[mirror_ubuntu-zesty-kernel.git] / fs / sysfs / dir.c

/*
 * dir.c - Operations for sysfs directories.
 */

#undef DEBUG

#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/module.h>
#include <linux/kobject.h>
#include <linux/namei.h>
#include <asm/semaphore.h>
#include "sysfs.h"

DECLARE_RWSEM(sysfs_rename_sem);

static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
{
	struct sysfs_dirent * sd = dentry->d_fsdata;

	if (sd) {
		BUG_ON(sd->s_dentry != dentry);
		sd->s_dentry = NULL;
		sysfs_put(sd);
	}
	iput(inode);
}

static struct dentry_operations sysfs_dentry_ops = {
	.d_iput		= sysfs_d_iput,
};

/*
 * Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
 */
static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent * parent_sd,
						void * element)
{
	struct sysfs_dirent * sd;

	sd = kmem_cache_alloc(sysfs_dir_cachep, GFP_KERNEL);
	if (!sd)
		return NULL;

	memset(sd, 0, sizeof(*sd));
	atomic_set(&sd->s_count, 1);
	atomic_set(&sd->s_event, 1);
	INIT_LIST_HEAD(&sd->s_children);
	list_add(&sd->s_sibling, &parent_sd->s_children);
	sd->s_element = element;

	return sd;
}

/*
 *
 * Return -EEXIST if there is already a sysfs element with the same name for
 * the same parent.
 *
 * called with parent inode's i_mutex held
 */
int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
			  const unsigned char *new)
{
	struct sysfs_dirent * sd;

	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
		if (sd->s_element) {
			const unsigned char *existing = sysfs_get_name(sd);
			if (strcmp(existing, new))
				continue;
			else
				return -EEXIST;
		}
	}

	return 0;
}


int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
			void * element, umode_t mode, int type)
{
	struct sysfs_dirent * sd;

	sd = sysfs_new_dirent(parent_sd, element);
	if (!sd)
		return -ENOMEM;

	sd->s_mode = mode;
	sd->s_type = type;
	sd->s_dentry = dentry;
	if (dentry) {
		dentry->d_fsdata = sysfs_get(sd);
		dentry->d_op = &sysfs_dentry_ops;
	}

	return 0;
}

static int init_dir(struct inode * inode)
{
	inode->i_op = &sysfs_dir_inode_operations;
	inode->i_fop = &sysfs_dir_operations;

	/* directory inodes start off with i_nlink == 2 (for "." entry) */
	inc_nlink(inode);
	return 0;
}

static int init_file(struct inode * inode)
{
	inode->i_size = PAGE_SIZE;
	inode->i_fop = &sysfs_file_operations;
	return 0;
}

static int init_symlink(struct inode * inode)
{
	inode->i_op = &sysfs_symlink_inode_operations;
	return 0;
}

static int create_dir(struct kobject * k, struct dentry * p,
		      const char * n, struct dentry ** d)
{
	int error;
	umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;

	mutex_lock(&p->d_inode->i_mutex);
	*d = lookup_one_len(n, p, strlen(n));
	if (!IS_ERR(*d)) {
 		if (sysfs_dirent_exist(p->d_fsdata, n))
  			error = -EEXIST;
  		else
			error = sysfs_make_dirent(p->d_fsdata, *d, k, mode,
								SYSFS_DIR);
		if (!error) {
			error = sysfs_create(*d, mode, init_dir);
			if (!error) {
				inc_nlink(p->d_inode);
				(*d)->d_op = &sysfs_dentry_ops;
				d_rehash(*d);
			}
		}
		if (error && (error != -EEXIST)) {
			struct sysfs_dirent *sd = (*d)->d_fsdata;
			if (sd) {
 				list_del_init(&sd->s_sibling);
				sysfs_put(sd);
			}
			d_drop(*d);
		}
		dput(*d);
	} else
		error = PTR_ERR(*d);
	mutex_unlock(&p->d_inode->i_mutex);
	return error;
}


int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
{
	return create_dir(k,k->dentry,n,d);
}

/**
 *	sysfs_create_dir - create a directory for an object.
 *	@parent:	parent parent object.
 *	@kobj:		object we're creating directory for. 
 */

int sysfs_create_dir(struct kobject * kobj)
{
	struct dentry * dentry = NULL;
	struct dentry * parent;
	int error = 0;

	BUG_ON(!kobj);

	if (kobj->parent)
		parent = kobj->parent->dentry;
	else if (sysfs_mount && sysfs_mount->mnt_sb)
		parent = sysfs_mount->mnt_sb->s_root;
	else
		return -EFAULT;

	error = create_dir(kobj,parent,kobject_name(kobj),&dentry);
	if (!error)
		kobj->dentry = dentry;
	return error;
}

/* attaches attribute's sysfs_dirent to the dentry corresponding to the
 * attribute file
 */
static int sysfs_attach_attr(struct sysfs_dirent * sd, struct dentry * dentry)
{
	struct attribute * attr = NULL;
	struct bin_attribute * bin_attr = NULL;
	int (* init) (struct inode *) = NULL;
	int error = 0;

        if (sd->s_type & SYSFS_KOBJ_BIN_ATTR) {
                bin_attr = sd->s_element;
                attr = &bin_attr->attr;
        } else {
                attr = sd->s_element;
                init = init_file;
        }

	dentry->d_fsdata = sysfs_get(sd);
	sd->s_dentry = dentry;
	error = sysfs_create(dentry, (attr->mode & S_IALLUGO) | S_IFREG, init);
	if (error) {
		sysfs_put(sd);
		return error;
	}

        if (bin_attr) {
		dentry->d_inode->i_size = bin_attr->size;
		dentry->d_inode->i_fop = &bin_fops;
	}
	dentry->d_op = &sysfs_dentry_ops;
	d_rehash(dentry);

	return 0;
}

static int sysfs_attach_link(struct sysfs_dirent * sd, struct dentry * dentry)
{
	int err = 0;

	dentry->d_fsdata = sysfs_get(sd);
	sd->s_dentry = dentry;
	err = sysfs_create(dentry, S_IFLNK|S_IRWXUGO, init_symlink);
	if (!err) {
		dentry->d_op = &sysfs_dentry_ops;
		d_rehash(dentry);
	} else
		sysfs_put(sd);

	return err;
}

static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
				struct nameidata *nd)
{
	struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
	struct sysfs_dirent * sd;
	int err = 0;

	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
		if (sd->s_type & SYSFS_NOT_PINNED) {
			const unsigned char * name = sysfs_get_name(sd);

			if (strcmp(name, dentry->d_name.name))
				continue;

			if (sd->s_type & SYSFS_KOBJ_LINK)
				err = sysfs_attach_link(sd, dentry);
			else
				err = sysfs_attach_attr(sd, dentry);
			break;
		}
	}

	return ERR_PTR(err);
}

struct inode_operations sysfs_dir_inode_operations = {
	.lookup		= sysfs_lookup,
	.setattr	= sysfs_setattr,
};

static void remove_dir(struct dentry * d)
{
	struct dentry * parent = dget(d->d_parent);
	struct sysfs_dirent * sd;

	mutex_lock(&parent->d_inode->i_mutex);
	d_delete(d);
	sd = d->d_fsdata;
 	list_del_init(&sd->s_sibling);
	sysfs_put(sd);
	if (d->d_inode)
		simple_rmdir(parent->d_inode,d);

	pr_debug(" o %s removing done (%d)\n",d->d_name.name,
		 atomic_read(&d->d_count));

	mutex_unlock(&parent->d_inode->i_mutex);
	dput(parent);
}

void sysfs_remove_subdir(struct dentry * d)
{
	remove_dir(d);
}


/**
 *	sysfs_remove_dir - remove an object's directory.
 *	@kobj:	object. 
 *
 *	The only thing special about this is that we remove any files in 
 *	the directory before we remove the directory, and we've inlined
 *	what used to be sysfs_rmdir() below, instead of calling separately.
 */

void sysfs_remove_dir(struct kobject * kobj)
{
	struct dentry * dentry = dget(kobj->dentry);
	struct sysfs_dirent * parent_sd;
	struct sysfs_dirent * sd, * tmp;

	if (!dentry)
		return;

	pr_debug("sysfs %s: removing dir\n",dentry->d_name.name);
	mutex_lock(&dentry->d_inode->i_mutex);
	parent_sd = dentry->d_fsdata;
	list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
		if (!sd->s_element || !(sd->s_type & SYSFS_NOT_PINNED))
			continue;
		list_del_init(&sd->s_sibling);
		sysfs_drop_dentry(sd, dentry);
		sysfs_put(sd);
	}
	mutex_unlock(&dentry->d_inode->i_mutex);

	remove_dir(dentry);
	/**
	 * Drop reference from dget() on entrance.
	 */
	dput(dentry);
	kobj->dentry = NULL;
}

int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
{
	int error = 0;
	struct dentry * new_dentry, * parent;

	if (!strcmp(kobject_name(kobj), new_name))
		return -EINVAL;

	if (!kobj->parent)
		return -EINVAL;

	down_write(&sysfs_rename_sem);
	parent = kobj->parent->dentry;

	mutex_lock(&parent->d_inode->i_mutex);

	new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
	if (!IS_ERR(new_dentry)) {
  		if (!new_dentry->d_inode) {
			error = kobject_set_name(kobj, "%s", new_name);
			if (!error) {
				d_add(new_dentry, NULL);
				d_move(kobj->dentry, new_dentry);
			}
			else
				d_drop(new_dentry);
		} else
			error = -EEXIST;
		dput(new_dentry);
	}
	mutex_unlock(&parent->d_inode->i_mutex);
	up_write(&sysfs_rename_sem);

	return error;
}

int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
{
	struct dentry *old_parent_dentry, *new_parent_dentry, *new_dentry;
	struct sysfs_dirent *new_parent_sd, *sd;
	int error;

	old_parent_dentry = kobj->parent ?
		kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
	new_parent_dentry = new_parent ?
		new_parent->dentry : sysfs_mount->mnt_sb->s_root;

again:
	mutex_lock(&old_parent_dentry->d_inode->i_mutex);
	if (!mutex_trylock(&new_parent_dentry->d_inode->i_mutex)) {
		mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
		goto again;
	}

	new_parent_sd = new_parent_dentry->d_fsdata;
	sd = kobj->dentry->d_fsdata;

	new_dentry = lookup_one_len(kobj->name, new_parent_dentry,
				    strlen(kobj->name));
	if (IS_ERR(new_dentry)) {
		error = PTR_ERR(new_dentry);
		goto out;
	} else
		error = 0;
	d_add(new_dentry, NULL);
	d_move(kobj->dentry, new_dentry);
	dput(new_dentry);

	/* Remove from old parent's list and insert into new parent's list. */
	list_del_init(&sd->s_sibling);
	list_add(&sd->s_sibling, &new_parent_sd->s_children);

out:
	mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
	mutex_unlock(&old_parent_dentry->d_inode->i_mutex);

	return error;
}

static int sysfs_dir_open(struct inode *inode, struct file *file)
{
	struct dentry * dentry = file->f_path.dentry;
	struct sysfs_dirent * parent_sd = dentry->d_fsdata;

	mutex_lock(&dentry->d_inode->i_mutex);
	file->private_data = sysfs_new_dirent(parent_sd, NULL);
	mutex_unlock(&dentry->d_inode->i_mutex);

	return file->private_data ? 0 : -ENOMEM;

}

static int sysfs_dir_close(struct inode *inode, struct file *file)
{
	struct dentry * dentry = file->f_path.dentry;
	struct sysfs_dirent * cursor = file->private_data;

	mutex_lock(&dentry->d_inode->i_mutex);
	list_del_init(&cursor->s_sibling);
	mutex_unlock(&dentry->d_inode->i_mutex);

	release_sysfs_dirent(cursor);

	return 0;
}

/* Relationship between s_mode and the DT_xxx types */
static inline unsigned char dt_type(struct sysfs_dirent *sd)
{
	return (sd->s_mode >> 12) & 15;
}

static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
	struct dentry *dentry = filp->f_path.dentry;
	struct sysfs_dirent * parent_sd = dentry->d_fsdata;
	struct sysfs_dirent *cursor = filp->private_data;
	struct list_head *p, *q = &cursor->s_sibling;
	ino_t ino;
	int i = filp->f_pos;

	switch (i) {
		case 0:
			ino = dentry->d_inode->i_ino;
			if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
				break;
			filp->f_pos++;
			i++;
			/* fallthrough */
		case 1:
			ino = parent_ino(dentry);
			if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
				break;
			filp->f_pos++;
			i++;
			/* fallthrough */
		default:
			if (filp->f_pos == 2)
				list_move(q, &parent_sd->s_children);

			for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
				struct sysfs_dirent *next;
				const char * name;
				int len;

				next = list_entry(p, struct sysfs_dirent,
						   s_sibling);
				if (!next->s_element)
					continue;

				name = sysfs_get_name(next);
				len = strlen(name);
				if (next->s_dentry)
					ino = next->s_dentry->d_inode->i_ino;
				else
					ino = iunique(sysfs_sb, 2);

				if (filldir(dirent, name, len, filp->f_pos, ino,
						 dt_type(next)) < 0)
					return 0;

				list_move(q, p);
				p = q;
				filp->f_pos++;
			}
	}
	return 0;
}

