fs/sysfs/symlink.c

   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
  46 static int sysfs_add_link(struct dentry * parent, const char * name, struct kobject * target)
  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
  69         kfree(sl->link_name);
  70 exit2:
  71         kfree(sl);
  72 exit1:
  73         return error;
  74 }
  75
  76 /**
  77  *      sysfs_create_link - create symlink between two objects.
  78  *      @kobj:  object whose directory we're creating the link in.
  79  *      @target:        object we're pointing to.
  80  *      @name:          name of the symlink.
  81  */
  82 int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char * name)
  83 {
  84         struct dentry * dentry = kobj->dentry;
  85         int error = -EEXIST;
  86
  87         BUG_ON(!kobj || !kobj->dentry || !name);
  88
  89         mutex_lock(&dentry->d_inode->i_mutex);
  90         if (!sysfs_dirent_exist(dentry->d_fsdata, name))
  91                 error = sysfs_add_link(dentry, name, target);
  92         mutex_unlock(&dentry->d_inode->i_mutex);
  93         return error;
  94 }
  95
  96
  97 /**
  98  *      sysfs_remove_link - remove symlink in object's directory.
  99  *      @kobj:  object we're acting for.
 100  *      @name:  name of the symlink to remove.
 101  */
 102
 103 void sysfs_remove_link(struct kobject * kobj, const char * name)
 104 {
 105         sysfs_hash_and_remove(kobj->dentry,name);
 106 }
 107
 108 static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target,
 109                                  char *path)
 110 {
 111         char * s;
 112         int depth, size;
 113
 114         depth = object_depth(kobj);
 115         size = object_path_length(target) + depth * 3 - 1;
 116         if (size > PATH_MAX)
 117                 return -ENAMETOOLONG;
 118
 119         pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size);
 120
 121         for (s = path; depth--; s += 3)
 122                 strcpy(s,"../");
 123
 124         fill_object_path(target, path, size);
 125         pr_debug("%s: path = '%s'\n", __FUNCTION__, path);
 126
 127         return 0;
 128 }
 129
 130 static int sysfs_getlink(struct dentry *dentry, char * path)
 131 {
 132         struct kobject *kobj, *target_kobj;
 133         int error = 0;
 134
 135         kobj = sysfs_get_kobject(dentry->d_parent);
 136         if (!kobj)
 137                 return -EINVAL;
 138
 139         target_kobj = sysfs_get_kobject(dentry);
 140         if (!target_kobj) {
 141                 kobject_put(kobj);
 142                 return -EINVAL;
 143         }
 144
 145         down_read(&sysfs_rename_sem);
 146         error = sysfs_get_target_path(kobj, target_kobj, path);
 147         up_read(&sysfs_rename_sem);
 148
 149         kobject_put(kobj);
 150         kobject_put(target_kobj);
 151         return error;
 152
 153 }
 154
 155 static void *sysfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 156 {
 157         int error = -ENOMEM;
 158         unsigned long page = get_zeroed_page(GFP_KERNEL);
 159         if (page)
 160                 error = sysfs_getlink(dentry, (char *) page);
 161         nd_set_link(nd, error ? ERR_PTR(error) : (char *)page);
 162         return NULL;
 163 }
 164
 165 static void sysfs_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
 166 {
 167         char *page = nd_get_link(nd);
 168         if (!IS_ERR(page))
 169                 free_page((unsigned long)page);
 170 }
 171
 172 struct inode_operations sysfs_symlink_inode_operations = {
 173         .readlink = generic_readlink,
 174         .follow_link = sysfs_follow_link,
 175         .put_link = sysfs_put_link,
 176 };
 177
 178
 179 EXPORT_SYMBOL_GPL(sysfs_create_link);
 180 EXPORT_SYMBOL_GPL(sysfs_remove_link);