17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 55a59a8b3Srsb * Common Development and Distribution License (the "License"). 65a59a8b3Srsb * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*0fbb751dSJohn Levon * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 237c478bd9Sstevel@tonic-gate */ 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 267c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate /* 297c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988 307c478bd9Sstevel@tonic-gate * The Regents of the University of California 317c478bd9Sstevel@tonic-gate * All Rights Reserved 327c478bd9Sstevel@tonic-gate * 337c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from 347c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its 357c478bd9Sstevel@tonic-gate * contributors. 367c478bd9Sstevel@tonic-gate */ 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #include <sys/types.h> 397c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 407c478bd9Sstevel@tonic-gate #include <sys/param.h> 417c478bd9Sstevel@tonic-gate #include <sys/errno.h> 427c478bd9Sstevel@tonic-gate #include <sys/user.h> 437c478bd9Sstevel@tonic-gate #include <sys/fstyp.h> 447c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 457c478bd9Sstevel@tonic-gate #include <sys/systm.h> 467c478bd9Sstevel@tonic-gate #include <sys/proc.h> 477c478bd9Sstevel@tonic-gate #include <sys/mount.h> 487c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 49aa59c4cbSrsb #include <sys/vfs_opreg.h> 507c478bd9Sstevel@tonic-gate #include <sys/fem.h> 517c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 527c478bd9Sstevel@tonic-gate #include <sys/stat.h> 537c478bd9Sstevel@tonic-gate #include <sys/statvfs.h> 547c478bd9Sstevel@tonic-gate #include <sys/statfs.h> 557c478bd9Sstevel@tonic-gate #include <sys/cred.h> 567c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 577c478bd9Sstevel@tonic-gate #include <sys/rwstlock.h> 587c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 597c478bd9Sstevel@tonic-gate #include <sys/file.h> 607c478bd9Sstevel@tonic-gate #include <sys/time.h> 617c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 627c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 637c478bd9Sstevel@tonic-gate #include <sys/buf.h> 647c478bd9Sstevel@tonic-gate #include <sys/swap.h> 657c478bd9Sstevel@tonic-gate #include <sys/debug.h> 667c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 677c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 687c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 697c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 707c478bd9Sstevel@tonic-gate #include <sys/bootconf.h> 717c478bd9Sstevel@tonic-gate #include <sys/dumphdr.h> 727c478bd9Sstevel@tonic-gate #include <sys/dc_ki.h> 737c478bd9Sstevel@tonic-gate #include <sys/poll.h> 747c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 757c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 767c478bd9Sstevel@tonic-gate #include <sys/zone.h> 777c478bd9Sstevel@tonic-gate #include <sys/policy.h> 787c478bd9Sstevel@tonic-gate #include <sys/ctfs.h> 797c478bd9Sstevel@tonic-gate #include <sys/objfs.h> 807c478bd9Sstevel@tonic-gate #include <sys/console.h> 817c478bd9Sstevel@tonic-gate #include <sys/reboot.h> 82da6c28aaSamw #include <sys/attr.h> 83b24ab676SJeff Bonwick #include <sys/zio.h> 84e7cbe64fSgw #include <sys/spa.h> 8593239addSjohnlev #include <sys/lofi.h> 866cefaae1SJack Meng #include <sys/bootprops.h> 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate #include <vm/page.h> 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate #include <fs/fs_subr.h> 9182c7f3c4Srsb /* Private interfaces to create vopstats-related data structures */ 9282c7f3c4Srsb extern void initialize_vopstats(vopstats_t *); 9382c7f3c4Srsb extern vopstats_t *get_fstype_vopstats(struct vfs *, struct vfssw *); 9482c7f3c4Srsb extern vsk_anchor_t *get_vskstat_anchor(struct vfs *); 9582c7f3c4Srsb 967c478bd9Sstevel@tonic-gate static void vfs_clearmntopt_nolock(mntopts_t *, const char *, int); 977c478bd9Sstevel@tonic-gate static void vfs_setmntopt_nolock(mntopts_t *, const char *, 987c478bd9Sstevel@tonic-gate const char *, int, int); 997c478bd9Sstevel@tonic-gate static int vfs_optionisset_nolock(const mntopts_t *, const char *, char **); 1007c478bd9Sstevel@tonic-gate static void vfs_freemnttab(struct vfs *); 1017c478bd9Sstevel@tonic-gate static void vfs_freeopt(mntopt_t *); 1027c478bd9Sstevel@tonic-gate static void vfs_swapopttbl_nolock(mntopts_t *, mntopts_t *); 1037c478bd9Sstevel@tonic-gate static void vfs_swapopttbl(mntopts_t *, mntopts_t *); 1047c478bd9Sstevel@tonic-gate static void vfs_copyopttbl_extend(const mntopts_t *, mntopts_t *, int); 1057c478bd9Sstevel@tonic-gate static void vfs_createopttbl_extend(mntopts_t *, const char *, 1067c478bd9Sstevel@tonic-gate const mntopts_t *); 1077c478bd9Sstevel@tonic-gate static char **vfs_copycancelopt_extend(char **const, int); 1087c478bd9Sstevel@tonic-gate static void vfs_freecancelopt(char **); 109843e1988Sjohnlev static void getrootfs(char **, char **); 1107c478bd9Sstevel@tonic-gate static int getmacpath(dev_info_t *, void *); 111df2381bfSpraks static void vfs_mnttabvp_setup(void); 1127c478bd9Sstevel@tonic-gate 1137c478bd9Sstevel@tonic-gate struct ipmnt { 1147c478bd9Sstevel@tonic-gate struct ipmnt *mip_next; 1157c478bd9Sstevel@tonic-gate dev_t mip_dev; 1167c478bd9Sstevel@tonic-gate struct vfs *mip_vfsp; 1177c478bd9Sstevel@tonic-gate }; 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate static kmutex_t vfs_miplist_mutex; 1207c478bd9Sstevel@tonic-gate static struct ipmnt *vfs_miplist = NULL; 1217c478bd9Sstevel@tonic-gate static struct ipmnt *vfs_miplist_end = NULL; 1227c478bd9Sstevel@tonic-gate 123da6c28aaSamw static kmem_cache_t *vfs_cache; /* Pointer to VFS kmem cache */ 124da6c28aaSamw 1257c478bd9Sstevel@tonic-gate /* 1267c478bd9Sstevel@tonic-gate * VFS global data. 1277c478bd9Sstevel@tonic-gate */ 1287c478bd9Sstevel@tonic-gate vnode_t *rootdir; /* pointer to root inode vnode. */ 1297c478bd9Sstevel@tonic-gate vnode_t *devicesdir; /* pointer to inode of devices root */ 130facf4a8dSllai vnode_t *devdir; /* pointer to inode of dev root */ 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate char *server_rootpath; /* root path for diskless clients */ 1337c478bd9Sstevel@tonic-gate char *server_hostname; /* hostname of diskless server */ 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate static struct vfs root; 1367c478bd9Sstevel@tonic-gate static struct vfs devices; 137facf4a8dSllai static struct vfs dev; 1387c478bd9Sstevel@tonic-gate struct vfs *rootvfs = &root; /* pointer to root vfs; head of VFS list. */ 1397c478bd9Sstevel@tonic-gate rvfs_t *rvfs_list; /* array of vfs ptrs for vfs hash list */ 1407c478bd9Sstevel@tonic-gate int vfshsz = 512; /* # of heads/locks in vfs hash arrays */ 1417c478bd9Sstevel@tonic-gate /* must be power of 2! */ 1427c478bd9Sstevel@tonic-gate timespec_t vfs_mnttab_ctime; /* mnttab created time */ 1437c478bd9Sstevel@tonic-gate timespec_t vfs_mnttab_mtime; /* mnttab last modified time */ 144ffc349abSdm char *vfs_dummyfstype = "\0"; 1457c478bd9Sstevel@tonic-gate struct pollhead vfs_pollhd; /* for mnttab pollers */ 146df2381bfSpraks struct vnode *vfs_mntdummyvp; /* to fake mnttab read/write for file events */ 147df2381bfSpraks int mntfstype; /* will be set once mnt fs is mounted */ 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate /* 1507c478bd9Sstevel@tonic-gate * Table for generic options recognized in the VFS layer and acted 1517c478bd9Sstevel@tonic-gate * on at this level before parsing file system specific options. 1527c478bd9Sstevel@tonic-gate * The nosuid option is stronger than any of the devices and setuid 1537c478bd9Sstevel@tonic-gate * options, so those are canceled when nosuid is seen. 1547c478bd9Sstevel@tonic-gate * 1557c478bd9Sstevel@tonic-gate * All options which are added here need to be added to the 1567c478bd9Sstevel@tonic-gate * list of standard options in usr/src/cmd/fs.d/fslib.c as well. 1577c478bd9Sstevel@tonic-gate */ 1587c478bd9Sstevel@tonic-gate /* 1597c478bd9Sstevel@tonic-gate * VFS Mount options table 1607c478bd9Sstevel@tonic-gate */ 1617c478bd9Sstevel@tonic-gate static char *ro_cancel[] = { MNTOPT_RW, NULL }; 1627c478bd9Sstevel@tonic-gate static char *rw_cancel[] = { MNTOPT_RO, NULL }; 1637c478bd9Sstevel@tonic-gate static char *suid_cancel[] = { MNTOPT_NOSUID, NULL }; 1647c478bd9Sstevel@tonic-gate static char *nosuid_cancel[] = { MNTOPT_SUID, MNTOPT_DEVICES, MNTOPT_NODEVICES, 1657c478bd9Sstevel@tonic-gate MNTOPT_NOSETUID, MNTOPT_SETUID, NULL }; 1667c478bd9Sstevel@tonic-gate static char *devices_cancel[] = { MNTOPT_NODEVICES, NULL }; 1677c478bd9Sstevel@tonic-gate static char *nodevices_cancel[] = { MNTOPT_DEVICES, NULL }; 1687c478bd9Sstevel@tonic-gate static char *setuid_cancel[] = { MNTOPT_NOSETUID, NULL }; 1697c478bd9Sstevel@tonic-gate static char *nosetuid_cancel[] = { MNTOPT_SETUID, NULL }; 1707c478bd9Sstevel@tonic-gate static char *nbmand_cancel[] = { MNTOPT_NONBMAND, NULL }; 1717c478bd9Sstevel@tonic-gate static char *nonbmand_cancel[] = { MNTOPT_NBMAND, NULL }; 1727c478bd9Sstevel@tonic-gate static char *exec_cancel[] = { MNTOPT_NOEXEC, NULL }; 1737c478bd9Sstevel@tonic-gate static char *noexec_cancel[] = { MNTOPT_EXEC, NULL }; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate static const mntopt_t mntopts[] = { 1767c478bd9Sstevel@tonic-gate /* 1777c478bd9Sstevel@tonic-gate * option name cancel options default arg flags 1787c478bd9Sstevel@tonic-gate */ 1797c478bd9Sstevel@tonic-gate { MNTOPT_REMOUNT, NULL, NULL, 1807c478bd9Sstevel@tonic-gate MO_NODISPLAY, (void *)0 }, 1817c478bd9Sstevel@tonic-gate { MNTOPT_RO, ro_cancel, NULL, 0, 1827c478bd9Sstevel@tonic-gate (void *)0 }, 1837c478bd9Sstevel@tonic-gate { MNTOPT_RW, rw_cancel, NULL, 0, 1847c478bd9Sstevel@tonic-gate (void *)0 }, 1857c478bd9Sstevel@tonic-gate { MNTOPT_SUID, suid_cancel, NULL, 0, 1867c478bd9Sstevel@tonic-gate (void *)0 }, 1877c478bd9Sstevel@tonic-gate { MNTOPT_NOSUID, nosuid_cancel, NULL, 0, 1887c478bd9Sstevel@tonic-gate (void *)0 }, 1897c478bd9Sstevel@tonic-gate { MNTOPT_DEVICES, devices_cancel, NULL, 0, 1907c478bd9Sstevel@tonic-gate (void *)0 }, 1917c478bd9Sstevel@tonic-gate { MNTOPT_NODEVICES, nodevices_cancel, NULL, 0, 1927c478bd9Sstevel@tonic-gate (void *)0 }, 1937c478bd9Sstevel@tonic-gate { MNTOPT_SETUID, setuid_cancel, NULL, 0, 1947c478bd9Sstevel@tonic-gate (void *)0 }, 1957c478bd9Sstevel@tonic-gate { MNTOPT_NOSETUID, nosetuid_cancel, NULL, 0, 1967c478bd9Sstevel@tonic-gate (void *)0 }, 1977c478bd9Sstevel@tonic-gate { MNTOPT_NBMAND, nbmand_cancel, NULL, 0, 1987c478bd9Sstevel@tonic-gate (void *)0 }, 1997c478bd9Sstevel@tonic-gate { MNTOPT_NONBMAND, nonbmand_cancel, NULL, 0, 2007c478bd9Sstevel@tonic-gate (void *)0 }, 2017c478bd9Sstevel@tonic-gate { MNTOPT_EXEC, exec_cancel, NULL, 0, 2027c478bd9Sstevel@tonic-gate (void *)0 }, 2037c478bd9Sstevel@tonic-gate { MNTOPT_NOEXEC, noexec_cancel, NULL, 0, 2047c478bd9Sstevel@tonic-gate (void *)0 }, 2057c478bd9Sstevel@tonic-gate }; 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate const mntopts_t vfs_mntopts = { 2087c478bd9Sstevel@tonic-gate sizeof (mntopts) / sizeof (mntopt_t), 2097c478bd9Sstevel@tonic-gate (mntopt_t *)&mntopts[0] 2107c478bd9Sstevel@tonic-gate }; 2117c478bd9Sstevel@tonic-gate 2127c478bd9Sstevel@tonic-gate /* 2137c478bd9Sstevel@tonic-gate * File system operation dispatch functions. 2147c478bd9Sstevel@tonic-gate */ 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate int 2177c478bd9Sstevel@tonic-gate fsop_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 2187c478bd9Sstevel@tonic-gate { 2197c478bd9Sstevel@tonic-gate return (*(vfsp)->vfs_op->vfs_mount)(vfsp, mvp, uap, cr); 2207c478bd9Sstevel@tonic-gate } 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate int 2237c478bd9Sstevel@tonic-gate fsop_unmount(vfs_t *vfsp, int flag, cred_t *cr) 2247c478bd9Sstevel@tonic-gate { 2257c478bd9Sstevel@tonic-gate return (*(vfsp)->vfs_op->vfs_unmount)(vfsp, flag, cr); 2267c478bd9Sstevel@tonic-gate } 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate int 2297c478bd9Sstevel@tonic-gate fsop_root(vfs_t *vfsp, vnode_t **vpp) 2307c478bd9Sstevel@tonic-gate { 2317c478bd9Sstevel@tonic-gate refstr_t *mntpt; 2327c478bd9Sstevel@tonic-gate int ret = (*(vfsp)->vfs_op->vfs_root)(vfsp, vpp); 2337c478bd9Sstevel@tonic-gate /* 2347c478bd9Sstevel@tonic-gate * Make sure this root has a path. With lofs, it is possible to have 2357c478bd9Sstevel@tonic-gate * a NULL mountpoint. 2367c478bd9Sstevel@tonic-gate */ 237ca2c3138Seschrock if (ret == 0 && vfsp->vfs_mntpt != NULL && (*vpp)->v_path == NULL) { 2387c478bd9Sstevel@tonic-gate mntpt = vfs_getmntpoint(vfsp); 2397c478bd9Sstevel@tonic-gate vn_setpath_str(*vpp, refstr_value(mntpt), 2407c478bd9Sstevel@tonic-gate strlen(refstr_value(mntpt))); 2417c478bd9Sstevel@tonic-gate refstr_rele(mntpt); 2427c478bd9Sstevel@tonic-gate } 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate return (ret); 2457c478bd9Sstevel@tonic-gate } 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate int 2487c478bd9Sstevel@tonic-gate fsop_statfs(vfs_t *vfsp, statvfs64_t *sp) 2497c478bd9Sstevel@tonic-gate { 2507c478bd9Sstevel@tonic-gate return (*(vfsp)->vfs_op->vfs_statvfs)(vfsp, sp); 2517c478bd9Sstevel@tonic-gate } 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate int 2547c478bd9Sstevel@tonic-gate fsop_sync(vfs_t *vfsp, short flag, cred_t *cr) 2557c478bd9Sstevel@tonic-gate { 2567c478bd9Sstevel@tonic-gate return (*(vfsp)->vfs_op->vfs_sync)(vfsp, flag, cr); 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate int 2607c478bd9Sstevel@tonic-gate fsop_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 2617c478bd9Sstevel@tonic-gate { 262da6c28aaSamw /* 263da6c28aaSamw * In order to handle system attribute fids in a manner 264da6c28aaSamw * transparent to the underlying fs, we embed the fid for 265da6c28aaSamw * the sysattr parent object in the sysattr fid and tack on 266da6c28aaSamw * some extra bytes that only the sysattr layer knows about. 267da6c28aaSamw * 268da6c28aaSamw * This guarantees that sysattr fids are larger than other fids 2699660e5cbSJanice Chang * for this vfs. If the vfs supports the sysattr view interface 2709660e5cbSJanice Chang * (as indicated by VFSFT_SYSATTR_VIEWS), we cannot have a size 2719660e5cbSJanice Chang * collision with XATTR_FIDSZ. 272da6c28aaSamw */ 2739660e5cbSJanice Chang if (vfs_has_feature(vfsp, VFSFT_SYSATTR_VIEWS) && 274da6c28aaSamw fidp->fid_len == XATTR_FIDSZ) 275da6c28aaSamw return (xattr_dir_vget(vfsp, vpp, fidp)); 276da6c28aaSamw 2777c478bd9Sstevel@tonic-gate return (*(vfsp)->vfs_op->vfs_vget)(vfsp, vpp, fidp); 2787c478bd9Sstevel@tonic-gate } 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate int 2817c478bd9Sstevel@tonic-gate fsop_mountroot(vfs_t *vfsp, enum whymountroot reason) 2827c478bd9Sstevel@tonic-gate { 2837c478bd9Sstevel@tonic-gate return (*(vfsp)->vfs_op->vfs_mountroot)(vfsp, reason); 2847c478bd9Sstevel@tonic-gate } 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate void 2877c478bd9Sstevel@tonic-gate fsop_freefs(vfs_t *vfsp) 2887c478bd9Sstevel@tonic-gate { 2897c478bd9Sstevel@tonic-gate (*(vfsp)->vfs_op->vfs_freevfs)(vfsp); 2907c478bd9Sstevel@tonic-gate } 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate int 2937c478bd9Sstevel@tonic-gate fsop_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate) 2947c478bd9Sstevel@tonic-gate { 2957c478bd9Sstevel@tonic-gate return ((*(vfsp)->vfs_op->vfs_vnstate)(vfsp, vp, nstate)); 2967c478bd9Sstevel@tonic-gate } 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate int 2997c478bd9Sstevel@tonic-gate fsop_sync_by_kind(int fstype, short flag, cred_t *cr) 3007c478bd9Sstevel@tonic-gate { 3017c478bd9Sstevel@tonic-gate ASSERT((fstype >= 0) && (fstype < nfstype)); 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate if (ALLOCATED_VFSSW(&vfssw[fstype]) && VFS_INSTALLED(&vfssw[fstype])) 3047c478bd9Sstevel@tonic-gate return (*vfssw[fstype].vsw_vfsops.vfs_sync) (NULL, flag, cr); 3057c478bd9Sstevel@tonic-gate else 3067c478bd9Sstevel@tonic-gate return (ENOTSUP); 3077c478bd9Sstevel@tonic-gate } 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate /* 3107c478bd9Sstevel@tonic-gate * File system initialization. vfs_setfsops() must be called from a file 3117c478bd9Sstevel@tonic-gate * system's init routine. 3127c478bd9Sstevel@tonic-gate */ 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate static int 3157c478bd9Sstevel@tonic-gate fs_copyfsops(const fs_operation_def_t *template, vfsops_t *actual, 3167c478bd9Sstevel@tonic-gate int *unused_ops) 3177c478bd9Sstevel@tonic-gate { 3187c478bd9Sstevel@tonic-gate static const fs_operation_trans_def_t vfs_ops_table[] = { 3197c478bd9Sstevel@tonic-gate VFSNAME_MOUNT, offsetof(vfsops_t, vfs_mount), 3207c478bd9Sstevel@tonic-gate fs_nosys, fs_nosys, 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate VFSNAME_UNMOUNT, offsetof(vfsops_t, vfs_unmount), 3237c478bd9Sstevel@tonic-gate fs_nosys, fs_nosys, 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate VFSNAME_ROOT, offsetof(vfsops_t, vfs_root), 3267c478bd9Sstevel@tonic-gate fs_nosys, fs_nosys, 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate VFSNAME_STATVFS, offsetof(vfsops_t, vfs_statvfs), 3297c478bd9Sstevel@tonic-gate fs_nosys, fs_nosys, 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate VFSNAME_SYNC, offsetof(vfsops_t, vfs_sync), 3327c478bd9Sstevel@tonic-gate (fs_generic_func_p) fs_sync, 3337c478bd9Sstevel@tonic-gate (fs_generic_func_p) fs_sync, /* No errors allowed */ 3347c478bd9Sstevel@tonic-gate 3357c478bd9Sstevel@tonic-gate VFSNAME_VGET, offsetof(vfsops_t, vfs_vget), 3367c478bd9Sstevel@tonic-gate fs_nosys, fs_nosys, 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate VFSNAME_MOUNTROOT, offsetof(vfsops_t, vfs_mountroot), 3397c478bd9Sstevel@tonic-gate fs_nosys, fs_nosys, 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate VFSNAME_FREEVFS, offsetof(vfsops_t, vfs_freevfs), 3427c478bd9Sstevel@tonic-gate (fs_generic_func_p)fs_freevfs, 3437c478bd9Sstevel@tonic-gate (fs_generic_func_p)fs_freevfs, /* Shouldn't fail */ 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate VFSNAME_VNSTATE, offsetof(vfsops_t, vfs_vnstate), 3467c478bd9Sstevel@tonic-gate (fs_generic_func_p)fs_nosys, 3477c478bd9Sstevel@tonic-gate (fs_generic_func_p)fs_nosys, 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate NULL, 0, NULL, NULL 3507c478bd9Sstevel@tonic-gate }; 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate return (fs_build_vector(actual, unused_ops, vfs_ops_table, template)); 3537c478bd9Sstevel@tonic-gate } 3547c478bd9Sstevel@tonic-gate 355e7cbe64fSgw void 356e7cbe64fSgw zfs_boot_init() { 357e7cbe64fSgw 358e7cbe64fSgw if (strcmp(rootfs.bo_fstype, MNTTYPE_ZFS) == 0) 359e7cbe64fSgw spa_boot_init(); 360e7cbe64fSgw } 361e7cbe64fSgw 3627c478bd9Sstevel@tonic-gate int 3637c478bd9Sstevel@tonic-gate vfs_setfsops(int fstype, const fs_operation_def_t *template, vfsops_t **actual) 3647c478bd9Sstevel@tonic-gate { 3657c478bd9Sstevel@tonic-gate int error; 3667c478bd9Sstevel@tonic-gate int unused_ops; 3677c478bd9Sstevel@tonic-gate 368d320ee2dSrsb /* 369d320ee2dSrsb * Verify that fstype refers to a valid fs. Note that 370d320ee2dSrsb * 0 is valid since it's used to set "stray" ops. 371d320ee2dSrsb */ 372d320ee2dSrsb if ((fstype < 0) || (fstype >= nfstype)) 3737c478bd9Sstevel@tonic-gate return (EINVAL); 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate if (!ALLOCATED_VFSSW(&vfssw[fstype])) 3767c478bd9Sstevel@tonic-gate return (EINVAL); 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /* Set up the operations vector. */ 3797c478bd9Sstevel@tonic-gate 3807c478bd9Sstevel@tonic-gate error = fs_copyfsops(template, &vfssw[fstype].vsw_vfsops, &unused_ops); 3817c478bd9Sstevel@tonic-gate 3827c478bd9Sstevel@tonic-gate if (error != 0) 3837c478bd9Sstevel@tonic-gate return (error); 3847c478bd9Sstevel@tonic-gate 3857c478bd9Sstevel@tonic-gate vfssw[fstype].vsw_flag |= VSW_INSTALLED; 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate if (actual != NULL) 3887c478bd9Sstevel@tonic-gate *actual = &vfssw[fstype].vsw_vfsops; 3897c478bd9Sstevel@tonic-gate 3907c478bd9Sstevel@tonic-gate #if DEBUG 3917c478bd9Sstevel@tonic-gate if (unused_ops != 0) 3927c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "vfs_setfsops: %s: %d operations supplied " 3937c478bd9Sstevel@tonic-gate "but not used", vfssw[fstype].vsw_name, unused_ops); 3947c478bd9Sstevel@tonic-gate #endif 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate return (0); 3977c478bd9Sstevel@tonic-gate } 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate int 4007c478bd9Sstevel@tonic-gate vfs_makefsops(const fs_operation_def_t *template, vfsops_t **actual) 4017c478bd9Sstevel@tonic-gate { 4027c478bd9Sstevel@tonic-gate int error; 4037c478bd9Sstevel@tonic-gate int unused_ops; 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate *actual = (vfsops_t *)kmem_alloc(sizeof (vfsops_t), KM_SLEEP); 4067c478bd9Sstevel@tonic-gate 4077c478bd9Sstevel@tonic-gate error = fs_copyfsops(template, *actual, &unused_ops); 4087c478bd9Sstevel@tonic-gate if (error != 0) { 4097c478bd9Sstevel@tonic-gate kmem_free(*actual, sizeof (vfsops_t)); 4107c478bd9Sstevel@tonic-gate *actual = NULL; 4117c478bd9Sstevel@tonic-gate return (error); 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate return (0); 4157c478bd9Sstevel@tonic-gate } 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate /* 4187c478bd9Sstevel@tonic-gate * Free a vfsops structure created as a result of vfs_makefsops(). 4197c478bd9Sstevel@tonic-gate * NOTE: For a vfsops structure initialized by vfs_setfsops(), use 4207c478bd9Sstevel@tonic-gate * vfs_freevfsops_by_type(). 4217c478bd9Sstevel@tonic-gate */ 4227c478bd9Sstevel@tonic-gate void 4237c478bd9Sstevel@tonic-gate vfs_freevfsops(vfsops_t *vfsops) 4247c478bd9Sstevel@tonic-gate { 4257c478bd9Sstevel@tonic-gate kmem_free(vfsops, sizeof (vfsops_t)); 4267c478bd9Sstevel@tonic-gate } 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate /* 4297c478bd9Sstevel@tonic-gate * Since the vfsops structure is part of the vfssw table and wasn't 4307c478bd9Sstevel@tonic-gate * really allocated, we're not really freeing anything. We keep 4317c478bd9Sstevel@tonic-gate * the name for consistency with vfs_freevfsops(). We do, however, 4327c478bd9Sstevel@tonic-gate * need to take care of a little bookkeeping. 4337c478bd9Sstevel@tonic-gate * NOTE: For a vfsops structure created by vfs_setfsops(), use 4347c478bd9Sstevel@tonic-gate * vfs_freevfsops_by_type(). 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate int 4377c478bd9Sstevel@tonic-gate vfs_freevfsops_by_type(int fstype) 4387c478bd9Sstevel@tonic-gate { 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate /* Verify that fstype refers to a loaded fs (and not fsid 0). */ 4417c478bd9Sstevel@tonic-gate if ((fstype <= 0) || (fstype >= nfstype)) 4427c478bd9Sstevel@tonic-gate return (EINVAL); 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate WLOCK_VFSSW(); 4457c478bd9Sstevel@tonic-gate if ((vfssw[fstype].vsw_flag & VSW_INSTALLED) == 0) { 4467c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 4477c478bd9Sstevel@tonic-gate return (EINVAL); 4487c478bd9Sstevel@tonic-gate } 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate vfssw[fstype].vsw_flag &= ~VSW_INSTALLED; 4517c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate return (0); 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate /* Support routines used to reference vfs_op */ 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate /* Set the operations vector for a vfs */ 4597c478bd9Sstevel@tonic-gate void 4607c478bd9Sstevel@tonic-gate vfs_setops(vfs_t *vfsp, vfsops_t *vfsops) 4617c478bd9Sstevel@tonic-gate { 4627c478bd9Sstevel@tonic-gate vfsops_t *op; 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate ASSERT(vfsp != NULL); 4657c478bd9Sstevel@tonic-gate ASSERT(vfsops != NULL); 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate op = vfsp->vfs_op; 4687c478bd9Sstevel@tonic-gate membar_consumer(); 469da6c28aaSamw if (vfsp->vfs_femhead == NULL && 4707c478bd9Sstevel@tonic-gate casptr(&vfsp->vfs_op, op, vfsops) == op) { 4717c478bd9Sstevel@tonic-gate return; 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate fsem_setvfsops(vfsp, vfsops); 4747c478bd9Sstevel@tonic-gate } 4757c478bd9Sstevel@tonic-gate 4767c478bd9Sstevel@tonic-gate /* Retrieve the operations vector for a vfs */ 4777c478bd9Sstevel@tonic-gate vfsops_t * 4787c478bd9Sstevel@tonic-gate vfs_getops(vfs_t *vfsp) 4797c478bd9Sstevel@tonic-gate { 4807c478bd9Sstevel@tonic-gate vfsops_t *op; 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate ASSERT(vfsp != NULL); 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate op = vfsp->vfs_op; 4857c478bd9Sstevel@tonic-gate membar_consumer(); 486da6c28aaSamw if (vfsp->vfs_femhead == NULL && op == vfsp->vfs_op) { 4877c478bd9Sstevel@tonic-gate return (op); 4887c478bd9Sstevel@tonic-gate } else { 4897c478bd9Sstevel@tonic-gate return (fsem_getvfsops(vfsp)); 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate } 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate /* 4947c478bd9Sstevel@tonic-gate * Returns non-zero (1) if the vfsops matches that of the vfs. 4957c478bd9Sstevel@tonic-gate * Returns zero (0) if not. 4967c478bd9Sstevel@tonic-gate */ 4977c478bd9Sstevel@tonic-gate int 4987c478bd9Sstevel@tonic-gate vfs_matchops(vfs_t *vfsp, vfsops_t *vfsops) 4997c478bd9Sstevel@tonic-gate { 5007c478bd9Sstevel@tonic-gate return (vfs_getops(vfsp) == vfsops); 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate /* 5047c478bd9Sstevel@tonic-gate * Returns non-zero (1) if the file system has installed a non-default, 5057c478bd9Sstevel@tonic-gate * non-error vfs_sync routine. Returns zero (0) otherwise. 5067c478bd9Sstevel@tonic-gate */ 5077c478bd9Sstevel@tonic-gate int 5087c478bd9Sstevel@tonic-gate vfs_can_sync(vfs_t *vfsp) 5097c478bd9Sstevel@tonic-gate { 5107c478bd9Sstevel@tonic-gate /* vfs_sync() routine is not the default/error function */ 5117c478bd9Sstevel@tonic-gate return (vfs_getops(vfsp)->vfs_sync != fs_sync); 5127c478bd9Sstevel@tonic-gate } 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate /* 5157c478bd9Sstevel@tonic-gate * Initialize a vfs structure. 5167c478bd9Sstevel@tonic-gate */ 5177c478bd9Sstevel@tonic-gate void 5187c478bd9Sstevel@tonic-gate vfs_init(vfs_t *vfsp, vfsops_t *op, void *data) 5197c478bd9Sstevel@tonic-gate { 520da6c28aaSamw /* Other initialization has been moved to vfs_alloc() */ 5217c478bd9Sstevel@tonic-gate vfsp->vfs_count = 0; 5227c478bd9Sstevel@tonic-gate vfsp->vfs_next = vfsp; 5237c478bd9Sstevel@tonic-gate vfsp->vfs_prev = vfsp; 5247c478bd9Sstevel@tonic-gate vfsp->vfs_zone_next = vfsp; 5257c478bd9Sstevel@tonic-gate vfsp->vfs_zone_prev = vfsp; 52693239addSjohnlev vfsp->vfs_lofi_minor = 0; 527da6c28aaSamw sema_init(&vfsp->vfs_reflock, 1, NULL, SEMA_DEFAULT, NULL); 528da6c28aaSamw vfsimpl_setup(vfsp); 5297c478bd9Sstevel@tonic-gate vfsp->vfs_data = (data); 5307c478bd9Sstevel@tonic-gate vfs_setops((vfsp), (op)); 5317c478bd9Sstevel@tonic-gate } 5327c478bd9Sstevel@tonic-gate 533ddfcde86Srsb /* 534ddfcde86Srsb * Allocate and initialize the vfs implementation private data 535ddfcde86Srsb * structure, vfs_impl_t. 536ddfcde86Srsb */ 537ddfcde86Srsb void 538ddfcde86Srsb vfsimpl_setup(vfs_t *vfsp) 539ddfcde86Srsb { 540da6c28aaSamw int i; 541da6c28aaSamw 542da6c28aaSamw if (vfsp->vfs_implp != NULL) { 543da6c28aaSamw return; 544da6c28aaSamw } 545da6c28aaSamw 546ddfcde86Srsb vfsp->vfs_implp = kmem_alloc(sizeof (vfs_impl_t), KM_SLEEP); 547da6c28aaSamw /* Note that these are #define'd in vfs.h */ 548ddfcde86Srsb vfsp->vfs_vskap = NULL; 549ddfcde86Srsb vfsp->vfs_fstypevsp = NULL; 550da6c28aaSamw 551da6c28aaSamw /* Set size of counted array, then zero the array */ 552da6c28aaSamw vfsp->vfs_featureset[0] = VFS_FEATURE_MAXSZ - 1; 553da6c28aaSamw for (i = 1; i < VFS_FEATURE_MAXSZ; i++) { 554da6c28aaSamw vfsp->vfs_featureset[i] = 0; 555da6c28aaSamw } 556ddfcde86Srsb } 557ddfcde86Srsb 558ddfcde86Srsb /* 559ddfcde86Srsb * Release the vfs_impl_t structure, if it exists. Some unbundled 560ddfcde86Srsb * filesystems may not use the newer version of vfs and thus 561ddfcde86Srsb * would not contain this implementation private data structure. 562ddfcde86Srsb */ 563ddfcde86Srsb void 564ddfcde86Srsb vfsimpl_teardown(vfs_t *vfsp) 565ddfcde86Srsb { 566ddfcde86Srsb vfs_impl_t *vip = vfsp->vfs_implp; 567ddfcde86Srsb 568ddfcde86Srsb if (vip == NULL) 569ddfcde86Srsb return; 570ddfcde86Srsb 571ddfcde86Srsb kmem_free(vfsp->vfs_implp, sizeof (vfs_impl_t)); 572ddfcde86Srsb vfsp->vfs_implp = NULL; 573ddfcde86Srsb } 5747c478bd9Sstevel@tonic-gate 5757c478bd9Sstevel@tonic-gate /* 5767c478bd9Sstevel@tonic-gate * VFS system calls: mount, umount, syssync, statfs, fstatfs, statvfs, 5777c478bd9Sstevel@tonic-gate * fstatvfs, and sysfs moved to common/syscall. 5787c478bd9Sstevel@tonic-gate */ 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate /* 5817c478bd9Sstevel@tonic-gate * Update every mounted file system. We call the vfs_sync operation of 5827c478bd9Sstevel@tonic-gate * each file system type, passing it a NULL vfsp to indicate that all 5837c478bd9Sstevel@tonic-gate * mounted file systems of that type should be updated. 5847c478bd9Sstevel@tonic-gate */ 5857c478bd9Sstevel@tonic-gate void 5867c478bd9Sstevel@tonic-gate vfs_sync(int flag) 5877c478bd9Sstevel@tonic-gate { 5887c478bd9Sstevel@tonic-gate struct vfssw *vswp; 5897c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 5907c478bd9Sstevel@tonic-gate for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 5917c478bd9Sstevel@tonic-gate if (ALLOCATED_VFSSW(vswp) && VFS_INSTALLED(vswp)) { 5927c478bd9Sstevel@tonic-gate vfs_refvfssw(vswp); 5937c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 5947c478bd9Sstevel@tonic-gate (void) (*vswp->vsw_vfsops.vfs_sync)(NULL, flag, 5957c478bd9Sstevel@tonic-gate CRED()); 5967c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vswp); 5977c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 5987c478bd9Sstevel@tonic-gate } 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate void 6047c478bd9Sstevel@tonic-gate sync(void) 6057c478bd9Sstevel@tonic-gate { 6067c478bd9Sstevel@tonic-gate vfs_sync(0); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate /* 6107c478bd9Sstevel@tonic-gate * External routines. 6117c478bd9Sstevel@tonic-gate */ 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate krwlock_t vfssw_lock; /* lock accesses to vfssw */ 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate /* 6167c478bd9Sstevel@tonic-gate * Lock for accessing the vfs linked list. Initialized in vfs_mountroot(), 6177c478bd9Sstevel@tonic-gate * but otherwise should be accessed only via vfs_list_lock() and 6187c478bd9Sstevel@tonic-gate * vfs_list_unlock(). Also used to protect the timestamp for mods to the list. 6197c478bd9Sstevel@tonic-gate */ 6207c478bd9Sstevel@tonic-gate static krwlock_t vfslist; 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate /* 6237c478bd9Sstevel@tonic-gate * Mount devfs on /devices. This is done right after root is mounted 6247c478bd9Sstevel@tonic-gate * to provide device access support for the system 6257c478bd9Sstevel@tonic-gate */ 6267c478bd9Sstevel@tonic-gate static void 6277c478bd9Sstevel@tonic-gate vfs_mountdevices(void) 6287c478bd9Sstevel@tonic-gate { 6297c478bd9Sstevel@tonic-gate struct vfssw *vsw; 6307c478bd9Sstevel@tonic-gate struct vnode *mvp; 6317c478bd9Sstevel@tonic-gate struct mounta mounta = { /* fake mounta for devfs_mount() */ 6327c478bd9Sstevel@tonic-gate NULL, 6337c478bd9Sstevel@tonic-gate NULL, 6347c478bd9Sstevel@tonic-gate MS_SYSSPACE, 6357c478bd9Sstevel@tonic-gate NULL, 6367c478bd9Sstevel@tonic-gate NULL, 6377c478bd9Sstevel@tonic-gate 0, 6387c478bd9Sstevel@tonic-gate NULL, 6397c478bd9Sstevel@tonic-gate 0 6407c478bd9Sstevel@tonic-gate }; 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate /* 6437c478bd9Sstevel@tonic-gate * _init devfs module to fill in the vfssw 6447c478bd9Sstevel@tonic-gate */ 6457c478bd9Sstevel@tonic-gate if (modload("fs", "devfs") == -1) 646ae115bc7Smrj panic("Cannot _init devfs module"); 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate /* 6497c478bd9Sstevel@tonic-gate * Hold vfs 6507c478bd9Sstevel@tonic-gate */ 6517c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 6527c478bd9Sstevel@tonic-gate vsw = vfs_getvfsswbyname("devfs"); 6537c478bd9Sstevel@tonic-gate VFS_INIT(&devices, &vsw->vsw_vfsops, NULL); 6547c478bd9Sstevel@tonic-gate VFS_HOLD(&devices); 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate /* 6577c478bd9Sstevel@tonic-gate * Locate mount point 6587c478bd9Sstevel@tonic-gate */ 6597c478bd9Sstevel@tonic-gate if (lookupname("/devices", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) 660ae115bc7Smrj panic("Cannot find /devices"); 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate /* 6637c478bd9Sstevel@tonic-gate * Perform the mount of /devices 6647c478bd9Sstevel@tonic-gate */ 6657c478bd9Sstevel@tonic-gate if (VFS_MOUNT(&devices, mvp, &mounta, CRED())) 666ae115bc7Smrj panic("Cannot mount /devices"); 6677c478bd9Sstevel@tonic-gate 6687c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate /* 6717c478bd9Sstevel@tonic-gate * Set appropriate members and add to vfs list for mnttab display 6727c478bd9Sstevel@tonic-gate */ 6737c478bd9Sstevel@tonic-gate vfs_setresource(&devices, "/devices"); 6747c478bd9Sstevel@tonic-gate vfs_setmntpoint(&devices, "/devices"); 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate /* 6777c478bd9Sstevel@tonic-gate * Hold the root of /devices so it won't go away 6787c478bd9Sstevel@tonic-gate */ 6797c478bd9Sstevel@tonic-gate if (VFS_ROOT(&devices, &devicesdir)) 680ae115bc7Smrj panic("vfs_mountdevices: not devices root"); 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate if (vfs_lock(&devices) != 0) { 683facf4a8dSllai VN_RELE(devicesdir); 6847c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /devices"); 6857c478bd9Sstevel@tonic-gate return; 6867c478bd9Sstevel@tonic-gate } 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate if (vn_vfswlock(mvp) != 0) { 6897c478bd9Sstevel@tonic-gate vfs_unlock(&devices); 690facf4a8dSllai VN_RELE(devicesdir); 6917c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "Cannot acquire vfswlock of /devices"); 6927c478bd9Sstevel@tonic-gate return; 6937c478bd9Sstevel@tonic-gate } 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate vfs_add(mvp, &devices, 0); 6967c478bd9Sstevel@tonic-gate vn_vfsunlock(mvp); 6977c478bd9Sstevel@tonic-gate vfs_unlock(&devices); 698facf4a8dSllai VN_RELE(devicesdir); 699facf4a8dSllai } 700facf4a8dSllai 701facf4a8dSllai /* 702facf4a8dSllai * mount the first instance of /dev to root and remain mounted 703facf4a8dSllai */ 704facf4a8dSllai static void 705facf4a8dSllai vfs_mountdev1(void) 706facf4a8dSllai { 707facf4a8dSllai struct vfssw *vsw; 708facf4a8dSllai struct vnode *mvp; 709facf4a8dSllai struct mounta mounta = { /* fake mounta for sdev_mount() */ 710facf4a8dSllai NULL, 711facf4a8dSllai NULL, 712facf4a8dSllai MS_SYSSPACE | MS_OVERLAY, 713facf4a8dSllai NULL, 714facf4a8dSllai NULL, 715facf4a8dSllai 0, 716facf4a8dSllai NULL, 717facf4a8dSllai 0 718facf4a8dSllai }; 719facf4a8dSllai 720facf4a8dSllai /* 721facf4a8dSllai * _init dev module to fill in the vfssw 722facf4a8dSllai */ 723facf4a8dSllai if (modload("fs", "dev") == -1) 724facf4a8dSllai cmn_err(CE_PANIC, "Cannot _init dev module\n"); 725facf4a8dSllai 726facf4a8dSllai /* 727facf4a8dSllai * Hold vfs 728facf4a8dSllai */ 729facf4a8dSllai RLOCK_VFSSW(); 730facf4a8dSllai vsw = vfs_getvfsswbyname("dev"); 731facf4a8dSllai VFS_INIT(&dev, &vsw->vsw_vfsops, NULL); 732facf4a8dSllai VFS_HOLD(&dev); 733facf4a8dSllai 734facf4a8dSllai /* 735facf4a8dSllai * Locate mount point 736facf4a8dSllai */ 737facf4a8dSllai if (lookupname("/dev", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) 738facf4a8dSllai cmn_err(CE_PANIC, "Cannot find /dev\n"); 739facf4a8dSllai 740facf4a8dSllai /* 741facf4a8dSllai * Perform the mount of /dev 742facf4a8dSllai */ 743facf4a8dSllai if (VFS_MOUNT(&dev, mvp, &mounta, CRED())) 744facf4a8dSllai cmn_err(CE_PANIC, "Cannot mount /dev 1\n"); 745facf4a8dSllai 746facf4a8dSllai RUNLOCK_VFSSW(); 747facf4a8dSllai 748facf4a8dSllai /* 749facf4a8dSllai * Set appropriate members and add to vfs list for mnttab display 750facf4a8dSllai */ 751facf4a8dSllai vfs_setresource(&dev, "/dev"); 752facf4a8dSllai vfs_setmntpoint(&dev, "/dev"); 753facf4a8dSllai 754facf4a8dSllai /* 755facf4a8dSllai * Hold the root of /dev so it won't go away 756facf4a8dSllai */ 757facf4a8dSllai if (VFS_ROOT(&dev, &devdir)) 758facf4a8dSllai cmn_err(CE_PANIC, "vfs_mountdev1: not dev root"); 759facf4a8dSllai 760facf4a8dSllai if (vfs_lock(&dev) != 0) { 761facf4a8dSllai VN_RELE(devdir); 762facf4a8dSllai cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /dev"); 763facf4a8dSllai return; 764facf4a8dSllai } 765facf4a8dSllai 766facf4a8dSllai if (vn_vfswlock(mvp) != 0) { 767facf4a8dSllai vfs_unlock(&dev); 768facf4a8dSllai VN_RELE(devdir); 769facf4a8dSllai cmn_err(CE_NOTE, "Cannot acquire vfswlock of /dev"); 770facf4a8dSllai return; 771facf4a8dSllai } 772facf4a8dSllai 773facf4a8dSllai vfs_add(mvp, &dev, 0); 774facf4a8dSllai vn_vfsunlock(mvp); 775facf4a8dSllai vfs_unlock(&dev); 776facf4a8dSllai VN_RELE(devdir); 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate /* 7807c478bd9Sstevel@tonic-gate * Mount required filesystem. This is done right after root is mounted. 7817c478bd9Sstevel@tonic-gate */ 7827c478bd9Sstevel@tonic-gate static void 7837c478bd9Sstevel@tonic-gate vfs_mountfs(char *module, char *spec, char *path) 7847c478bd9Sstevel@tonic-gate { 7857c478bd9Sstevel@tonic-gate struct vnode *mvp; 7867c478bd9Sstevel@tonic-gate struct mounta mounta; 7877c478bd9Sstevel@tonic-gate vfs_t *vfsp; 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate mounta.flags = MS_SYSSPACE | MS_DATA; 7907c478bd9Sstevel@tonic-gate mounta.fstype = module; 7917c478bd9Sstevel@tonic-gate mounta.spec = spec; 7927c478bd9Sstevel@tonic-gate mounta.dir = path; 7937c478bd9Sstevel@tonic-gate if (lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) { 794ae115bc7Smrj cmn_err(CE_WARN, "Cannot find %s", path); 7957c478bd9Sstevel@tonic-gate return; 7967c478bd9Sstevel@tonic-gate } 7977c478bd9Sstevel@tonic-gate if (domount(NULL, &mounta, mvp, CRED(), &vfsp)) 798ae115bc7Smrj cmn_err(CE_WARN, "Cannot mount %s", path); 7997c478bd9Sstevel@tonic-gate else 8007c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); 8017c478bd9Sstevel@tonic-gate VN_RELE(mvp); 8027c478bd9Sstevel@tonic-gate } 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate /* 8057c478bd9Sstevel@tonic-gate * vfs_mountroot is called by main() to mount the root filesystem. 8067c478bd9Sstevel@tonic-gate */ 8077c478bd9Sstevel@tonic-gate void 8087c478bd9Sstevel@tonic-gate vfs_mountroot(void) 8097c478bd9Sstevel@tonic-gate { 8107c478bd9Sstevel@tonic-gate struct vnode *rvp = NULL; 8117c478bd9Sstevel@tonic-gate char *path; 8127c478bd9Sstevel@tonic-gate size_t plen; 8135a59a8b3Srsb struct vfssw *vswp; 81435a5a358SJonathan Adams proc_t *p; 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate rw_init(&vfssw_lock, NULL, RW_DEFAULT, NULL); 8177c478bd9Sstevel@tonic-gate rw_init(&vfslist, NULL, RW_DEFAULT, NULL); 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate /* 8207c478bd9Sstevel@tonic-gate * Alloc the vfs hash bucket array and locks 8217c478bd9Sstevel@tonic-gate */ 8227c478bd9Sstevel@tonic-gate rvfs_list = kmem_zalloc(vfshsz * sizeof (rvfs_t), KM_SLEEP); 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate /* 8257c478bd9Sstevel@tonic-gate * Call machine-dependent routine "rootconf" to choose a root 8267c478bd9Sstevel@tonic-gate * file system type. 8277c478bd9Sstevel@tonic-gate */ 8287c478bd9Sstevel@tonic-gate if (rootconf()) 829ae115bc7Smrj panic("vfs_mountroot: cannot mount root"); 8307c478bd9Sstevel@tonic-gate /* 8317c478bd9Sstevel@tonic-gate * Get vnode for '/'. Set up rootdir, u.u_rdir and u.u_cdir 8327c478bd9Sstevel@tonic-gate * to point to it. These are used by lookuppn() so that it 8337c478bd9Sstevel@tonic-gate * knows where to start from ('/' or '.'). 8347c478bd9Sstevel@tonic-gate */ 8357c478bd9Sstevel@tonic-gate vfs_setmntpoint(rootvfs, "/"); 8367c478bd9Sstevel@tonic-gate if (VFS_ROOT(rootvfs, &rootdir)) 837ae115bc7Smrj panic("vfs_mountroot: no root vnode"); 83835a5a358SJonathan Adams 83935a5a358SJonathan Adams /* 84035a5a358SJonathan Adams * At this point, the process tree consists of p0 and possibly some 84135a5a358SJonathan Adams * direct children of p0. (i.e. there are no grandchildren) 84235a5a358SJonathan Adams * 84335a5a358SJonathan Adams * Walk through them all, setting their current directory. 84435a5a358SJonathan Adams */ 84535a5a358SJonathan Adams mutex_enter(&pidlock); 84635a5a358SJonathan Adams for (p = practive; p != NULL; p = p->p_next) { 84735a5a358SJonathan Adams ASSERT(p == &p0 || p->p_parent == &p0); 84835a5a358SJonathan Adams 84935a5a358SJonathan Adams PTOU(p)->u_cdir = rootdir; 85035a5a358SJonathan Adams VN_HOLD(PTOU(p)->u_cdir); 85135a5a358SJonathan Adams PTOU(p)->u_rdir = NULL; 85235a5a358SJonathan Adams } 85335a5a358SJonathan Adams mutex_exit(&pidlock); 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate /* 8567c478bd9Sstevel@tonic-gate * Setup the global zone's rootvp, now that it exists. 8577c478bd9Sstevel@tonic-gate */ 8587c478bd9Sstevel@tonic-gate global_zone->zone_rootvp = rootdir; 8597c478bd9Sstevel@tonic-gate VN_HOLD(global_zone->zone_rootvp); 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate /* 8627c478bd9Sstevel@tonic-gate * Notify the module code that it can begin using the 8637c478bd9Sstevel@tonic-gate * root filesystem instead of the boot program's services. 8647c478bd9Sstevel@tonic-gate */ 8657c478bd9Sstevel@tonic-gate modrootloaded = 1; 866e7cbe64fSgw 867e7cbe64fSgw /* 868e7cbe64fSgw * Special handling for a ZFS root file system. 869e7cbe64fSgw */ 870e7cbe64fSgw zfs_boot_init(); 871e7cbe64fSgw 8727c478bd9Sstevel@tonic-gate /* 8737c478bd9Sstevel@tonic-gate * Set up mnttab information for root 8747c478bd9Sstevel@tonic-gate */ 8757c478bd9Sstevel@tonic-gate vfs_setresource(rootvfs, rootfs.bo_name); 8767c478bd9Sstevel@tonic-gate 8777c478bd9Sstevel@tonic-gate /* 8787c478bd9Sstevel@tonic-gate * Notify cluster software that the root filesystem is available. 8797c478bd9Sstevel@tonic-gate */ 8807c478bd9Sstevel@tonic-gate clboot_mountroot(); 8817c478bd9Sstevel@tonic-gate 8825a59a8b3Srsb /* Now that we're all done with the root FS, set up its vopstats */ 8835a59a8b3Srsb if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) != NULL) { 8845a59a8b3Srsb /* Set flag for statistics collection */ 8855a59a8b3Srsb if (vswp->vsw_flag & VSW_STATS) { 88682c7f3c4Srsb initialize_vopstats(&rootvfs->vfs_vopstats); 8875a59a8b3Srsb rootvfs->vfs_flag |= VFS_STATS; 88882c7f3c4Srsb rootvfs->vfs_fstypevsp = 88982c7f3c4Srsb get_fstype_vopstats(rootvfs, vswp); 89082c7f3c4Srsb rootvfs->vfs_vskap = get_vskstat_anchor(rootvfs); 8915a59a8b3Srsb } 8925a59a8b3Srsb vfs_unrefvfssw(vswp); 8935a59a8b3Srsb } 8945a59a8b3Srsb 8957c478bd9Sstevel@tonic-gate /* 896facf4a8dSllai * Mount /devices, /dev instance 1, /system/contract, /etc/mnttab, 897a237e38eSth * /etc/svc/volatile, /etc/dfs/sharetab, /system/object, and /proc. 8987c478bd9Sstevel@tonic-gate */ 8997c478bd9Sstevel@tonic-gate vfs_mountdevices(); 900facf4a8dSllai vfs_mountdev1(); 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate vfs_mountfs("ctfs", "ctfs", CTFS_ROOT); 9037c478bd9Sstevel@tonic-gate vfs_mountfs("proc", "/proc", "/proc"); 9047c478bd9Sstevel@tonic-gate vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab"); 9057c478bd9Sstevel@tonic-gate vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile"); 9067c478bd9Sstevel@tonic-gate vfs_mountfs("objfs", "objfs", OBJFS_ROOT); 9077c478bd9Sstevel@tonic-gate 908a237e38eSth if (getzoneid() == GLOBAL_ZONEID) { 909a237e38eSth vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab"); 910a237e38eSth } 911a237e38eSth 9127c478bd9Sstevel@tonic-gate #ifdef __sparc 9137c478bd9Sstevel@tonic-gate /* 9147c478bd9Sstevel@tonic-gate * This bit of magic can go away when we convert sparc to 9157c478bd9Sstevel@tonic-gate * the new boot architecture based on ramdisk. 9167c478bd9Sstevel@tonic-gate * 9177c478bd9Sstevel@tonic-gate * Booting off a mirrored root volume: 9187c478bd9Sstevel@tonic-gate * At this point, we have booted and mounted root on a 9197c478bd9Sstevel@tonic-gate * single component of the mirror. Complete the boot 9207c478bd9Sstevel@tonic-gate * by configuring SVM and converting the root to the 9217c478bd9Sstevel@tonic-gate * dev_t of the mirrored root device. This dev_t conversion 9227c478bd9Sstevel@tonic-gate * only works because the underlying device doesn't change. 9237c478bd9Sstevel@tonic-gate */ 9247c478bd9Sstevel@tonic-gate if (root_is_svm) { 9257c478bd9Sstevel@tonic-gate if (svm_rootconf()) { 926ae115bc7Smrj panic("vfs_mountroot: cannot remount root"); 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate /* 9307c478bd9Sstevel@tonic-gate * mnttab should reflect the new root device 9317c478bd9Sstevel@tonic-gate */ 9327c478bd9Sstevel@tonic-gate vfs_lock_wait(rootvfs); 9337c478bd9Sstevel@tonic-gate vfs_setresource(rootvfs, rootfs.bo_name); 9347c478bd9Sstevel@tonic-gate vfs_unlock(rootvfs); 9357c478bd9Sstevel@tonic-gate } 9367c478bd9Sstevel@tonic-gate #endif /* __sparc */ 9377c478bd9Sstevel@tonic-gate 9387c478bd9Sstevel@tonic-gate /* 9397c478bd9Sstevel@tonic-gate * Look up the root device via devfs so that a dv_node is 9407c478bd9Sstevel@tonic-gate * created for it. The vnode is never VN_RELE()ed. 9417c478bd9Sstevel@tonic-gate * We allocate more than MAXPATHLEN so that the 9427c478bd9Sstevel@tonic-gate * buffer passed to i_ddi_prompath_to_devfspath() is 9437c478bd9Sstevel@tonic-gate * exactly MAXPATHLEN (the function expects a buffer 9447c478bd9Sstevel@tonic-gate * of that length). 9457c478bd9Sstevel@tonic-gate */ 9467c478bd9Sstevel@tonic-gate plen = strlen("/devices"); 9477c478bd9Sstevel@tonic-gate path = kmem_alloc(plen + MAXPATHLEN, KM_SLEEP); 9487c478bd9Sstevel@tonic-gate (void) strcpy(path, "/devices"); 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate if (i_ddi_prompath_to_devfspath(rootfs.bo_name, path + plen) 9517c478bd9Sstevel@tonic-gate != DDI_SUCCESS || 9527c478bd9Sstevel@tonic-gate lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &rvp)) { 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate /* NUL terminate in case "path" has garbage */ 9557c478bd9Sstevel@tonic-gate path[plen + MAXPATHLEN - 1] = '\0'; 9567c478bd9Sstevel@tonic-gate #ifdef DEBUG 9577c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!Cannot lookup root device: %s", path); 9587c478bd9Sstevel@tonic-gate #endif 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate kmem_free(path, plen + MAXPATHLEN); 961df2381bfSpraks vfs_mnttabvp_setup(); 9627c478bd9Sstevel@tonic-gate } 9637c478bd9Sstevel@tonic-gate 964fcad04f7Sevanl /* 965fcad04f7Sevanl * If remount failed and we're in a zone we need to check for the zone 966fcad04f7Sevanl * root path and strip it before the call to vfs_setpath(). 967fcad04f7Sevanl * 968fcad04f7Sevanl * If strpath doesn't begin with the zone_rootpath the original 969fcad04f7Sevanl * strpath is returned unchanged. 970fcad04f7Sevanl */ 971fcad04f7Sevanl static const char * 972fcad04f7Sevanl stripzonepath(const char *strpath) 973fcad04f7Sevanl { 974fcad04f7Sevanl char *str1, *str2; 975fcad04f7Sevanl int i; 976fcad04f7Sevanl zone_t *zonep = curproc->p_zone; 977fcad04f7Sevanl 978fcad04f7Sevanl if (zonep->zone_rootpath == NULL || strpath == NULL) { 979fcad04f7Sevanl return (NULL); 980fcad04f7Sevanl } 981fcad04f7Sevanl 982fcad04f7Sevanl /* 983fcad04f7Sevanl * we check for the end of the string at one past the 984fcad04f7Sevanl * current position because the zone_rootpath always 985fcad04f7Sevanl * ends with "/" but we don't want to strip that off. 986fcad04f7Sevanl */ 987fcad04f7Sevanl str1 = zonep->zone_rootpath; 988fcad04f7Sevanl str2 = (char *)strpath; 989fcad04f7Sevanl ASSERT(str1[0] != '\0'); 990fcad04f7Sevanl for (i = 0; str1[i + 1] != '\0'; i++) { 991fcad04f7Sevanl if (str1[i] != str2[i]) 992fcad04f7Sevanl return ((char *)strpath); 993fcad04f7Sevanl } 994fcad04f7Sevanl return (&str2[i]); 995fcad04f7Sevanl } 996fcad04f7Sevanl 99793239addSjohnlev /* 99893239addSjohnlev * Check to see if our "block device" is actually a file. If so, 99993239addSjohnlev * automatically add a lofi device, and keep track of this fact. 100093239addSjohnlev */ 100193239addSjohnlev static int 100293239addSjohnlev lofi_add(const char *fsname, struct vfs *vfsp, 100393239addSjohnlev mntopts_t *mntopts, struct mounta *uap) 100493239addSjohnlev { 100593239addSjohnlev int fromspace = (uap->flags & MS_SYSSPACE) ? 100693239addSjohnlev UIO_SYSSPACE : UIO_USERSPACE; 100793239addSjohnlev struct lofi_ioctl *li = NULL; 100893239addSjohnlev struct vnode *vp = NULL; 100993239addSjohnlev struct pathname pn = { NULL }; 101093239addSjohnlev ldi_ident_t ldi_id; 101193239addSjohnlev ldi_handle_t ldi_hdl; 101243d5cd3dSjohnlev vfssw_t *vfssw; 101393239addSjohnlev int minor; 101493239addSjohnlev int err = 0; 101593239addSjohnlev 1016*0fbb751dSJohn Levon if ((vfssw = vfs_getvfssw(fsname)) == NULL) 101793239addSjohnlev return (0); 101843d5cd3dSjohnlev 101943d5cd3dSjohnlev if (!(vfssw->vsw_flag & VSW_CANLOFI)) { 102043d5cd3dSjohnlev vfs_unrefvfssw(vfssw); 102193239addSjohnlev return (0); 102243d5cd3dSjohnlev } 102343d5cd3dSjohnlev 102443d5cd3dSjohnlev vfs_unrefvfssw(vfssw); 102543d5cd3dSjohnlev vfssw = NULL; 102693239addSjohnlev 102793239addSjohnlev if (pn_get(uap->spec, fromspace, &pn) != 0) 102893239addSjohnlev return (0); 102993239addSjohnlev 103093239addSjohnlev if (lookupname(uap->spec, fromspace, FOLLOW, NULL, &vp) != 0) 103193239addSjohnlev goto out; 103293239addSjohnlev 103393239addSjohnlev if (vp->v_type != VREG) 103493239addSjohnlev goto out; 103593239addSjohnlev 103693239addSjohnlev /* OK, this is a lofi mount. */ 103793239addSjohnlev 103893239addSjohnlev if ((uap->flags & (MS_REMOUNT|MS_GLOBAL)) || 103993239addSjohnlev vfs_optionisset_nolock(mntopts, MNTOPT_SUID, NULL) || 104093239addSjohnlev vfs_optionisset_nolock(mntopts, MNTOPT_SETUID, NULL) || 104193239addSjohnlev vfs_optionisset_nolock(mntopts, MNTOPT_DEVICES, NULL)) { 104293239addSjohnlev err = EINVAL; 104393239addSjohnlev goto out; 104493239addSjohnlev } 104593239addSjohnlev 104693239addSjohnlev ldi_id = ldi_ident_from_anon(); 104793239addSjohnlev li = kmem_zalloc(sizeof (*li), KM_SLEEP); 10486f02aa44SDina K Nimeh (void) strlcpy(li->li_filename, pn.pn_path, MAXPATHLEN); 104993239addSjohnlev 1050*0fbb751dSJohn Levon err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred, 1051*0fbb751dSJohn Levon &ldi_hdl, ldi_id); 105293239addSjohnlev 105393239addSjohnlev if (err) 105493239addSjohnlev goto out2; 105593239addSjohnlev 105693239addSjohnlev err = ldi_ioctl(ldi_hdl, LOFI_MAP_FILE, (intptr_t)li, 1057*0fbb751dSJohn Levon FREAD | FWRITE | FKIOCTL, kcred, &minor); 105893239addSjohnlev 1059*0fbb751dSJohn Levon (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred); 106093239addSjohnlev 106193239addSjohnlev if (!err) 106293239addSjohnlev vfsp->vfs_lofi_minor = minor; 106393239addSjohnlev 106493239addSjohnlev out2: 106593239addSjohnlev ldi_ident_release(ldi_id); 106693239addSjohnlev out: 106793239addSjohnlev if (li != NULL) 106893239addSjohnlev kmem_free(li, sizeof (*li)); 106993239addSjohnlev if (vp != NULL) 107093239addSjohnlev VN_RELE(vp); 107193239addSjohnlev pn_free(&pn); 107293239addSjohnlev return (err); 107393239addSjohnlev } 107493239addSjohnlev 107593239addSjohnlev static void 107693239addSjohnlev lofi_remove(struct vfs *vfsp) 107793239addSjohnlev { 107893239addSjohnlev struct lofi_ioctl *li = NULL; 107993239addSjohnlev ldi_ident_t ldi_id; 108093239addSjohnlev ldi_handle_t ldi_hdl; 108193239addSjohnlev int err; 108293239addSjohnlev 108393239addSjohnlev if (vfsp->vfs_lofi_minor == 0) 108493239addSjohnlev return; 108593239addSjohnlev 108693239addSjohnlev ldi_id = ldi_ident_from_anon(); 108793239addSjohnlev 108893239addSjohnlev li = kmem_zalloc(sizeof (*li), KM_SLEEP); 108993239addSjohnlev li->li_minor = vfsp->vfs_lofi_minor; 109093239addSjohnlev li->li_cleanup = B_TRUE; 109193239addSjohnlev 1092*0fbb751dSJohn Levon err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred, 1093*0fbb751dSJohn Levon &ldi_hdl, ldi_id); 109493239addSjohnlev 109593239addSjohnlev if (err) 109693239addSjohnlev goto out; 109793239addSjohnlev 109893239addSjohnlev err = ldi_ioctl(ldi_hdl, LOFI_UNMAP_FILE_MINOR, (intptr_t)li, 1099*0fbb751dSJohn Levon FREAD | FWRITE | FKIOCTL, kcred, NULL); 110093239addSjohnlev 1101*0fbb751dSJohn Levon (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred); 110293239addSjohnlev 110393239addSjohnlev if (!err) 110493239addSjohnlev vfsp->vfs_lofi_minor = 0; 110593239addSjohnlev 110693239addSjohnlev out: 110793239addSjohnlev ldi_ident_release(ldi_id); 110893239addSjohnlev if (li != NULL) 110993239addSjohnlev kmem_free(li, sizeof (*li)); 111093239addSjohnlev } 111193239addSjohnlev 11127c478bd9Sstevel@tonic-gate /* 11137c478bd9Sstevel@tonic-gate * Common mount code. Called from the system call entry point, from autofs, 1114b9238976Sth * nfsv4 trigger mounts, and from pxfs. 11157c478bd9Sstevel@tonic-gate * 11167c478bd9Sstevel@tonic-gate * Takes the effective file system type, mount arguments, the mount point 11177c478bd9Sstevel@tonic-gate * vnode, flags specifying whether the mount is a remount and whether it 11187c478bd9Sstevel@tonic-gate * should be entered into the vfs list, and credentials. Fills in its vfspp 11197c478bd9Sstevel@tonic-gate * parameter with the mounted file system instance's vfs. 11207c478bd9Sstevel@tonic-gate * 11217c478bd9Sstevel@tonic-gate * Note that the effective file system type is specified as a string. It may 11227c478bd9Sstevel@tonic-gate * be null, in which case it's determined from the mount arguments, and may 11237c478bd9Sstevel@tonic-gate * differ from the type specified in the mount arguments; this is a hook to 11247c478bd9Sstevel@tonic-gate * allow interposition when instantiating file system instances. 11257c478bd9Sstevel@tonic-gate * 11267c478bd9Sstevel@tonic-gate * The caller is responsible for releasing its own hold on the mount point 11277c478bd9Sstevel@tonic-gate * vp (this routine does its own hold when necessary). 11287c478bd9Sstevel@tonic-gate * Also note that for remounts, the mount point vp should be the vnode for 11297c478bd9Sstevel@tonic-gate * the root of the file system rather than the vnode that the file system 11307c478bd9Sstevel@tonic-gate * is mounted on top of. 11317c478bd9Sstevel@tonic-gate */ 11327c478bd9Sstevel@tonic-gate int 11337c478bd9Sstevel@tonic-gate domount(char *fsname, struct mounta *uap, vnode_t *vp, struct cred *credp, 11347c478bd9Sstevel@tonic-gate struct vfs **vfspp) 11357c478bd9Sstevel@tonic-gate { 11367c478bd9Sstevel@tonic-gate struct vfssw *vswp; 11377c478bd9Sstevel@tonic-gate vfsops_t *vfsops; 11387c478bd9Sstevel@tonic-gate struct vfs *vfsp; 11397c478bd9Sstevel@tonic-gate struct vnode *bvp; 11407c478bd9Sstevel@tonic-gate dev_t bdev = 0; 11417c478bd9Sstevel@tonic-gate mntopts_t mnt_mntopts; 11427c478bd9Sstevel@tonic-gate int error = 0; 11437c478bd9Sstevel@tonic-gate int copyout_error = 0; 11447c478bd9Sstevel@tonic-gate int ovflags; 11457c478bd9Sstevel@tonic-gate char *opts = uap->optptr; 11467c478bd9Sstevel@tonic-gate char *inargs = opts; 11477c478bd9Sstevel@tonic-gate int optlen = uap->optlen; 11487c478bd9Sstevel@tonic-gate int remount; 11497c478bd9Sstevel@tonic-gate int rdonly; 11507c478bd9Sstevel@tonic-gate int nbmand = 0; 11517c478bd9Sstevel@tonic-gate int delmip = 0; 11527c478bd9Sstevel@tonic-gate int addmip = 0; 11537c478bd9Sstevel@tonic-gate int splice = ((uap->flags & MS_NOSPLICE) == 0); 11547c478bd9Sstevel@tonic-gate int fromspace = (uap->flags & MS_SYSSPACE) ? 1155b1b8ab34Slling UIO_SYSSPACE : UIO_USERSPACE; 11567c478bd9Sstevel@tonic-gate char *resource = NULL, *mountpt = NULL; 11577c478bd9Sstevel@tonic-gate refstr_t *oldresource, *oldmntpt; 11587c478bd9Sstevel@tonic-gate struct pathname pn, rpn; 115982c7f3c4Srsb vsk_anchor_t *vskap; 116093239addSjohnlev char fstname[FSTYPSZ]; 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate /* 11637c478bd9Sstevel@tonic-gate * The v_flag value for the mount point vp is permanently set 11647c478bd9Sstevel@tonic-gate * to VVFSLOCK so that no one bypasses the vn_vfs*locks routine 11657c478bd9Sstevel@tonic-gate * for mount point locking. 11667c478bd9Sstevel@tonic-gate */ 11677c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 11687c478bd9Sstevel@tonic-gate vp->v_flag |= VVFSLOCK; 11697c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate mnt_mntopts.mo_count = 0; 11727c478bd9Sstevel@tonic-gate /* 11737c478bd9Sstevel@tonic-gate * Find the ops vector to use to invoke the file system-specific mount 11747c478bd9Sstevel@tonic-gate * method. If the fsname argument is non-NULL, use it directly. 11757c478bd9Sstevel@tonic-gate * Otherwise, dig the file system type information out of the mount 11767c478bd9Sstevel@tonic-gate * arguments. 11777c478bd9Sstevel@tonic-gate * 11787c478bd9Sstevel@tonic-gate * A side effect is to hold the vfssw entry. 11797c478bd9Sstevel@tonic-gate * 11807c478bd9Sstevel@tonic-gate * Mount arguments can be specified in several ways, which are 11817c478bd9Sstevel@tonic-gate * distinguished by flag bit settings. The preferred way is to set 11827c478bd9Sstevel@tonic-gate * MS_OPTIONSTR, indicating an 8 argument mount with the file system 11837c478bd9Sstevel@tonic-gate * type supplied as a character string and the last two arguments 11847c478bd9Sstevel@tonic-gate * being a pointer to a character buffer and the size of the buffer. 11857c478bd9Sstevel@tonic-gate * On entry, the buffer holds a null terminated list of options; on 11867c478bd9Sstevel@tonic-gate * return, the string is the list of options the file system 11877c478bd9Sstevel@tonic-gate * recognized. If MS_DATA is set arguments five and six point to a 11887c478bd9Sstevel@tonic-gate * block of binary data which the file system interprets. 11897c478bd9Sstevel@tonic-gate * A further wrinkle is that some callers don't set MS_FSS and MS_DATA 11907c478bd9Sstevel@tonic-gate * consistently with these conventions. To handle them, we check to 11917c478bd9Sstevel@tonic-gate * see whether the pointer to the file system name has a numeric value 11927c478bd9Sstevel@tonic-gate * less than 256. If so, we treat it as an index. 11937c478bd9Sstevel@tonic-gate */ 11947c478bd9Sstevel@tonic-gate if (fsname != NULL) { 11957c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfssw(fsname)) == NULL) { 11967c478bd9Sstevel@tonic-gate return (EINVAL); 11977c478bd9Sstevel@tonic-gate } 11987c478bd9Sstevel@tonic-gate } else if (uap->flags & (MS_OPTIONSTR | MS_DATA | MS_FSS)) { 11997c478bd9Sstevel@tonic-gate size_t n; 12007c478bd9Sstevel@tonic-gate uint_t fstype; 120193239addSjohnlev 120293239addSjohnlev fsname = fstname; 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate if ((fstype = (uintptr_t)uap->fstype) < 256) { 12057c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 12067c478bd9Sstevel@tonic-gate if (fstype == 0 || fstype >= nfstype || 12077c478bd9Sstevel@tonic-gate !ALLOCATED_VFSSW(&vfssw[fstype])) { 12087c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 12097c478bd9Sstevel@tonic-gate return (EINVAL); 12107c478bd9Sstevel@tonic-gate } 121193239addSjohnlev (void) strcpy(fsname, vfssw[fstype].vsw_name); 12127c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 121393239addSjohnlev if ((vswp = vfs_getvfssw(fsname)) == NULL) 12147c478bd9Sstevel@tonic-gate return (EINVAL); 12157c478bd9Sstevel@tonic-gate } else { 12167c478bd9Sstevel@tonic-gate /* 12177c478bd9Sstevel@tonic-gate * Handle either kernel or user address space. 12187c478bd9Sstevel@tonic-gate */ 12197c478bd9Sstevel@tonic-gate if (uap->flags & MS_SYSSPACE) { 122093239addSjohnlev error = copystr(uap->fstype, fsname, 12217c478bd9Sstevel@tonic-gate FSTYPSZ, &n); 12227c478bd9Sstevel@tonic-gate } else { 122393239addSjohnlev error = copyinstr(uap->fstype, fsname, 12247c478bd9Sstevel@tonic-gate FSTYPSZ, &n); 12257c478bd9Sstevel@tonic-gate } 12267c478bd9Sstevel@tonic-gate if (error) { 12277c478bd9Sstevel@tonic-gate if (error == ENAMETOOLONG) 12287c478bd9Sstevel@tonic-gate return (EINVAL); 12297c478bd9Sstevel@tonic-gate return (error); 12307c478bd9Sstevel@tonic-gate } 123193239addSjohnlev if ((vswp = vfs_getvfssw(fsname)) == NULL) 12327c478bd9Sstevel@tonic-gate return (EINVAL); 12337c478bd9Sstevel@tonic-gate } 12347c478bd9Sstevel@tonic-gate } else { 12357c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) == NULL) 12367c478bd9Sstevel@tonic-gate return (EINVAL); 1237*0fbb751dSJohn Levon fsname = vswp->vsw_name; 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate if (!VFS_INSTALLED(vswp)) 12407c478bd9Sstevel@tonic-gate return (EINVAL); 1241*0fbb751dSJohn Levon 1242*0fbb751dSJohn Levon if ((error = secpolicy_fs_allowed_mount(fsname)) != 0) { 1243*0fbb751dSJohn Levon vfs_unrefvfssw(vswp); 1244*0fbb751dSJohn Levon return (error); 1245*0fbb751dSJohn Levon } 1246*0fbb751dSJohn Levon 12477c478bd9Sstevel@tonic-gate vfsops = &vswp->vsw_vfsops; 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate vfs_copyopttbl(&vswp->vsw_optproto, &mnt_mntopts); 12507c478bd9Sstevel@tonic-gate /* 12517c478bd9Sstevel@tonic-gate * Fetch mount options and parse them for generic vfs options 12527c478bd9Sstevel@tonic-gate */ 12537c478bd9Sstevel@tonic-gate if (uap->flags & MS_OPTIONSTR) { 12547c478bd9Sstevel@tonic-gate /* 12557c478bd9Sstevel@tonic-gate * Limit the buffer size 12567c478bd9Sstevel@tonic-gate */ 12577c478bd9Sstevel@tonic-gate if (optlen < 0 || optlen > MAX_MNTOPT_STR) { 12587c478bd9Sstevel@tonic-gate error = EINVAL; 12597c478bd9Sstevel@tonic-gate goto errout; 12607c478bd9Sstevel@tonic-gate } 12617c478bd9Sstevel@tonic-gate if ((uap->flags & MS_SYSSPACE) == 0) { 12627c478bd9Sstevel@tonic-gate inargs = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP); 12637c478bd9Sstevel@tonic-gate inargs[0] = '\0'; 12647c478bd9Sstevel@tonic-gate if (optlen) { 12657c478bd9Sstevel@tonic-gate error = copyinstr(opts, inargs, (size_t)optlen, 1266b1b8ab34Slling NULL); 12677c478bd9Sstevel@tonic-gate if (error) { 12687c478bd9Sstevel@tonic-gate goto errout; 12697c478bd9Sstevel@tonic-gate } 12707c478bd9Sstevel@tonic-gate } 12717c478bd9Sstevel@tonic-gate } 12727c478bd9Sstevel@tonic-gate vfs_parsemntopts(&mnt_mntopts, inargs, 0); 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate /* 12757c478bd9Sstevel@tonic-gate * Flag bits override the options string. 12767c478bd9Sstevel@tonic-gate */ 12777c478bd9Sstevel@tonic-gate if (uap->flags & MS_REMOUNT) 12787c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_REMOUNT, NULL, 0, 0); 12797c478bd9Sstevel@tonic-gate if (uap->flags & MS_RDONLY) 12807c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_RO, NULL, 0, 0); 12817c478bd9Sstevel@tonic-gate if (uap->flags & MS_NOSUID) 12827c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0); 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate /* 12857c478bd9Sstevel@tonic-gate * Check if this is a remount; must be set in the option string and 12867c478bd9Sstevel@tonic-gate * the file system must support a remount option. 12877c478bd9Sstevel@tonic-gate */ 12887c478bd9Sstevel@tonic-gate if (remount = vfs_optionisset_nolock(&mnt_mntopts, 12897c478bd9Sstevel@tonic-gate MNTOPT_REMOUNT, NULL)) { 12907c478bd9Sstevel@tonic-gate if (!(vswp->vsw_flag & VSW_CANREMOUNT)) { 12917c478bd9Sstevel@tonic-gate error = ENOTSUP; 12927c478bd9Sstevel@tonic-gate goto errout; 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate uap->flags |= MS_REMOUNT; 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate 12977c478bd9Sstevel@tonic-gate /* 12987c478bd9Sstevel@tonic-gate * uap->flags and vfs_optionisset() should agree. 12997c478bd9Sstevel@tonic-gate */ 13007c478bd9Sstevel@tonic-gate if (rdonly = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_RO, NULL)) { 13017c478bd9Sstevel@tonic-gate uap->flags |= MS_RDONLY; 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate if (vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL)) { 13047c478bd9Sstevel@tonic-gate uap->flags |= MS_NOSUID; 13057c478bd9Sstevel@tonic-gate } 13067c478bd9Sstevel@tonic-gate nbmand = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NBMAND, NULL); 13077c478bd9Sstevel@tonic-gate ASSERT(splice || !remount); 13087c478bd9Sstevel@tonic-gate /* 13097c478bd9Sstevel@tonic-gate * If we are splicing the fs into the namespace, 13107c478bd9Sstevel@tonic-gate * perform mount point checks. 13117c478bd9Sstevel@tonic-gate * 13127c478bd9Sstevel@tonic-gate * We want to resolve the path for the mount point to eliminate 13137c478bd9Sstevel@tonic-gate * '.' and ".." and symlinks in mount points; we can't do the 13147c478bd9Sstevel@tonic-gate * same for the resource string, since it would turn 13157c478bd9Sstevel@tonic-gate * "/dev/dsk/c0t0d0s0" into "/devices/pci@...". We need to do 13167c478bd9Sstevel@tonic-gate * this before grabbing vn_vfswlock(), because otherwise we 13177c478bd9Sstevel@tonic-gate * would deadlock with lookuppn(). 13187c478bd9Sstevel@tonic-gate */ 13197c478bd9Sstevel@tonic-gate if (splice) { 13207c478bd9Sstevel@tonic-gate ASSERT(vp->v_count > 0); 13217c478bd9Sstevel@tonic-gate 13227c478bd9Sstevel@tonic-gate /* 13237c478bd9Sstevel@tonic-gate * Pick up mount point and device from appropriate space. 13247c478bd9Sstevel@tonic-gate */ 13257c478bd9Sstevel@tonic-gate if (pn_get(uap->spec, fromspace, &pn) == 0) { 13267c478bd9Sstevel@tonic-gate resource = kmem_alloc(pn.pn_pathlen + 1, 13277c478bd9Sstevel@tonic-gate KM_SLEEP); 13287c478bd9Sstevel@tonic-gate (void) strcpy(resource, pn.pn_path); 13297c478bd9Sstevel@tonic-gate pn_free(&pn); 13307c478bd9Sstevel@tonic-gate } 13317c478bd9Sstevel@tonic-gate /* 13327c478bd9Sstevel@tonic-gate * Do a lookupname prior to taking the 13337c478bd9Sstevel@tonic-gate * writelock. Mark this as completed if 13347c478bd9Sstevel@tonic-gate * successful for later cleanup and addition to 13357c478bd9Sstevel@tonic-gate * the mount in progress table. 13367c478bd9Sstevel@tonic-gate */ 13377c478bd9Sstevel@tonic-gate if ((uap->flags & MS_GLOBAL) == 0 && 13387c478bd9Sstevel@tonic-gate lookupname(uap->spec, fromspace, 1339b1b8ab34Slling FOLLOW, NULL, &bvp) == 0) { 13407c478bd9Sstevel@tonic-gate addmip = 1; 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate if ((error = pn_get(uap->dir, fromspace, &pn)) == 0) { 13447c478bd9Sstevel@tonic-gate pathname_t *pnp; 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate if (*pn.pn_path != '/') { 13477c478bd9Sstevel@tonic-gate error = EINVAL; 13487c478bd9Sstevel@tonic-gate pn_free(&pn); 13497c478bd9Sstevel@tonic-gate goto errout; 13507c478bd9Sstevel@tonic-gate } 13517c478bd9Sstevel@tonic-gate pn_alloc(&rpn); 13527c478bd9Sstevel@tonic-gate /* 13537c478bd9Sstevel@tonic-gate * Kludge to prevent autofs from deadlocking with 13547c478bd9Sstevel@tonic-gate * itself when it calls domount(). 13557c478bd9Sstevel@tonic-gate * 13567c478bd9Sstevel@tonic-gate * If autofs is calling, it is because it is doing 13577c478bd9Sstevel@tonic-gate * (autofs) mounts in the process of an NFS mount. A 13587c478bd9Sstevel@tonic-gate * lookuppn() here would cause us to block waiting for 13597c478bd9Sstevel@tonic-gate * said NFS mount to complete, which can't since this 13607c478bd9Sstevel@tonic-gate * is the thread that was supposed to doing it. 13617c478bd9Sstevel@tonic-gate */ 13627c478bd9Sstevel@tonic-gate if (fromspace == UIO_USERSPACE) { 13637c478bd9Sstevel@tonic-gate if ((error = lookuppn(&pn, &rpn, FOLLOW, NULL, 13647c478bd9Sstevel@tonic-gate NULL)) == 0) { 13657c478bd9Sstevel@tonic-gate pnp = &rpn; 13667c478bd9Sstevel@tonic-gate } else { 13677c478bd9Sstevel@tonic-gate /* 13687c478bd9Sstevel@tonic-gate * The file disappeared or otherwise 13697c478bd9Sstevel@tonic-gate * became inaccessible since we opened 13707c478bd9Sstevel@tonic-gate * it; might as well fail the mount 13717c478bd9Sstevel@tonic-gate * since the mount point is no longer 13727c478bd9Sstevel@tonic-gate * accessible. 13737c478bd9Sstevel@tonic-gate */ 13747c478bd9Sstevel@tonic-gate pn_free(&rpn); 13757c478bd9Sstevel@tonic-gate pn_free(&pn); 13767c478bd9Sstevel@tonic-gate goto errout; 13777c478bd9Sstevel@tonic-gate } 13787c478bd9Sstevel@tonic-gate } else { 13797c478bd9Sstevel@tonic-gate pnp = &pn; 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate mountpt = kmem_alloc(pnp->pn_pathlen + 1, KM_SLEEP); 13827c478bd9Sstevel@tonic-gate (void) strcpy(mountpt, pnp->pn_path); 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate /* 13857c478bd9Sstevel@tonic-gate * If the addition of the zone's rootpath 13867c478bd9Sstevel@tonic-gate * would push us over a total path length 13877c478bd9Sstevel@tonic-gate * of MAXPATHLEN, we fail the mount with 13887c478bd9Sstevel@tonic-gate * ENAMETOOLONG, which is what we would have 13897c478bd9Sstevel@tonic-gate * gotten if we were trying to perform the same 13907c478bd9Sstevel@tonic-gate * mount in the global zone. 13917c478bd9Sstevel@tonic-gate * 13927c478bd9Sstevel@tonic-gate * strlen() doesn't count the trailing 13937c478bd9Sstevel@tonic-gate * '\0', but zone_rootpathlen counts both a 13947c478bd9Sstevel@tonic-gate * trailing '/' and the terminating '\0'. 13957c478bd9Sstevel@tonic-gate */ 13967c478bd9Sstevel@tonic-gate if ((curproc->p_zone->zone_rootpathlen - 1 + 13977c478bd9Sstevel@tonic-gate strlen(mountpt)) > MAXPATHLEN || 13987c478bd9Sstevel@tonic-gate (resource != NULL && 13997c478bd9Sstevel@tonic-gate (curproc->p_zone->zone_rootpathlen - 1 + 14007c478bd9Sstevel@tonic-gate strlen(resource)) > MAXPATHLEN)) { 14017c478bd9Sstevel@tonic-gate error = ENAMETOOLONG; 14027c478bd9Sstevel@tonic-gate } 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate pn_free(&rpn); 14057c478bd9Sstevel@tonic-gate pn_free(&pn); 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate if (error) 14097c478bd9Sstevel@tonic-gate goto errout; 14107c478bd9Sstevel@tonic-gate 14117c478bd9Sstevel@tonic-gate /* 14127c478bd9Sstevel@tonic-gate * Prevent path name resolution from proceeding past 14137c478bd9Sstevel@tonic-gate * the mount point. 14147c478bd9Sstevel@tonic-gate */ 14157c478bd9Sstevel@tonic-gate if (vn_vfswlock(vp) != 0) { 14167c478bd9Sstevel@tonic-gate error = EBUSY; 14177c478bd9Sstevel@tonic-gate goto errout; 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate /* 14217c478bd9Sstevel@tonic-gate * Verify that it's legitimate to establish a mount on 14227c478bd9Sstevel@tonic-gate * the prospective mount point. 14237c478bd9Sstevel@tonic-gate */ 14247c478bd9Sstevel@tonic-gate if (vn_mountedvfs(vp) != NULL) { 14257c478bd9Sstevel@tonic-gate /* 14267c478bd9Sstevel@tonic-gate * The mount point lock was obtained after some 14277c478bd9Sstevel@tonic-gate * other thread raced through and established a mount. 14287c478bd9Sstevel@tonic-gate */ 14297c478bd9Sstevel@tonic-gate vn_vfsunlock(vp); 14307c478bd9Sstevel@tonic-gate error = EBUSY; 14317c478bd9Sstevel@tonic-gate goto errout; 14327c478bd9Sstevel@tonic-gate } 14337c478bd9Sstevel@tonic-gate if (vp->v_flag & VNOMOUNT) { 14347c478bd9Sstevel@tonic-gate vn_vfsunlock(vp); 14357c478bd9Sstevel@tonic-gate error = EINVAL; 14367c478bd9Sstevel@tonic-gate goto errout; 14377c478bd9Sstevel@tonic-gate } 14387c478bd9Sstevel@tonic-gate } 14397c478bd9Sstevel@tonic-gate if ((uap->flags & (MS_DATA | MS_OPTIONSTR)) == 0) { 14407c478bd9Sstevel@tonic-gate uap->dataptr = NULL; 14417c478bd9Sstevel@tonic-gate uap->datalen = 0; 14427c478bd9Sstevel@tonic-gate } 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate /* 14457c478bd9Sstevel@tonic-gate * If this is a remount, we don't want to create a new VFS. 14467c478bd9Sstevel@tonic-gate * Instead, we pass the existing one with a remount flag. 14477c478bd9Sstevel@tonic-gate */ 14487c478bd9Sstevel@tonic-gate if (remount) { 14497c478bd9Sstevel@tonic-gate /* 14507c478bd9Sstevel@tonic-gate * Confirm that the mount point is the root vnode of the 14517c478bd9Sstevel@tonic-gate * file system that is being remounted. 14527c478bd9Sstevel@tonic-gate * This can happen if the user specifies a different 14537c478bd9Sstevel@tonic-gate * mount point directory pathname in the (re)mount command. 14547c478bd9Sstevel@tonic-gate * 14557c478bd9Sstevel@tonic-gate * Code below can only be reached if splice is true, so it's 14567c478bd9Sstevel@tonic-gate * safe to do vn_vfsunlock() here. 14577c478bd9Sstevel@tonic-gate */ 14587c478bd9Sstevel@tonic-gate if ((vp->v_flag & VROOT) == 0) { 14597c478bd9Sstevel@tonic-gate vn_vfsunlock(vp); 14607c478bd9Sstevel@tonic-gate error = ENOENT; 14617c478bd9Sstevel@tonic-gate goto errout; 14627c478bd9Sstevel@tonic-gate } 14637c478bd9Sstevel@tonic-gate /* 14647c478bd9Sstevel@tonic-gate * Disallow making file systems read-only unless file system 14657c478bd9Sstevel@tonic-gate * explicitly allows it in its vfssw. Ignore other flags. 14667c478bd9Sstevel@tonic-gate */ 14677c478bd9Sstevel@tonic-gate if (rdonly && vn_is_readonly(vp) == 0 && 14687c478bd9Sstevel@tonic-gate (vswp->vsw_flag & VSW_CANRWRO) == 0) { 14697c478bd9Sstevel@tonic-gate vn_vfsunlock(vp); 14707c478bd9Sstevel@tonic-gate error = EINVAL; 14717c478bd9Sstevel@tonic-gate goto errout; 14727c478bd9Sstevel@tonic-gate } 14737c478bd9Sstevel@tonic-gate /* 1474da6c28aaSamw * Disallow changing the NBMAND disposition of the file 1475da6c28aaSamw * system on remounts. 14767c478bd9Sstevel@tonic-gate */ 14777c478bd9Sstevel@tonic-gate if ((nbmand && ((vp->v_vfsp->vfs_flag & VFS_NBMAND) == 0)) || 14787c478bd9Sstevel@tonic-gate (!nbmand && (vp->v_vfsp->vfs_flag & VFS_NBMAND))) { 1479da6c28aaSamw vn_vfsunlock(vp); 1480da6c28aaSamw error = EINVAL; 1481da6c28aaSamw goto errout; 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 14847c478bd9Sstevel@tonic-gate ovflags = vfsp->vfs_flag; 14857c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_REMOUNT; 14867c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_RDONLY; 14877c478bd9Sstevel@tonic-gate } else { 1488da6c28aaSamw vfsp = vfs_alloc(KM_SLEEP); 14897c478bd9Sstevel@tonic-gate VFS_INIT(vfsp, vfsops, NULL); 14907c478bd9Sstevel@tonic-gate } 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); 14937c478bd9Sstevel@tonic-gate 149493239addSjohnlev if ((error = lofi_add(fsname, vfsp, &mnt_mntopts, uap)) != 0) { 149593239addSjohnlev if (!remount) { 149693239addSjohnlev if (splice) 149793239addSjohnlev vn_vfsunlock(vp); 149893239addSjohnlev vfs_free(vfsp); 149993239addSjohnlev } else { 150093239addSjohnlev vn_vfsunlock(vp); 150193239addSjohnlev VFS_RELE(vfsp); 150293239addSjohnlev } 150393239addSjohnlev goto errout; 150493239addSjohnlev } 150593239addSjohnlev 150693239addSjohnlev /* 150793239addSjohnlev * PRIV_SYS_MOUNT doesn't mean you can become root. 150893239addSjohnlev */ 150993239addSjohnlev if (vfsp->vfs_lofi_minor != 0) { 151093239addSjohnlev uap->flags |= MS_NOSUID; 151193239addSjohnlev vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0); 151293239addSjohnlev } 151393239addSjohnlev 15147c478bd9Sstevel@tonic-gate /* 15157c478bd9Sstevel@tonic-gate * The vfs_reflock is not used anymore the code below explicitly 15167c478bd9Sstevel@tonic-gate * holds it preventing others accesing it directly. 15177c478bd9Sstevel@tonic-gate */ 15187c478bd9Sstevel@tonic-gate if ((sema_tryp(&vfsp->vfs_reflock) == 0) && 15197c478bd9Sstevel@tonic-gate !(vfsp->vfs_flag & VFS_REMOUNT)) 15207c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 1521ae115bc7Smrj "mount type %s couldn't get vfs_reflock", vswp->vsw_name); 15227c478bd9Sstevel@tonic-gate 15237c478bd9Sstevel@tonic-gate /* 15247c478bd9Sstevel@tonic-gate * Lock the vfs. If this is a remount we want to avoid spurious umount 15257c478bd9Sstevel@tonic-gate * failures that happen as a side-effect of fsflush() and other mount 15267c478bd9Sstevel@tonic-gate * and unmount operations that might be going on simultaneously and 15277c478bd9Sstevel@tonic-gate * may have locked the vfs currently. To not return EBUSY immediately 15287c478bd9Sstevel@tonic-gate * here we use vfs_lock_wait() instead vfs_lock() for the remount case. 15297c478bd9Sstevel@tonic-gate */ 15307c478bd9Sstevel@tonic-gate if (!remount) { 15317c478bd9Sstevel@tonic-gate if (error = vfs_lock(vfsp)) { 15327c478bd9Sstevel@tonic-gate vfsp->vfs_flag = ovflags; 153393239addSjohnlev 153493239addSjohnlev lofi_remove(vfsp); 153593239addSjohnlev 15367c478bd9Sstevel@tonic-gate if (splice) 15377c478bd9Sstevel@tonic-gate vn_vfsunlock(vp); 1538da6c28aaSamw vfs_free(vfsp); 15397c478bd9Sstevel@tonic-gate goto errout; 15407c478bd9Sstevel@tonic-gate } 15417c478bd9Sstevel@tonic-gate } else { 15427c478bd9Sstevel@tonic-gate vfs_lock_wait(vfsp); 15437c478bd9Sstevel@tonic-gate } 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate /* 15467c478bd9Sstevel@tonic-gate * Add device to mount in progress table, global mounts require special 15477c478bd9Sstevel@tonic-gate * handling. It is possible that we have already done the lookupname 15487c478bd9Sstevel@tonic-gate * on a spliced, non-global fs. If so, we don't want to do it again 15497c478bd9Sstevel@tonic-gate * since we cannot do a lookupname after taking the 15507c478bd9Sstevel@tonic-gate * wlock above. This case is for a non-spliced, non-global filesystem. 15517c478bd9Sstevel@tonic-gate */ 15527c478bd9Sstevel@tonic-gate if (!addmip) { 1553b1b8ab34Slling if ((uap->flags & MS_GLOBAL) == 0 && 1554b1b8ab34Slling lookupname(uap->spec, fromspace, FOLLOW, NULL, &bvp) == 0) { 15557c478bd9Sstevel@tonic-gate addmip = 1; 15567c478bd9Sstevel@tonic-gate } 15577c478bd9Sstevel@tonic-gate } 15587c478bd9Sstevel@tonic-gate 15597c478bd9Sstevel@tonic-gate if (addmip) { 156093239addSjohnlev vnode_t *lvp = NULL; 156193239addSjohnlev 156293239addSjohnlev error = vfs_get_lofi(vfsp, &lvp); 156393239addSjohnlev if (error > 0) { 156493239addSjohnlev lofi_remove(vfsp); 156593239addSjohnlev 156693239addSjohnlev if (splice) 156793239addSjohnlev vn_vfsunlock(vp); 156893239addSjohnlev vfs_unlock(vfsp); 156993239addSjohnlev 157093239addSjohnlev if (remount) { 157193239addSjohnlev VFS_RELE(vfsp); 157293239addSjohnlev } else { 157393239addSjohnlev vfs_free(vfsp); 157493239addSjohnlev } 157593239addSjohnlev 157693239addSjohnlev goto errout; 157793239addSjohnlev } else if (error == -1) { 157893239addSjohnlev bdev = bvp->v_rdev; 157993239addSjohnlev VN_RELE(bvp); 158093239addSjohnlev } else { 158193239addSjohnlev bdev = lvp->v_rdev; 158293239addSjohnlev VN_RELE(lvp); 158393239addSjohnlev VN_RELE(bvp); 158493239addSjohnlev } 158593239addSjohnlev 15867c478bd9Sstevel@tonic-gate vfs_addmip(bdev, vfsp); 15877c478bd9Sstevel@tonic-gate addmip = 0; 15887c478bd9Sstevel@tonic-gate delmip = 1; 15897c478bd9Sstevel@tonic-gate } 15907c478bd9Sstevel@tonic-gate /* 15917c478bd9Sstevel@tonic-gate * Invalidate cached entry for the mount point. 15927c478bd9Sstevel@tonic-gate */ 15937c478bd9Sstevel@tonic-gate if (splice) 15947c478bd9Sstevel@tonic-gate dnlc_purge_vp(vp); 15957c478bd9Sstevel@tonic-gate 15967c478bd9Sstevel@tonic-gate /* 15977c478bd9Sstevel@tonic-gate * If have an option string but the filesystem doesn't supply a 15987c478bd9Sstevel@tonic-gate * prototype options table, create a table with the global 15997c478bd9Sstevel@tonic-gate * options and sufficient room to accept all the options in the 16007c478bd9Sstevel@tonic-gate * string. Then parse the passed in option string 16017c478bd9Sstevel@tonic-gate * accepting all the options in the string. This gives us an 16027c478bd9Sstevel@tonic-gate * option table with all the proper cancel properties for the 16037c478bd9Sstevel@tonic-gate * global options. 16047c478bd9Sstevel@tonic-gate * 16057c478bd9Sstevel@tonic-gate * Filesystems that supply a prototype options table are handled 16067c478bd9Sstevel@tonic-gate * earlier in this function. 16077c478bd9Sstevel@tonic-gate */ 16087c478bd9Sstevel@tonic-gate if (uap->flags & MS_OPTIONSTR) { 16097c478bd9Sstevel@tonic-gate if (!(vswp->vsw_flag & VSW_HASPROTO)) { 16107c478bd9Sstevel@tonic-gate mntopts_t tmp_mntopts; 16117c478bd9Sstevel@tonic-gate 16127c478bd9Sstevel@tonic-gate tmp_mntopts.mo_count = 0; 16137c478bd9Sstevel@tonic-gate vfs_createopttbl_extend(&tmp_mntopts, inargs, 16147c478bd9Sstevel@tonic-gate &mnt_mntopts); 16157c478bd9Sstevel@tonic-gate vfs_parsemntopts(&tmp_mntopts, inargs, 1); 16167c478bd9Sstevel@tonic-gate vfs_swapopttbl_nolock(&mnt_mntopts, &tmp_mntopts); 16177c478bd9Sstevel@tonic-gate vfs_freeopttbl(&tmp_mntopts); 16187c478bd9Sstevel@tonic-gate } 16197c478bd9Sstevel@tonic-gate } 16207c478bd9Sstevel@tonic-gate 16217c478bd9Sstevel@tonic-gate /* 16227c478bd9Sstevel@tonic-gate * Serialize with zone creations. 16237c478bd9Sstevel@tonic-gate */ 16247c478bd9Sstevel@tonic-gate mount_in_progress(); 16257c478bd9Sstevel@tonic-gate /* 16267c478bd9Sstevel@tonic-gate * Instantiate (or reinstantiate) the file system. If appropriate, 16277c478bd9Sstevel@tonic-gate * splice it into the file system name space. 16287c478bd9Sstevel@tonic-gate * 16297c478bd9Sstevel@tonic-gate * We want VFS_MOUNT() to be able to override the vfs_resource 16307c478bd9Sstevel@tonic-gate * string if necessary (ie, mntfs), and also for a remount to 16317c478bd9Sstevel@tonic-gate * change the same (necessary when remounting '/' during boot). 16327c478bd9Sstevel@tonic-gate * So we set up vfs_mntpt and vfs_resource to what we think they 16337c478bd9Sstevel@tonic-gate * should be, then hand off control to VFS_MOUNT() which can 16347c478bd9Sstevel@tonic-gate * override this. 16357c478bd9Sstevel@tonic-gate * 16367c478bd9Sstevel@tonic-gate * For safety's sake, when changing vfs_resource or vfs_mntpt of 16377c478bd9Sstevel@tonic-gate * a vfs which is on the vfs list (i.e. during a remount), we must 16387c478bd9Sstevel@tonic-gate * never set those fields to NULL. Several bits of code make 16397c478bd9Sstevel@tonic-gate * assumptions that the fields are always valid. 16407c478bd9Sstevel@tonic-gate */ 16417c478bd9Sstevel@tonic-gate vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts); 16427c478bd9Sstevel@tonic-gate if (remount) { 16437c478bd9Sstevel@tonic-gate if ((oldresource = vfsp->vfs_resource) != NULL) 16447c478bd9Sstevel@tonic-gate refstr_hold(oldresource); 16457c478bd9Sstevel@tonic-gate if ((oldmntpt = vfsp->vfs_mntpt) != NULL) 16467c478bd9Sstevel@tonic-gate refstr_hold(oldmntpt); 16477c478bd9Sstevel@tonic-gate } 16487c478bd9Sstevel@tonic-gate vfs_setresource(vfsp, resource); 16497c478bd9Sstevel@tonic-gate vfs_setmntpoint(vfsp, mountpt); 16507c478bd9Sstevel@tonic-gate 1651df2381bfSpraks /* 1652df2381bfSpraks * going to mount on this vnode, so notify. 1653df2381bfSpraks */ 1654da6c28aaSamw vnevent_mountedover(vp, NULL); 16557c478bd9Sstevel@tonic-gate error = VFS_MOUNT(vfsp, vp, uap, credp); 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate if (uap->flags & MS_RDONLY) 16587c478bd9Sstevel@tonic-gate vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 16597c478bd9Sstevel@tonic-gate if (uap->flags & MS_NOSUID) 16607c478bd9Sstevel@tonic-gate vfs_setmntopt(vfsp, MNTOPT_NOSUID, NULL, 0); 16617c478bd9Sstevel@tonic-gate if (uap->flags & MS_GLOBAL) 16627c478bd9Sstevel@tonic-gate vfs_setmntopt(vfsp, MNTOPT_GLOBAL, NULL, 0); 16637c478bd9Sstevel@tonic-gate 16647c478bd9Sstevel@tonic-gate if (error) { 166593239addSjohnlev lofi_remove(vfsp); 166693239addSjohnlev 16677c478bd9Sstevel@tonic-gate if (remount) { 16687c478bd9Sstevel@tonic-gate /* put back pre-remount options */ 16697c478bd9Sstevel@tonic-gate vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts); 1670fcad04f7Sevanl vfs_setmntpoint(vfsp, (stripzonepath( 1671b1b8ab34Slling refstr_value(oldmntpt)))); 16727c478bd9Sstevel@tonic-gate if (oldmntpt) 16737c478bd9Sstevel@tonic-gate refstr_rele(oldmntpt); 1674fcad04f7Sevanl vfs_setresource(vfsp, (stripzonepath( 1675b1b8ab34Slling refstr_value(oldresource)))); 16767c478bd9Sstevel@tonic-gate if (oldresource) 16777c478bd9Sstevel@tonic-gate refstr_rele(oldresource); 16787c478bd9Sstevel@tonic-gate vfsp->vfs_flag = ovflags; 16797c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 16807c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); 16817c478bd9Sstevel@tonic-gate } else { 16827c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 16837c478bd9Sstevel@tonic-gate vfs_freemnttab(vfsp); 1684da6c28aaSamw vfs_free(vfsp); 16857c478bd9Sstevel@tonic-gate } 16867c478bd9Sstevel@tonic-gate } else { 16877c478bd9Sstevel@tonic-gate /* 16887c478bd9Sstevel@tonic-gate * Set the mount time to now 16897c478bd9Sstevel@tonic-gate */ 16907c478bd9Sstevel@tonic-gate vfsp->vfs_mtime = ddi_get_time(); 16917c478bd9Sstevel@tonic-gate if (remount) { 16927c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_REMOUNT; 16937c478bd9Sstevel@tonic-gate if (oldresource) 16947c478bd9Sstevel@tonic-gate refstr_rele(oldresource); 16957c478bd9Sstevel@tonic-gate if (oldmntpt) 16967c478bd9Sstevel@tonic-gate refstr_rele(oldmntpt); 16977c478bd9Sstevel@tonic-gate } else if (splice) { 16987c478bd9Sstevel@tonic-gate /* 16997c478bd9Sstevel@tonic-gate * Link vfsp into the name space at the mount 17007c478bd9Sstevel@tonic-gate * point. Vfs_add() is responsible for 17017c478bd9Sstevel@tonic-gate * holding the mount point which will be 17027c478bd9Sstevel@tonic-gate * released when vfs_remove() is called. 17037c478bd9Sstevel@tonic-gate */ 17047c478bd9Sstevel@tonic-gate vfs_add(vp, vfsp, uap->flags); 17057c478bd9Sstevel@tonic-gate } else { 17067c478bd9Sstevel@tonic-gate /* 17077c478bd9Sstevel@tonic-gate * Hold the reference to file system which is 17087c478bd9Sstevel@tonic-gate * not linked into the name space. 17097c478bd9Sstevel@tonic-gate */ 17107c478bd9Sstevel@tonic-gate vfsp->vfs_zone = NULL; 17117c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); 17127c478bd9Sstevel@tonic-gate vfsp->vfs_vnodecovered = NULL; 17137c478bd9Sstevel@tonic-gate } 17147c478bd9Sstevel@tonic-gate /* 17157c478bd9Sstevel@tonic-gate * Set flags for global options encountered 17167c478bd9Sstevel@tonic-gate */ 17177c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) 17187c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_RDONLY; 17197c478bd9Sstevel@tonic-gate else 17207c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_RDONLY; 17217c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) { 17227c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= (VFS_NOSETUID|VFS_NODEVICES); 17237c478bd9Sstevel@tonic-gate } else { 17247c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) 17257c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_NODEVICES; 17267c478bd9Sstevel@tonic-gate else 17277c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_NODEVICES; 17287c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) 17297c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_NOSETUID; 17307c478bd9Sstevel@tonic-gate else 17317c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_NOSETUID; 17327c478bd9Sstevel@tonic-gate } 17337c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) 17347c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_NBMAND; 17357c478bd9Sstevel@tonic-gate else 17367c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_NBMAND; 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) 17397c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_XATTR; 17407c478bd9Sstevel@tonic-gate else 17417c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_XATTR; 17427c478bd9Sstevel@tonic-gate 17437c478bd9Sstevel@tonic-gate if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) 17447c478bd9Sstevel@tonic-gate vfsp->vfs_flag |= VFS_NOEXEC; 17457c478bd9Sstevel@tonic-gate else 17467c478bd9Sstevel@tonic-gate vfsp->vfs_flag &= ~VFS_NOEXEC; 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate /* 17497c478bd9Sstevel@tonic-gate * Now construct the output option string of options 17507c478bd9Sstevel@tonic-gate * we recognized. 17517c478bd9Sstevel@tonic-gate */ 17527c478bd9Sstevel@tonic-gate if (uap->flags & MS_OPTIONSTR) { 17537c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 17547c478bd9Sstevel@tonic-gate copyout_error = vfs_buildoptionstr( 1755b1b8ab34Slling &vfsp->vfs_mntopts, inargs, optlen); 17567c478bd9Sstevel@tonic-gate vfs_list_unlock(); 17577c478bd9Sstevel@tonic-gate if (copyout_error == 0 && 17587c478bd9Sstevel@tonic-gate (uap->flags & MS_SYSSPACE) == 0) { 17597c478bd9Sstevel@tonic-gate copyout_error = copyoutstr(inargs, opts, 17607c478bd9Sstevel@tonic-gate optlen, NULL); 17617c478bd9Sstevel@tonic-gate } 17627c478bd9Sstevel@tonic-gate } 17635a59a8b3Srsb 176482c7f3c4Srsb /* 176582c7f3c4Srsb * If this isn't a remount, set up the vopstats before 1766ec64bf9dSrsb * anyone can touch this. We only allow spliced file 1767ec64bf9dSrsb * systems (file systems which are in the namespace) to 1768ec64bf9dSrsb * have the VFS_STATS flag set. 1769ec64bf9dSrsb * NOTE: PxFS mounts the underlying file system with 1770ec64bf9dSrsb * MS_NOSPLICE set and copies those vfs_flags to its private 1771ec64bf9dSrsb * vfs structure. As a result, PxFS should never have 1772ec64bf9dSrsb * the VFS_STATS flag or else we might access the vfs 1773ec64bf9dSrsb * statistics-related fields prior to them being 1774ec64bf9dSrsb * properly initialized. 177582c7f3c4Srsb */ 1776ec64bf9dSrsb if (!remount && (vswp->vsw_flag & VSW_STATS) && splice) { 177782c7f3c4Srsb initialize_vopstats(&vfsp->vfs_vopstats); 177882c7f3c4Srsb /* 177982c7f3c4Srsb * We need to set vfs_vskap to NULL because there's 178082c7f3c4Srsb * a chance it won't be set below. This is checked 178182c7f3c4Srsb * in teardown_vopstats() so we can't have garbage. 178282c7f3c4Srsb */ 178382c7f3c4Srsb vfsp->vfs_vskap = NULL; 17845a59a8b3Srsb vfsp->vfs_flag |= VFS_STATS; 178582c7f3c4Srsb vfsp->vfs_fstypevsp = get_fstype_vopstats(vfsp, vswp); 17865a59a8b3Srsb } 17875a59a8b3Srsb 1788f48205beScasper if (vswp->vsw_flag & VSW_XID) 1789f48205beScasper vfsp->vfs_flag |= VFS_XID; 1790f48205beScasper 17917c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 17927c478bd9Sstevel@tonic-gate } 17937c478bd9Sstevel@tonic-gate mount_completed(); 17947c478bd9Sstevel@tonic-gate if (splice) 17957c478bd9Sstevel@tonic-gate vn_vfsunlock(vp); 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate if ((error == 0) && (copyout_error == 0)) { 179882c7f3c4Srsb if (!remount) { 179982c7f3c4Srsb /* 180082c7f3c4Srsb * Don't call get_vskstat_anchor() while holding 180182c7f3c4Srsb * locks since it allocates memory and calls 180282c7f3c4Srsb * VFS_STATVFS(). For NFS, the latter can generate 180382c7f3c4Srsb * an over-the-wire call. 180482c7f3c4Srsb */ 180582c7f3c4Srsb vskap = get_vskstat_anchor(vfsp); 180682c7f3c4Srsb /* Only take the lock if we have something to do */ 180782c7f3c4Srsb if (vskap != NULL) { 180882c7f3c4Srsb vfs_lock_wait(vfsp); 180982c7f3c4Srsb if (vfsp->vfs_flag & VFS_STATS) { 181082c7f3c4Srsb vfsp->vfs_vskap = vskap; 181182c7f3c4Srsb } 181282c7f3c4Srsb vfs_unlock(vfsp); 181382c7f3c4Srsb } 181482c7f3c4Srsb } 18155a59a8b3Srsb /* Return vfsp to caller. */ 18167c478bd9Sstevel@tonic-gate *vfspp = vfsp; 18177c478bd9Sstevel@tonic-gate } 18187c478bd9Sstevel@tonic-gate errout: 18197c478bd9Sstevel@tonic-gate vfs_freeopttbl(&mnt_mntopts); 18207c478bd9Sstevel@tonic-gate if (resource != NULL) 18217c478bd9Sstevel@tonic-gate kmem_free(resource, strlen(resource) + 1); 18227c478bd9Sstevel@tonic-gate if (mountpt != NULL) 18237c478bd9Sstevel@tonic-gate kmem_free(mountpt, strlen(mountpt) + 1); 18247c478bd9Sstevel@tonic-gate /* 18257c478bd9Sstevel@tonic-gate * It is possible we errored prior to adding to mount in progress 18267c478bd9Sstevel@tonic-gate * table. Must free vnode we acquired with successful lookupname. 18277c478bd9Sstevel@tonic-gate */ 18287c478bd9Sstevel@tonic-gate if (addmip) 18297c478bd9Sstevel@tonic-gate VN_RELE(bvp); 18307c478bd9Sstevel@tonic-gate if (delmip) 18317c478bd9Sstevel@tonic-gate vfs_delmip(vfsp); 18327c478bd9Sstevel@tonic-gate ASSERT(vswp != NULL); 18337c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vswp); 18347c478bd9Sstevel@tonic-gate if (inargs != opts) 18357c478bd9Sstevel@tonic-gate kmem_free(inargs, MAX_MNTOPT_STR); 18367c478bd9Sstevel@tonic-gate if (copyout_error) { 183793239addSjohnlev lofi_remove(vfsp); 18387c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); 18397c478bd9Sstevel@tonic-gate error = copyout_error; 18407c478bd9Sstevel@tonic-gate } 18417c478bd9Sstevel@tonic-gate return (error); 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate static void 18457c478bd9Sstevel@tonic-gate vfs_setpath(struct vfs *vfsp, refstr_t **refp, const char *newpath) 18467c478bd9Sstevel@tonic-gate { 18477c478bd9Sstevel@tonic-gate size_t len; 18487c478bd9Sstevel@tonic-gate refstr_t *ref; 18497c478bd9Sstevel@tonic-gate zone_t *zone = curproc->p_zone; 18507c478bd9Sstevel@tonic-gate char *sp; 18517c478bd9Sstevel@tonic-gate int have_list_lock = 0; 18527c478bd9Sstevel@tonic-gate 18537c478bd9Sstevel@tonic-gate ASSERT(!VFS_ON_LIST(vfsp) || vfs_lock_held(vfsp)); 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate /* 18567c478bd9Sstevel@tonic-gate * New path must be less than MAXPATHLEN because mntfs 18577c478bd9Sstevel@tonic-gate * will only display up to MAXPATHLEN bytes. This is currently 18587c478bd9Sstevel@tonic-gate * safe, because domount() uses pn_get(), and other callers 18597c478bd9Sstevel@tonic-gate * similarly cap the size to fewer than MAXPATHLEN bytes. 18607c478bd9Sstevel@tonic-gate */ 18617c478bd9Sstevel@tonic-gate 18627c478bd9Sstevel@tonic-gate ASSERT(strlen(newpath) < MAXPATHLEN); 18637c478bd9Sstevel@tonic-gate 18647c478bd9Sstevel@tonic-gate /* mntfs requires consistency while vfs list lock is held */ 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate if (VFS_ON_LIST(vfsp)) { 18677c478bd9Sstevel@tonic-gate have_list_lock = 1; 18687c478bd9Sstevel@tonic-gate vfs_list_lock(); 18697c478bd9Sstevel@tonic-gate } 18707c478bd9Sstevel@tonic-gate 18717c478bd9Sstevel@tonic-gate if (*refp != NULL) 18727c478bd9Sstevel@tonic-gate refstr_rele(*refp); 18737c478bd9Sstevel@tonic-gate 18747c478bd9Sstevel@tonic-gate /* Do we need to modify the path? */ 18757c478bd9Sstevel@tonic-gate 18767c478bd9Sstevel@tonic-gate if (zone == global_zone || *newpath != '/') { 18777c478bd9Sstevel@tonic-gate ref = refstr_alloc(newpath); 18787c478bd9Sstevel@tonic-gate goto out; 18797c478bd9Sstevel@tonic-gate } 18807c478bd9Sstevel@tonic-gate 18817c478bd9Sstevel@tonic-gate /* 18827c478bd9Sstevel@tonic-gate * Truncate the trailing '/' in the zoneroot, and merge 18837c478bd9Sstevel@tonic-gate * in the zone's rootpath with the "newpath" (resource 18847c478bd9Sstevel@tonic-gate * or mountpoint) passed in. 18857c478bd9Sstevel@tonic-gate * 18867c478bd9Sstevel@tonic-gate * The size of the required buffer is thus the size of 18877c478bd9Sstevel@tonic-gate * the buffer required for the passed-in newpath 18887c478bd9Sstevel@tonic-gate * (strlen(newpath) + 1), plus the size of the buffer 18897c478bd9Sstevel@tonic-gate * required to hold zone_rootpath (zone_rootpathlen) 18907c478bd9Sstevel@tonic-gate * minus one for one of the now-superfluous NUL 18917c478bd9Sstevel@tonic-gate * terminations, minus one for the trailing '/'. 18927c478bd9Sstevel@tonic-gate * 18937c478bd9Sstevel@tonic-gate * That gives us: 18947c478bd9Sstevel@tonic-gate * 18957c478bd9Sstevel@tonic-gate * (strlen(newpath) + 1) + zone_rootpathlen - 1 - 1 18967c478bd9Sstevel@tonic-gate * 18977c478bd9Sstevel@tonic-gate * Which is what we have below. 18987c478bd9Sstevel@tonic-gate */ 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate len = strlen(newpath) + zone->zone_rootpathlen - 1; 19017c478bd9Sstevel@tonic-gate sp = kmem_alloc(len, KM_SLEEP); 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate /* 19047c478bd9Sstevel@tonic-gate * Copy everything including the trailing slash, which 19057c478bd9Sstevel@tonic-gate * we then overwrite with the NUL character. 19067c478bd9Sstevel@tonic-gate */ 19077c478bd9Sstevel@tonic-gate 19087c478bd9Sstevel@tonic-gate (void) strcpy(sp, zone->zone_rootpath); 19097c478bd9Sstevel@tonic-gate sp[zone->zone_rootpathlen - 2] = '\0'; 19107c478bd9Sstevel@tonic-gate (void) strcat(sp, newpath); 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate ref = refstr_alloc(sp); 19137c478bd9Sstevel@tonic-gate kmem_free(sp, len); 19147c478bd9Sstevel@tonic-gate out: 19157c478bd9Sstevel@tonic-gate *refp = ref; 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate if (have_list_lock) { 19187c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd(); 19197c478bd9Sstevel@tonic-gate vfs_list_unlock(); 19207c478bd9Sstevel@tonic-gate } 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate /* 19247c478bd9Sstevel@tonic-gate * Record a mounted resource name in a vfs structure. 19257c478bd9Sstevel@tonic-gate * If vfsp is already mounted, caller must hold the vfs lock. 19267c478bd9Sstevel@tonic-gate */ 19277c478bd9Sstevel@tonic-gate void 19287c478bd9Sstevel@tonic-gate vfs_setresource(struct vfs *vfsp, const char *resource) 19297c478bd9Sstevel@tonic-gate { 19307c478bd9Sstevel@tonic-gate if (resource == NULL || resource[0] == '\0') 19317c478bd9Sstevel@tonic-gate resource = VFS_NORESOURCE; 19327c478bd9Sstevel@tonic-gate vfs_setpath(vfsp, &vfsp->vfs_resource, resource); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate /* 19367c478bd9Sstevel@tonic-gate * Record a mount point name in a vfs structure. 19377c478bd9Sstevel@tonic-gate * If vfsp is already mounted, caller must hold the vfs lock. 19387c478bd9Sstevel@tonic-gate */ 19397c478bd9Sstevel@tonic-gate void 19407c478bd9Sstevel@tonic-gate vfs_setmntpoint(struct vfs *vfsp, const char *mntpt) 19417c478bd9Sstevel@tonic-gate { 19427c478bd9Sstevel@tonic-gate if (mntpt == NULL || mntpt[0] == '\0') 19437c478bd9Sstevel@tonic-gate mntpt = VFS_NOMNTPT; 19447c478bd9Sstevel@tonic-gate vfs_setpath(vfsp, &vfsp->vfs_mntpt, mntpt); 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate 19477c478bd9Sstevel@tonic-gate /* Returns the vfs_resource. Caller must call refstr_rele() when finished. */ 19487c478bd9Sstevel@tonic-gate 19497c478bd9Sstevel@tonic-gate refstr_t * 19507c478bd9Sstevel@tonic-gate vfs_getresource(const struct vfs *vfsp) 19517c478bd9Sstevel@tonic-gate { 19527c478bd9Sstevel@tonic-gate refstr_t *resource; 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 19557c478bd9Sstevel@tonic-gate resource = vfsp->vfs_resource; 19567c478bd9Sstevel@tonic-gate refstr_hold(resource); 19577c478bd9Sstevel@tonic-gate vfs_list_unlock(); 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate return (resource); 19607c478bd9Sstevel@tonic-gate } 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate /* Returns the vfs_mntpt. Caller must call refstr_rele() when finished. */ 19637c478bd9Sstevel@tonic-gate 19647c478bd9Sstevel@tonic-gate refstr_t * 19657c478bd9Sstevel@tonic-gate vfs_getmntpoint(const struct vfs *vfsp) 19667c478bd9Sstevel@tonic-gate { 19677c478bd9Sstevel@tonic-gate refstr_t *mntpt; 19687c478bd9Sstevel@tonic-gate 19697c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 19707c478bd9Sstevel@tonic-gate mntpt = vfsp->vfs_mntpt; 19717c478bd9Sstevel@tonic-gate refstr_hold(mntpt); 19727c478bd9Sstevel@tonic-gate vfs_list_unlock(); 19737c478bd9Sstevel@tonic-gate 19747c478bd9Sstevel@tonic-gate return (mntpt); 19757c478bd9Sstevel@tonic-gate } 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate /* 19787c478bd9Sstevel@tonic-gate * Create an empty options table with enough empty slots to hold all 19797c478bd9Sstevel@tonic-gate * The options in the options string passed as an argument. 19807c478bd9Sstevel@tonic-gate * Potentially prepend another options table. 19817c478bd9Sstevel@tonic-gate * 19827c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 19837c478bd9Sstevel@tonic-gate * to protect mops. 19847c478bd9Sstevel@tonic-gate */ 19857c478bd9Sstevel@tonic-gate static void 19867c478bd9Sstevel@tonic-gate vfs_createopttbl_extend(mntopts_t *mops, const char *opts, 19877c478bd9Sstevel@tonic-gate const mntopts_t *mtmpl) 19887c478bd9Sstevel@tonic-gate { 19897c478bd9Sstevel@tonic-gate const char *s = opts; 19907c478bd9Sstevel@tonic-gate uint_t count; 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate if (opts == NULL || *opts == '\0') { 19937c478bd9Sstevel@tonic-gate count = 0; 19947c478bd9Sstevel@tonic-gate } else { 19957c478bd9Sstevel@tonic-gate count = 1; 19967c478bd9Sstevel@tonic-gate 19977c478bd9Sstevel@tonic-gate /* 19987c478bd9Sstevel@tonic-gate * Count number of options in the string 19997c478bd9Sstevel@tonic-gate */ 20007c478bd9Sstevel@tonic-gate for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) { 20017c478bd9Sstevel@tonic-gate count++; 20027c478bd9Sstevel@tonic-gate s++; 20037c478bd9Sstevel@tonic-gate } 20047c478bd9Sstevel@tonic-gate } 20057c478bd9Sstevel@tonic-gate vfs_copyopttbl_extend(mtmpl, mops, count); 20067c478bd9Sstevel@tonic-gate } 20077c478bd9Sstevel@tonic-gate 20087c478bd9Sstevel@tonic-gate /* 20097c478bd9Sstevel@tonic-gate * Create an empty options table with enough empty slots to hold all 20107c478bd9Sstevel@tonic-gate * The options in the options string passed as an argument. 20117c478bd9Sstevel@tonic-gate * 20127c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 20137c478bd9Sstevel@tonic-gate * 20147c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 20157c478bd9Sstevel@tonic-gate * to protect mops. 20167c478bd9Sstevel@tonic-gate */ 20177c478bd9Sstevel@tonic-gate void 20187c478bd9Sstevel@tonic-gate vfs_createopttbl(mntopts_t *mops, const char *opts) 20197c478bd9Sstevel@tonic-gate { 20207c478bd9Sstevel@tonic-gate vfs_createopttbl_extend(mops, opts, NULL); 20217c478bd9Sstevel@tonic-gate } 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate 20247c478bd9Sstevel@tonic-gate /* 20257c478bd9Sstevel@tonic-gate * Swap two mount options tables 20267c478bd9Sstevel@tonic-gate */ 20277c478bd9Sstevel@tonic-gate static void 20287c478bd9Sstevel@tonic-gate vfs_swapopttbl_nolock(mntopts_t *optbl1, mntopts_t *optbl2) 20297c478bd9Sstevel@tonic-gate { 20307c478bd9Sstevel@tonic-gate uint_t tmpcnt; 20317c478bd9Sstevel@tonic-gate mntopt_t *tmplist; 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate tmpcnt = optbl2->mo_count; 20347c478bd9Sstevel@tonic-gate tmplist = optbl2->mo_list; 20357c478bd9Sstevel@tonic-gate optbl2->mo_count = optbl1->mo_count; 20367c478bd9Sstevel@tonic-gate optbl2->mo_list = optbl1->mo_list; 20377c478bd9Sstevel@tonic-gate optbl1->mo_count = tmpcnt; 20387c478bd9Sstevel@tonic-gate optbl1->mo_list = tmplist; 20397c478bd9Sstevel@tonic-gate } 20407c478bd9Sstevel@tonic-gate 20417c478bd9Sstevel@tonic-gate static void 20427c478bd9Sstevel@tonic-gate vfs_swapopttbl(mntopts_t *optbl1, mntopts_t *optbl2) 20437c478bd9Sstevel@tonic-gate { 20447c478bd9Sstevel@tonic-gate vfs_list_lock(); 20457c478bd9Sstevel@tonic-gate vfs_swapopttbl_nolock(optbl1, optbl2); 20467c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd(); 20477c478bd9Sstevel@tonic-gate vfs_list_unlock(); 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate static char ** 20517c478bd9Sstevel@tonic-gate vfs_copycancelopt_extend(char **const moc, int extend) 20527c478bd9Sstevel@tonic-gate { 20537c478bd9Sstevel@tonic-gate int i = 0; 20547c478bd9Sstevel@tonic-gate int j; 20557c478bd9Sstevel@tonic-gate char **result; 20567c478bd9Sstevel@tonic-gate 20577c478bd9Sstevel@tonic-gate if (moc != NULL) { 20587c478bd9Sstevel@tonic-gate for (; moc[i] != NULL; i++) 20597c478bd9Sstevel@tonic-gate /* count number of options to cancel */; 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate if (i + extend == 0) 20637c478bd9Sstevel@tonic-gate return (NULL); 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate result = kmem_alloc((i + extend + 1) * sizeof (char *), KM_SLEEP); 20667c478bd9Sstevel@tonic-gate 20677c478bd9Sstevel@tonic-gate for (j = 0; j < i; j++) { 20687c478bd9Sstevel@tonic-gate result[j] = kmem_alloc(strlen(moc[j]) + 1, KM_SLEEP); 20697c478bd9Sstevel@tonic-gate (void) strcpy(result[j], moc[j]); 20707c478bd9Sstevel@tonic-gate } 20717c478bd9Sstevel@tonic-gate for (; j <= i + extend; j++) 20727c478bd9Sstevel@tonic-gate result[j] = NULL; 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate return (result); 20757c478bd9Sstevel@tonic-gate } 20767c478bd9Sstevel@tonic-gate 20777c478bd9Sstevel@tonic-gate static void 20787c478bd9Sstevel@tonic-gate vfs_copyopt(const mntopt_t *s, mntopt_t *d) 20797c478bd9Sstevel@tonic-gate { 20807c478bd9Sstevel@tonic-gate char *sp, *dp; 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate d->mo_flags = s->mo_flags; 20837c478bd9Sstevel@tonic-gate d->mo_data = s->mo_data; 20847c478bd9Sstevel@tonic-gate sp = s->mo_name; 20857c478bd9Sstevel@tonic-gate if (sp != NULL) { 20867c478bd9Sstevel@tonic-gate dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP); 20877c478bd9Sstevel@tonic-gate (void) strcpy(dp, sp); 20887c478bd9Sstevel@tonic-gate d->mo_name = dp; 20897c478bd9Sstevel@tonic-gate } else { 20907c478bd9Sstevel@tonic-gate d->mo_name = NULL; /* should never happen */ 20917c478bd9Sstevel@tonic-gate } 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate d->mo_cancel = vfs_copycancelopt_extend(s->mo_cancel, 0); 20947c478bd9Sstevel@tonic-gate 20957c478bd9Sstevel@tonic-gate sp = s->mo_arg; 20967c478bd9Sstevel@tonic-gate if (sp != NULL) { 20977c478bd9Sstevel@tonic-gate dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP); 20987c478bd9Sstevel@tonic-gate (void) strcpy(dp, sp); 20997c478bd9Sstevel@tonic-gate d->mo_arg = dp; 21007c478bd9Sstevel@tonic-gate } else { 21017c478bd9Sstevel@tonic-gate d->mo_arg = NULL; 21027c478bd9Sstevel@tonic-gate } 21037c478bd9Sstevel@tonic-gate } 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate /* 21067c478bd9Sstevel@tonic-gate * Copy a mount options table, possibly allocating some spare 21077c478bd9Sstevel@tonic-gate * slots at the end. It is permissible to copy_extend the NULL table. 21087c478bd9Sstevel@tonic-gate */ 21097c478bd9Sstevel@tonic-gate static void 21107c478bd9Sstevel@tonic-gate vfs_copyopttbl_extend(const mntopts_t *smo, mntopts_t *dmo, int extra) 21117c478bd9Sstevel@tonic-gate { 21127c478bd9Sstevel@tonic-gate uint_t i, count; 21137c478bd9Sstevel@tonic-gate mntopt_t *motbl; 21147c478bd9Sstevel@tonic-gate 21157c478bd9Sstevel@tonic-gate /* 21167c478bd9Sstevel@tonic-gate * Clear out any existing stuff in the options table being initialized 21177c478bd9Sstevel@tonic-gate */ 21187c478bd9Sstevel@tonic-gate vfs_freeopttbl(dmo); 21197c478bd9Sstevel@tonic-gate count = (smo == NULL) ? 0 : smo->mo_count; 21207c478bd9Sstevel@tonic-gate if ((count + extra) == 0) /* nothing to do */ 21217c478bd9Sstevel@tonic-gate return; 21227c478bd9Sstevel@tonic-gate dmo->mo_count = count + extra; 21237c478bd9Sstevel@tonic-gate motbl = kmem_zalloc((count + extra) * sizeof (mntopt_t), KM_SLEEP); 21247c478bd9Sstevel@tonic-gate dmo->mo_list = motbl; 21257c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) { 21267c478bd9Sstevel@tonic-gate vfs_copyopt(&smo->mo_list[i], &motbl[i]); 21277c478bd9Sstevel@tonic-gate } 21287c478bd9Sstevel@tonic-gate for (i = count; i < count + extra; i++) { 21297c478bd9Sstevel@tonic-gate motbl[i].mo_flags = MO_EMPTY; 21307c478bd9Sstevel@tonic-gate } 21317c478bd9Sstevel@tonic-gate } 21327c478bd9Sstevel@tonic-gate 21337c478bd9Sstevel@tonic-gate /* 21347c478bd9Sstevel@tonic-gate * Copy a mount options table. 21357c478bd9Sstevel@tonic-gate * 21367c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 21377c478bd9Sstevel@tonic-gate * 21387c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 21397c478bd9Sstevel@tonic-gate * to protect smo and dmo. 21407c478bd9Sstevel@tonic-gate */ 21417c478bd9Sstevel@tonic-gate void 21427c478bd9Sstevel@tonic-gate vfs_copyopttbl(const mntopts_t *smo, mntopts_t *dmo) 21437c478bd9Sstevel@tonic-gate { 21447c478bd9Sstevel@tonic-gate vfs_copyopttbl_extend(smo, dmo, 0); 21457c478bd9Sstevel@tonic-gate } 21467c478bd9Sstevel@tonic-gate 21477c478bd9Sstevel@tonic-gate static char ** 21487c478bd9Sstevel@tonic-gate vfs_mergecancelopts(const mntopt_t *mop1, const mntopt_t *mop2) 21497c478bd9Sstevel@tonic-gate { 21507c478bd9Sstevel@tonic-gate int c1 = 0; 21517c478bd9Sstevel@tonic-gate int c2 = 0; 21527c478bd9Sstevel@tonic-gate char **result; 21537c478bd9Sstevel@tonic-gate char **sp1, **sp2, **dp; 21547c478bd9Sstevel@tonic-gate 21557c478bd9Sstevel@tonic-gate /* 21567c478bd9Sstevel@tonic-gate * First we count both lists of cancel options. 21577c478bd9Sstevel@tonic-gate * If either is NULL or has no elements, we return a copy of 21587c478bd9Sstevel@tonic-gate * the other. 21597c478bd9Sstevel@tonic-gate */ 21607c478bd9Sstevel@tonic-gate if (mop1->mo_cancel != NULL) { 21617c478bd9Sstevel@tonic-gate for (; mop1->mo_cancel[c1] != NULL; c1++) 21627c478bd9Sstevel@tonic-gate /* count cancel options in mop1 */; 21637c478bd9Sstevel@tonic-gate } 21647c478bd9Sstevel@tonic-gate 21657c478bd9Sstevel@tonic-gate if (c1 == 0) 21667c478bd9Sstevel@tonic-gate return (vfs_copycancelopt_extend(mop2->mo_cancel, 0)); 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate if (mop2->mo_cancel != NULL) { 21697c478bd9Sstevel@tonic-gate for (; mop2->mo_cancel[c2] != NULL; c2++) 21707c478bd9Sstevel@tonic-gate /* count cancel options in mop2 */; 21717c478bd9Sstevel@tonic-gate } 21727c478bd9Sstevel@tonic-gate 21737c478bd9Sstevel@tonic-gate result = vfs_copycancelopt_extend(mop1->mo_cancel, c2); 21747c478bd9Sstevel@tonic-gate 21757c478bd9Sstevel@tonic-gate if (c2 == 0) 21767c478bd9Sstevel@tonic-gate return (result); 21777c478bd9Sstevel@tonic-gate 21787c478bd9Sstevel@tonic-gate /* 21797c478bd9Sstevel@tonic-gate * When we get here, we've got two sets of cancel options; 21807c478bd9Sstevel@tonic-gate * we need to merge the two sets. We know that the result 21817c478bd9Sstevel@tonic-gate * array has "c1+c2+1" entries and in the end we might shrink 21827c478bd9Sstevel@tonic-gate * it. 21837c478bd9Sstevel@tonic-gate * Result now has a copy of the c1 entries from mop1; we'll 21847c478bd9Sstevel@tonic-gate * now lookup all the entries of mop2 in mop1 and copy it if 21857c478bd9Sstevel@tonic-gate * it is unique. 21867c478bd9Sstevel@tonic-gate * This operation is O(n^2) but it's only called once per 21877c478bd9Sstevel@tonic-gate * filesystem per duplicate option. This is a situation 21887c478bd9Sstevel@tonic-gate * which doesn't arise with the filesystems in ON and 21897c478bd9Sstevel@tonic-gate * n is generally 1. 21907c478bd9Sstevel@tonic-gate */ 21917c478bd9Sstevel@tonic-gate 21927c478bd9Sstevel@tonic-gate dp = &result[c1]; 21937c478bd9Sstevel@tonic-gate for (sp2 = mop2->mo_cancel; *sp2 != NULL; sp2++) { 21947c478bd9Sstevel@tonic-gate for (sp1 = mop1->mo_cancel; *sp1 != NULL; sp1++) { 21957c478bd9Sstevel@tonic-gate if (strcmp(*sp1, *sp2) == 0) 21967c478bd9Sstevel@tonic-gate break; 21977c478bd9Sstevel@tonic-gate } 21987c478bd9Sstevel@tonic-gate if (*sp1 == NULL) { 21997c478bd9Sstevel@tonic-gate /* 22007c478bd9Sstevel@tonic-gate * Option *sp2 not found in mop1, so copy it. 22017c478bd9Sstevel@tonic-gate * The calls to vfs_copycancelopt_extend() 22027c478bd9Sstevel@tonic-gate * guarantee that there's enough room. 22037c478bd9Sstevel@tonic-gate */ 22047c478bd9Sstevel@tonic-gate *dp = kmem_alloc(strlen(*sp2) + 1, KM_SLEEP); 22057c478bd9Sstevel@tonic-gate (void) strcpy(*dp++, *sp2); 22067c478bd9Sstevel@tonic-gate } 22077c478bd9Sstevel@tonic-gate } 22087c478bd9Sstevel@tonic-gate if (dp != &result[c1+c2]) { 22097c478bd9Sstevel@tonic-gate size_t bytes = (dp - result + 1) * sizeof (char *); 22107c478bd9Sstevel@tonic-gate char **nres = kmem_alloc(bytes, KM_SLEEP); 22117c478bd9Sstevel@tonic-gate 22127c478bd9Sstevel@tonic-gate bcopy(result, nres, bytes); 22137c478bd9Sstevel@tonic-gate kmem_free(result, (c1 + c2 + 1) * sizeof (char *)); 22147c478bd9Sstevel@tonic-gate result = nres; 22157c478bd9Sstevel@tonic-gate } 22167c478bd9Sstevel@tonic-gate return (result); 22177c478bd9Sstevel@tonic-gate } 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate /* 22207c478bd9Sstevel@tonic-gate * Merge two mount option tables (outer and inner) into one. This is very 22217c478bd9Sstevel@tonic-gate * similar to "merging" global variables and automatic variables in C. 22227c478bd9Sstevel@tonic-gate * 22237c478bd9Sstevel@tonic-gate * This isn't (and doesn't have to be) fast. 22247c478bd9Sstevel@tonic-gate * 22257c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 22267c478bd9Sstevel@tonic-gate * 22277c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 22287c478bd9Sstevel@tonic-gate * to protect omo, imo & dmo. 22297c478bd9Sstevel@tonic-gate */ 22307c478bd9Sstevel@tonic-gate void 22317c478bd9Sstevel@tonic-gate vfs_mergeopttbl(const mntopts_t *omo, const mntopts_t *imo, mntopts_t *dmo) 22327c478bd9Sstevel@tonic-gate { 22337c478bd9Sstevel@tonic-gate uint_t i, count; 22347c478bd9Sstevel@tonic-gate mntopt_t *mop, *motbl; 22357c478bd9Sstevel@tonic-gate uint_t freeidx; 22367c478bd9Sstevel@tonic-gate 22377c478bd9Sstevel@tonic-gate /* 22387c478bd9Sstevel@tonic-gate * First determine how much space we need to allocate. 22397c478bd9Sstevel@tonic-gate */ 22407c478bd9Sstevel@tonic-gate count = omo->mo_count; 22417c478bd9Sstevel@tonic-gate for (i = 0; i < imo->mo_count; i++) { 22427c478bd9Sstevel@tonic-gate if (imo->mo_list[i].mo_flags & MO_EMPTY) 22437c478bd9Sstevel@tonic-gate continue; 22447c478bd9Sstevel@tonic-gate if (vfs_hasopt(omo, imo->mo_list[i].mo_name) == NULL) 22457c478bd9Sstevel@tonic-gate count++; 22467c478bd9Sstevel@tonic-gate } 22477c478bd9Sstevel@tonic-gate ASSERT(count >= omo->mo_count && 22487c478bd9Sstevel@tonic-gate count <= omo->mo_count + imo->mo_count); 22497c478bd9Sstevel@tonic-gate motbl = kmem_alloc(count * sizeof (mntopt_t), KM_SLEEP); 22507c478bd9Sstevel@tonic-gate for (i = 0; i < omo->mo_count; i++) 22517c478bd9Sstevel@tonic-gate vfs_copyopt(&omo->mo_list[i], &motbl[i]); 22527c478bd9Sstevel@tonic-gate freeidx = omo->mo_count; 22537c478bd9Sstevel@tonic-gate for (i = 0; i < imo->mo_count; i++) { 22547c478bd9Sstevel@tonic-gate if (imo->mo_list[i].mo_flags & MO_EMPTY) 22557c478bd9Sstevel@tonic-gate continue; 22567c478bd9Sstevel@tonic-gate if ((mop = vfs_hasopt(omo, imo->mo_list[i].mo_name)) != NULL) { 22577c478bd9Sstevel@tonic-gate char **newcanp; 22587c478bd9Sstevel@tonic-gate uint_t index = mop - omo->mo_list; 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate newcanp = vfs_mergecancelopts(mop, &motbl[index]); 22617c478bd9Sstevel@tonic-gate 22627c478bd9Sstevel@tonic-gate vfs_freeopt(&motbl[index]); 22637c478bd9Sstevel@tonic-gate vfs_copyopt(&imo->mo_list[i], &motbl[index]); 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate vfs_freecancelopt(motbl[index].mo_cancel); 22667c478bd9Sstevel@tonic-gate motbl[index].mo_cancel = newcanp; 22677c478bd9Sstevel@tonic-gate } else { 22687c478bd9Sstevel@tonic-gate /* 22697c478bd9Sstevel@tonic-gate * If it's a new option, just copy it over to the first 22707c478bd9Sstevel@tonic-gate * free location. 22717c478bd9Sstevel@tonic-gate */ 22727c478bd9Sstevel@tonic-gate vfs_copyopt(&imo->mo_list[i], &motbl[freeidx++]); 22737c478bd9Sstevel@tonic-gate } 22747c478bd9Sstevel@tonic-gate } 22757c478bd9Sstevel@tonic-gate dmo->mo_count = count; 22767c478bd9Sstevel@tonic-gate dmo->mo_list = motbl; 22777c478bd9Sstevel@tonic-gate } 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate /* 22807c478bd9Sstevel@tonic-gate * Functions to set and clear mount options in a mount options table. 22817c478bd9Sstevel@tonic-gate */ 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate /* 22847c478bd9Sstevel@tonic-gate * Clear a mount option, if it exists. 22857c478bd9Sstevel@tonic-gate * 22867c478bd9Sstevel@tonic-gate * The update_mnttab arg indicates whether mops is part of a vfs that is on 22877c478bd9Sstevel@tonic-gate * the vfs list. 22887c478bd9Sstevel@tonic-gate */ 22897c478bd9Sstevel@tonic-gate static void 22907c478bd9Sstevel@tonic-gate vfs_clearmntopt_nolock(mntopts_t *mops, const char *opt, int update_mnttab) 22917c478bd9Sstevel@tonic-gate { 22927c478bd9Sstevel@tonic-gate struct mntopt *mop; 22937c478bd9Sstevel@tonic-gate uint_t i, count; 22947c478bd9Sstevel@tonic-gate 22957c478bd9Sstevel@tonic-gate ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist)); 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate count = mops->mo_count; 22987c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) { 22997c478bd9Sstevel@tonic-gate mop = &mops->mo_list[i]; 23007c478bd9Sstevel@tonic-gate 23017c478bd9Sstevel@tonic-gate if (mop->mo_flags & MO_EMPTY) 23027c478bd9Sstevel@tonic-gate continue; 23037c478bd9Sstevel@tonic-gate if (strcmp(opt, mop->mo_name)) 23047c478bd9Sstevel@tonic-gate continue; 23057c478bd9Sstevel@tonic-gate mop->mo_flags &= ~MO_SET; 23067c478bd9Sstevel@tonic-gate if (mop->mo_arg != NULL) { 23077c478bd9Sstevel@tonic-gate kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1); 23087c478bd9Sstevel@tonic-gate } 23097c478bd9Sstevel@tonic-gate mop->mo_arg = NULL; 23107c478bd9Sstevel@tonic-gate if (update_mnttab) 23117c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd(); 23127c478bd9Sstevel@tonic-gate break; 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate } 23157c478bd9Sstevel@tonic-gate 23167c478bd9Sstevel@tonic-gate void 23177c478bd9Sstevel@tonic-gate vfs_clearmntopt(struct vfs *vfsp, const char *opt) 23187c478bd9Sstevel@tonic-gate { 23197c478bd9Sstevel@tonic-gate int gotlock = 0; 23207c478bd9Sstevel@tonic-gate 23217c478bd9Sstevel@tonic-gate if (VFS_ON_LIST(vfsp)) { 23227c478bd9Sstevel@tonic-gate gotlock = 1; 23237c478bd9Sstevel@tonic-gate vfs_list_lock(); 23247c478bd9Sstevel@tonic-gate } 23257c478bd9Sstevel@tonic-gate vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, opt, gotlock); 23267c478bd9Sstevel@tonic-gate if (gotlock) 23277c478bd9Sstevel@tonic-gate vfs_list_unlock(); 23287c478bd9Sstevel@tonic-gate } 23297c478bd9Sstevel@tonic-gate 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate /* 23327c478bd9Sstevel@tonic-gate * Set a mount option on. If it's not found in the table, it's silently 23337c478bd9Sstevel@tonic-gate * ignored. If the option has MO_IGNORE set, it is still set unless the 23347c478bd9Sstevel@tonic-gate * VFS_NOFORCEOPT bit is set in the flags. Also, VFS_DISPLAY/VFS_NODISPLAY flag 23357c478bd9Sstevel@tonic-gate * bits can be used to toggle the MO_NODISPLAY bit for the option. 23367c478bd9Sstevel@tonic-gate * If the VFS_CREATEOPT flag bit is set then the first option slot with 23377c478bd9Sstevel@tonic-gate * MO_EMPTY set is created as the option passed in. 23387c478bd9Sstevel@tonic-gate * 23397c478bd9Sstevel@tonic-gate * The update_mnttab arg indicates whether mops is part of a vfs that is on 23407c478bd9Sstevel@tonic-gate * the vfs list. 23417c478bd9Sstevel@tonic-gate */ 23427c478bd9Sstevel@tonic-gate static void 23437c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(mntopts_t *mops, const char *opt, 23447c478bd9Sstevel@tonic-gate const char *arg, int flags, int update_mnttab) 23457c478bd9Sstevel@tonic-gate { 23467c478bd9Sstevel@tonic-gate mntopt_t *mop; 23477c478bd9Sstevel@tonic-gate uint_t i, count; 23487c478bd9Sstevel@tonic-gate char *sp; 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist)); 23517c478bd9Sstevel@tonic-gate 23527c478bd9Sstevel@tonic-gate if (flags & VFS_CREATEOPT) { 23537c478bd9Sstevel@tonic-gate if (vfs_hasopt(mops, opt) != NULL) { 23547c478bd9Sstevel@tonic-gate flags &= ~VFS_CREATEOPT; 23557c478bd9Sstevel@tonic-gate } 23567c478bd9Sstevel@tonic-gate } 23577c478bd9Sstevel@tonic-gate count = mops->mo_count; 23587c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) { 23597c478bd9Sstevel@tonic-gate mop = &mops->mo_list[i]; 23607c478bd9Sstevel@tonic-gate 23617c478bd9Sstevel@tonic-gate if (mop->mo_flags & MO_EMPTY) { 23627c478bd9Sstevel@tonic-gate if ((flags & VFS_CREATEOPT) == 0) 23637c478bd9Sstevel@tonic-gate continue; 23647c478bd9Sstevel@tonic-gate sp = kmem_alloc(strlen(opt) + 1, KM_SLEEP); 23657c478bd9Sstevel@tonic-gate (void) strcpy(sp, opt); 23667c478bd9Sstevel@tonic-gate mop->mo_name = sp; 23677c478bd9Sstevel@tonic-gate if (arg != NULL) 23687c478bd9Sstevel@tonic-gate mop->mo_flags = MO_HASVALUE; 23697c478bd9Sstevel@tonic-gate else 23707c478bd9Sstevel@tonic-gate mop->mo_flags = 0; 23717c478bd9Sstevel@tonic-gate } else if (strcmp(opt, mop->mo_name)) { 23727c478bd9Sstevel@tonic-gate continue; 23737c478bd9Sstevel@tonic-gate } 23747c478bd9Sstevel@tonic-gate if ((mop->mo_flags & MO_IGNORE) && (flags & VFS_NOFORCEOPT)) 23757c478bd9Sstevel@tonic-gate break; 23767c478bd9Sstevel@tonic-gate if (arg != NULL && (mop->mo_flags & MO_HASVALUE) != 0) { 23777c478bd9Sstevel@tonic-gate sp = kmem_alloc(strlen(arg) + 1, KM_SLEEP); 23787c478bd9Sstevel@tonic-gate (void) strcpy(sp, arg); 23797c478bd9Sstevel@tonic-gate } else { 23807c478bd9Sstevel@tonic-gate sp = NULL; 23817c478bd9Sstevel@tonic-gate } 23827c478bd9Sstevel@tonic-gate if (mop->mo_arg != NULL) 23837c478bd9Sstevel@tonic-gate kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1); 23847c478bd9Sstevel@tonic-gate mop->mo_arg = sp; 23857c478bd9Sstevel@tonic-gate if (flags & VFS_DISPLAY) 23867c478bd9Sstevel@tonic-gate mop->mo_flags &= ~MO_NODISPLAY; 23877c478bd9Sstevel@tonic-gate if (flags & VFS_NODISPLAY) 23887c478bd9Sstevel@tonic-gate mop->mo_flags |= MO_NODISPLAY; 23897c478bd9Sstevel@tonic-gate mop->mo_flags |= MO_SET; 23907c478bd9Sstevel@tonic-gate if (mop->mo_cancel != NULL) { 23917c478bd9Sstevel@tonic-gate char **cp; 23927c478bd9Sstevel@tonic-gate 23937c478bd9Sstevel@tonic-gate for (cp = mop->mo_cancel; *cp != NULL; cp++) 23947c478bd9Sstevel@tonic-gate vfs_clearmntopt_nolock(mops, *cp, 0); 23957c478bd9Sstevel@tonic-gate } 23967c478bd9Sstevel@tonic-gate if (update_mnttab) 23977c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd(); 23987c478bd9Sstevel@tonic-gate break; 23997c478bd9Sstevel@tonic-gate } 24007c478bd9Sstevel@tonic-gate } 24017c478bd9Sstevel@tonic-gate 24027c478bd9Sstevel@tonic-gate void 24037c478bd9Sstevel@tonic-gate vfs_setmntopt(struct vfs *vfsp, const char *opt, const char *arg, int flags) 24047c478bd9Sstevel@tonic-gate { 24057c478bd9Sstevel@tonic-gate int gotlock = 0; 24067c478bd9Sstevel@tonic-gate 24077c478bd9Sstevel@tonic-gate if (VFS_ON_LIST(vfsp)) { 24087c478bd9Sstevel@tonic-gate gotlock = 1; 24097c478bd9Sstevel@tonic-gate vfs_list_lock(); 24107c478bd9Sstevel@tonic-gate } 24117c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(&vfsp->vfs_mntopts, opt, arg, flags, gotlock); 24127c478bd9Sstevel@tonic-gate if (gotlock) 24137c478bd9Sstevel@tonic-gate vfs_list_unlock(); 24147c478bd9Sstevel@tonic-gate } 24157c478bd9Sstevel@tonic-gate 24167c478bd9Sstevel@tonic-gate 24177c478bd9Sstevel@tonic-gate /* 24187c478bd9Sstevel@tonic-gate * Add a "tag" option to a mounted file system's options list. 24197c478bd9Sstevel@tonic-gate * 24207c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 24217c478bd9Sstevel@tonic-gate * to protect mops. 24227c478bd9Sstevel@tonic-gate */ 24237c478bd9Sstevel@tonic-gate static mntopt_t * 24247c478bd9Sstevel@tonic-gate vfs_addtag(mntopts_t *mops, const char *tag) 24257c478bd9Sstevel@tonic-gate { 24267c478bd9Sstevel@tonic-gate uint_t count; 24277c478bd9Sstevel@tonic-gate mntopt_t *mop, *motbl; 24287c478bd9Sstevel@tonic-gate 24297c478bd9Sstevel@tonic-gate count = mops->mo_count + 1; 24307c478bd9Sstevel@tonic-gate motbl = kmem_zalloc(count * sizeof (mntopt_t), KM_SLEEP); 24317c478bd9Sstevel@tonic-gate if (mops->mo_count) { 24327c478bd9Sstevel@tonic-gate size_t len = (count - 1) * sizeof (mntopt_t); 24337c478bd9Sstevel@tonic-gate 24347c478bd9Sstevel@tonic-gate bcopy(mops->mo_list, motbl, len); 24357c478bd9Sstevel@tonic-gate kmem_free(mops->mo_list, len); 24367c478bd9Sstevel@tonic-gate } 24377c478bd9Sstevel@tonic-gate mops->mo_count = count; 24387c478bd9Sstevel@tonic-gate mops->mo_list = motbl; 24397c478bd9Sstevel@tonic-gate mop = &motbl[count - 1]; 24407c478bd9Sstevel@tonic-gate mop->mo_flags = MO_TAG; 24417c478bd9Sstevel@tonic-gate mop->mo_name = kmem_alloc(strlen(tag) + 1, KM_SLEEP); 24427c478bd9Sstevel@tonic-gate (void) strcpy(mop->mo_name, tag); 24437c478bd9Sstevel@tonic-gate return (mop); 24447c478bd9Sstevel@tonic-gate } 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate /* 24477c478bd9Sstevel@tonic-gate * Allow users to set arbitrary "tags" in a vfs's mount options. 24487c478bd9Sstevel@tonic-gate * Broader use within the kernel is discouraged. 24497c478bd9Sstevel@tonic-gate */ 24507c478bd9Sstevel@tonic-gate int 24517c478bd9Sstevel@tonic-gate vfs_settag(uint_t major, uint_t minor, const char *mntpt, const char *tag, 24527c478bd9Sstevel@tonic-gate cred_t *cr) 24537c478bd9Sstevel@tonic-gate { 24547c478bd9Sstevel@tonic-gate vfs_t *vfsp; 24557c478bd9Sstevel@tonic-gate mntopts_t *mops; 24567c478bd9Sstevel@tonic-gate mntopt_t *mop; 24577c478bd9Sstevel@tonic-gate int found = 0; 24587c478bd9Sstevel@tonic-gate dev_t dev = makedevice(major, minor); 24597c478bd9Sstevel@tonic-gate int err = 0; 24607c478bd9Sstevel@tonic-gate char *buf = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP); 24617c478bd9Sstevel@tonic-gate 24627c478bd9Sstevel@tonic-gate /* 24637c478bd9Sstevel@tonic-gate * Find the desired mounted file system 24647c478bd9Sstevel@tonic-gate */ 24657c478bd9Sstevel@tonic-gate vfs_list_lock(); 24667c478bd9Sstevel@tonic-gate vfsp = rootvfs; 24677c478bd9Sstevel@tonic-gate do { 24687c478bd9Sstevel@tonic-gate if (vfsp->vfs_dev == dev && 24697c478bd9Sstevel@tonic-gate strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) { 24707c478bd9Sstevel@tonic-gate found = 1; 24717c478bd9Sstevel@tonic-gate break; 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 24747c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 24757c478bd9Sstevel@tonic-gate 24767c478bd9Sstevel@tonic-gate if (!found) { 24777c478bd9Sstevel@tonic-gate err = EINVAL; 24787c478bd9Sstevel@tonic-gate goto out; 24797c478bd9Sstevel@tonic-gate } 24807c478bd9Sstevel@tonic-gate err = secpolicy_fs_config(cr, vfsp); 24817c478bd9Sstevel@tonic-gate if (err != 0) 24827c478bd9Sstevel@tonic-gate goto out; 24837c478bd9Sstevel@tonic-gate 24847c478bd9Sstevel@tonic-gate mops = &vfsp->vfs_mntopts; 24857c478bd9Sstevel@tonic-gate /* 24867c478bd9Sstevel@tonic-gate * Add tag if it doesn't already exist 24877c478bd9Sstevel@tonic-gate */ 24887c478bd9Sstevel@tonic-gate if ((mop = vfs_hasopt(mops, tag)) == NULL) { 24897c478bd9Sstevel@tonic-gate int len; 24907c478bd9Sstevel@tonic-gate 24917c478bd9Sstevel@tonic-gate (void) vfs_buildoptionstr(mops, buf, MAX_MNTOPT_STR); 24927c478bd9Sstevel@tonic-gate len = strlen(buf); 24937c478bd9Sstevel@tonic-gate if (len + strlen(tag) + 2 > MAX_MNTOPT_STR) { 24947c478bd9Sstevel@tonic-gate err = ENAMETOOLONG; 24957c478bd9Sstevel@tonic-gate goto out; 24967c478bd9Sstevel@tonic-gate } 24977c478bd9Sstevel@tonic-gate mop = vfs_addtag(mops, tag); 24987c478bd9Sstevel@tonic-gate } 24997c478bd9Sstevel@tonic-gate if ((mop->mo_flags & MO_TAG) == 0) { 25007c478bd9Sstevel@tonic-gate err = EINVAL; 25017c478bd9Sstevel@tonic-gate goto out; 25027c478bd9Sstevel@tonic-gate } 25037c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(mops, tag, NULL, 0, 1); 25047c478bd9Sstevel@tonic-gate out: 25057c478bd9Sstevel@tonic-gate vfs_list_unlock(); 25067c478bd9Sstevel@tonic-gate kmem_free(buf, MAX_MNTOPT_STR); 25077c478bd9Sstevel@tonic-gate return (err); 25087c478bd9Sstevel@tonic-gate } 25097c478bd9Sstevel@tonic-gate 25107c478bd9Sstevel@tonic-gate /* 25117c478bd9Sstevel@tonic-gate * Allow users to remove arbitrary "tags" in a vfs's mount options. 25127c478bd9Sstevel@tonic-gate * Broader use within the kernel is discouraged. 25137c478bd9Sstevel@tonic-gate */ 25147c478bd9Sstevel@tonic-gate int 25157c478bd9Sstevel@tonic-gate vfs_clrtag(uint_t major, uint_t minor, const char *mntpt, const char *tag, 25167c478bd9Sstevel@tonic-gate cred_t *cr) 25177c478bd9Sstevel@tonic-gate { 25187c478bd9Sstevel@tonic-gate vfs_t *vfsp; 25197c478bd9Sstevel@tonic-gate mntopt_t *mop; 25207c478bd9Sstevel@tonic-gate int found = 0; 25217c478bd9Sstevel@tonic-gate dev_t dev = makedevice(major, minor); 25227c478bd9Sstevel@tonic-gate int err = 0; 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate /* 25257c478bd9Sstevel@tonic-gate * Find the desired mounted file system 25267c478bd9Sstevel@tonic-gate */ 25277c478bd9Sstevel@tonic-gate vfs_list_lock(); 25287c478bd9Sstevel@tonic-gate vfsp = rootvfs; 25297c478bd9Sstevel@tonic-gate do { 25307c478bd9Sstevel@tonic-gate if (vfsp->vfs_dev == dev && 25317c478bd9Sstevel@tonic-gate strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) { 25327c478bd9Sstevel@tonic-gate found = 1; 25337c478bd9Sstevel@tonic-gate break; 25347c478bd9Sstevel@tonic-gate } 25357c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 25367c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 25377c478bd9Sstevel@tonic-gate 25387c478bd9Sstevel@tonic-gate if (!found) { 25397c478bd9Sstevel@tonic-gate err = EINVAL; 25407c478bd9Sstevel@tonic-gate goto out; 25417c478bd9Sstevel@tonic-gate } 25427c478bd9Sstevel@tonic-gate err = secpolicy_fs_config(cr, vfsp); 25437c478bd9Sstevel@tonic-gate if (err != 0) 25447c478bd9Sstevel@tonic-gate goto out; 25457c478bd9Sstevel@tonic-gate 25467c478bd9Sstevel@tonic-gate if ((mop = vfs_hasopt(&vfsp->vfs_mntopts, tag)) == NULL) { 25477c478bd9Sstevel@tonic-gate err = EINVAL; 25487c478bd9Sstevel@tonic-gate goto out; 25497c478bd9Sstevel@tonic-gate } 25507c478bd9Sstevel@tonic-gate if ((mop->mo_flags & MO_TAG) == 0) { 25517c478bd9Sstevel@tonic-gate err = EINVAL; 25527c478bd9Sstevel@tonic-gate goto out; 25537c478bd9Sstevel@tonic-gate } 25547c478bd9Sstevel@tonic-gate vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, tag, 1); 25557c478bd9Sstevel@tonic-gate out: 25567c478bd9Sstevel@tonic-gate vfs_list_unlock(); 25577c478bd9Sstevel@tonic-gate return (err); 25587c478bd9Sstevel@tonic-gate } 25597c478bd9Sstevel@tonic-gate 25607c478bd9Sstevel@tonic-gate /* 25617c478bd9Sstevel@tonic-gate * Function to parse an option string and fill in a mount options table. 25627c478bd9Sstevel@tonic-gate * Unknown options are silently ignored. The input option string is modified 25637c478bd9Sstevel@tonic-gate * by replacing separators with nulls. If the create flag is set, options 25647c478bd9Sstevel@tonic-gate * not found in the table are just added on the fly. The table must have 25657c478bd9Sstevel@tonic-gate * an option slot marked MO_EMPTY to add an option on the fly. 25667c478bd9Sstevel@tonic-gate * 25677c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 25687c478bd9Sstevel@tonic-gate * 25697c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 25707c478bd9Sstevel@tonic-gate * to protect mops.. 25717c478bd9Sstevel@tonic-gate */ 25727c478bd9Sstevel@tonic-gate void 25737c478bd9Sstevel@tonic-gate vfs_parsemntopts(mntopts_t *mops, char *osp, int create) 25747c478bd9Sstevel@tonic-gate { 25757c478bd9Sstevel@tonic-gate char *s = osp, *p, *nextop, *valp, *cp, *ep; 25767c478bd9Sstevel@tonic-gate int setflg = VFS_NOFORCEOPT; 25777c478bd9Sstevel@tonic-gate 25787c478bd9Sstevel@tonic-gate if (osp == NULL) 25797c478bd9Sstevel@tonic-gate return; 25807c478bd9Sstevel@tonic-gate while (*s != '\0') { 25817c478bd9Sstevel@tonic-gate p = strchr(s, ','); /* find next option */ 25827c478bd9Sstevel@tonic-gate if (p == NULL) { 25837c478bd9Sstevel@tonic-gate cp = NULL; 25847c478bd9Sstevel@tonic-gate p = s + strlen(s); 25857c478bd9Sstevel@tonic-gate } else { 25867c478bd9Sstevel@tonic-gate cp = p; /* save location of comma */ 25877c478bd9Sstevel@tonic-gate *p++ = '\0'; /* mark end and point to next option */ 25887c478bd9Sstevel@tonic-gate } 25897c478bd9Sstevel@tonic-gate nextop = p; 25907c478bd9Sstevel@tonic-gate p = strchr(s, '='); /* look for value */ 25917c478bd9Sstevel@tonic-gate if (p == NULL) { 25927c478bd9Sstevel@tonic-gate valp = NULL; /* no value supplied */ 25937c478bd9Sstevel@tonic-gate } else { 25947c478bd9Sstevel@tonic-gate ep = p; /* save location of equals */ 25957c478bd9Sstevel@tonic-gate *p++ = '\0'; /* end option and point to value */ 25967c478bd9Sstevel@tonic-gate valp = p; 25977c478bd9Sstevel@tonic-gate } 25987c478bd9Sstevel@tonic-gate /* 25997c478bd9Sstevel@tonic-gate * set option into options table 26007c478bd9Sstevel@tonic-gate */ 26017c478bd9Sstevel@tonic-gate if (create) 26027c478bd9Sstevel@tonic-gate setflg |= VFS_CREATEOPT; 26037c478bd9Sstevel@tonic-gate vfs_setmntopt_nolock(mops, s, valp, setflg, 0); 26047c478bd9Sstevel@tonic-gate if (cp != NULL) 26057c478bd9Sstevel@tonic-gate *cp = ','; /* restore the comma */ 26067c478bd9Sstevel@tonic-gate if (valp != NULL) 26077c478bd9Sstevel@tonic-gate *ep = '='; /* restore the equals */ 26087c478bd9Sstevel@tonic-gate s = nextop; 26097c478bd9Sstevel@tonic-gate } 26107c478bd9Sstevel@tonic-gate } 26117c478bd9Sstevel@tonic-gate 26127c478bd9Sstevel@tonic-gate /* 26137c478bd9Sstevel@tonic-gate * Function to inquire if an option exists in a mount options table. 26147c478bd9Sstevel@tonic-gate * Returns a pointer to the option if it exists, else NULL. 26157c478bd9Sstevel@tonic-gate * 26167c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 26177c478bd9Sstevel@tonic-gate * 26187c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 26197c478bd9Sstevel@tonic-gate * to protect mops. 26207c478bd9Sstevel@tonic-gate */ 26217c478bd9Sstevel@tonic-gate struct mntopt * 26227c478bd9Sstevel@tonic-gate vfs_hasopt(const mntopts_t *mops, const char *opt) 26237c478bd9Sstevel@tonic-gate { 26247c478bd9Sstevel@tonic-gate struct mntopt *mop; 26257c478bd9Sstevel@tonic-gate uint_t i, count; 26267c478bd9Sstevel@tonic-gate 26277c478bd9Sstevel@tonic-gate count = mops->mo_count; 26287c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) { 26297c478bd9Sstevel@tonic-gate mop = &mops->mo_list[i]; 26307c478bd9Sstevel@tonic-gate 26317c478bd9Sstevel@tonic-gate if (mop->mo_flags & MO_EMPTY) 26327c478bd9Sstevel@tonic-gate continue; 26337c478bd9Sstevel@tonic-gate if (strcmp(opt, mop->mo_name) == 0) 26347c478bd9Sstevel@tonic-gate return (mop); 26357c478bd9Sstevel@tonic-gate } 26367c478bd9Sstevel@tonic-gate return (NULL); 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate 26397c478bd9Sstevel@tonic-gate /* 26407c478bd9Sstevel@tonic-gate * Function to inquire if an option is set in a mount options table. 26417c478bd9Sstevel@tonic-gate * Returns non-zero if set and fills in the arg pointer with a pointer to 26427c478bd9Sstevel@tonic-gate * the argument string or NULL if there is no argument string. 26437c478bd9Sstevel@tonic-gate */ 26447c478bd9Sstevel@tonic-gate static int 26457c478bd9Sstevel@tonic-gate vfs_optionisset_nolock(const mntopts_t *mops, const char *opt, char **argp) 26467c478bd9Sstevel@tonic-gate { 26477c478bd9Sstevel@tonic-gate struct mntopt *mop; 26487c478bd9Sstevel@tonic-gate uint_t i, count; 26497c478bd9Sstevel@tonic-gate 26507c478bd9Sstevel@tonic-gate count = mops->mo_count; 26517c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) { 26527c478bd9Sstevel@tonic-gate mop = &mops->mo_list[i]; 26537c478bd9Sstevel@tonic-gate 26547c478bd9Sstevel@tonic-gate if (mop->mo_flags & MO_EMPTY) 26557c478bd9Sstevel@tonic-gate continue; 26567c478bd9Sstevel@tonic-gate if (strcmp(opt, mop->mo_name)) 26577c478bd9Sstevel@tonic-gate continue; 26587c478bd9Sstevel@tonic-gate if ((mop->mo_flags & MO_SET) == 0) 26597c478bd9Sstevel@tonic-gate return (0); 26607c478bd9Sstevel@tonic-gate if (argp != NULL && (mop->mo_flags & MO_HASVALUE) != 0) 26617c478bd9Sstevel@tonic-gate *argp = mop->mo_arg; 26627c478bd9Sstevel@tonic-gate return (1); 26637c478bd9Sstevel@tonic-gate } 26647c478bd9Sstevel@tonic-gate return (0); 26657c478bd9Sstevel@tonic-gate } 26667c478bd9Sstevel@tonic-gate 26677c478bd9Sstevel@tonic-gate 26687c478bd9Sstevel@tonic-gate int 26697c478bd9Sstevel@tonic-gate vfs_optionisset(const struct vfs *vfsp, const char *opt, char **argp) 26707c478bd9Sstevel@tonic-gate { 26717c478bd9Sstevel@tonic-gate int ret; 26727c478bd9Sstevel@tonic-gate 26737c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 26747c478bd9Sstevel@tonic-gate ret = vfs_optionisset_nolock(&vfsp->vfs_mntopts, opt, argp); 26757c478bd9Sstevel@tonic-gate vfs_list_unlock(); 26767c478bd9Sstevel@tonic-gate return (ret); 26777c478bd9Sstevel@tonic-gate } 26787c478bd9Sstevel@tonic-gate 26797c478bd9Sstevel@tonic-gate 26807c478bd9Sstevel@tonic-gate /* 26817c478bd9Sstevel@tonic-gate * Construct a comma separated string of the options set in the given 26827c478bd9Sstevel@tonic-gate * mount table, return the string in the given buffer. Return non-zero if 26837c478bd9Sstevel@tonic-gate * the buffer would overflow. 26847c478bd9Sstevel@tonic-gate * 26857c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 26867c478bd9Sstevel@tonic-gate * 26877c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 26887c478bd9Sstevel@tonic-gate * to protect mp. 26897c478bd9Sstevel@tonic-gate */ 26907c478bd9Sstevel@tonic-gate int 26917c478bd9Sstevel@tonic-gate vfs_buildoptionstr(const mntopts_t *mp, char *buf, int len) 26927c478bd9Sstevel@tonic-gate { 26937c478bd9Sstevel@tonic-gate char *cp; 26947c478bd9Sstevel@tonic-gate uint_t i; 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate buf[0] = '\0'; 26977c478bd9Sstevel@tonic-gate cp = buf; 26987c478bd9Sstevel@tonic-gate for (i = 0; i < mp->mo_count; i++) { 26997c478bd9Sstevel@tonic-gate struct mntopt *mop; 27007c478bd9Sstevel@tonic-gate 27017c478bd9Sstevel@tonic-gate mop = &mp->mo_list[i]; 27027c478bd9Sstevel@tonic-gate if (mop->mo_flags & MO_SET) { 27037c478bd9Sstevel@tonic-gate int optlen, comma = 0; 27047c478bd9Sstevel@tonic-gate 27057c478bd9Sstevel@tonic-gate if (buf[0] != '\0') 27067c478bd9Sstevel@tonic-gate comma = 1; 27077c478bd9Sstevel@tonic-gate optlen = strlen(mop->mo_name); 27087c478bd9Sstevel@tonic-gate if (strlen(buf) + comma + optlen + 1 > len) 27097c478bd9Sstevel@tonic-gate goto err; 27107c478bd9Sstevel@tonic-gate if (comma) 27117c478bd9Sstevel@tonic-gate *cp++ = ','; 27127c478bd9Sstevel@tonic-gate (void) strcpy(cp, mop->mo_name); 27137c478bd9Sstevel@tonic-gate cp += optlen; 27147c478bd9Sstevel@tonic-gate /* 27157c478bd9Sstevel@tonic-gate * Append option value if there is one 27167c478bd9Sstevel@tonic-gate */ 27177c478bd9Sstevel@tonic-gate if (mop->mo_arg != NULL) { 27187c478bd9Sstevel@tonic-gate int arglen; 27197c478bd9Sstevel@tonic-gate 27207c478bd9Sstevel@tonic-gate arglen = strlen(mop->mo_arg); 27217c478bd9Sstevel@tonic-gate if (strlen(buf) + arglen + 2 > len) 27227c478bd9Sstevel@tonic-gate goto err; 27237c478bd9Sstevel@tonic-gate *cp++ = '='; 27247c478bd9Sstevel@tonic-gate (void) strcpy(cp, mop->mo_arg); 27257c478bd9Sstevel@tonic-gate cp += arglen; 27267c478bd9Sstevel@tonic-gate } 27277c478bd9Sstevel@tonic-gate } 27287c478bd9Sstevel@tonic-gate } 27297c478bd9Sstevel@tonic-gate return (0); 27307c478bd9Sstevel@tonic-gate err: 27317c478bd9Sstevel@tonic-gate return (EOVERFLOW); 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate static void 27357c478bd9Sstevel@tonic-gate vfs_freecancelopt(char **moc) 27367c478bd9Sstevel@tonic-gate { 27377c478bd9Sstevel@tonic-gate if (moc != NULL) { 27387c478bd9Sstevel@tonic-gate int ccnt = 0; 27397c478bd9Sstevel@tonic-gate char **cp; 27407c478bd9Sstevel@tonic-gate 27417c478bd9Sstevel@tonic-gate for (cp = moc; *cp != NULL; cp++) { 27427c478bd9Sstevel@tonic-gate kmem_free(*cp, strlen(*cp) + 1); 27437c478bd9Sstevel@tonic-gate ccnt++; 27447c478bd9Sstevel@tonic-gate } 27457c478bd9Sstevel@tonic-gate kmem_free(moc, (ccnt + 1) * sizeof (char *)); 27467c478bd9Sstevel@tonic-gate } 27477c478bd9Sstevel@tonic-gate } 27487c478bd9Sstevel@tonic-gate 27497c478bd9Sstevel@tonic-gate static void 27507c478bd9Sstevel@tonic-gate vfs_freeopt(mntopt_t *mop) 27517c478bd9Sstevel@tonic-gate { 27527c478bd9Sstevel@tonic-gate if (mop->mo_name != NULL) 27537c478bd9Sstevel@tonic-gate kmem_free(mop->mo_name, strlen(mop->mo_name) + 1); 27547c478bd9Sstevel@tonic-gate 27557c478bd9Sstevel@tonic-gate vfs_freecancelopt(mop->mo_cancel); 27567c478bd9Sstevel@tonic-gate 27577c478bd9Sstevel@tonic-gate if (mop->mo_arg != NULL) 27587c478bd9Sstevel@tonic-gate kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1); 27597c478bd9Sstevel@tonic-gate } 27607c478bd9Sstevel@tonic-gate 27617c478bd9Sstevel@tonic-gate /* 27627c478bd9Sstevel@tonic-gate * Free a mount options table 27637c478bd9Sstevel@tonic-gate * 27647c478bd9Sstevel@tonic-gate * This function is *not* for general use by filesystems. 27657c478bd9Sstevel@tonic-gate * 27667c478bd9Sstevel@tonic-gate * Note: caller is responsible for locking the vfs list, if needed, 27677c478bd9Sstevel@tonic-gate * to protect mp. 27687c478bd9Sstevel@tonic-gate */ 27697c478bd9Sstevel@tonic-gate void 27707c478bd9Sstevel@tonic-gate vfs_freeopttbl(mntopts_t *mp) 27717c478bd9Sstevel@tonic-gate { 27727c478bd9Sstevel@tonic-gate uint_t i, count; 27737c478bd9Sstevel@tonic-gate 27747c478bd9Sstevel@tonic-gate count = mp->mo_count; 27757c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) { 27767c478bd9Sstevel@tonic-gate vfs_freeopt(&mp->mo_list[i]); 27777c478bd9Sstevel@tonic-gate } 27787c478bd9Sstevel@tonic-gate if (count) { 27797c478bd9Sstevel@tonic-gate kmem_free(mp->mo_list, sizeof (mntopt_t) * count); 27807c478bd9Sstevel@tonic-gate mp->mo_count = 0; 27817c478bd9Sstevel@tonic-gate mp->mo_list = NULL; 27827c478bd9Sstevel@tonic-gate } 27837c478bd9Sstevel@tonic-gate } 27847c478bd9Sstevel@tonic-gate 2785df2381bfSpraks 2786df2381bfSpraks /* ARGSUSED */ 2787df2381bfSpraks static int 2788df2381bfSpraks vfs_mntdummyread(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred, 2789df2381bfSpraks caller_context_t *ct) 2790df2381bfSpraks { 2791df2381bfSpraks return (0); 2792df2381bfSpraks } 2793df2381bfSpraks 2794df2381bfSpraks /* ARGSUSED */ 2795df2381bfSpraks static int 2796df2381bfSpraks vfs_mntdummywrite(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred, 2797df2381bfSpraks caller_context_t *ct) 2798df2381bfSpraks { 2799df2381bfSpraks return (0); 2800df2381bfSpraks } 2801df2381bfSpraks 2802df2381bfSpraks /* 2803df2381bfSpraks * The dummy vnode is currently used only by file events notification 2804df2381bfSpraks * module which is just interested in the timestamps. 2805df2381bfSpraks */ 2806df2381bfSpraks /* ARGSUSED */ 2807df2381bfSpraks static int 2808da6c28aaSamw vfs_mntdummygetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 2809da6c28aaSamw caller_context_t *ct) 2810df2381bfSpraks { 2811df2381bfSpraks bzero(vap, sizeof (vattr_t)); 2812df2381bfSpraks vap->va_type = VREG; 2813df2381bfSpraks vap->va_nlink = 1; 2814df2381bfSpraks vap->va_ctime = vfs_mnttab_ctime; 2815df2381bfSpraks /* 2816df2381bfSpraks * it is ok to just copy mtime as the time will be monotonically 2817df2381bfSpraks * increasing. 2818df2381bfSpraks */ 2819df2381bfSpraks vap->va_mtime = vfs_mnttab_mtime; 2820df2381bfSpraks vap->va_atime = vap->va_mtime; 2821df2381bfSpraks return (0); 2822df2381bfSpraks } 2823df2381bfSpraks 2824df2381bfSpraks static void 2825df2381bfSpraks vfs_mnttabvp_setup(void) 2826df2381bfSpraks { 2827df2381bfSpraks vnode_t *tvp; 2828df2381bfSpraks vnodeops_t *vfs_mntdummyvnops; 2829df2381bfSpraks const fs_operation_def_t mnt_dummyvnodeops_template[] = { 2830df2381bfSpraks VOPNAME_READ, { .vop_read = vfs_mntdummyread }, 2831df2381bfSpraks VOPNAME_WRITE, { .vop_write = vfs_mntdummywrite }, 2832df2381bfSpraks VOPNAME_GETATTR, { .vop_getattr = vfs_mntdummygetattr }, 2833df2381bfSpraks VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 2834df2381bfSpraks NULL, NULL 2835df2381bfSpraks }; 2836df2381bfSpraks 2837df2381bfSpraks if (vn_make_ops("mnttab", mnt_dummyvnodeops_template, 2838df2381bfSpraks &vfs_mntdummyvnops) != 0) { 2839df2381bfSpraks cmn_err(CE_WARN, "vfs_mnttabvp_setup: vn_make_ops failed"); 2840df2381bfSpraks /* Shouldn't happen, but not bad enough to panic */ 2841df2381bfSpraks return; 2842df2381bfSpraks } 2843df2381bfSpraks 2844df2381bfSpraks /* 2845df2381bfSpraks * A global dummy vnode is allocated to represent mntfs files. 2846df2381bfSpraks * The mntfs file (/etc/mnttab) can be monitored for file events 2847df2381bfSpraks * and receive an event when mnttab changes. Dummy VOP calls 2848df2381bfSpraks * will be made on this vnode. The file events notification module 2849df2381bfSpraks * intercepts this vnode and delivers relevant events. 2850df2381bfSpraks */ 2851df2381bfSpraks tvp = vn_alloc(KM_SLEEP); 2852df2381bfSpraks tvp->v_flag = VNOMOUNT|VNOMAP|VNOSWAP|VNOCACHE; 2853df2381bfSpraks vn_setops(tvp, vfs_mntdummyvnops); 2854df2381bfSpraks tvp->v_type = VREG; 2855df2381bfSpraks /* 2856df2381bfSpraks * The mnt dummy ops do not reference v_data. 2857df2381bfSpraks * No other module intercepting this vnode should either. 2858df2381bfSpraks * Just set it to point to itself. 2859df2381bfSpraks */ 2860df2381bfSpraks tvp->v_data = (caddr_t)tvp; 2861df2381bfSpraks tvp->v_vfsp = rootvfs; 2862df2381bfSpraks vfs_mntdummyvp = tvp; 2863df2381bfSpraks } 2864df2381bfSpraks 2865df2381bfSpraks /* 2866df2381bfSpraks * performs fake read/write ops 2867df2381bfSpraks */ 2868df2381bfSpraks static void 2869df2381bfSpraks vfs_mnttab_rwop(int rw) 2870df2381bfSpraks { 2871df2381bfSpraks struct uio uio; 2872df2381bfSpraks struct iovec iov; 2873df2381bfSpraks char buf[1]; 2874df2381bfSpraks 2875df2381bfSpraks if (vfs_mntdummyvp == NULL) 2876df2381bfSpraks return; 2877df2381bfSpraks 2878df2381bfSpraks bzero(&uio, sizeof (uio)); 2879df2381bfSpraks bzero(&iov, sizeof (iov)); 2880df2381bfSpraks iov.iov_base = buf; 2881df2381bfSpraks iov.iov_len = 0; 2882df2381bfSpraks uio.uio_iov = &iov; 2883df2381bfSpraks uio.uio_iovcnt = 1; 2884df2381bfSpraks uio.uio_loffset = 0; 2885df2381bfSpraks uio.uio_segflg = UIO_SYSSPACE; 2886df2381bfSpraks uio.uio_resid = 0; 2887df2381bfSpraks if (rw) { 2888df2381bfSpraks (void) VOP_WRITE(vfs_mntdummyvp, &uio, 0, kcred, NULL); 2889df2381bfSpraks } else { 2890df2381bfSpraks (void) VOP_READ(vfs_mntdummyvp, &uio, 0, kcred, NULL); 2891df2381bfSpraks } 2892df2381bfSpraks } 2893df2381bfSpraks 2894df2381bfSpraks /* 2895df2381bfSpraks * Generate a write operation. 2896df2381bfSpraks */ 2897df2381bfSpraks void 2898df2381bfSpraks vfs_mnttab_writeop(void) 2899df2381bfSpraks { 2900df2381bfSpraks vfs_mnttab_rwop(1); 2901df2381bfSpraks } 2902df2381bfSpraks 2903df2381bfSpraks /* 2904df2381bfSpraks * Generate a read operation. 2905df2381bfSpraks */ 2906df2381bfSpraks void 2907df2381bfSpraks vfs_mnttab_readop(void) 2908df2381bfSpraks { 2909df2381bfSpraks vfs_mnttab_rwop(0); 2910df2381bfSpraks } 2911df2381bfSpraks 29127c478bd9Sstevel@tonic-gate /* 29137c478bd9Sstevel@tonic-gate * Free any mnttab information recorded in the vfs struct. 29147c478bd9Sstevel@tonic-gate * The vfs must not be on the vfs list. 29157c478bd9Sstevel@tonic-gate */ 29167c478bd9Sstevel@tonic-gate static void 29177c478bd9Sstevel@tonic-gate vfs_freemnttab(struct vfs *vfsp) 29187c478bd9Sstevel@tonic-gate { 29197c478bd9Sstevel@tonic-gate ASSERT(!VFS_ON_LIST(vfsp)); 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate /* 29227c478bd9Sstevel@tonic-gate * Free device and mount point information 29237c478bd9Sstevel@tonic-gate */ 29247c478bd9Sstevel@tonic-gate if (vfsp->vfs_mntpt != NULL) { 29257c478bd9Sstevel@tonic-gate refstr_rele(vfsp->vfs_mntpt); 29267c478bd9Sstevel@tonic-gate vfsp->vfs_mntpt = NULL; 29277c478bd9Sstevel@tonic-gate } 29287c478bd9Sstevel@tonic-gate if (vfsp->vfs_resource != NULL) { 29297c478bd9Sstevel@tonic-gate refstr_rele(vfsp->vfs_resource); 29307c478bd9Sstevel@tonic-gate vfsp->vfs_resource = NULL; 29317c478bd9Sstevel@tonic-gate } 29327c478bd9Sstevel@tonic-gate /* 29337c478bd9Sstevel@tonic-gate * Now free mount options information 29347c478bd9Sstevel@tonic-gate */ 29357c478bd9Sstevel@tonic-gate vfs_freeopttbl(&vfsp->vfs_mntopts); 29367c478bd9Sstevel@tonic-gate } 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate /* 29397c478bd9Sstevel@tonic-gate * Return the last mnttab modification time 29407c478bd9Sstevel@tonic-gate */ 29417c478bd9Sstevel@tonic-gate void 29427c478bd9Sstevel@tonic-gate vfs_mnttab_modtime(timespec_t *ts) 29437c478bd9Sstevel@tonic-gate { 29447c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&vfslist)); 29457c478bd9Sstevel@tonic-gate *ts = vfs_mnttab_mtime; 29467c478bd9Sstevel@tonic-gate } 29477c478bd9Sstevel@tonic-gate 29487c478bd9Sstevel@tonic-gate /* 29497c478bd9Sstevel@tonic-gate * See if mnttab is changed 29507c478bd9Sstevel@tonic-gate */ 29517c478bd9Sstevel@tonic-gate void 29527c478bd9Sstevel@tonic-gate vfs_mnttab_poll(timespec_t *old, struct pollhead **phpp) 29537c478bd9Sstevel@tonic-gate { 29547c478bd9Sstevel@tonic-gate int changed; 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate *phpp = (struct pollhead *)NULL; 29577c478bd9Sstevel@tonic-gate 29587c478bd9Sstevel@tonic-gate /* 29597c478bd9Sstevel@tonic-gate * Note: don't grab vfs list lock before accessing vfs_mnttab_mtime. 29607c478bd9Sstevel@tonic-gate * Can lead to deadlock against vfs_mnttab_modtimeupd(). It is safe 29617c478bd9Sstevel@tonic-gate * to not grab the vfs list lock because tv_sec is monotonically 29627c478bd9Sstevel@tonic-gate * increasing. 29637c478bd9Sstevel@tonic-gate */ 29647c478bd9Sstevel@tonic-gate 29657c478bd9Sstevel@tonic-gate changed = (old->tv_nsec != vfs_mnttab_mtime.tv_nsec) || 29667c478bd9Sstevel@tonic-gate (old->tv_sec != vfs_mnttab_mtime.tv_sec); 29677c478bd9Sstevel@tonic-gate if (!changed) { 29687c478bd9Sstevel@tonic-gate *phpp = &vfs_pollhd; 29697c478bd9Sstevel@tonic-gate } 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate 2972835ee219SRobert Harris /* Provide a unique and monotonically-increasing timestamp. */ 2973835ee219SRobert Harris void 2974835ee219SRobert Harris vfs_mono_time(timespec_t *ts) 2975835ee219SRobert Harris { 2976835ee219SRobert Harris static volatile hrtime_t hrt; /* The saved time. */ 2977835ee219SRobert Harris hrtime_t newhrt, oldhrt; /* For effecting the CAS. */ 2978835ee219SRobert Harris timespec_t newts; 2979835ee219SRobert Harris 29804ba8a214SRobert Harris /* 29814ba8a214SRobert Harris * Try gethrestime() first, but be prepared to fabricate a sensible 29824ba8a214SRobert Harris * answer at the first sign of any trouble. 29834ba8a214SRobert Harris */ 2984835ee219SRobert Harris gethrestime(&newts); 2985835ee219SRobert Harris newhrt = ts2hrt(&newts); 29864ba8a214SRobert Harris for (;;) { 2987835ee219SRobert Harris oldhrt = hrt; 29884ba8a214SRobert Harris if (newhrt <= hrt) 29894ba8a214SRobert Harris newhrt = hrt + 1; 29904ba8a214SRobert Harris if (cas64((uint64_t *)&hrt, oldhrt, newhrt) == oldhrt) 29914ba8a214SRobert Harris break; 29924ba8a214SRobert Harris } 2993835ee219SRobert Harris hrt2ts(newhrt, ts); 2994835ee219SRobert Harris } 2995835ee219SRobert Harris 29967c478bd9Sstevel@tonic-gate /* 29977c478bd9Sstevel@tonic-gate * Update the mnttab modification time and wake up any waiters for 29987c478bd9Sstevel@tonic-gate * mnttab changes 29997c478bd9Sstevel@tonic-gate */ 30007c478bd9Sstevel@tonic-gate void 30017c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd() 30027c478bd9Sstevel@tonic-gate { 30034ba8a214SRobert Harris hrtime_t oldhrt, newhrt; 30044ba8a214SRobert Harris 30057c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&vfslist)); 30064ba8a214SRobert Harris oldhrt = ts2hrt(&vfs_mnttab_mtime); 30074ba8a214SRobert Harris gethrestime(&vfs_mnttab_mtime); 30084ba8a214SRobert Harris newhrt = ts2hrt(&vfs_mnttab_mtime); 30094ba8a214SRobert Harris if (oldhrt == (hrtime_t)0) 30107c478bd9Sstevel@tonic-gate vfs_mnttab_ctime = vfs_mnttab_mtime; 30114ba8a214SRobert Harris /* 30124ba8a214SRobert Harris * Attempt to provide unique mtime (like uniqtime but not). 30134ba8a214SRobert Harris */ 30144ba8a214SRobert Harris if (newhrt == oldhrt) { 30154ba8a214SRobert Harris newhrt++; 30164ba8a214SRobert Harris hrt2ts(newhrt, &vfs_mnttab_mtime); 30174ba8a214SRobert Harris } 30187c478bd9Sstevel@tonic-gate pollwakeup(&vfs_pollhd, (short)POLLRDBAND); 3019df2381bfSpraks vfs_mnttab_writeop(); 30207c478bd9Sstevel@tonic-gate } 30217c478bd9Sstevel@tonic-gate 30227c478bd9Sstevel@tonic-gate int 30237c478bd9Sstevel@tonic-gate dounmount(struct vfs *vfsp, int flag, cred_t *cr) 30247c478bd9Sstevel@tonic-gate { 30257c478bd9Sstevel@tonic-gate vnode_t *coveredvp; 30267c478bd9Sstevel@tonic-gate int error; 30275a59a8b3Srsb extern void teardown_vopstats(vfs_t *); 30287c478bd9Sstevel@tonic-gate 30297c478bd9Sstevel@tonic-gate /* 30307c478bd9Sstevel@tonic-gate * Get covered vnode. This will be NULL if the vfs is not linked 30317c478bd9Sstevel@tonic-gate * into the file system name space (i.e., domount() with MNT_NOSPICE). 30327c478bd9Sstevel@tonic-gate */ 30337c478bd9Sstevel@tonic-gate coveredvp = vfsp->vfs_vnodecovered; 30347c478bd9Sstevel@tonic-gate ASSERT(coveredvp == NULL || vn_vfswlock_held(coveredvp)); 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate /* 30377c478bd9Sstevel@tonic-gate * Purge all dnlc entries for this vfs. 30387c478bd9Sstevel@tonic-gate */ 30397c478bd9Sstevel@tonic-gate (void) dnlc_purge_vfsp(vfsp, 0); 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate /* For forcible umount, skip VFS_SYNC() since it may hang */ 30427c478bd9Sstevel@tonic-gate if ((flag & MS_FORCE) == 0) 30437c478bd9Sstevel@tonic-gate (void) VFS_SYNC(vfsp, 0, cr); 30447c478bd9Sstevel@tonic-gate 30457c478bd9Sstevel@tonic-gate /* 30467c478bd9Sstevel@tonic-gate * Lock the vfs to maintain fs status quo during unmount. This 30477c478bd9Sstevel@tonic-gate * has to be done after the sync because ufs_update tries to acquire 30487c478bd9Sstevel@tonic-gate * the vfs_reflock. 30497c478bd9Sstevel@tonic-gate */ 30507c478bd9Sstevel@tonic-gate vfs_lock_wait(vfsp); 30517c478bd9Sstevel@tonic-gate 30527c478bd9Sstevel@tonic-gate if (error = VFS_UNMOUNT(vfsp, flag, cr)) { 30537c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 30547c478bd9Sstevel@tonic-gate if (coveredvp != NULL) 30557c478bd9Sstevel@tonic-gate vn_vfsunlock(coveredvp); 30567c478bd9Sstevel@tonic-gate } else if (coveredvp != NULL) { 30575a59a8b3Srsb teardown_vopstats(vfsp); 30587c478bd9Sstevel@tonic-gate /* 30597c478bd9Sstevel@tonic-gate * vfs_remove() will do a VN_RELE(vfsp->vfs_vnodecovered) 30607c478bd9Sstevel@tonic-gate * when it frees vfsp so we do a VN_HOLD() so we can 30617c478bd9Sstevel@tonic-gate * continue to use coveredvp afterwards. 30627c478bd9Sstevel@tonic-gate */ 30637c478bd9Sstevel@tonic-gate VN_HOLD(coveredvp); 30647c478bd9Sstevel@tonic-gate vfs_remove(vfsp); 30657c478bd9Sstevel@tonic-gate vn_vfsunlock(coveredvp); 30667c478bd9Sstevel@tonic-gate VN_RELE(coveredvp); 30677c478bd9Sstevel@tonic-gate } else { 30685a59a8b3Srsb teardown_vopstats(vfsp); 30697c478bd9Sstevel@tonic-gate /* 30707c478bd9Sstevel@tonic-gate * Release the reference to vfs that is not linked 30717c478bd9Sstevel@tonic-gate * into the name space. 30727c478bd9Sstevel@tonic-gate */ 30737c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 30747c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); 30757c478bd9Sstevel@tonic-gate } 30767c478bd9Sstevel@tonic-gate return (error); 30777c478bd9Sstevel@tonic-gate } 30787c478bd9Sstevel@tonic-gate 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate /* 30817c478bd9Sstevel@tonic-gate * Vfs_unmountall() is called by uadmin() to unmount all 30827c478bd9Sstevel@tonic-gate * mounted file systems (except the root file system) during shutdown. 30837c478bd9Sstevel@tonic-gate * It follows the existing locking protocol when traversing the vfs list 30847c478bd9Sstevel@tonic-gate * to sync and unmount vfses. Even though there should be no 30857c478bd9Sstevel@tonic-gate * other thread running while the system is shutting down, it is prudent 30867c478bd9Sstevel@tonic-gate * to still follow the locking protocol. 30877c478bd9Sstevel@tonic-gate */ 30887c478bd9Sstevel@tonic-gate void 30897c478bd9Sstevel@tonic-gate vfs_unmountall(void) 30907c478bd9Sstevel@tonic-gate { 30917c478bd9Sstevel@tonic-gate struct vfs *vfsp; 30927c478bd9Sstevel@tonic-gate struct vfs *prev_vfsp = NULL; 30937c478bd9Sstevel@tonic-gate int error; 30947c478bd9Sstevel@tonic-gate 30957c478bd9Sstevel@tonic-gate /* 30967c478bd9Sstevel@tonic-gate * Toss all dnlc entries now so that the per-vfs sync 30977c478bd9Sstevel@tonic-gate * and unmount operations don't have to slog through 30987c478bd9Sstevel@tonic-gate * a bunch of uninteresting vnodes over and over again. 30997c478bd9Sstevel@tonic-gate */ 31007c478bd9Sstevel@tonic-gate dnlc_purge(); 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate vfs_list_lock(); 31037c478bd9Sstevel@tonic-gate for (vfsp = rootvfs->vfs_prev; vfsp != rootvfs; vfsp = prev_vfsp) { 31047c478bd9Sstevel@tonic-gate prev_vfsp = vfsp->vfs_prev; 31057c478bd9Sstevel@tonic-gate 31067c478bd9Sstevel@tonic-gate if (vfs_lock(vfsp) != 0) 31077c478bd9Sstevel@tonic-gate continue; 31087c478bd9Sstevel@tonic-gate error = vn_vfswlock(vfsp->vfs_vnodecovered); 31097c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 31107c478bd9Sstevel@tonic-gate if (error) 31117c478bd9Sstevel@tonic-gate continue; 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate vfs_list_unlock(); 31147c478bd9Sstevel@tonic-gate 31157c478bd9Sstevel@tonic-gate (void) VFS_SYNC(vfsp, SYNC_CLOSE, CRED()); 31167c478bd9Sstevel@tonic-gate (void) dounmount(vfsp, 0, CRED()); 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate /* 31197c478bd9Sstevel@tonic-gate * Since we dropped the vfslist lock above we must 31207c478bd9Sstevel@tonic-gate * verify that next_vfsp still exists, else start over. 31217c478bd9Sstevel@tonic-gate */ 31227c478bd9Sstevel@tonic-gate vfs_list_lock(); 31237c478bd9Sstevel@tonic-gate for (vfsp = rootvfs->vfs_prev; 3124b1b8ab34Slling vfsp != rootvfs; vfsp = vfsp->vfs_prev) 31257c478bd9Sstevel@tonic-gate if (vfsp == prev_vfsp) 31267c478bd9Sstevel@tonic-gate break; 31277c478bd9Sstevel@tonic-gate if (vfsp == rootvfs && prev_vfsp != rootvfs) 31287c478bd9Sstevel@tonic-gate prev_vfsp = rootvfs->vfs_prev; 31297c478bd9Sstevel@tonic-gate } 31307c478bd9Sstevel@tonic-gate vfs_list_unlock(); 31317c478bd9Sstevel@tonic-gate } 31327c478bd9Sstevel@tonic-gate 31337c478bd9Sstevel@tonic-gate /* 31347c478bd9Sstevel@tonic-gate * Called to add an entry to the end of the vfs mount in progress list 31357c478bd9Sstevel@tonic-gate */ 31367c478bd9Sstevel@tonic-gate void 31377c478bd9Sstevel@tonic-gate vfs_addmip(dev_t dev, struct vfs *vfsp) 31387c478bd9Sstevel@tonic-gate { 31397c478bd9Sstevel@tonic-gate struct ipmnt *mipp; 31407c478bd9Sstevel@tonic-gate 31417c478bd9Sstevel@tonic-gate mipp = (struct ipmnt *)kmem_alloc(sizeof (struct ipmnt), KM_SLEEP); 31427c478bd9Sstevel@tonic-gate mipp->mip_next = NULL; 31437c478bd9Sstevel@tonic-gate mipp->mip_dev = dev; 31447c478bd9Sstevel@tonic-gate mipp->mip_vfsp = vfsp; 31457c478bd9Sstevel@tonic-gate mutex_enter(&vfs_miplist_mutex); 31467c478bd9Sstevel@tonic-gate if (vfs_miplist_end != NULL) 31477c478bd9Sstevel@tonic-gate vfs_miplist_end->mip_next = mipp; 31487c478bd9Sstevel@tonic-gate else 31497c478bd9Sstevel@tonic-gate vfs_miplist = mipp; 31507c478bd9Sstevel@tonic-gate vfs_miplist_end = mipp; 31517c478bd9Sstevel@tonic-gate mutex_exit(&vfs_miplist_mutex); 31527c478bd9Sstevel@tonic-gate } 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate /* 31557c478bd9Sstevel@tonic-gate * Called to remove an entry from the mount in progress list 31567c478bd9Sstevel@tonic-gate * Either because the mount completed or it failed. 31577c478bd9Sstevel@tonic-gate */ 31587c478bd9Sstevel@tonic-gate void 31597c478bd9Sstevel@tonic-gate vfs_delmip(struct vfs *vfsp) 31607c478bd9Sstevel@tonic-gate { 31617c478bd9Sstevel@tonic-gate struct ipmnt *mipp, *mipprev; 31627c478bd9Sstevel@tonic-gate 31637c478bd9Sstevel@tonic-gate mutex_enter(&vfs_miplist_mutex); 31647c478bd9Sstevel@tonic-gate mipprev = NULL; 31657c478bd9Sstevel@tonic-gate for (mipp = vfs_miplist; 3166b1b8ab34Slling mipp && mipp->mip_vfsp != vfsp; mipp = mipp->mip_next) { 31677c478bd9Sstevel@tonic-gate mipprev = mipp; 31687c478bd9Sstevel@tonic-gate } 31697c478bd9Sstevel@tonic-gate if (mipp == NULL) 31707c478bd9Sstevel@tonic-gate return; /* shouldn't happen */ 31717c478bd9Sstevel@tonic-gate if (mipp == vfs_miplist_end) 31727c478bd9Sstevel@tonic-gate vfs_miplist_end = mipprev; 31737c478bd9Sstevel@tonic-gate if (mipprev == NULL) 31747c478bd9Sstevel@tonic-gate vfs_miplist = mipp->mip_next; 31757c478bd9Sstevel@tonic-gate else 31767c478bd9Sstevel@tonic-gate mipprev->mip_next = mipp->mip_next; 31777c478bd9Sstevel@tonic-gate mutex_exit(&vfs_miplist_mutex); 31787c478bd9Sstevel@tonic-gate kmem_free(mipp, sizeof (struct ipmnt)); 31797c478bd9Sstevel@tonic-gate } 31807c478bd9Sstevel@tonic-gate 31817c478bd9Sstevel@tonic-gate /* 31827c478bd9Sstevel@tonic-gate * vfs_add is called by a specific filesystem's mount routine to add 31837c478bd9Sstevel@tonic-gate * the new vfs into the vfs list/hash and to cover the mounted-on vnode. 31847c478bd9Sstevel@tonic-gate * The vfs should already have been locked by the caller. 31857c478bd9Sstevel@tonic-gate * 31867c478bd9Sstevel@tonic-gate * coveredvp is NULL if this is the root. 31877c478bd9Sstevel@tonic-gate */ 31887c478bd9Sstevel@tonic-gate void 31897c478bd9Sstevel@tonic-gate vfs_add(vnode_t *coveredvp, struct vfs *vfsp, int mflag) 31907c478bd9Sstevel@tonic-gate { 31917c478bd9Sstevel@tonic-gate int newflag; 31927c478bd9Sstevel@tonic-gate 31937c478bd9Sstevel@tonic-gate ASSERT(vfs_lock_held(vfsp)); 31947c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); 31957c478bd9Sstevel@tonic-gate newflag = vfsp->vfs_flag; 31967c478bd9Sstevel@tonic-gate if (mflag & MS_RDONLY) 31977c478bd9Sstevel@tonic-gate newflag |= VFS_RDONLY; 31987c478bd9Sstevel@tonic-gate else 31997c478bd9Sstevel@tonic-gate newflag &= ~VFS_RDONLY; 32007c478bd9Sstevel@tonic-gate if (mflag & MS_NOSUID) 32017c478bd9Sstevel@tonic-gate newflag |= (VFS_NOSETUID|VFS_NODEVICES); 32027c478bd9Sstevel@tonic-gate else 32037c478bd9Sstevel@tonic-gate newflag &= ~(VFS_NOSETUID|VFS_NODEVICES); 32047c478bd9Sstevel@tonic-gate if (mflag & MS_NOMNTTAB) 32057c478bd9Sstevel@tonic-gate newflag |= VFS_NOMNTTAB; 32067c478bd9Sstevel@tonic-gate else 32077c478bd9Sstevel@tonic-gate newflag &= ~VFS_NOMNTTAB; 32087c478bd9Sstevel@tonic-gate 32097c478bd9Sstevel@tonic-gate if (coveredvp != NULL) { 32107c478bd9Sstevel@tonic-gate ASSERT(vn_vfswlock_held(coveredvp)); 32117c478bd9Sstevel@tonic-gate coveredvp->v_vfsmountedhere = vfsp; 32127c478bd9Sstevel@tonic-gate VN_HOLD(coveredvp); 32137c478bd9Sstevel@tonic-gate } 32147c478bd9Sstevel@tonic-gate vfsp->vfs_vnodecovered = coveredvp; 32157c478bd9Sstevel@tonic-gate vfsp->vfs_flag = newflag; 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate vfs_list_add(vfsp); 32187c478bd9Sstevel@tonic-gate } 32197c478bd9Sstevel@tonic-gate 32207c478bd9Sstevel@tonic-gate /* 32217c478bd9Sstevel@tonic-gate * Remove a vfs from the vfs list, null out the pointer from the 32227c478bd9Sstevel@tonic-gate * covered vnode to the vfs (v_vfsmountedhere), and null out the pointer 32237c478bd9Sstevel@tonic-gate * from the vfs to the covered vnode (vfs_vnodecovered). Release the 32247c478bd9Sstevel@tonic-gate * reference to the vfs and to the covered vnode. 32257c478bd9Sstevel@tonic-gate * 32267c478bd9Sstevel@tonic-gate * Called from dounmount after it's confirmed with the file system 32277c478bd9Sstevel@tonic-gate * that the unmount is legal. 32287c478bd9Sstevel@tonic-gate */ 32297c478bd9Sstevel@tonic-gate void 32307c478bd9Sstevel@tonic-gate vfs_remove(struct vfs *vfsp) 32317c478bd9Sstevel@tonic-gate { 32327c478bd9Sstevel@tonic-gate vnode_t *vp; 32337c478bd9Sstevel@tonic-gate 32347c478bd9Sstevel@tonic-gate ASSERT(vfs_lock_held(vfsp)); 32357c478bd9Sstevel@tonic-gate 32367c478bd9Sstevel@tonic-gate /* 32377c478bd9Sstevel@tonic-gate * Can't unmount root. Should never happen because fs will 32387c478bd9Sstevel@tonic-gate * be busy. 32397c478bd9Sstevel@tonic-gate */ 32407c478bd9Sstevel@tonic-gate if (vfsp == rootvfs) 3241ae115bc7Smrj panic("vfs_remove: unmounting root"); 32427c478bd9Sstevel@tonic-gate 32437c478bd9Sstevel@tonic-gate vfs_list_remove(vfsp); 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate /* 32467c478bd9Sstevel@tonic-gate * Unhook from the file system name space. 32477c478bd9Sstevel@tonic-gate */ 32487c478bd9Sstevel@tonic-gate vp = vfsp->vfs_vnodecovered; 32497c478bd9Sstevel@tonic-gate ASSERT(vn_vfswlock_held(vp)); 32507c478bd9Sstevel@tonic-gate vp->v_vfsmountedhere = NULL; 32517c478bd9Sstevel@tonic-gate vfsp->vfs_vnodecovered = NULL; 32527c478bd9Sstevel@tonic-gate VN_RELE(vp); 32537c478bd9Sstevel@tonic-gate 32547c478bd9Sstevel@tonic-gate /* 32557c478bd9Sstevel@tonic-gate * Release lock and wakeup anybody waiting. 32567c478bd9Sstevel@tonic-gate */ 32577c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 32587c478bd9Sstevel@tonic-gate VFS_RELE(vfsp); 32597c478bd9Sstevel@tonic-gate } 32607c478bd9Sstevel@tonic-gate 32617c478bd9Sstevel@tonic-gate /* 32627c478bd9Sstevel@tonic-gate * Lock a filesystem to prevent access to it while mounting, 32637c478bd9Sstevel@tonic-gate * unmounting and syncing. Return EBUSY immediately if lock 32647c478bd9Sstevel@tonic-gate * can't be acquired. 32657c478bd9Sstevel@tonic-gate */ 32667c478bd9Sstevel@tonic-gate int 32677c478bd9Sstevel@tonic-gate vfs_lock(vfs_t *vfsp) 32687c478bd9Sstevel@tonic-gate { 32697c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 32707c478bd9Sstevel@tonic-gate 32717c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 32727c478bd9Sstevel@tonic-gate if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER)) 32737c478bd9Sstevel@tonic-gate return (0); 32747c478bd9Sstevel@tonic-gate 32757c478bd9Sstevel@tonic-gate vn_vfslocks_rele(vpvfsentry); 32767c478bd9Sstevel@tonic-gate return (EBUSY); 32777c478bd9Sstevel@tonic-gate } 32787c478bd9Sstevel@tonic-gate 32797c478bd9Sstevel@tonic-gate int 32807c478bd9Sstevel@tonic-gate vfs_rlock(vfs_t *vfsp) 32817c478bd9Sstevel@tonic-gate { 32827c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 32837c478bd9Sstevel@tonic-gate 32847c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 32857c478bd9Sstevel@tonic-gate 32867c478bd9Sstevel@tonic-gate if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER)) 32877c478bd9Sstevel@tonic-gate return (0); 32887c478bd9Sstevel@tonic-gate 32897c478bd9Sstevel@tonic-gate vn_vfslocks_rele(vpvfsentry); 32907c478bd9Sstevel@tonic-gate return (EBUSY); 32917c478bd9Sstevel@tonic-gate } 32927c478bd9Sstevel@tonic-gate 32937c478bd9Sstevel@tonic-gate void 32947c478bd9Sstevel@tonic-gate vfs_lock_wait(vfs_t *vfsp) 32957c478bd9Sstevel@tonic-gate { 32967c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 32997c478bd9Sstevel@tonic-gate rwst_enter(&vpvfsentry->ve_lock, RW_WRITER); 33007c478bd9Sstevel@tonic-gate } 33017c478bd9Sstevel@tonic-gate 33027c478bd9Sstevel@tonic-gate void 33037c478bd9Sstevel@tonic-gate vfs_rlock_wait(vfs_t *vfsp) 33047c478bd9Sstevel@tonic-gate { 33057c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 33067c478bd9Sstevel@tonic-gate 33077c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 33087c478bd9Sstevel@tonic-gate rwst_enter(&vpvfsentry->ve_lock, RW_READER); 33097c478bd9Sstevel@tonic-gate } 33107c478bd9Sstevel@tonic-gate 33117c478bd9Sstevel@tonic-gate /* 33127c478bd9Sstevel@tonic-gate * Unlock a locked filesystem. 33137c478bd9Sstevel@tonic-gate */ 33147c478bd9Sstevel@tonic-gate void 33157c478bd9Sstevel@tonic-gate vfs_unlock(vfs_t *vfsp) 33167c478bd9Sstevel@tonic-gate { 33177c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 33187c478bd9Sstevel@tonic-gate 33197c478bd9Sstevel@tonic-gate /* 33207c478bd9Sstevel@tonic-gate * vfs_unlock will mimic sema_v behaviour to fix 4748018. 33217c478bd9Sstevel@tonic-gate * And these changes should remain for the patch changes as it is. 33227c478bd9Sstevel@tonic-gate */ 33237c478bd9Sstevel@tonic-gate if (panicstr) 33247c478bd9Sstevel@tonic-gate return; 33257c478bd9Sstevel@tonic-gate 33267c478bd9Sstevel@tonic-gate /* 33277c478bd9Sstevel@tonic-gate * ve_refcount needs to be dropped twice here. 33287c478bd9Sstevel@tonic-gate * 1. To release refernce after a call to vfs_locks_getlock() 33297c478bd9Sstevel@tonic-gate * 2. To release the reference from the locking routines like 33307c478bd9Sstevel@tonic-gate * vfs_rlock_wait/vfs_wlock_wait/vfs_wlock etc,. 33317c478bd9Sstevel@tonic-gate */ 33327c478bd9Sstevel@tonic-gate 33337c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 33347c478bd9Sstevel@tonic-gate vn_vfslocks_rele(vpvfsentry); 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate rwst_exit(&vpvfsentry->ve_lock); 33377c478bd9Sstevel@tonic-gate vn_vfslocks_rele(vpvfsentry); 33387c478bd9Sstevel@tonic-gate } 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate /* 33417c478bd9Sstevel@tonic-gate * Utility routine that allows a filesystem to construct its 33427c478bd9Sstevel@tonic-gate * fsid in "the usual way" - by munging some underlying dev_t and 33437c478bd9Sstevel@tonic-gate * the filesystem type number into the 64-bit fsid. Note that 33447c478bd9Sstevel@tonic-gate * this implicitly relies on dev_t persistence to make filesystem 33457c478bd9Sstevel@tonic-gate * id's persistent. 33467c478bd9Sstevel@tonic-gate * 33477c478bd9Sstevel@tonic-gate * There's nothing to prevent an individual fs from constructing its 33487c478bd9Sstevel@tonic-gate * fsid in a different way, and indeed they should. 33497c478bd9Sstevel@tonic-gate * 33507c478bd9Sstevel@tonic-gate * Since we want fsids to be 32-bit quantities (so that they can be 33517c478bd9Sstevel@tonic-gate * exported identically by either 32-bit or 64-bit APIs, as well as 33527c478bd9Sstevel@tonic-gate * the fact that fsid's are "known" to NFS), we compress the device 33537c478bd9Sstevel@tonic-gate * number given down to 32-bits, and panic if that isn't possible. 33547c478bd9Sstevel@tonic-gate */ 33557c478bd9Sstevel@tonic-gate void 33567c478bd9Sstevel@tonic-gate vfs_make_fsid(fsid_t *fsi, dev_t dev, int val) 33577c478bd9Sstevel@tonic-gate { 33587c478bd9Sstevel@tonic-gate if (!cmpldev((dev32_t *)&fsi->val[0], dev)) 33597c478bd9Sstevel@tonic-gate panic("device number too big for fsid!"); 33607c478bd9Sstevel@tonic-gate fsi->val[1] = val; 33617c478bd9Sstevel@tonic-gate } 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate int 33647c478bd9Sstevel@tonic-gate vfs_lock_held(vfs_t *vfsp) 33657c478bd9Sstevel@tonic-gate { 33667c478bd9Sstevel@tonic-gate int held; 33677c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 33687c478bd9Sstevel@tonic-gate 33697c478bd9Sstevel@tonic-gate /* 33707c478bd9Sstevel@tonic-gate * vfs_lock_held will mimic sema_held behaviour 33717c478bd9Sstevel@tonic-gate * if panicstr is set. And these changes should remain 33727c478bd9Sstevel@tonic-gate * for the patch changes as it is. 33737c478bd9Sstevel@tonic-gate */ 33747c478bd9Sstevel@tonic-gate if (panicstr) 33757c478bd9Sstevel@tonic-gate return (1); 33767c478bd9Sstevel@tonic-gate 33777c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 33787c478bd9Sstevel@tonic-gate held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER); 33797c478bd9Sstevel@tonic-gate 33807c478bd9Sstevel@tonic-gate vn_vfslocks_rele(vpvfsentry); 33817c478bd9Sstevel@tonic-gate return (held); 33827c478bd9Sstevel@tonic-gate } 33837c478bd9Sstevel@tonic-gate 33847c478bd9Sstevel@tonic-gate struct _kthread * 33857c478bd9Sstevel@tonic-gate vfs_lock_owner(vfs_t *vfsp) 33867c478bd9Sstevel@tonic-gate { 33877c478bd9Sstevel@tonic-gate struct _kthread *owner; 33887c478bd9Sstevel@tonic-gate vn_vfslocks_entry_t *vpvfsentry; 33897c478bd9Sstevel@tonic-gate 33907c478bd9Sstevel@tonic-gate /* 33917c478bd9Sstevel@tonic-gate * vfs_wlock_held will mimic sema_held behaviour 33927c478bd9Sstevel@tonic-gate * if panicstr is set. And these changes should remain 33937c478bd9Sstevel@tonic-gate * for the patch changes as it is. 33947c478bd9Sstevel@tonic-gate */ 33957c478bd9Sstevel@tonic-gate if (panicstr) 33967c478bd9Sstevel@tonic-gate return (NULL); 33977c478bd9Sstevel@tonic-gate 33987c478bd9Sstevel@tonic-gate vpvfsentry = vn_vfslocks_getlock(vfsp); 33997c478bd9Sstevel@tonic-gate owner = rwst_owner(&vpvfsentry->ve_lock); 34007c478bd9Sstevel@tonic-gate 34017c478bd9Sstevel@tonic-gate vn_vfslocks_rele(vpvfsentry); 34027c478bd9Sstevel@tonic-gate return (owner); 34037c478bd9Sstevel@tonic-gate } 34047c478bd9Sstevel@tonic-gate 34057c478bd9Sstevel@tonic-gate /* 34067c478bd9Sstevel@tonic-gate * vfs list locking. 34077c478bd9Sstevel@tonic-gate * 34087c478bd9Sstevel@tonic-gate * Rather than manipulate the vfslist lock directly, we abstract into lock 34097c478bd9Sstevel@tonic-gate * and unlock routines to allow the locking implementation to be changed for 34107c478bd9Sstevel@tonic-gate * clustering. 34117c478bd9Sstevel@tonic-gate * 34127c478bd9Sstevel@tonic-gate * Whenever the vfs list is modified through its hash links, the overall list 34137c478bd9Sstevel@tonic-gate * lock must be obtained before locking the relevant hash bucket. But to see 34147c478bd9Sstevel@tonic-gate * whether a given vfs is on the list, it suffices to obtain the lock for the 34157c478bd9Sstevel@tonic-gate * hash bucket without getting the overall list lock. (See getvfs() below.) 34167c478bd9Sstevel@tonic-gate */ 34177c478bd9Sstevel@tonic-gate 34187c478bd9Sstevel@tonic-gate void 34197c478bd9Sstevel@tonic-gate vfs_list_lock() 34207c478bd9Sstevel@tonic-gate { 34217c478bd9Sstevel@tonic-gate rw_enter(&vfslist, RW_WRITER); 34227c478bd9Sstevel@tonic-gate } 34237c478bd9Sstevel@tonic-gate 34247c478bd9Sstevel@tonic-gate void 34257c478bd9Sstevel@tonic-gate vfs_list_read_lock() 34267c478bd9Sstevel@tonic-gate { 34277c478bd9Sstevel@tonic-gate rw_enter(&vfslist, RW_READER); 34287c478bd9Sstevel@tonic-gate } 34297c478bd9Sstevel@tonic-gate 34307c478bd9Sstevel@tonic-gate void 34317c478bd9Sstevel@tonic-gate vfs_list_unlock() 34327c478bd9Sstevel@tonic-gate { 34337c478bd9Sstevel@tonic-gate rw_exit(&vfslist); 34347c478bd9Sstevel@tonic-gate } 34357c478bd9Sstevel@tonic-gate 34367c478bd9Sstevel@tonic-gate /* 34377c478bd9Sstevel@tonic-gate * Low level worker routines for adding entries to and removing entries from 34387c478bd9Sstevel@tonic-gate * the vfs list. 34397c478bd9Sstevel@tonic-gate */ 34407c478bd9Sstevel@tonic-gate 34417c478bd9Sstevel@tonic-gate static void 34427c478bd9Sstevel@tonic-gate vfs_hash_add(struct vfs *vfsp, int insert_at_head) 34437c478bd9Sstevel@tonic-gate { 34447c478bd9Sstevel@tonic-gate int vhno; 34457c478bd9Sstevel@tonic-gate struct vfs **hp; 34467c478bd9Sstevel@tonic-gate dev_t dev; 34477c478bd9Sstevel@tonic-gate 34487c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&vfslist)); 34497c478bd9Sstevel@tonic-gate 34507c478bd9Sstevel@tonic-gate dev = expldev(vfsp->vfs_fsid.val[0]); 34517c478bd9Sstevel@tonic-gate vhno = VFSHASH(getmajor(dev), getminor(dev)); 34527c478bd9Sstevel@tonic-gate 34537c478bd9Sstevel@tonic-gate mutex_enter(&rvfs_list[vhno].rvfs_lock); 34547c478bd9Sstevel@tonic-gate 34557c478bd9Sstevel@tonic-gate /* 34567c478bd9Sstevel@tonic-gate * Link into the hash table, inserting it at the end, so that LOFS 34577c478bd9Sstevel@tonic-gate * with the same fsid as UFS (or other) file systems will not hide the 34587c478bd9Sstevel@tonic-gate * UFS. 34597c478bd9Sstevel@tonic-gate */ 34607c478bd9Sstevel@tonic-gate if (insert_at_head) { 34617c478bd9Sstevel@tonic-gate vfsp->vfs_hash = rvfs_list[vhno].rvfs_head; 34627c478bd9Sstevel@tonic-gate rvfs_list[vhno].rvfs_head = vfsp; 34637c478bd9Sstevel@tonic-gate } else { 34647c478bd9Sstevel@tonic-gate for (hp = &rvfs_list[vhno].rvfs_head; *hp != NULL; 34657c478bd9Sstevel@tonic-gate hp = &(*hp)->vfs_hash) 34667c478bd9Sstevel@tonic-gate continue; 34677c478bd9Sstevel@tonic-gate /* 34687c478bd9Sstevel@tonic-gate * hp now contains the address of the pointer to update 34697c478bd9Sstevel@tonic-gate * to effect the insertion. 34707c478bd9Sstevel@tonic-gate */ 34717c478bd9Sstevel@tonic-gate vfsp->vfs_hash = NULL; 34727c478bd9Sstevel@tonic-gate *hp = vfsp; 34737c478bd9Sstevel@tonic-gate } 34747c478bd9Sstevel@tonic-gate 34757c478bd9Sstevel@tonic-gate rvfs_list[vhno].rvfs_len++; 34767c478bd9Sstevel@tonic-gate mutex_exit(&rvfs_list[vhno].rvfs_lock); 34777c478bd9Sstevel@tonic-gate } 34787c478bd9Sstevel@tonic-gate 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate static void 34817c478bd9Sstevel@tonic-gate vfs_hash_remove(struct vfs *vfsp) 34827c478bd9Sstevel@tonic-gate { 34837c478bd9Sstevel@tonic-gate int vhno; 34847c478bd9Sstevel@tonic-gate struct vfs *tvfsp; 34857c478bd9Sstevel@tonic-gate dev_t dev; 34867c478bd9Sstevel@tonic-gate 34877c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&vfslist)); 34887c478bd9Sstevel@tonic-gate 34897c478bd9Sstevel@tonic-gate dev = expldev(vfsp->vfs_fsid.val[0]); 34907c478bd9Sstevel@tonic-gate vhno = VFSHASH(getmajor(dev), getminor(dev)); 34917c478bd9Sstevel@tonic-gate 34927c478bd9Sstevel@tonic-gate mutex_enter(&rvfs_list[vhno].rvfs_lock); 34937c478bd9Sstevel@tonic-gate 34947c478bd9Sstevel@tonic-gate /* 34957c478bd9Sstevel@tonic-gate * Remove from hash. 34967c478bd9Sstevel@tonic-gate */ 34977c478bd9Sstevel@tonic-gate if (rvfs_list[vhno].rvfs_head == vfsp) { 34987c478bd9Sstevel@tonic-gate rvfs_list[vhno].rvfs_head = vfsp->vfs_hash; 34997c478bd9Sstevel@tonic-gate rvfs_list[vhno].rvfs_len--; 35007c478bd9Sstevel@tonic-gate goto foundit; 35017c478bd9Sstevel@tonic-gate } 35027c478bd9Sstevel@tonic-gate for (tvfsp = rvfs_list[vhno].rvfs_head; tvfsp != NULL; 35037c478bd9Sstevel@tonic-gate tvfsp = tvfsp->vfs_hash) { 35047c478bd9Sstevel@tonic-gate if (tvfsp->vfs_hash == vfsp) { 35057c478bd9Sstevel@tonic-gate tvfsp->vfs_hash = vfsp->vfs_hash; 35067c478bd9Sstevel@tonic-gate rvfs_list[vhno].rvfs_len--; 35077c478bd9Sstevel@tonic-gate goto foundit; 35087c478bd9Sstevel@tonic-gate } 35097c478bd9Sstevel@tonic-gate } 35107c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "vfs_list_remove: vfs not found in hash"); 35117c478bd9Sstevel@tonic-gate 35127c478bd9Sstevel@tonic-gate foundit: 35137c478bd9Sstevel@tonic-gate 35147c478bd9Sstevel@tonic-gate mutex_exit(&rvfs_list[vhno].rvfs_lock); 35157c478bd9Sstevel@tonic-gate } 35167c478bd9Sstevel@tonic-gate 35177c478bd9Sstevel@tonic-gate 35187c478bd9Sstevel@tonic-gate void 35197c478bd9Sstevel@tonic-gate vfs_list_add(struct vfs *vfsp) 35207c478bd9Sstevel@tonic-gate { 35217c478bd9Sstevel@tonic-gate zone_t *zone; 35227c478bd9Sstevel@tonic-gate 3523835ee219SRobert Harris /* 3524835ee219SRobert Harris * Typically, the vfs_t will have been created on behalf of the file 3525835ee219SRobert Harris * system in vfs_init, where it will have been provided with a 3526835ee219SRobert Harris * vfs_impl_t. This, however, might be lacking if the vfs_t was created 3527835ee219SRobert Harris * by an unbundled file system. We therefore check for such an example 3528835ee219SRobert Harris * before stamping the vfs_t with its creation time for the benefit of 3529835ee219SRobert Harris * mntfs. 3530835ee219SRobert Harris */ 3531835ee219SRobert Harris if (vfsp->vfs_implp == NULL) 3532835ee219SRobert Harris vfsimpl_setup(vfsp); 3533835ee219SRobert Harris vfs_mono_time(&vfsp->vfs_hrctime); 3534835ee219SRobert Harris 35357c478bd9Sstevel@tonic-gate /* 35367c478bd9Sstevel@tonic-gate * The zone that owns the mount is the one that performed the mount. 35377c478bd9Sstevel@tonic-gate * Note that this isn't necessarily the same as the zone mounted into. 35387c478bd9Sstevel@tonic-gate * The corresponding zone_rele() will be done when the vfs_t is 35397c478bd9Sstevel@tonic-gate * being free'd. 35407c478bd9Sstevel@tonic-gate */ 35417c478bd9Sstevel@tonic-gate vfsp->vfs_zone = curproc->p_zone; 35427c478bd9Sstevel@tonic-gate zone_hold(vfsp->vfs_zone); 35437c478bd9Sstevel@tonic-gate 35447c478bd9Sstevel@tonic-gate /* 35457c478bd9Sstevel@tonic-gate * Find the zone mounted into, and put this mount on its vfs list. 35467c478bd9Sstevel@tonic-gate */ 35477c478bd9Sstevel@tonic-gate zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 35487c478bd9Sstevel@tonic-gate ASSERT(zone != NULL); 35497c478bd9Sstevel@tonic-gate /* 35507c478bd9Sstevel@tonic-gate * Special casing for the root vfs. This structure is allocated 35517c478bd9Sstevel@tonic-gate * statically and hooked onto rootvfs at link time. During the 35527c478bd9Sstevel@tonic-gate * vfs_mountroot call at system startup time, the root file system's 35537c478bd9Sstevel@tonic-gate * VFS_MOUNTROOT routine will call vfs_add with this root vfs struct 35547c478bd9Sstevel@tonic-gate * as argument. The code below must detect and handle this special 35557c478bd9Sstevel@tonic-gate * case. The only apparent justification for this special casing is 35567c478bd9Sstevel@tonic-gate * to ensure that the root file system appears at the head of the 35577c478bd9Sstevel@tonic-gate * list. 35587c478bd9Sstevel@tonic-gate * 35597c478bd9Sstevel@tonic-gate * XXX: I'm assuming that it's ok to do normal list locking when 35607c478bd9Sstevel@tonic-gate * adding the entry for the root file system (this used to be 35617c478bd9Sstevel@tonic-gate * done with no locks held). 35627c478bd9Sstevel@tonic-gate */ 35637c478bd9Sstevel@tonic-gate vfs_list_lock(); 35647c478bd9Sstevel@tonic-gate /* 35657c478bd9Sstevel@tonic-gate * Link into the vfs list proper. 35667c478bd9Sstevel@tonic-gate */ 35677c478bd9Sstevel@tonic-gate if (vfsp == &root) { 35687c478bd9Sstevel@tonic-gate /* 35697c478bd9Sstevel@tonic-gate * Assert: This vfs is already on the list as its first entry. 35707c478bd9Sstevel@tonic-gate * Thus, there's nothing to do. 35717c478bd9Sstevel@tonic-gate */ 35727c478bd9Sstevel@tonic-gate ASSERT(rootvfs == vfsp); 35737c478bd9Sstevel@tonic-gate /* 35747c478bd9Sstevel@tonic-gate * Add it to the head of the global zone's vfslist. 35757c478bd9Sstevel@tonic-gate */ 35767c478bd9Sstevel@tonic-gate ASSERT(zone == global_zone); 35777c478bd9Sstevel@tonic-gate ASSERT(zone->zone_vfslist == NULL); 35787c478bd9Sstevel@tonic-gate zone->zone_vfslist = vfsp; 35797c478bd9Sstevel@tonic-gate } else { 35807c478bd9Sstevel@tonic-gate /* 35817c478bd9Sstevel@tonic-gate * Link to end of list using vfs_prev (as rootvfs is now a 35827c478bd9Sstevel@tonic-gate * doubly linked circular list) so list is in mount order for 35837c478bd9Sstevel@tonic-gate * mnttab use. 35847c478bd9Sstevel@tonic-gate */ 35857c478bd9Sstevel@tonic-gate rootvfs->vfs_prev->vfs_next = vfsp; 35867c478bd9Sstevel@tonic-gate vfsp->vfs_prev = rootvfs->vfs_prev; 35877c478bd9Sstevel@tonic-gate rootvfs->vfs_prev = vfsp; 35887c478bd9Sstevel@tonic-gate vfsp->vfs_next = rootvfs; 35897c478bd9Sstevel@tonic-gate 35907c478bd9Sstevel@tonic-gate /* 35917c478bd9Sstevel@tonic-gate * Do it again for the zone-private list (which may be NULL). 35927c478bd9Sstevel@tonic-gate */ 35937c478bd9Sstevel@tonic-gate if (zone->zone_vfslist == NULL) { 35947c478bd9Sstevel@tonic-gate ASSERT(zone != global_zone); 35957c478bd9Sstevel@tonic-gate zone->zone_vfslist = vfsp; 35967c478bd9Sstevel@tonic-gate } else { 35977c478bd9Sstevel@tonic-gate zone->zone_vfslist->vfs_zone_prev->vfs_zone_next = vfsp; 35987c478bd9Sstevel@tonic-gate vfsp->vfs_zone_prev = zone->zone_vfslist->vfs_zone_prev; 35997c478bd9Sstevel@tonic-gate zone->zone_vfslist->vfs_zone_prev = vfsp; 36007c478bd9Sstevel@tonic-gate vfsp->vfs_zone_next = zone->zone_vfslist; 36017c478bd9Sstevel@tonic-gate } 36027c478bd9Sstevel@tonic-gate } 36037c478bd9Sstevel@tonic-gate 36047c478bd9Sstevel@tonic-gate /* 36057c478bd9Sstevel@tonic-gate * Link into the hash table, inserting it at the end, so that LOFS 36067c478bd9Sstevel@tonic-gate * with the same fsid as UFS (or other) file systems will not hide 36077c478bd9Sstevel@tonic-gate * the UFS. 36087c478bd9Sstevel@tonic-gate */ 36097c478bd9Sstevel@tonic-gate vfs_hash_add(vfsp, 0); 36107c478bd9Sstevel@tonic-gate 36117c478bd9Sstevel@tonic-gate /* 36127c478bd9Sstevel@tonic-gate * update the mnttab modification time 36137c478bd9Sstevel@tonic-gate */ 36147c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd(); 36157c478bd9Sstevel@tonic-gate vfs_list_unlock(); 36167c478bd9Sstevel@tonic-gate zone_rele(zone); 36177c478bd9Sstevel@tonic-gate } 36187c478bd9Sstevel@tonic-gate 36197c478bd9Sstevel@tonic-gate void 36207c478bd9Sstevel@tonic-gate vfs_list_remove(struct vfs *vfsp) 36217c478bd9Sstevel@tonic-gate { 36227c478bd9Sstevel@tonic-gate zone_t *zone; 36237c478bd9Sstevel@tonic-gate 36247c478bd9Sstevel@tonic-gate zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 36257c478bd9Sstevel@tonic-gate ASSERT(zone != NULL); 36267c478bd9Sstevel@tonic-gate /* 36277c478bd9Sstevel@tonic-gate * Callers are responsible for preventing attempts to unmount the 36287c478bd9Sstevel@tonic-gate * root. 36297c478bd9Sstevel@tonic-gate */ 36307c478bd9Sstevel@tonic-gate ASSERT(vfsp != rootvfs); 36317c478bd9Sstevel@tonic-gate 36327c478bd9Sstevel@tonic-gate vfs_list_lock(); 36337c478bd9Sstevel@tonic-gate 36347c478bd9Sstevel@tonic-gate /* 36357c478bd9Sstevel@tonic-gate * Remove from hash. 36367c478bd9Sstevel@tonic-gate */ 36377c478bd9Sstevel@tonic-gate vfs_hash_remove(vfsp); 36387c478bd9Sstevel@tonic-gate 36397c478bd9Sstevel@tonic-gate /* 36407c478bd9Sstevel@tonic-gate * Remove from vfs list. 36417c478bd9Sstevel@tonic-gate */ 36427c478bd9Sstevel@tonic-gate vfsp->vfs_prev->vfs_next = vfsp->vfs_next; 36437c478bd9Sstevel@tonic-gate vfsp->vfs_next->vfs_prev = vfsp->vfs_prev; 36447c478bd9Sstevel@tonic-gate vfsp->vfs_next = vfsp->vfs_prev = NULL; 36457c478bd9Sstevel@tonic-gate 36467c478bd9Sstevel@tonic-gate /* 36477c478bd9Sstevel@tonic-gate * Remove from zone-specific vfs list. 36487c478bd9Sstevel@tonic-gate */ 36497c478bd9Sstevel@tonic-gate if (zone->zone_vfslist == vfsp) 36507c478bd9Sstevel@tonic-gate zone->zone_vfslist = vfsp->vfs_zone_next; 36517c478bd9Sstevel@tonic-gate 36527c478bd9Sstevel@tonic-gate if (vfsp->vfs_zone_next == vfsp) { 36537c478bd9Sstevel@tonic-gate ASSERT(vfsp->vfs_zone_prev == vfsp); 36547c478bd9Sstevel@tonic-gate ASSERT(zone->zone_vfslist == vfsp); 36557c478bd9Sstevel@tonic-gate zone->zone_vfslist = NULL; 36567c478bd9Sstevel@tonic-gate } 36577c478bd9Sstevel@tonic-gate 36587c478bd9Sstevel@tonic-gate vfsp->vfs_zone_prev->vfs_zone_next = vfsp->vfs_zone_next; 36597c478bd9Sstevel@tonic-gate vfsp->vfs_zone_next->vfs_zone_prev = vfsp->vfs_zone_prev; 36607c478bd9Sstevel@tonic-gate vfsp->vfs_zone_next = vfsp->vfs_zone_prev = NULL; 36617c478bd9Sstevel@tonic-gate 36627c478bd9Sstevel@tonic-gate /* 36637c478bd9Sstevel@tonic-gate * update the mnttab modification time 36647c478bd9Sstevel@tonic-gate */ 36657c478bd9Sstevel@tonic-gate vfs_mnttab_modtimeupd(); 36667c478bd9Sstevel@tonic-gate vfs_list_unlock(); 36677c478bd9Sstevel@tonic-gate zone_rele(zone); 36687c478bd9Sstevel@tonic-gate } 36697c478bd9Sstevel@tonic-gate 36707c478bd9Sstevel@tonic-gate struct vfs * 36717c478bd9Sstevel@tonic-gate getvfs(fsid_t *fsid) 36727c478bd9Sstevel@tonic-gate { 36737c478bd9Sstevel@tonic-gate struct vfs *vfsp; 36747c478bd9Sstevel@tonic-gate int val0 = fsid->val[0]; 36757c478bd9Sstevel@tonic-gate int val1 = fsid->val[1]; 36767c478bd9Sstevel@tonic-gate dev_t dev = expldev(val0); 36777c478bd9Sstevel@tonic-gate int vhno = VFSHASH(getmajor(dev), getminor(dev)); 36787c478bd9Sstevel@tonic-gate kmutex_t *hmp = &rvfs_list[vhno].rvfs_lock; 36797c478bd9Sstevel@tonic-gate 36807c478bd9Sstevel@tonic-gate mutex_enter(hmp); 36817c478bd9Sstevel@tonic-gate for (vfsp = rvfs_list[vhno].rvfs_head; vfsp; vfsp = vfsp->vfs_hash) { 36827c478bd9Sstevel@tonic-gate if (vfsp->vfs_fsid.val[0] == val0 && 36837c478bd9Sstevel@tonic-gate vfsp->vfs_fsid.val[1] == val1) { 36847c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); 36857c478bd9Sstevel@tonic-gate mutex_exit(hmp); 36867c478bd9Sstevel@tonic-gate return (vfsp); 36877c478bd9Sstevel@tonic-gate } 36887c478bd9Sstevel@tonic-gate } 36897c478bd9Sstevel@tonic-gate mutex_exit(hmp); 36907c478bd9Sstevel@tonic-gate return (NULL); 36917c478bd9Sstevel@tonic-gate } 36927c478bd9Sstevel@tonic-gate 36937c478bd9Sstevel@tonic-gate /* 36947c478bd9Sstevel@tonic-gate * Search the vfs mount in progress list for a specified device/vfs entry. 36957c478bd9Sstevel@tonic-gate * Returns 0 if the first entry in the list that the device matches has the 36967c478bd9Sstevel@tonic-gate * given vfs pointer as well. If the device matches but a different vfs 36977c478bd9Sstevel@tonic-gate * pointer is encountered in the list before the given vfs pointer then 36987c478bd9Sstevel@tonic-gate * a 1 is returned. 36997c478bd9Sstevel@tonic-gate */ 37007c478bd9Sstevel@tonic-gate 37017c478bd9Sstevel@tonic-gate int 37027c478bd9Sstevel@tonic-gate vfs_devmounting(dev_t dev, struct vfs *vfsp) 37037c478bd9Sstevel@tonic-gate { 37047c478bd9Sstevel@tonic-gate int retval = 0; 37057c478bd9Sstevel@tonic-gate struct ipmnt *mipp; 37067c478bd9Sstevel@tonic-gate 37077c478bd9Sstevel@tonic-gate mutex_enter(&vfs_miplist_mutex); 37087c478bd9Sstevel@tonic-gate for (mipp = vfs_miplist; mipp != NULL; mipp = mipp->mip_next) { 37097c478bd9Sstevel@tonic-gate if (mipp->mip_dev == dev) { 37107c478bd9Sstevel@tonic-gate if (mipp->mip_vfsp != vfsp) 37117c478bd9Sstevel@tonic-gate retval = 1; 37127c478bd9Sstevel@tonic-gate break; 37137c478bd9Sstevel@tonic-gate } 37147c478bd9Sstevel@tonic-gate } 37157c478bd9Sstevel@tonic-gate mutex_exit(&vfs_miplist_mutex); 37167c478bd9Sstevel@tonic-gate return (retval); 37177c478bd9Sstevel@tonic-gate } 37187c478bd9Sstevel@tonic-gate 37197c478bd9Sstevel@tonic-gate /* 37207c478bd9Sstevel@tonic-gate * Search the vfs list for a specified device. Returns 1, if entry is found 37217c478bd9Sstevel@tonic-gate * or 0 if no suitable entry is found. 37227c478bd9Sstevel@tonic-gate */ 37237c478bd9Sstevel@tonic-gate 37247c478bd9Sstevel@tonic-gate int 37257c478bd9Sstevel@tonic-gate vfs_devismounted(dev_t dev) 37267c478bd9Sstevel@tonic-gate { 37277c478bd9Sstevel@tonic-gate struct vfs *vfsp; 37287c478bd9Sstevel@tonic-gate int found; 37297c478bd9Sstevel@tonic-gate 37307c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 37317c478bd9Sstevel@tonic-gate vfsp = rootvfs; 37327c478bd9Sstevel@tonic-gate found = 0; 37337c478bd9Sstevel@tonic-gate do { 37347c478bd9Sstevel@tonic-gate if (vfsp->vfs_dev == dev) { 37357c478bd9Sstevel@tonic-gate found = 1; 37367c478bd9Sstevel@tonic-gate break; 37377c478bd9Sstevel@tonic-gate } 37387c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 37397c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 37407c478bd9Sstevel@tonic-gate 37417c478bd9Sstevel@tonic-gate vfs_list_unlock(); 37427c478bd9Sstevel@tonic-gate return (found); 37437c478bd9Sstevel@tonic-gate } 37447c478bd9Sstevel@tonic-gate 37457c478bd9Sstevel@tonic-gate /* 37467c478bd9Sstevel@tonic-gate * Search the vfs list for a specified device. Returns a pointer to it 37477c478bd9Sstevel@tonic-gate * or NULL if no suitable entry is found. The caller of this routine 37487c478bd9Sstevel@tonic-gate * is responsible for releasing the returned vfs pointer. 37497c478bd9Sstevel@tonic-gate */ 37507c478bd9Sstevel@tonic-gate struct vfs * 37517c478bd9Sstevel@tonic-gate vfs_dev2vfsp(dev_t dev) 37527c478bd9Sstevel@tonic-gate { 37537c478bd9Sstevel@tonic-gate struct vfs *vfsp; 37547c478bd9Sstevel@tonic-gate int found; 37557c478bd9Sstevel@tonic-gate 37567c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 37577c478bd9Sstevel@tonic-gate vfsp = rootvfs; 37587c478bd9Sstevel@tonic-gate found = 0; 37597c478bd9Sstevel@tonic-gate do { 37607c478bd9Sstevel@tonic-gate /* 37617c478bd9Sstevel@tonic-gate * The following could be made more efficient by making 37627c478bd9Sstevel@tonic-gate * the entire loop use vfs_zone_next if the call is from 37637c478bd9Sstevel@tonic-gate * a zone. The only callers, however, ustat(2) and 37647c478bd9Sstevel@tonic-gate * umount2(2), don't seem to justify the added 37657c478bd9Sstevel@tonic-gate * complexity at present. 37667c478bd9Sstevel@tonic-gate */ 37677c478bd9Sstevel@tonic-gate if (vfsp->vfs_dev == dev && 37687c478bd9Sstevel@tonic-gate ZONE_PATH_VISIBLE(refstr_value(vfsp->vfs_mntpt), 37697c478bd9Sstevel@tonic-gate curproc->p_zone)) { 37707c478bd9Sstevel@tonic-gate VFS_HOLD(vfsp); 37717c478bd9Sstevel@tonic-gate found = 1; 37727c478bd9Sstevel@tonic-gate break; 37737c478bd9Sstevel@tonic-gate } 37747c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 37757c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 37767c478bd9Sstevel@tonic-gate vfs_list_unlock(); 37777c478bd9Sstevel@tonic-gate return (found ? vfsp: NULL); 37787c478bd9Sstevel@tonic-gate } 37797c478bd9Sstevel@tonic-gate 37807c478bd9Sstevel@tonic-gate /* 37817c478bd9Sstevel@tonic-gate * Search the vfs list for a specified mntpoint. Returns a pointer to it 37827c478bd9Sstevel@tonic-gate * or NULL if no suitable entry is found. The caller of this routine 37837c478bd9Sstevel@tonic-gate * is responsible for releasing the returned vfs pointer. 37847c478bd9Sstevel@tonic-gate * 37857c478bd9Sstevel@tonic-gate * Note that if multiple mntpoints match, the last one matching is 37867c478bd9Sstevel@tonic-gate * returned in an attempt to return the "top" mount when overlay 37877c478bd9Sstevel@tonic-gate * mounts are covering the same mount point. This is accomplished by starting 37887c478bd9Sstevel@tonic-gate * at the end of the list and working our way backwards, stopping at the first 37897c478bd9Sstevel@tonic-gate * matching mount. 37907c478bd9Sstevel@tonic-gate */ 37917c478bd9Sstevel@tonic-gate struct vfs * 37927c478bd9Sstevel@tonic-gate vfs_mntpoint2vfsp(const char *mp) 37937c478bd9Sstevel@tonic-gate { 37947c478bd9Sstevel@tonic-gate struct vfs *vfsp; 37957c478bd9Sstevel@tonic-gate struct vfs *retvfsp = NULL; 37967c478bd9Sstevel@tonic-gate zone_t *zone = curproc->p_zone; 37977c478bd9Sstevel@tonic-gate struct vfs *list; 37987c478bd9Sstevel@tonic-gate 37997c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 38007c478bd9Sstevel@tonic-gate if (getzoneid() == GLOBAL_ZONEID) { 38017c478bd9Sstevel@tonic-gate /* 38027c478bd9Sstevel@tonic-gate * The global zone may see filesystems in any zone. 38037c478bd9Sstevel@tonic-gate */ 38047c478bd9Sstevel@tonic-gate vfsp = rootvfs->vfs_prev; 38057c478bd9Sstevel@tonic-gate do { 38067c478bd9Sstevel@tonic-gate if (strcmp(refstr_value(vfsp->vfs_mntpt), mp) == 0) { 38077c478bd9Sstevel@tonic-gate retvfsp = vfsp; 38087c478bd9Sstevel@tonic-gate break; 38097c478bd9Sstevel@tonic-gate } 38107c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_prev; 38117c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs->vfs_prev); 38127c478bd9Sstevel@tonic-gate } else if ((list = zone->zone_vfslist) != NULL) { 38137c478bd9Sstevel@tonic-gate const char *mntpt; 38147c478bd9Sstevel@tonic-gate 38157c478bd9Sstevel@tonic-gate vfsp = list->vfs_zone_prev; 38167c478bd9Sstevel@tonic-gate do { 38177c478bd9Sstevel@tonic-gate mntpt = refstr_value(vfsp->vfs_mntpt); 38187c478bd9Sstevel@tonic-gate mntpt = ZONE_PATH_TRANSLATE(mntpt, zone); 38197c478bd9Sstevel@tonic-gate if (strcmp(mntpt, mp) == 0) { 38207c478bd9Sstevel@tonic-gate retvfsp = vfsp; 38217c478bd9Sstevel@tonic-gate break; 38227c478bd9Sstevel@tonic-gate } 38237c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_zone_prev; 38247c478bd9Sstevel@tonic-gate } while (vfsp != list->vfs_zone_prev); 38257c478bd9Sstevel@tonic-gate } 38267c478bd9Sstevel@tonic-gate if (retvfsp) 38277c478bd9Sstevel@tonic-gate VFS_HOLD(retvfsp); 38287c478bd9Sstevel@tonic-gate vfs_list_unlock(); 38297c478bd9Sstevel@tonic-gate return (retvfsp); 38307c478bd9Sstevel@tonic-gate } 38317c478bd9Sstevel@tonic-gate 38327c478bd9Sstevel@tonic-gate /* 38337c478bd9Sstevel@tonic-gate * Search the vfs list for a specified vfsops. 38347c478bd9Sstevel@tonic-gate * if vfs entry is found then return 1, else 0. 38357c478bd9Sstevel@tonic-gate */ 38367c478bd9Sstevel@tonic-gate int 38377c478bd9Sstevel@tonic-gate vfs_opsinuse(vfsops_t *ops) 38387c478bd9Sstevel@tonic-gate { 38397c478bd9Sstevel@tonic-gate struct vfs *vfsp; 38407c478bd9Sstevel@tonic-gate int found; 38417c478bd9Sstevel@tonic-gate 38427c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 38437c478bd9Sstevel@tonic-gate vfsp = rootvfs; 38447c478bd9Sstevel@tonic-gate found = 0; 38457c478bd9Sstevel@tonic-gate do { 38467c478bd9Sstevel@tonic-gate if (vfs_getops(vfsp) == ops) { 38477c478bd9Sstevel@tonic-gate found = 1; 38487c478bd9Sstevel@tonic-gate break; 38497c478bd9Sstevel@tonic-gate } 38507c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 38517c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 38527c478bd9Sstevel@tonic-gate vfs_list_unlock(); 38537c478bd9Sstevel@tonic-gate return (found); 38547c478bd9Sstevel@tonic-gate } 38557c478bd9Sstevel@tonic-gate 38567c478bd9Sstevel@tonic-gate /* 38577c478bd9Sstevel@tonic-gate * Allocate an entry in vfssw for a file system type 38587c478bd9Sstevel@tonic-gate */ 38597c478bd9Sstevel@tonic-gate struct vfssw * 386043d5cd3dSjohnlev allocate_vfssw(const char *type) 38617c478bd9Sstevel@tonic-gate { 38627c478bd9Sstevel@tonic-gate struct vfssw *vswp; 38637c478bd9Sstevel@tonic-gate 38647c478bd9Sstevel@tonic-gate if (type[0] == '\0' || strlen(type) + 1 > _ST_FSTYPSZ) { 38657c478bd9Sstevel@tonic-gate /* 38667c478bd9Sstevel@tonic-gate * The vfssw table uses the empty string to identify an 38677c478bd9Sstevel@tonic-gate * available entry; we cannot add any type which has 38687c478bd9Sstevel@tonic-gate * a leading NUL. The string length is limited to 38697c478bd9Sstevel@tonic-gate * the size of the st_fstype array in struct stat. 38707c478bd9Sstevel@tonic-gate */ 38717c478bd9Sstevel@tonic-gate return (NULL); 38727c478bd9Sstevel@tonic-gate } 38737c478bd9Sstevel@tonic-gate 38747c478bd9Sstevel@tonic-gate ASSERT(VFSSW_WRITE_LOCKED()); 38757c478bd9Sstevel@tonic-gate for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) 38767c478bd9Sstevel@tonic-gate if (!ALLOCATED_VFSSW(vswp)) { 38777c478bd9Sstevel@tonic-gate vswp->vsw_name = kmem_alloc(strlen(type) + 1, KM_SLEEP); 38787c478bd9Sstevel@tonic-gate (void) strcpy(vswp->vsw_name, type); 38797c478bd9Sstevel@tonic-gate ASSERT(vswp->vsw_count == 0); 38807c478bd9Sstevel@tonic-gate vswp->vsw_count = 1; 38817c478bd9Sstevel@tonic-gate mutex_init(&vswp->vsw_lock, NULL, MUTEX_DEFAULT, NULL); 38827c478bd9Sstevel@tonic-gate return (vswp); 38837c478bd9Sstevel@tonic-gate } 38847c478bd9Sstevel@tonic-gate return (NULL); 38857c478bd9Sstevel@tonic-gate } 38867c478bd9Sstevel@tonic-gate 38877c478bd9Sstevel@tonic-gate /* 38887c478bd9Sstevel@tonic-gate * Impose additional layer of translation between vfstype names 38897c478bd9Sstevel@tonic-gate * and module names in the filesystem. 38907c478bd9Sstevel@tonic-gate */ 389143d5cd3dSjohnlev static const char * 389243d5cd3dSjohnlev vfs_to_modname(const char *vfstype) 38937c478bd9Sstevel@tonic-gate { 38947c478bd9Sstevel@tonic-gate if (strcmp(vfstype, "proc") == 0) { 38957c478bd9Sstevel@tonic-gate vfstype = "procfs"; 38967c478bd9Sstevel@tonic-gate } else if (strcmp(vfstype, "fd") == 0) { 38977c478bd9Sstevel@tonic-gate vfstype = "fdfs"; 38987c478bd9Sstevel@tonic-gate } else if (strncmp(vfstype, "nfs", 3) == 0) { 38997c478bd9Sstevel@tonic-gate vfstype = "nfs"; 39007c478bd9Sstevel@tonic-gate } 39017c478bd9Sstevel@tonic-gate 39027c478bd9Sstevel@tonic-gate return (vfstype); 39037c478bd9Sstevel@tonic-gate } 39047c478bd9Sstevel@tonic-gate 39057c478bd9Sstevel@tonic-gate /* 39067c478bd9Sstevel@tonic-gate * Find a vfssw entry given a file system type name. 39077c478bd9Sstevel@tonic-gate * Try to autoload the filesystem if it's not found. 39087c478bd9Sstevel@tonic-gate * If it's installed, return the vfssw locked to prevent unloading. 39097c478bd9Sstevel@tonic-gate */ 39107c478bd9Sstevel@tonic-gate struct vfssw * 391143d5cd3dSjohnlev vfs_getvfssw(const char *type) 39127c478bd9Sstevel@tonic-gate { 39137c478bd9Sstevel@tonic-gate struct vfssw *vswp; 391443d5cd3dSjohnlev const char *modname; 39157c478bd9Sstevel@tonic-gate 39167c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 39177c478bd9Sstevel@tonic-gate vswp = vfs_getvfsswbyname(type); 39187c478bd9Sstevel@tonic-gate modname = vfs_to_modname(type); 39197c478bd9Sstevel@tonic-gate 39207c478bd9Sstevel@tonic-gate if (rootdir == NULL) { 39217c478bd9Sstevel@tonic-gate /* 39227c478bd9Sstevel@tonic-gate * If we haven't yet loaded the root file system, then our 39237c478bd9Sstevel@tonic-gate * _init won't be called until later. Allocate vfssw entry, 39247c478bd9Sstevel@tonic-gate * because mod_installfs won't be called. 39257c478bd9Sstevel@tonic-gate */ 39267c478bd9Sstevel@tonic-gate if (vswp == NULL) { 39277c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 39287c478bd9Sstevel@tonic-gate WLOCK_VFSSW(); 39297c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfsswbyname(type)) == NULL) { 39307c478bd9Sstevel@tonic-gate if ((vswp = allocate_vfssw(type)) == NULL) { 39317c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 39327c478bd9Sstevel@tonic-gate return (NULL); 39337c478bd9Sstevel@tonic-gate } 39347c478bd9Sstevel@tonic-gate } 39357c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 39367c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 39377c478bd9Sstevel@tonic-gate } 39387c478bd9Sstevel@tonic-gate if (!VFS_INSTALLED(vswp)) { 39397c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 39407c478bd9Sstevel@tonic-gate (void) modloadonly("fs", modname); 39417c478bd9Sstevel@tonic-gate } else 39427c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 39437c478bd9Sstevel@tonic-gate return (vswp); 39447c478bd9Sstevel@tonic-gate } 39457c478bd9Sstevel@tonic-gate 39467c478bd9Sstevel@tonic-gate /* 39477c478bd9Sstevel@tonic-gate * Try to load the filesystem. Before calling modload(), we drop 39487c478bd9Sstevel@tonic-gate * our lock on the VFS switch table, and pick it up after the 39497c478bd9Sstevel@tonic-gate * module is loaded. However, there is a potential race: the 39507c478bd9Sstevel@tonic-gate * module could be unloaded after the call to modload() completes 39517c478bd9Sstevel@tonic-gate * but before we pick up the lock and drive on. Therefore, 39527c478bd9Sstevel@tonic-gate * we keep reloading the module until we've loaded the module 39537c478bd9Sstevel@tonic-gate * _and_ we have the lock on the VFS switch table. 39547c478bd9Sstevel@tonic-gate */ 39557c478bd9Sstevel@tonic-gate while (vswp == NULL || !VFS_INSTALLED(vswp)) { 39567c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 39577c478bd9Sstevel@tonic-gate if (modload("fs", modname) == -1) 39587c478bd9Sstevel@tonic-gate return (NULL); 39597c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 39607c478bd9Sstevel@tonic-gate if (vswp == NULL) 39617c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfsswbyname(type)) == NULL) 39627c478bd9Sstevel@tonic-gate break; 39637c478bd9Sstevel@tonic-gate } 39647c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 39657c478bd9Sstevel@tonic-gate 39667c478bd9Sstevel@tonic-gate return (vswp); 39677c478bd9Sstevel@tonic-gate } 39687c478bd9Sstevel@tonic-gate 39697c478bd9Sstevel@tonic-gate /* 39707c478bd9Sstevel@tonic-gate * Find a vfssw entry given a file system type name. 39717c478bd9Sstevel@tonic-gate */ 39727c478bd9Sstevel@tonic-gate struct vfssw * 397343d5cd3dSjohnlev vfs_getvfsswbyname(const char *type) 39747c478bd9Sstevel@tonic-gate { 39757c478bd9Sstevel@tonic-gate struct vfssw *vswp; 39767c478bd9Sstevel@tonic-gate 39777c478bd9Sstevel@tonic-gate ASSERT(VFSSW_LOCKED()); 39787c478bd9Sstevel@tonic-gate if (type == NULL || *type == '\0') 39797c478bd9Sstevel@tonic-gate return (NULL); 39807c478bd9Sstevel@tonic-gate 39817c478bd9Sstevel@tonic-gate for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 39827c478bd9Sstevel@tonic-gate if (strcmp(type, vswp->vsw_name) == 0) { 39837c478bd9Sstevel@tonic-gate vfs_refvfssw(vswp); 39847c478bd9Sstevel@tonic-gate return (vswp); 39857c478bd9Sstevel@tonic-gate } 39867c478bd9Sstevel@tonic-gate } 39877c478bd9Sstevel@tonic-gate 39887c478bd9Sstevel@tonic-gate return (NULL); 39897c478bd9Sstevel@tonic-gate } 39907c478bd9Sstevel@tonic-gate 39917c478bd9Sstevel@tonic-gate /* 39927c478bd9Sstevel@tonic-gate * Find a vfssw entry given a set of vfsops. 39937c478bd9Sstevel@tonic-gate */ 39947c478bd9Sstevel@tonic-gate struct vfssw * 39957c478bd9Sstevel@tonic-gate vfs_getvfsswbyvfsops(vfsops_t *vfsops) 39967c478bd9Sstevel@tonic-gate { 39977c478bd9Sstevel@tonic-gate struct vfssw *vswp; 39987c478bd9Sstevel@tonic-gate 39997c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 40007c478bd9Sstevel@tonic-gate for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 40017c478bd9Sstevel@tonic-gate if (ALLOCATED_VFSSW(vswp) && &vswp->vsw_vfsops == vfsops) { 40027c478bd9Sstevel@tonic-gate vfs_refvfssw(vswp); 40037c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 40047c478bd9Sstevel@tonic-gate return (vswp); 40057c478bd9Sstevel@tonic-gate } 40067c478bd9Sstevel@tonic-gate } 40077c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 40087c478bd9Sstevel@tonic-gate 40097c478bd9Sstevel@tonic-gate return (NULL); 40107c478bd9Sstevel@tonic-gate } 40117c478bd9Sstevel@tonic-gate 40127c478bd9Sstevel@tonic-gate /* 40137c478bd9Sstevel@tonic-gate * Reference a vfssw entry. 40147c478bd9Sstevel@tonic-gate */ 40157c478bd9Sstevel@tonic-gate void 40167c478bd9Sstevel@tonic-gate vfs_refvfssw(struct vfssw *vswp) 40177c478bd9Sstevel@tonic-gate { 40187c478bd9Sstevel@tonic-gate 40197c478bd9Sstevel@tonic-gate mutex_enter(&vswp->vsw_lock); 40207c478bd9Sstevel@tonic-gate vswp->vsw_count++; 40217c478bd9Sstevel@tonic-gate mutex_exit(&vswp->vsw_lock); 40227c478bd9Sstevel@tonic-gate } 40237c478bd9Sstevel@tonic-gate 40247c478bd9Sstevel@tonic-gate /* 40257c478bd9Sstevel@tonic-gate * Unreference a vfssw entry. 40267c478bd9Sstevel@tonic-gate */ 40277c478bd9Sstevel@tonic-gate void 40287c478bd9Sstevel@tonic-gate vfs_unrefvfssw(struct vfssw *vswp) 40297c478bd9Sstevel@tonic-gate { 40307c478bd9Sstevel@tonic-gate 40317c478bd9Sstevel@tonic-gate mutex_enter(&vswp->vsw_lock); 40327c478bd9Sstevel@tonic-gate vswp->vsw_count--; 40337c478bd9Sstevel@tonic-gate mutex_exit(&vswp->vsw_lock); 40347c478bd9Sstevel@tonic-gate } 40357c478bd9Sstevel@tonic-gate 40367c478bd9Sstevel@tonic-gate int sync_timeout = 30; /* timeout for syncing a page during panic */ 40377c478bd9Sstevel@tonic-gate int sync_timeleft; /* portion of sync_timeout remaining */ 40387c478bd9Sstevel@tonic-gate 40397c478bd9Sstevel@tonic-gate static int sync_retries = 20; /* number of retries when not making progress */ 40407c478bd9Sstevel@tonic-gate static int sync_triesleft; /* portion of sync_retries remaining */ 40417c478bd9Sstevel@tonic-gate 40427c478bd9Sstevel@tonic-gate static pgcnt_t old_pgcnt, new_pgcnt; 40437c478bd9Sstevel@tonic-gate static int new_bufcnt, old_bufcnt; 40447c478bd9Sstevel@tonic-gate 40457c478bd9Sstevel@tonic-gate /* 40467c478bd9Sstevel@tonic-gate * Sync all of the mounted filesystems, and then wait for the actual i/o to 40477c478bd9Sstevel@tonic-gate * complete. We wait by counting the number of dirty pages and buffers, 40487c478bd9Sstevel@tonic-gate * pushing them out using bio_busy() and page_busy(), and then counting again. 40497c478bd9Sstevel@tonic-gate * This routine is used during both the uadmin A_SHUTDOWN code as well as 40507c478bd9Sstevel@tonic-gate * the SYNC phase of the panic code (see comments in panic.c). It should only 40517c478bd9Sstevel@tonic-gate * be used after some higher-level mechanism has quiesced the system so that 40527c478bd9Sstevel@tonic-gate * new writes are not being initiated while we are waiting for completion. 40537c478bd9Sstevel@tonic-gate * 40547c478bd9Sstevel@tonic-gate * To ensure finite running time, our algorithm uses two timeout mechanisms: 40557c478bd9Sstevel@tonic-gate * sync_timeleft (a timer implemented by the omnipresent deadman() cyclic), and 40567c478bd9Sstevel@tonic-gate * sync_triesleft (a progress counter used by the vfs_syncall() loop below). 40577c478bd9Sstevel@tonic-gate * Together these ensure that syncing completes if our i/o paths are stuck. 40587c478bd9Sstevel@tonic-gate * The counters are declared above so they can be found easily in the debugger. 40597c478bd9Sstevel@tonic-gate * 40607c478bd9Sstevel@tonic-gate * The sync_timeleft counter is reset by bio_busy() and page_busy() using the 40617c478bd9Sstevel@tonic-gate * vfs_syncprogress() subroutine whenever we make progress through the lists of 40627c478bd9Sstevel@tonic-gate * pages and buffers. It is decremented and expired by the deadman() cyclic. 40637c478bd9Sstevel@tonic-gate * When vfs_syncall() decides it is done, we disable the deadman() counter by 40647c478bd9Sstevel@tonic-gate * setting sync_timeleft to zero. This timer guards against vfs_syncall() 40657c478bd9Sstevel@tonic-gate * deadlocking or hanging inside of a broken filesystem or driver routine. 40667c478bd9Sstevel@tonic-gate * 40677c478bd9Sstevel@tonic-gate * The sync_triesleft counter is updated by vfs_syncall() itself. If we make 40687c478bd9Sstevel@tonic-gate * sync_retries consecutive calls to bio_busy() and page_busy() without 40697c478bd9Sstevel@tonic-gate * decreasing either the number of dirty buffers or dirty pages below the 40707c478bd9Sstevel@tonic-gate * lowest count we have seen so far, we give up and return from vfs_syncall(). 40717c478bd9Sstevel@tonic-gate * 40727c478bd9Sstevel@tonic-gate * Each loop iteration ends with a call to delay() one second to allow time for 40737c478bd9Sstevel@tonic-gate * i/o completion and to permit the user time to read our progress messages. 40747c478bd9Sstevel@tonic-gate */ 40757c478bd9Sstevel@tonic-gate void 40767c478bd9Sstevel@tonic-gate vfs_syncall(void) 40777c478bd9Sstevel@tonic-gate { 40787c478bd9Sstevel@tonic-gate if (rootdir == NULL && !modrootloaded) 40797c478bd9Sstevel@tonic-gate return; /* panic during boot - no filesystems yet */ 40807c478bd9Sstevel@tonic-gate 40817c478bd9Sstevel@tonic-gate printf("syncing file systems..."); 40827c478bd9Sstevel@tonic-gate vfs_syncprogress(); 40837c478bd9Sstevel@tonic-gate sync(); 40847c478bd9Sstevel@tonic-gate 40857c478bd9Sstevel@tonic-gate vfs_syncprogress(); 40867c478bd9Sstevel@tonic-gate sync_triesleft = sync_retries; 40877c478bd9Sstevel@tonic-gate 40887c478bd9Sstevel@tonic-gate old_bufcnt = new_bufcnt = INT_MAX; 40897c478bd9Sstevel@tonic-gate old_pgcnt = new_pgcnt = ULONG_MAX; 40907c478bd9Sstevel@tonic-gate 40917c478bd9Sstevel@tonic-gate while (sync_triesleft > 0) { 40927c478bd9Sstevel@tonic-gate old_bufcnt = MIN(old_bufcnt, new_bufcnt); 40937c478bd9Sstevel@tonic-gate old_pgcnt = MIN(old_pgcnt, new_pgcnt); 40947c478bd9Sstevel@tonic-gate 40957c478bd9Sstevel@tonic-gate new_bufcnt = bio_busy(B_TRUE); 40967c478bd9Sstevel@tonic-gate new_pgcnt = page_busy(B_TRUE); 40977c478bd9Sstevel@tonic-gate vfs_syncprogress(); 40987c478bd9Sstevel@tonic-gate 40997c478bd9Sstevel@tonic-gate if (new_bufcnt == 0 && new_pgcnt == 0) 41007c478bd9Sstevel@tonic-gate break; 41017c478bd9Sstevel@tonic-gate 41027c478bd9Sstevel@tonic-gate if (new_bufcnt < old_bufcnt || new_pgcnt < old_pgcnt) 41037c478bd9Sstevel@tonic-gate sync_triesleft = sync_retries; 41047c478bd9Sstevel@tonic-gate else 41057c478bd9Sstevel@tonic-gate sync_triesleft--; 41067c478bd9Sstevel@tonic-gate 41077c478bd9Sstevel@tonic-gate if (new_bufcnt) 41087c478bd9Sstevel@tonic-gate printf(" [%d]", new_bufcnt); 41097c478bd9Sstevel@tonic-gate if (new_pgcnt) 41107c478bd9Sstevel@tonic-gate printf(" %lu", new_pgcnt); 41117c478bd9Sstevel@tonic-gate 41127c478bd9Sstevel@tonic-gate delay(hz); 41137c478bd9Sstevel@tonic-gate } 41147c478bd9Sstevel@tonic-gate 41157c478bd9Sstevel@tonic-gate if (new_bufcnt != 0 || new_pgcnt != 0) 41167c478bd9Sstevel@tonic-gate printf(" done (not all i/o completed)\n"); 41177c478bd9Sstevel@tonic-gate else 41187c478bd9Sstevel@tonic-gate printf(" done\n"); 41197c478bd9Sstevel@tonic-gate 41207c478bd9Sstevel@tonic-gate sync_timeleft = 0; 41217c478bd9Sstevel@tonic-gate delay(hz); 41227c478bd9Sstevel@tonic-gate } 41237c478bd9Sstevel@tonic-gate 41247c478bd9Sstevel@tonic-gate /* 41257c478bd9Sstevel@tonic-gate * If we are in the middle of the sync phase of panic, reset sync_timeleft to 41267c478bd9Sstevel@tonic-gate * sync_timeout to indicate that we are making progress and the deadman() 41277c478bd9Sstevel@tonic-gate * omnipresent cyclic should not yet time us out. Note that it is safe to 41287c478bd9Sstevel@tonic-gate * store to sync_timeleft here since the deadman() is firing at high-level 41297c478bd9Sstevel@tonic-gate * on top of us. If we are racing with the deadman(), either the deadman() 41307c478bd9Sstevel@tonic-gate * will decrement the old value and then we will reset it, or we will 41317c478bd9Sstevel@tonic-gate * reset it and then the deadman() will immediately decrement it. In either 41327c478bd9Sstevel@tonic-gate * case, correct behavior results. 41337c478bd9Sstevel@tonic-gate */ 41347c478bd9Sstevel@tonic-gate void 41357c478bd9Sstevel@tonic-gate vfs_syncprogress(void) 41367c478bd9Sstevel@tonic-gate { 41377c478bd9Sstevel@tonic-gate if (panicstr) 41387c478bd9Sstevel@tonic-gate sync_timeleft = sync_timeout; 41397c478bd9Sstevel@tonic-gate } 41407c478bd9Sstevel@tonic-gate 41417c478bd9Sstevel@tonic-gate /* 41427c478bd9Sstevel@tonic-gate * Map VFS flags to statvfs flags. These shouldn't really be separate 41437c478bd9Sstevel@tonic-gate * flags at all. 41447c478bd9Sstevel@tonic-gate */ 41457c478bd9Sstevel@tonic-gate uint_t 41467c478bd9Sstevel@tonic-gate vf_to_stf(uint_t vf) 41477c478bd9Sstevel@tonic-gate { 41487c478bd9Sstevel@tonic-gate uint_t stf = 0; 41497c478bd9Sstevel@tonic-gate 41507c478bd9Sstevel@tonic-gate if (vf & VFS_RDONLY) 41517c478bd9Sstevel@tonic-gate stf |= ST_RDONLY; 41527c478bd9Sstevel@tonic-gate if (vf & VFS_NOSETUID) 41537c478bd9Sstevel@tonic-gate stf |= ST_NOSUID; 41547c478bd9Sstevel@tonic-gate if (vf & VFS_NOTRUNC) 41557c478bd9Sstevel@tonic-gate stf |= ST_NOTRUNC; 41567c478bd9Sstevel@tonic-gate 41577c478bd9Sstevel@tonic-gate return (stf); 41587c478bd9Sstevel@tonic-gate } 41597c478bd9Sstevel@tonic-gate 41607c478bd9Sstevel@tonic-gate /* 41617c478bd9Sstevel@tonic-gate * Entries for (illegal) fstype 0. 41627c478bd9Sstevel@tonic-gate */ 41637c478bd9Sstevel@tonic-gate /* ARGSUSED */ 41647c478bd9Sstevel@tonic-gate int 41657c478bd9Sstevel@tonic-gate vfsstray_sync(struct vfs *vfsp, short arg, struct cred *cr) 41667c478bd9Sstevel@tonic-gate { 41677c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "stray vfs operation"); 41687c478bd9Sstevel@tonic-gate return (0); 41697c478bd9Sstevel@tonic-gate } 41707c478bd9Sstevel@tonic-gate 41717c478bd9Sstevel@tonic-gate /* 41727c478bd9Sstevel@tonic-gate * Entries for (illegal) fstype 0. 41737c478bd9Sstevel@tonic-gate */ 41747c478bd9Sstevel@tonic-gate int 41757c478bd9Sstevel@tonic-gate vfsstray(void) 41767c478bd9Sstevel@tonic-gate { 41777c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "stray vfs operation"); 41787c478bd9Sstevel@tonic-gate return (0); 41797c478bd9Sstevel@tonic-gate } 41807c478bd9Sstevel@tonic-gate 41817c478bd9Sstevel@tonic-gate /* 41827c478bd9Sstevel@tonic-gate * Support for dealing with forced UFS unmount and its interaction with 41837c478bd9Sstevel@tonic-gate * LOFS. Could be used by any filesystem. 41847c478bd9Sstevel@tonic-gate * See bug 1203132. 41857c478bd9Sstevel@tonic-gate */ 41867c478bd9Sstevel@tonic-gate int 41877c478bd9Sstevel@tonic-gate vfs_EIO(void) 41887c478bd9Sstevel@tonic-gate { 41897c478bd9Sstevel@tonic-gate return (EIO); 41907c478bd9Sstevel@tonic-gate } 41917c478bd9Sstevel@tonic-gate 41927c478bd9Sstevel@tonic-gate /* 41937c478bd9Sstevel@tonic-gate * We've gotta define the op for sync separately, since the compiler gets 41947c478bd9Sstevel@tonic-gate * confused if we mix and match ANSI and normal style prototypes when 41957c478bd9Sstevel@tonic-gate * a "short" argument is present and spits out a warning. 41967c478bd9Sstevel@tonic-gate */ 41977c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 41987c478bd9Sstevel@tonic-gate int 41997c478bd9Sstevel@tonic-gate vfs_EIO_sync(struct vfs *vfsp, short arg, struct cred *cr) 42007c478bd9Sstevel@tonic-gate { 42017c478bd9Sstevel@tonic-gate return (EIO); 42027c478bd9Sstevel@tonic-gate } 42037c478bd9Sstevel@tonic-gate 42047c478bd9Sstevel@tonic-gate vfs_t EIO_vfs; 42057c478bd9Sstevel@tonic-gate vfsops_t *EIO_vfsops; 42067c478bd9Sstevel@tonic-gate 42077c478bd9Sstevel@tonic-gate /* 42087c478bd9Sstevel@tonic-gate * Called from startup() to initialize all loaded vfs's 42097c478bd9Sstevel@tonic-gate */ 42107c478bd9Sstevel@tonic-gate void 42117c478bd9Sstevel@tonic-gate vfsinit(void) 42127c478bd9Sstevel@tonic-gate { 42137c478bd9Sstevel@tonic-gate struct vfssw *vswp; 42147c478bd9Sstevel@tonic-gate int error; 421582c7f3c4Srsb extern int vopstats_enabled; 42165a59a8b3Srsb extern void vopstats_startup(); 42177c478bd9Sstevel@tonic-gate 42187c478bd9Sstevel@tonic-gate static const fs_operation_def_t EIO_vfsops_template[] = { 4219aa59c4cbSrsb VFSNAME_MOUNT, { .error = vfs_EIO }, 4220aa59c4cbSrsb VFSNAME_UNMOUNT, { .error = vfs_EIO }, 4221aa59c4cbSrsb VFSNAME_ROOT, { .error = vfs_EIO }, 4222aa59c4cbSrsb VFSNAME_STATVFS, { .error = vfs_EIO }, 4223aa59c4cbSrsb VFSNAME_SYNC, { .vfs_sync = vfs_EIO_sync }, 4224aa59c4cbSrsb VFSNAME_VGET, { .error = vfs_EIO }, 4225aa59c4cbSrsb VFSNAME_MOUNTROOT, { .error = vfs_EIO }, 4226aa59c4cbSrsb VFSNAME_FREEVFS, { .error = vfs_EIO }, 4227aa59c4cbSrsb VFSNAME_VNSTATE, { .error = vfs_EIO }, 42287c478bd9Sstevel@tonic-gate NULL, NULL 42297c478bd9Sstevel@tonic-gate }; 42307c478bd9Sstevel@tonic-gate 4231aa59c4cbSrsb static const fs_operation_def_t stray_vfsops_template[] = { 4232aa59c4cbSrsb VFSNAME_MOUNT, { .error = vfsstray }, 4233aa59c4cbSrsb VFSNAME_UNMOUNT, { .error = vfsstray }, 4234aa59c4cbSrsb VFSNAME_ROOT, { .error = vfsstray }, 4235aa59c4cbSrsb VFSNAME_STATVFS, { .error = vfsstray }, 4236aa59c4cbSrsb VFSNAME_SYNC, { .vfs_sync = vfsstray_sync }, 4237aa59c4cbSrsb VFSNAME_VGET, { .error = vfsstray }, 4238aa59c4cbSrsb VFSNAME_MOUNTROOT, { .error = vfsstray }, 4239aa59c4cbSrsb VFSNAME_FREEVFS, { .error = vfsstray }, 4240aa59c4cbSrsb VFSNAME_VNSTATE, { .error = vfsstray }, 4241aa59c4cbSrsb NULL, NULL 4242aa59c4cbSrsb }; 42437c478bd9Sstevel@tonic-gate 4244da6c28aaSamw /* Create vfs cache */ 4245da6c28aaSamw vfs_cache = kmem_cache_create("vfs_cache", sizeof (struct vfs), 4246da6c28aaSamw sizeof (uintptr_t), NULL, NULL, NULL, NULL, NULL, 0); 42477c478bd9Sstevel@tonic-gate 4248da6c28aaSamw /* Initialize the vnode cache (file systems may use it during init). */ 42497c478bd9Sstevel@tonic-gate vn_create_cache(); 42507c478bd9Sstevel@tonic-gate 42517c478bd9Sstevel@tonic-gate /* Setup event monitor framework */ 42527c478bd9Sstevel@tonic-gate fem_init(); 42537c478bd9Sstevel@tonic-gate 42547c478bd9Sstevel@tonic-gate /* Initialize the dummy stray file system type. */ 4255d320ee2dSrsb error = vfs_setfsops(0, stray_vfsops_template, NULL); 42567c478bd9Sstevel@tonic-gate 42577c478bd9Sstevel@tonic-gate /* Initialize the dummy EIO file system. */ 42587c478bd9Sstevel@tonic-gate error = vfs_makefsops(EIO_vfsops_template, &EIO_vfsops); 42597c478bd9Sstevel@tonic-gate if (error != 0) { 42607c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "vfsinit: bad EIO vfs ops template"); 42617c478bd9Sstevel@tonic-gate /* Shouldn't happen, but not bad enough to panic */ 42627c478bd9Sstevel@tonic-gate } 42637c478bd9Sstevel@tonic-gate 42647c478bd9Sstevel@tonic-gate VFS_INIT(&EIO_vfs, EIO_vfsops, (caddr_t)NULL); 42657c478bd9Sstevel@tonic-gate 42667c478bd9Sstevel@tonic-gate /* 42677c478bd9Sstevel@tonic-gate * Default EIO_vfs.vfs_flag to VFS_UNMOUNTED so a lookup 42687c478bd9Sstevel@tonic-gate * on this vfs can immediately notice it's invalid. 42697c478bd9Sstevel@tonic-gate */ 42707c478bd9Sstevel@tonic-gate EIO_vfs.vfs_flag |= VFS_UNMOUNTED; 42717c478bd9Sstevel@tonic-gate 42727c478bd9Sstevel@tonic-gate /* 42737c478bd9Sstevel@tonic-gate * Call the init routines of non-loadable filesystems only. 42747c478bd9Sstevel@tonic-gate * Filesystems which are loaded as separate modules will be 42757c478bd9Sstevel@tonic-gate * initialized by the module loading code instead. 42767c478bd9Sstevel@tonic-gate */ 42777c478bd9Sstevel@tonic-gate 42787c478bd9Sstevel@tonic-gate for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 42797c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 42807c478bd9Sstevel@tonic-gate if (vswp->vsw_init != NULL) 42817c478bd9Sstevel@tonic-gate (*vswp->vsw_init)(vswp - vfssw, vswp->vsw_name); 42827c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 42837c478bd9Sstevel@tonic-gate } 42845a59a8b3Srsb 42855a59a8b3Srsb vopstats_startup(); 428682c7f3c4Srsb 428782c7f3c4Srsb if (vopstats_enabled) { 428882c7f3c4Srsb /* EIO_vfs can collect stats, but we don't retrieve them */ 428982c7f3c4Srsb initialize_vopstats(&EIO_vfs.vfs_vopstats); 429082c7f3c4Srsb EIO_vfs.vfs_fstypevsp = NULL; 429182c7f3c4Srsb EIO_vfs.vfs_vskap = NULL; 429282c7f3c4Srsb EIO_vfs.vfs_flag |= VFS_STATS; 429382c7f3c4Srsb } 4294da6c28aaSamw 4295da6c28aaSamw xattr_init(); 42967a286c47SDai Ngo 42977a286c47SDai Ngo reparse_point_init(); 4298da6c28aaSamw } 4299da6c28aaSamw 4300da6c28aaSamw vfs_t * 4301da6c28aaSamw vfs_alloc(int kmflag) 4302da6c28aaSamw { 4303da6c28aaSamw vfs_t *vfsp; 4304da6c28aaSamw 4305da6c28aaSamw vfsp = kmem_cache_alloc(vfs_cache, kmflag); 4306da6c28aaSamw 4307da6c28aaSamw /* 4308da6c28aaSamw * Do the simplest initialization here. 4309da6c28aaSamw * Everything else gets done in vfs_init() 4310da6c28aaSamw */ 4311da6c28aaSamw bzero(vfsp, sizeof (vfs_t)); 4312da6c28aaSamw return (vfsp); 4313da6c28aaSamw } 4314da6c28aaSamw 4315da6c28aaSamw void 4316da6c28aaSamw vfs_free(vfs_t *vfsp) 4317da6c28aaSamw { 4318da6c28aaSamw /* 4319da6c28aaSamw * One would be tempted to assert that "vfsp->vfs_count == 0". 4320da6c28aaSamw * The problem is that this gets called out of domount() with 4321da6c28aaSamw * a partially initialized vfs and a vfs_count of 1. This is 4322da6c28aaSamw * also called from vfs_rele() with a vfs_count of 0. We can't 4323da6c28aaSamw * call VFS_RELE() from domount() if VFS_MOUNT() hasn't successfully 4324da6c28aaSamw * returned. This is because VFS_MOUNT() fully initializes the 4325da6c28aaSamw * vfs structure and its associated data. VFS_RELE() will call 4326da6c28aaSamw * VFS_FREEVFS() which may panic the system if the data structures 4327da6c28aaSamw * aren't fully initialized from a successful VFS_MOUNT()). 4328da6c28aaSamw */ 4329da6c28aaSamw 4330da6c28aaSamw /* If FEM was in use, make sure everything gets cleaned up */ 4331da6c28aaSamw if (vfsp->vfs_femhead) { 4332da6c28aaSamw ASSERT(vfsp->vfs_femhead->femh_list == NULL); 4333da6c28aaSamw mutex_destroy(&vfsp->vfs_femhead->femh_lock); 4334da6c28aaSamw kmem_free(vfsp->vfs_femhead, sizeof (*(vfsp->vfs_femhead))); 4335da6c28aaSamw vfsp->vfs_femhead = NULL; 4336da6c28aaSamw } 4337da6c28aaSamw 4338da6c28aaSamw if (vfsp->vfs_implp) 4339da6c28aaSamw vfsimpl_teardown(vfsp); 4340da6c28aaSamw sema_destroy(&vfsp->vfs_reflock); 4341da6c28aaSamw kmem_cache_free(vfs_cache, vfsp); 43427c478bd9Sstevel@tonic-gate } 43437c478bd9Sstevel@tonic-gate 43447c478bd9Sstevel@tonic-gate /* 43457c478bd9Sstevel@tonic-gate * Increments the vfs reference count by one atomically. 43467c478bd9Sstevel@tonic-gate */ 43477c478bd9Sstevel@tonic-gate void 43487c478bd9Sstevel@tonic-gate vfs_hold(vfs_t *vfsp) 43497c478bd9Sstevel@tonic-gate { 43507c478bd9Sstevel@tonic-gate atomic_add_32(&vfsp->vfs_count, 1); 43517c478bd9Sstevel@tonic-gate ASSERT(vfsp->vfs_count != 0); 43527c478bd9Sstevel@tonic-gate } 43537c478bd9Sstevel@tonic-gate 43547c478bd9Sstevel@tonic-gate /* 43557c478bd9Sstevel@tonic-gate * Decrements the vfs reference count by one atomically. When 43567c478bd9Sstevel@tonic-gate * vfs reference count becomes zero, it calls the file system 43577c478bd9Sstevel@tonic-gate * specific vfs_freevfs() to free up the resources. 43587c478bd9Sstevel@tonic-gate */ 43597c478bd9Sstevel@tonic-gate void 43607c478bd9Sstevel@tonic-gate vfs_rele(vfs_t *vfsp) 43617c478bd9Sstevel@tonic-gate { 43627c478bd9Sstevel@tonic-gate ASSERT(vfsp->vfs_count != 0); 43637c478bd9Sstevel@tonic-gate if (atomic_add_32_nv(&vfsp->vfs_count, -1) == 0) { 43647c478bd9Sstevel@tonic-gate VFS_FREEVFS(vfsp); 436593239addSjohnlev lofi_remove(vfsp); 43667c478bd9Sstevel@tonic-gate if (vfsp->vfs_zone) 43677c478bd9Sstevel@tonic-gate zone_rele(vfsp->vfs_zone); 43687c478bd9Sstevel@tonic-gate vfs_freemnttab(vfsp); 4369da6c28aaSamw vfs_free(vfsp); 43707c478bd9Sstevel@tonic-gate } 43717c478bd9Sstevel@tonic-gate } 43727c478bd9Sstevel@tonic-gate 43737c478bd9Sstevel@tonic-gate /* 43747c478bd9Sstevel@tonic-gate * Generic operations vector support. 43757c478bd9Sstevel@tonic-gate * 43767c478bd9Sstevel@tonic-gate * This is used to build operations vectors for both the vfs and vnode. 43777c478bd9Sstevel@tonic-gate * It's normally called only when a file system is loaded. 43787c478bd9Sstevel@tonic-gate * 43797c478bd9Sstevel@tonic-gate * There are many possible algorithms for this, including the following: 43807c478bd9Sstevel@tonic-gate * 43817c478bd9Sstevel@tonic-gate * (1) scan the list of known operations; for each, see if the file system 43827c478bd9Sstevel@tonic-gate * includes an entry for it, and fill it in as appropriate. 43837c478bd9Sstevel@tonic-gate * 43847c478bd9Sstevel@tonic-gate * (2) set up defaults for all known operations. scan the list of ops 43857c478bd9Sstevel@tonic-gate * supplied by the file system; for each which is both supplied and 43867c478bd9Sstevel@tonic-gate * known, fill it in. 43877c478bd9Sstevel@tonic-gate * 43887c478bd9Sstevel@tonic-gate * (3) sort the lists of known ops & supplied ops; scan the list, filling 43897c478bd9Sstevel@tonic-gate * in entries as we go. 43907c478bd9Sstevel@tonic-gate * 43917c478bd9Sstevel@tonic-gate * we choose (1) for simplicity, and because performance isn't critical here. 43927c478bd9Sstevel@tonic-gate * note that (2) could be sped up using a precomputed hash table on known ops. 43937c478bd9Sstevel@tonic-gate * (3) could be faster than either, but only if the lists were very large or 43947c478bd9Sstevel@tonic-gate * supplied in sorted order. 43957c478bd9Sstevel@tonic-gate * 43967c478bd9Sstevel@tonic-gate */ 43977c478bd9Sstevel@tonic-gate 43987c478bd9Sstevel@tonic-gate int 43997c478bd9Sstevel@tonic-gate fs_build_vector(void *vector, int *unused_ops, 44007c478bd9Sstevel@tonic-gate const fs_operation_trans_def_t *translation, 44017c478bd9Sstevel@tonic-gate const fs_operation_def_t *operations) 44027c478bd9Sstevel@tonic-gate { 44037c478bd9Sstevel@tonic-gate int i, num_trans, num_ops, used; 44047c478bd9Sstevel@tonic-gate 4405aa59c4cbSrsb /* 4406aa59c4cbSrsb * Count the number of translations and the number of supplied 4407aa59c4cbSrsb * operations. 4408aa59c4cbSrsb */ 44097c478bd9Sstevel@tonic-gate 44107c478bd9Sstevel@tonic-gate { 44117c478bd9Sstevel@tonic-gate const fs_operation_trans_def_t *p; 44127c478bd9Sstevel@tonic-gate 44137c478bd9Sstevel@tonic-gate for (num_trans = 0, p = translation; 44147c478bd9Sstevel@tonic-gate p->name != NULL; 44157c478bd9Sstevel@tonic-gate num_trans++, p++) 44167c478bd9Sstevel@tonic-gate ; 44177c478bd9Sstevel@tonic-gate } 44187c478bd9Sstevel@tonic-gate 44197c478bd9Sstevel@tonic-gate { 44207c478bd9Sstevel@tonic-gate const fs_operation_def_t *p; 44217c478bd9Sstevel@tonic-gate 44227c478bd9Sstevel@tonic-gate for (num_ops = 0, p = operations; 44237c478bd9Sstevel@tonic-gate p->name != NULL; 44247c478bd9Sstevel@tonic-gate num_ops++, p++) 44257c478bd9Sstevel@tonic-gate ; 44267c478bd9Sstevel@tonic-gate } 44277c478bd9Sstevel@tonic-gate 44287c478bd9Sstevel@tonic-gate /* Walk through each operation known to our caller. There will be */ 44297c478bd9Sstevel@tonic-gate /* one entry in the supplied "translation table" for each. */ 44307c478bd9Sstevel@tonic-gate 44317c478bd9Sstevel@tonic-gate used = 0; 44327c478bd9Sstevel@tonic-gate 44337c478bd9Sstevel@tonic-gate for (i = 0; i < num_trans; i++) { 44347c478bd9Sstevel@tonic-gate int j, found; 44357c478bd9Sstevel@tonic-gate char *curname; 44367c478bd9Sstevel@tonic-gate fs_generic_func_p result; 44377c478bd9Sstevel@tonic-gate fs_generic_func_p *location; 44387c478bd9Sstevel@tonic-gate 44397c478bd9Sstevel@tonic-gate curname = translation[i].name; 44407c478bd9Sstevel@tonic-gate 44417c478bd9Sstevel@tonic-gate /* Look for a matching operation in the list supplied by the */ 44427c478bd9Sstevel@tonic-gate /* file system. */ 44437c478bd9Sstevel@tonic-gate 44447c478bd9Sstevel@tonic-gate found = 0; 44457c478bd9Sstevel@tonic-gate 44467c478bd9Sstevel@tonic-gate for (j = 0; j < num_ops; j++) { 44477c478bd9Sstevel@tonic-gate if (strcmp(operations[j].name, curname) == 0) { 44487c478bd9Sstevel@tonic-gate used++; 44497c478bd9Sstevel@tonic-gate found = 1; 44507c478bd9Sstevel@tonic-gate break; 44517c478bd9Sstevel@tonic-gate } 44527c478bd9Sstevel@tonic-gate } 44537c478bd9Sstevel@tonic-gate 4454aa59c4cbSrsb /* 4455aa59c4cbSrsb * If the file system is using a "placeholder" for default 4456aa59c4cbSrsb * or error functions, grab the appropriate function out of 4457aa59c4cbSrsb * the translation table. If the file system didn't supply 4458aa59c4cbSrsb * this operation at all, use the default function. 4459aa59c4cbSrsb */ 44607c478bd9Sstevel@tonic-gate 44617c478bd9Sstevel@tonic-gate if (found) { 4462aa59c4cbSrsb result = operations[j].func.fs_generic; 44637c478bd9Sstevel@tonic-gate if (result == fs_default) { 44647c478bd9Sstevel@tonic-gate result = translation[i].defaultFunc; 44657c478bd9Sstevel@tonic-gate } else if (result == fs_error) { 44667c478bd9Sstevel@tonic-gate result = translation[i].errorFunc; 44677c478bd9Sstevel@tonic-gate } else if (result == NULL) { 44687c478bd9Sstevel@tonic-gate /* Null values are PROHIBITED */ 44697c478bd9Sstevel@tonic-gate return (EINVAL); 44707c478bd9Sstevel@tonic-gate } 44717c478bd9Sstevel@tonic-gate } else { 44727c478bd9Sstevel@tonic-gate result = translation[i].defaultFunc; 44737c478bd9Sstevel@tonic-gate } 44747c478bd9Sstevel@tonic-gate 44757c478bd9Sstevel@tonic-gate /* Now store the function into the operations vector. */ 44767c478bd9Sstevel@tonic-gate 44777c478bd9Sstevel@tonic-gate location = (fs_generic_func_p *) 44787c478bd9Sstevel@tonic-gate (((char *)vector) + translation[i].offset); 44797c478bd9Sstevel@tonic-gate 44807c478bd9Sstevel@tonic-gate *location = result; 44817c478bd9Sstevel@tonic-gate } 44827c478bd9Sstevel@tonic-gate 44837c478bd9Sstevel@tonic-gate *unused_ops = num_ops - used; 44847c478bd9Sstevel@tonic-gate 44857c478bd9Sstevel@tonic-gate return (0); 44867c478bd9Sstevel@tonic-gate } 44877c478bd9Sstevel@tonic-gate 44887c478bd9Sstevel@tonic-gate /* Placeholder functions, should never be called. */ 44897c478bd9Sstevel@tonic-gate 44907c478bd9Sstevel@tonic-gate int 44917c478bd9Sstevel@tonic-gate fs_error(void) 44927c478bd9Sstevel@tonic-gate { 44937c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "fs_error called"); 44947c478bd9Sstevel@tonic-gate return (0); 44957c478bd9Sstevel@tonic-gate } 44967c478bd9Sstevel@tonic-gate 44977c478bd9Sstevel@tonic-gate int 44987c478bd9Sstevel@tonic-gate fs_default(void) 44997c478bd9Sstevel@tonic-gate { 45007c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "fs_default called"); 45017c478bd9Sstevel@tonic-gate return (0); 45027c478bd9Sstevel@tonic-gate } 45037c478bd9Sstevel@tonic-gate 45047c478bd9Sstevel@tonic-gate #ifdef __sparc 45057c478bd9Sstevel@tonic-gate 45067c478bd9Sstevel@tonic-gate /* 45077c478bd9Sstevel@tonic-gate * Part of the implementation of booting off a mirrored root 45087c478bd9Sstevel@tonic-gate * involves a change of dev_t for the root device. To 45097c478bd9Sstevel@tonic-gate * accomplish this, first remove the existing hash table 45107c478bd9Sstevel@tonic-gate * entry for the root device, convert to the new dev_t, 45117c478bd9Sstevel@tonic-gate * then re-insert in the hash table at the head of the list. 45127c478bd9Sstevel@tonic-gate */ 45137c478bd9Sstevel@tonic-gate void 45147c478bd9Sstevel@tonic-gate vfs_root_redev(vfs_t *vfsp, dev_t ndev, int fstype) 45157c478bd9Sstevel@tonic-gate { 45167c478bd9Sstevel@tonic-gate vfs_list_lock(); 45177c478bd9Sstevel@tonic-gate 45187c478bd9Sstevel@tonic-gate vfs_hash_remove(vfsp); 45197c478bd9Sstevel@tonic-gate 45207c478bd9Sstevel@tonic-gate vfsp->vfs_dev = ndev; 45217c478bd9Sstevel@tonic-gate vfs_make_fsid(&vfsp->vfs_fsid, ndev, fstype); 45227c478bd9Sstevel@tonic-gate 45237c478bd9Sstevel@tonic-gate vfs_hash_add(vfsp, 1); 45247c478bd9Sstevel@tonic-gate 45257c478bd9Sstevel@tonic-gate vfs_list_unlock(); 45267c478bd9Sstevel@tonic-gate } 45277c478bd9Sstevel@tonic-gate 45287c478bd9Sstevel@tonic-gate #else /* x86 NEWBOOT */ 45297c478bd9Sstevel@tonic-gate 453006bbe1e0Sedp #if defined(__x86) 453106bbe1e0Sedp extern int hvmboot_rootconf(); 453206bbe1e0Sedp #endif /* __x86 */ 453306bbe1e0Sedp 45346cefaae1SJack Meng extern ib_boot_prop_t *iscsiboot_prop; 45356cefaae1SJack Meng 45367c478bd9Sstevel@tonic-gate int 45377c478bd9Sstevel@tonic-gate rootconf() 45387c478bd9Sstevel@tonic-gate { 45397c478bd9Sstevel@tonic-gate int error; 45407c478bd9Sstevel@tonic-gate struct vfssw *vsw; 45417c478bd9Sstevel@tonic-gate extern void pm_init(); 4542843e1988Sjohnlev char *fstyp, *fsmod; 45436cefaae1SJack Meng int ret = -1; 45447c478bd9Sstevel@tonic-gate 4545843e1988Sjohnlev getrootfs(&fstyp, &fsmod); 45467c478bd9Sstevel@tonic-gate 454706bbe1e0Sedp #if defined(__x86) 454806bbe1e0Sedp /* 454906bbe1e0Sedp * hvmboot_rootconf() is defined in the hvm_bootstrap misc module, 455006bbe1e0Sedp * which lives in /platform/i86hvm, and hence is only available when 455106bbe1e0Sedp * booted in an x86 hvm environment. If the hvm_bootstrap misc module 455206bbe1e0Sedp * is not available then the modstub for this function will return 0. 455306bbe1e0Sedp * If the hvm_bootstrap misc module is available it will be loaded 455406bbe1e0Sedp * and hvmboot_rootconf() will be invoked. 455506bbe1e0Sedp */ 455606bbe1e0Sedp if (error = hvmboot_rootconf()) 455706bbe1e0Sedp return (error); 455806bbe1e0Sedp #endif /* __x86 */ 455906bbe1e0Sedp 45607c478bd9Sstevel@tonic-gate if (error = clboot_rootconf()) 45617c478bd9Sstevel@tonic-gate return (error); 45627c478bd9Sstevel@tonic-gate 4563843e1988Sjohnlev if (modload("fs", fsmod) == -1) 4564843e1988Sjohnlev panic("Cannot _init %s module", fsmod); 45657c478bd9Sstevel@tonic-gate 45667c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 45677c478bd9Sstevel@tonic-gate vsw = vfs_getvfsswbyname(fstyp); 45687c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 456956c0b1daSPavel Filipensky if (vsw == NULL) { 457056c0b1daSPavel Filipensky cmn_err(CE_CONT, "Cannot find %s filesystem\n", fstyp); 457156c0b1daSPavel Filipensky return (ENXIO); 457256c0b1daSPavel Filipensky } 45737c478bd9Sstevel@tonic-gate VFS_INIT(rootvfs, &vsw->vsw_vfsops, 0); 45747c478bd9Sstevel@tonic-gate VFS_HOLD(rootvfs); 45757c478bd9Sstevel@tonic-gate 45767c478bd9Sstevel@tonic-gate /* always mount readonly first */ 45777c478bd9Sstevel@tonic-gate rootvfs->vfs_flag |= VFS_RDONLY; 45787c478bd9Sstevel@tonic-gate 45797c478bd9Sstevel@tonic-gate pm_init(); 45807c478bd9Sstevel@tonic-gate 45816cefaae1SJack Meng if (netboot && iscsiboot_prop) { 45826cefaae1SJack Meng cmn_err(CE_WARN, "NFS boot and iSCSI boot" 45836cefaae1SJack Meng " shouldn't happen in the same time"); 45846cefaae1SJack Meng return (EINVAL); 45856cefaae1SJack Meng } 45866cefaae1SJack Meng 4587dedec472SJack Meng if (netboot || iscsiboot_prop) { 45886cefaae1SJack Meng ret = strplumb(); 4589dedec472SJack Meng if (ret != 0) { 4590dedec472SJack Meng cmn_err(CE_WARN, "Cannot plumb network device %d", ret); 4591dedec472SJack Meng return (EFAULT); 4592dedec472SJack Meng } 4593dedec472SJack Meng } 45946cefaae1SJack Meng 45956cefaae1SJack Meng if ((ret == 0) && iscsiboot_prop) { 45966cefaae1SJack Meng ret = modload("drv", "iscsi"); 45976cefaae1SJack Meng /* -1 indicates fail */ 45986cefaae1SJack Meng if (ret == -1) { 45996cefaae1SJack Meng cmn_err(CE_WARN, "Failed to load iscsi module"); 46006cefaae1SJack Meng iscsi_boot_prop_free(); 46016cefaae1SJack Meng return (EINVAL); 46026cefaae1SJack Meng } else { 46036cefaae1SJack Meng if (!i_ddi_attach_pseudo_node("iscsi")) { 46046cefaae1SJack Meng cmn_err(CE_WARN, 46056cefaae1SJack Meng "Failed to attach iscsi driver"); 46066cefaae1SJack Meng iscsi_boot_prop_free(); 46076cefaae1SJack Meng return (ENODEV); 46086cefaae1SJack Meng } 46096cefaae1SJack Meng } 46106cefaae1SJack Meng } 46117c478bd9Sstevel@tonic-gate 46127c478bd9Sstevel@tonic-gate error = VFS_MOUNTROOT(rootvfs, ROOT_INIT); 46137c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vsw); 46147c478bd9Sstevel@tonic-gate rootdev = rootvfs->vfs_dev; 46157c478bd9Sstevel@tonic-gate 46167c478bd9Sstevel@tonic-gate if (error) 461756c0b1daSPavel Filipensky cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n", 461856c0b1daSPavel Filipensky rootfs.bo_name, fstyp); 461956c0b1daSPavel Filipensky else 462056c0b1daSPavel Filipensky cmn_err(CE_CONT, "?root on %s fstype %s\n", 462156c0b1daSPavel Filipensky rootfs.bo_name, fstyp); 46227c478bd9Sstevel@tonic-gate return (error); 46237c478bd9Sstevel@tonic-gate } 46247c478bd9Sstevel@tonic-gate 46257c478bd9Sstevel@tonic-gate /* 46267c478bd9Sstevel@tonic-gate * XXX this is called by nfs only and should probably be removed 46277c478bd9Sstevel@tonic-gate * If booted with ASKNAME, prompt on the console for a filesystem 46287c478bd9Sstevel@tonic-gate * name and return it. 46297c478bd9Sstevel@tonic-gate */ 46307c478bd9Sstevel@tonic-gate void 46317c478bd9Sstevel@tonic-gate getfsname(char *askfor, char *name, size_t namelen) 46327c478bd9Sstevel@tonic-gate { 46337c478bd9Sstevel@tonic-gate if (boothowto & RB_ASKNAME) { 46347c478bd9Sstevel@tonic-gate printf("%s name: ", askfor); 46357c478bd9Sstevel@tonic-gate console_gets(name, namelen); 46367c478bd9Sstevel@tonic-gate } 46377c478bd9Sstevel@tonic-gate } 46387c478bd9Sstevel@tonic-gate 46397c478bd9Sstevel@tonic-gate /* 464056c0b1daSPavel Filipensky * Init the root filesystem type (rootfs.bo_fstype) from the "fstype" 464156c0b1daSPavel Filipensky * property. 464256c0b1daSPavel Filipensky * 464356c0b1daSPavel Filipensky * Filesystem types starting with the prefix "nfs" are diskless clients; 464456c0b1daSPavel Filipensky * init the root filename name (rootfs.bo_name), too. 464556c0b1daSPavel Filipensky * 464656c0b1daSPavel Filipensky * If we are booting via NFS we currently have these options: 464756c0b1daSPavel Filipensky * nfs - dynamically choose NFS V2, V3, or V4 (default) 464856c0b1daSPavel Filipensky * nfs2 - force NFS V2 464956c0b1daSPavel Filipensky * nfs3 - force NFS V3 465056c0b1daSPavel Filipensky * nfs4 - force NFS V4 465156c0b1daSPavel Filipensky * Because we need to maintain backward compatibility with the naming 465256c0b1daSPavel Filipensky * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c) 465356c0b1daSPavel Filipensky * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs". The dynamic 465456c0b1daSPavel Filipensky * nfs module will map the type back to either "nfs", "nfs3", or "nfs4". 465556c0b1daSPavel Filipensky * This is only for root filesystems, all other uses such as cachefs 465656c0b1daSPavel Filipensky * will expect that "nfs" == NFS V2. 46577c478bd9Sstevel@tonic-gate */ 4658843e1988Sjohnlev static void 4659843e1988Sjohnlev getrootfs(char **fstypp, char **fsmodp) 46607c478bd9Sstevel@tonic-gate { 46617c478bd9Sstevel@tonic-gate extern char *strplumb_get_netdev_path(void); 46627c478bd9Sstevel@tonic-gate char *propstr = NULL; 46637c478bd9Sstevel@tonic-gate 466456c0b1daSPavel Filipensky /* 466556c0b1daSPavel Filipensky * Check fstype property; for diskless it should be one of "nfs", 466656c0b1daSPavel Filipensky * "nfs2", "nfs3" or "nfs4". 466756c0b1daSPavel Filipensky */ 46687c478bd9Sstevel@tonic-gate if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 46697c478bd9Sstevel@tonic-gate DDI_PROP_DONTPASS, "fstype", &propstr) 46707c478bd9Sstevel@tonic-gate == DDI_SUCCESS) { 46717c478bd9Sstevel@tonic-gate (void) strncpy(rootfs.bo_fstype, propstr, BO_MAXFSNAME); 46727c478bd9Sstevel@tonic-gate ddi_prop_free(propstr); 4673b1b8ab34Slling 4674b1b8ab34Slling /* 4675b1b8ab34Slling * if the boot property 'fstype' is not set, but 'zfs-bootfs' is set, 4676b1b8ab34Slling * assume the type of this root filesystem is 'zfs'. 4677b1b8ab34Slling */ 4678b1b8ab34Slling } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 4679b1b8ab34Slling DDI_PROP_DONTPASS, "zfs-bootfs", &propstr) 4680b1b8ab34Slling == DDI_SUCCESS) { 4681b1b8ab34Slling (void) strncpy(rootfs.bo_fstype, "zfs", BO_MAXFSNAME); 4682b1b8ab34Slling ddi_prop_free(propstr); 46837c478bd9Sstevel@tonic-gate } 46847c478bd9Sstevel@tonic-gate 4685843e1988Sjohnlev if (strncmp(rootfs.bo_fstype, "nfs", 3) != 0) { 4686843e1988Sjohnlev *fstypp = *fsmodp = rootfs.bo_fstype; 4687843e1988Sjohnlev return; 4688843e1988Sjohnlev } 46897c478bd9Sstevel@tonic-gate 46907c478bd9Sstevel@tonic-gate ++netboot; 469156c0b1daSPavel Filipensky 469256c0b1daSPavel Filipensky if (strcmp(rootfs.bo_fstype, "nfs2") == 0) 469356c0b1daSPavel Filipensky (void) strcpy(rootfs.bo_fstype, "nfs"); 469456c0b1daSPavel Filipensky else if (strcmp(rootfs.bo_fstype, "nfs") == 0) 469556c0b1daSPavel Filipensky (void) strcpy(rootfs.bo_fstype, "nfsdyn"); 469656c0b1daSPavel Filipensky 4697843e1988Sjohnlev /* 4698843e1988Sjohnlev * check if path to network interface is specified in bootpath 4699843e1988Sjohnlev * or by a hypervisor domain configuration file. 4700843e1988Sjohnlev * XXPV - enable strlumb_get_netdev_path() 4701843e1988Sjohnlev */ 4702843e1988Sjohnlev if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS, 4703843e1988Sjohnlev "xpv-nfsroot")) { 4704843e1988Sjohnlev (void) strcpy(rootfs.bo_name, "/xpvd/xnf@0"); 4705843e1988Sjohnlev } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 47067c478bd9Sstevel@tonic-gate DDI_PROP_DONTPASS, "bootpath", &propstr) 47077c478bd9Sstevel@tonic-gate == DDI_SUCCESS) { 47087c478bd9Sstevel@tonic-gate (void) strncpy(rootfs.bo_name, propstr, BO_MAXOBJNAME); 47097c478bd9Sstevel@tonic-gate ddi_prop_free(propstr); 47107c478bd9Sstevel@tonic-gate } else { 47117c478bd9Sstevel@tonic-gate /* attempt to determine netdev_path via boot_mac address */ 47127c478bd9Sstevel@tonic-gate netdev_path = strplumb_get_netdev_path(); 47137c478bd9Sstevel@tonic-gate if (netdev_path == NULL) 4714ae115bc7Smrj panic("cannot find boot network interface"); 47157c478bd9Sstevel@tonic-gate (void) strncpy(rootfs.bo_name, netdev_path, BO_MAXOBJNAME); 47167c478bd9Sstevel@tonic-gate } 4717843e1988Sjohnlev *fstypp = rootfs.bo_fstype; 4718843e1988Sjohnlev *fsmodp = "nfs"; 47197c478bd9Sstevel@tonic-gate } 47207c478bd9Sstevel@tonic-gate #endif 4721da6c28aaSamw 4722da6c28aaSamw /* 4723da6c28aaSamw * VFS feature routines 4724da6c28aaSamw */ 4725da6c28aaSamw 4726da6c28aaSamw #define VFTINDEX(feature) (((feature) >> 32) & 0xFFFFFFFF) 4727da6c28aaSamw #define VFTBITS(feature) ((feature) & 0xFFFFFFFFLL) 4728da6c28aaSamw 4729da6c28aaSamw /* Register a feature in the vfs */ 4730da6c28aaSamw void 4731da6c28aaSamw vfs_set_feature(vfs_t *vfsp, vfs_feature_t feature) 4732da6c28aaSamw { 4733da6c28aaSamw /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */ 4734da6c28aaSamw if (vfsp->vfs_implp == NULL) 4735da6c28aaSamw return; 4736da6c28aaSamw 4737da6c28aaSamw vfsp->vfs_featureset[VFTINDEX(feature)] |= VFTBITS(feature); 4738da6c28aaSamw } 4739da6c28aaSamw 4740da6c28aaSamw /* 4741da6c28aaSamw * Query a vfs for a feature. 4742da6c28aaSamw * Returns 1 if feature is present, 0 if not 4743da6c28aaSamw */ 4744da6c28aaSamw int 4745da6c28aaSamw vfs_has_feature(vfs_t *vfsp, vfs_feature_t feature) 4746da6c28aaSamw { 4747da6c28aaSamw int ret = 0; 4748da6c28aaSamw 4749da6c28aaSamw /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */ 4750da6c28aaSamw if (vfsp->vfs_implp == NULL) 4751da6c28aaSamw return (ret); 4752da6c28aaSamw 4753da6c28aaSamw if (vfsp->vfs_featureset[VFTINDEX(feature)] & VFTBITS(feature)) 4754da6c28aaSamw ret = 1; 4755da6c28aaSamw 4756da6c28aaSamw return (ret); 4757da6c28aaSamw } 475879a28c7aSmarks 475979a28c7aSmarks /* 476079a28c7aSmarks * Propagate feature set from one vfs to another 476179a28c7aSmarks */ 476279a28c7aSmarks void 476379a28c7aSmarks vfs_propagate_features(vfs_t *from, vfs_t *to) 476479a28c7aSmarks { 476579a28c7aSmarks int i; 476679a28c7aSmarks 476779a28c7aSmarks if (to->vfs_implp == NULL || from->vfs_implp == NULL) 476879a28c7aSmarks return; 476979a28c7aSmarks 477079a28c7aSmarks for (i = 1; i <= to->vfs_featureset[0]; i++) { 477179a28c7aSmarks to->vfs_featureset[i] = from->vfs_featureset[i]; 477279a28c7aSmarks } 477379a28c7aSmarks } 477493239addSjohnlev 4775*0fbb751dSJohn Levon #define LOFINODE_PATH "/dev/lofi/%d" 477693239addSjohnlev 477793239addSjohnlev /* 477893239addSjohnlev * Return the vnode for the lofi node if there's a lofi mount in place. 477993239addSjohnlev * Returns -1 when there's no lofi node, 0 on success, and > 0 on 478093239addSjohnlev * failure. 478193239addSjohnlev */ 478293239addSjohnlev int 478393239addSjohnlev vfs_get_lofi(vfs_t *vfsp, vnode_t **vpp) 478493239addSjohnlev { 478593239addSjohnlev char *path = NULL; 478693239addSjohnlev int strsize; 478793239addSjohnlev int err; 478893239addSjohnlev 478993239addSjohnlev if (vfsp->vfs_lofi_minor == 0) { 479093239addSjohnlev *vpp = NULL; 479193239addSjohnlev return (-1); 479293239addSjohnlev } 479393239addSjohnlev 4794*0fbb751dSJohn Levon strsize = snprintf(NULL, 0, LOFINODE_PATH, vfsp->vfs_lofi_minor); 479593239addSjohnlev path = kmem_alloc(strsize + 1, KM_SLEEP); 4796*0fbb751dSJohn Levon (void) snprintf(path, strsize + 1, LOFINODE_PATH, vfsp->vfs_lofi_minor); 4797*0fbb751dSJohn Levon 4798*0fbb751dSJohn Levon /* 4799*0fbb751dSJohn Levon * We may be inside a zone, so we need to use the /dev path, but 4800*0fbb751dSJohn Levon * it's created asynchronously, so we wait here. 4801*0fbb751dSJohn Levon */ 4802*0fbb751dSJohn Levon for (;;) { 4803*0fbb751dSJohn Levon err = lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, vpp); 4804*0fbb751dSJohn Levon 4805*0fbb751dSJohn Levon if (err != ENOENT) 4806*0fbb751dSJohn Levon break; 480793239addSjohnlev 4808*0fbb751dSJohn Levon if ((err = delay_sig(hz / 8)) == EINTR) 4809*0fbb751dSJohn Levon break; 4810*0fbb751dSJohn Levon } 481193239addSjohnlev 481293239addSjohnlev if (err) 481393239addSjohnlev *vpp = NULL; 481493239addSjohnlev 481593239addSjohnlev kmem_free(path, strsize + 1); 481693239addSjohnlev return (err); 481793239addSjohnlev } 4818