Add x64 support to debugfs
[linux-2.6.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/filesystems for more details.
13  *
14  */
15
16 #include <linux/module.h>
17 #include <linux/fs.h>
18 #include <linux/pagemap.h>
19 #include <linux/namei.h>
20 #include <linux/debugfs.h>
21
22 static ssize_t default_read_file(struct file *file, char __user *buf,
23                                  size_t count, loff_t *ppos)
24 {
25         return 0;
26 }
27
28 static ssize_t default_write_file(struct file *file, const char __user *buf,
29                                    size_t count, loff_t *ppos)
30 {
31         return count;
32 }
33
34 static int default_open(struct inode *inode, struct file *file)
35 {
36         if (inode->i_private)
37                 file->private_data = inode->i_private;
38
39         return 0;
40 }
41
42 const struct file_operations debugfs_file_operations = {
43         .read =         default_read_file,
44         .write =        default_write_file,
45         .open =         default_open,
46 };
47
48 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
49 {
50         nd_set_link(nd, dentry->d_inode->i_private);
51         return NULL;
52 }
53
54 const struct inode_operations debugfs_link_operations = {
55         .readlink       = generic_readlink,
56         .follow_link    = debugfs_follow_link,
57 };
58
59 static int debugfs_u8_set(void *data, u64 val)
60 {
61         *(u8 *)data = val;
62         return 0;
63 }
64 static int debugfs_u8_get(void *data, u64 *val)
65 {
66         *val = *(u8 *)data;
67         return 0;
68 }
69 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
70 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
71 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
72
73 /**
74  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
75  * @name: a pointer to a string containing the name of the file to create.
76  * @mode: the permission that the file should have
77  * @parent: a pointer to the parent dentry for this file.  This should be a
78  *          directory dentry if set.  If this parameter is %NULL, then the
79  *          file will be created in the root of the debugfs filesystem.
80  * @value: a pointer to the variable that the file should read to and write
81  *         from.
82  *
83  * This function creates a file in debugfs with the given name that
84  * contains the value of the variable @value.  If the @mode variable is so
85  * set, it can be read from, and written to.
86  *
87  * This function will return a pointer to a dentry if it succeeds.  This
88  * pointer must be passed to the debugfs_remove() function when the file is
89  * to be removed (no automatic cleanup happens if your module is unloaded,
90  * you are responsible here.)  If an error occurs, %NULL will be returned.
91  *
92  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
93  * returned.  It is not wise to check for this value, but rather, check for
94  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
95  * code.
96  */
97 struct dentry *debugfs_create_u8(const char *name, mode_t mode,
98                                  struct dentry *parent, u8 *value)
99 {
100         /* if there are no write bits set, make read only */
101         if (!(mode & S_IWUGO))
102                 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
103         /* if there are no read bits set, make write only */
104         if (!(mode & S_IRUGO))
105                 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
106
107         return debugfs_create_file(name, mode, parent, value, &fops_u8);
108 }
109 EXPORT_SYMBOL_GPL(debugfs_create_u8);
110
111 static int debugfs_u16_set(void *data, u64 val)
112 {
113         *(u16 *)data = val;
114         return 0;
115 }
116 static int debugfs_u16_get(void *data, u64 *val)
117 {
118         *val = *(u16 *)data;
119         return 0;
120 }
121 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
122 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
123 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
124
125 /**
126  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
127  * @name: a pointer to a string containing the name of the file to create.
128  * @mode: the permission that the file should have
129  * @parent: a pointer to the parent dentry for this file.  This should be a
130  *          directory dentry if set.  If this parameter is %NULL, then the
131  *          file will be created in the root of the debugfs filesystem.
132  * @value: a pointer to the variable that the file should read to and write
133  *         from.
134  *
135  * This function creates a file in debugfs with the given name that
136  * contains the value of the variable @value.  If the @mode variable is so
137  * set, it can be read from, and written to.
138  *
139  * This function will return a pointer to a dentry if it succeeds.  This
140  * pointer must be passed to the debugfs_remove() function when the file is
141  * to be removed (no automatic cleanup happens if your module is unloaded,
142  * you are responsible here.)  If an error occurs, %NULL will be returned.
143  *
144  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
145  * returned.  It is not wise to check for this value, but rather, check for
146  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
147  * code.
148  */
149 struct dentry *debugfs_create_u16(const char *name, mode_t mode,
150                                   struct dentry *parent, u16 *value)
151 {
152         /* if there are no write bits set, make read only */
153         if (!(mode & S_IWUGO))
154                 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
155         /* if there are no read bits set, make write only */
156         if (!(mode & S_IRUGO))
157                 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
158
159         return debugfs_create_file(name, mode, parent, value, &fops_u16);
160 }
161 EXPORT_SYMBOL_GPL(debugfs_create_u16);
162
163 static int debugfs_u32_set(void *data, u64 val)
164 {
165         *(u32 *)data = val;
166         return 0;
167 }
168 static int debugfs_u32_get(void *data, u64 *val)
169 {
170         *val = *(u32 *)data;
171         return 0;
172 }
173 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
174 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
175 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
176
177 /**
178  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
179  * @name: a pointer to a string containing the name of the file to create.
180  * @mode: the permission that the file should have
181  * @parent: a pointer to the parent dentry for this file.  This should be a
182  *          directory dentry if set.  If this parameter is %NULL, then the
183  *          file will be created in the root of the debugfs filesystem.
184  * @value: a pointer to the variable that the file should read to and write
185  *         from.
186  *
187  * This function creates a file in debugfs with the given name that
188  * contains the value of the variable @value.  If the @mode variable is so
189  * set, it can be read from, and written to.
190  *
191  * This function will return a pointer to a dentry if it succeeds.  This
192  * pointer must be passed to the debugfs_remove() function when the file is
193  * to be removed (no automatic cleanup happens if your module is unloaded,
194  * you are responsible here.)  If an error occurs, %NULL will be returned.
195  *
196  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
197  * returned.  It is not wise to check for this value, but rather, check for
198  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
199  * code.
200  */
201 struct dentry *debugfs_create_u32(const char *name, mode_t mode,
202                                  struct dentry *parent, u32 *value)
203 {
204         /* if there are no write bits set, make read only */
205         if (!(mode & S_IWUGO))
206                 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
207         /* if there are no read bits set, make write only */
208         if (!(mode & S_IRUGO))
209                 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
210
211         return debugfs_create_file(name, mode, parent, value, &fops_u32);
212 }
213 EXPORT_SYMBOL_GPL(debugfs_create_u32);
214
215 static int debugfs_u64_set(void *data, u64 val)
216 {
217         *(u64 *)data = val;
218         return 0;
219 }
220
221 static int debugfs_u64_get(void *data, u64 *val)
222 {
223         *val = *(u64 *)data;
224         return 0;
225 }
226 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
227 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
228 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
229
230 /**
231  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
232  * @name: a pointer to a string containing the name of the file to create.
233  * @mode: the permission that the file should have
234  * @parent: a pointer to the parent dentry for this file.  This should be a
235  *          directory dentry if set.  If this parameter is %NULL, then the
236  *          file will be created in the root of the debugfs filesystem.
237  * @value: a pointer to the variable that the file should read to and write
238  *         from.
239  *
240  * This function creates a file in debugfs with the given name that
241  * contains the value of the variable @value.  If the @mode variable is so
242  * set, it can be read from, and written to.
243  *
244  * This function will return a pointer to a dentry if it succeeds.  This
245  * pointer must be passed to the debugfs_remove() function when the file is
246  * to be removed (no automatic cleanup happens if your module is unloaded,
247  * you are responsible here.)  If an error occurs, %NULL will be returned.
248  *
249  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
250  * returned.  It is not wise to check for this value, but rather, check for
251  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
252  * code.
253  */
254 struct dentry *debugfs_create_u64(const char *name, mode_t mode,
255                                  struct dentry *parent, u64 *value)
256 {
257         /* if there are no write bits set, make read only */
258         if (!(mode & S_IWUGO))
259                 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
260         /* if there are no read bits set, make write only */
261         if (!(mode & S_IRUGO))
262                 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
263
264         return debugfs_create_file(name, mode, parent, value, &fops_u64);
265 }
266 EXPORT_SYMBOL_GPL(debugfs_create_u64);
267
268 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
269 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
270 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
271
272 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
273 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
274 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
275
276 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
277 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
278 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
279
280 DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
281
282 /*
283  * debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value
284  *
285  * These functions are exactly the same as the above functions (but use a hex
286  * output for the decimal challenged). For details look at the above unsigned
287  * decimal functions.
288  */
289
290 /**
291  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
292  * @name: a pointer to a string containing the name of the file to create.
293  * @mode: the permission that the file should have
294  * @parent: a pointer to the parent dentry for this file.  This should be a
295  *          directory dentry if set.  If this parameter is %NULL, then the
296  *          file will be created in the root of the debugfs filesystem.
297  * @value: a pointer to the variable that the file should read to and write
298  *         from.
299  */
300 struct dentry *debugfs_create_x8(const char *name, mode_t mode,
301                                  struct dentry *parent, u8 *value)
302 {
303         /* if there are no write bits set, make read only */
304         if (!(mode & S_IWUGO))
305                 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
306         /* if there are no read bits set, make write only */
307         if (!(mode & S_IRUGO))
308                 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
309
310         return debugfs_create_file(name, mode, parent, value, &fops_x8);
311 }
312 EXPORT_SYMBOL_GPL(debugfs_create_x8);
313
314 /**
315  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
316  * @name: a pointer to a string containing the name of the file to create.
317  * @mode: the permission that the file should have
318  * @parent: a pointer to the parent dentry for this file.  This should be a
319  *          directory dentry if set.  If this parameter is %NULL, then the
320  *          file will be created in the root of the debugfs filesystem.
321  * @value: a pointer to the variable that the file should read to and write
322  *         from.
323  */
324 struct dentry *debugfs_create_x16(const char *name, mode_t mode,
325                                  struct dentry *parent, u16 *value)
326 {
327         /* if there are no write bits set, make read only */
328         if (!(mode & S_IWUGO))
329                 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
330         /* if there are no read bits set, make write only */
331         if (!(mode & S_IRUGO))
332                 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
333
334         return debugfs_create_file(name, mode, parent, value, &fops_x16);
335 }
336 EXPORT_SYMBOL_GPL(debugfs_create_x16);
337
338 /**
339  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
340  * @name: a pointer to a string containing the name of the file to create.
341  * @mode: the permission that the file should have
342  * @parent: a pointer to the parent dentry for this file.  This should be a
343  *          directory dentry if set.  If this parameter is %NULL, then the
344  *          file will be created in the root of the debugfs filesystem.
345  * @value: a pointer to the variable that the file should read to and write
346  *         from.
347  */
348 struct dentry *debugfs_create_x32(const char *name, mode_t mode,
349                                  struct dentry *parent, u32 *value)
350 {
351         /* if there are no write bits set, make read only */
352         if (!(mode & S_IWUGO))
353                 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
354         /* if there are no read bits set, make write only */
355         if (!(mode & S_IRUGO))
356                 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
357
358         return debugfs_create_file(name, mode, parent, value, &fops_x32);
359 }
360 EXPORT_SYMBOL_GPL(debugfs_create_x32);
361
362 /**
363  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
364  * @name: a pointer to a string containing the name of the file to create.
365  * @mode: the permission that the file should have
366  * @parent: a pointer to the parent dentry for this file.  This should be a
367  *          directory dentry if set.  If this parameter is %NULL, then the
368  *          file will be created in the root of the debugfs filesystem.
369  * @value: a pointer to the variable that the file should read to and write
370  *         from.
371  */
372 struct dentry *debugfs_create_x64(const char *name, mode_t mode,
373                                  struct dentry *parent, u64 *value)
374 {
375         return debugfs_create_file(name, mode, parent, value, &fops_x64);
376 }
377 EXPORT_SYMBOL_GPL(debugfs_create_x64);
378
379
380 static int debugfs_size_t_set(void *data, u64 val)
381 {
382         *(size_t *)data = val;
383         return 0;
384 }
385 static int debugfs_size_t_get(void *data, u64 *val)
386 {
387         *val = *(size_t *)data;
388         return 0;
389 }
390 DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
391                         "%llu\n");      /* %llu and %zu are more or less the same */
392
393 /**
394  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
395  * @name: a pointer to a string containing the name of the file to create.
396  * @mode: the permission that the file should have
397  * @parent: a pointer to the parent dentry for this file.  This should be a
398  *          directory dentry if set.  If this parameter is %NULL, then the
399  *          file will be created in the root of the debugfs filesystem.
400  * @value: a pointer to the variable that the file should read to and write
401  *         from.
402  */
403 struct dentry *debugfs_create_size_t(const char *name, mode_t mode,
404                                      struct dentry *parent, size_t *value)
405 {
406         return debugfs_create_file(name, mode, parent, value, &fops_size_t);
407 }
408 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
409
410
411 static ssize_t read_file_bool(struct file *file, char __user *user_buf,
412                               size_t count, loff_t *ppos)
413 {
414         char buf[3];
415         u32 *val = file->private_data;
416         
417         if (*val)
418                 buf[0] = 'Y';
419         else
420                 buf[0] = 'N';
421         buf[1] = '\n';
422         buf[2] = 0x00;
423         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
424 }
425
426 static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
427                                size_t count, loff_t *ppos)
428 {
429         char buf[32];
430         int buf_size;
431         u32 *val = file->private_data;
432
433         buf_size = min(count, (sizeof(buf)-1));
434         if (copy_from_user(buf, user_buf, buf_size))
435                 return -EFAULT;
436
437         switch (buf[0]) {
438         case 'y':
439         case 'Y':
440         case '1':
441                 *val = 1;
442                 break;
443         case 'n':
444         case 'N':
445         case '0':
446                 *val = 0;
447                 break;
448         }
449         
450         return count;
451 }
452
453 static const struct file_operations fops_bool = {
454         .read =         read_file_bool,
455         .write =        write_file_bool,
456         .open =         default_open,
457 };
458
459 /**
460  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
461  * @name: a pointer to a string containing the name of the file to create.
462  * @mode: the permission that the file should have
463  * @parent: a pointer to the parent dentry for this file.  This should be a
464  *          directory dentry if set.  If this parameter is %NULL, then the
465  *          file will be created in the root of the debugfs filesystem.
466  * @value: a pointer to the variable that the file should read to and write
467  *         from.
468  *
469  * This function creates a file in debugfs with the given name that
470  * contains the value of the variable @value.  If the @mode variable is so
471  * set, it can be read from, and written to.
472  *
473  * This function will return a pointer to a dentry if it succeeds.  This
474  * pointer must be passed to the debugfs_remove() function when the file is
475  * to be removed (no automatic cleanup happens if your module is unloaded,
476  * you are responsible here.)  If an error occurs, %NULL will be returned.
477  *
478  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
479  * returned.  It is not wise to check for this value, but rather, check for
480  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
481  * code.
482  */
483 struct dentry *debugfs_create_bool(const char *name, mode_t mode,
484                                    struct dentry *parent, u32 *value)
485 {
486         return debugfs_create_file(name, mode, parent, value, &fops_bool);
487 }
488 EXPORT_SYMBOL_GPL(debugfs_create_bool);
489
490 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
491                               size_t count, loff_t *ppos)
492 {
493         struct debugfs_blob_wrapper *blob = file->private_data;
494         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
495                         blob->size);
496 }
497
498 static const struct file_operations fops_blob = {
499         .read =         read_file_blob,
500         .open =         default_open,
501 };
502
503 /**
504  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
505  * @name: a pointer to a string containing the name of the file to create.
506  * @mode: the permission that the file should have
507  * @parent: a pointer to the parent dentry for this file.  This should be a
508  *          directory dentry if set.  If this parameter is %NULL, then the
509  *          file will be created in the root of the debugfs filesystem.
510  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
511  *        to the blob data and the size of the data.
512  *
513  * This function creates a file in debugfs with the given name that exports
514  * @blob->data as a binary blob. If the @mode variable is so set it can be
515  * read from. Writing is not supported.
516  *
517  * This function will return a pointer to a dentry if it succeeds.  This
518  * pointer must be passed to the debugfs_remove() function when the file is
519  * to be removed (no automatic cleanup happens if your module is unloaded,
520  * you are responsible here.)  If an error occurs, %NULL will be returned.
521  *
522  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
523  * returned.  It is not wise to check for this value, but rather, check for
524  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
525  * code.
526  */
527 struct dentry *debugfs_create_blob(const char *name, mode_t mode,
528                                    struct dentry *parent,
529                                    struct debugfs_blob_wrapper *blob)
530 {
531         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
532 }
533 EXPORT_SYMBOL_GPL(debugfs_create_blob);