/**
   * @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.h>

  #include <linux/capability.h>

  #include <linux/dcookies.h>
  #include <linux/fs.h>
  #include <asm/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;

  	buffer_pos = 0;

  	event_buffer = vmalloc(sizeof(unsigned long) * buffer_size);
  	if (!event_buffer)

  		return -ENOMEM;

  	return 0;

  }
  
  
  void free_event_buffer(void)
  {

  	mutex_lock(&buffer_mutex);

  	vfree(event_buffer);

  	buffer_pos = 0;

  	event_buffer = NULL;

  	mutex_unlock(&buffer_mutex);

  }

  static int event_buffer_open(struct inode *inode, struct file *file)

  {
  	int err = -EPERM;
  
  	if (!capable(CAP_SYS_ADMIN))
  		return -EPERM;

  	if (test_and_set_bit_lock(0, &buffer_opened))

  		return -EBUSY;
  
  	/* Register as a user of dcookies
  	 * to ensure they persist for the lifetime of
  	 * the open event file
  	 */
  	err = -EINVAL;
  	file->private_data = dcookie_register();
  	if (!file->private_data)
  		goto out;

  	if ((err = oprofile_setup()))
  		goto fail;
  
  	/* NB: the actual start happens from userspace
  	 * echo 1 >/dev/oprofile/enable
  	 */

  	return nonseekable_open(inode, file);

  
  fail:
  	dcookie_unregister(file->private_data);
  out:

  	__clear_bit_unlock(0, &buffer_opened);

  	return err;
  }

  static int event_buffer_release(struct inode *inode, struct file *file)

  {
  	oprofile_stop();
  	oprofile_shutdown();
  	dcookie_unregister(file->private_data);
  	buffer_pos = 0;
  	atomic_set(&buffer_ready, 0);

  	__clear_bit_unlock(0, &buffer_opened);

  	return 0;
  }

  static ssize_t event_buffer_read(struct file *file, char __user *buf,
  				 size_t count, loff_t *offset)

  {
  	int retval = -EINVAL;
  	size_t const max = buffer_size * sizeof(unsigned long);
  
  	/* handling partial reads is more trouble than it's worth */
  	if (count != max || *offset)
  		return -EINVAL;
  
  	wait_event_interruptible(buffer_wait, atomic_read(&buffer_ready));
  
  	if (signal_pending(current))
  		return -EINTR;
  
  	/* can't currently happen */
  	if (!atomic_read(&buffer_ready))
  		return -EAGAIN;

  	mutex_lock(&buffer_mutex);

  	/* May happen if the buffer is freed during pending reads. */

  	if (!event_buffer) {
  		retval = -EINTR;
  		goto out;
  	}

  	atomic_set(&buffer_ready, 0);
  
  	retval = -EFAULT;
  
  	count = buffer_pos * sizeof(unsigned long);

  	if (copy_to_user(buf, event_buffer, count))
  		goto out;
  
  	retval = count;
  	buffer_pos = 0;

  out:

  	mutex_unlock(&buffer_mutex);

  	return retval;
  }

  const struct file_operations event_buffer_fops = {

  	.open		= event_buffer_open,
  	.release	= event_buffer_release,
  	.read		= event_buffer_read,

  	.llseek		= no_llseek,

  };