static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
{
	struct dentry * dentry = file->f_path.dentry;

	mutex_lock(&dentry->d_inode->i_mutex);
	switch (origin) {
		case 1:
			offset += file->f_pos;
		case 0:
			if (offset >= 0)
				break;
		default:
			mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
			return -EINVAL;
	}
	if (offset != file->f_pos) {
		file->f_pos = offset;
		if (file->f_pos >= 2) {
			struct sysfs_dirent *sd = dentry->d_fsdata;
			struct sysfs_dirent *cursor = file->private_data;
			struct list_head *p;
			loff_t n = file->f_pos - 2;

			list_del(&cursor->s_sibling);
			p = sd->s_children.next;
			while (n && p != &sd->s_children) {
				struct sysfs_dirent *next;
				next = list_entry(p, struct sysfs_dirent,
						   s_sibling);
				if (next->s_element)
					n--;
				p = p->next;
			}
			list_add_tail(&cursor->s_sibling, p);
		}
	}
	mutex_unlock(&dentry->d_inode->i_mutex);
	return offset;
}

const struct file_operations sysfs_dir_operations = {
	.open		= sysfs_dir_open,
	.release	= sysfs_dir_close,
	.llseek		= sysfs_dir_lseek,
	.read		= generic_read_dir,
	.readdir	= sysfs_readdir,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* dir.c - Operations for sysfs directories.
	3	*/
	4
	5	#undef DEBUG
	6
	7	#include <linux/fs.h>
	8	#include <linux/mount.h>
	9	#include <linux/module.h>
	10	#include <linux/kobject.h>
5f45f1a7	11	#include <linux/namei.h>
94bebf4d	12	#include <asm/semaphore.h>
1da177e4 LT	13	#include "sysfs.h"
	14
	15	DECLARE_RWSEM(sysfs_rename_sem);
	16
	17	static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
	18	{
	19	struct sysfs_dirent * sd = dentry->d_fsdata;
	20
	21	if (sd) {
	22	BUG_ON(sd->s_dentry != dentry);
	23	sd->s_dentry = NULL;
	24	sysfs_put(sd);
	25	}
	26	iput(inode);
	27	}
	28
	29	static struct dentry_operations sysfs_dentry_ops = {
	30	.d_iput = sysfs_d_iput,
	31	};
	32
	33	/*
	34	* Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
	35	*/
	36	static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent * parent_sd,
	37	void * element)
	38	{
	39	struct sysfs_dirent * sd;
	40
	41	sd = kmem_cache_alloc(sysfs_dir_cachep, GFP_KERNEL);
	42	if (!sd)
	43	return NULL;
	44
	45	memset(sd, 0, sizeof(*sd));
	46	atomic_set(&sd->s_count, 1);
eea3f891	47	atomic_set(&sd->s_event, 1);
1da177e4 LT	48	INIT_LIST_HEAD(&sd->s_children);
	49	list_add(&sd->s_sibling, &parent_sd->s_children);
	50	sd->s_element = element;
	51
	52	return sd;
	53	}
	54
a580290c	55	/*
c516865c MS	56	*
	57	* Return -EEXIST if there is already a sysfs element with the same name for
	58	* the same parent.
	59	*
	60	* called with parent inode's i_mutex held
	61	*/
	62	int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
	63	const unsigned char *new)
	64	{
	65	struct sysfs_dirent * sd;
	66
	67	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
	68	if (sd->s_element) {
	69	const unsigned char *existing = sysfs_get_name(sd);
	70	if (strcmp(existing, new))
	71	continue;
	72	else
	73	return -EEXIST;
	74	}
	75	}
	76
	77	return 0;
	78	}
	79
	80
