/*

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

 * Use is subject to license terms.

 */

#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_crypt.h>

#include <sys/zio_checksum.h>

#include <sys/zil.h>

#include <sys/sdt.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" };

#define	SYNC_PASS_DEFERRED_FREE	1	/* defer frees after this pass */

#define	SYNC_PASS_DONT_COMPRESS	4	/* don't compress after this pass */

#define	SYNC_PASS_REWRITE	1	/* rewrite new bps after this pass */

/*

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

 * I/O kmem caches

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

 */

kmem_cache_t *zio_cache;

kmem_cache_t *zio_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];

kmem_cache_t *zio_data_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];

#ifdef _KERNEL

extern vmem_t *zio_alloc_arena;

#endif

/*

 * An allocating zio is one that either currently has the DVA allocate

 * stage set or will have it later in its lifetime.

 */

#define	IO_IS_ALLOCATING(zio) \

	((zio)->io_orig_pipeline & (1U << ZIO_STAGE_DVA_ALLOCATE))

void

zio_init(void)

{

	size_t c;

	vmem_t *data_alloc_arena = NULL;

#ifdef _KERNEL

	data_alloc_arena = zio_alloc_arena;

#endif

	zio_cache = kmem_cache_create("zio_cache", sizeof (zio_t), 0,

	    NULL, NULL, NULL, NULL, NULL, 0);

	/*

	 * 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[36];

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

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

			zio_data_buf_cache[c] = kmem_cache_create(name, size,

			    align, NULL, NULL, NULL, NULL, data_alloc_arena,

			    KMC_NODEBUG);

		}

	}

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

		ASSERT(zio_data_buf_cache[c] != NULL);

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

			zio_data_buf_cache[c - 1] = zio_data_buf_cache[c];

	}

	zio_inject_init();

}

void

zio_fini(void)

{

	size_t c;

	kmem_cache_t *last_cache = NULL;

	kmem_cache_t *last_data_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;

		if (zio_data_buf_cache[c] != last_data_cache) {

			last_data_cache = zio_data_buf_cache[c];

			kmem_cache_destroy(zio_data_buf_cache[c]);

		}

		zio_data_buf_cache[c] = NULL;

	}

	kmem_cache_destroy(zio_cache);

	zio_inject_fini();

}

/*

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

 * Allocate and free I/O buffers

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

 */

/*

 * Use zio_buf_alloc to allocate ZFS metadata.  This data will appear in a

 * crashdump if the kernel panics, so use it judiciously.  Obviously, it's

 * useful to inspect ZFS metadata, but if possible, we should avoid keeping

 * excess / transient data in-core during a crashdump.

 */

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

}

/*

 * Use zio_data_buf_alloc to allocate data.  The data will not appear in a

 * crashdump if the kernel panics.  This exists so that we will limit the amount

 * of ZFS data that shows up in a kernel crashdump.  (Thus reducing the amount

 * of kernel heap dumped to disk when the kernel panics)

 */

void *

zio_data_buf_alloc(size_t size)

{

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

	ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);

	return (kmem_cache_alloc(zio_data_buf_cache[c], KM_PUSHPAGE));

}

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

}

void

zio_data_buf_free(void *buf, size_t size)

{

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

	ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);

	kmem_cache_free(zio_data_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_func_t *transform)

{

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

	zt->zt_orig_data = zio->io_data;

	zt->zt_orig_size = zio->io_size;

	zt->zt_bufsize = bufsize;

	zt->zt_transform = transform;

	zt->zt_next = zio->io_transform_stack;

	zio->io_transform_stack = zt;

	zio->io_data = data;

	zio->io_size = size;

}

static void

zio_pop_transforms(zio_t *zio)

