Skip to contentSkip to conversation

lib/vsprintf: Add support for printing V4L2 and DRM fourccs

PATCH RESEND Superseded Sakari Ailus 4 participants 6 messages Apr 27, 2020 – Nov 3, 2020

Subsystems (4)

v3 of 9 Superseded Latest is v9 →

lore
Share & tools
lore
#0 lore raw

PATCH RESEND v3 1/1 lib/vsprintf: Add support for printing V4L2 and DRM fourccs

Add a printk modifier %p4cc (for pixel format) for printing V4L2 and DRM pixel formats denoted by fourccs. The fourcc encoding is the same for both so the same implementation can be used.

---
since v2:

- Add comments to explain why things are being done

- Print characters under 32 (space) as hexadecimals in parenthesis.

- Do not print spaces in the fourcc codes.

- Make use of a loop over the fourcc characters instead of put_unaligned_le32(). This is necessary to omit spaces in the output.

- Use DRM style format instead of V4L2. This provides the precise code as a numerical value as well as explicit endianness information.

- Added WARN_ON_ONCE() sanity checks. Comments on these are welcome; I'd expect them mostly be covered by the tests.

- Added tests for %p4cc in lib/test_printf.c

 Documentation/core-api/printk-formats.rst | 12 ++++
 lib/test_printf.c                         | 17 +++++
 lib/vsprintf.c                            | 86 +++++++++++++++++++++++
 3 files changed, 115 insertions(+)
Documentation/core-api/printk-formats.rst +12 -0
index 8ebe46b1af39..7aa0451e06fb 100644
@@ -545,6 +545,18 @@ For printing netdev_features_t.
 
 Passed by reference.
 
+V4L2 and DRM FourCC code (pixel format)
+---------------------------------------
+
+::
+
+	%p4cc
+
+Print a FourCC code used by V4L2 or DRM, including format endianness and
+its numerical value as hexadecimal.
+
+Passed by reference.
+
 Thanks
 ======
 
lib/test_printf.c +17 -0
index 2d9f520d2f27..a14754086707 100644
@@ -624,6 +624,22 @@ static void __init fwnode_pointer(void)
 	software_node_unregister_nodes(softnodes);
 }
 
+static void __init fourcc_pointer(void)
+{
+	struct {
+		u32 code;
+		char *str;
+	} const try[] = {
+		{ 0x20104646, "FF(10) little-endian (0x20104646)", },
+		{ 0xa0104646, "FF(10) big-endian (0xa0104646)", },
+		{ 0x10111213, "(13)(12)(11)(10) little-endian (0x10111213)", },
+	};
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(try); i++)
+		test(try[i].str, "%p4cc", &try[i].code);
+}
+
 static void __init
 errptr(void)
 {
@@ -668,6 +684,7 @@ test_pointer(void)
 	flags();
 	errptr();
 	fwnode_pointer();
+	fourcc_pointer();
 }
 
 static void __init selftest(void)
lib/vsprintf.c +86 -0

104 lines not on this page · raw message

Signature · 1 line
2.20.1
#1 lore raw
Quoted 3 lines · Sakari Ailus

Add a printk modifier %p4cc (for pixel format) for printing V4L2 and DRM pixel formats denoted by fourccs. The fourcc encoding is the same for both so the same implementation can be used.

4cc is more generic than pixel format.

...

Documentation/core-api/printk-formats.rst For printing netdev_features_t. · line 553

Quoted 6 lines
Documentation/core-api/printk-formats.rst +6 -0
+V4L2 and DRM FourCC code (pixel format)
+---------------------------------------
+
+::
+
+	%p4cc

Missed examples.

Quoted 2 lines
Documentation/core-api/printk-formats.rst +2 -0
+Print a FourCC code used by V4L2 or DRM, including format endianness and
+its numerical value as hexadecimal.

...

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1731

