fs/afs/mntpt.c

   1 /* mountpoint management
   2  *
   3  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/fs.h>
  16 #include <linux/pagemap.h>
  17 #include <linux/mount.h>
  18 #include <linux/namei.h>
  19 #include <linux/gfp.h>
  20 #include "internal.h"
  21
  22
  23 static struct dentry *afs_mntpt_lookup(struct inode *dir,
  24                                        struct dentry *dentry,
  25                                        struct nameidata *nd);
  26 static int afs_mntpt_open(struct inode *inode, struct file *file);
  27 static void *afs_mntpt_follow_link(struct dentry *dentry, struct nameidata *nd);
  28 static void afs_mntpt_expiry_timed_out(struct work_struct *work);
  29
  30 const struct file_operations afs_mntpt_file_operations = {
  31         .open           = afs_mntpt_open,
  32 };
  33
  34 const struct inode_operations afs_mntpt_inode_operations = {
  35         .lookup         = afs_mntpt_lookup,
  36         .follow_link    = afs_mntpt_follow_link,
  37         .readlink       = page_readlink,
  38         .getattr        = afs_getattr,
  39 };
  40
  41 const struct inode_operations afs_autocell_inode_operations = {
  42         .follow_link    = afs_mntpt_follow_link,
  43         .getattr        = afs_getattr,
  44 };
  45
  46 static LIST_HEAD(afs_vfsmounts);
  47 static DECLARE_DELAYED_WORK(afs_mntpt_expiry_timer, afs_mntpt_expiry_timed_out);
  48
  49 static unsigned long afs_mntpt_expiry_timeout = 10 * 60;
  50
  51 /*
  52  * check a symbolic link to see whether it actually encodes a mountpoint
  53  * - sets the AFS_VNODE_MOUNTPOINT flag on the vnode appropriately
  54  */
  55 int afs_mntpt_check_symlink(struct afs_vnode *vnode, struct key *key)
  56 {
  57         struct page *page;
  58         size_t size;
  59         char *buf;
  60         int ret;
  61
  62         _enter("{%x:%u,%u}",
  63                vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
  64
  65         /* read the contents of the symlink into the pagecache */
  66         page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0,
  67                                afs_page_filler, key);
  68         if (IS_ERR(page)) {
  69                 ret = PTR_ERR(page);
  70                 goto out;
  71         }
  72
  73         ret = -EIO;
  74         if (PageError(page))
  75                 goto out_free;
  76
  77         buf = kmap(page);
  78
  79         /* examine the symlink's contents */
  80         size = vnode->status.size;
  81         _debug("symlink to %*.*s", (int) size, (int) size, buf);
  82
  83         if (size > 2 &&
  84             (buf[0] == '%' || buf[0] == '#') &&
  85             buf[size - 1] == '.'
  86             ) {
  87                 _debug("symlink is a mountpoint");
  88                 spin_lock(&vnode->lock);
  89                 set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
  90                 spin_unlock(&vnode->lock);
  91         }
  92
  93         ret = 0;
  94
  95         kunmap(page);
  96 out_free:
  97         page_cache_release(page);
  98 out:
  99         _leave(" = %d", ret);
 100         return ret;
 101 }
 102
 103 /*
 104  * no valid lookup procedure on this sort of dir
 105  */
 106 static struct dentry *afs_mntpt_lookup(struct inode *dir,
 107                                        struct dentry *dentry,
 108                                        struct nameidata *nd)
 109 {
 110         _enter("%p,%p{%p{%s},%s}",
 111                dir,
 112                dentry,
 113                dentry->d_parent,
 114                dentry->d_parent ?
 115                dentry->d_parent->d_name.name : (const unsigned char *) "",
 116                dentry->d_name.name);
 117
 118         return ERR_PTR(-EREMOTE);
 119 }
 120
 121 /*
 122  * no valid open procedure on this sort of dir
 123  */
 124 static int afs_mntpt_open(struct inode *inode, struct file *file)
 125 {
 126         _enter("%p,%p{%p{%s},%s}",
 127                inode, file,
 128                file->f_path.dentry->d_parent,
 129                file->f_path.dentry->d_parent ?
 130                file->f_path.dentry->d_parent->d_name.name :
 131                (const unsigned char *) "",
 132                file->f_path.dentry->d_name.name);
 133
 134         return -EREMOTE;
 135 }
 136
 137 /*
 138  * create a vfsmount to be automounted
 139  */
 140 static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
 141 {
 142         struct afs_super_info *super;
 143         struct vfsmount *mnt;
 144         struct afs_vnode *vnode;
 145         struct page *page;
 146         char *devname, *options;
 147         bool rwpath = false;
 148         int ret;
 149
 150         _enter("{%s}", mntpt->d_name.name);
 151
 152         BUG_ON(!mntpt->d_inode);
 153
 154         ret = -ENOMEM;
 155         devname = (char *) get_zeroed_page(GFP_KERNEL);
 156         if (!devname)
 157                 goto error_no_devname;
 158
 159         options = (char *) get_zeroed_page(GFP_KERNEL);
 160         if (!options)
 161                 goto error_no_options;
 162
 163         vnode = AFS_FS_I(mntpt->d_inode);
 164         if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) {
 165                 /* if the directory is a pseudo directory, use the d_name */
 166                 static const char afs_root_cell[] = ":root.cell.";
 167                 unsigned size = mntpt->d_name.len;
 168
 169                 ret = -ENOENT;
 170                 if (size < 2 || size > AFS_MAXCELLNAME)
 171                         goto error_no_page;
 172
 173                 if (mntpt->d_name.name[0] == '.') {
 174                         devname[0] = '#';
 175                         memcpy(devname + 1, mntpt->d_name.name, size - 1);
 176                         memcpy(devname + size, afs_root_cell,
 177                                sizeof(afs_root_cell));
 178                         rwpath = true;
 179                 } else {
 180                         devname[0] = '%';
 181                         memcpy(devname + 1, mntpt->d_name.name, size);
 182                         memcpy(devname + size + 1, afs_root_cell,
 183                                sizeof(afs_root_cell));
 184                 }
 185         } else {
 186                 /* read the contents of the AFS special symlink */
 187                 loff_t size = i_size_read(mntpt->d_inode);
 188                 char *buf;
 189
 190                 ret = -EINVAL;
 191                 if (size > PAGE_SIZE - 1)
 192                         goto error_no_page;
 193
 194                 page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL);
 195                 if (IS_ERR(page)) {
 196                         ret = PTR_ERR(page);
 197                         goto error_no_page;
 198                 }
 199
 200                 ret = -EIO;
 201                 if (PageError(page))
 202                         goto error;
 203
 204                 buf = kmap_atomic(page, KM_USER0);
 205                 memcpy(devname, buf, size);
 206                 kunmap_atomic(buf, KM_USER0);
 207                 page_cache_release(page);
 208                 page = NULL;
 209         }
 210
 211         /* work out what options we want */
 212         super = AFS_FS_S(mntpt->d_sb);
 213         memcpy(options, "cell=", 5);
 214         strcpy(options + 5, super->volume->cell->name);
 215         if (super->volume->type == AFSVL_RWVOL || rwpath)
 216                 strcat(options, ",rwpath");
 217
 218         /* try and do the mount */
 219         _debug("--- attempting mount %s -o %s ---", devname, options);
 220         mnt = vfs_kern_mount(&afs_fs_type, 0, devname, options);
 221         _debug("--- mount result %p ---", mnt);
 222
 223         free_page((unsigned long) devname);
 224         free_page((unsigned long) options);
 225         _leave(" = %p", mnt);
 226         return mnt;
 227
 228 error:
 229         page_cache_release(page);
 230 error_no_page:
 231         free_page((unsigned long) options);
 232 error_no_options:
 233         free_page((unsigned long) devname);
 234 error_no_devname:
 235         _leave(" = %d", ret);
 236         return ERR_PTR(ret);
 237 }
 238
 239 /*
 240  * follow a link from a mountpoint directory, thus causing it to be mounted
 241  */
 242 static void *afs_mntpt_follow_link(struct dentry *dentry, struct nameidata *nd)
 243 {
 244         struct vfsmount *newmnt;
 245         int err;
 246
 247         _enter("%p{%s},{%s:%p{%s},}",
 248                dentry,
 249                dentry->d_name.name,
 250                nd->path.mnt->mnt_devname,
 251                dentry,
 252                nd->path.dentry->d_name.name);
 253
 254         dput(nd->path.dentry);
 255         nd->path.dentry = dget(dentry);
 256
 257         newmnt = afs_mntpt_do_automount(nd->path.dentry);
 258         if (IS_ERR(newmnt)) {
 259                 path_put(&nd->path);
 260                 return (void *)newmnt;
 261         }
 262
 263         mntget(newmnt);
 264         err = do_add_mount(newmnt, &nd->path, MNT_SHRINKABLE, &afs_vfsmounts);
 265         switch (err) {
 266         case 0:
 267                 path_put(&nd->path);
 268                 nd->path.mnt = newmnt;
 269                 nd->path.dentry = dget(newmnt->mnt_root);
 270                 schedule_delayed_work(&afs_mntpt_expiry_timer,
 271                                       afs_mntpt_expiry_timeout * HZ);
 272                 break;
 273         case -EBUSY:
 274                 /* someone else made a mount here whilst we were busy */
 275                 while (d_mountpoint(nd->path.dentry) &&
 276                        follow_down(&nd->path))
 277                         ;
 278                 err = 0;
 279         default:
 280                 mntput(newmnt);
 281                 break;
 282         }
 283
 284         _leave(" = %d", err);
 285         return ERR_PTR(err);
 286 }
 287
 288 /*
 289  * handle mountpoint expiry timer going off
 290  */
 291 static void afs_mntpt_expiry_timed_out(struct work_struct *work)
 292 {
 293         _enter("");
 294
 295         if (!list_empty(&afs_vfsmounts)) {
 296                 mark_mounts_for_expiry(&afs_vfsmounts);
 297                 schedule_delayed_work(&afs_mntpt_expiry_timer,
 298                                       afs_mntpt_expiry_timeout * HZ);
 299         }
 300
 301         _leave("");
 302 }
 303
 304 /*
 305  * kill the AFS mountpoint timer if it's still running
 306  */
 307 void afs_mntpt_kill_timer(void)
 308 {
 309         _enter("");
 310
 311         ASSERT(list_empty(&afs_vfsmounts));
 312         cancel_delayed_work(&afs_mntpt_expiry_timer);
 313         flush_scheduled_work();
 314 }