[XFS] move sync code to its own file
[linux-2.6] / fs / configfs / symlink.c
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * symlink.c - operations for configfs symlinks.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public
17  * License along with this program; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 021110-1307, USA.
20  *
21  * Based on sysfs:
22  *      sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
23  *
24  * configfs Copyright (C) 2005 Oracle.  All rights reserved.
25  */
26
27 #include <linux/fs.h>
28 #include <linux/module.h>
29 #include <linux/namei.h>
30
31 #include <linux/configfs.h>
32 #include "configfs_internal.h"
33
34 /* Protects attachments of new symlinks */
35 DEFINE_MUTEX(configfs_symlink_mutex);
36
37 static int item_depth(struct config_item * item)
38 {
39         struct config_item * p = item;
40         int depth = 0;
41         do { depth++; } while ((p = p->ci_parent) && !configfs_is_root(p));
42         return depth;
43 }
44
45 static int item_path_length(struct config_item * item)
46 {
47         struct config_item * p = item;
48         int length = 1;
49         do {
50                 length += strlen(config_item_name(p)) + 1;
51                 p = p->ci_parent;
52         } while (p && !configfs_is_root(p));
53         return length;
54 }
55
56 static void fill_item_path(struct config_item * item, char * buffer, int length)
57 {
58         struct config_item * p;
59
60         --length;
61         for (p = item; p && !configfs_is_root(p); p = p->ci_parent) {
62                 int cur = strlen(config_item_name(p));
63
64                 /* back up enough to print this bus id with '/' */
65                 length -= cur;
66                 strncpy(buffer + length,config_item_name(p),cur);
67                 *(buffer + --length) = '/';
68         }
69 }
70
71 static int create_link(struct config_item *parent_item,
72                        struct config_item *item,
73                        struct dentry *dentry)
74 {
75         struct configfs_dirent *target_sd = item->ci_dentry->d_fsdata;
76         struct configfs_symlink *sl;
77         int ret;
78
79         ret = -ENOENT;
80         if (!configfs_dirent_is_ready(target_sd))
81                 goto out;
82         ret = -ENOMEM;
83         sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL);
84         if (sl) {
85                 sl->sl_target = config_item_get(item);
86                 spin_lock(&configfs_dirent_lock);
87                 if (target_sd->s_type & CONFIGFS_USET_DROPPING) {
88                         spin_unlock(&configfs_dirent_lock);
89                         config_item_put(item);
90                         kfree(sl);
91                         return -ENOENT;
92                 }
93                 list_add(&sl->sl_list, &target_sd->s_links);
94                 spin_unlock(&configfs_dirent_lock);
95                 ret = configfs_create_link(sl, parent_item->ci_dentry,
96                                            dentry);
97                 if (ret) {
98                         spin_lock(&configfs_dirent_lock);
99                         list_del_init(&sl->sl_list);
100                         spin_unlock(&configfs_dirent_lock);
101                         config_item_put(item);
102                         kfree(sl);
103                 }
104         }
105
106 out:
107         return ret;
108 }
109
110
111 static int get_target(const char *symname, struct path *path,
112                       struct config_item **target)
113 {
114         int ret;
115
116         ret = kern_path(symname, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, path);
117         if (!ret) {
118                 if (path->dentry->d_sb == configfs_sb) {
119                         *target = configfs_get_config_item(path->dentry);
120                         if (!*target) {
121                                 ret = -ENOENT;
122                                 path_put(path);
123                         }
124                 } else
125                         ret = -EPERM;
126         }
127
128         return ret;
129 }
130
131
132 int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
133 {
134         int ret;
135         struct path path;
136         struct configfs_dirent *sd;
137         struct config_item *parent_item;
138         struct config_item *target_item;
139         struct config_item_type *type;
140
141         ret = -EPERM;  /* What lack-of-symlink returns */
142         if (dentry->d_parent == configfs_sb->s_root)
143                 goto out;
144
145         sd = dentry->d_parent->d_fsdata;
146         /*
147          * Fake invisibility if dir belongs to a group/default groups hierarchy
148          * being attached
149          */
150         ret = -ENOENT;
151         if (!configfs_dirent_is_ready(sd))
152                 goto out;
153
154         parent_item = configfs_get_config_item(dentry->d_parent);
155         type = parent_item->ci_type;
156
157         ret = -EPERM;
158         if (!type || !type->ct_item_ops ||
159             !type->ct_item_ops->allow_link)
160                 goto out_put;
161
162         ret = get_target(symname, &path, &target_item);
163         if (ret)
164                 goto out_put;
165
166         ret = type->ct_item_ops->allow_link(parent_item, target_item);
167         if (!ret) {
168                 mutex_lock(&configfs_symlink_mutex);
169                 ret = create_link(parent_item, target_item, dentry);
170                 mutex_unlock(&configfs_symlink_mutex);
171                 if (ret && type->ct_item_ops->drop_link)
172                         type->ct_item_ops->drop_link(parent_item,
173                                                      target_item);
174         }
175
176         config_item_put(target_item);
177         path_put(&path);
178
179 out_put:
180         config_item_put(parent_item);
181
182 out:
183         return ret;
184 }
185
186 int configfs_unlink(struct inode *dir, struct dentry *dentry)
187 {
188         struct configfs_dirent *sd = dentry->d_fsdata;
189         struct configfs_symlink *sl;
190         struct config_item *parent_item;
191         struct config_item_type *type;
192         int ret;
193
194         ret = -EPERM;  /* What lack-of-symlink returns */
195         if (!(sd->s_type & CONFIGFS_ITEM_LINK))
196                 goto out;
197
198         BUG_ON(dentry->d_parent == configfs_sb->s_root);
199
200         sl = sd->s_element;
201
202         parent_item = configfs_get_config_item(dentry->d_parent);
203         type = parent_item->ci_type;
204
205         spin_lock(&configfs_dirent_lock);
206         list_del_init(&sd->s_sibling);
207         spin_unlock(&configfs_dirent_lock);
208         configfs_drop_dentry(sd, dentry->d_parent);
209         dput(dentry);
210         configfs_put(sd);
211
212         /*
213          * drop_link() must be called before
214          * list_del_init(&sl->sl_list), so that the order of
215          * drop_link(this, target) and drop_item(target) is preserved.
216          */
217         if (type && type->ct_item_ops &&
218             type->ct_item_ops->drop_link)
219                 type->ct_item_ops->drop_link(parent_item,
220                                                sl->sl_target);
221
222         spin_lock(&configfs_dirent_lock);
223         list_del_init(&sl->sl_list);
224         spin_unlock(&configfs_dirent_lock);
225
226         /* Put reference from create_link() */
227         config_item_put(sl->sl_target);
228         kfree(sl);
229
230         config_item_put(parent_item);
231
232         ret = 0;
233
234 out:
235         return ret;
236 }
237
238 static int configfs_get_target_path(struct config_item * item, struct config_item * target,
239                                    char *path)
240 {
241         char * s;
242         int depth, size;
243
244         depth = item_depth(item);
245         size = item_path_length(target) + depth * 3 - 1;
246         if (size > PATH_MAX)
247                 return -ENAMETOOLONG;
248
249         pr_debug("%s: depth = %d, size = %d\n", __func__, depth, size);
250
251         for (s = path; depth--; s += 3)
252                 strcpy(s,"../");
253
254         fill_item_path(target, path, size);
255         pr_debug("%s: path = '%s'\n", __func__, path);
256
257         return 0;
258 }
259
260 static int configfs_getlink(struct dentry *dentry, char * path)
261 {
262         struct config_item *item, *target_item;
263         int error = 0;
264
265         item = configfs_get_config_item(dentry->d_parent);
266         if (!item)
267                 return -EINVAL;
268
269         target_item = configfs_get_config_item(dentry);
270         if (!target_item) {
271                 config_item_put(item);
272                 return -EINVAL;
273         }
274
275         down_read(&configfs_rename_sem);
276         error = configfs_get_target_path(item, target_item, path);
277         up_read(&configfs_rename_sem);
278
279         config_item_put(item);
280         config_item_put(target_item);
281         return error;
282
283 }
284
285 static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd)
286 {
287         int error = -ENOMEM;
288         unsigned long page = get_zeroed_page(GFP_KERNEL);
289
290         if (page) {
291                 error = configfs_getlink(dentry, (char *)page);
292                 if (!error) {
293                         nd_set_link(nd, (char *)page);
294                         return (void *)page;
295                 }
296         }
297
298         nd_set_link(nd, ERR_PTR(error));
299         return NULL;
300 }
301
302 static void configfs_put_link(struct dentry *dentry, struct nameidata *nd,
303                               void *cookie)
304 {
305         if (cookie) {
306                 unsigned long page = (unsigned long)cookie;
307                 free_page(page);
308         }
309 }
310
311 const struct inode_operations configfs_symlink_inode_operations = {
312         .follow_link = configfs_follow_link,
313         .readlink = generic_readlink,
314         .put_link = configfs_put_link,
315         .setattr = configfs_setattr,
316 };
317