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 char buf[MAXPATHLEN]; 51 int error; 52 53 if (mp->mnt_flag & MNT_UPDATE) { 54 autofs_flush(VFSTOAUTOFS(mp)); 55 return (0); 56 } 57 58 error = copyin(data, &info, sizeof(info)); 59 if (error) 60 return (error); 61 62 memset(sbp->f_mntfromname, 0, sizeof(sbp->f_mntfromname)); 63 error = copyinstr(info.from, sbp->f_mntfromname, 64 sizeof(sbp->f_mntfromname), NULL); 65 if (error) 66 return (error); 67 68 memset(sbp->f_mntonname, 0, sizeof(sbp->f_mntonname)); 69 error = copyinstr(mntpt, sbp->f_mntonname, 70 sizeof(sbp->f_mntonname), NULL); 71 if (error) 72 return (error); 73 74 amp = kmalloc(sizeof(*amp), M_AUTOFS, M_WAITOK | M_ZERO); 75 mp->mnt_data = (qaddr_t)amp; 76 amp->am_mp = mp; 77 strlcpy(amp->am_from, sbp->f_mntfromname, sizeof(amp->am_from)); 78 strlcpy(amp->am_on, sbp->f_mntonname, sizeof(amp->am_on)); 79 80 memset(buf, 0, sizeof(buf)); 81 error = copyinstr(info.master_options, buf, sizeof(buf), NULL); 82 if (error) 83 goto fail; 84 strlcpy(amp->am_options, buf, sizeof(amp->am_options)); 85 86 memset(buf, 0, sizeof(buf)); 87 error = copyinstr(info.master_prefix, buf, sizeof(buf), NULL); 88 if (error) 89 goto fail; 90 strlcpy(amp->am_prefix, buf, sizeof(amp->am_prefix)); 91 92 lockinit(&->am_lock, "autofsmnlk", 0, 0); 93 amp->am_last_ino = AUTOFS_ROOTINO; 94 95 vfs_getnewfsid(mp); 96 vfs_add_vnodeops(mp, &autofs_vnode_vops, &mp->mnt_vn_norm_ops); 97 98 lockmgr(&->am_lock, LK_EXCLUSIVE); 99 error = autofs_node_new(NULL, amp, ".", -1, &->am_root); 100 lockmgr(&->am_lock, LK_RELEASE); 101 KKASSERT(error == 0); 102 KKASSERT(amp->am_root->an_ino == AUTOFS_ROOTINO); 103 104 autofs_statfs(mp, sbp, cred); 105 106 return (0); 107 108 fail: 109 kfree(amp, M_AUTOFS); 110 return (error); 111 } 112 113 static int 114 autofs_unmount(struct mount *mp, int mntflags) 115 { 116 struct autofs_mount *amp = VFSTOAUTOFS(mp); 117 struct autofs_node *anp; 118 struct autofs_request *ar; 119 int error, flags, dummy; 120 bool found; 121 122 flags = 0; 123 if (mntflags & MNT_FORCE) 124 flags |= FORCECLOSE; 125 error = vflush(mp, 0, flags); 126 if (error) { 127 AUTOFS_WARN("vflush failed with error %d", error); 128 return (error); 129 } 130 131 /* 132 * All vnodes are gone, and new one will not appear - so, 133 * no new triggerings. 134 */ 135 for (;;) { 136 found = false; 137 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE); 138 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) { 139 if (ar->ar_mount != amp) 140 continue; 141 ar->ar_error = ENXIO; 142 ar->ar_done = true; 143 ar->ar_in_progress = false; 144 found = true; 145 } 146 if (found == false) { 147 lockmgr(&autofs_softc->sc_lock, LK_RELEASE); 148 break; 149 } 150 151 cv_broadcast(&autofs_softc->sc_cv); 152 lockmgr(&autofs_softc->sc_lock, LK_RELEASE); 153 154 tsleep(&dummy, 0, "autofs_umount", hz); 155 } 156 157 lockmgr(&->am_lock, LK_EXCLUSIVE); 158 while (!RB_EMPTY(&->am_root->an_children)) { 159 anp = RB_MIN(autofs_node_tree, &->am_root->an_children); 160 autofs_node_delete(anp); 161 } 162 autofs_node_delete(amp->am_root); 163 mp->mnt_data = NULL; 164 lockmgr(&->am_lock, LK_RELEASE); 165 166 lockuninit(&->am_lock); 167 168 kfree(amp, M_AUTOFS); 169 170 return (0); 171 } 172 173 static int 174 autofs_root(struct mount *mp, struct vnode **vpp) 175 { 176 struct autofs_mount *amp = VFSTOAUTOFS(mp); 177 int error; 178 179 if (amp->am_root == NULL) { 180 AUTOFS_FATAL("called without root node %p", mp); 181 print_backtrace(-1); 182 *vpp = NULL; 183 error = EINVAL; 184 } else { 185 error = autofs_node_vn(amp->am_root, mp, LK_EXCLUSIVE, vpp); 186 (*vpp)->v_flag |= VROOT; 187 KKASSERT((*vpp)->v_type == VDIR); 188 } 189 190 return (error); 191 } 192 193 static int 194 autofs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred) 195 { 196 sbp->f_bsize = S_BLKSIZE; 197 sbp->f_iosize = 0; 198 sbp->f_blocks = 0; 199 sbp->f_bfree = 0; 200 sbp->f_bavail = 0; 201 sbp->f_files = 0; 202 sbp->f_ffree = 0; 203 204 return (0); 205 } 206 207 static int 208 autofs_statvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred) 209 { 210 sbp->f_bsize = S_BLKSIZE; 211 sbp->f_frsize = 0; 212 sbp->f_blocks = 0; 213 sbp->f_bfree = 0; 214 sbp->f_bavail = 0; 215 sbp->f_files = 0; 216 sbp->f_ffree = 0; 217 218 return (0); 219 } 220 221 static struct vfsops autofs_vfsops = { 222 .vfs_mount = autofs_mount, 223 .vfs_unmount = autofs_unmount, 224 .vfs_root = autofs_root, 225 .vfs_statfs = autofs_statfs, 226 .vfs_statvfs = autofs_statvfs, 227 .vfs_init = autofs_init, 228 .vfs_uninit = autofs_uninit, 229 #if 0 230 .vfs_vptofh = NULL, 231 .vfs_fhtovp = NULL, 232 .vfs_checkexp = NULL, 233 #endif 234 }; 235 236 VFS_SET(autofs_vfsops, autofs, VFCF_SYNTHETIC | VFCF_NETWORK); 237 MODULE_VERSION(autofs, 1); 238