xref: /illumos-gate/usr/src/cmd/ztest/ztest.c (revision d20e665c)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5441d80aaSlling  * Common Development and Distribution License (the "License").
6441d80aaSlling  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
224f5064b7SMark J Musante  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23fa9e4066Sahrens  * Use is subject to license terms.
24fa9e4066Sahrens  */
25fa9e4066Sahrens 
26fa9e4066Sahrens /*
27fa9e4066Sahrens  * The objective of this program is to provide a DMU/ZAP/SPA stress test
28fa9e4066Sahrens  * that runs entirely in userland, is easy to use, and easy to extend.
29fa9e4066Sahrens  *
30fa9e4066Sahrens  * The overall design of the ztest program is as follows:
31fa9e4066Sahrens  *
32fa9e4066Sahrens  * (1) For each major functional area (e.g. adding vdevs to a pool,
33fa9e4066Sahrens  *     creating and destroying datasets, reading and writing objects, etc)
34fa9e4066Sahrens  *     we have a simple routine to test that functionality.  These
35fa9e4066Sahrens  *     individual routines do not have to do anything "stressful".
36fa9e4066Sahrens  *
37fa9e4066Sahrens  * (2) We turn these simple functionality tests into a stress test by
38fa9e4066Sahrens  *     running them all in parallel, with as many threads as desired,
39fa9e4066Sahrens  *     and spread across as many datasets, objects, and vdevs as desired.
40fa9e4066Sahrens  *
41fa9e4066Sahrens  * (3) While all this is happening, we inject faults into the pool to
42fa9e4066Sahrens  *     verify that self-healing data really works.
43fa9e4066Sahrens  *
44fa9e4066Sahrens  * (4) Every time we open a dataset, we change its checksum and compression
45fa9e4066Sahrens  *     functions.  Thus even individual objects vary from block to block
46fa9e4066Sahrens  *     in which checksum they use and whether they're compressed.
47fa9e4066Sahrens  *
48fa9e4066Sahrens  * (5) To verify that we never lose on-disk consistency after a crash,
49fa9e4066Sahrens  *     we run the entire test in a child of the main process.
50fa9e4066Sahrens  *     At random times, the child self-immolates with a SIGKILL.
51fa9e4066Sahrens  *     This is the software equivalent of pulling the power cord.
52fa9e4066Sahrens  *     The parent then runs the test again, using the existing
53fa9e4066Sahrens  *     storage pool, as many times as desired.
54fa9e4066Sahrens  *
55fa9e4066Sahrens  * (6) To verify that we don't have future leaks or temporal incursions,
56fa9e4066Sahrens  *     many of the functional tests record the transaction group number
57fa9e4066Sahrens  *     as part of their data.  When reading old data, they verify that
58fa9e4066Sahrens  *     the transaction group number is less than the current, open txg.
59fa9e4066Sahrens  *     If you add a new test, please do this if applicable.
60fa9e4066Sahrens  *
61fa9e4066Sahrens  * When run with no arguments, ztest runs for about five minutes and
62fa9e4066Sahrens  * produces no output if successful.  To get a little bit of information,
63fa9e4066Sahrens  * specify -V.  To get more information, specify -VV, and so on.
64fa9e4066Sahrens  *
65fa9e4066Sahrens  * To turn this into an overnight stress test, use -T to specify run time.
66fa9e4066Sahrens  *
67fa9e4066Sahrens  * You can ask more more vdevs [-v], datasets [-d], or threads [-t]
68fa9e4066Sahrens  * to increase the pool capacity, fanout, and overall stress level.
69fa9e4066Sahrens  *
70fa9e4066Sahrens  * The -N(okill) option will suppress kills, so each child runs to completion.
71fa9e4066Sahrens  * This can be useful when you're trying to distinguish temporal incursions
72fa9e4066Sahrens  * from plain old race conditions.
73fa9e4066Sahrens  */
74fa9e4066Sahrens 
75fa9e4066Sahrens #include <sys/zfs_context.h>
76fa9e4066Sahrens #include <sys/spa.h>
77fa9e4066Sahrens #include <sys/dmu.h>
78fa9e4066Sahrens #include <sys/txg.h>
792fdbea25SAleksandr Guzovskiy #include <sys/dbuf.h>
80fa9e4066Sahrens #include <sys/zap.h>
81fa9e4066Sahrens #include <sys/dmu_objset.h>
82fa9e4066Sahrens #include <sys/poll.h>
83fa9e4066Sahrens #include <sys/stat.h>
84fa9e4066Sahrens #include <sys/time.h>
85fa9e4066Sahrens #include <sys/wait.h>
86fa9e4066Sahrens #include <sys/mman.h>
87fa9e4066Sahrens #include <sys/resource.h>
88fa9e4066Sahrens #include <sys/zio.h>
89fa9e4066Sahrens #include <sys/zio_checksum.h>
90fa9e4066Sahrens #include <sys/zio_compress.h>
91fa9e4066Sahrens #include <sys/zil.h>
92fa9e4066Sahrens #include <sys/vdev_impl.h>
93e14bb325SJeff Bonwick #include <sys/vdev_file.h>
94fa9e4066Sahrens #include <sys/spa_impl.h>
9588ecc943SGeorge Wilson #include <sys/metaslab_impl.h>
96fa9e4066Sahrens #include <sys/dsl_prop.h>
974f5064b7SMark J Musante #include <sys/dsl_dataset.h>
98fa9e4066Sahrens #include <sys/refcount.h>
99fa9e4066Sahrens #include <stdio.h>
100004388ebScasper #include <stdio_ext.h>
101fa9e4066Sahrens #include <stdlib.h>
102fa9e4066Sahrens #include <unistd.h>
103fa9e4066Sahrens #include <signal.h>
104fa9e4066Sahrens #include <umem.h>
105fa9e4066Sahrens #include <dlfcn.h>
106fa9e4066Sahrens #include <ctype.h>
107fa9e4066Sahrens #include <math.h>
108fa9e4066Sahrens #include <sys/fs/zfs.h>
109fa9e4066Sahrens 
110fa9e4066Sahrens static char cmdname[] = "ztest";
111fa9e4066Sahrens static char *zopt_pool = cmdname;
112fa9e4066Sahrens 
113fa9e4066Sahrens static uint64_t zopt_vdevs = 5;
114fa9e4066Sahrens static uint64_t zopt_vdevtime;
115ecc2d604Sbonwick static int zopt_ashift = SPA_MINBLOCKSHIFT;
116fa9e4066Sahrens static int zopt_mirrors = 2;
117fa9e4066Sahrens static int zopt_raidz = 4;
11899653d4eSeschrock static int zopt_raidz_parity = 1;
119fa9e4066Sahrens static size_t zopt_vdev_size = SPA_MINDEVSIZE;
120ecc2d604Sbonwick static int zopt_datasets = 7;
121fa9e4066Sahrens static int zopt_threads = 23;
122fa9e4066Sahrens static uint64_t zopt_passtime = 60;	/* 60 seconds */
123fa9e4066Sahrens static uint64_t zopt_killrate = 70;	/* 70% kill rate */
124fa9e4066Sahrens static int zopt_verbose = 0;
125fa9e4066Sahrens static int zopt_init = 1;
126fa9e4066Sahrens static char *zopt_dir = "/tmp";
127fa9e4066Sahrens static uint64_t zopt_time = 300;	/* 5 minutes */
128fa9e4066Sahrens static int zopt_maxfaults;
129fa9e4066Sahrens 
130e05725b1Sbonwick typedef struct ztest_block_tag {
131e05725b1Sbonwick 	uint64_t	bt_objset;
132e05725b1Sbonwick 	uint64_t	bt_object;
133e05725b1Sbonwick 	uint64_t	bt_offset;
134e05725b1Sbonwick 	uint64_t	bt_txg;
135e05725b1Sbonwick 	uint64_t	bt_thread;
136e05725b1Sbonwick 	uint64_t	bt_seq;
137e05725b1Sbonwick } ztest_block_tag_t;
138e05725b1Sbonwick 
139fa9e4066Sahrens typedef struct ztest_args {
140e05725b1Sbonwick 	char		za_pool[MAXNAMELEN];
141e05725b1Sbonwick 	spa_t		*za_spa;
142fa9e4066Sahrens 	objset_t	*za_os;
143fa9e4066Sahrens 	zilog_t		*za_zilog;
144fa9e4066Sahrens 	thread_t	za_thread;
145fa9e4066Sahrens 	uint64_t	za_instance;
146fa9e4066Sahrens 	uint64_t	za_random;
147fa9e4066Sahrens 	uint64_t	za_diroff;
148fa9e4066Sahrens 	uint64_t	za_diroff_shared;
149ea8dc4b6Seschrock 	uint64_t	za_zil_seq;
150fa9e4066Sahrens 	hrtime_t	za_start;
151fa9e4066Sahrens 	hrtime_t	za_stop;
152fa9e4066Sahrens 	hrtime_t	za_kill;
153e05725b1Sbonwick 	/*
154e05725b1Sbonwick 	 * Thread-local variables can go here to aid debugging.
155e05725b1Sbonwick 	 */
156e05725b1Sbonwick 	ztest_block_tag_t za_rbt;
157e05725b1Sbonwick 	ztest_block_tag_t za_wbt;
158e05725b1Sbonwick 	dmu_object_info_t za_doi;
159e05725b1Sbonwick 	dmu_buf_t	*za_dbuf;
160fa9e4066Sahrens } ztest_args_t;
161fa9e4066Sahrens 
162fa9e4066Sahrens typedef void ztest_func_t(ztest_args_t *);
163fa9e4066Sahrens 
164fa9e4066Sahrens /*
165fa9e4066Sahrens  * Note: these aren't static because we want dladdr() to work.
166fa9e4066Sahrens  */
167fa9e4066Sahrens ztest_func_t ztest_dmu_read_write;
1682fdbea25SAleksandr Guzovskiy ztest_func_t ztest_dmu_read_write_zcopy;
169fa9e4066Sahrens ztest_func_t ztest_dmu_write_parallel;
170fa9e4066Sahrens ztest_func_t ztest_dmu_object_alloc_free;
171*d20e665cSRicardo M. Correia ztest_func_t ztest_dmu_commit_callbacks;
172fa9e4066Sahrens ztest_func_t ztest_zap;
17312a2833aSSanjeev Bagewadi ztest_func_t ztest_fzap;
174fa9e4066Sahrens ztest_func_t ztest_zap_parallel;
175fa9e4066Sahrens ztest_func_t ztest_traverse;
176fa9e4066Sahrens ztest_func_t ztest_dsl_prop_get_set;
177fa9e4066Sahrens ztest_func_t ztest_dmu_objset_create_destroy;
178fa9e4066Sahrens ztest_func_t ztest_dmu_snapshot_create_destroy;
1794f5064b7SMark J Musante ztest_func_t ztest_dsl_dataset_promote_busy;
180fa9e4066Sahrens ztest_func_t ztest_spa_create_destroy;
181fa9e4066Sahrens ztest_func_t ztest_fault_inject;
182e14bb325SJeff Bonwick ztest_func_t ztest_spa_rename;
183fa9e4066Sahrens ztest_func_t ztest_vdev_attach_detach;
184fa9e4066Sahrens ztest_func_t ztest_vdev_LUN_growth;
185fa9e4066Sahrens ztest_func_t ztest_vdev_add_remove;
186e14bb325SJeff Bonwick ztest_func_t ztest_vdev_aux_add_remove;
187fa9e4066Sahrens ztest_func_t ztest_scrub;
188fa9e4066Sahrens 
189fa9e4066Sahrens typedef struct ztest_info {
190fa9e4066Sahrens 	ztest_func_t	*zi_func;	/* test function */
191e05725b1Sbonwick 	uint64_t	zi_iters;	/* iterations per execution */
192fa9e4066Sahrens 	uint64_t	*zi_interval;	/* execute every <interval> seconds */
193fa9e4066Sahrens 	uint64_t	zi_calls;	/* per-pass count */
194fa9e4066Sahrens 	uint64_t	zi_call_time;	/* per-pass time */
195fa9e4066Sahrens 	uint64_t	zi_call_total;	/* cumulative total */
196fa9e4066Sahrens 	uint64_t	zi_call_target;	/* target cumulative total */
197fa9e4066Sahrens } ztest_info_t;
198fa9e4066Sahrens 
199fa9e4066Sahrens uint64_t zopt_always = 0;		/* all the time */
200fa9e4066Sahrens uint64_t zopt_often = 1;		/* every second */
201fa9e4066Sahrens uint64_t zopt_sometimes = 10;		/* every 10 seconds */
202fa9e4066Sahrens uint64_t zopt_rarely = 60;		/* every 60 seconds */
203fa9e4066Sahrens 
204fa9e4066Sahrens ztest_info_t ztest_info[] = {
205e05725b1Sbonwick 	{ ztest_dmu_read_write,			1,	&zopt_always	},
2062fdbea25SAleksandr Guzovskiy 	{ ztest_dmu_read_write_zcopy,		1,	&zopt_always	},
207e05725b1Sbonwick 	{ ztest_dmu_write_parallel,		30,	&zopt_always	},
208e05725b1Sbonwick 	{ ztest_dmu_object_alloc_free,		1,	&zopt_always	},
209*d20e665cSRicardo M. Correia 	{ ztest_dmu_commit_callbacks,		10,	&zopt_always	},
210e05725b1Sbonwick 	{ ztest_zap,				30,	&zopt_always	},
21112a2833aSSanjeev Bagewadi 	{ ztest_fzap,				30,	&zopt_always	},
212e05725b1Sbonwick 	{ ztest_zap_parallel,			100,	&zopt_always	},
213e05725b1Sbonwick 	{ ztest_dsl_prop_get_set,		1,	&zopt_sometimes	},
214088f3894Sahrens 	{ ztest_dmu_objset_create_destroy,	1,	&zopt_sometimes },
215e14bb325SJeff Bonwick 	{ ztest_dmu_snapshot_create_destroy,	1,	&zopt_sometimes },
216088f3894Sahrens 	{ ztest_spa_create_destroy,		1,	&zopt_sometimes },
217e05725b1Sbonwick 	{ ztest_fault_inject,			1,	&zopt_sometimes	},
218e05725b1Sbonwick 	{ ztest_spa_rename,			1,	&zopt_rarely	},
219e14bb325SJeff Bonwick 	{ ztest_vdev_attach_detach,		1,	&zopt_rarely	},
220e14bb325SJeff Bonwick 	{ ztest_vdev_LUN_growth,		1,	&zopt_rarely	},
221b2d22b66SGeorge Wilson 	{ ztest_dsl_dataset_promote_busy,	1,	&zopt_rarely	},
222e14bb325SJeff Bonwick 	{ ztest_vdev_add_remove,		1,	&zopt_vdevtime	},
223e14bb325SJeff Bonwick 	{ ztest_vdev_aux_add_remove,		1,	&zopt_vdevtime	},
224e05725b1Sbonwick 	{ ztest_scrub,				1,	&zopt_vdevtime	},
225fa9e4066Sahrens };
226fa9e4066Sahrens 
227fa9e4066Sahrens #define	ZTEST_FUNCS	(sizeof (ztest_info) / sizeof (ztest_info_t))
228fa9e4066Sahrens 
229fa9e4066Sahrens #define	ZTEST_SYNC_LOCKS	16
230fa9e4066Sahrens 
231*d20e665cSRicardo M. Correia /*
232*d20e665cSRicardo M. Correia  * The following struct is used to hold a list of uncalled commit callbacks.
233*d20e665cSRicardo M. Correia  *
234*d20e665cSRicardo M. Correia  * The callbacks are ordered by txg number.
235*d20e665cSRicardo M. Correia  */
236*d20e665cSRicardo M. Correia typedef struct ztest_cb_list {
237*d20e665cSRicardo M. Correia 	mutex_t	zcl_callbacks_lock;
238*d20e665cSRicardo M. Correia 	list_t	zcl_callbacks;
239*d20e665cSRicardo M. Correia } ztest_cb_list_t;
240*d20e665cSRicardo M. Correia 
241fa9e4066Sahrens /*
242fa9e4066Sahrens  * Stuff we need to share writably between parent and child.
243fa9e4066Sahrens  */
244fa9e4066Sahrens typedef struct ztest_shared {
245fa9e4066Sahrens 	mutex_t		zs_vdev_lock;
246fa9e4066Sahrens 	rwlock_t	zs_name_lock;
24788ecc943SGeorge Wilson 	uint64_t	zs_vdev_next_leaf;
248e14bb325SJeff Bonwick 	uint64_t	zs_vdev_aux;
249fa9e4066Sahrens 	uint64_t	zs_enospc_count;
250fa9e4066Sahrens 	hrtime_t	zs_start_time;
251fa9e4066Sahrens 	hrtime_t	zs_stop_time;
252fa9e4066Sahrens 	uint64_t	zs_alloc;
253fa9e4066Sahrens 	uint64_t	zs_space;
254fa9e4066Sahrens 	ztest_info_t	zs_info[ZTEST_FUNCS];
255fa9e4066Sahrens 	mutex_t		zs_sync_lock[ZTEST_SYNC_LOCKS];
256fa9e4066Sahrens 	uint64_t	zs_seq[ZTEST_SYNC_LOCKS];
257fa9e4066Sahrens } ztest_shared_t;
258fa9e4066Sahrens 
259fa9e4066Sahrens static char ztest_dev_template[] = "%s/%s.%llua";
260e14bb325SJeff Bonwick static char ztest_aux_template[] = "%s/%s.%s.%llu";
261fa9e4066Sahrens static ztest_shared_t *ztest_shared;
262fa9e4066Sahrens 
263fa9e4066Sahrens static int ztest_random_fd;
264fa9e4066Sahrens static int ztest_dump_core = 1;
265fa9e4066Sahrens 
266d6e555bdSGeorge Wilson static uint64_t metaslab_sz;
267e14bb325SJeff Bonwick static boolean_t ztest_exiting;
2680a4e9518Sgw 
269*d20e665cSRicardo M. Correia /* Global commit callback list */
270*d20e665cSRicardo M. Correia static ztest_cb_list_t zcl;
271*d20e665cSRicardo M. Correia 
272e05725b1Sbonwick extern uint64_t metaslab_gang_bang;
273d6e555bdSGeorge Wilson extern uint64_t metaslab_df_alloc_threshold;
274fa9e4066Sahrens 
275fa9e4066Sahrens #define	ZTEST_DIROBJ		1
276fa9e4066Sahrens #define	ZTEST_MICROZAP_OBJ	2
277fa9e4066Sahrens #define	ZTEST_FATZAP_OBJ	3
278fa9e4066Sahrens 
279fa9e4066Sahrens #define	ZTEST_DIROBJ_BLOCKSIZE	(1 << 10)
280fa9e4066Sahrens #define	ZTEST_DIRSIZE		256
281fa9e4066Sahrens 
2821ce825d8Sraf static void usage(boolean_t) __NORETURN;
283f1b4288bSvb 
284fa9e4066Sahrens /*
285fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
286fa9e4066Sahrens  * debugging facilities.
287fa9e4066Sahrens  */
288fa9e4066Sahrens const char *
289fa9e4066Sahrens _umem_debug_init()
290fa9e4066Sahrens {
291fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
292fa9e4066Sahrens }
293fa9e4066Sahrens 
294fa9e4066Sahrens const char *
295fa9e4066Sahrens _umem_logging_init(void)
296fa9e4066Sahrens {
297fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
298fa9e4066Sahrens }
299fa9e4066Sahrens 
300fa9e4066Sahrens #define	FATAL_MSG_SZ	1024
301fa9e4066Sahrens 
302fa9e4066Sahrens char *fatal_msg;
303fa9e4066Sahrens 
304fa9e4066Sahrens static void
305fa9e4066Sahrens fatal(int do_perror, char *message, ...)
306fa9e4066Sahrens {
307fa9e4066Sahrens 	va_list args;
308fa9e4066Sahrens 	int save_errno = errno;
309fa9e4066Sahrens 	char buf[FATAL_MSG_SZ];
310fa9e4066Sahrens 
311fa9e4066Sahrens 	(void) fflush(stdout);
312fa9e4066Sahrens 
313fa9e4066Sahrens 	va_start(args, message);
314fa9e4066Sahrens 	(void) sprintf(buf, "ztest: ");
315fa9e4066Sahrens 	/* LINTED */
316fa9e4066Sahrens 	(void) vsprintf(buf + strlen(buf), message, args);
317fa9e4066Sahrens 	va_end(args);
318fa9e4066Sahrens 	if (do_perror) {
319fa9e4066Sahrens 		(void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf),
320fa9e4066Sahrens 		    ": %s", strerror(save_errno));
321fa9e4066Sahrens 	}
322fa9e4066Sahrens 	(void) fprintf(stderr, "%s\n", buf);
323fa9e4066Sahrens 	fatal_msg = buf;			/* to ease debugging */
324fa9e4066Sahrens 	if (ztest_dump_core)
325fa9e4066Sahrens 		abort();
326fa9e4066Sahrens 	exit(3);
327fa9e4066Sahrens }
328fa9e4066Sahrens 
329fa9e4066Sahrens static int
330fa9e4066Sahrens str2shift(const char *buf)
331fa9e4066Sahrens {
332fa9e4066Sahrens 	const char *ends = "BKMGTPEZ";
333fa9e4066Sahrens 	int i;
334fa9e4066Sahrens 
335fa9e4066Sahrens 	if (buf[0] == '\0')
336fa9e4066Sahrens 		return (0);
337fa9e4066Sahrens 	for (i = 0; i < strlen(ends); i++) {
338fa9e4066Sahrens 		if (toupper(buf[0]) == ends[i])
339fa9e4066Sahrens 			break;
340fa9e4066Sahrens 	}
341f1b4288bSvb 	if (i == strlen(ends)) {
342f1b4288bSvb 		(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n",
343f1b4288bSvb 		    buf);
344f1b4288bSvb 		usage(B_FALSE);
345f1b4288bSvb 	}
346fa9e4066Sahrens 	if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0')) {
347fa9e4066Sahrens 		return (10*i);
348fa9e4066Sahrens 	}
349f1b4288bSvb 	(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf);
350f1b4288bSvb 	usage(B_FALSE);
351f1b4288bSvb 	/* NOTREACHED */
352fa9e4066Sahrens }
353fa9e4066Sahrens 
354fa9e4066Sahrens static uint64_t
355fa9e4066Sahrens nicenumtoull(const char *buf)
356fa9e4066Sahrens {
357fa9e4066Sahrens 	char *end;
358fa9e4066Sahrens 	uint64_t val;
359fa9e4066Sahrens 
360fa9e4066Sahrens 	val = strtoull(buf, &end, 0);
361fa9e4066Sahrens 	if (end == buf) {
362f1b4288bSvb 		(void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf);
363f1b4288bSvb 		usage(B_FALSE);
364fa9e4066Sahrens 	} else if (end[0] == '.') {
365fa9e4066Sahrens 		double fval = strtod(buf, &end);
366fa9e4066Sahrens 		fval *= pow(2, str2shift(end));
367f1b4288bSvb 		if (fval > UINT64_MAX) {
368f1b4288bSvb 			(void) fprintf(stderr, "ztest: value too large: %s\n",
369f1b4288bSvb 			    buf);
370f1b4288bSvb 			usage(B_FALSE);
371f1b4288bSvb 		}
372fa9e4066Sahrens 		val = (uint64_t)fval;
373fa9e4066Sahrens 	} else {
374fa9e4066Sahrens 		int shift = str2shift(end);
375f1b4288bSvb 		if (shift >= 64 || (val << shift) >> shift != val) {
376f1b4288bSvb 			(void) fprintf(stderr, "ztest: value too large: %s\n",
377f1b4288bSvb 			    buf);
378f1b4288bSvb 			usage(B_FALSE);
379f1b4288bSvb 		}
380fa9e4066Sahrens 		val <<= shift;
381fa9e4066Sahrens 	}
382fa9e4066Sahrens 	return (val);
383fa9e4066Sahrens }
384fa9e4066Sahrens 
385fa9e4066Sahrens static void
386f1b4288bSvb usage(boolean_t requested)
387fa9e4066Sahrens {
388fa9e4066Sahrens 	char nice_vdev_size[10];
389fa9e4066Sahrens 	char nice_gang_bang[10];
390f1b4288bSvb 	FILE *fp = requested ? stdout : stderr;
391fa9e4066Sahrens 
392fa9e4066Sahrens 	nicenum(zopt_vdev_size, nice_vdev_size);
393e05725b1Sbonwick 	nicenum(metaslab_gang_bang, nice_gang_bang);
394fa9e4066Sahrens 
395f1b4288bSvb 	(void) fprintf(fp, "Usage: %s\n"
396fa9e4066Sahrens 	    "\t[-v vdevs (default: %llu)]\n"
397fa9e4066Sahrens 	    "\t[-s size_of_each_vdev (default: %s)]\n"
398ecc2d604Sbonwick 	    "\t[-a alignment_shift (default: %d) (use 0 for random)]\n"
399fa9e4066Sahrens 	    "\t[-m mirror_copies (default: %d)]\n"
400fa9e4066Sahrens 	    "\t[-r raidz_disks (default: %d)]\n"
40199653d4eSeschrock 	    "\t[-R raidz_parity (default: %d)]\n"
402fa9e4066Sahrens 	    "\t[-d datasets (default: %d)]\n"
403fa9e4066Sahrens 	    "\t[-t threads (default: %d)]\n"
404fa9e4066Sahrens 	    "\t[-g gang_block_threshold (default: %s)]\n"
405fa9e4066Sahrens 	    "\t[-i initialize pool i times (default: %d)]\n"
406fa9e4066Sahrens 	    "\t[-k kill percentage (default: %llu%%)]\n"
407fa9e4066Sahrens 	    "\t[-p pool_name (default: %s)]\n"
408fa9e4066Sahrens 	    "\t[-f file directory for vdev files (default: %s)]\n"
409fa9e4066Sahrens 	    "\t[-V(erbose)] (use multiple times for ever more blather)\n"
410ecc2d604Sbonwick 	    "\t[-E(xisting)] (use existing pool instead of creating new one)\n"
411fa9e4066Sahrens 	    "\t[-T time] total run time (default: %llu sec)\n"
412fa9e4066Sahrens 	    "\t[-P passtime] time per pass (default: %llu sec)\n"
413f1b4288bSvb 	    "\t[-h] (print help)\n"
414fa9e4066Sahrens 	    "",
415fa9e4066Sahrens 	    cmdname,
4160a4e9518Sgw 	    (u_longlong_t)zopt_vdevs,			/* -v */
4170a4e9518Sgw 	    nice_vdev_size,				/* -s */
4180a4e9518Sgw 	    zopt_ashift,				/* -a */
4190a4e9518Sgw 	    zopt_mirrors,				/* -m */
4200a4e9518Sgw 	    zopt_raidz,					/* -r */
4210a4e9518Sgw 	    zopt_raidz_parity,				/* -R */
4220a4e9518Sgw 	    zopt_datasets,				/* -d */
4230a4e9518Sgw 	    zopt_threads,				/* -t */
4240a4e9518Sgw 	    nice_gang_bang,				/* -g */
4250a4e9518Sgw 	    zopt_init,					/* -i */
4260a4e9518Sgw 	    (u_longlong_t)zopt_killrate,		/* -k */
4270a4e9518Sgw 	    zopt_pool,					/* -p */
4280a4e9518Sgw 	    zopt_dir,					/* -f */
4290a4e9518Sgw 	    (u_longlong_t)zopt_time,			/* -T */
430e14bb325SJeff Bonwick 	    (u_longlong_t)zopt_passtime);		/* -P */
431f1b4288bSvb 	exit(requested ? 0 : 1);
432fa9e4066Sahrens }
433fa9e4066Sahrens 
434fa9e4066Sahrens static uint64_t
435fa9e4066Sahrens ztest_random(uint64_t range)
436fa9e4066Sahrens {
437fa9e4066Sahrens 	uint64_t r;
438fa9e4066Sahrens 
439fa9e4066Sahrens 	if (range == 0)
440fa9e4066Sahrens 		return (0);
441fa9e4066Sahrens 
442fa9e4066Sahrens 	if (read(ztest_random_fd, &r, sizeof (r)) != sizeof (r))
443fa9e4066Sahrens 		fatal(1, "short read from /dev/urandom");
444fa9e4066Sahrens 
445fa9e4066Sahrens 	return (r % range);
446fa9e4066Sahrens }
447fa9e4066Sahrens 
4488ad4d6ddSJeff Bonwick /* ARGSUSED */
449fa9e4066Sahrens static void
450fa9e4066Sahrens ztest_record_enospc(char *s)
451fa9e4066Sahrens {
452fa9e4066Sahrens 	ztest_shared->zs_enospc_count++;
453fa9e4066Sahrens }
454fa9e4066Sahrens 
455fa9e4066Sahrens static void
456fa9e4066Sahrens process_options(int argc, char **argv)
457fa9e4066Sahrens {
458fa9e4066Sahrens 	int opt;
459fa9e4066Sahrens 	uint64_t value;
460fa9e4066Sahrens 
461fa9e4066Sahrens 	/* By default, test gang blocks for blocks 32K and greater */
462e05725b1Sbonwick 	metaslab_gang_bang = 32 << 10;
463fa9e4066Sahrens 
464fa9e4066Sahrens 	while ((opt = getopt(argc, argv,
465e14bb325SJeff Bonwick 	    "v:s:a:m:r:R:d:t:g:i:k:p:f:VET:P:h")) != EOF) {
466fa9e4066Sahrens 		value = 0;
467fa9e4066Sahrens 		switch (opt) {
4683d7072f8Seschrock 		case 'v':
4693d7072f8Seschrock 		case 's':
4703d7072f8Seschrock 		case 'a':
4713d7072f8Seschrock 		case 'm':
4723d7072f8Seschrock 		case 'r':
4733d7072f8Seschrock 		case 'R':
4743d7072f8Seschrock 		case 'd':
4753d7072f8Seschrock 		case 't':
4763d7072f8Seschrock 		case 'g':
4773d7072f8Seschrock 		case 'i':
4783d7072f8Seschrock 		case 'k':
4793d7072f8Seschrock 		case 'T':
4803d7072f8Seschrock 		case 'P':
481fa9e4066Sahrens 			value = nicenumtoull(optarg);
482fa9e4066Sahrens 		}
483fa9e4066Sahrens 		switch (opt) {
4843d7072f8Seschrock 		case 'v':
485fa9e4066Sahrens 			zopt_vdevs = value;
486fa9e4066Sahrens 			break;
4873d7072f8Seschrock 		case 's':
488fa9e4066Sahrens 			zopt_vdev_size = MAX(SPA_MINDEVSIZE, value);
489fa9e4066Sahrens 			break;
4903d7072f8Seschrock 		case 'a':
491ecc2d604Sbonwick 			zopt_ashift = value;
492ecc2d604Sbonwick 			break;
4933d7072f8Seschrock 		case 'm':
494fa9e4066Sahrens 			zopt_mirrors = value;
495fa9e4066Sahrens 			break;
4963d7072f8Seschrock 		case 'r':
497fa9e4066Sahrens 			zopt_raidz = MAX(1, value);
498fa9e4066Sahrens 			break;
4993d7072f8Seschrock 		case 'R':
500f94275ceSAdam Leventhal 			zopt_raidz_parity = MIN(MAX(value, 1), 3);
50199653d4eSeschrock 			break;
5023d7072f8Seschrock 		case 'd':
503ecc2d604Sbonwick 			zopt_datasets = MAX(1, value);
504fa9e4066Sahrens 			break;
5053d7072f8Seschrock 		case 't':
506fa9e4066Sahrens 			zopt_threads = MAX(1, value);
507fa9e4066Sahrens 			break;
5083d7072f8Seschrock 		case 'g':
509e05725b1Sbonwick 			metaslab_gang_bang = MAX(SPA_MINBLOCKSIZE << 1, value);
510fa9e4066Sahrens 			break;
5113d7072f8Seschrock 		case 'i':
512fa9e4066Sahrens 			zopt_init = value;
513fa9e4066Sahrens 			break;
5143d7072f8Seschrock 		case 'k':
515fa9e4066Sahrens 			zopt_killrate = value;
516fa9e4066Sahrens 			break;
5173d7072f8Seschrock 		case 'p':
518fa9e4066Sahrens 			zopt_pool = strdup(optarg);
519fa9e4066Sahrens 			break;
5203d7072f8Seschrock 		case 'f':
521fa9e4066Sahrens 			zopt_dir = strdup(optarg);
522fa9e4066Sahrens 			break;
5233d7072f8Seschrock 		case 'V':
524fa9e4066Sahrens 			zopt_verbose++;
525fa9e4066Sahrens 			break;
5263d7072f8Seschrock 		case 'E':
527fa9e4066Sahrens 			zopt_init = 0;
528fa9e4066Sahrens 			break;
5293d7072f8Seschrock 		case 'T':
530fa9e4066Sahrens 			zopt_time = value;
531fa9e4066Sahrens 			break;
5323d7072f8Seschrock 		case 'P':
533fa9e4066Sahrens 			zopt_passtime = MAX(1, value);
534fa9e4066Sahrens 			break;
5353d7072f8Seschrock 		case 'h':
536f1b4288bSvb 			usage(B_TRUE);
537f1b4288bSvb 			break;
5383d7072f8Seschrock 		case '?':
5393d7072f8Seschrock 		default:
540f1b4288bSvb 			usage(B_FALSE);
541fa9e4066Sahrens 			break;
542fa9e4066Sahrens 		}
543fa9e4066Sahrens 	}
544fa9e4066Sahrens 
54599653d4eSeschrock 	zopt_raidz_parity = MIN(zopt_raidz_parity, zopt_raidz - 1);
54699653d4eSeschrock 
547fa9e4066Sahrens 	zopt_vdevtime = (zopt_vdevs > 0 ? zopt_time / zopt_vdevs : UINT64_MAX);
54899653d4eSeschrock 	zopt_maxfaults = MAX(zopt_mirrors, 1) * (zopt_raidz_parity + 1) - 1;
549fa9e4066Sahrens }
550fa9e4066Sahrens 
551ecc2d604Sbonwick static uint64_t
552ecc2d604Sbonwick ztest_get_ashift(void)
553ecc2d604Sbonwick {
554ecc2d604Sbonwick 	if (zopt_ashift == 0)
555ecc2d604Sbonwick 		return (SPA_MINBLOCKSHIFT + ztest_random(3));
556ecc2d604Sbonwick 	return (zopt_ashift);
557ecc2d604Sbonwick }
558ecc2d604Sbonwick 
559fa9e4066Sahrens static nvlist_t *
560e14bb325SJeff Bonwick make_vdev_file(char *path, char *aux, size_t size, uint64_t ashift)
561fa9e4066Sahrens {
562e14bb325SJeff Bonwick 	char pathbuf[MAXPATHLEN];
563fa9e4066Sahrens 	uint64_t vdev;
564fa9e4066Sahrens 	nvlist_t *file;
565fa9e4066Sahrens 
566e14bb325SJeff Bonwick 	if (ashift == 0)
567e14bb325SJeff Bonwick 		ashift = ztest_get_ashift();
568e14bb325SJeff Bonwick 
569e14bb325SJeff Bonwick 	if (path == NULL) {
570e14bb325SJeff Bonwick 		path = pathbuf;
571fa9e4066Sahrens 
572e14bb325SJeff Bonwick 		if (aux != NULL) {
573e14bb325SJeff Bonwick 			vdev = ztest_shared->zs_vdev_aux;
574e14bb325SJeff Bonwick 			(void) sprintf(path, ztest_aux_template,
575e14bb325SJeff Bonwick 			    zopt_dir, zopt_pool, aux, vdev);
576e14bb325SJeff Bonwick 		} else {
57788ecc943SGeorge Wilson 			vdev = ztest_shared->zs_vdev_next_leaf++;
578e14bb325SJeff Bonwick 			(void) sprintf(path, ztest_dev_template,
579e14bb325SJeff Bonwick 			    zopt_dir, zopt_pool, vdev);
580e14bb325SJeff Bonwick 		}
581e14bb325SJeff Bonwick 	}
582e14bb325SJeff Bonwick 
583e14bb325SJeff Bonwick 	if (size != 0) {
584e14bb325SJeff Bonwick 		int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666);
585fa9e4066Sahrens 		if (fd == -1)
586e14bb325SJeff Bonwick 			fatal(1, "can't open %s", path);
587fa9e4066Sahrens 		if (ftruncate(fd, size) != 0)
588e14bb325SJeff Bonwick 			fatal(1, "can't ftruncate %s", path);
589fa9e4066Sahrens 		(void) close(fd);
590fa9e4066Sahrens 	}
591fa9e4066Sahrens 
592fa9e4066Sahrens 	VERIFY(nvlist_alloc(&file, NV_UNIQUE_NAME, 0) == 0);
593fa9e4066Sahrens 	VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_TYPE, VDEV_TYPE_FILE) == 0);
594e14bb325SJeff Bonwick 	VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_PATH, path) == 0);
595ecc2d604Sbonwick 	VERIFY(nvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift) == 0);
596fa9e4066Sahrens 
597fa9e4066Sahrens 	return (file);
598fa9e4066Sahrens }
599fa9e4066Sahrens 
600fa9e4066Sahrens static nvlist_t *
601e14bb325SJeff Bonwick make_vdev_raidz(char *path, char *aux, size_t size, uint64_t ashift, int r)
602fa9e4066Sahrens {
603fa9e4066Sahrens 	nvlist_t *raidz, **child;
604fa9e4066Sahrens 	int c;
605fa9e4066Sahrens 
606fa9e4066Sahrens 	if (r < 2)
607e14bb325SJeff Bonwick 		return (make_vdev_file(path, aux, size, ashift));
608fa9e4066Sahrens 	child = umem_alloc(r * sizeof (nvlist_t *), UMEM_NOFAIL);
609fa9e4066Sahrens 
610fa9e4066Sahrens 	for (c = 0; c < r; c++)
611e14bb325SJeff Bonwick 		child[c] = make_vdev_file(path, aux, size, ashift);
612fa9e4066Sahrens 
613fa9e4066Sahrens 	VERIFY(nvlist_alloc(&raidz, NV_UNIQUE_NAME, 0) == 0);
614fa9e4066Sahrens 	VERIFY(nvlist_add_string(raidz, ZPOOL_CONFIG_TYPE,
615fa9e4066Sahrens 	    VDEV_TYPE_RAIDZ) == 0);
61699653d4eSeschrock 	VERIFY(nvlist_add_uint64(raidz, ZPOOL_CONFIG_NPARITY,
61799653d4eSeschrock 	    zopt_raidz_parity) == 0);
618fa9e4066Sahrens 	VERIFY(nvlist_add_nvlist_array(raidz, ZPOOL_CONFIG_CHILDREN,
619fa9e4066Sahrens 	    child, r) == 0);
620fa9e4066Sahrens 
621fa9e4066Sahrens 	for (c = 0; c < r; c++)
622fa9e4066Sahrens 		nvlist_free(child[c]);
623fa9e4066Sahrens 
624fa9e4066Sahrens 	umem_free(child, r * sizeof (nvlist_t *));
625fa9e4066Sahrens 
626fa9e4066Sahrens 	return (raidz);
627fa9e4066Sahrens }
628fa9e4066Sahrens 
629fa9e4066Sahrens static nvlist_t *
630e14bb325SJeff Bonwick make_vdev_mirror(char *path, char *aux, size_t size, uint64_t ashift,
63131157203SJeff Bonwick 	int r, int m)
632fa9e4066Sahrens {
633fa9e4066Sahrens 	nvlist_t *mirror, **child;
634fa9e4066Sahrens 	int c;
635fa9e4066Sahrens 
636fa9e4066Sahrens 	if (m < 1)
637e14bb325SJeff Bonwick 		return (make_vdev_raidz(path, aux, size, ashift, r));
638fa9e4066Sahrens 
639fa9e4066Sahrens 	child = umem_alloc(m * sizeof (nvlist_t *), UMEM_NOFAIL);
640fa9e4066Sahrens 
641fa9e4066Sahrens 	for (c = 0; c < m; c++)
642e14bb325SJeff Bonwick 		child[c] = make_vdev_raidz(path, aux, size, ashift, r);
643fa9e4066Sahrens 
644fa9e4066Sahrens 	VERIFY(nvlist_alloc(&mirror, NV_UNIQUE_NAME, 0) == 0);
645fa9e4066Sahrens 	VERIFY(nvlist_add_string(mirror, ZPOOL_CONFIG_TYPE,
646fa9e4066Sahrens 	    VDEV_TYPE_MIRROR) == 0);
647fa9e4066Sahrens 	VERIFY(nvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN,
648fa9e4066Sahrens 	    child, m) == 0);
649fa9e4066Sahrens 
650fa9e4066Sahrens 	for (c = 0; c < m; c++)
651fa9e4066Sahrens 		nvlist_free(child[c]);
652fa9e4066Sahrens 
653fa9e4066Sahrens 	umem_free(child, m * sizeof (nvlist_t *));
654fa9e4066Sahrens 
655fa9e4066Sahrens 	return (mirror);
656fa9e4066Sahrens }
657fa9e4066Sahrens 
658fa9e4066Sahrens static nvlist_t *
659e14bb325SJeff Bonwick make_vdev_root(char *path, char *aux, size_t size, uint64_t ashift,
660e14bb325SJeff Bonwick 	int log, int r, int m, int t)
661fa9e4066Sahrens {
662fa9e4066Sahrens 	nvlist_t *root, **child;
663fa9e4066Sahrens 	int c;
664fa9e4066Sahrens 
665fa9e4066Sahrens 	ASSERT(t > 0);
666fa9e4066Sahrens 
667fa9e4066Sahrens 	child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL);
668fa9e4066Sahrens 
66931157203SJeff Bonwick 	for (c = 0; c < t; c++) {
67031157203SJeff Bonwick 		child[c] = make_vdev_mirror(path, aux, size, ashift, r, m);
67131157203SJeff Bonwick 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
67231157203SJeff Bonwick 		    log) == 0);
67331157203SJeff Bonwick 	}
674fa9e4066Sahrens 
675fa9e4066Sahrens 	VERIFY(nvlist_alloc(&root, NV_UNIQUE_NAME, 0) == 0);
676fa9e4066Sahrens 	VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0);
677e14bb325SJeff Bonwick 	VERIFY(nvlist_add_nvlist_array(root, aux ? aux : ZPOOL_CONFIG_CHILDREN,
678fa9e4066Sahrens 	    child, t) == 0);
679fa9e4066Sahrens 
680fa9e4066Sahrens 	for (c = 0; c < t; c++)
681fa9e4066Sahrens 		nvlist_free(child[c]);
682fa9e4066Sahrens 
683fa9e4066Sahrens 	umem_free(child, t * sizeof (nvlist_t *));
684fa9e4066Sahrens 
685fa9e4066Sahrens 	return (root);
686fa9e4066Sahrens }
687fa9e4066Sahrens 
688fa9e4066Sahrens static void
689fa9e4066Sahrens ztest_set_random_blocksize(objset_t *os, uint64_t object, dmu_tx_t *tx)
690fa9e4066Sahrens {
691fa9e4066Sahrens 	int bs = SPA_MINBLOCKSHIFT +
692fa9e4066Sahrens 	    ztest_random(SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT + 1);
693fa9e4066Sahrens 	int ibs = DN_MIN_INDBLKSHIFT +
694fa9e4066Sahrens 	    ztest_random(DN_MAX_INDBLKSHIFT - DN_MIN_INDBLKSHIFT + 1);
695fa9e4066Sahrens 	int error;
696fa9e4066Sahrens 
697fa9e4066Sahrens 	error = dmu_object_set_blocksize(os, object, 1ULL << bs, ibs, tx);
698fa9e4066Sahrens 	if (error) {
699fa9e4066Sahrens 		char osname[300];
700fa9e4066Sahrens 		dmu_objset_name(os, osname);
701fa9e4066Sahrens 		fatal(0, "dmu_object_set_blocksize('%s', %llu, %d, %d) = %d",
702fa9e4066Sahrens 		    osname, object, 1 << bs, ibs, error);
703fa9e4066Sahrens 	}
704fa9e4066Sahrens }
705fa9e4066Sahrens 
706fa9e4066Sahrens static uint8_t
707fa9e4066Sahrens ztest_random_checksum(void)
708fa9e4066Sahrens {
709fa9e4066Sahrens 	uint8_t checksum;
710fa9e4066Sahrens 
711fa9e4066Sahrens 	do {
712fa9e4066Sahrens 		checksum = ztest_random(ZIO_CHECKSUM_FUNCTIONS);
713fa9e4066Sahrens 	} while (zio_checksum_table[checksum].ci_zbt);
714fa9e4066Sahrens 
715fa9e4066Sahrens 	if (checksum == ZIO_CHECKSUM_OFF)
716fa9e4066Sahrens 		checksum = ZIO_CHECKSUM_ON;
717fa9e4066Sahrens 
718fa9e4066Sahrens 	return (checksum);
719fa9e4066Sahrens }
720fa9e4066Sahrens 
721fa9e4066Sahrens static uint8_t
722fa9e4066Sahrens ztest_random_compress(void)
723fa9e4066Sahrens {
724fa9e4066Sahrens 	return ((uint8_t)ztest_random(ZIO_COMPRESS_FUNCTIONS));
725fa9e4066Sahrens }
726fa9e4066Sahrens 
727fa9e4066Sahrens static int
7281209a471SNeil Perrin ztest_replay_create(objset_t *os, lr_create_t *lr, boolean_t byteswap)
729fa9e4066Sahrens {
730fa9e4066Sahrens 	dmu_tx_t *tx;
731fa9e4066Sahrens 	int error;
732fa9e4066Sahrens 
733fa9e4066Sahrens 	if (byteswap)
734fa9e4066Sahrens 		byteswap_uint64_array(lr, sizeof (*lr));
735fa9e4066Sahrens 
736fa9e4066Sahrens 	tx = dmu_tx_create(os);
737fa9e4066Sahrens 	dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
7381209a471SNeil Perrin 	error = dmu_tx_assign(tx, TXG_WAIT);
739fa9e4066Sahrens 	if (error) {
740fa9e4066Sahrens 		dmu_tx_abort(tx);
741fa9e4066Sahrens 		return (error);
742fa9e4066Sahrens 	}
743fa9e4066Sahrens 
744fa9e4066Sahrens 	error = dmu_object_claim(os, lr->lr_doid, lr->lr_mode, 0,
745fa9e4066Sahrens 	    DMU_OT_NONE, 0, tx);
74699653d4eSeschrock 	ASSERT3U(error, ==, 0);
747fa9e4066Sahrens 	dmu_tx_commit(tx);
748fa9e4066Sahrens 
749fa9e4066Sahrens 	if (zopt_verbose >= 5) {
750fa9e4066Sahrens 		char osname[MAXNAMELEN];
751fa9e4066Sahrens 		dmu_objset_name(os, osname);
752fa9e4066Sahrens 		(void) printf("replay create of %s object %llu"
753fa9e4066Sahrens 		    " in txg %llu = %d\n",
754fa9e4066Sahrens 		    osname, (u_longlong_t)lr->lr_doid,
7551209a471SNeil Perrin 		    (u_longlong_t)dmu_tx_get_txg(tx), error);
756fa9e4066Sahrens 	}
757fa9e4066Sahrens 
758fa9e4066Sahrens 	return (error);
759fa9e4066Sahrens }
760fa9e4066Sahrens 
761fa9e4066Sahrens static int
7621209a471SNeil Perrin ztest_replay_remove(objset_t *os, lr_remove_t *lr, boolean_t byteswap)
763fa9e4066Sahrens {
764fa9e4066Sahrens 	dmu_tx_t *tx;
765fa9e4066Sahrens 	int error;
766fa9e4066Sahrens 
767fa9e4066Sahrens 	if (byteswap)
768fa9e4066Sahrens 		byteswap_uint64_array(lr, sizeof (*lr));
769fa9e4066Sahrens 
770fa9e4066Sahrens 	tx = dmu_tx_create(os);
771fa9e4066Sahrens 	dmu_tx_hold_free(tx, lr->lr_doid, 0, DMU_OBJECT_END);
7721209a471SNeil Perrin 	error = dmu_tx_assign(tx, TXG_WAIT);
773fa9e4066Sahrens 	if (error) {
774fa9e4066Sahrens 		dmu_tx_abort(tx);
775fa9e4066Sahrens 		return (error);
776fa9e4066Sahrens 	}
777fa9e4066Sahrens 
778fa9e4066Sahrens 	error = dmu_object_free(os, lr->lr_doid, tx);
779fa9e4066Sahrens 	dmu_tx_commit(tx);
780fa9e4066Sahrens 
781fa9e4066Sahrens 	return (error);
782fa9e4066Sahrens }
783fa9e4066Sahrens 
784fa9e4066Sahrens zil_replay_func_t *ztest_replay_vector[TX_MAX_TYPE] = {
785fa9e4066Sahrens 	NULL,			/* 0 no such transaction type */
786fa9e4066Sahrens 	ztest_replay_create,	/* TX_CREATE */
787fa9e4066Sahrens 	NULL,			/* TX_MKDIR */
788fa9e4066Sahrens 	NULL,			/* TX_MKXATTR */
789fa9e4066Sahrens 	NULL,			/* TX_SYMLINK */
790fa9e4066Sahrens 	ztest_replay_remove,	/* TX_REMOVE */
791fa9e4066Sahrens 	NULL,			/* TX_RMDIR */
792fa9e4066Sahrens 	NULL,			/* TX_LINK */
793fa9e4066Sahrens 	NULL,			/* TX_RENAME */
794fa9e4066Sahrens 	NULL,			/* TX_WRITE */
795fa9e4066Sahrens 	NULL,			/* TX_TRUNCATE */
796fa9e4066Sahrens 	NULL,			/* TX_SETATTR */
797fa9e4066Sahrens 	NULL,			/* TX_ACL */
798fa9e4066Sahrens };
799fa9e4066Sahrens 
800fa9e4066Sahrens /*
801fa9e4066Sahrens  * Verify that we can't destroy an active pool, create an existing pool,
802fa9e4066Sahrens  * or create a pool with a bad vdev spec.
803fa9e4066Sahrens  */
804fa9e4066Sahrens void
805fa9e4066Sahrens ztest_spa_create_destroy(ztest_args_t *za)
806fa9e4066Sahrens {
807fa9e4066Sahrens 	int error;
808fa9e4066Sahrens 	spa_t *spa;
809fa9e4066Sahrens 	nvlist_t *nvroot;
810fa9e4066Sahrens 
811fa9e4066Sahrens 	/*
812fa9e4066Sahrens 	 * Attempt to create using a bad file.
813fa9e4066Sahrens 	 */
814e14bb325SJeff Bonwick 	nvroot = make_vdev_root("/dev/bogus", NULL, 0, 0, 0, 0, 0, 1);
8150a48a24eStimh 	error = spa_create("ztest_bad_file", nvroot, NULL, NULL, NULL);
816fa9e4066Sahrens 	nvlist_free(nvroot);
817fa9e4066Sahrens 	if (error != ENOENT)
818fa9e4066Sahrens 		fatal(0, "spa_create(bad_file) = %d", error);
819fa9e4066Sahrens 
820fa9e4066Sahrens 	/*
821fa9e4066Sahrens 	 * Attempt to create using a bad mirror.
822fa9e4066Sahrens 	 */
823e14bb325SJeff Bonwick 	nvroot = make_vdev_root("/dev/bogus", NULL, 0, 0, 0, 0, 2, 1);
8240a48a24eStimh 	error = spa_create("ztest_bad_mirror", nvroot, NULL, NULL, NULL);
825fa9e4066Sahrens 	nvlist_free(nvroot);
826fa9e4066Sahrens 	if (error != ENOENT)
827fa9e4066Sahrens 		fatal(0, "spa_create(bad_mirror) = %d", error);
828fa9e4066Sahrens 
829fa9e4066Sahrens 	/*
830fa9e4066Sahrens 	 * Attempt to create an existing pool.  It shouldn't matter
831fa9e4066Sahrens 	 * what's in the nvroot; we should fail with EEXIST.
832fa9e4066Sahrens 	 */
833fa9e4066Sahrens 	(void) rw_rdlock(&ztest_shared->zs_name_lock);
834e14bb325SJeff Bonwick 	nvroot = make_vdev_root("/dev/bogus", NULL, 0, 0, 0, 0, 0, 1);
8350a48a24eStimh 	error = spa_create(za->za_pool, nvroot, NULL, NULL, NULL);
836fa9e4066Sahrens 	nvlist_free(nvroot);
837fa9e4066Sahrens 	if (error != EEXIST)
838fa9e4066Sahrens 		fatal(0, "spa_create(whatever) = %d", error);
839fa9e4066Sahrens 
840fa9e4066Sahrens 	error = spa_open(za->za_pool, &spa, FTAG);
841fa9e4066Sahrens 	if (error)
842fa9e4066Sahrens 		fatal(0, "spa_open() = %d", error);
843fa9e4066Sahrens 
844fa9e4066Sahrens 	error = spa_destroy(za->za_pool);
845fa9e4066Sahrens 	if (error != EBUSY)
846fa9e4066Sahrens 		fatal(0, "spa_destroy() = %d", error);
847fa9e4066Sahrens 
848fa9e4066Sahrens 	spa_close(spa, FTAG);
849fa9e4066Sahrens 	(void) rw_unlock(&ztest_shared->zs_name_lock);
850fa9e4066Sahrens }
851fa9e4066Sahrens 
85231157203SJeff Bonwick static vdev_t *
85331157203SJeff Bonwick vdev_lookup_by_path(vdev_t *vd, const char *path)
85431157203SJeff Bonwick {
85531157203SJeff Bonwick 	vdev_t *mvd;
85631157203SJeff Bonwick 
85731157203SJeff Bonwick 	if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0)
85831157203SJeff Bonwick 		return (vd);
85931157203SJeff Bonwick 
86031157203SJeff Bonwick 	for (int c = 0; c < vd->vdev_children; c++)
86131157203SJeff Bonwick 		if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
86231157203SJeff Bonwick 		    NULL)
86331157203SJeff Bonwick 			return (mvd);
86431157203SJeff Bonwick 
86531157203SJeff Bonwick 	return (NULL);
86631157203SJeff Bonwick }
86731157203SJeff Bonwick 
86888ecc943SGeorge Wilson /*
86988ecc943SGeorge Wilson  * Find the first available hole which can be used as a top-level.
87088ecc943SGeorge Wilson  */
87188ecc943SGeorge Wilson int
87288ecc943SGeorge Wilson find_vdev_hole(spa_t *spa)
87388ecc943SGeorge Wilson {
87488ecc943SGeorge Wilson 	vdev_t *rvd = spa->spa_root_vdev;
87588ecc943SGeorge Wilson 	int c;
87688ecc943SGeorge Wilson 
87788ecc943SGeorge Wilson 	ASSERT(spa_config_held(spa, SCL_VDEV, RW_READER) == SCL_VDEV);
87888ecc943SGeorge Wilson 
87988ecc943SGeorge Wilson 	for (c = 0; c < rvd->vdev_children; c++) {
88088ecc943SGeorge Wilson 		vdev_t *cvd = rvd->vdev_child[c];
88188ecc943SGeorge Wilson 
88288ecc943SGeorge Wilson 		if (cvd->vdev_ishole)
88388ecc943SGeorge Wilson 			break;
88488ecc943SGeorge Wilson 	}
88588ecc943SGeorge Wilson 	return (c);
88688ecc943SGeorge Wilson }
88788ecc943SGeorge Wilson 
888fa9e4066Sahrens /*
889fa9e4066Sahrens  * Verify that vdev_add() works as expected.
890fa9e4066Sahrens  */
891fa9e4066Sahrens void
892fa9e4066Sahrens ztest_vdev_add_remove(ztest_args_t *za)
893fa9e4066Sahrens {
894e05725b1Sbonwick 	spa_t *spa = za->za_spa;
895fa9e4066Sahrens 	uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz;
89688ecc943SGeorge Wilson 	uint64_t guid;
897fa9e4066Sahrens 	nvlist_t *nvroot;
898fa9e4066Sahrens 	int error;
899fa9e4066Sahrens 
900fa9e4066Sahrens 	(void) mutex_lock(&ztest_shared->zs_vdev_lock);
901fa9e4066Sahrens 
902e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
903fa9e4066Sahrens 
90488ecc943SGeorge Wilson 	ztest_shared->zs_vdev_next_leaf = find_vdev_hole(spa) * leaves;
905fa9e4066Sahrens 
9068654d025Sperrin 	/*
90788ecc943SGeorge Wilson 	 * If we have slogs then remove them 1/4 of the time.
9088654d025Sperrin 	 */
90988ecc943SGeorge Wilson 	if (spa_has_slogs(spa) && ztest_random(4) == 0) {
91088ecc943SGeorge Wilson 		/*
91188ecc943SGeorge Wilson 		 * Grab the guid from the head of the log class rotor.
91288ecc943SGeorge Wilson 		 */
91388ecc943SGeorge Wilson 		guid = spa->spa_log_class->mc_rotor->mg_vd->vdev_guid;
9148654d025Sperrin 
91588ecc943SGeorge Wilson 		spa_config_exit(spa, SCL_VDEV, FTAG);
916fa9e4066Sahrens 
91788ecc943SGeorge Wilson 		/*
91888ecc943SGeorge Wilson 		 * We have to grab the zs_name_lock as writer to
91988ecc943SGeorge Wilson 		 * prevent a race between removing a slog (dmu_objset_find)
92088ecc943SGeorge Wilson 		 * and destroying a dataset. Removing the slog will
92188ecc943SGeorge Wilson 		 * grab a reference on the dataset which may cause
92288ecc943SGeorge Wilson 		 * dmu_objset_destroy() to fail with EBUSY thus
92388ecc943SGeorge Wilson 		 * leaving the dataset in an inconsistent state.
92488ecc943SGeorge Wilson 		 */
92588ecc943SGeorge Wilson 		(void) rw_wrlock(&ztest_shared->zs_name_lock);
92688ecc943SGeorge Wilson 		error = spa_vdev_remove(spa, guid, B_FALSE);
92788ecc943SGeorge Wilson 		(void) rw_unlock(&ztest_shared->zs_name_lock);
928fa9e4066Sahrens 
92988ecc943SGeorge Wilson 		if (error && error != EEXIST)
93088ecc943SGeorge Wilson 			fatal(0, "spa_vdev_remove() = %d", error);
93188ecc943SGeorge Wilson 	} else {
93288ecc943SGeorge Wilson 		spa_config_exit(spa, SCL_VDEV, FTAG);
93388ecc943SGeorge Wilson 
93488ecc943SGeorge Wilson 		/*
93588ecc943SGeorge Wilson 		 * Make 1/4 of the devices be log devices.
93688ecc943SGeorge Wilson 		 */
93788ecc943SGeorge Wilson 		nvroot = make_vdev_root(NULL, NULL, zopt_vdev_size, 0,
93888ecc943SGeorge Wilson 		    ztest_random(4) == 0, zopt_raidz, zopt_mirrors, 1);
93988ecc943SGeorge Wilson 
94088ecc943SGeorge Wilson 		error = spa_vdev_add(spa, nvroot);
94188ecc943SGeorge Wilson 		nvlist_free(nvroot);
94288ecc943SGeorge Wilson 
94388ecc943SGeorge Wilson 		if (error == ENOSPC)
94488ecc943SGeorge Wilson 			ztest_record_enospc("spa_vdev_add");
94588ecc943SGeorge Wilson 		else if (error != 0)
94688ecc943SGeorge Wilson 			fatal(0, "spa_vdev_add() = %d", error);
94788ecc943SGeorge Wilson 	}
94888ecc943SGeorge Wilson 
94988ecc943SGeorge Wilson 	(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
950e14bb325SJeff Bonwick }
951fa9e4066Sahrens 
952e14bb325SJeff Bonwick /*
953e14bb325SJeff Bonwick  * Verify that adding/removing aux devices (l2arc, hot spare) works as expected.
954e14bb325SJeff Bonwick  */
955e14bb325SJeff Bonwick void
956e14bb325SJeff Bonwick ztest_vdev_aux_add_remove(ztest_args_t *za)
957e14bb325SJeff Bonwick {
958e14bb325SJeff Bonwick 	spa_t *spa = za->za_spa;
95931157203SJeff Bonwick 	vdev_t *rvd = spa->spa_root_vdev;
960e14bb325SJeff Bonwick 	spa_aux_vdev_t *sav;
961e14bb325SJeff Bonwick 	char *aux;
962e14bb325SJeff Bonwick 	uint64_t guid = 0;
963e14bb325SJeff Bonwick 	int error;
964e14bb325SJeff Bonwick 
96531157203SJeff Bonwick 	if (ztest_random(2) == 0) {
966e14bb325SJeff Bonwick 		sav = &spa->spa_spares;
967e14bb325SJeff Bonwick 		aux = ZPOOL_CONFIG_SPARES;
968e14bb325SJeff Bonwick 	} else {
969e14bb325SJeff Bonwick 		sav = &spa->spa_l2cache;
970e14bb325SJeff Bonwick 		aux = ZPOOL_CONFIG_L2CACHE;
971e14bb325SJeff Bonwick 	}
972e14bb325SJeff Bonwick 
973e14bb325SJeff Bonwick 	(void) mutex_lock(&ztest_shared->zs_vdev_lock);
974e14bb325SJeff Bonwick 
975e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
976e14bb325SJeff Bonwick 
977e14bb325SJeff Bonwick 	if (sav->sav_count != 0 && ztest_random(4) == 0) {
978e14bb325SJeff Bonwick 		/*
979e14bb325SJeff Bonwick 		 * Pick a random device to remove.
980e14bb325SJeff Bonwick 		 */
981e14bb325SJeff Bonwick 		guid = sav->sav_vdevs[ztest_random(sav->sav_count)]->vdev_guid;
982e14bb325SJeff Bonwick 	} else {
983e14bb325SJeff Bonwick 		/*
984e14bb325SJeff Bonwick 		 * Find an unused device we can add.
985e14bb325SJeff Bonwick 		 */
986e14bb325SJeff Bonwick 		ztest_shared->zs_vdev_aux = 0;
987e14bb325SJeff Bonwick 		for (;;) {
988e14bb325SJeff Bonwick 			char path[MAXPATHLEN];
989e14bb325SJeff Bonwick 			int c;
990e14bb325SJeff Bonwick 			(void) sprintf(path, ztest_aux_template, zopt_dir,
991e14bb325SJeff Bonwick 			    zopt_pool, aux, ztest_shared->zs_vdev_aux);
992e14bb325SJeff Bonwick 			for (c = 0; c < sav->sav_count; c++)
993e14bb325SJeff Bonwick 				if (strcmp(sav->sav_vdevs[c]->vdev_path,
994e14bb325SJeff Bonwick 				    path) == 0)
995e14bb325SJeff Bonwick 					break;
99631157203SJeff Bonwick 			if (c == sav->sav_count &&
99731157203SJeff Bonwick 			    vdev_lookup_by_path(rvd, path) == NULL)
998e14bb325SJeff Bonwick 				break;
999e14bb325SJeff Bonwick 			ztest_shared->zs_vdev_aux++;
1000e14bb325SJeff Bonwick 		}
1001e14bb325SJeff Bonwick 	}
1002e14bb325SJeff Bonwick 
1003e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_VDEV, FTAG);
1004e14bb325SJeff Bonwick 
1005e14bb325SJeff Bonwick 	if (guid == 0) {
1006e14bb325SJeff Bonwick 		/*
1007e14bb325SJeff Bonwick 		 * Add a new device.
1008e14bb325SJeff Bonwick 		 */
100931157203SJeff Bonwick 		nvlist_t *nvroot = make_vdev_root(NULL, aux,
101031157203SJeff Bonwick 		    (zopt_vdev_size * 5) / 4, 0, 0, 0, 0, 1);
1011e14bb325SJeff Bonwick 		error = spa_vdev_add(spa, nvroot);
1012e14bb325SJeff Bonwick 		if (error != 0)
1013e14bb325SJeff Bonwick 			fatal(0, "spa_vdev_add(%p) = %d", nvroot, error);
1014e14bb325SJeff Bonwick 		nvlist_free(nvroot);
1015e14bb325SJeff Bonwick 	} else {
1016e14bb325SJeff Bonwick 		/*
1017e14bb325SJeff Bonwick 		 * Remove an existing device.  Sometimes, dirty its
1018e14bb325SJeff Bonwick 		 * vdev state first to make sure we handle removal
1019e14bb325SJeff Bonwick 		 * of devices that have pending state changes.
1020e14bb325SJeff Bonwick 		 */
1021e14bb325SJeff Bonwick 		if (ztest_random(2) == 0)
1022573ca77eSGeorge Wilson 			(void) vdev_online(spa, guid, 0, NULL);
1023e14bb325SJeff Bonwick 
1024e14bb325SJeff Bonwick 		error = spa_vdev_remove(spa, guid, B_FALSE);
1025e14bb325SJeff Bonwick 		if (error != 0 && error != EBUSY)
1026e14bb325SJeff Bonwick 			fatal(0, "spa_vdev_remove(%llu) = %d", guid, error);
1027e14bb325SJeff Bonwick 	}
1028e14bb325SJeff Bonwick 
1029e14bb325SJeff Bonwick 	(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
1030fa9e4066Sahrens }
1031fa9e4066Sahrens 
1032fa9e4066Sahrens /*
1033fa9e4066Sahrens  * Verify that we can attach and detach devices.
1034fa9e4066Sahrens  */
1035fa9e4066Sahrens void
1036fa9e4066Sahrens ztest_vdev_attach_detach(ztest_args_t *za)
1037fa9e4066Sahrens {
1038e05725b1Sbonwick 	spa_t *spa = za->za_spa;
103931157203SJeff Bonwick 	spa_aux_vdev_t *sav = &spa->spa_spares;
1040fa9e4066Sahrens 	vdev_t *rvd = spa->spa_root_vdev;
1041ea8dc4b6Seschrock 	vdev_t *oldvd, *newvd, *pvd;
1042e14bb325SJeff Bonwick 	nvlist_t *root;
1043fa9e4066Sahrens 	uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz;
1044fa9e4066Sahrens 	uint64_t leaf, top;
1045ecc2d604Sbonwick 	uint64_t ashift = ztest_get_ashift();
10468ad4d6ddSJeff Bonwick 	uint64_t oldguid, pguid;
1047ea8dc4b6Seschrock 	size_t oldsize, newsize;
1048ea8dc4b6Seschrock 	char oldpath[MAXPATHLEN], newpath[MAXPATHLEN];
1049fa9e4066Sahrens 	int replacing;
10509af0a4dfSJeff Bonwick 	int oldvd_has_siblings = B_FALSE;
105131157203SJeff Bonwick 	int newvd_is_spare = B_FALSE;
105231157203SJeff Bonwick 	int oldvd_is_log;
1053fa9e4066Sahrens 	int error, expected_error;
1054fa9e4066Sahrens 
1055fa9e4066Sahrens 	(void) mutex_lock(&ztest_shared->zs_vdev_lock);
1056fa9e4066Sahrens 
1057e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
1058fa9e4066Sahrens 
1059fa9e4066Sahrens 	/*
1060fa9e4066Sahrens 	 * Decide whether to do an attach or a replace.
1061fa9e4066Sahrens 	 */
1062fa9e4066Sahrens 	replacing = ztest_random(2);
1063fa9e4066Sahrens 
1064fa9e4066Sahrens 	/*
1065fa9e4066Sahrens 	 * Pick a random top-level vdev.
1066fa9e4066Sahrens 	 */
1067fa9e4066Sahrens 	top = ztest_random(rvd->vdev_children);
1068fa9e4066Sahrens 
1069fa9e4066Sahrens 	/*
1070fa9e4066Sahrens 	 * Pick a random leaf within it.
1071fa9e4066Sahrens 	 */
1072fa9e4066Sahrens 	leaf = ztest_random(leaves);
1073fa9e4066Sahrens 
1074fa9e4066Sahrens 	/*
107531157203SJeff Bonwick 	 * Locate this vdev.
1076fa9e4066Sahrens 	 */
107731157203SJeff Bonwick 	oldvd = rvd->vdev_child[top];
10788ad4d6ddSJeff Bonwick 	if (zopt_mirrors >= 1) {
10798ad4d6ddSJeff Bonwick 		ASSERT(oldvd->vdev_ops == &vdev_mirror_ops);
10808ad4d6ddSJeff Bonwick 		ASSERT(oldvd->vdev_children >= zopt_mirrors);
108131157203SJeff Bonwick 		oldvd = oldvd->vdev_child[leaf / zopt_raidz];
10828ad4d6ddSJeff Bonwick 	}
10838ad4d6ddSJeff Bonwick 	if (zopt_raidz > 1) {
10848ad4d6ddSJeff Bonwick 		ASSERT(oldvd->vdev_ops == &vdev_raidz_ops);
10858ad4d6ddSJeff Bonwick 		ASSERT(oldvd->vdev_children == zopt_raidz);
108631157203SJeff Bonwick 		oldvd = oldvd->vdev_child[leaf % zopt_raidz];
10878ad4d6ddSJeff Bonwick 	}
1088fa9e4066Sahrens 
1089fa9e4066Sahrens 	/*
109031157203SJeff Bonwick 	 * If we're already doing an attach or replace, oldvd may be a
109131157203SJeff Bonwick 	 * mirror vdev -- in which case, pick a random child.
1092fa9e4066Sahrens 	 */
109331157203SJeff Bonwick 	while (oldvd->vdev_children != 0) {
10949af0a4dfSJeff Bonwick 		oldvd_has_siblings = B_TRUE;
10958ad4d6ddSJeff Bonwick 		ASSERT(oldvd->vdev_children >= 2);
10968ad4d6ddSJeff Bonwick 		oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)];
109731157203SJeff Bonwick 	}
1098fa9e4066Sahrens 
109931157203SJeff Bonwick 	oldguid = oldvd->vdev_guid;
1100573ca77eSGeorge Wilson 	oldsize = vdev_get_min_asize(oldvd);
110131157203SJeff Bonwick 	oldvd_is_log = oldvd->vdev_top->vdev_islog;
110231157203SJeff Bonwick 	(void) strcpy(oldpath, oldvd->vdev_path);
1103ea8dc4b6Seschrock 	pvd = oldvd->vdev_parent;
11048ad4d6ddSJeff Bonwick 	pguid = pvd->vdev_guid;
1105fa9e4066Sahrens 
11069af0a4dfSJeff Bonwick 	/*
11079af0a4dfSJeff Bonwick 	 * If oldvd has siblings, then half of the time, detach it.
11089af0a4dfSJeff Bonwick 	 */
11099af0a4dfSJeff Bonwick 	if (oldvd_has_siblings && ztest_random(2) == 0) {
11109af0a4dfSJeff Bonwick 		spa_config_exit(spa, SCL_VDEV, FTAG);
11118ad4d6ddSJeff Bonwick 		error = spa_vdev_detach(spa, oldguid, pguid, B_FALSE);
11128ad4d6ddSJeff Bonwick 		if (error != 0 && error != ENODEV && error != EBUSY &&
11138ad4d6ddSJeff Bonwick 		    error != ENOTSUP)
11148ad4d6ddSJeff Bonwick 			fatal(0, "detach (%s) returned %d", oldpath, error);
11159af0a4dfSJeff Bonwick 		(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
11169af0a4dfSJeff Bonwick 		return;
11179af0a4dfSJeff Bonwick 	}
11189af0a4dfSJeff Bonwick 
1119fa9e4066Sahrens 	/*
112031157203SJeff Bonwick 	 * For the new vdev, choose with equal probability between the two
112131157203SJeff Bonwick 	 * standard paths (ending in either 'a' or 'b') or a random hot spare.
1122fa9e4066Sahrens 	 */
112331157203SJeff Bonwick 	if (sav->sav_count != 0 && ztest_random(3) == 0) {
112431157203SJeff Bonwick 		newvd = sav->sav_vdevs[ztest_random(sav->sav_count)];
112531157203SJeff Bonwick 		newvd_is_spare = B_TRUE;
112631157203SJeff Bonwick 		(void) strcpy(newpath, newvd->vdev_path);
112731157203SJeff Bonwick 	} else {
112831157203SJeff Bonwick 		(void) snprintf(newpath, sizeof (newpath), ztest_dev_template,
112931157203SJeff Bonwick 		    zopt_dir, zopt_pool, top * leaves + leaf);
113031157203SJeff Bonwick 		if (ztest_random(2) == 0)
113131157203SJeff Bonwick 			newpath[strlen(newpath) - 1] = 'b';
113231157203SJeff Bonwick 		newvd = vdev_lookup_by_path(rvd, newpath);
113331157203SJeff Bonwick 	}
113431157203SJeff Bonwick 
113531157203SJeff Bonwick 	if (newvd) {
1136573ca77eSGeorge Wilson 		newsize = vdev_get_min_asize(newvd);
113731157203SJeff Bonwick 	} else {
113831157203SJeff Bonwick 		/*
113931157203SJeff Bonwick 		 * Make newsize a little bigger or smaller than oldsize.
114031157203SJeff Bonwick 		 * If it's smaller, the attach should fail.
114131157203SJeff Bonwick 		 * If it's larger, and we're doing a replace,
114231157203SJeff Bonwick 		 * we should get dynamic LUN growth when we're done.
114331157203SJeff Bonwick 		 */
114431157203SJeff Bonwick 		newsize = 10 * oldsize / (9 + ztest_random(3));
114531157203SJeff Bonwick 	}
1146fa9e4066Sahrens 
1147fa9e4066Sahrens 	/*
1148fa9e4066Sahrens 	 * If pvd is not a mirror or root, the attach should fail with ENOTSUP,
1149fa9e4066Sahrens 	 * unless it's a replace; in that case any non-replacing parent is OK.
1150fa9e4066Sahrens 	 *
1151ea8dc4b6Seschrock 	 * If newvd is already part of the pool, it should fail with EBUSY.
1152fa9e4066Sahrens 	 *
1153ea8dc4b6Seschrock 	 * If newvd is too small, it should fail with EOVERFLOW.
1154fa9e4066Sahrens 	 */
115531157203SJeff Bonwick 	if (pvd->vdev_ops != &vdev_mirror_ops &&
115631157203SJeff Bonwick 	    pvd->vdev_ops != &vdev_root_ops && (!replacing ||
115731157203SJeff Bonwick 	    pvd->vdev_ops == &vdev_replacing_ops ||
115831157203SJeff Bonwick 	    pvd->vdev_ops == &vdev_spare_ops))
115931157203SJeff Bonwick 		expected_error = ENOTSUP;
116031157203SJeff Bonwick 	else if (newvd_is_spare && (!replacing || oldvd_is_log))
1161fa9e4066Sahrens 		expected_error = ENOTSUP;
116231157203SJeff Bonwick 	else if (newvd == oldvd)
116331157203SJeff Bonwick 		expected_error = replacing ? 0 : EBUSY;
116431157203SJeff Bonwick 	else if (vdev_lookup_by_path(rvd, newpath) != NULL)
116531157203SJeff Bonwick 		expected_error = EBUSY;
1166ea8dc4b6Seschrock 	else if (newsize < oldsize)
1167fa9e4066Sahrens 		expected_error = EOVERFLOW;
1168ecc2d604Sbonwick 	else if (ashift > oldvd->vdev_top->vdev_ashift)
1169ecc2d604Sbonwick 		expected_error = EDOM;
1170fa9e4066Sahrens 	else
1171fa9e4066Sahrens 		expected_error = 0;
1172fa9e4066Sahrens 
1173e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_VDEV, FTAG);
1174fa9e4066Sahrens 
1175fa9e4066Sahrens 	/*
1176ea8dc4b6Seschrock 	 * Build the nvlist describing newpath.
1177fa9e4066Sahrens 	 */
1178e14bb325SJeff Bonwick 	root = make_vdev_root(newpath, NULL, newvd == NULL ? newsize : 0,
1179e14bb325SJeff Bonwick 	    ashift, 0, 0, 0, 1);
1180fa9e4066Sahrens 
118131157203SJeff Bonwick 	error = spa_vdev_attach(spa, oldguid, root, replacing);
1182fa9e4066Sahrens 
1183fa9e4066Sahrens 	nvlist_free(root);
1184fa9e4066Sahrens 
1185fa9e4066Sahrens 	/*
1186fa9e4066Sahrens 	 * If our parent was the replacing vdev, but the replace completed,
1187fa9e4066Sahrens 	 * then instead of failing with ENOTSUP we may either succeed,
1188fa9e4066Sahrens 	 * fail with ENODEV, or fail with EOVERFLOW.
1189fa9e4066Sahrens 	 */
1190fa9e4066Sahrens 	if (expected_error == ENOTSUP &&
1191fa9e4066Sahrens 	    (error == 0 || error == ENODEV || error == EOVERFLOW))
1192fa9e4066Sahrens 		expected_error = error;
1193fa9e4066Sahrens 
1194f0aa80d4Sbonwick 	/*
1195f0aa80d4Sbonwick 	 * If someone grew the LUN, the replacement may be too small.
1196f0aa80d4Sbonwick 	 */
1197088f3894Sahrens 	if (error == EOVERFLOW || error == EBUSY)
1198f0aa80d4Sbonwick 		expected_error = error;
1199f0aa80d4Sbonwick 
1200088f3894Sahrens 	/* XXX workaround 6690467 */
1201088f3894Sahrens 	if (error != expected_error && expected_error != EBUSY) {
1202088f3894Sahrens 		fatal(0, "attach (%s %llu, %s %llu, %d) "
1203088f3894Sahrens 		    "returned %d, expected %d",
1204088f3894Sahrens 		    oldpath, (longlong_t)oldsize, newpath,
1205088f3894Sahrens 		    (longlong_t)newsize, replacing, error, expected_error);
1206fa9e4066Sahrens 	}
1207fa9e4066Sahrens 
1208fa9e4066Sahrens 	(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
1209fa9e4066Sahrens }
1210fa9e4066Sahrens 
1211573ca77eSGeorge Wilson /*
1212573ca77eSGeorge Wilson  * Callback function which expands the physical size of the vdev.
1213573ca77eSGeorge Wilson  */
1214573ca77eSGeorge Wilson vdev_t *
1215573ca77eSGeorge Wilson grow_vdev(vdev_t *vd, void *arg)
1216573ca77eSGeorge Wilson {
1217573ca77eSGeorge Wilson 	spa_t *spa = vd->vdev_spa;
1218573ca77eSGeorge Wilson 	size_t *newsize = arg;
1219573ca77eSGeorge Wilson 	size_t fsize;
1220573ca77eSGeorge Wilson 	int fd;
1221573ca77eSGeorge Wilson 
1222573ca77eSGeorge Wilson 	ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE);
1223573ca77eSGeorge Wilson 	ASSERT(vd->vdev_ops->vdev_op_leaf);
1224573ca77eSGeorge Wilson 
1225573ca77eSGeorge Wilson 	if ((fd = open(vd->vdev_path, O_RDWR)) == -1)
1226573ca77eSGeorge Wilson 		return (vd);
1227573ca77eSGeorge Wilson 
1228573ca77eSGeorge Wilson 	fsize = lseek(fd, 0, SEEK_END);
1229573ca77eSGeorge Wilson 	(void) ftruncate(fd, *newsize);
1230573ca77eSGeorge Wilson 
1231573ca77eSGeorge Wilson 	if (zopt_verbose >= 6) {
1232573ca77eSGeorge Wilson 		(void) printf("%s grew from %lu to %lu bytes\n",
1233573ca77eSGeorge Wilson 		    vd->vdev_path, (ulong_t)fsize, (ulong_t)*newsize);
1234573ca77eSGeorge Wilson 	}
1235573ca77eSGeorge Wilson 	(void) close(fd);
1236573ca77eSGeorge Wilson 	return (NULL);
1237573ca77eSGeorge Wilson }
1238573ca77eSGeorge Wilson 
1239573ca77eSGeorge Wilson /*
1240573ca77eSGeorge Wilson  * Callback function which expands a given vdev by calling vdev_online().
1241573ca77eSGeorge Wilson  */
1242573ca77eSGeorge Wilson /* ARGSUSED */
1243573ca77eSGeorge Wilson vdev_t *
1244573ca77eSGeorge Wilson online_vdev(vdev_t *vd, void *arg)
1245573ca77eSGeorge Wilson {
1246573ca77eSGeorge Wilson 	spa_t *spa = vd->vdev_spa;
1247573ca77eSGeorge Wilson 	vdev_t *tvd = vd->vdev_top;
1248573ca77eSGeorge Wilson 	vdev_t *pvd = vd->vdev_parent;
1249573ca77eSGeorge Wilson 	uint64_t guid = vd->vdev_guid;
1250573ca77eSGeorge Wilson 
1251573ca77eSGeorge Wilson 	ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE);
1252573ca77eSGeorge Wilson 	ASSERT(vd->vdev_ops->vdev_op_leaf);
1253573ca77eSGeorge Wilson 
1254573ca77eSGeorge Wilson 	/* Calling vdev_online will initialize the new metaslabs */
1255573ca77eSGeorge Wilson 	spa_config_exit(spa, SCL_STATE, spa);
1256573ca77eSGeorge Wilson 	(void) vdev_online(spa, guid, ZFS_ONLINE_EXPAND, NULL);
1257573ca77eSGeorge Wilson 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
1258573ca77eSGeorge Wilson 
1259573ca77eSGeorge Wilson 	/*
1260573ca77eSGeorge Wilson 	 * Since we dropped the lock we need to ensure that we're
1261573ca77eSGeorge Wilson 	 * still talking to the original vdev. It's possible this
1262573ca77eSGeorge Wilson 	 * vdev may have been detached/replaced while we were
1263573ca77eSGeorge Wilson 	 * trying to online it.
1264573ca77eSGeorge Wilson 	 */
1265573ca77eSGeorge Wilson 	if (vd != vdev_lookup_by_guid(tvd, guid) || vd->vdev_parent != pvd) {
1266573ca77eSGeorge Wilson 		if (zopt_verbose >= 6) {
1267573ca77eSGeorge Wilson 			(void) printf("vdev %p has disappeared, was "
1268573ca77eSGeorge Wilson 			    "guid %llu\n", (void *)vd, (u_longlong_t)guid);
1269573ca77eSGeorge Wilson 		}
1270573ca77eSGeorge Wilson 		return (vd);
1271573ca77eSGeorge Wilson 	}
1272573ca77eSGeorge Wilson 	return (NULL);
1273573ca77eSGeorge Wilson }
1274573ca77eSGeorge Wilson 
1275573ca77eSGeorge Wilson /*
1276573ca77eSGeorge Wilson  * Traverse the vdev tree calling the supplied function.
1277573ca77eSGeorge Wilson  * We continue to walk the tree until we either have walked all
1278573ca77eSGeorge Wilson  * children or we receive a non-NULL return from the callback.
1279573ca77eSGeorge Wilson  * If a NULL callback is passed, then we just return back the first
1280573ca77eSGeorge Wilson  * leaf vdev we encounter.
1281573ca77eSGeorge Wilson  */
1282573ca77eSGeorge Wilson vdev_t *
1283573ca77eSGeorge Wilson vdev_walk_tree(vdev_t *vd, vdev_t *(*func)(vdev_t *, void *), void *arg)
1284573ca77eSGeorge Wilson {
1285573ca77eSGeorge Wilson 	if (vd->vdev_ops->vdev_op_leaf) {
1286573ca77eSGeorge Wilson 		if (func == NULL)
1287573ca77eSGeorge Wilson 			return (vd);
1288573ca77eSGeorge Wilson 		else
1289573ca77eSGeorge Wilson 			return (func(vd, arg));
1290573ca77eSGeorge Wilson 	}
1291573ca77eSGeorge Wilson 
1292573ca77eSGeorge Wilson 	for (uint_t c = 0; c < vd->vdev_children; c++) {
1293573ca77eSGeorge Wilson 		vdev_t *cvd = vd->vdev_child[c];
1294573ca77eSGeorge Wilson 		if ((cvd = vdev_walk_tree(cvd, func, arg)) != NULL)
1295573ca77eSGeorge Wilson 			return (cvd);
1296573ca77eSGeorge Wilson 	}
1297573ca77eSGeorge Wilson 	return (NULL);
1298573ca77eSGeorge Wilson }
1299573ca77eSGeorge Wilson 
1300fa9e4066Sahrens /*
1301fa9e4066Sahrens  * Verify that dynamic LUN growth works as expected.
1302fa9e4066Sahrens  */
1303fa9e4066Sahrens void
1304fa9e4066Sahrens ztest_vdev_LUN_growth(ztest_args_t *za)
1305fa9e4066Sahrens {
1306e05725b1Sbonwick 	spa_t *spa = za->za_spa;
1307573ca77eSGeorge Wilson 	vdev_t *vd, *tvd = NULL;
1308573ca77eSGeorge Wilson 	size_t psize, newsize;
1309573ca77eSGeorge Wilson 	uint64_t spa_newsize, spa_cursize, ms_count;
1310fa9e4066Sahrens 
1311fa9e4066Sahrens 	(void) mutex_lock(&ztest_shared->zs_vdev_lock);
1312573ca77eSGeorge Wilson 	mutex_enter(&spa_namespace_lock);
1313573ca77eSGeorge Wilson 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
1314573ca77eSGeorge Wilson 
1315573ca77eSGeorge Wilson 	while (tvd == NULL || tvd->vdev_islog) {
1316573ca77eSGeorge Wilson 		uint64_t vdev;
1317573ca77eSGeorge Wilson 
1318573ca77eSGeorge Wilson 		vdev = ztest_random(spa->spa_root_vdev->vdev_children);
1319573ca77eSGeorge Wilson 		tvd = spa->spa_root_vdev->vdev_child[vdev];
1320573ca77eSGeorge Wilson 	}
1321fa9e4066Sahrens 
1322fa9e4066Sahrens 	/*
1323573ca77eSGeorge Wilson 	 * Determine the size of the first leaf vdev associated with
1324573ca77eSGeorge Wilson 	 * our top-level device.
1325fa9e4066Sahrens 	 */
1326573ca77eSGeorge Wilson 	vd = vdev_walk_tree(tvd, NULL, NULL);
1327573ca77eSGeorge Wilson 	ASSERT3P(vd, !=, NULL);
1328573ca77eSGeorge Wilson 	ASSERT(vd->vdev_ops->vdev_op_leaf);
1329fa9e4066Sahrens 
1330573ca77eSGeorge Wilson 	psize = vd->vdev_psize;
1331fa9e4066Sahrens 
1332573ca77eSGeorge Wilson 	/*
1333573ca77eSGeorge Wilson 	 * We only try to expand the vdev if it's less than 4x its
1334573ca77eSGeorge Wilson 	 * original size and it has a valid psize.
1335573ca77eSGeorge Wilson 	 */
1336573ca77eSGeorge Wilson 	if (psize == 0 || psize >= 4 * zopt_vdev_size) {
1337573ca77eSGeorge Wilson 		spa_config_exit(spa, SCL_STATE, spa);
1338573ca77eSGeorge Wilson 		mutex_exit(&spa_namespace_lock);
1339573ca77eSGeorge Wilson 		(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
1340573ca77eSGeorge Wilson 		return;
1341573ca77eSGeorge Wilson 	}
1342573ca77eSGeorge Wilson 	ASSERT(psize > 0);
1343573ca77eSGeorge Wilson 	newsize = psize + psize / 8;
1344573ca77eSGeorge Wilson 	ASSERT3U(newsize, >, psize);
1345fa9e4066Sahrens 
1346573ca77eSGeorge Wilson 	if (zopt_verbose >= 6) {
1347573ca77eSGeorge Wilson 		(void) printf("Expanding vdev %s from %lu to %lu\n",
1348573ca77eSGeorge Wilson 		    vd->vdev_path, (ulong_t)psize, (ulong_t)newsize);
1349573ca77eSGeorge Wilson 	}
1350573ca77eSGeorge Wilson 
1351573ca77eSGeorge Wilson 	spa_cursize = spa_get_space(spa);
1352573ca77eSGeorge Wilson 	ms_count = tvd->vdev_ms_count;
1353573ca77eSGeorge Wilson 
1354573ca77eSGeorge Wilson 	/*
1355573ca77eSGeorge Wilson 	 * Growing the vdev is a two step process:
1356573ca77eSGeorge Wilson 	 *	1). expand the physical size (i.e. relabel)
1357573ca77eSGeorge Wilson 	 *	2). online the vdev to create the new metaslabs
1358573ca77eSGeorge Wilson 	 */
1359573ca77eSGeorge Wilson 	if (vdev_walk_tree(tvd, grow_vdev, &newsize) != NULL ||
1360573ca77eSGeorge Wilson 	    vdev_walk_tree(tvd, online_vdev, NULL) != NULL ||
1361573ca77eSGeorge Wilson 	    tvd->vdev_state != VDEV_STATE_HEALTHY) {
1362573ca77eSGeorge Wilson 		if (zopt_verbose >= 5) {
1363573ca77eSGeorge Wilson 			(void) printf("Could not expand LUN because "
1364573ca77eSGeorge Wilson 			    "some vdevs were not healthy\n");
1365fa9e4066Sahrens 		}
1366573ca77eSGeorge Wilson 		(void) spa_config_exit(spa, SCL_STATE, spa);
1367573ca77eSGeorge Wilson 		mutex_exit(&spa_namespace_lock);
1368573ca77eSGeorge Wilson 		(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
1369573ca77eSGeorge Wilson 		return;
1370fa9e4066Sahrens 	}
1371fa9e4066Sahrens 
1372573ca77eSGeorge Wilson 	(void) spa_config_exit(spa, SCL_STATE, spa);
1373573ca77eSGeorge Wilson 	mutex_exit(&spa_namespace_lock);
1374573ca77eSGeorge Wilson 
1375573ca77eSGeorge Wilson 	/*
1376573ca77eSGeorge Wilson 	 * Expanding the LUN will update the config asynchronously,
1377573ca77eSGeorge Wilson 	 * thus we must wait for the async thread to complete any
1378573ca77eSGeorge Wilson 	 * pending tasks before proceeding.
1379573ca77eSGeorge Wilson 	 */
1380573ca77eSGeorge Wilson 	mutex_enter(&spa->spa_async_lock);
1381573ca77eSGeorge Wilson 	while (spa->spa_async_thread != NULL || spa->spa_async_tasks)
1382573ca77eSGeorge Wilson 		cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
1383573ca77eSGeorge Wilson 	mutex_exit(&spa->spa_async_lock);
1384573ca77eSGeorge Wilson 
1385573ca77eSGeorge Wilson 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
1386573ca77eSGeorge Wilson 	spa_newsize = spa_get_space(spa);
1387573ca77eSGeorge Wilson 
1388573ca77eSGeorge Wilson 	/*
1389573ca77eSGeorge Wilson 	 * Make sure we were able to grow the pool.
1390573ca77eSGeorge Wilson 	 */
1391573ca77eSGeorge Wilson 	if (ms_count >= tvd->vdev_ms_count ||
1392573ca77eSGeorge Wilson 	    spa_cursize >= spa_newsize) {
1393573ca77eSGeorge Wilson 		(void) printf("Top-level vdev metaslab count: "
1394573ca77eSGeorge Wilson 		    "before %llu, after %llu\n",
1395573ca77eSGeorge Wilson 		    (u_longlong_t)ms_count,
1396573ca77eSGeorge Wilson 		    (u_longlong_t)tvd->vdev_ms_count);
1397573ca77eSGeorge Wilson 		fatal(0, "LUN expansion failed: before %llu, "
1398573ca77eSGeorge Wilson 		    "after %llu\n", spa_cursize, spa_newsize);
1399573ca77eSGeorge Wilson 	} else if (zopt_verbose >= 5) {
1400573ca77eSGeorge Wilson 		char oldnumbuf[6], newnumbuf[6];
1401573ca77eSGeorge Wilson 
1402573ca77eSGeorge Wilson 		nicenum(spa_cursize, oldnumbuf);
1403573ca77eSGeorge Wilson 		nicenum(spa_newsize, newnumbuf);
1404573ca77eSGeorge Wilson 		(void) printf("%s grew from %s to %s\n",
1405573ca77eSGeorge Wilson 		    spa->spa_name, oldnumbuf, newnumbuf);
1406573ca77eSGeorge Wilson 	}
1407573ca77eSGeorge Wilson 	spa_config_exit(spa, SCL_STATE, spa);
1408fa9e4066Sahrens 	(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
1409fa9e4066Sahrens }
1410fa9e4066Sahrens 
1411fa9e4066Sahrens /* ARGSUSED */
1412fa9e4066Sahrens static void
1413ecd6cf80Smarks ztest_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
1414fa9e4066Sahrens {
1415fa9e4066Sahrens 	/*
1416fa9e4066Sahrens 	 * Create the directory object.
1417fa9e4066Sahrens 	 */
1418fa9e4066Sahrens 	VERIFY(dmu_object_claim(os, ZTEST_DIROBJ,
1419fa9e4066Sahrens 	    DMU_OT_UINT64_OTHER, ZTEST_DIROBJ_BLOCKSIZE,
1420e05725b1Sbonwick 	    DMU_OT_UINT64_OTHER, 5 * sizeof (ztest_block_tag_t), tx) == 0);
1421fa9e4066Sahrens 
1422fa9e4066Sahrens 	VERIFY(zap_create_claim(os, ZTEST_MICROZAP_OBJ,
1423fa9e4066Sahrens 	    DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx) == 0);
1424fa9e4066Sahrens 
1425fa9e4066Sahrens 	VERIFY(zap_create_claim(os, ZTEST_FATZAP_OBJ,
1426fa9e4066Sahrens 	    DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx) == 0);
1427fa9e4066Sahrens }
1428fa9e4066Sahrens 
14291d452cf5Sahrens static int
1430fa9e4066Sahrens ztest_destroy_cb(char *name, void *arg)
1431fa9e4066Sahrens {
1432e05725b1Sbonwick 	ztest_args_t *za = arg;
1433fa9e4066Sahrens 	objset_t *os;
1434e05725b1Sbonwick 	dmu_object_info_t *doi = &za->za_doi;
1435fa9e4066Sahrens 	int error;
1436fa9e4066Sahrens 
1437fa9e4066Sahrens 	/*
1438fa9e4066Sahrens 	 * Verify that the dataset contains a directory object.
1439fa9e4066Sahrens 	 */
1440503ad85cSMatthew Ahrens 	error = dmu_objset_hold(name, FTAG, &os);
1441fa9e4066Sahrens 	ASSERT3U(error, ==, 0);
1442e05725b1Sbonwick 	error = dmu_object_info(os, ZTEST_DIROBJ, doi);
1443e1930233Sbonwick 	if (error != ENOENT) {
1444e1930233Sbonwick 		/* We could have crashed in the middle of destroying it */
1445e1930233Sbonwick 		ASSERT3U(error, ==, 0);
1446e05725b1Sbonwick 		ASSERT3U(doi->doi_type, ==, DMU_OT_UINT64_OTHER);
1447e05725b1Sbonwick 		ASSERT3S(doi->doi_physical_blks, >=, 0);
1448e1930233Sbonwick 	}
1449503ad85cSMatthew Ahrens 	dmu_objset_rele(os, FTAG);
1450fa9e4066Sahrens 
1451fa9e4066Sahrens 	/*
1452fa9e4066Sahrens 	 * Destroy the dataset.
1453fa9e4066Sahrens 	 */
1454842727c2SChris Kirby 	error = dmu_objset_destroy(name, B_FALSE);
1455745cd3c5Smaybee 	if (error) {
1456503ad85cSMatthew Ahrens 		(void) dmu_objset_hold(name, FTAG, &os);
1457503ad85cSMatthew Ahrens 		fatal(0, "dmu_objset_destroy(os=%p) = %d\n", os, error);
1458745cd3c5Smaybee 	}
14591d452cf5Sahrens 	return (0);
1460fa9e4066Sahrens }
1461fa9e4066Sahrens 
1462fa9e4066Sahrens /*
1463fa9e4066Sahrens  * Verify that dmu_objset_{create,destroy,open,close} work as expected.
1464fa9e4066Sahrens  */
1465fa9e4066Sahrens static uint64_t
1466fa9e4066Sahrens ztest_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t object, int mode)
1467fa9e4066Sahrens {
1468fa9e4066Sahrens 	itx_t *itx;
1469fa9e4066Sahrens 	lr_create_t *lr;
1470fa9e4066Sahrens 	size_t namesize;
1471fa9e4066Sahrens 	char name[24];
1472fa9e4066Sahrens 
1473fa9e4066Sahrens 	(void) sprintf(name, "ZOBJ_%llu", (u_longlong_t)object);
1474fa9e4066Sahrens 	namesize = strlen(name) + 1;
1475fa9e4066Sahrens 
1476fa9e4066Sahrens 	itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize +
1477fa9e4066Sahrens 	    ztest_random(ZIL_MAX_BLKSZ));
1478fa9e4066Sahrens 	lr = (lr_create_t *)&itx->itx_lr;
1479fa9e4066Sahrens 	bzero(lr + 1, lr->lr_common.lrc_reclen - sizeof (*lr));
1480fa9e4066Sahrens 	lr->lr_doid = object;
1481fa9e4066Sahrens 	lr->lr_foid = 0;
1482fa9e4066Sahrens 	lr->lr_mode = mode;
1483fa9e4066Sahrens 	lr->lr_uid = 0;
1484fa9e4066Sahrens 	lr->lr_gid = 0;
1485fa9e4066Sahrens 	lr->lr_gen = dmu_tx_get_txg(tx);
1486fa9e4066Sahrens 	lr->lr_crtime[0] = time(NULL);
1487fa9e4066Sahrens 	lr->lr_crtime[1] = 0;
1488fa9e4066Sahrens 	lr->lr_rdev = 0;
1489fa9e4066Sahrens 	bcopy(name, (char *)(lr + 1), namesize);
1490fa9e4066Sahrens 
1491fa9e4066Sahrens 	return (zil_itx_assign(zilog, itx, tx));
1492fa9e4066Sahrens }
1493fa9e4066Sahrens 
1494fa9e4066Sahrens void
1495fa9e4066Sahrens ztest_dmu_objset_create_destroy(ztest_args_t *za)
1496fa9e4066Sahrens {
1497fa9e4066Sahrens 	int error;
1498745cd3c5Smaybee 	objset_t *os, *os2;
1499fa9e4066Sahrens 	char name[100];
1500fa9e4066Sahrens 	zilog_t *zilog;
1501fa9e4066Sahrens 	uint64_t seq;
1502fa9e4066Sahrens 	uint64_t objects;
1503fa9e4066Sahrens 
1504fa9e4066Sahrens 	(void) rw_rdlock(&ztest_shared->zs_name_lock);
1505fa9e4066Sahrens 	(void) snprintf(name, 100, "%s/%s_temp_%llu", za->za_pool, za->za_pool,
1506fa9e4066Sahrens 	    (u_longlong_t)za->za_instance);
1507fa9e4066Sahrens 
1508fa9e4066Sahrens 	/*
1509fa9e4066Sahrens 	 * If this dataset exists from a previous run, process its replay log
1510fa9e4066Sahrens 	 * half of the time.  If we don't replay it, then dmu_objset_destroy()
1511fa9e4066Sahrens 	 * (invoked from ztest_destroy_cb() below) should just throw it away.
1512fa9e4066Sahrens 	 */
1513fa9e4066Sahrens 	if (ztest_random(2) == 0 &&
1514503ad85cSMatthew Ahrens 	    dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os) == 0) {
15151209a471SNeil Perrin 		zil_replay(os, os, ztest_replay_vector);
1516503ad85cSMatthew Ahrens 		dmu_objset_disown(os, FTAG);
1517fa9e4066Sahrens 	}
1518fa9e4066Sahrens 
1519fa9e4066Sahrens 	/*
1520fa9e4066Sahrens 	 * There may be an old instance of the dataset we're about to
1521fa9e4066Sahrens 	 * create lying around from a previous run.  If so, destroy it
1522fa9e4066Sahrens 	 * and all of its snapshots.
1523fa9e4066Sahrens 	 */
1524e05725b1Sbonwick 	(void) dmu_objset_find(name, ztest_destroy_cb, za,
15250b69c2f0Sahrens 	    DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS);
1526fa9e4066Sahrens 
1527fa9e4066Sahrens 	/*
1528fa9e4066Sahrens 	 * Verify that the destroyed dataset is no longer in the namespace.
1529fa9e4066Sahrens 	 */
1530503ad85cSMatthew Ahrens 	error = dmu_objset_hold(name, FTAG, &os);
1531fa9e4066Sahrens 	if (error != ENOENT)
1532fa9e4066Sahrens 		fatal(1, "dmu_objset_open(%s) found destroyed dataset %p",
1533fa9e4066Sahrens 		    name, os);
1534fa9e4066Sahrens 
1535fa9e4066Sahrens 	/*
1536fa9e4066Sahrens 	 * Verify that we can create a new dataset.
1537fa9e4066Sahrens 	 */
1538ae46e4c7SMatthew Ahrens 	error = dmu_objset_create(name, DMU_OST_OTHER, 0,
1539ab04eb8eStimh 	    ztest_create_cb, NULL);
1540fa9e4066Sahrens 	if (error) {
1541fa9e4066Sahrens 		if (error == ENOSPC) {
1542fa9e4066Sahrens 			ztest_record_enospc("dmu_objset_create");
1543fa9e4066Sahrens 			(void) rw_unlock(&ztest_shared->zs_name_lock);
1544fa9e4066Sahrens 			return;
1545fa9e4066Sahrens 		}
1546fa9e4066Sahrens 		fatal(0, "dmu_objset_create(%s) = %d", name, error);
1547fa9e4066Sahrens 	}
1548fa9e4066Sahrens 
1549503ad85cSMatthew Ahrens 	error = dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os);
1550fa9e4066Sahrens 	if (error) {
1551fa9e4066Sahrens 		fatal(0, "dmu_objset_open(%s) = %d", name, error);
1552fa9e4066Sahrens 	}
1553fa9e4066Sahrens 
1554fa9e4066Sahrens 	/*
1555fa9e4066Sahrens 	 * Open the intent log for it.
1556fa9e4066Sahrens 	 */
1557fa9e4066Sahrens 	zilog = zil_open(os, NULL);
1558fa9e4066Sahrens 
1559fa9e4066Sahrens 	/*
1560fa9e4066Sahrens 	 * Put a random number of objects in there.
1561fa9e4066Sahrens 	 */
1562d80c45e0Sbonwick 	objects = ztest_random(20);
1563fa9e4066Sahrens 	seq = 0;
1564fa9e4066Sahrens 	while (objects-- != 0) {
1565fa9e4066Sahrens 		uint64_t object;
1566fa9e4066Sahrens 		dmu_tx_t *tx = dmu_tx_create(os);
1567fa9e4066Sahrens 		dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, sizeof (name));
1568fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
1569fa9e4066Sahrens 		if (error) {
1570fa9e4066Sahrens 			dmu_tx_abort(tx);
1571fa9e4066Sahrens 		} else {
1572fa9e4066Sahrens 			object = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
1573fa9e4066Sahrens 			    DMU_OT_NONE, 0, tx);
1574fa9e4066Sahrens 			ztest_set_random_blocksize(os, object, tx);
1575fa9e4066Sahrens 			seq = ztest_log_create(zilog, tx, object,
1576fa9e4066Sahrens 			    DMU_OT_UINT64_OTHER);
1577fa9e4066Sahrens 			dmu_write(os, object, 0, sizeof (name), name, tx);
1578fa9e4066Sahrens 			dmu_tx_commit(tx);
1579fa9e4066Sahrens 		}
1580fa9e4066Sahrens 		if (ztest_random(5) == 0) {
1581b19a79ecSperrin 			zil_commit(zilog, seq, object);
1582fa9e4066Sahrens 		}
1583d80c45e0Sbonwick 		if (ztest_random(100) == 0) {
1584fa9e4066Sahrens 			error = zil_suspend(zilog);
1585fa9e4066Sahrens 			if (error == 0) {
1586fa9e4066Sahrens 				zil_resume(zilog);
1587fa9e4066Sahrens 			}
1588fa9e4066Sahrens 		}
1589fa9e4066Sahrens 	}
1590fa9e4066Sahrens 
1591fa9e4066Sahrens 	/*
1592fa9e4066Sahrens 	 * Verify that we cannot create an existing dataset.
1593fa9e4066Sahrens 	 */
1594ae46e4c7SMatthew Ahrens 	error = dmu_objset_create(name, DMU_OST_OTHER, 0, NULL, NULL);
1595fa9e4066Sahrens 	if (error != EEXIST)
1596fa9e4066Sahrens 		fatal(0, "created existing dataset, error = %d", error);
1597fa9e4066Sahrens 
1598fa9e4066Sahrens 	/*
1599503ad85cSMatthew Ahrens 	 * Verify that we can hold an objset that is also owned.
1600745cd3c5Smaybee 	 */
1601503ad85cSMatthew Ahrens 	error = dmu_objset_hold(name, FTAG, &os2);
1602503ad85cSMatthew Ahrens 	if (error)
1603503ad85cSMatthew Ahrens 		fatal(0, "dmu_objset_open('%s') = %d", name, error);
1604503ad85cSMatthew Ahrens 	dmu_objset_rele(os2, FTAG);
1605503ad85cSMatthew Ahrens 
1606503ad85cSMatthew Ahrens 	/*
1607503ad85cSMatthew Ahrens 	 * Verify that we can not own an objset that is already owned.
1608503ad85cSMatthew Ahrens 	 */
1609503ad85cSMatthew Ahrens 	error = dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os2);
1610503ad85cSMatthew Ahrens 	if (error != EBUSY)
1611503ad85cSMatthew Ahrens 		fatal(0, "dmu_objset_open('%s') = %d, expected EBUSY",
1612503ad85cSMatthew Ahrens 		    name, error);
1613fa9e4066Sahrens 
1614fa9e4066Sahrens 	zil_close(zilog);
1615503ad85cSMatthew Ahrens 	dmu_objset_disown(os, FTAG);
1616fa9e4066Sahrens 
1617842727c2SChris Kirby 	error = dmu_objset_destroy(name, B_FALSE);
1618fa9e4066Sahrens 	if (error)
1619fa9e4066Sahrens 		fatal(0, "dmu_objset_destroy(%s) = %d", name, error);
1620fa9e4066Sahrens 
1621fa9e4066Sahrens 	(void) rw_unlock(&ztest_shared->zs_name_lock);
1622fa9e4066Sahrens }
1623fa9e4066Sahrens 
1624fa9e4066Sahrens /*
1625fa9e4066Sahrens  * Verify that dmu_snapshot_{create,destroy,open,close} work as expected.
1626fa9e4066Sahrens  */
1627fa9e4066Sahrens void
1628fa9e4066Sahrens ztest_dmu_snapshot_create_destroy(ztest_args_t *za)
1629fa9e4066Sahrens {
1630fa9e4066Sahrens 	int error;
1631fa9e4066Sahrens 	objset_t *os = za->za_os;
1632fa9e4066Sahrens 	char snapname[100];
1633fa9e4066Sahrens 	char osname[MAXNAMELEN];
1634fa9e4066Sahrens 
1635fa9e4066Sahrens 	(void) rw_rdlock(&ztest_shared->zs_name_lock);
1636fa9e4066Sahrens 	dmu_objset_name(os, osname);
1637fa9e4066Sahrens 	(void) snprintf(snapname, 100, "%s@%llu", osname,
1638fa9e4066Sahrens 	    (u_longlong_t)za->za_instance);
1639fa9e4066Sahrens 
1640842727c2SChris Kirby 	error = dmu_objset_destroy(snapname, B_FALSE);
1641fa9e4066Sahrens 	if (error != 0 && error != ENOENT)
1642fa9e4066Sahrens 		fatal(0, "dmu_objset_destroy() = %d", error);
1643ea2f5b9eSMatthew Ahrens 	error = dmu_objset_snapshot(osname, strchr(snapname, '@')+1,
1644ea2f5b9eSMatthew Ahrens 	    NULL, FALSE);
1645fa9e4066Sahrens 	if (error == ENOSPC)
1646fa9e4066Sahrens 		ztest_record_enospc("dmu_take_snapshot");
1647fa9e4066Sahrens 	else if (error != 0 && error != EEXIST)
1648fa9e4066Sahrens 		fatal(0, "dmu_take_snapshot() = %d", error);
1649fa9e4066Sahrens 	(void) rw_unlock(&ztest_shared->zs_name_lock);
16504f5064b7SMark J Musante }
16514f5064b7SMark J Musante 
1652718d718aSGeorge Wilson /*
1653718d718aSGeorge Wilson  * Cleanup non-standard snapshots and clones.
1654718d718aSGeorge Wilson  */
1655718d718aSGeorge Wilson void
1656718d718aSGeorge Wilson ztest_dsl_dataset_cleanup(char *osname, uint64_t curval)
1657718d718aSGeorge Wilson {
1658718d718aSGeorge Wilson 	char snap1name[100];
1659718d718aSGeorge Wilson 	char clone1name[100];
1660718d718aSGeorge Wilson 	char snap2name[100];
1661718d718aSGeorge Wilson 	char clone2name[100];
1662718d718aSGeorge Wilson 	char snap3name[100];
1663718d718aSGeorge Wilson 	int error;
1664718d718aSGeorge Wilson 
1665718d718aSGeorge Wilson 	(void) snprintf(snap1name, 100, "%s@s1_%llu", osname, curval);
1666718d718aSGeorge Wilson 	(void) snprintf(clone1name, 100, "%s/c1_%llu", osname, curval);
1667718d718aSGeorge Wilson 	(void) snprintf(snap2name, 100, "%s@s2_%llu", clone1name, curval);
1668718d718aSGeorge Wilson 	(void) snprintf(clone2name, 100, "%s/c2_%llu", osname, curval);
1669718d718aSGeorge Wilson 	(void) snprintf(snap3name, 100, "%s@s3_%llu", clone1name, curval);
1670718d718aSGeorge Wilson 
1671842727c2SChris Kirby 	error = dmu_objset_destroy(clone2name, B_FALSE);
1672718d718aSGeorge Wilson 	if (error && error != ENOENT)
1673718d718aSGeorge Wilson 		fatal(0, "dmu_objset_destroy(%s) = %d", clone2name, error);
1674842727c2SChris Kirby 	error = dmu_objset_destroy(snap3name, B_FALSE);
1675718d718aSGeorge Wilson 	if (error && error != ENOENT)
1676718d718aSGeorge Wilson 		fatal(0, "dmu_objset_destroy(%s) = %d", snap3name, error);
1677842727c2SChris Kirby 	error = dmu_objset_destroy(snap2name, B_FALSE);
1678718d718aSGeorge Wilson 	if (error && error != ENOENT)
1679718d718aSGeorge Wilson 		fatal(0, "dmu_objset_destroy(%s) = %d", snap2name, error);
1680842727c2SChris Kirby 	error = dmu_objset_destroy(clone1name, B_FALSE);
1681718d718aSGeorge Wilson 	if (error && error != ENOENT)
1682718d718aSGeorge Wilson 		fatal(0, "dmu_objset_destroy(%s) = %d", clone1name, error);
1683842727c2SChris Kirby 	error = dmu_objset_destroy(snap1name, B_FALSE);
1684718d718aSGeorge Wilson 	if (error && error != ENOENT)
1685718d718aSGeorge Wilson 		fatal(0, "dmu_objset_destroy(%s) = %d", snap1name, error);
1686718d718aSGeorge Wilson }
1687718d718aSGeorge Wilson 
16884f5064b7SMark J Musante /*
16894f5064b7SMark J Musante  * Verify dsl_dataset_promote handles EBUSY
16904f5064b7SMark J Musante  */
16914f5064b7SMark J Musante void
16924f5064b7SMark J Musante ztest_dsl_dataset_promote_busy(ztest_args_t *za)
16934f5064b7SMark J Musante {
16944f5064b7SMark J Musante 	int error;
16954f5064b7SMark J Musante 	objset_t *os = za->za_os;
16964f5064b7SMark J Musante 	objset_t *clone;
16974f5064b7SMark J Musante 	dsl_dataset_t *ds;
16984f5064b7SMark J Musante 	char snap1name[100];
16994f5064b7SMark J Musante 	char clone1name[100];
17004f5064b7SMark J Musante 	char snap2name[100];
17014f5064b7SMark J Musante 	char clone2name[100];
17024f5064b7SMark J Musante 	char snap3name[100];
17034f5064b7SMark J Musante 	char osname[MAXNAMELEN];
1704718d718aSGeorge Wilson 	uint64_t curval = za->za_instance;
17054f5064b7SMark J Musante 
17064f5064b7SMark J Musante 	(void) rw_rdlock(&ztest_shared->zs_name_lock);
17074f5064b7SMark J Musante 
17084f5064b7SMark J Musante 	dmu_objset_name(os, osname);
1709718d718aSGeorge Wilson 	ztest_dsl_dataset_cleanup(osname, curval);
1710718d718aSGeorge Wilson 
171105312e2cSMark J Musante 	(void) snprintf(snap1name, 100, "%s@s1_%llu", osname, curval);
171205312e2cSMark J Musante 	(void) snprintf(clone1name, 100, "%s/c1_%llu", osname, curval);
171305312e2cSMark J Musante 	(void) snprintf(snap2name, 100, "%s@s2_%llu", clone1name, curval);
171405312e2cSMark J Musante 	(void) snprintf(clone2name, 100, "%s/c2_%llu", osname, curval);
171505312e2cSMark J Musante 	(void) snprintf(snap3name, 100, "%s@s3_%llu", clone1name, curval);
171605312e2cSMark J Musante 
1717ea2f5b9eSMatthew Ahrens 	error = dmu_objset_snapshot(osname, strchr(snap1name, '@')+1,
1718ea2f5b9eSMatthew Ahrens 	    NULL, FALSE);
1719b2d22b66SGeorge Wilson 	if (error && error != EEXIST) {
1720b2d22b66SGeorge Wilson 		if (error == ENOSPC) {
1721b2d22b66SGeorge Wilson 			ztest_record_enospc("dmu_take_snapshot");
1722b2d22b66SGeorge Wilson 			goto out;
1723b2d22b66SGeorge Wilson 		}
1724b2d22b66SGeorge Wilson 		fatal(0, "dmu_take_snapshot(%s) = %d", snap1name, error);
1725b2d22b66SGeorge Wilson 	}
17264f5064b7SMark J Musante 
1727503ad85cSMatthew Ahrens 	error = dmu_objset_hold(snap1name, FTAG, &clone);
17284f5064b7SMark J Musante 	if (error)
17294f5064b7SMark J Musante 		fatal(0, "dmu_open_snapshot(%s) = %d", snap1name, error);
17304f5064b7SMark J Musante 
1731ae46e4c7SMatthew Ahrens 	error = dmu_objset_clone(clone1name, dmu_objset_ds(clone), 0);
1732503ad85cSMatthew Ahrens 	dmu_objset_rele(clone, FTAG);
1733b2d22b66SGeorge Wilson 	if (error) {
1734b2d22b66SGeorge Wilson 		if (error == ENOSPC) {
1735b2d22b66SGeorge Wilson 			ztest_record_enospc("dmu_objset_create");
1736b2d22b66SGeorge Wilson 			goto out;
1737b2d22b66SGeorge Wilson 		}
1738b2d22b66SGeorge Wilson 		fatal(0, "dmu_objset_create(%s) = %d", clone1name, error);
1739b2d22b66SGeorge Wilson 	}
17404f5064b7SMark J Musante 
17414f5064b7SMark J Musante 	error = dmu_objset_snapshot(clone1name, strchr(snap2name, '@')+1,
1742ea2f5b9eSMatthew Ahrens 	    NULL, FALSE);
1743b2d22b66SGeorge Wilson 	if (error && error != EEXIST) {
1744b2d22b66SGeorge Wilson 		if (error == ENOSPC) {
1745b2d22b66SGeorge Wilson 			ztest_record_enospc("dmu_take_snapshot");
1746b2d22b66SGeorge Wilson 			goto out;
1747b2d22b66SGeorge Wilson 		}
1748b2d22b66SGeorge Wilson 		fatal(0, "dmu_open_snapshot(%s) = %d", snap2name, error);
1749b2d22b66SGeorge Wilson 	}
17504f5064b7SMark J Musante 
17514f5064b7SMark J Musante 	error = dmu_objset_snapshot(clone1name, strchr(snap3name, '@')+1,
1752ea2f5b9eSMatthew Ahrens 	    NULL, FALSE);
1753b2d22b66SGeorge Wilson 	if (error && error != EEXIST) {
1754b2d22b66SGeorge Wilson 		if (error == ENOSPC) {
1755b2d22b66SGeorge Wilson 			ztest_record_enospc("dmu_take_snapshot");
1756b2d22b66SGeorge Wilson 			goto out;
1757b2d22b66SGeorge Wilson 		}
1758b2d22b66SGeorge Wilson 		fatal(0, "dmu_open_snapshot(%s) = %d", snap3name, error);
1759b2d22b66SGeorge Wilson 	}
17604f5064b7SMark J Musante 
1761503ad85cSMatthew Ahrens 	error = dmu_objset_hold(snap3name, FTAG, &clone);
17624f5064b7SMark J Musante 	if (error)
17634f5064b7SMark J Musante 		fatal(0, "dmu_open_snapshot(%s) = %d", snap3name, error);
17644f5064b7SMark J Musante 
1765ae46e4c7SMatthew Ahrens 	error = dmu_objset_clone(clone2name, dmu_objset_ds(clone), 0);
1766503ad85cSMatthew Ahrens 	dmu_objset_rele(clone, FTAG);
1767b2d22b66SGeorge Wilson 	if (error) {
1768b2d22b66SGeorge Wilson 		if (error == ENOSPC) {
1769b2d22b66SGeorge Wilson 			ztest_record_enospc("dmu_objset_create");
1770b2d22b66SGeorge Wilson 			goto out;
1771b2d22b66SGeorge Wilson 		}
1772b2d22b66SGeorge Wilson 		fatal(0, "dmu_objset_create(%s) = %d", clone2name, error);
1773b2d22b66SGeorge Wilson 	}
17744f5064b7SMark J Musante 
1775503ad85cSMatthew Ahrens 	error = dsl_dataset_own(snap1name, B_FALSE, FTAG, &ds);
17764f5064b7SMark J Musante 	if (error)
17774f5064b7SMark J Musante 		fatal(0, "dsl_dataset_own(%s) = %d", snap1name, error);
1778681d9761SEric Taylor 	error = dsl_dataset_promote(clone2name, NULL);
17794f5064b7SMark J Musante 	if (error != EBUSY)
17804f5064b7SMark J Musante 		fatal(0, "dsl_dataset_promote(%s), %d, not EBUSY", clone2name,
17814f5064b7SMark J Musante 		    error);
17824f5064b7SMark J Musante 	dsl_dataset_disown(ds, FTAG);
17834f5064b7SMark J Musante 
1784b2d22b66SGeorge Wilson out:
1785718d718aSGeorge Wilson 	ztest_dsl_dataset_cleanup(osname, curval);
17864f5064b7SMark J Musante 
17874f5064b7SMark J Musante 	(void) rw_unlock(&ztest_shared->zs_name_lock);
1788fa9e4066Sahrens }
1789fa9e4066Sahrens 
1790fa9e4066Sahrens /*
1791fa9e4066Sahrens  * Verify that dmu_object_{alloc,free} work as expected.
1792fa9e4066Sahrens  */
1793fa9e4066Sahrens void
1794fa9e4066Sahrens ztest_dmu_object_alloc_free(ztest_args_t *za)
1795fa9e4066Sahrens {
1796fa9e4066Sahrens 	objset_t *os = za->za_os;
1797fa9e4066Sahrens 	dmu_buf_t *db;
1798fa9e4066Sahrens 	dmu_tx_t *tx;
1799fa9e4066Sahrens 	uint64_t batchobj, object, batchsize, endoff, temp;
1800fa9e4066Sahrens 	int b, c, error, bonuslen;
1801e05725b1Sbonwick 	dmu_object_info_t *doi = &za->za_doi;
1802fa9e4066Sahrens 	char osname[MAXNAMELEN];
1803fa9e4066Sahrens 
1804fa9e4066Sahrens 	dmu_objset_name(os, osname);
1805fa9e4066Sahrens 
1806fa9e4066Sahrens 	endoff = -8ULL;
1807fa9e4066Sahrens 	batchsize = 2;
1808fa9e4066Sahrens 
1809fa9e4066Sahrens 	/*
1810fa9e4066Sahrens 	 * Create a batch object if necessary, and record it in the directory.
1811fa9e4066Sahrens 	 */
1812e14bb325SJeff Bonwick 	VERIFY3U(0, ==, dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
18137bfdf011SNeil Perrin 	    sizeof (uint64_t), &batchobj, DMU_READ_PREFETCH));
1814fa9e4066Sahrens 	if (batchobj == 0) {
1815fa9e4066Sahrens 		tx = dmu_tx_create(os);
1816fa9e4066Sahrens 		dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff,
1817fa9e4066Sahrens 		    sizeof (uint64_t));
1818fa9e4066Sahrens 		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1819fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
1820fa9e4066Sahrens 		if (error) {
1821fa9e4066Sahrens 			ztest_record_enospc("create a batch object");
1822fa9e4066Sahrens 			dmu_tx_abort(tx);
1823fa9e4066Sahrens 			return;
1824fa9e4066Sahrens 		}
1825fa9e4066Sahrens 		batchobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
1826fa9e4066Sahrens 		    DMU_OT_NONE, 0, tx);
1827fa9e4066Sahrens 		ztest_set_random_blocksize(os, batchobj, tx);
1828fa9e4066Sahrens 		dmu_write(os, ZTEST_DIROBJ, za->za_diroff,
1829fa9e4066Sahrens 		    sizeof (uint64_t), &batchobj, tx);
1830fa9e4066Sahrens 		dmu_tx_commit(tx);
1831fa9e4066Sahrens 	}
1832fa9e4066Sahrens 
1833fa9e4066Sahrens 	/*
1834fa9e4066Sahrens 	 * Destroy the previous batch of objects.
1835fa9e4066Sahrens 	 */
1836fa9e4066Sahrens 	for (b = 0; b < batchsize; b++) {
1837088f3894Sahrens 		VERIFY3U(0, ==, dmu_read(os, batchobj, b * sizeof (uint64_t),
18387bfdf011SNeil Perrin 		    sizeof (uint64_t), &object, DMU_READ_PREFETCH));
1839fa9e4066Sahrens 		if (object == 0)
1840fa9e4066Sahrens 			continue;
1841fa9e4066Sahrens 		/*
1842fa9e4066Sahrens 		 * Read and validate contents.
1843fa9e4066Sahrens 		 * We expect the nth byte of the bonus buffer to be n.
1844fa9e4066Sahrens 		 */
1845ea8dc4b6Seschrock 		VERIFY(0 == dmu_bonus_hold(os, object, FTAG, &db));
1846e05725b1Sbonwick 		za->za_dbuf = db;
1847fa9e4066Sahrens 
1848e05725b1Sbonwick 		dmu_object_info_from_db(db, doi);
1849e05725b1Sbonwick 		ASSERT(doi->doi_type == DMU_OT_UINT64_OTHER);
1850e05725b1Sbonwick 		ASSERT(doi->doi_bonus_type == DMU_OT_PLAIN_OTHER);
1851e05725b1Sbonwick 		ASSERT3S(doi->doi_physical_blks, >=, 0);
1852fa9e4066Sahrens 
1853e05725b1Sbonwick 		bonuslen = doi->doi_bonus_size;
1854fa9e4066Sahrens 
1855fa9e4066Sahrens 		for (c = 0; c < bonuslen; c++) {
1856fa9e4066Sahrens 			if (((uint8_t *)db->db_data)[c] !=
1857fa9e4066Sahrens 			    (uint8_t)(c + bonuslen)) {
1858fa9e4066Sahrens 				fatal(0,
1859fa9e4066Sahrens 				    "bad bonus: %s, obj %llu, off %d: %u != %u",
1860fa9e4066Sahrens 				    osname, object, c,
1861fa9e4066Sahrens 				    ((uint8_t *)db->db_data)[c],
1862fa9e4066Sahrens 				    (uint8_t)(c + bonuslen));
1863fa9e4066Sahrens 			}
1864fa9e4066Sahrens 		}
1865fa9e4066Sahrens 
1866ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
1867e05725b1Sbonwick 		za->za_dbuf = NULL;
1868fa9e4066Sahrens 
1869fa9e4066Sahrens 		/*
1870fa9e4066Sahrens 		 * We expect the word at endoff to be our object number.
1871fa9e4066Sahrens 		 */
1872ea8dc4b6Seschrock 		VERIFY(0 == dmu_read(os, object, endoff,
18737bfdf011SNeil Perrin 		    sizeof (uint64_t), &temp, DMU_READ_PREFETCH));
1874fa9e4066Sahrens 
1875fa9e4066Sahrens 		if (temp != object) {
1876fa9e4066Sahrens 			fatal(0, "bad data in %s, got %llu, expected %llu",
1877fa9e4066Sahrens 			    osname, temp, object);
1878fa9e4066Sahrens 		}
1879fa9e4066Sahrens 
1880fa9e4066Sahrens 		/*
1881fa9e4066Sahrens 		 * Destroy old object and clear batch entry.
1882fa9e4066Sahrens 		 */
1883fa9e4066Sahrens 		tx = dmu_tx_create(os);
1884fa9e4066Sahrens 		dmu_tx_hold_write(tx, batchobj,
1885fa9e4066Sahrens 		    b * sizeof (uint64_t), sizeof (uint64_t));
1886fa9e4066Sahrens 		dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
1887fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
1888fa9e4066Sahrens 		if (error) {
1889fa9e4066Sahrens 			ztest_record_enospc("free object");
1890fa9e4066Sahrens 			dmu_tx_abort(tx);
1891fa9e4066Sahrens 			return;
1892fa9e4066Sahrens 		}
1893fa9e4066Sahrens 		error = dmu_object_free(os, object, tx);
1894fa9e4066Sahrens 		if (error) {
1895fa9e4066Sahrens 			fatal(0, "dmu_object_free('%s', %llu) = %d",
1896fa9e4066Sahrens 			    osname, object, error);
1897fa9e4066Sahrens 		}
1898fa9e4066Sahrens 		object = 0;
1899fa9e4066Sahrens 
1900fa9e4066Sahrens 		dmu_object_set_checksum(os, batchobj,
1901fa9e4066Sahrens 		    ztest_random_checksum(), tx);
1902fa9e4066Sahrens 		dmu_object_set_compress(os, batchobj,
1903fa9e4066Sahrens 		    ztest_random_compress(), tx);
1904fa9e4066Sahrens 
1905fa9e4066Sahrens 		dmu_write(os, batchobj, b * sizeof (uint64_t),
1906fa9e4066Sahrens 		    sizeof (uint64_t), &object, tx);
1907fa9e4066Sahrens 
1908fa9e4066Sahrens 		dmu_tx_commit(tx);
1909fa9e4066Sahrens 	}
1910fa9e4066Sahrens 
1911fa9e4066Sahrens 	/*
1912fa9e4066Sahrens 	 * Before creating the new batch of objects, generate a bunch of churn.
1913fa9e4066Sahrens 	 */
1914fa9e4066Sahrens 	for (b = ztest_random(100); b > 0; b--) {
1915fa9e4066Sahrens 		tx = dmu_tx_create(os);
1916fa9e4066Sahrens 		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1917fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
1918fa9e4066Sahrens 		if (error) {
1919fa9e4066Sahrens 			ztest_record_enospc("churn objects");
1920fa9e4066Sahrens 			dmu_tx_abort(tx);
1921fa9e4066Sahrens 			return;
1922fa9e4066Sahrens 		}
1923fa9e4066Sahrens 		object = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
1924fa9e4066Sahrens 		    DMU_OT_NONE, 0, tx);
1925fa9e4066Sahrens 		ztest_set_random_blocksize(os, object, tx);
1926fa9e4066Sahrens 		error = dmu_object_free(os, object, tx);
1927fa9e4066Sahrens 		if (error) {
1928fa9e4066Sahrens 			fatal(0, "dmu_object_free('%s', %llu) = %d",
1929fa9e4066Sahrens 			    osname, object, error);
1930fa9e4066Sahrens 		}
1931fa9e4066Sahrens 		dmu_tx_commit(tx);
1932fa9e4066Sahrens 	}
1933fa9e4066Sahrens 
1934fa9e4066Sahrens 	/*
1935fa9e4066Sahrens 	 * Create a new batch of objects with randomly chosen
1936fa9e4066Sahrens 	 * blocksizes and record them in the batch directory.
1937fa9e4066Sahrens 	 */
1938fa9e4066Sahrens 	for (b = 0; b < batchsize; b++) {
1939fa9e4066Sahrens 		uint32_t va_blksize;
1940fa9e4066Sahrens 		u_longlong_t va_nblocks;
1941fa9e4066Sahrens 
1942fa9e4066Sahrens 		tx = dmu_tx_create(os);
1943fa9e4066Sahrens 		dmu_tx_hold_write(tx, batchobj, b * sizeof (uint64_t),
1944fa9e4066Sahrens 		    sizeof (uint64_t));
1945fa9e4066Sahrens 		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1946fa9e4066Sahrens 		dmu_tx_hold_write(tx, DMU_NEW_OBJECT, endoff,
1947fa9e4066Sahrens 		    sizeof (uint64_t));
1948fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
1949fa9e4066Sahrens 		if (error) {
1950fa9e4066Sahrens 			ztest_record_enospc("create batchobj");
1951fa9e4066Sahrens 			dmu_tx_abort(tx);
1952fa9e4066Sahrens 			return;
1953fa9e4066Sahrens 		}
1954fa9e4066Sahrens 		bonuslen = (int)ztest_random(dmu_bonus_max()) + 1;
1955fa9e4066Sahrens 
1956fa9e4066Sahrens 		object = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
1957fa9e4066Sahrens 		    DMU_OT_PLAIN_OTHER, bonuslen, tx);
1958fa9e4066Sahrens 
1959fa9e4066Sahrens 		ztest_set_random_blocksize(os, object, tx);
1960fa9e4066Sahrens 
1961fa9e4066Sahrens 		dmu_object_set_checksum(os, object,
1962fa9e4066Sahrens 		    ztest_random_checksum(), tx);
1963fa9e4066Sahrens 		dmu_object_set_compress(os, object,
1964fa9e4066Sahrens 		    ztest_random_compress(), tx);
1965fa9e4066Sahrens 
1966fa9e4066Sahrens 		dmu_write(os, batchobj, b * sizeof (uint64_t),
1967fa9e4066Sahrens 		    sizeof (uint64_t), &object, tx);
1968fa9e4066Sahrens 
1969fa9e4066Sahrens 		/*
1970fa9e4066Sahrens 		 * Write to both the bonus buffer and the regular data.
1971fa9e4066Sahrens 		 */
1972e05725b1Sbonwick 		VERIFY(dmu_bonus_hold(os, object, FTAG, &db) == 0);
1973e05725b1Sbonwick 		za->za_dbuf = db;
19741934e92fSmaybee 		ASSERT3U(bonuslen, <=, db->db_size);
1975fa9e4066Sahrens 
1976fa9e4066Sahrens 		dmu_object_size_from_db(db, &va_blksize, &va_nblocks);
1977fa9e4066Sahrens 		ASSERT3S(va_nblocks, >=, 0);
1978fa9e4066Sahrens 
1979fa9e4066Sahrens 		dmu_buf_will_dirty(db, tx);
1980fa9e4066Sahrens 
1981fa9e4066Sahrens 		/*
1982fa9e4066Sahrens 		 * See comments above regarding the contents of
1983fa9e4066Sahrens 		 * the bonus buffer and the word at endoff.
1984fa9e4066Sahrens 		 */
19851934e92fSmaybee 		for (c = 0; c < bonuslen; c++)
1986fa9e4066Sahrens 			((uint8_t *)db->db_data)[c] = (uint8_t)(c + bonuslen);
1987fa9e4066Sahrens 
1988ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
1989e05725b1Sbonwick 		za->za_dbuf = NULL;
1990fa9e4066Sahrens 
1991fa9e4066Sahrens 		/*
1992fa9e4066Sahrens 		 * Write to a large offset to increase indirection.
1993fa9e4066Sahrens 		 */
1994fa9e4066Sahrens 		dmu_write(os, object, endoff, sizeof (uint64_t), &object, tx);
1995fa9e4066Sahrens 
1996fa9e4066Sahrens 		dmu_tx_commit(tx);
1997fa9e4066Sahrens 	}
1998fa9e4066Sahrens }
1999fa9e4066Sahrens 
2000fa9e4066Sahrens /*
2001fa9e4066Sahrens  * Verify that dmu_{read,write} work as expected.
2002fa9e4066Sahrens  */
2003fa9e4066Sahrens typedef struct bufwad {
2004fa9e4066Sahrens 	uint64_t	bw_index;
2005fa9e4066Sahrens 	uint64_t	bw_txg;
2006fa9e4066Sahrens 	uint64_t	bw_data;
2007fa9e4066Sahrens } bufwad_t;
2008fa9e4066Sahrens 
2009fa9e4066Sahrens typedef struct dmu_read_write_dir {
2010fa9e4066Sahrens 	uint64_t	dd_packobj;
2011fa9e4066Sahrens 	uint64_t	dd_bigobj;
2012fa9e4066Sahrens 	uint64_t	dd_chunk;
2013fa9e4066Sahrens } dmu_read_write_dir_t;
2014fa9e4066Sahrens 
2015fa9e4066Sahrens void
2016fa9e4066Sahrens ztest_dmu_read_write(ztest_args_t *za)
2017fa9e4066Sahrens {
2018fa9e4066Sahrens 	objset_t *os = za->za_os;
2019fa9e4066Sahrens 	dmu_read_write_dir_t dd;
2020fa9e4066Sahrens 	dmu_tx_t *tx;
2021fa9e4066Sahrens 	int i, freeit, error;
2022fa9e4066Sahrens 	uint64_t n, s, txg;
2023fa9e4066Sahrens 	bufwad_t *packbuf, *bigbuf, *pack, *bigH, *bigT;
2024fa9e4066Sahrens 	uint64_t packoff, packsize, bigoff, bigsize;
2025fa9e4066Sahrens 	uint64_t regions = 997;
2026fa9e4066Sahrens 	uint64_t stride = 123456789ULL;
2027fa9e4066Sahrens 	uint64_t width = 40;
2028fa9e4066Sahrens 	int free_percent = 5;
2029fa9e4066Sahrens 
2030fa9e4066Sahrens 	/*
2031fa9e4066Sahrens 	 * This test uses two objects, packobj and bigobj, that are always
2032fa9e4066Sahrens 	 * updated together (i.e. in the same tx) so that their contents are
2033fa9e4066Sahrens 	 * in sync and can be compared.  Their contents relate to each other
2034fa9e4066Sahrens 	 * in a simple way: packobj is a dense array of 'bufwad' structures,
2035fa9e4066Sahrens 	 * while bigobj is a sparse array of the same bufwads.  Specifically,
2036fa9e4066Sahrens 	 * for any index n, there are three bufwads that should be identical:
2037fa9e4066Sahrens 	 *
2038fa9e4066Sahrens 	 *	packobj, at offset n * sizeof (bufwad_t)
2039fa9e4066Sahrens 	 *	bigobj, at the head of the nth chunk
2040fa9e4066Sahrens 	 *	bigobj, at the tail of the nth chunk
2041fa9e4066Sahrens 	 *
2042fa9e4066Sahrens 	 * The chunk size is arbitrary. It doesn't have to be a power of two,
2043fa9e4066Sahrens 	 * and it doesn't have any relation to the object blocksize.
2044fa9e4066Sahrens 	 * The only requirement is that it can hold at least two bufwads.
2045fa9e4066Sahrens 	 *
2046fa9e4066Sahrens 	 * Normally, we write the bufwad to each of these locations.
2047fa9e4066Sahrens 	 * However, free_percent of the time we instead write zeroes to
2048fa9e4066Sahrens 	 * packobj and perform a dmu_free_range() on bigobj.  By comparing
2049fa9e4066Sahrens 	 * bigobj to packobj, we can verify that the DMU is correctly
2050fa9e4066Sahrens 	 * tracking which parts of an object are allocated and free,
2051fa9e4066Sahrens 	 * and that the contents of the allocated blocks are correct.
2052fa9e4066Sahrens 	 */
2053fa9e4066Sahrens 
2054fa9e4066Sahrens 	/*
2055fa9e4066Sahrens 	 * Read the directory info.  If it's the first time, set things up.
2056fa9e4066Sahrens 	 */
2057ea8dc4b6Seschrock 	VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
20587bfdf011SNeil Perrin 	    sizeof (dd), &dd, DMU_READ_PREFETCH));
2059fa9e4066Sahrens 	if (dd.dd_chunk == 0) {
2060fa9e4066Sahrens 		ASSERT(dd.dd_packobj == 0);
2061fa9e4066Sahrens 		ASSERT(dd.dd_bigobj == 0);
2062fa9e4066Sahrens 		tx = dmu_tx_create(os);
2063fa9e4066Sahrens 		dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (dd));
2064fa9e4066Sahrens 		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
2065fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
2066fa9e4066Sahrens 		if (error) {
2067fa9e4066Sahrens 			ztest_record_enospc("create r/w directory");
2068fa9e4066Sahrens 			dmu_tx_abort(tx);
2069fa9e4066Sahrens 			return;
2070fa9e4066Sahrens 		}
2071fa9e4066Sahrens 
2072fa9e4066Sahrens 		dd.dd_packobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
2073fa9e4066Sahrens 		    DMU_OT_NONE, 0, tx);
2074fa9e4066Sahrens 		dd.dd_bigobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
2075fa9e4066Sahrens 		    DMU_OT_NONE, 0, tx);
2076fa9e4066Sahrens 		dd.dd_chunk = (1000 + ztest_random(1000)) * sizeof (uint64_t);
2077fa9e4066Sahrens 
2078fa9e4066Sahrens 		ztest_set_random_blocksize(os, dd.dd_packobj, tx);
2079fa9e4066Sahrens 		ztest_set_random_blocksize(os, dd.dd_bigobj, tx);
2080fa9e4066Sahrens 
2081fa9e4066Sahrens 		dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (dd), &dd,
2082fa9e4066Sahrens 		    tx);
2083fa9e4066Sahrens 		dmu_tx_commit(tx);
2084fa9e4066Sahrens 	}
2085fa9e4066Sahrens 
2086fa9e4066Sahrens 	/*
2087fa9e4066Sahrens 	 * Prefetch a random chunk of the big object.
2088fa9e4066Sahrens 	 * Our aim here is to get some async reads in flight
2089fa9e4066Sahrens 	 * for blocks that we may free below; the DMU should
2090fa9e4066Sahrens 	 * handle this race correctly.
2091fa9e4066Sahrens 	 */
2092fa9e4066Sahrens 	n = ztest_random(regions) * stride + ztest_random(width);
2093fa9e4066Sahrens 	s = 1 + ztest_random(2 * width - 1);
2094fa9e4066Sahrens 	dmu_prefetch(os, dd.dd_bigobj, n * dd.dd_chunk, s * dd.dd_chunk);
2095fa9e4066Sahrens 
2096fa9e4066Sahrens 	/*
2097fa9e4066Sahrens 	 * Pick a random index and compute the offsets into packobj and bigobj.
2098fa9e4066Sahrens 	 */
2099fa9e4066Sahrens 	n = ztest_random(regions) * stride + ztest_random(width);
2100fa9e4066Sahrens 	s = 1 + ztest_random(width - 1);
2101fa9e4066Sahrens 
2102fa9e4066Sahrens 	packoff = n * sizeof (bufwad_t);
2103fa9e4066Sahrens 	packsize = s * sizeof (bufwad_t);
2104fa9e4066Sahrens 
2105fa9e4066Sahrens 	bigoff = n * dd.dd_chunk;
2106fa9e4066Sahrens 	bigsize = s * dd.dd_chunk;
2107fa9e4066Sahrens 
2108fa9e4066Sahrens 	packbuf = umem_alloc(packsize, UMEM_NOFAIL);
2109fa9e4066Sahrens 	bigbuf = umem_alloc(bigsize, UMEM_NOFAIL);
2110fa9e4066Sahrens 
2111fa9e4066Sahrens 	/*
2112fa9e4066Sahrens 	 * free_percent of the time, free a range of bigobj rather than
2113fa9e4066Sahrens 	 * overwriting it.
2114fa9e4066Sahrens 	 */
2115fa9e4066Sahrens 	freeit = (ztest_random(100) < free_percent);
2116fa9e4066Sahrens 
2117fa9e4066Sahrens 	/*
2118fa9e4066Sahrens 	 * Read the current contents of our objects.
2119fa9e4066Sahrens 	 */
21207bfdf011SNeil Perrin 	error = dmu_read(os, dd.dd_packobj, packoff, packsize, packbuf,
21217bfdf011SNeil Perrin 	    DMU_READ_PREFETCH);
2122ea8dc4b6Seschrock 	ASSERT3U(error, ==, 0);
21237bfdf011SNeil Perrin 	error = dmu_read(os, dd.dd_bigobj, bigoff, bigsize, bigbuf,
21247bfdf011SNeil Perrin 	    DMU_READ_PREFETCH);
2125ea8dc4b6Seschrock 	ASSERT3U(error, ==, 0);
2126fa9e4066Sahrens 
2127fa9e4066Sahrens 	/*
2128fa9e4066Sahrens 	 * Get a tx for the mods to both packobj and bigobj.
2129fa9e4066Sahrens 	 */
2130fa9e4066Sahrens 	tx = dmu_tx_create(os);
2131fa9e4066Sahrens 
2132fa9e4066Sahrens 	dmu_tx_hold_write(tx, dd.dd_packobj, packoff, packsize);
2133fa9e4066Sahrens 
2134fa9e4066Sahrens 	if (freeit)
2135fa9e4066Sahrens 		dmu_tx_hold_free(tx, dd.dd_bigobj, bigoff, bigsize);
2136fa9e4066Sahrens 	else
2137fa9e4066Sahrens 		dmu_tx_hold_write(tx, dd.dd_bigobj, bigoff, bigsize);
2138fa9e4066Sahrens 
2139fa9e4066Sahrens 	error = dmu_tx_assign(tx, TXG_WAIT);
2140fa9e4066Sahrens 
2141fa9e4066Sahrens 	if (error) {
2142fa9e4066Sahrens 		ztest_record_enospc("dmu r/w range");
2143fa9e4066Sahrens 		dmu_tx_abort(tx);
2144fa9e4066Sahrens 		umem_free(packbuf, packsize);
2145fa9e4066Sahrens 		umem_free(bigbuf, bigsize);
2146fa9e4066Sahrens 		return;
2147fa9e4066Sahrens 	}
2148fa9e4066Sahrens 
2149fa9e4066Sahrens 	txg = dmu_tx_get_txg(tx);
2150fa9e4066Sahrens 
2151fa9e4066Sahrens 	/*
2152fa9e4066Sahrens 	 * For each index from n to n + s, verify that the existing bufwad
2153fa9e4066Sahrens 	 * in packobj matches the bufwads at the head and tail of the
2154fa9e4066Sahrens 	 * corresponding chunk in bigobj.  Then update all three bufwads
2155fa9e4066Sahrens 	 * with the new values we want to write out.
2156fa9e4066Sahrens 	 */
2157fa9e4066Sahrens 	for (i = 0; i < s; i++) {
2158fa9e4066Sahrens 		/* LINTED */
2159fa9e4066Sahrens 		pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
2160fa9e4066Sahrens 		/* LINTED */
2161fa9e4066Sahrens 		bigH = (bufwad_t *)((char *)bigbuf + i * dd.dd_chunk);
2162fa9e4066Sahrens 		/* LINTED */
2163fa9e4066Sahrens 		bigT = (bufwad_t *)((char *)bigH + dd.dd_chunk) - 1;
2164fa9e4066Sahrens 
2165fa9e4066Sahrens 		ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
2166fa9e4066Sahrens 		ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
2167fa9e4066Sahrens 
2168fa9e4066Sahrens 		if (pack->bw_txg > txg)
2169fa9e4066Sahrens 			fatal(0, "future leak: got %llx, open txg is %llx",
2170fa9e4066Sahrens 			    pack->bw_txg, txg);
2171fa9e4066Sahrens 
2172fa9e4066Sahrens 		if (pack->bw_data != 0 && pack->bw_index != n + i)
2173fa9e4066Sahrens 			fatal(0, "wrong index: got %llx, wanted %llx+%llx",
2174fa9e4066Sahrens 			    pack->bw_index, n, i);
2175fa9e4066Sahrens 
2176fa9e4066Sahrens 		if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0)
2177fa9e4066Sahrens 			fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH);
2178fa9e4066Sahrens 
2179fa9e4066Sahrens 		if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0)
2180fa9e4066Sahrens 			fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT);
2181fa9e4066Sahrens 
2182fa9e4066Sahrens 		if (freeit) {
2183fa9e4066Sahrens 			bzero(pack, sizeof (bufwad_t));
2184fa9e4066Sahrens 		} else {
2185fa9e4066Sahrens 			pack->bw_index = n + i;
2186fa9e4066Sahrens 			pack->bw_txg = txg;
2187fa9e4066Sahrens 			pack->bw_data = 1 + ztest_random(-2ULL);
2188fa9e4066Sahrens 		}
2189fa9e4066Sahrens 		*bigH = *pack;
2190fa9e4066Sahrens 		*bigT = *pack;
2191fa9e4066Sahrens 	}
2192fa9e4066Sahrens 
2193fa9e4066Sahrens 	/*
2194fa9e4066Sahrens 	 * We've verified all the old bufwads, and made new ones.
2195fa9e4066Sahrens 	 * Now write them out.
2196fa9e4066Sahrens 	 */
2197fa9e4066Sahrens 	dmu_write(os, dd.dd_packobj, packoff, packsize, packbuf, tx);
2198fa9e4066Sahrens 
2199fa9e4066Sahrens 	if (freeit) {
2200fa9e4066Sahrens 		if (zopt_verbose >= 6) {
2201fa9e4066Sahrens 			(void) printf("freeing offset %llx size %llx"
2202fa9e4066Sahrens 			    " txg %llx\n",
2203fa9e4066Sahrens 			    (u_longlong_t)bigoff,
2204fa9e4066Sahrens 			    (u_longlong_t)bigsize,
2205fa9e4066Sahrens 			    (u_longlong_t)txg);
2206fa9e4066Sahrens 		}
2207ea8dc4b6Seschrock 		VERIFY(0 == dmu_free_range(os, dd.dd_bigobj, bigoff,
2208ea8dc4b6Seschrock 		    bigsize, tx));
2209fa9e4066Sahrens 	} else {
2210fa9e4066Sahrens 		if (zopt_verbose >= 6) {
2211fa9e4066Sahrens 			(void) printf("writing offset %llx size %llx"
2212fa9e4066Sahrens 			    " txg %llx\n",
2213fa9e4066Sahrens 			    (u_longlong_t)bigoff,
2214fa9e4066Sahrens 			    (u_longlong_t)bigsize,
2215fa9e4066Sahrens 			    (u_longlong_t)txg);
2216fa9e4066Sahrens 		}
2217fa9e4066Sahrens 		dmu_write(os, dd.dd_bigobj, bigoff, bigsize, bigbuf, tx);
2218fa9e4066Sahrens 	}
2219fa9e4066Sahrens 
2220fa9e4066Sahrens 	dmu_tx_commit(tx);
2221fa9e4066Sahrens 
2222fa9e4066Sahrens 	/*
2223fa9e4066Sahrens 	 * Sanity check the stuff we just wrote.
2224fa9e4066Sahrens 	 */
2225fa9e4066Sahrens 	{
2226fa9e4066Sahrens 		void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
2227fa9e4066Sahrens 		void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
2228fa9e4066Sahrens 
2229ea8dc4b6Seschrock 		VERIFY(0 == dmu_read(os, dd.dd_packobj, packoff,
22307bfdf011SNeil Perrin 		    packsize, packcheck, DMU_READ_PREFETCH));
2231ea8dc4b6Seschrock 		VERIFY(0 == dmu_read(os, dd.dd_bigobj, bigoff,
22327bfdf011SNeil Perrin 		    bigsize, bigcheck, DMU_READ_PREFETCH));
2233fa9e4066Sahrens 
2234fa9e4066Sahrens 		ASSERT(bcmp(packbuf, packcheck, packsize) == 0);
2235fa9e4066Sahrens 		ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0);
2236fa9e4066Sahrens 
2237fa9e4066Sahrens 		umem_free(packcheck, packsize);
2238fa9e4066Sahrens 		umem_free(bigcheck, bigsize);
2239fa9e4066Sahrens 	}
2240fa9e4066Sahrens 
2241fa9e4066Sahrens 	umem_free(packbuf, packsize);
2242fa9e4066Sahrens 	umem_free(bigbuf, bigsize);
2243fa9e4066Sahrens }
2244fa9e4066Sahrens 
22452fdbea25SAleksandr Guzovskiy void
22462fdbea25SAleksandr Guzovskiy compare_and_update_pbbufs(uint64_t s, bufwad_t *packbuf, bufwad_t *bigbuf,
22472fdbea25SAleksandr Guzovskiy     uint64_t bigsize, uint64_t n, dmu_read_write_dir_t dd, uint64_t txg)
22482fdbea25SAleksandr Guzovskiy {
22492fdbea25SAleksandr Guzovskiy 	uint64_t i;
22502fdbea25SAleksandr Guzovskiy 	bufwad_t *pack;
22512fdbea25SAleksandr Guzovskiy 	bufwad_t *bigH;
22522fdbea25SAleksandr Guzovskiy 	bufwad_t *bigT;
22532fdbea25SAleksandr Guzovskiy 
22542fdbea25SAleksandr Guzovskiy 	/*
22552fdbea25SAleksandr Guzovskiy 	 * For each index from n to n + s, verify that the existing bufwad
22562fdbea25SAleksandr Guzovskiy 	 * in packobj matches the bufwads at the head and tail of the
22572fdbea25SAleksandr Guzovskiy 	 * corresponding chunk in bigobj.  Then update all three bufwads
22582fdbea25SAleksandr Guzovskiy 	 * with the new values we want to write out.
22592fdbea25SAleksandr Guzovskiy 	 */
22602fdbea25SAleksandr Guzovskiy 	for (i = 0; i < s; i++) {
22612fdbea25SAleksandr Guzovskiy 		/* LINTED */
22622fdbea25SAleksandr Guzovskiy 		pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
22632fdbea25SAleksandr Guzovskiy 		/* LINTED */
22642fdbea25SAleksandr Guzovskiy 		bigH = (bufwad_t *)((char *)bigbuf + i * dd.dd_chunk);
22652fdbea25SAleksandr Guzovskiy 		/* LINTED */
22662fdbea25SAleksandr Guzovskiy 		bigT = (bufwad_t *)((char *)bigH + dd.dd_chunk) - 1;
22672fdbea25SAleksandr Guzovskiy 
22682fdbea25SAleksandr Guzovskiy 		ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
22692fdbea25SAleksandr Guzovskiy 		ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
22702fdbea25SAleksandr Guzovskiy 
22712fdbea25SAleksandr Guzovskiy 		if (pack->bw_txg > txg)
22722fdbea25SAleksandr Guzovskiy 			fatal(0, "future leak: got %llx, open txg is %llx",
22732fdbea25SAleksandr Guzovskiy 			    pack->bw_txg, txg);
22742fdbea25SAleksandr Guzovskiy 
22752fdbea25SAleksandr Guzovskiy 		if (pack->bw_data != 0 && pack->bw_index != n + i)
22762fdbea25SAleksandr Guzovskiy 			fatal(0, "wrong index: got %llx, wanted %llx+%llx",
22772fdbea25SAleksandr Guzovskiy 			    pack->bw_index, n, i);
22782fdbea25SAleksandr Guzovskiy 
22792fdbea25SAleksandr Guzovskiy 		if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0)
22802fdbea25SAleksandr Guzovskiy 			fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH);
22812fdbea25SAleksandr Guzovskiy 
22822fdbea25SAleksandr Guzovskiy 		if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0)
22832fdbea25SAleksandr Guzovskiy 			fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT);
22842fdbea25SAleksandr Guzovskiy 
22852fdbea25SAleksandr Guzovskiy 		pack->bw_index = n + i;
22862fdbea25SAleksandr Guzovskiy 		pack->bw_txg = txg;
22872fdbea25SAleksandr Guzovskiy 		pack->bw_data = 1 + ztest_random(-2ULL);
22882fdbea25SAleksandr Guzovskiy 
22892fdbea25SAleksandr Guzovskiy 		*bigH = *pack;
22902fdbea25SAleksandr Guzovskiy 		*bigT = *pack;
22912fdbea25SAleksandr Guzovskiy 	}
22922fdbea25SAleksandr Guzovskiy }
22932fdbea25SAleksandr Guzovskiy 
22942fdbea25SAleksandr Guzovskiy void
22952fdbea25SAleksandr Guzovskiy ztest_dmu_read_write_zcopy(ztest_args_t *za)
22962fdbea25SAleksandr Guzovskiy {
22972fdbea25SAleksandr Guzovskiy 	objset_t *os = za->za_os;
22982fdbea25SAleksandr Guzovskiy 	dmu_read_write_dir_t dd;
22992fdbea25SAleksandr Guzovskiy 	dmu_tx_t *tx;
23002fdbea25SAleksandr Guzovskiy 	uint64_t i;
23012fdbea25SAleksandr Guzovskiy 	int error;
23022fdbea25SAleksandr Guzovskiy 	uint64_t n, s, txg;
23032fdbea25SAleksandr Guzovskiy 	bufwad_t *packbuf, *bigbuf;
23042fdbea25SAleksandr Guzovskiy 	uint64_t packoff, packsize, bigoff, bigsize;
23052fdbea25SAleksandr Guzovskiy 	uint64_t regions = 997;
23062fdbea25SAleksandr Guzovskiy 	uint64_t stride = 123456789ULL;
23072fdbea25SAleksandr Guzovskiy 	uint64_t width = 9;
23082fdbea25SAleksandr Guzovskiy 	dmu_buf_t *bonus_db;
23092fdbea25SAleksandr Guzovskiy 	arc_buf_t **bigbuf_arcbufs;
23102fdbea25SAleksandr Guzovskiy 	dmu_object_info_t *doi = &za->za_doi;
23112fdbea25SAleksandr Guzovskiy 
23122fdbea25SAleksandr Guzovskiy 	/*
23132fdbea25SAleksandr Guzovskiy 	 * This test uses two objects, packobj and bigobj, that are always
23142fdbea25SAleksandr Guzovskiy 	 * updated together (i.e. in the same tx) so that their contents are
23152fdbea25SAleksandr Guzovskiy 	 * in sync and can be compared.  Their contents relate to each other
23162fdbea25SAleksandr Guzovskiy 	 * in a simple way: packobj is a dense array of 'bufwad' structures,
23172fdbea25SAleksandr Guzovskiy 	 * while bigobj is a sparse array of the same bufwads.  Specifically,
23182fdbea25SAleksandr Guzovskiy 	 * for any index n, there are three bufwads that should be identical:
23192fdbea25SAleksandr Guzovskiy 	 *
23202fdbea25SAleksandr Guzovskiy 	 *	packobj, at offset n * sizeof (bufwad_t)
23212fdbea25SAleksandr Guzovskiy 	 *	bigobj, at the head of the nth chunk
23222fdbea25SAleksandr Guzovskiy 	 *	bigobj, at the tail of the nth chunk
23232fdbea25SAleksandr Guzovskiy 	 *
23242fdbea25SAleksandr Guzovskiy 	 * The chunk size is set equal to bigobj block size so that
23252fdbea25SAleksandr Guzovskiy 	 * dmu_assign_arcbuf() can be tested for object updates.
23262fdbea25SAleksandr Guzovskiy 	 */
23272fdbea25SAleksandr Guzovskiy 
23282fdbea25SAleksandr Guzovskiy 	/*
23292fdbea25SAleksandr Guzovskiy 	 * Read the directory info.  If it's the first time, set things up.
23302fdbea25SAleksandr Guzovskiy 	 */
23312fdbea25SAleksandr Guzovskiy 	VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
23327bfdf011SNeil Perrin 	    sizeof (dd), &dd, DMU_READ_PREFETCH));
23332fdbea25SAleksandr Guzovskiy 	if (dd.dd_chunk == 0) {
23342fdbea25SAleksandr Guzovskiy 		ASSERT(dd.dd_packobj == 0);
23352fdbea25SAleksandr Guzovskiy 		ASSERT(dd.dd_bigobj == 0);
23362fdbea25SAleksandr Guzovskiy 		tx = dmu_tx_create(os);
23372fdbea25SAleksandr Guzovskiy 		dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (dd));
23382fdbea25SAleksandr Guzovskiy 		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
23392fdbea25SAleksandr Guzovskiy 		error = dmu_tx_assign(tx, TXG_WAIT);
23402fdbea25SAleksandr Guzovskiy 		if (error) {
23412fdbea25SAleksandr Guzovskiy 			ztest_record_enospc("create r/w directory");
23422fdbea25SAleksandr Guzovskiy 			dmu_tx_abort(tx);
23432fdbea25SAleksandr Guzovskiy 			return;
23442fdbea25SAleksandr Guzovskiy 		}
23452fdbea25SAleksandr Guzovskiy 
23462fdbea25SAleksandr Guzovskiy 		dd.dd_packobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
23472fdbea25SAleksandr Guzovskiy 		    DMU_OT_NONE, 0, tx);
23482fdbea25SAleksandr Guzovskiy 		dd.dd_bigobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
23492fdbea25SAleksandr Guzovskiy 		    DMU_OT_NONE, 0, tx);
23502fdbea25SAleksandr Guzovskiy 		ztest_set_random_blocksize(os, dd.dd_packobj, tx);
23512fdbea25SAleksandr Guzovskiy 		ztest_set_random_blocksize(os, dd.dd_bigobj, tx);
23522fdbea25SAleksandr Guzovskiy 
23532fdbea25SAleksandr Guzovskiy 		VERIFY(dmu_object_info(os, dd.dd_bigobj, doi) == 0);
23542fdbea25SAleksandr Guzovskiy 		ASSERT(doi->doi_data_block_size >= 2 * sizeof (bufwad_t));
23552fdbea25SAleksandr Guzovskiy 		ASSERT(ISP2(doi->doi_data_block_size));
23562fdbea25SAleksandr Guzovskiy 		dd.dd_chunk = doi->doi_data_block_size;
23572fdbea25SAleksandr Guzovskiy 
23582fdbea25SAleksandr Guzovskiy 		dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (dd), &dd,
23592fdbea25SAleksandr Guzovskiy 		    tx);
23602fdbea25SAleksandr Guzovskiy 		dmu_tx_commit(tx);
23612fdbea25SAleksandr Guzovskiy 	} else {
23622fdbea25SAleksandr Guzovskiy 		VERIFY(dmu_object_info(os, dd.dd_bigobj, doi) == 0);
23632fdbea25SAleksandr Guzovskiy 		VERIFY(ISP2(doi->doi_data_block_size));
23642fdbea25SAleksandr Guzovskiy 		VERIFY(dd.dd_chunk == doi->doi_data_block_size);
23652fdbea25SAleksandr Guzovskiy 		VERIFY(dd.dd_chunk >= 2 * sizeof (bufwad_t));
23662fdbea25SAleksandr Guzovskiy 	}
23672fdbea25SAleksandr Guzovskiy 
23682fdbea25SAleksandr Guzovskiy 	/*
23692fdbea25SAleksandr Guzovskiy 	 * Pick a random index and compute the offsets into packobj and bigobj.
23702fdbea25SAleksandr Guzovskiy 	 */
23712fdbea25SAleksandr Guzovskiy 	n = ztest_random(regions) * stride + ztest_random(width);
23722fdbea25SAleksandr Guzovskiy 	s = 1 + ztest_random(width - 1);
23732fdbea25SAleksandr Guzovskiy 
23742fdbea25SAleksandr Guzovskiy 	packoff = n * sizeof (bufwad_t);
23752fdbea25SAleksandr Guzovskiy 	packsize = s * sizeof (bufwad_t);
23762fdbea25SAleksandr Guzovskiy 
23772fdbea25SAleksandr Guzovskiy 	bigoff = n * dd.dd_chunk;
23782fdbea25SAleksandr Guzovskiy 	bigsize = s * dd.dd_chunk;
23792fdbea25SAleksandr Guzovskiy 
23802fdbea25SAleksandr Guzovskiy 	packbuf = umem_zalloc(packsize, UMEM_NOFAIL);
23812fdbea25SAleksandr Guzovskiy 	bigbuf = umem_zalloc(bigsize, UMEM_NOFAIL);
23822fdbea25SAleksandr Guzovskiy 
23832fdbea25SAleksandr Guzovskiy 	VERIFY(dmu_bonus_hold(os, dd.dd_bigobj, FTAG, &bonus_db) == 0);
23842fdbea25SAleksandr Guzovskiy 
23852fdbea25SAleksandr Guzovskiy 	bigbuf_arcbufs = umem_zalloc(2 * s * sizeof (arc_buf_t *), UMEM_NOFAIL);
23862fdbea25SAleksandr Guzovskiy 
23872fdbea25SAleksandr Guzovskiy 	/*
23882fdbea25SAleksandr Guzovskiy 	 * Iteration 0 test zcopy for DB_UNCACHED dbufs.
23892fdbea25SAleksandr Guzovskiy 	 * Iteration 1 test zcopy to already referenced dbufs.
23902fdbea25SAleksandr Guzovskiy 	 * Iteration 2 test zcopy to dirty dbuf in the same txg.
23912fdbea25SAleksandr Guzovskiy 	 * Iteration 3 test zcopy to dbuf dirty in previous txg.
23922fdbea25SAleksandr Guzovskiy 	 * Iteration 4 test zcopy when dbuf is no longer dirty.
23932fdbea25SAleksandr Guzovskiy 	 * Iteration 5 test zcopy when it can't be done.
23942fdbea25SAleksandr Guzovskiy 	 * Iteration 6 one more zcopy write.
23952fdbea25SAleksandr Guzovskiy 	 */
23962fdbea25SAleksandr Guzovskiy 	for (i = 0; i < 7; i++) {
23972fdbea25SAleksandr Guzovskiy 		uint64_t j;
23982fdbea25SAleksandr Guzovskiy 		uint64_t off;
23992fdbea25SAleksandr Guzovskiy 
24002fdbea25SAleksandr Guzovskiy 		/*
24012fdbea25SAleksandr Guzovskiy 		 * In iteration 5 (i == 5) use arcbufs
24022fdbea25SAleksandr Guzovskiy 		 * that don't match bigobj blksz to test
24032fdbea25SAleksandr Guzovskiy 		 * dmu_assign_arcbuf() when it can't directly
24042fdbea25SAleksandr Guzovskiy 		 * assign an arcbuf to a dbuf.
24052fdbea25SAleksandr Guzovskiy 		 */
24062fdbea25SAleksandr Guzovskiy 		for (j = 0; j < s; j++) {
24072fdbea25SAleksandr Guzovskiy 			if (i != 5) {
24082fdbea25SAleksandr Guzovskiy 				bigbuf_arcbufs[j] =
24092fdbea25SAleksandr Guzovskiy 				    dmu_request_arcbuf(bonus_db,
24102fdbea25SAleksandr Guzovskiy 				    dd.dd_chunk);
24112fdbea25SAleksandr Guzovskiy 			} else {
24122fdbea25SAleksandr Guzovskiy 				bigbuf_arcbufs[2 * j] =
24132fdbea25SAleksandr Guzovskiy 				    dmu_request_arcbuf(bonus_db,
24142fdbea25SAleksandr Guzovskiy 				    dd.dd_chunk / 2);
24152fdbea25SAleksandr Guzovskiy 				bigbuf_arcbufs[2 * j + 1] =
24162fdbea25SAleksandr Guzovskiy 				    dmu_request_arcbuf(bonus_db,
24172fdbea25SAleksandr Guzovskiy 				    dd.dd_chunk / 2);
24182fdbea25SAleksandr Guzovskiy 			}
24192fdbea25SAleksandr Guzovskiy 		}
24202fdbea25SAleksandr Guzovskiy 
24212fdbea25SAleksandr Guzovskiy 		/*
24222fdbea25SAleksandr Guzovskiy 		 * Get a tx for the mods to both packobj and bigobj.
24232fdbea25SAleksandr Guzovskiy 		 */
24242fdbea25SAleksandr Guzovskiy 		tx = dmu_tx_create(os);
24252fdbea25SAleksandr Guzovskiy 
24262fdbea25SAleksandr Guzovskiy 		dmu_tx_hold_write(tx, dd.dd_packobj, packoff, packsize);
24272fdbea25SAleksandr Guzovskiy 		dmu_tx_hold_write(tx, dd.dd_bigobj, bigoff, bigsize);
24282fdbea25SAleksandr Guzovskiy 
24292fdbea25SAleksandr Guzovskiy 		if (ztest_random(100) == 0) {
24302fdbea25SAleksandr Guzovskiy 			error = -1;
24312fdbea25SAleksandr Guzovskiy 		} else {
24322fdbea25SAleksandr Guzovskiy 			error = dmu_tx_assign(tx, TXG_WAIT);
24332fdbea25SAleksandr Guzovskiy 		}
24342fdbea25SAleksandr Guzovskiy 
24352fdbea25SAleksandr Guzovskiy 		if (error) {
24362fdbea25SAleksandr Guzovskiy 			if (error != -1) {
24372fdbea25SAleksandr Guzovskiy 				ztest_record_enospc("dmu r/w range");
24382fdbea25SAleksandr Guzovskiy 			}
24392fdbea25SAleksandr Guzovskiy 			dmu_tx_abort(tx);
24402fdbea25SAleksandr Guzovskiy 			umem_free(packbuf, packsize);
24412fdbea25SAleksandr Guzovskiy 			umem_free(bigbuf, bigsize);
24422fdbea25SAleksandr Guzovskiy 			for (j = 0; j < s; j++) {
24432fdbea25SAleksandr Guzovskiy 				if (i != 5) {
24442fdbea25SAleksandr Guzovskiy 					dmu_return_arcbuf(bigbuf_arcbufs[j]);
24452fdbea25SAleksandr Guzovskiy 				} else {
24462fdbea25SAleksandr Guzovskiy 					dmu_return_arcbuf(
24472fdbea25SAleksandr Guzovskiy 					    bigbuf_arcbufs[2 * j]);
24482fdbea25SAleksandr Guzovskiy 					dmu_return_arcbuf(
24492fdbea25SAleksandr Guzovskiy 					    bigbuf_arcbufs[2 * j + 1]);
24502fdbea25SAleksandr Guzovskiy 				}
24512fdbea25SAleksandr Guzovskiy 			}
24522fdbea25SAleksandr Guzovskiy 			umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
24532fdbea25SAleksandr Guzovskiy 			dmu_buf_rele(bonus_db, FTAG);
24542fdbea25SAleksandr Guzovskiy 			return;
24552fdbea25SAleksandr Guzovskiy 		}
24562fdbea25SAleksandr Guzovskiy 
24572fdbea25SAleksandr Guzovskiy 		txg = dmu_tx_get_txg(tx);
24582fdbea25SAleksandr Guzovskiy 
24592fdbea25SAleksandr Guzovskiy 		/*
24602fdbea25SAleksandr Guzovskiy 		 * 50% of the time don't read objects in the 1st iteration to
24612fdbea25SAleksandr Guzovskiy 		 * test dmu_assign_arcbuf() for the case when there're no
24622fdbea25SAleksandr Guzovskiy 		 * existing dbufs for the specified offsets.
24632fdbea25SAleksandr Guzovskiy 		 */
24642fdbea25SAleksandr Guzovskiy 		if (i != 0 || ztest_random(2) != 0) {
24652fdbea25SAleksandr Guzovskiy 			error = dmu_read(os, dd.dd_packobj, packoff,
24667bfdf011SNeil Perrin 			    packsize, packbuf, DMU_READ_PREFETCH);
24672fdbea25SAleksandr Guzovskiy 			ASSERT3U(error, ==, 0);
24682fdbea25SAleksandr Guzovskiy 			error = dmu_read(os, dd.dd_bigobj, bigoff, bigsize,
24697bfdf011SNeil Perrin 			    bigbuf, DMU_READ_PREFETCH);
24702fdbea25SAleksandr Guzovskiy 			ASSERT3U(error, ==, 0);
24712fdbea25SAleksandr Guzovskiy 		}
24722fdbea25SAleksandr Guzovskiy 		compare_and_update_pbbufs(s, packbuf, bigbuf, bigsize,
24732fdbea25SAleksandr Guzovskiy 		    n, dd, txg);
24742fdbea25SAleksandr Guzovskiy 
24752fdbea25SAleksandr Guzovskiy 		/*
24762fdbea25SAleksandr Guzovskiy 		 * We've verified all the old bufwads, and made new ones.
24772fdbea25SAleksandr Guzovskiy 		 * Now write them out.
24782fdbea25SAleksandr Guzovskiy 		 */
24792fdbea25SAleksandr Guzovskiy 		dmu_write(os, dd.dd_packobj, packoff, packsize, packbuf, tx);
24802fdbea25SAleksandr Guzovskiy 		if (zopt_verbose >= 6) {
24812fdbea25SAleksandr Guzovskiy 			(void) printf("writing offset %llx size %llx"
24822fdbea25SAleksandr Guzovskiy 			    " txg %llx\n",
24832fdbea25SAleksandr Guzovskiy 			    (u_longlong_t)bigoff,
24842fdbea25SAleksandr Guzovskiy 			    (u_longlong_t)bigsize,
24852fdbea25SAleksandr Guzovskiy 			    (u_longlong_t)txg);
24862fdbea25SAleksandr Guzovskiy 		}
24872fdbea25SAleksandr Guzovskiy 		for (off = bigoff, j = 0; j < s; j++, off += dd.dd_chunk) {
24882fdbea25SAleksandr Guzovskiy 			dmu_buf_t *dbt;
24892fdbea25SAleksandr Guzovskiy 			if (i != 5) {
24902fdbea25SAleksandr Guzovskiy 				bcopy((caddr_t)bigbuf + (off - bigoff),
24912fdbea25SAleksandr Guzovskiy 				    bigbuf_arcbufs[j]->b_data, dd.dd_chunk);
24922fdbea25SAleksandr Guzovskiy 			} else {
24932fdbea25SAleksandr Guzovskiy 				bcopy((caddr_t)bigbuf + (off - bigoff),
24942fdbea25SAleksandr Guzovskiy 				    bigbuf_arcbufs[2 * j]->b_data,
24952fdbea25SAleksandr Guzovskiy 				    dd.dd_chunk / 2);
24962fdbea25SAleksandr Guzovskiy 				bcopy((caddr_t)bigbuf + (off - bigoff) +
24972fdbea25SAleksandr Guzovskiy 				    dd.dd_chunk / 2,
24982fdbea25SAleksandr Guzovskiy 				    bigbuf_arcbufs[2 * j + 1]->b_data,
24992fdbea25SAleksandr Guzovskiy 				    dd.dd_chunk / 2);
25002fdbea25SAleksandr Guzovskiy 			}
25012fdbea25SAleksandr Guzovskiy 
25022fdbea25SAleksandr Guzovskiy 			if (i == 1) {
25032fdbea25SAleksandr Guzovskiy 				VERIFY(dmu_buf_hold(os, dd.dd_bigobj, off,
25042fdbea25SAleksandr Guzovskiy 				    FTAG, &dbt) == 0);
25052fdbea25SAleksandr Guzovskiy 			}
25062fdbea25SAleksandr Guzovskiy 			if (i != 5) {
25072fdbea25SAleksandr Guzovskiy 				dmu_assign_arcbuf(bonus_db, off,
25082fdbea25SAleksandr Guzovskiy 				    bigbuf_arcbufs[j], tx);
25092fdbea25SAleksandr Guzovskiy 			} else {
25102fdbea25SAleksandr Guzovskiy 				dmu_assign_arcbuf(bonus_db, off,
25112fdbea25SAleksandr Guzovskiy 				    bigbuf_arcbufs[2 * j], tx);
25122fdbea25SAleksandr Guzovskiy 				dmu_assign_arcbuf(bonus_db,
25132fdbea25SAleksandr Guzovskiy 				    off + dd.dd_chunk / 2,
25142fdbea25SAleksandr Guzovskiy 				    bigbuf_arcbufs[2 * j + 1], tx);
25152fdbea25SAleksandr Guzovskiy 			}
25162fdbea25SAleksandr Guzovskiy 			if (i == 1) {
25172fdbea25SAleksandr Guzovskiy 				dmu_buf_rele(dbt, FTAG);
25182fdbea25SAleksandr Guzovskiy 			}
25192fdbea25SAleksandr Guzovskiy 		}
25202fdbea25SAleksandr Guzovskiy 		dmu_tx_commit(tx);
25212fdbea25SAleksandr Guzovskiy 
25222fdbea25SAleksandr Guzovskiy 		/*
25232fdbea25SAleksandr Guzovskiy 		 * Sanity check the stuff we just wrote.
25242fdbea25SAleksandr Guzovskiy 		 */
25252fdbea25SAleksandr Guzovskiy 		{
25262fdbea25SAleksandr Guzovskiy 			void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
25272fdbea25SAleksandr Guzovskiy 			void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
25282fdbea25SAleksandr Guzovskiy 
25292fdbea25SAleksandr Guzovskiy 			VERIFY(0 == dmu_read(os, dd.dd_packobj, packoff,
25307bfdf011SNeil Perrin 			    packsize, packcheck, DMU_READ_PREFETCH));
25312fdbea25SAleksandr Guzovskiy 			VERIFY(0 == dmu_read(os, dd.dd_bigobj, bigoff,
25327bfdf011SNeil Perrin 			    bigsize, bigcheck, DMU_READ_PREFETCH));
25332fdbea25SAleksandr Guzovskiy 
25342fdbea25SAleksandr Guzovskiy 			ASSERT(bcmp(packbuf, packcheck, packsize) == 0);
25352fdbea25SAleksandr Guzovskiy 			ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0);
25362fdbea25SAleksandr Guzovskiy 
25372fdbea25SAleksandr Guzovskiy 			umem_free(packcheck, packsize);
25382fdbea25SAleksandr Guzovskiy 			umem_free(bigcheck, bigsize);
25392fdbea25SAleksandr Guzovskiy 		}
25402fdbea25SAleksandr Guzovskiy 		if (i == 2) {
25412fdbea25SAleksandr Guzovskiy 			txg_wait_open(dmu_objset_pool(os), 0);
25422fdbea25SAleksandr Guzovskiy 		} else if (i == 3) {
25432fdbea25SAleksandr Guzovskiy 			txg_wait_synced(dmu_objset_pool(os), 0);
25442fdbea25SAleksandr Guzovskiy 		}
25452fdbea25SAleksandr Guzovskiy 	}
25462fdbea25SAleksandr Guzovskiy 
25472fdbea25SAleksandr Guzovskiy 	dmu_buf_rele(bonus_db, FTAG);
25482fdbea25SAleksandr Guzovskiy 	umem_free(packbuf, packsize);
25492fdbea25SAleksandr Guzovskiy 	umem_free(bigbuf, bigsize);
25502fdbea25SAleksandr Guzovskiy 	umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
25512fdbea25SAleksandr Guzovskiy }
25522fdbea25SAleksandr Guzovskiy 
25534d31c452Smaybee void
2554e05725b1Sbonwick ztest_dmu_check_future_leak(ztest_args_t *za)
25554d31c452Smaybee {
2556e05725b1Sbonwick 	objset_t *os = za->za_os;
25574d31c452Smaybee 	dmu_buf_t *db;
2558e05725b1Sbonwick 	ztest_block_tag_t *bt;
2559e05725b1Sbonwick 	dmu_object_info_t *doi = &za->za_doi;
25604d31c452Smaybee 
25614d31c452Smaybee 	/*
25624d31c452Smaybee 	 * Make sure that, if there is a write record in the bonus buffer
25634d31c452Smaybee 	 * of the ZTEST_DIROBJ, that the txg for this record is <= the
25644d31c452Smaybee 	 * last synced txg of the pool.
25654d31c452Smaybee 	 */
2566e05725b1Sbonwick 	VERIFY(dmu_bonus_hold(os, ZTEST_DIROBJ, FTAG, &db) == 0);
2567e05725b1Sbonwick 	za->za_dbuf = db;
2568e05725b1Sbonwick 	VERIFY(dmu_object_info(os, ZTEST_DIROBJ, doi) == 0);
2569e05725b1Sbonwick 	ASSERT3U(doi->doi_bonus_size, >=, sizeof (*bt));
2570e05725b1Sbonwick 	ASSERT3U(doi->doi_bonus_size, <=, db->db_size);
2571e05725b1Sbonwick 	ASSERT3U(doi->doi_bonus_size % sizeof (*bt), ==, 0);
2572e05725b1Sbonwick 	bt = (void *)((char *)db->db_data + doi->doi_bonus_size - sizeof (*bt));
2573e05725b1Sbonwick 	if (bt->bt_objset != 0) {
2574e05725b1Sbonwick 		ASSERT3U(bt->bt_objset, ==, dmu_objset_id(os));
2575e05725b1Sbonwick 		ASSERT3U(bt->bt_object, ==, ZTEST_DIROBJ);
2576e05725b1Sbonwick 		ASSERT3U(bt->bt_offset, ==, -1ULL);
2577e05725b1Sbonwick 		ASSERT3U(bt->bt_txg, <, spa_first_txg(za->za_spa));
25784d31c452Smaybee 	}
25794d31c452Smaybee 	dmu_buf_rele(db, FTAG);
2580e05725b1Sbonwick 	za->za_dbuf = NULL;
25814d31c452Smaybee }
25824d31c452Smaybee 
2583fa9e4066Sahrens void
2584fa9e4066Sahrens ztest_dmu_write_parallel(ztest_args_t *za)
2585fa9e4066Sahrens {
2586fa9e4066Sahrens 	objset_t *os = za->za_os;
2587e05725b1Sbonwick 	ztest_block_tag_t *rbt = &za->za_rbt;
2588e05725b1Sbonwick 	ztest_block_tag_t *wbt = &za->za_wbt;
2589e05725b1Sbonwick 	const size_t btsize = sizeof (ztest_block_tag_t);
2590fa9e4066Sahrens 	dmu_buf_t *db;
2591e05725b1Sbonwick 	int b, error;
2592e05725b1Sbonwick 	int bs = ZTEST_DIROBJ_BLOCKSIZE;
2593e05725b1Sbonwick 	int do_free = 0;
2594f4a72450SJeff Bonwick 	uint64_t off, txg, txg_how;
2595fa9e4066Sahrens 	mutex_t *lp;
2596fa9e4066Sahrens 	char osname[MAXNAMELEN];
2597fa9e4066Sahrens 	char iobuf[SPA_MAXBLOCKSIZE];
2598e05725b1Sbonwick 	blkptr_t blk = { 0 };
2599e05725b1Sbonwick 	uint64_t blkoff;
2600e05725b1Sbonwick 	zbookmark_t zb;
2601e05725b1Sbonwick 	dmu_tx_t *tx = dmu_tx_create(os);
26022fdbea25SAleksandr Guzovskiy 	dmu_buf_t *bonus_db;
26032fdbea25SAleksandr Guzovskiy 	arc_buf_t *abuf = NULL;
2604fa9e4066Sahrens 
2605fa9e4066Sahrens 	dmu_objset_name(os, osname);
2606fa9e4066Sahrens 
2607fa9e4066Sahrens 	/*
2608fa9e4066Sahrens 	 * Have multiple threads write to large offsets in ZTEST_DIROBJ
2609fa9e4066Sahrens 	 * to verify that having multiple threads writing to the same object
2610fa9e4066Sahrens 	 * in parallel doesn't cause any trouble.
2611fa9e4066Sahrens 	 */
2612e05725b1Sbonwick 	if (ztest_random(4) == 0) {
2613e05725b1Sbonwick 		/*
2614e05725b1Sbonwick 		 * Do the bonus buffer instead of a regular block.
2615e05725b1Sbonwick 		 * We need a lock to serialize resize vs. others,
2616e05725b1Sbonwick 		 * so we hash on the objset ID.
2617e05725b1Sbonwick 		 */
2618e05725b1Sbonwick 		b = dmu_objset_id(os) % ZTEST_SYNC_LOCKS;
2619e05725b1Sbonwick 		off = -1ULL;
2620e05725b1Sbonwick 		dmu_tx_hold_bonus(tx, ZTEST_DIROBJ);
2621e05725b1Sbonwick 	} else {
2622fa9e4066Sahrens 		b = ztest_random(ZTEST_SYNC_LOCKS);
2623e05725b1Sbonwick 		off = za->za_diroff_shared + (b << SPA_MAXBLOCKSHIFT);
2624fa9e4066Sahrens 		if (ztest_random(4) == 0) {
2625e05725b1Sbonwick 			do_free = 1;
2626fa9e4066Sahrens 			dmu_tx_hold_free(tx, ZTEST_DIROBJ, off, bs);
2627e05725b1Sbonwick 		} else {
2628fa9e4066Sahrens 			dmu_tx_hold_write(tx, ZTEST_DIROBJ, off, bs);
2629e05725b1Sbonwick 		}
2630e05725b1Sbonwick 	}
2631fa9e4066Sahrens 
26322fdbea25SAleksandr Guzovskiy 	if (off != -1ULL && P2PHASE(off, bs) == 0 && !do_free &&
26332fdbea25SAleksandr Guzovskiy 	    ztest_random(8) == 0) {
26342fdbea25SAleksandr Guzovskiy 		VERIFY(dmu_bonus_hold(os, ZTEST_DIROBJ, FTAG, &bonus_db) == 0);
26352fdbea25SAleksandr Guzovskiy 		abuf = dmu_request_arcbuf(bonus_db, bs);
26362fdbea25SAleksandr Guzovskiy 	}
26372fdbea25SAleksandr Guzovskiy 
2638e05725b1Sbonwick 	txg_how = ztest_random(2) == 0 ? TXG_WAIT : TXG_NOWAIT;
2639e05725b1Sbonwick 	error = dmu_tx_assign(tx, txg_how);
2640e05725b1Sbonwick 	if (error) {
2641e05725b1Sbonwick 		if (error == ERESTART) {
2642e05725b1Sbonwick 			ASSERT(txg_how == TXG_NOWAIT);
2643e05725b1Sbonwick 			dmu_tx_wait(tx);
2644e05725b1Sbonwick 		} else {
2645fa9e4066Sahrens 			ztest_record_enospc("dmu write parallel");
2646fa9e4066Sahrens 		}
2647e05725b1Sbonwick 		dmu_tx_abort(tx);
26482fdbea25SAleksandr Guzovskiy 		if (abuf != NULL) {
26492fdbea25SAleksandr Guzovskiy 			dmu_return_arcbuf(abuf);
26502fdbea25SAleksandr Guzovskiy 			dmu_buf_rele(bonus_db, FTAG);
26512fdbea25SAleksandr Guzovskiy 		}
2652e05725b1Sbonwick 		return;
2653e05725b1Sbonwick 	}
2654f4a72450SJeff Bonwick 	txg = dmu_tx_get_txg(tx);
2655fa9e4066Sahrens 
2656e05725b1Sbonwick 	lp = &ztest_shared->zs_sync_lock[b];
2657e05725b1Sbonwick 	(void) mutex_lock(lp);
2658e05725b1Sbonwick 
2659e05725b1Sbonwick 	wbt->bt_objset = dmu_objset_id(os);
2660e05725b1Sbonwick 	wbt->bt_object = ZTEST_DIROBJ;
2661e05725b1Sbonwick 	wbt->bt_offset = off;
2662f4a72450SJeff Bonwick 	wbt->bt_txg = txg;
2663e05725b1Sbonwick 	wbt->bt_thread = za->za_instance;
2664e05725b1Sbonwick 	wbt->bt_seq = ztest_shared->zs_seq[b]++;	/* protected by lp */
2665e05725b1Sbonwick 
2666f4a72450SJeff Bonwick 	/*
2667f4a72450SJeff Bonwick 	 * Occasionally, write an all-zero block to test the behavior
2668f4a72450SJeff Bonwick 	 * of blocks that compress into holes.
2669f4a72450SJeff Bonwick 	 */
2670f4a72450SJeff Bonwick 	if (off != -1ULL && ztest_random(8) == 0)
2671f4a72450SJeff Bonwick 		bzero(wbt, btsize);
2672f4a72450SJeff Bonwick 
2673e05725b1Sbonwick 	if (off == -1ULL) {
2674e05725b1Sbonwick 		dmu_object_info_t *doi = &za->za_doi;
2675e05725b1Sbonwick 		char *dboff;
2676e05725b1Sbonwick 
2677e05725b1Sbonwick 		VERIFY(dmu_bonus_hold(os, ZTEST_DIROBJ, FTAG, &db) == 0);
2678e05725b1Sbonwick 		za->za_dbuf = db;
2679e05725b1Sbonwick 		dmu_object_info_from_db(db, doi);
2680e05725b1Sbonwick 		ASSERT3U(doi->doi_bonus_size, <=, db->db_size);
2681e05725b1Sbonwick 		ASSERT3U(doi->doi_bonus_size, >=, btsize);
2682e05725b1Sbonwick 		ASSERT3U(doi->doi_bonus_size % btsize, ==, 0);
2683e05725b1Sbonwick 		dboff = (char *)db->db_data + doi->doi_bonus_size - btsize;
2684e05725b1Sbonwick 		bcopy(dboff, rbt, btsize);
2685e05725b1Sbonwick 		if (rbt->bt_objset != 0) {
2686e05725b1Sbonwick 			ASSERT3U(rbt->bt_objset, ==, wbt->bt_objset);
2687e05725b1Sbonwick 			ASSERT3U(rbt->bt_object, ==, wbt->bt_object);
2688e05725b1Sbonwick 			ASSERT3U(rbt->bt_offset, ==, wbt->bt_offset);
2689e05725b1Sbonwick 			ASSERT3U(rbt->bt_txg, <=, wbt->bt_txg);
2690fa9e4066Sahrens 		}
2691e05725b1Sbonwick 		if (ztest_random(10) == 0) {
2692e05725b1Sbonwick 			int newsize = (ztest_random(db->db_size /
2693e05725b1Sbonwick 			    btsize) + 1) * btsize;
2694e05725b1Sbonwick 
2695e05725b1Sbonwick 			ASSERT3U(newsize, >=, btsize);
2696e05725b1Sbonwick 			ASSERT3U(newsize, <=, db->db_size);
2697e05725b1Sbonwick 			VERIFY3U(dmu_set_bonus(db, newsize, tx), ==, 0);
2698e05725b1Sbonwick 			dboff = (char *)db->db_data + newsize - btsize;
2699fa9e4066Sahrens 		}
2700e05725b1Sbonwick 		dmu_buf_will_dirty(db, tx);
2701e05725b1Sbonwick 		bcopy(wbt, dboff, btsize);
2702e05725b1Sbonwick 		dmu_buf_rele(db, FTAG);
2703e05725b1Sbonwick 		za->za_dbuf = NULL;
2704e05725b1Sbonwick 	} else if (do_free) {
2705e05725b1Sbonwick 		VERIFY(dmu_free_range(os, ZTEST_DIROBJ, off, bs, tx) == 0);
27062fdbea25SAleksandr Guzovskiy 	} else if (abuf == NULL) {
2707e05725b1Sbonwick 		dmu_write(os, ZTEST_DIROBJ, off, btsize, wbt, tx);
27082fdbea25SAleksandr Guzovskiy 	} else {
27092fdbea25SAleksandr Guzovskiy 		bcopy(wbt, abuf->b_data, btsize);
27102fdbea25SAleksandr Guzovskiy 		dmu_assign_arcbuf(bonus_db, off, abuf, tx);
27112fdbea25SAleksandr Guzovskiy 		dmu_buf_rele(bonus_db, FTAG);
2712e05725b1Sbonwick 	}
2713e05725b1Sbonwick 
2714e05725b1Sbonwick 	(void) mutex_unlock(lp);
2715e05725b1Sbonwick 
2716e05725b1Sbonwick 	if (ztest_random(1000) == 0)
2717e05725b1Sbonwick 		(void) poll(NULL, 0, 1); /* open dn_notxholds window */
2718e05725b1Sbonwick 
2719e05725b1Sbonwick 	dmu_tx_commit(tx);
2720e05725b1Sbonwick 
2721e05725b1Sbonwick 	if (ztest_random(10000) == 0)
2722f4a72450SJeff Bonwick 		txg_wait_synced(dmu_objset_pool(os), txg);
2723fa9e4066Sahrens 
2724e14bb325SJeff Bonwick 	if (off == -1ULL || do_free)
2725e05725b1Sbonwick 		return;
2726fa9e4066Sahrens 
2727e05725b1Sbonwick 	if (ztest_random(2) != 0)
2728e05725b1Sbonwick 		return;
2729fa9e4066Sahrens 
2730e05725b1Sbonwick 	/*
2731e05725b1Sbonwick 	 * dmu_sync() the block we just wrote.
2732e05725b1Sbonwick 	 */
2733e05725b1Sbonwick 	(void) mutex_lock(lp);
2734fa9e4066Sahrens 
2735e05725b1Sbonwick 	blkoff = P2ALIGN_TYPED(off, bs, uint64_t);
2736e05725b1Sbonwick 	error = dmu_buf_hold(os, ZTEST_DIROBJ, blkoff, FTAG, &db);
2737e05725b1Sbonwick 	za->za_dbuf = db;
2738e05725b1Sbonwick 	if (error) {
2739fa9e4066Sahrens 		(void) mutex_unlock(lp);
2740e05725b1Sbonwick 		return;
2741e05725b1Sbonwick 	}
2742e05725b1Sbonwick 	blkoff = off - blkoff;
2743f4a72450SJeff Bonwick 	error = dmu_sync(NULL, db, &blk, txg, NULL, NULL);
2744e05725b1Sbonwick 	dmu_buf_rele(db, FTAG);
2745e05725b1Sbonwick 	za->za_dbuf = NULL;
2746fa9e4066Sahrens 
27472fdbea25SAleksandr Guzovskiy 	if (error) {
27482fdbea25SAleksandr Guzovskiy 		(void) mutex_unlock(lp);
2749e05725b1Sbonwick 		return;
27502fdbea25SAleksandr Guzovskiy 	}
2751fa9e4066Sahrens 
27522fdbea25SAleksandr Guzovskiy 	if (blk.blk_birth == 0)	{	/* concurrent free */
27532fdbea25SAleksandr Guzovskiy 		(void) mutex_unlock(lp);
2754e05725b1Sbonwick 		return;
27552fdbea25SAleksandr Guzovskiy 	}
2756fa9e4066Sahrens 
2757e05725b1Sbonwick 	txg_suspend(dmu_objset_pool(os));
2758fa9e4066Sahrens 
27592fdbea25SAleksandr Guzovskiy 	(void) mutex_unlock(lp);
27602fdbea25SAleksandr Guzovskiy 
2761e05725b1Sbonwick 	ASSERT(blk.blk_fill == 1);
2762e05725b1Sbonwick 	ASSERT3U(BP_GET_TYPE(&blk), ==, DMU_OT_UINT64_OTHER);
2763e05725b1Sbonwick 	ASSERT3U(BP_GET_LEVEL(&blk), ==, 0);
2764e05725b1Sbonwick 	ASSERT3U(BP_GET_LSIZE(&blk), ==, bs);
2765fa9e4066Sahrens 
2766e05725b1Sbonwick 	/*
2767e05725b1Sbonwick 	 * Read the block that dmu_sync() returned to make sure its contents
2768e05725b1Sbonwick 	 * match what we wrote.  We do this while still txg_suspend()ed
2769e05725b1Sbonwick 	 * to ensure that the block can't be reused before we read it.
2770e05725b1Sbonwick 	 */
2771e05725b1Sbonwick 	zb.zb_objset = dmu_objset_id(os);
2772e05725b1Sbonwick 	zb.zb_object = ZTEST_DIROBJ;
2773e05725b1Sbonwick 	zb.zb_level = 0;
2774e05725b1Sbonwick 	zb.zb_blkid = off / bs;
2775e05725b1Sbonwick 	error = zio_wait(zio_read(NULL, za->za_spa, &blk, iobuf, bs,
2776e05725b1Sbonwick 	    NULL, NULL, ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_MUSTSUCCEED, &zb));
2777e05725b1Sbonwick 	ASSERT3U(error, ==, 0);
2778fa9e4066Sahrens 
2779e05725b1Sbonwick 	txg_resume(dmu_objset_pool(os));
2780fa9e4066Sahrens 
2781e05725b1Sbonwick 	bcopy(&iobuf[blkoff], rbt, btsize);
2782fa9e4066Sahrens 
2783e05725b1Sbonwick 	if (rbt->bt_objset == 0)		/* concurrent free */
2784e05725b1Sbonwick 		return;
27850e34b6a7Sbonwick 
2786f4a72450SJeff Bonwick 	if (wbt->bt_objset == 0)		/* all-zero overwrite */
2787f4a72450SJeff Bonwick 		return;
2788f4a72450SJeff Bonwick 
2789e05725b1Sbonwick 	ASSERT3U(rbt->bt_objset, ==, wbt->bt_objset);
2790e05725b1Sbonwick 	ASSERT3U(rbt->bt_object, ==, wbt->bt_object);
2791e05725b1Sbonwick 	ASSERT3U(rbt->bt_offset, ==, wbt->bt_offset);
2792fa9e4066Sahrens 
2793e05725b1Sbonwick 	/*
2794e05725b1Sbonwick 	 * The semantic of dmu_sync() is that we always push the most recent
2795e05725b1Sbonwick 	 * version of the data, so in the face of concurrent updates we may
2796e05725b1Sbonwick 	 * see a newer version of the block.  That's OK.
2797e05725b1Sbonwick 	 */
2798e05725b1Sbonwick 	ASSERT3U(rbt->bt_txg, >=, wbt->bt_txg);
2799e05725b1Sbonwick 	if (rbt->bt_thread == wbt->bt_thread)
2800e05725b1Sbonwick 		ASSERT3U(rbt->bt_seq, ==, wbt->bt_seq);
2801e05725b1Sbonwick 	else
2802e05725b1Sbonwick 		ASSERT3U(rbt->bt_seq, >, wbt->bt_seq);
2803fa9e4066Sahrens }
2804fa9e4066Sahrens 
2805fa9e4066Sahrens /*
2806fa9e4066Sahrens  * Verify that zap_{create,destroy,add,remove,update} work as expected.
2807fa9e4066Sahrens  */
2808fa9e4066Sahrens #define	ZTEST_ZAP_MIN_INTS	1
2809fa9e4066Sahrens #define	ZTEST_ZAP_MAX_INTS	4
2810fa9e4066Sahrens #define	ZTEST_ZAP_MAX_PROPS	1000
2811fa9e4066Sahrens 
2812fa9e4066Sahrens void
2813fa9e4066Sahrens ztest_zap(ztest_args_t *za)
2814fa9e4066Sahrens {
2815fa9e4066Sahrens 	objset_t *os = za->za_os;
2816fa9e4066Sahrens 	uint64_t object;
2817fa9e4066Sahrens 	uint64_t txg, last_txg;
2818fa9e4066Sahrens 	uint64_t value[ZTEST_ZAP_MAX_INTS];
2819fa9e4066Sahrens 	uint64_t zl_ints, zl_intsize, prop;
2820fa9e4066Sahrens 	int i, ints;
2821fa9e4066Sahrens 	dmu_tx_t *tx;
2822fa9e4066Sahrens 	char propname[100], txgname[100];
2823fa9e4066Sahrens 	int error;
2824fa9e4066Sahrens 	char osname[MAXNAMELEN];
2825fa9e4066Sahrens 	char *hc[2] = { "s.acl.h", ".s.open.h.hyLZlg" };
2826fa9e4066Sahrens 
2827fa9e4066Sahrens 	dmu_objset_name(os, osname);
2828fa9e4066Sahrens 
2829fa9e4066Sahrens 	/*
2830fa9e4066Sahrens 	 * Create a new object if necessary, and record it in the directory.
2831fa9e4066Sahrens 	 */
2832ea8dc4b6Seschrock 	VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
28337bfdf011SNeil Perrin 	    sizeof (uint64_t), &object, DMU_READ_PREFETCH));
2834fa9e4066Sahrens 
2835fa9e4066Sahrens 	if (object == 0) {
2836fa9e4066Sahrens 		tx = dmu_tx_create(os);
2837fa9e4066Sahrens 		dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff,
2838fa9e4066Sahrens 		    sizeof (uint64_t));
2839ea8dc4b6Seschrock 		dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL);
2840fa9e4066Sahrens 		error = dmu_tx_assign(tx, TXG_WAIT);
2841fa9e4066Sahrens 		if (error) {
2842fa9e4066Sahrens 			ztest_record_enospc("create zap test obj");
2843fa9e4066Sahrens 			dmu_tx_abort(tx);
2844fa9e4066Sahrens 			return;
2845fa9e4066Sahrens 		}
2846fa9e4066Sahrens 		object = zap_create(os, DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx);
2847fa9e4066Sahrens 		if (error) {
2848fa9e4066Sahrens 			fatal(0, "zap_create('%s', %llu) = %d",
2849fa9e4066Sahrens 			    osname, object, error);
2850fa9e4066Sahrens 		}
2851fa9e4066Sahrens 		ASSERT(object != 0);
2852fa9e4066Sahrens 		dmu_write(os, ZTEST_DIROBJ, za->za_diroff,
2853fa9e4066Sahrens 		    sizeof (uint64_t), &object, tx);
2854fa9e4066Sahrens 		/*
2855fa9e4066Sahrens 		 * Generate a known hash collision, and verify that
2856fa9e4066Sahrens 		 * we can lookup and remove both entries.
2857fa9e4066Sahrens 		 */
2858fa9e4066Sahrens 		for (i = 0; i < 2; i++) {
2859fa9e4066Sahrens 			value[i] = i;
2860fa9e4066Sahrens 			error = zap_add(os, object, hc[i], sizeof (uint64_t),
2861fa9e4066Sahrens 			    1, &value[i], tx);
2862fa9e4066Sahrens 			ASSERT3U(error, ==, 0);
2863fa9e4066Sahrens 		}
2864fa9e4066Sahrens 		for (i = 0; i < 2; i++) {
2865fa9e4066Sahrens 			error = zap_add(os, object, hc[i], sizeof (uint64_t),
2866fa9e4066Sahrens 			    1, &value[i], tx);
2867fa9e4066Sahrens 			ASSERT3U(error, ==, EEXIST);
2868fa9e4066Sahrens 			error = zap_length(os, object, hc[i],
2869fa9e4066Sahrens 			    &zl_intsize, &zl_ints);
2870fa9e4066Sahrens 			ASSERT3U(error, ==, 0);
2871fa9e4066Sahrens 			ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
2872fa9e4066Sahrens 			ASSERT3U(zl_ints, ==, 1);
2873fa9e4066Sahrens 		}
2874fa9e4066Sahrens 		for (i = 0; i < 2; i++) {
2875fa9e4066Sahrens 			error = zap_remove(os, object, hc[i], tx);
2876fa9e4066Sahrens 			ASSERT3U(error, ==, 0);
2877fa9e4066Sahrens 		}
2878fa9e4066Sahrens 
2879fa9e4066Sahrens 		dmu_tx_commit(tx);
2880fa9e4066Sahrens 	}
2881fa9e4066Sahrens 
2882fa9e4066Sahrens 	ints = MAX(ZTEST_ZAP_MIN_INTS, object % ZTEST_ZAP_MAX_INTS);
2883fa9e4066Sahrens 
2884e05725b1Sbonwick 	prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
2885e05725b1Sbonwick 	(void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
2886e05725b1Sbonwick 	(void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
2887e05725b1Sbonwick 	bzero(value, sizeof (value));
2888e05725b1Sbonwick 	last_txg = 0;
2889fa9e4066Sahrens 
2890e05725b1Sbonwick 	/*
2891e05725b1Sbonwick 	 * If these zap entries already exist, validate their contents.
2892e05725b1Sbonwick 	 */
2893e05725b1Sbonwick 	error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
2894e05725b1Sbonwick 	if (error == 0) {
2895e05725b1Sbonwick 		ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
2896e05725b1Sbonwick 		ASSERT3U(zl_ints, ==, 1);
2897fa9e4066Sahrens 
2898e05725b1Sbonwick 		VERIFY(zap_lookup(os, object, txgname, zl_intsize,
2899e05725b1Sbonwick 		    zl_ints, &last_txg) == 0);
2900fa9e4066Sahrens 
2901e05725b1Sbonwick 		VERIFY(zap_length(os, object, propname, &zl_intsize,
2902e05725b1Sbonwick 		    &zl_ints) == 0);
2903fa9e4066Sahrens 
2904e05725b1Sbonwick 		ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
2905e05725b1Sbonwick 		ASSERT3U(zl_ints, ==, ints);
2906fa9e4066Sahrens 
2907e05725b1Sbonwick 		VERIFY(zap_lookup(os, object, propname, zl_intsize,
2908e05725b1Sbonwick 		    zl_ints, value) == 0);
2909fa9e4066Sahrens 
2910e05725b1Sbonwick 		for (i = 0; i < ints; i++) {
2911e05725b1Sbonwick 			ASSERT3U(value[i], ==, last_txg + object + i);
2912fa9e4066Sahrens 		}
2913e05725b1Sbonwick 	} else {
2914e05725b1Sbonwick 		ASSERT3U(error, ==, ENOENT);
2915e05725b1Sbonwick 	}
2916fa9e4066Sahrens 
2917e05725b1Sbonwick 	/*
2918e05725b1Sbonwick 	 * Atomically update two entries in our zap object.
2919e05725b1Sbonwick 	 * The first is named txg_%llu, and contains the txg
2920e05725b1Sbonwick 	 * in which the property was last updated.  The second
2921e05725b1Sbonwick 	 * is named prop_%llu, and the nth element of its value
2922e05725b1Sbonwick 	 * should be txg + object + n.
2923e05725b1Sbonwick 	 */
2924e05725b1Sbonwick 	tx = dmu_tx_create(os);
2925e05725b1Sbonwick 	dmu_tx_hold_zap(tx, object, TRUE, NULL);
2926e05725b1Sbonwick 	error = dmu_tx_assign(tx, TXG_WAIT);
2927e05725b1Sbonwick 	if (error) {
2928e05725b1Sbonwick 		ztest_record_enospc("create zap entry");
2929e05725b1Sbonwick 		dmu_tx_abort(tx);
2930e05725b1Sbonwick 		return;
2931e05725b1Sbonwick 	}
2932e05725b1Sbonwick 	txg = dmu_tx_get_txg(tx);
2933fa9e4066Sahrens 
2934e05725b1Sbonwick 	if (last_txg > txg)
2935e05725b1Sbonwick 		fatal(0, "zap future leak: old %llu new %llu", last_txg, txg);
2936fa9e4066Sahrens 
2937e05725b1Sbonwick 	for (i = 0; i < ints; i++)
2938e05725b1Sbonwick 		value[i] = txg + object + i;
2939fa9e4066Sahrens 
2940e05725b1Sbonwick 	error = zap_update(os, object, txgname, sizeof (uint64_t), 1, &txg, tx);
2941e05725b1Sbonwick 	if (error)
2942e05725b1Sbonwick 		fatal(0, "zap_update('%s', %llu, '%s') = %d",
2943e05725b1Sbonwick 		    osname, object, txgname, error);
2944fa9e4066Sahrens 
2945e05725b1Sbonwick 	error = zap_update(os, object, propname, sizeof (uint64_t),
2946e05725b1Sbonwick 	    ints, value, tx);
2947e05725b1Sbonwick 	if (error)
2948e05725b1Sbonwick 		fatal(0, "zap_update('%s', %llu, '%s') = %d",
2949e05725b1Sbonwick 		    osname, object, propname, error);
2950fa9e4066Sahrens 
2951e05725b1Sbonwick 	dmu_tx_commit(tx);
2952fa9e4066Sahrens 
2953e05725b1Sbonwick 	/*
2954e05725b1Sbonwick 	 * Remove a random pair of entries.
2955e05725b1Sbonwick 	 */
2956e05725b1Sbonwick 	prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
2957e05725b1Sbonwick 	(void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
2958e05725b1Sbonwick 	(void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
2959fa9e4066Sahrens 
2960e05725b1Sbonwick 	error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
2961fa9e4066Sahrens 
2962e05725b1Sbonwick 	if (error == ENOENT)
2963e05725b1Sbonwick 		return;
2964fa9e4066Sahrens 
2965e05725b1Sbonwick 	ASSERT3U(error, ==, 0);
2966fa9e4066Sahrens 
2967e05725b1Sbonwick 	tx = dmu_tx_create(os);
2968e05725b1Sbonwick 	dmu_tx_hold_zap(tx, object, TRUE, NULL);
2969e05725b1Sbonwick 	error = dmu_tx_assign(tx, TXG_WAIT);
2970e05725b1Sbonwick 	if (error) {
2971e05725b1Sbonwick 		ztest_record_enospc("remove zap entry");
2972e05725b1Sbonwick 		dmu_tx_abort(tx);
2973e05725b1Sbonwick 		return;
2974e05725b1Sbonwick 	}
2975e05725b1Sbonwick 	error = zap_remove(os, object, txgname, tx);
2976e05725b1Sbonwick 	if (error)
2977e05725b1Sbonwick 		fatal(0, "zap_remove('%s', %llu, '%s') = %d",
2978e05725b1Sbonwick 		    osname, object, txgname, error);
2979fa9e4066Sahrens 
2980e05725b1Sbonwick 	error = zap_remove(os, object, propname, tx);
2981e05725b1Sbonwick 	if (error)
2982e05725b1Sbonwick 		fatal(0, "zap_remove('%s', %llu, '%s') = %d",
2983e05725b1Sbonwick 		    osname, object, propname, error);
2984fa9e4066Sahrens 
2985e05725b1Sbonwick 	dmu_tx_commit(tx);
2986fa9e4066Sahrens 
2987fa9e4066Sahrens 	/*
2988fa9e4066Sahrens 	 * Once in a while, destroy the object.
2989fa9e4066Sahrens 	 */
2990e05725b1Sbonwick 	if (ztest_random(1000) != 0)
2991fa9e4066Sahrens 		return;
2992fa9e4066Sahrens 
2993fa9e4066Sahrens 	tx = dmu_tx_create(os);
2994fa9e4066Sahrens 	dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t));
2995fa9e4066Sahrens 	dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
2996fa9e4066Sahrens 	error = dmu_tx_assign(tx, TXG_WAIT);
2997fa9e4066Sahrens 	if (error) {
2998fa9e4066Sahrens 		ztest_record_enospc("destroy zap object");
299912a2833aSSanjeev Bagewadi 		dmu_tx_abort(tx);
300012a2833aSSanjeev Bagewadi 		return;
300112a2833aSSanjeev Bagewadi 	}
300212a2833aSSanjeev Bagewadi 	error = zap_destroy(os, object, tx);
300312a2833aSSanjeev Bagewadi 	if (error)
300412a2833aSSanjeev Bagewadi 		fatal(0, "zap_destroy('%s', %llu) = %d",
300512a2833aSSanjeev Bagewadi 		    osname, object, error);
300612a2833aSSanjeev Bagewadi 	object = 0;
300712a2833aSSanjeev Bagewadi 	dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t),
300812a2833aSSanjeev Bagewadi 	    &object, tx);
300912a2833aSSanjeev Bagewadi 	dmu_tx_commit(tx);
301012a2833aSSanjeev Bagewadi }
301112a2833aSSanjeev Bagewadi 
301212a2833aSSanjeev Bagewadi /*
301312a2833aSSanjeev Bagewadi  * Testcase to test the upgrading of a microzap to fatzap.
301412a2833aSSanjeev Bagewadi  */
301512a2833aSSanjeev Bagewadi void
301612a2833aSSanjeev Bagewadi ztest_fzap(ztest_args_t *za)
301712a2833aSSanjeev Bagewadi {
301812a2833aSSanjeev Bagewadi 	objset_t *os = za->za_os;
301912a2833aSSanjeev Bagewadi 	uint64_t object;
302012a2833aSSanjeev Bagewadi 	uint64_t value;
302112a2833aSSanjeev Bagewadi 	dmu_tx_t *tx;
302212a2833aSSanjeev Bagewadi 	int i, error;
302312a2833aSSanjeev Bagewadi 	char osname[MAXNAMELEN];
302412a2833aSSanjeev Bagewadi 	char *name = "aaa";
30251bc69b9cSSanjeev Bagewadi 	char entname[MAXNAMELEN];
302612a2833aSSanjeev Bagewadi 
302712a2833aSSanjeev Bagewadi 	dmu_objset_name(os, osname);
302812a2833aSSanjeev Bagewadi 
302912a2833aSSanjeev Bagewadi 	/*
303012a2833aSSanjeev Bagewadi 	 * Create a new object if necessary, and record it in the directory.
303112a2833aSSanjeev Bagewadi 	 */
303212a2833aSSanjeev Bagewadi 	VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
303312a2833aSSanjeev Bagewadi 	    sizeof (uint64_t), &object, DMU_READ_PREFETCH));
303412a2833aSSanjeev Bagewadi 
303512a2833aSSanjeev Bagewadi 	if (object == 0) {
303612a2833aSSanjeev Bagewadi 		tx = dmu_tx_create(os);
303712a2833aSSanjeev Bagewadi 		dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff,
303812a2833aSSanjeev Bagewadi 		    sizeof (uint64_t));
303912a2833aSSanjeev Bagewadi 		dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL);
304012a2833aSSanjeev Bagewadi 		error = dmu_tx_assign(tx, TXG_WAIT);
304112a2833aSSanjeev Bagewadi 		if (error) {
304212a2833aSSanjeev Bagewadi 			ztest_record_enospc("create zap test obj");
304312a2833aSSanjeev Bagewadi 			dmu_tx_abort(tx);
304412a2833aSSanjeev Bagewadi 			return;
304512a2833aSSanjeev Bagewadi 		}
304612a2833aSSanjeev Bagewadi 		object = zap_create(os, DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx);
304712a2833aSSanjeev Bagewadi 		if (error) {
304812a2833aSSanjeev Bagewadi 			fatal(0, "zap_create('%s', %llu) = %d",
304912a2833aSSanjeev Bagewadi 			    osname, object, error);
305012a2833aSSanjeev Bagewadi 		}
305112a2833aSSanjeev Bagewadi 		ASSERT(object != 0);
305212a2833aSSanjeev Bagewadi 		dmu_write(os, ZTEST_DIROBJ, za->za_diroff,
305312a2833aSSanjeev Bagewadi 		    sizeof (uint64_t), &object, tx);
305412a2833aSSanjeev Bagewadi 		dmu_tx_commit(tx);
305512a2833aSSanjeev Bagewadi 	}
305612a2833aSSanjeev Bagewadi 
305712a2833aSSanjeev Bagewadi 	/*
305812a2833aSSanjeev Bagewadi 	 * Add entries to this ZAP amd make sure it spills over
305912a2833aSSanjeev Bagewadi 	 * and gets upgraded to a fatzap. Also, since we are adding
306012a2833aSSanjeev Bagewadi 	 * 2050 entries we should see ptrtbl growth and leaf-block
306112a2833aSSanjeev Bagewadi 	 * split.
306212a2833aSSanjeev Bagewadi 	 */
306312a2833aSSanjeev Bagewadi 	for (i = 0; i < 2050; i++) {
30641bc69b9cSSanjeev Bagewadi 		(void) snprintf(entname, sizeof (entname), "%s-%d", name, i);
306512a2833aSSanjeev Bagewadi 		value = i;
306612a2833aSSanjeev Bagewadi 
306712a2833aSSanjeev Bagewadi 		tx = dmu_tx_create(os);
306812a2833aSSanjeev Bagewadi 		dmu_tx_hold_zap(tx, object, TRUE, entname);
306912a2833aSSanjeev Bagewadi 		error = dmu_tx_assign(tx, TXG_WAIT);
307012a2833aSSanjeev Bagewadi 
307112a2833aSSanjeev Bagewadi 		if (error) {
307212a2833aSSanjeev Bagewadi 			ztest_record_enospc("create zap entry");
307312a2833aSSanjeev Bagewadi 			dmu_tx_abort(tx);
307412a2833aSSanjeev Bagewadi 			return;
307512a2833aSSanjeev Bagewadi 		}
307612a2833aSSanjeev Bagewadi 		error = zap_add(os, object, entname, sizeof (uint64_t),
307712a2833aSSanjeev Bagewadi 		    1, &value, tx);
307812a2833aSSanjeev Bagewadi 
307912a2833aSSanjeev Bagewadi 		ASSERT(error == 0 || error == EEXIST);
308012a2833aSSanjeev Bagewadi 		dmu_tx_commit(tx);
308112a2833aSSanjeev Bagewadi 	}
308212a2833aSSanjeev Bagewadi 
308312a2833aSSanjeev Bagewadi 	/*
308412a2833aSSanjeev Bagewadi 	 * Once in a while, destroy the object.
308512a2833aSSanjeev Bagewadi 	 */
308612a2833aSSanjeev Bagewadi 	if (ztest_random(1000) != 0)
308712a2833aSSanjeev Bagewadi 		return;
308812a2833aSSanjeev Bagewadi 
308912a2833aSSanjeev Bagewadi 	tx = dmu_tx_create(os);
309012a2833aSSanjeev Bagewadi 	dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t));
309112a2833aSSanjeev Bagewadi 	dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
309212a2833aSSanjeev Bagewadi 	error = dmu_tx_assign(tx, TXG_WAIT);
309312a2833aSSanjeev Bagewadi 	if (error) {
309412a2833aSSanjeev Bagewadi 		ztest_record_enospc("destroy zap object");
3095fa9e4066Sahrens 		dmu_tx_abort(tx);
3096fa9e4066Sahrens 		return;
3097fa9e4066Sahrens 	}
3098fa9e4066Sahrens 	error = zap_destroy(os, object, tx);
3099fa9e4066Sahrens 	if (error)
3100fa9e4066Sahrens 		fatal(0, "zap_destroy('%s', %llu) = %d",
3101fa9e4066Sahrens 		    osname, object, error);
3102fa9e4066Sahrens 	object = 0;
3103fa9e4066Sahrens 	dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t),
3104fa9e4066Sahrens 	    &object, tx);
3105fa9e4066Sahrens 	dmu_tx_commit(tx);
3106fa9e4066Sahrens }
3107fa9e4066Sahrens 
3108fa9e4066Sahrens void
3109fa9e4066Sahrens ztest_zap_parallel(ztest_args_t *za)
3110fa9e4066Sahrens {
3111fa9e4066Sahrens 	objset_t *os = za->za_os;
3112fa9e4066Sahrens 	uint64_t txg, object, count, wsize, wc, zl_wsize, zl_wc;
3113fa9e4066Sahrens 	dmu_tx_t *tx;
3114fa9e4066Sahrens 	int i, namelen, error;
3115fa9e4066Sahrens 	char name[20], string_value[20];
3116fa9e4066Sahrens 	void *data;
3117fa9e4066Sahrens 
3118e05725b1Sbonwick 	/*
3119e05725b1Sbonwick 	 * Generate a random name of the form 'xxx.....' where each
3120e05725b1Sbonwick 	 * x is a random printable character and the dots are dots.
3121e05725b1Sbonwick 	 * There are 94 such characters, and the name length goes from
3122e05725b1Sbonwick 	 * 6 to 20, so there are 94^3 * 15 = 12,458,760 possible names.
3123e05725b1Sbonwick 	 */
3124e05725b1Sbonwick 	namelen = ztest_random(sizeof (name) - 5) + 5 + 1;
3125fa9e4066Sahrens 
3126e05725b1Sbonwick 	for (i = 0; i < 3; i++)
3127e05725b1Sbonwick 		name[i] = '!' + ztest_random('~' - '!' + 1);
3128e05725b1Sbonwick 	for (; i < namelen - 1; i++)
3129e05725b1Sbonwick 		name[i] = '.';
3130e05725b1Sbonwick 	name[i] = '\0';
3131fa9e4066Sahrens 
3132e05725b1Sbonwick 	if (ztest_random(2) == 0)
3133e05725b1Sbonwick 		object = ZTEST_MICROZAP_OBJ;
3134e05725b1Sbonwick 	else
3135e05725b1Sbonwick 		object = ZTEST_FATZAP_OBJ;
3136fa9e4066Sahrens 
3137e05725b1Sbonwick 	if ((namelen & 1) || object == ZTEST_MICROZAP_OBJ) {
3138e05725b1Sbonwick 		wsize = sizeof (txg);
3139e05725b1Sbonwick 		wc = 1;
3140e05725b1Sbonwick 		data = &txg;
3141e05725b1Sbonwick 	} else {
3142e05725b1Sbonwick 		wsize = 1;
3143e05725b1Sbonwick 		wc = namelen;
3144e05725b1Sbonwick 		data = string_value;
3145e05725b1Sbonwick 	}
3146fa9e4066Sahrens 
3147e05725b1Sbonwick 	count = -1ULL;
3148e05725b1Sbonwick 	VERIFY(zap_count(os, object, &count) == 0);
3149e05725b1Sbonwick 	ASSERT(count != -1ULL);
3150fa9e4066Sahrens 
3151e05725b1Sbonwick 	/*
3152e05725b1Sbonwick 	 * Select an operation: length, lookup, add, update, remove.
3153e05725b1Sbonwick 	 */
3154e05725b1Sbonwick 	i = ztest_random(5);
3155e05725b1Sbonwick 
3156e05725b1Sbonwick 	if (i >= 2) {
3157e05725b1Sbonwick 		tx = dmu_tx_create(os);
3158e05725b1Sbonwick 		dmu_tx_hold_zap(tx, object, TRUE, NULL);
3159e05725b1Sbonwick 		error = dmu_tx_assign(tx, TXG_WAIT);
3160e05725b1Sbonwick 		if (error) {
3161e05725b1Sbonwick 			ztest_record_enospc("zap parallel");
3162e05725b1Sbonwick 			dmu_tx_abort(tx);
3163e05725b1Sbonwick 			return;
3164fa9e4066Sahrens 		}
3165e05725b1Sbonwick 		txg = dmu_tx_get_txg(tx);
3166e05725b1Sbonwick 		bcopy(name, string_value, namelen);
3167e05725b1Sbonwick 	} else {
3168e05725b1Sbonwick 		tx = NULL;
3169e05725b1Sbonwick 		txg = 0;
3170e05725b1Sbonwick 		bzero(string_value, namelen);
3171e05725b1Sbonwick 	}
3172fa9e4066Sahrens 
3173e05725b1Sbonwick 	switch (i) {
3174fa9e4066Sahrens 
3175e05725b1Sbonwick 	case 0:
3176e05725b1Sbonwick 		error = zap_length(os, object, name, &zl_wsize, &zl_wc);
3177e05725b1Sbonwick 		if (error == 0) {
3178e05725b1Sbonwick 			ASSERT3U(wsize, ==, zl_wsize);
3179e05725b1Sbonwick 			ASSERT3U(wc, ==, zl_wc);
3180e05725b1Sbonwick 		} else {
3181e05725b1Sbonwick 			ASSERT3U(error, ==, ENOENT);
3182e05725b1Sbonwick 		}
3183e05725b1Sbonwick 		break;
3184fa9e4066Sahrens 
3185e05725b1Sbonwick 	case 1:
3186e05725b1Sbonwick 		error = zap_lookup(os, object, name, wsize, wc, data);
3187e05725b1Sbonwick 		if (error == 0) {
3188e05725b1Sbonwick 			if (data == string_value &&
3189e05725b1Sbonwick 			    bcmp(name, data, namelen) != 0)
3190e05725b1Sbonwick 				fatal(0, "name '%s' != val '%s' len %d",
3191e05725b1Sbonwick 				    name, data, namelen);
3192e05725b1Sbonwick 		} else {
3193e05725b1Sbonwick 			ASSERT3U(error, ==, ENOENT);
3194e05725b1Sbonwick 		}
3195e05725b1Sbonwick 		break;
3196fa9e4066Sahrens 
3197e05725b1Sbonwick 	case 2:
3198e05725b1Sbonwick 		error = zap_add(os, object, name, wsize, wc, data, tx);
3199e05725b1Sbonwick 		ASSERT(error == 0 || error == EEXIST);
3200e05725b1Sbonwick 		break;
3201fa9e4066Sahrens 
3202e05725b1Sbonwick 	case 3:
3203e05725b1Sbonwick 		VERIFY(zap_update(os, object, name, wsize, wc, data, tx) == 0);
3204e05725b1Sbonwick 		break;
3205fa9e4066Sahrens 
3206e05725b1Sbonwick 	case 4:
3207e05725b1Sbonwick 		error = zap_remove(os, object, name, tx);
3208e05725b1Sbonwick 		ASSERT(error == 0 || error == ENOENT);
3209e05725b1Sbonwick 		break;
3210fa9e4066Sahrens 	}
3211e05725b1Sbonwick 
3212e05725b1Sbonwick 	if (tx != NULL)
3213e05725b1Sbonwick 		dmu_tx_commit(tx);
3214fa9e4066Sahrens }
3215fa9e4066Sahrens 
3216*d20e665cSRicardo M. Correia /*
3217*d20e665cSRicardo M. Correia  * Commit callback data.
3218*d20e665cSRicardo M. Correia  */
3219*d20e665cSRicardo M. Correia typedef struct ztest_cb_data {
3220*d20e665cSRicardo M. Correia 	list_node_t		zcd_node;
3221*d20e665cSRicardo M. Correia 	uint64_t		zcd_txg;
3222*d20e665cSRicardo M. Correia 	int			zcd_expected_err;
3223*d20e665cSRicardo M. Correia 	boolean_t		zcd_added;
3224*d20e665cSRicardo M. Correia 	boolean_t		zcd_called;
3225*d20e665cSRicardo M. Correia 	spa_t			*zcd_spa;
3226*d20e665cSRicardo M. Correia } ztest_cb_data_t;
3227*d20e665cSRicardo M. Correia 
3228*d20e665cSRicardo M. Correia /* This is the actual commit callback function */
3229*d20e665cSRicardo M. Correia static void
3230*d20e665cSRicardo M. Correia ztest_commit_callback(void *arg, int error)
3231*d20e665cSRicardo M. Correia {
3232*d20e665cSRicardo M. Correia 	ztest_cb_data_t *data = arg;
3233*d20e665cSRicardo M. Correia 	uint64_t synced_txg;
3234*d20e665cSRicardo M. Correia 
3235*d20e665cSRicardo M. Correia 	VERIFY(data != NULL);
3236*d20e665cSRicardo M. Correia 	VERIFY3S(data->zcd_expected_err, ==, error);
3237*d20e665cSRicardo M. Correia 	VERIFY(!data->zcd_called);
3238*d20e665cSRicardo M. Correia 
3239*d20e665cSRicardo M. Correia 	synced_txg = spa_last_synced_txg(data->zcd_spa);
3240*d20e665cSRicardo M. Correia 	if (data->zcd_txg > synced_txg)
3241*d20e665cSRicardo M. Correia 		fatal(0, "commit callback of txg %" PRIu64 " called prematurely"
3242*d20e665cSRicardo M. Correia 		    ", last synced txg = %" PRIu64 "\n", data->zcd_txg,
3243*d20e665cSRicardo M. Correia 		    synced_txg);
3244*d20e665cSRicardo M. Correia 
3245*d20e665cSRicardo M. Correia 	data->zcd_called = B_TRUE;
3246*d20e665cSRicardo M. Correia 
3247*d20e665cSRicardo M. Correia 	if (error == ECANCELED) {
3248*d20e665cSRicardo M. Correia 		ASSERT3U(data->zcd_txg, ==, 0);
3249*d20e665cSRicardo M. Correia 		ASSERT(!data->zcd_added);
3250*d20e665cSRicardo M. Correia 
3251*d20e665cSRicardo M. Correia 		/*
3252*d20e665cSRicardo M. Correia 		 * The private callback data should be destroyed here, but
3253*d20e665cSRicardo M. Correia 		 * since we are going to check the zcd_called field after
3254*d20e665cSRicardo M. Correia 		 * dmu_tx_abort(), we will destroy it there.
3255*d20e665cSRicardo M. Correia 		 */
3256*d20e665cSRicardo M. Correia 		return;
3257*d20e665cSRicardo M. Correia 	}
3258*d20e665cSRicardo M. Correia 
3259*d20e665cSRicardo M. Correia 	/* Was this callback added to the global callback list? */
3260*d20e665cSRicardo M. Correia 	if (!data->zcd_added)
3261*d20e665cSRicardo M. Correia 		goto out;
3262*d20e665cSRicardo M. Correia 
3263*d20e665cSRicardo M. Correia 	ASSERT3U(data->zcd_txg, !=, 0);
3264*d20e665cSRicardo M. Correia 
3265*d20e665cSRicardo M. Correia 	/* Remove our callback from the list */
3266*d20e665cSRicardo M. Correia 	(void) mutex_lock(&zcl.zcl_callbacks_lock);
3267*d20e665cSRicardo M. Correia 	list_remove(&zcl.zcl_callbacks, data);
3268*d20e665cSRicardo M. Correia 	(void) mutex_unlock(&zcl.zcl_callbacks_lock);
3269*d20e665cSRicardo M. Correia 
3270*d20e665cSRicardo M. Correia out:
3271*d20e665cSRicardo M. Correia 	umem_free(data, sizeof (ztest_cb_data_t));
3272*d20e665cSRicardo M. Correia }
3273*d20e665cSRicardo M. Correia 
3274*d20e665cSRicardo M. Correia /* Allocate and initialize callback data structure */
3275*d20e665cSRicardo M. Correia static ztest_cb_data_t *
3276*d20e665cSRicardo M. Correia ztest_create_cb_data(objset_t *os, uint64_t txg)
3277*d20e665cSRicardo M. Correia {
3278*d20e665cSRicardo M. Correia 	ztest_cb_data_t *cb_data;
3279*d20e665cSRicardo M. Correia 
3280*d20e665cSRicardo M. Correia 	cb_data = umem_zalloc(sizeof (ztest_cb_data_t), UMEM_NOFAIL);
3281*d20e665cSRicardo M. Correia 
3282*d20e665cSRicardo M. Correia 	cb_data->zcd_txg = txg;
3283*d20e665cSRicardo M. Correia 	cb_data->zcd_spa = dmu_objset_spa(os);
3284*d20e665cSRicardo M. Correia 
3285*d20e665cSRicardo M. Correia 	return (cb_data);
3286*d20e665cSRicardo M. Correia }
3287*d20e665cSRicardo M. Correia 
3288*d20e665cSRicardo M. Correia /*
3289*d20e665cSRicardo M. Correia  * If a number of txgs equal to this threshold have been created after a commit
3290*d20e665cSRicardo M. Correia  * callback has been registered but not called, then we assume there is an
3291*d20e665cSRicardo M. Correia  * implementation bug.
3292*d20e665cSRicardo M. Correia  */
3293*d20e665cSRicardo M. Correia #define	ZTEST_COMMIT_CALLBACK_THRESH	(TXG_CONCURRENT_STATES + 2)
3294*d20e665cSRicardo M. Correia 
3295*d20e665cSRicardo M. Correia /*
3296*d20e665cSRicardo M. Correia  * Commit callback test.
3297*d20e665cSRicardo M. Correia  */
3298*d20e665cSRicardo M. Correia void
3299*d20e665cSRicardo M. Correia ztest_dmu_commit_callbacks(ztest_args_t *za)
3300*d20e665cSRicardo M. Correia {
3301*d20e665cSRicardo M. Correia 	objset_t *os = za->za_os;
3302*d20e665cSRicardo M. Correia 	dmu_tx_t *tx;
3303*d20e665cSRicardo M. Correia 	ztest_cb_data_t *cb_data[3], *tmp_cb;
3304*d20e665cSRicardo M. Correia 	uint64_t old_txg, txg;
3305*d20e665cSRicardo M. Correia 	int i, error;
3306*d20e665cSRicardo M. Correia 
3307*d20e665cSRicardo M. Correia 	tx = dmu_tx_create(os);
3308*d20e665cSRicardo M. Correia 
3309*d20e665cSRicardo M. Correia 	cb_data[0] = ztest_create_cb_data(os, 0);
3310*d20e665cSRicardo M. Correia 	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[0]);
3311*d20e665cSRicardo M. Correia 
3312*d20e665cSRicardo M. Correia 	dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t));
3313*d20e665cSRicardo M. Correia 
3314*d20e665cSRicardo M. Correia 	/* Every once in a while, abort the transaction on purpose */
3315*d20e665cSRicardo M. Correia 	if (ztest_random(100) == 0)
3316*d20e665cSRicardo M. Correia 		error = -1;
3317*d20e665cSRicardo M. Correia 
3318*d20e665cSRicardo M. Correia 	if (!error)
3319*d20e665cSRicardo M. Correia 		error = dmu_tx_assign(tx, TXG_NOWAIT);
3320*d20e665cSRicardo M. Correia 
3321*d20e665cSRicardo M. Correia 	txg = error ? 0 : dmu_tx_get_txg(tx);
3322*d20e665cSRicardo M. Correia 
3323*d20e665cSRicardo M. Correia 	cb_data[0]->zcd_txg = txg;
3324*d20e665cSRicardo M. Correia 	cb_data[1] = ztest_create_cb_data(os, txg);
3325*d20e665cSRicardo M. Correia 	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[1]);
3326*d20e665cSRicardo M. Correia 
3327*d20e665cSRicardo M. Correia 	if (error) {
3328*d20e665cSRicardo M. Correia 		/*
3329*d20e665cSRicardo M. Correia 		 * It's not a strict requirement to call the registered
3330*d20e665cSRicardo M. Correia 		 * callbacks from inside dmu_tx_abort(), but that's what
3331*d20e665cSRicardo M. Correia 		 * it's supposed to happen in the current implementation
3332*d20e665cSRicardo M. Correia 		 * so we will check for that.
3333*d20e665cSRicardo M. Correia 		 */
3334*d20e665cSRicardo M. Correia 		for (i = 0; i < 2; i++) {
3335*d20e665cSRicardo M. Correia 			cb_data[i]->zcd_expected_err = ECANCELED;
3336*d20e665cSRicardo M. Correia 			VERIFY(!cb_data[i]->zcd_called);
3337*d20e665cSRicardo M. Correia 		}
3338*d20e665cSRicardo M. Correia 
3339*d20e665cSRicardo M. Correia 		dmu_tx_abort(tx);
3340*d20e665cSRicardo M. Correia 
3341*d20e665cSRicardo M. Correia 		for (i = 0; i < 2; i++) {
3342*d20e665cSRicardo M. Correia 			VERIFY(cb_data[i]->zcd_called);
3343*d20e665cSRicardo M. Correia 			umem_free(cb_data[i], sizeof (ztest_cb_data_t));
3344*d20e665cSRicardo M. Correia 		}
3345*d20e665cSRicardo M. Correia 
3346*d20e665cSRicardo M. Correia 		return;
3347*d20e665cSRicardo M. Correia 	}
3348*d20e665cSRicardo M. Correia 
3349*d20e665cSRicardo M. Correia 	cb_data[2] = ztest_create_cb_data(os, txg);
3350*d20e665cSRicardo M. Correia 	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[2]);
3351*d20e665cSRicardo M. Correia 
3352*d20e665cSRicardo M. Correia 	/*
3353*d20e665cSRicardo M. Correia 	 * Read existing data to make sure there isn't a future leak.
3354*d20e665cSRicardo M. Correia 	 */
3355*d20e665cSRicardo M. Correia 	VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t),
3356*d20e665cSRicardo M. Correia 	    &old_txg, DMU_READ_PREFETCH));
3357*d20e665cSRicardo M. Correia 
3358*d20e665cSRicardo M. Correia 	if (old_txg > txg)
3359*d20e665cSRicardo M. Correia 		fatal(0, "future leak: got %" PRIu64 ", open txg is %" PRIu64,
3360*d20e665cSRicardo M. Correia 		    old_txg, txg);
3361*d20e665cSRicardo M. Correia 
3362*d20e665cSRicardo M. Correia 	dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t), &txg, tx);
3363*d20e665cSRicardo M. Correia 
3364*d20e665cSRicardo M. Correia 	(void) mutex_lock(&zcl.zcl_callbacks_lock);
3365*d20e665cSRicardo M. Correia 
3366*d20e665cSRicardo M. Correia 	/*
3367*d20e665cSRicardo M. Correia 	 * Since commit callbacks don't have any ordering requirement and since
3368*d20e665cSRicardo M. Correia 	 * it is theoretically possible for a commit callback to be called
3369*d20e665cSRicardo M. Correia 	 * after an arbitrary amount of time has elapsed since its txg has been
3370*d20e665cSRicardo M. Correia 	 * synced, it is difficult to reliably determine whether a commit
3371*d20e665cSRicardo M. Correia 	 * callback hasn't been called due to high load or due to a flawed
3372*d20e665cSRicardo M. Correia 	 * implementation.
3373*d20e665cSRicardo M. Correia 	 *
3374*d20e665cSRicardo M. Correia 	 * In practice, we will assume that if after a certain number of txgs a
3375*d20e665cSRicardo M. Correia 	 * commit callback hasn't been called, then most likely there's an
3376*d20e665cSRicardo M. Correia 	 * implementation bug..
3377*d20e665cSRicardo M. Correia 	 */
3378*d20e665cSRicardo M. Correia 	tmp_cb = list_head(&zcl.zcl_callbacks);
3379*d20e665cSRicardo M. Correia 	if (tmp_cb != NULL &&
3380*d20e665cSRicardo M. Correia 	    tmp_cb->zcd_txg > txg - ZTEST_COMMIT_CALLBACK_THRESH) {
3381*d20e665cSRicardo M. Correia 		fatal(0, "Commit callback threshold exceeded, oldest txg: %"
3382*d20e665cSRicardo M. Correia 		    PRIu64 ", open txg: %" PRIu64 "\n", tmp_cb->zcd_txg, txg);
3383*d20e665cSRicardo M. Correia 	}
3384*d20e665cSRicardo M. Correia 
3385*d20e665cSRicardo M. Correia 	/*
3386*d20e665cSRicardo M. Correia 	 * Let's find the place to insert our callbacks.
3387*d20e665cSRicardo M. Correia 	 *
3388*d20e665cSRicardo M. Correia 	 * Even though the list is ordered by txg, it is possible for the
3389*d20e665cSRicardo M. Correia 	 * insertion point to not be the end because our txg may already be
3390*d20e665cSRicardo M. Correia 	 * quiescing at this point and other callbacks in the open txg
3391*d20e665cSRicardo M. Correia 	 * (from other objsets) may have sneaked in.
3392*d20e665cSRicardo M. Correia 	 */
3393*d20e665cSRicardo M. Correia 	tmp_cb = list_tail(&zcl.zcl_callbacks);
3394*d20e665cSRicardo M. Correia 	while (tmp_cb != NULL && tmp_cb->zcd_txg > txg)
3395*d20e665cSRicardo M. Correia 		tmp_cb = list_prev(&zcl.zcl_callbacks, tmp_cb);
3396*d20e665cSRicardo M. Correia 
3397*d20e665cSRicardo M. Correia 	/* Add the 3 callbacks to the list */
3398*d20e665cSRicardo M. Correia 	for (i = 0; i < 3; i++) {
3399*d20e665cSRicardo M. Correia 		if (tmp_cb == NULL)
3400*d20e665cSRicardo M. Correia 			list_insert_head(&zcl.zcl_callbacks, cb_data[i]);
3401*d20e665cSRicardo M. Correia 		else
3402*d20e665cSRicardo M. Correia 			list_insert_after(&zcl.zcl_callbacks, tmp_cb,
3403*d20e665cSRicardo M. Correia 			    cb_data[i]);
3404*d20e665cSRicardo M. Correia 
3405*d20e665cSRicardo M. Correia 		cb_data[i]->zcd_added = B_TRUE;
3406*d20e665cSRicardo M. Correia 		VERIFY(!cb_data[i]->zcd_called);
3407*d20e665cSRicardo M. Correia 
3408*d20e665cSRicardo M. Correia 		tmp_cb = cb_data[i];
3409*d20e665cSRicardo M. Correia 	}
3410*d20e665cSRicardo M. Correia 
3411*d20e665cSRicardo M. Correia 	(void) mutex_unlock(&zcl.zcl_callbacks_lock);
3412*d20e665cSRicardo M. Correia 
3413*d20e665cSRicardo M. Correia 	dmu_tx_commit(tx);
3414*d20e665cSRicardo M. Correia }
3415*d20e665cSRicardo M. Correia 
3416fa9e4066Sahrens void
3417fa9e4066Sahrens ztest_dsl_prop_get_set(ztest_args_t *za)
3418fa9e4066Sahrens {
3419fa9e4066Sahrens 	objset_t *os = za->za_os;
3420fa9e4066Sahrens 	int i, inherit;
3421fa9e4066Sahrens 	uint64_t value;
3422fa9e4066Sahrens 	const char *prop, *valname;
3423fa9e4066Sahrens 	char setpoint[MAXPATHLEN];
3424fa9e4066Sahrens 	char osname[MAXNAMELEN];
3425ea8dc4b6Seschrock 	int error;
3426fa9e4066Sahrens 
3427fa9e4066Sahrens 	(void) rw_rdlock(&ztest_shared->zs_name_lock);
3428fa9e4066Sahrens 
3429fa9e4066Sahrens 	dmu_objset_name(os, osname);
3430fa9e4066Sahrens 
3431fa9e4066Sahrens 	for (i = 0; i < 2; i++) {
3432fa9e4066Sahrens 		if (i == 0) {
3433fa9e4066Sahrens 			prop = "checksum";
3434fa9e4066Sahrens 			value = ztest_random_checksum();
3435fa9e4066Sahrens 			inherit = (value == ZIO_CHECKSUM_INHERIT);
3436fa9e4066Sahrens 		} else {
3437fa9e4066Sahrens 			prop = "compression";
3438fa9e4066Sahrens 			value = ztest_random_compress();
3439fa9e4066Sahrens 			inherit = (value == ZIO_COMPRESS_INHERIT);
3440fa9e4066Sahrens 		}
3441fa9e4066Sahrens 
3442ea8dc4b6Seschrock 		error = dsl_prop_set(osname, prop, sizeof (value),
3443ea8dc4b6Seschrock 		    !inherit, &value);
3444ea8dc4b6Seschrock 
3445ea8dc4b6Seschrock 		if (error == ENOSPC) {
3446ea8dc4b6Seschrock 			ztest_record_enospc("dsl_prop_set");
3447ea8dc4b6Seschrock 			break;
3448ea8dc4b6Seschrock 		}
3449ea8dc4b6Seschrock 
3450ea8dc4b6Seschrock 		ASSERT3U(error, ==, 0);
3451fa9e4066Sahrens 
3452fa9e4066Sahrens 		VERIFY3U(dsl_prop_get(osname, prop, sizeof (value),
3453fa9e4066Sahrens 		    1, &value, setpoint), ==, 0);
3454fa9e4066Sahrens 
3455fa9e4066Sahrens 		if (i == 0)
3456fa9e4066Sahrens 			valname = zio_checksum_table[value].ci_name;
3457fa9e4066Sahrens 		else
3458fa9e4066Sahrens 			valname = zio_compress_table[value].ci_name;
3459fa9e4066Sahrens 
3460fa9e4066Sahrens 		if (zopt_verbose >= 6) {
3461fa9e4066Sahrens 			(void) printf("%s %s = %s for '%s'\n",
3462fa9e4066Sahrens 			    osname, prop, valname, setpoint);
3463fa9e4066Sahrens 		}
3464fa9e4066Sahrens 	}
3465fa9e4066Sahrens 
3466fa9e4066Sahrens 	(void) rw_unlock(&ztest_shared->zs_name_lock);
3467fa9e4066Sahrens }
3468fa9e4066Sahrens 
3469fa9e4066Sahrens /*
3470fa9e4066Sahrens  * Inject random faults into the on-disk data.
3471fa9e4066Sahrens  */
3472fa9e4066Sahrens void
3473fa9e4066Sahrens ztest_fault_inject(ztest_args_t *za)
3474fa9e4066Sahrens {
3475fa9e4066Sahrens 	int fd;
3476fa9e4066Sahrens 	uint64_t offset;
3477fa9e4066Sahrens 	uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz;
3478fa9e4066Sahrens 	uint64_t bad = 0x1990c0ffeedecade;
3479fa9e4066Sahrens 	uint64_t top, leaf;
3480fa9e4066Sahrens 	char path0[MAXPATHLEN];
3481fa9e4066Sahrens 	char pathrand[MAXPATHLEN];
3482fa9e4066Sahrens 	size_t fsize;
3483e05725b1Sbonwick 	spa_t *spa = za->za_spa;
3484fa9e4066Sahrens 	int bshift = SPA_MAXBLOCKSHIFT + 2;	/* don't scrog all labels */
3485fa9e4066Sahrens 	int iters = 1000;
3486e14bb325SJeff Bonwick 	int maxfaults = zopt_maxfaults;
3487e14bb325SJeff Bonwick 	vdev_t *vd0 = NULL;
3488ea8dc4b6Seschrock 	uint64_t guid0 = 0;
3489ea8dc4b6Seschrock 
3490e14bb325SJeff Bonwick 	ASSERT(leaves >= 1);
3491fa9e4066Sahrens 
3492fa9e4066Sahrens 	/*
3493e14bb325SJeff Bonwick 	 * We need SCL_STATE here because we're going to look at vd0->vdev_tsd.
3494fa9e4066Sahrens 	 */
3495e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
3496fa9e4066Sahrens 
3497e14bb325SJeff Bonwick 	if (ztest_random(2) == 0) {
3498e14bb325SJeff Bonwick 		/*
3499e14bb325SJeff Bonwick 		 * Inject errors on a normal data device.
3500e14bb325SJeff Bonwick 		 */
3501e14bb325SJeff Bonwick 		top = ztest_random(spa->spa_root_vdev->vdev_children);
3502e14bb325SJeff Bonwick 		leaf = ztest_random(leaves);
3503fa9e4066Sahrens 
3504e14bb325SJeff Bonwick 		/*
3505e14bb325SJeff Bonwick 		 * Generate paths to the first leaf in this top-level vdev,
3506e14bb325SJeff Bonwick 		 * and to the random leaf we selected.  We'll induce transient
3507e14bb325SJeff Bonwick 		 * write failures and random online/offline activity on leaf 0,
3508e14bb325SJeff Bonwick 		 * and we'll write random garbage to the randomly chosen leaf.
3509e14bb325SJeff Bonwick 		 */
3510e14bb325SJeff Bonwick 		(void) snprintf(path0, sizeof (path0), ztest_dev_template,
3511e14bb325SJeff Bonwick 		    zopt_dir, zopt_pool, top * leaves + 0);
3512e14bb325SJeff Bonwick 		(void) snprintf(pathrand, sizeof (pathrand), ztest_dev_template,
3513e14bb325SJeff Bonwick 		    zopt_dir, zopt_pool, top * leaves + leaf);
3514fa9e4066Sahrens 
3515e14bb325SJeff Bonwick 		vd0 = vdev_lookup_by_path(spa->spa_root_vdev, path0);
3516e14bb325SJeff Bonwick 		if (vd0 != NULL && maxfaults != 1) {
3517e14bb325SJeff Bonwick 			/*
3518e14bb325SJeff Bonwick 			 * Make vd0 explicitly claim to be unreadable,
3519e14bb325SJeff Bonwick 			 * or unwriteable, or reach behind its back
3520e14bb325SJeff Bonwick 			 * and close the underlying fd.  We can do this if
3521e14bb325SJeff Bonwick 			 * maxfaults == 0 because we'll fail and reexecute,
3522e14bb325SJeff Bonwick 			 * and we can do it if maxfaults >= 2 because we'll
3523e14bb325SJeff Bonwick 			 * have enough redundancy.  If maxfaults == 1, the
3524e14bb325SJeff Bonwick 			 * combination of this with injection of random data
3525e14bb325SJeff Bonwick 			 * corruption below exceeds the pool's fault tolerance.
3526e14bb325SJeff Bonwick 			 */
3527e14bb325SJeff Bonwick 			vdev_file_t *vf = vd0->vdev_tsd;
3528e14bb325SJeff Bonwick 
3529e14bb325SJeff Bonwick 			if (vf != NULL && ztest_random(3) == 0) {
3530e14bb325SJeff Bonwick 				(void) close(vf->vf_vnode->v_fd);
3531e14bb325SJeff Bonwick 				vf->vf_vnode->v_fd = -1;
3532e14bb325SJeff Bonwick 			} else if (ztest_random(2) == 0) {
3533e14bb325SJeff Bonwick 				vd0->vdev_cant_read = B_TRUE;
3534e14bb325SJeff Bonwick 			} else {
3535e14bb325SJeff Bonwick 				vd0->vdev_cant_write = B_TRUE;
3536e14bb325SJeff Bonwick 			}
3537e14bb325SJeff Bonwick 			guid0 = vd0->vdev_guid;
3538e14bb325SJeff Bonwick 		}
3539e14bb325SJeff Bonwick 	} else {
3540e14bb325SJeff Bonwick 		/*
3541e14bb325SJeff Bonwick 		 * Inject errors on an l2cache device.
3542e14bb325SJeff Bonwick 		 */
3543e14bb325SJeff Bonwick 		spa_aux_vdev_t *sav = &spa->spa_l2cache;
3544fa9e4066Sahrens 
3545e14bb325SJeff Bonwick 		if (sav->sav_count == 0) {
3546e14bb325SJeff Bonwick 			spa_config_exit(spa, SCL_STATE, FTAG);
3547e14bb325SJeff Bonwick 			return;
3548e14bb325SJeff Bonwick 		}
3549e14bb325SJeff Bonwick 		vd0 = sav->sav_vdevs[ztest_random(sav->sav_count)];
3550ea8dc4b6Seschrock 		guid0 = vd0->vdev_guid;
3551e14bb325SJeff Bonwick 		(void) strcpy(path0, vd0->vdev_path);
3552e14bb325SJeff Bonwick 		(void) strcpy(pathrand, vd0->vdev_path);
3553e14bb325SJeff Bonwick 
3554e14bb325SJeff Bonwick 		leaf = 0;
3555e14bb325SJeff Bonwick 		leaves = 1;
3556e14bb325SJeff Bonwick 		maxfaults = INT_MAX;	/* no limit on cache devices */
3557fa9e4066Sahrens 	}
3558fa9e4066Sahrens 
3559e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_STATE, FTAG);
3560e14bb325SJeff Bonwick 
3561e14bb325SJeff Bonwick 	if (maxfaults == 0)
3562e14bb325SJeff Bonwick 		return;
3563fa9e4066Sahrens 
3564fa9e4066Sahrens 	/*
3565ea8dc4b6Seschrock 	 * If we can tolerate two or more faults, randomly online/offline vd0.
3566fa9e4066Sahrens 	 */
3567e14bb325SJeff Bonwick 	if (maxfaults >= 2 && guid0 != 0) {
35688ad4d6ddSJeff Bonwick 		if (ztest_random(10) < 6) {
35698ad4d6ddSJeff Bonwick 			int flags = (ztest_random(2) == 0 ?
35708ad4d6ddSJeff Bonwick 			    ZFS_OFFLINE_TEMPORARY : 0);
35718ad4d6ddSJeff Bonwick 			VERIFY(vdev_offline(spa, guid0, flags) != EBUSY);
35728ad4d6ddSJeff Bonwick 		} else {
35738ad4d6ddSJeff Bonwick 			(void) vdev_online(spa, guid0, 0, NULL);
35748ad4d6ddSJeff Bonwick 		}
3575fa9e4066Sahrens 	}
3576fa9e4066Sahrens 
3577fa9e4066Sahrens 	/*
3578ea8dc4b6Seschrock 	 * We have at least single-fault tolerance, so inject data corruption.
3579fa9e4066Sahrens 	 */
3580fa9e4066Sahrens 	fd = open(pathrand, O_RDWR);
3581fa9e4066Sahrens 
3582fa9e4066Sahrens 	if (fd == -1)	/* we hit a gap in the device namespace */
3583fa9e4066Sahrens 		return;
3584fa9e4066Sahrens 
3585fa9e4066Sahrens 	fsize = lseek(fd, 0, SEEK_END);
3586fa9e4066Sahrens 
3587fa9e4066Sahrens 	while (--iters != 0) {
3588fa9e4066Sahrens 		offset = ztest_random(fsize / (leaves << bshift)) *
3589fa9e4066Sahrens 		    (leaves << bshift) + (leaf << bshift) +
3590fa9e4066Sahrens 		    (ztest_random(1ULL << (bshift - 1)) & -8ULL);
3591fa9e4066Sahrens 
3592fa9e4066Sahrens 		if (offset >= fsize)
3593fa9e4066Sahrens 			continue;
3594fa9e4066Sahrens 
3595fa9e4066Sahrens 		if (zopt_verbose >= 6)
3596fa9e4066Sahrens 			(void) printf("injecting bad word into %s,"
3597fa9e4066Sahrens 			    " offset 0x%llx\n", pathrand, (u_longlong_t)offset);
3598fa9e4066Sahrens 
3599fa9e4066Sahrens 		if (pwrite(fd, &bad, sizeof (bad), offset) != sizeof (bad))
3600fa9e4066Sahrens 			fatal(1, "can't inject bad word at 0x%llx in %s",
3601fa9e4066Sahrens 			    offset, pathrand);
3602fa9e4066Sahrens 	}
3603fa9e4066Sahrens 
3604fa9e4066Sahrens 	(void) close(fd);
3605fa9e4066Sahrens }
3606fa9e4066Sahrens 
3607fa9e4066Sahrens /*
3608fa9e4066Sahrens  * Scrub the pool.
3609fa9e4066Sahrens  */
3610fa9e4066Sahrens void
3611fa9e4066Sahrens ztest_scrub(ztest_args_t *za)
3612fa9e4066Sahrens {
3613e05725b1Sbonwick 	spa_t *spa = za->za_spa;
3614fa9e4066Sahrens 
3615088f3894Sahrens 	(void) spa_scrub(spa, POOL_SCRUB_EVERYTHING);
3616fa9e4066Sahrens 	(void) poll(NULL, 0, 1000); /* wait a second, then force a restart */
3617088f3894Sahrens 	(void) spa_scrub(spa, POOL_SCRUB_EVERYTHING);
3618fa9e4066Sahrens }
3619fa9e4066Sahrens 
3620fa9e4066Sahrens /*
3621fa9e4066Sahrens  * Rename the pool to a different name and then rename it back.
3622fa9e4066Sahrens  */
3623fa9e4066Sahrens void
3624fa9e4066Sahrens ztest_spa_rename(ztest_args_t *za)
3625fa9e4066Sahrens {
3626fa9e4066Sahrens 	char *oldname, *newname;
3627fa9e4066Sahrens 	int error;
3628fa9e4066Sahrens 	spa_t *spa;
3629fa9e4066Sahrens 
3630fa9e4066Sahrens 	(void) rw_wrlock(&ztest_shared->zs_name_lock);
3631fa9e4066Sahrens 
3632fa9e4066Sahrens 	oldname = za->za_pool;
3633fa9e4066Sahrens 	newname = umem_alloc(strlen(oldname) + 5, UMEM_NOFAIL);
3634fa9e4066Sahrens 	(void) strcpy(newname, oldname);
3635fa9e4066Sahrens 	(void) strcat(newname, "_tmp");
3636fa9e4066Sahrens 
3637fa9e4066Sahrens 	/*
3638fa9e4066Sahrens 	 * Do the rename
3639fa9e4066Sahrens 	 */
3640fa9e4066Sahrens 	error = spa_rename(oldname, newname);
3641fa9e4066Sahrens 	if (error)
3642fa9e4066Sahrens 		fatal(0, "spa_rename('%s', '%s') = %d", oldname,
3643fa9e4066Sahrens 		    newname, error);
3644fa9e4066Sahrens 
3645fa9e4066Sahrens 	/*
3646fa9e4066Sahrens 	 * Try to open it under the old name, which shouldn't exist
3647fa9e4066Sahrens 	 */
3648fa9e4066Sahrens 	error = spa_open(oldname, &spa, FTAG);
3649fa9e4066Sahrens 	if (error != ENOENT)
3650fa9e4066Sahrens 		fatal(0, "spa_open('%s') = %d", oldname, error);
3651fa9e4066Sahrens 
3652fa9e4066Sahrens 	/*
3653fa9e4066Sahrens 	 * Open it under the new name and make sure it's still the same spa_t.
3654fa9e4066Sahrens 	 */
3655fa9e4066Sahrens 	error = spa_open(newname, &spa, FTAG);
3656fa9e4066Sahrens 	if (error != 0)
3657fa9e4066Sahrens 		fatal(0, "spa_open('%s') = %d", newname, error);
3658fa9e4066Sahrens 
3659e05725b1Sbonwick 	ASSERT(spa == za->za_spa);
3660fa9e4066Sahrens 	spa_close(spa, FTAG);
3661fa9e4066Sahrens 
3662fa9e4066Sahrens 	/*
3663fa9e4066Sahrens 	 * Rename it back to the original
3664fa9e4066Sahrens 	 */
3665fa9e4066Sahrens 	error = spa_rename(newname, oldname);
3666fa9e4066Sahrens 	if (error)
3667fa9e4066Sahrens 		fatal(0, "spa_rename('%s', '%s') = %d", newname,
3668fa9e4066Sahrens 		    oldname, error);
3669fa9e4066Sahrens 
3670fa9e4066Sahrens 	/*
3671fa9e4066Sahrens 	 * Make sure it can still be opened
3672fa9e4066Sahrens 	 */
3673fa9e4066Sahrens 	error = spa_open(oldname, &spa, FTAG);
3674fa9e4066Sahrens 	if (error != 0)
3675fa9e4066Sahrens 		fatal(0, "spa_open('%s') = %d", oldname, error);
3676fa9e4066Sahrens 
3677e05725b1Sbonwick 	ASSERT(spa == za->za_spa);
3678fa9e4066Sahrens 	spa_close(spa, FTAG);
3679fa9e4066Sahrens 
3680fa9e4066Sahrens 	umem_free(newname, strlen(newname) + 1);
3681fa9e4066Sahrens 
3682fa9e4066Sahrens 	(void) rw_unlock(&ztest_shared->zs_name_lock);
3683fa9e4066Sahrens }
3684fa9e4066Sahrens 
3685fa9e4066Sahrens 
3686fa9e4066Sahrens /*
3687fa9e4066Sahrens  * Completely obliterate one disk.
3688fa9e4066Sahrens  */
3689fa9e4066Sahrens static void
3690fa9e4066Sahrens ztest_obliterate_one_disk(uint64_t vdev)
3691fa9e4066Sahrens {
3692fa9e4066Sahrens 	int fd;
3693d80c45e0Sbonwick 	char dev_name[MAXPATHLEN], copy_name[MAXPATHLEN];
3694fa9e4066Sahrens 	size_t fsize;
3695fa9e4066Sahrens 
3696fa9e4066Sahrens 	if (zopt_maxfaults < 2)
3697fa9e4066Sahrens 		return;
3698fa9e4066Sahrens 
3699fa9e4066Sahrens 	(void) sprintf(dev_name, ztest_dev_template, zopt_dir, zopt_pool, vdev);
3700d80c45e0Sbonwick 	(void) snprintf(copy_name, MAXPATHLEN, "%s.old", dev_name);
3701fa9e4066Sahrens 
3702fa9e4066Sahrens 	fd = open(dev_name, O_RDWR);
3703fa9e4066Sahrens 
3704fa9e4066Sahrens 	if (fd == -1)
3705fa9e4066Sahrens 		fatal(1, "can't open %s", dev_name);
3706fa9e4066Sahrens 
3707fa9e4066Sahrens 	/*
3708fa9e4066Sahrens 	 * Determine the size.
3709fa9e4066Sahrens 	 */
3710fa9e4066Sahrens 	fsize = lseek(fd, 0, SEEK_END);
3711d80c45e0Sbonwick 
3712fa9e4066Sahrens 	(void) close(fd);
3713fa9e4066Sahrens 
3714fa9e4066Sahrens 	/*
3715d80c45e0Sbonwick 	 * Rename the old device to dev_name.old (useful for debugging).
3716fa9e4066Sahrens 	 */
3717d80c45e0Sbonwick 	VERIFY(rename(dev_name, copy_name) == 0);
3718fa9e4066Sahrens 
3719fa9e4066Sahrens 	/*
3720fa9e4066Sahrens 	 * Create a new one.
3721fa9e4066Sahrens 	 */
3722fa9e4066Sahrens 	VERIFY((fd = open(dev_name, O_RDWR | O_CREAT | O_TRUNC, 0666)) >= 0);
3723fa9e4066Sahrens 	VERIFY(ftruncate(fd, fsize) == 0);
3724fa9e4066Sahrens 	(void) close(fd);
3725fa9e4066Sahrens }
3726fa9e4066Sahrens 
3727fa9e4066Sahrens static void
3728fa9e4066Sahrens ztest_replace_one_disk(spa_t *spa, uint64_t vdev)
3729fa9e4066Sahrens {
3730fa9e4066Sahrens 	char dev_name[MAXPATHLEN];
3731e14bb325SJeff Bonwick 	nvlist_t *root;
3732fa9e4066Sahrens 	int error;
3733ea8dc4b6Seschrock 	uint64_t guid;
3734ea8dc4b6Seschrock 	vdev_t *vd;
3735fa9e4066Sahrens 
3736fa9e4066Sahrens 	(void) sprintf(dev_name, ztest_dev_template, zopt_dir, zopt_pool, vdev);
3737fa9e4066Sahrens 
3738fa9e4066Sahrens 	/*
3739fa9e4066Sahrens 	 * Build the nvlist describing dev_name.
3740fa9e4066Sahrens 	 */
3741e14bb325SJeff Bonwick 	root = make_vdev_root(dev_name, NULL, 0, 0, 0, 0, 0, 1);
3742fa9e4066Sahrens 
3743e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
3744ea8dc4b6Seschrock 	if ((vd = vdev_lookup_by_path(spa->spa_root_vdev, dev_name)) == NULL)
3745ea8dc4b6Seschrock 		guid = 0;
3746ea8dc4b6Seschrock 	else
3747ea8dc4b6Seschrock 		guid = vd->vdev_guid;
3748e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_VDEV, FTAG);
3749ea8dc4b6Seschrock 	error = spa_vdev_attach(spa, guid, root, B_TRUE);
3750ecc2d604Sbonwick 	if (error != 0 &&
3751ecc2d604Sbonwick 	    error != EBUSY &&
3752ecc2d604Sbonwick 	    error != ENOTSUP &&
3753ecc2d604Sbonwick 	    error != ENODEV &&
3754ecc2d604Sbonwick 	    error != EDOM)
3755fa9e4066Sahrens 		fatal(0, "spa_vdev_attach(in-place) = %d", error);
3756fa9e4066Sahrens 
3757fa9e4066Sahrens 	nvlist_free(root);
3758fa9e4066Sahrens }
3759fa9e4066Sahrens 
3760fa9e4066Sahrens static void
3761fa9e4066Sahrens ztest_verify_blocks(char *pool)
3762fa9e4066Sahrens {
3763fa9e4066Sahrens 	int status;
3764fa9e4066Sahrens 	char zdb[MAXPATHLEN + MAXNAMELEN + 20];
3765fa9e4066Sahrens 	char zbuf[1024];
3766fa9e4066Sahrens 	char *bin;
37678654d025Sperrin 	char *ztest;
37688654d025Sperrin 	char *isa;
37698654d025Sperrin 	int isalen;
3770fa9e4066Sahrens 	FILE *fp;
3771fa9e4066Sahrens 
3772fa9e4066Sahrens 	(void) realpath(getexecname(), zdb);
3773fa9e4066Sahrens 
3774fa9e4066Sahrens 	/* zdb lives in /usr/sbin, while ztest lives in /usr/bin */
3775fa9e4066Sahrens 	bin = strstr(zdb, "/usr/bin/");
37768654d025Sperrin 	ztest = strstr(bin, "/ztest");
37778654d025Sperrin 	isa = bin + 8;
37788654d025Sperrin 	isalen = ztest - isa;
37798654d025Sperrin 	isa = strdup(isa);
3780fa9e4066Sahrens 	/* LINTED */
37813a57275aSck 	(void) sprintf(bin,
37826365109dSVictor Latushkin 	    "/usr/sbin%.*s/zdb -bcc%s%s -U /tmp/zpool.cache %s",
37838654d025Sperrin 	    isalen,
37848654d025Sperrin 	    isa,
3785fa9e4066Sahrens 	    zopt_verbose >= 3 ? "s" : "",
3786fa9e4066Sahrens 	    zopt_verbose >= 4 ? "v" : "",
378788b7b0f2SMatthew Ahrens 	    pool);
37888654d025Sperrin 	free(isa);
3789fa9e4066Sahrens 
3790fa9e4066Sahrens 	if (zopt_verbose >= 5)
3791fa9e4066Sahrens 		(void) printf("Executing %s\n", strstr(zdb, "zdb "));
3792fa9e4066Sahrens 
3793fa9e4066Sahrens 	fp = popen(zdb, "r");
3794fa9e4066Sahrens 
3795fa9e4066Sahrens 	while (fgets(zbuf, sizeof (zbuf), fp) != NULL)
3796fa9e4066Sahrens 		if (zopt_verbose >= 3)
3797fa9e4066Sahrens 			(void) printf("%s", zbuf);
3798fa9e4066Sahrens 
3799fa9e4066Sahrens 	status = pclose(fp);
3800fa9e4066Sahrens 
3801fa9e4066Sahrens 	if (status == 0)
3802fa9e4066Sahrens 		return;
3803fa9e4066Sahrens 
3804fa9e4066Sahrens 	ztest_dump_core = 0;
3805fa9e4066Sahrens 	if (WIFEXITED(status))
3806fa9e4066Sahrens 		fatal(0, "'%s' exit code %d", zdb, WEXITSTATUS(status));
3807fa9e4066Sahrens 	else
3808fa9e4066Sahrens 		fatal(0, "'%s' died with signal %d", zdb, WTERMSIG(status));
3809fa9e4066Sahrens }
3810fa9e4066Sahrens 
3811fa9e4066Sahrens static void
3812fa9e4066Sahrens ztest_walk_pool_directory(char *header)
3813fa9e4066Sahrens {
3814fa9e4066Sahrens 	spa_t *spa = NULL;
3815fa9e4066Sahrens 
3816fa9e4066Sahrens 	if (zopt_verbose >= 6)
3817fa9e4066Sahrens 		(void) printf("%s\n", header);
3818fa9e4066Sahrens 
3819fa9e4066Sahrens 	mutex_enter(&spa_namespace_lock);
3820fa9e4066Sahrens 	while ((spa = spa_next(spa)) != NULL)
3821fa9e4066Sahrens 		if (zopt_verbose >= 6)
3822fa9e4066Sahrens 			(void) printf("\t%s\n", spa_name(spa));
3823fa9e4066Sahrens 	mutex_exit(&spa_namespace_lock);
3824fa9e4066Sahrens }
3825fa9e4066Sahrens 
3826fa9e4066Sahrens static void
3827fa9e4066Sahrens ztest_spa_import_export(char *oldname, char *newname)
3828fa9e4066Sahrens {
38298ad4d6ddSJeff Bonwick 	nvlist_t *config, *newconfig;
3830fa9e4066Sahrens 	uint64_t pool_guid;
3831fa9e4066Sahrens 	spa_t *spa;
3832fa9e4066Sahrens 	int error;
3833fa9e4066Sahrens 
3834fa9e4066Sahrens 	if (zopt_verbose >= 4) {
3835fa9e4066Sahrens 		(void) printf("import/export: old = %s, new = %s\n",
3836fa9e4066Sahrens 		    oldname, newname);
3837fa9e4066Sahrens 	}
3838fa9e4066Sahrens 
3839fa9e4066Sahrens 	/*
3840fa9e4066Sahrens 	 * Clean up from previous runs.
3841fa9e4066Sahrens 	 */
3842fa9e4066Sahrens 	(void) spa_destroy(newname);
3843fa9e4066Sahrens 
3844fa9e4066Sahrens 	/*
3845fa9e4066Sahrens 	 * Get the pool's configuration and guid.
3846fa9e4066Sahrens 	 */
3847fa9e4066Sahrens 	error = spa_open(oldname, &spa, FTAG);
3848fa9e4066Sahrens 	if (error)
3849fa9e4066Sahrens 		fatal(0, "spa_open('%s') = %d", oldname, error);
3850fa9e4066Sahrens 
38518ad4d6ddSJeff Bonwick 	/*
38528ad4d6ddSJeff Bonwick 	 * Kick off a scrub to tickle scrub/export races.
38538ad4d6ddSJeff Bonwick 	 */
38548ad4d6ddSJeff Bonwick 	if (ztest_random(2) == 0)
38558ad4d6ddSJeff Bonwick 		(void) spa_scrub(spa, POOL_SCRUB_EVERYTHING);
38568ad4d6ddSJeff Bonwick 
3857fa9e4066Sahrens 	pool_guid = spa_guid(spa);
3858fa9e4066Sahrens 	spa_close(spa, FTAG);
3859fa9e4066Sahrens 
3860fa9e4066Sahrens 	ztest_walk_pool_directory("pools before export");
3861fa9e4066Sahrens 
3862fa9e4066Sahrens 	/*
3863fa9e4066Sahrens 	 * Export it.
3864fa9e4066Sahrens 	 */
3865394ab0cbSGeorge Wilson 	error = spa_export(oldname, &config, B_FALSE, B_FALSE);
3866fa9e4066Sahrens 	if (error)
3867fa9e4066Sahrens 		fatal(0, "spa_export('%s') = %d", oldname, error);
3868fa9e4066Sahrens 
3869fa9e4066Sahrens 	ztest_walk_pool_directory("pools after export");
3870fa9e4066Sahrens 
38718ad4d6ddSJeff Bonwick 	/*
38728ad4d6ddSJeff Bonwick 	 * Try to import it.
38738ad4d6ddSJeff Bonwick 	 */
38748ad4d6ddSJeff Bonwick 	newconfig = spa_tryimport(config);
38758ad4d6ddSJeff Bonwick 	ASSERT(newconfig != NULL);
38768ad4d6ddSJeff Bonwick 	nvlist_free(newconfig);
38778ad4d6ddSJeff Bonwick 
3878fa9e4066Sahrens 	/*
3879fa9e4066Sahrens 	 * Import it under the new name.
3880fa9e4066Sahrens 	 */
3881fa9e4066Sahrens 	error = spa_import(newname, config, NULL);
3882fa9e4066Sahrens 	if (error)
3883fa9e4066Sahrens 		fatal(0, "spa_import('%s') = %d", newname, error);
3884fa9e4066Sahrens 
3885fa9e4066Sahrens 	ztest_walk_pool_directory("pools after import");
3886fa9e4066Sahrens 
3887fa9e4066Sahrens 	/*
3888fa9e4066Sahrens 	 * Try to import it again -- should fail with EEXIST.
3889fa9e4066Sahrens 	 */
3890fa9e4066Sahrens 	error = spa_import(newname, config, NULL);
3891fa9e4066Sahrens 	if (error != EEXIST)
3892fa9e4066Sahrens 		fatal(0, "spa_import('%s') twice", newname);
3893fa9e4066Sahrens 
3894fa9e4066Sahrens 	/*
3895fa9e4066Sahrens 	 * Try to import it under a different name -- should fail with EEXIST.
3896fa9e4066Sahrens 	 */
3897fa9e4066Sahrens 	error = spa_import(oldname, config, NULL);
3898fa9e4066Sahrens 	if (error != EEXIST)
3899fa9e4066Sahrens 		fatal(0, "spa_import('%s') under multiple names", newname);
3900fa9e4066Sahrens 
3901fa9e4066Sahrens 	/*
3902fa9e4066Sahrens 	 * Verify that the pool is no longer visible under the old name.
3903fa9e4066Sahrens 	 */
3904fa9e4066Sahrens 	error = spa_open(oldname, &spa, FTAG);
3905fa9e4066Sahrens 	if (error != ENOENT)
3906fa9e4066Sahrens 		fatal(0, "spa_open('%s') = %d", newname, error);
3907fa9e4066Sahrens 
3908fa9e4066Sahrens 	/*
3909fa9e4066Sahrens 	 * Verify that we can open and close the pool using the new name.
3910fa9e4066Sahrens 	 */
3911fa9e4066Sahrens 	error = spa_open(newname, &spa, FTAG);
3912fa9e4066Sahrens 	if (error)
3913fa9e4066Sahrens 		fatal(0, "spa_open('%s') = %d", newname, error);
3914fa9e4066Sahrens 	ASSERT(pool_guid == spa_guid(spa));
3915fa9e4066Sahrens 	spa_close(spa, FTAG);
3916fa9e4066Sahrens 
3917fa9e4066Sahrens 	nvlist_free(config);
3918fa9e4066Sahrens }
3919fa9e4066Sahrens 
39208ad4d6ddSJeff Bonwick static void
39218ad4d6ddSJeff Bonwick ztest_resume(spa_t *spa)
39228ad4d6ddSJeff Bonwick {
39238ad4d6ddSJeff Bonwick 	if (spa_suspended(spa)) {
39248ad4d6ddSJeff Bonwick 		spa_vdev_state_enter(spa);
39258ad4d6ddSJeff Bonwick 		vdev_clear(spa, NULL);
39268ad4d6ddSJeff Bonwick 		(void) spa_vdev_state_exit(spa, NULL, 0);
392754d692b7SGeorge Wilson 		(void) zio_resume(spa);
39288ad4d6ddSJeff Bonwick 	}
39298ad4d6ddSJeff Bonwick }
39308ad4d6ddSJeff Bonwick 
39310a4e9518Sgw static void *
39328ad4d6ddSJeff Bonwick ztest_resume_thread(void *arg)
39330a4e9518Sgw {
3934e14bb325SJeff Bonwick 	spa_t *spa = arg;
39350a4e9518Sgw 
39360a4e9518Sgw 	while (!ztest_exiting) {
3937e14bb325SJeff Bonwick 		(void) poll(NULL, 0, 1000);
39388ad4d6ddSJeff Bonwick 		ztest_resume(spa);
39390a4e9518Sgw 	}
39400a4e9518Sgw 	return (NULL);
39410a4e9518Sgw }
39420a4e9518Sgw 
3943fa9e4066Sahrens static void *
3944fa9e4066Sahrens ztest_thread(void *arg)
3945fa9e4066Sahrens {
3946fa9e4066Sahrens 	ztest_args_t *za = arg;
3947fa9e4066Sahrens 	ztest_shared_t *zs = ztest_shared;
3948fa9e4066Sahrens 	hrtime_t now, functime;
3949fa9e4066Sahrens 	ztest_info_t *zi;
3950e05725b1Sbonwick 	int f, i;
3951fa9e4066Sahrens 
3952fa9e4066Sahrens 	while ((now = gethrtime()) < za->za_stop) {
3953fa9e4066Sahrens 		/*
3954fa9e4066Sahrens 		 * See if it's time to force a crash.
3955fa9e4066Sahrens 		 */
3956fa9e4066Sahrens 		if (now > za->za_kill) {
3957e05725b1Sbonwick 			zs->zs_alloc = spa_get_alloc(za->za_spa);
3958e05725b1Sbonwick 			zs->zs_space = spa_get_space(za->za_spa);
3959fa9e4066Sahrens 			(void) kill(getpid(), SIGKILL);
3960fa9e4066Sahrens 		}
3961fa9e4066Sahrens 
3962fa9e4066Sahrens 		/*
3963fa9e4066Sahrens 		 * Pick a random function.
3964fa9e4066Sahrens 		 */
3965fa9e4066Sahrens 		f = ztest_random(ZTEST_FUNCS);
3966fa9e4066Sahrens 		zi = &zs->zs_info[f];
3967fa9e4066Sahrens 
3968fa9e4066Sahrens 		/*
3969fa9e4066Sahrens 		 * Decide whether to call it, based on the requested frequency.
3970fa9e4066Sahrens 		 */
3971fa9e4066Sahrens 		if (zi->zi_call_target == 0 ||
3972fa9e4066Sahrens 		    (double)zi->zi_call_total / zi->zi_call_target >
3973fa9e4066Sahrens 		    (double)(now - zs->zs_start_time) / (zopt_time * NANOSEC))
3974fa9e4066Sahrens 			continue;
3975fa9e4066Sahrens 
3976fa9e4066Sahrens 		atomic_add_64(&zi->zi_calls, 1);
3977fa9e4066Sahrens 		atomic_add_64(&zi->zi_call_total, 1);
3978fa9e4066Sahrens 
3979fa9e4066Sahrens 		za->za_diroff = (za->za_instance * ZTEST_FUNCS + f) *
3980fa9e4066Sahrens 		    ZTEST_DIRSIZE;
3981fa9e4066Sahrens 		za->za_diroff_shared = (1ULL << 63);
3982fa9e4066Sahrens 
3983e05725b1Sbonwick 		for (i = 0; i < zi->zi_iters; i++)
3984e05725b1Sbonwick 			zi->zi_func(za);
3985fa9e4066Sahrens 
3986fa9e4066Sahrens 		functime = gethrtime() - now;
3987fa9e4066Sahrens 
3988fa9e4066Sahrens 		atomic_add_64(&zi->zi_call_time, functime);
3989fa9e4066Sahrens 
3990fa9e4066Sahrens 		if (zopt_verbose >= 4) {
3991fa9e4066Sahrens 			Dl_info dli;
3992fa9e4066Sahrens 			(void) dladdr((void *)zi->zi_func, &dli);
3993fa9e4066Sahrens 			(void) printf("%6.2f sec in %s\n",
3994fa9e4066Sahrens 			    (double)functime / NANOSEC, dli.dli_sname);
3995fa9e4066Sahrens 		}
3996fa9e4066Sahrens 
3997fa9e4066Sahrens 		/*
3998fa9e4066Sahrens 		 * If we're getting ENOSPC with some regularity, stop.
3999fa9e4066Sahrens 		 */
4000fa9e4066Sahrens 		if (zs->zs_enospc_count > 10)
4001fa9e4066Sahrens 			break;
4002fa9e4066Sahrens 	}
4003fa9e4066Sahrens 
4004fa9e4066Sahrens 	return (NULL);
4005fa9e4066Sahrens }
4006fa9e4066Sahrens 
4007fa9e4066Sahrens /*
4008fa9e4066Sahrens  * Kick off threads to run tests on all datasets in parallel.
4009fa9e4066Sahrens  */
4010fa9e4066Sahrens static void
4011fa9e4066Sahrens ztest_run(char *pool)
4012fa9e4066Sahrens {
4013fa9e4066Sahrens 	int t, d, error;
4014fa9e4066Sahrens 	ztest_shared_t *zs = ztest_shared;
4015fa9e4066Sahrens 	ztest_args_t *za;
4016fa9e4066Sahrens 	spa_t *spa;
4017fa9e4066Sahrens 	char name[100];
4018e14bb325SJeff Bonwick 	thread_t resume_tid;
4019e14bb325SJeff Bonwick 
4020e14bb325SJeff Bonwick 	ztest_exiting = B_FALSE;
4021fa9e4066Sahrens 
4022fa9e4066Sahrens 	(void) _mutex_init(&zs->zs_vdev_lock, USYNC_THREAD, NULL);
4023fa9e4066Sahrens 	(void) rwlock_init(&zs->zs_name_lock, USYNC_THREAD, NULL);
4024fa9e4066Sahrens 
4025*d20e665cSRicardo M. Correia 	(void) _mutex_init(&zcl.zcl_callbacks_lock, USYNC_THREAD,
4026*d20e665cSRicardo M. Correia 	    NULL);
4027*d20e665cSRicardo M. Correia 
4028*d20e665cSRicardo M. Correia 	list_create(&zcl.zcl_callbacks, sizeof (ztest_cb_data_t),
4029*d20e665cSRicardo M. Correia 	    offsetof(ztest_cb_data_t, zcd_node));
4030*d20e665cSRicardo M. Correia 
4031fa9e4066Sahrens 	for (t = 0; t < ZTEST_SYNC_LOCKS; t++)
4032fa9e4066Sahrens 		(void) _mutex_init(&zs->zs_sync_lock[t], USYNC_THREAD, NULL);
4033fa9e4066Sahrens 
4034fa9e4066Sahrens 	/*
4035fa9e4066Sahrens 	 * Destroy one disk before we even start.
4036fa9e4066Sahrens 	 * It's mirrored, so everything should work just fine.
4037fa9e4066Sahrens 	 * This makes us exercise fault handling very early in spa_load().
4038fa9e4066Sahrens 	 */
4039fa9e4066Sahrens 	ztest_obliterate_one_disk(0);
4040fa9e4066Sahrens 
4041fa9e4066Sahrens 	/*
4042fa9e4066Sahrens 	 * Verify that the sum of the sizes of all blocks in the pool
4043fa9e4066Sahrens 	 * equals the SPA's allocated space total.
4044fa9e4066Sahrens 	 */
4045fa9e4066Sahrens 	ztest_verify_blocks(pool);
4046fa9e4066Sahrens 
4047fa9e4066Sahrens 	/*
4048fa9e4066Sahrens 	 * Kick off a replacement of the disk we just obliterated.
4049fa9e4066Sahrens 	 */
4050fa9e4066Sahrens 	kernel_init(FREAD | FWRITE);
4051e14bb325SJeff Bonwick 	VERIFY(spa_open(pool, &spa, FTAG) == 0);
4052fa9e4066Sahrens 	ztest_replace_one_disk(spa, 0);
4053fa9e4066Sahrens 	if (zopt_verbose >= 5)
4054fa9e4066Sahrens 		show_pool_stats(spa);
4055fa9e4066Sahrens 	spa_close(spa, FTAG);
4056fa9e4066Sahrens 	kernel_fini();
4057fa9e4066Sahrens 
4058fa9e4066Sahrens 	kernel_init(FREAD | FWRITE);
4059fa9e4066Sahrens 
4060fa9e4066Sahrens 	/*
4061fa9e4066Sahrens 	 * Verify that we can export the pool and reimport it under a
4062fa9e4066Sahrens 	 * different name.
4063fa9e4066Sahrens 	 */
40640e34b6a7Sbonwick 	if (ztest_random(2) == 0) {
40650e34b6a7Sbonwick 		(void) snprintf(name, 100, "%s_import", pool);
40660e34b6a7Sbonwick 		ztest_spa_import_export(pool, name);
40670e34b6a7Sbonwick 		ztest_spa_import_export(name, pool);
40680e34b6a7Sbonwick 	}
4069fa9e4066Sahrens 
4070fa9e4066Sahrens 	/*
4071fa9e4066Sahrens 	 * Verify that we can loop over all pools.
4072fa9e4066Sahrens 	 */
4073fa9e4066Sahrens 	mutex_enter(&spa_namespace_lock);
4074fa9e4066Sahrens 	for (spa = spa_next(NULL); spa != NULL; spa = spa_next(spa)) {
4075fa9e4066Sahrens 		if (zopt_verbose > 3) {
4076fa9e4066Sahrens 			(void) printf("spa_next: found %s\n", spa_name(spa));
4077fa9e4066Sahrens 		}
4078fa9e4066Sahrens 	}
4079fa9e4066Sahrens 	mutex_exit(&spa_namespace_lock);
4080fa9e4066Sahrens 
40810a4e9518Sgw 	/*
4082e14bb325SJeff Bonwick 	 * Open our pool.
40830a4e9518Sgw 	 */
4084e14bb325SJeff Bonwick 	VERIFY(spa_open(pool, &spa, FTAG) == 0);
40850a4e9518Sgw 
40868ad4d6ddSJeff Bonwick 	/*
40878ad4d6ddSJeff Bonwick 	 * We don't expect the pool to suspend unless maxfaults == 0,
40888ad4d6ddSJeff Bonwick 	 * in which case ztest_fault_inject() temporarily takes away
40898ad4d6ddSJeff Bonwick 	 * the only valid replica.
40908ad4d6ddSJeff Bonwick 	 */
40918ad4d6ddSJeff Bonwick 	if (zopt_maxfaults == 0)
40928ad4d6ddSJeff Bonwick 		spa->spa_failmode = ZIO_FAILURE_MODE_WAIT;
40938ad4d6ddSJeff Bonwick 	else
40948ad4d6ddSJeff Bonwick 		spa->spa_failmode = ZIO_FAILURE_MODE_PANIC;
40958ad4d6ddSJeff Bonwick 
4096fa9e4066Sahrens 	/*
4097e14bb325SJeff Bonwick 	 * Create a thread to periodically resume suspended I/O.
4098fa9e4066Sahrens 	 */
40998ad4d6ddSJeff Bonwick 	VERIFY(thr_create(0, 0, ztest_resume_thread, spa, THR_BOUND,
4100e14bb325SJeff Bonwick 	    &resume_tid) == 0);
4101fa9e4066Sahrens 
4102fa9e4066Sahrens 	/*
4103fa9e4066Sahrens 	 * Verify that we can safely inquire about about any object,
4104fa9e4066Sahrens 	 * whether it's allocated or not.  To make it interesting,
4105fa9e4066Sahrens 	 * we probe a 5-wide window around each power of two.
4106fa9e4066Sahrens 	 * This hits all edge cases, including zero and the max.
4107fa9e4066Sahrens 	 */
4108fa9e4066Sahrens 	for (t = 0; t < 64; t++) {
4109fa9e4066Sahrens 		for (d = -5; d <= 5; d++) {
4110fa9e4066Sahrens 			error = dmu_object_info(spa->spa_meta_objset,
4111fa9e4066Sahrens 			    (1ULL << t) + d, NULL);
4112ea8dc4b6Seschrock 			ASSERT(error == 0 || error == ENOENT ||
4113ea8dc4b6Seschrock 			    error == EINVAL);
4114fa9e4066Sahrens 		}
4115fa9e4066Sahrens 	}
4116fa9e4066Sahrens 
4117fa9e4066Sahrens 	/*
4118fa9e4066Sahrens 	 * Now kick off all the tests that run in parallel.
4119fa9e4066Sahrens 	 */
4120fa9e4066Sahrens 	zs->zs_enospc_count = 0;
4121fa9e4066Sahrens 
4122fa9e4066Sahrens 	za = umem_zalloc(zopt_threads * sizeof (ztest_args_t), UMEM_NOFAIL);
4123fa9e4066Sahrens 
4124fa9e4066Sahrens 	if (zopt_verbose >= 4)
4125fa9e4066Sahrens 		(void) printf("starting main threads...\n");
4126fa9e4066Sahrens 
4127fa9e4066Sahrens 	za[0].za_start = gethrtime();
4128fa9e4066Sahrens 	za[0].za_stop = za[0].za_start + zopt_passtime * NANOSEC;
4129fa9e4066Sahrens 	za[0].za_stop = MIN(za[0].za_stop, zs->zs_stop_time);
4130fa9e4066Sahrens 	za[0].za_kill = za[0].za_stop;
4131fa9e4066Sahrens 	if (ztest_random(100) < zopt_killrate)
4132fa9e4066Sahrens 		za[0].za_kill -= ztest_random(zopt_passtime * NANOSEC);
4133fa9e4066Sahrens 
4134fa9e4066Sahrens 	for (t = 0; t < zopt_threads; t++) {
4135ecc2d604Sbonwick 		d = t % zopt_datasets;
4136e05725b1Sbonwick 
4137e05725b1Sbonwick 		(void) strcpy(za[t].za_pool, pool);
4138e05725b1Sbonwick 		za[t].za_os = za[d].za_os;
4139e05725b1Sbonwick 		za[t].za_spa = spa;
4140e05725b1Sbonwick 		za[t].za_zilog = za[d].za_zilog;
4141e05725b1Sbonwick 		za[t].za_instance = t;
4142e05725b1Sbonwick 		za[t].za_random = ztest_random(-1ULL);
4143e05725b1Sbonwick 		za[t].za_start = za[0].za_start;
4144e05725b1Sbonwick 		za[t].za_stop = za[0].za_stop;
4145e05725b1Sbonwick 		za[t].za_kill = za[0].za_kill;
4146e05725b1Sbonwick 
4147ecc2d604Sbonwick 		if (t < zopt_datasets) {
41484d31c452Smaybee 			int test_future = FALSE;
4149fa9e4066Sahrens 			(void) rw_rdlock(&ztest_shared->zs_name_lock);
4150fa9e4066Sahrens 			(void) snprintf(name, 100, "%s/%s_%d", pool, pool, d);
4151ae46e4c7SMatthew Ahrens 			error = dmu_objset_create(name, DMU_OST_OTHER, 0,
4152fa9e4066Sahrens 			    ztest_create_cb, NULL);
41534d31c452Smaybee 			if (error == EEXIST) {
41544d31c452Smaybee 				test_future = TRUE;
4155e05725b1Sbonwick 			} else if (error == ENOSPC) {
4156e05725b1Sbonwick 				zs->zs_enospc_count++;
4157e05725b1Sbonwick 				(void) rw_unlock(&ztest_shared->zs_name_lock);
4158e05725b1Sbonwick 				break;
41594d31c452Smaybee 			} else if (error != 0) {
4160fa9e4066Sahrens 				fatal(0, "dmu_objset_create(%s) = %d",
4161fa9e4066Sahrens 				    name, error);
4162fa9e4066Sahrens 			}
4163503ad85cSMatthew Ahrens 			error = dmu_objset_hold(name, FTAG, &za[d].za_os);
4164fa9e4066Sahrens 			if (error)
4165fa9e4066Sahrens 				fatal(0, "dmu_objset_open('%s') = %d",
4166fa9e4066Sahrens 				    name, error);
4167fa9e4066Sahrens 			(void) rw_unlock(&ztest_shared->zs_name_lock);
4168e05725b1Sbonwick 			if (test_future)
4169e05725b1Sbonwick 				ztest_dmu_check_future_leak(&za[t]);
41701209a471SNeil Perrin 			zil_replay(za[d].za_os, za[d].za_os,
41711209a471SNeil Perrin 			    ztest_replay_vector);
4172fa9e4066Sahrens 			za[d].za_zilog = zil_open(za[d].za_os, NULL);
4173fa9e4066Sahrens 		}
4174fa9e4066Sahrens 
4175e14bb325SJeff Bonwick 		VERIFY(thr_create(0, 0, ztest_thread, &za[t], THR_BOUND,
4176e14bb325SJeff Bonwick 		    &za[t].za_thread) == 0);
4177fa9e4066Sahrens 	}
4178fa9e4066Sahrens 
4179fa9e4066Sahrens 	while (--t >= 0) {
4180e14bb325SJeff Bonwick 		VERIFY(thr_join(za[t].za_thread, NULL, NULL) == 0);
4181ecc2d604Sbonwick 		if (t < zopt_datasets) {
4182fa9e4066Sahrens 			zil_close(za[t].za_zilog);
4183503ad85cSMatthew Ahrens 			dmu_objset_rele(za[t].za_os, FTAG);
4184fa9e4066Sahrens 		}
4185fa9e4066Sahrens 	}
4186fa9e4066Sahrens 
4187fa9e4066Sahrens 	if (zopt_verbose >= 3)
4188fa9e4066Sahrens 		show_pool_stats(spa);
4189fa9e4066Sahrens 
4190fa9e4066Sahrens 	txg_wait_synced(spa_get_dsl(spa), 0);
4191fa9e4066Sahrens 
4192fa9e4066Sahrens 	zs->zs_alloc = spa_get_alloc(spa);
4193fa9e4066Sahrens 	zs->zs_space = spa_get_space(spa);
4194fa9e4066Sahrens 
4195fa9e4066Sahrens 	/*
4196e05725b1Sbonwick 	 * If we had out-of-space errors, destroy a random objset.
4197fa9e4066Sahrens 	 */
4198fa9e4066Sahrens 	if (zs->zs_enospc_count != 0) {
4199fa9e4066Sahrens 		(void) rw_rdlock(&ztest_shared->zs_name_lock);
4200e05725b1Sbonwick 		d = (int)ztest_random(zopt_datasets);
4201e05725b1Sbonwick 		(void) snprintf(name, 100, "%s/%s_%d", pool, pool, d);
4202fa9e4066Sahrens 		if (zopt_verbose >= 3)
4203fa9e4066Sahrens 			(void) printf("Destroying %s to free up space\n", name);
4204718d718aSGeorge Wilson 
4205718d718aSGeorge Wilson 		/* Cleanup any non-standard clones and snapshots */
4206718d718aSGeorge Wilson 		ztest_dsl_dataset_cleanup(name, za[d].za_instance);
4207718d718aSGeorge Wilson 
4208e05725b1Sbonwick 		(void) dmu_objset_find(name, ztest_destroy_cb, &za[d],
42090b69c2f0Sahrens 		    DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
4210fa9e4066Sahrens 		(void) rw_unlock(&ztest_shared->zs_name_lock);
4211fa9e4066Sahrens 	}
4212fa9e4066Sahrens 
4213ea8dc4b6Seschrock 	txg_wait_synced(spa_get_dsl(spa), 0);
4214fa9e4066Sahrens 
4215e14bb325SJeff Bonwick 	umem_free(za, zopt_threads * sizeof (ztest_args_t));
4216e14bb325SJeff Bonwick 
4217e14bb325SJeff Bonwick 	/* Kill the resume thread */
4218e14bb325SJeff Bonwick 	ztest_exiting = B_TRUE;
4219e14bb325SJeff Bonwick 	VERIFY(thr_join(resume_tid, NULL, NULL) == 0);
42208ad4d6ddSJeff Bonwick 	ztest_resume(spa);
4221e14bb325SJeff Bonwick 
4222fa9e4066Sahrens 	/*
4223fa9e4066Sahrens 	 * Right before closing the pool, kick off a bunch of async I/O;
4224fa9e4066Sahrens 	 * spa_close() should wait for it to complete.
4225fa9e4066Sahrens 	 */
4226fa9e4066Sahrens 	for (t = 1; t < 50; t++)
4227fa9e4066Sahrens 		dmu_prefetch(spa->spa_meta_objset, t, 0, 1 << 15);
4228fa9e4066Sahrens 
4229e05725b1Sbonwick 	spa_close(spa, FTAG);
4230e05725b1Sbonwick 
4231fa9e4066Sahrens 	kernel_fini();
4232*d20e665cSRicardo M. Correia 
4233*d20e665cSRicardo M. Correia 	list_destroy(&zcl.zcl_callbacks);
4234*d20e665cSRicardo M. Correia 
4235*d20e665cSRicardo M. Correia 	(void) _mutex_destroy(&zcl.zcl_callbacks_lock);
4236*d20e665cSRicardo M. Correia 
4237*d20e665cSRicardo M. Correia 	(void) rwlock_destroy(&zs->zs_name_lock);
4238*d20e665cSRicardo M. Correia 	(void) _mutex_destroy(&zs->zs_vdev_lock);
4239fa9e4066Sahrens }
4240fa9e4066Sahrens 
4241fa9e4066Sahrens void
4242fa9e4066Sahrens print_time(hrtime_t t, char *timebuf)
4243fa9e4066Sahrens {
4244fa9e4066Sahrens 	hrtime_t s = t / NANOSEC;
4245fa9e4066Sahrens 	hrtime_t m = s / 60;
4246fa9e4066Sahrens 	hrtime_t h = m / 60;
4247fa9e4066Sahrens 	hrtime_t d = h / 24;
4248fa9e4066Sahrens 
4249fa9e4066Sahrens 	s -= m * 60;
4250fa9e4066Sahrens 	m -= h * 60;
4251fa9e4066Sahrens 	h -= d * 24;
4252fa9e4066Sahrens 
4253fa9e4066Sahrens 	timebuf[0] = '\0';
4254fa9e4066Sahrens 
4255fa9e4066Sahrens 	if (d)
4256fa9e4066Sahrens 		(void) sprintf(timebuf,
4257fa9e4066Sahrens 		    "%llud%02lluh%02llum%02llus", d, h, m, s);
4258fa9e4066Sahrens 	else if (h)
4259fa9e4066Sahrens 		(void) sprintf(timebuf, "%lluh%02llum%02llus", h, m, s);
4260fa9e4066Sahrens 	else if (m)
4261fa9e4066Sahrens 		(void) sprintf(timebuf, "%llum%02llus", m, s);
4262fa9e4066Sahrens 	else
4263fa9e4066Sahrens 		(void) sprintf(timebuf, "%llus", s);
4264fa9e4066Sahrens }
4265fa9e4066Sahrens 
4266fa9e4066Sahrens /*
4267fa9e4066Sahrens  * Create a storage pool with the given name and initial vdev size.
4268fa9e4066Sahrens  * Then create the specified number of datasets in the pool.
4269fa9e4066Sahrens  */
4270fa9e4066Sahrens static void
4271fa9e4066Sahrens ztest_init(char *pool)
4272fa9e4066Sahrens {
4273fa9e4066Sahrens 	spa_t *spa;
4274fa9e4066Sahrens 	int error;
4275fa9e4066Sahrens 	nvlist_t *nvroot;
4276fa9e4066Sahrens 
4277fa9e4066Sahrens 	kernel_init(FREAD | FWRITE);
4278fa9e4066Sahrens 
4279fa9e4066Sahrens 	/*
4280fa9e4066Sahrens 	 * Create the storage pool.
4281fa9e4066Sahrens 	 */
4282fa9e4066Sahrens 	(void) spa_destroy(pool);
428388ecc943SGeorge Wilson 	ztest_shared->zs_vdev_next_leaf = 0;
4284e14bb325SJeff Bonwick 	nvroot = make_vdev_root(NULL, NULL, zopt_vdev_size, 0,
4285e14bb325SJeff Bonwick 	    0, zopt_raidz, zopt_mirrors, 1);
42860a48a24eStimh 	error = spa_create(pool, nvroot, NULL, NULL, NULL);
4287fa9e4066Sahrens 	nvlist_free(nvroot);
4288fa9e4066Sahrens 
4289fa9e4066Sahrens 	if (error)
4290fa9e4066Sahrens 		fatal(0, "spa_create() = %d", error);
4291fa9e4066Sahrens 	error = spa_open(pool, &spa, FTAG);
4292fa9e4066Sahrens 	if (error)
4293fa9e4066Sahrens 		fatal(0, "spa_open() = %d", error);
4294fa9e4066Sahrens 
4295d6e555bdSGeorge Wilson 	metaslab_sz = 1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
4296d6e555bdSGeorge Wilson 
4297fa9e4066Sahrens 	if (zopt_verbose >= 3)
4298fa9e4066Sahrens 		show_pool_stats(spa);
4299fa9e4066Sahrens 
4300fa9e4066Sahrens 	spa_close(spa, FTAG);
4301fa9e4066Sahrens 
4302fa9e4066Sahrens 	kernel_fini();
4303fa9e4066Sahrens }
4304fa9e4066Sahrens 
4305fa9e4066Sahrens int
4306fa9e4066Sahrens main(int argc, char **argv)
4307fa9e4066Sahrens {
4308fa9e4066Sahrens 	int kills = 0;
4309fa9e4066Sahrens 	int iters = 0;
4310fa9e4066Sahrens 	int i, f;
4311fa9e4066Sahrens 	ztest_shared_t *zs;
4312fa9e4066Sahrens 	ztest_info_t *zi;
4313fa9e4066Sahrens 	char timebuf[100];
4314fa9e4066Sahrens 	char numbuf[6];
4315fa9e4066Sahrens 
4316fa9e4066Sahrens 	(void) setvbuf(stdout, NULL, _IOLBF, 0);
4317fa9e4066Sahrens 
4318fa9e4066Sahrens 	/* Override location of zpool.cache */
4319c5904d13Seschrock 	spa_config_path = "/tmp/zpool.cache";
4320fa9e4066Sahrens 
4321fa9e4066Sahrens 	ztest_random_fd = open("/dev/urandom", O_RDONLY);
4322fa9e4066Sahrens 
4323fa9e4066Sahrens 	process_options(argc, argv);
4324fa9e4066Sahrens 
4325ea8dc4b6Seschrock 	/*
4326ea8dc4b6Seschrock 	 * Blow away any existing copy of zpool.cache
4327ea8dc4b6Seschrock 	 */
4328ea8dc4b6Seschrock 	if (zopt_init != 0)
4329ea8dc4b6Seschrock 		(void) remove("/tmp/zpool.cache");
4330ea8dc4b6Seschrock 
4331fa9e4066Sahrens 	zs = ztest_shared = (void *)mmap(0,
4332fa9e4066Sahrens 	    P2ROUNDUP(sizeof (ztest_shared_t), getpagesize()),
4333fa9e4066Sahrens 	    PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
4334fa9e4066Sahrens 
4335fa9e4066Sahrens 	if (zopt_verbose >= 1) {
4336fa9e4066Sahrens 		(void) printf("%llu vdevs, %d datasets, %d threads,"
4337fa9e4066Sahrens 		    " %llu seconds...\n",
4338ecc2d604Sbonwick 		    (u_longlong_t)zopt_vdevs, zopt_datasets, zopt_threads,
4339fa9e4066Sahrens 		    (u_longlong_t)zopt_time);
4340fa9e4066Sahrens 	}
4341fa9e4066Sahrens 
4342fa9e4066Sahrens 	/*
4343fa9e4066Sahrens 	 * Create and initialize our storage pool.
4344fa9e4066Sahrens 	 */
4345fa9e4066Sahrens 	for (i = 1; i <= zopt_init; i++) {
4346fa9e4066Sahrens 		bzero(zs, sizeof (ztest_shared_t));
4347fa9e4066Sahrens 		if (zopt_verbose >= 3 && zopt_init != 1)
4348fa9e4066Sahrens 			(void) printf("ztest_init(), pass %d\n", i);
4349fa9e4066Sahrens 		ztest_init(zopt_pool);
4350fa9e4066Sahrens 	}
4351fa9e4066Sahrens 
4352fa9e4066Sahrens 	/*
4353fa9e4066Sahrens 	 * Initialize the call targets for each function.
4354fa9e4066Sahrens 	 */
4355fa9e4066Sahrens 	for (f = 0; f < ZTEST_FUNCS; f++) {
4356fa9e4066Sahrens 		zi = &zs->zs_info[f];
4357fa9e4066Sahrens 
4358fa9e4066Sahrens 		*zi = ztest_info[f];
4359fa9e4066Sahrens 
4360fa9e4066Sahrens 		if (*zi->zi_interval == 0)
4361fa9e4066Sahrens 			zi->zi_call_target = UINT64_MAX;
4362fa9e4066Sahrens 		else
4363fa9e4066Sahrens 			zi->zi_call_target = zopt_time / *zi->zi_interval;
4364fa9e4066Sahrens 	}
4365fa9e4066Sahrens 
4366fa9e4066Sahrens 	zs->zs_start_time = gethrtime();
4367fa9e4066Sahrens 	zs->zs_stop_time = zs->zs_start_time + zopt_time * NANOSEC;
4368fa9e4066Sahrens 
4369fa9e4066Sahrens 	/*
4370fa9e4066Sahrens 	 * Run the tests in a loop.  These tests include fault injection
4371fa9e4066Sahrens 	 * to verify that self-healing data works, and forced crashes
4372fa9e4066Sahrens 	 * to verify that we never lose on-disk consistency.
4373fa9e4066Sahrens 	 */
4374fa9e4066Sahrens 	while (gethrtime() < zs->zs_stop_time) {
4375fa9e4066Sahrens 		int status;
4376fa9e4066Sahrens 		pid_t pid;
4377fa9e4066Sahrens 		char *tmp;
4378fa9e4066Sahrens 
4379fa9e4066Sahrens 		/*
4380fa9e4066Sahrens 		 * Initialize the workload counters for each function.
4381fa9e4066Sahrens 		 */
4382fa9e4066Sahrens 		for (f = 0; f < ZTEST_FUNCS; f++) {
4383fa9e4066Sahrens 			zi = &zs->zs_info[f];
4384fa9e4066Sahrens 			zi->zi_calls = 0;
4385fa9e4066Sahrens 			zi->zi_call_time = 0;
4386fa9e4066Sahrens 		}
4387fa9e4066Sahrens 
4388d6e555bdSGeorge Wilson 		/* Set the allocation switch size */
4389d6e555bdSGeorge Wilson 		metaslab_df_alloc_threshold = ztest_random(metaslab_sz / 4) + 1;
4390d6e555bdSGeorge Wilson 
4391fa9e4066Sahrens 		pid = fork();
4392fa9e4066Sahrens 
4393fa9e4066Sahrens 		if (pid == -1)
4394fa9e4066Sahrens 			fatal(1, "fork failed");
4395fa9e4066Sahrens 
4396fa9e4066Sahrens 		if (pid == 0) {	/* child */
4397fa9e4066Sahrens 			struct rlimit rl = { 1024, 1024 };
4398fa9e4066Sahrens 			(void) setrlimit(RLIMIT_NOFILE, &rl);
4399004388ebScasper 			(void) enable_extended_FILE_stdio(-1, -1);
4400fa9e4066Sahrens 			ztest_run(zopt_pool);
4401fa9e4066Sahrens 			exit(0);
4402fa9e4066Sahrens 		}
4403fa9e4066Sahrens 
44045ad82045Snd 		while (waitpid(pid, &status, 0) != pid)
4405fa9e4066Sahrens 			continue;
4406fa9e4066Sahrens 
4407fa9e4066Sahrens 		if (WIFEXITED(status)) {
4408fa9e4066Sahrens 			if (WEXITSTATUS(status) != 0) {
4409fa9e4066Sahrens 				(void) fprintf(stderr,
4410fa9e4066Sahrens 				    "child exited with code %d\n",
4411fa9e4066Sahrens 				    WEXITSTATUS(status));
4412fa9e4066Sahrens 				exit(2);
4413fa9e4066Sahrens 			}
44145ad82045Snd 		} else if (WIFSIGNALED(status)) {
4415fa9e4066Sahrens 			if (WTERMSIG(status) != SIGKILL) {
4416fa9e4066Sahrens 				(void) fprintf(stderr,
4417fa9e4066Sahrens 				    "child died with signal %d\n",
4418fa9e4066Sahrens 				    WTERMSIG(status));
4419fa9e4066Sahrens 				exit(3);
4420fa9e4066Sahrens 			}
4421fa9e4066Sahrens 			kills++;
44225ad82045Snd 		} else {
44235ad82045Snd 			(void) fprintf(stderr, "something strange happened "
44245ad82045Snd 			    "to child\n");
44255ad82045Snd 			exit(4);
4426fa9e4066Sahrens 		}
4427fa9e4066Sahrens 
4428fa9e4066Sahrens 		iters++;
4429fa9e4066Sahrens 
4430fa9e4066Sahrens 		if (zopt_verbose >= 1) {
4431fa9e4066Sahrens 			hrtime_t now = gethrtime();
4432fa9e4066Sahrens 
4433fa9e4066Sahrens 			now = MIN(now, zs->zs_stop_time);
4434fa9e4066Sahrens 			print_time(zs->zs_stop_time - now, timebuf);
4435fa9e4066Sahrens 			nicenum(zs->zs_space, numbuf);
4436fa9e4066Sahrens 
4437fa9e4066Sahrens 			(void) printf("Pass %3d, %8s, %3llu ENOSPC, "
4438fa9e4066Sahrens 			    "%4.1f%% of %5s used, %3.0f%% done, %8s to go\n",
4439fa9e4066Sahrens 			    iters,
4440fa9e4066Sahrens 			    WIFEXITED(status) ? "Complete" : "SIGKILL",
4441fa9e4066Sahrens 			    (u_longlong_t)zs->zs_enospc_count,
4442fa9e4066Sahrens 			    100.0 * zs->zs_alloc / zs->zs_space,
4443fa9e4066Sahrens 			    numbuf,
4444fa9e4066Sahrens 			    100.0 * (now - zs->zs_start_time) /
4445fa9e4066Sahrens 			    (zopt_time * NANOSEC), timebuf);
4446fa9e4066Sahrens 		}
4447fa9e4066Sahrens 
4448fa9e4066Sahrens 		if (zopt_verbose >= 2) {
4449fa9e4066Sahrens 			(void) printf("\nWorkload summary:\n\n");
4450fa9e4066Sahrens 			(void) printf("%7s %9s   %s\n",
4451fa9e4066Sahrens 			    "Calls", "Time", "Function");
4452fa9e4066Sahrens 			(void) printf("%7s %9s   %s\n",
4453fa9e4066Sahrens 			    "-----", "----", "--------");
4454fa9e4066Sahrens 			for (f = 0; f < ZTEST_FUNCS; f++) {
4455fa9e4066Sahrens 				Dl_info dli;
4456fa9e4066Sahrens 
4457fa9e4066Sahrens 				zi = &zs->zs_info[f];
4458fa9e4066Sahrens 				print_time(zi->zi_call_time, timebuf);
4459fa9e4066Sahrens 				(void) dladdr((void *)zi->zi_func, &dli);
4460fa9e4066Sahrens 				(void) printf("%7llu %9s   %s\n",
4461fa9e4066Sahrens 				    (u_longlong_t)zi->zi_calls, timebuf,
4462fa9e4066Sahrens 				    dli.dli_sname);
4463fa9e4066Sahrens 			}
4464fa9e4066Sahrens 			(void) printf("\n");
4465fa9e4066Sahrens 		}
4466fa9e4066Sahrens 
4467fa9e4066Sahrens 		/*
4468fa9e4066Sahrens 		 * It's possible that we killed a child during a rename test, in
4469fa9e4066Sahrens 		 * which case we'll have a 'ztest_tmp' pool lying around instead
4470fa9e4066Sahrens 		 * of 'ztest'.  Do a blind rename in case this happened.
4471fa9e4066Sahrens 		 */
4472fa9e4066Sahrens 		tmp = umem_alloc(strlen(zopt_pool) + 5, UMEM_NOFAIL);
4473fa9e4066Sahrens 		(void) strcpy(tmp, zopt_pool);
4474fa9e4066Sahrens 		(void) strcat(tmp, "_tmp");
4475fa9e4066Sahrens 		kernel_init(FREAD | FWRITE);
4476fa9e4066Sahrens 		(void) spa_rename(tmp, zopt_pool);
4477fa9e4066Sahrens 		kernel_fini();
4478fa9e4066Sahrens 		umem_free(tmp, strlen(tmp) + 1);
4479fa9e4066Sahrens 	}
4480fa9e4066Sahrens 
4481fa9e4066Sahrens 	ztest_verify_blocks(zopt_pool);
4482fa9e4066Sahrens 
4483fa9e4066Sahrens 	if (zopt_verbose >= 1) {
4484fa9e4066Sahrens 		(void) printf("%d killed, %d completed, %.0f%% kill rate\n",
4485fa9e4066Sahrens 		    kills, iters - kills, (100.0 * kills) / MAX(1, iters));
4486fa9e4066Sahrens 	}
4487fa9e4066Sahrens 
4488fa9e4066Sahrens 	return (0);
4489fa9e4066Sahrens }
4490