/*

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

 */

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

/*

 * The objective of this program is to provide a DMU/ZAP/SPA stress test

 * that runs entirely in userland, is easy to use, and easy to extend.

 *

 * The overall design of the ztest program is as follows:

 *

 * (1) For each major functional area (e.g. adding vdevs to a pool,

 *     creating and destroying datasets, reading and writing objects, etc)

 *     we have a simple routine to test that functionality.  These

 *     individual routines do not have to do anything "stressful".

 *

 * (2) We turn these simple functionality tests into a stress test by

 *     running them all in parallel, with as many threads as desired,

 *     and spread across as many datasets, objects, and vdevs as desired.

 *

 * (3) While all this is happening, we inject faults into the pool to

 *     verify that self-healing data really works.

 *

 * (4) Every time we open a dataset, we change its checksum and compression

 *     functions.  Thus even individual objects vary from block to block

 *     in which checksum they use and whether they're compressed.

 *

 * (5) To verify that we never lose on-disk consistency after a crash,

 *     we run the entire test in a child of the main process.

 *     At random times, the child self-immolates with a SIGKILL.

 *     This is the software equivalent of pulling the power cord.

 *     The parent then runs the test again, using the existing

 *     storage pool, as many times as desired.

 *

 * (6) To verify that we don't have future leaks or temporal incursions,

 *     many of the functional tests record the transaction group number

 *     as part of their data.  When reading old data, they verify that

 *     the transaction group number is less than the current, open txg.

 *     If you add a new test, please do this if applicable.

 *

 * When run with no arguments, ztest runs for about five minutes and

 * produces no output if successful.  To get a little bit of information,

 * specify -V.  To get more information, specify -VV, and so on.

 *

 * To turn this into an overnight stress test, use -T to specify run time.

 *

 * You can ask more more vdevs [-v], datasets [-d], or threads [-t]

 * to increase the pool capacity, fanout, and overall stress level.

 *

 * The -N(okill) option will suppress kills, so each child runs to completion.

 * This can be useful when you're trying to distinguish temporal incursions

 * from plain old race conditions.

 */

#include <sys/zfs_context.h>

#include <sys/spa.h>

#include <sys/dmu.h>

#include <sys/txg.h>

#include <sys/zap.h>

#include <sys/dmu_traverse.h>

#include <sys/dmu_objset.h>

#include <sys/poll.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/wait.h>

#include <sys/mman.h>

#include <sys/resource.h>

#include <sys/zio.h>

#include <sys/zio_checksum.h>

#include <sys/zio_compress.h>

#include <sys/zil.h>

#include <sys/vdev_impl.h>

#include <sys/spa_impl.h>

#include <sys/dsl_prop.h>

#include <sys/refcount.h>

#include <stdio.h>

#include <stdio_ext.h>

#include <stdlib.h>

#include <unistd.h>

#include <signal.h>

#include <umem.h>

#include <dlfcn.h>

#include <ctype.h>

#include <math.h>

#include <sys/fs/zfs.h>

static char cmdname[] = "ztest";

static char *zopt_pool = cmdname;

static uint64_t zopt_vdevs = 5;

static uint64_t zopt_vdevtime;

static int zopt_ashift = SPA_MINBLOCKSHIFT;

static int zopt_mirrors = 2;

static int zopt_raidz = 4;

static int zopt_raidz_parity = 1;

static size_t zopt_vdev_size = SPA_MINDEVSIZE;

static int zopt_datasets = 7;

static int zopt_threads = 23;

static uint64_t zopt_passtime = 60;	/* 60 seconds */

static uint64_t zopt_killrate = 70;	/* 70% kill rate */

static int zopt_verbose = 0;

static int zopt_init = 1;

static char *zopt_dir = "/tmp";

static uint64_t zopt_time = 300;	/* 5 minutes */

static int zopt_maxfaults;

static uint16_t zopt_write_fail_shift = 5;

typedef struct ztest_block_tag {

	uint64_t	bt_objset;

	uint64_t	bt_object;

	uint64_t	bt_offset;

	uint64_t	bt_txg;

	uint64_t	bt_thread;

	uint64_t	bt_seq;

} ztest_block_tag_t;

