sysfs.c revision e7849e33
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2007 Oracle.  All rights reserved.
4 */
5
6#include <linux/sched.h>
7#include <linux/sched/mm.h>
8#include <linux/slab.h>
9#include <linux/spinlock.h>
10#include <linux/completion.h>
11#include <linux/bug.h>
12#include <crypto/hash.h>
13
14#include "ctree.h"
15#include "discard.h"
16#include "disk-io.h"
17#include "send.h"
18#include "transaction.h"
19#include "sysfs.h"
20#include "volumes.h"
21#include "space-info.h"
22#include "block-group.h"
23#include "qgroup.h"
24
25/*
26 * Structure name                       Path
27 * --------------------------------------------------------------------------
28 * btrfs_supported_static_feature_attrs /sys/fs/btrfs/features
29 * btrfs_supported_feature_attrs	/sys/fs/btrfs/features and
30 *					/sys/fs/btrfs/<uuid>/features
31 * btrfs_attrs				/sys/fs/btrfs/<uuid>
32 * devid_attrs				/sys/fs/btrfs/<uuid>/devinfo/<devid>
33 * allocation_attrs			/sys/fs/btrfs/<uuid>/allocation
34 * qgroup_attrs				/sys/fs/btrfs/<uuid>/qgroups/<level>_<qgroupid>
35 * space_info_attrs			/sys/fs/btrfs/<uuid>/allocation/<bg-type>
36 * raid_attrs				/sys/fs/btrfs/<uuid>/allocation/<bg-type>/<bg-profile>
37 *
38 * When built with BTRFS_CONFIG_DEBUG:
39 *
40 * btrfs_debug_feature_attrs		/sys/fs/btrfs/debug
41 * btrfs_debug_mount_attrs		/sys/fs/btrfs/<uuid>/debug
42 * discard_debug_attrs			/sys/fs/btrfs/<uuid>/debug/discard
43 */
44
45struct btrfs_feature_attr {
46	struct kobj_attribute kobj_attr;
47	enum btrfs_feature_set feature_set;
48	u64 feature_bit;
49};
50
51/* For raid type sysfs entries */
52struct raid_kobject {
53	u64 flags;
54	struct kobject kobj;
55};
56
57#define __INIT_KOBJ_ATTR(_name, _mode, _show, _store)			\
58{									\
59	.attr	= { .name = __stringify(_name), .mode = _mode },	\
60	.show	= _show,						\
61	.store	= _store,						\
62}
63
64#define BTRFS_ATTR_RW(_prefix, _name, _show, _store)			\
65	static struct kobj_attribute btrfs_attr_##_prefix##_##_name =	\
66			__INIT_KOBJ_ATTR(_name, 0644, _show, _store)
67
68#define BTRFS_ATTR(_prefix, _name, _show)				\
69	static struct kobj_attribute btrfs_attr_##_prefix##_##_name =	\
70			__INIT_KOBJ_ATTR(_name, 0444, _show, NULL)
71
72#define BTRFS_ATTR_PTR(_prefix, _name)					\
73	(&btrfs_attr_##_prefix##_##_name.attr)
74
75#define BTRFS_FEAT_ATTR(_name, _feature_set, _feature_prefix, _feature_bit)  \
76static struct btrfs_feature_attr btrfs_attr_features_##_name = {	     \
77	.kobj_attr = __INIT_KOBJ_ATTR(_name, S_IRUGO,			     \
78				      btrfs_feature_attr_show,		     \
79				      btrfs_feature_attr_store),	     \
80	.feature_set	= _feature_set,					     \
81	.feature_bit	= _feature_prefix ##_## _feature_bit,		     \
82}
83#define BTRFS_FEAT_ATTR_PTR(_name)					     \
84	(&btrfs_attr_features_##_name.kobj_attr.attr)
85
86#define BTRFS_FEAT_ATTR_COMPAT(name, feature) \
87	BTRFS_FEAT_ATTR(name, FEAT_COMPAT, BTRFS_FEATURE_COMPAT, feature)
88#define BTRFS_FEAT_ATTR_COMPAT_RO(name, feature) \
89	BTRFS_FEAT_ATTR(name, FEAT_COMPAT_RO, BTRFS_FEATURE_COMPAT_RO, feature)
90#define BTRFS_FEAT_ATTR_INCOMPAT(name, feature) \
91	BTRFS_FEAT_ATTR(name, FEAT_INCOMPAT, BTRFS_FEATURE_INCOMPAT, feature)
92
93static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj);
94static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj);
95
96static struct btrfs_feature_attr *to_btrfs_feature_attr(struct kobj_attribute *a)
97{
98	return container_of(a, struct btrfs_feature_attr, kobj_attr);
99}
100
101static struct kobj_attribute *attr_to_btrfs_attr(struct attribute *attr)
102{
103	return container_of(attr, struct kobj_attribute, attr);
104}
105
106static struct btrfs_feature_attr *attr_to_btrfs_feature_attr(
107		struct attribute *attr)
108{
109	return to_btrfs_feature_attr(attr_to_btrfs_attr(attr));
110}
111
112static u64 get_features(struct btrfs_fs_info *fs_info,
113			enum btrfs_feature_set set)
114{
115	struct btrfs_super_block *disk_super = fs_info->super_copy;
116	if (set == FEAT_COMPAT)
117		return btrfs_super_compat_flags(disk_super);
118	else if (set == FEAT_COMPAT_RO)
119		return btrfs_super_compat_ro_flags(disk_super);
120	else
121		return btrfs_super_incompat_flags(disk_super);
122}
123
124static void set_features(struct btrfs_fs_info *fs_info,
125			 enum btrfs_feature_set set, u64 features)
126{
127	struct btrfs_super_block *disk_super = fs_info->super_copy;
128	if (set == FEAT_COMPAT)
129		btrfs_set_super_compat_flags(disk_super, features);
130	else if (set == FEAT_COMPAT_RO)
131		btrfs_set_super_compat_ro_flags(disk_super, features);
132	else
133		btrfs_set_super_incompat_flags(disk_super, features);
134}
135
136static int can_modify_feature(struct btrfs_feature_attr *fa)
137{
138	int val = 0;
139	u64 set, clear;
140	switch (fa->feature_set) {
141	case FEAT_COMPAT:
142		set = BTRFS_FEATURE_COMPAT_SAFE_SET;
143		clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
144		break;
145	case FEAT_COMPAT_RO:
146		set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
147		clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
148		break;
149	case FEAT_INCOMPAT:
150		set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
151		clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
152		break;
153	default:
154		pr_warn("btrfs: sysfs: unknown feature set %d\n",
155				fa->feature_set);
156		return 0;
157	}
158
159	if (set & fa->feature_bit)
160		val |= 1;
161	if (clear & fa->feature_bit)
162		val |= 2;
163
164	return val;
165}
166
167static ssize_t btrfs_feature_attr_show(struct kobject *kobj,
168				       struct kobj_attribute *a, char *buf)
169{
170	int val = 0;
171	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
172	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
173	if (fs_info) {
174		u64 features = get_features(fs_info, fa->feature_set);
175		if (features & fa->feature_bit)
176			val = 1;
177	} else
178		val = can_modify_feature(fa);
179
180	return scnprintf(buf, PAGE_SIZE, "%d\n", val);
181}
182
183static ssize_t btrfs_feature_attr_store(struct kobject *kobj,
184					struct kobj_attribute *a,
185					const char *buf, size_t count)
186{
187	struct btrfs_fs_info *fs_info;
188	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
189	u64 features, set, clear;
190	unsigned long val;
191	int ret;
192
193	fs_info = to_fs_info(kobj);
194	if (!fs_info)
195		return -EPERM;
196
197	if (sb_rdonly(fs_info->sb))
198		return -EROFS;
199
200	ret = kstrtoul(skip_spaces(buf), 0, &val);
201	if (ret)
202		return ret;
203
204	if (fa->feature_set == FEAT_COMPAT) {
205		set = BTRFS_FEATURE_COMPAT_SAFE_SET;
206		clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
207	} else if (fa->feature_set == FEAT_COMPAT_RO) {
208		set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
209		clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
210	} else {
211		set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
212		clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
213	}
214
215	features = get_features(fs_info, fa->feature_set);
216
217	/* Nothing to do */
218	if ((val && (features & fa->feature_bit)) ||
219	    (!val && !(features & fa->feature_bit)))
220		return count;
221
222	if ((val && !(set & fa->feature_bit)) ||
223	    (!val && !(clear & fa->feature_bit))) {
224		btrfs_info(fs_info,
225			"%sabling feature %s on mounted fs is not supported.",
226			val ? "En" : "Dis", fa->kobj_attr.attr.name);
227		return -EPERM;
228	}
229
230	btrfs_info(fs_info, "%s %s feature flag",
231		   val ? "Setting" : "Clearing", fa->kobj_attr.attr.name);
232
233	spin_lock(&fs_info->super_lock);
234	features = get_features(fs_info, fa->feature_set);
235	if (val)
236		features |= fa->feature_bit;
237	else
238		features &= ~fa->feature_bit;
239	set_features(fs_info, fa->feature_set, features);
240	spin_unlock(&fs_info->super_lock);
241
242	/*
243	 * We don't want to do full transaction commit from inside sysfs
244	 */
245	btrfs_set_pending(fs_info, COMMIT);
246	wake_up_process(fs_info->transaction_kthread);
247
248	return count;
249}
250
251static umode_t btrfs_feature_visible(struct kobject *kobj,
252				     struct attribute *attr, int unused)
253{
254	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
255	umode_t mode = attr->mode;
256
257	if (fs_info) {
258		struct btrfs_feature_attr *fa;
259		u64 features;
260
261		fa = attr_to_btrfs_feature_attr(attr);
262		features = get_features(fs_info, fa->feature_set);
263
264		if (can_modify_feature(fa))
265			mode |= S_IWUSR;
266		else if (!(features & fa->feature_bit))
267			mode = 0;
268	}
269
270	return mode;
271}
272
273BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF);
274BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);
275BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);
276BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);
277BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD);
278BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
279BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
280BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
281BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);
282BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES);
283BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid, METADATA_UUID);
284BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE);
285BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34);
286/* Remove once support for zoned allocation is feature complete */
287#ifdef CONFIG_BTRFS_DEBUG
288BTRFS_FEAT_ATTR_INCOMPAT(zoned, ZONED);
289#endif
290#ifdef CONFIG_FS_VERITY
291BTRFS_FEAT_ATTR_COMPAT_RO(verity, VERITY);
292#endif
293
294/*
295 * Features which depend on feature bits and may differ between each fs.
296 *
297 * /sys/fs/btrfs/features      - all available features implemeted by this version
298 * /sys/fs/btrfs/UUID/features - features of the fs which are enabled or
299 *                               can be changed on a mounted filesystem.
300 */
301static struct attribute *btrfs_supported_feature_attrs[] = {
302	BTRFS_FEAT_ATTR_PTR(mixed_backref),
303	BTRFS_FEAT_ATTR_PTR(default_subvol),
304	BTRFS_FEAT_ATTR_PTR(mixed_groups),
305	BTRFS_FEAT_ATTR_PTR(compress_lzo),
306	BTRFS_FEAT_ATTR_PTR(compress_zstd),
307	BTRFS_FEAT_ATTR_PTR(big_metadata),
308	BTRFS_FEAT_ATTR_PTR(extended_iref),
309	BTRFS_FEAT_ATTR_PTR(raid56),
310	BTRFS_FEAT_ATTR_PTR(skinny_metadata),
311	BTRFS_FEAT_ATTR_PTR(no_holes),
312	BTRFS_FEAT_ATTR_PTR(metadata_uuid),
313	BTRFS_FEAT_ATTR_PTR(free_space_tree),
314	BTRFS_FEAT_ATTR_PTR(raid1c34),
315#ifdef CONFIG_BTRFS_DEBUG
316	BTRFS_FEAT_ATTR_PTR(zoned),
317#endif
318#ifdef CONFIG_FS_VERITY
319	BTRFS_FEAT_ATTR_PTR(verity),
320#endif
321	NULL
322};
323
324static const struct attribute_group btrfs_feature_attr_group = {
325	.name = "features",
326	.is_visible = btrfs_feature_visible,
327	.attrs = btrfs_supported_feature_attrs,
328};
329
330static ssize_t rmdir_subvol_show(struct kobject *kobj,
331				 struct kobj_attribute *ka, char *buf)
332{
333	return scnprintf(buf, PAGE_SIZE, "0\n");
334}
335BTRFS_ATTR(static_feature, rmdir_subvol, rmdir_subvol_show);
336
337static ssize_t supported_checksums_show(struct kobject *kobj,
338					struct kobj_attribute *a, char *buf)
339{
340	ssize_t ret = 0;
341	int i;
342
343	for (i = 0; i < btrfs_get_num_csums(); i++) {
344		/*
345		 * This "trick" only works as long as 'enum btrfs_csum_type' has
346		 * no holes in it
347		 */
348		ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s",
349				(i == 0 ? "" : " "), btrfs_super_csum_name(i));
350
351	}
352
353	ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
354	return ret;
355}
356BTRFS_ATTR(static_feature, supported_checksums, supported_checksums_show);
357
358static ssize_t send_stream_version_show(struct kobject *kobj,
359					struct kobj_attribute *ka, char *buf)
360{
361	return snprintf(buf, PAGE_SIZE, "%d\n", BTRFS_SEND_STREAM_VERSION);
362}
363BTRFS_ATTR(static_feature, send_stream_version, send_stream_version_show);
364
365static const char *rescue_opts[] = {
366	"usebackuproot",
367	"nologreplay",
368	"ignorebadroots",
369	"ignoredatacsums",
370	"all",
371};
372
373static ssize_t supported_rescue_options_show(struct kobject *kobj,
374					     struct kobj_attribute *a,
375					     char *buf)
376{
377	ssize_t ret = 0;
378	int i;
379
380	for (i = 0; i < ARRAY_SIZE(rescue_opts); i++)
381		ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s",
382				 (i ? " " : ""), rescue_opts[i]);
383	ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
384	return ret;
385}
386BTRFS_ATTR(static_feature, supported_rescue_options,
387	   supported_rescue_options_show);
388
389static ssize_t supported_sectorsizes_show(struct kobject *kobj,
390					  struct kobj_attribute *a,
391					  char *buf)
392{
393	ssize_t ret = 0;
394
395	/* 4K sector size is also supported with 64K page size */
396	if (PAGE_SIZE == SZ_64K)
397		ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%u ", SZ_4K);
398
399	/* Only sectorsize == PAGE_SIZE is now supported */
400	ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%lu\n", PAGE_SIZE);
401
402	return ret;
403}
404BTRFS_ATTR(static_feature, supported_sectorsizes,
405	   supported_sectorsizes_show);
406
407/*
408 * Features which only depend on kernel version.
409 *
410 * These are listed in /sys/fs/btrfs/features along with
411 * btrfs_supported_feature_attrs.
412 */
413static struct attribute *btrfs_supported_static_feature_attrs[] = {
414	BTRFS_ATTR_PTR(static_feature, rmdir_subvol),
415	BTRFS_ATTR_PTR(static_feature, supported_checksums),
416	BTRFS_ATTR_PTR(static_feature, send_stream_version),
417	BTRFS_ATTR_PTR(static_feature, supported_rescue_options),
418	BTRFS_ATTR_PTR(static_feature, supported_sectorsizes),
419	NULL
420};
421
422static const struct attribute_group btrfs_static_feature_attr_group = {
423	.name = "features",
424	.attrs = btrfs_supported_static_feature_attrs,
425};
426
427#ifdef CONFIG_BTRFS_DEBUG
428
429/*
430 * Discard statistics and tunables
431 */
432#define discard_to_fs_info(_kobj)	to_fs_info((_kobj)->parent->parent)
433
434static ssize_t btrfs_discardable_bytes_show(struct kobject *kobj,
435					    struct kobj_attribute *a,
436					    char *buf)
437{
438	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
439
440	return scnprintf(buf, PAGE_SIZE, "%lld\n",
441			atomic64_read(&fs_info->discard_ctl.discardable_bytes));
442}
443BTRFS_ATTR(discard, discardable_bytes, btrfs_discardable_bytes_show);
444
445static ssize_t btrfs_discardable_extents_show(struct kobject *kobj,
446					      struct kobj_attribute *a,
447					      char *buf)
448{
449	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
450
451	return scnprintf(buf, PAGE_SIZE, "%d\n",
452			atomic_read(&fs_info->discard_ctl.discardable_extents));
453}
454BTRFS_ATTR(discard, discardable_extents, btrfs_discardable_extents_show);
455
456static ssize_t btrfs_discard_bitmap_bytes_show(struct kobject *kobj,
457					       struct kobj_attribute *a,
458					       char *buf)
459{
460	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
461
462	return scnprintf(buf, PAGE_SIZE, "%llu\n",
463			fs_info->discard_ctl.discard_bitmap_bytes);
464}
465BTRFS_ATTR(discard, discard_bitmap_bytes, btrfs_discard_bitmap_bytes_show);
466
467static ssize_t btrfs_discard_bytes_saved_show(struct kobject *kobj,
468					      struct kobj_attribute *a,
469					      char *buf)
470{
471	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
472
473	return scnprintf(buf, PAGE_SIZE, "%lld\n",
474		atomic64_read(&fs_info->discard_ctl.discard_bytes_saved));
475}
476BTRFS_ATTR(discard, discard_bytes_saved, btrfs_discard_bytes_saved_show);
477
478static ssize_t btrfs_discard_extent_bytes_show(struct kobject *kobj,
479					       struct kobj_attribute *a,
480					       char *buf)
481{
482	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
483
484	return scnprintf(buf, PAGE_SIZE, "%llu\n",
485			fs_info->discard_ctl.discard_extent_bytes);
486}
487BTRFS_ATTR(discard, discard_extent_bytes, btrfs_discard_extent_bytes_show);
488
489static ssize_t btrfs_discard_iops_limit_show(struct kobject *kobj,
490					     struct kobj_attribute *a,
491					     char *buf)
492{
493	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
494
495	return scnprintf(buf, PAGE_SIZE, "%u\n",
496			READ_ONCE(fs_info->discard_ctl.iops_limit));
497}
498
499static ssize_t btrfs_discard_iops_limit_store(struct kobject *kobj,
500					      struct kobj_attribute *a,
501					      const char *buf, size_t len)
502{
503	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
504	struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;
505	u32 iops_limit;
506	int ret;
507
508	ret = kstrtou32(buf, 10, &iops_limit);
509	if (ret)
510		return -EINVAL;
511
512	WRITE_ONCE(discard_ctl->iops_limit, iops_limit);
513	btrfs_discard_calc_delay(discard_ctl);
514	btrfs_discard_schedule_work(discard_ctl, true);
515	return len;
516}
517BTRFS_ATTR_RW(discard, iops_limit, btrfs_discard_iops_limit_show,
518	      btrfs_discard_iops_limit_store);
519
520static ssize_t btrfs_discard_kbps_limit_show(struct kobject *kobj,
521					     struct kobj_attribute *a,
522					     char *buf)
523{
524	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
525
526	return scnprintf(buf, PAGE_SIZE, "%u\n",
527			READ_ONCE(fs_info->discard_ctl.kbps_limit));
528}
529
530static ssize_t btrfs_discard_kbps_limit_store(struct kobject *kobj,
531					      struct kobj_attribute *a,
532					      const char *buf, size_t len)
533{
534	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
535	struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;
536	u32 kbps_limit;
537	int ret;
538
539	ret = kstrtou32(buf, 10, &kbps_limit);
540	if (ret)
541		return -EINVAL;
542
543	WRITE_ONCE(discard_ctl->kbps_limit, kbps_limit);
544	btrfs_discard_schedule_work(discard_ctl, true);
545	return len;
546}
547BTRFS_ATTR_RW(discard, kbps_limit, btrfs_discard_kbps_limit_show,
548	      btrfs_discard_kbps_limit_store);
549
550static ssize_t btrfs_discard_max_discard_size_show(struct kobject *kobj,
551						   struct kobj_attribute *a,
552						   char *buf)
553{
554	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
555
556	return scnprintf(buf, PAGE_SIZE, "%llu\n",
557			READ_ONCE(fs_info->discard_ctl.max_discard_size));
558}
559
560static ssize_t btrfs_discard_max_discard_size_store(struct kobject *kobj,
561						    struct kobj_attribute *a,
562						    const char *buf, size_t len)
563{
564	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
565	struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;
566	u64 max_discard_size;
567	int ret;
568
569	ret = kstrtou64(buf, 10, &max_discard_size);
570	if (ret)
571		return -EINVAL;
572
573	WRITE_ONCE(discard_ctl->max_discard_size, max_discard_size);
574
575	return len;
576}
577BTRFS_ATTR_RW(discard, max_discard_size, btrfs_discard_max_discard_size_show,
578	      btrfs_discard_max_discard_size_store);
579
580/*
581 * Per-filesystem debugging of discard (when mounted with discard=async).
582 *
583 * Path: /sys/fs/btrfs/<uuid>/debug/discard/
584 */
585static const struct attribute *discard_debug_attrs[] = {
586	BTRFS_ATTR_PTR(discard, discardable_bytes),
587	BTRFS_ATTR_PTR(discard, discardable_extents),
588	BTRFS_ATTR_PTR(discard, discard_bitmap_bytes),
589	BTRFS_ATTR_PTR(discard, discard_bytes_saved),
590	BTRFS_ATTR_PTR(discard, discard_extent_bytes),
591	BTRFS_ATTR_PTR(discard, iops_limit),
592	BTRFS_ATTR_PTR(discard, kbps_limit),
593	BTRFS_ATTR_PTR(discard, max_discard_size),
594	NULL,
595};
596
597/*
598 * Per-filesystem runtime debugging exported via sysfs.
599 *
600 * Path: /sys/fs/btrfs/UUID/debug/
601 */
602static const struct attribute *btrfs_debug_mount_attrs[] = {
603	NULL,
604};
605
606/*
607 * Runtime debugging exported via sysfs, applies to all mounted filesystems.
608 *
609 * Path: /sys/fs/btrfs/debug
610 */
611static struct attribute *btrfs_debug_feature_attrs[] = {
612	NULL
613};
614
615static const struct attribute_group btrfs_debug_feature_attr_group = {
616	.name = "debug",
617	.attrs = btrfs_debug_feature_attrs,
618};
619
620#endif
621
622static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf)
623{
624	u64 val;
625	if (lock)
626		spin_lock(lock);
627	val = *value_ptr;
628	if (lock)
629		spin_unlock(lock);
630	return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
631}
632
633static ssize_t global_rsv_size_show(struct kobject *kobj,
634				    struct kobj_attribute *ka, char *buf)
635{
636	struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
637	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
638	return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf);
639}
640BTRFS_ATTR(allocation, global_rsv_size, global_rsv_size_show);
641
642static ssize_t global_rsv_reserved_show(struct kobject *kobj,
643					struct kobj_attribute *a, char *buf)
644{
645	struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
646	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
647	return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf);
648}
649BTRFS_ATTR(allocation, global_rsv_reserved, global_rsv_reserved_show);
650
651#define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
652#define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj)
653
654static ssize_t raid_bytes_show(struct kobject *kobj,
655			       struct kobj_attribute *attr, char *buf);
656BTRFS_ATTR(raid, total_bytes, raid_bytes_show);
657BTRFS_ATTR(raid, used_bytes, raid_bytes_show);
658
659static ssize_t raid_bytes_show(struct kobject *kobj,
660			       struct kobj_attribute *attr, char *buf)
661
662{
663	struct btrfs_space_info *sinfo = to_space_info(kobj->parent);
664	struct btrfs_block_group *block_group;
665	int index = btrfs_bg_flags_to_raid_index(to_raid_kobj(kobj)->flags);
666	u64 val = 0;
667
668	down_read(&sinfo->groups_sem);
669	list_for_each_entry(block_group, &sinfo->block_groups[index], list) {
670		if (&attr->attr == BTRFS_ATTR_PTR(raid, total_bytes))
671			val += block_group->length;
672		else
673			val += block_group->used;
674	}
675	up_read(&sinfo->groups_sem);
676	return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
677}
678
679/*
680 * Allocation information about block group profiles.
681 *
682 * Path: /sys/fs/btrfs/<uuid>/allocation/<bg-type>/<bg-profile>/
683 */
684static struct attribute *raid_attrs[] = {
685	BTRFS_ATTR_PTR(raid, total_bytes),
686	BTRFS_ATTR_PTR(raid, used_bytes),
687	NULL
688};
689ATTRIBUTE_GROUPS(raid);
690
691static void release_raid_kobj(struct kobject *kobj)
692{
693	kfree(to_raid_kobj(kobj));
694}
695
696static struct kobj_type btrfs_raid_ktype = {
697	.sysfs_ops = &kobj_sysfs_ops,
698	.release = release_raid_kobj,
699	.default_groups = raid_groups,
700};
701
702#define SPACE_INFO_ATTR(field)						\
703static ssize_t btrfs_space_info_show_##field(struct kobject *kobj,	\
704					     struct kobj_attribute *a,	\
705					     char *buf)			\
706{									\
707	struct btrfs_space_info *sinfo = to_space_info(kobj);		\
708	return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf);	\
709}									\
710BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field)
711
712SPACE_INFO_ATTR(flags);
713SPACE_INFO_ATTR(total_bytes);
714SPACE_INFO_ATTR(bytes_used);
715SPACE_INFO_ATTR(bytes_pinned);
716SPACE_INFO_ATTR(bytes_reserved);
717SPACE_INFO_ATTR(bytes_may_use);
718SPACE_INFO_ATTR(bytes_readonly);
719SPACE_INFO_ATTR(bytes_zone_unusable);
720SPACE_INFO_ATTR(disk_used);
721SPACE_INFO_ATTR(disk_total);
722
723/*
724 * Allocation information about block group types.
725 *
726 * Path: /sys/fs/btrfs/<uuid>/allocation/<bg-type>/
727 */
728static struct attribute *space_info_attrs[] = {
729	BTRFS_ATTR_PTR(space_info, flags),
730	BTRFS_ATTR_PTR(space_info, total_bytes),
731	BTRFS_ATTR_PTR(space_info, bytes_used),
732	BTRFS_ATTR_PTR(space_info, bytes_pinned),
733	BTRFS_ATTR_PTR(space_info, bytes_reserved),
734	BTRFS_ATTR_PTR(space_info, bytes_may_use),
735	BTRFS_ATTR_PTR(space_info, bytes_readonly),
736	BTRFS_ATTR_PTR(space_info, bytes_zone_unusable),
737	BTRFS_ATTR_PTR(space_info, disk_used),
738	BTRFS_ATTR_PTR(space_info, disk_total),
739	NULL,
740};
741ATTRIBUTE_GROUPS(space_info);
742
743static void space_info_release(struct kobject *kobj)
744{
745	struct btrfs_space_info *sinfo = to_space_info(kobj);
746	kfree(sinfo);
747}
748
749static struct kobj_type space_info_ktype = {
750	.sysfs_ops = &kobj_sysfs_ops,
751	.release = space_info_release,
752	.default_groups = space_info_groups,
753};
754
755/*
756 * Allocation information about block groups.
757 *
758 * Path: /sys/fs/btrfs/<uuid>/allocation/
759 */
760static const struct attribute *allocation_attrs[] = {
761	BTRFS_ATTR_PTR(allocation, global_rsv_reserved),
762	BTRFS_ATTR_PTR(allocation, global_rsv_size),
763	NULL,
764};
765
766static ssize_t btrfs_label_show(struct kobject *kobj,
767				struct kobj_attribute *a, char *buf)
768{
769	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
770	char *label = fs_info->super_copy->label;
771	ssize_t ret;
772
773	spin_lock(&fs_info->super_lock);
774	ret = scnprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label);
775	spin_unlock(&fs_info->super_lock);
776
777	return ret;
778}
779
780static ssize_t btrfs_label_store(struct kobject *kobj,
781				 struct kobj_attribute *a,
782				 const char *buf, size_t len)
783{
784	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
785	size_t p_len;
786
787	if (!fs_info)
788		return -EPERM;
789
790	if (sb_rdonly(fs_info->sb))
791		return -EROFS;
792
793	/*
794	 * p_len is the len until the first occurrence of either
795	 * '\n' or '\0'
796	 */
797	p_len = strcspn(buf, "\n");
798
799	if (p_len >= BTRFS_LABEL_SIZE)
800		return -EINVAL;
801
802	spin_lock(&fs_info->super_lock);
803	memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE);
804	memcpy(fs_info->super_copy->label, buf, p_len);
805	spin_unlock(&fs_info->super_lock);
806
807	/*
808	 * We don't want to do full transaction commit from inside sysfs
809	 */
810	btrfs_set_pending(fs_info, COMMIT);
811	wake_up_process(fs_info->transaction_kthread);
812
813	return len;
814}
815BTRFS_ATTR_RW(, label, btrfs_label_show, btrfs_label_store);
816
817static ssize_t btrfs_nodesize_show(struct kobject *kobj,
818				struct kobj_attribute *a, char *buf)
819{
820	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
821
822	return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize);
823}
824
825BTRFS_ATTR(, nodesize, btrfs_nodesize_show);
826
827static ssize_t btrfs_sectorsize_show(struct kobject *kobj,
828				struct kobj_attribute *a, char *buf)
829{
830	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
831
832	return scnprintf(buf, PAGE_SIZE, "%u\n",
833			 fs_info->super_copy->sectorsize);
834}
835
836BTRFS_ATTR(, sectorsize, btrfs_sectorsize_show);
837
838static ssize_t btrfs_clone_alignment_show(struct kobject *kobj,
839				struct kobj_attribute *a, char *buf)
840{
841	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
842
843	return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize);
844}
845
846BTRFS_ATTR(, clone_alignment, btrfs_clone_alignment_show);
847
848static ssize_t quota_override_show(struct kobject *kobj,
849				   struct kobj_attribute *a, char *buf)
850{
851	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
852	int quota_override;
853
854	quota_override = test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);
855	return scnprintf(buf, PAGE_SIZE, "%d\n", quota_override);
856}
857
858static ssize_t quota_override_store(struct kobject *kobj,
859				    struct kobj_attribute *a,
860				    const char *buf, size_t len)
861{
862	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
863	unsigned long knob;
864	int err;
865
866	if (!fs_info)
867		return -EPERM;
868
869	if (!capable(CAP_SYS_RESOURCE))
870		return -EPERM;
871
872	err = kstrtoul(buf, 10, &knob);
873	if (err)
874		return err;
875	if (knob > 1)
876		return -EINVAL;
877
878	if (knob)
879		set_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);
880	else
881		clear_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);
882
883	return len;
884}
885
886BTRFS_ATTR_RW(, quota_override, quota_override_show, quota_override_store);
887
888static ssize_t btrfs_metadata_uuid_show(struct kobject *kobj,
889				struct kobj_attribute *a, char *buf)
890{
891	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
892
893	return scnprintf(buf, PAGE_SIZE, "%pU\n",
894			fs_info->fs_devices->metadata_uuid);
895}
896
897BTRFS_ATTR(, metadata_uuid, btrfs_metadata_uuid_show);
898
899static ssize_t btrfs_checksum_show(struct kobject *kobj,
900				   struct kobj_attribute *a, char *buf)
901{
902	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
903	u16 csum_type = btrfs_super_csum_type(fs_info->super_copy);
904
905	return scnprintf(buf, PAGE_SIZE, "%s (%s)\n",
906			btrfs_super_csum_name(csum_type),
907			crypto_shash_driver_name(fs_info->csum_shash));
908}
909
910BTRFS_ATTR(, checksum, btrfs_checksum_show);
911
912static ssize_t btrfs_exclusive_operation_show(struct kobject *kobj,
913		struct kobj_attribute *a, char *buf)
914{
915	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
916	const char *str;
917
918	switch (READ_ONCE(fs_info->exclusive_operation)) {
919		case  BTRFS_EXCLOP_NONE:
920			str = "none\n";
921			break;
922		case BTRFS_EXCLOP_BALANCE:
923			str = "balance\n";
924			break;
925		case BTRFS_EXCLOP_DEV_ADD:
926			str = "device add\n";
927			break;
928		case BTRFS_EXCLOP_DEV_REMOVE:
929			str = "device remove\n";
930			break;
931		case BTRFS_EXCLOP_DEV_REPLACE:
932			str = "device replace\n";
933			break;
934		case BTRFS_EXCLOP_RESIZE:
935			str = "resize\n";
936			break;
937		case BTRFS_EXCLOP_SWAP_ACTIVATE:
938			str = "swap activate\n";
939			break;
940		default:
941			str = "UNKNOWN\n";
942			break;
943	}
944	return scnprintf(buf, PAGE_SIZE, "%s", str);
945}
946BTRFS_ATTR(, exclusive_operation, btrfs_exclusive_operation_show);
947
948static ssize_t btrfs_generation_show(struct kobject *kobj,
949				     struct kobj_attribute *a, char *buf)
950{
951	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
952
953	return scnprintf(buf, PAGE_SIZE, "%llu\n", fs_info->generation);
954}
955BTRFS_ATTR(, generation, btrfs_generation_show);
956
957/*
958 * Look for an exact string @string in @buffer with possible leading or
959 * trailing whitespace
960 */
961static bool strmatch(const char *buffer, const char *string)
962{
963	const size_t len = strlen(string);
964
965	/* Skip leading whitespace */
966	buffer = skip_spaces(buffer);
967
968	/* Match entire string, check if the rest is whitespace or empty */
969	if (strncmp(string, buffer, len) == 0 &&
970	    strlen(skip_spaces(buffer + len)) == 0)
971		return true;
972
973	return false;
974}
975
976static const char * const btrfs_read_policy_name[] = { "pid" };
977
978static ssize_t btrfs_read_policy_show(struct kobject *kobj,
979				      struct kobj_attribute *a, char *buf)
980{
981	struct btrfs_fs_devices *fs_devices = to_fs_devs(kobj);
982	ssize_t ret = 0;
983	int i;
984
985	for (i = 0; i < BTRFS_NR_READ_POLICY; i++) {
986		if (fs_devices->read_policy == i)
987			ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s[%s]",
988					 (ret == 0 ? "" : " "),
989					 btrfs_read_policy_name[i]);
990		else
991			ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s",
992					 (ret == 0 ? "" : " "),
993					 btrfs_read_policy_name[i]);
994	}
995
996	ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
997
998	return ret;
999}
1000
1001static ssize_t btrfs_read_policy_store(struct kobject *kobj,
1002				       struct kobj_attribute *a,
1003				       const char *buf, size_t len)
1004{
1005	struct btrfs_fs_devices *fs_devices = to_fs_devs(kobj);
1006	int i;
1007
1008	for (i = 0; i < BTRFS_NR_READ_POLICY; i++) {
1009		if (strmatch(buf, btrfs_read_policy_name[i])) {
1010			if (i != fs_devices->read_policy) {
1011				fs_devices->read_policy = i;
1012				btrfs_info(fs_devices->fs_info,
1013					   "read policy set to '%s'",
1014					   btrfs_read_policy_name[i]);
1015			}
1016			return len;
1017		}
1018	}
1019
1020	return -EINVAL;
1021}
1022BTRFS_ATTR_RW(, read_policy, btrfs_read_policy_show, btrfs_read_policy_store);
1023
1024static ssize_t btrfs_bg_reclaim_threshold_show(struct kobject *kobj,
1025					       struct kobj_attribute *a,
1026					       char *buf)
1027{
1028	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
1029	ssize_t ret;
1030
1031	ret = scnprintf(buf, PAGE_SIZE, "%d\n",
1032			READ_ONCE(fs_info->bg_reclaim_threshold));
1033
1034	return ret;
1035}
1036
1037static ssize_t btrfs_bg_reclaim_threshold_store(struct kobject *kobj,
1038						struct kobj_attribute *a,
1039						const char *buf, size_t len)
1040{
1041	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
1042	int thresh;
1043	int ret;
1044
1045	ret = kstrtoint(buf, 10, &thresh);
1046	if (ret)
1047		return ret;
1048
1049	if (thresh != 0 && (thresh <= 50 || thresh > 100))
1050		return -EINVAL;
1051
1052	WRITE_ONCE(fs_info->bg_reclaim_threshold, thresh);
1053
1054	return len;
1055}
1056BTRFS_ATTR_RW(, bg_reclaim_threshold, btrfs_bg_reclaim_threshold_show,
1057	      btrfs_bg_reclaim_threshold_store);
1058
1059/*
1060 * Per-filesystem information and stats.
1061 *
1062 * Path: /sys/fs/btrfs/<uuid>/
1063 */
1064static const struct attribute *btrfs_attrs[] = {
1065	BTRFS_ATTR_PTR(, label),
1066	BTRFS_ATTR_PTR(, nodesize),
1067	BTRFS_ATTR_PTR(, sectorsize),
1068	BTRFS_ATTR_PTR(, clone_alignment),
1069	BTRFS_ATTR_PTR(, quota_override),
1070	BTRFS_ATTR_PTR(, metadata_uuid),
1071	BTRFS_ATTR_PTR(, checksum),
1072	BTRFS_ATTR_PTR(, exclusive_operation),
1073	BTRFS_ATTR_PTR(, generation),
1074	BTRFS_ATTR_PTR(, read_policy),
1075	BTRFS_ATTR_PTR(, bg_reclaim_threshold),
1076	NULL,
1077};
1078
1079static void btrfs_release_fsid_kobj(struct kobject *kobj)
1080{
1081	struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj);
1082
1083	memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject));
1084	complete(&fs_devs->kobj_unregister);
1085}
1086
1087static struct kobj_type btrfs_ktype = {
1088	.sysfs_ops	= &kobj_sysfs_ops,
1089	.release	= btrfs_release_fsid_kobj,
1090};
1091
1092static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj)
1093{
1094	if (kobj->ktype != &btrfs_ktype)
1095		return NULL;
1096	return container_of(kobj, struct btrfs_fs_devices, fsid_kobj);
1097}
1098
1099static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)
1100{
1101	if (kobj->ktype != &btrfs_ktype)
1102		return NULL;
1103	return to_fs_devs(kobj)->fs_info;
1104}
1105
1106#define NUM_FEATURE_BITS 64
1107#define BTRFS_FEATURE_NAME_MAX 13
1108static char btrfs_unknown_feature_names[FEAT_MAX][NUM_FEATURE_BITS][BTRFS_FEATURE_NAME_MAX];
1109static struct btrfs_feature_attr btrfs_feature_attrs[FEAT_MAX][NUM_FEATURE_BITS];
1110
1111static const u64 supported_feature_masks[FEAT_MAX] = {
1112	[FEAT_COMPAT]    = BTRFS_FEATURE_COMPAT_SUPP,
1113	[FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
1114	[FEAT_INCOMPAT]  = BTRFS_FEATURE_INCOMPAT_SUPP,
1115};
1116
1117static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add)
1118{
1119	int set;
1120
1121	for (set = 0; set < FEAT_MAX; set++) {
1122		int i;
1123		struct attribute *attrs[2];
1124		struct attribute_group agroup = {
1125			.name = "features",
1126			.attrs = attrs,
1127		};
1128		u64 features = get_features(fs_info, set);
1129		features &= ~supported_feature_masks[set];
1130
1131		if (!features)
1132			continue;
1133
1134		attrs[1] = NULL;
1135		for (i = 0; i < NUM_FEATURE_BITS; i++) {
1136			struct btrfs_feature_attr *fa;
1137
1138			if (!(features & (1ULL << i)))
1139				continue;
1140
1141			fa = &btrfs_feature_attrs[set][i];
1142			attrs[0] = &fa->kobj_attr.attr;
1143			if (add) {
1144				int ret;
1145				ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj,
1146							&agroup);
1147				if (ret)
1148					return ret;
1149			} else
1150				sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj,
1151						    &agroup);
1152		}
1153
1154	}
1155	return 0;
1156}
1157
1158static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs)
1159{
1160	if (fs_devs->devinfo_kobj) {
1161		kobject_del(fs_devs->devinfo_kobj);
1162		kobject_put(fs_devs->devinfo_kobj);
1163		fs_devs->devinfo_kobj = NULL;
1164	}
1165
1166	if (fs_devs->devices_kobj) {
1167		kobject_del(fs_devs->devices_kobj);
1168		kobject_put(fs_devs->devices_kobj);
1169		fs_devs->devices_kobj = NULL;
1170	}
1171
1172	if (fs_devs->fsid_kobj.state_initialized) {
1173		kobject_del(&fs_devs->fsid_kobj);
1174		kobject_put(&fs_devs->fsid_kobj);
1175		wait_for_completion(&fs_devs->kobj_unregister);
1176	}
1177}
1178
1179/* when fs_devs is NULL it will remove all fsid kobject */
1180void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs)
1181{
1182	struct list_head *fs_uuids = btrfs_get_fs_uuids();
1183
1184	if (fs_devs) {
1185		__btrfs_sysfs_remove_fsid(fs_devs);
1186		return;
1187	}
1188
1189	list_for_each_entry(fs_devs, fs_uuids, fs_list) {
1190		__btrfs_sysfs_remove_fsid(fs_devs);
1191	}
1192}
1193
1194static void btrfs_sysfs_remove_fs_devices(struct btrfs_fs_devices *fs_devices)
1195{
1196	struct btrfs_device *device;
1197	struct btrfs_fs_devices *seed;
1198
1199	list_for_each_entry(device, &fs_devices->devices, dev_list)
1200		btrfs_sysfs_remove_device(device);
1201
1202	list_for_each_entry(seed, &fs_devices->seed_list, seed_list) {
1203		list_for_each_entry(device, &seed->devices, dev_list)
1204			btrfs_sysfs_remove_device(device);
1205	}
1206}
1207
1208void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info)
1209{
1210	struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj;
1211
1212	sysfs_remove_link(fsid_kobj, "bdi");
1213
1214	if (fs_info->space_info_kobj) {
1215		sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs);
1216		kobject_del(fs_info->space_info_kobj);
1217		kobject_put(fs_info->space_info_kobj);
1218	}
1219#ifdef CONFIG_BTRFS_DEBUG
1220	if (fs_info->discard_debug_kobj) {
1221		sysfs_remove_files(fs_info->discard_debug_kobj,
1222				   discard_debug_attrs);
1223		kobject_del(fs_info->discard_debug_kobj);
1224		kobject_put(fs_info->discard_debug_kobj);
1225	}
1226	if (fs_info->debug_kobj) {
1227		sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs);
1228		kobject_del(fs_info->debug_kobj);
1229		kobject_put(fs_info->debug_kobj);
1230	}
1231#endif
1232	addrm_unknown_feature_attrs(fs_info, false);
1233	sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group);
1234	sysfs_remove_files(fsid_kobj, btrfs_attrs);
1235	btrfs_sysfs_remove_fs_devices(fs_info->fs_devices);
1236}
1237
1238static const char * const btrfs_feature_set_names[FEAT_MAX] = {
1239	[FEAT_COMPAT]	 = "compat",
1240	[FEAT_COMPAT_RO] = "compat_ro",
1241	[FEAT_INCOMPAT]	 = "incompat",
1242};
1243
1244const char *btrfs_feature_set_name(enum btrfs_feature_set set)
1245{
1246	return btrfs_feature_set_names[set];
1247}
1248
1249char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags)
1250{
1251	size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */
1252	int len = 0;
1253	int i;
1254	char *str;
1255
1256	str = kmalloc(bufsize, GFP_KERNEL);
1257	if (!str)
1258		return str;
1259
1260	for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
1261		const char *name;
1262
1263		if (!(flags & (1ULL << i)))
1264			continue;
1265
1266		name = btrfs_feature_attrs[set][i].kobj_attr.attr.name;
1267		len += scnprintf(str + len, bufsize - len, "%s%s",
1268				len ? "," : "", name);
1269	}
1270
1271	return str;
1272}
1273
1274static void init_feature_attrs(void)
1275{
1276	struct btrfs_feature_attr *fa;
1277	int set, i;
1278
1279	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) !=
1280		     ARRAY_SIZE(btrfs_feature_attrs));
1281	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) !=
1282		     ARRAY_SIZE(btrfs_feature_attrs[0]));
1283
1284	memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs));
1285	memset(btrfs_unknown_feature_names, 0,
1286	       sizeof(btrfs_unknown_feature_names));
1287
1288	for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
1289		struct btrfs_feature_attr *sfa;
1290		struct attribute *a = btrfs_supported_feature_attrs[i];
1291		int bit;
1292		sfa = attr_to_btrfs_feature_attr(a);
1293		bit = ilog2(sfa->feature_bit);
1294		fa = &btrfs_feature_attrs[sfa->feature_set][bit];
1295
1296		fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name;
1297	}
1298
1299	for (set = 0; set < FEAT_MAX; set++) {
1300		for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
1301			char *name = btrfs_unknown_feature_names[set][i];
1302			fa = &btrfs_feature_attrs[set][i];
1303
1304			if (fa->kobj_attr.attr.name)
1305				continue;
1306
1307			snprintf(name, BTRFS_FEATURE_NAME_MAX, "%s:%u",
1308				 btrfs_feature_set_names[set], i);
1309
1310			fa->kobj_attr.attr.name = name;
1311			fa->kobj_attr.attr.mode = S_IRUGO;
1312			fa->feature_set = set;
1313			fa->feature_bit = 1ULL << i;
1314		}
1315	}
1316}
1317
1318/*
1319 * Create a sysfs entry for a given block group type at path
1320 * /sys/fs/btrfs/UUID/allocation/data/TYPE
1321 */
1322void btrfs_sysfs_add_block_group_type(struct btrfs_block_group *cache)
1323{
1324	struct btrfs_fs_info *fs_info = cache->fs_info;
1325	struct btrfs_space_info *space_info = cache->space_info;
1326	struct raid_kobject *rkobj;
1327	const int index = btrfs_bg_flags_to_raid_index(cache->flags);
1328	unsigned int nofs_flag;
1329	int ret;
1330
1331	/*
1332	 * Setup a NOFS context because kobject_add(), deep in its call chain,
1333	 * does GFP_KERNEL allocations, and we are often called in a context
1334	 * where if reclaim is triggered we can deadlock (we are either holding
1335	 * a transaction handle or some lock required for a transaction
1336	 * commit).
1337	 */
1338	nofs_flag = memalloc_nofs_save();
1339
1340	rkobj = kzalloc(sizeof(*rkobj), GFP_NOFS);
1341	if (!rkobj) {
1342		memalloc_nofs_restore(nofs_flag);
1343		btrfs_warn(cache->fs_info,
1344				"couldn't alloc memory for raid level kobject");
1345		return;
1346	}
1347
1348	rkobj->flags = cache->flags;
1349	kobject_init(&rkobj->kobj, &btrfs_raid_ktype);
1350
1351	/*
1352	 * We call this either on mount, or if we've created a block group for a
1353	 * new index type while running (i.e. when restriping).  The running
1354	 * case is tricky because we could race with other threads, so we need
1355	 * to have this check to make sure we didn't already init the kobject.
1356	 *
1357	 * We don't have to protect on the free side because it only happens on
1358	 * unmount.
1359	 */
1360	spin_lock(&space_info->lock);
1361	if (space_info->block_group_kobjs[index]) {
1362		spin_unlock(&space_info->lock);
1363		kobject_put(&rkobj->kobj);
1364		return;
1365	} else {
1366		space_info->block_group_kobjs[index] = &rkobj->kobj;
1367	}
1368	spin_unlock(&space_info->lock);
1369
1370	ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s",
1371			  btrfs_bg_type_to_raid_name(rkobj->flags));
1372	memalloc_nofs_restore(nofs_flag);
1373	if (ret) {
1374		spin_lock(&space_info->lock);
1375		space_info->block_group_kobjs[index] = NULL;
1376		spin_unlock(&space_info->lock);
1377		kobject_put(&rkobj->kobj);
1378		btrfs_warn(fs_info,
1379			"failed to add kobject for block cache, ignoring");
1380		return;
1381	}
1382}
1383
1384/*
1385 * Remove sysfs directories for all block group types of a given space info and
1386 * the space info as well
1387 */
1388void btrfs_sysfs_remove_space_info(struct btrfs_space_info *space_info)
1389{
1390	int i;
1391
1392	for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
1393		struct kobject *kobj;
1394
1395		kobj = space_info->block_group_kobjs[i];
1396		space_info->block_group_kobjs[i] = NULL;
1397		if (kobj) {
1398			kobject_del(kobj);
1399			kobject_put(kobj);
1400		}
1401	}
1402	kobject_del(&space_info->kobj);
1403	kobject_put(&space_info->kobj);
1404}
1405
1406static const char *alloc_name(u64 flags)
1407{
1408	switch (flags) {
1409	case BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA:
1410		return "mixed";
1411	case BTRFS_BLOCK_GROUP_METADATA:
1412		return "metadata";
1413	case BTRFS_BLOCK_GROUP_DATA:
1414		return "data";
1415	case BTRFS_BLOCK_GROUP_SYSTEM:
1416		return "system";
1417	default:
1418		WARN_ON(1);
1419		return "invalid-combination";
1420	}
1421}
1422
1423/*
1424 * Create a sysfs entry for a space info type at path
1425 * /sys/fs/btrfs/UUID/allocation/TYPE
1426 */
1427int btrfs_sysfs_add_space_info_type(struct btrfs_fs_info *fs_info,
1428				    struct btrfs_space_info *space_info)
1429{
1430	int ret;
1431
1432	ret = kobject_init_and_add(&space_info->kobj, &space_info_ktype,
1433				   fs_info->space_info_kobj, "%s",
1434				   alloc_name(space_info->flags));
1435	if (ret) {
1436		kobject_put(&space_info->kobj);
1437		return ret;
1438	}
1439
1440	return 0;
1441}
1442
1443void btrfs_sysfs_remove_device(struct btrfs_device *device)
1444{
1445	struct kobject *devices_kobj;
1446
1447	/*
1448	 * Seed fs_devices devices_kobj aren't used, fetch kobject from the
1449	 * fs_info::fs_devices.
1450	 */
1451	devices_kobj = device->fs_info->fs_devices->devices_kobj;
1452	ASSERT(devices_kobj);
1453
1454	if (device->bdev)
1455		sysfs_remove_link(devices_kobj, bdev_kobj(device->bdev)->name);
1456
1457	if (device->devid_kobj.state_initialized) {
1458		kobject_del(&device->devid_kobj);
1459		kobject_put(&device->devid_kobj);
1460		wait_for_completion(&device->kobj_unregister);
1461	}
1462}
1463
1464static ssize_t btrfs_devinfo_in_fs_metadata_show(struct kobject *kobj,
1465					         struct kobj_attribute *a,
1466					         char *buf)
1467{
1468	int val;
1469	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1470						   devid_kobj);
1471
1472	val = !!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
1473
1474	return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1475}
1476BTRFS_ATTR(devid, in_fs_metadata, btrfs_devinfo_in_fs_metadata_show);
1477
1478static ssize_t btrfs_devinfo_missing_show(struct kobject *kobj,
1479					struct kobj_attribute *a, char *buf)
1480{
1481	int val;
1482	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1483						   devid_kobj);
1484
1485	val = !!test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state);
1486
1487	return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1488}
1489BTRFS_ATTR(devid, missing, btrfs_devinfo_missing_show);
1490
1491static ssize_t btrfs_devinfo_replace_target_show(struct kobject *kobj,
1492					         struct kobj_attribute *a,
1493					         char *buf)
1494{
1495	int val;
1496	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1497						   devid_kobj);
1498
1499	val = !!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
1500
1501	return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1502}
1503BTRFS_ATTR(devid, replace_target, btrfs_devinfo_replace_target_show);
1504
1505static ssize_t btrfs_devinfo_scrub_speed_max_show(struct kobject *kobj,
1506					     struct kobj_attribute *a,
1507					     char *buf)
1508{
1509	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1510						   devid_kobj);
1511
1512	return scnprintf(buf, PAGE_SIZE, "%llu\n",
1513			 READ_ONCE(device->scrub_speed_max));
1514}
1515
1516static ssize_t btrfs_devinfo_scrub_speed_max_store(struct kobject *kobj,
1517					      struct kobj_attribute *a,
1518					      const char *buf, size_t len)
1519{
1520	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1521						   devid_kobj);
1522	char *endptr;
1523	unsigned long long limit;
1524
1525	limit = memparse(buf, &endptr);
1526	WRITE_ONCE(device->scrub_speed_max, limit);
1527	return len;
1528}
1529BTRFS_ATTR_RW(devid, scrub_speed_max, btrfs_devinfo_scrub_speed_max_show,
1530	      btrfs_devinfo_scrub_speed_max_store);
1531
1532static ssize_t btrfs_devinfo_writeable_show(struct kobject *kobj,
1533					    struct kobj_attribute *a, char *buf)
1534{
1535	int val;
1536	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1537						   devid_kobj);
1538
1539	val = !!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);
1540
1541	return scnprintf(buf, PAGE_SIZE, "%d\n", val);
1542}
1543BTRFS_ATTR(devid, writeable, btrfs_devinfo_writeable_show);
1544
1545static ssize_t btrfs_devinfo_error_stats_show(struct kobject *kobj,
1546		struct kobj_attribute *a, char *buf)
1547{
1548	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1549						   devid_kobj);
1550
1551	if (!device->dev_stats_valid)
1552		return scnprintf(buf, PAGE_SIZE, "invalid\n");
1553
1554	/*
1555	 * Print all at once so we get a snapshot of all values from the same
1556	 * time. Keep them in sync and in order of definition of
1557	 * btrfs_dev_stat_values.
1558	 */
1559	return scnprintf(buf, PAGE_SIZE,
1560		"write_errs %d\n"
1561		"read_errs %d\n"
1562		"flush_errs %d\n"
1563		"corruption_errs %d\n"
1564		"generation_errs %d\n",
1565		btrfs_dev_stat_read(device, BTRFS_DEV_STAT_WRITE_ERRS),
1566		btrfs_dev_stat_read(device, BTRFS_DEV_STAT_READ_ERRS),
1567		btrfs_dev_stat_read(device, BTRFS_DEV_STAT_FLUSH_ERRS),
1568		btrfs_dev_stat_read(device, BTRFS_DEV_STAT_CORRUPTION_ERRS),
1569		btrfs_dev_stat_read(device, BTRFS_DEV_STAT_GENERATION_ERRS));
1570}
1571BTRFS_ATTR(devid, error_stats, btrfs_devinfo_error_stats_show);
1572
1573/*
1574 * Information about one device.
1575 *
1576 * Path: /sys/fs/btrfs/<uuid>/devinfo/<devid>/
1577 */
1578static struct attribute *devid_attrs[] = {
1579	BTRFS_ATTR_PTR(devid, error_stats),
1580	BTRFS_ATTR_PTR(devid, in_fs_metadata),
1581	BTRFS_ATTR_PTR(devid, missing),
1582	BTRFS_ATTR_PTR(devid, replace_target),
1583	BTRFS_ATTR_PTR(devid, scrub_speed_max),
1584	BTRFS_ATTR_PTR(devid, writeable),
1585	NULL
1586};
1587ATTRIBUTE_GROUPS(devid);
1588
1589static void btrfs_release_devid_kobj(struct kobject *kobj)
1590{
1591	struct btrfs_device *device = container_of(kobj, struct btrfs_device,
1592						   devid_kobj);
1593
1594	memset(&device->devid_kobj, 0, sizeof(struct kobject));
1595	complete(&device->kobj_unregister);
1596}
1597
1598static struct kobj_type devid_ktype = {
1599	.sysfs_ops	= &kobj_sysfs_ops,
1600	.default_groups = devid_groups,
1601	.release	= btrfs_release_devid_kobj,
1602};
1603
1604int btrfs_sysfs_add_device(struct btrfs_device *device)
1605{
1606	int ret;
1607	unsigned int nofs_flag;
1608	struct kobject *devices_kobj;
1609	struct kobject *devinfo_kobj;
1610
1611	/*
1612	 * Make sure we use the fs_info::fs_devices to fetch the kobjects even
1613	 * for the seed fs_devices
1614	 */
1615	devices_kobj = device->fs_info->fs_devices->devices_kobj;
1616	devinfo_kobj = device->fs_info->fs_devices->devinfo_kobj;
1617	ASSERT(devices_kobj);
1618	ASSERT(devinfo_kobj);
1619
1620	nofs_flag = memalloc_nofs_save();
1621
1622	if (device->bdev) {
1623		struct kobject *disk_kobj = bdev_kobj(device->bdev);
1624
1625		ret = sysfs_create_link(devices_kobj, disk_kobj, disk_kobj->name);
1626		if (ret) {
1627			btrfs_warn(device->fs_info,
1628				"creating sysfs device link for devid %llu failed: %d",
1629				device->devid, ret);
1630			goto out;
1631		}
1632	}
1633
1634	init_completion(&device->kobj_unregister);
1635	ret = kobject_init_and_add(&device->devid_kobj, &devid_ktype,
1636				   devinfo_kobj, "%llu", device->devid);
1637	if (ret) {
1638		kobject_put(&device->devid_kobj);
1639		btrfs_warn(device->fs_info,
1640			   "devinfo init for devid %llu failed: %d",
1641			   device->devid, ret);
1642	}
1643
1644out:
1645	memalloc_nofs_restore(nofs_flag);
1646	return ret;
1647}
1648
1649static int btrfs_sysfs_add_fs_devices(struct btrfs_fs_devices *fs_devices)
1650{
1651	int ret;
1652	struct btrfs_device *device;
1653	struct btrfs_fs_devices *seed;
1654
1655	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1656		ret = btrfs_sysfs_add_device(device);
1657		if (ret)
1658			goto fail;
1659	}
1660
1661	list_for_each_entry(seed, &fs_devices->seed_list, seed_list) {
1662		list_for_each_entry(device, &seed->devices, dev_list) {
1663			ret = btrfs_sysfs_add_device(device);
1664			if (ret)
1665				goto fail;
1666		}
1667	}
1668
1669	return 0;
1670
1671fail:
1672	btrfs_sysfs_remove_fs_devices(fs_devices);
1673	return ret;
1674}
1675
1676void btrfs_kobject_uevent(struct block_device *bdev, enum kobject_action action)
1677{
1678	int ret;
1679
1680	ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
1681	if (ret)
1682		pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
1683			action, kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
1684			&disk_to_dev(bdev->bd_disk)->kobj);
1685}
1686
1687void btrfs_sysfs_update_sprout_fsid(struct btrfs_fs_devices *fs_devices)
1688
1689{
1690	char fsid_buf[BTRFS_UUID_UNPARSED_SIZE];
1691
1692	/*
1693	 * Sprouting changes fsid of the mounted filesystem, rename the fsid
1694	 * directory
1695	 */
1696	snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU", fs_devices->fsid);
1697	if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf))
1698		btrfs_warn(fs_devices->fs_info,
1699				"sysfs: failed to create fsid for sprout");
1700}
1701
1702void btrfs_sysfs_update_devid(struct btrfs_device *device)
1703{
1704	char tmp[24];
1705
1706	snprintf(tmp, sizeof(tmp), "%llu", device->devid);
1707
1708	if (kobject_rename(&device->devid_kobj, tmp))
1709		btrfs_warn(device->fs_devices->fs_info,
1710			   "sysfs: failed to update devid for %llu",
1711			   device->devid);
1712}
1713
1714/* /sys/fs/btrfs/ entry */
1715static struct kset *btrfs_kset;
1716
1717/*
1718 * Creates:
1719 *		/sys/fs/btrfs/UUID
1720 *
1721 * Can be called by the device discovery thread.
1722 */
1723int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs)
1724{
1725	int error;
1726
1727	init_completion(&fs_devs->kobj_unregister);
1728	fs_devs->fsid_kobj.kset = btrfs_kset;
1729	error = kobject_init_and_add(&fs_devs->fsid_kobj, &btrfs_ktype, NULL,
1730				     "%pU", fs_devs->fsid);
1731	if (error) {
1732		kobject_put(&fs_devs->fsid_kobj);
1733		return error;
1734	}
1735
1736	fs_devs->devices_kobj = kobject_create_and_add("devices",
1737						       &fs_devs->fsid_kobj);
1738	if (!fs_devs->devices_kobj) {
1739		btrfs_err(fs_devs->fs_info,
1740			  "failed to init sysfs device interface");
1741		btrfs_sysfs_remove_fsid(fs_devs);
1742		return -ENOMEM;
1743	}
1744
1745	fs_devs->devinfo_kobj = kobject_create_and_add("devinfo",
1746						       &fs_devs->fsid_kobj);
1747	if (!fs_devs->devinfo_kobj) {
1748		btrfs_err(fs_devs->fs_info,
1749			  "failed to init sysfs devinfo kobject");
1750		btrfs_sysfs_remove_fsid(fs_devs);
1751		return -ENOMEM;
1752	}
1753
1754	return 0;
1755}
1756
1757int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info)
1758{
1759	int error;
1760	struct btrfs_fs_devices *fs_devs = fs_info->fs_devices;
1761	struct kobject *fsid_kobj = &fs_devs->fsid_kobj;
1762
1763	error = btrfs_sysfs_add_fs_devices(fs_devs);
1764	if (error)
1765		return error;
1766
1767	error = sysfs_create_files(fsid_kobj, btrfs_attrs);
1768	if (error) {
1769		btrfs_sysfs_remove_fs_devices(fs_devs);
1770		return error;
1771	}
1772
1773	error = sysfs_create_group(fsid_kobj,
1774				   &btrfs_feature_attr_group);
1775	if (error)
1776		goto failure;
1777
1778#ifdef CONFIG_BTRFS_DEBUG
1779	fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj);
1780	if (!fs_info->debug_kobj) {
1781		error = -ENOMEM;
1782		goto failure;
1783	}
1784
1785	error = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs);
1786	if (error)
1787		goto failure;
1788
1789	/* Discard directory */
1790	fs_info->discard_debug_kobj = kobject_create_and_add("discard",
1791						     fs_info->debug_kobj);
1792	if (!fs_info->discard_debug_kobj) {
1793		error = -ENOMEM;
1794		goto failure;
1795	}
1796
1797	error = sysfs_create_files(fs_info->discard_debug_kobj,
1798				   discard_debug_attrs);
1799	if (error)
1800		goto failure;
1801#endif
1802
1803	error = addrm_unknown_feature_attrs(fs_info, true);
1804	if (error)
1805		goto failure;
1806
1807	error = sysfs_create_link(fsid_kobj, &fs_info->sb->s_bdi->dev->kobj, "bdi");
1808	if (error)
1809		goto failure;
1810
1811	fs_info->space_info_kobj = kobject_create_and_add("allocation",
1812						  fsid_kobj);
1813	if (!fs_info->space_info_kobj) {
1814		error = -ENOMEM;
1815		goto failure;
1816	}
1817
1818	error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs);
1819	if (error)
1820		goto failure;
1821
1822	return 0;
1823failure:
1824	btrfs_sysfs_remove_mounted(fs_info);
1825	return error;
1826}
1827
1828static inline struct btrfs_fs_info *qgroup_kobj_to_fs_info(struct kobject *kobj)
1829{
1830	return to_fs_info(kobj->parent->parent);
1831}
1832
1833#define QGROUP_ATTR(_member, _show_name)					\
1834static ssize_t btrfs_qgroup_show_##_member(struct kobject *qgroup_kobj,		\
1835					   struct kobj_attribute *a,		\
1836					   char *buf)				\
1837{										\
1838	struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj);	\
1839	struct btrfs_qgroup *qgroup = container_of(qgroup_kobj,			\
1840			struct btrfs_qgroup, kobj);				\
1841	return btrfs_show_u64(&qgroup->_member, &fs_info->qgroup_lock, buf);	\
1842}										\
1843BTRFS_ATTR(qgroup, _show_name, btrfs_qgroup_show_##_member)
1844
1845#define QGROUP_RSV_ATTR(_name, _type)						\
1846static ssize_t btrfs_qgroup_rsv_show_##_name(struct kobject *qgroup_kobj,	\
1847					     struct kobj_attribute *a,		\
1848					     char *buf)				\
1849{										\
1850	struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj);	\
1851	struct btrfs_qgroup *qgroup = container_of(qgroup_kobj,			\
1852			struct btrfs_qgroup, kobj);				\
1853	return btrfs_show_u64(&qgroup->rsv.values[_type],			\
1854			&fs_info->qgroup_lock, buf);				\
1855}										\
1856BTRFS_ATTR(qgroup, rsv_##_name, btrfs_qgroup_rsv_show_##_name)
1857
1858QGROUP_ATTR(rfer, referenced);
1859QGROUP_ATTR(excl, exclusive);
1860QGROUP_ATTR(max_rfer, max_referenced);
1861QGROUP_ATTR(max_excl, max_exclusive);
1862QGROUP_ATTR(lim_flags, limit_flags);
1863QGROUP_RSV_ATTR(data, BTRFS_QGROUP_RSV_DATA);
1864QGROUP_RSV_ATTR(meta_pertrans, BTRFS_QGROUP_RSV_META_PERTRANS);
1865QGROUP_RSV_ATTR(meta_prealloc, BTRFS_QGROUP_RSV_META_PREALLOC);
1866
1867/*
1868 * Qgroup information.
1869 *
1870 * Path: /sys/fs/btrfs/<uuid>/qgroups/<level>_<qgroupid>/
1871 */
1872static struct attribute *qgroup_attrs[] = {
1873	BTRFS_ATTR_PTR(qgroup, referenced),
1874	BTRFS_ATTR_PTR(qgroup, exclusive),
1875	BTRFS_ATTR_PTR(qgroup, max_referenced),
1876	BTRFS_ATTR_PTR(qgroup, max_exclusive),
1877	BTRFS_ATTR_PTR(qgroup, limit_flags),
1878	BTRFS_ATTR_PTR(qgroup, rsv_data),
1879	BTRFS_ATTR_PTR(qgroup, rsv_meta_pertrans),
1880	BTRFS_ATTR_PTR(qgroup, rsv_meta_prealloc),
1881	NULL
1882};
1883ATTRIBUTE_GROUPS(qgroup);
1884
1885static void qgroup_release(struct kobject *kobj)
1886{
1887	struct btrfs_qgroup *qgroup = container_of(kobj, struct btrfs_qgroup, kobj);
1888
1889	memset(&qgroup->kobj, 0, sizeof(*kobj));
1890}
1891
1892static struct kobj_type qgroup_ktype = {
1893	.sysfs_ops = &kobj_sysfs_ops,
1894	.release = qgroup_release,
1895	.default_groups = qgroup_groups,
1896};
1897
1898int btrfs_sysfs_add_one_qgroup(struct btrfs_fs_info *fs_info,
1899				struct btrfs_qgroup *qgroup)
1900{
1901	struct kobject *qgroups_kobj = fs_info->qgroups_kobj;
1902	int ret;
1903
1904	if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
1905		return 0;
1906	if (qgroup->kobj.state_initialized)
1907		return 0;
1908	if (!qgroups_kobj)
1909		return -EINVAL;
1910
1911	ret = kobject_init_and_add(&qgroup->kobj, &qgroup_ktype, qgroups_kobj,
1912			"%hu_%llu", btrfs_qgroup_level(qgroup->qgroupid),
1913			btrfs_qgroup_subvolid(qgroup->qgroupid));
1914	if (ret < 0)
1915		kobject_put(&qgroup->kobj);
1916
1917	return ret;
1918}
1919
1920void btrfs_sysfs_del_qgroups(struct btrfs_fs_info *fs_info)
1921{
1922	struct btrfs_qgroup *qgroup;
1923	struct btrfs_qgroup *next;
1924
1925	if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
1926		return;
1927
1928	rbtree_postorder_for_each_entry_safe(qgroup, next,
1929					     &fs_info->qgroup_tree, node)
1930		btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
1931	if (fs_info->qgroups_kobj) {
1932		kobject_del(fs_info->qgroups_kobj);
1933		kobject_put(fs_info->qgroups_kobj);
1934		fs_info->qgroups_kobj = NULL;
1935	}
1936}
1937
1938/* Called when qgroups get initialized, thus there is no need for locking */
1939int btrfs_sysfs_add_qgroups(struct btrfs_fs_info *fs_info)
1940{
1941	struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj;
1942	struct btrfs_qgroup *qgroup;
1943	struct btrfs_qgroup *next;
1944	int ret = 0;
1945
1946	if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
1947		return 0;
1948
1949	ASSERT(fsid_kobj);
1950	if (fs_info->qgroups_kobj)
1951		return 0;
1952
1953	fs_info->qgroups_kobj = kobject_create_and_add("qgroups", fsid_kobj);
1954	if (!fs_info->qgroups_kobj) {
1955		ret = -ENOMEM;
1956		goto out;
1957	}
1958	rbtree_postorder_for_each_entry_safe(qgroup, next,
1959					     &fs_info->qgroup_tree, node) {
1960		ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1961		if (ret < 0)
1962			goto out;
1963	}
1964
1965out:
1966	if (ret < 0)
1967		btrfs_sysfs_del_qgroups(fs_info);
1968	return ret;
1969}
1970
1971void btrfs_sysfs_del_one_qgroup(struct btrfs_fs_info *fs_info,
1972				struct btrfs_qgroup *qgroup)
1973{
1974	if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
1975		return;
1976
1977	if (qgroup->kobj.state_initialized) {
1978		kobject_del(&qgroup->kobj);
1979		kobject_put(&qgroup->kobj);
1980	}
1981}
1982
1983/*
1984 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current
1985 * values in superblock. Call after any changes to incompat/compat_ro flags
1986 */
1987void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info,
1988		u64 bit, enum btrfs_feature_set set)
1989{
1990	struct btrfs_fs_devices *fs_devs;
1991	struct kobject *fsid_kobj;
1992	u64 __maybe_unused features;
1993	int __maybe_unused ret;
1994
1995	if (!fs_info)
1996		return;
1997
1998	/*
1999	 * See 14e46e04958df74 and e410e34fad913dd, feature bit updates are not
2000	 * safe when called from some contexts (eg. balance)
2001	 */
2002	features = get_features(fs_info, set);
2003	ASSERT(bit & supported_feature_masks[set]);
2004
2005	fs_devs = fs_info->fs_devices;
2006	fsid_kobj = &fs_devs->fsid_kobj;
2007
2008	if (!fsid_kobj->state_initialized)
2009		return;
2010
2011	/*
2012	 * FIXME: this is too heavy to update just one value, ideally we'd like
2013	 * to use sysfs_update_group but some refactoring is needed first.
2014	 */
2015	sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group);
2016	ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group);
2017}
2018
2019int __init btrfs_init_sysfs(void)
2020{
2021	int ret;
2022
2023	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
2024	if (!btrfs_kset)
2025		return -ENOMEM;
2026
2027	init_feature_attrs();
2028	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
2029	if (ret)
2030		goto out2;
2031	ret = sysfs_merge_group(&btrfs_kset->kobj,
2032				&btrfs_static_feature_attr_group);
2033	if (ret)
2034		goto out_remove_group;
2035
2036#ifdef CONFIG_BTRFS_DEBUG
2037	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group);
2038	if (ret)
2039		goto out2;
2040#endif
2041
2042	return 0;
2043
2044out_remove_group:
2045	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
2046out2:
2047	kset_unregister(btrfs_kset);
2048
2049	return ret;
2050}
2051
2052void __cold btrfs_exit_sysfs(void)
2053{
2054	sysfs_unmerge_group(&btrfs_kset->kobj,
2055			    &btrfs_static_feature_attr_group);
2056	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
2057#ifdef CONFIG_BTRFS_DEBUG
2058	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group);
2059#endif
2060	kset_unregister(btrfs_kset);
2061}
2062
2063