[linux-2.6-block.git] / fs / btrfs / sysfs.c

/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/kobject.h>
#include <linux/bug.h>

#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "sysfs.h"

static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj);

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:
		BUG();
	}

	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 snprintf(buf, PAGE_SIZE, "%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);
	struct btrfs_trans_handle *trans;
	u64 features, set, clear;
	unsigned long val;
	int ret;

	fs_info = to_fs_info(kobj);
	if (!fs_info)
		return -EPERM;

	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);

	trans = btrfs_start_transaction(fs_info->fs_root, 1);
	if (IS_ERR(trans))
		return PTR_ERR(trans);

	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);

	ret = btrfs_commit_transaction(trans, fs_info->fs_root);
	if (ret)
		return ret;

	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(mixed_backref, MIXED_BACKREF);
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_lzov2, COMPRESS_LZOv2);
BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);

static struct attribute *btrfs_supported_feature_attrs[] = {
	BTRFS_FEAT_ATTR_PTR(mixed_backref),
	BTRFS_FEAT_ATTR_PTR(default_subvol),
	BTRFS_FEAT_ATTR_PTR(mixed_groups),
	BTRFS_FEAT_ATTR_PTR(compress_lzo),
	BTRFS_FEAT_ATTR_PTR(compress_lzov2),
	BTRFS_FEAT_ATTR_PTR(big_metadata),
	BTRFS_FEAT_ATTR_PTR(extended_iref),
	BTRFS_FEAT_ATTR_PTR(raid56),
	BTRFS_FEAT_ATTR_PTR(skinny_metadata),
	NULL
};

static const struct attribute_group btrfs_feature_attr_group = {
	.name = "features",
	.is_visible = btrfs_feature_visible,
	.attrs = btrfs_supported_feature_attrs,
};

static void btrfs_release_super_kobj(struct kobject *kobj)
{
	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	complete(&fs_info->kobj_unregister);
}

static struct kobj_type btrfs_ktype = {
	.sysfs_ops	= &kobj_sysfs_ops,
	.release	= btrfs_release_super_kobj,
};

static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)
{
	if (kobj->ktype != &btrfs_ktype)
		return NULL;
	return container_of(kobj, struct btrfs_fs_info, super_kobj);
}

void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
{
	kobject_del(&fs_info->super_kobj);
	kobject_put(&fs_info->super_kobj);
	wait_for_completion(&fs_info->kobj_unregister);
}

const char * const btrfs_feature_set_names[3] = {
	[FEAT_COMPAT]	 = "compat",
	[FEAT_COMPAT_RO] = "compat_ro",
	[FEAT_INCOMPAT]	 = "incompat",
};

#define NUM_FEATURE_BITS 64
static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13];
static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS];

static void init_feature_attrs(void)
{
	struct btrfs_feature_attr *fa;
	int set, i;

	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) !=
		     ARRAY_SIZE(btrfs_feature_attrs));
	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) !=
		     ARRAY_SIZE(btrfs_feature_attrs[0]));

	for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
		struct btrfs_feature_attr *sfa;
		struct attribute *a = btrfs_supported_feature_attrs[i];
		sfa = attr_to_btrfs_feature_attr(a);
		fa = &btrfs_feature_attrs[sfa->feature_set][sfa->feature_bit];

		fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name;
	}

	for (set = 0; set < FEAT_MAX; set++) {
		for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
			char *name = btrfs_unknown_feature_names[set][i];
			fa = &btrfs_feature_attrs[set][i];

			if (fa->kobj_attr.attr.name)
				continue;

			snprintf(name, 13, "%s:%u",
				 btrfs_feature_set_names[set], i);

			fa->kobj_attr.attr.name = name;
			fa->kobj_attr.attr.mode = S_IRUGO;
			fa->feature_set = set;
			fa->feature_bit = 1ULL << i;
		}
	}
}

