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