/** * @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; 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, };