6 files changed, 132 insertions, 41 deletions

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 8ac204360a39..63dbc7ff213f 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -323,12 +323,21 @@ static const char *trace_options[] = {
         "printk-msg-only",
         "context-info",
         "latency-format",
-        "global-clock",
         "sleep-time",
         "graph-time",
         NULL
 };
 
+static struct {
+        u64 (*func)(void);
+        const char *name;
+} trace_clocks[] = {
+        { trace_clock_local,    "local" },
+        { trace_clock_global,   "global" },
+};
+
+int trace_clock_id;
+
 /*
  * ftrace_max_lock is used to protect the swapping of buffers
  * when taking a max snapshot. The buffers themselves are
@@ -2159,22 +2168,6 @@ static void set_tracer_flags(unsigned int mask, int enabled)
                 trace_flags |= mask;
         else
                 trace_flags &= ~mask;
-
-        if (mask == TRACE_ITER_GLOBAL_CLK) {
-                u64 (*func)(void);
-
-                if (enabled)
-                        func = trace_clock_global;
-                else
-                        func = trace_clock_local;
-
-                mutex_lock(&trace_types_lock);
-                ring_buffer_set_clock(global_trace.buffer, func);
-
-                if (max_tr.buffer)
-                        ring_buffer_set_clock(max_tr.buffer, func);
-                mutex_unlock(&trace_types_lock);
-        }
 }
 
 static ssize_t
@@ -3142,6 +3135,62 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
+static ssize_t tracing_clock_read(struct file *filp, char __user *ubuf,
+                                  size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        int bufiter = 0;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(trace_clocks); i++)
+                bufiter += snprintf(buf + bufiter, sizeof(buf) - bufiter,
+                        "%s%s%s%s", i ? " " : "",
+                        i == trace_clock_id ? "[" : "", trace_clocks[i].name,
+                        i == trace_clock_id ? "]" : "");
+        bufiter += snprintf(buf + bufiter, sizeof(buf) - bufiter, "\n");
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, bufiter);
+}
+
+static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf,
+                                   size_t cnt, loff_t *fpos)
+{
+        char buf[64];
+        const char *clockstr;
+        int i;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        clockstr = strstrip(buf);
+
+        for (i = 0; i < ARRAY_SIZE(trace_clocks); i++) {
+                if (strcmp(trace_clocks[i].name, clockstr) == 0)
+                        break;
+        }
+        if (i == ARRAY_SIZE(trace_clocks))
+                return -EINVAL;
+
+        trace_clock_id = i;
+
+        mutex_lock(&trace_types_lock);
+
+        ring_buffer_set_clock(global_trace.buffer, trace_clocks[i].func);
+        if (max_tr.buffer)
+                ring_buffer_set_clock(max_tr.buffer, trace_clocks[i].func);
+
+        mutex_unlock(&trace_types_lock);
+
+        *fpos += cnt;
+
+        return cnt;
+}
+
 static const struct file_operations tracing_max_lat_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_max_lat_read,
@@ -3179,6 +3228,12 @@ static const struct file_operations tracing_mark_fops = {
         .write          = tracing_mark_write,
 };
 
+static const struct file_operations trace_clock_fops = {
+        .open           = tracing_open_generic,
+        .read           = tracing_clock_read,
+        .write          = tracing_clock_write,
+};
+
 struct ftrace_buffer_info {
         struct trace_array      *tr;
         void                    *spare;
@@ -3918,6 +3973,9 @@ static __init int tracer_init_debugfs(void)
         trace_create_file("saved_cmdlines", 0444, d_tracer,
                         NULL, &tracing_saved_cmdlines_fops);
 
+        trace_create_file("trace_clock", 0644, d_tracer, NULL,
+                          &trace_clock_fops);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
         trace_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                         &ftrace_update_tot_cnt, &tracing_dyn_info_fops);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 300ef788c976..654fd657bd03 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -568,6 +568,8 @@ trace_vprintk(unsigned long ip, const char *fmt, va_list args);
 
 extern unsigned long trace_flags;
 
+extern int trace_clock_id;
+
 /* Standard output formatting function used for function return traces */
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 extern enum print_line_t print_graph_function(struct trace_iterator *iter);
@@ -656,9 +658,8 @@ enum trace_iterator_flags {
         TRACE_ITER_PRINTK_MSGONLY       = 0x10000,
         TRACE_ITER_CONTEXT_INFO         = 0x20000, /* Print pid/cpu/time */
         TRACE_ITER_LATENCY_FMT          = 0x40000,
-        TRACE_ITER_GLOBAL_CLK           = 0x80000,
-        TRACE_ITER_SLEEP_TIME           = 0x100000,
-        TRACE_ITER_GRAPH_TIME           = 0x200000,
+        TRACE_ITER_SLEEP_TIME           = 0x80000,
+        TRACE_ITER_GRAPH_TIME           = 0x100000,
 };
 
 /*
@@ -755,6 +756,7 @@ struct ftrace_event_field {
         struct list_head        link;
         char                    *name;
         char                    *type;
+        int                     filter_type;
         int                     offset;
         int                     size;
         int                     is_signed;
@@ -800,6 +802,7 @@ extern int apply_subsystem_event_filter(struct event_subsystem *system,
                                         char *filter_string);
 extern void print_subsystem_event_filter(struct event_subsystem *system,
                                          struct trace_seq *s);
+extern int filter_assign_type(const char *type);
 
 static inline int
 filter_check_discard(struct ftrace_event_call *call, void *rec,
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 79d352027a61..d33bcdeffe69 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -28,7 +28,8 @@ DEFINE_MUTEX(event_mutex);
 LIST_HEAD(ftrace_events);
 
 int trace_define_field(struct ftrace_event_call *call, const char *type,
-                       const char *name, int offset, int size, int is_signed)
+                       const char *name, int offset, int size, int is_signed,
+                       int filter_type)
 {
         struct ftrace_event_field *field;
 
@@ -44,9 +45,15 @@ int trace_define_field(struct ftrace_event_call *call, const char *type,
         if (!field->type)
                 goto err;
 
+        if (filter_type == FILTER_OTHER)
+                field->filter_type = filter_assign_type(type);
+        else
+                field->filter_type = filter_type;
+
         field->offset = offset;
         field->size = size;
         field->is_signed = is_signed;
+
         list_add(&field->link, &call->fields);
 
         return 0;
@@ -66,7 +73,7 @@ EXPORT_SYMBOL_GPL(trace_define_field);
         ret = trace_define_field(call, #type, "common_" #item,          \
                                  offsetof(typeof(ent), item),           \
                                  sizeof(ent.item),                      \
-                                 is_signed_type(type));                 \
+                                 is_signed_type(type), FILTER_OTHER);   \
         if (ret)                                                        \
                 return ret;
 
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 490337abed75..9f03082c81d8 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -163,6 +163,20 @@ static int filter_pred_string(struct filter_pred *pred, void *event,
         return match;
 }
 
+/* Filter predicate for char * pointers */
+static int filter_pred_pchar(struct filter_pred *pred, void *event,
+                             int val1, int val2)
+{
+        char **addr = (char **)(event + pred->offset);
+        int cmp, match;
+
+        cmp = strncmp(*addr, pred->str_val, pred->str_len);
+
+        match = (!cmp) ^ pred->not;
+
+        return match;
+}
+
 /*
  * Filter predicate for dynamic sized arrays of characters.
  * These are implemented through a list of strings at the end
@@ -475,12 +489,7 @@ static int filter_add_pred_fn(struct filter_parse_state *ps,
         return 0;
 }
 
-enum {
-        FILTER_STATIC_STRING = 1,
-        FILTER_DYN_STRING
-};
-
-static int is_string_field(const char *type)
+int filter_assign_type(const char *type)
 {
         if (strstr(type, "__data_loc") && strstr(type, "char"))
                 return FILTER_DYN_STRING;
@@ -488,12 +497,19 @@ static int is_string_field(const char *type)
         if (strchr(type, '[') && strstr(type, "char"))
                 return FILTER_STATIC_STRING;
 
-        return 0;
+        return FILTER_OTHER;
+}
+
+static bool is_string_field(struct ftrace_event_field *field)
+{
+        return field->filter_type == FILTER_DYN_STRING ||
+               field->filter_type == FILTER_STATIC_STRING ||
+               field->filter_type == FILTER_PTR_STRING;
 }
 
 static int is_legal_op(struct ftrace_event_field *field, int op)
 {
-        if (is_string_field(field->type) && (op != OP_EQ && op != OP_NE))
+        if (is_string_field(field) && (op != OP_EQ && op != OP_NE))
                 return 0;
 
         return 1;
@@ -550,7 +566,6 @@ static int filter_add_pred(struct filter_parse_state *ps,
         struct ftrace_event_field *field;
         filter_pred_fn_t fn;
         unsigned long long val;
-        int string_type;
         int ret;
 
         pred->fn = filter_pred_none;
@@ -578,13 +593,17 @@ static int filter_add_pred(struct filter_parse_state *ps,
                 return -EINVAL;
         }
 
-        string_type = is_string_field(field->type);
-        if (string_type) {
-                if (string_type == FILTER_STATIC_STRING)
+        if (is_string_field(field)) {
+                pred->str_len = field->size;
+
+                if (field->filter_type == FILTER_STATIC_STRING)
                         fn = filter_pred_string;
-                else
+                else if (field->filter_type == FILTER_DYN_STRING)
                         fn = filter_pred_strloc;
-                pred->str_len = field->size;
+                else {
+                        fn = filter_pred_pchar;
+                        pred->str_len = strlen(pred->str_val);
+                }
         } else {
                 if (field->is_signed)
                         ret = strict_strtoll(pred->str_val, 0, &val);
diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
index 70875303ae46..029a91f42287 100644
--- a/kernel/trace/trace_export.c
+++ b/kernel/trace/trace_export.c
@@ -158,7 +158,8 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define TRACE_FIELD(type, item, assign)                                 \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), is_signed_type(type));     \
+                                 sizeof(field.item),                    \
+                                 is_signed_type(type), FILTER_OTHER);   \
         if (ret)                                                        \
                 return ret;
 
@@ -166,7 +167,7 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define TRACE_FIELD_SPECIAL(type, item, len, cmd)                       \
         ret = trace_define_field(event_call, #type "[" #len "]", #item, \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), 0);                \
+                                 sizeof(field.item), 0, FILTER_OTHER);  \
         if (ret)                                                        \
                 return ret;
 
@@ -174,7 +175,8 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #define TRACE_FIELD_SIGN(type, item, assign, is_signed)                 \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), is_signed);        \
+                                 sizeof(field.item), is_signed,         \
+                                 FILTER_OTHER);                         \
         if (ret)                                                        \
                 return ret;
 
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 2698fe401ebd..85291c4de406 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -195,7 +195,8 @@ int syscall_enter_define_fields(struct ftrace_event_call *call)
         for (i = 0; i < meta->nb_args; i++) {
                 ret = trace_define_field(call, meta->types[i],
                                          meta->args[i], offset,
-                                         sizeof(unsigned long), 0);
+                                         sizeof(unsigned long), 0,
+                                         FILTER_OTHER);
                 offset += sizeof(unsigned long);
         }
 
@@ -211,7 +212,8 @@ int syscall_exit_define_fields(struct ftrace_event_call *call)
         if (ret)
                 return ret;
 
-        ret = trace_define_field(call, SYSCALL_FIELD(unsigned long, ret), 0);
+        ret = trace_define_field(call, SYSCALL_FIELD(unsigned long, ret), 0,
+                                 FILTER_OTHER);
 
         return ret;
 }