4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
24 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
31 * University Copyright- Copyright (c) 1982, 1986, 1988
32 * The Regents of the University of California
35 * University Acknowledgment- Portions of this document are derived from
36 * software developed by the University of California, Berkeley, and its
40 #include <sys/types.h>
41 #include <sys/t_lock.h>
42 #include <sys/param.h>
43 #include <sys/errno.h>
45 #include <sys/fstyp.h>
47 #include <sys/systm.h>
49 #include <sys/mount.h>
51 #include <sys/vfs_opreg.h>
53 #include <sys/mntent.h>
55 #include <sys/statvfs.h>
56 #include <sys/statfs.h>
58 #include <sys/vnode.h>
59 #include <sys/rwstlock.h>
63 #include <sys/atomic.h>
64 #include <sys/cmn_err.h>
67 #include <sys/debug.h>
68 #include <sys/vnode.h>
69 #include <sys/modctl.h>
71 #include <sys/pathname.h>
72 #include <sys/bootconf.h>
73 #include <sys/dumphdr.h>
74 #include <sys/dc_ki.h>
76 #include <sys/sunddi.h>
77 #include <sys/sysmacros.h>
79 #include <sys/policy.h>
81 #include <sys/objfs.h>
82 #include <sys/console.h>
83 #include <sys/reboot.h>
88 #include <sys/bootprops.h>
92 #include <fs/fs_subr.h>
93 /* Private interfaces to create vopstats-related data structures */
94 extern void initialize_vopstats(vopstats_t
*);
95 extern vopstats_t
*get_fstype_vopstats(struct vfs
*, struct vfssw
*);
96 extern vsk_anchor_t
*get_vskstat_anchor(struct vfs
*);
98 static void vfs_clearmntopt_nolock(mntopts_t
*, const char *, int);
99 static void vfs_setmntopt_nolock(mntopts_t
*, const char *,
100 const char *, int, int);
101 static int vfs_optionisset_nolock(const mntopts_t
*, const char *, char **);
102 static void vfs_freemnttab(struct vfs
*);
103 static void vfs_freeopt(mntopt_t
*);
104 static void vfs_swapopttbl_nolock(mntopts_t
*, mntopts_t
*);
105 static void vfs_swapopttbl(mntopts_t
*, mntopts_t
*);
106 static void vfs_copyopttbl_extend(const mntopts_t
*, mntopts_t
*, int);
107 static void vfs_createopttbl_extend(mntopts_t
*, const char *,
109 static char **vfs_copycancelopt_extend(char **const, int);
110 static void vfs_freecancelopt(char **);
111 static void getrootfs(char **, char **);
112 static int getmacpath(dev_info_t
*, void *);
113 static void vfs_mnttabvp_setup(void);
116 struct ipmnt
*mip_next
;
118 struct vfs
*mip_vfsp
;
121 static kmutex_t vfs_miplist_mutex
;
122 static struct ipmnt
*vfs_miplist
= NULL
;
123 static struct ipmnt
*vfs_miplist_end
= NULL
;
125 static kmem_cache_t
*vfs_cache
; /* Pointer to VFS kmem cache */
130 vnode_t
*rootdir
; /* pointer to root inode vnode. */
131 vnode_t
*devicesdir
; /* pointer to inode of devices root */
132 vnode_t
*devdir
; /* pointer to inode of dev root */
134 char *server_rootpath
; /* root path for diskless clients */
135 char *server_hostname
; /* hostname of diskless server */
137 static struct vfs root
;
138 static struct vfs devices
;
139 static struct vfs dev
;
140 struct vfs
*rootvfs
= &root
; /* pointer to root vfs; head of VFS list. */
141 rvfs_t
*rvfs_list
; /* array of vfs ptrs for vfs hash list */
142 int vfshsz
= 512; /* # of heads/locks in vfs hash arrays */
143 /* must be power of 2! */
144 timespec_t vfs_mnttab_ctime
; /* mnttab created time */
145 timespec_t vfs_mnttab_mtime
; /* mnttab last modified time */
146 char *vfs_dummyfstype
= "\0";
147 struct pollhead vfs_pollhd
; /* for mnttab pollers */
148 struct vnode
*vfs_mntdummyvp
; /* to fake mnttab read/write for file events */
149 int mntfstype
; /* will be set once mnt fs is mounted */
152 * Table for generic options recognized in the VFS layer and acted
153 * on at this level before parsing file system specific options.
154 * The nosuid option is stronger than any of the devices and setuid
155 * options, so those are canceled when nosuid is seen.
157 * All options which are added here need to be added to the
158 * list of standard options in usr/src/cmd/fs.d/fslib.c as well.
161 * VFS Mount options table
163 static char *ro_cancel
[] = { MNTOPT_RW
, NULL
};
164 static char *rw_cancel
[] = { MNTOPT_RO
, NULL
};
165 static char *suid_cancel
[] = { MNTOPT_NOSUID
, NULL
};
166 static char *nosuid_cancel
[] = { MNTOPT_SUID
, MNTOPT_DEVICES
, MNTOPT_NODEVICES
,
167 MNTOPT_NOSETUID
, MNTOPT_SETUID
, NULL
};
168 static char *devices_cancel
[] = { MNTOPT_NODEVICES
, NULL
};
169 static char *nodevices_cancel
[] = { MNTOPT_DEVICES
, NULL
};
170 static char *setuid_cancel
[] = { MNTOPT_NOSETUID
, NULL
};
171 static char *nosetuid_cancel
[] = { MNTOPT_SETUID
, NULL
};
172 static char *nbmand_cancel
[] = { MNTOPT_NONBMAND
, NULL
};
173 static char *nonbmand_cancel
[] = { MNTOPT_NBMAND
, NULL
};
174 static char *exec_cancel
[] = { MNTOPT_NOEXEC
, NULL
};
175 static char *noexec_cancel
[] = { MNTOPT_EXEC
, NULL
};
177 static const mntopt_t mntopts
[] = {
179 * option name cancel options default arg flags
181 { MNTOPT_REMOUNT
, NULL
, NULL
,
182 MO_NODISPLAY
, (void *)0 },
183 { MNTOPT_RO
, ro_cancel
, NULL
, 0,
185 { MNTOPT_RW
, rw_cancel
, NULL
, 0,
187 { MNTOPT_SUID
, suid_cancel
, NULL
, 0,
189 { MNTOPT_NOSUID
, nosuid_cancel
, NULL
, 0,
191 { MNTOPT_DEVICES
, devices_cancel
, NULL
, 0,
193 { MNTOPT_NODEVICES
, nodevices_cancel
, NULL
, 0,
195 { MNTOPT_SETUID
, setuid_cancel
, NULL
, 0,
197 { MNTOPT_NOSETUID
, nosetuid_cancel
, NULL
, 0,
199 { MNTOPT_NBMAND
, nbmand_cancel
, NULL
, 0,
201 { MNTOPT_NONBMAND
, nonbmand_cancel
, NULL
, 0,
203 { MNTOPT_EXEC
, exec_cancel
, NULL
, 0,
205 { MNTOPT_NOEXEC
, noexec_cancel
, NULL
, 0,
209 const mntopts_t vfs_mntopts
= {
210 sizeof (mntopts
) / sizeof (mntopt_t
),
211 (mntopt_t
*)&mntopts
[0]
215 * File system operation dispatch functions.
219 fsop_mount(vfs_t
*vfsp
, vnode_t
*mvp
, struct mounta
*uap
, cred_t
*cr
)
221 return (*(vfsp
)->vfs_op
->vfs_mount
)(vfsp
, mvp
, uap
, cr
);
225 fsop_unmount(vfs_t
*vfsp
, int flag
, cred_t
*cr
)
227 return (*(vfsp
)->vfs_op
->vfs_unmount
)(vfsp
, flag
, cr
);
231 fsop_root(vfs_t
*vfsp
, vnode_t
**vpp
)
234 int ret
= (*(vfsp
)->vfs_op
->vfs_root
)(vfsp
, vpp
);
236 * Make sure this root has a path. With lofs, it is possible to have
239 if (ret
== 0 && vfsp
->vfs_mntpt
!= NULL
&& (*vpp
)->v_path
== NULL
) {
240 mntpt
= vfs_getmntpoint(vfsp
);
241 vn_setpath_str(*vpp
, refstr_value(mntpt
),
242 strlen(refstr_value(mntpt
)));
250 fsop_statfs(vfs_t
*vfsp
, statvfs64_t
*sp
)
252 return (*(vfsp
)->vfs_op
->vfs_statvfs
)(vfsp
, sp
);
256 fsop_sync(vfs_t
*vfsp
, short flag
, cred_t
*cr
)
258 return (*(vfsp
)->vfs_op
->vfs_sync
)(vfsp
, flag
, cr
);
262 fsop_vget(vfs_t
*vfsp
, vnode_t
**vpp
, fid_t
*fidp
)
265 * In order to handle system attribute fids in a manner
266 * transparent to the underlying fs, we embed the fid for
267 * the sysattr parent object in the sysattr fid and tack on
268 * some extra bytes that only the sysattr layer knows about.
270 * This guarantees that sysattr fids are larger than other fids
271 * for this vfs. If the vfs supports the sysattr view interface
272 * (as indicated by VFSFT_SYSATTR_VIEWS), we cannot have a size
273 * collision with XATTR_FIDSZ.
275 if (vfs_has_feature(vfsp
, VFSFT_SYSATTR_VIEWS
) &&
276 fidp
->fid_len
== XATTR_FIDSZ
)
277 return (xattr_dir_vget(vfsp
, vpp
, fidp
));
279 return (*(vfsp
)->vfs_op
->vfs_vget
)(vfsp
, vpp
, fidp
);
283 fsop_mountroot(vfs_t
*vfsp
, enum whymountroot reason
)
285 return (*(vfsp
)->vfs_op
->vfs_mountroot
)(vfsp
, reason
);
289 fsop_freefs(vfs_t
*vfsp
)
291 (*(vfsp
)->vfs_op
->vfs_freevfs
)(vfsp
);
295 fsop_vnstate(vfs_t
*vfsp
, vnode_t
*vp
, vntrans_t nstate
)
297 return ((*(vfsp
)->vfs_op
->vfs_vnstate
)(vfsp
, vp
, nstate
));
301 fsop_sync_by_kind(int fstype
, short flag
, cred_t
*cr
)
303 ASSERT((fstype
>= 0) && (fstype
< nfstype
));
305 if (ALLOCATED_VFSSW(&vfssw
[fstype
]) && VFS_INSTALLED(&vfssw
[fstype
]))
306 return (*vfssw
[fstype
].vsw_vfsops
.vfs_sync
) (NULL
, flag
, cr
);
312 * File system initialization. vfs_setfsops() must be called from a file
313 * system's init routine.
317 fs_copyfsops(const fs_operation_def_t
*template, vfsops_t
*actual
,
320 static const fs_operation_trans_def_t vfs_ops_table
[] = {
321 VFSNAME_MOUNT
, offsetof(vfsops_t
, vfs_mount
),
324 VFSNAME_UNMOUNT
, offsetof(vfsops_t
, vfs_unmount
),
327 VFSNAME_ROOT
, offsetof(vfsops_t
, vfs_root
),
330 VFSNAME_STATVFS
, offsetof(vfsops_t
, vfs_statvfs
),
333 VFSNAME_SYNC
, offsetof(vfsops_t
, vfs_sync
),
334 (fs_generic_func_p
) fs_sync
,
335 (fs_generic_func_p
) fs_sync
, /* No errors allowed */
337 VFSNAME_VGET
, offsetof(vfsops_t
, vfs_vget
),
340 VFSNAME_MOUNTROOT
, offsetof(vfsops_t
, vfs_mountroot
),
343 VFSNAME_FREEVFS
, offsetof(vfsops_t
, vfs_freevfs
),
344 (fs_generic_func_p
)fs_freevfs
,
345 (fs_generic_func_p
)fs_freevfs
, /* Shouldn't fail */
347 VFSNAME_VNSTATE
, offsetof(vfsops_t
, vfs_vnstate
),
348 (fs_generic_func_p
)fs_nosys
,
349 (fs_generic_func_p
)fs_nosys
,
354 return (fs_build_vector(actual
, unused_ops
, vfs_ops_table
, template));
360 if (strcmp(rootfs
.bo_fstype
, MNTTYPE_ZFS
) == 0)
365 vfs_setfsops(int fstype
, const fs_operation_def_t
*template, vfsops_t
**actual
)
371 * Verify that fstype refers to a valid fs. Note that
372 * 0 is valid since it's used to set "stray" ops.
374 if ((fstype
< 0) || (fstype
>= nfstype
))
377 if (!ALLOCATED_VFSSW(&vfssw
[fstype
]))
380 /* Set up the operations vector. */
382 error
= fs_copyfsops(template, &vfssw
[fstype
].vsw_vfsops
, &unused_ops
);
387 vfssw
[fstype
].vsw_flag
|= VSW_INSTALLED
;
390 *actual
= &vfssw
[fstype
].vsw_vfsops
;
394 cmn_err(CE_WARN
, "vfs_setfsops: %s: %d operations supplied "
395 "but not used", vfssw
[fstype
].vsw_name
, unused_ops
);
402 vfs_makefsops(const fs_operation_def_t
*template, vfsops_t
**actual
)
407 *actual
= (vfsops_t
*)kmem_alloc(sizeof (vfsops_t
), KM_SLEEP
);
409 error
= fs_copyfsops(template, *actual
, &unused_ops
);
411 kmem_free(*actual
, sizeof (vfsops_t
));
420 * Free a vfsops structure created as a result of vfs_makefsops().
421 * NOTE: For a vfsops structure initialized by vfs_setfsops(), use
422 * vfs_freevfsops_by_type().
425 vfs_freevfsops(vfsops_t
*vfsops
)
427 kmem_free(vfsops
, sizeof (vfsops_t
));
431 * Since the vfsops structure is part of the vfssw table and wasn't
432 * really allocated, we're not really freeing anything. We keep
433 * the name for consistency with vfs_freevfsops(). We do, however,
434 * need to take care of a little bookkeeping.
435 * NOTE: For a vfsops structure created by vfs_setfsops(), use
436 * vfs_freevfsops_by_type().
439 vfs_freevfsops_by_type(int fstype
)
442 /* Verify that fstype refers to a loaded fs (and not fsid 0). */
443 if ((fstype
<= 0) || (fstype
>= nfstype
))
447 if ((vfssw
[fstype
].vsw_flag
& VSW_INSTALLED
) == 0) {
452 vfssw
[fstype
].vsw_flag
&= ~VSW_INSTALLED
;
458 /* Support routines used to reference vfs_op */
460 /* Set the operations vector for a vfs */
462 vfs_setops(vfs_t
*vfsp
, vfsops_t
*vfsops
)
466 ASSERT(vfsp
!= NULL
);
467 ASSERT(vfsops
!= NULL
);
471 if (vfsp
->vfs_femhead
== NULL
&&
472 atomic_cas_ptr(&vfsp
->vfs_op
, op
, vfsops
) == op
) {
475 fsem_setvfsops(vfsp
, vfsops
);
478 /* Retrieve the operations vector for a vfs */
480 vfs_getops(vfs_t
*vfsp
)
484 ASSERT(vfsp
!= NULL
);
488 if (vfsp
->vfs_femhead
== NULL
&& op
== vfsp
->vfs_op
) {
491 return (fsem_getvfsops(vfsp
));
496 * Returns non-zero (1) if the vfsops matches that of the vfs.
497 * Returns zero (0) if not.
500 vfs_matchops(vfs_t
*vfsp
, vfsops_t
*vfsops
)
502 return (vfs_getops(vfsp
) == vfsops
);
506 * Returns non-zero (1) if the file system has installed a non-default,
507 * non-error vfs_sync routine. Returns zero (0) otherwise.
510 vfs_can_sync(vfs_t
*vfsp
)
512 /* vfs_sync() routine is not the default/error function */
513 return (vfs_getops(vfsp
)->vfs_sync
!= fs_sync
);
517 * Initialize a vfs structure.
520 vfs_init(vfs_t
*vfsp
, vfsops_t
*op
, void *data
)
522 /* Other initialization has been moved to vfs_alloc() */
524 vfsp
->vfs_next
= vfsp
;
525 vfsp
->vfs_prev
= vfsp
;
526 vfsp
->vfs_zone_next
= vfsp
;
527 vfsp
->vfs_zone_prev
= vfsp
;
528 vfsp
->vfs_lofi_minor
= 0;
529 sema_init(&vfsp
->vfs_reflock
, 1, NULL
, SEMA_DEFAULT
, NULL
);
531 vfsp
->vfs_data
= (data
);
532 vfs_setops((vfsp
), (op
));
536 * Allocate and initialize the vfs implementation private data
537 * structure, vfs_impl_t.
540 vfsimpl_setup(vfs_t
*vfsp
)
544 if (vfsp
->vfs_implp
!= NULL
) {
548 vfsp
->vfs_implp
= kmem_alloc(sizeof (vfs_impl_t
), KM_SLEEP
);
549 /* Note that these are #define'd in vfs.h */
550 vfsp
->vfs_vskap
= NULL
;
551 vfsp
->vfs_fstypevsp
= NULL
;
553 /* Set size of counted array, then zero the array */
554 vfsp
->vfs_featureset
[0] = VFS_FEATURE_MAXSZ
- 1;
555 for (i
= 1; i
< VFS_FEATURE_MAXSZ
; i
++) {
556 vfsp
->vfs_featureset
[i
] = 0;
561 * Release the vfs_impl_t structure, if it exists. Some unbundled
562 * filesystems may not use the newer version of vfs and thus
563 * would not contain this implementation private data structure.
566 vfsimpl_teardown(vfs_t
*vfsp
)
568 vfs_impl_t
*vip
= vfsp
->vfs_implp
;
573 kmem_free(vfsp
->vfs_implp
, sizeof (vfs_impl_t
));
574 vfsp
->vfs_implp
= NULL
;
578 * VFS system calls: mount, umount, syssync, statfs, fstatfs, statvfs,
579 * fstatvfs, and sysfs moved to common/syscall.
583 * Update every mounted file system. We call the vfs_sync operation of
584 * each file system type, passing it a NULL vfsp to indicate that all
585 * mounted file systems of that type should be updated.
592 for (vswp
= &vfssw
[1]; vswp
< &vfssw
[nfstype
]; vswp
++) {
593 if (ALLOCATED_VFSSW(vswp
) && VFS_INSTALLED(vswp
)) {
596 (void) (*vswp
->vsw_vfsops
.vfs_sync
)(NULL
, flag
,
598 vfs_unrefvfssw(vswp
);
615 krwlock_t vfssw_lock
; /* lock accesses to vfssw */
618 * Lock for accessing the vfs linked list. Initialized in vfs_mountroot(),
619 * but otherwise should be accessed only via vfs_list_lock() and
620 * vfs_list_unlock(). Also used to protect the timestamp for mods to the list.
622 static krwlock_t vfslist
;
625 * Mount devfs on /devices. This is done right after root is mounted
626 * to provide device access support for the system
629 vfs_mountdevices(void)
633 struct mounta mounta
= { /* fake mounta for devfs_mount() */
645 * _init devfs module to fill in the vfssw
647 if (modload("fs", "devfs") == -1)
648 panic("Cannot _init devfs module");
654 vsw
= vfs_getvfsswbyname("devfs");
655 VFS_INIT(&devices
, &vsw
->vsw_vfsops
, NULL
);
661 if (lookupname("/devices", UIO_SYSSPACE
, FOLLOW
, NULLVPP
, &mvp
))
662 panic("Cannot find /devices");
665 * Perform the mount of /devices
667 if (VFS_MOUNT(&devices
, mvp
, &mounta
, CRED()))
668 panic("Cannot mount /devices");
673 * Set appropriate members and add to vfs list for mnttab display
675 vfs_setresource(&devices
, "/devices", 0);
676 vfs_setmntpoint(&devices
, "/devices", 0);
679 * Hold the root of /devices so it won't go away
681 if (VFS_ROOT(&devices
, &devicesdir
))
682 panic("vfs_mountdevices: not devices root");
684 if (vfs_lock(&devices
) != 0) {
686 cmn_err(CE_NOTE
, "Cannot acquire vfs_lock of /devices");
690 if (vn_vfswlock(mvp
) != 0) {
691 vfs_unlock(&devices
);
693 cmn_err(CE_NOTE
, "Cannot acquire vfswlock of /devices");
697 vfs_add(mvp
, &devices
, 0);
699 vfs_unlock(&devices
);
704 * mount the first instance of /dev to root and remain mounted
711 struct mounta mounta
= { /* fake mounta for sdev_mount() */
714 MS_SYSSPACE
| MS_OVERLAY
,
723 * _init dev module to fill in the vfssw
725 if (modload("fs", "dev") == -1)
726 cmn_err(CE_PANIC
, "Cannot _init dev module\n");
732 vsw
= vfs_getvfsswbyname("dev");
733 VFS_INIT(&dev
, &vsw
->vsw_vfsops
, NULL
);
739 if (lookupname("/dev", UIO_SYSSPACE
, FOLLOW
, NULLVPP
, &mvp
))
740 cmn_err(CE_PANIC
, "Cannot find /dev\n");
743 * Perform the mount of /dev
745 if (VFS_MOUNT(&dev
, mvp
, &mounta
, CRED()))
746 cmn_err(CE_PANIC
, "Cannot mount /dev 1\n");
751 * Set appropriate members and add to vfs list for mnttab display
753 vfs_setresource(&dev
, "/dev", 0);
754 vfs_setmntpoint(&dev
, "/dev", 0);
757 * Hold the root of /dev so it won't go away
759 if (VFS_ROOT(&dev
, &devdir
))
760 cmn_err(CE_PANIC
, "vfs_mountdev1: not dev root");
762 if (vfs_lock(&dev
) != 0) {
764 cmn_err(CE_NOTE
, "Cannot acquire vfs_lock of /dev");
768 if (vn_vfswlock(mvp
) != 0) {
771 cmn_err(CE_NOTE
, "Cannot acquire vfswlock of /dev");
775 vfs_add(mvp
, &dev
, 0);
782 * Mount required filesystem. This is done right after root is mounted.
785 vfs_mountfs(char *module
, char *spec
, char *path
)
788 struct mounta mounta
;
791 mounta
.flags
= MS_SYSSPACE
| MS_DATA
;
792 mounta
.fstype
= module
;
795 if (lookupname(path
, UIO_SYSSPACE
, FOLLOW
, NULLVPP
, &mvp
)) {
796 cmn_err(CE_WARN
, "Cannot find %s", path
);
799 if (domount(NULL
, &mounta
, mvp
, CRED(), &vfsp
))
800 cmn_err(CE_WARN
, "Cannot mount %s", path
);
807 * vfs_mountroot is called by main() to mount the root filesystem.
812 struct vnode
*rvp
= NULL
;
818 rw_init(&vfssw_lock
, NULL
, RW_DEFAULT
, NULL
);
819 rw_init(&vfslist
, NULL
, RW_DEFAULT
, NULL
);
822 * Alloc the vfs hash bucket array and locks
824 rvfs_list
= kmem_zalloc(vfshsz
* sizeof (rvfs_t
), KM_SLEEP
);
827 * Call machine-dependent routine "rootconf" to choose a root
831 panic("vfs_mountroot: cannot mount root");
833 * Get vnode for '/'. Set up rootdir, u.u_rdir and u.u_cdir
834 * to point to it. These are used by lookuppn() so that it
835 * knows where to start from ('/' or '.').
837 vfs_setmntpoint(rootvfs
, "/", 0);
838 if (VFS_ROOT(rootvfs
, &rootdir
))
839 panic("vfs_mountroot: no root vnode");
842 * At this point, the process tree consists of p0 and possibly some
843 * direct children of p0. (i.e. there are no grandchildren)
845 * Walk through them all, setting their current directory.
847 mutex_enter(&pidlock
);
848 for (p
= practive
; p
!= NULL
; p
= p
->p_next
) {
849 ASSERT(p
== &p0
|| p
->p_parent
== &p0
);
851 PTOU(p
)->u_cdir
= rootdir
;
852 VN_HOLD(PTOU(p
)->u_cdir
);
853 PTOU(p
)->u_rdir
= NULL
;
855 mutex_exit(&pidlock
);
858 * Setup the global zone's rootvp, now that it exists.
860 global_zone
->zone_rootvp
= rootdir
;
861 VN_HOLD(global_zone
->zone_rootvp
);
864 * Notify the module code that it can begin using the
865 * root filesystem instead of the boot program's services.
870 * Special handling for a ZFS root file system.
875 * Set up mnttab information for root
877 vfs_setresource(rootvfs
, rootfs
.bo_name
, 0);
880 * Notify cluster software that the root filesystem is available.
884 /* Now that we're all done with the root FS, set up its vopstats */
885 if ((vswp
= vfs_getvfsswbyvfsops(vfs_getops(rootvfs
))) != NULL
) {
886 /* Set flag for statistics collection */
887 if (vswp
->vsw_flag
& VSW_STATS
) {
888 initialize_vopstats(&rootvfs
->vfs_vopstats
);
889 rootvfs
->vfs_flag
|= VFS_STATS
;
890 rootvfs
->vfs_fstypevsp
=
891 get_fstype_vopstats(rootvfs
, vswp
);
892 rootvfs
->vfs_vskap
= get_vskstat_anchor(rootvfs
);
894 vfs_unrefvfssw(vswp
);
898 * Mount /devices, /dev instance 1, /system/contract, /etc/mnttab,
899 * /etc/svc/volatile, /etc/dfs/sharetab, /system/object, and /proc.
904 vfs_mountfs("ctfs", "ctfs", CTFS_ROOT
);
905 vfs_mountfs("proc", "/proc", "/proc");
906 vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab");
907 vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile");
908 vfs_mountfs("objfs", "objfs", OBJFS_ROOT
);
909 vfs_mountfs("bootfs", "bootfs", "/system/boot");
911 if (getzoneid() == GLOBAL_ZONEID
) {
912 vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab");
917 * This bit of magic can go away when we convert sparc to
918 * the new boot architecture based on ramdisk.
920 * Booting off a mirrored root volume:
921 * At this point, we have booted and mounted root on a
922 * single component of the mirror. Complete the boot
923 * by configuring SVM and converting the root to the
924 * dev_t of the mirrored root device. This dev_t conversion
925 * only works because the underlying device doesn't change.
928 if (svm_rootconf()) {
929 panic("vfs_mountroot: cannot remount root");
933 * mnttab should reflect the new root device
935 vfs_lock_wait(rootvfs
);
936 vfs_setresource(rootvfs
, rootfs
.bo_name
, 0);
941 if (strcmp(rootfs
.bo_fstype
, "zfs") != 0) {
943 * Look up the root device via devfs so that a dv_node is
944 * created for it. The vnode is never VN_RELE()ed.
945 * We allocate more than MAXPATHLEN so that the
946 * buffer passed to i_ddi_prompath_to_devfspath() is
947 * exactly MAXPATHLEN (the function expects a buffer
950 plen
= strlen("/devices");
951 path
= kmem_alloc(plen
+ MAXPATHLEN
, KM_SLEEP
);
952 (void) strcpy(path
, "/devices");
954 if (i_ddi_prompath_to_devfspath(rootfs
.bo_name
, path
+ plen
)
956 lookupname(path
, UIO_SYSSPACE
, FOLLOW
, NULLVPP
, &rvp
)) {
958 /* NUL terminate in case "path" has garbage */
959 path
[plen
+ MAXPATHLEN
- 1] = '\0';
961 cmn_err(CE_WARN
, "!Cannot lookup root device: %s",
965 kmem_free(path
, plen
+ MAXPATHLEN
);
968 vfs_mnttabvp_setup();
972 * Check to see if our "block device" is actually a file. If so,
973 * automatically add a lofi device, and keep track of this fact.
976 lofi_add(const char *fsname
, struct vfs
*vfsp
,
977 mntopts_t
*mntopts
, struct mounta
*uap
)
979 int fromspace
= (uap
->flags
& MS_SYSSPACE
) ?
980 UIO_SYSSPACE
: UIO_USERSPACE
;
981 struct lofi_ioctl
*li
= NULL
;
982 struct vnode
*vp
= NULL
;
983 struct pathname pn
= { NULL
};
985 ldi_handle_t ldi_hdl
;
990 if ((vfssw
= vfs_getvfssw(fsname
)) == NULL
)
993 if (!(vfssw
->vsw_flag
& VSW_CANLOFI
)) {
994 vfs_unrefvfssw(vfssw
);
998 vfs_unrefvfssw(vfssw
);
1001 if (pn_get(uap
->spec
, fromspace
, &pn
) != 0)
1004 if (lookupname(uap
->spec
, fromspace
, FOLLOW
, NULL
, &vp
) != 0)
1007 if (vp
->v_type
!= VREG
)
1010 /* OK, this is a lofi mount. */
1012 if ((uap
->flags
& (MS_REMOUNT
|MS_GLOBAL
)) ||
1013 vfs_optionisset_nolock(mntopts
, MNTOPT_SUID
, NULL
) ||
1014 vfs_optionisset_nolock(mntopts
, MNTOPT_SETUID
, NULL
) ||
1015 vfs_optionisset_nolock(mntopts
, MNTOPT_DEVICES
, NULL
)) {
1020 ldi_id
= ldi_ident_from_anon();
1021 li
= kmem_zalloc(sizeof (*li
), KM_SLEEP
);
1022 (void) strlcpy(li
->li_filename
, pn
.pn_path
, MAXPATHLEN
);
1024 err
= ldi_open_by_name("/dev/lofictl", FREAD
| FWRITE
, kcred
,
1030 err
= ldi_ioctl(ldi_hdl
, LOFI_MAP_FILE
, (intptr_t)li
,
1031 FREAD
| FWRITE
| FKIOCTL
, kcred
, &minor
);
1033 (void) ldi_close(ldi_hdl
, FREAD
| FWRITE
, kcred
);
1036 vfsp
->vfs_lofi_minor
= minor
;
1039 ldi_ident_release(ldi_id
);
1042 kmem_free(li
, sizeof (*li
));
1050 lofi_remove(struct vfs
*vfsp
)
1052 struct lofi_ioctl
*li
= NULL
;
1054 ldi_handle_t ldi_hdl
;
1057 if (vfsp
->vfs_lofi_minor
== 0)
1060 ldi_id
= ldi_ident_from_anon();
1062 li
= kmem_zalloc(sizeof (*li
), KM_SLEEP
);
1063 li
->li_minor
= vfsp
->vfs_lofi_minor
;
1064 li
->li_cleanup
= B_TRUE
;
1066 err
= ldi_open_by_name("/dev/lofictl", FREAD
| FWRITE
, kcred
,
1072 err
= ldi_ioctl(ldi_hdl
, LOFI_UNMAP_FILE_MINOR
, (intptr_t)li
,
1073 FREAD
| FWRITE
| FKIOCTL
, kcred
, NULL
);
1075 (void) ldi_close(ldi_hdl
, FREAD
| FWRITE
, kcred
);
1078 vfsp
->vfs_lofi_minor
= 0;
1081 ldi_ident_release(ldi_id
);
1083 kmem_free(li
, sizeof (*li
));
1087 * Common mount code. Called from the system call entry point, from autofs,
1088 * nfsv4 trigger mounts, and from pxfs.
1090 * Takes the effective file system type, mount arguments, the mount point
1091 * vnode, flags specifying whether the mount is a remount and whether it
1092 * should be entered into the vfs list, and credentials. Fills in its vfspp
1093 * parameter with the mounted file system instance's vfs.
1095 * Note that the effective file system type is specified as a string. It may
1096 * be null, in which case it's determined from the mount arguments, and may
1097 * differ from the type specified in the mount arguments; this is a hook to
1098 * allow interposition when instantiating file system instances.
1100 * The caller is responsible for releasing its own hold on the mount point
1101 * vp (this routine does its own hold when necessary).
1102 * Also note that for remounts, the mount point vp should be the vnode for
1103 * the root of the file system rather than the vnode that the file system
1104 * is mounted on top of.
1107 domount(char *fsname
, struct mounta
*uap
, vnode_t
*vp
, struct cred
*credp
,
1115 mntopts_t mnt_mntopts
;
1117 int copyout_error
= 0;
1119 char *opts
= uap
->optptr
;
1120 char *inargs
= opts
;
1121 int optlen
= uap
->optlen
;
1127 int splice
= ((uap
->flags
& MS_NOSPLICE
) == 0);
1128 int fromspace
= (uap
->flags
& MS_SYSSPACE
) ?
1129 UIO_SYSSPACE
: UIO_USERSPACE
;
1130 char *resource
= NULL
, *mountpt
= NULL
;
1131 refstr_t
*oldresource
, *oldmntpt
;
1132 struct pathname pn
, rpn
;
1133 vsk_anchor_t
*vskap
;
1134 char fstname
[FSTYPSZ
];
1138 * The v_flag value for the mount point vp is permanently set
1139 * to VVFSLOCK so that no one bypasses the vn_vfs*locks routine
1140 * for mount point locking.
1142 mutex_enter(&vp
->v_lock
);
1143 vp
->v_flag
|= VVFSLOCK
;
1144 mutex_exit(&vp
->v_lock
);
1146 mnt_mntopts
.mo_count
= 0;
1148 * Find the ops vector to use to invoke the file system-specific mount
1149 * method. If the fsname argument is non-NULL, use it directly.
1150 * Otherwise, dig the file system type information out of the mount
1153 * A side effect is to hold the vfssw entry.
1155 * Mount arguments can be specified in several ways, which are
1156 * distinguished by flag bit settings. The preferred way is to set
1157 * MS_OPTIONSTR, indicating an 8 argument mount with the file system
1158 * type supplied as a character string and the last two arguments
1159 * being a pointer to a character buffer and the size of the buffer.
1160 * On entry, the buffer holds a null terminated list of options; on
1161 * return, the string is the list of options the file system
1162 * recognized. If MS_DATA is set arguments five and six point to a
1163 * block of binary data which the file system interprets.
1164 * A further wrinkle is that some callers don't set MS_FSS and MS_DATA
1165 * consistently with these conventions. To handle them, we check to
1166 * see whether the pointer to the file system name has a numeric value
1167 * less than 256. If so, we treat it as an index.
1169 if (fsname
!= NULL
) {
1170 if ((vswp
= vfs_getvfssw(fsname
)) == NULL
) {
1173 } else if (uap
->flags
& (MS_OPTIONSTR
| MS_DATA
| MS_FSS
)) {
1179 if ((fstype
= (uintptr_t)uap
->fstype
) < 256) {
1181 if (fstype
== 0 || fstype
>= nfstype
||
1182 !ALLOCATED_VFSSW(&vfssw
[fstype
])) {
1186 (void) strcpy(fsname
, vfssw
[fstype
].vsw_name
);
1188 if ((vswp
= vfs_getvfssw(fsname
)) == NULL
)
1192 * Handle either kernel or user address space.
1194 if (uap
->flags
& MS_SYSSPACE
) {
1195 error
= copystr(uap
->fstype
, fsname
,
1198 error
= copyinstr(uap
->fstype
, fsname
,
1202 if (error
== ENAMETOOLONG
)
1206 if ((vswp
= vfs_getvfssw(fsname
)) == NULL
)
1210 if ((vswp
= vfs_getvfsswbyvfsops(vfs_getops(rootvfs
))) == NULL
)
1212 fsname
= vswp
->vsw_name
;
1214 if (!VFS_INSTALLED(vswp
))
1217 if ((error
= secpolicy_fs_allowed_mount(fsname
)) != 0) {
1218 vfs_unrefvfssw(vswp
);
1222 vfsops
= &vswp
->vsw_vfsops
;
1224 vfs_copyopttbl(&vswp
->vsw_optproto
, &mnt_mntopts
);
1226 * Fetch mount options and parse them for generic vfs options
1228 if (uap
->flags
& MS_OPTIONSTR
) {
1230 * Limit the buffer size
1232 if (optlen
< 0 || optlen
> MAX_MNTOPT_STR
) {
1236 if ((uap
->flags
& MS_SYSSPACE
) == 0) {
1237 inargs
= kmem_alloc(MAX_MNTOPT_STR
, KM_SLEEP
);
1240 error
= copyinstr(opts
, inargs
, (size_t)optlen
,
1247 vfs_parsemntopts(&mnt_mntopts
, inargs
, 0);
1250 * Flag bits override the options string.
1252 if (uap
->flags
& MS_REMOUNT
)
1253 vfs_setmntopt_nolock(&mnt_mntopts
, MNTOPT_REMOUNT
, NULL
, 0, 0);
1254 if (uap
->flags
& MS_RDONLY
)
1255 vfs_setmntopt_nolock(&mnt_mntopts
, MNTOPT_RO
, NULL
, 0, 0);
1256 if (uap
->flags
& MS_NOSUID
)
1257 vfs_setmntopt_nolock(&mnt_mntopts
, MNTOPT_NOSUID
, NULL
, 0, 0);
1260 * Check if this is a remount; must be set in the option string and
1261 * the file system must support a remount option.
1263 if (remount
= vfs_optionisset_nolock(&mnt_mntopts
,
1264 MNTOPT_REMOUNT
, NULL
)) {
1265 if (!(vswp
->vsw_flag
& VSW_CANREMOUNT
)) {
1269 uap
->flags
|= MS_REMOUNT
;
1273 * uap->flags and vfs_optionisset() should agree.
1275 if (rdonly
= vfs_optionisset_nolock(&mnt_mntopts
, MNTOPT_RO
, NULL
)) {
1276 uap
->flags
|= MS_RDONLY
;
1278 if (vfs_optionisset_nolock(&mnt_mntopts
, MNTOPT_NOSUID
, NULL
)) {
1279 uap
->flags
|= MS_NOSUID
;
1281 nbmand
= vfs_optionisset_nolock(&mnt_mntopts
, MNTOPT_NBMAND
, NULL
);
1282 ASSERT(splice
|| !remount
);
1284 * If we are splicing the fs into the namespace,
1285 * perform mount point checks.
1287 * We want to resolve the path for the mount point to eliminate
1288 * '.' and ".." and symlinks in mount points; we can't do the
1289 * same for the resource string, since it would turn
1290 * "/dev/dsk/c0t0d0s0" into "/devices/pci@...". We need to do
1291 * this before grabbing vn_vfswlock(), because otherwise we
1292 * would deadlock with lookuppn().
1295 ASSERT(vp
->v_count
> 0);
1298 * Pick up mount point and device from appropriate space.
1300 if (pn_get(uap
->spec
, fromspace
, &pn
) == 0) {
1301 resource
= kmem_alloc(pn
.pn_pathlen
+ 1,
1303 (void) strcpy(resource
, pn
.pn_path
);
1307 * Do a lookupname prior to taking the
1308 * writelock. Mark this as completed if
1309 * successful for later cleanup and addition to
1310 * the mount in progress table.
1312 if ((uap
->flags
& MS_GLOBAL
) == 0 &&
1313 lookupname(uap
->spec
, fromspace
,
1314 FOLLOW
, NULL
, &bvp
) == 0) {
1318 if ((error
= pn_get(uap
->dir
, fromspace
, &pn
)) == 0) {
1321 if (*pn
.pn_path
!= '/') {
1328 * Kludge to prevent autofs from deadlocking with
1329 * itself when it calls domount().
1331 * If autofs is calling, it is because it is doing
1332 * (autofs) mounts in the process of an NFS mount. A
1333 * lookuppn() here would cause us to block waiting for
1334 * said NFS mount to complete, which can't since this
1335 * is the thread that was supposed to doing it.
1337 if (fromspace
== UIO_USERSPACE
) {
1338 if ((error
= lookuppn(&pn
, &rpn
, FOLLOW
, NULL
,
1343 * The file disappeared or otherwise
1344 * became inaccessible since we opened
1345 * it; might as well fail the mount
1346 * since the mount point is no longer
1356 mountpt
= kmem_alloc(pnp
->pn_pathlen
+ 1, KM_SLEEP
);
1357 (void) strcpy(mountpt
, pnp
->pn_path
);
1360 * If the addition of the zone's rootpath
1361 * would push us over a total path length
1362 * of MAXPATHLEN, we fail the mount with
1363 * ENAMETOOLONG, which is what we would have
1364 * gotten if we were trying to perform the same
1365 * mount in the global zone.
1367 * strlen() doesn't count the trailing
1368 * '\0', but zone_rootpathlen counts both a
1369 * trailing '/' and the terminating '\0'.
1371 if ((curproc
->p_zone
->zone_rootpathlen
- 1 +
1372 strlen(mountpt
)) > MAXPATHLEN
||
1373 (resource
!= NULL
&&
1374 (curproc
->p_zone
->zone_rootpathlen
- 1 +
1375 strlen(resource
)) > MAXPATHLEN
)) {
1376 error
= ENAMETOOLONG
;
1387 * Prevent path name resolution from proceeding past
1390 if (vn_vfswlock(vp
) != 0) {
1396 * Verify that it's legitimate to establish a mount on
1397 * the prospective mount point.
1399 if (vn_mountedvfs(vp
) != NULL
) {
1401 * The mount point lock was obtained after some
1402 * other thread raced through and established a mount.
1408 if (vp
->v_flag
& VNOMOUNT
) {
1414 if ((uap
->flags
& (MS_DATA
| MS_OPTIONSTR
)) == 0) {
1415 uap
->dataptr
= NULL
;
1420 * If this is a remount, we don't want to create a new VFS.
1421 * Instead, we pass the existing one with a remount flag.
1425 * Confirm that the mount point is the root vnode of the
1426 * file system that is being remounted.
1427 * This can happen if the user specifies a different
1428 * mount point directory pathname in the (re)mount command.
1430 * Code below can only be reached if splice is true, so it's
1431 * safe to do vn_vfsunlock() here.
1433 if ((vp
->v_flag
& VROOT
) == 0) {
1439 * Disallow making file systems read-only unless file system
1440 * explicitly allows it in its vfssw. Ignore other flags.
1442 if (rdonly
&& vn_is_readonly(vp
) == 0 &&
1443 (vswp
->vsw_flag
& VSW_CANRWRO
) == 0) {
1449 * Disallow changing the NBMAND disposition of the file
1450 * system on remounts.
1452 if ((nbmand
&& ((vp
->v_vfsp
->vfs_flag
& VFS_NBMAND
) == 0)) ||
1453 (!nbmand
&& (vp
->v_vfsp
->vfs_flag
& VFS_NBMAND
))) {
1459 ovflags
= vfsp
->vfs_flag
;
1460 vfsp
->vfs_flag
|= VFS_REMOUNT
;
1461 vfsp
->vfs_flag
&= ~VFS_RDONLY
;
1463 vfsp
= vfs_alloc(KM_SLEEP
);
1464 VFS_INIT(vfsp
, vfsops
, NULL
);
1469 if ((error
= lofi_add(fsname
, vfsp
, &mnt_mntopts
, uap
)) != 0) {
1482 * PRIV_SYS_MOUNT doesn't mean you can become root.
1484 if (vfsp
->vfs_lofi_minor
!= 0) {
1485 uap
->flags
|= MS_NOSUID
;
1486 vfs_setmntopt_nolock(&mnt_mntopts
, MNTOPT_NOSUID
, NULL
, 0, 0);
1490 * The vfs_reflock is not used anymore the code below explicitly
1491 * holds it preventing others accesing it directly.
1493 if ((sema_tryp(&vfsp
->vfs_reflock
) == 0) &&
1494 !(vfsp
->vfs_flag
& VFS_REMOUNT
))
1496 "mount type %s couldn't get vfs_reflock", vswp
->vsw_name
);
1499 * Lock the vfs. If this is a remount we want to avoid spurious umount
1500 * failures that happen as a side-effect of fsflush() and other mount
1501 * and unmount operations that might be going on simultaneously and
1502 * may have locked the vfs currently. To not return EBUSY immediately
1503 * here we use vfs_lock_wait() instead vfs_lock() for the remount case.
1506 if (error
= vfs_lock(vfsp
)) {
1507 vfsp
->vfs_flag
= ovflags
;
1517 vfs_lock_wait(vfsp
);
1521 * Add device to mount in progress table, global mounts require special
1522 * handling. It is possible that we have already done the lookupname
1523 * on a spliced, non-global fs. If so, we don't want to do it again
1524 * since we cannot do a lookupname after taking the
1525 * wlock above. This case is for a non-spliced, non-global filesystem.
1528 if ((uap
->flags
& MS_GLOBAL
) == 0 &&
1529 lookupname(uap
->spec
, fromspace
, FOLLOW
, NULL
, &bvp
) == 0) {
1535 vnode_t
*lvp
= NULL
;
1537 error
= vfs_get_lofi(vfsp
, &lvp
);
1552 } else if (error
== -1) {
1561 vfs_addmip(bdev
, vfsp
);
1566 * Invalidate cached entry for the mount point.
1572 * If have an option string but the filesystem doesn't supply a
1573 * prototype options table, create a table with the global
1574 * options and sufficient room to accept all the options in the
1575 * string. Then parse the passed in option string
1576 * accepting all the options in the string. This gives us an
1577 * option table with all the proper cancel properties for the
1580 * Filesystems that supply a prototype options table are handled
1581 * earlier in this function.
1583 if (uap
->flags
& MS_OPTIONSTR
) {
1584 if (!(vswp
->vsw_flag
& VSW_HASPROTO
)) {
1585 mntopts_t tmp_mntopts
;
1587 tmp_mntopts
.mo_count
= 0;
1588 vfs_createopttbl_extend(&tmp_mntopts
, inargs
,
1590 vfs_parsemntopts(&tmp_mntopts
, inargs
, 1);
1591 vfs_swapopttbl_nolock(&mnt_mntopts
, &tmp_mntopts
);
1592 vfs_freeopttbl(&tmp_mntopts
);
1597 * Serialize with zone state transitions.
1598 * See vfs_list_add; zone mounted into is:
1599 * zone_find_by_path(refstr_value(vfsp->vfs_mntpt))
1600 * not the zone doing the mount (curproc->p_zone), but if we're already
1601 * inside a NGZ, then we know what zone we are.
1603 if (INGLOBALZONE(curproc
)) {
1604 zone
= zone_find_by_path(mountpt
);
1605 ASSERT(zone
!= NULL
);
1607 zone
= curproc
->p_zone
;
1609 * zone_find_by_path does a hold, so do one here too so that
1610 * we can do a zone_rele after mount_completed.
1614 mount_in_progress(zone
);
1616 * Instantiate (or reinstantiate) the file system. If appropriate,
1617 * splice it into the file system name space.
1619 * We want VFS_MOUNT() to be able to override the vfs_resource
1620 * string if necessary (ie, mntfs), and also for a remount to
1621 * change the same (necessary when remounting '/' during boot).
1622 * So we set up vfs_mntpt and vfs_resource to what we think they
1623 * should be, then hand off control to VFS_MOUNT() which can
1626 * For safety's sake, when changing vfs_resource or vfs_mntpt of
1627 * a vfs which is on the vfs list (i.e. during a remount), we must
1628 * never set those fields to NULL. Several bits of code make
1629 * assumptions that the fields are always valid.
1631 vfs_swapopttbl(&mnt_mntopts
, &vfsp
->vfs_mntopts
);
1633 if ((oldresource
= vfsp
->vfs_resource
) != NULL
)
1634 refstr_hold(oldresource
);
1635 if ((oldmntpt
= vfsp
->vfs_mntpt
) != NULL
)
1636 refstr_hold(oldmntpt
);
1638 vfs_setresource(vfsp
, resource
, 0);
1639 vfs_setmntpoint(vfsp
, mountpt
, 0);
1642 * going to mount on this vnode, so notify.
1644 vnevent_mountedover(vp
, NULL
);
1645 error
= VFS_MOUNT(vfsp
, vp
, uap
, credp
);
1647 if (uap
->flags
& MS_RDONLY
)
1648 vfs_setmntopt(vfsp
, MNTOPT_RO
, NULL
, 0);
1649 if (uap
->flags
& MS_NOSUID
)
1650 vfs_setmntopt(vfsp
, MNTOPT_NOSUID
, NULL
, 0);
1651 if (uap
->flags
& MS_GLOBAL
)
1652 vfs_setmntopt(vfsp
, MNTOPT_GLOBAL
, NULL
, 0);
1658 /* put back pre-remount options */
1659 vfs_swapopttbl(&mnt_mntopts
, &vfsp
->vfs_mntopts
);
1660 vfs_setmntpoint(vfsp
, refstr_value(oldmntpt
),
1663 refstr_rele(oldmntpt
);
1664 vfs_setresource(vfsp
, refstr_value(oldresource
),
1667 refstr_rele(oldresource
);
1668 vfsp
->vfs_flag
= ovflags
;
1673 vfs_freemnttab(vfsp
);
1678 * Set the mount time to now
1680 vfsp
->vfs_mtime
= ddi_get_time();
1682 vfsp
->vfs_flag
&= ~VFS_REMOUNT
;
1684 refstr_rele(oldresource
);
1686 refstr_rele(oldmntpt
);
1687 } else if (splice
) {
1689 * Link vfsp into the name space at the mount
1690 * point. Vfs_add() is responsible for
1691 * holding the mount point which will be
1692 * released when vfs_remove() is called.
1694 vfs_add(vp
, vfsp
, uap
->flags
);
1697 * Hold the reference to file system which is
1698 * not linked into the name space.
1700 vfsp
->vfs_zone
= NULL
;
1702 vfsp
->vfs_vnodecovered
= NULL
;
1705 * Set flags for global options encountered
1707 if (vfs_optionisset(vfsp
, MNTOPT_RO
, NULL
))
1708 vfsp
->vfs_flag
|= VFS_RDONLY
;
1710 vfsp
->vfs_flag
&= ~VFS_RDONLY
;
1711 if (vfs_optionisset(vfsp
, MNTOPT_NOSUID
, NULL
)) {
1712 vfsp
->vfs_flag
|= (VFS_NOSETUID
|VFS_NODEVICES
);
1714 if (vfs_optionisset(vfsp
, MNTOPT_NODEVICES
, NULL
))
1715 vfsp
->vfs_flag
|= VFS_NODEVICES
;
1717 vfsp
->vfs_flag
&= ~VFS_NODEVICES
;
1718 if (vfs_optionisset(vfsp
, MNTOPT_NOSETUID
, NULL
))
1719 vfsp
->vfs_flag
|= VFS_NOSETUID
;
1721 vfsp
->vfs_flag
&= ~VFS_NOSETUID
;
1723 if (vfs_optionisset(vfsp
, MNTOPT_NBMAND
, NULL
))
1724 vfsp
->vfs_flag
|= VFS_NBMAND
;
1726 vfsp
->vfs_flag
&= ~VFS_NBMAND
;
1728 if (vfs_optionisset(vfsp
, MNTOPT_XATTR
, NULL
))
1729 vfsp
->vfs_flag
|= VFS_XATTR
;
1731 vfsp
->vfs_flag
&= ~VFS_XATTR
;
1733 if (vfs_optionisset(vfsp
, MNTOPT_NOEXEC
, NULL
))
1734 vfsp
->vfs_flag
|= VFS_NOEXEC
;
1736 vfsp
->vfs_flag
&= ~VFS_NOEXEC
;
1739 * Now construct the output option string of options
1742 if (uap
->flags
& MS_OPTIONSTR
) {
1743 vfs_list_read_lock();
1744 copyout_error
= vfs_buildoptionstr(
1745 &vfsp
->vfs_mntopts
, inargs
, optlen
);
1747 if (copyout_error
== 0 &&
1748 (uap
->flags
& MS_SYSSPACE
) == 0) {
1749 copyout_error
= copyoutstr(inargs
, opts
,
1755 * If this isn't a remount, set up the vopstats before
1756 * anyone can touch this. We only allow spliced file
1757 * systems (file systems which are in the namespace) to
1758 * have the VFS_STATS flag set.
1759 * NOTE: PxFS mounts the underlying file system with
1760 * MS_NOSPLICE set and copies those vfs_flags to its private
1761 * vfs structure. As a result, PxFS should never have
1762 * the VFS_STATS flag or else we might access the vfs
1763 * statistics-related fields prior to them being
1764 * properly initialized.
1766 if (!remount
&& (vswp
->vsw_flag
& VSW_STATS
) && splice
) {
1767 initialize_vopstats(&vfsp
->vfs_vopstats
);
1769 * We need to set vfs_vskap to NULL because there's
1770 * a chance it won't be set below. This is checked
1771 * in teardown_vopstats() so we can't have garbage.
1773 vfsp
->vfs_vskap
= NULL
;
1774 vfsp
->vfs_flag
|= VFS_STATS
;
1775 vfsp
->vfs_fstypevsp
= get_fstype_vopstats(vfsp
, vswp
);
1778 if (vswp
->vsw_flag
& VSW_XID
)
1779 vfsp
->vfs_flag
|= VFS_XID
;
1783 mount_completed(zone
);
1788 if ((error
== 0) && (copyout_error
== 0)) {
1791 * Don't call get_vskstat_anchor() while holding
1792 * locks since it allocates memory and calls
1793 * VFS_STATVFS(). For NFS, the latter can generate
1794 * an over-the-wire call.
1796 vskap
= get_vskstat_anchor(vfsp
);
1797 /* Only take the lock if we have something to do */
1798 if (vskap
!= NULL
) {
1799 vfs_lock_wait(vfsp
);
1800 if (vfsp
->vfs_flag
& VFS_STATS
) {
1801 vfsp
->vfs_vskap
= vskap
;
1806 /* Return vfsp to caller. */
1810 vfs_freeopttbl(&mnt_mntopts
);
1811 if (resource
!= NULL
)
1812 kmem_free(resource
, strlen(resource
) + 1);
1813 if (mountpt
!= NULL
)
1814 kmem_free(mountpt
, strlen(mountpt
) + 1);
1816 * It is possible we errored prior to adding to mount in progress
1817 * table. Must free vnode we acquired with successful lookupname.
1823 ASSERT(vswp
!= NULL
);
1824 vfs_unrefvfssw(vswp
);
1826 kmem_free(inargs
, MAX_MNTOPT_STR
);
1827 if (copyout_error
) {
1830 error
= copyout_error
;
1837 struct vfs
*vfsp
, /* vfs being updated */
1838 refstr_t
**refp
, /* Ref-count string to contain the new path */
1839 const char *newpath
, /* Path to add to refp (above) */
1840 uint32_t flag
) /* flag */
1844 zone_t
*zone
= curproc
->p_zone
;
1846 int have_list_lock
= 0;
1848 ASSERT(!VFS_ON_LIST(vfsp
) || vfs_lock_held(vfsp
));
1851 * New path must be less than MAXPATHLEN because mntfs
1852 * will only display up to MAXPATHLEN bytes. This is currently
1853 * safe, because domount() uses pn_get(), and other callers
1854 * similarly cap the size to fewer than MAXPATHLEN bytes.
1857 ASSERT(strlen(newpath
) < MAXPATHLEN
);
1859 /* mntfs requires consistency while vfs list lock is held */
1861 if (VFS_ON_LIST(vfsp
)) {
1870 * If we are in a non-global zone then we prefix the supplied path,
1871 * newpath, with the zone's root path, with two exceptions. The first
1872 * is where we have been explicitly directed to avoid doing so; this
1873 * will be the case following a failed remount, where the path supplied
1874 * will be a saved version which must now be restored. The second
1875 * exception is where newpath is not a pathname but a descriptive name,
1878 if (zone
== global_zone
|| (flag
& VFSSP_VERBATIM
) || *newpath
!= '/') {
1879 ref
= refstr_alloc(newpath
);
1884 * Truncate the trailing '/' in the zoneroot, and merge
1885 * in the zone's rootpath with the "newpath" (resource
1886 * or mountpoint) passed in.
1888 * The size of the required buffer is thus the size of
1889 * the buffer required for the passed-in newpath
1890 * (strlen(newpath) + 1), plus the size of the buffer
1891 * required to hold zone_rootpath (zone_rootpathlen)
1892 * minus one for one of the now-superfluous NUL
1893 * terminations, minus one for the trailing '/'.
1897 * (strlen(newpath) + 1) + zone_rootpathlen - 1 - 1
1899 * Which is what we have below.
1902 len
= strlen(newpath
) + zone
->zone_rootpathlen
- 1;
1903 sp
= kmem_alloc(len
, KM_SLEEP
);
1906 * Copy everything including the trailing slash, which
1907 * we then overwrite with the NUL character.
1910 (void) strcpy(sp
, zone
->zone_rootpath
);
1911 sp
[zone
->zone_rootpathlen
- 2] = '\0';
1912 (void) strcat(sp
, newpath
);
1914 ref
= refstr_alloc(sp
);
1919 if (have_list_lock
) {
1920 vfs_mnttab_modtimeupd();
1926 * Record a mounted resource name in a vfs structure.
1927 * If vfsp is already mounted, caller must hold the vfs lock.
1930 vfs_setresource(struct vfs
*vfsp
, const char *resource
, uint32_t flag
)
1932 if (resource
== NULL
|| resource
[0] == '\0')
1933 resource
= VFS_NORESOURCE
;
1934 vfs_setpath(vfsp
, &vfsp
->vfs_resource
, resource
, flag
);
1938 * Record a mount point name in a vfs structure.
1939 * If vfsp is already mounted, caller must hold the vfs lock.
1942 vfs_setmntpoint(struct vfs
*vfsp
, const char *mntpt
, uint32_t flag
)
1944 if (mntpt
== NULL
|| mntpt
[0] == '\0')
1945 mntpt
= VFS_NOMNTPT
;
1946 vfs_setpath(vfsp
, &vfsp
->vfs_mntpt
, mntpt
, flag
);
1949 /* Returns the vfs_resource. Caller must call refstr_rele() when finished. */
1952 vfs_getresource(const struct vfs
*vfsp
)
1956 vfs_list_read_lock();
1957 resource
= vfsp
->vfs_resource
;
1958 refstr_hold(resource
);
1964 /* Returns the vfs_mntpt. Caller must call refstr_rele() when finished. */
1967 vfs_getmntpoint(const struct vfs
*vfsp
)
1971 vfs_list_read_lock();
1972 mntpt
= vfsp
->vfs_mntpt
;
1980 * Create an empty options table with enough empty slots to hold all
1981 * The options in the options string passed as an argument.
1982 * Potentially prepend another options table.
1984 * Note: caller is responsible for locking the vfs list, if needed,
1988 vfs_createopttbl_extend(mntopts_t
*mops
, const char *opts
,
1989 const mntopts_t
*mtmpl
)
1991 const char *s
= opts
;
1994 if (opts
== NULL
|| *opts
== '\0') {
2000 * Count number of options in the string
2002 for (s
= strchr(s
, ','); s
!= NULL
; s
= strchr(s
, ',')) {
2007 vfs_copyopttbl_extend(mtmpl
, mops
, count
);
2011 * Create an empty options table with enough empty slots to hold all
2012 * The options in the options string passed as an argument.
2014 * This function is *not* for general use by filesystems.
2016 * Note: caller is responsible for locking the vfs list, if needed,
2020 vfs_createopttbl(mntopts_t
*mops
, const char *opts
)
2022 vfs_createopttbl_extend(mops
, opts
, NULL
);
2027 * Swap two mount options tables
2030 vfs_swapopttbl_nolock(mntopts_t
*optbl1
, mntopts_t
*optbl2
)
2035 tmpcnt
= optbl2
->mo_count
;
2036 tmplist
= optbl2
->mo_list
;
2037 optbl2
->mo_count
= optbl1
->mo_count
;
2038 optbl2
->mo_list
= optbl1
->mo_list
;
2039 optbl1
->mo_count
= tmpcnt
;
2040 optbl1
->mo_list
= tmplist
;
2044 vfs_swapopttbl(mntopts_t
*optbl1
, mntopts_t
*optbl2
)
2047 vfs_swapopttbl_nolock(optbl1
, optbl2
);
2048 vfs_mnttab_modtimeupd();
2053 vfs_copycancelopt_extend(char **const moc
, int extend
)
2060 for (; moc
[i
] != NULL
; i
++)
2061 /* count number of options to cancel */;
2064 if (i
+ extend
== 0)
2067 result
= kmem_alloc((i
+ extend
+ 1) * sizeof (char *), KM_SLEEP
);
2069 for (j
= 0; j
< i
; j
++) {
2070 result
[j
] = kmem_alloc(strlen(moc
[j
]) + 1, KM_SLEEP
);
2071 (void) strcpy(result
[j
], moc
[j
]);
2073 for (; j
<= i
+ extend
; j
++)
2080 vfs_copyopt(const mntopt_t
*s
, mntopt_t
*d
)
2084 d
->mo_flags
= s
->mo_flags
;
2085 d
->mo_data
= s
->mo_data
;
2088 dp
= kmem_alloc(strlen(sp
) + 1, KM_SLEEP
);
2089 (void) strcpy(dp
, sp
);
2092 d
->mo_name
= NULL
; /* should never happen */
2095 d
->mo_cancel
= vfs_copycancelopt_extend(s
->mo_cancel
, 0);
2099 dp
= kmem_alloc(strlen(sp
) + 1, KM_SLEEP
);
2100 (void) strcpy(dp
, sp
);
2108 * Copy a mount options table, possibly allocating some spare
2109 * slots at the end. It is permissible to copy_extend the NULL table.
2112 vfs_copyopttbl_extend(const mntopts_t
*smo
, mntopts_t
*dmo
, int extra
)
2118 * Clear out any existing stuff in the options table being initialized
2120 vfs_freeopttbl(dmo
);
2121 count
= (smo
== NULL
) ? 0 : smo
->mo_count
;
2122 if ((count
+ extra
) == 0) /* nothing to do */
2124 dmo
->mo_count
= count
+ extra
;
2125 motbl
= kmem_zalloc((count
+ extra
) * sizeof (mntopt_t
), KM_SLEEP
);
2126 dmo
->mo_list
= motbl
;
2127 for (i
= 0; i
< count
; i
++) {
2128 vfs_copyopt(&smo
->mo_list
[i
], &motbl
[i
]);
2130 for (i
= count
; i
< count
+ extra
; i
++) {
2131 motbl
[i
].mo_flags
= MO_EMPTY
;
2136 * Copy a mount options table.
2138 * This function is *not* for general use by filesystems.
2140 * Note: caller is responsible for locking the vfs list, if needed,
2141 * to protect smo and dmo.
2144 vfs_copyopttbl(const mntopts_t
*smo
, mntopts_t
*dmo
)
2146 vfs_copyopttbl_extend(smo
, dmo
, 0);
2150 vfs_mergecancelopts(const mntopt_t
*mop1
, const mntopt_t
*mop2
)
2155 char **sp1
, **sp2
, **dp
;
2158 * First we count both lists of cancel options.
2159 * If either is NULL or has no elements, we return a copy of
2162 if (mop1
->mo_cancel
!= NULL
) {
2163 for (; mop1
->mo_cancel
[c1
] != NULL
; c1
++)
2164 /* count cancel options in mop1 */;
2168 return (vfs_copycancelopt_extend(mop2
->mo_cancel
, 0));
2170 if (mop2
->mo_cancel
!= NULL
) {
2171 for (; mop2
->mo_cancel
[c2
] != NULL
; c2
++)
2172 /* count cancel options in mop2 */;
2175 result
= vfs_copycancelopt_extend(mop1
->mo_cancel
, c2
);
2181 * When we get here, we've got two sets of cancel options;
2182 * we need to merge the two sets. We know that the result
2183 * array has "c1+c2+1" entries and in the end we might shrink
2185 * Result now has a copy of the c1 entries from mop1; we'll
2186 * now lookup all the entries of mop2 in mop1 and copy it if
2188 * This operation is O(n^2) but it's only called once per
2189 * filesystem per duplicate option. This is a situation
2190 * which doesn't arise with the filesystems in ON and
2195 for (sp2
= mop2
->mo_cancel
; *sp2
!= NULL
; sp2
++) {
2196 for (sp1
= mop1
->mo_cancel
; *sp1
!= NULL
; sp1
++) {
2197 if (strcmp(*sp1
, *sp2
) == 0)
2202 * Option *sp2 not found in mop1, so copy it.
2203 * The calls to vfs_copycancelopt_extend()
2204 * guarantee that there's enough room.
2206 *dp
= kmem_alloc(strlen(*sp2
) + 1, KM_SLEEP
);
2207 (void) strcpy(*dp
++, *sp2
);
2210 if (dp
!= &result
[c1
+c2
]) {
2211 size_t bytes
= (dp
- result
+ 1) * sizeof (char *);
2212 char **nres
= kmem_alloc(bytes
, KM_SLEEP
);
2214 bcopy(result
, nres
, bytes
);
2215 kmem_free(result
, (c1
+ c2
+ 1) * sizeof (char *));
2222 * Merge two mount option tables (outer and inner) into one. This is very
2223 * similar to "merging" global variables and automatic variables in C.
2225 * This isn't (and doesn't have to be) fast.
2227 * This function is *not* for general use by filesystems.
2229 * Note: caller is responsible for locking the vfs list, if needed,
2230 * to protect omo, imo & dmo.
2233 vfs_mergeopttbl(const mntopts_t
*omo
, const mntopts_t
*imo
, mntopts_t
*dmo
)
2236 mntopt_t
*mop
, *motbl
;
2240 * First determine how much space we need to allocate.
2242 count
= omo
->mo_count
;
2243 for (i
= 0; i
< imo
->mo_count
; i
++) {
2244 if (imo
->mo_list
[i
].mo_flags
& MO_EMPTY
)
2246 if (vfs_hasopt(omo
, imo
->mo_list
[i
].mo_name
) == NULL
)
2249 ASSERT(count
>= omo
->mo_count
&&
2250 count
<= omo
->mo_count
+ imo
->mo_count
);
2251 motbl
= kmem_alloc(count
* sizeof (mntopt_t
), KM_SLEEP
);
2252 for (i
= 0; i
< omo
->mo_count
; i
++)
2253 vfs_copyopt(&omo
->mo_list
[i
], &motbl
[i
]);
2254 freeidx
= omo
->mo_count
;
2255 for (i
= 0; i
< imo
->mo_count
; i
++) {
2256 if (imo
->mo_list
[i
].mo_flags
& MO_EMPTY
)
2258 if ((mop
= vfs_hasopt(omo
, imo
->mo_list
[i
].mo_name
)) != NULL
) {
2260 uint_t index
= mop
- omo
->mo_list
;
2262 newcanp
= vfs_mergecancelopts(mop
, &motbl
[index
]);
2264 vfs_freeopt(&motbl
[index
]);
2265 vfs_copyopt(&imo
->mo_list
[i
], &motbl
[index
]);
2267 vfs_freecancelopt(motbl
[index
].mo_cancel
);
2268 motbl
[index
].mo_cancel
= newcanp
;
2271 * If it's a new option, just copy it over to the first
2274 vfs_copyopt(&imo
->mo_list
[i
], &motbl
[freeidx
++]);
2277 dmo
->mo_count
= count
;
2278 dmo
->mo_list
= motbl
;
2282 * Functions to set and clear mount options in a mount options table.
2286 * Clear a mount option, if it exists.
2288 * The update_mnttab arg indicates whether mops is part of a vfs that is on
2292 vfs_clearmntopt_nolock(mntopts_t
*mops
, const char *opt
, int update_mnttab
)
2297 ASSERT(!update_mnttab
|| RW_WRITE_HELD(&vfslist
));
2299 count
= mops
->mo_count
;
2300 for (i
= 0; i
< count
; i
++) {
2301 mop
= &mops
->mo_list
[i
];
2303 if (mop
->mo_flags
& MO_EMPTY
)
2305 if (strcmp(opt
, mop
->mo_name
))
2307 mop
->mo_flags
&= ~MO_SET
;
2308 if (mop
->mo_arg
!= NULL
) {
2309 kmem_free(mop
->mo_arg
, strlen(mop
->mo_arg
) + 1);
2313 vfs_mnttab_modtimeupd();
2319 vfs_clearmntopt(struct vfs
*vfsp
, const char *opt
)
2323 if (VFS_ON_LIST(vfsp
)) {
2327 vfs_clearmntopt_nolock(&vfsp
->vfs_mntopts
, opt
, gotlock
);
2334 * Set a mount option on. If it's not found in the table, it's silently
2335 * ignored. If the option has MO_IGNORE set, it is still set unless the
2336 * VFS_NOFORCEOPT bit is set in the flags. Also, VFS_DISPLAY/VFS_NODISPLAY flag
2337 * bits can be used to toggle the MO_NODISPLAY bit for the option.
2338 * If the VFS_CREATEOPT flag bit is set then the first option slot with
2339 * MO_EMPTY set is created as the option passed in.
2341 * The update_mnttab arg indicates whether mops is part of a vfs that is on
2345 vfs_setmntopt_nolock(mntopts_t
*mops
, const char *opt
,
2346 const char *arg
, int flags
, int update_mnttab
)
2352 ASSERT(!update_mnttab
|| RW_WRITE_HELD(&vfslist
));
2354 if (flags
& VFS_CREATEOPT
) {
2355 if (vfs_hasopt(mops
, opt
) != NULL
) {
2356 flags
&= ~VFS_CREATEOPT
;
2359 count
= mops
->mo_count
;
2360 for (i
= 0; i
< count
; i
++) {
2361 mop
= &mops
->mo_list
[i
];
2363 if (mop
->mo_flags
& MO_EMPTY
) {
2364 if ((flags
& VFS_CREATEOPT
) == 0)
2366 sp
= kmem_alloc(strlen(opt
) + 1, KM_SLEEP
);
2367 (void) strcpy(sp
, opt
);
2370 mop
->mo_flags
= MO_HASVALUE
;
2373 } else if (strcmp(opt
, mop
->mo_name
)) {
2376 if ((mop
->mo_flags
& MO_IGNORE
) && (flags
& VFS_NOFORCEOPT
))
2378 if (arg
!= NULL
&& (mop
->mo_flags
& MO_HASVALUE
) != 0) {
2379 sp
= kmem_alloc(strlen(arg
) + 1, KM_SLEEP
);
2380 (void) strcpy(sp
, arg
);
2384 if (mop
->mo_arg
!= NULL
)
2385 kmem_free(mop
->mo_arg
, strlen(mop
->mo_arg
) + 1);
2387 if (flags
& VFS_DISPLAY
)
2388 mop
->mo_flags
&= ~MO_NODISPLAY
;
2389 if (flags
& VFS_NODISPLAY
)
2390 mop
->mo_flags
|= MO_NODISPLAY
;
2391 mop
->mo_flags
|= MO_SET
;
2392 if (mop
->mo_cancel
!= NULL
) {
2395 for (cp
= mop
->mo_cancel
; *cp
!= NULL
; cp
++)
2396 vfs_clearmntopt_nolock(mops
, *cp
, 0);
2399 vfs_mnttab_modtimeupd();
2405 vfs_setmntopt(struct vfs
*vfsp
, const char *opt
, const char *arg
, int flags
)
2409 if (VFS_ON_LIST(vfsp
)) {
2413 vfs_setmntopt_nolock(&vfsp
->vfs_mntopts
, opt
, arg
, flags
, gotlock
);
2420 * Add a "tag" option to a mounted file system's options list.
2422 * Note: caller is responsible for locking the vfs list, if needed,
2426 vfs_addtag(mntopts_t
*mops
, const char *tag
)
2429 mntopt_t
*mop
, *motbl
;
2431 count
= mops
->mo_count
+ 1;
2432 motbl
= kmem_zalloc(count
* sizeof (mntopt_t
), KM_SLEEP
);
2433 if (mops
->mo_count
) {
2434 size_t len
= (count
- 1) * sizeof (mntopt_t
);
2436 bcopy(mops
->mo_list
, motbl
, len
);
2437 kmem_free(mops
->mo_list
, len
);
2439 mops
->mo_count
= count
;
2440 mops
->mo_list
= motbl
;
2441 mop
= &motbl
[count
- 1];
2442 mop
->mo_flags
= MO_TAG
;
2443 mop
->mo_name
= kmem_alloc(strlen(tag
) + 1, KM_SLEEP
);
2444 (void) strcpy(mop
->mo_name
, tag
);
2449 * Allow users to set arbitrary "tags" in a vfs's mount options.
2450 * Broader use within the kernel is discouraged.
2453 vfs_settag(uint_t major
, uint_t minor
, const char *mntpt
, const char *tag
,
2460 dev_t dev
= makedevice(major
, minor
);
2462 char *buf
= kmem_alloc(MAX_MNTOPT_STR
, KM_SLEEP
);
2465 * Find the desired mounted file system
2470 if (vfsp
->vfs_dev
== dev
&&
2471 strcmp(mntpt
, refstr_value(vfsp
->vfs_mntpt
)) == 0) {
2475 vfsp
= vfsp
->vfs_next
;
2476 } while (vfsp
!= rootvfs
);
2482 err
= secpolicy_fs_config(cr
, vfsp
);
2486 mops
= &vfsp
->vfs_mntopts
;
2488 * Add tag if it doesn't already exist
2490 if ((mop
= vfs_hasopt(mops
, tag
)) == NULL
) {
2493 (void) vfs_buildoptionstr(mops
, buf
, MAX_MNTOPT_STR
);
2495 if (len
+ strlen(tag
) + 2 > MAX_MNTOPT_STR
) {
2499 mop
= vfs_addtag(mops
, tag
);
2501 if ((mop
->mo_flags
& MO_TAG
) == 0) {
2505 vfs_setmntopt_nolock(mops
, tag
, NULL
, 0, 1);
2508 kmem_free(buf
, MAX_MNTOPT_STR
);
2513 * Allow users to remove arbitrary "tags" in a vfs's mount options.
2514 * Broader use within the kernel is discouraged.
2517 vfs_clrtag(uint_t major
, uint_t minor
, const char *mntpt
, const char *tag
,
2523 dev_t dev
= makedevice(major
, minor
);
2527 * Find the desired mounted file system
2532 if (vfsp
->vfs_dev
== dev
&&
2533 strcmp(mntpt
, refstr_value(vfsp
->vfs_mntpt
)) == 0) {
2537 vfsp
= vfsp
->vfs_next
;
2538 } while (vfsp
!= rootvfs
);
2544 err
= secpolicy_fs_config(cr
, vfsp
);
2548 if ((mop
= vfs_hasopt(&vfsp
->vfs_mntopts
, tag
)) == NULL
) {
2552 if ((mop
->mo_flags
& MO_TAG
) == 0) {
2556 vfs_clearmntopt_nolock(&vfsp
->vfs_mntopts
, tag
, 1);
2563 * Function to parse an option string and fill in a mount options table.
2564 * Unknown options are silently ignored. The input option string is modified
2565 * by replacing separators with nulls. If the create flag is set, options
2566 * not found in the table are just added on the fly. The table must have
2567 * an option slot marked MO_EMPTY to add an option on the fly.
2569 * This function is *not* for general use by filesystems.
2571 * Note: caller is responsible for locking the vfs list, if needed,
2575 vfs_parsemntopts(mntopts_t
*mops
, char *osp
, int create
)
2577 char *s
= osp
, *p
, *nextop
, *valp
, *cp
, *ep
;
2578 int setflg
= VFS_NOFORCEOPT
;
2582 while (*s
!= '\0') {
2583 p
= strchr(s
, ','); /* find next option */
2588 cp
= p
; /* save location of comma */
2589 *p
++ = '\0'; /* mark end and point to next option */
2592 p
= strchr(s
, '='); /* look for value */
2594 valp
= NULL
; /* no value supplied */
2596 ep
= p
; /* save location of equals */
2597 *p
++ = '\0'; /* end option and point to value */
2601 * set option into options table
2604 setflg
|= VFS_CREATEOPT
;
2605 vfs_setmntopt_nolock(mops
, s
, valp
, setflg
, 0);
2607 *cp
= ','; /* restore the comma */
2609 *ep
= '='; /* restore the equals */
2615 * Function to inquire if an option exists in a mount options table.
2616 * Returns a pointer to the option if it exists, else NULL.
2618 * This function is *not* for general use by filesystems.
2620 * Note: caller is responsible for locking the vfs list, if needed,
2624 vfs_hasopt(const mntopts_t
*mops
, const char *opt
)
2629 count
= mops
->mo_count
;
2630 for (i
= 0; i
< count
; i
++) {
2631 mop
= &mops
->mo_list
[i
];
2633 if (mop
->mo_flags
& MO_EMPTY
)
2635 if (strcmp(opt
, mop
->mo_name
) == 0)
2642 * Function to inquire if an option is set in a mount options table.
2643 * Returns non-zero if set and fills in the arg pointer with a pointer to
2644 * the argument string or NULL if there is no argument string.
2647 vfs_optionisset_nolock(const mntopts_t
*mops
, const char *opt
, char **argp
)
2652 count
= mops
->mo_count
;
2653 for (i
= 0; i
< count
; i
++) {
2654 mop
= &mops
->mo_list
[i
];
2656 if (mop
->mo_flags
& MO_EMPTY
)
2658 if (strcmp(opt
, mop
->mo_name
))
2660 if ((mop
->mo_flags
& MO_SET
) == 0)
2662 if (argp
!= NULL
&& (mop
->mo_flags
& MO_HASVALUE
) != 0)
2663 *argp
= mop
->mo_arg
;
2671 vfs_optionisset(const struct vfs
*vfsp
, const char *opt
, char **argp
)
2675 vfs_list_read_lock();
2676 ret
= vfs_optionisset_nolock(&vfsp
->vfs_mntopts
, opt
, argp
);
2683 * Construct a comma separated string of the options set in the given
2684 * mount table, return the string in the given buffer. Return non-zero if
2685 * the buffer would overflow.
2687 * This function is *not* for general use by filesystems.
2689 * Note: caller is responsible for locking the vfs list, if needed,
2693 vfs_buildoptionstr(const mntopts_t
*mp
, char *buf
, int len
)
2700 for (i
= 0; i
< mp
->mo_count
; i
++) {
2703 mop
= &mp
->mo_list
[i
];
2704 if (mop
->mo_flags
& MO_SET
) {
2705 int optlen
, comma
= 0;
2709 optlen
= strlen(mop
->mo_name
);
2710 if (strlen(buf
) + comma
+ optlen
+ 1 > len
)
2714 (void) strcpy(cp
, mop
->mo_name
);
2717 * Append option value if there is one
2719 if (mop
->mo_arg
!= NULL
) {
2722 arglen
= strlen(mop
->mo_arg
);
2723 if (strlen(buf
) + arglen
+ 2 > len
)
2726 (void) strcpy(cp
, mop
->mo_arg
);
2737 vfs_freecancelopt(char **moc
)
2743 for (cp
= moc
; *cp
!= NULL
; cp
++) {
2744 kmem_free(*cp
, strlen(*cp
) + 1);
2747 kmem_free(moc
, (ccnt
+ 1) * sizeof (char *));
2752 vfs_freeopt(mntopt_t
*mop
)
2754 if (mop
->mo_name
!= NULL
)
2755 kmem_free(mop
->mo_name
, strlen(mop
->mo_name
) + 1);
2757 vfs_freecancelopt(mop
->mo_cancel
);
2759 if (mop
->mo_arg
!= NULL
)
2760 kmem_free(mop
->mo_arg
, strlen(mop
->mo_arg
) + 1);
2764 * Free a mount options table
2766 * This function is *not* for general use by filesystems.
2768 * Note: caller is responsible for locking the vfs list, if needed,
2772 vfs_freeopttbl(mntopts_t
*mp
)
2776 count
= mp
->mo_count
;
2777 for (i
= 0; i
< count
; i
++) {
2778 vfs_freeopt(&mp
->mo_list
[i
]);
2781 kmem_free(mp
->mo_list
, sizeof (mntopt_t
) * count
);
2790 vfs_mntdummyread(vnode_t
*vp
, uio_t
*uio
, int ioflag
, cred_t
*cred
,
2791 caller_context_t
*ct
)
2798 vfs_mntdummywrite(vnode_t
*vp
, uio_t
*uio
, int ioflag
, cred_t
*cred
,
2799 caller_context_t
*ct
)
2805 * The dummy vnode is currently used only by file events notification
2806 * module which is just interested in the timestamps.
2810 vfs_mntdummygetattr(vnode_t
*vp
, vattr_t
*vap
, int flags
, cred_t
*cr
,
2811 caller_context_t
*ct
)
2813 bzero(vap
, sizeof (vattr_t
));
2814 vap
->va_type
= VREG
;
2816 vap
->va_ctime
= vfs_mnttab_ctime
;
2818 * it is ok to just copy mtime as the time will be monotonically
2821 vap
->va_mtime
= vfs_mnttab_mtime
;
2822 vap
->va_atime
= vap
->va_mtime
;
2827 vfs_mnttabvp_setup(void)
2830 vnodeops_t
*vfs_mntdummyvnops
;
2831 const fs_operation_def_t mnt_dummyvnodeops_template
[] = {
2832 VOPNAME_READ
, { .vop_read
= vfs_mntdummyread
},
2833 VOPNAME_WRITE
, { .vop_write
= vfs_mntdummywrite
},
2834 VOPNAME_GETATTR
, { .vop_getattr
= vfs_mntdummygetattr
},
2835 VOPNAME_VNEVENT
, { .vop_vnevent
= fs_vnevent_support
},
2839 if (vn_make_ops("mnttab", mnt_dummyvnodeops_template
,
2840 &vfs_mntdummyvnops
) != 0) {
2841 cmn_err(CE_WARN
, "vfs_mnttabvp_setup: vn_make_ops failed");
2842 /* Shouldn't happen, but not bad enough to panic */
2847 * A global dummy vnode is allocated to represent mntfs files.
2848 * The mntfs file (/etc/mnttab) can be monitored for file events
2849 * and receive an event when mnttab changes. Dummy VOP calls
2850 * will be made on this vnode. The file events notification module
2851 * intercepts this vnode and delivers relevant events.
2853 tvp
= vn_alloc(KM_SLEEP
);
2854 tvp
->v_flag
= VNOMOUNT
|VNOMAP
|VNOSWAP
|VNOCACHE
;
2855 vn_setops(tvp
, vfs_mntdummyvnops
);
2858 * The mnt dummy ops do not reference v_data.
2859 * No other module intercepting this vnode should either.
2860 * Just set it to point to itself.
2862 tvp
->v_data
= (caddr_t
)tvp
;
2863 tvp
->v_vfsp
= rootvfs
;
2864 vfs_mntdummyvp
= tvp
;
2868 * performs fake read/write ops
2871 vfs_mnttab_rwop(int rw
)
2877 if (vfs_mntdummyvp
== NULL
)
2880 bzero(&uio
, sizeof (uio
));
2881 bzero(&iov
, sizeof (iov
));
2886 uio
.uio_loffset
= 0;
2887 uio
.uio_segflg
= UIO_SYSSPACE
;
2890 (void) VOP_WRITE(vfs_mntdummyvp
, &uio
, 0, kcred
, NULL
);
2892 (void) VOP_READ(vfs_mntdummyvp
, &uio
, 0, kcred
, NULL
);
2897 * Generate a write operation.
2900 vfs_mnttab_writeop(void)
2906 * Generate a read operation.
2909 vfs_mnttab_readop(void)
2915 * Free any mnttab information recorded in the vfs struct.
2916 * The vfs must not be on the vfs list.
2919 vfs_freemnttab(struct vfs
*vfsp
)
2921 ASSERT(!VFS_ON_LIST(vfsp
));
2924 * Free device and mount point information
2926 if (vfsp
->vfs_mntpt
!= NULL
) {
2927 refstr_rele(vfsp
->vfs_mntpt
);
2928 vfsp
->vfs_mntpt
= NULL
;
2930 if (vfsp
->vfs_resource
!= NULL
) {
2931 refstr_rele(vfsp
->vfs_resource
);
2932 vfsp
->vfs_resource
= NULL
;
2935 * Now free mount options information
2937 vfs_freeopttbl(&vfsp
->vfs_mntopts
);
2941 * Return the last mnttab modification time
2944 vfs_mnttab_modtime(timespec_t
*ts
)
2946 ASSERT(RW_LOCK_HELD(&vfslist
));
2947 *ts
= vfs_mnttab_mtime
;
2951 * See if mnttab is changed
2954 vfs_mnttab_poll(timespec_t
*old
, struct pollhead
**phpp
)
2958 *phpp
= (struct pollhead
*)NULL
;
2961 * Note: don't grab vfs list lock before accessing vfs_mnttab_mtime.
2962 * Can lead to deadlock against vfs_mnttab_modtimeupd(). It is safe
2963 * to not grab the vfs list lock because tv_sec is monotonically
2967 changed
= (old
->tv_nsec
!= vfs_mnttab_mtime
.tv_nsec
) ||
2968 (old
->tv_sec
!= vfs_mnttab_mtime
.tv_sec
);
2970 *phpp
= &vfs_pollhd
;
2974 /* Provide a unique and monotonically-increasing timestamp. */
2976 vfs_mono_time(timespec_t
*ts
)
2978 static volatile hrtime_t hrt
; /* The saved time. */
2979 hrtime_t newhrt
, oldhrt
; /* For effecting the CAS. */
2983 * Try gethrestime() first, but be prepared to fabricate a sensible
2984 * answer at the first sign of any trouble.
2986 gethrestime(&newts
);
2987 newhrt
= ts2hrt(&newts
);
2992 if (atomic_cas_64((uint64_t *)&hrt
, oldhrt
, newhrt
) == oldhrt
)
2999 * Update the mnttab modification time and wake up any waiters for
3003 vfs_mnttab_modtimeupd()
3005 hrtime_t oldhrt
, newhrt
;
3007 ASSERT(RW_WRITE_HELD(&vfslist
));
3008 oldhrt
= ts2hrt(&vfs_mnttab_mtime
);
3009 gethrestime(&vfs_mnttab_mtime
);
3010 newhrt
= ts2hrt(&vfs_mnttab_mtime
);
3011 if (oldhrt
== (hrtime_t
)0)
3012 vfs_mnttab_ctime
= vfs_mnttab_mtime
;
3014 * Attempt to provide unique mtime (like uniqtime but not).
3016 if (newhrt
== oldhrt
) {
3018 hrt2ts(newhrt
, &vfs_mnttab_mtime
);
3020 pollwakeup(&vfs_pollhd
, (short)POLLRDBAND
);
3021 vfs_mnttab_writeop();
3025 dounmount(struct vfs
*vfsp
, int flag
, cred_t
*cr
)
3029 extern void teardown_vopstats(vfs_t
*);
3032 * Get covered vnode. This will be NULL if the vfs is not linked
3033 * into the file system name space (i.e., domount() with MNT_NOSPICE).
3035 coveredvp
= vfsp
->vfs_vnodecovered
;
3036 ASSERT(coveredvp
== NULL
|| vn_vfswlock_held(coveredvp
));
3039 * Purge all dnlc entries for this vfs.
3041 (void) dnlc_purge_vfsp(vfsp
, 0);
3043 /* For forcible umount, skip VFS_SYNC() since it may hang */
3044 if ((flag
& MS_FORCE
) == 0)
3045 (void) VFS_SYNC(vfsp
, 0, cr
);
3048 * Lock the vfs to maintain fs status quo during unmount. This
3049 * has to be done after the sync because ufs_update tries to acquire
3052 vfs_lock_wait(vfsp
);
3054 if (error
= VFS_UNMOUNT(vfsp
, flag
, cr
)) {
3056 if (coveredvp
!= NULL
)
3057 vn_vfsunlock(coveredvp
);
3058 } else if (coveredvp
!= NULL
) {
3059 teardown_vopstats(vfsp
);
3061 * vfs_remove() will do a VN_RELE(vfsp->vfs_vnodecovered)
3062 * when it frees vfsp so we do a VN_HOLD() so we can
3063 * continue to use coveredvp afterwards.
3067 vn_vfsunlock(coveredvp
);
3070 teardown_vopstats(vfsp
);
3072 * Release the reference to vfs that is not linked
3073 * into the name space.
3083 * Vfs_unmountall() is called by uadmin() to unmount all
3084 * mounted file systems (except the root file system) during shutdown.
3085 * It follows the existing locking protocol when traversing the vfs list
3086 * to sync and unmount vfses. Even though there should be no
3087 * other thread running while the system is shutting down, it is prudent
3088 * to still follow the locking protocol.
3091 vfs_unmountall(void)
3094 struct vfs
*prev_vfsp
= NULL
;
3098 * Toss all dnlc entries now so that the per-vfs sync
3099 * and unmount operations don't have to slog through
3100 * a bunch of uninteresting vnodes over and over again.
3105 for (vfsp
= rootvfs
->vfs_prev
; vfsp
!= rootvfs
; vfsp
= prev_vfsp
) {
3106 prev_vfsp
= vfsp
->vfs_prev
;
3108 if (vfs_lock(vfsp
) != 0)
3110 error
= vn_vfswlock(vfsp
->vfs_vnodecovered
);
3117 (void) VFS_SYNC(vfsp
, SYNC_CLOSE
, CRED());
3118 (void) dounmount(vfsp
, 0, CRED());
3121 * Since we dropped the vfslist lock above we must
3122 * verify that next_vfsp still exists, else start over.
3125 for (vfsp
= rootvfs
->vfs_prev
;
3126 vfsp
!= rootvfs
; vfsp
= vfsp
->vfs_prev
)
3127 if (vfsp
== prev_vfsp
)
3129 if (vfsp
== rootvfs
&& prev_vfsp
!= rootvfs
)
3130 prev_vfsp
= rootvfs
->vfs_prev
;
3136 * Called to add an entry to the end of the vfs mount in progress list
3139 vfs_addmip(dev_t dev
, struct vfs
*vfsp
)
3143 mipp
= (struct ipmnt
*)kmem_alloc(sizeof (struct ipmnt
), KM_SLEEP
);
3144 mipp
->mip_next
= NULL
;
3145 mipp
->mip_dev
= dev
;
3146 mipp
->mip_vfsp
= vfsp
;
3147 mutex_enter(&vfs_miplist_mutex
);
3148 if (vfs_miplist_end
!= NULL
)
3149 vfs_miplist_end
->mip_next
= mipp
;
3152 vfs_miplist_end
= mipp
;
3153 mutex_exit(&vfs_miplist_mutex
);
3157 * Called to remove an entry from the mount in progress list
3158 * Either because the mount completed or it failed.
3161 vfs_delmip(struct vfs
*vfsp
)
3163 struct ipmnt
*mipp
, *mipprev
;
3165 mutex_enter(&vfs_miplist_mutex
);
3167 for (mipp
= vfs_miplist
;
3168 mipp
&& mipp
->mip_vfsp
!= vfsp
; mipp
= mipp
->mip_next
) {
3172 return; /* shouldn't happen */
3173 if (mipp
== vfs_miplist_end
)
3174 vfs_miplist_end
= mipprev
;
3175 if (mipprev
== NULL
)
3176 vfs_miplist
= mipp
->mip_next
;
3178 mipprev
->mip_next
= mipp
->mip_next
;
3179 mutex_exit(&vfs_miplist_mutex
);
3180 kmem_free(mipp
, sizeof (struct ipmnt
));
3184 * vfs_add is called by a specific filesystem's mount routine to add
3185 * the new vfs into the vfs list/hash and to cover the mounted-on vnode.
3186 * The vfs should already have been locked by the caller.
3188 * coveredvp is NULL if this is the root.
3191 vfs_add(vnode_t
*coveredvp
, struct vfs
*vfsp
, int mflag
)
3195 ASSERT(vfs_lock_held(vfsp
));
3197 newflag
= vfsp
->vfs_flag
;
3198 if (mflag
& MS_RDONLY
)
3199 newflag
|= VFS_RDONLY
;
3201 newflag
&= ~VFS_RDONLY
;
3202 if (mflag
& MS_NOSUID
)
3203 newflag
|= (VFS_NOSETUID
|VFS_NODEVICES
);
3205 newflag
&= ~(VFS_NOSETUID
|VFS_NODEVICES
);
3206 if (mflag
& MS_NOMNTTAB
)
3207 newflag
|= VFS_NOMNTTAB
;
3209 newflag
&= ~VFS_NOMNTTAB
;
3211 if (coveredvp
!= NULL
) {
3212 ASSERT(vn_vfswlock_held(coveredvp
));
3213 coveredvp
->v_vfsmountedhere
= vfsp
;
3216 vfsp
->vfs_vnodecovered
= coveredvp
;
3217 vfsp
->vfs_flag
= newflag
;
3223 * Remove a vfs from the vfs list, null out the pointer from the
3224 * covered vnode to the vfs (v_vfsmountedhere), and null out the pointer
3225 * from the vfs to the covered vnode (vfs_vnodecovered). Release the
3226 * reference to the vfs and to the covered vnode.
3228 * Called from dounmount after it's confirmed with the file system
3229 * that the unmount is legal.
3232 vfs_remove(struct vfs
*vfsp
)
3236 ASSERT(vfs_lock_held(vfsp
));
3239 * Can't unmount root. Should never happen because fs will
3242 if (vfsp
== rootvfs
)
3243 panic("vfs_remove: unmounting root");
3245 vfs_list_remove(vfsp
);
3248 * Unhook from the file system name space.
3250 vp
= vfsp
->vfs_vnodecovered
;
3251 ASSERT(vn_vfswlock_held(vp
));
3252 vp
->v_vfsmountedhere
= NULL
;
3253 vfsp
->vfs_vnodecovered
= NULL
;
3257 * Release lock and wakeup anybody waiting.
3264 * Lock a filesystem to prevent access to it while mounting,
3265 * unmounting and syncing. Return EBUSY immediately if lock
3266 * can't be acquired.
3269 vfs_lock(vfs_t
*vfsp
)
3271 vn_vfslocks_entry_t
*vpvfsentry
;
3273 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3274 if (rwst_tryenter(&vpvfsentry
->ve_lock
, RW_WRITER
))
3277 vn_vfslocks_rele(vpvfsentry
);
3282 vfs_rlock(vfs_t
*vfsp
)
3284 vn_vfslocks_entry_t
*vpvfsentry
;
3286 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3288 if (rwst_tryenter(&vpvfsentry
->ve_lock
, RW_READER
))
3291 vn_vfslocks_rele(vpvfsentry
);
3296 vfs_lock_wait(vfs_t
*vfsp
)
3298 vn_vfslocks_entry_t
*vpvfsentry
;
3300 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3301 rwst_enter(&vpvfsentry
->ve_lock
, RW_WRITER
);
3305 vfs_rlock_wait(vfs_t
*vfsp
)
3307 vn_vfslocks_entry_t
*vpvfsentry
;
3309 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3310 rwst_enter(&vpvfsentry
->ve_lock
, RW_READER
);
3314 * Unlock a locked filesystem.
3317 vfs_unlock(vfs_t
*vfsp
)
3319 vn_vfslocks_entry_t
*vpvfsentry
;
3322 * vfs_unlock will mimic sema_v behaviour to fix 4748018.
3323 * And these changes should remain for the patch changes as it is.
3329 * ve_refcount needs to be dropped twice here.
3330 * 1. To release refernce after a call to vfs_locks_getlock()
3331 * 2. To release the reference from the locking routines like
3332 * vfs_rlock_wait/vfs_wlock_wait/vfs_wlock etc,.
3335 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3336 vn_vfslocks_rele(vpvfsentry
);
3338 rwst_exit(&vpvfsentry
->ve_lock
);
3339 vn_vfslocks_rele(vpvfsentry
);
3343 * Utility routine that allows a filesystem to construct its
3344 * fsid in "the usual way" - by munging some underlying dev_t and
3345 * the filesystem type number into the 64-bit fsid. Note that
3346 * this implicitly relies on dev_t persistence to make filesystem
3349 * There's nothing to prevent an individual fs from constructing its
3350 * fsid in a different way, and indeed they should.
3352 * Since we want fsids to be 32-bit quantities (so that they can be
3353 * exported identically by either 32-bit or 64-bit APIs, as well as
3354 * the fact that fsid's are "known" to NFS), we compress the device
3355 * number given down to 32-bits, and panic if that isn't possible.
3358 vfs_make_fsid(fsid_t
*fsi
, dev_t dev
, int val
)
3360 if (!cmpldev((dev32_t
*)&fsi
->val
[0], dev
))
3361 panic("device number too big for fsid!");
3366 vfs_lock_held(vfs_t
*vfsp
)
3369 vn_vfslocks_entry_t
*vpvfsentry
;
3372 * vfs_lock_held will mimic sema_held behaviour
3373 * if panicstr is set. And these changes should remain
3374 * for the patch changes as it is.
3379 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3380 held
= rwst_lock_held(&vpvfsentry
->ve_lock
, RW_WRITER
);
3382 vn_vfslocks_rele(vpvfsentry
);
3387 vfs_lock_owner(vfs_t
*vfsp
)
3389 struct _kthread
*owner
;
3390 vn_vfslocks_entry_t
*vpvfsentry
;
3393 * vfs_wlock_held will mimic sema_held behaviour
3394 * if panicstr is set. And these changes should remain
3395 * for the patch changes as it is.
3400 vpvfsentry
= vn_vfslocks_getlock(vfsp
);
3401 owner
= rwst_owner(&vpvfsentry
->ve_lock
);
3403 vn_vfslocks_rele(vpvfsentry
);
3410 * Rather than manipulate the vfslist lock directly, we abstract into lock
3411 * and unlock routines to allow the locking implementation to be changed for
3414 * Whenever the vfs list is modified through its hash links, the overall list
3415 * lock must be obtained before locking the relevant hash bucket. But to see
3416 * whether a given vfs is on the list, it suffices to obtain the lock for the
3417 * hash bucket without getting the overall list lock. (See getvfs() below.)
3423 rw_enter(&vfslist
, RW_WRITER
);
3427 vfs_list_read_lock()
3429 rw_enter(&vfslist
, RW_READER
);
3439 * Low level worker routines for adding entries to and removing entries from
3444 vfs_hash_add(struct vfs
*vfsp
, int insert_at_head
)
3450 ASSERT(RW_WRITE_HELD(&vfslist
));
3452 dev
= expldev(vfsp
->vfs_fsid
.val
[0]);
3453 vhno
= VFSHASH(getmajor(dev
), getminor(dev
));
3455 mutex_enter(&rvfs_list
[vhno
].rvfs_lock
);
3458 * Link into the hash table, inserting it at the end, so that LOFS
3459 * with the same fsid as UFS (or other) file systems will not hide the
3462 if (insert_at_head
) {
3463 vfsp
->vfs_hash
= rvfs_list
[vhno
].rvfs_head
;
3464 rvfs_list
[vhno
].rvfs_head
= vfsp
;
3466 for (hp
= &rvfs_list
[vhno
].rvfs_head
; *hp
!= NULL
;
3467 hp
= &(*hp
)->vfs_hash
)
3470 * hp now contains the address of the pointer to update
3471 * to effect the insertion.
3473 vfsp
->vfs_hash
= NULL
;
3477 rvfs_list
[vhno
].rvfs_len
++;
3478 mutex_exit(&rvfs_list
[vhno
].rvfs_lock
);
3483 vfs_hash_remove(struct vfs
*vfsp
)
3489 ASSERT(RW_WRITE_HELD(&vfslist
));
3491 dev
= expldev(vfsp
->vfs_fsid
.val
[0]);
3492 vhno
= VFSHASH(getmajor(dev
), getminor(dev
));
3494 mutex_enter(&rvfs_list
[vhno
].rvfs_lock
);
3499 if (rvfs_list
[vhno
].rvfs_head
== vfsp
) {
3500 rvfs_list
[vhno
].rvfs_head
= vfsp
->vfs_hash
;
3501 rvfs_list
[vhno
].rvfs_len
--;
3504 for (tvfsp
= rvfs_list
[vhno
].rvfs_head
; tvfsp
!= NULL
;
3505 tvfsp
= tvfsp
->vfs_hash
) {
3506 if (tvfsp
->vfs_hash
== vfsp
) {
3507 tvfsp
->vfs_hash
= vfsp
->vfs_hash
;
3508 rvfs_list
[vhno
].rvfs_len
--;
3512 cmn_err(CE_WARN
, "vfs_list_remove: vfs not found in hash");
3516 mutex_exit(&rvfs_list
[vhno
].rvfs_lock
);
3521 vfs_list_add(struct vfs
*vfsp
)
3526 * Typically, the vfs_t will have been created on behalf of the file
3527 * system in vfs_init, where it will have been provided with a
3528 * vfs_impl_t. This, however, might be lacking if the vfs_t was created
3529 * by an unbundled file system. We therefore check for such an example
3530 * before stamping the vfs_t with its creation time for the benefit of
3533 if (vfsp
->vfs_implp
== NULL
)
3534 vfsimpl_setup(vfsp
);
3535 vfs_mono_time(&vfsp
->vfs_hrctime
);
3538 * The zone that owns the mount is the one that performed the mount.
3539 * Note that this isn't necessarily the same as the zone mounted into.
3540 * The corresponding zone_rele_ref() will be done when the vfs_t
3543 vfsp
->vfs_zone
= curproc
->p_zone
;
3544 zone_init_ref(&vfsp
->vfs_implp
->vi_zone_ref
);
3545 zone_hold_ref(vfsp
->vfs_zone
, &vfsp
->vfs_implp
->vi_zone_ref
,
3549 * Find the zone mounted into, and put this mount on its vfs list.
3551 zone
= zone_find_by_path(refstr_value(vfsp
->vfs_mntpt
));
3552 ASSERT(zone
!= NULL
);
3554 * Special casing for the root vfs. This structure is allocated
3555 * statically and hooked onto rootvfs at link time. During the
3556 * vfs_mountroot call at system startup time, the root file system's
3557 * VFS_MOUNTROOT routine will call vfs_add with this root vfs struct
3558 * as argument. The code below must detect and handle this special
3559 * case. The only apparent justification for this special casing is
3560 * to ensure that the root file system appears at the head of the
3563 * XXX: I'm assuming that it's ok to do normal list locking when
3564 * adding the entry for the root file system (this used to be
3565 * done with no locks held).
3569 * Link into the vfs list proper.
3571 if (vfsp
== &root
) {
3573 * Assert: This vfs is already on the list as its first entry.
3574 * Thus, there's nothing to do.
3576 ASSERT(rootvfs
== vfsp
);
3578 * Add it to the head of the global zone's vfslist.
3580 ASSERT(zone
== global_zone
);
3581 ASSERT(zone
->zone_vfslist
== NULL
);
3582 zone
->zone_vfslist
= vfsp
;
3585 * Link to end of list using vfs_prev (as rootvfs is now a
3586 * doubly linked circular list) so list is in mount order for
3589 rootvfs
->vfs_prev
->vfs_next
= vfsp
;
3590 vfsp
->vfs_prev
= rootvfs
->vfs_prev
;
3591 rootvfs
->vfs_prev
= vfsp
;
3592 vfsp
->vfs_next
= rootvfs
;
3595 * Do it again for the zone-private list (which may be NULL).
3597 if (zone
->zone_vfslist
== NULL
) {
3598 ASSERT(zone
!= global_zone
);
3599 zone
->zone_vfslist
= vfsp
;
3601 zone
->zone_vfslist
->vfs_zone_prev
->vfs_zone_next
= vfsp
;
3602 vfsp
->vfs_zone_prev
= zone
->zone_vfslist
->vfs_zone_prev
;
3603 zone
->zone_vfslist
->vfs_zone_prev
= vfsp
;
3604 vfsp
->vfs_zone_next
= zone
->zone_vfslist
;
3609 * Link into the hash table, inserting it at the end, so that LOFS
3610 * with the same fsid as UFS (or other) file systems will not hide
3613 vfs_hash_add(vfsp
, 0);
3616 * update the mnttab modification time
3618 vfs_mnttab_modtimeupd();
3624 vfs_list_remove(struct vfs
*vfsp
)
3628 zone
= zone_find_by_path(refstr_value(vfsp
->vfs_mntpt
));
3629 ASSERT(zone
!= NULL
);
3631 * Callers are responsible for preventing attempts to unmount the
3634 ASSERT(vfsp
!= rootvfs
);
3641 vfs_hash_remove(vfsp
);
3644 * Remove from vfs list.
3646 vfsp
->vfs_prev
->vfs_next
= vfsp
->vfs_next
;
3647 vfsp
->vfs_next
->vfs_prev
= vfsp
->vfs_prev
;
3648 vfsp
->vfs_next
= vfsp
->vfs_prev
= NULL
;
3651 * Remove from zone-specific vfs list.
3653 if (zone
->zone_vfslist
== vfsp
)
3654 zone
->zone_vfslist
= vfsp
->vfs_zone_next
;
3656 if (vfsp
->vfs_zone_next
== vfsp
) {
3657 ASSERT(vfsp
->vfs_zone_prev
== vfsp
);
3658 ASSERT(zone
->zone_vfslist
== vfsp
);
3659 zone
->zone_vfslist
= NULL
;
3662 vfsp
->vfs_zone_prev
->vfs_zone_next
= vfsp
->vfs_zone_next
;
3663 vfsp
->vfs_zone_next
->vfs_zone_prev
= vfsp
->vfs_zone_prev
;
3664 vfsp
->vfs_zone_next
= vfsp
->vfs_zone_prev
= NULL
;
3667 * update the mnttab modification time
3669 vfs_mnttab_modtimeupd();
3675 getvfs(fsid_t
*fsid
)
3678 int val0
= fsid
->val
[0];
3679 int val1
= fsid
->val
[1];
3680 dev_t dev
= expldev(val0
);
3681 int vhno
= VFSHASH(getmajor(dev
), getminor(dev
));
3682 kmutex_t
*hmp
= &rvfs_list
[vhno
].rvfs_lock
;
3685 for (vfsp
= rvfs_list
[vhno
].rvfs_head
; vfsp
; vfsp
= vfsp
->vfs_hash
) {
3686 if (vfsp
->vfs_fsid
.val
[0] == val0
&&
3687 vfsp
->vfs_fsid
.val
[1] == val1
) {
3698 * Search the vfs mount in progress list for a specified device/vfs entry.
3699 * Returns 0 if the first entry in the list that the device matches has the
3700 * given vfs pointer as well. If the device matches but a different vfs
3701 * pointer is encountered in the list before the given vfs pointer then
3706 vfs_devmounting(dev_t dev
, struct vfs
*vfsp
)
3711 mutex_enter(&vfs_miplist_mutex
);
3712 for (mipp
= vfs_miplist
; mipp
!= NULL
; mipp
= mipp
->mip_next
) {
3713 if (mipp
->mip_dev
== dev
) {
3714 if (mipp
->mip_vfsp
!= vfsp
)
3719 mutex_exit(&vfs_miplist_mutex
);
3724 * Search the vfs list for a specified device. Returns 1, if entry is found
3725 * or 0 if no suitable entry is found.
3729 vfs_devismounted(dev_t dev
)
3734 vfs_list_read_lock();
3738 if (vfsp
->vfs_dev
== dev
) {
3742 vfsp
= vfsp
->vfs_next
;
3743 } while (vfsp
!= rootvfs
);
3750 * Search the vfs list for a specified device. Returns a pointer to it
3751 * or NULL if no suitable entry is found. The caller of this routine
3752 * is responsible for releasing the returned vfs pointer.
3755 vfs_dev2vfsp(dev_t dev
)
3760 vfs_list_read_lock();
3765 * The following could be made more efficient by making
3766 * the entire loop use vfs_zone_next if the call is from
3767 * a zone. The only callers, however, ustat(2) and
3768 * umount2(2), don't seem to justify the added
3769 * complexity at present.
3771 if (vfsp
->vfs_dev
== dev
&&
3772 ZONE_PATH_VISIBLE(refstr_value(vfsp
->vfs_mntpt
),
3778 vfsp
= vfsp
->vfs_next
;
3779 } while (vfsp
!= rootvfs
);
3781 return (found
? vfsp
: NULL
);
3785 * Search the vfs list for a specified mntpoint. Returns a pointer to it
3786 * or NULL if no suitable entry is found. The caller of this routine
3787 * is responsible for releasing the returned vfs pointer.
3789 * Note that if multiple mntpoints match, the last one matching is
3790 * returned in an attempt to return the "top" mount when overlay
3791 * mounts are covering the same mount point. This is accomplished by starting
3792 * at the end of the list and working our way backwards, stopping at the first
3796 vfs_mntpoint2vfsp(const char *mp
)
3799 struct vfs
*retvfsp
= NULL
;
3800 zone_t
*zone
= curproc
->p_zone
;
3803 vfs_list_read_lock();
3804 if (getzoneid() == GLOBAL_ZONEID
) {
3806 * The global zone may see filesystems in any zone.
3808 vfsp
= rootvfs
->vfs_prev
;
3810 if (strcmp(refstr_value(vfsp
->vfs_mntpt
), mp
) == 0) {
3814 vfsp
= vfsp
->vfs_prev
;
3815 } while (vfsp
!= rootvfs
->vfs_prev
);
3816 } else if ((list
= zone
->zone_vfslist
) != NULL
) {
3819 vfsp
= list
->vfs_zone_prev
;
3821 mntpt
= refstr_value(vfsp
->vfs_mntpt
);
3822 mntpt
= ZONE_PATH_TRANSLATE(mntpt
, zone
);
3823 if (strcmp(mntpt
, mp
) == 0) {
3827 vfsp
= vfsp
->vfs_zone_prev
;
3828 } while (vfsp
!= list
->vfs_zone_prev
);
3837 * Search the vfs list for a specified vfsops.
3838 * if vfs entry is found then return 1, else 0.
3841 vfs_opsinuse(vfsops_t
*ops
)
3846 vfs_list_read_lock();
3850 if (vfs_getops(vfsp
) == ops
) {
3854 vfsp
= vfsp
->vfs_next
;
3855 } while (vfsp
!= rootvfs
);
3861 * Allocate an entry in vfssw for a file system type
3864 allocate_vfssw(const char *type
)
3868 if (type
[0] == '\0' || strlen(type
) + 1 > _ST_FSTYPSZ
) {
3870 * The vfssw table uses the empty string to identify an
3871 * available entry; we cannot add any type which has
3872 * a leading NUL. The string length is limited to
3873 * the size of the st_fstype array in struct stat.
3878 ASSERT(VFSSW_WRITE_LOCKED());
3879 for (vswp
= &vfssw
[1]; vswp
< &vfssw
[nfstype
]; vswp
++)
3880 if (!ALLOCATED_VFSSW(vswp
)) {
3881 vswp
->vsw_name
= kmem_alloc(strlen(type
) + 1, KM_SLEEP
);
3882 (void) strcpy(vswp
->vsw_name
, type
);
3883 ASSERT(vswp
->vsw_count
== 0);
3884 vswp
->vsw_count
= 1;
3885 mutex_init(&vswp
->vsw_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
3892 * Impose additional layer of translation between vfstype names
3893 * and module names in the filesystem.
3896 vfs_to_modname(const char *vfstype
)
3898 if (strcmp(vfstype
, "proc") == 0) {
3900 } else if (strcmp(vfstype
, "fd") == 0) {
3902 } else if (strncmp(vfstype
, "nfs", 3) == 0) {
3910 * Find a vfssw entry given a file system type name.
3911 * Try to autoload the filesystem if it's not found.
3912 * If it's installed, return the vfssw locked to prevent unloading.
3915 vfs_getvfssw(const char *type
)
3918 const char *modname
;
3921 vswp
= vfs_getvfsswbyname(type
);
3922 modname
= vfs_to_modname(type
);
3924 if (rootdir
== NULL
) {
3926 * If we haven't yet loaded the root file system, then our
3927 * _init won't be called until later. Allocate vfssw entry,
3928 * because mod_installfs won't be called.
3933 if ((vswp
= vfs_getvfsswbyname(type
)) == NULL
) {
3934 if ((vswp
= allocate_vfssw(type
)) == NULL
) {
3942 if (!VFS_INSTALLED(vswp
)) {
3944 (void) modloadonly("fs", modname
);
3951 * Try to load the filesystem. Before calling modload(), we drop
3952 * our lock on the VFS switch table, and pick it up after the
3953 * module is loaded. However, there is a potential race: the
3954 * module could be unloaded after the call to modload() completes
3955 * but before we pick up the lock and drive on. Therefore,
3956 * we keep reloading the module until we've loaded the module
3957 * _and_ we have the lock on the VFS switch table.
3959 while (vswp
== NULL
|| !VFS_INSTALLED(vswp
)) {
3961 if (modload("fs", modname
) == -1)
3965 if ((vswp
= vfs_getvfsswbyname(type
)) == NULL
)
3974 * Find a vfssw entry given a file system type name.
3977 vfs_getvfsswbyname(const char *type
)
3981 ASSERT(VFSSW_LOCKED());
3982 if (type
== NULL
|| *type
== '\0')
3985 for (vswp
= &vfssw
[1]; vswp
< &vfssw
[nfstype
]; vswp
++) {
3986 if (strcmp(type
, vswp
->vsw_name
) == 0) {
3996 * Find a vfssw entry given a set of vfsops.
3999 vfs_getvfsswbyvfsops(vfsops_t
*vfsops
)
4004 for (vswp
= &vfssw
[1]; vswp
< &vfssw
[nfstype
]; vswp
++) {
4005 if (ALLOCATED_VFSSW(vswp
) && &vswp
->vsw_vfsops
== vfsops
) {
4017 * Reference a vfssw entry.
4020 vfs_refvfssw(struct vfssw
*vswp
)
4023 mutex_enter(&vswp
->vsw_lock
);
4025 mutex_exit(&vswp
->vsw_lock
);
4029 * Unreference a vfssw entry.
4032 vfs_unrefvfssw(struct vfssw
*vswp
)
4035 mutex_enter(&vswp
->vsw_lock
);
4037 mutex_exit(&vswp
->vsw_lock
);
4040 int sync_timeout
= 30; /* timeout for syncing a page during panic */
4041 int sync_timeleft
; /* portion of sync_timeout remaining */
4043 static int sync_retries
= 20; /* number of retries when not making progress */
4044 static int sync_triesleft
; /* portion of sync_retries remaining */
4046 static pgcnt_t old_pgcnt
, new_pgcnt
;
4047 static int new_bufcnt
, old_bufcnt
;
4050 * Sync all of the mounted filesystems, and then wait for the actual i/o to
4051 * complete. We wait by counting the number of dirty pages and buffers,
4052 * pushing them out using bio_busy() and page_busy(), and then counting again.
4053 * This routine is used during both the uadmin A_SHUTDOWN code as well as
4054 * the SYNC phase of the panic code (see comments in panic.c). It should only
4055 * be used after some higher-level mechanism has quiesced the system so that
4056 * new writes are not being initiated while we are waiting for completion.
4058 * To ensure finite running time, our algorithm uses two timeout mechanisms:
4059 * sync_timeleft (a timer implemented by the omnipresent deadman() cyclic), and
4060 * sync_triesleft (a progress counter used by the vfs_syncall() loop below).
4061 * Together these ensure that syncing completes if our i/o paths are stuck.
4062 * The counters are declared above so they can be found easily in the debugger.
4064 * The sync_timeleft counter is reset by bio_busy() and page_busy() using the
4065 * vfs_syncprogress() subroutine whenever we make progress through the lists of
4066 * pages and buffers. It is decremented and expired by the deadman() cyclic.
4067 * When vfs_syncall() decides it is done, we disable the deadman() counter by
4068 * setting sync_timeleft to zero. This timer guards against vfs_syncall()
4069 * deadlocking or hanging inside of a broken filesystem or driver routine.
4071 * The sync_triesleft counter is updated by vfs_syncall() itself. If we make
4072 * sync_retries consecutive calls to bio_busy() and page_busy() without
4073 * decreasing either the number of dirty buffers or dirty pages below the
4074 * lowest count we have seen so far, we give up and return from vfs_syncall().
4076 * Each loop iteration ends with a call to delay() one second to allow time for
4077 * i/o completion and to permit the user time to read our progress messages.
4082 if (rootdir
== NULL
&& !modrootloaded
)
4083 return; /* panic during boot - no filesystems yet */
4085 printf("syncing file systems...");
4090 sync_triesleft
= sync_retries
;
4092 old_bufcnt
= new_bufcnt
= INT_MAX
;
4093 old_pgcnt
= new_pgcnt
= ULONG_MAX
;
4095 while (sync_triesleft
> 0) {
4096 old_bufcnt
= MIN(old_bufcnt
, new_bufcnt
);
4097 old_pgcnt
= MIN(old_pgcnt
, new_pgcnt
);
4099 new_bufcnt
= bio_busy(B_TRUE
);
4100 new_pgcnt
= page_busy(B_TRUE
);
4103 if (new_bufcnt
== 0 && new_pgcnt
== 0)
4106 if (new_bufcnt
< old_bufcnt
|| new_pgcnt
< old_pgcnt
)
4107 sync_triesleft
= sync_retries
;
4112 printf(" [%d]", new_bufcnt
);
4114 printf(" %lu", new_pgcnt
);
4119 if (new_bufcnt
!= 0 || new_pgcnt
!= 0)
4120 printf(" done (not all i/o completed)\n");
4129 * If we are in the middle of the sync phase of panic, reset sync_timeleft to
4130 * sync_timeout to indicate that we are making progress and the deadman()
4131 * omnipresent cyclic should not yet time us out. Note that it is safe to
4132 * store to sync_timeleft here since the deadman() is firing at high-level
4133 * on top of us. If we are racing with the deadman(), either the deadman()
4134 * will decrement the old value and then we will reset it, or we will
4135 * reset it and then the deadman() will immediately decrement it. In either
4136 * case, correct behavior results.
4139 vfs_syncprogress(void)
4142 sync_timeleft
= sync_timeout
;
4146 * Map VFS flags to statvfs flags. These shouldn't really be separate
4150 vf_to_stf(uint_t vf
)
4154 if (vf
& VFS_RDONLY
)
4156 if (vf
& VFS_NOSETUID
)
4158 if (vf
& VFS_NOTRUNC
)
4165 * Entries for (illegal) fstype 0.
4169 vfsstray_sync(struct vfs
*vfsp
, short arg
, struct cred
*cr
)
4171 cmn_err(CE_PANIC
, "stray vfs operation");
4176 * Entries for (illegal) fstype 0.
4181 cmn_err(CE_PANIC
, "stray vfs operation");
4186 * Support for dealing with forced UFS unmount and its interaction with
4187 * LOFS. Could be used by any filesystem.
4197 * We've gotta define the op for sync separately, since the compiler gets
4198 * confused if we mix and match ANSI and normal style prototypes when
4199 * a "short" argument is present and spits out a warning.
4203 vfs_EIO_sync(struct vfs
*vfsp
, short arg
, struct cred
*cr
)
4209 vfsops_t
*EIO_vfsops
;
4212 * Called from startup() to initialize all loaded vfs's
4219 extern int vopstats_enabled
;
4220 extern void vopstats_startup();
4222 static const fs_operation_def_t EIO_vfsops_template
[] = {
4223 VFSNAME_MOUNT
, { .error
= vfs_EIO
},
4224 VFSNAME_UNMOUNT
, { .error
= vfs_EIO
},
4225 VFSNAME_ROOT
, { .error
= vfs_EIO
},
4226 VFSNAME_STATVFS
, { .error
= vfs_EIO
},
4227 VFSNAME_SYNC
, { .vfs_sync
= vfs_EIO_sync
},
4228 VFSNAME_VGET
, { .error
= vfs_EIO
},
4229 VFSNAME_MOUNTROOT
, { .error
= vfs_EIO
},
4230 VFSNAME_FREEVFS
, { .error
= vfs_EIO
},
4231 VFSNAME_VNSTATE
, { .error
= vfs_EIO
},
4235 static const fs_operation_def_t stray_vfsops_template
[] = {
4236 VFSNAME_MOUNT
, { .error
= vfsstray
},
4237 VFSNAME_UNMOUNT
, { .error
= vfsstray
},
4238 VFSNAME_ROOT
, { .error
= vfsstray
},
4239 VFSNAME_STATVFS
, { .error
= vfsstray
},
4240 VFSNAME_SYNC
, { .vfs_sync
= vfsstray_sync
},
4241 VFSNAME_VGET
, { .error
= vfsstray
},
4242 VFSNAME_MOUNTROOT
, { .error
= vfsstray
},
4243 VFSNAME_FREEVFS
, { .error
= vfsstray
},
4244 VFSNAME_VNSTATE
, { .error
= vfsstray
},
4248 /* Create vfs cache */
4249 vfs_cache
= kmem_cache_create("vfs_cache", sizeof (struct vfs
),
4250 sizeof (uintptr_t), NULL
, NULL
, NULL
, NULL
, NULL
, 0);
4252 /* Initialize the vnode cache (file systems may use it during init). */
4255 /* Setup event monitor framework */
4258 /* Initialize the dummy stray file system type. */
4259 error
= vfs_setfsops(0, stray_vfsops_template
, NULL
);
4261 /* Initialize the dummy EIO file system. */
4262 error
= vfs_makefsops(EIO_vfsops_template
, &EIO_vfsops
);
4264 cmn_err(CE_WARN
, "vfsinit: bad EIO vfs ops template");
4265 /* Shouldn't happen, but not bad enough to panic */
4268 VFS_INIT(&EIO_vfs
, EIO_vfsops
, (caddr_t
)NULL
);
4271 * Default EIO_vfs.vfs_flag to VFS_UNMOUNTED so a lookup
4272 * on this vfs can immediately notice it's invalid.
4274 EIO_vfs
.vfs_flag
|= VFS_UNMOUNTED
;
4277 * Call the init routines of non-loadable filesystems only.
4278 * Filesystems which are loaded as separate modules will be
4279 * initialized by the module loading code instead.
4282 for (vswp
= &vfssw
[1]; vswp
< &vfssw
[nfstype
]; vswp
++) {
4284 if (vswp
->vsw_init
!= NULL
)
4285 (*vswp
->vsw_init
)(vswp
- vfssw
, vswp
->vsw_name
);
4291 if (vopstats_enabled
) {
4292 /* EIO_vfs can collect stats, but we don't retrieve them */
4293 initialize_vopstats(&EIO_vfs
.vfs_vopstats
);
4294 EIO_vfs
.vfs_fstypevsp
= NULL
;
4295 EIO_vfs
.vfs_vskap
= NULL
;
4296 EIO_vfs
.vfs_flag
|= VFS_STATS
;
4301 reparse_point_init();
4305 vfs_alloc(int kmflag
)
4309 vfsp
= kmem_cache_alloc(vfs_cache
, kmflag
);
4312 * Do the simplest initialization here.
4313 * Everything else gets done in vfs_init()
4315 bzero(vfsp
, sizeof (vfs_t
));
4320 vfs_free(vfs_t
*vfsp
)
4323 * One would be tempted to assert that "vfsp->vfs_count == 0".
4324 * The problem is that this gets called out of domount() with
4325 * a partially initialized vfs and a vfs_count of 1. This is
4326 * also called from vfs_rele() with a vfs_count of 0. We can't
4327 * call VFS_RELE() from domount() if VFS_MOUNT() hasn't successfully
4328 * returned. This is because VFS_MOUNT() fully initializes the
4329 * vfs structure and its associated data. VFS_RELE() will call
4330 * VFS_FREEVFS() which may panic the system if the data structures
4331 * aren't fully initialized from a successful VFS_MOUNT()).
4334 /* If FEM was in use, make sure everything gets cleaned up */
4335 if (vfsp
->vfs_femhead
) {
4336 ASSERT(vfsp
->vfs_femhead
->femh_list
== NULL
);
4337 mutex_destroy(&vfsp
->vfs_femhead
->femh_lock
);
4338 kmem_free(vfsp
->vfs_femhead
, sizeof (*(vfsp
->vfs_femhead
)));
4339 vfsp
->vfs_femhead
= NULL
;
4342 if (vfsp
->vfs_implp
)
4343 vfsimpl_teardown(vfsp
);
4344 sema_destroy(&vfsp
->vfs_reflock
);
4345 kmem_cache_free(vfs_cache
, vfsp
);
4349 * Increments the vfs reference count by one atomically.
4352 vfs_hold(vfs_t
*vfsp
)
4354 atomic_inc_32(&vfsp
->vfs_count
);
4355 ASSERT(vfsp
->vfs_count
!= 0);
4359 * Decrements the vfs reference count by one atomically. When
4360 * vfs reference count becomes zero, it calls the file system
4361 * specific vfs_freevfs() to free up the resources.
4364 vfs_rele(vfs_t
*vfsp
)
4366 ASSERT(vfsp
->vfs_count
!= 0);
4367 if (atomic_dec_32_nv(&vfsp
->vfs_count
) == 0) {
4371 zone_rele_ref(&vfsp
->vfs_implp
->vi_zone_ref
,
4373 vfs_freemnttab(vfsp
);
4379 * Generic operations vector support.
4381 * This is used to build operations vectors for both the vfs and vnode.
4382 * It's normally called only when a file system is loaded.
4384 * There are many possible algorithms for this, including the following:
4386 * (1) scan the list of known operations; for each, see if the file system
4387 * includes an entry for it, and fill it in as appropriate.
4389 * (2) set up defaults for all known operations. scan the list of ops
4390 * supplied by the file system; for each which is both supplied and
4391 * known, fill it in.
4393 * (3) sort the lists of known ops & supplied ops; scan the list, filling
4394 * in entries as we go.
4396 * we choose (1) for simplicity, and because performance isn't critical here.
4397 * note that (2) could be sped up using a precomputed hash table on known ops.
4398 * (3) could be faster than either, but only if the lists were very large or
4399 * supplied in sorted order.
4404 fs_build_vector(void *vector
, int *unused_ops
,
4405 const fs_operation_trans_def_t
*translation
,
4406 const fs_operation_def_t
*operations
)
4408 int i
, num_trans
, num_ops
, used
;
4411 * Count the number of translations and the number of supplied
4416 const fs_operation_trans_def_t
*p
;
4418 for (num_trans
= 0, p
= translation
;
4425 const fs_operation_def_t
*p
;
4427 for (num_ops
= 0, p
= operations
;
4433 /* Walk through each operation known to our caller. There will be */
4434 /* one entry in the supplied "translation table" for each. */
4438 for (i
= 0; i
< num_trans
; i
++) {
4441 fs_generic_func_p result
;
4442 fs_generic_func_p
*location
;
4444 curname
= translation
[i
].name
;
4446 /* Look for a matching operation in the list supplied by the */
4451 for (j
= 0; j
< num_ops
; j
++) {
4452 if (strcmp(operations
[j
].name
, curname
) == 0) {
4460 * If the file system is using a "placeholder" for default
4461 * or error functions, grab the appropriate function out of
4462 * the translation table. If the file system didn't supply
4463 * this operation at all, use the default function.
4467 result
= operations
[j
].func
.fs_generic
;
4468 if (result
== fs_default
) {
4469 result
= translation
[i
].defaultFunc
;
4470 } else if (result
== fs_error
) {
4471 result
= translation
[i
].errorFunc
;
4472 } else if (result
== NULL
) {
4473 /* Null values are PROHIBITED */
4477 result
= translation
[i
].defaultFunc
;
4480 /* Now store the function into the operations vector. */
4482 location
= (fs_generic_func_p
*)
4483 (((char *)vector
) + translation
[i
].offset
);
4488 *unused_ops
= num_ops
- used
;
4493 /* Placeholder functions, should never be called. */
4498 cmn_err(CE_PANIC
, "fs_error called");
4505 cmn_err(CE_PANIC
, "fs_default called");
4512 * Part of the implementation of booting off a mirrored root
4513 * involves a change of dev_t for the root device. To
4514 * accomplish this, first remove the existing hash table
4515 * entry for the root device, convert to the new dev_t,
4516 * then re-insert in the hash table at the head of the list.
4519 vfs_root_redev(vfs_t
*vfsp
, dev_t ndev
, int fstype
)
4523 vfs_hash_remove(vfsp
);
4525 vfsp
->vfs_dev
= ndev
;
4526 vfs_make_fsid(&vfsp
->vfs_fsid
, ndev
, fstype
);
4528 vfs_hash_add(vfsp
, 1);
4533 #else /* x86 NEWBOOT */
4536 extern int hvmboot_rootconf();
4539 extern ib_boot_prop_t
*iscsiboot_prop
;
4546 extern void pm_init();
4547 char *fstyp
, *fsmod
;
4550 getrootfs(&fstyp
, &fsmod
);
4554 * hvmboot_rootconf() is defined in the hvm_bootstrap misc module,
4555 * which lives in /platform/i86hvm, and hence is only available when
4556 * booted in an x86 hvm environment. If the hvm_bootstrap misc module
4557 * is not available then the modstub for this function will return 0.
4558 * If the hvm_bootstrap misc module is available it will be loaded
4559 * and hvmboot_rootconf() will be invoked.
4561 if (error
= hvmboot_rootconf())
4565 if (error
= clboot_rootconf())
4568 if (modload("fs", fsmod
) == -1)
4569 panic("Cannot _init %s module", fsmod
);
4572 vsw
= vfs_getvfsswbyname(fstyp
);
4575 cmn_err(CE_CONT
, "Cannot find %s filesystem\n", fstyp
);
4578 VFS_INIT(rootvfs
, &vsw
->vsw_vfsops
, 0);
4581 /* always mount readonly first */
4582 rootvfs
->vfs_flag
|= VFS_RDONLY
;
4586 if (netboot
&& iscsiboot_prop
) {
4587 cmn_err(CE_WARN
, "NFS boot and iSCSI boot"
4588 " shouldn't happen in the same time");
4592 if (netboot
|| iscsiboot_prop
) {
4595 cmn_err(CE_WARN
, "Cannot plumb network device %d", ret
);
4600 if ((ret
== 0) && iscsiboot_prop
) {
4601 ret
= modload("drv", "iscsi");
4602 /* -1 indicates fail */
4604 cmn_err(CE_WARN
, "Failed to load iscsi module");
4605 iscsi_boot_prop_free();
4608 if (!i_ddi_attach_pseudo_node("iscsi")) {
4610 "Failed to attach iscsi driver");
4611 iscsi_boot_prop_free();
4617 error
= VFS_MOUNTROOT(rootvfs
, ROOT_INIT
);
4618 vfs_unrefvfssw(vsw
);
4619 rootdev
= rootvfs
->vfs_dev
;
4622 cmn_err(CE_CONT
, "Cannot mount root on %s fstype %s\n",
4623 rootfs
.bo_name
, fstyp
);
4625 cmn_err(CE_CONT
, "?root on %s fstype %s\n",
4626 rootfs
.bo_name
, fstyp
);
4631 * XXX this is called by nfs only and should probably be removed
4632 * If booted with ASKNAME, prompt on the console for a filesystem
4633 * name and return it.
4636 getfsname(char *askfor
, char *name
, size_t namelen
)
4638 if (boothowto
& RB_ASKNAME
) {
4639 printf("%s name: ", askfor
);
4640 console_gets(name
, namelen
);
4645 * Init the root filesystem type (rootfs.bo_fstype) from the "fstype"
4648 * Filesystem types starting with the prefix "nfs" are diskless clients;
4649 * init the root filename name (rootfs.bo_name), too.
4651 * If we are booting via NFS we currently have these options:
4652 * nfs - dynamically choose NFS V2, V3, or V4 (default)
4653 * nfs2 - force NFS V2
4654 * nfs3 - force NFS V3
4655 * nfs4 - force NFS V4
4656 * Because we need to maintain backward compatibility with the naming
4657 * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c)
4658 * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs". The dynamic
4659 * nfs module will map the type back to either "nfs", "nfs3", or "nfs4".
4660 * This is only for root filesystems, all other uses will expect
4661 * that "nfs" == NFS V2.
4664 getrootfs(char **fstypp
, char **fsmodp
)
4666 extern char *strplumb_get_netdev_path(void);
4667 char *propstr
= NULL
;
4670 * Check fstype property; for diskless it should be one of "nfs",
4671 * "nfs2", "nfs3" or "nfs4".
4673 if (ddi_prop_lookup_string(DDI_DEV_T_ANY
, ddi_root_node(),
4674 DDI_PROP_DONTPASS
, "fstype", &propstr
)
4676 (void) strncpy(rootfs
.bo_fstype
, propstr
, BO_MAXFSNAME
);
4677 ddi_prop_free(propstr
);
4680 * if the boot property 'fstype' is not set, but 'zfs-bootfs' is set,
4681 * assume the type of this root filesystem is 'zfs'.
4683 } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY
, ddi_root_node(),
4684 DDI_PROP_DONTPASS
, "zfs-bootfs", &propstr
)
4686 (void) strncpy(rootfs
.bo_fstype
, "zfs", BO_MAXFSNAME
);
4687 ddi_prop_free(propstr
);
4690 if (strncmp(rootfs
.bo_fstype
, "nfs", 3) != 0) {
4691 *fstypp
= *fsmodp
= rootfs
.bo_fstype
;
4697 if (strcmp(rootfs
.bo_fstype
, "nfs2") == 0)
4698 (void) strcpy(rootfs
.bo_fstype
, "nfs");
4699 else if (strcmp(rootfs
.bo_fstype
, "nfs") == 0)
4700 (void) strcpy(rootfs
.bo_fstype
, "nfsdyn");
4703 * check if path to network interface is specified in bootpath
4704 * or by a hypervisor domain configuration file.
4705 * XXPV - enable strlumb_get_netdev_path()
4707 if (ddi_prop_exists(DDI_DEV_T_ANY
, ddi_root_node(), DDI_PROP_DONTPASS
,
4709 (void) strcpy(rootfs
.bo_name
, "/xpvd/xnf@0");
4710 } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY
, ddi_root_node(),
4711 DDI_PROP_DONTPASS
, "bootpath", &propstr
)
4713 (void) strncpy(rootfs
.bo_name
, propstr
, BO_MAXOBJNAME
);
4714 ddi_prop_free(propstr
);
4716 /* attempt to determine netdev_path via boot_mac address */
4717 netdev_path
= strplumb_get_netdev_path();
4718 if (netdev_path
== NULL
)
4719 panic("cannot find boot network interface");
4720 (void) strncpy(rootfs
.bo_name
, netdev_path
, BO_MAXOBJNAME
);
4722 *fstypp
= rootfs
.bo_fstype
;
4728 * VFS feature routines
4731 #define VFTINDEX(feature) (((feature) >> 32) & 0xFFFFFFFF)
4732 #define VFTBITS(feature) ((feature) & 0xFFFFFFFFLL)
4734 /* Register a feature in the vfs */
4736 vfs_set_feature(vfs_t
*vfsp
, vfs_feature_t feature
)
4738 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4739 if (vfsp
->vfs_implp
== NULL
)
4742 vfsp
->vfs_featureset
[VFTINDEX(feature
)] |= VFTBITS(feature
);
4746 vfs_clear_feature(vfs_t
*vfsp
, vfs_feature_t feature
)
4748 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4749 if (vfsp
->vfs_implp
== NULL
)
4751 vfsp
->vfs_featureset
[VFTINDEX(feature
)] &= VFTBITS(~feature
);
4755 * Query a vfs for a feature.
4756 * Returns 1 if feature is present, 0 if not
4759 vfs_has_feature(vfs_t
*vfsp
, vfs_feature_t feature
)
4763 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4764 if (vfsp
->vfs_implp
== NULL
)
4767 if (vfsp
->vfs_featureset
[VFTINDEX(feature
)] & VFTBITS(feature
))
4774 * Propagate feature set from one vfs to another
4777 vfs_propagate_features(vfs_t
*from
, vfs_t
*to
)
4781 if (to
->vfs_implp
== NULL
|| from
->vfs_implp
== NULL
)
4784 for (i
= 1; i
<= to
->vfs_featureset
[0]; i
++) {
4785 to
->vfs_featureset
[i
] = from
->vfs_featureset
[i
];
4789 #define LOFINODE_PATH "/dev/lofi/%d"
4792 * Return the vnode for the lofi node if there's a lofi mount in place.
4793 * Returns -1 when there's no lofi node, 0 on success, and > 0 on
4797 vfs_get_lofi(vfs_t
*vfsp
, vnode_t
**vpp
)
4803 if (vfsp
->vfs_lofi_minor
== 0) {
4808 strsize
= snprintf(NULL
, 0, LOFINODE_PATH
, vfsp
->vfs_lofi_minor
);
4809 path
= kmem_alloc(strsize
+ 1, KM_SLEEP
);
4810 (void) snprintf(path
, strsize
+ 1, LOFINODE_PATH
, vfsp
->vfs_lofi_minor
);
4813 * We may be inside a zone, so we need to use the /dev path, but
4814 * it's created asynchronously, so we wait here.
4817 err
= lookupname(path
, UIO_SYSSPACE
, FOLLOW
, NULLVPP
, vpp
);
4822 if ((err
= delay_sig(hz
/ 8)) == EINTR
)
4829 kmem_free(path
, strsize
+ 1);