xref: /openbmc/linux/fs/xfs/xfs_sysfs.c (revision b46f7d33) 
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 }
704