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 /* FIXME: needs a lock, I'd bet */ 81 list_add(&sl->sl_list, &target_sd->s_links); 82 ret = configfs_create_link(sl, parent_item->ci_dentry, 83 dentry); 84 if (ret) { 85 list_del_init(&sl->sl_list); 86 config_item_put(item); 87 kfree(sl); 88 } 89 } 90 91 return ret; 92 } 93 94 95 static int get_target(const char *symname, struct nameidata *nd, 96 struct config_item **target) 97 { 98 int ret; 99 100 ret = path_lookup(symname, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, nd); 101 if (!ret) { 102 if (nd->dentry->d_sb == configfs_sb) { 103 *target = configfs_get_config_item(nd->dentry); 104 if (!*target) { 105 ret = -ENOENT; 106 path_release(nd); 107 } 108 } else 109 ret = -EPERM; 110 } 111 112 return ret; 113 } 114 115 116 int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 117 { 118 int ret; 119 struct nameidata nd; 120 struct config_item *parent_item; 121 struct config_item *target_item; 122 struct config_item_type *type; 123 124 ret = -EPERM; /* What lack-of-symlink returns */ 125 if (dentry->d_parent == configfs_sb->s_root) 126 goto out; 127 128 parent_item = configfs_get_config_item(dentry->d_parent); 129 type = parent_item->ci_type; 130 131 if (!type || !type->ct_item_ops || 132 !type->ct_item_ops->allow_link) 133 goto out_put; 134 135 ret = get_target(symname, &nd, &target_item); 136 if (ret) 137 goto out_put; 138 139 ret = type->ct_item_ops->allow_link(parent_item, target_item); 140 if (!ret) 141 ret = create_link(parent_item, target_item, dentry); 142 143 config_item_put(target_item); 144 path_release(&nd); 145 146 out_put: 147 config_item_put(parent_item); 148 149 out: 150 return ret; 151 } 152 153 int configfs_unlink(struct inode *dir, struct dentry *dentry) 154 { 155 struct configfs_dirent *sd = dentry->d_fsdata; 156 struct configfs_symlink *sl; 157 struct config_item *parent_item; 158 struct config_item_type *type; 159 int ret; 160 161 ret = -EPERM; /* What lack-of-symlink returns */ 162 if (!(sd->s_type & CONFIGFS_ITEM_LINK)) 163 goto out; 164 165 if (dentry->d_parent == configfs_sb->s_root) 166 BUG(); 167 168 sl = sd->s_element; 169 170 parent_item = configfs_get_config_item(dentry->d_parent); 171 type = parent_item->ci_type; 172 173 list_del_init(&sd->s_sibling); 174 configfs_drop_dentry(sd, dentry->d_parent); 175 dput(dentry); 176 configfs_put(sd); 177 178 /* 179 * drop_link() must be called before 180 * list_del_init(&sl->sl_list), so that the order of 181 * drop_link(this, target) and drop_item(target) is preserved. 182 */ 183 if (type && type->ct_item_ops && 184 type->ct_item_ops->drop_link) 185 type->ct_item_ops->drop_link(parent_item, 186 sl->sl_target); 187 188 /* FIXME: Needs lock */ 189 list_del_init(&sl->sl_list); 190 191 /* Put reference from create_link() */ 192 config_item_put(sl->sl_target); 193 kfree(sl); 194 195 config_item_put(parent_item); 196 197 ret = 0; 198 199 out: 200 return ret; 201 } 202 203 static int configfs_get_target_path(struct config_item * item, struct config_item * target, 204 char *path) 205 { 206 char * s; 207 int depth, size; 208 209 depth = item_depth(item); 210 size = item_path_length(target) + depth * 3 - 1; 211 if (size > PATH_MAX) 212 return -ENAMETOOLONG; 213 214 pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size); 215 216 for (s = path; depth--; s += 3) 217 strcpy(s,"../"); 218 219 fill_item_path(target, path, size); 220 pr_debug("%s: path = '%s'\n", __FUNCTION__, path); 221 222 return 0; 223 } 224 225 static int configfs_getlink(struct dentry *dentry, char * path) 226 { 227 struct config_item *item, *target_item; 228 int error = 0; 229 230 item = configfs_get_config_item(dentry->d_parent); 231 if (!item) 232 return -EINVAL; 233 234 target_item = configfs_get_config_item(dentry); 235 if (!target_item) { 236 config_item_put(item); 237 return -EINVAL; 238 } 239 240 down_read(&configfs_rename_sem); 241 error = configfs_get_target_path(item, target_item, path); 242 up_read(&configfs_rename_sem); 243 244 config_item_put(item); 245 config_item_put(target_item); 246 return error; 247 248 } 249 250 static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd) 251 { 252 int error = -ENOMEM; 253 unsigned long page = get_zeroed_page(GFP_KERNEL); 254 255 if (page) { 256 error = configfs_getlink(dentry, (char *)page); 257 if (!error) { 258 nd_set_link(nd, (char *)page); 259 return (void *)page; 260 } 261 } 262 263 nd_set_link(nd, ERR_PTR(error)); 264 return NULL; 265 } 266 267 static void configfs_put_link(struct dentry *dentry, struct nameidata *nd, 268 void *cookie) 269 { 270 if (cookie) { 271 unsigned long page = (unsigned long)cookie; 272 free_page(page); 273 } 274 } 275 276 struct inode_operations configfs_symlink_inode_operations = { 277 .follow_link = configfs_follow_link, 278 .readlink = generic_readlink, 279 .put_link = configfs_put_link, 280 }; 281 282