/*

 * 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/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" };

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

	zio_link_cache = kmem_cache_create("zio_link_cache",

	    sizeof (zio_link_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_link_cache);

	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 and decompression

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

 */

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;

}

/*

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

 * I/O parent/child relationships and pipeline interlocks

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

 */

/*

 * NOTE - Callers to zio_walk_parents() and zio_walk_children must

 *        continue calling these functions until they return NULL.

 *        Otherwise, the next caller will pick up the list walk in

 *        some indeterminate state.  (Otherwise every caller would

 *        have to pass in a cookie to keep the state represented by

 *        io_walk_link, which gets annoying.)

 */

zio_t *

zio_walk_parents(zio_t *cio)

{

	zio_link_t *zl = cio->io_walk_link;

	list_t *pl = &cio->io_parent_list;

	zl = (zl == NULL) ? list_head(pl) : list_next(pl, zl);

	cio->io_walk_link = zl;

	if (zl == NULL)

		return (NULL);

	ASSERT(zl->zl_child == cio);

	return (zl->zl_parent);

}

zio_t *

zio_walk_children(zio_t *pio)

{

	zio_link_t *zl = pio->io_walk_link;

	list_t *cl = &pio->io_child_list;

	zl = (zl == NULL) ? list_head(cl) : list_next(cl, zl);

	pio->io_walk_link = zl;

	if (zl == NULL)

		return (NULL);

	ASSERT(zl->zl_parent == pio);

	return (zl->zl_child);

}

zio_t *

zio_unique_parent(zio_t *cio)

{

	zio_t *pio = zio_walk_parents(cio);

	VERIFY(zio_walk_parents(cio) == NULL);

	return (pio);

}

void

zio_add_child(zio_t *pio, zio_t *cio)

{

	zio_link_t *zl = kmem_cache_alloc(zio_link_cache, KM_SLEEP);

	/*

	 * Logical I/Os can have logical, gang, or vdev children.

	 * Gang I/Os can have gang or vdev children.

	 * Vdev I/Os can only have vdev children.

	 * The following ASSERT captures all of these constraints.

	 */

	ASSERT(cio->io_child_type <= pio->io_child_type);

	zl->zl_parent = pio;

	zl->zl_child = cio;

	mutex_enter(&cio->io_lock);

	mutex_enter(&pio->io_lock);

	ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0);

	for (int w = 0; w < ZIO_WAIT_TYPES; w++)

		pio->io_children[cio->io_child_type][w] += !cio->io_state[w];

	list_insert_head(&pio->io_child_list, zl);

	list_insert_head(&cio->io_parent_list, zl);

	mutex_exit(&pio->io_lock);

	mutex_exit(&cio->io_lock);

}

static void

zio_remove_child(zio_t *pio, zio_t *cio, zio_link_t *zl)

{

	ASSERT(zl->zl_parent == pio);

	ASSERT(zl->zl_child == cio);

	mutex_enter(&cio->io_lock);

	mutex_enter(&pio->io_lock);

	list_remove(&pio->io_child_list, zl);

	list_remove(&cio->io_parent_list, zl);

	mutex_exit(&pio->io_lock);

	mutex_exit(&cio->io_lock);

	kmem_cache_free(zio_link_cache, zl);

}

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

	list_create(&zio->io_parent_list, sizeof (zio_link_t),

	    offsetof(zio_link_t, zl_parent_node));

	list_create(&zio->io_child_list, sizeof (zio_link_t),

	    offsetof(zio_link_t, zl_child_node));

	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)

			zio->io_logical = zio;

		if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp))

			pipeline |= ZIO_GANG_STAGES;

	}

	zio->io_spa = spa;

	zio->io_txg = txg;