/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/sysmacros.h>

#include <sys/kmem.h>

#include <sys/pathname.h>

#include <sys/vnode.h>

#include <sys/vfs.h>

#include <sys/vfs_opreg.h>

#include <sys/mntent.h>

#include <sys/mount.h>

#include <sys/cmn_err.h>

#include "fs/fs_subr.h"

#include <sys/zfs_znode.h>

#include <sys/zfs_dir.h>

#include <sys/zil.h>

#include <sys/fs/zfs.h>

#include <sys/dmu.h>

#include <sys/dsl_prop.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_deleg.h>

#include <sys/spa.h>

#include <sys/zap.h>

#include <sys/varargs.h>

#include <sys/policy.h>

#include <sys/atomic.h>

#include <sys/mkdev.h>

#include <sys/modctl.h>

#include <sys/refstr.h>

#include <sys/zfs_ioctl.h>

#include <sys/zfs_ctldir.h>

#include <sys/bootconf.h>

#include <sys/sunddi.h>

#include <sys/dnlc.h>

int zfsfstype;

vfsops_t *zfs_vfsops = NULL;

static major_t zfs_major;

static minor_t zfs_minor;

static kmutex_t	zfs_dev_mtx;

static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr);

static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr);

static int zfs_mountroot(vfs_t *vfsp, enum whymountroot);

static int zfs_root(vfs_t *vfsp, vnode_t **vpp);

static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp);

static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp);

static void zfs_freevfs(vfs_t *vfsp);

static const fs_operation_def_t zfs_vfsops_template[] = {

	VFSNAME_MOUNT,		{ .vfs_mount = zfs_mount },

	VFSNAME_MOUNTROOT,	{ .vfs_mountroot = zfs_mountroot },

	VFSNAME_UNMOUNT,	{ .vfs_unmount = zfs_umount },

	VFSNAME_ROOT,		{ .vfs_root = zfs_root },

	VFSNAME_STATVFS,	{ .vfs_statvfs = zfs_statvfs },

	VFSNAME_SYNC,		{ .vfs_sync = zfs_sync },

	VFSNAME_VGET,		{ .vfs_vget = zfs_vget },

	VFSNAME_FREEVFS,	{ .vfs_freevfs = zfs_freevfs },

	NULL,			NULL

};

static const fs_operation_def_t zfs_vfsops_eio_template[] = {

	VFSNAME_FREEVFS,	{ .vfs_freevfs =  zfs_freevfs },

	NULL,			NULL

};

/*

 * We need to keep a count of active fs's.

 * This is necessary to prevent our module

 * from being unloaded after a umount -f

 */

static uint32_t	zfs_active_fs_count = 0;

static char *noatime_cancel[] = { MNTOPT_ATIME, NULL };

static char *atime_cancel[] = { MNTOPT_NOATIME, NULL };

static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };

static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };

/*

 * MO_DEFAULT is not used since the default value is determined

 * by the equivalent property.

 */

static mntopt_t mntopts[] = {

	{ MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL },

	{ MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL },

	{ MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL },

	{ MNTOPT_ATIME, atime_cancel, NULL, 0, NULL }

};

static mntopts_t zfs_mntopts = {

	sizeof (mntopts) / sizeof (mntopt_t),

	mntopts

};

/*ARGSUSED*/

int

zfs_sync(vfs_t *vfsp, short flag, cred_t *cr)

{

	/*

	 * Data integrity is job one.  We don't want a compromised kernel

	 * writing to the storage pool, so we never sync during panic.

	 */

	if (panicstr)

		return (0);

	/*

	 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS

	 * to sync metadata, which they would otherwise cache indefinitely.

	 * Semantically, the only requirement is that the sync be initiated.

	 * The DMU syncs out txgs frequently, so there's nothing to do.

	 */

	if (flag & SYNC_ATTR)

		return (0);

	if (vfsp != NULL) {

		/*

		 * Sync a specific filesystem.

		 */

		zfsvfs_t *zfsvfs = vfsp->vfs_data;

		ZFS_ENTER(zfsvfs);

		if (zfsvfs->z_log != NULL)

			zil_commit(zfsvfs->z_log, UINT64_MAX, 0);

		else

			txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);

		ZFS_EXIT(zfsvfs);

	} else {

		/*

		 * Sync all ZFS filesystems.  This is what happens when you

		 * run sync(1M).  Unlike other filesystems, ZFS honors the

		 * request by waiting for all pools to commit all dirty data.

		 */

		spa_sync_allpools();

	}

	return (0);

}

static int

zfs_create_unique_device(dev_t *dev)

{

	major_t new_major;

	do {

		ASSERT3U(zfs_minor, <=, MAXMIN32);

		minor_t start = zfs_minor;

		do {

			mutex_enter(&zfs_dev_mtx);

			if (zfs_minor >= MAXMIN32) {

				/*

				 * If we're still using the real major

				 * keep out of /dev/zfs and /dev/zvol minor

				 * number space.  If we're using a getudev()'ed

				 * major number, we can use all of its minors.

				 */

				if (zfs_major == ddi_name_to_major(ZFS_DRIVER))

					zfs_minor = ZFS_MIN_MINOR;

				else

					zfs_minor = 0;

			} else {

				zfs_minor++;

			}

			*dev = makedevice(zfs_major, zfs_minor);

			mutex_exit(&zfs_dev_mtx);

		} while (vfs_devismounted(*dev) && zfs_minor != start);

		if (zfs_minor == start) {

			/*

			 * We are using all ~262,000 minor numbers for the

			 * current major number.  Create a new major number.

			 */

			if ((new_major = getudev()) == (major_t)-1) {

				cmn_err(CE_WARN,

				    "zfs_mount: Can't get unique major "

				    "device number.");

				return (-1);

			}

			mutex_enter(&zfs_dev_mtx);

			zfs_major = new_major;

			zfs_minor = 0;

			mutex_exit(&zfs_dev_mtx);

		} else {

			break;

		}

		/* CONSTANTCONDITION */

	} while (1);

	return (0);

}

