[deliverable/linux.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 <linux/genhd.h>

#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "sysfs.h"
#include "volumes.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:
		printk(KERN_WARNING "btrfs: sysfs: unknown feature set %d\n",
				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 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, 0);
	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(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(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 ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf)
{
	u64 val;
	if (lock)
		spin_lock(lock);
	val = *value_ptr;
	if (lock)
		spin_unlock(lock);
	return snprintf(buf, PAGE_SIZE, "%llu\n", val);
}

static ssize_t global_rsv_size_show(struct kobject *kobj,
				    struct kobj_attribute *ka, char *buf)
{
	struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
	return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf);
}
BTRFS_ATTR(global_rsv_size, 0444, global_rsv_size_show);

static ssize_t global_rsv_reserved_show(struct kobject *kobj,
					struct kobj_attribute *a, char *buf)
{
	struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
	return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf);
}
BTRFS_ATTR(global_rsv_reserved, 0444, global_rsv_reserved_show);

#define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)

static ssize_t raid_bytes_show(struct kobject *kobj,
			       struct kobj_attribute *attr, char *buf);
BTRFS_RAID_ATTR(total_bytes, raid_bytes_show);
BTRFS_RAID_ATTR(used_bytes, raid_bytes_show);

static ssize_t raid_bytes_show(struct kobject *kobj,
			       struct kobj_attribute *attr, char *buf)

{
	struct btrfs_space_info *sinfo = to_space_info(kobj->parent);
	struct btrfs_block_group_cache *block_group;
	int index = kobj - sinfo->block_group_kobjs;
	u64 val = 0;

	down_read(&sinfo->groups_sem);
	list_for_each_entry(block_group, &sinfo->block_groups[index], list) {
		if (&attr->attr == BTRFS_RAID_ATTR_PTR(total_bytes))
			val += block_group->key.offset;
		else
			val += btrfs_block_group_used(&block_group->item);
	}
	up_read(&sinfo->groups_sem);
	return snprintf(buf, PAGE_SIZE, "%llu\n", val);
}

static struct attribute *raid_attributes[] = {
	BTRFS_RAID_ATTR_PTR(total_bytes),
	BTRFS_RAID_ATTR_PTR(used_bytes),
	NULL
};

static void release_raid_kobj(struct kobject *kobj)
{
	kobject_put(kobj->parent);
}

struct kobj_type btrfs_raid_ktype = {
	.sysfs_ops = &kobj_sysfs_ops,
	.release = release_raid_kobj,
	.default_attrs = raid_attributes,
};

#define SPACE_INFO_ATTR(field)						\
static ssize_t btrfs_space_info_show_##field(struct kobject *kobj,	\
					     struct kobj_attribute *a,	\
					     char *buf)			\
{									\
	struct btrfs_space_info *sinfo = to_space_info(kobj);		\
	return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf);	\
}									\
BTRFS_ATTR(field, 0444, btrfs_space_info_show_##field)

static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj,
						       struct kobj_attribute *a,
						       char *buf)
{
	struct btrfs_space_info *sinfo = to_space_info(kobj);
	s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned);
	return snprintf(buf, PAGE_SIZE, "%lld\n", val);
}

SPACE_INFO_ATTR(flags);
SPACE_INFO_ATTR(total_bytes);
SPACE_INFO_ATTR(bytes_used);
SPACE_INFO_ATTR(bytes_pinned);
SPACE_INFO_ATTR(bytes_reserved);
SPACE_INFO_ATTR(bytes_may_use);
SPACE_INFO_ATTR(disk_used);
SPACE_INFO_ATTR(disk_total);
BTRFS_ATTR(total_bytes_pinned, 0444, btrfs_space_info_show_total_bytes_pinned);

static struct attribute *space_info_attrs[] = {
	BTRFS_ATTR_PTR(flags),
	BTRFS_ATTR_PTR(total_bytes),
	BTRFS_ATTR_PTR(bytes_used),
	BTRFS_ATTR_PTR(bytes_pinned),
	BTRFS_ATTR_PTR(bytes_reserved),
	BTRFS_ATTR_PTR(bytes_may_use),
	BTRFS_ATTR_PTR(disk_used),
	BTRFS_ATTR_PTR(disk_total),
	BTRFS_ATTR_PTR(total_bytes_pinned),
	NULL,
};

