/*

 * 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.

 */

/* Portions Copyright 2007 Jeremy Teo */

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

#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/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/fs/zfs.h>

#endif /* _KERNEL */

#include <sys/dmu.h>

#include <sys/refcount.h>

#include <sys/stat.h>

#include <sys/zap.h>

#include <sys/zfs_znode.h>

/*

 * 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

struct kmem_cache *znode_cache = NULL;

/*ARGSUSED*/

static void

znode_pageout_func(dmu_buf_t *dbuf, void *user_ptr)

{

	znode_t *zp = user_ptr;

	vnode_t *vp = ZTOV(zp);

	mutex_enter(&zp->z_lock);

	if (vp->v_count == 0) {

		mutex_exit(&zp->z_lock);

		vn_invalid(vp);

		zfs_znode_free(zp);

	} else {

		/* signal force unmount that this znode can be freed */

		zp->z_dbuf = NULL;

		mutex_exit(&zp->z_lock);

	}

}

/*ARGSUSED*/

static int

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

{

	znode_t *zp = buf;

	zp->z_vnode = vn_alloc(KM_SLEEP);

	zp->z_vnode->v_data = (caddr_t)zp;

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

	rw_init(&zp->z_map_lock, NULL, RW_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_held = 0;

	zp->z_dirlocks = 0;

	return (0);

}

/*ARGSUSED*/

static void

zfs_znode_cache_destructor(void *buf, void *cdarg)

{

	znode_t *zp = buf;

	ASSERT(zp->z_dirlocks == 0);

	mutex_destroy(&zp->z_lock);

	rw_destroy(&zp->z_map_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_held == 0);

	ASSERT(ZTOV(zp)->v_count == 0);

	vn_free(ZTOV(zp));

}

void

zfs_znode_init(void)

{

	/*

	 * Initialize zcache

	 */

	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);

}

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;

}

struct vnodeops *zfs_dvnodeops;

struct vnodeops *zfs_fvnodeops;

struct vnodeops *zfs_symvnodeops;

struct vnodeops *zfs_xdvnodeops;

struct vnodeops *zfs_evnodeops;

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);

	zfs_dvnodeops = NULL;

	zfs_fvnodeops = NULL;

	zfs_symvnodeops = NULL;

	zfs_xdvnodeops = NULL;

	zfs_evnodeops = 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[];

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);

	return (error);

}

/*

 * zfs_init_fs - Initialize the zfsvfs struct and the file system

 *	incore "master" object.  Verify version compatibility.

 */

int

zfs_init_fs(zfsvfs_t *zfsvfs, znode_t **zpp, cred_t *cr)

{

	extern int zfsfstype;

	objset_t	*os = zfsvfs->z_os;

	int		i, error;

	dmu_object_info_t doi;

	uint64_t fsid_guid;

	*zpp = NULL;

	/*

	 * XXX - hack to auto-create the pool root filesystem at

	 * the first attempted mount.

	 */

	if (dmu_object_info(os, MASTER_NODE_OBJ, &doi) == ENOENT) {

		dmu_tx_t *tx = dmu_tx_create(os);

		dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* master */

		dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* del queue */

		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); /* root node */

		error = dmu_tx_assign(tx, TXG_WAIT);

		ASSERT3U(error, ==, 0);

		zfs_create_fs(os, cr, ZPL_VERSION, tx);

		dmu_tx_commit(tx);

	}

	error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR, 8, 1,

	    &zfsvfs->z_version);

	if (error) {

		return (error);

	} else if (zfsvfs->z_version > ZPL_VERSION) {

		(void) printf("Mismatched versions:  File system "

		    "is version %lld on-disk format, which is "

		    "incompatible with this software version %lld!",

		    (u_longlong_t)zfsvfs->z_version, ZPL_VERSION);

		return (ENOTSUP);

	}

	/*

	 * The fsid is 64 bits, composed of an 8-bit fs type, which

	 * separates our fsid from any other filesystem types, and a

	 * 56-bit objset unique ID.  The objset unique ID is unique to

	 * all objsets open on this system, provided by unique_create().

	 * The 8-bit fs type must be put in the low bits of fsid[1]

	 * because that's where other Solaris filesystems put it.

	 */

	fsid_guid = dmu_objset_fsid_guid(os);

	ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0);

	zfsvfs->z_vfs->vfs_fsid.val[0] = fsid_guid;

	zfsvfs->z_vfs->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) |

	    zfsfstype & 0xFF;

	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1,

	    &zfsvfs->z_root);

	if (error)

		return (error);

	ASSERT(zfsvfs->z_root != 0);

	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1,

	    &zfsvfs->z_unlinkedobj);

	if (error)

		return (error);

	/*

	 * Initialize zget mutex's

	 */

	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)

		mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);

	error = zfs_zget(zfsvfs, zfsvfs->z_root, zpp);

	if (error) {

		/*

		 * On error, we destroy the mutexes here since it's not

		 * possible for the caller to determine if the mutexes were

		 * initialized properly.

		 */

		for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)

			mutex_destroy(&zfsvfs->z_hold_mtx[i]);

		return (error);

	}

	ASSERT3U((*zpp)->z_id, ==, zfsvfs->z_root);

	return (0);

}

/*

 * define a couple of values we need available

 * for both 64 and 32 bit environments.

 */

#ifndef NBITSMINOR64

#define	NBITSMINOR64	32

#endif

#ifndef MAXMAJ64

