X-Git-Url: http://ftp.safe.ca/?a=blobdiff_plain;f=fs%2Fsysfs%2Fsymlink.c;h=1b9a3a1e8a17a1e3951980b3b4179d06a2b0a916;hb=7cb32942d91a501b2df944928ccc9e6590ab237b;hp=d96bb9cbc9d41dbac53ffc7a0541cde4866ac2c0;hpb=a26cd7226c24c3be5dd5f48a74832fe64beb8489;p=safe%2Fjmp%2Flinux-2.6 diff --git a/fs/sysfs/symlink.c b/fs/sysfs/symlink.c index d96bb9c..1b9a3a1 100644 --- a/fs/sysfs/symlink.c +++ b/fs/sysfs/symlink.c @@ -1,5 +1,13 @@ /* - * symlink.c - operations for sysfs symlinks. + * fs/sysfs/symlink.c - sysfs symlink implementation + * + * Copyright (c) 2001-3 Patrick Mochel + * Copyright (c) 2007 SUSE Linux Products GmbH + * Copyright (c) 2007 Tejun Heo + * + * This file is released under the GPLv2. + * + * Please see Documentation/filesystems/sysfs.txt for more information. */ #include @@ -7,76 +15,66 @@ #include #include #include -#include +#include +#include #include "sysfs.h" -static int object_depth(struct kobject * kobj) +static int sysfs_do_create_link(struct kobject *kobj, struct kobject *target, + const char *name, int warn) { - 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)); + struct sysfs_dirent *parent_sd = NULL; + struct sysfs_dirent *target_sd = NULL; + struct sysfs_dirent *sd = NULL; + struct sysfs_addrm_cxt acxt; + int error; - /* back up enough to print this bus id with '/' */ - length -= cur; - strncpy(buffer + length,kobject_name(p),cur); - *(buffer + --length) = '/'; - } -} + BUG_ON(!name); -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; - struct sysfs_dirent * sd; - int error; + if (!kobj) + parent_sd = &sysfs_root; + else + parent_sd = kobj->sd; + + error = -EFAULT; + if (!parent_sd) + goto out_put; + + /* target->sd can go away beneath us but is protected with + * sysfs_assoc_lock. Fetch target_sd from it. + */ + spin_lock(&sysfs_assoc_lock); + if (target->sd) + target_sd = sysfs_get(target->sd); + spin_unlock(&sysfs_assoc_lock); + + error = -ENOENT; + if (!target_sd) + goto out_put; error = -ENOMEM; - sl = kzalloc(sizeof(*sl), GFP_KERNEL); - if (!sl) - goto err_out; + sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK); + if (!sd) + goto out_put; - sl->link_name = kmalloc(strlen(name) + 1, GFP_KERNEL); - if (!sl->link_name) - goto err_out; + sd->s_symlink.target_sd = target_sd; + target_sd = NULL; /* reference is now owned by the symlink */ - strcpy(sl->link_name, name); - sl->target_kobj = kobject_get(target); + sysfs_addrm_start(&acxt, parent_sd); + if (warn) + error = sysfs_add_one(&acxt, sd); + else + error = __sysfs_add_one(&acxt, sd); + sysfs_addrm_finish(&acxt); - sd = sysfs_new_dirent(sl, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK); - if (!sd) - goto err_out; - sysfs_attach_dirent(sd, parent_sd, NULL); + if (error) + goto out_put; return 0; - err_out: - if (sl) { - kobject_put(sl->target_kobj); - kfree(sl->link_name); - kfree(sl); - } + out_put: + sysfs_put(target_sd); + sysfs_put(sd); return error; } @@ -86,29 +84,26 @@ static int sysfs_add_link(struct dentry * parent, const char * name, struct kobj * @target: object we're pointing to. * @name: name of the symlink. */ -int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char * name) +int sysfs_create_link(struct kobject *kobj, struct kobject *target, + const char *name) { - struct dentry *dentry = NULL; - int error = -EEXIST; - - BUG_ON(!name); - - if (!kobj) { - if (sysfs_mount && sysfs_mount->mnt_sb) - dentry = sysfs_mount->mnt_sb->s_root; - } else - dentry = kobj->dentry; - - if (!dentry) - return -EFAULT; - - 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; + return sysfs_do_create_link(kobj, target, name, 1); } +/** + * sysfs_create_link_nowarn - 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. + * + * This function does the same as sysf_create_link(), but it + * doesn't warn if the link already exists. + */ +int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target, + const char *name) +{ + return sysfs_do_create_link(kobj, target, name, 0); +} /** * sysfs_remove_link - remove symlink in object's directory. @@ -118,62 +113,129 @@ int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char void sysfs_remove_link(struct kobject * kobj, const char * name) { - sysfs_hash_and_remove(kobj->dentry,name); + struct sysfs_dirent *parent_sd = NULL; + + if (!kobj) + parent_sd = &sysfs_root; + else + parent_sd = kobj->sd; + + sysfs_hash_and_remove(parent_sd, name); } -static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target, - char *path) +/** + * sysfs_rename_link - rename symlink in object's directory. + * @kobj: object we're acting for. + * @targ: object we're pointing to. + * @old: previous name of the symlink. + * @new: new name of the symlink. + * + * A helper function for the common rename symlink idiom. + */ +int sysfs_rename_link(struct kobject *kobj, struct kobject *targ, + const char *old, const char *new) { - char * s; - int depth, size; + struct sysfs_dirent *parent_sd, *sd = NULL; + int result; - depth = object_depth(kobj); - size = object_path_length(target) + depth * 3 - 1; - if (size > PATH_MAX) - return -ENAMETOOLONG; + if (!kobj) + parent_sd = &sysfs_root; + else + parent_sd = kobj->sd; - pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size); + result = -ENOENT; + sd = sysfs_get_dirent(parent_sd, old); + if (!sd) + goto out; - for (s = path; depth--; s += 3) - strcpy(s,"../"); + result = -EINVAL; + if (sysfs_type(sd) != SYSFS_KOBJ_LINK) + goto out; + if (sd->s_symlink.target_sd->s_dir.kobj != targ) + goto out; - fill_object_path(target, path, size); - pr_debug("%s: path = '%s'\n", __FUNCTION__, path); + result = sysfs_rename(sd, parent_sd, new); - return 0; +out: + sysfs_put(sd); + return result; } -static int sysfs_getlink(struct dentry *dentry, char * path) +static int sysfs_get_target_path(struct sysfs_dirent *parent_sd, + struct sysfs_dirent *target_sd, char *path) { - struct kobject *kobj, *target_kobj; - int error = 0; + struct sysfs_dirent *base, *sd; + char *s = path; + int len = 0; + + /* go up to the root, stop at the base */ + base = parent_sd; + while (base->s_parent) { + sd = target_sd->s_parent; + while (sd->s_parent && base != sd) + sd = sd->s_parent; + + if (base == sd) + break; + + strcpy(s, "../"); + s += 3; + base = base->s_parent; + } - kobj = sysfs_get_kobject(dentry->d_parent); - if (!kobj) - return -EINVAL; + /* determine end of target string for reverse fillup */ + sd = target_sd; + while (sd->s_parent && sd != base) { + len += strlen(sd->s_name) + 1; + sd = sd->s_parent; + } - target_kobj = sysfs_get_kobject(dentry); - if (!target_kobj) { - kobject_put(kobj); + /* check limits */ + if (len < 2) return -EINVAL; + len--; + if ((s - path) + len > PATH_MAX) + return -ENAMETOOLONG; + + /* reverse fillup of target string from target to base */ + sd = target_sd; + while (sd->s_parent && sd != base) { + int slen = strlen(sd->s_name); + + len -= slen; + strncpy(s + len, sd->s_name, slen); + if (len) + s[--len] = '/'; + + sd = sd->s_parent; } - 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; + return 0; +} +static int sysfs_getlink(struct dentry *dentry, char * path) +{ + struct sysfs_dirent *sd = dentry->d_fsdata; + struct sysfs_dirent *parent_sd = sd->s_parent; + struct sysfs_dirent *target_sd = sd->s_symlink.target_sd; + int error; + + mutex_lock(&sysfs_mutex); + error = sysfs_get_target_path(parent_sd, target_sd, path); + mutex_unlock(&sysfs_mutex); + + 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) + if (page) { error = sysfs_getlink(dentry, (char *) page); + if (error < 0) + free_page((unsigned long)page); + } nd_set_link(nd, error ? ERR_PTR(error) : (char *)page); return NULL; } @@ -186,9 +248,13 @@ static void sysfs_put_link(struct dentry *dentry, struct nameidata *nd, void *co } const struct inode_operations sysfs_symlink_inode_operations = { - .readlink = generic_readlink, - .follow_link = sysfs_follow_link, - .put_link = sysfs_put_link, + .setxattr = sysfs_setxattr, + .readlink = generic_readlink, + .follow_link = sysfs_follow_link, + .put_link = sysfs_put_link, + .setattr = sysfs_setattr, + .getattr = sysfs_getattr, + .permission = sysfs_permission, };