/**
 * @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");