1 files changed, 94 insertions, 25 deletions

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 4dcc4e85c5..4a87560073 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -27,6 +27,7 @@
 #include <linux/poll.h>
 #include <linux/gfp.h>
 #include <linux/fs.h>
+#include <linux/kprobes.h>
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
@@ -42,11 +43,6 @@ static cpumask_t __read_mostly		tracing_buffer_mask;
 #define for_each_tracing_cpu(cpu)       \
         for_each_cpu_mask(cpu, tracing_buffer_mask)
 
-/* dummy trace to disable tracing */
-static struct tracer no_tracer __read_mostly = {
-        .name           = "none",
-};
-
 static int trace_alloc_page(void);
 static int trace_free_page(void);
 
@@ -134,6 +130,23 @@ static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 /* trace_flags holds iter_ctrl options */
 unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
 
+static notrace void no_trace_init(struct trace_array *tr)
+{
+        int cpu;
+
+        if(tr->ctrl)
+                for_each_online_cpu(cpu)
+                        tracing_reset(tr->data[cpu]);
+        tracer_enabled = 0;
+}
+
+/* dummy trace to disable tracing */
+static struct tracer no_tracer __read_mostly = {
+        .name           = "none",
+        .init           = no_trace_init
+};
+
+
 /**
  * trace_wake_up - wake up tasks waiting for trace input
  *
@@ -249,24 +262,32 @@ __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
         tracing_record_cmdline(current);
 }
 
+#define CHECK_COND(cond)                        \
+        if (unlikely(cond)) {                   \
+                tracing_disabled = 1;           \
+                WARN_ON(1);                     \
+                return -1;                      \
+        }
+
 /**
  * check_pages - integrity check of trace buffers
  *
  * As a safty measure we check to make sure the data pages have not
- * been corrupted. TODO: configure to disable this because it adds
- * a bit of overhead.
+ * been corrupted.
  */
-void check_pages(struct trace_array_cpu *data)
+int check_pages(struct trace_array_cpu *data)
 {
         struct page *page, *tmp;
 
-        BUG_ON(data->trace_pages.next->prev != &data->trace_pages);
-        BUG_ON(data->trace_pages.prev->next != &data->trace_pages);
+        CHECK_COND(data->trace_pages.next->prev != &data->trace_pages);
+        CHECK_COND(data->trace_pages.prev->next != &data->trace_pages);
 
         list_for_each_entry_safe(page, tmp, &data->trace_pages, lru) {
-                BUG_ON(page->lru.next->prev != &page->lru);
-                BUG_ON(page->lru.prev->next != &page->lru);
+                CHECK_COND(page->lru.next->prev != &page->lru);
+                CHECK_COND(page->lru.prev->next != &page->lru);
         }
+
+        return 0;
 }
 
 /**
@@ -280,7 +301,6 @@ void *head_page(struct trace_array_cpu *data)
 {
         struct page *page;
 
-        check_pages(data);
         if (list_empty(&data->trace_pages))
                 return NULL;
 
@@ -645,9 +665,6 @@ static char saved_cmdlines[SAVED_CMDLINES][TASK_COMM_LEN];
 static int cmdline_idx;
 static DEFINE_SPINLOCK(trace_cmdline_lock);
 
-/* trace in all context switches */
-atomic_t trace_record_cmdline_enabled __read_mostly;
-
 /* temporary disable recording */
 atomic_t trace_record_cmdline_disabled __read_mostly;
 
@@ -976,6 +993,30 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
         trace_wake_up();
 }
 
+void
+ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+
+        if (tracing_disabled || current_trace == &no_tracer || !tr->ctrl)
+                return;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+
+        if (likely(disabled == 1))
+                __trace_special(tr, data, arg1, arg2, arg3);
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+}
+
 #ifdef CONFIG_FTRACE
 static void
 function_trace_call(unsigned long ip, unsigned long parent_ip)
@@ -989,6 +1030,9 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
         if (unlikely(!tracer_enabled))
                 return;
 
+        if (skip_trace(ip))
+                return;
+
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
@@ -1213,6 +1257,20 @@ static void s_stop(struct seq_file *m, void *p)
         mutex_unlock(&trace_types_lock);
 }
 
+#define KRETPROBE_MSG "[unknown/kretprobe'd]"
+
+#ifdef CONFIG_KRETPROBES
+static inline int kretprobed(unsigned long addr)
+{
+        return addr == (unsigned long)kretprobe_trampoline;
+}
+#else
+static inline int kretprobed(unsigned long addr)
+{
+        return 0;
+}
+#endif /* CONFIG_KRETPROBES */
+
 static int
 seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
@@ -1448,7 +1506,10 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
         case TRACE_FN:
                 seq_print_ip_sym(s, entry->fn.ip, sym_flags);
                 trace_seq_puts(s, " (");
-                seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
+                if (kretprobed(entry->fn.parent_ip))
+                        trace_seq_puts(s, KRETPROBE_MSG);
+                else
+                        seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
                 trace_seq_puts(s, ")\n");
                 break;
         case TRACE_CTX:
@@ -1528,8 +1589,11 @@ static int print_trace_fmt(struct trace_iterator *iter)
                         ret = trace_seq_printf(s, " <-");
                         if (!ret)
                                 return 0;
-                        ret = seq_print_ip_sym(s, entry->fn.parent_ip,
-                                               sym_flags);
+                        if (kretprobed(entry->fn.parent_ip))
+                                ret = trace_seq_puts(s, KRETPROBE_MSG);
+                        else
+                                ret = seq_print_ip_sym(s, entry->fn.parent_ip,
+                                                       sym_flags);
                         if (!ret)
                                 return 0;
                 }
@@ -2608,7 +2672,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 {
         unsigned long val;
         char buf[64];
-        int ret;
+        int i, ret;
 
         if (cnt >= sizeof(buf))
                 return -EINVAL;
@@ -2677,8 +2741,15 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                         trace_free_page();
         }
 
+        /* check integrity */
+        for_each_tracing_cpu(i)
+                check_pages(global_trace.data[i]);
+
         filp->f_pos += cnt;
 
+        /* If check pages failed, return ENOMEM */
+        if (tracing_disabled)
+                cnt = -ENOMEM;
  out:
         max_tr.entries = global_trace.entries;
         mutex_unlock(&trace_types_lock);
@@ -2969,8 +3040,6 @@ __init static int tracer_alloc_buffers(void)
         int ret = -ENOMEM;
         int i;
 
-        global_trace.ctrl = tracer_enabled;
-
         /* TODO: make the number of buffers hot pluggable with CPUS */
         tracing_nr_buffers = num_possible_cpus();
         tracing_buffer_mask = cpu_possible_map;
@@ -3027,9 +3096,8 @@ __init static int tracer_alloc_buffers(void)
         }
         max_tr.entries = global_trace.entries;
 
-        pr_info("tracer: %d pages allocated for %ld",
-                pages, trace_nr_entries);
-        pr_info(" entries of %ld bytes\n", (long)TRACE_ENTRY_SIZE);
+        pr_info("tracer: %d pages allocated for %ld entries of %ld bytes\n",
+                pages, trace_nr_entries, (long)TRACE_ENTRY_SIZE);
         pr_info("   actual entries %ld\n", global_trace.entries);
 
         tracer_init_debugfs();
@@ -3040,6 +3108,7 @@ __init static int tracer_alloc_buffers(void)
         current_trace = &no_tracer;
 
         /* All seems OK, enable tracing */
+        global_trace.ctrl = tracer_enabled;
         tracing_disabled = 0;
 
         return 0;