Change all references of num_cpus -> num_cores
[akaros.git] / kern / src / oprofile / cpu_buffer.c
index e719961..cf06381 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 = 32;
-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,29 +47,36 @@ 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)
 {
+       //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;
 }
 
@@ -77,111 +84,126 @@ static inline int op_cpu_buffer_get_size(struct op_entry *entry)
 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)
 {
+       //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);
+                                                RB_EVENT_HDR_SIZE);
        /* this can get called lots of times. Things might have been freed.
         * So be careful.
         */
        /* what limit? No idea. */
        if (!opq)
-               opq = qopen(1024, Qmsg, NULL, NULL);
+               opq = qopen(1024, 0, NULL, NULL);
        if (!opq)
                goto fail;
 
        /* we *really* don't want to block. Losing data is better. */
        qnoblock(opq, 1);
        if (!op_cpu_buffer) {
-               printk("ALlocate %d bytes\n", sizeof(*op_cpu_buffer) * num_cpus);
                op_cpu_buffer =
-                       kzmalloc(sizeof(*op_cpu_buffer) * num_cpus, KMALLOC_WAIT);
+                       kzmalloc(sizeof(*op_cpu_buffer) * num_cores, KMALLOC_WAIT);
                if (!op_cpu_buffer)
                        goto fail;
 
-               for (i = 0; i < num_cpus; i++) {
+               for (i = 0; i < num_cores; 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 = 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);
         */
+       //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.
@@ -189,25 +211,41 @@ 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) {
-               printk("%s: fail\n", __func__);
-               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;
 
 }
@@ -216,6 +254,7 @@ static int
 op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
                        int is_kernel, struct proc *proc)
 {
+       //print_func_entry();
        struct block *b;
        struct op_entry entry;
        struct op_sample *sample;
@@ -228,6 +267,7 @@ 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;
        }
 
@@ -252,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;
        }
 
@@ -260,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;
@@ -268,8 +309,8 @@ 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;
 }
 
@@ -277,6 +318,7 @@ static inline int
 op_add_sample(struct oprofile_cpu_buffer *cpu_buf,
                          unsigned long pc, unsigned long event)
 {
+       //print_func_entry();
        ERRSTACK(1);
        struct op_entry entry;
        struct op_sample *sample;
@@ -285,16 +327,17 @@ 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();
+       //print_func_exit();
        return 0;
 }
 
@@ -311,11 +354,13 @@ log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
                   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;
        }
 
@@ -323,27 +368,86 @@ log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
         * 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
@@ -351,6 +455,7 @@ __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;
 
@@ -361,10 +466,12 @@ __oprofile_add_ext_sample(unsigned long pc,
        if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event, proc))
                /* failed */
        {
+               //print_func_exit();
                return;
        }
 
        if (!backtrace) {
+               //print_func_exit();
                return;
        }
 #if 0
@@ -372,6 +479,7 @@ __oprofile_add_ext_sample(unsigned long pc,
        oprofile_ops.backtrace(regs, backtrace);
        oprofile_end_trace(cpu_buf);
 #endif
+       //print_func_exit();
 }
 
 void oprofile_add_ext_hw_sample(unsigned long pc,
@@ -379,19 +487,24 @@ void oprofile_add_ext_hw_sample(unsigned long pc,
                                                                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)
 {
+       //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)
 {
+       //print_func_entry();
        int is_kernel;
        unsigned long pc;
 
@@ -404,6 +517,7 @@ void oprofile_add_sample(void /*struct pt_regs */ *const regs,
        }
 
        __oprofile_add_ext_sample(pc, regs, event, is_kernel, NULL);
+       //print_func_exit();
 }
 
 /*
@@ -417,6 +531,7 @@ 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;
@@ -434,32 +549,38 @@ oprofile_write_reserve(struct op_entry *entry,
        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 */
 
        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)
 {
+       //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)
 {
+       //print_func_entry();
        if (!entry->event) {
+               //print_func_exit();
                return 0;
        }
        if (op_cpu_buffer_get_size(entry) < 2)
@@ -468,33 +589,44 @@ int oprofile_add_data64(struct op_entry *entry, uint64_t val)
                 * buffer, even if there is some space left
                 */
        {
+               //print_func_exit();
                return 0;
        }
        if (!op_cpu_buffer_add_data(entry, (uint32_t) val)) {
+               //print_func_exit();
                return 0;
        }
+       //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) {
+               //print_func_exit();
                return;
        }
 
@@ -504,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;
+}