vsprintf: Do not have bprintf dereference pointers

When trace_printk() was introduced, it was discussed that making it be as
low overhead as possible, that the processing of the format string should be
delayed until it is read. That is, a "trace_printk()" should not convert
the %d into numbers and so on, but instead, save the fmt string and all the
args in the buffer at the time of recording. When the trace_printk() data is
read, it would then parse the format string and do the conversions of the
saved arguments in the tracing buffer.

The code to perform this was added to vsprintf where vbin_printf() would
save the arguments of a specified format string in a buffer, then
bstr_printf() could be used to convert the buffer with the same format
string into the final output, as if vsprintf() was called in one go.

The issue arises when dereferenced pointers are used. The problem is that
something like %*pbl which reads a bitmask, will save the pointer to the
bitmask in the buffer. Then the reading of the buffer via bstr_printf() will
then look at the pointer to process the final output. Obviously the value of
that pointer could have changed since the time it was recorded to the time
the buffer is read. Worse yet, the bitmask could be unmapped, and the
reading of the trace buffer could actually cause a kernel oops.

Another problem is that user space tools such as perf and trace-cmd do not
have access to the contents of these pointers, and they become useless when
the tracing buffer is extracted.

Instead of having vbin_printf() simply save the pointer in the buffer for
later processing, have it perform the formatting at the time bin_printf() is
called. This will fix the issue of dereferencing pointers at a later time,
and has the extra benefit of having user space tools understand these
values.

Since perf and trace-cmd already can handle %p[sSfF] via saving kallsyms,
their pointers are saved and not processed during vbin_printf(). If they
were converted, it would break perf and trace-cmd, as they would not know
how to deal with the conversion.

Link: http://lkml.kernel.org/r/20171228204025.14a71d8f@gandalf.local.home
Reported-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>

diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 01c3957b2de621ae21fed6162058c37f801ff526..c0c3542d92faf6823c75098bbeab73b2adec2d07 100644 (file)
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -2516,29 +2516,34 @@ int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
 {
        struct printf_spec spec = {0};
        char *str, *end;
+       int width;
 
        str = (char *)bin_buf;
        end = (char *)(bin_buf + size);
 
 #define save_arg(type)                                                 \
-do {                                                                   \
+({                                                                     \
+       unsigned long long value;                                       \
        if (sizeof(type) == 8) {                                        \
-               unsigned long long value;                               \
+               unsigned long long val8;                                \
                str = PTR_ALIGN(str, sizeof(u32));                      \
-               value = va_arg(args, unsigned long long);               \
+               val8 = va_arg(args, unsigned long long);                \
                if (str + sizeof(type) <= end) {                        \
-                       *(u32 *)str = *(u32 *)&value;                   \
-                       *(u32 *)(str + 4) = *((u32 *)&value + 1);       \
+                       *(u32 *)str = *(u32 *)&val8;                    \
+                       *(u32 *)(str + 4) = *((u32 *)&val8 + 1);        \
                }                                                       \
+               value = val8;                                           \
        } else {                                                        \
-               unsigned long value;                                    \
+               unsigned int val4;                                      \
                str = PTR_ALIGN(str, sizeof(type));                     \
-               value = va_arg(args, int);                              \
+               val4 = va_arg(args, int);                               \
                if (str + sizeof(type) <= end)                          \
-                       *(typeof(type) *)str = (type)value;             \
+                       *(typeof(type) *)str = (type)(long)val4;        \
+               value = (unsigned long long)val4;                       \
        }                                                               \
        str += sizeof(type);                                            \
-} while (0)
+       value;                                                          \
+})
 
        while (*fmt) {
                int read = format_decode(fmt, &spec);
@@ -2554,7 +2559,10 @@ do {                                                                     \
 
                case FORMAT_TYPE_WIDTH:
                case FORMAT_TYPE_PRECISION:
-                       save_arg(int);
+                       width = (int)save_arg(int);
+                       /* Pointers may require the width */
+                       if (*fmt == 'p')
+                               set_field_width(&spec, width);
                        break;
 
                case FORMAT_TYPE_CHAR:
@@ -2576,7 +2584,27 @@ do {                                                                     \
                }
 
                case FORMAT_TYPE_PTR:
-                       save_arg(void *);
+                       /* Dereferenced pointers must be done now */
+                       switch (*fmt) {
+                       /* Dereference of functions is still OK */
+                       case 'S':
+                       case 's':
+                       case 'F':
+                       case 'f':
+                               save_arg(void *);
+                               break;
+                       default:
+                               if (!isalnum(*fmt)) {
+                                       save_arg(void *);
+                                       break;
+                               }
+                               str = pointer(fmt, str, end, va_arg(args, void *),
+                                             spec);
+                               if (str + 1 < end)
+                                       *str++ = '\0';
+                               else
+                                       end[-1] = '\0'; /* Must be nul terminated */
+                       }
                        /* skip all alphanumeric pointer suffixes */
                        while (isalnum(*fmt))
                                fmt++;
@@ -2728,11 +2756,39 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
                        break;
                }
 
-               case FORMAT_TYPE_PTR:
-                       str = pointer(fmt, str, end, get_arg(void *), spec);
+               case FORMAT_TYPE_PTR: {
+                       bool process = false;
+                       int copy, len;
+                       /* Non function dereferences were already done */
+                       switch (*fmt) {
+                       case 'S':
+                       case 's':
+                       case 'F':
+                       case 'f':
+                               process = true;
+                               break;
+                       default:
+                               if (!isalnum(*fmt)) {
+                                       process = true;
+                                       break;
+                               }
+                               /* Pointer dereference was already processed */
+                               if (str < end) {
+                                       len = copy = strlen(args);
+                                       if (copy > end - str)
+                                               copy = end - str;
+                                       memcpy(str, args, copy);
+                                       str += len;
+                                       args += len;
+                               }
+                       }
+                       if (process)
+                               str = pointer(fmt, str, end, get_arg(void *), spec);
+
                        while (isalnum(*fmt))
                                fmt++;
                        break;
+               }
 
                case FORMAT_TYPE_PERCENT_CHAR:
                        if (str < end)