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