static u64 supported_feature_masks[3] = {
	[FEAT_COMPAT]    = BTRFS_FEATURE_COMPAT_SUPP,
	[FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
	[FEAT_INCOMPAT]  = BTRFS_FEATURE_INCOMPAT_SUPP,
};

static int add_unknown_feature_attrs(struct btrfs_fs_info *fs_info)
{
	int set;

	for (set = 0; set < FEAT_MAX; set++) {
		int i, count, ret, index = 0;
		struct attribute **attrs;
		struct attribute_group agroup = {
			.name = "features",
		};
		u64 features = get_features(fs_info, set);
		features &= ~supported_feature_masks[set];

		count = hweight64(features);

		if (!count)
			continue;

		attrs = kcalloc(count + 1, sizeof(void *), GFP_KERNEL);

		for (i = 0; i < NUM_FEATURE_BITS; i++) {
			struct btrfs_feature_attr *fa;

			if (!(features & (1ULL << i)))
				continue;

			fa = &btrfs_feature_attrs[set][i];
			attrs[index++] = &fa->kobj_attr.attr;
		}

		attrs[index] = NULL;
		agroup.attrs = attrs;

		ret = sysfs_merge_group(&fs_info->super_kobj, &agroup);
		kfree(attrs);
		if (ret)
			return ret;
	}
	return 0;
}

/* /sys/fs/btrfs/ entry */
static struct kset *btrfs_kset;

int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info)
{
	int error;

	init_completion(&fs_info->kobj_unregister);
	fs_info->super_kobj.kset = btrfs_kset;
	error = kobject_init_and_add(&fs_info->super_kobj, &btrfs_ktype, NULL,
				     "%pU", fs_info->fsid);

	error = sysfs_create_group(&fs_info->super_kobj,
				   &btrfs_feature_attr_group);
	if (error)
		goto failure;

	error = add_unknown_feature_attrs(fs_info);
	if (error)
		goto failure;

	return 0;
failure:
	btrfs_sysfs_remove_one(fs_info);
	return error;
}

int btrfs_init_sysfs(void)
{
	int ret;
	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	if (!btrfs_kset)
		return -ENOMEM;

	init_feature_attrs();

	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
	if (ret) {
		kset_unregister(btrfs_kset);
		return ret;
	}

	return 0;
}

void btrfs_exit_sysfs(void)
{
	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
	kset_unregister(btrfs_kset);
}
Commit	Line	Data
6cbd5570 CM	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
58176a96 JB	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>
58176a96	24	#include <linux/kobject.h>
79da4fa4	25	#include <linux/bug.h>
58176a96	26
bae45de0 CM	27	#include "ctree.h"
	28	#include "disk-io.h"
	29	#include "transaction.h"
079b72bc JM	30	#include "sysfs.h"
079b72bc JM	31
510d7360	32	static inline struct btrfs_fs_info to_fs_info(struct kobject kobj);
5ac1d209	33
510d7360 JM	34	static u64 get_features(struct btrfs_fs_info *fs_info,
510d7360 JM	35	enum btrfs_feature_set set)
5ac1d209	36	{
510d7360 JM	37	struct btrfs_super_block *disk_super = fs_info->super_copy;
	38	if (set == FEAT_COMPAT)
	39	return btrfs_super_compat_flags(disk_super);
	40	else if (set == FEAT_COMPAT_RO)
	41	return btrfs_super_compat_ro_flags(disk_super);
	42	else
	43	return btrfs_super_incompat_flags(disk_super);
5ac1d209 JM	44	}
5ac1d209 JM	45
ba631941 JM	46	static void set_features(struct btrfs_fs_info *fs_info,
	47	enum btrfs_feature_set set, u64 features)
	48	{
	49	struct btrfs_super_block *disk_super = fs_info->super_copy;
	50	if (set == FEAT_COMPAT)
	51	btrfs_set_super_compat_flags(disk_super, features);
	52	else if (set == FEAT_COMPAT_RO)
	53	btrfs_set_super_compat_ro_flags(disk_super, features);
	54	else
	55	btrfs_set_super_incompat_flags(disk_super, features);
	56	}
	57
	58	static int can_modify_feature(struct btrfs_feature_attr *fa)
	59	{
	60	int val = 0;
	61	u64 set, clear;
	62	switch (fa->feature_set) {
	63	case FEAT_COMPAT:
	64	set = BTRFS_FEATURE_COMPAT_SAFE_SET;
	65	clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
	66	break;
	67	case FEAT_COMPAT_RO:
	68	set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
	69	clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
	70	break;
	71	case FEAT_INCOMPAT:
	72	set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
	73	clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
	74	break;
	75	default:
	76	BUG();
	77	}
	78
	79	if (set & fa->feature_bit)
	80	val \|= 1;
	81	if (clear & fa->feature_bit)
	82	val \|= 2;
	83
	84	return val;
	85	}
	86
