/*

 * CDDL HEADER START

 *

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

 * Common Development and Distribution License, Version 1.0 only

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

 * Use is subject to license terms.

 */

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

#include <sys/zfs_context.h>

#include <sys/dbuf.h>

#include <sys/dnode.h>

#include <sys/dmu.h>

#include <sys/dmu_impl.h>

#include <sys/dmu_tx.h>

#include <sys/dmu_objset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_dataset.h>

#include <sys/spa.h>

#include <sys/zio.h>

#include <sys/dmu_zfetch.h>

static int free_range_compar(const void *node1, const void *node2);

static kmem_cache_t *dnode_cache;

static dnode_phys_t dnode_phys_zero;

int zfs_default_bs = SPA_MINBLOCKSHIFT;

int zfs_default_ibs = DN_MAX_INDBLKSHIFT;

/* ARGSUSED */

static int

dnode_cons(void *arg, void *unused, int kmflag)

{

	int i;

	dnode_t *dn = arg;

	bzero(dn, sizeof (dnode_t));

	rw_init(&dn->dn_struct_rwlock, NULL, RW_DEFAULT, NULL);

	mutex_init(&dn->dn_mtx, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&dn->dn_dbufs_mtx, NULL, MUTEX_DEFAULT, NULL);

	refcount_create(&dn->dn_holds);

	refcount_create(&dn->dn_tx_holds);

	for (i = 0; i < TXG_SIZE; i++) {

		avl_create(&dn->dn_ranges[i], free_range_compar,

		    sizeof (free_range_t),

		    offsetof(struct free_range, fr_node));

		list_create(&dn->dn_dirty_dbufs[i],

		    sizeof (dmu_buf_impl_t),

		    offsetof(dmu_buf_impl_t, db_dirty_node[i]));

	}

	list_create(&dn->dn_dbufs, sizeof (dmu_buf_impl_t),

	    offsetof(dmu_buf_impl_t, db_link));

	return (0);

}

/* ARGSUSED */

static void

dnode_dest(void *arg, void *unused)

{

	int i;

	dnode_t *dn = arg;

	rw_destroy(&dn->dn_struct_rwlock);

	mutex_destroy(&dn->dn_mtx);

	mutex_destroy(&dn->dn_dbufs_mtx);

	refcount_destroy(&dn->dn_holds);

	refcount_destroy(&dn->dn_tx_holds);

	for (i = 0; i < TXG_SIZE; i++) {

		avl_destroy(&dn->dn_ranges[i]);

		list_destroy(&dn->dn_dirty_dbufs[i]);

	}

	list_destroy(&dn->dn_dbufs);

}

void

dnode_init(void)

{

	dnode_cache = kmem_cache_create("dnode_t",

	    sizeof (dnode_t),

	    0, dnode_cons, dnode_dest, NULL, NULL, NULL, 0);

}

void

dnode_fini(void)

{

	kmem_cache_destroy(dnode_cache);

}

#ifdef ZFS_DEBUG

void

dnode_verify(dnode_t *dn)

{

	int drop_struct_lock = FALSE;

	ASSERT(dn->dn_phys);

	ASSERT(dn->dn_objset);

	ASSERT(dn->dn_phys->dn_type < DMU_OT_NUMTYPES);

	if (!(zfs_flags & ZFS_DEBUG_DNODE_VERIFY))

		return;

	if (!RW_WRITE_HELD(&dn->dn_struct_rwlock)) {

		rw_enter(&dn->dn_struct_rwlock, RW_READER);

		drop_struct_lock = TRUE;

	}

	if (dn->dn_phys->dn_type != DMU_OT_NONE || dn->dn_allocated_txg != 0) {

		int i;

		ASSERT3U(dn->dn_indblkshift, >=, 0);

		ASSERT3U(dn->dn_indblkshift, <=, SPA_MAXBLOCKSHIFT);

		if (dn->dn_datablkshift) {

			ASSERT3U(dn->dn_datablkshift, >=, SPA_MINBLOCKSHIFT);

			ASSERT3U(dn->dn_datablkshift, <=, SPA_MAXBLOCKSHIFT);

			ASSERT3U(1<<dn->dn_datablkshift, ==, dn->dn_datablksz);

		}

		ASSERT3U(dn->dn_nlevels, <=, 30);

		ASSERT3U(dn->dn_type, <=, DMU_OT_NUMTYPES);

		ASSERT3U(dn->dn_nblkptr, >=, 1);

		ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);

		ASSERT3U(dn->dn_bonuslen, <=, DN_MAX_BONUSLEN);

		ASSERT3U(dn->dn_datablksz, ==,

		    dn->dn_datablkszsec << SPA_MINBLOCKSHIFT);

		ASSERT3U(ISP2(dn->dn_datablksz), ==, dn->dn_datablkshift != 0);

		ASSERT3U((dn->dn_nblkptr - 1) * sizeof (blkptr_t) +

		    dn->dn_bonuslen, <=, DN_MAX_BONUSLEN);

		for (i = 0; i < TXG_SIZE; i++) {

			ASSERT3U(dn->dn_next_nlevels[i], <=, dn->dn_nlevels);

		}

	}

	if (dn->dn_phys->dn_type != DMU_OT_NONE)

		ASSERT3U(dn->dn_phys->dn_nlevels, <=, dn->dn_nlevels);

	ASSERT(IS_DNODE_DNODE(dn->dn_object) || dn->dn_dbuf);

	if (dn->dn_dbuf != NULL) {

		ASSERT3P(dn->dn_phys, ==,

		    (dnode_phys_t *)dn->dn_dbuf->db.db_data +

		    (dn->dn_object % (dn->dn_dbuf->db.db_size >> DNODE_SHIFT)));

	}

	if (drop_struct_lock)

		rw_exit(&dn->dn_struct_rwlock);

}

#endif

void

dnode_byteswap(dnode_phys_t *dnp)

{

	uint64_t *buf64 = (void*)&dnp->dn_blkptr;

	int i;

	if (dnp->dn_type == DMU_OT_NONE) {

		bzero(dnp, sizeof (dnode_phys_t));

		return;

	}

	dnp->dn_type = BSWAP_8(dnp->dn_type);

	dnp->dn_indblkshift = BSWAP_8(dnp->dn_indblkshift);

	dnp->dn_nlevels = BSWAP_8(dnp->dn_nlevels);

	dnp->dn_nblkptr = BSWAP_8(dnp->dn_nblkptr);

	dnp->dn_bonustype = BSWAP_8(dnp->dn_bonustype);

	dnp->dn_checksum = BSWAP_8(dnp->dn_checksum);

	dnp->dn_compress = BSWAP_8(dnp->dn_compress);

	dnp->dn_datablkszsec = BSWAP_16(dnp->dn_datablkszsec);

	dnp->dn_bonuslen = BSWAP_16(dnp->dn_bonuslen);

	dnp->dn_maxblkid = BSWAP_64(dnp->dn_maxblkid);

	dnp->dn_secphys = BSWAP_64(dnp->dn_secphys);

	/*

	 * dn_nblkptr is only one byte, so it's OK to read it in either

	 * byte order.  We can't read dn_bouslen.

	 */

	ASSERT(dnp->dn_indblkshift <= SPA_MAXBLOCKSHIFT);

	ASSERT(dnp->dn_nblkptr <= DN_MAX_NBLKPTR);

	for (i = 0; i < dnp->dn_nblkptr * sizeof (blkptr_t)/8; i++)

		buf64[i] = BSWAP_64(buf64[i]);

	/*

	 * OK to check dn_bonuslen for zero, because it won't matter if

	 * we have the wrong byte order.  This is necessary because the

	 * dnode dnode is smaller than a regular dnode.

	 */

	if (dnp->dn_bonuslen != 0) {

		/*

		 * Note that the bonus length calculated here may be

		 * longer than the actual bonus buffer.  This is because

		 * we always put the bonus buffer after the last block

		 * pointer (instead of packing it against the end of the

		 * dnode buffer).

		 */

		int off = (dnp->dn_nblkptr-1) * sizeof (blkptr_t);

		size_t len = DN_MAX_BONUSLEN - off;

		dmu_ot[dnp->dn_bonustype].ot_byteswap(dnp->dn_bonus + off, len);

	}

}

