xref: /onnv-gate/usr/src/uts/common/fs/zfs/zfs_vfsops.c (revision 1646:b4e43ae19fff)
1789Sahrens /*
2789Sahrens  * CDDL HEADER START
3789Sahrens  *
4789Sahrens  * The contents of this file are subject to the terms of the
51484Sek110237  * Common Development and Distribution License (the "License").
61484Sek110237  * You may not use this file except in compliance with the License.
7789Sahrens  *
8789Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9789Sahrens  * or http://www.opensolaris.org/os/licensing.
10789Sahrens  * See the License for the specific language governing permissions
11789Sahrens  * and limitations under the License.
12789Sahrens  *
13789Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14789Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15789Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16789Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17789Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18789Sahrens  *
19789Sahrens  * CDDL HEADER END
20789Sahrens  */
21789Sahrens /*
221298Sperrin  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23789Sahrens  * Use is subject to license terms.
24789Sahrens  */
25789Sahrens 
26789Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
27789Sahrens 
28789Sahrens #include <sys/types.h>
29789Sahrens #include <sys/param.h>
30789Sahrens #include <sys/systm.h>
31789Sahrens #include <sys/sysmacros.h>
32789Sahrens #include <sys/kmem.h>
33789Sahrens #include <sys/pathname.h>
34789Sahrens #include <sys/acl.h>
35789Sahrens #include <sys/vnode.h>
36789Sahrens #include <sys/vfs.h>
37789Sahrens #include <sys/mntent.h>
38789Sahrens #include <sys/mount.h>
39789Sahrens #include <sys/cmn_err.h>
40789Sahrens #include "fs/fs_subr.h"
41789Sahrens #include <sys/zfs_znode.h>
42789Sahrens #include <sys/zil.h>
43789Sahrens #include <sys/fs/zfs.h>
44789Sahrens #include <sys/dmu.h>
45789Sahrens #include <sys/dsl_prop.h>
46789Sahrens #include <sys/spa.h>
47789Sahrens #include <sys/zap.h>
48789Sahrens #include <sys/varargs.h>
49789Sahrens #include <sys/policy.h>
50789Sahrens #include <sys/atomic.h>
51789Sahrens #include <sys/mkdev.h>
52789Sahrens #include <sys/modctl.h>
53789Sahrens #include <sys/zfs_ioctl.h>
54789Sahrens #include <sys/zfs_ctldir.h>
551544Seschrock #include <sys/bootconf.h>
56849Sbonwick #include <sys/sunddi.h>
571484Sek110237 #include <sys/dnlc.h>
58789Sahrens 
59789Sahrens int zfsfstype;
60789Sahrens vfsops_t *zfs_vfsops = NULL;
61849Sbonwick static major_t zfs_major;
62789Sahrens static minor_t zfs_minor;
63789Sahrens static kmutex_t	zfs_dev_mtx;
64789Sahrens 
651544Seschrock extern char zfs_bootpath[BO_MAXOBJNAME];
661544Seschrock 
67789Sahrens static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr);
68789Sahrens static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr);
691544Seschrock static int zfs_mountroot(vfs_t *vfsp, enum whymountroot);
70789Sahrens static int zfs_root(vfs_t *vfsp, vnode_t **vpp);
71789Sahrens static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp);
72789Sahrens static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp);
73789Sahrens static void zfs_freevfs(vfs_t *vfsp);
74789Sahrens static void zfs_objset_close(zfsvfs_t *zfsvfs);
75789Sahrens 
76789Sahrens static const fs_operation_def_t zfs_vfsops_template[] = {
77789Sahrens 	VFSNAME_MOUNT, zfs_mount,
781544Seschrock 	VFSNAME_MOUNTROOT, zfs_mountroot,
79789Sahrens 	VFSNAME_UNMOUNT, zfs_umount,
80789Sahrens 	VFSNAME_ROOT, zfs_root,
81789Sahrens 	VFSNAME_STATVFS, zfs_statvfs,
82789Sahrens 	VFSNAME_SYNC, (fs_generic_func_p) zfs_sync,
83789Sahrens 	VFSNAME_VGET, zfs_vget,
84789Sahrens 	VFSNAME_FREEVFS, (fs_generic_func_p) zfs_freevfs,
85789Sahrens 	NULL, NULL
86789Sahrens };
87789Sahrens 
88789Sahrens static const fs_operation_def_t zfs_vfsops_eio_template[] = {
89789Sahrens 	VFSNAME_FREEVFS, (fs_generic_func_p) zfs_freevfs,
90789Sahrens 	NULL, NULL
91789Sahrens };
92789Sahrens 
93789Sahrens /*
94789Sahrens  * We need to keep a count of active fs's.
95789Sahrens  * This is necessary to prevent our module
96789Sahrens  * from being unloaded after a umount -f
97789Sahrens  */
98789Sahrens static uint32_t	zfs_active_fs_count = 0;
99789Sahrens 
100789Sahrens static char *noatime_cancel[] = { MNTOPT_ATIME, NULL };
101789Sahrens static char *atime_cancel[] = { MNTOPT_NOATIME, NULL };
102789Sahrens 
103789Sahrens static mntopt_t mntopts[] = {
104789Sahrens 	{ MNTOPT_XATTR, NULL, NULL, MO_NODISPLAY|MO_DEFAULT, NULL },
105789Sahrens 	{ MNTOPT_NOATIME, noatime_cancel, NULL, MO_DEFAULT, NULL },
106789Sahrens 	{ MNTOPT_ATIME, atime_cancel, NULL, 0, NULL }
107789Sahrens };
108789Sahrens 
109789Sahrens static mntopts_t zfs_mntopts = {
110789Sahrens 	sizeof (mntopts) / sizeof (mntopt_t),
111789Sahrens 	mntopts
112789Sahrens };
113789Sahrens 
114789Sahrens /*ARGSUSED*/
115789Sahrens int
116789Sahrens zfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
117789Sahrens {
118789Sahrens 	/*
119789Sahrens 	 * Data integrity is job one.  We don't want a compromised kernel
120789Sahrens 	 * writing to the storage pool, so we never sync during panic.
121789Sahrens 	 */
122789Sahrens 	if (panicstr)
123789Sahrens 		return (0);
124789Sahrens 
125789Sahrens 	/*
126789Sahrens 	 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS
127789Sahrens 	 * to sync metadata, which they would otherwise cache indefinitely.
128789Sahrens 	 * Semantically, the only requirement is that the sync be initiated.
129789Sahrens 	 * The DMU syncs out txgs frequently, so there's nothing to do.
130789Sahrens 	 */
131789Sahrens 	if (flag & SYNC_ATTR)
132789Sahrens 		return (0);
133789Sahrens 
134789Sahrens 	if (vfsp != NULL) {
135789Sahrens 		/*
136789Sahrens 		 * Sync a specific filesystem.
137789Sahrens 		 */
138789Sahrens 		zfsvfs_t *zfsvfs = vfsp->vfs_data;
139789Sahrens 
140789Sahrens 		ZFS_ENTER(zfsvfs);
141789Sahrens 		if (zfsvfs->z_log != NULL)
142789Sahrens 			zil_commit(zfsvfs->z_log, UINT64_MAX, FSYNC);
143789Sahrens 		else
144789Sahrens 			txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
145789Sahrens 		ZFS_EXIT(zfsvfs);
146789Sahrens 	} else {
147789Sahrens 		/*
148789Sahrens 		 * Sync all ZFS filesystems.  This is what happens when you
149789Sahrens 		 * run sync(1M).  Unlike other filesystems, ZFS honors the
150789Sahrens 		 * request by waiting for all pools to commit all dirty data.
151789Sahrens 		 */
152789Sahrens 		spa_sync_allpools();
153789Sahrens 	}
154789Sahrens 
155789Sahrens 	return (0);
156789Sahrens }
157789Sahrens 
1581544Seschrock static int
1591544Seschrock zfs_create_unique_device(dev_t *dev)
1601544Seschrock {
1611544Seschrock 	major_t new_major;
1621544Seschrock 
1631544Seschrock 	do {
1641544Seschrock 		ASSERT3U(zfs_minor, <=, MAXMIN32);
1651544Seschrock 		minor_t start = zfs_minor;
1661544Seschrock 		do {
1671544Seschrock 			mutex_enter(&zfs_dev_mtx);
1681544Seschrock 			if (zfs_minor >= MAXMIN32) {
1691544Seschrock 				/*
1701544Seschrock 				 * If we're still using the real major
1711544Seschrock 				 * keep out of /dev/zfs and /dev/zvol minor
1721544Seschrock 				 * number space.  If we're using a getudev()'ed
1731544Seschrock 				 * major number, we can use all of its minors.
1741544Seschrock 				 */
1751544Seschrock 				if (zfs_major == ddi_name_to_major(ZFS_DRIVER))
1761544Seschrock 					zfs_minor = ZFS_MIN_MINOR;
1771544Seschrock 				else
1781544Seschrock 					zfs_minor = 0;
1791544Seschrock 			} else {
1801544Seschrock 				zfs_minor++;
1811544Seschrock 			}
1821544Seschrock 			*dev = makedevice(zfs_major, zfs_minor);
1831544Seschrock 			mutex_exit(&zfs_dev_mtx);
1841544Seschrock 		} while (vfs_devismounted(*dev) && zfs_minor != start);
1851544Seschrock 		if (zfs_minor == start) {
1861544Seschrock 			/*
1871544Seschrock 			 * We are using all ~262,000 minor numbers for the
1881544Seschrock 			 * current major number.  Create a new major number.
1891544Seschrock 			 */
1901544Seschrock 			if ((new_major = getudev()) == (major_t)-1) {
1911544Seschrock 				cmn_err(CE_WARN,
1921544Seschrock 				    "zfs_mount: Can't get unique major "
1931544Seschrock 				    "device number.");
1941544Seschrock 				return (-1);
1951544Seschrock 			}
1961544Seschrock 			mutex_enter(&zfs_dev_mtx);
1971544Seschrock 			zfs_major = new_major;
1981544Seschrock 			zfs_minor = 0;
1991544Seschrock 
2001544Seschrock 			mutex_exit(&zfs_dev_mtx);
2011544Seschrock 		} else {
2021544Seschrock 			break;
2031544Seschrock 		}
2041544Seschrock 		/* CONSTANTCONDITION */
2051544Seschrock 	} while (1);
2061544Seschrock 
2071544Seschrock 	return (0);
2081544Seschrock }
2091544Seschrock 
210789Sahrens static void
211789Sahrens atime_changed_cb(void *arg, uint64_t newval)
212789Sahrens {
213789Sahrens 	zfsvfs_t *zfsvfs = arg;
214789Sahrens 
215789Sahrens 	if (newval == TRUE) {
216789Sahrens 		zfsvfs->z_atime = TRUE;
217789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
218789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
219789Sahrens 	} else {
220789Sahrens 		zfsvfs->z_atime = FALSE;
221789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
222789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
223789Sahrens 	}
224789Sahrens }
225789Sahrens 
226789Sahrens static void
227789Sahrens blksz_changed_cb(void *arg, uint64_t newval)
228789Sahrens {
229789Sahrens 	zfsvfs_t *zfsvfs = arg;
230789Sahrens 
231789Sahrens 	if (newval < SPA_MINBLOCKSIZE ||
232789Sahrens 	    newval > SPA_MAXBLOCKSIZE || !ISP2(newval))
233789Sahrens 		newval = SPA_MAXBLOCKSIZE;
234789Sahrens 
235789Sahrens 	zfsvfs->z_max_blksz = newval;
236789Sahrens 	zfsvfs->z_vfs->vfs_bsize = newval;
237789Sahrens }
238789Sahrens 
239789Sahrens static void
240789Sahrens readonly_changed_cb(void *arg, uint64_t newval)
241789Sahrens {
242789Sahrens 	zfsvfs_t *zfsvfs = arg;
243789Sahrens 
244789Sahrens 	if (newval) {
245789Sahrens 		/* XXX locking on vfs_flag? */
246789Sahrens 		zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
247789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
248789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
249789Sahrens 		(void) zfs_delete_thread_target(zfsvfs, 0);
250789Sahrens 	} else {
251789Sahrens 		/* XXX locking on vfs_flag? */
252789Sahrens 		zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
253789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
254789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
255789Sahrens 		(void) zfs_delete_thread_target(zfsvfs, 1);
256789Sahrens 	}
257789Sahrens }
258789Sahrens 
259789Sahrens static void
260789Sahrens devices_changed_cb(void *arg, uint64_t newval)
261789Sahrens {
262789Sahrens 	zfsvfs_t *zfsvfs = arg;
263789Sahrens 
264789Sahrens 	if (newval == FALSE) {
265789Sahrens 		zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES;
266789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES);
267789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0);
268789Sahrens 	} else {
269789Sahrens 		zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES;
270789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES);
271789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0);
272789Sahrens 	}
273789Sahrens }
274789Sahrens 
275789Sahrens static void
276789Sahrens setuid_changed_cb(void *arg, uint64_t newval)
277789Sahrens {
278789Sahrens 	zfsvfs_t *zfsvfs = arg;
279789Sahrens 
280789Sahrens 	if (newval == FALSE) {
281789Sahrens 		zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
282789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
283789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
284789Sahrens 	} else {
285789Sahrens 		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
286789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
287789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
288789Sahrens 	}
289789Sahrens }
290789Sahrens 
291789Sahrens static void
292789Sahrens exec_changed_cb(void *arg, uint64_t newval)
293789Sahrens {
294789Sahrens 	zfsvfs_t *zfsvfs = arg;
295789Sahrens 
296789Sahrens 	if (newval == FALSE) {
297789Sahrens 		zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
298789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
299789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
300789Sahrens 	} else {
301789Sahrens 		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
302789Sahrens 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
303789Sahrens 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
304789Sahrens 	}
305789Sahrens }
306789Sahrens 
307789Sahrens static void
308789Sahrens snapdir_changed_cb(void *arg, uint64_t newval)
309789Sahrens {
310789Sahrens 	zfsvfs_t *zfsvfs = arg;
311789Sahrens 
312789Sahrens 	zfsvfs->z_show_ctldir = newval;
313789Sahrens }
314789Sahrens 
315789Sahrens static void
316789Sahrens acl_mode_changed_cb(void *arg, uint64_t newval)
317789Sahrens {
318789Sahrens 	zfsvfs_t *zfsvfs = arg;
319789Sahrens 
320789Sahrens 	zfsvfs->z_acl_mode = newval;
321789Sahrens }
322789Sahrens 
323789Sahrens static void
324789Sahrens acl_inherit_changed_cb(void *arg, uint64_t newval)
325789Sahrens {
326789Sahrens 	zfsvfs_t *zfsvfs = arg;
327789Sahrens 
328789Sahrens 	zfsvfs->z_acl_inherit = newval;
329789Sahrens }
330789Sahrens 
3311544Seschrock static int
3321544Seschrock zfs_refresh_properties(vfs_t *vfsp)
3331544Seschrock {
3341544Seschrock 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
3351544Seschrock 
3361544Seschrock 	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
3371544Seschrock 		readonly_changed_cb(zfsvfs, B_TRUE);
3381544Seschrock 	} else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
3391544Seschrock 		if (dmu_objset_is_snapshot(zfsvfs->z_os))
3401544Seschrock 			return (EROFS);
3411544Seschrock 		readonly_changed_cb(zfsvfs, B_FALSE);
3421544Seschrock 	}
3431544Seschrock 
3441544Seschrock 	if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
3451544Seschrock 		devices_changed_cb(zfsvfs, B_FALSE);
3461544Seschrock 		setuid_changed_cb(zfsvfs, B_FALSE);
3471544Seschrock 	} else {
3481544Seschrock 		if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
3491544Seschrock 			devices_changed_cb(zfsvfs, B_FALSE);
3501544Seschrock 		else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL))
3511544Seschrock 			devices_changed_cb(zfsvfs, B_TRUE);
3521544Seschrock 
3531544Seschrock 		if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL))
3541544Seschrock 			setuid_changed_cb(zfsvfs, B_FALSE);
3551544Seschrock 		else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL))
3561544Seschrock 			setuid_changed_cb(zfsvfs, B_TRUE);
3571544Seschrock 	}
3581544Seschrock 
3591544Seschrock 	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL))
3601544Seschrock 		exec_changed_cb(zfsvfs, B_FALSE);
3611544Seschrock 	else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL))
3621544Seschrock 		exec_changed_cb(zfsvfs, B_TRUE);
3631544Seschrock 
3641544Seschrock 	return (0);
3651544Seschrock }
3661544Seschrock 
3671544Seschrock static int
3681544Seschrock zfs_register_callbacks(vfs_t *vfsp)
3691544Seschrock {
3701544Seschrock 	struct dsl_dataset *ds = NULL;
3711544Seschrock 	objset_t *os = NULL;
3721544Seschrock 	zfsvfs_t *zfsvfs = NULL;
3731544Seschrock 	int do_readonly = FALSE, readonly;
3741544Seschrock 	int do_setuid = FALSE, setuid;
3751544Seschrock 	int do_exec = FALSE, exec;
3761544Seschrock 	int do_devices = FALSE, devices;
3771544Seschrock 	int error = 0;
3781544Seschrock 
3791544Seschrock 	ASSERT(vfsp);
3801544Seschrock 	zfsvfs = vfsp->vfs_data;
3811544Seschrock 	ASSERT(zfsvfs);
3821544Seschrock 	os = zfsvfs->z_os;
3831544Seschrock 
3841544Seschrock 	/*
3851544Seschrock 	 * The act of registering our callbacks will destroy any mount
3861544Seschrock 	 * options we may have.  In order to enable temporary overrides
3871544Seschrock 	 * of mount options, we stash away the current values and restore
3881544Seschrock 	 * restore them after we register the callbacks.
3891544Seschrock 	 */
3901544Seschrock 	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
3911544Seschrock 		readonly = B_TRUE;
3921544Seschrock 		do_readonly = B_TRUE;
3931544Seschrock 	} else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
3941544Seschrock 		readonly = B_FALSE;
3951544Seschrock 		do_readonly = B_TRUE;
3961544Seschrock 	}
3971544Seschrock 	if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
3981544Seschrock 		devices = B_FALSE;
3991544Seschrock 		setuid = B_FALSE;
4001544Seschrock 		do_devices = B_TRUE;
4011544Seschrock 		do_setuid = B_TRUE;
4021544Seschrock 	} else {
4031544Seschrock 		if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {
4041544Seschrock 			devices = B_FALSE;
4051544Seschrock 			do_devices = B_TRUE;
4061544Seschrock 		} else if (vfs_optionisset(vfsp,
4071544Seschrock 			    MNTOPT_DEVICES, NULL)) {
4081544Seschrock 			devices = B_TRUE;
4091544Seschrock 			do_devices = B_TRUE;
4101544Seschrock 		}
4111544Seschrock 
4121544Seschrock 		if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
4131544Seschrock 			setuid = B_FALSE;
4141544Seschrock 			do_setuid = B_TRUE;
4151544Seschrock 		} else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
4161544Seschrock 			setuid = B_TRUE;
4171544Seschrock 			do_setuid = B_TRUE;
4181544Seschrock 		}
4191544Seschrock 	}
4201544Seschrock 	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
4211544Seschrock 		exec = B_FALSE;
4221544Seschrock 		do_exec = B_TRUE;
4231544Seschrock 	} else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
4241544Seschrock 		exec = B_TRUE;
4251544Seschrock 		do_exec = B_TRUE;
4261544Seschrock 	}
4271544Seschrock 
4281544Seschrock 	/*
4291544Seschrock 	 * Register property callbacks.
4301544Seschrock 	 *
4311544Seschrock 	 * It would probably be fine to just check for i/o error from
4321544Seschrock 	 * the first prop_register(), but I guess I like to go
4331544Seschrock 	 * overboard...
4341544Seschrock 	 */
4351544Seschrock 	ds = dmu_objset_ds(os);
4361544Seschrock 	error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs);
4371544Seschrock 	error = error ? error : dsl_prop_register(ds,
4381544Seschrock 	    "recordsize", blksz_changed_cb, zfsvfs);
4391544Seschrock 	error = error ? error : dsl_prop_register(ds,
4401544Seschrock 	    "readonly", readonly_changed_cb, zfsvfs);
4411544Seschrock 	error = error ? error : dsl_prop_register(ds,
4421544Seschrock 	    "devices", devices_changed_cb, zfsvfs);
4431544Seschrock 	error = error ? error : dsl_prop_register(ds,
4441544Seschrock 	    "setuid", setuid_changed_cb, zfsvfs);
4451544Seschrock 	error = error ? error : dsl_prop_register(ds,
4461544Seschrock 	    "exec", exec_changed_cb, zfsvfs);
4471544Seschrock 	error = error ? error : dsl_prop_register(ds,
4481544Seschrock 	    "snapdir", snapdir_changed_cb, zfsvfs);
4491544Seschrock 	error = error ? error : dsl_prop_register(ds,
4501544Seschrock 	    "aclmode", acl_mode_changed_cb, zfsvfs);
4511544Seschrock 	error = error ? error : dsl_prop_register(ds,
4521544Seschrock 	    "aclinherit", acl_inherit_changed_cb, zfsvfs);
4531544Seschrock 	if (error)
4541544Seschrock 		goto unregister;
4551544Seschrock 
4561544Seschrock 	/*
4571544Seschrock 	 * Invoke our callbacks to restore temporary mount options.
4581544Seschrock 	 */
4591544Seschrock 	if (do_readonly)
4601544Seschrock 		readonly_changed_cb(zfsvfs, readonly);
4611544Seschrock 	if (do_setuid)
4621544Seschrock 		setuid_changed_cb(zfsvfs, setuid);
4631544Seschrock 	if (do_exec)
4641544Seschrock 		exec_changed_cb(zfsvfs, exec);
4651544Seschrock 	if (do_devices)
4661544Seschrock 		devices_changed_cb(zfsvfs, devices);
4671544Seschrock 
4681544Seschrock 	return (0);
4691544Seschrock 
4701544Seschrock unregister:
4711544Seschrock 	/*
4721544Seschrock 	 * We may attempt to unregister some callbacks that are not
4731544Seschrock 	 * registered, but this is OK; it will simply return ENOMSG,
4741544Seschrock 	 * which we will ignore.
4751544Seschrock 	 */
4761544Seschrock 	(void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs);
4771544Seschrock 	(void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs);
4781544Seschrock 	(void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs);
4791544Seschrock 	(void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs);
4801544Seschrock 	(void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs);
4811544Seschrock 	(void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs);
4821544Seschrock 	(void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs);
4831544Seschrock 	(void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs);
4841544Seschrock 	(void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,
4851544Seschrock 	    zfsvfs);
4861544Seschrock 	return (error);
4871544Seschrock 
4881544Seschrock }
4891544Seschrock 
4901544Seschrock static int
4911544Seschrock zfs_domount(vfs_t *vfsp, char *osname, cred_t *cr)
4921544Seschrock {
4931544Seschrock 	dev_t mount_dev;
4941544Seschrock 	uint64_t recordsize, readonly;
4951544Seschrock 	int error = 0;
4961544Seschrock 	int mode;
4971544Seschrock 	zfsvfs_t *zfsvfs;
4981544Seschrock 	znode_t *zp = NULL;
4991544Seschrock 
5001544Seschrock 	ASSERT(vfsp);
5011544Seschrock 	ASSERT(osname);
5021544Seschrock 
5031544Seschrock 	/*
5041544Seschrock 	 * Initialize the zfs-specific filesystem structure.
5051544Seschrock 	 * Should probably make this a kmem cache, shuffle fields,
5061544Seschrock 	 * and just bzero up to z_hold_mtx[].
5071544Seschrock 	 */
5081544Seschrock 	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
5091544Seschrock 	zfsvfs->z_vfs = vfsp;
5101544Seschrock 	zfsvfs->z_parent = zfsvfs;
5111544Seschrock 	zfsvfs->z_assign = TXG_NOWAIT;
5121544Seschrock 	zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE;
5131544Seschrock 	zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
5141544Seschrock 
5151544Seschrock 	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
5161544Seschrock 	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
5171544Seschrock 	    offsetof(znode_t, z_link_node));
5181544Seschrock 	rw_init(&zfsvfs->z_um_lock, NULL, RW_DEFAULT, NULL);
5191544Seschrock 
5201544Seschrock 	/* Initialize the generic filesystem structure. */
5211544Seschrock 	vfsp->vfs_bcount = 0;
5221544Seschrock 	vfsp->vfs_data = NULL;
5231544Seschrock 
5241544Seschrock 	if (zfs_create_unique_device(&mount_dev) == -1) {
5251544Seschrock 		error = ENODEV;
5261544Seschrock 		goto out;
5271544Seschrock 	}
5281544Seschrock 	ASSERT(vfs_devismounted(mount_dev) == 0);
5291544Seschrock 
5301544Seschrock 	if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize,
5311544Seschrock 	    NULL))
5321544Seschrock 		goto out;
5331544Seschrock 
5341544Seschrock 	vfsp->vfs_dev = mount_dev;
5351544Seschrock 	vfsp->vfs_fstype = zfsfstype;
5361544Seschrock 	vfsp->vfs_bsize = recordsize;
5371544Seschrock 	vfsp->vfs_flag |= VFS_NOTRUNC;
5381544Seschrock 	vfsp->vfs_data = zfsvfs;
5391544Seschrock 
5401544Seschrock 	if (error = dsl_prop_get_integer(osname, "readonly", &readonly, NULL))
5411544Seschrock 		goto out;
5421544Seschrock 
5431544Seschrock 	if (readonly)
5441544Seschrock 		mode = DS_MODE_PRIMARY | DS_MODE_READONLY;
5451544Seschrock 	else
5461544Seschrock 		mode = DS_MODE_PRIMARY;
5471544Seschrock 
5481544Seschrock 	error = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
5491544Seschrock 	if (error == EROFS) {
5501544Seschrock 		mode = DS_MODE_PRIMARY | DS_MODE_READONLY;
5511544Seschrock 		error = dmu_objset_open(osname, DMU_OST_ZFS, mode,
5521544Seschrock 		    &zfsvfs->z_os);
5531544Seschrock 	}
5541544Seschrock 
5551544Seschrock 	if (error)
5561544Seschrock 		goto out;
5571544Seschrock 
5581544Seschrock 	if (error = zfs_init_fs(zfsvfs, &zp, cr))
5591544Seschrock 		goto out;
5601544Seschrock 
5611544Seschrock 	/* The call to zfs_init_fs leaves the vnode held, release it here. */
5621544Seschrock 	VN_RELE(ZTOV(zp));
5631544Seschrock 
5641544Seschrock 	if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
5651544Seschrock 		ASSERT(mode & DS_MODE_READONLY);
5661544Seschrock 		atime_changed_cb(zfsvfs, B_FALSE);
5671544Seschrock 		readonly_changed_cb(zfsvfs, B_TRUE);
5681544Seschrock 		zfsvfs->z_issnap = B_TRUE;
5691544Seschrock 	} else {
5701544Seschrock 		error = zfs_register_callbacks(vfsp);
5711544Seschrock 		if (error)
5721544Seschrock 			goto out;
5731544Seschrock 
5741544Seschrock 		/*
5751544Seschrock 		 * Start a delete thread running.
5761544Seschrock 		 */
5771544Seschrock 		(void) zfs_delete_thread_target(zfsvfs, 1);
5781544Seschrock 
5791544Seschrock 		/*
5801544Seschrock 		 * Parse and replay the intent log.
5811544Seschrock 		 */
5821544Seschrock 		zil_replay(zfsvfs->z_os, zfsvfs, &zfsvfs->z_assign,
5831544Seschrock 		    zfs_replay_vector, (void (*)(void *))zfs_delete_wait_empty);
5841544Seschrock 
5851544Seschrock 		if (!zil_disable)
5861544Seschrock 			zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
5871544Seschrock 	}
5881544Seschrock 
5891544Seschrock 	if (!zfsvfs->z_issnap)
5901544Seschrock 		zfsctl_create(zfsvfs);
5911544Seschrock out:
5921544Seschrock 	if (error) {
5931544Seschrock 		if (zfsvfs->z_os)
5941544Seschrock 			dmu_objset_close(zfsvfs->z_os);
5951544Seschrock 		kmem_free(zfsvfs, sizeof (zfsvfs_t));
5961544Seschrock 	} else {
5971544Seschrock 		atomic_add_32(&zfs_active_fs_count, 1);
5981544Seschrock 	}
5991544Seschrock 
6001544Seschrock 	return (error);
6011544Seschrock 
6021544Seschrock }
6031544Seschrock 
6041544Seschrock void
6051544Seschrock zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
6061544Seschrock {
6071544Seschrock 	objset_t *os = zfsvfs->z_os;
6081544Seschrock 	struct dsl_dataset *ds;
6091544Seschrock 
6101544Seschrock 	/*
6111544Seschrock 	 * Unregister properties.
6121544Seschrock 	 */
6131544Seschrock 	if (!dmu_objset_is_snapshot(os)) {
6141544Seschrock 		ds = dmu_objset_ds(os);
6151544Seschrock 		VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb,
6161544Seschrock 		    zfsvfs) == 0);
6171544Seschrock 
6181544Seschrock 		VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb,
6191544Seschrock 		    zfsvfs) == 0);
6201544Seschrock 
6211544Seschrock 		VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb,
6221544Seschrock 		    zfsvfs) == 0);
6231544Seschrock 
6241544Seschrock 		VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb,
6251544Seschrock 		    zfsvfs) == 0);
6261544Seschrock 
6271544Seschrock 		VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb,
6281544Seschrock 		    zfsvfs) == 0);
6291544Seschrock 
6301544Seschrock 		VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb,
6311544Seschrock 		    zfsvfs) == 0);
6321544Seschrock 
6331544Seschrock 		VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb,
6341544Seschrock 		    zfsvfs) == 0);
6351544Seschrock 
6361544Seschrock 		VERIFY(dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb,
6371544Seschrock 		    zfsvfs) == 0);
6381544Seschrock 
6391544Seschrock 		VERIFY(dsl_prop_unregister(ds, "aclinherit",
6401544Seschrock 		    acl_inherit_changed_cb, zfsvfs) == 0);
6411544Seschrock 	}
6421544Seschrock }
6431544Seschrock 
6441544Seschrock static int
6451544Seschrock zfs_mountroot(vfs_t *vfsp, enum whymountroot why)
6461544Seschrock {
6471544Seschrock 	int error = 0;
6481544Seschrock 	int ret = 0;
6491544Seschrock 	static int zfsrootdone = 0;
6501544Seschrock 	zfsvfs_t *zfsvfs = NULL;
6511544Seschrock 	znode_t *zp = NULL;
6521544Seschrock 	vnode_t *vp = NULL;
6531544Seschrock 
6541544Seschrock 	ASSERT(vfsp);
6551544Seschrock 
6561544Seschrock 	/*
6571544Seschrock 	 * The filesystem that we mount as root is defined in
6581544Seschrock 	 * /etc/system using the zfsroot variable.  The value defined
6591544Seschrock 	 * there is copied early in startup code to zfs_bootpath
6601544Seschrock 	 * (defined in modsysfile.c).
6611544Seschrock 	 */
6621544Seschrock 	if (why == ROOT_INIT) {
6631544Seschrock 		if (zfsrootdone++)
6641544Seschrock 			return (EBUSY);
6651544Seschrock 
6661544Seschrock 		/*
6671544Seschrock 		 * This needs to be done here, so that when we return from
6681544Seschrock 		 * mountroot, the vfs resource name will be set correctly.
6691544Seschrock 		 */
6701544Seschrock 		if (snprintf(rootfs.bo_name, BO_MAXOBJNAME, "%s", zfs_bootpath)
6711544Seschrock 		    >= BO_MAXOBJNAME)
6721544Seschrock 			return (ENAMETOOLONG);
6731544Seschrock 
6741544Seschrock 		if (error = vfs_lock(vfsp))
6751544Seschrock 			return (error);
6761544Seschrock 
6771544Seschrock 		if (error = zfs_domount(vfsp, zfs_bootpath, CRED()))
6781544Seschrock 			goto out;
6791544Seschrock 
6801544Seschrock 		zfsvfs = (zfsvfs_t *)vfsp->vfs_data;
6811544Seschrock 		ASSERT(zfsvfs);
6821544Seschrock 		if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp))
6831544Seschrock 			goto out;
6841544Seschrock 
6851544Seschrock 		vp = ZTOV(zp);
6861544Seschrock 		mutex_enter(&vp->v_lock);
6871544Seschrock 		vp->v_flag |= VROOT;
6881544Seschrock 		mutex_exit(&vp->v_lock);
6891544Seschrock 		rootvp = vp;
6901544Seschrock 
6911544Seschrock 		/*
6921544Seschrock 		 * The zfs_zget call above returns with a hold on vp, we release
6931544Seschrock 		 * it here.
6941544Seschrock 		 */
6951544Seschrock 		VN_RELE(vp);
6961544Seschrock 
6971544Seschrock 		/*
6981544Seschrock 		 * Mount root as readonly initially, it will be remouted
6991544Seschrock 		 * read/write by /lib/svc/method/fs-usr.
7001544Seschrock 		 */
7011544Seschrock 		readonly_changed_cb(vfsp->vfs_data, B_TRUE);
7021544Seschrock 		vfs_add((struct vnode *)0, vfsp,
7031544Seschrock 		    (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0);
7041544Seschrock out:
7051544Seschrock 		vfs_unlock(vfsp);
7061544Seschrock 		ret = (error) ? error : 0;
7071544Seschrock 		return (ret);
7081544Seschrock 
7091544Seschrock 	} else if (why == ROOT_REMOUNT) {
7101544Seschrock 
7111544Seschrock 		readonly_changed_cb(vfsp->vfs_data, B_FALSE);
7121544Seschrock 		vfsp->vfs_flag |= VFS_REMOUNT;
7131544Seschrock 		return (zfs_refresh_properties(vfsp));
7141544Seschrock 
7151544Seschrock 	} else if (why == ROOT_UNMOUNT) {
7161544Seschrock 		zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data);
7171544Seschrock 		(void) zfs_sync(vfsp, 0, 0);
7181544Seschrock 		return (0);
7191544Seschrock 	}
7201544Seschrock 
7211544Seschrock 	/*
7221544Seschrock 	 * if "why" is equal to anything else other than ROOT_INIT,
7231544Seschrock 	 * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it.
7241544Seschrock 	 */
7251544Seschrock 	return (ENOTSUP);
7261544Seschrock }
7271544Seschrock 
728789Sahrens /*ARGSUSED*/
729789Sahrens static int
730789Sahrens zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
731789Sahrens {
732789Sahrens 	char		*osname;
733789Sahrens 	pathname_t	spn;
734789Sahrens 	int		error = 0;
735789Sahrens 	uio_seg_t	fromspace = (uap->flags & MS_SYSSPACE) ?
736789Sahrens 				UIO_SYSSPACE : UIO_USERSPACE;
737789Sahrens 	int		canwrite;
738789Sahrens 
739789Sahrens 	if (mvp->v_type != VDIR)
740789Sahrens 		return (ENOTDIR);
741789Sahrens 
742789Sahrens 	mutex_enter(&mvp->v_lock);
743789Sahrens 	if ((uap->flags & MS_REMOUNT) == 0 &&
744789Sahrens 	    (uap->flags & MS_OVERLAY) == 0 &&
745789Sahrens 	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
746789Sahrens 		mutex_exit(&mvp->v_lock);
747789Sahrens 		return (EBUSY);
748789Sahrens 	}
749789Sahrens 	mutex_exit(&mvp->v_lock);
750789Sahrens 
751789Sahrens 	/*
752789Sahrens 	 * ZFS does not support passing unparsed data in via MS_DATA.
753789Sahrens 	 * Users should use the MS_OPTIONSTR interface; this means
754789Sahrens 	 * that all option parsing is already done and the options struct
755789Sahrens 	 * can be interrogated.
756789Sahrens 	 */
757789Sahrens 	if ((uap->flags & MS_DATA) && uap->datalen > 0)
758789Sahrens 		return (EINVAL);
759789Sahrens 
760789Sahrens 	/*
761789Sahrens 	 * When doing a remount, we simply refresh our temporary properties
762789Sahrens 	 * according to those options set in the current VFS options.
763789Sahrens 	 */
764789Sahrens 	if (uap->flags & MS_REMOUNT) {
7651544Seschrock 		return (zfs_refresh_properties(vfsp));
766789Sahrens 	}
767789Sahrens 
768789Sahrens 	/*
769789Sahrens 	 * Get the objset name (the "special" mount argument).
770789Sahrens 	 */
771789Sahrens 	if (error = pn_get(uap->spec, fromspace, &spn))
772789Sahrens 		return (error);
773789Sahrens 
774789Sahrens 	osname = spn.pn_path;
775789Sahrens 
776789Sahrens 	if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
777789Sahrens 		goto out;
778789Sahrens 
779789Sahrens 	/*
780789Sahrens 	 * Refuse to mount a filesystem if we are in a local zone and the
781789Sahrens 	 * dataset is not visible.
782789Sahrens 	 */
783789Sahrens 	if (!INGLOBALZONE(curproc) &&
784789Sahrens 	    (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {
785789Sahrens 		error = EPERM;
786789Sahrens 		goto out;
787789Sahrens 	}
788789Sahrens 
7891544Seschrock 	error = zfs_domount(vfsp, osname, cr);
790789Sahrens 
791789Sahrens out:
792789Sahrens 	pn_free(&spn);
793789Sahrens 	return (error);
794789Sahrens }
795789Sahrens 
796789Sahrens static int
797789Sahrens zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp)
798789Sahrens {
799789Sahrens 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
800789Sahrens 	dmu_objset_stats_t dstats;
801789Sahrens 	dev32_t d32;
802789Sahrens 
803789Sahrens 	ZFS_ENTER(zfsvfs);
804789Sahrens 
805789Sahrens 	dmu_objset_stats(zfsvfs->z_os, &dstats);
806789Sahrens 
807789Sahrens 	/*
808789Sahrens 	 * The underlying storage pool actually uses multiple block sizes.
809789Sahrens 	 * We report the fragsize as the smallest block size we support,
810789Sahrens 	 * and we report our blocksize as the filesystem's maximum blocksize.
811789Sahrens 	 */
812789Sahrens 	statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT;
813789Sahrens 	statp->f_bsize = zfsvfs->z_max_blksz;
814789Sahrens 
815789Sahrens 	/*
816789Sahrens 	 * The following report "total" blocks of various kinds in the
817789Sahrens 	 * file system, but reported in terms of f_frsize - the
818789Sahrens 	 * "fragment" size.
819789Sahrens 	 */
820789Sahrens 
821789Sahrens 	statp->f_blocks =
822789Sahrens 	    (dstats.dds_space_refd + dstats.dds_available) >> SPA_MINBLOCKSHIFT;
823789Sahrens 	statp->f_bfree = dstats.dds_available >> SPA_MINBLOCKSHIFT;
824789Sahrens 	statp->f_bavail = statp->f_bfree; /* no root reservation */
825789Sahrens 
826789Sahrens 	/*
827789Sahrens 	 * statvfs() should really be called statufs(), because it assumes
828789Sahrens 	 * static metadata.  ZFS doesn't preallocate files, so the best
829789Sahrens 	 * we can do is report the max that could possibly fit in f_files,
830789Sahrens 	 * and that minus the number actually used in f_ffree.
831789Sahrens 	 * For f_ffree, report the smaller of the number of object available
832789Sahrens 	 * and the number of blocks (each object will take at least a block).
833789Sahrens 	 */
834789Sahrens 	statp->f_ffree = MIN(dstats.dds_objects_avail, statp->f_bfree);
835789Sahrens 	statp->f_favail = statp->f_ffree;	/* no "root reservation" */
836789Sahrens 	statp->f_files = statp->f_ffree + dstats.dds_objects_used;
837789Sahrens 
838789Sahrens 	(void) cmpldev(&d32, vfsp->vfs_dev);
839789Sahrens 	statp->f_fsid = d32;
840789Sahrens 
841789Sahrens 	/*
842789Sahrens 	 * We're a zfs filesystem.
843789Sahrens 	 */
844789Sahrens 	(void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
845789Sahrens 
8461123Smarks 	statp->f_flag = vf_to_stf(vfsp->vfs_flag);
847789Sahrens 
848789Sahrens 	statp->f_namemax = ZFS_MAXNAMELEN;
849789Sahrens 
850789Sahrens 	/*
851789Sahrens 	 * We have all of 32 characters to stuff a string here.
852789Sahrens 	 * Is there anything useful we could/should provide?
853789Sahrens 	 */
854789Sahrens 	bzero(statp->f_fstr, sizeof (statp->f_fstr));
855789Sahrens 
856789Sahrens 	ZFS_EXIT(zfsvfs);
857789Sahrens 	return (0);
858789Sahrens }
859789Sahrens 
860789Sahrens static int
861789Sahrens zfs_root(vfs_t *vfsp, vnode_t **vpp)
862789Sahrens {
863789Sahrens 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
864789Sahrens 	znode_t *rootzp;
865789Sahrens 	int error;
866789Sahrens 
867789Sahrens 	ZFS_ENTER(zfsvfs);
868789Sahrens 
869789Sahrens 	error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
870789Sahrens 	if (error == 0)
871789Sahrens 		*vpp = ZTOV(rootzp);
872789Sahrens 
873789Sahrens 	ZFS_EXIT(zfsvfs);
874789Sahrens 	return (error);
875789Sahrens }
876789Sahrens 
877789Sahrens /*ARGSUSED*/
878789Sahrens static int
879789Sahrens zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr)
880789Sahrens {
881789Sahrens 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
882789Sahrens 	int ret;
883789Sahrens 
884789Sahrens 	if ((ret = secpolicy_fs_unmount(cr, vfsp)) != 0)
885789Sahrens 		return (ret);
886789Sahrens 
8871484Sek110237 
8881484Sek110237 	(void) dnlc_purge_vfsp(vfsp, 0);
8891484Sek110237 
890789Sahrens 	/*
891789Sahrens 	 * Unmount any snapshots mounted under .zfs before unmounting the
892789Sahrens 	 * dataset itself.
893789Sahrens 	 */
894789Sahrens 	if (zfsvfs->z_ctldir != NULL &&
895789Sahrens 	    (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0)
896789Sahrens 		return (ret);
897789Sahrens 
898789Sahrens 	if (fflag & MS_FORCE) {
899789Sahrens 		vfsp->vfs_flag |= VFS_UNMOUNTED;
900789Sahrens 		zfsvfs->z_unmounted1 = B_TRUE;
901789Sahrens 
902789Sahrens 		/*
903789Sahrens 		 * Wait for all zfs threads to leave zfs.
904789Sahrens 		 * Grabbing a rwlock as reader in all vops and
905789Sahrens 		 * as writer here doesn't work because it too easy to get
906789Sahrens 		 * multiple reader enters as zfs can re-enter itself.
907789Sahrens 		 * This can lead to deadlock if there is an intervening
908789Sahrens 		 * rw_enter as writer.
909789Sahrens 		 * So a file system threads ref count (z_op_cnt) is used.
910789Sahrens 		 * A polling loop on z_op_cnt may seem inefficient, but
911789Sahrens 		 * - this saves all threads on exit from having to grab a
912789Sahrens 		 *   mutex in order to cv_signal
913789Sahrens 		 * - only occurs on forced unmount in the rare case when
914789Sahrens 		 *   there are outstanding threads within the file system.
915789Sahrens 		 */
916789Sahrens 		while (zfsvfs->z_op_cnt) {
917789Sahrens 			delay(1);
918789Sahrens 		}
919789Sahrens 
920789Sahrens 		zfs_objset_close(zfsvfs);
921789Sahrens 
922789Sahrens 		return (0);
923789Sahrens 	}
924789Sahrens 	/*
925789Sahrens 	 * Stop all delete threads.
926789Sahrens 	 */
927789Sahrens 	(void) zfs_delete_thread_target(zfsvfs, 0);
928789Sahrens 
929789Sahrens 	/*
930789Sahrens 	 * Check the number of active vnodes in the file system.
931789Sahrens 	 * Our count is maintained in the vfs structure, but the number
932789Sahrens 	 * is off by 1 to indicate a hold on the vfs structure itself.
933789Sahrens 	 *
934789Sahrens 	 * The '.zfs' directory maintains a reference of its own, and any active
935789Sahrens 	 * references underneath are reflected in the vnode count.
936789Sahrens 	 */
937789Sahrens 	if (zfsvfs->z_ctldir == NULL) {
938789Sahrens 		if (vfsp->vfs_count > 1) {
939789Sahrens 			if ((zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) == 0)
940789Sahrens 				(void) zfs_delete_thread_target(zfsvfs, 1);
941789Sahrens 			return (EBUSY);
942789Sahrens 		}
943789Sahrens 	} else {
944789Sahrens 		if (vfsp->vfs_count > 2 ||
945789Sahrens 		    (zfsvfs->z_ctldir->v_count > 1 && !(fflag & MS_FORCE))) {
946789Sahrens 			if ((zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) == 0)
947789Sahrens 				(void) zfs_delete_thread_target(zfsvfs, 1);
948789Sahrens 			return (EBUSY);
949789Sahrens 		}
950789Sahrens 	}
951789Sahrens 
952789Sahrens 	vfsp->vfs_flag |= VFS_UNMOUNTED;
953789Sahrens 	zfs_objset_close(zfsvfs);
954789Sahrens 
955789Sahrens 	return (0);
956789Sahrens }
957789Sahrens 
958789Sahrens static int
959789Sahrens zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
960789Sahrens {
961789Sahrens 	zfsvfs_t	*zfsvfs = vfsp->vfs_data;
962789Sahrens 	znode_t		*zp;
963789Sahrens 	uint64_t	object = 0;
964789Sahrens 	uint64_t	fid_gen = 0;
965789Sahrens 	uint64_t	gen_mask;
966789Sahrens 	uint64_t	zp_gen;
967789Sahrens 	int 		i, err;
968789Sahrens 
969789Sahrens 	*vpp = NULL;
970789Sahrens 
971789Sahrens 	ZFS_ENTER(zfsvfs);
972789Sahrens 
973789Sahrens 	if (fidp->fid_len == LONG_FID_LEN) {
974789Sahrens 		zfid_long_t	*zlfid = (zfid_long_t *)fidp;
975789Sahrens 		uint64_t	objsetid = 0;
976789Sahrens 		uint64_t	setgen = 0;
977789Sahrens 
978789Sahrens 		for (i = 0; i < sizeof (zlfid->zf_setid); i++)
979789Sahrens 			objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
980789Sahrens 
981789Sahrens 		for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
982789Sahrens 			setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);
983789Sahrens 
984789Sahrens 		ZFS_EXIT(zfsvfs);
985789Sahrens 
986789Sahrens 		err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
987789Sahrens 		if (err)
988789Sahrens 			return (EINVAL);
989789Sahrens 		ZFS_ENTER(zfsvfs);
990789Sahrens 	}
991789Sahrens 
992789Sahrens 	if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) {
993789Sahrens 		zfid_short_t	*zfid = (zfid_short_t *)fidp;
994789Sahrens 
995789Sahrens 		for (i = 0; i < sizeof (zfid->zf_object); i++)
996789Sahrens 			object |= ((uint64_t)zfid->zf_object[i]) << (8 * i);
997789Sahrens 
998789Sahrens 		for (i = 0; i < sizeof (zfid->zf_gen); i++)
999789Sahrens 			fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
1000789Sahrens 	} else {
1001789Sahrens 		ZFS_EXIT(zfsvfs);
1002789Sahrens 		return (EINVAL);
1003789Sahrens 	}
1004789Sahrens 
1005789Sahrens 	/* A zero fid_gen means we are in the .zfs control directories */
1006789Sahrens 	if (fid_gen == 0 &&
1007789Sahrens 	    (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) {
1008789Sahrens 		*vpp = zfsvfs->z_ctldir;
1009789Sahrens 		ASSERT(*vpp != NULL);
1010789Sahrens 		if (object == ZFSCTL_INO_SNAPDIR) {
1011789Sahrens 			VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL,
1012789Sahrens 			    0, NULL, NULL) == 0);
1013789Sahrens 		} else {
1014789Sahrens 			VN_HOLD(*vpp);
1015789Sahrens 		}
1016789Sahrens 		ZFS_EXIT(zfsvfs);
1017789Sahrens 		return (0);
1018789Sahrens 	}
1019789Sahrens 
1020789Sahrens 	gen_mask = -1ULL >> (64 - 8 * i);
1021789Sahrens 
1022789Sahrens 	dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask);
1023789Sahrens 	if (err = zfs_zget(zfsvfs, object, &zp)) {
1024789Sahrens 		ZFS_EXIT(zfsvfs);
1025789Sahrens 		return (err);
1026789Sahrens 	}
1027789Sahrens 	zp_gen = zp->z_phys->zp_gen & gen_mask;
1028789Sahrens 	if (zp_gen == 0)
1029789Sahrens 		zp_gen = 1;
1030789Sahrens 	if (zp->z_reap || zp_gen != fid_gen) {
1031789Sahrens 		dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
1032789Sahrens 		VN_RELE(ZTOV(zp));
1033789Sahrens 		ZFS_EXIT(zfsvfs);
1034789Sahrens 		return (EINVAL);
1035789Sahrens 	}
1036789Sahrens 
1037789Sahrens 	*vpp = ZTOV(zp);
1038789Sahrens 	ZFS_EXIT(zfsvfs);
1039789Sahrens 	return (0);
1040789Sahrens }
1041789Sahrens 
1042789Sahrens static void
1043789Sahrens zfs_objset_close(zfsvfs_t *zfsvfs)
1044789Sahrens {
1045789Sahrens 	zfs_delete_t	*zd = &zfsvfs->z_delete_head;
1046789Sahrens 	znode_t		*zp, *nextzp;
1047789Sahrens 	objset_t	*os = zfsvfs->z_os;
1048789Sahrens 
1049789Sahrens 	/*
1050789Sahrens 	 * Stop all delete threads.
1051789Sahrens 	 */
1052789Sahrens 	(void) zfs_delete_thread_target(zfsvfs, 0);
1053789Sahrens 
1054789Sahrens 	/*
1055789Sahrens 	 * For forced unmount, at this point all vops except zfs_inactive
1056789Sahrens 	 * are erroring EIO. We need to now suspend zfs_inactive threads
1057789Sahrens 	 * while we are freeing dbufs before switching zfs_inactive
1058789Sahrens 	 * to use behaviour without a objset.
1059789Sahrens 	 */
1060789Sahrens 	rw_enter(&zfsvfs->z_um_lock, RW_WRITER);
1061789Sahrens 
1062789Sahrens 	/*
1063789Sahrens 	 * Release all delete in progress znodes
1064789Sahrens 	 * They will be processed when the file system remounts.
1065789Sahrens 	 */
1066789Sahrens 	mutex_enter(&zd->z_mutex);
1067789Sahrens 	while (zp = list_head(&zd->z_znodes)) {
1068789Sahrens 		list_remove(&zd->z_znodes, zp);
1069789Sahrens 		zp->z_dbuf_held = 0;
10701544Seschrock 		dmu_buf_rele(zp->z_dbuf, NULL);
1071789Sahrens 	}
1072789Sahrens 	mutex_exit(&zd->z_mutex);
1073789Sahrens 
1074789Sahrens 	/*
1075789Sahrens 	 * Release all holds on dbufs
1076789Sahrens 	 * Note, although we have stopped all other vop threads and
1077789Sahrens 	 * zfs_inactive(), the dmu can callback via znode_pageout_func()
1078789Sahrens 	 * which can zfs_znode_free() the znode.
1079789Sahrens 	 * So we lock z_all_znodes; search the list for a held
1080789Sahrens 	 * dbuf; drop the lock (we know zp can't disappear if we hold
1081789Sahrens 	 * a dbuf lock; then regrab the lock and restart.
1082789Sahrens 	 */
1083789Sahrens 	mutex_enter(&zfsvfs->z_znodes_lock);
1084789Sahrens 	for (zp = list_head(&zfsvfs->z_all_znodes); zp; zp = nextzp) {
1085789Sahrens 		nextzp = list_next(&zfsvfs->z_all_znodes, zp);
1086789Sahrens 		if (zp->z_dbuf_held) {
1087789Sahrens 			/* dbufs should only be held when force unmounting */
1088789Sahrens 			zp->z_dbuf_held = 0;
1089789Sahrens 			mutex_exit(&zfsvfs->z_znodes_lock);
10901544Seschrock 			dmu_buf_rele(zp->z_dbuf, NULL);
1091789Sahrens 			/* Start again */
1092789Sahrens 			mutex_enter(&zfsvfs->z_znodes_lock);
1093789Sahrens 			nextzp = list_head(&zfsvfs->z_all_znodes);
1094789Sahrens 		}
1095789Sahrens 	}
1096789Sahrens 	mutex_exit(&zfsvfs->z_znodes_lock);
1097789Sahrens 
1098789Sahrens 	/*
1099789Sahrens 	 * Unregister properties.
1100789Sahrens 	 */
11011544Seschrock 	if (!dmu_objset_is_snapshot(os))
11021544Seschrock 		zfs_unregister_callbacks(zfsvfs);
1103789Sahrens 
1104789Sahrens 	/*
1105789Sahrens 	 * Switch zfs_inactive to behaviour without an objset.
1106789Sahrens 	 * It just tosses cached pages and frees the znode & vnode.
1107789Sahrens 	 * Then re-enable zfs_inactive threads in that new behaviour.
1108789Sahrens 	 */
1109789Sahrens 	zfsvfs->z_unmounted2 = B_TRUE;
1110789Sahrens 	rw_exit(&zfsvfs->z_um_lock); /* re-enable any zfs_inactive threads */
1111789Sahrens 
1112789Sahrens 	/*
1113789Sahrens 	 * Close the zil. Can't close the zil while zfs_inactive
1114789Sahrens 	 * threads are blocked as zil_close can call zfs_inactive.
1115789Sahrens 	 */
1116789Sahrens 	if (zfsvfs->z_log) {
1117789Sahrens 		zil_close(zfsvfs->z_log);
1118789Sahrens 		zfsvfs->z_log = NULL;
1119789Sahrens 	}
1120789Sahrens 
1121789Sahrens 	/*
11221544Seschrock 	 * Evict all dbufs so that cached znodes will be freed
11231544Seschrock 	 */
1124*1646Sperrin 	if (dmu_objset_evict_dbufs(os, 1)) {
1125*1646Sperrin 		txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
1126*1646Sperrin 		(void) dmu_objset_evict_dbufs(os, 0);
1127*1646Sperrin 	}
11281544Seschrock 
11291544Seschrock 	/*
1130789Sahrens 	 * Finally close the objset
1131789Sahrens 	 */
1132789Sahrens 	dmu_objset_close(os);
1133789Sahrens 
11341298Sperrin 	/*
11351298Sperrin 	 * We can now safely destroy the '.zfs' directory node.
11361298Sperrin 	 */
11371298Sperrin 	if (zfsvfs->z_ctldir != NULL)
11381298Sperrin 		zfsctl_destroy(zfsvfs);
11391298Sperrin 
1140789Sahrens }
1141789Sahrens 
1142789Sahrens static void
1143789Sahrens zfs_freevfs(vfs_t *vfsp)
1144789Sahrens {
1145789Sahrens 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1146789Sahrens 
1147789Sahrens 	kmem_free(zfsvfs, sizeof (zfsvfs_t));
1148789Sahrens 
1149789Sahrens 	atomic_add_32(&zfs_active_fs_count, -1);
1150789Sahrens }
1151789Sahrens 
1152789Sahrens /*
1153789Sahrens  * VFS_INIT() initialization.  Note that there is no VFS_FINI(),
1154789Sahrens  * so we can't safely do any non-idempotent initialization here.
1155789Sahrens  * Leave that to zfs_init() and zfs_fini(), which are called
1156789Sahrens  * from the module's _init() and _fini() entry points.
1157789Sahrens  */
1158789Sahrens /*ARGSUSED*/
1159789Sahrens static int
1160789Sahrens zfs_vfsinit(int fstype, char *name)
1161789Sahrens {
1162789Sahrens 	int error;
1163789Sahrens 
1164789Sahrens 	zfsfstype = fstype;
1165789Sahrens 
1166789Sahrens 	/*
1167789Sahrens 	 * Setup vfsops and vnodeops tables.
1168789Sahrens 	 */
1169789Sahrens 	error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops);
1170789Sahrens 	if (error != 0) {
1171789Sahrens 		cmn_err(CE_WARN, "zfs: bad vfs ops template");
1172789Sahrens 	}
1173789Sahrens 
1174789Sahrens 	error = zfs_create_op_tables();
1175789Sahrens 	if (error) {
1176789Sahrens 		zfs_remove_op_tables();
1177789Sahrens 		cmn_err(CE_WARN, "zfs: bad vnode ops template");
1178789Sahrens 		(void) vfs_freevfsops_by_type(zfsfstype);
1179789Sahrens 		return (error);
1180789Sahrens 	}
1181789Sahrens 
1182789Sahrens 	mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL);
1183789Sahrens 
1184789Sahrens 	/*
1185849Sbonwick 	 * Unique major number for all zfs mounts.
1186849Sbonwick 	 * If we run out of 32-bit minors, we'll getudev() another major.
1187789Sahrens 	 */
1188849Sbonwick 	zfs_major = ddi_name_to_major(ZFS_DRIVER);
1189849Sbonwick 	zfs_minor = ZFS_MIN_MINOR;
1190789Sahrens 
1191789Sahrens 	return (0);
1192789Sahrens }
1193789Sahrens 
1194789Sahrens void
1195789Sahrens zfs_init(void)
1196789Sahrens {
1197789Sahrens 	/*
1198789Sahrens 	 * Initialize .zfs directory structures
1199789Sahrens 	 */
1200789Sahrens 	zfsctl_init();
1201789Sahrens 
1202789Sahrens 	/*
1203789Sahrens 	 * Initialize znode cache, vnode ops, etc...
1204789Sahrens 	 */
1205789Sahrens 	zfs_znode_init();
1206789Sahrens }
1207789Sahrens 
1208789Sahrens void
1209789Sahrens zfs_fini(void)
1210789Sahrens {
1211789Sahrens 	zfsctl_fini();
1212789Sahrens 	zfs_znode_fini();
1213789Sahrens }
1214789Sahrens 
1215789Sahrens int
1216789Sahrens zfs_busy(void)
1217789Sahrens {
1218789Sahrens 	return (zfs_active_fs_count != 0);
1219789Sahrens }
1220789Sahrens 
1221789Sahrens static vfsdef_t vfw = {
1222789Sahrens 	VFSDEF_VERSION,
1223789Sahrens 	MNTTYPE_ZFS,
1224789Sahrens 	zfs_vfsinit,
12251488Srsb 	VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_VOLATILEDEV|VSW_STATS,
1226789Sahrens 	&zfs_mntopts
1227789Sahrens };
1228789Sahrens 
1229789Sahrens struct modlfs zfs_modlfs = {
1230789Sahrens 	&mod_fsops, "ZFS filesystem version 1", &vfw
1231789Sahrens };
1232