2702 lines · 71.2 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2007 Oracle.  All rights reserved. */ #include <linux/sched.h>#include <linux/sched/mm.h>#include <linux/slab.h>#include <linux/spinlock.h>#include <linux/completion.h>#include <linux/bug.h>#include <linux/list.h>#include <linux/string_choices.h>#include "messages.h"#include "ctree.h"#include "discard.h"#include "disk-io.h"#include "send.h"#include "transaction.h"#include "sysfs.h"#include "volumes.h"#include "space-info.h"#include "block-group.h"#include "qgroup.h"#include "misc.h"#include "fs.h"#include "accessors.h" /* * Structure name                       Path * -------------------------------------------------------------------------- * btrfs_supported_static_feature_attrs /sys/fs/btrfs/features * btrfs_supported_feature_attrs	/sys/fs/btrfs/features and *					/sys/fs/btrfs/<uuid>/features * btrfs_attrs				/sys/fs/btrfs/<uuid> * devid_attrs				/sys/fs/btrfs/<uuid>/devinfo/<devid> * allocation_attrs			/sys/fs/btrfs/<uuid>/allocation * qgroup_attrs				/sys/fs/btrfs/<uuid>/qgroups/<level>_<qgroupid> * space_info_attrs			/sys/fs/btrfs/<uuid>/allocation/<bg-type> * raid_attrs				/sys/fs/btrfs/<uuid>/allocation/<bg-type>/<bg-profile> * discard_attrs			/sys/fs/btrfs/<uuid>/discard * * When built with BTRFS_CONFIG_DEBUG: * * btrfs_debug_feature_attrs		/sys/fs/btrfs/debug * btrfs_debug_mount_attrs		/sys/fs/btrfs/<uuid>/debug */ struct btrfs_feature_attr {	struct kobj_attribute kobj_attr;	enum btrfs_feature_set feature_set;	u64 feature_bit;}; /* For raid type sysfs entries */struct raid_kobject {	u64 flags;	struct kobject kobj;}; #define __INIT_KOBJ_ATTR(_name, _mode, _show, _store)			\{									\	.attr	= { .name = __stringify(_name), .mode = _mode },	\	.show	= _show,						\	.store	= _store,						\} #define BTRFS_ATTR_W(_prefix, _name, _store)			        \	static struct kobj_attribute btrfs_attr_##_prefix##_##_name =	\			__INIT_KOBJ_ATTR(_name, 0200, NULL, _store) #define BTRFS_ATTR_RW(_prefix, _name, _show, _store)			\	static struct kobj_attribute btrfs_attr_##_prefix##_##_name =	\			__INIT_KOBJ_ATTR(_name, 0644, _show, _store) #define BTRFS_ATTR(_prefix, _name, _show)				\	static struct kobj_attribute btrfs_attr_##_prefix##_##_name =	\			__INIT_KOBJ_ATTR(_name, 0444, _show, NULL) #define BTRFS_ATTR_PTR(_prefix, _name)					\	(&btrfs_attr_##_prefix##_##_name.attr) #define BTRFS_FEAT_ATTR(_name, _feature_set, _feature_prefix, _feature_bit)  \static struct btrfs_feature_attr btrfs_attr_features_##_name = {	     \	.kobj_attr = __INIT_KOBJ_ATTR(_name, S_IRUGO,			     \				      btrfs_feature_attr_show,		     \				      btrfs_feature_attr_store),	     \	.feature_set	= _feature_set,					     \	.feature_bit	= _feature_prefix ##_## _feature_bit,		     \}#define BTRFS_FEAT_ATTR_PTR(_name)					     \	(&btrfs_attr_features_##_name.kobj_attr.attr) #define BTRFS_FEAT_ATTR_COMPAT(name, feature) \	BTRFS_FEAT_ATTR(name, FEAT_COMPAT, BTRFS_FEATURE_COMPAT, feature)#define BTRFS_FEAT_ATTR_COMPAT_RO(name, feature) \	BTRFS_FEAT_ATTR(name, FEAT_COMPAT_RO, BTRFS_FEATURE_COMPAT_RO, feature)#define BTRFS_FEAT_ATTR_INCOMPAT(name, feature) \	BTRFS_FEAT_ATTR(name, FEAT_INCOMPAT, BTRFS_FEATURE_INCOMPAT, feature) static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj);static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj);static struct kobject *get_btrfs_kobj(struct kobject *kobj); static struct btrfs_feature_attr *to_btrfs_feature_attr(struct kobj_attribute *a){	return container_of(a, struct btrfs_feature_attr, kobj_attr);} static struct kobj_attribute *attr_to_btrfs_attr(struct attribute *attr){	return container_of(attr, struct kobj_attribute, attr);} static struct btrfs_feature_attr *attr_to_btrfs_feature_attr(		struct attribute *attr){	return to_btrfs_feature_attr(attr_to_btrfs_attr(attr));} static u64 get_features(struct btrfs_fs_info *fs_info,			enum btrfs_feature_set set){	struct btrfs_super_block *disk_super = fs_info->super_copy;	if (set == FEAT_COMPAT)		return btrfs_super_compat_flags(disk_super);	else if (set == FEAT_COMPAT_RO)		return btrfs_super_compat_ro_flags(disk_super);	else		return btrfs_super_incompat_flags(disk_super);} static void set_features(struct btrfs_fs_info *fs_info,			 enum btrfs_feature_set set, u64 features){	struct btrfs_super_block *disk_super = fs_info->super_copy;	if (set == FEAT_COMPAT)		btrfs_set_super_compat_flags(disk_super, features);	else if (set == FEAT_COMPAT_RO)		btrfs_set_super_compat_ro_flags(disk_super, features);	else		btrfs_set_super_incompat_flags(disk_super, features);} static int can_modify_feature(struct btrfs_feature_attr *fa){	int val = 0;	u64 set, clear;	switch (fa->feature_set) {	case FEAT_COMPAT:		set = BTRFS_FEATURE_COMPAT_SAFE_SET;		clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;		break;	case FEAT_COMPAT_RO:		set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;		clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;		break;	case FEAT_INCOMPAT:		set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;		clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;		break;	default:		btrfs_warn(NULL, "sysfs: unknown feature set %d", fa->feature_set);		return 0;	} 	if (set & fa->feature_bit)		val |= 1;	if (clear & fa->feature_bit)		val |= 2; 	return val;} static ssize_t btrfs_feature_attr_show(struct kobject *kobj,				       struct kobj_attribute *a, char *buf){	int val = 0;	struct btrfs_fs_info *fs_info = to_fs_info(kobj);	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);	if (fs_info) {		u64 features = get_features(fs_info, fa->feature_set);		if (features & fa->feature_bit)			val = 1;	} else		val = can_modify_feature(fa); 	return sysfs_emit(buf, "%d\n", val);} static ssize_t btrfs_feature_attr_store(struct kobject *kobj,					struct kobj_attribute *a,					const char *buf, size_t count){	struct btrfs_fs_info *fs_info;	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);	u64 features, set, clear;	unsigned long val;	int ret; 	fs_info = to_fs_info(kobj);	if (!fs_info)		return -EPERM; 	if (sb_rdonly(fs_info->sb))		return -EROFS; 	ret = kstrtoul(skip_spaces(buf), 0, &val);	if (ret)		return ret; 	if (fa->feature_set == FEAT_COMPAT) {		set = BTRFS_FEATURE_COMPAT_SAFE_SET;		clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;	} else if (fa->feature_set == FEAT_COMPAT_RO) {		set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;		clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;	} else {		set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;		clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;	} 	features = get_features(fs_info, fa->feature_set); 	/* Nothing to do */	if ((val && (features & fa->feature_bit)) ||	    (!val && !(features & fa->feature_bit)))		return count; 	if ((val && !(set & fa->feature_bit)) ||	    (!val && !(clear & fa->feature_bit))) {		btrfs_info(fs_info,			"%sabling feature %s on mounted fs is not supported.",			val ? "En" : "Dis", fa->kobj_attr.attr.name);		return -EPERM;	} 	btrfs_info(fs_info, "%s %s feature flag",		   val ? "Setting" : "Clearing", fa->kobj_attr.attr.name); 	spin_lock(&fs_info->super_lock);	features = get_features(fs_info, fa->feature_set);	if (val)		features |= fa->feature_bit;	else		features &= ~fa->feature_bit;	set_features(fs_info, fa->feature_set, features);	spin_unlock(&fs_info->super_lock); 	/*	 * We don't want to do full transaction commit from inside sysfs	 */	set_bit(BTRFS_FS_NEED_TRANS_COMMIT, &fs_info->flags);	wake_up_process(fs_info->transaction_kthread); 	return count;} static umode_t btrfs_feature_visible(struct kobject *kobj,				     struct attribute *attr, int unused){	struct btrfs_fs_info *fs_info = to_fs_info(kobj);	umode_t mode = attr->mode; 	if (fs_info) {		struct btrfs_feature_attr *fa;		u64 features; 		fa = attr_to_btrfs_feature_attr(attr);		features = get_features(fs_info, fa->feature_set); 		if (can_modify_feature(fa))			mode |= S_IWUSR;		else if (!(features & fa->feature_bit))			mode = 0;	} 	return mode;} BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD);BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES);BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid, METADATA_UUID);BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE);BTRFS_FEAT_ATTR_COMPAT_RO(block_group_tree, BLOCK_GROUP_TREE);BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34);BTRFS_FEAT_ATTR_INCOMPAT(simple_quota, SIMPLE_QUOTA);#ifdef CONFIG_BLK_DEV_ZONEDBTRFS_FEAT_ATTR_INCOMPAT(zoned, ZONED);#endif#ifdef CONFIG_BTRFS_EXPERIMENTAL/* Remove once support for extent tree v2 is feature complete */BTRFS_FEAT_ATTR_INCOMPAT(extent_tree_v2, EXTENT_TREE_V2);/* Remove once support for raid stripe tree is feature complete. */BTRFS_FEAT_ATTR_INCOMPAT(raid_stripe_tree, RAID_STRIPE_TREE);/* Remove once support for remap tree is feature complete. */BTRFS_FEAT_ATTR_INCOMPAT(remap_tree, REMAP_TREE);#endif#ifdef CONFIG_FS_VERITYBTRFS_FEAT_ATTR_COMPAT_RO(verity, VERITY);#endif /* * Features which depend on feature bits and may differ between each fs. * * /sys/fs/btrfs/features      - all available features implemented by this version * /sys/fs/btrfs/UUID/features - features of the fs which are enabled or *                               can be changed on a mounted filesystem. */static struct attribute *btrfs_supported_feature_attrs[] = {	BTRFS_FEAT_ATTR_PTR(default_subvol),	BTRFS_FEAT_ATTR_PTR(mixed_groups),	BTRFS_FEAT_ATTR_PTR(compress_lzo),	BTRFS_FEAT_ATTR_PTR(compress_zstd),	BTRFS_FEAT_ATTR_PTR(extended_iref),	BTRFS_FEAT_ATTR_PTR(raid56),	BTRFS_FEAT_ATTR_PTR(skinny_metadata),	BTRFS_FEAT_ATTR_PTR(no_holes),	BTRFS_FEAT_ATTR_PTR(metadata_uuid),	BTRFS_FEAT_ATTR_PTR(free_space_tree),	BTRFS_FEAT_ATTR_PTR(raid1c34),	BTRFS_FEAT_ATTR_PTR(block_group_tree),	BTRFS_FEAT_ATTR_PTR(simple_quota),#ifdef CONFIG_BLK_DEV_ZONED	BTRFS_FEAT_ATTR_PTR(zoned),#endif#ifdef CONFIG_BTRFS_EXPERIMENTAL	BTRFS_FEAT_ATTR_PTR(extent_tree_v2),	BTRFS_FEAT_ATTR_PTR(raid_stripe_tree),	BTRFS_FEAT_ATTR_PTR(remap_tree),#endif#ifdef CONFIG_FS_VERITY	BTRFS_FEAT_ATTR_PTR(verity),#endif	NULL}; static const struct attribute_group btrfs_feature_attr_group = {	.name = "features",	.is_visible = btrfs_feature_visible,	.attrs = btrfs_supported_feature_attrs,}; static ssize_t rmdir_subvol_show(struct kobject *kobj,				 struct kobj_attribute *ka, char *buf){	return sysfs_emit(buf, "0\n");}BTRFS_ATTR(static_feature, rmdir_subvol, rmdir_subvol_show); static ssize_t supported_checksums_show(struct kobject *kobj,					struct kobj_attribute *a, char *buf){	ssize_t ret = 0;	int i; 	for (i = 0; i < btrfs_get_num_csums(); i++) {		/*		 * This "trick" only works as long as 'enum btrfs_csum_type' has		 * no holes in it		 */		ret += sysfs_emit_at(buf, ret, "%s%s", (i == 0 ? "" : " "),				     btrfs_super_csum_name(i)); 	} 	ret += sysfs_emit_at(buf, ret, "\n");	return ret;}BTRFS_ATTR(static_feature, supported_checksums, supported_checksums_show); static ssize_t send_stream_version_show(struct kobject *kobj,					struct kobj_attribute *ka, char *buf){	return sysfs_emit(buf, "%d\n", BTRFS_SEND_STREAM_VERSION);}BTRFS_ATTR(static_feature, send_stream_version, send_stream_version_show); static const char *rescue_opts[] = {	"usebackuproot",	"nologreplay",	"ignorebadroots",	"ignoredatacsums",	"ignoremetacsums",	"ignoresuperflags",	"all",}; static ssize_t supported_rescue_options_show(struct kobject *kobj,					     struct kobj_attribute *a,					     char *buf){	ssize_t ret = 0;	int i; 	for (i = 0; i < ARRAY_SIZE(rescue_opts); i++)		ret += sysfs_emit_at(buf, ret, "%s%s", (i ? " " : ""), rescue_opts[i]);	ret += sysfs_emit_at(buf, ret, "\n");	return ret;}BTRFS_ATTR(static_feature, supported_rescue_options,	   supported_rescue_options_show); static ssize_t supported_sectorsizes_show(struct kobject *kobj,					  struct kobj_attribute *a,					  char *buf){	ssize_t ret = 0;	bool has_output = false; 	for (u32 cur = BTRFS_MIN_BLOCKSIZE; cur <= BTRFS_MAX_BLOCKSIZE; cur *= 2) {		if (!btrfs_supported_blocksize(cur))			continue;		if (has_output)			ret += sysfs_emit_at(buf, ret, " ");		ret += sysfs_emit_at(buf, ret, "%u", cur);		has_output = true;	}	ret += sysfs_emit_at(buf, ret, "\n");	return ret;}BTRFS_ATTR(static_feature, supported_sectorsizes,	   supported_sectorsizes_show); static ssize_t acl_show(struct kobject *kobj, struct kobj_attribute *a, char *buf){	return sysfs_emit(buf, "%d\n", IS_ENABLED(CONFIG_BTRFS_FS_POSIX_ACL));}BTRFS_ATTR(static_feature, acl, acl_show); static ssize_t temp_fsid_supported_show(struct kobject *kobj,					struct kobj_attribute *a, char *buf){	return sysfs_emit(buf, "0\n");}BTRFS_ATTR(static_feature, temp_fsid, temp_fsid_supported_show); /* * Features which only depend on kernel version. * * These are listed in /sys/fs/btrfs/features along with * btrfs_supported_feature_attrs. */static struct attribute *btrfs_supported_static_feature_attrs[] = {	BTRFS_ATTR_PTR(static_feature, acl),	BTRFS_ATTR_PTR(static_feature, rmdir_subvol),	BTRFS_ATTR_PTR(static_feature, supported_checksums),	BTRFS_ATTR_PTR(static_feature, send_stream_version),	BTRFS_ATTR_PTR(static_feature, supported_rescue_options),	BTRFS_ATTR_PTR(static_feature, supported_sectorsizes),	BTRFS_ATTR_PTR(static_feature, temp_fsid),	NULL}; static const struct attribute_group btrfs_static_feature_attr_group = {	.name = "features",	.attrs = btrfs_supported_static_feature_attrs,}; /* * Discard statistics and tunables */#define discard_to_fs_info(_kobj)	to_fs_info(get_btrfs_kobj(_kobj)) static ssize_t btrfs_discardable_bytes_show(struct kobject *kobj,					    struct kobj_attribute *a,					    char *buf){	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 	return sysfs_emit(buf, "%lld\n",			atomic64_read(&fs_info->discard_ctl.discardable_bytes));}BTRFS_ATTR(discard, discardable_bytes, btrfs_discardable_bytes_show); static ssize_t btrfs_discardable_extents_show(struct kobject *kobj,					      struct kobj_attribute *a,					      char *buf){	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 	return sysfs_emit(buf, "%d\n",			atomic_read(&fs_info->discard_ctl.discardable_extents));}BTRFS_ATTR(discard, discardable_extents, btrfs_discardable_extents_show); static ssize_t btrfs_discard_bitmap_bytes_show(struct kobject *kobj,					       struct kobj_attribute *a,					       char *buf){	struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 	return sysfs_emit(buf, "%llu\n",			  fs_info->discard_ctl.discard_bitmap_bytes);

Lines 1–500 of 2702.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t