1 files changed, 81 insertions, 148 deletions

diff --git a/drivers/oprofile/buffer_sync.c b/drivers/oprofile/buffer_sync.c
index b55cd23ffdef..ac014cb27915 100644
--- a/drivers/oprofile/buffer_sync.c
+++ b/drivers/oprofile/buffer_sync.c
@@ -1,11 +1,12 @@
 /**
  * @file buffer_sync.c
  *
- * @remark Copyright 2002 OProfile authors
+ * @remark Copyright 2002-2009 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon <levon@movementarian.org>
  * @author Barry Kasindorf
+ * @author Robert Richter <robert.richter@amd.com>
  *
  * This is the core of the buffer management. Each
  * CPU buffer is processed and entered into the
@@ -268,18 +269,6 @@ lookup_dcookie(struct mm_struct *mm, unsigned long addr, off_t *offset)
         return cookie;
 }
 
-static void increment_tail(struct oprofile_cpu_buffer *b)
-{
-        unsigned long new_tail = b->tail_pos + 1;
-
-        rmb();  /* be sure fifo pointers are synchromized */
-
-        if (new_tail < b->buffer_size)
-                b->tail_pos = new_tail;
-        else
-                b->tail_pos = 0;
-}
-
 static unsigned long last_cookie = INVALID_COOKIE;
 
 static void add_cpu_switch(int i)
@@ -327,84 +316,73 @@ static void add_trace_begin(void)
         add_event_entry(TRACE_BEGIN_CODE);
 }
 
