Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 /**
  2  * @file oprofile_files.c
  3  *
  4  * @remark Copyright 2002 OProfile authors
  5  * @remark Read the file COPYING
  6  *
  7  * @author John Levon <levon@movementarian.org>
  8  */
  9 
 10 #include <linux/fs.h>
 11 #include <linux/oprofile.h>
 12 
 13 #include "event_buffer.h"
 14 #include "oprofile_stats.h"
 15 #include "oprof.h"
 16 
 17 #define BUFFER_SIZE_DEFAULT             131072
 18 #define CPU_BUFFER_SIZE_DEFAULT         8192
 19 #define BUFFER_WATERSHED_DEFAULT        32768   /* FIXME: tune */
 20 
 21 unsigned long oprofile_buffer_size;
 22 unsigned long oprofile_cpu_buffer_size;
 23 unsigned long oprofile_buffer_watershed;
 24 
 25 static ssize_t depth_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 26 {
 27         return oprofilefs_ulong_to_user(oprofile_backtrace_depth, buf, count,
 28                                         offset);
 29 }
 30 
 31 
 32 static ssize_t depth_write(struct file *file, char const __user *buf, size_t count, loff_t *offset)
 33 {
 34         unsigned long val;
 35         int retval;
 36 
 37         if (*offset)
 38                 return -EINVAL;
 39 
 40         retval = oprofilefs_ulong_from_user(&val, buf, count);
 41         if (retval)
 42                 return retval;
 43 
 44         retval = oprofile_set_backtrace(val);
 45 
 46         if (retval)
 47                 return retval;
 48         return count;
 49 }
 50 
 51 
 52 static const struct file_operations depth_fops = {
 53         .read           = depth_read,
 54         .write          = depth_write
 55 };
 56 
 57 
 58 static ssize_t pointer_size_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 59 {
 60         return oprofilefs_ulong_to_user(sizeof(void *), buf, count, offset);
 61 }
 62 
 63 
 64 static const struct file_operations pointer_size_fops = {
 65         .read           = pointer_size_read,
 66 };
 67 
 68 
 69 static ssize_t cpu_type_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 70 {
 71         return oprofilefs_str_to_user(oprofile_ops.cpu_type, buf, count, offset);
 72 }
 73 
 74 
 75 static const struct file_operations cpu_type_fops = {
 76         .read           = cpu_type_read,
 77 };
 78 
 79 
 80 static ssize_t enable_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 81 {
 82         return oprofilefs_ulong_to_user(oprofile_started, buf, count, offset);
 83 }
 84 
 85 
 86 static ssize_t enable_write(struct file *file, char const __user *buf, size_t count, loff_t *offset)
 87 {
 88         unsigned long val;
 89         int retval;
 90 
 91         if (*offset)
 92                 return -EINVAL;
 93 
 94         retval = oprofilefs_ulong_from_user(&val, buf, count);
 95         if (retval)
 96                 return retval;
 97 
 98         if (val)
 99                 retval = oprofile_start();
100         else
101                 oprofile_stop();
102 
103         if (retval)
104                 return retval;
105         return count;
106 }
107 
108 
109 static const struct file_operations enable_fops = {
110         .read           = enable_read,
111         .write          = enable_write,
112 };
113 
114 
115 static ssize_t dump_write(struct file *file, char const __user *buf, size_t count, loff_t *offset)
116 {
117         wake_up_buffer_waiter();
118         return count;
119 }
120 
121 
122 static const struct file_operations dump_fops = {
123         .write          = dump_write,
124 };
125 
126 void oprofile_create_files(struct super_block *sb, struct dentry *root)
127 {
128         /* reinitialize default values */
129         oprofile_buffer_size =          BUFFER_SIZE_DEFAULT;
130         oprofile_cpu_buffer_size =      CPU_BUFFER_SIZE_DEFAULT;
131         oprofile_buffer_watershed =     BUFFER_WATERSHED_DEFAULT;
132 
133         oprofilefs_create_file(sb, root, "enable", &enable_fops);
134         oprofilefs_create_file_perm(sb, root, "dump", &dump_fops, 0666);
135         oprofilefs_create_file(sb, root, "buffer", &event_buffer_fops);
136         oprofilefs_create_ulong(sb, root, "buffer_size", &oprofile_buffer_size);
137         oprofilefs_create_ulong(sb, root, "buffer_watershed", &oprofile_buffer_watershed);
138         oprofilefs_create_ulong(sb, root, "cpu_buffer_size", &oprofile_cpu_buffer_size);
139         oprofilefs_create_file(sb, root, "cpu_type", &cpu_type_fops);
140         oprofilefs_create_file(sb, root, "backtrace_depth", &depth_fops);
141         oprofilefs_create_file(sb, root, "pointer_size", &pointer_size_fops);
142         oprofile_create_stats_files(sb, root);
143         if (oprofile_ops.create_files)
144                 oprofile_ops.create_files(sb, root);
145 }
146 
  This page was automatically generated by the LXR engine.