1 files changed, 147 insertions, 64 deletions

diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index 79e52d93860b..930e51462dc8 100644
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -260,6 +260,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
                 goto error;
 
         INIT_LIST_HEAD(&tu->list);
+        INIT_LIST_HEAD(&tu->tp.files);
         tu->consumer.handler = uprobe_dispatcher;
         if (is_ret)
                 tu->consumer.ret_handler = uretprobe_dispatcher;
@@ -293,7 +294,7 @@ static struct trace_uprobe *find_probe_event(const char *event, const char *grou
         struct trace_uprobe *tu;
 
         list_for_each_entry(tu, &uprobe_list, list)
-                if (strcmp(tu->tp.call.name, event) == 0 &&
+                if (strcmp(ftrace_event_name(&tu->tp.call), event) == 0 &&
                     strcmp(tu->tp.call.class->system, group) == 0)
                         return tu;
 
@@ -323,7 +324,8 @@ static int register_trace_uprobe(struct trace_uprobe *tu)
         mutex_lock(&uprobe_lock);
 
         /* register as an event */
-        old_tu = find_probe_event(tu->tp.call.name, tu->tp.call.class->system);
+        old_tu = find_probe_event(ftrace_event_name(&tu->tp.call),
+                        tu->tp.call.class->system);
         if (old_tu) {
                 /* delete old event */
                 ret = unregister_trace_uprobe(old_tu);
@@ -598,7 +600,8 @@ static int probes_seq_show(struct seq_file *m, void *v)
         char c = is_ret_probe(tu) ? 'r' : 'p';
         int i;
 
-        seq_printf(m, "%c:%s/%s", c, tu->tp.call.class->system, tu->tp.call.name);
+        seq_printf(m, "%c:%s/%s", c, tu->tp.call.class->system,
+                        ftrace_event_name(&tu->tp.call));
         seq_printf(m, " %s:0x%p", tu->filename, (void *)tu->offset);
 
         for (i = 0; i < tu->tp.nr_args; i++)
@@ -648,7 +651,8 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
         struct trace_uprobe *tu = v;
 
-        seq_printf(m, "  %s %-44s %15lu\n", tu->filename, tu->tp.call.name, tu->nhit);
+        seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
+                        ftrace_event_name(&tu->tp.call), tu->nhit);
         return 0;
 }
 
@@ -758,31 +762,32 @@ static void uprobe_buffer_put(struct uprobe_cpu_buffer *ucb)
         mutex_unlock(&ucb->mutex);
 }
 
-static void uprobe_trace_print(struct trace_uprobe *tu,
-                                unsigned long func, struct pt_regs *regs)
+static void __uprobe_trace_func(struct trace_uprobe *tu,
+                                unsigned long func, struct pt_regs *regs,
+                                struct uprobe_cpu_buffer *ucb, int dsize,
+                                struct ftrace_event_file *ftrace_file)
 {
         struct uprobe_trace_entry_head *entry;
         struct ring_buffer_event *event;
         struct ring_buffer *buffer;
-        struct uprobe_cpu_buffer *ucb;
         void *data;
-        int size, dsize, esize;
+        int size, esize;
         struct ftrace_event_call *call = &tu->tp.call;
 
-        dsize = __get_data_size(&tu->tp, regs);
-        esize = SIZEOF_TRACE_ENTRY(is_ret_probe(tu));
+        WARN_ON(call != ftrace_file->event_call);
 
-        if (WARN_ON_ONCE(!uprobe_cpu_buffer || tu->tp.size + dsize > PAGE_SIZE))
+        if (WARN_ON_ONCE(tu->tp.size + dsize > PAGE_SIZE))
                 return;
 
-        ucb = uprobe_buffer_get();
-        store_trace_args(esize, &tu->tp, regs, ucb->buf, dsize);
+        if (ftrace_trigger_soft_disabled(ftrace_file))
+                return;
 
+        esize = SIZEOF_TRACE_ENTRY(is_ret_probe(tu));
         size = esize + tu->tp.size + dsize;
-        event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
-                                                  size, 0, 0);
+        event = trace_event_buffer_lock_reserve(&buffer, ftrace_file,
+                                                call->event.type, size, 0, 0);
         if (!event)
