xref: /titanic_41/usr/src/uts/common/fs/zfs/zfs_vfsops.c (revision 09cb82ca24006b806e9f17e2135eef96364facfe)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <sys/types.h>
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/sysmacros.h>
32 #include <sys/kmem.h>
33 #include <sys/pathname.h>
34 #include <sys/vnode.h>
35 #include <sys/vfs.h>
36 #include <sys/vfs_opreg.h>
37 #include <sys/mntent.h>
38 #include <sys/mount.h>
39 #include <sys/cmn_err.h>
40 #include "fs/fs_subr.h"
41 #include <sys/zfs_znode.h>
42 #include <sys/zfs_dir.h>
43 #include <sys/zil.h>
44 #include <sys/fs/zfs.h>
45 #include <sys/dmu.h>
46 #include <sys/dsl_prop.h>
47 #include <sys/dsl_dataset.h>
48 #include <sys/dsl_deleg.h>
49 #include <sys/spa.h>
50 #include <sys/zap.h>
51 #include <sys/varargs.h>
52 #include <sys/policy.h>
53 #include <sys/atomic.h>
54 #include <sys/mkdev.h>
55 #include <sys/modctl.h>
56 #include <sys/refstr.h>
57 #include <sys/zfs_ioctl.h>
58 #include <sys/zfs_ctldir.h>
59 #include <sys/zfs_fuid.h>
60 #include <sys/bootconf.h>
61 #include <sys/sunddi.h>
62 #include <sys/dnlc.h>
63 #include <sys/dmu_objset.h>
64 #include <sys/spa_boot.h>
65 
66 int zfsfstype;
67 vfsops_t *zfs_vfsops = NULL;
68 static major_t zfs_major;
69 static minor_t zfs_minor;
70 static kmutex_t	zfs_dev_mtx;
71 
72 static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr);
73 static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr);
74 static int zfs_mountroot(vfs_t *vfsp, enum whymountroot);
75 static int zfs_root(vfs_t *vfsp, vnode_t **vpp);
76 static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp);
77 static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp);
78 static void zfs_freevfs(vfs_t *vfsp);
79 
80 static const fs_operation_def_t zfs_vfsops_template[] = {
81 	VFSNAME_MOUNT,		{ .vfs_mount = zfs_mount },
82 	VFSNAME_MOUNTROOT,	{ .vfs_mountroot = zfs_mountroot },
83 	VFSNAME_UNMOUNT,	{ .vfs_unmount = zfs_umount },
84 	VFSNAME_ROOT,		{ .vfs_root = zfs_root },
85 	VFSNAME_STATVFS,	{ .vfs_statvfs = zfs_statvfs },
86 	VFSNAME_SYNC,		{ .vfs_sync = zfs_sync },
87 	VFSNAME_VGET,		{ .vfs_vget = zfs_vget },
88 	VFSNAME_FREEVFS,	{ .vfs_freevfs = zfs_freevfs },
89 	NULL,			NULL
90 };
91 
92 static const fs_operation_def_t zfs_vfsops_eio_template[] = {
93 	VFSNAME_FREEVFS,	{ .vfs_freevfs =  zfs_freevfs },
94 	NULL,			NULL
95 };
96 
97 /*
98  * We need to keep a count of active fs's.
99  * This is necessary to prevent our module
100  * from being unloaded after a umount -f
101  */
102 static uint32_t	zfs_active_fs_count = 0;
103 
104 static char *noatime_cancel[] = { MNTOPT_ATIME, NULL };
105 static char *atime_cancel[] = { MNTOPT_NOATIME, NULL };
106 static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
107 static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
108 
109 /*
110  * MO_DEFAULT is not used since the default value is determined
111  * by the equivalent property.
112  */
113 static mntopt_t mntopts[] = {
114 	{ MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL },
115 	{ MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL },
116 	{ MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL },
117 	{ MNTOPT_ATIME, atime_cancel, NULL, 0, NULL }
118 };
119 
120 static mntopts_t zfs_mntopts = {
121 	sizeof (mntopts) / sizeof (mntopt_t),
122 	mntopts
123 };
124 
125 /*ARGSUSED*/
126 int
127 zfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
128 {
129 	/*
130 	 * Data integrity is job one.  We don't want a compromised kernel
131 	 * writing to the storage pool, so we never sync during panic.
132 	 */
133 	if (panicstr)
134 		return (0);
135 
136 	/*
137 	 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS
138 	 * to sync metadata, which they would otherwise cache indefinitely.
139 	 * Semantically, the only requirement is that the sync be initiated.
140 	 * The DMU syncs out txgs frequently, so there's nothing to do.
141 	 */
142 	if (flag & SYNC_ATTR)
143 		return (0);
144 
145 	if (vfsp != NULL) {
146 		/*
147 		 * Sync a specific filesystem.
148 		 */
149 		zfsvfs_t *zfsvfs = vfsp->vfs_data;
150 
151 		ZFS_ENTER(zfsvfs);
152 		if (zfsvfs->z_log != NULL)
153 			zil_commit(zfsvfs->z_log, UINT64_MAX, 0);
154 		else
155 			txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
156 		ZFS_EXIT(zfsvfs);
157 	} else {
158 		/*
159 		 * Sync all ZFS filesystems.  This is what happens when you
160 		 * run sync(1M).  Unlike other filesystems, ZFS honors the
161 		 * request by waiting for all pools to commit all dirty data.
162 		 */
163 		spa_sync_allpools();
164 	}
165 
166 	return (0);
167 }
168 
169 static int
170 zfs_create_unique_device(dev_t *dev)
171 {
172 	major_t new_major;
173 
174 	do {
175 		ASSERT3U(zfs_minor, <=, MAXMIN32);
176 		minor_t start = zfs_minor;
177 		do {
178 			mutex_enter(&zfs_dev_mtx);
179 			if (zfs_minor >= MAXMIN32) {
180 				/*
181 				 * If we're still using the real major
182 				 * keep out of /dev/zfs and /dev/zvol minor
183 				 * number space.  If we're using a getudev()'ed
184 				 * major number, we can use all of its minors.
185 				 */
186 				if (zfs_major == ddi_name_to_major(ZFS_DRIVER))
187 					zfs_minor = ZFS_MIN_MINOR;
188 				else
189 					zfs_minor = 0;
190 			} else {
191 				zfs_minor++;
192 			}
193 			*dev = makedevice(zfs_major, zfs_minor);
194 			mutex_exit(&zfs_dev_mtx);
195 		} while (vfs_devismounted(*dev) && zfs_minor != start);
196 		if (zfs_minor == start) {
197 			/*
198 			 * We are using all ~262,000 minor numbers for the
199 			 * current major number.  Create a new major number.
200 			 */
201 			if ((new_major = getudev()) == (major_t)-1) {
202 				cmn_err(CE_WARN,
203 				    "zfs_mount: Can't get unique major "
204 				    "device number.");
205 				return (-1);
206 			}
207 			mutex_enter(&zfs_dev_mtx);
208 			zfs_major = new_major;
209 			zfs_minor = 0;
210 
211 			mutex_exit(&zfs_dev_mtx);
212 		} else {
213 			break;
214 		}
215 		/* CONSTANTCONDITION */
216 	} while (1);
217 
218 	return (0);
219 }
220 
221 static void
222 atime_changed_cb(void *arg, uint64_t newval)
223 {
224 	zfsvfs_t *zfsvfs = arg;
225 
226 	if (newval == TRUE) {
227 		zfsvfs->z_atime = TRUE;
228 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
229 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
230 	} else {
231 		zfsvfs->z_atime = FALSE;
232 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
233 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
234 	}
235 }
236 
237 static void
238 xattr_changed_cb(void *arg, uint64_t newval)
239 {
240 	zfsvfs_t *zfsvfs = arg;
241 
242 	if (newval == TRUE) {
243 		/* XXX locking on vfs_flag? */
244 		zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;
245 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);
246 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);
247 	} else {
248 		/* XXX locking on vfs_flag? */
249 		zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;
250 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);
251 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);
252 	}
253 }
254 
255 static void
256 blksz_changed_cb(void *arg, uint64_t newval)
257 {
258 	zfsvfs_t *zfsvfs = arg;
259 
260 	if (newval < SPA_MINBLOCKSIZE ||
261 	    newval > SPA_MAXBLOCKSIZE || !ISP2(newval))
262 		newval = SPA_MAXBLOCKSIZE;
263 
264 	zfsvfs->z_max_blksz = newval;
265 	zfsvfs->z_vfs->vfs_bsize = newval;
266 }
267 
268 static void
269 readonly_changed_cb(void *arg, uint64_t newval)
270 {
271 	zfsvfs_t *zfsvfs = arg;
272 
273 	if (newval) {
274 		/* XXX locking on vfs_flag? */
275 		zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
276 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
277 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
278 	} else {
279 		/* XXX locking on vfs_flag? */
280 		zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
281 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
282 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
283 	}
284 }
285 
286 static void
287 devices_changed_cb(void *arg, uint64_t newval)
288 {
289 	zfsvfs_t *zfsvfs = arg;
290 
291 	if (newval == FALSE) {
292 		zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES;
293 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES);
294 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0);
295 	} else {
296 		zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES;
297 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES);
298 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0);
299 	}
300 }
301 
302 static void
303 setuid_changed_cb(void *arg, uint64_t newval)
304 {
305 	zfsvfs_t *zfsvfs = arg;
306 
307 	if (newval == FALSE) {
308 		zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
309 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
310 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
311 	} else {
312 		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
313 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
314 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
315 	}
316 }
317 
318 static void
319 exec_changed_cb(void *arg, uint64_t newval)
320 {
321 	zfsvfs_t *zfsvfs = arg;
322 
323 	if (newval == FALSE) {
324 		zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
325 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
326 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
327 	} else {
328 		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
329 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
330 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
331 	}
332 }
333 
334 /*
335  * The nbmand mount option can be changed at mount time.
336  * We can't allow it to be toggled on live file systems or incorrect
337  * behavior may be seen from cifs clients
338  *
339  * This property isn't registered via dsl_prop_register(), but this callback
340  * will be called when a file system is first mounted
341  */
342 static void
343 nbmand_changed_cb(void *arg, uint64_t newval)
344 {
345 	zfsvfs_t *zfsvfs = arg;
346 	if (newval == FALSE) {
347 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
348 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
349 	} else {
350 		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
351 		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
352 	}
353 }
354 
355 static void
356 snapdir_changed_cb(void *arg, uint64_t newval)
357 {
358 	zfsvfs_t *zfsvfs = arg;
359 
360 	zfsvfs->z_show_ctldir = newval;
361 }
362 
363 static void
364 vscan_changed_cb(void *arg, uint64_t newval)
365 {
366 	zfsvfs_t *zfsvfs = arg;
367 
368 	zfsvfs->z_vscan = newval;
369 }
370 
371 static void
372 acl_mode_changed_cb(void *arg, uint64_t newval)
373 {
374 	zfsvfs_t *zfsvfs = arg;
375 
376 	zfsvfs->z_acl_mode = newval;
377 }
378 
379 static void
380 acl_inherit_changed_cb(void *arg, uint64_t newval)
381 {
382 	zfsvfs_t *zfsvfs = arg;
383 
384 	zfsvfs->z_acl_inherit = newval;
385 }
386 
387 static int
388 zfs_register_callbacks(vfs_t *vfsp)
389 {
390 	struct dsl_dataset *ds = NULL;
391 	objset_t *os = NULL;
392 	zfsvfs_t *zfsvfs = NULL;
393 	uint64_t nbmand;
394 	int readonly, do_readonly = B_FALSE;
395 	int setuid, do_setuid = B_FALSE;
396 	int exec, do_exec = B_FALSE;
397 	int devices, do_devices = B_FALSE;
398 	int xattr, do_xattr = B_FALSE;
399 	int atime, do_atime = B_FALSE;
400 	int error = 0;
401 
402 	ASSERT(vfsp);
403 	zfsvfs = vfsp->vfs_data;
404 	ASSERT(zfsvfs);
405 	os = zfsvfs->z_os;
406 
407 	/*
408 	 * The act of registering our callbacks will destroy any mount
409 	 * options we may have.  In order to enable temporary overrides
410 	 * of mount options, we stash away the current values and
411 	 * restore them after we register the callbacks.
412 	 */
413 	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
414 		readonly = B_TRUE;
415 		do_readonly = B_TRUE;
416 	} else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
417 		readonly = B_FALSE;
418 		do_readonly = B_TRUE;
419 	}
420 	if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
421 		devices = B_FALSE;
422 		setuid = B_FALSE;
423 		do_devices = B_TRUE;
424 		do_setuid = B_TRUE;
425 	} else {
426 		if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {
427 			devices = B_FALSE;
428 			do_devices = B_TRUE;
429 		} else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) {
430 			devices = B_TRUE;
431 			do_devices = B_TRUE;
432 		}
433 
434 		if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
435 			setuid = B_FALSE;
436 			do_setuid = B_TRUE;
437 		} else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
438 			setuid = B_TRUE;
439 			do_setuid = B_TRUE;
440 		}
441 	}
442 	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
443 		exec = B_FALSE;
444 		do_exec = B_TRUE;
445 	} else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
446 		exec = B_TRUE;
447 		do_exec = B_TRUE;
448 	}
449 	if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
450 		xattr = B_FALSE;
451 		do_xattr = B_TRUE;
452 	} else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {
453 		xattr = B_TRUE;
454 		do_xattr = B_TRUE;
455 	}
456 	if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {
457 		atime = B_FALSE;
458 		do_atime = B_TRUE;
459 	} else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {
460 		atime = B_TRUE;
461 		do_atime = B_TRUE;
462 	}
463 
464 	/*
465 	 * nbmand is a special property.  It can only be changed at
466 	 * mount time.
467 	 *
468 	 * This is weird, but it is documented to only be changeable
469 	 * at mount time.
470 	 */
471 	if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
472 		nbmand = B_FALSE;
473 	} else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) {
474 		nbmand = B_TRUE;
475 	} else {
476 		char osname[MAXNAMELEN];
477 
478 		dmu_objset_name(os, osname);
479 		if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand,
480 		    NULL))
481 		return (error);
482 	}
483 
484 	/*
485 	 * Register property callbacks.
486 	 *
487 	 * It would probably be fine to just check for i/o error from
488 	 * the first prop_register(), but I guess I like to go
489 	 * overboard...
490 	 */
491 	ds = dmu_objset_ds(os);
492 	error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs);
493 	error = error ? error : dsl_prop_register(ds,
494 	    "xattr", xattr_changed_cb, zfsvfs);
495 	error = error ? error : dsl_prop_register(ds,
496 	    "recordsize", blksz_changed_cb, zfsvfs);
497 	error = error ? error : dsl_prop_register(ds,
498 	    "readonly", readonly_changed_cb, zfsvfs);
499 	error = error ? error : dsl_prop_register(ds,
500 	    "devices", devices_changed_cb, zfsvfs);
501 	error = error ? error : dsl_prop_register(ds,
502 	    "setuid", setuid_changed_cb, zfsvfs);
503 	error = error ? error : dsl_prop_register(ds,
504 	    "exec", exec_changed_cb, zfsvfs);
505 	error = error ? error : dsl_prop_register(ds,
506 	    "snapdir", snapdir_changed_cb, zfsvfs);
507 	error = error ? error : dsl_prop_register(ds,
508 	    "aclmode", acl_mode_changed_cb, zfsvfs);
509 	error = error ? error : dsl_prop_register(ds,
510 	    "aclinherit", acl_inherit_changed_cb, zfsvfs);
511 	error = error ? error : dsl_prop_register(ds,
512 	    "vscan", vscan_changed_cb, zfsvfs);
513 	if (error)
514 		goto unregister;
515 
516 	/*
517 	 * Invoke our callbacks to restore temporary mount options.
518 	 */
519 	if (do_readonly)
520 		readonly_changed_cb(zfsvfs, readonly);
521 	if (do_setuid)
522 		setuid_changed_cb(zfsvfs, setuid);
523 	if (do_exec)
524 		exec_changed_cb(zfsvfs, exec);
525 	if (do_devices)
526 		devices_changed_cb(zfsvfs, devices);
527 	if (do_xattr)
528 		xattr_changed_cb(zfsvfs, xattr);
529 	if (do_atime)
530 		atime_changed_cb(zfsvfs, atime);
531 
532 	nbmand_changed_cb(zfsvfs, nbmand);
533 
534 	return (0);
535 
536 unregister:
537 	/*
538 	 * We may attempt to unregister some callbacks that are not
539 	 * registered, but this is OK; it will simply return ENOMSG,
540 	 * which we will ignore.
541 	 */
542 	(void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs);
543 	(void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs);
544 	(void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs);
545 	(void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs);
546 	(void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs);
547 	(void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs);
548 	(void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs);
549 	(void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs);
550 	(void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs);
551 	(void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,
552 	    zfsvfs);
553 	(void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zfsvfs);
554 	return (error);
555 
556 }
557 
558 static int
559 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
560 {
561 	uint_t readonly;
562 	int error;
563 
564 	error = zfs_register_callbacks(zfsvfs->z_vfs);
565 	if (error)
566 		return (error);
567 
568 	/*
569 	 * Set the objset user_ptr to track its zfsvfs.
570 	 */
571 	mutex_enter(&zfsvfs->z_os->os->os_user_ptr_lock);
572 	dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
573 	mutex_exit(&zfsvfs->z_os->os->os_user_ptr_lock);
574 
575 	/*
576 	 * If we are not mounting (ie: online recv), then we don't
577 	 * have to worry about replaying the log as we blocked all
578 	 * operations out since we closed the ZIL.
579 	 */
580 	if (mounting) {
581 		/*
582 		 * During replay we remove the read only flag to
583 		 * allow replays to succeed.
584 		 */
585 		readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
586 		if (readonly != 0)
587 			zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
588 		else
589 			zfs_unlinked_drain(zfsvfs);
590 
591 		/*
592 		 * Parse and replay the intent log.
593 		 *
594 		 * Because of ziltest, this must be done after
595 		 * zfs_unlinked_drain().  (Further note: ziltest doesn't
596 		 * use readonly mounts, where zfs_unlinked_drain() isn't
597 		 * called.)  This is because ziltest causes spa_sync()
598 		 * to think it's committed, but actually it is not, so
599 		 * the intent log contains many txg's worth of changes.
600 		 *
601 		 * In particular, if object N is in the unlinked set in
602 		 * the last txg to actually sync, then it could be
603 		 * actually freed in a later txg and then reallocated in
604 		 * a yet later txg.  This would write a "create object
605 		 * N" record to the intent log.  Normally, this would be
606 		 * fine because the spa_sync() would have written out
607 		 * the fact that object N is free, before we could write
608 		 * the "create object N" intent log record.
609 		 *
610 		 * But when we are in ziltest mode, we advance the "open
611 		 * txg" without actually spa_sync()-ing the changes to
612 		 * disk.  So we would see that object N is still
613 		 * allocated and in the unlinked set, and there is an
614 		 * intent log record saying to allocate it.
615 		 */
616 		zil_replay(zfsvfs->z_os, zfsvfs, &zfsvfs->z_assign,
617 		    zfs_replay_vector);
618 
619 		zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */
620 	}
621 
622 	if (!zil_disable)
623 		zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
624 
625 	return (0);
626 }
627 
628 static void
629 zfs_freezfsvfs(zfsvfs_t *zfsvfs)
630 {
631 	mutex_destroy(&zfsvfs->z_znodes_lock);
632 	mutex_destroy(&zfsvfs->z_online_recv_lock);
633 	list_destroy(&zfsvfs->z_all_znodes);
634 	rrw_destroy(&zfsvfs->z_teardown_lock);
635 	rw_destroy(&zfsvfs->z_teardown_inactive_lock);
636 	rw_destroy(&zfsvfs->z_fuid_lock);
637 	kmem_free(zfsvfs, sizeof (zfsvfs_t));
638 }
639 
640 static int
641 zfs_domount(vfs_t *vfsp, char *osname)
642 {
643 	dev_t mount_dev;
644 	uint64_t recordsize, readonly;
645 	int error = 0;
646 	int mode;
647 	zfsvfs_t *zfsvfs;
648 	znode_t *zp = NULL;
649 
650 	ASSERT(vfsp);
651 	ASSERT(osname);
652 
653 	/*
654 	 * Initialize the zfs-specific filesystem structure.
655 	 * Should probably make this a kmem cache, shuffle fields,
656 	 * and just bzero up to z_hold_mtx[].
657 	 */
658 	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
659 	zfsvfs->z_vfs = vfsp;
660 	zfsvfs->z_parent = zfsvfs;
661 	zfsvfs->z_assign = TXG_NOWAIT;
662 	zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE;
663 	zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
664 
665 	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
666 	mutex_init(&zfsvfs->z_online_recv_lock, NULL, MUTEX_DEFAULT, NULL);
667 	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
668 	    offsetof(znode_t, z_link_node));
669 	rrw_init(&zfsvfs->z_teardown_lock);
670 	rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
671 	rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
672 
673 	/* Initialize the generic filesystem structure. */
674 	vfsp->vfs_bcount = 0;
675 	vfsp->vfs_data = NULL;
676 
677 	if (zfs_create_unique_device(&mount_dev) == -1) {
678 		error = ENODEV;
679 		goto out;
680 	}
681 	ASSERT(vfs_devismounted(mount_dev) == 0);
682 
683 	if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize,
684 	    NULL))
685 		goto out;
686 
687 	vfsp->vfs_dev = mount_dev;
688 	vfsp->vfs_fstype = zfsfstype;
689 	vfsp->vfs_bsize = recordsize;
690 	vfsp->vfs_flag |= VFS_NOTRUNC;
691 	vfsp->vfs_data = zfsvfs;
692 
693 	if (error = dsl_prop_get_integer(osname, "readonly", &readonly, NULL))
694 		goto out;
695 
696 	mode = DS_MODE_OWNER;
697 	if (readonly)
698 		mode |= DS_MODE_READONLY;
699 
700 	error = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
701 	if (error == EROFS) {
702 		mode = DS_MODE_OWNER | DS_MODE_READONLY;
703 		error = dmu_objset_open(osname, DMU_OST_ZFS, mode,
704 		    &zfsvfs->z_os);
705 	}
706 
707 	if (error)
708 		goto out;
709 
710 	if (error = zfs_init_fs(zfsvfs, &zp))
711 		goto out;
712 
713 	/* The call to zfs_init_fs leaves the vnode held, release it here. */
714 	VN_RELE(ZTOV(zp));
715 
716 	/*
717 	 * Set features for file system.
718 	 */
719 	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
720 	if (zfsvfs->z_use_fuids) {
721 		vfs_set_feature(vfsp, VFSFT_XVATTR);
722 		vfs_set_feature(vfsp, VFSFT_ACEMASKONACCESS);
723 		vfs_set_feature(vfsp, VFSFT_ACLONCREATE);
724 	}
725 	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
726 		vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
727 		vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
728 		vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE);
729 	} else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
730 		vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
731 		vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
732 	}
733 
734 	if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
735 		uint64_t pval;
736 
737 		ASSERT(mode & DS_MODE_READONLY);
738 		atime_changed_cb(zfsvfs, B_FALSE);
739 		readonly_changed_cb(zfsvfs, B_TRUE);
740 		if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL))
741 			goto out;
742 		xattr_changed_cb(zfsvfs, pval);
743 		zfsvfs->z_issnap = B_TRUE;
744 	} else {
745 		error = zfsvfs_setup(zfsvfs, B_TRUE);
746 	}
747 
748 	if (!zfsvfs->z_issnap)
749 		zfsctl_create(zfsvfs);
750 out:
751 	if (error) {
752 		if (zfsvfs->z_os)
753 			dmu_objset_close(zfsvfs->z_os);
754 		zfs_freezfsvfs(zfsvfs);
755 	} else {
756 		atomic_add_32(&zfs_active_fs_count, 1);
757 	}
758 
759 	return (error);
760 }
761 
762 void
763 zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
764 {
765 	objset_t *os = zfsvfs->z_os;
766 	struct dsl_dataset *ds;
767 
768 	/*
769 	 * Unregister properties.
770 	 */
771 	if (!dmu_objset_is_snapshot(os)) {
772 		ds = dmu_objset_ds(os);
773 		VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb,
774 		    zfsvfs) == 0);
775 
776 		VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb,
777 		    zfsvfs) == 0);
778 
779 		VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb,
780 		    zfsvfs) == 0);
781 
782 		VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb,
783 		    zfsvfs) == 0);
784 
785 		VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb,
786 		    zfsvfs) == 0);
787 
788 		VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb,
789 		    zfsvfs) == 0);
790 
791 		VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb,
792 		    zfsvfs) == 0);
793 
794 		VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb,
795 		    zfsvfs) == 0);
796 
797 		VERIFY(dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb,
798 		    zfsvfs) == 0);
799 
800 		VERIFY(dsl_prop_unregister(ds, "aclinherit",
801 		    acl_inherit_changed_cb, zfsvfs) == 0);
802 
803 		VERIFY(dsl_prop_unregister(ds, "vscan",
804 		    vscan_changed_cb, zfsvfs) == 0);
805 	}
806 }
807 
808 /*
809  * Convert a decimal digit string to a uint64_t integer.
810  */
811 static int
812 str_to_uint64(char *str, uint64_t *objnum)
813 {
814 	uint64_t num = 0;
815 
816 	while (*str) {
817 		if (*str < '0' || *str > '9')
818 			return (EINVAL);
819 
820 		num = num*10 + *str++ - '0';
821 	}
822 
823 	*objnum = num;
824 	return (0);
825 }
826 
827 /*
828  * The boot path passed from the boot loader is in the form of
829  * "rootpool-name/root-filesystem-object-number'. Convert this
830  * string to a dataset name: "rootpool-name/root-filesystem-name".
831  */
832 static int
833 zfs_parse_bootfs(char *bpath, char *outpath)
834 {
835 	char *slashp;
836 	uint64_t objnum;
837 	int error;
838 
839 	if (*bpath == 0 || *bpath == '/')
840 		return (EINVAL);
841 
842 	slashp = strchr(bpath, '/');
843 
844 	/* if no '/', just return the pool name */
845 	if (slashp == NULL) {
846 		(void) strcpy(outpath, bpath);
847 		return (0);
848 	}
849 
850 	if (error = str_to_uint64(slashp+1, &objnum))
851 		return (error);
852 
853 	*slashp = '\0';
854 	error = dsl_dsobj_to_dsname(bpath, objnum, outpath);
855 	*slashp = '/';
856 
857 	return (error);
858 }
859 
860 static int
861 zfs_mountroot(vfs_t *vfsp, enum whymountroot why)
862 {
863 	int error = 0;
864 	static int zfsrootdone = 0;
865 	zfsvfs_t *zfsvfs = NULL;
866 	znode_t *zp = NULL;
867 	vnode_t *vp = NULL;
868 	char *zfs_bootfs;
869 	char *zfs_devid;
870 
871 	ASSERT(vfsp);
872 
873 	/*
874 	 * The filesystem that we mount as root is defined in the
875 	 * boot property "zfs-bootfs" with a format of
876 	 * "poolname/root-dataset-objnum".
877 	 */
878 	if (why == ROOT_INIT) {
879 		if (zfsrootdone++)
880 			return (EBUSY);
881 		/*
882 		 * the process of doing a spa_load will require the
883 		 * clock to be set before we could (for example) do
884 		 * something better by looking at the timestamp on
885 		 * an uberblock, so just set it to -1.
886 		 */
887 		clkset(-1);
888 
889 		if ((zfs_bootfs = spa_get_bootprop("zfs-bootfs")) == NULL) {
890 			cmn_err(CE_NOTE, "spa_get_bootfs: can not get "
891 			    "bootfs name");
892 			return (EINVAL);
893 		}
894 		zfs_devid = spa_get_bootprop("diskdevid");
895 		error = spa_import_rootpool(rootfs.bo_name, zfs_devid);
896 		if (zfs_devid)
897 			spa_free_bootprop(zfs_devid);
898 		if (error) {
899 			spa_free_bootprop(zfs_bootfs);
900 			cmn_err(CE_NOTE, "spa_import_rootpool: error %d",
901 			    error);
902 			return (error);
903 		}
904 		if (error = zfs_parse_bootfs(zfs_bootfs, rootfs.bo_name)) {
905 			spa_free_bootprop(zfs_bootfs);
906 			cmn_err(CE_NOTE, "zfs_parse_bootfs: error %d",
907 			    error);
908 			return (error);
909 		}
910 
911 		spa_free_bootprop(zfs_bootfs);
912 
913 		if (error = vfs_lock(vfsp))
914 			return (error);
915 
916 		if (error = zfs_domount(vfsp, rootfs.bo_name)) {
917 			cmn_err(CE_NOTE, "zfs_domount: error %d", error);
918 			goto out;
919 		}
920 
921 		zfsvfs = (zfsvfs_t *)vfsp->vfs_data;
922 		ASSERT(zfsvfs);
923 		if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) {
924 			cmn_err(CE_NOTE, "zfs_zget: error %d", error);
925 			goto out;
926 		}
927 
928 		vp = ZTOV(zp);
929 		mutex_enter(&vp->v_lock);
930 		vp->v_flag |= VROOT;
931 		mutex_exit(&vp->v_lock);
932 		rootvp = vp;
933 
934 		/*
935 		 * Leave rootvp held.  The root file system is never unmounted.
936 		 */
937 
938 		vfs_add((struct vnode *)0, vfsp,
939 		    (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0);
940 out:
941 		vfs_unlock(vfsp);
942 		return (error);
943 	} else if (why == ROOT_REMOUNT) {
944 		readonly_changed_cb(vfsp->vfs_data, B_FALSE);
945 		vfsp->vfs_flag |= VFS_REMOUNT;
946 
947 		/* refresh mount options */
948 		zfs_unregister_callbacks(vfsp->vfs_data);
949 		return (zfs_register_callbacks(vfsp));
950 
951 	} else if (why == ROOT_UNMOUNT) {
952 		zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data);
953 		(void) zfs_sync(vfsp, 0, 0);
954 		return (0);
955 	}
956 
957 	/*
958 	 * if "why" is equal to anything else other than ROOT_INIT,
959 	 * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it.
960 	 */
961 	return (ENOTSUP);
962 }
963 
964 /*ARGSUSED*/
965 static int
966 zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
967 {
968 	char		*osname;
969 	pathname_t	spn;
970 	int		error = 0;
971 	uio_seg_t	fromspace = (uap->flags & MS_SYSSPACE) ?
972 	    UIO_SYSSPACE : UIO_USERSPACE;
973 	int		canwrite;
974 
975 	if (mvp->v_type != VDIR)
976 		return (ENOTDIR);
977 
978 	mutex_enter(&mvp->v_lock);
979 	if ((uap->flags & MS_REMOUNT) == 0 &&
980 	    (uap->flags & MS_OVERLAY) == 0 &&
981 	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
982 		mutex_exit(&mvp->v_lock);
983 		return (EBUSY);
984 	}
985 	mutex_exit(&mvp->v_lock);
986 
987 	/*
988 	 * ZFS does not support passing unparsed data in via MS_DATA.
989 	 * Users should use the MS_OPTIONSTR interface; this means
990 	 * that all option parsing is already done and the options struct
991 	 * can be interrogated.
992 	 */
993 	if ((uap->flags & MS_DATA) && uap->datalen > 0)
994 		return (EINVAL);
995 
996 	/*
997 	 * Get the objset name (the "special" mount argument).
998 	 */
999 	if (error = pn_get(uap->spec, fromspace, &spn))
1000 		return (error);
1001 
1002 	osname = spn.pn_path;
1003 
1004 	/*
1005 	 * Check for mount privilege?
1006 	 *
1007 	 * If we don't have privilege then see if
1008 	 * we have local permission to allow it
1009 	 */
1010 	error = secpolicy_fs_mount(cr, mvp, vfsp);
1011 	if (error) {
1012 		error = dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr);
1013 		if (error == 0) {
1014 			vattr_t		vattr;
1015 
1016 			/*
1017 			 * Make sure user is the owner of the mount point
1018 			 * or has sufficient privileges.
1019 			 */
1020 
1021 			vattr.va_mask = AT_UID;
1022 
1023 			if (error = VOP_GETATTR(mvp, &vattr, 0, cr, NULL)) {
1024 				goto out;
1025 			}
1026 
1027 			if (secpolicy_vnode_owner(cr, vattr.va_uid) != 0 &&
1028 			    VOP_ACCESS(mvp, VWRITE, 0, cr, NULL) != 0) {
1029 				error = EPERM;
1030 				goto out;
1031 			}
1032 
1033 			secpolicy_fs_mount_clearopts(cr, vfsp);
1034 		} else {
1035 			goto out;
1036 		}
1037 	}
1038 
1039 	/*
1040 	 * Refuse to mount a filesystem if we are in a local zone and the
1041 	 * dataset is not visible.
1042 	 */
1043 	if (!INGLOBALZONE(curproc) &&
1044 	    (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {
1045 		error = EPERM;
1046 		goto out;
1047 	}
1048 
1049 	/*
1050 	 * When doing a remount, we simply refresh our temporary properties
1051 	 * according to those options set in the current VFS options.
1052 	 */
1053 	if (uap->flags & MS_REMOUNT) {
1054 		/* refresh mount options */
1055 		zfs_unregister_callbacks(vfsp->vfs_data);
1056 		error = zfs_register_callbacks(vfsp);
1057 		goto out;
1058 	}
1059 
1060 	error = zfs_domount(vfsp, osname);
1061 
1062 out:
1063 	pn_free(&spn);
1064 	return (error);
1065 }
1066 
1067 static int
1068 zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp)
1069 {
1070 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1071 	dev32_t d32;
1072 	uint64_t refdbytes, availbytes, usedobjs, availobjs;
1073 
1074 	ZFS_ENTER(zfsvfs);
1075 
1076 	dmu_objset_space(zfsvfs->z_os,
1077 	    &refdbytes, &availbytes, &usedobjs, &availobjs);
1078 
1079 	/*
1080 	 * The underlying storage pool actually uses multiple block sizes.
1081 	 * We report the fragsize as the smallest block size we support,
1082 	 * and we report our blocksize as the filesystem's maximum blocksize.
1083 	 */
1084 	statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT;
1085 	statp->f_bsize = zfsvfs->z_max_blksz;
1086 
1087 	/*
1088 	 * The following report "total" blocks of various kinds in the
1089 	 * file system, but reported in terms of f_frsize - the
1090 	 * "fragment" size.
1091 	 */
1092 
1093 	statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT;
1094 	statp->f_bfree = availbytes >> SPA_MINBLOCKSHIFT;
1095 	statp->f_bavail = statp->f_bfree; /* no root reservation */
1096 
1097 	/*
1098 	 * statvfs() should really be called statufs(), because it assumes
1099 	 * static metadata.  ZFS doesn't preallocate files, so the best
1100 	 * we can do is report the max that could possibly fit in f_files,
1101 	 * and that minus the number actually used in f_ffree.
1102 	 * For f_ffree, report the smaller of the number of object available
1103 	 * and the number of blocks (each object will take at least a block).
1104 	 */
1105 	statp->f_ffree = MIN(availobjs, statp->f_bfree);
1106 	statp->f_favail = statp->f_ffree;	/* no "root reservation" */
1107 	statp->f_files = statp->f_ffree + usedobjs;
1108 
1109 	(void) cmpldev(&d32, vfsp->vfs_dev);
1110 	statp->f_fsid = d32;
1111 
1112 	/*
1113 	 * We're a zfs filesystem.
1114 	 */
1115 	(void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
1116 
1117 	statp->f_flag = vf_to_stf(vfsp->vfs_flag);
1118 
1119 	statp->f_namemax = ZFS_MAXNAMELEN;
1120 
1121 	/*
1122 	 * We have all of 32 characters to stuff a string here.
1123 	 * Is there anything useful we could/should provide?
1124 	 */
1125 	bzero(statp->f_fstr, sizeof (statp->f_fstr));
1126 
1127 	ZFS_EXIT(zfsvfs);
1128 	return (0);
1129 }
1130 
1131 static int
1132 zfs_root(vfs_t *vfsp, vnode_t **vpp)
1133 {
1134 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1135 	znode_t *rootzp;
1136 	int error;
1137 
1138 	ZFS_ENTER(zfsvfs);
1139 
1140 	error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
1141 	if (error == 0)
1142 		*vpp = ZTOV(rootzp);
1143 
1144 	ZFS_EXIT(zfsvfs);
1145 	return (error);
1146 }
1147 
1148 /*
1149  * Teardown the zfsvfs::z_os.
1150  *
1151  * Note, if 'unmounting' if FALSE, we return with the 'z_teardown_lock'
1152  * and 'z_teardown_inactive_lock' held.
1153  */
1154 static int
1155 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
1156 {
1157 	znode_t	*zp;
1158 
1159 	rrw_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
1160 
1161 	if (!unmounting) {
1162 		/*
1163 		 * We purge the parent filesystem's vfsp as the parent
1164 		 * filesystem and all of its snapshots have their vnode's
1165 		 * v_vfsp set to the parent's filesystem's vfsp.  Note,
1166 		 * 'z_parent' is self referential for non-snapshots.
1167 		 */
1168 		(void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1169 	}
1170 
1171 	/*
1172 	 * Close the zil. NB: Can't close the zil while zfs_inactive
1173 	 * threads are blocked as zil_close can call zfs_inactive.
1174 	 */
1175 	if (zfsvfs->z_log) {
1176 		zil_close(zfsvfs->z_log);
1177 		zfsvfs->z_log = NULL;
1178 	}
1179 
1180 	rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
1181 
1182 	/*
1183 	 * If we are not unmounting (ie: online recv) and someone already
1184 	 * unmounted this file system while we were doing the switcheroo,
1185 	 * or a reopen of z_os failed then just bail out now.
1186 	 */
1187 	if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
1188 		rw_exit(&zfsvfs->z_teardown_inactive_lock);
1189 		rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1190 		return (EIO);
1191 	}
1192 
1193 	/*
1194 	 * At this point there are no vops active, and any new vops will
1195 	 * fail with EIO since we have z_teardown_lock for writer (only
1196 	 * relavent for forced unmount).
1197 	 *
1198 	 * Release all holds on dbufs.
1199 	 */
1200 	mutex_enter(&zfsvfs->z_znodes_lock);
1201 	for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
1202 	    zp = list_next(&zfsvfs->z_all_znodes, zp))
1203 		if (zp->z_dbuf) {
1204 			ASSERT(ZTOV(zp)->v_count > 0);
1205 			zfs_znode_dmu_fini(zp);
1206 		}
1207 	mutex_exit(&zfsvfs->z_znodes_lock);
1208 
1209 	/*
1210 	 * If we are unmounting, set the unmounted flag and let new vops
1211 	 * unblock.  zfs_inactive will have the unmounted behavior, and all
1212 	 * other vops will fail with EIO.
1213 	 */
1214 	if (unmounting) {
1215 		zfsvfs->z_unmounted = B_TRUE;
1216 		rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1217 		rw_exit(&zfsvfs->z_teardown_inactive_lock);
1218 	}
1219 
1220 	/*
1221 	 * z_os will be NULL if there was an error in attempting to reopen
1222 	 * zfsvfs, so just return as the properties had already been
1223 	 * unregistered and cached data had been evicted before.
1224 	 */
1225 	if (zfsvfs->z_os == NULL)
1226 		return (0);
1227 
1228 	/*
1229 	 * Unregister properties.
1230 	 */
1231 	zfs_unregister_callbacks(zfsvfs);
1232 
1233 	/*
1234 	 * Evict cached data
1235 	 */
1236 	if (dmu_objset_evict_dbufs(zfsvfs->z_os)) {
1237 		txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
1238 		(void) dmu_objset_evict_dbufs(zfsvfs->z_os);
1239 	}
1240 
1241 	return (0);
1242 }
1243 
1244 /*ARGSUSED*/
1245 static int
1246 zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr)
1247 {
1248 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1249 	objset_t *os;
1250 	int ret;
1251 
1252 	ret = secpolicy_fs_unmount(cr, vfsp);
1253 	if (ret) {
1254 		ret = dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource),
1255 		    ZFS_DELEG_PERM_MOUNT, cr);
1256 		if (ret)
1257 			return (ret);
1258 	}
1259 
1260 	/*
1261 	 * We purge the parent filesystem's vfsp as the parent filesystem
1262 	 * and all of its snapshots have their vnode's v_vfsp set to the
1263 	 * parent's filesystem's vfsp.  Note, 'z_parent' is self
1264 	 * referential for non-snapshots.
1265 	 */
1266 	(void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1267 
1268 	/*
1269 	 * Unmount any snapshots mounted under .zfs before unmounting the
1270 	 * dataset itself.
1271 	 */
1272 	if (zfsvfs->z_ctldir != NULL &&
1273 	    (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) {
1274 		return (ret);
1275 	}
1276 
1277 	if (!(fflag & MS_FORCE)) {
1278 		/*
1279 		 * Check the number of active vnodes in the file system.
1280 		 * Our count is maintained in the vfs structure, but the
1281 		 * number is off by 1 to indicate a hold on the vfs
1282 		 * structure itself.
1283 		 *
1284 		 * The '.zfs' directory maintains a reference of its
1285 		 * own, and any active references underneath are
1286 		 * reflected in the vnode count.
1287 		 */
1288 		if (zfsvfs->z_ctldir == NULL) {
1289 			if (vfsp->vfs_count > 1)
1290 				return (EBUSY);
1291 		} else {
1292 			if (vfsp->vfs_count > 2 ||
1293 			    zfsvfs->z_ctldir->v_count > 1)
1294 				return (EBUSY);
1295 		}
1296 	}
1297 
1298 	vfsp->vfs_flag |= VFS_UNMOUNTED;
1299 
1300 	VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
1301 	os = zfsvfs->z_os;
1302 
1303 	/*
1304 	 * z_os will be NULL if there was an error in
1305 	 * attempting to reopen zfsvfs.
1306 	 */
1307 	if (os != NULL) {
1308 		/*
1309 		 * Unset the objset user_ptr.
1310 		 */
1311 		mutex_enter(&os->os->os_user_ptr_lock);
1312 		dmu_objset_set_user(os, NULL);
1313 		mutex_exit(&os->os->os_user_ptr_lock);
1314 
1315 		/*
1316 		 * Finally release the objset
1317 		 */
1318 		dmu_objset_close(os);
1319 	}
1320 
1321 	/*
1322 	 * We can now safely destroy the '.zfs' directory node.
1323 	 */
1324 	if (zfsvfs->z_ctldir != NULL)
1325 		zfsctl_destroy(zfsvfs);
1326 
1327 	return (0);
1328 }
1329 
1330 static int
1331 zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
1332 {
1333 	zfsvfs_t	*zfsvfs = vfsp->vfs_data;
1334 	znode_t		*zp;
1335 	uint64_t	object = 0;
1336 	uint64_t	fid_gen = 0;
1337 	uint64_t	gen_mask;
1338 	uint64_t	zp_gen;
1339 	int 		i, err;
1340 
1341 	*vpp = NULL;
1342 
1343 	ZFS_ENTER(zfsvfs);
1344 
1345 	if (fidp->fid_len == LONG_FID_LEN) {
1346 		zfid_long_t	*zlfid = (zfid_long_t *)fidp;
1347 		uint64_t	objsetid = 0;
1348 		uint64_t	setgen = 0;
1349 
1350 		for (i = 0; i < sizeof (zlfid->zf_setid); i++)
1351 			objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
1352 
1353 		for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
1354 			setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);
1355 
1356 		ZFS_EXIT(zfsvfs);
1357 
1358 		err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
1359 		if (err)
1360 			return (EINVAL);
1361 		ZFS_ENTER(zfsvfs);
1362 	}
1363 
1364 	if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) {
1365 		zfid_short_t	*zfid = (zfid_short_t *)fidp;
1366 
1367 		for (i = 0; i < sizeof (zfid->zf_object); i++)
1368 			object |= ((uint64_t)zfid->zf_object[i]) << (8 * i);
1369 
1370 		for (i = 0; i < sizeof (zfid->zf_gen); i++)
1371 			fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
1372 	} else {
1373 		ZFS_EXIT(zfsvfs);
1374 		return (EINVAL);
1375 	}
1376 
1377 	/* A zero fid_gen means we are in the .zfs control directories */
1378 	if (fid_gen == 0 &&
1379 	    (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) {
1380 		*vpp = zfsvfs->z_ctldir;
1381 		ASSERT(*vpp != NULL);
1382 		if (object == ZFSCTL_INO_SNAPDIR) {
1383 			VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL,
1384 			    0, NULL, NULL, NULL, NULL, NULL) == 0);
1385 		} else {
1386 			VN_HOLD(*vpp);
1387 		}
1388 		ZFS_EXIT(zfsvfs);
1389 		return (0);
1390 	}
1391 
1392 	gen_mask = -1ULL >> (64 - 8 * i);
1393 
1394 	dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask);
1395 	if (err = zfs_zget(zfsvfs, object, &zp)) {
1396 		ZFS_EXIT(zfsvfs);
1397 		return (err);
1398 	}
1399 	zp_gen = zp->z_phys->zp_gen & gen_mask;
1400 	if (zp_gen == 0)
1401 		zp_gen = 1;
1402 	if (zp->z_unlinked || zp_gen != fid_gen) {
1403 		dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
1404 		VN_RELE(ZTOV(zp));
1405 		ZFS_EXIT(zfsvfs);
1406 		return (EINVAL);
1407 	}
1408 
1409 	*vpp = ZTOV(zp);
1410 	ZFS_EXIT(zfsvfs);
1411 	return (0);
1412 }
1413 
1414 /*
1415  * Block out VOPs and close zfsvfs_t::z_os
1416  *
1417  * Note, if successful, then we return with the 'z_teardown_lock' and
1418  * 'z_teardown_inactive_lock' write held.
1419  */
1420 int
1421 zfs_suspend_fs(zfsvfs_t *zfsvfs, char *name, int *mode)
1422 {
1423 	int error;
1424 
1425 	if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
1426 		return (error);
1427 
1428 	*mode = zfsvfs->z_os->os_mode;
1429 	dmu_objset_name(zfsvfs->z_os, name);
1430 	dmu_objset_close(zfsvfs->z_os);
1431 
1432 	return (0);
1433 }
1434 
1435 /*
1436  * Reopen zfsvfs_t::z_os and release VOPs.
1437  */
1438 int
1439 zfs_resume_fs(zfsvfs_t *zfsvfs, const char *osname, int mode)
1440 {
1441 	int err;
1442 
1443 	ASSERT(RRW_WRITE_HELD(&zfsvfs->z_teardown_lock));
1444 	ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
1445 
1446 	err = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
1447 	if (err) {
1448 		zfsvfs->z_os = NULL;
1449 	} else {
1450 		znode_t *zp;
1451 
1452 		VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);
1453 
1454 		/*
1455 		 * Attempt to re-establish all the active znodes with
1456 		 * their dbufs.  If a zfs_rezget() fails, then we'll let
1457 		 * any potential callers discover that via ZFS_ENTER_VERIFY_VP
1458 		 * when they try to use their znode.
1459 		 */
1460 		mutex_enter(&zfsvfs->z_znodes_lock);
1461 		for (zp = list_head(&zfsvfs->z_all_znodes); zp;
1462 		    zp = list_next(&zfsvfs->z_all_znodes, zp)) {
1463 			(void) zfs_rezget(zp);
1464 		}
1465 		mutex_exit(&zfsvfs->z_znodes_lock);
1466 
1467 	}
1468 
1469 	/* release the VOPs */
1470 	rw_exit(&zfsvfs->z_teardown_inactive_lock);
1471 	rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1472 
1473 	if (err) {
1474 		/*
1475 		 * Since we couldn't reopen zfsvfs::z_os, force
1476 		 * unmount this file system.
1477 		 */
1478 		if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0)
1479 			(void) dounmount(zfsvfs->z_vfs, MS_FORCE, CRED());
1480 	}
1481 	return (err);
1482 }
1483 
1484 static void
1485 zfs_freevfs(vfs_t *vfsp)
1486 {
1487 	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1488 	int i;
1489 
1490 	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
1491 		mutex_destroy(&zfsvfs->z_hold_mtx[i]);
1492 
1493 	zfs_fuid_destroy(zfsvfs);
1494 	zfs_freezfsvfs(zfsvfs);
1495 
1496 	atomic_add_32(&zfs_active_fs_count, -1);
1497 }
1498 
1499 /*
1500  * VFS_INIT() initialization.  Note that there is no VFS_FINI(),
1501  * so we can't safely do any non-idempotent initialization here.
1502  * Leave that to zfs_init() and zfs_fini(), which are called
1503  * from the module's _init() and _fini() entry points.
1504  */
1505 /*ARGSUSED*/
1506 static int
1507 zfs_vfsinit(int fstype, char *name)
1508 {
1509 	int error;
1510 
1511 	zfsfstype = fstype;
1512 
1513 	/*
1514 	 * Setup vfsops and vnodeops tables.
1515 	 */
1516 	error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops);
1517 	if (error != 0) {
1518 		cmn_err(CE_WARN, "zfs: bad vfs ops template");
1519 	}
1520 
1521 	error = zfs_create_op_tables();
1522 	if (error) {
1523 		zfs_remove_op_tables();
1524 		cmn_err(CE_WARN, "zfs: bad vnode ops template");
1525 		(void) vfs_freevfsops_by_type(zfsfstype);
1526 		return (error);
1527 	}
1528 
1529 	mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL);
1530 
1531 	/*
1532 	 * Unique major number for all zfs mounts.
1533 	 * If we run out of 32-bit minors, we'll getudev() another major.
1534 	 */
1535 	zfs_major = ddi_name_to_major(ZFS_DRIVER);
1536 	zfs_minor = ZFS_MIN_MINOR;
1537 
1538 	return (0);
1539 }
1540 
1541 void
1542 zfs_init(void)
1543 {
1544 	/*
1545 	 * Initialize .zfs directory structures
1546 	 */
1547 	zfsctl_init();
1548 
1549 	/*
1550 	 * Initialize znode cache, vnode ops, etc...
1551 	 */
1552 	zfs_znode_init();
1553 }
1554 
1555 void
1556 zfs_fini(void)
1557 {
1558 	zfsctl_fini();
1559 	zfs_znode_fini();
1560 }
1561 
1562 int
1563 zfs_busy(void)
1564 {
1565 	return (zfs_active_fs_count != 0);
1566 }
1567 
1568 int
1569 zfs_set_version(const char *name, uint64_t newvers)
1570 {
1571 	int error;
1572 	objset_t *os;
1573 	dmu_tx_t *tx;
1574 	uint64_t curvers;
1575 
1576 	/*
1577 	 * XXX for now, require that the filesystem be unmounted.  Would
1578 	 * be nice to find the zfsvfs_t and just update that if
1579 	 * possible.
1580 	 */
1581 
1582 	if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION)
1583 		return (EINVAL);
1584 
1585 	error = dmu_objset_open(name, DMU_OST_ZFS, DS_MODE_OWNER, &os);
1586 	if (error)
1587 		return (error);
1588 
1589 	error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1590 	    8, 1, &curvers);
1591 	if (error)
1592 		goto out;
1593 	if (newvers < curvers) {
1594 		error = EINVAL;
1595 		goto out;
1596 	}
1597 
1598 	tx = dmu_tx_create(os);
1599 	dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, 0, ZPL_VERSION_STR);
1600 	error = dmu_tx_assign(tx, TXG_WAIT);
1601 	if (error) {
1602 		dmu_tx_abort(tx);
1603 		goto out;
1604 	}
1605 	error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR, 8, 1,
1606 	    &newvers, tx);
1607 
1608 	spa_history_internal_log(LOG_DS_UPGRADE,
1609 	    dmu_objset_spa(os), tx, CRED(),
1610 	    "oldver=%llu newver=%llu dataset = %llu", curvers, newvers,
1611 	    dmu_objset_id(os));
1612 	dmu_tx_commit(tx);
1613 
1614 out:
1615 	dmu_objset_close(os);
1616 	return (error);
1617 }
1618 
1619 /*
1620  * Read a property stored within the master node.
1621  */
1622 int
1623 zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value)
1624 {
1625 	const char *pname;
1626 	int error;
1627 
1628 	/*
1629 	 * Look up the file system's value for the property.  For the
1630 	 * version property, we look up a slightly different string.
1631 	 */
1632 	if (prop == ZFS_PROP_VERSION)
1633 		pname = ZPL_VERSION_STR;
1634 	else
1635 		pname = zfs_prop_to_name(prop);
1636 
1637 	error = zap_lookup(os, MASTER_NODE_OBJ, pname, 8, 1, value);
1638 
1639 	if (error == ENOENT) {
1640 		/* No value set, use the default value */
1641 		switch (prop) {
1642 		case ZFS_PROP_VERSION:
1643 			*value = ZPL_VERSION;
1644 			break;
1645 		case ZFS_PROP_NORMALIZE:
1646 		case ZFS_PROP_UTF8ONLY:
1647 			*value = 0;
1648 			break;
1649 		case ZFS_PROP_CASE:
1650 			*value = ZFS_CASE_SENSITIVE;
1651 			break;
1652 		default:
1653 			return (error);
1654 		}
1655 		error = 0;
1656 	}
1657 	return (error);
1658 }
1659 
1660 static vfsdef_t vfw = {
1661 	VFSDEF_VERSION,
1662 	MNTTYPE_ZFS,
1663 	zfs_vfsinit,
1664 	VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_VOLATILEDEV|VSW_STATS|
1665 	    VSW_XID,
1666 	&zfs_mntopts
1667 };
1668 
1669 struct modlfs zfs_modlfs = {
1670 	&mod_fsops, "ZFS filesystem version " SPA_VERSION_STRING, &vfw
1671 };
1672