1da177e4 LT	81	int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
	82	void * element, umode_t mode, int type)
	83	{
	84	struct sysfs_dirent * sd;
	85
	86	sd = sysfs_new_dirent(parent_sd, element);
	87	if (!sd)
	88	return -ENOMEM;
	89
	90	sd->s_mode = mode;
	91	sd->s_type = type;
	92	sd->s_dentry = dentry;
	93	if (dentry) {
	94	dentry->d_fsdata = sysfs_get(sd);
	95	dentry->d_op = &sysfs_dentry_ops;
	96	}
	97
	98	return 0;
	99	}
	100
	101	static int init_dir(struct inode * inode)
	102	{
	103	inode->i_op = &sysfs_dir_inode_operations;
	104	inode->i_fop = &sysfs_dir_operations;
	105
	106	/* directory inodes start off with i_nlink == 2 (for "." entry) */
d8c76e6f	107	inc_nlink(inode);
1da177e4 LT	108	return 0;
	109	}
	110
	111	static int init_file(struct inode * inode)
	112	{
	113	inode->i_size = PAGE_SIZE;
	114	inode->i_fop = &sysfs_file_operations;
	115	return 0;
	116	}
	117
	118	static int init_symlink(struct inode * inode)
	119	{
	120	inode->i_op = &sysfs_symlink_inode_operations;
	121	return 0;
	122	}
	123
	124	static int create_dir(struct kobject * k, struct dentry * p,
	125	const char * n, struct dentry ** d)
	126	{
	127	int error;
	128	umode_t mode = S_IFDIR\| S_IRWXU \| S_IRUGO \| S_IXUGO;
	129
1b1dcc1b	130	mutex_lock(&p->d_inode->i_mutex);
5f45f1a7	131	*d = lookup_one_len(n, p, strlen(n));
1da177e4	132	if (!IS_ERR(*d)) {
c516865c MS	133	if (sysfs_dirent_exist(p->d_fsdata, n))
	134	error = -EEXIST;
	135	else
	136	error = sysfs_make_dirent(p->d_fsdata, *d, k, mode,
	137	SYSFS_DIR);
1da177e4	138	if (!error) {
6fa5c828	139	error = sysfs_create(*d, mode, init_dir);
1da177e4	140	if (!error) {
d8c76e6f	141	inc_nlink(p->d_inode);
1da177e4 LT	142	(*d)->d_op = &sysfs_dentry_ops;
	143	d_rehash(*d);
	144	}
	145	}
6fa5c828	146	if (error && (error != -EEXIST)) {
e80a5dea SR	147	struct sysfs_dirent sd = (d)->d_fsdata;
	148	if (sd) {
	149	list_del_init(&sd->s_sibling);
	150	sysfs_put(sd);
	151	}
1da177e4	152	d_drop(*d);
6fa5c828	153	}
1da177e4 LT	154	dput(*d);
	155	} else
	156	error = PTR_ERR(*d);
1b1dcc1b	157	mutex_unlock(&p->d_inode->i_mutex);
1da177e4 LT	158	return error;
	159	}
	160
	161
	162	int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
	163	{
	164	return create_dir(k,k->dentry,n,d);
	165	}
	166
	167	/**
	168	* sysfs_create_dir - create a directory for an object.
	169	* @parent: parent parent object.
	170	* @kobj: object we're creating directory for.
	171	*/
	172
	173	int sysfs_create_dir(struct kobject * kobj)
	174	{
	175	struct dentry * dentry = NULL;
	176	struct dentry * parent;
	177	int error = 0;
	178
	179	BUG_ON(!kobj);
	180
	181	if (kobj->parent)
	182	parent = kobj->parent->dentry;
	183	else if (sysfs_mount && sysfs_mount->mnt_sb)
	184	parent = sysfs_mount->mnt_sb->s_root;
	185	else
	186	return -EFAULT;
	187
	188	error = create_dir(kobj,parent,kobject_name(kobj),&dentry);
	189	if (!error)
	190	kobj->dentry = dentry;
	191	return error;
	192	}
	193
	194	/* attaches attribute's sysfs_dirent to the dentry corresponding to the
	195	* attribute file
	196	*/
	197	static int sysfs_attach_attr(struct sysfs_dirent * sd, struct dentry * dentry)
	198	{
	199	struct attribute * attr = NULL;
	200	struct bin_attribute * bin_attr = NULL;
	201	int (* init) (struct inode *) = NULL;
	202	int error = 0;
	203
	204	if (sd->s_type & SYSFS_KOBJ_BIN_ATTR) {
	205	bin_attr = sd->s_element;
	206	attr = &bin_attr->attr;
	207	} else {
	208	attr = sd->s_element;
	209	init = init_file;
	210	}
	211
6fa5c828 MS	212	dentry->d_fsdata = sysfs_get(sd);
6fa5c828 MS	213	sd->s_dentry = dentry;
1da177e4	214	error = sysfs_create(dentry, (attr->mode & S_IALLUGO) \| S_IFREG, init);
6fa5c828 MS	215	if (error) {
6fa5c828 MS	216	sysfs_put(sd);
1da177e4	217	return error;
6fa5c828	218	}
1da177e4 LT	219
	220	if (bin_attr) {
	221	dentry->d_inode->i_size = bin_attr->size;
	222	dentry->d_inode->i_fop = &bin_fops;
	223	}
	224	dentry->d_op = &sysfs_dentry_ops;
1da177e4 LT	225	d_rehash(dentry);
	226
	227	return 0;
	228	}
	229
	230	static int sysfs_attach_link(struct sysfs_dirent * sd, struct dentry * dentry)
	231	{
	232	int err = 0;
	233
6fa5c828 MS	234	dentry->d_fsdata = sysfs_get(sd);
6fa5c828 MS	235	sd->s_dentry = dentry;
1da177e4 LT	236	err = sysfs_create(dentry, S_IFLNK\|S_IRWXUGO, init_symlink);
	237	if (!err) {
	238	dentry->d_op = &sysfs_dentry_ops;
1da177e4	239	d_rehash(dentry);
6fa5c828 MS	240	} else
	241	sysfs_put(sd);
	242
1da177e4 LT	243	return err;
	244	}
	245
	246	static struct dentry * sysfs_lookup(struct inode dir, struct dentry dentry,
	247	struct nameidata *nd)
	248	{
	249	struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
	250	struct sysfs_dirent * sd;
	251	int err = 0;
	252
	253	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
	254	if (sd->s_type & SYSFS_NOT_PINNED) {
	255	const unsigned char * name = sysfs_get_name(sd);
	256
	257	if (strcmp(name, dentry->d_name.name))
	258	continue;
	259
	260	if (sd->s_type & SYSFS_KOBJ_LINK)
	261	err = sysfs_attach_link(sd, dentry);
	262	else
	263	err = sysfs_attach_attr(sd, dentry);
	264	break;
	265	}
	266	}
	267
	268	return ERR_PTR(err);
	269	}
	270
	271	struct inode_operations sysfs_dir_inode_operations = {
	272	.lookup = sysfs_lookup,
988d186d	273	.setattr = sysfs_setattr,
1da177e4 LT	274	};
	275
	276	static void remove_dir(struct dentry * d)
	277	{
	278	struct dentry * parent = dget(d->d_parent);
	279	struct sysfs_dirent * sd;
	280
1b1dcc1b	281	mutex_lock(&parent->d_inode->i_mutex);
1da177e4 LT	282	d_delete(d);
	283	sd = d->d_fsdata;
	284	list_del_init(&sd->s_sibling);
	285	sysfs_put(sd);
	286	if (d->d_inode)
	287	simple_rmdir(parent->d_inode,d);
	288
	289	pr_debug(" o %s removing done (%d)\n",d->d_name.name,
	290	atomic_read(&d->d_count));
	291
1b1dcc1b	292	mutex_unlock(&parent->d_inode->i_mutex);
1da177e4 LT	293	dput(parent);
	294	}
	295
	296	void sysfs_remove_subdir(struct dentry * d)
	297	{
	298	remove_dir(d);
	299	}
	300
	301
	302	/**
	303	* sysfs_remove_dir - remove an object's directory.
	304	* @kobj: object.
	305	*
	306	* The only thing special about this is that we remove any files in
	307	* the directory before we remove the directory, and we've inlined
	308	* what used to be sysfs_rmdir() below, instead of calling separately.
	309	*/
	310
	311	void sysfs_remove_dir(struct kobject * kobj)
	312	{
	313	struct dentry * dentry = dget(kobj->dentry);
	314	struct sysfs_dirent * parent_sd;
	315	struct sysfs_dirent * sd, * tmp;
	316
	317	if (!dentry)
	318	return;
	319
	320	pr_debug("sysfs %s: removing dir\n",dentry->d_name.name);
1b1dcc1b	321	mutex_lock(&dentry->d_inode->i_mutex);
1da177e4 LT	322	parent_sd = dentry->d_fsdata;
	323	list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
	324	if (!sd->s_element \|\| !(sd->s_type & SYSFS_NOT_PINNED))
	325	continue;
	326	list_del_init(&sd->s_sibling);
	327	sysfs_drop_dentry(sd, dentry);
	328	sysfs_put(sd);
	329	}
