/*

 * 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 2006 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/fm/fs/zfs.h>

#include <sys/spa.h>

#include <sys/txg.h>

#include <sys/spa_impl.h>

#include <sys/vdev_impl.h>

#include <sys/zio_impl.h>

#include <sys/zio_compress.h>

#include <sys/zio_checksum.h>

/*

 * ==========================================================================

 * I/O priority table

 * ==========================================================================

 */

uint8_t zio_priority_table[ZIO_PRIORITY_TABLE_SIZE] = {

	0,	/* ZIO_PRIORITY_NOW		*/

	0,	/* ZIO_PRIORITY_SYNC_READ	*/

	0,	/* ZIO_PRIORITY_SYNC_WRITE	*/

	6,	/* ZIO_PRIORITY_ASYNC_READ	*/

	4,	/* ZIO_PRIORITY_ASYNC_WRITE	*/

	4,	/* ZIO_PRIORITY_FREE		*/

	0,	/* ZIO_PRIORITY_CACHE_FILL	*/

	0,	/* ZIO_PRIORITY_LOG_WRITE	*/

	10,	/* ZIO_PRIORITY_RESILVER	*/

	20,	/* ZIO_PRIORITY_SCRUB		*/

};

/*

 * ==========================================================================

 * I/O type descriptions

 * ==========================================================================

 */

char *zio_type_name[ZIO_TYPES] = {

	"null", "read", "write", "free", "claim", "ioctl" };

/* At or above this size, force gang blocking - for testing */

uint64_t zio_gang_bang = SPA_MAXBLOCKSIZE + 1;

typedef struct zio_sync_pass {

	int	zp_defer_free;		/* defer frees after this pass */

	int	zp_dontcompress;	/* don't compress after this pass */

	int	zp_rewrite;		/* rewrite new bps after this pass */

} zio_sync_pass_t;

zio_sync_pass_t zio_sync_pass = {

	1,	/* zp_defer_free */

	4,	/* zp_dontcompress */

	1,	/* zp_rewrite */

};

/*

 * ==========================================================================

 * I/O kmem caches

 * ==========================================================================

 */

kmem_cache_t *zio_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];

void

zio_init(void)

{

	size_t c;

	/*

	 * For small buffers, we want a cache for each multiple of

	 * SPA_MINBLOCKSIZE.  For medium-size buffers, we want a cache

	 * for each quarter-power of 2.  For large buffers, we want

	 * a cache for each multiple of PAGESIZE.

	 */

	for (c = 0; c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; c++) {

		size_t size = (c + 1) << SPA_MINBLOCKSHIFT;

		size_t p2 = size;

		size_t align = 0;

		while (p2 & (p2 - 1))

			p2 &= p2 - 1;

		if (size <= 4 * SPA_MINBLOCKSIZE) {

			align = SPA_MINBLOCKSIZE;

		} else if (P2PHASE(size, PAGESIZE) == 0) {

			align = PAGESIZE;

		} else if (P2PHASE(size, p2 >> 2) == 0) {

			align = p2 >> 2;

		}

		if (align != 0) {

			char name[30];

			(void) sprintf(name, "zio_buf_%lu", (ulong_t)size);

			zio_buf_cache[c] = kmem_cache_create(name, size,

			    align, NULL, NULL, NULL, NULL, NULL, KMC_NODEBUG);

			dprintf("creating cache for size %5lx align %5lx\n",

			    size, align);

		}

	}

	while (--c != 0) {

		ASSERT(zio_buf_cache[c] != NULL);

		if (zio_buf_cache[c - 1] == NULL)

			zio_buf_cache[c - 1] = zio_buf_cache[c];

	}

	zio_inject_init();

}

void

zio_fini(void)

{

	size_t c;

	kmem_cache_t *last_cache = NULL;

	for (c = 0; c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; c++) {

		if (zio_buf_cache[c] != last_cache) {

			last_cache = zio_buf_cache[c];

			kmem_cache_destroy(zio_buf_cache[c]);

		}

		zio_buf_cache[c] = NULL;

	}

	zio_inject_fini();

}

/*

 * ==========================================================================

 * Allocate and free I/O buffers

 * ==========================================================================

 */

void *

