autofs_vfsops.c revision 270897
1/*- 2 * Copyright (c) 2014 The FreeBSD Foundation 3 * All rights reserved. 4 * 5 * This software was developed by Edward Tomasz Napierala under sponsorship 6 * from the FreeBSD Foundation. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 */ 30 31#include <sys/cdefs.h> 32 __FBSDID("$FreeBSD: stable/10/sys/fs/autofs/autofs_vfsops.c 270897 2014-08-31 21:48:12Z trasz $"); 33 34#include <sys/param.h> 35#include <sys/systm.h> 36#include <sys/conf.h> 37#include <sys/condvar.h> 38#include <sys/ioccom.h> 39#include <sys/kernel.h> 40#include <sys/module.h> 41#include <sys/mount.h> 42#include <sys/sx.h> 43#include <sys/vnode.h> 44 45#include "autofs.h" 46 47static const char *autofs_opts[] = { 48 "from", "master_options", "master_prefix", NULL 49}; 50 51extern struct autofs_softc *sc; 52 53static int 54autofs_mount(struct mount *mp) 55{ 56 struct autofs_mount *amp; 57 char *from, *fspath, *options, *prefix; 58 int error; 59 60 if (vfs_filteropt(mp->mnt_optnew, autofs_opts)) 61 return (EINVAL); 62 63 if (mp->mnt_flag & MNT_UPDATE) 64 return (0); 65 66 if (vfs_getopt(mp->mnt_optnew, "from", (void **)&from, NULL)) 67 return (EINVAL); 68 69 if (vfs_getopt(mp->mnt_optnew, "fspath", (void **)&fspath, NULL)) 70 return (EINVAL); 71 72 if (vfs_getopt(mp->mnt_optnew, "master_options", (void **)&options, NULL)) 73 return (EINVAL); 74 75 if (vfs_getopt(mp->mnt_optnew, "master_prefix", (void **)&prefix, NULL)) 76 return (EINVAL); 77 78 amp = malloc(sizeof(*amp), M_AUTOFS, M_WAITOK | M_ZERO); 79 mp->mnt_data = amp; 80 amp->am_mp = mp; 81 amp->am_softc = sc; 82 strlcpy(amp->am_from, from, sizeof(amp->am_from)); 83 strlcpy(amp->am_mountpoint, fspath, sizeof(amp->am_mountpoint)); 84 strlcpy(amp->am_options, options, sizeof(amp->am_options)); 85 strlcpy(amp->am_prefix, prefix, sizeof(amp->am_prefix)); 86 sx_init(&->am_lock, "autofslk"); 87 amp->am_last_fileno = 1; 88 89 vfs_getnewfsid(mp); 90 91 AUTOFS_LOCK(amp); 92 error = autofs_node_new(NULL, amp, ".", -1, &->am_root); 93 if (error != 0) { 94 AUTOFS_UNLOCK(amp); 95 free(amp, M_AUTOFS); 96 return (error); 97 } 98 AUTOFS_UNLOCK(amp); 99 100 vfs_mountedfrom(mp, from); 101 102 return (0); 103} 104 105static int 106autofs_unmount(struct mount *mp, int mntflags) 107{ 108 struct autofs_mount *amp; 109 struct autofs_node *anp; 110 struct autofs_request *ar; 111 int error, flags; 112 bool found; 113 114 amp = VFSTOAUTOFS(mp); 115 116 flags = 0; 117 if (mntflags & MNT_FORCE) 118 flags |= FORCECLOSE; 119 error = vflush(mp, 0, flags, curthread); 120 if (error != 0) { 121 AUTOFS_WARN("vflush failed with error %d", error); 122 return (error); 123 } 124 125 /* 126 * All vnodes are gone, and new one will not appear - so, 127 * no new triggerings. We can iterate over outstanding 128 * autofs_requests and terminate them. 129 */ 130 for (;;) { 131 found = false; 132 sx_xlock(&sc->sc_lock); 133 TAILQ_FOREACH(ar, &sc->sc_requests, ar_next) { 134 if (ar->ar_mount != amp) 135 continue; 136 ar->ar_error = ENXIO; 137 ar->ar_done = true; 138 ar->ar_in_progress = false; 139 found = true; 140 } 141 sx_xunlock(&sc->sc_lock); 142 if (found == false) 143 break; 144 145 cv_broadcast(&sc->sc_cv); 146 pause("autofs_umount", 1); 147 } 148 149 AUTOFS_LOCK(amp); 150 151 /* 152 * Not terribly efficient, but at least not recursive. 153 */ 154 while (!TAILQ_EMPTY(&->am_root->an_children)) { 155 anp = TAILQ_FIRST(&->am_root->an_children); 156 while (!TAILQ_EMPTY(&anp->an_children)) 157 anp = TAILQ_FIRST(&anp->an_children); 158 autofs_node_delete(anp); 159 } 160 autofs_node_delete(amp->am_root); 161 162 mp->mnt_data = NULL; 163 AUTOFS_UNLOCK(amp); 164 165 sx_destroy(&->am_lock); 166 167 free(amp, M_AUTOFS); 168 169 return (0); 170} 171 172static int 173autofs_root(struct mount *mp, int flags, struct vnode **vpp) 174{ 175 struct autofs_mount *amp; 176 int error; 177 178 amp = VFSTOAUTOFS(mp); 179 180 error = autofs_node_vn(amp->am_root, mp, vpp); 181 182 return (error); 183} 184 185static int 186autofs_statfs(struct mount *mp, struct statfs *sbp) 187{ 188 189 sbp->f_bsize = 512; 190 sbp->f_iosize = 0; 191 sbp->f_blocks = 0; 192 sbp->f_bfree = 0; 193 sbp->f_bavail = 0; 194 sbp->f_files = 0; 195 sbp->f_ffree = 0; 196 197 return (0); 198} 199 200static struct vfsops autofs_vfsops = { 201 .vfs_fhtovp = NULL, /* XXX */ 202 .vfs_mount = autofs_mount, 203 .vfs_unmount = autofs_unmount, 204 .vfs_root = autofs_root, 205 .vfs_statfs = autofs_statfs, 206 .vfs_init = autofs_init, 207 .vfs_uninit = autofs_uninit, 208}; 209 210VFS_SET(autofs_vfsops, autofs, VFCF_SYNTHETIC | VFCF_NETWORK); 211MODULE_VERSION(autofs, 1); 212