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