[net-next-2.6.git] / fs / sysfs / inode.c

/*
 * inode.c - basic inode and dentry operations.
 *
 * sysfs is Copyright (c) 2001-3 Patrick Mochel
 *
 * Please see Documentation/filesystems/sysfs.txt for more information.
 */

#undef DEBUG 

#include <linux/pagemap.h>
#include <linux/namei.h>
#include <linux/backing-dev.h>
#include <linux/capability.h>
#include "sysfs.h"

extern struct super_block * sysfs_sb;

static struct address_space_operations sysfs_aops = {
	.readpage	= simple_readpage,
	.prepare_write	= simple_prepare_write,
	.commit_write	= simple_commit_write
};

static struct backing_dev_info sysfs_backing_dev_info = {
	.ra_pages	= 0,	/* No readahead */
	.capabilities	= BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
};

static struct inode_operations sysfs_inode_operations ={
	.setattr	= sysfs_setattr,
};

int sysfs_setattr(struct dentry * dentry, struct iattr * iattr)
{
	struct inode * inode = dentry->d_inode;
	struct sysfs_dirent * sd = dentry->d_fsdata;
	struct iattr * sd_iattr;
	unsigned int ia_valid = iattr->ia_valid;
	int error;

	if (!sd)
		return -EINVAL;

	sd_iattr = sd->s_iattr;

	error = inode_change_ok(inode, iattr);
	if (error)
		return error;

	error = inode_setattr(inode, iattr);
	if (error)
		return error;

	if (!sd_iattr) {
		/* setting attributes for the first time, allocate now */
		sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
		if (!sd_iattr)
			return -ENOMEM;
		/* assign default attributes */
		sd_iattr->ia_mode = sd->s_mode;
		sd_iattr->ia_uid = 0;
		sd_iattr->ia_gid = 0;
		sd_iattr->ia_atime = sd_iattr->ia_mtime = sd_iattr->ia_ctime = CURRENT_TIME;
		sd->s_iattr = sd_iattr;
	}

	/* attributes were changed atleast once in past */

	if (ia_valid & ATTR_UID)
		sd_iattr->ia_uid = iattr->ia_uid;
	if (ia_valid & ATTR_GID)
		sd_iattr->ia_gid = iattr->ia_gid;
	if (ia_valid & ATTR_ATIME)
		sd_iattr->ia_atime = timespec_trunc(iattr->ia_atime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_MTIME)
		sd_iattr->ia_mtime = timespec_trunc(iattr->ia_mtime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_CTIME)
		sd_iattr->ia_ctime = timespec_trunc(iattr->ia_ctime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_MODE) {
		umode_t mode = iattr->ia_mode;

		if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
			mode &= ~S_ISGID;
		sd_iattr->ia_mode = sd->s_mode = mode;
	}

	return error;
}

static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
{
	inode->i_mode = mode;
	inode->i_uid = 0;
	inode->i_gid = 0;
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
}

static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
{
	inode->i_mode = iattr->ia_mode;
	inode->i_uid = iattr->ia_uid;
	inode->i_gid = iattr->ia_gid;
	inode->i_atime = iattr->ia_atime;
	inode->i_mtime = iattr->ia_mtime;
	inode->i_ctime = iattr->ia_ctime;
}

struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent * sd)
{
	struct inode * inode = new_inode(sysfs_sb);
	if (inode) {
		inode->i_blksize = PAGE_CACHE_SIZE;
		inode->i_blocks = 0;
		inode->i_mapping->a_ops = &sysfs_aops;
		inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
		inode->i_op = &sysfs_inode_operations;

		if (sd->s_iattr) {
			/* sysfs_dirent has non-default attributes
			 * get them for the new inode from persistent copy
			 * in sysfs_dirent
			 */
			set_inode_attr(inode, sd->s_iattr);
		} else
			set_default_inode_attr(inode, mode);
	}
	return inode;
}

int sysfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *))
{
	int error = 0;
	struct inode * inode = NULL;
	if (dentry) {
		if (!dentry->d_inode) {
			struct sysfs_dirent * sd = dentry->d_fsdata;
			if ((inode = sysfs_new_inode(mode, sd))) {
				if (dentry->d_parent && dentry->d_parent->d_inode) {
					struct inode *p_inode = dentry->d_parent->d_inode;
					p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
				}
				goto Proceed;
			}
			else 
				error = -ENOMEM;
		} else
			error = -EEXIST;
	} else 
		error = -ENOENT;
	goto Done;

 Proceed:
	if (init)
		error = init(inode);
	if (!error) {
		d_instantiate(dentry, inode);
		if (S_ISDIR(mode))
			dget(dentry);  /* pin only directory dentry in core */
	} else
		iput(inode);
 Done:
	return error;
}

/*
 * Get the name for corresponding element represented by the given sysfs_dirent
 */
const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
{
	struct attribute * attr;
	struct bin_attribute * bin_attr;
	struct sysfs_symlink  * sl;

	BUG_ON(!sd || !sd->s_element);

	switch (sd->s_type) {
		case SYSFS_DIR:
			/* Always have a dentry so use that */
			return sd->s_dentry->d_name.name;

		case SYSFS_KOBJ_ATTR:
			attr = sd->s_element;
			return attr->name;

		case SYSFS_KOBJ_BIN_ATTR:
			bin_attr = sd->s_element;
			return bin_attr->attr.name;

		case SYSFS_KOBJ_LINK:
			sl = sd->s_element;
			return sl->link_name;
	}
	return NULL;
}


/*
 * Unhashes the dentry corresponding to given sysfs_dirent
 * Called with parent inode's i_mutex held.
 */
void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
{
	struct dentry * dentry = sd->s_dentry;

	if (dentry) {
		spin_lock(&dcache_lock);
		spin_lock(&dentry->d_lock);
		if (!(d_unhashed(dentry) && dentry->d_inode)) {
			dget_locked(dentry);
			__d_drop(dentry);
			spin_unlock(&dentry->d_lock);
			spin_unlock(&dcache_lock);
			simple_unlink(parent->d_inode, dentry);
		} else {
			spin_unlock(&dentry->d_lock);
			spin_unlock(&dcache_lock);
		}
	}
}

void sysfs_hash_and_remove(struct dentry * dir, const char * name)
{
	struct sysfs_dirent * sd;
	struct sysfs_dirent * parent_sd;

	if (!dir)
		return;

	if (dir->d_inode == NULL)
		/* no inode means this hasn't been made visible yet */
		return;

	parent_sd = dir->d_fsdata;
	mutex_lock(&dir->d_inode->i_mutex);
	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
		if (!sd->s_element)
			continue;
		if (!strcmp(sysfs_get_name(sd), name)) {
			list_del_init(&sd->s_sibling);
			sysfs_drop_dentry(sd, dir);
			sysfs_put(sd);
			break;
		}
	}
	mutex_unlock(&dir->d_inode->i_mutex);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* inode.c - basic inode and dentry operations.
	3	*
	4	* sysfs is Copyright (c) 2001-3 Patrick Mochel
	5	*
	6	* Please see Documentation/filesystems/sysfs.txt for more information.
	7	*/
	8
	9	#undef DEBUG
	10
	11	#include <linux/pagemap.h>
	12	#include <linux/namei.h>
	13	#include <linux/backing-dev.h>
16f7e0fe	14	#include <linux/capability.h>
1da177e4 LT	15	#include "sysfs.h"
	16
	17	extern struct super_block * sysfs_sb;
	18
	19	static struct address_space_operations sysfs_aops = {
	20	.readpage = simple_readpage,
	21	.prepare_write = simple_prepare_write,
	22	.commit_write = simple_commit_write
	23	};
	24
	25	static struct backing_dev_info sysfs_backing_dev_info = {
	26	.ra_pages = 0, /* No readahead */
	27	.capabilities = BDI_CAP_NO_ACCT_DIRTY \| BDI_CAP_NO_WRITEBACK,
	28	};
	29
988d186d MS	30	static struct inode_operations sysfs_inode_operations ={
	31	.setattr = sysfs_setattr,
	32	};
	33
	34	int sysfs_setattr(struct dentry * dentry, struct iattr * iattr)
	35	{
	36	struct inode * inode = dentry->d_inode;
	37	struct sysfs_dirent * sd = dentry->d_fsdata;
	38	struct iattr * sd_iattr;
	39	unsigned int ia_valid = iattr->ia_valid;
	40	int error;
	41
	42	if (!sd)
	43	return -EINVAL;
	44
	45	sd_iattr = sd->s_iattr;
	46
	47	error = inode_change_ok(inode, iattr);
	48	if (error)
	49	return error;
	50
	51	error = inode_setattr(inode, iattr);
	52	if (error)
	53	return error;
	54
	55	if (!sd_iattr) {
	56	/* setting attributes for the first time, allocate now */
58d49283	57	sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
988d186d MS	58	if (!sd_iattr)
	59	return -ENOMEM;
	60	/* assign default attributes */
988d186d MS	61	sd_iattr->ia_mode = sd->s_mode;
	62	sd_iattr->ia_uid = 0;
	63	sd_iattr->ia_gid = 0;
	64	sd_iattr->ia_atime = sd_iattr->ia_mtime = sd_iattr->ia_ctime = CURRENT_TIME;
	65	sd->s_iattr = sd_iattr;
	66	}
	67
	68	/* attributes were changed atleast once in past */
	69
	70	if (ia_valid & ATTR_UID)
	71	sd_iattr->ia_uid = iattr->ia_uid;
	72	if (ia_valid & ATTR_GID)
	73	sd_iattr->ia_gid = iattr->ia_gid;
	74	if (ia_valid & ATTR_ATIME)
	75	sd_iattr->ia_atime = timespec_trunc(iattr->ia_atime,
	76	inode->i_sb->s_time_gran);
	77	if (ia_valid & ATTR_MTIME)
	78	sd_iattr->ia_mtime = timespec_trunc(iattr->ia_mtime,
	79	inode->i_sb->s_time_gran);
	80	if (ia_valid & ATTR_CTIME)
	81	sd_iattr->ia_ctime = timespec_trunc(iattr->ia_ctime,
	82	inode->i_sb->s_time_gran);
	83	if (ia_valid & ATTR_MODE) {
	84	umode_t mode = iattr->ia_mode;
	85
	86	if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
	87	mode &= ~S_ISGID;
9ca1eb32	88	sd_iattr->ia_mode = sd->s_mode = mode;
988d186d MS	89	}
	90
	91	return error;
	92	}
	93
8215534c MS	94	static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
	95	{
	96	inode->i_mode = mode;
	97	inode->i_uid = 0;
	98	inode->i_gid = 0;
	99	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	100	}
	101
	102	static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
	103	{
	104	inode->i_mode = iattr->ia_mode;
	105	inode->i_uid = iattr->ia_uid;
	106	inode->i_gid = iattr->ia_gid;
	107	inode->i_atime = iattr->ia_atime;
	108	inode->i_mtime = iattr->ia_mtime;
	109	inode->i_ctime = iattr->ia_ctime;
	110	}
	111
	112	struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent * sd)
1da177e4 LT	113	{
	114	struct inode * inode = new_inode(sysfs_sb);
	115	if (inode) {
1da177e4 LT	116	inode->i_blksize = PAGE_CACHE_SIZE;
1da177e4 LT	117	inode->i_blocks = 0;
1da177e4 LT	118	inode->i_mapping->a_ops = &sysfs_aops;
1da177e4 LT	119	inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
8215534c MS	120	inode->i_op = &sysfs_inode_operations;
	121
	122	if (sd->s_iattr) {
	123	/* sysfs_dirent has non-default attributes
	124	* get them for the new inode from persistent copy
	125	* in sysfs_dirent
	126	*/
	127	set_inode_attr(inode, sd->s_iattr);
	128	} else
	129	set_default_inode_attr(inode, mode);
1da177e4 LT	130	}
	131	return inode;
	132	}
	133
	134	int sysfs_create(struct dentry * dentry, int mode, int (init)(struct inode ))
	135	{
	136	int error = 0;
	137	struct inode * inode = NULL;
	138	if (dentry) {
	139	if (!dentry->d_inode) {
8215534c MS	140	struct sysfs_dirent * sd = dentry->d_fsdata;
8215534c MS	141	if ((inode = sysfs_new_inode(mode, sd))) {
1da177e4 LT	142	if (dentry->d_parent && dentry->d_parent->d_inode) {
	143	struct inode *p_inode = dentry->d_parent->d_inode;
	144	p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
	145	}
	146	goto Proceed;
	147	}
	148	else
	149	error = -ENOMEM;
	150	} else
	151	error = -EEXIST;
	152	} else
	153	error = -ENOENT;
	154	goto Done;
	155
	156	Proceed:
	157	if (init)
	158	error = init(inode);
	159	if (!error) {
	160	d_instantiate(dentry, inode);
	161	if (S_ISDIR(mode))
	162	dget(dentry); /* pin only directory dentry in core */
	163	} else
	164	iput(inode);
	165	Done:
	166	return error;
	167	}
	168
1da177e4 LT	169	/*
	170	* Get the name for corresponding element represented by the given sysfs_dirent
	171	*/
	172	const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
	173	{
	174	struct attribute * attr;
	175	struct bin_attribute * bin_attr;
	176	struct sysfs_symlink * sl;
	177
99cee0cd	178	BUG_ON(!sd \|\| !sd->s_element);
1da177e4 LT	179
	180	switch (sd->s_type) {
	181	case SYSFS_DIR:
	182	/* Always have a dentry so use that */
	183	return sd->s_dentry->d_name.name;
	184
	185	case SYSFS_KOBJ_ATTR:
	186	attr = sd->s_element;
	187	return attr->name;
	188
	189	case SYSFS_KOBJ_BIN_ATTR:
	190	bin_attr = sd->s_element;
	191	return bin_attr->attr.name;
	192
	193	case SYSFS_KOBJ_LINK:
	194	sl = sd->s_element;
	195	return sl->link_name;
	196	}
	197	return NULL;
	198	}
	199
	200
	201	/*
	202	* Unhashes the dentry corresponding to given sysfs_dirent
1b1dcc1b	203	* Called with parent inode's i_mutex held.
1da177e4 LT	204	*/
	205	void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
	206	{
	207	struct dentry * dentry = sd->s_dentry;
	208
	209	if (dentry) {
	210	spin_lock(&dcache_lock);
	211	spin_lock(&dentry->d_lock);
	212	if (!(d_unhashed(dentry) && dentry->d_inode)) {
	213	dget_locked(dentry);
	214	__d_drop(dentry);
	215	spin_unlock(&dentry->d_lock);
	216	spin_unlock(&dcache_lock);
	217	simple_unlink(parent->d_inode, dentry);
	218	} else {
	219	spin_unlock(&dentry->d_lock);
	220	spin_unlock(&dcache_lock);
	221	}
	222	}
	223	}
	224
	225	void sysfs_hash_and_remove(struct dentry * dir, const char * name)
	226	{
	227	struct sysfs_dirent * sd;
641e6f30 GKH	228	struct sysfs_dirent * parent_sd;
	229
	230	if (!dir)
	231	return;
1da177e4	232
36676bcb JB	233	if (dir->d_inode == NULL)
	234	/* no inode means this hasn't been made visible yet */
	235	return;
	236
641e6f30	237	parent_sd = dir->d_fsdata;
1b1dcc1b	238	mutex_lock(&dir->d_inode->i_mutex);
1da177e4 LT	239	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
	240	if (!sd->s_element)
	241	continue;
	242	if (!strcmp(sysfs_get_name(sd), name)) {
	243	list_del_init(&sd->s_sibling);
	244	sysfs_drop_dentry(sd, dir);
	245	sysfs_put(sd);
	246	break;
	247	}
	248	}
1b1dcc1b	249	mutex_unlock(&dir->d_inode->i_mutex);
1da177e4	250	}