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