mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 11:49:32 +00:00
![Vaibhav Jain](/assets/img/avatar_default.png)
'seq_buf' provides a very useful abstraction for writing to a string buffer without needing to worry about it over-flowing. However even though the API has been stable for couple of years now its still not exported to kernel loadable modules limiting its usage. Hence this patch proposes update to 'seq_buf.c' to mark seq_buf_printf() which is part of the seq_buf API to be exported to kernel loadable GPL modules. This symbol will be used in later parts of this patch-set to simplify content creation for a sysfs attribute. Signed-off-by: Vaibhav Jain <vaibhav@linux.ibm.com> Acked-by: Steven Rostedt (VMware) <rostedt@goodmis.org> Cc: Piotr Maziarz <piotrx.maziarz@linux.intel.com> Cc: Cezary Rojewski <cezary.rojewski@intel.com> Cc: Christoph Hellwig <hch@infradead.org> Cc: Steven Rostedt <rostedt@goodmis.org> Cc: Borislav Petkov <bp@alien8.de> Link: https://lore.kernel.org/r/20200615124407.32596-3-vaibhav@linux.ibm.com Signed-off-by: Dan Williams <dan.j.williams@intel.com>
393 lines
9.9 KiB
C
393 lines
9.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* seq_buf.c
|
|
*
|
|
* Copyright (C) 2014 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
|
|
*
|
|
* The seq_buf is a handy tool that allows you to pass a descriptor around
|
|
* to a buffer that other functions can write to. It is similar to the
|
|
* seq_file functionality but has some differences.
|
|
*
|
|
* To use it, the seq_buf must be initialized with seq_buf_init().
|
|
* This will set up the counters within the descriptor. You can call
|
|
* seq_buf_init() more than once to reset the seq_buf to start
|
|
* from scratch.
|
|
*/
|
|
#include <linux/uaccess.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/seq_buf.h>
|
|
|
|
/**
|
|
* seq_buf_can_fit - can the new data fit in the current buffer?
|
|
* @s: the seq_buf descriptor
|
|
* @len: The length to see if it can fit in the current buffer
|
|
*
|
|
* Returns true if there's enough unused space in the seq_buf buffer
|
|
* to fit the amount of new data according to @len.
|
|
*/
|
|
static bool seq_buf_can_fit(struct seq_buf *s, size_t len)
|
|
{
|
|
return s->len + len <= s->size;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_print_seq - move the contents of seq_buf into a seq_file
|
|
* @m: the seq_file descriptor that is the destination
|
|
* @s: the seq_buf descriptor that is the source.
|
|
*
|
|
* Returns zero on success, non zero otherwise
|
|
*/
|
|
int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s)
|
|
{
|
|
unsigned int len = seq_buf_used(s);
|
|
|
|
return seq_write(m, s->buffer, len);
|
|
}
|
|
|
|
/**
|
|
* seq_buf_vprintf - sequence printing of information.
|
|
* @s: seq_buf descriptor
|
|
* @fmt: printf format string
|
|
* @args: va_list of arguments from a printf() type function
|
|
*
|
|
* Writes a vnprintf() format into the sequencce buffer.
|
|
*
|
|
* Returns zero on success, -1 on overflow.
|
|
*/
|
|
int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args)
|
|
{
|
|
int len;
|
|
|
|
WARN_ON(s->size == 0);
|
|
|
|
if (s->len < s->size) {
|
|
len = vsnprintf(s->buffer + s->len, s->size - s->len, fmt, args);
|
|
if (s->len + len < s->size) {
|
|
s->len += len;
|
|
return 0;
|
|
}
|
|
}
|
|
seq_buf_set_overflow(s);
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_printf - sequence printing of information
|
|
* @s: seq_buf descriptor
|
|
* @fmt: printf format string
|
|
*
|
|
* Writes a printf() format into the sequence buffer.
|
|
*
|
|
* Returns zero on success, -1 on overflow.
|
|
*/
|
|
int seq_buf_printf(struct seq_buf *s, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
|
|
va_start(ap, fmt);
|
|
ret = seq_buf_vprintf(s, fmt, ap);
|
|
va_end(ap);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(seq_buf_printf);
|
|
|
|
#ifdef CONFIG_BINARY_PRINTF
|
|
/**
|
|
* seq_buf_bprintf - Write the printf string from binary arguments
|
|
* @s: seq_buf descriptor
|
|
* @fmt: The format string for the @binary arguments
|
|
* @binary: The binary arguments for @fmt.
|
|
*
|
|
* When recording in a fast path, a printf may be recorded with just
|
|
* saving the format and the arguments as they were passed to the
|
|
* function, instead of wasting cycles converting the arguments into
|
|
* ASCII characters. Instead, the arguments are saved in a 32 bit
|
|
* word array that is defined by the format string constraints.
|
|
*
|
|
* This function will take the format and the binary array and finish
|
|
* the conversion into the ASCII string within the buffer.
|
|
*
|
|
* Returns zero on success, -1 on overflow.
|
|
*/
|
|
int seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary)
|
|
{
|
|
unsigned int len = seq_buf_buffer_left(s);
|
|
int ret;
|
|
|
|
WARN_ON(s->size == 0);
|
|
|
|
if (s->len < s->size) {
|
|
ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
|
|
if (s->len + ret < s->size) {
|
|
s->len += ret;
|
|
return 0;
|
|
}
|
|
}
|
|
seq_buf_set_overflow(s);
|
|
return -1;
|
|
}
|
|
#endif /* CONFIG_BINARY_PRINTF */
|
|
|
|
/**
|
|
* seq_buf_puts - sequence printing of simple string
|
|
* @s: seq_buf descriptor
|
|
* @str: simple string to record
|
|
*
|
|
* Copy a simple string into the sequence buffer.
|
|
*
|
|
* Returns zero on success, -1 on overflow
|
|
*/
|
|
int seq_buf_puts(struct seq_buf *s, const char *str)
|
|
{
|
|
size_t len = strlen(str);
|
|
|
|
WARN_ON(s->size == 0);
|
|
|
|
/* Add 1 to len for the trailing null byte which must be there */
|
|
len += 1;
|
|
|
|
if (seq_buf_can_fit(s, len)) {
|
|
memcpy(s->buffer + s->len, str, len);
|
|
/* Don't count the trailing null byte against the capacity */
|
|
s->len += len - 1;
|
|
return 0;
|
|
}
|
|
seq_buf_set_overflow(s);
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_putc - sequence printing of simple character
|
|
* @s: seq_buf descriptor
|
|
* @c: simple character to record
|
|
*
|
|
* Copy a single character into the sequence buffer.
|
|
*
|
|
* Returns zero on success, -1 on overflow
|
|
*/
|
|
int seq_buf_putc(struct seq_buf *s, unsigned char c)
|
|
{
|
|
WARN_ON(s->size == 0);
|
|
|
|
if (seq_buf_can_fit(s, 1)) {
|
|
s->buffer[s->len++] = c;
|
|
return 0;
|
|
}
|
|
seq_buf_set_overflow(s);
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_putmem - write raw data into the sequenc buffer
|
|
* @s: seq_buf descriptor
|
|
* @mem: The raw memory to copy into the buffer
|
|
* @len: The length of the raw memory to copy (in bytes)
|
|
*
|
|
* There may be cases where raw memory needs to be written into the
|
|
* buffer and a strcpy() would not work. Using this function allows
|
|
* for such cases.
|
|
*
|
|
* Returns zero on success, -1 on overflow
|
|
*/
|
|
int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len)
|
|
{
|
|
WARN_ON(s->size == 0);
|
|
|
|
if (seq_buf_can_fit(s, len)) {
|
|
memcpy(s->buffer + s->len, mem, len);
|
|
s->len += len;
|
|
return 0;
|
|
}
|
|
seq_buf_set_overflow(s);
|
|
return -1;
|
|
}
|
|
|
|
#define MAX_MEMHEX_BYTES 8U
|
|
#define HEX_CHARS (MAX_MEMHEX_BYTES*2 + 1)
|
|
|
|
/**
|
|
* seq_buf_putmem_hex - write raw memory into the buffer in ASCII hex
|
|
* @s: seq_buf descriptor
|
|
* @mem: The raw memory to write its hex ASCII representation of
|
|
* @len: The length of the raw memory to copy (in bytes)
|
|
*
|
|
* This is similar to seq_buf_putmem() except instead of just copying the
|
|
* raw memory into the buffer it writes its ASCII representation of it
|
|
* in hex characters.
|
|
*
|
|
* Returns zero on success, -1 on overflow
|
|
*/
|
|
int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
|
|
unsigned int len)
|
|
{
|
|
unsigned char hex[HEX_CHARS];
|
|
const unsigned char *data = mem;
|
|
unsigned int start_len;
|
|
int i, j;
|
|
|
|
WARN_ON(s->size == 0);
|
|
|
|
while (len) {
|
|
start_len = min(len, HEX_CHARS - 1);
|
|
#ifdef __BIG_ENDIAN
|
|
for (i = 0, j = 0; i < start_len; i++) {
|
|
#else
|
|
for (i = start_len-1, j = 0; i >= 0; i--) {
|
|
#endif
|
|
hex[j++] = hex_asc_hi(data[i]);
|
|
hex[j++] = hex_asc_lo(data[i]);
|
|
}
|
|
if (WARN_ON_ONCE(j == 0 || j/2 > len))
|
|
break;
|
|
|
|
/* j increments twice per loop */
|
|
len -= j / 2;
|
|
hex[j++] = ' ';
|
|
|
|
seq_buf_putmem(s, hex, j);
|
|
if (seq_buf_has_overflowed(s))
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_path - copy a path into the sequence buffer
|
|
* @s: seq_buf descriptor
|
|
* @path: path to write into the sequence buffer.
|
|
* @esc: set of characters to escape in the output
|
|
*
|
|
* Write a path name into the sequence buffer.
|
|
*
|
|
* Returns the number of written bytes on success, -1 on overflow
|
|
*/
|
|
int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc)
|
|
{
|
|
char *buf;
|
|
size_t size = seq_buf_get_buf(s, &buf);
|
|
int res = -1;
|
|
|
|
WARN_ON(s->size == 0);
|
|
|
|
if (size) {
|
|
char *p = d_path(path, buf, size);
|
|
if (!IS_ERR(p)) {
|
|
char *end = mangle_path(buf, p, esc);
|
|
if (end)
|
|
res = end - buf;
|
|
}
|
|
}
|
|
seq_buf_commit(s, res);
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_to_user - copy the squence buffer to user space
|
|
* @s: seq_buf descriptor
|
|
* @ubuf: The userspace memory location to copy to
|
|
* @cnt: The amount to copy
|
|
*
|
|
* Copies the sequence buffer into the userspace memory pointed to
|
|
* by @ubuf. It starts from the last read position (@s->readpos)
|
|
* and writes up to @cnt characters or till it reaches the end of
|
|
* the content in the buffer (@s->len), which ever comes first.
|
|
*
|
|
* On success, it returns a positive number of the number of bytes
|
|
* it copied.
|
|
*
|
|
* On failure it returns -EBUSY if all of the content in the
|
|
* sequence has been already read, which includes nothing in the
|
|
* sequence (@s->len == @s->readpos).
|
|
*
|
|
* Returns -EFAULT if the copy to userspace fails.
|
|
*/
|
|
int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, int cnt)
|
|
{
|
|
int len;
|
|
int ret;
|
|
|
|
if (!cnt)
|
|
return 0;
|
|
|
|
len = seq_buf_used(s);
|
|
|
|
if (len <= s->readpos)
|
|
return -EBUSY;
|
|
|
|
len -= s->readpos;
|
|
if (cnt > len)
|
|
cnt = len;
|
|
ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
|
|
if (ret == cnt)
|
|
return -EFAULT;
|
|
|
|
cnt -= ret;
|
|
|
|
s->readpos += cnt;
|
|
return cnt;
|
|
}
|
|
|
|
/**
|
|
* seq_buf_hex_dump - print formatted hex dump into the sequence buffer
|
|
* @s: seq_buf descriptor
|
|
* @prefix_str: string to prefix each line with;
|
|
* caller supplies trailing spaces for alignment if desired
|
|
* @prefix_type: controls whether prefix of an offset, address, or none
|
|
* is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
|
|
* @rowsize: number of bytes to print per line; must be 16 or 32
|
|
* @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
|
|
* @buf: data blob to dump
|
|
* @len: number of bytes in the @buf
|
|
* @ascii: include ASCII after the hex output
|
|
*
|
|
* Function is an analogue of print_hex_dump() and thus has similar interface.
|
|
*
|
|
* linebuf size is maximal length for one line.
|
|
* 32 * 3 - maximum bytes per line, each printed into 2 chars + 1 for
|
|
* separating space
|
|
* 2 - spaces separating hex dump and ascii representation
|
|
* 32 - ascii representation
|
|
* 1 - terminating '\0'
|
|
*
|
|
* Returns zero on success, -1 on overflow
|
|
*/
|
|
int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str, int prefix_type,
|
|
int rowsize, int groupsize,
|
|
const void *buf, size_t len, bool ascii)
|
|
{
|
|
const u8 *ptr = buf;
|
|
int i, linelen, remaining = len;
|
|
unsigned char linebuf[32 * 3 + 2 + 32 + 1];
|
|
int ret;
|
|
|
|
if (rowsize != 16 && rowsize != 32)
|
|
rowsize = 16;
|
|
|
|
for (i = 0; i < len; i += rowsize) {
|
|
linelen = min(remaining, rowsize);
|
|
remaining -= rowsize;
|
|
|
|
hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
|
|
linebuf, sizeof(linebuf), ascii);
|
|
|
|
switch (prefix_type) {
|
|
case DUMP_PREFIX_ADDRESS:
|
|
ret = seq_buf_printf(s, "%s%p: %s\n",
|
|
prefix_str, ptr + i, linebuf);
|
|
break;
|
|
case DUMP_PREFIX_OFFSET:
|
|
ret = seq_buf_printf(s, "%s%.8x: %s\n",
|
|
prefix_str, i, linebuf);
|
|
break;
|
|
default:
|
|
ret = seq_buf_printf(s, "%s%s\n", prefix_str, linebuf);
|
|
break;
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|