fs/afs/mntpt.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* mountpoint management
   3  *
   4  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/fs.h>
  12 #include <linux/pagemap.h>
  13 #include <linux/mount.h>
  14 #include <linux/namei.h>
  15 #include <linux/gfp.h>
  16 #include <linux/fs_context.h>
  17 #include "internal.h"
  18
  19
  20 static struct dentry *afs_mntpt_lookup(struct inode *dir,
  21                                        struct dentry *dentry,
  22                                        unsigned int flags);
  23 static int afs_mntpt_open(struct inode *inode, struct file *file);
  24 static void afs_mntpt_expiry_timed_out(struct work_struct *work);
  25
  26 const struct file_operations afs_mntpt_file_operations = {
  27         .open           = afs_mntpt_open,
  28         .llseek         = noop_llseek,
  29 };
  30
  31 const struct inode_operations afs_mntpt_inode_operations = {
  32         .lookup         = afs_mntpt_lookup,
  33         .readlink       = page_readlink,
  34         .getattr        = afs_getattr,
  35 };
  36
  37 const struct inode_operations afs_autocell_inode_operations = {
  38         .getattr        = afs_getattr,
  39 };
  40
  41 static LIST_HEAD(afs_vfsmounts);
  42 static DECLARE_DELAYED_WORK(afs_mntpt_expiry_timer, afs_mntpt_expiry_timed_out);
  43
  44 static unsigned long afs_mntpt_expiry_timeout = 10 * 60;
  45
  46 static const char afs_root_volume[] = "root.cell";
  47
  48 /*
  49  * no valid lookup procedure on this sort of dir
  50  */
  51 static struct dentry *afs_mntpt_lookup(struct inode *dir,
  52                                        struct dentry *dentry,
  53                                        unsigned int flags)
  54 {
  55         _enter("%p,%p{%pd2}", dir, dentry, dentry);
  56         return ERR_PTR(-EREMOTE);
  57 }
  58
  59 /*
  60  * no valid open procedure on this sort of dir
  61  */
  62 static int afs_mntpt_open(struct inode *inode, struct file *file)
  63 {
  64         _enter("%p,%p{%pD2}", inode, file, file);
  65         return -EREMOTE;
  66 }
  67
  68 /*
  69  * Set the parameters for the proposed superblock.
  70  */
  71 static int afs_mntpt_set_params(struct fs_context *fc, struct dentry *mntpt)
  72 {
  73         struct afs_fs_context *ctx = fc->fs_private;
  74         struct afs_super_info *src_as = AFS_FS_S(mntpt->d_sb);
  75         struct afs_vnode *vnode = AFS_FS_I(d_inode(mntpt));
  76         struct afs_cell *cell;
  77         const char *p;
  78         int ret;
  79
  80         if (fc->net_ns != src_as->net_ns) {
  81                 put_net(fc->net_ns);
  82                 fc->net_ns = get_net(src_as->net_ns);
  83         }
  84
  85         if (src_as->volume && src_as->volume->type == AFSVL_RWVOL) {
  86                 ctx->type = AFSVL_RWVOL;
  87                 ctx->force = true;
  88         }
  89         if (ctx->cell) {
  90                 afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_mntpt);
  91                 ctx->cell = NULL;
  92         }
  93         if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) {
  94                 /* if the directory is a pseudo directory, use the d_name */
  95                 unsigned size = mntpt->d_name.len;
  96
  97                 if (size < 2)
  98                         return -ENOENT;
  99
 100                 p = mntpt->d_name.name;
 101                 if (mntpt->d_name.name[0] == '.') {
 102                         size--;
 103                         p++;
 104                         ctx->type = AFSVL_RWVOL;
 105                         ctx->force = true;
 106                 }
 107                 if (size > AFS_MAXCELLNAME)
 108                         return -ENAMETOOLONG;
 109
 110                 cell = afs_lookup_cell(ctx->net, p, size, NULL, false);
 111                 if (IS_ERR(cell)) {
 112                         pr_err("kAFS: unable to lookup cell '%pd'\n", mntpt);
 113                         return PTR_ERR(cell);
 114                 }
 115                 ctx->cell = cell;
 116
 117                 ctx->volname = afs_root_volume;
 118                 ctx->volnamesz = sizeof(afs_root_volume) - 1;
 119         } else {
 120                 /* read the contents of the AFS special symlink */
 121                 struct page *page;
 122                 loff_t size = i_size_read(d_inode(mntpt));
 123                 char *buf;
 124
 125                 if (src_as->cell)
 126                         ctx->cell = afs_use_cell(src_as->cell, afs_cell_trace_use_mntpt);
 127
 128                 if (size < 2 || size > PAGE_SIZE - 1)
 129                         return -EINVAL;
 130
 131                 page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL);
 132                 if (IS_ERR(page))
 133                         return PTR_ERR(page);
 134
 135                 buf = kmap(page);
 136                 ret = -EINVAL;
 137                 if (buf[size - 1] == '.')
 138                         ret = vfs_parse_fs_string(fc, "source", buf, size - 1);
 139                 kunmap(page);
 140                 put_page(page);
 141                 if (ret < 0)
 142                         return ret;
 143         }
 144
 145         return 0;
 146 }
 147
 148 /*
 149  * create a vfsmount to be automounted
 150  */
 151 static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
 152 {
 153         struct fs_context *fc;
 154         struct vfsmount *mnt;
 155         int ret;
 156
 157         BUG_ON(!d_inode(mntpt));
 158
 159         fc = fs_context_for_submount(&afs_fs_type, mntpt);
 160         if (IS_ERR(fc))
 161                 return ERR_CAST(fc);
 162
 163         ret = afs_mntpt_set_params(fc, mntpt);
 164         if (!ret)
 165                 mnt = fc_mount(fc);
 166         else
 167                 mnt = ERR_PTR(ret);
 168
 169         put_fs_context(fc);
 170         return mnt;
 171 }
 172
 173 /*
 174  * handle an automount point
 175  */
 176 struct vfsmount *afs_d_automount(struct path *path)
 177 {
 178         struct vfsmount *newmnt;
 179
 180         _enter("{%pd}", path->dentry);
 181
 182         newmnt = afs_mntpt_do_automount(path->dentry);
 183         if (IS_ERR(newmnt))
 184                 return newmnt;
 185
 186         mntget(newmnt); /* prevent immediate expiration */
 187         mnt_set_expiry(newmnt, &afs_vfsmounts);
 188         queue_delayed_work(afs_wq, &afs_mntpt_expiry_timer,
 189                            afs_mntpt_expiry_timeout * HZ);
 190         _leave(" = %p", newmnt);
 191         return newmnt;
 192 }
 193
 194 /*
 195  * handle mountpoint expiry timer going off
 196  */
 197 static void afs_mntpt_expiry_timed_out(struct work_struct *work)
 198 {
 199         _enter("");
 200
 201         if (!list_empty(&afs_vfsmounts)) {
 202                 mark_mounts_for_expiry(&afs_vfsmounts);
 203                 queue_delayed_work(afs_wq, &afs_mntpt_expiry_timer,
 204                                    afs_mntpt_expiry_timeout * HZ);
 205         }
 206
 207         _leave("");
 208 }
 209
 210 /*
 211  * kill the AFS mountpoint timer if it's still running
 212  */
 213 void afs_mntpt_kill_timer(void)
 214 {
 215         _enter("");
 216
 217         ASSERT(list_empty(&afs_vfsmounts));
 218         cancel_delayed_work_sync(&afs_mntpt_expiry_timer);
 219 }