linux-imx

/**

 * @file event_buffer.c

 *

 * @remark Copyright 2002 OProfile authors

 * @remark Read the file COPYING

 *

 * @author John Levon <levon@movementarian.org>

 *

 * This is the global event buffer that the user-space

 * daemon reads from. The event buffer is an untyped array

 * of unsigned longs. Entries are prefixed by the

 * escape value ESCAPE_CODE followed by an identifying code.

 */

​

#include <linux/vmalloc.h>

#include <linux/oprofile.h>

#include <linux/sched/signal.h>

#include <linux/capability.h>

#include <linux/dcookies.h>

#include <linux/fs.h>

#include <linux/uaccess.h>

​

#include "oprof.h"

#include "event_buffer.h"

#include "oprofile_stats.h"

​

DEFINE_MUTEX(buffer_mutex);

​

static unsigned long buffer_opened;

static DECLARE_WAIT_QUEUE_HEAD(buffer_wait);

static unsigned long *event_buffer;

static unsigned long buffer_size;

static unsigned long buffer_watershed;

static size_t buffer_pos;

/* atomic_t because wait_event checks it outside of buffer_mutex */

static atomic_t buffer_ready = ATOMIC_INIT(0);

​

/*

 * Add an entry to the event buffer. When we get near to the end we

 * wake up the process sleeping on the read() of the file. To protect

 * the event_buffer this function may only be called when buffer_mutex

 * is set.

 */

void add_event_entry(unsigned long value)

{

    /*

     * This shouldn't happen since all workqueues or handlers are

     * canceled or flushed before the event buffer is freed.

     */

    if (!event_buffer) {

        WARN_ON_ONCE(1);

        return;

    }

​

    if (buffer_pos == buffer_size) {

        atomic_inc(&oprofile_stats.event_lost_overflow);

        return;

    }

​

    event_buffer[buffer_pos] = value;

    if (++buffer_pos == buffer_size - buffer_watershed) {

        atomic_set(&buffer_ready, 1);

        wake_up(&buffer_wait);

    }

}

​

​

/* Wake up the waiting process if any. This happens

 * on "echo 0 >/dev/oprofile/enable" so the daemon

 * processes the data remaining in the event buffer.

 */

void wake_up_buffer_waiter(void)

{

    mutex_lock(&buffer_mutex);

    atomic_set(&buffer_ready, 1);

    wake_up(&buffer_wait);

    mutex_unlock(&buffer_mutex);

}

​

​

int alloc_event_buffer(void)

{

    unsigned long flags;

​

    raw_spin_lock_irqsave(&oprofilefs_lock, flags);

    buffer_size = oprofile_buffer_size;

    buffer_watershed = oprofile_buffer_watershed;

    raw_spin_unlock_irqrestore(&oprofilefs_lock, flags);

​

    if (buffer_watershed >= buffer_size)

        return -EINVAL;

​