sys/kern/vfs_mount.c

   1 /*-
   2  * Copyright (c) 1999-2004 Poul-Henning Kamp
   3  * Copyright (c) 1999 Michael Smith
   4  * Copyright (c) 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 #include <sys/param.h>
  41 #include <sys/conf.h>
  42 #include <sys/fcntl.h>
  43 #include <sys/jail.h>
  44 #include <sys/kernel.h>
  45 #include <sys/libkern.h>
  46 #include <sys/malloc.h>
  47 #include <sys/mount.h>
  48 #include <sys/mutex.h>
  49 #include <sys/namei.h>
  50 #include <sys/priv.h>
  51 #include <sys/proc.h>
  52 #include <sys/filedesc.h>
  53 #include <sys/reboot.h>
  54 #include <sys/sbuf.h>
  55 #include <sys/syscallsubr.h>
  56 #include <sys/sysproto.h>
  57 #include <sys/sx.h>
  58 #include <sys/sysctl.h>
  59 #include <sys/sysent.h>
  60 #include <sys/systm.h>
  61 #include <sys/vnode.h>
  62 #include <vm/uma.h>
  63
  64 #include <geom/geom.h>
  65
  66 #include <machine/stdarg.h>
  67
  68 #include <security/audit/audit.h>
  69 #include <security/mac/mac_framework.h>
  70
  71 #define VFS_MOUNTARG_SIZE_MAX   (1024 * 64)
  72
  73 static int      vfs_domount(struct thread *td, const char *fstype, char *fspath,
  74                     uint64_t fsflags, struct vfsoptlist **optlist);
  75 static void     free_mntarg(struct mntarg *ma);
  76
  77 static int      usermount = 0;
  78 SYSCTL_INT(_vfs, OID_AUTO, usermount, CTLFLAG_RW, &usermount, 0,
  79     "Unprivileged users may mount and unmount file systems");
  80
  81 static bool     default_autoro = false;
  82 SYSCTL_BOOL(_vfs, OID_AUTO, default_autoro, CTLFLAG_RW, &default_autoro, 0,
  83     "Retry failed r/w mount as r/o if no explicit ro/rw option is specified");
  84
  85 MALLOC_DEFINE(M_MOUNT, "mount", "vfs mount structure");
  86 MALLOC_DEFINE(M_STATFS, "statfs", "statfs structure");
  87 static uma_zone_t mount_zone;
  88
  89 /* List of mounted filesystems. */
  90 struct mntlist mountlist = TAILQ_HEAD_INITIALIZER(mountlist);
  91
  92 /* For any iteration/modification of mountlist */
  93 struct mtx mountlist_mtx;
  94 MTX_SYSINIT(mountlist, &mountlist_mtx, "mountlist", MTX_DEF);
  95
  96 /*
  97  * Global opts, taken by all filesystems
  98  */
  99 static const char *global_opts[] = {
 100         "errmsg",
 101         "fstype",
 102         "fspath",
 103         "ro",
 104         "rw",
 105         "nosuid",
 106         "noexec",
 107         NULL
 108 };
 109
 110 static int
 111 mount_init(void *mem, int size, int flags)
 112 {
 113         struct mount *mp;
 114
 115         mp = (struct mount *)mem;
 116         mtx_init(&mp->mnt_mtx, "struct mount mtx", NULL, MTX_DEF);
 117         lockinit(&mp->mnt_explock, PVFS, "explock", 0, 0);
 118         return (0);
 119 }
 120
 121 static void
 122 mount_fini(void *mem, int size)
 123 {
 124         struct mount *mp;
 125
 126         mp = (struct mount *)mem;
 127         lockdestroy(&mp->mnt_explock);
 128         mtx_destroy(&mp->mnt_mtx);
 129 }
 130
 131 static void
 132 vfs_mount_init(void *dummy __unused)
 133 {
 134
 135         mount_zone = uma_zcreate("Mountpoints", sizeof(struct mount), NULL,
 136             NULL, mount_init, mount_fini, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
 137 }
 138 SYSINIT(vfs_mount, SI_SUB_VFS, SI_ORDER_ANY, vfs_mount_init, NULL);
 139
 140 /*
 141  * ---------------------------------------------------------------------
 142  * Functions for building and sanitizing the mount options
 143  */
 144
 145 /* Remove one mount option. */
 146 static void
 147 vfs_freeopt(struct vfsoptlist *opts, struct vfsopt *opt)
 148 {
 149
 150         TAILQ_REMOVE(opts, opt, link);
 151         free(opt->name, M_MOUNT);
 152         if (opt->value != NULL)
 153                 free(opt->value, M_MOUNT);
 154         free(opt, M_MOUNT);
 155 }
 156
 157 /* Release all resources related to the mount options. */
 158 void
 159 vfs_freeopts(struct vfsoptlist *opts)
 160 {
 161         struct vfsopt *opt;
 162
 163         while (!TAILQ_EMPTY(opts)) {
 164                 opt = TAILQ_FIRST(opts);
 165                 vfs_freeopt(opts, opt);
 166         }
 167         free(opts, M_MOUNT);
 168 }
 169
 170 void
 171 vfs_deleteopt(struct vfsoptlist *opts, const char *name)
 172 {
 173         struct vfsopt *opt, *temp;
 174
 175         if (opts == NULL)
 176                 return;
 177         TAILQ_FOREACH_SAFE(opt, opts, link, temp)  {
 178                 if (strcmp(opt->name, name) == 0)
 179                         vfs_freeopt(opts, opt);
 180         }
 181 }
 182
 183 static int
 184 vfs_isopt_ro(const char *opt)
 185 {
 186
 187         if (strcmp(opt, "ro") == 0 || strcmp(opt, "rdonly") == 0 ||
 188             strcmp(opt, "norw") == 0)
 189                 return (1);
 190         return (0);
 191 }
 192
 193 static int
 194 vfs_isopt_rw(const char *opt)
 195 {
 196
 197         if (strcmp(opt, "rw") == 0 || strcmp(opt, "noro") == 0)
 198                 return (1);
 199         return (0);
 200 }
 201
 202 /*
 203  * Check if options are equal (with or without the "no" prefix).
 204  */
 205 static int
 206 vfs_equalopts(const char *opt1, const char *opt2)
 207 {
 208         char *p;
 209
 210         /* "opt" vs. "opt" or "noopt" vs. "noopt" */
 211         if (strcmp(opt1, opt2) == 0)
 212                 return (1);
 213         /* "noopt" vs. "opt" */
 214         if (strncmp(opt1, "no", 2) == 0 && strcmp(opt1 + 2, opt2) == 0)
 215                 return (1);
 216         /* "opt" vs. "noopt" */
 217         if (strncmp(opt2, "no", 2) == 0 && strcmp(opt1, opt2 + 2) == 0)
 218                 return (1);
 219         while ((p = strchr(opt1, '.')) != NULL &&
 220             !strncmp(opt1, opt2, ++p - opt1)) {
 221                 opt2 += p - opt1;
 222                 opt1 = p;
 223                 /* "foo.noopt" vs. "foo.opt" */
 224                 if (strncmp(opt1, "no", 2) == 0 && strcmp(opt1 + 2, opt2) == 0)
 225                         return (1);
 226                 /* "foo.opt" vs. "foo.noopt" */
 227                 if (strncmp(opt2, "no", 2) == 0 && strcmp(opt1, opt2 + 2) == 0)
 228                         return (1);
 229         }
 230         /* "ro" / "rdonly" / "norw" / "rw" / "noro" */
 231         if ((vfs_isopt_ro(opt1) || vfs_isopt_rw(opt1)) &&
 232             (vfs_isopt_ro(opt2) || vfs_isopt_rw(opt2)))
 233                 return (1);
 234         return (0);
 235 }
 236
 237 /*
 238  * If a mount option is specified several times,
 239  * (with or without the "no" prefix) only keep
 240  * the last occurrence of it.
 241  */
 242 static void
 243 vfs_sanitizeopts(struct vfsoptlist *opts)
 244 {
 245         struct vfsopt *opt, *opt2, *tmp;
 246
 247         TAILQ_FOREACH_REVERSE(opt, opts, vfsoptlist, link) {
 248                 opt2 = TAILQ_PREV(opt, vfsoptlist, link);
 249                 while (opt2 != NULL) {
 250                         if (vfs_equalopts(opt->name, opt2->name)) {
 251                                 tmp = TAILQ_PREV(opt2, vfsoptlist, link);
 252                                 vfs_freeopt(opts, opt2);
 253                                 opt2 = tmp;
 254                         } else {
 255                                 opt2 = TAILQ_PREV(opt2, vfsoptlist, link);
 256                         }
 257                 }
 258         }
 259 }
 260
 261 /*
 262  * Build a linked list of mount options from a struct uio.
 263  */
 264 int
 265 vfs_buildopts(struct uio *auio, struct vfsoptlist **options)
 266 {
 267         struct vfsoptlist *opts;
 268         struct vfsopt *opt;
 269         size_t memused, namelen, optlen;
 270         unsigned int i, iovcnt;
 271         int error;
 272
 273         opts = malloc(sizeof(struct vfsoptlist), M_MOUNT, M_WAITOK);
 274         TAILQ_INIT(opts);
 275         memused = 0;
 276         iovcnt = auio->uio_iovcnt;
 277         for (i = 0; i < iovcnt; i += 2) {
 278                 namelen = auio->uio_iov[i].iov_len;
 279                 optlen = auio->uio_iov[i + 1].iov_len;
 280                 memused += sizeof(struct vfsopt) + optlen + namelen;
 281                 /*
 282                  * Avoid consuming too much memory, and attempts to overflow
 283                  * memused.
 284                  */
 285                 if (memused > VFS_MOUNTARG_SIZE_MAX ||
 286                     optlen > VFS_MOUNTARG_SIZE_MAX ||
 287                     namelen > VFS_MOUNTARG_SIZE_MAX) {
 288                         error = EINVAL;
 289                         goto bad;
 290                 }
 291
 292                 opt = malloc(sizeof(struct vfsopt), M_MOUNT, M_WAITOK);
 293                 opt->name = malloc(namelen, M_MOUNT, M_WAITOK);
 294                 opt->value = NULL;
 295                 opt->len = 0;
 296                 opt->pos = i / 2;
 297                 opt->seen = 0;
 298
 299                 /*
 300                  * Do this early, so jumps to "bad" will free the current
 301                  * option.
 302                  */
 303                 TAILQ_INSERT_TAIL(opts, opt, link);
 304
 305                 if (auio->uio_segflg == UIO_SYSSPACE) {
 306                         bcopy(auio->uio_iov[i].iov_base, opt->name, namelen);
 307                 } else {
 308                         error = copyin(auio->uio_iov[i].iov_base, opt->name,
 309                             namelen);
 310                         if (error)
 311                                 goto bad;
 312                 }
 313                 /* Ensure names are null-terminated strings. */
 314                 if (namelen == 0 || opt->name[namelen - 1] != '\0') {
 315                         error = EINVAL;
 316                         goto bad;
 317                 }
 318                 if (optlen != 0) {
 319                         opt->len = optlen;
 320                         opt->value = malloc(optlen, M_MOUNT, M_WAITOK);
 321                         if (auio->uio_segflg == UIO_SYSSPACE) {
 322                                 bcopy(auio->uio_iov[i + 1].iov_base, opt->value,
 323                                     optlen);
 324                         } else {
 325                                 error = copyin(auio->uio_iov[i + 1].iov_base,
 326                                     opt->value, optlen);
 327                                 if (error)
 328                                         goto bad;
 329                         }
 330                 }
 331         }
 332         vfs_sanitizeopts(opts);
 333         *options = opts;
 334         return (0);
 335 bad:
 336         vfs_freeopts(opts);
 337         return (error);
 338 }
 339
 340 /*
 341  * Merge the old mount options with the new ones passed
 342  * in the MNT_UPDATE case.
 343  *
 344  * XXX: This function will keep a "nofoo" option in the new
 345  * options.  E.g, if the option's canonical name is "foo",
 346  * "nofoo" ends up in the mount point's active options.
 347  */
 348 static void
 349 vfs_mergeopts(struct vfsoptlist *toopts, struct vfsoptlist *oldopts)
 350 {
 351         struct vfsopt *opt, *new;
 352
 353         TAILQ_FOREACH(opt, oldopts, link) {
 354                 new = malloc(sizeof(struct vfsopt), M_MOUNT, M_WAITOK);
 355                 new->name = strdup(opt->name, M_MOUNT);
 356                 if (opt->len != 0) {
 357                         new->value = malloc(opt->len, M_MOUNT, M_WAITOK);
 358                         bcopy(opt->value, new->value, opt->len);
 359                 } else
 360                         new->value = NULL;
 361                 new->len = opt->len;
 362                 new->seen = opt->seen;
 363                 TAILQ_INSERT_HEAD(toopts, new, link);
 364         }
 365         vfs_sanitizeopts(toopts);
 366 }
 367
 368 /*
 369  * Mount a filesystem.
 370  */
 371 #ifndef _SYS_SYSPROTO_H_
 372 struct nmount_args {
 373         struct iovec *iovp;
 374         unsigned int iovcnt;
 375         int flags;
 376 };
 377 #endif
 378 int
 379 sys_nmount(struct thread *td, struct nmount_args *uap)
 380 {
 381         struct uio *auio;
 382         int error;
 383         u_int iovcnt;
 384         uint64_t flags;
 385
 386         /*
 387          * Mount flags are now 64-bits. On 32-bit archtectures only
 388          * 32-bits are passed in, but from here on everything handles
 389          * 64-bit flags correctly.
 390          */
 391         flags = uap->flags;
 392
 393         AUDIT_ARG_FFLAGS(flags);
 394         CTR4(KTR_VFS, "%s: iovp %p with iovcnt %d and flags %d", __func__,
 395             uap->iovp, uap->iovcnt, flags);
 396
 397         /*
 398          * Filter out MNT_ROOTFS.  We do not want clients of nmount() in
 399          * userspace to set this flag, but we must filter it out if we want
 400          * MNT_UPDATE on the root file system to work.
 401          * MNT_ROOTFS should only be set by the kernel when mounting its
 402          * root file system.
 403          */
 404         flags &= ~MNT_ROOTFS;
 405
 406         iovcnt = uap->iovcnt;
 407         /*
 408          * Check that we have an even number of iovec's
 409          * and that we have at least two options.
 410          */
 411         if ((iovcnt & 1) || (iovcnt < 4)) {
 412                 CTR2(KTR_VFS, "%s: failed for invalid iovcnt %d", __func__,
 413                     uap->iovcnt);
 414                 return (EINVAL);
 415         }
 416
 417         error = copyinuio(uap->iovp, iovcnt, &auio);
 418         if (error) {
 419                 CTR2(KTR_VFS, "%s: failed for invalid uio op with %d errno",
 420                     __func__, error);
 421                 return (error);
 422         }
 423         error = vfs_donmount(td, flags, auio);
 424
 425         free(auio, M_IOV);
 426         return (error);
 427 }
 428
 429 /*
 430  * ---------------------------------------------------------------------
 431  * Various utility functions
 432  */
 433
 434 void
 435 vfs_ref(struct mount *mp)
 436 {
 437
 438         CTR2(KTR_VFS, "%s: mp %p", __func__, mp);
 439         MNT_ILOCK(mp);
 440         MNT_REF(mp);
 441         MNT_IUNLOCK(mp);
 442 }
 443
 444 void
 445 vfs_rel(struct mount *mp)
 446 {
 447
 448         CTR2(KTR_VFS, "%s: mp %p", __func__, mp);
 449         MNT_ILOCK(mp);
 450         MNT_REL(mp);
 451         MNT_IUNLOCK(mp);
 452 }
 453
 454 /*
 455  * Allocate and initialize the mount point struct.
 456  */
 457 struct mount *
 458 vfs_mount_alloc(struct vnode *vp, struct vfsconf *vfsp, const char *fspath,
 459     struct ucred *cred)
 460 {
 461         struct mount *mp;
 462
 463         mp = uma_zalloc(mount_zone, M_WAITOK);
 464         bzero(&mp->mnt_startzero,
 465             __rangeof(struct mount, mnt_startzero, mnt_endzero));
 466         TAILQ_INIT(&mp->mnt_nvnodelist);
 467         mp->mnt_nvnodelistsize = 0;
 468         TAILQ_INIT(&mp->mnt_activevnodelist);
 469         mp->mnt_activevnodelistsize = 0;
 470         mp->mnt_ref = 0;
 471         (void) vfs_busy(mp, MBF_NOWAIT);
 472         atomic_add_acq_int(&vfsp->vfc_refcount, 1);
 473         mp->mnt_op = vfsp->vfc_vfsops;
 474         mp->mnt_vfc = vfsp;
 475         mp->mnt_stat.f_type = vfsp->vfc_typenum;
 476         mp->mnt_gen++;
 477         strlcpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
 478         mp->mnt_vnodecovered = vp;
 479         mp->mnt_cred = crdup(cred);
 480         mp->mnt_stat.f_owner = cred->cr_uid;
 481         strlcpy(mp->mnt_stat.f_mntonname, fspath, MNAMELEN);
 482         mp->mnt_iosize_max = DFLTPHYS;
 483 #ifdef MAC
 484         mac_mount_init(mp);
 485         mac_mount_create(cred, mp);
 486 #endif
 487         arc4rand(&mp->mnt_hashseed, sizeof mp->mnt_hashseed, 0);
 488         TAILQ_INIT(&mp->mnt_uppers);
 489         return (mp);
 490 }
 491
 492 /*
 493  * Destroy the mount struct previously allocated by vfs_mount_alloc().
 494  */
 495 void
 496 vfs_mount_destroy(struct mount *mp)
 497 {
 498
 499         MNT_ILOCK(mp);
 500         mp->mnt_kern_flag |= MNTK_REFEXPIRE;
 501         if (mp->mnt_kern_flag & MNTK_MWAIT) {
 502                 mp->mnt_kern_flag &= ~MNTK_MWAIT;
 503                 wakeup(mp);
 504         }
 505         while (mp->mnt_ref)
 506                 msleep(mp, MNT_MTX(mp), PVFS, "mntref", 0);
 507         KASSERT(mp->mnt_ref == 0,
 508             ("%s: invalid refcount in the drain path @ %s:%d", __func__,
 509             __FILE__, __LINE__));
 510         if (mp->mnt_writeopcount != 0)
 511                 panic("vfs_mount_destroy: nonzero writeopcount");
 512         if (mp->mnt_secondary_writes != 0)
 513                 panic("vfs_mount_destroy: nonzero secondary_writes");
 514         atomic_subtract_rel_int(&mp->mnt_vfc->vfc_refcount, 1);
 515         if (!TAILQ_EMPTY(&mp->mnt_nvnodelist)) {
 516                 struct vnode *vp;
 517
 518                 TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes)
 519                         vn_printf(vp, "dangling vnode ");
 520                 panic("unmount: dangling vnode");
 521         }
 522         KASSERT(TAILQ_EMPTY(&mp->mnt_uppers), ("mnt_uppers"));
 523         if (mp->mnt_nvnodelistsize != 0)
 524                 panic("vfs_mount_destroy: nonzero nvnodelistsize");
 525         if (mp->mnt_activevnodelistsize != 0)
 526                 panic("vfs_mount_destroy: nonzero activevnodelistsize");
 527         if (mp->mnt_lockref != 0)
 528                 panic("vfs_mount_destroy: nonzero lock refcount");
 529         MNT_IUNLOCK(mp);
 530         if (mp->mnt_vnodecovered != NULL)
 531                 vrele(mp->mnt_vnodecovered);
 532 #ifdef MAC
 533         mac_mount_destroy(mp);
 534 #endif
 535         if (mp->mnt_opt != NULL)
 536                 vfs_freeopts(mp->mnt_opt);
 537         crfree(mp->mnt_cred);
 538         uma_zfree(mount_zone, mp);
 539 }
 540
 541 static bool
 542 vfs_should_downgrade_to_ro_mount(uint64_t fsflags, int error)
 543 {
 544         /* This is an upgrade of an exisiting mount. */
 545         if ((fsflags & MNT_UPDATE) != 0)
 546                 return (false);
 547         /* This is already an R/O mount. */
 548         if ((fsflags & MNT_RDONLY) != 0)
 549                 return (false);
 550
 551         switch (error) {
 552         case ENODEV:    /* generic, geom, ... */
 553         case EACCES:    /* cam/scsi, ... */
 554         case EROFS:     /* md, mmcsd, ... */
 555                 /*
 556                  * These errors can be returned by the storage layer to signal
 557                  * that the media is read-only.  No harm in the R/O mount
 558                  * attempt if the error was returned for some other reason.
 559                  */
 560                 return (true);
 561         default:
 562                 return (false);
 563         }
 564 }
 565
 566 int
 567 vfs_donmount(struct thread *td, uint64_t fsflags, struct uio *fsoptions)
 568 {
 569         struct vfsoptlist *optlist;
 570         struct vfsopt *opt, *tmp_opt;
 571         char *fstype, *fspath, *errmsg;
 572         int error, fstypelen, fspathlen, errmsg_len, errmsg_pos;
 573         bool autoro;
 574
 575         errmsg = fspath = NULL;
 576         errmsg_len = fspathlen = 0;
 577         errmsg_pos = -1;
 578         autoro = default_autoro;
 579
 580         error = vfs_buildopts(fsoptions, &optlist);
 581         if (error)
 582                 return (error);
 583
 584         if (vfs_getopt(optlist, "errmsg", (void **)&errmsg, &errmsg_len) == 0)
 585                 errmsg_pos = vfs_getopt_pos(optlist, "errmsg");
 586
 587         /*
 588          * We need these two options before the others,
 589          * and they are mandatory for any filesystem.
 590          * Ensure they are NUL terminated as well.
 591          */
 592         fstypelen = 0;
 593         error = vfs_getopt(optlist, "fstype", (void **)&fstype, &fstypelen);
 594         if (error || fstypelen <= 0 || fstype[fstypelen - 1] != '\0') {
 595                 error = EINVAL;
 596                 if (errmsg != NULL)
 597                         strncpy(errmsg, "Invalid fstype", errmsg_len);
 598                 goto bail;
 599         }
 600         fspathlen = 0;
 601         error = vfs_getopt(optlist, "fspath", (void **)&fspath, &fspathlen);
 602         if (error || fspathlen <= 0 || fspath[fspathlen - 1] != '\0') {
 603                 error = EINVAL;
 604                 if (errmsg != NULL)
 605                         strncpy(errmsg, "Invalid fspath", errmsg_len);
 606                 goto bail;
 607         }
 608
 609         /*
 610          * We need to see if we have the "update" option
 611          * before we call vfs_domount(), since vfs_domount() has special
 612          * logic based on MNT_UPDATE.  This is very important
 613          * when we want to update the root filesystem.
 614          */
 615         TAILQ_FOREACH_SAFE(opt, optlist, link, tmp_opt) {
 616                 if (strcmp(opt->name, "update") == 0) {
 617                         fsflags |= MNT_UPDATE;
 618                         vfs_freeopt(optlist, opt);
 619                 }
 620                 else if (strcmp(opt->name, "async") == 0)
 621                         fsflags |= MNT_ASYNC;
 622                 else if (strcmp(opt->name, "force") == 0) {
 623                         fsflags |= MNT_FORCE;
 624                         vfs_freeopt(optlist, opt);
 625                 }
 626                 else if (strcmp(opt->name, "reload") == 0) {
 627                         fsflags |= MNT_RELOAD;
 628                         vfs_freeopt(optlist, opt);
 629                 }
 630                 else if (strcmp(opt->name, "multilabel") == 0)
 631                         fsflags |= MNT_MULTILABEL;
 632                 else if (strcmp(opt->name, "noasync") == 0)
 633                         fsflags &= ~MNT_ASYNC;
 634                 else if (strcmp(opt->name, "noatime") == 0)
 635                         fsflags |= MNT_NOATIME;
 636                 else if (strcmp(opt->name, "atime") == 0) {
 637                         free(opt->name, M_MOUNT);
 638                         opt->name = strdup("nonoatime", M_MOUNT);
 639                 }
 640                 else if (strcmp(opt->name, "noclusterr") == 0)
 641                         fsflags |= MNT_NOCLUSTERR;
 642                 else if (strcmp(opt->name, "clusterr") == 0) {
 643                         free(opt->name, M_MOUNT);
 644                         opt->name = strdup("nonoclusterr", M_MOUNT);
 645                 }
 646                 else if (strcmp(opt->name, "noclusterw") == 0)
 647                         fsflags |= MNT_NOCLUSTERW;
 648                 else if (strcmp(opt->name, "clusterw") == 0) {
 649                         free(opt->name, M_MOUNT);
 650                         opt->name = strdup("nonoclusterw", M_MOUNT);
 651                 }
 652                 else if (strcmp(opt->name, "noexec") == 0)
 653                         fsflags |= MNT_NOEXEC;
 654                 else if (strcmp(opt->name, "exec") == 0) {
 655                         free(opt->name, M_MOUNT);
 656                         opt->name = strdup("nonoexec", M_MOUNT);
 657                 }
 658                 else if (strcmp(opt->name, "nosuid") == 0)
 659                         fsflags |= MNT_NOSUID;
 660                 else if (strcmp(opt->name, "suid") == 0) {
 661                         free(opt->name, M_MOUNT);
 662                         opt->name = strdup("nonosuid", M_MOUNT);
 663                 }
 664                 else if (strcmp(opt->name, "nosymfollow") == 0)
 665                         fsflags |= MNT_NOSYMFOLLOW;
 666                 else if (strcmp(opt->name, "symfollow") == 0) {
 667                         free(opt->name, M_MOUNT);
 668                         opt->name = strdup("nonosymfollow", M_MOUNT);
 669                 }
 670                 else if (strcmp(opt->name, "noro") == 0) {
 671                         fsflags &= ~MNT_RDONLY;
 672                         autoro = false;
 673                 }
 674                 else if (strcmp(opt->name, "rw") == 0) {
 675                         fsflags &= ~MNT_RDONLY;
 676                         autoro = false;
 677                 }
 678                 else if (strcmp(opt->name, "ro") == 0) {
 679                         fsflags |= MNT_RDONLY;
 680                         autoro = false;
 681                 }
 682                 else if (strcmp(opt->name, "rdonly") == 0) {
 683                         free(opt->name, M_MOUNT);
 684                         opt->name = strdup("ro", M_MOUNT);
 685                         fsflags |= MNT_RDONLY;
 686                         autoro = false;
 687                 }
 688                 else if (strcmp(opt->name, "autoro") == 0) {
 689                         vfs_freeopt(optlist, opt);
 690                         autoro = true;
 691                 }
 692                 else if (strcmp(opt->name, "suiddir") == 0)
 693                         fsflags |= MNT_SUIDDIR;
 694                 else if (strcmp(opt->name, "sync") == 0)
 695                         fsflags |= MNT_SYNCHRONOUS;
 696                 else if (strcmp(opt->name, "union") == 0)
 697                         fsflags |= MNT_UNION;
 698                 else if (strcmp(opt->name, "automounted") == 0) {
 699                         fsflags |= MNT_AUTOMOUNTED;
 700                         vfs_freeopt(optlist, opt);
 701                 }
 702         }
 703
 704         /*
 705          * Be ultra-paranoid about making sure the type and fspath
 706          * variables will fit in our mp buffers, including the
 707          * terminating NUL.
 708          */
 709         if (fstypelen > MFSNAMELEN || fspathlen > MNAMELEN) {
 710                 error = ENAMETOOLONG;
 711                 goto bail;
 712         }
 713
 714         error = vfs_domount(td, fstype, fspath, fsflags, &optlist);
 715
 716         /*
 717          * See if we can mount in the read-only mode if the error code suggests
 718          * that it could be possible and the mount options allow for that.
 719          * Never try it if "[no]{ro|rw}" has been explicitly requested and not
 720          * overridden by "autoro".
 721          */
 722         if (autoro && vfs_should_downgrade_to_ro_mount(fsflags, error)) {
 723                 printf("%s: R/W mount failed, possibly R/O media,"
 724                     " trying R/O mount\n", __func__);
 725                 fsflags |= MNT_RDONLY;
 726                 error = vfs_domount(td, fstype, fspath, fsflags, &optlist);
 727         }
 728 bail:
 729         /* copyout the errmsg */
 730         if (errmsg_pos != -1 && ((2 * errmsg_pos + 1) < fsoptions->uio_iovcnt)
 731             && errmsg_len > 0 && errmsg != NULL) {
 732                 if (fsoptions->uio_segflg == UIO_SYSSPACE) {
 733                         bcopy(errmsg,
 734                             fsoptions->uio_iov[2 * errmsg_pos + 1].iov_base,
 735                             fsoptions->uio_iov[2 * errmsg_pos + 1].iov_len);
 736                 } else {
 737                         copyout(errmsg,
 738                             fsoptions->uio_iov[2 * errmsg_pos + 1].iov_base,
 739                             fsoptions->uio_iov[2 * errmsg_pos + 1].iov_len);
 740                 }
 741         }
 742
 743         if (optlist != NULL)
 744                 vfs_freeopts(optlist);
 745         return (error);
 746 }
 747
 748 /*
 749  * Old mount API.
 750  */
 751 #ifndef _SYS_SYSPROTO_H_
 752 struct mount_args {
 753         char    *type;
 754         char    *path;
 755         int     flags;
 756         caddr_t data;
 757 };
 758 #endif
 759 /* ARGSUSED */
 760 int
 761 sys_mount(struct thread *td, struct mount_args *uap)
 762 {
 763         char *fstype;
 764         struct vfsconf *vfsp = NULL;
 765         struct mntarg *ma = NULL;
 766         uint64_t flags;
 767         int error;
 768
 769         /*
 770          * Mount flags are now 64-bits. On 32-bit architectures only
 771          * 32-bits are passed in, but from here on everything handles
 772          * 64-bit flags correctly.
 773          */
 774         flags = uap->flags;
 775
 776         AUDIT_ARG_FFLAGS(flags);
 777
 778         /*
 779          * Filter out MNT_ROOTFS.  We do not want clients of mount() in
 780          * userspace to set this flag, but we must filter it out if we want
 781          * MNT_UPDATE on the root file system to work.
 782          * MNT_ROOTFS should only be set by the kernel when mounting its
 783          * root file system.
 784          */
 785         flags &= ~MNT_ROOTFS;
 786
 787         fstype = malloc(MFSNAMELEN, M_TEMP, M_WAITOK);
 788         error = copyinstr(uap->type, fstype, MFSNAMELEN, NULL);
 789         if (error) {
 790                 free(fstype, M_TEMP);
 791                 return (error);
 792         }
 793
 794         AUDIT_ARG_TEXT(fstype);
 795         vfsp = vfs_byname_kld(fstype, td, &error);
 796         free(fstype, M_TEMP);
 797         if (vfsp == NULL)
 798                 return (ENOENT);
 799         if (vfsp->vfc_vfsops->vfs_cmount == NULL)
 800                 return (EOPNOTSUPP);
 801
 802         ma = mount_argsu(ma, "fstype", uap->type, MFSNAMELEN);
 803         ma = mount_argsu(ma, "fspath", uap->path, MNAMELEN);
 804         ma = mount_argb(ma, flags & MNT_RDONLY, "noro");
 805         ma = mount_argb(ma, !(flags & MNT_NOSUID), "nosuid");
 806         ma = mount_argb(ma, !(flags & MNT_NOEXEC), "noexec");
 807
 808         error = vfsp->vfc_vfsops->vfs_cmount(ma, uap->data, flags);
 809         return (error);
 810 }
 811
 812 /*
 813  * vfs_domount_first(): first file system mount (not update)
 814  */
 815 static int
 816 vfs_domount_first(
 817         struct thread *td,              /* Calling thread. */
 818         struct vfsconf *vfsp,           /* File system type. */
 819         char *fspath,                   /* Mount path. */
 820         struct vnode *vp,               /* Vnode to be covered. */
 821         uint64_t fsflags,               /* Flags common to all filesystems. */
 822         struct vfsoptlist **optlist     /* Options local to the filesystem. */
 823         )
 824 {
 825         struct vattr va;
 826         struct mount *mp;
 827         struct vnode *newdp;
 828         int error, error1;
 829
 830         ASSERT_VOP_ELOCKED(vp, __func__);
 831         KASSERT((fsflags & MNT_UPDATE) == 0, ("MNT_UPDATE shouldn't be here"));
 832
 833         /*
 834          * If the user is not root, ensure that they own the directory
 835          * onto which we are attempting to mount.
 836          */
 837         error = VOP_GETATTR(vp, &va, td->td_ucred);
 838         if (error == 0 && va.va_uid != td->td_ucred->cr_uid)
 839                 error = priv_check_cred(td->td_ucred, PRIV_VFS_ADMIN, 0);
 840         if (error == 0)
 841                 error = vinvalbuf(vp, V_SAVE, 0, 0);
 842         if (error == 0 && vp->v_type != VDIR)
 843                 error = ENOTDIR;
 844         if (error == 0) {
 845                 VI_LOCK(vp);
 846                 if ((vp->v_iflag & VI_MOUNT) == 0 && vp->v_mountedhere == NULL)
 847                         vp->v_iflag |= VI_MOUNT;
 848                 else
 849                         error = EBUSY;
 850                 VI_UNLOCK(vp);
 851         }
 852         if (error != 0) {
 853                 vput(vp);
 854                 return (error);
 855         }
 856         VOP_UNLOCK(vp, 0);
 857
 858         /* Allocate and initialize the filesystem. */
 859         mp = vfs_mount_alloc(vp, vfsp, fspath, td->td_ucred);
 860         /* XXXMAC: pass to vfs_mount_alloc? */
 861         mp->mnt_optnew = *optlist;
 862         /* Set the mount level flags. */
 863         mp->mnt_flag = (fsflags & (MNT_UPDATEMASK | MNT_ROOTFS | MNT_RDONLY));
 864
 865         /*
 866          * Mount the filesystem.
 867          * XXX The final recipients of VFS_MOUNT just overwrite the ndp they
 868          * get.  No freeing of cn_pnbuf.
 869          */
 870         error1 = 0;
 871         if ((error = VFS_MOUNT(mp)) != 0 ||
 872             (error1 = VFS_STATFS(mp, &mp->mnt_stat)) != 0 ||
 873             (error1 = VFS_ROOT(mp, LK_EXCLUSIVE, &newdp)) != 0) {
 874                 if (error1 != 0) {
 875                         error = error1;
 876                         if ((error1 = VFS_UNMOUNT(mp, 0)) != 0)
 877                                 printf("VFS_UNMOUNT returned %d\n", error1);
 878                 }
 879                 vfs_unbusy(mp);
 880                 mp->mnt_vnodecovered = NULL;
 881                 vfs_mount_destroy(mp);
 882                 VI_LOCK(vp);
 883                 vp->v_iflag &= ~VI_MOUNT;
 884                 VI_UNLOCK(vp);
 885                 vrele(vp);
 886                 return (error);
 887         }
 888         VOP_UNLOCK(newdp, 0);
 889
 890         if (mp->mnt_opt != NULL)
 891                 vfs_freeopts(mp->mnt_opt);
 892         mp->mnt_opt = mp->mnt_optnew;
 893         *optlist = NULL;
 894
 895         /*
 896          * Prevent external consumers of mount options from reading mnt_optnew.
 897          */
 898         mp->mnt_optnew = NULL;
 899
 900         MNT_ILOCK(mp);
 901         if ((mp->mnt_flag & MNT_ASYNC) != 0 &&
 902             (mp->mnt_kern_flag & MNTK_NOASYNC) == 0)
 903                 mp->mnt_kern_flag |= MNTK_ASYNC;
 904         else
 905                 mp->mnt_kern_flag &= ~MNTK_ASYNC;
 906         MNT_IUNLOCK(mp);
 907
 908         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 909         cache_purge(vp);
 910         VI_LOCK(vp);
 911         vp->v_iflag &= ~VI_MOUNT;
 912         VI_UNLOCK(vp);
 913         vp->v_mountedhere = mp;
 914         /* Place the new filesystem at the end of the mount list. */
 915         mtx_lock(&mountlist_mtx);
 916         TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
 917         mtx_unlock(&mountlist_mtx);
 918         vfs_event_signal(NULL, VQ_MOUNT, 0);
 919         vn_lock(newdp, LK_EXCLUSIVE | LK_RETRY);
 920         VOP_UNLOCK(vp, 0);
 921         EVENTHANDLER_INVOKE(vfs_mounted, mp, newdp, td);
 922         VOP_UNLOCK(newdp, 0);
 923         mountcheckdirs(vp, newdp);
 924         vrele(newdp);
 925         if ((mp->mnt_flag & MNT_RDONLY) == 0)
 926                 vfs_allocate_syncvnode(mp);
 927         vfs_unbusy(mp);
 928         return (0);
 929 }
 930
 931 /*
 932  * vfs_domount_update(): update of mounted file system
 933  */
 934 static int
 935 vfs_domount_update(
 936         struct thread *td,              /* Calling thread. */
 937         struct vnode *vp,               /* Mount point vnode. */
 938         uint64_t fsflags,               /* Flags common to all filesystems. */
 939         struct vfsoptlist **optlist     /* Options local to the filesystem. */
 940         )
 941 {
 942         struct export_args export;
 943         void *bufp;
 944         struct mount *mp;
 945         int error, export_error, len;
 946         uint64_t flag;
 947
 948         ASSERT_VOP_ELOCKED(vp, __func__);
 949         KASSERT((fsflags & MNT_UPDATE) != 0, ("MNT_UPDATE should be here"));
 950         mp = vp->v_mount;
 951
 952         if ((vp->v_vflag & VV_ROOT) == 0) {
 953                 if (vfs_copyopt(*optlist, "export", &export, sizeof(export))
 954                     == 0)
 955                         error = EXDEV;
 956                 else
 957                         error = EINVAL;
 958                 vput(vp);
 959                 return (error);
 960         }
 961
 962         /*
 963          * We only allow the filesystem to be reloaded if it
 964          * is currently mounted read-only.
 965          */
 966         flag = mp->mnt_flag;
 967         if ((fsflags & MNT_RELOAD) != 0 && (flag & MNT_RDONLY) == 0) {
 968                 vput(vp);
 969                 return (EOPNOTSUPP);    /* Needs translation */
 970         }
 971         /*
 972          * Only privileged root, or (if MNT_USER is set) the user that
 973          * did the original mount is permitted to update it.
 974          */
 975         error = vfs_suser(mp, td);
 976         if (error != 0) {
 977                 vput(vp);
 978                 return (error);
 979         }
 980         if (vfs_busy(mp, MBF_NOWAIT)) {
 981                 vput(vp);
 982                 return (EBUSY);
 983         }
 984         VI_LOCK(vp);
 985         if ((vp->v_iflag & VI_MOUNT) != 0 || vp->v_mountedhere != NULL) {
 986                 VI_UNLOCK(vp);
 987                 vfs_unbusy(mp);
 988                 vput(vp);
 989                 return (EBUSY);
 990         }
 991         vp->v_iflag |= VI_MOUNT;
 992         VI_UNLOCK(vp);
 993         VOP_UNLOCK(vp, 0);
 994
 995         MNT_ILOCK(mp);
 996         if ((mp->mnt_kern_flag & MNTK_UNMOUNT) != 0) {
 997                 MNT_IUNLOCK(mp);
 998                 error = EBUSY;
 999                 goto end;
1000         }
1001         mp->mnt_flag &= ~MNT_UPDATEMASK;
1002         mp->mnt_flag |= fsflags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE |
1003             MNT_SNAPSHOT | MNT_ROOTFS | MNT_UPDATEMASK | MNT_RDONLY);
1004         if ((mp->mnt_flag & MNT_ASYNC) == 0)
1005                 mp->mnt_kern_flag &= ~MNTK_ASYNC;
1006         MNT_IUNLOCK(mp);
1007         mp->mnt_optnew = *optlist;
1008         vfs_mergeopts(mp->mnt_optnew, mp->mnt_opt);
1009
1010         /*
1011          * Mount the filesystem.
1012          * XXX The final recipients of VFS_MOUNT just overwrite the ndp they
1013          * get.  No freeing of cn_pnbuf.
1014          */
1015         error = VFS_MOUNT(mp);
1016
1017         export_error = 0;
1018         /* Process the export option. */
1019         if (error == 0 && vfs_getopt(mp->mnt_optnew, "export", &bufp,
1020             &len) == 0) {
1021                 /* Assume that there is only 1 ABI for each length. */
1022                 switch (len) {
1023                 case (sizeof(struct oexport_args)):
1024                         bzero(&export, sizeof(export));
1025                         /* FALLTHROUGH */
1026                 case (sizeof(export)):
1027                         bcopy(bufp, &export, len);
1028                         export_error = vfs_export(mp, &export);
1029                         break;
1030                 default:
1031                         export_error = EINVAL;
1032                         break;
1033                 }
1034         }
1035
1036         MNT_ILOCK(mp);
1037         if (error == 0) {
1038                 mp->mnt_flag &= ~(MNT_UPDATE | MNT_RELOAD | MNT_FORCE |
1039                     MNT_SNAPSHOT);
1040         } else {
1041                 /*
1042                  * If we fail, restore old mount flags. MNT_QUOTA is special,
1043                  * because it is not part of MNT_UPDATEMASK, but it could have
1044                  * changed in the meantime if quotactl(2) was called.
1045                  * All in all we want current value of MNT_QUOTA, not the old
1046                  * one.
1047                  */
1048                 mp->mnt_flag = (mp->mnt_flag & MNT_QUOTA) | (flag & ~MNT_QUOTA);
1049         }
1050         if ((mp->mnt_flag & MNT_ASYNC) != 0 &&
1051             (mp->mnt_kern_flag & MNTK_NOASYNC) == 0)
1052                 mp->mnt_kern_flag |= MNTK_ASYNC;
1053         else
1054                 mp->mnt_kern_flag &= ~MNTK_ASYNC;
1055         MNT_IUNLOCK(mp);
1056
1057         if (error != 0)
1058                 goto end;
1059
1060         if (mp->mnt_opt != NULL)
1061                 vfs_freeopts(mp->mnt_opt);
1062         mp->mnt_opt = mp->mnt_optnew;
1063         *optlist = NULL;
1064         (void)VFS_STATFS(mp, &mp->mnt_stat);
1065         /*
1066          * Prevent external consumers of mount options from reading
1067          * mnt_optnew.
1068          */
1069         mp->mnt_optnew = NULL;
1070
1071         if ((mp->mnt_flag & MNT_RDONLY) == 0)
1072                 vfs_allocate_syncvnode(mp);
1073         else
1074                 vfs_deallocate_syncvnode(mp);
1075 end:
1076         vfs_unbusy(mp);
1077         VI_LOCK(vp);
1078         vp->v_iflag &= ~VI_MOUNT;
1079         VI_UNLOCK(vp);
1080         vrele(vp);
1081         return (error != 0 ? error : export_error);
1082 }
1083
1084 /*
1085  * vfs_domount(): actually attempt a filesystem mount.
1086  */
1087 static int
1088 vfs_domount(
1089         struct thread *td,              /* Calling thread. */
1090         const char *fstype,             /* Filesystem type. */
1091         char *fspath,                   /* Mount path. */
1092         uint64_t fsflags,               /* Flags common to all filesystems. */
1093         struct vfsoptlist **optlist     /* Options local to the filesystem. */
1094         )
1095 {
1096         struct vfsconf *vfsp;
1097         struct nameidata nd;
1098         struct vnode *vp;
1099         char *pathbuf;
1100         int error;
1101
1102         /*
1103          * Be ultra-paranoid about making sure the type and fspath
1104          * variables will fit in our mp buffers, including the
1105          * terminating NUL.
1106          */
1107         if (strlen(fstype) >= MFSNAMELEN || strlen(fspath) >= MNAMELEN)
1108                 return (ENAMETOOLONG);
1109
1110         if (jailed(td->td_ucred) || usermount == 0) {
1111                 if ((error = priv_check(td, PRIV_VFS_MOUNT)) != 0)
1112                         return (error);
1113         }
1114
1115         /*
1116          * Do not allow NFS export or MNT_SUIDDIR by unprivileged users.
1117          */
1118         if (fsflags & MNT_EXPORTED) {
1119                 error = priv_check(td, PRIV_VFS_MOUNT_EXPORTED);
1120                 if (error)
1121                         return (error);
1122         }
1123         if (fsflags & MNT_SUIDDIR) {
1124                 error = priv_check(td, PRIV_VFS_MOUNT_SUIDDIR);
1125                 if (error)
1126                         return (error);
1127         }
1128         /*
1129          * Silently enforce MNT_NOSUID and MNT_USER for unprivileged users.
1130          */
1131         if ((fsflags & (MNT_NOSUID | MNT_USER)) != (MNT_NOSUID | MNT_USER)) {
1132                 if (priv_check(td, PRIV_VFS_MOUNT_NONUSER) != 0)
1133                         fsflags |= MNT_NOSUID | MNT_USER;
1134         }
1135
1136         /* Load KLDs before we lock the covered vnode to avoid reversals. */
1137         vfsp = NULL;
1138         if ((fsflags & MNT_UPDATE) == 0) {
1139                 /* Don't try to load KLDs if we're mounting the root. */
1140                 if (fsflags & MNT_ROOTFS)
1141                         vfsp = vfs_byname(fstype);
1142                 else
1143                         vfsp = vfs_byname_kld(fstype, td, &error);
1144                 if (vfsp == NULL)
1145                         return (ENODEV);
1146                 if (jailed(td->td_ucred) && !(vfsp->vfc_flags & VFCF_JAIL))
1147                         return (EPERM);
1148         }
1149
1150         /*
1151          * Get vnode to be covered or mount point's vnode in case of MNT_UPDATE.
1152          */
1153         NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1,
1154             UIO_SYSSPACE, fspath, td);
1155         error = namei(&nd);
1156         if (error != 0)
1157                 return (error);
1158         NDFREE(&nd, NDF_ONLY_PNBUF);
1159         vp = nd.ni_vp;
1160         if ((fsflags & MNT_UPDATE) == 0) {
1161                 pathbuf = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1162                 strcpy(pathbuf, fspath);
1163                 error = vn_path_to_global_path(td, vp, pathbuf, MNAMELEN);
1164                 /* debug.disablefullpath == 1 results in ENODEV */
1165                 if (error == 0 || error == ENODEV) {
1166                         error = vfs_domount_first(td, vfsp, pathbuf, vp,
1167                             fsflags, optlist);
1168                 }
1169                 free(pathbuf, M_TEMP);
1170         } else
1171                 error = vfs_domount_update(td, vp, fsflags, optlist);
1172
1173         return (error);
1174 }
1175
1176 /*
1177  * Unmount a filesystem.
1178  *
1179  * Note: unmount takes a path to the vnode mounted on as argument, not
1180  * special file (as before).
1181  */
1182 #ifndef _SYS_SYSPROTO_H_
1183 struct unmount_args {
1184         char    *path;
1185         int     flags;
1186 };
1187 #endif
1188 /* ARGSUSED */
1189 int
1190 sys_unmount(struct thread *td, struct unmount_args *uap)
1191 {
1192         struct nameidata nd;
1193         struct mount *mp;
1194         char *pathbuf;
1195         int error, id0, id1;
1196
1197         AUDIT_ARG_VALUE(uap->flags);
1198         if (jailed(td->td_ucred) || usermount == 0) {
1199                 error = priv_check(td, PRIV_VFS_UNMOUNT);
1200                 if (error)
1201                         return (error);
1202         }
1203
1204         pathbuf = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1205         error = copyinstr(uap->path, pathbuf, MNAMELEN, NULL);
1206         if (error) {
1207                 free(pathbuf, M_TEMP);
1208                 return (error);
1209         }
1210         if (uap->flags & MNT_BYFSID) {
1211                 AUDIT_ARG_TEXT(pathbuf);
1212                 /* Decode the filesystem ID. */
1213                 if (sscanf(pathbuf, "FSID:%d:%d", &id0, &id1) != 2) {
1214                         free(pathbuf, M_TEMP);
1215                         return (EINVAL);
1216                 }
1217
1218                 mtx_lock(&mountlist_mtx);
1219                 TAILQ_FOREACH_REVERSE(mp, &mountlist, mntlist, mnt_list) {
1220                         if (mp->mnt_stat.f_fsid.val[0] == id0 &&
1221                             mp->mnt_stat.f_fsid.val[1] == id1) {
1222                                 vfs_ref(mp);
1223                                 break;
1224                         }
1225                 }
1226                 mtx_unlock(&mountlist_mtx);
1227         } else {
1228                 /*
1229                  * Try to find global path for path argument.
1230                  */
1231                 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1,
1232                     UIO_SYSSPACE, pathbuf, td);
1233                 if (namei(&nd) == 0) {
1234                         NDFREE(&nd, NDF_ONLY_PNBUF);
1235                         error = vn_path_to_global_path(td, nd.ni_vp, pathbuf,
1236                             MNAMELEN);
1237                         if (error == 0 || error == ENODEV)
1238                                 vput(nd.ni_vp);
1239                 }
1240                 mtx_lock(&mountlist_mtx);
1241                 TAILQ_FOREACH_REVERSE(mp, &mountlist, mntlist, mnt_list) {
1242                         if (strcmp(mp->mnt_stat.f_mntonname, pathbuf) == 0) {
1243                                 vfs_ref(mp);
1244                                 break;
1245                         }
1246                 }
1247                 mtx_unlock(&mountlist_mtx);
1248         }
1249         free(pathbuf, M_TEMP);
1250         if (mp == NULL) {
1251                 /*
1252                  * Previously we returned ENOENT for a nonexistent path and
1253                  * EINVAL for a non-mountpoint.  We cannot tell these apart
1254                  * now, so in the !MNT_BYFSID case return the more likely
1255                  * EINVAL for compatibility.
1256                  */
1257                 return ((uap->flags & MNT_BYFSID) ? ENOENT : EINVAL);
1258         }
1259
1260         /*
1261          * Don't allow unmounting the root filesystem.
1262          */
1263         if (mp->mnt_flag & MNT_ROOTFS) {
1264                 vfs_rel(mp);
1265                 return (EINVAL);
1266         }
1267         error = dounmount(mp, uap->flags, td);
1268         return (error);
1269 }
1270
1271 /*
1272  * Return error if any of the vnodes, ignoring the root vnode
1273  * and the syncer vnode, have non-zero usecount.
1274  *
1275  * This function is purely advisory - it can return false positives
1276  * and negatives.
1277  */
1278 static int
1279 vfs_check_usecounts(struct mount *mp)
1280 {
1281         struct vnode *vp, *mvp;
1282
1283         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1284                 if ((vp->v_vflag & VV_ROOT) == 0 && vp->v_type != VNON &&
1285                     vp->v_usecount != 0) {
1286                         VI_UNLOCK(vp);
1287                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1288                         return (EBUSY);
1289                 }
1290                 VI_UNLOCK(vp);
1291         }
1292
1293         return (0);
1294 }
1295
1296 static void
1297 dounmount_cleanup(struct mount *mp, struct vnode *coveredvp, int mntkflags)
1298 {
1299
1300         mtx_assert(MNT_MTX(mp), MA_OWNED);
1301         mp->mnt_kern_flag &= ~mntkflags;
1302         if ((mp->mnt_kern_flag & MNTK_MWAIT) != 0) {
1303                 mp->mnt_kern_flag &= ~MNTK_MWAIT;
1304                 wakeup(mp);
1305         }
1306         MNT_IUNLOCK(mp);
1307         if (coveredvp != NULL) {
1308                 VOP_UNLOCK(coveredvp, 0);
1309                 vdrop(coveredvp);
1310         }
1311         vn_finished_write(mp);
1312 }
1313
1314 /*
1315  * Do the actual filesystem unmount.
1316  */
1317 int
1318 dounmount(struct mount *mp, int flags, struct thread *td)
1319 {
1320         struct vnode *coveredvp, *fsrootvp;
1321         int error;
1322         uint64_t async_flag;
1323         int mnt_gen_r;
1324
1325         if ((coveredvp = mp->mnt_vnodecovered) != NULL) {
1326                 mnt_gen_r = mp->mnt_gen;
1327                 VI_LOCK(coveredvp);
1328                 vholdl(coveredvp);
1329                 vn_lock(coveredvp, LK_EXCLUSIVE | LK_INTERLOCK | LK_RETRY);
1330                 /*
1331                  * Check for mp being unmounted while waiting for the
1332                  * covered vnode lock.
1333                  */
1334                 if (coveredvp->v_mountedhere != mp ||
1335                     coveredvp->v_mountedhere->mnt_gen != mnt_gen_r) {
1336                         VOP_UNLOCK(coveredvp, 0);
1337                         vdrop(coveredvp);
1338                         vfs_rel(mp);
1339                         return (EBUSY);
1340                 }
1341         }
1342
1343         /*
1344          * Only privileged root, or (if MNT_USER is set) the user that did the
1345          * original mount is permitted to unmount this filesystem.
1346          */
1347         error = vfs_suser(mp, td);
1348         if (error != 0) {
1349                 if (coveredvp != NULL) {
1350                         VOP_UNLOCK(coveredvp, 0);
1351                         vdrop(coveredvp);
1352                 }
1353                 vfs_rel(mp);
1354                 return (error);
1355         }
1356
1357         vn_start_write(NULL, &mp, V_WAIT | V_MNTREF);
1358         MNT_ILOCK(mp);
1359         if ((mp->mnt_kern_flag & MNTK_UNMOUNT) != 0 ||
1360             (mp->mnt_flag & MNT_UPDATE) != 0 ||
1361             !TAILQ_EMPTY(&mp->mnt_uppers)) {
1362                 dounmount_cleanup(mp, coveredvp, 0);
1363                 return (EBUSY);
1364         }
1365         mp->mnt_kern_flag |= MNTK_UNMOUNT | MNTK_NOINSMNTQ;
1366         if (flags & MNT_NONBUSY) {
1367                 MNT_IUNLOCK(mp);
1368                 error = vfs_check_usecounts(mp);
1369                 MNT_ILOCK(mp);
1370                 if (error != 0) {
1371                         dounmount_cleanup(mp, coveredvp, MNTK_UNMOUNT |
1372                             MNTK_NOINSMNTQ);
1373                         return (error);
1374                 }
1375         }
1376         /* Allow filesystems to detect that a forced unmount is in progress. */
1377         if (flags & MNT_FORCE) {
1378                 mp->mnt_kern_flag |= MNTK_UNMOUNTF;
1379                 MNT_IUNLOCK(mp);
1380                 /*
1381                  * Must be done after setting MNTK_UNMOUNTF and before
1382                  * waiting for mnt_lockref to become 0.
1383                  */
1384                 VFS_PURGE(mp);
1385                 MNT_ILOCK(mp);
1386         }
1387         error = 0;
1388         if (mp->mnt_lockref) {
1389                 mp->mnt_kern_flag |= MNTK_DRAINING;
1390                 error = msleep(&mp->mnt_lockref, MNT_MTX(mp), PVFS,
1391                     "mount drain", 0);
1392         }
1393         MNT_IUNLOCK(mp);
1394         KASSERT(mp->mnt_lockref == 0,
1395             ("%s: invalid lock refcount in the drain path @ %s:%d",
1396             __func__, __FILE__, __LINE__));
1397         KASSERT(error == 0,
1398             ("%s: invalid return value for msleep in the drain path @ %s:%d",
1399             __func__, __FILE__, __LINE__));
1400
1401         if (mp->mnt_flag & MNT_EXPUBLIC)
1402                 vfs_setpublicfs(NULL, NULL, NULL);
1403
1404         /*
1405          * From now, we can claim that the use reference on the
1406          * coveredvp is ours, and the ref can be released only by
1407          * successfull unmount by us, or left for later unmount
1408          * attempt.  The previously acquired hold reference is no
1409          * longer needed to protect the vnode from reuse.
1410          */
1411         if (coveredvp != NULL)
1412                 vdrop(coveredvp);
1413
1414         vfs_msync(mp, MNT_WAIT);
1415         MNT_ILOCK(mp);
1416         async_flag = mp->mnt_flag & MNT_ASYNC;
1417         mp->mnt_flag &= ~MNT_ASYNC;
1418         mp->mnt_kern_flag &= ~MNTK_ASYNC;
1419         MNT_IUNLOCK(mp);
1420         cache_purgevfs(mp, false); /* remove cache entries for this file sys */
1421         vfs_deallocate_syncvnode(mp);
1422         /*
1423          * For forced unmounts, move process cdir/rdir refs on the fs root
1424          * vnode to the covered vnode.  For non-forced unmounts we want
1425          * such references to cause an EBUSY error.
1426          */
1427         if ((flags & MNT_FORCE) &&
1428             VFS_ROOT(mp, LK_EXCLUSIVE, &fsrootvp) == 0) {
1429                 if (mp->mnt_vnodecovered != NULL &&
1430                     (mp->mnt_flag & MNT_IGNORE) == 0)
1431                         mountcheckdirs(fsrootvp, mp->mnt_vnodecovered);
1432                 if (fsrootvp == rootvnode) {
1433                         vrele(rootvnode);
1434                         rootvnode = NULL;
1435                 }
1436                 vput(fsrootvp);
1437         }
1438         if ((mp->mnt_flag & MNT_RDONLY) != 0 || (flags & MNT_FORCE) != 0 ||
1439             (error = VFS_SYNC(mp, MNT_WAIT)) == 0)
1440                 error = VFS_UNMOUNT(mp, flags);
1441         vn_finished_write(mp);
1442         /*
1443          * If we failed to flush the dirty blocks for this mount point,
1444          * undo all the cdir/rdir and rootvnode changes we made above.
1445          * Unless we failed to do so because the device is reporting that
1446          * it doesn't exist anymore.
1447          */
1448         if (error && error != ENXIO) {
1449                 if ((flags & MNT_FORCE) &&
1450                     VFS_ROOT(mp, LK_EXCLUSIVE, &fsrootvp) == 0) {
1451                         if (mp->mnt_vnodecovered != NULL &&
1452                             (mp->mnt_flag & MNT_IGNORE) == 0)
1453                                 mountcheckdirs(mp->mnt_vnodecovered, fsrootvp);
1454                         if (rootvnode == NULL) {
1455                                 rootvnode = fsrootvp;
1456                                 vref(rootvnode);
1457                         }
1458                         vput(fsrootvp);
1459                 }
1460                 MNT_ILOCK(mp);
1461                 mp->mnt_kern_flag &= ~MNTK_NOINSMNTQ;
1462                 if ((mp->mnt_flag & MNT_RDONLY) == 0) {
1463                         MNT_IUNLOCK(mp);
1464                         vfs_allocate_syncvnode(mp);
1465                         MNT_ILOCK(mp);
1466                 }
1467                 mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_UNMOUNTF);
1468                 mp->mnt_flag |= async_flag;
1469                 if ((mp->mnt_flag & MNT_ASYNC) != 0 &&
1470                     (mp->mnt_kern_flag & MNTK_NOASYNC) == 0)
1471                         mp->mnt_kern_flag |= MNTK_ASYNC;
1472                 if (mp->mnt_kern_flag & MNTK_MWAIT) {
1473                         mp->mnt_kern_flag &= ~MNTK_MWAIT;
1474                         wakeup(mp);
1475                 }
1476                 MNT_IUNLOCK(mp);
1477                 if (coveredvp)
1478                         VOP_UNLOCK(coveredvp, 0);
1479                 return (error);
1480         }
1481         mtx_lock(&mountlist_mtx);
1482         TAILQ_REMOVE(&mountlist, mp, mnt_list);
1483         mtx_unlock(&mountlist_mtx);
1484         EVENTHANDLER_INVOKE(vfs_unmounted, mp, td);
1485         if (coveredvp != NULL) {
1486                 coveredvp->v_mountedhere = NULL;
1487                 VOP_UNLOCK(coveredvp, 0);
1488         }
1489         vfs_event_signal(NULL, VQ_UNMOUNT, 0);
1490         if (mp == rootdevmp)
1491                 rootdevmp = NULL;
1492         vfs_mount_destroy(mp);
1493         return (0);
1494 }
1495
1496 /*
1497  * Report errors during filesystem mounting.
1498  */
1499 void
1500 vfs_mount_error(struct mount *mp, const char *fmt, ...)
1501 {
1502         struct vfsoptlist *moptlist = mp->mnt_optnew;
1503         va_list ap;
1504         int error, len;
1505         char *errmsg;
1506
1507         error = vfs_getopt(moptlist, "errmsg", (void **)&errmsg, &len);
1508         if (error || errmsg == NULL || len <= 0)
1509                 return;
1510
1511         va_start(ap, fmt);
1512         vsnprintf(errmsg, (size_t)len, fmt, ap);
1513         va_end(ap);
1514 }
1515
1516 void
1517 vfs_opterror(struct vfsoptlist *opts, const char *fmt, ...)
1518 {
1519         va_list ap;
1520         int error, len;
1521         char *errmsg;
1522
1523         error = vfs_getopt(opts, "errmsg", (void **)&errmsg, &len);
1524         if (error || errmsg == NULL || len <= 0)
1525                 return;
1526
1527         va_start(ap, fmt);
1528         vsnprintf(errmsg, (size_t)len, fmt, ap);
1529         va_end(ap);
1530 }
1531
1532 /*
1533  * ---------------------------------------------------------------------
1534  * Functions for querying mount options/arguments from filesystems.
1535  */
1536
1537 /*
1538  * Check that no unknown options are given
1539  */
1540 int
1541 vfs_filteropt(struct vfsoptlist *opts, const char **legal)
1542 {
1543         struct vfsopt *opt;
1544         char errmsg[255];
1545         const char **t, *p, *q;
1546         int ret = 0;
1547
1548         TAILQ_FOREACH(opt, opts, link) {
1549                 p = opt->name;
1550                 q = NULL;
1551                 if (p[0] == 'n' && p[1] == 'o')
1552                         q = p + 2;
1553                 for(t = global_opts; *t != NULL; t++) {
1554                         if (strcmp(*t, p) == 0)
1555                                 break;
1556                         if (q != NULL) {
1557                                 if (strcmp(*t, q) == 0)
1558                                         break;
1559                         }
1560                 }
1561                 if (*t != NULL)
1562                         continue;
1563                 for(t = legal; *t != NULL; t++) {
1564                         if (strcmp(*t, p) == 0)
1565                                 break;
1566                         if (q != NULL) {
1567                                 if (strcmp(*t, q) == 0)
1568                                         break;
1569                         }
1570                 }
1571                 if (*t != NULL)
1572                         continue;
1573                 snprintf(errmsg, sizeof(errmsg),
1574                     "mount option <%s> is unknown", p);
1575                 ret = EINVAL;
1576         }
1577         if (ret != 0) {
1578                 TAILQ_FOREACH(opt, opts, link) {
1579                         if (strcmp(opt->name, "errmsg") == 0) {
1580                                 strncpy((char *)opt->value, errmsg, opt->len);
1581                                 break;
1582                         }
1583                 }
1584                 if (opt == NULL)
1585                         printf("%s\n", errmsg);
1586         }
1587         return (ret);
1588 }
1589
1590 /*
1591  * Get a mount option by its name.
1592  *
1593  * Return 0 if the option was found, ENOENT otherwise.
1594  * If len is non-NULL it will be filled with the length
1595  * of the option. If buf is non-NULL, it will be filled
1596  * with the address of the option.
1597  */
1598 int
1599 vfs_getopt(struct vfsoptlist *opts, const char *name, void **buf, int *len)
1600 {
1601         struct vfsopt *opt;
1602
1603         KASSERT(opts != NULL, ("vfs_getopt: caller passed 'opts' as NULL"));
1604
1605         TAILQ_FOREACH(opt, opts, link) {
1606                 if (strcmp(name, opt->name) == 0) {
1607                         opt->seen = 1;
1608                         if (len != NULL)
1609                                 *len = opt->len;
1610                         if (buf != NULL)
1611                                 *buf = opt->value;
1612                         return (0);
1613                 }
1614         }
1615         return (ENOENT);
1616 }
1617
1618 int
1619 vfs_getopt_pos(struct vfsoptlist *opts, const char *name)
1620 {
1621         struct vfsopt *opt;
1622
1623         if (opts == NULL)
1624                 return (-1);
1625
1626         TAILQ_FOREACH(opt, opts, link) {
1627                 if (strcmp(name, opt->name) == 0) {
1628                         opt->seen = 1;
1629                         return (opt->pos);
1630                 }
1631         }
1632         return (-1);
1633 }
1634
1635 int
1636 vfs_getopt_size(struct vfsoptlist *opts, const char *name, off_t *value)
1637 {
1638         char *opt_value, *vtp;
1639         quad_t iv;
1640         int error, opt_len;
1641
1642         error = vfs_getopt(opts, name, (void **)&opt_value, &opt_len);
1643         if (error != 0)
1644                 return (error);
1645         if (opt_len == 0 || opt_value == NULL)
1646                 return (EINVAL);
1647         if (opt_value[0] == '\0' || opt_value[opt_len - 1] != '\0')
1648                 return (EINVAL);
1649         iv = strtoq(opt_value, &vtp, 0);
1650         if (vtp == opt_value || (vtp[0] != '\0' && vtp[1] != '\0'))
1651                 return (EINVAL);
1652         if (iv < 0)
1653                 return (EINVAL);
1654         switch (vtp[0]) {
1655         case 't':
1656         case 'T':
1657                 iv *= 1024;
1658         case 'g':
1659         case 'G':
1660                 iv *= 1024;
1661         case 'm':
1662         case 'M':
1663                 iv *= 1024;
1664         case 'k':
1665         case 'K':
1666                 iv *= 1024;
1667         case '\0':
1668                 break;
1669         default:
1670                 return (EINVAL);
1671         }
1672         *value = iv;
1673
1674         return (0);
1675 }
1676
1677 char *
1678 vfs_getopts(struct vfsoptlist *opts, const char *name, int *error)
1679 {
1680         struct vfsopt *opt;
1681
1682         *error = 0;
1683         TAILQ_FOREACH(opt, opts, link) {
1684                 if (strcmp(name, opt->name) != 0)
1685                         continue;
1686                 opt->seen = 1;
1687                 if (opt->len == 0 ||
1688                     ((char *)opt->value)[opt->len - 1] != '\0') {
1689                         *error = EINVAL;
1690                         return (NULL);
1691                 }
1692                 return (opt->value);
1693         }
1694         *error = ENOENT;
1695         return (NULL);
1696 }
1697
1698 int
1699 vfs_flagopt(struct vfsoptlist *opts, const char *name, uint64_t *w,
1700         uint64_t val)
1701 {
1702         struct vfsopt *opt;
1703
1704         TAILQ_FOREACH(opt, opts, link) {
1705                 if (strcmp(name, opt->name) == 0) {
1706                         opt->seen = 1;
1707                         if (w != NULL)
1708                                 *w |= val;
1709                         return (1);
1710                 }
1711         }
1712         if (w != NULL)
1713                 *w &= ~val;
1714         return (0);
1715 }
1716
1717 int
1718 vfs_scanopt(struct vfsoptlist *opts, const char *name, const char *fmt, ...)
1719 {
1720         va_list ap;
1721         struct vfsopt *opt;
1722         int ret;
1723
1724         KASSERT(opts != NULL, ("vfs_getopt: caller passed 'opts' as NULL"));
1725
1726         TAILQ_FOREACH(opt, opts, link) {
1727                 if (strcmp(name, opt->name) != 0)
1728                         continue;
1729                 opt->seen = 1;
1730                 if (opt->len == 0 || opt->value == NULL)
1731                         return (0);
1732                 if (((char *)opt->value)[opt->len - 1] != '\0')
1733                         return (0);
1734                 va_start(ap, fmt);
1735                 ret = vsscanf(opt->value, fmt, ap);
1736                 va_end(ap);
1737                 return (ret);
1738         }
1739         return (0);
1740 }
1741
1742 int
1743 vfs_setopt(struct vfsoptlist *opts, const char *name, void *value, int len)
1744 {
1745         struct vfsopt *opt;
1746
1747         TAILQ_FOREACH(opt, opts, link) {
1748                 if (strcmp(name, opt->name) != 0)
1749                         continue;
1750                 opt->seen = 1;
1751                 if (opt->value == NULL)
1752                         opt->len = len;
1753                 else {
1754                         if (opt->len != len)
1755                                 return (EINVAL);
1756                         bcopy(value, opt->value, len);
1757                 }
1758                 return (0);
1759         }
1760         return (ENOENT);
1761 }
1762
1763 int
1764 vfs_setopt_part(struct vfsoptlist *opts, const char *name, void *value, int len)
1765 {
1766         struct vfsopt *opt;
1767
1768         TAILQ_FOREACH(opt, opts, link) {
1769                 if (strcmp(name, opt->name) != 0)
1770                         continue;
1771                 opt->seen = 1;
1772                 if (opt->value == NULL)
1773                         opt->len = len;
1774                 else {
1775                         if (opt->len < len)
1776                                 return (EINVAL);
1777                         opt->len = len;
1778                         bcopy(value, opt->value, len);
1779                 }
1780                 return (0);
1781         }
1782         return (ENOENT);
1783 }
1784
1785 int
1786 vfs_setopts(struct vfsoptlist *opts, const char *name, const char *value)
1787 {
1788         struct vfsopt *opt;
1789
1790         TAILQ_FOREACH(opt, opts, link) {
1791                 if (strcmp(name, opt->name) != 0)
1792                         continue;
1793                 opt->seen = 1;
1794                 if (opt->value == NULL)
1795                         opt->len = strlen(value) + 1;
1796                 else if (strlcpy(opt->value, value, opt->len) >= opt->len)
1797                         return (EINVAL);
1798                 return (0);
1799         }
1800         return (ENOENT);
1801 }
1802
1803 /*
1804  * Find and copy a mount option.
1805  *
1806  * The size of the buffer has to be specified
1807  * in len, if it is not the same length as the
1808  * mount option, EINVAL is returned.
1809  * Returns ENOENT if the option is not found.
1810  */
1811 int
1812 vfs_copyopt(struct vfsoptlist *opts, const char *name, void *dest, int len)
1813 {
1814         struct vfsopt *opt;
1815
1816         KASSERT(opts != NULL, ("vfs_copyopt: caller passed 'opts' as NULL"));
1817
1818         TAILQ_FOREACH(opt, opts, link) {
1819                 if (strcmp(name, opt->name) == 0) {
1820                         opt->seen = 1;
1821                         if (len != opt->len)
1822                                 return (EINVAL);
1823                         bcopy(opt->value, dest, opt->len);
1824                         return (0);
1825                 }
1826         }
1827         return (ENOENT);
1828 }
1829
1830 int
1831 __vfs_statfs(struct mount *mp, struct statfs *sbp)
1832 {
1833         int error;
1834
1835         error = mp->mnt_op->vfs_statfs(mp, &mp->mnt_stat);
1836         if (sbp != &mp->mnt_stat)
1837                 *sbp = mp->mnt_stat;
1838         return (error);
1839 }
1840
1841 void
1842 vfs_mountedfrom(struct mount *mp, const char *from)
1843 {
1844
1845         bzero(mp->mnt_stat.f_mntfromname, sizeof mp->mnt_stat.f_mntfromname);
1846         strlcpy(mp->mnt_stat.f_mntfromname, from,
1847             sizeof mp->mnt_stat.f_mntfromname);
1848 }
1849
1850 /*
1851  * ---------------------------------------------------------------------
1852  * This is the api for building mount args and mounting filesystems from
1853  * inside the kernel.
1854  *
1855  * The API works by accumulation of individual args.  First error is
1856  * latched.
1857  *
1858  * XXX: should be documented in new manpage kernel_mount(9)
1859  */
1860
1861 /* A memory allocation which must be freed when we are done */
1862 struct mntaarg {
1863         SLIST_ENTRY(mntaarg)    next;
1864 };
1865
1866 /* The header for the mount arguments */
1867 struct mntarg {
1868         struct iovec *v;
1869         int len;
1870         int error;
1871         SLIST_HEAD(, mntaarg)   list;
1872 };
1873
1874 /*
1875  * Add a boolean argument.
1876  *
1877  * flag is the boolean value.
1878  * name must start with "no".
1879  */
1880 struct mntarg *
1881 mount_argb(struct mntarg *ma, int flag, const char *name)
1882 {
1883
1884         KASSERT(name[0] == 'n' && name[1] == 'o',
1885             ("mount_argb(...,%s): name must start with 'no'", name));
1886
1887         return (mount_arg(ma, name + (flag ? 2 : 0), NULL, 0));
1888 }
1889
1890 /*
1891  * Add an argument printf style
1892  */
1893 struct mntarg *
1894 mount_argf(struct mntarg *ma, const char *name, const char *fmt, ...)
1895 {
1896         va_list ap;
1897         struct mntaarg *maa;
1898         struct sbuf *sb;
1899         int len;
1900
1901         if (ma == NULL) {
1902                 ma = malloc(sizeof *ma, M_MOUNT, M_WAITOK | M_ZERO);
1903                 SLIST_INIT(&ma->list);
1904         }
1905         if (ma->error)
1906                 return (ma);
1907
1908         ma->v = realloc(ma->v, sizeof *ma->v * (ma->len + 2),
1909             M_MOUNT, M_WAITOK);
1910         ma->v[ma->len].iov_base = (void *)(uintptr_t)name;
1911         ma->v[ma->len].iov_len = strlen(name) + 1;
1912         ma->len++;
1913
1914         sb = sbuf_new_auto();
1915         va_start(ap, fmt);
1916         sbuf_vprintf(sb, fmt, ap);
1917         va_end(ap);
1918         sbuf_finish(sb);
1919         len = sbuf_len(sb) + 1;
1920         maa = malloc(sizeof *maa + len, M_MOUNT, M_WAITOK | M_ZERO);
1921         SLIST_INSERT_HEAD(&ma->list, maa, next);
1922         bcopy(sbuf_data(sb), maa + 1, len);
1923         sbuf_delete(sb);
1924
1925         ma->v[ma->len].iov_base = maa + 1;
1926         ma->v[ma->len].iov_len = len;
1927         ma->len++;
1928
1929         return (ma);
1930 }
1931
1932 /*
1933  * Add an argument which is a userland string.
1934  */
1935 struct mntarg *
1936 mount_argsu(struct mntarg *ma, const char *name, const void *val, int len)
1937 {
1938         struct mntaarg *maa;
1939         char *tbuf;
1940
1941         if (val == NULL)
1942                 return (ma);
1943         if (ma == NULL) {
1944                 ma = malloc(sizeof *ma, M_MOUNT, M_WAITOK | M_ZERO);
1945                 SLIST_INIT(&ma->list);
1946         }
1947         if (ma->error)
1948                 return (ma);
1949         maa = malloc(sizeof *maa + len, M_MOUNT, M_WAITOK | M_ZERO);
1950         SLIST_INSERT_HEAD(&ma->list, maa, next);
1951         tbuf = (void *)(maa + 1);
1952         ma->error = copyinstr(val, tbuf, len, NULL);
1953         return (mount_arg(ma, name, tbuf, -1));
1954 }
1955
1956 /*
1957  * Plain argument.
1958  *
1959  * If length is -1, treat value as a C string.
1960  */
1961 struct mntarg *
1962 mount_arg(struct mntarg *ma, const char *name, const void *val, int len)
1963 {
1964
1965         if (ma == NULL) {
1966                 ma = malloc(sizeof *ma, M_MOUNT, M_WAITOK | M_ZERO);
1967                 SLIST_INIT(&ma->list);
1968         }
1969         if (ma->error)
1970                 return (ma);
1971
1972         ma->v = realloc(ma->v, sizeof *ma->v * (ma->len + 2),
1973             M_MOUNT, M_WAITOK);
1974         ma->v[ma->len].iov_base = (void *)(uintptr_t)name;
1975         ma->v[ma->len].iov_len = strlen(name) + 1;
1976         ma->len++;
1977
1978         ma->v[ma->len].iov_base = (void *)(uintptr_t)val;
1979         if (len < 0)
1980                 ma->v[ma->len].iov_len = strlen(val) + 1;
1981         else
1982                 ma->v[ma->len].iov_len = len;
1983         ma->len++;
1984         return (ma);
1985 }
1986
1987 /*
1988  * Free a mntarg structure
1989  */
1990 static void
1991 free_mntarg(struct mntarg *ma)
1992 {
1993         struct mntaarg *maa;
1994
1995         while (!SLIST_EMPTY(&ma->list)) {
1996                 maa = SLIST_FIRST(&ma->list);
1997                 SLIST_REMOVE_HEAD(&ma->list, next);
1998                 free(maa, M_MOUNT);
1999         }
2000         free(ma->v, M_MOUNT);
2001         free(ma, M_MOUNT);
2002 }
2003
2004 /*
2005  * Mount a filesystem
2006  */
2007 int
2008 kernel_mount(struct mntarg *ma, uint64_t flags)
2009 {
2010         struct uio auio;
2011         int error;
2012
2013         KASSERT(ma != NULL, ("kernel_mount NULL ma"));
2014         KASSERT(ma->v != NULL, ("kernel_mount NULL ma->v"));
2015         KASSERT(!(ma->len & 1), ("kernel_mount odd ma->len (%d)", ma->len));
2016
2017         auio.uio_iov = ma->v;
2018         auio.uio_iovcnt = ma->len;
2019         auio.uio_segflg = UIO_SYSSPACE;
2020
2021         error = ma->error;
2022         if (!error)
2023                 error = vfs_donmount(curthread, flags, &auio);
2024         free_mntarg(ma);
2025         return (error);
2026 }
2027
2028 /*
2029  * A printflike function to mount a filesystem.
2030  */
2031 int
2032 kernel_vmount(int flags, ...)
2033 {
2034         struct mntarg *ma = NULL;
2035         va_list ap;
2036         const char *cp;
2037         const void *vp;
2038         int error;
2039
2040         va_start(ap, flags);
2041         for (;;) {
2042                 cp = va_arg(ap, const char *);
2043                 if (cp == NULL)
2044                         break;
2045                 vp = va_arg(ap, const void *);
2046                 ma = mount_arg(ma, cp, vp, (vp != NULL ? -1 : 0));
2047         }
2048         va_end(ap);
2049
2050         error = kernel_mount(ma, flags);
2051         return (error);
2052 }
2053
2054 void
2055 vfs_oexport_conv(const struct oexport_args *oexp, struct export_args *exp)
2056 {
2057
2058         bcopy(oexp, exp, sizeof(*oexp));
2059         exp->ex_numsecflavors = 0;
2060 }