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