Quoted 8 lines
lib/vsprintf.c +8 -0
+static noinline_for_stack
+char *fourcc_string(char *buf, char *end, const u32 *__fourcc,
+		    struct printf_spec spec, const char *fmt)
+{
+#define FOURCC_HEX_CHAR_STR		"(xx)"
+#define FOURCC_BIG_ENDIAN_STR		" big-endian"
+#define FOURCC_LITTLE_ENDIAN_STR	" little-endian"
+#define FOURCC_HEX_NUMBER		" (0x01234567)"

Where are #undef:s?

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1741

Quoted 11 lines
lib/vsprintf.c +10 -0
+#define FOURCC_STRING_MAX						\
+	FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR	\
+	FOURCC_HEX_CHAR_STR FOURCC_LITTLE_ENDIAN_STR FOURCC_HEX_NUMBER
 
+	struct printf_spec my_spec = {
+		.type = FORMAT_TYPE_UINT,
+		.field_width = 2,
+		.flags = SMALL,
+		.base = 16,
+		.precision = -1,
+	};

Seems like close enough to bus_spec.

Quoted 22 lines
lib/vsprintf.c +22 -0
+	char __s[sizeof(FOURCC_STRING_MAX)];
+	char *s = __s;
+	unsigned int i;
+	/*
+	 * The 31st bit defines the endianness of the data, so save its printing
+	 * for later.
+	 */
+	u32 fourcc = *__fourcc & ~BIT(31);
+	int ret;
+
+	if (check_pointer(&buf, end, __fourcc, spec))
+		return buf;
+
+	if (fmt[1] != 'c' || fmt[2] != 'c')
+		return error_string(buf, end, "(%p4?)", spec);
+
+	for (i = 0; i < sizeof(fourcc); i++, fourcc >>= 8) {
+		unsigned char c = fourcc;
+
+		/* Weed out spaces */
+		if (c == ' ')
+			continue;

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1773

Quoted 10 lines
lib/vsprintf.c +9 -0
+
+		/* Print non-control characters as-is */
+		if (c > ' ') {
+			*s = c;
+			s++;
+			continue;
+		}
 
+		if (WARN_ON_ONCE(sizeof(__s) <
+				 (s - __s) + sizeof(FOURCC_HEX_CHAR_STR)))

Why WARN?!

Quoted 4 lines
lib/vsprintf.c +4 -0
+			break;
+
+		*s = '(';
+		s++;

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1786

Quoted 10 lines
lib/vsprintf.c +9 -0
+		s = number(s, s + 2, c, my_spec);
+		*s = ')';
+		s++;
+	}
+
+	ret = strscpy(s, *__fourcc & BIT(31) ? FOURCC_BIG_ENDIAN_STR
+					     : FOURCC_LITTLE_ENDIAN_STR,
+		      sizeof(__s) - (s - __s));
 
+	if (!WARN_ON_ONCE(ret < 0))

Ditto.

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1790

Quoted 4 lines
lib/vsprintf.c +3 -0
+		s += ret;
 
+	if (!WARN_ON_ONCE(sizeof(__s) <
+			  (s - __s) + sizeof(FOURCC_HEX_NUMBER))) {

Ditto.

Quoted 4 lines
lib/vsprintf.c +4 -0
+		*s = ' ';
+		s++;
+		*s = '(';
+		s++;

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1804

Quoted 10 lines
lib/vsprintf.c +10 -0
+		/* subtract parentheses and the space from the size */
+		special_hex_number(s, s + sizeof(FOURCC_HEX_NUMBER) - 3,
+				   *__fourcc, sizeof(u32));
+		s += sizeof(u32) * 2 + 2 /* 0x */;
+		*s = ')';
+		s++;
+		*s = '\0';
+	}
+
+	return string(buf, end, __s, spec);

This looks overengineered. Why everyone will need so long strings to be printed?

Quoted 1 line

+}

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#2 lore raw
In reply to Sakari Ailus
Quoted 114 lines · Sakari Ailus

Add a printk modifier %p4cc (for pixel format) for printing V4L2 and DRM pixel formats denoted by fourccs. The fourcc encoding is the same for both so the same implementation can be used.

---
since v2:

- Add comments to explain why things are being done

- Print characters under 32 (space) as hexadecimals in parenthesis.

- Do not print spaces in the fourcc codes.

- Make use of a loop over the fourcc characters instead of put_unaligned_le32(). This is necessary to omit spaces in the output.

