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