{

	zio_transform_t *zt;

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

		if (zt->zt_transform != NULL)

			zt->zt_transform(zio,

			    zt->zt_orig_data, zt->zt_orig_size);

		zio_buf_free(zio->io_data, zt->zt_bufsize);

		zio->io_data = zt->zt_orig_data;

		zio->io_size = zt->zt_orig_size;

		zio->io_transform_stack = zt->zt_next;

		kmem_free(zt, sizeof (zio_transform_t));

	}

}

/*

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

 * I/O transform callbacks for subblocks, decompression and decryption

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

 */

static void

zio_subblock(zio_t *zio, void *data, uint64_t size)

{

	ASSERT(zio->io_size > size);

	if (zio->io_type == ZIO_TYPE_READ)

		bcopy(zio->io_data, data, size);

}

static void

zio_decompress(zio_t *zio, void *data, uint64_t size)

{

	if (zio->io_error == 0 &&

	    zio_decompress_data(BP_GET_COMPRESS(zio->io_bp),

	    zio->io_data, zio->io_size, data, size) != 0)

		zio->io_error = EIO;

}

static void

zio_decrypt(zio_t *zio, void *data, uint64_t size)

{

	blkptr_t *bp = zio->io_bp;

	int type = BP_GET_TYPE(bp);

	int crypt = BP_GET_CRYPT(bp);

	uint64_t mac[2];

	int crypt_error = 0;

	ASSERT3U(spa_version(zio->io_spa), >=, SPA_VERSION_CRYPTO);

	ASSERT3U(crypt, !=, ZIO_CRYPT_OFF);

	ASSERT3U(crypt, !=, ZIO_CRYPT_INHERIT);

	if (type == DMU_OT_INTENT_LOG) {

		zil_trailer_t *ztp;

		ztp = (zil_trailer_t *)((char *)zio->io_data

		    + zio->io_size) - 1;

		mac[0] = BE_64(ztp->zit_mac);

		mac[1] = 0;

	} else {

		ASSERT3U(16, ==, zio_crypt_table[crypt].ci_maclen);

		/* MAC is in the blkptr as the top two words of the checksum */

		ASSERT3U(BP_GET_CHECKSUM(bp), ==, ZIO_CHECKSUM_SHA256_CCM_MAC);

		mac[0] = BE_64(bp->blk_cksum.zc_word[2]);

		mac[1] = BE_64(bp->blk_cksum.zc_word[3]);

	}

	crypt_error = zio_decrypt_data(crypt, zio->io_spa,

	    &zio->io_bookmark, bp->blk_birth, type,

	    zio->io_data, zio->io_size, &mac, data, size);

	/*

	 * If we didn't have the decryption key we get EAGAIN so post an

	 * FMA event.

	 */

	if (crypt_error != 0) {

		if (crypt_error == EAGAIN) {

			zfs_ereport_post(FM_EREPORT_ZFS_CRYPTO_KEY_UNAVAIL,

			    zio->io_spa, zio->io_vd, zio, 0, 0);

			/*

			 * If it is a dnode we were looking for we need the

			 * clear text parts to be passed on.

			 */

#ifdef _KERNEL

			if (type == DMU_OT_DNODE || type == DMU_OT_INTENT_LOG) {

#endif

				DTRACE_PROBE2(zio__ciphertext__dnode,

				    blkptr_t *, bp, zbookmark_t *,

				    &zio->io_bookmark);

				bcopy(zio->io_data, data, size);

				crypt_error = 0;

#ifdef _KERNEL

			}

#endif

		}

		zio->io_error = crypt_error;

	}

}

/*

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

 * I/O parent/child relationships and pipeline interlocks

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

 */

static void

zio_add_child(zio_t *pio, zio_t *zio)

{

	mutex_enter(&pio->io_lock);

	if (zio->io_stage < ZIO_STAGE_READY)

		pio->io_children[zio->io_child_type][ZIO_WAIT_READY]++;

	if (zio->io_stage < ZIO_STAGE_DONE)

		pio->io_children[zio->io_child_type][ZIO_WAIT_DONE]++;

	zio->io_sibling_prev = NULL;

	zio->io_sibling_next = pio->io_child;

	if (pio->io_child != NULL)

		pio->io_child->io_sibling_prev = zio;

	pio->io_child = zio;

	zio->io_parent = pio;

	mutex_exit(&pio->io_lock);

}

static void

zio_remove_child(zio_t *pio, zio_t *zio)

{

	zio_t *next, *prev;

	ASSERT(zio->io_parent == pio);

	mutex_enter(&pio->io_lock);

	next = zio->io_sibling_next;

	prev = zio->io_sibling_prev;

	if (next != NULL)

		next->io_sibling_prev = prev;

	if (prev != NULL)

		prev->io_sibling_next = next;

	if (pio->io_child == zio)

		pio->io_child = next;

	mutex_exit(&pio->io_lock);

}

static boolean_t

zio_wait_for_children(zio_t *zio, enum zio_child child, enum zio_wait_type wait)

{

	uint64_t *countp = &zio->io_children[child][wait];

	boolean_t waiting = B_FALSE;

	mutex_enter(&zio->io_lock);

	ASSERT(zio->io_stall == NULL);

	if (*countp != 0) {

		zio->io_stage--;

		zio->io_stall = countp;

		waiting = B_TRUE;

	}

	mutex_exit(&zio->io_lock);

	return (waiting);

}

static void

zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)

{

	uint64_t *countp = &pio->io_children[zio->io_child_type][wait];

	int *errorp = &pio->io_child_error[zio->io_child_type];

	mutex_enter(&pio->io_lock);

	if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))

		*errorp = zio_worst_error(*errorp, zio->io_error);

	pio->io_reexecute |= zio->io_reexecute;

	ASSERT3U(*countp, >, 0);

	if (--*countp == 0 && pio->io_stall == countp) {

		pio->io_stall = NULL;

		mutex_exit(&pio->io_lock);

		zio_execute(pio);

	} else {

		mutex_exit(&pio->io_lock);

	}

}

static void

zio_inherit_child_errors(zio_t *zio, enum zio_child c)

{

	if (zio->io_child_error[c] != 0 && zio->io_error == 0)

		zio->io_error = zio->io_child_error[c];

}

/*

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

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

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

 */

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, vdev_t *vd, uint64_t offset,

    const zbookmark_t *zb, uint8_t stage, uint32_t pipeline)

{

	zio_t *zio;

	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);

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

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

	ASSERT(!vd || spa_config_held(spa, SCL_STATE_ALL, RW_READER));

	ASSERT(!bp || !(flags & ZIO_FLAG_CONFIG_WRITER));

	ASSERT(vd || stage == ZIO_STAGE_OPEN);

	zio = kmem_cache_alloc(zio_cache, KM_SLEEP);

	bzero(zio, sizeof (zio_t));

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

	cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL);

	if (vd != NULL)

		zio->io_child_type = ZIO_CHILD_VDEV;

	else if (flags & ZIO_FLAG_GANG_CHILD)

		zio->io_child_type = ZIO_CHILD_GANG;

	else

		zio->io_child_type = ZIO_CHILD_LOGICAL;

	if (bp != NULL) {

		zio->io_bp = bp;

		zio->io_bp_copy = *bp;

		zio->io_bp_orig = *bp;

		if (type != ZIO_TYPE_WRITE)

			zio->io_bp = &zio->io_bp_copy;	/* so caller can free */

		if (zio->io_child_type == ZIO_CHILD_LOGICAL) {

			if (BP_IS_GANG(bp))

				pipeline |= ZIO_GANG_STAGES;

			zio->io_logical = zio;

		}

	}

	zio->io_spa = spa;

	zio->io_txg = txg;

	zio->io_data = data;

	zio->io_size = size;

	zio->io_done = done;

	zio->io_private = private;

	zio->io_type = type;

	zio->io_priority = priority;