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

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

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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/debugfs.h>
 21 #include <linux/io.h>
 22 #include <linux/slab.h>
 23 #include <linux/atomic.h>
 24 #include <linux/device.h>
 25 #include <linux/srcu.h>
 26 #include <asm/poll.h>
 27 
 28 #include "internal.h"
 29 
 30 struct poll_table_struct;
 31 
 32 static ssize_t default_read_file(struct file *file, char __user *buf,
 33                                  size_t count, loff_t *ppos)
 34 {
 35         return 0;
 36 }
 37 
 38 static ssize_t default_write_file(struct file *file, const char __user *buf,
 39                                    size_t count, loff_t *ppos)
 40 {
 41         return count;
 42 }
 43 
 44 const struct file_operations debugfs_noop_file_operations = {
 45         .read =         default_read_file,
 46         .write =        default_write_file,
 47         .open =         simple_open,
 48         .llseek =       noop_llseek,
 49 };
 50 
 51 /**
 52  * debugfs_use_file_start - mark the beginning of file data access
 53  * @dentry: the dentry object whose data is being accessed.
 54  * @srcu_idx: a pointer to some memory to store a SRCU index in.
 55  *
 56  * Up to a matching call to debugfs_use_file_finish(), any
 57  * successive call into the file removing functions debugfs_remove()
 58  * and debugfs_remove_recursive() will block. Since associated private
 59  * file data may only get freed after a successful return of any of
 60  * the removal functions, you may safely access it after a successful
 61  * call to debugfs_use_file_start() without worrying about
 62  * lifetime issues.
 63  *
 64  * If -%EIO is returned, the file has already been removed and thus,
 65  * it is not safe to access any of its data. If, on the other hand,
 66  * it is allowed to access the file data, zero is returned.
 67  *
 68  * Regardless of the return code, any call to
 69  * debugfs_use_file_start() must be followed by a matching call
 70  * to debugfs_use_file_finish().
 71  */
 72 int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx)
 73         __acquires(&debugfs_srcu)
 74 {
 75         *srcu_idx = srcu_read_lock(&debugfs_srcu);
 76         barrier();
 77         if (d_unlinked(dentry))
 78                 return -EIO;
 79         return 0;
 80 }
 81 EXPORT_SYMBOL_GPL(debugfs_use_file_start);
 82 
 83 /**
 84  * debugfs_use_file_finish - mark the end of file data access
 85  * @srcu_idx: the SRCU index "created" by a former call to
 86  *            debugfs_use_file_start().
 87  *
 88  * Allow any ongoing concurrent call into debugfs_remove() or
 89  * debugfs_remove_recursive() blocked by a former call to
 90  * debugfs_use_file_start() to proceed and return to its caller.
 91  */
 92 void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu)
 93 {
 94         srcu_read_unlock(&debugfs_srcu, srcu_idx);
 95 }
 96 EXPORT_SYMBOL_GPL(debugfs_use_file_finish);
 97 
 98 #define F_DENTRY(filp) ((filp)->f_path.dentry)
 99 