1b1dcc1b	330	mutex_unlock(&dentry->d_inode->i_mutex);
1da177e4 LT	331
	332	remove_dir(dentry);
	333	/**
	334	* Drop reference from dget() on entrance.
	335	*/
	336	dput(dentry);
641e6f30	337	kobj->dentry = NULL;
1da177e4 LT	338	}
	339
	340	int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
	341	{
	342	int error = 0;
	343	struct dentry * new_dentry, * parent;
	344
	345	if (!strcmp(kobject_name(kobj), new_name))
	346	return -EINVAL;
	347
	348	if (!kobj->parent)
	349	return -EINVAL;
	350
	351	down_write(&sysfs_rename_sem);
	352	parent = kobj->parent->dentry;
	353
1b1dcc1b	354	mutex_lock(&parent->d_inode->i_mutex);
1da177e4	355
5f45f1a7	356	new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
1da177e4 LT	357	if (!IS_ERR(new_dentry)) {
	358	if (!new_dentry->d_inode) {
	359	error = kobject_set_name(kobj, "%s", new_name);
	360	if (!error) {
	361	d_add(new_dentry, NULL);
	362	d_move(kobj->dentry, new_dentry);
	363	}
	364	else
	365	d_drop(new_dentry);
	366	} else
	367	error = -EEXIST;
	368	dput(new_dentry);
	369	}
1b1dcc1b	370	mutex_unlock(&parent->d_inode->i_mutex);
1da177e4 LT	371	up_write(&sysfs_rename_sem);
	372
	373	return error;
	374	}
	375
