[PATCH] debugfs: add header file
[linux-3.10.git] / fs / debugfs / file.c
1 /*
2  *  file.c - part of debugfs, a tiny little debug file system
3  *
4  *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
5  *  Copyright (C) 2004 IBM Inc.
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License version
9  *      2 as published by the Free Software Foundation.
10  *
11  *  debugfs is for people to use instead of /proc or /sys.
12  *  See Documentation/DocBook/kernel-api for more details.
13  *
14  */
15
16 #include <linux/module.h>
17 #include <linux/fs.h>
18 #include <linux/pagemap.h>
19 #include <linux/debugfs.h>
20
21 static ssize_t default_read_file(struct file *file, char __user *buf,
22                                  size_t count, loff_t *ppos)
23 {
24         return 0;
25 }
26
27 static ssize_t default_write_file(struct file *file, const char __user *buf,
28                                    size_t count, loff_t *ppos)
29 {
30         return count;
31 }
32
33 static int default_open(struct inode *inode, struct file *file)
34 {
35         if (inode->i_private)
36                 file->private_data = inode->i_private;
37
38         return 0;
39 }
40
41 const struct file_operations debugfs_file_operations = {
42         .read =         default_read_file,
43         .write =        default_write_file,
44         .open =         default_open,
45 };
46
47 static void debugfs_u8_set(void *data, u64 val)
48 {
49         *(u8 *)data = val;
50 }
51 static u64 debugfs_u8_get(void *data)
52 {
53         return *(u8 *)data;
54 }
55 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
56
57 /**
58  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
59  * @name: a pointer to a string containing the name of the file to create.
60  * @mode: the permission that the file should have
61  * @parent: a pointer to the parent dentry for this file.  This should be a
62  *          directory dentry if set.  If this parameter is %NULL, then the
63  *          file will be created in the root of the debugfs filesystem.
64  * @value: a pointer to the variable that the file should read to and write
65  *         from.
66  *
67  * This function creates a file in debugfs with the given name that
68  * contains the value of the variable @value.  If the @mode variable is so
69  * set, it can be read from, and written to.
70  *
71  * This function will return a pointer to a dentry if it succeeds.  This
72  * pointer must be passed to the debugfs_remove() function when the file is
73  * to be removed (no automatic cleanup happens if your module is unloaded,
74  * you are responsible here.)  If an error occurs, %NULL will be returned.
75  *
76  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
77  * returned.  It is not wise to check for this value, but rather, check for
78  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
79  * code.
80  */
81 struct dentry *debugfs_create_u8(const char *name, mode_t mode,
82                                  struct dentry *parent, u8 *value)
83 {
84         return debugfs_create_file(name, mode, parent, value, &fops_u8);
85 }
86 EXPORT_SYMBOL_GPL(debugfs_create_u8);
87
88 static void debugfs_u16_set(void *data, u64 val)
89 {
90         *(u16 *)data = val;
91 }
92 static u64 debugfs_u16_get(void *data)
93 {
94         return *(u16 *)data;
95 }
96 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
97
98 /**
99  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
100  * @name: a pointer to a string containing the name of the file to create.
101  * @mode: the permission that the file should have
102  * @parent: a pointer to the parent dentry for this file.  This should be a
103  *          directory dentry if set.  If this parameter is %NULL, then the
104  *          file will be created in the root of the debugfs filesystem.
105  * @value: a pointer to the variable that the file should read to and write
106  *         from.
107  *
108  * This function creates a file in debugfs with the given name that
109  * contains the value of the variable @value.  If the @mode variable is so
110  * set, it can be read from, and written to.
111  *
112  * This function will return a pointer to a dentry if it succeeds.  This
113  * pointer must be passed to the debugfs_remove() function when the file is
114  * to be removed (no automatic cleanup happens if your module is unloaded,
115  * you are responsible here.)  If an error occurs, %NULL will be returned.
116  *
117  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
118  * returned.  It is not wise to check for this value, but rather, check for
119  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
120  * code.
121  */
122 struct dentry *debugfs_create_u16(const char *name, mode_t mode,
123                                   struct dentry *parent, u16 *value)
124 {
125         return debugfs_create_file(name, mode, parent, value, &fops_u16);
126 }
127 EXPORT_SYMBOL_GPL(debugfs_create_u16);
128
129 static void debugfs_u32_set(void *data, u64 val)
130 {
131         *(u32 *)data = val;
132 }
133 static u64 debugfs_u32_get(void *data)
134 {
135         return *(u32 *)data;
136 }
137 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
138
139 /**
140  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
141  * @name: a pointer to a string containing the name of the file to create.
142  * @mode: the permission that the file should have
143  * @parent: a pointer to the parent dentry for this file.  This should be a
144  *          directory dentry if set.  If this parameter is %NULL, then the
145  *          file will be created in the root of the debugfs filesystem.
146  * @value: a pointer to the variable that the file should read to and write
147  *         from.
148  *
149  * This function creates a file in debugfs with the given name that
150  * contains the value of the variable @value.  If the @mode variable is so
151  * set, it can be read from, and written to.
152  *
153  * This function will return a pointer to a dentry if it succeeds.  This
154  * pointer must be passed to the debugfs_remove() function when the file is
155  * to be removed (no automatic cleanup happens if your module is unloaded,
156  * you are responsible here.)  If an error occurs, %NULL will be returned.
157  *
158  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
159  * returned.  It is not wise to check for this value, but rather, check for
160  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
161  * code.
162  */
163 struct dentry *debugfs_create_u32(const char *name, mode_t mode,
164                                  struct dentry *parent, u32 *value)
165 {
166         return debugfs_create_file(name, mode, parent, value, &fops_u32);
167 }
168 EXPORT_SYMBOL_GPL(debugfs_create_u32);
169
170 static ssize_t read_file_bool(struct file *file, char __user *user_buf,
171                               size_t count, loff_t *ppos)
172 {
173         char buf[3];
174         u32 *val = file->private_data;
175         
176         if (*val)
177                 buf[0] = 'Y';
178         else
179                 buf[0] = 'N';
180         buf[1] = '\n';
181         buf[2] = 0x00;
182         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
183 }
184
185 static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
186                                size_t count, loff_t *ppos)
187 {
188         char buf[32];
189         int buf_size;
190         u32 *val = file->private_data;
191
192         buf_size = min(count, (sizeof(buf)-1));
193         if (copy_from_user(buf, user_buf, buf_size))
194                 return -EFAULT;
195
196         switch (buf[0]) {
197         case 'y':
198         case 'Y':
199         case '1':
200                 *val = 1;
201                 break;
202         case 'n':
203         case 'N':
204         case '0':
205                 *val = 0;
206                 break;
207         }
208         
209         return count;
210 }
211
212 static const struct file_operations fops_bool = {
213         .read =         read_file_bool,
214         .write =        write_file_bool,
215         .open =         default_open,
216 };
217
218 /**
219  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
220  * @name: a pointer to a string containing the name of the file to create.
221  * @mode: the permission that the file should have
222  * @parent: a pointer to the parent dentry for this file.  This should be a
223  *          directory dentry if set.  If this parameter is %NULL, then the
224  *          file will be created in the root of the debugfs filesystem.
225  * @value: a pointer to the variable that the file should read to and write
226  *         from.
227  *
228  * This function creates a file in debugfs with the given name that
229  * contains the value of the variable @value.  If the @mode variable is so
230  * set, it can be read from, and written to.
231  *
232  * This function will return a pointer to a dentry if it succeeds.  This
233  * pointer must be passed to the debugfs_remove() function when the file is
234  * to be removed (no automatic cleanup happens if your module is unloaded,
235  * you are responsible here.)  If an error occurs, %NULL will be returned.
236  *
237  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
238  * returned.  It is not wise to check for this value, but rather, check for
239  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
240  * code.
241  */
242 struct dentry *debugfs_create_bool(const char *name, mode_t mode,
243                                    struct dentry *parent, u32 *value)
244 {
245         return debugfs_create_file(name, mode, parent, value, &fops_bool);
246 }
247 EXPORT_SYMBOL_GPL(debugfs_create_bool);
248
249 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
250                               size_t count, loff_t *ppos)
251 {
252         struct debugfs_blob_wrapper *blob = file->private_data;
253         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
254                         blob->size);
255 }
256
257 static struct file_operations fops_blob = {
258         .read =         read_file_blob,
259         .open =         default_open,
260 };
261
262 /**
263  * debugfs_create_blob - create a debugfs file that is used to read and write a binary blob
264  * @name: a pointer to a string containing the name of the file to create.
265  * @mode: the permission that the file should have
266  * @parent: a pointer to the parent dentry for this file.  This should be a
267  *          directory dentry if set.  If this parameter is %NULL, then the
268  *          file will be created in the root of the debugfs filesystem.
269  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
270  *        to the blob data and the size of the data.
271  *
272  * This function creates a file in debugfs with the given name that exports
273  * @blob->data as a binary blob. If the @mode variable is so set it can be
274  * read from. Writing is not supported.
275  *
276  * This function will return a pointer to a dentry if it succeeds.  This
277  * pointer must be passed to the debugfs_remove() function when the file is
278  * to be removed (no automatic cleanup happens if your module is unloaded,
279  * you are responsible here.)  If an error occurs, %NULL will be returned.
280  *
281  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
282  * returned.  It is not wise to check for this value, but rather, check for
283  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
284  * code.
285  */
286 struct dentry *debugfs_create_blob(const char *name, mode_t mode,
287                                    struct dentry *parent,
288                                    struct debugfs_blob_wrapper *blob)
289 {
290         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
291 }
292 EXPORT_SYMBOL_GPL(debugfs_create_blob);