2 * Copyright (C) 2007 Oracle. All rights reserved.
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.
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.
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.
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>
31 #include "transaction.h"
35 static inline struct btrfs_fs_info
*to_fs_info(struct kobject
*kobj
);
37 static u64
get_features(struct btrfs_fs_info
*fs_info
,
38 enum btrfs_feature_set set
)
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
);
46 return btrfs_super_incompat_flags(disk_super
);
49 static void set_features(struct btrfs_fs_info
*fs_info
,
50 enum btrfs_feature_set set
, u64 features
)
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
);
58 btrfs_set_super_incompat_flags(disk_super
, features
);
61 static int can_modify_feature(struct btrfs_feature_attr
*fa
)
65 switch (fa
->feature_set
) {
67 set
= BTRFS_FEATURE_COMPAT_SAFE_SET
;
68 clear
= BTRFS_FEATURE_COMPAT_SAFE_CLEAR
;
71 set
= BTRFS_FEATURE_COMPAT_RO_SAFE_SET
;
72 clear
= BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR
;
75 set
= BTRFS_FEATURE_INCOMPAT_SAFE_SET
;
76 clear
= BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR
;
79 printk(KERN_WARNING
"btrfs: sysfs: unknown feature set %d\n",
84 if (set
& fa
->feature_bit
)
86 if (clear
& fa
->feature_bit
)
92 static ssize_t
btrfs_feature_attr_show(struct kobject
*kobj
,
93 struct kobj_attribute
*a
, char *buf
)
96 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
97 struct btrfs_feature_attr
*fa
= to_btrfs_feature_attr(a
);
99 u64 features
= get_features(fs_info
, fa
->feature_set
);
100 if (features
& fa
->feature_bit
)
103 val
= can_modify_feature(fa
);
105 return snprintf(buf
, PAGE_SIZE
, "%d\n", val
);
108 static ssize_t
btrfs_feature_attr_store(struct kobject
*kobj
,
109 struct kobj_attribute
*a
,
110 const char *buf
, size_t count
)
112 struct btrfs_fs_info
*fs_info
;
113 struct btrfs_feature_attr
*fa
= to_btrfs_feature_attr(a
);
114 u64 features
, set
, clear
;
118 fs_info
= to_fs_info(kobj
);
122 ret
= kstrtoul(skip_spaces(buf
), 0, &val
);
126 if (fa
->feature_set
== FEAT_COMPAT
) {
127 set
= BTRFS_FEATURE_COMPAT_SAFE_SET
;
128 clear
= BTRFS_FEATURE_COMPAT_SAFE_CLEAR
;
129 } else if (fa
->feature_set
== FEAT_COMPAT_RO
) {
130 set
= BTRFS_FEATURE_COMPAT_RO_SAFE_SET
;
131 clear
= BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR
;
133 set
= BTRFS_FEATURE_INCOMPAT_SAFE_SET
;
134 clear
= BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR
;
137 features
= get_features(fs_info
, fa
->feature_set
);
140 if ((val
&& (features
& fa
->feature_bit
)) ||
141 (!val
&& !(features
& fa
->feature_bit
)))
144 if ((val
&& !(set
& fa
->feature_bit
)) ||
145 (!val
&& !(clear
& fa
->feature_bit
))) {
147 "%sabling feature %s on mounted fs is not supported.",
148 val
? "En" : "Dis", fa
->kobj_attr
.attr
.name
);
152 btrfs_info(fs_info
, "%s %s feature flag",
153 val
? "Setting" : "Clearing", fa
->kobj_attr
.attr
.name
);
155 spin_lock(&fs_info
->super_lock
);
156 features
= get_features(fs_info
, fa
->feature_set
);
158 features
|= fa
->feature_bit
;
160 features
&= ~fa
->feature_bit
;
161 set_features(fs_info
, fa
->feature_set
, features
);
162 spin_unlock(&fs_info
->super_lock
);
165 * We don't want to do full transaction commit from inside sysfs
167 btrfs_set_pending(fs_info
, COMMIT
);
168 wake_up_process(fs_info
->transaction_kthread
);
173 static umode_t
btrfs_feature_visible(struct kobject
*kobj
,
174 struct attribute
*attr
, int unused
)
176 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
177 umode_t mode
= attr
->mode
;
180 struct btrfs_feature_attr
*fa
;
183 fa
= attr_to_btrfs_feature_attr(attr
);
184 features
= get_features(fs_info
, fa
->feature_set
);
186 if (can_modify_feature(fa
))
188 else if (!(features
& fa
->feature_bit
))
195 BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref
, MIXED_BACKREF
);
196 BTRFS_FEAT_ATTR_INCOMPAT(default_subvol
, DEFAULT_SUBVOL
);
197 BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups
, MIXED_GROUPS
);
198 BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo
, COMPRESS_LZO
);
199 BTRFS_FEAT_ATTR_INCOMPAT(big_metadata
, BIG_METADATA
);
200 BTRFS_FEAT_ATTR_INCOMPAT(extended_iref
, EXTENDED_IREF
);
201 BTRFS_FEAT_ATTR_INCOMPAT(raid56
, RAID56
);
202 BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata
, SKINNY_METADATA
);
203 BTRFS_FEAT_ATTR_INCOMPAT(no_holes
, NO_HOLES
);
205 static struct attribute
*btrfs_supported_feature_attrs
[] = {
206 BTRFS_FEAT_ATTR_PTR(mixed_backref
),
207 BTRFS_FEAT_ATTR_PTR(default_subvol
),
208 BTRFS_FEAT_ATTR_PTR(mixed_groups
),
209 BTRFS_FEAT_ATTR_PTR(compress_lzo
),
210 BTRFS_FEAT_ATTR_PTR(big_metadata
),
211 BTRFS_FEAT_ATTR_PTR(extended_iref
),
212 BTRFS_FEAT_ATTR_PTR(raid56
),
213 BTRFS_FEAT_ATTR_PTR(skinny_metadata
),
214 BTRFS_FEAT_ATTR_PTR(no_holes
),
218 static const struct attribute_group btrfs_feature_attr_group
= {
220 .is_visible
= btrfs_feature_visible
,
221 .attrs
= btrfs_supported_feature_attrs
,
224 static ssize_t
btrfs_show_u64(u64
*value_ptr
, spinlock_t
*lock
, char *buf
)
232 return snprintf(buf
, PAGE_SIZE
, "%llu\n", val
);
235 static ssize_t
global_rsv_size_show(struct kobject
*kobj
,
236 struct kobj_attribute
*ka
, char *buf
)
238 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
->parent
);
239 struct btrfs_block_rsv
*block_rsv
= &fs_info
->global_block_rsv
;
240 return btrfs_show_u64(&block_rsv
->size
, &block_rsv
->lock
, buf
);
242 BTRFS_ATTR(global_rsv_size
, global_rsv_size_show
);
244 static ssize_t
global_rsv_reserved_show(struct kobject
*kobj
,
245 struct kobj_attribute
*a
, char *buf
)
247 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
->parent
);
248 struct btrfs_block_rsv
*block_rsv
= &fs_info
->global_block_rsv
;
249 return btrfs_show_u64(&block_rsv
->reserved
, &block_rsv
->lock
, buf
);
251 BTRFS_ATTR(global_rsv_reserved
, global_rsv_reserved_show
);
253 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
254 #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj)
256 static ssize_t
raid_bytes_show(struct kobject
*kobj
,
257 struct kobj_attribute
*attr
, char *buf
);
258 BTRFS_RAID_ATTR(total_bytes
, raid_bytes_show
);
259 BTRFS_RAID_ATTR(used_bytes
, raid_bytes_show
);
261 static ssize_t
raid_bytes_show(struct kobject
*kobj
,
262 struct kobj_attribute
*attr
, char *buf
)
265 struct btrfs_space_info
*sinfo
= to_space_info(kobj
->parent
);
266 struct btrfs_block_group_cache
*block_group
;
267 int index
= to_raid_kobj(kobj
)->raid_type
;
270 down_read(&sinfo
->groups_sem
);
271 list_for_each_entry(block_group
, &sinfo
->block_groups
[index
], list
) {
272 if (&attr
->attr
== BTRFS_RAID_ATTR_PTR(total_bytes
))
273 val
+= block_group
->key
.offset
;
275 val
+= btrfs_block_group_used(&block_group
->item
);
277 up_read(&sinfo
->groups_sem
);
278 return snprintf(buf
, PAGE_SIZE
, "%llu\n", val
);
281 static struct attribute
*raid_attributes
[] = {
282 BTRFS_RAID_ATTR_PTR(total_bytes
),
283 BTRFS_RAID_ATTR_PTR(used_bytes
),
287 static void release_raid_kobj(struct kobject
*kobj
)
289 kfree(to_raid_kobj(kobj
));
292 struct kobj_type btrfs_raid_ktype
= {
293 .sysfs_ops
= &kobj_sysfs_ops
,
294 .release
= release_raid_kobj
,
295 .default_attrs
= raid_attributes
,
298 #define SPACE_INFO_ATTR(field) \
299 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \
300 struct kobj_attribute *a, \
303 struct btrfs_space_info *sinfo = to_space_info(kobj); \
304 return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \
306 BTRFS_ATTR(field, btrfs_space_info_show_##field)
308 static ssize_t
btrfs_space_info_show_total_bytes_pinned(struct kobject
*kobj
,
309 struct kobj_attribute
*a
,
312 struct btrfs_space_info
*sinfo
= to_space_info(kobj
);
313 s64 val
= percpu_counter_sum(&sinfo
->total_bytes_pinned
);
314 return snprintf(buf
, PAGE_SIZE
, "%lld\n", val
);
317 SPACE_INFO_ATTR(flags
);
318 SPACE_INFO_ATTR(total_bytes
);
319 SPACE_INFO_ATTR(bytes_used
);
320 SPACE_INFO_ATTR(bytes_pinned
);
321 SPACE_INFO_ATTR(bytes_reserved
);
322 SPACE_INFO_ATTR(bytes_may_use
);
323 SPACE_INFO_ATTR(disk_used
);
324 SPACE_INFO_ATTR(disk_total
);
325 BTRFS_ATTR(total_bytes_pinned
, btrfs_space_info_show_total_bytes_pinned
);
327 static struct attribute
*space_info_attrs
[] = {
328 BTRFS_ATTR_PTR(flags
),
329 BTRFS_ATTR_PTR(total_bytes
),
330 BTRFS_ATTR_PTR(bytes_used
),
331 BTRFS_ATTR_PTR(bytes_pinned
),
332 BTRFS_ATTR_PTR(bytes_reserved
),
333 BTRFS_ATTR_PTR(bytes_may_use
),
334 BTRFS_ATTR_PTR(disk_used
),
335 BTRFS_ATTR_PTR(disk_total
),
336 BTRFS_ATTR_PTR(total_bytes_pinned
),
340 static void space_info_release(struct kobject
*kobj
)
342 struct btrfs_space_info
*sinfo
= to_space_info(kobj
);
343 percpu_counter_destroy(&sinfo
->total_bytes_pinned
);
347 struct kobj_type space_info_ktype
= {
348 .sysfs_ops
= &kobj_sysfs_ops
,
349 .release
= space_info_release
,
350 .default_attrs
= space_info_attrs
,
353 static const struct attribute
*allocation_attrs
[] = {
354 BTRFS_ATTR_PTR(global_rsv_reserved
),
355 BTRFS_ATTR_PTR(global_rsv_size
),
359 static ssize_t
btrfs_label_show(struct kobject
*kobj
,
360 struct kobj_attribute
*a
, char *buf
)
362 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
363 char *label
= fs_info
->super_copy
->label
;
364 return snprintf(buf
, PAGE_SIZE
, label
[0] ? "%s\n" : "%s", label
);
367 static ssize_t
btrfs_label_store(struct kobject
*kobj
,
368 struct kobj_attribute
*a
,
369 const char *buf
, size_t len
)
371 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
372 struct btrfs_trans_handle
*trans
;
373 struct btrfs_root
*root
= fs_info
->fs_root
;
377 if (fs_info
->sb
->s_flags
& MS_RDONLY
)
381 * p_len is the len until the first occurrence of either
384 p_len
= strcspn(buf
, "\n");
386 if (p_len
>= BTRFS_LABEL_SIZE
)
389 trans
= btrfs_start_transaction(root
, 0);
391 return PTR_ERR(trans
);
393 spin_lock(&root
->fs_info
->super_lock
);
394 memset(fs_info
->super_copy
->label
, 0, BTRFS_LABEL_SIZE
);
395 memcpy(fs_info
->super_copy
->label
, buf
, p_len
);
396 spin_unlock(&root
->fs_info
->super_lock
);
397 ret
= btrfs_commit_transaction(trans
, root
);
404 BTRFS_ATTR_RW(label
, btrfs_label_show
, btrfs_label_store
);
406 static ssize_t
btrfs_nodesize_show(struct kobject
*kobj
,
407 struct kobj_attribute
*a
, char *buf
)
409 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
411 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->nodesize
);
414 BTRFS_ATTR(nodesize
, btrfs_nodesize_show
);
416 static ssize_t
btrfs_sectorsize_show(struct kobject
*kobj
,
417 struct kobj_attribute
*a
, char *buf
)
419 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
421 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->sectorsize
);
424 BTRFS_ATTR(sectorsize
, btrfs_sectorsize_show
);
426 static ssize_t
btrfs_clone_alignment_show(struct kobject
*kobj
,
427 struct kobj_attribute
*a
, char *buf
)
429 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
431 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->sectorsize
);
434 BTRFS_ATTR(clone_alignment
, btrfs_clone_alignment_show
);
436 static struct attribute
*btrfs_attrs
[] = {
437 BTRFS_ATTR_PTR(label
),
438 BTRFS_ATTR_PTR(nodesize
),
439 BTRFS_ATTR_PTR(sectorsize
),
440 BTRFS_ATTR_PTR(clone_alignment
),
444 static void btrfs_release_super_kobj(struct kobject
*kobj
)
446 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
447 complete(&fs_info
->kobj_unregister
);
450 static struct kobj_type btrfs_ktype
= {
451 .sysfs_ops
= &kobj_sysfs_ops
,
452 .release
= btrfs_release_super_kobj
,
453 .default_attrs
= btrfs_attrs
,
456 static inline struct btrfs_fs_info
*to_fs_info(struct kobject
*kobj
)
458 if (kobj
->ktype
!= &btrfs_ktype
)
460 return container_of(kobj
, struct btrfs_fs_info
, super_kobj
);
463 #define NUM_FEATURE_BITS 64
464 static char btrfs_unknown_feature_names
[3][NUM_FEATURE_BITS
][13];
465 static struct btrfs_feature_attr btrfs_feature_attrs
[3][NUM_FEATURE_BITS
];
467 static u64 supported_feature_masks
[3] = {
468 [FEAT_COMPAT
] = BTRFS_FEATURE_COMPAT_SUPP
,
469 [FEAT_COMPAT_RO
] = BTRFS_FEATURE_COMPAT_RO_SUPP
,
470 [FEAT_INCOMPAT
] = BTRFS_FEATURE_INCOMPAT_SUPP
,
473 static int addrm_unknown_feature_attrs(struct btrfs_fs_info
*fs_info
, bool add
)
477 for (set
= 0; set
< FEAT_MAX
; set
++) {
479 struct attribute
*attrs
[2];
480 struct attribute_group agroup
= {
484 u64 features
= get_features(fs_info
, set
);
485 features
&= ~supported_feature_masks
[set
];
491 for (i
= 0; i
< NUM_FEATURE_BITS
; i
++) {
492 struct btrfs_feature_attr
*fa
;
494 if (!(features
& (1ULL << i
)))
497 fa
= &btrfs_feature_attrs
[set
][i
];
498 attrs
[0] = &fa
->kobj_attr
.attr
;
501 ret
= sysfs_merge_group(&fs_info
->super_kobj
,
506 sysfs_unmerge_group(&fs_info
->super_kobj
,
514 static void __btrfs_sysfs_remove_one(struct btrfs_fs_info
*fs_info
)
516 kobject_del(&fs_info
->super_kobj
);
517 kobject_put(&fs_info
->super_kobj
);
518 wait_for_completion(&fs_info
->kobj_unregister
);
521 void btrfs_sysfs_remove_one(struct btrfs_fs_info
*fs_info
)
523 if (fs_info
->space_info_kobj
) {
524 sysfs_remove_files(fs_info
->space_info_kobj
, allocation_attrs
);
525 kobject_del(fs_info
->space_info_kobj
);
526 kobject_put(fs_info
->space_info_kobj
);
528 kobject_del(fs_info
->device_dir_kobj
);
529 kobject_put(fs_info
->device_dir_kobj
);
530 addrm_unknown_feature_attrs(fs_info
, false);
531 sysfs_remove_group(&fs_info
->super_kobj
, &btrfs_feature_attr_group
);
532 __btrfs_sysfs_remove_one(fs_info
);
535 const char * const btrfs_feature_set_names
[3] = {
536 [FEAT_COMPAT
] = "compat",
537 [FEAT_COMPAT_RO
] = "compat_ro",
538 [FEAT_INCOMPAT
] = "incompat",
541 char *btrfs_printable_features(enum btrfs_feature_set set
, u64 flags
)
543 size_t bufsize
= 4096; /* safe max, 64 names * 64 bytes */
548 str
= kmalloc(bufsize
, GFP_KERNEL
);
552 for (i
= 0; i
< ARRAY_SIZE(btrfs_feature_attrs
[set
]); i
++) {
555 if (!(flags
& (1ULL << i
)))
558 name
= btrfs_feature_attrs
[set
][i
].kobj_attr
.attr
.name
;
559 len
+= snprintf(str
+ len
, bufsize
- len
, "%s%s",
560 len
? "," : "", name
);
566 static void init_feature_attrs(void)
568 struct btrfs_feature_attr
*fa
;
571 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names
) !=
572 ARRAY_SIZE(btrfs_feature_attrs
));
573 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names
[0]) !=
574 ARRAY_SIZE(btrfs_feature_attrs
[0]));
576 memset(btrfs_feature_attrs
, 0, sizeof(btrfs_feature_attrs
));
577 memset(btrfs_unknown_feature_names
, 0,
578 sizeof(btrfs_unknown_feature_names
));
580 for (i
= 0; btrfs_supported_feature_attrs
[i
]; i
++) {
581 struct btrfs_feature_attr
*sfa
;
582 struct attribute
*a
= btrfs_supported_feature_attrs
[i
];
584 sfa
= attr_to_btrfs_feature_attr(a
);
585 bit
= ilog2(sfa
->feature_bit
);
586 fa
= &btrfs_feature_attrs
[sfa
->feature_set
][bit
];
588 fa
->kobj_attr
.attr
.name
= sfa
->kobj_attr
.attr
.name
;
591 for (set
= 0; set
< FEAT_MAX
; set
++) {
592 for (i
= 0; i
< ARRAY_SIZE(btrfs_feature_attrs
[set
]); i
++) {
593 char *name
= btrfs_unknown_feature_names
[set
][i
];
594 fa
= &btrfs_feature_attrs
[set
][i
];
596 if (fa
->kobj_attr
.attr
.name
)
599 snprintf(name
, 13, "%s:%u",
600 btrfs_feature_set_names
[set
], i
);
602 fa
->kobj_attr
.attr
.name
= name
;
603 fa
->kobj_attr
.attr
.mode
= S_IRUGO
;
604 fa
->feature_set
= set
;
605 fa
->feature_bit
= 1ULL << i
;
610 int btrfs_kobj_rm_device(struct btrfs_fs_info
*fs_info
,
611 struct btrfs_device
*one_device
)
613 struct hd_struct
*disk
;
614 struct kobject
*disk_kobj
;
616 if (!fs_info
->device_dir_kobj
)
619 if (one_device
&& one_device
->bdev
) {
620 disk
= one_device
->bdev
->bd_part
;
621 disk_kobj
= &part_to_dev(disk
)->kobj
;
623 sysfs_remove_link(fs_info
->device_dir_kobj
,
630 int btrfs_kobj_add_device(struct btrfs_fs_info
*fs_info
,
631 struct btrfs_device
*one_device
)
634 struct btrfs_fs_devices
*fs_devices
= fs_info
->fs_devices
;
635 struct btrfs_device
*dev
;
637 if (!fs_info
->device_dir_kobj
)
638 fs_info
->device_dir_kobj
= kobject_create_and_add("devices",
639 &fs_info
->super_kobj
);
641 if (!fs_info
->device_dir_kobj
)
644 list_for_each_entry(dev
, &fs_devices
->devices
, dev_list
) {
645 struct hd_struct
*disk
;
646 struct kobject
*disk_kobj
;
651 if (one_device
&& one_device
!= dev
)
654 disk
= dev
->bdev
->bd_part
;
655 disk_kobj
= &part_to_dev(disk
)->kobj
;
657 error
= sysfs_create_link(fs_info
->device_dir_kobj
,
658 disk_kobj
, disk_kobj
->name
);
666 /* /sys/fs/btrfs/ entry */
667 static struct kset
*btrfs_kset
;
669 /* /sys/kernel/debug/btrfs */
670 static struct dentry
*btrfs_debugfs_root_dentry
;
672 /* Debugging tunables and exported data */
673 u64 btrfs_debugfs_test
;
675 int btrfs_sysfs_add_one(struct btrfs_fs_info
*fs_info
)
679 init_completion(&fs_info
->kobj_unregister
);
680 fs_info
->super_kobj
.kset
= btrfs_kset
;
681 error
= kobject_init_and_add(&fs_info
->super_kobj
, &btrfs_ktype
, NULL
,
682 "%pU", fs_info
->fsid
);
686 error
= sysfs_create_group(&fs_info
->super_kobj
,
687 &btrfs_feature_attr_group
);
689 __btrfs_sysfs_remove_one(fs_info
);
693 error
= addrm_unknown_feature_attrs(fs_info
, true);
697 error
= btrfs_kobj_add_device(fs_info
, NULL
);
701 fs_info
->space_info_kobj
= kobject_create_and_add("allocation",
702 &fs_info
->super_kobj
);
703 if (!fs_info
->space_info_kobj
) {
708 error
= sysfs_create_files(fs_info
->space_info_kobj
, allocation_attrs
);
714 btrfs_sysfs_remove_one(fs_info
);
718 static int btrfs_init_debugfs(void)
720 #ifdef CONFIG_DEBUG_FS
721 btrfs_debugfs_root_dentry
= debugfs_create_dir("btrfs", NULL
);
722 if (!btrfs_debugfs_root_dentry
)
725 debugfs_create_u64("test", S_IRUGO
| S_IWUGO
, btrfs_debugfs_root_dentry
,
726 &btrfs_debugfs_test
);
731 int btrfs_init_sysfs(void)
735 btrfs_kset
= kset_create_and_add("btrfs", NULL
, fs_kobj
);
739 ret
= btrfs_init_debugfs();
743 init_feature_attrs();
744 ret
= sysfs_create_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
749 void btrfs_exit_sysfs(void)
751 sysfs_remove_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
752 kset_unregister(btrfs_kset
);
753 debugfs_remove_recursive(btrfs_debugfs_root_dentry
);