static void space_info_release(struct kobject *kobj)
{
	struct btrfs_space_info *sinfo = to_space_info(kobj);
	percpu_counter_destroy(&sinfo->total_bytes_pinned);
	kfree(sinfo);
}

struct kobj_type space_info_ktype = {
	.sysfs_ops = &kobj_sysfs_ops,
	.release = space_info_release,
	.default_attrs = space_info_attrs,
};

static const struct attribute *allocation_attrs[] = {
	BTRFS_ATTR_PTR(global_rsv_reserved),
	BTRFS_ATTR_PTR(global_rsv_size),
	NULL,
};

static ssize_t btrfs_label_show(struct kobject *kobj,
				struct kobj_attribute *a, char *buf)
{
	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	return snprintf(buf, PAGE_SIZE, "%s\n", fs_info->super_copy->label);
}

static ssize_t btrfs_label_store(struct kobject *kobj,
				 struct kobj_attribute *a,
				 const char *buf, size_t len)
{
	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = fs_info->fs_root;
	int ret;

	if (len >= BTRFS_LABEL_SIZE) {
		pr_err("BTRFS: unable to set label with more than %d bytes\n",
		       BTRFS_LABEL_SIZE - 1);
		return -EINVAL;
	}

	trans = btrfs_start_transaction(root, 0);
	if (IS_ERR(trans))
		return PTR_ERR(trans);

	spin_lock(&root->fs_info->super_lock);
	strcpy(fs_info->super_copy->label, buf);
	spin_unlock(&root->fs_info->super_lock);
	ret = btrfs_commit_transaction(trans, root);

	if (!ret)
		return len;

	return ret;
}
BTRFS_ATTR_RW(label, 0644, btrfs_label_show, btrfs_label_store);

static struct attribute *btrfs_attrs[] = {
	BTRFS_ATTR_PTR(label),
	NULL,
};

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,
	.default_attrs	= btrfs_attrs,
};

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

#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 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 addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add)
{
	int set;

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

		if (!features)
			continue;

		attrs[1] = NULL;
		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[0] = &fa->kobj_attr.attr;
			if (add) {
				int ret;
				ret = sysfs_merge_group(&fs_info->super_kobj,
							&agroup);
				if (ret)
					return ret;
			} else
				sysfs_unmerge_group(&fs_info->super_kobj,
						    &agroup);
		}

	}
	return 0;
}

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

void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
{
	if (fs_info->space_info_kobj) {
		sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs);
		kobject_del(fs_info->space_info_kobj);
		kobject_put(fs_info->space_info_kobj);
	}
	kobject_del(fs_info->device_dir_kobj);
	kobject_put(fs_info->device_dir_kobj);
	addrm_unknown_feature_attrs(fs_info, false);
	sysfs_remove_group(&fs_info->super_kobj, &btrfs_feature_attr_group);
	__btrfs_sysfs_remove_one(fs_info);
}

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

char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags)
{
	size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */
	int len = 0;
	int i;
	char *str;

	str = kmalloc(bufsize, GFP_KERNEL);
	if (!str)
		return str;

	for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
		const char *name;

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

		name = btrfs_feature_attrs[set][i].kobj_attr.attr.name;
		len += snprintf(str + len, bufsize - len, "%s%s",
				len ? "," : "", name);
	}

	return str;
}

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

	memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs));
	memset(btrfs_unknown_feature_names, 0,
	       sizeof(btrfs_unknown_feature_names));

	for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
		struct btrfs_feature_attr *sfa;
		struct attribute *a = btrfs_supported_feature_attrs[i];
		int bit;
		sfa = attr_to_btrfs_feature_attr(a);
		bit = ilog2(sfa->feature_bit);
		fa = &btrfs_feature_attrs[sfa->feature_set][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 int add_device_membership(struct btrfs_fs_info *fs_info)
{
	int error = 0;
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
	struct btrfs_device *dev;

	fs_info->device_dir_kobj = kobject_create_and_add("devices",
						&fs_info->super_kobj);
	if (!fs_info->device_dir_kobj)
		return -ENOMEM;

	list_for_each_entry(dev, &fs_devices->devices, dev_list) {
		struct hd_struct *disk = dev->bdev->bd_part;
		struct kobject *disk_kobj = &part_to_dev(disk)->kobj;

		error = sysfs_create_link(fs_info->device_dir_kobj,
					  disk_kobj, disk_kobj->name);
		if (error)
			break;
	}

	return error;
}

/* /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);
	if (error)
		return error;

	error = sysfs_create_group(&fs_info->super_kobj,
				   &btrfs_feature_attr_group);
	if (error) {
		__btrfs_sysfs_remove_one(fs_info);
		return error;
	}

	error = addrm_unknown_feature_attrs(fs_info, true);
	if (error)
		goto failure;

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

	fs_info->space_info_kobj = kobject_create_and_add("allocation",
						  &fs_info->super_kobj);
	if (!fs_info->space_info_kobj) {
		error = -ENOMEM;
		goto failure;
	}

	error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs);
	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>
29e5be24	26	#include <linux/genhd.h>
58176a96	27
bae45de0 CM	28	#include "ctree.h"
	29	#include "disk-io.h"
	30	#include "transaction.h"
079b72bc	31	#include "sysfs.h"
29e5be24	32	#include "volumes.h"
079b72bc	33
510d7360	34	static inline struct btrfs_fs_info to_fs_info(struct kobject kobj);
5ac1d209	35
510d7360 JM	36	static u64 get_features(struct btrfs_fs_info *fs_info,
510d7360 JM	37	enum btrfs_feature_set set)
5ac1d209	38	{
510d7360 JM	39	struct btrfs_super_block *disk_super = fs_info->super_copy;
	40	if (set == FEAT_COMPAT)
	41	return btrfs_super_compat_flags(disk_super);
	42	else if (set == FEAT_COMPAT_RO)
	43	return btrfs_super_compat_ro_flags(disk_super);
	44	else
	45	return btrfs_super_incompat_flags(disk_super);
5ac1d209 JM	46	}
5ac1d209 JM	47
ba631941 JM	48	static void set_features(struct btrfs_fs_info *fs_info,
	49	enum btrfs_feature_set set, u64 features)
	50	{
	51	struct btrfs_super_block *disk_super = fs_info->super_copy;
	52	if (set == FEAT_COMPAT)
	53	btrfs_set_super_compat_flags(disk_super, features);
	54	else if (set == FEAT_COMPAT_RO)
	55	btrfs_set_super_compat_ro_flags(disk_super, features);
	56	else
	57	btrfs_set_super_incompat_flags(disk_super, features);
	58	}
	59
	60	static int can_modify_feature(struct btrfs_feature_attr *fa)
	61	{
	62	int val = 0;
	63	u64 set, clear;
	64	switch (fa->feature_set) {
	65	case FEAT_COMPAT:
	66	set = BTRFS_FEATURE_COMPAT_SAFE_SET;
	67	clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
	68	break;
	69	case FEAT_COMPAT_RO:
	70	set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
	71	clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
	72	break;
	73	case FEAT_INCOMPAT:
	74	set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
	75	clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
	76	break;
	77	default:
cc37bb04 DS	78	printk(KERN_WARNING "btrfs: sysfs: unknown feature set %d\n",
	79	fa->feature_set);
	80	return 0;
ba631941 JM	81	}
	82
	83	if (set & fa->feature_bit)
	84	val \|= 1;
	85	if (clear & fa->feature_bit)
	86	val \|= 2;
	87
	88	return val;
	89	}
	90
510d7360 JM	91	static ssize_t btrfs_feature_attr_show(struct kobject *kobj,
510d7360 JM	92	struct kobj_attribute a, char buf)
5ac1d209	93	{
510d7360	94	int val = 0;
5ac1d209	95	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
ba631941	96	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
510d7360	97	if (fs_info) {
510d7360 JM	98	u64 features = get_features(fs_info, fa->feature_set);
	99	if (features & fa->feature_bit)
	100	val = 1;
ba631941 JM	101	} else
ba631941 JM	102	val = can_modify_feature(fa);
510d7360 JM	103
510d7360 JM	104	return snprintf(buf, PAGE_SIZE, "%d\n", val);
5ac1d209 JM	105	}
5ac1d209 JM	106
ba631941 JM	107	static ssize_t btrfs_feature_attr_store(struct kobject *kobj,
	108	struct kobj_attribute *a,
	109	const char *buf, size_t count)
	110	{
	111	struct btrfs_fs_info *fs_info;
	112	struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
	113	struct btrfs_trans_handle *trans;
	114	u64 features, set, clear;
	115	unsigned long val;
	116	int ret;
	117
	118	fs_info = to_fs_info(kobj);
	119	if (!fs_info)
	120	return -EPERM;
	121
	122	ret = kstrtoul(skip_spaces(buf), 0, &val);
	123	if (ret)
	124	return ret;
	125
	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;
	132	} else {
	133	set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
	134	clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
	135	}
	136
	137	features = get_features(fs_info, fa->feature_set);
	138
	139	/* Nothing to do */
	140	if ((val && (features & fa->feature_bit)) \|\|
	141	(!val && !(features & fa->feature_bit)))
	142	return count;
	143
	144	if ((val && !(set & fa->feature_bit)) \|\|
	145	(!val && !(clear & fa->feature_bit))) {
	146	btrfs_info(fs_info,
	147	"%sabling feature %s on mounted fs is not supported.",
	148	val ? "En" : "Dis", fa->kobj_attr.attr.name);
	149	return -EPERM;
	150	}
	151
	152	btrfs_info(fs_info, "%s %s feature flag",
	153	val ? "Setting" : "Clearing", fa->kobj_attr.attr.name);
	154
43d87fa2	155	trans = btrfs_start_transaction(fs_info->fs_root, 0);
ba631941 JM	156	if (IS_ERR(trans))
	157	return PTR_ERR(trans);
	158
	159	spin_lock(&fs_info->super_lock);
	160	features = get_features(fs_info, fa->feature_set);
	161	if (val)
	162	features \|= fa->feature_bit;
	163	else
	164	features &= ~fa->feature_bit;
	165	set_features(fs_info, fa->feature_set, features);
	166	spin_unlock(&fs_info->super_lock);
	167
	168	ret = btrfs_commit_transaction(trans, fs_info->fs_root);
	169	if (ret)
	170	return ret;
	171
	172	return count;
	173	}
	174
510d7360 JM	175	static umode_t btrfs_feature_visible(struct kobject *kobj,
510d7360 JM	176	struct attribute *attr, int unused)
079b72bc	177	{
510d7360 JM	178	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	179	umode_t mode = attr->mode;
	180
	181	if (fs_info) {
	182	struct btrfs_feature_attr *fa;
	183	u64 features;
	184
	185	fa = attr_to_btrfs_feature_attr(attr);
	186	features = get_features(fs_info, fa->feature_set);
	187
ba631941 JM	188	if (can_modify_feature(fa))
	189	mode \|= S_IWUSR;
	190	else if (!(features & fa->feature_bit))
510d7360 JM	191	mode = 0;
	192	}
	193
	194	return mode;
079b72bc JM	195	}
	196
	197	BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF);
	198	BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);
	199	BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);
	200	BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);
079b72bc JM	201	BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
	202	BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
	203	BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
	204	BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);
	205
	206	static struct attribute *btrfs_supported_feature_attrs[] = {
	207	BTRFS_FEAT_ATTR_PTR(mixed_backref),
	208	BTRFS_FEAT_ATTR_PTR(default_subvol),
	209	BTRFS_FEAT_ATTR_PTR(mixed_groups),
	210	BTRFS_FEAT_ATTR_PTR(compress_lzo),
079b72bc JM	211	BTRFS_FEAT_ATTR_PTR(big_metadata),
	212	BTRFS_FEAT_ATTR_PTR(extended_iref),
	213	BTRFS_FEAT_ATTR_PTR(raid56),
	214	BTRFS_FEAT_ATTR_PTR(skinny_metadata),
	215	NULL
	216	};
	217
	218	static const struct attribute_group btrfs_feature_attr_group = {
	219	.name = "features",
510d7360	220	.is_visible = btrfs_feature_visible,
079b72bc JM	221	.attrs = btrfs_supported_feature_attrs,
079b72bc JM	222	};
58176a96	223
6ab0a202 JM	224	static ssize_t btrfs_show_u64(u64 value_ptr, spinlock_t lock, char *buf)
	225	{
	226	u64 val;
	227	if (lock)
	228	spin_lock(lock);
	229	val = *value_ptr;
	230	if (lock)
	231	spin_unlock(lock);
	232	return snprintf(buf, PAGE_SIZE, "%llu\n", val);
	233	}
	234
	235	static ssize_t global_rsv_size_show(struct kobject *kobj,
	236	struct kobj_attribute ka, char buf)
	237	{
	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);
	241	}
	242	BTRFS_ATTR(global_rsv_size, 0444, global_rsv_size_show);
	243
	244	static ssize_t global_rsv_reserved_show(struct kobject *kobj,
	245	struct kobj_attribute a, char buf)
	246	{
	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);
	250	}
	251	BTRFS_ATTR(global_rsv_reserved, 0444, global_rsv_reserved_show);
	252
	253	#define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
	254
	255	static ssize_t raid_bytes_show(struct kobject *kobj,
	256	struct kobj_attribute attr, char buf);
	257	BTRFS_RAID_ATTR(total_bytes, raid_bytes_show);
	258	BTRFS_RAID_ATTR(used_bytes, raid_bytes_show);
	259
	260	static ssize_t raid_bytes_show(struct kobject *kobj,
	261	struct kobj_attribute attr, char buf)
	262
	263	{
	264	struct btrfs_space_info *sinfo = to_space_info(kobj->parent);
	265	struct btrfs_block_group_cache *block_group;
	266	int index = kobj - sinfo->block_group_kobjs;
	267	u64 val = 0;
	268
	269	down_read(&sinfo->groups_sem);
	270	list_for_each_entry(block_group, &sinfo->block_groups[index], list) {
	271	if (&attr->attr == BTRFS_RAID_ATTR_PTR(total_bytes))
	272	val += block_group->key.offset;
	273	else
	274	val += btrfs_block_group_used(&block_group->item);
	275	}
	276	up_read(&sinfo->groups_sem);
	277	return snprintf(buf, PAGE_SIZE, "%llu\n", val);
	278	}
	279
	280	static struct attribute *raid_attributes[] = {
	281	BTRFS_RAID_ATTR_PTR(total_bytes),
	282	BTRFS_RAID_ATTR_PTR(used_bytes),
	283	NULL
	284	};
	285
	286	static void release_raid_kobj(struct kobject *kobj)
	287	{
288	kobject_put(kobj->parent);
289	}
290
291	struct kobj_type btrfs_raid_ktype = {
292	.sysfs_ops = &kobj_sysfs_ops,
293	.release = release_raid_kobj,
294	.default_attrs = raid_attributes,
295	};
296
297	#define SPACE_INFO_ATTR(field) \
298	static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \
299	struct kobj_attribute *a, \
300	char *buf) \
301	{ \
302	struct btrfs_space_info *sinfo = to_space_info(kobj); \
303	return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \
304	} \
305	BTRFS_ATTR(field, 0444, btrfs_space_info_show_##field)
306
307	static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj,
308	struct kobj_attribute *a,
309	char *buf)
310	{
311	struct btrfs_space_info *sinfo = to_space_info(kobj);
312	s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned);
313	return snprintf(buf, PAGE_SIZE, "%lld\n", val);
314	}
315
316	SPACE_INFO_ATTR(flags);
317	SPACE_INFO_ATTR(total_bytes);
318	SPACE_INFO_ATTR(bytes_used);
319	SPACE_INFO_ATTR(bytes_pinned);
320	SPACE_INFO_ATTR(bytes_reserved);
321	SPACE_INFO_ATTR(bytes_may_use);
322	SPACE_INFO_ATTR(disk_used);
323	SPACE_INFO_ATTR(disk_total);
324	BTRFS_ATTR(total_bytes_pinned, 0444, btrfs_space_info_show_total_bytes_pinned);
325
326	static struct attribute *space_info_attrs[] = {
327	BTRFS_ATTR_PTR(flags),
328	BTRFS_ATTR_PTR(total_bytes),
329	BTRFS_ATTR_PTR(bytes_used),
330	BTRFS_ATTR_PTR(bytes_pinned),
331	BTRFS_ATTR_PTR(bytes_reserved),
332	BTRFS_ATTR_PTR(bytes_may_use),
333	BTRFS_ATTR_PTR(disk_used),
334	BTRFS_ATTR_PTR(disk_total),
335	BTRFS_ATTR_PTR(total_bytes_pinned),
336	NULL,
337	};
338
339	static void space_info_release(struct kobject *kobj)
340	{
341	struct btrfs_space_info *sinfo = to_space_info(kobj);
342	percpu_counter_destroy(&sinfo->total_bytes_pinned);
343	kfree(sinfo);
344	}
345
346	struct kobj_type space_info_ktype = {
347	.sysfs_ops = &kobj_sysfs_ops,
348	.release = space_info_release,
349	.default_attrs = space_info_attrs,
350	};
351
352	static const struct attribute *allocation_attrs[] = {
353	BTRFS_ATTR_PTR(global_rsv_reserved),
354	BTRFS_ATTR_PTR(global_rsv_size),
355	NULL,
356	};
357
f8ba9c11 JM	358	static ssize_t btrfs_label_show(struct kobject *kobj,
	359	struct kobj_attribute a, char buf)
	360	{
	361	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	362	return snprintf(buf, PAGE_SIZE, "%s\n", fs_info->super_copy->label);
	363	}
	364
	365	static ssize_t btrfs_label_store(struct kobject *kobj,
	366	struct kobj_attribute *a,
	367	const char *buf, size_t len)
	368	{
	369	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	370	struct btrfs_trans_handle *trans;
	371	struct btrfs_root *root = fs_info->fs_root;
	372	int ret;
	373
	374	if (len >= BTRFS_LABEL_SIZE) {
efe120a0	375	pr_err("BTRFS: unable to set label with more than %d bytes\n",
f8ba9c11 JM	376	BTRFS_LABEL_SIZE - 1);
	377	return -EINVAL;
	378	}
	379
	380	trans = btrfs_start_transaction(root, 0);
	381	if (IS_ERR(trans))
	382	return PTR_ERR(trans);
	383
	384	spin_lock(&root->fs_info->super_lock);
	385	strcpy(fs_info->super_copy->label, buf);
	386	spin_unlock(&root->fs_info->super_lock);
	387	ret = btrfs_commit_transaction(trans, root);
	388
	389	if (!ret)
	390	return len;
	391
	392	return ret;
	393	}
	394	BTRFS_ATTR_RW(label, 0644, btrfs_label_show, btrfs_label_store);
	395
	396	static struct attribute *btrfs_attrs[] = {
	397	BTRFS_ATTR_PTR(label),
	398	NULL,
	399	};
	400
510d7360 JM	401	static void btrfs_release_super_kobj(struct kobject *kobj)
	402	{
	403	struct btrfs_fs_info *fs_info = to_fs_info(kobj);
	404	complete(&fs_info->kobj_unregister);
	405	}
	406
	407	static struct kobj_type btrfs_ktype = {
	408	.sysfs_ops = &kobj_sysfs_ops,
	409	.release = btrfs_release_super_kobj,
f8ba9c11	410	.default_attrs = btrfs_attrs,
510d7360 JM	411	};
	412
	413	static inline struct btrfs_fs_info to_fs_info(struct kobject kobj)
	414	{
	415	if (kobj->ktype != &btrfs_ktype)
	416	return NULL;
	417	return container_of(kobj, struct btrfs_fs_info, super_kobj);
	418	}
58176a96	419
e453d989 JM	420	#define NUM_FEATURE_BITS 64
	421	static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13];
	422	static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS];
	423
	424	static u64 supported_feature_masks[3] = {
	425	[FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP,
	426	[FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
	427	[FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP,
	428	};
	429
	430	static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add)
	431	{
	432	int set;
	433
	434	for (set = 0; set < FEAT_MAX; set++) {
	435	int i;
	436	struct attribute *attrs[2];
	437	struct attribute_group agroup = {
	438	.name = "features",
	439	.attrs = attrs,
	440	};
	441	u64 features = get_features(fs_info, set);
	442	features &= ~supported_feature_masks[set];
	443
	444	if (!features)
	445	continue;
	446
	447	attrs[1] = NULL;
	448	for (i = 0; i < NUM_FEATURE_BITS; i++) {
	449	struct btrfs_feature_attr *fa;
	450
	451	if (!(features & (1ULL << i)))
	452	continue;
	453
	454	fa = &btrfs_feature_attrs[set][i];
	455	attrs[0] = &fa->kobj_attr.attr;
	456	if (add) {
	457	int ret;
	458	ret = sysfs_merge_group(&fs_info->super_kobj,
	459	&agroup);
	460	if (ret)
	461	return ret;
	462	} else
	463	sysfs_unmerge_group(&fs_info->super_kobj,
	464	&agroup);
	465	}
	466
	467	}
	468	return 0;
	469	}
	470
	471	static void __btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
5ac1d209 JM	472	{
	473	kobject_del(&fs_info->super_kobj);
	474	kobject_put(&fs_info->super_kobj);
	475	wait_for_completion(&fs_info->kobj_unregister);
	476	}
	477
e453d989 JM	478	void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info)
	479	{
	480	if (fs_info->space_info_kobj) {
	481	sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs);
	482	kobject_del(fs_info->space_info_kobj);
	483	kobject_put(fs_info->space_info_kobj);
	484	}
	485	kobject_del(fs_info->device_dir_kobj);
	486	kobject_put(fs_info->device_dir_kobj);
	487	addrm_unknown_feature_attrs(fs_info, false);
	488	sysfs_remove_group(&fs_info->super_kobj, &btrfs_feature_attr_group);
	489	__btrfs_sysfs_remove_one(fs_info);
	490	}
	491
79da4fa4 JM	492	const char * const btrfs_feature_set_names[3] = {
	493	[FEAT_COMPAT] = "compat",
	494	[FEAT_COMPAT_RO] = "compat_ro",
	495	[FEAT_INCOMPAT] = "incompat",
	496	};
	497
3b02a68a JM	498	char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags)
	499	{
	500	size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */
	501	int len = 0;
	502	int i;
	503	char *str;
	504
	505	str = kmalloc(bufsize, GFP_KERNEL);
	506	if (!str)
	507	return str;
	508
	509	for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
	510	const char *name;
	511
	512	if (!(flags & (1ULL << i)))
	513	continue;
	514
	515	name = btrfs_feature_attrs[set][i].kobj_attr.attr.name;
	516	len += snprintf(str + len, bufsize - len, "%s%s",
	517	len ? "," : "", name);
	518	}
	519
	520	return str;
	521	}
	522
79da4fa4 JM	523	static void init_feature_attrs(void)
	524	{
	525	struct btrfs_feature_attr *fa;
	526	int set, i;
	527
	528	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) !=
	529	ARRAY_SIZE(btrfs_feature_attrs));
	530	BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) !=
	531	ARRAY_SIZE(btrfs_feature_attrs[0]));
	532
3b02a68a JM	533	memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs));
	534	memset(btrfs_unknown_feature_names, 0,
	535	sizeof(btrfs_unknown_feature_names));
	536
79da4fa4 JM	537	for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
	538	struct btrfs_feature_attr *sfa;
	539	struct attribute *a = btrfs_supported_feature_attrs[i];
3b02a68a	540	int bit;
79da4fa4	541	sfa = attr_to_btrfs_feature_attr(a);
3b02a68a JM	542	bit = ilog2(sfa->feature_bit);
3b02a68a JM	543	fa = &btrfs_feature_attrs[sfa->feature_set][bit];
79da4fa4 JM	544
	545	fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name;
	546	}
	547
	548	for (set = 0; set < FEAT_MAX; set++) {
	549	for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
	550	char *name = btrfs_unknown_feature_names[set][i];
	551	fa = &btrfs_feature_attrs[set][i];
	552
	553	if (fa->kobj_attr.attr.name)
	554	continue;
	555
	556	snprintf(name, 13, "%s:%u",
	557	btrfs_feature_set_names[set], i);
	558
	559	fa->kobj_attr.attr.name = name;
	560	fa->kobj_attr.attr.mode = S_IRUGO;
	561	fa->feature_set = set;
	562	fa->feature_bit = 1ULL << i;
	563	}
	564	}
	565	}
	566
29e5be24 JM	567	static int add_device_membership(struct btrfs_fs_info *fs_info)
	568	{
	569	int error = 0;
	570	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
	571	struct btrfs_device *dev;
	572
	573	fs_info->device_dir_kobj = kobject_create_and_add("devices",
	574	&fs_info->super_kobj);
	575	if (!fs_info->device_dir_kobj)
	576	return -ENOMEM;
	577
	578	list_for_each_entry(dev, &fs_devices->devices, dev_list) {
	579	struct hd_struct *disk = dev->bdev->bd_part;
	580	struct kobject *disk_kobj = &part_to_dev(disk)->kobj;
	581
	582	error = sysfs_create_link(fs_info->device_dir_kobj,
	583	disk_kobj, disk_kobj->name);
	584	if (error)
	585	break;
	586	}
	587
	588	return error;
	589	}
	590
510d7360 JM	591	/* /sys/fs/btrfs/ entry */
	592	static struct kset *btrfs_kset;
	593
5ac1d209 JM	594	int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info)
	595	{
	596	int error;
	597
	598	init_completion(&fs_info->kobj_unregister);
510d7360	599	fs_info->super_kobj.kset = btrfs_kset;
5ac1d209 JM	600	error = kobject_init_and_add(&fs_info->super_kobj, &btrfs_ktype, NULL,
5ac1d209 JM	601	"%pU", fs_info->fsid);
e453d989 JM	602	if (error)
e453d989 JM	603	return error;
510d7360 JM	604
	605	error = sysfs_create_group(&fs_info->super_kobj,
	606	&btrfs_feature_attr_group);
e453d989 JM	607	if (error) {
	608	__btrfs_sysfs_remove_one(fs_info);
	609	return error;
	610	}
79da4fa4	611
e453d989	612	error = addrm_unknown_feature_attrs(fs_info, true);
79da4fa4 JM	613	if (error)
	614	goto failure;
	615
29e5be24 JM	616	error = add_device_membership(fs_info);
	617	if (error)
	618	goto failure;
	619
6ab0a202 JM	620	fs_info->space_info_kobj = kobject_create_and_add("allocation",
	621	&fs_info->super_kobj);
	622	if (!fs_info->space_info_kobj) {
	623	error = -ENOMEM;
	624	goto failure;
	625	}
	626
	627	error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs);
	628	if (error)
	629	goto failure;
	630
79da4fa4 JM	631	return 0;
	632	failure:
	633	btrfs_sysfs_remove_one(fs_info);
5ac1d209 JM	634	return error;
	635	}
	636
b214107e	637	int btrfs_init_sysfs(void)
58176a96	638	{
079b72bc	639	int ret;
e3fe4e71 GK	640	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	641	if (!btrfs_kset)
	642	return -ENOMEM;
079b72bc	643
79da4fa4 JM	644	init_feature_attrs();
79da4fa4 JM	645
079b72bc JM	646	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
	647	if (ret) {
	648	kset_unregister(btrfs_kset);
	649	return ret;
	650	}
	651
e3fe4e71	652	return 0;
58176a96 JB	653	}
58176a96 JB	654
b214107e	655	void btrfs_exit_sysfs(void)
58176a96	656	{
079b72bc	657	sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
e3fe4e71	658	kset_unregister(btrfs_kset);
58176a96	659	}
55d47414	660