Print this page
3949 ztest fault injection should avoid resilvering devices
3950 ztest: deadman fires when we're doing a scan
3951 ztest hang when running dedup test
3952 ztest: ztest_reguid test and ztest_fault_inject don't place nice together
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Adam Leventhal <ahl@delphix.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/ztest/ztest.c
+++ new/usr/src/cmd/ztest/ztest.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright (c) 2012 by Delphix. All rights reserved.
24 24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 25 * Copyright (c) 2013 Steven Hartland. All rights reserved.
26 26 */
27 27
28 28 /*
29 29 * The objective of this program is to provide a DMU/ZAP/SPA stress test
30 30 * that runs entirely in userland, is easy to use, and easy to extend.
31 31 *
32 32 * The overall design of the ztest program is as follows:
33 33 *
34 34 * (1) For each major functional area (e.g. adding vdevs to a pool,
35 35 * creating and destroying datasets, reading and writing objects, etc)
36 36 * we have a simple routine to test that functionality. These
37 37 * individual routines do not have to do anything "stressful".
38 38 *
39 39 * (2) We turn these simple functionality tests into a stress test by
40 40 * running them all in parallel, with as many threads as desired,
41 41 * and spread across as many datasets, objects, and vdevs as desired.
42 42 *
43 43 * (3) While all this is happening, we inject faults into the pool to
44 44 * verify that self-healing data really works.
45 45 *
46 46 * (4) Every time we open a dataset, we change its checksum and compression
47 47 * functions. Thus even individual objects vary from block to block
48 48 * in which checksum they use and whether they're compressed.
49 49 *
50 50 * (5) To verify that we never lose on-disk consistency after a crash,
51 51 * we run the entire test in a child of the main process.
52 52 * At random times, the child self-immolates with a SIGKILL.
53 53 * This is the software equivalent of pulling the power cord.
54 54 * The parent then runs the test again, using the existing
55 55 * storage pool, as many times as desired. If backwards compatability
56 56 * testing is enabled ztest will sometimes run the "older" version
57 57 * of ztest after a SIGKILL.
58 58 *
59 59 * (6) To verify that we don't have future leaks or temporal incursions,
60 60 * many of the functional tests record the transaction group number
61 61 * as part of their data. When reading old data, they verify that
62 62 * the transaction group number is less than the current, open txg.
63 63 * If you add a new test, please do this if applicable.
64 64 *
65 65 * When run with no arguments, ztest runs for about five minutes and
66 66 * produces no output if successful. To get a little bit of information,
67 67 * specify -V. To get more information, specify -VV, and so on.
68 68 *
69 69 * To turn this into an overnight stress test, use -T to specify run time.
70 70 *
71 71 * You can ask more more vdevs [-v], datasets [-d], or threads [-t]
72 72 * to increase the pool capacity, fanout, and overall stress level.
73 73 *
74 74 * Use the -k option to set the desired frequency of kills.
75 75 *
76 76 * When ztest invokes itself it passes all relevant information through a
77 77 * temporary file which is mmap-ed in the child process. This allows shared
78 78 * memory to survive the exec syscall. The ztest_shared_hdr_t struct is always
79 79 * stored at offset 0 of this file and contains information on the size and
80 80 * number of shared structures in the file. The information stored in this file
81 81 * must remain backwards compatible with older versions of ztest so that
82 82 * ztest can invoke them during backwards compatibility testing (-B).
83 83 */
84 84
85 85 #include <sys/zfs_context.h>
86 86 #include <sys/spa.h>
87 87 #include <sys/dmu.h>
88 88 #include <sys/txg.h>
89 89 #include <sys/dbuf.h>
90 90 #include <sys/zap.h>
91 91 #include <sys/dmu_objset.h>
92 92 #include <sys/poll.h>
93 93 #include <sys/stat.h>
94 94 #include <sys/time.h>
95 95 #include <sys/wait.h>
96 96 #include <sys/mman.h>
97 97 #include <sys/resource.h>
98 98 #include <sys/zio.h>
99 99 #include <sys/zil.h>
100 100 #include <sys/zil_impl.h>
101 101 #include <sys/vdev_impl.h>
102 102 #include <sys/vdev_file.h>
103 103 #include <sys/spa_impl.h>
104 104 #include <sys/metaslab_impl.h>
105 105 #include <sys/dsl_prop.h>
106 106 #include <sys/dsl_dataset.h>
107 107 #include <sys/dsl_destroy.h>
108 108 #include <sys/dsl_scan.h>
109 109 #include <sys/zio_checksum.h>
110 110 #include <sys/refcount.h>
111 111 #include <sys/zfeature.h>
112 112 #include <sys/dsl_userhold.h>
113 113 #include <stdio.h>
114 114 #include <stdio_ext.h>
115 115 #include <stdlib.h>
116 116 #include <unistd.h>
117 117 #include <signal.h>
118 118 #include <umem.h>
119 119 #include <dlfcn.h>
120 120 #include <ctype.h>
121 121 #include <math.h>
122 122 #include <sys/fs/zfs.h>
123 123 #include <libnvpair.h>
124 124
125 125 static int ztest_fd_data = -1;
126 126 static int ztest_fd_rand = -1;
127 127
128 128 typedef struct ztest_shared_hdr {
129 129 uint64_t zh_hdr_size;
130 130 uint64_t zh_opts_size;
131 131 uint64_t zh_size;
132 132 uint64_t zh_stats_size;
133 133 uint64_t zh_stats_count;
134 134 uint64_t zh_ds_size;
135 135 uint64_t zh_ds_count;
136 136 } ztest_shared_hdr_t;
137 137
138 138 static ztest_shared_hdr_t *ztest_shared_hdr;
139 139
140 140 typedef struct ztest_shared_opts {
141 141 char zo_pool[MAXNAMELEN];
142 142 char zo_dir[MAXNAMELEN];
143 143 char zo_alt_ztest[MAXNAMELEN];
144 144 char zo_alt_libpath[MAXNAMELEN];
145 145 uint64_t zo_vdevs;
146 146 uint64_t zo_vdevtime;
147 147 size_t zo_vdev_size;
148 148 int zo_ashift;
149 149 int zo_mirrors;
150 150 int zo_raidz;
151 151 int zo_raidz_parity;
152 152 int zo_datasets;
153 153 int zo_threads;
154 154 uint64_t zo_passtime;
155 155 uint64_t zo_killrate;
156 156 int zo_verbose;
157 157 int zo_init;
158 158 uint64_t zo_time;
159 159 uint64_t zo_maxloops;
160 160 uint64_t zo_metaslab_gang_bang;
161 161 } ztest_shared_opts_t;
162 162
163 163 static const ztest_shared_opts_t ztest_opts_defaults = {
164 164 .zo_pool = { 'z', 't', 'e', 's', 't', '\0' },
165 165 .zo_dir = { '/', 't', 'm', 'p', '\0' },
166 166 .zo_alt_ztest = { '\0' },
167 167 .zo_alt_libpath = { '\0' },
168 168 .zo_vdevs = 5,
169 169 .zo_ashift = SPA_MINBLOCKSHIFT,
170 170 .zo_mirrors = 2,
171 171 .zo_raidz = 4,
172 172 .zo_raidz_parity = 1,
173 173 .zo_vdev_size = SPA_MINDEVSIZE,
174 174 .zo_datasets = 7,
175 175 .zo_threads = 23,
176 176 .zo_passtime = 60, /* 60 seconds */
|
↓ open down ↓ |
176 lines elided |
↑ open up ↑ |
177 177 .zo_killrate = 70, /* 70% kill rate */
178 178 .zo_verbose = 0,
179 179 .zo_init = 1,
180 180 .zo_time = 300, /* 5 minutes */
181 181 .zo_maxloops = 50, /* max loops during spa_freeze() */
182 182 .zo_metaslab_gang_bang = 32 << 10
183 183 };
184 184
185 185 extern uint64_t metaslab_gang_bang;
186 186 extern uint64_t metaslab_df_alloc_threshold;
187 +extern uint64_t zfs_deadman_synctime;
187 188
188 189 static ztest_shared_opts_t *ztest_shared_opts;
189 190 static ztest_shared_opts_t ztest_opts;
190 191
191 192 typedef struct ztest_shared_ds {
192 193 uint64_t zd_seq;
193 194 } ztest_shared_ds_t;
194 195
195 196 static ztest_shared_ds_t *ztest_shared_ds;
196 197 #define ZTEST_GET_SHARED_DS(d) (&ztest_shared_ds[d])
197 198
198 199 #define BT_MAGIC 0x123456789abcdefULL
199 200 #define MAXFAULTS() \
200 201 (MAX(zs->zs_mirrors, 1) * (ztest_opts.zo_raidz_parity + 1) - 1)
201 202
202 203 enum ztest_io_type {
203 204 ZTEST_IO_WRITE_TAG,
204 205 ZTEST_IO_WRITE_PATTERN,
205 206 ZTEST_IO_WRITE_ZEROES,
206 207 ZTEST_IO_TRUNCATE,
207 208 ZTEST_IO_SETATTR,
208 209 ZTEST_IO_REWRITE,
209 210 ZTEST_IO_TYPES
210 211 };
211 212
212 213 typedef struct ztest_block_tag {
213 214 uint64_t bt_magic;
214 215 uint64_t bt_objset;
215 216 uint64_t bt_object;
216 217 uint64_t bt_offset;
217 218 uint64_t bt_gen;
218 219 uint64_t bt_txg;
219 220 uint64_t bt_crtxg;
220 221 } ztest_block_tag_t;
221 222
222 223 typedef struct bufwad {
223 224 uint64_t bw_index;
224 225 uint64_t bw_txg;
225 226 uint64_t bw_data;
226 227 } bufwad_t;
227 228
228 229 /*
229 230 * XXX -- fix zfs range locks to be generic so we can use them here.
230 231 */
231 232 typedef enum {
232 233 RL_READER,
233 234 RL_WRITER,
234 235 RL_APPEND
235 236 } rl_type_t;
236 237
237 238 typedef struct rll {
238 239 void *rll_writer;
239 240 int rll_readers;
240 241 mutex_t rll_lock;
241 242 cond_t rll_cv;
242 243 } rll_t;
243 244
244 245 typedef struct rl {
245 246 uint64_t rl_object;
246 247 uint64_t rl_offset;
247 248 uint64_t rl_size;
248 249 rll_t *rl_lock;
249 250 } rl_t;
250 251
251 252 #define ZTEST_RANGE_LOCKS 64
252 253 #define ZTEST_OBJECT_LOCKS 64
253 254
254 255 /*
255 256 * Object descriptor. Used as a template for object lookup/create/remove.
256 257 */
257 258 typedef struct ztest_od {
258 259 uint64_t od_dir;
259 260 uint64_t od_object;
260 261 dmu_object_type_t od_type;
261 262 dmu_object_type_t od_crtype;
262 263 uint64_t od_blocksize;
263 264 uint64_t od_crblocksize;
264 265 uint64_t od_gen;
265 266 uint64_t od_crgen;
266 267 char od_name[MAXNAMELEN];
267 268 } ztest_od_t;
268 269
269 270 /*
270 271 * Per-dataset state.
271 272 */
272 273 typedef struct ztest_ds {
273 274 ztest_shared_ds_t *zd_shared;
274 275 objset_t *zd_os;
275 276 rwlock_t zd_zilog_lock;
276 277 zilog_t *zd_zilog;
277 278 ztest_od_t *zd_od; /* debugging aid */
278 279 char zd_name[MAXNAMELEN];
279 280 mutex_t zd_dirobj_lock;
280 281 rll_t zd_object_lock[ZTEST_OBJECT_LOCKS];
281 282 rll_t zd_range_lock[ZTEST_RANGE_LOCKS];
282 283 } ztest_ds_t;
283 284
284 285 /*
285 286 * Per-iteration state.
286 287 */
287 288 typedef void ztest_func_t(ztest_ds_t *zd, uint64_t id);
288 289
289 290 typedef struct ztest_info {
290 291 ztest_func_t *zi_func; /* test function */
291 292 uint64_t zi_iters; /* iterations per execution */
292 293 uint64_t *zi_interval; /* execute every <interval> seconds */
293 294 } ztest_info_t;
294 295
295 296 typedef struct ztest_shared_callstate {
296 297 uint64_t zc_count; /* per-pass count */
297 298 uint64_t zc_time; /* per-pass time */
298 299 uint64_t zc_next; /* next time to call this function */
299 300 } ztest_shared_callstate_t;
300 301
301 302 static ztest_shared_callstate_t *ztest_shared_callstate;
302 303 #define ZTEST_GET_SHARED_CALLSTATE(c) (&ztest_shared_callstate[c])
303 304
304 305 /*
305 306 * Note: these aren't static because we want dladdr() to work.
306 307 */
307 308 ztest_func_t ztest_dmu_read_write;
308 309 ztest_func_t ztest_dmu_write_parallel;
309 310 ztest_func_t ztest_dmu_object_alloc_free;
310 311 ztest_func_t ztest_dmu_commit_callbacks;
311 312 ztest_func_t ztest_zap;
312 313 ztest_func_t ztest_zap_parallel;
313 314 ztest_func_t ztest_zil_commit;
314 315 ztest_func_t ztest_zil_remount;
315 316 ztest_func_t ztest_dmu_read_write_zcopy;
316 317 ztest_func_t ztest_dmu_objset_create_destroy;
317 318 ztest_func_t ztest_dmu_prealloc;
318 319 ztest_func_t ztest_fzap;
319 320 ztest_func_t ztest_dmu_snapshot_create_destroy;
320 321 ztest_func_t ztest_dsl_prop_get_set;
321 322 ztest_func_t ztest_spa_prop_get_set;
322 323 ztest_func_t ztest_spa_create_destroy;
323 324 ztest_func_t ztest_fault_inject;
324 325 ztest_func_t ztest_ddt_repair;
325 326 ztest_func_t ztest_dmu_snapshot_hold;
326 327 ztest_func_t ztest_spa_rename;
327 328 ztest_func_t ztest_scrub;
328 329 ztest_func_t ztest_dsl_dataset_promote_busy;
329 330 ztest_func_t ztest_vdev_attach_detach;
330 331 ztest_func_t ztest_vdev_LUN_growth;
331 332 ztest_func_t ztest_vdev_add_remove;
332 333 ztest_func_t ztest_vdev_aux_add_remove;
333 334 ztest_func_t ztest_split_pool;
334 335 ztest_func_t ztest_reguid;
335 336 ztest_func_t ztest_spa_upgrade;
336 337
337 338 uint64_t zopt_always = 0ULL * NANOSEC; /* all the time */
338 339 uint64_t zopt_incessant = 1ULL * NANOSEC / 10; /* every 1/10 second */
339 340 uint64_t zopt_often = 1ULL * NANOSEC; /* every second */
340 341 uint64_t zopt_sometimes = 10ULL * NANOSEC; /* every 10 seconds */
341 342 uint64_t zopt_rarely = 60ULL * NANOSEC; /* every 60 seconds */
342 343
343 344 ztest_info_t ztest_info[] = {
344 345 { ztest_dmu_read_write, 1, &zopt_always },
345 346 { ztest_dmu_write_parallel, 10, &zopt_always },
346 347 { ztest_dmu_object_alloc_free, 1, &zopt_always },
347 348 { ztest_dmu_commit_callbacks, 1, &zopt_always },
348 349 { ztest_zap, 30, &zopt_always },
349 350 { ztest_zap_parallel, 100, &zopt_always },
350 351 { ztest_split_pool, 1, &zopt_always },
351 352 { ztest_zil_commit, 1, &zopt_incessant },
352 353 { ztest_zil_remount, 1, &zopt_sometimes },
353 354 { ztest_dmu_read_write_zcopy, 1, &zopt_often },
354 355 { ztest_dmu_objset_create_destroy, 1, &zopt_often },
355 356 { ztest_dsl_prop_get_set, 1, &zopt_often },
|
↓ open down ↓ |
159 lines elided |
↑ open up ↑ |
356 357 { ztest_spa_prop_get_set, 1, &zopt_sometimes },
357 358 #if 0
358 359 { ztest_dmu_prealloc, 1, &zopt_sometimes },
359 360 #endif
360 361 { ztest_fzap, 1, &zopt_sometimes },
361 362 { ztest_dmu_snapshot_create_destroy, 1, &zopt_sometimes },
362 363 { ztest_spa_create_destroy, 1, &zopt_sometimes },
363 364 { ztest_fault_inject, 1, &zopt_sometimes },
364 365 { ztest_ddt_repair, 1, &zopt_sometimes },
365 366 { ztest_dmu_snapshot_hold, 1, &zopt_sometimes },
366 - { ztest_reguid, 1, &zopt_sometimes },
367 + { ztest_reguid, 1, &zopt_rarely },
367 368 { ztest_spa_rename, 1, &zopt_rarely },
368 369 { ztest_scrub, 1, &zopt_rarely },
369 370 { ztest_spa_upgrade, 1, &zopt_rarely },
370 371 { ztest_dsl_dataset_promote_busy, 1, &zopt_rarely },
371 372 { ztest_vdev_attach_detach, 1, &zopt_sometimes },
372 373 { ztest_vdev_LUN_growth, 1, &zopt_rarely },
373 374 { ztest_vdev_add_remove, 1,
374 375 &ztest_opts.zo_vdevtime },
375 376 { ztest_vdev_aux_add_remove, 1,
376 377 &ztest_opts.zo_vdevtime },
377 378 };
378 379
379 380 #define ZTEST_FUNCS (sizeof (ztest_info) / sizeof (ztest_info_t))
380 381
381 382 /*
382 383 * The following struct is used to hold a list of uncalled commit callbacks.
383 384 * The callbacks are ordered by txg number.
384 385 */
385 386 typedef struct ztest_cb_list {
386 387 mutex_t zcl_callbacks_lock;
387 388 list_t zcl_callbacks;
388 389 } ztest_cb_list_t;
389 390
390 391 /*
391 392 * Stuff we need to share writably between parent and child.
392 393 */
393 394 typedef struct ztest_shared {
394 395 boolean_t zs_do_init;
395 396 hrtime_t zs_proc_start;
396 397 hrtime_t zs_proc_stop;
397 398 hrtime_t zs_thread_start;
398 399 hrtime_t zs_thread_stop;
399 400 hrtime_t zs_thread_kill;
400 401 uint64_t zs_enospc_count;
401 402 uint64_t zs_vdev_next_leaf;
402 403 uint64_t zs_vdev_aux;
403 404 uint64_t zs_alloc;
404 405 uint64_t zs_space;
405 406 uint64_t zs_splits;
406 407 uint64_t zs_mirrors;
407 408 uint64_t zs_metaslab_sz;
408 409 uint64_t zs_metaslab_df_alloc_threshold;
409 410 uint64_t zs_guid;
410 411 } ztest_shared_t;
411 412
412 413 #define ID_PARALLEL -1ULL
413 414
414 415 static char ztest_dev_template[] = "%s/%s.%llua";
415 416 static char ztest_aux_template[] = "%s/%s.%s.%llu";
416 417 ztest_shared_t *ztest_shared;
417 418
418 419 static spa_t *ztest_spa = NULL;
419 420 static ztest_ds_t *ztest_ds;
420 421
421 422 static mutex_t ztest_vdev_lock;
422 423
423 424 /*
424 425 * The ztest_name_lock protects the pool and dataset namespace used by
425 426 * the individual tests. To modify the namespace, consumers must grab
426 427 * this lock as writer. Grabbing the lock as reader will ensure that the
427 428 * namespace does not change while the lock is held.
428 429 */
429 430 static rwlock_t ztest_name_lock;
430 431
431 432 static boolean_t ztest_dump_core = B_TRUE;
432 433 static boolean_t ztest_exiting;
433 434
434 435 /* Global commit callback list */
435 436 static ztest_cb_list_t zcl;
436 437
437 438 enum ztest_object {
438 439 ZTEST_META_DNODE = 0,
439 440 ZTEST_DIROBJ,
440 441 ZTEST_OBJECTS
441 442 };
442 443
443 444 static void usage(boolean_t) __NORETURN;
444 445
445 446 /*
446 447 * These libumem hooks provide a reasonable set of defaults for the allocator's
447 448 * debugging facilities.
448 449 */
449 450 const char *
450 451 _umem_debug_init()
451 452 {
452 453 return ("default,verbose"); /* $UMEM_DEBUG setting */
453 454 }
454 455
455 456 const char *
456 457 _umem_logging_init(void)
457 458 {
458 459 return ("fail,contents"); /* $UMEM_LOGGING setting */
459 460 }
460 461
461 462 #define FATAL_MSG_SZ 1024
462 463
463 464 char *fatal_msg;
464 465
465 466 static void
466 467 fatal(int do_perror, char *message, ...)
467 468 {
468 469 va_list args;
469 470 int save_errno = errno;
470 471 char buf[FATAL_MSG_SZ];
471 472
472 473 (void) fflush(stdout);
473 474
474 475 va_start(args, message);
475 476 (void) sprintf(buf, "ztest: ");
476 477 /* LINTED */
477 478 (void) vsprintf(buf + strlen(buf), message, args);
478 479 va_end(args);
479 480 if (do_perror) {
480 481 (void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf),
481 482 ": %s", strerror(save_errno));
482 483 }
483 484 (void) fprintf(stderr, "%s\n", buf);
484 485 fatal_msg = buf; /* to ease debugging */
485 486 if (ztest_dump_core)
486 487 abort();
487 488 exit(3);
488 489 }
489 490
490 491 static int
491 492 str2shift(const char *buf)
492 493 {
493 494 const char *ends = "BKMGTPEZ";
494 495 int i;
495 496
496 497 if (buf[0] == '\0')
497 498 return (0);
498 499 for (i = 0; i < strlen(ends); i++) {
499 500 if (toupper(buf[0]) == ends[i])
500 501 break;
501 502 }
502 503 if (i == strlen(ends)) {
503 504 (void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n",
504 505 buf);
505 506 usage(B_FALSE);
506 507 }
507 508 if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0')) {
508 509 return (10*i);
509 510 }
510 511 (void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf);
511 512 usage(B_FALSE);
512 513 /* NOTREACHED */
513 514 }
514 515
515 516 static uint64_t
516 517 nicenumtoull(const char *buf)
517 518 {
518 519 char *end;
519 520 uint64_t val;
520 521
521 522 val = strtoull(buf, &end, 0);
522 523 if (end == buf) {
523 524 (void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf);
524 525 usage(B_FALSE);
525 526 } else if (end[0] == '.') {
526 527 double fval = strtod(buf, &end);
527 528 fval *= pow(2, str2shift(end));
528 529 if (fval > UINT64_MAX) {
529 530 (void) fprintf(stderr, "ztest: value too large: %s\n",
530 531 buf);
531 532 usage(B_FALSE);
532 533 }
533 534 val = (uint64_t)fval;
534 535 } else {
535 536 int shift = str2shift(end);
536 537 if (shift >= 64 || (val << shift) >> shift != val) {
537 538 (void) fprintf(stderr, "ztest: value too large: %s\n",
538 539 buf);
539 540 usage(B_FALSE);
540 541 }
541 542 val <<= shift;
542 543 }
543 544 return (val);
544 545 }
545 546
546 547 static void
547 548 usage(boolean_t requested)
548 549 {
549 550 const ztest_shared_opts_t *zo = &ztest_opts_defaults;
550 551
551 552 char nice_vdev_size[10];
552 553 char nice_gang_bang[10];
553 554 FILE *fp = requested ? stdout : stderr;
554 555
555 556 nicenum(zo->zo_vdev_size, nice_vdev_size);
556 557 nicenum(zo->zo_metaslab_gang_bang, nice_gang_bang);
557 558
558 559 (void) fprintf(fp, "Usage: %s\n"
559 560 "\t[-v vdevs (default: %llu)]\n"
560 561 "\t[-s size_of_each_vdev (default: %s)]\n"
561 562 "\t[-a alignment_shift (default: %d)] use 0 for random\n"
562 563 "\t[-m mirror_copies (default: %d)]\n"
563 564 "\t[-r raidz_disks (default: %d)]\n"
564 565 "\t[-R raidz_parity (default: %d)]\n"
565 566 "\t[-d datasets (default: %d)]\n"
566 567 "\t[-t threads (default: %d)]\n"
567 568 "\t[-g gang_block_threshold (default: %s)]\n"
568 569 "\t[-i init_count (default: %d)] initialize pool i times\n"
569 570 "\t[-k kill_percentage (default: %llu%%)]\n"
570 571 "\t[-p pool_name (default: %s)]\n"
571 572 "\t[-f dir (default: %s)] file directory for vdev files\n"
572 573 "\t[-V] verbose (use multiple times for ever more blather)\n"
573 574 "\t[-E] use existing pool instead of creating new one\n"
574 575 "\t[-T time (default: %llu sec)] total run time\n"
575 576 "\t[-F freezeloops (default: %llu)] max loops in spa_freeze()\n"
576 577 "\t[-P passtime (default: %llu sec)] time per pass\n"
577 578 "\t[-B alt_ztest (default: <none>)] alternate ztest path\n"
578 579 "\t[-h] (print help)\n"
579 580 "",
580 581 zo->zo_pool,
581 582 (u_longlong_t)zo->zo_vdevs, /* -v */
582 583 nice_vdev_size, /* -s */
583 584 zo->zo_ashift, /* -a */
584 585 zo->zo_mirrors, /* -m */
585 586 zo->zo_raidz, /* -r */
586 587 zo->zo_raidz_parity, /* -R */
587 588 zo->zo_datasets, /* -d */
588 589 zo->zo_threads, /* -t */
589 590 nice_gang_bang, /* -g */
590 591 zo->zo_init, /* -i */
591 592 (u_longlong_t)zo->zo_killrate, /* -k */
592 593 zo->zo_pool, /* -p */
593 594 zo->zo_dir, /* -f */
594 595 (u_longlong_t)zo->zo_time, /* -T */
595 596 (u_longlong_t)zo->zo_maxloops, /* -F */
596 597 (u_longlong_t)zo->zo_passtime);
597 598 exit(requested ? 0 : 1);
598 599 }
599 600
600 601 static void
601 602 process_options(int argc, char **argv)
602 603 {
603 604 char *path;
604 605 ztest_shared_opts_t *zo = &ztest_opts;
605 606
606 607 int opt;
607 608 uint64_t value;
608 609 char altdir[MAXNAMELEN] = { 0 };
609 610
610 611 bcopy(&ztest_opts_defaults, zo, sizeof (*zo));
611 612
612 613 while ((opt = getopt(argc, argv,
613 614 "v:s:a:m:r:R:d:t:g:i:k:p:f:VET:P:hF:B:")) != EOF) {
614 615 value = 0;
615 616 switch (opt) {
616 617 case 'v':
617 618 case 's':
618 619 case 'a':
619 620 case 'm':
620 621 case 'r':
621 622 case 'R':
622 623 case 'd':
623 624 case 't':
624 625 case 'g':
625 626 case 'i':
626 627 case 'k':
627 628 case 'T':
628 629 case 'P':
629 630 case 'F':
630 631 value = nicenumtoull(optarg);
631 632 }
632 633 switch (opt) {
633 634 case 'v':
634 635 zo->zo_vdevs = value;
635 636 break;
636 637 case 's':
637 638 zo->zo_vdev_size = MAX(SPA_MINDEVSIZE, value);
638 639 break;
639 640 case 'a':
640 641 zo->zo_ashift = value;
641 642 break;
642 643 case 'm':
643 644 zo->zo_mirrors = value;
644 645 break;
645 646 case 'r':
646 647 zo->zo_raidz = MAX(1, value);
647 648 break;
648 649 case 'R':
649 650 zo->zo_raidz_parity = MIN(MAX(value, 1), 3);
650 651 break;
651 652 case 'd':
652 653 zo->zo_datasets = MAX(1, value);
653 654 break;
654 655 case 't':
655 656 zo->zo_threads = MAX(1, value);
656 657 break;
657 658 case 'g':
658 659 zo->zo_metaslab_gang_bang = MAX(SPA_MINBLOCKSIZE << 1,
659 660 value);
660 661 break;
661 662 case 'i':
662 663 zo->zo_init = value;
663 664 break;
664 665 case 'k':
665 666 zo->zo_killrate = value;
666 667 break;
667 668 case 'p':
668 669 (void) strlcpy(zo->zo_pool, optarg,
669 670 sizeof (zo->zo_pool));
670 671 break;
671 672 case 'f':
672 673 path = realpath(optarg, NULL);
673 674 if (path == NULL) {
674 675 (void) fprintf(stderr, "error: %s: %s\n",
675 676 optarg, strerror(errno));
676 677 usage(B_FALSE);
677 678 } else {
678 679 (void) strlcpy(zo->zo_dir, path,
679 680 sizeof (zo->zo_dir));
680 681 }
681 682 break;
682 683 case 'V':
683 684 zo->zo_verbose++;
684 685 break;
685 686 case 'E':
686 687 zo->zo_init = 0;
687 688 break;
688 689 case 'T':
689 690 zo->zo_time = value;
690 691 break;
691 692 case 'P':
692 693 zo->zo_passtime = MAX(1, value);
693 694 break;
694 695 case 'F':
695 696 zo->zo_maxloops = MAX(1, value);
696 697 break;
697 698 case 'B':
698 699 (void) strlcpy(altdir, optarg, sizeof (altdir));
699 700 break;
700 701 case 'h':
701 702 usage(B_TRUE);
702 703 break;
703 704 case '?':
704 705 default:
705 706 usage(B_FALSE);
706 707 break;
707 708 }
708 709 }
709 710
710 711 zo->zo_raidz_parity = MIN(zo->zo_raidz_parity, zo->zo_raidz - 1);
711 712
712 713 zo->zo_vdevtime =
713 714 (zo->zo_vdevs > 0 ? zo->zo_time * NANOSEC / zo->zo_vdevs :
714 715 UINT64_MAX >> 2);
715 716
716 717 if (strlen(altdir) > 0) {
717 718 char *cmd;
718 719 char *realaltdir;
719 720 char *bin;
720 721 char *ztest;
721 722 char *isa;
722 723 int isalen;
723 724
724 725 cmd = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
725 726 realaltdir = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
726 727
727 728 VERIFY(NULL != realpath(getexecname(), cmd));
728 729 if (0 != access(altdir, F_OK)) {
729 730 ztest_dump_core = B_FALSE;
730 731 fatal(B_TRUE, "invalid alternate ztest path: %s",
731 732 altdir);
732 733 }
733 734 VERIFY(NULL != realpath(altdir, realaltdir));
734 735
735 736 /*
736 737 * 'cmd' should be of the form "<anything>/usr/bin/<isa>/ztest".
737 738 * We want to extract <isa> to determine if we should use
738 739 * 32 or 64 bit binaries.
739 740 */
740 741 bin = strstr(cmd, "/usr/bin/");
741 742 ztest = strstr(bin, "/ztest");
742 743 isa = bin + 9;
743 744 isalen = ztest - isa;
744 745 (void) snprintf(zo->zo_alt_ztest, sizeof (zo->zo_alt_ztest),
745 746 "%s/usr/bin/%.*s/ztest", realaltdir, isalen, isa);
746 747 (void) snprintf(zo->zo_alt_libpath, sizeof (zo->zo_alt_libpath),
747 748 "%s/usr/lib/%.*s", realaltdir, isalen, isa);
748 749
749 750 if (0 != access(zo->zo_alt_ztest, X_OK)) {
750 751 ztest_dump_core = B_FALSE;
751 752 fatal(B_TRUE, "invalid alternate ztest: %s",
752 753 zo->zo_alt_ztest);
753 754 } else if (0 != access(zo->zo_alt_libpath, X_OK)) {
754 755 ztest_dump_core = B_FALSE;
755 756 fatal(B_TRUE, "invalid alternate lib directory %s",
756 757 zo->zo_alt_libpath);
757 758 }
758 759
759 760 umem_free(cmd, MAXPATHLEN);
760 761 umem_free(realaltdir, MAXPATHLEN);
761 762 }
762 763 }
763 764
764 765 static void
765 766 ztest_kill(ztest_shared_t *zs)
766 767 {
767 768 zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(ztest_spa));
768 769 zs->zs_space = metaslab_class_get_space(spa_normal_class(ztest_spa));
769 770 (void) kill(getpid(), SIGKILL);
770 771 }
771 772
772 773 static uint64_t
773 774 ztest_random(uint64_t range)
774 775 {
775 776 uint64_t r;
776 777
777 778 ASSERT3S(ztest_fd_rand, >=, 0);
778 779
779 780 if (range == 0)
780 781 return (0);
781 782
782 783 if (read(ztest_fd_rand, &r, sizeof (r)) != sizeof (r))
783 784 fatal(1, "short read from /dev/urandom");
784 785
785 786 return (r % range);
786 787 }
787 788
788 789 /* ARGSUSED */
789 790 static void
790 791 ztest_record_enospc(const char *s)
791 792 {
792 793 ztest_shared->zs_enospc_count++;
793 794 }
794 795
795 796 static uint64_t
796 797 ztest_get_ashift(void)
797 798 {
798 799 if (ztest_opts.zo_ashift == 0)
799 800 return (SPA_MINBLOCKSHIFT + ztest_random(3));
800 801 return (ztest_opts.zo_ashift);
801 802 }
802 803
803 804 static nvlist_t *
804 805 make_vdev_file(char *path, char *aux, char *pool, size_t size, uint64_t ashift)
805 806 {
806 807 char pathbuf[MAXPATHLEN];
807 808 uint64_t vdev;
808 809 nvlist_t *file;
809 810
810 811 if (ashift == 0)
811 812 ashift = ztest_get_ashift();
812 813
813 814 if (path == NULL) {
814 815 path = pathbuf;
815 816
816 817 if (aux != NULL) {
817 818 vdev = ztest_shared->zs_vdev_aux;
818 819 (void) snprintf(path, sizeof (pathbuf),
819 820 ztest_aux_template, ztest_opts.zo_dir,
820 821 pool == NULL ? ztest_opts.zo_pool : pool,
821 822 aux, vdev);
822 823 } else {
823 824 vdev = ztest_shared->zs_vdev_next_leaf++;
824 825 (void) snprintf(path, sizeof (pathbuf),
825 826 ztest_dev_template, ztest_opts.zo_dir,
826 827 pool == NULL ? ztest_opts.zo_pool : pool, vdev);
827 828 }
828 829 }
829 830
830 831 if (size != 0) {
831 832 int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666);
832 833 if (fd == -1)
833 834 fatal(1, "can't open %s", path);
834 835 if (ftruncate(fd, size) != 0)
835 836 fatal(1, "can't ftruncate %s", path);
836 837 (void) close(fd);
837 838 }
838 839
839 840 VERIFY(nvlist_alloc(&file, NV_UNIQUE_NAME, 0) == 0);
840 841 VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_TYPE, VDEV_TYPE_FILE) == 0);
841 842 VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_PATH, path) == 0);
842 843 VERIFY(nvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift) == 0);
843 844
844 845 return (file);
845 846 }
846 847
847 848 static nvlist_t *
848 849 make_vdev_raidz(char *path, char *aux, char *pool, size_t size,
849 850 uint64_t ashift, int r)
850 851 {
851 852 nvlist_t *raidz, **child;
852 853 int c;
853 854
854 855 if (r < 2)
855 856 return (make_vdev_file(path, aux, pool, size, ashift));
856 857 child = umem_alloc(r * sizeof (nvlist_t *), UMEM_NOFAIL);
857 858
858 859 for (c = 0; c < r; c++)
859 860 child[c] = make_vdev_file(path, aux, pool, size, ashift);
860 861
861 862 VERIFY(nvlist_alloc(&raidz, NV_UNIQUE_NAME, 0) == 0);
862 863 VERIFY(nvlist_add_string(raidz, ZPOOL_CONFIG_TYPE,
863 864 VDEV_TYPE_RAIDZ) == 0);
864 865 VERIFY(nvlist_add_uint64(raidz, ZPOOL_CONFIG_NPARITY,
865 866 ztest_opts.zo_raidz_parity) == 0);
866 867 VERIFY(nvlist_add_nvlist_array(raidz, ZPOOL_CONFIG_CHILDREN,
867 868 child, r) == 0);
868 869
869 870 for (c = 0; c < r; c++)
870 871 nvlist_free(child[c]);
871 872
872 873 umem_free(child, r * sizeof (nvlist_t *));
873 874
874 875 return (raidz);
875 876 }
876 877
877 878 static nvlist_t *
878 879 make_vdev_mirror(char *path, char *aux, char *pool, size_t size,
879 880 uint64_t ashift, int r, int m)
880 881 {
881 882 nvlist_t *mirror, **child;
882 883 int c;
883 884
884 885 if (m < 1)
885 886 return (make_vdev_raidz(path, aux, pool, size, ashift, r));
886 887
887 888 child = umem_alloc(m * sizeof (nvlist_t *), UMEM_NOFAIL);
888 889
889 890 for (c = 0; c < m; c++)
890 891 child[c] = make_vdev_raidz(path, aux, pool, size, ashift, r);
891 892
892 893 VERIFY(nvlist_alloc(&mirror, NV_UNIQUE_NAME, 0) == 0);
893 894 VERIFY(nvlist_add_string(mirror, ZPOOL_CONFIG_TYPE,
894 895 VDEV_TYPE_MIRROR) == 0);
895 896 VERIFY(nvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN,
896 897 child, m) == 0);
897 898
898 899 for (c = 0; c < m; c++)
899 900 nvlist_free(child[c]);
900 901
901 902 umem_free(child, m * sizeof (nvlist_t *));
902 903
903 904 return (mirror);
904 905 }
905 906
906 907 static nvlist_t *
907 908 make_vdev_root(char *path, char *aux, char *pool, size_t size, uint64_t ashift,
908 909 int log, int r, int m, int t)
909 910 {
910 911 nvlist_t *root, **child;
911 912 int c;
912 913
913 914 ASSERT(t > 0);
914 915
915 916 child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL);
916 917
917 918 for (c = 0; c < t; c++) {
918 919 child[c] = make_vdev_mirror(path, aux, pool, size, ashift,
919 920 r, m);
920 921 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
921 922 log) == 0);
922 923 }
923 924
924 925 VERIFY(nvlist_alloc(&root, NV_UNIQUE_NAME, 0) == 0);
925 926 VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0);
926 927 VERIFY(nvlist_add_nvlist_array(root, aux ? aux : ZPOOL_CONFIG_CHILDREN,
927 928 child, t) == 0);
928 929
929 930 for (c = 0; c < t; c++)
930 931 nvlist_free(child[c]);
931 932
932 933 umem_free(child, t * sizeof (nvlist_t *));
933 934
934 935 return (root);
935 936 }
936 937
937 938 /*
938 939 * Find a random spa version. Returns back a random spa version in the
939 940 * range [initial_version, SPA_VERSION_FEATURES].
940 941 */
941 942 static uint64_t
942 943 ztest_random_spa_version(uint64_t initial_version)
943 944 {
944 945 uint64_t version = initial_version;
945 946
946 947 if (version <= SPA_VERSION_BEFORE_FEATURES) {
947 948 version = version +
948 949 ztest_random(SPA_VERSION_BEFORE_FEATURES - version + 1);
949 950 }
950 951
951 952 if (version > SPA_VERSION_BEFORE_FEATURES)
952 953 version = SPA_VERSION_FEATURES;
953 954
954 955 ASSERT(SPA_VERSION_IS_SUPPORTED(version));
955 956 return (version);
956 957 }
957 958
958 959 static int
959 960 ztest_random_blocksize(void)
960 961 {
961 962 return (1 << (SPA_MINBLOCKSHIFT +
962 963 ztest_random(SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT + 1)));
963 964 }
964 965
965 966 static int
966 967 ztest_random_ibshift(void)
967 968 {
968 969 return (DN_MIN_INDBLKSHIFT +
969 970 ztest_random(DN_MAX_INDBLKSHIFT - DN_MIN_INDBLKSHIFT + 1));
970 971 }
971 972
972 973 static uint64_t
973 974 ztest_random_vdev_top(spa_t *spa, boolean_t log_ok)
974 975 {
975 976 uint64_t top;
976 977 vdev_t *rvd = spa->spa_root_vdev;
977 978 vdev_t *tvd;
978 979
979 980 ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
980 981
981 982 do {
982 983 top = ztest_random(rvd->vdev_children);
983 984 tvd = rvd->vdev_child[top];
984 985 } while (tvd->vdev_ishole || (tvd->vdev_islog && !log_ok) ||
985 986 tvd->vdev_mg == NULL || tvd->vdev_mg->mg_class == NULL);
986 987
987 988 return (top);
988 989 }
989 990
990 991 static uint64_t
991 992 ztest_random_dsl_prop(zfs_prop_t prop)
992 993 {
993 994 uint64_t value;
994 995
995 996 do {
996 997 value = zfs_prop_random_value(prop, ztest_random(-1ULL));
997 998 } while (prop == ZFS_PROP_CHECKSUM && value == ZIO_CHECKSUM_OFF);
998 999
999 1000 return (value);
1000 1001 }
1001 1002
1002 1003 static int
1003 1004 ztest_dsl_prop_set_uint64(char *osname, zfs_prop_t prop, uint64_t value,
1004 1005 boolean_t inherit)
1005 1006 {
1006 1007 const char *propname = zfs_prop_to_name(prop);
1007 1008 const char *valname;
1008 1009 char setpoint[MAXPATHLEN];
1009 1010 uint64_t curval;
1010 1011 int error;
1011 1012
1012 1013 error = dsl_prop_set_int(osname, propname,
1013 1014 (inherit ? ZPROP_SRC_NONE : ZPROP_SRC_LOCAL), value);
1014 1015
1015 1016 if (error == ENOSPC) {
1016 1017 ztest_record_enospc(FTAG);
1017 1018 return (error);
1018 1019 }
1019 1020 ASSERT0(error);
1020 1021
1021 1022 VERIFY0(dsl_prop_get_integer(osname, propname, &curval, setpoint));
1022 1023
1023 1024 if (ztest_opts.zo_verbose >= 6) {
1024 1025 VERIFY(zfs_prop_index_to_string(prop, curval, &valname) == 0);
1025 1026 (void) printf("%s %s = %s at '%s'\n",
1026 1027 osname, propname, valname, setpoint);
1027 1028 }
1028 1029
1029 1030 return (error);
1030 1031 }
1031 1032
1032 1033 static int
1033 1034 ztest_spa_prop_set_uint64(zpool_prop_t prop, uint64_t value)
1034 1035 {
1035 1036 spa_t *spa = ztest_spa;
1036 1037 nvlist_t *props = NULL;
1037 1038 int error;
1038 1039
1039 1040 VERIFY(nvlist_alloc(&props, NV_UNIQUE_NAME, 0) == 0);
1040 1041 VERIFY(nvlist_add_uint64(props, zpool_prop_to_name(prop), value) == 0);
1041 1042
1042 1043 error = spa_prop_set(spa, props);
1043 1044
1044 1045 nvlist_free(props);
1045 1046
1046 1047 if (error == ENOSPC) {
1047 1048 ztest_record_enospc(FTAG);
1048 1049 return (error);
1049 1050 }
1050 1051 ASSERT0(error);
1051 1052
1052 1053 return (error);
1053 1054 }
1054 1055
1055 1056 static void
1056 1057 ztest_rll_init(rll_t *rll)
1057 1058 {
1058 1059 rll->rll_writer = NULL;
1059 1060 rll->rll_readers = 0;
1060 1061 VERIFY(_mutex_init(&rll->rll_lock, USYNC_THREAD, NULL) == 0);
1061 1062 VERIFY(cond_init(&rll->rll_cv, USYNC_THREAD, NULL) == 0);
1062 1063 }
1063 1064
1064 1065 static void
1065 1066 ztest_rll_destroy(rll_t *rll)
1066 1067 {
1067 1068 ASSERT(rll->rll_writer == NULL);
1068 1069 ASSERT(rll->rll_readers == 0);
1069 1070 VERIFY(_mutex_destroy(&rll->rll_lock) == 0);
1070 1071 VERIFY(cond_destroy(&rll->rll_cv) == 0);
1071 1072 }
1072 1073
1073 1074 static void
1074 1075 ztest_rll_lock(rll_t *rll, rl_type_t type)
1075 1076 {
1076 1077 VERIFY(mutex_lock(&rll->rll_lock) == 0);
1077 1078
1078 1079 if (type == RL_READER) {
1079 1080 while (rll->rll_writer != NULL)
1080 1081 (void) cond_wait(&rll->rll_cv, &rll->rll_lock);
1081 1082 rll->rll_readers++;
1082 1083 } else {
1083 1084 while (rll->rll_writer != NULL || rll->rll_readers)
1084 1085 (void) cond_wait(&rll->rll_cv, &rll->rll_lock);
1085 1086 rll->rll_writer = curthread;
1086 1087 }
1087 1088
1088 1089 VERIFY(mutex_unlock(&rll->rll_lock) == 0);
1089 1090 }
1090 1091
1091 1092 static void
1092 1093 ztest_rll_unlock(rll_t *rll)
1093 1094 {
1094 1095 VERIFY(mutex_lock(&rll->rll_lock) == 0);
1095 1096
1096 1097 if (rll->rll_writer) {
1097 1098 ASSERT(rll->rll_readers == 0);
1098 1099 rll->rll_writer = NULL;
1099 1100 } else {
1100 1101 ASSERT(rll->rll_readers != 0);
1101 1102 ASSERT(rll->rll_writer == NULL);
1102 1103 rll->rll_readers--;
1103 1104 }
1104 1105
1105 1106 if (rll->rll_writer == NULL && rll->rll_readers == 0)
1106 1107 VERIFY(cond_broadcast(&rll->rll_cv) == 0);
1107 1108
1108 1109 VERIFY(mutex_unlock(&rll->rll_lock) == 0);
1109 1110 }
1110 1111
1111 1112 static void
1112 1113 ztest_object_lock(ztest_ds_t *zd, uint64_t object, rl_type_t type)
1113 1114 {
1114 1115 rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)];
1115 1116
1116 1117 ztest_rll_lock(rll, type);
1117 1118 }
1118 1119
1119 1120 static void
1120 1121 ztest_object_unlock(ztest_ds_t *zd, uint64_t object)
1121 1122 {
1122 1123 rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)];
1123 1124
1124 1125 ztest_rll_unlock(rll);
1125 1126 }
1126 1127
1127 1128 static rl_t *
1128 1129 ztest_range_lock(ztest_ds_t *zd, uint64_t object, uint64_t offset,
1129 1130 uint64_t size, rl_type_t type)
1130 1131 {
1131 1132 uint64_t hash = object ^ (offset % (ZTEST_RANGE_LOCKS + 1));
1132 1133 rll_t *rll = &zd->zd_range_lock[hash & (ZTEST_RANGE_LOCKS - 1)];
1133 1134 rl_t *rl;
1134 1135
1135 1136 rl = umem_alloc(sizeof (*rl), UMEM_NOFAIL);
1136 1137 rl->rl_object = object;
1137 1138 rl->rl_offset = offset;
1138 1139 rl->rl_size = size;
1139 1140 rl->rl_lock = rll;
1140 1141
1141 1142 ztest_rll_lock(rll, type);
1142 1143
1143 1144 return (rl);
1144 1145 }
1145 1146
1146 1147 static void
1147 1148 ztest_range_unlock(rl_t *rl)
1148 1149 {
1149 1150 rll_t *rll = rl->rl_lock;
1150 1151
1151 1152 ztest_rll_unlock(rll);
1152 1153
1153 1154 umem_free(rl, sizeof (*rl));
1154 1155 }
1155 1156
1156 1157 static void
1157 1158 ztest_zd_init(ztest_ds_t *zd, ztest_shared_ds_t *szd, objset_t *os)
1158 1159 {
1159 1160 zd->zd_os = os;
1160 1161 zd->zd_zilog = dmu_objset_zil(os);
1161 1162 zd->zd_shared = szd;
1162 1163 dmu_objset_name(os, zd->zd_name);
1163 1164
1164 1165 if (zd->zd_shared != NULL)
1165 1166 zd->zd_shared->zd_seq = 0;
1166 1167
1167 1168 VERIFY(rwlock_init(&zd->zd_zilog_lock, USYNC_THREAD, NULL) == 0);
1168 1169 VERIFY(_mutex_init(&zd->zd_dirobj_lock, USYNC_THREAD, NULL) == 0);
1169 1170
1170 1171 for (int l = 0; l < ZTEST_OBJECT_LOCKS; l++)
1171 1172 ztest_rll_init(&zd->zd_object_lock[l]);
1172 1173
1173 1174 for (int l = 0; l < ZTEST_RANGE_LOCKS; l++)
1174 1175 ztest_rll_init(&zd->zd_range_lock[l]);
1175 1176 }
1176 1177
1177 1178 static void
1178 1179 ztest_zd_fini(ztest_ds_t *zd)
1179 1180 {
1180 1181 VERIFY(_mutex_destroy(&zd->zd_dirobj_lock) == 0);
1181 1182
1182 1183 for (int l = 0; l < ZTEST_OBJECT_LOCKS; l++)
1183 1184 ztest_rll_destroy(&zd->zd_object_lock[l]);
1184 1185
1185 1186 for (int l = 0; l < ZTEST_RANGE_LOCKS; l++)
1186 1187 ztest_rll_destroy(&zd->zd_range_lock[l]);
1187 1188 }
1188 1189
1189 1190 #define TXG_MIGHTWAIT (ztest_random(10) == 0 ? TXG_NOWAIT : TXG_WAIT)
1190 1191
1191 1192 static uint64_t
1192 1193 ztest_tx_assign(dmu_tx_t *tx, uint64_t txg_how, const char *tag)
1193 1194 {
1194 1195 uint64_t txg;
1195 1196 int error;
1196 1197
1197 1198 /*
1198 1199 * Attempt to assign tx to some transaction group.
1199 1200 */
1200 1201 error = dmu_tx_assign(tx, txg_how);
1201 1202 if (error) {
1202 1203 if (error == ERESTART) {
1203 1204 ASSERT(txg_how == TXG_NOWAIT);
1204 1205 dmu_tx_wait(tx);
1205 1206 } else {
1206 1207 ASSERT3U(error, ==, ENOSPC);
1207 1208 ztest_record_enospc(tag);
1208 1209 }
1209 1210 dmu_tx_abort(tx);
1210 1211 return (0);
1211 1212 }
1212 1213 txg = dmu_tx_get_txg(tx);
1213 1214 ASSERT(txg != 0);
1214 1215 return (txg);
1215 1216 }
1216 1217
1217 1218 static void
1218 1219 ztest_pattern_set(void *buf, uint64_t size, uint64_t value)
1219 1220 {
1220 1221 uint64_t *ip = buf;
1221 1222 uint64_t *ip_end = (uint64_t *)((uintptr_t)buf + (uintptr_t)size);
1222 1223
1223 1224 while (ip < ip_end)
1224 1225 *ip++ = value;
1225 1226 }
1226 1227
1227 1228 static boolean_t
1228 1229 ztest_pattern_match(void *buf, uint64_t size, uint64_t value)
1229 1230 {
1230 1231 uint64_t *ip = buf;
1231 1232 uint64_t *ip_end = (uint64_t *)((uintptr_t)buf + (uintptr_t)size);
1232 1233 uint64_t diff = 0;
1233 1234
1234 1235 while (ip < ip_end)
1235 1236 diff |= (value - *ip++);
1236 1237
1237 1238 return (diff == 0);
1238 1239 }
1239 1240
1240 1241 static void
1241 1242 ztest_bt_generate(ztest_block_tag_t *bt, objset_t *os, uint64_t object,
1242 1243 uint64_t offset, uint64_t gen, uint64_t txg, uint64_t crtxg)
1243 1244 {
1244 1245 bt->bt_magic = BT_MAGIC;
1245 1246 bt->bt_objset = dmu_objset_id(os);
1246 1247 bt->bt_object = object;
1247 1248 bt->bt_offset = offset;
1248 1249 bt->bt_gen = gen;
1249 1250 bt->bt_txg = txg;
1250 1251 bt->bt_crtxg = crtxg;
1251 1252 }
1252 1253
1253 1254 static void
1254 1255 ztest_bt_verify(ztest_block_tag_t *bt, objset_t *os, uint64_t object,
1255 1256 uint64_t offset, uint64_t gen, uint64_t txg, uint64_t crtxg)
1256 1257 {
1257 1258 ASSERT(bt->bt_magic == BT_MAGIC);
1258 1259 ASSERT(bt->bt_objset == dmu_objset_id(os));
1259 1260 ASSERT(bt->bt_object == object);
1260 1261 ASSERT(bt->bt_offset == offset);
1261 1262 ASSERT(bt->bt_gen <= gen);
1262 1263 ASSERT(bt->bt_txg <= txg);
1263 1264 ASSERT(bt->bt_crtxg == crtxg);
1264 1265 }
1265 1266
1266 1267 static ztest_block_tag_t *
1267 1268 ztest_bt_bonus(dmu_buf_t *db)
1268 1269 {
1269 1270 dmu_object_info_t doi;
1270 1271 ztest_block_tag_t *bt;
1271 1272
1272 1273 dmu_object_info_from_db(db, &doi);
1273 1274 ASSERT3U(doi.doi_bonus_size, <=, db->db_size);
1274 1275 ASSERT3U(doi.doi_bonus_size, >=, sizeof (*bt));
1275 1276 bt = (void *)((char *)db->db_data + doi.doi_bonus_size - sizeof (*bt));
1276 1277
1277 1278 return (bt);
1278 1279 }
1279 1280
1280 1281 /*
1281 1282 * ZIL logging ops
1282 1283 */
1283 1284
1284 1285 #define lrz_type lr_mode
1285 1286 #define lrz_blocksize lr_uid
1286 1287 #define lrz_ibshift lr_gid
1287 1288 #define lrz_bonustype lr_rdev
1288 1289 #define lrz_bonuslen lr_crtime[1]
1289 1290
1290 1291 static void
1291 1292 ztest_log_create(ztest_ds_t *zd, dmu_tx_t *tx, lr_create_t *lr)
1292 1293 {
1293 1294 char *name = (void *)(lr + 1); /* name follows lr */
1294 1295 size_t namesize = strlen(name) + 1;
1295 1296 itx_t *itx;
1296 1297
1297 1298 if (zil_replaying(zd->zd_zilog, tx))
1298 1299 return;
1299 1300
1300 1301 itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize);
1301 1302 bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
1302 1303 sizeof (*lr) + namesize - sizeof (lr_t));
1303 1304
1304 1305 zil_itx_assign(zd->zd_zilog, itx, tx);
1305 1306 }
1306 1307
1307 1308 static void
1308 1309 ztest_log_remove(ztest_ds_t *zd, dmu_tx_t *tx, lr_remove_t *lr, uint64_t object)
1309 1310 {
1310 1311 char *name = (void *)(lr + 1); /* name follows lr */
1311 1312 size_t namesize = strlen(name) + 1;
1312 1313 itx_t *itx;
1313 1314
1314 1315 if (zil_replaying(zd->zd_zilog, tx))
1315 1316 return;
1316 1317
1317 1318 itx = zil_itx_create(TX_REMOVE, sizeof (*lr) + namesize);
1318 1319 bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
1319 1320 sizeof (*lr) + namesize - sizeof (lr_t));
1320 1321
1321 1322 itx->itx_oid = object;
1322 1323 zil_itx_assign(zd->zd_zilog, itx, tx);
1323 1324 }
1324 1325
1325 1326 static void
1326 1327 ztest_log_write(ztest_ds_t *zd, dmu_tx_t *tx, lr_write_t *lr)
1327 1328 {
1328 1329 itx_t *itx;
1329 1330 itx_wr_state_t write_state = ztest_random(WR_NUM_STATES);
1330 1331
1331 1332 if (zil_replaying(zd->zd_zilog, tx))
1332 1333 return;
1333 1334
1334 1335 if (lr->lr_length > ZIL_MAX_LOG_DATA)
1335 1336 write_state = WR_INDIRECT;
1336 1337
1337 1338 itx = zil_itx_create(TX_WRITE,
1338 1339 sizeof (*lr) + (write_state == WR_COPIED ? lr->lr_length : 0));
1339 1340
1340 1341 if (write_state == WR_COPIED &&
1341 1342 dmu_read(zd->zd_os, lr->lr_foid, lr->lr_offset, lr->lr_length,
1342 1343 ((lr_write_t *)&itx->itx_lr) + 1, DMU_READ_NO_PREFETCH) != 0) {
1343 1344 zil_itx_destroy(itx);
1344 1345 itx = zil_itx_create(TX_WRITE, sizeof (*lr));
1345 1346 write_state = WR_NEED_COPY;
1346 1347 }
1347 1348 itx->itx_private = zd;
1348 1349 itx->itx_wr_state = write_state;
1349 1350 itx->itx_sync = (ztest_random(8) == 0);
1350 1351 itx->itx_sod += (write_state == WR_NEED_COPY ? lr->lr_length : 0);
1351 1352
1352 1353 bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
1353 1354 sizeof (*lr) - sizeof (lr_t));
1354 1355
1355 1356 zil_itx_assign(zd->zd_zilog, itx, tx);
1356 1357 }
1357 1358
1358 1359 static void
1359 1360 ztest_log_truncate(ztest_ds_t *zd, dmu_tx_t *tx, lr_truncate_t *lr)
1360 1361 {
1361 1362 itx_t *itx;
1362 1363
1363 1364 if (zil_replaying(zd->zd_zilog, tx))
1364 1365 return;
1365 1366
1366 1367 itx = zil_itx_create(TX_TRUNCATE, sizeof (*lr));
1367 1368 bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
1368 1369 sizeof (*lr) - sizeof (lr_t));
1369 1370
1370 1371 itx->itx_sync = B_FALSE;
1371 1372 zil_itx_assign(zd->zd_zilog, itx, tx);
1372 1373 }
1373 1374
1374 1375 static void
1375 1376 ztest_log_setattr(ztest_ds_t *zd, dmu_tx_t *tx, lr_setattr_t *lr)
1376 1377 {
1377 1378 itx_t *itx;
1378 1379
1379 1380 if (zil_replaying(zd->zd_zilog, tx))
1380 1381 return;
1381 1382
1382 1383 itx = zil_itx_create(TX_SETATTR, sizeof (*lr));
1383 1384 bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
1384 1385 sizeof (*lr) - sizeof (lr_t));
1385 1386
1386 1387 itx->itx_sync = B_FALSE;
1387 1388 zil_itx_assign(zd->zd_zilog, itx, tx);
1388 1389 }
1389 1390
1390 1391 /*
1391 1392 * ZIL replay ops
1392 1393 */
1393 1394 static int
1394 1395 ztest_replay_create(ztest_ds_t *zd, lr_create_t *lr, boolean_t byteswap)
1395 1396 {
1396 1397 char *name = (void *)(lr + 1); /* name follows lr */
1397 1398 objset_t *os = zd->zd_os;
1398 1399 ztest_block_tag_t *bbt;
1399 1400 dmu_buf_t *db;
1400 1401 dmu_tx_t *tx;
1401 1402 uint64_t txg;
1402 1403 int error = 0;
1403 1404
1404 1405 if (byteswap)
1405 1406 byteswap_uint64_array(lr, sizeof (*lr));
1406 1407
1407 1408 ASSERT(lr->lr_doid == ZTEST_DIROBJ);
1408 1409 ASSERT(name[0] != '\0');
1409 1410
1410 1411 tx = dmu_tx_create(os);
1411 1412
1412 1413 dmu_tx_hold_zap(tx, lr->lr_doid, B_TRUE, name);
1413 1414
1414 1415 if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
1415 1416 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, B_TRUE, NULL);
1416 1417 } else {
1417 1418 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
1418 1419 }
1419 1420
1420 1421 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
1421 1422 if (txg == 0)
1422 1423 return (ENOSPC);
1423 1424
1424 1425 ASSERT(dmu_objset_zil(os)->zl_replay == !!lr->lr_foid);
1425 1426
1426 1427 if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
1427 1428 if (lr->lr_foid == 0) {
1428 1429 lr->lr_foid = zap_create(os,
1429 1430 lr->lrz_type, lr->lrz_bonustype,
1430 1431 lr->lrz_bonuslen, tx);
1431 1432 } else {
1432 1433 error = zap_create_claim(os, lr->lr_foid,
1433 1434 lr->lrz_type, lr->lrz_bonustype,
1434 1435 lr->lrz_bonuslen, tx);
1435 1436 }
1436 1437 } else {
1437 1438 if (lr->lr_foid == 0) {
1438 1439 lr->lr_foid = dmu_object_alloc(os,
1439 1440 lr->lrz_type, 0, lr->lrz_bonustype,
1440 1441 lr->lrz_bonuslen, tx);
1441 1442 } else {
1442 1443 error = dmu_object_claim(os, lr->lr_foid,
1443 1444 lr->lrz_type, 0, lr->lrz_bonustype,
1444 1445 lr->lrz_bonuslen, tx);
1445 1446 }
1446 1447 }
1447 1448
1448 1449 if (error) {
1449 1450 ASSERT3U(error, ==, EEXIST);
1450 1451 ASSERT(zd->zd_zilog->zl_replay);
1451 1452 dmu_tx_commit(tx);
1452 1453 return (error);
1453 1454 }
1454 1455
1455 1456 ASSERT(lr->lr_foid != 0);
1456 1457
1457 1458 if (lr->lrz_type != DMU_OT_ZAP_OTHER)
1458 1459 VERIFY3U(0, ==, dmu_object_set_blocksize(os, lr->lr_foid,
1459 1460 lr->lrz_blocksize, lr->lrz_ibshift, tx));
1460 1461
1461 1462 VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
1462 1463 bbt = ztest_bt_bonus(db);
1463 1464 dmu_buf_will_dirty(db, tx);
1464 1465 ztest_bt_generate(bbt, os, lr->lr_foid, -1ULL, lr->lr_gen, txg, txg);
1465 1466 dmu_buf_rele(db, FTAG);
1466 1467
1467 1468 VERIFY3U(0, ==, zap_add(os, lr->lr_doid, name, sizeof (uint64_t), 1,
1468 1469 &lr->lr_foid, tx));
1469 1470
1470 1471 (void) ztest_log_create(zd, tx, lr);
1471 1472
1472 1473 dmu_tx_commit(tx);
1473 1474
1474 1475 return (0);
1475 1476 }
1476 1477
1477 1478 static int
1478 1479 ztest_replay_remove(ztest_ds_t *zd, lr_remove_t *lr, boolean_t byteswap)
1479 1480 {
1480 1481 char *name = (void *)(lr + 1); /* name follows lr */
1481 1482 objset_t *os = zd->zd_os;
1482 1483 dmu_object_info_t doi;
1483 1484 dmu_tx_t *tx;
1484 1485 uint64_t object, txg;
1485 1486
1486 1487 if (byteswap)
1487 1488 byteswap_uint64_array(lr, sizeof (*lr));
1488 1489
1489 1490 ASSERT(lr->lr_doid == ZTEST_DIROBJ);
1490 1491 ASSERT(name[0] != '\0');
1491 1492
1492 1493 VERIFY3U(0, ==,
1493 1494 zap_lookup(os, lr->lr_doid, name, sizeof (object), 1, &object));
1494 1495 ASSERT(object != 0);
1495 1496
1496 1497 ztest_object_lock(zd, object, RL_WRITER);
1497 1498
1498 1499 VERIFY3U(0, ==, dmu_object_info(os, object, &doi));
1499 1500
1500 1501 tx = dmu_tx_create(os);
1501 1502
1502 1503 dmu_tx_hold_zap(tx, lr->lr_doid, B_FALSE, name);
1503 1504 dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
1504 1505
1505 1506 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
1506 1507 if (txg == 0) {
1507 1508 ztest_object_unlock(zd, object);
1508 1509 return (ENOSPC);
1509 1510 }
1510 1511
1511 1512 if (doi.doi_type == DMU_OT_ZAP_OTHER) {
1512 1513 VERIFY3U(0, ==, zap_destroy(os, object, tx));
1513 1514 } else {
1514 1515 VERIFY3U(0, ==, dmu_object_free(os, object, tx));
1515 1516 }
1516 1517
1517 1518 VERIFY3U(0, ==, zap_remove(os, lr->lr_doid, name, tx));
1518 1519
1519 1520 (void) ztest_log_remove(zd, tx, lr, object);
1520 1521
1521 1522 dmu_tx_commit(tx);
1522 1523
1523 1524 ztest_object_unlock(zd, object);
1524 1525
1525 1526 return (0);
1526 1527 }
1527 1528
1528 1529 static int
1529 1530 ztest_replay_write(ztest_ds_t *zd, lr_write_t *lr, boolean_t byteswap)
1530 1531 {
1531 1532 objset_t *os = zd->zd_os;
1532 1533 void *data = lr + 1; /* data follows lr */
1533 1534 uint64_t offset, length;
1534 1535 ztest_block_tag_t *bt = data;
1535 1536 ztest_block_tag_t *bbt;
1536 1537 uint64_t gen, txg, lrtxg, crtxg;
1537 1538 dmu_object_info_t doi;
1538 1539 dmu_tx_t *tx;
1539 1540 dmu_buf_t *db;
1540 1541 arc_buf_t *abuf = NULL;
1541 1542 rl_t *rl;
1542 1543
1543 1544 if (byteswap)
1544 1545 byteswap_uint64_array(lr, sizeof (*lr));
1545 1546
1546 1547 offset = lr->lr_offset;
1547 1548 length = lr->lr_length;
1548 1549
1549 1550 /* If it's a dmu_sync() block, write the whole block */
1550 1551 if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {
1551 1552 uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr);
1552 1553 if (length < blocksize) {
1553 1554 offset -= offset % blocksize;
1554 1555 length = blocksize;
1555 1556 }
1556 1557 }
1557 1558
1558 1559 if (bt->bt_magic == BSWAP_64(BT_MAGIC))
1559 1560 byteswap_uint64_array(bt, sizeof (*bt));
1560 1561
1561 1562 if (bt->bt_magic != BT_MAGIC)
1562 1563 bt = NULL;
1563 1564
1564 1565 ztest_object_lock(zd, lr->lr_foid, RL_READER);
1565 1566 rl = ztest_range_lock(zd, lr->lr_foid, offset, length, RL_WRITER);
1566 1567
1567 1568 VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
1568 1569
1569 1570 dmu_object_info_from_db(db, &doi);
1570 1571
1571 1572 bbt = ztest_bt_bonus(db);
1572 1573 ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
1573 1574 gen = bbt->bt_gen;
1574 1575 crtxg = bbt->bt_crtxg;
1575 1576 lrtxg = lr->lr_common.lrc_txg;
1576 1577
1577 1578 tx = dmu_tx_create(os);
1578 1579
1579 1580 dmu_tx_hold_write(tx, lr->lr_foid, offset, length);
1580 1581
1581 1582 if (ztest_random(8) == 0 && length == doi.doi_data_block_size &&
1582 1583 P2PHASE(offset, length) == 0)
1583 1584 abuf = dmu_request_arcbuf(db, length);
1584 1585
1585 1586 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
1586 1587 if (txg == 0) {
1587 1588 if (abuf != NULL)
1588 1589 dmu_return_arcbuf(abuf);
1589 1590 dmu_buf_rele(db, FTAG);
1590 1591 ztest_range_unlock(rl);
1591 1592 ztest_object_unlock(zd, lr->lr_foid);
1592 1593 return (ENOSPC);
1593 1594 }
1594 1595
1595 1596 if (bt != NULL) {
1596 1597 /*
1597 1598 * Usually, verify the old data before writing new data --
1598 1599 * but not always, because we also want to verify correct
1599 1600 * behavior when the data was not recently read into cache.
1600 1601 */
1601 1602 ASSERT(offset % doi.doi_data_block_size == 0);
1602 1603 if (ztest_random(4) != 0) {
1603 1604 int prefetch = ztest_random(2) ?
1604 1605 DMU_READ_PREFETCH : DMU_READ_NO_PREFETCH;
1605 1606 ztest_block_tag_t rbt;
1606 1607
1607 1608 VERIFY(dmu_read(os, lr->lr_foid, offset,
1608 1609 sizeof (rbt), &rbt, prefetch) == 0);
1609 1610 if (rbt.bt_magic == BT_MAGIC) {
1610 1611 ztest_bt_verify(&rbt, os, lr->lr_foid,
1611 1612 offset, gen, txg, crtxg);
1612 1613 }
1613 1614 }
1614 1615
1615 1616 /*
1616 1617 * Writes can appear to be newer than the bonus buffer because
1617 1618 * the ztest_get_data() callback does a dmu_read() of the
1618 1619 * open-context data, which may be different than the data
1619 1620 * as it was when the write was generated.
1620 1621 */
1621 1622 if (zd->zd_zilog->zl_replay) {
1622 1623 ztest_bt_verify(bt, os, lr->lr_foid, offset,
1623 1624 MAX(gen, bt->bt_gen), MAX(txg, lrtxg),
1624 1625 bt->bt_crtxg);
1625 1626 }
1626 1627
1627 1628 /*
1628 1629 * Set the bt's gen/txg to the bonus buffer's gen/txg
1629 1630 * so that all of the usual ASSERTs will work.
1630 1631 */
1631 1632 ztest_bt_generate(bt, os, lr->lr_foid, offset, gen, txg, crtxg);
1632 1633 }
1633 1634
1634 1635 if (abuf == NULL) {
1635 1636 dmu_write(os, lr->lr_foid, offset, length, data, tx);
1636 1637 } else {
1637 1638 bcopy(data, abuf->b_data, length);
1638 1639 dmu_assign_arcbuf(db, offset, abuf, tx);
1639 1640 }
1640 1641
1641 1642 (void) ztest_log_write(zd, tx, lr);
1642 1643
1643 1644 dmu_buf_rele(db, FTAG);
1644 1645
1645 1646 dmu_tx_commit(tx);
1646 1647
1647 1648 ztest_range_unlock(rl);
1648 1649 ztest_object_unlock(zd, lr->lr_foid);
1649 1650
1650 1651 return (0);
1651 1652 }
1652 1653
1653 1654 static int
1654 1655 ztest_replay_truncate(ztest_ds_t *zd, lr_truncate_t *lr, boolean_t byteswap)
1655 1656 {
1656 1657 objset_t *os = zd->zd_os;
1657 1658 dmu_tx_t *tx;
1658 1659 uint64_t txg;
1659 1660 rl_t *rl;
1660 1661
1661 1662 if (byteswap)
1662 1663 byteswap_uint64_array(lr, sizeof (*lr));
1663 1664
1664 1665 ztest_object_lock(zd, lr->lr_foid, RL_READER);
1665 1666 rl = ztest_range_lock(zd, lr->lr_foid, lr->lr_offset, lr->lr_length,
1666 1667 RL_WRITER);
1667 1668
1668 1669 tx = dmu_tx_create(os);
1669 1670
1670 1671 dmu_tx_hold_free(tx, lr->lr_foid, lr->lr_offset, lr->lr_length);
1671 1672
1672 1673 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
1673 1674 if (txg == 0) {
1674 1675 ztest_range_unlock(rl);
1675 1676 ztest_object_unlock(zd, lr->lr_foid);
1676 1677 return (ENOSPC);
1677 1678 }
1678 1679
1679 1680 VERIFY(dmu_free_range(os, lr->lr_foid, lr->lr_offset,
1680 1681 lr->lr_length, tx) == 0);
1681 1682
1682 1683 (void) ztest_log_truncate(zd, tx, lr);
1683 1684
1684 1685 dmu_tx_commit(tx);
1685 1686
1686 1687 ztest_range_unlock(rl);
1687 1688 ztest_object_unlock(zd, lr->lr_foid);
1688 1689
1689 1690 return (0);
1690 1691 }
1691 1692
1692 1693 static int
1693 1694 ztest_replay_setattr(ztest_ds_t *zd, lr_setattr_t *lr, boolean_t byteswap)
1694 1695 {
1695 1696 objset_t *os = zd->zd_os;
1696 1697 dmu_tx_t *tx;
1697 1698 dmu_buf_t *db;
1698 1699 ztest_block_tag_t *bbt;
1699 1700 uint64_t txg, lrtxg, crtxg;
1700 1701
1701 1702 if (byteswap)
1702 1703 byteswap_uint64_array(lr, sizeof (*lr));
1703 1704
1704 1705 ztest_object_lock(zd, lr->lr_foid, RL_WRITER);
1705 1706
1706 1707 VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
1707 1708
1708 1709 tx = dmu_tx_create(os);
1709 1710 dmu_tx_hold_bonus(tx, lr->lr_foid);
1710 1711
1711 1712 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
1712 1713 if (txg == 0) {
1713 1714 dmu_buf_rele(db, FTAG);
1714 1715 ztest_object_unlock(zd, lr->lr_foid);
1715 1716 return (ENOSPC);
1716 1717 }
1717 1718
1718 1719 bbt = ztest_bt_bonus(db);
1719 1720 ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
1720 1721 crtxg = bbt->bt_crtxg;
1721 1722 lrtxg = lr->lr_common.lrc_txg;
1722 1723
1723 1724 if (zd->zd_zilog->zl_replay) {
1724 1725 ASSERT(lr->lr_size != 0);
1725 1726 ASSERT(lr->lr_mode != 0);
1726 1727 ASSERT(lrtxg != 0);
1727 1728 } else {
1728 1729 /*
1729 1730 * Randomly change the size and increment the generation.
1730 1731 */
1731 1732 lr->lr_size = (ztest_random(db->db_size / sizeof (*bbt)) + 1) *
1732 1733 sizeof (*bbt);
1733 1734 lr->lr_mode = bbt->bt_gen + 1;
1734 1735 ASSERT(lrtxg == 0);
1735 1736 }
1736 1737
1737 1738 /*
1738 1739 * Verify that the current bonus buffer is not newer than our txg.
1739 1740 */
1740 1741 ztest_bt_verify(bbt, os, lr->lr_foid, -1ULL, lr->lr_mode,
1741 1742 MAX(txg, lrtxg), crtxg);
1742 1743
1743 1744 dmu_buf_will_dirty(db, tx);
1744 1745
1745 1746 ASSERT3U(lr->lr_size, >=, sizeof (*bbt));
1746 1747 ASSERT3U(lr->lr_size, <=, db->db_size);
1747 1748 VERIFY0(dmu_set_bonus(db, lr->lr_size, tx));
1748 1749 bbt = ztest_bt_bonus(db);
1749 1750
1750 1751 ztest_bt_generate(bbt, os, lr->lr_foid, -1ULL, lr->lr_mode, txg, crtxg);
1751 1752
1752 1753 dmu_buf_rele(db, FTAG);
1753 1754
1754 1755 (void) ztest_log_setattr(zd, tx, lr);
1755 1756
1756 1757 dmu_tx_commit(tx);
1757 1758
1758 1759 ztest_object_unlock(zd, lr->lr_foid);
1759 1760
1760 1761 return (0);
1761 1762 }
1762 1763
1763 1764 zil_replay_func_t *ztest_replay_vector[TX_MAX_TYPE] = {
1764 1765 NULL, /* 0 no such transaction type */
1765 1766 ztest_replay_create, /* TX_CREATE */
1766 1767 NULL, /* TX_MKDIR */
1767 1768 NULL, /* TX_MKXATTR */
1768 1769 NULL, /* TX_SYMLINK */
1769 1770 ztest_replay_remove, /* TX_REMOVE */
1770 1771 NULL, /* TX_RMDIR */
1771 1772 NULL, /* TX_LINK */
1772 1773 NULL, /* TX_RENAME */
1773 1774 ztest_replay_write, /* TX_WRITE */
1774 1775 ztest_replay_truncate, /* TX_TRUNCATE */
1775 1776 ztest_replay_setattr, /* TX_SETATTR */
1776 1777 NULL, /* TX_ACL */
1777 1778 NULL, /* TX_CREATE_ACL */
1778 1779 NULL, /* TX_CREATE_ATTR */
1779 1780 NULL, /* TX_CREATE_ACL_ATTR */
1780 1781 NULL, /* TX_MKDIR_ACL */
1781 1782 NULL, /* TX_MKDIR_ATTR */
1782 1783 NULL, /* TX_MKDIR_ACL_ATTR */
1783 1784 NULL, /* TX_WRITE2 */
1784 1785 };
1785 1786
1786 1787 /*
1787 1788 * ZIL get_data callbacks
1788 1789 */
1789 1790
1790 1791 static void
1791 1792 ztest_get_done(zgd_t *zgd, int error)
1792 1793 {
1793 1794 ztest_ds_t *zd = zgd->zgd_private;
1794 1795 uint64_t object = zgd->zgd_rl->rl_object;
1795 1796
1796 1797 if (zgd->zgd_db)
1797 1798 dmu_buf_rele(zgd->zgd_db, zgd);
1798 1799
1799 1800 ztest_range_unlock(zgd->zgd_rl);
1800 1801 ztest_object_unlock(zd, object);
1801 1802
1802 1803 if (error == 0 && zgd->zgd_bp)
1803 1804 zil_add_block(zgd->zgd_zilog, zgd->zgd_bp);
1804 1805
1805 1806 umem_free(zgd, sizeof (*zgd));
1806 1807 }
1807 1808
1808 1809 static int
1809 1810 ztest_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
1810 1811 {
1811 1812 ztest_ds_t *zd = arg;
1812 1813 objset_t *os = zd->zd_os;
1813 1814 uint64_t object = lr->lr_foid;
1814 1815 uint64_t offset = lr->lr_offset;
1815 1816 uint64_t size = lr->lr_length;
1816 1817 blkptr_t *bp = &lr->lr_blkptr;
1817 1818 uint64_t txg = lr->lr_common.lrc_txg;
1818 1819 uint64_t crtxg;
1819 1820 dmu_object_info_t doi;
1820 1821 dmu_buf_t *db;
1821 1822 zgd_t *zgd;
1822 1823 int error;
1823 1824
1824 1825 ztest_object_lock(zd, object, RL_READER);
1825 1826 error = dmu_bonus_hold(os, object, FTAG, &db);
1826 1827 if (error) {
1827 1828 ztest_object_unlock(zd, object);
1828 1829 return (error);
1829 1830 }
1830 1831
1831 1832 crtxg = ztest_bt_bonus(db)->bt_crtxg;
1832 1833
1833 1834 if (crtxg == 0 || crtxg > txg) {
1834 1835 dmu_buf_rele(db, FTAG);
1835 1836 ztest_object_unlock(zd, object);
1836 1837 return (ENOENT);
1837 1838 }
1838 1839
1839 1840 dmu_object_info_from_db(db, &doi);
1840 1841 dmu_buf_rele(db, FTAG);
1841 1842 db = NULL;
1842 1843
1843 1844 zgd = umem_zalloc(sizeof (*zgd), UMEM_NOFAIL);
1844 1845 zgd->zgd_zilog = zd->zd_zilog;
1845 1846 zgd->zgd_private = zd;
1846 1847
1847 1848 if (buf != NULL) { /* immediate write */
1848 1849 zgd->zgd_rl = ztest_range_lock(zd, object, offset, size,
1849 1850 RL_READER);
1850 1851
1851 1852 error = dmu_read(os, object, offset, size, buf,
1852 1853 DMU_READ_NO_PREFETCH);
1853 1854 ASSERT(error == 0);
1854 1855 } else {
1855 1856 size = doi.doi_data_block_size;
1856 1857 if (ISP2(size)) {
1857 1858 offset = P2ALIGN(offset, size);
1858 1859 } else {
1859 1860 ASSERT(offset < size);
1860 1861 offset = 0;
1861 1862 }
1862 1863
1863 1864 zgd->zgd_rl = ztest_range_lock(zd, object, offset, size,
1864 1865 RL_READER);
1865 1866
1866 1867 error = dmu_buf_hold(os, object, offset, zgd, &db,
1867 1868 DMU_READ_NO_PREFETCH);
1868 1869
1869 1870 if (error == 0) {
1870 1871 blkptr_t *obp = dmu_buf_get_blkptr(db);
1871 1872 if (obp) {
1872 1873 ASSERT(BP_IS_HOLE(bp));
1873 1874 *bp = *obp;
1874 1875 }
1875 1876
1876 1877 zgd->zgd_db = db;
1877 1878 zgd->zgd_bp = bp;
1878 1879
1879 1880 ASSERT(db->db_offset == offset);
1880 1881 ASSERT(db->db_size == size);
1881 1882
1882 1883 error = dmu_sync(zio, lr->lr_common.lrc_txg,
1883 1884 ztest_get_done, zgd);
1884 1885
1885 1886 if (error == 0)
1886 1887 return (0);
1887 1888 }
1888 1889 }
1889 1890
1890 1891 ztest_get_done(zgd, error);
1891 1892
1892 1893 return (error);
1893 1894 }
1894 1895
1895 1896 static void *
1896 1897 ztest_lr_alloc(size_t lrsize, char *name)
1897 1898 {
1898 1899 char *lr;
1899 1900 size_t namesize = name ? strlen(name) + 1 : 0;
1900 1901
1901 1902 lr = umem_zalloc(lrsize + namesize, UMEM_NOFAIL);
1902 1903
1903 1904 if (name)
1904 1905 bcopy(name, lr + lrsize, namesize);
1905 1906
1906 1907 return (lr);
1907 1908 }
1908 1909
1909 1910 void
1910 1911 ztest_lr_free(void *lr, size_t lrsize, char *name)
1911 1912 {
1912 1913 size_t namesize = name ? strlen(name) + 1 : 0;
1913 1914
1914 1915 umem_free(lr, lrsize + namesize);
1915 1916 }
1916 1917
1917 1918 /*
1918 1919 * Lookup a bunch of objects. Returns the number of objects not found.
1919 1920 */
1920 1921 static int
1921 1922 ztest_lookup(ztest_ds_t *zd, ztest_od_t *od, int count)
1922 1923 {
1923 1924 int missing = 0;
1924 1925 int error;
1925 1926
1926 1927 ASSERT(_mutex_held(&zd->zd_dirobj_lock));
1927 1928
1928 1929 for (int i = 0; i < count; i++, od++) {
1929 1930 od->od_object = 0;
1930 1931 error = zap_lookup(zd->zd_os, od->od_dir, od->od_name,
1931 1932 sizeof (uint64_t), 1, &od->od_object);
1932 1933 if (error) {
1933 1934 ASSERT(error == ENOENT);
1934 1935 ASSERT(od->od_object == 0);
1935 1936 missing++;
1936 1937 } else {
1937 1938 dmu_buf_t *db;
1938 1939 ztest_block_tag_t *bbt;
1939 1940 dmu_object_info_t doi;
1940 1941
1941 1942 ASSERT(od->od_object != 0);
1942 1943 ASSERT(missing == 0); /* there should be no gaps */
1943 1944
1944 1945 ztest_object_lock(zd, od->od_object, RL_READER);
1945 1946 VERIFY3U(0, ==, dmu_bonus_hold(zd->zd_os,
1946 1947 od->od_object, FTAG, &db));
1947 1948 dmu_object_info_from_db(db, &doi);
1948 1949 bbt = ztest_bt_bonus(db);
1949 1950 ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
1950 1951 od->od_type = doi.doi_type;
1951 1952 od->od_blocksize = doi.doi_data_block_size;
1952 1953 od->od_gen = bbt->bt_gen;
1953 1954 dmu_buf_rele(db, FTAG);
1954 1955 ztest_object_unlock(zd, od->od_object);
1955 1956 }
1956 1957 }
1957 1958
1958 1959 return (missing);
1959 1960 }
1960 1961
1961 1962 static int
1962 1963 ztest_create(ztest_ds_t *zd, ztest_od_t *od, int count)
1963 1964 {
1964 1965 int missing = 0;
1965 1966
1966 1967 ASSERT(_mutex_held(&zd->zd_dirobj_lock));
1967 1968
1968 1969 for (int i = 0; i < count; i++, od++) {
1969 1970 if (missing) {
1970 1971 od->od_object = 0;
1971 1972 missing++;
1972 1973 continue;
1973 1974 }
1974 1975
1975 1976 lr_create_t *lr = ztest_lr_alloc(sizeof (*lr), od->od_name);
1976 1977
1977 1978 lr->lr_doid = od->od_dir;
1978 1979 lr->lr_foid = 0; /* 0 to allocate, > 0 to claim */
1979 1980 lr->lrz_type = od->od_crtype;
1980 1981 lr->lrz_blocksize = od->od_crblocksize;
1981 1982 lr->lrz_ibshift = ztest_random_ibshift();
1982 1983 lr->lrz_bonustype = DMU_OT_UINT64_OTHER;
1983 1984 lr->lrz_bonuslen = dmu_bonus_max();
1984 1985 lr->lr_gen = od->od_crgen;
1985 1986 lr->lr_crtime[0] = time(NULL);
1986 1987
1987 1988 if (ztest_replay_create(zd, lr, B_FALSE) != 0) {
1988 1989 ASSERT(missing == 0);
1989 1990 od->od_object = 0;
1990 1991 missing++;
1991 1992 } else {
1992 1993 od->od_object = lr->lr_foid;
1993 1994 od->od_type = od->od_crtype;
1994 1995 od->od_blocksize = od->od_crblocksize;
1995 1996 od->od_gen = od->od_crgen;
1996 1997 ASSERT(od->od_object != 0);
1997 1998 }
1998 1999
1999 2000 ztest_lr_free(lr, sizeof (*lr), od->od_name);
2000 2001 }
2001 2002
2002 2003 return (missing);
2003 2004 }
2004 2005
2005 2006 static int
2006 2007 ztest_remove(ztest_ds_t *zd, ztest_od_t *od, int count)
2007 2008 {
2008 2009 int missing = 0;
2009 2010 int error;
2010 2011
2011 2012 ASSERT(_mutex_held(&zd->zd_dirobj_lock));
2012 2013
2013 2014 od += count - 1;
2014 2015
2015 2016 for (int i = count - 1; i >= 0; i--, od--) {
2016 2017 if (missing) {
2017 2018 missing++;
2018 2019 continue;
2019 2020 }
2020 2021
2021 2022 /*
2022 2023 * No object was found.
2023 2024 */
2024 2025 if (od->od_object == 0)
2025 2026 continue;
2026 2027
2027 2028 lr_remove_t *lr = ztest_lr_alloc(sizeof (*lr), od->od_name);
2028 2029
2029 2030 lr->lr_doid = od->od_dir;
2030 2031
2031 2032 if ((error = ztest_replay_remove(zd, lr, B_FALSE)) != 0) {
2032 2033 ASSERT3U(error, ==, ENOSPC);
2033 2034 missing++;
2034 2035 } else {
2035 2036 od->od_object = 0;
2036 2037 }
2037 2038 ztest_lr_free(lr, sizeof (*lr), od->od_name);
2038 2039 }
2039 2040
2040 2041 return (missing);
2041 2042 }
2042 2043
2043 2044 static int
2044 2045 ztest_write(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size,
2045 2046 void *data)
2046 2047 {
2047 2048 lr_write_t *lr;
2048 2049 int error;
2049 2050
2050 2051 lr = ztest_lr_alloc(sizeof (*lr) + size, NULL);
2051 2052
2052 2053 lr->lr_foid = object;
2053 2054 lr->lr_offset = offset;
2054 2055 lr->lr_length = size;
2055 2056 lr->lr_blkoff = 0;
2056 2057 BP_ZERO(&lr->lr_blkptr);
2057 2058
2058 2059 bcopy(data, lr + 1, size);
2059 2060
2060 2061 error = ztest_replay_write(zd, lr, B_FALSE);
2061 2062
2062 2063 ztest_lr_free(lr, sizeof (*lr) + size, NULL);
2063 2064
2064 2065 return (error);
2065 2066 }
2066 2067
2067 2068 static int
2068 2069 ztest_truncate(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
2069 2070 {
2070 2071 lr_truncate_t *lr;
2071 2072 int error;
2072 2073
2073 2074 lr = ztest_lr_alloc(sizeof (*lr), NULL);
2074 2075
2075 2076 lr->lr_foid = object;
2076 2077 lr->lr_offset = offset;
2077 2078 lr->lr_length = size;
2078 2079
2079 2080 error = ztest_replay_truncate(zd, lr, B_FALSE);
2080 2081
2081 2082 ztest_lr_free(lr, sizeof (*lr), NULL);
2082 2083
2083 2084 return (error);
2084 2085 }
2085 2086
2086 2087 static int
2087 2088 ztest_setattr(ztest_ds_t *zd, uint64_t object)
2088 2089 {
2089 2090 lr_setattr_t *lr;
2090 2091 int error;
2091 2092
2092 2093 lr = ztest_lr_alloc(sizeof (*lr), NULL);
2093 2094
2094 2095 lr->lr_foid = object;
2095 2096 lr->lr_size = 0;
2096 2097 lr->lr_mode = 0;
2097 2098
2098 2099 error = ztest_replay_setattr(zd, lr, B_FALSE);
2099 2100
2100 2101 ztest_lr_free(lr, sizeof (*lr), NULL);
2101 2102
2102 2103 return (error);
2103 2104 }
2104 2105
2105 2106 static void
2106 2107 ztest_prealloc(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
2107 2108 {
2108 2109 objset_t *os = zd->zd_os;
2109 2110 dmu_tx_t *tx;
2110 2111 uint64_t txg;
2111 2112 rl_t *rl;
2112 2113
2113 2114 txg_wait_synced(dmu_objset_pool(os), 0);
2114 2115
2115 2116 ztest_object_lock(zd, object, RL_READER);
2116 2117 rl = ztest_range_lock(zd, object, offset, size, RL_WRITER);
2117 2118
2118 2119 tx = dmu_tx_create(os);
2119 2120
2120 2121 dmu_tx_hold_write(tx, object, offset, size);
2121 2122
2122 2123 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
2123 2124
2124 2125 if (txg != 0) {
2125 2126 dmu_prealloc(os, object, offset, size, tx);
2126 2127 dmu_tx_commit(tx);
2127 2128 txg_wait_synced(dmu_objset_pool(os), txg);
2128 2129 } else {
2129 2130 (void) dmu_free_long_range(os, object, offset, size);
2130 2131 }
2131 2132
2132 2133 ztest_range_unlock(rl);
2133 2134 ztest_object_unlock(zd, object);
2134 2135 }
2135 2136
2136 2137 static void
2137 2138 ztest_io(ztest_ds_t *zd, uint64_t object, uint64_t offset)
2138 2139 {
2139 2140 int err;
2140 2141 ztest_block_tag_t wbt;
2141 2142 dmu_object_info_t doi;
2142 2143 enum ztest_io_type io_type;
2143 2144 uint64_t blocksize;
2144 2145 void *data;
2145 2146
2146 2147 VERIFY(dmu_object_info(zd->zd_os, object, &doi) == 0);
2147 2148 blocksize = doi.doi_data_block_size;
2148 2149 data = umem_alloc(blocksize, UMEM_NOFAIL);
2149 2150
2150 2151 /*
2151 2152 * Pick an i/o type at random, biased toward writing block tags.
2152 2153 */
2153 2154 io_type = ztest_random(ZTEST_IO_TYPES);
2154 2155 if (ztest_random(2) == 0)
2155 2156 io_type = ZTEST_IO_WRITE_TAG;
2156 2157
2157 2158 (void) rw_rdlock(&zd->zd_zilog_lock);
2158 2159
2159 2160 switch (io_type) {
2160 2161
2161 2162 case ZTEST_IO_WRITE_TAG:
2162 2163 ztest_bt_generate(&wbt, zd->zd_os, object, offset, 0, 0, 0);
2163 2164 (void) ztest_write(zd, object, offset, sizeof (wbt), &wbt);
2164 2165 break;
2165 2166
2166 2167 case ZTEST_IO_WRITE_PATTERN:
2167 2168 (void) memset(data, 'a' + (object + offset) % 5, blocksize);
2168 2169 if (ztest_random(2) == 0) {
2169 2170 /*
2170 2171 * Induce fletcher2 collisions to ensure that
2171 2172 * zio_ddt_collision() detects and resolves them
2172 2173 * when using fletcher2-verify for deduplication.
2173 2174 */
2174 2175 ((uint64_t *)data)[0] ^= 1ULL << 63;
2175 2176 ((uint64_t *)data)[4] ^= 1ULL << 63;
2176 2177 }
2177 2178 (void) ztest_write(zd, object, offset, blocksize, data);
2178 2179 break;
2179 2180
2180 2181 case ZTEST_IO_WRITE_ZEROES:
2181 2182 bzero(data, blocksize);
2182 2183 (void) ztest_write(zd, object, offset, blocksize, data);
2183 2184 break;
2184 2185
2185 2186 case ZTEST_IO_TRUNCATE:
2186 2187 (void) ztest_truncate(zd, object, offset, blocksize);
2187 2188 break;
2188 2189
2189 2190 case ZTEST_IO_SETATTR:
2190 2191 (void) ztest_setattr(zd, object);
2191 2192 break;
2192 2193
2193 2194 case ZTEST_IO_REWRITE:
2194 2195 (void) rw_rdlock(&ztest_name_lock);
2195 2196 err = ztest_dsl_prop_set_uint64(zd->zd_name,
2196 2197 ZFS_PROP_CHECKSUM, spa_dedup_checksum(ztest_spa),
2197 2198 B_FALSE);
2198 2199 VERIFY(err == 0 || err == ENOSPC);
2199 2200 err = ztest_dsl_prop_set_uint64(zd->zd_name,
2200 2201 ZFS_PROP_COMPRESSION,
2201 2202 ztest_random_dsl_prop(ZFS_PROP_COMPRESSION),
2202 2203 B_FALSE);
2203 2204 VERIFY(err == 0 || err == ENOSPC);
2204 2205 (void) rw_unlock(&ztest_name_lock);
2205 2206
2206 2207 VERIFY0(dmu_read(zd->zd_os, object, offset, blocksize, data,
2207 2208 DMU_READ_NO_PREFETCH));
2208 2209
2209 2210 (void) ztest_write(zd, object, offset, blocksize, data);
2210 2211 break;
2211 2212 }
2212 2213
2213 2214 (void) rw_unlock(&zd->zd_zilog_lock);
2214 2215
2215 2216 umem_free(data, blocksize);
2216 2217 }
2217 2218
2218 2219 /*
2219 2220 * Initialize an object description template.
2220 2221 */
2221 2222 static void
2222 2223 ztest_od_init(ztest_od_t *od, uint64_t id, char *tag, uint64_t index,
2223 2224 dmu_object_type_t type, uint64_t blocksize, uint64_t gen)
2224 2225 {
2225 2226 od->od_dir = ZTEST_DIROBJ;
2226 2227 od->od_object = 0;
2227 2228
2228 2229 od->od_crtype = type;
2229 2230 od->od_crblocksize = blocksize ? blocksize : ztest_random_blocksize();
2230 2231 od->od_crgen = gen;
2231 2232
2232 2233 od->od_type = DMU_OT_NONE;
2233 2234 od->od_blocksize = 0;
2234 2235 od->od_gen = 0;
2235 2236
2236 2237 (void) snprintf(od->od_name, sizeof (od->od_name), "%s(%lld)[%llu]",
2237 2238 tag, (int64_t)id, index);
2238 2239 }
2239 2240
2240 2241 /*
2241 2242 * Lookup or create the objects for a test using the od template.
2242 2243 * If the objects do not all exist, or if 'remove' is specified,
2243 2244 * remove any existing objects and create new ones. Otherwise,
2244 2245 * use the existing objects.
2245 2246 */
2246 2247 static int
2247 2248 ztest_object_init(ztest_ds_t *zd, ztest_od_t *od, size_t size, boolean_t remove)
2248 2249 {
2249 2250 int count = size / sizeof (*od);
2250 2251 int rv = 0;
2251 2252
2252 2253 VERIFY(mutex_lock(&zd->zd_dirobj_lock) == 0);
2253 2254 if ((ztest_lookup(zd, od, count) != 0 || remove) &&
2254 2255 (ztest_remove(zd, od, count) != 0 ||
2255 2256 ztest_create(zd, od, count) != 0))
2256 2257 rv = -1;
2257 2258 zd->zd_od = od;
2258 2259 VERIFY(mutex_unlock(&zd->zd_dirobj_lock) == 0);
2259 2260
2260 2261 return (rv);
2261 2262 }
2262 2263
2263 2264 /* ARGSUSED */
2264 2265 void
2265 2266 ztest_zil_commit(ztest_ds_t *zd, uint64_t id)
2266 2267 {
2267 2268 zilog_t *zilog = zd->zd_zilog;
2268 2269
2269 2270 (void) rw_rdlock(&zd->zd_zilog_lock);
2270 2271
2271 2272 zil_commit(zilog, ztest_random(ZTEST_OBJECTS));
2272 2273
2273 2274 /*
2274 2275 * Remember the committed values in zd, which is in parent/child
2275 2276 * shared memory. If we die, the next iteration of ztest_run()
2276 2277 * will verify that the log really does contain this record.
2277 2278 */
2278 2279 mutex_enter(&zilog->zl_lock);
2279 2280 ASSERT(zd->zd_shared != NULL);
2280 2281 ASSERT3U(zd->zd_shared->zd_seq, <=, zilog->zl_commit_lr_seq);
2281 2282 zd->zd_shared->zd_seq = zilog->zl_commit_lr_seq;
2282 2283 mutex_exit(&zilog->zl_lock);
2283 2284
2284 2285 (void) rw_unlock(&zd->zd_zilog_lock);
2285 2286 }
2286 2287
2287 2288 /*
2288 2289 * This function is designed to simulate the operations that occur during a
2289 2290 * mount/unmount operation. We hold the dataset across these operations in an
2290 2291 * attempt to expose any implicit assumptions about ZIL management.
2291 2292 */
2292 2293 /* ARGSUSED */
2293 2294 void
2294 2295 ztest_zil_remount(ztest_ds_t *zd, uint64_t id)
2295 2296 {
2296 2297 objset_t *os = zd->zd_os;
2297 2298
2298 2299 /*
2299 2300 * We grab the zd_dirobj_lock to ensure that no other thread is
2300 2301 * updating the zil (i.e. adding in-memory log records) and the
2301 2302 * zd_zilog_lock to block any I/O.
2302 2303 */
2303 2304 VERIFY0(mutex_lock(&zd->zd_dirobj_lock));
2304 2305 (void) rw_wrlock(&zd->zd_zilog_lock);
2305 2306
2306 2307 /* zfsvfs_teardown() */
2307 2308 zil_close(zd->zd_zilog);
2308 2309
2309 2310 /* zfsvfs_setup() */
2310 2311 VERIFY(zil_open(os, ztest_get_data) == zd->zd_zilog);
2311 2312 zil_replay(os, zd, ztest_replay_vector);
2312 2313
2313 2314 (void) rw_unlock(&zd->zd_zilog_lock);
2314 2315 VERIFY(mutex_unlock(&zd->zd_dirobj_lock) == 0);
2315 2316 }
2316 2317
2317 2318 /*
2318 2319 * Verify that we can't destroy an active pool, create an existing pool,
2319 2320 * or create a pool with a bad vdev spec.
2320 2321 */
2321 2322 /* ARGSUSED */
2322 2323 void
2323 2324 ztest_spa_create_destroy(ztest_ds_t *zd, uint64_t id)
2324 2325 {
2325 2326 ztest_shared_opts_t *zo = &ztest_opts;
2326 2327 spa_t *spa;
2327 2328 nvlist_t *nvroot;
2328 2329
2329 2330 /*
2330 2331 * Attempt to create using a bad file.
2331 2332 */
2332 2333 nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, 0, 0, 0, 1);
2333 2334 VERIFY3U(ENOENT, ==,
2334 2335 spa_create("ztest_bad_file", nvroot, NULL, NULL));
2335 2336 nvlist_free(nvroot);
2336 2337
2337 2338 /*
2338 2339 * Attempt to create using a bad mirror.
2339 2340 */
2340 2341 nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, 0, 0, 2, 1);
2341 2342 VERIFY3U(ENOENT, ==,
2342 2343 spa_create("ztest_bad_mirror", nvroot, NULL, NULL));
2343 2344 nvlist_free(nvroot);
2344 2345
2345 2346 /*
2346 2347 * Attempt to create an existing pool. It shouldn't matter
2347 2348 * what's in the nvroot; we should fail with EEXIST.
2348 2349 */
2349 2350 (void) rw_rdlock(&ztest_name_lock);
2350 2351 nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, 0, 0, 0, 1);
2351 2352 VERIFY3U(EEXIST, ==, spa_create(zo->zo_pool, nvroot, NULL, NULL));
2352 2353 nvlist_free(nvroot);
2353 2354 VERIFY3U(0, ==, spa_open(zo->zo_pool, &spa, FTAG));
2354 2355 VERIFY3U(EBUSY, ==, spa_destroy(zo->zo_pool));
2355 2356 spa_close(spa, FTAG);
2356 2357
2357 2358 (void) rw_unlock(&ztest_name_lock);
2358 2359 }
2359 2360
2360 2361 /* ARGSUSED */
2361 2362 void
2362 2363 ztest_spa_upgrade(ztest_ds_t *zd, uint64_t id)
2363 2364 {
2364 2365 spa_t *spa;
2365 2366 uint64_t initial_version = SPA_VERSION_INITIAL;
2366 2367 uint64_t version, newversion;
2367 2368 nvlist_t *nvroot, *props;
2368 2369 char *name;
2369 2370
2370 2371 VERIFY0(mutex_lock(&ztest_vdev_lock));
2371 2372 name = kmem_asprintf("%s_upgrade", ztest_opts.zo_pool);
2372 2373
2373 2374 /*
2374 2375 * Clean up from previous runs.
2375 2376 */
2376 2377 (void) spa_destroy(name);
2377 2378
2378 2379 nvroot = make_vdev_root(NULL, NULL, name, ztest_opts.zo_vdev_size, 0,
2379 2380 0, ztest_opts.zo_raidz, ztest_opts.zo_mirrors, 1);
2380 2381
2381 2382 /*
2382 2383 * If we're configuring a RAIDZ device then make sure that the
2383 2384 * the initial version is capable of supporting that feature.
2384 2385 */
2385 2386 switch (ztest_opts.zo_raidz_parity) {
2386 2387 case 0:
2387 2388 case 1:
2388 2389 initial_version = SPA_VERSION_INITIAL;
2389 2390 break;
2390 2391 case 2:
2391 2392 initial_version = SPA_VERSION_RAIDZ2;
2392 2393 break;
2393 2394 case 3:
2394 2395 initial_version = SPA_VERSION_RAIDZ3;
2395 2396 break;
2396 2397 }
2397 2398
2398 2399 /*
2399 2400 * Create a pool with a spa version that can be upgraded. Pick
2400 2401 * a value between initial_version and SPA_VERSION_BEFORE_FEATURES.
2401 2402 */
2402 2403 do {
2403 2404 version = ztest_random_spa_version(initial_version);
2404 2405 } while (version > SPA_VERSION_BEFORE_FEATURES);
2405 2406
2406 2407 props = fnvlist_alloc();
2407 2408 fnvlist_add_uint64(props,
2408 2409 zpool_prop_to_name(ZPOOL_PROP_VERSION), version);
2409 2410 VERIFY0(spa_create(name, nvroot, props, NULL));
2410 2411 fnvlist_free(nvroot);
2411 2412 fnvlist_free(props);
2412 2413
2413 2414 VERIFY0(spa_open(name, &spa, FTAG));
2414 2415 VERIFY3U(spa_version(spa), ==, version);
2415 2416 newversion = ztest_random_spa_version(version + 1);
2416 2417
2417 2418 if (ztest_opts.zo_verbose >= 4) {
2418 2419 (void) printf("upgrading spa version from %llu to %llu\n",
2419 2420 (u_longlong_t)version, (u_longlong_t)newversion);
2420 2421 }
2421 2422
2422 2423 spa_upgrade(spa, newversion);
2423 2424 VERIFY3U(spa_version(spa), >, version);
2424 2425 VERIFY3U(spa_version(spa), ==, fnvlist_lookup_uint64(spa->spa_config,
2425 2426 zpool_prop_to_name(ZPOOL_PROP_VERSION)));
2426 2427 spa_close(spa, FTAG);
2427 2428
2428 2429 strfree(name);
2429 2430 VERIFY0(mutex_unlock(&ztest_vdev_lock));
2430 2431 }
2431 2432
2432 2433 static vdev_t *
2433 2434 vdev_lookup_by_path(vdev_t *vd, const char *path)
2434 2435 {
2435 2436 vdev_t *mvd;
2436 2437
2437 2438 if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0)
2438 2439 return (vd);
2439 2440
2440 2441 for (int c = 0; c < vd->vdev_children; c++)
2441 2442 if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
2442 2443 NULL)
2443 2444 return (mvd);
2444 2445
2445 2446 return (NULL);
2446 2447 }
2447 2448
2448 2449 /*
2449 2450 * Find the first available hole which can be used as a top-level.
2450 2451 */
2451 2452 int
2452 2453 find_vdev_hole(spa_t *spa)
2453 2454 {
2454 2455 vdev_t *rvd = spa->spa_root_vdev;
2455 2456 int c;
2456 2457
2457 2458 ASSERT(spa_config_held(spa, SCL_VDEV, RW_READER) == SCL_VDEV);
2458 2459
2459 2460 for (c = 0; c < rvd->vdev_children; c++) {
2460 2461 vdev_t *cvd = rvd->vdev_child[c];
2461 2462
2462 2463 if (cvd->vdev_ishole)
2463 2464 break;
2464 2465 }
2465 2466 return (c);
2466 2467 }
2467 2468
2468 2469 /*
2469 2470 * Verify that vdev_add() works as expected.
2470 2471 */
2471 2472 /* ARGSUSED */
2472 2473 void
2473 2474 ztest_vdev_add_remove(ztest_ds_t *zd, uint64_t id)
2474 2475 {
2475 2476 ztest_shared_t *zs = ztest_shared;
2476 2477 spa_t *spa = ztest_spa;
2477 2478 uint64_t leaves;
2478 2479 uint64_t guid;
2479 2480 nvlist_t *nvroot;
2480 2481 int error;
2481 2482
2482 2483 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
2483 2484 leaves = MAX(zs->zs_mirrors + zs->zs_splits, 1) * ztest_opts.zo_raidz;
2484 2485
2485 2486 spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
2486 2487
2487 2488 ztest_shared->zs_vdev_next_leaf = find_vdev_hole(spa) * leaves;
2488 2489
2489 2490 /*
2490 2491 * If we have slogs then remove them 1/4 of the time.
2491 2492 */
2492 2493 if (spa_has_slogs(spa) && ztest_random(4) == 0) {
2493 2494 /*
2494 2495 * Grab the guid from the head of the log class rotor.
2495 2496 */
2496 2497 guid = spa_log_class(spa)->mc_rotor->mg_vd->vdev_guid;
2497 2498
2498 2499 spa_config_exit(spa, SCL_VDEV, FTAG);
2499 2500
2500 2501 /*
2501 2502 * We have to grab the zs_name_lock as writer to
2502 2503 * prevent a race between removing a slog (dmu_objset_find)
2503 2504 * and destroying a dataset. Removing the slog will
2504 2505 * grab a reference on the dataset which may cause
2505 2506 * dmu_objset_destroy() to fail with EBUSY thus
2506 2507 * leaving the dataset in an inconsistent state.
2507 2508 */
2508 2509 VERIFY(rw_wrlock(&ztest_name_lock) == 0);
2509 2510 error = spa_vdev_remove(spa, guid, B_FALSE);
2510 2511 VERIFY(rw_unlock(&ztest_name_lock) == 0);
2511 2512
2512 2513 if (error && error != EEXIST)
2513 2514 fatal(0, "spa_vdev_remove() = %d", error);
2514 2515 } else {
2515 2516 spa_config_exit(spa, SCL_VDEV, FTAG);
2516 2517
2517 2518 /*
2518 2519 * Make 1/4 of the devices be log devices.
2519 2520 */
2520 2521 nvroot = make_vdev_root(NULL, NULL, NULL,
2521 2522 ztest_opts.zo_vdev_size, 0,
2522 2523 ztest_random(4) == 0, ztest_opts.zo_raidz,
2523 2524 zs->zs_mirrors, 1);
2524 2525
2525 2526 error = spa_vdev_add(spa, nvroot);
2526 2527 nvlist_free(nvroot);
2527 2528
2528 2529 if (error == ENOSPC)
2529 2530 ztest_record_enospc("spa_vdev_add");
2530 2531 else if (error != 0)
2531 2532 fatal(0, "spa_vdev_add() = %d", error);
2532 2533 }
2533 2534
2534 2535 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
2535 2536 }
2536 2537
2537 2538 /*
2538 2539 * Verify that adding/removing aux devices (l2arc, hot spare) works as expected.
2539 2540 */
2540 2541 /* ARGSUSED */
2541 2542 void
2542 2543 ztest_vdev_aux_add_remove(ztest_ds_t *zd, uint64_t id)
2543 2544 {
2544 2545 ztest_shared_t *zs = ztest_shared;
2545 2546 spa_t *spa = ztest_spa;
2546 2547 vdev_t *rvd = spa->spa_root_vdev;
2547 2548 spa_aux_vdev_t *sav;
2548 2549 char *aux;
2549 2550 uint64_t guid = 0;
2550 2551 int error;
2551 2552
2552 2553 if (ztest_random(2) == 0) {
2553 2554 sav = &spa->spa_spares;
2554 2555 aux = ZPOOL_CONFIG_SPARES;
2555 2556 } else {
2556 2557 sav = &spa->spa_l2cache;
2557 2558 aux = ZPOOL_CONFIG_L2CACHE;
2558 2559 }
2559 2560
2560 2561 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
2561 2562
2562 2563 spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
2563 2564
2564 2565 if (sav->sav_count != 0 && ztest_random(4) == 0) {
2565 2566 /*
2566 2567 * Pick a random device to remove.
2567 2568 */
2568 2569 guid = sav->sav_vdevs[ztest_random(sav->sav_count)]->vdev_guid;
2569 2570 } else {
2570 2571 /*
2571 2572 * Find an unused device we can add.
2572 2573 */
2573 2574 zs->zs_vdev_aux = 0;
2574 2575 for (;;) {
2575 2576 char path[MAXPATHLEN];
2576 2577 int c;
2577 2578 (void) snprintf(path, sizeof (path), ztest_aux_template,
2578 2579 ztest_opts.zo_dir, ztest_opts.zo_pool, aux,
2579 2580 zs->zs_vdev_aux);
2580 2581 for (c = 0; c < sav->sav_count; c++)
2581 2582 if (strcmp(sav->sav_vdevs[c]->vdev_path,
2582 2583 path) == 0)
2583 2584 break;
2584 2585 if (c == sav->sav_count &&
2585 2586 vdev_lookup_by_path(rvd, path) == NULL)
2586 2587 break;
2587 2588 zs->zs_vdev_aux++;
2588 2589 }
2589 2590 }
2590 2591
2591 2592 spa_config_exit(spa, SCL_VDEV, FTAG);
2592 2593
2593 2594 if (guid == 0) {
2594 2595 /*
2595 2596 * Add a new device.
2596 2597 */
2597 2598 nvlist_t *nvroot = make_vdev_root(NULL, aux, NULL,
2598 2599 (ztest_opts.zo_vdev_size * 5) / 4, 0, 0, 0, 0, 1);
2599 2600 error = spa_vdev_add(spa, nvroot);
2600 2601 if (error != 0)
2601 2602 fatal(0, "spa_vdev_add(%p) = %d", nvroot, error);
2602 2603 nvlist_free(nvroot);
2603 2604 } else {
2604 2605 /*
2605 2606 * Remove an existing device. Sometimes, dirty its
2606 2607 * vdev state first to make sure we handle removal
2607 2608 * of devices that have pending state changes.
2608 2609 */
2609 2610 if (ztest_random(2) == 0)
2610 2611 (void) vdev_online(spa, guid, 0, NULL);
2611 2612
2612 2613 error = spa_vdev_remove(spa, guid, B_FALSE);
2613 2614 if (error != 0 && error != EBUSY)
2614 2615 fatal(0, "spa_vdev_remove(%llu) = %d", guid, error);
2615 2616 }
2616 2617
2617 2618 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
2618 2619 }
2619 2620
2620 2621 /*
2621 2622 * split a pool if it has mirror tlvdevs
2622 2623 */
2623 2624 /* ARGSUSED */
2624 2625 void
2625 2626 ztest_split_pool(ztest_ds_t *zd, uint64_t id)
2626 2627 {
2627 2628 ztest_shared_t *zs = ztest_shared;
2628 2629 spa_t *spa = ztest_spa;
2629 2630 vdev_t *rvd = spa->spa_root_vdev;
2630 2631 nvlist_t *tree, **child, *config, *split, **schild;
2631 2632 uint_t c, children, schildren = 0, lastlogid = 0;
2632 2633 int error = 0;
2633 2634
2634 2635 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
2635 2636
2636 2637 /* ensure we have a useable config; mirrors of raidz aren't supported */
2637 2638 if (zs->zs_mirrors < 3 || ztest_opts.zo_raidz > 1) {
2638 2639 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
2639 2640 return;
2640 2641 }
2641 2642
2642 2643 /* clean up the old pool, if any */
2643 2644 (void) spa_destroy("splitp");
2644 2645
2645 2646 spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
2646 2647
2647 2648 /* generate a config from the existing config */
2648 2649 mutex_enter(&spa->spa_props_lock);
2649 2650 VERIFY(nvlist_lookup_nvlist(spa->spa_config, ZPOOL_CONFIG_VDEV_TREE,
2650 2651 &tree) == 0);
2651 2652 mutex_exit(&spa->spa_props_lock);
2652 2653
2653 2654 VERIFY(nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN, &child,
2654 2655 &children) == 0);
2655 2656
2656 2657 schild = malloc(rvd->vdev_children * sizeof (nvlist_t *));
2657 2658 for (c = 0; c < children; c++) {
2658 2659 vdev_t *tvd = rvd->vdev_child[c];
2659 2660 nvlist_t **mchild;
2660 2661 uint_t mchildren;
2661 2662
2662 2663 if (tvd->vdev_islog || tvd->vdev_ops == &vdev_hole_ops) {
2663 2664 VERIFY(nvlist_alloc(&schild[schildren], NV_UNIQUE_NAME,
2664 2665 0) == 0);
2665 2666 VERIFY(nvlist_add_string(schild[schildren],
2666 2667 ZPOOL_CONFIG_TYPE, VDEV_TYPE_HOLE) == 0);
2667 2668 VERIFY(nvlist_add_uint64(schild[schildren],
2668 2669 ZPOOL_CONFIG_IS_HOLE, 1) == 0);
2669 2670 if (lastlogid == 0)
2670 2671 lastlogid = schildren;
2671 2672 ++schildren;
2672 2673 continue;
2673 2674 }
2674 2675 lastlogid = 0;
2675 2676 VERIFY(nvlist_lookup_nvlist_array(child[c],
2676 2677 ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren) == 0);
2677 2678 VERIFY(nvlist_dup(mchild[0], &schild[schildren++], 0) == 0);
2678 2679 }
2679 2680
2680 2681 /* OK, create a config that can be used to split */
2681 2682 VERIFY(nvlist_alloc(&split, NV_UNIQUE_NAME, 0) == 0);
2682 2683 VERIFY(nvlist_add_string(split, ZPOOL_CONFIG_TYPE,
2683 2684 VDEV_TYPE_ROOT) == 0);
2684 2685 VERIFY(nvlist_add_nvlist_array(split, ZPOOL_CONFIG_CHILDREN, schild,
2685 2686 lastlogid != 0 ? lastlogid : schildren) == 0);
2686 2687
2687 2688 VERIFY(nvlist_alloc(&config, NV_UNIQUE_NAME, 0) == 0);
2688 2689 VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, split) == 0);
2689 2690
2690 2691 for (c = 0; c < schildren; c++)
2691 2692 nvlist_free(schild[c]);
2692 2693 free(schild);
2693 2694 nvlist_free(split);
2694 2695
2695 2696 spa_config_exit(spa, SCL_VDEV, FTAG);
2696 2697
2697 2698 (void) rw_wrlock(&ztest_name_lock);
2698 2699 error = spa_vdev_split_mirror(spa, "splitp", config, NULL, B_FALSE);
2699 2700 (void) rw_unlock(&ztest_name_lock);
2700 2701
2701 2702 nvlist_free(config);
2702 2703
2703 2704 if (error == 0) {
2704 2705 (void) printf("successful split - results:\n");
2705 2706 mutex_enter(&spa_namespace_lock);
2706 2707 show_pool_stats(spa);
2707 2708 show_pool_stats(spa_lookup("splitp"));
2708 2709 mutex_exit(&spa_namespace_lock);
2709 2710 ++zs->zs_splits;
2710 2711 --zs->zs_mirrors;
2711 2712 }
2712 2713 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
2713 2714
2714 2715 }
2715 2716
2716 2717 /*
2717 2718 * Verify that we can attach and detach devices.
2718 2719 */
2719 2720 /* ARGSUSED */
2720 2721 void
2721 2722 ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
2722 2723 {
2723 2724 ztest_shared_t *zs = ztest_shared;
2724 2725 spa_t *spa = ztest_spa;
2725 2726 spa_aux_vdev_t *sav = &spa->spa_spares;
2726 2727 vdev_t *rvd = spa->spa_root_vdev;
2727 2728 vdev_t *oldvd, *newvd, *pvd;
2728 2729 nvlist_t *root;
2729 2730 uint64_t leaves;
2730 2731 uint64_t leaf, top;
2731 2732 uint64_t ashift = ztest_get_ashift();
2732 2733 uint64_t oldguid, pguid;
2733 2734 size_t oldsize, newsize;
2734 2735 char oldpath[MAXPATHLEN], newpath[MAXPATHLEN];
2735 2736 int replacing;
2736 2737 int oldvd_has_siblings = B_FALSE;
2737 2738 int newvd_is_spare = B_FALSE;
2738 2739 int oldvd_is_log;
2739 2740 int error, expected_error;
2740 2741
2741 2742 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
2742 2743 leaves = MAX(zs->zs_mirrors, 1) * ztest_opts.zo_raidz;
2743 2744
2744 2745 spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
2745 2746
2746 2747 /*
2747 2748 * Decide whether to do an attach or a replace.
2748 2749 */
2749 2750 replacing = ztest_random(2);
2750 2751
2751 2752 /*
2752 2753 * Pick a random top-level vdev.
2753 2754 */
2754 2755 top = ztest_random_vdev_top(spa, B_TRUE);
2755 2756
2756 2757 /*
2757 2758 * Pick a random leaf within it.
2758 2759 */
2759 2760 leaf = ztest_random(leaves);
2760 2761
2761 2762 /*
2762 2763 * Locate this vdev.
2763 2764 */
2764 2765 oldvd = rvd->vdev_child[top];
2765 2766 if (zs->zs_mirrors >= 1) {
2766 2767 ASSERT(oldvd->vdev_ops == &vdev_mirror_ops);
2767 2768 ASSERT(oldvd->vdev_children >= zs->zs_mirrors);
2768 2769 oldvd = oldvd->vdev_child[leaf / ztest_opts.zo_raidz];
2769 2770 }
2770 2771 if (ztest_opts.zo_raidz > 1) {
2771 2772 ASSERT(oldvd->vdev_ops == &vdev_raidz_ops);
2772 2773 ASSERT(oldvd->vdev_children == ztest_opts.zo_raidz);
2773 2774 oldvd = oldvd->vdev_child[leaf % ztest_opts.zo_raidz];
2774 2775 }
2775 2776
2776 2777 /*
2777 2778 * If we're already doing an attach or replace, oldvd may be a
2778 2779 * mirror vdev -- in which case, pick a random child.
2779 2780 */
2780 2781 while (oldvd->vdev_children != 0) {
2781 2782 oldvd_has_siblings = B_TRUE;
2782 2783 ASSERT(oldvd->vdev_children >= 2);
2783 2784 oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)];
2784 2785 }
2785 2786
2786 2787 oldguid = oldvd->vdev_guid;
2787 2788 oldsize = vdev_get_min_asize(oldvd);
2788 2789 oldvd_is_log = oldvd->vdev_top->vdev_islog;
2789 2790 (void) strcpy(oldpath, oldvd->vdev_path);
2790 2791 pvd = oldvd->vdev_parent;
2791 2792 pguid = pvd->vdev_guid;
2792 2793
2793 2794 /*
2794 2795 * If oldvd has siblings, then half of the time, detach it.
2795 2796 */
2796 2797 if (oldvd_has_siblings && ztest_random(2) == 0) {
2797 2798 spa_config_exit(spa, SCL_VDEV, FTAG);
2798 2799 error = spa_vdev_detach(spa, oldguid, pguid, B_FALSE);
2799 2800 if (error != 0 && error != ENODEV && error != EBUSY &&
2800 2801 error != ENOTSUP)
2801 2802 fatal(0, "detach (%s) returned %d", oldpath, error);
2802 2803 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
2803 2804 return;
2804 2805 }
2805 2806
2806 2807 /*
2807 2808 * For the new vdev, choose with equal probability between the two
2808 2809 * standard paths (ending in either 'a' or 'b') or a random hot spare.
2809 2810 */
2810 2811 if (sav->sav_count != 0 && ztest_random(3) == 0) {
2811 2812 newvd = sav->sav_vdevs[ztest_random(sav->sav_count)];
2812 2813 newvd_is_spare = B_TRUE;
2813 2814 (void) strcpy(newpath, newvd->vdev_path);
2814 2815 } else {
2815 2816 (void) snprintf(newpath, sizeof (newpath), ztest_dev_template,
2816 2817 ztest_opts.zo_dir, ztest_opts.zo_pool,
2817 2818 top * leaves + leaf);
2818 2819 if (ztest_random(2) == 0)
2819 2820 newpath[strlen(newpath) - 1] = 'b';
2820 2821 newvd = vdev_lookup_by_path(rvd, newpath);
2821 2822 }
2822 2823
2823 2824 if (newvd) {
2824 2825 newsize = vdev_get_min_asize(newvd);
2825 2826 } else {
2826 2827 /*
2827 2828 * Make newsize a little bigger or smaller than oldsize.
2828 2829 * If it's smaller, the attach should fail.
2829 2830 * If it's larger, and we're doing a replace,
2830 2831 * we should get dynamic LUN growth when we're done.
2831 2832 */
2832 2833 newsize = 10 * oldsize / (9 + ztest_random(3));
2833 2834 }
2834 2835
2835 2836 /*
2836 2837 * If pvd is not a mirror or root, the attach should fail with ENOTSUP,
2837 2838 * unless it's a replace; in that case any non-replacing parent is OK.
2838 2839 *
2839 2840 * If newvd is already part of the pool, it should fail with EBUSY.
2840 2841 *
2841 2842 * If newvd is too small, it should fail with EOVERFLOW.
2842 2843 */
2843 2844 if (pvd->vdev_ops != &vdev_mirror_ops &&
2844 2845 pvd->vdev_ops != &vdev_root_ops && (!replacing ||
2845 2846 pvd->vdev_ops == &vdev_replacing_ops ||
2846 2847 pvd->vdev_ops == &vdev_spare_ops))
2847 2848 expected_error = ENOTSUP;
2848 2849 else if (newvd_is_spare && (!replacing || oldvd_is_log))
2849 2850 expected_error = ENOTSUP;
2850 2851 else if (newvd == oldvd)
2851 2852 expected_error = replacing ? 0 : EBUSY;
2852 2853 else if (vdev_lookup_by_path(rvd, newpath) != NULL)
2853 2854 expected_error = EBUSY;
2854 2855 else if (newsize < oldsize)
2855 2856 expected_error = EOVERFLOW;
2856 2857 else if (ashift > oldvd->vdev_top->vdev_ashift)
2857 2858 expected_error = EDOM;
2858 2859 else
2859 2860 expected_error = 0;
2860 2861
2861 2862 spa_config_exit(spa, SCL_VDEV, FTAG);
2862 2863
2863 2864 /*
2864 2865 * Build the nvlist describing newpath.
2865 2866 */
2866 2867 root = make_vdev_root(newpath, NULL, NULL, newvd == NULL ? newsize : 0,
2867 2868 ashift, 0, 0, 0, 1);
2868 2869
2869 2870 error = spa_vdev_attach(spa, oldguid, root, replacing);
2870 2871
2871 2872 nvlist_free(root);
2872 2873
2873 2874 /*
2874 2875 * If our parent was the replacing vdev, but the replace completed,
2875 2876 * then instead of failing with ENOTSUP we may either succeed,
2876 2877 * fail with ENODEV, or fail with EOVERFLOW.
2877 2878 */
2878 2879 if (expected_error == ENOTSUP &&
2879 2880 (error == 0 || error == ENODEV || error == EOVERFLOW))
2880 2881 expected_error = error;
2881 2882
2882 2883 /*
2883 2884 * If someone grew the LUN, the replacement may be too small.
2884 2885 */
2885 2886 if (error == EOVERFLOW || error == EBUSY)
2886 2887 expected_error = error;
2887 2888
2888 2889 /* XXX workaround 6690467 */
2889 2890 if (error != expected_error && expected_error != EBUSY) {
2890 2891 fatal(0, "attach (%s %llu, %s %llu, %d) "
2891 2892 "returned %d, expected %d",
2892 2893 oldpath, (longlong_t)oldsize, newpath,
2893 2894 (longlong_t)newsize, replacing, error, expected_error);
2894 2895 }
2895 2896
2896 2897 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
2897 2898 }
2898 2899
2899 2900 /*
2900 2901 * Callback function which expands the physical size of the vdev.
2901 2902 */
2902 2903 vdev_t *
2903 2904 grow_vdev(vdev_t *vd, void *arg)
2904 2905 {
2905 2906 spa_t *spa = vd->vdev_spa;
2906 2907 size_t *newsize = arg;
2907 2908 size_t fsize;
2908 2909 int fd;
2909 2910
2910 2911 ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE);
2911 2912 ASSERT(vd->vdev_ops->vdev_op_leaf);
2912 2913
2913 2914 if ((fd = open(vd->vdev_path, O_RDWR)) == -1)
2914 2915 return (vd);
2915 2916
2916 2917 fsize = lseek(fd, 0, SEEK_END);
2917 2918 (void) ftruncate(fd, *newsize);
2918 2919
2919 2920 if (ztest_opts.zo_verbose >= 6) {
2920 2921 (void) printf("%s grew from %lu to %lu bytes\n",
2921 2922 vd->vdev_path, (ulong_t)fsize, (ulong_t)*newsize);
2922 2923 }
2923 2924 (void) close(fd);
2924 2925 return (NULL);
2925 2926 }
2926 2927
2927 2928 /*
2928 2929 * Callback function which expands a given vdev by calling vdev_online().
2929 2930 */
2930 2931 /* ARGSUSED */
2931 2932 vdev_t *
2932 2933 online_vdev(vdev_t *vd, void *arg)
2933 2934 {
2934 2935 spa_t *spa = vd->vdev_spa;
2935 2936 vdev_t *tvd = vd->vdev_top;
2936 2937 uint64_t guid = vd->vdev_guid;
2937 2938 uint64_t generation = spa->spa_config_generation + 1;
2938 2939 vdev_state_t newstate = VDEV_STATE_UNKNOWN;
2939 2940 int error;
2940 2941
2941 2942 ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE);
2942 2943 ASSERT(vd->vdev_ops->vdev_op_leaf);
2943 2944
2944 2945 /* Calling vdev_online will initialize the new metaslabs */
2945 2946 spa_config_exit(spa, SCL_STATE, spa);
2946 2947 error = vdev_online(spa, guid, ZFS_ONLINE_EXPAND, &newstate);
2947 2948 spa_config_enter(spa, SCL_STATE, spa, RW_READER);
2948 2949
2949 2950 /*
2950 2951 * If vdev_online returned an error or the underlying vdev_open
2951 2952 * failed then we abort the expand. The only way to know that
2952 2953 * vdev_open fails is by checking the returned newstate.
2953 2954 */
2954 2955 if (error || newstate != VDEV_STATE_HEALTHY) {
2955 2956 if (ztest_opts.zo_verbose >= 5) {
2956 2957 (void) printf("Unable to expand vdev, state %llu, "
2957 2958 "error %d\n", (u_longlong_t)newstate, error);
2958 2959 }
2959 2960 return (vd);
2960 2961 }
2961 2962 ASSERT3U(newstate, ==, VDEV_STATE_HEALTHY);
2962 2963
2963 2964 /*
2964 2965 * Since we dropped the lock we need to ensure that we're
2965 2966 * still talking to the original vdev. It's possible this
2966 2967 * vdev may have been detached/replaced while we were
2967 2968 * trying to online it.
2968 2969 */
2969 2970 if (generation != spa->spa_config_generation) {
2970 2971 if (ztest_opts.zo_verbose >= 5) {
2971 2972 (void) printf("vdev configuration has changed, "
2972 2973 "guid %llu, state %llu, expected gen %llu, "
2973 2974 "got gen %llu\n",
2974 2975 (u_longlong_t)guid,
2975 2976 (u_longlong_t)tvd->vdev_state,
2976 2977 (u_longlong_t)generation,
2977 2978 (u_longlong_t)spa->spa_config_generation);
2978 2979 }
2979 2980 return (vd);
2980 2981 }
2981 2982 return (NULL);
2982 2983 }
2983 2984
2984 2985 /*
2985 2986 * Traverse the vdev tree calling the supplied function.
2986 2987 * We continue to walk the tree until we either have walked all
2987 2988 * children or we receive a non-NULL return from the callback.
2988 2989 * If a NULL callback is passed, then we just return back the first
2989 2990 * leaf vdev we encounter.
2990 2991 */
2991 2992 vdev_t *
2992 2993 vdev_walk_tree(vdev_t *vd, vdev_t *(*func)(vdev_t *, void *), void *arg)
2993 2994 {
2994 2995 if (vd->vdev_ops->vdev_op_leaf) {
2995 2996 if (func == NULL)
2996 2997 return (vd);
2997 2998 else
2998 2999 return (func(vd, arg));
2999 3000 }
3000 3001
3001 3002 for (uint_t c = 0; c < vd->vdev_children; c++) {
3002 3003 vdev_t *cvd = vd->vdev_child[c];
3003 3004 if ((cvd = vdev_walk_tree(cvd, func, arg)) != NULL)
3004 3005 return (cvd);
3005 3006 }
3006 3007 return (NULL);
3007 3008 }
3008 3009
3009 3010 /*
3010 3011 * Verify that dynamic LUN growth works as expected.
3011 3012 */
3012 3013 /* ARGSUSED */
3013 3014 void
3014 3015 ztest_vdev_LUN_growth(ztest_ds_t *zd, uint64_t id)
3015 3016 {
3016 3017 spa_t *spa = ztest_spa;
3017 3018 vdev_t *vd, *tvd;
3018 3019 metaslab_class_t *mc;
3019 3020 metaslab_group_t *mg;
3020 3021 size_t psize, newsize;
3021 3022 uint64_t top;
3022 3023 uint64_t old_class_space, new_class_space, old_ms_count, new_ms_count;
3023 3024
3024 3025 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
3025 3026 spa_config_enter(spa, SCL_STATE, spa, RW_READER);
3026 3027
3027 3028 top = ztest_random_vdev_top(spa, B_TRUE);
3028 3029
3029 3030 tvd = spa->spa_root_vdev->vdev_child[top];
3030 3031 mg = tvd->vdev_mg;
3031 3032 mc = mg->mg_class;
3032 3033 old_ms_count = tvd->vdev_ms_count;
3033 3034 old_class_space = metaslab_class_get_space(mc);
3034 3035
3035 3036 /*
3036 3037 * Determine the size of the first leaf vdev associated with
3037 3038 * our top-level device.
3038 3039 */
3039 3040 vd = vdev_walk_tree(tvd, NULL, NULL);
3040 3041 ASSERT3P(vd, !=, NULL);
3041 3042 ASSERT(vd->vdev_ops->vdev_op_leaf);
3042 3043
3043 3044 psize = vd->vdev_psize;
3044 3045
3045 3046 /*
3046 3047 * We only try to expand the vdev if it's healthy, less than 4x its
3047 3048 * original size, and it has a valid psize.
3048 3049 */
3049 3050 if (tvd->vdev_state != VDEV_STATE_HEALTHY ||
3050 3051 psize == 0 || psize >= 4 * ztest_opts.zo_vdev_size) {
3051 3052 spa_config_exit(spa, SCL_STATE, spa);
3052 3053 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
3053 3054 return;
3054 3055 }
3055 3056 ASSERT(psize > 0);
3056 3057 newsize = psize + psize / 8;
3057 3058 ASSERT3U(newsize, >, psize);
3058 3059
3059 3060 if (ztest_opts.zo_verbose >= 6) {
3060 3061 (void) printf("Expanding LUN %s from %lu to %lu\n",
3061 3062 vd->vdev_path, (ulong_t)psize, (ulong_t)newsize);
3062 3063 }
3063 3064
3064 3065 /*
3065 3066 * Growing the vdev is a two step process:
3066 3067 * 1). expand the physical size (i.e. relabel)
3067 3068 * 2). online the vdev to create the new metaslabs
3068 3069 */
3069 3070 if (vdev_walk_tree(tvd, grow_vdev, &newsize) != NULL ||
3070 3071 vdev_walk_tree(tvd, online_vdev, NULL) != NULL ||
3071 3072 tvd->vdev_state != VDEV_STATE_HEALTHY) {
3072 3073 if (ztest_opts.zo_verbose >= 5) {
3073 3074 (void) printf("Could not expand LUN because "
3074 3075 "the vdev configuration changed.\n");
3075 3076 }
3076 3077 spa_config_exit(spa, SCL_STATE, spa);
3077 3078 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
3078 3079 return;
3079 3080 }
3080 3081
3081 3082 spa_config_exit(spa, SCL_STATE, spa);
3082 3083
3083 3084 /*
3084 3085 * Expanding the LUN will update the config asynchronously,
3085 3086 * thus we must wait for the async thread to complete any
3086 3087 * pending tasks before proceeding.
3087 3088 */
3088 3089 for (;;) {
3089 3090 boolean_t done;
3090 3091 mutex_enter(&spa->spa_async_lock);
3091 3092 done = (spa->spa_async_thread == NULL && !spa->spa_async_tasks);
3092 3093 mutex_exit(&spa->spa_async_lock);
3093 3094 if (done)
3094 3095 break;
3095 3096 txg_wait_synced(spa_get_dsl(spa), 0);
3096 3097 (void) poll(NULL, 0, 100);
3097 3098 }
3098 3099
3099 3100 spa_config_enter(spa, SCL_STATE, spa, RW_READER);
3100 3101
3101 3102 tvd = spa->spa_root_vdev->vdev_child[top];
3102 3103 new_ms_count = tvd->vdev_ms_count;
3103 3104 new_class_space = metaslab_class_get_space(mc);
3104 3105
3105 3106 if (tvd->vdev_mg != mg || mg->mg_class != mc) {
3106 3107 if (ztest_opts.zo_verbose >= 5) {
3107 3108 (void) printf("Could not verify LUN expansion due to "
3108 3109 "intervening vdev offline or remove.\n");
3109 3110 }
3110 3111 spa_config_exit(spa, SCL_STATE, spa);
3111 3112 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
3112 3113 return;
3113 3114 }
3114 3115
3115 3116 /*
3116 3117 * Make sure we were able to grow the vdev.
3117 3118 */
3118 3119 if (new_ms_count <= old_ms_count)
3119 3120 fatal(0, "LUN expansion failed: ms_count %llu <= %llu\n",
3120 3121 old_ms_count, new_ms_count);
3121 3122
3122 3123 /*
3123 3124 * Make sure we were able to grow the pool.
3124 3125 */
3125 3126 if (new_class_space <= old_class_space)
3126 3127 fatal(0, "LUN expansion failed: class_space %llu <= %llu\n",
3127 3128 old_class_space, new_class_space);
3128 3129
3129 3130 if (ztest_opts.zo_verbose >= 5) {
3130 3131 char oldnumbuf[6], newnumbuf[6];
3131 3132
3132 3133 nicenum(old_class_space, oldnumbuf);
3133 3134 nicenum(new_class_space, newnumbuf);
3134 3135 (void) printf("%s grew from %s to %s\n",
3135 3136 spa->spa_name, oldnumbuf, newnumbuf);
3136 3137 }
3137 3138
3138 3139 spa_config_exit(spa, SCL_STATE, spa);
3139 3140 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
3140 3141 }
3141 3142
3142 3143 /*
3143 3144 * Verify that dmu_objset_{create,destroy,open,close} work as expected.
3144 3145 */
3145 3146 /* ARGSUSED */
3146 3147 static void
3147 3148 ztest_objset_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
3148 3149 {
3149 3150 /*
3150 3151 * Create the objects common to all ztest datasets.
3151 3152 */
3152 3153 VERIFY(zap_create_claim(os, ZTEST_DIROBJ,
3153 3154 DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx) == 0);
3154 3155 }
3155 3156
3156 3157 static int
3157 3158 ztest_dataset_create(char *dsname)
3158 3159 {
3159 3160 uint64_t zilset = ztest_random(100);
3160 3161 int err = dmu_objset_create(dsname, DMU_OST_OTHER, 0,
3161 3162 ztest_objset_create_cb, NULL);
3162 3163
3163 3164 if (err || zilset < 80)
3164 3165 return (err);
3165 3166
3166 3167 if (ztest_opts.zo_verbose >= 6)
3167 3168 (void) printf("Setting dataset %s to sync always\n", dsname);
3168 3169 return (ztest_dsl_prop_set_uint64(dsname, ZFS_PROP_SYNC,
3169 3170 ZFS_SYNC_ALWAYS, B_FALSE));
3170 3171 }
3171 3172
3172 3173 /* ARGSUSED */
3173 3174 static int
3174 3175 ztest_objset_destroy_cb(const char *name, void *arg)
3175 3176 {
3176 3177 objset_t *os;
3177 3178 dmu_object_info_t doi;
3178 3179 int error;
3179 3180
3180 3181 /*
3181 3182 * Verify that the dataset contains a directory object.
3182 3183 */
3183 3184 VERIFY0(dmu_objset_own(name, DMU_OST_OTHER, B_TRUE, FTAG, &os));
3184 3185 error = dmu_object_info(os, ZTEST_DIROBJ, &doi);
3185 3186 if (error != ENOENT) {
3186 3187 /* We could have crashed in the middle of destroying it */
3187 3188 ASSERT0(error);
3188 3189 ASSERT3U(doi.doi_type, ==, DMU_OT_ZAP_OTHER);
3189 3190 ASSERT3S(doi.doi_physical_blocks_512, >=, 0);
3190 3191 }
3191 3192 dmu_objset_disown(os, FTAG);
3192 3193
3193 3194 /*
3194 3195 * Destroy the dataset.
3195 3196 */
3196 3197 if (strchr(name, '@') != NULL) {
3197 3198 VERIFY0(dsl_destroy_snapshot(name, B_FALSE));
3198 3199 } else {
3199 3200 VERIFY0(dsl_destroy_head(name));
3200 3201 }
3201 3202 return (0);
3202 3203 }
3203 3204
3204 3205 static boolean_t
3205 3206 ztest_snapshot_create(char *osname, uint64_t id)
3206 3207 {
3207 3208 char snapname[MAXNAMELEN];
3208 3209 int error;
3209 3210
3210 3211 (void) snprintf(snapname, sizeof (snapname), "%llu", (u_longlong_t)id);
3211 3212
3212 3213 error = dmu_objset_snapshot_one(osname, snapname);
3213 3214 if (error == ENOSPC) {
3214 3215 ztest_record_enospc(FTAG);
3215 3216 return (B_FALSE);
3216 3217 }
3217 3218 if (error != 0 && error != EEXIST) {
3218 3219 fatal(0, "ztest_snapshot_create(%s@%s) = %d", osname,
3219 3220 snapname, error);
3220 3221 }
3221 3222 return (B_TRUE);
3222 3223 }
3223 3224
3224 3225 static boolean_t
3225 3226 ztest_snapshot_destroy(char *osname, uint64_t id)
3226 3227 {
3227 3228 char snapname[MAXNAMELEN];
3228 3229 int error;
3229 3230
3230 3231 (void) snprintf(snapname, MAXNAMELEN, "%s@%llu", osname,
3231 3232 (u_longlong_t)id);
3232 3233
3233 3234 error = dsl_destroy_snapshot(snapname, B_FALSE);
3234 3235 if (error != 0 && error != ENOENT)
3235 3236 fatal(0, "ztest_snapshot_destroy(%s) = %d", snapname, error);
3236 3237 return (B_TRUE);
3237 3238 }
3238 3239
3239 3240 /* ARGSUSED */
3240 3241 void
3241 3242 ztest_dmu_objset_create_destroy(ztest_ds_t *zd, uint64_t id)
3242 3243 {
3243 3244 ztest_ds_t zdtmp;
3244 3245 int iters;
3245 3246 int error;
3246 3247 objset_t *os, *os2;
3247 3248 char name[MAXNAMELEN];
3248 3249 zilog_t *zilog;
3249 3250
3250 3251 (void) rw_rdlock(&ztest_name_lock);
3251 3252
3252 3253 (void) snprintf(name, MAXNAMELEN, "%s/temp_%llu",
3253 3254 ztest_opts.zo_pool, (u_longlong_t)id);
3254 3255
3255 3256 /*
3256 3257 * If this dataset exists from a previous run, process its replay log
3257 3258 * half of the time. If we don't replay it, then dmu_objset_destroy()
3258 3259 * (invoked from ztest_objset_destroy_cb()) should just throw it away.
3259 3260 */
3260 3261 if (ztest_random(2) == 0 &&
3261 3262 dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os) == 0) {
3262 3263 ztest_zd_init(&zdtmp, NULL, os);
3263 3264 zil_replay(os, &zdtmp, ztest_replay_vector);
3264 3265 ztest_zd_fini(&zdtmp);
3265 3266 dmu_objset_disown(os, FTAG);
3266 3267 }
3267 3268
3268 3269 /*
3269 3270 * There may be an old instance of the dataset we're about to
3270 3271 * create lying around from a previous run. If so, destroy it
3271 3272 * and all of its snapshots.
3272 3273 */
3273 3274 (void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL,
3274 3275 DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS);
3275 3276
3276 3277 /*
3277 3278 * Verify that the destroyed dataset is no longer in the namespace.
3278 3279 */
3279 3280 VERIFY3U(ENOENT, ==, dmu_objset_own(name, DMU_OST_OTHER, B_TRUE,
3280 3281 FTAG, &os));
3281 3282
3282 3283 /*
3283 3284 * Verify that we can create a new dataset.
3284 3285 */
3285 3286 error = ztest_dataset_create(name);
3286 3287 if (error) {
3287 3288 if (error == ENOSPC) {
3288 3289 ztest_record_enospc(FTAG);
3289 3290 (void) rw_unlock(&ztest_name_lock);
3290 3291 return;
3291 3292 }
3292 3293 fatal(0, "dmu_objset_create(%s) = %d", name, error);
3293 3294 }
3294 3295
3295 3296 VERIFY0(dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os));
3296 3297
3297 3298 ztest_zd_init(&zdtmp, NULL, os);
3298 3299
3299 3300 /*
3300 3301 * Open the intent log for it.
3301 3302 */
3302 3303 zilog = zil_open(os, ztest_get_data);
3303 3304
3304 3305 /*
3305 3306 * Put some objects in there, do a little I/O to them,
3306 3307 * and randomly take a couple of snapshots along the way.
3307 3308 */
3308 3309 iters = ztest_random(5);
3309 3310 for (int i = 0; i < iters; i++) {
3310 3311 ztest_dmu_object_alloc_free(&zdtmp, id);
3311 3312 if (ztest_random(iters) == 0)
3312 3313 (void) ztest_snapshot_create(name, i);
3313 3314 }
3314 3315
3315 3316 /*
3316 3317 * Verify that we cannot create an existing dataset.
3317 3318 */
3318 3319 VERIFY3U(EEXIST, ==,
3319 3320 dmu_objset_create(name, DMU_OST_OTHER, 0, NULL, NULL));
3320 3321
3321 3322 /*
3322 3323 * Verify that we can hold an objset that is also owned.
3323 3324 */
3324 3325 VERIFY3U(0, ==, dmu_objset_hold(name, FTAG, &os2));
3325 3326 dmu_objset_rele(os2, FTAG);
3326 3327
3327 3328 /*
3328 3329 * Verify that we cannot own an objset that is already owned.
3329 3330 */
3330 3331 VERIFY3U(EBUSY, ==,
3331 3332 dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os2));
3332 3333
3333 3334 zil_close(zilog);
3334 3335 dmu_objset_disown(os, FTAG);
3335 3336 ztest_zd_fini(&zdtmp);
3336 3337
3337 3338 (void) rw_unlock(&ztest_name_lock);
3338 3339 }
3339 3340
3340 3341 /*
3341 3342 * Verify that dmu_snapshot_{create,destroy,open,close} work as expected.
3342 3343 */
3343 3344 void
3344 3345 ztest_dmu_snapshot_create_destroy(ztest_ds_t *zd, uint64_t id)
3345 3346 {
3346 3347 (void) rw_rdlock(&ztest_name_lock);
3347 3348 (void) ztest_snapshot_destroy(zd->zd_name, id);
3348 3349 (void) ztest_snapshot_create(zd->zd_name, id);
3349 3350 (void) rw_unlock(&ztest_name_lock);
3350 3351 }
3351 3352
3352 3353 /*
3353 3354 * Cleanup non-standard snapshots and clones.
3354 3355 */
3355 3356 void
3356 3357 ztest_dsl_dataset_cleanup(char *osname, uint64_t id)
3357 3358 {
3358 3359 char snap1name[MAXNAMELEN];
3359 3360 char clone1name[MAXNAMELEN];
3360 3361 char snap2name[MAXNAMELEN];
3361 3362 char clone2name[MAXNAMELEN];
3362 3363 char snap3name[MAXNAMELEN];
3363 3364 int error;
3364 3365
3365 3366 (void) snprintf(snap1name, MAXNAMELEN, "%s@s1_%llu", osname, id);
3366 3367 (void) snprintf(clone1name, MAXNAMELEN, "%s/c1_%llu", osname, id);
3367 3368 (void) snprintf(snap2name, MAXNAMELEN, "%s@s2_%llu", clone1name, id);
3368 3369 (void) snprintf(clone2name, MAXNAMELEN, "%s/c2_%llu", osname, id);
3369 3370 (void) snprintf(snap3name, MAXNAMELEN, "%s@s3_%llu", clone1name, id);
3370 3371
3371 3372 error = dsl_destroy_head(clone2name);
3372 3373 if (error && error != ENOENT)
3373 3374 fatal(0, "dsl_destroy_head(%s) = %d", clone2name, error);
3374 3375 error = dsl_destroy_snapshot(snap3name, B_FALSE);
3375 3376 if (error && error != ENOENT)
3376 3377 fatal(0, "dsl_destroy_snapshot(%s) = %d", snap3name, error);
3377 3378 error = dsl_destroy_snapshot(snap2name, B_FALSE);
3378 3379 if (error && error != ENOENT)
3379 3380 fatal(0, "dsl_destroy_snapshot(%s) = %d", snap2name, error);
3380 3381 error = dsl_destroy_head(clone1name);
3381 3382 if (error && error != ENOENT)
3382 3383 fatal(0, "dsl_destroy_head(%s) = %d", clone1name, error);
3383 3384 error = dsl_destroy_snapshot(snap1name, B_FALSE);
3384 3385 if (error && error != ENOENT)
3385 3386 fatal(0, "dsl_destroy_snapshot(%s) = %d", snap1name, error);
3386 3387 }
3387 3388
3388 3389 /*
3389 3390 * Verify dsl_dataset_promote handles EBUSY
3390 3391 */
3391 3392 void
3392 3393 ztest_dsl_dataset_promote_busy(ztest_ds_t *zd, uint64_t id)
3393 3394 {
3394 3395 objset_t *os;
3395 3396 char snap1name[MAXNAMELEN];
3396 3397 char clone1name[MAXNAMELEN];
3397 3398 char snap2name[MAXNAMELEN];
3398 3399 char clone2name[MAXNAMELEN];
3399 3400 char snap3name[MAXNAMELEN];
3400 3401 char *osname = zd->zd_name;
3401 3402 int error;
3402 3403
3403 3404 (void) rw_rdlock(&ztest_name_lock);
3404 3405
3405 3406 ztest_dsl_dataset_cleanup(osname, id);
3406 3407
3407 3408 (void) snprintf(snap1name, MAXNAMELEN, "%s@s1_%llu", osname, id);
3408 3409 (void) snprintf(clone1name, MAXNAMELEN, "%s/c1_%llu", osname, id);
3409 3410 (void) snprintf(snap2name, MAXNAMELEN, "%s@s2_%llu", clone1name, id);
3410 3411 (void) snprintf(clone2name, MAXNAMELEN, "%s/c2_%llu", osname, id);
3411 3412 (void) snprintf(snap3name, MAXNAMELEN, "%s@s3_%llu", clone1name, id);
3412 3413
3413 3414 error = dmu_objset_snapshot_one(osname, strchr(snap1name, '@') + 1);
3414 3415 if (error && error != EEXIST) {
3415 3416 if (error == ENOSPC) {
3416 3417 ztest_record_enospc(FTAG);
3417 3418 goto out;
3418 3419 }
3419 3420 fatal(0, "dmu_take_snapshot(%s) = %d", snap1name, error);
3420 3421 }
3421 3422
3422 3423 error = dmu_objset_clone(clone1name, snap1name);
3423 3424 if (error) {
3424 3425 if (error == ENOSPC) {
3425 3426 ztest_record_enospc(FTAG);
3426 3427 goto out;
3427 3428 }
3428 3429 fatal(0, "dmu_objset_create(%s) = %d", clone1name, error);
3429 3430 }
3430 3431
3431 3432 error = dmu_objset_snapshot_one(clone1name, strchr(snap2name, '@') + 1);
3432 3433 if (error && error != EEXIST) {
3433 3434 if (error == ENOSPC) {
3434 3435 ztest_record_enospc(FTAG);
3435 3436 goto out;
3436 3437 }
3437 3438 fatal(0, "dmu_open_snapshot(%s) = %d", snap2name, error);
3438 3439 }
3439 3440
3440 3441 error = dmu_objset_snapshot_one(clone1name, strchr(snap3name, '@') + 1);
3441 3442 if (error && error != EEXIST) {
3442 3443 if (error == ENOSPC) {
3443 3444 ztest_record_enospc(FTAG);
3444 3445 goto out;
3445 3446 }
3446 3447 fatal(0, "dmu_open_snapshot(%s) = %d", snap3name, error);
3447 3448 }
3448 3449
3449 3450 error = dmu_objset_clone(clone2name, snap3name);
3450 3451 if (error) {
3451 3452 if (error == ENOSPC) {
3452 3453 ztest_record_enospc(FTAG);
3453 3454 goto out;
3454 3455 }
3455 3456 fatal(0, "dmu_objset_create(%s) = %d", clone2name, error);
3456 3457 }
3457 3458
3458 3459 error = dmu_objset_own(snap2name, DMU_OST_ANY, B_TRUE, FTAG, &os);
3459 3460 if (error)
3460 3461 fatal(0, "dmu_objset_own(%s) = %d", snap2name, error);
3461 3462 error = dsl_dataset_promote(clone2name, NULL);
3462 3463 if (error != EBUSY)
3463 3464 fatal(0, "dsl_dataset_promote(%s), %d, not EBUSY", clone2name,
3464 3465 error);
3465 3466 dmu_objset_disown(os, FTAG);
3466 3467
3467 3468 out:
3468 3469 ztest_dsl_dataset_cleanup(osname, id);
3469 3470
3470 3471 (void) rw_unlock(&ztest_name_lock);
3471 3472 }
3472 3473
3473 3474 /*
3474 3475 * Verify that dmu_object_{alloc,free} work as expected.
3475 3476 */
3476 3477 void
3477 3478 ztest_dmu_object_alloc_free(ztest_ds_t *zd, uint64_t id)
3478 3479 {
3479 3480 ztest_od_t od[4];
3480 3481 int batchsize = sizeof (od) / sizeof (od[0]);
3481 3482
3482 3483 for (int b = 0; b < batchsize; b++)
3483 3484 ztest_od_init(&od[b], id, FTAG, b, DMU_OT_UINT64_OTHER, 0, 0);
3484 3485
3485 3486 /*
3486 3487 * Destroy the previous batch of objects, create a new batch,
3487 3488 * and do some I/O on the new objects.
3488 3489 */
3489 3490 if (ztest_object_init(zd, od, sizeof (od), B_TRUE) != 0)
3490 3491 return;
3491 3492
3492 3493 while (ztest_random(4 * batchsize) != 0)
3493 3494 ztest_io(zd, od[ztest_random(batchsize)].od_object,
3494 3495 ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
3495 3496 }
3496 3497
3497 3498 /*
3498 3499 * Verify that dmu_{read,write} work as expected.
3499 3500 */
3500 3501 void
3501 3502 ztest_dmu_read_write(ztest_ds_t *zd, uint64_t id)
3502 3503 {
3503 3504 objset_t *os = zd->zd_os;
3504 3505 ztest_od_t od[2];
3505 3506 dmu_tx_t *tx;
3506 3507 int i, freeit, error;
3507 3508 uint64_t n, s, txg;
3508 3509 bufwad_t *packbuf, *bigbuf, *pack, *bigH, *bigT;
3509 3510 uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize;
3510 3511 uint64_t chunksize = (1000 + ztest_random(1000)) * sizeof (uint64_t);
3511 3512 uint64_t regions = 997;
3512 3513 uint64_t stride = 123456789ULL;
3513 3514 uint64_t width = 40;
3514 3515 int free_percent = 5;
3515 3516
3516 3517 /*
3517 3518 * This test uses two objects, packobj and bigobj, that are always
3518 3519 * updated together (i.e. in the same tx) so that their contents are
3519 3520 * in sync and can be compared. Their contents relate to each other
3520 3521 * in a simple way: packobj is a dense array of 'bufwad' structures,
3521 3522 * while bigobj is a sparse array of the same bufwads. Specifically,
3522 3523 * for any index n, there are three bufwads that should be identical:
3523 3524 *
3524 3525 * packobj, at offset n * sizeof (bufwad_t)
3525 3526 * bigobj, at the head of the nth chunk
3526 3527 * bigobj, at the tail of the nth chunk
3527 3528 *
3528 3529 * The chunk size is arbitrary. It doesn't have to be a power of two,
3529 3530 * and it doesn't have any relation to the object blocksize.
3530 3531 * The only requirement is that it can hold at least two bufwads.
3531 3532 *
3532 3533 * Normally, we write the bufwad to each of these locations.
3533 3534 * However, free_percent of the time we instead write zeroes to
3534 3535 * packobj and perform a dmu_free_range() on bigobj. By comparing
3535 3536 * bigobj to packobj, we can verify that the DMU is correctly
3536 3537 * tracking which parts of an object are allocated and free,
3537 3538 * and that the contents of the allocated blocks are correct.
3538 3539 */
3539 3540
3540 3541 /*
3541 3542 * Read the directory info. If it's the first time, set things up.
3542 3543 */
3543 3544 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, chunksize);
3544 3545 ztest_od_init(&od[1], id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, chunksize);
3545 3546
3546 3547 if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0)
3547 3548 return;
3548 3549
3549 3550 bigobj = od[0].od_object;
3550 3551 packobj = od[1].od_object;
3551 3552 chunksize = od[0].od_gen;
3552 3553 ASSERT(chunksize == od[1].od_gen);
3553 3554
3554 3555 /*
3555 3556 * Prefetch a random chunk of the big object.
3556 3557 * Our aim here is to get some async reads in flight
3557 3558 * for blocks that we may free below; the DMU should
3558 3559 * handle this race correctly.
3559 3560 */
3560 3561 n = ztest_random(regions) * stride + ztest_random(width);
3561 3562 s = 1 + ztest_random(2 * width - 1);
3562 3563 dmu_prefetch(os, bigobj, n * chunksize, s * chunksize);
3563 3564
3564 3565 /*
3565 3566 * Pick a random index and compute the offsets into packobj and bigobj.
3566 3567 */
3567 3568 n = ztest_random(regions) * stride + ztest_random(width);
3568 3569 s = 1 + ztest_random(width - 1);
3569 3570
3570 3571 packoff = n * sizeof (bufwad_t);
3571 3572 packsize = s * sizeof (bufwad_t);
3572 3573
3573 3574 bigoff = n * chunksize;
3574 3575 bigsize = s * chunksize;
3575 3576
3576 3577 packbuf = umem_alloc(packsize, UMEM_NOFAIL);
3577 3578 bigbuf = umem_alloc(bigsize, UMEM_NOFAIL);
3578 3579
3579 3580 /*
3580 3581 * free_percent of the time, free a range of bigobj rather than
3581 3582 * overwriting it.
3582 3583 */
3583 3584 freeit = (ztest_random(100) < free_percent);
3584 3585
3585 3586 /*
3586 3587 * Read the current contents of our objects.
3587 3588 */
3588 3589 error = dmu_read(os, packobj, packoff, packsize, packbuf,
3589 3590 DMU_READ_PREFETCH);
3590 3591 ASSERT0(error);
3591 3592 error = dmu_read(os, bigobj, bigoff, bigsize, bigbuf,
3592 3593 DMU_READ_PREFETCH);
3593 3594 ASSERT0(error);
3594 3595
3595 3596 /*
3596 3597 * Get a tx for the mods to both packobj and bigobj.
3597 3598 */
3598 3599 tx = dmu_tx_create(os);
3599 3600
3600 3601 dmu_tx_hold_write(tx, packobj, packoff, packsize);
3601 3602
3602 3603 if (freeit)
3603 3604 dmu_tx_hold_free(tx, bigobj, bigoff, bigsize);
3604 3605 else
3605 3606 dmu_tx_hold_write(tx, bigobj, bigoff, bigsize);
3606 3607
3607 3608 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
3608 3609 if (txg == 0) {
3609 3610 umem_free(packbuf, packsize);
3610 3611 umem_free(bigbuf, bigsize);
3611 3612 return;
3612 3613 }
3613 3614
3614 3615 dmu_object_set_checksum(os, bigobj,
3615 3616 (enum zio_checksum)ztest_random_dsl_prop(ZFS_PROP_CHECKSUM), tx);
3616 3617
3617 3618 dmu_object_set_compress(os, bigobj,
3618 3619 (enum zio_compress)ztest_random_dsl_prop(ZFS_PROP_COMPRESSION), tx);
3619 3620
3620 3621 /*
3621 3622 * For each index from n to n + s, verify that the existing bufwad
3622 3623 * in packobj matches the bufwads at the head and tail of the
3623 3624 * corresponding chunk in bigobj. Then update all three bufwads
3624 3625 * with the new values we want to write out.
3625 3626 */
3626 3627 for (i = 0; i < s; i++) {
3627 3628 /* LINTED */
3628 3629 pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
3629 3630 /* LINTED */
3630 3631 bigH = (bufwad_t *)((char *)bigbuf + i * chunksize);
3631 3632 /* LINTED */
3632 3633 bigT = (bufwad_t *)((char *)bigH + chunksize) - 1;
3633 3634
3634 3635 ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
3635 3636 ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
3636 3637
3637 3638 if (pack->bw_txg > txg)
3638 3639 fatal(0, "future leak: got %llx, open txg is %llx",
3639 3640 pack->bw_txg, txg);
3640 3641
3641 3642 if (pack->bw_data != 0 && pack->bw_index != n + i)
3642 3643 fatal(0, "wrong index: got %llx, wanted %llx+%llx",
3643 3644 pack->bw_index, n, i);
3644 3645
3645 3646 if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0)
3646 3647 fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH);
3647 3648
3648 3649 if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0)
3649 3650 fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT);
3650 3651
3651 3652 if (freeit) {
3652 3653 bzero(pack, sizeof (bufwad_t));
3653 3654 } else {
3654 3655 pack->bw_index = n + i;
3655 3656 pack->bw_txg = txg;
3656 3657 pack->bw_data = 1 + ztest_random(-2ULL);
3657 3658 }
3658 3659 *bigH = *pack;
3659 3660 *bigT = *pack;
3660 3661 }
3661 3662
3662 3663 /*
3663 3664 * We've verified all the old bufwads, and made new ones.
3664 3665 * Now write them out.
3665 3666 */
3666 3667 dmu_write(os, packobj, packoff, packsize, packbuf, tx);
3667 3668
3668 3669 if (freeit) {
3669 3670 if (ztest_opts.zo_verbose >= 7) {
3670 3671 (void) printf("freeing offset %llx size %llx"
3671 3672 " txg %llx\n",
3672 3673 (u_longlong_t)bigoff,
3673 3674 (u_longlong_t)bigsize,
3674 3675 (u_longlong_t)txg);
3675 3676 }
3676 3677 VERIFY(0 == dmu_free_range(os, bigobj, bigoff, bigsize, tx));
3677 3678 } else {
3678 3679 if (ztest_opts.zo_verbose >= 7) {
3679 3680 (void) printf("writing offset %llx size %llx"
3680 3681 " txg %llx\n",
3681 3682 (u_longlong_t)bigoff,
3682 3683 (u_longlong_t)bigsize,
3683 3684 (u_longlong_t)txg);
3684 3685 }
3685 3686 dmu_write(os, bigobj, bigoff, bigsize, bigbuf, tx);
3686 3687 }
3687 3688
3688 3689 dmu_tx_commit(tx);
3689 3690
3690 3691 /*
3691 3692 * Sanity check the stuff we just wrote.
3692 3693 */
3693 3694 {
3694 3695 void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
3695 3696 void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
3696 3697
3697 3698 VERIFY(0 == dmu_read(os, packobj, packoff,
3698 3699 packsize, packcheck, DMU_READ_PREFETCH));
3699 3700 VERIFY(0 == dmu_read(os, bigobj, bigoff,
3700 3701 bigsize, bigcheck, DMU_READ_PREFETCH));
3701 3702
3702 3703 ASSERT(bcmp(packbuf, packcheck, packsize) == 0);
3703 3704 ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0);
3704 3705
3705 3706 umem_free(packcheck, packsize);
3706 3707 umem_free(bigcheck, bigsize);
3707 3708 }
3708 3709
3709 3710 umem_free(packbuf, packsize);
3710 3711 umem_free(bigbuf, bigsize);
3711 3712 }
3712 3713
3713 3714 void
3714 3715 compare_and_update_pbbufs(uint64_t s, bufwad_t *packbuf, bufwad_t *bigbuf,
3715 3716 uint64_t bigsize, uint64_t n, uint64_t chunksize, uint64_t txg)
3716 3717 {
3717 3718 uint64_t i;
3718 3719 bufwad_t *pack;
3719 3720 bufwad_t *bigH;
3720 3721 bufwad_t *bigT;
3721 3722
3722 3723 /*
3723 3724 * For each index from n to n + s, verify that the existing bufwad
3724 3725 * in packobj matches the bufwads at the head and tail of the
3725 3726 * corresponding chunk in bigobj. Then update all three bufwads
3726 3727 * with the new values we want to write out.
3727 3728 */
3728 3729 for (i = 0; i < s; i++) {
3729 3730 /* LINTED */
3730 3731 pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
3731 3732 /* LINTED */
3732 3733 bigH = (bufwad_t *)((char *)bigbuf + i * chunksize);
3733 3734 /* LINTED */
3734 3735 bigT = (bufwad_t *)((char *)bigH + chunksize) - 1;
3735 3736
3736 3737 ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
3737 3738 ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
3738 3739
3739 3740 if (pack->bw_txg > txg)
3740 3741 fatal(0, "future leak: got %llx, open txg is %llx",
3741 3742 pack->bw_txg, txg);
3742 3743
3743 3744 if (pack->bw_data != 0 && pack->bw_index != n + i)
3744 3745 fatal(0, "wrong index: got %llx, wanted %llx+%llx",
3745 3746 pack->bw_index, n, i);
3746 3747
3747 3748 if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0)
3748 3749 fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH);
3749 3750
3750 3751 if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0)
3751 3752 fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT);
3752 3753
3753 3754 pack->bw_index = n + i;
3754 3755 pack->bw_txg = txg;
3755 3756 pack->bw_data = 1 + ztest_random(-2ULL);
3756 3757
3757 3758 *bigH = *pack;
3758 3759 *bigT = *pack;
3759 3760 }
3760 3761 }
3761 3762
3762 3763 void
3763 3764 ztest_dmu_read_write_zcopy(ztest_ds_t *zd, uint64_t id)
3764 3765 {
3765 3766 objset_t *os = zd->zd_os;
3766 3767 ztest_od_t od[2];
3767 3768 dmu_tx_t *tx;
3768 3769 uint64_t i;
3769 3770 int error;
3770 3771 uint64_t n, s, txg;
3771 3772 bufwad_t *packbuf, *bigbuf;
3772 3773 uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize;
3773 3774 uint64_t blocksize = ztest_random_blocksize();
3774 3775 uint64_t chunksize = blocksize;
3775 3776 uint64_t regions = 997;
3776 3777 uint64_t stride = 123456789ULL;
3777 3778 uint64_t width = 9;
3778 3779 dmu_buf_t *bonus_db;
3779 3780 arc_buf_t **bigbuf_arcbufs;
3780 3781 dmu_object_info_t doi;
3781 3782
3782 3783 /*
3783 3784 * This test uses two objects, packobj and bigobj, that are always
3784 3785 * updated together (i.e. in the same tx) so that their contents are
3785 3786 * in sync and can be compared. Their contents relate to each other
3786 3787 * in a simple way: packobj is a dense array of 'bufwad' structures,
3787 3788 * while bigobj is a sparse array of the same bufwads. Specifically,
3788 3789 * for any index n, there are three bufwads that should be identical:
3789 3790 *
3790 3791 * packobj, at offset n * sizeof (bufwad_t)
3791 3792 * bigobj, at the head of the nth chunk
3792 3793 * bigobj, at the tail of the nth chunk
3793 3794 *
3794 3795 * The chunk size is set equal to bigobj block size so that
3795 3796 * dmu_assign_arcbuf() can be tested for object updates.
3796 3797 */
3797 3798
3798 3799 /*
3799 3800 * Read the directory info. If it's the first time, set things up.
3800 3801 */
3801 3802 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0);
3802 3803 ztest_od_init(&od[1], id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, chunksize);
3803 3804
3804 3805 if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0)
3805 3806 return;
3806 3807
3807 3808 bigobj = od[0].od_object;
3808 3809 packobj = od[1].od_object;
3809 3810 blocksize = od[0].od_blocksize;
3810 3811 chunksize = blocksize;
3811 3812 ASSERT(chunksize == od[1].od_gen);
3812 3813
3813 3814 VERIFY(dmu_object_info(os, bigobj, &doi) == 0);
3814 3815 VERIFY(ISP2(doi.doi_data_block_size));
3815 3816 VERIFY(chunksize == doi.doi_data_block_size);
3816 3817 VERIFY(chunksize >= 2 * sizeof (bufwad_t));
3817 3818
3818 3819 /*
3819 3820 * Pick a random index and compute the offsets into packobj and bigobj.
3820 3821 */
3821 3822 n = ztest_random(regions) * stride + ztest_random(width);
3822 3823 s = 1 + ztest_random(width - 1);
3823 3824
3824 3825 packoff = n * sizeof (bufwad_t);
3825 3826 packsize = s * sizeof (bufwad_t);
3826 3827
3827 3828 bigoff = n * chunksize;
3828 3829 bigsize = s * chunksize;
3829 3830
3830 3831 packbuf = umem_zalloc(packsize, UMEM_NOFAIL);
3831 3832 bigbuf = umem_zalloc(bigsize, UMEM_NOFAIL);
3832 3833
3833 3834 VERIFY3U(0, ==, dmu_bonus_hold(os, bigobj, FTAG, &bonus_db));
3834 3835
3835 3836 bigbuf_arcbufs = umem_zalloc(2 * s * sizeof (arc_buf_t *), UMEM_NOFAIL);
3836 3837
3837 3838 /*
3838 3839 * Iteration 0 test zcopy for DB_UNCACHED dbufs.
3839 3840 * Iteration 1 test zcopy to already referenced dbufs.
3840 3841 * Iteration 2 test zcopy to dirty dbuf in the same txg.
3841 3842 * Iteration 3 test zcopy to dbuf dirty in previous txg.
3842 3843 * Iteration 4 test zcopy when dbuf is no longer dirty.
3843 3844 * Iteration 5 test zcopy when it can't be done.
3844 3845 * Iteration 6 one more zcopy write.
3845 3846 */
3846 3847 for (i = 0; i < 7; i++) {
3847 3848 uint64_t j;
3848 3849 uint64_t off;
3849 3850
3850 3851 /*
3851 3852 * In iteration 5 (i == 5) use arcbufs
3852 3853 * that don't match bigobj blksz to test
3853 3854 * dmu_assign_arcbuf() when it can't directly
3854 3855 * assign an arcbuf to a dbuf.
3855 3856 */
3856 3857 for (j = 0; j < s; j++) {
3857 3858 if (i != 5) {
3858 3859 bigbuf_arcbufs[j] =
3859 3860 dmu_request_arcbuf(bonus_db, chunksize);
3860 3861 } else {
3861 3862 bigbuf_arcbufs[2 * j] =
3862 3863 dmu_request_arcbuf(bonus_db, chunksize / 2);
3863 3864 bigbuf_arcbufs[2 * j + 1] =
3864 3865 dmu_request_arcbuf(bonus_db, chunksize / 2);
3865 3866 }
3866 3867 }
3867 3868
3868 3869 /*
3869 3870 * Get a tx for the mods to both packobj and bigobj.
3870 3871 */
3871 3872 tx = dmu_tx_create(os);
3872 3873
3873 3874 dmu_tx_hold_write(tx, packobj, packoff, packsize);
3874 3875 dmu_tx_hold_write(tx, bigobj, bigoff, bigsize);
3875 3876
3876 3877 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
3877 3878 if (txg == 0) {
3878 3879 umem_free(packbuf, packsize);
3879 3880 umem_free(bigbuf, bigsize);
3880 3881 for (j = 0; j < s; j++) {
3881 3882 if (i != 5) {
3882 3883 dmu_return_arcbuf(bigbuf_arcbufs[j]);
3883 3884 } else {
3884 3885 dmu_return_arcbuf(
3885 3886 bigbuf_arcbufs[2 * j]);
3886 3887 dmu_return_arcbuf(
3887 3888 bigbuf_arcbufs[2 * j + 1]);
3888 3889 }
3889 3890 }
3890 3891 umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
3891 3892 dmu_buf_rele(bonus_db, FTAG);
3892 3893 return;
3893 3894 }
3894 3895
3895 3896 /*
3896 3897 * 50% of the time don't read objects in the 1st iteration to
3897 3898 * test dmu_assign_arcbuf() for the case when there're no
3898 3899 * existing dbufs for the specified offsets.
3899 3900 */
3900 3901 if (i != 0 || ztest_random(2) != 0) {
3901 3902 error = dmu_read(os, packobj, packoff,
3902 3903 packsize, packbuf, DMU_READ_PREFETCH);
3903 3904 ASSERT0(error);
3904 3905 error = dmu_read(os, bigobj, bigoff, bigsize,
3905 3906 bigbuf, DMU_READ_PREFETCH);
3906 3907 ASSERT0(error);
3907 3908 }
3908 3909 compare_and_update_pbbufs(s, packbuf, bigbuf, bigsize,
3909 3910 n, chunksize, txg);
3910 3911
3911 3912 /*
3912 3913 * We've verified all the old bufwads, and made new ones.
3913 3914 * Now write them out.
3914 3915 */
3915 3916 dmu_write(os, packobj, packoff, packsize, packbuf, tx);
3916 3917 if (ztest_opts.zo_verbose >= 7) {
3917 3918 (void) printf("writing offset %llx size %llx"
3918 3919 " txg %llx\n",
3919 3920 (u_longlong_t)bigoff,
3920 3921 (u_longlong_t)bigsize,
3921 3922 (u_longlong_t)txg);
3922 3923 }
3923 3924 for (off = bigoff, j = 0; j < s; j++, off += chunksize) {
3924 3925 dmu_buf_t *dbt;
3925 3926 if (i != 5) {
3926 3927 bcopy((caddr_t)bigbuf + (off - bigoff),
3927 3928 bigbuf_arcbufs[j]->b_data, chunksize);
3928 3929 } else {
3929 3930 bcopy((caddr_t)bigbuf + (off - bigoff),
3930 3931 bigbuf_arcbufs[2 * j]->b_data,
3931 3932 chunksize / 2);
3932 3933 bcopy((caddr_t)bigbuf + (off - bigoff) +
3933 3934 chunksize / 2,
3934 3935 bigbuf_arcbufs[2 * j + 1]->b_data,
3935 3936 chunksize / 2);
3936 3937 }
3937 3938
3938 3939 if (i == 1) {
3939 3940 VERIFY(dmu_buf_hold(os, bigobj, off,
3940 3941 FTAG, &dbt, DMU_READ_NO_PREFETCH) == 0);
3941 3942 }
3942 3943 if (i != 5) {
3943 3944 dmu_assign_arcbuf(bonus_db, off,
3944 3945 bigbuf_arcbufs[j], tx);
3945 3946 } else {
3946 3947 dmu_assign_arcbuf(bonus_db, off,
3947 3948 bigbuf_arcbufs[2 * j], tx);
3948 3949 dmu_assign_arcbuf(bonus_db,
3949 3950 off + chunksize / 2,
3950 3951 bigbuf_arcbufs[2 * j + 1], tx);
3951 3952 }
3952 3953 if (i == 1) {
3953 3954 dmu_buf_rele(dbt, FTAG);
3954 3955 }
3955 3956 }
3956 3957 dmu_tx_commit(tx);
3957 3958
3958 3959 /*
3959 3960 * Sanity check the stuff we just wrote.
3960 3961 */
3961 3962 {
3962 3963 void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
3963 3964 void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
3964 3965
3965 3966 VERIFY(0 == dmu_read(os, packobj, packoff,
3966 3967 packsize, packcheck, DMU_READ_PREFETCH));
3967 3968 VERIFY(0 == dmu_read(os, bigobj, bigoff,
3968 3969 bigsize, bigcheck, DMU_READ_PREFETCH));
3969 3970
3970 3971 ASSERT(bcmp(packbuf, packcheck, packsize) == 0);
3971 3972 ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0);
3972 3973
3973 3974 umem_free(packcheck, packsize);
3974 3975 umem_free(bigcheck, bigsize);
3975 3976 }
3976 3977 if (i == 2) {
3977 3978 txg_wait_open(dmu_objset_pool(os), 0);
3978 3979 } else if (i == 3) {
3979 3980 txg_wait_synced(dmu_objset_pool(os), 0);
3980 3981 }
3981 3982 }
3982 3983
3983 3984 dmu_buf_rele(bonus_db, FTAG);
3984 3985 umem_free(packbuf, packsize);
3985 3986 umem_free(bigbuf, bigsize);
3986 3987 umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
3987 3988 }
3988 3989
3989 3990 /* ARGSUSED */
3990 3991 void
3991 3992 ztest_dmu_write_parallel(ztest_ds_t *zd, uint64_t id)
3992 3993 {
3993 3994 ztest_od_t od[1];
3994 3995 uint64_t offset = (1ULL << (ztest_random(20) + 43)) +
3995 3996 (ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
3996 3997
3997 3998 /*
3998 3999 * Have multiple threads write to large offsets in an object
3999 4000 * to verify that parallel writes to an object -- even to the
4000 4001 * same blocks within the object -- doesn't cause any trouble.
4001 4002 */
4002 4003 ztest_od_init(&od[0], ID_PARALLEL, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0);
4003 4004
4004 4005 if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0)
4005 4006 return;
4006 4007
4007 4008 while (ztest_random(10) != 0)
4008 4009 ztest_io(zd, od[0].od_object, offset);
4009 4010 }
4010 4011
4011 4012 void
4012 4013 ztest_dmu_prealloc(ztest_ds_t *zd, uint64_t id)
4013 4014 {
4014 4015 ztest_od_t od[1];
4015 4016 uint64_t offset = (1ULL << (ztest_random(4) + SPA_MAXBLOCKSHIFT)) +
4016 4017 (ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
4017 4018 uint64_t count = ztest_random(20) + 1;
4018 4019 uint64_t blocksize = ztest_random_blocksize();
4019 4020 void *data;
4020 4021
4021 4022 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0);
4022 4023
4023 4024 if (ztest_object_init(zd, od, sizeof (od), !ztest_random(2)) != 0)
4024 4025 return;
4025 4026
4026 4027 if (ztest_truncate(zd, od[0].od_object, offset, count * blocksize) != 0)
4027 4028 return;
4028 4029
4029 4030 ztest_prealloc(zd, od[0].od_object, offset, count * blocksize);
4030 4031
4031 4032 data = umem_zalloc(blocksize, UMEM_NOFAIL);
4032 4033
4033 4034 while (ztest_random(count) != 0) {
4034 4035 uint64_t randoff = offset + (ztest_random(count) * blocksize);
4035 4036 if (ztest_write(zd, od[0].od_object, randoff, blocksize,
4036 4037 data) != 0)
4037 4038 break;
4038 4039 while (ztest_random(4) != 0)
4039 4040 ztest_io(zd, od[0].od_object, randoff);
4040 4041 }
4041 4042
4042 4043 umem_free(data, blocksize);
4043 4044 }
4044 4045
4045 4046 /*
4046 4047 * Verify that zap_{create,destroy,add,remove,update} work as expected.
4047 4048 */
4048 4049 #define ZTEST_ZAP_MIN_INTS 1
4049 4050 #define ZTEST_ZAP_MAX_INTS 4
4050 4051 #define ZTEST_ZAP_MAX_PROPS 1000
4051 4052
4052 4053 void
4053 4054 ztest_zap(ztest_ds_t *zd, uint64_t id)
4054 4055 {
4055 4056 objset_t *os = zd->zd_os;
4056 4057 ztest_od_t od[1];
4057 4058 uint64_t object;
4058 4059 uint64_t txg, last_txg;
4059 4060 uint64_t value[ZTEST_ZAP_MAX_INTS];
4060 4061 uint64_t zl_ints, zl_intsize, prop;
4061 4062 int i, ints;
4062 4063 dmu_tx_t *tx;
4063 4064 char propname[100], txgname[100];
4064 4065 int error;
4065 4066 char *hc[2] = { "s.acl.h", ".s.open.h.hyLZlg" };
4066 4067
4067 4068 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0);
4068 4069
4069 4070 if (ztest_object_init(zd, od, sizeof (od), !ztest_random(2)) != 0)
4070 4071 return;
4071 4072
4072 4073 object = od[0].od_object;
4073 4074
4074 4075 /*
4075 4076 * Generate a known hash collision, and verify that
4076 4077 * we can lookup and remove both entries.
4077 4078 */
4078 4079 tx = dmu_tx_create(os);
4079 4080 dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
4080 4081 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
4081 4082 if (txg == 0)
4082 4083 return;
4083 4084 for (i = 0; i < 2; i++) {
4084 4085 value[i] = i;
4085 4086 VERIFY3U(0, ==, zap_add(os, object, hc[i], sizeof (uint64_t),
4086 4087 1, &value[i], tx));
4087 4088 }
4088 4089 for (i = 0; i < 2; i++) {
4089 4090 VERIFY3U(EEXIST, ==, zap_add(os, object, hc[i],
4090 4091 sizeof (uint64_t), 1, &value[i], tx));
4091 4092 VERIFY3U(0, ==,
4092 4093 zap_length(os, object, hc[i], &zl_intsize, &zl_ints));
4093 4094 ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
4094 4095 ASSERT3U(zl_ints, ==, 1);
4095 4096 }
4096 4097 for (i = 0; i < 2; i++) {
4097 4098 VERIFY3U(0, ==, zap_remove(os, object, hc[i], tx));
4098 4099 }
4099 4100 dmu_tx_commit(tx);
4100 4101
4101 4102 /*
4102 4103 * Generate a buch of random entries.
4103 4104 */
4104 4105 ints = MAX(ZTEST_ZAP_MIN_INTS, object % ZTEST_ZAP_MAX_INTS);
4105 4106
4106 4107 prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
4107 4108 (void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
4108 4109 (void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
4109 4110 bzero(value, sizeof (value));
4110 4111 last_txg = 0;
4111 4112
4112 4113 /*
4113 4114 * If these zap entries already exist, validate their contents.
4114 4115 */
4115 4116 error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
4116 4117 if (error == 0) {
4117 4118 ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
4118 4119 ASSERT3U(zl_ints, ==, 1);
4119 4120
4120 4121 VERIFY(zap_lookup(os, object, txgname, zl_intsize,
4121 4122 zl_ints, &last_txg) == 0);
4122 4123
4123 4124 VERIFY(zap_length(os, object, propname, &zl_intsize,
4124 4125 &zl_ints) == 0);
4125 4126
4126 4127 ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
4127 4128 ASSERT3U(zl_ints, ==, ints);
4128 4129
4129 4130 VERIFY(zap_lookup(os, object, propname, zl_intsize,
4130 4131 zl_ints, value) == 0);
4131 4132
4132 4133 for (i = 0; i < ints; i++) {
4133 4134 ASSERT3U(value[i], ==, last_txg + object + i);
4134 4135 }
4135 4136 } else {
4136 4137 ASSERT3U(error, ==, ENOENT);
4137 4138 }
4138 4139
4139 4140 /*
4140 4141 * Atomically update two entries in our zap object.
4141 4142 * The first is named txg_%llu, and contains the txg
4142 4143 * in which the property was last updated. The second
4143 4144 * is named prop_%llu, and the nth element of its value
4144 4145 * should be txg + object + n.
4145 4146 */
4146 4147 tx = dmu_tx_create(os);
4147 4148 dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
4148 4149 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
4149 4150 if (txg == 0)
4150 4151 return;
4151 4152
4152 4153 if (last_txg > txg)
4153 4154 fatal(0, "zap future leak: old %llu new %llu", last_txg, txg);
4154 4155
4155 4156 for (i = 0; i < ints; i++)
4156 4157 value[i] = txg + object + i;
4157 4158
4158 4159 VERIFY3U(0, ==, zap_update(os, object, txgname, sizeof (uint64_t),
4159 4160 1, &txg, tx));
4160 4161 VERIFY3U(0, ==, zap_update(os, object, propname, sizeof (uint64_t),
4161 4162 ints, value, tx));
4162 4163
4163 4164 dmu_tx_commit(tx);
4164 4165
4165 4166 /*
4166 4167 * Remove a random pair of entries.
4167 4168 */
4168 4169 prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
4169 4170 (void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
4170 4171 (void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
4171 4172
4172 4173 error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
4173 4174
4174 4175 if (error == ENOENT)
4175 4176 return;
4176 4177
4177 4178 ASSERT0(error);
4178 4179
4179 4180 tx = dmu_tx_create(os);
4180 4181 dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
4181 4182 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
4182 4183 if (txg == 0)
4183 4184 return;
4184 4185 VERIFY3U(0, ==, zap_remove(os, object, txgname, tx));
4185 4186 VERIFY3U(0, ==, zap_remove(os, object, propname, tx));
4186 4187 dmu_tx_commit(tx);
4187 4188 }
4188 4189
4189 4190 /*
4190 4191 * Testcase to test the upgrading of a microzap to fatzap.
4191 4192 */
4192 4193 void
4193 4194 ztest_fzap(ztest_ds_t *zd, uint64_t id)
4194 4195 {
4195 4196 objset_t *os = zd->zd_os;
4196 4197 ztest_od_t od[1];
4197 4198 uint64_t object, txg;
4198 4199
4199 4200 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0);
4200 4201
4201 4202 if (ztest_object_init(zd, od, sizeof (od), !ztest_random(2)) != 0)
4202 4203 return;
4203 4204
4204 4205 object = od[0].od_object;
4205 4206
4206 4207 /*
4207 4208 * Add entries to this ZAP and make sure it spills over
4208 4209 * and gets upgraded to a fatzap. Also, since we are adding
4209 4210 * 2050 entries we should see ptrtbl growth and leaf-block split.
4210 4211 */
4211 4212 for (int i = 0; i < 2050; i++) {
4212 4213 char name[MAXNAMELEN];
4213 4214 uint64_t value = i;
4214 4215 dmu_tx_t *tx;
4215 4216 int error;
4216 4217
4217 4218 (void) snprintf(name, sizeof (name), "fzap-%llu-%llu",
4218 4219 id, value);
4219 4220
4220 4221 tx = dmu_tx_create(os);
4221 4222 dmu_tx_hold_zap(tx, object, B_TRUE, name);
4222 4223 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
4223 4224 if (txg == 0)
4224 4225 return;
4225 4226 error = zap_add(os, object, name, sizeof (uint64_t), 1,
4226 4227 &value, tx);
4227 4228 ASSERT(error == 0 || error == EEXIST);
4228 4229 dmu_tx_commit(tx);
4229 4230 }
4230 4231 }
4231 4232
4232 4233 /* ARGSUSED */
4233 4234 void
4234 4235 ztest_zap_parallel(ztest_ds_t *zd, uint64_t id)
4235 4236 {
4236 4237 objset_t *os = zd->zd_os;
4237 4238 ztest_od_t od[1];
4238 4239 uint64_t txg, object, count, wsize, wc, zl_wsize, zl_wc;
4239 4240 dmu_tx_t *tx;
4240 4241 int i, namelen, error;
4241 4242 int micro = ztest_random(2);
4242 4243 char name[20], string_value[20];
4243 4244 void *data;
4244 4245
4245 4246 ztest_od_init(&od[0], ID_PARALLEL, FTAG, micro, DMU_OT_ZAP_OTHER, 0, 0);
4246 4247
4247 4248 if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0)
4248 4249 return;
4249 4250
4250 4251 object = od[0].od_object;
4251 4252
4252 4253 /*
4253 4254 * Generate a random name of the form 'xxx.....' where each
4254 4255 * x is a random printable character and the dots are dots.
4255 4256 * There are 94 such characters, and the name length goes from
4256 4257 * 6 to 20, so there are 94^3 * 15 = 12,458,760 possible names.
4257 4258 */
4258 4259 namelen = ztest_random(sizeof (name) - 5) + 5 + 1;
4259 4260
4260 4261 for (i = 0; i < 3; i++)
4261 4262 name[i] = '!' + ztest_random('~' - '!' + 1);
4262 4263 for (; i < namelen - 1; i++)
4263 4264 name[i] = '.';
4264 4265 name[i] = '\0';
4265 4266
4266 4267 if ((namelen & 1) || micro) {
4267 4268 wsize = sizeof (txg);
4268 4269 wc = 1;
4269 4270 data = &txg;
4270 4271 } else {
4271 4272 wsize = 1;
4272 4273 wc = namelen;
4273 4274 data = string_value;
4274 4275 }
4275 4276
4276 4277 count = -1ULL;
4277 4278 VERIFY0(zap_count(os, object, &count));
4278 4279 ASSERT(count != -1ULL);
4279 4280
4280 4281 /*
4281 4282 * Select an operation: length, lookup, add, update, remove.
4282 4283 */
4283 4284 i = ztest_random(5);
4284 4285
4285 4286 if (i >= 2) {
4286 4287 tx = dmu_tx_create(os);
4287 4288 dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
4288 4289 txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
4289 4290 if (txg == 0)
4290 4291 return;
4291 4292 bcopy(name, string_value, namelen);
4292 4293 } else {
4293 4294 tx = NULL;
4294 4295 txg = 0;
4295 4296 bzero(string_value, namelen);
4296 4297 }
4297 4298
4298 4299 switch (i) {
4299 4300
4300 4301 case 0:
4301 4302 error = zap_length(os, object, name, &zl_wsize, &zl_wc);
4302 4303 if (error == 0) {
4303 4304 ASSERT3U(wsize, ==, zl_wsize);
4304 4305 ASSERT3U(wc, ==, zl_wc);
4305 4306 } else {
4306 4307 ASSERT3U(error, ==, ENOENT);
4307 4308 }
4308 4309 break;
4309 4310
4310 4311 case 1:
4311 4312 error = zap_lookup(os, object, name, wsize, wc, data);
4312 4313 if (error == 0) {
4313 4314 if (data == string_value &&
4314 4315 bcmp(name, data, namelen) != 0)
4315 4316 fatal(0, "name '%s' != val '%s' len %d",
4316 4317 name, data, namelen);
4317 4318 } else {
4318 4319 ASSERT3U(error, ==, ENOENT);
4319 4320 }
4320 4321 break;
4321 4322
4322 4323 case 2:
4323 4324 error = zap_add(os, object, name, wsize, wc, data, tx);
4324 4325 ASSERT(error == 0 || error == EEXIST);
4325 4326 break;
4326 4327
4327 4328 case 3:
4328 4329 VERIFY(zap_update(os, object, name, wsize, wc, data, tx) == 0);
4329 4330 break;
4330 4331
4331 4332 case 4:
4332 4333 error = zap_remove(os, object, name, tx);
4333 4334 ASSERT(error == 0 || error == ENOENT);
4334 4335 break;
4335 4336 }
4336 4337
4337 4338 if (tx != NULL)
4338 4339 dmu_tx_commit(tx);
4339 4340 }
4340 4341
4341 4342 /*
4342 4343 * Commit callback data.
4343 4344 */
4344 4345 typedef struct ztest_cb_data {
4345 4346 list_node_t zcd_node;
4346 4347 uint64_t zcd_txg;
4347 4348 int zcd_expected_err;
4348 4349 boolean_t zcd_added;
4349 4350 boolean_t zcd_called;
4350 4351 spa_t *zcd_spa;
4351 4352 } ztest_cb_data_t;
4352 4353
4353 4354 /* This is the actual commit callback function */
4354 4355 static void
4355 4356 ztest_commit_callback(void *arg, int error)
4356 4357 {
4357 4358 ztest_cb_data_t *data = arg;
4358 4359 uint64_t synced_txg;
4359 4360
4360 4361 VERIFY(data != NULL);
4361 4362 VERIFY3S(data->zcd_expected_err, ==, error);
4362 4363 VERIFY(!data->zcd_called);
4363 4364
4364 4365 synced_txg = spa_last_synced_txg(data->zcd_spa);
4365 4366 if (data->zcd_txg > synced_txg)
4366 4367 fatal(0, "commit callback of txg %" PRIu64 " called prematurely"
4367 4368 ", last synced txg = %" PRIu64 "\n", data->zcd_txg,
4368 4369 synced_txg);
4369 4370
4370 4371 data->zcd_called = B_TRUE;
4371 4372
4372 4373 if (error == ECANCELED) {
4373 4374 ASSERT0(data->zcd_txg);
4374 4375 ASSERT(!data->zcd_added);
4375 4376
4376 4377 /*
4377 4378 * The private callback data should be destroyed here, but
4378 4379 * since we are going to check the zcd_called field after
4379 4380 * dmu_tx_abort(), we will destroy it there.
4380 4381 */
4381 4382 return;
4382 4383 }
4383 4384
4384 4385 /* Was this callback added to the global callback list? */
4385 4386 if (!data->zcd_added)
4386 4387 goto out;
4387 4388
4388 4389 ASSERT3U(data->zcd_txg, !=, 0);
4389 4390
4390 4391 /* Remove our callback from the list */
4391 4392 (void) mutex_lock(&zcl.zcl_callbacks_lock);
4392 4393 list_remove(&zcl.zcl_callbacks, data);
4393 4394 (void) mutex_unlock(&zcl.zcl_callbacks_lock);
4394 4395
4395 4396 out:
4396 4397 umem_free(data, sizeof (ztest_cb_data_t));
4397 4398 }
4398 4399
4399 4400 /* Allocate and initialize callback data structure */
4400 4401 static ztest_cb_data_t *
4401 4402 ztest_create_cb_data(objset_t *os, uint64_t txg)
4402 4403 {
4403 4404 ztest_cb_data_t *cb_data;
4404 4405
4405 4406 cb_data = umem_zalloc(sizeof (ztest_cb_data_t), UMEM_NOFAIL);
4406 4407
4407 4408 cb_data->zcd_txg = txg;
4408 4409 cb_data->zcd_spa = dmu_objset_spa(os);
4409 4410
4410 4411 return (cb_data);
4411 4412 }
4412 4413
4413 4414 /*
4414 4415 * If a number of txgs equal to this threshold have been created after a commit
4415 4416 * callback has been registered but not called, then we assume there is an
4416 4417 * implementation bug.
4417 4418 */
4418 4419 #define ZTEST_COMMIT_CALLBACK_THRESH (TXG_CONCURRENT_STATES + 2)
4419 4420
4420 4421 /*
4421 4422 * Commit callback test.
4422 4423 */
4423 4424 void
4424 4425 ztest_dmu_commit_callbacks(ztest_ds_t *zd, uint64_t id)
4425 4426 {
4426 4427 objset_t *os = zd->zd_os;
4427 4428 ztest_od_t od[1];
4428 4429 dmu_tx_t *tx;
4429 4430 ztest_cb_data_t *cb_data[3], *tmp_cb;
4430 4431 uint64_t old_txg, txg;
4431 4432 int i, error;
4432 4433
4433 4434 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0);
4434 4435
4435 4436 if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0)
4436 4437 return;
4437 4438
4438 4439 tx = dmu_tx_create(os);
4439 4440
4440 4441 cb_data[0] = ztest_create_cb_data(os, 0);
4441 4442 dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[0]);
4442 4443
4443 4444 dmu_tx_hold_write(tx, od[0].od_object, 0, sizeof (uint64_t));
4444 4445
4445 4446 /* Every once in a while, abort the transaction on purpose */
4446 4447 if (ztest_random(100) == 0)
4447 4448 error = -1;
4448 4449
4449 4450 if (!error)
4450 4451 error = dmu_tx_assign(tx, TXG_NOWAIT);
4451 4452
4452 4453 txg = error ? 0 : dmu_tx_get_txg(tx);
4453 4454
4454 4455 cb_data[0]->zcd_txg = txg;
4455 4456 cb_data[1] = ztest_create_cb_data(os, txg);
4456 4457 dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[1]);
4457 4458
4458 4459 if (error) {
4459 4460 /*
4460 4461 * It's not a strict requirement to call the registered
4461 4462 * callbacks from inside dmu_tx_abort(), but that's what
4462 4463 * it's supposed to happen in the current implementation
4463 4464 * so we will check for that.
4464 4465 */
4465 4466 for (i = 0; i < 2; i++) {
4466 4467 cb_data[i]->zcd_expected_err = ECANCELED;
4467 4468 VERIFY(!cb_data[i]->zcd_called);
4468 4469 }
4469 4470
4470 4471 dmu_tx_abort(tx);
4471 4472
4472 4473 for (i = 0; i < 2; i++) {
4473 4474 VERIFY(cb_data[i]->zcd_called);
4474 4475 umem_free(cb_data[i], sizeof (ztest_cb_data_t));
4475 4476 }
4476 4477
4477 4478 return;
4478 4479 }
4479 4480
4480 4481 cb_data[2] = ztest_create_cb_data(os, txg);
4481 4482 dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[2]);
4482 4483
4483 4484 /*
4484 4485 * Read existing data to make sure there isn't a future leak.
4485 4486 */
4486 4487 VERIFY(0 == dmu_read(os, od[0].od_object, 0, sizeof (uint64_t),
4487 4488 &old_txg, DMU_READ_PREFETCH));
4488 4489
4489 4490 if (old_txg > txg)
4490 4491 fatal(0, "future leak: got %" PRIu64 ", open txg is %" PRIu64,
4491 4492 old_txg, txg);
4492 4493
4493 4494 dmu_write(os, od[0].od_object, 0, sizeof (uint64_t), &txg, tx);
4494 4495
4495 4496 (void) mutex_lock(&zcl.zcl_callbacks_lock);
4496 4497
4497 4498 /*
4498 4499 * Since commit callbacks don't have any ordering requirement and since
4499 4500 * it is theoretically possible for a commit callback to be called
4500 4501 * after an arbitrary amount of time has elapsed since its txg has been
4501 4502 * synced, it is difficult to reliably determine whether a commit
4502 4503 * callback hasn't been called due to high load or due to a flawed
4503 4504 * implementation.
4504 4505 *
4505 4506 * In practice, we will assume that if after a certain number of txgs a
4506 4507 * commit callback hasn't been called, then most likely there's an
4507 4508 * implementation bug..
4508 4509 */
4509 4510 tmp_cb = list_head(&zcl.zcl_callbacks);
4510 4511 if (tmp_cb != NULL &&
4511 4512 (txg - ZTEST_COMMIT_CALLBACK_THRESH) > tmp_cb->zcd_txg) {
4512 4513 fatal(0, "Commit callback threshold exceeded, oldest txg: %"
4513 4514 PRIu64 ", open txg: %" PRIu64 "\n", tmp_cb->zcd_txg, txg);
4514 4515 }
4515 4516
4516 4517 /*
4517 4518 * Let's find the place to insert our callbacks.
4518 4519 *
4519 4520 * Even though the list is ordered by txg, it is possible for the
4520 4521 * insertion point to not be the end because our txg may already be
4521 4522 * quiescing at this point and other callbacks in the open txg
4522 4523 * (from other objsets) may have sneaked in.
4523 4524 */
4524 4525 tmp_cb = list_tail(&zcl.zcl_callbacks);
4525 4526 while (tmp_cb != NULL && tmp_cb->zcd_txg > txg)
4526 4527 tmp_cb = list_prev(&zcl.zcl_callbacks, tmp_cb);
4527 4528
4528 4529 /* Add the 3 callbacks to the list */
4529 4530 for (i = 0; i < 3; i++) {
4530 4531 if (tmp_cb == NULL)
4531 4532 list_insert_head(&zcl.zcl_callbacks, cb_data[i]);
4532 4533 else
4533 4534 list_insert_after(&zcl.zcl_callbacks, tmp_cb,
4534 4535 cb_data[i]);
4535 4536
4536 4537 cb_data[i]->zcd_added = B_TRUE;
4537 4538 VERIFY(!cb_data[i]->zcd_called);
4538 4539
4539 4540 tmp_cb = cb_data[i];
4540 4541 }
4541 4542
4542 4543 (void) mutex_unlock(&zcl.zcl_callbacks_lock);
4543 4544
4544 4545 dmu_tx_commit(tx);
4545 4546 }
4546 4547
4547 4548 /* ARGSUSED */
4548 4549 void
4549 4550 ztest_dsl_prop_get_set(ztest_ds_t *zd, uint64_t id)
4550 4551 {
4551 4552 zfs_prop_t proplist[] = {
4552 4553 ZFS_PROP_CHECKSUM,
4553 4554 ZFS_PROP_COMPRESSION,
4554 4555 ZFS_PROP_COPIES,
4555 4556 ZFS_PROP_DEDUP
4556 4557 };
4557 4558
4558 4559 (void) rw_rdlock(&ztest_name_lock);
4559 4560
4560 4561 for (int p = 0; p < sizeof (proplist) / sizeof (proplist[0]); p++)
4561 4562 (void) ztest_dsl_prop_set_uint64(zd->zd_name, proplist[p],
4562 4563 ztest_random_dsl_prop(proplist[p]), (int)ztest_random(2));
4563 4564
4564 4565 (void) rw_unlock(&ztest_name_lock);
4565 4566 }
4566 4567
4567 4568 /* ARGSUSED */
4568 4569 void
4569 4570 ztest_spa_prop_get_set(ztest_ds_t *zd, uint64_t id)
4570 4571 {
4571 4572 nvlist_t *props = NULL;
4572 4573
4573 4574 (void) rw_rdlock(&ztest_name_lock);
4574 4575
4575 4576 (void) ztest_spa_prop_set_uint64(ZPOOL_PROP_DEDUPDITTO,
4576 4577 ZIO_DEDUPDITTO_MIN + ztest_random(ZIO_DEDUPDITTO_MIN));
4577 4578
4578 4579 VERIFY0(spa_prop_get(ztest_spa, &props));
4579 4580
4580 4581 if (ztest_opts.zo_verbose >= 6)
4581 4582 dump_nvlist(props, 4);
4582 4583
4583 4584 nvlist_free(props);
4584 4585
4585 4586 (void) rw_unlock(&ztest_name_lock);
4586 4587 }
4587 4588
4588 4589 static int
4589 4590 user_release_one(const char *snapname, const char *holdname)
4590 4591 {
4591 4592 nvlist_t *snaps, *holds;
4592 4593 int error;
4593 4594
4594 4595 snaps = fnvlist_alloc();
4595 4596 holds = fnvlist_alloc();
4596 4597 fnvlist_add_boolean(holds, holdname);
4597 4598 fnvlist_add_nvlist(snaps, snapname, holds);
4598 4599 fnvlist_free(holds);
4599 4600 error = dsl_dataset_user_release(snaps, NULL);
4600 4601 fnvlist_free(snaps);
4601 4602 return (error);
4602 4603 }
4603 4604
4604 4605 /*
4605 4606 * Test snapshot hold/release and deferred destroy.
4606 4607 */
4607 4608 void
4608 4609 ztest_dmu_snapshot_hold(ztest_ds_t *zd, uint64_t id)
4609 4610 {
4610 4611 int error;
4611 4612 objset_t *os = zd->zd_os;
4612 4613 objset_t *origin;
4613 4614 char snapname[100];
4614 4615 char fullname[100];
4615 4616 char clonename[100];
4616 4617 char tag[100];
4617 4618 char osname[MAXNAMELEN];
4618 4619 nvlist_t *holds;
4619 4620
4620 4621 (void) rw_rdlock(&ztest_name_lock);
4621 4622
4622 4623 dmu_objset_name(os, osname);
4623 4624
4624 4625 (void) snprintf(snapname, sizeof (snapname), "sh1_%llu", id);
4625 4626 (void) snprintf(fullname, sizeof (fullname), "%s@%s", osname, snapname);
4626 4627 (void) snprintf(clonename, sizeof (clonename),
4627 4628 "%s/ch1_%llu", osname, id);
4628 4629 (void) snprintf(tag, sizeof (tag), "tag_%llu", id);
4629 4630
4630 4631 /*
4631 4632 * Clean up from any previous run.
4632 4633 */
4633 4634 error = dsl_destroy_head(clonename);
4634 4635 if (error != ENOENT)
4635 4636 ASSERT0(error);
4636 4637 error = user_release_one(fullname, tag);
4637 4638 if (error != ESRCH && error != ENOENT)
4638 4639 ASSERT0(error);
4639 4640 error = dsl_destroy_snapshot(fullname, B_FALSE);
4640 4641 if (error != ENOENT)
4641 4642 ASSERT0(error);
4642 4643
4643 4644 /*
4644 4645 * Create snapshot, clone it, mark snap for deferred destroy,
4645 4646 * destroy clone, verify snap was also destroyed.
4646 4647 */
4647 4648 error = dmu_objset_snapshot_one(osname, snapname);
4648 4649 if (error) {
4649 4650 if (error == ENOSPC) {
4650 4651 ztest_record_enospc("dmu_objset_snapshot");
4651 4652 goto out;
4652 4653 }
4653 4654 fatal(0, "dmu_objset_snapshot(%s) = %d", fullname, error);
4654 4655 }
4655 4656
4656 4657 error = dmu_objset_clone(clonename, fullname);
4657 4658 if (error) {
4658 4659 if (error == ENOSPC) {
4659 4660 ztest_record_enospc("dmu_objset_clone");
4660 4661 goto out;
4661 4662 }
4662 4663 fatal(0, "dmu_objset_clone(%s) = %d", clonename, error);
4663 4664 }
4664 4665
4665 4666 error = dsl_destroy_snapshot(fullname, B_TRUE);
4666 4667 if (error) {
4667 4668 fatal(0, "dsl_destroy_snapshot(%s, B_TRUE) = %d",
4668 4669 fullname, error);
4669 4670 }
4670 4671
4671 4672 error = dsl_destroy_head(clonename);
4672 4673 if (error)
4673 4674 fatal(0, "dsl_destroy_head(%s) = %d", clonename, error);
4674 4675
4675 4676 error = dmu_objset_hold(fullname, FTAG, &origin);
4676 4677 if (error != ENOENT)
4677 4678 fatal(0, "dmu_objset_hold(%s) = %d", fullname, error);
4678 4679
4679 4680 /*
4680 4681 * Create snapshot, add temporary hold, verify that we can't
4681 4682 * destroy a held snapshot, mark for deferred destroy,
4682 4683 * release hold, verify snapshot was destroyed.
4683 4684 */
4684 4685 error = dmu_objset_snapshot_one(osname, snapname);
4685 4686 if (error) {
4686 4687 if (error == ENOSPC) {
4687 4688 ztest_record_enospc("dmu_objset_snapshot");
4688 4689 goto out;
4689 4690 }
4690 4691 fatal(0, "dmu_objset_snapshot(%s) = %d", fullname, error);
4691 4692 }
4692 4693
4693 4694 holds = fnvlist_alloc();
4694 4695 fnvlist_add_string(holds, fullname, tag);
4695 4696 error = dsl_dataset_user_hold(holds, 0, NULL);
4696 4697 fnvlist_free(holds);
4697 4698
4698 4699 if (error)
4699 4700 fatal(0, "dsl_dataset_user_hold(%s)", fullname, tag);
4700 4701
4701 4702 error = dsl_destroy_snapshot(fullname, B_FALSE);
4702 4703 if (error != EBUSY) {
4703 4704 fatal(0, "dsl_destroy_snapshot(%s, B_FALSE) = %d",
4704 4705 fullname, error);
4705 4706 }
4706 4707
4707 4708 error = dsl_destroy_snapshot(fullname, B_TRUE);
4708 4709 if (error) {
4709 4710 fatal(0, "dsl_destroy_snapshot(%s, B_TRUE) = %d",
4710 4711 fullname, error);
4711 4712 }
4712 4713
4713 4714 error = user_release_one(fullname, tag);
4714 4715 if (error)
4715 4716 fatal(0, "user_release_one(%s, %s) = %d", fullname, tag, error);
4716 4717
4717 4718 VERIFY3U(dmu_objset_hold(fullname, FTAG, &origin), ==, ENOENT);
4718 4719
4719 4720 out:
4720 4721 (void) rw_unlock(&ztest_name_lock);
4721 4722 }
4722 4723
4723 4724 /*
4724 4725 * Inject random faults into the on-disk data.
4725 4726 */
4726 4727 /* ARGSUSED */
4727 4728 void
4728 4729 ztest_fault_inject(ztest_ds_t *zd, uint64_t id)
4729 4730 {
4730 4731 ztest_shared_t *zs = ztest_shared;
4731 4732 spa_t *spa = ztest_spa;
4732 4733 int fd;
4733 4734 uint64_t offset;
4734 4735 uint64_t leaves;
4735 4736 uint64_t bad = 0x1990c0ffeedecade;
4736 4737 uint64_t top, leaf;
4737 4738 char path0[MAXPATHLEN];
4738 4739 char pathrand[MAXPATHLEN];
4739 4740 size_t fsize;
4740 4741 int bshift = SPA_MAXBLOCKSHIFT + 2; /* don't scrog all labels */
4741 4742 int iters = 1000;
4742 4743 int maxfaults;
4743 4744 int mirror_save;
4744 4745 vdev_t *vd0 = NULL;
4745 4746 uint64_t guid0 = 0;
4746 4747 boolean_t islog = B_FALSE;
|
↓ open down ↓ |
4370 lines elided |
↑ open up ↑ |
4747 4748
4748 4749 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
4749 4750 maxfaults = MAXFAULTS();
4750 4751 leaves = MAX(zs->zs_mirrors, 1) * ztest_opts.zo_raidz;
4751 4752 mirror_save = zs->zs_mirrors;
4752 4753 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
4753 4754
4754 4755 ASSERT(leaves >= 1);
4755 4756
4756 4757 /*
4758 + * Grab the name lock as reader. There are some operations
4759 + * which don't like to have their vdevs changed while
4760 + * they are in progress (i.e. spa_change_guid). Those
4761 + * operations will have grabbed the name lock as writer.
4762 + */
4763 + (void) rw_rdlock(&ztest_name_lock);
4764 +
4765 + /*
4757 4766 * We need SCL_STATE here because we're going to look at vd0->vdev_tsd.
4758 4767 */
4759 4768 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
4760 4769
4761 4770 if (ztest_random(2) == 0) {
4762 4771 /*
4763 4772 * Inject errors on a normal data device or slog device.
4764 4773 */
4765 4774 top = ztest_random_vdev_top(spa, B_TRUE);
4766 4775 leaf = ztest_random(leaves) + zs->zs_splits;
4767 4776
4768 4777 /*
4769 4778 * Generate paths to the first leaf in this top-level vdev,
4770 4779 * and to the random leaf we selected. We'll induce transient
4771 4780 * write failures and random online/offline activity on leaf 0,
4772 4781 * and we'll write random garbage to the randomly chosen leaf.
4773 4782 */
4774 4783 (void) snprintf(path0, sizeof (path0), ztest_dev_template,
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
4775 4784 ztest_opts.zo_dir, ztest_opts.zo_pool,
4776 4785 top * leaves + zs->zs_splits);
4777 4786 (void) snprintf(pathrand, sizeof (pathrand), ztest_dev_template,
4778 4787 ztest_opts.zo_dir, ztest_opts.zo_pool,
4779 4788 top * leaves + leaf);
4780 4789
4781 4790 vd0 = vdev_lookup_by_path(spa->spa_root_vdev, path0);
4782 4791 if (vd0 != NULL && vd0->vdev_top->vdev_islog)
4783 4792 islog = B_TRUE;
4784 4793
4785 - if (vd0 != NULL && maxfaults != 1) {
4794 + /*
4795 + * If the top-level vdev needs to be resilvered
4796 + * then we only allow faults on the device that is
4797 + * resilvering.
4798 + */
4799 + if (vd0 != NULL && maxfaults != 1 &&
4800 + (!vdev_resilver_needed(vd0->vdev_top, NULL, NULL) ||
4801 + vd0->vdev_resilvering)) {
4786 4802 /*
4787 4803 * Make vd0 explicitly claim to be unreadable,
4788 4804 * or unwriteable, or reach behind its back
4789 4805 * and close the underlying fd. We can do this if
4790 4806 * maxfaults == 0 because we'll fail and reexecute,
4791 4807 * and we can do it if maxfaults >= 2 because we'll
4792 4808 * have enough redundancy. If maxfaults == 1, the
4793 4809 * combination of this with injection of random data
4794 4810 * corruption below exceeds the pool's fault tolerance.
4795 4811 */
4796 4812 vdev_file_t *vf = vd0->vdev_tsd;
4797 4813
4798 4814 if (vf != NULL && ztest_random(3) == 0) {
4799 4815 (void) close(vf->vf_vnode->v_fd);
4800 4816 vf->vf_vnode->v_fd = -1;
4801 4817 } else if (ztest_random(2) == 0) {
4802 4818 vd0->vdev_cant_read = B_TRUE;
4803 4819 } else {
4804 4820 vd0->vdev_cant_write = B_TRUE;
4805 4821 }
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
4806 4822 guid0 = vd0->vdev_guid;
4807 4823 }
4808 4824 } else {
4809 4825 /*
4810 4826 * Inject errors on an l2cache device.
4811 4827 */
4812 4828 spa_aux_vdev_t *sav = &spa->spa_l2cache;
4813 4829
4814 4830 if (sav->sav_count == 0) {
4815 4831 spa_config_exit(spa, SCL_STATE, FTAG);
4832 + (void) rw_unlock(&ztest_name_lock);
4816 4833 return;
4817 4834 }
4818 4835 vd0 = sav->sav_vdevs[ztest_random(sav->sav_count)];
4819 4836 guid0 = vd0->vdev_guid;
4820 4837 (void) strcpy(path0, vd0->vdev_path);
4821 4838 (void) strcpy(pathrand, vd0->vdev_path);
4822 4839
4823 4840 leaf = 0;
4824 4841 leaves = 1;
4825 4842 maxfaults = INT_MAX; /* no limit on cache devices */
4826 4843 }
4827 4844
4828 4845 spa_config_exit(spa, SCL_STATE, FTAG);
4846 + (void) rw_unlock(&ztest_name_lock);
4829 4847
4830 4848 /*
4831 4849 * If we can tolerate two or more faults, or we're dealing
4832 4850 * with a slog, randomly online/offline vd0.
4833 4851 */
4834 4852 if ((maxfaults >= 2 || islog) && guid0 != 0) {
4835 4853 if (ztest_random(10) < 6) {
4836 4854 int flags = (ztest_random(2) == 0 ?
4837 4855 ZFS_OFFLINE_TEMPORARY : 0);
4838 4856
4839 4857 /*
4840 4858 * We have to grab the zs_name_lock as writer to
4841 4859 * prevent a race between offlining a slog and
4842 4860 * destroying a dataset. Offlining the slog will
4843 4861 * grab a reference on the dataset which may cause
4844 4862 * dmu_objset_destroy() to fail with EBUSY thus
4845 4863 * leaving the dataset in an inconsistent state.
4846 4864 */
4847 4865 if (islog)
4848 4866 (void) rw_wrlock(&ztest_name_lock);
4849 4867
4850 4868 VERIFY(vdev_offline(spa, guid0, flags) != EBUSY);
4851 4869
4852 4870 if (islog)
4853 4871 (void) rw_unlock(&ztest_name_lock);
4854 4872 } else {
4855 4873 /*
4856 4874 * Ideally we would like to be able to randomly
4857 4875 * call vdev_[on|off]line without holding locks
4858 4876 * to force unpredictable failures but the side
4859 4877 * effects of vdev_[on|off]line prevent us from
4860 4878 * doing so. We grab the ztest_vdev_lock here to
4861 4879 * prevent a race between injection testing and
4862 4880 * aux_vdev removal.
4863 4881 */
4864 4882 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
4865 4883 (void) vdev_online(spa, guid0, 0, NULL);
4866 4884 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
4867 4885 }
4868 4886 }
4869 4887
4870 4888 if (maxfaults == 0)
4871 4889 return;
4872 4890
4873 4891 /*
4874 4892 * We have at least single-fault tolerance, so inject data corruption.
4875 4893 */
4876 4894 fd = open(pathrand, O_RDWR);
4877 4895
4878 4896 if (fd == -1) /* we hit a gap in the device namespace */
4879 4897 return;
4880 4898
4881 4899 fsize = lseek(fd, 0, SEEK_END);
4882 4900
4883 4901 while (--iters != 0) {
4884 4902 offset = ztest_random(fsize / (leaves << bshift)) *
4885 4903 (leaves << bshift) + (leaf << bshift) +
4886 4904 (ztest_random(1ULL << (bshift - 1)) & -8ULL);
4887 4905
4888 4906 if (offset >= fsize)
4889 4907 continue;
4890 4908
4891 4909 VERIFY(mutex_lock(&ztest_vdev_lock) == 0);
4892 4910 if (mirror_save != zs->zs_mirrors) {
4893 4911 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
4894 4912 (void) close(fd);
4895 4913 return;
4896 4914 }
4897 4915
4898 4916 if (pwrite(fd, &bad, sizeof (bad), offset) != sizeof (bad))
4899 4917 fatal(1, "can't inject bad word at 0x%llx in %s",
4900 4918 offset, pathrand);
4901 4919
4902 4920 VERIFY(mutex_unlock(&ztest_vdev_lock) == 0);
4903 4921
4904 4922 if (ztest_opts.zo_verbose >= 7)
4905 4923 (void) printf("injected bad word into %s,"
4906 4924 " offset 0x%llx\n", pathrand, (u_longlong_t)offset);
4907 4925 }
4908 4926
4909 4927 (void) close(fd);
4910 4928 }
4911 4929
4912 4930 /*
4913 4931 * Verify that DDT repair works as expected.
4914 4932 */
4915 4933 void
4916 4934 ztest_ddt_repair(ztest_ds_t *zd, uint64_t id)
4917 4935 {
4918 4936 ztest_shared_t *zs = ztest_shared;
4919 4937 spa_t *spa = ztest_spa;
4920 4938 objset_t *os = zd->zd_os;
4921 4939 ztest_od_t od[1];
4922 4940 uint64_t object, blocksize, txg, pattern, psize;
4923 4941 enum zio_checksum checksum = spa_dedup_checksum(spa);
4924 4942 dmu_buf_t *db;
4925 4943 dmu_tx_t *tx;
4926 4944 void *buf;
4927 4945 blkptr_t blk;
4928 4946 int copies = 2 * ZIO_DEDUPDITTO_MIN;
4929 4947
4930 4948 blocksize = ztest_random_blocksize();
4931 4949 blocksize = MIN(blocksize, 2048); /* because we write so many */
4932 4950
4933 4951 ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0);
4934 4952
4935 4953 if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0)
4936 4954 return;
4937 4955
4938 4956 /*
4939 4957 * Take the name lock as writer to prevent anyone else from changing
4940 4958 * the pool and dataset properies we need to maintain during this test.
4941 4959 */
4942 4960 (void) rw_wrlock(&ztest_name_lock);
4943 4961
4944 4962 if (ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_DEDUP, checksum,
4945 4963 B_FALSE) != 0 ||
4946 4964 ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_COPIES, 1,
4947 4965 B_FALSE) != 0) {
4948 4966 (void) rw_unlock(&ztest_name_lock);
4949 4967 return;
4950 4968 }
4951 4969
4952 4970 object = od[0].od_object;
4953 4971 blocksize = od[0].od_blocksize;
4954 4972 pattern = zs->zs_guid ^ dmu_objset_fsid_guid(os);
4955 4973
4956 4974 ASSERT(object != 0);
4957 4975
4958 4976 tx = dmu_tx_create(os);
4959 4977 dmu_tx_hold_write(tx, object, 0, copies * blocksize);
4960 4978 txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
4961 4979 if (txg == 0) {
4962 4980 (void) rw_unlock(&ztest_name_lock);
4963 4981 return;
4964 4982 }
4965 4983
4966 4984 /*
4967 4985 * Write all the copies of our block.
4968 4986 */
4969 4987 for (int i = 0; i < copies; i++) {
4970 4988 uint64_t offset = i * blocksize;
4971 4989 int error = dmu_buf_hold(os, object, offset, FTAG, &db,
4972 4990 DMU_READ_NO_PREFETCH);
4973 4991 if (error != 0) {
4974 4992 fatal(B_FALSE, "dmu_buf_hold(%p, %llu, %llu) = %u",
4975 4993 os, (long long)object, (long long) offset, error);
4976 4994 }
4977 4995 ASSERT(db->db_offset == offset);
4978 4996 ASSERT(db->db_size == blocksize);
4979 4997 ASSERT(ztest_pattern_match(db->db_data, db->db_size, pattern) ||
4980 4998 ztest_pattern_match(db->db_data, db->db_size, 0ULL));
4981 4999 dmu_buf_will_fill(db, tx);
4982 5000 ztest_pattern_set(db->db_data, db->db_size, pattern);
4983 5001 dmu_buf_rele(db, FTAG);
4984 5002 }
4985 5003
4986 5004 dmu_tx_commit(tx);
4987 5005 txg_wait_synced(spa_get_dsl(spa), txg);
4988 5006
4989 5007 /*
4990 5008 * Find out what block we got.
4991 5009 */
4992 5010 VERIFY0(dmu_buf_hold(os, object, 0, FTAG, &db,
4993 5011 DMU_READ_NO_PREFETCH));
4994 5012 blk = *((dmu_buf_impl_t *)db)->db_blkptr;
4995 5013 dmu_buf_rele(db, FTAG);
4996 5014
4997 5015 /*
4998 5016 * Damage the block. Dedup-ditto will save us when we read it later.
4999 5017 */
5000 5018 psize = BP_GET_PSIZE(&blk);
5001 5019 buf = zio_buf_alloc(psize);
5002 5020 ztest_pattern_set(buf, psize, ~pattern);
5003 5021
5004 5022 (void) zio_wait(zio_rewrite(NULL, spa, 0, &blk,
5005 5023 buf, psize, NULL, NULL, ZIO_PRIORITY_SYNC_WRITE,
5006 5024 ZIO_FLAG_CANFAIL | ZIO_FLAG_INDUCE_DAMAGE, NULL));
5007 5025
5008 5026 zio_buf_free(buf, psize);
5009 5027
5010 5028 (void) rw_unlock(&ztest_name_lock);
5011 5029 }
5012 5030
5013 5031 /*
5014 5032 * Scrub the pool.
5015 5033 */
5016 5034 /* ARGSUSED */
5017 5035 void
5018 5036 ztest_scrub(ztest_ds_t *zd, uint64_t id)
5019 5037 {
5020 5038 spa_t *spa = ztest_spa;
5021 5039
5022 5040 (void) spa_scan(spa, POOL_SCAN_SCRUB);
5023 5041 (void) poll(NULL, 0, 100); /* wait a moment, then force a restart */
5024 5042 (void) spa_scan(spa, POOL_SCAN_SCRUB);
5025 5043 }
5026 5044
5027 5045 /*
5028 5046 * Change the guid for the pool.
5029 5047 */
5030 5048 /* ARGSUSED */
5031 5049 void
5032 5050 ztest_reguid(ztest_ds_t *zd, uint64_t id)
5033 5051 {
5034 5052 spa_t *spa = ztest_spa;
5035 5053 uint64_t orig, load;
5036 5054 int error;
5037 5055
5038 5056 orig = spa_guid(spa);
5039 5057 load = spa_load_guid(spa);
5040 5058
5041 5059 (void) rw_wrlock(&ztest_name_lock);
5042 5060 error = spa_change_guid(spa);
5043 5061 (void) rw_unlock(&ztest_name_lock);
5044 5062
5045 5063 if (error != 0)
5046 5064 return;
5047 5065
5048 5066 if (ztest_opts.zo_verbose >= 4) {
5049 5067 (void) printf("Changed guid old %llu -> %llu\n",
5050 5068 (u_longlong_t)orig, (u_longlong_t)spa_guid(spa));
5051 5069 }
5052 5070
5053 5071 VERIFY3U(orig, !=, spa_guid(spa));
5054 5072 VERIFY3U(load, ==, spa_load_guid(spa));
5055 5073 }
5056 5074
5057 5075 /*
5058 5076 * Rename the pool to a different name and then rename it back.
5059 5077 */
5060 5078 /* ARGSUSED */
5061 5079 void
5062 5080 ztest_spa_rename(ztest_ds_t *zd, uint64_t id)
5063 5081 {
5064 5082 char *oldname, *newname;
5065 5083 spa_t *spa;
5066 5084
5067 5085 (void) rw_wrlock(&ztest_name_lock);
5068 5086
5069 5087 oldname = ztest_opts.zo_pool;
5070 5088 newname = umem_alloc(strlen(oldname) + 5, UMEM_NOFAIL);
5071 5089 (void) strcpy(newname, oldname);
5072 5090 (void) strcat(newname, "_tmp");
5073 5091
5074 5092 /*
5075 5093 * Do the rename
5076 5094 */
5077 5095 VERIFY3U(0, ==, spa_rename(oldname, newname));
5078 5096
5079 5097 /*
5080 5098 * Try to open it under the old name, which shouldn't exist
5081 5099 */
5082 5100 VERIFY3U(ENOENT, ==, spa_open(oldname, &spa, FTAG));
5083 5101
5084 5102 /*
5085 5103 * Open it under the new name and make sure it's still the same spa_t.
5086 5104 */
5087 5105 VERIFY3U(0, ==, spa_open(newname, &spa, FTAG));
5088 5106
5089 5107 ASSERT(spa == ztest_spa);
5090 5108 spa_close(spa, FTAG);
5091 5109
5092 5110 /*
5093 5111 * Rename it back to the original
5094 5112 */
5095 5113 VERIFY3U(0, ==, spa_rename(newname, oldname));
5096 5114
5097 5115 /*
5098 5116 * Make sure it can still be opened
5099 5117 */
5100 5118 VERIFY3U(0, ==, spa_open(oldname, &spa, FTAG));
5101 5119
5102 5120 ASSERT(spa == ztest_spa);
5103 5121 spa_close(spa, FTAG);
5104 5122
5105 5123 umem_free(newname, strlen(newname) + 1);
5106 5124
5107 5125 (void) rw_unlock(&ztest_name_lock);
5108 5126 }
5109 5127
5110 5128 /*
5111 5129 * Verify pool integrity by running zdb.
5112 5130 */
5113 5131 static void
5114 5132 ztest_run_zdb(char *pool)
5115 5133 {
5116 5134 int status;
5117 5135 char zdb[MAXPATHLEN + MAXNAMELEN + 20];
5118 5136 char zbuf[1024];
5119 5137 char *bin;
5120 5138 char *ztest;
5121 5139 char *isa;
5122 5140 int isalen;
5123 5141 FILE *fp;
5124 5142
5125 5143 (void) realpath(getexecname(), zdb);
5126 5144
5127 5145 /* zdb lives in /usr/sbin, while ztest lives in /usr/bin */
5128 5146 bin = strstr(zdb, "/usr/bin/");
5129 5147 ztest = strstr(bin, "/ztest");
5130 5148 isa = bin + 8;
5131 5149 isalen = ztest - isa;
5132 5150 isa = strdup(isa);
5133 5151 /* LINTED */
5134 5152 (void) sprintf(bin,
5135 5153 "/usr/sbin%.*s/zdb -bcc%s%s -U %s %s",
5136 5154 isalen,
5137 5155 isa,
5138 5156 ztest_opts.zo_verbose >= 3 ? "s" : "",
5139 5157 ztest_opts.zo_verbose >= 4 ? "v" : "",
5140 5158 spa_config_path,
5141 5159 pool);
5142 5160 free(isa);
5143 5161
5144 5162 if (ztest_opts.zo_verbose >= 5)
5145 5163 (void) printf("Executing %s\n", strstr(zdb, "zdb "));
5146 5164
5147 5165 fp = popen(zdb, "r");
5148 5166
5149 5167 while (fgets(zbuf, sizeof (zbuf), fp) != NULL)
5150 5168 if (ztest_opts.zo_verbose >= 3)
5151 5169 (void) printf("%s", zbuf);
5152 5170
5153 5171 status = pclose(fp);
5154 5172
5155 5173 if (status == 0)
5156 5174 return;
5157 5175
5158 5176 ztest_dump_core = 0;
5159 5177 if (WIFEXITED(status))
5160 5178 fatal(0, "'%s' exit code %d", zdb, WEXITSTATUS(status));
5161 5179 else
5162 5180 fatal(0, "'%s' died with signal %d", zdb, WTERMSIG(status));
5163 5181 }
5164 5182
5165 5183 static void
5166 5184 ztest_walk_pool_directory(char *header)
5167 5185 {
5168 5186 spa_t *spa = NULL;
5169 5187
5170 5188 if (ztest_opts.zo_verbose >= 6)
5171 5189 (void) printf("%s\n", header);
5172 5190
5173 5191 mutex_enter(&spa_namespace_lock);
5174 5192 while ((spa = spa_next(spa)) != NULL)
5175 5193 if (ztest_opts.zo_verbose >= 6)
5176 5194 (void) printf("\t%s\n", spa_name(spa));
5177 5195 mutex_exit(&spa_namespace_lock);
5178 5196 }
5179 5197
5180 5198 static void
5181 5199 ztest_spa_import_export(char *oldname, char *newname)
5182 5200 {
5183 5201 nvlist_t *config, *newconfig;
5184 5202 uint64_t pool_guid;
5185 5203 spa_t *spa;
5186 5204 int error;
5187 5205
5188 5206 if (ztest_opts.zo_verbose >= 4) {
5189 5207 (void) printf("import/export: old = %s, new = %s\n",
5190 5208 oldname, newname);
5191 5209 }
5192 5210
5193 5211 /*
5194 5212 * Clean up from previous runs.
5195 5213 */
5196 5214 (void) spa_destroy(newname);
5197 5215
5198 5216 /*
5199 5217 * Get the pool's configuration and guid.
5200 5218 */
5201 5219 VERIFY3U(0, ==, spa_open(oldname, &spa, FTAG));
5202 5220
5203 5221 /*
5204 5222 * Kick off a scrub to tickle scrub/export races.
5205 5223 */
5206 5224 if (ztest_random(2) == 0)
5207 5225 (void) spa_scan(spa, POOL_SCAN_SCRUB);
5208 5226
5209 5227 pool_guid = spa_guid(spa);
5210 5228 spa_close(spa, FTAG);
5211 5229
5212 5230 ztest_walk_pool_directory("pools before export");
5213 5231
5214 5232 /*
5215 5233 * Export it.
5216 5234 */
5217 5235 VERIFY3U(0, ==, spa_export(oldname, &config, B_FALSE, B_FALSE));
5218 5236
5219 5237 ztest_walk_pool_directory("pools after export");
5220 5238
5221 5239 /*
5222 5240 * Try to import it.
5223 5241 */
5224 5242 newconfig = spa_tryimport(config);
5225 5243 ASSERT(newconfig != NULL);
5226 5244 nvlist_free(newconfig);
5227 5245
5228 5246 /*
5229 5247 * Import it under the new name.
5230 5248 */
5231 5249 error = spa_import(newname, config, NULL, 0);
5232 5250 if (error != 0) {
5233 5251 dump_nvlist(config, 0);
5234 5252 fatal(B_FALSE, "couldn't import pool %s as %s: error %u",
5235 5253 oldname, newname, error);
5236 5254 }
5237 5255
5238 5256 ztest_walk_pool_directory("pools after import");
5239 5257
5240 5258 /*
5241 5259 * Try to import it again -- should fail with EEXIST.
5242 5260 */
5243 5261 VERIFY3U(EEXIST, ==, spa_import(newname, config, NULL, 0));
5244 5262
5245 5263 /*
5246 5264 * Try to import it under a different name -- should fail with EEXIST.
5247 5265 */
5248 5266 VERIFY3U(EEXIST, ==, spa_import(oldname, config, NULL, 0));
5249 5267
5250 5268 /*
5251 5269 * Verify that the pool is no longer visible under the old name.
5252 5270 */
5253 5271 VERIFY3U(ENOENT, ==, spa_open(oldname, &spa, FTAG));
5254 5272
5255 5273 /*
5256 5274 * Verify that we can open and close the pool using the new name.
5257 5275 */
5258 5276 VERIFY3U(0, ==, spa_open(newname, &spa, FTAG));
5259 5277 ASSERT(pool_guid == spa_guid(spa));
5260 5278 spa_close(spa, FTAG);
5261 5279
5262 5280 nvlist_free(config);
5263 5281 }
5264 5282
5265 5283 static void
5266 5284 ztest_resume(spa_t *spa)
5267 5285 {
5268 5286 if (spa_suspended(spa) && ztest_opts.zo_verbose >= 6)
5269 5287 (void) printf("resuming from suspended state\n");
5270 5288 spa_vdev_state_enter(spa, SCL_NONE);
5271 5289 vdev_clear(spa, NULL);
5272 5290 (void) spa_vdev_state_exit(spa, NULL, 0);
5273 5291 (void) zio_resume(spa);
5274 5292 }
5275 5293
5276 5294 static void *
5277 5295 ztest_resume_thread(void *arg)
5278 5296 {
5279 5297 spa_t *spa = arg;
5280 5298
5281 5299 while (!ztest_exiting) {
5282 5300 if (spa_suspended(spa))
|
↓ open down ↓ |
444 lines elided |
↑ open up ↑ |
5283 5301 ztest_resume(spa);
5284 5302 (void) poll(NULL, 0, 100);
5285 5303 }
5286 5304 return (NULL);
5287 5305 }
5288 5306
5289 5307 static void *
5290 5308 ztest_deadman_thread(void *arg)
5291 5309 {
5292 5310 ztest_shared_t *zs = arg;
5293 - int grace = 300;
5294 - hrtime_t delta;
5311 + spa_t *spa = ztest_spa;
5312 + hrtime_t delta, total = 0;
5295 5313
5296 - delta = (zs->zs_thread_stop - zs->zs_thread_start) / NANOSEC + grace;
5314 + for (;;) {
5315 + delta = (zs->zs_thread_stop - zs->zs_thread_start) /
5316 + NANOSEC + zfs_deadman_synctime;
5297 5317
5298 - (void) poll(NULL, 0, (int)(1000 * delta));
5318 + (void) poll(NULL, 0, (int)(1000 * delta));
5299 5319
5300 - fatal(0, "failed to complete within %d seconds of deadline", grace);
5320 + /*
5321 + * If the pool is suspended then fail immediately. Otherwise,
5322 + * check to see if the pool is making any progress. If
5323 + * vdev_deadman() discovers that there hasn't been any recent
5324 + * I/Os then it will end up aborting the tests.
5325 + */
5326 + if (spa_suspended(spa)) {
5327 + fatal(0, "aborting test after %llu seconds because "
5328 + "pool has transitioned to a suspended state.",
5329 + zfs_deadman_synctime);
5330 + return (NULL);
5331 + }
5332 + vdev_deadman(spa->spa_root_vdev);
5301 5333
5302 - return (NULL);
5334 + total += zfs_deadman_synctime;
5335 + (void) printf("ztest has been running for %lld seconds\n",
5336 + total);
5337 + }
5303 5338 }
5304 5339
5305 5340 static void
5306 5341 ztest_execute(int test, ztest_info_t *zi, uint64_t id)
5307 5342 {
5308 5343 ztest_ds_t *zd = &ztest_ds[id % ztest_opts.zo_datasets];
5309 5344 ztest_shared_callstate_t *zc = ZTEST_GET_SHARED_CALLSTATE(test);
5310 5345 hrtime_t functime = gethrtime();
5311 5346
5312 5347 for (int i = 0; i < zi->zi_iters; i++)
5313 5348 zi->zi_func(zd, id);
5314 5349
5315 5350 functime = gethrtime() - functime;
5316 5351
5317 5352 atomic_add_64(&zc->zc_count, 1);
5318 5353 atomic_add_64(&zc->zc_time, functime);
5319 5354
5320 5355 if (ztest_opts.zo_verbose >= 4) {
5321 5356 Dl_info dli;
5322 5357 (void) dladdr((void *)zi->zi_func, &dli);
5323 5358 (void) printf("%6.2f sec in %s\n",
5324 5359 (double)functime / NANOSEC, dli.dli_sname);
5325 5360 }
5326 5361 }
5327 5362
5328 5363 static void *
5329 5364 ztest_thread(void *arg)
5330 5365 {
5331 5366 int rand;
5332 5367 uint64_t id = (uintptr_t)arg;
5333 5368 ztest_shared_t *zs = ztest_shared;
5334 5369 uint64_t call_next;
5335 5370 hrtime_t now;
5336 5371 ztest_info_t *zi;
5337 5372 ztest_shared_callstate_t *zc;
5338 5373
5339 5374 while ((now = gethrtime()) < zs->zs_thread_stop) {
5340 5375 /*
5341 5376 * See if it's time to force a crash.
5342 5377 */
5343 5378 if (now > zs->zs_thread_kill)
5344 5379 ztest_kill(zs);
5345 5380
5346 5381 /*
5347 5382 * If we're getting ENOSPC with some regularity, stop.
5348 5383 */
5349 5384 if (zs->zs_enospc_count > 10)
5350 5385 break;
5351 5386
5352 5387 /*
5353 5388 * Pick a random function to execute.
5354 5389 */
5355 5390 rand = ztest_random(ZTEST_FUNCS);
5356 5391 zi = &ztest_info[rand];
5357 5392 zc = ZTEST_GET_SHARED_CALLSTATE(rand);
5358 5393 call_next = zc->zc_next;
5359 5394
5360 5395 if (now >= call_next &&
5361 5396 atomic_cas_64(&zc->zc_next, call_next, call_next +
5362 5397 ztest_random(2 * zi->zi_interval[0] + 1)) == call_next) {
5363 5398 ztest_execute(rand, zi, id);
5364 5399 }
5365 5400 }
5366 5401
5367 5402 return (NULL);
5368 5403 }
5369 5404
5370 5405 static void
5371 5406 ztest_dataset_name(char *dsname, char *pool, int d)
5372 5407 {
5373 5408 (void) snprintf(dsname, MAXNAMELEN, "%s/ds_%d", pool, d);
5374 5409 }
5375 5410
5376 5411 static void
5377 5412 ztest_dataset_destroy(int d)
5378 5413 {
5379 5414 char name[MAXNAMELEN];
5380 5415
5381 5416 ztest_dataset_name(name, ztest_opts.zo_pool, d);
5382 5417
5383 5418 if (ztest_opts.zo_verbose >= 3)
5384 5419 (void) printf("Destroying %s to free up space\n", name);
5385 5420
5386 5421 /*
5387 5422 * Cleanup any non-standard clones and snapshots. In general,
5388 5423 * ztest thread t operates on dataset (t % zopt_datasets),
5389 5424 * so there may be more than one thing to clean up.
5390 5425 */
5391 5426 for (int t = d; t < ztest_opts.zo_threads;
5392 5427 t += ztest_opts.zo_datasets) {
5393 5428 ztest_dsl_dataset_cleanup(name, t);
5394 5429 }
5395 5430
5396 5431 (void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL,
5397 5432 DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
5398 5433 }
5399 5434
5400 5435 static void
5401 5436 ztest_dataset_dirobj_verify(ztest_ds_t *zd)
5402 5437 {
5403 5438 uint64_t usedobjs, dirobjs, scratch;
5404 5439
5405 5440 /*
5406 5441 * ZTEST_DIROBJ is the object directory for the entire dataset.
5407 5442 * Therefore, the number of objects in use should equal the
5408 5443 * number of ZTEST_DIROBJ entries, +1 for ZTEST_DIROBJ itself.
5409 5444 * If not, we have an object leak.
5410 5445 *
5411 5446 * Note that we can only check this in ztest_dataset_open(),
5412 5447 * when the open-context and syncing-context values agree.
5413 5448 * That's because zap_count() returns the open-context value,
5414 5449 * while dmu_objset_space() returns the rootbp fill count.
5415 5450 */
5416 5451 VERIFY3U(0, ==, zap_count(zd->zd_os, ZTEST_DIROBJ, &dirobjs));
5417 5452 dmu_objset_space(zd->zd_os, &scratch, &scratch, &usedobjs, &scratch);
5418 5453 ASSERT3U(dirobjs + 1, ==, usedobjs);
5419 5454 }
5420 5455
5421 5456 static int
5422 5457 ztest_dataset_open(int d)
5423 5458 {
5424 5459 ztest_ds_t *zd = &ztest_ds[d];
5425 5460 uint64_t committed_seq = ZTEST_GET_SHARED_DS(d)->zd_seq;
5426 5461 objset_t *os;
5427 5462 zilog_t *zilog;
5428 5463 char name[MAXNAMELEN];
5429 5464 int error;
5430 5465
5431 5466 ztest_dataset_name(name, ztest_opts.zo_pool, d);
5432 5467
5433 5468 (void) rw_rdlock(&ztest_name_lock);
5434 5469
5435 5470 error = ztest_dataset_create(name);
5436 5471 if (error == ENOSPC) {
5437 5472 (void) rw_unlock(&ztest_name_lock);
5438 5473 ztest_record_enospc(FTAG);
5439 5474 return (error);
5440 5475 }
5441 5476 ASSERT(error == 0 || error == EEXIST);
5442 5477
5443 5478 VERIFY0(dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, zd, &os));
5444 5479 (void) rw_unlock(&ztest_name_lock);
5445 5480
5446 5481 ztest_zd_init(zd, ZTEST_GET_SHARED_DS(d), os);
5447 5482
5448 5483 zilog = zd->zd_zilog;
5449 5484
5450 5485 if (zilog->zl_header->zh_claim_lr_seq != 0 &&
5451 5486 zilog->zl_header->zh_claim_lr_seq < committed_seq)
5452 5487 fatal(0, "missing log records: claimed %llu < committed %llu",
5453 5488 zilog->zl_header->zh_claim_lr_seq, committed_seq);
5454 5489
5455 5490 ztest_dataset_dirobj_verify(zd);
5456 5491
5457 5492 zil_replay(os, zd, ztest_replay_vector);
5458 5493
5459 5494 ztest_dataset_dirobj_verify(zd);
5460 5495
5461 5496 if (ztest_opts.zo_verbose >= 6)
5462 5497 (void) printf("%s replay %llu blocks, %llu records, seq %llu\n",
5463 5498 zd->zd_name,
5464 5499 (u_longlong_t)zilog->zl_parse_blk_count,
5465 5500 (u_longlong_t)zilog->zl_parse_lr_count,
5466 5501 (u_longlong_t)zilog->zl_replaying_seq);
5467 5502
5468 5503 zilog = zil_open(os, ztest_get_data);
5469 5504
5470 5505 if (zilog->zl_replaying_seq != 0 &&
5471 5506 zilog->zl_replaying_seq < committed_seq)
5472 5507 fatal(0, "missing log records: replayed %llu < committed %llu",
5473 5508 zilog->zl_replaying_seq, committed_seq);
5474 5509
5475 5510 return (0);
5476 5511 }
5477 5512
5478 5513 static void
5479 5514 ztest_dataset_close(int d)
5480 5515 {
5481 5516 ztest_ds_t *zd = &ztest_ds[d];
5482 5517
5483 5518 zil_close(zd->zd_zilog);
5484 5519 dmu_objset_disown(zd->zd_os, zd);
5485 5520
5486 5521 ztest_zd_fini(zd);
5487 5522 }
5488 5523
5489 5524 /*
5490 5525 * Kick off threads to run tests on all datasets in parallel.
5491 5526 */
5492 5527 static void
5493 5528 ztest_run(ztest_shared_t *zs)
5494 5529 {
5495 5530 thread_t *tid;
5496 5531 spa_t *spa;
5497 5532 objset_t *os;
5498 5533 thread_t resume_tid;
5499 5534 int error;
5500 5535
5501 5536 ztest_exiting = B_FALSE;
5502 5537
5503 5538 /*
5504 5539 * Initialize parent/child shared state.
5505 5540 */
5506 5541 VERIFY(_mutex_init(&ztest_vdev_lock, USYNC_THREAD, NULL) == 0);
5507 5542 VERIFY(rwlock_init(&ztest_name_lock, USYNC_THREAD, NULL) == 0);
5508 5543
5509 5544 zs->zs_thread_start = gethrtime();
5510 5545 zs->zs_thread_stop =
5511 5546 zs->zs_thread_start + ztest_opts.zo_passtime * NANOSEC;
5512 5547 zs->zs_thread_stop = MIN(zs->zs_thread_stop, zs->zs_proc_stop);
5513 5548 zs->zs_thread_kill = zs->zs_thread_stop;
5514 5549 if (ztest_random(100) < ztest_opts.zo_killrate) {
5515 5550 zs->zs_thread_kill -=
5516 5551 ztest_random(ztest_opts.zo_passtime * NANOSEC);
5517 5552 }
5518 5553
5519 5554 (void) _mutex_init(&zcl.zcl_callbacks_lock, USYNC_THREAD, NULL);
5520 5555
5521 5556 list_create(&zcl.zcl_callbacks, sizeof (ztest_cb_data_t),
5522 5557 offsetof(ztest_cb_data_t, zcd_node));
5523 5558
5524 5559 /*
5525 5560 * Open our pool.
5526 5561 */
5527 5562 kernel_init(FREAD | FWRITE);
5528 5563 VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
5529 5564 spa->spa_debug = B_TRUE;
5530 5565 ztest_spa = spa;
5531 5566
5532 5567 VERIFY0(dmu_objset_own(ztest_opts.zo_pool,
5533 5568 DMU_OST_ANY, B_TRUE, FTAG, &os));
5534 5569 zs->zs_guid = dmu_objset_fsid_guid(os);
5535 5570 dmu_objset_disown(os, FTAG);
5536 5571
5537 5572 spa->spa_dedup_ditto = 2 * ZIO_DEDUPDITTO_MIN;
5538 5573
5539 5574 /*
5540 5575 * We don't expect the pool to suspend unless maxfaults == 0,
5541 5576 * in which case ztest_fault_inject() temporarily takes away
5542 5577 * the only valid replica.
5543 5578 */
5544 5579 if (MAXFAULTS() == 0)
5545 5580 spa->spa_failmode = ZIO_FAILURE_MODE_WAIT;
5546 5581 else
5547 5582 spa->spa_failmode = ZIO_FAILURE_MODE_PANIC;
5548 5583
5549 5584 /*
5550 5585 * Create a thread to periodically resume suspended I/O.
5551 5586 */
5552 5587 VERIFY(thr_create(0, 0, ztest_resume_thread, spa, THR_BOUND,
5553 5588 &resume_tid) == 0);
5554 5589
5555 5590 /*
5556 5591 * Create a deadman thread to abort() if we hang.
5557 5592 */
5558 5593 VERIFY(thr_create(0, 0, ztest_deadman_thread, zs, THR_BOUND,
5559 5594 NULL) == 0);
5560 5595
5561 5596 /*
5562 5597 * Verify that we can safely inquire about about any object,
5563 5598 * whether it's allocated or not. To make it interesting,
5564 5599 * we probe a 5-wide window around each power of two.
5565 5600 * This hits all edge cases, including zero and the max.
5566 5601 */
5567 5602 for (int t = 0; t < 64; t++) {
5568 5603 for (int d = -5; d <= 5; d++) {
5569 5604 error = dmu_object_info(spa->spa_meta_objset,
5570 5605 (1ULL << t) + d, NULL);
5571 5606 ASSERT(error == 0 || error == ENOENT ||
5572 5607 error == EINVAL);
5573 5608 }
5574 5609 }
5575 5610
5576 5611 /*
5577 5612 * If we got any ENOSPC errors on the previous run, destroy something.
5578 5613 */
5579 5614 if (zs->zs_enospc_count != 0) {
5580 5615 int d = ztest_random(ztest_opts.zo_datasets);
5581 5616 ztest_dataset_destroy(d);
5582 5617 }
5583 5618 zs->zs_enospc_count = 0;
5584 5619
5585 5620 tid = umem_zalloc(ztest_opts.zo_threads * sizeof (thread_t),
5586 5621 UMEM_NOFAIL);
5587 5622
5588 5623 if (ztest_opts.zo_verbose >= 4)
5589 5624 (void) printf("starting main threads...\n");
5590 5625
5591 5626 /*
5592 5627 * Kick off all the tests that run in parallel.
5593 5628 */
5594 5629 for (int t = 0; t < ztest_opts.zo_threads; t++) {
5595 5630 if (t < ztest_opts.zo_datasets &&
5596 5631 ztest_dataset_open(t) != 0)
5597 5632 return;
5598 5633 VERIFY(thr_create(0, 0, ztest_thread, (void *)(uintptr_t)t,
5599 5634 THR_BOUND, &tid[t]) == 0);
5600 5635 }
5601 5636
5602 5637 /*
5603 5638 * Wait for all of the tests to complete. We go in reverse order
5604 5639 * so we don't close datasets while threads are still using them.
5605 5640 */
5606 5641 for (int t = ztest_opts.zo_threads - 1; t >= 0; t--) {
5607 5642 VERIFY(thr_join(tid[t], NULL, NULL) == 0);
5608 5643 if (t < ztest_opts.zo_datasets)
5609 5644 ztest_dataset_close(t);
5610 5645 }
5611 5646
5612 5647 txg_wait_synced(spa_get_dsl(spa), 0);
5613 5648
5614 5649 zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
5615 5650 zs->zs_space = metaslab_class_get_space(spa_normal_class(spa));
5616 5651
5617 5652 umem_free(tid, ztest_opts.zo_threads * sizeof (thread_t));
5618 5653
5619 5654 /* Kill the resume thread */
5620 5655 ztest_exiting = B_TRUE;
5621 5656 VERIFY(thr_join(resume_tid, NULL, NULL) == 0);
5622 5657 ztest_resume(spa);
5623 5658
5624 5659 /*
5625 5660 * Right before closing the pool, kick off a bunch of async I/O;
5626 5661 * spa_close() should wait for it to complete.
5627 5662 */
5628 5663 for (uint64_t object = 1; object < 50; object++)
5629 5664 dmu_prefetch(spa->spa_meta_objset, object, 0, 1ULL << 20);
5630 5665
5631 5666 spa_close(spa, FTAG);
5632 5667
5633 5668 /*
5634 5669 * Verify that we can loop over all pools.
5635 5670 */
5636 5671 mutex_enter(&spa_namespace_lock);
5637 5672 for (spa = spa_next(NULL); spa != NULL; spa = spa_next(spa))
5638 5673 if (ztest_opts.zo_verbose > 3)
5639 5674 (void) printf("spa_next: found %s\n", spa_name(spa));
5640 5675 mutex_exit(&spa_namespace_lock);
5641 5676
5642 5677 /*
5643 5678 * Verify that we can export the pool and reimport it under a
5644 5679 * different name.
5645 5680 */
5646 5681 if (ztest_random(2) == 0) {
5647 5682 char name[MAXNAMELEN];
5648 5683 (void) snprintf(name, MAXNAMELEN, "%s_import",
5649 5684 ztest_opts.zo_pool);
5650 5685 ztest_spa_import_export(ztest_opts.zo_pool, name);
5651 5686 ztest_spa_import_export(name, ztest_opts.zo_pool);
5652 5687 }
5653 5688
5654 5689 kernel_fini();
5655 5690
5656 5691 list_destroy(&zcl.zcl_callbacks);
5657 5692
5658 5693 (void) _mutex_destroy(&zcl.zcl_callbacks_lock);
5659 5694
5660 5695 (void) rwlock_destroy(&ztest_name_lock);
5661 5696 (void) _mutex_destroy(&ztest_vdev_lock);
5662 5697 }
5663 5698
5664 5699 static void
5665 5700 ztest_freeze(void)
5666 5701 {
5667 5702 ztest_ds_t *zd = &ztest_ds[0];
5668 5703 spa_t *spa;
5669 5704 int numloops = 0;
5670 5705
5671 5706 if (ztest_opts.zo_verbose >= 3)
5672 5707 (void) printf("testing spa_freeze()...\n");
5673 5708
5674 5709 kernel_init(FREAD | FWRITE);
5675 5710 VERIFY3U(0, ==, spa_open(ztest_opts.zo_pool, &spa, FTAG));
5676 5711 VERIFY3U(0, ==, ztest_dataset_open(0));
5677 5712 spa->spa_debug = B_TRUE;
5678 5713 ztest_spa = spa;
5679 5714
5680 5715 /*
5681 5716 * Force the first log block to be transactionally allocated.
5682 5717 * We have to do this before we freeze the pool -- otherwise
5683 5718 * the log chain won't be anchored.
5684 5719 */
5685 5720 while (BP_IS_HOLE(&zd->zd_zilog->zl_header->zh_log)) {
5686 5721 ztest_dmu_object_alloc_free(zd, 0);
5687 5722 zil_commit(zd->zd_zilog, 0);
5688 5723 }
5689 5724
5690 5725 txg_wait_synced(spa_get_dsl(spa), 0);
5691 5726
5692 5727 /*
5693 5728 * Freeze the pool. This stops spa_sync() from doing anything,
5694 5729 * so that the only way to record changes from now on is the ZIL.
5695 5730 */
5696 5731 spa_freeze(spa);
5697 5732
5698 5733 /*
5699 5734 * Run tests that generate log records but don't alter the pool config
5700 5735 * or depend on DSL sync tasks (snapshots, objset create/destroy, etc).
5701 5736 * We do a txg_wait_synced() after each iteration to force the txg
5702 5737 * to increase well beyond the last synced value in the uberblock.
5703 5738 * The ZIL should be OK with that.
5704 5739 */
5705 5740 while (ztest_random(10) != 0 &&
5706 5741 numloops++ < ztest_opts.zo_maxloops) {
5707 5742 ztest_dmu_write_parallel(zd, 0);
5708 5743 ztest_dmu_object_alloc_free(zd, 0);
5709 5744 txg_wait_synced(spa_get_dsl(spa), 0);
5710 5745 }
5711 5746
5712 5747 /*
5713 5748 * Commit all of the changes we just generated.
5714 5749 */
5715 5750 zil_commit(zd->zd_zilog, 0);
5716 5751 txg_wait_synced(spa_get_dsl(spa), 0);
5717 5752
5718 5753 /*
5719 5754 * Close our dataset and close the pool.
5720 5755 */
5721 5756 ztest_dataset_close(0);
5722 5757 spa_close(spa, FTAG);
5723 5758 kernel_fini();
5724 5759
5725 5760 /*
5726 5761 * Open and close the pool and dataset to induce log replay.
5727 5762 */
5728 5763 kernel_init(FREAD | FWRITE);
5729 5764 VERIFY3U(0, ==, spa_open(ztest_opts.zo_pool, &spa, FTAG));
5730 5765 ASSERT(spa_freeze_txg(spa) == UINT64_MAX);
5731 5766 VERIFY3U(0, ==, ztest_dataset_open(0));
5732 5767 ztest_dataset_close(0);
5733 5768
5734 5769 spa->spa_debug = B_TRUE;
5735 5770 ztest_spa = spa;
5736 5771 txg_wait_synced(spa_get_dsl(spa), 0);
5737 5772 ztest_reguid(NULL, 0);
5738 5773
5739 5774 spa_close(spa, FTAG);
5740 5775 kernel_fini();
5741 5776 }
5742 5777
5743 5778 void
5744 5779 print_time(hrtime_t t, char *timebuf)
5745 5780 {
5746 5781 hrtime_t s = t / NANOSEC;
5747 5782 hrtime_t m = s / 60;
5748 5783 hrtime_t h = m / 60;
5749 5784 hrtime_t d = h / 24;
5750 5785
5751 5786 s -= m * 60;
5752 5787 m -= h * 60;
5753 5788 h -= d * 24;
5754 5789
5755 5790 timebuf[0] = '\0';
5756 5791
5757 5792 if (d)
5758 5793 (void) sprintf(timebuf,
5759 5794 "%llud%02lluh%02llum%02llus", d, h, m, s);
5760 5795 else if (h)
5761 5796 (void) sprintf(timebuf, "%lluh%02llum%02llus", h, m, s);
5762 5797 else if (m)
5763 5798 (void) sprintf(timebuf, "%llum%02llus", m, s);
5764 5799 else
5765 5800 (void) sprintf(timebuf, "%llus", s);
5766 5801 }
5767 5802
5768 5803 static nvlist_t *
5769 5804 make_random_props()
5770 5805 {
5771 5806 nvlist_t *props;
5772 5807
5773 5808 VERIFY(nvlist_alloc(&props, NV_UNIQUE_NAME, 0) == 0);
5774 5809 if (ztest_random(2) == 0)
5775 5810 return (props);
5776 5811 VERIFY(nvlist_add_uint64(props, "autoreplace", 1) == 0);
5777 5812
5778 5813 return (props);
5779 5814 }
5780 5815
5781 5816 /*
5782 5817 * Create a storage pool with the given name and initial vdev size.
5783 5818 * Then test spa_freeze() functionality.
5784 5819 */
5785 5820 static void
5786 5821 ztest_init(ztest_shared_t *zs)
5787 5822 {
5788 5823 spa_t *spa;
5789 5824 nvlist_t *nvroot, *props;
5790 5825
5791 5826 VERIFY(_mutex_init(&ztest_vdev_lock, USYNC_THREAD, NULL) == 0);
5792 5827 VERIFY(rwlock_init(&ztest_name_lock, USYNC_THREAD, NULL) == 0);
5793 5828
5794 5829 kernel_init(FREAD | FWRITE);
5795 5830
5796 5831 /*
5797 5832 * Create the storage pool.
5798 5833 */
5799 5834 (void) spa_destroy(ztest_opts.zo_pool);
5800 5835 ztest_shared->zs_vdev_next_leaf = 0;
5801 5836 zs->zs_splits = 0;
5802 5837 zs->zs_mirrors = ztest_opts.zo_mirrors;
5803 5838 nvroot = make_vdev_root(NULL, NULL, NULL, ztest_opts.zo_vdev_size, 0,
5804 5839 0, ztest_opts.zo_raidz, zs->zs_mirrors, 1);
5805 5840 props = make_random_props();
5806 5841 for (int i = 0; i < SPA_FEATURES; i++) {
5807 5842 char buf[1024];
5808 5843 (void) snprintf(buf, sizeof (buf), "feature@%s",
5809 5844 spa_feature_table[i].fi_uname);
5810 5845 VERIFY3U(0, ==, nvlist_add_uint64(props, buf, 0));
5811 5846 }
5812 5847 VERIFY3U(0, ==, spa_create(ztest_opts.zo_pool, nvroot, props, NULL));
5813 5848 nvlist_free(nvroot);
5814 5849
5815 5850 VERIFY3U(0, ==, spa_open(ztest_opts.zo_pool, &spa, FTAG));
5816 5851 zs->zs_metaslab_sz =
5817 5852 1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
5818 5853
5819 5854 spa_close(spa, FTAG);
5820 5855
5821 5856 kernel_fini();
5822 5857
5823 5858 ztest_run_zdb(ztest_opts.zo_pool);
5824 5859
5825 5860 ztest_freeze();
5826 5861
5827 5862 ztest_run_zdb(ztest_opts.zo_pool);
5828 5863
5829 5864 (void) rwlock_destroy(&ztest_name_lock);
5830 5865 (void) _mutex_destroy(&ztest_vdev_lock);
5831 5866 }
5832 5867
5833 5868 static void
5834 5869 setup_data_fd(void)
5835 5870 {
5836 5871 static char ztest_name_data[] = "/tmp/ztest.data.XXXXXX";
5837 5872
5838 5873 ztest_fd_data = mkstemp(ztest_name_data);
5839 5874 ASSERT3S(ztest_fd_data, >=, 0);
5840 5875 (void) unlink(ztest_name_data);
5841 5876 }
5842 5877
5843 5878
5844 5879 static int
5845 5880 shared_data_size(ztest_shared_hdr_t *hdr)
5846 5881 {
5847 5882 int size;
5848 5883
5849 5884 size = hdr->zh_hdr_size;
5850 5885 size += hdr->zh_opts_size;
5851 5886 size += hdr->zh_size;
5852 5887 size += hdr->zh_stats_size * hdr->zh_stats_count;
5853 5888 size += hdr->zh_ds_size * hdr->zh_ds_count;
5854 5889
5855 5890 return (size);
5856 5891 }
5857 5892
5858 5893 static void
5859 5894 setup_hdr(void)
5860 5895 {
5861 5896 int size;
5862 5897 ztest_shared_hdr_t *hdr;
5863 5898
5864 5899 hdr = (void *)mmap(0, P2ROUNDUP(sizeof (*hdr), getpagesize()),
5865 5900 PROT_READ | PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
5866 5901 ASSERT(hdr != MAP_FAILED);
5867 5902
5868 5903 VERIFY3U(0, ==, ftruncate(ztest_fd_data, sizeof (ztest_shared_hdr_t)));
5869 5904
5870 5905 hdr->zh_hdr_size = sizeof (ztest_shared_hdr_t);
5871 5906 hdr->zh_opts_size = sizeof (ztest_shared_opts_t);
5872 5907 hdr->zh_size = sizeof (ztest_shared_t);
5873 5908 hdr->zh_stats_size = sizeof (ztest_shared_callstate_t);
5874 5909 hdr->zh_stats_count = ZTEST_FUNCS;
5875 5910 hdr->zh_ds_size = sizeof (ztest_shared_ds_t);
5876 5911 hdr->zh_ds_count = ztest_opts.zo_datasets;
5877 5912
5878 5913 size = shared_data_size(hdr);
5879 5914 VERIFY3U(0, ==, ftruncate(ztest_fd_data, size));
5880 5915
5881 5916 (void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
5882 5917 }
5883 5918
5884 5919 static void
5885 5920 setup_data(void)
5886 5921 {
5887 5922 int size, offset;
5888 5923 ztest_shared_hdr_t *hdr;
5889 5924 uint8_t *buf;
5890 5925
5891 5926 hdr = (void *)mmap(0, P2ROUNDUP(sizeof (*hdr), getpagesize()),
5892 5927 PROT_READ, MAP_SHARED, ztest_fd_data, 0);
5893 5928 ASSERT(hdr != MAP_FAILED);
5894 5929
5895 5930 size = shared_data_size(hdr);
5896 5931
5897 5932 (void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
5898 5933 hdr = ztest_shared_hdr = (void *)mmap(0, P2ROUNDUP(size, getpagesize()),
5899 5934 PROT_READ | PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
5900 5935 ASSERT(hdr != MAP_FAILED);
5901 5936 buf = (uint8_t *)hdr;
5902 5937
5903 5938 offset = hdr->zh_hdr_size;
5904 5939 ztest_shared_opts = (void *)&buf[offset];
5905 5940 offset += hdr->zh_opts_size;
5906 5941 ztest_shared = (void *)&buf[offset];
5907 5942 offset += hdr->zh_size;
5908 5943 ztest_shared_callstate = (void *)&buf[offset];
5909 5944 offset += hdr->zh_stats_size * hdr->zh_stats_count;
5910 5945 ztest_shared_ds = (void *)&buf[offset];
5911 5946 }
5912 5947
5913 5948 static boolean_t
5914 5949 exec_child(char *cmd, char *libpath, boolean_t ignorekill, int *statusp)
5915 5950 {
5916 5951 pid_t pid;
5917 5952 int status;
5918 5953 char *cmdbuf = NULL;
5919 5954
5920 5955 pid = fork();
5921 5956
5922 5957 if (cmd == NULL) {
5923 5958 cmdbuf = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
5924 5959 (void) strlcpy(cmdbuf, getexecname(), MAXPATHLEN);
5925 5960 cmd = cmdbuf;
5926 5961 }
5927 5962
5928 5963 if (pid == -1)
5929 5964 fatal(1, "fork failed");
5930 5965
5931 5966 if (pid == 0) { /* child */
5932 5967 char *emptyargv[2] = { cmd, NULL };
5933 5968 char fd_data_str[12];
5934 5969
5935 5970 struct rlimit rl = { 1024, 1024 };
5936 5971 (void) setrlimit(RLIMIT_NOFILE, &rl);
5937 5972
5938 5973 (void) close(ztest_fd_rand);
5939 5974 VERIFY3U(11, >=,
5940 5975 snprintf(fd_data_str, 12, "%d", ztest_fd_data));
5941 5976 VERIFY0(setenv("ZTEST_FD_DATA", fd_data_str, 1));
5942 5977
5943 5978 (void) enable_extended_FILE_stdio(-1, -1);
5944 5979 if (libpath != NULL)
5945 5980 VERIFY(0 == setenv("LD_LIBRARY_PATH", libpath, 1));
5946 5981 (void) execv(cmd, emptyargv);
5947 5982 ztest_dump_core = B_FALSE;
5948 5983 fatal(B_TRUE, "exec failed: %s", cmd);
5949 5984 }
5950 5985
5951 5986 if (cmdbuf != NULL) {
5952 5987 umem_free(cmdbuf, MAXPATHLEN);
5953 5988 cmd = NULL;
5954 5989 }
5955 5990
5956 5991 while (waitpid(pid, &status, 0) != pid)
5957 5992 continue;
5958 5993 if (statusp != NULL)
5959 5994 *statusp = status;
5960 5995
5961 5996 if (WIFEXITED(status)) {
5962 5997 if (WEXITSTATUS(status) != 0) {
5963 5998 (void) fprintf(stderr, "child exited with code %d\n",
5964 5999 WEXITSTATUS(status));
5965 6000 exit(2);
5966 6001 }
5967 6002 return (B_FALSE);
5968 6003 } else if (WIFSIGNALED(status)) {
5969 6004 if (!ignorekill || WTERMSIG(status) != SIGKILL) {
5970 6005 (void) fprintf(stderr, "child died with signal %d\n",
5971 6006 WTERMSIG(status));
5972 6007 exit(3);
5973 6008 }
5974 6009 return (B_TRUE);
5975 6010 } else {
5976 6011 (void) fprintf(stderr, "something strange happened to child\n");
5977 6012 exit(4);
5978 6013 /* NOTREACHED */
5979 6014 }
5980 6015 }
5981 6016
5982 6017 static void
5983 6018 ztest_run_init(void)
5984 6019 {
5985 6020 ztest_shared_t *zs = ztest_shared;
5986 6021
5987 6022 ASSERT(ztest_opts.zo_init != 0);
5988 6023
5989 6024 /*
5990 6025 * Blow away any existing copy of zpool.cache
5991 6026 */
5992 6027 (void) remove(spa_config_path);
5993 6028
5994 6029 /*
5995 6030 * Create and initialize our storage pool.
5996 6031 */
5997 6032 for (int i = 1; i <= ztest_opts.zo_init; i++) {
5998 6033 bzero(zs, sizeof (ztest_shared_t));
5999 6034 if (ztest_opts.zo_verbose >= 3 &&
6000 6035 ztest_opts.zo_init != 1) {
6001 6036 (void) printf("ztest_init(), pass %d\n", i);
6002 6037 }
6003 6038 ztest_init(zs);
6004 6039 }
6005 6040 }
6006 6041
6007 6042 int
6008 6043 main(int argc, char **argv)
6009 6044 {
6010 6045 int kills = 0;
6011 6046 int iters = 0;
6012 6047 int older = 0;
6013 6048 int newer = 0;
6014 6049 ztest_shared_t *zs;
6015 6050 ztest_info_t *zi;
6016 6051 ztest_shared_callstate_t *zc;
|
↓ open down ↓ |
704 lines elided |
↑ open up ↑ |
6017 6052 char timebuf[100];
6018 6053 char numbuf[6];
6019 6054 spa_t *spa;
6020 6055 char *cmd;
6021 6056 boolean_t hasalt;
6022 6057 char *fd_data_str = getenv("ZTEST_FD_DATA");
6023 6058
6024 6059 (void) setvbuf(stdout, NULL, _IOLBF, 0);
6025 6060
6026 6061 dprintf_setup(&argc, argv);
6062 + zfs_deadman_synctime = 300;
6027 6063
6028 6064 ztest_fd_rand = open("/dev/urandom", O_RDONLY);
6029 6065 ASSERT3S(ztest_fd_rand, >=, 0);
6030 6066
6031 6067 if (!fd_data_str) {
6032 6068 process_options(argc, argv);
6033 6069
6034 6070 setup_data_fd();
6035 6071 setup_hdr();
6036 6072 setup_data();
6037 6073 bcopy(&ztest_opts, ztest_shared_opts,
6038 6074 sizeof (*ztest_shared_opts));
6039 6075 } else {
6040 6076 ztest_fd_data = atoi(fd_data_str);
6041 6077 setup_data();
6042 6078 bcopy(ztest_shared_opts, &ztest_opts, sizeof (ztest_opts));
6043 6079 }
6044 6080 ASSERT3U(ztest_opts.zo_datasets, ==, ztest_shared_hdr->zh_ds_count);
6045 6081
6046 6082 /* Override location of zpool.cache */
6047 6083 VERIFY3U(asprintf((char **)&spa_config_path, "%s/zpool.cache",
6048 6084 ztest_opts.zo_dir), !=, -1);
6049 6085
6050 6086 ztest_ds = umem_alloc(ztest_opts.zo_datasets * sizeof (ztest_ds_t),
6051 6087 UMEM_NOFAIL);
6052 6088 zs = ztest_shared;
6053 6089
6054 6090 if (fd_data_str) {
6055 6091 metaslab_gang_bang = ztest_opts.zo_metaslab_gang_bang;
6056 6092 metaslab_df_alloc_threshold =
6057 6093 zs->zs_metaslab_df_alloc_threshold;
6058 6094
6059 6095 if (zs->zs_do_init)
6060 6096 ztest_run_init();
6061 6097 else
6062 6098 ztest_run(zs);
6063 6099 exit(0);
6064 6100 }
6065 6101
6066 6102 hasalt = (strlen(ztest_opts.zo_alt_ztest) != 0);
6067 6103
6068 6104 if (ztest_opts.zo_verbose >= 1) {
6069 6105 (void) printf("%llu vdevs, %d datasets, %d threads,"
6070 6106 " %llu seconds...\n",
6071 6107 (u_longlong_t)ztest_opts.zo_vdevs,
6072 6108 ztest_opts.zo_datasets,
6073 6109 ztest_opts.zo_threads,
6074 6110 (u_longlong_t)ztest_opts.zo_time);
6075 6111 }
6076 6112
6077 6113 cmd = umem_alloc(MAXNAMELEN, UMEM_NOFAIL);
6078 6114 (void) strlcpy(cmd, getexecname(), MAXNAMELEN);
6079 6115
6080 6116 zs->zs_do_init = B_TRUE;
6081 6117 if (strlen(ztest_opts.zo_alt_ztest) != 0) {
6082 6118 if (ztest_opts.zo_verbose >= 1) {
6083 6119 (void) printf("Executing older ztest for "
6084 6120 "initialization: %s\n", ztest_opts.zo_alt_ztest);
6085 6121 }
6086 6122 VERIFY(!exec_child(ztest_opts.zo_alt_ztest,
6087 6123 ztest_opts.zo_alt_libpath, B_FALSE, NULL));
6088 6124 } else {
6089 6125 VERIFY(!exec_child(NULL, NULL, B_FALSE, NULL));
6090 6126 }
6091 6127 zs->zs_do_init = B_FALSE;
6092 6128
6093 6129 zs->zs_proc_start = gethrtime();
6094 6130 zs->zs_proc_stop = zs->zs_proc_start + ztest_opts.zo_time * NANOSEC;
6095 6131
6096 6132 for (int f = 0; f < ZTEST_FUNCS; f++) {
6097 6133 zi = &ztest_info[f];
6098 6134 zc = ZTEST_GET_SHARED_CALLSTATE(f);
6099 6135 if (zs->zs_proc_start + zi->zi_interval[0] > zs->zs_proc_stop)
6100 6136 zc->zc_next = UINT64_MAX;
6101 6137 else
6102 6138 zc->zc_next = zs->zs_proc_start +
6103 6139 ztest_random(2 * zi->zi_interval[0] + 1);
6104 6140 }
6105 6141
6106 6142 /*
6107 6143 * Run the tests in a loop. These tests include fault injection
6108 6144 * to verify that self-healing data works, and forced crashes
6109 6145 * to verify that we never lose on-disk consistency.
6110 6146 */
6111 6147 while (gethrtime() < zs->zs_proc_stop) {
6112 6148 int status;
6113 6149 boolean_t killed;
6114 6150
6115 6151 /*
6116 6152 * Initialize the workload counters for each function.
6117 6153 */
6118 6154 for (int f = 0; f < ZTEST_FUNCS; f++) {
6119 6155 zc = ZTEST_GET_SHARED_CALLSTATE(f);
6120 6156 zc->zc_count = 0;
6121 6157 zc->zc_time = 0;
6122 6158 }
6123 6159
6124 6160 /* Set the allocation switch size */
6125 6161 zs->zs_metaslab_df_alloc_threshold =
6126 6162 ztest_random(zs->zs_metaslab_sz / 4) + 1;
6127 6163
6128 6164 if (!hasalt || ztest_random(2) == 0) {
6129 6165 if (hasalt && ztest_opts.zo_verbose >= 1) {
6130 6166 (void) printf("Executing newer ztest: %s\n",
6131 6167 cmd);
6132 6168 }
6133 6169 newer++;
6134 6170 killed = exec_child(cmd, NULL, B_TRUE, &status);
6135 6171 } else {
6136 6172 if (hasalt && ztest_opts.zo_verbose >= 1) {
6137 6173 (void) printf("Executing older ztest: %s\n",
6138 6174 ztest_opts.zo_alt_ztest);
6139 6175 }
6140 6176 older++;
6141 6177 killed = exec_child(ztest_opts.zo_alt_ztest,
6142 6178 ztest_opts.zo_alt_libpath, B_TRUE, &status);
6143 6179 }
6144 6180
6145 6181 if (killed)
6146 6182 kills++;
6147 6183 iters++;
6148 6184
6149 6185 if (ztest_opts.zo_verbose >= 1) {
6150 6186 hrtime_t now = gethrtime();
6151 6187
6152 6188 now = MIN(now, zs->zs_proc_stop);
6153 6189 print_time(zs->zs_proc_stop - now, timebuf);
6154 6190 nicenum(zs->zs_space, numbuf);
6155 6191
6156 6192 (void) printf("Pass %3d, %8s, %3llu ENOSPC, "
6157 6193 "%4.1f%% of %5s used, %3.0f%% done, %8s to go\n",
6158 6194 iters,
6159 6195 WIFEXITED(status) ? "Complete" : "SIGKILL",
6160 6196 (u_longlong_t)zs->zs_enospc_count,
6161 6197 100.0 * zs->zs_alloc / zs->zs_space,
6162 6198 numbuf,
6163 6199 100.0 * (now - zs->zs_proc_start) /
6164 6200 (ztest_opts.zo_time * NANOSEC), timebuf);
6165 6201 }
6166 6202
6167 6203 if (ztest_opts.zo_verbose >= 2) {
6168 6204 (void) printf("\nWorkload summary:\n\n");
6169 6205 (void) printf("%7s %9s %s\n",
6170 6206 "Calls", "Time", "Function");
6171 6207 (void) printf("%7s %9s %s\n",
6172 6208 "-----", "----", "--------");
6173 6209 for (int f = 0; f < ZTEST_FUNCS; f++) {
6174 6210 Dl_info dli;
6175 6211
6176 6212 zi = &ztest_info[f];
6177 6213 zc = ZTEST_GET_SHARED_CALLSTATE(f);
6178 6214 print_time(zc->zc_time, timebuf);
6179 6215 (void) dladdr((void *)zi->zi_func, &dli);
6180 6216 (void) printf("%7llu %9s %s\n",
6181 6217 (u_longlong_t)zc->zc_count, timebuf,
6182 6218 dli.dli_sname);
6183 6219 }
6184 6220 (void) printf("\n");
6185 6221 }
6186 6222
6187 6223 /*
6188 6224 * It's possible that we killed a child during a rename test,
6189 6225 * in which case we'll have a 'ztest_tmp' pool lying around
6190 6226 * instead of 'ztest'. Do a blind rename in case this happened.
6191 6227 */
6192 6228 kernel_init(FREAD);
6193 6229 if (spa_open(ztest_opts.zo_pool, &spa, FTAG) == 0) {
6194 6230 spa_close(spa, FTAG);
6195 6231 } else {
6196 6232 char tmpname[MAXNAMELEN];
6197 6233 kernel_fini();
6198 6234 kernel_init(FREAD | FWRITE);
6199 6235 (void) snprintf(tmpname, sizeof (tmpname), "%s_tmp",
6200 6236 ztest_opts.zo_pool);
6201 6237 (void) spa_rename(tmpname, ztest_opts.zo_pool);
6202 6238 }
6203 6239 kernel_fini();
6204 6240
6205 6241 ztest_run_zdb(ztest_opts.zo_pool);
6206 6242 }
6207 6243
6208 6244 if (ztest_opts.zo_verbose >= 1) {
6209 6245 if (hasalt) {
6210 6246 (void) printf("%d runs of older ztest: %s\n", older,
6211 6247 ztest_opts.zo_alt_ztest);
6212 6248 (void) printf("%d runs of newer ztest: %s\n", newer,
6213 6249 cmd);
6214 6250 }
6215 6251 (void) printf("%d killed, %d completed, %.0f%% kill rate\n",
6216 6252 kills, iters - kills, (100.0 * kills) / MAX(1, iters));
6217 6253 }
6218 6254
6219 6255 umem_free(cmd, MAXNAMELEN);
6220 6256
6221 6257 return (0);
6222 6258 }
|
↓ open down ↓ |
186 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX