drivers/oprofile/oprof.c

   1 /**
   2  * @file oprof.c
   3  *
   4  * @remark Copyright 2002 OProfile authors
   5  * @remark Read the file COPYING
   6  *
   7  * @author John Levon <levon@movementarian.org>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/oprofile.h>
  14 #include <linux/moduleparam.h>
  15 #include <linux/workqueue.h>
  16 #include <linux/time.h>
  17 #include <asm/mutex.h>
  18
  19 #include "oprof.h"
  20 #include "event_buffer.h"
  21 #include "cpu_buffer.h"
  22 #include "buffer_sync.h"
  23 #include "oprofile_stats.h"
  24
  25 struct oprofile_operations oprofile_ops;
  26
  27 unsigned long oprofile_started;
  28 unsigned long oprofile_backtrace_depth;
  29 static unsigned long is_setup;
  30 static DEFINE_MUTEX(start_mutex);
  31
  32 /* timer
  33    0 - use performance monitoring hardware if available
  34    1 - use the timer int mechanism regardless
  35  */
  36 static int timer = 0;
  37
  38 int oprofile_setup(void)
  39 {
  40         int err;
  41
  42         mutex_lock(&start_mutex);
  43
  44         if ((err = alloc_cpu_buffers()))
  45                 goto out;
  46
  47         if ((err = alloc_event_buffer()))
  48                 goto out1;
  49
  50         if (oprofile_ops.setup && (err = oprofile_ops.setup()))
  51                 goto out2;
  52
  53         /* Note even though this starts part of the
  54          * profiling overhead, it's necessary to prevent
  55          * us missing task deaths and eventually oopsing
  56          * when trying to process the event buffer.
  57          */
  58         if (oprofile_ops.sync_start) {
  59                 int sync_ret = oprofile_ops.sync_start();
  60                 switch (sync_ret) {
  61                 case 0:
  62                         goto post_sync;
  63                 case 1:
  64                         goto do_generic;
  65                 case -1:
  66                         goto out3;
  67                 default:
  68                         goto out3;
  69                 }
  70         }
  71 do_generic:
  72         if ((err = sync_start()))
  73                 goto out3;
  74
  75 post_sync:
  76         is_setup = 1;
  77         mutex_unlock(&start_mutex);
  78         return 0;
  79
  80 out3:
  81         if (oprofile_ops.shutdown)
  82                 oprofile_ops.shutdown();
  83 out2:
  84         free_event_buffer();
  85 out1:
  86         free_cpu_buffers();
  87 out:
  88         mutex_unlock(&start_mutex);
  89         return err;
  90 }
  91
  92 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
  93
  94 static void switch_worker(struct work_struct *work);
  95 static DECLARE_DELAYED_WORK(switch_work, switch_worker);
  96
  97 static void start_switch_worker(void)
  98 {
  99         if (oprofile_ops.switch_events)
 100                 schedule_delayed_work(&switch_work, oprofile_time_slice);
 101 }
 102
 103 static void stop_switch_worker(void)
 104 {
 105         cancel_delayed_work_sync(&switch_work);
 106 }
 107
 108 static void switch_worker(struct work_struct *work)
 109 {
 110         if (oprofile_ops.switch_events())
 111                 return;
 112
 113         atomic_inc(&oprofile_stats.multiplex_counter);
 114         start_switch_worker();
 115 }
 116
 117 /* User inputs in ms, converts to jiffies */
 118 int oprofile_set_timeout(unsigned long val_msec)
 119 {
 120         int err = 0;
 121         unsigned long time_slice;
 122
 123         mutex_lock(&start_mutex);
 124
 125         if (oprofile_started) {
 126                 err = -EBUSY;
 127                 goto out;
 128         }
 129
 130         if (!oprofile_ops.switch_events) {
 131                 err = -EINVAL;
 132                 goto out;
 133         }
 134
 135         time_slice = msecs_to_jiffies(val_msec);
 136         if (time_slice == MAX_JIFFY_OFFSET) {
 137                 err = -EINVAL;
 138                 goto out;
 139         }
 140
 141         oprofile_time_slice = time_slice;
 142
 143 out:
 144         mutex_unlock(&start_mutex);
 145         return err;
 146
 147 }
 148
 149 #else
 150
 151 static inline void start_switch_worker(void) { }
 152 static inline void stop_switch_worker(void) { }
 153
 154 #endif
 155
 156 /* Actually start profiling (echo 1>/dev/oprofile/enable) */
 157 int oprofile_start(void)
 158 {
 159         int err = -EINVAL;
 160
 161         mutex_lock(&start_mutex);
 162
 163         if (!is_setup)
 164                 goto out;
 165
 166         err = 0;
 167
 168         if (oprofile_started)
 169                 goto out;
 170
 171         oprofile_reset_stats();
 172
 173         if ((err = oprofile_ops.start()))
 174                 goto out;
 175
 176         start_switch_worker();
 177
 178         oprofile_started = 1;
 179 out:
 180         mutex_unlock(&start_mutex);
 181         return err;
 182 }
 183
 184
 185 /* echo 0>/dev/oprofile/enable */
 186 void oprofile_stop(void)
 187 {
 188         mutex_lock(&start_mutex);
 189         if (!oprofile_started)
 190                 goto out;
 191         oprofile_ops.stop();
 192         oprofile_started = 0;
 193
 194         stop_switch_worker();
 195
 196         /* wake up the daemon to read what remains */
 197         wake_up_buffer_waiter();
 198 out:
 199         mutex_unlock(&start_mutex);
 200 }
 201
 202
 203 void oprofile_shutdown(void)
 204 {
 205         mutex_lock(&start_mutex);
 206         if (oprofile_ops.sync_stop) {
 207                 int sync_ret = oprofile_ops.sync_stop();
 208                 switch (sync_ret) {
 209                 case 0:
 210                         goto post_sync;
 211                 case 1:
 212                         goto do_generic;
 213                 default:
 214                         goto post_sync;
 215                 }
 216         }
 217 do_generic:
 218         sync_stop();
 219 post_sync:
 220         if (oprofile_ops.shutdown)
 221                 oprofile_ops.shutdown();
 222         is_setup = 0;
 223         free_event_buffer();
 224         free_cpu_buffers();
 225         mutex_unlock(&start_mutex);
 226 }
 227
 228 int oprofile_set_backtrace(unsigned long val)
 229 {
 230         int err = 0;
 231
 232         mutex_lock(&start_mutex);
 233
 234         if (oprofile_started) {
 235                 err = -EBUSY;
 236                 goto out;
 237         }
 238
 239         if (!oprofile_ops.backtrace) {
 240                 err = -EINVAL;
 241                 goto out;
 242         }
 243
 244         oprofile_backtrace_depth = val;
 245
 246 out:
 247         mutex_unlock(&start_mutex);
 248         return err;
 249 }
 250
 251 static int __init oprofile_init(void)
 252 {
 253         int err;
 254
 255         err = oprofile_arch_init(&oprofile_ops);
 256
 257         if (err < 0 || timer) {
 258                 printk(KERN_INFO "oprofile: using timer interrupt.\n");
 259                 oprofile_timer_init(&oprofile_ops);
 260         }
 261
 262         err = oprofilefs_register();
 263         if (err)
 264                 oprofile_arch_exit();
 265
 266         return err;
 267 }
 268
 269
 270 static void __exit oprofile_exit(void)
 271 {
 272         oprofilefs_unregister();
 273         oprofile_arch_exit();
 274 }
 275
 276
 277 module_init(oprofile_init);
 278 module_exit(oprofile_exit);
 279
 280 module_param_named(timer, timer, int, 0644);
 281 MODULE_PARM_DESC(timer, "force use of timer interrupt");
 282
 283 MODULE_LICENSE("GPL");
 284 MODULE_AUTHOR("John Levon <levon@movementarian.org>");
 285 MODULE_DESCRIPTION("OProfile system profiler");