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 BUG_ON(dentry->d_parent == configfs_sb->s_root); 166 167 sl = sd->s_element; 168 169 parent_item = configfs_get_config_item(dentry->d_parent); 170 type = parent_item->ci_type; 171 172 list_del_init(&sd->s_sibling); 173 configfs_drop_dentry(sd, dentry->d_parent); 174 dput(dentry); 175 configfs_put(sd); 176 177 /* 178 * drop_link() must be called before 179 * list_del_init(&sl->sl_list), so that the order of 180 * drop_link(this, target) and drop_item(target) is preserved. 181 */ 182 if (type && type->ct_item_ops && 183 type->ct_item_ops->drop_link) 184 type->ct_item_ops->drop_link(parent_item, 185 sl->sl_target); 186 187 /* FIXME: Needs lock */ 188 list_del_init(&sl->sl_list); 189 190 /* Put reference from create_link() */ 191 config_item_put(sl->sl_target); 192 kfree(sl); 193 194 config_item_put(parent_item); 195 196 ret = 0; 197 198 out: 199 return ret; 200 } 201 202 static int configfs_get_target_path(struct config_item * item, struct config_item * target, 203 char *path) 204 { 205 char * s; 206 int depth, size; 207 208 depth = item_depth(item); 209 size = item_path_length(target) + depth * 3 - 1; 210 if (size > PATH_MAX) 211 return -ENAMETOOLONG; 212 213 pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size); 214 215 for (s = path; depth--; s += 3) 216 strcpy(s,"../"); 217 218 fill_item_path(target, path, size); 219 pr_debug("%s: path = '%s'\n", __FUNCTION__, path); 220 221 return 0; 222 } 223 224 static int configfs_getlink(struct dentry *dentry, char * path) 225 { 226 struct config_item *item, *target_item; 227 int error = 0; 228 229 item = configfs_get_config_item(dentry->d_parent); 230 if (!item) 231 return -EINVAL; 232 233 target_item = configfs_get_config_item(dentry); 234 if (!target_item) { 235 config_item_put(item); 236 return -EINVAL; 237 } 238 239 down_read(&configfs_rename_sem); 240 error = configfs_get_target_path(item, target_item, path); 241 up_read(&configfs_rename_sem); 242 243 config_item_put(item); 244 config_item_put(target_item); 245 return error; 246 247 } 248 249 static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd) 250 { 251 int error = -ENOMEM; 252 unsigned long page = get_zeroed_page(GFP_KERNEL); 253 254 if (page) { 255 error = configfs_getlink(dentry, (char *)page); 256 if (!error) { 257 nd_set_link(nd, (char *)page); 258 return (void *)page; 259 } 260 } 261 262 nd_set_link(nd, ERR_PTR(error)); 263 return NULL; 264 } 265 266 static void configfs_put_link(struct dentry *dentry, struct nameidata *nd, 267 void *cookie) 268 { 269 if (cookie) { 270 unsigned long page = (unsigned long)cookie; 271 free_page(page); 272 } 273 } 274 275 const struct inode_operations configfs_symlink_inode_operations = { 276 .follow_link = configfs_follow_link, 277 .readlink = generic_readlink, 278 .put_link = configfs_put_link, 279 .setattr = configfs_setattr, 280 }; 281 282