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 <linux/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
 25struct oprofile_operations oprofile_ops;
 26
 27unsigned long oprofile_started;
 28unsigned long oprofile_backtrace_depth;
 29static unsigned long is_setup;
 30static DEFINE_MUTEX(start_mutex);
 31
 32/* timer
 33   0 - use performance monitoring hardware if available
 34   1 - use the timer int mechanism regardless
 35 */
 36static int timer = 0;
 37
 38int 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	}
 71do_generic:
 72	if ((err = sync_start()))
 73		goto out3;
 74
 75post_sync:
 76	is_setup = 1;
 77	mutex_unlock(&start_mutex);
 78	return 0;
 79
 80out3:
 81	if (oprofile_ops.shutdown)
 82		oprofile_ops.shutdown();
 83out2:
 84	free_event_buffer();
 85out1:
 86	free_cpu_buffers();
 87out:
 88	mutex_unlock(&start_mutex);
 89	return err;
 90}
 91
 92#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 93
 94static void switch_worker(struct work_struct *work);
 95static DECLARE_DELAYED_WORK(switch_work, switch_worker);
 96
 97static void start_switch_worker(void)
 98{
 99	if (oprofile_ops.switch_events)
100		schedule_delayed_work(&switch_work, oprofile_time_slice);
101}
102
103static void stop_switch_worker(void)
104{
105	cancel_delayed_work_sync(&switch_work);
106}
107
108static 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 */
118int 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
143out:
144	mutex_unlock(&start_mutex);
145	return err;
146
147}
148
149#else
150
151static inline void start_switch_worker(void) { }
152static inline void stop_switch_worker(void) { }
153
154#endif
155
156/* Actually start profiling (echo 1>/dev/oprofile/enable) */
157int 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;
179out:
180	mutex_unlock(&start_mutex);
181	return err;
182}
183
184
185/* echo 0>/dev/oprofile/enable */
186void 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();
198out:
199	mutex_unlock(&start_mutex);
200}
201
202
203void 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	}
217do_generic:
218	sync_stop();
219post_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
228int oprofile_set_ulong(unsigned long *addr, unsigned long val)
229{
230	int err = -EBUSY;
231
232	mutex_lock(&start_mutex);
233	if (!oprofile_started) {
234		*addr = val;
235		err = 0;
236	}
237	mutex_unlock(&start_mutex);
238
239	return err;
240}
241
242static int timer_mode;
243
244static int __init oprofile_init(void)
245{
246	int err;
247
248	/* always init architecture to setup backtrace support */
249	timer_mode = 0;
250	err = oprofile_arch_init(&oprofile_ops);
251	if (!err) {
252		if (!timer && !oprofilefs_register())
253			return 0;
254		oprofile_arch_exit();
255	}
256
257	/* setup timer mode: */
258	timer_mode = 1;
259	/* no nmi timer mode if oprofile.timer is set */
260	if (timer || op_nmi_timer_init(&oprofile_ops)) {
261		err = oprofile_timer_init(&oprofile_ops);
262		if (err)
263			return err;
264	}
265
266	return oprofilefs_register();
267}
268
269
270static void __exit oprofile_exit(void)
271{
272	oprofilefs_unregister();
273	if (!timer_mode)
274		oprofile_arch_exit();
275}
276
277
278module_init(oprofile_init);
279module_exit(oprofile_exit);
280
281module_param_named(timer, timer, int, 0644);
282MODULE_PARM_DESC(timer, "force use of timer interrupt");
283
284MODULE_LICENSE("GPL");
285MODULE_AUTHOR("John Levon <levon@movementarian.org>");
286MODULE_DESCRIPTION("OProfile system profiler");