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