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

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

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

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