zio_buf_alloc(size_t size)

{

	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;

	ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);

	return (kmem_cache_alloc(zio_buf_cache[c], KM_SLEEP));

}

void

zio_buf_free(void *buf, size_t size)

{

	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;

	ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);

	kmem_cache_free(zio_buf_cache[c], buf);

}

/*

 * ==========================================================================

 * Push and pop I/O transform buffers

 * ==========================================================================

 */

static void

zio_push_transform(zio_t *zio, void *data, uint64_t size, uint64_t bufsize)

{

	zio_transform_t *zt = kmem_alloc(sizeof (zio_transform_t), KM_SLEEP);

	zt->zt_data = data;

	zt->zt_size = size;

	zt->zt_bufsize = bufsize;

	zt->zt_next = zio->io_transform_stack;

	zio->io_transform_stack = zt;

	zio->io_data = data;

	zio->io_size = size;

}

static void

zio_pop_transform(zio_t *zio, void **data, uint64_t *size, uint64_t *bufsize)

{

	zio_transform_t *zt = zio->io_transform_stack;

	*data = zt->zt_data;

	*size = zt->zt_size;

	*bufsize = zt->zt_bufsize;

	zio->io_transform_stack = zt->zt_next;

	kmem_free(zt, sizeof (zio_transform_t));

	if ((zt = zio->io_transform_stack) != NULL) {

		zio->io_data = zt->zt_data;

		zio->io_size = zt->zt_size;

	}

}

static void

zio_clear_transform_stack(zio_t *zio)

{

	void *data;

	uint64_t size, bufsize;

	ASSERT(zio->io_transform_stack != NULL);

	zio_pop_transform(zio, &data, &size, &bufsize);

	while (zio->io_transform_stack != NULL) {

		zio_buf_free(data, bufsize);

		zio_pop_transform(zio, &data, &size, &bufsize);

	}

}

/*

 * ==========================================================================

 * Create the various types of I/O (read, write, free)

 * ==========================================================================

 */

static zio_t *

zio_create(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,

    void *data, uint64_t size, zio_done_func_t *done, void *private,

    zio_type_t type, int priority, int flags, uint8_t stage, uint32_t pipeline)

{

	zio_t *zio;

	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);

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

	zio = kmem_zalloc(sizeof (zio_t), KM_SLEEP);

	zio->io_parent = pio;

	zio->io_spa = spa;

	zio->io_txg = txg;

	if (bp != NULL) {

		zio->io_bp = bp;

		zio->io_bp_copy = *bp;

		zio->io_bp_orig = *bp;

	}

	zio->io_done = done;

	zio->io_private = private;

	zio->io_type = type;

	zio->io_priority = priority;

	zio->io_stage = stage;

	zio->io_pipeline = pipeline;

	zio->io_async_stages = ZIO_ASYNC_PIPELINE_STAGES;

	zio->io_timestamp = lbolt64;

	zio->io_flags = flags;

	mutex_init(&zio->io_lock, NULL, MUTEX_DEFAULT, NULL);

	zio_push_transform(zio, data, size, size);

	if (pio == NULL) {

		if (!(flags & ZIO_FLAG_CONFIG_HELD))

			spa_config_enter(zio->io_spa, RW_READER, zio);

		zio->io_root = zio;

	} else {

		zio->io_root = pio->io_root;

		if (!(flags & ZIO_FLAG_NOBOOKMARK))

			zio->io_logical = pio->io_logical;

		mutex_enter(&pio->io_lock);

		if (stage < ZIO_STAGE_READY)

			pio->io_children_notready++;

		pio->io_children_notdone++;

		zio->io_sibling_next = pio->io_child;

		zio->io_sibling_prev = NULL;

		if (pio->io_child != NULL)

			pio->io_child->io_sibling_prev = zio;

		pio->io_child = zio;

		zio->io_ndvas = pio->io_ndvas;

		mutex_exit(&pio->io_lock);

	}

	return (zio);

}

zio_t *

zio_null(zio_t *pio, spa_t *spa, zio_done_func_t *done, void *private,

	int flags)