void

dnode_buf_byteswap(void *vbuf, size_t size)

{

	dnode_phys_t *buf = vbuf;

	int i;

	ASSERT3U(sizeof (dnode_phys_t), ==, (1<<DNODE_SHIFT));

	ASSERT((size & (sizeof (dnode_phys_t)-1)) == 0);

	size >>= DNODE_SHIFT;

	for (i = 0; i < size; i++) {

		dnode_byteswap(buf);

		buf++;

	}

}

static int

free_range_compar(const void *node1, const void *node2)

{

	const free_range_t *rp1 = node1;

	const free_range_t *rp2 = node2;

	if (rp1->fr_blkid < rp2->fr_blkid)

		return (-1);

	else if (rp1->fr_blkid > rp2->fr_blkid)

		return (1);

	else return (0);

}

static void

dnode_setdblksz(dnode_t *dn, int size)

{

	ASSERT3U(P2PHASE(size, SPA_MINBLOCKSIZE), ==, 0);

	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);

	ASSERT3U(size, >=, SPA_MINBLOCKSIZE);

	ASSERT3U(size >> SPA_MINBLOCKSHIFT, <,

	    1<<(sizeof (dn->dn_phys->dn_datablkszsec) * 8));

	dn->dn_datablksz = size;

	dn->dn_datablkszsec = size >> SPA_MINBLOCKSHIFT;

	dn->dn_datablkshift = ISP2(size) ? highbit(size - 1) : 0;

}

static dnode_t *

dnode_create(objset_impl_t *os, dnode_phys_t *dnp, dmu_buf_impl_t *db,

    uint64_t object)

{

	dnode_t *dn = kmem_cache_alloc(dnode_cache, KM_SLEEP);

	(void) dnode_cons(dn, NULL, 0); /* XXX */

	dn->dn_objset = os;

	dn->dn_object = object;

	dn->dn_dbuf = db;

	dn->dn_phys = dnp;

	if (dnp->dn_datablkszsec)

		dnode_setdblksz(dn, dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);

	dn->dn_indblkshift = dnp->dn_indblkshift;

	dn->dn_nlevels = dnp->dn_nlevels;

	dn->dn_type = dnp->dn_type;

	dn->dn_nblkptr = dnp->dn_nblkptr;

	dn->dn_checksum = dnp->dn_checksum;

	dn->dn_compress = dnp->dn_compress;

	dn->dn_bonustype = dnp->dn_bonustype;

	dn->dn_bonuslen = dnp->dn_bonuslen;

	dn->dn_maxblkid = dnp->dn_maxblkid;

	dmu_zfetch_init(&dn->dn_zfetch, dn);

	ASSERT(dn->dn_phys->dn_type < DMU_OT_NUMTYPES);

	mutex_enter(&os->os_lock);

	list_insert_head(&os->os_dnodes, dn);

	mutex_exit(&os->os_lock);

	return (dn);

}

static void

dnode_destroy(dnode_t *dn)

{

	objset_impl_t *os = dn->dn_objset;

	mutex_enter(&os->os_lock);

	list_remove(&os->os_dnodes, dn);

	mutex_exit(&os->os_lock);

	if (dn->dn_dirtyctx_firstset) {

		kmem_free(dn->dn_dirtyctx_firstset, 1);

		dn->dn_dirtyctx_firstset = NULL;

	}

	dmu_zfetch_rele(&dn->dn_zfetch);

	kmem_cache_free(dnode_cache, dn);

}

void

dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,

	dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)

