Change all references of num_cpus -> num_cores
[akaros.git] / kern / src / oprofile / cpu_buffer.c
index 38bb9a5..cf06381 100644 (file)
@@ -18,7 +18,6 @@
  * would lead to catastrophic global synchronisation if
  * a global buffer was used.
  */
-
 #include "event_buffer.h"
 #include "cpu_buffer.h"
 #include "buffer_sync.h"
 
 #define OP_BUFFER_FLAGS        0
 
-static struct ring_buffer *op_ring_buffer;
-DEFINE_PER_CPU(struct oprofile_cpu_buffer, op_cpu_buffer);
+/* we allocate an array of these and set the pointer in pcpui */
+struct oprofile_cpu_buffer *op_cpu_buffer;
+
+/* this one queue is used by #K to get all events. */
+static struct queue *opq;
 
-static void wq_sync_buffer(struct work_struct *work);
+/* this is run from core 0 for all cpu buffers. */
+static void wq_sync_buffer(void);
+unsigned long oprofile_cpu_buffer_size = 65536;
+unsigned long oprofile_backtrace_depth = 16;
 
 #define DEFAULT_TIMER_EXPIRE (HZ / 10)
 static int work_enabled;
 
+/*
+ * Resets the cpu buffer to a sane state.
+ *
+ * reset these to invalid values; the next sample collected will
+ * populate the buffer with proper values to initialize the buffer
+ */
+static inline void op_cpu_buffer_reset(int cpu)
+{
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
+
+       cpu_buf->last_is_kernel = -1;
+       cpu_buf->last_proc = NULL;
+       //print_func_exit();
+}
+
+/* returns the remaining free size of data in the entry */
+static inline
+       int op_cpu_buffer_add_data(struct op_entry *entry, unsigned long val)
+{
+       //print_func_entry();
+       assert(entry->size >= 0);
+       if (!entry->size) {
+               //print_func_exit();
+               return 0;
+       }
+       *entry->data = val;
+       entry->size--;
+       entry->data++;
+       //print_func_exit();
+       return entry->size;
+}
+
+/* returns the size of data in the entry */
+static inline int op_cpu_buffer_get_size(struct op_entry *entry)
+{
+       //print_func_entry();
+       //print_func_exit();
+       return entry->size;
+}
+
+/* returns 0 if empty or the size of data including the current value */
+static inline
+       int op_cpu_buffer_get_data(struct op_entry *entry, unsigned long *val)
+{
+       //print_func_entry();
+       int size = entry->size;
+       if (!size) {
+               //print_func_exit();
+               return 0;
+       }
+       *val = *entry->data;
+       entry->size--;
+       entry->data++;
+       //print_func_exit();
+       return size;
+}
+
 unsigned long oprofile_get_cpu_buffer_size(void)
 {
+       //print_func_entry();
+       //print_func_exit();
        return oprofile_cpu_buffer_size;
 }
 
 void oprofile_cpu_buffer_inc_smpl_lost(void)
 {
-       struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
 
        cpu_buf->sample_lost_overflow++;
+       //print_func_exit();
 }
 
 void free_cpu_buffers(void)
 {
-       if (op_ring_buffer)
-               ring_buffer_free(op_ring_buffer);
-       op_ring_buffer = NULL;
+       //print_func_entry();
+       kfree(op_cpu_buffer);
+       /* we can just leave the queue set up; it will then always return EOF */
+       //print_func_exit();
 }
 
 #define RB_EVENT_HDR_SIZE 4
 
 int alloc_cpu_buffers(void)
 {
+       //print_func_entry();
+       /* should probably start using waserror() here. The fail stuff just gets
+        * ugly.
+        */
        int i;
-
        unsigned long buffer_size = oprofile_cpu_buffer_size;
        unsigned long byte_size = buffer_size * (sizeof(struct op_sample) +
                                                 RB_EVENT_HDR_SIZE);
-
-       op_ring_buffer = ring_buffer_alloc(byte_size, OP_BUFFER_FLAGS);
-       if (!op_ring_buffer)
+       /* this can get called lots of times. Things might have been freed.
+        * So be careful.
+        */
+       /* what limit? No idea. */
+       if (!opq)
+               opq = qopen(1024, 0, NULL, NULL);
+       if (!opq)
                goto fail;
 
-       for_each_possible_cpu(i) {
-               struct oprofile_cpu_buffer *b = &per_cpu(op_cpu_buffer, i);
-
-               b->last_task = NULL;
-               b->last_is_kernel = -1;
-               b->tracing = 0;
-               b->buffer_size = buffer_size;
-               b->sample_received = 0;
-               b->sample_lost_overflow = 0;
-               b->backtrace_aborted = 0;
-               b->sample_invalid_eip = 0;
-               b->cpu = i;
-               INIT_DELAYED_WORK(&b->work, wq_sync_buffer);
+       /* we *really* don't want to block. Losing data is better. */
+       qnoblock(opq, 1);
+       if (!op_cpu_buffer) {
+               op_cpu_buffer =
+                       kzmalloc(sizeof(*op_cpu_buffer) * num_cores, KMALLOC_WAIT);
+               if (!op_cpu_buffer)
+                       goto fail;
+
+               for (i = 0; i < num_cores; i++) {
+                       struct oprofile_cpu_buffer *b = &op_cpu_buffer[i];
+                       b->last_proc = NULL;
+                       b->last_is_kernel = -1;
+                       b->tracing = 0;
+                       b->buffer_size = buffer_size;
+                       b->sample_received = 0;
+                       b->sample_lost_overflow = 0;
+                       b->backtrace_aborted = 0;
+                       b->sample_invalid_eip = 0;
+                       b->cpu = i;
+                       b->fullqueue = qopen(1024, Qmsg, NULL, NULL);
+                       b->emptyqueue = qopen(1024, Qmsg, NULL, NULL);
+                       spinlock_init_irqsave(&b->lock);
+               }
        }
+
+       //print_func_exit();
        return 0;
 
 fail:
        free_cpu_buffers();
+       //print_func_exit();
        return -ENOMEM;
 }
 
 void start_cpu_work(void)
 {
+       //print_func_entry();
        int i;
 
        work_enabled = 1;
-
-       for_each_online_cpu(i) {
-               struct oprofile_cpu_buffer *b = &per_cpu(op_cpu_buffer, i);
-
-               /*
-                * Spread the work by 1 jiffy per cpu so they dont all
-                * fire at once.
-                */
-               schedule_delayed_work_on(i, &b->work, DEFAULT_TIMER_EXPIRE + i);
-       }
+       /* task starts here.
+          schedule_delayed_work_on(i, &b->work, DEFAULT_TIMER_EXPIRE + i);
+        */
+       //print_func_exit();
 }
 
 void end_cpu_work(void)
 {
+       //print_func_entry();
        work_enabled = 0;
+       //print_func_exit();
 }
 
+/* placeholder. Not used yet.
+ */
 void flush_cpu_work(void)
 {
+       //print_func_entry();
        int i;
+       struct oprofile_cpu_buffer *b = &op_cpu_buffer[core_id()];
 
-       for_each_online_cpu(i) {
-               struct oprofile_cpu_buffer *b = &per_cpu(op_cpu_buffer, i);
-
-               /* these works are per-cpu, no need for flush_sync */
-               flush_delayed_work(&b->work);
-       }
+       //print_func_exit();
 }
 
-/*
- * This function prepares the cpu buffer to write a sample.
- *
- * Struct op_entry is used during operations on the ring buffer while
- * struct op_sample contains the data that is stored in the ring
- * buffer. Struct entry can be uninitialized. The function reserves a
- * data array that is specified by size. Use
- * op_cpu_buffer_write_commit() after preparing the sample. In case of
- * errors a null pointer is returned, otherwise the pointer to the
- * sample.
- *
+/* Not used since we're not doing per-cpu buffering yet.
  */
-struct op_sample
-*op_cpu_buffer_write_reserve(struct op_entry *entry, unsigned long size)
-{
-       entry->event = ring_buffer_lock_reserve
-               (op_ring_buffer, sizeof(struct op_sample) +
-                size * sizeof(entry->sample->data[0]));
-       if (!entry->event)
-               return NULL;
-       entry->sample = ring_buffer_event_data(entry->event);
-       entry->size = size;
-       entry->data = entry->sample->data;
-
-       return entry->sample;
-}
 
-int op_cpu_buffer_write_commit(struct op_entry *entry)
+struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
 {
-       return ring_buffer_unlock_commit(op_ring_buffer, entry->event);
+       //print_func_entry();
+       //print_func_exit();
+       return NULL;
 }
 
-struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
+static struct block *op_cpu_buffer_write_reserve(struct oprofile_cpu_buffer *cpu_buf,
+       struct op_entry *entry, int size)
 {
-       struct ring_buffer_event *e;
-       e = ring_buffer_consume(op_ring_buffer, cpu, NULL, NULL);
-       if (!e)
-               return NULL;
-
-       entry->event = e;
-       entry->sample = ring_buffer_event_data(e);
-       entry->size = (ring_buffer_event_length(e) - sizeof(struct op_sample))
-               / sizeof(entry->sample->data[0]);
+       //print_func_entry();
+       struct block *b;
+       int totalsize = sizeof(struct op_sample) +
+               size * sizeof(entry->sample->data[0]);
+
+       b = cpu_buf->block;
+       /* we might have run out. */
+       if ((! b) || (b->lim - b->wp) < size) {
+               if (b){
+                       qibwrite(opq, b);
+               }
+               /* For now. Later, we will grab a block off the
+                * emptyblock queue.
+                */
+               cpu_buf->block = b = iallocb(oprofile_cpu_buffer_size);
+               if (!b) {
+                       printk("%s: fail\n", __func__);
+                       //print_func_exit();
+                       return NULL;
+               }
+       }
+       entry->sample = (void *)b->wp;
+       entry->size = size;
        entry->data = entry->sample->data;
-       return entry->sample;
-}
 
-unsigned long op_cpu_buffer_entries(int cpu)
-{
-       return ring_buffer_entries_cpu(op_ring_buffer, cpu);
+       b->wp += totalsize;
+       //print_func_exit();
+       return b;
+
 }
 
 static int
 op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
-           int is_kernel, struct task_struct *task)
+                       int is_kernel, struct proc *proc)
 {
+       //print_func_entry();
+       struct block *b;
        struct op_entry entry;
        struct op_sample *sample;
        unsigned long flags;
        int size;
+       ERRSTACK(1);
 
        flags = 0;
 
+       if (waserror()) {
+               poperror();
+               printk("%s: failed\n", __func__);
+               //print_func_exit();
+               return 1;
+       }
+
        if (backtrace)
                flags |= TRACE_BEGIN;
 
        /* notice a switch from user->kernel or vice versa */
-       is_kernel = !!is_kernel;
+       is_kernel = ! !is_kernel;
        if (cpu_buf->last_is_kernel != is_kernel) {
                cpu_buf->last_is_kernel = is_kernel;
                flags |= KERNEL_CTX_SWITCH;
@@ -197,51 +283,62 @@ op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
                        flags |= IS_KERNEL;
        }
 
-       /* notice a task switch */
-       if (cpu_buf->last_task != task) {
-               cpu_buf->last_task = task;
+       /* notice a proc switch */
+       if (cpu_buf->last_proc != proc) {
+               cpu_buf->last_proc = proc;
                flags |= USER_CTX_SWITCH;
        }
 
-       if (!flags)
+       if (!flags) {
+               poperror();
                /* nothing to do */
+               //print_func_exit();
                return 0;
+       }
 
        if (flags & USER_CTX_SWITCH)
                size = 1;
        else
                size = 0;
 
-       sample = op_cpu_buffer_write_reserve(&entry, size);
-       if (!sample)
-               return -ENOMEM;
+       b = op_cpu_buffer_write_reserve(cpu_buf, &entry, size);
 
-       sample->eip = ESCAPE_CODE;
-       sample->event = flags;
+       entry.sample->eip = ESCAPE_CODE;
+       entry.sample->event = flags;
 
        if (size)
-               op_cpu_buffer_add_data(&entry, (unsigned long)task);
-
-       op_cpu_buffer_write_commit(&entry);
+               op_cpu_buffer_add_data(&entry, (unsigned long)proc);
 
+       poperror();
+       //print_func_exit();
        return 0;
 }
 
 static inline int
 op_add_sample(struct oprofile_cpu_buffer *cpu_buf,
-             unsigned long pc, unsigned long event)
+                         unsigned long pc, unsigned long event)
 {
+       //print_func_entry();
+       ERRSTACK(1);
        struct op_entry entry;
        struct op_sample *sample;
+       struct block *b;
+
+       if (waserror()) {
+               poperror();
+               printk("%s: failed\n", __func__);
+               //print_func_exit();
+               return 1;
+       }
 
-       sample = op_cpu_buffer_write_reserve(&entry, 0);
-       if (!sample)
-               return -ENOMEM;
+       b = op_cpu_buffer_write_reserve(cpu_buf, &entry, 0);
 
+       sample = entry.sample;
        sample->eip = pc;
        sample->event = event;
-
-       return op_cpu_buffer_write_commit(&entry);
+       poperror();
+       //print_func_exit();
+       return 0;
 }
 
 /*
@@ -254,91 +351,173 @@ op_add_sample(struct oprofile_cpu_buffer *cpu_buf,
  */
 static int
 log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
