fs/xfs/xfs_sysfs.c

   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 }