{

	int i;

	if (blocksize == 0)

		blocksize = 1 << zfs_default_bs;

	blocksize = MIN(MAX(blocksize, SPA_MINBLOCKSIZE), SPA_MAXBLOCKSIZE);

	if (ibs == 0)

		ibs = zfs_default_ibs;

	ibs = MIN(MAX(ibs, DN_MIN_INDBLKSHIFT), DN_MAX_INDBLKSHIFT);

	dprintf("os=%p obj=%llu txg=%llu blocksize=%d ibs=%d\n", dn->dn_objset,

	    dn->dn_object, tx->tx_txg, blocksize, ibs);

	ASSERT(dn->dn_type == DMU_OT_NONE);

	ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0);

	ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE);

	ASSERT(ot != DMU_OT_NONE);

	ASSERT3U(ot, <, DMU_OT_NUMTYPES);

	ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) ||

	    (bonustype != DMU_OT_NONE && bonuslen != 0));

	ASSERT3U(bonustype, <, DMU_OT_NUMTYPES);

	ASSERT3U(bonuslen, <=, DN_MAX_BONUSLEN);

	ASSERT(dn->dn_type == DMU_OT_NONE);

	ASSERT3U(dn->dn_maxblkid, ==, 0);

	ASSERT3U(dn->dn_allocated_txg, ==, 0);

	ASSERT3U(dn->dn_assigned_txg, ==, 0);

	ASSERT(refcount_is_zero(&dn->dn_tx_holds));

	ASSERT3U(refcount_count(&dn->dn_holds), <=, 1);

	ASSERT3P(list_head(&dn->dn_dbufs), ==, NULL);

	for (i = 0; i < TXG_SIZE; i++) {

		ASSERT3U(dn->dn_next_nlevels[i], ==, 0);

		ASSERT3U(dn->dn_next_indblkshift[i], ==, 0);

		ASSERT3U(dn->dn_dirtyblksz[i], ==, 0);

		ASSERT3P(list_head(&dn->dn_dirty_dbufs[i]), ==, NULL);

		ASSERT3U(avl_numnodes(&dn->dn_ranges[i]), ==, 0);

	}

	dn->dn_type = ot;

	dnode_setdblksz(dn, blocksize);

	dn->dn_indblkshift = ibs;

	dn->dn_nlevels = 1;

	dn->dn_nblkptr = 1 + ((DN_MAX_BONUSLEN - bonuslen) >> SPA_BLKPTRSHIFT);

	dn->dn_bonustype = bonustype;

	dn->dn_bonuslen = bonuslen;

	dn->dn_checksum = ZIO_CHECKSUM_INHERIT;

	dn->dn_compress = ZIO_COMPRESS_INHERIT;

	dn->dn_dirtyctx = 0;

	dn->dn_free_txg = 0;

	if (dn->dn_dirtyctx_firstset) {

		kmem_free(dn->dn_dirtyctx_firstset, 1);

		dn->dn_dirtyctx_firstset = NULL;

	}

	dn->dn_allocated_txg = tx->tx_txg;

	dnode_setdirty(dn, tx);

}

void

dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize,

    dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)