8a82472f CH	376	int sysfs_move_dir(struct kobject kobj, struct kobject new_parent)
	377	{
	378	struct dentry old_parent_dentry, new_parent_dentry, *new_dentry;
	379	struct sysfs_dirent new_parent_sd, sd;
	380	int error;
	381
8a82472f CH	382	old_parent_dentry = kobj->parent ?
8a82472f CH	383	kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
c744aeae CH	384	new_parent_dentry = new_parent ?
c744aeae CH	385	new_parent->dentry : sysfs_mount->mnt_sb->s_root;
8a82472f CH	386
	387	again:
	388	mutex_lock(&old_parent_dentry->d_inode->i_mutex);
	389	if (!mutex_trylock(&new_parent_dentry->d_inode->i_mutex)) {
	390	mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
	391	goto again;
	392	}
	393
	394	new_parent_sd = new_parent_dentry->d_fsdata;
	395	sd = kobj->dentry->d_fsdata;
	396
	397	new_dentry = lookup_one_len(kobj->name, new_parent_dentry,
	398	strlen(kobj->name));
	399	if (IS_ERR(new_dentry)) {
	400	error = PTR_ERR(new_dentry);
	401	goto out;
	402	} else
	403	error = 0;
	404	d_add(new_dentry, NULL);
	405	d_move(kobj->dentry, new_dentry);
	406	dput(new_dentry);
	407
	408	/* Remove from old parent's list and insert into new parent's list. */
	409	list_del_init(&sd->s_sibling);
	410	list_add(&sd->s_sibling, &new_parent_sd->s_children);
	411
	412	out:
	413	mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
	414	mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
	415
	416	return error;
	417	}
	418