100 static int open_proxy_open(struct inode *inode, struct file *filp)
101 {
102         const struct dentry *dentry = F_DENTRY(filp);
103         const struct file_operations *real_fops = NULL;
104         int srcu_idx, r;
105 
106         r = debugfs_use_file_start(dentry, &srcu_idx);
107         if (r) {
108                 r = -ENOENT;
109                 goto out;
110         }
111 
112         real_fops = debugfs_real_fops(filp);
113         real_fops = fops_get(real_fops);
114         if (!real_fops) {
115                 /* Huh? Module did not clean up after itself at exit? */
116                 WARN(1, "debugfs file owner did not clean up at exit: %pd",
117                         dentry);
118                 r = -ENXIO;
119                 goto out;
120         }
121         replace_fops(filp, real_fops);
122 
123         if (real_fops->open)
124                 r = real_fops->open(inode, filp);
125 
126 out:
127         debugfs_use_file_finish(srcu_idx);
128         return r;
129 }
130 
131 const struct file_operations debugfs_open_proxy_file_operations = {
132         .open = open_proxy_open,
133 };
134 
135 #define PROTO(args...) args
136 #define ARGS(args...) args
137 
138 #define FULL_PROXY_FUNC(name, ret_type, filp, proto, args)              \
139 static ret_type full_proxy_ ## name(proto)                              \
140 {                                                                       \
141         const struct dentry *dentry = F_DENTRY(filp);                   \
142         const struct file_operations *real_fops =                       \
143                 debugfs_real_fops(filp);                                \
144         int srcu_idx;                                                   \
145         ret_type r;                                                     \
146                                                                         \
147         r = debugfs_use_file_start(dentry, &srcu_idx);                  \
148         if (likely(!r))                                         \
149                 r = real_fops->name(args);                              \
150         debugfs_use_file_finish(srcu_idx);                              \
151         return r;                                                       \
152 }
153 
154 FULL_PROXY_FUNC(llseek, loff_t, filp,
155                 PROTO(struct file *filp, loff_t offset, int whence),
156                 ARGS(filp, offset, whence));
157 
158 FULL_PROXY_FUNC(read, ssize_t, filp,
159                 PROTO(struct file *filp, char __user *buf, size_t size,
160                         loff_t *ppos),
161                 ARGS(filp, buf, size, ppos));
162 
163 FULL_PROXY_FUNC(write, ssize_t, filp,
164                 PROTO(struct file *filp, const char __user *buf, size_t size,
165                         loff_t *ppos),
166                 ARGS(filp, buf, size, ppos));
167 
168 FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
169                 PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
170                 ARGS(filp, cmd, arg));
171 
172 static unsigned int full_proxy_poll(struct file *filp,
173                                 struct poll_table_struct *wait)
174 {
175         const struct dentry *dentry = F_DENTRY(filp);
176         const struct file_operations *real_fops = debugfs_real_fops(filp);
177         int srcu_idx;
178         unsigned int r = 0;
179 
180         if (debugfs_use_file_start(dentry, &srcu_idx)) {
181                 debugfs_use_file_finish(srcu_idx);
182                 return POLLHUP;
183         }
184 
185         r = real_fops->poll(filp, wait);
186         debugfs_use_file_finish(srcu_idx);
187         return r;
188 }
189 
190 static int full_proxy_release(struct inode *inode, struct file *filp)
191 {
192         const struct dentry *dentry = F_DENTRY(filp);
193         const struct file_operations *real_fops = debugfs_real_fops(filp);
194         const struct file_operations *proxy_fops = filp->f_op;
195         int r = 0;
196 
197         /*
198          * We must not protect this against removal races here: the
199          * original releaser should be called unconditionally in order
200          * not to leak any resources. Releasers must not assume that
201          * ->i_private is still being meaningful here.
202          */
203         if (real_fops->release)
204                 r = real_fops->release(inode, filp);
205 
206         replace_fops(filp, d_inode(dentry)->i_fop);
207         kfree((void *)proxy_fops);
208         fops_put(real_fops);
209         return r;
210 }
211 
212 static void __full_proxy_fops_init(struct file_operations *proxy_fops,
213                                 const struct file_operations *real_fops)
214 {
215         proxy_fops->release = full_proxy_release;
216         if (real_fops->llseek)
217                 proxy_fops->llseek = full_proxy_llseek;
218         if (real_fops->read)
219                 proxy_fops->read = full_proxy_read;
220         if (real_fops->write)
221                 proxy_fops->write = full_proxy_write;
222         if (real_fops->poll)
223                 proxy_fops->poll = full_proxy_poll;
224         if (real_fops->unlocked_ioctl)
225                 proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
226 }
227 
228 static int full_proxy_open(struct inode *inode, struct file *filp)
229 {
230         const struct dentry *dentry = F_DENTRY(filp);
231         const struct file_operations *real_fops = NULL;
232         struct file_operations *proxy_fops = NULL;
233         int srcu_idx, r;
234 
235         r = debugfs_use_file_start(dentry, &srcu_idx);
236         if (r) {
237                 r = -ENOENT;
238                 goto out;
239         }
240 
241         real_fops = debugfs_real_fops(filp);
242         real_fops = fops_get(real_fops);
243         if (!real_fops) {
244                 /* Huh? Module did not cleanup after itself at exit? */
245                 WARN(1, "debugfs file owner did not clean up at exit: %pd",
246                         dentry);
247                 r = -ENXIO;
248                 goto out;
249         }
250 
251         proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
252         if (!proxy_fops) {
253                 r = -ENOMEM;
254                 goto free_proxy;
255         }
256         __full_proxy_fops_init(proxy_fops, real_fops);
257         replace_fops(filp, proxy_fops);
258 
259         if (real_fops->open) {
260                 r = real_fops->open(inode, filp);
261                 if (r) {
262                         replace_fops(filp, d_inode(dentry)->i_fop);
263                         goto free_proxy;
264                 } else if (filp->f_op != proxy_fops) {
265                         /* No protection against file removal anymore. */
266                         WARN(1, "debugfs file owner replaced proxy fops: %pd",
267                                 dentry);
268                         goto free_proxy;
269                 }
270         }
271 
272         goto out;
273 free_proxy:
274         kfree(proxy_fops);
275         fops_put(real_fops);
276 out:
277         debugfs_use_file_finish(srcu_idx);
278         return r;
279 }
280 
281 const struct file_operations debugfs_full_proxy_file_operations = {
282         .open = full_proxy_open,
283 };
284 
285 ssize_t debugfs_attr_read(struct file *file, char __user *buf,
286                         size_t len, loff_t *ppos)
287 {
288         ssize_t ret;
289         int srcu_idx;
290 
291         ret = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
292         if (likely(!ret))
293                 ret = simple_attr_read(file, buf, len, ppos);
294         debugfs_use_file_finish(srcu_idx);
295         return ret;
296 }
297 EXPORT_SYMBOL_GPL(debugfs_attr_read);
298 
299 ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
300                          size_t len, loff_t *ppos)
301 {
302         ssize_t ret;
303         int srcu_idx;
304 
305         ret = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
306         if (likely(!ret))
307                 ret = simple_attr_write(file, buf, len, ppos);
308         debugfs_use_file_finish(srcu_idx);
309         return ret;
310 }
311 EXPORT_SYMBOL_GPL(debugfs_attr_write);
312 
313 static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
314                                         struct dentry *parent, void *value,
315                                         const struct file_operations *fops,
316                                         const struct file_operations *fops_ro,
317                                         const struct file_operations *fops_wo)
318 {
319         /* if there are no write bits set, make read only */
320         if (!(mode & S_IWUGO))
321                 return debugfs_create_file_unsafe(name, mode, parent, value,
322                                                 fops_ro);
323         /* if there are no read bits set, make write only */
324         if (!(mode & S_IRUGO))
325                 return debugfs_create_file_unsafe(name, mode, parent, value,
326                                                 fops_wo);
327 
328         return debugfs_create_file_unsafe(name, mode, parent, value, fops);
329 }
330 
331 static int debugfs_u8_set(void *data, u64 val)
332 {
333         *(u8 *)data = val;
334         return 0;
335 }
336 static int debugfs_u8_get(void *data, u64 *val)
337 {
338         *val = *(u8 *)data;
339         return 0;
340 }
341 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
342 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
343 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
344 
345 /**
346  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
347  * @name: a pointer to a string containing the name of the file to create.
348  * @mode: the permission that the file should have
349  * @parent: a pointer to the parent dentry for this file.  This should be a
350  *          directory dentry if set.  If this parameter is %NULL, then the
351  *          file will be created in the root of the debugfs filesystem.
352  * @value: a pointer to the variable that the file should read to and write
353  *         from.
354  *
355  * This function creates a file in debugfs with the given name that
356  * contains the value of the variable @value.  If the @mode variable is so
357  * set, it can be read from, and written to.
358  *
359  * This function will return a pointer to a dentry if it succeeds.  This
360  * pointer must be passed to the debugfs_remove() function when the file is
361  * to be removed (no automatic cleanup happens if your module is unloaded,
362  * you are responsible here.)  If an error occurs, %NULL will be returned.
363  *
364  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
365  * returned.  It is not wise to check for this value, but rather, check for
366  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
367  * code.
368  */
369 struct dentry *debugfs_create_u8(const char *name, umode_t mode,
370                                  struct dentry *parent, u8 *value)
371 {
372         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
373                                    &fops_u8_ro, &fops_u8_wo);
374 }
375 EXPORT_SYMBOL_GPL(debugfs_create_u8);
376 
377 static int debugfs_u16_set(void *data, u64 val)
378 {
379         *(u16 *)data = val;
380         return 0;
381 }
382 static int debugfs_u16_get(void *data, u64 *val)
383 {
384         *val = *(u16 *)data;
385         return 0;
386 }
387 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
388 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
389 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
390 
391 /**
392  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
393  * @name: a pointer to a string containing the name of the file to create.
394  * @mode: the permission that the file should have
395  * @parent: a pointer to the parent dentry for this file.  This should be a
396  *          directory dentry if set.  If this parameter is %NULL, then the
397  *          file will be created in the root of the debugfs filesystem.
398  * @value: a pointer to the variable that the file should read to and write
399  *         from.
400  *
401  * This function creates a file in debugfs with the given name that
402  * contains the value of the variable @value.  If the @mode variable is so
403  * set, it can be read from, and written to.
404  *
405  * This function will return a pointer to a dentry if it succeeds.  This
406  * pointer must be passed to the debugfs_remove() function when the file is
407  * to be removed (no automatic cleanup happens if your module is unloaded,
408  * you are responsible here.)  If an error occurs, %NULL will be returned.
409  *
410  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
411  * returned.  It is not wise to check for this value, but rather, check for
412  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
413  * code.
414  */
415 struct dentry *debugfs_create_u16(const char *name, umode_t mode,
416                                   struct dentry *parent, u16 *value)
417 {
418         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
419                                    &fops_u16_ro, &fops_u16_wo);
420 }
421 EXPORT_SYMBOL_GPL(debugfs_create_u16);
422 
423 static int debugfs_u32_set(void *data, u64 val)
424 {
425         *(u32 *)data = val;
426         return 0;
427 }
428 static int debugfs_u32_get(void *data, u64 *val)
429 {
430         *val = *(u32 *)data;
431         return 0;
432 }
433 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
434 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
435 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
436 
437 /**
438  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
439  * @name: a pointer to a string containing the name of the file to create.
440  * @mode: the permission that the file should have
441  * @parent: a pointer to the parent dentry for this file.  This should be a
442  *          directory dentry if set.  If this parameter is %NULL, then the
443  *          file will be created in the root of the debugfs filesystem.
444  * @value: a pointer to the variable that the file should read to and write
445  *         from.
446  *
447  * This function creates a file in debugfs with the given name that
448  * contains the value of the variable @value.  If the @mode variable is so
449  * set, it can be read from, and written to.
450  *
451  * This function will return a pointer to a dentry if it succeeds.  This
452  * pointer must be passed to the debugfs_remove() function when the file is
453  * to be removed (no automatic cleanup happens if your module is unloaded,
454  * you are responsible here.)  If an error occurs, %NULL will be returned.
455  *
456  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
457  * returned.  It is not wise to check for this value, but rather, check for
458  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
459  * code.
460  */
461 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
462                                  struct dentry *parent, u32 *value)
463 {
464         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
465                                    &fops_u32_ro, &fops_u32_wo);
466 }
467 EXPORT_SYMBOL_GPL(debugfs_create_u32);
468 
469 static int debugfs_u64_set(void *data, u64 val)
470 {
471         *(u64 *)data = val;
472         return 0;
473 }
474 
475 static int debugfs_u64_get(void *data, u64 *val)
476 {
477         *val = *(u64 *)data;
478         return 0;
479 }
480 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
481 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
482 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
483 
484 /**
485  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
486  * @name: a pointer to a string containing the name of the file to create.
487  * @mode: the permission that the file should have
488  * @parent: a pointer to the parent dentry for this file.  This should be a
489  *          directory dentry if set.  If this parameter is %NULL, then the
490  *          file will be created in the root of the debugfs filesystem.
491  * @value: a pointer to the variable that the file should read to and write
492  *         from.
493  *
494  * This function creates a file in debugfs with the given name that
495  * contains the value of the variable @value.  If the @mode variable is so
496  * set, it can be read from, and written to.
497  *
498  * This function will return a pointer to a dentry if it succeeds.  This
499  * pointer must be passed to the debugfs_remove() function when the file is
500  * to be removed (no automatic cleanup happens if your module is unloaded,
501  * you are responsible here.)  If an error occurs, %NULL will be returned.
502  *
503  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
504  * returned.  It is not wise to check for this value, but rather, check for
505  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
506  * code.
507  */
508 struct dentry *debugfs_create_u64(const char *name, umode_t mode,
509                                  struct dentry *parent, u64 *value)
510 {
511         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
512                                    &fops_u64_ro, &fops_u64_wo);
513 }
514 EXPORT_SYMBOL_GPL(debugfs_create_u64);
515 
516 static int debugfs_ulong_set(void *data, u64 val)
517 {
518         *(unsigned long *)data = val;
519         return 0;
520 }
521 
522 static int debugfs_ulong_get(void *data, u64 *val)
523 {
524         *val = *(unsigned long *)data;
525         return 0;
526 }
527 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
528                         "%llu\n");
529 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
530 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
531 
532 /**
533  * debugfs_create_ulong - create a debugfs file that is used to read and write
534  * an unsigned long value.
535  * @name: a pointer to a string containing the name of the file to create.
536  * @mode: the permission that the file should have
537  * @parent: a pointer to the parent dentry for this file.  This should be a
538  *          directory dentry if set.  If this parameter is %NULL, then the
539  *          file will be created in the root of the debugfs filesystem.
540  * @value: a pointer to the variable that the file should read to and write
541  *         from.
542  *
543  * This function creates a file in debugfs with the given name that
544  * contains the value of the variable @value.  If the @mode variable is so
545  * set, it can be read from, and written to.
546  *
547  * This function will return a pointer to a dentry if it succeeds.  This
548  * pointer must be passed to the debugfs_remove() function when the file is
549  * to be removed (no automatic cleanup happens if your module is unloaded,
550  * you are responsible here.)  If an error occurs, %NULL will be returned.
551  *
552  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
553  * returned.  It is not wise to check for this value, but rather, check for
554  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
555  * code.
556  */
557 struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
558                                     struct dentry *parent, unsigned long *value)
559 {
560         return debugfs_create_mode_unsafe(name, mode, parent, value,
561                                         &fops_ulong, &fops_ulong_ro,
562                                         &fops_ulong_wo);
563 }
564 EXPORT_SYMBOL_GPL(debugfs_create_ulong);
565 
566 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
567 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
568 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
569 
570 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
571                         "0x%04llx\n");
572 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
573 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
574 
575 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
576                         "0x%08llx\n");
577 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
578 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
579 
580 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
581                         "0x%016llx\n");
582 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
583 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
584 
585 /*
586  * 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
587  *
588  * These functions are exactly the same as the above functions (but use a hex
589  * output for the decimal challenged). For details look at the above unsigned
590  * decimal functions.
591  */
592 
593 /**
594  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
595  * @name: a pointer to a string containing the name of the file to create.
596  * @mode: the permission that the file should have
597  * @parent: a pointer to the parent dentry for this file.  This should be a
598  *          directory dentry if set.  If this parameter is %NULL, then the
599  *          file will be created in the root of the debugfs filesystem.
600  * @value: a pointer to the variable that the file should read to and write
601  *         from.
602  */
603 struct dentry *debugfs_create_x8(const char *name, umode_t mode,
604                                  struct dentry *parent, u8 *value)
605 {
606         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
607                                    &fops_x8_ro, &fops_x8_wo);
608 }
609 EXPORT_SYMBOL_GPL(debugfs_create_x8);
610 
611 /**
612  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
613  * @name: a pointer to a string containing the name of the file to create.
614  * @mode: the permission that the file should have
615  * @parent: a pointer to the parent dentry for this file.  This should be a
616  *          directory dentry if set.  If this parameter is %NULL, then the
617  *          file will be created in the root of the debugfs filesystem.
618  * @value: a pointer to the variable that the file should read to and write
619  *         from.
620  */
621 struct dentry *debugfs_create_x16(const char *name, umode_t mode,
622                                  struct dentry *parent, u16 *value)
623 {
624         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
625                                    &fops_x16_ro, &fops_x16_wo);
626 }
627 EXPORT_SYMBOL_GPL(debugfs_create_x16);
628 
629 /**
630  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
631  * @name: a pointer to a string containing the name of the file to create.
632  * @mode: the permission that the file should have
633  * @parent: a pointer to the parent dentry for this file.  This should be a
634  *          directory dentry if set.  If this parameter is %NULL, then the
635  *          file will be created in the root of the debugfs filesystem.
636  * @value: a pointer to the variable that the file should read to and write
637  *         from.
638  */
639 struct dentry *debugfs_create_x32(const char *name, umode_t mode,
640                                  struct dentry *parent, u32 *value)
641 {
642         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
643                                    &fops_x32_ro, &fops_x32_wo);
644 }
645 EXPORT_SYMBOL_GPL(debugfs_create_x32);
646 
647 /**
648  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
649  * @name: a pointer to a string containing the name of the file to create.
650  * @mode: the permission that the file should have
651  * @parent: a pointer to the parent dentry for this file.  This should be a
652  *          directory dentry if set.  If this parameter is %NULL, then the
653  *          file will be created in the root of the debugfs filesystem.
654  * @value: a pointer to the variable that the file should read to and write
655  *         from.
656  */
657 struct dentry *debugfs_create_x64(const char *name, umode_t mode,
658                                  struct dentry *parent, u64 *value)
659 {
660         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
661                                    &fops_x64_ro, &fops_x64_wo);
662 }
663 EXPORT_SYMBOL_GPL(debugfs_create_x64);
664 
665 
666 static int debugfs_size_t_set(void *data, u64 val)
667 {
668         *(size_t *)data = val;
669         return 0;
670 }
671 static int debugfs_size_t_get(void *data, u64 *val)
672 {
673         *val = *(size_t *)data;
674         return 0;
675 }
676 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
677                         "%llu\n"); /* %llu and %zu are more or less the same */
678 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
679 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
680 
681 /**
682  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
683  * @name: a pointer to a string containing the name of the file to create.
684  * @mode: the permission that the file should have
685  * @parent: a pointer to the parent dentry for this file.  This should be a
686  *          directory dentry if set.  If this parameter is %NULL, then the
687  *          file will be created in the root of the debugfs filesystem.
688  * @value: a pointer to the variable that the file should read to and write
689  *         from.
690  */
691 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
692                                      struct dentry *parent, size_t *value)
693 {
694         return debugfs_create_mode_unsafe(name, mode, parent, value,
695                                         &fops_size_t, &fops_size_t_ro,
696                                         &fops_size_t_wo);
697 }
698 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
699 
700 static int debugfs_atomic_t_set(void *data, u64 val)
701 {
702         atomic_set((atomic_t *)data, val);
703         return 0;
704 }
705 static int debugfs_atomic_t_get(void *data, u64 *val)
706 {
707         *val = atomic_read((atomic_t *)data);
708         return 0;
709 }
710 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
711                         debugfs_atomic_t_set, "%lld\n");
712 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
713                         "%lld\n");
714 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
715                         "%lld\n");
716 
717 /**
718  * debugfs_create_atomic_t - create a debugfs file that is used to read and
719  * write an atomic_t value
720  * @name: a pointer to a string containing the name of the file to create.
721  * @mode: the permission that the file should have
722  * @parent: a pointer to the parent dentry for this file.  This should be a
723  *          directory dentry if set.  If this parameter is %NULL, then the
724  *          file will be created in the root of the debugfs filesystem.
725  * @value: a pointer to the variable that the file should read to and write
726  *         from.
727  */
728 struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
729                                  struct dentry *parent, atomic_t *value)
730 {
731         return debugfs_create_mode_unsafe(name, mode, parent, value,
732                                         &fops_atomic_t, &fops_atomic_t_ro,
733                                         &fops_atomic_t_wo);
734 }
735 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
736 
737 ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
738                                size_t count, loff_t *ppos)
739 {
740         char buf[3];
741         bool val;
742         int r, srcu_idx;
743 
744         r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
745         if (likely(!r))
746                 val = *(bool *)file->private_data;
747         debugfs_use_file_finish(srcu_idx);
748         if (r)
749                 return r;
750 
751         if (val)
752                 buf[0] = 'Y';
753         else
754                 buf[0] = 'N';
755         buf[1] = '\n';
756         buf[2] = 0x00;
757         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
758 }
759 EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
760 
761 ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
762                                 size_t count, loff_t *ppos)
763 {
764         char buf[32];
765         size_t buf_size;
766         bool bv;
767         int r, srcu_idx;
768         bool *val = file->private_data;
769 
770         buf_size = min(count, (sizeof(buf)-1));
771         if (copy_from_user(buf, user_buf, buf_size))
772                 return -EFAULT;
773 
774         buf[buf_size] = '\0';
775         if (strtobool(buf, &bv) == 0) {
776                 r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
777                 if (likely(!r))
778                         *val = bv;
779                 debugfs_use_file_finish(srcu_idx);
780                 if (r)
781                         return r;
782         }
783 
784         return count;
785 }
786 EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
787 
788 static const struct file_operations fops_bool = {
789         .read =         debugfs_read_file_bool,
790         .write =        debugfs_write_file_bool,
791         .open =         simple_open,
792         .llseek =       default_llseek,
793 };
794 
795 static const struct file_operations fops_bool_ro = {
796         .read =         debugfs_read_file_bool,
797         .open =         simple_open,
798         .llseek =       default_llseek,
799 };
800 
801 static const struct file_operations fops_bool_wo = {
802         .write =        debugfs_write_file_bool,
803         .open =         simple_open,
804         .llseek =       default_llseek,
805 };
806 
807 /**
808  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
809  * @name: a pointer to a string containing the name of the file to create.
810  * @mode: the permission that the file should have
811  * @parent: a pointer to the parent dentry for this file.  This should be a
812  *          directory dentry if set.  If this parameter is %NULL, then the
813  *          file will be created in the root of the debugfs filesystem.
814  * @value: a pointer to the variable that the file should read to and write
815  *         from.
816  *
817  * This function creates a file in debugfs with the given name that
818  * contains the value of the variable @value.  If the @mode variable is so
819  * set, it can be read from, and written to.
820  *
821  * This function will return a pointer to a dentry if it succeeds.  This
822  * pointer must be passed to the debugfs_remove() function when the file is
823  * to be removed (no automatic cleanup happens if your module is unloaded,
824  * you are responsible here.)  If an error occurs, %NULL will be returned.
825  *
826  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
827  * returned.  It is not wise to check for this value, but rather, check for
828  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
829  * code.
830  */
831 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
832                                    struct dentry *parent, bool *value)
833 {
834         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
835                                    &fops_bool_ro, &fops_bool_wo);
836 }
837 EXPORT_SYMBOL_GPL(debugfs_create_bool);
838 
839 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
840                               size_t count, loff_t *ppos)
841 {
842         struct debugfs_blob_wrapper *blob = file->private_data;
843         ssize_t r;
844         int srcu_idx;
845 
846         r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
847         if (likely(!r))
848                 r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
849                                         blob->size);
850         debugfs_use_file_finish(srcu_idx);
851         return r;
852 }
853 
854 static const struct file_operations fops_blob = {
855         .read =         read_file_blob,
856         .open =         simple_open,
857         .llseek =       default_llseek,
858 };
859 
860 /**
861  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
862  * @name: a pointer to a string containing the name of the file to create.
863  * @mode: the permission that the file should have
864  * @parent: a pointer to the parent dentry for this file.  This should be a
865  *          directory dentry if set.  If this parameter is %NULL, then the
866  *          file will be created in the root of the debugfs filesystem.
867  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
868  *        to the blob data and the size of the data.
869  *
870  * This function creates a file in debugfs with the given name that exports
871  * @blob->data as a binary blob. If the @mode variable is so set it can be
872  * read from. Writing is not supported.
873  *
874  * This function will return a pointer to a dentry if it succeeds.  This
875  * pointer must be passed to the debugfs_remove() function when the file is
876  * to be removed (no automatic cleanup happens if your module is unloaded,
877  * you are responsible here.)  If an error occurs, %NULL will be returned.
878  *
879  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
880  * returned.  It is not wise to check for this value, but rather, check for
881  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
882  * code.
883  */
884 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
885                                    struct dentry *parent,
886                                    struct debugfs_blob_wrapper *blob)
887 {
888         return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
889 }
890 EXPORT_SYMBOL_GPL(debugfs_create_blob);
891 
892 struct array_data {
893         void *array;
894         u32 elements;
895 };
896 
897 static size_t u32_format_array(char *buf, size_t bufsize,
898                                u32 *array, int array_size)
899 {
900         size_t ret = 0;
901 
902         while (--array_size >= 0) {
903                 size_t len;
904                 char term = array_size ? ' ' : '\n';
905 
906                 len = snprintf(buf, bufsize, "%u%c", *array++, term);
907                 ret += len;
908 
909                 buf += len;
910                 bufsize -= len;
911         }
912         return ret;
913 }
914 
915 static int u32_array_open(struct inode *inode, struct file *file)
916 {
917         struct array_data *data = inode->i_private;
918         int size, elements = data->elements;
919         char *buf;
920 
921         /*
922          * Max size:
923          *  - 10 digits + ' '/'\n' = 11 bytes per number
924          *  - terminating NUL character
925          */
926         size = elements*11;
927         buf = kmalloc(size+1, GFP_KERNEL);
928         if (!buf)
929                 return -ENOMEM;
930         buf[size] = 0;
931 
932         file->private_data = buf;
933         u32_format_array(buf, size, data->array, data->elements);
934 
935         return nonseekable_open(inode, file);
936 }
937 
938 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
939                               loff_t *ppos)
940 {
941         size_t size = strlen(file->private_data);
942 
943         return simple_read_from_buffer(buf, len, ppos,
944                                         file->private_data, size);
945 }
946 
947 static int u32_array_release(struct inode *inode, struct file *file)
948 {
949         kfree(file->private_data);
950 
951         return 0;
952 }
953 
954 static const struct file_operations u32_array_fops = {
955         .owner   = THIS_MODULE,
956         .open    = u32_array_open,
957         .release = u32_array_release,
958         .read    = u32_array_read,
959         .llseek  = no_llseek,
960 };
961 
962 /**
963  * debugfs_create_u32_array - create a debugfs file that is used to read u32
964  * array.
965  * @name: a pointer to a string containing the name of the file to create.
966  * @mode: the permission that the file should have.
967  * @parent: a pointer to the parent dentry for this file.  This should be a
968  *          directory dentry if set.  If this parameter is %NULL, then the
969  *          file will be created in the root of the debugfs filesystem.
970  * @array: u32 array that provides data.
971  * @elements: total number of elements in the array.
972  *
973  * This function creates a file in debugfs with the given name that exports
974  * @array as data. If the @mode variable is so set it can be read from.
975  * Writing is not supported. Seek within the file is also not supported.
976  * Once array is created its size can not be changed.
977  *
978  * The function returns a pointer to dentry on success. If debugfs is not
979  * enabled in the kernel, the value -%ENODEV will be returned.
980  */
981 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
982                                             struct dentry *parent,
983                                             u32 *array, u32 elements)
984 {
985         struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
986 
987         if (data == NULL)
988                 return NULL;
989 
990         data->array = array;
991         data->elements = elements;
992 
993         return debugfs_create_file_unsafe(name, mode, parent, data,
994                                         &u32_array_fops);
995 }
996 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
997 
998 #ifdef CONFIG_HAS_IOMEM
999 
1000 /*
1001  * The regset32 stuff is used to print 32-bit registers using the
1002  * seq_file utilities. We offer printing a register set in an already-opened
1003  * sequential file or create a debugfs file that only prints a regset32.
1004  */
1005 
1006 /**
1007  * debugfs_print_regs32 - use seq_print to describe a set of registers
1008  * @s: the seq_file structure being used to generate output
1009  * @regs: an array if struct debugfs_reg32 structures
1010  * @nregs: the length of the above array
1011  * @base: the base address to be used in reading the registers
1012  * @prefix: a string to be prefixed to every output line
1013  *
1014  * This function outputs a text block describing the current values of
1015  * some 32-bit hardware registers. It is meant to be used within debugfs
1016  * files based on seq_file that need to show registers, intermixed with other
1017  * information. The prefix argument may be used to specify a leading string,
1018  * because some peripherals have several blocks of identical registers,
1019  * for example configuration of dma channels
1020  */
1021 void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1022                           int nregs, void __iomem *base, char *prefix)
1023 {
1024         int i;
1025 
1026         for (i = 0; i < nregs; i++, regs++) {
1027                 if (prefix)
1028                         seq_printf(s, "%s", prefix);
1029                 seq_printf(s, "%s = 0x%08x\n", regs->name,
1030                            readl(base + regs->offset));
1031                 if (seq_has_overflowed(s))
1032                         break;
1033         }
1034 }
1035 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1036 
1037 static int debugfs_show_regset32(struct seq_file *s, void *data)
1038 {
1039         struct debugfs_regset32 *regset = s->private;
1040 
1041         debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1042         return 0;
1043 }
1044 
1045 static int debugfs_open_regset32(struct inode *inode, struct file *file)
1046 {
1047         return single_open(file, debugfs_show_regset32, inode->i_private);
1048 }
1049 
1050 static const struct file_operations fops_regset32 = {
1051         .open =         debugfs_open_regset32,
1052         .read =         seq_read,
1053         .llseek =       seq_lseek,
1054         .release =      single_release,
1055 };
1056 
1057 /**
1058  * debugfs_create_regset32 - create a debugfs file that returns register values
1059  * @name: a pointer to a string containing the name of the file to create.
1060  * @mode: the permission that the file should have
1061  * @parent: a pointer to the parent dentry for this file.  This should be a
1062  *          directory dentry if set.  If this parameter is %NULL, then the
1063  *          file will be created in the root of the debugfs filesystem.
1064  * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1065  *          to an array of register definitions, the array size and the base
1066  *          address where the register bank is to be found.
1067  *
1068  * This function creates a file in debugfs with the given name that reports
1069  * the names and values of a set of 32-bit registers. If the @mode variable
1070  * is so set it can be read from. Writing is not supported.
1071  *
1072  * This function will return a pointer to a dentry if it succeeds.  This
1073  * pointer must be passed to the debugfs_remove() function when the file is
1074  * to be removed (no automatic cleanup happens if your module is unloaded,
1075  * you are responsible here.)  If an error occurs, %NULL will be returned.
1076  *
1077  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
1078  * returned.  It is not wise to check for this value, but rather, check for
1079  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
1080  * code.
1081  */
1082 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
1083                                        struct dentry *parent,
1084                                        struct debugfs_regset32 *regset)
1085 {
1086         return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
1087 }
1088 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1089 
1090 #endif /* CONFIG_HAS_IOMEM */
1091 
1092 struct debugfs_devm_entry {
1093         int (*read)(struct seq_file *seq, void *data);
1094         struct device *dev;
1095 };
1096 
1097 static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1098 {
1099         struct debugfs_devm_entry *entry = inode->i_private;
1100 
1101         return single_open(f, entry->read, entry->dev);
1102 }
1103 
1104 static const struct file_operations debugfs_devm_entry_ops = {
1105         .owner = THIS_MODULE,
1106         .open = debugfs_devm_entry_open,
1107         .release = single_release,
1108         .read = seq_read,
1109         .llseek = seq_lseek
1110 };
1111 
1112 /**
1113  * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1114  *
1115  * @dev: device related to this debugfs file.
1116  * @name: name of the debugfs file.
1117  * @parent: a pointer to the parent dentry for this file.  This should be a
1118  *      directory dentry if set.  If this parameter is %NULL, then the
1119  *      file will be created in the root of the debugfs filesystem.
1120  * @read_fn: function pointer called to print the seq_file content.
1121  */
1122 struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
1123                                            struct dentry *parent,
1124                                            int (*read_fn)(struct seq_file *s,
1125                                                           void *data))
1126 {
1127         struct debugfs_devm_entry *entry;
1128 
1129         if (IS_ERR(parent))
1130                 return ERR_PTR(-ENOENT);
1131 
1132         entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1133         if (!entry)
1134                 return ERR_PTR(-ENOMEM);
1135 
1136         entry->read = read_fn;
1137         entry->dev = dev;
1138 
1139         return debugfs_create_file(name, S_IRUGO, parent, entry,
1140                                    &debugfs_devm_entry_ops);
1141 }
1142 EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
1143 
1144 

~ [ 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