-                goto out;
+                return;
 
         entry = ring_buffer_event_data(event);
         if (is_ret_probe(tu)) {
@@ -796,25 +801,36 @@ static void uprobe_trace_print(struct trace_uprobe *tu,
 
         memcpy(data, ucb->buf, tu->tp.size + dsize);
 
-        if (!call_filter_check_discard(call, entry, buffer, event))
-                trace_buffer_unlock_commit(buffer, event, 0, 0);
-
-out:
-        uprobe_buffer_put(ucb);
+        event_trigger_unlock_commit(ftrace_file, buffer, event, entry, 0, 0);
 }
 
 /* uprobe handler */
-static int uprobe_trace_func(struct trace_uprobe *tu, struct pt_regs *regs)
+static int uprobe_trace_func(struct trace_uprobe *tu, struct pt_regs *regs,
+                             struct uprobe_cpu_buffer *ucb, int dsize)
 {
-        if (!is_ret_probe(tu))
-                uprobe_trace_print(tu, 0, regs);
+        struct event_file_link *link;
+
+        if (is_ret_probe(tu))
+                return 0;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(link, &tu->tp.files, list)
+                __uprobe_trace_func(tu, 0, regs, ucb, dsize, link->file);
+        rcu_read_unlock();
+
         return 0;
 }
 
 static void uretprobe_trace_func(struct trace_uprobe *tu, unsigned long func,
-                                struct pt_regs *regs)
+                                 struct pt_regs *regs,
+                                 struct uprobe_cpu_buffer *ucb, int dsize)
 {
-        uprobe_trace_print(tu, func, regs);
+        struct event_file_link *link;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(link, &tu->tp.files, list)
+                __uprobe_trace_func(tu, func, regs, ucb, dsize, link->file);
+        rcu_read_unlock();
 }
 
 /* Event entry printers */
@@ -831,12 +847,14 @@ print_uprobe_event(struct trace_iterator *iter, int flags, struct trace_event *e
         tu = container_of(event, struct trace_uprobe, tp.call.event);
 
         if (is_ret_probe(tu)) {
-                if (!trace_seq_printf(s, "%s: (0x%lx <- 0x%lx)", tu->tp.call.name,
+                if (!trace_seq_printf(s, "%s: (0x%lx <- 0x%lx)",
+                                        ftrace_event_name(&tu->tp.call),
                                         entry->vaddr[1], entry->vaddr[0]))
                         goto partial;
                 data = DATAOF_TRACE_ENTRY(entry, true);
         } else {
-                if (!trace_seq_printf(s, "%s: (0x%lx)", tu->tp.call.name,
+                if (!trace_seq_printf(s, "%s: (0x%lx)",
+                                        ftrace_event_name(&tu->tp.call),
                                         entry->vaddr[0]))
                         goto partial;
                 data = DATAOF_TRACE_ENTRY(entry, false);
@@ -861,12 +879,24 @@ typedef bool (*filter_func_t)(struct uprobe_consumer *self,
                                 struct mm_struct *mm);
 
 static int
-probe_event_enable(struct trace_uprobe *tu, int flag, filter_func_t filter)
+probe_event_enable(struct trace_uprobe *tu, struct ftrace_event_file *file,
+                   filter_func_t filter)
 {
-        int ret = 0;
+        bool enabled = trace_probe_is_enabled(&tu->tp);
+        struct event_file_link *link = NULL;
+        int ret;
+
+        if (file) {
+                link = kmalloc(sizeof(*link), GFP_KERNEL);
+                if (!link)
+                        return -ENOMEM;
 
-        if (trace_probe_is_enabled(&tu->tp))
-                return -EINTR;
+                link->file = file;
+                list_add_tail_rcu(&link->list, &tu->tp.files);
+
+                tu->tp.flags |= TP_FLAG_TRACE;
+        } else
+                tu->tp.flags |= TP_FLAG_PROFILE;
 
         ret = uprobe_buffer_enable();
         if (ret < 0)
@@ -874,24 +904,49 @@ probe_event_enable(struct trace_uprobe *tu, int flag, filter_func_t filter)
 
         WARN_ON(!uprobe_filter_is_empty(&tu->filter));
 
-        tu->tp.flags |= flag;
+        if (enabled)
+                return 0;
+
         tu->consumer.filter = filter;
         ret = uprobe_register(tu->inode, tu->offset, &tu->consumer);
-        if (ret)
-                tu->tp.flags &= ~flag;
+        if (ret) {
+                if (file) {
+                        list_del(&link->list);
+                        kfree(link);
+                        tu->tp.flags &= ~TP_FLAG_TRACE;
+                } else
+                        tu->tp.flags &= ~TP_FLAG_PROFILE;
+        }
 
         return ret;
 }
 
-static void probe_event_disable(struct trace_uprobe *tu, int flag)
+static void
+probe_event_disable(struct trace_uprobe *tu, struct ftrace_event_file *file)
 {
         if (!trace_probe_is_enabled(&tu->tp))
                 return;
 
+        if (file) {
+                struct event_file_link *link;
+
+                link = find_event_file_link(&tu->tp, file);
+                if (!link)
+                        return;
+
+                list_del_rcu(&link->list);
+                /* synchronize with u{,ret}probe_trace_func */
+                synchronize_sched();
+                kfree(link);
+
+                if (!list_empty(&tu->tp.files))
+                        return;
+        }
+
         WARN_ON(!uprobe_filter_is_empty(&tu->filter));
 
         uprobe_unregister(tu->inode, tu->offset, &tu->consumer);
-        tu->tp.flags &= ~flag;
+        tu->tp.flags &= file ? ~TP_FLAG_TRACE : ~TP_FLAG_PROFILE;
 
         uprobe_buffer_disable();
 }
@@ -1014,31 +1069,24 @@ static bool uprobe_perf_filter(struct uprobe_consumer *uc,
         return ret;
 }
 
-static void uprobe_perf_print(struct trace_uprobe *tu,
-                                unsigned long func, struct pt_regs *regs)
+static void __uprobe_perf_func(struct trace_uprobe *tu,
+                               unsigned long func, struct pt_regs *regs,
+                               struct uprobe_cpu_buffer *ucb, int dsize)
 {
         struct ftrace_event_call *call = &tu->tp.call;
         struct uprobe_trace_entry_head *entry;
         struct hlist_head *head;
-        struct uprobe_cpu_buffer *ucb;
         void *data;
-        int size, dsize, esize;
+        int size, esize;
         int rctx;
 
-        dsize = __get_data_size(&tu->tp, regs);
         esize = SIZEOF_TRACE_ENTRY(is_ret_probe(tu));
 
-        if (WARN_ON_ONCE(!uprobe_cpu_buffer))
-                return;
-
         size = esize + tu->tp.size + dsize;
         size = ALIGN(size + sizeof(u32), sizeof(u64)) - sizeof(u32);
         if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE, "profile buffer not large enough"))
                 return;
 
-        ucb = uprobe_buffer_get();
-        store_trace_args(esize, &tu->tp, regs, ucb->buf, dsize);
-
         preempt_disable();
         head = this_cpu_ptr(call->perf_events);
         if (hlist_empty(head))
@@ -1068,46 +1116,49 @@ static void uprobe_perf_print(struct trace_uprobe *tu,
         perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL);
  out:
         preempt_enable();
-        uprobe_buffer_put(ucb);
 }
 
 /* uprobe profile handler */
-static int uprobe_perf_func(struct trace_uprobe *tu, struct pt_regs *regs)
+static int uprobe_perf_func(struct trace_uprobe *tu, struct pt_regs *regs,
+                            struct uprobe_cpu_buffer *ucb, int dsize)
 {
         if (!uprobe_perf_filter(&tu->consumer, 0, current->mm))
                 return UPROBE_HANDLER_REMOVE;
 
         if (!is_ret_probe(tu))
-                uprobe_perf_print(tu, 0, regs);
+                __uprobe_perf_func(tu, 0, regs, ucb, dsize);
         return 0;
 }
 
 static void uretprobe_perf_func(struct trace_uprobe *tu, unsigned long func,
-                                struct pt_regs *regs)
+                                struct pt_regs *regs,
+                                struct uprobe_cpu_buffer *ucb, int dsize)
 {
-        uprobe_perf_print(tu, func, regs);
+        __uprobe_perf_func(tu, func, regs, ucb, dsize);
 }
 #endif  /* CONFIG_PERF_EVENTS */
 
-static
-int trace_uprobe_register(struct ftrace_event_call *event, enum trace_reg type, void *data)
+static int
+trace_uprobe_register(struct ftrace_event_call *event, enum trace_reg type,
+                      void *data)
 {
         struct trace_uprobe *tu = event->data;
+        struct ftrace_event_file *file = data;
 
         switch (type) {
         case TRACE_REG_REGISTER:
-                return probe_event_enable(tu, TP_FLAG_TRACE, NULL);
+                return probe_event_enable(tu, file, NULL);
 
         case TRACE_REG_UNREGISTER:
-                probe_event_disable(tu, TP_FLAG_TRACE);
+                probe_event_disable(tu, file);
                 return 0;
 
 #ifdef CONFIG_PERF_EVENTS
         case TRACE_REG_PERF_REGISTER:
-                return probe_event_enable(tu, TP_FLAG_PROFILE, uprobe_perf_filter);
+                return probe_event_enable(tu, NULL, uprobe_perf_filter);
 
         case TRACE_REG_PERF_UNREGISTER:
-                probe_event_disable(tu, TP_FLAG_PROFILE);
+                probe_event_disable(tu, NULL);
                 return 0;
 
         case TRACE_REG_PERF_OPEN:
@@ -1127,8 +1178,11 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
 {
         struct trace_uprobe *tu;
         struct uprobe_dispatch_data udd;
+        struct uprobe_cpu_buffer *ucb;
+        int dsize, esize;
         int ret = 0;
 
+
         tu = container_of(con, struct trace_uprobe, consumer);
         tu->nhit++;
 
@@ -1137,13 +1191,29 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
 
         current->utask->vaddr = (unsigned long) &udd;
 
+#ifdef CONFIG_PERF_EVENTS
+        if ((tu->tp.flags & TP_FLAG_TRACE) == 0 &&
+            !uprobe_perf_filter(&tu->consumer, 0, current->mm))
+                return UPROBE_HANDLER_REMOVE;
+#endif
+
+        if (WARN_ON_ONCE(!uprobe_cpu_buffer))
+                return 0;
+
+        dsize = __get_data_size(&tu->tp, regs);
+        esize = SIZEOF_TRACE_ENTRY(is_ret_probe(tu));
+
+        ucb = uprobe_buffer_get();
+        store_trace_args(esize, &tu->tp, regs, ucb->buf, dsize);
+
         if (tu->tp.flags & TP_FLAG_TRACE)
-                ret |= uprobe_trace_func(tu, regs);
+                ret |= uprobe_trace_func(tu, regs, ucb, dsize);
 
 #ifdef CONFIG_PERF_EVENTS
         if (tu->tp.flags & TP_FLAG_PROFILE)
-                ret |= uprobe_perf_func(tu, regs);
+                ret |= uprobe_perf_func(tu, regs, ucb, dsize);
 #endif
+        uprobe_buffer_put(ucb);
         return ret;
 }
 
@@ -1152,6 +1222,8 @@ static int uretprobe_dispatcher(struct uprobe_consumer *con,
 {
         struct trace_uprobe *tu;
         struct uprobe_dispatch_data udd;
+        struct uprobe_cpu_buffer *ucb;
+        int dsize, esize;
 
         tu = container_of(con, struct trace_uprobe, consumer);
 
@@ -1160,13 +1232,23 @@ static int uretprobe_dispatcher(struct uprobe_consumer *con,
 
         current->utask->vaddr = (unsigned long) &udd;
 
+        if (WARN_ON_ONCE(!uprobe_cpu_buffer))
+                return 0;
+
+        dsize = __get_data_size(&tu->tp, regs);
+        esize = SIZEOF_TRACE_ENTRY(is_ret_probe(tu));
+
+        ucb = uprobe_buffer_get();
+        store_trace_args(esize, &tu->tp, regs, ucb->buf, dsize);
+
         if (tu->tp.flags & TP_FLAG_TRACE)
-                uretprobe_trace_func(tu, func, regs);
+                uretprobe_trace_func(tu, func, regs, ucb, dsize);
 
 #ifdef CONFIG_PERF_EVENTS
         if (tu->tp.flags & TP_FLAG_PROFILE)
-                uretprobe_perf_func(tu, func, regs);
+                uretprobe_perf_func(tu, func, regs, ucb, dsize);
 #endif
+        uprobe_buffer_put(ucb);
         return 0;
 }
 
@@ -1198,7 +1280,8 @@ static int register_uprobe_event(struct trace_uprobe *tu)
         ret = trace_add_event_call(call);
 
         if (ret) {
-                pr_info("Failed to register uprobe event: %s\n", call->name);
+                pr_info("Failed to register uprobe event: %s\n",
+                        ftrace_event_name(call));
                 kfree(call->print_fmt);
                 unregister_ftrace_event(&call->event);
         }