[deliverable/linux.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 const 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;
}


/*
 * sysfs has a different i_mutex lock order behavior for i_mutex than other
 * filesystems; sysfs i_mutex is called in many places with subsystem locks
 * held. At the same time, many of the VFS locking rules do not apply to
 * sysfs at all (cross directory rename for example). To untangle this mess
 * (which gives false positives in lockdep), we're giving sysfs inodes their
 * own class for i_mutex.
 */
static struct lock_class_key sysfs_inode_imutex_key;

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;
		lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);

		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
f5e54d6e	19	static const struct address_space_operations sysfs_aops = {
1da177e4 LT	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
232ba9db AV	112
	113	/*
	114	* sysfs has a different i_mutex lock order behavior for i_mutex than other
	115	* filesystems; sysfs i_mutex is called in many places with subsystem locks
	116	* held. At the same time, many of the VFS locking rules do not apply to
	117	* sysfs at all (cross directory rename for example). To untangle this mess
	118	* (which gives false positives in lockdep), we're giving sysfs inodes their
	119	* own class for i_mutex.
	120	*/
	121	static struct lock_class_key sysfs_inode_imutex_key;
	122
8215534c	123	struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent * sd)
1da177e4 LT	124	{
	125	struct inode * inode = new_inode(sysfs_sb);
	126	if (inode) {
1da177e4 LT	127	inode->i_blksize = PAGE_CACHE_SIZE;
1da177e4 LT	128	inode->i_blocks = 0;
1da177e4 LT	129	inode->i_mapping->a_ops = &sysfs_aops;
1da177e4 LT	130	inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
8215534c	131	inode->i_op = &sysfs_inode_operations;
232ba9db	132	lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);
8215534c MS	133
	134	if (sd->s_iattr) {
	135	/* sysfs_dirent has non-default attributes
	136	* get them for the new inode from persistent copy
	137	* in sysfs_dirent
	138	*/
	139	set_inode_attr(inode, sd->s_iattr);
	140	} else
	141	set_default_inode_attr(inode, mode);
1da177e4 LT	142	}
	143	return inode;
	144	}
	145
	146	int sysfs_create(struct dentry * dentry, int mode, int (init)(struct inode ))
	147	{
	148	int error = 0;
	149	struct inode * inode = NULL;
	150	if (dentry) {
	151	if (!dentry->d_inode) {
8215534c MS	152	struct sysfs_dirent * sd = dentry->d_fsdata;
8215534c MS	153	if ((inode = sysfs_new_inode(mode, sd))) {
1da177e4 LT	154	if (dentry->d_parent && dentry->d_parent->d_inode) {
	155	struct inode *p_inode = dentry->d_parent->d_inode;
	156	p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
	157	}
	158	goto Proceed;
	159	}
	160	else
	161	error = -ENOMEM;
	162	} else
	163	error = -EEXIST;
	164	} else
	165	error = -ENOENT;
	166	goto Done;
	167
	168	Proceed:
	169	if (init)
	170	error = init(inode);
	171	if (!error) {
	172	d_instantiate(dentry, inode);
	173	if (S_ISDIR(mode))
	174	dget(dentry); /* pin only directory dentry in core */
	175	} else
	176	iput(inode);
	177	Done:
	178	return error;
	179	}
	180
1da177e4 LT	181	/*
	182	* Get the name for corresponding element represented by the given sysfs_dirent
	183	*/
	184	const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
	185	{
	186	struct attribute * attr;
	187	struct bin_attribute * bin_attr;
	188	struct sysfs_symlink * sl;
	189
99cee0cd	190	BUG_ON(!sd \|\| !sd->s_element);
1da177e4 LT	191
	192	switch (sd->s_type) {
	193	case SYSFS_DIR:
	194	/* Always have a dentry so use that */
	195	return sd->s_dentry->d_name.name;
	196
	197	case SYSFS_KOBJ_ATTR:
	198	attr = sd->s_element;
	199	return attr->name;
	200
	201	case SYSFS_KOBJ_BIN_ATTR:
	202	bin_attr = sd->s_element;
	203	return bin_attr->attr.name;
	204
	205	case SYSFS_KOBJ_LINK:
	206	sl = sd->s_element;
	207	return sl->link_name;
	208	}
	209	return NULL;
	210	}
	211
	212
	213	/*
	214	* Unhashes the dentry corresponding to given sysfs_dirent
1b1dcc1b	215	* Called with parent inode's i_mutex held.
1da177e4 LT	216	*/
	217	void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
	218	{
	219	struct dentry * dentry = sd->s_dentry;
	220
	221	if (dentry) {
	222	spin_lock(&dcache_lock);
	223	spin_lock(&dentry->d_lock);
	224	if (!(d_unhashed(dentry) && dentry->d_inode)) {
	225	dget_locked(dentry);
	226	__d_drop(dentry);
	227	spin_unlock(&dentry->d_lock);
	228	spin_unlock(&dcache_lock);
	229	simple_unlink(parent->d_inode, dentry);
	230	} else {
	231	spin_unlock(&dentry->d_lock);
	232	spin_unlock(&dcache_lock);
	233	}
	234	}
	235	}
	236
	237	void sysfs_hash_and_remove(struct dentry * dir, const char * name)
	238	{
	239	struct sysfs_dirent * sd;
641e6f30 GKH	240	struct sysfs_dirent * parent_sd;
	241
	242	if (!dir)
	243	return;
1da177e4	244
36676bcb JB	245	if (dir->d_inode == NULL)
	246	/* no inode means this hasn't been made visible yet */
	247	return;
	248
641e6f30	249	parent_sd = dir->d_fsdata;
1b1dcc1b	250	mutex_lock(&dir->d_inode->i_mutex);
1da177e4 LT	251	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
	252	if (!sd->s_element)
	253	continue;
	254	if (!strcmp(sysfs_get_name(sd), name)) {
	255	list_del_init(&sd->s_sibling);
	256	sysfs_drop_dentry(sd, dir);
	257	sysfs_put(sd);
	258	break;
	259	}
	260	}
1b1dcc1b	261	mutex_unlock(&dir->d_inode->i_mutex);
1da177e4	262	}