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