/*

 * 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 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/* Portions Copyright 2007 Jeremy Teo */

#ifdef _KERNEL

#include <sys/types.h>

#include <sys/param.h>

#include <sys/time.h>

#include <sys/systm.h>

#include <sys/sysmacros.h>

#include <sys/resource.h>

#include <sys/mntent.h>

#include <sys/mkdev.h>

#include <sys/u8_textprep.h>

#include <sys/dsl_dataset.h>

#include <sys/vfs.h>

#include <sys/vfs_opreg.h>

#include <sys/vnode.h>

#include <sys/file.h>

#include <sys/kmem.h>

#include <sys/errno.h>

#include <sys/unistd.h>

#include <sys/mode.h>

#include <sys/atomic.h>

#include <vm/pvn.h>

#include "fs/fs_subr.h"

#include <sys/zfs_dir.h>

#include <sys/zfs_acl.h>

#include <sys/zfs_ioctl.h>

#include <sys/zfs_rlock.h>

#include <sys/zfs_fuid.h>

#include <sys/fs/zfs.h>

#include <sys/kidmap.h>

#endif /* _KERNEL */

#include <sys/dmu.h>

#include <sys/refcount.h>

#include <sys/stat.h>

#include <sys/zap.h>

#include <sys/zfs_znode.h>

#include "zfs_prop.h"

/*

 * Define ZNODE_STATS to turn on statistic gathering. By default, it is only

 * turned on when DEBUG is also defined.

 */

#ifdef	DEBUG

#define	ZNODE_STATS

#endif	/* DEBUG */

#ifdef	ZNODE_STATS

#define	ZNODE_STAT_ADD(stat)			((stat)++)

#else

#define	ZNODE_STAT_ADD(stat)			/* nothing */

#endif	/* ZNODE_STATS */

#define	POINTER_IS_VALID(p)	(!((uintptr_t)(p) & 0x3))

#define	POINTER_INVALIDATE(pp)	(*(pp) = (void *)((uintptr_t)(*(pp)) | 0x1))

/*

 * Functions needed for userland (ie: libzpool) are not put under

 * #ifdef_KERNEL; the rest of the functions have dependencies

 * (such as VFS logic) that will not compile easily in userland.

 */

#ifdef _KERNEL

/*

 * Needed to close a small window in zfs_znode_move() that allows the zfsvfs to

 * be freed before it can be safely accessed.

 */

krwlock_t zfsvfs_lock;

static kmem_cache_t *znode_cache = NULL;

/*ARGSUSED*/

static void

znode_evict_error(dmu_buf_t *dbuf, void *user_ptr)

{

	/*

	 * We should never drop all dbuf refs without first clearing

	 * the eviction callback.

	 */

	panic("evicting znode %p\n", user_ptr);

}

/*ARGSUSED*/

static int

zfs_znode_cache_constructor(void *buf, void *arg, int kmflags)

{

	znode_t *zp = buf;

	ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs));

	zp->z_vnode = vn_alloc(kmflags);

	if (zp->z_vnode == NULL) {

		return (-1);

	}

	ZTOV(zp)->v_data = zp;

	list_link_init(&zp->z_link_node);

	mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL);

	rw_init(&zp->z_parent_lock, NULL, RW_DEFAULT, NULL);

	rw_init(&zp->z_name_lock, NULL, RW_DEFAULT, NULL);

	mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&zp->z_range_lock, NULL, MUTEX_DEFAULT, NULL);

	avl_create(&zp->z_range_avl, zfs_range_compare,

	    sizeof (rl_t), offsetof(rl_t, r_node));

	zp->z_dbuf = NULL;

	zp->z_dirlocks = NULL;

	zp->z_acl_cached = NULL;

	return (0);

}

/*ARGSUSED*/

static void

zfs_znode_cache_destructor(void *buf, void *arg)

{

	znode_t *zp = buf;

	ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs));

	ASSERT(ZTOV(zp)->v_data == zp);

	vn_free(ZTOV(zp));

	ASSERT(!list_link_active(&zp->z_link_node));

	mutex_destroy(&zp->z_lock);

	rw_destroy(&zp->z_parent_lock);

	rw_destroy(&zp->z_name_lock);

	mutex_destroy(&zp->z_acl_lock);

	avl_destroy(&zp->z_range_avl);

	mutex_destroy(&zp->z_range_lock);

	ASSERT(zp->z_dbuf == NULL);

	ASSERT(zp->z_dirlocks == NULL);

	ASSERT(zp->z_acl_cached == NULL);

}

