1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2014 Red Hat, Inc. 4 * All Rights Reserved. 5 */ 6 7 #include "xfs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_sysfs.h" 13 #include "xfs_log.h" 14 #include "xfs_log_priv.h" 15 #include "xfs_mount.h" 16 17 struct xfs_sysfs_attr { 18 struct attribute attr; 19 ssize_t (*show)(struct kobject *kobject, char *buf); 20 ssize_t (*store)(struct kobject *kobject, const char *buf, 21 size_t count); 22 }; 23 24 static inline struct xfs_sysfs_attr * 25 to_attr(struct attribute *attr) 26 { 27 return container_of(attr, struct xfs_sysfs_attr, attr); 28 } 29 30 #define XFS_SYSFS_ATTR_RW(name) \ 31 static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RW(name) 32 #define XFS_SYSFS_ATTR_RO(name) \ 33 static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RO(name) 34 #define XFS_SYSFS_ATTR_WO(name) \ 35 static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_WO(name) 36 37 #define ATTR_LIST(name) &xfs_sysfs_attr_##name.attr 38 39 STATIC ssize_t 40 xfs_sysfs_object_show( 41 struct kobject *kobject, 42 struct attribute *attr, 43 char *buf) 44 { 45 struct xfs_sysfs_attr *xfs_attr = to_attr(attr); 46 47 return xfs_attr->show ? xfs_attr->show(kobject, buf) : 0; 48 } 49 50 STATIC ssize_t 51 xfs_sysfs_object_store( 52 struct kobject *kobject, 53 struct attribute *attr, 54 const char *buf, 55 size_t count) 56 { 57 struct xfs_sysfs_attr *xfs_attr = to_attr(attr); 58 59 return xfs_attr->store ? xfs_attr->store(kobject, buf, count) : 0; 60 } 61 62 static const struct sysfs_ops xfs_sysfs_ops = { 63 .show = xfs_sysfs_object_show, 64 .store = xfs_sysfs_object_store, 65 }; 66 67 static struct attribute *xfs_mp_attrs[] = { 68 NULL, 69 }; 70 ATTRIBUTE_GROUPS(xfs_mp); 71 72 const struct kobj_type xfs_mp_ktype = { 73 .release = xfs_sysfs_release, 74 .sysfs_ops = &xfs_sysfs_ops, 75 .default_groups = xfs_mp_groups, 76 }; 77 78 #ifdef DEBUG 79 /* debug */ 80 81 STATIC ssize_t 82 bug_on_assert_store( 83 struct kobject *kobject, 84 const char *buf, 85 size_t count) 86 { 87 int ret; 88 int val; 89 90 ret = kstrtoint(buf, 0, &val); 91 if (ret) 92 return ret; 93 94 if (val == 1) 95 xfs_globals.bug_on_assert = true; 96 else if (val == 0) 97 xfs_globals.bug_on_assert = false; 98 else 99 return -EINVAL; 100 101 return count; 102 } 103 104 STATIC ssize_t 105 bug_on_assert_show( 106 struct kobject *kobject, 107 char *buf) 108 { 109 return sysfs_emit(buf, "%d\n", xfs_globals.bug_on_assert); 110 } 111 XFS_SYSFS_ATTR_RW(bug_on_assert); 112 113 STATIC ssize_t 114 log_recovery_delay_store( 115 struct kobject *kobject, 116 const char *buf, 117 size_t count) 118 { 119 int ret; 120 int val; 121 122 ret = kstrtoint(buf, 0, &val); 123 if (ret) 124 return ret; 125 126 if (val < 0 || val > 60) 127 return -EINVAL; 128 129 xfs_globals.log_recovery_delay = val; 130 131 return count; 132 } 133 134 STATIC ssize_t 135 log_recovery_delay_show( 136 struct kobject *kobject, 137 char *buf) 138 { 139 return sysfs_emit(buf, "%d\n", xfs_globals.log_recovery_delay); 140 } 141 XFS_SYSFS_ATTR_RW(log_recovery_delay); 142 143 STATIC ssize_t 144 mount_delay_store( 145 struct kobject *kobject, 146 const char *buf, 147 size_t count) 148 { 149 int ret; 150 int val; 151 152 ret = kstrtoint(buf, 0, &val); 153 if (ret) 154 return ret; 155 156 if (val < 0 || val > 60) 157 return -EINVAL; 158 159 xfs_globals.mount_delay = val; 160 161 return count; 162 } 163 164 STATIC ssize_t 165 mount_delay_show( 166 struct kobject *kobject, 167 char *buf) 168 { 169 return sysfs_emit(buf, "%d\n", xfs_globals.mount_delay); 170 } 171 XFS_SYSFS_ATTR_RW(mount_delay); 172 173 static ssize_t 174 always_cow_store( 175 struct kobject *kobject, 176 const char *buf, 177 size_t count) 178 { 179 ssize_t ret; 180 181 ret = kstrtobool(buf, &xfs_globals.always_cow); 182 if (ret < 0) 183 return ret; 184 return count; 185 } 186 187 static ssize_t 188 always_cow_show( 189 struct kobject *kobject, 190 char *buf) 191 { 192 return sysfs_emit(buf, "%d\n", xfs_globals.always_cow); 193 } 194 XFS_SYSFS_ATTR_RW(always_cow); 195 196 /* 197 * Override how many threads the parallel work queue is allowed to create. 198 * This has to be a debug-only global (instead of an errortag) because one of 199 * the main users of parallel workqueues is mount time quotacheck. 200 */ 201 STATIC ssize_t 202 pwork_threads_store( 203 struct kobject *kobject, 204 const char *buf, 205 size_t count) 206 { 207 int ret; 208 int val; 209 210 ret = kstrtoint(buf, 0, &val); 211 if (ret) 212 return ret; 213 214 if (val < -1 || val > num_possible_cpus()) 215 return -EINVAL; 216 217 xfs_globals.pwork_threads = val; 218 219 return count; 220 } 221 222 STATIC ssize_t 223 pwork_threads_show( 224 struct kobject *kobject, 225 char *buf) 226 { 227 return sysfs_emit(buf, "%d\n", xfs_globals.pwork_threads); 228 } 229 XFS_SYSFS_ATTR_RW(pwork_threads); 230 231 /* 232 * The "LARP" (Logged extended Attribute Recovery Persistence) debugging knob 233 * sets the XFS_DA_OP_LOGGED flag on all xfs_attr_set operations performed on 234 * V5 filesystems. As a result, the intermediate progress of all setxattr and 235 * removexattr operations are tracked via the log and can be restarted during 236 * recovery. This is useful for testing xattr recovery prior to merging of the 237 * parent pointer feature which requires it to maintain consistency, and may be 238 * enabled for userspace xattrs in the future. 239 */ 240 static ssize_t 241 larp_store( 242 struct kobject *kobject, 243 const char *buf, 244 size_t count) 245 { 246 ssize_t ret; 247 248 ret = kstrtobool(buf, &xfs_globals.larp); 249 if (ret < 0) 250 return ret; 251 return count; 252 } 253 254 STATIC ssize_t 255 larp_show( 256 struct kobject *kobject, 257 char *buf) 258 { 259 return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.larp); 260 } 261 XFS_SYSFS_ATTR_RW(larp); 262 263 STATIC ssize_t 264 bload_leaf_slack_store( 265 struct kobject *kobject, 266 const char *buf, 267 size_t count) 268 { 269 int ret; 270 int val; 271 272 ret = kstrtoint(buf, 0, &val); 273 if (ret) 274 return ret; 275 276 xfs_globals.bload_leaf_slack = val; 277 return count; 278 } 279 280 STATIC ssize_t 281 bload_leaf_slack_show( 282 struct kobject *kobject, 283 char *buf) 284 { 285 return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.bload_leaf_slack); 286 } 287 XFS_SYSFS_ATTR_RW(bload_leaf_slack); 288 289 STATIC ssize_t 290 bload_node_slack_store( 291 struct kobject *kobject, 292 const char *buf, 293 size_t count) 294 { 295 int ret; 296 int val; 297 298 ret = kstrtoint(buf, 0, &val); 299 if (ret) 300 return ret; 301 302 xfs_globals.bload_node_slack = val; 303 return count; 304 } 305 306 STATIC ssize_t 307 bload_node_slack_show( 308 struct kobject *kobject, 309 char *buf) 310 { 311 return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.bload_node_slack); 312 } 313 XFS_SYSFS_ATTR_RW(bload_node_slack); 314 315 static struct attribute *xfs_dbg_attrs[] = { 316 ATTR_LIST(bug_on_assert), 317 ATTR_LIST(log_recovery_delay), 318 ATTR_LIST(mount_delay), 319 ATTR_LIST(always_cow), 320 ATTR_LIST(pwork_threads), 321 ATTR_LIST(larp), 322 ATTR_LIST(bload_leaf_slack), 323 ATTR_LIST(bload_node_slack), 324 NULL, 325 }; 326 ATTRIBUTE_GROUPS(xfs_dbg); 327 328 const struct kobj_type xfs_dbg_ktype = { 329 .release = xfs_sysfs_release, 330 .sysfs_ops = &xfs_sysfs_ops, 331 .default_groups = xfs_dbg_groups, 332 }; 333 334 #endif /* DEBUG */ 335 336 /* stats */ 337 338 static inline struct xstats * 339 to_xstats(struct kobject *kobject) 340 { 341 struct xfs_kobj *kobj = to_kobj(kobject); 342 343 return container_of(kobj, struct xstats, xs_kobj); 344 } 345 346 STATIC ssize_t 347 stats_show( 348 struct kobject *kobject, 349 char *buf) 350 { 351 struct xstats *stats = to_xstats(kobject); 352 353 return xfs_stats_format(stats->xs_stats, buf); 354 } 355 XFS_SYSFS_ATTR_RO(stats); 356 357 STATIC ssize_t 358 stats_clear_store( 359 struct kobject *kobject, 360 const char *buf, 361 size_t count) 362 { 363 int ret; 364 int val; 365 struct xstats *stats = to_xstats(kobject); 366 367 ret = kstrtoint(buf, 0, &val); 368 if (ret) 369 return ret; 370 371 if (val != 1) 372 return -EINVAL; 373 374 xfs_stats_clearall(stats->xs_stats); 375 return count; 376 } 377 XFS_SYSFS_ATTR_WO(stats_clear); 378 379 static struct attribute *xfs_stats_attrs[] = { 380 ATTR_LIST(stats), 381 ATTR_LIST(stats_clear), 382 NULL, 383 }; 384 ATTRIBUTE_GROUPS(xfs_stats); 385 386 const struct kobj_type xfs_stats_ktype = { 387 .release = xfs_sysfs_release, 388 .sysfs_ops = &xfs_sysfs_ops, 389 .default_groups = xfs_stats_groups, 390 }; 391 392 /* xlog */ 393 394 static inline struct xlog * 395 to_xlog(struct kobject *kobject) 396 { 397 struct xfs_kobj *kobj = to_kobj(kobject); 398 399 return container_of(kobj, struct xlog, l_kobj); 400 } 401 402 STATIC ssize_t 403 log_head_lsn_show( 404 struct kobject *kobject, 405 char *buf) 406 { 407 int cycle; 408 int block; 409 struct xlog *log = to_xlog(kobject); 410 411 spin_lock(&log->l_icloglock); 412 cycle = log->l_curr_cycle; 413 block = log->l_curr_block; 414 spin_unlock(&log->l_icloglock); 415 416 return sysfs_emit(buf, "%d:%d\n", cycle, block); 417 } 418 XFS_SYSFS_ATTR_RO(log_head_lsn); 419 420 STATIC ssize_t 421 log_tail_lsn_show( 422 struct kobject *kobject, 423 char *buf) 424 { 425 int cycle; 426 int block; 427 struct xlog *log = to_xlog(kobject); 428 429 xlog_crack_atomic_lsn(&log->l_tail_lsn, &cycle, &block); 430 return sysfs_emit(buf, "%d:%d\n", cycle, block); 431 } 432 XFS_SYSFS_ATTR_RO(log_tail_lsn); 433 434 STATIC ssize_t 435 reserve_grant_head_show( 436 struct kobject *kobject, 437 char *buf) 438 439 { 440 int cycle; 441 int bytes; 442 struct xlog *log = to_xlog(kobject); 443 444 xlog_crack_grant_head(&log->l_reserve_head.grant, &cycle, &bytes); 445 return sysfs_emit(buf, "%d:%d\n", cycle, bytes); 446 } 447 XFS_SYSFS_ATTR_RO(reserve_grant_head); 448 449 STATIC ssize_t 450 write_grant_head_show( 451 struct kobject *kobject, 452 char *buf) 453 { 454 int cycle; 455 int bytes; 456 struct xlog *log = to_xlog(kobject); 457 458 xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &bytes); 459 return sysfs_emit(buf, "%d:%d\n", cycle, bytes); 460 } 461 XFS_SYSFS_ATTR_RO(write_grant_head); 462 463 static struct attribute *xfs_log_attrs[] = { 464 ATTR_LIST(log_head_lsn), 465 ATTR_LIST(log_tail_lsn), 466 ATTR_LIST(reserve_grant_head), 467 ATTR_LIST(write_grant_head), 468 NULL, 469 }; 470 ATTRIBUTE_GROUPS(xfs_log); 471 472 const struct kobj_type xfs_log_ktype = { 473 .release = xfs_sysfs_release, 474 .sysfs_ops = &xfs_sysfs_ops, 475 .default_groups = xfs_log_groups, 476 }; 477 478 /* 479 * Metadata IO error configuration 480 * 481 * The sysfs structure here is: 482 * ...xfs/<dev>/error/<class>/<errno>/<error_attrs> 483 * 484 * where <class> allows us to discriminate between data IO and metadata IO, 485 * and any other future type of IO (e.g. special inode or directory error 486 * handling) we care to support. 487 */ 488 static inline struct xfs_error_cfg * 489 to_error_cfg(struct kobject *kobject) 490 { 491 struct xfs_kobj *kobj = to_kobj(kobject); 492 return container_of(kobj, struct xfs_error_cfg, kobj); 493 } 494 495 static inline struct xfs_mount * 496 err_to_mp(struct kobject *kobject) 497 { 498 struct xfs_kobj *kobj = to_kobj(kobject); 499 return container_of(kobj, struct xfs_mount, m_error_kobj); 500 } 501 502 static ssize_t 503 max_retries_show( 504 struct kobject *kobject, 505 char *buf) 506 { 507 int retries; 508 struct xfs_error_cfg *cfg = to_error_cfg(kobject); 509 510 if (cfg->max_retries == XFS_ERR_RETRY_FOREVER) 511 retries = -1; 512 else 513 retries = cfg->max_retries; 514 515 return sysfs_emit(buf, "%d\n", retries); 516 } 517 518 static ssize_t 519 max_retries_store( 520 struct kobject *kobject, 521 const char *buf, 522 size_t count) 523 { 524 struct xfs_error_cfg *cfg = to_error_cfg(kobject); 525 int ret; 526 int val; 527 528 ret = kstrtoint(buf, 0, &val); 529 if (ret) 530 return ret; 531 532 if (val < -1) 533 return -EINVAL; 534 535 if (val == -1) 536 cfg->max_retries = XFS_ERR_RETRY_FOREVER; 537 else 538 cfg->max_retries = val; 539 return count; 540 } 541 XFS_SYSFS_ATTR_RW(max_retries); 542 543 static ssize_t 544 retry_timeout_seconds_show( 545 struct kobject *kobject, 546 char *buf) 547 { 548 int timeout; 549 struct xfs_error_cfg *cfg = to_error_cfg(kobject); 550 551 if (cfg->retry_timeout == XFS_ERR_RETRY_FOREVER) 552 timeout = -1; 553 else 554 timeout = jiffies_to_msecs(cfg->retry_timeout) / MSEC_PER_SEC; 555 556 return sysfs_emit(buf, "%d\n", timeout); 557 } 558 559 static ssize_t 560 retry_timeout_seconds_store( 561 struct kobject *kobject, 562 const char *buf, 563 size_t count) 564 { 565 struct xfs_error_cfg *cfg = to_error_cfg(kobject); 566 int ret; 567 int val; 568 569 ret = kstrtoint(buf, 0, &val); 570 if (ret) 571 return ret; 572 573 /* 1 day timeout maximum, -1 means infinite */ 574 if (val < -1 || val > 86400) 575 return -EINVAL; 576 577 if (val == -1) 578 cfg->retry_timeout = XFS_ERR_RETRY_FOREVER; 579 else { 580 cfg->retry_timeout = msecs_to_jiffies(val * MSEC_PER_SEC); 581 ASSERT(msecs_to_jiffies(val * MSEC_PER_SEC) < LONG_MAX); 582 } 583 return count; 584 } 585 XFS_SYSFS_ATTR_RW(retry_timeout_seconds); 586 587 static ssize_t 588 fail_at_unmount_show( 589 struct kobject *kobject, 590 char *buf) 591 { 592 struct xfs_mount *mp = err_to_mp(kobject); 593 594 return sysfs_emit(buf, "%d\n", mp->m_fail_unmount); 595 } 596 597 static ssize_t 598 fail_at_unmount_store( 599 struct kobject *kobject, 600 const char *buf, 601 size_t count) 602 { 603 struct xfs_mount *mp = err_to_mp(kobject); 604 int ret; 605 int val; 606 607 ret = kstrtoint(buf, 0, &val); 608 if (ret) 609 return ret; 610 611 if (val < 0 || val > 1) 612 return -EINVAL; 613 614 mp->m_fail_unmount = val; 615 return count; 616 } 617 XFS_SYSFS_ATTR_RW(fail_at_unmount); 618 619 static struct attribute *xfs_error_attrs[] = { 620 ATTR_LIST(max_retries), 621 ATTR_LIST(retry_timeout_seconds), 622 NULL, 623 }; 624 ATTRIBUTE_GROUPS(xfs_error); 625 626 static const struct kobj_type xfs_error_cfg_ktype = { 627 .release = xfs_sysfs_release, 628 .sysfs_ops = &xfs_sysfs_ops, 629 .default_groups = xfs_error_groups, 630 }; 631 632 static const struct kobj_type xfs_error_ktype = { 633 .release = xfs_sysfs_release, 634 .sysfs_ops = &xfs_sysfs_ops, 635 }; 636 637 /* 638 * Error initialization tables. These need to be ordered in the same 639 * order as the enums used to index the array. All class init tables need to 640 * define a "default" behaviour as the first entry, all other entries can be 641 * empty. 642 */ 643 struct xfs_error_init { 644 char *name; 645 int max_retries; 646 int retry_timeout; /* in seconds */ 647 }; 648 649 static const struct xfs_error_init xfs_error_meta_init[XFS_ERR_ERRNO_MAX] = { 650 { .name = "default", 651 .max_retries = XFS_ERR_RETRY_FOREVER, 652 .retry_timeout = XFS_ERR_RETRY_FOREVER, 653 }, 654 { .name = "EIO", 655 .max_retries = XFS_ERR_RETRY_FOREVER, 656 .retry_timeout = XFS_ERR_RETRY_FOREVER, 657 }, 658 { .name = "ENOSPC", 659 .max_retries = XFS_ERR_RETRY_FOREVER, 660 .retry_timeout = XFS_ERR_RETRY_FOREVER, 661 }, 662 { .name = "ENODEV", 663 .max_retries = 0, /* We can't recover from devices disappearing */ 664 .retry_timeout = 0, 665 }, 666 }; 667 668 static int 669 xfs_error_sysfs_init_class( 670 struct xfs_mount *mp, 671 int class, 672 const char *parent_name, 673 struct xfs_kobj *parent_kobj, 674 const struct xfs_error_init init[]) 675 { 676 struct xfs_error_cfg *cfg; 677 int error; 678 int i; 679 680 ASSERT(class < XFS_ERR_CLASS_MAX); 681 682 error = xfs_sysfs_init(parent_kobj, &xfs_error_ktype, 683 &mp->m_error_kobj, parent_name); 684 if (error) 685 return error; 686 687 for (i = 0; i < XFS_ERR_ERRNO_MAX; i++) { 688 cfg = &mp->m_error_cfg[class][i]; 689 error = xfs_sysfs_init(&cfg->kobj, &xfs_error_cfg_ktype, 690 parent_kobj, init[i].name); 691 if (error) 692 goto out_error; 693 694 cfg->max_retries = init[i].max_retries; 695 if (init[i].retry_timeout == XFS_ERR_RETRY_FOREVER) 696 cfg->retry_timeout = XFS_ERR_RETRY_FOREVER; 697 else 698 cfg->retry_timeout = msecs_to_jiffies( 699 init[i].retry_timeout * MSEC_PER_SEC); 700 } 701 return 0; 702 703 out_error: 704 /* unwind the entries that succeeded */ 705 for (i--; i >= 0; i--) { 706 cfg = &mp->m_error_cfg[class][i]; 707 xfs_sysfs_del(&cfg->kobj); 708 } 709 xfs_sysfs_del(parent_kobj); 710 return error; 711 } 712 713 int 714 xfs_error_sysfs_init( 715 struct xfs_mount *mp) 716 { 717 int error; 718 719 /* .../xfs/<dev>/error/ */ 720 error = xfs_sysfs_init(&mp->m_error_kobj, &xfs_error_ktype, 721 &mp->m_kobj, "error"); 722 if (error) 723 return error; 724 725 error = sysfs_create_file(&mp->m_error_kobj.kobject, 726 ATTR_LIST(fail_at_unmount)); 727 728 if (error) 729 goto out_error; 730 731 /* .../xfs/<dev>/error/metadata/ */ 732 error = xfs_error_sysfs_init_class(mp, XFS_ERR_METADATA, 733 "metadata", &mp->m_error_meta_kobj, 734 xfs_error_meta_init); 735 if (error) 736 goto out_error; 737 738 return 0; 739 740 out_error: 741 xfs_sysfs_del(&mp->m_error_kobj); 742 return error; 743 } 744 745 void 746 xfs_error_sysfs_del( 747 struct xfs_mount *mp) 748 { 749 struct xfs_error_cfg *cfg; 750 int i, j; 751 752 for (i = 0; i < XFS_ERR_CLASS_MAX; i++) { 753 for (j = 0; j < XFS_ERR_ERRNO_MAX; j++) { 754 cfg = &mp->m_error_cfg[i][j]; 755 756 xfs_sysfs_del(&cfg->kobj); 757 } 758 } 759 xfs_sysfs_del(&mp->m_error_meta_kobj); 760 xfs_sysfs_del(&mp->m_error_kobj); 761 } 762 763 struct xfs_error_cfg * 764 xfs_error_get_cfg( 765 struct xfs_mount *mp, 766 int error_class, 767 int error) 768 { 769 struct xfs_error_cfg *cfg; 770 771 if (error < 0) 772 error = -error; 773 774 switch (error) { 775 case EIO: 776 cfg = &mp->m_error_cfg[error_class][XFS_ERR_EIO]; 777 break; 778 case ENOSPC: 779 cfg = &mp->m_error_cfg[error_class][XFS_ERR_ENOSPC]; 780 break; 781 case ENODEV: 782 cfg = &mp->m_error_cfg[error_class][XFS_ERR_ENODEV]; 783 break; 784 default: 785 cfg = &mp->m_error_cfg[error_class][XFS_ERR_DEFAULT]; 786 break; 787 } 788 789 return cfg; 790 } 791