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, %ERR_PTR(-ERROR) will be
 398  * returned.
 399  *
 400  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 401  * be returned.
 402  */
 403 struct dentry *debugfs_create_u8(const char *name, umode_t mode,
 404                                  struct dentry *parent, u8 *value)
 405 {
 406         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
 407                                    &fops_u8_ro, &fops_u8_wo);
 408 }
 409 EXPORT_SYMBOL_GPL(debugfs_create_u8);
 410
 411 static int debugfs_u16_set(void *data, u64 val)
 412 {
 413         *(u16 *)data = val;
 414         return 0;
 415 }
 416 static int debugfs_u16_get(void *data, u64 *val)
 417 {
 418         *val = *(u16 *)data;
 419         return 0;
 420 }
 421 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 422 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 423 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 424
 425 /**
 426  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 427  * @name: a pointer to a string containing the name of the file to create.
 428  * @mode: the permission that the file should have
 429  * @parent: a pointer to the parent dentry for this file.  This should be a
 430  *          directory dentry if set.  If this parameter is %NULL, then the
 431  *          file will be created in the root of the debugfs filesystem.
 432  * @value: a pointer to the variable that the file should read to and write
 433  *         from.
 434  *
 435  * This function creates a file in debugfs with the given name that
 436  * contains the value of the variable @value.  If the @mode variable is so
 437  * set, it can be read from, and written to.
 438  *
 439  * This function will return a pointer to a dentry if it succeeds.  This
 440  * pointer must be passed to the debugfs_remove() function when the file is
 441  * to be removed (no automatic cleanup happens if your module is unloaded,
 442  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
 443  * returned.
 444  *
 445  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 446  * be returned.
 447  */
 448 struct dentry *debugfs_create_u16(const char *name, umode_t mode,
 449                                   struct dentry *parent, u16 *value)
 450 {
 451         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
 452                                    &fops_u16_ro, &fops_u16_wo);
 453 }
 454 EXPORT_SYMBOL_GPL(debugfs_create_u16);
 455
 456 static int debugfs_u32_set(void *data, u64 val)
 457 {
 458         *(u32 *)data = val;
 459         return 0;
 460 }
 461 static int debugfs_u32_get(void *data, u64 *val)
 462 {
 463         *val = *(u32 *)data;
 464         return 0;
 465 }
 466 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 467 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 468 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 469
 470 /**
 471  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 472  * @name: a pointer to a string containing the name of the file to create.
 473  * @mode: the permission that the file should have
 474  * @parent: a pointer to the parent dentry for this file.  This should be a
 475  *          directory dentry if set.  If this parameter is %NULL, then the
 476  *          file will be created in the root of the debugfs filesystem.
 477  * @value: a pointer to the variable that the file should read to and write
 478  *         from.
 479  *
 480  * This function creates a file in debugfs with the given name that
 481  * contains the value of the variable @value.  If the @mode variable is so
 482  * set, it can be read from, and written to.
 483  *
 484  * This function will return a pointer to a dentry if it succeeds.  This
 485  * pointer must be passed to the debugfs_remove() function when the file is
 486  * to be removed (no automatic cleanup happens if your module is unloaded,
 487  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
 488  * returned.
 489  *
 490  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 491  * be returned.
 492  */
 493 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
 494                                  struct dentry *parent, u32 *value)
 495 {
 496         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
 497                                    &fops_u32_ro, &fops_u32_wo);
 498 }
 499 EXPORT_SYMBOL_GPL(debugfs_create_u32);
 500
 501 static int debugfs_u64_set(void *data, u64 val)
 502 {
 503         *(u64 *)data = val;
 504         return 0;
 505 }
 506
 507 static int debugfs_u64_get(void *data, u64 *val)
 508 {
 509         *val = *(u64 *)data;
 510         return 0;
 511 }
 512 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 513 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 514 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 515
 516 /**
 517  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 518  * @name: a pointer to a string containing the name of the file to create.
 519  * @mode: the permission that the file should have
 520  * @parent: a pointer to the parent dentry for this file.  This should be a
 521  *          directory dentry if set.  If this parameter is %NULL, then the
 522  *          file will be created in the root of the debugfs filesystem.
 523  * @value: a pointer to the variable that the file should read to and write
 524  *         from.
 525  *
 526  * This function creates a file in debugfs with the given name that
 527  * contains the value of the variable @value.  If the @mode variable is so
 528  * set, it can be read from, and written to.
 529  *
 530  * This function will return a pointer to a dentry if it succeeds.  This
 531  * pointer must be passed to the debugfs_remove() function when the file is
 532  * to be removed (no automatic cleanup happens if your module is unloaded,
 533  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
 534  * returned.
 535  *
 536  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 537  * be returned.
 538  */
 539 struct dentry *debugfs_create_u64(const char *name, umode_t mode,
 540                                  struct dentry *parent, u64 *value)
 541 {
 542         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
 543                                    &fops_u64_ro, &fops_u64_wo);
 544 }
 545 EXPORT_SYMBOL_GPL(debugfs_create_u64);
 546
 547 static int debugfs_ulong_set(void *data, u64 val)
 548 {
 549         *(unsigned long *)data = val;
 550         return 0;
 551 }
 552
 553 static int debugfs_ulong_get(void *data, u64 *val)
 554 {
 555         *val = *(unsigned long *)data;
 556         return 0;
 557 }
 558 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
 559                         "%llu\n");
 560 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
 561 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 562
 563 /**
 564  * debugfs_create_ulong - create a debugfs file that is used to read and write
 565  * an unsigned long value.
 566  * @name: a pointer to a string containing the name of the file to create.
 567  * @mode: the permission that the file should have
 568  * @parent: a pointer to the parent dentry for this file.  This should be a
 569  *          directory dentry if set.  If this parameter is %NULL, then the
 570  *          file will be created in the root of the debugfs filesystem.
 571  * @value: a pointer to the variable that the file should read to and write
 572  *         from.
 573  *
 574  * This function creates a file in debugfs with the given name that
 575  * contains the value of the variable @value.  If the @mode variable is so
 576  * set, it can be read from, and written to.
 577  *
 578  * This function will return a pointer to a dentry if it succeeds.  This
 579  * pointer must be passed to the debugfs_remove() function when the file is
 580  * to be removed (no automatic cleanup happens if your module is unloaded,
 581  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
 582  * returned.
 583  *
 584  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 585  * be returned.
 586  */
 587 struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
 588                                     struct dentry *parent, unsigned long *value)
 589 {
 590         return debugfs_create_mode_unsafe(name, mode, parent, value,
 591                                         &fops_ulong, &fops_ulong_ro,
 592                                         &fops_ulong_wo);
 593 }
 594 EXPORT_SYMBOL_GPL(debugfs_create_ulong);
 595
 596 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 597 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 598 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 599
 600 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
 601                         "0x%04llx\n");
 602 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 603 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 604
 605 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
 606                         "0x%08llx\n");
 607 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 608 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 609
 610 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
 611                         "0x%016llx\n");
 612 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
 613 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 614
 615 /*
 616  * 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
 617  *
 618  * These functions are exactly the same as the above functions (but use a hex
 619  * output for the decimal challenged). For details look at the above unsigned
 620  * decimal functions.
 621  */
 622
 623 /**
 624  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 625  * @name: a pointer to a string containing the name of the file to create.
 626  * @mode: the permission that the file should have
 627  * @parent: a pointer to the parent dentry for this file.  This should be a
 628  *          directory dentry if set.  If this parameter is %NULL, then the
 629  *          file will be created in the root of the debugfs filesystem.
 630  * @value: a pointer to the variable that the file should read to and write
 631  *         from.
 632  */
 633 struct dentry *debugfs_create_x8(const char *name, umode_t mode,
 634                                  struct dentry *parent, u8 *value)
 635 {
 636         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
 637                                    &fops_x8_ro, &fops_x8_wo);
 638 }
 639 EXPORT_SYMBOL_GPL(debugfs_create_x8);
 640
 641 /**
 642  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 643  * @name: a pointer to a string containing the name of the file to create.
 644  * @mode: the permission that the file should have
 645  * @parent: a pointer to the parent dentry for this file.  This should be a
 646  *          directory dentry if set.  If this parameter is %NULL, then the
 647  *          file will be created in the root of the debugfs filesystem.
 648  * @value: a pointer to the variable that the file should read to and write
 649  *         from.
 650  */
 651 struct dentry *debugfs_create_x16(const char *name, umode_t mode,
 652                                  struct dentry *parent, u16 *value)
 653 {
 654         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
 655                                    &fops_x16_ro, &fops_x16_wo);
 656 }
 657 EXPORT_SYMBOL_GPL(debugfs_create_x16);
 658
 659 /**
 660  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 661  * @name: a pointer to a string containing the name of the file to create.
 662  * @mode: the permission that the file should have
 663  * @parent: a pointer to the parent dentry for this file.  This should be a
 664  *          directory dentry if set.  If this parameter is %NULL, then the
 665  *          file will be created in the root of the debugfs filesystem.
 666  * @value: a pointer to the variable that the file should read to and write
 667  *         from.
 668  */
 669 struct dentry *debugfs_create_x32(const char *name, umode_t mode,
 670                                  struct dentry *parent, u32 *value)
 671 {
 672         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
 673                                    &fops_x32_ro, &fops_x32_wo);
 674 }
 675 EXPORT_SYMBOL_GPL(debugfs_create_x32);
 676
 677 /**
 678  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 679  * @name: a pointer to a string containing the name of the file to create.
 680  * @mode: the permission that the file should have
 681  * @parent: a pointer to the parent dentry for this file.  This should be a
 682  *          directory dentry if set.  If this parameter is %NULL, then the
 683  *          file will be created in the root of the debugfs filesystem.
 684  * @value: a pointer to the variable that the file should read to and write
 685  *         from.
 686  */
 687 struct dentry *debugfs_create_x64(const char *name, umode_t mode,
 688                                  struct dentry *parent, u64 *value)
 689 {
 690         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
 691                                    &fops_x64_ro, &fops_x64_wo);
 692 }
 693 EXPORT_SYMBOL_GPL(debugfs_create_x64);
 694
 695
 696 static int debugfs_size_t_set(void *data, u64 val)
 697 {
 698         *(size_t *)data = val;
 699         return 0;
 700 }
 701 static int debugfs_size_t_get(void *data, u64 *val)
 702 {
 703         *val = *(size_t *)data;
 704         return 0;
 705 }
 706 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 707                         "%llu\n"); /* %llu and %zu are more or less the same */
 708 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
 709 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 710
 711 /**
 712  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
 713  * @name: a pointer to a string containing the name of the file to create.
 714  * @mode: the permission that the file should have
 715  * @parent: a pointer to the parent dentry for this file.  This should be a
 716  *          directory dentry if set.  If this parameter is %NULL, then the
 717  *          file will be created in the root of the debugfs filesystem.
 718  * @value: a pointer to the variable that the file should read to and write
 719  *         from.
 720  */
 721 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
 722                                      struct dentry *parent, size_t *value)
 723 {
 724         return debugfs_create_mode_unsafe(name, mode, parent, value,
 725                                         &fops_size_t, &fops_size_t_ro,
 726                                         &fops_size_t_wo);
 727 }
 728 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 729
 730 static int debugfs_atomic_t_set(void *data, u64 val)
 731 {
 732         atomic_set((atomic_t *)data, val);
 733         return 0;
 734 }
 735 static int debugfs_atomic_t_get(void *data, u64 *val)
 736 {
 737         *val = atomic_read((atomic_t *)data);
 738         return 0;
 739 }
 740 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
 741                         debugfs_atomic_t_set, "%lld\n");
 742 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
 743                         "%lld\n");
 744 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
 745                         "%lld\n");
 746
 747 /**
 748  * debugfs_create_atomic_t - create a debugfs file that is used to read and
 749  * write an atomic_t value
 750  * @name: a pointer to a string containing the name of the file to create.
 751  * @mode: the permission that the file should have
 752  * @parent: a pointer to the parent dentry for this file.  This should be a
 753  *          directory dentry if set.  If this parameter is %NULL, then the
 754  *          file will be created in the root of the debugfs filesystem.
 755  * @value: a pointer to the variable that the file should read to and write
 756  *         from.
 757  */
 758 struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
 759                                  struct dentry *parent, atomic_t *value)
 760 {
 761         return debugfs_create_mode_unsafe(name, mode, parent, value,
 762                                         &fops_atomic_t, &fops_atomic_t_ro,
 763                                         &fops_atomic_t_wo);
 764 }
 765 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 766
 767 ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
 768                                size_t count, loff_t *ppos)
 769 {
 770         char buf[3];
 771         bool val;
 772         int r;
 773         struct dentry *dentry = F_DENTRY(file);
 774
 775         r = debugfs_file_get(dentry);
 776         if (unlikely(r))
 777                 return r;
 778         val = *(bool *)file->private_data;
 779         debugfs_file_put(dentry);
 780
 781         if (val)
 782                 buf[0] = 'Y';
 783         else
 784                 buf[0] = 'N';
 785         buf[1] = '\n';
 786         buf[2] = 0x00;
 787         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 788 }
 789 EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
 790
 791 ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
 792                                 size_t count, loff_t *ppos)
 793 {
 794         bool bv;
 795         int r;
 796         bool *val = file->private_data;
 797         struct dentry *dentry = F_DENTRY(file);
 798
 799         r = kstrtobool_from_user(user_buf, count, &bv);
 800         if (!r) {
 801                 r = debugfs_file_get(dentry);
 802                 if (unlikely(r))
 803                         return r;
 804                 *val = bv;
 805                 debugfs_file_put(dentry);
 806         }
 807
 808         return count;
 809 }
 810 EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 811
 812 static const struct file_operations fops_bool = {
 813         .read =         debugfs_read_file_bool,
 814         .write =        debugfs_write_file_bool,
 815         .open =         simple_open,
 816         .llseek =       default_llseek,
 817 };
 818
 819 static const struct file_operations fops_bool_ro = {
 820         .read =         debugfs_read_file_bool,
 821         .open =         simple_open,
 822         .llseek =       default_llseek,
 823 };
 824
 825 static const struct file_operations fops_bool_wo = {
 826         .write =        debugfs_write_file_bool,
 827         .open =         simple_open,
 828         .llseek =       default_llseek,
 829 };
 830
 831 /**
 832  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 833  * @name: a pointer to a string containing the name of the file to create.
 834  * @mode: the permission that the file should have
 835  * @parent: a pointer to the parent dentry for this file.  This should be a
 836  *          directory dentry if set.  If this parameter is %NULL, then the
 837  *          file will be created in the root of the debugfs filesystem.
 838  * @value: a pointer to the variable that the file should read to and write
 839  *         from.
 840  *
 841  * This function creates a file in debugfs with the given name that
 842  * contains the value of the variable @value.  If the @mode variable is so
 843  * set, it can be read from, and written to.
 844  *
 845  * This function will return a pointer to a dentry if it succeeds.  This
 846  * pointer must be passed to the debugfs_remove() function when the file is
 847  * to be removed (no automatic cleanup happens if your module is unloaded,
 848  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
 849  * returned.
 850  *
 851  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 852  * be returned.
 853  */
 854 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 855                                    struct dentry *parent, bool *value)
 856 {
 857         return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
 858                                    &fops_bool_ro, &fops_bool_wo);
 859 }
 860 EXPORT_SYMBOL_GPL(debugfs_create_bool);
 861
 862 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 863                               size_t count, loff_t *ppos)
 864 {
 865         struct debugfs_blob_wrapper *blob = file->private_data;
 866         struct dentry *dentry = F_DENTRY(file);
 867         ssize_t r;
 868
 869         r = debugfs_file_get(dentry);
 870         if (unlikely(r))
 871                 return r;
 872         r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
 873                                 blob->size);
 874         debugfs_file_put(dentry);
 875         return r;
 876 }
 877
 878 static const struct file_operations fops_blob = {
 879         .read =         read_file_blob,
 880         .open =         simple_open,
 881         .llseek =       default_llseek,
 882 };
 883
 884 /**
 885  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 886  * @name: a pointer to a string containing the name of the file to create.
 887  * @mode: the permission that the file should have
 888  * @parent: a pointer to the parent dentry for this file.  This should be a
 889  *          directory dentry if set.  If this parameter is %NULL, then the
 890  *          file will be created in the root of the debugfs filesystem.
 891  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 892  *        to the blob data and the size of the data.
 893  *
 894  * This function creates a file in debugfs with the given name that exports
 895  * @blob->data as a binary blob. If the @mode variable is so set it can be
 896  * read from. Writing is not supported.
 897  *
 898  * This function will return a pointer to a dentry if it succeeds.  This
 899  * pointer must be passed to the debugfs_remove() function when the file is
 900  * to be removed (no automatic cleanup happens if your module is unloaded,
 901  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
 902  * returned.
 903  *
 904  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
 905  * be returned.
 906  */
 907 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 908                                    struct dentry *parent,
 909                                    struct debugfs_blob_wrapper *blob)
 910 {
 911         return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
 912 }
 913 EXPORT_SYMBOL_GPL(debugfs_create_blob);
 914
 915 struct array_data {
 916         void *array;
 917         u32 elements;
 918 };
 919
 920 static size_t u32_format_array(char *buf, size_t bufsize,
 921                                u32 *array, int array_size)
 922 {
 923         size_t ret = 0;
 924
 925         while (--array_size >= 0) {
 926                 size_t len;
 927                 char term = array_size ? ' ' : '\n';
 928
 929                 len = snprintf(buf, bufsize, "%u%c", *array++, term);
 930                 ret += len;
 931
 932                 buf += len;
 933                 bufsize -= len;
 934         }
 935         return ret;
 936 }
 937
 938 static int u32_array_open(struct inode *inode, struct file *file)
 939 {
 940         struct array_data *data = inode->i_private;
 941         int size, elements = data->elements;
 942         char *buf;
 943
 944         /*
 945          * Max size:
 946          *  - 10 digits + ' '/'\n' = 11 bytes per number
 947          *  - terminating NUL character
 948          */
 949         size = elements*11;
 950         buf = kmalloc(size+1, GFP_KERNEL);
 951         if (!buf)
 952                 return -ENOMEM;
 953         buf[size] = 0;
 954
 955         file->private_data = buf;
 956         u32_format_array(buf, size, data->array, data->elements);
 957
 958         return nonseekable_open(inode, file);
 959 }
 960
 961 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
 962                               loff_t *ppos)
 963 {
 964         size_t size = strlen(file->private_data);
 965
 966         return simple_read_from_buffer(buf, len, ppos,
 967                                         file->private_data, size);
 968 }
 969
 970 static int u32_array_release(struct inode *inode, struct file *file)
 971 {
 972         kfree(file->private_data);
 973
 974         return 0;
 975 }
 976
 977 static const struct file_operations u32_array_fops = {
 978         .owner   = THIS_MODULE,
 979         .open    = u32_array_open,
 980         .release = u32_array_release,
 981         .read    = u32_array_read,
 982         .llseek  = no_llseek,
 983 };
 984
 985 /**
 986  * debugfs_create_u32_array - create a debugfs file that is used to read u32
 987  * array.
 988  * @name: a pointer to a string containing the name of the file to create.
 989  * @mode: the permission that the file should have.
 990  * @parent: a pointer to the parent dentry for this file.  This should be a
 991  *          directory dentry if set.  If this parameter is %NULL, then the
 992  *          file will be created in the root of the debugfs filesystem.
 993  * @array: u32 array that provides data.
 994  * @elements: total number of elements in the array.
 995  *
 996  * This function creates a file in debugfs with the given name that exports
 997  * @array as data. If the @mode variable is so set it can be read from.
 998  * Writing is not supported. Seek within the file is also not supported.
 999  * Once array is created its size can not be changed.
1000  */
1001 void debugfs_create_u32_array(const char *name, umode_t mode,
1002                               struct dentry *parent, u32 *array, u32 elements)
1003 {
1004         struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
1005
1006         if (data == NULL)
1007                 return;
1008
1009         data->array = array;
1010         data->elements = elements;
1011
1012         debugfs_create_file_unsafe(name, mode, parent, data, &u32_array_fops);
1013 }
1014 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
1015
1016 #ifdef CONFIG_HAS_IOMEM
1017
1018 /*
1019  * The regset32 stuff is used to print 32-bit registers using the
1020  * seq_file utilities. We offer printing a register set in an already-opened
1021  * sequential file or create a debugfs file that only prints a regset32.
1022  */
1023
1024 /**
1025  * debugfs_print_regs32 - use seq_print to describe a set of registers
1026  * @s: the seq_file structure being used to generate output
1027  * @regs: an array if struct debugfs_reg32 structures
1028  * @nregs: the length of the above array
1029  * @base: the base address to be used in reading the registers
1030  * @prefix: a string to be prefixed to every output line
1031  *
1032  * This function outputs a text block describing the current values of
1033  * some 32-bit hardware registers. It is meant to be used within debugfs
1034  * files based on seq_file that need to show registers, intermixed with other
1035  * information. The prefix argument may be used to specify a leading string,
1036  * because some peripherals have several blocks of identical registers,
1037  * for example configuration of dma channels
1038  */
1039 void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1040                           int nregs, void __iomem *base, char *prefix)
1041 {
1042         int i;
1043
1044         for (i = 0; i < nregs; i++, regs++) {
1045                 if (prefix)
1046                         seq_printf(s, "%s", prefix);
1047                 seq_printf(s, "%s = 0x%08x\n", regs->name,
1048                            readl(base + regs->offset));
1049                 if (seq_has_overflowed(s))
1050                         break;
1051         }
1052 }
1053 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1054
1055 static int debugfs_show_regset32(struct seq_file *s, void *data)
1056 {
1057         struct debugfs_regset32 *regset = s->private;
1058
1059         debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1060         return 0;
1061 }
1062
1063 static int debugfs_open_regset32(struct inode *inode, struct file *file)
1064 {
1065         return single_open(file, debugfs_show_regset32, inode->i_private);
1066 }
1067
1068 static const struct file_operations fops_regset32 = {
1069         .open =         debugfs_open_regset32,
1070         .read =         seq_read,
1071         .llseek =       seq_lseek,
1072         .release =      single_release,
1073 };
1074
1075 /**
1076  * debugfs_create_regset32 - create a debugfs file that returns register values
1077  * @name: a pointer to a string containing the name of the file to create.
1078  * @mode: the permission that the file should have
1079  * @parent: a pointer to the parent dentry for this file.  This should be a
1080  *          directory dentry if set.  If this parameter is %NULL, then the
1081  *          file will be created in the root of the debugfs filesystem.
1082  * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1083  *          to an array of register definitions, the array size and the base
1084  *          address where the register bank is to be found.
1085  *
1086  * This function creates a file in debugfs with the given name that reports
1087  * the names and values of a set of 32-bit registers. If the @mode variable
1088  * is so set it can be read from. Writing is not supported.
1089  *
1090  * This function will return a pointer to a dentry if it succeeds.  This
1091  * pointer must be passed to the debugfs_remove() function when the file is
1092  * to be removed (no automatic cleanup happens if your module is unloaded,
1093  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
1094  * returned.
1095  *
1096  * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
1097  * be returned.
1098  */
1099 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
1100                                        struct dentry *parent,
1101                                        struct debugfs_regset32 *regset)
1102 {
1103         return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
1104 }
1105 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1106
1107 #endif /* CONFIG_HAS_IOMEM */
1108
1109 struct debugfs_devm_entry {
1110         int (*read)(struct seq_file *seq, void *data);
1111         struct device *dev;
1112 };
1113
1114 static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1115 {
1116         struct debugfs_devm_entry *entry = inode->i_private;
1117
1118         return single_open(f, entry->read, entry->dev);
1119 }
1120
1121 static const struct file_operations debugfs_devm_entry_ops = {
1122         .owner = THIS_MODULE,
1123         .open = debugfs_devm_entry_open,
1124         .release = single_release,
1125         .read = seq_read,
1126         .llseek = seq_lseek
1127 };
1128
1129 /**
1130  * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1131  *
1132  * @dev: device related to this debugfs file.
1133  * @name: name of the debugfs file.
1134  * @parent: a pointer to the parent dentry for this file.  This should be a
1135  *      directory dentry if set.  If this parameter is %NULL, then the
1136  *      file will be created in the root of the debugfs filesystem.
1137  * @read_fn: function pointer called to print the seq_file content.
1138  */
1139 struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
1140                                            struct dentry *parent,
1141                                            int (*read_fn)(struct seq_file *s,
1142                                                           void *data))
1143 {
1144         struct debugfs_devm_entry *entry;
1145
1146         if (IS_ERR(parent))
1147                 return ERR_PTR(-ENOENT);
1148
1149         entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1150         if (!entry)
1151                 return ERR_PTR(-ENOMEM);
1152
1153         entry->read = read_fn;
1154         entry->dev = dev;
1155
1156         return debugfs_create_file(name, S_IRUGO, parent, entry,
1157                                    &debugfs_devm_entry_ops);
1158 }
1159 EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
1160