opensolaris_vfs.c revision 299068
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: releng/10.1/sys/cddl/compat/opensolaris/kern/opensolaris_vfs.c 299068 2016-05-04 15:27:09Z delphij $"); 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 /* 125 * Be ultra-paranoid about making sure the type and fspath 126 * variables will fit in our mp buffers, including the 127 * terminating NUL. 128 */ 129 if (strlen(fstype) >= MFSNAMELEN || strlen(fspath) >= MNAMELEN) 130 return (ENAMETOOLONG); 131 132 vfsp = vfs_byname_kld(fstype, td, &error); 133 if (vfsp == NULL) 134 return (ENODEV); 135 136 vp = *vpp; 137 if (vp->v_type != VDIR) 138 return (ENOTDIR); 139 /* 140 * We need vnode lock to protect v_mountedhere and vnode interlock 141 * to protect v_iflag. 142 */ 143 vn_lock(vp, LK_SHARED | LK_RETRY); 144 VI_LOCK(vp); 145 if ((vp->v_iflag & VI_MOUNT) != 0 || vp->v_mountedhere != NULL) { 146 VI_UNLOCK(vp); 147 VOP_UNLOCK(vp, 0); 148 return (EBUSY); 149 } 150 vp->v_iflag |= VI_MOUNT; 151 VI_UNLOCK(vp); 152 VOP_UNLOCK(vp, 0); 153 154 /* 155 * Allocate and initialize the filesystem. 156 * We don't want regular user that triggered snapshot mount to be able 157 * to unmount it, so pass credentials of the parent mount. 158 */ 159 mp = vfs_mount_alloc(vp, vfsp, fspath, vp->v_mount->mnt_cred); 160 161 mp->mnt_optnew = NULL; 162 vfs_setmntopt(mp, "from", fspec, 0); 163 mp->mnt_optnew = mp->mnt_opt; 164 mp->mnt_opt = NULL; 165 166 /* 167 * Set the mount level flags. 168 */ 169 mp->mnt_flag = fsflags & MNT_UPDATEMASK; 170 /* 171 * Snapshots are always read-only. 172 */ 173 mp->mnt_flag |= MNT_RDONLY; 174 /* 175 * We don't want snapshots to allow access to vulnerable setuid 176 * programs, so we turn off setuid when mounting snapshots. 177 */ 178 mp->mnt_flag |= MNT_NOSUID; 179 /* 180 * We don't want snapshots to be visible in regular 181 * mount(8) and df(1) output. 182 */ 183 mp->mnt_flag |= MNT_IGNORE; 184 /* 185 * XXX: This is evil, but we can't mount a snapshot as a regular user. 186 * XXX: Is is safe when snapshot is mounted from within a jail? 187 */ 188 cr = td->td_ucred; 189 td->td_ucred = kcred; 190 error = VFS_MOUNT(mp); 191 td->td_ucred = cr; 192 193 if (error != 0) { 194 VI_LOCK(vp); 195 vp->v_iflag &= ~VI_MOUNT; 196 VI_UNLOCK(vp); 197 vrele(vp); 198 vfs_unbusy(mp); 199 vfs_freeopts(mp->mnt_optnew); 200 vfs_mount_destroy(mp); 201 *vpp = NULL; 202 return (error); 203 } 204 205 if (mp->mnt_opt != NULL) 206 vfs_freeopts(mp->mnt_opt); 207 mp->mnt_opt = mp->mnt_optnew; 208 (void)VFS_STATFS(mp, &mp->mnt_stat); 209 210 /* 211 * Prevent external consumers of mount options from reading 212 * mnt_optnew. 213 */ 214 mp->mnt_optnew = NULL; 215 216 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 217#ifdef FREEBSD_NAMECACHE 218 cache_purge(vp); 219#endif 220 VI_LOCK(vp); 221 vp->v_iflag &= ~VI_MOUNT; 222 VI_UNLOCK(vp); 223 224 vp->v_mountedhere = mp; 225 /* Put the new filesystem on the mount list. */ 226 mtx_lock(&mountlist_mtx); 227 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); 228 mtx_unlock(&mountlist_mtx); 229 vfs_event_signal(NULL, VQ_MOUNT, 0); 230 if (VFS_ROOT(mp, LK_EXCLUSIVE, &mvp)) 231 panic("mount: lost mount"); 232 vput(vp); 233 vfs_unbusy(mp); 234 *vpp = mvp; 235 return (0); 236} 237