/*

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

 */

#include <sys/dmu.h>

#include <sys/dmu_impl.h>

#include <sys/dbuf.h>

#include <sys/dmu_tx.h>

#include <sys/dmu_objset.h>

#include <sys/dsl_dataset.h> /* for dsl_dataset_block_freeable() */

#include <sys/dsl_dir.h> /* for dsl_dir_tempreserve_*() */

#include <sys/dsl_pool.h>

#include <sys/zap_impl.h> /* for fzap_default_block_shift */

#include <sys/spa.h>

#include <sys/zfs_context.h>

typedef void (*dmu_tx_hold_func_t)(dmu_tx_t *tx, struct dnode *dn,

    uint64_t arg1, uint64_t arg2);

dmu_tx_t *

dmu_tx_create_dd(dsl_dir_t *dd)

{

	dmu_tx_t *tx = kmem_zalloc(sizeof (dmu_tx_t), KM_SLEEP);

	tx->tx_dir = dd;

	if (dd)

		tx->tx_pool = dd->dd_pool;

	list_create(&tx->tx_holds, sizeof (dmu_tx_hold_t),

	    offsetof(dmu_tx_hold_t, txh_node));

#ifdef ZFS_DEBUG

	refcount_create(&tx->tx_space_written);

	refcount_create(&tx->tx_space_freed);

#endif

	return (tx);

}

dmu_tx_t *

dmu_tx_create(objset_t *os)

{

	dmu_tx_t *tx = dmu_tx_create_dd(os->os->os_dsl_dataset->ds_dir);

	tx->tx_objset = os;

	tx->tx_lastsnap_txg = dsl_dataset_prev_snap_txg(os->os->os_dsl_dataset);

	return (tx);

}

dmu_tx_t *

dmu_tx_create_assigned(struct dsl_pool *dp, uint64_t txg)

{

	dmu_tx_t *tx = dmu_tx_create_dd(NULL);

	ASSERT3U(txg, <=, dp->dp_tx.tx_open_txg);

	tx->tx_pool = dp;

	tx->tx_txg = txg;

	tx->tx_anyobj = TRUE;

	return (tx);

}

int

dmu_tx_is_syncing(dmu_tx_t *tx)

{

	return (tx->tx_anyobj);

}

int

dmu_tx_private_ok(dmu_tx_t *tx)

{

	return (tx->tx_anyobj);

}

static dmu_tx_hold_t *

dmu_tx_hold_object_impl(dmu_tx_t *tx, objset_t *os, uint64_t object,

    enum dmu_tx_hold_type type, uint64_t arg1, uint64_t arg2)

{

	dmu_tx_hold_t *txh;

	dnode_t *dn = NULL;

	int err;

	if (object != DMU_NEW_OBJECT) {

		err = dnode_hold(os->os, object, tx, &dn);

		if (err) {

			tx->tx_err = err;

			return (NULL);

		}

		if (err == 0 && tx->tx_txg != 0) {

			mutex_enter(&dn->dn_mtx);

			/*

			 * dn->dn_assigned_txg == tx->tx_txg doesn't pose a

			 * problem, but there's no way for it to happen (for

			 * now, at least).

			 */

			ASSERT(dn->dn_assigned_txg == 0);

			dn->dn_assigned_txg = tx->tx_txg;

			(void) refcount_add(&dn->dn_tx_holds, tx);

			mutex_exit(&dn->dn_mtx);

		}

	}

	txh = kmem_zalloc(sizeof (dmu_tx_hold_t), KM_SLEEP);

	txh->txh_tx = tx;

	txh->txh_dnode = dn;

#ifdef ZFS_DEBUG

	txh->txh_type = type;

	txh->txh_arg1 = arg1;

	txh->txh_arg2 = arg2;

#endif

	list_insert_tail(&tx->tx_holds, txh);

	return (txh);

}

void

dmu_tx_add_new_object(dmu_tx_t *tx, objset_t *os, uint64_t object)

{

	/*

	 * If we're syncing, they can manipulate any object anyhow, and

	 * the hold on the dnode_t can cause problems.

	 */

	if (!dmu_tx_is_syncing(tx)) {

		(void) dmu_tx_hold_object_impl(tx, os,

		    object, THT_NEWOBJECT, 0, 0);

	}

}

