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

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

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

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

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
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 struct sysfs_ops btrfs_super_attr_ops = {
	.show	= btrfs_super_attr_show,
	.store	= btrfs_super_attr_store,
};

static 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);
	if (error)
		goto fail;

	kfree(name);
	return 0;

fail:
	kfree(name);
	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()
{
	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	if (!btrfs_kset)
		return -ENOMEM;
	return 0;
}

void btrfs_exit_sysfs()
{
	kset_unregister(btrfs_kset);
}

#else

int btrfs_sysfs_add_super(struct btrfs_fs_info *fs)
{
	return 0;
}

int btrfs_sysfs_add_root(struct btrfs_root *root)
{
	return 0;
}

void btrfs_sysfs_del_root(struct btrfs_root *root)
{
	return;
}

void btrfs_sysfs_del_super(struct btrfs_fs_info *fs)
{
	return;
}

int btrfs_init_sysfs()
{
	return 0;
}

void btrfs_exit_sysfs()
{
	return;
}
#endif
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	30
55d47414	31	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
58176a96 JB	32	static ssize_t root_blocks_used_show(struct btrfs_root root, char buf)
	33	{
	34	return snprintf(buf, PAGE_SIZE, "%llu\n",
5f39d397	35	(unsigned long long)btrfs_root_used(&root->root_item));
58176a96 JB	36	}
	37
	38	static ssize_t root_block_limit_show(struct btrfs_root root, char buf)
	39	{
	40	return snprintf(buf, PAGE_SIZE, "%llu\n",
5f39d397	41	(unsigned long long)btrfs_root_limit(&root->root_item));
58176a96 JB	42	}
	43
	44	static ssize_t super_blocks_used_show(struct btrfs_fs_info fs, char buf)
	45	{
db94535d	46
58176a96	47	return snprintf(buf, PAGE_SIZE, "%llu\n",
db94535d	48	(unsigned long long)btrfs_super_bytes_used(&fs->super_copy));
58176a96 JB	49	}
	50
	51	static ssize_t super_total_blocks_show(struct btrfs_fs_info fs, char buf)
	52	{
	53	return snprintf(buf, PAGE_SIZE, "%llu\n",
db94535d	54	(unsigned long long)btrfs_super_total_bytes(&fs->super_copy));
58176a96 JB	55	}
	56
	57	static ssize_t super_blocksize_show(struct btrfs_fs_info fs, char buf)
	58	{
	59	return snprintf(buf, PAGE_SIZE, "%llu\n",
5f39d397	60	(unsigned long long)btrfs_super_sectorsize(&fs->super_copy));
58176a96 JB	61	}
	62
	63	/* this is for root attrs (subvols/snapshots) */
	64	struct btrfs_root_attr {
	65	struct attribute attr;
	66	ssize_t (show)(struct btrfs_root , char *);
	67	ssize_t (store)(struct btrfs_root , const char *, size_t);
	68	};
	69
	70	#define ROOT_ATTR(name, mode, show, store) \
	71	static struct btrfs_root_attr btrfs_root_attr_##name = __ATTR(name, mode, show, store)
	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) \
	90	static struct btrfs_super_attr btrfs_super_attr_##name = __ATTR(name, mode, show, store)
	91
	92	SUPER_ATTR(blocks_used, 0444, super_blocks_used_show, NULL);
	93	SUPER_ATTR(total_blocks, 0444, super_total_blocks_show, NULL);
	94	SUPER_ATTR(blocksize, 0444, super_blocksize_show, NULL);
	95
	96	static struct attribute *btrfs_super_attrs[] = {
	97	&btrfs_super_attr_blocks_used.attr,
	98	&btrfs_super_attr_total_blocks.attr,
	99	&btrfs_super_attr_blocksize.attr,
	100	NULL,
	101	};
	102
	103	static ssize_t btrfs_super_attr_show(struct kobject *kobj,
	104	struct attribute attr, char buf)
	105	{
	106	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
	107	super_kobj);
	108	struct btrfs_super_attr *a = container_of(attr,
	109	struct btrfs_super_attr,
	110	attr);
	111
	112	return a->show ? a->show(fs, buf) : 0;
	113	}
	114
	115	static ssize_t btrfs_super_attr_store(struct kobject *kobj,
	116	struct attribute *attr,
	117	const char *buf, size_t len)
	118	{
	119	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
	120	super_kobj);
	121	struct btrfs_super_attr *a = container_of(attr,
	122	struct btrfs_super_attr,
	123	attr);
	124
125	return a->store ? a->store(fs, buf, len) : 0;
126	}
127
128	static ssize_t btrfs_root_attr_show(struct kobject *kobj,
129	struct attribute attr, char buf)
130	{
131	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
132	root_kobj);
133	struct btrfs_root_attr *a = container_of(attr,
134	struct btrfs_root_attr,
135	attr);
136
137	return a->show ? a->show(root, buf) : 0;
138	}
139
140	static ssize_t btrfs_root_attr_store(struct kobject *kobj,
141	struct attribute *attr,
142	const char *buf, size_t len)
143	{
144	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
145	root_kobj);
146	struct btrfs_root_attr *a = container_of(attr,
147	struct btrfs_root_attr,
148	attr);
149	return a->store ? a->store(root, buf, len) : 0;
150	}
151
152	static void btrfs_super_release(struct kobject *kobj)
153	{
154	struct btrfs_fs_info *fs = container_of(kobj, struct btrfs_fs_info,
155	super_kobj);
156	complete(&fs->kobj_unregister);
157	}
158
159	static void btrfs_root_release(struct kobject *kobj)
160	{
161	struct btrfs_root *root = container_of(kobj, struct btrfs_root,
162	root_kobj);
163	complete(&root->kobj_unregister);
164	}
165
166	static struct sysfs_ops btrfs_super_attr_ops = {
167	.show = btrfs_super_attr_show,
168	.store = btrfs_super_attr_store,
169	};
170
171	static struct sysfs_ops btrfs_root_attr_ops = {
172	.show = btrfs_root_attr_show,
173	.store = btrfs_root_attr_store,
174	};
175
176	static struct kobj_type btrfs_root_ktype = {
177	.default_attrs = btrfs_root_attrs,
178	.sysfs_ops = &btrfs_root_attr_ops,
179	.release = btrfs_root_release,
180	};
181
182	static struct kobj_type btrfs_super_ktype = {
183	.default_attrs = btrfs_super_attrs,
184	.sysfs_ops = &btrfs_super_attr_ops,
185	.release = btrfs_super_release,
186	};
187
e3fe4e71 GK	188	/* /sys/fs/btrfs/ entry */
e3fe4e71 GK	189	static struct kset *btrfs_kset;
58176a96 JB	190
	191	int btrfs_sysfs_add_super(struct btrfs_fs_info *fs)
	192	{
	193	int error;
6da6abae CM	194	char *name;
	195	char c;
	196	int len = strlen(fs->sb->s_id) + 1;
	197	int i;
	198
	199	name = kmalloc(len, GFP_NOFS);
	200	if (!name) {
	201	error = -ENOMEM;
	202	goto fail;
	203	}
	204
	205	for (i = 0; i < len; i++) {
	206	c = fs->sb->s_id[i];
	207	if (c == '/' \|\| c == '\\')
	208	c = '!';
	209	name[i] = c;
	210	}
	211	name[len] = '\0';
58176a96	212
e3fe4e71 GK	213	fs->super_kobj.kset = btrfs_kset;
	214	error = kobject_init_and_add(&fs->super_kobj, &btrfs_super_ktype,
	215	NULL, "%s", name);
58176a96 JB	216	if (error)
	217	goto fail;
	218
6da6abae	219	kfree(name);
58176a96 JB	220	return 0;
	221
	222	fail:
6da6abae	223	kfree(name);
58176a96 JB	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 GK	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
	257	int btrfs_init_sysfs()
	258	{
e3fe4e71 GK	259	btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
	260	if (!btrfs_kset)
	261	return -ENOMEM;
	262	return 0;
58176a96 JB	263	}
	264
	265	void btrfs_exit_sysfs()
	266	{
e3fe4e71	267	kset_unregister(btrfs_kset);
58176a96	268	}
55d47414 CM	269
	270	#else
	271
	272	int btrfs_sysfs_add_super(struct btrfs_fs_info *fs)
	273	{
	274	return 0;
	275	}
	276
	277	int btrfs_sysfs_add_root(struct btrfs_root *root)
	278	{
	279	return 0;
	280	}
	281
	282	void btrfs_sysfs_del_root(struct btrfs_root *root)
	283	{
	284	return;
	285	}
	286
	287	void btrfs_sysfs_del_super(struct btrfs_fs_info *fs)
	288	{
	289	return;
	290	}
	291
	292	int btrfs_init_sysfs()
	293	{
	294	return 0;
	295	}
	296
	297	void btrfs_exit_sysfs()
	298	{
	299	return;
	300	}
	301	#endif