1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 
  25 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  26 /*        All Rights Reserved   */
  27 
  28 /*
  29  * University Copyright- Copyright (c) 1982, 1986, 1988
  30  * The Regents of the University of California
  31  * All Rights Reserved
  32  *
  33  * University Acknowledgment- Portions of this document are derived from
  34  * software developed by the University of California, Berkeley, and its
  35  * contributors.
  36  */
  37 
  38 #include <sys/types.h>
  39 #include <sys/t_lock.h>
  40 #include <sys/param.h>
  41 #include <sys/errno.h>
  42 #include <sys/user.h>
  43 #include <sys/fstyp.h>
  44 #include <sys/kmem.h>
  45 #include <sys/systm.h>
  46 #include <sys/proc.h>
  47 #include <sys/mount.h>
  48 #include <sys/vfs.h>
  49 #include <sys/vfs_opreg.h>
  50 #include <sys/fem.h>
  51 #include <sys/mntent.h>
  52 #include <sys/stat.h>
  53 #include <sys/statvfs.h>
  54 #include <sys/statfs.h>
  55 #include <sys/cred.h>
  56 #include <sys/vnode.h>
  57 #include <sys/rwstlock.h>
  58 #include <sys/dnlc.h>
  59 #include <sys/file.h>
  60 #include <sys/time.h>
  61 #include <sys/atomic.h>
  62 #include <sys/cmn_err.h>
  63 #include <sys/buf.h>
  64 #include <sys/swap.h>
  65 #include <sys/debug.h>
  66 #include <sys/vnode.h>
  67 #include <sys/modctl.h>
  68 #include <sys/ddi.h>
  69 #include <sys/pathname.h>
  70 #include <sys/bootconf.h>
  71 #include <sys/dumphdr.h>
  72 #include <sys/dc_ki.h>
  73 #include <sys/poll.h>
  74 #include <sys/sunddi.h>
  75 #include <sys/sysmacros.h>
  76 #include <sys/zone.h>
  77 #include <sys/policy.h>
  78 #include <sys/ctfs.h>
  79 #include <sys/objfs.h>
  80 #include <sys/console.h>
  81 #include <sys/reboot.h>
  82 #include <sys/attr.h>
  83 #include <sys/zio.h>
  84 #include <sys/spa.h>
  85 #include <sys/lofi.h>
  86 #include <sys/bootprops.h>
  87 #include <sys/fsh.h>
  88 #include <sys/fsh_impl.h>
  89 
  90 #include <vm/page.h>
  91 
  92 #include <fs/fs_subr.h>
  93 /* Private interfaces to create vopstats-related data structures */
  94 extern void             initialize_vopstats(vopstats_t *);
  95 extern vopstats_t       *get_fstype_vopstats(struct vfs *, struct vfssw *);
  96 extern vsk_anchor_t     *get_vskstat_anchor(struct vfs *);
  97 
  98 static void vfs_clearmntopt_nolock(mntopts_t *, const char *, int);
  99 static void vfs_setmntopt_nolock(mntopts_t *, const char *,
 100     const char *, int, int);
 101 static int  vfs_optionisset_nolock(const mntopts_t *, const char *, char **);
 102 static void vfs_freemnttab(struct vfs *);
 103 static void vfs_freeopt(mntopt_t *);
 104 static void vfs_swapopttbl_nolock(mntopts_t *, mntopts_t *);
 105 static void vfs_swapopttbl(mntopts_t *, mntopts_t *);
 106 static void vfs_copyopttbl_extend(const mntopts_t *, mntopts_t *, int);
 107 static void vfs_createopttbl_extend(mntopts_t *, const char *,
 108     const mntopts_t *);
 109 static char **vfs_copycancelopt_extend(char **const, int);
 110 static void vfs_freecancelopt(char **);
 111 static void getrootfs(char **, char **);
 112 static int getmacpath(dev_info_t *, void *);
 113 static void vfs_mnttabvp_setup(void);
 114 
 115 struct ipmnt {
 116         struct ipmnt    *mip_next;
 117         dev_t           mip_dev;
 118         struct vfs      *mip_vfsp;
 119 };
 120 
 121 static kmutex_t         vfs_miplist_mutex;
 122 static struct ipmnt     *vfs_miplist = NULL;
 123 static struct ipmnt     *vfs_miplist_end = NULL;
 124 
 125 static kmem_cache_t *vfs_cache; /* Pointer to VFS kmem cache */
 126 
 127 /*
 128  * VFS global data.
 129  */
 130 vnode_t *rootdir;               /* pointer to root inode vnode. */
 131 vnode_t *devicesdir;            /* pointer to inode of devices root */
 132 vnode_t *devdir;                /* pointer to inode of dev root */
 133 
 134 char *server_rootpath;          /* root path for diskless clients */
 135 char *server_hostname;          /* hostname of diskless server */
 136 
 137 static struct vfs root;
 138 static struct vfs devices;
 139 static struct vfs dev;
 140 struct vfs *rootvfs = &root;        /* pointer to root vfs; head of VFS list. */
 141 rvfs_t *rvfs_list;              /* array of vfs ptrs for vfs hash list */
 142 int vfshsz = 512;               /* # of heads/locks in vfs hash arrays */
 143                                 /* must be power of 2!  */
 144 timespec_t vfs_mnttab_ctime;    /* mnttab created time */
 145 timespec_t vfs_mnttab_mtime;    /* mnttab last modified time */
 146 char *vfs_dummyfstype = "\0";
 147 struct pollhead vfs_pollhd;     /* for mnttab pollers */
 148 struct vnode *vfs_mntdummyvp;   /* to fake mnttab read/write for file events */
 149 int     mntfstype;              /* will be set once mnt fs is mounted */
 150 
 151 /*
 152  * Table for generic options recognized in the VFS layer and acted
 153  * on at this level before parsing file system specific options.
 154  * The nosuid option is stronger than any of the devices and setuid
 155  * options, so those are canceled when nosuid is seen.
 156  *
 157  * All options which are added here need to be added to the
 158  * list of standard options in usr/src/cmd/fs.d/fslib.c as well.
 159  */
 160 /*
 161  * VFS Mount options table
 162  */
 163 static char *ro_cancel[] = { MNTOPT_RW, NULL };
 164 static char *rw_cancel[] = { MNTOPT_RO, NULL };
 165 static char *suid_cancel[] = { MNTOPT_NOSUID, NULL };
 166 static char *nosuid_cancel[] = { MNTOPT_SUID, MNTOPT_DEVICES, MNTOPT_NODEVICES,
 167     MNTOPT_NOSETUID, MNTOPT_SETUID, NULL };
 168 static char *devices_cancel[] = { MNTOPT_NODEVICES, NULL };
 169 static char *nodevices_cancel[] = { MNTOPT_DEVICES, NULL };
 170 static char *setuid_cancel[] = { MNTOPT_NOSETUID, NULL };
 171 static char *nosetuid_cancel[] = { MNTOPT_SETUID, NULL };
 172 static char *nbmand_cancel[] = { MNTOPT_NONBMAND, NULL };
 173 static char *nonbmand_cancel[] = { MNTOPT_NBMAND, NULL };
 174 static char *exec_cancel[] = { MNTOPT_NOEXEC, NULL };
 175 static char *noexec_cancel[] = { MNTOPT_EXEC, NULL };
 176 
 177 static const mntopt_t mntopts[] = {
 178 /*
 179  *      option name             cancel options          default arg     flags
 180  */
 181         { MNTOPT_REMOUNT,       NULL,                   NULL,
 182                 MO_NODISPLAY, (void *)0 },
 183         { MNTOPT_RO,            ro_cancel,              NULL,           0,
 184                 (void *)0 },
 185         { MNTOPT_RW,            rw_cancel,              NULL,           0,
 186                 (void *)0 },
 187         { MNTOPT_SUID,          suid_cancel,            NULL,           0,
 188                 (void *)0 },
 189         { MNTOPT_NOSUID,        nosuid_cancel,          NULL,           0,
 190                 (void *)0 },
 191         { MNTOPT_DEVICES,       devices_cancel,         NULL,           0,
 192                 (void *)0 },
 193         { MNTOPT_NODEVICES,     nodevices_cancel,       NULL,           0,
 194                 (void *)0 },
 195         { MNTOPT_SETUID,        setuid_cancel,          NULL,           0,
 196                 (void *)0 },
 197         { MNTOPT_NOSETUID,      nosetuid_cancel,        NULL,           0,
 198                 (void *)0 },
 199         { MNTOPT_NBMAND,        nbmand_cancel,          NULL,           0,
 200                 (void *)0 },
 201         { MNTOPT_NONBMAND,      nonbmand_cancel,        NULL,           0,
 202                 (void *)0 },
 203         { MNTOPT_EXEC,          exec_cancel,            NULL,           0,
 204                 (void *)0 },
 205         { MNTOPT_NOEXEC,        noexec_cancel,          NULL,           0,
 206                 (void *)0 },
 207 };
 208 
 209 const mntopts_t vfs_mntopts = {
 210         sizeof (mntopts) / sizeof (mntopt_t),
 211         (mntopt_t *)&mntopts[0]
 212 };
 213 
 214 /*
 215  * File system operation dispatch functions.
 216  */
 217 
 218 int
 219 fsop_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
 220 {
 221         return (fsh_mount(vfsp, mvp, uap, cr));
 222 }
 223 
 224 int
 225 fsop_unmount(vfs_t *vfsp, int flag, cred_t *cr)
 226 {
 227         return (fsh_unmount(vfsp, flag, cr));
 228 }
 229 
 230 int
 231 fsop_root(vfs_t *vfsp, vnode_t **vpp)
 232 {
 233         refstr_t *mntpt;
 234         int ret = fsh_root(vfsp, vpp);
 235         /*
 236          * Make sure this root has a path.  With lofs, it is possible to have
 237          * a NULL mountpoint.
 238          */
 239         if (ret == 0 && vfsp->vfs_mntpt != NULL && (*vpp)->v_path == NULL) {
 240                 mntpt = vfs_getmntpoint(vfsp);
 241                 vn_setpath_str(*vpp, refstr_value(mntpt),
 242                     strlen(refstr_value(mntpt)));
 243                 refstr_rele(mntpt);
 244         }
 245 
 246         return (ret);
 247 }
 248 
 249 int
 250 fsop_statfs(vfs_t *vfsp, statvfs64_t *sp)
 251 {
 252         return (fsh_statfs(vfsp, sp));
 253 }
 254 
 255 int
 256 fsop_sync(vfs_t *vfsp, short flag, cred_t *cr)
 257 {
 258         return (*(vfsp)->vfs_op->vfs_sync)(vfsp, flag, cr);
 259 }
 260 
 261 int
 262 fsop_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
 263 {
 264         /*
 265          * In order to handle system attribute fids in a manner
 266          * transparent to the underlying fs, we embed the fid for
 267          * the sysattr parent object in the sysattr fid and tack on
 268          * some extra bytes that only the sysattr layer knows about.
 269          *
 270          * This guarantees that sysattr fids are larger than other fids
 271          * for this vfs. If the vfs supports the sysattr view interface
 272          * (as indicated by VFSFT_SYSATTR_VIEWS), we cannot have a size
 273          * collision with XATTR_FIDSZ.
 274          */
 275         if (vfs_has_feature(vfsp, VFSFT_SYSATTR_VIEWS) &&
 276             fidp->fid_len == XATTR_FIDSZ)
 277                 return (xattr_dir_vget(vfsp, vpp, fidp));
 278 
 279         return (fsh_vget(vfsp, vpp, fidp));
 280 }
 281 
 282 int
 283 fsop_mountroot(vfs_t *vfsp, enum whymountroot reason)
 284 {
 285         return (*(vfsp)->vfs_op->vfs_mountroot)(vfsp, reason);
 286 }
 287 
 288 void
 289 fsop_freefs(vfs_t *vfsp)
 290 {
 291         (*(vfsp)->vfs_op->vfs_freevfs)(vfsp);
 292 }
 293 
 294 int
 295 fsop_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate)
 296 {
 297         return ((*(vfsp)->vfs_op->vfs_vnstate)(vfsp, vp, nstate));
 298 }
 299 
 300 int
 301 fsop_sync_by_kind(int fstype, short flag, cred_t *cr)
 302 {
 303         ASSERT((fstype >= 0) && (fstype < nfstype));
 304 
 305         if (ALLOCATED_VFSSW(&vfssw[fstype]) && VFS_INSTALLED(&vfssw[fstype]))
 306                 return (*vfssw[fstype].vsw_vfsops.vfs_sync) (NULL, flag, cr);
 307         else
 308                 return (ENOTSUP);
 309 }
 310 
 311 /*
 312  * File system initialization.  vfs_setfsops() must be called from a file
 313  * system's init routine.
 314  */
 315 
 316 static int
 317 fs_copyfsops(const fs_operation_def_t *template, vfsops_t *actual,
 318     int *unused_ops)
 319 {
 320         static const fs_operation_trans_def_t vfs_ops_table[] = {
 321                 VFSNAME_MOUNT, offsetof(vfsops_t, vfs_mount),
 322                         fs_nosys, fs_nosys,
 323 
 324                 VFSNAME_UNMOUNT, offsetof(vfsops_t, vfs_unmount),
 325                         fs_nosys, fs_nosys,
 326 
 327                 VFSNAME_ROOT, offsetof(vfsops_t, vfs_root),
 328                         fs_nosys, fs_nosys,
 329 
 330                 VFSNAME_STATVFS, offsetof(vfsops_t, vfs_statvfs),
 331                         fs_nosys, fs_nosys,
 332 
 333                 VFSNAME_SYNC, offsetof(vfsops_t, vfs_sync),
 334                         (fs_generic_func_p) fs_sync,
 335                         (fs_generic_func_p) fs_sync,    /* No errors allowed */
 336 
 337                 VFSNAME_VGET, offsetof(vfsops_t, vfs_vget),
 338                         fs_nosys, fs_nosys,
 339 
 340                 VFSNAME_MOUNTROOT, offsetof(vfsops_t, vfs_mountroot),
 341                         fs_nosys, fs_nosys,
 342 
 343                 VFSNAME_FREEVFS, offsetof(vfsops_t, vfs_freevfs),
 344                         (fs_generic_func_p)fs_freevfs,
 345                         (fs_generic_func_p)fs_freevfs,  /* Shouldn't fail */
 346 
 347                 VFSNAME_VNSTATE, offsetof(vfsops_t, vfs_vnstate),
 348                         (fs_generic_func_p)fs_nosys,
 349                         (fs_generic_func_p)fs_nosys,
 350 
 351                 NULL, 0, NULL, NULL
 352         };
 353 
 354         return (fs_build_vector(actual, unused_ops, vfs_ops_table, template));
 355 }
 356 
 357 void
 358 zfs_boot_init() {
 359 
 360         if (strcmp(rootfs.bo_fstype, MNTTYPE_ZFS) == 0)
 361                 spa_boot_init();
 362 }
 363 
 364 int
 365 vfs_setfsops(int fstype, const fs_operation_def_t *template, vfsops_t **actual)
 366 {
 367         int error;
 368         int unused_ops;
 369 
 370         /*
 371          * Verify that fstype refers to a valid fs.  Note that
 372          * 0 is valid since it's used to set "stray" ops.
 373          */
 374         if ((fstype < 0) || (fstype >= nfstype))
 375                 return (EINVAL);
 376 
 377         if (!ALLOCATED_VFSSW(&vfssw[fstype]))
 378                 return (EINVAL);
 379 
 380         /* Set up the operations vector. */
 381 
 382         error = fs_copyfsops(template, &vfssw[fstype].vsw_vfsops, &unused_ops);
 383 
 384         if (error != 0)
 385                 return (error);
 386 
 387         vfssw[fstype].vsw_flag |= VSW_INSTALLED;
 388 
 389         if (actual != NULL)
 390                 *actual = &vfssw[fstype].vsw_vfsops;
 391 
 392 #if DEBUG
 393         if (unused_ops != 0)
 394                 cmn_err(CE_WARN, "vfs_setfsops: %s: %d operations supplied "
 395                     "but not used", vfssw[fstype].vsw_name, unused_ops);
 396 #endif
 397 
 398         return (0);
 399 }
 400 
 401 int
 402 vfs_makefsops(const fs_operation_def_t *template, vfsops_t **actual)
 403 {
 404         int error;
 405         int unused_ops;
 406 
 407         *actual = (vfsops_t *)kmem_alloc(sizeof (vfsops_t), KM_SLEEP);
 408 
 409         error = fs_copyfsops(template, *actual, &unused_ops);
 410         if (error != 0) {
 411                 kmem_free(*actual, sizeof (vfsops_t));
 412                 *actual = NULL;
 413                 return (error);
 414         }
 415 
 416         return (0);
 417 }
 418 
 419 /*
 420  * Free a vfsops structure created as a result of vfs_makefsops().
 421  * NOTE: For a vfsops structure initialized by vfs_setfsops(), use
 422  * vfs_freevfsops_by_type().
 423  */
 424 void
 425 vfs_freevfsops(vfsops_t *vfsops)
 426 {
 427         kmem_free(vfsops, sizeof (vfsops_t));
 428 }
 429 
 430 /*
 431  * Since the vfsops structure is part of the vfssw table and wasn't
 432  * really allocated, we're not really freeing anything.  We keep
 433  * the name for consistency with vfs_freevfsops().  We do, however,
 434  * need to take care of a little bookkeeping.
 435  * NOTE: For a vfsops structure created by vfs_setfsops(), use
 436  * vfs_freevfsops_by_type().
 437  */
 438 int
 439 vfs_freevfsops_by_type(int fstype)
 440 {
 441 
 442         /* Verify that fstype refers to a loaded fs (and not fsid 0). */
 443         if ((fstype <= 0) || (fstype >= nfstype))
 444                 return (EINVAL);
 445 
 446         WLOCK_VFSSW();
 447         if ((vfssw[fstype].vsw_flag & VSW_INSTALLED) == 0) {
 448                 WUNLOCK_VFSSW();
 449                 return (EINVAL);
 450         }
 451 
 452         vfssw[fstype].vsw_flag &= ~VSW_INSTALLED;
 453         WUNLOCK_VFSSW();
 454 
 455         return (0);
 456 }
 457 
 458 /* Support routines used to reference vfs_op */
 459 
 460 /* Set the operations vector for a vfs */
 461 void
 462 vfs_setops(vfs_t *vfsp, vfsops_t *vfsops)
 463 {
 464         vfsops_t        *op;
 465 
 466         ASSERT(vfsp != NULL);
 467         ASSERT(vfsops != NULL);
 468 
 469         op = vfsp->vfs_op;
 470         membar_consumer();
 471         if (vfsp->vfs_femhead == NULL &&
 472             casptr(&vfsp->vfs_op, op, vfsops) == op) {
 473                 return;
 474         }
 475         fsem_setvfsops(vfsp, vfsops);
 476 }
 477 
 478 /* Retrieve the operations vector for a vfs */
 479 vfsops_t *
 480 vfs_getops(vfs_t *vfsp)
 481 {
 482         vfsops_t        *op;
 483 
 484         ASSERT(vfsp != NULL);
 485 
 486         op = vfsp->vfs_op;
 487         membar_consumer();
 488         if (vfsp->vfs_femhead == NULL && op == vfsp->vfs_op) {
 489                 return (op);
 490         } else {
 491                 return (fsem_getvfsops(vfsp));
 492         }
 493 }
 494 
 495 /*
 496  * Returns non-zero (1) if the vfsops matches that of the vfs.
 497  * Returns zero (0) if not.
 498  */
 499 int
 500 vfs_matchops(vfs_t *vfsp, vfsops_t *vfsops)
 501 {
 502         return (vfs_getops(vfsp) == vfsops);
 503 }
 504 
 505 /*
 506  * Returns non-zero (1) if the file system has installed a non-default,
 507  * non-error vfs_sync routine.  Returns zero (0) otherwise.
 508  */
 509 int
 510 vfs_can_sync(vfs_t *vfsp)
 511 {
 512         /* vfs_sync() routine is not the default/error function */
 513         return (vfs_getops(vfsp)->vfs_sync != fs_sync);
 514 }
 515 
 516 /*
 517  * Initialize a vfs structure.
 518  */
 519 void
 520 vfs_init(vfs_t *vfsp, vfsops_t *op, void *data)
 521 {
 522         /* Other initialization has been moved to vfs_alloc() */
 523         vfsp->vfs_count = 0;
 524         vfsp->vfs_next = vfsp;
 525         vfsp->vfs_prev = vfsp;
 526         vfsp->vfs_zone_next = vfsp;
 527         vfsp->vfs_zone_prev = vfsp;
 528         vfsp->vfs_lofi_minor = 0;
 529         sema_init(&vfsp->vfs_reflock, 1, NULL, SEMA_DEFAULT, NULL);
 530         vfsimpl_setup(vfsp);
 531         vfsp->vfs_data = (data);
 532         vfs_setops((vfsp), (op));
 533         vfsp->vfs_fshrecord = fsh_fsrec_create();
 534 }
 535 
 536 /*
 537  * Allocate and initialize the vfs implementation private data
 538  * structure, vfs_impl_t.
 539  */
 540 void
 541 vfsimpl_setup(vfs_t *vfsp)
 542 {
 543         int i;
 544 
 545         if (vfsp->vfs_implp != NULL) {
 546                 return;
 547         }
 548 
 549         vfsp->vfs_implp = kmem_alloc(sizeof (vfs_impl_t), KM_SLEEP);
 550         /* Note that these are #define'd in vfs.h */
 551         vfsp->vfs_vskap = NULL;
 552         vfsp->vfs_fstypevsp = NULL;
 553 
 554         /* Set size of counted array, then zero the array */
 555         vfsp->vfs_featureset[0] = VFS_FEATURE_MAXSZ - 1;
 556         for (i = 1; i <  VFS_FEATURE_MAXSZ; i++) {
 557                 vfsp->vfs_featureset[i] = 0;
 558         }
 559 }
 560 
 561 /*
 562  * Release the vfs_impl_t structure, if it exists. Some unbundled
 563  * filesystems may not use the newer version of vfs and thus
 564  * would not contain this implementation private data structure.
 565  */
 566 void
 567 vfsimpl_teardown(vfs_t *vfsp)
 568 {
 569         vfs_impl_t      *vip = vfsp->vfs_implp;
 570 
 571         if (vip == NULL)
 572                 return;
 573 
 574         kmem_free(vfsp->vfs_implp, sizeof (vfs_impl_t));
 575         vfsp->vfs_implp = NULL;
 576 }
 577 
 578 /*
 579  * VFS system calls: mount, umount, syssync, statfs, fstatfs, statvfs,
 580  * fstatvfs, and sysfs moved to common/syscall.
 581  */
 582 
 583 /*
 584  * Update every mounted file system.  We call the vfs_sync operation of
 585  * each file system type, passing it a NULL vfsp to indicate that all
 586  * mounted file systems of that type should be updated.
 587  */
 588 void
 589 vfs_sync(int flag)
 590 {
 591         struct vfssw *vswp;
 592         RLOCK_VFSSW();
 593         for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
 594                 if (ALLOCATED_VFSSW(vswp) && VFS_INSTALLED(vswp)) {
 595                         vfs_refvfssw(vswp);
 596                         RUNLOCK_VFSSW();
 597                         (void) (*vswp->vsw_vfsops.vfs_sync)(NULL, flag,
 598                             CRED());
 599                         vfs_unrefvfssw(vswp);
 600                         RLOCK_VFSSW();
 601                 }
 602         }
 603         RUNLOCK_VFSSW();
 604 }
 605 
 606 void
 607 sync(void)
 608 {
 609         vfs_sync(0);
 610 }
 611 
 612 /*
 613  * External routines.
 614  */
 615 
 616 krwlock_t vfssw_lock;   /* lock accesses to vfssw */
 617 
 618 /*
 619  * Lock for accessing the vfs linked list.  Initialized in vfs_mountroot(),
 620  * but otherwise should be accessed only via vfs_list_lock() and
 621  * vfs_list_unlock().  Also used to protect the timestamp for mods to the list.
 622  */
 623 static krwlock_t vfslist;
 624 
 625 /*
 626  * Mount devfs on /devices. This is done right after root is mounted
 627  * to provide device access support for the system
 628  */
 629 static void
 630 vfs_mountdevices(void)
 631 {
 632         struct vfssw *vsw;
 633         struct vnode *mvp;
 634         struct mounta mounta = {        /* fake mounta for devfs_mount() */
 635                 NULL,
 636                 NULL,
 637                 MS_SYSSPACE,
 638                 NULL,
 639                 NULL,
 640                 0,
 641                 NULL,
 642                 0
 643         };
 644 
 645         /*
 646          * _init devfs module to fill in the vfssw
 647          */
 648         if (modload("fs", "devfs") == -1)
 649                 panic("Cannot _init devfs module");
 650 
 651         /*
 652          * Hold vfs
 653          */
 654         RLOCK_VFSSW();
 655         vsw = vfs_getvfsswbyname("devfs");
 656         VFS_INIT(&devices, &vsw->vsw_vfsops, NULL);
 657         VFS_HOLD(&devices);
 658 
 659         /*
 660          * Locate mount point
 661          */
 662         if (lookupname("/devices", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp))
 663                 panic("Cannot find /devices");
 664 
 665         /*
 666          * Perform the mount of /devices
 667          */
 668         if (VFS_MOUNT(&devices, mvp, &mounta, CRED()))
 669                 panic("Cannot mount /devices");
 670 
 671         RUNLOCK_VFSSW();
 672 
 673         /*
 674          * Set appropriate members and add to vfs list for mnttab display
 675          */
 676         vfs_setresource(&devices, "/devices", 0);
 677         vfs_setmntpoint(&devices, "/devices", 0);
 678 
 679         /*
 680          * Hold the root of /devices so it won't go away
 681          */
 682         if (VFS_ROOT(&devices, &devicesdir))
 683                 panic("vfs_mountdevices: not devices root");
 684 
 685         if (vfs_lock(&devices) != 0) {
 686                 VN_RELE(devicesdir);
 687                 cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /devices");
 688                 return;
 689         }
 690 
 691         if (vn_vfswlock(mvp) != 0) {
 692                 vfs_unlock(&devices);
 693                 VN_RELE(devicesdir);
 694                 cmn_err(CE_NOTE, "Cannot acquire vfswlock of /devices");
 695                 return;
 696         }
 697 
 698         vfs_add(mvp, &devices, 0);
 699         vn_vfsunlock(mvp);
 700         vfs_unlock(&devices);
 701         VN_RELE(devicesdir);
 702 }
 703 
 704 /*
 705  * mount the first instance of /dev  to root and remain mounted
 706  */
 707 static void
 708 vfs_mountdev1(void)
 709 {
 710         struct vfssw *vsw;
 711         struct vnode *mvp;
 712         struct mounta mounta = {        /* fake mounta for sdev_mount() */
 713                 NULL,
 714                 NULL,
 715                 MS_SYSSPACE | MS_OVERLAY,
 716                 NULL,
 717                 NULL,
 718                 0,
 719                 NULL,
 720                 0
 721         };
 722 
 723         /*
 724          * _init dev module to fill in the vfssw
 725          */
 726         if (modload("fs", "dev") == -1)
 727                 cmn_err(CE_PANIC, "Cannot _init dev module\n");
 728 
 729         /*
 730          * Hold vfs
 731          */
 732         RLOCK_VFSSW();
 733         vsw = vfs_getvfsswbyname("dev");
 734         VFS_INIT(&dev, &vsw->vsw_vfsops, NULL);
 735         VFS_HOLD(&dev);
 736 
 737         /*
 738          * Locate mount point
 739          */
 740         if (lookupname("/dev", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp))
 741                 cmn_err(CE_PANIC, "Cannot find /dev\n");
 742 
 743         /*
 744          * Perform the mount of /dev
 745          */
 746         if (VFS_MOUNT(&dev, mvp, &mounta, CRED()))
 747                 cmn_err(CE_PANIC, "Cannot mount /dev 1\n");
 748 
 749         RUNLOCK_VFSSW();
 750 
 751         /*
 752          * Set appropriate members and add to vfs list for mnttab display
 753          */
 754         vfs_setresource(&dev, "/dev", 0);
 755         vfs_setmntpoint(&dev, "/dev", 0);
 756 
 757         /*
 758          * Hold the root of /dev so it won't go away
 759          */
 760         if (VFS_ROOT(&dev, &devdir))
 761                 cmn_err(CE_PANIC, "vfs_mountdev1: not dev root");
 762 
 763         if (vfs_lock(&dev) != 0) {
 764                 VN_RELE(devdir);
 765                 cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /dev");
 766                 return;
 767         }
 768 
 769         if (vn_vfswlock(mvp) != 0) {
 770                 vfs_unlock(&dev);
 771                 VN_RELE(devdir);
 772                 cmn_err(CE_NOTE, "Cannot acquire vfswlock of /dev");
 773                 return;
 774         }
 775 
 776         vfs_add(mvp, &dev, 0);
 777         vn_vfsunlock(mvp);
 778         vfs_unlock(&dev);
 779         VN_RELE(devdir);
 780 }
 781 
 782 /*
 783  * Mount required filesystem. This is done right after root is mounted.
 784  */
 785 static void
 786 vfs_mountfs(char *module, char *spec, char *path)
 787 {
 788         struct vnode *mvp;
 789         struct mounta mounta;
 790         vfs_t *vfsp;
 791 
 792         mounta.flags = MS_SYSSPACE | MS_DATA;
 793         mounta.fstype = module;
 794         mounta.spec = spec;
 795         mounta.dir = path;
 796         if (lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) {
 797                 cmn_err(CE_WARN, "Cannot find %s", path);
 798                 return;
 799         }
 800         if (domount(NULL, &mounta, mvp, CRED(), &vfsp))
 801                 cmn_err(CE_WARN, "Cannot mount %s", path);
 802         else
 803                 VFS_RELE(vfsp);
 804         VN_RELE(mvp);
 805 }
 806 
 807 /*
 808  * vfs_mountroot is called by main() to mount the root filesystem.
 809  */
 810 void
 811 vfs_mountroot(void)
 812 {
 813         struct vnode    *rvp = NULL;
 814         char            *path;
 815         size_t          plen;
 816         struct vfssw    *vswp;
 817         proc_t          *p;
 818 
 819         rw_init(&vfssw_lock, NULL, RW_DEFAULT, NULL);
 820         rw_init(&vfslist, NULL, RW_DEFAULT, NULL);
 821 
 822         /*
 823          * Alloc the vfs hash bucket array and locks
 824          */
 825         rvfs_list = kmem_zalloc(vfshsz * sizeof (rvfs_t), KM_SLEEP);
 826 
 827         /*
 828          * Call machine-dependent routine "rootconf" to choose a root
 829          * file system type.
 830          */
 831         if (rootconf())
 832                 panic("vfs_mountroot: cannot mount root");
 833         /*
 834          * Get vnode for '/'.  Set up rootdir, u.u_rdir and u.u_cdir
 835          * to point to it.  These are used by lookuppn() so that it
 836          * knows where to start from ('/' or '.').
 837          */
 838         vfs_setmntpoint(rootvfs, "/", 0);
 839         if (VFS_ROOT(rootvfs, &rootdir))
 840                 panic("vfs_mountroot: no root vnode");
 841 
 842         /*
 843          * At this point, the process tree consists of p0 and possibly some
 844          * direct children of p0.  (i.e. there are no grandchildren)
 845          *
 846          * Walk through them all, setting their current directory.
 847          */
 848         mutex_enter(&pidlock);
 849         for (p = practive; p != NULL; p = p->p_next) {
 850                 ASSERT(p == &p0 || p->p_parent == &p0);
 851 
 852                 PTOU(p)->u_cdir = rootdir;
 853                 VN_HOLD(PTOU(p)->u_cdir);
 854                 PTOU(p)->u_rdir = NULL;
 855         }
 856         mutex_exit(&pidlock);
 857 
 858         /*
 859          * Setup the global zone's rootvp, now that it exists.
 860          */
 861         global_zone->zone_rootvp = rootdir;
 862         VN_HOLD(global_zone->zone_rootvp);
 863 
 864         /*
 865          * Notify the module code that it can begin using the
 866          * root filesystem instead of the boot program's services.
 867          */
 868         modrootloaded = 1;
 869 
 870         /*
 871          * Special handling for a ZFS root file system.
 872          */
 873         zfs_boot_init();
 874 
 875         /*
 876          * Set up mnttab information for root
 877          */
 878         vfs_setresource(rootvfs, rootfs.bo_name, 0);
 879 
 880         /*
 881          * Notify cluster software that the root filesystem is available.
 882          */
 883         clboot_mountroot();
 884 
 885         /* Now that we're all done with the root FS, set up its vopstats */
 886         if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) != NULL) {
 887                 /* Set flag for statistics collection */
 888                 if (vswp->vsw_flag & VSW_STATS) {
 889                         initialize_vopstats(&rootvfs->vfs_vopstats);
 890                         rootvfs->vfs_flag |= VFS_STATS;
 891                         rootvfs->vfs_fstypevsp =
 892                             get_fstype_vopstats(rootvfs, vswp);
 893                         rootvfs->vfs_vskap = get_vskstat_anchor(rootvfs);
 894                 }
 895                 vfs_unrefvfssw(vswp);
 896         }
 897 
 898         /*
 899          * Mount /devices, /dev instance 1, /system/contract, /etc/mnttab,
 900          * /etc/svc/volatile, /etc/dfs/sharetab, /system/object, and /proc.
 901          */
 902         vfs_mountdevices();
 903         vfs_mountdev1();
 904 
 905         vfs_mountfs("ctfs", "ctfs", CTFS_ROOT);
 906         vfs_mountfs("proc", "/proc", "/proc");
 907         vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab");
 908         vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile");
 909         vfs_mountfs("objfs", "objfs", OBJFS_ROOT);
 910 
 911         if (getzoneid() == GLOBAL_ZONEID) {
 912                 vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab");
 913         }
 914 
 915 #ifdef __sparc
 916         /*
 917          * This bit of magic can go away when we convert sparc to
 918          * the new boot architecture based on ramdisk.
 919          *
 920          * Booting off a mirrored root volume:
 921          * At this point, we have booted and mounted root on a
 922          * single component of the mirror.  Complete the boot
 923          * by configuring SVM and converting the root to the
 924          * dev_t of the mirrored root device.  This dev_t conversion
 925          * only works because the underlying device doesn't change.
 926          */
 927         if (root_is_svm) {
 928                 if (svm_rootconf()) {
 929                         panic("vfs_mountroot: cannot remount root");
 930                 }
 931 
 932                 /*
 933                  * mnttab should reflect the new root device
 934                  */
 935                 vfs_lock_wait(rootvfs);
 936                 vfs_setresource(rootvfs, rootfs.bo_name, 0);
 937                 vfs_unlock(rootvfs);
 938         }
 939 #endif /* __sparc */
 940 
 941         if (strcmp(rootfs.bo_fstype, "zfs") != 0) {
 942                 /*
 943                  * Look up the root device via devfs so that a dv_node is
 944                  * created for it. The vnode is never VN_RELE()ed.
 945                  * We allocate more than MAXPATHLEN so that the
 946                  * buffer passed to i_ddi_prompath_to_devfspath() is
 947                  * exactly MAXPATHLEN (the function expects a buffer
 948                  * of that length).
 949                  */
 950                 plen = strlen("/devices");
 951                 path = kmem_alloc(plen + MAXPATHLEN, KM_SLEEP);
 952                 (void) strcpy(path, "/devices");
 953 
 954                 if (i_ddi_prompath_to_devfspath(rootfs.bo_name, path + plen)
 955                     != DDI_SUCCESS ||
 956                     lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &rvp)) {
 957 
 958                         /* NUL terminate in case "path" has garbage */
 959                         path[plen + MAXPATHLEN - 1] = '\0';
 960 #ifdef  DEBUG
 961                         cmn_err(CE_WARN, "!Cannot lookup root device: %s",
 962                             path);
 963 #endif
 964                 }
 965                 kmem_free(path, plen + MAXPATHLEN);
 966         }
 967 
 968         vfs_mnttabvp_setup();
 969 }
 970 
 971 /*
 972  * Check to see if our "block device" is actually a file.  If so,
 973  * automatically add a lofi device, and keep track of this fact.
 974  */
 975 static int
 976 lofi_add(const char *fsname, struct vfs *vfsp,
 977     mntopts_t *mntopts, struct mounta *uap)
 978 {
 979         int fromspace = (uap->flags & MS_SYSSPACE) ?
 980             UIO_SYSSPACE : UIO_USERSPACE;
 981         struct lofi_ioctl *li = NULL;
 982         struct vnode *vp = NULL;
 983         struct pathname pn = { NULL };
 984         ldi_ident_t ldi_id;
 985         ldi_handle_t ldi_hdl;
 986         vfssw_t *vfssw;
 987         int minor;
 988         int err = 0;
 989 
 990         if ((vfssw = vfs_getvfssw(fsname)) == NULL)
 991                 return (0);
 992 
 993         if (!(vfssw->vsw_flag & VSW_CANLOFI)) {
 994                 vfs_unrefvfssw(vfssw);
 995                 return (0);
 996         }
 997 
 998         vfs_unrefvfssw(vfssw);
 999         vfssw = NULL;
1000 
1001         if (pn_get(uap->spec, fromspace, &pn) != 0)
1002                 return (0);
1003 
1004         if (lookupname(uap->spec, fromspace, FOLLOW, NULL, &vp) != 0)
1005                 goto out;
1006 
1007         if (vp->v_type != VREG)
1008                 goto out;
1009 
1010         /* OK, this is a lofi mount. */
1011 
1012         if ((uap->flags & (MS_REMOUNT|MS_GLOBAL)) ||
1013             vfs_optionisset_nolock(mntopts, MNTOPT_SUID, NULL) ||
1014             vfs_optionisset_nolock(mntopts, MNTOPT_SETUID, NULL) ||
1015             vfs_optionisset_nolock(mntopts, MNTOPT_DEVICES, NULL)) {
1016                 err = EINVAL;
1017                 goto out;
1018         }
1019 
1020         ldi_id = ldi_ident_from_anon();
1021         li = kmem_zalloc(sizeof (*li), KM_SLEEP);
1022         (void) strlcpy(li->li_filename, pn.pn_path, MAXPATHLEN);
1023 
1024         err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred,
1025             &ldi_hdl, ldi_id);
1026 
1027         if (err)
1028                 goto out2;
1029 
1030         err = ldi_ioctl(ldi_hdl, LOFI_MAP_FILE, (intptr_t)li,
1031             FREAD | FWRITE | FKIOCTL, kcred, &minor);
1032 
1033         (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred);
1034 
1035         if (!err)
1036                 vfsp->vfs_lofi_minor = minor;
1037 
1038 out2:
1039         ldi_ident_release(ldi_id);
1040 out:
1041         if (li != NULL)
1042                 kmem_free(li, sizeof (*li));
1043         if (vp != NULL)
1044                 VN_RELE(vp);
1045         pn_free(&pn);
1046         return (err);
1047 }
1048 
1049 static void
1050 lofi_remove(struct vfs *vfsp)
1051 {
1052         struct lofi_ioctl *li = NULL;
1053         ldi_ident_t ldi_id;
1054         ldi_handle_t ldi_hdl;
1055         int err;
1056 
1057         if (vfsp->vfs_lofi_minor == 0)
1058                 return;
1059 
1060         ldi_id = ldi_ident_from_anon();
1061 
1062         li = kmem_zalloc(sizeof (*li), KM_SLEEP);
1063         li->li_minor = vfsp->vfs_lofi_minor;
1064         li->li_cleanup = B_TRUE;
1065 
1066         err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred,
1067             &ldi_hdl, ldi_id);
1068 
1069         if (err)
1070                 goto out;
1071 
1072         err = ldi_ioctl(ldi_hdl, LOFI_UNMAP_FILE_MINOR, (intptr_t)li,
1073             FREAD | FWRITE | FKIOCTL, kcred, NULL);
1074 
1075         (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred);
1076 
1077         if (!err)
1078                 vfsp->vfs_lofi_minor = 0;
1079 
1080 out:
1081         ldi_ident_release(ldi_id);
1082         if (li != NULL)
1083                 kmem_free(li, sizeof (*li));
1084 }
1085 
1086 /*
1087  * Common mount code.  Called from the system call entry point, from autofs,
1088  * nfsv4 trigger mounts, and from pxfs.
1089  *
1090  * Takes the effective file system type, mount arguments, the mount point
1091  * vnode, flags specifying whether the mount is a remount and whether it
1092  * should be entered into the vfs list, and credentials.  Fills in its vfspp
1093  * parameter with the mounted file system instance's vfs.
1094  *
1095  * Note that the effective file system type is specified as a string.  It may
1096  * be null, in which case it's determined from the mount arguments, and may
1097  * differ from the type specified in the mount arguments; this is a hook to
1098  * allow interposition when instantiating file system instances.
1099  *
1100  * The caller is responsible for releasing its own hold on the mount point
1101  * vp (this routine does its own hold when necessary).
1102  * Also note that for remounts, the mount point vp should be the vnode for
1103  * the root of the file system rather than the vnode that the file system
1104  * is mounted on top of.
1105  */
1106 int
1107 domount(char *fsname, struct mounta *uap, vnode_t *vp, struct cred *credp,
1108         struct vfs **vfspp)
1109 {
1110         struct vfssw    *vswp;
1111         vfsops_t        *vfsops;
1112         struct vfs      *vfsp;
1113         struct vnode    *bvp;
1114         dev_t           bdev = 0;
1115         mntopts_t       mnt_mntopts;
1116         int             error = 0;
1117         int             copyout_error = 0;
1118         int             ovflags;
1119         char            *opts = uap->optptr;
1120         char            *inargs = opts;
1121         int             optlen = uap->optlen;
1122         int             remount;
1123         int             rdonly;
1124         int             nbmand = 0;
1125         int             delmip = 0;
1126         int             addmip = 0;
1127         int             splice = ((uap->flags & MS_NOSPLICE) == 0);
1128         int             fromspace = (uap->flags & MS_SYSSPACE) ?
1129             UIO_SYSSPACE : UIO_USERSPACE;
1130         char            *resource = NULL, *mountpt = NULL;
1131         refstr_t        *oldresource, *oldmntpt;
1132         struct pathname pn, rpn;
1133         vsk_anchor_t    *vskap;
1134         char fstname[FSTYPSZ];
1135 
1136         /*
1137          * The v_flag value for the mount point vp is permanently set
1138          * to VVFSLOCK so that no one bypasses the vn_vfs*locks routine
1139          * for mount point locking.
1140          */
1141         mutex_enter(&vp->v_lock);
1142         vp->v_flag |= VVFSLOCK;
1143         mutex_exit(&vp->v_lock);
1144 
1145         mnt_mntopts.mo_count = 0;
1146         /*
1147          * Find the ops vector to use to invoke the file system-specific mount
1148          * method.  If the fsname argument is non-NULL, use it directly.
1149          * Otherwise, dig the file system type information out of the mount
1150          * arguments.
1151          *
1152          * A side effect is to hold the vfssw entry.
1153          *
1154          * Mount arguments can be specified in several ways, which are
1155          * distinguished by flag bit settings.  The preferred way is to set
1156          * MS_OPTIONSTR, indicating an 8 argument mount with the file system
1157          * type supplied as a character string and the last two arguments
1158          * being a pointer to a character buffer and the size of the buffer.
1159          * On entry, the buffer holds a null terminated list of options; on
1160          * return, the string is the list of options the file system
1161          * recognized. If MS_DATA is set arguments five and six point to a
1162          * block of binary data which the file system interprets.
1163          * A further wrinkle is that some callers don't set MS_FSS and MS_DATA
1164          * consistently with these conventions.  To handle them, we check to
1165          * see whether the pointer to the file system name has a numeric value
1166          * less than 256.  If so, we treat it as an index.
1167          */
1168         if (fsname != NULL) {
1169                 if ((vswp = vfs_getvfssw(fsname)) == NULL) {
1170                         return (EINVAL);
1171                 }
1172         } else if (uap->flags & (MS_OPTIONSTR | MS_DATA | MS_FSS)) {
1173                 size_t n;
1174                 uint_t fstype;
1175 
1176                 fsname = fstname;
1177 
1178                 if ((fstype = (uintptr_t)uap->fstype) < 256) {
1179                         RLOCK_VFSSW();
1180                         if (fstype == 0 || fstype >= nfstype ||
1181                             !ALLOCATED_VFSSW(&vfssw[fstype])) {
1182                                 RUNLOCK_VFSSW();
1183                                 return (EINVAL);
1184                         }
1185                         (void) strcpy(fsname, vfssw[fstype].vsw_name);
1186                         RUNLOCK_VFSSW();
1187                         if ((vswp = vfs_getvfssw(fsname)) == NULL)
1188                                 return (EINVAL);
1189                 } else {
1190                         /*
1191                          * Handle either kernel or user address space.
1192                          */
1193                         if (uap->flags & MS_SYSSPACE) {
1194                                 error = copystr(uap->fstype, fsname,
1195                                     FSTYPSZ, &n);
1196                         } else {
1197                                 error = copyinstr(uap->fstype, fsname,
1198                                     FSTYPSZ, &n);
1199                         }
1200                         if (error) {
1201                                 if (error == ENAMETOOLONG)
1202                                         return (EINVAL);
1203                                 return (error);
1204                         }
1205                         if ((vswp = vfs_getvfssw(fsname)) == NULL)
1206                                 return (EINVAL);
1207                 }
1208         } else {
1209                 if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) == NULL)
1210                         return (EINVAL);
1211                 fsname = vswp->vsw_name;
1212         }
1213         if (!VFS_INSTALLED(vswp))
1214                 return (EINVAL);
1215 
1216         if ((error = secpolicy_fs_allowed_mount(fsname)) != 0)  {
1217                 vfs_unrefvfssw(vswp);
1218                 return (error);
1219         }
1220 
1221         vfsops = &vswp->vsw_vfsops;
1222 
1223         vfs_copyopttbl(&vswp->vsw_optproto, &mnt_mntopts);
1224         /*
1225          * Fetch mount options and parse them for generic vfs options
1226          */
1227         if (uap->flags & MS_OPTIONSTR) {
1228                 /*
1229                  * Limit the buffer size
1230                  */
1231                 if (optlen < 0 || optlen > MAX_MNTOPT_STR) {
1232                         error = EINVAL;
1233                         goto errout;
1234                 }
1235                 if ((uap->flags & MS_SYSSPACE) == 0) {
1236                         inargs = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP);
1237                         inargs[0] = '\0';
1238                         if (optlen) {
1239                                 error = copyinstr(opts, inargs, (size_t)optlen,
1240                                     NULL);
1241                                 if (error) {
1242                                         goto errout;
1243                                 }
1244                         }
1245                 }
1246                 vfs_parsemntopts(&mnt_mntopts, inargs, 0);
1247         }
1248         /*
1249          * Flag bits override the options string.
1250          */
1251         if (uap->flags & MS_REMOUNT)
1252                 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_REMOUNT, NULL, 0, 0);
1253         if (uap->flags & MS_RDONLY)
1254                 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_RO, NULL, 0, 0);
1255         if (uap->flags & MS_NOSUID)
1256                 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0);
1257 
1258         /*
1259          * Check if this is a remount; must be set in the option string and
1260          * the file system must support a remount option.
1261          */
1262         if (remount = vfs_optionisset_nolock(&mnt_mntopts,
1263             MNTOPT_REMOUNT, NULL)) {
1264                 if (!(vswp->vsw_flag & VSW_CANREMOUNT)) {
1265                         error = ENOTSUP;
1266                         goto errout;
1267                 }
1268                 uap->flags |= MS_REMOUNT;
1269         }
1270 
1271         /*
1272          * uap->flags and vfs_optionisset() should agree.
1273          */
1274         if (rdonly = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_RO, NULL)) {
1275                 uap->flags |= MS_RDONLY;
1276         }
1277         if (vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL)) {
1278                 uap->flags |= MS_NOSUID;
1279         }
1280         nbmand = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NBMAND, NULL);
1281         ASSERT(splice || !remount);
1282         /*
1283          * If we are splicing the fs into the namespace,
1284          * perform mount point checks.
1285          *
1286          * We want to resolve the path for the mount point to eliminate
1287          * '.' and ".." and symlinks in mount points; we can't do the
1288          * same for the resource string, since it would turn
1289          * "/dev/dsk/c0t0d0s0" into "/devices/pci@...".  We need to do
1290          * this before grabbing vn_vfswlock(), because otherwise we
1291          * would deadlock with lookuppn().
1292          */
1293         if (splice) {
1294                 ASSERT(vp->v_count > 0);
1295 
1296                 /*
1297                  * Pick up mount point and device from appropriate space.
1298                  */
1299                 if (pn_get(uap->spec, fromspace, &pn) == 0) {
1300                         resource = kmem_alloc(pn.pn_pathlen + 1,
1301                             KM_SLEEP);
1302                         (void) strcpy(resource, pn.pn_path);
1303                         pn_free(&pn);
1304                 }
1305                 /*
1306                  * Do a lookupname prior to taking the
1307                  * writelock. Mark this as completed if
1308                  * successful for later cleanup and addition to
1309                  * the mount in progress table.
1310                  */
1311                 if ((uap->flags & MS_GLOBAL) == 0 &&
1312                     lookupname(uap->spec, fromspace,
1313                     FOLLOW, NULL, &bvp) == 0) {
1314                         addmip = 1;
1315                 }
1316 
1317                 if ((error = pn_get(uap->dir, fromspace, &pn)) == 0) {
1318                         pathname_t *pnp;
1319 
1320                         if (*pn.pn_path != '/') {
1321                                 error = EINVAL;
1322                                 pn_free(&pn);
1323                                 goto errout;
1324                         }
1325                         pn_alloc(&rpn);
1326                         /*
1327                          * Kludge to prevent autofs from deadlocking with
1328                          * itself when it calls domount().
1329                          *
1330                          * If autofs is calling, it is because it is doing
1331                          * (autofs) mounts in the process of an NFS mount.  A
1332                          * lookuppn() here would cause us to block waiting for
1333                          * said NFS mount to complete, which can't since this
1334                          * is the thread that was supposed to doing it.
1335                          */
1336                         if (fromspace == UIO_USERSPACE) {
1337                                 if ((error = lookuppn(&pn, &rpn, FOLLOW, NULL,
1338                                     NULL)) == 0) {
1339                                         pnp = &rpn;
1340                                 } else {
1341                                         /*
1342                                          * The file disappeared or otherwise
1343                                          * became inaccessible since we opened
1344                                          * it; might as well fail the mount
1345                                          * since the mount point is no longer
1346                                          * accessible.
1347                                          */
1348                                         pn_free(&rpn);
1349                                         pn_free(&pn);
1350                                         goto errout;
1351                                 }
1352                         } else {
1353                                 pnp = &pn;
1354                         }
1355                         mountpt = kmem_alloc(pnp->pn_pathlen + 1, KM_SLEEP);
1356                         (void) strcpy(mountpt, pnp->pn_path);
1357 
1358                         /*
1359                          * If the addition of the zone's rootpath
1360                          * would push us over a total path length
1361                          * of MAXPATHLEN, we fail the mount with
1362                          * ENAMETOOLONG, which is what we would have
1363                          * gotten if we were trying to perform the same
1364                          * mount in the global zone.
1365                          *
1366                          * strlen() doesn't count the trailing
1367                          * '\0', but zone_rootpathlen counts both a
1368                          * trailing '/' and the terminating '\0'.
1369                          */
1370                         if ((curproc->p_zone->zone_rootpathlen - 1 +
1371                             strlen(mountpt)) > MAXPATHLEN ||
1372                             (resource != NULL &&
1373                             (curproc->p_zone->zone_rootpathlen - 1 +
1374                             strlen(resource)) > MAXPATHLEN)) {
1375                                 error = ENAMETOOLONG;
1376                         }
1377 
1378                         pn_free(&rpn);
1379                         pn_free(&pn);
1380                 }
1381 
1382                 if (error)
1383                         goto errout;
1384 
1385                 /*
1386                  * Prevent path name resolution from proceeding past
1387                  * the mount point.
1388                  */
1389                 if (vn_vfswlock(vp) != 0) {
1390                         error = EBUSY;
1391                         goto errout;
1392                 }
1393 
1394                 /*
1395                  * Verify that it's legitimate to establish a mount on
1396                  * the prospective mount point.
1397                  */
1398                 if (vn_mountedvfs(vp) != NULL) {
1399                         /*
1400                          * The mount point lock was obtained after some
1401                          * other thread raced through and established a mount.
1402                          */
1403                         vn_vfsunlock(vp);
1404                         error = EBUSY;
1405                         goto errout;
1406                 }
1407                 if (vp->v_flag & VNOMOUNT) {
1408                         vn_vfsunlock(vp);
1409                         error = EINVAL;
1410                         goto errout;
1411                 }
1412         }
1413         if ((uap->flags & (MS_DATA | MS_OPTIONSTR)) == 0) {
1414                 uap->dataptr = NULL;
1415                 uap->datalen = 0;
1416         }
1417 
1418         /*
1419          * If this is a remount, we don't want to create a new VFS.
1420          * Instead, we pass the existing one with a remount flag.
1421          */
1422         if (remount) {
1423                 /*
1424                  * Confirm that the mount point is the root vnode of the
1425                  * file system that is being remounted.
1426                  * This can happen if the user specifies a different
1427                  * mount point directory pathname in the (re)mount command.
1428                  *
1429                  * Code below can only be reached if splice is true, so it's
1430                  * safe to do vn_vfsunlock() here.
1431                  */
1432                 if ((vp->v_flag & VROOT) == 0) {
1433                         vn_vfsunlock(vp);
1434                         error = ENOENT;
1435                         goto errout;
1436                 }
1437                 /*
1438                  * Disallow making file systems read-only unless file system
1439                  * explicitly allows it in its vfssw.  Ignore other flags.
1440                  */
1441                 if (rdonly && vn_is_readonly(vp) == 0 &&
1442                     (vswp->vsw_flag & VSW_CANRWRO) == 0) {
1443                         vn_vfsunlock(vp);
1444                         error = EINVAL;
1445                         goto errout;
1446                 }
1447                 /*
1448                  * Disallow changing the NBMAND disposition of the file
1449                  * system on remounts.
1450                  */
1451                 if ((nbmand && ((vp->v_vfsp->vfs_flag & VFS_NBMAND) == 0)) ||
1452                     (!nbmand && (vp->v_vfsp->vfs_flag & VFS_NBMAND))) {
1453                         vn_vfsunlock(vp);
1454                         error = EINVAL;
1455                         goto errout;
1456                 }
1457                 vfsp = vp->v_vfsp;
1458                 ovflags = vfsp->vfs_flag;
1459                 vfsp->vfs_flag |= VFS_REMOUNT;
1460                 vfsp->vfs_flag &= ~VFS_RDONLY;
1461         } else {
1462                 vfsp = vfs_alloc(KM_SLEEP);
1463                 VFS_INIT(vfsp, vfsops, NULL);
1464         }
1465 
1466         VFS_HOLD(vfsp);
1467 
1468         if ((error = lofi_add(fsname, vfsp, &mnt_mntopts, uap)) != 0) {
1469                 if (!remount) {
1470                         if (splice)
1471                                 vn_vfsunlock(vp);
1472                         vfs_free(vfsp);
1473                 } else {
1474                         vn_vfsunlock(vp);
1475                         VFS_RELE(vfsp);
1476                 }
1477                 goto errout;
1478         }
1479 
1480         /*
1481          * PRIV_SYS_MOUNT doesn't mean you can become root.
1482          */
1483         if (vfsp->vfs_lofi_minor != 0) {
1484                 uap->flags |= MS_NOSUID;
1485                 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0);
1486         }
1487 
1488         /*
1489          * The vfs_reflock is not used anymore the code below explicitly
1490          * holds it preventing others accesing it directly.
1491          */
1492         if ((sema_tryp(&vfsp->vfs_reflock) == 0) &&
1493             !(vfsp->vfs_flag & VFS_REMOUNT))
1494                 cmn_err(CE_WARN,
1495                     "mount type %s couldn't get vfs_reflock", vswp->vsw_name);
1496 
1497         /*
1498          * Lock the vfs. If this is a remount we want to avoid spurious umount
1499          * failures that happen as a side-effect of fsflush() and other mount
1500          * and unmount operations that might be going on simultaneously and
1501          * may have locked the vfs currently. To not return EBUSY immediately
1502          * here we use vfs_lock_wait() instead vfs_lock() for the remount case.
1503          */
1504         if (!remount) {
1505                 if (error = vfs_lock(vfsp)) {
1506                         vfsp->vfs_flag = ovflags;
1507 
1508                         lofi_remove(vfsp);
1509 
1510                         if (splice)
1511                                 vn_vfsunlock(vp);
1512                         vfs_free(vfsp);
1513                         goto errout;
1514                 }
1515         } else {
1516                 vfs_lock_wait(vfsp);
1517         }
1518 
1519         /*
1520          * Add device to mount in progress table, global mounts require special
1521          * handling. It is possible that we have already done the lookupname
1522          * on a spliced, non-global fs. If so, we don't want to do it again
1523          * since we cannot do a lookupname after taking the
1524          * wlock above. This case is for a non-spliced, non-global filesystem.
1525          */
1526         if (!addmip) {
1527                 if ((uap->flags & MS_GLOBAL) == 0 &&
1528                     lookupname(uap->spec, fromspace, FOLLOW, NULL, &bvp) == 0) {
1529                         addmip = 1;
1530                 }
1531         }
1532 
1533         if (addmip) {
1534                 vnode_t *lvp = NULL;
1535 
1536                 error = vfs_get_lofi(vfsp, &lvp);
1537                 if (error > 0) {
1538                         lofi_remove(vfsp);
1539 
1540                         if (splice)
1541                                 vn_vfsunlock(vp);
1542                         vfs_unlock(vfsp);
1543 
1544                         if (remount) {
1545                                 VFS_RELE(vfsp);
1546                         } else {
1547                                 vfs_free(vfsp);
1548                         }
1549 
1550                         goto errout;
1551                 } else if (error == -1) {
1552                         bdev = bvp->v_rdev;
1553                         VN_RELE(bvp);
1554                 } else {
1555                         bdev = lvp->v_rdev;
1556                         VN_RELE(lvp);
1557                         VN_RELE(bvp);
1558                 }
1559 
1560                 vfs_addmip(bdev, vfsp);
1561                 addmip = 0;
1562                 delmip = 1;
1563         }
1564         /*
1565          * Invalidate cached entry for the mount point.
1566          */
1567         if (splice)
1568                 dnlc_purge_vp(vp);
1569 
1570         /*
1571          * If have an option string but the filesystem doesn't supply a
1572          * prototype options table, create a table with the global
1573          * options and sufficient room to accept all the options in the
1574          * string.  Then parse the passed in option string
1575          * accepting all the options in the string.  This gives us an
1576          * option table with all the proper cancel properties for the
1577          * global options.
1578          *
1579          * Filesystems that supply a prototype options table are handled
1580          * earlier in this function.
1581          */
1582         if (uap->flags & MS_OPTIONSTR) {
1583                 if (!(vswp->vsw_flag & VSW_HASPROTO)) {
1584                         mntopts_t tmp_mntopts;
1585 
1586                         tmp_mntopts.mo_count = 0;
1587                         vfs_createopttbl_extend(&tmp_mntopts, inargs,
1588                             &mnt_mntopts);
1589                         vfs_parsemntopts(&tmp_mntopts, inargs, 1);
1590                         vfs_swapopttbl_nolock(&mnt_mntopts, &tmp_mntopts);
1591                         vfs_freeopttbl(&tmp_mntopts);
1592                 }
1593         }
1594 
1595         /*
1596          * Serialize with zone creations.
1597          */
1598         mount_in_progress();
1599         /*
1600          * Instantiate (or reinstantiate) the file system.  If appropriate,
1601          * splice it into the file system name space.
1602          *
1603          * We want VFS_MOUNT() to be able to override the vfs_resource
1604          * string if necessary (ie, mntfs), and also for a remount to
1605          * change the same (necessary when remounting '/' during boot).
1606          * So we set up vfs_mntpt and vfs_resource to what we think they
1607          * should be, then hand off control to VFS_MOUNT() which can
1608          * override this.
1609          *
1610          * For safety's sake, when changing vfs_resource or vfs_mntpt of
1611          * a vfs which is on the vfs list (i.e. during a remount), we must
1612          * never set those fields to NULL. Several bits of code make
1613          * assumptions that the fields are always valid.
1614          */
1615         vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts);
1616         if (remount) {
1617                 if ((oldresource = vfsp->vfs_resource) != NULL)
1618                         refstr_hold(oldresource);
1619                 if ((oldmntpt = vfsp->vfs_mntpt) != NULL)
1620                         refstr_hold(oldmntpt);
1621         }
1622         vfs_setresource(vfsp, resource, 0);
1623         vfs_setmntpoint(vfsp, mountpt, 0);
1624 
1625         /*
1626          * going to mount on this vnode, so notify.
1627          */
1628         vnevent_mountedover(vp, NULL);
1629         error = VFS_MOUNT(vfsp, vp, uap, credp);
1630 
1631         if (uap->flags & MS_RDONLY)
1632                 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1633         if (uap->flags & MS_NOSUID)
1634                 vfs_setmntopt(vfsp, MNTOPT_NOSUID, NULL, 0);
1635         if (uap->flags & MS_GLOBAL)
1636                 vfs_setmntopt(vfsp, MNTOPT_GLOBAL, NULL, 0);
1637 
1638         if (error) {
1639                 lofi_remove(vfsp);
1640 
1641                 if (remount) {
1642                         /* put back pre-remount options */
1643                         vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts);
1644                         vfs_setmntpoint(vfsp, refstr_value(oldmntpt),
1645                             VFSSP_VERBATIM);
1646                         if (oldmntpt)
1647                                 refstr_rele(oldmntpt);
1648                         vfs_setresource(vfsp, refstr_value(oldresource),
1649                             VFSSP_VERBATIM);
1650                         if (oldresource)
1651                                 refstr_rele(oldresource);
1652                         vfsp->vfs_flag = ovflags;
1653                         vfs_unlock(vfsp);
1654                         VFS_RELE(vfsp);
1655                 } else {
1656                         vfs_unlock(vfsp);
1657                         vfs_freemnttab(vfsp);
1658                         vfs_free(vfsp);
1659                 }
1660         } else {
1661                 /*
1662                  * Set the mount time to now
1663                  */
1664                 vfsp->vfs_mtime = ddi_get_time();
1665                 if (remount) {
1666                         vfsp->vfs_flag &= ~VFS_REMOUNT;
1667                         if (oldresource)
1668                                 refstr_rele(oldresource);
1669                         if (oldmntpt)
1670                                 refstr_rele(oldmntpt);
1671                 } else if (splice) {
1672                         /*
1673                          * Link vfsp into the name space at the mount
1674                          * point. Vfs_add() is responsible for
1675                          * holding the mount point which will be
1676                          * released when vfs_remove() is called.
1677                          */
1678                         vfs_add(vp, vfsp, uap->flags);
1679                 } else {
1680                         /*
1681                          * Hold the reference to file system which is
1682                          * not linked into the name space.
1683                          */
1684                         vfsp->vfs_zone = NULL;
1685                         VFS_HOLD(vfsp);
1686                         vfsp->vfs_vnodecovered = NULL;
1687                 }
1688                 /*
1689                  * Set flags for global options encountered
1690                  */
1691                 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL))
1692                         vfsp->vfs_flag |= VFS_RDONLY;
1693                 else
1694                         vfsp->vfs_flag &= ~VFS_RDONLY;
1695                 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
1696                         vfsp->vfs_flag |= (VFS_NOSETUID|VFS_NODEVICES);
1697                 } else {
1698                         if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
1699                                 vfsp->vfs_flag |= VFS_NODEVICES;
1700                         else
1701                                 vfsp->vfs_flag &= ~VFS_NODEVICES;
1702                         if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL))
1703                                 vfsp->vfs_flag |= VFS_NOSETUID;
1704                         else
1705                                 vfsp->vfs_flag &= ~VFS_NOSETUID;
1706                 }
1707                 if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL))
1708                         vfsp->vfs_flag |= VFS_NBMAND;
1709                 else
1710                         vfsp->vfs_flag &= ~VFS_NBMAND;
1711 
1712                 if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL))
1713                         vfsp->vfs_flag |= VFS_XATTR;
1714                 else
1715                         vfsp->vfs_flag &= ~VFS_XATTR;
1716 
1717                 if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL))
1718                         vfsp->vfs_flag |= VFS_NOEXEC;
1719                 else
1720                         vfsp->vfs_flag &= ~VFS_NOEXEC;
1721 
1722                 /*
1723                  * Now construct the output option string of options
1724                  * we recognized.
1725                  */
1726                 if (uap->flags & MS_OPTIONSTR) {
1727                         vfs_list_read_lock();
1728                         copyout_error = vfs_buildoptionstr(
1729                             &vfsp->vfs_mntopts, inargs, optlen);
1730                         vfs_list_unlock();
1731                         if (copyout_error == 0 &&
1732                             (uap->flags & MS_SYSSPACE) == 0) {
1733                                 copyout_error = copyoutstr(inargs, opts,
1734                                     optlen, NULL);
1735                         }
1736                 }
1737 
1738                 /*
1739                  * If this isn't a remount, set up the vopstats before
1740                  * anyone can touch this. We only allow spliced file
1741                  * systems (file systems which are in the namespace) to
1742                  * have the VFS_STATS flag set.
1743                  * NOTE: PxFS mounts the underlying file system with
1744                  * MS_NOSPLICE set and copies those vfs_flags to its private
1745                  * vfs structure. As a result, PxFS should never have
1746                  * the VFS_STATS flag or else we might access the vfs
1747                  * statistics-related fields prior to them being
1748                  * properly initialized.
1749                  */
1750                 if (!remount && (vswp->vsw_flag & VSW_STATS) && splice) {
1751                         initialize_vopstats(&vfsp->vfs_vopstats);
1752                         /*
1753                          * We need to set vfs_vskap to NULL because there's
1754                          * a chance it won't be set below.  This is checked
1755                          * in teardown_vopstats() so we can't have garbage.
1756                          */
1757                         vfsp->vfs_vskap = NULL;
1758                         vfsp->vfs_flag |= VFS_STATS;
1759                         vfsp->vfs_fstypevsp = get_fstype_vopstats(vfsp, vswp);
1760                 }
1761 
1762                 if (vswp->vsw_flag & VSW_XID)
1763                         vfsp->vfs_flag |= VFS_XID;
1764 
1765                 vfs_unlock(vfsp);
1766         }
1767         mount_completed();
1768         if (splice)
1769                 vn_vfsunlock(vp);
1770 
1771         if ((error == 0) && (copyout_error == 0)) {
1772                 if (!remount) {
1773                         /*
1774                          * Don't call get_vskstat_anchor() while holding
1775                          * locks since it allocates memory and calls
1776                          * VFS_STATVFS().  For NFS, the latter can generate
1777                          * an over-the-wire call.
1778                          */
1779                         vskap = get_vskstat_anchor(vfsp);
1780                         /* Only take the lock if we have something to do */
1781                         if (vskap != NULL) {
1782                                 vfs_lock_wait(vfsp);
1783                                 if (vfsp->vfs_flag & VFS_STATS) {
1784                                         vfsp->vfs_vskap = vskap;
1785                                 }
1786                                 vfs_unlock(vfsp);
1787                         }
1788                 }
1789                 /* Return vfsp to caller. */
1790                 *vfspp = vfsp;
1791                 fsh_exec_create_callbacks(vfsp);
1792         }
1793 errout:
1794         vfs_freeopttbl(&mnt_mntopts);
1795         if (resource != NULL)
1796                 kmem_free(resource, strlen(resource) + 1);
1797         if (mountpt != NULL)
1798                 kmem_free(mountpt, strlen(mountpt) + 1);
1799         /*
1800          * It is possible we errored prior to adding to mount in progress
1801          * table. Must free vnode we acquired with successful lookupname.
1802          */
1803         if (addmip)
1804                 VN_RELE(bvp);
1805         if (delmip)
1806                 vfs_delmip(vfsp);
1807         ASSERT(vswp != NULL);
1808         vfs_unrefvfssw(vswp);
1809         if (inargs != opts)
1810                 kmem_free(inargs, MAX_MNTOPT_STR);
1811         if (copyout_error) {
1812                 lofi_remove(vfsp);
1813                 VFS_RELE(vfsp);
1814                 error = copyout_error;
1815         }
1816         return (error);
1817 }
1818 
1819 static void
1820 vfs_setpath(
1821     struct vfs *vfsp,           /* vfs being updated */
1822     refstr_t **refp,            /* Ref-count string to contain the new path */
1823     const char *newpath,        /* Path to add to refp (above) */
1824     uint32_t flag)              /* flag */
1825 {
1826         size_t len;
1827         refstr_t *ref;
1828         zone_t *zone = curproc->p_zone;
1829         char *sp;
1830         int have_list_lock = 0;
1831 
1832         ASSERT(!VFS_ON_LIST(vfsp) || vfs_lock_held(vfsp));
1833 
1834         /*
1835          * New path must be less than MAXPATHLEN because mntfs
1836          * will only display up to MAXPATHLEN bytes. This is currently
1837          * safe, because domount() uses pn_get(), and other callers
1838          * similarly cap the size to fewer than MAXPATHLEN bytes.
1839          */
1840 
1841         ASSERT(strlen(newpath) < MAXPATHLEN);
1842 
1843         /* mntfs requires consistency while vfs list lock is held */
1844 
1845         if (VFS_ON_LIST(vfsp)) {
1846                 have_list_lock = 1;
1847                 vfs_list_lock();
1848         }
1849 
1850         if (*refp != NULL)
1851                 refstr_rele(*refp);
1852 
1853         /*
1854          * If we are in a non-global zone then we prefix the supplied path,
1855          * newpath, with the zone's root path, with two exceptions. The first
1856          * is where we have been explicitly directed to avoid doing so; this
1857          * will be the case following a failed remount, where the path supplied
1858          * will be a saved version which must now be restored. The second
1859          * exception is where newpath is not a pathname but a descriptive name,
1860          * e.g. "procfs".
1861          */
1862         if (zone == global_zone || (flag & VFSSP_VERBATIM) || *newpath != '/') {
1863                 ref = refstr_alloc(newpath);
1864                 goto out;
1865         }
1866 
1867         /*
1868          * Truncate the trailing '/' in the zoneroot, and merge
1869          * in the zone's rootpath with the "newpath" (resource
1870          * or mountpoint) passed in.
1871          *
1872          * The size of the required buffer is thus the size of
1873          * the buffer required for the passed-in newpath
1874          * (strlen(newpath) + 1), plus the size of the buffer
1875          * required to hold zone_rootpath (zone_rootpathlen)
1876          * minus one for one of the now-superfluous NUL
1877          * terminations, minus one for the trailing '/'.
1878          *
1879          * That gives us:
1880          *
1881          * (strlen(newpath) + 1) + zone_rootpathlen - 1 - 1
1882          *
1883          * Which is what we have below.
1884          */
1885 
1886         len = strlen(newpath) + zone->zone_rootpathlen - 1;
1887         sp = kmem_alloc(len, KM_SLEEP);
1888 
1889         /*
1890          * Copy everything including the trailing slash, which
1891          * we then overwrite with the NUL character.
1892          */
1893 
1894         (void) strcpy(sp, zone->zone_rootpath);
1895         sp[zone->zone_rootpathlen - 2] = '\0';
1896         (void) strcat(sp, newpath);
1897 
1898         ref = refstr_alloc(sp);
1899         kmem_free(sp, len);
1900 out:
1901         *refp = ref;
1902 
1903         if (have_list_lock) {
1904                 vfs_mnttab_modtimeupd();
1905                 vfs_list_unlock();
1906         }
1907 }
1908 
1909 /*
1910  * Record a mounted resource name in a vfs structure.
1911  * If vfsp is already mounted, caller must hold the vfs lock.
1912  */
1913 void
1914 vfs_setresource(struct vfs *vfsp, const char *resource, uint32_t flag)
1915 {
1916         if (resource == NULL || resource[0] == '\0')
1917                 resource = VFS_NORESOURCE;
1918         vfs_setpath(vfsp, &vfsp->vfs_resource, resource, flag);
1919 }
1920 
1921 /*
1922  * Record a mount point name in a vfs structure.
1923  * If vfsp is already mounted, caller must hold the vfs lock.
1924  */
1925 void
1926 vfs_setmntpoint(struct vfs *vfsp, const char *mntpt, uint32_t flag)
1927 {
1928         if (mntpt == NULL || mntpt[0] == '\0')
1929                 mntpt = VFS_NOMNTPT;
1930         vfs_setpath(vfsp, &vfsp->vfs_mntpt, mntpt, flag);
1931 }
1932 
1933 /* Returns the vfs_resource. Caller must call refstr_rele() when finished. */
1934 
1935 refstr_t *
1936 vfs_getresource(const struct vfs *vfsp)
1937 {
1938         refstr_t *resource;
1939 
1940         vfs_list_read_lock();
1941         resource = vfsp->vfs_resource;
1942         refstr_hold(resource);
1943         vfs_list_unlock();
1944 
1945         return (resource);
1946 }
1947 
1948 /* Returns the vfs_mntpt. Caller must call refstr_rele() when finished. */
1949 
1950 refstr_t *
1951 vfs_getmntpoint(const struct vfs *vfsp)
1952 {
1953         refstr_t *mntpt;
1954 
1955         vfs_list_read_lock();
1956         mntpt = vfsp->vfs_mntpt;
1957         refstr_hold(mntpt);
1958         vfs_list_unlock();
1959 
1960         return (mntpt);
1961 }
1962 
1963 /*
1964  * Create an empty options table with enough empty slots to hold all
1965  * The options in the options string passed as an argument.
1966  * Potentially prepend another options table.
1967  *
1968  * Note: caller is responsible for locking the vfs list, if needed,
1969  *       to protect mops.
1970  */
1971 static void
1972 vfs_createopttbl_extend(mntopts_t *mops, const char *opts,
1973     const mntopts_t *mtmpl)
1974 {
1975         const char *s = opts;
1976         uint_t count;
1977 
1978         if (opts == NULL || *opts == '\0') {
1979                 count = 0;
1980         } else {
1981                 count = 1;
1982 
1983                 /*
1984                  * Count number of options in the string
1985                  */
1986                 for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) {
1987                         count++;
1988                         s++;
1989                 }
1990         }
1991         vfs_copyopttbl_extend(mtmpl, mops, count);
1992 }
1993 
1994 /*
1995  * Create an empty options table with enough empty slots to hold all
1996  * The options in the options string passed as an argument.
1997  *
1998  * This function is *not* for general use by filesystems.
1999  *
2000  * Note: caller is responsible for locking the vfs list, if needed,
2001  *       to protect mops.
2002  */
2003 void
2004 vfs_createopttbl(mntopts_t *mops, const char *opts)
2005 {
2006         vfs_createopttbl_extend(mops, opts, NULL);
2007 }
2008 
2009 
2010 /*
2011  * Swap two mount options tables
2012  */
2013 static void
2014 vfs_swapopttbl_nolock(mntopts_t *optbl1, mntopts_t *optbl2)
2015 {
2016         uint_t tmpcnt;
2017         mntopt_t *tmplist;
2018 
2019         tmpcnt = optbl2->mo_count;
2020         tmplist = optbl2->mo_list;
2021         optbl2->mo_count = optbl1->mo_count;
2022         optbl2->mo_list = optbl1->mo_list;
2023         optbl1->mo_count = tmpcnt;
2024         optbl1->mo_list = tmplist;
2025 }
2026 
2027 static void
2028 vfs_swapopttbl(mntopts_t *optbl1, mntopts_t *optbl2)
2029 {
2030         vfs_list_lock();
2031         vfs_swapopttbl_nolock(optbl1, optbl2);
2032         vfs_mnttab_modtimeupd();
2033         vfs_list_unlock();
2034 }
2035 
2036 static char **
2037 vfs_copycancelopt_extend(char **const moc, int extend)
2038 {
2039         int i = 0;
2040         int j;
2041         char **result;
2042 
2043         if (moc != NULL) {
2044                 for (; moc[i] != NULL; i++)
2045                         /* count number of options to cancel */;
2046         }
2047 
2048         if (i + extend == 0)
2049                 return (NULL);
2050 
2051         result = kmem_alloc((i + extend + 1) * sizeof (char *), KM_SLEEP);
2052 
2053         for (j = 0; j < i; j++) {
2054                 result[j] = kmem_alloc(strlen(moc[j]) + 1, KM_SLEEP);
2055                 (void) strcpy(result[j], moc[j]);
2056         }
2057         for (; j <= i + extend; j++)
2058                 result[j] = NULL;
2059 
2060         return (result);
2061 }
2062 
2063 static void
2064 vfs_copyopt(const mntopt_t *s, mntopt_t *d)
2065 {
2066         char *sp, *dp;
2067 
2068         d->mo_flags = s->mo_flags;
2069         d->mo_data = s->mo_data;
2070         sp = s->mo_name;
2071         if (sp != NULL) {
2072                 dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP);
2073                 (void) strcpy(dp, sp);
2074                 d->mo_name = dp;
2075         } else {
2076                 d->mo_name = NULL; /* should never happen */
2077         }
2078 
2079         d->mo_cancel = vfs_copycancelopt_extend(s->mo_cancel, 0);
2080 
2081         sp = s->mo_arg;
2082         if (sp != NULL) {
2083                 dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP);
2084                 (void) strcpy(dp, sp);
2085                 d->mo_arg = dp;
2086         } else {
2087                 d->mo_arg = NULL;
2088         }
2089 }
2090 
2091 /*
2092  * Copy a mount options table, possibly allocating some spare
2093  * slots at the end.  It is permissible to copy_extend the NULL table.
2094  */
2095 static void
2096 vfs_copyopttbl_extend(const mntopts_t *smo, mntopts_t *dmo, int extra)
2097 {
2098         uint_t i, count;
2099         mntopt_t *motbl;
2100 
2101         /*
2102          * Clear out any existing stuff in the options table being initialized
2103          */
2104         vfs_freeopttbl(dmo);
2105         count = (smo == NULL) ? 0 : smo->mo_count;
2106         if ((count + extra) == 0)       /* nothing to do */
2107                 return;
2108         dmo->mo_count = count + extra;
2109         motbl = kmem_zalloc((count + extra) * sizeof (mntopt_t), KM_SLEEP);
2110         dmo->mo_list = motbl;
2111         for (i = 0; i < count; i++) {
2112                 vfs_copyopt(&smo->mo_list[i], &motbl[i]);
2113         }
2114         for (i = count; i < count + extra; i++) {
2115                 motbl[i].mo_flags = MO_EMPTY;
2116         }
2117 }
2118 
2119 /*
2120  * Copy a mount options table.
2121  *
2122  * This function is *not* for general use by filesystems.
2123  *
2124  * Note: caller is responsible for locking the vfs list, if needed,
2125  *       to protect smo and dmo.
2126  */
2127 void
2128 vfs_copyopttbl(const mntopts_t *smo, mntopts_t *dmo)
2129 {
2130         vfs_copyopttbl_extend(smo, dmo, 0);
2131 }
2132 
2133 static char **
2134 vfs_mergecancelopts(const mntopt_t *mop1, const mntopt_t *mop2)
2135 {
2136         int c1 = 0;
2137         int c2 = 0;
2138         char **result;
2139         char **sp1, **sp2, **dp;
2140 
2141         /*
2142          * First we count both lists of cancel options.
2143          * If either is NULL or has no elements, we return a copy of
2144          * the other.
2145          */
2146         if (mop1->mo_cancel != NULL) {
2147                 for (; mop1->mo_cancel[c1] != NULL; c1++)
2148                         /* count cancel options in mop1 */;
2149         }
2150 
2151         if (c1 == 0)
2152                 return (vfs_copycancelopt_extend(mop2->mo_cancel, 0));
2153 
2154         if (mop2->mo_cancel != NULL) {
2155                 for (; mop2->mo_cancel[c2] != NULL; c2++)
2156                         /* count cancel options in mop2 */;
2157         }
2158 
2159         result = vfs_copycancelopt_extend(mop1->mo_cancel, c2);
2160 
2161         if (c2 == 0)
2162                 return (result);
2163 
2164         /*
2165          * When we get here, we've got two sets of cancel options;
2166          * we need to merge the two sets.  We know that the result
2167          * array has "c1+c2+1" entries and in the end we might shrink
2168          * it.
2169          * Result now has a copy of the c1 entries from mop1; we'll
2170          * now lookup all the entries of mop2 in mop1 and copy it if
2171          * it is unique.
2172          * This operation is O(n^2) but it's only called once per
2173          * filesystem per duplicate option.  This is a situation
2174          * which doesn't arise with the filesystems in ON and
2175          * n is generally 1.
2176          */
2177 
2178         dp = &result[c1];
2179         for (sp2 = mop2->mo_cancel; *sp2 != NULL; sp2++) {
2180                 for (sp1 = mop1->mo_cancel; *sp1 != NULL; sp1++) {
2181                         if (strcmp(*sp1, *sp2) == 0)
2182                                 break;
2183                 }
2184                 if (*sp1 == NULL) {
2185                         /*
2186                          * Option *sp2 not found in mop1, so copy it.
2187                          * The calls to vfs_copycancelopt_extend()
2188                          * guarantee that there's enough room.
2189                          */
2190                         *dp = kmem_alloc(strlen(*sp2) + 1, KM_SLEEP);
2191                         (void) strcpy(*dp++, *sp2);
2192                 }
2193         }
2194         if (dp != &result[c1+c2]) {
2195                 size_t bytes = (dp - result + 1) * sizeof (char *);
2196                 char **nres = kmem_alloc(bytes, KM_SLEEP);
2197 
2198                 bcopy(result, nres, bytes);
2199                 kmem_free(result, (c1 + c2 + 1) * sizeof (char *));
2200                 result = nres;
2201         }
2202         return (result);
2203 }
2204 
2205 /*
2206  * Merge two mount option tables (outer and inner) into one.  This is very
2207  * similar to "merging" global variables and automatic variables in C.
2208  *
2209  * This isn't (and doesn't have to be) fast.
2210  *
2211  * This function is *not* for general use by filesystems.
2212  *
2213  * Note: caller is responsible for locking the vfs list, if needed,
2214  *       to protect omo, imo & dmo.
2215  */
2216 void
2217 vfs_mergeopttbl(const mntopts_t *omo, const mntopts_t *imo, mntopts_t *dmo)
2218 {
2219         uint_t i, count;
2220         mntopt_t *mop, *motbl;
2221         uint_t freeidx;
2222 
2223         /*
2224          * First determine how much space we need to allocate.
2225          */
2226         count = omo->mo_count;
2227         for (i = 0; i < imo->mo_count; i++) {
2228                 if (imo->mo_list[i].mo_flags & MO_EMPTY)
2229                         continue;
2230                 if (vfs_hasopt(omo, imo->mo_list[i].mo_name) == NULL)
2231                         count++;
2232         }
2233         ASSERT(count >= omo->mo_count &&
2234             count <= omo->mo_count + imo->mo_count);
2235         motbl = kmem_alloc(count * sizeof (mntopt_t), KM_SLEEP);
2236         for (i = 0; i < omo->mo_count; i++)
2237                 vfs_copyopt(&omo->mo_list[i], &motbl[i]);
2238         freeidx = omo->mo_count;
2239         for (i = 0; i < imo->mo_count; i++) {
2240                 if (imo->mo_list[i].mo_flags & MO_EMPTY)
2241                         continue;
2242                 if ((mop = vfs_hasopt(omo, imo->mo_list[i].mo_name)) != NULL) {
2243                         char **newcanp;
2244                         uint_t index = mop - omo->mo_list;
2245 
2246                         newcanp = vfs_mergecancelopts(mop, &motbl[index]);
2247 
2248                         vfs_freeopt(&motbl[index]);
2249                         vfs_copyopt(&imo->mo_list[i], &motbl[index]);
2250 
2251                         vfs_freecancelopt(motbl[index].mo_cancel);
2252                         motbl[index].mo_cancel = newcanp;
2253                 } else {
2254                         /*
2255                          * If it's a new option, just copy it over to the first
2256                          * free location.
2257                          */
2258                         vfs_copyopt(&imo->mo_list[i], &motbl[freeidx++]);
2259                 }
2260         }
2261         dmo->mo_count = count;
2262         dmo->mo_list = motbl;
2263 }
2264 
2265 /*
2266  * Functions to set and clear mount options in a mount options table.
2267  */
2268 
2269 /*
2270  * Clear a mount option, if it exists.
2271  *
2272  * The update_mnttab arg indicates whether mops is part of a vfs that is on
2273  * the vfs list.
2274  */
2275 static void
2276 vfs_clearmntopt_nolock(mntopts_t *mops, const char *opt, int update_mnttab)
2277 {
2278         struct mntopt *mop;
2279         uint_t i, count;
2280 
2281         ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist));
2282 
2283         count = mops->mo_count;
2284         for (i = 0; i < count; i++) {
2285                 mop = &mops->mo_list[i];
2286 
2287                 if (mop->mo_flags & MO_EMPTY)
2288                         continue;
2289                 if (strcmp(opt, mop->mo_name))
2290                         continue;
2291                 mop->mo_flags &= ~MO_SET;
2292                 if (mop->mo_arg != NULL) {
2293                         kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2294                 }
2295                 mop->mo_arg = NULL;
2296                 if (update_mnttab)
2297                         vfs_mnttab_modtimeupd();
2298                 break;
2299         }
2300 }
2301 
2302 void
2303 vfs_clearmntopt(struct vfs *vfsp, const char *opt)
2304 {
2305         int gotlock = 0;
2306 
2307         if (VFS_ON_LIST(vfsp)) {
2308                 gotlock = 1;
2309                 vfs_list_lock();
2310         }
2311         vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, opt, gotlock);
2312         if (gotlock)
2313                 vfs_list_unlock();
2314 }
2315 
2316 
2317 /*
2318  * Set a mount option on.  If it's not found in the table, it's silently
2319  * ignored.  If the option has MO_IGNORE set, it is still set unless the
2320  * VFS_NOFORCEOPT bit is set in the flags.  Also, VFS_DISPLAY/VFS_NODISPLAY flag
2321  * bits can be used to toggle the MO_NODISPLAY bit for the option.
2322  * If the VFS_CREATEOPT flag bit is set then the first option slot with
2323  * MO_EMPTY set is created as the option passed in.
2324  *
2325  * The update_mnttab arg indicates whether mops is part of a vfs that is on
2326  * the vfs list.
2327  */
2328 static void
2329 vfs_setmntopt_nolock(mntopts_t *mops, const char *opt,
2330     const char *arg, int flags, int update_mnttab)
2331 {
2332         mntopt_t *mop;
2333         uint_t i, count;
2334         char *sp;
2335 
2336         ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist));
2337 
2338         if (flags & VFS_CREATEOPT) {
2339                 if (vfs_hasopt(mops, opt) != NULL) {
2340                         flags &= ~VFS_CREATEOPT;
2341                 }
2342         }
2343         count = mops->mo_count;
2344         for (i = 0; i < count; i++) {
2345                 mop = &mops->mo_list[i];
2346 
2347                 if (mop->mo_flags & MO_EMPTY) {
2348                         if ((flags & VFS_CREATEOPT) == 0)
2349                                 continue;
2350                         sp = kmem_alloc(strlen(opt) + 1, KM_SLEEP);
2351                         (void) strcpy(sp, opt);
2352                         mop->mo_name = sp;
2353                         if (arg != NULL)
2354                                 mop->mo_flags = MO_HASVALUE;
2355                         else
2356                                 mop->mo_flags = 0;
2357                 } else if (strcmp(opt, mop->mo_name)) {
2358                         continue;
2359                 }
2360                 if ((mop->mo_flags & MO_IGNORE) && (flags & VFS_NOFORCEOPT))
2361                         break;
2362                 if (arg != NULL && (mop->mo_flags & MO_HASVALUE) != 0) {
2363                         sp = kmem_alloc(strlen(arg) + 1, KM_SLEEP);
2364                         (void) strcpy(sp, arg);
2365                 } else {
2366                         sp = NULL;
2367                 }
2368                 if (mop->mo_arg != NULL)
2369                         kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2370                 mop->mo_arg = sp;
2371                 if (flags & VFS_DISPLAY)
2372                         mop->mo_flags &= ~MO_NODISPLAY;
2373                 if (flags & VFS_NODISPLAY)
2374                         mop->mo_flags |= MO_NODISPLAY;
2375                 mop->mo_flags |= MO_SET;
2376                 if (mop->mo_cancel != NULL) {
2377                         char **cp;
2378 
2379                         for (cp = mop->mo_cancel; *cp != NULL; cp++)
2380                                 vfs_clearmntopt_nolock(mops, *cp, 0);
2381                 }
2382                 if (update_mnttab)
2383                         vfs_mnttab_modtimeupd();
2384                 break;
2385         }
2386 }
2387 
2388 void
2389 vfs_setmntopt(struct vfs *vfsp, const char *opt, const char *arg, int flags)
2390 {
2391         int gotlock = 0;
2392 
2393         if (VFS_ON_LIST(vfsp)) {
2394                 gotlock = 1;
2395                 vfs_list_lock();
2396         }
2397         vfs_setmntopt_nolock(&vfsp->vfs_mntopts, opt, arg, flags, gotlock);
2398         if (gotlock)
2399                 vfs_list_unlock();
2400 }
2401 
2402 
2403 /*
2404  * Add a "tag" option to a mounted file system's options list.
2405  *
2406  * Note: caller is responsible for locking the vfs list, if needed,
2407  *       to protect mops.
2408  */
2409 static mntopt_t *
2410 vfs_addtag(mntopts_t *mops, const char *tag)
2411 {
2412         uint_t count;
2413         mntopt_t *mop, *motbl;
2414 
2415         count = mops->mo_count + 1;
2416         motbl = kmem_zalloc(count * sizeof (mntopt_t), KM_SLEEP);
2417         if (mops->mo_count) {
2418                 size_t len = (count - 1) * sizeof (mntopt_t);
2419 
2420                 bcopy(mops->mo_list, motbl, len);
2421                 kmem_free(mops->mo_list, len);
2422         }
2423         mops->mo_count = count;
2424         mops->mo_list = motbl;
2425         mop = &motbl[count - 1];
2426         mop->mo_flags = MO_TAG;
2427         mop->mo_name = kmem_alloc(strlen(tag) + 1, KM_SLEEP);
2428         (void) strcpy(mop->mo_name, tag);
2429         return (mop);
2430 }
2431 
2432 /*
2433  * Allow users to set arbitrary "tags" in a vfs's mount options.
2434  * Broader use within the kernel is discouraged.
2435  */
2436 int
2437 vfs_settag(uint_t major, uint_t minor, const char *mntpt, const char *tag,
2438     cred_t *cr)
2439 {
2440         vfs_t *vfsp;
2441         mntopts_t *mops;
2442         mntopt_t *mop;
2443         int found = 0;
2444         dev_t dev = makedevice(major, minor);
2445         int err = 0;
2446         char *buf = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP);
2447 
2448         /*
2449          * Find the desired mounted file system
2450          */
2451         vfs_list_lock();
2452         vfsp = rootvfs;
2453         do {
2454                 if (vfsp->vfs_dev == dev &&
2455                     strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) {
2456                         found = 1;
2457                         break;
2458                 }
2459                 vfsp = vfsp->vfs_next;
2460         } while (vfsp != rootvfs);
2461 
2462         if (!found) {
2463                 err = EINVAL;
2464                 goto out;
2465         }
2466         err = secpolicy_fs_config(cr, vfsp);
2467         if (err != 0)
2468                 goto out;
2469 
2470         mops = &vfsp->vfs_mntopts;
2471         /*
2472          * Add tag if it doesn't already exist
2473          */
2474         if ((mop = vfs_hasopt(mops, tag)) == NULL) {
2475                 int len;
2476 
2477                 (void) vfs_buildoptionstr(mops, buf, MAX_MNTOPT_STR);
2478                 len = strlen(buf);
2479                 if (len + strlen(tag) + 2 > MAX_MNTOPT_STR) {
2480                         err = ENAMETOOLONG;
2481                         goto out;
2482                 }
2483                 mop = vfs_addtag(mops, tag);
2484         }
2485         if ((mop->mo_flags & MO_TAG) == 0) {
2486                 err = EINVAL;
2487                 goto out;
2488         }
2489         vfs_setmntopt_nolock(mops, tag, NULL, 0, 1);
2490 out:
2491         vfs_list_unlock();
2492         kmem_free(buf, MAX_MNTOPT_STR);
2493         return (err);
2494 }
2495 
2496 /*
2497  * Allow users to remove arbitrary "tags" in a vfs's mount options.
2498  * Broader use within the kernel is discouraged.
2499  */
2500 int
2501 vfs_clrtag(uint_t major, uint_t minor, const char *mntpt, const char *tag,
2502     cred_t *cr)
2503 {
2504         vfs_t *vfsp;
2505         mntopt_t *mop;
2506         int found = 0;
2507         dev_t dev = makedevice(major, minor);
2508         int err = 0;
2509 
2510         /*
2511          * Find the desired mounted file system
2512          */
2513         vfs_list_lock();
2514         vfsp = rootvfs;
2515         do {
2516                 if (vfsp->vfs_dev == dev &&
2517                     strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) {
2518                         found = 1;
2519                         break;
2520                 }
2521                 vfsp = vfsp->vfs_next;
2522         } while (vfsp != rootvfs);
2523 
2524         if (!found) {
2525                 err = EINVAL;
2526                 goto out;
2527         }
2528         err = secpolicy_fs_config(cr, vfsp);
2529         if (err != 0)
2530                 goto out;
2531 
2532         if ((mop = vfs_hasopt(&vfsp->vfs_mntopts, tag)) == NULL) {
2533                 err = EINVAL;
2534                 goto out;
2535         }
2536         if ((mop->mo_flags & MO_TAG) == 0) {
2537                 err = EINVAL;
2538                 goto out;
2539         }
2540         vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, tag, 1);
2541 out:
2542         vfs_list_unlock();
2543         return (err);
2544 }
2545 
2546 /*
2547  * Function to parse an option string and fill in a mount options table.
2548  * Unknown options are silently ignored.  The input option string is modified
2549  * by replacing separators with nulls.  If the create flag is set, options
2550  * not found in the table are just added on the fly.  The table must have
2551  * an option slot marked MO_EMPTY to add an option on the fly.
2552  *
2553  * This function is *not* for general use by filesystems.
2554  *
2555  * Note: caller is responsible for locking the vfs list, if needed,
2556  *       to protect mops..
2557  */
2558 void
2559 vfs_parsemntopts(mntopts_t *mops, char *osp, int create)
2560 {
2561         char *s = osp, *p, *nextop, *valp, *cp, *ep;
2562         int setflg = VFS_NOFORCEOPT;
2563 
2564         if (osp == NULL)
2565                 return;
2566         while (*s != '\0') {
2567                 p = strchr(s, ',');     /* find next option */
2568                 if (p == NULL) {
2569                         cp = NULL;
2570                         p = s + strlen(s);
2571                 } else {
2572                         cp = p;         /* save location of comma */
2573                         *p++ = '\0';    /* mark end and point to next option */
2574                 }
2575                 nextop = p;
2576                 p = strchr(s, '=');     /* look for value */
2577                 if (p == NULL) {
2578                         valp = NULL;    /* no value supplied */
2579                 } else {
2580                         ep = p;         /* save location of equals */
2581                         *p++ = '\0';    /* end option and point to value */
2582                         valp = p;
2583                 }
2584                 /*
2585                  * set option into options table
2586                  */
2587                 if (create)
2588                         setflg |= VFS_CREATEOPT;
2589                 vfs_setmntopt_nolock(mops, s, valp, setflg, 0);
2590                 if (cp != NULL)
2591                         *cp = ',';      /* restore the comma */
2592                 if (valp != NULL)
2593                         *ep = '=';      /* restore the equals */
2594                 s = nextop;
2595         }
2596 }
2597 
2598 /*
2599  * Function to inquire if an option exists in a mount options table.
2600  * Returns a pointer to the option if it exists, else NULL.
2601  *
2602  * This function is *not* for general use by filesystems.
2603  *
2604  * Note: caller is responsible for locking the vfs list, if needed,
2605  *       to protect mops.
2606  */
2607 struct mntopt *
2608 vfs_hasopt(const mntopts_t *mops, const char *opt)
2609 {
2610         struct mntopt *mop;
2611         uint_t i, count;
2612 
2613         count = mops->mo_count;
2614         for (i = 0; i < count; i++) {
2615                 mop = &mops->mo_list[i];
2616 
2617                 if (mop->mo_flags & MO_EMPTY)
2618                         continue;
2619                 if (strcmp(opt, mop->mo_name) == 0)
2620                         return (mop);
2621         }
2622         return (NULL);
2623 }
2624 
2625 /*
2626  * Function to inquire if an option is set in a mount options table.
2627  * Returns non-zero if set and fills in the arg pointer with a pointer to
2628  * the argument string or NULL if there is no argument string.
2629  */
2630 static int
2631 vfs_optionisset_nolock(const mntopts_t *mops, const char *opt, char **argp)
2632 {
2633         struct mntopt *mop;
2634         uint_t i, count;
2635 
2636         count = mops->mo_count;
2637         for (i = 0; i < count; i++) {
2638                 mop = &mops->mo_list[i];
2639 
2640                 if (mop->mo_flags & MO_EMPTY)
2641                         continue;
2642                 if (strcmp(opt, mop->mo_name))
2643                         continue;
2644                 if ((mop->mo_flags & MO_SET) == 0)
2645                         return (0);
2646                 if (argp != NULL && (mop->mo_flags & MO_HASVALUE) != 0)
2647                         *argp = mop->mo_arg;
2648                 return (1);
2649         }
2650         return (0);
2651 }
2652 
2653 
2654 int
2655 vfs_optionisset(const struct vfs *vfsp, const char *opt, char **argp)
2656 {
2657         int ret;
2658 
2659         vfs_list_read_lock();
2660         ret = vfs_optionisset_nolock(&vfsp->vfs_mntopts, opt, argp);
2661         vfs_list_unlock();
2662         return (ret);
2663 }
2664 
2665 
2666 /*
2667  * Construct a comma separated string of the options set in the given
2668  * mount table, return the string in the given buffer.  Return non-zero if
2669  * the buffer would overflow.
2670  *
2671  * This function is *not* for general use by filesystems.
2672  *
2673  * Note: caller is responsible for locking the vfs list, if needed,
2674  *       to protect mp.
2675  */
2676 int
2677 vfs_buildoptionstr(const mntopts_t *mp, char *buf, int len)
2678 {
2679         char *cp;
2680         uint_t i;
2681 
2682         buf[0] = '\0';
2683         cp = buf;
2684         for (i = 0; i < mp->mo_count; i++) {
2685                 struct mntopt *mop;
2686 
2687                 mop = &mp->mo_list[i];
2688                 if (mop->mo_flags & MO_SET) {
2689                         int optlen, comma = 0;
2690 
2691                         if (buf[0] != '\0')
2692                                 comma = 1;
2693                         optlen = strlen(mop->mo_name);
2694                         if (strlen(buf) + comma + optlen + 1 > len)
2695                                 goto err;
2696                         if (comma)
2697                                 *cp++ = ',';
2698                         (void) strcpy(cp, mop->mo_name);
2699                         cp += optlen;
2700                         /*
2701                          * Append option value if there is one
2702                          */
2703                         if (mop->mo_arg != NULL) {
2704                                 int arglen;
2705 
2706                                 arglen = strlen(mop->mo_arg);
2707                                 if (strlen(buf) + arglen + 2 > len)
2708                                         goto err;
2709                                 *cp++ = '=';
2710                                 (void) strcpy(cp, mop->mo_arg);
2711                                 cp += arglen;
2712                         }
2713                 }
2714         }
2715         return (0);
2716 err:
2717         return (EOVERFLOW);
2718 }
2719 
2720 static void
2721 vfs_freecancelopt(char **moc)
2722 {
2723         if (moc != NULL) {
2724                 int ccnt = 0;
2725                 char **cp;
2726 
2727                 for (cp = moc; *cp != NULL; cp++) {
2728                         kmem_free(*cp, strlen(*cp) + 1);
2729                         ccnt++;
2730                 }
2731                 kmem_free(moc, (ccnt + 1) * sizeof (char *));
2732         }
2733 }
2734 
2735 static void
2736 vfs_freeopt(mntopt_t *mop)
2737 {
2738         if (mop->mo_name != NULL)
2739                 kmem_free(mop->mo_name, strlen(mop->mo_name) + 1);
2740 
2741         vfs_freecancelopt(mop->mo_cancel);
2742 
2743         if (mop->mo_arg != NULL)
2744                 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2745 }
2746 
2747 /*
2748  * Free a mount options table
2749  *
2750  * This function is *not* for general use by filesystems.
2751  *
2752  * Note: caller is responsible for locking the vfs list, if needed,
2753  *       to protect mp.
2754  */
2755 void
2756 vfs_freeopttbl(mntopts_t *mp)
2757 {
2758         uint_t i, count;
2759 
2760         count = mp->mo_count;
2761         for (i = 0; i < count; i++) {
2762                 vfs_freeopt(&mp->mo_list[i]);
2763         }
2764         if (count) {
2765                 kmem_free(mp->mo_list, sizeof (mntopt_t) * count);
2766                 mp->mo_count = 0;
2767                 mp->mo_list = NULL;
2768         }
2769 }
2770 
2771 
2772 /* ARGSUSED */
2773 static int
2774 vfs_mntdummyread(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred,
2775         caller_context_t *ct)
2776 {
2777         return (0);
2778 }
2779 
2780 /* ARGSUSED */
2781 static int
2782 vfs_mntdummywrite(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred,
2783         caller_context_t *ct)
2784 {
2785         return (0);
2786 }
2787 
2788 /*
2789  * The dummy vnode is currently used only by file events notification
2790  * module which is just interested in the timestamps.
2791  */
2792 /* ARGSUSED */
2793 static int
2794 vfs_mntdummygetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
2795     caller_context_t *ct)
2796 {
2797         bzero(vap, sizeof (vattr_t));
2798         vap->va_type = VREG;
2799         vap->va_nlink = 1;
2800         vap->va_ctime = vfs_mnttab_ctime;
2801         /*
2802          * it is ok to just copy mtime as the time will be monotonically
2803          * increasing.
2804          */
2805         vap->va_mtime = vfs_mnttab_mtime;
2806         vap->va_atime = vap->va_mtime;
2807         return (0);
2808 }
2809 
2810 static void
2811 vfs_mnttabvp_setup(void)
2812 {
2813         vnode_t *tvp;
2814         vnodeops_t *vfs_mntdummyvnops;
2815         const fs_operation_def_t mnt_dummyvnodeops_template[] = {
2816                 VOPNAME_READ,           { .vop_read = vfs_mntdummyread },
2817                 VOPNAME_WRITE,          { .vop_write = vfs_mntdummywrite },
2818                 VOPNAME_GETATTR,        { .vop_getattr = vfs_mntdummygetattr },
2819                 VOPNAME_VNEVENT,        { .vop_vnevent = fs_vnevent_support },
2820                 NULL,                   NULL
2821         };
2822 
2823         if (vn_make_ops("mnttab", mnt_dummyvnodeops_template,
2824             &vfs_mntdummyvnops) != 0) {
2825                 cmn_err(CE_WARN, "vfs_mnttabvp_setup: vn_make_ops failed");
2826                 /* Shouldn't happen, but not bad enough to panic */
2827                 return;
2828         }
2829 
2830         /*
2831          * A global dummy vnode is allocated to represent mntfs files.
2832          * The mntfs file (/etc/mnttab) can be monitored for file events
2833          * and receive an event when mnttab changes. Dummy VOP calls
2834          * will be made on this vnode. The file events notification module
2835          * intercepts this vnode and delivers relevant events.
2836          */
2837         tvp = vn_alloc(KM_SLEEP);
2838         tvp->v_flag = VNOMOUNT|VNOMAP|VNOSWAP|VNOCACHE;
2839         vn_setops(tvp, vfs_mntdummyvnops);
2840         tvp->v_type = VREG;
2841         /*
2842          * The mnt dummy ops do not reference v_data.
2843          * No other module intercepting this vnode should either.
2844          * Just set it to point to itself.
2845          */
2846         tvp->v_data = (caddr_t)tvp;
2847         tvp->v_vfsp = rootvfs;
2848         vfs_mntdummyvp = tvp;
2849 }
2850 
2851 /*
2852  * performs fake read/write ops
2853  */
2854 static void
2855 vfs_mnttab_rwop(int rw)
2856 {
2857         struct uio      uio;
2858         struct iovec    iov;
2859         char    buf[1];
2860 
2861         if (vfs_mntdummyvp == NULL)
2862                 return;
2863 
2864         bzero(&uio, sizeof (uio));
2865         bzero(&iov, sizeof (iov));
2866         iov.iov_base = buf;
2867         iov.iov_len = 0;
2868         uio.uio_iov = &iov;
2869         uio.uio_iovcnt = 1;
2870         uio.uio_loffset = 0;
2871         uio.uio_segflg = UIO_SYSSPACE;
2872         uio.uio_resid = 0;
2873         if (rw) {
2874                 (void) VOP_WRITE(vfs_mntdummyvp, &uio, 0, kcred, NULL);
2875         } else {
2876                 (void) VOP_READ(vfs_mntdummyvp, &uio, 0, kcred, NULL);
2877         }
2878 }
2879 
2880 /*
2881  * Generate a write operation.
2882  */
2883 void
2884 vfs_mnttab_writeop(void)
2885 {
2886         vfs_mnttab_rwop(1);
2887 }
2888 
2889 /*
2890  * Generate a read operation.
2891  */
2892 void
2893 vfs_mnttab_readop(void)
2894 {
2895         vfs_mnttab_rwop(0);
2896 }
2897 
2898 /*
2899  * Free any mnttab information recorded in the vfs struct.
2900  * The vfs must not be on the vfs list.
2901  */
2902 static void
2903 vfs_freemnttab(struct vfs *vfsp)
2904 {
2905         ASSERT(!VFS_ON_LIST(vfsp));
2906 
2907         /*
2908          * Free device and mount point information
2909          */
2910         if (vfsp->vfs_mntpt != NULL) {
2911                 refstr_rele(vfsp->vfs_mntpt);
2912                 vfsp->vfs_mntpt = NULL;
2913         }
2914         if (vfsp->vfs_resource != NULL) {
2915                 refstr_rele(vfsp->vfs_resource);
2916                 vfsp->vfs_resource = NULL;
2917         }
2918         /*
2919          * Now free mount options information
2920          */
2921         vfs_freeopttbl(&vfsp->vfs_mntopts);
2922 }
2923 
2924 /*
2925  * Return the last mnttab modification time
2926  */
2927 void
2928 vfs_mnttab_modtime(timespec_t *ts)
2929 {
2930         ASSERT(RW_LOCK_HELD(&vfslist));
2931         *ts = vfs_mnttab_mtime;
2932 }
2933 
2934 /*
2935  * See if mnttab is changed
2936  */
2937 void
2938 vfs_mnttab_poll(timespec_t *old, struct pollhead **phpp)
2939 {
2940         int changed;
2941 
2942         *phpp = (struct pollhead *)NULL;
2943 
2944         /*
2945          * Note: don't grab vfs list lock before accessing vfs_mnttab_mtime.
2946          * Can lead to deadlock against vfs_mnttab_modtimeupd(). It is safe
2947          * to not grab the vfs list lock because tv_sec is monotonically
2948          * increasing.
2949          */
2950 
2951         changed = (old->tv_nsec != vfs_mnttab_mtime.tv_nsec) ||
2952             (old->tv_sec != vfs_mnttab_mtime.tv_sec);
2953         if (!changed) {
2954                 *phpp = &vfs_pollhd;
2955         }
2956 }
2957 
2958 /* Provide a unique and monotonically-increasing timestamp. */
2959 void
2960 vfs_mono_time(timespec_t *ts)
2961 {
2962         static volatile hrtime_t hrt;           /* The saved time. */
2963         hrtime_t        newhrt, oldhrt;         /* For effecting the CAS. */
2964         timespec_t      newts;
2965 
2966         /*
2967          * Try gethrestime() first, but be prepared to fabricate a sensible
2968          * answer at the first sign of any trouble.
2969          */
2970         gethrestime(&newts);
2971         newhrt = ts2hrt(&newts);
2972         for (;;) {
2973                 oldhrt = hrt;
2974                 if (newhrt <= hrt)
2975                         newhrt = hrt + 1;
2976                 if (cas64((uint64_t *)&hrt, oldhrt, newhrt) == oldhrt)
2977                         break;
2978         }
2979         hrt2ts(newhrt, ts);
2980 }
2981 
2982 /*
2983  * Update the mnttab modification time and wake up any waiters for
2984  * mnttab changes
2985  */
2986 void
2987 vfs_mnttab_modtimeupd()
2988 {
2989         hrtime_t oldhrt, newhrt;
2990 
2991         ASSERT(RW_WRITE_HELD(&vfslist));
2992         oldhrt = ts2hrt(&vfs_mnttab_mtime);
2993         gethrestime(&vfs_mnttab_mtime);
2994         newhrt = ts2hrt(&vfs_mnttab_mtime);
2995         if (oldhrt == (hrtime_t)0)
2996                 vfs_mnttab_ctime = vfs_mnttab_mtime;
2997         /*
2998          * Attempt to provide unique mtime (like uniqtime but not).
2999          */
3000         if (newhrt == oldhrt) {
3001                 newhrt++;
3002                 hrt2ts(newhrt, &vfs_mnttab_mtime);
3003         }
3004         pollwakeup(&vfs_pollhd, (short)POLLRDBAND);
3005         vfs_mnttab_writeop();
3006 }
3007 
3008 int
3009 dounmount(struct vfs *vfsp, int flag, cred_t *cr)
3010 {
3011         vnode_t *coveredvp;
3012         int error;
3013         extern void teardown_vopstats(vfs_t *);
3014 
3015         /*
3016          * Get covered vnode. This will be NULL if the vfs is not linked
3017          * into the file system name space (i.e., domount() with MNT_NOSPICE).
3018          */
3019         coveredvp = vfsp->vfs_vnodecovered;
3020         ASSERT(coveredvp == NULL || vn_vfswlock_held(coveredvp));
3021 
3022         /*
3023          * Purge all dnlc entries for this vfs.
3024          */
3025         (void) dnlc_purge_vfsp(vfsp, 0);
3026 
3027         /* For forcible umount, skip VFS_SYNC() since it may hang */
3028         if ((flag & MS_FORCE) == 0)
3029                 (void) VFS_SYNC(vfsp, 0, cr);
3030 
3031         /*
3032          * Lock the vfs to maintain fs status quo during unmount.  This
3033          * has to be done after the sync because ufs_update tries to acquire
3034          * the vfs_reflock.
3035          */
3036         vfs_lock_wait(vfsp);
3037 
3038         if (error = VFS_UNMOUNT(vfsp, flag, cr)) {
3039                 vfs_unlock(vfsp);
3040                 if (coveredvp != NULL)
3041                         vn_vfsunlock(coveredvp);
3042         } else if (coveredvp != NULL) {
3043                 teardown_vopstats(vfsp);
3044                 /*
3045                  * vfs_remove() will do a VN_RELE(vfsp->vfs_vnodecovered)
3046                  * when it frees vfsp so we do a VN_HOLD() so we can
3047                  * continue to use coveredvp afterwards.
3048                  */
3049                 VN_HOLD(coveredvp);
3050                 vfs_remove(vfsp);
3051                 vn_vfsunlock(coveredvp);
3052                 VN_RELE(coveredvp);
3053         } else {
3054                 teardown_vopstats(vfsp);
3055                 /*
3056                  * Release the reference to vfs that is not linked
3057                  * into the name space.
3058                  */
3059                 vfs_unlock(vfsp);
3060                 VFS_RELE(vfsp);
3061         }
3062         return (error);
3063 }
3064 
3065 
3066 /*
3067  * Vfs_unmountall() is called by uadmin() to unmount all
3068  * mounted file systems (except the root file system) during shutdown.
3069  * It follows the existing locking protocol when traversing the vfs list
3070  * to sync and unmount vfses. Even though there should be no
3071  * other thread running while the system is shutting down, it is prudent
3072  * to still follow the locking protocol.
3073  */
3074 void
3075 vfs_unmountall(void)
3076 {
3077         struct vfs *vfsp;
3078         struct vfs *prev_vfsp = NULL;
3079         int error;
3080 
3081         /*
3082          * Toss all dnlc entries now so that the per-vfs sync
3083          * and unmount operations don't have to slog through
3084          * a bunch of uninteresting vnodes over and over again.
3085          */
3086         dnlc_purge();
3087 
3088         vfs_list_lock();
3089         for (vfsp = rootvfs->vfs_prev; vfsp != rootvfs; vfsp = prev_vfsp) {
3090                 prev_vfsp = vfsp->vfs_prev;
3091 
3092                 if (vfs_lock(vfsp) != 0)
3093                         continue;
3094                 error = vn_vfswlock(vfsp->vfs_vnodecovered);
3095                 vfs_unlock(vfsp);
3096                 if (error)
3097                         continue;
3098 
3099                 vfs_list_unlock();
3100 
3101                 (void) VFS_SYNC(vfsp, SYNC_CLOSE, CRED());
3102                 (void) dounmount(vfsp, 0, CRED());
3103 
3104                 /*
3105                  * Since we dropped the vfslist lock above we must
3106                  * verify that next_vfsp still exists, else start over.
3107                  */
3108                 vfs_list_lock();
3109                 for (vfsp = rootvfs->vfs_prev;
3110                     vfsp != rootvfs; vfsp = vfsp->vfs_prev)
3111                         if (vfsp == prev_vfsp)
3112                                 break;
3113                 if (vfsp == rootvfs && prev_vfsp != rootvfs)
3114                         prev_vfsp = rootvfs->vfs_prev;
3115         }
3116         vfs_list_unlock();
3117 }
3118 
3119 /*
3120  * Called to add an entry to the end of the vfs mount in progress list
3121  */
3122 void
3123 vfs_addmip(dev_t dev, struct vfs *vfsp)
3124 {
3125         struct ipmnt *mipp;
3126 
3127         mipp = (struct ipmnt *)kmem_alloc(sizeof (struct ipmnt), KM_SLEEP);
3128         mipp->mip_next = NULL;
3129         mipp->mip_dev = dev;
3130         mipp->mip_vfsp = vfsp;
3131         mutex_enter(&vfs_miplist_mutex);
3132         if (vfs_miplist_end != NULL)
3133                 vfs_miplist_end->mip_next = mipp;
3134         else
3135                 vfs_miplist = mipp;
3136         vfs_miplist_end = mipp;
3137         mutex_exit(&vfs_miplist_mutex);
3138 }
3139 
3140 /*
3141  * Called to remove an entry from the mount in progress list
3142  * Either because the mount completed or it failed.
3143  */
3144 void
3145 vfs_delmip(struct vfs *vfsp)
3146 {
3147         struct ipmnt *mipp, *mipprev;
3148 
3149         mutex_enter(&vfs_miplist_mutex);
3150         mipprev = NULL;
3151         for (mipp = vfs_miplist;
3152             mipp && mipp->mip_vfsp != vfsp; mipp = mipp->mip_next) {
3153                 mipprev = mipp;
3154         }
3155         if (mipp == NULL)
3156                 return; /* shouldn't happen */
3157         if (mipp == vfs_miplist_end)
3158                 vfs_miplist_end = mipprev;
3159         if (mipprev == NULL)
3160                 vfs_miplist = mipp->mip_next;
3161         else
3162                 mipprev->mip_next = mipp->mip_next;
3163         mutex_exit(&vfs_miplist_mutex);
3164         kmem_free(mipp, sizeof (struct ipmnt));
3165 }
3166 
3167 /*
3168  * vfs_add is called by a specific filesystem's mount routine to add
3169  * the new vfs into the vfs list/hash and to cover the mounted-on vnode.
3170  * The vfs should already have been locked by the caller.
3171  *
3172  * coveredvp is NULL if this is the root.
3173  */
3174 void
3175 vfs_add(vnode_t *coveredvp, struct vfs *vfsp, int mflag)
3176 {
3177         int newflag;
3178 
3179         ASSERT(vfs_lock_held(vfsp));
3180         VFS_HOLD(vfsp);
3181         newflag = vfsp->vfs_flag;
3182         if (mflag & MS_RDONLY)
3183                 newflag |= VFS_RDONLY;
3184         else
3185                 newflag &= ~VFS_RDONLY;
3186         if (mflag & MS_NOSUID)
3187                 newflag |= (VFS_NOSETUID|VFS_NODEVICES);
3188         else
3189                 newflag &= ~(VFS_NOSETUID|VFS_NODEVICES);
3190         if (mflag & MS_NOMNTTAB)
3191                 newflag |= VFS_NOMNTTAB;
3192         else
3193                 newflag &= ~VFS_NOMNTTAB;
3194 
3195         if (coveredvp != NULL) {
3196                 ASSERT(vn_vfswlock_held(coveredvp));
3197                 coveredvp->v_vfsmountedhere = vfsp;
3198                 VN_HOLD(coveredvp);
3199         }
3200         vfsp->vfs_vnodecovered = coveredvp;
3201         vfsp->vfs_flag = newflag;
3202 
3203         vfs_list_add(vfsp);
3204 }
3205 
3206 /*
3207  * Remove a vfs from the vfs list, null out the pointer from the
3208  * covered vnode to the vfs (v_vfsmountedhere), and null out the pointer
3209  * from the vfs to the covered vnode (vfs_vnodecovered). Release the
3210  * reference to the vfs and to the covered vnode.
3211  *
3212  * Called from dounmount after it's confirmed with the file system
3213  * that the unmount is legal.
3214  */
3215 void
3216 vfs_remove(struct vfs *vfsp)
3217 {
3218         vnode_t *vp;
3219 
3220         ASSERT(vfs_lock_held(vfsp));
3221 
3222         /*
3223          * Can't unmount root.  Should never happen because fs will
3224          * be busy.
3225          */
3226         if (vfsp == rootvfs)
3227                 panic("vfs_remove: unmounting root");
3228 
3229         vfs_list_remove(vfsp);
3230 
3231         /*
3232          * Unhook from the file system name space.
3233          */
3234         vp = vfsp->vfs_vnodecovered;
3235         ASSERT(vn_vfswlock_held(vp));
3236         vp->v_vfsmountedhere = NULL;
3237         vfsp->vfs_vnodecovered = NULL;
3238         VN_RELE(vp);
3239 
3240         /*
3241          * Release lock and wakeup anybody waiting.
3242          */
3243         vfs_unlock(vfsp);
3244         VFS_RELE(vfsp);
3245 }
3246 
3247 /*
3248  * Lock a filesystem to prevent access to it while mounting,
3249  * unmounting and syncing.  Return EBUSY immediately if lock
3250  * can't be acquired.
3251  */
3252 int
3253 vfs_lock(vfs_t *vfsp)
3254 {
3255         vn_vfslocks_entry_t *vpvfsentry;
3256 
3257         vpvfsentry = vn_vfslocks_getlock(vfsp);
3258         if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER))
3259                 return (0);
3260 
3261         vn_vfslocks_rele(vpvfsentry);
3262         return (EBUSY);
3263 }
3264 
3265 int
3266 vfs_rlock(vfs_t *vfsp)
3267 {
3268         vn_vfslocks_entry_t *vpvfsentry;
3269 
3270         vpvfsentry = vn_vfslocks_getlock(vfsp);
3271 
3272         if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER))
3273                 return (0);
3274 
3275         vn_vfslocks_rele(vpvfsentry);
3276         return (EBUSY);
3277 }
3278 
3279 void
3280 vfs_lock_wait(vfs_t *vfsp)
3281 {
3282         vn_vfslocks_entry_t *vpvfsentry;
3283 
3284         vpvfsentry = vn_vfslocks_getlock(vfsp);
3285         rwst_enter(&vpvfsentry->ve_lock, RW_WRITER);
3286 }
3287 
3288 void
3289 vfs_rlock_wait(vfs_t *vfsp)
3290 {
3291         vn_vfslocks_entry_t *vpvfsentry;
3292 
3293         vpvfsentry = vn_vfslocks_getlock(vfsp);
3294         rwst_enter(&vpvfsentry->ve_lock, RW_READER);
3295 }
3296 
3297 /*
3298  * Unlock a locked filesystem.
3299  */
3300 void
3301 vfs_unlock(vfs_t *vfsp)
3302 {
3303         vn_vfslocks_entry_t *vpvfsentry;
3304 
3305         /*
3306          * vfs_unlock will mimic sema_v behaviour to fix 4748018.
3307          * And these changes should remain for the patch changes as it is.
3308          */
3309         if (panicstr)
3310                 return;
3311 
3312         /*
3313          * ve_refcount needs to be dropped twice here.
3314          * 1. To release refernce after a call to vfs_locks_getlock()
3315          * 2. To release the reference from the locking routines like
3316          *    vfs_rlock_wait/vfs_wlock_wait/vfs_wlock etc,.
3317          */
3318 
3319         vpvfsentry = vn_vfslocks_getlock(vfsp);
3320         vn_vfslocks_rele(vpvfsentry);
3321 
3322         rwst_exit(&vpvfsentry->ve_lock);
3323         vn_vfslocks_rele(vpvfsentry);
3324 }
3325 
3326 /*
3327  * Utility routine that allows a filesystem to construct its
3328  * fsid in "the usual way" - by munging some underlying dev_t and
3329  * the filesystem type number into the 64-bit fsid.  Note that
3330  * this implicitly relies on dev_t persistence to make filesystem
3331  * id's persistent.
3332  *
3333  * There's nothing to prevent an individual fs from constructing its
3334  * fsid in a different way, and indeed they should.
3335  *
3336  * Since we want fsids to be 32-bit quantities (so that they can be
3337  * exported identically by either 32-bit or 64-bit APIs, as well as
3338  * the fact that fsid's are "known" to NFS), we compress the device
3339  * number given down to 32-bits, and panic if that isn't possible.
3340  */
3341 void
3342 vfs_make_fsid(fsid_t *fsi, dev_t dev, int val)
3343 {
3344         if (!cmpldev((dev32_t *)&fsi->val[0], dev))
3345                 panic("device number too big for fsid!");
3346         fsi->val[1] = val;
3347 }
3348 
3349 int
3350 vfs_lock_held(vfs_t *vfsp)
3351 {
3352         int held;
3353         vn_vfslocks_entry_t *vpvfsentry;
3354 
3355         /*
3356          * vfs_lock_held will mimic sema_held behaviour
3357          * if panicstr is set. And these changes should remain
3358          * for the patch changes as it is.
3359          */
3360         if (panicstr)
3361                 return (1);
3362 
3363         vpvfsentry = vn_vfslocks_getlock(vfsp);
3364         held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER);
3365 
3366         vn_vfslocks_rele(vpvfsentry);
3367         return (held);
3368 }
3369 
3370 struct _kthread *
3371 vfs_lock_owner(vfs_t *vfsp)
3372 {
3373         struct _kthread *owner;
3374         vn_vfslocks_entry_t *vpvfsentry;
3375 
3376         /*
3377          * vfs_wlock_held will mimic sema_held behaviour
3378          * if panicstr is set. And these changes should remain
3379          * for the patch changes as it is.
3380          */
3381         if (panicstr)
3382                 return (NULL);
3383 
3384         vpvfsentry = vn_vfslocks_getlock(vfsp);
3385         owner = rwst_owner(&vpvfsentry->ve_lock);
3386 
3387         vn_vfslocks_rele(vpvfsentry);
3388         return (owner);
3389 }
3390 
3391 /*
3392  * vfs list locking.
3393  *
3394  * Rather than manipulate the vfslist lock directly, we abstract into lock
3395  * and unlock routines to allow the locking implementation to be changed for
3396  * clustering.
3397  *
3398  * Whenever the vfs list is modified through its hash links, the overall list
3399  * lock must be obtained before locking the relevant hash bucket.  But to see
3400  * whether a given vfs is on the list, it suffices to obtain the lock for the
3401  * hash bucket without getting the overall list lock.  (See getvfs() below.)
3402  */
3403 
3404 void
3405 vfs_list_lock()
3406 {
3407         rw_enter(&vfslist, RW_WRITER);
3408 }
3409 
3410 void
3411 vfs_list_read_lock()
3412 {
3413         rw_enter(&vfslist, RW_READER);
3414 }
3415 
3416 void
3417 vfs_list_unlock()
3418 {
3419         rw_exit(&vfslist);
3420 }
3421 
3422 /*
3423  * Low level worker routines for adding entries to and removing entries from
3424  * the vfs list.
3425  */
3426 
3427 static void
3428 vfs_hash_add(struct vfs *vfsp, int insert_at_head)
3429 {
3430         int vhno;
3431         struct vfs **hp;
3432         dev_t dev;
3433 
3434         ASSERT(RW_WRITE_HELD(&vfslist));
3435 
3436         dev = expldev(vfsp->vfs_fsid.val[0]);
3437         vhno = VFSHASH(getmajor(dev), getminor(dev));
3438 
3439         mutex_enter(&rvfs_list[vhno].rvfs_lock);
3440 
3441         /*
3442          * Link into the hash table, inserting it at the end, so that LOFS
3443          * with the same fsid as UFS (or other) file systems will not hide the
3444          * UFS.
3445          */
3446         if (insert_at_head) {
3447                 vfsp->vfs_hash = rvfs_list[vhno].rvfs_head;
3448                 rvfs_list[vhno].rvfs_head = vfsp;
3449         } else {
3450                 for (hp = &rvfs_list[vhno].rvfs_head; *hp != NULL;
3451                     hp = &(*hp)->vfs_hash)
3452                         continue;
3453                 /*
3454                  * hp now contains the address of the pointer to update
3455                  * to effect the insertion.
3456                  */
3457                 vfsp->vfs_hash = NULL;
3458                 *hp = vfsp;
3459         }
3460 
3461         rvfs_list[vhno].rvfs_len++;
3462         mutex_exit(&rvfs_list[vhno].rvfs_lock);
3463 }
3464 
3465 
3466 static void
3467 vfs_hash_remove(struct vfs *vfsp)
3468 {
3469         int vhno;
3470         struct vfs *tvfsp;
3471         dev_t dev;
3472 
3473         ASSERT(RW_WRITE_HELD(&vfslist));
3474 
3475         dev = expldev(vfsp->vfs_fsid.val[0]);
3476         vhno = VFSHASH(getmajor(dev), getminor(dev));
3477 
3478         mutex_enter(&rvfs_list[vhno].rvfs_lock);
3479 
3480         /*
3481          * Remove from hash.
3482          */
3483         if (rvfs_list[vhno].rvfs_head == vfsp) {
3484                 rvfs_list[vhno].rvfs_head = vfsp->vfs_hash;
3485                 rvfs_list[vhno].rvfs_len--;
3486                 goto foundit;
3487         }
3488         for (tvfsp = rvfs_list[vhno].rvfs_head; tvfsp != NULL;
3489             tvfsp = tvfsp->vfs_hash) {
3490                 if (tvfsp->vfs_hash == vfsp) {
3491                         tvfsp->vfs_hash = vfsp->vfs_hash;
3492                         rvfs_list[vhno].rvfs_len--;
3493                         goto foundit;
3494                 }
3495         }
3496         cmn_err(CE_WARN, "vfs_list_remove: vfs not found in hash");
3497 
3498 foundit:
3499 
3500         mutex_exit(&rvfs_list[vhno].rvfs_lock);
3501 }
3502 
3503 
3504 void
3505 vfs_list_add(struct vfs *vfsp)
3506 {
3507         zone_t *zone;
3508 
3509         /*
3510          * Typically, the vfs_t will have been created on behalf of the file
3511          * system in vfs_init, where it will have been provided with a
3512          * vfs_impl_t. This, however, might be lacking if the vfs_t was created
3513          * by an unbundled file system. We therefore check for such an example
3514          * before stamping the vfs_t with its creation time for the benefit of
3515          * mntfs.
3516          */
3517         if (vfsp->vfs_implp == NULL)
3518                 vfsimpl_setup(vfsp);
3519         vfs_mono_time(&vfsp->vfs_hrctime);
3520 
3521         /*
3522          * The zone that owns the mount is the one that performed the mount.
3523          * Note that this isn't necessarily the same as the zone mounted into.
3524          * The corresponding zone_rele_ref() will be done when the vfs_t
3525          * is being free'd.
3526          */
3527         vfsp->vfs_zone = curproc->p_zone;
3528         zone_init_ref(&vfsp->vfs_implp->vi_zone_ref);
3529         zone_hold_ref(vfsp->vfs_zone, &vfsp->vfs_implp->vi_zone_ref,
3530             ZONE_REF_VFS);
3531 
3532         /*
3533          * Find the zone mounted into, and put this mount on its vfs list.
3534          */
3535         zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
3536         ASSERT(zone != NULL);
3537         /*
3538          * Special casing for the root vfs.  This structure is allocated
3539          * statically and hooked onto rootvfs at link time.  During the
3540          * vfs_mountroot call at system startup time, the root file system's
3541          * VFS_MOUNTROOT routine will call vfs_add with this root vfs struct
3542          * as argument.  The code below must detect and handle this special
3543          * case.  The only apparent justification for this special casing is
3544          * to ensure that the root file system appears at the head of the
3545          * list.
3546          *
3547          * XXX: I'm assuming that it's ok to do normal list locking when
3548          *      adding the entry for the root file system (this used to be
3549          *      done with no locks held).
3550          */
3551         vfs_list_lock();
3552         /*
3553          * Link into the vfs list proper.
3554          */
3555         if (vfsp == &root) {
3556                 /*
3557                  * Assert: This vfs is already on the list as its first entry.
3558                  * Thus, there's nothing to do.
3559                  */
3560                 ASSERT(rootvfs == vfsp);
3561                 /*
3562                  * Add it to the head of the global zone's vfslist.
3563                  */
3564                 ASSERT(zone == global_zone);
3565                 ASSERT(zone->zone_vfslist == NULL);
3566                 zone->zone_vfslist = vfsp;
3567         } else {
3568                 /*
3569                  * Link to end of list using vfs_prev (as rootvfs is now a
3570                  * doubly linked circular list) so list is in mount order for
3571                  * mnttab use.
3572                  */
3573                 rootvfs->vfs_prev->vfs_next = vfsp;
3574                 vfsp->vfs_prev = rootvfs->vfs_prev;
3575                 rootvfs->vfs_prev = vfsp;
3576                 vfsp->vfs_next = rootvfs;
3577 
3578                 /*
3579                  * Do it again for the zone-private list (which may be NULL).
3580                  */
3581                 if (zone->zone_vfslist == NULL) {
3582                         ASSERT(zone != global_zone);
3583                         zone->zone_vfslist = vfsp;
3584                 } else {
3585                         zone->zone_vfslist->vfs_zone_prev->vfs_zone_next = vfsp;
3586                         vfsp->vfs_zone_prev = zone->zone_vfslist->vfs_zone_prev;
3587                         zone->zone_vfslist->vfs_zone_prev = vfsp;
3588                         vfsp->vfs_zone_next = zone->zone_vfslist;
3589                 }
3590         }
3591 
3592         /*
3593          * Link into the hash table, inserting it at the end, so that LOFS
3594          * with the same fsid as UFS (or other) file systems will not hide
3595          * the UFS.
3596          */
3597         vfs_hash_add(vfsp, 0);
3598 
3599         /*
3600          * update the mnttab modification time
3601          */
3602         vfs_mnttab_modtimeupd();
3603         vfs_list_unlock();
3604         zone_rele(zone);
3605 }
3606 
3607 void
3608 vfs_list_remove(struct vfs *vfsp)
3609 {
3610         zone_t *zone;
3611 
3612         zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
3613         ASSERT(zone != NULL);
3614         /*
3615          * Callers are responsible for preventing attempts to unmount the
3616          * root.
3617          */
3618         ASSERT(vfsp != rootvfs);
3619 
3620         vfs_list_lock();
3621 
3622         /*
3623          * Remove from hash.
3624          */
3625         vfs_hash_remove(vfsp);
3626 
3627         /*
3628          * Remove from vfs list.
3629          */
3630         vfsp->vfs_prev->vfs_next = vfsp->vfs_next;
3631         vfsp->vfs_next->vfs_prev = vfsp->vfs_prev;
3632         vfsp->vfs_next = vfsp->vfs_prev = NULL;
3633 
3634         /*
3635          * Remove from zone-specific vfs list.
3636          */
3637         if (zone->zone_vfslist == vfsp)
3638                 zone->zone_vfslist = vfsp->vfs_zone_next;
3639 
3640         if (vfsp->vfs_zone_next == vfsp) {
3641                 ASSERT(vfsp->vfs_zone_prev == vfsp);
3642                 ASSERT(zone->zone_vfslist == vfsp);
3643                 zone->zone_vfslist = NULL;
3644         }
3645 
3646         vfsp->vfs_zone_prev->vfs_zone_next = vfsp->vfs_zone_next;
3647         vfsp->vfs_zone_next->vfs_zone_prev = vfsp->vfs_zone_prev;
3648         vfsp->vfs_zone_next = vfsp->vfs_zone_prev = NULL;
3649 
3650         /*
3651          * update the mnttab modification time
3652          */
3653         vfs_mnttab_modtimeupd();
3654         vfs_list_unlock();
3655         zone_rele(zone);
3656 }
3657 
3658 struct vfs *
3659 getvfs(fsid_t *fsid)
3660 {
3661         struct vfs *vfsp;
3662         int val0 = fsid->val[0];
3663         int val1 = fsid->val[1];
3664         dev_t dev = expldev(val0);
3665         int vhno = VFSHASH(getmajor(dev), getminor(dev));
3666         kmutex_t *hmp = &rvfs_list[vhno].rvfs_lock;
3667 
3668         mutex_enter(hmp);
3669         for (vfsp = rvfs_list[vhno].rvfs_head; vfsp; vfsp = vfsp->vfs_hash) {
3670                 if (vfsp->vfs_fsid.val[0] == val0 &&
3671                     vfsp->vfs_fsid.val[1] == val1) {
3672                         VFS_HOLD(vfsp);
3673                         mutex_exit(hmp);
3674                         return (vfsp);
3675                 }
3676         }
3677         mutex_exit(hmp);
3678         return (NULL);
3679 }
3680 
3681 /*
3682  * Search the vfs mount in progress list for a specified device/vfs entry.
3683  * Returns 0 if the first entry in the list that the device matches has the
3684  * given vfs pointer as well.  If the device matches but a different vfs
3685  * pointer is encountered in the list before the given vfs pointer then
3686  * a 1 is returned.
3687  */
3688 
3689 int
3690 vfs_devmounting(dev_t dev, struct vfs *vfsp)
3691 {
3692         int retval = 0;
3693         struct ipmnt *mipp;
3694 
3695         mutex_enter(&vfs_miplist_mutex);
3696         for (mipp = vfs_miplist; mipp != NULL; mipp = mipp->mip_next) {
3697                 if (mipp->mip_dev == dev) {
3698                         if (mipp->mip_vfsp != vfsp)
3699                                 retval = 1;
3700                         break;
3701                 }
3702         }
3703         mutex_exit(&vfs_miplist_mutex);
3704         return (retval);
3705 }
3706 
3707 /*
3708  * Search the vfs list for a specified device.  Returns 1, if entry is found
3709  * or 0 if no suitable entry is found.
3710  */
3711 
3712 int
3713 vfs_devismounted(dev_t dev)
3714 {
3715         struct vfs *vfsp;
3716         int found;
3717 
3718         vfs_list_read_lock();
3719         vfsp = rootvfs;
3720         found = 0;
3721         do {
3722                 if (vfsp->vfs_dev == dev) {
3723                         found = 1;
3724                         break;
3725                 }
3726                 vfsp = vfsp->vfs_next;
3727         } while (vfsp != rootvfs);
3728 
3729         vfs_list_unlock();
3730         return (found);
3731 }
3732 
3733 /*
3734  * Search the vfs list for a specified device.  Returns a pointer to it
3735  * or NULL if no suitable entry is found. The caller of this routine
3736  * is responsible for releasing the returned vfs pointer.
3737  */
3738 struct vfs *
3739 vfs_dev2vfsp(dev_t dev)
3740 {
3741         struct vfs *vfsp;
3742         int found;
3743 
3744         vfs_list_read_lock();
3745         vfsp = rootvfs;
3746         found = 0;
3747         do {
3748                 /*
3749                  * The following could be made more efficient by making
3750                  * the entire loop use vfs_zone_next if the call is from
3751                  * a zone.  The only callers, however, ustat(2) and
3752                  * umount2(2), don't seem to justify the added
3753                  * complexity at present.
3754                  */
3755                 if (vfsp->vfs_dev == dev &&
3756                     ZONE_PATH_VISIBLE(refstr_value(vfsp->vfs_mntpt),
3757                     curproc->p_zone)) {
3758                         VFS_HOLD(vfsp);
3759                         found = 1;
3760                         break;
3761                 }
3762                 vfsp = vfsp->vfs_next;
3763         } while (vfsp != rootvfs);
3764         vfs_list_unlock();
3765         return (found ? vfsp: NULL);
3766 }
3767 
3768 /*
3769  * Search the vfs list for a specified mntpoint.  Returns a pointer to it
3770  * or NULL if no suitable entry is found. The caller of this routine
3771  * is responsible for releasing the returned vfs pointer.
3772  *
3773  * Note that if multiple mntpoints match, the last one matching is
3774  * returned in an attempt to return the "top" mount when overlay
3775  * mounts are covering the same mount point.  This is accomplished by starting
3776  * at the end of the list and working our way backwards, stopping at the first
3777  * matching mount.
3778  */
3779 struct vfs *
3780 vfs_mntpoint2vfsp(const char *mp)
3781 {
3782         struct vfs *vfsp;
3783         struct vfs *retvfsp = NULL;
3784         zone_t *zone = curproc->p_zone;
3785         struct vfs *list;
3786 
3787         vfs_list_read_lock();
3788         if (getzoneid() == GLOBAL_ZONEID) {
3789                 /*
3790                  * The global zone may see filesystems in any zone.
3791                  */
3792                 vfsp = rootvfs->vfs_prev;
3793                 do {
3794                         if (strcmp(refstr_value(vfsp->vfs_mntpt), mp) == 0) {
3795                                 retvfsp = vfsp;
3796                                 break;
3797                         }
3798                         vfsp = vfsp->vfs_prev;
3799                 } while (vfsp != rootvfs->vfs_prev);
3800         } else if ((list = zone->zone_vfslist) != NULL) {
3801                 const char *mntpt;
3802 
3803                 vfsp = list->vfs_zone_prev;
3804                 do {
3805                         mntpt = refstr_value(vfsp->vfs_mntpt);
3806                         mntpt = ZONE_PATH_TRANSLATE(mntpt, zone);
3807                         if (strcmp(mntpt, mp) == 0) {
3808                                 retvfsp = vfsp;
3809                                 break;
3810                         }
3811                         vfsp = vfsp->vfs_zone_prev;
3812                 } while (vfsp != list->vfs_zone_prev);
3813         }
3814         if (retvfsp)
3815                 VFS_HOLD(retvfsp);
3816         vfs_list_unlock();
3817         return (retvfsp);
3818 }
3819 
3820 /*
3821  * Search the vfs list for a specified vfsops.
3822  * if vfs entry is found then return 1, else 0.
3823  */
3824 int
3825 vfs_opsinuse(vfsops_t *ops)
3826 {
3827         struct vfs *vfsp;
3828         int found;
3829 
3830         vfs_list_read_lock();
3831         vfsp = rootvfs;
3832         found = 0;
3833         do {
3834                 if (vfs_getops(vfsp) == ops) {
3835                         found = 1;
3836                         break;
3837                 }
3838                 vfsp = vfsp->vfs_next;
3839         } while (vfsp != rootvfs);
3840         vfs_list_unlock();
3841         return (found);
3842 }
3843 
3844 /*
3845  * Allocate an entry in vfssw for a file system type
3846  */
3847 struct vfssw *
3848 allocate_vfssw(const char *type)
3849 {
3850         struct vfssw *vswp;
3851 
3852         if (type[0] == '\0' || strlen(type) + 1 > _ST_FSTYPSZ) {
3853                 /*
3854                  * The vfssw table uses the empty string to identify an
3855                  * available entry; we cannot add any type which has
3856                  * a leading NUL. The string length is limited to
3857                  * the size of the st_fstype array in struct stat.
3858                  */
3859                 return (NULL);
3860         }
3861 
3862         ASSERT(VFSSW_WRITE_LOCKED());
3863         for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++)
3864                 if (!ALLOCATED_VFSSW(vswp)) {
3865                         vswp->vsw_name = kmem_alloc(strlen(type) + 1, KM_SLEEP);
3866                         (void) strcpy(vswp->vsw_name, type);
3867                         ASSERT(vswp->vsw_count == 0);
3868                         vswp->vsw_count = 1;
3869                         mutex_init(&vswp->vsw_lock, NULL, MUTEX_DEFAULT, NULL);
3870                         return (vswp);
3871                 }
3872         return (NULL);
3873 }
3874 
3875 /*
3876  * Impose additional layer of translation between vfstype names
3877  * and module names in the filesystem.
3878  */
3879 static const char *
3880 vfs_to_modname(const char *vfstype)
3881 {
3882         if (strcmp(vfstype, "proc") == 0) {
3883                 vfstype = "procfs";
3884         } else if (strcmp(vfstype, "fd") == 0) {
3885                 vfstype = "fdfs";
3886         } else if (strncmp(vfstype, "nfs", 3) == 0) {
3887                 vfstype = "nfs";
3888         }
3889 
3890         return (vfstype);
3891 }
3892 
3893 /*
3894  * Find a vfssw entry given a file system type name.
3895  * Try to autoload the filesystem if it's not found.
3896  * If it's installed, return the vfssw locked to prevent unloading.
3897  */
3898 struct vfssw *
3899 vfs_getvfssw(const char *type)
3900 {
3901         struct vfssw *vswp;
3902         const char *modname;
3903 
3904         RLOCK_VFSSW();
3905         vswp = vfs_getvfsswbyname(type);
3906         modname = vfs_to_modname(type);
3907 
3908         if (rootdir == NULL) {
3909                 /*
3910                  * If we haven't yet loaded the root file system, then our
3911                  * _init won't be called until later. Allocate vfssw entry,
3912                  * because mod_installfs won't be called.
3913                  */
3914                 if (vswp == NULL) {
3915                         RUNLOCK_VFSSW();
3916                         WLOCK_VFSSW();
3917                         if ((vswp = vfs_getvfsswbyname(type)) == NULL) {
3918                                 if ((vswp = allocate_vfssw(type)) == NULL) {
3919                                         WUNLOCK_VFSSW();
3920                                         return (NULL);
3921                                 }
3922                         }
3923                         WUNLOCK_VFSSW();
3924                         RLOCK_VFSSW();
3925                 }
3926                 if (!VFS_INSTALLED(vswp)) {
3927                         RUNLOCK_VFSSW();
3928                         (void) modloadonly("fs", modname);
3929                 } else
3930                         RUNLOCK_VFSSW();
3931                 return (vswp);
3932         }
3933 
3934         /*
3935          * Try to load the filesystem.  Before calling modload(), we drop
3936          * our lock on the VFS switch table, and pick it up after the
3937          * module is loaded.  However, there is a potential race:  the
3938          * module could be unloaded after the call to modload() completes
3939          * but before we pick up the lock and drive on.  Therefore,
3940          * we keep reloading the module until we've loaded the module
3941          * _and_ we have the lock on the VFS switch table.
3942          */
3943         while (vswp == NULL || !VFS_INSTALLED(vswp)) {
3944                 RUNLOCK_VFSSW();
3945                 if (modload("fs", modname) == -1)
3946                         return (NULL);
3947                 RLOCK_VFSSW();
3948                 if (vswp == NULL)
3949                         if ((vswp = vfs_getvfsswbyname(type)) == NULL)
3950                                 break;
3951         }
3952         RUNLOCK_VFSSW();
3953 
3954         return (vswp);
3955 }
3956 
3957 /*
3958  * Find a vfssw entry given a file system type name.
3959  */
3960 struct vfssw *
3961 vfs_getvfsswbyname(const char *type)
3962 {
3963         struct vfssw *vswp;
3964 
3965         ASSERT(VFSSW_LOCKED());
3966         if (type == NULL || *type == '\0')
3967                 return (NULL);
3968 
3969         for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
3970                 if (strcmp(type, vswp->vsw_name) == 0) {
3971                         vfs_refvfssw(vswp);
3972                         return (vswp);
3973                 }
3974         }
3975 
3976         return (NULL);
3977 }
3978 
3979 /*
3980  * Find a vfssw entry given a set of vfsops.
3981  */
3982 struct vfssw *
3983 vfs_getvfsswbyvfsops(vfsops_t *vfsops)
3984 {
3985         struct vfssw *vswp;
3986 
3987         RLOCK_VFSSW();
3988         for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
3989                 if (ALLOCATED_VFSSW(vswp) && &vswp->vsw_vfsops == vfsops) {
3990                         vfs_refvfssw(vswp);
3991                         RUNLOCK_VFSSW();
3992                         return (vswp);
3993                 }
3994         }
3995         RUNLOCK_VFSSW();
3996 
3997         return (NULL);
3998 }
3999 
4000 /*
4001  * Reference a vfssw entry.
4002  */
4003 void
4004 vfs_refvfssw(struct vfssw *vswp)
4005 {
4006 
4007         mutex_enter(&vswp->vsw_lock);
4008         vswp->vsw_count++;
4009         mutex_exit(&vswp->vsw_lock);
4010 }
4011 
4012 /*
4013  * Unreference a vfssw entry.
4014  */
4015 void
4016 vfs_unrefvfssw(struct vfssw *vswp)
4017 {
4018 
4019         mutex_enter(&vswp->vsw_lock);
4020         vswp->vsw_count--;
4021         mutex_exit(&vswp->vsw_lock);
4022 }
4023 
4024 int sync_timeout = 30;          /* timeout for syncing a page during panic */
4025 int sync_timeleft;              /* portion of sync_timeout remaining */
4026 
4027 static int sync_retries = 20;   /* number of retries when not making progress */
4028 static int sync_triesleft;      /* portion of sync_retries remaining */
4029 
4030 static pgcnt_t old_pgcnt, new_pgcnt;
4031 static int new_bufcnt, old_bufcnt;
4032 
4033 /*
4034  * Sync all of the mounted filesystems, and then wait for the actual i/o to
4035  * complete.  We wait by counting the number of dirty pages and buffers,
4036  * pushing them out using bio_busy() and page_busy(), and then counting again.
4037  * This routine is used during both the uadmin A_SHUTDOWN code as well as
4038  * the SYNC phase of the panic code (see comments in panic.c).  It should only
4039  * be used after some higher-level mechanism has quiesced the system so that
4040  * new writes are not being initiated while we are waiting for completion.
4041  *
4042  * To ensure finite running time, our algorithm uses two timeout mechanisms:
4043  * sync_timeleft (a timer implemented by the omnipresent deadman() cyclic), and
4044  * sync_triesleft (a progress counter used by the vfs_syncall() loop below).
4045  * Together these ensure that syncing completes if our i/o paths are stuck.
4046  * The counters are declared above so they can be found easily in the debugger.
4047  *
4048  * The sync_timeleft counter is reset by bio_busy() and page_busy() using the
4049  * vfs_syncprogress() subroutine whenever we make progress through the lists of
4050  * pages and buffers.  It is decremented and expired by the deadman() cyclic.
4051  * When vfs_syncall() decides it is done, we disable the deadman() counter by
4052  * setting sync_timeleft to zero.  This timer guards against vfs_syncall()
4053  * deadlocking or hanging inside of a broken filesystem or driver routine.
4054  *
4055  * The sync_triesleft counter is updated by vfs_syncall() itself.  If we make
4056  * sync_retries consecutive calls to bio_busy() and page_busy() without
4057  * decreasing either the number of dirty buffers or dirty pages below the
4058  * lowest count we have seen so far, we give up and return from vfs_syncall().
4059  *
4060  * Each loop iteration ends with a call to delay() one second to allow time for
4061  * i/o completion and to permit the user time to read our progress messages.
4062  */
4063 void
4064 vfs_syncall(void)
4065 {
4066         if (rootdir == NULL && !modrootloaded)
4067                 return; /* panic during boot - no filesystems yet */
4068 
4069         printf("syncing file systems...");
4070         vfs_syncprogress();
4071         sync();
4072 
4073         vfs_syncprogress();
4074         sync_triesleft = sync_retries;
4075 
4076         old_bufcnt = new_bufcnt = INT_MAX;
4077         old_pgcnt = new_pgcnt = ULONG_MAX;
4078 
4079         while (sync_triesleft > 0) {
4080                 old_bufcnt = MIN(old_bufcnt, new_bufcnt);
4081                 old_pgcnt = MIN(old_pgcnt, new_pgcnt);
4082 
4083                 new_bufcnt = bio_busy(B_TRUE);
4084                 new_pgcnt = page_busy(B_TRUE);
4085                 vfs_syncprogress();
4086 
4087                 if (new_bufcnt == 0 && new_pgcnt == 0)
4088                         break;
4089 
4090                 if (new_bufcnt < old_bufcnt || new_pgcnt < old_pgcnt)
4091                         sync_triesleft = sync_retries;
4092                 else
4093                         sync_triesleft--;
4094 
4095                 if (new_bufcnt)
4096                         printf(" [%d]", new_bufcnt);
4097                 if (new_pgcnt)
4098                         printf(" %lu", new_pgcnt);
4099 
4100                 delay(hz);
4101         }
4102 
4103         if (new_bufcnt != 0 || new_pgcnt != 0)
4104                 printf(" done (not all i/o completed)\n");
4105         else
4106                 printf(" done\n");
4107 
4108         sync_timeleft = 0;
4109         delay(hz);
4110 }
4111 
4112 /*
4113  * If we are in the middle of the sync phase of panic, reset sync_timeleft to
4114  * sync_timeout to indicate that we are making progress and the deadman()
4115  * omnipresent cyclic should not yet time us out.  Note that it is safe to
4116  * store to sync_timeleft here since the deadman() is firing at high-level
4117  * on top of us.  If we are racing with the deadman(), either the deadman()
4118  * will decrement the old value and then we will reset it, or we will
4119  * reset it and then the deadman() will immediately decrement it.  In either
4120  * case, correct behavior results.
4121  */
4122 void
4123 vfs_syncprogress(void)
4124 {
4125         if (panicstr)
4126                 sync_timeleft = sync_timeout;
4127 }
4128 
4129 /*
4130  * Map VFS flags to statvfs flags.  These shouldn't really be separate
4131  * flags at all.
4132  */
4133 uint_t
4134 vf_to_stf(uint_t vf)
4135 {
4136         uint_t stf = 0;
4137 
4138         if (vf & VFS_RDONLY)
4139                 stf |= ST_RDONLY;
4140         if (vf & VFS_NOSETUID)
4141                 stf |= ST_NOSUID;
4142         if (vf & VFS_NOTRUNC)
4143                 stf |= ST_NOTRUNC;
4144 
4145         return (stf);
4146 }
4147 
4148 /*
4149  * Entries for (illegal) fstype 0.
4150  */
4151 /* ARGSUSED */
4152 int
4153 vfsstray_sync(struct vfs *vfsp, short arg, struct cred *cr)
4154 {
4155         cmn_err(CE_PANIC, "stray vfs operation");
4156         return (0);
4157 }
4158 
4159 /*
4160  * Entries for (illegal) fstype 0.
4161  */
4162 int
4163 vfsstray(void)
4164 {
4165         cmn_err(CE_PANIC, "stray vfs operation");
4166         return (0);
4167 }
4168 
4169 /*
4170  * Support for dealing with forced UFS unmount and its interaction with
4171  * LOFS. Could be used by any filesystem.
4172  * See bug 1203132.
4173  */
4174 int
4175 vfs_EIO(void)
4176 {
4177         return (EIO);
4178 }
4179 
4180 /*
4181  * We've gotta define the op for sync separately, since the compiler gets
4182  * confused if we mix and match ANSI and normal style prototypes when
4183  * a "short" argument is present and spits out a warning.
4184  */
4185 /*ARGSUSED*/
4186 int
4187 vfs_EIO_sync(struct vfs *vfsp, short arg, struct cred *cr)
4188 {
4189         return (EIO);
4190 }
4191 
4192 vfs_t EIO_vfs;
4193 vfsops_t *EIO_vfsops;
4194 
4195 /*
4196  * Called from startup() to initialize all loaded vfs's
4197  */
4198 void
4199 vfsinit(void)
4200 {
4201         struct vfssw *vswp;
4202         int error;
4203         extern int vopstats_enabled;
4204         extern void vopstats_startup();
4205 
4206         static const fs_operation_def_t EIO_vfsops_template[] = {
4207                 VFSNAME_MOUNT,          { .error = vfs_EIO },
4208                 VFSNAME_UNMOUNT,        { .error = vfs_EIO },
4209                 VFSNAME_ROOT,           { .error = vfs_EIO },
4210                 VFSNAME_STATVFS,        { .error = vfs_EIO },
4211                 VFSNAME_SYNC,           { .vfs_sync = vfs_EIO_sync },
4212                 VFSNAME_VGET,           { .error = vfs_EIO },
4213                 VFSNAME_MOUNTROOT,      { .error = vfs_EIO },
4214                 VFSNAME_FREEVFS,        { .error = vfs_EIO },
4215                 VFSNAME_VNSTATE,        { .error = vfs_EIO },
4216                 NULL, NULL
4217         };
4218 
4219         static const fs_operation_def_t stray_vfsops_template[] = {
4220                 VFSNAME_MOUNT,          { .error = vfsstray },
4221                 VFSNAME_UNMOUNT,        { .error = vfsstray },
4222                 VFSNAME_ROOT,           { .error = vfsstray },
4223                 VFSNAME_STATVFS,        { .error = vfsstray },
4224                 VFSNAME_SYNC,           { .vfs_sync = vfsstray_sync },
4225                 VFSNAME_VGET,           { .error = vfsstray },
4226                 VFSNAME_MOUNTROOT,      { .error = vfsstray },
4227                 VFSNAME_FREEVFS,        { .error = vfsstray },
4228                 VFSNAME_VNSTATE,        { .error = vfsstray },
4229                 NULL, NULL
4230         };
4231 
4232         /* Create vfs cache */
4233         vfs_cache = kmem_cache_create("vfs_cache", sizeof (struct vfs),
4234             sizeof (uintptr_t), NULL, NULL, NULL, NULL, NULL, 0);
4235 
4236         /* Initialize the vnode cache (file systems may use it during init). */
4237         vn_create_cache();
4238 
4239         /* Setup event monitor framework */
4240         fem_init();
4241 
4242         /* Initialize the dummy stray file system type. */
4243         error = vfs_setfsops(0, stray_vfsops_template, NULL);
4244 
4245         /* Initialize the dummy EIO file system. */
4246         error = vfs_makefsops(EIO_vfsops_template, &EIO_vfsops);
4247         if (error != 0) {
4248                 cmn_err(CE_WARN, "vfsinit: bad EIO vfs ops template");
4249                 /* Shouldn't happen, but not bad enough to panic */
4250         }
4251 
4252         VFS_INIT(&EIO_vfs, EIO_vfsops, (caddr_t)NULL);
4253 
4254         /*
4255          * Default EIO_vfs.vfs_flag to VFS_UNMOUNTED so a lookup
4256          * on this vfs can immediately notice it's invalid.
4257          */
4258         EIO_vfs.vfs_flag |= VFS_UNMOUNTED;
4259 
4260         /*
4261          * Call the init routines of non-loadable filesystems only.
4262          * Filesystems which are loaded as separate modules will be
4263          * initialized by the module loading code instead.
4264          */
4265 
4266         for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
4267                 RLOCK_VFSSW();
4268                 if (vswp->vsw_init != NULL)
4269                         (*vswp->vsw_init)(vswp - vfssw, vswp->vsw_name);
4270                 RUNLOCK_VFSSW();
4271         }
4272 
4273         vopstats_startup();
4274 
4275         if (vopstats_enabled) {
4276                 /* EIO_vfs can collect stats, but we don't retrieve them */
4277                 initialize_vopstats(&EIO_vfs.vfs_vopstats);
4278                 EIO_vfs.vfs_fstypevsp = NULL;
4279                 EIO_vfs.vfs_vskap = NULL;
4280                 EIO_vfs.vfs_flag |= VFS_STATS;
4281         }
4282 
4283         xattr_init();
4284 
4285         reparse_point_init();
4286 }
4287 
4288 vfs_t *
4289 vfs_alloc(int kmflag)
4290 {
4291         vfs_t *vfsp;
4292 
4293         vfsp = kmem_cache_alloc(vfs_cache, kmflag);
4294 
4295         /*
4296          * Do the simplest initialization here.
4297          * Everything else gets done in vfs_init()
4298          */
4299         bzero(vfsp, sizeof (vfs_t));
4300         return (vfsp);
4301 }
4302 
4303 void
4304 vfs_free(vfs_t *vfsp)
4305 {
4306         /*
4307          * One would be tempted to assert that "vfsp->vfs_count == 0".
4308          * The problem is that this gets called out of domount() with
4309          * a partially initialized vfs and a vfs_count of 1.  This is
4310          * also called from vfs_rele() with a vfs_count of 0.  We can't
4311          * call VFS_RELE() from domount() if VFS_MOUNT() hasn't successfully
4312          * returned.  This is because VFS_MOUNT() fully initializes the
4313          * vfs structure and its associated data.  VFS_RELE() will call
4314          * VFS_FREEVFS() which may panic the system if the data structures
4315          * aren't fully initialized from a successful VFS_MOUNT()).
4316          */
4317 
4318         /* If FEM was in use, make sure everything gets cleaned up */
4319         if (vfsp->vfs_femhead) {
4320                 ASSERT(vfsp->vfs_femhead->femh_list == NULL);
4321                 mutex_destroy(&vfsp->vfs_femhead->femh_lock);
4322                 kmem_free(vfsp->vfs_femhead, sizeof (*(vfsp->vfs_femhead)));
4323                 vfsp->vfs_femhead = NULL;
4324         }
4325 
4326         /* FSH cleanup */
4327         fsh_fsrec_destroy(vfsp->vfs_fshrecord);
4328         vfsp->vfs_fshrecord = NULL;
4329 
4330         if (vfsp->vfs_implp)
4331                 vfsimpl_teardown(vfsp);
4332         sema_destroy(&vfsp->vfs_reflock);
4333         kmem_cache_free(vfs_cache, vfsp);
4334 }
4335 
4336 /*
4337  * Increments the vfs reference count by one atomically.
4338  */
4339 void
4340 vfs_hold(vfs_t *vfsp)
4341 {
4342         atomic_add_32(&vfsp->vfs_count, 1);
4343         ASSERT(vfsp->vfs_count != 0);
4344 }
4345 
4346 /*
4347  * Decrements the vfs reference count by one atomically. When
4348  * vfs reference count becomes zero, it calls the file system
4349  * specific vfs_freevfs() to free up the resources.
4350  */
4351 void
4352 vfs_rele(vfs_t *vfsp)
4353 {
4354         ASSERT(vfsp->vfs_count != 0);
4355         if (atomic_add_32_nv(&vfsp->vfs_count, -1) == 0) {
4356                 fsh_exec_destroy_callbacks(vfsp);
4357                 VFS_FREEVFS(vfsp);
4358                 lofi_remove(vfsp);
4359                 if (vfsp->vfs_zone)
4360                         zone_rele_ref(&vfsp->vfs_implp->vi_zone_ref,
4361                             ZONE_REF_VFS);
4362                 vfs_freemnttab(vfsp);
4363                 vfs_free(vfsp);
4364         }
4365 }
4366 
4367 /*
4368  * Generic operations vector support.
4369  *
4370  * This is used to build operations vectors for both the vfs and vnode.
4371  * It's normally called only when a file system is loaded.
4372  *
4373  * There are many possible algorithms for this, including the following:
4374  *
4375  *   (1) scan the list of known operations; for each, see if the file system
4376  *       includes an entry for it, and fill it in as appropriate.
4377  *
4378  *   (2) set up defaults for all known operations.  scan the list of ops
4379  *       supplied by the file system; for each which is both supplied and
4380  *       known, fill it in.
4381  *
4382  *   (3) sort the lists of known ops & supplied ops; scan the list, filling
4383  *       in entries as we go.
4384  *
4385  * we choose (1) for simplicity, and because performance isn't critical here.
4386  * note that (2) could be sped up using a precomputed hash table on known ops.
4387  * (3) could be faster than either, but only if the lists were very large or
4388  * supplied in sorted order.
4389  *
4390  */
4391 
4392 int
4393 fs_build_vector(void *vector, int *unused_ops,
4394     const fs_operation_trans_def_t *translation,
4395     const fs_operation_def_t *operations)
4396 {
4397         int i, num_trans, num_ops, used;
4398 
4399         /*
4400          * Count the number of translations and the number of supplied
4401          * operations.
4402          */
4403 
4404         {
4405                 const fs_operation_trans_def_t *p;
4406 
4407                 for (num_trans = 0, p = translation;
4408                     p->name != NULL;
4409                     num_trans++, p++)
4410                         ;
4411         }
4412 
4413         {
4414                 const fs_operation_def_t *p;
4415 
4416                 for (num_ops = 0, p = operations;
4417                     p->name != NULL;
4418                     num_ops++, p++)
4419                         ;
4420         }
4421 
4422         /* Walk through each operation known to our caller.  There will be */
4423         /* one entry in the supplied "translation table" for each. */
4424 
4425         used = 0;
4426 
4427         for (i = 0; i < num_trans; i++) {
4428                 int j, found;
4429                 char *curname;
4430                 fs_generic_func_p result;
4431                 fs_generic_func_p *location;
4432 
4433                 curname = translation[i].name;
4434 
4435                 /* Look for a matching operation in the list supplied by the */
4436                 /* file system. */
4437 
4438                 found = 0;
4439 
4440                 for (j = 0; j < num_ops; j++) {
4441                         if (strcmp(operations[j].name, curname) == 0) {
4442                                 used++;
4443                                 found = 1;
4444                                 break;
4445                         }
4446                 }
4447 
4448                 /*
4449                  * If the file system is using a "placeholder" for default
4450                  * or error functions, grab the appropriate function out of
4451                  * the translation table.  If the file system didn't supply
4452                  * this operation at all, use the default function.
4453                  */
4454 
4455                 if (found) {
4456                         result = operations[j].func.fs_generic;
4457                         if (result == fs_default) {
4458                                 result = translation[i].defaultFunc;
4459                         } else if (result == fs_error) {
4460                                 result = translation[i].errorFunc;
4461                         } else if (result == NULL) {
4462                                 /* Null values are PROHIBITED */
4463                                 return (EINVAL);
4464                         }
4465                 } else {
4466                         result = translation[i].defaultFunc;
4467                 }
4468 
4469                 /* Now store the function into the operations vector. */
4470 
4471                 location = (fs_generic_func_p *)
4472                     (((char *)vector) + translation[i].offset);
4473 
4474                 *location = result;
4475         }
4476 
4477         *unused_ops = num_ops - used;
4478 
4479         return (0);
4480 }
4481 
4482 /* Placeholder functions, should never be called. */
4483 
4484 int
4485 fs_error(void)
4486 {
4487         cmn_err(CE_PANIC, "fs_error called");
4488         return (0);
4489 }
4490 
4491 int
4492 fs_default(void)
4493 {
4494         cmn_err(CE_PANIC, "fs_default called");
4495         return (0);
4496 }
4497 
4498 #ifdef __sparc
4499 
4500 /*
4501  * Part of the implementation of booting off a mirrored root
4502  * involves a change of dev_t for the root device.  To
4503  * accomplish this, first remove the existing hash table
4504  * entry for the root device, convert to the new dev_t,
4505  * then re-insert in the hash table at the head of the list.
4506  */
4507 void
4508 vfs_root_redev(vfs_t *vfsp, dev_t ndev, int fstype)
4509 {
4510         vfs_list_lock();
4511 
4512         vfs_hash_remove(vfsp);
4513 
4514         vfsp->vfs_dev = ndev;
4515         vfs_make_fsid(&vfsp->vfs_fsid, ndev, fstype);
4516 
4517         vfs_hash_add(vfsp, 1);
4518 
4519         vfs_list_unlock();
4520 }
4521 
4522 #else /* x86 NEWBOOT */
4523 
4524 #if defined(__x86)
4525 extern int hvmboot_rootconf();
4526 #endif /* __x86 */
4527 
4528 extern ib_boot_prop_t *iscsiboot_prop;
4529 
4530 int
4531 rootconf()
4532 {
4533         int error;
4534         struct vfssw *vsw;
4535         extern void pm_init();
4536         char *fstyp, *fsmod;
4537         int ret = -1;
4538 
4539         getrootfs(&fstyp, &fsmod);
4540 
4541 #if defined(__x86)
4542         /*
4543          * hvmboot_rootconf() is defined in the hvm_bootstrap misc module,
4544          * which lives in /platform/i86hvm, and hence is only available when
4545          * booted in an x86 hvm environment.  If the hvm_bootstrap misc module
4546          * is not available then the modstub for this function will return 0.
4547          * If the hvm_bootstrap misc module is available it will be loaded
4548          * and hvmboot_rootconf() will be invoked.
4549          */
4550         if (error = hvmboot_rootconf())
4551                 return (error);
4552 #endif /* __x86 */
4553 
4554         if (error = clboot_rootconf())
4555                 return (error);
4556 
4557         if (modload("fs", fsmod) == -1)
4558                 panic("Cannot _init %s module", fsmod);
4559 
4560         RLOCK_VFSSW();
4561         vsw = vfs_getvfsswbyname(fstyp);
4562         RUNLOCK_VFSSW();
4563         if (vsw == NULL) {
4564                 cmn_err(CE_CONT, "Cannot find %s filesystem\n", fstyp);
4565                 return (ENXIO);
4566         }
4567         VFS_INIT(rootvfs, &vsw->vsw_vfsops, 0);
4568         VFS_HOLD(rootvfs);
4569 
4570         /* always mount readonly first */
4571         rootvfs->vfs_flag |= VFS_RDONLY;
4572 
4573         pm_init();
4574 
4575         if (netboot && iscsiboot_prop) {
4576                 cmn_err(CE_WARN, "NFS boot and iSCSI boot"
4577                     " shouldn't happen in the same time");
4578                 return (EINVAL);
4579         }
4580 
4581         if (netboot || iscsiboot_prop) {
4582                 ret = strplumb();
4583                 if (ret != 0) {
4584                         cmn_err(CE_WARN, "Cannot plumb network device %d", ret);
4585                         return (EFAULT);
4586                 }
4587         }
4588 
4589         if ((ret == 0) && iscsiboot_prop) {
4590                 ret = modload("drv", "iscsi");
4591                 /* -1 indicates fail */
4592                 if (ret == -1) {
4593                         cmn_err(CE_WARN, "Failed to load iscsi module");
4594                         iscsi_boot_prop_free();
4595                         return (EINVAL);
4596                 } else {
4597                         if (!i_ddi_attach_pseudo_node("iscsi")) {
4598                                 cmn_err(CE_WARN,
4599                                     "Failed to attach iscsi driver");
4600                                 iscsi_boot_prop_free();
4601                                 return (ENODEV);
4602                         }
4603                 }
4604         }
4605 
4606         error = VFS_MOUNTROOT(rootvfs, ROOT_INIT);
4607         vfs_unrefvfssw(vsw);
4608         rootdev = rootvfs->vfs_dev;
4609 
4610         if (error)
4611                 cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n",
4612                     rootfs.bo_name, fstyp);
4613         else
4614                 cmn_err(CE_CONT, "?root on %s fstype %s\n",
4615                     rootfs.bo_name, fstyp);
4616         return (error);
4617 }
4618 
4619 /*
4620  * XXX this is called by nfs only and should probably be removed
4621  * If booted with ASKNAME, prompt on the console for a filesystem
4622  * name and return it.
4623  */
4624 void
4625 getfsname(char *askfor, char *name, size_t namelen)
4626 {
4627         if (boothowto & RB_ASKNAME) {
4628                 printf("%s name: ", askfor);
4629                 console_gets(name, namelen);
4630         }
4631 }
4632 
4633 /*
4634  * Init the root filesystem type (rootfs.bo_fstype) from the "fstype"
4635  * property.
4636  *
4637  * Filesystem types starting with the prefix "nfs" are diskless clients;
4638  * init the root filename name (rootfs.bo_name), too.
4639  *
4640  * If we are booting via NFS we currently have these options:
4641  *      nfs -   dynamically choose NFS V2, V3, or V4 (default)
4642  *      nfs2 -  force NFS V2
4643  *      nfs3 -  force NFS V3
4644  *      nfs4 -  force NFS V4
4645  * Because we need to maintain backward compatibility with the naming
4646  * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c)
4647  * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs".  The dynamic
4648  * nfs module will map the type back to either "nfs", "nfs3", or "nfs4".
4649  * This is only for root filesystems, all other uses such as cachefs
4650  * will expect that "nfs" == NFS V2.
4651  */
4652 static void
4653 getrootfs(char **fstypp, char **fsmodp)
4654 {
4655         extern char *strplumb_get_netdev_path(void);
4656         char *propstr = NULL;
4657 
4658         /*
4659          * Check fstype property; for diskless it should be one of "nfs",
4660          * "nfs2", "nfs3" or "nfs4".
4661          */
4662         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4663             DDI_PROP_DONTPASS, "fstype", &propstr)
4664             == DDI_SUCCESS) {
4665                 (void) strncpy(rootfs.bo_fstype, propstr, BO_MAXFSNAME);
4666                 ddi_prop_free(propstr);
4667 
4668         /*
4669          * if the boot property 'fstype' is not set, but 'zfs-bootfs' is set,
4670          * assume the type of this root filesystem is 'zfs'.
4671          */
4672         } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4673             DDI_PROP_DONTPASS, "zfs-bootfs", &propstr)
4674             == DDI_SUCCESS) {
4675                 (void) strncpy(rootfs.bo_fstype, "zfs", BO_MAXFSNAME);
4676                 ddi_prop_free(propstr);
4677         }
4678 
4679         if (strncmp(rootfs.bo_fstype, "nfs", 3) != 0) {
4680                 *fstypp = *fsmodp = rootfs.bo_fstype;
4681                 return;
4682         }
4683 
4684         ++netboot;
4685 
4686         if (strcmp(rootfs.bo_fstype, "nfs2") == 0)
4687                 (void) strcpy(rootfs.bo_fstype, "nfs");
4688         else if (strcmp(rootfs.bo_fstype, "nfs") == 0)
4689                 (void) strcpy(rootfs.bo_fstype, "nfsdyn");
4690 
4691         /*
4692          * check if path to network interface is specified in bootpath
4693          * or by a hypervisor domain configuration file.
4694          * XXPV - enable strlumb_get_netdev_path()
4695          */
4696         if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS,
4697             "xpv-nfsroot")) {
4698                 (void) strcpy(rootfs.bo_name, "/xpvd/xnf@0");
4699         } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4700             DDI_PROP_DONTPASS, "bootpath", &propstr)
4701             == DDI_SUCCESS) {
4702                 (void) strncpy(rootfs.bo_name, propstr, BO_MAXOBJNAME);
4703                 ddi_prop_free(propstr);
4704         } else {
4705                 /* attempt to determine netdev_path via boot_mac address */
4706                 netdev_path = strplumb_get_netdev_path();
4707                 if (netdev_path == NULL)
4708                         panic("cannot find boot network interface");
4709                 (void) strncpy(rootfs.bo_name, netdev_path, BO_MAXOBJNAME);
4710         }
4711         *fstypp = rootfs.bo_fstype;
4712         *fsmodp = "nfs";
4713 }
4714 #endif
4715 
4716 /*
4717  * VFS feature routines
4718  */
4719 
4720 #define VFTINDEX(feature)       (((feature) >> 32) & 0xFFFFFFFF)
4721 #define VFTBITS(feature)        ((feature) & 0xFFFFFFFFLL)
4722 
4723 /* Register a feature in the vfs */
4724 void
4725 vfs_set_feature(vfs_t *vfsp, vfs_feature_t feature)
4726 {
4727         /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4728         if (vfsp->vfs_implp == NULL)
4729                 return;
4730 
4731         vfsp->vfs_featureset[VFTINDEX(feature)] |= VFTBITS(feature);
4732 }
4733 
4734 void
4735 vfs_clear_feature(vfs_t *vfsp, vfs_feature_t feature)
4736 {
4737         /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4738         if (vfsp->vfs_implp == NULL)
4739                 return;
4740         vfsp->vfs_featureset[VFTINDEX(feature)] &= VFTBITS(~feature);
4741 }
4742 
4743 /*
4744  * Query a vfs for a feature.
4745  * Returns 1 if feature is present, 0 if not
4746  */
4747 int
4748 vfs_has_feature(vfs_t *vfsp, vfs_feature_t feature)
4749 {
4750         int     ret = 0;
4751 
4752         /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4753         if (vfsp->vfs_implp == NULL)
4754                 return (ret);
4755 
4756         if (vfsp->vfs_featureset[VFTINDEX(feature)] & VFTBITS(feature))
4757                 ret = 1;
4758 
4759         return (ret);
4760 }
4761 
4762 /*
4763  * Propagate feature set from one vfs to another
4764  */
4765 void
4766 vfs_propagate_features(vfs_t *from, vfs_t *to)
4767 {
4768         int i;
4769 
4770         if (to->vfs_implp == NULL || from->vfs_implp == NULL)
4771                 return;
4772 
4773         for (i = 1; i <= to->vfs_featureset[0]; i++) {
4774                 to->vfs_featureset[i] = from->vfs_featureset[i];
4775         }
4776 }
4777 
4778 #define LOFINODE_PATH "/dev/lofi/%d"
4779 
4780 /*
4781  * Return the vnode for the lofi node if there's a lofi mount in place.
4782  * Returns -1 when there's no lofi node, 0 on success, and > 0 on
4783  * failure.
4784  */
4785 int
4786 vfs_get_lofi(vfs_t *vfsp, vnode_t **vpp)
4787 {
4788         char *path = NULL;
4789         int strsize;
4790         int err;
4791 
4792         if (vfsp->vfs_lofi_minor == 0) {
4793                 *vpp = NULL;
4794                 return (-1);
4795         }
4796 
4797         strsize = snprintf(NULL, 0, LOFINODE_PATH, vfsp->vfs_lofi_minor);
4798         path = kmem_alloc(strsize + 1, KM_SLEEP);
4799         (void) snprintf(path, strsize + 1, LOFINODE_PATH, vfsp->vfs_lofi_minor);
4800 
4801         /*
4802          * We may be inside a zone, so we need to use the /dev path, but
4803          * it's created asynchronously, so we wait here.
4804          */
4805         for (;;) {
4806                 err = lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, vpp);
4807 
4808                 if (err != ENOENT)
4809                         break;
4810 
4811                 if ((err = delay_sig(hz / 8)) == EINTR)
4812                         break;
4813         }
4814 
4815         if (err)
4816                 *vpp = NULL;
4817 
4818         kmem_free(path, strsize + 1);
4819         return (err);
4820 }