-          unsigned long backtrace, int is_kernel, unsigned long event,
-          struct task_struct *task)
+                  unsigned long backtrace, int is_kernel, unsigned long event,
+                  struct proc *proc)
 {
-       struct task_struct *tsk = task ? task : current;
+       //print_func_entry();
+       struct proc *tsk = proc ? proc : current;
        cpu_buf->sample_received++;
 
        if (pc == ESCAPE_CODE) {
                cpu_buf->sample_invalid_eip++;
+               //print_func_exit();
                return 0;
        }
 
+       /* ah, so great. op_add* return 1 in event of failure.
+        * this function returns 0 in event of failure.
+        * what a cluster.
+        */
+       spin_lock_irqsave(&cpu_buf->lock);
        if (op_add_code(cpu_buf, backtrace, is_kernel, tsk))
                goto fail;
 
        if (op_add_sample(cpu_buf, pc, event))
                goto fail;
+       spin_unlock_irqsave(&cpu_buf->lock);
 
+       //print_func_exit();
        return 1;
 
 fail:
        cpu_buf->sample_lost_overflow++;
+       //print_func_exit();
        return 0;
 }
 
 static inline void oprofile_begin_trace(struct oprofile_cpu_buffer *cpu_buf)
 {
+       //print_func_entry();
        cpu_buf->tracing = 1;
+       //print_func_exit();
 }
 
 static inline void oprofile_end_trace(struct oprofile_cpu_buffer *cpu_buf)
 {
+       //print_func_entry();
        cpu_buf->tracing = 0;
+       //print_func_exit();
+}
+
+void oprofile_cpubuf_flushone(int core, int newbuf)
+{
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf;
+       cpu_buf = &op_cpu_buffer[core];
+       spin_lock_irqsave(&cpu_buf->lock);
+       if (cpu_buf->block) {
+               printk("Core %d has data\n", core);
+               qibwrite(opq, cpu_buf->block);
+               printk("After qibwrite in %s, opq len %d\n", __func__, qlen(opq));
+       }
+       if (newbuf)
+               cpu_buf->block = iallocb(oprofile_cpu_buffer_size);
+       else
+               cpu_buf->block = NULL;
+       spin_unlock_irqsave(&cpu_buf->lock);
+       //print_func_exit();
+}
+
+void oprofile_cpubuf_flushall(int alloc)
+{
+       //print_func_entry();
+       int core;
+
+       for(core = 0; core < num_cores; core++) {
+               oprofile_cpubuf_flushone(core, alloc);
+       }
+       //print_func_exit();
+}
+
+void oprofile_control_trace(int onoff)
+{
+       //print_func_entry();
+       int core;
+       struct oprofile_cpu_buffer *cpu_buf;
+
+       for(core = 0; core < num_cores; core++) {
+               cpu_buf = &op_cpu_buffer[core];
+               cpu_buf->tracing = onoff;
+
+               if (onoff) {
+                       printk("Enable tracing on %d\n", core);
+                       continue;
+               }
+
+               /* halting. Force out all buffers. */
+               oprofile_cpubuf_flushone(core, 0);
+       }
+       //print_func_exit();
 }
 
 static inline void
