/* * 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 <teheo@suse.de> * * This file is released under the GPLv2. * * Please see Documentation/filesystems/sysfs.txt for more information. */ #include <linux/fs.h> #include <linux/mount.h> #include <linux/module.h> #include <linux/kobject.h> #include <linux/namei.h> #include <linux/mutex.h> #include "sysfs.h" /** * 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 sysfs_dirent *parent_sd = NULL; struct sysfs_dirent *target_sd = NULL; struct sysfs_dirent *sd = NULL; struct sysfs_addrm_cxt acxt; int error; BUG_ON(!name); 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; sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK); if (!sd) goto out_put; sd->s_symlink.target_sd = target_sd; target_sd = NULL; /* reference is now owned by the symlink */ sysfs_addrm_start(&acxt, parent_sd); error = sysfs_add_one(&acxt, sd); sysfs_addrm_finish(&acxt); if (error) goto out_put; return 0; out_put: sysfs_put(target_sd); sysfs_put(sd); 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->sd, name); } static int sysfs_get_target_path(struct sysfs_dirent *parent_sd, struct sysfs_dirent *target_sd, char *path) { 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; } /* 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; } /* 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; } 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) 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); } const 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);