510d7360 JM	87	static ssize_t btrfs_feature_attr_show(struct kobject *kobj,
510d7360 JM	88	struct kobj_attribute a, char buf)
5ac1d209	89	{
510d7360	90	int val = 0;
5ac1d209	91	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
ba631941	92	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
510d7360	93	if (fs_info) {
510d7360 JM	94	u64 features = get_features(fs_info, fa->feature_set);
	95	if (features & fa->feature_bit)
	96	val = 1;
ba631941 JM	97	} else
ba631941 JM	98	val = can_modify_feature(fa);
510d7360 JM	99
510d7360 JM	100	return snprintf(buf, PAGE_SIZE, "%d\n", val);
5ac1d209 JM	101	}
5ac1d209 JM	102
ba631941 JM	103	static ssize_t btrfs_feature_attr_store(struct kobject *kobj,
	104	struct kobj_attribute *a,
	105	const char *buf, size_t count)
	106	{
	107	struct btrfs_fs_info *fs_info;
	108	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
	109	struct btrfs_trans_handle *trans;
	110	u64 features, set, clear;
	111	unsigned long val;
	112	int ret;
	113
	114	fs_info = to_fs_info(kobj);
	115	if (!fs_info)
	116	return -EPERM;
	117
	118	ret = kstrtoul(skip_spaces(buf), 0, &val);
	119	if (ret)
	120	return ret;
	121
	122	if (fa->feature_set == FEAT_COMPAT) {
	123	set = BTRFS_FEATURE_COMPAT_SAFE_SET;
	124	clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
	125	} else if (fa->feature_set == FEAT_COMPAT_RO) {
	126	set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
	127	clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
	128	} else {
	129	set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
	130	clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
	131	}
	132
	133	features = get_features(fs_info, fa->feature_set);
	134
	135	/* Nothing to do */
	136	if ((val && (features & fa->feature_bit)) \|\|
	137	(!val && !(features & fa->feature_bit)))
	138	return count;
	139
	140	if ((val && !(set & fa->feature_bit)) \|\|
	141	(!val && !(clear & fa->feature_bit))) {
	142	btrfs_info(fs_info,
	143	"%sabling feature %s on mounted fs is not supported.",
	144	val ? "En" : "Dis", fa->kobj_attr.attr.name);
	145	return -EPERM;
	146	}
	147
	148	btrfs_info(fs_info, "%s %s feature flag",
	149	val ? "Setting" : "Clearing", fa->kobj_attr.attr.name);
	150
	151	trans = btrfs_start_transaction(fs_info->fs_root, 1);
	152	if (IS_ERR(trans))
	153	return PTR_ERR(trans);
	154
	155	spin_lock(&fs_info->super_lock);
	156	features = get_features(fs_info, fa->feature_set);
	157	if (val)
	158	features \|= fa->feature_bit;
	159	else
	160	features &= ~fa->feature_bit;
	161	set_features(fs_info, fa->feature_set, features);
	162	spin_unlock(&fs_info->super_lock);
	163
	164	ret = btrfs_commit_transaction(trans, fs_info->fs_root);
	165	if (ret)
	166	return ret;
167
168	return count;
169	}
170
510d7360 JM	171	static umode_t btrfs_feature_visible(struct kobject *kobj,
510d7360 JM	172	struct attribute *attr, int unused)
079b72bc	173	{
510d7360 JM	174	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	175	umode_t mode = attr->mode;
	176
	177	if (fs_info) {
	178	struct btrfs_feature_attr *fa;
	179	u64 features;
	180
	181	fa = attr_to_btrfs_feature_attr(attr);
	182	features = get_features(fs_info, fa->feature_set);
	183
ba631941 JM	184	if (can_modify_feature(fa))
	185	mode \|= S_IWUSR;
	186	else if (!(features & fa->feature_bit))
510d7360 JM	187	mode = 0;
	188	}
	189
	190	return mode;
079b72bc JM	191	}
	192
	193	BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF);
	194	BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);
	195	BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);
	196	BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);
	197	BTRFS_FEAT_ATTR_INCOMPAT(compress_lzov2, COMPRESS_LZOv2);
	198	BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
	199	BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
	200	BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
	201	BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);
	202
	203	static struct attribute *btrfs_supported_feature_attrs[] = {
	204	BTRFS_FEAT_ATTR_PTR(mixed_backref),
	205	BTRFS_FEAT_ATTR_PTR(default_subvol),
	206	BTRFS_FEAT_ATTR_PTR(mixed_groups),
	207	BTRFS_FEAT_ATTR_PTR(compress_lzo),
	208	BTRFS_FEAT_ATTR_PTR(compress_lzov2),
	209	BTRFS_FEAT_ATTR_PTR(big_metadata),
	210	BTRFS_FEAT_ATTR_PTR(extended_iref),
	211	BTRFS_FEAT_ATTR_PTR(raid56),
	212	BTRFS_FEAT_ATTR_PTR(skinny_metadata),
	213	NULL
	214	};
	215
	216	static const struct attribute_group btrfs_feature_attr_group = {
	217	.name = "features",
510d7360	218	.is_visible = btrfs_feature_visible,
079b72bc JM	219	.attrs = btrfs_supported_feature_attrs,
079b72bc JM	220	};
58176a96	221
510d7360 JM	222	static void btrfs_release_super_kobj(struct kobject *kobj)
	223	{
	224	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	225	complete(&fs_info->kobj_unregister);
	226	}
	227
	228	static struct kobj_type btrfs_ktype = {
	229	.sysfs_ops = &kobj_sysfs_ops,
	230	.release = btrfs_release_super_kobj,
	231	};
	232
	233	static inline struct btrfs_fs_info to_fs_info(struct kobject kobj)
	234	{
	235	if (kobj->ktype != &btrfs_ktype)
	236	return NULL;
	237	return container_of(kobj, struct btrfs_fs_info, super_kobj);
	238	}
