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 struct btrfs_trans_handle
*trans
;
115 u64 features
, set
, clear
;
119 fs_info
= to_fs_info(kobj
);
123 ret
= kstrtoul(skip_spaces(buf
), 0, &val
);
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
;
134 set
= BTRFS_FEATURE_INCOMPAT_SAFE_SET
;
135 clear
= BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR
;
138 features
= get_features(fs_info
, fa
->feature_set
);
141 if ((val
&& (features
& fa
->feature_bit
)) ||
142 (!val
&& !(features
& fa
->feature_bit
)))
145 if ((val
&& !(set
& fa
->feature_bit
)) ||
146 (!val
&& !(clear
& fa
->feature_bit
))) {
148 "%sabling feature %s on mounted fs is not supported.",
149 val
? "En" : "Dis", fa
->kobj_attr
.attr
.name
);
153 btrfs_info(fs_info
, "%s %s feature flag",
154 val
? "Setting" : "Clearing", fa
->kobj_attr
.attr
.name
);
156 trans
= btrfs_start_transaction(fs_info
->fs_root
, 0);
158 return PTR_ERR(trans
);
160 spin_lock(&fs_info
->super_lock
);
161 features
= get_features(fs_info
, fa
->feature_set
);
163 features
|= fa
->feature_bit
;
165 features
&= ~fa
->feature_bit
;
166 set_features(fs_info
, fa
->feature_set
, features
);
167 spin_unlock(&fs_info
->super_lock
);
169 ret
= btrfs_commit_transaction(trans
, fs_info
->fs_root
);
176 static umode_t
btrfs_feature_visible(struct kobject
*kobj
,
177 struct attribute
*attr
, int unused
)
179 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
180 umode_t mode
= attr
->mode
;
183 struct btrfs_feature_attr
*fa
;
186 fa
= attr_to_btrfs_feature_attr(attr
);
187 features
= get_features(fs_info
, fa
->feature_set
);
189 if (can_modify_feature(fa
))
191 else if (!(features
& fa
->feature_bit
))
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
);
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
),
221 static const struct attribute_group btrfs_feature_attr_group
= {
223 .is_visible
= btrfs_feature_visible
,
224 .attrs
= btrfs_supported_feature_attrs
,
227 static ssize_t
btrfs_show_u64(u64
*value_ptr
, spinlock_t
*lock
, char *buf
)
235 return snprintf(buf
, PAGE_SIZE
, "%llu\n", val
);
238 static ssize_t
global_rsv_size_show(struct kobject
*kobj
,
239 struct kobj_attribute
*ka
, char *buf
)
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
);
245 BTRFS_ATTR(global_rsv_size
, 0444, global_rsv_size_show
);
247 static ssize_t
global_rsv_reserved_show(struct kobject
*kobj
,
248 struct kobj_attribute
*a
, char *buf
)
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
);
254 BTRFS_ATTR(global_rsv_reserved
, 0444, global_rsv_reserved_show
);
256 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
257 #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj)
259 static ssize_t
raid_bytes_show(struct kobject
*kobj
,
260 struct kobj_attribute
*attr
, char *buf
);
261 BTRFS_RAID_ATTR(total_bytes
, raid_bytes_show
);
262 BTRFS_RAID_ATTR(used_bytes
, raid_bytes_show
);
264 static ssize_t
raid_bytes_show(struct kobject
*kobj
,
265 struct kobj_attribute
*attr
, char *buf
)
268 struct btrfs_space_info
*sinfo
= to_space_info(kobj
->parent
);
269 struct btrfs_block_group_cache
*block_group
;
270 int index
= to_raid_kobj(kobj
)->raid_type
;
273 down_read(&sinfo
->groups_sem
);
274 list_for_each_entry(block_group
, &sinfo
->block_groups
[index
], list
) {
275 if (&attr
->attr
== BTRFS_RAID_ATTR_PTR(total_bytes
))
276 val
+= block_group
->key
.offset
;
278 val
+= btrfs_block_group_used(&block_group
->item
);
280 up_read(&sinfo
->groups_sem
);
281 return snprintf(buf
, PAGE_SIZE
, "%llu\n", val
);
284 static struct attribute
*raid_attributes
[] = {
285 BTRFS_RAID_ATTR_PTR(total_bytes
),
286 BTRFS_RAID_ATTR_PTR(used_bytes
),
290 static void release_raid_kobj(struct kobject
*kobj
)
292 kfree(to_raid_kobj(kobj
));
295 struct kobj_type btrfs_raid_ktype
= {
296 .sysfs_ops
= &kobj_sysfs_ops
,
297 .release
= release_raid_kobj
,
298 .default_attrs
= raid_attributes
,
301 #define SPACE_INFO_ATTR(field) \
302 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \
303 struct kobj_attribute *a, \
306 struct btrfs_space_info *sinfo = to_space_info(kobj); \
307 return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \
309 BTRFS_ATTR(field, 0444, btrfs_space_info_show_##field)
311 static ssize_t
btrfs_space_info_show_total_bytes_pinned(struct kobject
*kobj
,
312 struct kobj_attribute
*a
,
315 struct btrfs_space_info
*sinfo
= to_space_info(kobj
);
316 s64 val
= percpu_counter_sum(&sinfo
->total_bytes_pinned
);
317 return snprintf(buf
, PAGE_SIZE
, "%lld\n", val
);
320 SPACE_INFO_ATTR(flags
);
321 SPACE_INFO_ATTR(total_bytes
);
322 SPACE_INFO_ATTR(bytes_used
);
323 SPACE_INFO_ATTR(bytes_pinned
);
324 SPACE_INFO_ATTR(bytes_reserved
);
325 SPACE_INFO_ATTR(bytes_may_use
);
326 SPACE_INFO_ATTR(disk_used
);
327 SPACE_INFO_ATTR(disk_total
);
328 BTRFS_ATTR(total_bytes_pinned
, 0444, btrfs_space_info_show_total_bytes_pinned
);
330 static struct attribute
*space_info_attrs
[] = {
331 BTRFS_ATTR_PTR(flags
),
332 BTRFS_ATTR_PTR(total_bytes
),
333 BTRFS_ATTR_PTR(bytes_used
),
334 BTRFS_ATTR_PTR(bytes_pinned
),
335 BTRFS_ATTR_PTR(bytes_reserved
),
336 BTRFS_ATTR_PTR(bytes_may_use
),
337 BTRFS_ATTR_PTR(disk_used
),
338 BTRFS_ATTR_PTR(disk_total
),
339 BTRFS_ATTR_PTR(total_bytes_pinned
),
343 static void space_info_release(struct kobject
*kobj
)
345 struct btrfs_space_info
*sinfo
= to_space_info(kobj
);
346 percpu_counter_destroy(&sinfo
->total_bytes_pinned
);
350 struct kobj_type space_info_ktype
= {
351 .sysfs_ops
= &kobj_sysfs_ops
,
352 .release
= space_info_release
,
353 .default_attrs
= space_info_attrs
,
356 static const struct attribute
*allocation_attrs
[] = {
357 BTRFS_ATTR_PTR(global_rsv_reserved
),
358 BTRFS_ATTR_PTR(global_rsv_size
),
362 static ssize_t
btrfs_label_show(struct kobject
*kobj
,
363 struct kobj_attribute
*a
, char *buf
)
365 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
366 char *label
= fs_info
->super_copy
->label
;
367 return snprintf(buf
, PAGE_SIZE
, label
[0] ? "%s\n" : "%s", label
);
370 static ssize_t
btrfs_label_store(struct kobject
*kobj
,
371 struct kobj_attribute
*a
,
372 const char *buf
, size_t len
)
374 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
375 struct btrfs_trans_handle
*trans
;
376 struct btrfs_root
*root
= fs_info
->fs_root
;
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
, 0644, btrfs_label_show
, btrfs_label_store
);
406 static ssize_t
btrfs_no_store(struct kobject
*kobj
,
407 struct kobj_attribute
*a
,
408 const char *buf
, size_t len
)
413 static ssize_t
btrfs_nodesize_show(struct kobject
*kobj
,
414 struct kobj_attribute
*a
, char *buf
)
416 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
418 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->nodesize
);
421 BTRFS_ATTR_RW(nodesize
, 0444, btrfs_nodesize_show
, btrfs_no_store
);
423 static ssize_t
btrfs_sectorsize_show(struct kobject
*kobj
,
424 struct kobj_attribute
*a
, char *buf
)
426 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
428 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->sectorsize
);
431 BTRFS_ATTR_RW(sectorsize
, 0444, btrfs_sectorsize_show
, btrfs_no_store
);
433 static ssize_t
btrfs_clone_alignment_show(struct kobject
*kobj
,
434 struct kobj_attribute
*a
, char *buf
)
436 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
438 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->sectorsize
);
441 BTRFS_ATTR_RW(clone_alignment
, 0444, btrfs_clone_alignment_show
, btrfs_no_store
);
443 static struct attribute
*btrfs_attrs
[] = {
444 BTRFS_ATTR_PTR(label
),
445 BTRFS_ATTR_PTR(nodesize
),
446 BTRFS_ATTR_PTR(sectorsize
),
447 BTRFS_ATTR_PTR(clone_alignment
),
451 static void btrfs_release_super_kobj(struct kobject
*kobj
)
453 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
454 complete(&fs_info
->kobj_unregister
);
457 static struct kobj_type btrfs_ktype
= {
458 .sysfs_ops
= &kobj_sysfs_ops
,
459 .release
= btrfs_release_super_kobj
,
460 .default_attrs
= btrfs_attrs
,
463 static inline struct btrfs_fs_info
*to_fs_info(struct kobject
*kobj
)
465 if (kobj
->ktype
!= &btrfs_ktype
)
467 return container_of(kobj
, struct btrfs_fs_info
, super_kobj
);
470 #define NUM_FEATURE_BITS 64
471 static char btrfs_unknown_feature_names
[3][NUM_FEATURE_BITS
][13];
472 static struct btrfs_feature_attr btrfs_feature_attrs
[3][NUM_FEATURE_BITS
];
474 static u64 supported_feature_masks
[3] = {
475 [FEAT_COMPAT
] = BTRFS_FEATURE_COMPAT_SUPP
,
476 [FEAT_COMPAT_RO
] = BTRFS_FEATURE_COMPAT_RO_SUPP
,
477 [FEAT_INCOMPAT
] = BTRFS_FEATURE_INCOMPAT_SUPP
,
480 static int addrm_unknown_feature_attrs(struct btrfs_fs_info
*fs_info
, bool add
)
484 for (set
= 0; set
< FEAT_MAX
; set
++) {
486 struct attribute
*attrs
[2];
487 struct attribute_group agroup
= {
491 u64 features
= get_features(fs_info
, set
);
492 features
&= ~supported_feature_masks
[set
];
498 for (i
= 0; i
< NUM_FEATURE_BITS
; i
++) {
499 struct btrfs_feature_attr
*fa
;
501 if (!(features
& (1ULL << i
)))
504 fa
= &btrfs_feature_attrs
[set
][i
];
505 attrs
[0] = &fa
->kobj_attr
.attr
;
508 ret
= sysfs_merge_group(&fs_info
->super_kobj
,
513 sysfs_unmerge_group(&fs_info
->super_kobj
,
521 static void __btrfs_sysfs_remove_one(struct btrfs_fs_info
*fs_info
)
523 kobject_del(&fs_info
->super_kobj
);
524 kobject_put(&fs_info
->super_kobj
);
525 wait_for_completion(&fs_info
->kobj_unregister
);
528 void btrfs_sysfs_remove_one(struct btrfs_fs_info
*fs_info
)
530 if (fs_info
->space_info_kobj
) {
531 sysfs_remove_files(fs_info
->space_info_kobj
, allocation_attrs
);
532 kobject_del(fs_info
->space_info_kobj
);
533 kobject_put(fs_info
->space_info_kobj
);
535 kobject_del(fs_info
->device_dir_kobj
);
536 kobject_put(fs_info
->device_dir_kobj
);
537 addrm_unknown_feature_attrs(fs_info
, false);
538 sysfs_remove_group(&fs_info
->super_kobj
, &btrfs_feature_attr_group
);
539 __btrfs_sysfs_remove_one(fs_info
);
542 const char * const btrfs_feature_set_names
[3] = {
543 [FEAT_COMPAT
] = "compat",
544 [FEAT_COMPAT_RO
] = "compat_ro",
545 [FEAT_INCOMPAT
] = "incompat",
548 char *btrfs_printable_features(enum btrfs_feature_set set
, u64 flags
)
550 size_t bufsize
= 4096; /* safe max, 64 names * 64 bytes */
555 str
= kmalloc(bufsize
, GFP_KERNEL
);
559 for (i
= 0; i
< ARRAY_SIZE(btrfs_feature_attrs
[set
]); i
++) {
562 if (!(flags
& (1ULL << i
)))
565 name
= btrfs_feature_attrs
[set
][i
].kobj_attr
.attr
.name
;
566 len
+= snprintf(str
+ len
, bufsize
- len
, "%s%s",
567 len
? "," : "", name
);
573 static void init_feature_attrs(void)
575 struct btrfs_feature_attr
*fa
;
578 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names
) !=
579 ARRAY_SIZE(btrfs_feature_attrs
));
580 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names
[0]) !=
581 ARRAY_SIZE(btrfs_feature_attrs
[0]));
583 memset(btrfs_feature_attrs
, 0, sizeof(btrfs_feature_attrs
));
584 memset(btrfs_unknown_feature_names
, 0,
585 sizeof(btrfs_unknown_feature_names
));
587 for (i
= 0; btrfs_supported_feature_attrs
[i
]; i
++) {
588 struct btrfs_feature_attr
*sfa
;
589 struct attribute
*a
= btrfs_supported_feature_attrs
[i
];
591 sfa
= attr_to_btrfs_feature_attr(a
);
592 bit
= ilog2(sfa
->feature_bit
);
593 fa
= &btrfs_feature_attrs
[sfa
->feature_set
][bit
];
595 fa
->kobj_attr
.attr
.name
= sfa
->kobj_attr
.attr
.name
;
598 for (set
= 0; set
< FEAT_MAX
; set
++) {
599 for (i
= 0; i
< ARRAY_SIZE(btrfs_feature_attrs
[set
]); i
++) {
600 char *name
= btrfs_unknown_feature_names
[set
][i
];
601 fa
= &btrfs_feature_attrs
[set
][i
];
603 if (fa
->kobj_attr
.attr
.name
)
606 snprintf(name
, 13, "%s:%u",
607 btrfs_feature_set_names
[set
], i
);
609 fa
->kobj_attr
.attr
.name
= name
;
610 fa
->kobj_attr
.attr
.mode
= S_IRUGO
;
611 fa
->feature_set
= set
;
612 fa
->feature_bit
= 1ULL << i
;
617 int btrfs_kobj_rm_device(struct btrfs_fs_info
*fs_info
,
618 struct btrfs_device
*one_device
)
620 struct hd_struct
*disk
;
621 struct kobject
*disk_kobj
;
623 if (!fs_info
->device_dir_kobj
)
626 if (one_device
&& one_device
->bdev
) {
627 disk
= one_device
->bdev
->bd_part
;
628 disk_kobj
= &part_to_dev(disk
)->kobj
;
630 sysfs_remove_link(fs_info
->device_dir_kobj
,
637 int btrfs_kobj_add_device(struct btrfs_fs_info
*fs_info
,
638 struct btrfs_device
*one_device
)
641 struct btrfs_fs_devices
*fs_devices
= fs_info
->fs_devices
;
642 struct btrfs_device
*dev
;
644 if (!fs_info
->device_dir_kobj
)
645 fs_info
->device_dir_kobj
= kobject_create_and_add("devices",
646 &fs_info
->super_kobj
);
648 if (!fs_info
->device_dir_kobj
)
651 list_for_each_entry(dev
, &fs_devices
->devices
, dev_list
) {
652 struct hd_struct
*disk
;
653 struct kobject
*disk_kobj
;
658 if (one_device
&& one_device
!= dev
)
661 disk
= dev
->bdev
->bd_part
;
662 disk_kobj
= &part_to_dev(disk
)->kobj
;
664 error
= sysfs_create_link(fs_info
->device_dir_kobj
,
665 disk_kobj
, disk_kobj
->name
);
673 /* /sys/fs/btrfs/ entry */
674 static struct kset
*btrfs_kset
;
676 /* /sys/kernel/debug/btrfs */
677 static struct dentry
*btrfs_debugfs_root_dentry
;
679 /* Debugging tunables and exported data */
680 u64 btrfs_debugfs_test
;
682 int btrfs_sysfs_add_one(struct btrfs_fs_info
*fs_info
)
686 init_completion(&fs_info
->kobj_unregister
);
687 fs_info
->super_kobj
.kset
= btrfs_kset
;
688 error
= kobject_init_and_add(&fs_info
->super_kobj
, &btrfs_ktype
, NULL
,
689 "%pU", fs_info
->fsid
);
693 error
= sysfs_create_group(&fs_info
->super_kobj
,
694 &btrfs_feature_attr_group
);
696 __btrfs_sysfs_remove_one(fs_info
);
700 error
= addrm_unknown_feature_attrs(fs_info
, true);
704 error
= btrfs_kobj_add_device(fs_info
, NULL
);
708 fs_info
->space_info_kobj
= kobject_create_and_add("allocation",
709 &fs_info
->super_kobj
);
710 if (!fs_info
->space_info_kobj
) {
715 error
= sysfs_create_files(fs_info
->space_info_kobj
, allocation_attrs
);
721 btrfs_sysfs_remove_one(fs_info
);
725 static int btrfs_init_debugfs(void)
727 #ifdef CONFIG_DEBUG_FS
728 btrfs_debugfs_root_dentry
= debugfs_create_dir("btrfs", NULL
);
729 if (!btrfs_debugfs_root_dentry
)
732 debugfs_create_u64("test", S_IRUGO
| S_IWUGO
, btrfs_debugfs_root_dentry
,
733 &btrfs_debugfs_test
);
738 int btrfs_init_sysfs(void)
742 btrfs_kset
= kset_create_and_add("btrfs", NULL
, fs_kobj
);
746 ret
= btrfs_init_debugfs();
750 init_feature_attrs();
751 ret
= sysfs_create_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
756 void btrfs_exit_sysfs(void)
758 sysfs_remove_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
759 kset_unregister(btrfs_kset
);
760 debugfs_remove_recursive(btrfs_debugfs_root_dentry
);