Merge branch 'for-linus2' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[platform/adaptation/renesas_rcar/renesas_kernel.git] / fs / sysfs / symlink.c
1 /*
2  * fs/sysfs/symlink.c - sysfs symlink implementation
3  *
4  * Copyright (c) 2001-3 Patrick Mochel
5  * Copyright (c) 2007 SUSE Linux Products GmbH
6  * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7  *
8  * This file is released under the GPLv2.
9  *
10  * Please see Documentation/filesystems/sysfs.txt for more information.
11  */
12
13 #include <linux/fs.h>
14 #include <linux/gfp.h>
15 #include <linux/mount.h>
16 #include <linux/module.h>
17 #include <linux/kobject.h>
18 #include <linux/namei.h>
19 #include <linux/mutex.h>
20 #include <linux/security.h>
21
22 #include "sysfs.h"
23
24 static int sysfs_do_create_link_sd(struct sysfs_dirent *parent_sd,
25                                    struct kobject *target,
26                                    const char *name, int warn)
27 {
28         struct sysfs_dirent *target_sd = NULL;
29         struct sysfs_dirent *sd = NULL;
30         struct sysfs_addrm_cxt acxt;
31         enum kobj_ns_type ns_type;
32         int error;
33
34         BUG_ON(!name || !parent_sd);
35
36         /*
37          * We don't own @target and it may be removed at any time.
38          * Synchronize using sysfs_symlink_target_lock.  See
39          * sysfs_remove_dir() for details.
40          */
41         spin_lock(&sysfs_symlink_target_lock);
42         if (target->sd)
43                 target_sd = sysfs_get(target->sd);
44         spin_unlock(&sysfs_symlink_target_lock);
45
46         error = -ENOENT;
47         if (!target_sd)
48                 goto out_put;
49
50         error = -ENOMEM;
51         sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK);
52         if (!sd)
53                 goto out_put;
54
55         ns_type = sysfs_ns_type(parent_sd);
56         if (ns_type)
57                 sd->s_ns = target_sd->s_ns;
58         sd->s_symlink.target_sd = target_sd;
59         target_sd = NULL;       /* reference is now owned by the symlink */
60
61         sysfs_addrm_start(&acxt);
62         /* Symlinks must be between directories with the same ns_type */
63         if (!ns_type ||
64             (ns_type == sysfs_ns_type(sd->s_symlink.target_sd->s_parent))) {
65                 if (warn)
66                         error = sysfs_add_one(&acxt, sd, parent_sd);
67                 else
68                         error = __sysfs_add_one(&acxt, sd, parent_sd);
69         } else {
70                 error = -EINVAL;
71                 WARN(1, KERN_WARNING
72                         "sysfs: symlink across ns_types %s/%s -> %s/%s\n",
73                         parent_sd->s_name,
74                         sd->s_name,
75                         sd->s_symlink.target_sd->s_parent->s_name,
76                         sd->s_symlink.target_sd->s_name);
77         }
78         sysfs_addrm_finish(&acxt);
79
80         if (error)
81                 goto out_put;
82
83         return 0;
84
85  out_put:
86         sysfs_put(target_sd);
87         sysfs_put(sd);
88         return error;
89 }
90
91 /**
92  *      sysfs_create_link_sd - create symlink to a given object.
93  *      @sd:            directory we're creating the link in.
94  *      @target:        object we're pointing to.
95  *      @name:          name of the symlink.
96  */
97 int sysfs_create_link_sd(struct sysfs_dirent *sd, struct kobject *target,
98                          const char *name)
99 {
100         return sysfs_do_create_link_sd(sd, target, name, 1);
101 }
102
103 static int sysfs_do_create_link(struct kobject *kobj, struct kobject *target,
104                                 const char *name, int warn)
105 {
106         struct sysfs_dirent *parent_sd = NULL;
107
108         if (!kobj)
109                 parent_sd = &sysfs_root;
110         else
111                 parent_sd = kobj->sd;
112
113         if (!parent_sd)
114                 return -EFAULT;
115
116         return sysfs_do_create_link_sd(parent_sd, target, name, warn);
117 }
118
119 /**
120  *      sysfs_create_link - create symlink between two objects.
121  *      @kobj:  object whose directory we're creating the link in.
122  *      @target:        object we're pointing to.
123  *      @name:          name of the symlink.
124  */
125 int sysfs_create_link(struct kobject *kobj, struct kobject *target,
126                       const char *name)
127 {
128         return sysfs_do_create_link(kobj, target, name, 1);
129 }
130 EXPORT_SYMBOL_GPL(sysfs_create_link);
131
132 /**
133  *      sysfs_create_link_nowarn - create symlink between two objects.
134  *      @kobj:  object whose directory we're creating the link in.
135  *      @target:        object we're pointing to.
136  *      @name:          name of the symlink.
137  *
138  *      This function does the same as sysfs_create_link(), but it
139  *      doesn't warn if the link already exists.
140  */
141 int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target,
142                              const char *name)
143 {
144         return sysfs_do_create_link(kobj, target, name, 0);
145 }
146
147 /**
148  *      sysfs_delete_link - remove symlink in object's directory.
149  *      @kobj:  object we're acting for.
150  *      @targ:  object we're pointing to.
151  *      @name:  name of the symlink to remove.
152  *
153  *      Unlike sysfs_remove_link sysfs_delete_link has enough information
154  *      to successfully delete symlinks in tagged directories.
155  */
156 void sysfs_delete_link(struct kobject *kobj, struct kobject *targ,
157                         const char *name)
158 {
159         const void *ns = NULL;
160
161         /*
162          * We don't own @target and it may be removed at any time.
163          * Synchronize using sysfs_symlink_target_lock.  See
164          * sysfs_remove_dir() for details.
165          */
166         spin_lock(&sysfs_symlink_target_lock);
167         if (targ->sd && sysfs_ns_type(kobj->sd))
168                 ns = targ->sd->s_ns;
169         spin_unlock(&sysfs_symlink_target_lock);
170         sysfs_hash_and_remove(kobj->sd, name, ns);
171 }
172
173 /**
174  *      sysfs_remove_link - remove symlink in object's directory.
175  *      @kobj:  object we're acting for.
176  *      @name:  name of the symlink to remove.
177  */
178 void sysfs_remove_link(struct kobject *kobj, const char *name)
179 {
180         struct sysfs_dirent *parent_sd = NULL;
181
182         if (!kobj)
183                 parent_sd = &sysfs_root;
184         else
185                 parent_sd = kobj->sd;
186
187         sysfs_hash_and_remove(parent_sd, name, NULL);
188 }
189 EXPORT_SYMBOL_GPL(sysfs_remove_link);
190
191 /**
192  *      sysfs_rename_link_ns - rename symlink in object's directory.
193  *      @kobj:  object we're acting for.
194  *      @targ:  object we're pointing to.
195  *      @old:   previous name of the symlink.
196  *      @new:   new name of the symlink.
197  *      @new_ns: new namespace of the symlink.
198  *
199  *      A helper function for the common rename symlink idiom.
200  */
201 int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *targ,
202                          const char *old, const char *new, const void *new_ns)
203 {
204         struct sysfs_dirent *parent_sd, *sd = NULL;
205         const void *old_ns = NULL;
206         int result;
207
208         if (!kobj)
209                 parent_sd = &sysfs_root;
210         else
211                 parent_sd = kobj->sd;
212
213         if (targ->sd)
214                 old_ns = targ->sd->s_ns;
215
216         result = -ENOENT;
217         sd = sysfs_get_dirent_ns(parent_sd, old, old_ns);
218         if (!sd)
219                 goto out;
220
221         result = -EINVAL;
222         if (sysfs_type(sd) != SYSFS_KOBJ_LINK)
223                 goto out;
224         if (sd->s_symlink.target_sd->s_dir.kobj != targ)
225                 goto out;
226
227         result = sysfs_rename(sd, parent_sd, new, new_ns);
228
229 out:
230         sysfs_put(sd);
231         return result;
232 }
233 EXPORT_SYMBOL_GPL(sysfs_rename_link_ns);
234
235 static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
236                                  struct sysfs_dirent *target_sd, char *path)
237 {
238         struct sysfs_dirent *base, *sd;
239         char *s = path;
240         int len = 0;
241
242         /* go up to the root, stop at the base */
243         base = parent_sd;
244         while (base->s_parent) {
245                 sd = target_sd->s_parent;
246                 while (sd->s_parent && base != sd)
247                         sd = sd->s_parent;
248
249                 if (base == sd)
250                         break;
251
252                 strcpy(s, "../");
253                 s += 3;
254                 base = base->s_parent;
255         }
256
257         /* determine end of target string for reverse fillup */
258         sd = target_sd;
259         while (sd->s_parent && sd != base) {
260                 len += strlen(sd->s_name) + 1;
261                 sd = sd->s_parent;
262         }
263
264         /* check limits */
265         if (len < 2)
266                 return -EINVAL;
267         len--;
268         if ((s - path) + len > PATH_MAX)
269                 return -ENAMETOOLONG;
270
271         /* reverse fillup of target string from target to base */
272         sd = target_sd;
273         while (sd->s_parent && sd != base) {
274                 int slen = strlen(sd->s_name);
275
276                 len -= slen;
277                 strncpy(s + len, sd->s_name, slen);
278                 if (len)
279                         s[--len] = '/';
280
281                 sd = sd->s_parent;
282         }
283
284         return 0;
285 }
286
287 static int sysfs_getlink(struct dentry *dentry, char *path)
288 {
289         struct sysfs_dirent *sd = dentry->d_fsdata;
290         struct sysfs_dirent *parent_sd = sd->s_parent;
291         struct sysfs_dirent *target_sd = sd->s_symlink.target_sd;
292         int error;
293
294         mutex_lock(&sysfs_mutex);
295         error = sysfs_get_target_path(parent_sd, target_sd, path);
296         mutex_unlock(&sysfs_mutex);
297
298         return error;
299 }
300
301 static void *sysfs_follow_link(struct dentry *dentry, struct nameidata *nd)
302 {
303         int error = -ENOMEM;
304         unsigned long page = get_zeroed_page(GFP_KERNEL);
305         if (page) {
306                 error = sysfs_getlink(dentry, (char *) page);
307                 if (error < 0)
308                         free_page((unsigned long)page);
309         }
310         nd_set_link(nd, error ? ERR_PTR(error) : (char *)page);
311         return NULL;
312 }
313
314 static void sysfs_put_link(struct dentry *dentry, struct nameidata *nd,
315                            void *cookie)
316 {
317         char *page = nd_get_link(nd);
318         if (!IS_ERR(page))
319                 free_page((unsigned long)page);
320 }
321
322 const struct inode_operations sysfs_symlink_inode_operations = {
323         .setxattr       = sysfs_setxattr,
324         .readlink       = generic_readlink,
325         .follow_link    = sysfs_follow_link,
326         .put_link       = sysfs_put_link,
327         .setattr        = sysfs_setattr,
328         .getattr        = sysfs_getattr,
329         .permission     = sysfs_permission,
330 };