- Use DRM style format instead of V4L2. This provides the precise code as a numerical value as well as explicit endianness information.

- Added WARN_ON_ONCE() sanity checks. Comments on these are welcome; I'd expect them mostly be covered by the tests.

- Added tests for %p4cc in lib/test_printf.c

 Documentation/core-api/printk-formats.rst | 12 ++++
 lib/test_printf.c                         | 17 +++++
 lib/vsprintf.c                            | 86 +++++++++++++++++++++++
 3 files changed, 115 insertions(+)
Documentation/core-api/printk-formats.rst +12 -0
index 8ebe46b1af39..7aa0451e06fb 100644
@@ -545,6 +545,18 @@ For printing netdev_features_t.
 
 Passed by reference.
 
+V4L2 and DRM FourCC code (pixel format)
+---------------------------------------
+
+::
+
+	%p4cc
+
+Print a FourCC code used by V4L2 or DRM, including format endianness and
+its numerical value as hexadecimal.
+
+Passed by reference.
+
 Thanks
 ======
 
lib/test_printf.c +17 -0
index 2d9f520d2f27..a14754086707 100644
@@ -624,6 +624,22 @@ static void __init fwnode_pointer(void)
 	software_node_unregister_nodes(softnodes);
 }
 
+static void __init fourcc_pointer(void)
+{
+	struct {
+		u32 code;
+		char *str;
+	} const try[] = {
+		{ 0x20104646, "FF(10) little-endian (0x20104646)", },
+		{ 0xa0104646, "FF(10) big-endian (0xa0104646)", },
+		{ 0x10111213, "(13)(12)(11)(10) little-endian (0x10111213)", },
+	};
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(try); i++)
+		test(try[i].str, "%p4cc", &try[i].code);
+}
+
 static void __init
 errptr(void)
 {
@@ -668,6 +684,7 @@ test_pointer(void)
 	flags();
 	errptr();
 	fwnode_pointer();
+	fourcc_pointer();
 }
 
 static void __init selftest(void)
lib/vsprintf.c +17 -0
index 7c488a1ce318..02e7906619c0 100644
@@ -1721,6 +1721,89 @@ char *netdev_bits(char *buf, char *end, const void *addr,
 	return special_hex_number(buf, end, num, size);
 }
 