-__oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
-                         unsigned long event, int is_kernel,
-                         struct task_struct *task)
+__oprofile_add_ext_sample(unsigned long pc,
+                                                 void /*struct pt_regs */ *const regs,
+                                                 unsigned long event, int is_kernel, struct proc *proc)
 {
-       struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
        unsigned long backtrace = oprofile_backtrace_depth;
 
        /*
         * if log_sample() fail we can't backtrace since we lost the
         * source of this event
         */
-       if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event, task))
+       if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event, proc))
                /* failed */
+       {
+               //print_func_exit();
                return;
+       }
 
-       if (!backtrace)
+       if (!backtrace) {
+               //print_func_exit();
                return;
-
+       }
+#if 0
        oprofile_begin_trace(cpu_buf);
        oprofile_ops.backtrace(regs, backtrace);
        oprofile_end_trace(cpu_buf);
+#endif
+       //print_func_exit();
 }
 
-void oprofile_add_ext_hw_sample(unsigned long pc, struct pt_regs * const regs,
-                               unsigned long event, int is_kernel,
-                               struct task_struct *task)
+void oprofile_add_ext_hw_sample(unsigned long pc,
+                                                               void /*struct pt_regs */ *const regs,
+                                                               unsigned long event, int is_kernel,
+                                                               struct proc *proc)
 {
-       __oprofile_add_ext_sample(pc, regs, event, is_kernel, task);
+       //print_func_entry();
+       __oprofile_add_ext_sample(pc, regs, event, is_kernel, proc);
+       //print_func_exit();
 }
 
-void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
-                            unsigned long event, int is_kernel)
+void oprofile_add_ext_sample(unsigned long pc,
+                                                        void /*struct pt_regs */ *const regs,
+                                                        unsigned long event, int is_kernel)
 {
+       //print_func_entry();
        __oprofile_add_ext_sample(pc, regs, event, is_kernel, NULL);
+       //print_func_exit();
 }
 
-void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
+void oprofile_add_sample(void /*struct pt_regs */ *const regs,
+                                                unsigned long event)
 {
+       //print_func_entry();
        int is_kernel;
        unsigned long pc;
 
-       if (likely(regs)) {
-               is_kernel = !user_mode(regs);
-               pc = profile_pc(regs);
+       if (regs) {
+               is_kernel = 0;  // FIXME!user_mode(regs);
+               pc = 0; // FIXME profile_pc(regs);
        } else {
-               is_kernel = 0;    /* This value will not be used */
-               pc = ESCAPE_CODE; /* as this causes an early return. */
+               is_kernel = 0;  /* This value will not be used */
+               pc = ESCAPE_CODE;       /* as this causes an early return. */
        }
 
        __oprofile_add_ext_sample(pc, regs, event, is_kernel, NULL);
+       //print_func_exit();
 }
 
 /*
@@ -348,76 +527,108 @@ void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
  * oprofile_write_commit(&entry) to commit the sample.
  */
 void
-oprofile_write_reserve(struct op_entry *entry, struct pt_regs * const regs,
-                      unsigned long pc, int code, int size)
+oprofile_write_reserve(struct op_entry *entry,
+                                          void /*struct pt_regs */ *const regs,
+                                          unsigned long pc, int code, int size)
 {
+       //print_func_entry();
+       ERRSTACK(1);
        struct op_sample *sample;
-       int is_kernel = !user_mode(regs);
-       struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
+       struct block *b;
+       int is_kernel = 0;                      // FIXME!user_mode(regs);
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
 
+       if (waserror()) {
+               printk("%s: failed\n", __func__);
+               poperror();
+               goto fail;
+       }
        cpu_buf->sample_received++;
 
        /* no backtraces for samples with data */
        if (op_add_code(cpu_buf, 0, is_kernel, current))
                goto fail;
 
-       sample = op_cpu_buffer_write_reserve(entry, size + 2);
-       if (!sample)
-               goto fail;
+       b = op_cpu_buffer_write_reserve(cpu_buf, entry, size + 2);
+       sample = entry->sample;
        sample->eip = ESCAPE_CODE;
-       sample->event = 0;              /* no flags */
+       sample->event = 0;      /* no flags */
 
        op_cpu_buffer_add_data(entry, code);
        op_cpu_buffer_add_data(entry, pc);
-
+       poperror();
+       //print_func_exit();
        return;
-
 fail:
        entry->event = NULL;
        cpu_buf->sample_lost_overflow++;
+       //print_func_exit();
 }
 
 int oprofile_add_data(struct op_entry *entry, unsigned long val)
 {
-       if (!entry->event)
+       //print_func_entry();
+       if (!entry->event) {
+               //print_func_exit();
                return 0;
+       }
+       //print_func_exit();
        return op_cpu_buffer_add_data(entry, val);
 }
 
-int oprofile_add_data64(struct op_entry *entry, u64 val)
+int oprofile_add_data64(struct op_entry *entry, uint64_t val)
 {
-       if (!entry->event)
+       //print_func_entry();
+       if (!entry->event) {
+               //print_func_exit();
                return 0;
+       }
        if (op_cpu_buffer_get_size(entry) < 2)
                /*
                 * the function returns 0 to indicate a too small
                 * buffer, even if there is some space left
                 */
+       {
+               //print_func_exit();
                return 0;
-       if (!op_cpu_buffer_add_data(entry, (u32)val))
+       }
+       if (!op_cpu_buffer_add_data(entry, (uint32_t) val)) {
+               //print_func_exit();
                return 0;
-       return op_cpu_buffer_add_data(entry, (u32)(val >> 32));
+       }
+       //print_func_exit();
+       return op_cpu_buffer_add_data(entry, (uint32_t) (val >> 32));
 }
 
 int oprofile_write_commit(struct op_entry *entry)
 {
-       if (!entry->event)
-               return -EINVAL;
-       return op_cpu_buffer_write_commit(entry);
+       //print_func_entry();
+       /* not much to do at present. In future, we might write the Block
+        * to opq.
+        */
+       //print_func_exit();
+       return 0;
 }
 
 void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
 {
-       struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
        log_sample(cpu_buf, pc, 0, is_kernel, event, NULL);
+       //print_func_exit();
 }
 
 void oprofile_add_trace(unsigned long pc)
 {
-       struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
+       if (! op_cpu_buffer)
+               return;
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
 
-       if (!cpu_buf->tracing)
+       if (!cpu_buf->tracing) {
+               //print_func_exit();
                return;
+       }
 
        /*
         * broken frame can give an eip with the same value as an
@@ -425,35 +636,125 @@ void oprofile_add_trace(unsigned long pc)
         */
        if (pc == ESCAPE_CODE)
                goto fail;
-
-       if (op_add_sample(cpu_buf, pc, 0))
+       if (op_add_sample(cpu_buf, pc, nsec()&~0xf))
                goto fail;
 
+       //print_func_exit();
        return;
 fail:
+       printk("%s: fail. Turning of tracing on cpu %d\n", core_id());
        cpu_buf->tracing = 0;
        cpu_buf->backtrace_aborted++;
+       //print_func_exit();
        return;
 }
 
-/*
- * This serves to avoid cpu buffer overflow, and makes sure
- * the task mortuary progresses
+/* Format for samples:
+ * first word:
+ * high 8 bits is ee, which is an invalid address on amd64. 
+ * next 8 bits is protocol version
+ * next 16 bits is unused, MBZ. Later, we can make it a packet type. 
+ * next 16 bits is core id
+ * next 8 bits is unused
+ * next 8 bits is # PCs following. This should be at least 1, for one EIP.
  *
- * By using schedule_delayed_work_on and then schedule_delayed_work
- * we guarantee this will stay on the correct cpu
+ * second word is time in ns.
+ * 
+ * Third and following words are PCs, there must be at least one of them. 
  */
-static void wq_sync_buffer(struct work_struct *work)
+void oprofile_add_backtrace(uintptr_t pc, uintptr_t fp)
 {
-       struct oprofile_cpu_buffer *b =
-               container_of(work, struct oprofile_cpu_buffer, work.work);
-       if (b->cpu != smp_processor_id() && !cpu_online(b->cpu)) {
-               cancel_delayed_work(&b->work);
+       /* version 1. */
+       uint64_t descriptor = 0xee01ULL<<48;
+       if (! op_cpu_buffer)
                return;
+       //print_func_entry();
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
+
+       if (!cpu_buf->tracing) {
+               //print_func_exit();
+               return;
+       }
+
+       struct op_entry entry;
+       struct op_sample *sample;
+       struct block *b;
+       uint64_t event = nsec();
+
+       uintptr_t bt_pcs[oprofile_backtrace_depth];
+
+       int nr_pcs;
+       nr_pcs = backtrace_list(pc, fp, bt_pcs, oprofile_backtrace_depth);
+
+       /* write_reserve always assumes passed-in-size + 2.
+        * backtrace_depth should always be > 0.
+        */
+       b = op_cpu_buffer_write_reserve(cpu_buf, &entry, nr_pcs);
+
+       if (! b)
+               return;
+
+       /* we are changing the sample format, but not the struct
+        * member names yet. Later, assuming this works out.
+        */
+       descriptor |= (core_id() << 16) | nr_pcs;
+       sample = entry.sample;
+       sample->eip = descriptor;
+       sample->event = event;
+       memcpy(sample->data, bt_pcs, sizeof(uintptr_t) * nr_pcs);
+
+       //print_func_exit();
+       return;
+fail:
+       printk("%s: fail. Turning of tracing on cpu %d\n", core_id());
+       cpu_buf->tracing = 0;
+       cpu_buf->backtrace_aborted++;
+       //print_func_exit();
+       return;
+}
+
+void oprofile_add_userpc(uintptr_t pc)
+{
+       struct oprofile_cpu_buffer *cpu_buf;
+       uint32_t pcoreid = core_id();
+       struct op_entry entry;
+       struct block *b;
+       uint64_t descriptor = (0xee01ULL << 48) | (pcoreid << 16) | 1;
+
+       if (!op_cpu_buffer)
+               return;
+       cpu_buf = &op_cpu_buffer[pcoreid];
+       if (!cpu_buf->tracing)
+               return;
+       /* write_reserve always assumes passed-in-size + 2.  need room for 1 PC. */
+       b = op_cpu_buffer_write_reserve(cpu_buf, &entry, 1);
+       if (!b)
+               return;
+       entry.sample->eip = descriptor;
+       entry.sample->event = nsec();
+       /* entry.sample->data == entry.data */
+       assert(entry.sample->data == entry.data);
+       *entry.sample->data = pc;
+}
+
+int
+oproflen(void)
+{
+       return qlen(opq);
+}
+
+/* return # bytes read, or 0 if profiling is off, or block if profiling on and no data.
+ */
+int
+oprofread(void *va, int n)
+{
+       int len = qlen(opq);
+       struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
+       if (len == 0) {
+               if (cpu_buf->tracing == 0)
+                       return 0;
        }
-       sync_buffer(b->cpu);
 
-       /* don't re-add the work if we're shutting down */
-       if (work_enabled)
-               schedule_delayed_work(&b->work, DEFAULT_TIMER_EXPIRE);
+       len = qread(opq, va, n);
+       return len;
 }