[PATCH] sysfs: fix problem with duplicate sysfs directories and files
[linux-2.6.git] / 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);