PageRenderTime 96ms CodeModel.GetById 3ms app.highlight 79ms RepoModel.GetById 2ms app.codeStats 0ms

/usr/src/uts/common/fs/zfs/zfs_vfsops.c

https://bitbucket.org/osunix/osunix-gate
C | 2303 lines | 1503 code | 326 blank | 474 comment | 397 complexity | 93a155c7638877746adb1d04151f97bc MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * CDDL HEADER START
   3 *
   4 * The contents of this file are subject to the terms of the
   5 * Common Development and Distribution License (the "License").
   6 * You may not use this file except in compliance with the License.
   7 *
   8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9 * or http://www.opensolaris.org/os/licensing.
  10 * See the License for the specific language governing permissions
  11 * and limitations under the License.
  12 *
  13 * When distributing Covered Code, include this CDDL HEADER in each
  14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15 * If applicable, add the following below this CDDL HEADER, with the
  16 * fields enclosed by brackets "[]" replaced with your own identifying
  17 * information: Portions Copyright [yyyy] [name of copyright owner]
  18 *
  19 * CDDL HEADER END
  20 */
  21/*
  22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23 */
  24
  25/* Portions Copyright 2010 Robert Milkowski */
  26
  27#include <sys/types.h>
  28#include <sys/param.h>
  29#include <sys/systm.h>
  30#include <sys/sysmacros.h>
  31#include <sys/kmem.h>
  32#include <sys/pathname.h>
  33#include <sys/vnode.h>
  34#include <sys/vfs.h>
  35#include <sys/vfs_opreg.h>
  36#include <sys/mntent.h>
  37#include <sys/mount.h>
  38#include <sys/cmn_err.h>
  39#include "fs/fs_subr.h"
  40#include <sys/zfs_znode.h>
  41#include <sys/zfs_dir.h>
  42#include <sys/zil.h>
  43#include <sys/fs/zfs.h>
  44#include <sys/dmu.h>
  45#include <sys/dsl_prop.h>
  46#include <sys/dsl_dataset.h>
  47#include <sys/dsl_deleg.h>
  48#include <sys/spa.h>
  49#include <sys/zap.h>
  50#include <sys/sa.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#include <sys/sa.h>
  66#include "zfs_comutil.h"
  67
  68int zfsfstype;
  69vfsops_t *zfs_vfsops = NULL;
  70static major_t zfs_major;
  71static minor_t zfs_minor;
  72static kmutex_t	zfs_dev_mtx;
  73
  74extern int sys_shutdown;
  75
  76static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr);
  77static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr);
  78static int zfs_mountroot(vfs_t *vfsp, enum whymountroot);
  79static int zfs_root(vfs_t *vfsp, vnode_t **vpp);
  80static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp);
  81static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp);
  82static void zfs_freevfs(vfs_t *vfsp);
  83
  84static const fs_operation_def_t zfs_vfsops_template[] = {
  85	VFSNAME_MOUNT,		{ .vfs_mount = zfs_mount },
  86	VFSNAME_MOUNTROOT,	{ .vfs_mountroot = zfs_mountroot },
  87	VFSNAME_UNMOUNT,	{ .vfs_unmount = zfs_umount },
  88	VFSNAME_ROOT,		{ .vfs_root = zfs_root },
  89	VFSNAME_STATVFS,	{ .vfs_statvfs = zfs_statvfs },
  90	VFSNAME_SYNC,		{ .vfs_sync = zfs_sync },
  91	VFSNAME_VGET,		{ .vfs_vget = zfs_vget },
  92	VFSNAME_FREEVFS,	{ .vfs_freevfs = zfs_freevfs },
  93	NULL,			NULL
  94};
  95
  96static const fs_operation_def_t zfs_vfsops_eio_template[] = {
  97	VFSNAME_FREEVFS,	{ .vfs_freevfs =  zfs_freevfs },
  98	NULL,			NULL
  99};
 100
 101/*
 102 * We need to keep a count of active fs's.
 103 * This is necessary to prevent our module
 104 * from being unloaded after a umount -f
 105 */
 106static uint32_t	zfs_active_fs_count = 0;
 107
 108static char *noatime_cancel[] = { MNTOPT_ATIME, NULL };
 109static char *atime_cancel[] = { MNTOPT_NOATIME, NULL };
 110static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
 111static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
 112
 113/*
 114 * MO_DEFAULT is not used since the default value is determined
 115 * by the equivalent property.
 116 */
 117static mntopt_t mntopts[] = {
 118	{ MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL },
 119	{ MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL },
 120	{ MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL },
 121	{ MNTOPT_ATIME, atime_cancel, NULL, 0, NULL }
 122};
 123
 124static mntopts_t zfs_mntopts = {
 125	sizeof (mntopts) / sizeof (mntopt_t),
 126	mntopts
 127};
 128
 129/*ARGSUSED*/
 130int
 131zfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
 132{
 133	/*
 134	 * Data integrity is job one.  We don't want a compromised kernel
 135	 * writing to the storage pool, so we never sync during panic.
 136	 */
 137	if (panicstr)
 138		return (0);
 139
 140	/*
 141	 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS
 142	 * to sync metadata, which they would otherwise cache indefinitely.
 143	 * Semantically, the only requirement is that the sync be initiated.
 144	 * The DMU syncs out txgs frequently, so there's nothing to do.
 145	 */
 146	if (flag & SYNC_ATTR)
 147		return (0);
 148
 149	if (vfsp != NULL) {
 150		/*
 151		 * Sync a specific filesystem.
 152		 */
 153		zfsvfs_t *zfsvfs = vfsp->vfs_data;
 154		dsl_pool_t *dp;
 155
 156		ZFS_ENTER(zfsvfs);
 157		dp = dmu_objset_pool(zfsvfs->z_os);
 158
 159		/*
 160		 * If the system is shutting down, then skip any
 161		 * filesystems which may exist on a suspended pool.
 162		 */
 163		if (sys_shutdown && spa_suspended(dp->dp_spa)) {
 164			ZFS_EXIT(zfsvfs);
 165			return (0);
 166		}
 167
 168		if (zfsvfs->z_log != NULL)
 169			zil_commit(zfsvfs->z_log, 0);
 170
 171		ZFS_EXIT(zfsvfs);
 172	} else {
 173		/*
 174		 * Sync all ZFS filesystems.  This is what happens when you
 175		 * run sync(1M).  Unlike other filesystems, ZFS honors the
 176		 * request by waiting for all pools to commit all dirty data.
 177		 */
 178		spa_sync_allpools();
 179	}
 180
 181	return (0);
 182}
 183
 184static int
 185zfs_create_unique_device(dev_t *dev)
 186{
 187	major_t new_major;
 188
 189	do {
 190		ASSERT3U(zfs_minor, <=, MAXMIN32);
 191		minor_t start = zfs_minor;
 192		do {
 193			mutex_enter(&zfs_dev_mtx);
 194			if (zfs_minor >= MAXMIN32) {
 195				/*
 196				 * If we're still using the real major
 197				 * keep out of /dev/zfs and /dev/zvol minor
 198				 * number space.  If we're using a getudev()'ed
 199				 * major number, we can use all of its minors.
 200				 */
 201				if (zfs_major == ddi_name_to_major(ZFS_DRIVER))
 202					zfs_minor = ZFS_MIN_MINOR;
 203				else
 204					zfs_minor = 0;
 205			} else {
 206				zfs_minor++;
 207			}
 208			*dev = makedevice(zfs_major, zfs_minor);
 209			mutex_exit(&zfs_dev_mtx);
 210		} while (vfs_devismounted(*dev) && zfs_minor != start);
 211		if (zfs_minor == start) {
 212			/*
 213			 * We are using all ~262,000 minor numbers for the
 214			 * current major number.  Create a new major number.
 215			 */
 216			if ((new_major = getudev()) == (major_t)-1) {
 217				cmn_err(CE_WARN,
 218				    "zfs_mount: Can't get unique major "
 219				    "device number.");
 220				return (-1);
 221			}
 222			mutex_enter(&zfs_dev_mtx);
 223			zfs_major = new_major;
 224			zfs_minor = 0;
 225
 226			mutex_exit(&zfs_dev_mtx);
 227		} else {
 228			break;
 229		}
 230		/* CONSTANTCONDITION */
 231	} while (1);
 232
 233	return (0);
 234}
 235
 236static void
 237atime_changed_cb(void *arg, uint64_t newval)
 238{
 239	zfsvfs_t *zfsvfs = arg;
 240
 241	if (newval == TRUE) {
 242		zfsvfs->z_atime = TRUE;
 243		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
 244		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
 245	} else {
 246		zfsvfs->z_atime = FALSE;
 247		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
 248		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
 249	}
 250}
 251
 252static void
 253xattr_changed_cb(void *arg, uint64_t newval)
 254{
 255	zfsvfs_t *zfsvfs = arg;
 256
 257	if (newval == TRUE) {
 258		/* XXX locking on vfs_flag? */
 259		zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;
 260		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);
 261		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);
 262	} else {
 263		/* XXX locking on vfs_flag? */
 264		zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;
 265		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);
 266		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);
 267	}
 268}
 269
 270static void
 271blksz_changed_cb(void *arg, uint64_t newval)
 272{
 273	zfsvfs_t *zfsvfs = arg;
 274
 275	if (newval < SPA_MINBLOCKSIZE ||
 276	    newval > SPA_MAXBLOCKSIZE || !ISP2(newval))
 277		newval = SPA_MAXBLOCKSIZE;
 278
 279	zfsvfs->z_max_blksz = newval;
 280	zfsvfs->z_vfs->vfs_bsize = newval;
 281}
 282
 283static void
 284readonly_changed_cb(void *arg, uint64_t newval)
 285{
 286	zfsvfs_t *zfsvfs = arg;
 287
 288	if (newval) {
 289		/* XXX locking on vfs_flag? */
 290		zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
 291		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
 292		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
 293	} else {
 294		/* XXX locking on vfs_flag? */
 295		zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
 296		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
 297		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
 298	}
 299}
 300
 301static void
 302devices_changed_cb(void *arg, uint64_t newval)
 303{
 304	zfsvfs_t *zfsvfs = arg;
 305
 306	if (newval == FALSE) {
 307		zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES;
 308		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES);
 309		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0);
 310	} else {
 311		zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES;
 312		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES);
 313		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0);
 314	}
 315}
 316
 317static void
 318setuid_changed_cb(void *arg, uint64_t newval)
 319{
 320	zfsvfs_t *zfsvfs = arg;
 321
 322	if (newval == FALSE) {
 323		zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
 324		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
 325		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
 326	} else {
 327		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
 328		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
 329		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
 330	}
 331}
 332
 333static void
 334exec_changed_cb(void *arg, uint64_t newval)
 335{
 336	zfsvfs_t *zfsvfs = arg;
 337
 338	if (newval == FALSE) {
 339		zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
 340		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
 341		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
 342	} else {
 343		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
 344		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
 345		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
 346	}
 347}
 348
 349/*
 350 * The nbmand mount option can be changed at mount time.
 351 * We can't allow it to be toggled on live file systems or incorrect
 352 * behavior may be seen from cifs clients
 353 *
 354 * This property isn't registered via dsl_prop_register(), but this callback
 355 * will be called when a file system is first mounted
 356 */
 357static void
 358nbmand_changed_cb(void *arg, uint64_t newval)
 359{
 360	zfsvfs_t *zfsvfs = arg;
 361	if (newval == FALSE) {
 362		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
 363		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
 364	} else {
 365		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
 366		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
 367	}
 368}
 369
 370static void
 371snapdir_changed_cb(void *arg, uint64_t newval)
 372{
 373	zfsvfs_t *zfsvfs = arg;
 374
 375	zfsvfs->z_show_ctldir = newval;
 376}
 377
 378static void
 379vscan_changed_cb(void *arg, uint64_t newval)
 380{
 381	zfsvfs_t *zfsvfs = arg;
 382
 383	zfsvfs->z_vscan = newval;
 384}
 385
 386static void
 387acl_inherit_changed_cb(void *arg, uint64_t newval)
 388{
 389	zfsvfs_t *zfsvfs = arg;
 390
 391	zfsvfs->z_acl_inherit = newval;
 392}
 393
 394static int
 395zfs_register_callbacks(vfs_t *vfsp)
 396{
 397	struct dsl_dataset *ds = NULL;
 398	objset_t *os = NULL;
 399	zfsvfs_t *zfsvfs = NULL;
 400	uint64_t nbmand;
 401	int readonly, do_readonly = B_FALSE;
 402	int setuid, do_setuid = B_FALSE;
 403	int exec, do_exec = B_FALSE;
 404	int devices, do_devices = B_FALSE;
 405	int xattr, do_xattr = B_FALSE;
 406	int atime, do_atime = B_FALSE;
 407	int error = 0;
 408
 409	ASSERT(vfsp);
 410	zfsvfs = vfsp->vfs_data;
 411	ASSERT(zfsvfs);
 412	os = zfsvfs->z_os;
 413
 414	/*
 415	 * The act of registering our callbacks will destroy any mount
 416	 * options we may have.  In order to enable temporary overrides
 417	 * of mount options, we stash away the current values and
 418	 * restore them after we register the callbacks.
 419	 */
 420	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL) ||
 421	    !spa_writeable(dmu_objset_spa(os))) {
 422		readonly = B_TRUE;
 423		do_readonly = B_TRUE;
 424	} else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
 425		readonly = B_FALSE;
 426		do_readonly = B_TRUE;
 427	}
 428	if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
 429		devices = B_FALSE;
 430		setuid = B_FALSE;
 431		do_devices = B_TRUE;
 432		do_setuid = B_TRUE;
 433	} else {
 434		if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {
 435			devices = B_FALSE;
 436			do_devices = B_TRUE;
 437		} else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) {
 438			devices = B_TRUE;
 439			do_devices = B_TRUE;
 440		}
 441
 442		if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
 443			setuid = B_FALSE;
 444			do_setuid = B_TRUE;
 445		} else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
 446			setuid = B_TRUE;
 447			do_setuid = B_TRUE;
 448		}
 449	}
 450	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
 451		exec = B_FALSE;
 452		do_exec = B_TRUE;
 453	} else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
 454		exec = B_TRUE;
 455		do_exec = B_TRUE;
 456	}
 457	if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
 458		xattr = B_FALSE;
 459		do_xattr = B_TRUE;
 460	} else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {
 461		xattr = B_TRUE;
 462		do_xattr = B_TRUE;
 463	}
 464	if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {
 465		atime = B_FALSE;
 466		do_atime = B_TRUE;
 467	} else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {
 468		atime = B_TRUE;
 469		do_atime = B_TRUE;
 470	}
 471
 472	/*
 473	 * nbmand is a special property.  It can only be changed at
 474	 * mount time.
 475	 *
 476	 * This is weird, but it is documented to only be changeable
 477	 * at mount time.
 478	 */
 479	if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
 480		nbmand = B_FALSE;
 481	} else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) {
 482		nbmand = B_TRUE;
 483	} else {
 484		char osname[MAXNAMELEN];
 485
 486		dmu_objset_name(os, osname);
 487		if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand,
 488		    NULL)) {
 489			return (error);
 490		}
 491	}
 492
 493	/*
 494	 * Register property callbacks.
 495	 *
 496	 * It would probably be fine to just check for i/o error from
 497	 * the first prop_register(), but I guess I like to go
 498	 * overboard...
 499	 */
 500	ds = dmu_objset_ds(os);
 501	error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs);
 502	error = error ? error : dsl_prop_register(ds,
 503	    "xattr", xattr_changed_cb, zfsvfs);
 504	error = error ? error : dsl_prop_register(ds,
 505	    "recordsize", blksz_changed_cb, zfsvfs);
 506	error = error ? error : dsl_prop_register(ds,
 507	    "readonly", readonly_changed_cb, zfsvfs);
 508	error = error ? error : dsl_prop_register(ds,
 509	    "devices", devices_changed_cb, zfsvfs);
 510	error = error ? error : dsl_prop_register(ds,
 511	    "setuid", setuid_changed_cb, zfsvfs);
 512	error = error ? error : dsl_prop_register(ds,
 513	    "exec", exec_changed_cb, zfsvfs);
 514	error = error ? error : dsl_prop_register(ds,
 515	    "snapdir", snapdir_changed_cb, zfsvfs);
 516	error = error ? error : dsl_prop_register(ds,
 517	    "aclinherit", acl_inherit_changed_cb, zfsvfs);
 518	error = error ? error : dsl_prop_register(ds,
 519	    "vscan", vscan_changed_cb, zfsvfs);
 520	if (error)
 521		goto unregister;
 522
 523	/*
 524	 * Invoke our callbacks to restore temporary mount options.
 525	 */
 526	if (do_readonly)
 527		readonly_changed_cb(zfsvfs, readonly);
 528	if (do_setuid)
 529		setuid_changed_cb(zfsvfs, setuid);
 530	if (do_exec)
 531		exec_changed_cb(zfsvfs, exec);
 532	if (do_devices)
 533		devices_changed_cb(zfsvfs, devices);
 534	if (do_xattr)
 535		xattr_changed_cb(zfsvfs, xattr);
 536	if (do_atime)
 537		atime_changed_cb(zfsvfs, atime);
 538
 539	nbmand_changed_cb(zfsvfs, nbmand);
 540
 541	return (0);
 542
 543unregister:
 544	/*
 545	 * We may attempt to unregister some callbacks that are not
 546	 * registered, but this is OK; it will simply return ENOMSG,
 547	 * which we will ignore.
 548	 */
 549	(void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs);
 550	(void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs);
 551	(void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs);
 552	(void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs);
 553	(void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs);
 554	(void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs);
 555	(void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs);
 556	(void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs);
 557	(void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,
 558	    zfsvfs);
 559	(void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zfsvfs);
 560	return (error);
 561
 562}
 563
 564static int
 565zfs_space_delta_cb(dmu_object_type_t bonustype, void *data,
 566    uint64_t *userp, uint64_t *groupp)
 567{
 568	znode_phys_t *znp = data;
 569	int error = 0;
 570
 571	/*
 572	 * Is it a valid type of object to track?
 573	 */
 574	if (bonustype != DMU_OT_ZNODE && bonustype != DMU_OT_SA)
 575		return (ENOENT);
 576
 577	/*
 578	 * If we have a NULL data pointer
 579	 * then assume the id's aren't changing and
 580	 * return EEXIST to the dmu to let it know to
 581	 * use the same ids
 582	 */
 583	if (data == NULL)
 584		return (EEXIST);
 585
 586	if (bonustype == DMU_OT_ZNODE) {
 587		*userp = znp->zp_uid;
 588		*groupp = znp->zp_gid;
 589	} else {
 590		int hdrsize;
 591
 592		ASSERT(bonustype == DMU_OT_SA);
 593		hdrsize = sa_hdrsize(data);
 594
 595		if (hdrsize != 0) {
 596			*userp = *((uint64_t *)((uintptr_t)data + hdrsize +
 597			    SA_UID_OFFSET));
 598			*groupp = *((uint64_t *)((uintptr_t)data + hdrsize +
 599			    SA_GID_OFFSET));
 600		} else {
 601			/*
 602			 * This should only happen for newly created
 603			 * files that haven't had the znode data filled
 604			 * in yet.
 605			 */
 606			*userp = 0;
 607			*groupp = 0;
 608		}
 609	}
 610	return (error);
 611}
 612
 613static void
 614fuidstr_to_sid(zfsvfs_t *zfsvfs, const char *fuidstr,
 615    char *domainbuf, int buflen, uid_t *ridp)
 616{
 617	uint64_t fuid;
 618	const char *domain;
 619
 620	fuid = strtonum(fuidstr, NULL);
 621
 622	domain = zfs_fuid_find_by_idx(zfsvfs, FUID_INDEX(fuid));
 623	if (domain)
 624		(void) strlcpy(domainbuf, domain, buflen);
 625	else
 626		domainbuf[0] = '\0';
 627	*ridp = FUID_RID(fuid);
 628}
 629
 630static uint64_t
 631zfs_userquota_prop_to_obj(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type)
 632{
 633	switch (type) {
 634	case ZFS_PROP_USERUSED:
 635		return (DMU_USERUSED_OBJECT);
 636	case ZFS_PROP_GROUPUSED:
 637		return (DMU_GROUPUSED_OBJECT);
 638	case ZFS_PROP_USERQUOTA:
 639		return (zfsvfs->z_userquota_obj);
 640	case ZFS_PROP_GROUPQUOTA:
 641		return (zfsvfs->z_groupquota_obj);
 642	}
 643	return (0);
 644}
 645
 646int
 647zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
 648    uint64_t *cookiep, void *vbuf, uint64_t *bufsizep)
 649{
 650	int error;
 651	zap_cursor_t zc;
 652	zap_attribute_t za;
 653	zfs_useracct_t *buf = vbuf;
 654	uint64_t obj;
 655
 656	if (!dmu_objset_userspace_present(zfsvfs->z_os))
 657		return (ENOTSUP);
 658
 659	obj = zfs_userquota_prop_to_obj(zfsvfs, type);
 660	if (obj == 0) {
 661		*bufsizep = 0;
 662		return (0);
 663	}
 664
 665	for (zap_cursor_init_serialized(&zc, zfsvfs->z_os, obj, *cookiep);
 666	    (error = zap_cursor_retrieve(&zc, &za)) == 0;
 667	    zap_cursor_advance(&zc)) {
 668		if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) >
 669		    *bufsizep)
 670			break;
 671
 672		fuidstr_to_sid(zfsvfs, za.za_name,
 673		    buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid);
 674
 675		buf->zu_space = za.za_first_integer;
 676		buf++;
 677	}
 678	if (error == ENOENT)
 679		error = 0;
 680
 681	ASSERT3U((uintptr_t)buf - (uintptr_t)vbuf, <=, *bufsizep);
 682	*bufsizep = (uintptr_t)buf - (uintptr_t)vbuf;
 683	*cookiep = zap_cursor_serialize(&zc);
 684	zap_cursor_fini(&zc);
 685	return (error);
 686}
 687
 688/*
 689 * buf must be big enough (eg, 32 bytes)
 690 */
 691static int
 692id_to_fuidstr(zfsvfs_t *zfsvfs, const char *domain, uid_t rid,
 693    char *buf, boolean_t addok)
 694{
 695	uint64_t fuid;
 696	int domainid = 0;
 697
 698	if (domain && domain[0]) {
 699		domainid = zfs_fuid_find_by_domain(zfsvfs, domain, NULL, addok);
 700		if (domainid == -1)
 701			return (ENOENT);
 702	}
 703	fuid = FUID_ENCODE(domainid, rid);
 704	(void) sprintf(buf, "%llx", (longlong_t)fuid);
 705	return (0);
 706}
 707
 708int
 709zfs_userspace_one(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
 710    const char *domain, uint64_t rid, uint64_t *valp)
 711{
 712	char buf[32];
 713	int err;
 714	uint64_t obj;
 715
 716	*valp = 0;
 717
 718	if (!dmu_objset_userspace_present(zfsvfs->z_os))
 719		return (ENOTSUP);
 720
 721	obj = zfs_userquota_prop_to_obj(zfsvfs, type);
 722	if (obj == 0)
 723		return (0);
 724
 725	err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_FALSE);
 726	if (err)
 727		return (err);
 728
 729	err = zap_lookup(zfsvfs->z_os, obj, buf, 8, 1, valp);
 730	if (err == ENOENT)
 731		err = 0;
 732	return (err);
 733}
 734
 735int
 736zfs_set_userquota(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
 737    const char *domain, uint64_t rid, uint64_t quota)
 738{
 739	char buf[32];
 740	int err;
 741	dmu_tx_t *tx;
 742	uint64_t *objp;
 743	boolean_t fuid_dirtied;
 744
 745	if (type != ZFS_PROP_USERQUOTA && type != ZFS_PROP_GROUPQUOTA)
 746		return (EINVAL);
 747
 748	if (zfsvfs->z_version < ZPL_VERSION_USERSPACE)
 749		return (ENOTSUP);
 750
 751	objp = (type == ZFS_PROP_USERQUOTA) ? &zfsvfs->z_userquota_obj :
 752	    &zfsvfs->z_groupquota_obj;
 753
 754	err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_TRUE);
 755	if (err)
 756		return (err);
 757	fuid_dirtied = zfsvfs->z_fuid_dirty;
 758
 759	tx = dmu_tx_create(zfsvfs->z_os);
 760	dmu_tx_hold_zap(tx, *objp ? *objp : DMU_NEW_OBJECT, B_TRUE, NULL);
 761	if (*objp == 0) {
 762		dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE,
 763		    zfs_userquota_prop_prefixes[type]);
 764	}
 765	if (fuid_dirtied)
 766		zfs_fuid_txhold(zfsvfs, tx);
 767	err = dmu_tx_assign(tx, TXG_WAIT);
 768	if (err) {
 769		dmu_tx_abort(tx);
 770		return (err);
 771	}
 772
 773	mutex_enter(&zfsvfs->z_lock);
 774	if (*objp == 0) {
 775		*objp = zap_create(zfsvfs->z_os, DMU_OT_USERGROUP_QUOTA,
 776		    DMU_OT_NONE, 0, tx);
 777		VERIFY(0 == zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
 778		    zfs_userquota_prop_prefixes[type], 8, 1, objp, tx));
 779	}
 780	mutex_exit(&zfsvfs->z_lock);
 781
 782	if (quota == 0) {
 783		err = zap_remove(zfsvfs->z_os, *objp, buf, tx);
 784		if (err == ENOENT)
 785			err = 0;
 786	} else {
 787		err = zap_update(zfsvfs->z_os, *objp, buf, 8, 1, &quota, tx);
 788	}
 789	ASSERT(err == 0);
 790	if (fuid_dirtied)
 791		zfs_fuid_sync(zfsvfs, tx);
 792	dmu_tx_commit(tx);
 793	return (err);
 794}
 795
 796boolean_t
 797zfs_fuid_overquota(zfsvfs_t *zfsvfs, boolean_t isgroup, uint64_t fuid)
 798{
 799	char buf[32];
 800	uint64_t used, quota, usedobj, quotaobj;
 801	int err;
 802
 803	usedobj = isgroup ? DMU_GROUPUSED_OBJECT : DMU_USERUSED_OBJECT;
 804	quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj;
 805
 806	if (quotaobj == 0 || zfsvfs->z_replay)
 807		return (B_FALSE);
 808
 809	(void) sprintf(buf, "%llx", (longlong_t)fuid);
 810	err = zap_lookup(zfsvfs->z_os, quotaobj, buf, 8, 1, &quota);
 811	if (err != 0)
 812		return (B_FALSE);
 813
 814	err = zap_lookup(zfsvfs->z_os, usedobj, buf, 8, 1, &used);
 815	if (err != 0)
 816		return (B_FALSE);
 817	return (used >= quota);
 818}
 819
 820boolean_t
 821zfs_owner_overquota(zfsvfs_t *zfsvfs, znode_t *zp, boolean_t isgroup)
 822{
 823	uint64_t fuid;
 824	uint64_t quotaobj;
 825
 826	quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj;
 827
 828	fuid = isgroup ? zp->z_gid : zp->z_uid;
 829
 830	if (quotaobj == 0 || zfsvfs->z_replay)
 831		return (B_FALSE);
 832
 833	return (zfs_fuid_overquota(zfsvfs, isgroup, fuid));
 834}
 835
 836int
 837zfsvfs_create(const char *osname, zfsvfs_t **zfvp)
 838{
 839	objset_t *os;
 840	zfsvfs_t *zfsvfs;
 841	uint64_t zval;
 842	int i, error;
 843	uint64_t sa_obj;
 844
 845	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
 846
 847	/*
 848	 * We claim to always be readonly so we can open snapshots;
 849	 * other ZPL code will prevent us from writing to snapshots.
 850	 */
 851	error = dmu_objset_own(osname, DMU_OST_ZFS, B_TRUE, zfsvfs, &os);
 852	if (error) {
 853		kmem_free(zfsvfs, sizeof (zfsvfs_t));
 854		return (error);
 855	}
 856
 857	/*
 858	 * Initialize the zfs-specific filesystem structure.
 859	 * Should probably make this a kmem cache, shuffle fields,
 860	 * and just bzero up to z_hold_mtx[].
 861	 */
 862	zfsvfs->z_vfs = NULL;
 863	zfsvfs->z_parent = zfsvfs;
 864	zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE;
 865	zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
 866	zfsvfs->z_os = os;
 867
 868	error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version);
 869	if (error) {
 870		goto out;
 871	} else if (zfsvfs->z_version >
 872	    zfs_zpl_version_map(spa_version(dmu_objset_spa(os)))) {
 873		(void) printf("Can't mount a version %lld file system "
 874		    "on a version %lld pool\n. Pool must be upgraded to mount "
 875		    "this file system.", (u_longlong_t)zfsvfs->z_version,
 876		    (u_longlong_t)spa_version(dmu_objset_spa(os)));
 877		error = ENOTSUP;
 878		goto out;
 879	}
 880	if ((error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &zval)) != 0)
 881		goto out;
 882	zfsvfs->z_norm = (int)zval;
 883
 884	if ((error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &zval)) != 0)
 885		goto out;
 886	zfsvfs->z_utf8 = (zval != 0);
 887
 888	if ((error = zfs_get_zplprop(os, ZFS_PROP_CASE, &zval)) != 0)
 889		goto out;
 890	zfsvfs->z_case = (uint_t)zval;
 891
 892	/*
 893	 * Fold case on file systems that are always or sometimes case
 894	 * insensitive.
 895	 */
 896	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE ||
 897	    zfsvfs->z_case == ZFS_CASE_MIXED)
 898		zfsvfs->z_norm |= U8_TEXTPREP_TOUPPER;
 899
 900	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
 901	zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
 902
 903	if (zfsvfs->z_use_sa) {
 904		/* should either have both of these objects or none */
 905		error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1,
 906		    &sa_obj);
 907		if (error)
 908			return (error);
 909	} else {
 910		/*
 911		 * Pre SA versions file systems should never touch
 912		 * either the attribute registration or layout objects.
 913		 */
 914		sa_obj = 0;
 915	}
 916
 917	error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
 918	    &zfsvfs->z_attr_table);
 919	if (error)
 920		goto out;
 921
 922	if (zfsvfs->z_version >= ZPL_VERSION_SA)
 923		sa_register_update_callback(os, zfs_sa_upgrade);
 924
 925	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1,
 926	    &zfsvfs->z_root);
 927	if (error)
 928		goto out;
 929	ASSERT(zfsvfs->z_root != 0);
 930
 931	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1,
 932	    &zfsvfs->z_unlinkedobj);
 933	if (error)
 934		goto out;
 935
 936	error = zap_lookup(os, MASTER_NODE_OBJ,
 937	    zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA],
 938	    8, 1, &zfsvfs->z_userquota_obj);
 939	if (error && error != ENOENT)
 940		goto out;
 941
 942	error = zap_lookup(os, MASTER_NODE_OBJ,
 943	    zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA],
 944	    8, 1, &zfsvfs->z_groupquota_obj);
 945	if (error && error != ENOENT)
 946		goto out;
 947
 948	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES, 8, 1,
 949	    &zfsvfs->z_fuid_obj);
 950	if (error && error != ENOENT)
 951		goto out;
 952
 953	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SHARES_DIR, 8, 1,
 954	    &zfsvfs->z_shares_dir);
 955	if (error && error != ENOENT)
 956		goto out;
 957
 958	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
 959	mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL);
 960	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
 961	    offsetof(znode_t, z_link_node));
 962	rrw_init(&zfsvfs->z_teardown_lock);
 963	rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
 964	rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
 965	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
 966		mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);
 967
 968	*zfvp = zfsvfs;
 969	return (0);
 970
 971out:
 972	dmu_objset_disown(os, zfsvfs);
 973	*zfvp = NULL;
 974	kmem_free(zfsvfs, sizeof (zfsvfs_t));
 975	return (error);
 976}
 977
 978static int
 979zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
 980{
 981	int error;
 982
 983	error = zfs_register_callbacks(zfsvfs->z_vfs);
 984	if (error)
 985		return (error);
 986
 987	/*
 988	 * Set the objset user_ptr to track its zfsvfs.
 989	 */
 990	mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
 991	dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
 992	mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
 993
 994	zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
 995
 996	/*
 997	 * If we are not mounting (ie: online recv), then we don't
 998	 * have to worry about replaying the log as we blocked all
 999	 * operations out since we closed the ZIL.
1000	 */
1001	if (mounting) {
1002		boolean_t readonly;
1003
1004		/*
1005		 * During replay we remove the read only flag to
1006		 * allow replays to succeed.
1007		 */
1008		readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
1009		if (readonly != 0)
1010			zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
1011		else
1012			zfs_unlinked_drain(zfsvfs);
1013
1014		/*
1015		 * Parse and replay the intent log.
1016		 *
1017		 * Because of ziltest, this must be done after
1018		 * zfs_unlinked_drain().  (Further note: ziltest
1019		 * doesn't use readonly mounts, where
1020		 * zfs_unlinked_drain() isn't called.)  This is because
1021		 * ziltest causes spa_sync() to think it's committed,
1022		 * but actually it is not, so the intent log contains
1023		 * many txg's worth of changes.
1024		 *
1025		 * In particular, if object N is in the unlinked set in
1026		 * the last txg to actually sync, then it could be
1027		 * actually freed in a later txg and then reallocated
1028		 * in a yet later txg.  This would write a "create
1029		 * object N" record to the intent log.  Normally, this
1030		 * would be fine because the spa_sync() would have
1031		 * written out the fact that object N is free, before
1032		 * we could write the "create object N" intent log
1033		 * record.
1034		 *
1035		 * But when we are in ziltest mode, we advance the "open
1036		 * txg" without actually spa_sync()-ing the changes to
1037		 * disk.  So we would see that object N is still
1038		 * allocated and in the unlinked set, and there is an
1039		 * intent log record saying to allocate it.
1040		 */
1041		if (spa_writeable(dmu_objset_spa(zfsvfs->z_os))) {
1042			if (zil_replay_disable) {
1043				zil_destroy(zfsvfs->z_log, B_FALSE);
1044			} else {
1045				zfsvfs->z_replay = B_TRUE;
1046				zil_replay(zfsvfs->z_os, zfsvfs,
1047				    zfs_replay_vector);
1048				zfsvfs->z_replay = B_FALSE;
1049			}
1050		}
1051		zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */
1052	}
1053
1054	return (0);
1055}
1056
1057void
1058zfsvfs_free(zfsvfs_t *zfsvfs)
1059{
1060	int i;
1061	extern krwlock_t zfsvfs_lock; /* in zfs_znode.c */
1062
1063	/*
1064	 * This is a barrier to prevent the filesystem from going away in
1065	 * zfs_znode_move() until we can safely ensure that the filesystem is
1066	 * not unmounted. We consider the filesystem valid before the barrier
1067	 * and invalid after the barrier.
1068	 */
1069	rw_enter(&zfsvfs_lock, RW_READER);
1070	rw_exit(&zfsvfs_lock);
1071
1072	zfs_fuid_destroy(zfsvfs);
1073
1074	mutex_destroy(&zfsvfs->z_znodes_lock);
1075	mutex_destroy(&zfsvfs->z_lock);
1076	list_destroy(&zfsvfs->z_all_znodes);
1077	rrw_destroy(&zfsvfs->z_teardown_lock);
1078	rw_destroy(&zfsvfs->z_teardown_inactive_lock);
1079	rw_destroy(&zfsvfs->z_fuid_lock);
1080	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
1081		mutex_destroy(&zfsvfs->z_hold_mtx[i]);
1082	kmem_free(zfsvfs, sizeof (zfsvfs_t));
1083}
1084
1085static void
1086zfs_set_fuid_feature(zfsvfs_t *zfsvfs)
1087{
1088	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
1089	if (zfsvfs->z_vfs) {
1090		if (zfsvfs->z_use_fuids) {
1091			vfs_set_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
1092			vfs_set_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
1093			vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
1094			vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
1095			vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
1096			vfs_set_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
1097		} else {
1098			vfs_clear_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
1099			vfs_clear_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
1100			vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
1101			vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
1102			vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
1103			vfs_clear_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
1104		}
1105	}
1106	zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
1107}
1108
1109static int
1110zfs_domount(vfs_t *vfsp, char *osname)
1111{
1112	dev_t mount_dev;
1113	uint64_t recordsize, fsid_guid;
1114	int error = 0;
1115	zfsvfs_t *zfsvfs;
1116
1117	ASSERT(vfsp);
1118	ASSERT(osname);
1119
1120	error = zfsvfs_create(osname, &zfsvfs);
1121	if (error)
1122		return (error);
1123	zfsvfs->z_vfs = vfsp;
1124
1125	/* Initialize the generic filesystem structure. */
1126	vfsp->vfs_bcount = 0;
1127	vfsp->vfs_data = NULL;
1128
1129	if (zfs_create_unique_device(&mount_dev) == -1) {
1130		error = ENODEV;
1131		goto out;
1132	}
1133	ASSERT(vfs_devismounted(mount_dev) == 0);
1134
1135	if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize,
1136	    NULL))
1137		goto out;
1138
1139	vfsp->vfs_dev = mount_dev;
1140	vfsp->vfs_fstype = zfsfstype;
1141	vfsp->vfs_bsize = recordsize;
1142	vfsp->vfs_flag |= VFS_NOTRUNC;
1143	vfsp->vfs_data = zfsvfs;
1144
1145	/*
1146	 * The fsid is 64 bits, composed of an 8-bit fs type, which
1147	 * separates our fsid from any other filesystem types, and a
1148	 * 56-bit objset unique ID.  The objset unique ID is unique to
1149	 * all objsets open on this system, provided by unique_create().
1150	 * The 8-bit fs type must be put in the low bits of fsid[1]
1151	 * because that's where other Solaris filesystems put it.
1152	 */
1153	fsid_guid = dmu_objset_fsid_guid(zfsvfs->z_os);
1154	ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0);
1155	vfsp->vfs_fsid.val[0] = fsid_guid;
1156	vfsp->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) |
1157	    zfsfstype & 0xFF;
1158
1159	/*
1160	 * Set features for file system.
1161	 */
1162	zfs_set_fuid_feature(zfsvfs);
1163	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
1164		vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
1165		vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
1166		vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE);
1167	} else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
1168		vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
1169		vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
1170	}
1171	vfs_set_feature(vfsp, VFSFT_ZEROCOPY_SUPPORTED);
1172
1173	if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
1174		uint64_t pval;
1175
1176		atime_changed_cb(zfsvfs, B_FALSE);
1177		readonly_changed_cb(zfsvfs, B_TRUE);
1178		if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL))
1179			goto out;
1180		xattr_changed_cb(zfsvfs, pval);
1181		zfsvfs->z_issnap = B_TRUE;
1182		zfsvfs->z_os->os_sync = ZFS_SYNC_DISABLED;
1183
1184		mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
1185		dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
1186		mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
1187	} else {
1188		error = zfsvfs_setup(zfsvfs, B_TRUE);
1189	}
1190
1191	if (!zfsvfs->z_issnap)
1192		zfsctl_create(zfsvfs);
1193out:
1194	if (error) {
1195		dmu_objset_disown(zfsvfs->z_os, zfsvfs);
1196		zfsvfs_free(zfsvfs);
1197	} else {
1198		atomic_add_32(&zfs_active_fs_count, 1);
1199	}
1200
1201	return (error);
1202}
1203
1204void
1205zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
1206{
1207	objset_t *os = zfsvfs->z_os;
1208	struct dsl_dataset *ds;
1209
1210	/*
1211	 * Unregister properties.
1212	 */
1213	if (!dmu_objset_is_snapshot(os)) {
1214		ds = dmu_objset_ds(os);
1215		VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb,
1216		    zfsvfs) == 0);
1217
1218		VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb,
1219		    zfsvfs) == 0);
1220
1221		VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb,
1222		    zfsvfs) == 0);
1223
1224		VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb,
1225		    zfsvfs) == 0);
1226
1227		VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb,
1228		    zfsvfs) == 0);
1229
1230		VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb,
1231		    zfsvfs) == 0);
1232
1233		VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb,
1234		    zfsvfs) == 0);
1235
1236		VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb,
1237		    zfsvfs) == 0);
1238
1239		VERIFY(dsl_prop_unregister(ds, "aclinherit",
1240		    acl_inherit_changed_cb, zfsvfs) == 0);
1241
1242		VERIFY(dsl_prop_unregister(ds, "vscan",
1243		    vscan_changed_cb, zfsvfs) == 0);
1244	}
1245}
1246
1247/*
1248 * Convert a decimal digit string to a uint64_t integer.
1249 */
1250static int
1251str_to_uint64(char *str, uint64_t *objnum)
1252{
1253	uint64_t num = 0;
1254
1255	while (*str) {
1256		if (*str < '0' || *str > '9')
1257			return (EINVAL);
1258
1259		num = num*10 + *str++ - '0';
1260	}
1261
1262	*objnum = num;
1263	return (0);
1264}
1265
1266/*
1267 * The boot path passed from the boot loader is in the form of
1268 * "rootpool-name/root-filesystem-object-number'. Convert this
1269 * string to a dataset name: "rootpool-name/root-filesystem-name".
1270 */
1271static int
1272zfs_parse_bootfs(char *bpath, char *outpath)
1273{
1274	char *slashp;
1275	uint64_t objnum;
1276	int error;
1277
1278	if (*bpath == 0 || *bpath == '/')
1279		return (EINVAL);
1280
1281	(void) strcpy(outpath, bpath);
1282
1283	slashp = strchr(bpath, '/');
1284
1285	/* if no '/', just return the pool name */
1286	if (slashp == NULL) {
1287		return (0);
1288	}
1289
1290	/* if not a number, just return the root dataset name */
1291	if (str_to_uint64(slashp+1, &objnum)) {
1292		return (0);
1293	}
1294
1295	*slashp = '\0';
1296	error = dsl_dsobj_to_dsname(bpath, objnum, outpath);
1297	*slashp = '/';
1298
1299	return (error);
1300}
1301
1302/*
1303 * zfs_check_global_label:
1304 *	Check that the hex label string is appropriate for the dataset
1305 *	being mounted into the global_zone proper.
1306 *
1307 *	Return an error if the hex label string is not default or
1308 *	admin_low/admin_high.  For admin_low labels, the corresponding
1309 *	dataset must be readonly.
1310 */
1311int
1312zfs_check_global_label(const char *dsname, const char *hexsl)
1313{
1314	if (strcasecmp(hexsl, ZFS_MLSLABEL_DEFAULT) == 0)
1315		return (0);
1316	if (strcasecmp(hexsl, ADMIN_HIGH) == 0)
1317		return (0);
1318	if (strcasecmp(hexsl, ADMIN_LOW) == 0) {
1319		/* must be readonly */
1320		uint64_t rdonly;
1321
1322		if (dsl_prop_get_integer(dsname,
1323		    zfs_prop_to_name(ZFS_PROP_READONLY), &rdonly, NULL))
1324			return (EACCES);
1325		return (rdonly ? 0 : EACCES);
1326	}
1327	return (EACCES);
1328}
1329
1330/*
1331 * zfs_mount_label_policy:
1332 *	Determine whether the mount is allowed according to MAC check.
1333 *	by comparing (where appropriate) label of the dataset against
1334 *	the label of the zone being mounted into.  If the dataset has
1335 *	no label, create one.
1336 *
1337 *	Returns:
1338 *		 0 :	access allowed
1339 *		>0 :	error code, such as EACCES
1340 */
1341static int
1342zfs_mount_label_policy(vfs_t *vfsp, char *osname)
1343{
1344	int		error, retv;
1345	zone_t		*mntzone = NULL;
1346	ts_label_t	*mnt_tsl;
1347	bslabel_t	*mnt_sl;
1348	bslabel_t	ds_sl;
1349	char		ds_hexsl[MAXNAMELEN];
1350
1351	retv = EACCES;				/* assume the worst */
1352
1353	/*
1354	 * Start by getting the dataset label if it exists.
1355	 */
1356	error = dsl_prop_get(osname, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
1357	    1, sizeof (ds_hexsl), &ds_hexsl, NULL);
1358	if (error)
1359		return (EACCES);
1360
1361	/*
1362	 * If labeling is NOT enabled, then disallow the mount of datasets
1363	 * which have a non-default label already.  No other label checks
1364	 * are needed.
1365	 */
1366	if (!is_system_labeled()) {
1367		if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0)
1368			return (0);
1369		return (EACCES);
1370	}
1371
1372	/*
1373	 * Get the label of the mountpoint.  If mounting into the global
1374	 * zone (i.e. mountpoint is not within an active zone and the
1375	 * zoned property is off), the label must be default or
1376	 * admin_low/admin_high only; no other checks are needed.
1377	 */
1378	mntzone = zone_find_by_any_path(refstr_value(vfsp->vfs_mntpt), B_FALSE);
1379	if (mntzone->zone_id == GLOBAL_ZONEID) {
1380		uint64_t zoned;
1381
1382		zone_rele(mntzone);
1383
1384		if (dsl_prop_get_integer(osname,
1385		    zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL))
1386			return (EACCES);
1387		if (!zoned)
1388			return (zfs_check_global_label(osname, ds_hexsl));
1389		else
1390			/*
1391			 * This is the case of a zone dataset being mounted
1392			 * initially, before the zone has been fully created;
1393			 * allow this mount into global zone.
1394			 */
1395			return (0);
1396	}
1397
1398	mnt_tsl = mntzone->zone_slabel;
1399	ASSERT(mnt_tsl != NULL);
1400	label_hold(mnt_tsl);
1401	mnt_sl = label2bslabel(mnt_tsl);
1402
1403	if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0) {
1404		/*
1405		 * The dataset doesn't have a real label, so fabricate one.
1406		 */
1407		char *str = NULL;
1408
1409		if (l_to_str_internal(mnt_sl, &str) == 0 &&
1410		    dsl_prop_set(osname, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
1411		    ZPROP_SRC_LOCAL, 1, strlen(str) + 1, str) == 0)
1412			retv = 0;
1413		if (str != NULL)
1414			kmem_free(str, strlen(str) + 1);
1415	} else if (hexstr_to_label(ds_hexsl, &ds_sl) == 0) {
1416		/*
1417		 * Now compare labels to complete the MAC check.  If the
1418		 * labels are equal then allow access.  If the mountpoint
1419		 * label dominates the dataset label, allow readonly access.
1420		 * Otherwise, access is denied.
1421		 */
1422		if (blequal(mnt_sl, &ds_sl))
1423			retv = 0;
1424		else if (bldominates(mnt_sl, &ds_sl)) {
1425			vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1426			retv = 0;
1427		}
1428	}
1429
1430	label_rele(mnt_tsl);
1431	zone_rele(mntzone);
1432	return (retv);
1433}
1434
1435static int
1436zfs_mountroot(vfs_t *vfsp, enum whymountroot why)
1437{
1438	int error = 0;
1439	static int zfsrootdone = 0;
1440	zfsvfs_t *zfsvfs = NULL;
1441	znode_t *zp = NULL;
1442	vnode_t *vp = NULL;
1443	char *zfs_bootfs;
1444	char *zfs_devid;
1445
1446	ASSERT(vfsp);
1447
1448	/*
1449	 * The filesystem that we mount as root is defined in the
1450	 * boot property "zfs-bootfs" with a format of
1451	 * "poolname/root-dataset-objnum".
1452	 */
1453	if (why == ROOT_INIT) {
1454		if (zfsrootdone++)
1455			return (EBUSY);
1456		/*
1457		 * the process of doing a spa_load will require the
1458		 * clock to be set before we could (for example) do
1459		 * something better by looking at the timestamp on
1460		 * an uberblock, so just set it to -1.
1461		 */
1462		clkset(-1);
1463
1464		if ((zfs_bootfs = spa_get_bootprop("zfs-bootfs")) == NULL) {
1465			cmn_err(CE_NOTE, "spa_get_bootfs: can not get "
1466			    "bootfs name");
1467			return (EINVAL);
1468		}
1469		zfs_devid = spa_get_bootprop("diskdevid");
1470		error = spa_import_rootpool(rootfs.bo_name, zfs_devid);
1471		if (zfs_devid)
1472			spa_free_bootprop(zfs_devid);
1473		if (error) {
1474			spa_free_bootprop(zfs_bootfs);
1475			cmn_err(CE_NOTE, "spa_import_rootpool: error %d",
1476			    error);
1477			return (error);
1478		}
1479		if (error = zfs_parse_bootfs(zfs_bootfs, rootfs.bo_name)) {
1480			spa_free_bootprop(zfs_bootfs);
1481			cmn_err(CE_NOTE, "zfs_parse_bootfs: error %d",
1482			    error);
1483			return (error);
1484		}
1485
1486		spa_free_bootprop(zfs_bootfs);
1487
1488		if (error = vfs_lock(vfsp))
1489			return (error);
1490
1491		if (error = zfs_domount(vfsp, rootfs.bo_name)) {
1492			cmn_err(CE_NOTE, "zfs_domount: error %d", error);
1493			goto out;
1494		}
1495
1496		zfsvfs = (zfsvfs_t *)vfsp->vfs_data;
1497		ASSERT(zfsvfs);
1498		if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) {
1499			cmn_err(CE_NOTE, "zfs_zget: error %d", error);
1500			goto out;
1501		}
1502
1503		vp = ZTOV(zp);
1504		mutex_enter(&vp->v_lock);
1505		vp->v_flag |= VROOT;
1506		mutex_exit(&vp->v_lock);
1507		rootvp = vp;
1508
1509		/*
1510		 * Leave rootvp held.  The root file system is never unmounted.
1511		 */
1512
1513		vfs_add((struct vnode *)0, vfsp,
1514		    (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0);
1515out:
1516		vfs_unlock(vfsp);
1517		return (error);
1518	} else if (why == ROOT_REMOUNT) {
1519		readonly_changed_cb(vfsp->vfs_data, B_FALSE);
1520		vfsp->vfs_flag |= VFS_REMOUNT;
1521
1522		/* refresh mount options */
1523		zfs_unregister_callbacks(vfsp->vfs_data);
1524		return (zfs_register_callbacks(vfsp));
1525
1526	} else if (why == ROOT_UNMOUNT) {
1527		zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data);
1528		(void) zfs_sync(vfsp, 0, 0);
1529		return (0);
1530	}
1531
1532	/*
1533	 * if "why" is equal to anything else other than ROOT_INIT,
1534	 * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it.
1535	 */
1536	return (ENOTSUP);
1537}
1538
1539/*ARGSUSED*/
1540static int
1541zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
1542{
1543	char		*osname;
1544	pathname_t	spn;
1545	int		error = 0;
1546	uio_seg_t	fromspace = (uap->flags & MS_SYSSPACE) ?
1547	    UIO_SYSSPACE : UIO_USERSPACE;
1548	int		canwrite;
1549
1550	if (mvp->v_type != VDIR)
1551		return (ENOTDIR);
1552
1553	mutex_enter(&mvp->v_lock);
1554	if ((uap->flags & MS_REMOUNT) == 0 &&
1555	    (uap->flags & MS_OVERLAY) == 0 &&
1556	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
1557		mutex_exit(&mvp->v_lock);
1558		return (EBUSY);
1559	}
1560	mutex_exit(&mvp->v_lock);
1561
1562	/*
1563	 * ZFS does not support passing unparsed data in via MS_DATA.
1564	 * Users should use the MS_OPTIONSTR interface; this means
1565	 * that all option parsing is already done and the options struct
1566	 * can be interrogated.
1567	 */
1568	if ((uap->flags & MS_DATA) && uap->datalen > 0)
1569		return (EINVAL);
1570
1571	/*
1572	 * Get the objset name (the "special" mount argument).
1573	 */
1574	if (error = pn_get(uap->spec, fromspace, &spn))
1575		return (error);
1576
1577	osname = spn.pn_path;
1578
1579	/*
1580	 * Check for mount privilege?
1581	 *
1582	 * If we don't have privilege then see if
1583	 * we have local permission to allow it
1584	 */
1585	error = secpolicy_fs_mount(cr, mvp, vfsp);
1586	if (error) {
1587		if (dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) == 0) {
1588			vattr_t		vattr;
1589
1590			/*
1591			 * Make sure user is the owner of the mount point
1592			 * or has sufficient privileges.
1593			 */
1594
1595			vattr.va_mask = AT_UID;
1596
1597			if (VOP_GETATTR(mvp, &vattr, 0, cr, NULL)) {
1598				goto out;
1599			}
1600
1601			if (secpolicy_vnode_owner(cr, vattr.va_uid) != 0 &&
1602			    VOP_ACCESS(mvp, VWRITE, 0, cr, NULL) != 0) {
1603				goto out;
1604			}
1605			secpolicy_fs_mount_clearopts(cr, vfsp);
1606		} else {
1607			goto out;
1608		}
1609	}
1610
1611	/*
1612	 * Refuse to mount a filesystem if we are in a local zone and the
1613	 * dataset is not visible.
1614	 */
1615	if (!INGLOBALZONE(curproc) &&
1616	    (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {
1617		error = EPERM;
1618		goto out;
1619	}
1620
1621	error = zfs_mount_label_policy(vfsp, osname);
1622	if (error)
1623		goto out;
1624
1625	/*
1626	 * When doing a remount, we simply refresh our temporary properties
1627	 * according to those options set in the current VFS options.
1628	 */
1629	if (uap->flags & MS_REMOUNT) {
1630		/* refresh mount options */
1631		zfs_unregister_callbacks(vfsp->vfs_data);
1632		error = zfs_register_callbacks(vfsp);
1633		goto out;
1634	}
1635
1636	error = zfs_domount(vfsp, osname);
1637
1638	/*
1639	 * Add an extra VFS_HOLD on our parent vfs so that it can't
1640	 * disappear due to a forced unmount.
1641	 */
1642	if (error == 0 && ((zfsvfs_t *)vfsp->vfs_data)->z_issnap)
1643		VFS_HOLD(mvp->v_vfsp);
1644
1645out:
1646	pn_free(&spn);
1647	return (error);
1648}
1649
1650static int
1651zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp)
1652{
1653	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1654	dev32_t d32;
1655	uint64_t refdbytes, availbytes, usedobjs, availobjs;
1656
1657	ZFS_ENTER(zfsvfs);
1658
1659	dmu_objset_space(zfsvfs->z_os,
1660	    &refdbytes, &availbytes, &usedobjs, &availobjs);
1661
1662	/*
1663	 * The underlying storage pool actually uses multiple block sizes.
1664	 * We report the fragsize as the smallest block size we support,
1665	 * and we report our blocksize as the filesystem's maximum blocksize.
1666	 */
1667	statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT;
1668	statp->f_bsize = zfsvfs->z_max_blksz;
1669
1670	/*
1671	 * The following report "total" blocks of various kinds in the
1672	 * file system, but reported in terms of f_frsize - the
1673	 * "fragment" size.
1674	 */
1675
1676	statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT;
1677	statp->f_bfree = availbytes >> SPA_MINBLOCKSHIFT;
1678	statp->f_bavail = statp->f_bfree; /* no root reservation */
1679
1680	/*
1681	 * statvfs() should really be called statufs(), because it assumes
1682	 * static metadata.  ZFS doesn't preallocate files, so the best
1683	 * we can do is report the max that could possibly fit in f_files,
1684	 * and that minus the number actually used in f_ffree.
1685	 * For f_ffree, report the smaller of the number of object available
1686	 * and the number of blocks (each object will take at least a block).
1687	 */
1688	statp->f_ffree = MIN(availobjs, statp->f_bfree);
1689	statp->f_favail = statp->f_ffree;	/* no "root reservation" */
1690	statp->f_files = statp->f_ffree + usedobjs;
1691
1692	(void) cmpldev(&d32, vfsp->vfs_dev);
1693	statp->f_fsid = d32;
1694
1695	/*
1696	 * We're a zfs filesystem.
1697	 */
1698	(void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
1699
1700	statp->f_flag = vf_to_stf(vfsp->vfs_flag);
1701
1702	statp->f_namemax = ZFS_MAXNAMELEN;
1703
1704	/*
1705	 * We have all of 32 characters to stuff a string here.
1706	 * Is there anything useful we could/should provide?
1707	 */
1708	bzero(statp->f_fstr, sizeof (statp->f_fstr));
1709
1710	ZFS_EXIT(zfsvfs);
1711	return (0);
1712}
1713
1714static int
1715zfs_root(vfs_t *vfsp, vnode_t **vpp)
1716{
1717	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1718	znode_t *rootzp;
1719	int error;
1720
1721	ZFS_ENTER(zfsvfs);
1722
1723	error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
1724	if (error == 0)
1725		*vpp = ZTOV(rootzp);
1726
1727	ZFS_EXIT(zfsvfs);
1728	return (error);
1729}
1730
1731/*
1732 * Teardown the zfsvfs::z_os.
1733 *
1734 * Note, if 'unmounting' if FALSE, we return with the 'z_teardown_lock'
1735 * and 'z_teardown_inactive_lock' held.
1736 */
1737static int
1738zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
1739{
1740	znode_t	*zp;
1741
1742	rrw_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
1743
1744	if (!unmounting) {
1745		/*
1746		 * We purge the parent filesystem's vfsp as the parent
1747		 * filesystem and all of its snapshots have their vnode's
1748		 * v_vfsp set to the parent's filesystem's vfsp.  Note,
1749		 * 'z_parent' is self referential for non-snapshots.
1750		 */
1751		(void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1752	}
1753
1754	/*
1755	 * Close the zil. NB: Can't close the zil while zfs_inactive
1756	 * threads are blocked as zil_close can call zfs_inactive.
1757	 */
1758	if (zfsvfs->z_log) {
1759		zil_close(zfsvfs->z_log);
1760		zfsvfs->z_log = NULL;
1761	}
1762
1763	rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
1764
1765	/*
1766	 * If we are not unmounting (ie: online recv) and someone already
1767	 * unmounted this file system while we were doing the switcheroo,
1768	 * or a reopen of z_os failed then just bail out now.
1769	 */
1770	if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
1771		rw_exit(&zfsvfs->z_teardown_inactive_lock);
1772		rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1773		return (EIO);
1774	}
1775
1776	/*
1777	 * At this point there are no vops active, and any new vops will
1778	 * fail with EIO since we have z_teardown_lock for writer (only
1779	 * relavent for forced unmount).
1780	 *
1781	 * Release all holds on dbufs.
1782	 */
1783	mutex_enter(&zfsvfs->z_znodes_lock);
1784	for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
1785	    zp = list_next(&zfsvfs->z_all_znodes, zp))
1786		if (zp->z_sa_hdl) {
1787			ASSERT(ZTOV(zp)->v_count > 0);
1788			zfs_znode_dmu_fini(zp);
1789		}
1790	mutex_exit(&zfsvfs->z_znodes_lock);
1791
1792	/*
1793	 * If we are unmounting, set the unmounted flag and let new vops
1794	 * unblock.  zfs_inactive will have the unmounted behavior, and all
1795	 * other vops will fail with EIO.
1796	 */
1797	if (unmounting) {
1798		zfsvfs->z_unmounted = B_TRUE;
1799		rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1800		rw_exit(&zfsvfs->z_teardown_inactive_lock);
1801	}
1802
1803	/*
1804	 * z_os will be NULL if there was an error in attempting to reopen
1805	 * zfsvfs, so just return as the properties had already been
1806	 * unregistered and cached data had been evicted before.
1807	 */
1808	if (zfsvfs->z_os == NULL)
1809		return (0);
1810
1811	/*
1812	 * Unregister properties.
1813	 */
1814	zfs_unregister_callbacks(zfsvfs);
1815
1816	/*
1817	 * Evict cached data
1818	 */
1819	if (dmu_objset_is_dirty_anywhere(zfsvfs->z_os))
1820		if (!(zfsvfs->z_vfs->vfs_flag & VFS_RDONLY))
1821			txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
1822	(void) dmu_objset_evict_dbufs(zfsvfs->z_os);
1823
1824	return (0);
1825}
1826
1827/*ARGSUSED*/
1828static int
1829zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr)
1830{
1831	zfsvfs_t *zfsvfs = vfsp->vfs_data;
1832	objset_t *os;
1833	int ret;
1834
1835	ret = secpolicy_fs_unmount(cr, vfsp);
1836	if (ret) {
1837		if (dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource),
1838		    ZFS_DELEG_PERM_MOUNT, cr))
1839			return (ret);
1840	}
1841
1842	/*
1843	 * We purge the parent filesystem's vfsp as the parent filesystem
1844	 * and all of its snapshots have their vnode's v_vfsp set to the
1845	 * parent's filesystem's vfsp.  Note, 'z_parent' is self
1846	 * referential for non-snapshots.
1847	 */
1848	(void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1849
1850	/*
1851	 * Unmount any snapshots mounted under .zfs before unmounting the
1852	 * dataset itself.
1853	 */
1854	if (zfsvfs->z_ctldir != NULL &&
1855	    (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) {
1856		return (ret);
1857	}
1858
1859	if (!(fflag & MS_FORCE)) {
1860		/*
1861		 * Check the number of active vnodes in the file system.
1862		 * Our count is maintained in the vfs structure, but the
1863		 * number is off by 1 to indicate a hold on the vfs
1864		 * structure itself.
1865		 *
1866		 * The '.zfs' directory maintains a reference of its
1867		 * own, and any active references underneath are
1868		 * reflected in the vnode count.
1869		 */
1870		if (zfsvfs->z_ctldir == NULL) {
1871			if (vfsp->vfs_count > 1)
1872				return (EBUSY);
1873		} else {
1874			if (vfsp->vfs_count > 2 ||
1875			    zfsvfs->z_ctldir->v_count > 1)
1876				return (EBUSY);
1877		}
1878	}
1879
1880	vfsp->vfs_flag |= VFS_UNMOUNTED;
1881
1882	VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
1883	os = zfsvfs->z_os;
1884
1885	/*
1886	 * z_os will be NULL if there was an error in
1887	 * attempting to reopen zfsvfs.
1888	 */
1889	if (os != NULL) {
1890		/*
1891		 * Unset the objset user_ptr.
1892		 */
1893		mutex_enter(&os->os_user_ptr_lock);
1894		dmu_objset_set_user(os, NULL);
1895		mutex_exit(&os->os_user_ptr_lock);
1896
1897		/*
1898		 * Finally release the objset
1899		 */
1900		dmu_objset_disown(os, zfsvfs);
1901	}
1902
1903	/*
1904	 * We can now safely destroy the '.zfs' directory node.
1905	 */
1906	if (zfsvfs->z_ctldir != NULL)
1907		zfsctl_destroy(zfsvfs);
1908
1909	return (0);
1910}
1911
1912static int
1913zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
1914{
1915	zfsvfs_t	*zfsvfs = vfsp->vfs_data;
1916	znode_t		*zp;
1917	uint64_t	object = 0;
1918	uint64_t	fid_gen = 0;
1919	uint64_t	gen_mask;
1920	uint64_t	zp_gen;
1921	int 		i, err;
1922
1923	*vpp = NULL;
1924
1925	ZFS_ENTER(zfsvfs);
1926
1927	if (fidp->fid_len == LONG_FID_LEN) {
1928		zfid_long_t	*zlfid = (zfid_long_t *)fidp;
1929		uint64_t	objsetid = 0;
1930		uint64_t	setgen = 0;
1931
1932		for (i = 0; i < sizeof (zlfid->zf_setid); i++)
1933			objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
1934
1935

Large files files are truncated, but you can click here to view the full file