xref: /openbmc/linux/fs/btrfs/sysfs.c (revision b34e08d5)
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18 
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/spinlock.h>
22 #include <linux/completion.h>
23 #include <linux/buffer_head.h>
24 #include <linux/kobject.h>
25 #include <linux/bug.h>
26 #include <linux/genhd.h>
27 #include <linux/debugfs.h>
28 
29 #include "ctree.h"
30 #include "disk-io.h"
31 #include "transaction.h"
32 #include "sysfs.h"
33 #include "volumes.h"
34 
35 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj);
36 
37 static u64 get_features(struct btrfs_fs_info *fs_info,
38 			enum btrfs_feature_set set)
39 {
40 	struct btrfs_super_block *disk_super = fs_info->super_copy;
41 	if (set == FEAT_COMPAT)
42 		return btrfs_super_compat_flags(disk_super);
43 	else if (set == FEAT_COMPAT_RO)
44 		return btrfs_super_compat_ro_flags(disk_super);
45 	else
46 		return btrfs_super_incompat_flags(disk_super);
47 }
48 
49 static void set_features(struct btrfs_fs_info *fs_info,
50 			 enum btrfs_feature_set set, u64 features)
51 {
52 	struct btrfs_super_block *disk_super = fs_info->super_copy;
53 	if (set == FEAT_COMPAT)
54 		btrfs_set_super_compat_flags(disk_super, features);
55 	else if (set == FEAT_COMPAT_RO)
56 		btrfs_set_super_compat_ro_flags(disk_super, features);
57 	else
58 		btrfs_set_super_incompat_flags(disk_super, features);
59 }
60 
61 static int can_modify_feature(struct btrfs_feature_attr *fa)
62 {
63 	int val = 0;
64 	u64 set, clear;
65 	switch (fa->feature_set) {
66 	case FEAT_COMPAT:
67 		set = BTRFS_FEATURE_COMPAT_SAFE_SET;
68 		clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
69 		break;
70 	case FEAT_COMPAT_RO:
71 		set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
72 		clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
73 		break;
74 	case FEAT_INCOMPAT:
75 		set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
76 		clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
77 		break;
78 	default:
79 		printk(KERN_WARNING "btrfs: sysfs: unknown feature set %d\n",
80 				fa->feature_set);
81 		return 0;
82 	}
83 
84 	if (set & fa->feature_bit)
85 		val |= 1;
86 	if (clear & fa->feature_bit)
87 		val |= 2;
88 
89 	return val;
90 }
91 
92 static ssize_t btrfs_feature_attr_show(struct kobject *kobj,
93 				       struct kobj_attribute *a, char *buf)
94 {
95 	int val = 0;
96 	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
97 	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
98 	if (fs_info) {
99 		u64 features = get_features(fs_info, fa->feature_set);
100 		if (features & fa->feature_bit)
101 			val = 1;
102 	} else
103 		val = can_modify_feature(fa);
104 
105 	return snprintf(buf, PAGE_SIZE, "%d\n", val);
106 }
107 
108 static ssize_t btrfs_feature_attr_store(struct kobject *kobj,
109 					struct kobj_attribute *a,
110 					const char *buf, size_t count)
111 {
112 	struct btrfs_fs_info *fs_info;
113 	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
114 	struct btrfs_trans_handle *trans;
115 	u64 features, set, clear;
116 	unsigned long val;
117 	int ret;
118 
119 	fs_info = to_fs_info(kobj);
120 	if (!fs_info)
121 		return -EPERM;
122 
123 	ret = kstrtoul(skip_spaces(buf), 0, &val);
124 	if (ret)
125 		return ret;
126 
127 	if (fa->feature_set == FEAT_COMPAT) {
128 		set = BTRFS_FEATURE_COMPAT_SAFE_SET;
129 		clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
130 	} else if (fa->feature_set == FEAT_COMPAT_RO) {
131 		set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
132 		clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
133 	} else {
134 		set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
135 		clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
136 	}
137 
138 	features = get_features(fs_info, fa->feature_set);
139 
140 	/* Nothing to do */
141 	if ((val && (features & fa->feature_bit)) ||
142 	    (!val && !(features & fa->feature_bit)))
143 		return count;
144 
145 	if ((val && !(set & fa->feature_bit)) ||
146 	    (!val && !(clear & fa->feature_bit))) {
147 		btrfs_info(fs_info,
148 			"%sabling feature %s on mounted fs is not supported.",
149 			val ? "En" : "Dis", fa->kobj_attr.attr.name);
150 		return -EPERM;
151 	}
152 
153 	btrfs_info(fs_info, "%s %s feature flag",
154 		   val ? "Setting" : "Clearing", fa->kobj_attr.attr.name);
155 
156 	trans = btrfs_start_transaction(fs_info->fs_root, 0);
157 	if (IS_ERR(trans))
158 		return PTR_ERR(trans);
159 
160 	spin_lock(&fs_info->super_lock);
161 	features = get_features(fs_info, fa->feature_set);
162 	if (val)
163 		features |= fa->feature_bit;
164 	else
165 		features &= ~fa->feature_bit;
166 	set_features(fs_info, fa->feature_set, features);
167 	spin_unlock(&fs_info->super_lock);
168 
169 	ret = btrfs_commit_transaction(trans, fs_info->fs_root);
170 	if (ret)
171 		return ret;
172 
173 	return count;
174 }
175 
176 static umode_t btrfs_feature_visible(struct kobject *kobj,
177 				     struct attribute *attr, int unused)
178 {
179 	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
180 	umode_t mode = attr->mode;
181 
182 	if (fs_info) {
183 		struct btrfs_feature_attr *fa;
184 		u64 features;
185 
186 		fa = attr_to_btrfs_feature_attr(attr);
187 		features = get_features(fs_info, fa->feature_set);
188 
189 		if (can_modify_feature(fa))
190 			mode |= S_IWUSR;
191 		else if (!(features & fa->feature_bit))
192 			mode = 0;
193 	}
194 
195 	return mode;
196 }
197 
198 BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF);
199 BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);
200 BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);
201 BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);
202 BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
203 BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
204 BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
205 BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);
206 BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES);
207 
208 static struct attribute *btrfs_supported_feature_attrs[] = {
209 	BTRFS_FEAT_ATTR_PTR(mixed_backref),
210 	BTRFS_FEAT_ATTR_PTR(default_subvol),
211 	BTRFS_FEAT_ATTR_PTR(mixed_groups),
212 	BTRFS_FEAT_ATTR_PTR(compress_lzo),
213 	BTRFS_FEAT_ATTR_PTR(big_metadata),
214 	BTRFS_FEAT_ATTR_PTR(extended_iref),
215 	BTRFS_FEAT_ATTR_PTR(raid56),
216 	BTRFS_FEAT_ATTR_PTR(skinny_metadata),
217 	BTRFS_FEAT_ATTR_PTR(no_holes),
218 	NULL
219 };
220 
221 static const struct attribute_group btrfs_feature_attr_group = {
222 	.name = "features",
223 	.is_visible = btrfs_feature_visible,
224 	.attrs = btrfs_supported_feature_attrs,
225 };
226 
227 static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf)
228 {
229 	u64 val;
230 	if (lock)
231 		spin_lock(lock);
232 	val = *value_ptr;
233 	if (lock)
234 		spin_unlock(lock);
235 	return snprintf(buf, PAGE_SIZE, "%llu\n", val);
236 }
237 
238 static ssize_t global_rsv_size_show(struct kobject *kobj,
239 				    struct kobj_attribute *ka, char *buf)
240 {
241 	struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
242 	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
243 	return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf);
244 }
245 BTRFS_ATTR(global_rsv_size, 0444, global_rsv_size_show);
246 
247 static ssize_t global_rsv_reserved_show(struct kobject *kobj,
248 					struct kobj_attribute *a, char *buf)
249 {
250 	struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
251 	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
252 	return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf);
253 }
254 BTRFS_ATTR(global_rsv_reserved, 0444, global_rsv_reserved_show);
255 
256 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
257 
258 static ssize_t raid_bytes_show(struct kobject *kobj,
259 			       struct kobj_attribute *attr, char *buf);
260 BTRFS_RAID_ATTR(total_bytes, raid_bytes_show);
261 BTRFS_RAID_ATTR(used_bytes, raid_bytes_show);
262 
263 static ssize_t raid_bytes_show(struct kobject *kobj,
264 			       struct kobj_attribute *attr, char *buf)
265 
266 {
267 	struct btrfs_space_info *sinfo = to_space_info(kobj->parent);
268 	struct btrfs_block_group_cache *block_group;
269 	int index = kobj - sinfo->block_group_kobjs;
270 	u64 val = 0;
271 
272 	down_read(&sinfo->groups_sem);
273 	list_for_each_entry(block_group, &sinfo->block_groups[index], list) {
274 		if (&attr->attr == BTRFS_RAID_ATTR_PTR(total_bytes))
275 			val += block_group->key.offset;
276 		else
277 			val += btrfs_block_group_used(&block_group->item);
278 	}
279 	up_read(&sinfo->groups_sem);
280 	return snprintf(buf, PAGE_SIZE, "%llu\n", val);
281 }
282 
283 static struct attribute *raid_attributes[] = {
284 	BTRFS_RAID_ATTR_PTR(total_bytes),
285 	BTRFS_RAID_ATTR_PTR(used_bytes),
286 	NULL
287 };
288 
289 static void release_raid_kobj(struct kobject *kobj)
290 {
291 	kobject_put(kobj->parent);
292 }
293 
294 struct kobj_type btrfs_raid_ktype = {
295 	.sysfs_ops = &kobj_sysfs_ops,
296 	.release = release_raid_kobj,
297 	.default_attrs = raid_attributes,
298 };
299 
300 #define SPACE_INFO_ATTR(field)						\
301 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj,	\
302 					     struct kobj_attribute *a,	\
303 					     char *buf)			\
304 {									\
305 	struct btrfs_space_info *sinfo = to_space_info(kobj);		\
306 	return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf);	\
307 }									\
308 BTRFS_ATTR(field, 0444, btrfs_space_info_show_##field)
309 
310 static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj,
311 						       struct kobj_attribute *a,
312 						       char *buf)
313 {
314 	struct btrfs_space_info *sinfo = to_space_info(kobj);
315 	s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned);
316 	return snprintf(buf, PAGE_SIZE, "%lld\n", val);
317 }
318 
319 SPACE_INFO_ATTR(flags);
320 SPACE_INFO_ATTR(total_bytes);
321 SPACE_INFO_ATTR(bytes_used);
322 SPACE_INFO_ATTR(bytes_pinned);
323 SPACE_INFO_ATTR(bytes_reserved);
324 SPACE_INFO_ATTR(bytes_may_use);
325 SPACE_INFO_ATTR(disk_used);
326 SPACE_INFO_ATTR(disk_total);
327 BTRFS_ATTR(total_bytes_pinned, 0444, btrfs_space_info_show_total_bytes_pinned);
328 
329 static struct attribute *space_info_attrs[] = {
330 	BTRFS_ATTR_PTR(flags),
331 	BTRFS_ATTR_PTR(total_bytes),
332 	BTRFS_ATTR_PTR(bytes_used),
333 	BTRFS_ATTR_PTR(bytes_pinned),
334 	BTRFS_ATTR_PTR(bytes_reserved),
335 	BTRFS_ATTR_PTR(bytes_may_use),
336 	BTRFS_ATTR_PTR(disk_used),
337 	BTRFS_ATTR_PTR(disk_total),
338 	BTRFS_ATTR_PTR(total_bytes_pinned),
339 	NULL,
340 };
341 
342 static void space_info_release(struct kobject *kobj)
343 {
344 	struct btrfs_space_info *sinfo = to_space_info(kobj);
345 	percpu_counter_destroy(&sinfo->total_bytes_pinned);
346 	kfree(sinfo);
347 }
348 
349 struct kobj_type space_info_ktype = {
350 	.sysfs_ops = &kobj_sysfs_ops,
351 	.release = space_info_release,
352 	.default_attrs = space_info_attrs,
353 };
354 
355 static const struct attribute *allocation_attrs[] = {
356 	BTRFS_ATTR_PTR(global_rsv_reserved),
357 	BTRFS_ATTR_PTR(global_rsv_size),
358 	NULL,
359 };
360 
361 static ssize_t btrfs_label_show(struct kobject *kobj,
362 				struct kobj_attribute *a, char *buf)
363 {
364 	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
365 	return snprintf(buf, PAGE_SIZE, "%s\n", fs_info->super_copy->label);
366 }
367 
368 static ssize_t btrfs_label_store(struct kobject *kobj,
369 				 struct kobj_attribute *a,
370 				 const char *buf, size_t len)
371 {
372 	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
373 	struct btrfs_trans_handle *trans;
374 	struct btrfs_root *root = fs_info->fs_root;
375 	int ret;
376 
377 	if (len >= BTRFS_LABEL_SIZE) {
378 		pr_err("BTRFS: unable to set label with more than %d bytes\n",
379 		       BTRFS_LABEL_SIZE - 1);
380 		return -EINVAL;
381 	}
382 
383 	trans = btrfs_start_transaction(root, 0);
384 	if (IS_ERR(trans))
385 		return PTR_ERR(trans);
386 
387 	spin_lock(&root->fs_info->super_lock);
388 	strcpy(fs_info->super_copy->label, buf);
389 	spin_unlock(&root->fs_info->super_lock);
390 	ret = btrfs_commit_transaction(trans, root);
391 
392 	if (!ret)
393 		return len;
394 
395 	return ret;
396 }
397 BTRFS_ATTR_RW(label, 0644, btrfs_label_show, btrfs_label_store);
398 
399 static struct attribute *btrfs_attrs[] = {
400 	BTRFS_ATTR_PTR(label),
401 	NULL,
402 };
403 
404 static void btrfs_release_super_kobj(struct kobject *kobj)
405 {
406 	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
407 	complete(&fs_info->kobj_unregister);
408 }
409 
410 static struct kobj_type btrfs_ktype = {
411 	.sysfs_ops	= &kobj_sysfs_ops,
412 	.release	= btrfs_release_super_kobj,
413 	.default_attrs	= btrfs_attrs,
414 };
415 
416 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)
417 {
418 	if (kobj->ktype != &btrfs_ktype)
419 		return NULL;
420 	return container_of(kobj, struct btrfs_fs_info, super_kobj);
421 }
422 
423 #define NUM_FEATURE_BITS 64
424 static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13];
425 static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS];
426 
427 static u64 supported_feature_masks[3] = {
428 	[FEAT_COMPAT]    = BTRFS_FEATURE_COMPAT_SUPP,
429 	[FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
430 	[FEAT_INCOMPAT]  = BTRFS_FEATURE_INCOMPAT_SUPP,
431 };
432 
433 static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add)
434 {
435 	int set;
436 
437 	for (set = 0; set < FEAT_MAX; set++) {
438 		int i;
439 		struct attribute *attrs[2];
440 		struct attribute_group agroup = {
441 			.name = "features",
442 			.attrs = attrs,
443 		};
444 		u64 features = get_features(fs_info, set);
445 		features &= ~supported_feature_masks[set];
446 
447 		if (!features)
448 			continue;
449 
450 		attrs[1] = NULL;
451 		for (i = 0; i < NUM_FEATURE_BITS; i++) {
452 			struct btrfs_feature_attr *fa;
453 
454 			if (!(features & (1ULL << i)))
455 				continue;
456 
457 			fa = &btrfs_feature_attrs[set][i];
458 			attrs[0] = &fa->kobj_attr.attr;
459 			if (add) {
460 				int ret;
461 				ret = sysfs_merge_group(&fs_info->super_kobj,
462 							&agroup);
463 				if (ret)
464 					return ret;
465 			} else
466 				sysfs_unmerge_group(&fs_info->super_kobj,
467 						    &agroup);
468 		}
469 
470 	}
471 	return 0;
472 }
473 
474 static void __btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
475 {
476 	kobject_del(&fs_info->super_kobj);
477 	kobject_put(&fs_info->super_kobj);
478 	wait_for_completion(&fs_info->kobj_unregister);
479 }
480 
481 void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
482 {
483 	if (fs_info->space_info_kobj) {
484 		sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs);
485 		kobject_del(fs_info->space_info_kobj);
486 		kobject_put(fs_info->space_info_kobj);
487 	}
488 	kobject_del(fs_info->device_dir_kobj);
489 	kobject_put(fs_info->device_dir_kobj);
490 	addrm_unknown_feature_attrs(fs_info, false);
491 	sysfs_remove_group(&fs_info->super_kobj, &btrfs_feature_attr_group);
492 	__btrfs_sysfs_remove_one(fs_info);
493 }
494 
495 const char * const btrfs_feature_set_names[3] = {
496 	[FEAT_COMPAT]	 = "compat",
497 	[FEAT_COMPAT_RO] = "compat_ro",
498 	[FEAT_INCOMPAT]	 = "incompat",
499 };
500 
501 char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags)
502 {
503 	size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */
504 	int len = 0;
505 	int i;
506 	char *str;
507 
508 	str = kmalloc(bufsize, GFP_KERNEL);
509 	if (!str)
510 		return str;
511 
512 	for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
513 		const char *name;
514 
515 		if (!(flags & (1ULL << i)))
516 			continue;
517 
518 		name = btrfs_feature_attrs[set][i].kobj_attr.attr.name;
519 		len += snprintf(str + len, bufsize - len, "%s%s",
520 				len ? "," : "", name);
521 	}
522 
523 	return str;
524 }
525 
526 static void init_feature_attrs(void)
527 {
528 	struct btrfs_feature_attr *fa;
529 	int set, i;
530 
531 	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) !=
532 		     ARRAY_SIZE(btrfs_feature_attrs));
533 	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) !=
534 		     ARRAY_SIZE(btrfs_feature_attrs[0]));
535 
536 	memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs));
537 	memset(btrfs_unknown_feature_names, 0,
538 	       sizeof(btrfs_unknown_feature_names));
539 
540 	for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
541 		struct btrfs_feature_attr *sfa;
542 		struct attribute *a = btrfs_supported_feature_attrs[i];
543 		int bit;
544 		sfa = attr_to_btrfs_feature_attr(a);
545 		bit = ilog2(sfa->feature_bit);
546 		fa = &btrfs_feature_attrs[sfa->feature_set][bit];
547 
548 		fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name;
549 	}
550 
551 	for (set = 0; set < FEAT_MAX; set++) {
552 		for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
553 			char *name = btrfs_unknown_feature_names[set][i];
554 			fa = &btrfs_feature_attrs[set][i];
555 
556 			if (fa->kobj_attr.attr.name)
557 				continue;
558 
559 			snprintf(name, 13, "%s:%u",
560 				 btrfs_feature_set_names[set], i);
561 
562 			fa->kobj_attr.attr.name = name;
563 			fa->kobj_attr.attr.mode = S_IRUGO;
564 			fa->feature_set = set;
565 			fa->feature_bit = 1ULL << i;
566 		}
567 	}
568 }
569 
570 static int add_device_membership(struct btrfs_fs_info *fs_info)
571 {
572 	int error = 0;
573 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
574 	struct btrfs_device *dev;
575 
576 	fs_info->device_dir_kobj = kobject_create_and_add("devices",
577 						&fs_info->super_kobj);
578 	if (!fs_info->device_dir_kobj)
579 		return -ENOMEM;
580 
581 	list_for_each_entry(dev, &fs_devices->devices, dev_list) {
582 		struct hd_struct *disk;
583 		struct kobject *disk_kobj;
584 
585 		if (!dev->bdev)
586 			continue;
587 
588 		disk = dev->bdev->bd_part;
589 		disk_kobj = &part_to_dev(disk)->kobj;
590 
591 		error = sysfs_create_link(fs_info->device_dir_kobj,
592 					  disk_kobj, disk_kobj->name);
593 		if (error)
594 			break;
595 	}
596 
597 	return error;
598 }
599 
600 /* /sys/fs/btrfs/ entry */
601 static struct kset *btrfs_kset;
602 
603 /* /sys/kernel/debug/btrfs */
604 static struct dentry *btrfs_debugfs_root_dentry;
605 
606 /* Debugging tunables and exported data */
607 u64 btrfs_debugfs_test;
608 
609 int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info)
610 {
611 	int error;
612 
613 	init_completion(&fs_info->kobj_unregister);
614 	fs_info->super_kobj.kset = btrfs_kset;
615 	error = kobject_init_and_add(&fs_info->super_kobj, &btrfs_ktype, NULL,
616 				     "%pU", fs_info->fsid);
617 	if (error)
618 		return error;
619 
620 	error = sysfs_create_group(&fs_info->super_kobj,
621 				   &btrfs_feature_attr_group);
622 	if (error) {
623 		__btrfs_sysfs_remove_one(fs_info);
624 		return error;
625 	}
626 
627 	error = addrm_unknown_feature_attrs(fs_info, true);
628 	if (error)
629 		goto failure;
630 
631 	error = add_device_membership(fs_info);
632 	if (error)
633 		goto failure;
634 
635 	fs_info->space_info_kobj = kobject_create_and_add("allocation",
636 						  &fs_info->super_kobj);
637 	if (!fs_info->space_info_kobj) {
638 		error = -ENOMEM;
639 		goto failure;
640 	}
641 
642 	error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs);
643 	if (error)
644 		goto failure;
645 
646 	return 0;
647 failure:
648 	btrfs_sysfs_remove_one(fs_info);
649 	return error;
650 }
651 
652 static int btrfs_init_debugfs(void)
653 {
654 #ifdef CONFIG_DEBUG_FS
655 	btrfs_debugfs_root_dentry = debugfs_create_dir("btrfs", NULL);
656 	if (!btrfs_debugfs_root_dentry)
657 		return -ENOMEM;
658 
659 	debugfs_create_u64("test", S_IRUGO | S_IWUGO, btrfs_debugfs_root_dentry,
660 			&btrfs_debugfs_test);
661 #endif
662 	return 0;
663 }
664 
665 int btrfs_init_sysfs(void)
666 {
667 	int ret;
668 
669 	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
670 	if (!btrfs_kset)
671 		return -ENOMEM;
672 
673 	ret = btrfs_init_debugfs();
674 	if (ret)
675 		return ret;
676 
677 	init_feature_attrs();
678 	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
679 
680 	return ret;
681 }
682 
683 void btrfs_exit_sysfs(void)
684 {
685 	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
686 	kset_unregister(btrfs_kset);
687 	debugfs_remove_recursive(btrfs_debugfs_root_dentry);
688 }
689 
690