1da177e4 LT	419	static int sysfs_dir_open(struct inode inode, struct file file)
1da177e4 LT	420	{
f427f5d5	421	struct dentry * dentry = file->f_path.dentry;
1da177e4 LT	422	struct sysfs_dirent * parent_sd = dentry->d_fsdata;
1da177e4 LT	423
1b1dcc1b	424	mutex_lock(&dentry->d_inode->i_mutex);
1da177e4	425	file->private_data = sysfs_new_dirent(parent_sd, NULL);
1b1dcc1b	426	mutex_unlock(&dentry->d_inode->i_mutex);
1da177e4 LT	427
	428	return file->private_data ? 0 : -ENOMEM;
	429
	430	}
	431
	432	static int sysfs_dir_close(struct inode inode, struct file file)
	433	{
f427f5d5	434	struct dentry * dentry = file->f_path.dentry;
1da177e4 LT	435	struct sysfs_dirent * cursor = file->private_data;
1da177e4 LT	436
1b1dcc1b	437	mutex_lock(&dentry->d_inode->i_mutex);
1da177e4	438	list_del_init(&cursor->s_sibling);
1b1dcc1b	439	mutex_unlock(&dentry->d_inode->i_mutex);
1da177e4 LT	440
	441	release_sysfs_dirent(cursor);
	442
	443	return 0;
	444	}
	445
	446	/* Relationship between s_mode and the DT_xxx types */
	447	static inline unsigned char dt_type(struct sysfs_dirent *sd)
	448	{
	449	return (sd->s_mode >> 12) & 15;
	450	}
	451
	452	static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
	453	{
f427f5d5	454	struct dentry *dentry = filp->f_path.dentry;
1da177e4 LT	455	struct sysfs_dirent * parent_sd = dentry->d_fsdata;
	456	struct sysfs_dirent *cursor = filp->private_data;
	457	struct list_head p, q = &cursor->s_sibling;
	458	ino_t ino;
	459	int i = filp->f_pos;
	460
	461	switch (i) {
	462	case 0:
	463	ino = dentry->d_inode->i_ino;
	464	if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
	465	break;
	466	filp->f_pos++;
	467	i++;
	468	/* fallthrough */
	469	case 1:
	470	ino = parent_ino(dentry);
	471	if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
	472	break;
	473	filp->f_pos++;
	474	i++;
	475	/* fallthrough */
	476	default:
1bfba4e8 AM	477	if (filp->f_pos == 2)
	478	list_move(q, &parent_sd->s_children);
	479
1da177e4 LT	480	for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
	481	struct sysfs_dirent *next;
	482	const char * name;
	483	int len;
	484
	485	next = list_entry(p, struct sysfs_dirent,
	486	s_sibling);
	487	if (!next->s_element)
	488	continue;
	489
	490	name = sysfs_get_name(next);
	491	len = strlen(name);
	492	if (next->s_dentry)
	493	ino = next->s_dentry->d_inode->i_ino;
	494	else
	495	ino = iunique(sysfs_sb, 2);
	496
	497	if (filldir(dirent, name, len, filp->f_pos, ino,
	498	dt_type(next)) < 0)
	499	return 0;
	500
1bfba4e8	501	list_move(q, p);
1da177e4 LT	502	p = q;
	503	filp->f_pos++;
	504	}
	505	}
	506	return 0;
	507	}
	508
	509	static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
	510	{
f427f5d5	511	struct dentry * dentry = file->f_path.dentry;
1da177e4	512
1b1dcc1b	513	mutex_lock(&dentry->d_inode->i_mutex);
1da177e4 LT	514	switch (origin) {
	515	case 1:
	516	offset += file->f_pos;
	517	case 0:
	518	if (offset >= 0)
	519	break;
	520	default:
f427f5d5	521	mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
1da177e4 LT	522	return -EINVAL;
	523	}
	524	if (offset != file->f_pos) {
	525	file->f_pos = offset;
	526	if (file->f_pos >= 2) {
	527	struct sysfs_dirent *sd = dentry->d_fsdata;
	528	struct sysfs_dirent *cursor = file->private_data;
	529	struct list_head *p;
	530	loff_t n = file->f_pos - 2;
	531
	532	list_del(&cursor->s_sibling);
	533	p = sd->s_children.next;
	534	while (n && p != &sd->s_children) {
	535	struct sysfs_dirent *next;
	536	next = list_entry(p, struct sysfs_dirent,
	537	s_sibling);
	538	if (next->s_element)
	539	n--;
	540	p = p->next;
	541	}
	542	list_add_tail(&cursor->s_sibling, p);
	543	}
	544	}
1b1dcc1b	545	mutex_unlock(&dentry->d_inode->i_mutex);
1da177e4 LT	546	return offset;
	547	}
	548
4b6f5d20	549	const struct file_operations sysfs_dir_operations = {
1da177e4 LT	550	.open = sysfs_dir_open,
	551	.release = sysfs_dir_close,
	552	.llseek = sysfs_dir_lseek,
	553	.read = generic_read_dir,
	554	.readdir = sysfs_readdir,
	555	};