fs/debugfs/file.c

   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         bool bv;
 800         int r;
 801         bool *val = file->private_data;
 802         struct dentry *dentry = F_DENTRY(file);
 803
 804         r = kstrtobool_from_user(user_buf, count, &bv);
 805         if (!r) {
 806                 r = debugfs_file_get(dentry);
 807                 if (unlikely(r))
 808                         return r;
 809                 *val = bv;
 810                 debugfs_file_put(dentry);
 811         }
 812
 813         return count;
 814 }
 815 EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 816
 817 static const struct file_operations fops_bool = {
 818         .read =         debugfs_read_file_bool,
 819         .write =        debugfs_write_file_bool,
 820         .open =         simple_open,
 821         .llseek =       default_llseek,
 822 };
 823
 824 static const struct file_operations fops_bool_ro = {
 825         .read =         debugfs_read_file_bool,
 826         .open =         simple_open,
 827         .llseek =       default_llseek,
 828 };
 829
 830 static const struct file_operations fops_bool_wo = {
 831         .write =        debugfs_write_file_bool,
 832         .open =         simple_open,
 833         .llseek =       default_llseek,
 834 };
 835
 836 /**
 837  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 838  * @name: a pointer to a string containing the name of the file to create.
 839  * @mode: the permission that the file should have
 840  * @parent: a pointer to the parent dentry for this file.  This should be a
 841  *          directory dentry if set.  If this parameter is %NULL, then the
 842  *          file will be created in the root of the debugfs filesystem.
 843  * @value: a pointer to the variable that the file should read to and write
 844  *         from.
 845  *
 846  * This function creates a file in debugfs with the given name that
 847  * contains the value of the variable @value.  If the @mode variable is so
 848  * set, it can be read from, and written to.
 849  *
 850  * This function will return a pointer to a dentry if it succeeds.  This
 851  * pointer must be passed to the debugfs_remove() function when the file is
 852  * to be removed (no automatic cleanup happens if your module is unloaded,
 853  * you are responsible here.)  If an error occurs, %NULL will be returned.
 854  *
 855  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 856  * returned.  It is not wise to check for this value, but rather, check for
 857  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 858  * code.
 859  */
 860 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 861                                    struct dentry *parent, bool *value)
 862 {
 863         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
 864                                    &fops_bool_ro, &fops_bool_wo);
 865 }
 866 EXPORT_SYMBOL_GPL(debugfs_create_bool);
 867
 868 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 869                               size_t count, loff_t *ppos)
 870 {
 871         struct debugfs_blob_wrapper *blob = file->private_data;
 872         struct dentry *dentry = F_DENTRY(file);
 873         ssize_t r;
 874
 875         r = debugfs_file_get(dentry);
 876         if (unlikely(r))
 877                 return r;
 878         r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
 879                                 blob->size);
 880         debugfs_file_put(dentry);
 881         return r;
 882 }
 883
 884 static const struct file_operations fops_blob = {
 885         .read =         read_file_blob,
 886         .open =         simple_open,
 887         .llseek =       default_llseek,
 888 };
 889
 890 /**
 891  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 892  * @name: a pointer to a string containing the name of the file to create.
 893  * @mode: the permission that the file should have
 894  * @parent: a pointer to the parent dentry for this file.  This should be a
 895  *          directory dentry if set.  If this parameter is %NULL, then the
 896  *          file will be created in the root of the debugfs filesystem.
 897  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 898  *        to the blob data and the size of the data.
 899  *
 900  * This function creates a file in debugfs with the given name that exports
 901  * @blob->data as a binary blob. If the @mode variable is so set it can be
 902  * read from. Writing is not supported.
 903  *
 904  * This function will return a pointer to a dentry if it succeeds.  This
 905  * pointer must be passed to the debugfs_remove() function when the file is
 906  * to be removed (no automatic cleanup happens if your module is unloaded,
 907  * you are responsible here.)  If an error occurs, %NULL will be returned.
 908  *
 909  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 910  * returned.  It is not wise to check for this value, but rather, check for
 911  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 912  * code.
 913  */
 914 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 915                                    struct dentry *parent,
 916                                    struct debugfs_blob_wrapper *blob)
 917 {
 918         return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
 919 }
 920 EXPORT_SYMBOL_GPL(debugfs_create_blob);
 921
 922 struct array_data {
 923         void *array;
 924         u32 elements;
 925 };
 926
 927 static size_t u32_format_array(char *buf, size_t bufsize,
 928                                u32 *array, int array_size)
 929 {
 930         size_t ret = 0;
 931
 932         while (--array_size >= 0) {
 933                 size_t len;
 934                 char term = array_size ? ' ' : '\n';
 935
 936                 len = snprintf(buf, bufsize, "%u%c", *array++, term);
 937                 ret += len;
 938
 939                 buf += len;
 940                 bufsize -= len;
 941         }
 942         return ret;
 943 }
 944
 945 static int u32_array_open(struct inode *inode, struct file *file)
 946 {
 947         struct array_data *data = inode->i_private;
 948         int size, elements = data->elements;
 949         char *buf;
 950
 951         /*
 952          * Max size:
 953          *  - 10 digits + ' '/'\n' = 11 bytes per number
 954          *  - terminating NUL character
 955          */
 956         size = elements*11;
 957         buf = kmalloc(size+1, GFP_KERNEL);
 958         if (!buf)
 959                 return -ENOMEM;
 960         buf[size] = 0;
 961
 962         file->private_data = buf;
 963         u32_format_array(buf, size, data->array, data->elements);
 964
 965         return nonseekable_open(inode, file);
 966 }
 967
 968 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
 969                               loff_t *ppos)
 970 {
 971         size_t size = strlen(file->private_data);
 972
 973         return simple_read_from_buffer(buf, len, ppos,
 974                                         file->private_data, size);
 975 }
 976
 977 static int u32_array_release(struct inode *inode, struct file *file)
 978 {
 979         kfree(file->private_data);
 980
 981         return 0;
 982 }
 983
 984 static const struct file_operations u32_array_fops = {
 985         .owner   = THIS_MODULE,
 986         .open    = u32_array_open,
 987         .release = u32_array_release,
 988         .read    = u32_array_read,
 989         .llseek  = no_llseek,
 990 };
 991
 992 /**
 993  * debugfs_create_u32_array - create a debugfs file that is used to read u32
 994  * array.
 995  * @name: a pointer to a string containing the name of the file to create.
 996  * @mode: the permission that the file should have.
 997  * @parent: a pointer to the parent dentry for this file.  This should be a
 998  *          directory dentry if set.  If this parameter is %NULL, then the
 999  *          file will be created in the root of the debugfs filesystem.
1000  * @array: u32 array that provides data.
1001  * @elements: total number of elements in the array.
1002  *
1003  * This function creates a file in debugfs with the given name that exports
1004  * @array as data. If the @mode variable is so set it can be read from.
1005  * Writing is not supported. Seek within the file is also not supported.
1006  * Once array is created its size can not be changed.
1007  *
1008  * The function returns a pointer to dentry on success. If debugfs is not
1009  * enabled in the kernel, the value -%ENODEV will be returned.
1010  */
1011 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
1012                                             struct dentry *parent,
1013                                             u32 *array, u32 elements)
1014 {
1015         struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
1016
1017         if (data == NULL)
1018                 return NULL;
1019
1020         data->array = array;
1021         data->elements = elements;
1022
1023         return debugfs_create_file_unsafe(name, mode, parent, data,
1024                                         &u32_array_fops);
1025 }
1026 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
1027
1028 #ifdef CONFIG_HAS_IOMEM
1029
1030 /*
1031  * The regset32 stuff is used to print 32-bit registers using the
1032  * seq_file utilities. We offer printing a register set in an already-opened
1033  * sequential file or create a debugfs file that only prints a regset32.
1034  */
1035
1036 /**
1037  * debugfs_print_regs32 - use seq_print to describe a set of registers
1038  * @s: the seq_file structure being used to generate output
1039  * @regs: an array if struct debugfs_reg32 structures
1040  * @nregs: the length of the above array
1041  * @base: the base address to be used in reading the registers
1042  * @prefix: a string to be prefixed to every output line
1043  *
1044  * This function outputs a text block describing the current values of
1045  * some 32-bit hardware registers. It is meant to be used within debugfs
1046  * files based on seq_file that need to show registers, intermixed with other
1047  * information. The prefix argument may be used to specify a leading string,
1048  * because some peripherals have several blocks of identical registers,
1049  * for example configuration of dma channels
1050  */
1051 void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1052                           int nregs, void __iomem *base, char *prefix)
1053 {
1054         int i;
1055
1056         for (i = 0; i < nregs; i++, regs++) {
1057                 if (prefix)
1058                         seq_printf(s, "%s", prefix);
1059                 seq_printf(s, "%s = 0x%08x\n", regs->name,
1060                            readl(base + regs->offset));
1061                 if (seq_has_overflowed(s))
1062                         break;
1063         }
1064 }
1065 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1066
1067 static int debugfs_show_regset32(struct seq_file *s, void *data)
1068 {
1069         struct debugfs_regset32 *regset = s->private;
1070
1071         debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1072         return 0;
1073 }
1074
1075 static int debugfs_open_regset32(struct inode *inode, struct file *file)
1076 {
1077         return single_open(file, debugfs_show_regset32, inode->i_private);
1078 }
1079
1080 static const struct file_operations fops_regset32 = {
1081         .open =         debugfs_open_regset32,
1082         .read =         seq_read,
1083         .llseek =       seq_lseek,
1084         .release =      single_release,
1085 };
1086
1087 /**
1088  * debugfs_create_regset32 - create a debugfs file that returns register values
1089  * @name: a pointer to a string containing the name of the file to create.
1090  * @mode: the permission that the file should have
1091  * @parent: a pointer to the parent dentry for this file.  This should be a
1092  *          directory dentry if set.  If this parameter is %NULL, then the
1093  *          file will be created in the root of the debugfs filesystem.
1094  * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1095  *          to an array of register definitions, the array size and the base
1096  *          address where the register bank is to be found.
1097  *
1098  * This function creates a file in debugfs with the given name that reports
1099  * the names and values of a set of 32-bit registers. If the @mode variable
1100  * is so set it can be read from. Writing is not supported.
1101  *
1102  * This function will return a pointer to a dentry if it succeeds.  This
1103  * pointer must be passed to the debugfs_remove() function when the file is
1104  * to be removed (no automatic cleanup happens if your module is unloaded,
1105  * you are responsible here.)  If an error occurs, %NULL will be returned.
1106  *
1107  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
1108  * returned.  It is not wise to check for this value, but rather, check for
1109  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
1110  * code.
1111  */
1112 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
1113                                        struct dentry *parent,
1114                                        struct debugfs_regset32 *regset)
1115 {
1116         return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
1117 }
1118 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1119
1120 #endif /* CONFIG_HAS_IOMEM */
1121
1122 struct debugfs_devm_entry {
1123         int (*read)(struct seq_file *seq, void *data);
1124         struct device *dev;
1125 };
1126
1127 static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1128 {
1129         struct debugfs_devm_entry *entry = inode->i_private;
1130
1131         return single_open(f, entry->read, entry->dev);
1132 }
1133
1134 static const struct file_operations debugfs_devm_entry_ops = {
1135         .owner = THIS_MODULE,
1136         .open = debugfs_devm_entry_open,
1137         .release = single_release,
1138         .read = seq_read,
1139         .llseek = seq_lseek
1140 };
1141
1142 /**
1143  * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1144  *
1145  * @dev: device related to this debugfs file.
1146  * @name: name of the debugfs file.
1147  * @parent: a pointer to the parent dentry for this file.  This should be a
1148  *      directory dentry if set.  If this parameter is %NULL, then the
1149  *      file will be created in the root of the debugfs filesystem.
1150  * @read_fn: function pointer called to print the seq_file content.
1151  */
1152 struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
1153                                            struct dentry *parent,
1154                                            int (*read_fn)(struct seq_file *s,
1155                                                           void *data))
1156 {
1157         struct debugfs_devm_entry *entry;
1158
1159         if (IS_ERR(parent))
1160                 return ERR_PTR(-ENOENT);
1161
1162         entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1163         if (!entry)
1164                 return ERR_PTR(-ENOMEM);
1165
1166         entry->read = read_fn;
1167         entry->dev = dev;
1168
1169         return debugfs_create_file(name, S_IRUGO, parent, entry,
1170                                    &debugfs_devm_entry_ops);
1171 }
1172 EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
1173