#define	MAXMAJ64	0xffffffffUL

#endif

#ifndef	MAXMIN64

#define	MAXMIN64	0xffffffffUL

#endif

/*

 * Create special expldev for ZFS private use.

 * Can't use standard expldev since it doesn't do

 * what we want.  The standard expldev() takes a

 * dev32_t in LP64 and expands it to a long dev_t.

 * We need an interface that takes a dev32_t in ILP32

 * and expands it to a long dev_t.

 */

static uint64_t

zfs_expldev(dev_t dev)

{

#ifndef _LP64

	major_t major = (major_t)dev >> NBITSMINOR32 & MAXMAJ32;

	return (((uint64_t)major << NBITSMINOR64) |

	    ((minor_t)dev & MAXMIN32));

#else

	return (dev);

#endif

}

/*

 * Special cmpldev for ZFS private use.

 * Can't use standard cmpldev since it takes

 * a long dev_t and compresses it to dev32_t in

 * LP64.  We need to do a compaction of a long dev_t

 * to a dev32_t in ILP32.

 */

dev_t

zfs_cmpldev(uint64_t dev)

{

#ifndef _LP64

	minor_t minor = (minor_t)dev & MAXMIN64;

	major_t major = (major_t)(dev >> NBITSMINOR64) & MAXMAJ64;

	if (major > MAXMAJ32 || minor > MAXMIN32)

		return (NODEV32);

	return (((dev32_t)major << NBITSMINOR32) | minor);

#else

	return (dev);

#endif

}

/*

 * Construct a new znode/vnode and intialize.

 *

 * This does not do a call to dmu_set_user() that is

 * up to the caller to do, in case you don't want to

 * return the znode

 */

static znode_t *

zfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, uint64_t obj_num, int blksz)

{

	znode_t	*zp;

	vnode_t *vp;

	zp = kmem_cache_alloc(znode_cache, KM_SLEEP);

	ASSERT(zp->z_dirlocks == NULL);

	zp->z_phys = db->db_data;

	zp->z_zfsvfs = zfsvfs;

	zp->z_unlinked = 0;

	zp->z_atime_dirty = 0;

	zp->z_dbuf_held = 0;

	zp->z_mapcnt = 0;

	zp->z_last_itx = 0;

	zp->z_dbuf = db;

	zp->z_id = obj_num;

	zp->z_blksz = blksz;

	zp->z_seq = 0x7A4653;

	zp->z_sync_cnt = 0;

	mutex_enter(&zfsvfs->z_znodes_lock);

	list_insert_tail(&zfsvfs->z_all_znodes, zp);

	mutex_exit(&zfsvfs->z_znodes_lock);

	vp = ZTOV(zp);

	vn_reinit(vp);

	vp->v_vfsp = zfsvfs->z_parent->z_vfs;

	vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode);

	switch (vp->v_type) {

	case VDIR:

		if (zp->z_phys->zp_flags & ZFS_XATTR) {

			vn_setops(vp, zfs_xdvnodeops);

			vp->v_flag |= V_XATTRDIR;

		} else

			vn_setops(vp, zfs_dvnodeops);

		zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */

		break;

	case VBLK:

	case VCHR:

		vp->v_rdev = zfs_cmpldev(zp->z_phys->zp_rdev);

		/*FALLTHROUGH*/

	case VFIFO:

	case VSOCK:

	case VDOOR:

		vn_setops(vp, zfs_fvnodeops);

		break;

	case VREG:

		vp->v_flag |= VMODSORT;

		vn_setops(vp, zfs_fvnodeops);

		break;

	case VLNK:

		vn_setops(vp, zfs_symvnodeops);

		break;

	default:

		vn_setops(vp, zfs_evnodeops);

		break;

	}

	return (zp);

}

static void

zfs_znode_dmu_init(znode_t *zp)

{

	znode_t		*nzp;

	zfsvfs_t	*zfsvfs = zp->z_zfsvfs;

	dmu_buf_t	*db = zp->z_dbuf;

	mutex_enter(&zp->z_lock);

	nzp = dmu_buf_set_user_ie(db, zp, &zp->z_phys, znode_pageout_func);

	/*

	 * there should be no

	 * concurrent zgets on this object.

	 */

	ASSERT3P(nzp, ==, NULL);

	/*

	 * Slap on VROOT if we are the root znode

	 */

	if (zp->z_id == zfsvfs->z_root) {

		ZTOV(zp)->v_flag |= VROOT;

	}

	ASSERT(zp->z_dbuf_held == 0);

	zp->z_dbuf_held = 1;

	VFS_HOLD(zfsvfs->z_vfs);

	mutex_exit(&zp->z_lock);

	vn_exists(ZTOV(zp));

}

/*

 * Create a new DMU object to hold a zfs znode.

 *

 *	IN:	dzp	- parent directory for new znode

 *		vap	- file attributes for new znode

 *		tx	- dmu transaction id for zap operations

 *		cr	- credentials of caller

 *		flag	- flags:

 *			  IS_ROOT_NODE	- new object will be root

 *			  IS_XATTR	- new object is an attribute

 *			  IS_REPLAY	- intent log replay

 *

 *	OUT:	oid	- ID of created object

 *

 */

void

zfs_mknode(znode_t *dzp, vattr_t *vap, uint64_t *oid, dmu_tx_t *tx, cred_t *cr,

	uint_t flag, znode_t **zpp, int bonuslen)

{

	dmu_buf_t	*dbp;