2 files changed, 78 insertions, 19 deletions

diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index a2dea5008826..6781e9aab2c0 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -1027,8 +1027,23 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
         struct ring_buffer_event *event;
         u64 ts, delta;
         int commit = 0;
+        int nr_loops = 0;
 
  again:
+        /*
+         * We allow for interrupts to reenter here and do a trace.
+         * If one does, it will cause this original code to loop
+         * back here. Even with heavy interrupts happening, this
+         * should only happen a few times in a row. If this happens
+         * 1000 times in a row, there must be either an interrupt
+         * storm or we have something buggy.
+         * Bail!
+         */
+        if (unlikely(++nr_loops > 1000)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
         ts = ring_buffer_time_stamp(cpu_buffer->cpu);
 
         /*
@@ -1526,11 +1541,24 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
 {
         struct buffer_page *reader = NULL;
         unsigned long flags;
+        int nr_loops = 0;
 
         local_irq_save(flags);
         __raw_spin_lock(&cpu_buffer->lock);
 
  again:
+        /*
+         * This should normally only loop twice. But because the
+         * start of the reader inserts an empty page, it causes
+         * a case where we will loop three times. There should be no
+         * reason to loop four times (that I know of).
+         */
+        if (unlikely(++nr_loops > 3)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                reader = NULL;
+                goto out;
+        }
+
         reader = cpu_buffer->reader_page;
 
         /* If there's more to read, return this page */
@@ -1661,6 +1689,7 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
         struct buffer_page *reader;
+        int nr_loops = 0;
 
         if (!cpu_isset(cpu, buffer->cpumask))
                 return NULL;
@@ -1668,6 +1697,19 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         cpu_buffer = buffer->buffers[cpu];
 
  again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have.  Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
         reader = rb_get_reader_page(cpu_buffer);
         if (!reader)
                 return NULL;
@@ -1718,6 +1760,7 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         struct ring_buffer *buffer;
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
+        int nr_loops = 0;
 
         if (ring_buffer_iter_empty(iter))
                 return NULL;
@@ -1726,6 +1769,19 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         buffer = cpu_buffer->buffer;
 
  again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have. Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
         if (rb_per_cpu_empty(cpu_buffer))
                 return NULL;
 
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index ff1e9ed9b587..d55ccfc8d674 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -1231,17 +1231,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)
+static inline const char *kretprobed(const char *name)
 {
-        return addr == (unsigned long)kretprobe_trampoline;
+        static const char tramp_name[] = "kretprobe_trampoline";
+        int size = sizeof(tramp_name);
+
+        if (strncmp(tramp_name, name, size) == 0)
+                return "[unknown/kretprobe'd]";
+        return name;
 }
 #else
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return 0;
+        return name;
 }
 #endif /* CONFIG_KRETPROBES */
 
@@ -1250,10 +1253,13 @@ seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
 #ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+        const char *name;
 
         kallsyms_lookup(address, NULL, NULL, NULL, str);
 
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
 #endif
         return 1;
 }
@@ -1264,9 +1270,12 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 {
 #ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+        const char *name;
 
         sprint_symbol(str, address);
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
 #endif
         return 1;
 }
@@ -1520,10 +1529,7 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
 
                 seq_print_ip_sym(s, field->ip, sym_flags);
                 trace_seq_puts(s, " (");
-                if (kretprobed(field->parent_ip))
-                        trace_seq_puts(s, KRETPROBE_MSG);
-                else
-                        seq_print_ip_sym(s, field->parent_ip, sym_flags);
+                seq_print_ip_sym(s, field->parent_ip, sym_flags);
                 trace_seq_puts(s, ")\n");
                 break;
         }
@@ -1639,12 +1645,9 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
                         ret = trace_seq_printf(s, " <-");
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
-                        if (kretprobed(field->parent_ip))
-                                ret = trace_seq_puts(s, KRETPROBE_MSG);
-                        else
-                                ret = seq_print_ip_sym(s,
-                                                       field->parent_ip,
-                                                       sym_flags);
+                        ret = seq_print_ip_sym(s,
+                                               field->parent_ip,
+                                               sym_flags);
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
                 }
@@ -1895,7 +1898,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
                 return TRACE_TYPE_HANDLED;
 
         SEQ_PUT_FIELD_RET(s, entry->pid);
-        SEQ_PUT_FIELD_RET(s, iter->cpu);
+        SEQ_PUT_FIELD_RET(s, entry->cpu);
         SEQ_PUT_FIELD_RET(s, iter->ts);
 
         switch (entry->type) {