#ifdef	ZNODE_STATS

static struct {

	uint64_t zms_zfsvfs_invalid;

	uint64_t zms_zfsvfs_recheck1;

	uint64_t zms_zfsvfs_unmounted;

	uint64_t zms_zfsvfs_recheck2;

	uint64_t zms_obj_held;

	uint64_t zms_vnode_locked;

	uint64_t zms_not_only_dnlc;

} znode_move_stats;

#endif	/* ZNODE_STATS */

static void

zfs_znode_move_impl(znode_t *ozp, znode_t *nzp)

{

	vnode_t *vp;

	/* Copy fields. */

	nzp->z_zfsvfs = ozp->z_zfsvfs;

	/* Swap vnodes. */

	vp = nzp->z_vnode;

	nzp->z_vnode = ozp->z_vnode;

	ozp->z_vnode = vp; /* let destructor free the overwritten vnode */

	ZTOV(ozp)->v_data = ozp;

	ZTOV(nzp)->v_data = nzp;

	nzp->z_id = ozp->z_id;

	ASSERT(ozp->z_dirlocks == NULL); /* znode not in use */

	ASSERT(avl_numnodes(&ozp->z_range_avl) == 0);

	nzp->z_unlinked = ozp->z_unlinked;

	nzp->z_atime_dirty = ozp->z_atime_dirty;

	nzp->z_zn_prefetch = ozp->z_zn_prefetch;

	nzp->z_blksz = ozp->z_blksz;

	nzp->z_seq = ozp->z_seq;

	nzp->z_mapcnt = ozp->z_mapcnt;

	nzp->z_last_itx = ozp->z_last_itx;

	nzp->z_gen = ozp->z_gen;

	nzp->z_sync_cnt = ozp->z_sync_cnt;

	nzp->z_phys = ozp->z_phys;

	nzp->z_dbuf = ozp->z_dbuf;

	/*

	 * Since this is just an idle znode and kmem is already dealing with

	 * memory pressure, release any cached ACL.

	 */

	if (ozp->z_acl_cached) {

		zfs_acl_free(ozp->z_acl_cached);

		ozp->z_acl_cached = NULL;

	}

	/* Update back pointers. */

	(void) dmu_buf_update_user(nzp->z_dbuf, ozp, nzp, &nzp->z_phys,

	    znode_evict_error);

	/*

	 * Invalidate the original znode by clearing fields that provide a

	 * pointer back to the znode. Set the low bit of the vfs pointer to

	 * ensure that zfs_znode_move() recognizes the znode as invalid in any

	 * subsequent callback.

	 */

	ozp->z_dbuf = NULL;

	POINTER_INVALIDATE(&ozp->z_zfsvfs);

}

/*ARGSUSED*/

static kmem_cbrc_t

zfs_znode_move(void *buf, void *newbuf, size_t size, void *arg)

