1/** 2 * @file event_buffer.c 3 * 4 * @remark Copyright 2002 OProfile authors 5 * @remark Read the file COPYING 6 * 7 * @author John Levon <levon@movementarian.org> 8 * 9 * This is the global event buffer that the user-space 10 * daemon reads from. The event buffer is an untyped array 11 * of unsigned longs. Entries are prefixed by the 12 * escape value ESCAPE_CODE followed by an identifying code. 13 */ 14 15#include <linux/vmalloc.h> 16#include <linux/oprofile.h> 17#include <linux/sched.h> 18#include <linux/capability.h> 19#include <linux/dcookies.h> 20#include <linux/fs.h> 21#include <asm/uaccess.h> 22 23#include "oprof.h" 24#include "event_buffer.h" 25#include "oprofile_stats.h" 26 27DEFINE_MUTEX(buffer_mutex); 28 29static unsigned long buffer_opened; 30static DECLARE_WAIT_QUEUE_HEAD(buffer_wait); 31static unsigned long *event_buffer; 32static unsigned long buffer_size; 33static unsigned long buffer_watershed; 34static size_t buffer_pos; 35/* atomic_t because wait_event checks it outside of buffer_mutex */ 36static atomic_t buffer_ready = ATOMIC_INIT(0); 37 38/* 39 * Add an entry to the event buffer. When we get near to the end we 40 * wake up the process sleeping on the read() of the file. To protect 41 * the event_buffer this function may only be called when buffer_mutex 42 * is set. 43 */ 44void add_event_entry(unsigned long value) 45{ 46 /* 47 * This shouldn't happen since all workqueues or handlers are 48 * canceled or flushed before the event buffer is freed. 49 */ 50 if (!event_buffer) { 51 WARN_ON_ONCE(1); 52 return; 53 } 54 55 if (buffer_pos == buffer_size) { 56 atomic_inc(&oprofile_stats.event_lost_overflow); 57 return; 58 } 59 60 event_buffer[buffer_pos] = value; 61 if (++buffer_pos == buffer_size - buffer_watershed) { 62 atomic_set(&buffer_ready, 1); 63 wake_up(&buffer_wait); 64 } 65} 66 67 68/* Wake up the waiting process if any. This happens 69 * on "echo 0 >/dev/oprofile/enable" so the daemon 70 * processes the data remaining in the event buffer. 71 */ 72void wake_up_buffer_waiter(void) 73{ 74 mutex_lock(&buffer_mutex); 75 atomic_set(&buffer_ready, 1); 76 wake_up(&buffer_wait); 77 mutex_unlock(&buffer_mutex); 78} 79 80 81int alloc_event_buffer(void) 82{ 83 unsigned long flags; 84 85 spin_lock_irqsave(&oprofilefs_lock, flags); 86 buffer_size = oprofile_buffer_size; 87 buffer_watershed = oprofile_buffer_watershed; 88 spin_unlock_irqrestore(&oprofilefs_lock, flags); 89 90 if (buffer_watershed >= buffer_size) 91 return -EINVAL; 92 93 buffer_pos = 0; 94 event_buffer = vmalloc(sizeof(unsigned long) * buffer_size); 95 if (!event_buffer) 96 return -ENOMEM; 97 98 return 0; 99} 100 101 102void free_event_buffer(void) 103{ 104 mutex_lock(&buffer_mutex); 105 vfree(event_buffer); 106 buffer_pos = 0; 107 event_buffer = NULL; 108 mutex_unlock(&buffer_mutex); 109} 110 111 112static int event_buffer_open(struct inode *inode, struct file *file) 113{ 114 int err = -EPERM; 115 116 if (!capable(CAP_SYS_ADMIN)) 117 return -EPERM; 118 119 if (test_and_set_bit_lock(0, &buffer_opened)) 120 return -EBUSY; 121 122 /* Register as a user of dcookies 123 * to ensure they persist for the lifetime of 124 * the open event file 125 */ 126 err = -EINVAL; 127 file->private_data = dcookie_register(); 128 if (!file->private_data) 129 goto out; 130 131 if ((err = oprofile_setup())) 132 goto fail; 133 134 /* NB: the actual start happens from userspace 135 * echo 1 >/dev/oprofile/enable 136 */ 137 138 return nonseekable_open(inode, file); 139 140fail: 141 dcookie_unregister(file->private_data); 142out: 143 __clear_bit_unlock(0, &buffer_opened); 144 return err; 145} 146 147 148static int event_buffer_release(struct inode *inode, struct file *file) 149{ 150 oprofile_stop(); 151 oprofile_shutdown(); 152 dcookie_unregister(file->private_data); 153 buffer_pos = 0; 154 atomic_set(&buffer_ready, 0); 155 __clear_bit_unlock(0, &buffer_opened); 156 return 0; 157} 158 159 160static ssize_t event_buffer_read(struct file *file, char __user *buf, 161 size_t count, loff_t *offset) 162{ 163 int retval = -EINVAL; 164 size_t const max = buffer_size * sizeof(unsigned long); 165 166 /* handling partial reads is more trouble than it's worth */ 167 if (count != max || *offset) 168 return -EINVAL; 169 170 wait_event_interruptible(buffer_wait, atomic_read(&buffer_ready)); 171 172 if (signal_pending(current)) 173 return -EINTR; 174 175 /* can't currently happen */ 176 if (!atomic_read(&buffer_ready)) 177 return -EAGAIN; 178 179 mutex_lock(&buffer_mutex); 180 181 /* May happen if the buffer is freed during pending reads. */ 182 if (!event_buffer) { 183 retval = -EINTR; 184 goto out; 185 } 186 187 atomic_set(&buffer_ready, 0); 188 189 retval = -EFAULT; 190 191 count = buffer_pos * sizeof(unsigned long); 192 193 if (copy_to_user(buf, event_buffer, count)) 194 goto out; 195 196 retval = count; 197 buffer_pos = 0; 198 199out: 200 mutex_unlock(&buffer_mutex); 201 return retval; 202} 203 204const struct file_operations event_buffer_fops = { 205 .open = event_buffer_open, 206 .release = event_buffer_release, 207 .read = event_buffer_read, 208 .llseek = no_llseek, 209}; 210