{

	dmu_buf_impl_t *db = NULL;

	ASSERT3U(blocksize, >=, SPA_MINBLOCKSIZE);

	ASSERT3U(blocksize, <=, SPA_MAXBLOCKSIZE);

	ASSERT3U(blocksize % SPA_MINBLOCKSIZE, ==, 0);

	ASSERT3P(list_head(&dn->dn_dbufs), ==, NULL);

	ASSERT(!(dn->dn_object & DMU_PRIVATE_OBJECT) || dmu_tx_private_ok(tx));

	ASSERT(tx->tx_txg != 0);

	ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) ||

	    (bonustype != DMU_OT_NONE && bonuslen != 0));

	ASSERT3U(bonustype, <, DMU_OT_NUMTYPES);

	ASSERT3U(bonuslen, <=, DN_MAX_BONUSLEN);

	ASSERT(dn->dn_dirtyblksz[0] == 0);

	ASSERT(dn->dn_dirtyblksz[1] == 0);

	ASSERT(dn->dn_dirtyblksz[2] == 0);

	ASSERT(dn->dn_dirtyblksz[3] == 0);

	/*

	 * XXX I should really have a generation number to tell if we

	 * need to do this...

	 */

	if (blocksize != dn->dn_datablksz ||

	    dn->dn_bonustype != bonustype || dn->dn_bonuslen != bonuslen) {

		/* free all old data */

		dnode_free_range(dn, 0, -1ULL, tx);

	}

	/* change blocksize */

	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);

	dnode_setdblksz(dn, blocksize);

	dnode_setdirty(dn, tx);

	/* don't need dd_dirty_mtx, dnode is already dirty */

	ASSERT(dn->dn_dirtyblksz[tx->tx_txg&TXG_MASK] != 0);

	dn->dn_dirtyblksz[tx->tx_txg&TXG_MASK] = blocksize;

	rw_exit(&dn->dn_struct_rwlock);

	/* change type */

	dn->dn_type = ot;

	if (dn->dn_bonuslen != bonuslen) {

		/* change bonus size */

		if (bonuslen == 0)

			bonuslen = 1; /* XXX */

		db = dbuf_hold_bonus(dn, FTAG);

		dbuf_read(db);

		mutex_enter(&db->db_mtx);

		ASSERT3U(db->db.db_size, ==, dn->dn_bonuslen);

		ASSERT(db->db.db_data != NULL);

		db->db.db_size = bonuslen;

		mutex_exit(&db->db_mtx);

		dbuf_dirty(db, tx);

	}

	/* change bonus size and type */

	mutex_enter(&dn->dn_mtx);

	dn->dn_bonustype = bonustype;

	dn->dn_bonuslen = bonuslen;

	dn->dn_nblkptr = 1 + ((DN_MAX_BONUSLEN - bonuslen) >> SPA_BLKPTRSHIFT);

	dn->dn_checksum = ZIO_CHECKSUM_INHERIT;

	dn->dn_compress = ZIO_COMPRESS_INHERIT;

	ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);

	dn->dn_allocated_txg = tx->tx_txg;

	mutex_exit(&dn->dn_mtx);

	if (db)

		dbuf_remove_ref(db, FTAG);

}

void

dnode_special_close(dnode_t *dn)

{

	dnode_destroy(dn);

}

dnode_t *

dnode_special_open(objset_impl_t *os, dnode_phys_t *dnp, uint64_t object)

{

	dnode_t *dn = dnode_create(os, dnp, NULL, object);

	DNODE_VERIFY(dn);

	return (dn);

}

static void

dnode_buf_pageout(dmu_buf_t *db, void *arg)

{

	dnode_t **children_dnodes = arg;

	int i;

	int epb = db->db_size >> DNODE_SHIFT;

	for (i = 0; i < epb; i++) {

		dnode_t *dn = children_dnodes[i];

		int n;

		if (dn == NULL)

			continue;

#ifdef ZFS_DEBUG

		/*

		 * If there are holds on this dnode, then there should

		 * be holds on the dnode's containing dbuf as well; thus

		 * it wouldn't be eligable for eviction and this function

		 * would not have been called.

		 */

		ASSERT(refcount_is_zero(&dn->dn_holds));

		ASSERT(list_head(&dn->dn_dbufs) == NULL);

		ASSERT(refcount_is_zero(&dn->dn_tx_holds));

		for (n = 0; n < TXG_SIZE; n++)

			ASSERT(dn->dn_dirtyblksz[n] == 0);

#endif

		children_dnodes[i] = NULL;

		dnode_destroy(dn);

	}

	kmem_free(children_dnodes, epb * sizeof (dnode_t *));

}

/*

 * Returns held dnode if the object number is valid, NULL if not.

 * Note that this will succeed even for free dnodes.

 */

dnode_t *

dnode_hold_impl(objset_impl_t *os, uint64_t object, int flag, void *ref)

{

	int epb, idx;

	int drop_struct_lock = FALSE;

	uint64_t blk;

	dnode_t *mdn, *dn;

	dmu_buf_impl_t *db;

	dnode_t **children_dnodes;

	if (object == 0 || object >= DN_MAX_OBJECT)

		return (NULL);

	mdn = os->os_meta_dnode;

	DNODE_VERIFY(mdn);

	if (!RW_WRITE_HELD(&mdn->dn_struct_rwlock)) {

		rw_enter(&mdn->dn_struct_rwlock, RW_READER);

		drop_struct_lock = TRUE;

	}

	blk = dbuf_whichblock(mdn, object * sizeof (dnode_phys_t));

	db = dbuf_hold(mdn, blk);

	if (drop_struct_lock)