* [PATCH 01/32] lib/printbuf: New data structure for printing strings
2022-08-14 21:19 Printbufs v6 Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 02/32] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
` (19 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Matthew Wilcox
From: Kent Overstreet <kent.overstreet@gmail.com>
This adds printbufs: a printbuf points to a char * buffer and knows the
size of the output buffer as well as the current output position.
Future patches will be adding more features to printbuf, but initially
printbufs are targeted at refactoring and improving our existing code in
lib/vsprintf.c - so this initial printbuf patch has the features
required for that.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Reviewed-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
include/linux/printbuf.h | 122 +++++++++++++++++++++++++++++++++++++++
1 file changed, 122 insertions(+)
create mode 100644 include/linux/printbuf.h
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
new file mode 100644
index 0000000000..1aa3331bf0
--- /dev/null
+++ b/include/linux/printbuf.h
@@ -0,0 +1,122 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/* Copyright (C) 2022 Kent Overstreet */
+
+#ifndef _LINUX_PRINTBUF_H
+#define _LINUX_PRINTBUF_H
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+
+/*
+ * Printbufs: String buffer for outputting (printing) to, for vsnprintf
+ */
+
+struct printbuf {
+ char *buf;
+ unsigned size;
+ unsigned pos;
+};
+
+/*
+ * Returns size remaining of output buffer:
+ */
+static inline unsigned printbuf_remaining_size(struct printbuf *out)
+{
+ return out->pos < out->size ? out->size - out->pos : 0;
+}
+
+/*
+ * Returns number of characters we can print to the output buffer - i.e.
+ * excluding the terminating nul:
+ */
+static inline unsigned printbuf_remaining(struct printbuf *out)
+{
+ return out->pos < out->size ? out->size - out->pos - 1 : 0;
+}
+
+static inline unsigned printbuf_written(struct printbuf *out)
+{
+ return out->size ? min(out->pos, out->size - 1) : 0;
+}
+
+/*
+ * Returns true if output was truncated:
+ */
+static inline bool printbuf_overflowed(struct printbuf *out)
+{
+ return out->pos >= out->size;
+}
+
+static inline void printbuf_nul_terminate(struct printbuf *out)
+{
+ if (out->pos < out->size)
+ out->buf[out->pos] = 0;
+ else if (out->size)
+ out->buf[out->size - 1] = 0;
+}
+
+static inline void __prt_char(struct printbuf *out, char c)
+{
+ if (printbuf_remaining(out))
+ out->buf[out->pos] = c;
+ out->pos++;
+}
+
+static inline void prt_char(struct printbuf *out, char c)
+{
+ __prt_char(out, c);
+ printbuf_nul_terminate(out);
+}
+
+static inline void __prt_chars(struct printbuf *out, char c, unsigned n)
+{
+ unsigned i, can_print = min(n, printbuf_remaining(out));
+
+ for (i = 0; i < can_print; i++)
+ out->buf[out->pos++] = c;
+ out->pos += n - can_print;
+}
+
+static inline void prt_chars(struct printbuf *out, char c, unsigned n)
+{
+ __prt_chars(out, c, n);
+ printbuf_nul_terminate(out);
+}
+
+static inline void prt_bytes(struct printbuf *out, const void *b, unsigned n)
+{
+ unsigned i, can_print = min(n, printbuf_remaining(out));
+
+ for (i = 0; i < can_print; i++)
+ out->buf[out->pos++] = ((char *) b)[i];
+ out->pos += n - can_print;
+
+ printbuf_nul_terminate(out);
+}
+
+static inline void prt_str(struct printbuf *out, const char *str)
+{
+ prt_bytes(out, str, strlen(str));
+}
+
+static inline void prt_hex_byte(struct printbuf *out, u8 byte)
+{
+ __prt_char(out, hex_asc_hi(byte));
+ __prt_char(out, hex_asc_lo(byte));
+ printbuf_nul_terminate(out);
+}
+
+static inline void prt_hex_byte_upper(struct printbuf *out, u8 byte)
+{
+ __prt_char(out, hex_asc_upper_hi(byte));
+ __prt_char(out, hex_asc_upper_lo(byte));
+ printbuf_nul_terminate(out);
+}
+
+#define PRINTBUF_EXTERN(_buf, _size) \
+((struct printbuf) { \
+ .buf = _buf, \
+ .size = _size, \
+})
+
+#endif /* _LINUX_PRINTBUF_H */
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 02/32] lib/string_helpers: Convert string_escape_mem() to printbuf
2022-08-14 21:19 Printbufs v6 Kent Overstreet
2022-08-14 21:19 ` [PATCH 01/32] lib/printbuf: New data structure for printing strings Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 03/32] vsprintf: Convert " Kent Overstreet
` (18 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Andy Shevchenko
From: Kent Overstreet <kent.overstreet@gmail.com>
Like the upcoming vsprintf.c conversion, this converts string_escape_mem
to prt_escaped_string(), which uses and outputs to a printbuf, and makes
string_escape_mem() a smaller wrapper to support existing users.
The new printbuf helpers greatly simplify the code.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Andy Shevchenko <andy@kernel.org>
---
include/linux/string_helpers.h | 3 +
lib/string_helpers.c | 217 ++++++++++++++++++---------------
2 files changed, 125 insertions(+), 95 deletions(-)
diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h
index 4d72258d42..c048eaec08 100644
--- a/include/linux/string_helpers.h
+++ b/include/linux/string_helpers.h
@@ -9,6 +9,7 @@
struct device;
struct file;
+struct printbuf;
struct task_struct;
/* Descriptions of the types of units to
@@ -62,6 +63,8 @@ static inline int string_unescape_any_inplace(char *buf)
#define ESCAPE_ALL_MASK GENMASK(8, 0)
+void prt_escaped_string(struct printbuf *out, const char *src, size_t isz,
+ unsigned int flags, const char *only);
int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
unsigned int flags, const char *only);
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 5ed3beb066..b366c660e6 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -15,6 +15,7 @@
#include <linux/fs.h>
#include <linux/limits.h>
#include <linux/mm.h>
+#include <linux/printbuf.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/string_helpers.h>
@@ -301,19 +302,14 @@ int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
}
EXPORT_SYMBOL(string_unescape);
-static bool escape_passthrough(unsigned char c, char **dst, char *end)
+static bool escape_passthrough(struct printbuf *out, unsigned char c)
{
- char *out = *dst;
-
- if (out < end)
- *out = c;
- *dst = out + 1;
+ prt_char(out, c);
return true;
}
-static bool escape_space(unsigned char c, char **dst, char *end)
+static bool escape_space(struct printbuf *out, unsigned char c)
{
- char *out = *dst;
unsigned char to;
switch (c) {
@@ -336,20 +332,13 @@ static bool escape_space(unsigned char c, char **dst, char *end)
return false;
}
- if (out < end)
- *out = '\\';
- ++out;
- if (out < end)
- *out = to;
- ++out;
-
- *dst = out;
+ prt_char(out, '\\');
+ prt_char(out, to);
return true;
}
-static bool escape_special(unsigned char c, char **dst, char *end)
+static bool escape_special(struct printbuf *out, unsigned char c)
{
- char *out = *dst;
unsigned char to;
switch (c) {
@@ -369,83 +358,43 @@ static bool escape_special(unsigned char c, char **dst, char *end)
return false;
}
- if (out < end)
- *out = '\\';
- ++out;
- if (out < end)
- *out = to;
- ++out;
-
- *dst = out;
+ prt_char(out, '\\');
+ prt_char(out, to);
return true;
}
-static bool escape_null(unsigned char c, char **dst, char *end)
+static bool escape_null(struct printbuf *out, unsigned char c)
{
- char *out = *dst;
-
if (c)
return false;
- if (out < end)
- *out = '\\';
- ++out;
- if (out < end)
- *out = '0';
- ++out;
-
- *dst = out;
+ prt_char(out, '\\');
+ prt_char(out, '0');
return true;
}
-static bool escape_octal(unsigned char c, char **dst, char *end)
+static bool escape_octal(struct printbuf *out, unsigned char c)
{
- char *out = *dst;
-
- if (out < end)
- *out = '\\';
- ++out;
- if (out < end)
- *out = ((c >> 6) & 0x07) + '0';
- ++out;
- if (out < end)
- *out = ((c >> 3) & 0x07) + '0';
- ++out;
- if (out < end)
- *out = ((c >> 0) & 0x07) + '0';
- ++out;
-
- *dst = out;
+ prt_char(out, '\\');
+ prt_char(out, ((c >> 6) & 0x07) + '0');
+ prt_char(out, ((c >> 3) & 0x07) + '0');
+ prt_char(out, ((c >> 0) & 0x07) + '0');
return true;
}
-static bool escape_hex(unsigned char c, char **dst, char *end)
+static bool escape_hex(struct printbuf *out, unsigned char c)
{
- char *out = *dst;
-
- if (out < end)
- *out = '\\';
- ++out;
- if (out < end)
- *out = 'x';
- ++out;
- if (out < end)
- *out = hex_asc_hi(c);
- ++out;
- if (out < end)
- *out = hex_asc_lo(c);
- ++out;
-
- *dst = out;
+ prt_char(out, '\\');
+ prt_char(out, 'x');
+ prt_hex_byte(out, c);
return true;
}
/**
- * string_escape_mem - quote characters in the given memory buffer
+ * prt_escaped_string - quote characters in the given memory buffer
+ * @out: printbuf to output to (escaped)
* @src: source buffer (unescaped)
* @isz: source buffer size
- * @dst: destination buffer (escaped)
- * @osz: destination buffer size
* @flags: combination of the flags
* @only: NULL-terminated string containing characters used to limit
* the selected escape class. If characters are included in @only
@@ -510,18 +459,11 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
* or %ESCAPE_HEX, because they cover most of the other character classes.
* %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to
* the above.
- *
- * Return:
- * The total size of the escaped output that would be generated for
- * the given input and flags. To check whether the output was
- * truncated, compare the return value to osz. There is room left in
- * dst for a '\0' terminator if and only if ret < osz.
*/
-int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
- unsigned int flags, const char *only)
+void prt_escaped_string(struct printbuf *out,
+ const char *src, size_t isz,
+ unsigned int flags, const char *only)
{
- char *p = dst;
- char *end = p + osz;
bool is_dict = only && *only;
bool is_append = flags & ESCAPE_APPEND;
@@ -549,41 +491,126 @@ int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
* %ESCAPE_NA cases.
*/
if (!(is_append || in_dict) && is_dict &&
- escape_passthrough(c, &p, end))
+ escape_passthrough(out, c))
continue;
if (!(is_append && in_dict) && isascii(c) && isprint(c) &&
- flags & ESCAPE_NAP && escape_passthrough(c, &p, end))
+ flags & ESCAPE_NAP && escape_passthrough(out, c))
continue;
if (!(is_append && in_dict) && isprint(c) &&
- flags & ESCAPE_NP && escape_passthrough(c, &p, end))
+ flags & ESCAPE_NP && escape_passthrough(out, c))
continue;
if (!(is_append && in_dict) && isascii(c) &&
- flags & ESCAPE_NA && escape_passthrough(c, &p, end))
+ flags & ESCAPE_NA && escape_passthrough(out, c))
continue;
- if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
+ if (flags & ESCAPE_SPACE && escape_space(out, c))
continue;
- if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
+ if (flags & ESCAPE_SPECIAL && escape_special(out, c))
continue;
- if (flags & ESCAPE_NULL && escape_null(c, &p, end))
+ if (flags & ESCAPE_NULL && escape_null(out, c))
continue;
/* ESCAPE_OCTAL and ESCAPE_HEX always go last */
- if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
+ if (flags & ESCAPE_OCTAL && escape_octal(out, c))
continue;
- if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
+ if (flags & ESCAPE_HEX && escape_hex(out, c))
continue;
- escape_passthrough(c, &p, end);
+ escape_passthrough(out, c);
}
+}
+EXPORT_SYMBOL(prt_escaped_string);
+
+/**
+ * string_escape_mem - quote characters in the given memory buffer
+ * @src: source buffer (unescaped)
+ * @isz: source buffer size
+ * @dst: destination buffer (escaped)
+ * @osz: destination buffer size
+ * @flags: combination of the flags
+ * @only: NULL-terminated string containing characters used to limit
+ * the selected escape class. If characters are included in @only
+ * that would not normally be escaped by the classes selected
+ * in @flags, they will be copied to @dst unescaped.
+ *
+ * Description:
+ * The process of escaping byte buffer includes several parts. They are applied
+ * in the following sequence.
+ *
+ * 1. The character is not matched to the one from @only string and thus
+ * must go as-is to the output.
+ * 2. The character is matched to the printable and ASCII classes, if asked,
+ * and in case of match it passes through to the output.
+ * 3. The character is matched to the printable or ASCII class, if asked,
+ * and in case of match it passes through to the output.
+ * 4. The character is checked if it falls into the class given by @flags.
+ * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
+ * character. Note that they actually can't go together, otherwise
+ * %ESCAPE_HEX will be ignored.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will not be NULL-terminated, thus caller have to append
+ * it if needs. The supported flags are::
+ *
+ * %ESCAPE_SPACE: (special white space, not space itself)
+ * '\f' - form feed
+ * '\n' - new line
+ * '\r' - carriage return
+ * '\t' - horizontal tab
+ * '\v' - vertical tab
+ * %ESCAPE_SPECIAL:
+ * '\"' - double quote
+ * '\\' - backslash
+ * '\a' - alert (BEL)
+ * '\e' - escape
+ * %ESCAPE_NULL:
+ * '\0' - null
+ * %ESCAPE_OCTAL:
+ * '\NNN' - byte with octal value NNN (3 digits)
+ * %ESCAPE_ANY:
+ * all previous together
+ * %ESCAPE_NP:
+ * escape only non-printable characters, checked by isprint()
+ * %ESCAPE_ANY_NP:
+ * all previous together
+ * %ESCAPE_HEX:
+ * '\xHH' - byte with hexadecimal value HH (2 digits)
+ * %ESCAPE_NA:
+ * escape only non-ascii characters, checked by isascii()
+ * %ESCAPE_NAP:
+ * escape only non-printable or non-ascii characters
+ * %ESCAPE_APPEND:
+ * append characters from @only to be escaped by the given classes
+ *
+ * %ESCAPE_APPEND would help to pass additional characters to the escaped, when
+ * one of %ESCAPE_NP, %ESCAPE_NA, or %ESCAPE_NAP is provided.
+ *
+ * One notable caveat, the %ESCAPE_NAP, %ESCAPE_NP and %ESCAPE_NA have the
+ * higher priority than the rest of the flags (%ESCAPE_NAP is the highest).
+ * It doesn't make much sense to use either of them without %ESCAPE_OCTAL
+ * or %ESCAPE_HEX, because they cover most of the other character classes.
+ * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to
+ * the above.
+ *
+ * Return:
+ * The total size of the escaped output that would be generated for
+ * the given input and flags. To check whether the output was
+ * truncated, compare the return value to osz. There is room left in
+ * dst for a '\0' terminator if and only if ret < osz.
+ */
+int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
+ unsigned int flags, const char *only)
+{
+ struct printbuf out = PRINTBUF_EXTERN(dst, osz);
- return p - dst;
+ prt_escaped_string(&out, src, isz, flags, only);
+ return out.pos;
}
EXPORT_SYMBOL(string_escape_mem);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 03/32] vsprintf: Convert to printbuf
2022-08-14 21:19 Printbufs v6 Kent Overstreet
2022-08-14 21:19 ` [PATCH 01/32] lib/printbuf: New data structure for printing strings Kent Overstreet
2022-08-14 21:19 ` [PATCH 02/32] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 04/32] lib/hexdump: " Kent Overstreet
` (17 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm
Cc: linux-kernel, Kent Overstreet, Petr Mladek, Steven Rostedt,
Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
This converts vsnprintf() to printbufs: instead of passing around raw
char * pointers for current buf position and end of buf, we have a real
type!
This makes the calling convention for our existing pretty printers a lot
saner and less error prone, plus printbufs add some new helpers that
make the code smaller and more readable, with a lot less crazy pointer
arithmetic.
There are a lot more refactorings to be done: this patch tries to stick
to just converting the calling conventions, as that needs to be done all
at once in order to avoid introducing a ton of wrappers that will just
be deleted.
Thankfully we have good unit tests for printf, and they have been run
and are all passing with this patch.
We have two new exported functions with this patch:
- prt_printf(), which is like snprintf but outputs to a printbuf
- prt_vprintf, like vsnprintf
These are the actual core print routines now - vsnprintf() is a wrapper
around prt_vprintf().
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
include/linux/kernel.h | 4 +
include/linux/string.h | 5 +
lib/vsprintf.c | 1367 +++++++++++++++++++---------------------
3 files changed, 643 insertions(+), 733 deletions(-)
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index fe6efb24d1..5c4f4b6d36 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -207,6 +207,10 @@ extern int num_to_str(char *buf, int size,
/* lib/printf utilities */
+struct printbuf;
+extern __printf(2, 3) void prt_printf(struct printbuf *out, const char *fmt, ...);
+extern __printf(2, 0) void prt_vprintf(struct printbuf *out, const char *fmt, va_list);
+
extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
extern __printf(2, 0) int vsprintf(char *buf, const char *, va_list);
extern __printf(3, 4)
diff --git a/include/linux/string.h b/include/linux/string.h
index 61ec7e4f63..22a45d553f 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -195,7 +195,12 @@ int __sysfs_match_string(const char * const *array, size_t n, const char *s);
*/
#define sysfs_match_string(_a, _s) __sysfs_match_string(_a, ARRAY_SIZE(_a), _s)
+struct printbuf;
+
#ifdef CONFIG_BINARY_PRINTF
+void prt_vbinprintf(struct printbuf *out, const char *fmt, va_list args);
+void prt_bstrprintf(struct printbuf *out, const char *fmt, const u32 *bin_buf);
+void prt_bprintf(struct printbuf *out, const char *fmt, ...) __printf(2, 3);
int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 3c1853a9d1..52dac8519a 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -44,6 +44,7 @@
#ifdef CONFIG_BLOCK
#include <linux/blkdev.h>
#endif
+#include <linux/printbuf.h>
#include "../mm/internal.h" /* For the trace_print_flags arrays */
@@ -451,8 +452,8 @@ static_assert(sizeof(struct printf_spec) == 8);
#define PRECISION_MAX ((1 << 15) - 1)
static noinline_for_stack
-char *number(char *buf, char *end, unsigned long long num,
- struct printf_spec spec)
+void number(struct printbuf *out, unsigned long long num,
+ struct printf_spec spec)
{
/* put_dec requires 2-byte alignment of the buffer. */
char tmp[3 * sizeof(num)] __aligned(2);
@@ -512,67 +513,43 @@ char *number(char *buf, char *end, unsigned long long num,
if (i > precision)
precision = i;
/* leading space padding */
- field_width -= precision;
- if (!(spec.flags & (ZEROPAD | LEFT))) {
- while (--field_width >= 0) {
- if (buf < end)
- *buf = ' ';
- ++buf;
- }
+ field_width = max(0, field_width - precision);
+ if (!(spec.flags & (ZEROPAD | LEFT)) && field_width) {
+ __prt_chars(out, ' ', field_width);
+ field_width = 0;
}
/* sign */
- if (sign) {
- if (buf < end)
- *buf = sign;
- ++buf;
- }
+ if (sign)
+ __prt_char(out, sign);
/* "0x" / "0" prefix */
if (need_pfx) {
- if (spec.base == 16 || !is_zero) {
- if (buf < end)
- *buf = '0';
- ++buf;
- }
- if (spec.base == 16) {
- if (buf < end)
- *buf = ('X' | locase);
- ++buf;
- }
+ if (spec.base == 16 || !is_zero)
+ __prt_char(out, '0');
+ if (spec.base == 16)
+ __prt_char(out, 'X' | locase);
}
/* zero or space padding */
- if (!(spec.flags & LEFT)) {
+ if (!(spec.flags & LEFT) && field_width) {
char c = ' ' + (spec.flags & ZEROPAD);
- while (--field_width >= 0) {
- if (buf < end)
- *buf = c;
- ++buf;
- }
+ __prt_chars(out, c, field_width);
+ field_width = 0;
}
/* hmm even more zero padding? */
- while (i <= --precision) {
- if (buf < end)
- *buf = '0';
- ++buf;
- }
+ if (precision > i)
+ __prt_chars(out, '0', precision - i);
/* actual digits of result */
- while (--i >= 0) {
- if (buf < end)
- *buf = tmp[i];
- ++buf;
- }
+ while (--i >= 0)
+ __prt_char(out, tmp[i]);
/* trailing space padding */
- while (--field_width >= 0) {
- if (buf < end)
- *buf = ' ';
- ++buf;
- }
+ if (field_width)
+ __prt_chars(out, ' ', field_width);
- return buf;
+ printbuf_nul_terminate(out);
}
static noinline_for_stack
-char *special_hex_number(char *buf, char *end, unsigned long long num, int size)
+void special_hex_number(struct printbuf *out, unsigned long long num, int size)
{
struct printf_spec spec;
@@ -582,25 +559,28 @@ char *special_hex_number(char *buf, char *end, unsigned long long num, int size)
spec.base = 16;
spec.precision = -1;
- return number(buf, end, num, spec);
+ number(out, num, spec);
}
-static void move_right(char *buf, char *end, unsigned len, unsigned spaces)
+/*
+ * inserts @spaces spaces @len from the end of @out
+ */
+static void move_right(struct printbuf *out,
+ unsigned len, unsigned spaces)
{
- size_t size;
- if (buf >= end) /* nowhere to put anything */
- return;
- size = end - buf;
- if (size <= spaces) {
- memset(buf, ' ', size);
- return;
- }
- if (len) {
- if (len > size - spaces)
- len = size - spaces;
- memmove(buf + spaces, buf, len);
- }
- memset(buf, ' ', spaces);
+ unsigned move_src = out->pos - len;
+ unsigned move_dst = move_src + spaces;
+ unsigned remaining_from_dst = move_dst < out->size ? out->size - move_dst : 0;
+ unsigned remaining_from_src = move_src < out->size ? out->size - move_src : 0;
+
+ BUG_ON(len > out->pos);
+
+ memmove(out->buf + move_dst,
+ out->buf + move_src,
+ min(remaining_from_dst, len));
+ memset(out->buf + move_src, ' ',
+ min(remaining_from_src, spaces));
+ out->pos += spaces;
}
/*
@@ -612,67 +592,55 @@ static void move_right(char *buf, char *end, unsigned len, unsigned spaces)
* Returns: new buffer position after padding.
*/
static noinline_for_stack
-char *widen_string(char *buf, int n, char *end, struct printf_spec spec)
+void widen_string(struct printbuf *out, int n,
+ struct printf_spec spec)
{
unsigned spaces;
if (likely(n >= spec.field_width))
- return buf;
+ return;
/* we want to pad the sucker */
spaces = spec.field_width - n;
- if (!(spec.flags & LEFT)) {
- move_right(buf - n, end, n, spaces);
- return buf + spaces;
- }
- while (spaces--) {
- if (buf < end)
- *buf = ' ';
- ++buf;
- }
- return buf;
+ if (!(spec.flags & LEFT))
+ move_right(out, n, spaces);
+ else
+ prt_chars(out, ' ', spaces);
}
/* Handle string from a well known address. */
-static char *string_nocheck(char *buf, char *end, const char *s,
- struct printf_spec spec)
+static void string_nocheck(struct printbuf *out,
+ const char *s,
+ struct printf_spec spec)
{
- int len = 0;
- int lim = spec.precision;
+ int len = strnlen(s, spec.precision);
- while (lim--) {
- char c = *s++;
- if (!c)
- break;
- if (buf < end)
- *buf = c;
- ++buf;
- ++len;
- }
- return widen_string(buf, len, end, spec);
+ prt_bytes(out, s, len);
+ widen_string(out, len, spec);
}
-static char *err_ptr(char *buf, char *end, void *ptr,
- struct printf_spec spec)
+static void err_ptr(struct printbuf *out, void *ptr,
+ struct printf_spec spec)
{
int err = PTR_ERR(ptr);
const char *sym = errname(err);
- if (sym)
- return string_nocheck(buf, end, sym, spec);
-
- /*
- * Somebody passed ERR_PTR(-1234) or some other non-existing
- * Efoo - or perhaps CONFIG_SYMBOLIC_ERRNAME=n. Fall back to
- * printing it as its decimal representation.
- */
- spec.flags |= SIGN;
- spec.base = 10;
- return number(buf, end, err, spec);
+ if (sym) {
+ string_nocheck(out, sym, spec);
+ } else {
+ /*
+ * Somebody passed ERR_PTR(-1234) or some other non-existing
+ * Efoo - or perhaps CONFIG_SYMBOLIC_ERRNAME=n. Fall back to
+ * printing it as its decimal representation.
+ */
+ spec.flags |= SIGN;
+ spec.base = 10;
+ number(out, err, spec);
+ }
}
/* Be careful: error messages must fit into the given buffer. */
-static char *error_string(char *buf, char *end, const char *s,
- struct printf_spec spec)
+static void error_string(struct printbuf *out, const char *s,
+ struct printf_spec spec)
{
/*
* Hard limit to avoid a completely insane messages. It actually
@@ -682,7 +650,7 @@ static char *error_string(char *buf, char *end, const char *s,
if (spec.precision == -1)
spec.precision = 2 * sizeof(void *);
- return string_nocheck(buf, end, s, spec);
+ string_nocheck(out, s, spec);
}
/*
@@ -701,14 +669,15 @@ static const char *check_pointer_msg(const void *ptr)
return NULL;
}
-static int check_pointer(char **buf, char *end, const void *ptr,
+static int check_pointer(struct printbuf *out,
+ const void *ptr,
struct printf_spec spec)
{
const char *err_msg;
err_msg = check_pointer_msg(ptr);
if (err_msg) {
- *buf = error_string(*buf, end, err_msg, spec);
+ error_string(out, err_msg, spec);
return -EFAULT;
}
@@ -716,18 +685,19 @@ static int check_pointer(char **buf, char *end, const void *ptr,
}
static noinline_for_stack
-char *string(char *buf, char *end, const char *s,
- struct printf_spec spec)
+void string(struct printbuf *out,
+ const char *s,
+ struct printf_spec spec)
{
- if (check_pointer(&buf, end, s, spec))
- return buf;
+ if (check_pointer(out, s, spec))
+ return;
- return string_nocheck(buf, end, s, spec);
+ string_nocheck(out, s, spec);
}
-static char *pointer_string(char *buf, char *end,
- const void *ptr,
- struct printf_spec spec)
+static void pointer_string(struct printbuf *out,
+ const void *ptr,
+ struct printf_spec spec)
{
spec.base = 16;
spec.flags |= SMALL;
@@ -736,7 +706,7 @@ static char *pointer_string(char *buf, char *end,
spec.flags |= ZEROPAD;
}
- return number(buf, end, (unsigned long int)ptr, spec);
+ number(out, (unsigned long int)ptr, spec);
}
/* Make pointers available for printing early in the boot sequence. */
@@ -801,8 +771,9 @@ int ptr_to_hashval(const void *ptr, unsigned long *hashval_out)
return __ptr_to_hashval(ptr, hashval_out);
}
-static char *ptr_to_id(char *buf, char *end, const void *ptr,
- struct printf_spec spec)
+static void ptr_to_id(struct printbuf *out,
+ const void *ptr,
+ struct printf_spec spec)
{
const char *str = sizeof(ptr) == 8 ? "(____ptrval____)" : "(ptrval)";
unsigned long hashval;
@@ -813,47 +784,49 @@ static char *ptr_to_id(char *buf, char *end, const void *ptr,
* as they are not actual addresses.
*/
if (IS_ERR_OR_NULL(ptr))
- return pointer_string(buf, end, ptr, spec);
+ return pointer_string(out, ptr, spec);
/* When debugging early boot use non-cryptographically secure hash. */
if (unlikely(debug_boot_weak_hash)) {
hashval = hash_long((unsigned long)ptr, 32);
- return pointer_string(buf, end, (const void *)hashval, spec);
+ return pointer_string(out, (const void *)hashval, spec);
}
ret = __ptr_to_hashval(ptr, &hashval);
if (ret) {
spec.field_width = 2 * sizeof(ptr);
/* string length must be less than default_width */
- return error_string(buf, end, str, spec);
+ return error_string(out, str, spec);
}
- return pointer_string(buf, end, (const void *)hashval, spec);
+ pointer_string(out, (const void *)hashval, spec);
}
-static char *default_pointer(char *buf, char *end, const void *ptr,
- struct printf_spec spec)
+static void default_pointer(struct printbuf *out,
+ const void *ptr,
+ struct printf_spec spec)
{
/*
* default is to _not_ leak addresses, so hash before printing,
* unless no_hash_pointers is specified on the command line.
*/
if (unlikely(no_hash_pointers))
- return pointer_string(buf, end, ptr, spec);
+ return pointer_string(out, ptr, spec);
- return ptr_to_id(buf, end, ptr, spec);
+ return ptr_to_id(out, ptr, spec);
}
int kptr_restrict __read_mostly;
static noinline_for_stack
-char *restricted_pointer(char *buf, char *end, const void *ptr,
- struct printf_spec spec)
+void restricted_pointer(struct printbuf *out,
+ const void *ptr,
+ struct printf_spec spec)
{
switch (kptr_restrict) {
case 0:
/* Handle as %p, hash and do _not_ leak addresses. */
- return default_pointer(buf, end, ptr, spec);
+ return default_pointer(out, ptr, spec);
case 1: {
const struct cred *cred;
@@ -864,7 +837,7 @@ char *restricted_pointer(char *buf, char *end, const void *ptr,
if (in_irq() || in_serving_softirq() || in_nmi()) {
if (spec.field_width == -1)
spec.field_width = 2 * sizeof(ptr);
- return error_string(buf, end, "pK-error", spec);
+ return error_string(out, "pK-error", spec);
}
/*
@@ -890,12 +863,13 @@ char *restricted_pointer(char *buf, char *end, const void *ptr,
break;
}
- return pointer_string(buf, end, ptr, spec);
+ return pointer_string(out, ptr, spec);
}
static noinline_for_stack
-char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,
- const char *fmt)
+void dentry_name(struct printbuf *out,
+ const struct dentry *d, struct printf_spec spec,
+ const char *fmt)
{
const char *array[4], *s;
const struct dentry *p;
@@ -912,9 +886,9 @@ char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_sp
rcu_read_lock();
for (i = 0; i < depth; i++, d = p) {
- if (check_pointer(&buf, end, d, spec)) {
+ if (check_pointer(out, d, spec)) {
rcu_read_unlock();
- return buf;
+ return;
}
p = READ_ONCE(d->d_parent);
@@ -927,7 +901,7 @@ char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_sp
}
}
s = array[--i];
- for (n = 0; n != spec.precision; n++, buf++) {
+ for (n = 0; n != spec.precision; n++) {
char c = *s++;
if (!c) {
if (!i)
@@ -935,49 +909,47 @@ char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_sp
c = '/';
s = array[--i];
}
- if (buf < end)
- *buf = c;
+ prt_char(out, c);
}
rcu_read_unlock();
- return widen_string(buf, n, end, spec);
+
+ widen_string(out, n, spec);
}
static noinline_for_stack
-char *file_dentry_name(char *buf, char *end, const struct file *f,
- struct printf_spec spec, const char *fmt)
+void file_dentry_name(struct printbuf *out,
+ const struct file *f,
+ struct printf_spec spec, const char *fmt)
{
- if (check_pointer(&buf, end, f, spec))
- return buf;
+ if (check_pointer(out, f, spec))
+ return;
- return dentry_name(buf, end, f->f_path.dentry, spec, fmt);
+ return dentry_name(out, f->f_path.dentry, spec, fmt);
}
#ifdef CONFIG_BLOCK
static noinline_for_stack
-char *bdev_name(char *buf, char *end, struct block_device *bdev,
- struct printf_spec spec, const char *fmt)
+void bdev_name(struct printbuf *out,
+ struct block_device *bdev,
+ struct printf_spec spec, const char *fmt)
{
struct gendisk *hd;
- if (check_pointer(&buf, end, bdev, spec))
- return buf;
+ if (check_pointer(out, bdev, spec))
+ return;
hd = bdev->bd_disk;
- buf = string(buf, end, hd->disk_name, spec);
+ string(out, hd->disk_name, spec);
if (bdev->bd_partno) {
- if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) {
- if (buf < end)
- *buf = 'p';
- buf++;
- }
- buf = number(buf, end, bdev->bd_partno, spec);
+ if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
+ prt_char(out, 'p');
+ number(out, bdev->bd_partno, spec);
}
- return buf;
}
#endif
static noinline_for_stack
-char *symbol_string(char *buf, char *end, void *ptr,
- struct printf_spec spec, const char *fmt)
+void symbol_string(struct printbuf *out, void *ptr,
+ struct printf_spec spec, const char *fmt)
{
unsigned long value;
#ifdef CONFIG_KALLSYMS
@@ -1000,9 +972,9 @@ char *symbol_string(char *buf, char *end, void *ptr,
else
sprint_symbol_no_offset(sym, value);
- return string_nocheck(buf, end, sym, spec);
+ string_nocheck(out, sym, spec);
#else
- return special_hex_number(buf, end, value, sizeof(void *));
+ special_hex_number(out, value, sizeof(void *));
#endif
}
@@ -1037,8 +1009,8 @@ static const struct printf_spec default_dec04_spec = {
};
static noinline_for_stack
-char *resource_string(char *buf, char *end, struct resource *res,
- struct printf_spec spec, const char *fmt)
+void resource_string(struct printbuf *out, struct resource *res,
+ struct printf_spec spec, const char *fmt)
{
#ifndef IO_RSRC_PRINTK_SIZE
#define IO_RSRC_PRINTK_SIZE 6
@@ -1077,69 +1049,67 @@ char *resource_string(char *buf, char *end, struct resource *res,
#define FLAG_BUF_SIZE (2 * sizeof(res->flags))
#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
- char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
+ char sym_buf[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
-
- char *p = sym, *pend = sym + sizeof(sym);
+ struct printbuf sym = PRINTBUF_EXTERN(sym_buf, sizeof(sym_buf));
int decode = (fmt[0] == 'R') ? 1 : 0;
const struct printf_spec *specp;
- if (check_pointer(&buf, end, res, spec))
- return buf;
+ if (check_pointer(out, res, spec))
+ return;
- *p++ = '[';
+ prt_char(&sym, '[');
if (res->flags & IORESOURCE_IO) {
- p = string_nocheck(p, pend, "io ", str_spec);
+ string_nocheck(&sym, "io ", str_spec);
specp = &io_spec;
} else if (res->flags & IORESOURCE_MEM) {
- p = string_nocheck(p, pend, "mem ", str_spec);
+ string_nocheck(&sym, "mem ", str_spec);
specp = &mem_spec;
} else if (res->flags & IORESOURCE_IRQ) {
- p = string_nocheck(p, pend, "irq ", str_spec);
+ string_nocheck(&sym, "irq ", str_spec);
specp = &default_dec_spec;
} else if (res->flags & IORESOURCE_DMA) {
- p = string_nocheck(p, pend, "dma ", str_spec);
+ string_nocheck(&sym, "dma ", str_spec);
specp = &default_dec_spec;
} else if (res->flags & IORESOURCE_BUS) {
- p = string_nocheck(p, pend, "bus ", str_spec);
+ string_nocheck(&sym, "bus ", str_spec);
specp = &bus_spec;
} else {
- p = string_nocheck(p, pend, "??? ", str_spec);
+ string_nocheck(&sym, "??? ", str_spec);
specp = &mem_spec;
decode = 0;
}
if (decode && res->flags & IORESOURCE_UNSET) {
- p = string_nocheck(p, pend, "size ", str_spec);
- p = number(p, pend, resource_size(res), *specp);
+ string_nocheck(&sym, "size ", str_spec);
+ number(&sym, resource_size(res), *specp);
} else {
- p = number(p, pend, res->start, *specp);
+ number(&sym, res->start, *specp);
if (res->start != res->end) {
- *p++ = '-';
- p = number(p, pend, res->end, *specp);
+ prt_char(&sym, '-');
+ number(&sym, res->end, *specp);
}
}
if (decode) {
if (res->flags & IORESOURCE_MEM_64)
- p = string_nocheck(p, pend, " 64bit", str_spec);
+ string_nocheck(&sym, " 64bit", str_spec);
if (res->flags & IORESOURCE_PREFETCH)
- p = string_nocheck(p, pend, " pref", str_spec);
+ string_nocheck(&sym, " pref", str_spec);
if (res->flags & IORESOURCE_WINDOW)
- p = string_nocheck(p, pend, " window", str_spec);
+ string_nocheck(&sym, " window", str_spec);
if (res->flags & IORESOURCE_DISABLED)
- p = string_nocheck(p, pend, " disabled", str_spec);
+ string_nocheck(&sym, " disabled", str_spec);
} else {
- p = string_nocheck(p, pend, " flags ", str_spec);
- p = number(p, pend, res->flags, default_flag_spec);
+ string_nocheck(&sym, " flags ", str_spec);
+ number(&sym, res->flags, default_flag_spec);
}
- *p++ = ']';
- *p = '\0';
+ prt_char(&sym, ']');
- return string_nocheck(buf, end, sym, spec);
+ string_nocheck(out, sym_buf, spec);
}
static noinline_for_stack
-char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
- const char *fmt)
+void hex_string(struct printbuf *out, u8 *addr,
+ struct printf_spec spec, const char *fmt)
{
int i, len = 1; /* if we pass '%ph[CDN]', field width remains
negative value, fallback to the default */
@@ -1147,10 +1117,10 @@ char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
if (spec.field_width == 0)
/* nothing to print */
- return buf;
+ return;
- if (check_pointer(&buf, end, addr, spec))
- return buf;
+ if (check_pointer(out, addr, spec))
+ return;
switch (fmt[1]) {
case 'C':
@@ -1171,34 +1141,27 @@ char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
len = min_t(int, spec.field_width, 64);
for (i = 0; i < len; ++i) {
- if (buf < end)
- *buf = hex_asc_hi(addr[i]);
- ++buf;
- if (buf < end)
- *buf = hex_asc_lo(addr[i]);
- ++buf;
-
- if (separator && i != len - 1) {
- if (buf < end)
- *buf = separator;
- ++buf;
- }
+ __prt_char(out, hex_asc_hi(addr[i]));
+ __prt_char(out, hex_asc_lo(addr[i]));
+
+ if (separator && i != len - 1)
+ __prt_char(out, separator);
}
- return buf;
+ printbuf_nul_terminate(out);
}
static noinline_for_stack
-char *bitmap_string(char *buf, char *end, unsigned long *bitmap,
- struct printf_spec spec, const char *fmt)
+void bitmap_string(struct printbuf *out, unsigned long *bitmap,
+ struct printf_spec spec, const char *fmt)
{
const int CHUNKSZ = 32;
int nr_bits = max_t(int, spec.field_width, 0);
int i, chunksz;
bool first = true;
- if (check_pointer(&buf, end, bitmap, spec))
- return buf;
+ if (check_pointer(out, bitmap, spec))
+ return;
/* reused to print numbers */
spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };
@@ -1217,54 +1180,45 @@ char *bitmap_string(char *buf, char *end, unsigned long *bitmap,
bit = i % BITS_PER_LONG;
val = (bitmap[word] >> bit) & chunkmask;
- if (!first) {
- if (buf < end)
- *buf = ',';
- buf++;
- }
+ if (!first)
+ prt_char(out, ',');
first = false;
spec.field_width = DIV_ROUND_UP(chunksz, 4);
- buf = number(buf, end, val, spec);
+ number(out, val, spec);
chunksz = CHUNKSZ;
}
- return buf;
}
static noinline_for_stack
-char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,
- struct printf_spec spec, const char *fmt)
+void bitmap_list_string(struct printbuf *out, unsigned long *bitmap,
+ struct printf_spec spec, const char *fmt)
{
int nr_bits = max_t(int, spec.field_width, 0);
bool first = true;
int rbot, rtop;
- if (check_pointer(&buf, end, bitmap, spec))
- return buf;
+ if (check_pointer(out, bitmap, spec))
+ return ;
for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) {
- if (!first) {
- if (buf < end)
- *buf = ',';
- buf++;
- }
+ if (!first)
+ prt_char(out, ',');
first = false;
- buf = number(buf, end, rbot, default_dec_spec);
+ number(out, rbot, default_dec_spec);
if (rtop == rbot + 1)
continue;
- if (buf < end)
- *buf = '-';
- buf = number(++buf, end, rtop - 1, default_dec_spec);
+ prt_char(out, '-');
+ number(out, rtop - 1, default_dec_spec);
}
- return buf;
}
static noinline_for_stack
-char *mac_address_string(char *buf, char *end, u8 *addr,
- struct printf_spec spec, const char *fmt)
+void mac_address_string(struct printbuf *out, u8 *addr,
+ struct printf_spec spec, const char *fmt)
{
char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
char *p = mac_addr;
@@ -1272,8 +1226,8 @@ char *mac_address_string(char *buf, char *end, u8 *addr,
char separator;
bool reversed = false;
- if (check_pointer(&buf, end, addr, spec))
- return buf;
+ if (check_pointer(out, addr, spec))
+ return;
switch (fmt[1]) {
case 'F':
@@ -1300,11 +1254,12 @@ char *mac_address_string(char *buf, char *end, u8 *addr,
}
*p = '\0';
- return string_nocheck(buf, end, mac_addr, spec);
+ string_nocheck(out, mac_addr, spec);
}
static noinline_for_stack
-char *ip4_string(char *p, const u8 *addr, const char *fmt)
+void ip4_string(struct printbuf *out,
+ const u8 *addr, const char *fmt)
{
int i;
bool leading_zeros = (fmt[0] == 'i');
@@ -1337,24 +1292,21 @@ char *ip4_string(char *p, const u8 *addr, const char *fmt)
int digits = put_dec_trunc8(temp, addr[index]) - temp;
if (leading_zeros) {
if (digits < 3)
- *p++ = '0';
+ prt_char(out, '0');
if (digits < 2)
- *p++ = '0';
+ prt_char(out, '0');
}
/* reverse the digits in the quad */
while (digits--)
- *p++ = temp[digits];
+ prt_char(out, temp[digits]);
if (i < 3)
- *p++ = '.';
+ prt_char(out, '.');
index += step;
}
- *p = '\0';
-
- return p;
}
static noinline_for_stack
-char *ip6_compressed_string(char *p, const char *addr)
+void ip6_compressed_string(struct printbuf *out, const char *addr)
{
int i, j, range;
unsigned char zerolength[8];
@@ -1398,14 +1350,14 @@ char *ip6_compressed_string(char *p, const char *addr)
for (i = 0; i < range; i++) {
if (i == colonpos) {
if (needcolon || i == 0)
- *p++ = ':';
- *p++ = ':';
+ __prt_char(out, ':');
+ __prt_char(out, ':');
needcolon = false;
i += longest - 1;
continue;
}
if (needcolon) {
- *p++ = ':';
+ __prt_char(out, ':');
needcolon = false;
}
/* hex u16 without leading 0s */
@@ -1414,81 +1366,79 @@ char *ip6_compressed_string(char *p, const char *addr)
lo = word & 0xff;
if (hi) {
if (hi > 0x0f)
- p = hex_byte_pack(p, hi);
+ prt_hex_byte(out, hi);
else
- *p++ = hex_asc_lo(hi);
- p = hex_byte_pack(p, lo);
+ __prt_char(out, hex_asc_lo(hi));
+ prt_hex_byte(out, lo);
}
else if (lo > 0x0f)
- p = hex_byte_pack(p, lo);
+ prt_hex_byte(out, lo);
else
- *p++ = hex_asc_lo(lo);
+ __prt_char(out, hex_asc_lo(lo));
needcolon = true;
}
if (useIPv4) {
if (needcolon)
- *p++ = ':';
- p = ip4_string(p, &in6.s6_addr[12], "I4");
+ __prt_char(out, ':');
+ ip4_string(out, &in6.s6_addr[12], "I4");
}
- *p = '\0';
- return p;
+ printbuf_nul_terminate(out);
}
static noinline_for_stack
-char *ip6_string(char *p, const char *addr, const char *fmt)
+void ip6_string(struct printbuf *out, const char *addr, const char *fmt)
{
int i;
for (i = 0; i < 8; i++) {
- p = hex_byte_pack(p, *addr++);
- p = hex_byte_pack(p, *addr++);
+ prt_hex_byte(out, *addr++);
+ prt_hex_byte(out, *addr++);
if (fmt[0] == 'I' && i != 7)
- *p++ = ':';
+ prt_char(out, ':');
}
- *p = '\0';
-
- return p;
}
static noinline_for_stack
-char *ip6_addr_string(char *buf, char *end, const u8 *addr,
- struct printf_spec spec, const char *fmt)
+void ip6_addr_string(struct printbuf *out, const u8 *addr,
+ struct printf_spec spec, const char *fmt)
{
- char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
+ char ip6_addr_buf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
+ struct printbuf ip6_addr = PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_addr_buf));
if (fmt[0] == 'I' && fmt[2] == 'c')
- ip6_compressed_string(ip6_addr, addr);
+ ip6_compressed_string(&ip6_addr, addr);
else
- ip6_string(ip6_addr, addr, fmt);
+ ip6_string(&ip6_addr, addr, fmt);
- return string_nocheck(buf, end, ip6_addr, spec);
+ string_nocheck(out, ip6_addr_buf, spec);
}
static noinline_for_stack
-char *ip4_addr_string(char *buf, char *end, const u8 *addr,
- struct printf_spec spec, const char *fmt)
+void ip4_addr_string(struct printbuf *out, const u8 *addr,
+ struct printf_spec spec, const char *fmt)
{
- char ip4_addr[sizeof("255.255.255.255")];
+ char ip4_addr_buf[sizeof("255.255.255.255")];
+ struct printbuf ip4_addr = PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_addr_buf));
- ip4_string(ip4_addr, addr, fmt);
+ ip4_string(&ip4_addr, addr, fmt);
- return string_nocheck(buf, end, ip4_addr, spec);
+ string_nocheck(out, ip4_addr_buf, spec);
}
static noinline_for_stack
-char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
- struct printf_spec spec, const char *fmt)
+void ip6_addr_string_sa(struct printbuf *out,
+ const struct sockaddr_in6 *sa,
+ struct printf_spec spec, const char *fmt)
{
bool have_p = false, have_s = false, have_f = false, have_c = false;
- char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
- sizeof(":12345") + sizeof("/123456789") +
- sizeof("%1234567890")];
- char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);
+ char ip6_addr_buf[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
+ sizeof(":12345") + sizeof("/123456789") +
+ sizeof("%1234567890")];
+ struct printbuf ip6_addr = PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_addr_buf));
const u8 *addr = (const u8 *) &sa->sin6_addr;
char fmt6[2] = { fmt[0], '6' };
- u8 off = 0;
fmt++;
while (isalpha(*++fmt)) {
@@ -1508,44 +1458,42 @@ char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
}
}
- if (have_p || have_s || have_f) {
- *p = '[';
- off = 1;
- }
+ if (have_p || have_s || have_f)
+ prt_char(&ip6_addr, '[');
if (fmt6[0] == 'I' && have_c)
- p = ip6_compressed_string(ip6_addr + off, addr);
+ ip6_compressed_string(&ip6_addr, addr);
else
- p = ip6_string(ip6_addr + off, addr, fmt6);
+ ip6_string(&ip6_addr, addr, fmt6);
if (have_p || have_s || have_f)
- *p++ = ']';
+ prt_char(&ip6_addr, ']');
if (have_p) {
- *p++ = ':';
- p = number(p, pend, ntohs(sa->sin6_port), spec);
+ prt_char(&ip6_addr, ':');
+ number(&ip6_addr, ntohs(sa->sin6_port), spec);
}
if (have_f) {
- *p++ = '/';
- p = number(p, pend, ntohl(sa->sin6_flowinfo &
- IPV6_FLOWINFO_MASK), spec);
+ prt_char(&ip6_addr, '/');
+ number(&ip6_addr, ntohl(sa->sin6_flowinfo &
+ IPV6_FLOWINFO_MASK), spec);
}
if (have_s) {
- *p++ = '%';
- p = number(p, pend, sa->sin6_scope_id, spec);
+ prt_char(&ip6_addr, '%');
+ number(&ip6_addr, sa->sin6_scope_id, spec);
}
- *p = '\0';
- return string_nocheck(buf, end, ip6_addr, spec);
+ string_nocheck(out, ip6_addr_buf, spec);
}
static noinline_for_stack
-char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
- struct printf_spec spec, const char *fmt)
+void ip4_addr_string_sa(struct printbuf *out,
+ const struct sockaddr_in *sa,
+ struct printf_spec spec, const char *fmt)
{
bool have_p = false;
- char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];
- char *pend = ip4_addr + sizeof(ip4_addr);
+ char ip4_addr_buf[sizeof("255.255.255.255") + sizeof(":12345")];
+ struct printbuf ip4_addr = PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_addr_buf));
const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
char fmt4[3] = { fmt[0], '4', 0 };
@@ -1564,30 +1512,29 @@ char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
}
}
- p = ip4_string(ip4_addr, addr, fmt4);
+ ip4_string(&ip4_addr, addr, fmt4);
if (have_p) {
- *p++ = ':';
- p = number(p, pend, ntohs(sa->sin_port), spec);
+ prt_char(&ip4_addr, ':');
+ number(&ip4_addr, ntohs(sa->sin_port), spec);
}
- *p = '\0';
- return string_nocheck(buf, end, ip4_addr, spec);
+ string_nocheck(out, ip4_addr_buf, spec);
}
static noinline_for_stack
-char *ip_addr_string(char *buf, char *end, const void *ptr,
- struct printf_spec spec, const char *fmt)
+void ip_addr_string(struct printbuf *out, const void *ptr,
+ struct printf_spec spec, const char *fmt)
{
char *err_fmt_msg;
- if (check_pointer(&buf, end, ptr, spec))
- return buf;
+ if (check_pointer(out, ptr, spec))
+ return;
switch (fmt[1]) {
case '6':
- return ip6_addr_string(buf, end, ptr, spec, fmt);
+ return ip6_addr_string(out, ptr, spec, fmt);
case '4':
- return ip4_addr_string(buf, end, ptr, spec, fmt);
+ return ip4_addr_string(out, ptr, spec, fmt);
case 'S': {
const union {
struct sockaddr raw;
@@ -1597,21 +1544,21 @@ char *ip_addr_string(char *buf, char *end, const void *ptr,
switch (sa->raw.sa_family) {
case AF_INET:
- return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
+ return ip4_addr_string_sa(out, &sa->v4, spec, fmt);
case AF_INET6:
- return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
+ return ip6_addr_string_sa(out, &sa->v6, spec, fmt);
default:
- return error_string(buf, end, "(einval)", spec);
+ return error_string(out, "(einval)", spec);
}}
}
err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)";
- return error_string(buf, end, err_fmt_msg, spec);
+ return error_string(out, err_fmt_msg, spec);
}
static noinline_for_stack
-char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
- const char *fmt)
+void escaped_string(struct printbuf *out, u8 *addr,
+ struct printf_spec spec, const char *fmt)
{
bool found = true;
int count = 1;
@@ -1619,10 +1566,10 @@ char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
int len;
if (spec.field_width == 0)
- return buf; /* nothing to print */
+ return; /* nothing to print */
- if (check_pointer(&buf, end, addr, spec))
- return buf;
+ if (check_pointer(out, addr, spec))
+ return;
do {
switch (fmt[count++]) {
@@ -1657,44 +1604,35 @@ char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
flags = ESCAPE_ANY_NP;
len = spec.field_width < 0 ? 1 : spec.field_width;
-
- /*
- * string_escape_mem() writes as many characters as it can to
- * the given buffer, and returns the total size of the output
- * had the buffer been big enough.
- */
- buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL);
-
- return buf;
+ prt_escaped_string(out, addr, len, flags, NULL);
}
-static char *va_format(char *buf, char *end, struct va_format *va_fmt,
- struct printf_spec spec, const char *fmt)
+static void va_format(struct printbuf *out,
+ struct va_format *va_fmt,
+ struct printf_spec spec, const char *fmt)
{
va_list va;
- if (check_pointer(&buf, end, va_fmt, spec))
- return buf;
+ if (check_pointer(out, va_fmt, spec))
+ return;
va_copy(va, *va_fmt->va);
- buf += vsnprintf(buf, end > buf ? end - buf : 0, va_fmt->fmt, va);
+ prt_vprintf(out, va_fmt->fmt, va);
va_end(va);
-
- return buf;
}
static noinline_for_stack
-char *uuid_string(char *buf, char *end, const u8 *addr,
- struct printf_spec spec, const char *fmt)
+void uuid_string(struct printbuf *out, const u8 *addr,
+ struct printf_spec spec, const char *fmt)
{
- char uuid[UUID_STRING_LEN + 1];
- char *p = uuid;
+ char uuid_buf[UUID_STRING_LEN + 1];
+ struct printbuf uuid = PRINTBUF_EXTERN(uuid_buf, sizeof(uuid_buf));
int i;
const u8 *index = uuid_index;
bool uc = false;
- if (check_pointer(&buf, end, addr, spec))
- return buf;
+ if (check_pointer(out, addr, spec))
+ return;
switch (*(++fmt)) {
case 'L':
@@ -1710,60 +1648,58 @@ char *uuid_string(char *buf, char *end, const u8 *addr,
for (i = 0; i < 16; i++) {
if (uc)
- p = hex_byte_pack_upper(p, addr[index[i]]);
+ prt_hex_byte_upper(&uuid, addr[index[i]]);
else
- p = hex_byte_pack(p, addr[index[i]]);
+ prt_hex_byte(&uuid, addr[index[i]]);
switch (i) {
case 3:
case 5:
case 7:
case 9:
- *p++ = '-';
+ prt_char(&uuid, '-');
break;
}
}
- *p = 0;
-
- return string_nocheck(buf, end, uuid, spec);
+ string_nocheck(out, uuid_buf, spec);
}
static noinline_for_stack
-char *netdev_bits(char *buf, char *end, const void *addr,
- struct printf_spec spec, const char *fmt)
+void netdev_bits(struct printbuf *out, const void *addr,
+ struct printf_spec spec, const char *fmt)
{
unsigned long long num;
int size;
- if (check_pointer(&buf, end, addr, spec))
- return buf;
+ if (check_pointer(out, addr, spec))
+ return;
switch (fmt[1]) {
case 'F':
num = *(const netdev_features_t *)addr;
size = sizeof(netdev_features_t);
+ special_hex_number(out, num, size);
break;
default:
- return error_string(buf, end, "(%pN?)", spec);
+ error_string(out, "(%pN?)", spec);
+ break;
}
-
- return special_hex_number(buf, end, num, size);
}
static noinline_for_stack
-char *fourcc_string(char *buf, char *end, const u32 *fourcc,
- struct printf_spec spec, const char *fmt)
+void fourcc_string(struct printbuf *out, const u32 *fourcc,
+ struct printf_spec spec, const char *fmt)
{
- char output[sizeof("0123 little-endian (0x01234567)")];
- char *p = output;
+ char output_buf[sizeof("0123 little-endian (0x01234567)")];
+ struct printbuf output = PRINTBUF_EXTERN(output_buf, sizeof(output_buf));
unsigned int i;
u32 orig, val;
if (fmt[1] != 'c' || fmt[2] != 'c')
- return error_string(buf, end, "(%p4?)", spec);
+ return error_string(out, "(%p4?)", spec);
- if (check_pointer(&buf, end, fourcc, spec))
- return buf;
+ if (check_pointer(out, fourcc, spec))
+ return;
orig = get_unaligned(fourcc);
val = orig & ~BIT(31);
@@ -1772,31 +1708,29 @@ char *fourcc_string(char *buf, char *end, const u32 *fourcc,
unsigned char c = val >> (i * 8);
/* Print non-control ASCII characters as-is, dot otherwise */
- *p++ = isascii(c) && isprint(c) ? c : '.';
+ prt_char(&output, isascii(c) && isprint(c) ? c : '.');
}
- *p++ = ' ';
- strcpy(p, orig & BIT(31) ? "big-endian" : "little-endian");
- p += strlen(p);
+ prt_char(&output, ' ');
+ prt_str(&output, orig & BIT(31) ? "big-endian" : "little-endian");
- *p++ = ' ';
- *p++ = '(';
- p = special_hex_number(p, output + sizeof(output) - 2, orig, sizeof(u32));
- *p++ = ')';
- *p = '\0';
+ prt_char(&output, ' ');
+ prt_char(&output, '(');
+ special_hex_number(&output, orig, sizeof(u32));
+ prt_char(&output, ')');
- return string(buf, end, output, spec);
+ string(out, output_buf, spec);
}
static noinline_for_stack
-char *address_val(char *buf, char *end, const void *addr,
- struct printf_spec spec, const char *fmt)
+void address_val(struct printbuf *out, const void *addr,
+ struct printf_spec spec, const char *fmt)
{
unsigned long long num;
int size;
- if (check_pointer(&buf, end, addr, spec))
- return buf;
+ if (check_pointer(out, addr, spec))
+ return;
switch (fmt[1]) {
case 'd':
@@ -1810,55 +1744,44 @@ char *address_val(char *buf, char *end, const void *addr,
break;
}
- return special_hex_number(buf, end, num, size);
+ special_hex_number(out, num, size);
}
static noinline_for_stack
-char *date_str(char *buf, char *end, const struct rtc_time *tm, bool r)
+void date_str(struct printbuf *out,
+ const struct rtc_time *tm, bool r)
{
int year = tm->tm_year + (r ? 0 : 1900);
int mon = tm->tm_mon + (r ? 0 : 1);
- buf = number(buf, end, year, default_dec04_spec);
- if (buf < end)
- *buf = '-';
- buf++;
-
- buf = number(buf, end, mon, default_dec02_spec);
- if (buf < end)
- *buf = '-';
- buf++;
-
- return number(buf, end, tm->tm_mday, default_dec02_spec);
+ number(out, year, default_dec04_spec);
+ prt_char(out, '-');
+ number(out, mon, default_dec02_spec);
+ prt_char(out, '-');
+ number(out, tm->tm_mday, default_dec02_spec);
}
static noinline_for_stack
-char *time_str(char *buf, char *end, const struct rtc_time *tm, bool r)
+void time_str(struct printbuf *out, const struct rtc_time *tm, bool r)
{
- buf = number(buf, end, tm->tm_hour, default_dec02_spec);
- if (buf < end)
- *buf = ':';
- buf++;
-
- buf = number(buf, end, tm->tm_min, default_dec02_spec);
- if (buf < end)
- *buf = ':';
- buf++;
-
- return number(buf, end, tm->tm_sec, default_dec02_spec);
+ number(out, tm->tm_hour, default_dec02_spec);
+ prt_char(out, ':');
+ number(out, tm->tm_min, default_dec02_spec);
+ prt_char(out, ':');
+ number(out, tm->tm_sec, default_dec02_spec);
}
static noinline_for_stack
-char *rtc_str(char *buf, char *end, const struct rtc_time *tm,
- struct printf_spec spec, const char *fmt)
+void rtc_str(struct printbuf *out, const struct rtc_time *tm,
+ struct printf_spec spec, const char *fmt)
{
bool have_t = true, have_d = true;
bool raw = false, iso8601_separator = true;
bool found = true;
int count = 2;
- if (check_pointer(&buf, end, tm, spec))
- return buf;
+ if (check_pointer(out, tm, spec))
+ return;
switch (fmt[count]) {
case 'd':
@@ -1886,21 +1809,16 @@ char *rtc_str(char *buf, char *end, const struct rtc_time *tm,
} while (found);
if (have_d)
- buf = date_str(buf, end, tm, raw);
- if (have_d && have_t) {
- if (buf < end)
- *buf = iso8601_separator ? 'T' : ' ';
- buf++;
- }
+ date_str(out, tm, raw);
+ if (have_d && have_t)
+ prt_char(out, iso8601_separator ? 'T' : ' ');
if (have_t)
- buf = time_str(buf, end, tm, raw);
-
- return buf;
+ time_str(out, tm, raw);
}
static noinline_for_stack
-char *time64_str(char *buf, char *end, const time64_t time,
- struct printf_spec spec, const char *fmt)
+void time64_str(struct printbuf *out, const time64_t time,
+ struct printf_spec spec, const char *fmt)
{
struct rtc_time rtc_time;
struct tm tm;
@@ -1918,47 +1836,48 @@ char *time64_str(char *buf, char *end, const time64_t time,
rtc_time.tm_isdst = 0;
- return rtc_str(buf, end, &rtc_time, spec, fmt);
+ rtc_str(out, &rtc_time, spec, fmt);
}
static noinline_for_stack
-char *time_and_date(char *buf, char *end, void *ptr, struct printf_spec spec,
- const char *fmt)
+void time_and_date(struct printbuf *out,
+ void *ptr, struct printf_spec spec,
+ const char *fmt)
{
switch (fmt[1]) {
case 'R':
- return rtc_str(buf, end, (const struct rtc_time *)ptr, spec, fmt);
+ return rtc_str(out, (const struct rtc_time *)ptr, spec, fmt);
case 'T':
- return time64_str(buf, end, *(const time64_t *)ptr, spec, fmt);
+ return time64_str(out, *(const time64_t *)ptr, spec, fmt);
default:
- return error_string(buf, end, "(%pt?)", spec);
+ return error_string(out, "(%pt?)", spec);
}
}
static noinline_for_stack
-char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec,
- const char *fmt)
+void clock(struct printbuf *out, struct clk *clk,
+ struct printf_spec spec, const char *fmt)
{
if (!IS_ENABLED(CONFIG_HAVE_CLK))
- return error_string(buf, end, "(%pC?)", spec);
+ return error_string(out, "(%pC?)", spec);
- if (check_pointer(&buf, end, clk, spec))
- return buf;
+ if (check_pointer(out, clk, spec))
+ return;
switch (fmt[1]) {
case 'n':
default:
#ifdef CONFIG_COMMON_CLK
- return string(buf, end, __clk_get_name(clk), spec);
+ return string(out, __clk_get_name(clk), spec);
#else
- return ptr_to_id(buf, end, clk, spec);
+ return ptr_to_id(out, clk, spec);
#endif
}
}
static
-char *format_flags(char *buf, char *end, unsigned long flags,
- const struct trace_print_flags *names)
+void format_flags(struct printbuf *out, unsigned long flags,
+ const struct trace_print_flags *names)
{
unsigned long mask;
@@ -1967,20 +1886,15 @@ char *format_flags(char *buf, char *end, unsigned long flags,
if ((flags & mask) != mask)
continue;
- buf = string(buf, end, names->name, default_str_spec);
+ string(out, names->name, default_str_spec);
flags &= ~mask;
- if (flags) {
- if (buf < end)
- *buf = '|';
- buf++;
- }
+ if (flags)
+ prt_char(out, '|');
}
if (flags)
- buf = number(buf, end, flags, default_flag_spec);
-
- return buf;
+ number(out, flags, default_flag_spec);
}
struct page_flags_fields {
@@ -2005,20 +1919,18 @@ static const struct page_flags_fields pff[] = {
};
static
-char *format_page_flags(char *buf, char *end, unsigned long flags)
+void format_page_flags(struct printbuf *out, unsigned long flags)
{
unsigned long main_flags = flags & PAGEFLAGS_MASK;
bool append = false;
int i;
- buf = number(buf, end, flags, default_flag_spec);
- if (buf < end)
- *buf = '(';
- buf++;
+ number(out, flags, default_flag_spec);
+ prt_char(out, '(');
/* Page flags from the main area. */
if (main_flags) {
- buf = format_flags(buf, end, main_flags, pageflag_names);
+ format_flags(out, main_flags, pageflag_names);
append = true;
}
@@ -2029,41 +1941,31 @@ char *format_page_flags(char *buf, char *end, unsigned long flags)
continue;
/* Format: Flag Name + '=' (equals sign) + Number + '|' (separator) */
- if (append) {
- if (buf < end)
- *buf = '|';
- buf++;
- }
+ if (append)
+ prt_char(out, '|');
- buf = string(buf, end, pff[i].name, default_str_spec);
- if (buf < end)
- *buf = '=';
- buf++;
- buf = number(buf, end, (flags >> pff[i].shift) & pff[i].mask,
- *pff[i].spec);
+ string(out, pff[i].name, default_str_spec);
+ prt_char(out, '=');
+ number(out, (flags >> pff[i].shift) & pff[i].mask, *pff[i].spec);
append = true;
}
- if (buf < end)
- *buf = ')';
- buf++;
-
- return buf;
+ prt_char(out, ')');
}
static noinline_for_stack
-char *flags_string(char *buf, char *end, void *flags_ptr,
- struct printf_spec spec, const char *fmt)
+void flags_string(struct printbuf *out, void *flags_ptr,
+ struct printf_spec spec, const char *fmt)
{
unsigned long flags;
const struct trace_print_flags *names;
- if (check_pointer(&buf, end, flags_ptr, spec))
- return buf;
+ if (check_pointer(out, flags_ptr, spec))
+ return;
switch (fmt[1]) {
case 'p':
- return format_page_flags(buf, end, *(unsigned long *)flags_ptr);
+ return format_page_flags(out, *(unsigned long *)flags_ptr);
case 'v':
flags = *(unsigned long *)flags_ptr;
names = vmaflag_names;
@@ -2073,15 +1975,15 @@ char *flags_string(char *buf, char *end, void *flags_ptr,
names = gfpflag_names;
break;
default:
- return error_string(buf, end, "(%pG?)", spec);
+ return error_string(out, "(%pG?)", spec);
}
- return format_flags(buf, end, flags, names);
+ return format_flags(out, flags, names);
}
static noinline_for_stack
-char *fwnode_full_name_string(struct fwnode_handle *fwnode, char *buf,
- char *end)
+void fwnode_full_name_string(struct printbuf *out,
+ struct fwnode_handle *fwnode)
{
int depth;
@@ -2090,25 +1992,23 @@ char *fwnode_full_name_string(struct fwnode_handle *fwnode, char *buf,
struct fwnode_handle *__fwnode =
fwnode_get_nth_parent(fwnode, depth);
- buf = string(buf, end, fwnode_get_name_prefix(__fwnode),
- default_str_spec);
- buf = string(buf, end, fwnode_get_name(__fwnode),
- default_str_spec);
+ string(out, fwnode_get_name_prefix(__fwnode),
+ default_str_spec);
+ string(out, fwnode_get_name(__fwnode),
+ default_str_spec);
fwnode_handle_put(__fwnode);
}
-
- return buf;
}
static noinline_for_stack
-char *device_node_string(char *buf, char *end, struct device_node *dn,
- struct printf_spec spec, const char *fmt)
+void device_node_string(struct printbuf *out, struct device_node *dn,
+ struct printf_spec spec, const char *fmt)
{
char tbuf[sizeof("xxxx") + 1];
const char *p;
int ret;
- char *buf_start = buf;
+ unsigned start = out->pos;
struct property *prop;
bool has_mult, pass;
@@ -2116,13 +2016,13 @@ char *device_node_string(char *buf, char *end, struct device_node *dn,
str_spec.field_width = -1;
if (fmt[0] != 'F')
- return error_string(buf, end, "(%pO?)", spec);
+ return error_string(out, "(%pO?)", spec);
if (!IS_ENABLED(CONFIG_OF))
- return error_string(buf, end, "(%pOF?)", spec);
+ return error_string(out, "(%pOF?)", spec);
- if (check_pointer(&buf, end, dn, spec))
- return buf;
+ if (check_pointer(out, dn, spec))
+ return;
/* simple case without anything any more format specifiers */
fmt++;
@@ -2131,32 +2031,28 @@ char *device_node_string(char *buf, char *end, struct device_node *dn,
for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) {
int precision;
- if (pass) {
- if (buf < end)
- *buf = ':';
- buf++;
- }
+ if (pass)
+ prt_char(out, ':');
switch (*fmt) {
case 'f': /* full_name */
- buf = fwnode_full_name_string(of_fwnode_handle(dn), buf,
- end);
+ fwnode_full_name_string(out, of_fwnode_handle(dn));
break;
case 'n': /* name */
p = fwnode_get_name(of_fwnode_handle(dn));
precision = str_spec.precision;
str_spec.precision = strchrnul(p, '@') - p;
- buf = string(buf, end, p, str_spec);
+ string(out, p, str_spec);
str_spec.precision = precision;
break;
case 'p': /* phandle */
- buf = number(buf, end, (unsigned int)dn->phandle, default_dec_spec);
+ number(out, (unsigned int)dn->phandle, default_dec_spec);
break;
case 'P': /* path-spec */
p = fwnode_get_name(of_fwnode_handle(dn));
if (!p[1])
p = "/";
- buf = string(buf, end, p, str_spec);
+ string(out, p, str_spec);
break;
case 'F': /* flags */
tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';
@@ -2164,21 +2060,21 @@ char *device_node_string(char *buf, char *end, struct device_node *dn,
tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-';
tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-';
tbuf[4] = 0;
- buf = string_nocheck(buf, end, tbuf, str_spec);
+ string_nocheck(out, tbuf, str_spec);
break;
case 'c': /* major compatible string */
ret = of_property_read_string(dn, "compatible", &p);
if (!ret)
- buf = string(buf, end, p, str_spec);
+ string(out, p, str_spec);
break;
case 'C': /* full compatible string */
has_mult = false;
of_property_for_each_string(dn, "compatible", prop, p) {
if (has_mult)
- buf = string_nocheck(buf, end, ",", str_spec);
- buf = string_nocheck(buf, end, "\"", str_spec);
- buf = string(buf, end, p, str_spec);
- buf = string_nocheck(buf, end, "\"", str_spec);
+ string_nocheck(out, ",", str_spec);
+ string_nocheck(out, "\"", str_spec);
+ string(out, p, str_spec);
+ string_nocheck(out, "\"", str_spec);
has_mult = true;
}
@@ -2188,37 +2084,38 @@ char *device_node_string(char *buf, char *end, struct device_node *dn,
}
}
- return widen_string(buf, buf - buf_start, end, spec);
+ widen_string(out, out->pos - start, spec);
}
static noinline_for_stack
-char *fwnode_string(char *buf, char *end, struct fwnode_handle *fwnode,
- struct printf_spec spec, const char *fmt)
+void fwnode_string(struct printbuf *out,
+ struct fwnode_handle *fwnode,
+ struct printf_spec spec, const char *fmt)
{
struct printf_spec str_spec = spec;
- char *buf_start = buf;
+ unsigned start = out->pos;
str_spec.field_width = -1;
if (*fmt != 'w')
- return error_string(buf, end, "(%pf?)", spec);
+ return error_string(out, "(%pf?)", spec);
- if (check_pointer(&buf, end, fwnode, spec))
- return buf;
+ if (check_pointer(out, fwnode, spec))
+ return;
fmt++;
switch (*fmt) {
case 'P': /* name */
- buf = string(buf, end, fwnode_get_name(fwnode), str_spec);
+ string(out, fwnode_get_name(fwnode), str_spec);
break;
case 'f': /* full_name */
default:
- buf = fwnode_full_name_string(fwnode, buf, end);
+ fwnode_full_name_string(out, fwnode);
break;
}
- return widen_string(buf, buf - buf_start, end, spec);
+ widen_string(out, out->pos - start, spec);
}
int __init no_hash_pointers_enable(char *str)
@@ -2374,8 +2271,8 @@ early_param("no_hash_pointers", no_hash_pointers_enable);
* rendering it useful as a unique identifier.
*/
static noinline_for_stack
-char *pointer(const char *fmt, char *buf, char *end, void *ptr,
- struct printf_spec spec)
+void pointer(struct printbuf *out, const char *fmt,
+ void *ptr, struct printf_spec spec)
{
switch (*fmt) {
case 'S':
@@ -2383,24 +2280,24 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
ptr = dereference_symbol_descriptor(ptr);
fallthrough;
case 'B':
- return symbol_string(buf, end, ptr, spec, fmt);
+ return symbol_string(out, ptr, spec, fmt);
case 'R':
case 'r':
- return resource_string(buf, end, ptr, spec, fmt);
+ return resource_string(out, ptr, spec, fmt);
case 'h':
- return hex_string(buf, end, ptr, spec, fmt);
+ return hex_string(out, ptr, spec, fmt);
case 'b':
switch (fmt[1]) {
case 'l':
- return bitmap_list_string(buf, end, ptr, spec, fmt);
+ return bitmap_list_string(out, ptr, spec, fmt);
default:
- return bitmap_string(buf, end, ptr, spec, fmt);
+ return bitmap_string(out, ptr, spec, fmt);
}
case 'M': /* Colon separated: 00:01:02:03:04:05 */
case 'm': /* Contiguous: 000102030405 */
/* [mM]F (FDDI) */
/* [mM]R (Reverse order; Bluetooth) */
- return mac_address_string(buf, end, ptr, spec, fmt);
+ return mac_address_string(out, ptr, spec, fmt);
case 'I': /* Formatted IP supported
* 4: 1.2.3.4
* 6: 0001:0203:...:0708
@@ -2410,57 +2307,57 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
* 4: 001.002.003.004
* 6: 000102...0f
*/
- return ip_addr_string(buf, end, ptr, spec, fmt);
+ return ip_addr_string(out, ptr, spec, fmt);
case 'E':
- return escaped_string(buf, end, ptr, spec, fmt);
+ return escaped_string(out, ptr, spec, fmt);
case 'U':
- return uuid_string(buf, end, ptr, spec, fmt);
+ return uuid_string(out, ptr, spec, fmt);
case 'V':
- return va_format(buf, end, ptr, spec, fmt);
+ return va_format(out, ptr, spec, fmt);
case 'K':
- return restricted_pointer(buf, end, ptr, spec);
+ return restricted_pointer(out, ptr, spec);
case 'N':
- return netdev_bits(buf, end, ptr, spec, fmt);
+ return netdev_bits(out, ptr, spec, fmt);
case '4':
- return fourcc_string(buf, end, ptr, spec, fmt);
+ return fourcc_string(out, ptr, spec, fmt);
case 'a':
- return address_val(buf, end, ptr, spec, fmt);
+ return address_val(out, ptr, spec, fmt);
case 'd':
- return dentry_name(buf, end, ptr, spec, fmt);
+ return dentry_name(out, ptr, spec, fmt);
case 't':
- return time_and_date(buf, end, ptr, spec, fmt);
+ return time_and_date(out, ptr, spec, fmt);
case 'C':
- return clock(buf, end, ptr, spec, fmt);
+ return clock(out, ptr, spec, fmt);
case 'D':
- return file_dentry_name(buf, end, ptr, spec, fmt);
+ return file_dentry_name(out, ptr, spec, fmt);
#ifdef CONFIG_BLOCK
case 'g':
- return bdev_name(buf, end, ptr, spec, fmt);
+ return bdev_name(out, ptr, spec, fmt);
#endif
case 'G':
- return flags_string(buf, end, ptr, spec, fmt);
+ return flags_string(out, ptr, spec, fmt);
case 'O':
- return device_node_string(buf, end, ptr, spec, fmt + 1);
+ return device_node_string(out, ptr, spec, fmt + 1);
case 'f':
- return fwnode_string(buf, end, ptr, spec, fmt + 1);
+ return fwnode_string(out, ptr, spec, fmt + 1);
case 'x':
- return pointer_string(buf, end, ptr, spec);
+ return pointer_string(out, ptr, spec);
case 'e':
/* %pe with a non-ERR_PTR gets treated as plain %p */
if (!IS_ERR(ptr))
- return default_pointer(buf, end, ptr, spec);
- return err_ptr(buf, end, ptr, spec);
+ return default_pointer(out, ptr, spec);
+ return err_ptr(out, ptr, spec);
case 'u':
case 'k':
switch (fmt[1]) {
case 's':
- return string(buf, end, ptr, spec);
+ return string(out, ptr, spec);
default:
- return error_string(buf, end, "(einval)", spec);
+ return error_string(out, "(einval)", spec);
}
default:
- return default_pointer(buf, end, ptr, spec);
+ return default_pointer(out, ptr, spec);
}
}
@@ -2682,52 +2579,27 @@ set_precision(struct printf_spec *spec, int prec)
}
/**
- * vsnprintf - Format a string and place it in a buffer
- * @buf: The buffer to place the result into
- * @size: The size of the buffer, including the trailing null space
+ * prt_vprintf - Format a string, outputting to a printbuf
+ * @out: The printbuf to output to
* @fmt: The format string to use
* @args: Arguments for the format string
*
- * This function generally follows C99 vsnprintf, but has some
- * extensions and a few limitations:
- *
- * - ``%n`` is unsupported
- * - ``%p*`` is handled by pointer()
- *
- * See pointer() or Documentation/core-api/printk-formats.rst for more
- * extensive description.
- *
- * **Please update the documentation in both places when making changes**
+ * prt_vprintf works much like the traditional vsnprintf(), but outputs to a
+ * printbuf instead of raw pointer/size.
*
- * The return value is the number of characters which would
- * be generated for the given input, excluding the trailing
- * '\0', as per ISO C99. If you want to have the exact
- * number of characters written into @buf as return value
- * (not including the trailing '\0'), use vscnprintf(). If the
- * return is greater than or equal to @size, the resulting
- * string is truncated.
+ * If you're not already dealing with a va_list consider using prt_printf().
*
- * If you're not already dealing with a va_list consider using snprintf().
+ * See the vsnprintf() documentation for format string extensions over C99.
*/
-int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
+void prt_vprintf(struct printbuf *out, const char *fmt, va_list args)
{
unsigned long long num;
- char *str, *end;
struct printf_spec spec = {0};
/* Reject out-of-range values early. Large positive sizes are
used for unknown buffer sizes. */
- if (WARN_ON_ONCE(size > INT_MAX))
- return 0;
-
- str = buf;
- end = buf + size;
-
- /* Make sure end is always >= buf */
- if (end < buf) {
- end = ((void *)-1);
- size = end - buf;
- }
+ if (WARN_ON_ONCE(out->size > INT_MAX))
+ return;
while (*fmt) {
const char *old_fmt = fmt;
@@ -2736,16 +2608,9 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
fmt += read;
switch (spec.type) {
- case FORMAT_TYPE_NONE: {
- int copy = read;
- if (str < end) {
- if (copy > end - str)
- copy = end - str;
- memcpy(str, old_fmt, copy);
- }
- str += read;
+ case FORMAT_TYPE_NONE:
+ prt_bytes(out, old_fmt, read);
break;
- }
case FORMAT_TYPE_WIDTH:
set_field_width(&spec, va_arg(args, int));
@@ -2755,44 +2620,29 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
set_precision(&spec, va_arg(args, int));
break;
- case FORMAT_TYPE_CHAR: {
- char c;
+ case FORMAT_TYPE_CHAR:
+ if (spec.field_width > 0 && !(spec.flags & LEFT))
+ prt_chars(out, spec.field_width, ' ');
- if (!(spec.flags & LEFT)) {
- while (--spec.field_width > 0) {
- if (str < end)
- *str = ' ';
- ++str;
+ __prt_char(out, (unsigned char) va_arg(args, int));
- }
- }
- c = (unsigned char) va_arg(args, int);
- if (str < end)
- *str = c;
- ++str;
- while (--spec.field_width > 0) {
- if (str < end)
- *str = ' ';
- ++str;
- }
+ if (spec.field_width > 0 && (spec.flags & LEFT))
+ prt_chars(out, spec.field_width, ' ');
+ spec.field_width = 0;
break;
- }
case FORMAT_TYPE_STR:
- str = string(str, end, va_arg(args, char *), spec);
+ string(out, va_arg(args, char *), spec);
break;
case FORMAT_TYPE_PTR:
- str = pointer(fmt, str, end, va_arg(args, void *),
- spec);
+ pointer(out, fmt, va_arg(args, void *), spec);
while (isalnum(*fmt))
fmt++;
break;
case FORMAT_TYPE_PERCENT_CHAR:
- if (str < end)
- *str = '%';
- ++str;
+ __prt_char(out, '%');
break;
case FORMAT_TYPE_INVALID:
@@ -2845,21 +2695,70 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
num = va_arg(args, unsigned int);
}
- str = number(str, end, num, spec);
+ number(out, num, spec);
}
}
-
out:
- if (size > 0) {
- if (str < end)
- *str = '\0';
- else
- end[-1] = '\0';
- }
+ printbuf_nul_terminate(out);
+}
+EXPORT_SYMBOL(prt_vprintf);
- /* the trailing null byte doesn't count towards the total */
- return str-buf;
+/**
+ * prt_printf - Format a string, outputting to a printbuf
+ * @out: The printbuf to output to
+ * @fmt: The format string to use
+ * @args: Arguments for the format string
+ *
+ *
+ * prt_printf works much like the traditional sprintf(), but outputs to a
+ * printbuf instead of raw pointer/size.
+ *
+ * See the vsnprintf() documentation for format string extensions over C99.
+ */
+void prt_printf(struct printbuf *out, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ prt_vprintf(out, fmt, args);
+ va_end(args);
+}
+EXPORT_SYMBOL(prt_printf);
+
+/**
+ * vsnprintf - Format a string and place it in a buffer
+ * @buf: The buffer to place the result into
+ * @size: The size of the buffer, including the trailing null space
+ * @fmt: The format string to use
+ * @args: Arguments for the format string
+ *
+ * This function generally follows C99 vsnprintf, but has some
+ * extensions and a few limitations:
+ *
+ * - ``%n`` is unsupported
+ * - ``%p*`` is handled by pointer()
+ *
+ * See pointer() or Documentation/core-api/printk-formats.rst for more
+ * extensive description.
+ *
+ * **Please update the documentation in both places when making changes**
+ *
+ * The return value is the number of characters which would
+ * be generated for the given input, excluding the trailing
+ * '\0', as per ISO C99. If you want to have the exact
+ * number of characters written into @buf as return value
+ * (not including the trailing '\0'), use vscnprintf(). If the
+ * return is greater than or equal to @size, the resulting
+ * string is truncated.
+ *
+ * If you're not already dealing with a va_list consider using snprintf().
+ */
+int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+ struct printbuf out = PRINTBUF_EXTERN(buf, size);
+
+ prt_vprintf(&out, fmt, args);
+ return out.pos;
}
EXPORT_SYMBOL(vsnprintf);
@@ -2997,53 +2896,46 @@ EXPORT_SYMBOL(sprintf);
* bstr_printf() - Binary data to text string
*/
+static inline void printbuf_align(struct printbuf *out, unsigned align)
+{
+ /* Assumes output buffer is correctly aligned: */
+ out->pos += align - 1;
+ out->pos &= ~(align - 1);
+}
+
/**
- * vbin_printf - Parse a format string and place args' binary value in a buffer
- * @bin_buf: The buffer to place args' binary value
- * @size: The size of the buffer(by words(32bits), not characters)
+ * prt_vbinprintf - Parse a format string and place args' binary value in a buffer
+ * @out: The buffer to place args' binary value
* @fmt: The format string to use
* @args: Arguments for the format string
*
* The format follows C99 vsnprintf, except %n is ignored, and its argument
* is skipped.
*
- * The return value is the number of words(32bits) which would be generated for
- * the given input.
- *
* NOTE:
* If the return value is greater than @size, the resulting bin_buf is NOT
* valid for bstr_printf().
*/
-int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
+void prt_vbinprintf(struct printbuf *out, const char *fmt, va_list args)
{
struct printf_spec spec = {0};
- char *str, *end;
int width;
- str = (char *)bin_buf;
- end = (char *)(bin_buf + size);
-
#define save_arg(type) \
({ \
unsigned long long value; \
if (sizeof(type) == 8) { \
- unsigned long long val8; \
- str = PTR_ALIGN(str, sizeof(u32)); \
- val8 = va_arg(args, unsigned long long); \
- if (str + sizeof(type) <= end) { \
- *(u32 *)str = *(u32 *)&val8; \
- *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \
- } \
+ u64 val8 = va_arg(args, u64); \
+ printbuf_align(out, sizeof(u32)); \
+ prt_bytes(out, (u32 *) &val8, 4); \
+ prt_bytes(out, ((u32 *) &val8) + 1, 4); \
value = val8; \
} else { \
- unsigned int val4; \
- str = PTR_ALIGN(str, sizeof(type)); \
- val4 = va_arg(args, int); \
- if (str + sizeof(type) <= end) \
- *(typeof(type) *)str = (type)(long)val4; \
+ u32 val4 = va_arg(args, u32); \
+ printbuf_align(out, sizeof(type)); \
+ prt_bytes(out, &val4, sizeof(type)); \
value = (unsigned long long)val4; \
} \
- str += sizeof(type); \
value; \
})
@@ -3074,16 +2966,12 @@ int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
case FORMAT_TYPE_STR: {
const char *save_str = va_arg(args, char *);
const char *err_msg;
- size_t len;
err_msg = check_pointer_msg(save_str);
if (err_msg)
save_str = err_msg;
- len = strlen(save_str) + 1;
- if (str + len < end)
- memcpy(str, save_str, len);
- str += len;
+ prt_str(out, save_str);
break;
}
@@ -3103,12 +2991,7 @@ int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
save_arg(void *);
break;
}
- str = pointer(fmt, str, end, va_arg(args, void *),
- spec);
- if (str + 1 < end)
- *str++ = '\0';
- else
- end[-1] = '\0'; /* Must be nul terminated */
+ pointer(out, fmt, va_arg(args, void *), spec);
}
/* skip all alphanumeric pointer suffixes */
while (isalnum(*fmt))
@@ -3146,15 +3029,15 @@ int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
}
out:
- return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
+ printbuf_nul_terminate(out);
+ printbuf_align(out, 4);
#undef save_arg
}
-EXPORT_SYMBOL_GPL(vbin_printf);
+EXPORT_SYMBOL_GPL(prt_vbinprintf);
/**
- * bstr_printf - Format a string from binary arguments and place it in a buffer
+ * prt_bstrprintf - Format a string from binary arguments and place it in a buffer
* @buf: The buffer to place the result into
- * @size: The size of the buffer, including the trailing null space
* @fmt: The format string to use
* @bin_buf: Binary arguments for the format string
*
@@ -3164,26 +3047,14 @@ EXPORT_SYMBOL_GPL(vbin_printf);
*
* The format follows C99 vsnprintf, but has some extensions:
* see vsnprintf comment for details.
- *
- * The return value is the number of characters which would
- * be generated for the given input, excluding the trailing
- * '\0', as per ISO C99. If you want to have the exact
- * number of characters written into @buf as return value
- * (not including the trailing '\0'), use vscnprintf(). If the
- * return is greater than or equal to @size, the resulting
- * string is truncated.
*/
-int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
+void prt_bstrprintf(struct printbuf *out, const char *fmt, const u32 *bin_buf)
{
struct printf_spec spec = {0};
- char *str, *end;
const char *args = (const char *)bin_buf;
- if (WARN_ON_ONCE(size > INT_MAX))
- return 0;
-
- str = buf;
- end = buf + size;
+ if (WARN_ON_ONCE(out->size > INT_MAX))
+ return;
#define get_arg(type) \
({ \
@@ -3200,12 +3071,6 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
value; \
})
- /* Make sure end is always >= buf */
- if (end < buf) {
- end = ((void *)-1);
- size = end - buf;
- }
-
while (*fmt) {
const char *old_fmt = fmt;
int read = format_decode(fmt, &spec);
@@ -3213,16 +3078,9 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
fmt += read;
switch (spec.type) {
- case FORMAT_TYPE_NONE: {
- int copy = read;
- if (str < end) {
- if (copy > end - str)
- copy = end - str;
- memcpy(str, old_fmt, copy);
- }
- str += read;
+ case FORMAT_TYPE_NONE:
+ prt_bytes(out, old_fmt, read);
break;
- }
case FORMAT_TYPE_WIDTH:
set_field_width(&spec, get_arg(int));
@@ -3232,38 +3090,24 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
set_precision(&spec, get_arg(int));
break;
- case FORMAT_TYPE_CHAR: {
- char c;
-
- if (!(spec.flags & LEFT)) {
- while (--spec.field_width > 0) {
- if (str < end)
- *str = ' ';
- ++str;
- }
- }
- c = (unsigned char) get_arg(char);
- if (str < end)
- *str = c;
- ++str;
- while (--spec.field_width > 0) {
- if (str < end)
- *str = ' ';
- ++str;
- }
+ case FORMAT_TYPE_CHAR:
+ if (!(spec.flags & LEFT))
+ prt_chars(out, spec.field_width, ' ');
+ __prt_char(out, (unsigned char) get_arg(char));
+ if ((spec.flags & LEFT))
+ prt_chars(out, spec.field_width, ' ');
break;
- }
case FORMAT_TYPE_STR: {
const char *str_arg = args;
args += strlen(str_arg) + 1;
- str = string(str, end, (char *)str_arg, spec);
+ string(out, (char *)str_arg, spec);
break;
}
case FORMAT_TYPE_PTR: {
bool process = false;
- int copy, len;
+ int len;
/* Non function dereferences were already done */
switch (*fmt) {
case 'S':
@@ -3279,17 +3123,12 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
break;
}
/* Pointer dereference was already processed */
- if (str < end) {
- len = copy = strlen(args);
- if (copy > end - str)
- copy = end - str;
- memcpy(str, args, copy);
- str += len;
- args += len + 1;
- }
+ len = strlen(args);
+ prt_bytes(out, args, len);
+ args += len + 1;
}
if (process)
- str = pointer(fmt, str, end, get_arg(void *), spec);
+ pointer(out, fmt, get_arg(void *), spec);
while (isalnum(*fmt))
fmt++;
@@ -3297,9 +3136,7 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
}
case FORMAT_TYPE_PERCENT_CHAR:
- if (str < end)
- *str = '%';
- ++str;
+ __prt_char(out, '%');
break;
case FORMAT_TYPE_INVALID:
@@ -3342,23 +3179,87 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
num = get_arg(int);
}
- str = number(str, end, num, spec);
+ number(out, num, spec);
} /* default: */
} /* switch(spec.type) */
} /* while(*fmt) */
out:
- if (size > 0) {
- if (str < end)
- *str = '\0';
- else
- end[-1] = '\0';
- }
-
#undef get_arg
+ printbuf_nul_terminate(out);
+}
+EXPORT_SYMBOL_GPL(prt_bstrprintf);
+
+/**
+ * prt_bprintf - Parse a format string and place args' binary value in a buffer
+ * @out: The buffer to place args' binary value
+ * @fmt: The format string to use
+ * @...: Arguments for the format string
+ */
+void prt_bprintf(struct printbuf *out, const char *fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ prt_vbinprintf(out, fmt, args);
+ va_end(args);
+}
+EXPORT_SYMBOL_GPL(prt_bprintf);
+
+/**
+ * vbin_printf - Parse a format string and place args' binary value in a buffer
+ * @bin_buf: The buffer to place args' binary value
+ * @size: The size of the buffer(by words(32bits), not characters)
+ * @fmt: The format string to use
+ * @args: Arguments for the format string
+ *
+ * The format follows C99 vsnprintf, except %n is ignored, and its argument
+ * is skipped.
+ *
+ * The return value is the number of words(32bits) which would be generated for
+ * the given input.
+ *
+ * NOTE:
+ * If the return value is greater than @size, the resulting bin_buf is NOT
+ * valid for bstr_printf().
+ */
+int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
+{
+ struct printbuf out = PRINTBUF_EXTERN((char *) bin_buf, size);
+
+ prt_vbinprintf(&out, fmt, args);
+ return out.pos;
+}
+EXPORT_SYMBOL_GPL(vbin_printf);
+
+/**
+ * bstr_printf - Format a string from binary arguments and place it in a buffer
+ * @buf: The buffer to place the result into
+ * @size: The size of the buffer, including the trailing null space
+ * @fmt: The format string to use
+ * @bin_buf: Binary arguments for the format string
+ *
+ * This function like C99 vsnprintf, but the difference is that vsnprintf gets
+ * arguments from stack, and bstr_printf gets arguments from @bin_buf which is
+ * a binary buffer that generated by vbin_printf.
+ *
+ * The format follows C99 vsnprintf, but has some extensions:
+ * see vsnprintf comment for details.
+ *
+ * The return value is the number of characters which would
+ * be generated for the given input, excluding the trailing
+ * '\0', as per ISO C99. If you want to have the exact
+ * number of characters written into @buf as return value
+ * (not including the trailing '\0'), use vscnprintf(). If the
+ * return is greater than or equal to @size, the resulting
+ * string is truncated.
+ */
+int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
+{
+ struct printbuf out = PRINTBUF_EXTERN(buf, size);
- /* the trailing null byte doesn't count towards the total */
- return str - buf;
+ prt_bstrprintf(&out, fmt, bin_buf);
+ return out.pos;
}
EXPORT_SYMBOL_GPL(bstr_printf);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 04/32] lib/hexdump: Convert to printbuf
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (2 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 03/32] vsprintf: Convert " Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 05/32] lib/string_helpers: string_get_size() now returns characters wrote Kent Overstreet
` (16 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Mikulas Patocka
From: Kent Overstreet <kent.overstreet@gmail.com>
This converts most of the hexdump code to printbufs, along with some
significant cleanups and a bit of reorganization. The old non-printbuf
functions are mostly left as wrappers around the new printbuf versions.
Big note: byte swabbing behaviour
Previously, hex_dump_to_buffer() would byteswab the groups of bytes
being printed on little endian machines. This behaviour is... not
standard or typical for a hex dumper, and this behaviour was silently
added/changed without documentation (in 2007).
Given that the hex dumpers are just used for debugging output, nothing
is likely to break, and hopefully by reverting to more standard
behaviour the end result will be _less_ confusion, modulo a few kernel
developers who will certainly be annoyed by their tools changing.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Mikulas Patocka <mpatocka@redhat.com>
---
include/linux/kernel.h | 6 +
lib/hexdump.c | 246 ++++++++++++++++++++++++-----------------
lib/test_hexdump.c | 30 +----
3 files changed, 159 insertions(+), 123 deletions(-)
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 5c4f4b6d36..1906861ece 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -293,6 +293,12 @@ extern int hex_to_bin(unsigned char ch);
extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
extern char *bin2hex(char *dst, const void *src, size_t count);
+struct printbuf;
+void prt_hex_bytes(struct printbuf *, const void *, unsigned, unsigned, unsigned);
+void prt_hex_line(struct printbuf *, const void *, size_t, int, int, bool);
+void prt_hex_dump(struct printbuf *, const void *, size_t,
+ const char *, int, unsigned, unsigned, bool);
+
bool mac_pton(const char *s, u8 *mac);
/*
diff --git a/lib/hexdump.c b/lib/hexdump.c
index 06833d4043..9556f15ad2 100644
--- a/lib/hexdump.c
+++ b/lib/hexdump.c
@@ -9,6 +9,7 @@
#include <linux/kernel.h>
#include <linux/minmax.h>
#include <linux/export.h>
+#include <linux/printbuf.h>
#include <asm/unaligned.h>
const char hex_asc[] = "0123456789abcdef";
@@ -79,32 +80,40 @@ int hex2bin(u8 *dst, const char *src, size_t count)
EXPORT_SYMBOL(hex2bin);
/**
- * bin2hex - convert binary data to an ascii hexadecimal string
- * @dst: ascii hexadecimal result
- * @src: binary data
- * @count: binary data length
+ * prt_hex_bytes - Print a string of hex bytes, with optional separator
+ *
+ * @out: The printbuf to output to
+ * @addr: Buffer to print
+ * @nr: Number of bytes to print
+ * @separator: Optional separator character between each byte
*/
-char *bin2hex(char *dst, const void *src, size_t count)
+void prt_hex_bytes(struct printbuf *out, const void *buf, unsigned len,
+ unsigned groupsize, unsigned separator)
{
- const unsigned char *_src = src;
+ const u8 *ptr = buf;
+ unsigned i;
- while (count--)
- dst = hex_byte_pack(dst, *_src++);
- return dst;
+ if (!groupsize)
+ groupsize = 1;
+
+ for (i = 0; i < len ; ++i) {
+ if (i && separator && !(i % groupsize))
+ __prt_char(out, separator);
+ prt_hex_byte(out, ptr[i]);
+ }
}
-EXPORT_SYMBOL(bin2hex);
+EXPORT_SYMBOL(prt_hex_bytes);
/**
- * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
+ * prt_hex_line - convert a blob of data to "hex ASCII" in memory
+ * @out: printbuf to output to
* @buf: data blob to dump
* @len: number of bytes in the @buf
* @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)
- * @linebuf: where to put the converted data
- * @linebuflen: total size of @linebuf, including space for terminating NUL
* @ascii: include ASCII after the hex output
*
- * hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
+ * prt_hex_line() works on one "line" of output at a time, i.e.,
* 16 or 32 bytes of input data converted to hex + ASCII output.
*
* Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
@@ -117,22 +126,13 @@ EXPORT_SYMBOL(bin2hex);
*
* example output buffer:
* 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
- *
- * Return:
- * The amount of bytes placed in the buffer without terminating NUL. If the
- * output was truncated, then the return value is the number of bytes
- * (excluding the terminating NUL) which would have been written to the final
- * string if enough space had been available.
*/
-int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
- char *linebuf, size_t linebuflen, bool ascii)
+void prt_hex_line(struct printbuf *out, const void *buf, size_t len,
+ int rowsize, int groupsize, bool ascii)
{
+ unsigned saved_pos = out->pos;
const u8 *ptr = buf;
- int ngroups;
- u8 ch;
- int j, lx = 0;
- int ascii_column;
- int ret;
+ int i, ngroups;
if (rowsize != 16 && rowsize != 32)
rowsize = 16;
@@ -145,84 +145,127 @@ int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
groupsize = 1;
ngroups = len / groupsize;
- ascii_column = rowsize * 2 + rowsize / groupsize + 1;
-
- if (!linebuflen)
- goto overflow1;
if (!len)
- goto nil;
-
- if (groupsize == 8) {
- const u64 *ptr8 = buf;
-
- for (j = 0; j < ngroups; j++) {
- ret = snprintf(linebuf + lx, linebuflen - lx,
- "%s%16.16llx", j ? " " : "",
- get_unaligned(ptr8 + j));
- if (ret >= linebuflen - lx)
- goto overflow1;
- lx += ret;
- }
- } else if (groupsize == 4) {
- const u32 *ptr4 = buf;
-
- for (j = 0; j < ngroups; j++) {
- ret = snprintf(linebuf + lx, linebuflen - lx,
- "%s%8.8x", j ? " " : "",
- get_unaligned(ptr4 + j));
- if (ret >= linebuflen - lx)
- goto overflow1;
- lx += ret;
- }
- } else if (groupsize == 2) {
- const u16 *ptr2 = buf;
-
- for (j = 0; j < ngroups; j++) {
- ret = snprintf(linebuf + lx, linebuflen - lx,
- "%s%4.4x", j ? " " : "",
- get_unaligned(ptr2 + j));
- if (ret >= linebuflen - lx)
- goto overflow1;
- lx += ret;
- }
- } else {
- for (j = 0; j < len; j++) {
- if (linebuflen < lx + 2)
- goto overflow2;
- ch = ptr[j];
- linebuf[lx++] = hex_asc_hi(ch);
- if (linebuflen < lx + 2)
- goto overflow2;
- linebuf[lx++] = hex_asc_lo(ch);
- if (linebuflen < lx + 2)
- goto overflow2;
- linebuf[lx++] = ' ';
+ return;
+
+ prt_hex_bytes(out, ptr, len, groupsize, ' ');
+
+ if (ascii) {
+ unsigned ascii_column = rowsize * 2 + rowsize / groupsize + 1;
+
+ prt_chars(out, ' ', max_t(int, 0, ascii_column - (out->pos - saved_pos)));
+
+ for (i = 0; i < len; i++) {
+ u8 ch = ptr[i];
+ prt_char(out, isascii(ch) && isprint(ch) ? ch : '.');
}
- if (j)
- lx--;
}
- if (!ascii)
- goto nil;
+}
+EXPORT_SYMBOL(prt_hex_line);
- while (lx < ascii_column) {
- if (linebuflen < lx + 2)
- goto overflow2;
- linebuf[lx++] = ' ';
- }
- for (j = 0; j < len; j++) {
- if (linebuflen < lx + 2)
- goto overflow2;
- ch = ptr[j];
- linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';
+/**
+ * prt_hex_dump - print multiline formatted hex dump
+ * @out: printbuf to output to
+ * @buf: data blob to dump
+ * @len: number of bytes in the @buf
+ * @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)
+ * @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'
+ */
+void prt_hex_dump(struct printbuf *out, const void *buf, size_t len,
+ const char *prefix_str, int prefix_type,
+ unsigned rowsize, unsigned groupsize, bool ascii)
+{
+ const u8 *ptr = buf;
+ size_t i;
+
+ if (rowsize != 16 && rowsize != 32)
+ rowsize = 16;
+
+ for (i = 0; i < len; i += rowsize) {
+ prt_str(out, prefix_str);
+
+ switch (prefix_type) {
+ case DUMP_PREFIX_ADDRESS:
+ prt_printf(out, "%p: ", ptr + i);
+ break;
+ case DUMP_PREFIX_OFFSET:
+ prt_printf(out, "%.8zx: ", i);
+ break;
+ }
+
+ prt_hex_line(out, ptr + i, min_t(size_t, len - i, rowsize),
+ rowsize, groupsize, ascii);
+ prt_char(out, '\n');
}
-nil:
- linebuf[lx] = '\0';
- return lx;
-overflow2:
- linebuf[lx++] = '\0';
-overflow1:
- return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1;
+}
+
+/**
+ * bin2hex - convert binary data to an ascii hexadecimal string
+ * @dst: ascii hexadecimal result
+ * @src: binary data
+ * @count: binary data length
+ */
+char *bin2hex(char *dst, const void *src, size_t count)
+{
+ struct printbuf out = PRINTBUF_EXTERN(dst, count * 4);
+
+ prt_hex_bytes(&out, src, count, 0, 0);
+ return dst + out.pos;
+}
+EXPORT_SYMBOL(bin2hex);
+
+/**
+ * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
+ * @buf: data blob to dump
+ * @len: number of bytes in the @buf
+ * @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)
+ * @linebuf: where to put the converted data
+ * @linebuflen: total size of @linebuf, including space for terminating NUL
+ * @ascii: include ASCII after the hex output
+ *
+ * hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
+ * 16 or 32 bytes of input data converted to hex + ASCII output.
+ *
+ * Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
+ * to a hex + ASCII dump at the supplied memory location.
+ * The converted output is always NUL-terminated.
+ *
+ * E.g.:
+ * hex_dump_to_buffer(frame->data, frame->len, 16, 1,
+ * linebuf, sizeof(linebuf), true);
+ *
+ * example output buffer:
+ * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
+ *
+ * Return:
+ * The amount of bytes placed in the buffer without terminating NUL. If the
+ * output was truncated, then the return value is the number of bytes
+ * (excluding the terminating NUL) which would have been written to the final
+ * string if enough space had been available.
+ */
+int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
+ char *linebuf, size_t linebuflen, bool ascii)
+{
+ struct printbuf out = PRINTBUF_EXTERN(linebuf, linebuflen);
+
+ prt_hex_line(&out, buf, len, rowsize, groupsize, ascii);
+ return out.pos;
}
EXPORT_SYMBOL(hex_dump_to_buffer);
@@ -262,6 +305,11 @@ void print_hex_dump(const char *level, const char *prefix_str, int prefix_type,
int rowsize, int groupsize,
const void *buf, size_t len, bool ascii)
{
+ /*
+ * XXX: this code does the exact same thing as prt_hex_dump(): we should
+ * be able to call that and printk() the result, except printk is
+ * restricted to 1024 bytes of output per call
+ */
const u8 *ptr = buf;
int i, linelen, remaining = len;
unsigned char linebuf[32 * 3 + 2 + 32 + 1];
diff --git a/lib/test_hexdump.c b/lib/test_hexdump.c
index 5144899d3c..f9e97879dc 100644
--- a/lib/test_hexdump.c
+++ b/lib/test_hexdump.c
@@ -25,36 +25,19 @@ static const char * const test_data_1[] __initconst = {
"4c", "d1", "19", "99", "43", "b1", "af", "0c",
};
-static const char * const test_data_2_le[] __initconst = {
- "32be", "7bdb", "180a", "b293",
- "ba70", "24c4", "837d", "9b34",
- "9ca6", "ad31", "0f9c", "e9ac",
- "d14c", "9919", "b143", "0caf",
-};
-
-static const char * const test_data_2_be[] __initconst = {
+static const char * const test_data_2[] __initconst = {
"be32", "db7b", "0a18", "93b2",
"70ba", "c424", "7d83", "349b",
"a69c", "31ad", "9c0f", "ace9",
"4cd1", "1999", "43b1", "af0c",
};
-static const char * const test_data_4_le[] __initconst = {
- "7bdb32be", "b293180a", "24c4ba70", "9b34837d",
- "ad319ca6", "e9ac0f9c", "9919d14c", "0cafb143",
-};
-
-static const char * const test_data_4_be[] __initconst = {
+static const char * const test_data_4[] __initconst = {
"be32db7b", "0a1893b2", "70bac424", "7d83349b",
"a69c31ad", "9c0face9", "4cd11999", "43b1af0c",
};
-static const char * const test_data_8_le[] __initconst = {
- "b293180a7bdb32be", "9b34837d24c4ba70",
- "e9ac0f9cad319ca6", "0cafb1439919d14c",
-};
-
-static const char * const test_data_8_be[] __initconst = {
+static const char * const test_data_8[] __initconst = {
"be32db7b0a1893b2", "70bac4247d83349b",
"a69c31ad9c0face9", "4cd1199943b1af0c",
};
@@ -73,7 +56,6 @@ static void __init test_hexdump_prepare_test(size_t len, int rowsize,
size_t l = len;
int gs = groupsize, rs = rowsize;
unsigned int i;
- const bool is_be = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN);
if (rs != 16 && rs != 32)
rs = 16;
@@ -85,11 +67,11 @@ static void __init test_hexdump_prepare_test(size_t len, int rowsize,
gs = 1;
if (gs == 8)
- result = is_be ? test_data_8_be : test_data_8_le;
+ result = test_data_8;
else if (gs == 4)
- result = is_be ? test_data_4_be : test_data_4_le;
+ result = test_data_4;
else if (gs == 2)
- result = is_be ? test_data_2_be : test_data_2_le;
+ result = test_data_2;
else
result = test_data_1;
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 05/32] lib/string_helpers: string_get_size() now returns characters wrote
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (3 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 04/32] lib/hexdump: " Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 06/32] lib/printbuf: Heap allocation Kent Overstreet
` (15 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Andy Shevchenko
From: Kent Overstreet <kent.overstreet@gmail.com>
printbuf now needs to know the number of characters that would have been
written if the buffer was too small, like snprintf(); this changes
string_get_size() to return the return value of snprintf().
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Andy Shevchenko <andy@kernel.org>
Acked-by: Andy Shevchenko <andy@kernel.org>
---
include/linux/string_helpers.h | 4 ++--
lib/string_helpers.c | 7 +++----
2 files changed, 5 insertions(+), 6 deletions(-)
diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h
index c048eaec08..ae4383f0fe 100644
--- a/include/linux/string_helpers.h
+++ b/include/linux/string_helpers.h
@@ -19,8 +19,8 @@ enum string_size_units {
STRING_UNITS_2, /* use binary powers of 2^10 */
};
-void string_get_size(u64 size, u64 blk_size, enum string_size_units units,
- char *buf, int len);
+int string_get_size(u64 size, u64 blk_size, enum string_size_units units,
+ char *buf, int len);
#define UNESCAPE_SPACE BIT(0)
#define UNESCAPE_OCTAL BIT(1)
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index b366c660e6..a48c6a1cdd 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -33,8 +33,8 @@
* at least 9 bytes and will always be zero terminated.
*
*/
-void string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
- char *buf, int len)
+int string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
+ char *buf, int len)
{
static const char *const units_10[] = {
"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
@@ -127,8 +127,7 @@ void string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
else
unit = units_str[units][i];
- snprintf(buf, len, "%u%s %s", (u32)size,
- tmp, unit);
+ return snprintf(buf, len, "%u%s %s", (u32)size, tmp, unit);
}
EXPORT_SYMBOL(string_get_size);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 06/32] lib/printbuf: Heap allocation
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (4 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 05/32] lib/string_helpers: string_get_size() now returns characters wrote Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 07/32] lib/printbuf: Tabstops, indenting Kent Overstreet
` (14 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet
From: Kent Overstreet <kent.overstreet@gmail.com>
This makes printbufs optionally heap allocated: a printbuf initialized
with the PRINTBUF initializer will automatically heap allocate and
resize as needed.
Allocations are done with GFP_KERNEL: code should use e.g.
memalloc_nofs_save()/restore() as needed. Since we do not currently have
memalloc_nowait_save()/restore(), in contexts where it is not safe to
block we provide the helpers
printbuf_atomic_inc()
printbuf_atomic_dec()
When the atomic count is nonzero, memory allocations will be done with
GFP_NOWAIT.
On memory allocation failure, output will be truncated. Code that wishes
to check for memory allocation failure (in contexts where we should
return -ENOMEM) should check if printbuf->allocation_failure is set.
Since printbufs are expected to be typically used for log messages and
on a best effort basis, we don't return errors directly.
Other helpers provided by this patch:
- printbuf_make_room(buf, extra)
Reallocates if necessary to make room for @extra bytes (not including
terminating null).
- printbuf_str(buf)
Returns a null terminated string equivalent to the contents of @buf.
If @buf was never allocated (or allocation failed), returns a
constant empty string.
- printbuf_exit(buf)
Releases memory allocated by a printbuf.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
include/linux/printbuf.h | 124 +++++++++++++++++++++++++++++++++------
lib/Makefile | 2 +-
lib/printbuf.c | 76 ++++++++++++++++++++++++
3 files changed, 184 insertions(+), 18 deletions(-)
create mode 100644 lib/printbuf.c
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
index 1aa3331bf0..71f631c49f 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -4,19 +4,73 @@
#ifndef _LINUX_PRINTBUF_H
#define _LINUX_PRINTBUF_H
-#include <linux/kernel.h>
-#include <linux/string.h>
-
/*
- * Printbufs: String buffer for outputting (printing) to, for vsnprintf
+ * Printbufs: Simple strings for printing to, with optional heap allocation
+ *
+ * This code has provisions for use in userspace, to aid in making other code
+ * portable between kernelspace and userspace.
+ *
+ * Basic example:
+ * struct printbuf buf = PRINTBUF;
+ *
+ * prt_printf(&buf, "foo=");
+ * foo_to_text(&buf, foo);
+ * printk("%s", buf.buf);
+ * printbuf_exit(&buf);
+ *
+ * Or
+ * struct printbuf buf = PRINTBUF_EXTERN(char_buf, char_buf_size)
+ *
+ * We can now write pretty printers instead of writing code that dumps
+ * everything to the kernel log buffer, and then those pretty-printers can be
+ * used by other code that outputs to kernel log, sysfs, debugfs, etc.
+ *
+ * Memory allocation: Outputing to a printbuf may allocate memory. This
+ * allocation is done with GFP_KERNEL, by default: use the newer
+ * memalloc_*_(save|restore) functions as needed.
+ *
+ * Since no equivalent yet exists for GFP_ATOMIC/GFP_NOWAIT, memory allocations
+ * will be done with GFP_NOWAIT if printbuf->atomic is nonzero.
+ *
+ * It's allowed to grab the output buffer and free it later with kfree() instead
+ * of using printbuf_exit(), if the user just needs a heap allocated string at
+ * the end.
+ *
+ * Memory allocation failures: We don't return errors directly, because on
+ * memory allocation failure we usually don't want to bail out and unwind - we
+ * want to print what we've got, on a best-effort basis. But code that does want
+ * to return -ENOMEM may check printbuf.allocation_failure.
*/
+#include <linux/kernel.h>
+#include <linux/string.h>
+
struct printbuf {
char *buf;
unsigned size;
unsigned pos;
+ /*
+ * If nonzero, allocations will be done with GFP_ATOMIC:
+ */
+ u8 atomic;
+ bool allocation_failure:1;
+ bool heap_allocated:1;
};
+int printbuf_make_room(struct printbuf *, unsigned);
+const char *printbuf_str(const struct printbuf *);
+void printbuf_exit(struct printbuf *);
+
+/* Initializer for a heap allocated printbuf: */
+#define PRINTBUF ((struct printbuf) { .heap_allocated = true })
+
+/* Initializer a printbuf that points to an external buffer: */
+#define PRINTBUF_EXTERN(_buf, _size) \
+((struct printbuf) { \
+ .buf = _buf, \
+ .size = _size, \
+})
+
/*
* Returns size remaining of output buffer:
*/
@@ -49,26 +103,36 @@ static inline bool printbuf_overflowed(struct printbuf *out)
static inline void printbuf_nul_terminate(struct printbuf *out)
{
+ printbuf_make_room(out, 1);
+
if (out->pos < out->size)
out->buf[out->pos] = 0;
else if (out->size)
out->buf[out->size - 1] = 0;
}
-static inline void __prt_char(struct printbuf *out, char c)
+/* Doesn't call printbuf_make_room(), doesn't nul terminate: */
+static inline void __prt_char_reserved(struct printbuf *out, char c)
{
if (printbuf_remaining(out))
out->buf[out->pos] = c;
out->pos++;
}
+/* Doesn't nul terminate: */
+static inline void __prt_char(struct printbuf *out, char c)
+{
+ printbuf_make_room(out, 1);
+ __prt_char_reserved(out, c);
+}
+
static inline void prt_char(struct printbuf *out, char c)
{
__prt_char(out, c);
printbuf_nul_terminate(out);
}
-static inline void __prt_chars(struct printbuf *out, char c, unsigned n)
+static inline void __prt_chars_reserved(struct printbuf *out, char c, unsigned n)
{
unsigned i, can_print = min(n, printbuf_remaining(out));
@@ -79,13 +143,18 @@ static inline void __prt_chars(struct printbuf *out, char c, unsigned n)
static inline void prt_chars(struct printbuf *out, char c, unsigned n)
{
- __prt_chars(out, c, n);
+ printbuf_make_room(out, n);
+ __prt_chars_reserved(out, c, n);
printbuf_nul_terminate(out);
}
static inline void prt_bytes(struct printbuf *out, const void *b, unsigned n)
{
- unsigned i, can_print = min(n, printbuf_remaining(out));
+ unsigned i, can_print;
+
+ printbuf_make_room(out, n);
+
+ can_print = min(n, printbuf_remaining(out));
for (i = 0; i < can_print; i++)
out->buf[out->pos++] = ((char *) b)[i];
@@ -101,22 +170,43 @@ static inline void prt_str(struct printbuf *out, const char *str)
static inline void prt_hex_byte(struct printbuf *out, u8 byte)
{
- __prt_char(out, hex_asc_hi(byte));
- __prt_char(out, hex_asc_lo(byte));
+ printbuf_make_room(out, 2);
+ __prt_char_reserved(out, hex_asc_hi(byte));
+ __prt_char_reserved(out, hex_asc_lo(byte));
printbuf_nul_terminate(out);
}
static inline void prt_hex_byte_upper(struct printbuf *out, u8 byte)
{
- __prt_char(out, hex_asc_upper_hi(byte));
- __prt_char(out, hex_asc_upper_lo(byte));
+ printbuf_make_room(out, 2);
+ __prt_char_reserved(out, hex_asc_upper_hi(byte));
+ __prt_char_reserved(out, hex_asc_upper_lo(byte));
printbuf_nul_terminate(out);
}
-#define PRINTBUF_EXTERN(_buf, _size) \
-((struct printbuf) { \
- .buf = _buf, \
- .size = _size, \
-})
+/**
+ * printbuf_reset - re-use a printbuf without freeing and re-initializing it:
+ */
+static inline void printbuf_reset(struct printbuf *buf)
+{
+ buf->pos = 0;
+ buf->allocation_failure = 0;
+}
+
+/**
+ * printbuf_atomic_inc - mark as entering an atomic section
+ */
+static inline void printbuf_atomic_inc(struct printbuf *buf)
+{
+ buf->atomic++;
+}
+
+/**
+ * printbuf_atomic_inc - mark as leaving an atomic section
+ */
+static inline void printbuf_atomic_dec(struct printbuf *buf)
+{
+ buf->atomic--;
+}
#endif /* _LINUX_PRINTBUF_H */
diff --git a/lib/Makefile b/lib/Makefile
index 17e48da223..d44f8d03d6 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -34,7 +34,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
is_single_threaded.o plist.o decompress.o kobject_uevent.o \
earlycpio.o seq_buf.o siphash.o dec_and_lock.o \
nmi_backtrace.o nodemask.o win_minmax.o memcat_p.o \
- buildid.o cpumask.o
+ buildid.o cpumask.o printbuf.o
lib-$(CONFIG_PRINTK) += dump_stack.o
diff --git a/lib/printbuf.c b/lib/printbuf.c
new file mode 100644
index 0000000000..e3e5a791b2
--- /dev/null
+++ b/lib/printbuf.c
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: LGPL-2.1+
+/* Copyright (C) 2022 Kent Overstreet */
+
+#ifdef __KERNEL__
+#include <linux/export.h>
+#include <linux/kernel.h>
+#else
+#define EXPORT_SYMBOL(x)
+#endif
+
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/printbuf.h>
+
+int printbuf_make_room(struct printbuf *out, unsigned extra)
+{
+ unsigned new_size;
+ char *buf;
+
+ if (!out->heap_allocated)
+ return 0;
+
+ /* Reserved space for terminating nul: */
+ extra += 1;
+
+ if (out->pos + extra < out->size)
+ return 0;
+
+ new_size = roundup_pow_of_two(out->size + extra);
+
+ /*
+ * Note: output buffer must be freeable with kfree(), it's not required
+ * that the user use printbuf_exit().
+ */
+ buf = krealloc(out->buf, new_size, !out->atomic ? GFP_KERNEL : GFP_NOWAIT);
+
+ if (!buf) {
+ out->allocation_failure = true;
+ return -ENOMEM;
+ }
+
+ out->buf = buf;
+ out->size = new_size;
+ return 0;
+}
+EXPORT_SYMBOL(printbuf_make_room);
+
+/**
+ * printbuf_str - returns printbuf's buf as a C string, guaranteed to be null
+ * terminated
+ */
+const char *printbuf_str(const struct printbuf *buf)
+{
+ /*
+ * If we've written to a printbuf then it's guaranteed to be a null
+ * terminated string - but if we haven't, then we might not have
+ * allocated a buffer at all:
+ */
+ return buf->pos
+ ? buf->buf
+ : "";
+}
+EXPORT_SYMBOL(printbuf_str);
+
+/**
+ * printbuf_exit - exit a printbuf, freeing memory it owns and poisoning it
+ * against accidental use.
+ */
+void printbuf_exit(struct printbuf *buf)
+{
+ if (buf->heap_allocated) {
+ kfree(buf->buf);
+ buf->buf = ERR_PTR(-EINTR); /* poison value */
+ }
+}
+EXPORT_SYMBOL(printbuf_exit);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 07/32] lib/printbuf: Tabstops, indenting
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (5 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 06/32] lib/printbuf: Heap allocation Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 08/32] lib/printbuf: Unit specifiers Kent Overstreet
` (13 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet
From: Kent Overstreet <kent.overstreet@gmail.com>
This patch adds two new features to printbuf for structured formatting:
- Indent level: the indent level, as a number of spaces, may be
increased with pr_indent_add() and decreased with pr_indent_sub().
Subsequent lines, when started with pr_newline() (not "\n", although
that may change) will then be intended according to the current
indent level. This helps with pretty-printers that structure a large
amonut of data across multiple lines and multiple functions.
- Tabstops: Tabstops may be set by assigning to the printbuf->tabstops
array.
Then, pr_tab() may be used to advance to the next tabstop, printing
as many spaces as required - leaving previous output left justified
to the previous tabstop. pr_tab_rjust() advances to the next tabstop
but inserts the spaces just after the previous tabstop - right
justifying the previously-outputted text to the next tabstop.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
include/linux/printbuf.h | 30 ++++++++++
lib/printbuf.c | 125 +++++++++++++++++++++++++++++++++++++++
2 files changed, 155 insertions(+)
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
index 71f631c49f..c1a482b6c0 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -40,6 +40,23 @@
* memory allocation failure we usually don't want to bail out and unwind - we
* want to print what we've got, on a best-effort basis. But code that does want
* to return -ENOMEM may check printbuf.allocation_failure.
+ *
+ * Indenting, tabstops:
+ *
+ * To aid is writing multi-line pretty printers spread across multiple
+ * functions, printbufs track the current indent level.
+ *
+ * printbuf_indent_push() and printbuf_indent_pop() increase and decrease the current indent
+ * level, respectively.
+ *
+ * To use tabstops, set printbuf->tabstops[]; they are in units of spaces, from
+ * start of line. Once set, prt_tab() will output spaces up to the next tabstop.
+ * prt_tab_rjust() will also advance the current line of text up to the next
+ * tabstop, but it does so by shifting text since the previous tabstop up to the
+ * next tabstop - right justifying it.
+ *
+ * Make sure you use prt_newline() instead of \n in the format string for indent
+ * level and tabstops to work corretly.
*/
#include <linux/kernel.h>
@@ -49,18 +66,29 @@ struct printbuf {
char *buf;
unsigned size;
unsigned pos;
+ unsigned last_newline;
+ unsigned last_field;
+ unsigned indent;
/*
* If nonzero, allocations will be done with GFP_ATOMIC:
*/
u8 atomic;
bool allocation_failure:1;
bool heap_allocated:1;
+ u8 tabstop;
+ u8 tabstops[4];
};
int printbuf_make_room(struct printbuf *, unsigned);
const char *printbuf_str(const struct printbuf *);
void printbuf_exit(struct printbuf *);
+void prt_newline(struct printbuf *);
+void printbuf_indent_add(struct printbuf *, unsigned);
+void printbuf_indent_sub(struct printbuf *, unsigned);
+void prt_tab(struct printbuf *);
+void prt_tab_rjust(struct printbuf *);
+
/* Initializer for a heap allocated printbuf: */
#define PRINTBUF ((struct printbuf) { .heap_allocated = true })
@@ -191,6 +219,8 @@ static inline void printbuf_reset(struct printbuf *buf)
{
buf->pos = 0;
buf->allocation_failure = 0;
+ buf->indent = 0;
+ buf->tabstop = 0;
}
/**
diff --git a/lib/printbuf.c b/lib/printbuf.c
index e3e5a791b2..395c681e3a 100644
--- a/lib/printbuf.c
+++ b/lib/printbuf.c
@@ -12,6 +12,11 @@
#include <linux/slab.h>
#include <linux/printbuf.h>
+static inline size_t printbuf_linelen(struct printbuf *buf)
+{
+ return buf->pos - buf->last_newline;
+}
+
int printbuf_make_room(struct printbuf *out, unsigned extra)
{
unsigned new_size;
@@ -74,3 +79,123 @@ void printbuf_exit(struct printbuf *buf)
}
}
EXPORT_SYMBOL(printbuf_exit);
+
+void prt_newline(struct printbuf *buf)
+{
+ unsigned i;
+
+ printbuf_make_room(buf, 1 + buf->indent);
+
+ __prt_char(buf, '\n');
+
+ buf->last_newline = buf->pos;
+
+ for (i = 0; i < buf->indent; i++)
+ __prt_char(buf, ' ');
+
+ printbuf_nul_terminate(buf);
+
+ buf->last_field = buf->pos;
+ buf->tabstop = 0;
+}
+EXPORT_SYMBOL(prt_newline);
+
+/**
+ * printbuf_indent_add - add to the current indent level
+ *
+ * @buf: printbuf to control
+ * @spaces: number of spaces to add to the current indent level
+ *
+ * Subsequent lines, and the current line if the output position is at the start
+ * of the current line, will be indented by @spaces more spaces.
+ */
+void printbuf_indent_add(struct printbuf *buf, unsigned spaces)
+{
+ if (WARN_ON_ONCE(buf->indent + spaces < buf->indent))
+ spaces = 0;
+
+ buf->indent += spaces;
+ while (spaces--)
+ prt_char(buf, ' ');
+}
+EXPORT_SYMBOL(printbuf_indent_add);
+
+/**
+ * printbuf_indent_sub - subtract from the current indent level
+ *
+ * @buf: printbuf to control
+ * @spaces: number of spaces to subtract from the current indent level
+ *
+ * Subsequent lines, and the current line if the output position is at the start
+ * of the current line, will be indented by @spaces less spaces.
+ */
+void printbuf_indent_sub(struct printbuf *buf, unsigned spaces)
+{
+ if (WARN_ON_ONCE(spaces > buf->indent))
+ spaces = buf->indent;
+
+ if (buf->last_newline + buf->indent == buf->pos) {
+ buf->pos -= spaces;
+ printbuf_nul_terminate(buf);
+ }
+ buf->indent -= spaces;
+}
+EXPORT_SYMBOL(printbuf_indent_sub);
+
+/**
+ * prt_tab - Advance printbuf to the next tabstop
+ *
+ * @buf: printbuf to control
+ *
+ * Advance output to the next tabstop by printing spaces.
+ */
+void prt_tab(struct printbuf *out)
+{
+ int spaces = max_t(int, 0, out->tabstops[out->tabstop] - printbuf_linelen(out));
+
+ BUG_ON(out->tabstop > ARRAY_SIZE(out->tabstops));
+
+ prt_chars(out, ' ', spaces);
+
+ out->last_field = out->pos;
+ out->tabstop++;
+}
+EXPORT_SYMBOL(prt_tab);
+
+/**
+ * prt_tab_rjust - Advance printbuf to the next tabstop, right justifying
+ * previous output
+ *
+ * @buf: printbuf to control
+ *
+ * Advance output to the next tabstop by inserting spaces immediately after the
+ * previous tabstop, right justifying previously outputted text.
+ */
+void prt_tab_rjust(struct printbuf *buf)
+{
+ BUG_ON(buf->tabstop > ARRAY_SIZE(buf->tabstops));
+
+ if (printbuf_linelen(buf) < buf->tabstops[buf->tabstop]) {
+ unsigned move = buf->pos - buf->last_field;
+ unsigned shift = buf->tabstops[buf->tabstop] -
+ printbuf_linelen(buf);
+
+ printbuf_make_room(buf, shift);
+
+ if (buf->last_field + shift < buf->size)
+ memmove(buf->buf + buf->last_field + shift,
+ buf->buf + buf->last_field,
+ min(move, buf->size - 1 - buf->last_field - shift));
+
+ if (buf->last_field < buf->size)
+ memset(buf->buf + buf->last_field, ' ',
+ min(shift, buf->size - buf->last_field));
+
+ buf->pos += shift;
+ printbuf_nul_terminate(buf);
+ }
+
+ buf->last_field = buf->pos;
+ buf->tabstop++;
+}
+EXPORT_SYMBOL(prt_tab_rjust);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 08/32] lib/printbuf: Unit specifiers
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (6 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 07/32] lib/printbuf: Tabstops, indenting Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 09/32] vsprintf: Improve number() Kent Overstreet
` (12 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet
From: Kent Overstreet <kent.overstreet@gmail.com>
This adds options to printbuf for specifying whether units should be
printed raw (default) or with human readable units, and for controlling
whether human-readable units should be base 2 (default), or base 10.
This also adds new helpers that obey these options:
- pr_human_readable_u64
- pr_human_readable_s64
These obey printbuf->si_units
- pr_units_u64
- pr_units_s64
These obey both printbuf-human_readable_units and printbuf->si_units
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
include/linux/printbuf.h | 15 +++++++++++
lib/printbuf.c | 57 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 72 insertions(+)
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
index c1a482b6c0..ebbc4a55fc 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -57,11 +57,20 @@
*
* Make sure you use prt_newline() instead of \n in the format string for indent
* level and tabstops to work corretly.
+ *
+ * Output units: printbuf->units exists to tell pretty-printers how to output
+ * numbers: a raw value (e.g. directly from a superblock field), as bytes, or as
+ * human readable bytes. prt_units() obeys it.
*/
#include <linux/kernel.h>
#include <linux/string.h>
+enum printbuf_si {
+ PRINTBUF_UNITS_2, /* use binary powers of 2^10 */
+ PRINTBUF_UNITS_10, /* use powers of 10^3 (standard SI) */
+};
+
struct printbuf {
char *buf;
unsigned size;
@@ -75,6 +84,8 @@ struct printbuf {
u8 atomic;
bool allocation_failure:1;
bool heap_allocated:1;
+ enum printbuf_si si_units:1;
+ bool human_readable_units:1;
u8 tabstop;
u8 tabstops[4];
};
@@ -88,6 +99,10 @@ void printbuf_indent_add(struct printbuf *, unsigned);
void printbuf_indent_sub(struct printbuf *, unsigned);
void prt_tab(struct printbuf *);
void prt_tab_rjust(struct printbuf *);
+void prt_human_readable_u64(struct printbuf *, u64);
+void prt_human_readable_s64(struct printbuf *, s64);
+void prt_units_u64(struct printbuf *, u64);
+void prt_units_s64(struct printbuf *, s64);
/* Initializer for a heap allocated printbuf: */
#define PRINTBUF ((struct printbuf) { .heap_allocated = true })
diff --git a/lib/printbuf.c b/lib/printbuf.c
index 395c681e3a..0474700257 100644
--- a/lib/printbuf.c
+++ b/lib/printbuf.c
@@ -10,6 +10,7 @@
#include <linux/err.h>
#include <linux/slab.h>
+#include <linux/string_helpers.h>
#include <linux/printbuf.h>
static inline size_t printbuf_linelen(struct printbuf *buf)
@@ -199,3 +200,59 @@ void prt_tab_rjust(struct printbuf *buf)
buf->tabstop++;
}
EXPORT_SYMBOL(prt_tab_rjust);
+
+/**
+ * prt_human_readable_u64 - Print out a u64 in human readable units
+ *
+ * Units of 2^10 (default) or 10^3 are controlled via @buf->si_units
+ */
+void prt_human_readable_u64(struct printbuf *buf, u64 v)
+{
+ printbuf_make_room(buf, 10);
+ buf->pos += string_get_size(v, 1, !buf->si_units,
+ buf->buf + buf->pos,
+ printbuf_remaining_size(buf));
+}
+EXPORT_SYMBOL(prt_human_readable_u64);
+
+/**
+ * prt_human_readable_s64 - Print out a s64 in human readable units
+ *
+ * Units of 2^10 (default) or 10^3 are controlled via @buf->si_units
+ */
+void prt_human_readable_s64(struct printbuf *buf, s64 v)
+{
+ if (v < 0)
+ prt_char(buf, '-');
+ prt_human_readable_u64(buf, abs(v));
+}
+EXPORT_SYMBOL(prt_human_readable_s64);
+
+/**
+ * prt_units_u64 - Print out a u64 according to printbuf unit options
+ *
+ * Units are either raw (default), or human reabable units (controlled via
+ * @buf->human_readable_units)
+ */
+void prt_units_u64(struct printbuf *out, u64 v)
+{
+ if (out->human_readable_units)
+ prt_human_readable_u64(out, v);
+ else
+ prt_printf(out, "%llu", v);
+}
+EXPORT_SYMBOL(prt_units_u64);
+
+/**
+ * prt_units_s64 - Print out a s64 according to printbuf unit options
+ *
+ * Units are either raw (default), or human reabable units (controlled via
+ * @buf->human_readable_units)
+ */
+void prt_units_s64(struct printbuf *out, s64 v)
+{
+ if (v < 0)
+ prt_char(out, '-');
+ prt_units_u64(out, abs(v));
+}
+EXPORT_SYMBOL(prt_units_s64);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 09/32] vsprintf: Improve number()
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (7 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 08/32] lib/printbuf: Unit specifiers Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 10/32] vsprintf: prt_u64_minwidth(), prt_u64() Kent Overstreet
` (11 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
This patch refactors number() to make it a bit clearer, and it also
changes it to call printbuf_make_room() only once at the start, instead
of in the printbuf output helpers.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 83 +++++++++++++++++++++++++-------------------------
1 file changed, 41 insertions(+), 42 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 52dac8519a..87adc528c6 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -457,93 +457,92 @@ void number(struct printbuf *out, unsigned long long num,
{
/* put_dec requires 2-byte alignment of the buffer. */
char tmp[3 * sizeof(num)] __aligned(2);
- char sign;
- char locase;
+ char sign = 0;
+ /* locase = 0 or 0x20. ORing digits or letters with 'locase'
+ * produces same digits or (maybe lowercased) letters */
+ char locase = (spec.flags & SMALL);
int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
- int i;
bool is_zero = num == 0LL;
int field_width = spec.field_width;
int precision = spec.precision;
+ int nr_digits = 0;
+ int output_bytes = 0;
- /* locase = 0 or 0x20. ORing digits or letters with 'locase'
- * produces same digits or (maybe lowercased) letters */
- locase = (spec.flags & SMALL);
if (spec.flags & LEFT)
spec.flags &= ~ZEROPAD;
- sign = 0;
if (spec.flags & SIGN) {
if ((signed long long)num < 0) {
sign = '-';
num = -(signed long long)num;
- field_width--;
+ output_bytes++;
} else if (spec.flags & PLUS) {
sign = '+';
- field_width--;
+ output_bytes++;
} else if (spec.flags & SPACE) {
sign = ' ';
- field_width--;
+ output_bytes++;
}
}
if (need_pfx) {
if (spec.base == 16)
- field_width -= 2;
+ output_bytes += 2;
else if (!is_zero)
- field_width--;
+ output_bytes++;
}
/* generate full string in tmp[], in reverse order */
- i = 0;
- if (num < spec.base)
- tmp[i++] = hex_asc_upper[num] | locase;
- else if (spec.base != 10) { /* 8 or 16 */
+ if (spec.base == 10) {
+ nr_digits = put_dec(tmp, num) - tmp;
+ } else { /* 8 or 16 */
int mask = spec.base - 1;
- int shift = 3;
+ int shift = ilog2((unsigned) spec.base);
- if (spec.base == 16)
- shift = 4;
do {
- tmp[i++] = (hex_asc_upper[((unsigned char)num) & mask] | locase);
+ tmp[nr_digits++] = (hex_asc_upper[((unsigned char)num) & mask] | locase);
num >>= shift;
} while (num);
- } else { /* base 10 */
- i = put_dec(tmp, num) - tmp;
}
/* printing 100 using %2d gives "100", not "00" */
- if (i > precision)
- precision = i;
+ precision = max(nr_digits, precision);
+ output_bytes += precision;
+ field_width = max(0, field_width - output_bytes);
+
+ printbuf_make_room(out, field_width + output_bytes);
+
/* leading space padding */
- field_width = max(0, field_width - precision);
if (!(spec.flags & (ZEROPAD | LEFT)) && field_width) {
- __prt_chars(out, ' ', field_width);
+ __prt_chars_reserved(out, ' ', field_width);
field_width = 0;
}
+
/* sign */
if (sign)
- __prt_char(out, sign);
+ __prt_char_reserved(out, sign);
+
/* "0x" / "0" prefix */
if (need_pfx) {
if (spec.base == 16 || !is_zero)
- __prt_char(out, '0');
+ __prt_char_reserved(out, '0');
if (spec.base == 16)
- __prt_char(out, 'X' | locase);
+ __prt_char_reserved(out, 'X' | locase);
}
- /* zero or space padding */
- if (!(spec.flags & LEFT) && field_width) {
- char c = ' ' + (spec.flags & ZEROPAD);
- __prt_chars(out, c, field_width);
- field_width = 0;
- }
- /* hmm even more zero padding? */
- if (precision > i)
- __prt_chars(out, '0', precision - i);
+ /* zero padding */
+ if (!(spec.flags & LEFT) && field_width)
+ __prt_chars_reserved(out, '0', field_width);
+
+ /* zero padding from precision */
+ if (precision > nr_digits)
+ __prt_chars_reserved(out, '0', precision - nr_digits);
+
/* actual digits of result */
- while (--i >= 0)
- __prt_char(out, tmp[i]);
+ while (--nr_digits >= 0)
+ __prt_char_reserved(out, tmp[nr_digits]);
+
/* trailing space padding */
- if (field_width)
- __prt_chars(out, ' ', field_width);
+ if ((spec.flags & LEFT) && field_width)
+ __prt_chars_reserved(out, ' ', field_width);
printbuf_nul_terminate(out);
}
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 10/32] vsprintf: prt_u64_minwidth(), prt_u64()
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (8 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 09/32] vsprintf: Improve number() Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 11/32] test_printf: Drop requirement that sprintf not write past nul Kent Overstreet
` (10 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
This adds two new-style printbuf helpers for printing simple u64s, and
converts num_to_str() to be a simple wrapper around prt_u64_minwidth().
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
include/linux/kernel.h | 4 +-
lib/vsprintf.c | 94 ++++++++++++++++++++----------------------
2 files changed, 48 insertions(+), 50 deletions(-)
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 1906861ece..9ba5a53c6a 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -202,12 +202,14 @@ static inline void might_fault(void) { }
void do_exit(long error_code) __noreturn;
+struct printbuf;
+extern void prt_u64_minwidth(struct printbuf *out, u64 num, unsigned width);
+extern void prt_u64(struct printbuf *out, u64 num);
extern int num_to_str(char *buf, int size,
unsigned long long num, unsigned int width);
/* lib/printf utilities */
-struct printbuf;
extern __printf(2, 3) void prt_printf(struct printbuf *out, const char *fmt, ...);
extern __printf(2, 0) void prt_vprintf(struct printbuf *out, const char *fmt, va_list);
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 87adc528c6..d389f74071 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -368,41 +368,51 @@ char *put_dec(char *buf, unsigned long long n)
#endif
-/*
- * Convert passed number to decimal string.
- * Returns the length of string. On buffer overflow, returns 0.
- *
- * If speed is not important, use snprintf(). It's easy to read the code.
+/**
+ * prt_u64_minwidth - print a u64, in decimal, with zero padding
+ * @out: printbuf to output to
+ * @num: u64 to print
+ * @width: minimum width
*/
-int num_to_str(char *buf, int size, unsigned long long num, unsigned int width)
+void prt_u64_minwidth(struct printbuf *out, u64 num, unsigned width)
{
/* put_dec requires 2-byte alignment of the buffer. */
char tmp[sizeof(num) * 3] __aligned(2);
- int idx, len;
+ unsigned len = put_dec(tmp, num) - tmp;
- /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
- if (num <= 9) {
- tmp[0] = '0' + num;
- len = 1;
- } else {
- len = put_dec(tmp, num) - tmp;
- }
+ printbuf_make_room(out, max(len, width));
- if (len > size || width > size)
- return 0;
+ if (width > len)
+ __prt_chars_reserved(out, ' ', width - len);
- if (width > len) {
- width = width - len;
- for (idx = 0; idx < width; idx++)
- buf[idx] = ' ';
- } else {
- width = 0;
- }
+ while (len)
+ __prt_char_reserved(out, tmp[--len]);
+ printbuf_nul_terminate(out);
+}
- for (idx = 0; idx < len; ++idx)
- buf[idx + width] = tmp[len - idx - 1];
+/**
+ * prt_u64 - print a simple u64, in decimal
+ * @out: printbuf to output to
+ * @num: u64 to print
+ */
+void prt_u64(struct printbuf *out, u64 num)
+{
+ prt_u64_minwidth(out, num, 0);
+}
- return len + width;
+/*
+ * Convert passed number to decimal string.
+ * Returns the length of string. On buffer overflow, returns 0.
+ *
+ * Consider switching to printbufs and using prt_u64() or prt_u64_minwith()
+ * instead.
+ */
+int num_to_str(char *buf, int size, unsigned long long num, unsigned int width)
+{
+ struct printbuf out = PRINTBUF_EXTERN(buf, size);
+
+ prt_u64_minwidth(&out, num, width);
+ return out.pos;
}
#define SIGN 1 /* unsigned/signed, must be 1 */
@@ -993,20 +1003,6 @@ static const struct printf_spec default_dec_spec = {
.precision = -1,
};
-static const struct printf_spec default_dec02_spec = {
- .base = 10,
- .field_width = 2,
- .precision = -1,
- .flags = ZEROPAD,
-};
-
-static const struct printf_spec default_dec04_spec = {
- .base = 10,
- .field_width = 4,
- .precision = -1,
- .flags = ZEROPAD,
-};
-
static noinline_for_stack
void resource_string(struct printbuf *out, struct resource *res,
struct printf_spec spec, const char *fmt)
@@ -1206,12 +1202,12 @@ void bitmap_list_string(struct printbuf *out, unsigned long *bitmap,
prt_char(out, ',');
first = false;
- number(out, rbot, default_dec_spec);
+ prt_u64(out, rbot);
if (rtop == rbot + 1)
continue;
prt_char(out, '-');
- number(out, rtop - 1, default_dec_spec);
+ prt_u64(out, rtop - 1);
}
}
@@ -1753,21 +1749,21 @@ void date_str(struct printbuf *out,
int year = tm->tm_year + (r ? 0 : 1900);
int mon = tm->tm_mon + (r ? 0 : 1);
- number(out, year, default_dec04_spec);
+ prt_u64_minwidth(out, year, 4);
prt_char(out, '-');
- number(out, mon, default_dec02_spec);
+ prt_u64_minwidth(out, mon, 2);
prt_char(out, '-');
- number(out, tm->tm_mday, default_dec02_spec);
+ prt_u64_minwidth(out, tm->tm_mday, 2);
}
static noinline_for_stack
void time_str(struct printbuf *out, const struct rtc_time *tm, bool r)
{
- number(out, tm->tm_hour, default_dec02_spec);
+ prt_u64_minwidth(out, tm->tm_hour, 2);
prt_char(out, ':');
- number(out, tm->tm_min, default_dec02_spec);
+ prt_u64_minwidth(out, tm->tm_min, 2);
prt_char(out, ':');
- number(out, tm->tm_sec, default_dec02_spec);
+ prt_u64_minwidth(out, tm->tm_sec, 2);
}
static noinline_for_stack
@@ -2045,7 +2041,7 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
str_spec.precision = precision;
break;
case 'p': /* phandle */
- number(out, (unsigned int)dn->phandle, default_dec_spec);
+ prt_u64(out, (unsigned int)dn->phandle);
break;
case 'P': /* path-spec */
p = fwnode_get_name(of_fwnode_handle(dn));
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 11/32] test_printf: Drop requirement that sprintf not write past nul
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (9 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 10/32] vsprintf: prt_u64_minwidth(), prt_u64() Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 12/32] vsprintf: Start consolidating printf_spec handling Kent Overstreet
` (9 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
The current test code checks that sprintf never writes past the
terminating nul. This is a rather strange requirement, completely
separate from writing past the end of the buffer, which of course we
can't do: writing anywhere to the buffer passed to snprintf, within size
of course, should be perfectly fine.
Since this check has no documentation as to where it comes from or what
depends on it, and it's getting in the way of further refactoring
(printf_spec handling is right now scattered massively throughout the
code, and we'd like to consolidate it) - delete it.
Also, many current pretty-printers building up their output on the
stack, and then copy it to the actual output buffer - by eliminating
this requirement we can kill those extra buffers.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/test_printf.c | 6 ------
1 file changed, 6 deletions(-)
diff --git a/lib/test_printf.c b/lib/test_printf.c
index 4bd15a593f..da91301eae 100644
--- a/lib/test_printf.c
+++ b/lib/test_printf.c
@@ -84,12 +84,6 @@ do_test(int bufsize, const char *expect, int elen,
return 1;
}
- if (memchr_inv(test_buffer + written + 1, FILL_CHAR, bufsize - (written + 1))) {
- pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote beyond the nul-terminator\n",
- bufsize, fmt);
- return 1;
- }
-
if (memchr_inv(test_buffer + bufsize, FILL_CHAR, BUF_SIZE + PAD_SIZE - bufsize)) {
pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote beyond buffer\n", bufsize, fmt);
return 1;
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 12/32] vsprintf: Start consolidating printf_spec handling
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (10 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 11/32] test_printf: Drop requirement that sprintf not write past nul Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 13/32] vsprintf: Refactor resource_string() Kent Overstreet
` (8 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
printf_spec is right now something of a mess - it's a grab-bag of state
that's interpreted inconsistently by different code, and it's scattered
throughout vsprintf.c.
We'd like to get it out of the pretty-printers, and have it be solely
the responsibility of vsprintf()/vpr_buf(), the code that parses and
handles format strings.
Most of the code that uses printf_spec is only using it for a minimum &
maximum field width - that can be done at the toplevel by checking how
much we just printed, and padding or truncating it as necessary. This
patch takes those "simple" uses of printf_spec and moves them as far up
the call stack as possible.
This patch also renames some helpers and creates new ones that don't
take printf_spec:
- do_width_precision: new helper that handles with/precision of
printf_spec
- error_string -> error_string_spec
- check_pointer -> check_pointer_spec
- string -> string_spec
Next patches will be reducing/eliminating uses of the *_spec versions.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 248 ++++++++++++++++++++++++++++---------------------
1 file changed, 141 insertions(+), 107 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index d389f74071..2b337e30c2 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -616,6 +616,19 @@ void widen_string(struct printbuf *out, int n,
prt_chars(out, ' ', spaces);
}
+static void do_width_precision(struct printbuf *out, unsigned prev_pos,
+ struct printf_spec spec)
+{
+ unsigned n = out->pos - prev_pos;
+
+ if (n > spec.precision) {
+ out->pos -= n - spec.precision;
+ n = spec.precision;
+ }
+
+ widen_string(out, n, spec);
+}
+
/* Handle string from a well known address. */
static void string_nocheck(struct printbuf *out,
const char *s,
@@ -648,7 +661,7 @@ static void err_ptr(struct printbuf *out, void *ptr,
}
/* Be careful: error messages must fit into the given buffer. */
-static void error_string(struct printbuf *out, const char *s,
+static void error_string_spec(struct printbuf *out, const char *s,
struct printf_spec spec)
{
/*
@@ -678,7 +691,7 @@ static const char *check_pointer_msg(const void *ptr)
return NULL;
}
-static int check_pointer(struct printbuf *out,
+static int check_pointer_spec(struct printbuf *out,
const void *ptr,
struct printf_spec spec)
{
@@ -686,7 +699,7 @@ static int check_pointer(struct printbuf *out,
err_msg = check_pointer_msg(ptr);
if (err_msg) {
- error_string(out, err_msg, spec);
+ error_string_spec(out, err_msg, spec);
return -EFAULT;
}
@@ -694,16 +707,47 @@ static int check_pointer(struct printbuf *out,
}
static noinline_for_stack
-void string(struct printbuf *out,
+void string_spec(struct printbuf *out,
const char *s,
struct printf_spec spec)
{
- if (check_pointer(out, s, spec))
+ if (check_pointer_spec(out, s, spec))
return;
string_nocheck(out, s, spec);
}
+static void error_string(struct printbuf *out, const char *s)
+{
+ /*
+ * Hard limit to avoid a completely insane messages. It actually
+ * works pretty well because most error messages are in
+ * the many pointer format modifiers.
+ */
+ prt_bytes(out, s, min(strlen(s), 2 * sizeof(void *)));
+}
+
+static int check_pointer(struct printbuf *out, const void *ptr)
+{
+ const char *err_msg;
+
+ err_msg = check_pointer_msg(ptr);
+ if (err_msg) {
+ error_string(out, err_msg);
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+static void string(struct printbuf *out, const char *s)
+{
+ if (check_pointer(out, s))
+ return;
+
+ prt_str(out, s);
+}
+
static void pointer_string(struct printbuf *out,
const void *ptr,
struct printf_spec spec)
@@ -805,7 +849,7 @@ static void ptr_to_id(struct printbuf *out,
if (ret) {
spec.field_width = 2 * sizeof(ptr);
/* string length must be less than default_width */
- return error_string(out, str, spec);
+ return error_string_spec(out, str, spec);
}
pointer_string(out, (const void *)hashval, spec);
@@ -846,7 +890,7 @@ void restricted_pointer(struct printbuf *out,
if (in_irq() || in_serving_softirq() || in_nmi()) {
if (spec.field_width == -1)
spec.field_width = 2 * sizeof(ptr);
- return error_string(out, "pK-error", spec);
+ return error_string_spec(out, "pK-error", spec);
}
/*
@@ -876,14 +920,12 @@ void restricted_pointer(struct printbuf *out,
}
static noinline_for_stack
-void dentry_name(struct printbuf *out,
- const struct dentry *d, struct printf_spec spec,
+void dentry_name(struct printbuf *out, const struct dentry *d,
const char *fmt)
{
- const char *array[4], *s;
+ const char *array[4];
const struct dentry *p;
- int depth;
- int i, n;
+ int i, depth;
switch (fmt[1]) {
case '2': case '3': case '4':
@@ -895,7 +937,7 @@ void dentry_name(struct printbuf *out,
rcu_read_lock();
for (i = 0; i < depth; i++, d = p) {
- if (check_pointer(out, d, spec)) {
+ if (check_pointer(out, d)) {
rcu_read_unlock();
return;
}
@@ -909,56 +951,46 @@ void dentry_name(struct printbuf *out,
break;
}
}
- s = array[--i];
- for (n = 0; n != spec.precision; n++) {
- char c = *s++;
- if (!c) {
- if (!i)
- break;
- c = '/';
- s = array[--i];
- }
- prt_char(out, c);
+ while (1) {
+ prt_str(out, array[--i]);
+ if (!i)
+ break;
+ prt_char(out, '/');
}
rcu_read_unlock();
-
- widen_string(out, n, spec);
}
static noinline_for_stack
-void file_dentry_name(struct printbuf *out,
- const struct file *f,
- struct printf_spec spec, const char *fmt)
+void file_dentry_name(struct printbuf *out, const struct file *f,
+ const char *fmt)
{
- if (check_pointer(out, f, spec))
+ if (check_pointer(out, f))
return;
- return dentry_name(out, f->f_path.dentry, spec, fmt);
+ return dentry_name(out, f->f_path.dentry, fmt);
}
#ifdef CONFIG_BLOCK
static noinline_for_stack
-void bdev_name(struct printbuf *out,
- struct block_device *bdev,
- struct printf_spec spec, const char *fmt)
+void bdev_name(struct printbuf *out, struct block_device *bdev)
{
struct gendisk *hd;
- if (check_pointer(out, bdev, spec))
+ if (check_pointer(out, bdev))
return;
hd = bdev->bd_disk;
- string(out, hd->disk_name, spec);
+ string(out, hd->disk_name);
if (bdev->bd_partno) {
if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
prt_char(out, 'p');
- number(out, bdev->bd_partno, spec);
+ prt_u64(out, bdev->bd_partno);
}
}
#endif
static noinline_for_stack
void symbol_string(struct printbuf *out, void *ptr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
unsigned long value;
#ifdef CONFIG_KALLSYMS
@@ -981,17 +1013,12 @@ void symbol_string(struct printbuf *out, void *ptr,
else
sprint_symbol_no_offset(sym, value);
- string_nocheck(out, sym, spec);
+ prt_str(out, sym);
#else
special_hex_number(out, value, sizeof(void *));
#endif
}
-static const struct printf_spec default_str_spec = {
- .field_width = -1,
- .precision = -1,
-};
-
static const struct printf_spec default_flag_spec = {
.base = 16,
.precision = -1,
@@ -1050,7 +1077,7 @@ void resource_string(struct printbuf *out, struct resource *res,
int decode = (fmt[0] == 'R') ? 1 : 0;
const struct printf_spec *specp;
- if (check_pointer(out, res, spec))
+ if (check_pointer_spec(out, res, spec))
return;
prt_char(&sym, '[');
@@ -1114,7 +1141,7 @@ void hex_string(struct printbuf *out, u8 *addr,
/* nothing to print */
return;
- if (check_pointer(out, addr, spec))
+ if (check_pointer_spec(out, addr, spec))
return;
switch (fmt[1]) {
@@ -1155,7 +1182,7 @@ void bitmap_string(struct printbuf *out, unsigned long *bitmap,
int i, chunksz;
bool first = true;
- if (check_pointer(out, bitmap, spec))
+ if (check_pointer_spec(out, bitmap, spec))
return;
/* reused to print numbers */
@@ -1194,7 +1221,7 @@ void bitmap_list_string(struct printbuf *out, unsigned long *bitmap,
bool first = true;
int rbot, rtop;
- if (check_pointer(out, bitmap, spec))
+ if (check_pointer_spec(out, bitmap, spec))
return ;
for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) {
@@ -1221,7 +1248,7 @@ void mac_address_string(struct printbuf *out, u8 *addr,
char separator;
bool reversed = false;
- if (check_pointer(out, addr, spec))
+ if (check_pointer_spec(out, addr, spec))
return;
switch (fmt[1]) {
@@ -1522,7 +1549,7 @@ void ip_addr_string(struct printbuf *out, const void *ptr,
{
char *err_fmt_msg;
- if (check_pointer(out, ptr, spec))
+ if (check_pointer_spec(out, ptr, spec))
return;
switch (fmt[1]) {
@@ -1543,12 +1570,12 @@ void ip_addr_string(struct printbuf *out, const void *ptr,
case AF_INET6:
return ip6_addr_string_sa(out, &sa->v6, spec, fmt);
default:
- return error_string(out, "(einval)", spec);
+ return error_string_spec(out, "(einval)", spec);
}}
}
err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)";
- return error_string(out, err_fmt_msg, spec);
+ return error_string_spec(out, err_fmt_msg, spec);
}
static noinline_for_stack
@@ -1563,7 +1590,7 @@ void escaped_string(struct printbuf *out, u8 *addr,
if (spec.field_width == 0)
return; /* nothing to print */
- if (check_pointer(out, addr, spec))
+ if (check_pointer_spec(out, addr, spec))
return;
do {
@@ -1608,7 +1635,7 @@ static void va_format(struct printbuf *out,
{
va_list va;
- if (check_pointer(out, va_fmt, spec))
+ if (check_pointer_spec(out, va_fmt, spec))
return;
va_copy(va, *va_fmt->va);
@@ -1617,16 +1644,13 @@ static void va_format(struct printbuf *out,
}
static noinline_for_stack
-void uuid_string(struct printbuf *out, const u8 *addr,
- struct printf_spec spec, const char *fmt)
+void uuid_string(struct printbuf *out, const u8 *addr, const char *fmt)
{
- char uuid_buf[UUID_STRING_LEN + 1];
- struct printbuf uuid = PRINTBUF_EXTERN(uuid_buf, sizeof(uuid_buf));
int i;
const u8 *index = uuid_index;
bool uc = false;
- if (check_pointer(out, addr, spec))
+ if (check_pointer(out, addr))
return;
switch (*(++fmt)) {
@@ -1643,30 +1667,28 @@ void uuid_string(struct printbuf *out, const u8 *addr,
for (i = 0; i < 16; i++) {
if (uc)
- prt_hex_byte_upper(&uuid, addr[index[i]]);
+ prt_hex_byte_upper(out, addr[index[i]]);
else
- prt_hex_byte(&uuid, addr[index[i]]);
+ prt_hex_byte(out, addr[index[i]]);
switch (i) {
case 3:
case 5:
case 7:
case 9:
- prt_char(&uuid, '-');
+ prt_char(out, '-');
break;
}
}
-
- string_nocheck(out, uuid_buf, spec);
}
static noinline_for_stack
void netdev_bits(struct printbuf *out, const void *addr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
unsigned long long num;
int size;
- if (check_pointer(out, addr, spec))
+ if (check_pointer(out, addr))
return;
switch (fmt[1]) {
@@ -1676,7 +1698,7 @@ void netdev_bits(struct printbuf *out, const void *addr,
special_hex_number(out, num, size);
break;
default:
- error_string(out, "(%pN?)", spec);
+ error_string(out, "(%pN?)");
break;
}
}
@@ -1691,9 +1713,9 @@ void fourcc_string(struct printbuf *out, const u32 *fourcc,
u32 orig, val;
if (fmt[1] != 'c' || fmt[2] != 'c')
- return error_string(out, "(%p4?)", spec);
+ return error_string_spec(out, "(%p4?)", spec);
- if (check_pointer(out, fourcc, spec))
+ if (check_pointer_spec(out, fourcc, spec))
return;
orig = get_unaligned(fourcc);
@@ -1714,17 +1736,17 @@ void fourcc_string(struct printbuf *out, const u32 *fourcc,
special_hex_number(&output, orig, sizeof(u32));
prt_char(&output, ')');
- string(out, output_buf, spec);
+ string_spec(out, output_buf, spec);
}
static noinline_for_stack
void address_val(struct printbuf *out, const void *addr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
unsigned long long num;
int size;
- if (check_pointer(out, addr, spec))
+ if (check_pointer(out, addr))
return;
switch (fmt[1]) {
@@ -1775,7 +1797,7 @@ void rtc_str(struct printbuf *out, const struct rtc_time *tm,
bool found = true;
int count = 2;
- if (check_pointer(out, tm, spec))
+ if (check_pointer_spec(out, tm, spec))
return;
switch (fmt[count]) {
@@ -1845,7 +1867,7 @@ void time_and_date(struct printbuf *out,
case 'T':
return time64_str(out, *(const time64_t *)ptr, spec, fmt);
default:
- return error_string(out, "(%pt?)", spec);
+ return error_string_spec(out, "(%pt?)", spec);
}
}
@@ -1854,16 +1876,16 @@ void clock(struct printbuf *out, struct clk *clk,
struct printf_spec spec, const char *fmt)
{
if (!IS_ENABLED(CONFIG_HAVE_CLK))
- return error_string(out, "(%pC?)", spec);
+ return error_string_spec(out, "(%pC?)", spec);
- if (check_pointer(out, clk, spec))
+ if (check_pointer_spec(out, clk, spec))
return;
switch (fmt[1]) {
case 'n':
default:
#ifdef CONFIG_COMMON_CLK
- return string(out, __clk_get_name(clk), spec);
+ return string_spec(out, __clk_get_name(clk), spec);
#else
return ptr_to_id(out, clk, spec);
#endif
@@ -1881,7 +1903,7 @@ void format_flags(struct printbuf *out, unsigned long flags,
if ((flags & mask) != mask)
continue;
- string(out, names->name, default_str_spec);
+ string(out, names->name);
flags &= ~mask;
if (flags)
@@ -1939,7 +1961,7 @@ void format_page_flags(struct printbuf *out, unsigned long flags)
if (append)
prt_char(out, '|');
- string(out, pff[i].name, default_str_spec);
+ string(out, pff[i].name);
prt_char(out, '=');
number(out, (flags >> pff[i].shift) & pff[i].mask, *pff[i].spec);
@@ -1955,7 +1977,7 @@ void flags_string(struct printbuf *out, void *flags_ptr,
unsigned long flags;
const struct trace_print_flags *names;
- if (check_pointer(out, flags_ptr, spec))
+ if (check_pointer_spec(out, flags_ptr, spec))
return;
switch (fmt[1]) {
@@ -1970,7 +1992,7 @@ void flags_string(struct printbuf *out, void *flags_ptr,
names = gfpflag_names;
break;
default:
- return error_string(out, "(%pG?)", spec);
+ return error_string_spec(out, "(%pG?)", spec);
}
return format_flags(out, flags, names);
@@ -1987,10 +2009,8 @@ void fwnode_full_name_string(struct printbuf *out,
struct fwnode_handle *__fwnode =
fwnode_get_nth_parent(fwnode, depth);
- string(out, fwnode_get_name_prefix(__fwnode),
- default_str_spec);
- string(out, fwnode_get_name(__fwnode),
- default_str_spec);
+ string(out, fwnode_get_name_prefix(__fwnode));
+ string(out, fwnode_get_name(__fwnode));
fwnode_handle_put(__fwnode);
}
@@ -2011,12 +2031,12 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
str_spec.field_width = -1;
if (fmt[0] != 'F')
- return error_string(out, "(%pO?)", spec);
+ return error_string_spec(out, "(%pO?)", spec);
if (!IS_ENABLED(CONFIG_OF))
- return error_string(out, "(%pOF?)", spec);
+ return error_string_spec(out, "(%pOF?)", spec);
- if (check_pointer(out, dn, spec))
+ if (check_pointer_spec(out, dn, spec))
return;
/* simple case without anything any more format specifiers */
@@ -2037,7 +2057,7 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
p = fwnode_get_name(of_fwnode_handle(dn));
precision = str_spec.precision;
str_spec.precision = strchrnul(p, '@') - p;
- string(out, p, str_spec);
+ string_spec(out, p, str_spec);
str_spec.precision = precision;
break;
case 'p': /* phandle */
@@ -2047,7 +2067,7 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
p = fwnode_get_name(of_fwnode_handle(dn));
if (!p[1])
p = "/";
- string(out, p, str_spec);
+ string_spec(out, p, str_spec);
break;
case 'F': /* flags */
tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';
@@ -2057,18 +2077,18 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
tbuf[4] = 0;
string_nocheck(out, tbuf, str_spec);
break;
- case 'c': /* major compatible string */
+ case 'c': /* major compatible string_spec */
ret = of_property_read_string(dn, "compatible", &p);
if (!ret)
- string(out, p, str_spec);
+ string_spec(out, p, str_spec);
break;
- case 'C': /* full compatible string */
+ case 'C': /* full compatible string_spec */
has_mult = false;
of_property_for_each_string(dn, "compatible", prop, p) {
if (has_mult)
string_nocheck(out, ",", str_spec);
string_nocheck(out, "\"", str_spec);
- string(out, p, str_spec);
+ string_spec(out, p, str_spec);
string_nocheck(out, "\"", str_spec);
has_mult = true;
@@ -2093,16 +2113,16 @@ void fwnode_string(struct printbuf *out,
str_spec.field_width = -1;
if (*fmt != 'w')
- return error_string(out, "(%pf?)", spec);
+ return error_string_spec(out, "(%pf?)", spec);
- if (check_pointer(out, fwnode, spec))
+ if (check_pointer_spec(out, fwnode, spec))
return;
fmt++;
switch (*fmt) {
case 'P': /* name */
- string(out, fwnode_get_name(fwnode), str_spec);
+ string_spec(out, fwnode_get_name(fwnode), str_spec);
break;
case 'f': /* full_name */
default:
@@ -2269,13 +2289,16 @@ static noinline_for_stack
void pointer(struct printbuf *out, const char *fmt,
void *ptr, struct printf_spec spec)
{
+ unsigned prev_pos = out->pos;
+
switch (*fmt) {
case 'S':
case 's':
ptr = dereference_symbol_descriptor(ptr);
fallthrough;
case 'B':
- return symbol_string(out, ptr, spec, fmt);
+ symbol_string(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'R':
case 'r':
return resource_string(out, ptr, spec, fmt);
@@ -2306,28 +2329,34 @@ void pointer(struct printbuf *out, const char *fmt,
case 'E':
return escaped_string(out, ptr, spec, fmt);
case 'U':
- return uuid_string(out, ptr, spec, fmt);
+ uuid_string(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'V':
return va_format(out, ptr, spec, fmt);
case 'K':
return restricted_pointer(out, ptr, spec);
case 'N':
- return netdev_bits(out, ptr, spec, fmt);
+ netdev_bits(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case '4':
return fourcc_string(out, ptr, spec, fmt);
case 'a':
- return address_val(out, ptr, spec, fmt);
+ address_val(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'd':
- return dentry_name(out, ptr, spec, fmt);
+ dentry_name(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 't':
return time_and_date(out, ptr, spec, fmt);
case 'C':
return clock(out, ptr, spec, fmt);
case 'D':
- return file_dentry_name(out, ptr, spec, fmt);
+ file_dentry_name(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
#ifdef CONFIG_BLOCK
case 'g':
- return bdev_name(out, ptr, spec, fmt);
+ bdev_name(out, ptr);
+ return do_width_precision(out, prev_pos, spec);
#endif
case 'G':
@@ -2347,9 +2376,9 @@ void pointer(struct printbuf *out, const char *fmt,
case 'k':
switch (fmt[1]) {
case 's':
- return string(out, ptr, spec);
+ return string_spec(out, ptr, spec);
default:
- return error_string(out, "(einval)", spec);
+ return error_string_spec(out, "(einval)", spec);
}
default:
return default_pointer(out, ptr, spec);
@@ -2627,7 +2656,12 @@ void prt_vprintf(struct printbuf *out, const char *fmt, va_list args)
break;
case FORMAT_TYPE_STR:
- string(out, va_arg(args, char *), spec);
+ /*
+ * we can't use string() then do_width_precision
+ * afterwards: people use the field width for passing
+ * non nul terminated strings
+ */
+ string_spec(out, va_arg(args, char *), spec);
break;
case FORMAT_TYPE_PTR:
@@ -3096,7 +3130,7 @@ void prt_bstrprintf(struct printbuf *out, const char *fmt, const u32 *bin_buf)
case FORMAT_TYPE_STR: {
const char *str_arg = args;
args += strlen(str_arg) + 1;
- string(out, (char *)str_arg, spec);
+ string_spec(out, (char *)str_arg, spec);
break;
}
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 13/32] vsprintf: Refactor resource_string()
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (11 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 12/32] vsprintf: Start consolidating printf_spec handling Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 14/32] vsprintf: Refactor fourcc_string() Kent Overstreet
` (7 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
Two changes:
- We're attempting to consolidate printf_spec and format string
handling in the top level vpr_buf(), this changes resource_string to
not take printf_spec
- With the new printbuf helpers there's no need to use a separate stack
allocated buffer, so this patch deletes it.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 51 ++++++++++++++++++++++++--------------------------
1 file changed, 24 insertions(+), 27 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 2b337e30c2..f8abeee393 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1032,7 +1032,7 @@ static const struct printf_spec default_dec_spec = {
static noinline_for_stack
void resource_string(struct printbuf *out, struct resource *res,
- struct printf_spec spec, const char *fmt)
+ int decode)
{
#ifndef IO_RSRC_PRINTK_SIZE
#define IO_RSRC_PRINTK_SIZE 6
@@ -1071,62 +1071,58 @@ void resource_string(struct printbuf *out, struct resource *res,
#define FLAG_BUF_SIZE (2 * sizeof(res->flags))
#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
- char sym_buf[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
- 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
- struct printbuf sym = PRINTBUF_EXTERN(sym_buf, sizeof(sym_buf));
- int decode = (fmt[0] == 'R') ? 1 : 0;
const struct printf_spec *specp;
- if (check_pointer_spec(out, res, spec))
+ if (check_pointer(out, res))
return;
- prt_char(&sym, '[');
+ prt_char(out, '[');
if (res->flags & IORESOURCE_IO) {
- string_nocheck(&sym, "io ", str_spec);
+ string_nocheck(out, "io ", str_spec);
specp = &io_spec;
} else if (res->flags & IORESOURCE_MEM) {
- string_nocheck(&sym, "mem ", str_spec);
+ string_nocheck(out, "mem ", str_spec);
specp = &mem_spec;
} else if (res->flags & IORESOURCE_IRQ) {
- string_nocheck(&sym, "irq ", str_spec);
+ string_nocheck(out, "irq ", str_spec);
specp = &default_dec_spec;
} else if (res->flags & IORESOURCE_DMA) {
- string_nocheck(&sym, "dma ", str_spec);
+ string_nocheck(out, "dma ", str_spec);
specp = &default_dec_spec;
} else if (res->flags & IORESOURCE_BUS) {
- string_nocheck(&sym, "bus ", str_spec);
+ string_nocheck(out, "bus ", str_spec);
specp = &bus_spec;
} else {
- string_nocheck(&sym, "??? ", str_spec);
+ string_nocheck(out, "??? ", str_spec);
specp = &mem_spec;
decode = 0;
}
if (decode && res->flags & IORESOURCE_UNSET) {
- string_nocheck(&sym, "size ", str_spec);
- number(&sym, resource_size(res), *specp);
+ string_nocheck(out, "size ", str_spec);
+ number(out, resource_size(res), *specp);
} else {
- number(&sym, res->start, *specp);
+ number(out, res->start, *specp);
if (res->start != res->end) {
- prt_char(&sym, '-');
- number(&sym, res->end, *specp);
+ prt_char(out, '-');
+ number(out, res->end, *specp);
}
}
if (decode) {
if (res->flags & IORESOURCE_MEM_64)
- string_nocheck(&sym, " 64bit", str_spec);
+ string_nocheck(out, " 64bit", str_spec);
if (res->flags & IORESOURCE_PREFETCH)
- string_nocheck(&sym, " pref", str_spec);
+ string_nocheck(out, " pref", str_spec);
if (res->flags & IORESOURCE_WINDOW)
- string_nocheck(&sym, " window", str_spec);
+ string_nocheck(out, " window", str_spec);
if (res->flags & IORESOURCE_DISABLED)
- string_nocheck(&sym, " disabled", str_spec);
+ string_nocheck(out, " disabled", str_spec);
} else {
- string_nocheck(&sym, " flags ", str_spec);
- number(&sym, res->flags, default_flag_spec);
+ string_nocheck(out, " flags ", str_spec);
+ number(out, res->flags, default_flag_spec);
}
- prt_char(&sym, ']');
+ prt_char(out, ']');
- string_nocheck(out, sym_buf, spec);
+ printbuf_nul_terminate(out);
}
static noinline_for_stack
@@ -2301,7 +2297,8 @@ void pointer(struct printbuf *out, const char *fmt,
return do_width_precision(out, prev_pos, spec);
case 'R':
case 'r':
- return resource_string(out, ptr, spec, fmt);
+ resource_string(out, ptr, fmt[0] == 'R');
+ return do_width_precision(out, prev_pos, spec);
case 'h':
return hex_string(out, ptr, spec, fmt);
case 'b':
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 14/32] vsprintf: Refactor fourcc_string()
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (12 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 13/32] vsprintf: Refactor resource_string() Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 15/32] vsprintf: Refactor ip_addr_string() Kent Overstreet
` (6 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
- We're attempting to consolidate printf_spec and format string
handling in the top level vpr_buf(), this changes fourcc_string() to
not take printf_spec
- With the new printbuf helpers there's no need to use a separate stack
allocated buffer, so this patch deletes it.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 27 ++++++++++++---------------
1 file changed, 12 insertions(+), 15 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index f8abeee393..e3189c9f2d 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1701,17 +1701,15 @@ void netdev_bits(struct printbuf *out, const void *addr,
static noinline_for_stack
void fourcc_string(struct printbuf *out, const u32 *fourcc,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
- char output_buf[sizeof("0123 little-endian (0x01234567)")];
- struct printbuf output = PRINTBUF_EXTERN(output_buf, sizeof(output_buf));
unsigned int i;
u32 orig, val;
if (fmt[1] != 'c' || fmt[2] != 'c')
- return error_string_spec(out, "(%p4?)", spec);
+ return error_string(out, "(%p4?)");
- if (check_pointer_spec(out, fourcc, spec))
+ if (check_pointer(out, fourcc))
return;
orig = get_unaligned(fourcc);
@@ -1721,18 +1719,16 @@ void fourcc_string(struct printbuf *out, const u32 *fourcc,
unsigned char c = val >> (i * 8);
/* Print non-control ASCII characters as-is, dot otherwise */
- prt_char(&output, isascii(c) && isprint(c) ? c : '.');
+ prt_char(out, isascii(c) && isprint(c) ? c : '.');
}
- prt_char(&output, ' ');
- prt_str(&output, orig & BIT(31) ? "big-endian" : "little-endian");
-
- prt_char(&output, ' ');
- prt_char(&output, '(');
- special_hex_number(&output, orig, sizeof(u32));
- prt_char(&output, ')');
+ prt_char(out, ' ');
+ prt_str(out, orig & BIT(31) ? "big-endian" : "little-endian");
- string_spec(out, output_buf, spec);
+ prt_char(out, ' ');
+ prt_char(out, '(');
+ special_hex_number(out, orig, sizeof(u32));
+ prt_char(out, ')');
}
static noinline_for_stack
@@ -2336,7 +2332,8 @@ void pointer(struct printbuf *out, const char *fmt,
netdev_bits(out, ptr, fmt);
return do_width_precision(out, prev_pos, spec);
case '4':
- return fourcc_string(out, ptr, spec, fmt);
+ fourcc_string(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'a':
address_val(out, ptr, fmt);
return do_width_precision(out, prev_pos, spec);
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 15/32] vsprintf: Refactor ip_addr_string()
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (13 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 14/32] vsprintf: Refactor fourcc_string() Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 16/32] vsprintf: Refactor mac_address_string() Kent Overstreet
` (5 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
- We're attempting to consolidate printf_spec and format string
handling in the top level vpr_buf(), this changes ip_addr_string() to
not take printf_spec
- With the new printbuf helpers there's no need to use a separate stack
allocated buffer, so this patch deletes it.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 114 ++++++++++++++++---------------------------------
1 file changed, 37 insertions(+), 77 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index e3189c9f2d..27d23e82f5 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1276,13 +1276,13 @@ void mac_address_string(struct printbuf *out, u8 *addr,
}
static noinline_for_stack
-void ip4_string(struct printbuf *out,
- const u8 *addr, const char *fmt)
+void ip4_string(struct printbuf *out, const u8 *addr, const char *fmt)
{
- int i;
- bool leading_zeros = (fmt[0] == 'i');
- int index;
- int step;
+ struct printf_spec spec = default_dec_spec;
+ int i, index, step;
+
+ if (fmt[0] == 'i')
+ spec.precision = 3;
switch (fmt[2]) {
case 'h':
@@ -1306,19 +1306,9 @@ void ip4_string(struct printbuf *out,
break;
}
for (i = 0; i < 4; i++) {
- char temp[4] __aligned(2); /* hold each IP quad in reverse order */
- int digits = put_dec_trunc8(temp, addr[index]) - temp;
- if (leading_zeros) {
- if (digits < 3)
- prt_char(out, '0');
- if (digits < 2)
- prt_char(out, '0');
- }
- /* reverse the digits in the quad */
- while (digits--)
- prt_char(out, temp[digits]);
- if (i < 3)
+ if (i)
prt_char(out, '.');
+ number(out, addr[index], spec);
index += step;
}
}
@@ -1401,8 +1391,6 @@ void ip6_compressed_string(struct printbuf *out, const char *addr)
__prt_char(out, ':');
ip4_string(out, &in6.s6_addr[12], "I4");
}
-
- printbuf_nul_terminate(out);
}
static noinline_for_stack
@@ -1420,41 +1408,20 @@ void ip6_string(struct printbuf *out, const char *addr, const char *fmt)
static noinline_for_stack
void ip6_addr_string(struct printbuf *out, const u8 *addr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
- char ip6_addr_buf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
- struct printbuf ip6_addr = PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_addr_buf));
-
if (fmt[0] == 'I' && fmt[2] == 'c')
- ip6_compressed_string(&ip6_addr, addr);
+ ip6_compressed_string(out, addr);
else
- ip6_string(&ip6_addr, addr, fmt);
-
- string_nocheck(out, ip6_addr_buf, spec);
-}
-
-static noinline_for_stack
-void ip4_addr_string(struct printbuf *out, const u8 *addr,
- struct printf_spec spec, const char *fmt)
-{
- char ip4_addr_buf[sizeof("255.255.255.255")];
- struct printbuf ip4_addr = PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_addr_buf));
-
- ip4_string(&ip4_addr, addr, fmt);
-
- string_nocheck(out, ip4_addr_buf, spec);
+ ip6_string(out, addr, fmt);
}
static noinline_for_stack
void ip6_addr_string_sa(struct printbuf *out,
const struct sockaddr_in6 *sa,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
bool have_p = false, have_s = false, have_f = false, have_c = false;
- char ip6_addr_buf[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
- sizeof(":12345") + sizeof("/123456789") +
- sizeof("%1234567890")];
- struct printbuf ip6_addr = PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_addr_buf));
const u8 *addr = (const u8 *) &sa->sin6_addr;
char fmt6[2] = { fmt[0], '6' };
@@ -1477,41 +1444,35 @@ void ip6_addr_string_sa(struct printbuf *out,
}
if (have_p || have_s || have_f)
- prt_char(&ip6_addr, '[');
+ prt_char(out, '[');
if (fmt6[0] == 'I' && have_c)
- ip6_compressed_string(&ip6_addr, addr);
+ ip6_compressed_string(out, addr);
else
- ip6_string(&ip6_addr, addr, fmt6);
+ ip6_string(out, addr, fmt6);
if (have_p || have_s || have_f)
- prt_char(&ip6_addr, ']');
+ prt_char(out, ']');
if (have_p) {
- prt_char(&ip6_addr, ':');
- number(&ip6_addr, ntohs(sa->sin6_port), spec);
+ prt_char(out, ':');
+ prt_u64(out, ntohs(sa->sin6_port));
}
if (have_f) {
- prt_char(&ip6_addr, '/');
- number(&ip6_addr, ntohl(sa->sin6_flowinfo &
- IPV6_FLOWINFO_MASK), spec);
+ prt_char(out, '/');
+ prt_u64(out, ntohl(sa->sin6_flowinfo & IPV6_FLOWINFO_MASK));
}
if (have_s) {
- prt_char(&ip6_addr, '%');
- number(&ip6_addr, sa->sin6_scope_id, spec);
+ prt_char(out, '%');
+ prt_u64(out, sa->sin6_scope_id);
}
-
- string_nocheck(out, ip6_addr_buf, spec);
}
static noinline_for_stack
-void ip4_addr_string_sa(struct printbuf *out,
- const struct sockaddr_in *sa,
- struct printf_spec spec, const char *fmt)
+void ip4_addr_string_sa(struct printbuf *out, const struct sockaddr_in *sa,
+ const char *fmt)
{
bool have_p = false;
- char ip4_addr_buf[sizeof("255.255.255.255") + sizeof(":12345")];
- struct printbuf ip4_addr = PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_addr_buf));
const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
char fmt4[3] = { fmt[0], '4', 0 };
@@ -1530,29 +1491,27 @@ void ip4_addr_string_sa(struct printbuf *out,
}
}
- ip4_string(&ip4_addr, addr, fmt4);
+ ip4_string(out, addr, fmt4);
if (have_p) {
- prt_char(&ip4_addr, ':');
- number(&ip4_addr, ntohs(sa->sin_port), spec);
+ prt_char(out, ':');
+ prt_u64(out, ntohs(sa->sin_port));
}
-
- string_nocheck(out, ip4_addr_buf, spec);
}
static noinline_for_stack
void ip_addr_string(struct printbuf *out, const void *ptr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
char *err_fmt_msg;
- if (check_pointer_spec(out, ptr, spec))
+ if (check_pointer(out, ptr))
return;
switch (fmt[1]) {
case '6':
- return ip6_addr_string(out, ptr, spec, fmt);
+ return ip6_addr_string(out, ptr, fmt);
case '4':
- return ip4_addr_string(out, ptr, spec, fmt);
+ return ip4_string(out, ptr, fmt);
case 'S': {
const union {
struct sockaddr raw;
@@ -1562,16 +1521,16 @@ void ip_addr_string(struct printbuf *out, const void *ptr,
switch (sa->raw.sa_family) {
case AF_INET:
- return ip4_addr_string_sa(out, &sa->v4, spec, fmt);
+ return ip4_addr_string_sa(out, &sa->v4, fmt);
case AF_INET6:
- return ip6_addr_string_sa(out, &sa->v6, spec, fmt);
+ return ip6_addr_string_sa(out, &sa->v6, fmt);
default:
- return error_string_spec(out, "(einval)", spec);
+ return error_string(out, "(einval)");
}}
}
err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)";
- return error_string_spec(out, err_fmt_msg, spec);
+ error_string(out, err_fmt_msg);
}
static noinline_for_stack
@@ -2318,7 +2277,8 @@ void pointer(struct printbuf *out, const char *fmt,
* 4: 001.002.003.004
* 6: 000102...0f
*/
- return ip_addr_string(out, ptr, spec, fmt);
+ ip_addr_string(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'E':
return escaped_string(out, ptr, spec, fmt);
case 'U':
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 16/32] vsprintf: Refactor mac_address_string()
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (14 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 15/32] vsprintf: Refactor ip_addr_string() Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 17/32] vsprintf: time_and_date() no longer takes printf_spec Kent Overstreet
` (4 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
- We're attempting to consolidate printf_spec and format string
handling in the top level ptr_vprintf(), this changes
mac_address_string() to not take printf_spec
- With the new printbuf helpers there's no need to use a separate stack
allocated buffer, so this patch deletes it.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 18 +++++++-----------
1 file changed, 7 insertions(+), 11 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 27d23e82f5..d8e8d211bd 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1236,15 +1236,13 @@ void bitmap_list_string(struct printbuf *out, unsigned long *bitmap,
static noinline_for_stack
void mac_address_string(struct printbuf *out, u8 *addr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
- char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
- char *p = mac_addr;
int i;
char separator;
bool reversed = false;
- if (check_pointer_spec(out, addr, spec))
+ if (check_pointer(out, addr))
return;
switch (fmt[1]) {
@@ -1263,16 +1261,13 @@ void mac_address_string(struct printbuf *out, u8 *addr,
for (i = 0; i < 6; i++) {
if (reversed)
- p = hex_byte_pack(p, addr[5 - i]);
+ prt_hex_byte(out, addr[5 - i]);
else
- p = hex_byte_pack(p, addr[i]);
+ prt_hex_byte(out, addr[i]);
if (fmt[0] == 'M' && i != 5)
- *p++ = separator;
+ prt_char(out, separator);
}
- *p = '\0';
-
- string_nocheck(out, mac_addr, spec);
}
static noinline_for_stack
@@ -2267,7 +2262,8 @@ void pointer(struct printbuf *out, const char *fmt,
case 'm': /* Contiguous: 000102030405 */
/* [mM]F (FDDI) */
/* [mM]R (Reverse order; Bluetooth) */
- return mac_address_string(out, ptr, spec, fmt);
+ mac_address_string(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'I': /* Formatted IP supported
* 4: 1.2.3.4
* 6: 0001:0203:...:0708
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 17/32] vsprintf: time_and_date() no longer takes printf_spec
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (15 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 16/32] vsprintf: Refactor mac_address_string() Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 18/32] vsprintf: flags_string() " Kent Overstreet
` (3 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
We're attempting to consolidate printf_spec and format string handling
in the top level vpr_buf(), this changes time_and_date() to not
take printf_spec.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 20 ++++++++++----------
1 file changed, 10 insertions(+), 10 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index d8e8d211bd..8154beae12 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1736,14 +1736,14 @@ void time_str(struct printbuf *out, const struct rtc_time *tm, bool r)
static noinline_for_stack
void rtc_str(struct printbuf *out, const struct rtc_time *tm,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
bool have_t = true, have_d = true;
bool raw = false, iso8601_separator = true;
bool found = true;
int count = 2;
- if (check_pointer_spec(out, tm, spec))
+ if (check_pointer(out, tm))
return;
switch (fmt[count]) {
@@ -1781,7 +1781,7 @@ void rtc_str(struct printbuf *out, const struct rtc_time *tm,
static noinline_for_stack
void time64_str(struct printbuf *out, const time64_t time,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
struct rtc_time rtc_time;
struct tm tm;
@@ -1799,21 +1799,20 @@ void time64_str(struct printbuf *out, const time64_t time,
rtc_time.tm_isdst = 0;
- rtc_str(out, &rtc_time, spec, fmt);
+ rtc_str(out, &rtc_time, fmt);
}
static noinline_for_stack
-void time_and_date(struct printbuf *out,
- void *ptr, struct printf_spec spec,
+void time_and_date(struct printbuf *out, void *ptr,
const char *fmt)
{
switch (fmt[1]) {
case 'R':
- return rtc_str(out, (const struct rtc_time *)ptr, spec, fmt);
+ return rtc_str(out, (const struct rtc_time *)ptr, fmt);
case 'T':
- return time64_str(out, *(const time64_t *)ptr, spec, fmt);
+ return time64_str(out, *(const time64_t *)ptr, fmt);
default:
- return error_string_spec(out, "(%pt?)", spec);
+ return error_string(out, "(%pt?)");
}
}
@@ -2297,7 +2296,8 @@ void pointer(struct printbuf *out, const char *fmt,
dentry_name(out, ptr, fmt);
return do_width_precision(out, prev_pos, spec);
case 't':
- return time_and_date(out, ptr, spec, fmt);
+ time_and_date(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'C':
return clock(out, ptr, spec, fmt);
case 'D':
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 18/32] vsprintf: flags_string() no longer takes printf_spec
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (16 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 17/32] vsprintf: time_and_date() no longer takes printf_spec Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 19/32] vsprintf: Refactor device_node_string, fwnode_string Kent Overstreet
` (2 subsequent siblings)
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
We're attempting to consolidate printf_spec and format string handling
in the top level vpr_buf(), this changes time_and_date() to not
take printf_spec.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 8154beae12..df954902a1 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1917,12 +1917,12 @@ void format_page_flags(struct printbuf *out, unsigned long flags)
static noinline_for_stack
void flags_string(struct printbuf *out, void *flags_ptr,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
unsigned long flags;
const struct trace_print_flags *names;
- if (check_pointer_spec(out, flags_ptr, spec))
+ if (check_pointer(out, flags_ptr))
return;
switch (fmt[1]) {
@@ -1937,7 +1937,7 @@ void flags_string(struct printbuf *out, void *flags_ptr,
names = gfpflag_names;
break;
default:
- return error_string_spec(out, "(%pG?)", spec);
+ return error_string(out, "(%pG?)");
}
return format_flags(out, flags, names);
@@ -2310,7 +2310,8 @@ void pointer(struct printbuf *out, const char *fmt,
#endif
case 'G':
- return flags_string(out, ptr, spec, fmt);
+ flags_string(out, ptr, fmt);
+ return do_width_precision(out, prev_pos, spec);
case 'O':
return device_node_string(out, ptr, spec, fmt + 1);
case 'f':
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 19/32] vsprintf: Refactor device_node_string, fwnode_string
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (17 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 18/32] vsprintf: flags_string() " Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:19 ` [PATCH 20/32] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string Kent Overstreet
2022-08-14 21:20 ` [PATCH 21/32] Input/joystick/analog: Convert from seq_buf -> printbuf Kent Overstreet
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
- eliminate on-stack buffer in device_node_string
- eliminate unnecessary uses of printf_spec, lift format string
precision/field width to pointer()
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 73 ++++++++++++++++++++------------------------------
1 file changed, 29 insertions(+), 44 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index df954902a1..81d2f3fa1a 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1963,25 +1963,20 @@ void fwnode_full_name_string(struct printbuf *out,
static noinline_for_stack
void device_node_string(struct printbuf *out, struct device_node *dn,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
- char tbuf[sizeof("xxxx") + 1];
const char *p;
int ret;
- unsigned start = out->pos;
struct property *prop;
bool has_mult, pass;
- struct printf_spec str_spec = spec;
- str_spec.field_width = -1;
-
if (fmt[0] != 'F')
- return error_string_spec(out, "(%pO?)", spec);
+ return error_string(out, "(%pO?)");
if (!IS_ENABLED(CONFIG_OF))
- return error_string_spec(out, "(%pOF?)", spec);
+ return error_string(out, "(%pOF?)");
- if (check_pointer_spec(out, dn, spec))
+ if (check_pointer(out, dn))
return;
/* simple case without anything any more format specifiers */
@@ -1990,7 +1985,6 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
fmt = "f";
for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) {
- int precision;
if (pass)
prt_char(out, ':');
@@ -1998,43 +1992,41 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
case 'f': /* full_name */
fwnode_full_name_string(out, of_fwnode_handle(dn));
break;
- case 'n': /* name */
- p = fwnode_get_name(of_fwnode_handle(dn));
- precision = str_spec.precision;
- str_spec.precision = strchrnul(p, '@') - p;
- string_spec(out, p, str_spec);
- str_spec.precision = precision;
+ case 'n': { /* name */
+ const char *name = fwnode_get_name(of_fwnode_handle(dn));
+ unsigned len = strchrnul(name, '@') - name;
+
+ prt_bytes(out, name, len);
break;
+ }
case 'p': /* phandle */
- prt_u64(out, (unsigned int)dn->phandle);
+ prt_u64(out, dn->phandle);
break;
case 'P': /* path-spec */
p = fwnode_get_name(of_fwnode_handle(dn));
if (!p[1])
p = "/";
- string_spec(out, p, str_spec);
+ string(out, p);
break;
case 'F': /* flags */
- tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';
- tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-';
- tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-';
- tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-';
- tbuf[4] = 0;
- string_nocheck(out, tbuf, str_spec);
+ prt_char(out, of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-');
+ prt_char(out, of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-');
+ prt_char(out, of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-');
+ prt_char(out, of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-');
break;
case 'c': /* major compatible string_spec */
ret = of_property_read_string(dn, "compatible", &p);
if (!ret)
- string_spec(out, p, str_spec);
+ string(out, p);
break;
case 'C': /* full compatible string_spec */
has_mult = false;
of_property_for_each_string(dn, "compatible", prop, p) {
if (has_mult)
- string_nocheck(out, ",", str_spec);
- string_nocheck(out, "\"", str_spec);
- string_spec(out, p, str_spec);
- string_nocheck(out, "\"", str_spec);
+ prt_char(out, ',');
+ prt_char(out, '\"');
+ string(out, p);
+ prt_char(out, '\"');
has_mult = true;
}
@@ -2043,39 +2035,30 @@ void device_node_string(struct printbuf *out, struct device_node *dn,
break;
}
}
-
- widen_string(out, out->pos - start, spec);
}
static noinline_for_stack
void fwnode_string(struct printbuf *out,
struct fwnode_handle *fwnode,
- struct printf_spec spec, const char *fmt)
+ const char *fmt)
{
- struct printf_spec str_spec = spec;
- unsigned start = out->pos;
-
- str_spec.field_width = -1;
-
if (*fmt != 'w')
- return error_string_spec(out, "(%pf?)", spec);
+ return error_string(out, "(%pf?)");
- if (check_pointer_spec(out, fwnode, spec))
+ if (check_pointer(out, fwnode))
return;
fmt++;
switch (*fmt) {
case 'P': /* name */
- string_spec(out, fwnode_get_name(fwnode), str_spec);
+ string(out, fwnode_get_name(fwnode));
break;
case 'f': /* full_name */
default:
fwnode_full_name_string(out, fwnode);
break;
}
-
- widen_string(out, out->pos - start, spec);
}
int __init no_hash_pointers_enable(char *str)
@@ -2313,9 +2296,11 @@ void pointer(struct printbuf *out, const char *fmt,
flags_string(out, ptr, fmt);
return do_width_precision(out, prev_pos, spec);
case 'O':
- return device_node_string(out, ptr, spec, fmt + 1);
+ device_node_string(out, ptr, fmt + 1);
+ return do_width_precision(out, prev_pos, spec);
case 'f':
- return fwnode_string(out, ptr, spec, fmt + 1);
+ fwnode_string(out, ptr, fmt + 1);
+ return do_width_precision(out, prev_pos, spec);
case 'x':
return pointer_string(out, ptr, spec);
case 'e':
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 20/32] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (18 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 19/32] vsprintf: Refactor device_node_string, fwnode_string Kent Overstreet
@ 2022-08-14 21:19 ` Kent Overstreet
2022-08-14 21:20 ` [PATCH 21/32] Input/joystick/analog: Convert from seq_buf -> printbuf Kent Overstreet
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:19 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Petr Mladek, Rasmus Villemoes
From: Kent Overstreet <kent.overstreet@gmail.com>
This patch cleans up printf_spec handling: these functions only use
spec.field_width and they do not interpret it in the normal way -
instead it's a number of bits/bytes passed in to print, so these
functions are changed to take that parameter directly.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
---
lib/vsprintf.c | 59 +++++++++++++++++++++++---------------------------
1 file changed, 27 insertions(+), 32 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 81d2f3fa1a..e01d660a6f 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1126,18 +1126,23 @@ void resource_string(struct printbuf *out, struct resource *res,
}
static noinline_for_stack
-void hex_string(struct printbuf *out, u8 *addr,
- struct printf_spec spec, const char *fmt)
+void hex_string(struct printbuf *out, const u8 *addr,
+ int len, const char *fmt)
{
- int i, len = 1; /* if we pass '%ph[CDN]', field width remains
- negative value, fallback to the default */
char separator;
- if (spec.field_width == 0)
- /* nothing to print */
+ /* nothing to print */
+ if (len == 0)
return;
- if (check_pointer_spec(out, addr, spec))
+ /* if we pass '%ph[CDN]', field width remains
+ negative value, fallback to the default */
+ if (len < 0)
+ len = 1;
+
+ len = min(len, 64);
+
+ if (check_pointer(out, addr))
return;
switch (fmt[1]) {
@@ -1155,34 +1160,21 @@ void hex_string(struct printbuf *out, u8 *addr,
break;
}
- if (spec.field_width > 0)
- len = min_t(int, spec.field_width, 64);
-
- for (i = 0; i < len; ++i) {
- __prt_char(out, hex_asc_hi(addr[i]));
- __prt_char(out, hex_asc_lo(addr[i]));
-
- if (separator && i != len - 1)
- __prt_char(out, separator);
- }
-
- printbuf_nul_terminate(out);
+ prt_hex_bytes(out, addr, len, 1, separator);
}
static noinline_for_stack
-void bitmap_string(struct printbuf *out, unsigned long *bitmap,
- struct printf_spec spec, const char *fmt)
+void bitmap_string(struct printbuf *out, unsigned long *bitmap, int nr_bits)
{
+ struct printf_spec spec = { .flags = SMALL | ZEROPAD, .base = 16 };
const int CHUNKSZ = 32;
- int nr_bits = max_t(int, spec.field_width, 0);
int i, chunksz;
bool first = true;
- if (check_pointer_spec(out, bitmap, spec))
- return;
+ nr_bits = max(nr_bits, 0);
- /* reused to print numbers */
- spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };
+ if (check_pointer(out, bitmap))
+ return;
chunksz = nr_bits & (CHUNKSZ - 1);
if (chunksz == 0)
@@ -1211,13 +1203,14 @@ void bitmap_string(struct printbuf *out, unsigned long *bitmap,
static noinline_for_stack
void bitmap_list_string(struct printbuf *out, unsigned long *bitmap,
- struct printf_spec spec, const char *fmt)
+ int nr_bits)
{
- int nr_bits = max_t(int, spec.field_width, 0);
bool first = true;
int rbot, rtop;
- if (check_pointer_spec(out, bitmap, spec))
+ nr_bits = max(nr_bits, 0);
+
+ if (check_pointer(out, bitmap))
return ;
for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) {
@@ -2232,13 +2225,15 @@ void pointer(struct printbuf *out, const char *fmt,
resource_string(out, ptr, fmt[0] == 'R');
return do_width_precision(out, prev_pos, spec);
case 'h':
- return hex_string(out, ptr, spec, fmt);
+ /* Uses field_width but _not_ as field size */
+ return hex_string(out, ptr, spec.field_width, fmt);
case 'b':
+ /* Uses field_width but _not_ as field size */
switch (fmt[1]) {
case 'l':
- return bitmap_list_string(out, ptr, spec, fmt);
+ return bitmap_list_string(out, ptr, spec.field_width);
default:
- return bitmap_string(out, ptr, spec, fmt);
+ return bitmap_string(out, ptr, spec.field_width);
}
case 'M': /* Colon separated: 00:01:02:03:04:05 */
case 'm': /* Contiguous: 000102030405 */
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 21/32] Input/joystick/analog: Convert from seq_buf -> printbuf
2022-08-14 21:19 Printbufs v6 Kent Overstreet
` (19 preceding siblings ...)
2022-08-14 21:19 ` [PATCH 20/32] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string Kent Overstreet
@ 2022-08-14 21:20 ` Kent Overstreet
20 siblings, 0 replies; 23+ messages in thread
From: Kent Overstreet @ 2022-08-14 21:20 UTC (permalink / raw)
To: akpm; +Cc: linux-kernel, Kent Overstreet, Dmitry Torokhov
From: Kent Overstreet <kent.overstreet@gmail.com>
seq_buf is being deprecated, this converts to printbuf.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Dmitry Torokhov <dmitry.torokhov@gmail.com>
---
drivers/input/joystick/analog.c | 23 ++++++++++-------------
1 file changed, 10 insertions(+), 13 deletions(-)
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index 3088c5b829..a8c5f90e82 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -19,7 +19,7 @@
#include <linux/input.h>
#include <linux/gameport.h>
#include <linux/jiffies.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/timex.h>
#include <linux/timekeeping.h>
@@ -339,24 +339,21 @@ static void analog_calibrate_timer(struct analog_port *port)
static void analog_name(struct analog *analog)
{
- struct seq_buf s;
+ struct printbuf buf = PRINTBUF_EXTERN(analog->name, sizeof(analog->name));
- seq_buf_init(&s, analog->name, sizeof(analog->name));
- seq_buf_printf(&s, "Analog %d-axis %d-button",
- hweight8(analog->mask & ANALOG_AXES_STD),
- hweight8(analog->mask & ANALOG_BTNS_STD) + !!(analog->mask & ANALOG_BTNS_CHF) * 2 +
- hweight16(analog->mask & ANALOG_BTNS_GAMEPAD) + !!(analog->mask & ANALOG_HBTN_CHF) * 4);
+ prt_printf(&buf, "Analog %d-axis %d-button",
+ hweight8(analog->mask & ANALOG_AXES_STD),
+ hweight8(analog->mask & ANALOG_BTNS_STD) + !!(analog->mask & ANALOG_BTNS_CHF) * 2 +
+ hweight16(analog->mask & ANALOG_BTNS_GAMEPAD) + !!(analog->mask & ANALOG_HBTN_CHF) * 4);
if (analog->mask & ANALOG_HATS_ALL)
- seq_buf_printf(&s, " %d-hat",
- hweight16(analog->mask & ANALOG_HATS_ALL));
-
+ prt_printf(&buf, " %d-hat", hweight16(analog->mask & ANALOG_HATS_ALL));
if (analog->mask & ANALOG_HAT_FCS)
- seq_buf_printf(&s, " FCS");
+ prt_printf(&buf, " FCS");
if (analog->mask & ANALOG_ANY_CHF)
- seq_buf_printf(&s, (analog->mask & ANALOG_SAITEK) ? " Saitek" : " CHF");
+ prt_printf(&buf, (analog->mask & ANALOG_SAITEK) ? " Saitek" : " CHF");
- seq_buf_printf(&s, (analog->mask & ANALOG_GAMEPAD) ? " gamepad" : " joystick");
+ prt_printf(&buf, (analog->mask & ANALOG_GAMEPAD) ? " gamepad" : " joystick");
}
/*
--
2.36.1
^ permalink raw reply related [flat|nested] 23+ messages in thread