static int

dmu_tx_check_ioerr(zio_t *zio, dnode_t *dn, int level, uint64_t blkid)

{

	int err;

	dmu_buf_impl_t *db;

	rw_enter(&dn->dn_struct_rwlock, RW_READER);

	db = dbuf_hold_level(dn, level, blkid, FTAG);

	rw_exit(&dn->dn_struct_rwlock);

	if (db == NULL)

		return (EIO);

	err = dbuf_read(db, zio, DB_RF_CANFAIL | DB_RF_NOPREFETCH);

	dbuf_rele(db, FTAG);

	return (err);

}

static void

dmu_tx_count_indirects(dmu_tx_hold_t *txh, dmu_buf_impl_t *db,

    boolean_t freeable, dmu_buf_impl_t **history)

{

	int i = db->db_level + 1;

	dnode_t *dn = db->db_dnode;

	if (i >= dn->dn_nlevels)

		return;

	db = db->db_parent;

	if (db == NULL) {

		uint64_t lvls = dn->dn_nlevels - i;

		txh->txh_space_towrite += lvls << dn->dn_indblkshift;

		return;

	}

	if (db != history[i]) {

		dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;

		uint64_t space = 1ULL << dn->dn_indblkshift;

		freeable = (db->db_blkptr && (freeable ||

		    dsl_dataset_block_freeable(ds, db->db_blkptr->blk_birth)));

		if (freeable)

			txh->txh_space_tooverwrite += space;

		else

			txh->txh_space_towrite += space;

		if (db->db_blkptr)

			txh->txh_space_tounref += space;

		history[i] = db;

		dmu_tx_count_indirects(txh, db, freeable, history);

	}

}

/* ARGSUSED */

static void

dmu_tx_count_write(dmu_tx_hold_t *txh, uint64_t off, uint64_t len)

{

	dnode_t *dn = txh->txh_dnode;

	uint64_t start, end, i;

	int min_bs, max_bs, min_ibs, max_ibs, epbs, bits;

	int err = 0;

	if (len == 0)

		return;

	min_bs = SPA_MINBLOCKSHIFT;

	max_bs = SPA_MAXBLOCKSHIFT;

	min_ibs = DN_MIN_INDBLKSHIFT;

	max_ibs = DN_MAX_INDBLKSHIFT;

	if (dn) {

		dmu_buf_impl_t *last[DN_MAX_LEVELS];

		int nlvls = dn->dn_nlevels;

		int delta;

		/*

		 * For i/o error checking, read the first and last level-0

		 * blocks (if they are not aligned), and all the level-1 blocks.

		 */

		if (dn->dn_maxblkid == 0) {

			delta = dn->dn_datablksz;

			start = (off < dn->dn_datablksz) ? 0 : 1;

			end = (off+len <= dn->dn_datablksz) ? 0 : 1;

			if (start == 0 && (off > 0 || len < dn->dn_datablksz)) {

				err = dmu_tx_check_ioerr(NULL, dn, 0, 0);

				if (err)

					goto out;

				delta -= off;

			}

		} else {

			zio_t *zio = zio_root(dn->dn_objset->os_spa,

			    NULL, NULL, ZIO_FLAG_CANFAIL);

			/* first level-0 block */

			start = off >> dn->dn_datablkshift;

			if (P2PHASE(off, dn->dn_datablksz) ||

			    len < dn->dn_datablksz) {

				err = dmu_tx_check_ioerr(zio, dn, 0, start);

				if (err)

					goto out;

			}

			/* last level-0 block */

			end = (off+len-1) >> dn->dn_datablkshift;

			if (end != start && end <= dn->dn_maxblkid &&

			    P2PHASE(off+len, dn->dn_datablksz)) {

				err = dmu_tx_check_ioerr(zio, dn, 0, end);

				if (err)

					goto out;

			}

			/* level-1 blocks */

			if (nlvls > 1) {

				int shft = dn->dn_indblkshift - SPA_BLKPTRSHIFT;

				for (i = (start>>shft)+1; i < end>>shft; i++) {

					err = dmu_tx_check_ioerr(zio, dn, 1, i);

					if (err)

						goto out;

				}

			}

			err = zio_wait(zio);

			if (err)

				goto out;

			delta = P2NPHASE(off, dn->dn_datablksz);

		}

		if (dn->dn_maxblkid > 0) {

			/*

			 * The blocksize can't change,

			 * so we can make a more precise estimate.

			 */

			ASSERT(dn->dn_datablkshift != 0);

			min_bs = max_bs = dn->dn_datablkshift;

			min_ibs = max_ibs = dn->dn_indblkshift;

		} else if (dn->dn_indblkshift > max_ibs) {

			/*

			 * This ensures that if we reduce DN_MAX_INDBLKSHIFT,

			 * the code will still work correctly on older pools.

			 */

			min_ibs = max_ibs = dn->dn_indblkshift;

		}

		/*

		 * If this write is not off the end of the file

		 * we need to account for overwrites/unref.

		 */

		if (start <= dn->dn_maxblkid)

			bzero(last, sizeof (dmu_buf_impl_t *) * DN_MAX_LEVELS);

		while (start <= dn->dn_maxblkid) {

			spa_t *spa = txh->txh_tx->tx_pool->dp_spa;

			dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;

			dmu_buf_impl_t *db;

			rw_enter(&dn->dn_struct_rwlock, RW_READER);

			db = dbuf_hold_level(dn, 0, start, FTAG);

			rw_exit(&dn->dn_struct_rwlock);

			if (db->db_blkptr && dsl_dataset_block_freeable(ds,

			    db->db_blkptr->blk_birth)) {

				dprintf_bp(db->db_blkptr, "can free old%s", "");

				txh->txh_space_tooverwrite += dn->dn_datablksz;

				txh->txh_space_tounref += dn->dn_datablksz;

				dmu_tx_count_indirects(txh, db, TRUE, last);

			} else {

				txh->txh_space_towrite += dn->dn_datablksz;

				if (db->db_blkptr)

					txh->txh_space_tounref +=

					    bp_get_dasize(spa, db->db_blkptr);

				dmu_tx_count_indirects(txh, db, FALSE, last);

			}

			dbuf_rele(db, FTAG);

			if (++start > end) {

				/*

				 * Account for new indirects appearing

				 * before this IO gets assigned into a txg.

				 */

				bits = 64 - min_bs;

				epbs = min_ibs - SPA_BLKPTRSHIFT;

				for (bits -= epbs * (nlvls - 1);

				    bits >= 0; bits -= epbs)

					txh->txh_fudge += 1ULL << max_ibs;

				goto out;

			}

			off += delta;

			if (len >= delta)

				len -= delta;

			delta = dn->dn_datablksz;

		}

	}

	/*

	 * 'end' is the last thing we will access, not one past.

	 * This way we won't overflow when accessing the last byte.

	 */

	start = P2ALIGN(off, 1ULL << max_bs);

	end = P2ROUNDUP(off + len, 1ULL << max_bs) - 1;

	txh->txh_space_towrite += end - start + 1;

	start >>= min_bs;

	end >>= min_bs;

	epbs = min_ibs - SPA_BLKPTRSHIFT;

	/*

	 * The object contains at most 2^(64 - min_bs) blocks,

	 * and each indirect level maps 2^epbs.

	 */

	for (bits = 64 - min_bs; bits >= 0; bits -= epbs) {

		start >>= epbs;

		end >>= epbs;

		ASSERT3U(end, >=, start);

		txh->txh_space_towrite += (end - start + 1) << max_ibs;

		if (start != 0) {

			/*

			 * We also need a new blkid=0 indirect block

			 * to reference any existing file data.

			 */

			txh->txh_space_towrite += 1ULL << max_ibs;

		}

	}

out:

	if (txh->txh_space_towrite + txh->txh_space_tooverwrite >

	    2 * DMU_MAX_ACCESS)

		err = EFBIG;

	if (err)

		txh->txh_tx->tx_err = err;

}

static void

dmu_tx_count_dnode(dmu_tx_hold_t *txh)

{

	dnode_t *dn = txh->txh_dnode;

	dnode_t *mdn = txh->txh_tx->tx_objset->os->os_meta_dnode;

	uint64_t space = mdn->dn_datablksz +

	    ((mdn->dn_nlevels-1) << mdn->dn_indblkshift);

	if (dn && dn->dn_dbuf->db_blkptr &&

	    dsl_dataset_block_freeable(dn->dn_objset->os_dsl_dataset,

	    dn->dn_dbuf->db_blkptr->blk_birth)) {

		txh->txh_space_tooverwrite += space;

		txh->txh_space_tounref += space;

	} else {

		txh->txh_space_towrite += space;

		if (dn && dn->dn_dbuf->db_blkptr)

			txh->txh_space_tounref += space;

	}

}

void

dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len)

{

	dmu_tx_hold_t *txh;

	ASSERT(tx->tx_txg == 0);

	ASSERT(len < DMU_MAX_ACCESS);

	ASSERT(len == 0 || UINT64_MAX - off >= len - 1);

	txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,

	    object, THT_WRITE, off, len);

	if (txh == NULL)

		return;

	dmu_tx_count_write(txh, off, len);

	dmu_tx_count_dnode(txh);

}

static void

dmu_tx_count_free(dmu_tx_hold_t *txh, uint64_t off, uint64_t len)

{

	uint64_t blkid, nblks, lastblk;

	uint64_t space = 0, unref = 0, skipped = 0;

	dnode_t *dn = txh->txh_dnode;

	dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;

	spa_t *spa = txh->txh_tx->tx_pool->dp_spa;

	int epbs;

	if (dn->dn_nlevels == 0)

		return;

	/*

	 * The struct_rwlock protects us against dn_nlevels

	 * changing, in case (against all odds) we manage to dirty &

	 * sync out the changes after we check for being dirty.

	 * Also, dbuf_hold_level() wants us to have the struct_rwlock.

	 */

	rw_enter(&dn->dn_struct_rwlock, RW_READER);

	epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;

	if (dn->dn_maxblkid == 0) {

		if (off == 0 && len >= dn->dn_datablksz) {

			blkid = 0;

			nblks = 1;

		} else {

			rw_exit(&dn->dn_struct_rwlock);

			return;

		}

	} else {

		blkid = off >> dn->dn_datablkshift;

		nblks = (len + dn->dn_datablksz - 1) >> dn->dn_datablkshift;

		if (blkid >= dn->dn_maxblkid) {

			rw_exit(&dn->dn_struct_rwlock);

			return;

		}

		if (blkid + nblks > dn->dn_maxblkid)

			nblks = dn->dn_maxblkid - blkid;

	}

	if (dn->dn_nlevels == 1) {

		int i;

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

			blkptr_t *bp = dn->dn_phys->dn_blkptr;

			ASSERT3U(blkid + i, <, dn->dn_nblkptr);

			bp += blkid + i;

			if (dsl_dataset_block_freeable(ds, bp->blk_birth)) {

				dprintf_bp(bp, "can free old%s", "");

				space += bp_get_dasize(spa, bp);

			}

			unref += BP_GET_ASIZE(bp);

		}

		nblks = 0;

	}

	/*

	 * Add in memory requirements of higher-level indirects.

	 * This assumes a worst-possible scenario for dn_nlevels.

	 */

	{

		uint64_t blkcnt = 1 + ((nblks >> epbs) >> epbs);

		int level = (dn->dn_nlevels > 1) ? 2 : 1;

		while (level++ < DN_MAX_LEVELS) {

			txh->txh_memory_tohold += blkcnt << dn->dn_indblkshift;

			blkcnt = 1 + (blkcnt >> epbs);

		}

		ASSERT(blkcnt <= dn->dn_nblkptr);

	}

	lastblk = blkid + nblks - 1;

	while (nblks) {

		dmu_buf_impl_t *dbuf;

		uint64_t ibyte, new_blkid;

		int epb = 1 << epbs;

		int err, i, blkoff, tochk;

		blkptr_t *bp;

		ibyte = blkid << dn->dn_datablkshift;

		err = dnode_next_offset(dn,

		    DNODE_FIND_HAVELOCK, &ibyte, 2, 1, 0);

		new_blkid = ibyte >> dn->dn_datablkshift;

		if (err == ESRCH) {

			skipped += (lastblk >> epbs) - (blkid >> epbs) + 1;