+static noinline_for_stack
+char *fourcc_string(char *buf, char *end, const u32 *__fourcc,
+		    struct printf_spec spec, const char *fmt)
+{
+#define FOURCC_HEX_CHAR_STR		"(xx)"
+#define FOURCC_BIG_ENDIAN_STR		" big-endian"
+#define FOURCC_LITTLE_ENDIAN_STR	" little-endian"
+#define FOURCC_HEX_NUMBER		" (0x01234567)"
+#define FOURCC_STRING_MAX						\
+	FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR	\
+	FOURCC_HEX_CHAR_STR FOURCC_LITTLE_ENDIAN_STR FOURCC_HEX_NUMBER
+	struct printf_spec my_spec = {
+		.type = FORMAT_TYPE_UINT,
+		.field_width = 2,
+		.flags = SMALL,
+		.base = 16,
+		.precision = -1,

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1750

Quoted 10 lines
lib/vsprintf.c +10 -0
+	};
+	char __s[sizeof(FOURCC_STRING_MAX)];
+	char *s = __s;
+	unsigned int i;
+	/*
+	 * The 31st bit defines the endianness of the data, so save its printing
+	 * for later.
+	 */
+	u32 fourcc = *__fourcc & ~BIT(31);
+	int ret;

Dereference __fourcc ...

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1753

Quoted 2 lines
lib/vsprintf.c +2 -0
+	if (check_pointer(&buf, end, __fourcc, spec))
+		return buf;

.. and then sanity check it?

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1756

Quoted 2 lines
lib/vsprintf.c +2 -0
+	if (fmt[1] != 'c' || fmt[2] != 'c')
+		return error_string(buf, end, "(%p4?)", spec);

Doesn't that want to come before everything else, including the check_pointer()?

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1770

Quoted 13 lines
lib/vsprintf.c +13 -0
+	for (i = 0; i < sizeof(fourcc); i++, fourcc >>= 8) {
+		unsigned char c = fourcc;
+
+		/* Weed out spaces */
+		if (c == ' ')
+			continue;
+
+		/* Print non-control characters as-is */
+		if (c > ' ') {
+			*s = c;
+			s++;
+			continue;
+		}

Are you sure you want to pass non-ascii characters through?

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1774

Quoted 3 lines
lib/vsprintf.c +3 -0
+		if (WARN_ON_ONCE(sizeof(__s) <
+				 (s - __s) + sizeof(FOURCC_HEX_CHAR_STR)))
+			break;

I really don't see the point of these checks. Why check here but not before we output a non-control character? That seems rather arbitrary. Also, assume we do take this break, (to be continued below [*])

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1778

Quoted 3 lines
lib/vsprintf.c +3 -0
+		*s = '(';
+		s++;
+		s = number(s, s + 2, c, my_spec);

You can drop my_spec and just use "s = hex_byte_pack(s, c);".

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1790

Quoted 12 lines
lib/vsprintf.c +12 -0
+		*s = ')';
+		s++;
+	}
+
+	ret = strscpy(s, *__fourcc & BIT(31) ? FOURCC_BIG_ENDIAN_STR
+					     : FOURCC_LITTLE_ENDIAN_STR,
+		      sizeof(__s) - (s - __s));
+	if (!WARN_ON_ONCE(ret < 0))
+		s += ret;
+
+	if (!WARN_ON_ONCE(sizeof(__s) <
+			  (s - __s) + sizeof(FOURCC_HEX_NUMBER))) {

[*] then AFAICT this WARN_ON_ONCE is guaranteed to also fire [the left-hand side is the same as before, the right-hand side consists of a quantity s-__s that can only be larger or equal than before and a constant sizeof(FOURCC_HEX_NUMBER) that is definitely larger], hence we do not enter this if () and [**]

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1797

Quoted 7 lines
lib/vsprintf.c +7 -0
+		*s = ' ';
+		s++;
+		*s = '(';
+		s++;
+		/* subtract parentheses and the space from the size */
+		special_hex_number(s, s + sizeof(FOURCC_HEX_NUMBER) - 3,
+				   *__fourcc, sizeof(u32));

Urgh. Don't we have an ARRAY_END() macro that let's you call this with (s, ARRAY_END(__s)) as buf, end?

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1798

Quoted 1 line
lib/vsprintf.c +1 -0
+		s += sizeof(u32) * 2 + 2 /* 0x */;

Why, when special_hex_number returns a pointer to one-past-its-output?

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1804

Quoted 6 lines
lib/vsprintf.c +6 -0
+		*s = ')';
+		s++;
+		*s = '\0';
+	}
+
+	return string(buf, end, __s, spec);

[**] __s does not get nul-terminated, so we call string() with stack garbage.

I'd say just drop those checks, and de-obfuscate the sizing of the __s array so it becomes obviously large enough for what the algorithm can produce. Just

char __s[sizeof("(01)(02)(03)(04) little-endian (0x01020304)")]

or something like that should be sufficient.

Rasmus

#3 lore raw

Hi Rasmus,

Thanks for the review.

Quoted 133 lines · Rasmus Villemoes
Quoted 114 lines · Sakari Ailus

Add a printk modifier %p4cc (for pixel format) for printing V4L2 and DRM pixel formats denoted by fourccs. The fourcc encoding is the same for both so the same implementation can be used.

---
since v2:

- Add comments to explain why things are being done

- Print characters under 32 (space) as hexadecimals in parenthesis.

- Do not print spaces in the fourcc codes.

- Make use of a loop over the fourcc characters instead of put_unaligned_le32(). This is necessary to omit spaces in the output.

- Use DRM style format instead of V4L2. This provides the precise code as a numerical value as well as explicit endianness information.

- Added WARN_ON_ONCE() sanity checks. Comments on these are welcome; I'd expect them mostly be covered by the tests.

- Added tests for %p4cc in lib/test_printf.c

 Documentation/core-api/printk-formats.rst | 12 ++++
 lib/test_printf.c                         | 17 +++++
 lib/vsprintf.c                            | 86 +++++++++++++++++++++++
 3 files changed, 115 insertions(+)
Documentation/core-api/printk-formats.rst +12 -0
index 8ebe46b1af39..7aa0451e06fb 100644
@@ -545,6 +545,18 @@ For printing netdev_features_t.
 
 Passed by reference.
 
+V4L2 and DRM FourCC code (pixel format)
+---------------------------------------
+
+::
+
+	%p4cc
+
+Print a FourCC code used by V4L2 or DRM, including format endianness and
+its numerical value as hexadecimal.
+
+Passed by reference.
+
 Thanks
 ======
 
lib/test_printf.c +17 -0
index 2d9f520d2f27..a14754086707 100644
@@ -624,6 +624,22 @@ static void __init fwnode_pointer(void)
 	software_node_unregister_nodes(softnodes);
 }
 
