tracing: Fix test_event_printk() to process entire print argument

The test_event_printk() analyzes print formats of trace events looking for
cases where it may dereference a pointer that is not in the ring buffer
which can possibly be a bug when the trace event is read from the ring
buffer and the content of that pointer no longer exists.

The function needs to accurately go from one print format argument to the
next. It handles quotes and parenthesis that may be included in an
argument. When it finds the start of the next argument, it uses a simple
"c = strstr(fmt + i, ',')" to find the end of that argument!

In order to include "%s" dereferencing, it needs to process the entire
content of the print format argument and not just the content of the first
',' it finds. As there may be content like:

 ({ const char *saved_ptr = trace_seq_buffer_ptr(p); static const char
   *access_str[] = { "---", "--x", "w--", "w-x", "-u-", "-ux", "wu-", "wux"
   }; union kvm_mmu_page_role role; role.word = REC->role;
   trace_seq_printf(p, "sp gen %u gfn %llx l%u %u-byte q%u%s %s%s" " %snxe
   %sad root %u %s%c", REC->mmu_valid_gen, REC->gfn, role.level,
   role.has_4_byte_gpte ? 4 : 8, role.quadrant, role.direct ? " direct" : "",
   access_str[role.access], role.invalid ? " invalid" : "", role.efer_nx ? ""
   : "!", role.ad_disabled ? "!" : "", REC->root_count, REC->unsync ?
   "unsync" : "sync", 0); saved_ptr; })

Which is an example of a full argument of an existing event. As the code
already handles finding the next print format argument, process the
argument at the end of it and not the start of it. This way it has both
the start of the argument as well as the end of it.

Add a helper function "process_pointer()" that will do the processing during
the loop as well as at the end. It also makes the code cleaner and easier
to read.

Cc: stable@vger.kernel.org
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: https://lore.kernel.org/20241217024720.362271189@goodmis.org
Fixes: 5013f454a352c ("tracing: Add check of trace event print fmts for dereferencing pointers")
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 77e68efbd43e279ec1d136295041d472de440044..14e160a5b9054ac526bd1f73ef4577dccba71d54 100644 (file)
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -265,8 +265,7 @@ static bool test_field(const char *fmt, struct trace_event_call *call)
        len = p - fmt;
 
        for (; field->type; field++) {
-               if (strncmp(field->name, fmt, len) ||
-                   field->name[len])
+               if (strncmp(field->name, fmt, len) || field->name[len])
                        continue;
                array_descriptor = strchr(field->type, '[');
                /* This is an array and is OK to dereference. */
@@ -275,6 +274,32 @@ static bool test_field(const char *fmt, struct trace_event_call *call)
        return false;
 }
 
+/* Return true if the argument pointer is safe */
+static bool process_pointer(const char *fmt, int len, struct trace_event_call *call)
+{
+       const char *r, *e, *a;
+
+       e = fmt + len;
+
+       /* Find the REC-> in the argument */
+       r = strstr(fmt, "REC->");
+       if (r && r < e) {
+               /*
+                * Addresses of events on the buffer, or an array on the buffer is
+                * OK to dereference. There's ways to fool this, but
+                * this is to catch common mistakes, not malicious code.
+                */
+               a = strchr(fmt, '&');
+               if ((a && (a < r)) || test_field(r, call))
+                       return true;
+       } else if ((r = strstr(fmt, "__get_dynamic_array(")) && r < e) {
+               return true;
+       } else if ((r = strstr(fmt, "__get_sockaddr(")) && r < e) {
+               return true;
+       }
+       return false;
+}
+
 /*
  * Examine the print fmt of the event looking for unsafe dereference
  * pointers using %p* that could be recorded in the trace event and
@@ -285,12 +310,12 @@ static void test_event_printk(struct trace_event_call *call)
 {
        u64 dereference_flags = 0;
        bool first = true;
-       const char *fmt, *c, *r, *a;
+       const char *fmt;
        int parens = 0;
        char in_quote = 0;
        int start_arg = 0;
        int arg = 0;
-       int i;
+       int i, e;
 
        fmt = call->print_fmt;
 
@@ -403,42 +428,41 @@ static void test_event_printk(struct trace_event_call *call)
                case ',':
                        if (in_quote || parens)
                                continue;
+                       e = i;
                        i++;
                        while (isspace(fmt[i]))
                                i++;
-                       start_arg = i;
-                       if (!(dereference_flags & (1ULL << arg)))
-                               goto next_arg;
 
-                       /* Find the REC-> in the argument */
-                       c = strchr(fmt + i, ',');
-                       r = strstr(fmt + i, "REC->");
-                       if (r && (!c || r < c)) {
-                               /*
-                                * Addresses of events on the buffer,
-                                * or an array on the buffer is
-                                * OK to dereference.
-                                * There's ways to fool this, but
-                                * this is to catch common mistakes,
-                                * not malicious code.
-                                */
-                               a = strchr(fmt + i, '&');
-                               if ((a && (a < r)) || test_field(r, call))
+                       /*
+                        * If start_arg is zero, then this is the start of the
+                        * first argument. The processing of the argument happens
+                        * when the end of the argument is found, as it needs to
+                        * handle paranthesis and such.
+                        */
+                       if (!start_arg) {
+                               start_arg = i;
+                               /* Balance out the i++ in the for loop */
+                               i--;
+                               continue;
+                       }
+
+                       if (dereference_flags & (1ULL << arg)) {
+                               if (process_pointer(fmt + start_arg, e - start_arg, call))
                                        dereference_flags &= ~(1ULL << arg);
-                       } else if ((r = strstr(fmt + i, "__get_dynamic_array(")) &&
-                                  (!c || r < c)) {
-                               dereference_flags &= ~(1ULL << arg);
-                       } else if ((r = strstr(fmt + i, "__get_sockaddr(")) &&
-                                  (!c || r < c)) {
-                               dereference_flags &= ~(1ULL << arg);
                        }
 
-               next_arg:
-                       i--;
+                       start_arg = i;
                        arg++;
+                       /* Balance out the i++ in the for loop */
+                       i--;
                }
        }
 
+       if (dereference_flags & (1ULL << arg)) {
+               if (process_pointer(fmt + start_arg, i - start_arg, call))
+                       dereference_flags &= ~(1ULL << arg);
+       }
+
        /*
         * If you triggered the below warning, the trace event reported
         * uses an unsafe dereference pointer %p*. As the data stored