Initial import

1 files changed, 286 insertions, 0 deletions

diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
new file mode 100644
index 000000000..ed2c3ec07
--- /dev/null
+++ b/drivers/oprofile/oprof.c
@@ -0,0 +1,286 @@
+/**
+ * @file oprof.c
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon <levon@movementarian.org>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/oprofile.h>
+#include <linux/moduleparam.h>
+#include <linux/workqueue.h>
+#include <linux/time.h>
+#include <linux/mutex.h>
+
+#include "oprof.h"
+#include "event_buffer.h"
+#include "cpu_buffer.h"
+#include "buffer_sync.h"
+#include "oprofile_stats.h"
+
+struct oprofile_operations oprofile_ops;
+
+unsigned long oprofile_started;
+unsigned long oprofile_backtrace_depth;
+static unsigned long is_setup;
+static DEFINE_MUTEX(start_mutex);
+
+/* timer
+   0 - use performance monitoring hardware if available
+   1 - use the timer int mechanism regardless
+ */
+static int timer = 0;
+
+int oprofile_setup(void)
+{
+	int err;
+
+	mutex_lock(&start_mutex);
+
+	if ((err = alloc_cpu_buffers()))
+		goto out;
+
+	if ((err = alloc_event_buffer()))
+		goto out1;
+
+	if (oprofile_ops.setup && (err = oprofile_ops.setup()))
+		goto out2;
+
+	/* Note even though this starts part of the
+	 * profiling overhead, it's necessary to prevent
+	 * us missing task deaths and eventually oopsing
+	 * when trying to process the event buffer.
+	 */
+	if (oprofile_ops.sync_start) {
+		int sync_ret = oprofile_ops.sync_start();
+		switch (sync_ret) {
+		case 0:
+			goto post_sync;
+		case 1:
+			goto do_generic;
+		case -1:
+			goto out3;
+		default:
+			goto out3;
+		}
+	}
+do_generic:
+	if ((err = sync_start()))
+		goto out3;
+
+post_sync:
+	is_setup = 1;
+	mutex_unlock(&start_mutex);
+	return 0;
+
+out3:
+	if (oprofile_ops.shutdown)
+		oprofile_ops.shutdown();
+out2:
+	free_event_buffer();
+out1:
+	free_cpu_buffers();
+out:
+	mutex_unlock(&start_mutex);
+	return err;
+}
+
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static void switch_worker(struct work_struct *work);
+static DECLARE_DELAYED_WORK(switch_work, switch_worker);
+
+static void start_switch_worker(void)
+{
+	if (oprofile_ops.switch_events)
+		schedule_delayed_work(&switch_work, oprofile_time_slice);
+}
+
+static void stop_switch_worker(void)
+{
+	cancel_delayed_work_sync(&switch_work);
+}
+
+static void switch_worker(struct work_struct *work)
+{
+	if (oprofile_ops.switch_events())
+		return;
+
+	atomic_inc(&oprofile_stats.multiplex_counter);
+	start_switch_worker();
+}
+
+/* User inputs in ms, converts to jiffies */
+int oprofile_set_timeout(unsigned long val_msec)
+{
+	int err = 0;
+	unsigned long time_slice;
+
+	mutex_lock(&start_mutex);
+
+	if (oprofile_started) {
+		err = -EBUSY;
+		goto out;
+	}
+
+	if (!oprofile_ops.switch_events) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	time_slice = msecs_to_jiffies(val_msec);
+	if (time_slice == MAX_JIFFY_OFFSET) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	oprofile_time_slice = time_slice;
+
+out:
+	mutex_unlock(&start_mutex);
+	return err;
+
+}
+
+#else
+
+static inline void start_switch_worker(void) { }
+static inline void stop_switch_worker(void) { }
+
+#endif
+
+/* Actually start profiling (echo 1>/dev/oprofile/enable) */
+int oprofile_start(void)
+{
+	int err = -EINVAL;
+
+	mutex_lock(&start_mutex);
+
+	if (!is_setup)
+		goto out;
+
+	err = 0;
+
+	if (oprofile_started)
+		goto out;
+
+	oprofile_reset_stats();
+
+	if ((err = oprofile_ops.start()))
+		goto out;
+
+	start_switch_worker();
+
+	oprofile_started = 1;
+out:
+	mutex_unlock(&start_mutex);
+	return err;
+}
+
+
+/* echo 0>/dev/oprofile/enable */
+void oprofile_stop(void)
+{
+	mutex_lock(&start_mutex);
+	if (!oprofile_started)
+		goto out;
+	oprofile_ops.stop();
+	oprofile_started = 0;
+
+	stop_switch_worker();
+
+	/* wake up the daemon to read what remains */
+	wake_up_buffer_waiter();
+out:
+	mutex_unlock(&start_mutex);
+}
+
+
+void oprofile_shutdown(void)
+{
+	mutex_lock(&start_mutex);
+	if (oprofile_ops.sync_stop) {
+		int sync_ret = oprofile_ops.sync_stop();
+		switch (sync_ret) {
+		case 0:
+			goto post_sync;
+		case 1:
+			goto do_generic;
+		default:
+			goto post_sync;
+		}
+	}
+do_generic:
+	sync_stop();
+post_sync:
+	if (oprofile_ops.shutdown)
+		oprofile_ops.shutdown();
+	is_setup = 0;
+	free_event_buffer();
+	free_cpu_buffers();
+	mutex_unlock(&start_mutex);
+}
+
+int oprofile_set_ulong(unsigned long *addr, unsigned long val)
+{
+	int err = -EBUSY;
+
+	mutex_lock(&start_mutex);
+	if (!oprofile_started) {
+		*addr = val;
+		err = 0;
+	}
+	mutex_unlock(&start_mutex);
+
+	return err;
+}
+
+static int timer_mode;
+
+static int __init oprofile_init(void)
+{
+	int err;
+
+	/* always init architecture to setup backtrace support */
+	timer_mode = 0;
+	err = oprofile_arch_init(&oprofile_ops);
+	if (!err) {
+		if (!timer && !oprofilefs_register())
+			return 0;
+		oprofile_arch_exit();
+	}
+
+	/* setup timer mode: */
+	timer_mode = 1;
+	/* no nmi timer mode if oprofile.timer is set */
+	if (timer || op_nmi_timer_init(&oprofile_ops)) {
+		err = oprofile_timer_init(&oprofile_ops);
+		if (err)
+			return err;
+	}
+
+	return oprofilefs_register();
+}
+
+
+static void __exit oprofile_exit(void)
+{
+	oprofilefs_unregister();
+	if (!timer_mode)
+		oprofile_arch_exit();
+}
+
+
+module_init(oprofile_init);
+module_exit(oprofile_exit);
+
+module_param_named(timer, timer, int, 0644);
+MODULE_PARM_DESC(timer, "force use of timer interrupt");
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("John Levon <levon@movementarian.org>");
+MODULE_DESCRIPTION("OProfile system profiler");