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