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/pagemap.h>
  19 #include <linux/namei.h>
  20 #include <linux/debugfs.h>
  21
  22 static ssize_t default_read_file(struct file *file, char __user *buf,
  23                                  size_t count, loff_t *ppos)
  24 {
  25         return 0;
  26 }
  27
  28 static ssize_t default_write_file(struct file *file, const char __user *buf,
  29                                    size_t count, loff_t *ppos)
  30 {
  31         return count;
  32 }
  33
  34 static int default_open(struct inode *inode, struct file *file)
  35 {
  36         if (inode->i_private)
  37                 file->private_data = inode->i_private;
  38
  39         return 0;
  40 }
  41
  42 const struct file_operations debugfs_file_operations = {
  43         .read =         default_read_file,
  44         .write =        default_write_file,
  45         .open =         default_open,
  46         .llseek =       noop_llseek,
  47 };
  48
  49 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
  50 {
  51         nd_set_link(nd, dentry->d_inode->i_private);
  52         return NULL;
  53 }
  54
  55 const struct inode_operations debugfs_link_operations = {
  56         .readlink       = generic_readlink,
  57         .follow_link    = debugfs_follow_link,
  58 };
  59
  60 static int debugfs_u8_set(void *data, u64 val)
  61 {
  62         *(u8 *)data = val;
  63         return 0;
  64 }
  65 static int debugfs_u8_get(void *data, u64 *val)
  66 {
  67         *val = *(u8 *)data;
  68         return 0;
  69 }
  70 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
  71 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
  72 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
  73
  74 /**
  75  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
  76  * @name: a pointer to a string containing the name of the file to create.
  77  * @mode: the permission that the file should have
  78  * @parent: a pointer to the parent dentry for this file.  This should be a
  79  *          directory dentry if set.  If this parameter is %NULL, then the
  80  *          file will be created in the root of the debugfs filesystem.
  81  * @value: a pointer to the variable that the file should read to and write
  82  *         from.
  83  *
  84  * This function creates a file in debugfs with the given name that
  85  * contains the value of the variable @value.  If the @mode variable is so
  86  * set, it can be read from, and written to.
  87  *
  88  * This function will return a pointer to a dentry if it succeeds.  This
  89  * pointer must be passed to the debugfs_remove() function when the file is
  90  * to be removed (no automatic cleanup happens if your module is unloaded,
  91  * you are responsible here.)  If an error occurs, %NULL will be returned.
  92  *
  93  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  94  * returned.  It is not wise to check for this value, but rather, check for
  95  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  96  * code.
  97  */
  98 struct dentry *debugfs_create_u8(const char *name, mode_t mode,
  99                                  struct dentry *parent, u8 *value)
 100 {
 101         /* if there are no write bits set, make read only */
 102         if (!(mode & S_IWUGO))
 103                 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
 104         /* if there are no read bits set, make write only */
 105         if (!(mode & S_IRUGO))
 106                 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
 107
 108         return debugfs_create_file(name, mode, parent, value, &fops_u8);
 109 }
 110 EXPORT_SYMBOL_GPL(debugfs_create_u8);
 111
 112 static int debugfs_u16_set(void *data, u64 val)
 113 {
 114         *(u16 *)data = val;
 115         return 0;
 116 }
 117 static int debugfs_u16_get(void *data, u64 *val)
 118 {
 119         *val = *(u16 *)data;
 120         return 0;
 121 }
 122 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 123 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 124 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 125
 126 /**
 127  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 128  * @name: a pointer to a string containing the name of the file to create.
 129  * @mode: the permission that the file should have
 130  * @parent: a pointer to the parent dentry for this file.  This should be a
 131  *          directory dentry if set.  If this parameter is %NULL, then the
 132  *          file will be created in the root of the debugfs filesystem.
 133  * @value: a pointer to the variable that the file should read to and write
 134  *         from.
 135  *
 136  * This function creates a file in debugfs with the given name that
 137  * contains the value of the variable @value.  If the @mode variable is so
 138  * set, it can be read from, and written to.
 139  *
 140  * This function will return a pointer to a dentry if it succeeds.  This
 141  * pointer must be passed to the debugfs_remove() function when the file is
 142  * to be removed (no automatic cleanup happens if your module is unloaded,
 143  * you are responsible here.)  If an error occurs, %NULL will be returned.
 144  *
 145  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 146  * returned.  It is not wise to check for this value, but rather, check for
 147  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 148  * code.
 149  */
 150 struct dentry *debugfs_create_u16(const char *name, mode_t mode,
 151                                   struct dentry *parent, u16 *value)
 152 {
 153         /* if there are no write bits set, make read only */
 154         if (!(mode & S_IWUGO))
 155                 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
 156         /* if there are no read bits set, make write only */
 157         if (!(mode & S_IRUGO))
 158                 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
 159
 160         return debugfs_create_file(name, mode, parent, value, &fops_u16);
 161 }
 162 EXPORT_SYMBOL_GPL(debugfs_create_u16);
 163
 164 static int debugfs_u32_set(void *data, u64 val)
 165 {
 166         *(u32 *)data = val;
 167         return 0;
 168 }
 169 static int debugfs_u32_get(void *data, u64 *val)
 170 {
 171         *val = *(u32 *)data;
 172         return 0;
 173 }
 174 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 175 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 176 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 177
 178 /**
 179  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 180  * @name: a pointer to a string containing the name of the file to create.
 181  * @mode: the permission that the file should have
 182  * @parent: a pointer to the parent dentry for this file.  This should be a
 183  *          directory dentry if set.  If this parameter is %NULL, then the
 184  *          file will be created in the root of the debugfs filesystem.
 185  * @value: a pointer to the variable that the file should read to and write
 186  *         from.
 187  *
 188  * This function creates a file in debugfs with the given name that
 189  * contains the value of the variable @value.  If the @mode variable is so
 190  * set, it can be read from, and written to.
 191  *
 192  * This function will return a pointer to a dentry if it succeeds.  This
 193  * pointer must be passed to the debugfs_remove() function when the file is
 194  * to be removed (no automatic cleanup happens if your module is unloaded,
 195  * you are responsible here.)  If an error occurs, %NULL will be returned.
 196  *
 197  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 198  * returned.  It is not wise to check for this value, but rather, check for
 199  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 200  * code.
 201  */
 202 struct dentry *debugfs_create_u32(const char *name, mode_t mode,
 203                                  struct dentry *parent, u32 *value)
 204 {
 205         /* if there are no write bits set, make read only */
 206         if (!(mode & S_IWUGO))
 207                 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
 208         /* if there are no read bits set, make write only */
 209         if (!(mode & S_IRUGO))
 210                 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
 211
 212         return debugfs_create_file(name, mode, parent, value, &fops_u32);
 213 }
 214 EXPORT_SYMBOL_GPL(debugfs_create_u32);
 215
 216 static int debugfs_u64_set(void *data, u64 val)
 217 {
 218         *(u64 *)data = val;
 219         return 0;
 220 }
 221
 222 static int debugfs_u64_get(void *data, u64 *val)
 223 {
 224         *val = *(u64 *)data;
 225         return 0;
 226 }
 227 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 228 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 229 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 230
 231 /**
 232  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 233  * @name: a pointer to a string containing the name of the file to create.
 234  * @mode: the permission that the file should have
 235  * @parent: a pointer to the parent dentry for this file.  This should be a
 236  *          directory dentry if set.  If this parameter is %NULL, then the
 237  *          file will be created in the root of the debugfs filesystem.
 238  * @value: a pointer to the variable that the file should read to and write
 239  *         from.
 240  *
 241  * This function creates a file in debugfs with the given name that
 242  * contains the value of the variable @value.  If the @mode variable is so
 243  * set, it can be read from, and written to.
 244  *
 245  * This function will return a pointer to a dentry if it succeeds.  This
 246  * pointer must be passed to the debugfs_remove() function when the file is
 247  * to be removed (no automatic cleanup happens if your module is unloaded,
 248  * you are responsible here.)  If an error occurs, %NULL will be returned.
 249  *
 250  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 251  * returned.  It is not wise to check for this value, but rather, check for
 252  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 253  * code.
 254  */
 255 struct dentry *debugfs_create_u64(const char *name, mode_t mode,
 256                                  struct dentry *parent, u64 *value)
 257 {
 258         /* if there are no write bits set, make read only */
 259         if (!(mode & S_IWUGO))
 260                 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
 261         /* if there are no read bits set, make write only */
 262         if (!(mode & S_IRUGO))
 263                 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
 264
 265         return debugfs_create_file(name, mode, parent, value, &fops_u64);
 266 }
 267 EXPORT_SYMBOL_GPL(debugfs_create_u64);
 268
 269 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 270 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 271 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 272
 273 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
 274 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 275 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 276
 277 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
 278 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 279 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 280
 281 DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
 282
 283 /*
 284  * 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
 285  *
 286  * These functions are exactly the same as the above functions (but use a hex
 287  * output for the decimal challenged). For details look at the above unsigned
 288  * decimal functions.
 289  */
 290
 291 /**
 292  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 293  * @name: a pointer to a string containing the name of the file to create.
 294  * @mode: the permission that the file should have
 295  * @parent: a pointer to the parent dentry for this file.  This should be a
 296  *          directory dentry if set.  If this parameter is %NULL, then the
 297  *          file will be created in the root of the debugfs filesystem.
 298  * @value: a pointer to the variable that the file should read to and write
 299  *         from.
 300  */
 301 struct dentry *debugfs_create_x8(const char *name, mode_t mode,
 302                                  struct dentry *parent, u8 *value)
 303 {
 304         /* if there are no write bits set, make read only */
 305         if (!(mode & S_IWUGO))
 306                 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
 307         /* if there are no read bits set, make write only */
 308         if (!(mode & S_IRUGO))
 309                 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
 310
 311         return debugfs_create_file(name, mode, parent, value, &fops_x8);
 312 }
 313 EXPORT_SYMBOL_GPL(debugfs_create_x8);
 314
 315 /**
 316  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 317  * @name: a pointer to a string containing the name of the file to create.
 318  * @mode: the permission that the file should have
 319  * @parent: a pointer to the parent dentry for this file.  This should be a
 320  *          directory dentry if set.  If this parameter is %NULL, then the
 321  *          file will be created in the root of the debugfs filesystem.
 322  * @value: a pointer to the variable that the file should read to and write
 323  *         from.
 324  */
 325 struct dentry *debugfs_create_x16(const char *name, mode_t mode,
 326                                  struct dentry *parent, u16 *value)
 327 {
 328         /* if there are no write bits set, make read only */
 329         if (!(mode & S_IWUGO))
 330                 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
 331         /* if there are no read bits set, make write only */
 332         if (!(mode & S_IRUGO))
 333                 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
 334
 335         return debugfs_create_file(name, mode, parent, value, &fops_x16);
 336 }
 337 EXPORT_SYMBOL_GPL(debugfs_create_x16);
 338
 339 /**
 340  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 341  * @name: a pointer to a string containing the name of the file to create.
 342  * @mode: the permission that the file should have
 343  * @parent: a pointer to the parent dentry for this file.  This should be a
 344  *          directory dentry if set.  If this parameter is %NULL, then the
 345  *          file will be created in the root of the debugfs filesystem.
 346  * @value: a pointer to the variable that the file should read to and write
 347  *         from.
 348  */
 349 struct dentry *debugfs_create_x32(const char *name, mode_t mode,
 350                                  struct dentry *parent, u32 *value)
 351 {
 352         /* if there are no write bits set, make read only */
 353         if (!(mode & S_IWUGO))
 354                 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
 355         /* if there are no read bits set, make write only */
 356         if (!(mode & S_IRUGO))
 357                 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
 358
 359         return debugfs_create_file(name, mode, parent, value, &fops_x32);
 360 }
 361 EXPORT_SYMBOL_GPL(debugfs_create_x32);
 362
 363 /**
 364  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 365  * @name: a pointer to a string containing the name of the file to create.
 366  * @mode: the permission that the file should have
 367  * @parent: a pointer to the parent dentry for this file.  This should be a
 368  *          directory dentry if set.  If this parameter is %NULL, then the
 369  *          file will be created in the root of the debugfs filesystem.
 370  * @value: a pointer to the variable that the file should read to and write
 371  *         from.
 372  */
 373 struct dentry *debugfs_create_x64(const char *name, mode_t mode,
 374                                  struct dentry *parent, u64 *value)
 375 {
 376         return debugfs_create_file(name, mode, parent, value, &fops_x64);
 377 }
 378 EXPORT_SYMBOL_GPL(debugfs_create_x64);
 379
 380
 381 static int debugfs_size_t_set(void *data, u64 val)
 382 {
 383         *(size_t *)data = val;
 384         return 0;
 385 }
 386 static int debugfs_size_t_get(void *data, u64 *val)
 387 {
 388         *val = *(size_t *)data;
 389         return 0;
 390 }
 391 DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 392                         "%llu\n");      /* %llu and %zu are more or less the same */
 393
 394 /**
 395  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t 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 struct dentry *debugfs_create_size_t(const char *name, mode_t mode,
 405                                      struct dentry *parent, size_t *value)
 406 {
 407         return debugfs_create_file(name, mode, parent, value, &fops_size_t);
 408 }
 409 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 410
 411
 412 static ssize_t read_file_bool(struct file *file, char __user *user_buf,
 413                               size_t count, loff_t *ppos)
 414 {
 415         char buf[3];
 416         u32 *val = file->private_data;
 417
 418         if (*val)
 419                 buf[0] = 'Y';
 420         else
 421                 buf[0] = 'N';
 422         buf[1] = '\n';
 423         buf[2] = 0x00;
 424         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 425 }
 426
 427 static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
 428                                size_t count, loff_t *ppos)
 429 {
 430         char buf[32];
 431         int buf_size;
 432         u32 *val = file->private_data;
 433
 434         buf_size = min(count, (sizeof(buf)-1));
 435         if (copy_from_user(buf, user_buf, buf_size))
 436                 return -EFAULT;
 437
 438         switch (buf[0]) {
 439         case 'y':
 440         case 'Y':
 441         case '1':
 442                 *val = 1;
 443                 break;
 444         case 'n':
 445         case 'N':
 446         case '0':
 447                 *val = 0;
 448                 break;
 449         }
 450
 451         return count;
 452 }
 453
 454 static const struct file_operations fops_bool = {
 455         .read =         read_file_bool,
 456         .write =        write_file_bool,
 457         .open =         default_open,
 458         .llseek =       default_llseek,
 459 };
 460
 461 /**
 462  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 463  * @name: a pointer to a string containing the name of the file to create.
 464  * @mode: the permission that the file should have
 465  * @parent: a pointer to the parent dentry for this file.  This should be a
 466  *          directory dentry if set.  If this parameter is %NULL, then the
 467  *          file will be created in the root of the debugfs filesystem.
 468  * @value: a pointer to the variable that the file should read to and write
 469  *         from.
 470  *
 471  * This function creates a file in debugfs with the given name that
 472  * contains the value of the variable @value.  If the @mode variable is so
 473  * set, it can be read from, and written to.
 474  *
 475  * This function will return a pointer to a dentry if it succeeds.  This
 476  * pointer must be passed to the debugfs_remove() function when the file is
 477  * to be removed (no automatic cleanup happens if your module is unloaded,
 478  * you are responsible here.)  If an error occurs, %NULL will be returned.
 479  *
 480  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 481  * returned.  It is not wise to check for this value, but rather, check for
 482  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 483  * code.
 484  */
 485 struct dentry *debugfs_create_bool(const char *name, mode_t mode,
 486                                    struct dentry *parent, u32 *value)
 487 {
 488         return debugfs_create_file(name, mode, parent, value, &fops_bool);
 489 }
 490 EXPORT_SYMBOL_GPL(debugfs_create_bool);
 491
 492 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 493                               size_t count, loff_t *ppos)
 494 {
 495         struct debugfs_blob_wrapper *blob = file->private_data;
 496         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
 497                         blob->size);
 498 }
 499
 500 static const struct file_operations fops_blob = {
 501         .read =         read_file_blob,
 502         .open =         default_open,
 503         .llseek =       default_llseek,
 504 };
 505
 506 /**
 507  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 508  * @name: a pointer to a string containing the name of the file to create.
 509  * @mode: the permission that the file should have
 510  * @parent: a pointer to the parent dentry for this file.  This should be a
 511  *          directory dentry if set.  If this parameter is %NULL, then the
 512  *          file will be created in the root of the debugfs filesystem.
 513  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 514  *        to the blob data and the size of the data.
 515  *
 516  * This function creates a file in debugfs with the given name that exports
 517  * @blob->data as a binary blob. If the @mode variable is so set it can be
 518  * read from. Writing is not supported.
 519  *
 520  * This function will return a pointer to a dentry if it succeeds.  This
 521  * pointer must be passed to the debugfs_remove() function when the file is
 522  * to be removed (no automatic cleanup happens if your module is unloaded,
 523  * you are responsible here.)  If an error occurs, %NULL will be returned.
 524  *
 525  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 526  * returned.  It is not wise to check for this value, but rather, check for
 527  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 528  * code.
 529  */
 530 struct dentry *debugfs_create_blob(const char *name, mode_t mode,
 531                                    struct dentry *parent,
 532                                    struct debugfs_blob_wrapper *blob)
 533 {
 534         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
 535 }
 536 EXPORT_SYMBOL_GPL(debugfs_create_blob);