1 /* 2 * Copyright (c) 2006-2007 Pawel Jakub Dawidek <pjd@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/types.h> 31 #include <sys/param.h> 32 #include <sys/kernel.h> 33 #include <sys/systm.h> 34 #include <sys/malloc.h> 35 #include <sys/mount.h> 36 #include <sys/cred.h> 37 #include <sys/vfs.h> 38 #include <sys/priv.h> 39 #include <sys/libkern.h> 40 41 #include <sys/mutex.h> 42 #include <sys/vnode.h> 43 #include <sys/taskq.h> 44 45 #include <sys/ccompat.h> 46 47 MALLOC_DECLARE(M_MOUNT); 48 49 void 50 vfs_setmntopt(vfs_t *vfsp, const char *name, const char *arg, 51 int flags __unused) 52 { 53 struct vfsopt *opt; 54 size_t namesize; 55 int locked; 56 57 if (!(locked = mtx_owned(MNT_MTX(vfsp)))) 58 MNT_ILOCK(vfsp); 59 60 if (vfsp->mnt_opt == NULL) { 61 void *opts; 62 63 MNT_IUNLOCK(vfsp); 64 opts = malloc(sizeof (*vfsp->mnt_opt), M_MOUNT, M_WAITOK); 65 MNT_ILOCK(vfsp); 66 if (vfsp->mnt_opt == NULL) { 67 vfsp->mnt_opt = opts; 68 TAILQ_INIT(vfsp->mnt_opt); 69 } else { 70 free(opts, M_MOUNT); 71 } 72 } 73 74 MNT_IUNLOCK(vfsp); 75 76 opt = malloc(sizeof (*opt), M_MOUNT, M_WAITOK); 77 namesize = strlen(name) + 1; 78 opt->name = malloc(namesize, M_MOUNT, M_WAITOK); 79 strlcpy(opt->name, name, namesize); 80 opt->pos = -1; 81 opt->seen = 1; 82 if (arg == NULL) { 83 opt->value = NULL; 84 opt->len = 0; 85 } else { 86 opt->len = strlen(arg) + 1; 87 opt->value = malloc(opt->len, M_MOUNT, M_WAITOK); 88 memcpy(opt->value, arg, opt->len); 89 } 90 91 MNT_ILOCK(vfsp); 92 TAILQ_INSERT_TAIL(vfsp->mnt_opt, opt, link); 93 if (!locked) 94 MNT_IUNLOCK(vfsp); 95 } 96 97 void 98 vfs_clearmntopt(vfs_t *vfsp, const char *name) 99 { 100 int locked; 101 102 if (!(locked = mtx_owned(MNT_MTX(vfsp)))) 103 MNT_ILOCK(vfsp); 104 vfs_deleteopt(vfsp->mnt_opt, name); 105 if (!locked) 106 MNT_IUNLOCK(vfsp); 107 } 108 109 int 110 vfs_optionisset(const vfs_t *vfsp, const char *opt, char **argp) 111 { 112 struct vfsoptlist *opts = vfsp->mnt_optnew; 113 int error; 114 115 if (opts == NULL) 116 return (0); 117 error = vfs_getopt(opts, opt, (void **)argp, NULL); 118 return (error != 0 ? 0 : 1); 119 } 120 121 int 122 mount_snapshot(kthread_t *td, vnode_t **vpp, const char *fstype, char *fspath, 123 char *fspec, int fsflags) 124 { 125 struct vfsconf *vfsp; 126 struct mount *mp; 127 vnode_t *vp, *mvp; 128 int error; 129 130 ASSERT_VOP_ELOCKED(*vpp, "mount_snapshot"); 131 132 vp = *vpp; 133 *vpp = NULL; 134 error = 0; 135 136 /* 137 * Be ultra-paranoid about making sure the type and fspath 138 * variables will fit in our mp buffers, including the 139 * terminating NUL. 140 */ 141 if (strlen(fstype) >= MFSNAMELEN || strlen(fspath) >= MNAMELEN) 142 error = ENAMETOOLONG; 143 if (error == 0 && (vfsp = vfs_byname_kld(fstype, td, &error)) == NULL) 144 error = ENODEV; 145 if (error == 0 && vp->v_type != VDIR) 146 error = ENOTDIR; 147 /* 148 * We need vnode lock to protect v_mountedhere and vnode interlock 149 * to protect v_iflag. 150 */ 151 if (error == 0) { 152 VI_LOCK(vp); 153 if ((vp->v_iflag & VI_MOUNT) == 0 && vp->v_mountedhere == NULL) 154 vp->v_iflag |= VI_MOUNT; 155 else 156 error = EBUSY; 157 VI_UNLOCK(vp); 158 } 159 if (error != 0) { 160 vput(vp); 161 return (error); 162 } 163 vn_seqc_write_begin(vp); 164 VOP_UNLOCK1(vp); 165 166 /* 167 * Allocate and initialize the filesystem. 168 * We don't want regular user that triggered snapshot mount to be able 169 * to unmount it, so pass credentials of the parent mount. 170 */ 171 mp = vfs_mount_alloc(vp, vfsp, fspath, vp->v_mount->mnt_cred); 172 173 mp->mnt_optnew = NULL; 174 vfs_setmntopt(mp, "from", fspec, 0); 175 mp->mnt_optnew = mp->mnt_opt; 176 mp->mnt_opt = NULL; 177 178 /* 179 * Set the mount level flags. 180 */ 181 mp->mnt_flag = fsflags & MNT_UPDATEMASK; 182 /* 183 * Snapshots are always read-only. 184 */ 185 mp->mnt_flag |= MNT_RDONLY; 186 /* 187 * We don't want snapshots to allow access to vulnerable setuid 188 * programs, so we turn off setuid when mounting snapshots. 189 */ 190 mp->mnt_flag |= MNT_NOSUID; 191 /* 192 * We don't want snapshots to be visible in regular 193 * mount(8) and df(1) output. 194 */ 195 mp->mnt_flag |= MNT_IGNORE; 196 197 error = VFS_MOUNT(mp); 198 if (error != 0) { 199 /* 200 * Clear VI_MOUNT and decrement the use count "atomically", 201 * under the vnode lock. This is not strictly required, 202 * but makes it easier to reason about the life-cycle and 203 * ownership of the covered vnode. 204 */ 205 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 206 VI_LOCK(vp); 207 vp->v_iflag &= ~VI_MOUNT; 208 VI_UNLOCK(vp); 209 vn_seqc_write_end(vp); 210 vput(vp); 211 vfs_unbusy(mp); 212 vfs_freeopts(mp->mnt_optnew); 213 mp->mnt_vnodecovered = NULL; 214 vfs_mount_destroy(mp); 215 return (error); 216 } 217 218 if (mp->mnt_opt != NULL) 219 vfs_freeopts(mp->mnt_opt); 220 mp->mnt_opt = mp->mnt_optnew; 221 (void) VFS_STATFS(mp, &mp->mnt_stat); 222 223 /* 224 * Prevent external consumers of mount options from reading 225 * mnt_optnew. 226 */ 227 mp->mnt_optnew = NULL; 228 229 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 230 #ifdef FREEBSD_NAMECACHE 231 cache_purge(vp); 232 #endif 233 VI_LOCK(vp); 234 vp->v_iflag &= ~VI_MOUNT; 235 #ifdef VIRF_MOUNTPOINT 236 vn_irflag_set_locked(vp, VIRF_MOUNTPOINT); 237 #endif 238 vp->v_mountedhere = mp; 239 VI_UNLOCK(vp); 240 /* Put the new filesystem on the mount list. */ 241 mtx_lock(&mountlist_mtx); 242 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); 243 mtx_unlock(&mountlist_mtx); 244 vfs_event_signal(NULL, VQ_MOUNT, 0); 245 if (VFS_ROOT(mp, LK_EXCLUSIVE, &mvp)) 246 panic("mount: lost mount"); 247 vn_seqc_write_end(vp); 248 VOP_UNLOCK1(vp); 249 #if __FreeBSD_version >= 1300048 250 vfs_op_exit(mp); 251 #endif 252 vfs_unbusy(mp); 253 *vpp = mvp; 254 return (0); 255 } 256 257 /* 258 * Like vn_rele() except if we are going to call VOP_INACTIVE() then do it 259 * asynchronously using a taskq. This can avoid deadlocks caused by re-entering 260 * the file system as a result of releasing the vnode. Note, file systems 261 * already have to handle the race where the vnode is incremented before the 262 * inactive routine is called and does its locking. 263 * 264 * Warning: Excessive use of this routine can lead to performance problems. 265 * This is because taskqs throttle back allocation if too many are created. 266 */ 267 void 268 vn_rele_async(vnode_t *vp, taskq_t *taskq) 269 { 270 VERIFY3U(vp->v_usecount, >, 0); 271 if (refcount_release_if_not_last(&vp->v_usecount)) { 272 #if __FreeBSD_version < 1300045 273 vdrop(vp); 274 #endif 275 return; 276 } 277 VERIFY3U(taskq_dispatch((taskq_t *)taskq, 278 (task_func_t *)vrele, vp, TQ_SLEEP), !=, 0); 279 } 280