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