fs/debugfs/file.c

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