+static void __init fourcc_pointer(void)
+{
+	struct {
+		u32 code;
+		char *str;
+	} const try[] = {
+		{ 0x20104646, "FF(10) little-endian (0x20104646)", },
+		{ 0xa0104646, "FF(10) big-endian (0xa0104646)", },
+		{ 0x10111213, "(13)(12)(11)(10) little-endian (0x10111213)", },
+	};
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(try); i++)
+		test(try[i].str, "%p4cc", &try[i].code);
+}
+
 static void __init
 errptr(void)
 {
@@ -668,6 +684,7 @@ test_pointer(void)
 	flags();
 	errptr();
 	fwnode_pointer();
+	fourcc_pointer();
 }
 
 static void __init selftest(void)
lib/vsprintf.c +17 -0
index 7c488a1ce318..02e7906619c0 100644
@@ -1721,6 +1721,89 @@ char *netdev_bits(char *buf, char *end, const void *addr,
 	return special_hex_number(buf, end, num, size);
 }
 
+static noinline_for_stack
+char *fourcc_string(char *buf, char *end, const u32 *__fourcc,
+		    struct printf_spec spec, const char *fmt)
+{
+#define FOURCC_HEX_CHAR_STR		"(xx)"
+#define FOURCC_BIG_ENDIAN_STR		" big-endian"
+#define FOURCC_LITTLE_ENDIAN_STR	" little-endian"
+#define FOURCC_HEX_NUMBER		" (0x01234567)"
+#define FOURCC_STRING_MAX						\
+	FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR	\
+	FOURCC_HEX_CHAR_STR FOURCC_LITTLE_ENDIAN_STR FOURCC_HEX_NUMBER
+	struct printf_spec my_spec = {
+		.type = FORMAT_TYPE_UINT,
+		.field_width = 2,
+		.flags = SMALL,
+		.base = 16,
+		.precision = -1,

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1750

Quoted 10 lines
lib/vsprintf.c +10 -0
+	};
+	char __s[sizeof(FOURCC_STRING_MAX)];
+	char *s = __s;
+	unsigned int i;
+	/*
+	 * The 31st bit defines the endianness of the data, so save its printing
+	 * for later.
+	 */
+	u32 fourcc = *__fourcc & ~BIT(31);
+	int ret;

Dereference __fourcc ...

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1753

Quoted 2 lines
lib/vsprintf.c +2 -0
+	if (check_pointer(&buf, end, __fourcc, spec))
+		return buf;

.. and then sanity check it?

Quoted 5 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1756

Quoted 2 lines
lib/vsprintf.c +2 -0
+	if (fmt[1] != 'c' || fmt[2] != 'c')
+		return error_string(buf, end, "(%p4?)", spec);

Doesn't that want to come before everything else, including the check_pointer()?

Agreed on all three.

Quoted 16 lines
Quoted 4 lines
lib/vsprintf.c +3 -0
+	for (i = 0; i < sizeof(fourcc); i++, fourcc >>= 8) {
+		unsigned char c = fourcc;
+

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1770

Quoted 10 lines
lib/vsprintf.c +10 -0
+		/* Weed out spaces */
+		if (c == ' ')
+			continue;
+
+		/* Print non-control characters as-is */
+		if (c > ' ') {
+			*s = c;
+			s++;
+			continue;
+		}

Are you sure you want to pass non-ascii characters through?

I'll print the hexadecimal value in v4.

Quoted 8 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1774

Quoted 4 lines
lib/vsprintf.c +3 -0
+		if (WARN_ON_ONCE(sizeof(__s) <
+				 (s - __s) + sizeof(FOURCC_HEX_CHAR_STR)))
+			break;

I really don't see the point of these checks. Why check here but not before we output a non-control character? That seems rather arbitrary. Also, assume we do take this break, (to be continued below [*])

Will remove.

Quoted 6 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1778

Quoted 4 lines
lib/vsprintf.c +3 -0
+		*s = '(';
+		s++;
+		s = number(s, s + 2, c, my_spec);

You can drop my_spec and just use "s = hex_byte_pack(s, c);".

Ack, this cleans it up indeed.

Quoted 20 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1790

Quoted 13 lines
lib/vsprintf.c +12 -0
+		*s = ')';
+		s++;
+	}
+
+	ret = strscpy(s, *__fourcc & BIT(31) ? FOURCC_BIG_ENDIAN_STR
+					     : FOURCC_LITTLE_ENDIAN_STR,
+		      sizeof(__s) - (s - __s));
+	if (!WARN_ON_ONCE(ret < 0))
+		s += ret;
+
+	if (!WARN_ON_ONCE(sizeof(__s) <
+			  (s - __s) + sizeof(FOURCC_HEX_NUMBER))) {

[*] then AFAICT this WARN_ON_ONCE is guaranteed to also fire [the left-hand side is the same as before, the right-hand side consists of a quantity s-__s that can only be larger or equal than before and a constant sizeof(FOURCC_HEX_NUMBER) that is definitely larger], hence we do not enter this if () and [**]

Quoted 10 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1797

Quoted 7 lines
lib/vsprintf.c +7 -0
+		*s = ' ';
+		s++;
+		*s = '(';
+		s++;
+		/* subtract parentheses and the space from the size */
+		special_hex_number(s, s + sizeof(FOURCC_HEX_NUMBER) - 3,
+				   *__fourcc, sizeof(u32));

Urgh. Don't we have an ARRAY_END() macro that let's you call this with (s, ARRAY_END(__s)) as buf, end?

We do, yes. In drivers/block/floppy.c. :-)

Quoted 4 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1798

Quoted 2 lines
lib/vsprintf.c +1 -0
+		s += sizeof(u32) * 2 + 2 /* 0x */;

Why, when special_hex_number returns a pointer to one-past-its-output?

I'll use that for v4.

Quoted 11 lines

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1804

Quoted 7 lines
lib/vsprintf.c +6 -0
+		*s = ')';
+		s++;
+		*s = '\0';
+	}
+
+	return string(buf, end, __s, spec);

