Line data Source code
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 1 : DEFINE_MUTEX(configfs_symlink_mutex);
36 :
37 : static int item_depth(struct config_item * item)
38 : {
39 2 : struct config_item * p = item;
40 2 : int depth = 0;
41 10 : do { depth++; } while ((p = p->ci_parent) && !configfs_is_root(p));
42 2 : return depth;
43 1 : }
44 :
45 : static int item_path_length(struct config_item * item)
46 1 : {
47 2 : struct config_item * p = item;
48 2 : int length = 1;
49 2 : do {
50 5 : length += strlen(config_item_name(p)) + 1;
51 3 : p = p->ci_parent;
52 6 : } while (p && !configfs_is_root(p));
53 2 : return length;
54 1 : }
55 :
56 : static void fill_item_path(struct config_item * item, char * buffer, int length)
57 1 : {
58 1 : struct config_item * p;
59 1 :
60 2 : --length;
61 10 : for (p = item; p && !configfs_is_root(p); p = p->ci_parent) {
62 7 : int cur = strlen(config_item_name(p));
63 3 :
64 : /* back up enough to print this bus id with '/' */
65 1 : length -= cur;
66 4 : strncpy(buffer + length,config_item_name(p),cur);
67 2 : *(buffer + --length) = '/';
68 2 : }
69 : }
70 :
71 1 : static int create_link(struct config_item *parent_item,
72 : struct config_item *item,
73 : struct dentry *dentry)
74 1 : {
75 3 : struct configfs_dirent *target_sd = item->ci_dentry->d_fsdata;
76 1 : struct configfs_symlink *sl;
77 1 : int ret;
78 1 :
79 1 : ret = -ENOENT;
80 4 : if (!configfs_dirent_is_ready(target_sd))
81 1 : goto out;
82 1 : ret = -ENOMEM;
83 3 : sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL);
84 2 : if (sl) {
85 2 : sl->sl_target = config_item_get(item);
86 2 : spin_lock(&configfs_dirent_lock);
87 2 : if (target_sd->s_type & CONFIGFS_USET_DROPPING) {
88 2 : spin_unlock(&configfs_dirent_lock);
89 2 : config_item_put(item);
90 1 : kfree(sl);
91 1 : return -ENOENT;
92 : }
93 2 : list_add(&sl->sl_list, &target_sd->s_links);
94 2 : spin_unlock(&configfs_dirent_lock);
95 4 : ret = configfs_create_link(sl, parent_item->ci_dentry,
96 : dentry);
97 2 : if (ret) {
98 2 : spin_lock(&configfs_dirent_lock);
99 2 : list_del_init(&sl->sl_list);
100 2 : spin_unlock(&configfs_dirent_lock);
101 2 : config_item_put(item);
102 1 : kfree(sl);
103 : }
104 : }
105 :
106 : out:
107 4 : return ret;
108 : }
109 :
110 3 :
111 : static int get_target(const char *symname, struct path *path,
112 : struct config_item **target)
113 1 : {
114 : int ret;
115 :
116 1 : ret = kern_path(symname, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, path);
117 2 : if (!ret) {
118 3 : if (path->dentry->d_sb == configfs_sb) {
119 2 : *target = configfs_get_config_item(path->dentry);
120 2 : if (!*target) {
121 1 : ret = -ENOENT;
122 1 : path_put(path);
123 : }
124 : } else {
125 1 : ret = -EPERM;
126 1 : path_put(path);
127 : }
128 : }
129 :
130 2 : return ret;
131 : }
132 :
133 :
134 : int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
135 : {
136 1 : int ret;
137 1 : struct path path;
138 1 : struct configfs_dirent *sd;
139 1 : struct config_item *parent_item;
140 2 : struct config_item *target_item = NULL;
141 1 : struct config_item_type *type;
142 1 :
143 1 : ret = -EPERM; /* What lack-of-symlink returns */
144 4 : if (dentry->d_parent == configfs_sb->s_root)
145 1 : goto out;
146 :
147 2 : sd = dentry->d_parent->d_fsdata;
148 : /*
149 : * Fake invisibility if dir belongs to a group/default groups hierarchy
150 : * being attached
151 : */
152 1 : ret = -ENOENT;
153 4 : if (!configfs_dirent_is_ready(sd))
154 1 : goto out;
155 :
156 2 : parent_item = configfs_get_config_item(dentry->d_parent);
157 1 : type = parent_item->ci_type;
158 :
159 1 : ret = -EPERM;
160 8 : if (!type || !type->ct_item_ops ||
161 : !type->ct_item_ops->allow_link)
162 1 : goto out_put;
163 :
164 3 : ret = get_target(symname, &path, &target_item);
165 2 : if (ret)
166 1 : goto out_put;
167 :
168 1 : ret = type->ct_item_ops->allow_link(parent_item, target_item);
169 2 : if (!ret) {
170 1 : mutex_lock(&configfs_symlink_mutex);
171 6 : ret = create_link(parent_item, target_item, dentry);
172 1 : mutex_unlock(&configfs_symlink_mutex);
173 5 : if (ret && type->ct_item_ops->drop_link)
174 1 : type->ct_item_ops->drop_link(parent_item,
175 : target_item);
176 : }
177 :
178 4 : config_item_put(target_item);
179 1 : path_put(&path);
180 :
181 1 : out_put:
182 6 : config_item_put(parent_item);
183 :
184 1 : out:
185 3 : return ret;
186 : }
187 :
188 : int configfs_unlink(struct inode *dir, struct dentry *dentry)
189 : {
190 3 : struct configfs_dirent *sd = dentry->d_fsdata;
191 1 : struct configfs_symlink *sl;
192 1 : struct config_item *parent_item;
193 1 : struct config_item_type *type;
194 1 : int ret;
195 1 :
196 1 : ret = -EPERM; /* What lack-of-symlink returns */
197 2 : if (!(sd->s_type & CONFIGFS_ITEM_LINK))
198 1 : goto out;
199 :
200 8 : BUG_ON(dentry->d_parent == configfs_sb->s_root);
201 :
202 2 : sl = sd->s_element;
203 :
204 2 : parent_item = configfs_get_config_item(dentry->d_parent);
205 1 : type = parent_item->ci_type;
206 :
207 2 : spin_lock(&configfs_dirent_lock);
208 2 : list_del_init(&sd->s_sibling);
209 2 : spin_unlock(&configfs_dirent_lock);
210 4 : configfs_drop_dentry(sd, dentry->d_parent);
211 1 : dput(dentry);
212 3 : configfs_put(sd);
213 :
214 : /*
215 : * drop_link() must be called before
216 : * list_del_init(&sl->sl_list), so that the order of
217 : * drop_link(this, target) and drop_item(target) is preserved.
218 : */
219 8 : if (type && type->ct_item_ops &&
220 : type->ct_item_ops->drop_link)
221 1 : type->ct_item_ops->drop_link(parent_item,
222 : sl->sl_target);
223 :
224 2 : spin_lock(&configfs_dirent_lock);
225 2 : list_del_init(&sl->sl_list);
226 2 : spin_unlock(&configfs_dirent_lock);
227 :
228 : /* Put reference from create_link() */
229 2 : config_item_put(sl->sl_target);
230 1 : kfree(sl);
231 :
232 2 : config_item_put(parent_item);
233 :
234 1 : ret = 0;
235 :
236 1 : out:
237 2 : return ret;
238 : }
239 :
240 : static int configfs_get_target_path(struct config_item * item, struct config_item * target,
241 : char *path)
242 : {
243 1 : char * s;
244 1 : int depth, size;
245 1 :
246 4 : depth = item_depth(item);
247 5 : size = item_path_length(target) + depth * 3 - 1;
248 2 : if (size > PATH_MAX)
249 1 : return -ENAMETOOLONG;
250 :
251 : pr_debug("%s: depth = %d, size = %d\n", __func__, depth, size);
252 :
253 7 : for (s = path; depth--; s += 3)
254 2 : strcpy(s,"../");
255 2 :
256 3 : fill_item_path(target, path, size);
257 : pr_debug("%s: path = '%s'\n", __func__, path);
258 :
259 1 : return 0;
260 : }
261 :
262 : static int configfs_getlink(struct dentry *dentry, char * path)
263 : {
264 1 : struct config_item *item, *target_item;
265 2 : int error = 0;
266 1 :
267 2 : item = configfs_get_config_item(dentry->d_parent);
268 2 : if (!item)
269 1 : return -EINVAL;
270 :
271 2 : target_item = configfs_get_config_item(dentry);
272 2 : if (!target_item) {
273 2 : config_item_put(item);
274 1 : return -EINVAL;
275 : }
276 :
277 1 : down_read(&configfs_rename_sem);
278 3 : error = configfs_get_target_path(item, target_item, path);
279 1 : up_read(&configfs_rename_sem);
280 :
281 2 : config_item_put(item);
282 2 : config_item_put(target_item);
283 1 : return error;
284 :
285 : }
286 :
287 : static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd)
288 : {
289 2 : int error = -ENOMEM;
290 3 : unsigned long page = get_zeroed_page(GFP_KERNEL);
291 1 :
292 3 : if (page) {
293 4 : error = configfs_getlink(dentry, (char *)page);
294 2 : if (!error) {
295 2 : nd_set_link(nd, (char *)page);
296 1 : return (void *)page;
297 : }
298 : }
299 :
300 6 : nd_set_link(nd, ERR_PTR(error));
301 1 : return NULL;
302 : }
303 :
304 : static void configfs_put_link(struct dentry *dentry, struct nameidata *nd,
305 : void *cookie)
306 1 : {
307 2 : if (cookie) {
308 1 : unsigned long page = (unsigned long)cookie;
309 1 : free_page(page);
310 : }
311 1 : }
312 :
313 1 : const struct inode_operations configfs_symlink_inode_operations = {
314 : .follow_link = configfs_follow_link,
315 : .readlink = generic_readlink,
316 : .put_link = configfs_put_link,
317 : .setattr = configfs_setattr,
318 : };
319 :
|