{

	zio_t *zio;

	zio = zio_create(pio, spa, 0, NULL, NULL, 0, done, private,

	    ZIO_TYPE_NULL, ZIO_PRIORITY_NOW, flags, ZIO_STAGE_OPEN,

	    ZIO_WAIT_FOR_CHILDREN_PIPELINE);

	return (zio);

}

zio_t *

zio_root(spa_t *spa, zio_done_func_t *done, void *private, int flags)

{

	return (zio_null(NULL, spa, done, private, flags));

}

zio_t *

zio_read(zio_t *pio, spa_t *spa, blkptr_t *bp, void *data,

    uint64_t size, zio_done_func_t *done, void *private,

    int priority, int flags, zbookmark_t *zb)

{

	zio_t *zio;

	ASSERT3U(size, ==, BP_GET_LSIZE(bp));

	zio = zio_create(pio, spa, bp->blk_birth, bp, data, size, done, private,

	    ZIO_TYPE_READ, priority, flags | ZIO_FLAG_USER,

	    ZIO_STAGE_OPEN, ZIO_READ_PIPELINE);

	zio->io_bookmark = *zb;

	zio->io_logical = zio;

	/*

	 * Work off our copy of the bp so the caller can free it.

	 */

	zio->io_bp = &zio->io_bp_copy;

	if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF) {

		uint64_t csize = BP_GET_PSIZE(bp);

		void *cbuf = zio_buf_alloc(csize);

		zio_push_transform(zio, cbuf, csize, csize);

		zio->io_pipeline |= 1U << ZIO_STAGE_READ_DECOMPRESS;

	}

	if (BP_IS_GANG(bp)) {

		uint64_t gsize = SPA_GANGBLOCKSIZE;

		void *gbuf = zio_buf_alloc(gsize);

		zio_push_transform(zio, gbuf, gsize, gsize);

		zio->io_pipeline |= 1U << ZIO_STAGE_READ_GANG_MEMBERS;

	}

	return (zio);

}

zio_t *

zio_write(zio_t *pio, spa_t *spa, int checksum, int compress, int ncopies,

    uint64_t txg, blkptr_t *bp, void *data, uint64_t size,

    zio_done_func_t *done, void *private, int priority, int flags,

    zbookmark_t *zb)

{

	zio_t *zio;

	ASSERT(checksum >= ZIO_CHECKSUM_OFF &&

	    checksum < ZIO_CHECKSUM_FUNCTIONS);

	ASSERT(compress >= ZIO_COMPRESS_OFF &&

	    compress < ZIO_COMPRESS_FUNCTIONS);

	zio = zio_create(pio, spa, txg, bp, data, size, done, private,

	    ZIO_TYPE_WRITE, priority, flags | ZIO_FLAG_USER,

	    ZIO_STAGE_OPEN, ZIO_WRITE_PIPELINE);

	zio->io_bookmark = *zb;

	zio->io_logical = zio;

	zio->io_checksum = checksum;

	zio->io_compress = compress;

	zio->io_ndvas = ncopies;

	if (compress != ZIO_COMPRESS_OFF)

		zio->io_async_stages |= 1U << ZIO_STAGE_WRITE_COMPRESS;

	if (bp->blk_birth != txg) {

		/* XXX the bp usually (always?) gets re-zeroed later */

		BP_ZERO(bp);

		BP_SET_LSIZE(bp, size);

		BP_SET_PSIZE(bp, size);

	} else {

		/* Make sure someone doesn't change their mind on overwrites */

		ASSERT(MIN(zio->io_ndvas + BP_IS_GANG(bp),

		    spa_max_replication(spa)) == BP_GET_NDVAS(bp));

	}

	return (zio);

}

zio_t *

zio_rewrite(zio_t *pio, spa_t *spa, int checksum,

    uint64_t txg, blkptr_t *bp, void *data, uint64_t size,

    zio_done_func_t *done, void *private, int priority, int flags,

    zbookmark_t *zb)

{

	zio_t *zio;

	zio = zio_create(pio, spa, txg, bp, data, size, done, private,

	    ZIO_TYPE_WRITE, priority, flags | ZIO_FLAG_USER,

	    ZIO_STAGE_OPEN, ZIO_REWRITE_PIPELINE);

	zio->io_bookmark = *zb;

	zio->io_checksum = checksum;

	zio->io_compress = ZIO_COMPRESS_OFF;

	if (pio != NULL)

		ASSERT3U(zio->io_ndvas, <=, BP_GET_NDVAS(bp));

	return (zio);

}

static zio_t *

zio_write_allocate(zio_t *pio, spa_t *spa, int checksum,

    uint64_t txg, blkptr_t *bp, void *data, uint64_t size,

    zio_done_func_t *done, void *private, int priority, int flags)

{

	zio_t *zio;

	BP_ZERO(bp);

	BP_SET_LSIZE(bp, size);

	BP_SET_PSIZE(bp, size);

	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);

	zio = zio_create(pio, spa, txg, bp, data, size, done, private,

	    ZIO_TYPE_WRITE, priority, flags,

	    ZIO_STAGE_OPEN, ZIO_WRITE_ALLOCATE_PIPELINE);

	zio->io_checksum = checksum;

	zio->io_compress = ZIO_COMPRESS_OFF;

	return (zio);

}

zio_t *

zio_free(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,

    zio_done_func_t *done, void *private)

{

	zio_t *zio;

	ASSERT(!BP_IS_HOLE(bp));

	if (txg == spa->spa_syncing_txg &&

	    spa->spa_sync_pass > zio_sync_pass.zp_defer_free) {

		bplist_enqueue_deferred(&spa->spa_sync_bplist, bp);

		return (zio_null(pio, spa, NULL, NULL, 0));

	}

	zio = zio_create(pio, spa, txg, bp, NULL, 0, done, private,

	    ZIO_TYPE_FREE, ZIO_PRIORITY_FREE, ZIO_FLAG_USER,

	    ZIO_STAGE_OPEN, ZIO_FREE_PIPELINE);

	zio->io_bp = &zio->io_bp_copy;

	return (zio);

}

zio_t *

zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,

    zio_done_func_t *done, void *private)

{

	zio_t *zio;

	/*

	 * A claim is an allocation of a specific block.  Claims are needed

	 * to support immediate writes in the intent log.  The issue is that

	 * immediate writes contain committed data, but in a txg that was

	 * *not* committed.  Upon opening the pool after an unclean shutdown,

	 * the intent log claims all blocks that contain immediate write data

	 * so that the SPA knows they're in use.

	 *

	 * All claims *must* be resolved in the first txg -- before the SPA

	 * starts allocating blocks -- so that nothing is allocated twice.

	 */

	ASSERT3U(spa->spa_uberblock.ub_rootbp.blk_birth, <, spa_first_txg(spa));

	ASSERT3U(spa_first_txg(spa), <=, txg);

	zio = zio_create(pio, spa, txg, bp, NULL, 0, done, private,

	    ZIO_TYPE_CLAIM, ZIO_PRIORITY_NOW, 0,

	    ZIO_STAGE_OPEN, ZIO_CLAIM_PIPELINE);

	zio->io_bp = &zio->io_bp_copy;

	return (zio);

}

zio_t *

zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd,

    zio_done_func_t *done, void *private, int priority, int flags)

{

	zio_t *zio;

	int c;

	if (vd->vdev_children == 0) {

		zio = zio_create(pio, spa, 0, NULL, NULL, 0, done, private,

		    ZIO_TYPE_IOCTL, priority, flags,

		    ZIO_STAGE_OPEN, ZIO_IOCTL_PIPELINE);

		zio->io_vd = vd;

		zio->io_cmd = cmd;

	} else {

		zio = zio_null(pio, spa, NULL, NULL, flags);

		for (c = 0; c < vd->vdev_children; c++)

			zio_nowait(zio_ioctl(zio, spa, vd->vdev_child[c], cmd,

			    done, private, priority, flags));

	}

	return (zio);

}

static void

zio_phys_bp_init(vdev_t *vd, blkptr_t *bp, uint64_t offset, uint64_t size,

    int checksum)

{

	ASSERT(vd->vdev_children == 0);

	ASSERT(size <= SPA_MAXBLOCKSIZE);

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

	ASSERT(P2PHASE(offset, SPA_MINBLOCKSIZE) == 0);

	ASSERT(offset + size <= VDEV_LABEL_START_SIZE ||

	    offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE);