[linux-block.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 "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 = kmalloc(sizeof(struct iattr), GFP_KERNEL);
		if (!sd_iattr)
			return -ENOMEM;
		/* assign default attributes */
		memset(sd_iattr, 0, sizeof(struct iattr));
		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;

	if (!sd || !sd->s_element)
		BUG();

	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 = dir->d_fsdata;

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

	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>
	14	#include "sysfs.h"
	15
	16	extern struct super_block * sysfs_sb;
	17
	18	static struct address_space_operations sysfs_aops = {
	19	.readpage = simple_readpage,
	20	.prepare_write = simple_prepare_write,
	21	.commit_write = simple_commit_write
	22	};
	23
	24	static struct backing_dev_info sysfs_backing_dev_info = {
	25	.ra_pages = 0, /* No readahead */
	26	.capabilities = BDI_CAP_NO_ACCT_DIRTY \| BDI_CAP_NO_WRITEBACK,
	27	};
	28
988d186d MS	29	static struct inode_operations sysfs_inode_operations ={
	30	.setattr = sysfs_setattr,
	31	};
	32
	33	int sysfs_setattr(struct dentry * dentry, struct iattr * iattr)
	34	{
	35	struct inode * inode = dentry->d_inode;
	36	struct sysfs_dirent * sd = dentry->d_fsdata;
	37	struct iattr * sd_iattr;
	38	unsigned int ia_valid = iattr->ia_valid;
	39	int error;
	40
	41	if (!sd)
	42	return -EINVAL;
	43
	44	sd_iattr = sd->s_iattr;
	45
	46	error = inode_change_ok(inode, iattr);
	47	if (error)
	48	return error;
	49
	50	error = inode_setattr(inode, iattr);
	51	if (error)
	52	return error;
	53
	54	if (!sd_iattr) {
	55	/* setting attributes for the first time, allocate now */
	56	sd_iattr = kmalloc(sizeof(struct iattr), GFP_KERNEL);
	57	if (!sd_iattr)
	58	return -ENOMEM;
	59	/* assign default attributes */
	60	memset(sd_iattr, 0, sizeof(struct iattr));
	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
	178	if (!sd \|\| !sd->s_element)
	179	BUG();
	180
	181	switch (sd->s_type) {
	182	case SYSFS_DIR:
	183	/* Always have a dentry so use that */
	184	return sd->s_dentry->d_name.name;
	185
	186	case SYSFS_KOBJ_ATTR:
	187	attr = sd->s_element;
	188	return attr->name;
	189
	190	case SYSFS_KOBJ_BIN_ATTR:
	191	bin_attr = sd->s_element;
	192	return bin_attr->attr.name;
	193
	194	case SYSFS_KOBJ_LINK:
	195	sl = sd->s_element;
	196	return sl->link_name;
	197	}
	198	return NULL;
	199	}
	200
	201
	202	/*
	203	* Unhashes the dentry corresponding to given sysfs_dirent
1b1dcc1b	204	* Called with parent inode's i_mutex held.
1da177e4 LT	205	*/
	206	void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
	207	{
	208	struct dentry * dentry = sd->s_dentry;
	209
	210	if (dentry) {
	211	spin_lock(&dcache_lock);
	212	spin_lock(&dentry->d_lock);
	213	if (!(d_unhashed(dentry) && dentry->d_inode)) {
	214	dget_locked(dentry);
	215	__d_drop(dentry);
	216	spin_unlock(&dentry->d_lock);
	217	spin_unlock(&dcache_lock);
	218	simple_unlink(parent->d_inode, dentry);
	219	} else {
	220	spin_unlock(&dentry->d_lock);
	221	spin_unlock(&dcache_lock);
	222	}
	223	}
	224	}
	225
	226	void sysfs_hash_and_remove(struct dentry * dir, const char * name)
	227	{
	228	struct sysfs_dirent * sd;
	229	struct sysfs_dirent * parent_sd = dir->d_fsdata;
	230
36676bcb JB	231	if (dir->d_inode == NULL)
	232	/* no inode means this hasn't been made visible yet */
	233	return;
	234
1b1dcc1b	235	mutex_lock(&dir->d_inode->i_mutex);
1da177e4 LT	236	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
	237	if (!sd->s_element)
	238	continue;
	239	if (!strcmp(sysfs_get_name(sd), name)) {
	240	list_del_init(&sd->s_sibling);
	241	sysfs_drop_dentry(sd, dir);
	242	sysfs_put(sd);
	243	break;
	244	}
	245	}
1b1dcc1b	246	mutex_unlock(&dir->d_inode->i_mutex);
1da177e4	247	}