{

	znode_t *ozp = buf, *nzp = newbuf;

	zfsvfs_t *zfsvfs;

	vnode_t *vp;

	/*

	 * The znode is on the file system's list of known znodes if the vfs

	 * pointer is valid. We set the low bit of the vfs pointer when freeing

	 * the znode to invalidate it, and the memory patterns written by kmem

	 * (baddcafe and deadbeef) set at least one of the two low bits. A newly

	 * created znode sets the vfs pointer last of all to indicate that the

	 * znode is known and in a valid state to be moved by this function.

	 */

	zfsvfs = ozp->z_zfsvfs;

	if (!POINTER_IS_VALID(zfsvfs)) {

		ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_invalid);

		return (KMEM_CBRC_DONT_KNOW);

	}

	/*

	 * Close a small window in which it's possible that the filesystem could

	 * be unmounted and freed, and zfsvfs, though valid in the previous

	 * statement, could point to unrelated memory by the time we try to

	 * prevent the filesystem from being unmounted.

	 */

	rw_enter(&zfsvfs_lock, RW_WRITER);

	if (zfsvfs != ozp->z_zfsvfs) {

		rw_exit(&zfsvfs_lock);

		ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_recheck1);

		return (KMEM_CBRC_DONT_KNOW);

	}

	/*

	 * If the znode is still valid, then so is the file system. We know that

	 * no valid file system can be freed while we hold zfsvfs_lock, so we

	 * can safely ensure that the filesystem is not and will not be

	 * unmounted. The next statement is equivalent to ZFS_ENTER().

	 */

	rrw_enter(&zfsvfs->z_teardown_lock, RW_READER, FTAG);

	if (zfsvfs->z_unmounted) {

		ZFS_EXIT(zfsvfs);

		rw_exit(&zfsvfs_lock);

		ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_unmounted);

		return (KMEM_CBRC_DONT_KNOW);

	}

	rw_exit(&zfsvfs_lock);

	mutex_enter(&zfsvfs->z_znodes_lock);

	/*

	 * Recheck the vfs pointer in case the znode was removed just before

	 * acquiring the lock.

	 */

	if (zfsvfs != ozp->z_zfsvfs) {

		mutex_exit(&zfsvfs->z_znodes_lock);

		ZFS_EXIT(zfsvfs);

		ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_recheck2);

		return (KMEM_CBRC_DONT_KNOW);

	}

	/*

	 * At this point we know that as long as we hold z_znodes_lock, the

	 * znode cannot be freed and fields within the znode can be safely

	 * accessed. Now, prevent a race with zfs_zget().

	 */

	if (ZFS_OBJ_HOLD_TRYENTER(zfsvfs, ozp->z_id) == 0) {

		mutex_exit(&zfsvfs->z_znodes_lock);

		ZFS_EXIT(zfsvfs);

		ZNODE_STAT_ADD(znode_move_stats.zms_obj_held);

		return (KMEM_CBRC_LATER);

	}

	vp = ZTOV(ozp);

	if (mutex_tryenter(&vp->v_lock) == 0) {

		ZFS_OBJ_HOLD_EXIT(zfsvfs, ozp->z_id);

		mutex_exit(&zfsvfs->z_znodes_lock);

		ZFS_EXIT(zfsvfs);

		ZNODE_STAT_ADD(znode_move_stats.zms_vnode_locked);

		return (KMEM_CBRC_LATER);

	}

	/* Only move znodes that are referenced _only_ by the DNLC. */

	if (vp->v_count != 1 || !vn_in_dnlc(vp)) {

		mutex_exit(&vp->v_lock);

		ZFS_OBJ_HOLD_EXIT(zfsvfs, ozp->z_id);

		mutex_exit(&zfsvfs->z_znodes_lock);

		ZFS_EXIT(zfsvfs);

		ZNODE_STAT_ADD(znode_move_stats.zms_not_only_dnlc);

		return (KMEM_CBRC_LATER);

	}

	/*

	 * The znode is known and in a valid state to move. We're holding the

	 * locks needed to execute the critical section.

	 */

	zfs_znode_move_impl(ozp, nzp);

	mutex_exit(&vp->v_lock);

	ZFS_OBJ_HOLD_EXIT(zfsvfs, ozp->z_id);

	list_link_replace(&ozp->z_link_node, &nzp->z_link_node);

	mutex_exit(&zfsvfs->z_znodes_lock);

	ZFS_EXIT(zfsvfs);

	return (KMEM_CBRC_YES);

}

void

zfs_znode_init(void)

{

	/*

	 * Initialize zcache

	 */

	rw_init(&zfsvfs_lock, NULL, RW_DEFAULT, NULL);

	ASSERT(znode_cache == NULL);

	znode_cache = kmem_cache_create("zfs_znode_cache",

	    sizeof (znode_t), 0, zfs_znode_cache_constructor,

	    zfs_znode_cache_destructor, NULL, NULL, NULL, 0);

	kmem_cache_set_move(znode_cache, zfs_znode_move);

}

void

zfs_znode_fini(void)

{

	/*

	 * Cleanup vfs & vnode ops

	 */

	zfs_remove_op_tables();

	/*

	 * Cleanup zcache

	 */

	if (znode_cache)

		kmem_cache_destroy(znode_cache);

	znode_cache = NULL;

	rw_destroy(&zfsvfs_lock);

}

struct vnodeops *zfs_dvnodeops;

struct vnodeops *zfs_fvnodeops;

struct vnodeops *zfs_symvnodeops;

struct vnodeops *zfs_xdvnodeops;

struct vnodeops *zfs_evnodeops;

struct vnodeops *zfs_sharevnodeops;

void

zfs_remove_op_tables()

