[mirror_ubuntu-artful-kernel.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 <linux/debugfs.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);
BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES);

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),
	BTRFS_FEAT_ATTR_PTR(no_holes),
	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;
		struct kobject *disk_kobj;

		if (!dev->bdev)
			continue;

		disk = dev->bdev->bd_part;
		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;

/* /sys/kernel/debug/btrfs */
static struct dentry *btrfs_debugfs_root_dentry;

/* Debugging tunables and exported data */
u64 btrfs_debugfs_test;

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

static int btrfs_init_debugfs(void)
{
#ifdef CONFIG_DEBUG_FS
	btrfs_debugfs_root_dentry = debugfs_create_dir("btrfs", NULL);
	if (!btrfs_debugfs_root_dentry)
		return -ENOMEM;

	debugfs_create_u64("test", S_IRUGO | S_IWUGO, btrfs_debugfs_root_dentry,
			&btrfs_debugfs_test);
#endif
	return 0;
}

int btrfs_init_sysfs(void)
{
	int ret;

	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	if (!btrfs_kset)
		return -ENOMEM;

	ret = btrfs_init_debugfs();
	if (ret)
		return ret;

	init_feature_attrs();
	ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);

	return ret;
}

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