lkml.org 
[lkml]   [2020]   [Apr]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
SubjectRe: [RESEND PATCH v3 1/1] lib/vsprintf: Add support for printing V4L2 and DRM fourccs
From
Date
On 27/04/2020 16.53, Sakari Ailus wrote:
> 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.
>
> Suggested-by: Mauro Carvalho Chehab <mchehab@kernel.org>
> Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
> ---
> 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(+)
>
> diff --git a/Documentation/core-api/printk-formats.rst b/Documentation/core-api/printk-formats.rst
> index 8ebe46b1af39..7aa0451e06fb 100644
> --- a/Documentation/core-api/printk-formats.rst
> +++ b/Documentation/core-api/printk-formats.rst
> @@ -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
> ======
>
> diff --git a/lib/test_printf.c b/lib/test_printf.c
> index 2d9f520d2f27..a14754086707 100644
> --- a/lib/test_printf.c
> +++ b/lib/test_printf.c
> @@ -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)
> diff --git a/lib/vsprintf.c b/lib/vsprintf.c
> index 7c488a1ce318..02e7906619c0 100644
> --- a/lib/vsprintf.c
> +++ b/lib/vsprintf.c
> @@ -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,
> + };
> + 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 ...

> + if (check_pointer(&buf, end, __fourcc, spec))
> + return buf;

.. and then sanity check it?

> + 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()?

> + 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?

> + 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 [*])

> + *s = '(';
> + s++;
> + s = number(s, s + 2, c, my_spec);

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

> + *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 [**]

> + *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?

> + s += sizeof(u32) * 2 + 2 /* 0x */;

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

> + *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

\
 
 \ /
  Last update: 2020-04-27 17:44    [W:0.063 / U:3.312 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site