{

	/*

	 * Remove vfs ops

	 */

	ASSERT(zfsfstype);

	(void) vfs_freevfsops_by_type(zfsfstype);

	zfsfstype = 0;

	/*

	 * Remove vnode ops

	 */

	if (zfs_dvnodeops)

		vn_freevnodeops(zfs_dvnodeops);

	if (zfs_fvnodeops)

		vn_freevnodeops(zfs_fvnodeops);

	if (zfs_symvnodeops)

		vn_freevnodeops(zfs_symvnodeops);

	if (zfs_xdvnodeops)

		vn_freevnodeops(zfs_xdvnodeops);

	if (zfs_evnodeops)

		vn_freevnodeops(zfs_evnodeops);

	if (zfs_sharevnodeops)

		vn_freevnodeops(zfs_sharevnodeops);

	zfs_dvnodeops = NULL;

	zfs_fvnodeops = NULL;

	zfs_symvnodeops = NULL;

	zfs_xdvnodeops = NULL;

	zfs_evnodeops = NULL;

	zfs_sharevnodeops = NULL;

}

extern const fs_operation_def_t zfs_dvnodeops_template[];

extern const fs_operation_def_t zfs_fvnodeops_template[];

extern const fs_operation_def_t zfs_xdvnodeops_template[];

extern const fs_operation_def_t zfs_symvnodeops_template[];

extern const fs_operation_def_t zfs_evnodeops_template[];

extern const fs_operation_def_t zfs_sharevnodeops_template[];

int

zfs_create_op_tables()

{

	int error;

	/*

	 * zfs_dvnodeops can be set if mod_remove() calls mod_installfs()

	 * due to a failure to remove the the 2nd modlinkage (zfs_modldrv).

	 * In this case we just return as the ops vectors are already set up.

	 */

	if (zfs_dvnodeops)

		return (0);

	error = vn_make_ops(MNTTYPE_ZFS, zfs_dvnodeops_template,

	    &zfs_dvnodeops);

	if (error)

		return (error);

	error = vn_make_ops(MNTTYPE_ZFS, zfs_fvnodeops_template,

	    &zfs_fvnodeops);

	if (error)

		return (error);

	error = vn_make_ops(MNTTYPE_ZFS, zfs_symvnodeops_template,

	    &zfs_symvnodeops);

	if (error)

		return (error);

	error = vn_make_ops(MNTTYPE_ZFS, zfs_xdvnodeops_template,

	    &zfs_xdvnodeops);

	if (error)

		return (error);

	error = vn_make_ops(MNTTYPE_ZFS, zfs_evnodeops_template,

	    &zfs_evnodeops);

	if (error)

		return (error);

	error = vn_make_ops(MNTTYPE_ZFS, zfs_sharevnodeops_template,

	    &zfs_sharevnodeops);

	return (error);

}

int

zfs_create_share_dir(zfsvfs_t *zfsvfs, dmu_tx_t *tx)

{

	zfs_acl_ids_t acl_ids;

	vattr_t vattr;

	znode_t *sharezp;

	vnode_t *vp;

	znode_t *zp;

	int error;

	vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE;

	vattr.va_type = VDIR;

	vattr.va_mode = S_IFDIR|0555;

	vattr.va_uid = crgetuid(kcred);

	vattr.va_gid = crgetgid(kcred);

	sharezp = kmem_cache_alloc(znode_cache, KM_SLEEP);

	sharezp->z_unlinked = 0;

	sharezp->z_atime_dirty = 0;

	sharezp->z_zfsvfs = zfsvfs;

	vp = ZTOV(sharezp);

	vn_reinit(vp);

	vp->v_type = VDIR;

	VERIFY(0 == zfs_acl_ids_create(sharezp, IS_ROOT_NODE, &vattr,

	    kcred, NULL, &acl_ids));

	zfs_mknode(sharezp, &vattr, tx, kcred, IS_ROOT_NODE,

	    &zp, 0, &acl_ids);

	ASSERT3P(zp, ==, sharezp);

	ASSERT(!vn_in_dnlc(ZTOV(sharezp))); /* not valid to move */

	POINTER_INVALIDATE(&sharezp->z_zfsvfs);

	error = zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,

	    ZFS_SHARES_DIR, 8, 1, &sharezp->z_id, tx);

	zfsvfs->z_shares_dir = sharezp->z_id;

	zfs_acl_ids_free(&acl_ids);

	ZTOV(sharezp)->v_count = 0;

	dmu_buf_rele(sharezp->z_dbuf, NULL);

	sharezp->z_dbuf = NULL;

	kmem_cache_free(znode_cache, sharezp);