/*

 * 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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2012 by Delphix. All rights reserved.

 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.

 */

/*

 * 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. If backwards compatability

 *     testing is enabled ztest will sometimes run the "older" version

 *     of ztest after a SIGKILL.

 *

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

 *

 * Use the -k option to set the desired frequency of kills.

 *

 * When ztest invokes itself it passes all relevant information through a

 * temporary file which is mmap-ed in the child process. This allows shared

 * memory to survive the exec syscall. The ztest_shared_hdr_t struct is always

 * stored at offset 0 of this file and contains information on the size and

 * number of shared structures in the file. The information stored in this file

 * must remain backwards compatible with older versions of ztest so that

 * ztest can invoke them during backwards compatibility testing (-B).

 */

#include <sys/zfs_context.h>

#include <sys/spa.h>

#include <sys/dmu.h>

#include <sys/txg.h>

#include <sys/dbuf.h>

#include <sys/zap.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/zil.h>

#include <sys/zil_impl.h>

#include <sys/vdev_impl.h>

#include <sys/vdev_file.h>

#include <sys/spa_impl.h>

#include <sys/metaslab_impl.h>

#include <sys/dsl_prop.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_scan.h>

#include <sys/zio_checksum.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>

#include <libnvpair.h>

#define	ZTEST_FD_DATA 3

#define	ZTEST_FD_RAND 4

typedef struct ztest_shared_hdr {

	uint64_t	zh_hdr_size;

	uint64_t	zh_opts_size;

	uint64_t	zh_size;

	uint64_t	zh_stats_size;

	uint64_t	zh_stats_count;

	uint64_t	zh_ds_size;

	uint64_t	zh_ds_count;

} ztest_shared_hdr_t;

static ztest_shared_hdr_t *ztest_shared_hdr;

typedef struct ztest_shared_opts {

	char zo_pool[MAXNAMELEN];

	char zo_dir[MAXNAMELEN];

	char zo_alt_ztest[MAXNAMELEN];

	char zo_alt_libpath[MAXNAMELEN];

	uint64_t zo_vdevs;

	uint64_t zo_vdevtime;

	size_t zo_vdev_size;

	int zo_ashift;

	int zo_mirrors;

	int zo_raidz;

	int zo_raidz_parity;

	int zo_datasets;

	int zo_threads;

	uint64_t zo_passtime;

	uint64_t zo_killrate;

	int zo_verbose;

	int zo_init;

	uint64_t zo_time;

	uint64_t zo_maxloops;

	uint64_t zo_metaslab_gang_bang;

} ztest_shared_opts_t;

static const ztest_shared_opts_t ztest_opts_defaults = {

	.zo_pool = { 'z', 't', 'e', 's', 't', '\0' },

	.zo_dir = { '/', 't', 'm', 'p', '\0' },

	.zo_alt_ztest = { '\0' },

	.zo_alt_libpath = { '\0' },

	.zo_vdevs = 5,

	.zo_ashift = SPA_MINBLOCKSHIFT,

	.zo_mirrors = 2,

	.zo_raidz = 4,

	.zo_raidz_parity = 1,

	.zo_vdev_size = SPA_MINDEVSIZE,

	.zo_datasets = 7,

	.zo_threads = 23,

	.zo_passtime = 60,		/* 60 seconds */

	.zo_killrate = 70,		/* 70% kill rate */

	.zo_verbose = 0,

	.zo_init = 1,

	.zo_time = 300,			/* 5 minutes */

	.zo_maxloops = 50,		/* max loops during spa_freeze() */

	.zo_metaslab_gang_bang = 32 << 10

};

extern uint64_t metaslab_gang_bang;

extern uint64_t metaslab_df_alloc_threshold;

static ztest_shared_opts_t *ztest_shared_opts;

static ztest_shared_opts_t ztest_opts;

typedef struct ztest_shared_ds {

	uint64_t	zd_seq;

} ztest_shared_ds_t;

static ztest_shared_ds_t *ztest_shared_ds;

#define	ZTEST_GET_SHARED_DS(d) (&ztest_shared_ds[d])

#define	BT_MAGIC	0x123456789abcdefULL

