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