58176a96	239
5ac1d209 JM	240	void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
	241	{
	242	kobject_del(&fs_info->super_kobj);
	243	kobject_put(&fs_info->super_kobj);
	244	wait_for_completion(&fs_info->kobj_unregister);
	245	}
	246
79da4fa4 JM	247	const char * const btrfs_feature_set_names[3] = {
	248	[FEAT_COMPAT] = "compat",
	249	[FEAT_COMPAT_RO] = "compat_ro",
	250	[FEAT_INCOMPAT] = "incompat",
	251	};
	252
	253	#define NUM_FEATURE_BITS 64
	254	static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13];
	255	static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS];
	256
	257	static void init_feature_attrs(void)
	258	{
	259	struct btrfs_feature_attr *fa;
	260	int set, i;
	261
	262	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) !=
	263	ARRAY_SIZE(btrfs_feature_attrs));
	264	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) !=
	265	ARRAY_SIZE(btrfs_feature_attrs[0]));
	266
	267	for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
	268	struct btrfs_feature_attr *sfa;
	269	struct attribute *a = btrfs_supported_feature_attrs[i];
	270	sfa = attr_to_btrfs_feature_attr(a);
	271	fa = &btrfs_feature_attrs[sfa->feature_set][sfa->feature_bit];
	272
	273	fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name;
	274	}
	275
	276	for (set = 0; set < FEAT_MAX; set++) {
	277	for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
	278	char *name = btrfs_unknown_feature_names[set][i];
	279	fa = &btrfs_feature_attrs[set][i];
	280
	281	if (fa->kobj_attr.attr.name)
	282	continue;
	283
	284	snprintf(name, 13, "%s:%u",
	285	btrfs_feature_set_names[set], i);
	286
	287	fa->kobj_attr.attr.name = name;
	288	fa->kobj_attr.attr.mode = S_IRUGO;
	289	fa->feature_set = set;
	290	fa->feature_bit = 1ULL << i;
	291	}
	292	}
	293	}
	294
	295	static u64 supported_feature_masks[3] = {
	296	[FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP,
	297	[FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
	298	[FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP,
	299	};
	300
	301	static int add_unknown_feature_attrs(struct btrfs_fs_info *fs_info)
	302	{
	303	int set;
	304
	305	for (set = 0; set < FEAT_MAX; set++) {
	306	int i, count, ret, index = 0;
	307	struct attribute **attrs;
	308	struct attribute_group agroup = {
	309	.name = "features",
	310	};
311	u64 features = get_features(fs_info, set);
312	features &= ~supported_feature_masks[set];
313
314	count = hweight64(features);
315
316	if (!count)
317	continue;
318
319	attrs = kcalloc(count + 1, sizeof(void *), GFP_KERNEL);
320
321	for (i = 0; i < NUM_FEATURE_BITS; i++) {
322	struct btrfs_feature_attr *fa;
323
324	if (!(features & (1ULL << i)))
325	continue;
326
327	fa = &btrfs_feature_attrs[set][i];
328	attrs[index++] = &fa->kobj_attr.attr;
329	}
330
331	attrs[index] = NULL;
332	agroup.attrs = attrs;
333
334	ret = sysfs_merge_group(&fs_info->super_kobj, &agroup);
335	kfree(attrs);
336	if (ret)
337	return ret;
338	}
339	return 0;
340	}
341
510d7360 JM	342	/* /sys/fs/btrfs/ entry */
	343	static struct kset *btrfs_kset;
	344
5ac1d209 JM	345	int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info)
	346	{
	347	int error;
	348
	349	init_completion(&fs_info->kobj_unregister);
510d7360	350	fs_info->super_kobj.kset = btrfs_kset;
5ac1d209 JM	351	error = kobject_init_and_add(&fs_info->super_kobj, &btrfs_ktype, NULL,
5ac1d209 JM	352	"%pU", fs_info->fsid);
510d7360 JM	353
	354	error = sysfs_create_group(&fs_info->super_kobj,
	355	&btrfs_feature_attr_group);
	356	if (error)
79da4fa4 JM	357	goto failure;
	358
	359	error = add_unknown_feature_attrs(fs_info);
	360	if (error)
	361	goto failure;
	362
	363	return 0;
	364	failure:
	365	btrfs_sysfs_remove_one(fs_info);
5ac1d209 JM	366	return error;
	367	}
	368
b214107e	369	int btrfs_init_sysfs(void)
58176a96	370	{
079b72bc	371	int ret;
e3fe4e71 GK	372	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	373	if (!btrfs_kset)
	374	return -ENOMEM;
079b72bc	375
79da4fa4 JM	376	init_feature_attrs();
79da4fa4 JM	377
079b72bc JM	378	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
	379	if (ret) {
	380	kset_unregister(btrfs_kset);
	381	return ret;
	382	}
	383
e3fe4e71	384	return 0;
58176a96 JB	385	}
58176a96 JB	386
b214107e	387	void btrfs_exit_sysfs(void)
58176a96	388	{
079b72bc	389	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
e3fe4e71	390	kset_unregister(btrfs_kset);
58176a96	391	}
55d47414	392