[**] __s does not get nul-terminated, so we call string() with stack garbage.

Quoted 7 lines

I'd say just drop those checks, and de-obfuscate the sizing of the __s array so it becomes obviously large enough for what the algorithm can produce. Just

char __s[sizeof("(01)(02)(03)(04) little-endian (0x01020304)")]

or something like that should be sufficient.

Done.

Signature · 7 lines
Kind regards,

Sakari Ailus
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#4 lore raw
In reply to Sakari Ailus
Quoted 3 lines · Sakari Ailus

Add a printk modifier %p4cc (for pixel format) for printing V4L2 and DRM pixel formats denoted by fourccs. The fourcc encoding is the same for both so the same implementation can be used.

[]

Quoted 2 lines

- Added WARN_ON_ONCE() sanity checks. Comments on these are welcome; I'd expect them mostly be covered by the tests.

All the WARN_ON_ONCE uses are not necessary.

lib/vsprintf.c

Quoted 1 line
lib/vsprintf.c +0 -0

[]

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1726

Quoted 7 lines
lib/vsprintf.c +3 -0
@@ -1721,6 +1721,89 @@ char *netdev_bits(char *buf, char *end, const void *addr,
 	return special_hex_number(buf, end, num, size);
 }
 
+static noinline_for_stack
+char *fourcc_string(char *buf, char *end, const u32 *__fourcc,
+		    struct printf_spec spec, const char *fmt)

There's no reason to use __ prefixed argument names here.

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1730

