1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2007 Oracle. All rights reserved.
6 #include <linux/sched.h>
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/completion.h>
10 #include <linux/kobject.h>
11 #include <linux/bug.h>
12 #include <linux/debugfs.h>
16 #include "transaction.h"
20 static inline struct btrfs_fs_info
*to_fs_info(struct kobject
*kobj
);
21 static inline struct btrfs_fs_devices
*to_fs_devs(struct kobject
*kobj
);
23 static u64
get_features(struct btrfs_fs_info
*fs_info
,
24 enum btrfs_feature_set set
)
26 struct btrfs_super_block
*disk_super
= fs_info
->super_copy
;
27 if (set
== FEAT_COMPAT
)
28 return btrfs_super_compat_flags(disk_super
);
29 else if (set
== FEAT_COMPAT_RO
)
30 return btrfs_super_compat_ro_flags(disk_super
);
32 return btrfs_super_incompat_flags(disk_super
);
35 static void set_features(struct btrfs_fs_info
*fs_info
,
36 enum btrfs_feature_set set
, u64 features
)
38 struct btrfs_super_block
*disk_super
= fs_info
->super_copy
;
39 if (set
== FEAT_COMPAT
)
40 btrfs_set_super_compat_flags(disk_super
, features
);
41 else if (set
== FEAT_COMPAT_RO
)
42 btrfs_set_super_compat_ro_flags(disk_super
, features
);
44 btrfs_set_super_incompat_flags(disk_super
, features
);
47 static int can_modify_feature(struct btrfs_feature_attr
*fa
)
51 switch (fa
->feature_set
) {
53 set
= BTRFS_FEATURE_COMPAT_SAFE_SET
;
54 clear
= BTRFS_FEATURE_COMPAT_SAFE_CLEAR
;
57 set
= BTRFS_FEATURE_COMPAT_RO_SAFE_SET
;
58 clear
= BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR
;
61 set
= BTRFS_FEATURE_INCOMPAT_SAFE_SET
;
62 clear
= BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR
;
65 pr_warn("btrfs: sysfs: unknown feature set %d\n",
70 if (set
& fa
->feature_bit
)
72 if (clear
& fa
->feature_bit
)
78 static ssize_t
btrfs_feature_attr_show(struct kobject
*kobj
,
79 struct kobj_attribute
*a
, char *buf
)
82 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
83 struct btrfs_feature_attr
*fa
= to_btrfs_feature_attr(a
);
85 u64 features
= get_features(fs_info
, fa
->feature_set
);
86 if (features
& fa
->feature_bit
)
89 val
= can_modify_feature(fa
);
91 return snprintf(buf
, PAGE_SIZE
, "%d\n", val
);
94 static ssize_t
btrfs_feature_attr_store(struct kobject
*kobj
,
95 struct kobj_attribute
*a
,
96 const char *buf
, size_t count
)
98 struct btrfs_fs_info
*fs_info
;
99 struct btrfs_feature_attr
*fa
= to_btrfs_feature_attr(a
);
100 u64 features
, set
, clear
;
104 fs_info
= to_fs_info(kobj
);
108 if (sb_rdonly(fs_info
->sb
))
111 ret
= kstrtoul(skip_spaces(buf
), 0, &val
);
115 if (fa
->feature_set
== FEAT_COMPAT
) {
116 set
= BTRFS_FEATURE_COMPAT_SAFE_SET
;
117 clear
= BTRFS_FEATURE_COMPAT_SAFE_CLEAR
;
118 } else if (fa
->feature_set
== FEAT_COMPAT_RO
) {
119 set
= BTRFS_FEATURE_COMPAT_RO_SAFE_SET
;
120 clear
= BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR
;
122 set
= BTRFS_FEATURE_INCOMPAT_SAFE_SET
;
123 clear
= BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR
;
126 features
= get_features(fs_info
, fa
->feature_set
);
129 if ((val
&& (features
& fa
->feature_bit
)) ||
130 (!val
&& !(features
& fa
->feature_bit
)))
133 if ((val
&& !(set
& fa
->feature_bit
)) ||
134 (!val
&& !(clear
& fa
->feature_bit
))) {
136 "%sabling feature %s on mounted fs is not supported.",
137 val
? "En" : "Dis", fa
->kobj_attr
.attr
.name
);
141 btrfs_info(fs_info
, "%s %s feature flag",
142 val
? "Setting" : "Clearing", fa
->kobj_attr
.attr
.name
);
144 spin_lock(&fs_info
->super_lock
);
145 features
= get_features(fs_info
, fa
->feature_set
);
147 features
|= fa
->feature_bit
;
149 features
&= ~fa
->feature_bit
;
150 set_features(fs_info
, fa
->feature_set
, features
);
151 spin_unlock(&fs_info
->super_lock
);
154 * We don't want to do full transaction commit from inside sysfs
156 btrfs_set_pending(fs_info
, COMMIT
);
157 wake_up_process(fs_info
->transaction_kthread
);
162 static umode_t
btrfs_feature_visible(struct kobject
*kobj
,
163 struct attribute
*attr
, int unused
)
165 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
166 umode_t mode
= attr
->mode
;
169 struct btrfs_feature_attr
*fa
;
172 fa
= attr_to_btrfs_feature_attr(attr
);
173 features
= get_features(fs_info
, fa
->feature_set
);
175 if (can_modify_feature(fa
))
177 else if (!(features
& fa
->feature_bit
))
184 BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref
, MIXED_BACKREF
);
185 BTRFS_FEAT_ATTR_INCOMPAT(default_subvol
, DEFAULT_SUBVOL
);
186 BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups
, MIXED_GROUPS
);
187 BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo
, COMPRESS_LZO
);
188 BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd
, COMPRESS_ZSTD
);
189 BTRFS_FEAT_ATTR_INCOMPAT(big_metadata
, BIG_METADATA
);
190 BTRFS_FEAT_ATTR_INCOMPAT(extended_iref
, EXTENDED_IREF
);
191 BTRFS_FEAT_ATTR_INCOMPAT(raid56
, RAID56
);
192 BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata
, SKINNY_METADATA
);
193 BTRFS_FEAT_ATTR_INCOMPAT(no_holes
, NO_HOLES
);
194 BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid
, METADATA_UUID
);
195 BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree
, FREE_SPACE_TREE
);
197 static struct attribute
*btrfs_supported_feature_attrs
[] = {
198 BTRFS_FEAT_ATTR_PTR(mixed_backref
),
199 BTRFS_FEAT_ATTR_PTR(default_subvol
),
200 BTRFS_FEAT_ATTR_PTR(mixed_groups
),
201 BTRFS_FEAT_ATTR_PTR(compress_lzo
),
202 BTRFS_FEAT_ATTR_PTR(compress_zstd
),
203 BTRFS_FEAT_ATTR_PTR(big_metadata
),
204 BTRFS_FEAT_ATTR_PTR(extended_iref
),
205 BTRFS_FEAT_ATTR_PTR(raid56
),
206 BTRFS_FEAT_ATTR_PTR(skinny_metadata
),
207 BTRFS_FEAT_ATTR_PTR(no_holes
),
208 BTRFS_FEAT_ATTR_PTR(metadata_uuid
),
209 BTRFS_FEAT_ATTR_PTR(free_space_tree
),
214 * Features which depend on feature bits and may differ between each fs.
216 * /sys/fs/btrfs/features lists all available features of this kernel while
217 * /sys/fs/btrfs/UUID/features shows features of the fs which are enabled or
218 * can be changed online.
220 static const struct attribute_group btrfs_feature_attr_group
= {
222 .is_visible
= btrfs_feature_visible
,
223 .attrs
= btrfs_supported_feature_attrs
,
226 static ssize_t
rmdir_subvol_show(struct kobject
*kobj
,
227 struct kobj_attribute
*ka
, char *buf
)
229 return snprintf(buf
, PAGE_SIZE
, "0\n");
231 BTRFS_ATTR(static_feature
, rmdir_subvol
, rmdir_subvol_show
);
233 static struct attribute
*btrfs_supported_static_feature_attrs
[] = {
234 BTRFS_ATTR_PTR(static_feature
, rmdir_subvol
),
239 * Features which only depend on kernel version.
241 * These are listed in /sys/fs/btrfs/features along with
242 * btrfs_feature_attr_group
244 static const struct attribute_group btrfs_static_feature_attr_group
= {
246 .attrs
= btrfs_supported_static_feature_attrs
,
249 static ssize_t
btrfs_show_u64(u64
*value_ptr
, spinlock_t
*lock
, char *buf
)
257 return snprintf(buf
, PAGE_SIZE
, "%llu\n", val
);
260 static ssize_t
global_rsv_size_show(struct kobject
*kobj
,
261 struct kobj_attribute
*ka
, char *buf
)
263 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
->parent
);
264 struct btrfs_block_rsv
*block_rsv
= &fs_info
->global_block_rsv
;
265 return btrfs_show_u64(&block_rsv
->size
, &block_rsv
->lock
, buf
);
267 BTRFS_ATTR(allocation
, global_rsv_size
, global_rsv_size_show
);
269 static ssize_t
global_rsv_reserved_show(struct kobject
*kobj
,
270 struct kobj_attribute
*a
, char *buf
)
272 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
->parent
);
273 struct btrfs_block_rsv
*block_rsv
= &fs_info
->global_block_rsv
;
274 return btrfs_show_u64(&block_rsv
->reserved
, &block_rsv
->lock
, buf
);
276 BTRFS_ATTR(allocation
, global_rsv_reserved
, global_rsv_reserved_show
);
278 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
279 #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj)
281 static ssize_t
raid_bytes_show(struct kobject
*kobj
,
282 struct kobj_attribute
*attr
, char *buf
);
283 BTRFS_ATTR(raid
, total_bytes
, raid_bytes_show
);
284 BTRFS_ATTR(raid
, used_bytes
, raid_bytes_show
);
286 static ssize_t
raid_bytes_show(struct kobject
*kobj
,
287 struct kobj_attribute
*attr
, char *buf
)
290 struct btrfs_space_info
*sinfo
= to_space_info(kobj
->parent
);
291 struct btrfs_block_group_cache
*block_group
;
292 int index
= btrfs_bg_flags_to_raid_index(to_raid_kobj(kobj
)->flags
);
295 down_read(&sinfo
->groups_sem
);
296 list_for_each_entry(block_group
, &sinfo
->block_groups
[index
], list
) {
297 if (&attr
->attr
== BTRFS_ATTR_PTR(raid
, total_bytes
))
298 val
+= block_group
->key
.offset
;
300 val
+= btrfs_block_group_used(&block_group
->item
);
302 up_read(&sinfo
->groups_sem
);
303 return snprintf(buf
, PAGE_SIZE
, "%llu\n", val
);
306 static struct attribute
*raid_attributes
[] = {
307 BTRFS_ATTR_PTR(raid
, total_bytes
),
308 BTRFS_ATTR_PTR(raid
, used_bytes
),
312 static void release_raid_kobj(struct kobject
*kobj
)
314 kfree(to_raid_kobj(kobj
));
317 struct kobj_type btrfs_raid_ktype
= {
318 .sysfs_ops
= &kobj_sysfs_ops
,
319 .release
= release_raid_kobj
,
320 .default_attrs
= raid_attributes
,
323 #define SPACE_INFO_ATTR(field) \
324 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \
325 struct kobj_attribute *a, \
328 struct btrfs_space_info *sinfo = to_space_info(kobj); \
329 return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \
331 BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field)
333 static ssize_t
btrfs_space_info_show_total_bytes_pinned(struct kobject
*kobj
,
334 struct kobj_attribute
*a
,
337 struct btrfs_space_info
*sinfo
= to_space_info(kobj
);
338 s64 val
= percpu_counter_sum(&sinfo
->total_bytes_pinned
);
339 return snprintf(buf
, PAGE_SIZE
, "%lld\n", val
);
342 SPACE_INFO_ATTR(flags
);
343 SPACE_INFO_ATTR(total_bytes
);
344 SPACE_INFO_ATTR(bytes_used
);
345 SPACE_INFO_ATTR(bytes_pinned
);
346 SPACE_INFO_ATTR(bytes_reserved
);
347 SPACE_INFO_ATTR(bytes_may_use
);
348 SPACE_INFO_ATTR(bytes_readonly
);
349 SPACE_INFO_ATTR(disk_used
);
350 SPACE_INFO_ATTR(disk_total
);
351 BTRFS_ATTR(space_info
, total_bytes_pinned
,
352 btrfs_space_info_show_total_bytes_pinned
);
354 static struct attribute
*space_info_attrs
[] = {
355 BTRFS_ATTR_PTR(space_info
, flags
),
356 BTRFS_ATTR_PTR(space_info
, total_bytes
),
357 BTRFS_ATTR_PTR(space_info
, bytes_used
),
358 BTRFS_ATTR_PTR(space_info
, bytes_pinned
),
359 BTRFS_ATTR_PTR(space_info
, bytes_reserved
),
360 BTRFS_ATTR_PTR(space_info
, bytes_may_use
),
361 BTRFS_ATTR_PTR(space_info
, bytes_readonly
),
362 BTRFS_ATTR_PTR(space_info
, disk_used
),
363 BTRFS_ATTR_PTR(space_info
, disk_total
),
364 BTRFS_ATTR_PTR(space_info
, total_bytes_pinned
),
368 static void space_info_release(struct kobject
*kobj
)
370 struct btrfs_space_info
*sinfo
= to_space_info(kobj
);
371 percpu_counter_destroy(&sinfo
->total_bytes_pinned
);
375 struct kobj_type space_info_ktype
= {
376 .sysfs_ops
= &kobj_sysfs_ops
,
377 .release
= space_info_release
,
378 .default_attrs
= space_info_attrs
,
381 static const struct attribute
*allocation_attrs
[] = {
382 BTRFS_ATTR_PTR(allocation
, global_rsv_reserved
),
383 BTRFS_ATTR_PTR(allocation
, global_rsv_size
),
387 static ssize_t
btrfs_label_show(struct kobject
*kobj
,
388 struct kobj_attribute
*a
, char *buf
)
390 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
391 char *label
= fs_info
->super_copy
->label
;
394 spin_lock(&fs_info
->super_lock
);
395 ret
= snprintf(buf
, PAGE_SIZE
, label
[0] ? "%s\n" : "%s", label
);
396 spin_unlock(&fs_info
->super_lock
);
401 static ssize_t
btrfs_label_store(struct kobject
*kobj
,
402 struct kobj_attribute
*a
,
403 const char *buf
, size_t len
)
405 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
411 if (sb_rdonly(fs_info
->sb
))
415 * p_len is the len until the first occurrence of either
418 p_len
= strcspn(buf
, "\n");
420 if (p_len
>= BTRFS_LABEL_SIZE
)
423 spin_lock(&fs_info
->super_lock
);
424 memset(fs_info
->super_copy
->label
, 0, BTRFS_LABEL_SIZE
);
425 memcpy(fs_info
->super_copy
->label
, buf
, p_len
);
426 spin_unlock(&fs_info
->super_lock
);
429 * We don't want to do full transaction commit from inside sysfs
431 btrfs_set_pending(fs_info
, COMMIT
);
432 wake_up_process(fs_info
->transaction_kthread
);
436 BTRFS_ATTR_RW(, label
, btrfs_label_show
, btrfs_label_store
);
438 static ssize_t
btrfs_nodesize_show(struct kobject
*kobj
,
439 struct kobj_attribute
*a
, char *buf
)
441 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
443 return snprintf(buf
, PAGE_SIZE
, "%u\n", fs_info
->super_copy
->nodesize
);
446 BTRFS_ATTR(, nodesize
, btrfs_nodesize_show
);
448 static ssize_t
btrfs_sectorsize_show(struct kobject
*kobj
,
449 struct kobj_attribute
*a
, char *buf
)
451 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
453 return snprintf(buf
, PAGE_SIZE
, "%u\n",
454 fs_info
->super_copy
->sectorsize
);
457 BTRFS_ATTR(, sectorsize
, btrfs_sectorsize_show
);
459 static ssize_t
btrfs_clone_alignment_show(struct kobject
*kobj
,
460 struct kobj_attribute
*a
, char *buf
)
462 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
464 return snprintf(buf
, PAGE_SIZE
, "%u\n",
465 fs_info
->super_copy
->sectorsize
);
468 BTRFS_ATTR(, clone_alignment
, btrfs_clone_alignment_show
);
470 static ssize_t
quota_override_show(struct kobject
*kobj
,
471 struct kobj_attribute
*a
, char *buf
)
473 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
476 quota_override
= test_bit(BTRFS_FS_QUOTA_OVERRIDE
, &fs_info
->flags
);
477 return snprintf(buf
, PAGE_SIZE
, "%d\n", quota_override
);
480 static ssize_t
quota_override_store(struct kobject
*kobj
,
481 struct kobj_attribute
*a
,
482 const char *buf
, size_t len
)
484 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
491 if (!capable(CAP_SYS_RESOURCE
))
494 err
= kstrtoul(buf
, 10, &knob
);
501 set_bit(BTRFS_FS_QUOTA_OVERRIDE
, &fs_info
->flags
);
503 clear_bit(BTRFS_FS_QUOTA_OVERRIDE
, &fs_info
->flags
);
508 BTRFS_ATTR_RW(, quota_override
, quota_override_show
, quota_override_store
);
510 static ssize_t
btrfs_metadata_uuid_show(struct kobject
*kobj
,
511 struct kobj_attribute
*a
, char *buf
)
513 struct btrfs_fs_info
*fs_info
= to_fs_info(kobj
);
515 return snprintf(buf
, PAGE_SIZE
, "%pU\n",
516 fs_info
->fs_devices
->metadata_uuid
);
519 BTRFS_ATTR(, metadata_uuid
, btrfs_metadata_uuid_show
);
521 static const struct attribute
*btrfs_attrs
[] = {
522 BTRFS_ATTR_PTR(, label
),
523 BTRFS_ATTR_PTR(, nodesize
),
524 BTRFS_ATTR_PTR(, sectorsize
),
525 BTRFS_ATTR_PTR(, clone_alignment
),
526 BTRFS_ATTR_PTR(, quota_override
),
527 BTRFS_ATTR_PTR(, metadata_uuid
),
531 static void btrfs_release_fsid_kobj(struct kobject
*kobj
)
533 struct btrfs_fs_devices
*fs_devs
= to_fs_devs(kobj
);
535 memset(&fs_devs
->fsid_kobj
, 0, sizeof(struct kobject
));
536 complete(&fs_devs
->kobj_unregister
);
539 static struct kobj_type btrfs_ktype
= {
540 .sysfs_ops
= &kobj_sysfs_ops
,
541 .release
= btrfs_release_fsid_kobj
,
544 static inline struct btrfs_fs_devices
*to_fs_devs(struct kobject
*kobj
)
546 if (kobj
->ktype
!= &btrfs_ktype
)
548 return container_of(kobj
, struct btrfs_fs_devices
, fsid_kobj
);
551 static inline struct btrfs_fs_info
*to_fs_info(struct kobject
*kobj
)
553 if (kobj
->ktype
!= &btrfs_ktype
)
555 return to_fs_devs(kobj
)->fs_info
;
558 #define NUM_FEATURE_BITS 64
559 #define BTRFS_FEATURE_NAME_MAX 13
560 static char btrfs_unknown_feature_names
[FEAT_MAX
][NUM_FEATURE_BITS
][BTRFS_FEATURE_NAME_MAX
];
561 static struct btrfs_feature_attr btrfs_feature_attrs
[FEAT_MAX
][NUM_FEATURE_BITS
];
563 static const u64 supported_feature_masks
[FEAT_MAX
] = {
564 [FEAT_COMPAT
] = BTRFS_FEATURE_COMPAT_SUPP
,
565 [FEAT_COMPAT_RO
] = BTRFS_FEATURE_COMPAT_RO_SUPP
,
566 [FEAT_INCOMPAT
] = BTRFS_FEATURE_INCOMPAT_SUPP
,
569 static int addrm_unknown_feature_attrs(struct btrfs_fs_info
*fs_info
, bool add
)
573 for (set
= 0; set
< FEAT_MAX
; set
++) {
575 struct attribute
*attrs
[2];
576 struct attribute_group agroup
= {
580 u64 features
= get_features(fs_info
, set
);
581 features
&= ~supported_feature_masks
[set
];
587 for (i
= 0; i
< NUM_FEATURE_BITS
; i
++) {
588 struct btrfs_feature_attr
*fa
;
590 if (!(features
& (1ULL << i
)))
593 fa
= &btrfs_feature_attrs
[set
][i
];
594 attrs
[0] = &fa
->kobj_attr
.attr
;
597 ret
= sysfs_merge_group(&fs_info
->fs_devices
->fsid_kobj
,
602 sysfs_unmerge_group(&fs_info
->fs_devices
->fsid_kobj
,
610 static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices
*fs_devs
)
612 if (fs_devs
->device_dir_kobj
) {
613 kobject_del(fs_devs
->device_dir_kobj
);
614 kobject_put(fs_devs
->device_dir_kobj
);
615 fs_devs
->device_dir_kobj
= NULL
;
618 if (fs_devs
->fsid_kobj
.state_initialized
) {
619 kobject_del(&fs_devs
->fsid_kobj
);
620 kobject_put(&fs_devs
->fsid_kobj
);
621 wait_for_completion(&fs_devs
->kobj_unregister
);
625 /* when fs_devs is NULL it will remove all fsid kobject */
626 void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices
*fs_devs
)
628 struct list_head
*fs_uuids
= btrfs_get_fs_uuids();
631 __btrfs_sysfs_remove_fsid(fs_devs
);
635 list_for_each_entry(fs_devs
, fs_uuids
, fs_list
) {
636 __btrfs_sysfs_remove_fsid(fs_devs
);
640 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info
*fs_info
)
642 btrfs_reset_fs_info_ptr(fs_info
);
644 if (fs_info
->space_info_kobj
) {
645 sysfs_remove_files(fs_info
->space_info_kobj
, allocation_attrs
);
646 kobject_del(fs_info
->space_info_kobj
);
647 kobject_put(fs_info
->space_info_kobj
);
649 addrm_unknown_feature_attrs(fs_info
, false);
650 sysfs_remove_group(&fs_info
->fs_devices
->fsid_kobj
, &btrfs_feature_attr_group
);
651 sysfs_remove_files(&fs_info
->fs_devices
->fsid_kobj
, btrfs_attrs
);
652 btrfs_sysfs_rm_device_link(fs_info
->fs_devices
, NULL
);
655 const char * const btrfs_feature_set_names
[FEAT_MAX
] = {
656 [FEAT_COMPAT
] = "compat",
657 [FEAT_COMPAT_RO
] = "compat_ro",
658 [FEAT_INCOMPAT
] = "incompat",
661 char *btrfs_printable_features(enum btrfs_feature_set set
, u64 flags
)
663 size_t bufsize
= 4096; /* safe max, 64 names * 64 bytes */
668 str
= kmalloc(bufsize
, GFP_KERNEL
);
672 for (i
= 0; i
< ARRAY_SIZE(btrfs_feature_attrs
[set
]); i
++) {
675 if (!(flags
& (1ULL << i
)))
678 name
= btrfs_feature_attrs
[set
][i
].kobj_attr
.attr
.name
;
679 len
+= snprintf(str
+ len
, bufsize
- len
, "%s%s",
680 len
? "," : "", name
);
686 static void init_feature_attrs(void)
688 struct btrfs_feature_attr
*fa
;
691 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names
) !=
692 ARRAY_SIZE(btrfs_feature_attrs
));
693 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names
[0]) !=
694 ARRAY_SIZE(btrfs_feature_attrs
[0]));
696 memset(btrfs_feature_attrs
, 0, sizeof(btrfs_feature_attrs
));
697 memset(btrfs_unknown_feature_names
, 0,
698 sizeof(btrfs_unknown_feature_names
));
700 for (i
= 0; btrfs_supported_feature_attrs
[i
]; i
++) {
701 struct btrfs_feature_attr
*sfa
;
702 struct attribute
*a
= btrfs_supported_feature_attrs
[i
];
704 sfa
= attr_to_btrfs_feature_attr(a
);
705 bit
= ilog2(sfa
->feature_bit
);
706 fa
= &btrfs_feature_attrs
[sfa
->feature_set
][bit
];
708 fa
->kobj_attr
.attr
.name
= sfa
->kobj_attr
.attr
.name
;
711 for (set
= 0; set
< FEAT_MAX
; set
++) {
712 for (i
= 0; i
< ARRAY_SIZE(btrfs_feature_attrs
[set
]); i
++) {
713 char *name
= btrfs_unknown_feature_names
[set
][i
];
714 fa
= &btrfs_feature_attrs
[set
][i
];
716 if (fa
->kobj_attr
.attr
.name
)
719 snprintf(name
, BTRFS_FEATURE_NAME_MAX
, "%s:%u",
720 btrfs_feature_set_names
[set
], i
);
722 fa
->kobj_attr
.attr
.name
= name
;
723 fa
->kobj_attr
.attr
.mode
= S_IRUGO
;
724 fa
->feature_set
= set
;
725 fa
->feature_bit
= 1ULL << i
;
730 /* when one_device is NULL, it removes all device links */
732 int btrfs_sysfs_rm_device_link(struct btrfs_fs_devices
*fs_devices
,
733 struct btrfs_device
*one_device
)
735 struct hd_struct
*disk
;
736 struct kobject
*disk_kobj
;
738 if (!fs_devices
->device_dir_kobj
)
741 if (one_device
&& one_device
->bdev
) {
742 disk
= one_device
->bdev
->bd_part
;
743 disk_kobj
= &part_to_dev(disk
)->kobj
;
745 sysfs_remove_link(fs_devices
->device_dir_kobj
,
752 list_for_each_entry(one_device
,
753 &fs_devices
->devices
, dev_list
) {
754 if (!one_device
->bdev
)
756 disk
= one_device
->bdev
->bd_part
;
757 disk_kobj
= &part_to_dev(disk
)->kobj
;
759 sysfs_remove_link(fs_devices
->device_dir_kobj
,
766 int btrfs_sysfs_add_device(struct btrfs_fs_devices
*fs_devs
)
768 if (!fs_devs
->device_dir_kobj
)
769 fs_devs
->device_dir_kobj
= kobject_create_and_add("devices",
770 &fs_devs
->fsid_kobj
);
772 if (!fs_devs
->device_dir_kobj
)
778 int btrfs_sysfs_add_device_link(struct btrfs_fs_devices
*fs_devices
,
779 struct btrfs_device
*one_device
)
782 struct btrfs_device
*dev
;
784 list_for_each_entry(dev
, &fs_devices
->devices
, dev_list
) {
785 struct hd_struct
*disk
;
786 struct kobject
*disk_kobj
;
791 if (one_device
&& one_device
!= dev
)
794 disk
= dev
->bdev
->bd_part
;
795 disk_kobj
= &part_to_dev(disk
)->kobj
;
797 error
= sysfs_create_link(fs_devices
->device_dir_kobj
,
798 disk_kobj
, disk_kobj
->name
);
806 /* /sys/fs/btrfs/ entry */
807 static struct kset
*btrfs_kset
;
809 /* /sys/kernel/debug/btrfs */
810 static struct dentry
*btrfs_debugfs_root_dentry
;
812 /* Debugging tunables and exported data */
813 u64 btrfs_debugfs_test
;
816 * Can be called by the device discovery thread.
817 * And parent can be specified for seed device
819 int btrfs_sysfs_add_fsid(struct btrfs_fs_devices
*fs_devs
,
820 struct kobject
*parent
)
824 init_completion(&fs_devs
->kobj_unregister
);
825 fs_devs
->fsid_kobj
.kset
= btrfs_kset
;
826 error
= kobject_init_and_add(&fs_devs
->fsid_kobj
,
827 &btrfs_ktype
, parent
, "%pU", fs_devs
->fsid
);
831 int btrfs_sysfs_add_mounted(struct btrfs_fs_info
*fs_info
)
834 struct btrfs_fs_devices
*fs_devs
= fs_info
->fs_devices
;
835 struct kobject
*fsid_kobj
= &fs_devs
->fsid_kobj
;
837 btrfs_set_fs_info_ptr(fs_info
);
839 error
= btrfs_sysfs_add_device_link(fs_devs
, NULL
);
843 error
= sysfs_create_files(fsid_kobj
, btrfs_attrs
);
845 btrfs_sysfs_rm_device_link(fs_devs
, NULL
);
849 error
= sysfs_create_group(fsid_kobj
,
850 &btrfs_feature_attr_group
);
854 error
= addrm_unknown_feature_attrs(fs_info
, true);
858 fs_info
->space_info_kobj
= kobject_create_and_add("allocation",
860 if (!fs_info
->space_info_kobj
) {
865 error
= sysfs_create_files(fs_info
->space_info_kobj
, allocation_attrs
);
871 btrfs_sysfs_remove_mounted(fs_info
);
877 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current
878 * values in superblock. Call after any changes to incompat/compat_ro flags
880 void btrfs_sysfs_feature_update(struct btrfs_fs_info
*fs_info
,
881 u64 bit
, enum btrfs_feature_set set
)
883 struct btrfs_fs_devices
*fs_devs
;
884 struct kobject
*fsid_kobj
;
891 features
= get_features(fs_info
, set
);
892 ASSERT(bit
& supported_feature_masks
[set
]);
894 fs_devs
= fs_info
->fs_devices
;
895 fsid_kobj
= &fs_devs
->fsid_kobj
;
897 if (!fsid_kobj
->state_initialized
)
901 * FIXME: this is too heavy to update just one value, ideally we'd like
902 * to use sysfs_update_group but some refactoring is needed first.
904 sysfs_remove_group(fsid_kobj
, &btrfs_feature_attr_group
);
905 ret
= sysfs_create_group(fsid_kobj
, &btrfs_feature_attr_group
);
908 static int btrfs_init_debugfs(void)
910 #ifdef CONFIG_DEBUG_FS
911 btrfs_debugfs_root_dentry
= debugfs_create_dir("btrfs", NULL
);
912 if (!btrfs_debugfs_root_dentry
)
916 * Example code, how to export data through debugfs.
918 * file: /sys/kernel/debug/btrfs/test
919 * contents of: btrfs_debugfs_test
921 #ifdef CONFIG_BTRFS_DEBUG
922 debugfs_create_u64("test", S_IRUGO
| S_IWUSR
, btrfs_debugfs_root_dentry
,
923 &btrfs_debugfs_test
);
930 int __init
btrfs_init_sysfs(void)
934 btrfs_kset
= kset_create_and_add("btrfs", NULL
, fs_kobj
);
938 ret
= btrfs_init_debugfs();
942 init_feature_attrs();
943 ret
= sysfs_create_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
946 ret
= sysfs_merge_group(&btrfs_kset
->kobj
,
947 &btrfs_static_feature_attr_group
);
949 goto out_remove_group
;
954 sysfs_remove_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
956 debugfs_remove_recursive(btrfs_debugfs_root_dentry
);
958 kset_unregister(btrfs_kset
);
963 void __cold
btrfs_exit_sysfs(void)
965 sysfs_unmerge_group(&btrfs_kset
->kobj
,
966 &btrfs_static_feature_attr_group
);
967 sysfs_remove_group(&btrfs_kset
->kobj
, &btrfs_feature_attr_group
);
968 kset_unregister(btrfs_kset
);
969 debugfs_remove_recursive(btrfs_debugfs_root_dentry
);