sys/cddl/compat/opensolaris/kern/opensolaris_vfs.c

   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/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
  40 MALLOC_DECLARE(M_MOUNT);
  41
  42 void
  43 vfs_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
  90 void
  91 vfs_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
 102 int
 103 vfs_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
 114 int
 115 mount_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_mount_destroy(mp);
 200                 *vpp = NULL;
 201                 return (error);
 202         }
 203
 204         if (mp->mnt_opt != NULL)
 205                 vfs_freeopts(mp->mnt_opt);
 206         mp->mnt_opt = mp->mnt_optnew;
 207         (void)VFS_STATFS(mp, &mp->mnt_stat);
 208
 209         /*
 210          * Prevent external consumers of mount options from reading
 211          * mnt_optnew.
 212         */
 213         mp->mnt_optnew = NULL;
 214
 215         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 216 #ifdef FREEBSD_NAMECACHE
 217         cache_purge(vp);
 218 #endif
 219         VI_LOCK(vp);
 220         vp->v_iflag &= ~VI_MOUNT;
 221         VI_UNLOCK(vp);
 222
 223         vp->v_mountedhere = mp;
 224         /* Put the new filesystem on the mount list. */
 225         mtx_lock(&mountlist_mtx);
 226         TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
 227         mtx_unlock(&mountlist_mtx);
 228         vfs_event_signal(NULL, VQ_MOUNT, 0);
 229         if (VFS_ROOT(mp, LK_EXCLUSIVE, &mvp))
 230                 panic("mount: lost mount");
 231         vput(vp);
 232         vfs_unbusy(mp);
 233         *vpp = mvp;
 234         return (0);
 235 }