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