-#ifdef CONFIG_OPROFILE_IBS
-
-#define IBS_FETCH_CODE_SIZE     2
-#define IBS_OP_CODE_SIZE        5
-#define IBS_EIP(offset)                         \
-        (((struct op_sample *)&cpu_buf->buffer[(offset)])->eip)
-#define IBS_EVENT(offset)                               \
-        (((struct op_sample *)&cpu_buf->buffer[(offset)])->event)
-
-/*
- * Add IBS fetch and op entries to event buffer
- */
-static void add_ibs_begin(struct oprofile_cpu_buffer *cpu_buf, int code,
-                          struct mm_struct *mm)
+static void add_data(struct op_entry *entry, struct mm_struct *mm)
 {
-        unsigned long rip;
-        int i, count;
-        unsigned long ibs_cookie = 0;
+        unsigned long code, pc, val;
+        unsigned long cookie;
         off_t offset;
 
-        increment_tail(cpu_buf);        /* move to RIP entry */
-
-        rip = IBS_EIP(cpu_buf->tail_pos);
-
-#ifdef __LP64__
-        rip += IBS_EVENT(cpu_buf->tail_pos) << 32;
-#endif
+        if (!op_cpu_buffer_get_data(entry, &code))
+                return;
+        if (!op_cpu_buffer_get_data(entry, &pc))
+                return;
+        if (!op_cpu_buffer_get_size(entry))
+                return;
 
         if (mm) {
-                ibs_cookie = lookup_dcookie(mm, rip, &offset);
+                cookie = lookup_dcookie(mm, pc, &offset);
 
-                if (ibs_cookie == NO_COOKIE)
-                        offset = rip;
-                if (ibs_cookie == INVALID_COOKIE) {
+                if (cookie == NO_COOKIE)
+                        offset = pc;
+                if (cookie == INVALID_COOKIE) {
                         atomic_inc(&oprofile_stats.sample_lost_no_mapping);
-                        offset = rip;
+                        offset = pc;
                 }
-                if (ibs_cookie != last_cookie) {
-                        add_cookie_switch(ibs_cookie);
-                        last_cookie = ibs_cookie;
+                if (cookie != last_cookie) {
+                        add_cookie_switch(cookie);
+                        last_cookie = cookie;
                 }
         } else
-                offset = rip;
+                offset = pc;
 
         add_event_entry(ESCAPE_CODE);
         add_event_entry(code);
         add_event_entry(offset);        /* Offset from Dcookie */
 
-        /* we send the Dcookie offset, but send the raw Linear Add also*/
-        add_event_entry(IBS_EIP(cpu_buf->tail_pos));
-        add_event_entry(IBS_EVENT(cpu_buf->tail_pos));
-
-        if (code == IBS_FETCH_CODE)
-                count = IBS_FETCH_CODE_SIZE;    /*IBS FETCH is 2 int64s*/
-        else
-                count = IBS_OP_CODE_SIZE;       /*IBS OP is 5 int64s*/
-
-        for (i = 0; i < count; i++) {
-                increment_tail(cpu_buf);
-                add_event_entry(IBS_EIP(cpu_buf->tail_pos));
-                add_event_entry(IBS_EVENT(cpu_buf->tail_pos));
-        }
+        while (op_cpu_buffer_get_data(entry, &val))
+                add_event_entry(val);
 }
 
-#endif
-
-static void add_sample_entry(unsigned long offset, unsigned long event)
+static inline void add_sample_entry(unsigned long offset, unsigned long event)
 {
         add_event_entry(offset);
         add_event_entry(event);
 }
 
 
-static int add_us_sample(struct mm_struct *mm, struct op_sample *s)
+/*
+ * Add a sample to the global event buffer. If possible the
+ * sample is converted into a persistent dentry/offset pair
+ * for later lookup from userspace. Return 0 on failure.
+ */
+static int
+add_sample(struct mm_struct *mm, struct op_sample *s, int in_kernel)
 {
         unsigned long cookie;
         off_t offset;
 
+        if (in_kernel) {
+                add_sample_entry(s->eip, s->event);
+                return 1;
+        }
+
+        /* add userspace sample */
+
+        if (!mm) {
+                atomic_inc(&oprofile_stats.sample_lost_no_mm);
+                return 0;
+        }
+
         cookie = lookup_dcookie(mm, s->eip, &offset);
 
         if (cookie == INVALID_COOKIE) {
@@ -423,25 +401,6 @@ static int add_us_sample(struct mm_struct *mm, struct op_sample *s)
 }
 
 
-/* Add a sample to the global event buffer. If possible the
- * sample is converted into a persistent dentry/offset pair
- * for later lookup from userspace.
- */
-static int
-add_sample(struct mm_struct *mm, struct op_sample *s, int in_kernel)
-{
-        if (in_kernel) {
-                add_sample_entry(s->eip, s->event);
-                return 1;
-        } else if (mm) {
-                return add_us_sample(mm, s);
-        } else {
-                atomic_inc(&oprofile_stats.sample_lost_no_mm);
-        }
-        return 0;
-}
-
-
 static void release_mm(struct mm_struct *mm)
 {
         if (!mm)
@@ -466,33 +425,6 @@ static inline int is_code(unsigned long val)
 }
 
 
-/* "acquire" as many cpu buffer slots as we can */
-static unsigned long get_slots(struct oprofile_cpu_buffer *b)
-{
-        unsigned long head = b->head_pos;
-        unsigned long tail = b->tail_pos;
-
-        /*
-         * Subtle. This resets the persistent last_task
-         * and in_kernel values used for switching notes.
-         * BUT, there is a small window between reading
-         * head_pos, and this call, that means samples
-         * can appear at the new head position, but not
-         * be prefixed with the notes for switching
-         * kernel mode or a task switch. This small hole
-         * can lead to mis-attribution or samples where
-         * we don't know if it's in the kernel or not,
-         * at the start of an event buffer.
-         */
-        cpu_buffer_reset(b);
-
-        if (head >= tail)
-                return head - tail;
-
-        return head + (b->buffer_size - tail);
-}
-
-
 /* Move tasks along towards death. Any tasks on dead_tasks
  * will definitely have no remaining references in any
  * CPU buffers at this point, because we use two lists,
@@ -559,71 +491,72 @@ typedef enum {
  */
 void sync_buffer(int cpu)
 {
-        struct oprofile_cpu_buffer *cpu_buf = &per_cpu(cpu_buffer, cpu);
         struct mm_struct *mm = NULL;
+        struct mm_struct *oldmm;
+        unsigned long val;
         struct task_struct *new;
         unsigned long cookie = 0;
         int in_kernel = 1;
         sync_buffer_state state = sb_buffer_start;
-#ifndef CONFIG_OPROFILE_IBS
         unsigned int i;
         unsigned long available;
-#endif
+        unsigned long flags;
+        struct op_entry entry;
+        struct op_sample *sample;
 
         mutex_lock(&buffer_mutex);
 
         add_cpu_switch(cpu);
 
-        /* Remember, only we can modify tail_pos */
-
-#ifndef CONFIG_OPROFILE_IBS
-        available = get_slots(cpu_buf);
+        op_cpu_buffer_reset(cpu);
+        available = op_cpu_buffer_entries(cpu);
 
         for (i = 0; i < available; ++i) {
-#else
-        while (get_slots(cpu_buf)) {
-#endif
-                struct op_sample *s = &cpu_buf->buffer[cpu_buf->tail_pos];
+                sample = op_cpu_buffer_read_entry(&entry, cpu);
+                if (!sample)
+                        break;
 
-                if (is_code(s->eip)) {
-                        if (s->event <= CPU_IS_KERNEL) {
+                if (is_code(sample->eip)) {
+                        flags = sample->event;
+                        if (flags & TRACE_BEGIN) {
+                                state = sb_bt_start;
+                                add_trace_begin();
+                        }
+                        if (flags & KERNEL_CTX_SWITCH) {
                                 /* kernel/userspace switch */
-                                in_kernel = s->event;
+                                in_kernel = flags & IS_KERNEL;
                                 if (state == sb_buffer_start)
                                         state = sb_sample_start;
-                                add_kernel_ctx_switch(s->event);
-                        } else if (s->event == CPU_TRACE_BEGIN) {
-                                state = sb_bt_start;
-                                add_trace_begin();
-#ifdef CONFIG_OPROFILE_IBS
-                        } else if (s->event == IBS_FETCH_BEGIN) {
-                                state = sb_bt_start;
-                                add_ibs_begin(cpu_buf, IBS_FETCH_CODE, mm);
-                        } else if (s->event == IBS_OP_BEGIN) {
-                                state = sb_bt_start;
-                                add_ibs_begin(cpu_buf, IBS_OP_CODE, mm);
-#endif
-                        } else {
-                                struct mm_struct *oldmm = mm;
-
+                                add_kernel_ctx_switch(flags & IS_KERNEL);
+                        }
+                        if (flags & USER_CTX_SWITCH
+                            && op_cpu_buffer_get_data(&entry, &val)) {
                                 /* userspace context switch */
-                                new = (struct task_struct *)s->event;
-
+                                new = (struct task_struct *)val;
+                                oldmm = mm;
                                 release_mm(oldmm);
                                 mm = take_tasks_mm(new);
                                 if (mm != oldmm)
                                         cookie = get_exec_dcookie(mm);
                                 add_user_ctx_switch(new, cookie);
                         }
-                } else if (state >= sb_bt_start &&
-                           !add_sample(mm, s, in_kernel)) {
-                        if (state == sb_bt_start) {
-                                state = sb_bt_ignore;
-                                atomic_inc(&oprofile_stats.bt_lost_no_mapping);
-                        }
+                        if (op_cpu_buffer_get_size(&entry))
+                                add_data(&entry, mm);
+                        continue;
                 }
 
-                increment_tail(cpu_buf);
+                if (state < sb_bt_start)
+                        /* ignore sample */
+                        continue;
+
+                if (add_sample(mm, sample, in_kernel))
+                        continue;
+
+                /* ignore backtraces if failed to add a sample */
+                if (state == sb_bt_start) {
+                        state = sb_bt_ignore;
+                        atomic_inc(&oprofile_stats.bt_lost_no_mapping);
+                }
         }
         release_mm(mm);