typedef struct ztest_args {

	char		za_pool[MAXNAMELEN];

	spa_t		*za_spa;

	objset_t	*za_os;

	zilog_t		*za_zilog;

	thread_t	za_thread;

	uint64_t	za_instance;

	uint64_t	za_random;

	uint64_t	za_diroff;

	uint64_t	za_diroff_shared;

	uint64_t	za_zil_seq;

	hrtime_t	za_start;

	hrtime_t	za_stop;

	hrtime_t	za_kill;

	traverse_handle_t *za_th;

	/*

	 * Thread-local variables can go here to aid debugging.

	 */

	ztest_block_tag_t za_rbt;

	ztest_block_tag_t za_wbt;

	dmu_object_info_t za_doi;

	dmu_buf_t	*za_dbuf;

} ztest_args_t;

typedef void ztest_func_t(ztest_args_t *);

/*

 * Note: these aren't static because we want dladdr() to work.

 */

ztest_func_t ztest_dmu_read_write;

ztest_func_t ztest_dmu_write_parallel;

ztest_func_t ztest_dmu_object_alloc_free;

ztest_func_t ztest_zap;

ztest_func_t ztest_zap_parallel;

ztest_func_t ztest_traverse;

ztest_func_t ztest_dsl_prop_get_set;

ztest_func_t ztest_dmu_objset_create_destroy;

ztest_func_t ztest_dmu_snapshot_create_destroy;

ztest_func_t ztest_spa_create_destroy;

ztest_func_t ztest_fault_inject;

ztest_func_t ztest_vdev_attach_detach;

ztest_func_t ztest_vdev_LUN_growth;

ztest_func_t ztest_vdev_add_remove;

ztest_func_t ztest_scrub;

ztest_func_t ztest_spa_rename;

typedef struct ztest_info {

	ztest_func_t	*zi_func;	/* test function */

	uint64_t	zi_iters;	/* iterations per execution */

	uint64_t	*zi_interval;	/* execute every <interval> seconds */

	uint64_t	zi_calls;	/* per-pass count */

	uint64_t	zi_call_time;	/* per-pass time */

	uint64_t	zi_call_total;	/* cumulative total */

	uint64_t	zi_call_target;	/* target cumulative total */

} ztest_info_t;

uint64_t zopt_always = 0;		/* all the time */

uint64_t zopt_often = 1;		/* every second */

uint64_t zopt_sometimes = 10;		/* every 10 seconds */

uint64_t zopt_rarely = 60;		/* every 60 seconds */

ztest_info_t ztest_info[] = {

	{ ztest_dmu_read_write,			1,	&zopt_always	},

	{ ztest_dmu_write_parallel,		30,	&zopt_always	},

	{ ztest_dmu_object_alloc_free,		1,	&zopt_always	},

	{ ztest_zap,				30,	&zopt_always	},

	{ ztest_zap_parallel,			100,	&zopt_always	},

	{ ztest_traverse,			1,	&zopt_often	},

	{ ztest_dsl_prop_get_set,		1,	&zopt_sometimes	},

	{ ztest_dmu_objset_create_destroy,	1,	&zopt_sometimes	},

	{ ztest_dmu_snapshot_create_destroy,	1,	&zopt_rarely	},

	{ ztest_spa_create_destroy,		1,	&zopt_sometimes	},

	{ ztest_fault_inject,			1,	&zopt_sometimes	},

	{ ztest_spa_rename,			1,	&zopt_rarely	},

	{ ztest_vdev_attach_detach,		1,	&zopt_rarely	},

	{ ztest_vdev_LUN_growth,		1,	&zopt_rarely	},

	{ ztest_vdev_add_remove,		1,	&zopt_vdevtime	},

	{ ztest_scrub,				1,	&zopt_vdevtime	},

};

#define	ZTEST_FUNCS	(sizeof (ztest_info) / sizeof (ztest_info_t))

#define	ZTEST_SYNC_LOCKS	16

/*

 * Stuff we need to share writably between parent and child.

 */

typedef struct ztest_shared {

	mutex_t		zs_vdev_lock;

	rwlock_t	zs_name_lock;

	uint64_t	zs_vdev_primaries;

	uint64_t	zs_enospc_count;

	hrtime_t	zs_start_time;

	hrtime_t	zs_stop_time;

	uint64_t	zs_alloc;

	uint64_t	zs_space;

	ztest_info_t	zs_info[ZTEST_FUNCS];

	mutex_t		zs_sync_lock[ZTEST_SYNC_LOCKS];

	uint64_t	zs_seq[ZTEST_SYNC_LOCKS];

} ztest_shared_t;

static char ztest_dev_template[] = "%s/%s.%llua";

static ztest_shared_t *ztest_shared;

static int ztest_random_fd;

static int ztest_dump_core = 1;

static boolean_t ztest_exiting = B_FALSE;

extern uint64_t metaslab_gang_bang;

extern uint16_t zio_zil_fail_shift;

extern uint16_t zio_io_fail_shift;

#define	ZTEST_DIROBJ		1

#define	ZTEST_MICROZAP_OBJ	2

#define	ZTEST_FATZAP_OBJ	3

#define	ZTEST_DIROBJ_BLOCKSIZE	(1 << 10)

#define	ZTEST_DIRSIZE		256

static void usage(boolean_t) __NORETURN;

/*

 * These libumem hooks provide a reasonable set of defaults for the allocator's

 * debugging facilities.

 */

const char *

_umem_debug_init()

{

	return ("default,verbose"); /* $UMEM_DEBUG setting */

}

const char *

_umem_logging_init(void)

{

	return ("fail,contents"); /* $UMEM_LOGGING setting */

}

#define	FATAL_MSG_SZ	1024

char *fatal_msg;

static void

fatal(int do_perror, char *message, ...)

{

	va_list args;

	int save_errno = errno;

	char buf[FATAL_MSG_SZ];

	(void) fflush(stdout);

	va_start(args, message);

	(void) sprintf(buf, "ztest: ");

	/* LINTED */

	(void) vsprintf(buf + strlen(buf), message, args);

	va_end(args);

	if (do_perror) {

		(void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf),

		    ": %s", strerror(save_errno));

	}

	(void) fprintf(stderr, "%s\n", buf);

	fatal_msg = buf;			/* to ease debugging */

	if (ztest_dump_core)

		abort();

	exit(3);

}

static int

str2shift(const char *buf)

{

	const char *ends = "BKMGTPEZ";

	int i;

	if (buf[0] == '\0')

		return (0);

	for (i = 0; i < strlen(ends); i++) {

		if (toupper(buf[0]) == ends[i])

			break;

	}

	if (i == strlen(ends)) {

		(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n",

		    buf);

		usage(B_FALSE);

	}

	if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0')) {

		return (10*i);

	}

	(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf);

	usage(B_FALSE);

	/* NOTREACHED */

}

static uint64_t

nicenumtoull(const char *buf)

{

	char *end;

	uint64_t val;

	val = strtoull(buf, &end, 0);

	if (end == buf) {

		(void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf);

		usage(B_FALSE);

	} else if (end[0] == '.') {

		double fval = strtod(buf, &end);

		fval *= pow(2, str2shift(end));

		if (fval > UINT64_MAX) {

			(void) fprintf(stderr, "ztest: value too large: %s\n",

			    buf);

			usage(B_FALSE);

		}

		val = (uint64_t)fval;

	} else {

		int shift = str2shift(end);

		if (shift >= 64 || (val << shift) >> shift != val) {

			(void) fprintf(stderr, "ztest: value too large: %s\n",

			    buf);

			usage(B_FALSE);

		}

		val <<= shift;

	}

	return (val);

}

static void

usage(boolean_t requested)

{

	char nice_vdev_size[10];

	char nice_gang_bang[10];

	FILE *fp = requested ? stdout : stderr;

	nicenum(zopt_vdev_size, nice_vdev_size);

	nicenum(metaslab_gang_bang, nice_gang_bang);

	(void) fprintf(fp, "Usage: %s\n"

	    "\t[-v vdevs (default: %llu)]\n"

	    "\t[-s size_of_each_vdev (default: %s)]\n"

	    "\t[-a alignment_shift (default: %d) (use 0 for random)]\n"

	    "\t[-m mirror_copies (default: %d)]\n"

	    "\t[-r raidz_disks (default: %d)]\n"

	    "\t[-R raidz_parity (default: %d)]\n"

	    "\t[-d datasets (default: %d)]\n"

	    "\t[-t threads (default: %d)]\n"

	    "\t[-g gang_block_threshold (default: %s)]\n"

	    "\t[-i initialize pool i times (default: %d)]\n"

	    "\t[-k kill percentage (default: %llu%%)]\n"

	    "\t[-p pool_name (default: %s)]\n"

	    "\t[-f file directory for vdev files (default: %s)]\n"

	    "\t[-V(erbose)] (use multiple times for ever more blather)\n"

	    "\t[-E(xisting)] (use existing pool instead of creating new one)\n"

	    "\t[-T time] total run time (default: %llu sec)\n"

	    "\t[-P passtime] time per pass (default: %llu sec)\n"

	    "\t[-z zil failure rate (default: fail every 2^%llu allocs)]\n"

	    "\t[-w write failure rate (default: fail every 2^%llu allocs)]\n"

	    "\t[-h] (print help)\n"

	    "",

	    cmdname,

	    (u_longlong_t)zopt_vdevs,			/* -v */

	    nice_vdev_size,				/* -s */

	    zopt_ashift,				/* -a */

	    zopt_mirrors,				/* -m */

	    zopt_raidz,					/* -r */

	    zopt_raidz_parity,				/* -R */

	    zopt_datasets,				/* -d */

	    zopt_threads,				/* -t */

	    nice_gang_bang,				/* -g */

	    zopt_init,					/* -i */

	    (u_longlong_t)zopt_killrate,		/* -k */

	    zopt_pool,					/* -p */

	    zopt_dir,					/* -f */

	    (u_longlong_t)zopt_time,			/* -T */

	    (u_longlong_t)zopt_passtime,		/* -P */

	    (u_longlong_t)zio_zil_fail_shift,		/* -z */

	    (u_longlong_t)zopt_write_fail_shift);	/* -w */

	exit(requested ? 0 : 1);

}

static uint64_t

ztest_random(uint64_t range)

{

	uint64_t r;

	if (range == 0)

		return (0);

	if (read(ztest_random_fd, &r, sizeof (r)) != sizeof (r))

		fatal(1, "short read from /dev/urandom");

	return (r % range);

}

static void

ztest_record_enospc(char *s)

{

	dprintf("ENOSPC doing: %s\n", s ? s : "<unknown>");

	ztest_shared->zs_enospc_count++;

}

static void

process_options(int argc, char **argv)

{

	int opt;

	uint64_t value;

	/* By default, test gang blocks for blocks 32K and greater */

	metaslab_gang_bang = 32 << 10;

	/* Default value, fail every 32nd allocation */

	zio_zil_fail_shift = 5;

	while ((opt = getopt(argc, argv,

	    "v:s:a:m:r:R:d:t:g:i:k:p:f:VET:P:z:w:h")) != EOF) {

		value = 0;

		switch (opt) {

		case 'v':

		case 's':

		case 'a':

		case 'm':

		case 'r':

		case 'R':

		case 'd':

		case 't':

		case 'g':

		case 'i':

		case 'k':

		case 'T':

		case 'P':

		case 'z':

		case 'w':

			value = nicenumtoull(optarg);

		}

		switch (opt) {

		case 'v':

			zopt_vdevs = value;

			break;

		case 's':

			zopt_vdev_size = MAX(SPA_MINDEVSIZE, value);

			break;

		case 'a':

			zopt_ashift = value;

			break;

		case 'm':

			zopt_mirrors = value;

			break;

		case 'r':

			zopt_raidz = MAX(1, value);

			break;

		case 'R':

			zopt_raidz_parity = MIN(MAX(value, 1), 2);

			break;

		case 'd':

			zopt_datasets = MAX(1, value);

			break;

		case 't':

			zopt_threads = MAX(1, value);

			break;

		case 'g':

			metaslab_gang_bang = MAX(SPA_MINBLOCKSIZE << 1, value);

			break;

		case 'i':

			zopt_init = value;

			break;

		case 'k':

			zopt_killrate = value;

			break;

		case 'p':

			zopt_pool = strdup(optarg);

			break;

		case 'f':

			zopt_dir = strdup(optarg);

			break;

		case 'V':

			zopt_verbose++;

			break;

		case 'E':