#define	MAXFAULTS() \

	(MAX(zs->zs_mirrors, 1) * (ztest_opts.zo_raidz_parity + 1) - 1)

enum ztest_io_type {

	ZTEST_IO_WRITE_TAG,

	ZTEST_IO_WRITE_PATTERN,

	ZTEST_IO_WRITE_ZEROES,

	ZTEST_IO_TRUNCATE,

	ZTEST_IO_SETATTR,

	ZTEST_IO_TYPES

};

typedef struct ztest_block_tag {

	uint64_t	bt_magic;

	uint64_t	bt_objset;

	uint64_t	bt_object;

	uint64_t	bt_offset;

	uint64_t	bt_gen;

	uint64_t	bt_txg;

	uint64_t	bt_crtxg;

} ztest_block_tag_t;

typedef struct bufwad {

	uint64_t	bw_index;

	uint64_t	bw_txg;

	uint64_t	bw_data;

} bufwad_t;

/*

 * XXX -- fix zfs range locks to be generic so we can use them here.

 */

typedef enum {

	RL_READER,

	RL_WRITER,

	RL_APPEND

} rl_type_t;

typedef struct rll {

	void		*rll_writer;

	int		rll_readers;

	mutex_t		rll_lock;

	cond_t		rll_cv;

} rll_t;

typedef struct rl {

	uint64_t	rl_object;

	uint64_t	rl_offset;

	uint64_t	rl_size;

	rll_t		*rl_lock;

} rl_t;

#define	ZTEST_RANGE_LOCKS	64

#define	ZTEST_OBJECT_LOCKS	64

/*

 * Object descriptor.  Used as a template for object lookup/create/remove.

 */

typedef struct ztest_od {

	uint64_t	od_dir;

	uint64_t	od_object;

	dmu_object_type_t od_type;

	dmu_object_type_t od_crtype;

	uint64_t	od_blocksize;

	uint64_t	od_crblocksize;

	uint64_t	od_gen;

	uint64_t	od_crgen;

	char		od_name[MAXNAMELEN];

} ztest_od_t;

/*

 * Per-dataset state.

 */

typedef struct ztest_ds {

	ztest_shared_ds_t *zd_shared;

	objset_t	*zd_os;

	rwlock_t	zd_zilog_lock;

	zilog_t		*zd_zilog;

	ztest_od_t	*zd_od;		/* debugging aid */

	char		zd_name[MAXNAMELEN];

	mutex_t		zd_dirobj_lock;

	rll_t		zd_object_lock[ZTEST_OBJECT_LOCKS];

	rll_t		zd_range_lock[ZTEST_RANGE_LOCKS];

} ztest_ds_t;

/*

 * Per-iteration state.

 */

typedef void ztest_func_t(ztest_ds_t *zd, uint64_t id);

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

} ztest_info_t;

typedef struct ztest_shared_callstate {

	uint64_t	zc_count;	/* per-pass count */

	uint64_t	zc_time;	/* per-pass time */

	uint64_t	zc_next;	/* next time to call this function */

} ztest_shared_callstate_t;

static ztest_shared_callstate_t *ztest_shared_callstate;

#define	ZTEST_GET_SHARED_CALLSTATE(c) (&ztest_shared_callstate[c])

/*

 * 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_dmu_commit_callbacks;

ztest_func_t ztest_zap;

ztest_func_t ztest_zap_parallel;

ztest_func_t ztest_zil_commit;

ztest_func_t ztest_zil_remount;

ztest_func_t ztest_dmu_read_write_zcopy;

ztest_func_t ztest_dmu_objset_create_destroy;

ztest_func_t ztest_dmu_prealloc;

ztest_func_t ztest_fzap;

ztest_func_t ztest_dmu_snapshot_create_destroy;

ztest_func_t ztest_dsl_prop_get_set;

ztest_func_t ztest_spa_prop_get_set;

ztest_func_t ztest_spa_create_destroy;

ztest_func_t ztest_fault_inject;

ztest_func_t ztest_ddt_repair;

ztest_func_t ztest_dmu_snapshot_hold;

ztest_func_t ztest_spa_rename;

ztest_func_t ztest_scrub;

ztest_func_t ztest_dsl_dataset_promote_busy;

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

ztest_func_t ztest_split_pool;

ztest_func_t ztest_reguid;

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

uint64_t zopt_incessant = 1ULL * NANOSEC / 10;	/* every 1/10 second */

uint64_t zopt_often = 1ULL * NANOSEC;		/* every second */

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

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

ztest_info_t ztest_info[] = {

	{ ztest_dmu_read_write,			1,	&zopt_always	},

	{ ztest_dmu_write_parallel,		10,	&zopt_always	},

	{ ztest_dmu_object_alloc_free,		1,	&zopt_always	},

	{ ztest_dmu_commit_callbacks,		1,	&zopt_always	},

	{ ztest_zap,				30,	&zopt_always	},

	{ ztest_zap_parallel,			100,	&zopt_always	},

	{ ztest_split_pool,			1,	&zopt_always	},

	{ ztest_zil_commit,			1,	&zopt_incessant	},

	{ ztest_zil_remount,			1,	&zopt_sometimes	},

	{ ztest_dmu_read_write_zcopy,		1,	&zopt_often	},

	{ ztest_dmu_objset_create_destroy,	1,	&zopt_often	},

	{ ztest_dsl_prop_get_set,		1,	&zopt_often	},

	{ ztest_spa_prop_get_set,		1,	&zopt_sometimes	},

#if 0

	{ ztest_dmu_prealloc,			1,	&zopt_sometimes	},

#endif

	{ ztest_fzap,				1,	&zopt_sometimes	},

	{ ztest_dmu_snapshot_create_destroy,	1,	&zopt_sometimes	},

	{ ztest_spa_create_destroy,		1,	&zopt_sometimes	},

	{ ztest_fault_inject,			1,	&zopt_sometimes	},

	{ ztest_ddt_repair,			1,	&zopt_sometimes	},

	{ ztest_dmu_snapshot_hold,		1,	&zopt_sometimes	},

	{ ztest_reguid,				1,	&zopt_sometimes },

	{ ztest_spa_rename,			1,	&zopt_rarely	},

	{ ztest_scrub,				1,	&zopt_rarely	},

	{ ztest_dsl_dataset_promote_busy,	1,	&zopt_rarely	},

	{ ztest_vdev_attach_detach,		1,	&zopt_rarely },

	{ ztest_vdev_LUN_growth,		1,	&zopt_rarely	},

	{ ztest_vdev_add_remove,		1,

	    &ztest_opts.zo_vdevtime				},

	{ ztest_vdev_aux_add_remove,		1,

	    &ztest_opts.zo_vdevtime				},

};

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

/*

 * The following struct is used to hold a list of uncalled commit callbacks.

 * The callbacks are ordered by txg number.

 */

typedef struct ztest_cb_list {

	mutex_t	zcl_callbacks_lock;

	list_t	zcl_callbacks;

} ztest_cb_list_t;

/*

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

 */

typedef struct ztest_shared {

	boolean_t	zs_do_init;

	hrtime_t	zs_proc_start;

	hrtime_t	zs_proc_stop;

	hrtime_t	zs_thread_start;

	hrtime_t	zs_thread_stop;

	hrtime_t	zs_thread_kill;

	uint64_t	zs_enospc_count;

	uint64_t	zs_vdev_next_leaf;

	uint64_t	zs_vdev_aux;

	uint64_t	zs_alloc;

	uint64_t	zs_space;

	uint64_t	zs_splits;

	uint64_t	zs_mirrors;

	uint64_t	zs_metaslab_sz;

	uint64_t	zs_metaslab_df_alloc_threshold;

	uint64_t	zs_guid;

} ztest_shared_t;

#define	ID_PARALLEL	-1ULL

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

static char ztest_aux_template[] = "%s/%s.%s.%llu";

ztest_shared_t *ztest_shared;

static spa_t *ztest_spa = NULL;

static ztest_ds_t *ztest_ds;

static mutex_t ztest_vdev_lock;

static rwlock_t ztest_name_lock;

static boolean_t ztest_dump_core = B_TRUE;

static boolean_t ztest_exiting;

/* Global commit callback list */

static ztest_cb_list_t zcl;

enum ztest_object {

	ZTEST_META_DNODE = 0,

	ZTEST_DIROBJ,

	ZTEST_OBJECTS

};

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

}