1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * file.c - part of debugfs, a tiny little debug file system 4 * 5 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com> 6 * Copyright (C) 2004 IBM Inc. 7 * 8 * debugfs is for people to use instead of /proc or /sys. 9 * See Documentation/filesystems/ for more details. 10 */ 11 12 #include <linux/module.h> 13 #include <linux/fs.h> 14 #include <linux/seq_file.h> 15 #include <linux/pagemap.h> 16 #include <linux/debugfs.h> 17 #include <linux/io.h> 18 #include <linux/slab.h> 19 #include <linux/atomic.h> 20 #include <linux/device.h> 21 #include <linux/poll.h> 22 #include <linux/security.h> 23 24 #include "internal.h" 25 26 struct poll_table_struct; 27 28 static ssize_t default_read_file(struct file *file, char __user *buf, 29 size_t count, loff_t *ppos) 30 { 31 return 0; 32 } 33 34 static ssize_t default_write_file(struct file *file, const char __user *buf, 35 size_t count, loff_t *ppos) 36 { 37 return count; 38 } 39 40 const struct file_operations debugfs_noop_file_operations = { 41 .read = default_read_file, 42 .write = default_write_file, 43 .open = simple_open, 44 .llseek = noop_llseek, 45 }; 46 47 #define F_DENTRY(filp) ((filp)->f_path.dentry) 48 49 const struct file_operations *debugfs_real_fops(const struct file *filp) 50 { 51 struct debugfs_fsdata *fsd = F_DENTRY(filp)->d_fsdata; 52 53 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT) { 54 /* 55 * Urgh, we've been called w/o a protecting 56 * debugfs_file_get(). 57 */ 58 WARN_ON(1); 59 return NULL; 60 } 61 62 return fsd->real_fops; 63 } 64 EXPORT_SYMBOL_GPL(debugfs_real_fops); 65 66 /** 67 * debugfs_file_get - mark the beginning of file data access 68 * @dentry: the dentry object whose data is being accessed. 69 * 70 * Up to a matching call to debugfs_file_put(), any successive call 71 * into the file removing functions debugfs_remove() and 72 * debugfs_remove_recursive() will block. Since associated private 73 * file data may only get freed after a successful return of any of 74 * the removal functions, you may safely access it after a successful 75 * call to debugfs_file_get() without worrying about lifetime issues. 76 * 77 * If -%EIO is returned, the file has already been removed and thus, 78 * it is not safe to access any of its data. If, on the other hand, 79 * it is allowed to access the file data, zero is returned. 80 */ 81 int debugfs_file_get(struct dentry *dentry) 82 { 83 struct debugfs_fsdata *fsd; 84 void *d_fsd; 85 86 d_fsd = READ_ONCE(dentry->d_fsdata); 87 if (!((unsigned long)d_fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)) { 88 fsd = d_fsd; 89 } else { 90 fsd = kmalloc(sizeof(*fsd), GFP_KERNEL); 91 if (!fsd) 92 return -ENOMEM; 93 94 fsd->real_fops = (void *)((unsigned long)d_fsd & 95 ~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT); 96 refcount_set(&fsd->active_users, 1); 97 init_completion(&fsd->active_users_drained); 98 if (cmpxchg(&dentry->d_fsdata, d_fsd, fsd) != d_fsd) { 99 kfree(fsd); 100 fsd = READ_ONCE(dentry->d_fsdata); 101 } 102 } 103 104 /* 105 * In case of a successful cmpxchg() above, this check is 106 * strictly necessary and must follow it, see the comment in 107 * __debugfs_remove_file(). 108 * OTOH, if the cmpxchg() hasn't been executed or wasn't 109 * successful, this serves the purpose of not starving 110 * removers. 111 */ 112 if (d_unlinked(dentry)) 113 return -EIO; 114 115 if (!refcount_inc_not_zero(&fsd->active_users)) 116 return -EIO; 117 118 return 0; 119 } 120 EXPORT_SYMBOL_GPL(debugfs_file_get); 121 122 /** 123 * debugfs_file_put - mark the end of file data access 124 * @dentry: the dentry object formerly passed to 125 * debugfs_file_get(). 126 * 127 * Allow any ongoing concurrent call into debugfs_remove() or 128 * debugfs_remove_recursive() blocked by a former call to 129 * debugfs_file_get() to proceed and return to its caller. 130 */ 131 void debugfs_file_put(struct dentry *dentry) 132 { 133 struct debugfs_fsdata *fsd = READ_ONCE(dentry->d_fsdata); 134 135 if (refcount_dec_and_test(&fsd->active_users)) 136 complete(&fsd->active_users_drained); 137 } 138 EXPORT_SYMBOL_GPL(debugfs_file_put); 139 140 /* 141 * Only permit access to world-readable files when the kernel is locked down. 142 * We also need to exclude any file that has ways to write or alter it as root 143 * can bypass the permissions check. 144 */ 145 static bool debugfs_is_locked_down(struct inode *inode, 146 struct file *filp, 147 const struct file_operations *real_fops) 148 { 149 if ((inode->i_mode & 07777) == 0444 && 150 !(filp->f_mode & FMODE_WRITE) && 151 !real_fops->unlocked_ioctl && 152 !real_fops->compat_ioctl && 153 !real_fops->mmap) 154 return false; 155 156 return security_locked_down(LOCKDOWN_DEBUGFS); 157 } 158 159 static int open_proxy_open(struct inode *inode, struct file *filp) 160 { 161 struct dentry *dentry = F_DENTRY(filp); 162 const struct file_operations *real_fops = NULL; 163 int r; 164 165 r = debugfs_file_get(dentry); 166 if (r) 167 return r == -EIO ? -ENOENT : r; 168 169 real_fops = debugfs_real_fops(filp); 170 171 r = debugfs_is_locked_down(inode, filp, real_fops); 172 if (r) 173 goto out; 174 175 real_fops = fops_get(real_fops); 176 if (!real_fops) { 177 /* Huh? Module did not clean up after itself at exit? */ 178 WARN(1, "debugfs file owner did not clean up at exit: %pd", 179 dentry); 180 r = -ENXIO; 181 goto out; 182 } 183 replace_fops(filp, real_fops); 184 185 if (real_fops->open) 186 r = real_fops->open(inode, filp); 187 188 out: 189 debugfs_file_put(dentry); 190 return r; 191 } 192 193 const struct file_operations debugfs_open_proxy_file_operations = { 194 .open = open_proxy_open, 195 }; 196 197 #define PROTO(args...) args 198 #define ARGS(args...) args 199 200 #define FULL_PROXY_FUNC(name, ret_type, filp, proto, args) \ 201 static ret_type full_proxy_ ## name(proto) \ 202 { \ 203 struct dentry *dentry = F_DENTRY(filp); \ 204 const struct file_operations *real_fops; \ 205 ret_type r; \ 206 \ 207 r = debugfs_file_get(dentry); \ 208 if (unlikely(r)) \ 209 return r; \ 210 real_fops = debugfs_real_fops(filp); \ 211 r = real_fops->name(args); \ 212 debugfs_file_put(dentry); \ 213 return r; \ 214 } 215 216 FULL_PROXY_FUNC(llseek, loff_t, filp, 217 PROTO(struct file *filp, loff_t offset, int whence), 218 ARGS(filp, offset, whence)); 219 220 FULL_PROXY_FUNC(read, ssize_t, filp, 221 PROTO(struct file *filp, char __user *buf, size_t size, 222 loff_t *ppos), 223 ARGS(filp, buf, size, ppos)); 224 225 FULL_PROXY_FUNC(write, ssize_t, filp, 226 PROTO(struct file *filp, const char __user *buf, size_t size, 227 loff_t *ppos), 228 ARGS(filp, buf, size, ppos)); 229 230 FULL_PROXY_FUNC(unlocked_ioctl, long, filp, 231 PROTO(struct file *filp, unsigned int cmd, unsigned long arg), 232 ARGS(filp, cmd, arg)); 233 234 static __poll_t full_proxy_poll(struct file *filp, 235 struct poll_table_struct *wait) 236 { 237 struct dentry *dentry = F_DENTRY(filp); 238 __poll_t r = 0; 239 const struct file_operations *real_fops; 240 241 if (debugfs_file_get(dentry)) 242 return EPOLLHUP; 243 244 real_fops = debugfs_real_fops(filp); 245 r = real_fops->poll(filp, wait); 246 debugfs_file_put(dentry); 247 return r; 248 } 249 250 static int full_proxy_release(struct inode *inode, struct file *filp) 251 { 252 const struct dentry *dentry = F_DENTRY(filp); 253 const struct file_operations *real_fops = debugfs_real_fops(filp); 254 const struct file_operations *proxy_fops = filp->f_op; 255 int r = 0; 256 257 /* 258 * We must not protect this against removal races here: the 259 * original releaser should be called unconditionally in order 260 * not to leak any resources. Releasers must not assume that 261 * ->i_private is still being meaningful here. 262 */ 263 if (real_fops->release) 264 r = real_fops->release(inode, filp); 265 266 replace_fops(filp, d_inode(dentry)->i_fop); 267 kfree((void *)proxy_fops); 268 fops_put(real_fops); 269 return r; 270 } 271 272 static void __full_proxy_fops_init(struct file_operations *proxy_fops, 273 const struct file_operations *real_fops) 274 { 275 proxy_fops->release = full_proxy_release; 276 if (real_fops->llseek) 277 proxy_fops->llseek = full_proxy_llseek; 278 if (real_fops->read) 279 proxy_fops->read = full_proxy_read; 280 if (real_fops->write) 281 proxy_fops->write = full_proxy_write; 282 if (real_fops->poll) 283 proxy_fops->poll = full_proxy_poll; 284 if (real_fops->unlocked_ioctl) 285 proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl; 286 } 287 288 static int full_proxy_open(struct inode *inode, struct file *filp) 289 { 290 struct dentry *dentry = F_DENTRY(filp); 291 const struct file_operations *real_fops = NULL; 292 struct file_operations *proxy_fops = NULL; 293 int r; 294 295 r = debugfs_file_get(dentry); 296 if (r) 297 return r == -EIO ? -ENOENT : r; 298 299 real_fops = debugfs_real_fops(filp); 300 301 r = debugfs_is_locked_down(inode, filp, real_fops); 302 if (r) 303 goto out; 304 305 real_fops = fops_get(real_fops); 306 if (!real_fops) { 307 /* Huh? Module did not cleanup after itself at exit? */ 308 WARN(1, "debugfs file owner did not clean up at exit: %pd", 309 dentry); 310 r = -ENXIO; 311 goto out; 312 } 313 314 proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL); 315 if (!proxy_fops) { 316 r = -ENOMEM; 317 goto free_proxy; 318 } 319 __full_proxy_fops_init(proxy_fops, real_fops); 320 replace_fops(filp, proxy_fops); 321 322 if (real_fops->open) { 323 r = real_fops->open(inode, filp); 324 if (r) { 325 replace_fops(filp, d_inode(dentry)->i_fop); 326 goto free_proxy; 327 } else if (filp->f_op != proxy_fops) { 328 /* No protection against file removal anymore. */ 329 WARN(1, "debugfs file owner replaced proxy fops: %pd", 330 dentry); 331 goto free_proxy; 332 } 333 } 334 335 goto out; 336 free_proxy: 337 kfree(proxy_fops); 338 fops_put(real_fops); 339 out: 340 debugfs_file_put(dentry); 341 return r; 342 } 343 344 const struct file_operations debugfs_full_proxy_file_operations = { 345 .open = full_proxy_open, 346 }; 347 348 ssize_t debugfs_attr_read(struct file *file, char __user *buf, 349 size_t len, loff_t *ppos) 350 { 351 struct dentry *dentry = F_DENTRY(file); 352 ssize_t ret; 353 354 ret = debugfs_file_get(dentry); 355 if (unlikely(ret)) 356 return ret; 357 ret = simple_attr_read(file, buf, len, ppos); 358 debugfs_file_put(dentry); 359 return ret; 360 } 361 EXPORT_SYMBOL_GPL(debugfs_attr_read); 362 363 ssize_t debugfs_attr_write(struct file *file, const char __user *buf, 364 size_t len, loff_t *ppos) 365 { 366 struct dentry *dentry = F_DENTRY(file); 367 ssize_t ret; 368 369 ret = debugfs_file_get(dentry); 370 if (unlikely(ret)) 371 return ret; 372 ret = simple_attr_write(file, buf, len, ppos); 373 debugfs_file_put(dentry); 374 return ret; 375 } 376 EXPORT_SYMBOL_GPL(debugfs_attr_write); 377 378 static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode, 379 struct dentry *parent, void *value, 380 const struct file_operations *fops, 381 const struct file_operations *fops_ro, 382 const struct file_operations *fops_wo) 383 { 384 /* if there are no write bits set, make read only */ 385 if (!(mode & S_IWUGO)) 386 return debugfs_create_file_unsafe(name, mode, parent, value, 387 fops_ro); 388 /* if there are no read bits set, make write only */ 389 if (!(mode & S_IRUGO)) 390 return debugfs_create_file_unsafe(name, mode, parent, value, 391 fops_wo); 392 393 return debugfs_create_file_unsafe(name, mode, parent, value, fops); 394 } 395 396 static int debugfs_u8_set(void *data, u64 val) 397 { 398 *(u8 *)data = val; 399 return 0; 400 } 401 static int debugfs_u8_get(void *data, u64 *val) 402 { 403 *val = *(u8 *)data; 404 return 0; 405 } 406 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n"); 407 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n"); 408 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n"); 409 410 /** 411 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value 412 * @name: a pointer to a string containing the name of the file to create. 413 * @mode: the permission that the file should have 414 * @parent: a pointer to the parent dentry for this file. This should be a 415 * directory dentry if set. If this parameter is %NULL, then the 416 * file will be created in the root of the debugfs filesystem. 417 * @value: a pointer to the variable that the file should read to and write 418 * from. 419 * 420 * This function creates a file in debugfs with the given name that 421 * contains the value of the variable @value. If the @mode variable is so 422 * set, it can be read from, and written to. 423 */ 424 void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent, 425 u8 *value) 426 { 427 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8, 428 &fops_u8_ro, &fops_u8_wo); 429 } 430 EXPORT_SYMBOL_GPL(debugfs_create_u8); 431 432 static int debugfs_u16_set(void *data, u64 val) 433 { 434 *(u16 *)data = val; 435 return 0; 436 } 437 static int debugfs_u16_get(void *data, u64 *val) 438 { 439 *val = *(u16 *)data; 440 return 0; 441 } 442 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n"); 443 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n"); 444 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n"); 445 446 /** 447 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value 448 * @name: a pointer to a string containing the name of the file to create. 449 * @mode: the permission that the file should have 450 * @parent: a pointer to the parent dentry for this file. This should be a 451 * directory dentry if set. If this parameter is %NULL, then the 452 * file will be created in the root of the debugfs filesystem. 453 * @value: a pointer to the variable that the file should read to and write 454 * from. 455 * 456 * This function creates a file in debugfs with the given name that 457 * contains the value of the variable @value. If the @mode variable is so 458 * set, it can be read from, and written to. 459 */ 460 void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent, 461 u16 *value) 462 { 463 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16, 464 &fops_u16_ro, &fops_u16_wo); 465 } 466 EXPORT_SYMBOL_GPL(debugfs_create_u16); 467 468 static int debugfs_u32_set(void *data, u64 val) 469 { 470 *(u32 *)data = val; 471 return 0; 472 } 473 static int debugfs_u32_get(void *data, u64 *val) 474 { 475 *val = *(u32 *)data; 476 return 0; 477 } 478 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n"); 479 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n"); 480 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n"); 481 482 /** 483 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value 484 * @name: a pointer to a string containing the name of the file to create. 485 * @mode: the permission that the file should have 486 * @parent: a pointer to the parent dentry for this file. This should be a 487 * directory dentry if set. If this parameter is %NULL, then the 488 * file will be created in the root of the debugfs filesystem. 489 * @value: a pointer to the variable that the file should read to and write 490 * from. 491 * 492 * This function creates a file in debugfs with the given name that 493 * contains the value of the variable @value. If the @mode variable is so 494 * set, it can be read from, and written to. 495 * 496 * This function will return a pointer to a dentry if it succeeds. This 497 * pointer must be passed to the debugfs_remove() function when the file is 498 * to be removed (no automatic cleanup happens if your module is unloaded, 499 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be 500 * returned. 501 * 502 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will 503 * be returned. 504 */ 505 struct dentry *debugfs_create_u32(const char *name, umode_t mode, 506 struct dentry *parent, u32 *value) 507 { 508 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32, 509 &fops_u32_ro, &fops_u32_wo); 510 } 511 EXPORT_SYMBOL_GPL(debugfs_create_u32); 512 513 static int debugfs_u64_set(void *data, u64 val) 514 { 515 *(u64 *)data = val; 516 return 0; 517 } 518 519 static int debugfs_u64_get(void *data, u64 *val) 520 { 521 *val = *(u64 *)data; 522 return 0; 523 } 524 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n"); 525 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n"); 526 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n"); 527 528 /** 529 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value 530 * @name: a pointer to a string containing the name of the file to create. 531 * @mode: the permission that the file should have 532 * @parent: a pointer to the parent dentry for this file. This should be a 533 * directory dentry if set. If this parameter is %NULL, then the 534 * file will be created in the root of the debugfs filesystem. 535 * @value: a pointer to the variable that the file should read to and write 536 * from. 537 * 538 * This function creates a file in debugfs with the given name that 539 * contains the value of the variable @value. If the @mode variable is so 540 * set, it can be read from, and written to. 541 */ 542 void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent, 543 u64 *value) 544 { 545 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64, 546 &fops_u64_ro, &fops_u64_wo); 547 } 548 EXPORT_SYMBOL_GPL(debugfs_create_u64); 549 550 static int debugfs_ulong_set(void *data, u64 val) 551 { 552 *(unsigned long *)data = val; 553 return 0; 554 } 555 556 static int debugfs_ulong_get(void *data, u64 *val) 557 { 558 *val = *(unsigned long *)data; 559 return 0; 560 } 561 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set, 562 "%llu\n"); 563 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n"); 564 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n"); 565 566 /** 567 * debugfs_create_ulong - create a debugfs file that is used to read and write 568 * an unsigned long value. 569 * @name: a pointer to a string containing the name of the file to create. 570 * @mode: the permission that the file should have 571 * @parent: a pointer to the parent dentry for this file. This should be a 572 * directory dentry if set. If this parameter is %NULL, then the 573 * file will be created in the root of the debugfs filesystem. 574 * @value: a pointer to the variable that the file should read to and write 575 * from. 576 * 577 * This function creates a file in debugfs with the given name that 578 * contains the value of the variable @value. If the @mode variable is so 579 * set, it can be read from, and written to. 580 * 581 * This function will return a pointer to a dentry if it succeeds. This 582 * pointer must be passed to the debugfs_remove() function when the file is 583 * to be removed (no automatic cleanup happens if your module is unloaded, 584 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be 585 * returned. 586 * 587 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will 588 * be returned. 589 */ 590 struct dentry *debugfs_create_ulong(const char *name, umode_t mode, 591 struct dentry *parent, unsigned long *value) 592 { 593 return debugfs_create_mode_unsafe(name, mode, parent, value, 594 &fops_ulong, &fops_ulong_ro, 595 &fops_ulong_wo); 596 } 597 EXPORT_SYMBOL_GPL(debugfs_create_ulong); 598 599 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n"); 600 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n"); 601 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n"); 602 603 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, 604 "0x%04llx\n"); 605 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n"); 606 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n"); 607 608 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, 609 "0x%08llx\n"); 610 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n"); 611 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n"); 612 613 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, 614 "0x%016llx\n"); 615 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n"); 616 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n"); 617 618 /* 619 * 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 620 * 621 * These functions are exactly the same as the above functions (but use a hex 622 * output for the decimal challenged). For details look at the above unsigned 623 * decimal functions. 624 */ 625 626 /** 627 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value 628 * @name: a pointer to a string containing the name of the file to create. 629 * @mode: the permission that the file should have 630 * @parent: a pointer to the parent dentry for this file. This should be a 631 * directory dentry if set. If this parameter is %NULL, then the 632 * file will be created in the root of the debugfs filesystem. 633 * @value: a pointer to the variable that the file should read to and write 634 * from. 635 */ 636 struct dentry *debugfs_create_x8(const char *name, umode_t mode, 637 struct dentry *parent, u8 *value) 638 { 639 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8, 640 &fops_x8_ro, &fops_x8_wo); 641 } 642 EXPORT_SYMBOL_GPL(debugfs_create_x8); 643 644 /** 645 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value 646 * @name: a pointer to a string containing the name of the file to create. 647 * @mode: the permission that the file should have 648 * @parent: a pointer to the parent dentry for this file. This should be a 649 * directory dentry if set. If this parameter is %NULL, then the 650 * file will be created in the root of the debugfs filesystem. 651 * @value: a pointer to the variable that the file should read to and write 652 * from. 653 */ 654 struct dentry *debugfs_create_x16(const char *name, umode_t mode, 655 struct dentry *parent, u16 *value) 656 { 657 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16, 658 &fops_x16_ro, &fops_x16_wo); 659 } 660 EXPORT_SYMBOL_GPL(debugfs_create_x16); 661 662 /** 663 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value 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 * @value: a pointer to the variable that the file should read to and write 670 * from. 671 */ 672 struct dentry *debugfs_create_x32(const char *name, umode_t mode, 673 struct dentry *parent, u32 *value) 674 { 675 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32, 676 &fops_x32_ro, &fops_x32_wo); 677 } 678 EXPORT_SYMBOL_GPL(debugfs_create_x32); 679 680 /** 681 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value 682 * @name: a pointer to a string containing the name of the file to create. 683 * @mode: the permission that the file should have 684 * @parent: a pointer to the parent dentry for this file. This should be a 685 * directory dentry if set. If this parameter is %NULL, then the 686 * file will be created in the root of the debugfs filesystem. 687 * @value: a pointer to the variable that the file should read to and write 688 * from. 689 */ 690 struct dentry *debugfs_create_x64(const char *name, umode_t mode, 691 struct dentry *parent, u64 *value) 692 { 693 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64, 694 &fops_x64_ro, &fops_x64_wo); 695 } 696 EXPORT_SYMBOL_GPL(debugfs_create_x64); 697 698 699 static int debugfs_size_t_set(void *data, u64 val) 700 { 701 *(size_t *)data = val; 702 return 0; 703 } 704 static int debugfs_size_t_get(void *data, u64 *val) 705 { 706 *val = *(size_t *)data; 707 return 0; 708 } 709 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set, 710 "%llu\n"); /* %llu and %zu are more or less the same */ 711 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n"); 712 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n"); 713 714 /** 715 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value 716 * @name: a pointer to a string containing the name of the file to create. 717 * @mode: the permission that the file should have 718 * @parent: a pointer to the parent dentry for this file. This should be a 719 * directory dentry if set. If this parameter is %NULL, then the 720 * file will be created in the root of the debugfs filesystem. 721 * @value: a pointer to the variable that the file should read to and write 722 * from. 723 */ 724 struct dentry *debugfs_create_size_t(const char *name, umode_t mode, 725 struct dentry *parent, size_t *value) 726 { 727 return debugfs_create_mode_unsafe(name, mode, parent, value, 728 &fops_size_t, &fops_size_t_ro, 729 &fops_size_t_wo); 730 } 731 EXPORT_SYMBOL_GPL(debugfs_create_size_t); 732 733 static int debugfs_atomic_t_set(void *data, u64 val) 734 { 735 atomic_set((atomic_t *)data, val); 736 return 0; 737 } 738 static int debugfs_atomic_t_get(void *data, u64 *val) 739 { 740 *val = atomic_read((atomic_t *)data); 741 return 0; 742 } 743 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get, 744 debugfs_atomic_t_set, "%lld\n"); 745 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, 746 "%lld\n"); 747 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, 748 "%lld\n"); 749 750 /** 751 * debugfs_create_atomic_t - create a debugfs file that is used to read and 752 * write an atomic_t value 753 * @name: a pointer to a string containing the name of the file to create. 754 * @mode: the permission that the file should have 755 * @parent: a pointer to the parent dentry for this file. This should be a 756 * directory dentry if set. If this parameter is %NULL, then the 757 * file will be created in the root of the debugfs filesystem. 758 * @value: a pointer to the variable that the file should read to and write 759 * from. 760 */ 761 struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode, 762 struct dentry *parent, atomic_t *value) 763 { 764 return debugfs_create_mode_unsafe(name, mode, parent, value, 765 &fops_atomic_t, &fops_atomic_t_ro, 766 &fops_atomic_t_wo); 767 } 768 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t); 769 770 ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf, 771 size_t count, loff_t *ppos) 772 { 773 char buf[3]; 774 bool val; 775 int r; 776 struct dentry *dentry = F_DENTRY(file); 777 778 r = debugfs_file_get(dentry); 779 if (unlikely(r)) 780 return r; 781 val = *(bool *)file->private_data; 782 debugfs_file_put(dentry); 783 784 if (val) 785 buf[0] = 'Y'; 786 else 787 buf[0] = 'N'; 788 buf[1] = '\n'; 789 buf[2] = 0x00; 790 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 791 } 792 EXPORT_SYMBOL_GPL(debugfs_read_file_bool); 793 794 ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf, 795 size_t count, loff_t *ppos) 796 { 797 bool bv; 798 int r; 799 bool *val = file->private_data; 800 struct dentry *dentry = F_DENTRY(file); 801 802 r = kstrtobool_from_user(user_buf, count, &bv); 803 if (!r) { 804 r = debugfs_file_get(dentry); 805 if (unlikely(r)) 806 return r; 807 *val = bv; 808 debugfs_file_put(dentry); 809 } 810 811 return count; 812 } 813 EXPORT_SYMBOL_GPL(debugfs_write_file_bool); 814 815 static const struct file_operations fops_bool = { 816 .read = debugfs_read_file_bool, 817 .write = debugfs_write_file_bool, 818 .open = simple_open, 819 .llseek = default_llseek, 820 }; 821 822 static const struct file_operations fops_bool_ro = { 823 .read = debugfs_read_file_bool, 824 .open = simple_open, 825 .llseek = default_llseek, 826 }; 827 828 static const struct file_operations fops_bool_wo = { 829 .write = debugfs_write_file_bool, 830 .open = simple_open, 831 .llseek = default_llseek, 832 }; 833 834 /** 835 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value 836 * @name: a pointer to a string containing the name of the file to create. 837 * @mode: the permission that the file should have 838 * @parent: a pointer to the parent dentry for this file. This should be a 839 * directory dentry if set. If this parameter is %NULL, then the 840 * file will be created in the root of the debugfs filesystem. 841 * @value: a pointer to the variable that the file should read to and write 842 * from. 843 * 844 * This function creates a file in debugfs with the given name that 845 * contains the value of the variable @value. If the @mode variable is so 846 * set, it can be read from, and written to. 847 * 848 * This function will return a pointer to a dentry if it succeeds. This 849 * pointer must be passed to the debugfs_remove() function when the file is 850 * to be removed (no automatic cleanup happens if your module is unloaded, 851 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be 852 * returned. 853 * 854 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will 855 * be returned. 856 */ 857 struct dentry *debugfs_create_bool(const char *name, umode_t mode, 858 struct dentry *parent, bool *value) 859 { 860 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool, 861 &fops_bool_ro, &fops_bool_wo); 862 } 863 EXPORT_SYMBOL_GPL(debugfs_create_bool); 864 865 static ssize_t read_file_blob(struct file *file, char __user *user_buf, 866 size_t count, loff_t *ppos) 867 { 868 struct debugfs_blob_wrapper *blob = file->private_data; 869 struct dentry *dentry = F_DENTRY(file); 870 ssize_t r; 871 872 r = debugfs_file_get(dentry); 873 if (unlikely(r)) 874 return r; 875 r = simple_read_from_buffer(user_buf, count, ppos, blob->data, 876 blob->size); 877 debugfs_file_put(dentry); 878 return r; 879 } 880 881 static const struct file_operations fops_blob = { 882 .read = read_file_blob, 883 .open = simple_open, 884 .llseek = default_llseek, 885 }; 886 887 /** 888 * debugfs_create_blob - create a debugfs file that is used to read a binary blob 889 * @name: a pointer to a string containing the name of the file to create. 890 * @mode: the permission that the file should have 891 * @parent: a pointer to the parent dentry for this file. This should be a 892 * directory dentry if set. If this parameter is %NULL, then the 893 * file will be created in the root of the debugfs filesystem. 894 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer 895 * to the blob data and the size of the data. 896 * 897 * This function creates a file in debugfs with the given name that exports 898 * @blob->data as a binary blob. If the @mode variable is so set it can be 899 * read from. Writing is not supported. 900 * 901 * This function will return a pointer to a dentry if it succeeds. This 902 * pointer must be passed to the debugfs_remove() function when the file is 903 * to be removed (no automatic cleanup happens if your module is unloaded, 904 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be 905 * returned. 906 * 907 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will 908 * be returned. 909 */ 910 struct dentry *debugfs_create_blob(const char *name, umode_t mode, 911 struct dentry *parent, 912 struct debugfs_blob_wrapper *blob) 913 { 914 return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob); 915 } 916 EXPORT_SYMBOL_GPL(debugfs_create_blob); 917 918 struct array_data { 919 void *array; 920 u32 elements; 921 }; 922 923 static size_t u32_format_array(char *buf, size_t bufsize, 924 u32 *array, int array_size) 925 { 926 size_t ret = 0; 927 928 while (--array_size >= 0) { 929 size_t len; 930 char term = array_size ? ' ' : '\n'; 931 932 len = snprintf(buf, bufsize, "%u%c", *array++, term); 933 ret += len; 934 935 buf += len; 936 bufsize -= len; 937 } 938 return ret; 939 } 940 941 static int u32_array_open(struct inode *inode, struct file *file) 942 { 943 struct array_data *data = inode->i_private; 944 int size, elements = data->elements; 945 char *buf; 946 947 /* 948 * Max size: 949 * - 10 digits + ' '/'\n' = 11 bytes per number 950 * - terminating NUL character 951 */ 952 size = elements*11; 953 buf = kmalloc(size+1, GFP_KERNEL); 954 if (!buf) 955 return -ENOMEM; 956 buf[size] = 0; 957 958 file->private_data = buf; 959 u32_format_array(buf, size, data->array, data->elements); 960 961 return nonseekable_open(inode, file); 962 } 963 964 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len, 965 loff_t *ppos) 966 { 967 size_t size = strlen(file->private_data); 968 969 return simple_read_from_buffer(buf, len, ppos, 970 file->private_data, size); 971 } 972 973 static int u32_array_release(struct inode *inode, struct file *file) 974 { 975 kfree(file->private_data); 976 977 return 0; 978 } 979 980 static const struct file_operations u32_array_fops = { 981 .owner = THIS_MODULE, 982 .open = u32_array_open, 983 .release = u32_array_release, 984 .read = u32_array_read, 985 .llseek = no_llseek, 986 }; 987 988 /** 989 * debugfs_create_u32_array - create a debugfs file that is used to read u32 990 * array. 991 * @name: a pointer to a string containing the name of the file to create. 992 * @mode: the permission that the file should have. 993 * @parent: a pointer to the parent dentry for this file. This should be a 994 * directory dentry if set. If this parameter is %NULL, then the 995 * file will be created in the root of the debugfs filesystem. 996 * @array: u32 array that provides data. 997 * @elements: total number of elements in the array. 998 * 999 * This function creates a file in debugfs with the given name that exports 1000 * @array as data. If the @mode variable is so set it can be read from. 1001 * Writing is not supported. Seek within the file is also not supported. 1002 * Once array is created its size can not be changed. 1003 */ 1004 void debugfs_create_u32_array(const char *name, umode_t mode, 1005 struct dentry *parent, u32 *array, u32 elements) 1006 { 1007 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL); 1008 1009 if (data == NULL) 1010 return; 1011 1012 data->array = array; 1013 data->elements = elements; 1014 1015 debugfs_create_file_unsafe(name, mode, parent, data, &u32_array_fops); 1016 } 1017 EXPORT_SYMBOL_GPL(debugfs_create_u32_array); 1018 1019 #ifdef CONFIG_HAS_IOMEM 1020 1021 /* 1022 * The regset32 stuff is used to print 32-bit registers using the 1023 * seq_file utilities. We offer printing a register set in an already-opened 1024 * sequential file or create a debugfs file that only prints a regset32. 1025 */ 1026 1027 /** 1028 * debugfs_print_regs32 - use seq_print to describe a set of registers 1029 * @s: the seq_file structure being used to generate output 1030 * @regs: an array if struct debugfs_reg32 structures 1031 * @nregs: the length of the above array 1032 * @base: the base address to be used in reading the registers 1033 * @prefix: a string to be prefixed to every output line 1034 * 1035 * This function outputs a text block describing the current values of 1036 * some 32-bit hardware registers. It is meant to be used within debugfs 1037 * files based on seq_file that need to show registers, intermixed with other 1038 * information. The prefix argument may be used to specify a leading string, 1039 * because some peripherals have several blocks of identical registers, 1040 * for example configuration of dma channels 1041 */ 1042 void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs, 1043 int nregs, void __iomem *base, char *prefix) 1044 { 1045 int i; 1046 1047 for (i = 0; i < nregs; i++, regs++) { 1048 if (prefix) 1049 seq_printf(s, "%s", prefix); 1050 seq_printf(s, "%s = 0x%08x\n", regs->name, 1051 readl(base + regs->offset)); 1052 if (seq_has_overflowed(s)) 1053 break; 1054 } 1055 } 1056 EXPORT_SYMBOL_GPL(debugfs_print_regs32); 1057 1058 static int debugfs_show_regset32(struct seq_file *s, void *data) 1059 { 1060 struct debugfs_regset32 *regset = s->private; 1061 1062 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, ""); 1063 return 0; 1064 } 1065 1066 static int debugfs_open_regset32(struct inode *inode, struct file *file) 1067 { 1068 return single_open(file, debugfs_show_regset32, inode->i_private); 1069 } 1070 1071 static const struct file_operations fops_regset32 = { 1072 .open = debugfs_open_regset32, 1073 .read = seq_read, 1074 .llseek = seq_lseek, 1075 .release = single_release, 1076 }; 1077 1078 /** 1079 * debugfs_create_regset32 - create a debugfs file that returns register values 1080 * @name: a pointer to a string containing the name of the file to create. 1081 * @mode: the permission that the file should have 1082 * @parent: a pointer to the parent dentry for this file. This should be a 1083 * directory dentry if set. If this parameter is %NULL, then the 1084 * file will be created in the root of the debugfs filesystem. 1085 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer 1086 * to an array of register definitions, the array size and the base 1087 * address where the register bank is to be found. 1088 * 1089 * This function creates a file in debugfs with the given name that reports 1090 * the names and values of a set of 32-bit registers. If the @mode variable 1091 * is so set it can be read from. Writing is not supported. 1092 * 1093 * This function will return a pointer to a dentry if it succeeds. This 1094 * pointer must be passed to the debugfs_remove() function when the file is 1095 * to be removed (no automatic cleanup happens if your module is unloaded, 1096 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be 1097 * returned. 1098 * 1099 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will 1100 * be returned. 1101 */ 1102 struct dentry *debugfs_create_regset32(const char *name, umode_t mode, 1103 struct dentry *parent, 1104 struct debugfs_regset32 *regset) 1105 { 1106 return debugfs_create_file(name, mode, parent, regset, &fops_regset32); 1107 } 1108 EXPORT_SYMBOL_GPL(debugfs_create_regset32); 1109 1110 #endif /* CONFIG_HAS_IOMEM */ 1111 1112 struct debugfs_devm_entry { 1113 int (*read)(struct seq_file *seq, void *data); 1114 struct device *dev; 1115 }; 1116 1117 static int debugfs_devm_entry_open(struct inode *inode, struct file *f) 1118 { 1119 struct debugfs_devm_entry *entry = inode->i_private; 1120 1121 return single_open(f, entry->read, entry->dev); 1122 } 1123 1124 static const struct file_operations debugfs_devm_entry_ops = { 1125 .owner = THIS_MODULE, 1126 .open = debugfs_devm_entry_open, 1127 .release = single_release, 1128 .read = seq_read, 1129 .llseek = seq_lseek 1130 }; 1131 1132 /** 1133 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device. 1134 * 1135 * @dev: device related to this debugfs file. 1136 * @name: name of the debugfs file. 1137 * @parent: a pointer to the parent dentry for this file. This should be a 1138 * directory dentry if set. If this parameter is %NULL, then the 1139 * file will be created in the root of the debugfs filesystem. 1140 * @read_fn: function pointer called to print the seq_file content. 1141 */ 1142 struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name, 1143 struct dentry *parent, 1144 int (*read_fn)(struct seq_file *s, 1145 void *data)) 1146 { 1147 struct debugfs_devm_entry *entry; 1148 1149 if (IS_ERR(parent)) 1150 return ERR_PTR(-ENOENT); 1151 1152 entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL); 1153 if (!entry) 1154 return ERR_PTR(-ENOMEM); 1155 1156 entry->read = read_fn; 1157 entry->dev = dev; 1158 1159 return debugfs_create_file(name, S_IRUGO, parent, entry, 1160 &debugfs_devm_entry_ops); 1161 } 1162 EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile); 1163 1164