~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/debugfs/file.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/seq_file.h>
 19 #include <linux/pagemap.h>
 20 #include <linux/namei.h>
 21 #include <linux/debugfs.h>
 22 #include <linux/io.h>
 23 #include <linux/slab.h>
 24 #include <linux/atomic.h>
 25 
 26 static ssize_t default_read_file(struct file *file, char __user *buf,
 27                                  size_t count, loff_t *ppos)
 28 {
 29         return 0;
 30 }
 31 
 32 static ssize_t default_write_file(struct file *file, const char __user *buf,
 33                                    size_t count, loff_t *ppos)
 34 {
 35         return count;
 36 }
 37 
 38 const struct file_operations debugfs_file_operations = {
 39         .read =         default_read_file,
 40         .write =        default_write_file,
 41         .open =         simple_open,
 42         .llseek =       noop_llseek,
 43 };
 44 
 45 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 46 {
 47         nd_set_link(nd, dentry->d_inode->i_private);
 48         return NULL;
 49 }
 50 
 51 const struct inode_operations debugfs_link_operations = {
 52         .readlink       = generic_readlink,
 53         .follow_link    = debugfs_follow_link,
 54 };
 55 
 56 static int debugfs_u8_set(void *data, u64 val)
 57 {
 58         *(u8 *)data = val;
 59         return 0;
 60 }
 61 static int debugfs_u8_get(void *data, u64 *val)
 62 {
 63         *val = *(u8 *)data;
 64         return 0;
 65 }
 66 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
 67 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
 68 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 69 
 70 /**
 71  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 72  * @name: a pointer to a string containing the name of the file to create.
 73  * @mode: the permission that the file should have
 74  * @parent: a pointer to the parent dentry for this file.  This should be a
 75  *          directory dentry if set.  If this parameter is %NULL, then the
 76  *          file will be created in the root of the debugfs filesystem.
 77  * @value: a pointer to the variable that the file should read to and write
 78  *         from.
 79  *
 80  * This function creates a file in debugfs with the given name that
 81  * contains the value of the variable @value.  If the @mode variable is so
 82  * set, it can be read from, and written to.
 83  *
 84  * This function will return a pointer to a dentry if it succeeds.  This
 85  * pointer must be passed to the debugfs_remove() function when the file is
 86  * to be removed (no automatic cleanup happens if your module is unloaded,
 87  * you are responsible here.)  If an error occurs, %NULL will be returned.
 88  *
 89  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 90  * returned.  It is not wise to check for this value, but rather, check for
 91  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 92  * code.
 93  */
 94 struct dentry *debugfs_create_u8(const char *name, umode_t mode,
 95                                  struct dentry *parent, u8 *value)
 96 {
 97         /* if there are no write bits set, make read only */
 98         if (!(mode & S_IWUGO))
 99                 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
100         /* if there are no read bits set, make write only */
101         if (!(mode & S_IRUGO))
102                 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
103 
104         return debugfs_create_file(name, mode, parent, value, &fops_u8);
105 }
106 EXPORT_SYMBOL_GPL(debugfs_create_u8);
107 
108 static int debugfs_u16_set(void *data, u64 val)
109 {
110         *(u16 *)data = val;
111         return 0;
112 }
113 static int debugfs_u16_get(void *data, u64 *val)
114 {
115         *val = *(u16 *)data;
116         return 0;
117 }
118 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
119 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
120 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
121 
122 /**
123  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
124  * @name: a pointer to a string containing the name of the file to create.
125  * @mode: the permission that the file should have
126  * @parent: a pointer to the parent dentry for this file.  This should be a
127  *          directory dentry if set.  If this parameter is %NULL, then the
128  *          file will be created in the root of the debugfs filesystem.
129  * @value: a pointer to the variable that the file should read to and write
130  *         from.
131  *
132  * This function creates a file in debugfs with the given name that
133  * contains the value of the variable @value.  If the @mode variable is so
134  * set, it can be read from, and written to.
135  *
136  * This function will return a pointer to a dentry if it succeeds.  This
137  * pointer must be passed to the debugfs_remove() function when the file is
138  * to be removed (no automatic cleanup happens if your module is unloaded,
139  * you are responsible here.)  If an error occurs, %NULL will be returned.
140  *
141  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
142  * returned.  It is not wise to check for this value, but rather, check for
143  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
144  * code.
145  */
146 struct dentry *debugfs_create_u16(const char *name, umode_t mode,
147                                   struct dentry *parent, u16 *value)
148 {
149         /* if there are no write bits set, make read only */
150         if (!(mode & S_IWUGO))
151                 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
152         /* if there are no read bits set, make write only */
153         if (!(mode & S_IRUGO))
154                 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
155 
156         return debugfs_create_file(name, mode, parent, value, &fops_u16);
157 }
158 EXPORT_SYMBOL_GPL(debugfs_create_u16);
159 
160 static int debugfs_u32_set(void *data, u64 val)
161 {
162         *(u32 *)data = val;
163         return 0;
164 }
165 static int debugfs_u32_get(void *data, u64 *val)
166 {
167         *val = *(u32 *)data;
168         return 0;
169 }
170 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
171 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
172 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
173 
174 /**
175  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
176  * @name: a pointer to a string containing the name of the file to create.
177  * @mode: the permission that the file should have
178  * @parent: a pointer to the parent dentry for this file.  This should be a
179  *          directory dentry if set.  If this parameter is %NULL, then the
180  *          file will be created in the root of the debugfs filesystem.
181  * @value: a pointer to the variable that the file should read to and write
182  *         from.
183  *
184  * This function creates a file in debugfs with the given name that
185  * contains the value of the variable @value.  If the @mode variable is so
186  * set, it can be read from, and written to.
187  *
188  * This function will return a pointer to a dentry if it succeeds.  This
189  * pointer must be passed to the debugfs_remove() function when the file is
190  * to be removed (no automatic cleanup happens if your module is unloaded,
191  * you are responsible here.)  If an error occurs, %NULL will be returned.
192  *
193  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
194  * returned.  It is not wise to check for this value, but rather, check for
195  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
196  * code.
197  */
198 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
199                                  struct dentry *parent, u32 *value)
200 {
201         /* if there are no write bits set, make read only */
202         if (!(mode & S_IWUGO))
203                 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
204         /* if there are no read bits set, make write only */
205         if (!(mode & S_IRUGO))
206                 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
207 
208         return debugfs_create_file(name, mode, parent, value, &fops_u32);
209 }
210 EXPORT_SYMBOL_GPL(debugfs_create_u32);
211 
212 static int debugfs_u64_set(void *data, u64 val)
213 {
214         *(u64 *)data = val;
215         return 0;
216 }
217 
218 static int debugfs_u64_get(void *data, u64 *val)
219 {
220         *val = *(u64 *)data;
221         return 0;
222 }
223 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
224 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
225 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
226 
227 /**
228  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
229  * @name: a pointer to a string containing the name of the file to create.
230  * @mode: the permission that the file should have
231  * @parent: a pointer to the parent dentry for this file.  This should be a
232  *          directory dentry if set.  If this parameter is %NULL, then the
233  *          file will be created in the root of the debugfs filesystem.
234  * @value: a pointer to the variable that the file should read to and write
235  *         from.
236  *
237  * This function creates a file in debugfs with the given name that
238  * contains the value of the variable @value.  If the @mode variable is so
239  * set, it can be read from, and written to.
240  *
241  * This function will return a pointer to a dentry if it succeeds.  This
242  * pointer must be passed to the debugfs_remove() function when the file is
243  * to be removed (no automatic cleanup happens if your module is unloaded,
244  * you are responsible here.)  If an error occurs, %NULL will be returned.
245  *
246  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
247  * returned.  It is not wise to check for this value, but rather, check for
248  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
249  * code.
250  */
251 struct dentry *debugfs_create_u64(const char *name, umode_t mode,
252                                  struct dentry *parent, u64 *value)
253 {
254         /* if there are no write bits set, make read only */
255         if (!(mode & S_IWUGO))
256                 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
257         /* if there are no read bits set, make write only */
258         if (!(mode & S_IRUGO))
259                 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
260 
261         return debugfs_create_file(name, mode, parent, value, &fops_u64);
262 }
263 EXPORT_SYMBOL_GPL(debugfs_create_u64);
264 
265 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
266 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
267 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
268 
269 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
270 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
271 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
272 
273 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
274 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
275 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
276 
277 DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
278 
279 /*
280  * 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
281  *
282  * These functions are exactly the same as the above functions (but use a hex
283  * output for the decimal challenged). For details look at the above unsigned
284  * decimal functions.
285  */
286 
287 /**
288  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
289  * @name: a pointer to a string containing the name of the file to create.
290  * @mode: the permission that the file should have
291  * @parent: a pointer to the parent dentry for this file.  This should be a
292  *          directory dentry if set.  If this parameter is %NULL, then the
293  *          file will be created in the root of the debugfs filesystem.
294  * @value: a pointer to the variable that the file should read to and write
295  *         from.
296  */
297 struct dentry *debugfs_create_x8(const char *name, umode_t mode,
298                                  struct dentry *parent, u8 *value)
299 {
300         /* if there are no write bits set, make read only */
301         if (!(mode & S_IWUGO))
302                 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
303         /* if there are no read bits set, make write only */
304         if (!(mode & S_IRUGO))
305                 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
306 
307         return debugfs_create_file(name, mode, parent, value, &fops_x8);
308 }
309 EXPORT_SYMBOL_GPL(debugfs_create_x8);
310 
311 /**
312  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
313  * @name: a pointer to a string containing the name of the file to create.
314  * @mode: the permission that the file should have
315  * @parent: a pointer to the parent dentry for this file.  This should be a
316  *          directory dentry if set.  If this parameter is %NULL, then the
317  *          file will be created in the root of the debugfs filesystem.
318  * @value: a pointer to the variable that the file should read to and write
319  *         from.
320  */
321 struct dentry *debugfs_create_x16(const char *name, umode_t mode,
322                                  struct dentry *parent, u16 *value)
323 {
324         /* if there are no write bits set, make read only */
325         if (!(mode & S_IWUGO))
326                 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
327         /* if there are no read bits set, make write only */
328         if (!(mode & S_IRUGO))
329                 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
330 
331         return debugfs_create_file(name, mode, parent, value, &fops_x16);
332 }
333 EXPORT_SYMBOL_GPL(debugfs_create_x16);
334 
335 /**
336  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
337  * @name: a pointer to a string containing the name of the file to create.
338  * @mode: the permission that the file should have
339  * @parent: a pointer to the parent dentry for this file.  This should be a
340  *          directory dentry if set.  If this parameter is %NULL, then the
341  *          file will be created in the root of the debugfs filesystem.
342  * @value: a pointer to the variable that the file should read to and write
343  *         from.
344  */
345 struct dentry *debugfs_create_x32(const char *name, umode_t mode,
346                                  struct dentry *parent, u32 *value)
347 {
348         /* if there are no write bits set, make read only */
349         if (!(mode & S_IWUGO))
350                 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
351         /* if there are no read bits set, make write only */
352         if (!(mode & S_IRUGO))
353                 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
354 
355         return debugfs_create_file(name, mode, parent, value, &fops_x32);
356 }
357 EXPORT_SYMBOL_GPL(debugfs_create_x32);
358 
359 /**
360  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
361  * @name: a pointer to a string containing the name of the file to create.
362  * @mode: the permission that the file should have
363  * @parent: a pointer to the parent dentry for this file.  This should be a
364  *          directory dentry if set.  If this parameter is %NULL, then the
365  *          file will be created in the root of the debugfs filesystem.
366  * @value: a pointer to the variable that the file should read to and write
367  *         from.
368  */
369 struct dentry *debugfs_create_x64(const char *name, umode_t mode,
370                                  struct dentry *parent, u64 *value)
371 {
372         return debugfs_create_file(name, mode, parent, value, &fops_x64);
373 }
374 EXPORT_SYMBOL_GPL(debugfs_create_x64);
375 
376 
377 static int debugfs_size_t_set(void *data, u64 val)
378 {
379         *(size_t *)data = val;
380         return 0;
381 }
382 static int debugfs_size_t_get(void *data, u64 *val)
383 {
384         *val = *(size_t *)data;
385         return 0;
386 }
387 DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
388                         "%llu\n");      /* %llu and %zu are more or less the same */
389 
390 /**
391  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
392  * @name: a pointer to a string containing the name of the file to create.
393  * @mode: the permission that the file should have
394  * @parent: a pointer to the parent dentry for this file.  This should be a
395  *          directory dentry if set.  If this parameter is %NULL, then the
396  *          file will be created in the root of the debugfs filesystem.
397  * @value: a pointer to the variable that the file should read to and write
398  *         from.
399  */
400 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
401                                      struct dentry *parent, size_t *value)
402 {
403         return debugfs_create_file(name, mode, parent, value, &fops_size_t);
404 }
405 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
406 
407 static int debugfs_atomic_t_set(void *data, u64 val)
408 {
409         atomic_set((atomic_t *)data, val);
410         return 0;
411 }
412 static int debugfs_atomic_t_get(void *data, u64 *val)
413 {
414         *val = atomic_read((atomic_t *)data);
415         return 0;
416 }
417 DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
418                         debugfs_atomic_t_set, "%lld\n");
419 DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, "%lld\n");
420 DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
421 
422 /**
423  * debugfs_create_atomic_t - create a debugfs file that is used to read and
424  * write an atomic_t value
425  * @name: a pointer to a string containing the name of the file to create.
426  * @mode: the permission that the file should have
427  * @parent: a pointer to the parent dentry for this file.  This should be a
428  *          directory dentry if set.  If this parameter is %NULL, then the
429  *          file will be created in the root of the debugfs filesystem.
430  * @value: a pointer to the variable that the file should read to and write
431  *         from.
432  */
433 struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
434                                  struct dentry *parent, atomic_t *value)
435 {
436         /* if there are no write bits set, make read only */
437         if (!(mode & S_IWUGO))
438                 return debugfs_create_file(name, mode, parent, value,
439                                         &fops_atomic_t_ro);
440         /* if there are no read bits set, make write only */
441         if (!(mode & S_IRUGO))
442                 return debugfs_create_file(name, mode, parent, value,
443                                         &fops_atomic_t_wo);
444 
445         return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
446 }
447 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
448 
449 static ssize_t read_file_bool(struct file *file, char __user *user_buf,
450                               size_t count, loff_t *ppos)
451 {
452         char buf[3];
453         u32 *val = file->private_data;
454 
455         if (*val)
456                 buf[0] = 'Y';
457         else
458                 buf[0] = 'N';
459         buf[1] = '\n';
460         buf[2] = 0x00;
461         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
462 }
463 
464 static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
465                                size_t count, loff_t *ppos)
466 {
467         char buf[32];
468         size_t buf_size;
469         bool bv;
470         u32 *val = file->private_data;
471 
472         buf_size = min(count, (sizeof(buf)-1));
473         if (copy_from_user(buf, user_buf, buf_size))
474                 return -EFAULT;
475 
476         buf[buf_size] = '\0';
477         if (strtobool(buf, &bv) == 0)
478                 *val = bv;
479 
480         return count;
481 }
482 
483 static const struct file_operations fops_bool = {
484         .read =         read_file_bool,
485         .write =        write_file_bool,
486         .open =         simple_open,
487         .llseek =       default_llseek,
488 };
489 
490 /**
491  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
492  * @name: a pointer to a string containing the name of the file to create.
493  * @mode: the permission that the file should have
494  * @parent: a pointer to the parent dentry for this file.  This should be a
495  *          directory dentry if set.  If this parameter is %NULL, then the
496  *          file will be created in the root of the debugfs filesystem.
497  * @value: a pointer to the variable that the file should read to and write
498  *         from.
499  *
500  * This function creates a file in debugfs with the given name that
501  * contains the value of the variable @value.  If the @mode variable is so
502  * set, it can be read from, and written to.
503  *
504  * This function will return a pointer to a dentry if it succeeds.  This
505  * pointer must be passed to the debugfs_remove() function when the file is
506  * to be removed (no automatic cleanup happens if your module is unloaded,
507  * you are responsible here.)  If an error occurs, %NULL will be returned.
508  *
509  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
510  * returned.  It is not wise to check for this value, but rather, check for
511  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
512  * code.
513  */
514 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
515                                    struct dentry *parent, u32 *value)
516 {
517         return debugfs_create_file(name, mode, parent, value, &fops_bool);
518 }
519 EXPORT_SYMBOL_GPL(debugfs_create_bool);
520 
521 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
522                               size_t count, loff_t *ppos)
523 {
524         struct debugfs_blob_wrapper *blob = file->private_data;
525         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
526                         blob->size);
527 }
528 
529 static const struct file_operations fops_blob = {
530         .read =         read_file_blob,
531         .open =         simple_open,
532         .llseek =       default_llseek,
533 };
534 
535 /**
536  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
537  * @name: a pointer to a string containing the name of the file to create.
538  * @mode: the permission that the file should have
539  * @parent: a pointer to the parent dentry for this file.  This should be a
540  *          directory dentry if set.  If this parameter is %NULL, then the
541  *          file will be created in the root of the debugfs filesystem.
542  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
543  *        to the blob data and the size of the data.
544  *
545  * This function creates a file in debugfs with the given name that exports
546  * @blob->data as a binary blob. If the @mode variable is so set it can be
547  * read from. Writing is not supported.
548  *
549  * This function will return a pointer to a dentry if it succeeds.  This
550  * pointer must be passed to the debugfs_remove() function when the file is
551  * to be removed (no automatic cleanup happens if your module is unloaded,
552  * you are responsible here.)  If an error occurs, %NULL will be returned.
553  *
554  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
555  * returned.  It is not wise to check for this value, but rather, check for
556  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
557  * code.
558  */
559 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
560                                    struct dentry *parent,
561                                    struct debugfs_blob_wrapper *blob)
562 {
563         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
564 }
565 EXPORT_SYMBOL_GPL(debugfs_create_blob);
566 
567 struct array_data {
568         void *array;
569         u32 elements;
570 };
571 
572 static size_t u32_format_array(char *buf, size_t bufsize,
573                                u32 *array, int array_size)
574 {
575         size_t ret = 0;
576 
577         while (--array_size >= 0) {
578                 size_t len;
579                 char term = array_size ? ' ' : '\n';
580 
581                 len = snprintf(buf, bufsize, "%u%c", *array++, term);
582                 ret += len;
583 
584                 buf += len;
585                 bufsize -= len;
586         }
587         return ret;
588 }
589 
590 static int u32_array_open(struct inode *inode, struct file *file)
591 {
592         struct array_data *data = inode->i_private;
593         int size, elements = data->elements;
594         char *buf;
595 
596         /*
597          * Max size:
598          *  - 10 digits + ' '/'\n' = 11 bytes per number
599          *  - terminating NUL character
600          */
601         size = elements*11;
602         buf = kmalloc(size+1, GFP_KERNEL);
603         if (!buf)
604                 return -ENOMEM;
605         buf[size] = 0;
606 
607         file->private_data = buf;
608         u32_format_array(buf, size, data->array, data->elements);
609 
610         return nonseekable_open(inode, file);
611 }
612 
613 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
614                               loff_t *ppos)
615 {
616         size_t size = strlen(file->private_data);
617 
618         return simple_read_from_buffer(buf, len, ppos,
619                                         file->private_data, size);
620 }
621 
622 static int u32_array_release(struct inode *inode, struct file *file)
623 {
624         kfree(file->private_data);
625 
626         return 0;
627 }
628 
629 static const struct file_operations u32_array_fops = {
630         .owner   = THIS_MODULE,
631         .open    = u32_array_open,
632         .release = u32_array_release,
633         .read    = u32_array_read,
634         .llseek  = no_llseek,
635 };
636 
637 /**
638  * debugfs_create_u32_array - create a debugfs file that is used to read u32
639  * array.
640  * @name: a pointer to a string containing the name of the file to create.
641  * @mode: the permission that the file should have.
642  * @parent: a pointer to the parent dentry for this file.  This should be a
643  *          directory dentry if set.  If this parameter is %NULL, then the
644  *          file will be created in the root of the debugfs filesystem.
645  * @array: u32 array that provides data.
646  * @elements: total number of elements in the array.
647  *
648  * This function creates a file in debugfs with the given name that exports
649  * @array as data. If the @mode variable is so set it can be read from.
650  * Writing is not supported. Seek within the file is also not supported.
651  * Once array is created its size can not be changed.
652  *
653  * The function returns a pointer to dentry on success. If debugfs is not
654  * enabled in the kernel, the value -%ENODEV will be returned.
655  */
656 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
657                                             struct dentry *parent,
658                                             u32 *array, u32 elements)
659 {
660         struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
661 
662         if (data == NULL)
663                 return NULL;
664 
665         data->array = array;
666         data->elements = elements;
667 
668         return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
669 }
670 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
671 
672 #ifdef CONFIG_HAS_IOMEM
673 
674 /*
675  * The regset32 stuff is used to print 32-bit registers using the
676  * seq_file utilities. We offer printing a register set in an already-opened
677  * sequential file or create a debugfs file that only prints a regset32.
678  */
679 
680 /**
681  * debugfs_print_regs32 - use seq_print to describe a set of registers
682  * @s: the seq_file structure being used to generate output
683  * @regs: an array if struct debugfs_reg32 structures
684  * @nregs: the length of the above array
685  * @base: the base address to be used in reading the registers
686  * @prefix: a string to be prefixed to every output line
687  *
688  * This function outputs a text block describing the current values of
689  * some 32-bit hardware registers. It is meant to be used within debugfs
690  * files based on seq_file that need to show registers, intermixed with other
691  * information. The prefix argument may be used to specify a leading string,
692  * because some peripherals have several blocks of identical registers,
693  * for example configuration of dma channels
694  */
695 int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
696                            int nregs, void __iomem *base, char *prefix)
697 {
698         int i, ret = 0;
699 
700         for (i = 0; i < nregs; i++, regs++) {
701                 if (prefix)
702                         ret += seq_printf(s, "%s", prefix);
703                 ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
704                                   readl(base + regs->offset));
705         }
706         return ret;
707 }
708 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
709 
710 static int debugfs_show_regset32(struct seq_file *s, void *data)
711 {
712         struct debugfs_regset32 *regset = s->private;
713 
714         debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
715         return 0;
716 }
717 
718 static int debugfs_open_regset32(struct inode *inode, struct file *file)
719 {
720         return single_open(file, debugfs_show_regset32, inode->i_private);
721 }
722 
723 static const struct file_operations fops_regset32 = {
724         .open =         debugfs_open_regset32,
725         .read =         seq_read,
726         .llseek =       seq_lseek,
727         .release =      single_release,
728 };
729 
730 /**
731  * debugfs_create_regset32 - create a debugfs file that returns register values
732  * @name: a pointer to a string containing the name of the file to create.
733  * @mode: the permission that the file should have
734  * @parent: a pointer to the parent dentry for this file.  This should be a
735  *          directory dentry if set.  If this parameter is %NULL, then the
736  *          file will be created in the root of the debugfs filesystem.
737  * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
738  *          to an array of register definitions, the array size and the base
739  *          address where the register bank is to be found.
740  *
741  * This function creates a file in debugfs with the given name that reports
742  * the names and values of a set of 32-bit registers. If the @mode variable
743  * is so set it can be read from. Writing is not supported.
744  *
745  * This function will return a pointer to a dentry if it succeeds.  This
746  * pointer must be passed to the debugfs_remove() function when the file is
747  * to be removed (no automatic cleanup happens if your module is unloaded,
748  * you are responsible here.)  If an error occurs, %NULL will be returned.
749  *
750  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
751  * returned.  It is not wise to check for this value, but rather, check for
752  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
753  * code.
754  */
755 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
756                                        struct dentry *parent,
757                                        struct debugfs_regset32 *regset)
758 {
759         return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
760 }
761 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
762 
763 #endif /* CONFIG_HAS_IOMEM */
764 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp