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