tracing: Add ustring operation to filtering string pointers

Since referencing user space pointers is special, if the user wants to
filter on a field that is a pointer to user space, then they need to
specify it.

Add a ".ustring" attribute to the field name for filters to state that the
field is pointing to user space such that the kernel can take the
appropriate action to read that pointer.

Link: https://lore.kernel.org/all/yt9d8rvmt2jq.fsf@linux.ibm.com/
Fixes: 77360f9bbc7e ("tracing: Add test for user space strings when filtering on string pointers")
Tested-by: Sven Schnelle <svens@linux.ibm.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

diff --git a/Documentation/trace/events.rst b/Documentation/trace/events.rst
index 45e66a60a816a916bdc460064bb666189b5c41e9..c47f381d0c00252b3e9993c9a784bb2f39a8b089 100644 (file)
--- a/Documentation/trace/events.rst
+++ b/Documentation/trace/events.rst
@@ -198,6 +198,15 @@ The glob (~) accepts a wild card character (\*,?) and character classes
   prev_comm ~ "*sh*"
   prev_comm ~ "ba*sh"
 
+If the field is a pointer that points into user space (for example
+"filename" from sys_enter_openat), then you have to append ".ustring" to the
+field name::
+
+  filename.ustring ~ "password"
+
+As the kernel will have to know how to retrieve the memory that the pointer
+is at from user space.
+
 5.2 Setting filters
 -------------------
 

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 2e9ef64e9ee9ffb8f578eea5e1ec72dab5dba83a..b458a9afa2c00ef73bd826335e2bc5ee3d4d22bf 100644 (file)
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -665,6 +665,23 @@ struct ustring_buffer {
 static __percpu struct ustring_buffer *ustring_per_cpu;
 
 static __always_inline char *test_string(char *str)
+{
+       struct ustring_buffer *ubuf;
+       char *kstr;
+
+       if (!ustring_per_cpu)
+               return NULL;
+
+       ubuf = this_cpu_ptr(ustring_per_cpu);
+       kstr = ubuf->buffer;
+
+       /* For safety, do not trust the string pointer */
+       if (!strncpy_from_kernel_nofault(kstr, str, USTRING_BUF_SIZE))
+               return NULL;
+       return kstr;
+}
+
+static __always_inline char *test_ustring(char *str)
 {
        struct ustring_buffer *ubuf;
        char __user *ustr;
@@ -676,23 +693,11 @@ static __always_inline char *test_string(char *str)
        ubuf = this_cpu_ptr(ustring_per_cpu);
        kstr = ubuf->buffer;
 
-       /*
-        * We use TASK_SIZE to denote user or kernel space, but this will
-        * not work for all architectures. If it picks the wrong one, it may
-        * just fail the filter (but will not bug).
-        *
-        * TODO: Have a way to properly denote which one this is for.
-        */
-       if (likely((unsigned long)str >= TASK_SIZE)) {
-               /* For safety, do not trust the string pointer */
-               if (!strncpy_from_kernel_nofault(kstr, str, USTRING_BUF_SIZE))
-                       return NULL;
-       } else {
-               /* user space address? */
-               ustr = (char __user *)str;
-               if (!strncpy_from_user_nofault(kstr, ustr, USTRING_BUF_SIZE))
-                       return NULL;
-       }
+       /* user space address? */
+       ustr = (char __user *)str;
+       if (!strncpy_from_user_nofault(kstr, ustr, USTRING_BUF_SIZE))
+               return NULL;
+
        return kstr;
 }
 
@@ -709,24 +714,42 @@ static int filter_pred_string(struct filter_pred *pred, void *event)
        return match;
 }
 
+static __always_inline int filter_pchar(struct filter_pred *pred, char *str)
+{
+       int cmp, match;
+       int len;
+
+       len = strlen(str) + 1;  /* including tailing '\0' */
+       cmp = pred->regex.match(str, &pred->regex, len);
+
+       match = cmp ^ pred->not;
+
+       return match;
+}
 /* Filter predicate for char * pointers */
 static int filter_pred_pchar(struct filter_pred *pred, void *event)
 {
        char **addr = (char **)(event + pred->offset);
        char *str;
-       int cmp, match;
-       int len;
 
        str = test_string(*addr);
        if (!str)
                return 0;
 
-       len = strlen(str) + 1;  /* including tailing '\0' */
-       cmp = pred->regex.match(str, &pred->regex, len);
+       return filter_pchar(pred, str);
+}
 
-       match = cmp ^ pred->not;
+/* Filter predicate for char * pointers in user space*/
+static int filter_pred_pchar_user(struct filter_pred *pred, void *event)
+{
+       char **addr = (char **)(event + pred->offset);
+       char *str;
 
-       return match;
+       str = test_ustring(*addr);
+       if (!str)
+               return 0;
+
+       return filter_pchar(pred, str);
 }
 
 /*
@@ -1232,6 +1255,7 @@ static int parse_pred(const char *str, void *data,
        struct filter_pred *pred = NULL;
        char num_buf[24];       /* Big enough to hold an address */
        char *field_name;
+       bool ustring = false;
        char q;
        u64 val;
        int len;
@@ -1266,6 +1290,12 @@ static int parse_pred(const char *str, void *data,
                return -EINVAL;
        }
 
+       /* See if the field is a user space string */
+       if ((len = str_has_prefix(str + i, ".ustring"))) {
+               ustring = true;
+               i += len;
+       }
+
        while (isspace(str[i]))
                i++;
 
@@ -1405,7 +1435,10 @@ static int parse_pred(const char *str, void *data,
                                        goto err_mem;
                        }
 
-                       pred->fn = filter_pred_pchar;
+                       if (ustring)
+                               pred->fn = filter_pred_pchar_user;
+                       else
+                               pred->fn = filter_pred_pchar;
                }
                /* go past the last quote */
                i++;