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         size_t buf_size;
 432         bool bv;
 433         u32 *val = file->private_data;
 434
 435         buf_size = min(count, (sizeof(buf)-1));
 436         if (copy_from_user(buf, user_buf, buf_size))
 437                 return -EFAULT;
 438
 439         if (strtobool(buf, &bv) == 0)
 440                 *val = bv;
 441
 442         return count;
 443 }
 444
 445 static const struct file_operations fops_bool = {
 446         .read =         read_file_bool,
 447         .write =        write_file_bool,
 448         .open =         default_open,
 449         .llseek =       default_llseek,
 450 };
 451
 452 /**
 453  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 454  * @name: a pointer to a string containing the name of the file to create.
 455  * @mode: the permission that the file should have
 456  * @parent: a pointer to the parent dentry for this file.  This should be a
 457  *          directory dentry if set.  If this parameter is %NULL, then the
 458  *          file will be created in the root of the debugfs filesystem.
 459  * @value: a pointer to the variable that the file should read to and write
 460  *         from.
 461  *
 462  * This function creates a file in debugfs with the given name that
 463  * contains the value of the variable @value.  If the @mode variable is so
 464  * set, it can be read from, and written to.
 465  *
 466  * This function will return a pointer to a dentry if it succeeds.  This
 467  * pointer must be passed to the debugfs_remove() function when the file is
 468  * to be removed (no automatic cleanup happens if your module is unloaded,
 469  * you are responsible here.)  If an error occurs, %NULL will be returned.
 470  *
 471  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 472  * returned.  It is not wise to check for this value, but rather, check for
 473  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 474  * code.
 475  */
 476 struct dentry *debugfs_create_bool(const char *name, mode_t mode,
 477                                    struct dentry *parent, u32 *value)
 478 {
 479         return debugfs_create_file(name, mode, parent, value, &fops_bool);
 480 }
 481 EXPORT_SYMBOL_GPL(debugfs_create_bool);
 482
 483 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 484                               size_t count, loff_t *ppos)
 485 {
 486         struct debugfs_blob_wrapper *blob = file->private_data;
 487         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
 488                         blob->size);
 489 }
 490
 491 static const struct file_operations fops_blob = {
 492         .read =         read_file_blob,
 493         .open =         default_open,
 494         .llseek =       default_llseek,
 495 };
 496
 497 /**
 498  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 499  * @name: a pointer to a string containing the name of the file to create.
 500  * @mode: the permission that the file should have
 501  * @parent: a pointer to the parent dentry for this file.  This should be a
 502  *          directory dentry if set.  If this parameter is %NULL, then the
 503  *          file will be created in the root of the debugfs filesystem.
 504  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 505  *        to the blob data and the size of the data.
 506  *
 507  * This function creates a file in debugfs with the given name that exports
 508  * @blob->data as a binary blob. If the @mode variable is so set it can be
 509  * read from. Writing is not supported.
 510  *
 511  * This function will return a pointer to a dentry if it succeeds.  This
 512  * pointer must be passed to the debugfs_remove() function when the file is
 513  * to be removed (no automatic cleanup happens if your module is unloaded,
 514  * you are responsible here.)  If an error occurs, %NULL will be returned.
 515  *
 516  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 517  * returned.  It is not wise to check for this value, but rather, check for
 518  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 519  * code.
 520  */
 521 struct dentry *debugfs_create_blob(const char *name, mode_t mode,
 522                                    struct dentry *parent,
 523                                    struct debugfs_blob_wrapper *blob)
 524 {
 525         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
 526 }
 527 EXPORT_SYMBOL_GPL(debugfs_create_blob);