* [PATCH v3 00/33] Printbufs
@ 2022-06-04 19:30 Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 01/33] lib/printbuf: New data structure for printing strings Kent Overstreet
` (33 more replies)
0 siblings, 34 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
Printbufs, your new data structure for all your string-building and outputting
needs!
git repo: https://evilpiepirate.org/git/bcachefs.git/log/?h=printbuf_v3
Benefits:
- Replaces passing & returning raw char * pointers and lengths in a ton of
places, including especially vsprintf.c, with a much saner calling convention
- New helpers which greatly simplify and cleanup aforementioned vsprintf.c
- New standard calling convention/naming for pretty printers!
- New printf format string - %pf(%p) - for calling pretty printers by passing
them to sprintf instead of sticking them in vsprintf.c behind weird dispatch
code
- printbufs can auto-heap allocate! No need for statically sized buffers,
unless you want to do that
- Tabstops and indenting, for greatly improved formatting of multi-line output
...and probably more that I've forgotten to mention.
Changes since last patche:
New namespace prefixes:
-----------------------
We're not overloading pr_* anymore: any standard library code that outputs to a
printbuf should use the prt_ prefix. This is not for printbuf control code -
that uses the printbuf_ prefix; prt_ is just for things that print.
string_escape_mem():
--------------------
string_escape_mem() has now been properly converted to printbufs instead of just
adding a printbuf-style wrapper; the new printbuf helpers simplify that code
quite a bit.
hexdump:
--------
The hexdump code has been converted to printbuf and also reorganized and cleaned
up quite a bit, with better naming too. We now have
- prt_hex_bytes(), for printing a few hex bytes, with optional grouping
- prt_hex_line(), for printing a whole line of hex output with ascii characters
at the end
- prt_hex_dump(), for printing a whole multiline hex dump
Important behaviour change:
Previously, the hex dump code would _byte swap the output on little endian_.
Since this is not exactly standard behaviour for a hex dumper (binutils doesn't
do this), and is confusing as hell if you're trying to map byte offsets in
structs to your hex output, I've dropped it. Since we only use the hex dumper in
debug output, nothing should break, but to avoid confusion I've put this front
and center in the commit message for that patch.
tracing:
--------
This iteration of the patch series finally converts tracing to printbufs, which
is the last seq_buf user and that code is now also deleted. The tracing
conversion was pretty uneventful, not much to say here (except that it had its
own unique implementation of hex dumping with byte swabbing on little endian;
this is now replaced with just a call to prt_hex_bytes()).
Kent Overstreet (33):
lib/printbuf: New data structure for printing strings
lib/string_helpers: Convert string_escape_mem() to printbuf
vsprintf: Convert to printbuf
lib/hexdump: Convert to printbuf
vsprintf: %pf(%p)
lib/string_helpers: string_get_size() now returns characters wrote
lib/printbuf: Heap allocation
lib/printbuf: Tabstops, indenting
lib/printbuf: Unit specifiers
lib/pretty-printers: prt_string_option(), prt_bitflags()
vsprintf: Improve number()
vsprintf: prt_u64_minwidth(), prt_u64()
test_printf: Drop requirement that sprintf not write past nul
vsprintf: Start consolidating printf_spec handling
vsprintf: Refactor resource_string()
vsprintf: Refactor fourcc_string()
vsprintf: Refactor ip_addr_string()
vsprintf: Refactor mac_address_string()
vsprintf: time_and_date() no longer takes printf_spec
vsprintf: flags_string() no longer takes printf_spec
vsprintf: Refactor device_node_string, fwnode_string
vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string
Input/joystick/analog: Convert from seq_buf -> printbuf
mm/memcontrol.c: Convert to printbuf
clk: tegra: bpmp: Convert to printbuf
tools/testing/nvdimm: Convert to printbuf
powerpc: Convert to printbuf
x86/resctrl: Convert to printbuf
PCI/P2PDMA: Convert to printbuf
tracing: trace_events_synth: Convert to printbuf
d_path: prt_path()
tracing: Convert to printbuf
Delete seq_buf
Documentation/core-api/printk-formats.rst | 22 +
arch/powerpc/kernel/process.c | 16 +-
arch/powerpc/kernel/security.c | 75 +-
arch/powerpc/platforms/pseries/papr_scm.c | 34 +-
arch/x86/kernel/cpu/resctrl/rdtgroup.c | 16 +-
drivers/clk/tegra/clk-bpmp.c | 21 +-
drivers/input/joystick/analog.c | 23 +-
drivers/pci/p2pdma.c | 17 +-
fs/d_path.c | 34 +
include/linux/dcache.h | 1 +
include/linux/kernel.h | 12 +
include/linux/pretty-printers.h | 10 +
include/linux/printbuf.h | 245 +++
include/linux/seq_buf.h | 162 --
include/linux/string.h | 5 +
include/linux/string_helpers.h | 8 +-
include/linux/trace_events.h | 2 +-
include/linux/trace_seq.h | 14 +-
kernel/trace/trace.c | 45 +-
kernel/trace/trace_dynevent.c | 34 +-
kernel/trace/trace_events_filter.c | 2 +-
kernel/trace/trace_events_synth.c | 32 +-
kernel/trace/trace_functions_graph.c | 6 +-
kernel/trace/trace_kprobe.c | 2 +-
kernel/trace/trace_seq.c | 111 +-
lib/Makefile | 4 +-
lib/hexdump.c | 246 +--
lib/pretty-printers.c | 59 +
lib/printbuf.c | 252 +++
lib/seq_buf.c | 397 -----
lib/string_helpers.c | 141 +-
lib/test_hexdump.c | 30 +-
lib/test_printf.c | 26 +-
lib/vsprintf.c | 1716 ++++++++++-----------
mm/memcontrol.c | 68 +-
tools/testing/nvdimm/test/ndtest.c | 22 +-
36 files changed, 1943 insertions(+), 1967 deletions(-)
create mode 100644 include/linux/pretty-printers.h
create mode 100644 include/linux/printbuf.h
delete mode 100644 include/linux/seq_buf.h
create mode 100644 lib/pretty-printers.c
create mode 100644 lib/printbuf.c
delete mode 100644 lib/seq_buf.c
--
2.36.0
^ permalink raw reply [flat|nested] 48+ messages in thread
* [PATCH v3 01/33] lib/printbuf: New data structure for printing strings
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-09 13:55 ` Petr Mladek
2022-06-04 19:30 ` [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
` (32 subsequent siblings)
33 siblings, 1 reply; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt, Matthew Wilcox
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 | 118 +++++++++++++++++++++++++++++++++++++++
1 file changed, 118 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..8b3797dc4b
--- /dev/null
+++ b/include/linux/printbuf.h
@@ -0,0 +1,118 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/* Copyright (C) 2022 Kent Overstreet */
+
+#ifndef _LINUX_PRINTBUF_H
+#define _LINUX_PRINTBUF_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 min(out->pos, out->size);
+}
+
+/*
+ * 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_chars(struct printbuf *out, char c, unsigned n)
+{
+ memset(out->buf + out->pos,
+ c,
+ min(n, printbuf_remaining(out)));
+ out->pos += n;
+}
+
+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_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_bytes(struct printbuf *out, const void *b, unsigned n)
+{
+ memcpy(out->buf + out->pos,
+ b,
+ min(n, printbuf_remaining(out)));
+ out->pos += n;
+ 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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 01/33] lib/printbuf: New data structure for printing strings Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-09 14:25 ` Petr Mladek
2022-06-04 19:30 ` [PATCH v3 03/33] vsprintf: Convert " Kent Overstreet
` (31 subsequent siblings)
33 siblings, 1 reply; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
include/linux/string_helpers.h | 4 +
lib/string_helpers.c | 134 +++++++++++----------------------
2 files changed, 49 insertions(+), 89 deletions(-)
diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h
index 4d72258d42..67de398944 100644
--- a/include/linux/string_helpers.h
+++ b/include/linux/string_helpers.h
@@ -10,6 +10,7 @@
struct device;
struct file;
struct task_struct;
+struct printbuf;
/* Descriptions of the types of units to
* print in */
@@ -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);
@@ -71,6 +74,7 @@ static inline int string_escape_mem_any_np(const char *src, size_t isz,
return string_escape_mem(src, isz, dst, osz, ESCAPE_ANY_NP, only);
}
+
static inline int string_escape_str(const char *src, char *dst, size_t sz,
unsigned int flags, const char *only)
{
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 4f877e9551..3b1118337e 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
@@ -517,11 +466,10 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
* 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 +497,49 @@ 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);
+
+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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 03/33] vsprintf: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 01/33] lib/printbuf: New data structure for printing strings Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-15 9:09 ` Rasmus Villemoes
2022-06-04 19:30 ` [PATCH v3 04/33] lib/hexdump: " Kent Overstreet
` (30 subsequent siblings)
33 siblings, 1 reply; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
include/linux/kernel.h | 4 +
include/linux/string.h | 5 +
lib/vsprintf.c | 1362 +++++++++++++++++++---------------------
3 files changed, 640 insertions(+), 731 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 b6572aeca2..0a737d5b92 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 40d26a07a1..b686dafb2f 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,42 @@ char *number(char *buf, char *end, unsigned long long num,
if (i > precision)
precision = i;
/* leading space padding */
- field_width -= precision;
+ field_width = max(0, field_width - precision);
if (!(spec.flags & (ZEROPAD | LEFT))) {
- while (--field_width >= 0) {
- if (buf < end)
- *buf = ' ';
- ++buf;
- }
+ __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)) {
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;
- }
+ __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 +558,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 +591,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 = min_t(unsigned, strlen(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 +649,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 +668,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 +684,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 +705,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. */
@@ -825,8 +794,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;
@@ -837,47 +807,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;
@@ -888,7 +860,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);
}
/*
@@ -914,12 +886,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;
@@ -936,9 +909,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);
@@ -951,7 +924,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)
@@ -959,49 +932,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
@@ -1024,9 +995,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
}
@@ -1061,8 +1032,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
@@ -1101,69 +1072,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 */
@@ -1171,10 +1140,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':
@@ -1195,34 +1164,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 };
@@ -1241,54 +1203,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;
@@ -1296,8 +1249,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':
@@ -1324,11 +1277,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');
@@ -1361,24 +1315,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];
@@ -1422,14 +1373,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 */
@@ -1438,81 +1389,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)) {
@@ -1532,44 +1481,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 };
@@ -1588,30 +1535,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;
@@ -1621,21 +1567,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;
@@ -1643,10 +1589,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++]) {
@@ -1681,44 +1627,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':
@@ -1734,60 +1671,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);
@@ -1796,31 +1731,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':
@@ -1834,55 +1767,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':
@@ -1910,21 +1832,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;
@@ -1942,47 +1859,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;
@@ -1991,20 +1909,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 {
@@ -2029,20 +1942,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;
}
@@ -2053,41 +1964,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;
@@ -2097,15 +1998,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;
@@ -2114,25 +2015,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;
@@ -2140,13 +2039,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++;
@@ -2155,32 +2054,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' : '-';
@@ -2188,21 +2083,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;
}
@@ -2212,37 +2107,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)
@@ -2398,8 +2294,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':
@@ -2407,24 +2303,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
@@ -2434,57 +2330,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);
}
}
@@ -2706,52 +2602,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;
@@ -2760,16 +2631,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));
@@ -2779,44 +2643,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:
@@ -2869,21 +2718,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);
@@ -3021,53 +2919,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; \
})
@@ -3098,16 +2989,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;
}
@@ -3127,12 +3014,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))
@@ -3170,15 +3052,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
*
@@ -3188,26 +3070,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) \
({ \
@@ -3224,12 +3094,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);
@@ -3237,16 +3101,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));
@@ -3256,38 +3113,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':
@@ -3303,17 +3146,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++;
@@ -3321,9 +3159,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:
@@ -3366,23 +3202,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 04/33] lib/hexdump: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (2 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 03/33] vsprintf: Convert " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 05/33] vsprintf: %pf(%p) Kent Overstreet
` (29 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 05/33] vsprintf: %pf(%p)
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (3 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 04/33] lib/hexdump: " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 06/33] lib/string_helpers: string_get_size() now returns characters wrote Kent Overstreet
` (28 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt, Matthew Wilcox
This implements two new format strings: both do the same thing, one more
compatible with current gcc format string checking, the other that we'd
like to standardize:
%pf(%p) - more compatible
%(%p) - more prettier
Both can take variable numbers of arguments, i.e. %(%p,%p,%p).
They're used to indicate that snprintf or pr_buf should interpret the
next argument as a pretty-printer function to call, and subsequent
arguments within the parentheses should be passed to the pretty-printer.
A pretty printer takes as its first argument a printbuf, and then zero
or more pointer arguments - integer arguments are not (currently) supported.
Example usage:
static void foo_to_text(struct printbuf *out, struct foo *foo)
{
pr_buf(out, "bar=%u baz=%u", foo->bar, foo->baz);
}
printf("%(%p)", foo_to_text, foo);
The goal is to replace most of our %p format extensions with this
interface, and to move pretty-printers out of the core vsprintf.c code -
this will get us better organization and better discoverability (you'll
be able to cscope to pretty printer calls!), as well as eliminate a lot
of dispatch code in vsprintf.c.
Currently, we can only call pretty printers with pointer arguments. This
could be changed to also allow at least integer arguments in the future
by using libffi.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Reviewed-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
Documentation/core-api/printk-formats.rst | 22 ++++++
lib/test_printf.c | 20 ++++++
lib/vsprintf.c | 81 ++++++++++++++++++++++-
3 files changed, 121 insertions(+), 2 deletions(-)
diff --git a/Documentation/core-api/printk-formats.rst b/Documentation/core-api/printk-formats.rst
index 5e89497ba3..8fc0b62af1 100644
--- a/Documentation/core-api/printk-formats.rst
+++ b/Documentation/core-api/printk-formats.rst
@@ -625,6 +625,28 @@ Examples::
%p4cc Y10 little-endian (0x20303159)
%p4cc NV12 big-endian (0xb231564e)
+Calling a pretty printer function
+---------------------------------
+
+::
+
+ %pf(%p) pretty printer function taking one argument
+ %pf(%p,%p) pretty printer function taking two arguments
+
+For calling generic pretty printers. A pretty printer is a function that takes
+as its first argument a pointer to a printbuf, and then zero or more additional
+pointer arguments. For example:
+
+ void foo_to_text(struct printbuf *out, struct foo *foo)
+ {
+ pr_buf(out, "bar=%u baz=%u", foo->bar, foo->baz);
+ }
+
+ printf("%pf(%p)", foo_to_text, foo);
+
+Note that a pretty-printer may not sleep, if called from printk(). If called
+from pr_buf() or sprintf() there are no such restrictions.
+
Thanks
======
diff --git a/lib/test_printf.c b/lib/test_printf.c
index 07309c45f3..ff833870f5 100644
--- a/lib/test_printf.c
+++ b/lib/test_printf.c
@@ -783,6 +783,25 @@ test_pointer(void)
fourcc_pointer();
}
+static void printf_test_fn(struct printbuf *out, void *p)
+{
+ int *i = p;
+
+ prt_printf(out, "%i", *i);
+}
+
+static void __init
+test_fn(void)
+{
+ int i = 1;
+
+ test("1", "%pf(%p)", printf_test_fn, &i);
+ /*
+ * Not tested, so we don't fail the build with -Werror:
+ */
+ //test("1", "%(%p)", printf_test_fn, &i);
+}
+
static void __init selftest(void)
{
alloced_buffer = kmalloc(BUF_SIZE + 2*PAD_SIZE, GFP_KERNEL);
@@ -794,6 +813,7 @@ static void __init selftest(void)
test_number();
test_string();
test_pointer();
+ test_fn();
kfree(alloced_buffer);
}
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index b686dafb2f..118d6f65c3 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -436,7 +436,8 @@ enum format_type {
FORMAT_TYPE_UINT,
FORMAT_TYPE_INT,
FORMAT_TYPE_SIZE_T,
- FORMAT_TYPE_PTRDIFF
+ FORMAT_TYPE_PTRDIFF,
+ FORMAT_TYPE_FN,
};
struct printf_spec {
@@ -2519,7 +2520,16 @@ int format_decode(const char *fmt, struct printf_spec *spec)
return ++fmt - start;
case 'p':
- spec->type = FORMAT_TYPE_PTR;
+ fmt++;
+ if (fmt[0] == 'f' &&
+ fmt[1] == '(') {
+ fmt += 2;
+ spec->type = FORMAT_TYPE_FN;
+ } else
+ spec->type = FORMAT_TYPE_PTR;
+ return fmt - start;
+ case '(':
+ spec->type = FORMAT_TYPE_FN;
return ++fmt - start;
case '%':
@@ -2601,6 +2611,49 @@ set_precision(struct printf_spec *spec, int prec)
}
}
+static void call_prt_fn(struct printbuf *out, void *fn, void **fn_args, unsigned nr_args)
+{
+ typedef void (*printf_fn_0)(struct printbuf *);
+ typedef void (*printf_fn_1)(struct printbuf *, void *);
+ typedef void (*printf_fn_2)(struct printbuf *, void *, void *);
+ typedef void (*printf_fn_3)(struct printbuf *, void *, void *, void *);
+ typedef void (*printf_fn_4)(struct printbuf *, void *, void *, void *, void *);
+ typedef void (*printf_fn_5)(struct printbuf *, void *, void *, void *, void *, void *);
+ typedef void (*printf_fn_6)(struct printbuf *, void *, void *, void *, void *, void *, void *);
+ typedef void (*printf_fn_7)(struct printbuf *, void *, void *, void *, void *, void *, void *, void *);
+ typedef void (*printf_fn_8)(struct printbuf *, void *, void *, void *, void *, void *, void *, void *, void *);
+
+ switch (nr_args) {
+ case 0:
+ ((printf_fn_0)fn)(out);
+ break;
+ case 1:
+ ((printf_fn_1)fn)(out, fn_args[0]);
+ break;
+ case 2:
+ ((printf_fn_2)fn)(out, fn_args[0], fn_args[1]);
+ break;
+ case 3:
+ ((printf_fn_3)fn)(out, fn_args[0], fn_args[1], fn_args[2]);
+ break;
+ case 4:
+ ((printf_fn_4)fn)(out, fn_args[0], fn_args[1], fn_args[2], fn_args[3]);
+ break;
+ case 5:
+ ((printf_fn_5)fn)(out, fn_args[0], fn_args[1], fn_args[2], fn_args[3], fn_args[4]);
+ break;
+ case 6:
+ ((printf_fn_6)fn)(out, fn_args[0], fn_args[1], fn_args[2], fn_args[3], fn_args[4], fn_args[5]);
+ break;
+ case 7:
+ ((printf_fn_7)fn)(out, fn_args[0], fn_args[1], fn_args[2], fn_args[3], fn_args[4], fn_args[5], fn_args[6]);
+ break;
+ case 8:
+ ((printf_fn_8)fn)(out, fn_args[0], fn_args[1], fn_args[2], fn_args[3], fn_args[4], fn_args[5], fn_args[6], fn_args[7]);
+ break;
+ }
+}
+
/**
* prt_vprintf - Format a string, outputting to a printbuf
* @out: The printbuf to output to
@@ -2664,6 +2717,30 @@ void prt_vprintf(struct printbuf *out, const char *fmt, va_list args)
fmt++;
break;
+ case FORMAT_TYPE_FN: {
+ unsigned nr_args = 0;
+ void *fn_args[8];
+ void *fn = va_arg(args, void *);
+
+ while (1) {
+ if (WARN_ON_ONCE(nr_args == ARRAY_SIZE(fn_args)))
+ goto out;
+ if (*fmt++ != '%')
+ goto out;
+ if (*fmt++ != 'p')
+ goto out;
+ fn_args[nr_args++] = va_arg(args, void *);
+ if (*fmt == ')')
+ break;
+ if (*fmt++ != ',')
+ goto out;
+ }
+
+ call_prt_fn(out, fn, fn_args, nr_args);
+ fmt++; /* past trailing ) */
+ break;
+ }
+
case FORMAT_TYPE_PERCENT_CHAR:
__prt_char(out, '%');
break;
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 06/33] lib/string_helpers: string_get_size() now returns characters wrote
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (4 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 05/33] vsprintf: %pf(%p) Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 07/33] lib/printbuf: Heap allocation Kent Overstreet
` (27 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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 the return value of snprintf().
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
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 67de398944..52e0f1d283 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 3b1118337e..22aa161005 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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 07/33] lib/printbuf: Heap allocation
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (5 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 06/33] lib/string_helpers: string_get_size() now returns characters wrote Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 08/33] lib/printbuf: Tabstops, indenting Kent Overstreet
` (26 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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 | 114 +++++++++++++++++++++++++++++++++------
lib/Makefile | 2 +-
lib/printbuf.c | 70 ++++++++++++++++++++++++
3 files changed, 170 insertions(+), 16 deletions(-)
create mode 100644 lib/printbuf.c
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
index 8b3797dc4b..35236f774a 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -4,18 +4,68 @@
#ifndef _LINUX_PRINTBUF_H
#define _LINUX_PRINTBUF_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.
+ *
+ * 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/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:
*/
@@ -48,13 +98,15 @@ 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_chars(struct printbuf *out, char c, unsigned n)
+static inline void __prt_chars_reserved(struct printbuf *out, char c, unsigned n)
{
memset(out->buf + out->pos,
c,
@@ -64,17 +116,26 @@ 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_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);
@@ -83,6 +144,8 @@ static inline void prt_char(struct printbuf *out, char c)
static inline void prt_bytes(struct printbuf *out, const void *b, unsigned n)
{
+ printbuf_make_room(out, n);
+
memcpy(out->buf + out->pos,
b,
min(n, printbuf_remaining(out)));
@@ -97,22 +160,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 6b9ffc1bd1..b4609a4258 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
+ buildid.o printbuf.o
lib-$(CONFIG_PRINTK) += dump_stack.o
lib-$(CONFIG_SMP) += cpumask.o
diff --git a/lib/printbuf.c b/lib/printbuf.c
new file mode 100644
index 0000000000..0093b34158
--- /dev/null
+++ b/lib/printbuf.c
@@ -0,0 +1,70 @@
+// 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/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);
+ 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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 08/33] lib/printbuf: Tabstops, indenting
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (6 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 07/33] lib/printbuf: Heap allocation Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 09/33] lib/printbuf: Unit specifiers Kent Overstreet
` (25 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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 | 28 +++++++++
lib/printbuf.c | 125 +++++++++++++++++++++++++++++++++++++++
2 files changed, 153 insertions(+)
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
index 35236f774a..8fb074eb67 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -36,6 +36,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/string.h>
@@ -44,18 +61,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 })
diff --git a/lib/printbuf.c b/lib/printbuf.c
index 0093b34158..e11a504abf 100644
--- a/lib/printbuf.c
+++ b/lib/printbuf.c
@@ -11,6 +11,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;
@@ -68,3 +73,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 09/33] lib/printbuf: Unit specifiers
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (7 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 08/33] lib/printbuf: Tabstops, indenting Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-05 1:06 ` Joe Perches
2022-06-04 19:30 ` [PATCH v3 10/33] lib/pretty-printers: prt_string_option(), prt_bitflags() Kent Overstreet
` (24 subsequent siblings)
33 siblings, 1 reply; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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 8fb074eb67..9d6c951626 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -53,10 +53,19 @@
*
* 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/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;
@@ -70,6 +79,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];
};
@@ -83,6 +94,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 e11a504abf..88f1f34fe6 100644
--- a/lib/printbuf.c
+++ b/lib/printbuf.c
@@ -9,6 +9,7 @@
#endif
#include <linux/slab.h>
+#include <linux/string_helpers.h>
#include <linux/printbuf.h>
static inline size_t printbuf_linelen(struct printbuf *buf)
@@ -193,3 +194,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 10/33] lib/pretty-printers: prt_string_option(), prt_bitflags()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (8 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 09/33] lib/printbuf: Unit specifiers Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 11/33] vsprintf: Improve number() Kent Overstreet
` (23 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
include/linux/pretty-printers.h | 10 ++++++
lib/Makefile | 2 +-
lib/pretty-printers.c | 59 +++++++++++++++++++++++++++++++++
3 files changed, 70 insertions(+), 1 deletion(-)
create mode 100644 include/linux/pretty-printers.h
create mode 100644 lib/pretty-printers.c
diff --git a/include/linux/pretty-printers.h b/include/linux/pretty-printers.h
new file mode 100644
index 0000000000..f39d8edfba
--- /dev/null
+++ b/include/linux/pretty-printers.h
@@ -0,0 +1,10 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/* Copyright (C) 2022 Kent Overstreet */
+
+#ifndef _LINUX_PRETTY_PRINTERS_H
+#define _LINUX_PRETTY_PRINTERS_H
+
+void prt_string_option(struct printbuf *, const char * const[], size_t);
+void prt_bitflags(struct printbuf *, const char * const[], u64);
+
+#endif /* _LINUX_PRETTY_PRINTERS_H */
diff --git a/lib/Makefile b/lib/Makefile
index b4609a4258..b520024852 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 printbuf.o
+ buildid.o printbuf.o pretty-printers.o
lib-$(CONFIG_PRINTK) += dump_stack.o
lib-$(CONFIG_SMP) += cpumask.o
diff --git a/lib/pretty-printers.c b/lib/pretty-printers.c
new file mode 100644
index 0000000000..8794eb3824
--- /dev/null
+++ b/lib/pretty-printers.c
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: LGPL-2.1+
+/* Copyright (C) 2022 Kent Overstreet */
+
+#include <linux/kernel.h>
+#include <linux/printbuf.h>
+#include <linux/pretty-printers.h>
+
+/**
+ * prt_string_option - Given a list of strings, print out the list and indicate
+ * which option is selected, with square brackets (sysfs style)
+ *
+ * @out: The printbuf to output to
+ * @list: List of strings to choose from
+ * @selected: The option to highlight, with square brackets
+ */
+void prt_string_option(struct printbuf *out,
+ const char * const list[],
+ size_t selected)
+{
+ size_t i;
+
+ for (i = 0; list[i]; i++) {
+ if (i)
+ prt_char(out, ' ');
+ if (i == selected)
+ prt_char(out, '[');
+ prt_str(out, list[i]);
+ if (i == selected)
+ prt_char(out, ']');
+ }
+}
+EXPORT_SYMBOL(prt_string_option);
+
+/**
+ * prt_bitflags: Given a bitmap and a list of names for each bit, print out which
+ * bits are on, comma separated
+ *
+ * @out: The printbuf to output to
+ * @list: List of names for each bit
+ * @flags: Bits to print
+ */
+void prt_bitflags(struct printbuf *out,
+ const char * const list[], u64 flags)
+{
+ unsigned bit, nr = 0;
+ bool first = true;
+
+ while (list[nr])
+ nr++;
+
+ while (flags && (bit = __ffs(flags)) < nr) {
+ if (!first)
+ prt_char(out, ',');
+ first = false;
+ prt_str(out, list[bit]);
+ flags ^= 1 << bit;
+ }
+}
+EXPORT_SYMBOL(prt_bitflags);
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 11/33] vsprintf: Improve number()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (9 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 10/33] lib/pretty-printers: prt_string_option(), prt_bitflags() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 12/33] vsprintf: prt_u64_minwidth(), prt_u64() Kent Overstreet
` (22 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/vsprintf.c | 82 +++++++++++++++++++++++++-------------------------
1 file changed, 41 insertions(+), 41 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 118d6f65c3..1c5ffc7f28 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -458,92 +458,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))) {
- __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)) {
- 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))
+ __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 */
- __prt_chars(out, ' ', field_width);
+ if (spec.flags & LEFT)
+ __prt_chars_reserved(out, ' ', field_width);
printbuf_nul_terminate(out);
}
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 12/33] vsprintf: prt_u64_minwidth(), prt_u64()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (10 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 11/33] vsprintf: Improve number() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 13/33] test_printf: Drop requirement that sprintf not write past nul Kent Overstreet
` (21 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
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 1c5ffc7f28..7b49a998d3 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, '0', 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 */
@@ -1018,20 +1028,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)
@@ -1231,12 +1227,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);
}
}
@@ -1778,21 +1774,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
@@ -2070,7 +2066,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 13/33] test_printf: Drop requirement that sprintf not write past nul
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (11 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 12/33] vsprintf: prt_u64_minwidth(), prt_u64() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 14/33] vsprintf: Start consolidating printf_spec handling Kent Overstreet
` (20 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/test_printf.c | 6 ------
1 file changed, 6 deletions(-)
diff --git a/lib/test_printf.c b/lib/test_printf.c
index ff833870f5..a702dd5dc0 100644
--- a/lib/test_printf.c
+++ b/lib/test_printf.c
@@ -78,12 +78,6 @@ do_test(int bufsize, const char *expect, int elen,
return 1;
}
- if (memchr_inv(test_buffer + written + 1, FILL_CHAR, BUF_SIZE + PAD_SIZE - (written + 1))) {
- pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote beyond the nul-terminator\n",
- bufsize, fmt);
- return 1;
- }
-
if (memcmp(test_buffer, expect, written)) {
pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote '%s', expected '%.*s'\n",
bufsize, fmt, test_buffer, written, expect);
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 14/33] vsprintf: Start consolidating printf_spec handling
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (12 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 13/33] test_printf: Drop requirement that sprintf not write past nul Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 15/33] vsprintf: Refactor resource_string() Kent Overstreet
` (19 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/vsprintf.c | 245 ++++++++++++++++++++++++++++---------------------
1 file changed, 138 insertions(+), 107 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 7b49a998d3..863040fdaa 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -617,6 +617,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,
@@ -649,7 +662,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)
{
/*
@@ -679,7 +692,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)
{
@@ -687,7 +700,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;
}
@@ -695,16 +708,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)
@@ -830,7 +874,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);
@@ -871,7 +915,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);
}
/*
@@ -901,14 +945,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':
@@ -920,7 +962,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;
}
@@ -934,56 +976,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
@@ -1006,17 +1038,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,
@@ -1075,7 +1102,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, '[');
@@ -1139,7 +1166,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]) {
@@ -1180,7 +1207,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 */
@@ -1219,7 +1246,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) {
@@ -1246,7 +1273,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]) {
@@ -1547,7 +1574,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]) {
@@ -1568,12 +1595,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
@@ -1588,7 +1615,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 {
@@ -1633,7 +1660,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);
@@ -1642,16 +1669,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)) {
@@ -1668,30 +1692,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]) {
@@ -1701,7 +1723,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;
}
}
@@ -1716,9 +1738,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);
@@ -1739,17 +1761,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]) {
@@ -1800,7 +1822,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]) {
@@ -1870,7 +1892,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);
}
}
@@ -1879,16 +1901,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
@@ -1906,7 +1928,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)
@@ -1964,7 +1986,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);
@@ -1980,7 +2002,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]) {
@@ -1995,7 +2017,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);
@@ -2012,10 +2034,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);
}
@@ -2036,12 +2056,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 */
@@ -2062,7 +2082,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 */
@@ -2072,7 +2092,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' : '-';
@@ -2082,18 +2102,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;
@@ -2118,16 +2138,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:
@@ -2294,13 +2314,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);
@@ -2331,28 +2354,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':
@@ -2372,9 +2401,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);
@@ -2675,6 +2704,7 @@ void prt_vprintf(struct printbuf *out, const char *fmt, va_list args)
while (*fmt) {
const char *old_fmt = fmt;
+ unsigned prev_pos = out->pos;
int read = format_decode(fmt, &spec);
fmt += read;
@@ -2704,7 +2734,8 @@ void prt_vprintf(struct printbuf *out, const char *fmt, va_list args)
break;
case FORMAT_TYPE_STR:
- string(out, va_arg(args, char *), spec);
+ string(out, va_arg(args, char *));
+ do_width_precision(out, prev_pos, spec);
break;
case FORMAT_TYPE_PTR:
@@ -3197,7 +3228,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 15/33] vsprintf: Refactor resource_string()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (13 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 14/33] vsprintf: Start consolidating printf_spec handling Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 16/33] vsprintf: Refactor fourcc_string() Kent Overstreet
` (18 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/vsprintf.c | 51 ++++++++++++++++++++++++--------------------------
1 file changed, 24 insertions(+), 27 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 863040fdaa..4256b1d3a5 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1057,7 +1057,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
@@ -1096,62 +1096,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
@@ -2326,7 +2322,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 16/33] vsprintf: Refactor fourcc_string()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (14 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 15/33] vsprintf: Refactor resource_string() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 17/33] vsprintf: Refactor ip_addr_string() Kent Overstreet
` (17 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
- 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>
---
lib/vsprintf.c | 27 ++++++++++++---------------
1 file changed, 12 insertions(+), 15 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 4256b1d3a5..49565e0dc4 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1726,17 +1726,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);
@@ -1746,18 +1744,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
@@ -2361,7 +2357,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 17/33] vsprintf: Refactor ip_addr_string()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (15 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 16/33] vsprintf: Refactor fourcc_string() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 18/33] vsprintf: Refactor mac_address_string() Kent Overstreet
` (16 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
- 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>
---
lib/vsprintf.c | 114 ++++++++++++++++---------------------------------
1 file changed, 37 insertions(+), 77 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 49565e0dc4..964e00b6a2 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1301,13 +1301,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':
@@ -1331,19 +1331,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;
}
}
@@ -1426,8 +1416,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
@@ -1445,41 +1433,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' };
@@ -1502,41 +1469,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 };
@@ -1555,29 +1516,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;
@@ -1587,16 +1546,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
@@ -2343,7 +2302,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 18/33] vsprintf: Refactor mac_address_string()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (16 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 17/33] vsprintf: Refactor ip_addr_string() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 19/33] vsprintf: time_and_date() no longer takes printf_spec Kent Overstreet
` (15 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
- 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>
---
lib/vsprintf.c | 18 +++++++-----------
1 file changed, 7 insertions(+), 11 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 964e00b6a2..6020f55fc0 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1261,15 +1261,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]) {
@@ -1288,16 +1286,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
@@ -2292,7 +2287,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 19/33] vsprintf: time_and_date() no longer takes printf_spec
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (17 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 18/33] vsprintf: Refactor mac_address_string() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 20/33] vsprintf: flags_string() " Kent Overstreet
` (14 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/vsprintf.c | 20 ++++++++++----------
1 file changed, 10 insertions(+), 10 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 6020f55fc0..5de25723a3 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1761,14 +1761,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]) {
@@ -1806,7 +1806,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;
@@ -1824,21 +1824,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?)");
}
}
@@ -2322,7 +2321,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 20/33] vsprintf: flags_string() no longer takes printf_spec
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (18 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 19/33] vsprintf: time_and_date() no longer takes printf_spec Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 21/33] vsprintf: Refactor device_node_string, fwnode_string Kent Overstreet
` (13 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/vsprintf.c | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 5de25723a3..1cd08d0d5b 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1942,12 +1942,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]) {
@@ -1962,7 +1962,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);
@@ -2335,7 +2335,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 21/33] vsprintf: Refactor device_node_string, fwnode_string
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (19 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 20/33] vsprintf: flags_string() " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 22/33] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string Kent Overstreet
` (12 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
- 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>
---
lib/vsprintf.c | 73 ++++++++++++++++++++------------------------------
1 file changed, 29 insertions(+), 44 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 1cd08d0d5b..a0a17a2aac 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1988,25 +1988,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 */
@@ -2015,7 +2010,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, ':');
@@ -2023,43 +2017,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;
}
@@ -2068,39 +2060,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)
@@ -2338,9 +2321,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 22/33] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (20 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 21/33] vsprintf: Refactor device_node_string, fwnode_string Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 23/33] Input/joystick/analog: Convert from seq_buf -> printbuf Kent Overstreet
` (11 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
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>
---
lib/vsprintf.c | 60 +++++++++++++++++++++++---------------------------
1 file changed, 28 insertions(+), 32 deletions(-)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index a0a17a2aac..f5c93c36fa 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -53,6 +53,7 @@
#include <asm/unaligned.h>
#include <linux/string_helpers.h>
+#include <linux/pretty-printers.h>
#include "kstrtox.h"
/* Disable pointer hashing if requested */
@@ -1151,18 +1152,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]) {
@@ -1180,34 +1186,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)
@@ -1236,13 +1229,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) {
@@ -2257,13 +2251,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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 23/33] Input/joystick/analog: Convert from seq_buf -> printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (21 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 22/33] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 24/33] mm/memcontrol.c: Convert to printbuf Kent Overstreet
` (10 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
seq_buf is being deprecated, this converts to printbuf.
Signed-off-by: Kent Overstreet <kent.overstreet@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.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 24/33] mm/memcontrol.c: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (22 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 23/33] Input/joystick/analog: Convert from seq_buf -> printbuf Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 25/33] clk: tegra: bpmp: " Kent Overstreet
` (9 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
This converts memory_stat_format() from seq_buf to printbuf. Printbuf is
simalar to seq_buf except that it heap allocates the string buffer:
here, we were already heap allocating the buffer with kmalloc() so the
conversion is trivial.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
mm/memcontrol.c | 68 ++++++++++++++++++++++++-------------------------
1 file changed, 33 insertions(+), 35 deletions(-)
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 598fece89e..57861dc9fe 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -62,7 +62,7 @@
#include <linux/file.h>
#include <linux/resume_user_mode.h>
#include <linux/psi.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include "internal.h"
#include <net/sock.h>
#include <net/ip.h>
@@ -1461,13 +1461,9 @@ static inline unsigned long memcg_page_state_output(struct mem_cgroup *memcg,
static char *memory_stat_format(struct mem_cgroup *memcg)
{
- struct seq_buf s;
+ struct printbuf buf = PRINTBUF;
int i;
- seq_buf_init(&s, kmalloc(PAGE_SIZE, GFP_KERNEL), PAGE_SIZE);
- if (!s.buffer)
- return NULL;
-
/*
* Provide statistics on the state of the memory subsystem as
* well as cumulative event counters that show past behavior.
@@ -1484,49 +1480,51 @@ static char *memory_stat_format(struct mem_cgroup *memcg)
u64 size;
size = memcg_page_state_output(memcg, memory_stats[i].idx);
- seq_buf_printf(&s, "%s %llu\n", memory_stats[i].name, size);
+ prt_printf(&buf, "%s %llu\n", memory_stats[i].name, size);
if (unlikely(memory_stats[i].idx == NR_SLAB_UNRECLAIMABLE_B)) {
size += memcg_page_state_output(memcg,
NR_SLAB_RECLAIMABLE_B);
- seq_buf_printf(&s, "slab %llu\n", size);
+ prt_printf(&buf, "slab %llu\n", size);
}
}
/* Accumulated memory events */
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGFAULT),
- memcg_events(memcg, PGFAULT));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGMAJFAULT),
- memcg_events(memcg, PGMAJFAULT));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGREFILL),
- memcg_events(memcg, PGREFILL));
- seq_buf_printf(&s, "pgscan %lu\n",
- memcg_events(memcg, PGSCAN_KSWAPD) +
- memcg_events(memcg, PGSCAN_DIRECT));
- seq_buf_printf(&s, "pgsteal %lu\n",
- memcg_events(memcg, PGSTEAL_KSWAPD) +
- memcg_events(memcg, PGSTEAL_DIRECT));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGACTIVATE),
- memcg_events(memcg, PGACTIVATE));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGDEACTIVATE),
- memcg_events(memcg, PGDEACTIVATE));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGLAZYFREE),
- memcg_events(memcg, PGLAZYFREE));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGLAZYFREED),
- memcg_events(memcg, PGLAZYFREED));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGFAULT),
+ memcg_events(memcg, PGFAULT));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGMAJFAULT),
+ memcg_events(memcg, PGMAJFAULT));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGREFILL),
+ memcg_events(memcg, PGREFILL));
+ prt_printf(&buf, "pgscan %lu\n",
+ memcg_events(memcg, PGSCAN_KSWAPD) +
+ memcg_events(memcg, PGSCAN_DIRECT));
+ prt_printf(&buf, "pgsteal %lu\n",
+ memcg_events(memcg, PGSTEAL_KSWAPD) +
+ memcg_events(memcg, PGSTEAL_DIRECT));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGACTIVATE),
+ memcg_events(memcg, PGACTIVATE));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGDEACTIVATE),
+ memcg_events(memcg, PGDEACTIVATE));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGLAZYFREE),
+ memcg_events(memcg, PGLAZYFREE));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(PGLAZYFREED),
+ memcg_events(memcg, PGLAZYFREED));
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(THP_FAULT_ALLOC),
- memcg_events(memcg, THP_FAULT_ALLOC));
- seq_buf_printf(&s, "%s %lu\n", vm_event_name(THP_COLLAPSE_ALLOC),
- memcg_events(memcg, THP_COLLAPSE_ALLOC));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(THP_FAULT_ALLOC),
+ memcg_events(memcg, THP_FAULT_ALLOC));
+ prt_printf(&buf, "%s %lu\n", vm_event_name(THP_COLLAPSE_ALLOC),
+ memcg_events(memcg, THP_COLLAPSE_ALLOC));
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
- /* The above should easily fit into one page */
- WARN_ON_ONCE(seq_buf_has_overflowed(&s));
+ if (buf.allocation_failure) {
+ printbuf_exit(&buf);
+ return NULL;
+ }
- return s.buffer;
+ return buf.buf;
}
#define K(x) ((x) << (PAGE_SHIFT-10))
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 25/33] clk: tegra: bpmp: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (23 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 24/33] mm/memcontrol.c: Convert to printbuf Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 26/33] tools/testing/nvdimm: " Kent Overstreet
` (8 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
This converts from seq_buf to printbuf, which is similar but heap
allocates the string buffer.
Previously in this code the string buffer was allocated on the stack;
this means we've added a new potential memory allocation failure. This
is fine though since it's only for a dev_printk() message.
Memory allocation context: printbuf doesn't take gfp flags, instead we
prefer the new memalloc_no*_(save|restore) interfaces to be used. Here
the surrounding code is already allocating with GFP_KERNEL, so
everything is fine.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
drivers/clk/tegra/clk-bpmp.c | 21 ++++++++++-----------
1 file changed, 10 insertions(+), 11 deletions(-)
diff --git a/drivers/clk/tegra/clk-bpmp.c b/drivers/clk/tegra/clk-bpmp.c
index 6ecf18f71c..301551174c 100644
--- a/drivers/clk/tegra/clk-bpmp.c
+++ b/drivers/clk/tegra/clk-bpmp.c
@@ -5,7 +5,7 @@
#include <linux/clk-provider.h>
#include <linux/device.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/slab.h>
#include <soc/tegra/bpmp.h>
@@ -360,39 +360,38 @@ static void tegra_bpmp_clk_info_dump(struct tegra_bpmp *bpmp,
const struct tegra_bpmp_clk_info *info)
{
const char *prefix = "";
- struct seq_buf buf;
+ struct printbuf buf = PRINTBUF;
unsigned int i;
- char flags[64];
-
- seq_buf_init(&buf, flags, sizeof(flags));
if (info->flags)
- seq_buf_printf(&buf, "(");
+ prt_printf(&buf, "(");
if (info->flags & TEGRA_BPMP_CLK_HAS_MUX) {
- seq_buf_printf(&buf, "%smux", prefix);
+ prt_printf(&buf, "%smux", prefix);
prefix = ", ";
}
if ((info->flags & TEGRA_BPMP_CLK_HAS_SET_RATE) == 0) {
- seq_buf_printf(&buf, "%sfixed", prefix);
+ prt_printf(&buf, "%sfixed", prefix);
prefix = ", ";
}
if (info->flags & TEGRA_BPMP_CLK_IS_ROOT) {
- seq_buf_printf(&buf, "%sroot", prefix);
+ prt_printf(&buf, "%sroot", prefix);
prefix = ", ";
}
if (info->flags)
- seq_buf_printf(&buf, ")");
+ prt_printf(&buf, ")");
dev_printk(level, bpmp->dev, "%03u: %s\n", info->id, info->name);
- dev_printk(level, bpmp->dev, " flags: %lx %s\n", info->flags, flags);
+ dev_printk(level, bpmp->dev, " flags: %lx %s\n", info->flags, printbuf_str(&buf));
dev_printk(level, bpmp->dev, " parents: %u\n", info->num_parents);
for (i = 0; i < info->num_parents; i++)
dev_printk(level, bpmp->dev, " %03u\n", info->parents[i]);
+
+ printbuf_exit(&buf);
}
static int tegra_bpmp_probe_clocks(struct tegra_bpmp *bpmp,
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 26/33] tools/testing/nvdimm: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (24 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 25/33] clk: tegra: bpmp: " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` Kent Overstreet
` (7 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel
Cc: Kent Overstreet, pmladek, rostedt, Dan Williams, Dave Hansen, nvdimm
This converts from seq_buf to printbuf. Here we're using printbuf with
an external buffer, meaning it's a direct conversion.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: nvdimm@lists.linux.dev
---
tools/testing/nvdimm/test/ndtest.c | 22 ++++++++++------------
1 file changed, 10 insertions(+), 12 deletions(-)
diff --git a/tools/testing/nvdimm/test/ndtest.c b/tools/testing/nvdimm/test/ndtest.c
index 4d1a947367..a2097955da 100644
--- a/tools/testing/nvdimm/test/ndtest.c
+++ b/tools/testing/nvdimm/test/ndtest.c
@@ -12,7 +12,7 @@
#include <linux/ndctl.h>
#include <nd-core.h>
#include <linux/printk.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include "../watermark.h"
#include "nfit_test.h"
@@ -740,32 +740,30 @@ static ssize_t flags_show(struct device *dev,
{
struct nvdimm *nvdimm = to_nvdimm(dev);
struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
u64 flags;
flags = dimm->flags;
- seq_buf_init(&s, buf, PAGE_SIZE);
if (flags & PAPR_PMEM_UNARMED_MASK)
- seq_buf_printf(&s, "not_armed ");
+ prt_printf(&s, "not_armed ");
if (flags & PAPR_PMEM_BAD_SHUTDOWN_MASK)
- seq_buf_printf(&s, "flush_fail ");
+ prt_printf(&s, "flush_fail ");
if (flags & PAPR_PMEM_BAD_RESTORE_MASK)
- seq_buf_printf(&s, "restore_fail ");
+ prt_printf(&s, "restore_fail ");
if (flags & PAPR_PMEM_SAVE_MASK)
- seq_buf_printf(&s, "save_fail ");
+ prt_printf(&s, "save_fail ");
if (flags & PAPR_PMEM_SMART_EVENT_MASK)
- seq_buf_printf(&s, "smart_notify ");
+ prt_printf(&s, "smart_notify ");
+ if (printbuf_written(&s))
+ prt_printf(&s, "\n");
- if (seq_buf_used(&s))
- seq_buf_printf(&s, "\n");
-
- return seq_buf_used(&s);
+ return printbuf_written(&s);
}
static DEVICE_ATTR_RO(flags);
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 27/33] powerpc: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
` (32 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt, linuxppc-dev
This converts from seq_buf to printbuf. We're using printbuf in external
buffer mode, so it's a direct conversion, aside from some trivial
refactoring in cpu_show_meltdown() to make the code more consistent.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: linuxppc-dev@lists.ozlabs.org
---
arch/powerpc/kernel/process.c | 16 +++--
arch/powerpc/kernel/security.c | 75 ++++++++++-------------
arch/powerpc/platforms/pseries/papr_scm.c | 34 +++++-----
3 files changed, 57 insertions(+), 68 deletions(-)
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 984813a4d5..fb8ba50223 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -39,7 +39,7 @@
#include <linux/uaccess.h>
#include <linux/elf-randomize.h>
#include <linux/pkeys.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <asm/interrupt.h>
#include <asm/io.h>
@@ -1399,32 +1399,30 @@ void show_user_instructions(struct pt_regs *regs)
{
unsigned long pc;
int n = NR_INSN_TO_PRINT;
- struct seq_buf s;
char buf[96]; /* enough for 8 times 9 + 2 chars */
+ struct printbuf s = PRINTBUF_EXTERN(buf, sizeof(buf));
pc = regs->nip - (NR_INSN_TO_PRINT * 3 / 4 * sizeof(int));
- seq_buf_init(&s, buf, sizeof(buf));
-
while (n) {
int i;
- seq_buf_clear(&s);
+ printbuf_reset(&s);
for (i = 0; i < 8 && n; i++, n--, pc += sizeof(int)) {
int instr;
if (copy_from_user_nofault(&instr, (void __user *)pc,
sizeof(instr))) {
- seq_buf_printf(&s, "XXXXXXXX ");
+ prt_printf(&s, "XXXXXXXX ");
continue;
}
- seq_buf_printf(&s, regs->nip == pc ? "<%08x> " : "%08x ", instr);
+ prt_printf(&s, regs->nip == pc ? "<%08x> " : "%08x ", instr);
}
- if (!seq_buf_has_overflowed(&s))
+ if (printbuf_remaining(&s))
pr_info("%s[%d]: code: %s\n", current->comm,
- current->pid, s.buffer);
+ current->pid, s.buf);
}
}
diff --git a/arch/powerpc/kernel/security.c b/arch/powerpc/kernel/security.c
index d96fd14bd7..b34de62e65 100644
--- a/arch/powerpc/kernel/security.c
+++ b/arch/powerpc/kernel/security.c
@@ -10,7 +10,7 @@
#include <linux/memblock.h>
#include <linux/nospec.h>
#include <linux/prctl.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/debugfs.h>
#include <asm/asm-prototypes.h>
@@ -144,31 +144,28 @@ void __init setup_spectre_v2(void)
#ifdef CONFIG_PPC_BOOK3S_64
ssize_t cpu_show_meltdown(struct device *dev, struct device_attribute *attr, char *buf)
{
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
bool thread_priv;
thread_priv = security_ftr_enabled(SEC_FTR_L1D_THREAD_PRIV);
if (rfi_flush) {
- struct seq_buf s;
- seq_buf_init(&s, buf, PAGE_SIZE - 1);
- seq_buf_printf(&s, "Mitigation: RFI Flush");
+ prt_printf(&s, "Mitigation: RFI Flush");
if (thread_priv)
- seq_buf_printf(&s, ", L1D private per thread");
-
- seq_buf_printf(&s, "\n");
-
- return s.len;
+ prt_printf(&s, ", L1D private per thread");
+
+ prt_printf(&s, "\n");
+ } else if (thread_priv) {
+ prt_printf(&s, "Vulnerable: L1D private per thread\n");
+ } else if (!security_ftr_enabled(SEC_FTR_L1D_FLUSH_HV) &&
+ !security_ftr_enabled(SEC_FTR_L1D_FLUSH_PR)) {
+ prt_printf(&s, "Not affected\n");
+ } else {
+ prt_printf(&s, "Vulnerable\n");
}
- if (thread_priv)
- return sprintf(buf, "Vulnerable: L1D private per thread\n");
-
- if (!security_ftr_enabled(SEC_FTR_L1D_FLUSH_HV) &&
- !security_ftr_enabled(SEC_FTR_L1D_FLUSH_PR))
- return sprintf(buf, "Not affected\n");
-
- return sprintf(buf, "Vulnerable\n");
+ return printbuf_written(&s);
}
ssize_t cpu_show_l1tf(struct device *dev, struct device_attribute *attr, char *buf)
@@ -179,70 +176,66 @@ ssize_t cpu_show_l1tf(struct device *dev, struct device_attribute *attr, char *b
ssize_t cpu_show_spectre_v1(struct device *dev, struct device_attribute *attr, char *buf)
{
- struct seq_buf s;
-
- seq_buf_init(&s, buf, PAGE_SIZE - 1);
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
if (security_ftr_enabled(SEC_FTR_BNDS_CHK_SPEC_BAR)) {
if (barrier_nospec_enabled)
- seq_buf_printf(&s, "Mitigation: __user pointer sanitization");
+ prt_printf(&s, "Mitigation: __user pointer sanitization");
else
- seq_buf_printf(&s, "Vulnerable");
+ prt_printf(&s, "Vulnerable");
if (security_ftr_enabled(SEC_FTR_SPEC_BAR_ORI31))
- seq_buf_printf(&s, ", ori31 speculation barrier enabled");
+ prt_printf(&s, ", ori31 speculation barrier enabled");
- seq_buf_printf(&s, "\n");
+ prt_printf(&s, "\n");
} else
- seq_buf_printf(&s, "Not affected\n");
+ prt_printf(&s, "Not affected\n");
- return s.len;
+ return printbuf_written(&s);
}
ssize_t cpu_show_spectre_v2(struct device *dev, struct device_attribute *attr, char *buf)
{
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
bool bcs, ccd;
- seq_buf_init(&s, buf, PAGE_SIZE - 1);
-
bcs = security_ftr_enabled(SEC_FTR_BCCTRL_SERIALISED);
ccd = security_ftr_enabled(SEC_FTR_COUNT_CACHE_DISABLED);
if (bcs || ccd) {
- seq_buf_printf(&s, "Mitigation: ");
+ prt_printf(&s, "Mitigation: ");
if (bcs)
- seq_buf_printf(&s, "Indirect branch serialisation (kernel only)");
+ prt_printf(&s, "Indirect branch serialisation (kernel only)");
if (bcs && ccd)
- seq_buf_printf(&s, ", ");
+ prt_printf(&s, ", ");
if (ccd)
- seq_buf_printf(&s, "Indirect branch cache disabled");
+ prt_printf(&s, "Indirect branch cache disabled");
} else if (count_cache_flush_type != BRANCH_CACHE_FLUSH_NONE) {
- seq_buf_printf(&s, "Mitigation: Software count cache flush");
+ prt_printf(&s, "Mitigation: Software count cache flush");
if (count_cache_flush_type == BRANCH_CACHE_FLUSH_HW)
- seq_buf_printf(&s, " (hardware accelerated)");
+ prt_printf(&s, " (hardware accelerated)");
} else if (btb_flush_enabled) {
- seq_buf_printf(&s, "Mitigation: Branch predictor state flush");
+ prt_printf(&s, "Mitigation: Branch predictor state flush");
} else {
- seq_buf_printf(&s, "Vulnerable");
+ prt_printf(&s, "Vulnerable");
}
if (bcs || ccd || count_cache_flush_type != BRANCH_CACHE_FLUSH_NONE) {
if (link_stack_flush_type != BRANCH_CACHE_FLUSH_NONE)
- seq_buf_printf(&s, ", Software link stack flush");
+ prt_printf(&s, ", Software link stack flush");
if (link_stack_flush_type == BRANCH_CACHE_FLUSH_HW)
- seq_buf_printf(&s, " (hardware accelerated)");
+ prt_printf(&s, " (hardware accelerated)");
}
- seq_buf_printf(&s, "\n");
+ prt_printf(&s, "\n");
- return s.len;
+ return printbuf_written(&s);
}
#ifdef CONFIG_PPC_BOOK3S_64
diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
index 39962c9055..317d4513db 100644
--- a/arch/powerpc/platforms/pseries/papr_scm.c
+++ b/arch/powerpc/platforms/pseries/papr_scm.c
@@ -12,7 +12,7 @@
#include <linux/libnvdimm.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/nd.h>
#include <asm/plpar_wrappers.h>
@@ -1145,7 +1145,7 @@ static ssize_t perf_stats_show(struct device *dev,
{
int index;
ssize_t rc;
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
struct papr_scm_perf_stat *stat;
struct papr_scm_perf_stats *stats;
struct nvdimm *dimm = to_nvdimm(dev);
@@ -1168,18 +1168,17 @@ static ssize_t perf_stats_show(struct device *dev,
* values. Since stat_id is essentially a char string of
* 8 bytes, simply use the string format specifier to print it.
*/
- seq_buf_init(&s, buf, PAGE_SIZE);
for (index = 0, stat = stats->scm_statistic;
index < be32_to_cpu(stats->num_statistics);
++index, ++stat) {
- seq_buf_printf(&s, "%.8s = 0x%016llX\n",
- stat->stat_id,
- be64_to_cpu(stat->stat_val));
+ prt_printf(&s, "%.8s = 0x%016llX\n",
+ stat->stat_id,
+ be64_to_cpu(stat->stat_val));
}
free_stats:
kfree(stats);
- return rc ? rc : (ssize_t)seq_buf_used(&s);
+ return rc ?: printbuf_written(&s);
}
static DEVICE_ATTR_ADMIN_RO(perf_stats);
@@ -1188,7 +1187,7 @@ static ssize_t flags_show(struct device *dev,
{
struct nvdimm *dimm = to_nvdimm(dev);
struct papr_scm_priv *p = nvdimm_provider_data(dimm);
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
u64 health;
int rc;
@@ -1199,29 +1198,28 @@ static ssize_t flags_show(struct device *dev,
/* Copy health_bitmap locally, check masks & update out buffer */
health = READ_ONCE(p->health_bitmap);
- seq_buf_init(&s, buf, PAGE_SIZE);
if (health & PAPR_PMEM_UNARMED_MASK)
- seq_buf_printf(&s, "not_armed ");
+ prt_printf(&s, "not_armed ");
if (health & PAPR_PMEM_BAD_SHUTDOWN_MASK)
- seq_buf_printf(&s, "flush_fail ");
+ prt_printf(&s, "flush_fail ");
if (health & PAPR_PMEM_BAD_RESTORE_MASK)
- seq_buf_printf(&s, "restore_fail ");
+ prt_printf(&s, "restore_fail ");
if (health & PAPR_PMEM_ENCRYPTED)
- seq_buf_printf(&s, "encrypted ");
+ prt_printf(&s, "encrypted ");
if (health & PAPR_PMEM_SMART_EVENT_MASK)
- seq_buf_printf(&s, "smart_notify ");
+ prt_printf(&s, "smart_notify ");
if (health & PAPR_PMEM_SCRUBBED_AND_LOCKED)
- seq_buf_printf(&s, "scrubbed locked ");
+ prt_printf(&s, "scrubbed locked ");
- if (seq_buf_used(&s))
- seq_buf_printf(&s, "\n");
+ if (printbuf_written(&s))
+ prt_printf(&s, "\n");
- return seq_buf_used(&s);
+ return printbuf_written(&s);
}
DEVICE_ATTR_RO(flags);
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 27/33] powerpc: Convert to printbuf
@ 2022-06-04 19:30 ` Kent Overstreet
0 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: pmladek, linuxppc-dev, Kent Overstreet, rostedt
This converts from seq_buf to printbuf. We're using printbuf in external
buffer mode, so it's a direct conversion, aside from some trivial
refactoring in cpu_show_meltdown() to make the code more consistent.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: linuxppc-dev@lists.ozlabs.org
---
arch/powerpc/kernel/process.c | 16 +++--
arch/powerpc/kernel/security.c | 75 ++++++++++-------------
arch/powerpc/platforms/pseries/papr_scm.c | 34 +++++-----
3 files changed, 57 insertions(+), 68 deletions(-)
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 984813a4d5..fb8ba50223 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -39,7 +39,7 @@
#include <linux/uaccess.h>
#include <linux/elf-randomize.h>
#include <linux/pkeys.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <asm/interrupt.h>
#include <asm/io.h>
@@ -1399,32 +1399,30 @@ void show_user_instructions(struct pt_regs *regs)
{
unsigned long pc;
int n = NR_INSN_TO_PRINT;
- struct seq_buf s;
char buf[96]; /* enough for 8 times 9 + 2 chars */
+ struct printbuf s = PRINTBUF_EXTERN(buf, sizeof(buf));
pc = regs->nip - (NR_INSN_TO_PRINT * 3 / 4 * sizeof(int));
- seq_buf_init(&s, buf, sizeof(buf));
-
while (n) {
int i;
- seq_buf_clear(&s);
+ printbuf_reset(&s);
for (i = 0; i < 8 && n; i++, n--, pc += sizeof(int)) {
int instr;
if (copy_from_user_nofault(&instr, (void __user *)pc,
sizeof(instr))) {
- seq_buf_printf(&s, "XXXXXXXX ");
+ prt_printf(&s, "XXXXXXXX ");
continue;
}
- seq_buf_printf(&s, regs->nip == pc ? "<%08x> " : "%08x ", instr);
+ prt_printf(&s, regs->nip == pc ? "<%08x> " : "%08x ", instr);
}
- if (!seq_buf_has_overflowed(&s))
+ if (printbuf_remaining(&s))
pr_info("%s[%d]: code: %s\n", current->comm,
- current->pid, s.buffer);
+ current->pid, s.buf);
}
}
diff --git a/arch/powerpc/kernel/security.c b/arch/powerpc/kernel/security.c
index d96fd14bd7..b34de62e65 100644
--- a/arch/powerpc/kernel/security.c
+++ b/arch/powerpc/kernel/security.c
@@ -10,7 +10,7 @@
#include <linux/memblock.h>
#include <linux/nospec.h>
#include <linux/prctl.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/debugfs.h>
#include <asm/asm-prototypes.h>
@@ -144,31 +144,28 @@ void __init setup_spectre_v2(void)
#ifdef CONFIG_PPC_BOOK3S_64
ssize_t cpu_show_meltdown(struct device *dev, struct device_attribute *attr, char *buf)
{
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
bool thread_priv;
thread_priv = security_ftr_enabled(SEC_FTR_L1D_THREAD_PRIV);
if (rfi_flush) {
- struct seq_buf s;
- seq_buf_init(&s, buf, PAGE_SIZE - 1);
- seq_buf_printf(&s, "Mitigation: RFI Flush");
+ prt_printf(&s, "Mitigation: RFI Flush");
if (thread_priv)
- seq_buf_printf(&s, ", L1D private per thread");
-
- seq_buf_printf(&s, "\n");
-
- return s.len;
+ prt_printf(&s, ", L1D private per thread");
+
+ prt_printf(&s, "\n");
+ } else if (thread_priv) {
+ prt_printf(&s, "Vulnerable: L1D private per thread\n");
+ } else if (!security_ftr_enabled(SEC_FTR_L1D_FLUSH_HV) &&
+ !security_ftr_enabled(SEC_FTR_L1D_FLUSH_PR)) {
+ prt_printf(&s, "Not affected\n");
+ } else {
+ prt_printf(&s, "Vulnerable\n");
}
- if (thread_priv)
- return sprintf(buf, "Vulnerable: L1D private per thread\n");
-
- if (!security_ftr_enabled(SEC_FTR_L1D_FLUSH_HV) &&
- !security_ftr_enabled(SEC_FTR_L1D_FLUSH_PR))
- return sprintf(buf, "Not affected\n");
-
- return sprintf(buf, "Vulnerable\n");
+ return printbuf_written(&s);
}
ssize_t cpu_show_l1tf(struct device *dev, struct device_attribute *attr, char *buf)
@@ -179,70 +176,66 @@ ssize_t cpu_show_l1tf(struct device *dev, struct device_attribute *attr, char *b
ssize_t cpu_show_spectre_v1(struct device *dev, struct device_attribute *attr, char *buf)
{
- struct seq_buf s;
-
- seq_buf_init(&s, buf, PAGE_SIZE - 1);
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
if (security_ftr_enabled(SEC_FTR_BNDS_CHK_SPEC_BAR)) {
if (barrier_nospec_enabled)
- seq_buf_printf(&s, "Mitigation: __user pointer sanitization");
+ prt_printf(&s, "Mitigation: __user pointer sanitization");
else
- seq_buf_printf(&s, "Vulnerable");
+ prt_printf(&s, "Vulnerable");
if (security_ftr_enabled(SEC_FTR_SPEC_BAR_ORI31))
- seq_buf_printf(&s, ", ori31 speculation barrier enabled");
+ prt_printf(&s, ", ori31 speculation barrier enabled");
- seq_buf_printf(&s, "\n");
+ prt_printf(&s, "\n");
} else
- seq_buf_printf(&s, "Not affected\n");
+ prt_printf(&s, "Not affected\n");
- return s.len;
+ return printbuf_written(&s);
}
ssize_t cpu_show_spectre_v2(struct device *dev, struct device_attribute *attr, char *buf)
{
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
bool bcs, ccd;
- seq_buf_init(&s, buf, PAGE_SIZE - 1);
-
bcs = security_ftr_enabled(SEC_FTR_BCCTRL_SERIALISED);
ccd = security_ftr_enabled(SEC_FTR_COUNT_CACHE_DISABLED);
if (bcs || ccd) {
- seq_buf_printf(&s, "Mitigation: ");
+ prt_printf(&s, "Mitigation: ");
if (bcs)
- seq_buf_printf(&s, "Indirect branch serialisation (kernel only)");
+ prt_printf(&s, "Indirect branch serialisation (kernel only)");
if (bcs && ccd)
- seq_buf_printf(&s, ", ");
+ prt_printf(&s, ", ");
if (ccd)
- seq_buf_printf(&s, "Indirect branch cache disabled");
+ prt_printf(&s, "Indirect branch cache disabled");
} else if (count_cache_flush_type != BRANCH_CACHE_FLUSH_NONE) {
- seq_buf_printf(&s, "Mitigation: Software count cache flush");
+ prt_printf(&s, "Mitigation: Software count cache flush");
if (count_cache_flush_type == BRANCH_CACHE_FLUSH_HW)
- seq_buf_printf(&s, " (hardware accelerated)");
+ prt_printf(&s, " (hardware accelerated)");
} else if (btb_flush_enabled) {
- seq_buf_printf(&s, "Mitigation: Branch predictor state flush");
+ prt_printf(&s, "Mitigation: Branch predictor state flush");
} else {
- seq_buf_printf(&s, "Vulnerable");
+ prt_printf(&s, "Vulnerable");
}
if (bcs || ccd || count_cache_flush_type != BRANCH_CACHE_FLUSH_NONE) {
if (link_stack_flush_type != BRANCH_CACHE_FLUSH_NONE)
- seq_buf_printf(&s, ", Software link stack flush");
+ prt_printf(&s, ", Software link stack flush");
if (link_stack_flush_type == BRANCH_CACHE_FLUSH_HW)
- seq_buf_printf(&s, " (hardware accelerated)");
+ prt_printf(&s, " (hardware accelerated)");
}
- seq_buf_printf(&s, "\n");
+ prt_printf(&s, "\n");
- return s.len;
+ return printbuf_written(&s);
}
#ifdef CONFIG_PPC_BOOK3S_64
diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
index 39962c9055..317d4513db 100644
--- a/arch/powerpc/platforms/pseries/papr_scm.c
+++ b/arch/powerpc/platforms/pseries/papr_scm.c
@@ -12,7 +12,7 @@
#include <linux/libnvdimm.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/nd.h>
#include <asm/plpar_wrappers.h>
@@ -1145,7 +1145,7 @@ static ssize_t perf_stats_show(struct device *dev,
{
int index;
ssize_t rc;
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
struct papr_scm_perf_stat *stat;
struct papr_scm_perf_stats *stats;
struct nvdimm *dimm = to_nvdimm(dev);
@@ -1168,18 +1168,17 @@ static ssize_t perf_stats_show(struct device *dev,
* values. Since stat_id is essentially a char string of
* 8 bytes, simply use the string format specifier to print it.
*/
- seq_buf_init(&s, buf, PAGE_SIZE);
for (index = 0, stat = stats->scm_statistic;
index < be32_to_cpu(stats->num_statistics);
++index, ++stat) {
- seq_buf_printf(&s, "%.8s = 0x%016llX\n",
- stat->stat_id,
- be64_to_cpu(stat->stat_val));
+ prt_printf(&s, "%.8s = 0x%016llX\n",
+ stat->stat_id,
+ be64_to_cpu(stat->stat_val));
}
free_stats:
kfree(stats);
- return rc ? rc : (ssize_t)seq_buf_used(&s);
+ return rc ?: printbuf_written(&s);
}
static DEVICE_ATTR_ADMIN_RO(perf_stats);
@@ -1188,7 +1187,7 @@ static ssize_t flags_show(struct device *dev,
{
struct nvdimm *dimm = to_nvdimm(dev);
struct papr_scm_priv *p = nvdimm_provider_data(dimm);
- struct seq_buf s;
+ struct printbuf s = PRINTBUF_EXTERN(buf, PAGE_SIZE);
u64 health;
int rc;
@@ -1199,29 +1198,28 @@ static ssize_t flags_show(struct device *dev,
/* Copy health_bitmap locally, check masks & update out buffer */
health = READ_ONCE(p->health_bitmap);
- seq_buf_init(&s, buf, PAGE_SIZE);
if (health & PAPR_PMEM_UNARMED_MASK)
- seq_buf_printf(&s, "not_armed ");
+ prt_printf(&s, "not_armed ");
if (health & PAPR_PMEM_BAD_SHUTDOWN_MASK)
- seq_buf_printf(&s, "flush_fail ");
+ prt_printf(&s, "flush_fail ");
if (health & PAPR_PMEM_BAD_RESTORE_MASK)
- seq_buf_printf(&s, "restore_fail ");
+ prt_printf(&s, "restore_fail ");
if (health & PAPR_PMEM_ENCRYPTED)
- seq_buf_printf(&s, "encrypted ");
+ prt_printf(&s, "encrypted ");
if (health & PAPR_PMEM_SMART_EVENT_MASK)
- seq_buf_printf(&s, "smart_notify ");
+ prt_printf(&s, "smart_notify ");
if (health & PAPR_PMEM_SCRUBBED_AND_LOCKED)
- seq_buf_printf(&s, "scrubbed locked ");
+ prt_printf(&s, "scrubbed locked ");
- if (seq_buf_used(&s))
- seq_buf_printf(&s, "\n");
+ if (printbuf_written(&s))
+ prt_printf(&s, "\n");
- return seq_buf_used(&s);
+ return printbuf_written(&s);
}
DEVICE_ATTR_RO(flags);
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 28/33] x86/resctrl: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (26 preceding siblings ...)
2022-06-04 19:30 ` Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 29/33] PCI/P2PDMA: " Kent Overstreet
` (5 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt, x86
This converts from seq_buf to printbuf. We're using printbuf in external
buffer mode, so it's a direct conversion, aside from some trivial
refactoring in cpu_show_meltdown() to make the code more consistent.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: x86@kernel.org
---
arch/x86/kernel/cpu/resctrl/rdtgroup.c | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/arch/x86/kernel/cpu/resctrl/rdtgroup.c b/arch/x86/kernel/cpu/resctrl/rdtgroup.c
index 83f901e2c2..5b6720b6a4 100644
--- a/arch/x86/kernel/cpu/resctrl/rdtgroup.c
+++ b/arch/x86/kernel/cpu/resctrl/rdtgroup.c
@@ -19,7 +19,7 @@
#include <linux/fs_parser.h>
#include <linux/sysfs.h>
#include <linux/kernfs.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/seq_file.h>
#include <linux/sched/signal.h>
#include <linux/sched/task.h>
@@ -51,7 +51,7 @@ static struct kernfs_node *kn_mongrp;
/* Kernel fs node for "mon_data" directory under root */
static struct kernfs_node *kn_mondata;
-static struct seq_buf last_cmd_status;
+static struct printbuf last_cmd_status;
static char last_cmd_status_buf[512];
struct dentry *debugfs_resctrl;
@@ -59,13 +59,13 @@ struct dentry *debugfs_resctrl;
void rdt_last_cmd_clear(void)
{
lockdep_assert_held(&rdtgroup_mutex);
- seq_buf_clear(&last_cmd_status);
+ printbuf_reset(&last_cmd_status);
}
void rdt_last_cmd_puts(const char *s)
{
lockdep_assert_held(&rdtgroup_mutex);
- seq_buf_puts(&last_cmd_status, s);
+ prt_str(&last_cmd_status, s);
}
void rdt_last_cmd_printf(const char *fmt, ...)
@@ -74,7 +74,7 @@ void rdt_last_cmd_printf(const char *fmt, ...)
va_start(ap, fmt);
lockdep_assert_held(&rdtgroup_mutex);
- seq_buf_vprintf(&last_cmd_status, fmt, ap);
+ prt_vprintf(&last_cmd_status, fmt, ap);
va_end(ap);
}
@@ -833,7 +833,7 @@ static int rdt_last_cmd_status_show(struct kernfs_open_file *of,
int len;
mutex_lock(&rdtgroup_mutex);
- len = seq_buf_used(&last_cmd_status);
+ len = printbuf_written(&last_cmd_status);
if (len)
seq_printf(seq, "%.*s", len, last_cmd_status_buf);
else
@@ -3248,8 +3248,8 @@ int __init rdtgroup_init(void)
{
int ret = 0;
- seq_buf_init(&last_cmd_status, last_cmd_status_buf,
- sizeof(last_cmd_status_buf));
+ last_cmd_status = PRINTBUF_EXTERN(last_cmd_status_buf,
+ sizeof(last_cmd_status_buf));
ret = rdtgroup_setup_root();
if (ret)
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 29/33] PCI/P2PDMA: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (27 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 28/33] x86/resctrl: " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-08 21:11 ` Bjorn Helgaas
2022-06-04 19:30 ` [PATCH v3 30/33] tracing: trace_events_synth: " Kent Overstreet
` (4 subsequent siblings)
33 siblings, 1 reply; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt, linux-pci
This converts from seq_buf to printbuf. We're using printbuf in external
buffer mode, so it's a direct conversion, aside from some trivial
refactoring in cpu_show_meltdown() to make the code more consistent.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: linux-pci@vger.kernel.org
---
drivers/pci/p2pdma.c | 17 ++++++-----------
1 file changed, 6 insertions(+), 11 deletions(-)
diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c
index 30b1df3c9d..c40d91912a 100644
--- a/drivers/pci/p2pdma.c
+++ b/drivers/pci/p2pdma.c
@@ -17,7 +17,7 @@
#include <linux/memremap.h>
#include <linux/percpu-refcount.h>
#include <linux/random.h>
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <linux/xarray.h>
enum pci_p2pdma_map_type {
@@ -281,12 +281,9 @@ static int pci_bridge_has_acs_redir(struct pci_dev *pdev)
return 0;
}
-static void seq_buf_print_bus_devfn(struct seq_buf *buf, struct pci_dev *pdev)
+static void prt_bus_devfn(struct printbuf *buf, struct pci_dev *pdev)
{
- if (!buf)
- return;
-
- seq_buf_printf(buf, "%s;", pci_name(pdev));
+ prt_printf(buf, "%s;", pci_name(pdev));
}
static bool cpu_supports_p2pdma(void)
@@ -455,13 +452,11 @@ calc_map_type_and_dist(struct pci_dev *provider, struct pci_dev *client,
struct pci_dev *a = provider, *b = client, *bb;
bool acs_redirects = false;
struct pci_p2pdma *p2pdma;
- struct seq_buf acs_list;
int acs_cnt = 0;
int dist_a = 0;
int dist_b = 0;
char buf[128];
-
- seq_buf_init(&acs_list, buf, sizeof(buf));
+ struct printbuf acs_list = PRINTBUF_EXTERN(buf, sizeof(buf));
/*
* Note, we don't need to take references to devices returned by
@@ -472,7 +467,7 @@ calc_map_type_and_dist(struct pci_dev *provider, struct pci_dev *client,
dist_b = 0;
if (pci_bridge_has_acs_redir(a)) {
- seq_buf_print_bus_devfn(&acs_list, a);
+ prt_bus_devfn(&acs_list, a);
acs_cnt++;
}
@@ -501,7 +496,7 @@ calc_map_type_and_dist(struct pci_dev *provider, struct pci_dev *client,
break;
if (pci_bridge_has_acs_redir(bb)) {
- seq_buf_print_bus_devfn(&acs_list, bb);
+ prt_bus_devfn(&acs_list, bb);
acs_cnt++;
}
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 30/33] tracing: trace_events_synth: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (28 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 29/33] PCI/P2PDMA: " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 31/33] d_path: prt_path() Kent Overstreet
` (3 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt, Ingo Molnar
This converts from seq_buf to printbuf
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Ingo Molnar <mingo@redhat.com>
---
kernel/trace/trace_events_synth.c | 30 ++++++++++++++----------------
1 file changed, 14 insertions(+), 16 deletions(-)
diff --git a/kernel/trace/trace_events_synth.c b/kernel/trace/trace_events_synth.c
index 5e8c07aef0..627e0e45f0 100644
--- a/kernel/trace/trace_events_synth.c
+++ b/kernel/trace/trace_events_synth.c
@@ -5,13 +5,14 @@
* Copyright (C) 2015, 2020 Tom Zanussi <tom.zanussi@linux.intel.com>
*/
-#include <linux/module.h>
#include <linux/kallsyms.h>
-#include <linux/security.h>
+#include <linux/module.h>
#include <linux/mutex.h>
+#include <linux/printbuf.h>
+#include <linux/rculist.h>
+#include <linux/security.h>
#include <linux/slab.h>
#include <linux/stacktrace.h>
-#include <linux/rculist.h>
#include <linux/tracefs.h>
/* for gfp flag names */
@@ -611,7 +612,7 @@ static struct synth_field *parse_synth_field(int argc, char **argv,
const char *prefix = NULL, *field_type = argv[0], *field_name, *array;
struct synth_field *field;
int len, ret = -ENOMEM;
- struct seq_buf s;
+ struct printbuf s;
ssize_t size;
if (!strcmp(field_type, "unsigned")) {
@@ -666,17 +667,15 @@ static struct synth_field *parse_synth_field(int argc, char **argv,
if (!field->type)
goto free;
- seq_buf_init(&s, field->type, len);
+ s = PRINTBUF_EXTERN(field->type, len);
if (prefix)
- seq_buf_puts(&s, prefix);
- seq_buf_puts(&s, field_type);
+ prt_str(&s, prefix);
+ prt_str(&s, field_type);
if (array)
- seq_buf_puts(&s, array);
- if (WARN_ON_ONCE(!seq_buf_buffer_left(&s)))
+ prt_str(&s, array);
+ if (WARN_ON_ONCE(!printbuf_remaining(&s)))
goto free;
- s.buffer[s.len] = '\0';
-
size = synth_field_size(field->type);
if (size < 0) {
if (array)
@@ -694,13 +693,12 @@ static struct synth_field *parse_synth_field(int argc, char **argv,
if (!type)
goto free;
- seq_buf_init(&s, type, len);
- seq_buf_puts(&s, "__data_loc ");
- seq_buf_puts(&s, field->type);
+ s = PRINTBUF_EXTERN(type, len);
+ prt_str(&s, "__data_loc ");
+ prt_str(&s, field->type);
- if (WARN_ON_ONCE(!seq_buf_buffer_left(&s)))
+ if (WARN_ON_ONCE(!printbuf_remaining(&s)))
goto free;
- s.buffer[s.len] = '\0';
kfree(field->type);
field->type = type;
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 31/33] d_path: prt_path()
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (29 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 30/33] tracing: trace_events_synth: " Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 32/33] tracing: Convert to printbuf Kent Overstreet
` (2 subsequent siblings)
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
This implements a new printbuf version of d_path()/mangle_path(), which
will replace the seq_buf version.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
fs/d_path.c | 34 ++++++++++++++++++++++++++++++++++
include/linux/dcache.h | 1 +
2 files changed, 35 insertions(+)
diff --git a/fs/d_path.c b/fs/d_path.c
index e4e0ebad1f..2aa8dfc1a7 100644
--- a/fs/d_path.c
+++ b/fs/d_path.c
@@ -294,6 +294,40 @@ char *d_path(const struct path *path, char *buf, int buflen)
}
EXPORT_SYMBOL(d_path);
+/**
+ * prt_path - format a path for output
+ * @out: printbuf to output to
+ * @path: path to write into the sequence buffer.
+ * @esc: set of characters to escape in the output
+ *
+ * Write a path name into the sequence buffer.
+ *
+ * Returns 0 on success, or error code from d_path
+ */
+int prt_path(struct printbuf *out, const struct path *path, const char *esc)
+{
+ char *p, *buf;
+ size_t size;
+again:
+ buf = out->buf + out->pos;
+ size = printbuf_remaining_size(out);
+
+ p = d_path(path, buf, size);
+ if (IS_ERR(p)) {
+ printbuf_make_room(out, max(64, size * 2));
+ if (printbuf_remaining_size(out) > size)
+ goto again;
+
+ return PTR_ERR(p);
+ }
+
+ p = mangle_path(buf, p, esc);
+ if (p)
+ out->pos += p - buf;
+ return 0;
+}
+EXPORT_SYMBOL(prt_path);
+
/*
* Helper function for dentry_operations.d_dname() members
*/
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index f5bba51480..2181144f9f 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -293,6 +293,7 @@ extern char *d_absolute_path(const struct path *, char *, int);
extern char *d_path(const struct path *, char *, int);
extern char *dentry_path_raw(const struct dentry *, char *, int);
extern char *dentry_path(const struct dentry *, char *, int);
+extern int prt_path(struct printbuf *, const struct path *, const char *);
/* Allocation counts.. */
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 32/33] tracing: Convert to printbuf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (30 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 31/33] d_path: prt_path() Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 33/33] Delete seq_buf Kent Overstreet
2022-06-05 16:21 ` [PATCH v3 00/33] Printbufs Steven Rostedt
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
This converts the seq_bufs in dynevent_cmd and trace_seq to printbufs.
- read_pos in seq_buf doesn't exist in printbuf, so is added to
trace_seq
- seq_buf_to_user doesn't have a printbuf equivalent, so is inlined
into trace_seq_to_user
- seq_buf_putmem_hex currently swabs bytes on little endian, hardcoded
to 8 byte units. This patch switches it to prt_hex_bytes(), which
does _not_ swab.
Otherwise this is largely a direct conversion, with a few slight
refactorings and cleanups.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
include/linux/trace_events.h | 2 +-
include/linux/trace_seq.h | 14 ++--
kernel/trace/trace.c | 45 ++++-------
kernel/trace/trace_dynevent.c | 34 ++++----
kernel/trace/trace_events_filter.c | 2 +-
kernel/trace/trace_events_synth.c | 2 +-
kernel/trace/trace_functions_graph.c | 6 +-
kernel/trace/trace_kprobe.c | 2 +-
kernel/trace/trace_seq.c | 111 ++++++++++++++-------------
9 files changed, 100 insertions(+), 118 deletions(-)
diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
index e6e95a9f07..48471e32f8 100644
--- a/include/linux/trace_events.h
+++ b/include/linux/trace_events.h
@@ -496,7 +496,7 @@ struct dynevent_cmd;
typedef int (*dynevent_create_fn_t)(struct dynevent_cmd *cmd);
struct dynevent_cmd {
- struct seq_buf seq;
+ struct printbuf seq;
const char *event_name;
unsigned int n_fields;
enum dynevent_type type;
diff --git a/include/linux/trace_seq.h b/include/linux/trace_seq.h
index 5a2c650d9e..0aeb9760cb 100644
--- a/include/linux/trace_seq.h
+++ b/include/linux/trace_seq.h
@@ -2,7 +2,7 @@
#ifndef _LINUX_TRACE_SEQ_H
#define _LINUX_TRACE_SEQ_H
-#include <linux/seq_buf.h>
+#include <linux/printbuf.h>
#include <asm/page.h>
@@ -13,14 +13,16 @@
struct trace_seq {
char buffer[PAGE_SIZE];
- struct seq_buf seq;
+ struct printbuf seq;
+ unsigned readpos;
int full;
};
static inline void
trace_seq_init(struct trace_seq *s)
{
- seq_buf_init(&s->seq, s->buffer, PAGE_SIZE);
+ s->seq = PRINTBUF_EXTERN(s->buffer, PAGE_SIZE);
+ s->readpos = 0;
s->full = 0;
}
@@ -39,7 +41,7 @@ trace_seq_init(struct trace_seq *s)
*/
static inline int trace_seq_used(struct trace_seq *s)
{
- return seq_buf_used(&s->seq);
+ return printbuf_written(&s->seq);
}
/**
@@ -54,7 +56,7 @@ static inline int trace_seq_used(struct trace_seq *s)
static inline char *
trace_seq_buffer_ptr(struct trace_seq *s)
{
- return s->buffer + seq_buf_used(&s->seq);
+ return s->buffer + printbuf_written(&s->seq);
}
/**
@@ -66,7 +68,7 @@ trace_seq_buffer_ptr(struct trace_seq *s)
*/
static inline bool trace_seq_has_overflowed(struct trace_seq *s)
{
- return s->full || seq_buf_has_overflowed(&s->seq);
+ return s->full || printbuf_overflowed(&s->seq);
}
/*
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index f4de111fa1..b815a914b5 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -1670,15 +1670,15 @@ static ssize_t trace_seq_to_buffer(struct trace_seq *s, void *buf, size_t cnt)
{
int len;
- if (trace_seq_used(s) <= s->seq.readpos)
+ if (trace_seq_used(s) <= s->readpos)
return -EBUSY;
- len = trace_seq_used(s) - s->seq.readpos;
+ len = trace_seq_used(s) - s->readpos;
if (cnt > len)
cnt = len;
- memcpy(buf, s->buffer + s->seq.readpos, cnt);
+ memcpy(buf, s->buffer + s->readpos, cnt);
- s->seq.readpos += cnt;
+ s->readpos += cnt;
return cnt;
}
@@ -3725,11 +3725,7 @@ static bool trace_safe_str(struct trace_iterator *iter, const char *str,
static const char *show_buffer(struct trace_seq *s)
{
- struct seq_buf *seq = &s->seq;
-
- seq_buf_terminate(seq);
-
- return seq->buffer;
+ return printbuf_str(&s->seq);
}
static DEFINE_STATIC_KEY_FALSE(trace_no_verify);
@@ -6762,12 +6758,12 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
trace_access_lock(iter->cpu_file);
while (trace_find_next_entry_inc(iter) != NULL) {
enum print_line_t ret;
- int save_len = iter->seq.seq.len;
+ int save_pos = iter->seq.seq.pos;
ret = print_trace_line(iter);
if (ret == TRACE_TYPE_PARTIAL_LINE) {
/* don't print partial lines */
- iter->seq.seq.len = save_len;
+ iter->seq.seq.pos = save_pos;
break;
}
if (ret != TRACE_TYPE_NO_CONSUME)
@@ -6789,7 +6785,7 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
/* Now copy what we have to the user */
sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
- if (iter->seq.seq.readpos >= trace_seq_used(&iter->seq))
+ if (iter->seq.readpos >= trace_seq_used(&iter->seq))
trace_seq_init(&iter->seq);
/*
@@ -6815,16 +6811,15 @@ static size_t
tracing_fill_pipe_page(size_t rem, struct trace_iterator *iter)
{
size_t count;
- int save_len;
int ret;
/* Seq buffer is page-sized, exactly what we need. */
for (;;) {
- save_len = iter->seq.seq.len;
+ unsigned save_pos = iter->seq.seq.pos;
ret = print_trace_line(iter);
if (trace_seq_has_overflowed(&iter->seq)) {
- iter->seq.seq.len = save_len;
+ iter->seq.seq.pos = save_pos;
break;
}
@@ -6834,14 +6829,14 @@ tracing_fill_pipe_page(size_t rem, struct trace_iterator *iter)
* anyway to be safe.
*/
if (ret == TRACE_TYPE_PARTIAL_LINE) {
- iter->seq.seq.len = save_len;
+ iter->seq.seq.pos = save_pos;
break;
}
- count = trace_seq_used(&iter->seq) - save_len;
+ count = trace_seq_used(&iter->seq) - save_pos;
if (rem < count) {
rem = 0;
- iter->seq.seq.len = save_len;
+ iter->seq.seq.pos = save_pos;
break;
}
@@ -9817,20 +9812,8 @@ static struct notifier_block trace_die_notifier = {
void
trace_printk_seq(struct trace_seq *s)
{
- /* Probably should print a warning here. */
- if (s->seq.len >= TRACE_MAX_PRINT)
- s->seq.len = TRACE_MAX_PRINT;
-
- /*
- * More paranoid code. Although the buffer size is set to
- * PAGE_SIZE, and TRACE_MAX_PRINT is 1000, this is just
- * an extra layer of protection.
- */
- if (WARN_ON_ONCE(s->seq.len >= s->seq.size))
- s->seq.len = s->seq.size - 1;
-
/* should be zero ended, but we are paranoid. */
- s->buffer[s->seq.len] = 0;
+ printbuf_nul_terminate(&s->seq);
printk(KERN_TRACE "%s", s->buffer);
diff --git a/kernel/trace/trace_dynevent.c b/kernel/trace/trace_dynevent.c
index e34e8182ee..eabeeb97b5 100644
--- a/kernel/trace/trace_dynevent.c
+++ b/kernel/trace/trace_dynevent.c
@@ -295,21 +295,19 @@ int dynevent_arg_add(struct dynevent_cmd *cmd,
struct dynevent_arg *arg,
dynevent_check_arg_fn_t check_arg)
{
- int ret = 0;
-
if (check_arg) {
- ret = check_arg(arg);
+ int ret = check_arg(arg);
if (ret)
return ret;
}
- ret = seq_buf_printf(&cmd->seq, " %s%c", arg->str, arg->separator);
- if (ret) {
+ prt_printf(&cmd->seq, " %s%c", arg->str, arg->separator);
+ if (printbuf_overflowed(&cmd->seq)) {
pr_err("String is too long: %s%c\n", arg->str, arg->separator);
return -E2BIG;
}
- return ret;
+ return 0;
}
/**
@@ -340,25 +338,23 @@ int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
struct dynevent_arg_pair *arg_pair,
dynevent_check_arg_fn_t check_arg)
{
- int ret = 0;
-
if (check_arg) {
- ret = check_arg(arg_pair);
+ int ret = check_arg(arg_pair);
if (ret)
return ret;
}
- ret = seq_buf_printf(&cmd->seq, " %s%c%s%c", arg_pair->lhs,
- arg_pair->operator, arg_pair->rhs,
- arg_pair->separator);
- if (ret) {
+ prt_printf(&cmd->seq, " %s%c%s%c", arg_pair->lhs,
+ arg_pair->operator, arg_pair->rhs,
+ arg_pair->separator);
+ if (printbuf_overflowed(&cmd->seq)) {
pr_err("field string is too long: %s%c%s%c\n", arg_pair->lhs,
arg_pair->operator, arg_pair->rhs,
arg_pair->separator);
return -E2BIG;
}
- return ret;
+ return 0;
}
/**
@@ -373,15 +369,13 @@ int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
*/
int dynevent_str_add(struct dynevent_cmd *cmd, const char *str)
{
- int ret = 0;
-
- ret = seq_buf_puts(&cmd->seq, str);
- if (ret) {
+ prt_str(&cmd->seq, str);
+ if (printbuf_overflowed(&cmd->seq)) {
pr_err("String is too long: %s\n", str);
return -E2BIG;
}
- return ret;
+ return 0;
}
/**
@@ -410,7 +404,7 @@ void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
{
memset(cmd, '\0', sizeof(*cmd));
- seq_buf_init(&cmd->seq, buf, maxlen);
+ cmd->seq = PRINTBUF_EXTERN(buf, maxlen);
cmd->type = type;
cmd->run_command = run_command;
}
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index b458a9afa2..70cfd12410 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -1059,7 +1059,7 @@ static void append_filter_err(struct trace_array *tr,
FILT_ERR_ERRNO, 0);
}
trace_seq_putc(s, 0);
- buf = kmemdup_nul(s->buffer, s->seq.len, GFP_KERNEL);
+ buf = kstrdup(printbuf_str(&s->seq), GFP_KERNEL);
if (buf) {
kfree(filter->filter_string);
filter->filter_string = buf;
diff --git a/kernel/trace/trace_events_synth.c b/kernel/trace/trace_events_synth.c
index 627e0e45f0..ddb2a2737b 100644
--- a/kernel/trace/trace_events_synth.c
+++ b/kernel/trace/trace_events_synth.c
@@ -1512,7 +1512,7 @@ static int synth_event_run_command(struct dynevent_cmd *cmd)
struct synth_event *se;
int ret;
- ret = create_or_delete_synth_event(cmd->seq.buffer);
+ ret = create_or_delete_synth_event(cmd->seq.buf);
if (ret)
return ret;
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 203204cadf..9f270fdde9 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -1022,9 +1022,9 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
goto out;
/* Strip ending newline */
- if (s->buffer[s->seq.len - 1] == '\n') {
- s->buffer[s->seq.len - 1] = '\0';
- s->seq.len--;
+ if (s->buffer[s->seq.pos - 1] == '\n') {
+ s->buffer[s->seq.pos - 1] = '\0';
+ s->seq.pos--;
}
trace_seq_puts(s, " */\n");
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 47cebef785..b97a912eed 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -915,7 +915,7 @@ static int create_or_delete_trace_kprobe(const char *raw_command)
static int trace_kprobe_run_command(struct dynevent_cmd *cmd)
{
- return create_or_delete_trace_kprobe(cmd->seq.buffer);
+ return create_or_delete_trace_kprobe(printbuf_str(&cmd->seq));
}
/**
diff --git a/kernel/trace/trace_seq.c b/kernel/trace/trace_seq.c
index 9c90b3a7dc..240eaad3e5 100644
--- a/kernel/trace/trace_seq.c
+++ b/kernel/trace/trace_seq.c
@@ -25,11 +25,9 @@
*/
#include <linux/uaccess.h>
#include <linux/seq_file.h>
+#include <linux/string.h>
#include <linux/trace_seq.h>
-/* How much buffer is left on the trace_seq? */
-#define TRACE_SEQ_BUF_LEFT(s) seq_buf_buffer_left(&(s)->seq)
-
/*
* trace_seq should work with being initialized with 0s.
*/
@@ -54,7 +52,7 @@ int trace_print_seq(struct seq_file *m, struct trace_seq *s)
__trace_seq_init(s);
- ret = seq_buf_print_seq(m, &s->seq);
+ ret = seq_write(m, s->seq.buf, printbuf_written(&s->seq));
/*
* Only reset this buffer if we successfully wrote to the
@@ -80,7 +78,7 @@ int trace_print_seq(struct seq_file *m, struct trace_seq *s)
*/
void trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
va_list ap;
if (s->full)
@@ -89,12 +87,12 @@ void trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
__trace_seq_init(s);
va_start(ap, fmt);
- seq_buf_vprintf(&s->seq, fmt, ap);
+ prt_vprintf(&s->seq, fmt, ap);
va_end(ap);
/* If we can't write it all, don't bother writing anything */
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
}
}
@@ -111,17 +109,17 @@ EXPORT_SYMBOL_GPL(trace_seq_printf);
void trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
int nmaskbits)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
if (s->full)
return;
__trace_seq_init(s);
- seq_buf_printf(&s->seq, "%*pb", nmaskbits, maskp);
+ prt_printf(&s->seq, "%*pb", nmaskbits, maskp);
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
}
}
@@ -140,18 +138,18 @@ EXPORT_SYMBOL_GPL(trace_seq_bitmask);
*/
void trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
if (s->full)
return;
__trace_seq_init(s);
- seq_buf_vprintf(&s->seq, fmt, args);
+ prt_vprintf(&s->seq, fmt, args);
/* If we can't write it all, don't bother writing anything */
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
}
}
@@ -174,18 +172,18 @@ EXPORT_SYMBOL_GPL(trace_seq_vprintf);
*/
void trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
if (s->full)
return;
__trace_seq_init(s);
- seq_buf_bprintf(&s->seq, fmt, binary);
+ prt_bstrprintf(&s->seq, fmt, binary);
/* If we can't write it all, don't bother writing anything */
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(!printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
return;
}
@@ -211,12 +209,12 @@ void trace_seq_puts(struct trace_seq *s, const char *str)
__trace_seq_init(s);
- if (len > TRACE_SEQ_BUF_LEFT(s)) {
+ if (len > printbuf_remaining(&s->seq)) {
s->full = 1;
return;
}
- seq_buf_putmem(&s->seq, str, len);
+ prt_bytes(&s->seq, str, len);
}
EXPORT_SYMBOL_GPL(trace_seq_puts);
@@ -237,12 +235,12 @@ void trace_seq_putc(struct trace_seq *s, unsigned char c)
__trace_seq_init(s);
- if (TRACE_SEQ_BUF_LEFT(s) < 1) {
+ if (!printbuf_remaining(&s->seq)) {
s->full = 1;
return;
}
- seq_buf_putc(&s->seq, c);
+ prt_char(&s->seq, c);
}
EXPORT_SYMBOL_GPL(trace_seq_putc);
@@ -263,12 +261,12 @@ void trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len)
__trace_seq_init(s);
- if (len > TRACE_SEQ_BUF_LEFT(s)) {
+ if (len > printbuf_remaining(&s->seq)) {
s->full = 1;
return;
}
- seq_buf_putmem(&s->seq, mem, len);
+ prt_bytes(&s->seq, mem, len);
}
EXPORT_SYMBOL_GPL(trace_seq_putmem);
@@ -285,24 +283,17 @@ EXPORT_SYMBOL_GPL(trace_seq_putmem);
void trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
unsigned int len)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
if (s->full)
return;
__trace_seq_init(s);
- /* Each byte is represented by two chars */
- if (len * 2 > TRACE_SEQ_BUF_LEFT(s)) {
- s->full = 1;
- return;
- }
+ prt_hex_bytes(out, mem, len, 8, ' ');
- /* The added spaces can still cause an overflow */
- seq_buf_putmem_hex(&s->seq, mem, len);
-
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
return;
}
@@ -323,22 +314,22 @@ EXPORT_SYMBOL_GPL(trace_seq_putmem_hex);
*/
int trace_seq_path(struct trace_seq *s, const struct path *path)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
if (s->full)
return 0;
__trace_seq_init(s);
- if (TRACE_SEQ_BUF_LEFT(s) < 1) {
+ if (printbuf_remaining(&s->seq) < 1) {
s->full = 1;
return 0;
}
- seq_buf_path(&s->seq, path, "\n");
+ prt_path(&s->seq, path, "\n");
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
return 0;
}
@@ -369,8 +360,25 @@ EXPORT_SYMBOL_GPL(trace_seq_path);
*/
int trace_seq_to_user(struct trace_seq *s, char __user *ubuf, int cnt)
{
+ int ret, len;
+
__trace_seq_init(s);
- return seq_buf_to_user(&s->seq, ubuf, cnt);
+
+ len = printbuf_written(&s->seq);
+ if (len <= s->readpos)
+ return -EBUSY;
+
+ len -= s->readpos;
+ if (cnt > len)
+ cnt = len;
+ ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
+ if (ret == cnt)
+ return -EFAULT;
+
+ cnt -= ret;
+
+ s->readpos += cnt;
+ return cnt;
}
EXPORT_SYMBOL_GPL(trace_seq_to_user);
@@ -378,24 +386,19 @@ int trace_seq_hex_dump(struct trace_seq *s, const char *prefix_str,
int prefix_type, int rowsize, int groupsize,
const void *buf, size_t len, bool ascii)
{
- unsigned int save_len = s->seq.len;
+ unsigned int save_pos = s->seq.pos;
if (s->full)
return 0;
__trace_seq_init(s);
- if (TRACE_SEQ_BUF_LEFT(s) < 1) {
- s->full = 1;
- return 0;
- }
-
- seq_buf_hex_dump(&(s->seq), prefix_str,
- prefix_type, rowsize, groupsize,
- buf, len, ascii);
+ prt_hex_dump(&s->seq, buf, len,
+ prefix_str, prefix_type,
+ rowsize, groupsize, ascii);
- if (unlikely(seq_buf_has_overflowed(&s->seq))) {
- s->seq.len = save_len;
+ if (unlikely(printbuf_overflowed(&s->seq))) {
+ s->seq.pos = save_pos;
s->full = 1;
return 0;
}
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* [PATCH v3 33/33] Delete seq_buf
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (31 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 32/33] tracing: Convert to printbuf Kent Overstreet
@ 2022-06-04 19:30 ` Kent Overstreet
2022-06-05 16:21 ` [PATCH v3 00/33] Printbufs Steven Rostedt
33 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-04 19:30 UTC (permalink / raw)
To: linux-kernel; +Cc: Kent Overstreet, pmladek, rostedt
No longer has any users, so delete it.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
---
include/linux/seq_buf.h | 162 ----------------
lib/Makefile | 2 +-
lib/seq_buf.c | 397 ----------------------------------------
3 files changed, 1 insertion(+), 560 deletions(-)
delete mode 100644 include/linux/seq_buf.h
delete mode 100644 lib/seq_buf.c
diff --git a/include/linux/seq_buf.h b/include/linux/seq_buf.h
deleted file mode 100644
index 5b31c51479..0000000000
--- a/include/linux/seq_buf.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _LINUX_SEQ_BUF_H
-#define _LINUX_SEQ_BUF_H
-
-#include <linux/fs.h>
-
-/*
- * Trace sequences are used to allow a function to call several other functions
- * to create a string of data to use.
- */
-
-/**
- * seq_buf - seq buffer structure
- * @buffer: pointer to the buffer
- * @size: size of the buffer
- * @len: the amount of data inside the buffer
- * @readpos: The next position to read in the buffer.
- */
-struct seq_buf {
- char *buffer;
- size_t size;
- size_t len;
- loff_t readpos;
-};
-
-static inline void seq_buf_clear(struct seq_buf *s)
-{
- s->len = 0;
- s->readpos = 0;
-}
-
-static inline void
-seq_buf_init(struct seq_buf *s, char *buf, unsigned int size)
-{
- s->buffer = buf;
- s->size = size;
- seq_buf_clear(s);
-}
-
-/*
- * seq_buf have a buffer that might overflow. When this happens
- * the len and size are set to be equal.
- */
-static inline bool
-seq_buf_has_overflowed(struct seq_buf *s)
-{
- return s->len > s->size;
-}
-
-static inline void
-seq_buf_set_overflow(struct seq_buf *s)
-{
- s->len = s->size + 1;
-}
-
-/*
- * How much buffer is left on the seq_buf?
- */
-static inline unsigned int
-seq_buf_buffer_left(struct seq_buf *s)
-{
- if (seq_buf_has_overflowed(s))
- return 0;
-
- return s->size - s->len;
-}
-
-/* How much buffer was written? */
-static inline unsigned int seq_buf_used(struct seq_buf *s)
-{
- return min(s->len, s->size);
-}
-
-/**
- * seq_buf_terminate - Make sure buffer is nul terminated
- * @s: the seq_buf descriptor to terminate.
- *
- * This makes sure that the buffer in @s is nul terminated and
- * safe to read as a string.
- *
- * Note, if this is called when the buffer has overflowed, then
- * the last byte of the buffer is zeroed, and the len will still
- * point passed it.
- *
- * After this function is called, s->buffer is safe to use
- * in string operations.
- */
-static inline void seq_buf_terminate(struct seq_buf *s)
-{
- if (WARN_ON(s->size == 0))
- return;
-
- if (seq_buf_buffer_left(s))
- s->buffer[s->len] = 0;
- else
- s->buffer[s->size - 1] = 0;
-}
-
-/**
- * seq_buf_get_buf - get buffer to write arbitrary data to
- * @s: the seq_buf handle
- * @bufp: the beginning of the buffer is stored here
- *
- * Return the number of bytes available in the buffer, or zero if
- * there's no space.
- */
-static inline size_t seq_buf_get_buf(struct seq_buf *s, char **bufp)
-{
- WARN_ON(s->len > s->size + 1);
-
- if (s->len < s->size) {
- *bufp = s->buffer + s->len;
- return s->size - s->len;
- }
-
- *bufp = NULL;
- return 0;
-}
-
-/**
- * seq_buf_commit - commit data to the buffer
- * @s: the seq_buf handle
- * @num: the number of bytes to commit
- *
- * Commit @num bytes of data written to a buffer previously acquired
- * by seq_buf_get. To signal an error condition, or that the data
- * didn't fit in the available space, pass a negative @num value.
- */
-static inline void seq_buf_commit(struct seq_buf *s, int num)
-{
- if (num < 0) {
- seq_buf_set_overflow(s);
- } else {
- /* num must be negative on overflow */
- BUG_ON(s->len + num > s->size);
- s->len += num;
- }
-}
-
-extern __printf(2, 3)
-int seq_buf_printf(struct seq_buf *s, const char *fmt, ...);
-extern __printf(2, 0)
-int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args);
-extern int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s);
-extern int seq_buf_to_user(struct seq_buf *s, char __user *ubuf,
- int cnt);
-extern int seq_buf_puts(struct seq_buf *s, const char *str);
-extern int seq_buf_putc(struct seq_buf *s, unsigned char c);
-extern int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len);
-extern int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
- unsigned int len);
-extern int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc);
-extern int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str,
- int prefix_type, int rowsize, int groupsize,
- const void *buf, size_t len, bool ascii);
-
-#ifdef CONFIG_BINARY_PRINTF
-extern int
-seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary);
-#endif
-
-#endif /* _LINUX_SEQ_BUF_H */
diff --git a/lib/Makefile b/lib/Makefile
index b520024852..f8ad89dc9a 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -32,7 +32,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
idr.o extable.o sha1.o irq_regs.o argv_split.o \
flex_proportions.o ratelimit.o show_mem.o \
is_single_threaded.o plist.o decompress.o kobject_uevent.o \
- earlycpio.o seq_buf.o siphash.o dec_and_lock.o \
+ earlycpio.o siphash.o dec_and_lock.o \
nmi_backtrace.o nodemask.o win_minmax.o memcat_p.o \
buildid.o printbuf.o pretty-printers.o
diff --git a/lib/seq_buf.c b/lib/seq_buf.c
deleted file mode 100644
index 0a68f7aa85..0000000000
--- a/lib/seq_buf.c
+++ /dev/null
@@ -1,397 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * seq_buf.c
- *
- * Copyright (C) 2014 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
- *
- * The seq_buf is a handy tool that allows you to pass a descriptor around
- * to a buffer that other functions can write to. It is similar to the
- * seq_file functionality but has some differences.
- *
- * To use it, the seq_buf must be initialized with seq_buf_init().
- * This will set up the counters within the descriptor. You can call
- * seq_buf_init() more than once to reset the seq_buf to start
- * from scratch.
- */
-#include <linux/uaccess.h>
-#include <linux/seq_file.h>
-#include <linux/seq_buf.h>
-
-/**
- * seq_buf_can_fit - can the new data fit in the current buffer?
- * @s: the seq_buf descriptor
- * @len: The length to see if it can fit in the current buffer
- *
- * Returns true if there's enough unused space in the seq_buf buffer
- * to fit the amount of new data according to @len.
- */
-static bool seq_buf_can_fit(struct seq_buf *s, size_t len)
-{
- return s->len + len <= s->size;
-}
-
-/**
- * seq_buf_print_seq - move the contents of seq_buf into a seq_file
- * @m: the seq_file descriptor that is the destination
- * @s: the seq_buf descriptor that is the source.
- *
- * Returns zero on success, non zero otherwise
- */
-int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s)
-{
- unsigned int len = seq_buf_used(s);
-
- return seq_write(m, s->buffer, len);
-}
-
-/**
- * seq_buf_vprintf - sequence printing of information.
- * @s: seq_buf descriptor
- * @fmt: printf format string
- * @args: va_list of arguments from a printf() type function
- *
- * Writes a vnprintf() format into the sequencce buffer.
- *
- * Returns zero on success, -1 on overflow.
- */
-int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args)
-{
- int len;
-
- WARN_ON(s->size == 0);
-
- if (s->len < s->size) {
- len = vsnprintf(s->buffer + s->len, s->size - s->len, fmt, args);
- if (s->len + len < s->size) {
- s->len += len;
- return 0;
- }
- }
- seq_buf_set_overflow(s);
- return -1;
-}
-
-/**
- * seq_buf_printf - sequence printing of information
- * @s: seq_buf descriptor
- * @fmt: printf format string
- *
- * Writes a printf() format into the sequence buffer.
- *
- * Returns zero on success, -1 on overflow.
- */
-int seq_buf_printf(struct seq_buf *s, const char *fmt, ...)
-{
- va_list ap;
- int ret;
-
- va_start(ap, fmt);
- ret = seq_buf_vprintf(s, fmt, ap);
- va_end(ap);
-
- return ret;
-}
-EXPORT_SYMBOL_GPL(seq_buf_printf);
-
-#ifdef CONFIG_BINARY_PRINTF
-/**
- * seq_buf_bprintf - Write the printf string from binary arguments
- * @s: seq_buf descriptor
- * @fmt: The format string for the @binary arguments
- * @binary: The binary arguments for @fmt.
- *
- * When recording in a fast path, a printf may be recorded with just
- * saving the format and the arguments as they were passed to the
- * function, instead of wasting cycles converting the arguments into
- * ASCII characters. Instead, the arguments are saved in a 32 bit
- * word array that is defined by the format string constraints.
- *
- * This function will take the format and the binary array and finish
- * the conversion into the ASCII string within the buffer.
- *
- * Returns zero on success, -1 on overflow.
- */
-int seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary)
-{
- unsigned int len = seq_buf_buffer_left(s);
- int ret;
-
- WARN_ON(s->size == 0);
-
- if (s->len < s->size) {
- ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
- if (s->len + ret < s->size) {
- s->len += ret;
- return 0;
- }
- }
- seq_buf_set_overflow(s);
- return -1;
-}
-#endif /* CONFIG_BINARY_PRINTF */
-
-/**
- * seq_buf_puts - sequence printing of simple string
- * @s: seq_buf descriptor
- * @str: simple string to record
- *
- * Copy a simple string into the sequence buffer.
- *
- * Returns zero on success, -1 on overflow
- */
-int seq_buf_puts(struct seq_buf *s, const char *str)
-{
- size_t len = strlen(str);
-
- WARN_ON(s->size == 0);
-
- /* Add 1 to len for the trailing null byte which must be there */
- len += 1;
-
- if (seq_buf_can_fit(s, len)) {
- memcpy(s->buffer + s->len, str, len);
- /* Don't count the trailing null byte against the capacity */
- s->len += len - 1;
- return 0;
- }
- seq_buf_set_overflow(s);
- return -1;
-}
-
-/**
- * seq_buf_putc - sequence printing of simple character
- * @s: seq_buf descriptor
- * @c: simple character to record
- *
- * Copy a single character into the sequence buffer.
- *
- * Returns zero on success, -1 on overflow
- */
-int seq_buf_putc(struct seq_buf *s, unsigned char c)
-{
- WARN_ON(s->size == 0);
-
- if (seq_buf_can_fit(s, 1)) {
- s->buffer[s->len++] = c;
- return 0;
- }
- seq_buf_set_overflow(s);
- return -1;
-}
-
-/**
- * seq_buf_putmem - write raw data into the sequenc buffer
- * @s: seq_buf descriptor
- * @mem: The raw memory to copy into the buffer
- * @len: The length of the raw memory to copy (in bytes)
- *
- * There may be cases where raw memory needs to be written into the
- * buffer and a strcpy() would not work. Using this function allows
- * for such cases.
- *
- * Returns zero on success, -1 on overflow
- */
-int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len)
-{
- WARN_ON(s->size == 0);
-
- if (seq_buf_can_fit(s, len)) {
- memcpy(s->buffer + s->len, mem, len);
- s->len += len;
- return 0;
- }
- seq_buf_set_overflow(s);
- return -1;
-}
-
-#define MAX_MEMHEX_BYTES 8U
-#define HEX_CHARS (MAX_MEMHEX_BYTES*2 + 1)
-
-/**
- * seq_buf_putmem_hex - write raw memory into the buffer in ASCII hex
- * @s: seq_buf descriptor
- * @mem: The raw memory to write its hex ASCII representation of
- * @len: The length of the raw memory to copy (in bytes)
- *
- * This is similar to seq_buf_putmem() except instead of just copying the
- * raw memory into the buffer it writes its ASCII representation of it
- * in hex characters.
- *
- * Returns zero on success, -1 on overflow
- */
-int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
- unsigned int len)
-{
- unsigned char hex[HEX_CHARS];
- const unsigned char *data = mem;
- unsigned int start_len;
- int i, j;
-
- WARN_ON(s->size == 0);
-
- BUILD_BUG_ON(MAX_MEMHEX_BYTES * 2 >= HEX_CHARS);
-
- while (len) {
- start_len = min(len, MAX_MEMHEX_BYTES);
-#ifdef __BIG_ENDIAN
- for (i = 0, j = 0; i < start_len; i++) {
-#else
- for (i = start_len-1, j = 0; i >= 0; i--) {
-#endif
- hex[j++] = hex_asc_hi(data[i]);
- hex[j++] = hex_asc_lo(data[i]);
- }
- if (WARN_ON_ONCE(j == 0 || j/2 > len))
- break;
-
- /* j increments twice per loop */
- hex[j++] = ' ';
-
- seq_buf_putmem(s, hex, j);
- if (seq_buf_has_overflowed(s))
- return -1;
-
- len -= start_len;
- data += start_len;
- }
- return 0;
-}
-
-/**
- * seq_buf_path - copy a path into the sequence buffer
- * @s: seq_buf descriptor
- * @path: path to write into the sequence buffer.
- * @esc: set of characters to escape in the output
- *
- * Write a path name into the sequence buffer.
- *
- * Returns the number of written bytes on success, -1 on overflow
- */
-int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc)
-{
- char *buf;
- size_t size = seq_buf_get_buf(s, &buf);
- int res = -1;
-
- WARN_ON(s->size == 0);
-
- if (size) {
- char *p = d_path(path, buf, size);
- if (!IS_ERR(p)) {
- char *end = mangle_path(buf, p, esc);
- if (end)
- res = end - buf;
- }
- }
- seq_buf_commit(s, res);
-
- return res;
-}
-
-/**
- * seq_buf_to_user - copy the sequence buffer to user space
- * @s: seq_buf descriptor
- * @ubuf: The userspace memory location to copy to
- * @cnt: The amount to copy
- *
- * Copies the sequence buffer into the userspace memory pointed to
- * by @ubuf. It starts from the last read position (@s->readpos)
- * and writes up to @cnt characters or till it reaches the end of
- * the content in the buffer (@s->len), which ever comes first.
- *
- * On success, it returns a positive number of the number of bytes
- * it copied.
- *
- * On failure it returns -EBUSY if all of the content in the
- * sequence has been already read, which includes nothing in the
- * sequence (@s->len == @s->readpos).
- *
- * Returns -EFAULT if the copy to userspace fails.
- */
-int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, int cnt)
-{
- int len;
- int ret;
-
- if (!cnt)
- return 0;
-
- len = seq_buf_used(s);
-
- if (len <= s->readpos)
- return -EBUSY;
-
- len -= s->readpos;
- if (cnt > len)
- cnt = len;
- ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
- if (ret == cnt)
- return -EFAULT;
-
- cnt -= ret;
-
- s->readpos += cnt;
- return cnt;
-}
-
-/**
- * seq_buf_hex_dump - print formatted hex dump into the sequence buffer
- * @s: seq_buf descriptor
- * @prefix_str: string to prefix each line with;
- * caller supplies trailing spaces for alignment if desired
- * @prefix_type: controls whether prefix of an offset, address, or none
- * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
- * @rowsize: number of bytes to print per line; must be 16 or 32
- * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
- * @buf: data blob to dump
- * @len: number of bytes in the @buf
- * @ascii: include ASCII after the hex output
- *
- * Function is an analogue of print_hex_dump() and thus has similar interface.
- *
- * linebuf size is maximal length for one line.
- * 32 * 3 - maximum bytes per line, each printed into 2 chars + 1 for
- * separating space
- * 2 - spaces separating hex dump and ascii representation
- * 32 - ascii representation
- * 1 - terminating '\0'
- *
- * Returns zero on success, -1 on overflow
- */
-int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str, int prefix_type,
- int rowsize, int groupsize,
- const void *buf, size_t len, bool ascii)
-{
- const u8 *ptr = buf;
- int i, linelen, remaining = len;
- unsigned char linebuf[32 * 3 + 2 + 32 + 1];
- int ret;
-
- if (rowsize != 16 && rowsize != 32)
- rowsize = 16;
-
- for (i = 0; i < len; i += rowsize) {
- linelen = min(remaining, rowsize);
- remaining -= rowsize;
-
- hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
- linebuf, sizeof(linebuf), ascii);
-
- switch (prefix_type) {
- case DUMP_PREFIX_ADDRESS:
- ret = seq_buf_printf(s, "%s%p: %s\n",
- prefix_str, ptr + i, linebuf);
- break;
- case DUMP_PREFIX_OFFSET:
- ret = seq_buf_printf(s, "%s%.8x: %s\n",
- prefix_str, i, linebuf);
- break;
- default:
- ret = seq_buf_printf(s, "%s%s\n", prefix_str, linebuf);
- break;
- }
- if (ret)
- return ret;
- }
- return 0;
-}
--
2.36.0
^ permalink raw reply related [flat|nested] 48+ messages in thread
* Re: [PATCH v3 09/33] lib/printbuf: Unit specifiers
2022-06-04 19:30 ` [PATCH v3 09/33] lib/printbuf: Unit specifiers Kent Overstreet
@ 2022-06-05 1:06 ` Joe Perches
0 siblings, 0 replies; 48+ messages in thread
From: Joe Perches @ 2022-06-05 1:06 UTC (permalink / raw)
To: Kent Overstreet, linux-kernel; +Cc: pmladek, rostedt
On Sat, 2022-06-04 at 15:30 -0400, Kent Overstreet wrote:
> 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
Mismatched between commit message and code
> diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
[]
> @@ -53,10 +53,19 @@
[]
> +void prt_human_readable_u64(struct printbuf *, u64);
> +void prt_human_readable_s64(struct printbuf *, s64);
etc...
I think pb_ a better prefix
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 00/33] Printbufs
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
` (32 preceding siblings ...)
2022-06-04 19:30 ` [PATCH v3 33/33] Delete seq_buf Kent Overstreet
@ 2022-06-05 16:21 ` Steven Rostedt
2022-06-05 17:55 ` Kent Overstreet
33 siblings, 1 reply; 48+ messages in thread
From: Steven Rostedt @ 2022-06-05 16:21 UTC (permalink / raw)
To: Kent Overstreet; +Cc: linux-kernel, pmladek
On Sat, 4 Jun 2022 15:30:09 -0400
Kent Overstreet <kent.overstreet@gmail.com> wrote:
> Printbufs, your new data structure for all your string-building and outputting
> needs!
>
> git repo: https://evilpiepirate.org/git/bcachefs.git/log/?h=printbuf_v3
Hi Kent,
Just wanted to let you know that I want to review this and I'm not
ignoring it. But there's a still quite a bit in my queue that I must
review before I get to this, so it may still be a while. :-/
-- Steve
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 00/33] Printbufs
2022-06-05 16:21 ` [PATCH v3 00/33] Printbufs Steven Rostedt
@ 2022-06-05 17:55 ` Kent Overstreet
0 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-05 17:55 UTC (permalink / raw)
To: Steven Rostedt; +Cc: linux-kernel, pmladek
On Sun, Jun 05, 2022 at 12:21:10PM -0400, Steven Rostedt wrote:
> On Sat, 4 Jun 2022 15:30:09 -0400
> Kent Overstreet <kent.overstreet@gmail.com> wrote:
>
> > Printbufs, your new data structure for all your string-building and outputting
> > needs!
> >
> > git repo: https://evilpiepirate.org/git/bcachefs.git/log/?h=printbuf_v3
>
> Hi Kent,
>
> Just wanted to let you know that I want to review this and I'm not
> ignoring it. But there's a still quite a bit in my queue that I must
> review before I get to this, so it may still be a while. :-/
Could you just review the parts that touch your code then? The rest has already
seen some review and Petr's going to do more, and I'd like to get this patchset
done and squared away so I can go back to building my OOM debugging improvements
on top of this stuff :)
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 29/33] PCI/P2PDMA: Convert to printbuf
2022-06-04 19:30 ` [PATCH v3 29/33] PCI/P2PDMA: " Kent Overstreet
@ 2022-06-08 21:11 ` Bjorn Helgaas
2022-06-08 23:24 ` Kent Overstreet
0 siblings, 1 reply; 48+ messages in thread
From: Bjorn Helgaas @ 2022-06-08 21:11 UTC (permalink / raw)
To: Kent Overstreet
Cc: linux-kernel, pmladek, rostedt, linux-pci, Logan Gunthorpe
[+cc Logan, maintainer of p2pdma.c]
On Sat, Jun 04, 2022 at 03:30:38PM -0400, Kent Overstreet wrote:
> This converts from seq_buf to printbuf. We're using printbuf in external
> buffer mode, so it's a direct conversion, aside from some trivial
> refactoring in cpu_show_meltdown() to make the code more consistent.
cpu_show_meltdown() doesn't appear in p2pdma.c. Leftover from another
patch? Maybe from 27/33 ("powerpc: Convert to printbuf")?
I'm not opposed to this, but it would be nice to say what the benefit
is. How is printbuf better than seq_buf? It's not obvious from the
patch how this is better/safer/shorter/etc.
Even the cover letter [1] is not very clear about the benefit. Yes, I
see it has something to do with improving buffer management, and I
know from experience that's a pain. Concrete examples of typical
printbuf usage and bugs that printbufs avoid would be helpful.
I guess "external buffer mode" means we use an existing buffer (on the
stack in this case) instead of allocating a buffer from the heap [2]?
And we do that for performance (i.e., we know the max size) and to
avoid sleeping to alloc?
Are there any other printf-type things in drivers/pci that
could/should be converted? Is this basically a seq_buf replacement,
so we can find everything with "git grep seq_buf drivers/pci/"?
[1] https://lore.kernel.org/all/20220604193042.1674951-1-kent.overstreet@gmail.com/
[2] https://lore.kernel.org/all/20220604193042.1674951-8-kent.overstreet@gmail.com/
> Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
> Cc: linux-pci@vger.kernel.org
> ---
> drivers/pci/p2pdma.c | 17 ++++++-----------
> 1 file changed, 6 insertions(+), 11 deletions(-)
>
> diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c
> index 30b1df3c9d..c40d91912a 100644
> --- a/drivers/pci/p2pdma.c
> +++ b/drivers/pci/p2pdma.c
> @@ -17,7 +17,7 @@
> #include <linux/memremap.h>
> #include <linux/percpu-refcount.h>
> #include <linux/random.h>
> -#include <linux/seq_buf.h>
> +#include <linux/printbuf.h>
> #include <linux/xarray.h>
>
> enum pci_p2pdma_map_type {
> @@ -281,12 +281,9 @@ static int pci_bridge_has_acs_redir(struct pci_dev *pdev)
> return 0;
> }
>
> -static void seq_buf_print_bus_devfn(struct seq_buf *buf, struct pci_dev *pdev)
> +static void prt_bus_devfn(struct printbuf *buf, struct pci_dev *pdev)
> {
> - if (!buf)
> - return;
> -
> - seq_buf_printf(buf, "%s;", pci_name(pdev));
> + prt_printf(buf, "%s;", pci_name(pdev));
> }
>
> static bool cpu_supports_p2pdma(void)
> @@ -455,13 +452,11 @@ calc_map_type_and_dist(struct pci_dev *provider, struct pci_dev *client,
> struct pci_dev *a = provider, *b = client, *bb;
> bool acs_redirects = false;
> struct pci_p2pdma *p2pdma;
> - struct seq_buf acs_list;
> int acs_cnt = 0;
> int dist_a = 0;
> int dist_b = 0;
> char buf[128];
> -
> - seq_buf_init(&acs_list, buf, sizeof(buf));
> + struct printbuf acs_list = PRINTBUF_EXTERN(buf, sizeof(buf));
>
> /*
> * Note, we don't need to take references to devices returned by
> @@ -472,7 +467,7 @@ calc_map_type_and_dist(struct pci_dev *provider, struct pci_dev *client,
> dist_b = 0;
>
> if (pci_bridge_has_acs_redir(a)) {
> - seq_buf_print_bus_devfn(&acs_list, a);
> + prt_bus_devfn(&acs_list, a);
> acs_cnt++;
> }
>
> @@ -501,7 +496,7 @@ calc_map_type_and_dist(struct pci_dev *provider, struct pci_dev *client,
> break;
>
> if (pci_bridge_has_acs_redir(bb)) {
> - seq_buf_print_bus_devfn(&acs_list, bb);
> + prt_bus_devfn(&acs_list, bb);
> acs_cnt++;
> }
>
> --
> 2.36.0
>
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 29/33] PCI/P2PDMA: Convert to printbuf
2022-06-08 21:11 ` Bjorn Helgaas
@ 2022-06-08 23:24 ` Kent Overstreet
2022-06-08 23:34 ` Logan Gunthorpe
2022-06-08 23:40 ` Bjorn Helgaas
0 siblings, 2 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-08 23:24 UTC (permalink / raw)
To: Bjorn Helgaas; +Cc: linux-kernel, pmladek, rostedt, linux-pci, Logan Gunthorpe
On 6/8/22 17:11, Bjorn Helgaas wrote:
> [+cc Logan, maintainer of p2pdma.c]
>
> On Sat, Jun 04, 2022 at 03:30:38PM -0400, Kent Overstreet wrote:
>> This converts from seq_buf to printbuf. We're using printbuf in external
>> buffer mode, so it's a direct conversion, aside from some trivial
>> refactoring in cpu_show_meltdown() to make the code more consistent.
>
> cpu_show_meltdown() doesn't appear in p2pdma.c. Leftover from another
> patch? Maybe from 27/33 ("powerpc: Convert to printbuf")?
>
> I'm not opposed to this, but it would be nice to say what the benefit
> is. How is printbuf better than seq_buf? It's not obvious from the
> patch how this is better/safer/shorter/etc.
>
> Even the cover letter [1] is not very clear about the benefit. Yes, I
> see it has something to do with improving buffer management, and I
> know from experience that's a pain. Concrete examples of typical
> printbuf usage and bugs that printbufs avoid would be helpful.
Take a look at the vsprintf.c conversion if you want to see big
improvements. Also, %pf() is another thing that's going to enable a lot
more improvements.
> I guess "external buffer mode" means we use an existing buffer (on the
> stack in this case) instead of allocating a buffer from the heap [2]?
> And we do that for performance (i.e., we know the max size) and to
> avoid sleeping to alloc?
I did it that way because I didn't want to touch unrelated code more
than was necessary - just doing a direct conversion. Heap allocation
would probably make sense here, but it's not my code.
> Are there any other printf-type things in drivers/pci that
> could/should be converted? Is this basically a seq_buf replacement,
> so we can find everything with "git grep seq_buf drivers/pci/"?
All seq_buf uses are fully converted to printbuf in this patch series,
and seq_buf is removed.
There is a lot of non seq_buf code that still uses raw char * pointers
and lengths that should be converted to printbuf, but this patch series
already does a lot of that and I'm not trying to boil the oceans today... :)
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 29/33] PCI/P2PDMA: Convert to printbuf
2022-06-08 23:24 ` Kent Overstreet
@ 2022-06-08 23:34 ` Logan Gunthorpe
2022-06-08 23:40 ` Bjorn Helgaas
1 sibling, 0 replies; 48+ messages in thread
From: Logan Gunthorpe @ 2022-06-08 23:34 UTC (permalink / raw)
To: Kent Overstreet, Bjorn Helgaas; +Cc: linux-kernel, pmladek, rostedt, linux-pci
On 2022-06-08 17:24, Kent Overstreet wrote:
> On 6/8/22 17:11, Bjorn Helgaas wrote:
>> [+cc Logan, maintainer of p2pdma.c]
>>
>> On Sat, Jun 04, 2022 at 03:30:38PM -0400, Kent Overstreet wrote:
>>> This converts from seq_buf to printbuf. We're using printbuf in external
>>> buffer mode, so it's a direct conversion, aside from some trivial
>>> refactoring in cpu_show_meltdown() to make the code more consistent.
>>
>> cpu_show_meltdown() doesn't appear in p2pdma.c. Leftover from another
>> patch? Maybe from 27/33 ("powerpc: Convert to printbuf")?
>>
>> I'm not opposed to this, but it would be nice to say what the benefit
>> is. How is printbuf better than seq_buf? It's not obvious from the
>> patch how this is better/safer/shorter/etc.
>>
>> Even the cover letter [1] is not very clear about the benefit. Yes, I
>> see it has something to do with improving buffer management, and I
>> know from experience that's a pain. Concrete examples of typical
>> printbuf usage and bugs that printbufs avoid would be helpful.
>
> Take a look at the vsprintf.c conversion if you want to see big
> improvements. Also, %pf() is another thing that's going to enable a lot
> more improvements.
IMHO I'm not sure how these benefits are a result of what looks largely
like a rewrite and rename of seq_buf... Seems to me like it should be
possible to stick with seq_buf and add features to it instead of doing a
replace and remove. As I understand the kernel community, that is always
the preferred practice and would certainly reduce a lot of churn in this
series. But I haven't looked at the entire series and it's not really
something I'm responsible for, so take my opinion with a grain of salt.
>> I guess "external buffer mode" means we use an existing buffer (on the
>> stack in this case) instead of allocating a buffer from the heap [2]?
>> And we do that for performance (i.e., we know the max size) and to
>> avoid sleeping to alloc?
>
> I did it that way because I didn't want to touch unrelated code more
> than was necessary - just doing a direct conversion. Heap allocation
> would probably make sense here, but it's not my code.
It was changed to a heap allocation recently because my pending patch
set will add a path where this code is called in an atomic context and
cannot sleep. Simplest solution was stack allocation instead of tracking
GFP context for the atomic path.
Logan
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 29/33] PCI/P2PDMA: Convert to printbuf
2022-06-08 23:24 ` Kent Overstreet
2022-06-08 23:34 ` Logan Gunthorpe
@ 2022-06-08 23:40 ` Bjorn Helgaas
1 sibling, 0 replies; 48+ messages in thread
From: Bjorn Helgaas @ 2022-06-08 23:40 UTC (permalink / raw)
To: Kent Overstreet
Cc: linux-kernel, pmladek, rostedt, linux-pci, Logan Gunthorpe
On Wed, Jun 08, 2022 at 07:24:02PM -0400, Kent Overstreet wrote:
> On 6/8/22 17:11, Bjorn Helgaas wrote:
> > On Sat, Jun 04, 2022 at 03:30:38PM -0400, Kent Overstreet wrote:
> > > This converts from seq_buf to printbuf. We're using printbuf in external
> > > buffer mode, so it's a direct conversion, aside from some trivial
> > > refactoring in cpu_show_meltdown() to make the code more consistent.
> >
> > cpu_show_meltdown() doesn't appear in p2pdma.c. Leftover from another
> > patch? Maybe from 27/33 ("powerpc: Convert to printbuf")?
Don't forget this part :)
> > I'm not opposed to this, but it would be nice to say what the benefit
> > is. How is printbuf better than seq_buf? It's not obvious from the
> > patch how this is better/safer/shorter/etc.
> >
> > Even the cover letter [1] is not very clear about the benefit. Yes, I
> > see it has something to do with improving buffer management, and I
> > know from experience that's a pain. Concrete examples of typical
> > printbuf usage and bugs that printbufs avoid would be helpful.
>
> Take a look at the vsprintf.c conversion if you want to see big
> improvements. Also, %pf() is another thing that's going to enable a lot more
> improvements.
Like I said, I'm not opposed to this, I'm just looking for a hint in
this commit log that makes me think "yes, this is a good idea for
PCI."
Right now it just says "converts X to Y." I'm hoping for "convert X
to Y to avoid <some problem with X>."
Bjorn
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 01/33] lib/printbuf: New data structure for printing strings
2022-06-04 19:30 ` [PATCH v3 01/33] lib/printbuf: New data structure for printing strings Kent Overstreet
@ 2022-06-09 13:55 ` Petr Mladek
0 siblings, 0 replies; 48+ messages in thread
From: Petr Mladek @ 2022-06-09 13:55 UTC (permalink / raw)
To: Kent Overstreet; +Cc: linux-kernel, rostedt, Matthew Wilcox
On Sat 2022-06-04 15:30:10, Kent Overstreet wrote:
> 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 | 118 +++++++++++++++++++++++++++++++++++++++
> 1 file changed, 118 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..8b3797dc4b
> --- /dev/null
> +++ b/include/linux/printbuf.h
> @@ -0,0 +1,118 @@
> +/* SPDX-License-Identifier: LGPL-2.1+ */
> +/* Copyright (C) 2022 Kent Overstreet */
> +
> +#ifndef _LINUX_PRINTBUF_H
> +#define _LINUX_PRINTBUF_H
> +
> +#include <linux/string.h>
> +
> +/*
> + * Printbufs: String buffer for outputting (printing) to, for vsnprintf
It might be worth to mention:
@pos is the position that would be used to write into the buffer.
The string is truncated when @pos is greater or equal to
the buffer @size.
@buf might be NULL and @size zero when the buffer is used just
to count the needed buffer size.
It is visible in the code. But it would be nice to explicitly
mention it because it is one important feature of this buffer.
> + */
> +
> +struct printbuf {
> + char *buf;
> + unsigned size;
> + unsigned pos;
> +};
> +
> +static inline void __prt_chars(struct printbuf *out, char c, unsigned n)
> +{
> + memset(out->buf + out->pos,
> + c,
> + min(n, printbuf_remaining(out)));
> + out->pos += n;
> +}
Thanks for using "prt_" prefix. It is better than "pr_", definitely.
Though, I wonder if you considered using:
pb_ aka "Print to Buffer"
ppb_ aka "Print to PrintBuffer"
bpr_ aka "Buffer Print"
to make it more obvious that it is printing into some buffer.
I promise that this is my last try to bikeshed about the prefix.
I just want to get it "right" before you extend the patchset even
more.
Otherwise, the code looks good to me.
Best Regards,
Petr
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf
2022-06-04 19:30 ` [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
@ 2022-06-09 14:25 ` Petr Mladek
2022-06-09 17:53 ` Kent Overstreet
0 siblings, 1 reply; 48+ messages in thread
From: Petr Mladek @ 2022-06-09 14:25 UTC (permalink / raw)
To: Kent Overstreet; +Cc: linux-kernel, rostedt
On Sat 2022-06-04 15:30:11, Kent Overstreet wrote:
> 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.
>
> --- 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);
This modifies the behavior. The original code did not add
the trailing '\0'.
I agree that the original behavior is ugly but it is documented
see the comment:
* 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.
^^^^^^^^^^^^^^
I am all for changing the behavior but it would require checking
all callers.
Anyway, adding the trailing '\0' all is not much effective.
I suggest to use __prt_char() and add the trailing '\0' when
the string is complete.
We must make sure that __prt_char() is able to add the last
character even when there will not longer be space for
the trailing '\0'.
> 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
> @@ -517,11 +466,10 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
> * 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 +497,49 @@ 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);
> +
> +int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
> + unsigned int flags, const char *only)
We need keep the comment above this API as long as it is public.
Note that it uses the docbook comment format, starging with /** ...
And the symbol is exported.
It is even more important because of the crazy behavior where
it does not add the trailing '\0'.
> +{
> + 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);
Note: If you decided to change/fix the behavior then please do so
in a separate patch(set). I was able to catch the problem
because the patch was straightforward and "easy" to review.
Best Regards,
Petr
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf
2022-06-09 14:25 ` Petr Mladek
@ 2022-06-09 17:53 ` Kent Overstreet
0 siblings, 0 replies; 48+ messages in thread
From: Kent Overstreet @ 2022-06-09 17:53 UTC (permalink / raw)
To: Petr Mladek; +Cc: linux-kernel, rostedt
On 6/9/22 10:25, Petr Mladek wrote:
> On Sat 2022-06-04 15:30:11, Kent Overstreet wrote:
>> 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.
>>
>> --- 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);
>
> This modifies the behavior. The original code did not add
> the trailing '\0'.
>
> I agree that the original behavior is ugly but it is documented
> see the comment:
>
> * 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.
> ^^^^^^^^^^^^^^
>
>
> I am all for changing the behavior but it would require checking
> all callers.
>
> Anyway, adding the trailing '\0' all is not much effective.
> I suggest to use __prt_char() and add the trailing '\0' when
> the string is complete.
>
> We must make sure that __prt_char() is able to add the last
> character even when there will not longer be space for
> the trailing '\0'.
You really think there's going to be code depending on an _absence_ of a
trailing nul? I should've updated the comment (I missed that originally,
doing it now) - but this seems excessively nitpicky.
And I'm looking at the callers now:
- seq_file, which doesn't commit the results if it overflowed the buffer
- net/sunrpc/cache.c, which also appears to turn an overflow into an error
and that's it, aside from test cases.
The nul termination is an explicit thing: as I convert to printbuf, I
don't want functions that output to printbufs returning printbufs that
aren't nul terminated unless explicitly documented - and there's no
reason to be doing this except for a few fast path helpers.
>
>> +int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
>> + unsigned int flags, const char *only)
>
> We need keep the comment above this API as long as it is public.
Will do.
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 03/33] vsprintf: Convert to printbuf
2022-06-04 19:30 ` [PATCH v3 03/33] vsprintf: Convert " Kent Overstreet
@ 2022-06-15 9:09 ` Rasmus Villemoes
2022-06-15 18:44 ` Kent Overstreet
0 siblings, 1 reply; 48+ messages in thread
From: Rasmus Villemoes @ 2022-06-15 9:09 UTC (permalink / raw)
To: Kent Overstreet, linux-kernel; +Cc: pmladek, rostedt
On 04/06/2022 21.30, Kent Overstreet wrote:
> 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.
So, as the primary author of those tests, a somewhat active contributor
to vsprintf.c and being listed as R: for both files, why wasn't I cc'ed
on this?
Anyway, my main concern with this is that performance goes down the
drain and the generated code will be awful. Have you done any
measurements and/or looked at disassembly? Thanks to
-fno-strict-aliasing (or perhaps just because we're writing through a
char* pointer which IIRC may alias anything), I think the compiler will
be forced to reload prt->pos and prt->size over and over and over. I may
be wrong, of course, that happens often. Perhaps __restrict could help, IDK.
> ---
> include/linux/kernel.h | 4 +
Please don't expand that dumping ground. Please, if printbufs will
become a thing (whether or not vsprintf internally will be refactored to
use them), add a new linux/printf.h where these things can go, and the
declarations of vsprintf() and close friends can eventually be moved.
Rasmus
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 03/33] vsprintf: Convert to printbuf
2022-06-15 9:09 ` Rasmus Villemoes
@ 2022-06-15 18:44 ` Kent Overstreet
2022-06-17 8:59 ` Rasmus Villemoes
0 siblings, 1 reply; 48+ messages in thread
From: Kent Overstreet @ 2022-06-15 18:44 UTC (permalink / raw)
To: Rasmus Villemoes, linux-kernel; +Cc: pmladek, rostedt
On 6/15/22 05:09, Rasmus Villemoes wrote:
> On 04/06/2022 21.30, Kent Overstreet wrote:
>> 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.
>
> So, as the primary author of those tests, a somewhat active contributor
> to vsprintf.c and being listed as R: for both files, why wasn't I cc'ed
> on this?
Apologies for the oversight.
> Anyway, my main concern with this is that performance goes down the
> drain and the generated code will be awful. Have you done any
> measurements and/or looked at disassembly? Thanks to
> -fno-strict-aliasing (or perhaps just because we're writing through a
> char* pointer which IIRC may alias anything), I think the compiler will
> be forced to reload prt->pos and prt->size over and over and over. I may
> be wrong, of course, that happens often. Perhaps __restrict could help, IDK.
If we care that much about sprintf performance we must have some
benchmarks somewhere - could you point me at them?
>> ---
>> include/linux/kernel.h | 4 +
>
> Please don't expand that dumping ground. Please, if printbufs will
> become a thing (whether or not vsprintf internally will be refactored to
> use them), add a new linux/printf.h where these things can go, and the
> declarations of vsprintf() and close friends can eventually be moved.
kernel.h is indeed a dumping ground that needs to be reorganized, but
this patch series is about printbufs, not reorganizing header files (and
my doctor tells me I need to be taking my blood pressure meds more
regularly before taking something like that on). For now, prt_printf()
goes with the other printf() functions.
^ permalink raw reply [flat|nested] 48+ messages in thread
* Re: [PATCH v3 03/33] vsprintf: Convert to printbuf
2022-06-15 18:44 ` Kent Overstreet
@ 2022-06-17 8:59 ` Rasmus Villemoes
0 siblings, 0 replies; 48+ messages in thread
From: Rasmus Villemoes @ 2022-06-17 8:59 UTC (permalink / raw)
To: Kent Overstreet, linux-kernel; +Cc: pmladek, rostedt
On 15/06/2022 20.44, Kent Overstreet wrote:
> On 6/15/22 05:09, Rasmus Villemoes wrote:
>> Anyway, my main concern with this is that performance goes down the
>> drain and the generated code will be awful. Have you done any
>> measurements and/or looked at disassembly? Thanks to
>> -fno-strict-aliasing (or perhaps just because we're writing through a
>> char* pointer which IIRC may alias anything), I think the compiler will
>> be forced to reload prt->pos and prt->size over and over and over. I may
>> be wrong, of course, that happens often. Perhaps __restrict could
>> help, IDK.
>
> If we care that much about sprintf performance we must have some
> benchmarks somewhere - could you point me at them?
Try 'perf top'. Or copy the meat of vsprintf.c (all the %p gunk can be
elided) and do some measurements in userspace, that's what I did when I
improved the decimal conversion a few years back.
And yes, "we" care about sprintf performance because it's used to
generate all those files in /proc, /sys etc. etc. which many tools (e.g.
top/ps) rely on.
Rasmus
^ permalink raw reply [flat|nested] 48+ messages in thread
end of thread, other threads:[~2022-06-17 8:59 UTC | newest]
Thread overview: 48+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-06-04 19:30 [PATCH v3 00/33] Printbufs Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 01/33] lib/printbuf: New data structure for printing strings Kent Overstreet
2022-06-09 13:55 ` Petr Mladek
2022-06-04 19:30 ` [PATCH v3 02/33] lib/string_helpers: Convert string_escape_mem() to printbuf Kent Overstreet
2022-06-09 14:25 ` Petr Mladek
2022-06-09 17:53 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 03/33] vsprintf: Convert " Kent Overstreet
2022-06-15 9:09 ` Rasmus Villemoes
2022-06-15 18:44 ` Kent Overstreet
2022-06-17 8:59 ` Rasmus Villemoes
2022-06-04 19:30 ` [PATCH v3 04/33] lib/hexdump: " Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 05/33] vsprintf: %pf(%p) Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 06/33] lib/string_helpers: string_get_size() now returns characters wrote Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 07/33] lib/printbuf: Heap allocation Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 08/33] lib/printbuf: Tabstops, indenting Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 09/33] lib/printbuf: Unit specifiers Kent Overstreet
2022-06-05 1:06 ` Joe Perches
2022-06-04 19:30 ` [PATCH v3 10/33] lib/pretty-printers: prt_string_option(), prt_bitflags() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 11/33] vsprintf: Improve number() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 12/33] vsprintf: prt_u64_minwidth(), prt_u64() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 13/33] test_printf: Drop requirement that sprintf not write past nul Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 14/33] vsprintf: Start consolidating printf_spec handling Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 15/33] vsprintf: Refactor resource_string() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 16/33] vsprintf: Refactor fourcc_string() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 17/33] vsprintf: Refactor ip_addr_string() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 18/33] vsprintf: Refactor mac_address_string() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 19/33] vsprintf: time_and_date() no longer takes printf_spec Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 20/33] vsprintf: flags_string() " Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 21/33] vsprintf: Refactor device_node_string, fwnode_string Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 22/33] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 23/33] Input/joystick/analog: Convert from seq_buf -> printbuf Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 24/33] mm/memcontrol.c: Convert to printbuf Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 25/33] clk: tegra: bpmp: " Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 26/33] tools/testing/nvdimm: " Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 27/33] powerpc: " Kent Overstreet
2022-06-04 19:30 ` Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 28/33] x86/resctrl: " Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 29/33] PCI/P2PDMA: " Kent Overstreet
2022-06-08 21:11 ` Bjorn Helgaas
2022-06-08 23:24 ` Kent Overstreet
2022-06-08 23:34 ` Logan Gunthorpe
2022-06-08 23:40 ` Bjorn Helgaas
2022-06-04 19:30 ` [PATCH v3 30/33] tracing: trace_events_synth: " Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 31/33] d_path: prt_path() Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 32/33] tracing: Convert to printbuf Kent Overstreet
2022-06-04 19:30 ` [PATCH v3 33/33] Delete seq_buf Kent Overstreet
2022-06-05 16:21 ` [PATCH v3 00/33] Printbufs Steven Rostedt
2022-06-05 17:55 ` Kent Overstreet
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.