From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 07052C19F2A for ; Mon, 8 Aug 2022 02:42:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244040AbiHHCm4 (ORCPT ); Sun, 7 Aug 2022 22:42:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32768 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242409AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5D5492183 for ; Sun, 7 Aug 2022 19:41:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=m0DsKEBL9X2In7g3SaJJ//Eus47I5rm2wtDKWJEHJOc=; b=Mw6XIXrlnBLezyeYbm9vOc8hvb rvaPrlZrDsvJas4TiCy3kljk9B6lq2b+F0HrbhLs9sxyG78Dd312Ve7C1LG//jd87GFLKKHllWPgm CgfN645tBmX7DjCjZCwCsZHZwgl+WNhMbGdW5vuoqCV4OsO55gVkIzngjKod02ISOSi4RIRzwesDf VJv2GjbezpvwgOQAOm6p9wRlTuI5grLxH8d6IpHzOQjHL6NsDz79VqcrtMRYHW3DQIUAWzdA9tFf3 usohG+1EQvvX1xCGggUCtOHzQxnf8JgjVzzHV9fZ4Bc4v3onYMRVNIyLPZPuXJShAM9DiLSuWbwFZ Am+KL02Q==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshw-00DVRP-LQ; Mon, 08 Aug 2022 02:41:32 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Matthew Wilcox Subject: [PATCH v5 01/32] lib/printbuf: New data structure for printing strings Date: Mon, 8 Aug 2022 03:40:57 +0100 Message-Id: <20220808024128.3219082-2-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Reviewed-by: Matthew Wilcox (Oracle) --- include/linux/printbuf.h | 122 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 include/linux/printbuf.h diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h new file mode 100644 index 000000000000..1aa3331bf00b --- /dev/null +++ b/include/linux/printbuf.h @@ -0,0 +1,122 @@ +/* SPDX-License-Identifier: LGPL-2.1+ */ +/* Copyright (C) 2022 Kent Overstreet */ + +#ifndef _LINUX_PRINTBUF_H +#define _LINUX_PRINTBUF_H + +#include +#include + +/* + * Printbufs: String buffer for outputting (printing) to, for vsnprintf + */ + +struct printbuf { + char *buf; + unsigned size; + unsigned pos; +}; + +/* + * Returns size remaining of output buffer: + */ +static inline unsigned printbuf_remaining_size(struct printbuf *out) +{ + return out->pos < out->size ? out->size - out->pos : 0; +} + +/* + * Returns number of characters we can print to the output buffer - i.e. + * excluding the terminating nul: + */ +static inline unsigned printbuf_remaining(struct printbuf *out) +{ + return out->pos < out->size ? out->size - out->pos - 1 : 0; +} + +static inline unsigned printbuf_written(struct printbuf *out) +{ + return out->size ? min(out->pos, out->size - 1) : 0; +} + +/* + * Returns true if output was truncated: + */ +static inline bool printbuf_overflowed(struct printbuf *out) +{ + return out->pos >=3D out->size; +} + +static inline void printbuf_nul_terminate(struct printbuf *out) +{ + if (out->pos < out->size) + out->buf[out->pos] =3D 0; + else if (out->size) + out->buf[out->size - 1] =3D 0; +} + +static inline void __prt_char(struct printbuf *out, char c) +{ + if (printbuf_remaining(out)) + out->buf[out->pos] =3D c; + out->pos++; +} + +static inline void prt_char(struct printbuf *out, char c) +{ + __prt_char(out, c); + printbuf_nul_terminate(out); +} + +static inline void __prt_chars(struct printbuf *out, char c, unsigned n) +{ + unsigned i, can_print =3D min(n, printbuf_remaining(out)); + + for (i =3D 0; i < can_print; i++) + out->buf[out->pos++] =3D c; + out->pos +=3D n - can_print; +} + +static inline void prt_chars(struct printbuf *out, char c, unsigned n) +{ + __prt_chars(out, c, n); + printbuf_nul_terminate(out); +} + +static inline void prt_bytes(struct printbuf *out, const void *b, unsigned= n) +{ + unsigned i, can_print =3D min(n, printbuf_remaining(out)); + + for (i =3D 0; i < can_print; i++) + out->buf[out->pos++] =3D ((char *) b)[i]; + out->pos +=3D n - can_print; + + printbuf_nul_terminate(out); +} + +static inline void prt_str(struct printbuf *out, const char *str) +{ + prt_bytes(out, str, strlen(str)); +} + +static inline void prt_hex_byte(struct printbuf *out, u8 byte) +{ + __prt_char(out, hex_asc_hi(byte)); + __prt_char(out, hex_asc_lo(byte)); + printbuf_nul_terminate(out); +} + +static inline void prt_hex_byte_upper(struct printbuf *out, u8 byte) +{ + __prt_char(out, hex_asc_upper_hi(byte)); + __prt_char(out, hex_asc_upper_lo(byte)); + printbuf_nul_terminate(out); +} + +#define PRINTBUF_EXTERN(_buf, _size) \ +((struct printbuf) { \ + .buf =3D _buf, \ + .size =3D _size, \ +}) + +#endif /* _LINUX_PRINTBUF_H */ --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 49AE2C19F2A for ; Mon, 8 Aug 2022 02:42:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235146AbiHHCmS (ORCPT ); Sun, 7 Aug 2022 22:42:18 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60986 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241906AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1200121A0 for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=Gu7E425V0iQ09fl0rKkMxUs5hGFHfm7wcAjUWU6QsC0=; b=EkDS2YIcgaEOL7lgUCs+DjIc80 BqsGZM8taB76nkv4bO1HblmPKAORGjfmP5902S45+S2A1SscElpDexmxCOepGPwMvVhz3ZQta21Yu CBKQcNJgDpQBzGLsDCKWDGP44194+/OC3NNC/mOu4s0UJXj5kKZEurBJM2A1VcTTWE6jhxwQd3tRq iqBMC9oHllOITKUsrAFKsgJtlTa1WnzUmh1UofoSA2yptLNlZ6cdluQ0m/GNr3dyfGoAZzrtDAqMO yuEUG+1J3G/crOnFnWH1mAwvolsvWn/efAjCIpuVFPJxv92d8YHWrgHoGRuO5cjl8yBnqPnzFwNNA xscCGUKg==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshw-00DVRR-O8; Mon, 08 Aug 2022 02:41:32 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Andy Shevchenko Subject: [PATCH v5 02/32] lib/string_helpers: Convert string_escape_mem() to printbuf Date: Mon, 8 Aug 2022 03:40:58 +0100 Message-Id: <20220808024128.3219082-3-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Andy Shevchenko --- include/linux/string_helpers.h | 4 + lib/string_helpers.c | 217 ++++++++++++++++++--------------- 2 files changed, 126 insertions(+), 95 deletions(-) diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h index 4d72258d42fd..67de398944e8 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; =20 /* Descriptions of the types of units to * print in */ @@ -62,6 +63,8 @@ static inline int string_unescape_any_inplace(char *buf) =20 #define ESCAPE_ALL_MASK GENMASK(8, 0) =20 +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); =20 @@ -71,6 +74,7 @@ static inline int string_escape_mem_any_np(const char *sr= c, size_t isz, return string_escape_mem(src, isz, dst, osz, ESCAPE_ANY_NP, only); } =20 + 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 5ed3beb066e6..7be20bcc6137 100644 --- a/lib/string_helpers.c +++ b/lib/string_helpers.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -301,19 +302,14 @@ int string_unescape(char *src, char *dst, size_t size= , unsigned int flags) } EXPORT_SYMBOL(string_unescape); =20 -static bool escape_passthrough(unsigned char c, char **dst, char *end) +static bool escape_passthrough(struct printbuf *out, unsigned char c) { - char *out =3D *dst; - - if (out < end) - *out =3D c; - *dst =3D out + 1; + prt_char(out, c); return true; } =20 -static bool escape_space(unsigned char c, char **dst, char *end) +static bool escape_space(struct printbuf *out, unsigned char c) { - char *out =3D *dst; unsigned char to; =20 switch (c) { @@ -336,20 +332,13 @@ static bool escape_space(unsigned char c, char **dst,= char *end) return false; } =20 - if (out < end) - *out =3D '\\'; - ++out; - if (out < end) - *out =3D to; - ++out; - - *dst =3D out; + prt_char(out, '\\'); + prt_char(out, to); return true; } =20 -static bool escape_special(unsigned char c, char **dst, char *end) +static bool escape_special(struct printbuf *out, unsigned char c) { - char *out =3D *dst; unsigned char to; =20 switch (c) { @@ -369,83 +358,43 @@ static bool escape_special(unsigned char c, char **ds= t, char *end) return false; } =20 - if (out < end) - *out =3D '\\'; - ++out; - if (out < end) - *out =3D to; - ++out; - - *dst =3D out; + prt_char(out, '\\'); + prt_char(out, to); return true; } =20 -static bool escape_null(unsigned char c, char **dst, char *end) +static bool escape_null(struct printbuf *out, unsigned char c) { - char *out =3D *dst; - if (c) return false; =20 - if (out < end) - *out =3D '\\'; - ++out; - if (out < end) - *out =3D '0'; - ++out; - - *dst =3D out; + prt_char(out, '\\'); + prt_char(out, '0'); return true; } =20 -static bool escape_octal(unsigned char c, char **dst, char *end) +static bool escape_octal(struct printbuf *out, unsigned char c) { - char *out =3D *dst; - - if (out < end) - *out =3D '\\'; - ++out; - if (out < end) - *out =3D ((c >> 6) & 0x07) + '0'; - ++out; - if (out < end) - *out =3D ((c >> 3) & 0x07) + '0'; - ++out; - if (out < end) - *out =3D ((c >> 0) & 0x07) + '0'; - ++out; - - *dst =3D 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; } =20 -static bool escape_hex(unsigned char c, char **dst, char *end) +static bool escape_hex(struct printbuf *out, unsigned char c) { - char *out =3D *dst; - - if (out < end) - *out =3D '\\'; - ++out; - if (out < end) - *out =3D 'x'; - ++out; - if (out < end) - *out =3D hex_asc_hi(c); - ++out; - if (out < end) - *out =3D hex_asc_lo(c); - ++out; - - *dst =3D out; + prt_char(out, '\\'); + prt_char(out, 'x'); + prt_hex_byte(out, c); return true; } =20 /** - * string_escape_mem - quote characters in the given memory buffer + * prt_escaped_string - quote characters in the given memory buffer + * @out: printbuf to output to (escaped) * @src: source buffer (unescaped) * @isz: source buffer size - * @dst: destination buffer (escaped) - * @osz: destination buffer size * @flags: combination of the flags * @only: NULL-terminated string containing characters used to limit * the selected escape class. If characters are included in @only @@ -510,18 +459,11 @@ static bool escape_hex(unsigned char c, char **dst, c= har *end) * or %ESCAPE_HEX, because they cover most of the other character classes. * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to * the above. - * - * Return: - * The total size of the escaped output that would be generated for - * the given input and flags. To check whether the output was - * truncated, compare the return value to osz. There is room left in - * dst for a '\0' terminator if and only if ret < osz. */ -int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz, - unsigned int flags, const char *only) +void prt_escaped_string(struct printbuf *out, + const char *src, size_t isz, + unsigned int flags, const char *only) { - char *p =3D dst; - char *end =3D p + osz; bool is_dict =3D only && *only; bool is_append =3D flags & ESCAPE_APPEND; =20 @@ -549,41 +491,126 @@ int string_escape_mem(const char *src, size_t isz, c= har *dst, size_t osz, * %ESCAPE_NA cases. */ if (!(is_append || in_dict) && is_dict && - escape_passthrough(c, &p, end)) + escape_passthrough(out, c)) continue; =20 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; =20 if (!(is_append && in_dict) && isprint(c) && - flags & ESCAPE_NP && escape_passthrough(c, &p, end)) + flags & ESCAPE_NP && escape_passthrough(out, c)) continue; =20 if (!(is_append && in_dict) && isascii(c) && - flags & ESCAPE_NA && escape_passthrough(c, &p, end)) + flags & ESCAPE_NA && escape_passthrough(out, c)) continue; =20 - if (flags & ESCAPE_SPACE && escape_space(c, &p, end)) + if (flags & ESCAPE_SPACE && escape_space(out, c)) continue; =20 - if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end)) + if (flags & ESCAPE_SPECIAL && escape_special(out, c)) continue; =20 - if (flags & ESCAPE_NULL && escape_null(c, &p, end)) + if (flags & ESCAPE_NULL && escape_null(out, c)) continue; =20 /* 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; =20 - if (flags & ESCAPE_HEX && escape_hex(c, &p, end)) + if (flags & ESCAPE_HEX && escape_hex(out, c)) continue; =20 - escape_passthrough(c, &p, end); + escape_passthrough(out, c); } +} +EXPORT_SYMBOL(prt_escaped_string); + +/** + * string_escape_mem - quote characters in the given memory buffer + * @src: source buffer (unescaped) + * @isz: source buffer size + * @dst: destination buffer (escaped) + * @osz: destination buffer size + * @flags: combination of the flags + * @only: NULL-terminated string containing characters used to limit + * the selected escape class. If characters are included in @only + * that would not normally be escaped by the classes selected + * in @flags, they will be copied to @dst unescaped. + * + * Description: + * The process of escaping byte buffer includes several parts. They are ap= plied + * in the following sequence. + * + * 1. The character is not matched to the one from @only string and thus + * must go as-is to the output. + * 2. The character is matched to the printable and ASCII classes, if aske= d, + * and in case of match it passes through to the output. + * 3. The character is matched to the printable or ASCII class, if asked, + * and in case of match it passes through to the output. + * 4. The character is checked if it falls into the class given by @flags. + * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any + * character. Note that they actually can't go together, otherwise + * %ESCAPE_HEX will be ignored. + * + * Caller must provide valid source and destination pointers. Be aware that + * destination buffer will not be NULL-terminated, thus caller have to app= end + * it if needs. The supported flags are:: + * + * %ESCAPE_SPACE: (special white space, not space itself) + * '\f' - form feed + * '\n' - new line + * '\r' - carriage return + * '\t' - horizontal tab + * '\v' - vertical tab + * %ESCAPE_SPECIAL: + * '\"' - double quote + * '\\' - backslash + * '\a' - alert (BEL) + * '\e' - escape + * %ESCAPE_NULL: + * '\0' - null + * %ESCAPE_OCTAL: + * '\NNN' - byte with octal value NNN (3 digits) + * %ESCAPE_ANY: + * all previous together + * %ESCAPE_NP: + * escape only non-printable characters, checked by isprint() + * %ESCAPE_ANY_NP: + * all previous together + * %ESCAPE_HEX: + * '\xHH' - byte with hexadecimal value HH (2 digits) + * %ESCAPE_NA: + * escape only non-ascii characters, checked by isascii() + * %ESCAPE_NAP: + * escape only non-printable or non-ascii characters + * %ESCAPE_APPEND: + * append characters from @only to be escaped by the given classes + * + * %ESCAPE_APPEND would help to pass additional characters to the escaped,= when + * one of %ESCAPE_NP, %ESCAPE_NA, or %ESCAPE_NAP is provided. + * + * One notable caveat, the %ESCAPE_NAP, %ESCAPE_NP and %ESCAPE_NA have the + * higher priority than the rest of the flags (%ESCAPE_NAP is the highest). + * It doesn't make much sense to use either of them without %ESCAPE_OCTAL + * or %ESCAPE_HEX, because they cover most of the other character classes. + * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to + * the above. + * + * Return: + * The total size of the escaped output that would be generated for + * the given input and flags. To check whether the output was + * truncated, compare the return value to osz. There is room left in + * dst for a '\0' terminator if and only if ret < osz. + */ +int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz, + unsigned int flags, const char *only) +{ + struct printbuf out =3D PRINTBUF_EXTERN(dst, osz); =20 - return p - dst; + prt_escaped_string(&out, src, isz, flags, only); + return out.pos; } EXPORT_SYMBOL(string_escape_mem); =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 191D7C19F2A for ; Mon, 8 Aug 2022 02:43:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244066AbiHHCng (ORCPT ); Sun, 7 Aug 2022 22:43:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60990 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242648AbiHHCln (ORCPT ); Sun, 7 Aug 2022 22:41:43 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4859C25E9 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=15fEZP0YMfEK/MrdHJTKSx+xJh0dinRi/+TTvMnRdMc=; b=WVQ7pC6UwyMqT1aE29EKesYKfp TULVPPBco44Ei7aAhzuP5XVm39VS52GbjueSRA5VU2KERzZg43+Xwd+luiWXKs94LyDXSP8UlceRg 2Bvazvi4UCCx3sar2FT3gnpnOiRwKC6WONpqDP6G6qsB4McwetegaMxitO69jDVjKFkWkrEibEXjv oWGneIuU7ClrkGg0dEzdeMiyte/XPT2/I/rdYiza3VK6uywizJ7iOTgBA60CVmyBExy5On35guXAw 0HM6Kh1V38wMn1Dsk0jQKrEHqtyJimmRqz7g0t+1EoQTVUYYSlrUqNoWAKnSl2PsBULENdg0C3D71 XZbdj1Mg==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshw-00DVRT-RK; Mon, 08 Aug 2022 02:41:32 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Steven Rostedt , Rasmus Villemoes Subject: [PATCH v5 03/32] vsprintf: Convert to printbuf Date: Mon, 8 Aug 2022 03:40:59 +0100 Message-Id: <20220808024128.3219082-4-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Steven Rostedt Cc: Rasmus Villemoes --- include/linux/kernel.h | 4 + include/linux/string.h | 5 + lib/vsprintf.c | 1367 +++++++++++++++++++--------------------- 3 files changed, 643 insertions(+), 733 deletions(-) diff --git a/include/linux/kernel.h b/include/linux/kernel.h index fe6efb24d151..5c4f4b6d36ab 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -207,6 +207,10 @@ extern int num_to_str(char *buf, int size, =20 /* lib/printf utilities */ =20 +struct printbuf; +extern __printf(2, 3) void prt_printf(struct printbuf *out, const char *fm= t, ...); +extern __printf(2, 0) void prt_vprintf(struct printbuf *out, const char *f= mt, 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 61ec7e4f6311..22a45d553fbc 100644 --- a/include/linux/string.h +++ b/include/linux/string.h @@ -195,7 +195,12 @@ int __sysfs_match_string(const char * const *array, si= ze_t n, const char *s); */ #define sysfs_match_string(_a, _s) __sysfs_match_string(_a, ARRAY_SIZE(_a)= , _s) =20 +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_bu= f); 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 3c1853a9d1c0..52dac8519a0a 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -44,6 +44,7 @@ #ifdef CONFIG_BLOCK #include #endif +#include =20 #include "../mm/internal.h" /* For the trace_print_flags arrays */ =20 @@ -451,8 +452,8 @@ static_assert(sizeof(struct printf_spec) =3D=3D 8); #define PRECISION_MAX ((1 << 15) - 1) =20 static noinline_for_stack -char *number(char *buf, char *end, unsigned long long num, - struct printf_spec spec) +void number(struct printbuf *out, unsigned long long num, + struct printf_spec spec) { /* put_dec requires 2-byte alignment of the buffer. */ char tmp[3 * sizeof(num)] __aligned(2); @@ -512,67 +513,43 @@ char *number(char *buf, char *end, unsigned long long= num, if (i > precision) precision =3D i; /* leading space padding */ - field_width -=3D precision; - if (!(spec.flags & (ZEROPAD | LEFT))) { - while (--field_width >=3D 0) { - if (buf < end) - *buf =3D ' '; - ++buf; - } + field_width =3D max(0, field_width - precision); + if (!(spec.flags & (ZEROPAD | LEFT)) && field_width) { + __prt_chars(out, ' ', field_width); + field_width =3D 0; } /* sign */ - if (sign) { - if (buf < end) - *buf =3D sign; - ++buf; - } + if (sign) + __prt_char(out, sign); /* "0x" / "0" prefix */ if (need_pfx) { - if (spec.base =3D=3D 16 || !is_zero) { - if (buf < end) - *buf =3D '0'; - ++buf; - } - if (spec.base =3D=3D 16) { - if (buf < end) - *buf =3D ('X' | locase); - ++buf; - } + if (spec.base =3D=3D 16 || !is_zero) + __prt_char(out, '0'); + if (spec.base =3D=3D 16) + __prt_char(out, 'X' | locase); } /* zero or space padding */ - if (!(spec.flags & LEFT)) { + if (!(spec.flags & LEFT) && field_width) { char c =3D ' ' + (spec.flags & ZEROPAD); =20 - while (--field_width >=3D 0) { - if (buf < end) - *buf =3D c; - ++buf; - } + __prt_chars(out, c, field_width); + field_width =3D 0; } /* hmm even more zero padding? */ - while (i <=3D --precision) { - if (buf < end) - *buf =3D '0'; - ++buf; - } + if (precision > i) + __prt_chars(out, '0', precision - i); /* actual digits of result */ - while (--i >=3D 0) { - if (buf < end) - *buf =3D tmp[i]; - ++buf; - } + while (--i >=3D 0) + __prt_char(out, tmp[i]); /* trailing space padding */ - while (--field_width >=3D 0) { - if (buf < end) - *buf =3D ' '; - ++buf; - } + if (field_width) + __prt_chars(out, ' ', field_width); =20 - return buf; + printbuf_nul_terminate(out); } =20 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; =20 @@ -582,25 +559,28 @@ char *special_hex_number(char *buf, char *end, unsign= ed long long num, int size) spec.base =3D 16; spec.precision =3D -1; =20 - return number(buf, end, num, spec); + number(out, num, spec); } =20 -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 >=3D end) /* nowhere to put anything */ - return; - size =3D end - buf; - if (size <=3D spaces) { - memset(buf, ' ', size); - return; - } - if (len) { - if (len > size - spaces) - len =3D size - spaces; - memmove(buf + spaces, buf, len); - } - memset(buf, ' ', spaces); + unsigned move_src =3D out->pos - len; + unsigned move_dst =3D move_src + spaces; + unsigned remaining_from_dst =3D move_dst < out->size ? out->size - move_d= st : 0; + unsigned remaining_from_src =3D move_src < out->size ? out->size - move_s= rc : 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 +=3D spaces; } =20 /* @@ -612,67 +592,55 @@ static void move_right(char *buf, char *end, unsigned= len, unsigned spaces) * Returns: new buffer position after padding. */ static noinline_for_stack -char *widen_string(char *buf, int n, char *end, struct printf_spec spec) +void widen_string(struct printbuf *out, int n, + struct printf_spec spec) { unsigned spaces; =20 if (likely(n >=3D spec.field_width)) - return buf; + return; /* we want to pad the sucker */ spaces =3D spec.field_width - n; - if (!(spec.flags & LEFT)) { - move_right(buf - n, end, n, spaces); - return buf + spaces; - } - while (spaces--) { - if (buf < end) - *buf =3D ' '; - ++buf; - } - return buf; + if (!(spec.flags & LEFT)) + move_right(out, n, spaces); + else + prt_chars(out, ' ', spaces); } =20 /* 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 =3D 0; - int lim =3D spec.precision; + int len =3D strnlen(s, spec.precision); =20 - while (lim--) { - char c =3D *s++; - if (!c) - break; - if (buf < end) - *buf =3D c; - ++buf; - ++len; - } - return widen_string(buf, len, end, spec); + prt_bytes(out, s, len); + widen_string(out, len, spec); } =20 -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 =3D PTR_ERR(ptr); const char *sym =3D errname(err); =20 - 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=3Dn. Fall back to - * printing it as its decimal representation. - */ - spec.flags |=3D SIGN; - spec.base =3D 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=3Dn. Fall back to + * printing it as its decimal representation. + */ + spec.flags |=3D SIGN; + spec.base =3D 10; + number(out, err, spec); + } } =20 /* Be careful: error messages must fit into the given buffer. */ -static char *error_string(char *buf, char *end, const char *s, - struct printf_spec spec) +static void error_string(struct printbuf *out, const char *s, + struct printf_spec spec) { /* * Hard limit to avoid a completely insane messages. It actually @@ -682,7 +650,7 @@ static char *error_string(char *buf, char *end, const c= har *s, if (spec.precision =3D=3D -1) spec.precision =3D 2 * sizeof(void *); =20 - return string_nocheck(buf, end, s, spec); + string_nocheck(out, s, spec); } =20 /* @@ -701,14 +669,15 @@ static const char *check_pointer_msg(const void *ptr) return NULL; } =20 -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; =20 err_msg =3D check_pointer_msg(ptr); if (err_msg) { - *buf =3D error_string(*buf, end, err_msg, spec); + error_string(out, err_msg, spec); return -EFAULT; } =20 @@ -716,18 +685,19 @@ static int check_pointer(char **buf, char *end, const= void *ptr, } =20 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; =20 - return string_nocheck(buf, end, s, spec); + string_nocheck(out, s, spec); } =20 -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 =3D 16; spec.flags |=3D SMALL; @@ -736,7 +706,7 @@ static char *pointer_string(char *buf, char *end, spec.flags |=3D ZEROPAD; } =20 - return number(buf, end, (unsigned long int)ptr, spec); + number(out, (unsigned long int)ptr, spec); } =20 /* Make pointers available for printing early in the boot sequence. */ @@ -801,8 +771,9 @@ int ptr_to_hashval(const void *ptr, unsigned long *hash= val_out) return __ptr_to_hashval(ptr, hashval_out); } =20 -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 =3D sizeof(ptr) =3D=3D 8 ? "(____ptrval____)" : "(ptrval)= "; unsigned long hashval; @@ -813,47 +784,49 @@ static char *ptr_to_id(char *buf, char *end, const vo= id *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); =20 /* When debugging early boot use non-cryptographically secure hash. */ if (unlikely(debug_boot_weak_hash)) { hashval =3D hash_long((unsigned long)ptr, 32); - return pointer_string(buf, end, (const void *)hashval, spec); + return pointer_string(out, (const void *)hashval, spec); } =20 ret =3D __ptr_to_hashval(ptr, &hashval); if (ret) { spec.field_width =3D 2 * sizeof(ptr); /* string length must be less than default_width */ - return error_string(buf, end, str, spec); + return error_string(out, str, spec); } =20 - return pointer_string(buf, end, (const void *)hashval, spec); + pointer_string(out, (const void *)hashval, spec); } =20 -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); =20 - return ptr_to_id(buf, end, ptr, spec); + return ptr_to_id(out, ptr, spec); } =20 int kptr_restrict __read_mostly; =20 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; =20 @@ -864,7 +837,7 @@ char *restricted_pointer(char *buf, char *end, const vo= id *ptr, if (in_irq() || in_serving_softirq() || in_nmi()) { if (spec.field_width =3D=3D -1) spec.field_width =3D 2 * sizeof(ptr); - return error_string(buf, end, "pK-error", spec); + return error_string(out, "pK-error", spec); } =20 /* @@ -890,12 +863,13 @@ char *restricted_pointer(char *buf, char *end, const = void *ptr, break; } =20 - return pointer_string(buf, end, ptr, spec); + return pointer_string(out, ptr, spec); } =20 static noinline_for_stack -char *dentry_name(char *buf, char *end, const struct dentry *d, struct pri= ntf_spec spec, - const char *fmt) +void dentry_name(struct printbuf *out, + const struct dentry *d, struct printf_spec spec, + const char *fmt) { const char *array[4], *s; const struct dentry *p; @@ -912,9 +886,9 @@ char *dentry_name(char *buf, char *end, const struct de= ntry *d, struct printf_sp =20 rcu_read_lock(); for (i =3D 0; i < depth; i++, d =3D p) { - if (check_pointer(&buf, end, d, spec)) { + if (check_pointer(out, d, spec)) { rcu_read_unlock(); - return buf; + return; } =20 p =3D READ_ONCE(d->d_parent); @@ -927,7 +901,7 @@ char *dentry_name(char *buf, char *end, const struct de= ntry *d, struct printf_sp } } s =3D array[--i]; - for (n =3D 0; n !=3D spec.precision; n++, buf++) { + for (n =3D 0; n !=3D spec.precision; n++) { char c =3D *s++; if (!c) { if (!i) @@ -935,49 +909,47 @@ char *dentry_name(char *buf, char *end, const struct = dentry *d, struct printf_sp c =3D '/'; s =3D array[--i]; } - if (buf < end) - *buf =3D c; + prt_char(out, c); } rcu_read_unlock(); - return widen_string(buf, n, end, spec); + + widen_string(out, n, spec); } =20 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; =20 - 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; =20 - if (check_pointer(&buf, end, bdev, spec)) - return buf; + if (check_pointer(out, bdev, spec)) + return; =20 hd =3D bdev->bd_disk; - buf =3D 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 =3D 'p'; - buf++; - } - buf =3D 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 =20 static noinline_for_stack -char *symbol_string(char *buf, char *end, void *ptr, - struct printf_spec spec, const char *fmt) +void symbol_string(struct printbuf *out, void *ptr, + struct printf_spec spec, const char *fmt) { unsigned long value; #ifdef CONFIG_KALLSYMS @@ -1000,9 +972,9 @@ char *symbol_string(char *buf, char *end, void *ptr, else sprint_symbol_no_offset(sym, value); =20 - 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 } =20 @@ -1037,8 +1009,8 @@ static const struct printf_spec default_dec04_spec = =3D { }; =20 static noinline_for_stack -char *resource_string(char *buf, char *end, struct resource *res, - struct printf_spec spec, const char *fmt) +void resource_string(struct printbuf *out, struct resource *res, + struct printf_spec spec, const char *fmt) { #ifndef IO_RSRC_PRINTK_SIZE #define IO_RSRC_PRINTK_SIZE 6 @@ -1077,69 +1049,67 @@ char *resource_string(char *buf, char *end, struct = resource *res, #define FLAG_BUF_SIZE (2 * sizeof(res->flags)) #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]") #define RAW_BUF_SIZE sizeof("[mem - flags 0x]") - char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, + char sym_buf[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)]; - - char *p =3D sym, *pend =3D sym + sizeof(sym); + struct printbuf sym =3D PRINTBUF_EXTERN(sym_buf, sizeof(sym_buf)); int decode =3D (fmt[0] =3D=3D 'R') ? 1 : 0; const struct printf_spec *specp; =20 - if (check_pointer(&buf, end, res, spec)) - return buf; + if (check_pointer(out, res, spec)) + return; =20 - *p++ =3D '['; + prt_char(&sym, '['); if (res->flags & IORESOURCE_IO) { - p =3D string_nocheck(p, pend, "io ", str_spec); + string_nocheck(&sym, "io ", str_spec); specp =3D &io_spec; } else if (res->flags & IORESOURCE_MEM) { - p =3D string_nocheck(p, pend, "mem ", str_spec); + string_nocheck(&sym, "mem ", str_spec); specp =3D &mem_spec; } else if (res->flags & IORESOURCE_IRQ) { - p =3D string_nocheck(p, pend, "irq ", str_spec); + string_nocheck(&sym, "irq ", str_spec); specp =3D &default_dec_spec; } else if (res->flags & IORESOURCE_DMA) { - p =3D string_nocheck(p, pend, "dma ", str_spec); + string_nocheck(&sym, "dma ", str_spec); specp =3D &default_dec_spec; } else if (res->flags & IORESOURCE_BUS) { - p =3D string_nocheck(p, pend, "bus ", str_spec); + string_nocheck(&sym, "bus ", str_spec); specp =3D &bus_spec; } else { - p =3D string_nocheck(p, pend, "??? ", str_spec); + string_nocheck(&sym, "??? ", str_spec); specp =3D &mem_spec; decode =3D 0; } if (decode && res->flags & IORESOURCE_UNSET) { - p =3D string_nocheck(p, pend, "size ", str_spec); - p =3D number(p, pend, resource_size(res), *specp); + string_nocheck(&sym, "size ", str_spec); + number(&sym, resource_size(res), *specp); } else { - p =3D number(p, pend, res->start, *specp); + number(&sym, res->start, *specp); if (res->start !=3D res->end) { - *p++ =3D '-'; - p =3D number(p, pend, res->end, *specp); + prt_char(&sym, '-'); + number(&sym, res->end, *specp); } } if (decode) { if (res->flags & IORESOURCE_MEM_64) - p =3D string_nocheck(p, pend, " 64bit", str_spec); + string_nocheck(&sym, " 64bit", str_spec); if (res->flags & IORESOURCE_PREFETCH) - p =3D string_nocheck(p, pend, " pref", str_spec); + string_nocheck(&sym, " pref", str_spec); if (res->flags & IORESOURCE_WINDOW) - p =3D string_nocheck(p, pend, " window", str_spec); + string_nocheck(&sym, " window", str_spec); if (res->flags & IORESOURCE_DISABLED) - p =3D string_nocheck(p, pend, " disabled", str_spec); + string_nocheck(&sym, " disabled", str_spec); } else { - p =3D string_nocheck(p, pend, " flags ", str_spec); - p =3D number(p, pend, res->flags, default_flag_spec); + string_nocheck(&sym, " flags ", str_spec); + number(&sym, res->flags, default_flag_spec); } - *p++ =3D ']'; - *p =3D '\0'; + prt_char(&sym, ']'); =20 - return string_nocheck(buf, end, sym, spec); + string_nocheck(out, sym_buf, spec); } =20 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 =3D 1; /* if we pass '%ph[CDN]', field width remains negative value, fallback to the default */ @@ -1147,10 +1117,10 @@ char *hex_string(char *buf, char *end, u8 *addr, st= ruct printf_spec spec, =20 if (spec.field_width =3D=3D 0) /* nothing to print */ - return buf; + return; =20 - if (check_pointer(&buf, end, addr, spec)) - return buf; + if (check_pointer(out, addr, spec)) + return; =20 switch (fmt[1]) { case 'C': @@ -1171,34 +1141,27 @@ char *hex_string(char *buf, char *end, u8 *addr, st= ruct printf_spec spec, len =3D min_t(int, spec.field_width, 64); =20 for (i =3D 0; i < len; ++i) { - if (buf < end) - *buf =3D hex_asc_hi(addr[i]); - ++buf; - if (buf < end) - *buf =3D hex_asc_lo(addr[i]); - ++buf; - - if (separator && i !=3D len - 1) { - if (buf < end) - *buf =3D separator; - ++buf; - } + __prt_char(out, hex_asc_hi(addr[i])); + __prt_char(out, hex_asc_lo(addr[i])); + + if (separator && i !=3D len - 1) + __prt_char(out, separator); } =20 - return buf; + printbuf_nul_terminate(out); } =20 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 =3D 32; int nr_bits =3D max_t(int, spec.field_width, 0); int i, chunksz; bool first =3D true; =20 - if (check_pointer(&buf, end, bitmap, spec)) - return buf; + if (check_pointer(out, bitmap, spec)) + return; =20 /* reused to print numbers */ spec =3D (struct printf_spec){ .flags =3D SMALL | ZEROPAD, .base =3D 16 }; @@ -1217,54 +1180,45 @@ char *bitmap_string(char *buf, char *end, unsigned = long *bitmap, bit =3D i % BITS_PER_LONG; val =3D (bitmap[word] >> bit) & chunkmask; =20 - if (!first) { - if (buf < end) - *buf =3D ','; - buf++; - } + if (!first) + prt_char(out, ','); first =3D false; =20 spec.field_width =3D DIV_ROUND_UP(chunksz, 4); - buf =3D number(buf, end, val, spec); + number(out, val, spec); =20 chunksz =3D CHUNKSZ; } - return buf; } =20 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 =3D max_t(int, spec.field_width, 0); bool first =3D true; int rbot, rtop; =20 - if (check_pointer(&buf, end, bitmap, spec)) - return buf; + if (check_pointer(out, bitmap, spec)) + return ; =20 for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) { - if (!first) { - if (buf < end) - *buf =3D ','; - buf++; - } + if (!first) + prt_char(out, ','); first =3D false; =20 - buf =3D number(buf, end, rbot, default_dec_spec); + number(out, rbot, default_dec_spec); if (rtop =3D=3D rbot + 1) continue; =20 - if (buf < end) - *buf =3D '-'; - buf =3D number(++buf, end, rtop - 1, default_dec_spec); + prt_char(out, '-'); + number(out, rtop - 1, default_dec_spec); } - return buf; } =20 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 =3D mac_addr; @@ -1272,8 +1226,8 @@ char *mac_address_string(char *buf, char *end, u8 *ad= dr, char separator; bool reversed =3D false; =20 - if (check_pointer(&buf, end, addr, spec)) - return buf; + if (check_pointer(out, addr, spec)) + return; =20 switch (fmt[1]) { case 'F': @@ -1300,11 +1254,12 @@ char *mac_address_string(char *buf, char *end, u8 *= addr, } *p =3D '\0'; =20 - return string_nocheck(buf, end, mac_addr, spec); + string_nocheck(out, mac_addr, spec); } =20 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 =3D (fmt[0] =3D=3D 'i'); @@ -1337,24 +1292,21 @@ char *ip4_string(char *p, const u8 *addr, const cha= r *fmt) int digits =3D put_dec_trunc8(temp, addr[index]) - temp; if (leading_zeros) { if (digits < 3) - *p++ =3D '0'; + prt_char(out, '0'); if (digits < 2) - *p++ =3D '0'; + prt_char(out, '0'); } /* reverse the digits in the quad */ while (digits--) - *p++ =3D temp[digits]; + prt_char(out, temp[digits]); if (i < 3) - *p++ =3D '.'; + prt_char(out, '.'); index +=3D step; } - *p =3D '\0'; - - return p; } =20 static noinline_for_stack -char *ip6_compressed_string(char *p, const char *addr) +void ip6_compressed_string(struct printbuf *out, const char *addr) { int i, j, range; unsigned char zerolength[8]; @@ -1398,14 +1350,14 @@ char *ip6_compressed_string(char *p, const char *ad= dr) for (i =3D 0; i < range; i++) { if (i =3D=3D colonpos) { if (needcolon || i =3D=3D 0) - *p++ =3D ':'; - *p++ =3D ':'; + __prt_char(out, ':'); + __prt_char(out, ':'); needcolon =3D false; i +=3D longest - 1; continue; } if (needcolon) { - *p++ =3D ':'; + __prt_char(out, ':'); needcolon =3D false; } /* hex u16 without leading 0s */ @@ -1414,81 +1366,79 @@ char *ip6_compressed_string(char *p, const char *ad= dr) lo =3D word & 0xff; if (hi) { if (hi > 0x0f) - p =3D hex_byte_pack(p, hi); + prt_hex_byte(out, hi); else - *p++ =3D hex_asc_lo(hi); - p =3D hex_byte_pack(p, lo); + __prt_char(out, hex_asc_lo(hi)); + prt_hex_byte(out, lo); } else if (lo > 0x0f) - p =3D hex_byte_pack(p, lo); + prt_hex_byte(out, lo); else - *p++ =3D hex_asc_lo(lo); + __prt_char(out, hex_asc_lo(lo)); needcolon =3D true; } =20 if (useIPv4) { if (needcolon) - *p++ =3D ':'; - p =3D ip4_string(p, &in6.s6_addr[12], "I4"); + __prt_char(out, ':'); + ip4_string(out, &in6.s6_addr[12], "I4"); } - *p =3D '\0'; =20 - return p; + printbuf_nul_terminate(out); } =20 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; =20 for (i =3D 0; i < 8; i++) { - p =3D hex_byte_pack(p, *addr++); - p =3D hex_byte_pack(p, *addr++); + prt_hex_byte(out, *addr++); + prt_hex_byte(out, *addr++); if (fmt[0] =3D=3D 'I' && i !=3D 7) - *p++ =3D ':'; + prt_char(out, ':'); } - *p =3D '\0'; - - return p; } =20 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 =3D PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_add= r_buf)); =20 if (fmt[0] =3D=3D 'I' && fmt[2] =3D=3D '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); =20 - return string_nocheck(buf, end, ip6_addr, spec); + string_nocheck(out, ip6_addr_buf, spec); } =20 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 =3D PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_add= r_buf)); =20 - ip4_string(ip4_addr, addr, fmt); + ip4_string(&ip4_addr, addr, fmt); =20 - return string_nocheck(buf, end, ip4_addr, spec); + string_nocheck(out, ip4_addr_buf, spec); } =20 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 =3D false, have_s =3D false, have_f =3D false, have_c =3D fal= se; - char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") + - sizeof(":12345") + sizeof("/123456789") + - sizeof("%1234567890")]; - char *p =3D ip6_addr, *pend =3D 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 =3D PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_add= r_buf)); const u8 *addr =3D (const u8 *) &sa->sin6_addr; char fmt6[2] =3D { fmt[0], '6' }; - u8 off =3D 0; =20 fmt++; while (isalpha(*++fmt)) { @@ -1508,44 +1458,42 @@ char *ip6_addr_string_sa(char *buf, char *end, cons= t struct sockaddr_in6 *sa, } } =20 - if (have_p || have_s || have_f) { - *p =3D '['; - off =3D 1; - } + if (have_p || have_s || have_f) + prt_char(&ip6_addr, '['); =20 if (fmt6[0] =3D=3D 'I' && have_c) - p =3D ip6_compressed_string(ip6_addr + off, addr); + ip6_compressed_string(&ip6_addr, addr); else - p =3D ip6_string(ip6_addr + off, addr, fmt6); + ip6_string(&ip6_addr, addr, fmt6); =20 if (have_p || have_s || have_f) - *p++ =3D ']'; + prt_char(&ip6_addr, ']'); =20 if (have_p) { - *p++ =3D ':'; - p =3D number(p, pend, ntohs(sa->sin6_port), spec); + prt_char(&ip6_addr, ':'); + number(&ip6_addr, ntohs(sa->sin6_port), spec); } if (have_f) { - *p++ =3D '/'; - p =3D 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++ =3D '%'; - p =3D number(p, pend, sa->sin6_scope_id, spec); + prt_char(&ip6_addr, '%'); + number(&ip6_addr, sa->sin6_scope_id, spec); } - *p =3D '\0'; =20 - return string_nocheck(buf, end, ip6_addr, spec); + string_nocheck(out, ip6_addr_buf, spec); } =20 static noinline_for_stack -char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *s= a, - 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 =3D false; - char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")]; - char *pend =3D ip4_addr + sizeof(ip4_addr); + char ip4_addr_buf[sizeof("255.255.255.255") + sizeof(":12345")]; + struct printbuf ip4_addr =3D PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_add= r_buf)); const u8 *addr =3D (const u8 *) &sa->sin_addr.s_addr; char fmt4[3] =3D { fmt[0], '4', 0 }; =20 @@ -1564,30 +1512,29 @@ char *ip4_addr_string_sa(char *buf, char *end, cons= t struct sockaddr_in *sa, } } =20 - p =3D ip4_string(ip4_addr, addr, fmt4); + ip4_string(&ip4_addr, addr, fmt4); if (have_p) { - *p++ =3D ':'; - p =3D number(p, pend, ntohs(sa->sin_port), spec); + prt_char(&ip4_addr, ':'); + number(&ip4_addr, ntohs(sa->sin_port), spec); } - *p =3D '\0'; =20 - return string_nocheck(buf, end, ip4_addr, spec); + string_nocheck(out, ip4_addr_buf, spec); } =20 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; =20 - if (check_pointer(&buf, end, ptr, spec)) - return buf; + if (check_pointer(out, ptr, spec)) + return; =20 switch (fmt[1]) { case '6': - return ip6_addr_string(buf, end, ptr, spec, fmt); + return ip6_addr_string(out, ptr, spec, fmt); case '4': - return ip4_addr_string(buf, end, ptr, spec, fmt); + return ip4_addr_string(out, ptr, spec, fmt); case 'S': { const union { struct sockaddr raw; @@ -1597,21 +1544,21 @@ char *ip_addr_string(char *buf, char *end, const vo= id *ptr, =20 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); }} } =20 err_fmt_msg =3D fmt[0] =3D=3D 'i' ? "(%pi?)" : "(%pI?)"; - return error_string(buf, end, err_fmt_msg, spec); + return error_string(out, err_fmt_msg, spec); } =20 static noinline_for_stack -char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec sp= ec, - const char *fmt) +void escaped_string(struct printbuf *out, u8 *addr, + struct printf_spec spec, const char *fmt) { bool found =3D true; int count =3D 1; @@ -1619,10 +1566,10 @@ char *escaped_string(char *buf, char *end, u8 *addr= , struct printf_spec spec, int len; =20 if (spec.field_width =3D=3D 0) - return buf; /* nothing to print */ + return; /* nothing to print */ =20 - if (check_pointer(&buf, end, addr, spec)) - return buf; + if (check_pointer(out, addr, spec)) + return; =20 do { switch (fmt[count++]) { @@ -1657,44 +1604,35 @@ char *escaped_string(char *buf, char *end, u8 *addr= , struct printf_spec spec, flags =3D ESCAPE_ANY_NP; =20 len =3D 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 +=3D string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, fla= gs, NULL); - - return buf; + prt_escaped_string(out, addr, len, flags, NULL); } =20 -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; =20 - if (check_pointer(&buf, end, va_fmt, spec)) - return buf; + if (check_pointer(out, va_fmt, spec)) + return; =20 va_copy(va, *va_fmt->va); - buf +=3D vsnprintf(buf, end > buf ? end - buf : 0, va_fmt->fmt, va); + prt_vprintf(out, va_fmt->fmt, va); va_end(va); - - return buf; } =20 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 =3D uuid; + char uuid_buf[UUID_STRING_LEN + 1]; + struct printbuf uuid =3D PRINTBUF_EXTERN(uuid_buf, sizeof(uuid_buf)); int i; const u8 *index =3D uuid_index; bool uc =3D false; =20 - if (check_pointer(&buf, end, addr, spec)) - return buf; + if (check_pointer(out, addr, spec)) + return; =20 switch (*(++fmt)) { case 'L': @@ -1710,60 +1648,58 @@ char *uuid_string(char *buf, char *end, const u8 *a= ddr, =20 for (i =3D 0; i < 16; i++) { if (uc) - p =3D hex_byte_pack_upper(p, addr[index[i]]); + prt_hex_byte_upper(&uuid, addr[index[i]]); else - p =3D 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++ =3D '-'; + prt_char(&uuid, '-'); break; } } =20 - *p =3D 0; - - return string_nocheck(buf, end, uuid, spec); + string_nocheck(out, uuid_buf, spec); } =20 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; =20 - if (check_pointer(&buf, end, addr, spec)) - return buf; + if (check_pointer(out, addr, spec)) + return; =20 switch (fmt[1]) { case 'F': num =3D *(const netdev_features_t *)addr; size =3D 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); } =20 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 =3D output; + char output_buf[sizeof("0123 little-endian (0x01234567)")]; + struct printbuf output =3D PRINTBUF_EXTERN(output_buf, sizeof(output_buf)= ); unsigned int i; u32 orig, val; =20 if (fmt[1] !=3D 'c' || fmt[2] !=3D 'c') - return error_string(buf, end, "(%p4?)", spec); + return error_string(out, "(%p4?)", spec); =20 - if (check_pointer(&buf, end, fourcc, spec)) - return buf; + if (check_pointer(out, fourcc, spec)) + return; =20 orig =3D get_unaligned(fourcc); val =3D orig & ~BIT(31); @@ -1772,31 +1708,29 @@ char *fourcc_string(char *buf, char *end, const u32= *fourcc, unsigned char c =3D val >> (i * 8); =20 /* Print non-control ASCII characters as-is, dot otherwise */ - *p++ =3D isascii(c) && isprint(c) ? c : '.'; + prt_char(&output, isascii(c) && isprint(c) ? c : '.'); } =20 - *p++ =3D ' '; - strcpy(p, orig & BIT(31) ? "big-endian" : "little-endian"); - p +=3D strlen(p); + prt_char(&output, ' '); + prt_str(&output, orig & BIT(31) ? "big-endian" : "little-endian"); =20 - *p++ =3D ' '; - *p++ =3D '('; - p =3D special_hex_number(p, output + sizeof(output) - 2, orig, sizeof(u32= )); - *p++ =3D ')'; - *p =3D '\0'; + prt_char(&output, ' '); + prt_char(&output, '('); + special_hex_number(&output, orig, sizeof(u32)); + prt_char(&output, ')'); =20 - return string(buf, end, output, spec); + string(out, output_buf, spec); } =20 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; =20 - if (check_pointer(&buf, end, addr, spec)) - return buf; + if (check_pointer(out, addr, spec)) + return; =20 switch (fmt[1]) { case 'd': @@ -1810,55 +1744,44 @@ char *address_val(char *buf, char *end, const void = *addr, break; } =20 - return special_hex_number(buf, end, num, size); + special_hex_number(out, num, size); } =20 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 =3D tm->tm_year + (r ? 0 : 1900); int mon =3D tm->tm_mon + (r ? 0 : 1); =20 - buf =3D number(buf, end, year, default_dec04_spec); - if (buf < end) - *buf =3D '-'; - buf++; - - buf =3D number(buf, end, mon, default_dec02_spec); - if (buf < end) - *buf =3D '-'; - 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); } =20 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 =3D number(buf, end, tm->tm_hour, default_dec02_spec); - if (buf < end) - *buf =3D ':'; - buf++; - - buf =3D number(buf, end, tm->tm_min, default_dec02_spec); - if (buf < end) - *buf =3D ':'; - 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); } =20 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 =3D true, have_d =3D true; bool raw =3D false, iso8601_separator =3D true; bool found =3D true; int count =3D 2; =20 - if (check_pointer(&buf, end, tm, spec)) - return buf; + if (check_pointer(out, tm, spec)) + return; =20 switch (fmt[count]) { case 'd': @@ -1886,21 +1809,16 @@ char *rtc_str(char *buf, char *end, const struct rt= c_time *tm, } while (found); =20 if (have_d) - buf =3D date_str(buf, end, tm, raw); - if (have_d && have_t) { - if (buf < end) - *buf =3D iso8601_separator ? 'T' : ' '; - buf++; - } + date_str(out, tm, raw); + if (have_d && have_t) + prt_char(out, iso8601_separator ? 'T' : ' '); if (have_t) - buf =3D time_str(buf, end, tm, raw); - - return buf; + time_str(out, tm, raw); } =20 static noinline_for_stack -char *time64_str(char *buf, char *end, const time64_t time, - struct printf_spec spec, const char *fmt) +void time64_str(struct printbuf *out, const time64_t time, + struct printf_spec spec, const char *fmt) { struct rtc_time rtc_time; struct tm tm; @@ -1918,47 +1836,48 @@ char *time64_str(char *buf, char *end, const time64= _t time, =20 rtc_time.tm_isdst =3D 0; =20 - return rtc_str(buf, end, &rtc_time, spec, fmt); + rtc_str(out, &rtc_time, spec, fmt); } =20 static noinline_for_stack -char *time_and_date(char *buf, char *end, void *ptr, struct printf_spec sp= ec, - 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); } } =20 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); =20 - if (check_pointer(&buf, end, clk, spec)) - return buf; + if (check_pointer(out, clk, spec)) + return; =20 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 } } =20 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; =20 @@ -1967,20 +1886,15 @@ char *format_flags(char *buf, char *end, unsigned l= ong flags, if ((flags & mask) !=3D mask) continue; =20 - buf =3D string(buf, end, names->name, default_str_spec); + string(out, names->name, default_str_spec); =20 flags &=3D ~mask; - if (flags) { - if (buf < end) - *buf =3D '|'; - buf++; - } + if (flags) + prt_char(out, '|'); } =20 if (flags) - buf =3D number(buf, end, flags, default_flag_spec); - - return buf; + number(out, flags, default_flag_spec); } =20 struct page_flags_fields { @@ -2005,20 +1919,18 @@ static const struct page_flags_fields pff[] =3D { }; =20 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 =3D flags & PAGEFLAGS_MASK; bool append =3D false; int i; =20 - buf =3D number(buf, end, flags, default_flag_spec); - if (buf < end) - *buf =3D '('; - buf++; + number(out, flags, default_flag_spec); + prt_char(out, '('); =20 /* Page flags from the main area. */ if (main_flags) { - buf =3D format_flags(buf, end, main_flags, pageflag_names); + format_flags(out, main_flags, pageflag_names); append =3D true; } =20 @@ -2029,41 +1941,31 @@ char *format_page_flags(char *buf, char *end, unsig= ned long flags) continue; =20 /* Format: Flag Name + '=3D' (equals sign) + Number + '|' (separator) */ - if (append) { - if (buf < end) - *buf =3D '|'; - buf++; - } + if (append) + prt_char(out, '|'); =20 - buf =3D string(buf, end, pff[i].name, default_str_spec); - if (buf < end) - *buf =3D '=3D'; - buf++; - buf =3D number(buf, end, (flags >> pff[i].shift) & pff[i].mask, - *pff[i].spec); + string(out, pff[i].name, default_str_spec); + prt_char(out, '=3D'); + number(out, (flags >> pff[i].shift) & pff[i].mask, *pff[i].spec); =20 append =3D true; } - if (buf < end) - *buf =3D ')'; - buf++; - - return buf; + prt_char(out, ')'); } =20 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; =20 - if (check_pointer(&buf, end, flags_ptr, spec)) - return buf; + if (check_pointer(out, flags_ptr, spec)) + return; =20 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 =3D *(unsigned long *)flags_ptr; names =3D vmaflag_names; @@ -2073,15 +1975,15 @@ char *flags_string(char *buf, char *end, void *flag= s_ptr, names =3D gfpflag_names; break; default: - return error_string(buf, end, "(%pG?)", spec); + return error_string(out, "(%pG?)", spec); } =20 - return format_flags(buf, end, flags, names); + return format_flags(out, flags, names); } =20 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; =20 @@ -2090,25 +1992,23 @@ char *fwnode_full_name_string(struct fwnode_handle = *fwnode, char *buf, struct fwnode_handle *__fwnode =3D fwnode_get_nth_parent(fwnode, depth); =20 - buf =3D string(buf, end, fwnode_get_name_prefix(__fwnode), - default_str_spec); - buf =3D 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); =20 fwnode_handle_put(__fwnode); } - - return buf; } =20 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 =3D buf; + unsigned start =3D out->pos; struct property *prop; bool has_mult, pass; =20 @@ -2116,13 +2016,13 @@ char *device_node_string(char *buf, char *end, stru= ct device_node *dn, str_spec.field_width =3D -1; =20 if (fmt[0] !=3D 'F') - return error_string(buf, end, "(%pO?)", spec); + return error_string(out, "(%pO?)", spec); =20 if (!IS_ENABLED(CONFIG_OF)) - return error_string(buf, end, "(%pOF?)", spec); + return error_string(out, "(%pOF?)", spec); =20 - if (check_pointer(&buf, end, dn, spec)) - return buf; + if (check_pointer(out, dn, spec)) + return; =20 /* simple case without anything any more format specifiers */ fmt++; @@ -2131,32 +2031,28 @@ char *device_node_string(char *buf, char *end, stru= ct device_node *dn, =20 for (pass =3D false; strspn(fmt,"fnpPFcC"); fmt++, pass =3D true) { int precision; - if (pass) { - if (buf < end) - *buf =3D ':'; - buf++; - } + if (pass) + prt_char(out, ':'); =20 switch (*fmt) { case 'f': /* full_name */ - buf =3D fwnode_full_name_string(of_fwnode_handle(dn), buf, - end); + fwnode_full_name_string(out, of_fwnode_handle(dn)); break; case 'n': /* name */ p =3D fwnode_get_name(of_fwnode_handle(dn)); precision =3D str_spec.precision; str_spec.precision =3D strchrnul(p, '@') - p; - buf =3D string(buf, end, p, str_spec); + string(out, p, str_spec); str_spec.precision =3D precision; break; case 'p': /* phandle */ - buf =3D 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 =3D fwnode_get_name(of_fwnode_handle(dn)); if (!p[1]) p =3D "/"; - buf =3D string(buf, end, p, str_spec); + string(out, p, str_spec); break; case 'F': /* flags */ tbuf[0] =3D of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; @@ -2164,21 +2060,21 @@ char *device_node_string(char *buf, char *end, stru= ct device_node *dn, tbuf[2] =3D of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-'; tbuf[3] =3D of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-'; tbuf[4] =3D 0; - buf =3D string_nocheck(buf, end, tbuf, str_spec); + string_nocheck(out, tbuf, str_spec); break; case 'c': /* major compatible string */ ret =3D of_property_read_string(dn, "compatible", &p); if (!ret) - buf =3D string(buf, end, p, str_spec); + string(out, p, str_spec); break; case 'C': /* full compatible string */ has_mult =3D false; of_property_for_each_string(dn, "compatible", prop, p) { if (has_mult) - buf =3D string_nocheck(buf, end, ",", str_spec); - buf =3D string_nocheck(buf, end, "\"", str_spec); - buf =3D string(buf, end, p, str_spec); - buf =3D 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); =20 has_mult =3D true; } @@ -2188,37 +2084,38 @@ char *device_node_string(char *buf, char *end, stru= ct device_node *dn, } } =20 - return widen_string(buf, buf - buf_start, end, spec); + widen_string(out, out->pos - start, spec); } =20 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 =3D spec; - char *buf_start =3D buf; + unsigned start =3D out->pos; =20 str_spec.field_width =3D -1; =20 if (*fmt !=3D 'w') - return error_string(buf, end, "(%pf?)", spec); + return error_string(out, "(%pf?)", spec); =20 - if (check_pointer(&buf, end, fwnode, spec)) - return buf; + if (check_pointer(out, fwnode, spec)) + return; =20 fmt++; =20 switch (*fmt) { case 'P': /* name */ - buf =3D string(buf, end, fwnode_get_name(fwnode), str_spec); + string(out, fwnode_get_name(fwnode), str_spec); break; case 'f': /* full_name */ default: - buf =3D fwnode_full_name_string(fwnode, buf, end); + fwnode_full_name_string(out, fwnode); break; } =20 - return widen_string(buf, buf - buf_start, end, spec); + widen_string(out, out->pos - start, spec); } =20 int __init no_hash_pointers_enable(char *str) @@ -2374,8 +2271,8 @@ early_param("no_hash_pointers", no_hash_pointers_enab= le); * rendering it useful as a unique identifier. */ static noinline_for_stack -char *pointer(const char *fmt, char *buf, char *end, void *ptr, - struct printf_spec spec) +void pointer(struct printbuf *out, const char *fmt, + void *ptr, struct printf_spec spec) { switch (*fmt) { case 'S': @@ -2383,24 +2280,24 @@ char *pointer(const char *fmt, char *buf, char *end= , void *ptr, ptr =3D dereference_symbol_descriptor(ptr); fallthrough; case 'B': - return symbol_string(buf, end, ptr, spec, fmt); + return symbol_string(out, ptr, spec, fmt); case 'R': case 'r': - return resource_string(buf, end, ptr, spec, fmt); + return resource_string(out, ptr, spec, fmt); case 'h': - return hex_string(buf, end, ptr, spec, fmt); + return hex_string(out, ptr, spec, fmt); case 'b': switch (fmt[1]) { case 'l': - return bitmap_list_string(buf, end, ptr, spec, fmt); + return bitmap_list_string(out, ptr, spec, fmt); default: - return bitmap_string(buf, end, ptr, spec, fmt); + return bitmap_string(out, ptr, spec, fmt); } case 'M': /* Colon separated: 00:01:02:03:04:05 */ case 'm': /* Contiguous: 000102030405 */ /* [mM]F (FDDI) */ /* [mM]R (Reverse order; Bluetooth) */ - return mac_address_string(buf, end, ptr, spec, fmt); + return mac_address_string(out, ptr, spec, fmt); case 'I': /* Formatted IP supported * 4: 1.2.3.4 * 6: 0001:0203:...:0708 @@ -2410,57 +2307,57 @@ char *pointer(const char *fmt, char *buf, char *end= , void *ptr, * 4: 001.002.003.004 * 6: 000102...0f */ - return ip_addr_string(buf, end, ptr, spec, fmt); + return ip_addr_string(out, ptr, spec, fmt); case 'E': - return escaped_string(buf, end, ptr, spec, fmt); + return escaped_string(out, ptr, spec, fmt); case 'U': - return uuid_string(buf, end, ptr, spec, fmt); + return uuid_string(out, ptr, spec, fmt); case 'V': - return va_format(buf, end, ptr, spec, fmt); + return va_format(out, ptr, spec, fmt); case 'K': - return restricted_pointer(buf, end, ptr, spec); + return restricted_pointer(out, ptr, spec); case 'N': - return netdev_bits(buf, end, ptr, spec, fmt); + return netdev_bits(out, ptr, spec, fmt); case '4': - return fourcc_string(buf, end, ptr, spec, fmt); + return fourcc_string(out, ptr, spec, fmt); case 'a': - return address_val(buf, end, ptr, spec, fmt); + return address_val(out, ptr, spec, fmt); case 'd': - return dentry_name(buf, end, ptr, spec, fmt); + return dentry_name(out, ptr, spec, fmt); case 't': - return time_and_date(buf, end, ptr, spec, fmt); + return time_and_date(out, ptr, spec, fmt); case 'C': - return clock(buf, end, ptr, spec, fmt); + return clock(out, ptr, spec, fmt); case 'D': - return file_dentry_name(buf, end, ptr, spec, fmt); + return file_dentry_name(out, ptr, spec, fmt); #ifdef CONFIG_BLOCK case 'g': - return bdev_name(buf, end, ptr, spec, fmt); + return bdev_name(out, ptr, spec, fmt); #endif =20 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); } } =20 @@ -2682,52 +2579,27 @@ set_precision(struct printf_spec *spec, int prec) } =20 /** - * 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 =3D {0}; =20 /* 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 =3D buf; - end =3D buf + size; - - /* Make sure end is always >=3D buf */ - if (end < buf) { - end =3D ((void *)-1); - size =3D end - buf; - } + if (WARN_ON_ONCE(out->size > INT_MAX)) + return; =20 while (*fmt) { const char *old_fmt =3D fmt; @@ -2736,16 +2608,9 @@ int vsnprintf(char *buf, size_t size, const char *fm= t, va_list args) fmt +=3D read; =20 switch (spec.type) { - case FORMAT_TYPE_NONE: { - int copy =3D read; - if (str < end) { - if (copy > end - str) - copy =3D end - str; - memcpy(str, old_fmt, copy); - } - str +=3D read; + case FORMAT_TYPE_NONE: + prt_bytes(out, old_fmt, read); break; - } =20 case FORMAT_TYPE_WIDTH: set_field_width(&spec, va_arg(args, int)); @@ -2755,44 +2620,29 @@ int vsnprintf(char *buf, size_t size, const char *f= mt, va_list args) set_precision(&spec, va_arg(args, int)); break; =20 - case FORMAT_TYPE_CHAR: { - char c; + case FORMAT_TYPE_CHAR: + if (spec.field_width > 0 && !(spec.flags & LEFT)) + prt_chars(out, spec.field_width, ' '); =20 - if (!(spec.flags & LEFT)) { - while (--spec.field_width > 0) { - if (str < end) - *str =3D ' '; - ++str; + __prt_char(out, (unsigned char) va_arg(args, int)); =20 - } - } - c =3D (unsigned char) va_arg(args, int); - if (str < end) - *str =3D c; - ++str; - while (--spec.field_width > 0) { - if (str < end) - *str =3D ' '; - ++str; - } + if (spec.field_width > 0 && (spec.flags & LEFT)) + prt_chars(out, spec.field_width, ' '); + spec.field_width =3D 0; break; - } =20 case FORMAT_TYPE_STR: - str =3D string(str, end, va_arg(args, char *), spec); + string(out, va_arg(args, char *), spec); break; =20 case FORMAT_TYPE_PTR: - str =3D pointer(fmt, str, end, va_arg(args, void *), - spec); + pointer(out, fmt, va_arg(args, void *), spec); while (isalnum(*fmt)) fmt++; break; =20 case FORMAT_TYPE_PERCENT_CHAR: - if (str < end) - *str =3D '%'; - ++str; + __prt_char(out, '%'); break; =20 case FORMAT_TYPE_INVALID: @@ -2845,21 +2695,70 @@ int vsnprintf(char *buf, size_t size, const char *f= mt, va_list args) num =3D va_arg(args, unsigned int); } =20 - str =3D number(str, end, num, spec); + number(out, num, spec); } } - out: - if (size > 0) { - if (str < end) - *str =3D '\0'; - else - end[-1] =3D '\0'; - } + printbuf_nul_terminate(out); +} +EXPORT_SYMBOL(prt_vprintf); =20 - /* 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; =20 + 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 =3D PRINTBUF_EXTERN(buf, size); + + prt_vprintf(&out, fmt, args); + return out.pos; } EXPORT_SYMBOL(vsnprintf); =20 @@ -2997,53 +2896,46 @@ EXPORT_SYMBOL(sprintf); * bstr_printf() - Binary data to text string */ =20 +static inline void printbuf_align(struct printbuf *out, unsigned align) +{ + /* Assumes output buffer is correctly aligned: */ + out->pos +=3D align - 1; + out->pos &=3D ~(align - 1); +} + /** - * vbin_printf - Parse a format string and place args' binary value in a b= uffer - * @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 generate= d 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 =3D {0}; - char *str, *end; int width; =20 - str =3D (char *)bin_buf; - end =3D (char *)(bin_buf + size); - #define save_arg(type) \ ({ \ unsigned long long value; \ if (sizeof(type) =3D=3D 8) { \ - unsigned long long val8; \ - str =3D PTR_ALIGN(str, sizeof(u32)); \ - val8 =3D va_arg(args, unsigned long long); \ - if (str + sizeof(type) <=3D end) { \ - *(u32 *)str =3D *(u32 *)&val8; \ - *(u32 *)(str + 4) =3D *((u32 *)&val8 + 1); \ - } \ + u64 val8 =3D va_arg(args, u64); \ + printbuf_align(out, sizeof(u32)); \ + prt_bytes(out, (u32 *) &val8, 4); \ + prt_bytes(out, ((u32 *) &val8) + 1, 4); \ value =3D val8; \ } else { \ - unsigned int val4; \ - str =3D PTR_ALIGN(str, sizeof(type)); \ - val4 =3D va_arg(args, int); \ - if (str + sizeof(type) <=3D end) \ - *(typeof(type) *)str =3D (type)(long)val4; \ + u32 val4 =3D va_arg(args, u32); \ + printbuf_align(out, sizeof(type)); \ + prt_bytes(out, &val4, sizeof(type)); \ value =3D (unsigned long long)val4; \ } \ - str +=3D sizeof(type); \ value; \ }) =20 @@ -3074,16 +2966,12 @@ int vbin_printf(u32 *bin_buf, size_t size, const ch= ar *fmt, va_list args) case FORMAT_TYPE_STR: { const char *save_str =3D va_arg(args, char *); const char *err_msg; - size_t len; =20 err_msg =3D check_pointer_msg(save_str); if (err_msg) save_str =3D err_msg; =20 - len =3D strlen(save_str) + 1; - if (str + len < end) - memcpy(str, save_str, len); - str +=3D len; + prt_str(out, save_str); break; } =20 @@ -3103,12 +2991,7 @@ int vbin_printf(u32 *bin_buf, size_t size, const cha= r *fmt, va_list args) save_arg(void *); break; } - str =3D pointer(fmt, str, end, va_arg(args, void *), - spec); - if (str + 1 < end) - *str++ =3D '\0'; - else - end[-1] =3D '\0'; /* Must be nul terminated */ + pointer(out, fmt, va_arg(args, void *), spec); } /* skip all alphanumeric pointer suffixes */ while (isalnum(*fmt)) @@ -3146,15 +3029,15 @@ int vbin_printf(u32 *bin_buf, size_t size, const ch= ar *fmt, va_list args) } =20 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); =20 /** - * bstr_printf - Format a string from binary arguments and place it in a b= uffer + * prt_bstrprintf - Format a string from binary arguments and place it in = a buffer * @buf: The buffer to place the result into - * @size: The size of the buffer, including the trailing null space * @fmt: The format string to use * @bin_buf: Binary arguments for the format string * @@ -3164,26 +3047,14 @@ EXPORT_SYMBOL_GPL(vbin_printf); * * The format follows C99 vsnprintf, but has some extensions: * see vsnprintf comment for details. - * - * The return value is the number of characters which would - * be generated for the given input, excluding the trailing - * '\0', as per ISO C99. If you want to have the exact - * number of characters written into @buf as return value - * (not including the trailing '\0'), use vscnprintf(). If the - * return is greater than or equal to @size, the resulting - * string is truncated. */ -int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_bu= f) +void prt_bstrprintf(struct printbuf *out, const char *fmt, const u32 *bin_= buf) { struct printf_spec spec =3D {0}; - char *str, *end; const char *args =3D (const char *)bin_buf; =20 - if (WARN_ON_ONCE(size > INT_MAX)) - return 0; - - str =3D buf; - end =3D buf + size; + if (WARN_ON_ONCE(out->size > INT_MAX)) + return; =20 #define get_arg(type) \ ({ \ @@ -3200,12 +3071,6 @@ int bstr_printf(char *buf, size_t size, const char *= fmt, const u32 *bin_buf) value; \ }) =20 - /* Make sure end is always >=3D buf */ - if (end < buf) { - end =3D ((void *)-1); - size =3D end - buf; - } - while (*fmt) { const char *old_fmt =3D fmt; int read =3D format_decode(fmt, &spec); @@ -3213,16 +3078,9 @@ int bstr_printf(char *buf, size_t size, const char *= fmt, const u32 *bin_buf) fmt +=3D read; =20 switch (spec.type) { - case FORMAT_TYPE_NONE: { - int copy =3D read; - if (str < end) { - if (copy > end - str) - copy =3D end - str; - memcpy(str, old_fmt, copy); - } - str +=3D read; + case FORMAT_TYPE_NONE: + prt_bytes(out, old_fmt, read); break; - } =20 case FORMAT_TYPE_WIDTH: set_field_width(&spec, get_arg(int)); @@ -3232,38 +3090,24 @@ int bstr_printf(char *buf, size_t size, const char = *fmt, const u32 *bin_buf) set_precision(&spec, get_arg(int)); break; =20 - case FORMAT_TYPE_CHAR: { - char c; - - if (!(spec.flags & LEFT)) { - while (--spec.field_width > 0) { - if (str < end) - *str =3D ' '; - ++str; - } - } - c =3D (unsigned char) get_arg(char); - if (str < end) - *str =3D c; - ++str; - while (--spec.field_width > 0) { - if (str < end) - *str =3D ' '; - ++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; - } =20 case FORMAT_TYPE_STR: { const char *str_arg =3D args; args +=3D strlen(str_arg) + 1; - str =3D string(str, end, (char *)str_arg, spec); + string(out, (char *)str_arg, spec); break; } =20 case FORMAT_TYPE_PTR: { bool process =3D false; - int copy, len; + int len; /* Non function dereferences were already done */ switch (*fmt) { case 'S': @@ -3279,17 +3123,12 @@ int bstr_printf(char *buf, size_t size, const char = *fmt, const u32 *bin_buf) break; } /* Pointer dereference was already processed */ - if (str < end) { - len =3D copy =3D strlen(args); - if (copy > end - str) - copy =3D end - str; - memcpy(str, args, copy); - str +=3D len; - args +=3D len + 1; - } + len =3D strlen(args); + prt_bytes(out, args, len); + args +=3D len + 1; } if (process) - str =3D pointer(fmt, str, end, get_arg(void *), spec); + pointer(out, fmt, get_arg(void *), spec); =20 while (isalnum(*fmt)) fmt++; @@ -3297,9 +3136,7 @@ int bstr_printf(char *buf, size_t size, const char *f= mt, const u32 *bin_buf) } =20 case FORMAT_TYPE_PERCENT_CHAR: - if (str < end) - *str =3D '%'; - ++str; + __prt_char(out, '%'); break; =20 case FORMAT_TYPE_INVALID: @@ -3342,23 +3179,87 @@ int bstr_printf(char *buf, size_t size, const char = *fmt, const u32 *bin_buf) num =3D get_arg(int); } =20 - str =3D number(str, end, num, spec); + number(out, num, spec); } /* default: */ } /* switch(spec.type) */ } /* while(*fmt) */ =20 out: - if (size > 0) { - if (str < end) - *str =3D '\0'; - else - end[-1] =3D '\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 b= uffer + * @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 b= uffer + * @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 generate= d 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 =3D 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 b= uffer + * @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 whic= h 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_bu= f) +{ + struct printbuf out =3D PRINTBUF_EXTERN(buf, size); =20 - /* 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); =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F042EC19F2A for ; Mon, 8 Aug 2022 02:44:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244172AbiHHCoK (ORCPT ); Sun, 7 Aug 2022 22:44:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32800 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242142AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 03C5F218F for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=hZjSf88l3+lM66CwidCtP8JI0G0z2t8AvLM0WYfg0TQ=; b=p5jQkZsDy0AV/sNBCWvC/4+8dm 0VaauoPgqp4NVYzCwEV248UOyXSbbi/ql8lNU+jBMby6YpldIFoWTeyLSs+dLRkysE/Jyas0ICMBy Wl0sp26rQOV16Yq4oNZnM7j04HAgUpGYAGQ7NrLrr2Nl/7bwbwp+FKheY7pXjm2oBBoyC0W6NkexV G2Mcz0DGTQZ4PTBC7qG+CYU2KlbWr8nGeYREeW0VChzZSHGI8d383et5XxDYLoxSOqdcTcTuwHxGj CTSryPAawPxkn1vsqhu2+3NM7FN0KpaGaaKYq6weI0hhQjiMKcSJc/dq5fwz3R1UwlkTk2hTNPchK r7ft5Flw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshw-00DVRV-V7; Mon, 08 Aug 2022 02:41:32 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Mikulas Patocka Subject: [PATCH v5 04/32] lib/hexdump: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:00 +0100 Message-Id: <20220808024128.3219082-5-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Mikulas Patocka --- 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 5c4f4b6d36ab..1906861ece7a 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); =20 +struct printbuf; +void prt_hex_bytes(struct printbuf *, const void *, unsigned, unsigned, un= signed); +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); =20 /* diff --git a/lib/hexdump.c b/lib/hexdump.c index 06833d404398..9556f15ad295 100644 --- a/lib/hexdump.c +++ b/lib/hexdump.c @@ -9,6 +9,7 @@ #include #include #include +#include #include =20 const char hex_asc[] =3D "0123456789abcdef"; @@ -79,32 +80,40 @@ int hex2bin(u8 *dst, const char *src, size_t count) EXPORT_SYMBOL(hex2bin); =20 /** - * 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 =3D src; + const u8 *ptr =3D buf; + unsigned i; =20 - while (count--) - dst =3D hex_byte_pack(dst, *_src++); - return dst; + if (!groupsize) + groupsize =3D 1; + + for (i =3D 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); =20 /** - * 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 =3D= 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 fi= nal - * string if enough space had been available. */ -int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int group= size, - 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 =3D out->pos; const u8 *ptr =3D buf; - int ngroups; - u8 ch; - int j, lx =3D 0; - int ascii_column; - int ret; + int i, ngroups; =20 if (rowsize !=3D 16 && rowsize !=3D 32) rowsize =3D 16; @@ -145,84 +145,127 @@ int hex_dump_to_buffer(const void *buf, size_t len, = int rowsize, int groupsize, groupsize =3D 1; =20 ngroups =3D len / groupsize; - ascii_column =3D rowsize * 2 + rowsize / groupsize + 1; - - if (!linebuflen) - goto overflow1; =20 if (!len) - goto nil; - - if (groupsize =3D=3D 8) { - const u64 *ptr8 =3D buf; - - for (j =3D 0; j < ngroups; j++) { - ret =3D snprintf(linebuf + lx, linebuflen - lx, - "%s%16.16llx", j ? " " : "", - get_unaligned(ptr8 + j)); - if (ret >=3D linebuflen - lx) - goto overflow1; - lx +=3D ret; - } - } else if (groupsize =3D=3D 4) { - const u32 *ptr4 =3D buf; - - for (j =3D 0; j < ngroups; j++) { - ret =3D snprintf(linebuf + lx, linebuflen - lx, - "%s%8.8x", j ? " " : "", - get_unaligned(ptr4 + j)); - if (ret >=3D linebuflen - lx) - goto overflow1; - lx +=3D ret; - } - } else if (groupsize =3D=3D 2) { - const u16 *ptr2 =3D buf; - - for (j =3D 0; j < ngroups; j++) { - ret =3D snprintf(linebuf + lx, linebuflen - lx, - "%s%4.4x", j ? " " : "", - get_unaligned(ptr2 + j)); - if (ret >=3D linebuflen - lx) - goto overflow1; - lx +=3D ret; - } - } else { - for (j =3D 0; j < len; j++) { - if (linebuflen < lx + 2) - goto overflow2; - ch =3D ptr[j]; - linebuf[lx++] =3D hex_asc_hi(ch); - if (linebuflen < lx + 2) - goto overflow2; - linebuf[lx++] =3D hex_asc_lo(ch); - if (linebuflen < lx + 2) - goto overflow2; - linebuf[lx++] =3D ' '; + return; + + prt_hex_bytes(out, ptr, len, groupsize, ' '); + + if (ascii) { + unsigned ascii_column =3D rowsize * 2 + rowsize / groupsize + 1; + + prt_chars(out, ' ', max_t(int, 0, ascii_column - (out->pos - saved_pos))= ); + + for (i =3D 0; i < len; i++) { + u8 ch =3D ptr[i]; + prt_char(out, isascii(ch) && isprint(ch) ? ch : '.'); } - if (j) - lx--; } - if (!ascii) - goto nil; +} +EXPORT_SYMBOL(prt_hex_line); =20 - while (lx < ascii_column) { - if (linebuflen < lx + 2) - goto overflow2; - linebuf[lx++] =3D ' '; - } - for (j =3D 0; j < len; j++) { - if (linebuflen < lx + 2) - goto overflow2; - ch =3D ptr[j]; - linebuf[lx++] =3D (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_NO= NE) + * @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 =3D= 1) + * @ascii: include ASCII after the hex output + * + * Function is an analogue of print_hex_dump() and thus has similar interf= ace. + * + * 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 =3D buf; + size_t i; + + if (rowsize !=3D 16 && rowsize !=3D 32) + rowsize =3D 16; + + for (i =3D 0; i < len; i +=3D 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] =3D '\0'; - return lx; -overflow2: - linebuf[lx++] =3D '\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 =3D 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 =3D= 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 fi= nal + * string if enough space had been available. + */ +int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int group= size, + char *linebuf, size_t linebuflen, bool ascii) +{ + struct printbuf out =3D PRINTBUF_EXTERN(linebuf, linebuflen); + + prt_hex_line(&out, buf, len, rowsize, groupsize, ascii); + return out.pos; } EXPORT_SYMBOL(hex_dump_to_buffer); =20 @@ -262,6 +305,11 @@ void print_hex_dump(const char *level, const char *pre= fix_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 =3D buf; int i, linelen, remaining =3D len; unsigned char linebuf[32 * 3 + 2 + 32 + 1]; diff --git a/lib/test_hexdump.c b/lib/test_hexdump.c index 5144899d3c6b..f9e97879dcdf 100644 --- a/lib/test_hexdump.c +++ b/lib/test_hexdump.c @@ -25,36 +25,19 @@ static const char * const test_data_1[] __initconst =3D= { "4c", "d1", "19", "99", "43", "b1", "af", "0c", }; =20 -static const char * const test_data_2_le[] __initconst =3D { - "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 =3D { +static const char * const test_data_2[] __initconst =3D { "be32", "db7b", "0a18", "93b2", "70ba", "c424", "7d83", "349b", "a69c", "31ad", "9c0f", "ace9", "4cd1", "1999", "43b1", "af0c", }; =20 -static const char * const test_data_4_le[] __initconst =3D { - "7bdb32be", "b293180a", "24c4ba70", "9b34837d", - "ad319ca6", "e9ac0f9c", "9919d14c", "0cafb143", -}; - -static const char * const test_data_4_be[] __initconst =3D { +static const char * const test_data_4[] __initconst =3D { "be32db7b", "0a1893b2", "70bac424", "7d83349b", "a69c31ad", "9c0face9", "4cd11999", "43b1af0c", }; =20 -static const char * const test_data_8_le[] __initconst =3D { - "b293180a7bdb32be", "9b34837d24c4ba70", - "e9ac0f9cad319ca6", "0cafb1439919d14c", -}; - -static const char * const test_data_8_be[] __initconst =3D { +static const char * const test_data_8[] __initconst =3D { "be32db7b0a1893b2", "70bac4247d83349b", "a69c31ad9c0face9", "4cd1199943b1af0c", }; @@ -73,7 +56,6 @@ static void __init test_hexdump_prepare_test(size_t len, = int rowsize, size_t l =3D len; int gs =3D groupsize, rs =3D rowsize; unsigned int i; - const bool is_be =3D IS_ENABLED(CONFIG_CPU_BIG_ENDIAN); =20 if (rs !=3D 16 && rs !=3D 32) rs =3D 16; @@ -85,11 +67,11 @@ static void __init test_hexdump_prepare_test(size_t len= , int rowsize, gs =3D 1; =20 if (gs =3D=3D 8) - result =3D is_be ? test_data_8_be : test_data_8_le; + result =3D test_data_8; else if (gs =3D=3D 4) - result =3D is_be ? test_data_4_be : test_data_4_le; + result =3D test_data_4; else if (gs =3D=3D 2) - result =3D is_be ? test_data_2_be : test_data_2_le; + result =3D test_data_2; else result =3D test_data_1; =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 84ED6C19F2A for ; Mon, 8 Aug 2022 02:41:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242831AbiHHClq (ORCPT ); Sun, 7 Aug 2022 22:41:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60982 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234358AbiHHCli (ORCPT ); Sun, 7 Aug 2022 22:41:38 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 08A0D2195 for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=iecNj4WrMIq076EGFI4G8r6T8aFWcjvbvosteNe+9mQ=; b=Ez13KjVAlCu0nKB9Ummsx8Cb9J ZpbWKQD3ZMlfkTWkRTHdByuUqWF3IjBQ1Y/G3rzTPzh3v2frnGV2TXnl8vzGxxOrcwNjHnlDu/G7E kSfZVPrhAH7HuZTCyV+4yzgClAu/Rs95nNPmw1+DnHsli8RQArVoV/ewIQ4FARb/XMqSHrNXrQ2Fd Q8Y15fG12X4YgNdSLGgvuvSAmZAf1jBkRIGt6yKAbOt9VNPJvEaMBHrzHXKzMx2tK8OalV89wGIdh XTB7z1zEKKsv+Bi69FbZhNAINgSjXB0jcSUEAkCVX7epTYBSpy1wPpzf2F4cjWCDccxeMzC30NmHi fG8av77Q==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRX-1J; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Andy Shevchenko Subject: [PATCH v5 05/32] lib/string_helpers: string_get_size() now returns characters wrote Date: Mon, 8 Aug 2022 03:41:01 +0100 Message-Id: <20220808024128.3219082-6-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Andy Shevchenko Acked-by: Andy Shevchenko --- 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 67de398944e8..52e0f1d283b9 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 */ }; =20 -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); =20 #define UNESCAPE_SPACE BIT(0) #define UNESCAPE_OCTAL BIT(1) diff --git a/lib/string_helpers.c b/lib/string_helpers.c index 7be20bcc6137..d247bf945f16 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 u= nits, + char *buf, int len) { static const char *const units_10[] =3D { "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 =3D units_str[units][i]; =20 - 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); =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6964BC19F2A for ; Mon, 8 Aug 2022 02:42:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243715AbiHHCmA (ORCPT ); Sun, 7 Aug 2022 22:42:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60996 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235236AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0D61B219E for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc: Content-Type:Content-ID:Content-Description; bh=1Pcy2nOf2MsuNc/qSkleQYM5fWNCLNN0ZDrbzvs8o90=; b=p9voLeBA7Kp4Z8voQNS9EXjJHV U3ADUHQogvPAofuVJ/qm/dLNAbmj246qcrCf1oiYgK35a16Uw2N+C8PG9RdHiTldPNa8elQteEi1l Y447ZNdS65FTNOb+tBFZSNbisoQPinpMqJGIz4lnbbYK1VYoQLV0a4qLwlCLregmCcdaCnQpTbz07 kVgtGnMjAPJh143A2jzNqYE+BdYwf047Htaz58Y6YpqK5gOgBZ+dVS7OolLTonbO45API93Xms7Je usPRwridBb1TyhYyIXKYoeC6QO0QievEIU27pvIM3izvnGpMrjxZr2xuG1TiC3r9auYn1MMMM9uvh +ZmRO/5A==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRZ-41; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Subject: [PATCH v5 06/32] lib/printbuf: Heap allocation Date: Mon, 8 Aug 2022 03:41:02 +0100 Message-Id: <20220808024128.3219082-7-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 --- include/linux/printbuf.h | 124 +++++++++++++++++++++++++++++++++------ lib/Makefile | 2 +- lib/printbuf.c | 76 ++++++++++++++++++++++++ 3 files changed, 184 insertions(+), 18 deletions(-) create mode 100644 lib/printbuf.c diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h index 1aa3331bf00b..71f631c49f4e 100644 --- a/include/linux/printbuf.h +++ b/include/linux/printbuf.h @@ -4,19 +4,73 @@ #ifndef _LINUX_PRINTBUF_H #define _LINUX_PRINTBUF_H =20 -#include -#include - /* - * 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 c= ode + * portable between kernelspace and userspace. + * + * Basic example: + * struct printbuf buf =3D PRINTBUF; + * + * prt_printf(&buf, "foo=3D"); + * foo_to_text(&buf, foo); + * printk("%s", buf.buf); + * printbuf_exit(&buf); + * + * Or + * struct printbuf buf =3D 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 alloca= tions + * will be done with GFP_NOWAIT if printbuf->atomic is nonzero. + * + * It's allowed to grab the output buffer and free it later with kfree() i= nstead + * of using printbuf_exit(), if the user just needs a heap allocated strin= g at + * the end. + * + * Memory allocation failures: We don't return errors directly, because on + * memory allocation failure we usually don't want to bail out and unwind = - we + * want to print what we've got, on a best-effort basis. But code that doe= s want + * to return -ENOMEM may check printbuf.allocation_failure. */ =20 +#include +#include + 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; }; =20 +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 =3D true }) + +/* Initializer a printbuf that points to an external buffer: */ +#define PRINTBUF_EXTERN(_buf, _size) \ +((struct printbuf) { \ + .buf =3D _buf, \ + .size =3D _size, \ +}) + /* * Returns size remaining of output buffer: */ @@ -49,26 +103,36 @@ static inline bool printbuf_overflowed(struct printbuf= *out) =20 static inline void printbuf_nul_terminate(struct printbuf *out) { + printbuf_make_room(out, 1); + if (out->pos < out->size) out->buf[out->pos] =3D 0; else if (out->size) out->buf[out->size - 1] =3D 0; } =20 -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] =3D c; out->pos++; } =20 +/* Doesn't nul terminate: */ +static inline void __prt_char(struct printbuf *out, char c) +{ + printbuf_make_room(out, 1); + __prt_char_reserved(out, c); +} + static inline void prt_char(struct printbuf *out, char c) { __prt_char(out, c); printbuf_nul_terminate(out); } =20 -static inline void __prt_chars(struct printbuf *out, char c, unsigned n) +static inline void __prt_chars_reserved(struct printbuf *out, char c, unsi= gned n) { unsigned i, can_print =3D min(n, printbuf_remaining(out)); =20 @@ -79,13 +143,18 @@ static inline void __prt_chars(struct printbuf *out, c= har c, unsigned n) =20 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); } =20 static inline void prt_bytes(struct printbuf *out, const void *b, unsigned= n) { - unsigned i, can_print =3D min(n, printbuf_remaining(out)); + unsigned i, can_print; + + printbuf_make_room(out, n); + + can_print =3D min(n, printbuf_remaining(out)); =20 for (i =3D 0; i < can_print; i++) out->buf[out->pos++] =3D ((char *) b)[i]; @@ -101,22 +170,43 @@ static inline void prt_str(struct printbuf *out, cons= t char *str) =20 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); } =20 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); } =20 -#define PRINTBUF_EXTERN(_buf, _size) \ -((struct printbuf) { \ - .buf =3D _buf, \ - .size =3D _size, \ -}) +/** + * printbuf_reset - re-use a printbuf without freeing and re-initializing = it: + */ +static inline void printbuf_reset(struct printbuf *buf) +{ + buf->pos =3D 0; + buf->allocation_failure =3D 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--; +} =20 #endif /* _LINUX_PRINTBUF_H */ diff --git a/lib/Makefile b/lib/Makefile index 17e48da223e2..d44f8d03d66b 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -34,7 +34,7 @@ lib-y :=3D ctype.o string.o vsprintf.o cmdline.o \ is_single_threaded.o plist.o decompress.o kobject_uevent.o \ earlycpio.o seq_buf.o siphash.o dec_and_lock.o \ nmi_backtrace.o nodemask.o win_minmax.o memcat_p.o \ - buildid.o cpumask.o + buildid.o cpumask.o printbuf.o =20 lib-$(CONFIG_PRINTK) +=3D dump_stack.o =20 diff --git a/lib/printbuf.c b/lib/printbuf.c new file mode 100644 index 000000000000..e3e5a791b244 --- /dev/null +++ b/lib/printbuf.c @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: LGPL-2.1+ +/* Copyright (C) 2022 Kent Overstreet */ + +#ifdef __KERNEL__ +#include +#include +#else +#define EXPORT_SYMBOL(x) +#endif + +#include +#include +#include + +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 +=3D 1; + + if (out->pos + extra < out->size) + return 0; + + new_size =3D roundup_pow_of_two(out->size + extra); + + /* + * Note: output buffer must be freeable with kfree(), it's not required + * that the user use printbuf_exit(). + */ + buf =3D krealloc(out->buf, new_size, !out->atomic ? GFP_KERNEL : GFP_NOWA= IT); + + if (!buf) { + out->allocation_failure =3D true; + return -ENOMEM; + } + + out->buf =3D buf; + out->size =3D new_size; + return 0; +} +EXPORT_SYMBOL(printbuf_make_room); + +/** + * printbuf_str - returns printbuf's buf as a C string, guaranteed to be n= ull + * 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 =3D ERR_PTR(-EINTR); /* poison value */ + } +} +EXPORT_SYMBOL(printbuf_exit); --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F05A0C19F2A for ; Mon, 8 Aug 2022 02:41:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243581AbiHHCl5 (ORCPT ); Sun, 7 Aug 2022 22:41:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32768 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235536AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1FE8621B4 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc: Content-Type:Content-ID:Content-Description; bh=oEg9AsCOZDOluYzZVESlodsCM31B8LHTgFU/mz1O/dw=; b=immJNjPThnAPBDU9T21B8lJXu7 5qJsOClID5bGeO/98Rhe3D7yJlmZkx6zLOewvA5JdShAy9zRzYvu2AQUgZZiYzwhFhMdr3qocjlYG 9unXn04o6NqSqHTc46e6LfZ+eg3HdrEf9Wnj4dtzQ1g4FOve28IsxZNSHably9eTfAjOvTlndTbxT K2df1ctq6jc+58HBj24GZMY1oFuBhlR2Xf4T0fG/KOLFCf2+2N7R3Bn64snoDjMSWqmdmFtLvBfTE dHTxFZE/X+rKFYqQP5WJN5Pp4xG2z2Z0r5FrDQfghOzJyHXe5hrHWo6LEcwFCcVav6GIYrHDzYBkD GtLZ+A+w==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRc-6z; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Subject: [PATCH v5 07/32] lib/printbuf: Tabstops, indenting Date: Mon, 8 Aug 2022 03:41:03 +0100 Message-Id: <20220808024128.3219082-8-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 --- include/linux/printbuf.h | 30 ++++++++++ lib/printbuf.c | 125 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 155 insertions(+) diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h index 71f631c49f4e..c1a482b6c0a8 100644 --- a/include/linux/printbuf.h +++ b/include/linux/printbuf.h @@ -40,6 +40,23 @@ * memory allocation failure we usually don't want to bail out and unwind = - we * want to print what we've got, on a best-effort basis. But code that doe= s 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 ta= bstop. + * prt_tab_rjust() will also advance the current line of text up to the ne= xt + * 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. */ =20 #include @@ -49,18 +66,29 @@ struct printbuf { char *buf; unsigned size; unsigned pos; + unsigned last_newline; + unsigned last_field; + unsigned indent; /* * If nonzero, allocations will be done with GFP_ATOMIC: */ u8 atomic; bool allocation_failure:1; bool heap_allocated:1; + u8 tabstop; + u8 tabstops[4]; }; =20 int printbuf_make_room(struct printbuf *, unsigned); const char *printbuf_str(const struct printbuf *); void printbuf_exit(struct printbuf *); =20 +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 =3D true }) =20 @@ -191,6 +219,8 @@ static inline void printbuf_reset(struct printbuf *buf) { buf->pos =3D 0; buf->allocation_failure =3D 0; + buf->indent =3D 0; + buf->tabstop =3D 0; } =20 /** diff --git a/lib/printbuf.c b/lib/printbuf.c index e3e5a791b244..395c681e3acb 100644 --- a/lib/printbuf.c +++ b/lib/printbuf.c @@ -12,6 +12,11 @@ #include #include =20 +static inline size_t printbuf_linelen(struct printbuf *buf) +{ + return buf->pos - buf->last_newline; +} + int printbuf_make_room(struct printbuf *out, unsigned extra) { unsigned new_size; @@ -74,3 +79,123 @@ void printbuf_exit(struct printbuf *buf) } } EXPORT_SYMBOL(printbuf_exit); + +void prt_newline(struct printbuf *buf) +{ + unsigned i; + + printbuf_make_room(buf, 1 + buf->indent); + + __prt_char(buf, '\n'); + + buf->last_newline =3D buf->pos; + + for (i =3D 0; i < buf->indent; i++) + __prt_char(buf, ' '); + + printbuf_nul_terminate(buf); + + buf->last_field =3D buf->pos; + buf->tabstop =3D 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 =3D 0; + + buf->indent +=3D 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 =3D buf->indent; + + if (buf->last_newline + buf->indent =3D=3D buf->pos) { + buf->pos -=3D spaces; + printbuf_nul_terminate(buf); + } + buf->indent -=3D 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 =3D max_t(int, 0, out->tabstops[out->tabstop] - printbuf_linel= en(out)); + + BUG_ON(out->tabstop > ARRAY_SIZE(out->tabstops)); + + prt_chars(out, ' ', spaces); + + out->last_field =3D 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 afte= r 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 =3D buf->pos - buf->last_field; + unsigned shift =3D 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 +=3D shift; + printbuf_nul_terminate(buf); + } + + buf->last_field =3D buf->pos; + buf->tabstop++; +} +EXPORT_SYMBOL(prt_tab_rjust); --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0D888C19F2A for ; Mon, 8 Aug 2022 02:41:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242760AbiHHClx (ORCPT ); Sun, 7 Aug 2022 22:41:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60986 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234929AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 16AFE21A8 for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc: Content-Type:Content-ID:Content-Description; bh=0Phd27slBhf2oZB2+aKxZkfRmOzBSjVGNr+tezYnifU=; b=IadeLGs48NTANaTLlCZ9j21PjY Y0NUj07GBC+dsXzPSMJvJNTKqJxhF4rHIoQGSKZNFvjxwVM7N8L745psCWispeSCSMJEWCv/BVAmT XWKkYYEVEkH54k2fBQVjvq62LsJce73njhhAEa42aMBzpgEVUMtOsPCQglS/DDwgSuwYjABXnVKLd qE0FpjqFOvJ3xoJLiunrfr4uMZW3y9em32+82YmR+2cBJ6b8iVI2E9xFLd07lXUfE9597xe9d+lQH itWNTKFo8CYmqCCOtcm7GxT+xujybOqpzPBzB+c/H525KOiWrVEkiJJWwukssQXv+cdSYO3DNkIuq oyvLOH+Q==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRe-98; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Subject: [PATCH v5 08/32] lib/printbuf: Unit specifiers Date: Mon, 8 Aug 2022 03:41:04 +0100 Message-Id: <20220808024128.3219082-9-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 --- 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 c1a482b6c0a8..ebbc4a55fc04 100644 --- a/include/linux/printbuf.h +++ b/include/linux/printbuf.h @@ -57,11 +57,20 @@ * * Make sure you use prt_newline() instead of \n in the format string for = indent * level and tabstops to work corretly. + * + * Output units: printbuf->units exists to tell pretty-printers how to out= put + * numbers: a raw value (e.g. directly from a superblock field), as bytes,= or as + * human readable bytes. prt_units() obeys it. */ =20 #include #include =20 +enum printbuf_si { + PRINTBUF_UNITS_2, /* use binary powers of 2^10 */ + PRINTBUF_UNITS_10, /* use powers of 10^3 (standard SI) */ +}; + struct printbuf { char *buf; unsigned size; @@ -75,6 +84,8 @@ struct printbuf { u8 atomic; bool allocation_failure:1; bool heap_allocated:1; + enum printbuf_si si_units:1; + bool human_readable_units:1; u8 tabstop; u8 tabstops[4]; }; @@ -88,6 +99,10 @@ void printbuf_indent_add(struct printbuf *, unsigned); void printbuf_indent_sub(struct printbuf *, unsigned); void prt_tab(struct printbuf *); void prt_tab_rjust(struct printbuf *); +void prt_human_readable_u64(struct printbuf *, u64); +void prt_human_readable_s64(struct printbuf *, s64); +void prt_units_u64(struct printbuf *, u64); +void prt_units_s64(struct printbuf *, s64); =20 /* Initializer for a heap allocated printbuf: */ #define PRINTBUF ((struct printbuf) { .heap_allocated =3D true }) diff --git a/lib/printbuf.c b/lib/printbuf.c index 395c681e3acb..047470025748 100644 --- a/lib/printbuf.c +++ b/lib/printbuf.c @@ -10,6 +10,7 @@ =20 #include #include +#include #include =20 static inline size_t printbuf_linelen(struct printbuf *buf) @@ -199,3 +200,59 @@ void prt_tab_rjust(struct printbuf *buf) buf->tabstop++; } EXPORT_SYMBOL(prt_tab_rjust); + +/** + * prt_human_readable_u64 - Print out a u64 in human readable units + * + * Units of 2^10 (default) or 10^3 are controlled via @buf->si_units + */ +void prt_human_readable_u64(struct printbuf *buf, u64 v) +{ + printbuf_make_room(buf, 10); + buf->pos +=3D 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); --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EC53BC25B07 for ; Mon, 8 Aug 2022 02:41:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242666AbiHHCln (ORCPT ); Sun, 7 Aug 2022 22:41:43 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60980 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231560AbiHHCli (ORCPT ); Sun, 7 Aug 2022 22:41:38 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F1FD42183 for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=mymWwDkjjiHh/KYD2mfecqldcFEi+AVyZTL9MNt1bp8=; b=SIABDbFY5J2Gk7jbWFiO3p0ZNf KnDzFa4aGU9xZH59qz/GileVMl4Avij+19/5gDJ6lrrNv/sQjQRHWSLCIZ0WjOXOA3yH3AhtTLyKG ccuQ7CkkqScB3jIIIbsoITNIaXq2jb1/BUklPldKXS3rw4EKbUK86KlfxRAvfQk23SYDLO3tee9Sd hPTmWgrM1J+UkjXBA68Sv1oKotYUtRN/WCdHJelLGVvsai8pnxtL4wvwAjtBCiKCiRnrcWwM1FQpt QulsI4DSgAsSbmj5rhF9seHsZCehHE3Chl3qdUaEBo2Wva4w7ReuS72UaDg82PfrN6mstk+jgLfvd 9U/Z8H7w==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRg-Bg; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 09/32] vsprintf: Improve number() Date: Mon, 8 Aug 2022 03:41:05 +0100 Message-Id: <20220808024128.3219082-10-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 83 +++++++++++++++++++++++++------------------------- 1 file changed, 41 insertions(+), 42 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 52dac8519a0a..87adc528c6c7 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -457,93 +457,92 @@ void number(struct printbuf *out, unsigned long long = num, { /* put_dec requires 2-byte alignment of the buffer. */ char tmp[3 * sizeof(num)] __aligned(2); - char sign; - char locase; + char sign =3D 0; + /* locase =3D 0 or 0x20. ORing digits or letters with 'locase' + * produces same digits or (maybe lowercased) letters */ + char locase =3D (spec.flags & SMALL); int need_pfx =3D ((spec.flags & SPECIAL) && spec.base !=3D 10); - int i; bool is_zero =3D num =3D=3D 0LL; int field_width =3D spec.field_width; int precision =3D spec.precision; + int nr_digits =3D 0; + int output_bytes =3D 0; =20 - /* locase =3D 0 or 0x20. ORing digits or letters with 'locase' - * produces same digits or (maybe lowercased) letters */ - locase =3D (spec.flags & SMALL); if (spec.flags & LEFT) spec.flags &=3D ~ZEROPAD; - sign =3D 0; if (spec.flags & SIGN) { if ((signed long long)num < 0) { sign =3D '-'; num =3D -(signed long long)num; - field_width--; + output_bytes++; } else if (spec.flags & PLUS) { sign =3D '+'; - field_width--; + output_bytes++; } else if (spec.flags & SPACE) { sign =3D ' '; - field_width--; + output_bytes++; } } if (need_pfx) { if (spec.base =3D=3D 16) - field_width -=3D 2; + output_bytes +=3D 2; else if (!is_zero) - field_width--; + output_bytes++; } =20 /* generate full string in tmp[], in reverse order */ - i =3D 0; - if (num < spec.base) - tmp[i++] =3D hex_asc_upper[num] | locase; - else if (spec.base !=3D 10) { /* 8 or 16 */ + if (spec.base =3D=3D 10) { + nr_digits =3D put_dec(tmp, num) - tmp; + } else { /* 8 or 16 */ int mask =3D spec.base - 1; - int shift =3D 3; + int shift =3D ilog2((unsigned) spec.base); =20 - if (spec.base =3D=3D 16) - shift =3D 4; do { - tmp[i++] =3D (hex_asc_upper[((unsigned char)num) & mask] | locase); + tmp[nr_digits++] =3D (hex_asc_upper[((unsigned char)num) & mask] | loca= se); num >>=3D shift; } while (num); - } else { /* base 10 */ - i =3D put_dec(tmp, num) - tmp; } =20 /* printing 100 using %2d gives "100", not "00" */ - if (i > precision) - precision =3D i; + precision =3D max(nr_digits, precision); + output_bytes +=3D precision; + field_width =3D max(0, field_width - output_bytes); + + printbuf_make_room(out, field_width + output_bytes); + /* leading space padding */ - field_width =3D max(0, field_width - precision); if (!(spec.flags & (ZEROPAD | LEFT)) && field_width) { - __prt_chars(out, ' ', field_width); + __prt_chars_reserved(out, ' ', field_width); field_width =3D 0; } + /* sign */ if (sign) - __prt_char(out, sign); + __prt_char_reserved(out, sign); + /* "0x" / "0" prefix */ if (need_pfx) { if (spec.base =3D=3D 16 || !is_zero) - __prt_char(out, '0'); + __prt_char_reserved(out, '0'); if (spec.base =3D=3D 16) - __prt_char(out, 'X' | locase); + __prt_char_reserved(out, 'X' | locase); } - /* zero or space padding */ - if (!(spec.flags & LEFT) && field_width) { - char c =3D ' ' + (spec.flags & ZEROPAD); =20 - __prt_chars(out, c, field_width); - field_width =3D 0; - } - /* hmm even more zero padding? */ - if (precision > i) - __prt_chars(out, '0', precision - i); + /* zero padding */ + if (!(spec.flags & LEFT) && field_width) + __prt_chars_reserved(out, '0', field_width); + + /* zero padding from precision */ + if (precision > nr_digits) + __prt_chars_reserved(out, '0', precision - nr_digits); + /* actual digits of result */ - while (--i >=3D 0) - __prt_char(out, tmp[i]); + while (--nr_digits >=3D 0) + __prt_char_reserved(out, tmp[nr_digits]); + /* trailing space padding */ - if (field_width) - __prt_chars(out, ' ', field_width); + if ((spec.flags & LEFT) && field_width) + __prt_chars_reserved(out, ' ', field_width); =20 printbuf_nul_terminate(out); } --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 17516C19F2A for ; Mon, 8 Aug 2022 02:41:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242814AbiHHClu (ORCPT ); Sun, 7 Aug 2022 22:41:50 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60990 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235146AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1B59A21AF for ; Sun, 7 Aug 2022 19:41:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=bSGKE8iFlW5a7FQH8CgH+oMcAkiK5MKZFOT72qzciO0=; b=jt7X1iCUv5mwyJBs5nnKwXo1St DiGJj5DR1zBUtb5zHJVBOI1lreCGl/PenFWfN0U8Tmtnyq4iKrGCCkdItC4TRjJyEoQn9oGQ1Armu bnHlrUrvxN8atfe6yk3aLgo9MYq/B5OwFem8ji4pW4251g9lKeghTnkJaV5xW7a0UikdcWPLvj/JP qdRJqCPaUQyrJSWoP1/aF+UWG2mnkqAqQIMxU4H/gcvL6AeqR67+fGYDfsMQt+4NAcv8NwX3BJenO 9KOf4riy0B9lBNxU6wMPAqGt9DatOecGrwlWu+KyVADD4M2cf3v8vduyuNSB9O2EHub8JD4DHEVjQ 6M+kdVIQ==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRj-E3; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 10/32] vsprintf: prt_u64_minwidth(), prt_u64() Date: Mon, 8 Aug 2022 03:41:06 +0100 Message-Id: <20220808024128.3219082-11-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- 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 1906861ece7a..9ba5a53c6ad5 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -202,12 +202,14 @@ static inline void might_fault(void) { } =20 void do_exit(long error_code) __noreturn; =20 +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); =20 /* lib/printf utilities */ =20 -struct printbuf; extern __printf(2, 3) void prt_printf(struct printbuf *out, const char *fm= t, ...); extern __printf(2, 0) void prt_vprintf(struct printbuf *out, const char *f= mt, va_list); =20 diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 87adc528c6c7..6001710352c4 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -368,41 +368,51 @@ char *put_dec(char *buf, unsigned long long n) =20 #endif =20 -/* - * 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 w= idth) +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 =3D put_dec(tmp, num) - tmp; =20 - /* put_dec() may work incorrectly for num =3D 0 (generate "", not "0") */ - if (num <=3D 9) { - tmp[0] =3D '0' + num; - len =3D 1; - } else { - len =3D put_dec(tmp, num) - tmp; - } + printbuf_make_room(out, max(len, width)); =20 - if (len > size || width > size) - return 0; + if (width > len) + __prt_chars_reserved(out, '0', width - len); =20 - if (width > len) { - width =3D width - len; - for (idx =3D 0; idx < width; idx++) - buf[idx] =3D ' '; - } else { - width =3D 0; - } + while (len) + __prt_char_reserved(out, tmp[--len]); + printbuf_nul_terminate(out); +} =20 - for (idx =3D 0; idx < len; ++idx) - buf[idx + width] =3D 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); +} =20 - 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 w= idth) +{ + struct printbuf out =3D PRINTBUF_EXTERN(buf, size); + + prt_u64_minwidth(&out, num, width); + return out.pos; } =20 #define SIGN 1 /* unsigned/signed, must be 1 */ @@ -993,20 +1003,6 @@ static const struct printf_spec default_dec_spec =3D { .precision =3D -1, }; =20 -static const struct printf_spec default_dec02_spec =3D { - .base =3D 10, - .field_width =3D 2, - .precision =3D -1, - .flags =3D ZEROPAD, -}; - -static const struct printf_spec default_dec04_spec =3D { - .base =3D 10, - .field_width =3D 4, - .precision =3D -1, - .flags =3D ZEROPAD, -}; - static noinline_for_stack void resource_string(struct printbuf *out, struct resource *res, struct printf_spec spec, const char *fmt) @@ -1206,12 +1202,12 @@ void bitmap_list_string(struct printbuf *out, unsig= ned long *bitmap, prt_char(out, ','); first =3D false; =20 - number(out, rbot, default_dec_spec); + prt_u64(out, rbot); if (rtop =3D=3D rbot + 1) continue; =20 prt_char(out, '-'); - number(out, rtop - 1, default_dec_spec); + prt_u64(out, rtop - 1); } } =20 @@ -1753,21 +1749,21 @@ void date_str(struct printbuf *out, int year =3D tm->tm_year + (r ? 0 : 1900); int mon =3D tm->tm_mon + (r ? 0 : 1); =20 - 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); } =20 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); } =20 static noinline_for_stack @@ -2045,7 +2041,7 @@ void device_node_string(struct printbuf *out, struct = device_node *dn, str_spec.precision =3D 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 =3D fwnode_get_name(of_fwnode_handle(dn)); --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7EC20C19F2A for ; Mon, 8 Aug 2022 02:42:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243922AbiHHCml (ORCPT ); Sun, 7 Aug 2022 22:42:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32832 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242314AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 11D6B2195 for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=a3gw8T2wmTsMaOixEBYK8gncqlwLvCu6/33p0qCLa04=; b=bnqPuJaktKpPDB2PsSxP8w75YI Kmaoz5QEXu7/3vSjhh9wcJmljO7wjGgkCCs+tmtwvj1aQPhrPP8SsH9BGV2e6cIANJKzo/ZjvJPLN 3CiUpRrXWYd1j+tXC6EPGp29kbBOJY2CiRneABJXeR/wYfhvT1PaWXVcHuVmNmKxP7KQiaQtAQckn QiGJPajg6oCE+lDTqXuNh4pJsHDTYMmtUPxD/q+gkI+rXOqxLQLjt4O2RUvctZabO0nZ5/rS2iKBK /tOEIF29Bkbznx0TzBa8dh9/n3QJw8pJJOr6Wrr/xKrdb/Ma1hCsyqxfYxofxn821CaqY+uTlDNY2 62r6pa1g==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRl-I8; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 11/32] test_printf: Drop requirement that sprintf not write past nul Date: Mon, 8 Aug 2022 03:41:07 +0100 Message-Id: <20220808024128.3219082-12-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Rasmus Villemoes --- lib/test_printf.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/lib/test_printf.c b/lib/test_printf.c index 4bd15a593fbd..da91301eae50 100644 --- a/lib/test_printf.c +++ b/lib/test_printf.c @@ -84,12 +84,6 @@ do_test(int bufsize, const char *expect, int elen, return 1; } =20 - if (memchr_inv(test_buffer + written + 1, FILL_CHAR, bufsize - (written += 1))) { - pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote beyond the nul-terminator= \n", - bufsize, fmt); - return 1; - } - if (memchr_inv(test_buffer + bufsize, FILL_CHAR, BUF_SIZE + PAD_SIZE - bu= fsize)) { pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote beyond buffer\n", bufsize= , fmt); return 1; --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 79B2DC19F2A for ; Mon, 8 Aug 2022 02:43:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244146AbiHHCnl (ORCPT ); Sun, 7 Aug 2022 22:43:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32770 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242582AbiHHClm (ORCPT ); Sun, 7 Aug 2022 22:41:42 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 22734219E for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=7qSX4DWk660gtWbE+pgHZXY5fOXYwG1CgY0pli4vuy8=; b=ha2IKdP4Xnoza5Q3udgzwC+YmH n+DTg1QCq3pqYape5KSxsduOwk2QpLZfeKDvgc19Nx4l1sjS6Pyav80bFyFIZNJHJJ77Lys4U2V6i 3ySLEeOXCzMl0GDPXT/c6BKX3571ftBrnr5SavPyPmUARDjIq0KXmUvEaI+kuxEqsFjXS3rpaynNg vJPE+CcBEvTkEiFsEaWnqemgD1unFhxSZK0IOyaB9xdYNGo826NIPpNvrwzDDrjoj5Bf3zrnlcuhP bmDJ23YeNdOsBcrMCEfmnSyMSAy2MAahCr64Otiv7xK5H+wV4tvOvZLiYUsajhMJH9nhOLZgBpOK8 8EdcYv8Q==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRn-KQ; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 12/32] vsprintf: Start consolidating printf_spec handling Date: Mon, 8 Aug 2022 03:41:08 +0100 Message-Id: <20220808024128.3219082-13-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 248 ++++++++++++++++++++++++++++--------------------- 1 file changed, 141 insertions(+), 107 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 6001710352c4..5cc8337ada0c 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -616,6 +616,19 @@ void widen_string(struct printbuf *out, int n, prt_chars(out, ' ', spaces); } =20 +static void do_width_precision(struct printbuf *out, unsigned prev_pos, + struct printf_spec spec) +{ + unsigned n =3D out->pos - prev_pos; + + if (n > spec.precision) { + out->pos -=3D n - spec.precision; + n =3D spec.precision; + } + + widen_string(out, n, spec); +} + /* Handle string from a well known address. */ static void string_nocheck(struct printbuf *out, const char *s, @@ -648,7 +661,7 @@ static void err_ptr(struct printbuf *out, void *ptr, } =20 /* Be careful: error messages must fit into the given buffer. */ -static void error_string(struct printbuf *out, const char *s, +static void error_string_spec(struct printbuf *out, const char *s, struct printf_spec spec) { /* @@ -678,7 +691,7 @@ static const char *check_pointer_msg(const void *ptr) return NULL; } =20 -static int check_pointer(struct printbuf *out, +static int check_pointer_spec(struct printbuf *out, const void *ptr, struct printf_spec spec) { @@ -686,7 +699,7 @@ static int check_pointer(struct printbuf *out, =20 err_msg =3D check_pointer_msg(ptr); if (err_msg) { - error_string(out, err_msg, spec); + error_string_spec(out, err_msg, spec); return -EFAULT; } =20 @@ -694,16 +707,47 @@ static int check_pointer(struct printbuf *out, } =20 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; =20 string_nocheck(out, s, spec); } =20 +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 =3D check_pointer_msg(ptr); + if (err_msg) { + error_string(out, err_msg); + return -EFAULT; + } + + return 0; +} + +static void string(struct printbuf *out, const char *s) +{ + if (check_pointer(out, s)) + return; + + prt_str(out, s); +} + static void pointer_string(struct printbuf *out, const void *ptr, struct printf_spec spec) @@ -805,7 +849,7 @@ static void ptr_to_id(struct printbuf *out, if (ret) { spec.field_width =3D 2 * sizeof(ptr); /* string length must be less than default_width */ - return error_string(out, str, spec); + return error_string_spec(out, str, spec); } =20 pointer_string(out, (const void *)hashval, spec); @@ -846,7 +890,7 @@ void restricted_pointer(struct printbuf *out, if (in_irq() || in_serving_softirq() || in_nmi()) { if (spec.field_width =3D=3D -1) spec.field_width =3D 2 * sizeof(ptr); - return error_string(out, "pK-error", spec); + return error_string_spec(out, "pK-error", spec); } =20 /* @@ -876,14 +920,12 @@ void restricted_pointer(struct printbuf *out, } =20 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; =20 switch (fmt[1]) { case '2': case '3': case '4': @@ -895,7 +937,7 @@ void dentry_name(struct printbuf *out, =20 rcu_read_lock(); for (i =3D 0; i < depth; i++, d =3D p) { - if (check_pointer(out, d, spec)) { + if (check_pointer(out, d)) { rcu_read_unlock(); return; } @@ -909,56 +951,46 @@ void dentry_name(struct printbuf *out, break; } } - s =3D array[--i]; - for (n =3D 0; n !=3D spec.precision; n++) { - char c =3D *s++; - if (!c) { - if (!i) - break; - c =3D '/'; - s =3D 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); } =20 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; =20 - 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; =20 - if (check_pointer(out, bdev, spec)) + if (check_pointer(out, bdev)) return; =20 hd =3D 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 =20 static noinline_for_stack void symbol_string(struct printbuf *out, void *ptr, - struct printf_spec spec, const char *fmt) + const char *fmt) { unsigned long value; #ifdef CONFIG_KALLSYMS @@ -981,17 +1013,12 @@ void symbol_string(struct printbuf *out, void *ptr, else sprint_symbol_no_offset(sym, value); =20 - string_nocheck(out, sym, spec); + prt_str(out, sym); #else special_hex_number(out, value, sizeof(void *)); #endif } =20 -static const struct printf_spec default_str_spec =3D { - .field_width =3D -1, - .precision =3D -1, -}; - static const struct printf_spec default_flag_spec =3D { .base =3D 16, .precision =3D -1, @@ -1050,7 +1077,7 @@ void resource_string(struct printbuf *out, struct res= ource *res, int decode =3D (fmt[0] =3D=3D 'R') ? 1 : 0; const struct printf_spec *specp; =20 - if (check_pointer(out, res, spec)) + if (check_pointer_spec(out, res, spec)) return; =20 prt_char(&sym, '['); @@ -1114,7 +1141,7 @@ void hex_string(struct printbuf *out, u8 *addr, /* nothing to print */ return; =20 - if (check_pointer(out, addr, spec)) + if (check_pointer_spec(out, addr, spec)) return; =20 switch (fmt[1]) { @@ -1155,7 +1182,7 @@ void bitmap_string(struct printbuf *out, unsigned lon= g *bitmap, int i, chunksz; bool first =3D true; =20 - if (check_pointer(out, bitmap, spec)) + if (check_pointer_spec(out, bitmap, spec)) return; =20 /* reused to print numbers */ @@ -1194,7 +1221,7 @@ void bitmap_list_string(struct printbuf *out, unsigne= d long *bitmap, bool first =3D true; int rbot, rtop; =20 - if (check_pointer(out, bitmap, spec)) + if (check_pointer_spec(out, bitmap, spec)) return ; =20 for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) { @@ -1221,7 +1248,7 @@ void mac_address_string(struct printbuf *out, u8 *add= r, char separator; bool reversed =3D false; =20 - if (check_pointer(out, addr, spec)) + if (check_pointer_spec(out, addr, spec)) return; =20 switch (fmt[1]) { @@ -1522,7 +1549,7 @@ void ip_addr_string(struct printbuf *out, const void = *ptr, { char *err_fmt_msg; =20 - if (check_pointer(out, ptr, spec)) + if (check_pointer_spec(out, ptr, spec)) return; =20 switch (fmt[1]) { @@ -1543,12 +1570,12 @@ void ip_addr_string(struct printbuf *out, const voi= d *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); }} } =20 err_fmt_msg =3D fmt[0] =3D=3D 'i' ? "(%pi?)" : "(%pI?)"; - return error_string(out, err_fmt_msg, spec); + return error_string_spec(out, err_fmt_msg, spec); } =20 static noinline_for_stack @@ -1563,7 +1590,7 @@ void escaped_string(struct printbuf *out, u8 *addr, if (spec.field_width =3D=3D 0) return; /* nothing to print */ =20 - if (check_pointer(out, addr, spec)) + if (check_pointer_spec(out, addr, spec)) return; =20 do { @@ -1608,7 +1635,7 @@ static void va_format(struct printbuf *out, { va_list va; =20 - if (check_pointer(out, va_fmt, spec)) + if (check_pointer_spec(out, va_fmt, spec)) return; =20 va_copy(va, *va_fmt->va); @@ -1617,16 +1644,13 @@ static void va_format(struct printbuf *out, } =20 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 =3D PRINTBUF_EXTERN(uuid_buf, sizeof(uuid_buf)); int i; const u8 *index =3D uuid_index; bool uc =3D false; =20 - if (check_pointer(out, addr, spec)) + if (check_pointer(out, addr)) return; =20 switch (*(++fmt)) { @@ -1643,30 +1667,28 @@ void uuid_string(struct printbuf *out, const u8 *ad= dr, =20 for (i =3D 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); } =20 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; =20 - if (check_pointer(out, addr, spec)) + if (check_pointer(out, addr)) return; =20 switch (fmt[1]) { @@ -1676,7 +1698,7 @@ void netdev_bits(struct printbuf *out, const void *ad= dr, special_hex_number(out, num, size); break; default: - error_string(out, "(%pN?)", spec); + error_string(out, "(%pN?)"); break; } } @@ -1691,9 +1713,9 @@ void fourcc_string(struct printbuf *out, const u32 *f= ourcc, u32 orig, val; =20 if (fmt[1] !=3D 'c' || fmt[2] !=3D 'c') - return error_string(out, "(%p4?)", spec); + return error_string_spec(out, "(%p4?)", spec); =20 - if (check_pointer(out, fourcc, spec)) + if (check_pointer_spec(out, fourcc, spec)) return; =20 orig =3D get_unaligned(fourcc); @@ -1714,17 +1736,17 @@ void fourcc_string(struct printbuf *out, const u32 = *fourcc, special_hex_number(&output, orig, sizeof(u32)); prt_char(&output, ')'); =20 - string(out, output_buf, spec); + string_spec(out, output_buf, spec); } =20 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; =20 - if (check_pointer(out, addr, spec)) + if (check_pointer(out, addr)) return; =20 switch (fmt[1]) { @@ -1775,7 +1797,7 @@ void rtc_str(struct printbuf *out, const struct rtc_t= ime *tm, bool found =3D true; int count =3D 2; =20 - if (check_pointer(out, tm, spec)) + if (check_pointer_spec(out, tm, spec)) return; =20 switch (fmt[count]) { @@ -1845,7 +1867,7 @@ void time_and_date(struct printbuf *out, case 'T': return time64_str(out, *(const time64_t *)ptr, spec, fmt); default: - return error_string(out, "(%pt?)", spec); + return error_string_spec(out, "(%pt?)", spec); } } =20 @@ -1854,16 +1876,16 @@ void clock(struct printbuf *out, struct clk *clk, struct printf_spec spec, const char *fmt) { if (!IS_ENABLED(CONFIG_HAVE_CLK)) - return error_string(out, "(%pC?)", spec); + return error_string_spec(out, "(%pC?)", spec); =20 - if (check_pointer(out, clk, spec)) + if (check_pointer_spec(out, clk, spec)) return; =20 switch (fmt[1]) { case 'n': default: #ifdef CONFIG_COMMON_CLK - return string(out, __clk_get_name(clk), spec); + return string_spec(out, __clk_get_name(clk), spec); #else return ptr_to_id(out, clk, spec); #endif @@ -1881,7 +1903,7 @@ void format_flags(struct printbuf *out, unsigned long= flags, if ((flags & mask) !=3D mask) continue; =20 - string(out, names->name, default_str_spec); + string(out, names->name); =20 flags &=3D ~mask; if (flags) @@ -1939,7 +1961,7 @@ void format_page_flags(struct printbuf *out, unsigned= long flags) if (append) prt_char(out, '|'); =20 - string(out, pff[i].name, default_str_spec); + string(out, pff[i].name); prt_char(out, '=3D'); number(out, (flags >> pff[i].shift) & pff[i].mask, *pff[i].spec); =20 @@ -1955,7 +1977,7 @@ void flags_string(struct printbuf *out, void *flags_p= tr, unsigned long flags; const struct trace_print_flags *names; =20 - if (check_pointer(out, flags_ptr, spec)) + if (check_pointer_spec(out, flags_ptr, spec)) return; =20 switch (fmt[1]) { @@ -1970,7 +1992,7 @@ void flags_string(struct printbuf *out, void *flags_p= tr, names =3D gfpflag_names; break; default: - return error_string(out, "(%pG?)", spec); + return error_string_spec(out, "(%pG?)", spec); } =20 return format_flags(out, flags, names); @@ -1987,10 +2009,8 @@ void fwnode_full_name_string(struct printbuf *out, struct fwnode_handle *__fwnode =3D fwnode_get_nth_parent(fwnode, depth); =20 - 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)); =20 fwnode_handle_put(__fwnode); } @@ -2011,12 +2031,12 @@ void device_node_string(struct printbuf *out, struc= t device_node *dn, str_spec.field_width =3D -1; =20 if (fmt[0] !=3D 'F') - return error_string(out, "(%pO?)", spec); + return error_string_spec(out, "(%pO?)", spec); =20 if (!IS_ENABLED(CONFIG_OF)) - return error_string(out, "(%pOF?)", spec); + return error_string_spec(out, "(%pOF?)", spec); =20 - if (check_pointer(out, dn, spec)) + if (check_pointer_spec(out, dn, spec)) return; =20 /* simple case without anything any more format specifiers */ @@ -2037,7 +2057,7 @@ void device_node_string(struct printbuf *out, struct = device_node *dn, p =3D fwnode_get_name(of_fwnode_handle(dn)); precision =3D str_spec.precision; str_spec.precision =3D strchrnul(p, '@') - p; - string(out, p, str_spec); + string_spec(out, p, str_spec); str_spec.precision =3D precision; break; case 'p': /* phandle */ @@ -2047,7 +2067,7 @@ void device_node_string(struct printbuf *out, struct = device_node *dn, p =3D fwnode_get_name(of_fwnode_handle(dn)); if (!p[1]) p =3D "/"; - string(out, p, str_spec); + string_spec(out, p, str_spec); break; case 'F': /* flags */ tbuf[0] =3D of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; @@ -2057,18 +2077,18 @@ void device_node_string(struct printbuf *out, struc= t device_node *dn, tbuf[4] =3D 0; string_nocheck(out, tbuf, str_spec); break; - case 'c': /* major compatible string */ + case 'c': /* major compatible string_spec */ ret =3D 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 =3D 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); =20 has_mult =3D true; @@ -2093,16 +2113,16 @@ void fwnode_string(struct printbuf *out, str_spec.field_width =3D -1; =20 if (*fmt !=3D 'w') - return error_string(out, "(%pf?)", spec); + return error_string_spec(out, "(%pf?)", spec); =20 - if (check_pointer(out, fwnode, spec)) + if (check_pointer_spec(out, fwnode, spec)) return; =20 fmt++; =20 switch (*fmt) { case 'P': /* name */ - string(out, fwnode_get_name(fwnode), str_spec); + string_spec(out, fwnode_get_name(fwnode), str_spec); break; case 'f': /* full_name */ default: @@ -2269,13 +2289,16 @@ static noinline_for_stack void pointer(struct printbuf *out, const char *fmt, void *ptr, struct printf_spec spec) { + unsigned prev_pos =3D out->pos; + switch (*fmt) { case 'S': case 's': ptr =3D dereference_symbol_descriptor(ptr); fallthrough; case 'B': - return symbol_string(out, ptr, spec, fmt); + symbol_string(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'R': case 'r': return resource_string(out, ptr, spec, fmt); @@ -2306,28 +2329,34 @@ void pointer(struct printbuf *out, const char *fmt, case 'E': return escaped_string(out, ptr, spec, fmt); case 'U': - return uuid_string(out, ptr, spec, fmt); + uuid_string(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'V': return va_format(out, ptr, spec, fmt); case 'K': return restricted_pointer(out, ptr, spec); case 'N': - return netdev_bits(out, ptr, spec, fmt); + netdev_bits(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case '4': return fourcc_string(out, ptr, spec, fmt); case 'a': - return address_val(out, ptr, spec, fmt); + address_val(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'd': - return dentry_name(out, ptr, spec, fmt); + dentry_name(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 't': return time_and_date(out, ptr, spec, fmt); case 'C': return clock(out, ptr, spec, fmt); case 'D': - return file_dentry_name(out, ptr, spec, fmt); + file_dentry_name(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); #ifdef CONFIG_BLOCK case 'g': - return bdev_name(out, ptr, spec, fmt); + bdev_name(out, ptr); + return do_width_precision(out, prev_pos, spec); #endif =20 case 'G': @@ -2347,9 +2376,9 @@ void pointer(struct printbuf *out, const char *fmt, case 'k': switch (fmt[1]) { case 's': - return string(out, ptr, spec); + return string_spec(out, ptr, spec); default: - return error_string(out, "(einval)", spec); + return error_string_spec(out, "(einval)", spec); } default: return default_pointer(out, ptr, spec); @@ -2627,7 +2656,12 @@ void prt_vprintf(struct printbuf *out, const char *f= mt, va_list args) break; =20 case FORMAT_TYPE_STR: - string(out, va_arg(args, char *), spec); + /* + * we can't use string() then do_width_precision + * afterwards: people use the field width for passing + * non nul terminated strings + */ + string_spec(out, va_arg(args, char *), spec); break; =20 case FORMAT_TYPE_PTR: @@ -3096,7 +3130,7 @@ void prt_bstrprintf(struct printbuf *out, const char = *fmt, const u32 *bin_buf) case FORMAT_TYPE_STR: { const char *str_arg =3D args; args +=3D strlen(str_arg) + 1; - string(out, (char *)str_arg, spec); + string_spec(out, (char *)str_arg, spec); break; } =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CF248C19F2A for ; Mon, 8 Aug 2022 02:43:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244045AbiHHCnJ (ORCPT ); Sun, 7 Aug 2022 22:43:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32854 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242413AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 40C8121A8 for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=RlavjRy9kvgaAWt9y6l0Gv7CjB4rdfzSfzo2twQl+yU=; b=KW2wt7jTWSA+RBXfBDJPAqxqKP i9j4reKMem5DlX6LwuZ6/MaZP62/SM9IQP+CXTPgOvmzWr8QiCWYKkltkP8nx1Ns2eRZWejlxqIXA OpmBc2mrKETeAstSEVuq5fbTimq4K0V/pW6F38SWM9VJixNL5H4mf4Vo45yYy7hpcfxtddhdiR2OR Ybr/YfTJoqrv+XHORCF5riSRJNSgwQOZ14ky8RaXjSULgDkMQ2UOSIj827HH8Rxb1ZrBK7irMSfi2 XMsP1hkBE/bXk8eLA3ibnXxsEDU4e6DqE2J8pwPmIbNKVBGkAUncrA6bu5o+mq+VbmNiUW/yCXkCt rLYnUJPw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRp-N2; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 13/32] vsprintf: Refactor resource_string() Date: Mon, 8 Aug 2022 03:41:09 +0100 Message-Id: <20220808024128.3219082-14-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 51 ++++++++++++++++++++++++-------------------------- 1 file changed, 24 insertions(+), 27 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 5cc8337ada0c..2c5f10bc59e2 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1032,7 +1032,7 @@ static const struct printf_spec default_dec_spec =3D { =20 static noinline_for_stack void resource_string(struct printbuf *out, struct resource *res, - struct printf_spec spec, const char *fmt) + int decode) { #ifndef IO_RSRC_PRINTK_SIZE #define IO_RSRC_PRINTK_SIZE 6 @@ -1071,62 +1071,58 @@ void resource_string(struct printbuf *out, struct r= esource *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 =3D PRINTBUF_EXTERN(sym_buf, sizeof(sym_buf)); - int decode =3D (fmt[0] =3D=3D 'R') ? 1 : 0; const struct printf_spec *specp; =20 - if (check_pointer_spec(out, res, spec)) + if (check_pointer(out, res)) return; =20 - prt_char(&sym, '['); + prt_char(out, '['); if (res->flags & IORESOURCE_IO) { - string_nocheck(&sym, "io ", str_spec); + string_nocheck(out, "io ", str_spec); specp =3D &io_spec; } else if (res->flags & IORESOURCE_MEM) { - string_nocheck(&sym, "mem ", str_spec); + string_nocheck(out, "mem ", str_spec); specp =3D &mem_spec; } else if (res->flags & IORESOURCE_IRQ) { - string_nocheck(&sym, "irq ", str_spec); + string_nocheck(out, "irq ", str_spec); specp =3D &default_dec_spec; } else if (res->flags & IORESOURCE_DMA) { - string_nocheck(&sym, "dma ", str_spec); + string_nocheck(out, "dma ", str_spec); specp =3D &default_dec_spec; } else if (res->flags & IORESOURCE_BUS) { - string_nocheck(&sym, "bus ", str_spec); + string_nocheck(out, "bus ", str_spec); specp =3D &bus_spec; } else { - string_nocheck(&sym, "??? ", str_spec); + string_nocheck(out, "??? ", str_spec); specp =3D &mem_spec; decode =3D 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 !=3D 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, ']'); =20 - string_nocheck(out, sym_buf, spec); + printbuf_nul_terminate(out); } =20 static noinline_for_stack @@ -2301,7 +2297,8 @@ void pointer(struct printbuf *out, const char *fmt, return do_width_precision(out, prev_pos, spec); case 'R': case 'r': - return resource_string(out, ptr, spec, fmt); + resource_string(out, ptr, fmt[0] =3D=3D 'R'); + return do_width_precision(out, prev_pos, spec); case 'h': return hex_string(out, ptr, spec, fmt); case 'b': --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 30789C19F2A for ; Mon, 8 Aug 2022 02:43:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244162AbiHHCns (ORCPT ); Sun, 7 Aug 2022 22:43:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32856 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242448AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4B15A21AF for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=D8UCvE42MAR+ZYM3si/CNIX4RG/qDGM3KKoxlZUxilc=; b=XsNu7EIebpiESnQvtSefLjOIGa kCD4DfmYmuM4c2J31kJyTvxn2hyJAs2HXeldH7iCoMzDtc75hUDC04RxzX3hOeOy1jiHV1J9Q7Ety SgHZgeZEQ5fuOcgHqujimflQFHSsT4ANiLhtwr00tCSIXfz9+F4Ol6ItThzVvAI0K4wrxY18G+qp0 DAlyD+Eyo9DZCHkpB/YXjUw94f0tQ4HBlNrUCD1iKyrHMFL/spSkA/1mKtdpJyhWjjZ/nGZvo/SM7 7KMuL4sFJ9TyPqTx0l1xLGv8q0nN95rwOX17SZ2urvmHZGPJipPVUr7HyiV1M5+xYE1a1+nZLxrNG zEL8rIrQ==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRr-P6; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 14/32] vsprintf: Refactor fourcc_string() Date: Mon, 8 Aug 2022 03:41:10 +0100 Message-Id: <20220808024128.3219082-15-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet - 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 2c5f10bc59e2..f47f10659737 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1701,17 +1701,15 @@ void netdev_bits(struct printbuf *out, const void *= addr, =20 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 =3D PRINTBUF_EXTERN(output_buf, sizeof(output_buf)= ); unsigned int i; u32 orig, val; =20 if (fmt[1] !=3D 'c' || fmt[2] !=3D 'c') - return error_string_spec(out, "(%p4?)", spec); + return error_string(out, "(%p4?)"); =20 - if (check_pointer_spec(out, fourcc, spec)) + if (check_pointer(out, fourcc)) return; =20 orig =3D get_unaligned(fourcc); @@ -1721,18 +1719,16 @@ void fourcc_string(struct printbuf *out, const u32 = *fourcc, unsigned char c =3D val >> (i * 8); =20 /* 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 : '.'); } =20 - 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"); =20 - string_spec(out, output_buf, spec); + prt_char(out, ' '); + prt_char(out, '('); + special_hex_number(out, orig, sizeof(u32)); + prt_char(out, ')'); } =20 static noinline_for_stack @@ -2336,7 +2332,8 @@ void pointer(struct printbuf *out, const char *fmt, netdev_bits(out, ptr, fmt); return do_width_precision(out, prev_pos, spec); case '4': - return fourcc_string(out, ptr, spec, fmt); + fourcc_string(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'a': address_val(out, ptr, fmt); return do_width_precision(out, prev_pos, spec); --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 54F0FC19F2A for ; Mon, 8 Aug 2022 02:43:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244051AbiHHCnR (ORCPT ); Sun, 7 Aug 2022 22:43:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32858 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242456AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 556E821B4 for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=W2IBSE6OJvDnrYaJoiE0u8Y6LmGWG6njA3i978Pnn/E=; b=aCyTn0AbGOfCdL2wtfff6oEQ+x s6ZE+C8K84hpVto1NiK3IQGqXdl8nMqGziOVuC75RKlVXD2fo/IcdTpFTQtqqY5SEKhuliQuLhtW7 UwCYa3eGp35ag3TMIuy2zvWtYxAQyn8Yg3dpqEmVuL3GvJAUfH1T9RHhegecPkoOkPM2TvSLWCIDU hZqjPt1uL3F8lGXG8MYOFN+8Kfjckzrj1hC5knbk5l8jqarMOclFN3KY0lHxq3nXu0E74hyQNGBO/ 5OvS+t4CaRDHYlWXUlF5uxZdt/Uc/Qlu1bN/XglH38RkqBxFSCnQzIAS72Y5hxs4Ov+dphfXlOxis VE205cSA==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRt-RN; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 15/32] vsprintf: Refactor ip_addr_string() Date: Mon, 8 Aug 2022 03:41:11 +0100 Message-Id: <20220808024128.3219082-16-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet - 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 114 ++++++++++++++++--------------------------------- 1 file changed, 37 insertions(+), 77 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index f47f10659737..076e2d23be47 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1276,13 +1276,13 @@ void mac_address_string(struct printbuf *out, u8 *a= ddr, } =20 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 =3D (fmt[0] =3D=3D 'i'); - int index; - int step; + struct printf_spec spec =3D default_dec_spec; + int i, index, step; + + if (fmt[0] =3D=3D 'i') + spec.precision =3D 3; =20 switch (fmt[2]) { case 'h': @@ -1306,19 +1306,9 @@ void ip4_string(struct printbuf *out, break; } for (i =3D 0; i < 4; i++) { - char temp[4] __aligned(2); /* hold each IP quad in reverse order */ - int digits =3D 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 +=3D step; } } @@ -1401,8 +1391,6 @@ void ip6_compressed_string(struct printbuf *out, cons= t char *addr) __prt_char(out, ':'); ip4_string(out, &in6.s6_addr[12], "I4"); } - - printbuf_nul_terminate(out); } =20 static noinline_for_stack @@ -1420,41 +1408,20 @@ void ip6_string(struct printbuf *out, const char *a= ddr, const char *fmt) =20 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 =3D PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_add= r_buf)); - if (fmt[0] =3D=3D 'I' && fmt[2] =3D=3D '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 =3D PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_add= r_buf)); - - ip4_string(&ip4_addr, addr, fmt); - - string_nocheck(out, ip4_addr_buf, spec); + ip6_string(out, addr, fmt); } =20 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 =3D false, have_s =3D false, have_f =3D false, have_c =3D fal= se; - 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 =3D PRINTBUF_EXTERN(ip6_addr_buf, sizeof(ip6_add= r_buf)); const u8 *addr =3D (const u8 *) &sa->sin6_addr; char fmt6[2] =3D { fmt[0], '6' }; =20 @@ -1477,41 +1444,35 @@ void ip6_addr_string_sa(struct printbuf *out, } =20 if (have_p || have_s || have_f) - prt_char(&ip6_addr, '['); + prt_char(out, '['); =20 if (fmt6[0] =3D=3D '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); =20 if (have_p || have_s || have_f) - prt_char(&ip6_addr, ']'); + prt_char(out, ']'); =20 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); } =20 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 =3D false; - char ip4_addr_buf[sizeof("255.255.255.255") + sizeof(":12345")]; - struct printbuf ip4_addr =3D PRINTBUF_EXTERN(ip4_addr_buf, sizeof(ip4_add= r_buf)); const u8 *addr =3D (const u8 *) &sa->sin_addr.s_addr; char fmt4[3] =3D { fmt[0], '4', 0 }; =20 @@ -1530,29 +1491,27 @@ void ip4_addr_string_sa(struct printbuf *out, } } =20 - 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); } =20 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; =20 - if (check_pointer_spec(out, ptr, spec)) + if (check_pointer(out, ptr)) return; =20 switch (fmt[1]) { case '6': - return ip6_addr_string(out, ptr, spec, fmt); + return ip6_addr_string(out, ptr, fmt); case '4': - return ip4_addr_string(out, ptr, spec, fmt); + return ip4_string(out, ptr, fmt); case 'S': { const union { struct sockaddr raw; @@ -1562,16 +1521,16 @@ void ip_addr_string(struct printbuf *out, const voi= d *ptr, =20 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)"); }} } =20 err_fmt_msg =3D fmt[0] =3D=3D 'i' ? "(%pi?)" : "(%pI?)"; - return error_string_spec(out, err_fmt_msg, spec); + error_string(out, err_fmt_msg); } =20 static noinline_for_stack @@ -2318,7 +2277,8 @@ void pointer(struct printbuf *out, const char *fmt, * 4: 001.002.003.004 * 6: 000102...0f */ - return ip_addr_string(out, ptr, spec, fmt); + ip_addr_string(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'E': return escaped_string(out, ptr, spec, fmt); case 'U': --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2F5DBC19F2A for ; Mon, 8 Aug 2022 02:43:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244078AbiHHCno (ORCPT ); Sun, 7 Aug 2022 22:43:44 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32800 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242501AbiHHClm (ORCPT ); Sun, 7 Aug 2022 22:41:42 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A3C4F21A0 for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=UmntpirdSpPRuDoceI03X6/H8+qGMeNpl5xMH8+vOYo=; b=nTWvwNKF5as3dgMXOWCJrpx3Fi LPq5lpmrm8Yn724a1WBVo92EyBBZ/ME8vpJ3A3GsA5BDXM76k2T73dUBd+sXvq5V066XUn0fnBbB+ 7vWo10sN9nBWKMCr2UdWp5GT9ElOBk/xNkcC+62Nrd4sydCGYYlMzHNHDees/RcPMYldiMkeCJfmw KeBjNeBlPfeCYMuP7e5/hiIOp4sh6gJNXNXoHm+5h0M54wyfEoiI1CEIxMK9nJHMqeyNeKOpiIUiy T9n5FaEEtJQb6W86rjJHGrL1VJIZpXS0YJvbYxoMJkXd8fyOQl/kGH1nZkJUTvqD0KDGQylNqLzGl W0SpSVRA==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshx-00DVRv-UI; Mon, 08 Aug 2022 02:41:33 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 16/32] vsprintf: Refactor mac_address_string() Date: Mon, 8 Aug 2022 03:41:12 +0100 Message-Id: <20220808024128.3219082-17-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet - 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 076e2d23be47..2042c17f571e 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1236,15 +1236,13 @@ void bitmap_list_string(struct printbuf *out, unsig= ned long *bitmap, =20 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 =3D mac_addr; int i; char separator; bool reversed =3D false; =20 - if (check_pointer_spec(out, addr, spec)) + if (check_pointer(out, addr)) return; =20 switch (fmt[1]) { @@ -1263,16 +1261,13 @@ void mac_address_string(struct printbuf *out, u8 *a= ddr, =20 for (i =3D 0; i < 6; i++) { if (reversed) - p =3D hex_byte_pack(p, addr[5 - i]); + prt_hex_byte(out, addr[5 - i]); else - p =3D hex_byte_pack(p, addr[i]); + prt_hex_byte(out, addr[i]); =20 if (fmt[0] =3D=3D 'M' && i !=3D 5) - *p++ =3D separator; + prt_char(out, separator); } - *p =3D '\0'; - - string_nocheck(out, mac_addr, spec); } =20 static noinline_for_stack @@ -2267,7 +2262,8 @@ void pointer(struct printbuf *out, const char *fmt, case 'm': /* Contiguous: 000102030405 */ /* [mM]F (FDDI) */ /* [mM]R (Reverse order; Bluetooth) */ - return mac_address_string(out, ptr, spec, fmt); + mac_address_string(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'I': /* Formatted IP supported * 4: 1.2.3.4 * 6: 0001:0203:...:0708 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2B93CC19F2A for ; Mon, 8 Aug 2022 02:43:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244058AbiHHCnU (ORCPT ); Sun, 7 Aug 2022 22:43:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60986 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242539AbiHHClm (ORCPT ); Sun, 7 Aug 2022 22:41:42 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C177C25ED for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=XMPtB3chMhlXpXIghsTgAd24SoNYbzppATzU+ECsSLw=; b=oCAkoSLbXX9r3HlgG8il8G41x5 Ed2SKexRgOfHJPUy4mgqJXrHIj5sYv+OX3S0rxJNEn1/GG9MGIJvcg4VbW3TnVgDEsaSSmDu0woHd 9iTPTf5oSqEqMr4B3KU3+SxJjQXLeHJOnPjXxQjMw1lYzugr5jjmRJdahHqyzb2pbI1UlOqawOgUL B9v8DhOPf9AzLS4Yau1UQ8wo+HZPn8vowSQBtvcBpuXHJK97yI7Z68io7xQtYhrYavqBYOiU/gAQH kTKN4iktY/YbqljHCix/r4Y3L7GdOWxhc0p6swUFODfnE2a7XIPIPxRJXHlvmJOMU8L8+yP0OWCfs k8URUZoQ==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVRx-0m; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 17/32] vsprintf: time_and_date() no longer takes printf_spec Date: Mon, 8 Aug 2022 03:41:13 +0100 Message-Id: <20220808024128.3219082-18-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 2042c17f571e..784f7cb64926 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1736,14 +1736,14 @@ void time_str(struct printbuf *out, const struct rt= c_time *tm, bool r) =20 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 =3D true, have_d =3D true; bool raw =3D false, iso8601_separator =3D true; bool found =3D true; int count =3D 2; =20 - if (check_pointer_spec(out, tm, spec)) + if (check_pointer(out, tm)) return; =20 switch (fmt[count]) { @@ -1781,7 +1781,7 @@ void rtc_str(struct printbuf *out, const struct rtc_t= ime *tm, =20 static noinline_for_stack void time64_str(struct printbuf *out, const time64_t time, - struct printf_spec spec, const char *fmt) + const char *fmt) { struct rtc_time rtc_time; struct tm tm; @@ -1799,21 +1799,20 @@ void time64_str(struct printbuf *out, const time64_= t time, =20 rtc_time.tm_isdst =3D 0; =20 - rtc_str(out, &rtc_time, spec, fmt); + rtc_str(out, &rtc_time, fmt); } =20 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?)"); } } =20 @@ -2297,7 +2296,8 @@ void pointer(struct printbuf *out, const char *fmt, dentry_name(out, ptr, fmt); return do_width_precision(out, prev_pos, spec); case 't': - return time_and_date(out, ptr, spec, fmt); + time_and_date(out, ptr, fmt); + return do_width_precision(out, prev_pos, spec); case 'C': return clock(out, ptr, spec, fmt); case 'D': --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8638CC19F2A for ; Mon, 8 Aug 2022 02:43:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244130AbiHHCn1 (ORCPT ); Sun, 7 Aug 2022 22:43:27 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32832 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242554AbiHHClm (ORCPT ); Sun, 7 Aug 2022 22:41:42 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C16EB25C7 for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=3nTy8qXUtiWwK0lkpgZkPPlVZYKOkb4CQCRiIBiqF8c=; b=VpQZmaPYMFsBUjC6WvDtekZH8C YSsZlzM2D3V9e5i+s/PW6VUHKYAy5S5ZYmgoaq58YZ/AqAUWR9+HWO0vrNCM5kVN+QTO5/4+6+KEY njEi1j9hXxBLU+joDPx7kB/pA+AnacjOw2jj8fi8GCb0GUiBpNtupvXXhZ0Y+2h81iS9p6KnMGIsl XBEN8qhvnDmh6TwB032v14BUyWiQLA0wbRiL0pVewLKkcgAZfbcxM4rKBeezyao1m01tyvV70DN7l W848IvKJ0rqI5j1AUExjUKhSkEcQGfpXXKdj/uL34ppYhmepBoHHpC+Q/hoI0Ux61r4/yQZj/MEh8 R/y1HUKw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVRz-2u; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 18/32] vsprintf: flags_string() no longer takes printf_spec Date: Mon, 8 Aug 2022 03:41:14 +0100 Message-Id: <20220808024128.3219082-19-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 784f7cb64926..38d16aa79e56 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1917,12 +1917,12 @@ void format_page_flags(struct printbuf *out, unsign= ed long flags) =20 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; =20 - if (check_pointer_spec(out, flags_ptr, spec)) + if (check_pointer(out, flags_ptr)) return; =20 switch (fmt[1]) { @@ -1937,7 +1937,7 @@ void flags_string(struct printbuf *out, void *flags_p= tr, names =3D gfpflag_names; break; default: - return error_string_spec(out, "(%pG?)", spec); + return error_string(out, "(%pG?)"); } =20 return format_flags(out, flags, names); @@ -2310,7 +2310,8 @@ void pointer(struct printbuf *out, const char *fmt, #endif =20 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': --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5D49BC19F2A for ; Mon, 8 Aug 2022 02:43:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244120AbiHHCnO (ORCPT ); Sun, 7 Aug 2022 22:43:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32802 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242536AbiHHClm (ORCPT ); Sun, 7 Aug 2022 22:41:42 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C166521BA for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=gLSmP0ezGtWML91IudXrNJu8Zj7NmJrDaiBCbrXz+LY=; b=MTuHy9VnQfrt2AB+/dowXbi0Xl p/HsStgU1cVih1U6rA3n+lDtpLxkQnEfX/PJ9DCqQLl9dmaOeL+IMDfMclxATrkBqZTJk/yVL/+ym Dvi5FrLyOGSBglGfyE/fmAK0psd/SAOf5CAfd3w9Z/A5ArMZft9EED/FgJU4F4LRVUfRe1SK5244n UUvRaRG11eBhZWsSXwpHo+I6f5EiRjAR6j1EeEqIwctpKDo3WCeDhq3bvz33d4T13V9/H775it6jV grcDXX65Gl6/qi6bkwITzFZo3MNtqHnXmRWWQyCYi+agf/UoME3pil5+McLv7ZUCHL3s2YoiV0fUN XtBiz4Lw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVS2-56; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 19/32] vsprintf: Refactor device_node_string, fwnode_string Date: Mon, 8 Aug 2022 03:41:15 +0100 Message-Id: <20220808024128.3219082-20-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet - 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 73 ++++++++++++++++++++------------------------------ 1 file changed, 29 insertions(+), 44 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 38d16aa79e56..06cfa06aa4ee 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1963,25 +1963,20 @@ void fwnode_full_name_string(struct printbuf *out, =20 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 =3D out->pos; struct property *prop; bool has_mult, pass; =20 - struct printf_spec str_spec =3D spec; - str_spec.field_width =3D -1; - if (fmt[0] !=3D 'F') - return error_string_spec(out, "(%pO?)", spec); + return error_string(out, "(%pO?)"); =20 if (!IS_ENABLED(CONFIG_OF)) - return error_string_spec(out, "(%pOF?)", spec); + return error_string(out, "(%pOF?)"); =20 - if (check_pointer_spec(out, dn, spec)) + if (check_pointer(out, dn)) return; =20 /* simple case without anything any more format specifiers */ @@ -1990,7 +1985,6 @@ void device_node_string(struct printbuf *out, struct = device_node *dn, fmt =3D "f"; =20 for (pass =3D false; strspn(fmt,"fnpPFcC"); fmt++, pass =3D true) { - int precision; if (pass) prt_char(out, ':'); =20 @@ -1998,43 +1992,41 @@ void device_node_string(struct printbuf *out, struc= t device_node *dn, case 'f': /* full_name */ fwnode_full_name_string(out, of_fwnode_handle(dn)); break; - case 'n': /* name */ - p =3D fwnode_get_name(of_fwnode_handle(dn)); - precision =3D str_spec.precision; - str_spec.precision =3D strchrnul(p, '@') - p; - string_spec(out, p, str_spec); - str_spec.precision =3D precision; + case 'n': { /* name */ + const char *name =3D fwnode_get_name(of_fwnode_handle(dn)); + unsigned len =3D 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 =3D fwnode_get_name(of_fwnode_handle(dn)); if (!p[1]) p =3D "/"; - string_spec(out, p, str_spec); + string(out, p); break; case 'F': /* flags */ - tbuf[0] =3D of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; - tbuf[1] =3D of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-'; - tbuf[2] =3D of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-'; - tbuf[3] =3D of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-'; - tbuf[4] =3D 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 =3D 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 =3D 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, '\"'); =20 has_mult =3D true; } @@ -2043,39 +2035,30 @@ void device_node_string(struct printbuf *out, struc= t device_node *dn, break; } } - - widen_string(out, out->pos - start, spec); } =20 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 =3D spec; - unsigned start =3D out->pos; - - str_spec.field_width =3D -1; - if (*fmt !=3D 'w') - return error_string_spec(out, "(%pf?)", spec); + return error_string(out, "(%pf?)"); =20 - if (check_pointer_spec(out, fwnode, spec)) + if (check_pointer(out, fwnode)) return; =20 fmt++; =20 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); } =20 int __init no_hash_pointers_enable(char *str) @@ -2313,9 +2296,11 @@ void pointer(struct printbuf *out, const char *fmt, flags_string(out, ptr, fmt); return do_width_precision(out, prev_pos, spec); case 'O': - return device_node_string(out, ptr, spec, fmt + 1); + device_node_string(out, ptr, fmt + 1); + return do_width_precision(out, prev_pos, spec); case 'f': - return fwnode_string(out, ptr, spec, fmt + 1); + fwnode_string(out, ptr, fmt + 1); + return do_width_precision(out, prev_pos, spec); case 'x': return pointer_string(out, ptr, spec); case 'e': --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CF944C19F2A for ; Mon, 8 Aug 2022 02:43:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244137AbiHHCnb (ORCPT ); Sun, 7 Aug 2022 22:43:31 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242602AbiHHClm (ORCPT ); Sun, 7 Aug 2022 22:41:42 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C18E425F0 for ; Sun, 7 Aug 2022 19:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=UMLp/z/zO9tVZ6IGymm87CLlbDOH1CSK9TxXY2OyJZw=; b=TV+mgKMyauh+4PXLlijjPCxJht 1olmilKT9KP1bAhpAgOESD5U+piHKmUsW9sv2+1YVm/vEmDIOPnO9TtpdgW83zVbFFEwDLAJxhrDx r9NNAI/mkBYzZB48VkTUtbiiIhkzVNPjj7muCJ/vLu0oFfcn1wKcyA0yhZsZDHGbSHnHjGSc2W2UO L9NbIbIiztxhQKBLKBomDBNb9S0n4N7omOOAtiTNh0y5sUKNZAqJPUNw1t6uNY/S5T/aPVf1SEe1t 58LI5yfvwU9aoV0DB1CWBUOpLgFHdrTykavF/D7+1MwmCLMyjzSJtK0nOQys0lowPHo0gbgCzJa9c 2vVLYrbA==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVS4-7m; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Rasmus Villemoes Subject: [PATCH v5 20/32] vsprintf: Refactor hex_string, bitmap_string_list, bitmap_string Date: Mon, 8 Aug 2022 03:41:16 +0100 Message-Id: <20220808024128.3219082-21-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Petr Mladek Cc: Rasmus Villemoes --- lib/vsprintf.c | 60 +++++++++++++++++++++++--------------------------- 1 file changed, 28 insertions(+), 32 deletions(-) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 06cfa06aa4ee..0ff7d9fea6da 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -53,6 +53,7 @@ #include =20 #include +#include #include "kstrtox.h" =20 /* Disable pointer hashing if requested */ @@ -1126,18 +1127,23 @@ void resource_string(struct printbuf *out, struct r= esource *res, } =20 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 =3D 1; /* if we pass '%ph[CDN]', field width remains - negative value, fallback to the default */ char separator; =20 - if (spec.field_width =3D=3D 0) - /* nothing to print */ + /* nothing to print */ + if (len =3D=3D 0) return; =20 - 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 =3D 1; + + len =3D min(len, 64); + + if (check_pointer(out, addr)) return; =20 switch (fmt[1]) { @@ -1155,34 +1161,21 @@ void hex_string(struct printbuf *out, u8 *addr, break; } =20 - if (spec.field_width > 0) - len =3D min_t(int, spec.field_width, 64); - - for (i =3D 0; i < len; ++i) { - __prt_char(out, hex_asc_hi(addr[i])); - __prt_char(out, hex_asc_lo(addr[i])); - - if (separator && i !=3D len - 1) - __prt_char(out, separator); - } - - printbuf_nul_terminate(out); + prt_hex_bytes(out, addr, len, 1, separator); } =20 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_bit= s) { + struct printf_spec spec =3D { .flags =3D SMALL | ZEROPAD, .base =3D 16 }; const int CHUNKSZ =3D 32; - int nr_bits =3D max_t(int, spec.field_width, 0); int i, chunksz; bool first =3D true; =20 - if (check_pointer_spec(out, bitmap, spec)) - return; + nr_bits =3D max(nr_bits, 0); =20 - /* reused to print numbers */ - spec =3D (struct printf_spec){ .flags =3D SMALL | ZEROPAD, .base =3D 16 }; + if (check_pointer(out, bitmap)) + return; =20 chunksz =3D nr_bits & (CHUNKSZ - 1); if (chunksz =3D=3D 0) @@ -1211,13 +1204,14 @@ void bitmap_string(struct printbuf *out, unsigned l= ong *bitmap, =20 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 =3D max_t(int, spec.field_width, 0); bool first =3D true; int rbot, rtop; =20 - if (check_pointer_spec(out, bitmap, spec)) + nr_bits =3D max(nr_bits, 0); + + if (check_pointer(out, bitmap)) return ; =20 for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) { @@ -2232,13 +2226,15 @@ void pointer(struct printbuf *out, const char *fmt, resource_string(out, ptr, fmt[0] =3D=3D '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 */ --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CF9F4C19F2A for ; Mon, 8 Aug 2022 02:42:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242987AbiHHCm1 (ORCPT ); Sun, 7 Aug 2022 22:42:27 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32768 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241978AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 24C4821B9 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=lfQTXZiY1X35koMGsi465Yl9F2fwXfjrVq4gI2j3bhc=; b=mBXOn5/7/Ubjyu4VKJpvGkaoV/ uX179iuL1fclHsc+EFKeSlPqJ2ay/ncaHC08hxoBl/nEou6mAsT5+7pg5joTfv6kgNFQnHvZO5OV8 VVUJUrndxAfgMASgNOBK98cwxalRqWZeUeaPbl6C8VpuSZMnJBtqZuixTgRGqiLbbCcF2HJVARzmk m871dvFmhZ0zByM/ZNaCDN9aPVtPqWq/qS1GIMfy0bBuZ7e9pMU4wGFbrW0cP8596hOqlSnfV9Thl 7Q42W3dOY/46Hrrd8p8F3cJqcBmjuoCcRmAcSvmbpReOMKSCseS3klf6NZ8apH0BIxkyVpbVGPgfN d1ZDoavA==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVS6-9v; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Dmitry Torokhov Subject: [PATCH v5 21/32] Input/joystick/analog: Convert from seq_buf -> printbuf Date: Mon, 8 Aug 2022 03:41:17 +0100 Message-Id: <20220808024128.3219082-22-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet seq_buf is being deprecated, this converts to printbuf. Signed-off-by: Kent Overstreet Cc: Dmitry Torokhov Acked-by: Dmitry Torokhov --- 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/analo= g.c index 3088c5b829f0..a8c5f90e8208 100644 --- a/drivers/input/joystick/analog.c +++ b/drivers/input/joystick/analog.c @@ -19,7 +19,7 @@ #include #include #include -#include +#include #include #include =20 @@ -339,24 +339,21 @@ static void analog_calibrate_timer(struct analog_port= *port) =20 static void analog_name(struct analog *analog) { - struct seq_buf s; + struct printbuf buf =3D PRINTBUF_EXTERN(analog->name, sizeof(analog->name= )); =20 - 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_BTN= S_CHF) * 2 + - hweight16(analog->mask & ANALOG_BTNS_GAMEPAD) + !!(analog->mask & ANALO= G_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 & ANALO= G_BTNS_CHF) * 2 + + hweight16(analog->mask & ANALOG_BTNS_GAMEPAD) + !!(analog->mask & = ANALOG_HBTN_CHF) * 4); =20 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"); =20 - seq_buf_printf(&s, (analog->mask & ANALOG_GAMEPAD) ? " gamepad" : " joyst= ick"); + prt_printf(&buf, (analog->mask & ANALOG_GAMEPAD) ? " gamepad" : " joystic= k"); } =20 /* --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 66BA9C19F2A for ; Mon, 8 Aug 2022 02:42:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244065AbiHHCmo (ORCPT ); Sun, 7 Aug 2022 22:42:44 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32822 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242235AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0B7E125D8 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=sneZ41lYORveEGJd86wLRINVdrJyNjdlMYzBcdpxZVM=; b=gHsZmUmooiEPQn2wHoC+85cXvp uUArEgvwkwTMO/rXNRp0gPoodsCYZIIJnFcz75pPW3q8m5am8CL0NhvgxKYYAWrSAUeC73Z/lPkPs h4I44dOOHdLqJhxSlBifUdptWyIeU2ZxgB6iQ2w6KaPpsCDck6HhMij6kmyazjOnSEUnr6L1jLqJ9 IQSY+w7Z78SL/f6kcz8Ncq7NPw6uus03Nhyd2oLnPCkQSrsFXKNAC18OUfix8lDia35iIoLoqh1t/ JQiFlo2Gw4YnT2v+AqHVv7w/+hdDHKX68rLMTNh95mc/ottWiYhO/BKQnzFBRUz3aJd0fiK6fsWFS QQ+9YZWw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSQ-CB; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Johannes Weiner , Michal Hocko , Roman Gushchin Subject: [PATCH v5 22/32] mm/memcontrol.c: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:18 +0100 Message-Id: <20220808024128.3219082-23-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Johannes Weiner Cc: Michal Hocko Cc: Roman Gushchin Acked-by: Michal Hocko --- mm/memcontrol.c | 54 ++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/mm/memcontrol.c b/mm/memcontrol.c index b69979c9ced5..54897e4ac4ef 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -62,7 +62,7 @@ #include #include #include -#include +#include #include "internal.h" #include #include @@ -1490,13 +1490,10 @@ static const unsigned int memcg_vm_event_stat[] =3D= { #endif }; =20 -static void memory_stat_format(struct mem_cgroup *memcg, char *buf, int bu= fsize) +static void memory_stat_format(struct printbuf *out, struct mem_cgroup *me= mcg) { - struct seq_buf s; int i; =20 - seq_buf_init(&s, buf, bufsize); - /* * Provide statistics on the state of the memory subsystem as * well as cumulative event counters that show past behavior. @@ -1513,30 +1510,30 @@ static void memory_stat_format(struct mem_cgroup *m= emcg, char *buf, int bufsize) u64 size; =20 size =3D memcg_page_state_output(memcg, memory_stats[i].idx); - seq_buf_printf(&s, "%s %llu\n", memory_stats[i].name, size); + prt_printf(out, "%s %llu\n", memory_stats[i].name, size); =20 if (unlikely(memory_stats[i].idx =3D=3D NR_SLAB_UNRECLAIMABLE_B)) { size +=3D memcg_page_state_output(memcg, NR_SLAB_RECLAIMABLE_B); - seq_buf_printf(&s, "slab %llu\n", size); + prt_printf(out, "slab %llu\n", size); } } =20 /* Accumulated memory events */ - 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)); + prt_printf(out, "pgscan %lu\n", + memcg_events(memcg, PGSCAN_KSWAPD) + + memcg_events(memcg, PGSCAN_DIRECT)); + prt_printf(out, "pgsteal %lu\n", + memcg_events(memcg, PGSTEAL_KSWAPD) + + memcg_events(memcg, PGSTEAL_DIRECT)); =20 for (i =3D 0; i < ARRAY_SIZE(memcg_vm_event_stat); i++) - seq_buf_printf(&s, "%s %lu\n", - vm_event_name(memcg_vm_event_stat[i]), - memcg_events(memcg, memcg_vm_event_stat[i])); + prt_printf(out, "%s %lu\n", + vm_event_name(memcg_vm_event_stat[i]), + memcg_events(memcg, memcg_vm_event_stat[i])); =20 /* The above should easily fit into one page */ - WARN_ON_ONCE(seq_buf_has_overflowed(&s)); + WARN_ON_ONCE(!printbuf_remaining(out)); } =20 #define K(x) ((x) << (PAGE_SHIFT-10)) @@ -1573,7 +1570,8 @@ void mem_cgroup_print_oom_context(struct mem_cgroup *= memcg, struct task_struct * void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg) { /* Use static buffer, for the caller is holding oom_lock. */ - static char buf[PAGE_SIZE]; + static char _buf[PAGE_SIZE]; + struct printbuf buf =3D PRINTBUF_EXTERN(_buf, sizeof(_buf)); =20 lockdep_assert_held(&oom_lock); =20 @@ -1596,8 +1594,8 @@ void mem_cgroup_print_oom_meminfo(struct mem_cgroup *= memcg) pr_info("Memory cgroup stats for "); pr_cont_cgroup_path(memcg->css.cgroup); pr_cont(":"); - memory_stat_format(memcg, buf, sizeof(buf)); - pr_info("%s", buf); + memory_stat_format(&buf, memcg); + pr_info("%s", buf.buf); } =20 /* @@ -6401,14 +6399,16 @@ static int memory_events_local_show(struct seq_file= *m, void *v) static int memory_stat_show(struct seq_file *m, void *v) { struct mem_cgroup *memcg =3D mem_cgroup_from_seq(m); - char *buf =3D kmalloc(PAGE_SIZE, GFP_KERNEL); + struct printbuf buf =3D PRINTBUF; + int ret; =20 - if (!buf) - return -ENOMEM; - memory_stat_format(memcg, buf, PAGE_SIZE); - seq_puts(m, buf); - kfree(buf); - return 0; + memory_stat_format(&buf, memcg); + ret =3D buf.allocation_failure ? -ENOMEM : 0; + if (!ret) + seq_puts(m, buf.buf); + + printbuf_exit(&buf); + return ret; } =20 #ifdef CONFIG_NUMA --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9E134C19F2A for ; Mon, 8 Aug 2022 02:43:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244044AbiHHCnz (ORCPT ); Sun, 7 Aug 2022 22:43:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32770 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242120AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 94FBE25C4; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=fiLWB7FlMZG/t3/6at/lVnmuLuXlP9ApBxUL44LLPGI=; b=cV+xsr2dJdusY7y0TkSTgMXeQ0 hiXR1lQDTb0NZ1r+yPBc/SHwfmocssIf1OWmy7KfHT0zQhxNolb+CBN8mJ+rzcAqxTB7d0jZGxCc2 yeAO0NPrLksriSMv1Tjv55L/P1iTRnYT5eiymmpzFFtIySvuDh8xaUuVSOvQEysBDxEG4gsGiX8JT jg74xcTcIF/+GQvexqGnUqjhudrIrBlSuElsRc7yjmn8k1PmBb+p1vf0Hd5N+gDURFOfDjVagZeYF hZRpk2vdiPL6Ynyd65sLsSPz/ef0ZmpeorlTJZGkIhOw6f+X7tXAd41fClIw1bUShUYqzghpwigEL Z25ohh/A==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSX-Gm; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: linux-tegra@vger.kernel.org Subject: [PATCH v5 23/32] clk: tegra: bpmp: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:19 +0100 Message-Id: <20220808024128.3219082-24-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: linux-tegra@vger.kernel.org --- 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 3748a39dae7c..7e3b48ed9d45 100644 --- a/drivers/clk/tegra/clk-bpmp.c +++ b/drivers/clk/tegra/clk-bpmp.c @@ -5,7 +5,7 @@ =20 #include #include -#include +#include #include =20 #include @@ -365,39 +365,38 @@ static void tegra_bpmp_clk_info_dump(struct tegra_bpm= p *bpmp, const struct tegra_bpmp_clk_info *info) { const char *prefix =3D ""; - struct seq_buf buf; + struct printbuf buf =3D PRINTBUF; unsigned int i; - char flags[64]; - - seq_buf_init(&buf, flags, sizeof(flags)); =20 if (info->flags) - seq_buf_printf(&buf, "("); + prt_printf(&buf, "("); =20 if (info->flags & TEGRA_BPMP_CLK_HAS_MUX) { - seq_buf_printf(&buf, "%smux", prefix); + prt_printf(&buf, "%smux", prefix); prefix =3D ", "; } =20 if ((info->flags & TEGRA_BPMP_CLK_HAS_SET_RATE) =3D=3D 0) { - seq_buf_printf(&buf, "%sfixed", prefix); + prt_printf(&buf, "%sfixed", prefix); prefix =3D ", "; } =20 if (info->flags & TEGRA_BPMP_CLK_IS_ROOT) { - seq_buf_printf(&buf, "%sroot", prefix); + prt_printf(&buf, "%sroot", prefix); prefix =3D ", "; } =20 if (info->flags) - seq_buf_printf(&buf, ")"); + prt_printf(&buf, ")"); =20 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_s= tr(&buf)); dev_printk(level, bpmp->dev, " parents: %u\n", info->num_parents); =20 for (i =3D 0; i < info->num_parents; i++) dev_printk(level, bpmp->dev, " %03u\n", info->parents[i]); + + printbuf_exit(&buf); } =20 static int tegra_bpmp_probe_clocks(struct tegra_bpmp *bpmp, --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C29B2C19F2A for ; Mon, 8 Aug 2022 02:44:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244166AbiHHCoG (ORCPT ); Sun, 7 Aug 2022 22:44:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60986 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242209AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 216CC25E4 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=JSiABMMZnULesSHXbODZXbNdNrS+sWlJ8WR8yu48vGY=; b=R+fJeXfM+C7UzxYJOIbPtnhJZN ZFVd2X7tbiIrV3eQ+rjj9m0N85640VYmeYs0YCyQT8oTrXtm5P7wkAQ+W8xxRQUAfmbU9FccnA1lE +pf9VZUG0TAk9uZysyl2+JyAI/2JX50RSZDsMeFoJspbcYgJytqXk7D27TyyA3B+29V6S/QCmHUQX /5lVcoZ2gVykipqHm3UWr7u/5l7YqVcU1HNZC8zlsYKcb4c4xhh+mVj2zqzE3FkN2Bj4qSWbMNXf6 cTLiGoAeF6E3+KTxB1NLTNpmw48EMBhf+q5XVGeuYbRGaJBXGEfqiMPch1+k89PhMvVMrv8AqZW8K KsTEv3Tw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSZ-Iz; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Dan Williams , Dave Hansen , nvdimm@lists.linux.dev Subject: [PATCH v5 24/32] tools/testing/nvdimm: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:20 +0100 Message-Id: <20220808024128.3219082-25-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Dan Williams Cc: Dave Hansen 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 4d1a947367f9..a2097955dace 100644 --- a/tools/testing/nvdimm/test/ndtest.c +++ b/tools/testing/nvdimm/test/ndtest.c @@ -12,7 +12,7 @@ #include #include #include -#include +#include =20 #include "../watermark.h" #include "nfit_test.h" @@ -740,32 +740,30 @@ static ssize_t flags_show(struct device *dev, { struct nvdimm *nvdimm =3D to_nvdimm(dev); struct ndtest_dimm *dimm =3D nvdimm_provider_data(nvdimm); - struct seq_buf s; + struct printbuf s =3D PRINTBUF_EXTERN(buf, PAGE_SIZE); u64 flags; =20 flags =3D dimm->flags; =20 - seq_buf_init(&s, buf, PAGE_SIZE); if (flags & PAPR_PMEM_UNARMED_MASK) - seq_buf_printf(&s, "not_armed "); + prt_printf(&s, "not_armed "); =20 if (flags & PAPR_PMEM_BAD_SHUTDOWN_MASK) - seq_buf_printf(&s, "flush_fail "); + prt_printf(&s, "flush_fail "); =20 if (flags & PAPR_PMEM_BAD_RESTORE_MASK) - seq_buf_printf(&s, "restore_fail "); + prt_printf(&s, "restore_fail "); =20 if (flags & PAPR_PMEM_SAVE_MASK) - seq_buf_printf(&s, "save_fail "); + prt_printf(&s, "save_fail "); =20 if (flags & PAPR_PMEM_SMART_EVENT_MASK) - seq_buf_printf(&s, "smart_notify "); + prt_printf(&s, "smart_notify "); =20 + if (printbuf_written(&s)) + prt_printf(&s, "\n"); =20 - if (seq_buf_used(&s)) - seq_buf_printf(&s, "\n"); - - return seq_buf_used(&s); + return printbuf_written(&s); } static DEVICE_ATTR_RO(flags); =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4EAE3C19F2A for ; Mon, 8 Aug 2022 02:43:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244095AbiHHCnC (ORCPT ); Sun, 7 Aug 2022 22:43:02 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32820 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242212AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0422D25D7 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=Fm2ENERu942wdlKdXWdAvKqUsF1f7AoQiPFqKkHP5RY=; b=vhGp/28L7DmmiQH3DU9HTzlGN8 amyA6brqU+0ebuC4jkX2oK21cGjHBxJSEdtkmZJeWIqMXBTY7A2KK2yQjCe86ZXvXyWda9vcTEYmx kPz6m5dWSLV7trRqrsmnu1A3aqhVkkD7dsntNbJRyn5CPZuRFe5GQUPX4fld/c5wTXpbg3K6Wzf5K dQoUBa1Ln+1pxFbHG7EoxCIYfPZ2RJZo67SKgTu8gnTuG7aP8ViMspPFOlGYhK8C9TWBdZziP+y5R 2JRg1oFQaG+2rQjhsI5lVhy1pwdhOnce3SG2EFtESFKV24zboSir9F57zaMew8fbqF4Q36t8wVlao 6xbB51hw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSd-LB; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: linuxppc-dev@lists.ozlabs.org Subject: [PATCH v5 25/32] powerpc: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:21 +0100 Message-Id: <20220808024128.3219082-26-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 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 0fbda89cd1bb..05654dbeb2c4 100644 --- a/arch/powerpc/kernel/process.c +++ b/arch/powerpc/kernel/process.c @@ -37,7 +37,7 @@ #include #include #include -#include +#include =20 #include #include @@ -1396,32 +1396,30 @@ void show_user_instructions(struct pt_regs *regs) { unsigned long pc; int n =3D NR_INSN_TO_PRINT; - struct seq_buf s; char buf[96]; /* enough for 8 times 9 + 2 chars */ + struct printbuf s =3D PRINTBUF_EXTERN(buf, sizeof(buf)); =20 pc =3D regs->nip - (NR_INSN_TO_PRINT * 3 / 4 * sizeof(int)); =20 - seq_buf_init(&s, buf, sizeof(buf)); - while (n) { int i; =20 - seq_buf_clear(&s); + printbuf_reset(&s); =20 for (i =3D 0; i < 8 && n; i++, n--, pc +=3D sizeof(int)) { int instr; =20 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 =3D=3D pc ? "<%08x> " : "%08x ", instr); + prt_printf(&s, regs->nip =3D=3D pc ? "<%08x> " : "%08x ", instr); } =20 - 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); } } =20 diff --git a/arch/powerpc/kernel/security.c b/arch/powerpc/kernel/security.c index d96fd14bd7c9..b34de62e65ce 100644 --- a/arch/powerpc/kernel/security.c +++ b/arch/powerpc/kernel/security.c @@ -10,7 +10,7 @@ #include #include #include -#include +#include #include =20 #include @@ -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 *att= r, char *buf) { + struct printbuf s =3D PRINTBUF_EXTERN(buf, PAGE_SIZE); bool thread_priv; =20 thread_priv =3D security_ftr_enabled(SEC_FTR_L1D_THREAD_PRIV); =20 if (rfi_flush) { - struct seq_buf s; - seq_buf_init(&s, buf, PAGE_SIZE - 1); =20 - 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"); } =20 - 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); } =20 ssize_t cpu_show_l1tf(struct device *dev, struct device_attribute *attr, c= har *buf) @@ -179,70 +176,66 @@ ssize_t cpu_show_l1tf(struct device *dev, struct devi= ce_attribute *attr, char *b =20 ssize_t cpu_show_spectre_v1(struct device *dev, struct device_attribute *a= ttr, char *buf) { - struct seq_buf s; - - seq_buf_init(&s, buf, PAGE_SIZE - 1); + struct printbuf s =3D PRINTBUF_EXTERN(buf, PAGE_SIZE); =20 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"); =20 if (security_ftr_enabled(SEC_FTR_SPEC_BAR_ORI31)) - seq_buf_printf(&s, ", ori31 speculation barrier enabled"); + prt_printf(&s, ", ori31 speculation barrier enabled"); =20 - seq_buf_printf(&s, "\n"); + prt_printf(&s, "\n"); } else - seq_buf_printf(&s, "Not affected\n"); + prt_printf(&s, "Not affected\n"); =20 - return s.len; + return printbuf_written(&s); } =20 ssize_t cpu_show_spectre_v2(struct device *dev, struct device_attribute *a= ttr, char *buf) { - struct seq_buf s; + struct printbuf s =3D PRINTBUF_EXTERN(buf, PAGE_SIZE); bool bcs, ccd; =20 - seq_buf_init(&s, buf, PAGE_SIZE - 1); - bcs =3D security_ftr_enabled(SEC_FTR_BCCTRL_SERIALISED); ccd =3D security_ftr_enabled(SEC_FTR_COUNT_CACHE_DISABLED); =20 if (bcs || ccd) { - seq_buf_printf(&s, "Mitigation: "); + prt_printf(&s, "Mitigation: "); =20 if (bcs) - seq_buf_printf(&s, "Indirect branch serialisation (kernel only)"); + prt_printf(&s, "Indirect branch serialisation (kernel only)"); =20 if (bcs && ccd) - seq_buf_printf(&s, ", "); + prt_printf(&s, ", "); =20 if (ccd) - seq_buf_printf(&s, "Indirect branch cache disabled"); + prt_printf(&s, "Indirect branch cache disabled"); =20 } else if (count_cache_flush_type !=3D BRANCH_CACHE_FLUSH_NONE) { - seq_buf_printf(&s, "Mitigation: Software count cache flush"); + prt_printf(&s, "Mitigation: Software count cache flush"); =20 if (count_cache_flush_type =3D=3D BRANCH_CACHE_FLUSH_HW) - seq_buf_printf(&s, " (hardware accelerated)"); + prt_printf(&s, " (hardware accelerated)"); =20 } 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"); } =20 if (bcs || ccd || count_cache_flush_type !=3D BRANCH_CACHE_FLUSH_NONE) { if (link_stack_flush_type !=3D BRANCH_CACHE_FLUSH_NONE) - seq_buf_printf(&s, ", Software link stack flush"); + prt_printf(&s, ", Software link stack flush"); if (link_stack_flush_type =3D=3D BRANCH_CACHE_FLUSH_HW) - seq_buf_printf(&s, " (hardware accelerated)"); + prt_printf(&s, " (hardware accelerated)"); } =20 - seq_buf_printf(&s, "\n"); + prt_printf(&s, "\n"); =20 - return s.len; + return printbuf_written(&s); } =20 #ifdef CONFIG_PPC_BOOK3S_64 diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platf= orms/pseries/papr_scm.c index 20f6ed813bff..a1fd25243c48 100644 --- a/arch/powerpc/platforms/pseries/papr_scm.c +++ b/arch/powerpc/platforms/pseries/papr_scm.c @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include =20 #include @@ -1142,7 +1142,7 @@ static ssize_t perf_stats_show(struct device *dev, { int index; ssize_t rc; - struct seq_buf s; + struct printbuf s =3D PRINTBUF_EXTERN(buf, PAGE_SIZE); struct papr_scm_perf_stat *stat; struct papr_scm_perf_stats *stats; struct nvdimm *dimm =3D to_nvdimm(dev); @@ -1165,18 +1165,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 =3D 0, stat =3D stats->scm_statistic; index < be32_to_cpu(stats->num_statistics); ++index, ++stat) { - seq_buf_printf(&s, "%.8s =3D 0x%016llX\n", - stat->stat_id, - be64_to_cpu(stat->stat_val)); + prt_printf(&s, "%.8s =3D 0x%016llX\n", + stat->stat_id, + be64_to_cpu(stat->stat_val)); } =20 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); =20 @@ -1185,7 +1184,7 @@ static ssize_t flags_show(struct device *dev, { struct nvdimm *dimm =3D to_nvdimm(dev); struct papr_scm_priv *p =3D nvdimm_provider_data(dimm); - struct seq_buf s; + struct printbuf s =3D PRINTBUF_EXTERN(buf, PAGE_SIZE); u64 health; int rc; =20 @@ -1196,29 +1195,28 @@ static ssize_t flags_show(struct device *dev, /* Copy health_bitmap locally, check masks & update out buffer */ health =3D READ_ONCE(p->health_bitmap); =20 - seq_buf_init(&s, buf, PAGE_SIZE); if (health & PAPR_PMEM_UNARMED_MASK) - seq_buf_printf(&s, "not_armed "); + prt_printf(&s, "not_armed "); =20 if (health & PAPR_PMEM_BAD_SHUTDOWN_MASK) - seq_buf_printf(&s, "flush_fail "); + prt_printf(&s, "flush_fail "); =20 if (health & PAPR_PMEM_BAD_RESTORE_MASK) - seq_buf_printf(&s, "restore_fail "); + prt_printf(&s, "restore_fail "); =20 if (health & PAPR_PMEM_ENCRYPTED) - seq_buf_printf(&s, "encrypted "); + prt_printf(&s, "encrypted "); =20 if (health & PAPR_PMEM_SMART_EVENT_MASK) - seq_buf_printf(&s, "smart_notify "); + prt_printf(&s, "smart_notify "); =20 if (health & PAPR_PMEM_SCRUBBED_AND_LOCKED) - seq_buf_printf(&s, "scrubbed locked "); + prt_printf(&s, "scrubbed locked "); =20 - if (seq_buf_used(&s)) - seq_buf_printf(&s, "\n"); + if (printbuf_written(&s)) + prt_printf(&s, "\n"); =20 - return seq_buf_used(&s); + return printbuf_written(&s); } DEVICE_ATTR_RO(flags); =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 12FFFC19F2A for ; Mon, 8 Aug 2022 02:42:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243501AbiHHCmK (ORCPT ); Sun, 7 Aug 2022 22:42:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241862AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id ACDCC25C7 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=GVucidUOOwtQ2TJCPsgzEhLdwKKhX1FOI8GcU2GMl0g=; b=ISaWvnuqHzawQhPdc61l2Sxvkd WpOlQVvan5xH10oxr1v4QtaDOYTBgKIdnjePj3WSsmntzoVv1cZeDWgjqY9gf1YVBSR0GRg47zQ9C zNQOgZ3Pfx7iDHcwOroSP0crMagexUKgC5+fcakQ5ReQ98wNRNybzSv+B/Z8iZVI2y/ej2F0CHyod MalFPsk0dE2SI+lJDsOQx8Gta0gcdVWEd9luP4qK2SdlFQIrwn6JVx1Ar2x51Y+J5Rryb9k6iISEm YXr4cuPvSUtXF1nJVuZKJX9m081xfv6hWw/B+ty29iMyWhh7ex+QhBHUPjNS3BWkXQLwm6Ex8l4nz G/ykCLUg==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSf-OB; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: x86@kernel.org Subject: [PATCH v5 26/32] x86/resctrl: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:22 +0100 Message-Id: <20220808024128.3219082-27-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 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/r= esctrl/rdtgroup.c index f276aff521e8..50c12711a249 100644 --- a/arch/x86/kernel/cpu/resctrl/rdtgroup.c +++ b/arch/x86/kernel/cpu/resctrl/rdtgroup.c @@ -19,7 +19,7 @@ #include #include #include -#include +#include #include #include #include @@ -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; =20 -static struct seq_buf last_cmd_status; +static struct printbuf last_cmd_status; static char last_cmd_status_buf[512]; =20 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); } =20 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); } =20 void rdt_last_cmd_printf(const char *fmt, ...) @@ -74,7 +74,7 @@ void rdt_last_cmd_printf(const char *fmt, ...) =20 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); } =20 @@ -833,7 +833,7 @@ static int rdt_last_cmd_status_show(struct kernfs_open_= file *of, int len; =20 mutex_lock(&rdtgroup_mutex); - len =3D seq_buf_used(&last_cmd_status); + len =3D 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 =3D 0; =20 - seq_buf_init(&last_cmd_status, last_cmd_status_buf, - sizeof(last_cmd_status_buf)); + last_cmd_status =3D PRINTBUF_EXTERN(last_cmd_status_buf, + sizeof(last_cmd_status_buf)); =20 ret =3D rdtgroup_setup_root(); if (ret) --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C7E81C19F2A for ; Mon, 8 Aug 2022 02:42:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243902AbiHHCma (ORCPT ); Sun, 7 Aug 2022 22:42:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60990 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241965AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 76AF121BF; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=BvTU+A/nzuWUa8MQa4k7Sb4glYSL+iQXtzbWCaKztNY=; b=GLqkpcfBCrPO49rGo+VKNZFVZU iFKYf5NbjDOjL4T7Ju6Az370rqSdPV+96FyYRNmhl3+vbhVxDgIqTUDNIHpSR0FIKJqXava9rSkkU pYZE51oQzMU37HijszMPXEys7ubsnPoFDlFr0ye4g4iiyr5hg68zVpKt2/DItFlQoSTeSRUFcCfn7 g/d7u693Gyd85tSt6SxgEZlBJQT4Uz5NyD1OOtZzX+yNRjygMRX4DeZ75dfKkjj89tCiYU+Tvyce/ PQsKCLIC0R55T5USWY/OT4FdnaAKeF+ufewhzxYP142nkG/bFzidi4z+wsj209PGZ9DD7wjLzjgXr HeAlwkHA==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSh-QD; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: linux-pci@vger.kernel.org Subject: [PATCH v5 27/32] PCI/P2PDMA: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:23 +0100 Message-Id: <20220808024128.3219082-28-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: linux-pci@vger.kernel.org --- drivers/pci/p2pdma.c | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-) diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c index 4496a7c5c478..8e29e7cabad3 100644 --- a/drivers/pci/p2pdma.c +++ b/drivers/pci/p2pdma.c @@ -18,7 +18,7 @@ #include #include #include -#include +#include #include =20 struct pci_p2pdma { @@ -275,12 +275,9 @@ static int pci_bridge_has_acs_redir(struct pci_dev *pd= ev) return 0; } =20 -static void seq_buf_print_bus_devfn(struct seq_buf *buf, struct pci_dev *p= dev) +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)); } =20 static bool cpu_supports_p2pdma(void) @@ -454,13 +451,11 @@ calc_map_type_and_dist(struct pci_dev *provider, stru= ct pci_dev *client, struct pci_dev *a =3D provider, *b =3D client, *bb; bool acs_redirects =3D false; struct pci_p2pdma *p2pdma; - struct seq_buf acs_list; int acs_cnt =3D 0; int dist_a =3D 0; int dist_b =3D 0; char buf[128]; - - seq_buf_init(&acs_list, buf, sizeof(buf)); + struct printbuf acs_list =3D PRINTBUF_EXTERN(buf, sizeof(buf)); =20 /* * Note, we don't need to take references to devices returned by @@ -471,7 +466,7 @@ calc_map_type_and_dist(struct pci_dev *provider, struct= pci_dev *client, dist_b =3D 0; =20 if (pci_bridge_has_acs_redir(a)) { - seq_buf_print_bus_devfn(&acs_list, a); + prt_bus_devfn(&acs_list, a); acs_cnt++; } =20 @@ -500,7 +495,7 @@ calc_map_type_and_dist(struct pci_dev *provider, struct= pci_dev *client, break; =20 if (pci_bridge_has_acs_redir(bb)) { - seq_buf_print_bus_devfn(&acs_list, bb); + prt_bus_devfn(&acs_list, bb); acs_cnt++; } =20 @@ -515,11 +510,11 @@ calc_map_type_and_dist(struct pci_dev *provider, stru= ct pci_dev *client, } =20 if (verbose) { - acs_list.buffer[acs_list.len-1] =3D 0; /* drop final semicolon */ + acs_list.buf[acs_list.pos-1] =3D 0; /* drop final semicolon */ pci_warn(client, "ACS redirect is set between the client and provider (%= s)\n", pci_name(provider)); pci_warn(client, "to disable ACS redirect for this path, add the kernel = parameter: pci=3Ddisable_acs_redir=3D%s\n", - acs_list.buffer); + acs_list.buf); } acs_redirects =3D true; =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0777CC19F2A for ; Mon, 8 Aug 2022 02:44:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244129AbiHHCoB (ORCPT ); Sun, 7 Aug 2022 22:44:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32802 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242185AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1BD8225E3 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=O10e4f89X47Ind7IOvarTPJ2k5gxmqsKR8G7YqYX1Cg=; b=N7edtCxvgsKuafmwDdeWT0yPZ2 FB3MJMFhR12jcCZEHcTZcus9815lmWGogVyh8sutkUHiE0kE4vbmkm5R7nG8Xuu+aXml0uVTPcFtx 6mZXoP0+8H17Szl7f8trEwkAfnR4viPXlkZG9LqRSJIZPahVAkzKHT4AKMKBh64nc/3+QRWXIc9vU /yC2B3mbwSyyiYsZDKNQu/BiAggV1x0aHDnMEsNLObEf+ayUJGRNKMcYcw1yI4m5aTWb5td/NZYID uM3vCfk3ZZxbqa8+bULyt6g8e50Sc1lb1o7U1TdogvlEXSL6CizBYaKVCgIiq2DFoGGiieusYqp0X LmjsFJ9A==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSl-Sz; Mon, 08 Aug 2022 02:41:34 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Steven Rostedt , Ingo Molnar Subject: [PATCH v5 28/32] tracing: trace_events_synth: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:24 +0100 Message-Id: <20220808024128.3219082-29-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet This converts from seq_buf to printbuf. This code was using seq_buf for building up dynamically allocated strings; the conversion uses printbuf's heap allocation functionality to simplify things (no longer need to calculate size of the output string). Also, alphabetize the #includes. Signed-off-by: Kent Overstreet Cc: Steven Rostedt Cc: Ingo Molnar --- kernel/trace/trace_events_synth.c | 51 ++++++++++--------------------- 1 file changed, 16 insertions(+), 35 deletions(-) diff --git a/kernel/trace/trace_events_synth.c b/kernel/trace/trace_events_= synth.c index 5e8c07aef071..720c75429c8f 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 */ =20 -#include #include -#include +#include #include +#include +#include +#include #include #include -#include #include =20 /* for gfp flag names */ @@ -611,7 +612,7 @@ static struct synth_field *parse_synth_field(int argc, = char **argv, const char *prefix =3D NULL, *field_type =3D argv[0], *field_name, *array; struct synth_field *field; int len, ret =3D -ENOMEM; - struct seq_buf s; + struct printbuf buf; ssize_t size; =20 if (!strcmp(field_type, "unsigned")) { @@ -654,28 +655,16 @@ static struct synth_field *parse_synth_field(int argc= , char **argv, goto free; } =20 - len =3D strlen(field_type) + 1; - - if (array) - len +=3D strlen(array); - - if (prefix) - len +=3D strlen(prefix); - - field->type =3D kzalloc(len, GFP_KERNEL); - if (!field->type) - goto free; - - seq_buf_init(&s, field->type, len); + buf =3D PRINTBUF; if (prefix) - seq_buf_puts(&s, prefix); - seq_buf_puts(&s, field_type); + prt_str(&buf, prefix); + prt_str(&buf, field_type); if (array) - seq_buf_puts(&s, array); - if (WARN_ON_ONCE(!seq_buf_buffer_left(&s))) + prt_str(&buf, array); + if (buf.allocation_failure) goto free; =20 - s.buffer[s.len] =3D '\0'; + field->type =3D buf.buf; =20 size =3D synth_field_size(field->type); if (size < 0) { @@ -687,23 +676,15 @@ static struct synth_field *parse_synth_field(int argc= , char **argv, goto free; } else if (size =3D=3D 0) { if (synth_field_is_string(field->type)) { - char *type; - - len =3D sizeof("__data_loc ") + strlen(field->type) + 1; - type =3D kzalloc(len, GFP_KERNEL); - if (!type) - goto free; - - seq_buf_init(&s, type, len); - seq_buf_puts(&s, "__data_loc "); - seq_buf_puts(&s, field->type); + buf =3D PRINTBUF; + prt_str(&buf, "__data_loc "); + prt_str(&buf, field->type); =20 - if (WARN_ON_ONCE(!seq_buf_buffer_left(&s))) + if (buf.allocation_failure) goto free; - s.buffer[s.len] =3D '\0'; =20 kfree(field->type); - field->type =3D type; + field->type =3D buf.buf; =20 field->is_dynamic =3D true; size =3D sizeof(u64); --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3881CC19F2A for ; Mon, 8 Aug 2022 02:42:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237367AbiHHCmY (ORCPT ); Sun, 7 Aug 2022 22:42:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60996 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241934AbiHHClj (ORCPT ); Sun, 7 Aug 2022 22:41:39 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E615B25D5 for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=PdlpiFKX35KK8r3Bv1PVQ9ch5aGjfo6klq0s7Ja/ZcU=; b=oavNtuqiUYqRRZhJ0sIwHV2ERi QtwceMggiiUt4buzv5kNGHnxwn78DqQLJ9+zdX3PyUGRwKMMT3uQ9a14miL94tKa8TDlz5IMHHpnv CvymKXqKOcfi9tdYZHtcsaGyJI6dp4ahgWSNVtOq/ZRG9gGAoE2ZRR8FT7RCCGOgebyhM/p4wXPb2 XmyW8qkOjaWxz7nlCbLBKTuX3JFkcZ4vAxSnUH1pJNZyk7fZ0Z/AN0QDUbHiQuGRn6OdSEPOPQw9y ulUb13Y3kdgROubNzvA3OSf21ei2nqJVFl86XRx1ceCMc7VAWy/SD8vBX7aqpwkDSduDQwxzJPT1D OBUNPUaw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshy-00DVSp-Vf; Mon, 08 Aug 2022 02:41:35 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Alexander Viro Subject: [PATCH v5 29/32] d_path: prt_path() Date: Mon, 8 Aug 2022 03:41:25 +0100 Message-Id: <20220808024128.3219082-30-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet This implements a new printbuf version of d_path()/mangle_path(), which will replace the seq_buf version. Part of what we're trying to do with printbufs is standardizing a calling convention so they don't have to live in lib/vsprintf.c, and can instead with the code for the types they're printing - so this patch adds prt_path() to d_path.c, another patch will switch vsprintf.c to use it. Signed-off-by: Kent Overstreet Cc: Alexander Viro --- fs/d_path.c | 35 +++++++++++++++++++++++++++++++++++ include/linux/dcache.h | 1 + 2 files changed, 36 insertions(+) diff --git a/fs/d_path.c b/fs/d_path.c index e4e0ebad1f15..1bd9e85f2f65 100644 --- a/fs/d_path.c +++ b/fs/d_path.c @@ -5,6 +5,7 @@ #include #include #include +#include #include #include "mount.h" =20 @@ -294,6 +295,40 @@ char *d_path(const struct path *path, char *buf, int b= uflen) } EXPORT_SYMBOL(d_path); =20 +/** + * 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 *es= c) +{ + char *p, *buf; + size_t size; +again: + buf =3D out->buf + out->pos; + size =3D printbuf_remaining_size(out); + + p =3D d_path(path, buf, size); + if (IS_ERR(p)) { + printbuf_make_room(out, max_t(size_t, 64, size * 2)); + if (printbuf_remaining_size(out) > size) + goto again; + + return PTR_ERR(p); + } + + p =3D mangle_path(buf, p, esc); + if (p) + out->pos +=3D 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 c73e5e327e76..bdd5940aa75a 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 *); =20 /* Allocation counts.. */ =20 --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7D234C19F2A for ; Mon, 8 Aug 2022 02:42:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243905AbiHHCmf (ORCPT ); Sun, 7 Aug 2022 22:42:35 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241980AbiHHClk (ORCPT ); Sun, 7 Aug 2022 22:41:40 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E04E925C8; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=gzcS+2g8qckyZYIbV9gGRltqepY9Wqdgqqh++TVUMKc=; b=LhxYf0PPJIbN0YuEmB1f0e3VgE P1xTVDnQvAPJHX89BkXP4kHoCf3BKzomhlrXrvRlI7gkvQr4xZFerWQHDbfdD2RQIwkCBi5Zz9Pa2 mdMG5Y4fUAa/7R5x5jHHnEJszfwNKz5Sfh01olXYyT51emzASbl7aImEk434uLv1MZzo+a/fjblfx /TxNUjfNLkR/eOKZIZ1EQRk2HT3OUR8Kc3nB3elhNx0YyP8bL7RDAGcAldyB1LcrcPfIpnoJmPmFw Q15p6yrVxgqxtjJ5W9QIlcMt+htSsHpIbHW5GdL4fzYW9/6HWL1DWYm/SvKMtHZzLs+ZbdZJms0Mm 9H3/c/9A==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshz-00DVSr-1Y; Mon, 08 Aug 2022 02:41:35 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: linux-acpi@vger.kernel.org Subject: [PATCH v5 30/32] ACPI/APEI: Add missing include Date: Mon, 8 Aug 2022 03:41:26 +0100 Message-Id: <20220808024128.3219082-31-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet The upcoming patch to switch tracing from seq_buf to printbuf means we're no longer pulling in headers that we used to; this adds a missing include so things don't break. Signed-off-by: Kent Overstreet Cc: linux-acpi@vger.kernel.org Acked-by: Rafael J. Wysocki --- drivers/acpi/apei/erst-dbg.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/acpi/apei/erst-dbg.c b/drivers/acpi/apei/erst-dbg.c index 8bc71cdc2270..370993c9c381 100644 --- a/drivers/acpi/apei/erst-dbg.c +++ b/drivers/acpi/apei/erst-dbg.c @@ -11,6 +11,7 @@ * Author: Huang Ying */ =20 +#include #include #include #include --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 62669C19F2A for ; Mon, 8 Aug 2022 02:42:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243929AbiHHCms (ORCPT ); Sun, 7 Aug 2022 22:42:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60990 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242395AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1103325DC for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=3GaETBdzlxAcdaQwpNjEEsJ8bc70Xh+pVgrrFGfJAkI=; b=XIpuc/MvC8RrUiQunDAIHH3ReT RjkQ4M84pjg0OiKyU4q8YK7E6Z/2d+O2C/3uV3mEkcrVJ273wQc9OyaKuTl7mfTeed2LfC6pLgiHq 6dpKDYkWOszD9hxsA+9g5+musH4Ic+tly7DYNKHj8eC33WcHtN8nxkTDVDDfL//p+uSfml4I1eVWT ug7IO7fMPB0NxoeJyQYvepiUR4nuUZFaRbGSSadXmzvEIVKI6mI2yAt+anKtf3WeQQG+OlfW+SaYs +B6Db33XUHUCV9RMqGEqv18P1CzaATlWVGVhxCyEbGCHx4WYzmKtK5GwEAcfoUa3NNSvjDHfdkyxi RZw4GBzw==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshz-00DVT3-5X; Mon, 08 Aug 2022 02:41:35 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Steven Rostedt , Ingo Molnar Subject: [PATCH v5 31/32] tracing: Convert to printbuf Date: Mon, 8 Aug 2022 03:41:27 +0100 Message-Id: <20220808024128.3219082-32-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet 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 Cc: Steven Rostedt Cc: Ingo Molnar --- include/linux/trace_events.h | 2 +- include/linux/trace_seq.h | 17 ++-- 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, 103 insertions(+), 118 deletions(-) diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h index b18759a673c6..4cb7cacb57b1 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); =20 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 5a2c650d9e1c..d2b51007b3b9 100644 --- a/include/linux/trace_seq.h +++ b/include/linux/trace_seq.h @@ -2,10 +2,12 @@ #ifndef _LINUX_TRACE_SEQ_H #define _LINUX_TRACE_SEQ_H =20 -#include +#include =20 #include =20 +struct seq_file; + /* * Trace sequences are used to allow a function to call several other func= tions * to create a string of data to use (up to a max of PAGE_SIZE). @@ -13,14 +15,16 @@ =20 struct trace_seq { char buffer[PAGE_SIZE]; - struct seq_buf seq; + struct printbuf seq; + unsigned readpos; int full; }; =20 static inline void trace_seq_init(struct trace_seq *s) { - seq_buf_init(&s->seq, s->buffer, PAGE_SIZE); + s->seq =3D PRINTBUF_EXTERN(s->buffer, PAGE_SIZE); + s->readpos =3D 0; s->full =3D 0; } =20 @@ -39,7 +43,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); } =20 /** @@ -54,7 +58,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); } =20 /** @@ -66,7 +70,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); } =20 /* @@ -87,6 +91,7 @@ extern void trace_seq_putc(struct trace_seq *s, unsigned = char c); extern void trace_seq_putmem(struct trace_seq *s, const void *mem, unsigne= d int len); extern void trace_seq_putmem_hex(struct trace_seq *s, const void *mem, unsigned int len); +struct path; extern int trace_seq_path(struct trace_seq *s, const struct path *path); =20 extern void trace_seq_bitmask(struct trace_seq *s, const unsigned long *ma= skp, diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index d3005279165d..b27fe1e45138 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -1673,15 +1673,15 @@ static ssize_t trace_seq_to_buffer(struct trace_seq= *s, void *buf, size_t cnt) { int len; =20 - if (trace_seq_used(s) <=3D s->seq.readpos) + if (trace_seq_used(s) <=3D s->readpos) return -EBUSY; =20 - len =3D trace_seq_used(s) - s->seq.readpos; + len =3D trace_seq_used(s) - s->readpos; if (cnt > len) cnt =3D len; - memcpy(buf, s->buffer + s->seq.readpos, cnt); + memcpy(buf, s->buffer + s->readpos, cnt); =20 - s->seq.readpos +=3D cnt; + s->readpos +=3D cnt; return cnt; } =20 @@ -3728,11 +3728,7 @@ static bool trace_safe_str(struct trace_iterator *it= er, const char *str, =20 static const char *show_buffer(struct trace_seq *s) { - struct seq_buf *seq =3D &s->seq; - - seq_buf_terminate(seq); - - return seq->buffer; + return printbuf_str(&s->seq); } =20 static DEFINE_STATIC_KEY_FALSE(trace_no_verify); @@ -6759,12 +6755,12 @@ tracing_read_pipe(struct file *filp, char __user *u= buf, trace_access_lock(iter->cpu_file); while (trace_find_next_entry_inc(iter) !=3D NULL) { enum print_line_t ret; - int save_len =3D iter->seq.seq.len; + int save_pos =3D iter->seq.seq.pos; =20 ret =3D print_trace_line(iter); if (ret =3D=3D TRACE_TYPE_PARTIAL_LINE) { /* don't print partial lines */ - iter->seq.seq.len =3D save_len; + iter->seq.seq.pos =3D save_pos; break; } if (ret !=3D TRACE_TYPE_NO_CONSUME) @@ -6786,7 +6782,7 @@ tracing_read_pipe(struct file *filp, char __user *ubu= f, =20 /* Now copy what we have to the user */ sret =3D trace_seq_to_user(&iter->seq, ubuf, cnt); - if (iter->seq.seq.readpos >=3D trace_seq_used(&iter->seq)) + if (iter->seq.readpos >=3D trace_seq_used(&iter->seq)) trace_seq_init(&iter->seq); =20 /* @@ -6812,16 +6808,15 @@ static size_t tracing_fill_pipe_page(size_t rem, struct trace_iterator *iter) { size_t count; - int save_len; int ret; =20 /* Seq buffer is page-sized, exactly what we need. */ for (;;) { - save_len =3D iter->seq.seq.len; + unsigned save_pos =3D iter->seq.seq.pos; ret =3D print_trace_line(iter); =20 if (trace_seq_has_overflowed(&iter->seq)) { - iter->seq.seq.len =3D save_len; + iter->seq.seq.pos =3D save_pos; break; } =20 @@ -6831,14 +6826,14 @@ tracing_fill_pipe_page(size_t rem, struct trace_ite= rator *iter) * anyway to be safe. */ if (ret =3D=3D TRACE_TYPE_PARTIAL_LINE) { - iter->seq.seq.len =3D save_len; + iter->seq.seq.pos =3D save_pos; break; } =20 - count =3D trace_seq_used(&iter->seq) - save_len; + count =3D trace_seq_used(&iter->seq) - save_pos; if (rem < count) { rem =3D 0; - iter->seq.seq.len =3D save_len; + iter->seq.seq.pos =3D save_pos; break; } =20 @@ -9826,20 +9821,8 @@ static struct notifier_block trace_die_notifier =3D { void trace_printk_seq(struct trace_seq *s) { - /* Probably should print a warning here. */ - if (s->seq.len >=3D TRACE_MAX_PRINT) - s->seq.len =3D 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 >=3D s->seq.size)) - s->seq.len =3D s->seq.size - 1; - /* should be zero ended, but we are paranoid. */ - s->buffer[s->seq.len] =3D 0; + printbuf_nul_terminate(&s->seq); =20 printk(KERN_TRACE "%s", s->buffer); =20 diff --git a/kernel/trace/trace_dynevent.c b/kernel/trace/trace_dynevent.c index 154996684fb5..c14f99af79ed 100644 --- a/kernel/trace/trace_dynevent.c +++ b/kernel/trace/trace_dynevent.c @@ -290,21 +290,19 @@ int dynevent_arg_add(struct dynevent_cmd *cmd, struct dynevent_arg *arg, dynevent_check_arg_fn_t check_arg) { - int ret =3D 0; - if (check_arg) { - ret =3D check_arg(arg); + int ret =3D check_arg(arg); if (ret) return ret; } =20 - ret =3D 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; } =20 - return ret; + return 0; } =20 /** @@ -335,25 +333,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 =3D 0; - if (check_arg) { - ret =3D check_arg(arg_pair); + int ret =3D check_arg(arg_pair); if (ret) return ret; } =20 - ret =3D 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; } =20 - return ret; + return 0; } =20 /** @@ -368,15 +364,13 @@ int dynevent_arg_pair_add(struct dynevent_cmd *cmd, */ int dynevent_str_add(struct dynevent_cmd *cmd, const char *str) { - int ret =3D 0; - - ret =3D 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; } =20 - return ret; + return 0; } =20 /** @@ -405,7 +399,7 @@ void dynevent_cmd_init(struct dynevent_cmd *cmd, char *= buf, int maxlen, { memset(cmd, '\0', sizeof(*cmd)); =20 - seq_buf_init(&cmd->seq, buf, maxlen); + cmd->seq =3D PRINTBUF_EXTERN(buf, maxlen); cmd->type =3D type; cmd->run_command =3D run_command; } diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 4b1057ab9d96..9d5137df1a15 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 =3D kmemdup_nul(s->buffer, s->seq.len, GFP_KERNEL); + buf =3D kstrdup(printbuf_str(&s->seq), GFP_KERNEL); if (buf) { kfree(filter->filter_string); filter->filter_string =3D buf; diff --git a/kernel/trace/trace_events_synth.c b/kernel/trace/trace_events_= synth.c index 720c75429c8f..914b4e5e32a5 100644 --- a/kernel/trace/trace_events_synth.c +++ b/kernel/trace/trace_events_synth.c @@ -1495,7 +1495,7 @@ static int synth_event_run_command(struct dynevent_cm= d *cmd) struct synth_event *se; int ret; =20 - ret =3D create_or_delete_synth_event(cmd->seq.buffer); + ret =3D create_or_delete_synth_event(cmd->seq.buf); if (ret) return ret; =20 diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_func= tions_graph.c index 203204cadf92..9f270fdde99b 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; =20 /* Strip ending newline */ - if (s->buffer[s->seq.len - 1] =3D=3D '\n') { - s->buffer[s->seq.len - 1] =3D '\0'; - s->seq.len--; + if (s->buffer[s->seq.pos - 1] =3D=3D '\n') { + s->buffer[s->seq.pos - 1] =3D '\0'; + s->seq.pos--; } =20 trace_seq_puts(s, " */\n"); diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c index 23f7f0ec4f4c..2917d74bc41e 100644 --- a/kernel/trace/trace_kprobe.c +++ b/kernel/trace/trace_kprobe.c @@ -919,7 +919,7 @@ static int create_or_delete_trace_kprobe(const char *ra= w_command) =20 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)); } =20 /** diff --git a/kernel/trace/trace_seq.c b/kernel/trace/trace_seq.c index 9c90b3a7dce2..48c08f29c342 100644 --- a/kernel/trace/trace_seq.c +++ b/kernel/trace/trace_seq.c @@ -25,11 +25,9 @@ */ #include #include +#include #include =20 -/* 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) =20 __trace_seq_init(s); =20 - ret =3D seq_buf_print_seq(m, &s->seq); + ret =3D seq_write(m, s->seq.buf, printbuf_written(&s->seq)); =20 /* * 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 =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; va_list ap; =20 if (s->full) @@ -89,12 +87,12 @@ void trace_seq_printf(struct trace_seq *s, const char *= fmt, ...) __trace_seq_init(s); =20 va_start(ap, fmt); - seq_buf_vprintf(&s->seq, fmt, ap); + prt_vprintf(&s->seq, fmt, ap); va_end(ap); =20 /* If we can't write it all, don't bother writing anything */ - if (unlikely(seq_buf_has_overflowed(&s->seq))) { - s->seq.len =3D save_len; + if (unlikely(printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 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 =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; =20 if (s->full) return; =20 __trace_seq_init(s); =20 - seq_buf_printf(&s->seq, "%*pb", nmaskbits, maskp); + prt_printf(&s->seq, "%*pb", nmaskbits, maskp); =20 - if (unlikely(seq_buf_has_overflowed(&s->seq))) { - s->seq.len =3D save_len; + if (unlikely(printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 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 =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; =20 if (s->full) return; =20 __trace_seq_init(s); =20 - seq_buf_vprintf(&s->seq, fmt, args); + prt_vprintf(&s->seq, fmt, args); =20 /* If we can't write it all, don't bother writing anything */ - if (unlikely(seq_buf_has_overflowed(&s->seq))) { - s->seq.len =3D save_len; + if (unlikely(printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 1; } } @@ -174,18 +172,18 @@ EXPORT_SYMBOL_GPL(trace_seq_vprintf); */ void trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *bi= nary) { - unsigned int save_len =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; =20 if (s->full) return; =20 __trace_seq_init(s); =20 - seq_buf_bprintf(&s->seq, fmt, binary); + prt_bstrprintf(&s->seq, fmt, binary); =20 /* If we can't write it all, don't bother writing anything */ - if (unlikely(seq_buf_has_overflowed(&s->seq))) { - s->seq.len =3D save_len; + if (unlikely(!printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 1; return; } @@ -211,12 +209,12 @@ void trace_seq_puts(struct trace_seq *s, const char *= str) =20 __trace_seq_init(s); =20 - if (len > TRACE_SEQ_BUF_LEFT(s)) { + if (len > printbuf_remaining(&s->seq)) { s->full =3D 1; return; } =20 - seq_buf_putmem(&s->seq, str, len); + prt_bytes(&s->seq, str, len); } EXPORT_SYMBOL_GPL(trace_seq_puts); =20 @@ -237,12 +235,12 @@ void trace_seq_putc(struct trace_seq *s, unsigned cha= r c) =20 __trace_seq_init(s); =20 - if (TRACE_SEQ_BUF_LEFT(s) < 1) { + if (!printbuf_remaining(&s->seq)) { s->full =3D 1; return; } =20 - seq_buf_putc(&s->seq, c); + prt_char(&s->seq, c); } EXPORT_SYMBOL_GPL(trace_seq_putc); =20 @@ -263,12 +261,12 @@ void trace_seq_putmem(struct trace_seq *s, const void= *mem, unsigned int len) =20 __trace_seq_init(s); =20 - if (len > TRACE_SEQ_BUF_LEFT(s)) { + if (len > printbuf_remaining(&s->seq)) { s->full =3D 1; return; } =20 - seq_buf_putmem(&s->seq, mem, len); + prt_bytes(&s->seq, mem, len); } EXPORT_SYMBOL_GPL(trace_seq_putmem); =20 @@ -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 =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; =20 if (s->full) return; =20 __trace_seq_init(s); =20 - /* Each byte is represented by two chars */ - if (len * 2 > TRACE_SEQ_BUF_LEFT(s)) { - s->full =3D 1; - return; - } + prt_hex_bytes(&s->seq, mem, len, 8, ' '); =20 - /* 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 =3D save_len; + if (unlikely(printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 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 =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; =20 if (s->full) return 0; =20 __trace_seq_init(s); =20 - if (TRACE_SEQ_BUF_LEFT(s) < 1) { + if (printbuf_remaining(&s->seq) < 1) { s->full =3D 1; return 0; } =20 - seq_buf_path(&s->seq, path, "\n"); + prt_path(&s->seq, path, "\n"); =20 - if (unlikely(seq_buf_has_overflowed(&s->seq))) { - s->seq.len =3D save_len; + if (unlikely(printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 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 =3D printbuf_written(&s->seq); + if (len <=3D s->readpos) + return -EBUSY; + + len -=3D s->readpos; + if (cnt > len) + cnt =3D len; + ret =3D copy_to_user(ubuf, s->buffer + s->readpos, cnt); + if (ret =3D=3D cnt) + return -EFAULT; + + cnt -=3D ret; + + s->readpos +=3D cnt; + return cnt; } EXPORT_SYMBOL_GPL(trace_seq_to_user); =20 @@ -378,24 +386,19 @@ int trace_seq_hex_dump(struct trace_seq *s, const cha= r *prefix_str, int prefix_type, int rowsize, int groupsize, const void *buf, size_t len, bool ascii) { - unsigned int save_len =3D s->seq.len; + unsigned int save_pos =3D s->seq.pos; =20 if (s->full) return 0; =20 __trace_seq_init(s); =20 - if (TRACE_SEQ_BUF_LEFT(s) < 1) { - s->full =3D 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); =20 - if (unlikely(seq_buf_has_overflowed(&s->seq))) { - s->seq.len =3D save_len; + if (unlikely(printbuf_overflowed(&s->seq))) { + s->seq.pos =3D save_pos; s->full =3D 1; return 0; } --=20 2.35.1 From nobody Sat Apr 11 19:32:43 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 03445C19F2A for ; Mon, 8 Aug 2022 02:43:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244102AbiHHCnF (ORCPT ); Sun, 7 Aug 2022 22:43:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60996 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242382AbiHHCll (ORCPT ); Sun, 7 Aug 2022 22:41:41 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1666B25DD for ; Sun, 7 Aug 2022 19:41:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=1rMz6qsSbhllFog8MPVw0+Iw98hXTLVuCK5MUoQIH24=; b=HIGlbNIrEdOrWcYxLlI1kHwcxo cVob1sgWVxoNRcoyn4zA6Zc9W+M7WUH4l3WzSgyxVyK8d6rG9XIXDN0vwFnlDKD7zNoWYJeH0/Xf4 qkxdA2McB1TuYAnrLUokh06PNmYz94SkqCMmDYEqH7bug/ZG1QIDxHk6RHZVaNWkZGrtkP67ZdbCO z+5dMeGCBYoMMb4McdjrNn/CAHEn5Iu9dkHVZXvsK9BK5zOWAdbPoYF0NgIWENeLN2P1oq2xSkgqa OBh4JGTcleFlsl9TBtix8CrjM0kvAkn18LyCK6leidOkW5vU5YYtacLnYUmh6oP3j1LDuHxKk8ZWS kyEpQ0uA==; Received: from willy by casper.infradead.org with local (Exim 4.94.2 #2 (Red Hat Linux)) id 1oKshz-00DVTB-88; Mon, 08 Aug 2022 02:41:35 +0000 From: "Matthew Wilcox (Oracle)" To: linux-kernel@vger.kernel.org, pmladek@suse.com, Kent Overstreet Cc: Steven Rostedt Subject: [PATCH v5 32/32] Delete seq_buf Date: Mon, 8 Aug 2022 03:41:28 +0100 Message-Id: <20220808024128.3219082-33-willy@infradead.org> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20220808024128.3219082-1-willy@infradead.org> References: <20220808024128.3219082-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Kent Overstreet All users have now been converted to printbufs. Signed-off-by: Kent Overstreet Cc: Steven Rostedt --- 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 5b31c5147969..000000000000 --- 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 - -/* - * Trace sequences are used to allow a function to call several other func= tions - * 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 =3D 0; - s->readpos =3D 0; -} - -static inline void -seq_buf_init(struct seq_buf *s, char *buf, unsigned int size) -{ - s->buffer =3D buf; - s->size =3D 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 =3D 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 =3D=3D 0)) - return; - - if (seq_buf_buffer_left(s)) - s->buffer[s->len] =3D 0; - else - s->buffer[s->size - 1] =3D 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 =3D s->buffer + s->len; - return s->size - s->len; - } - - *bufp =3D 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 +=3D 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 d44f8d03d66b..9ed57a1f9fa0 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -32,7 +32,7 @@ lib-y :=3D ctype.o string.o vsprintf.o cmdline.o \ idr.o extable.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 cpumask.o printbuf.o =20 diff --git a/lib/seq_buf.c b/lib/seq_buf.c deleted file mode 100644 index 0a68f7aa85d6..000000000000 --- 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 - * - * 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 -#include -#include - -/** - * 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 <=3D 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 =3D 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 =3D=3D 0); - - if (s->len < s->size) { - len =3D vsnprintf(s->buffer + s->len, s->size - s->len, fmt, args); - if (s->len + len < s->size) { - s->len +=3D 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 =3D 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 =3D seq_buf_buffer_left(s); - int ret; - - WARN_ON(s->size =3D=3D 0); - - if (s->len < s->size) { - ret =3D bstr_printf(s->buffer + s->len, len, fmt, binary); - if (s->len + ret < s->size) { - s->len +=3D 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 =3D strlen(str); - - WARN_ON(s->size =3D=3D 0); - - /* Add 1 to len for the trailing null byte which must be there */ - len +=3D 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 +=3D 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 =3D=3D 0); - - if (seq_buf_can_fit(s, 1)) { - s->buffer[s->len++] =3D 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 =3D=3D 0); - - if (seq_buf_can_fit(s, len)) { - memcpy(s->buffer + s->len, mem, len); - s->len +=3D 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 =3D mem; - unsigned int start_len; - int i, j; - - WARN_ON(s->size =3D=3D 0); - - BUILD_BUG_ON(MAX_MEMHEX_BYTES * 2 >=3D HEX_CHARS); - - while (len) { - start_len =3D min(len, MAX_MEMHEX_BYTES); -#ifdef __BIG_ENDIAN - for (i =3D 0, j =3D 0; i < start_len; i++) { -#else - for (i =3D start_len-1, j =3D 0; i >=3D 0; i--) { -#endif - hex[j++] =3D hex_asc_hi(data[i]); - hex[j++] =3D hex_asc_lo(data[i]); - } - if (WARN_ON_ONCE(j =3D=3D 0 || j/2 > len)) - break; - - /* j increments twice per loop */ - hex[j++] =3D ' '; - - seq_buf_putmem(s, hex, j); - if (seq_buf_has_overflowed(s)) - return -1; - - len -=3D start_len; - data +=3D 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 *e= sc) -{ - char *buf; - size_t size =3D seq_buf_get_buf(s, &buf); - int res =3D -1; - - WARN_ON(s->size =3D=3D 0); - - if (size) { - char *p =3D d_path(path, buf, size); - if (!IS_ERR(p)) { - char *end =3D mangle_path(buf, p, esc); - if (end) - res =3D 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 =3D=3D @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 =3D seq_buf_used(s); - - if (len <=3D s->readpos) - return -EBUSY; - - len -=3D s->readpos; - if (cnt > len) - cnt =3D len; - ret =3D copy_to_user(ubuf, s->buffer + s->readpos, cnt); - if (ret =3D=3D cnt) - return -EFAULT; - - cnt -=3D ret; - - s->readpos +=3D 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_NO= NE) - * @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 =3D= 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 interf= ace. - * - * 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 =3D buf; - int i, linelen, remaining =3D len; - unsigned char linebuf[32 * 3 + 2 + 32 + 1]; - int ret; - - if (rowsize !=3D 16 && rowsize !=3D 32) - rowsize =3D 16; - - for (i =3D 0; i < len; i +=3D rowsize) { - linelen =3D min(remaining, rowsize); - remaining -=3D rowsize; - - hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize, - linebuf, sizeof(linebuf), ascii); - - switch (prefix_type) { - case DUMP_PREFIX_ADDRESS: - ret =3D seq_buf_printf(s, "%s%p: %s\n", - prefix_str, ptr + i, linebuf); - break; - case DUMP_PREFIX_OFFSET: - ret =3D seq_buf_printf(s, "%s%.8x: %s\n", - prefix_str, i, linebuf); - break; - default: - ret =3D seq_buf_printf(s, "%s%s\n", prefix_str, linebuf); - break; - } - if (ret) - return ret; - } - return 0; -} --=20 2.35.1