fs/xfs/xfs_sysfs.c

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