static void

atime_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval == TRUE) {

		zfsvfs->z_atime = TRUE;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);

	} else {

		zfsvfs->z_atime = FALSE;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);

	}

}

static void

xattr_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval == TRUE) {

		/* XXX locking on vfs_flag? */

		zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);

	} else {

		/* XXX locking on vfs_flag? */

		zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);

	}

}

static void

blksz_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval < SPA_MINBLOCKSIZE ||

	    newval > SPA_MAXBLOCKSIZE || !ISP2(newval))

		newval = SPA_MAXBLOCKSIZE;

	zfsvfs->z_max_blksz = newval;

	zfsvfs->z_vfs->vfs_bsize = newval;

}

static void

readonly_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval) {

		/* XXX locking on vfs_flag? */

		zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);

	} else {

		/* XXX locking on vfs_flag? */

		zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);

	}

}

static void

devices_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval == FALSE) {

		zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0);

	} else {

		zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0);

	}

}

static void

setuid_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval == FALSE) {

		zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);

	} else {

		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);

	}

}

static void

exec_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	if (newval == FALSE) {

		zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);

	} else {

		zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;

		vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);

		vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);

	}

}

static void

snapdir_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_show_ctldir = newval;

}

static void

acl_mode_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_acl_mode = newval;

}

static void

acl_inherit_changed_cb(void *arg, uint64_t newval)

{

	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_acl_inherit = newval;

}

static int

zfs_register_callbacks(vfs_t *vfsp)

{

	struct dsl_dataset *ds = NULL;

	objset_t *os = NULL;

	zfsvfs_t *zfsvfs = NULL;

	int readonly, do_readonly = FALSE;

	int setuid, do_setuid = FALSE;

	int exec, do_exec = FALSE;

	int devices, do_devices = FALSE;

	int xattr, do_xattr = FALSE;

	int atime, do_atime = FALSE;

	int error = 0;

	ASSERT(vfsp);

	zfsvfs = vfsp->vfs_data;

	ASSERT(zfsvfs);

	os = zfsvfs->z_os;

	/*

	 * The act of registering our callbacks will destroy any mount

	 * options we may have.  In order to enable temporary overrides

	 * of mount options, we stash away the current values and

	 * restore them after we register the callbacks.

	 */

	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {

		readonly = B_TRUE;

		do_readonly = B_TRUE;

	} else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {

		readonly = B_FALSE;

		do_readonly = B_TRUE;

	}

	if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {

		devices = B_FALSE;

		setuid = B_FALSE;

		do_devices = B_TRUE;

		do_setuid = B_TRUE;

	} else {

		if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {

			devices = B_FALSE;

			do_devices = B_TRUE;

		} else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) {

			devices = B_TRUE;

			do_devices = B_TRUE;

		}

		if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {

			setuid = B_FALSE;

			do_setuid = B_TRUE;

		} else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {

			setuid = B_TRUE;

			do_setuid = B_TRUE;

		}

	}

	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {

		exec = B_FALSE;

		do_exec = B_TRUE;

	} else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {

		exec = B_TRUE;

		do_exec = B_TRUE;

	}

	if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {

		xattr = B_FALSE;

		do_xattr = B_TRUE;

	} else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {

		xattr = B_TRUE;

		do_xattr = B_TRUE;

	}

	if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {

		atime = B_FALSE;

		do_atime = B_TRUE;

	} else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {

		atime = B_TRUE;

		do_atime = B_TRUE;

	}

	/*

	 * Register property callbacks.

	 *

	 * It would probably be fine to just check for i/o error from

	 * the first prop_register(), but I guess I like to go

	 * overboard...

	 */

	ds = dmu_objset_ds(os);

	error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "xattr", xattr_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "recordsize", blksz_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "readonly", readonly_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "devices", devices_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "setuid", setuid_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "exec", exec_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "snapdir", snapdir_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "aclmode", acl_mode_changed_cb, zfsvfs);

	error = error ? error : dsl_prop_register(ds,

	    "aclinherit", acl_inherit_changed_cb, zfsvfs);

	if (error)

		goto unregister;

	/*

	 * Invoke our callbacks to restore temporary mount options.

	 */

	if (do_readonly)

		readonly_changed_cb(zfsvfs, readonly);

	if (do_setuid)

		setuid_changed_cb(zfsvfs, setuid);

	if (do_exec)

		exec_changed_cb(zfsvfs, exec);

	if (do_devices)

		devices_changed_cb(zfsvfs, devices);

	if (do_xattr)

		xattr_changed_cb(zfsvfs, xattr);

	if (do_atime)

		atime_changed_cb(zfsvfs, atime);

	return (0);

unregister:

	/*

	 * We may attempt to unregister some callbacks that are not

	 * registered, but this is OK; it will simply return ENOMSG,

	 * which we will ignore.

	 */

	(void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs);

	(void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,

	    zfsvfs);

	return (error);

}

static int