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