lib/vsprintf: Add support for generic FourCCs by extending %p4cc

%p4cc is designed for DRM/V4L2 FourCCs with their specific quirks, but
it's useful to be able to print generic 4-character codes formatted as
an integer. Extend it to add format specifiers for printing generic
32-bit FourCCs with various endian semantics:

%p4ch	Host byte order
%p4cn	Network byte order
%p4cl	Little-endian
%p4cb	Big-endian

The endianness determines how bytes are interpreted as a u32, and the
FourCC is then always printed MSByte-first (this is the opposite of
V4L/DRM FourCCs). This covers most practical cases, e.g. %p4cn would
allow printing LSByte-first FourCCs stored in host endian order
(other than the hex form being in character order, not the integer
value).

Acked-by: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Reviewed-by: Petr Mladek <pmladek@suse.com>
Tested-by: Petr Mladek <pmladek@suse.com>
Signed-off-by: Hector Martin <marcan@marcan.st>
Signed-off-by: Aditya Garg <gargaditya08@live.com>
Reviewed-by: Kees Cook <kees@kernel.org>
Link: https://lore.kernel.org/r/PN3PR01MB9597B01823415CB7FCD3BC27B8B52@PN3PR01MB9597.INDPRD01.PROD.OUTLOOK.COM
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>

diff --git a/Documentation/core-api/printk-formats.rst b/Documentation/core-api/printk-formats.rst
index 4bdc394e86af4f0e59f6f0142b84deafca24cf1a..125fd039751041fc553afaf4d1193a7e867c0bf9 100644 (file)
--- a/Documentation/core-api/printk-formats.rst
+++ b/Documentation/core-api/printk-formats.rst
@@ -648,6 +648,38 @@ Examples::
        %p4cc   Y10  little-endian (0x20303159)
        %p4cc   NV12 big-endian (0xb231564e)
 
+Generic FourCC code
+-------------------
+
+::
+       %p4c[hnlb]      gP00 (0x67503030)
+
+Print a generic FourCC code, as both ASCII characters and its numerical
+value as hexadecimal.
+
+The generic FourCC code is always printed in the big-endian format,
+the most significant byte first. This is the opposite of V4L/DRM FourCCs.
+
+The additional ``h``, ``n``, ``l``, and ``b`` specifiers define what
+endianness is used to load the stored bytes. The data might be interpreted
+using the host byte order, network byte order, little-endian, or big-endian.
+
+Passed by reference.
+
+Examples for a little-endian machine, given &(u32)0x67503030::
+
+       %p4ch   gP00 (0x67503030)
+       %p4cn   00Pg (0x30305067)
+       %p4cl   gP00 (0x67503030)
+       %p4cb   00Pg (0x30305067)
+
+Examples for a big-endian machine, given &(u32)0x67503030::
+
+       %p4ch   gP00 (0x67503030)
+       %p4cn   00Pg (0x30305067)
+       %p4cl   00Pg (0x30305067)
+       %p4cb   gP00 (0x67503030)
+
 Rust
 ----
 

diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 01699852f30cdf88d8004ca6af86800797496135..6bc64ae52166226aa6a004cc22752518934560a3 100644 (file)
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -1793,27 +1793,50 @@ char *fourcc_string(char *buf, char *end, const u32 *fourcc,
        char output[sizeof("0123 little-endian (0x01234567)")];
        char *p = output;
        unsigned int i;
+       bool pixel_fmt = false;
        u32 orig, val;
 
-       if (fmt[1] != 'c' || fmt[2] != 'c')
+       if (fmt[1] != 'c')
                return error_string(buf, end, "(%p4?)", spec);
 
        if (check_pointer(&buf, end, fourcc, spec))
                return buf;
 
        orig = get_unaligned(fourcc);
-       val = orig & ~BIT(31);
+       switch (fmt[2]) {
+       case 'h':
+               break;
+       case 'n':
+               orig = swab32(orig);
+               break;
+       case 'l':
+               orig = (__force u32)cpu_to_le32(orig);
+               break;
+       case 'b':
+               orig = (__force u32)cpu_to_be32(orig);
+               break;
+       case 'c':
+               /* Pixel formats are printed LSB-first */
+               pixel_fmt = true;
+               break;
+       default:
+               return error_string(buf, end, "(%p4?)", spec);
+       }
+
+       val = pixel_fmt ? swab32(orig & ~BIT(31)) : orig;
 
        for (i = 0; i < sizeof(u32); i++) {
-               unsigned char c = val >> (i * 8);
+               unsigned char c = val >> ((3 - i) * 8);
 
                /* Print non-control ASCII characters as-is, dot otherwise */
                *p++ = isascii(c) && isprint(c) ? c : '.';
        }
 
-       *p++ = ' ';
-       strcpy(p, orig & BIT(31) ? "big-endian" : "little-endian");
-       p += strlen(p);
+       if (pixel_fmt) {
+               *p++ = ' ';
+               strcpy(p, orig & BIT(31) ? "big-endian" : "little-endian");
+               p += strlen(p);
+       }
 
        *p++ = ' ';
        *p++ = '(';

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 3d22bf863eec9edf0c2fe7ad7a8986d7e8ad892a..44e233b6f428ac26a121a063a396500e001ff5e4 100755 (executable)
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -6891,7 +6891,7 @@ sub process {
                                            ($extension eq "f" &&
                                             defined $qualifier && $qualifier !~ /^w/) ||
                                            ($extension eq "4" &&
-                                            defined $qualifier && $qualifier !~ /^cc/)) {
+                                            defined $qualifier && $qualifier !~ /^c[hnlbc]/)) {
                                                $bad_specifier = $specifier;
                                                last;
                                        }