opensolaris_vfs.c revision 315844
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: stable/10/sys/cddl/compat/opensolaris/kern/opensolaris_vfs.c 315844 2017-03-23 08:16:29Z avg $"); 29 30#include <sys/param.h> 31#include <sys/kernel.h> 32#include <sys/systm.h> 33#include <sys/malloc.h> 34#include <sys/mount.h> 35#include <sys/cred.h> 36#include <sys/vfs.h> 37#include <sys/priv.h> 38#include <sys/libkern.h> 39 40MALLOC_DECLARE(M_MOUNT); 41 42void 43vfs_setmntopt(vfs_t *vfsp, const char *name, const char *arg, 44 int flags __unused) 45{ 46 struct vfsopt *opt; 47 size_t namesize; 48 int locked; 49 50 if (!(locked = mtx_owned(MNT_MTX(vfsp)))) 51 MNT_ILOCK(vfsp); 52 53 if (vfsp->mnt_opt == NULL) { 54 void *opts; 55 56 MNT_IUNLOCK(vfsp); 57 opts = malloc(sizeof(*vfsp->mnt_opt), M_MOUNT, M_WAITOK); 58 MNT_ILOCK(vfsp); 59 if (vfsp->mnt_opt == NULL) { 60 vfsp->mnt_opt = opts; 61 TAILQ_INIT(vfsp->mnt_opt); 62 } else { 63 free(opts, M_MOUNT); 64 } 65 } 66 67 MNT_IUNLOCK(vfsp); 68 69 opt = malloc(sizeof(*opt), M_MOUNT, M_WAITOK); 70 namesize = strlen(name) + 1; 71 opt->name = malloc(namesize, M_MOUNT, M_WAITOK); 72 strlcpy(opt->name, name, namesize); 73 opt->pos = -1; 74 opt->seen = 1; 75 if (arg == NULL) { 76 opt->value = NULL; 77 opt->len = 0; 78 } else { 79 opt->len = strlen(arg) + 1; 80 opt->value = malloc(opt->len, M_MOUNT, M_WAITOK); 81 bcopy(arg, opt->value, opt->len); 82 } 83 84 MNT_ILOCK(vfsp); 85 TAILQ_INSERT_TAIL(vfsp->mnt_opt, opt, link); 86 if (!locked) 87 MNT_IUNLOCK(vfsp); 88} 89 90void 91vfs_clearmntopt(vfs_t *vfsp, const char *name) 92{ 93 int locked; 94 95 if (!(locked = mtx_owned(MNT_MTX(vfsp)))) 96 MNT_ILOCK(vfsp); 97 vfs_deleteopt(vfsp->mnt_opt, name); 98 if (!locked) 99 MNT_IUNLOCK(vfsp); 100} 101 102int 103vfs_optionisset(const vfs_t *vfsp, const char *opt, char **argp) 104{ 105 struct vfsoptlist *opts = vfsp->mnt_optnew; 106 int error; 107 108 if (opts == NULL) 109 return (0); 110 error = vfs_getopt(opts, opt, (void **)argp, NULL); 111 return (error != 0 ? 0 : 1); 112} 113 114int 115mount_snapshot(kthread_t *td, vnode_t **vpp, const char *fstype, char *fspath, 116 char *fspec, int fsflags) 117{ 118 struct vfsconf *vfsp; 119 struct mount *mp; 120 vnode_t *vp, *mvp; 121 struct ucred *cr; 122 int error; 123 124 ASSERT_VOP_ELOCKED(*vpp, "mount_snapshot"); 125 126 vp = *vpp; 127 *vpp = NULL; 128 error = 0; 129 130 /* 131 * Be ultra-paranoid about making sure the type and fspath 132 * variables will fit in our mp buffers, including the 133 * terminating NUL. 134 */ 135 if (strlen(fstype) >= MFSNAMELEN || strlen(fspath) >= MNAMELEN) 136 error = ENAMETOOLONG; 137 if (error == 0 && (vfsp = vfs_byname_kld(fstype, td, &error)) == NULL) 138 error = ENODEV; 139 if (error == 0 && vp->v_type != VDIR) 140 error = ENOTDIR; 141 /* 142 * We need vnode lock to protect v_mountedhere and vnode interlock 143 * to protect v_iflag. 144 */ 145 if (error == 0) { 146 VI_LOCK(vp); 147 if ((vp->v_iflag & VI_MOUNT) == 0 && vp->v_mountedhere == NULL) 148 vp->v_iflag |= VI_MOUNT; 149 else 150 error = EBUSY; 151 VI_UNLOCK(vp); 152 } 153 if (error != 0) { 154 vput(vp); 155 return (error); 156 } 157 VOP_UNLOCK(vp, 0); 158 159 /* 160 * Allocate and initialize the filesystem. 161 * We don't want regular user that triggered snapshot mount to be able 162 * to unmount it, so pass credentials of the parent mount. 163 */ 164 mp = vfs_mount_alloc(vp, vfsp, fspath, vp->v_mount->mnt_cred); 165 166 mp->mnt_optnew = NULL; 167 vfs_setmntopt(mp, "from", fspec, 0); 168 mp->mnt_optnew = mp->mnt_opt; 169 mp->mnt_opt = NULL; 170 171 /* 172 * Set the mount level flags. 173 */ 174 mp->mnt_flag = fsflags & MNT_UPDATEMASK; 175 /* 176 * Snapshots are always read-only. 177 */ 178 mp->mnt_flag |= MNT_RDONLY; 179 /* 180 * We don't want snapshots to allow access to vulnerable setuid 181 * programs, so we turn off setuid when mounting snapshots. 182 */ 183 mp->mnt_flag |= MNT_NOSUID; 184 /* 185 * We don't want snapshots to be visible in regular 186 * mount(8) and df(1) output. 187 */ 188 mp->mnt_flag |= MNT_IGNORE; 189 /* 190 * XXX: This is evil, but we can't mount a snapshot as a regular user. 191 * XXX: Is is safe when snapshot is mounted from within a jail? 192 */ 193 cr = td->td_ucred; 194 td->td_ucred = kcred; 195 error = VFS_MOUNT(mp); 196 td->td_ucred = cr; 197 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 vput(vp); 210 vfs_unbusy(mp); 211 vfs_freeopts(mp->mnt_optnew); 212 vfs_mount_destroy(mp); 213 return (error); 214 } 215 216 if (mp->mnt_opt != NULL) 217 vfs_freeopts(mp->mnt_opt); 218 mp->mnt_opt = mp->mnt_optnew; 219 (void)VFS_STATFS(mp, &mp->mnt_stat); 220 221 /* 222 * Prevent external consumers of mount options from reading 223 * mnt_optnew. 224 */ 225 mp->mnt_optnew = NULL; 226 227 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 228#ifdef FREEBSD_NAMECACHE 229 cache_purge(vp); 230#endif 231 VI_LOCK(vp); 232 vp->v_iflag &= ~VI_MOUNT; 233 VI_UNLOCK(vp); 234 235 vp->v_mountedhere = mp; 236 /* Put the new filesystem on the mount list. */ 237 mtx_lock(&mountlist_mtx); 238 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); 239 mtx_unlock(&mountlist_mtx); 240 vfs_event_signal(NULL, VQ_MOUNT, 0); 241 if (VFS_ROOT(mp, LK_EXCLUSIVE, &mvp)) 242 panic("mount: lost mount"); 243 VOP_UNLOCK(vp, 0); 244 vfs_unbusy(mp); 245 *vpp = mvp; 246 return (0); 247} 248