drivers/oprofile/cpu_buffer.c

   1 /**
   2  * @file cpu_buffer.c
   3  *
   4  * @remark Copyright 2002-2009 OProfile authors
   5  * @remark Read the file COPYING
   6  *
   7  * @author John Levon <levon@movementarian.org>
   8  * @author Barry Kasindorf <barry.kasindorf@amd.com>
   9  * @author Robert Richter <robert.richter@amd.com>
  10  *
  11  * Each CPU has a local buffer that stores PC value/event
  12  * pairs. We also log context switches when we notice them.
  13  * Eventually each CPU's buffer is processed into the global
  14  * event buffer by sync_buffer().
  15  *
  16  * We use a local buffer for two reasons: an NMI or similar
  17  * interrupt cannot synchronise, and high sampling rates
  18  * would lead to catastrophic global synchronisation if
  19  * a global buffer was used.
  20  */
  21
  22 #include <linux/sched.h>
  23 #include <linux/oprofile.h>
  24 #include <linux/errno.h>
  25
  26 #include "event_buffer.h"
  27 #include "cpu_buffer.h"
  28 #include "buffer_sync.h"
  29 #include "oprof.h"
  30
  31 #define OP_BUFFER_FLAGS 0
  32
  33 static struct ring_buffer *op_ring_buffer;
  34 DEFINE_PER_CPU(struct oprofile_cpu_buffer, op_cpu_buffer);
  35
  36 static void wq_sync_buffer(struct work_struct *work);
  37
  38 #define DEFAULT_TIMER_EXPIRE (HZ / 10)
  39 static int work_enabled;
  40
  41 unsigned long oprofile_get_cpu_buffer_size(void)
  42 {
  43         return oprofile_cpu_buffer_size;
  44 }
  45
  46 void oprofile_cpu_buffer_inc_smpl_lost(void)
  47 {
  48         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
  49
  50         cpu_buf->sample_lost_overflow++;
  51 }
  52
  53 void free_cpu_buffers(void)
  54 {
  55         if (op_ring_buffer)
  56                 ring_buffer_free(op_ring_buffer);
  57         op_ring_buffer = NULL;
  58 }
  59
  60 #define RB_EVENT_HDR_SIZE 4
  61
  62 int alloc_cpu_buffers(void)
  63 {
  64         int i;
  65
  66         unsigned long buffer_size = oprofile_cpu_buffer_size;
  67         unsigned long byte_size = buffer_size * (sizeof(struct op_sample) +
  68                                                  RB_EVENT_HDR_SIZE);
  69
  70         op_ring_buffer = ring_buffer_alloc(byte_size, OP_BUFFER_FLAGS);
  71         if (!op_ring_buffer)
  72                 goto fail;
  73
  74         for_each_possible_cpu(i) {
  75                 struct oprofile_cpu_buffer *b = &per_cpu(op_cpu_buffer, i);
  76
  77                 b->last_task = NULL;
  78                 b->last_is_kernel = -1;
  79                 b->tracing = 0;
  80                 b->buffer_size = buffer_size;
  81                 b->sample_received = 0;
  82                 b->sample_lost_overflow = 0;
  83                 b->backtrace_aborted = 0;
  84                 b->sample_invalid_eip = 0;
  85                 b->cpu = i;
  86                 INIT_DELAYED_WORK(&b->work, wq_sync_buffer);
  87         }
  88         return 0;
  89
  90 fail:
  91         free_cpu_buffers();
  92         return -ENOMEM;
  93 }
  94
  95 void start_cpu_work(void)
  96 {
  97         int i;
  98
  99         work_enabled = 1;
 100
 101         for_each_online_cpu(i) {
 102                 struct oprofile_cpu_buffer *b = &per_cpu(op_cpu_buffer, i);
 103
 104                 /*
 105                  * Spread the work by 1 jiffy per cpu so they dont all
 106                  * fire at once.
 107                  */
 108                 schedule_delayed_work_on(i, &b->work, DEFAULT_TIMER_EXPIRE + i);
 109         }
 110 }
 111
 112 void end_cpu_work(void)
 113 {
 114         work_enabled = 0;
 115 }
 116
 117 void flush_cpu_work(void)
 118 {
 119         int i;
 120
 121         for_each_online_cpu(i) {
 122                 struct oprofile_cpu_buffer *b = &per_cpu(op_cpu_buffer, i);
 123
 124                 /* these works are per-cpu, no need for flush_sync */
 125                 flush_delayed_work(&b->work);
 126         }
 127 }
 128
 129 /*
 130  * This function prepares the cpu buffer to write a sample.
 131  *
 132  * Struct op_entry is used during operations on the ring buffer while
 133  * struct op_sample contains the data that is stored in the ring
 134  * buffer. Struct entry can be uninitialized. The function reserves a
 135  * data array that is specified by size. Use
 136  * op_cpu_buffer_write_commit() after preparing the sample. In case of
 137  * errors a null pointer is returned, otherwise the pointer to the
 138  * sample.
 139  *
 140  */
 141 struct op_sample
 142 *op_cpu_buffer_write_reserve(struct op_entry *entry, unsigned long size)
 143 {
 144         entry->event = ring_buffer_lock_reserve
 145                 (op_ring_buffer, sizeof(struct op_sample) +
 146                  size * sizeof(entry->sample->data[0]));
 147         if (!entry->event)
 148                 return NULL;
 149         entry->sample = ring_buffer_event_data(entry->event);
 150         entry->size = size;
 151         entry->data = entry->sample->data;
 152
 153         return entry->sample;
 154 }
 155
 156 int op_cpu_buffer_write_commit(struct op_entry *entry)
 157 {
 158         return ring_buffer_unlock_commit(op_ring_buffer, entry->event);
 159 }
 160
 161 struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
 162 {
 163         struct ring_buffer_event *e;
 164         e = ring_buffer_consume(op_ring_buffer, cpu, NULL, NULL);
 165         if (!e)
 166                 return NULL;
 167
 168         entry->event = e;
 169         entry->sample = ring_buffer_event_data(e);
 170         entry->size = (ring_buffer_event_length(e) - sizeof(struct op_sample))
 171                 / sizeof(entry->sample->data[0]);
 172         entry->data = entry->sample->data;
 173         return entry->sample;
 174 }
 175
 176 unsigned long op_cpu_buffer_entries(int cpu)
 177 {
 178         return ring_buffer_entries_cpu(op_ring_buffer, cpu);
 179 }
 180
 181 static int
 182 op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
 183             int is_kernel, struct task_struct *task)
 184 {
 185         struct op_entry entry;
 186         struct op_sample *sample;
 187         unsigned long flags;
 188         int size;
 189
 190         flags = 0;
 191
 192         if (backtrace)
 193                 flags |= TRACE_BEGIN;
 194
 195         /* notice a switch from user->kernel or vice versa */
 196         is_kernel = !!is_kernel;
 197         if (cpu_buf->last_is_kernel != is_kernel) {
 198                 cpu_buf->last_is_kernel = is_kernel;
 199                 flags |= KERNEL_CTX_SWITCH;
 200                 if (is_kernel)
 201                         flags |= IS_KERNEL;
 202         }
 203
 204         /* notice a task switch */
 205         if (cpu_buf->last_task != task) {
 206                 cpu_buf->last_task = task;
 207                 flags |= USER_CTX_SWITCH;
 208         }
 209
 210         if (!flags)
 211                 /* nothing to do */
 212                 return 0;
 213
 214         if (flags & USER_CTX_SWITCH)
 215                 size = 1;
 216         else
 217                 size = 0;
 218
 219         sample = op_cpu_buffer_write_reserve(&entry, size);
 220         if (!sample)
 221                 return -ENOMEM;
 222
 223         sample->eip = ESCAPE_CODE;
 224         sample->event = flags;
 225
 226         if (size)
 227                 op_cpu_buffer_add_data(&entry, (unsigned long)task);
 228
 229         op_cpu_buffer_write_commit(&entry);
 230
 231         return 0;
 232 }
 233
 234 static inline int
 235 op_add_sample(struct oprofile_cpu_buffer *cpu_buf,
 236               unsigned long pc, unsigned long event)
 237 {
 238         struct op_entry entry;
 239         struct op_sample *sample;
 240
 241         sample = op_cpu_buffer_write_reserve(&entry, 0);
 242         if (!sample)
 243                 return -ENOMEM;
 244
 245         sample->eip = pc;
 246         sample->event = event;
 247
 248         return op_cpu_buffer_write_commit(&entry);
 249 }
 250
 251 /*
 252  * This must be safe from any context.
 253  *
 254  * is_kernel is needed because on some architectures you cannot
 255  * tell if you are in kernel or user space simply by looking at
 256  * pc. We tag this in the buffer by generating kernel enter/exit
 257  * events whenever is_kernel changes
 258  */
 259 static int
 260 log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
 261            unsigned long backtrace, int is_kernel, unsigned long event)
 262 {
 263         cpu_buf->sample_received++;
 264
 265         if (pc == ESCAPE_CODE) {
 266                 cpu_buf->sample_invalid_eip++;
 267                 return 0;
 268         }
 269
 270         if (op_add_code(cpu_buf, backtrace, is_kernel, current))
 271                 goto fail;
 272
 273         if (op_add_sample(cpu_buf, pc, event))
 274                 goto fail;
 275
 276         return 1;
 277
 278 fail:
 279         cpu_buf->sample_lost_overflow++;
 280         return 0;
 281 }
 282
 283 static inline void oprofile_begin_trace(struct oprofile_cpu_buffer *cpu_buf)
 284 {
 285         cpu_buf->tracing = 1;
 286 }
 287
 288 static inline void oprofile_end_trace(struct oprofile_cpu_buffer *cpu_buf)
 289 {
 290         cpu_buf->tracing = 0;
 291 }
 292
 293 static inline void
 294 __oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
 295                           unsigned long event, int is_kernel)
 296 {
 297         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
 298         unsigned long backtrace = oprofile_backtrace_depth;
 299
 300         /*
 301          * if log_sample() fail we can't backtrace since we lost the
 302          * source of this event
 303          */
 304         if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event))
 305                 /* failed */
 306                 return;
 307
 308         if (!backtrace)
 309                 return;
 310
 311         oprofile_begin_trace(cpu_buf);
 312         oprofile_ops.backtrace(regs, backtrace);
 313         oprofile_end_trace(cpu_buf);
 314 }
 315
 316 void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
 317                              unsigned long event, int is_kernel)
 318 {
 319         __oprofile_add_ext_sample(pc, regs, event, is_kernel);
 320 }
 321
 322 void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
 323 {
 324         int is_kernel;
 325         unsigned long pc;
 326
 327         if (likely(regs)) {
 328                 is_kernel = !user_mode(regs);
 329                 pc = profile_pc(regs);
 330         } else {
 331                 is_kernel = 0;    /* This value will not be used */
 332                 pc = ESCAPE_CODE; /* as this causes an early return. */
 333         }
 334
 335         __oprofile_add_ext_sample(pc, regs, event, is_kernel);
 336 }
 337
 338 /*
 339  * Add samples with data to the ring buffer.
 340  *
 341  * Use oprofile_add_data(&entry, val) to add data and
 342  * oprofile_write_commit(&entry) to commit the sample.
 343  */
 344 void
 345 oprofile_write_reserve(struct op_entry *entry, struct pt_regs * const regs,
 346                        unsigned long pc, int code, int size)
 347 {
 348         struct op_sample *sample;
 349         int is_kernel = !user_mode(regs);
 350         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
 351
 352         cpu_buf->sample_received++;
 353
 354         /* no backtraces for samples with data */
 355         if (op_add_code(cpu_buf, 0, is_kernel, current))
 356                 goto fail;
 357
 358         sample = op_cpu_buffer_write_reserve(entry, size + 2);
 359         if (!sample)
 360                 goto fail;
 361         sample->eip = ESCAPE_CODE;
 362         sample->event = 0;              /* no flags */
 363
 364         op_cpu_buffer_add_data(entry, code);
 365         op_cpu_buffer_add_data(entry, pc);
 366
 367         return;
 368
 369 fail:
 370         entry->event = NULL;
 371         cpu_buf->sample_lost_overflow++;
 372 }
 373
 374 int oprofile_add_data(struct op_entry *entry, unsigned long val)
 375 {
 376         if (!entry->event)
 377                 return 0;
 378         return op_cpu_buffer_add_data(entry, val);
 379 }
 380
 381 int oprofile_add_data64(struct op_entry *entry, u64 val)
 382 {
 383         if (!entry->event)
 384                 return 0;
 385         if (op_cpu_buffer_get_size(entry) < 2)
 386                 /*
 387                  * the function returns 0 to indicate a too small
 388                  * buffer, even if there is some space left
 389                  */
 390                 return 0;
 391         if (!op_cpu_buffer_add_data(entry, (u32)val))
 392                 return 0;
 393         return op_cpu_buffer_add_data(entry, (u32)(val >> 32));
 394 }
 395
 396 int oprofile_write_commit(struct op_entry *entry)
 397 {
 398         if (!entry->event)
 399                 return -EINVAL;
 400         return op_cpu_buffer_write_commit(entry);
 401 }
 402
 403 void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
 404 {
 405         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
 406         log_sample(cpu_buf, pc, 0, is_kernel, event);
 407 }
 408
 409 void oprofile_add_trace(unsigned long pc)
 410 {
 411         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(op_cpu_buffer);
 412
 413         if (!cpu_buf->tracing)
 414                 return;
 415
 416         /*
 417          * broken frame can give an eip with the same value as an
 418          * escape code, abort the trace if we get it
 419          */
 420         if (pc == ESCAPE_CODE)
 421                 goto fail;
 422
 423         if (op_add_sample(cpu_buf, pc, 0))
 424                 goto fail;
 425
 426         return;
 427 fail:
 428         cpu_buf->tracing = 0;
 429         cpu_buf->backtrace_aborted++;
 430         return;
 431 }
 432
 433 /*
 434  * This serves to avoid cpu buffer overflow, and makes sure
 435  * the task mortuary progresses
 436  *
 437  * By using schedule_delayed_work_on and then schedule_delayed_work
 438  * we guarantee this will stay on the correct cpu
 439  */
 440 static void wq_sync_buffer(struct work_struct *work)
 441 {
 442         struct oprofile_cpu_buffer *b =
 443                 container_of(work, struct oprofile_cpu_buffer, work.work);
 444         if (b->cpu != smp_processor_id()) {
 445                 printk(KERN_DEBUG "WQ on CPU%d, prefer CPU%d\n",
 446                        smp_processor_id(), b->cpu);
 447
 448                 if (!cpu_online(b->cpu)) {
 449                         cancel_delayed_work(&b->work);
 450                         return;
 451                 }
 452         }
 453         sync_buffer(b->cpu);
 454
 455         /* don't re-add the work if we're shutting down */
 456         if (work_enabled)
 457                 schedule_delayed_work(&b->work, DEFAULT_TIMER_EXPIRE);
 458 }