[deliverable/linux.git] / fs / sysfs / symlink.c

/*
 * symlink.c - operations for sysfs symlinks.
 */

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/kobject.h>
#include <linux/namei.h>

#include "sysfs.h"

static int object_depth(struct kobject * kobj)
{
	struct kobject * p = kobj;
	int depth = 0;
	do { depth++; } while ((p = p->parent));
	return depth;
}

static int object_path_length(struct kobject * kobj)
{
	struct kobject * p = kobj;
	int length = 1;
	do {
		length += strlen(kobject_name(p)) + 1;
		p = p->parent;
	} while (p);
	return length;
}

static void fill_object_path(struct kobject * kobj, char * buffer, int length)
{
	struct kobject * p;

	--length;
	for (p = kobj; p; p = p->parent) {
		int cur = strlen(kobject_name(p));

		/* back up enough to print this bus id with '/' */
		length -= cur;
		strncpy(buffer + length,kobject_name(p),cur);
		*(buffer + --length) = '/';
	}
}

static int sysfs_add_link(struct dentry * parent, const char * name, struct kobject * target)
{
	struct sysfs_dirent * parent_sd = parent->d_fsdata;
	struct sysfs_symlink * sl;
	int error = 0;

	error = -ENOMEM;
	sl = kmalloc(sizeof(*sl), GFP_KERNEL);
	if (!sl)
		goto exit1;

	sl->link_name = kmalloc(strlen(name) + 1, GFP_KERNEL);
	if (!sl->link_name)
		goto exit2;

	strcpy(sl->link_name, name);
	sl->target_kobj = kobject_get(target);

	error = sysfs_make_dirent(parent_sd, NULL, sl, S_IFLNK|S_IRWXUGO,
				SYSFS_KOBJ_LINK);
	if (!error)
		return 0;

	kobject_put(target);
	kfree(sl->link_name);
exit2:
	kfree(sl);
exit1:
	return error;
}

/**
 *	sysfs_create_link - create symlink between two objects.
 *	@kobj:	object whose directory we're creating the link in.
 *	@target:	object we're pointing to.
 *	@name:		name of the symlink.
 */
int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char * name)
{
	struct dentry * dentry = kobj->dentry;
	int error = -EEXIST;

	BUG_ON(!kobj || !kobj->dentry || !name);

	mutex_lock(&dentry->d_inode->i_mutex);
	if (!sysfs_dirent_exist(dentry->d_fsdata, name))
		error = sysfs_add_link(dentry, name, target);
	mutex_unlock(&dentry->d_inode->i_mutex);
	return error;
}


/**
 *	sysfs_remove_link - remove symlink in object's directory.
 *	@kobj:	object we're acting for.
 *	@name:	name of the symlink to remove.
 */

void sysfs_remove_link(struct kobject * kobj, const char * name)
{
	sysfs_hash_and_remove(kobj->dentry,name);
}

static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target,
				 char *path)
{
	char * s;
	int depth, size;

	depth = object_depth(kobj);
	size = object_path_length(target) + depth * 3 - 1;
	if (size > PATH_MAX)
		return -ENAMETOOLONG;

	pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size);

	for (s = path; depth--; s += 3)
		strcpy(s,"../");

	fill_object_path(target, path, size);
	pr_debug("%s: path = '%s'\n", __FUNCTION__, path);

	return 0;
}

static int sysfs_getlink(struct dentry *dentry, char * path)
{
	struct kobject *kobj, *target_kobj;
	int error = 0;

	kobj = sysfs_get_kobject(dentry->d_parent);
	if (!kobj)
		return -EINVAL;

	target_kobj = sysfs_get_kobject(dentry);
	if (!target_kobj) {
		kobject_put(kobj);
		return -EINVAL;
	}

	down_read(&sysfs_rename_sem);
	error = sysfs_get_target_path(kobj, target_kobj, path);
	up_read(&sysfs_rename_sem);
	
	kobject_put(kobj);
	kobject_put(target_kobj);
	return error;

}

static void *sysfs_follow_link(struct dentry *dentry, struct nameidata *nd)
{
	int error = -ENOMEM;
	unsigned long page = get_zeroed_page(GFP_KERNEL);
	if (page)
		error = sysfs_getlink(dentry, (char *) page); 
	nd_set_link(nd, error ? ERR_PTR(error) : (char *)page);
	return NULL;
}

static void sysfs_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
{
	char *page = nd_get_link(nd);
	if (!IS_ERR(page))
		free_page((unsigned long)page);
}

struct inode_operations sysfs_symlink_inode_operations = {
	.readlink = generic_readlink,
	.follow_link = sysfs_follow_link,
	.put_link = sysfs_put_link,
};


EXPORT_SYMBOL_GPL(sysfs_create_link);
EXPORT_SYMBOL_GPL(sysfs_remove_link);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* symlink.c - operations for sysfs symlinks.
	3	*/
	4
	5	#include <linux/fs.h>
	6	#include <linux/module.h>
	7	#include <linux/kobject.h>
	8	#include <linux/namei.h>
	9
	10	#include "sysfs.h"
	11
	12	static int object_depth(struct kobject * kobj)
	13	{
	14	struct kobject * p = kobj;
	15	int depth = 0;
	16	do { depth++; } while ((p = p->parent));
	17	return depth;
	18	}
	19
	20	static int object_path_length(struct kobject * kobj)
	21	{
	22	struct kobject * p = kobj;
	23	int length = 1;
	24	do {
	25	length += strlen(kobject_name(p)) + 1;
	26	p = p->parent;
	27	} while (p);
	28	return length;
	29	}
	30
	31	static void fill_object_path(struct kobject * kobj, char * buffer, int length)
	32	{
	33	struct kobject * p;
	34
	35	--length;
	36	for (p = kobj; p; p = p->parent) {
	37	int cur = strlen(kobject_name(p));
	38
	39	/* back up enough to print this bus id with '/' */
	40	length -= cur;
	41	strncpy(buffer + length,kobject_name(p),cur);
	42	*(buffer + --length) = '/';
	43	}
	44	}
	45