Quoted 4 lines
lib/vsprintf.c +4 -0
+{
+#define FOURCC_HEX_CHAR_STR		"(xx)"
+#define FOURCC_BIG_ENDIAN_STR		" big-endian"
+#define FOURCC_LITTLE_ENDIAN_STR	" little-endian"

I don't believe used-once macro defines are useful.

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1734

Quoted 5 lines
lib/vsprintf.c +4 -0
+#define FOURCC_HEX_NUMBER		" (0x01234567)"
 
+#define FOURCC_STRING_MAX						\
+	FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR FOURCC_HEX_CHAR_STR	\
+	FOURCC_HEX_CHAR_STR FOURCC_LITTLE_ENDIAN_STR FOURCC_HEX_NUMBER

This is very difficult to read and is size dependent on the size of little-endian > big_endian

I'd write it out

	FOURCC_STRING_MAX	sizeof("(xx)(xx)(xx)(xx) little-endian (0x01234567)")

and then not have the define at all but use
the written out string in the declaration.

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1741

Quoted 7 lines
lib/vsprintf.c +7 -0
+	struct printf_spec my_spec = {
+		.type = FORMAT_TYPE_UINT,
+		.field_width = 2,
+		.flags = SMALL,
+		.base = 16,
+		.precision = -1,
+	};

my_spec isn't usefully named, likely not necessary at all, and if really necessary, it should be static const

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1742

Quoted 1 line
lib/vsprintf.c +1 -0
+	char __s[sizeof(FOURCC_STRING_MAX)];

I'd declare the buffer

	char fourcc[sizeof("(xx)(xx)(xx)(xx) little-endian (0x01234567)"];

like all the other specialty functions do.

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1743

Quoted 1 line
lib/vsprintf.c +1 -0
+	char *s = __s;

There's no reason to use __ prefixed variable names here either. All the other specialty function use:

	char *p = <output_buffer_name>;

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1745

Quoted 1 line
lib/vsprintf.c +1 -0
+	unsigned int i;

just int i; is typical

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1749

Quoted 5 lines
lib/vsprintf.c +5 -0
+	/*
+	 * The 31st bit defines the endianness of the data, so save its printing
+	 * for later.
+	 */
+	u32 fourcc = *__fourcc & ~BIT(31);
	bool be = fourcc & BIT(31);

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr,

Quoted 10 lines
lib/vsprintf.c +10 -0
+	int ret;
+
+	if (check_pointer(&buf, end, __fourcc, spec))
+		return buf;
+
+	if (fmt[1] != 'c' || fmt[2] != 'c')
+		return error_string(buf, end, "(%p4?)", spec);
+
+	for (i = 0; i < sizeof(fourcc); i++, fourcc >>= 8) {
+		unsigned char c = fourcc >> (i*8);

Please remove the fourcc >>= 8 from the loop and use

		unsigned char c = fourcc >> (i*8);

If I understand this correctly, I think this is simpler:

		if (isascii(c) && isprint(c)) {
			*s++ = c;
		} else {
			*s++ = '(';
			s = hex_byte_pack(s, c);
			*s++ = ')';
		}
Quoted 16 lines
lib/vsprintf.c +16 -0
+
+		/* Weed out spaces */
+		if (c == ' ')
+			continue;
+
+		/* Print non-control characters as-is */
+		if (c > ' ') {
+			*s = c;
+			s++;
+			continue;
+		}
+
+		if (WARN_ON_ONCE(sizeof(__s) <
+				 (s - __s) + sizeof(FOURCC_HEX_CHAR_STR)))
+			break;
+

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1785

Quoted 10 lines
lib/vsprintf.c +10 -0
+		*s = '(';
+		s++;
+		s = number(s, s + 2, c, my_spec);
+		*s = ')';
+		s++;
+	}
+
+	ret = strscpy(s, *__fourcc & BIT(31) ? FOURCC_BIG_ENDIAN_STR
+					     : FOURCC_LITTLE_ENDIAN_STR,
+		      sizeof(__s) - (s - __s));

If you size the initial buffer correctly, strscpy is unnecessary.

	strcpy(s, <bit31> ? "big endian" : "little endian");
	s += strlen(s);

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1794

Quoted 9 lines
lib/vsprintf.c +9 -0
+	if (!WARN_ON_ONCE(ret < 0))
+		s += ret;
+
+	if (!WARN_ON_ONCE(sizeof(__s) <
+			  (s - __s) + sizeof(FOURCC_HEX_NUMBER))) {
+		*s = ' ';
+		s++;
+		*s = '(';
+		s++;
		*s++ = ' ';
		*s++ = '(';

+ /* subtract parentheses and the space from the size */

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr, · line 1800

Quoted 5 lines
lib/vsprintf.c +5 -0
+		special_hex_number(s, s + sizeof(FOURCC_HEX_NUMBER) - 3,
+				   *__fourcc, sizeof(u32));
+		s += sizeof(u32) * 2 + 2 /* 0x */;
+		*s = ')';
+		s++;
		*s++ = ')';

lib/vsprintf.c char *netdev_bits(char *buf, char *end, const void *addr,

Quoted 6 lines
lib/vsprintf.c +5 -0
+		*s = '\0';
+	}
+
+	return string(buf, end, __s, spec);
+}
 

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#5 lore raw
Quoted 7 lines · Joe Perches
Quoted 3 lines · Sakari Ailus

Add a printk modifier %p4cc (for pixel format) for printing V4L2 and DRM pixel formats denoted by fourccs. The fourcc encoding is the same for both so the same implementation can be used.

[]

Quoted 2 lines

- Added WARN_ON_ONCE() sanity checks. Comments on these are welcome; I'd expect them mostly be covered by the tests.

perhaps this is simpler?

---
 lib/vsprintf.c | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
lib/vsprintf.c +43 -0
index 7c488a..3e1dbd7 100644
@@ -1721,6 +1721,46 @@ char *netdev_bits(char *buf, char *end, const void *addr,
 	return special_hex_number(buf, end, num, size);
 }
 
+static noinline_for_stack
+char *fourcc_string(char *buf, char *end, const u32 *fourcc,
+		    struct printf_spec spec, const char *fmt)
+{
+	char output[sizeof("(xx)(xx)(xx)(xx) little-endian (0x01234567)")];
+	char *p = output;
+	int i;
+	u32 val;
+
+	if (check_pointer(&buf, end, fourcc, spec))
+		return buf;
+
+	if (fmt[1] != 'c' || fmt[2] != 'c')
+		return error_string(buf, end, "(%p4?)", spec);
+
+	val = *fourcc & ~BIT(31);
+
+	for (i = 0; i < 4; i++) {
+		unsigned char c = val >> (i * 8);
+
+		if (isascii(c) && isprint(c)) {
+			*p++ = c;
+		} else {
+			*p++ = '(';
+			p = hex_byte_pack(p, c);
+			*p++ = ')';
+		}
+	}
+
+	strcpy(p, *fourcc & BIT(31) ? "big endian" : "little endian");
+	p += strlen(p);
+	*p++ = ' ';
+	*p++ = '(';
+	p = special_hex_number(p, p + 10, val, 4);
+	*p++ = ')';
+	*p = 0;
+
+	return string(buf, end, output, spec);
+}
+
 static noinline_for_stack
 char *address_val(char *buf, char *end, const void *addr,
 		  struct printf_spec spec, const char *fmt)
@@ -2131,6 +2171,7 @@ char *fwnode_string(char *buf, char *end, struct fwnode_handle *fwnode,
  *       correctness of the format string and va_list arguments.
  * - 'K' For a kernel pointer that should be hidden from unprivileged users
  * - 'NF' For a netdev_features_t
+ * - '4cc' V4L2 or DRM FourCC code, with endianness and raw numerical value.
  * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
  *            a certain separator (' ' by default):
  *              C colon
@@ -2223,6 +2264,8 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
 		return restricted_pointer(buf, end, ptr, spec);
 	case 'N':
 		return netdev_bits(buf, end, ptr, spec, fmt);
+	case '4':
+		return fourcc_string(buf, end, ptr, spec, fmt);
 	case 'a':
 		return address_val(buf, end, ptr, spec, fmt);
 	case 'd':

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel