[net-next-2.6.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/module.h>
#include <linux/kobject.h>

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

static ssize_t root_blocks_used_show(struct btrfs_root *root, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%llu\n",
		(unsigned long long)btrfs_root_used(&root->root_item));
}

static ssize_t root_block_limit_show(struct btrfs_root *root, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%llu\n",
		(unsigned long long)btrfs_root_limit(&root->root_item));
}

static ssize_t super_blocks_used_show(struct btrfs_fs_info *fs, char *buf)
{

	return snprintf(buf, PAGE_SIZE, "%llu\n",
		(unsigned long long)btrfs_super_bytes_used(&fs->super_copy));
}

static ssize_t super_total_blocks_show(struct btrfs_fs_info *fs, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%llu\n",
		(unsigned long long)btrfs_super_total_bytes(&fs->super_copy));
}

static ssize_t super_blocksize_show(struct btrfs_fs_info *fs, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%llu\n",
		(unsigned long long)btrfs_super_sectorsize(&fs->super_copy));
}

/* this is for root attrs (subvols/snapshots) */
struct btrfs_root_attr {
	struct attribute attr;
	ssize_t (*show)(struct btrfs_root *, char *);
	ssize_t (*store)(struct btrfs_root *, const char *, size_t);
};

#define ROOT_ATTR(name, mode, show, store) \
static struct btrfs_root_attr btrfs_root_attr_##name = __ATTR(name, mode, \
							      show, store)

ROOT_ATTR(blocks_used,	0444,	root_blocks_used_show,	NULL);
ROOT_ATTR(block_limit,	0644,	root_block_limit_show,	NULL);

static struct attribute *btrfs_root_attrs[] = {
	&btrfs_root_attr_blocks_used.attr,
	&btrfs_root_attr_block_limit.attr,
	NULL,
};

/* this is for super attrs (actual full fs) */
struct btrfs_super_attr {
	struct attribute attr;
	ssize_t (*show)(struct btrfs_fs_info *, char *);
	ssize_t (*store)(struct btrfs_fs_info *, const char *, size_t);
};

#define SUPER_ATTR(name, mode, show, store) \
static struct btrfs_super_attr btrfs_super_attr_##name = __ATTR(name, mode, \
								show, store)

SUPER_ATTR(blocks_used,		0444,	super_blocks_used_show,		NULL);
SUPER_ATTR(total_blocks,	0444,	super_total_blocks_show,	NULL);
SUPER_ATTR(blocksize,		0444,	super_blocksize_show,		NULL);

static struct attribute *btrfs_super_attrs[] = {
	&btrfs_super_attr_blocks_used.attr,
	&btrfs_super_attr_total_blocks.attr,
	&btrfs_super_attr_blocksize.attr,
	NULL,
};

static ssize_t btrfs_super_attr_show(struct kobject *kobj,
				    struct attribute *attr, char *buf)
{
	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
						super_kobj);
	struct btrfs_super_attr *a = container_of(attr,
						  struct btrfs_super_attr,
						  attr);

	return a->show ? a->show(fs, buf) : 0;
}

static ssize_t btrfs_super_attr_store(struct kobject *kobj,
				     struct attribute *attr,
				     const char *buf, size_t len)
{
	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
						super_kobj);
	struct btrfs_super_attr *a = container_of(attr,
						  struct btrfs_super_attr,
						  attr);

	return a->store ? a->store(fs, buf, len) : 0;
}

static ssize_t btrfs_root_attr_show(struct kobject *kobj,
				    struct attribute *attr, char *buf)
{
	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
						root_kobj);
	struct btrfs_root_attr *a = container_of(attr,
						 struct btrfs_root_attr,
						 attr);

	return a->show ? a->show(root, buf) : 0;
}

static ssize_t btrfs_root_attr_store(struct kobject *kobj,
				     struct attribute *attr,
				     const char *buf, size_t len)
{
	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
						root_kobj);
	struct btrfs_root_attr *a = container_of(attr,
						 struct btrfs_root_attr,
						 attr);
	return a->store ? a->store(root, buf, len) : 0;
}

static void btrfs_super_release(struct kobject *kobj)
{
	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
						super_kobj);
	complete(&fs->kobj_unregister);
}

static void btrfs_root_release(struct kobject *kobj)
{
	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
						root_kobj);
	complete(&root->kobj_unregister);
}

static const struct sysfs_ops btrfs_super_attr_ops = {
	.show	= btrfs_super_attr_show,
	.store	= btrfs_super_attr_store,
};

static const struct sysfs_ops btrfs_root_attr_ops = {
	.show	= btrfs_root_attr_show,
	.store	= btrfs_root_attr_store,
};

static struct kobj_type btrfs_root_ktype = {
	.default_attrs	= btrfs_root_attrs,
	.sysfs_ops	= &btrfs_root_attr_ops,
	.release	= btrfs_root_release,
};

static struct kobj_type btrfs_super_ktype = {
	.default_attrs	= btrfs_super_attrs,
	.sysfs_ops	= &btrfs_super_attr_ops,
	.release	= btrfs_super_release,
};

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

int btrfs_sysfs_add_super(struct btrfs_fs_info *fs)
{
	int error;
	char *name;
	char c;
	int len = strlen(fs->sb->s_id) + 1;
	int i;

	name = kmalloc(len, GFP_NOFS);
	if (!name) {
		error = -ENOMEM;
		goto fail;
	}

	for (i = 0; i < len; i++) {
		c = fs->sb->s_id[i];
		if (c == '/' || c == '\\')
			c = '!';
		name[i] = c;
	}
	name[len] = '\0';

	fs->super_kobj.kset = btrfs_kset;
	error = kobject_init_and_add(&fs->super_kobj, &btrfs_super_ktype,
				     NULL, "%s", name);
	kfree(name);
	if (error)
		goto fail;

	return 0;

fail:
	printk(KERN_ERR "btrfs: sysfs creation for super failed\n");
	return error;
}

int btrfs_sysfs_add_root(struct btrfs_root *root)
{
	int error;

	error = kobject_init_and_add(&root->root_kobj, &btrfs_root_ktype,
				     &root->fs_info->super_kobj,
				     "%s", root->name);
	if (error)
		goto fail;

	return 0;

fail:
	printk(KERN_ERR "btrfs: sysfs creation for root failed\n");
	return error;
}

void btrfs_sysfs_del_root(struct btrfs_root *root)
{
	kobject_put(&root->root_kobj);
	wait_for_completion(&root->kobj_unregister);
}

void btrfs_sysfs_del_super(struct btrfs_fs_info *fs)
{
	kobject_put(&fs->super_kobj);
	wait_for_completion(&fs->kobj_unregister);
}

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

void btrfs_exit_sysfs(void)
{
	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>
	24	#include <linux/module.h>
	25	#include <linux/kobject.h>
	26
bae45de0 CM	27	#include "ctree.h"
	28	#include "disk-io.h"
	29	#include "transaction.h"
58176a96 JB	30
	31	static ssize_t root_blocks_used_show(struct btrfs_root root, char buf)
	32	{
	33	return snprintf(buf, PAGE_SIZE, "%llu\n",
5f39d397	34	(unsigned long long)btrfs_root_used(&root->root_item));
58176a96 JB	35	}
	36
	37	static ssize_t root_block_limit_show(struct btrfs_root root, char buf)
	38	{
	39	return snprintf(buf, PAGE_SIZE, "%llu\n",
5f39d397	40	(unsigned long long)btrfs_root_limit(&root->root_item));
58176a96 JB	41	}
	42
	43	static ssize_t super_blocks_used_show(struct btrfs_fs_info fs, char buf)
	44	{
db94535d	45
58176a96	46	return snprintf(buf, PAGE_SIZE, "%llu\n",
db94535d	47	(unsigned long long)btrfs_super_bytes_used(&fs->super_copy));
58176a96 JB	48	}
	49
	50	static ssize_t super_total_blocks_show(struct btrfs_fs_info fs, char buf)
	51	{
	52	return snprintf(buf, PAGE_SIZE, "%llu\n",
db94535d	53	(unsigned long long)btrfs_super_total_bytes(&fs->super_copy));
58176a96 JB	54	}
	55
	56	static ssize_t super_blocksize_show(struct btrfs_fs_info fs, char buf)
	57	{
	58	return snprintf(buf, PAGE_SIZE, "%llu\n",
5f39d397	59	(unsigned long long)btrfs_super_sectorsize(&fs->super_copy));
58176a96 JB	60	}
	61
	62	/* this is for root attrs (subvols/snapshots) */
	63	struct btrfs_root_attr {
	64	struct attribute attr;
	65	ssize_t (show)(struct btrfs_root , char *);
	66	ssize_t (store)(struct btrfs_root , const char *, size_t);
	67	};
	68
	69	#define ROOT_ATTR(name, mode, show, store) \
d397712b CM	70	static struct btrfs_root_attr btrfs_root_attr_##name = __ATTR(name, mode, \
d397712b CM	71	show, store)
58176a96 JB	72
	73	ROOT_ATTR(blocks_used, 0444, root_blocks_used_show, NULL);
	74	ROOT_ATTR(block_limit, 0644, root_block_limit_show, NULL);
	75
	76	static struct attribute *btrfs_root_attrs[] = {
	77	&btrfs_root_attr_blocks_used.attr,
	78	&btrfs_root_attr_block_limit.attr,
	79	NULL,
	80	};
	81
	82	/* this is for super attrs (actual full fs) */
	83	struct btrfs_super_attr {
	84	struct attribute attr;
	85	ssize_t (show)(struct btrfs_fs_info , char *);
	86	ssize_t (store)(struct btrfs_fs_info , const char *, size_t);
	87	};
	88
	89	#define SUPER_ATTR(name, mode, show, store) \
d397712b CM	90	static struct btrfs_super_attr btrfs_super_attr_##name = __ATTR(name, mode, \
d397712b CM	91	show, store)
58176a96 JB	92
	93	SUPER_ATTR(blocks_used, 0444, super_blocks_used_show, NULL);
	94	SUPER_ATTR(total_blocks, 0444, super_total_blocks_show, NULL);
	95	SUPER_ATTR(blocksize, 0444, super_blocksize_show, NULL);
	96
	97	static struct attribute *btrfs_super_attrs[] = {
	98	&btrfs_super_attr_blocks_used.attr,
	99	&btrfs_super_attr_total_blocks.attr,
	100	&btrfs_super_attr_blocksize.attr,
	101	NULL,
	102	};
	103
	104	static ssize_t btrfs_super_attr_show(struct kobject *kobj,
	105	struct attribute attr, char buf)
	106	{
	107	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
	108	super_kobj);
	109	struct btrfs_super_attr *a = container_of(attr,
	110	struct btrfs_super_attr,
	111	attr);
	112
	113	return a->show ? a->show(fs, buf) : 0;
	114	}
	115
	116	static ssize_t btrfs_super_attr_store(struct kobject *kobj,
	117	struct attribute *attr,
	118	const char *buf, size_t len)
	119	{
	120	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
	121	super_kobj);
	122	struct btrfs_super_attr *a = container_of(attr,
	123	struct btrfs_super_attr,
	124	attr);
	125
	126	return a->store ? a->store(fs, buf, len) : 0;
	127	}
	128
	129	static ssize_t btrfs_root_attr_show(struct kobject *kobj,
	130	struct attribute attr, char buf)
	131	{
	132	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
	133	root_kobj);
	134	struct btrfs_root_attr *a = container_of(attr,
	135	struct btrfs_root_attr,
	136	attr);
	137
	138	return a->show ? a->show(root, buf) : 0;
	139	}
	140
	141	static ssize_t btrfs_root_attr_store(struct kobject *kobj,
	142	struct attribute *attr,
	143	const char *buf, size_t len)
	144	{
	145	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
	146	root_kobj);
	147	struct btrfs_root_attr *a = container_of(attr,
	148	struct btrfs_root_attr,
	149	attr);
	150	return a->store ? a->store(root, buf, len) : 0;
	151	}
	152
	153	static void btrfs_super_release(struct kobject *kobj)
	154	{
	155	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
156	super_kobj);
157	complete(&fs->kobj_unregister);
158	}
159
160	static void btrfs_root_release(struct kobject *kobj)
161	{
162	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
163	root_kobj);
164	complete(&root->kobj_unregister);
165	}
166
52cf25d0	167	static const struct sysfs_ops btrfs_super_attr_ops = {
58176a96 JB	168	.show = btrfs_super_attr_show,
	169	.store = btrfs_super_attr_store,
	170	};
	171
52cf25d0	172	static const struct sysfs_ops btrfs_root_attr_ops = {
58176a96 JB	173	.show = btrfs_root_attr_show,
	174	.store = btrfs_root_attr_store,
	175	};
	176
	177	static struct kobj_type btrfs_root_ktype = {
	178	.default_attrs = btrfs_root_attrs,
	179	.sysfs_ops = &btrfs_root_attr_ops,
	180	.release = btrfs_root_release,
	181	};
	182
	183	static struct kobj_type btrfs_super_ktype = {
	184	.default_attrs = btrfs_super_attrs,
	185	.sysfs_ops = &btrfs_super_attr_ops,
	186	.release = btrfs_super_release,
	187	};
	188
e3fe4e71 GKH	189	/* /sys/fs/btrfs/ entry */
e3fe4e71 GKH	190	static struct kset *btrfs_kset;
58176a96 JB	191
	192	int btrfs_sysfs_add_super(struct btrfs_fs_info *fs)
	193	{
	194	int error;
6da6abae CM	195	char *name;
	196	char c;
	197	int len = strlen(fs->sb->s_id) + 1;
	198	int i;
	199
	200	name = kmalloc(len, GFP_NOFS);
	201	if (!name) {
	202	error = -ENOMEM;
	203	goto fail;
	204	}
	205
	206	for (i = 0; i < len; i++) {
	207	c = fs->sb->s_id[i];
	208	if (c == '/' \|\| c == '\\')
	209	c = '!';
	210	name[i] = c;
	211	}
	212	name[len] = '\0';
58176a96	213
e3fe4e71 GKH	214	fs->super_kobj.kset = btrfs_kset;
	215	error = kobject_init_and_add(&fs->super_kobj, &btrfs_super_ktype,
	216	NULL, "%s", name);
dd3fd8bd	217	kfree(name);
58176a96 JB	218	if (error)
	219	goto fail;
	220
	221	return 0;
	222
	223	fail:
	224	printk(KERN_ERR "btrfs: sysfs creation for super failed\n");
	225	return error;
	226	}
	227
	228	int btrfs_sysfs_add_root(struct btrfs_root *root)
	229	{
	230	int error;
	231
e3fe4e71 GKH	232	error = kobject_init_and_add(&root->root_kobj, &btrfs_root_ktype,
	233	&root->fs_info->super_kobj,
	234	"%s", root->name);
58176a96 JB	235	if (error)
	236	goto fail;
	237
	238	return 0;
	239
	240	fail:
	241	printk(KERN_ERR "btrfs: sysfs creation for root failed\n");
	242	return error;
	243	}
	244
	245	void btrfs_sysfs_del_root(struct btrfs_root *root)
	246	{
e3fe4e71	247	kobject_put(&root->root_kobj);
58176a96 JB	248	wait_for_completion(&root->kobj_unregister);
	249	}
	250
	251	void btrfs_sysfs_del_super(struct btrfs_fs_info *fs)
	252	{
e3fe4e71	253	kobject_put(&fs->super_kobj);
58176a96 JB	254	wait_for_completion(&fs->kobj_unregister);
	255	}
	256
b214107e	257	int btrfs_init_sysfs(void)
58176a96	258	{
e3fe4e71 GKH	259	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	260	if (!btrfs_kset)
	261	return -ENOMEM;
	262	return 0;
58176a96 JB	263	}
58176a96 JB	264
b214107e	265	void btrfs_exit_sysfs(void)
58176a96	266	{
e3fe4e71	267	kset_unregister(btrfs_kset);
58176a96	268	}
55d47414	269