Return bool from reset_alarm_* apis.
[akaros.git] / kern / src / oprofile / cpu_buffer.c
index fe0ac25..5036d7a 100644 (file)
 struct oprofile_cpu_buffer *op_cpu_buffer;
 
 /* this one queue is used by #K to get all events. */
-struct queue *opq;
+static struct queue *opq;
 
 /* 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 = 8;
+unsigned long oprofile_cpu_buffer_size = 65536;
+unsigned long oprofile_backtrace_depth = 16;
 
 #define DEFAULT_TIMER_EXPIRE (HZ / 10)
 static int work_enabled;
@@ -47,132 +47,163 @@ static int work_enabled;
  */
 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)
+       int op_cpu_buffer_add_data(struct op_entry *entry, unsigned long val)
 {
+       //print_func_entry();
        assert(entry->size >= 0);
-       if (!entry->size)
+       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)
+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)
+       int op_cpu_buffer_get_data(struct op_entry *entry, unsigned long *val)
 {
+       //print_func_entry();
        int size = entry->size;
-       if (!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)
 {
+       //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)
 {
+       //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);
-
+       /* this can get called lots of times. Things might have been freed.
+        * So be careful.
+        */
        /* what limit? No idea. */
-       opq = qopen(1024, Qmsg, NULL, NULL);
-       if (! opq)
+       if (!opq)
+               opq = qopen(1024, 0, NULL, NULL);
+       if (!opq)
                goto fail;
 
-       op_cpu_buffer = kzmalloc(sizeof(*op_cpu_buffer), num_cpus);
-       if (! op_cpu_buffer)
-               goto fail;
-
-       for(i = 0; i < num_cpus; i++) {
-               struct oprofile_cpu_buffer *b = &op_cpu_buffer[i];
-               /* short term: for each event, we're going to kmalloc a
-                * sample and shove it into the opq.
-                * Long term: TBD. One option is to create a big damn Block and
-                * add to it as needed. Once the block is full we can push
-                * it onto the opq. That will actually be pretty fast and easy
-                * if we make the block page-sized. Far, far simpler than the
-                * Linux tracebuffer stuff. 
-                */
-               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;
+       /* 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_cpus, KMALLOC_WAIT);
+               if (!op_cpu_buffer)
+                       goto fail;
+
+               for (i = 0; i < num_cpus; 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;
-       /* task starts here. 
-       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()];
 
+       //print_func_exit();
 }
 
 /* Not used since we're not doing per-cpu buffering yet.
@@ -180,30 +211,50 @@ void flush_cpu_work(void)
 
 struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
 {
+       //print_func_entry();
+       //print_func_exit();
        return NULL;
 }
 
-static struct block *op_cpu_buffer_write_reserve(struct op_entry *entry, int size)
+static struct block *op_cpu_buffer_write_reserve(struct oprofile_cpu_buffer *cpu_buf,
+       struct op_entry *entry, int size)
 {
+       //print_func_entry();
        struct block *b;
-       
-       b = allocb(sizeof(struct op_sample) +
-                  size * sizeof(entry->sample->data[0]));
-       if (!b)
-               return NULL;
+       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;
 
-       b->wp += sizeof(struct op_sample) +
-               size * sizeof(entry->sample->data[0]);
+       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 proc *proc)
+                       int is_kernel, struct proc *proc)
 {
+       //print_func_entry();
        struct block *b;
        struct op_entry entry;
        struct op_sample *sample;
@@ -215,6 +266,8 @@ op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
 
        if (waserror()) {
                poperror();
+               printk("%s: failed\n", __func__);
+               //print_func_exit();
                return 1;
        }
 
@@ -222,7 +275,7 @@ op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long 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;
@@ -239,6 +292,7 @@ op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
        if (!flags) {
                poperror();
                /* nothing to do */
+               //print_func_exit();
                return 0;
        }
 
@@ -247,7 +301,7 @@ op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
        else
                size = 0;
 
-       b = op_cpu_buffer_write_reserve(&entry, size);
+       b = op_cpu_buffer_write_reserve(cpu_buf, &entry, size);
 
        entry.sample->eip = ESCAPE_CODE;
        entry.sample->event = flags;
@@ -255,15 +309,16 @@ op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
        if (size)
                op_cpu_buffer_add_data(&entry, (unsigned long)proc);
 
-       qbwrite(opq, b); /* note: out of our hands now. Don't free. */
        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;
@@ -271,18 +326,19 @@ op_add_sample(struct oprofile_cpu_buffer *cpu_buf,
 
        if (waserror()) {
                poperror();
+               printk("%s: failed\n", __func__);
+               //print_func_exit();
                return 1;
        }
 
-       b = op_cpu_buffer_write_reserve(&entry, 0);
+       b = op_cpu_buffer_write_reserve(cpu_buf, &entry, 0);
 
        sample = entry.sample;
        sample->eip = pc;
        sample->event = event;
-
-       qbwrite(opq, b);
        poperror();
-       return 1;
+       //print_func_exit();
+       return 0;
 }
 
 /*
@@ -295,49 +351,111 @@ 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 proc *proc)
+                  unsigned long backtrace, int is_kernel, unsigned long event,
+                  struct proc *proc)
 {
+       //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. 
+       /* 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_cpus; 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_cpus; 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, void /*struct pt_regs*/ * const regs,
-                         unsigned long event, int is_kernel,
-                         struct proc *proc)
+__oprofile_add_ext_sample(unsigned long pc,
+                                                 void /*struct pt_regs */ *const regs,
+                                                 unsigned long event, int is_kernel, struct proc *proc)
 {
+       //print_func_entry();
        struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
        unsigned long backtrace = oprofile_backtrace_depth;
 
@@ -347,44 +465,59 @@ __oprofile_add_ext_sample(unsigned long pc, void /*struct pt_regs*/ * const regs
         */
        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, void /*struct pt_regs*/ * const regs,
-                               unsigned long event, int is_kernel,
-                               struct proc *proc)
+void oprofile_add_ext_hw_sample(unsigned long pc,
+                                                               void /*struct pt_regs */ *const regs,
+                                                               unsigned long event, int is_kernel,
+                                                               struct proc *proc)
 {
+       //print_func_entry();
        __oprofile_add_ext_sample(pc, regs, event, is_kernel, proc);
+       //print_func_exit();
 }
 
-void oprofile_add_ext_sample(unsigned long pc, void /*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(void /*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 (regs) {
-               is_kernel = 0; // FIXME!user_mode(regs);
-               pc = 0; // FIXME profile_pc(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();
 }
 
 /*
@@ -394,16 +527,19 @@ void oprofile_add_sample(void /*struct pt_regs*/ * const regs, unsigned long eve
  * oprofile_write_commit(&entry) to commit the sample.
  */
 void
-oprofile_write_reserve(struct op_entry *entry, void /*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;
        struct block *b;
-       int is_kernel = 0; // FIXME!user_mode(regs);
+       int is_kernel = 0;                      // FIXME!user_mode(regs);
        struct oprofile_cpu_buffer *cpu_buf = &op_cpu_buffer[core_id()];
 
-       if (waserror()){
+       if (waserror()) {
+               printk("%s: failed\n", __func__);
                poperror();
                goto fail;
        }
@@ -413,63 +549,86 @@ oprofile_write_reserve(struct op_entry *entry, void /*struct pt_regs*/ * const r
        if (op_add_code(cpu_buf, 0, is_kernel, current))
                goto fail;
 
-       b = op_cpu_buffer_write_reserve(entry, size + 2);
+       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);
-       qbwrite(opq, b);
        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, 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, (uint32_t)val))
+       }
+       if (!op_cpu_buffer_add_data(entry, (uint32_t) val)) {
+               //print_func_exit();
                return 0;
-       return op_cpu_buffer_add_data(entry, (uint32_t)(val >> 32));
+       }
+       //print_func_exit();
+       return op_cpu_buffer_add_data(entry, (uint32_t) (val >> 32));
 }
 
 int oprofile_write_commit(struct op_entry *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)
 {
+       //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)
 {
+       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
@@ -477,14 +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;
 }
 
+/* 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.
+ *
+ * second word is time in ns.
+ * 
+ * Third and following words are PCs, there must be at least one of them. 
+ */
+void oprofile_add_backtrace(uintptr_t pc, uintptr_t fp)
+{
+       /* 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;
+       }
+
+       len = qread(opq, va, n);
+       return len;
+}