sys/vfs/autofs/autofs_vfsops.c

   1 /*-
   2  * Copyright (c) 2016 The DragonFly Project
   3  * Copyright (c) 2014 The FreeBSD Foundation
   4  * All rights reserved.
   5  *
   6  * This software was developed by Edward Tomasz Napierala under sponsorship
   7  * from the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  */
  31
  32 #include <sys/kernel.h>
  33 #include <sys/module.h>
  34 #include <sys/stat.h>
  35
  36 #include "autofs.h"
  37 #include "autofs_mount.h"
  38
  39 static int      autofs_statfs(struct mount *mp, struct statfs *sbp,
  40                     struct ucred *cred);
  41
  42 extern struct autofs_softc      *autofs_softc;
  43
  44 static int
  45 autofs_mount(struct mount *mp, char *mntpt, caddr_t data, struct ucred *cred)
  46 {
  47         struct autofs_mount_info info;
  48         struct autofs_mount *amp;
  49         struct statfs *sbp = &mp->mnt_stat;
  50         int error;
  51
  52         if (mp->mnt_flag & MNT_UPDATE) {
  53                 autofs_flush(VFSTOAUTOFS(mp));
  54                 return (0);
  55         }
  56
  57         error = copyin(data, &info, sizeof(info));
  58         if (error)
  59                 return (error);
  60
  61         /*
  62          * Copy-in ->f_mntfromname string.
  63          */
  64         memset(sbp->f_mntfromname, 0, sizeof(sbp->f_mntfromname));
  65         error = copyinstr(info.from, sbp->f_mntfromname,
  66             sizeof(sbp->f_mntfromname), NULL);
  67         if (error)
  68                 return (error);
  69         /*
  70          * Copy-in ->f_mntonname string.
  71          */
  72         memset(sbp->f_mntonname, 0, sizeof(sbp->f_mntonname));
  73         error = copyinstr(mntpt, sbp->f_mntonname,
  74             sizeof(sbp->f_mntonname), NULL);
  75         if (error)
  76                 return (error);
  77
  78         /*
  79          * Allocate the autofs mount.
  80          */
  81         amp = kmalloc(sizeof(*amp), M_AUTOFS, M_WAITOK | M_ZERO);
  82         mp->mnt_data = (qaddr_t)amp;
  83         amp->am_mp = mp;
  84         strlcpy(amp->am_from, sbp->f_mntfromname, sizeof(amp->am_from));
  85         strlcpy(amp->am_on, sbp->f_mntonname, sizeof(amp->am_on));
  86
  87         /*
  88          * Copy-in master_options string.
  89          */
  90         error = copyinstr(info.master_options, amp->am_options,
  91             sizeof(amp->am_options), NULL);
  92         if (error)
  93                 goto fail;
  94         /*
  95          * Copy-in master_prefix string.
  96          */
  97         error = copyinstr(info.master_prefix, amp->am_prefix,
  98             sizeof(amp->am_prefix), NULL);
  99         if (error)
 100                 goto fail;
 101
 102         /*
 103          * Initialize the autofs mount.
 104          */
 105         lockinit(&amp->am_lock, "autofsmnlk", 0, 0);
 106         amp->am_last_ino = AUTOFS_ROOTINO;
 107
 108         vfs_getnewfsid(mp);
 109         vfs_add_vnodeops(mp, &autofs_vnode_vops, &mp->mnt_vn_norm_ops);
 110
 111         lockmgr(&amp->am_lock, LK_EXCLUSIVE);
 112         error = autofs_node_new(NULL, amp, ".", -1, &amp->am_root);
 113         lockmgr(&amp->am_lock, LK_RELEASE);
 114         KKASSERT(error == 0);
 115         KKASSERT(amp->am_root->an_ino == AUTOFS_ROOTINO);
 116
 117         autofs_statfs(mp, sbp, cred);
 118
 119         return (0);
 120
 121 fail:
 122         kfree(amp, M_AUTOFS);
 123         return (error);
 124 }
 125
 126 static int
 127 autofs_unmount(struct mount *mp, int mntflags)
 128 {
 129         struct autofs_mount *amp = VFSTOAUTOFS(mp);
 130         struct autofs_node *anp;
 131         struct autofs_request *ar;
 132         int error, flags, dummy;
 133         bool found;
 134
 135         flags = 0;
 136         if (mntflags & MNT_FORCE)
 137                 flags |= FORCECLOSE;
 138         error = vflush(mp, 0, flags);
 139         if (error) {
 140                 AUTOFS_WARN("vflush failed with error %d", error);
 141                 return (error);
 142         }
 143
 144         /*
 145          * All vnodes are gone, and new one will not appear - so,
 146          * no new triggerings.
 147          */
 148         for (;;) {
 149                 found = false;
 150                 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
 151                 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
 152                         if (ar->ar_mount != amp)
 153                                 continue;
 154                         ar->ar_error = ENXIO;
 155                         ar->ar_done = true;
 156                         ar->ar_in_progress = false;
 157                         found = true;
 158                 }
 159                 if (found == false) {
 160                         lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
 161                         break;
 162                 }
 163
 164                 cv_broadcast(&autofs_softc->sc_cv);
 165                 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
 166
 167                 tsleep(&dummy, 0, "autofs_umount", hz);
 168         }
 169
 170         lockmgr(&amp->am_lock, LK_EXCLUSIVE);
 171         while (!RB_EMPTY(&amp->am_root->an_children)) {
 172                 anp = RB_MIN(autofs_node_tree, &amp->am_root->an_children);
 173                 if (!RB_EMPTY(&anp->an_children)) {
 174                         AUTOFS_DEBUG("%s has children", anp->an_name);
 175                         lockmgr(&amp->am_lock, LK_RELEASE);
 176                         return EBUSY;
 177                 }
 178                 autofs_node_delete(anp);
 179         }
 180         autofs_node_delete(amp->am_root);
 181         mp->mnt_data = NULL;
 182         lockmgr(&amp->am_lock, LK_RELEASE);
 183
 184         lockuninit(&amp->am_lock);
 185
 186         kfree(amp, M_AUTOFS);
 187
 188         return (0);
 189 }
 190
 191 static int
 192 autofs_root(struct mount *mp, struct vnode **vpp)
 193 {
 194         struct autofs_mount *amp = VFSTOAUTOFS(mp);
 195         int error;
 196
 197         if (amp->am_root == NULL) {
 198                 AUTOFS_FATAL("called without root node %p", mp);
 199                 print_backtrace(-1);
 200                 *vpp = NULL;
 201                 error = EINVAL;
 202         } else {
 203                 error = autofs_node_vn(amp->am_root, mp, LK_EXCLUSIVE, vpp);
 204                 (*vpp)->v_flag |= VROOT;
 205                 KKASSERT((*vpp)->v_type == VDIR);
 206         }
 207
 208         return (error);
 209 }
 210
 211 static int
 212 autofs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 213 {
 214         sbp->f_bsize = S_BLKSIZE;
 215         sbp->f_iosize = 0;
 216         sbp->f_blocks = 0;
 217         sbp->f_bfree = 0;
 218         sbp->f_bavail = 0;
 219         sbp->f_files = 0;
 220         sbp->f_ffree = 0;
 221
 222         return (0);
 223 }
 224
 225 static int
 226 autofs_statvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred)
 227 {
 228         sbp->f_bsize = S_BLKSIZE;
 229         sbp->f_frsize = 0;
 230         sbp->f_blocks = 0;
 231         sbp->f_bfree = 0;
 232         sbp->f_bavail = 0;
 233         sbp->f_files = 0;
 234         sbp->f_ffree = 0;
 235
 236         return (0);
 237 }
 238
 239 static struct vfsops autofs_vfsops = {
 240         .vfs_mount =            autofs_mount,
 241         .vfs_unmount =          autofs_unmount,
 242         .vfs_root =             autofs_root,
 243         .vfs_statfs =           autofs_statfs,
 244         .vfs_statvfs =          autofs_statvfs,
 245         .vfs_init =             autofs_init,
 246         .vfs_uninit =           autofs_uninit,
 247 #if 0
 248         .vfs_vptofh =           NULL,
 249         .vfs_fhtovp =           NULL,
 250         .vfs_checkexp =         NULL,
 251 #endif
 252 };
 253
 254 VFS_SET(autofs_vfsops, autofs, VFCF_SYNTHETIC | VFCF_NETWORK);
 255 MODULE_VERSION(autofs, 1);