Pileus Git - ~andy/linux/blob - 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/namei.h>
  21 #include <linux/debugfs.h>
  22 #include <linux/io.h>
  23 #include <linux/slab.h>
  24 #include <linux/atomic.h>
  25
  26 static ssize_t default_read_file(struct file *file, char __user *buf,
  27                                  size_t count, loff_t *ppos)
  28 {
  29         return 0;
  30 }
  31
  32 static ssize_t default_write_file(struct file *file, const char __user *buf,
  33                                    size_t count, loff_t *ppos)
  34 {
  35         return count;
  36 }
  37
  38 const struct file_operations debugfs_file_operations = {
  39         .read =         default_read_file,
  40         .write =        default_write_file,
  41         .open =         simple_open,
  42         .llseek =       noop_llseek,
  43 };
  44
  45 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
  46 {
  47         nd_set_link(nd, dentry->d_inode->i_private);
  48         return NULL;
  49 }
  50
  51 const struct inode_operations debugfs_link_operations = {
  52         .readlink       = generic_readlink,
  53         .follow_link    = debugfs_follow_link,
  54 };
  55
  56 static int debugfs_u8_set(void *data, u64 val)
  57 {
  58         *(u8 *)data = val;
  59         return 0;
  60 }
  61 static int debugfs_u8_get(void *data, u64 *val)
  62 {
  63         *val = *(u8 *)data;
  64         return 0;
  65 }
  66 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
  67 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
  68 DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
  69
  70 /**
  71  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
  72  * @name: a pointer to a string containing the name of the file to create.
  73  * @mode: the permission that the file should have
  74  * @parent: a pointer to the parent dentry for this file.  This should be a
  75  *          directory dentry if set.  If this parameter is %NULL, then the
  76  *          file will be created in the root of the debugfs filesystem.
  77  * @value: a pointer to the variable that the file should read to and write
  78  *         from.
  79  *
  80  * This function creates a file in debugfs with the given name that
  81  * contains the value of the variable @value.  If the @mode variable is so
  82  * set, it can be read from, and written to.
  83  *
  84  * This function will return a pointer to a dentry if it succeeds.  This
  85  * pointer must be passed to the debugfs_remove() function when the file is
  86  * to be removed (no automatic cleanup happens if your module is unloaded,
  87  * you are responsible here.)  If an error occurs, %NULL will be returned.
  88  *
  89  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  90  * returned.  It is not wise to check for this value, but rather, check for
  91  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  92  * code.
  93  */
  94 struct dentry *debugfs_create_u8(const char *name, umode_t mode,
  95                                  struct dentry *parent, u8 *value)
  96 {
  97         /* if there are no write bits set, make read only */
  98         if (!(mode & S_IWUGO))
  99                 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
 100         /* if there are no read bits set, make write only */
 101         if (!(mode & S_IRUGO))
 102                 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
 103
 104         return debugfs_create_file(name, mode, parent, value, &fops_u8);
 105 }
 106 EXPORT_SYMBOL_GPL(debugfs_create_u8);
 107
 108 static int debugfs_u16_set(void *data, u64 val)
 109 {
 110         *(u16 *)data = val;
 111         return 0;
 112 }
 113 static int debugfs_u16_get(void *data, u64 *val)
 114 {
 115         *val = *(u16 *)data;
 116         return 0;
 117 }
 118 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 119 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 120 DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 121
 122 /**
 123  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 124  * @name: a pointer to a string containing the name of the file to create.
 125  * @mode: the permission that the file should have
 126  * @parent: a pointer to the parent dentry for this file.  This should be a
 127  *          directory dentry if set.  If this parameter is %NULL, then the
 128  *          file will be created in the root of the debugfs filesystem.
 129  * @value: a pointer to the variable that the file should read to and write
 130  *         from.
 131  *
 132  * This function creates a file in debugfs with the given name that
 133  * contains the value of the variable @value.  If the @mode variable is so
 134  * set, it can be read from, and written to.
 135  *
 136  * This function will return a pointer to a dentry if it succeeds.  This
 137  * pointer must be passed to the debugfs_remove() function when the file is
 138  * to be removed (no automatic cleanup happens if your module is unloaded,
 139  * you are responsible here.)  If an error occurs, %NULL will be returned.
 140  *
 141  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 142  * returned.  It is not wise to check for this value, but rather, check for
 143  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 144  * code.
 145  */
 146 struct dentry *debugfs_create_u16(const char *name, umode_t mode,
 147                                   struct dentry *parent, u16 *value)
 148 {
 149         /* if there are no write bits set, make read only */
 150         if (!(mode & S_IWUGO))
 151                 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
 152         /* if there are no read bits set, make write only */
 153         if (!(mode & S_IRUGO))
 154                 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
 155
 156         return debugfs_create_file(name, mode, parent, value, &fops_u16);
 157 }
 158 EXPORT_SYMBOL_GPL(debugfs_create_u16);
 159
 160 static int debugfs_u32_set(void *data, u64 val)
 161 {
 162         *(u32 *)data = val;
 163         return 0;
 164 }
 165 static int debugfs_u32_get(void *data, u64 *val)
 166 {
 167         *val = *(u32 *)data;
 168         return 0;
 169 }
 170 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 171 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 172 DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 173
 174 /**
 175  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 176  * @name: a pointer to a string containing the name of the file to create.
 177  * @mode: the permission that the file should have
 178  * @parent: a pointer to the parent dentry for this file.  This should be a
 179  *          directory dentry if set.  If this parameter is %NULL, then the
 180  *          file will be created in the root of the debugfs filesystem.
 181  * @value: a pointer to the variable that the file should read to and write
 182  *         from.
 183  *
 184  * This function creates a file in debugfs with the given name that
 185  * contains the value of the variable @value.  If the @mode variable is so
 186  * set, it can be read from, and written to.
 187  *
 188  * This function will return a pointer to a dentry if it succeeds.  This
 189  * pointer must be passed to the debugfs_remove() function when the file is
 190  * to be removed (no automatic cleanup happens if your module is unloaded,
 191  * you are responsible here.)  If an error occurs, %NULL will be returned.
 192  *
 193  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 194  * returned.  It is not wise to check for this value, but rather, check for
 195  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 196  * code.
 197  */
 198 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
 199                                  struct dentry *parent, u32 *value)
 200 {
 201         /* if there are no write bits set, make read only */
 202         if (!(mode & S_IWUGO))
 203                 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
 204         /* if there are no read bits set, make write only */
 205         if (!(mode & S_IRUGO))
 206                 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
 207
 208         return debugfs_create_file(name, mode, parent, value, &fops_u32);
 209 }
 210 EXPORT_SYMBOL_GPL(debugfs_create_u32);
 211
 212 static int debugfs_u64_set(void *data, u64 val)
 213 {
 214         *(u64 *)data = val;
 215         return 0;
 216 }
 217
 218 static int debugfs_u64_get(void *data, u64 *val)
 219 {
 220         *val = *(u64 *)data;
 221         return 0;
 222 }
 223 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 224 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 225 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 226
 227 /**
 228  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 229  * @name: a pointer to a string containing the name of the file to create.
 230  * @mode: the permission that the file should have
 231  * @parent: a pointer to the parent dentry for this file.  This should be a
 232  *          directory dentry if set.  If this parameter is %NULL, then the
 233  *          file will be created in the root of the debugfs filesystem.
 234  * @value: a pointer to the variable that the file should read to and write
 235  *         from.
 236  *
 237  * This function creates a file in debugfs with the given name that
 238  * contains the value of the variable @value.  If the @mode variable is so
 239  * set, it can be read from, and written to.
 240  *
 241  * This function will return a pointer to a dentry if it succeeds.  This
 242  * pointer must be passed to the debugfs_remove() function when the file is
 243  * to be removed (no automatic cleanup happens if your module is unloaded,
 244  * you are responsible here.)  If an error occurs, %NULL will be returned.
 245  *
 246  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 247  * returned.  It is not wise to check for this value, but rather, check for
 248  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 249  * code.
 250  */
 251 struct dentry *debugfs_create_u64(const char *name, umode_t mode,
 252                                  struct dentry *parent, u64 *value)
 253 {
 254         /* if there are no write bits set, make read only */
 255         if (!(mode & S_IWUGO))
 256                 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
 257         /* if there are no read bits set, make write only */
 258         if (!(mode & S_IRUGO))
 259                 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
 260
 261         return debugfs_create_file(name, mode, parent, value, &fops_u64);
 262 }
 263 EXPORT_SYMBOL_GPL(debugfs_create_u64);
 264
 265 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 266 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 267 DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 268
 269 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
 270 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 271 DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 272
 273 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
 274 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 275 DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 276
 277 DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
 278
 279 /*
 280  * 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
 281  *
 282  * These functions are exactly the same as the above functions (but use a hex
 283  * output for the decimal challenged). For details look at the above unsigned
 284  * decimal functions.
 285  */
 286
 287 /**
 288  * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 289  * @name: a pointer to a string containing the name of the file to create.
 290  * @mode: the permission that the file should have
 291  * @parent: a pointer to the parent dentry for this file.  This should be a
 292  *          directory dentry if set.  If this parameter is %NULL, then the
 293  *          file will be created in the root of the debugfs filesystem.
 294  * @value: a pointer to the variable that the file should read to and write
 295  *         from.
 296  */
 297 struct dentry *debugfs_create_x8(const char *name, umode_t mode,
 298                                  struct dentry *parent, u8 *value)
 299 {
 300         /* if there are no write bits set, make read only */
 301         if (!(mode & S_IWUGO))
 302                 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
 303         /* if there are no read bits set, make write only */
 304         if (!(mode & S_IRUGO))
 305                 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
 306
 307         return debugfs_create_file(name, mode, parent, value, &fops_x8);
 308 }
 309 EXPORT_SYMBOL_GPL(debugfs_create_x8);
 310
 311 /**
 312  * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 313  * @name: a pointer to a string containing the name of the file to create.
 314  * @mode: the permission that the file should have
 315  * @parent: a pointer to the parent dentry for this file.  This should be a
 316  *          directory dentry if set.  If this parameter is %NULL, then the
 317  *          file will be created in the root of the debugfs filesystem.
 318  * @value: a pointer to the variable that the file should read to and write
 319  *         from.
 320  */
 321 struct dentry *debugfs_create_x16(const char *name, umode_t mode,
 322                                  struct dentry *parent, u16 *value)
 323 {
 324         /* if there are no write bits set, make read only */
 325         if (!(mode & S_IWUGO))
 326                 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
 327         /* if there are no read bits set, make write only */
 328         if (!(mode & S_IRUGO))
 329                 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
 330
 331         return debugfs_create_file(name, mode, parent, value, &fops_x16);
 332 }
 333 EXPORT_SYMBOL_GPL(debugfs_create_x16);
 334
 335 /**
 336  * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 337  * @name: a pointer to a string containing the name of the file to create.
 338  * @mode: the permission that the file should have
 339  * @parent: a pointer to the parent dentry for this file.  This should be a
 340  *          directory dentry if set.  If this parameter is %NULL, then the
 341  *          file will be created in the root of the debugfs filesystem.
 342  * @value: a pointer to the variable that the file should read to and write
 343  *         from.
 344  */
 345 struct dentry *debugfs_create_x32(const char *name, umode_t mode,
 346                                  struct dentry *parent, u32 *value)
 347 {
 348         /* if there are no write bits set, make read only */
 349         if (!(mode & S_IWUGO))
 350                 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
 351         /* if there are no read bits set, make write only */
 352         if (!(mode & S_IRUGO))
 353                 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
 354
 355         return debugfs_create_file(name, mode, parent, value, &fops_x32);
 356 }
 357 EXPORT_SYMBOL_GPL(debugfs_create_x32);
 358
 359 /**
 360  * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 361  * @name: a pointer to a string containing the name of the file to create.
 362  * @mode: the permission that the file should have
 363  * @parent: a pointer to the parent dentry for this file.  This should be a
 364  *          directory dentry if set.  If this parameter is %NULL, then the
 365  *          file will be created in the root of the debugfs filesystem.
 366  * @value: a pointer to the variable that the file should read to and write
 367  *         from.
 368  */
 369 struct dentry *debugfs_create_x64(const char *name, umode_t mode,
 370                                  struct dentry *parent, u64 *value)
 371 {
 372         return debugfs_create_file(name, mode, parent, value, &fops_x64);
 373 }
 374 EXPORT_SYMBOL_GPL(debugfs_create_x64);
 375
 376
 377 static int debugfs_size_t_set(void *data, u64 val)
 378 {
 379         *(size_t *)data = val;
 380         return 0;
 381 }
 382 static int debugfs_size_t_get(void *data, u64 *val)
 383 {
 384         *val = *(size_t *)data;
 385         return 0;
 386 }
 387 DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 388                         "%llu\n");      /* %llu and %zu are more or less the same */
 389
 390 /**
 391  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
 392  * @name: a pointer to a string containing the name of the file to create.
 393  * @mode: the permission that the file should have
 394  * @parent: a pointer to the parent dentry for this file.  This should be a
 395  *          directory dentry if set.  If this parameter is %NULL, then the
 396  *          file will be created in the root of the debugfs filesystem.
 397  * @value: a pointer to the variable that the file should read to and write
 398  *         from.
 399  */
 400 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
 401                                      struct dentry *parent, size_t *value)
 402 {
 403         return debugfs_create_file(name, mode, parent, value, &fops_size_t);
 404 }
 405 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 406
 407 static int debugfs_atomic_t_set(void *data, u64 val)
 408 {
 409         atomic_set((atomic_t *)data, val);
 410         return 0;
 411 }
 412 static int debugfs_atomic_t_get(void *data, u64 *val)
 413 {
 414         *val = atomic_read((atomic_t *)data);
 415         return 0;
 416 }
 417 DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
 418                         debugfs_atomic_t_set, "%lld\n");
 419 DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, "%lld\n");
 420 DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
 421
 422 /**
 423  * debugfs_create_atomic_t - create a debugfs file that is used to read and
 424  * write an atomic_t value
 425  * @name: a pointer to a string containing the name of the file to create.
 426  * @mode: the permission that the file should have
 427  * @parent: a pointer to the parent dentry for this file.  This should be a
 428  *          directory dentry if set.  If this parameter is %NULL, then the
 429  *          file will be created in the root of the debugfs filesystem.
 430  * @value: a pointer to the variable that the file should read to and write
 431  *         from.
 432  */
 433 struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
 434                                  struct dentry *parent, atomic_t *value)
 435 {
 436         /* if there are no write bits set, make read only */
 437         if (!(mode & S_IWUGO))
 438                 return debugfs_create_file(name, mode, parent, value,
 439                                         &fops_atomic_t_ro);
 440         /* if there are no read bits set, make write only */
 441         if (!(mode & S_IRUGO))
 442                 return debugfs_create_file(name, mode, parent, value,
 443                                         &fops_atomic_t_wo);
 444
 445         return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
 446 }
 447 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 448
 449 static ssize_t read_file_bool(struct file *file, char __user *user_buf,
 450                               size_t count, loff_t *ppos)
 451 {
 452         char buf[3];
 453         u32 *val = file->private_data;
 454
 455         if (*val)
 456                 buf[0] = 'Y';
 457         else
 458                 buf[0] = 'N';
 459         buf[1] = '\n';
 460         buf[2] = 0x00;
 461         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 462 }
 463
 464 static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
 465                                size_t count, loff_t *ppos)
 466 {
 467         char buf[32];
 468         size_t buf_size;
 469         bool bv;
 470         u32 *val = file->private_data;
 471
 472         buf_size = min(count, (sizeof(buf)-1));
 473         if (copy_from_user(buf, user_buf, buf_size))
 474                 return -EFAULT;
 475
 476         buf[buf_size] = '\0';
 477         if (strtobool(buf, &bv) == 0)
 478                 *val = bv;
 479
 480         return count;
 481 }
 482
 483 static const struct file_operations fops_bool = {
 484         .read =         read_file_bool,
 485         .write =        write_file_bool,
 486         .open =         simple_open,
 487         .llseek =       default_llseek,
 488 };
 489
 490 /**
 491  * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 492  * @name: a pointer to a string containing the name of the file to create.
 493  * @mode: the permission that the file should have
 494  * @parent: a pointer to the parent dentry for this file.  This should be a
 495  *          directory dentry if set.  If this parameter is %NULL, then the
 496  *          file will be created in the root of the debugfs filesystem.
 497  * @value: a pointer to the variable that the file should read to and write
 498  *         from.
 499  *
 500  * This function creates a file in debugfs with the given name that
 501  * contains the value of the variable @value.  If the @mode variable is so
 502  * set, it can be read from, and written to.
 503  *
 504  * This function will return a pointer to a dentry if it succeeds.  This
 505  * pointer must be passed to the debugfs_remove() function when the file is
 506  * to be removed (no automatic cleanup happens if your module is unloaded,
 507  * you are responsible here.)  If an error occurs, %NULL will be returned.
 508  *
 509  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 510  * returned.  It is not wise to check for this value, but rather, check for
 511  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 512  * code.
 513  */
 514 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 515                                    struct dentry *parent, u32 *value)
 516 {
 517         return debugfs_create_file(name, mode, parent, value, &fops_bool);
 518 }
 519 EXPORT_SYMBOL_GPL(debugfs_create_bool);
 520
 521 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 522                               size_t count, loff_t *ppos)
 523 {
 524         struct debugfs_blob_wrapper *blob = file->private_data;
 525         return simple_read_from_buffer(user_buf, count, ppos, blob->data,
 526                         blob->size);
 527 }
 528
 529 static const struct file_operations fops_blob = {
 530         .read =         read_file_blob,
 531         .open =         simple_open,
 532         .llseek =       default_llseek,
 533 };
 534
 535 /**
 536  * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 537  * @name: a pointer to a string containing the name of the file to create.
 538  * @mode: the permission that the file should have
 539  * @parent: a pointer to the parent dentry for this file.  This should be a
 540  *          directory dentry if set.  If this parameter is %NULL, then the
 541  *          file will be created in the root of the debugfs filesystem.
 542  * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 543  *        to the blob data and the size of the data.
 544  *
 545  * This function creates a file in debugfs with the given name that exports
 546  * @blob->data as a binary blob. If the @mode variable is so set it can be
 547  * read from. Writing is not supported.
 548  *
 549  * This function will return a pointer to a dentry if it succeeds.  This
 550  * pointer must be passed to the debugfs_remove() function when the file is
 551  * to be removed (no automatic cleanup happens if your module is unloaded,
 552  * you are responsible here.)  If an error occurs, %NULL will be returned.
 553  *
 554  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 555  * returned.  It is not wise to check for this value, but rather, check for
 556  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 557  * code.
 558  */
 559 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 560                                    struct dentry *parent,
 561                                    struct debugfs_blob_wrapper *blob)
 562 {
 563         return debugfs_create_file(name, mode, parent, blob, &fops_blob);
 564 }
 565 EXPORT_SYMBOL_GPL(debugfs_create_blob);
 566
 567 struct array_data {
 568         void *array;
 569         u32 elements;
 570 };
 571
 572 static size_t u32_format_array(char *buf, size_t bufsize,
 573                                u32 *array, int array_size)
 574 {
 575         size_t ret = 0;
 576
 577         while (--array_size >= 0) {
 578                 size_t len;
 579                 char term = array_size ? ' ' : '\n';
 580
 581                 len = snprintf(buf, bufsize, "%u%c", *array++, term);
 582                 ret += len;
 583
 584                 buf += len;
 585                 bufsize -= len;
 586         }
 587         return ret;
 588 }
 589
 590 static int u32_array_open(struct inode *inode, struct file *file)
 591 {
 592         struct array_data *data = inode->i_private;
 593         int size, elements = data->elements;
 594         char *buf;
 595
 596         /*
 597          * Max size:
 598          *  - 10 digits + ' '/'\n' = 11 bytes per number
 599          *  - terminating NUL character
 600          */
 601         size = elements*11;
 602         buf = kmalloc(size+1, GFP_KERNEL);
 603         if (!buf)
 604                 return -ENOMEM;
 605         buf[size] = 0;
 606
 607         file->private_data = buf;
 608         u32_format_array(buf, size, data->array, data->elements);
 609
 610         return nonseekable_open(inode, file);
 611 }
 612
 613 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
 614                               loff_t *ppos)
 615 {
 616         size_t size = strlen(file->private_data);
 617
 618         return simple_read_from_buffer(buf, len, ppos,
 619                                         file->private_data, size);
 620 }
 621
 622 static int u32_array_release(struct inode *inode, struct file *file)
 623 {
 624         kfree(file->private_data);
 625
 626         return 0;
 627 }
 628
 629 static const struct file_operations u32_array_fops = {
 630         .owner   = THIS_MODULE,
 631         .open    = u32_array_open,
 632         .release = u32_array_release,
 633         .read    = u32_array_read,
 634         .llseek  = no_llseek,
 635 };
 636
 637 /**
 638  * debugfs_create_u32_array - create a debugfs file that is used to read u32
 639  * array.
 640  * @name: a pointer to a string containing the name of the file to create.
 641  * @mode: the permission that the file should have.
 642  * @parent: a pointer to the parent dentry for this file.  This should be a
 643  *          directory dentry if set.  If this parameter is %NULL, then the
 644  *          file will be created in the root of the debugfs filesystem.
 645  * @array: u32 array that provides data.
 646  * @elements: total number of elements in the array.
 647  *
 648  * This function creates a file in debugfs with the given name that exports
 649  * @array as data. If the @mode variable is so set it can be read from.
 650  * Writing is not supported. Seek within the file is also not supported.
 651  * Once array is created its size can not be changed.
 652  *
 653  * The function returns a pointer to dentry on success. If debugfs is not
 654  * enabled in the kernel, the value -%ENODEV will be returned.
 655  */
 656 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
 657                                             struct dentry *parent,
 658                                             u32 *array, u32 elements)
 659 {
 660         struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
 661
 662         if (data == NULL)
 663                 return NULL;
 664
 665         data->array = array;
 666         data->elements = elements;
 667
 668         return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
 669 }
 670 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
 671
 672 #ifdef CONFIG_HAS_IOMEM
 673
 674 /*
 675  * The regset32 stuff is used to print 32-bit registers using the
 676  * seq_file utilities. We offer printing a register set in an already-opened
 677  * sequential file or create a debugfs file that only prints a regset32.
 678  */
 679
 680 /**
 681  * debugfs_print_regs32 - use seq_print to describe a set of registers
 682  * @s: the seq_file structure being used to generate output
 683  * @regs: an array if struct debugfs_reg32 structures
 684  * @nregs: the length of the above array
 685  * @base: the base address to be used in reading the registers
 686  * @prefix: a string to be prefixed to every output line
 687  *
 688  * This function outputs a text block describing the current values of
 689  * some 32-bit hardware registers. It is meant to be used within debugfs
 690  * files based on seq_file that need to show registers, intermixed with other
 691  * information. The prefix argument may be used to specify a leading string,
 692  * because some peripherals have several blocks of identical registers,
 693  * for example configuration of dma channels
 694  */
 695 int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
 696                            int nregs, void __iomem *base, char *prefix)
 697 {
 698         int i, ret = 0;
 699
 700         for (i = 0; i < nregs; i++, regs++) {
 701                 if (prefix)
 702                         ret += seq_printf(s, "%s", prefix);
 703                 ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
 704                                   readl(base + regs->offset));
 705         }
 706         return ret;
 707 }
 708 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
 709
 710 static int debugfs_show_regset32(struct seq_file *s, void *data)
 711 {
 712         struct debugfs_regset32 *regset = s->private;
 713
 714         debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
 715         return 0;
 716 }
 717
 718 static int debugfs_open_regset32(struct inode *inode, struct file *file)
 719 {
 720         return single_open(file, debugfs_show_regset32, inode->i_private);
 721 }
 722
 723 static const struct file_operations fops_regset32 = {
 724         .open =         debugfs_open_regset32,
 725         .read =         seq_read,
 726         .llseek =       seq_lseek,
 727         .release =      single_release,
 728 };
 729
 730 /**
 731  * debugfs_create_regset32 - create a debugfs file that returns register values
 732  * @name: a pointer to a string containing the name of the file to create.
 733  * @mode: the permission that the file should have
 734  * @parent: a pointer to the parent dentry for this file.  This should be a
 735  *          directory dentry if set.  If this parameter is %NULL, then the
 736  *          file will be created in the root of the debugfs filesystem.
 737  * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
 738  *          to an array of register definitions, the array size and the base
 739  *          address where the register bank is to be found.
 740  *
 741  * This function creates a file in debugfs with the given name that reports
 742  * the names and values of a set of 32-bit registers. If the @mode variable
 743  * is so set it can be read from. Writing is not supported.
 744  *
 745  * This function will return a pointer to a dentry if it succeeds.  This
 746  * pointer must be passed to the debugfs_remove() function when the file is
 747  * to be removed (no automatic cleanup happens if your module is unloaded,
 748  * you are responsible here.)  If an error occurs, %NULL will be returned.
 749  *
 750  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 751  * returned.  It is not wise to check for this value, but rather, check for
 752  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 753  * code.
 754  */
 755 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
 756                                        struct dentry *parent,
 757                                        struct debugfs_regset32 *regset)
 758 {
 759         return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
 760 }
 761 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
 762
 763 #endif /* CONFIG_HAS_IOMEM */