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