e3a15db2	46	static int sysfs_add_link(struct dentry * parent, const char * name, struct kobject * target)
1da177e4 LT	47	{
	48	struct sysfs_dirent * parent_sd = parent->d_fsdata;
	49	struct sysfs_symlink * sl;
	50	int error = 0;
	51
	52	error = -ENOMEM;
	53	sl = kmalloc(sizeof(*sl), GFP_KERNEL);
	54	if (!sl)
	55	goto exit1;
	56
	57	sl->link_name = kmalloc(strlen(name) + 1, GFP_KERNEL);
	58	if (!sl->link_name)
	59	goto exit2;
	60
	61	strcpy(sl->link_name, name);
	62	sl->target_kobj = kobject_get(target);
	63
	64	error = sysfs_make_dirent(parent_sd, NULL, sl, S_IFLNK\|S_IRWXUGO,
	65	SYSFS_KOBJ_LINK);
	66	if (!error)
	67	return 0;
	68
b3229087	69	kobject_put(target);
1da177e4 LT	70	kfree(sl->link_name);
	71	exit2:
	72	kfree(sl);
	73	exit1:
	74	return error;
	75	}
	76
	77	/**
	78	* sysfs_create_link - create symlink between two objects.
	79	* @kobj: object whose directory we're creating the link in.
	80	* @target: object we're pointing to.
	81	* @name: name of the symlink.
	82	*/
e3a15db2	83	int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char * name)
1da177e4 LT	84	{
1da177e4 LT	85	struct dentry * dentry = kobj->dentry;
c516865c	86	int error = -EEXIST;
1da177e4 LT	87
	88	BUG_ON(!kobj \|\| !kobj->dentry \|\| !name);
	89
1b1dcc1b	90	mutex_lock(&dentry->d_inode->i_mutex);
c516865c MS	91	if (!sysfs_dirent_exist(dentry->d_fsdata, name))
c516865c MS	92	error = sysfs_add_link(dentry, name, target);
1b1dcc1b	93	mutex_unlock(&dentry->d_inode->i_mutex);
1da177e4 LT	94	return error;
	95	}
	96
	97
	98	/**
	99	* sysfs_remove_link - remove symlink in object's directory.
	100	* @kobj: object we're acting for.
	101	* @name: name of the symlink to remove.
	102	*/
	103
e3a15db2	104	void sysfs_remove_link(struct kobject * kobj, const char * name)
1da177e4 LT	105	{
	106	sysfs_hash_and_remove(kobj->dentry,name);
	107	}
	108
	109	static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target,
e3a15db2	110	char *path)
1da177e4 LT	111	{
	112	char * s;
	113	int depth, size;
	114
	115	depth = object_depth(kobj);
	116	size = object_path_length(target) + depth * 3 - 1;
	117	if (size > PATH_MAX)
	118	return -ENAMETOOLONG;
	119
	120	pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size);
	121
	122	for (s = path; depth--; s += 3)
	123	strcpy(s,"../");
	124
	125	fill_object_path(target, path, size);
	126	pr_debug("%s: path = '%s'\n", __FUNCTION__, path);
	127
	128	return 0;
	129	}
	130
	131	static int sysfs_getlink(struct dentry dentry, char path)
	132	{
	133	struct kobject kobj, target_kobj;
	134	int error = 0;
	135
	136	kobj = sysfs_get_kobject(dentry->d_parent);
	137	if (!kobj)
	138	return -EINVAL;
	139
	140	target_kobj = sysfs_get_kobject(dentry);
	141	if (!target_kobj) {
	142	kobject_put(kobj);
	143	return -EINVAL;
	144	}
	145
	146	down_read(&sysfs_rename_sem);
	147	error = sysfs_get_target_path(kobj, target_kobj, path);
	148	up_read(&sysfs_rename_sem);
	149
	150	kobject_put(kobj);
	151	kobject_put(target_kobj);
	152	return error;
	153
	154	}
	155
cc314eef	156	static void sysfs_follow_link(struct dentry dentry, struct nameidata *nd)
1da177e4 LT	157	{
	158	int error = -ENOMEM;
	159	unsigned long page = get_zeroed_page(GFP_KERNEL);
	160	if (page)
	161	error = sysfs_getlink(dentry, (char *) page);
	162	nd_set_link(nd, error ? ERR_PTR(error) : (char *)page);
cc314eef	163	return NULL;
1da177e4 LT	164	}
1da177e4 LT	165
cc314eef	166	static void sysfs_put_link(struct dentry dentry, struct nameidata nd, void *cookie)
1da177e4 LT	167	{
	168	char *page = nd_get_link(nd);
	169	if (!IS_ERR(page))
	170	free_page((unsigned long)page);
	171	}
	172
	173	struct inode_operations sysfs_symlink_inode_operations = {
	174	.readlink = generic_readlink,
	175	.follow_link = sysfs_follow_link,
	176	.put_link = sysfs_put_link,
	177	};
	178
	179
	180	EXPORT_SYMBOL_GPL(sysfs_create_link);
	181	EXPORT_SYMBOL_GPL(sysfs_remove_link);