ztest.c revision c5904d138f3bdf0762dbf452a43d5a5c387ea6a8
fa9e4066f08beec538e775443c5be79dd423fcabahrens * CDDL HEADER START
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The contents of this file are subject to the terms of the
441d80aa4f613b6298fc8bd3151f4be02dbf84fclling * Common Development and Distribution License (the "License").
441d80aa4f613b6298fc8bd3151f4be02dbf84fclling * You may not use this file except in compliance with the License.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
fa9e4066f08beec538e775443c5be79dd423fcabahrens * See the License for the specific language governing permissions
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and limitations under the License.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * When distributing Covered Code, include this CDDL HEADER in each
fa9e4066f08beec538e775443c5be79dd423fcabahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If applicable, add the following below this CDDL HEADER, with the
fa9e4066f08beec538e775443c5be79dd423fcabahrens * fields enclosed by brackets "[]" replaced with your own identifying
fa9e4066f08beec538e775443c5be79dd423fcabahrens * information: Portions Copyright [yyyy] [name of copyright owner]
fa9e4066f08beec538e775443c5be79dd423fcabahrens * CDDL HEADER END
3a57275a335306e90136ebd00a4689fe0ee72519ck * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Use is subject to license terms.
fa9e4066f08beec538e775443c5be79dd423fcabahrens#pragma ident "%Z%%M% %I% %E% SMI"
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The objective of this program is to provide a DMU/ZAP/SPA stress test
fa9e4066f08beec538e775443c5be79dd423fcabahrens * that runs entirely in userland, is easy to use, and easy to extend.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The overall design of the ztest program is as follows:
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (1) For each major functional area (e.g. adding vdevs to a pool,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * creating and destroying datasets, reading and writing objects, etc)
fa9e4066f08beec538e775443c5be79dd423fcabahrens * we have a simple routine to test that functionality. These
fa9e4066f08beec538e775443c5be79dd423fcabahrens * individual routines do not have to do anything "stressful".
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (2) We turn these simple functionality tests into a stress test by
fa9e4066f08beec538e775443c5be79dd423fcabahrens * running them all in parallel, with as many threads as desired,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and spread across as many datasets, objects, and vdevs as desired.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (3) While all this is happening, we inject faults into the pool to
fa9e4066f08beec538e775443c5be79dd423fcabahrens * verify that self-healing data really works.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (4) Every time we open a dataset, we change its checksum and compression
fa9e4066f08beec538e775443c5be79dd423fcabahrens * functions. Thus even individual objects vary from block to block
fa9e4066f08beec538e775443c5be79dd423fcabahrens * in which checksum they use and whether they're compressed.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (5) To verify that we never lose on-disk consistency after a crash,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * we run the entire test in a child of the main process.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * At random times, the child self-immolates with a SIGKILL.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * This is the software equivalent of pulling the power cord.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The parent then runs the test again, using the existing
fa9e4066f08beec538e775443c5be79dd423fcabahrens * storage pool, as many times as desired.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (6) To verify that we don't have future leaks or temporal incursions,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * many of the functional tests record the transaction group number
fa9e4066f08beec538e775443c5be79dd423fcabahrens * as part of their data. When reading old data, they verify that
fa9e4066f08beec538e775443c5be79dd423fcabahrens * the transaction group number is less than the current, open txg.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If you add a new test, please do this if applicable.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * When run with no arguments, ztest runs for about five minutes and
fa9e4066f08beec538e775443c5be79dd423fcabahrens * produces no output if successful. To get a little bit of information,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * specify -V. To get more information, specify -VV, and so on.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * To turn this into an overnight stress test, use -T to specify run time.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * You can ask more more vdevs [-v], datasets [-d], or threads [-t]
fa9e4066f08beec538e775443c5be79dd423fcabahrens * to increase the pool capacity, fanout, and overall stress level.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The -N(okill) option will suppress kills, so each child runs to completion.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * This can be useful when you're trying to distinguish temporal incursions
fa9e4066f08beec538e775443c5be79dd423fcabahrens * from plain old race conditions.
fa9e4066f08beec538e775443c5be79dd423fcabahrensstatic uint64_t zopt_killrate = 70; /* 70% kill rate */
fa9e4066f08beec538e775443c5be79dd423fcabahrensstatic int zopt_verbose = 0;
e05725b117836db173257fae43fb0746eb857fb5bonwicktypedef struct ztest_block_tag {
fa9e4066f08beec538e775443c5be79dd423fcabahrenstypedef struct ztest_args {
e05725b117836db173257fae43fb0746eb857fb5bonwick * Thread-local variables can go here to aid debugging.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Note: these aren't static because we want dladdr() to work.
fa9e4066f08beec538e775443c5be79dd423fcabahrenstypedef struct ztest_info {
fa9e4066f08beec538e775443c5be79dd423fcabahrens uint64_t *zi_interval; /* execute every <interval> seconds */
fa9e4066f08beec538e775443c5be79dd423fcabahrens uint64_t zi_call_target; /* target cumulative total */
e05725b117836db173257fae43fb0746eb857fb5bonwick { ztest_dmu_objset_create_destroy, 1, &zopt_sometimes },
e05725b117836db173257fae43fb0746eb857fb5bonwick { ztest_dmu_snapshot_create_destroy, 1, &zopt_rarely },
fa9e4066f08beec538e775443c5be79dd423fcabahrens#define ZTEST_FUNCS (sizeof (ztest_info) / sizeof (ztest_info_t))
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Stuff we need to share writably between parent and child.
fa9e4066f08beec538e775443c5be79dd423fcabahrenstypedef struct ztest_shared {
fa9e4066f08beec538e775443c5be79dd423fcabahrens * These libumem hooks provide a reasonable set of defaults for the allocator's
fa9e4066f08beec538e775443c5be79dd423fcabahrens * debugging facilities.
fa9e4066f08beec538e775443c5be79dd423fcabahrensconst char *
fa9e4066f08beec538e775443c5be79dd423fcabahrens return ("default,verbose"); /* $UMEM_DEBUG setting */
fa9e4066f08beec538e775443c5be79dd423fcabahrensconst char *
fa9e4066f08beec538e775443c5be79dd423fcabahrens return ("fail,contents"); /* $UMEM_LOGGING setting */
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* LINTED */
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf),
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);
f1b4288b3b466065edd5eb9868399db6a4ff283evb (void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0')) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (10*i);
f1b4288b3b466065edd5eb9868399db6a4ff283evb (void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf);
f1b4288b3b466065edd5eb9868399db6a4ff283evb /* NOTREACHED */
f1b4288b3b466065edd5eb9868399db6a4ff283evb (void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf);
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-v vdevs (default: %llu)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-s size_of_each_vdev (default: %s)]\n"
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick "\t[-a alignment_shift (default: %d) (use 0 for random)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-m mirror_copies (default: %d)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-r raidz_disks (default: %d)]\n"
99653d4ee642c6528e88224f12409a5f23060994eschrock "\t[-R raidz_parity (default: %d)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-d datasets (default: %d)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-t threads (default: %d)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-g gang_block_threshold (default: %s)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-i initialize pool i times (default: %d)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-k kill percentage (default: %llu%%)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-p pool_name (default: %s)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-f file directory for vdev files (default: %s)]\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-V(erbose)] (use multiple times for ever more blather)\n"
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick "\t[-E(xisting)] (use existing pool instead of creating new one)\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-T time] total run time (default: %llu sec)\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens "\t[-P passtime] time per pass (default: %llu sec)\n"
d63d470b66194d40e74d5a669bd21e215bd63fc2gw "\t[-z zil failure rate (default: fail every 2^%llu allocs)]\n"
0a4e9518a44f226be6d39383330b5b1792d2f184gw "\t[-w write failure rate (default: fail every 2^%llu allocs)]\n"
f1b4288b3b466065edd5eb9868399db6a4ff283evb "\t[-h] (print help)\n"
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (read(ztest_random_fd, &r, sizeof (r)) != sizeof (r))
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (r % range);
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* By default, test gang blocks for blocks 32K and greater */
d63d470b66194d40e74d5a669bd21e215bd63fc2gw /* Default value, fail every 32nd allocation */
e05725b117836db173257fae43fb0746eb857fb5bonwick metaslab_gang_bang = MAX(SPA_MINBLOCKSIZE << 1, value);
99653d4ee642c6528e88224f12409a5f23060994eschrock zopt_raidz_parity = MIN(zopt_raidz_parity, zopt_raidz - 1);
fa9e4066f08beec538e775443c5be79dd423fcabahrens zopt_vdevtime = (zopt_vdevs > 0 ? zopt_time / zopt_vdevs : UINT64_MAX);
99653d4ee642c6528e88224f12409a5f23060994eschrock zopt_maxfaults = MAX(zopt_mirrors, 1) * (zopt_raidz_parity + 1) - 1;
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (size == 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens fd = open(dev_name, O_RDWR | O_CREAT | O_TRUNC, 0666);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_TYPE, VDEV_TYPE_FILE) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_PATH, dev_name) == 0);
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick VERIFY(nvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens child = umem_alloc(r * sizeof (nvlist_t *), UMEM_NOFAIL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < r; c++)
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_alloc(&raidz, NV_UNIQUE_NAME, 0) == 0);
99653d4ee642c6528e88224f12409a5f23060994eschrock VERIFY(nvlist_add_uint64(raidz, ZPOOL_CONFIG_NPARITY,
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_nvlist_array(raidz, ZPOOL_CONFIG_CHILDREN,
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < r; c++)
fa9e4066f08beec538e775443c5be79dd423fcabahrens child = umem_alloc(m * sizeof (nvlist_t *), UMEM_NOFAIL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < m; c++)
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_alloc(&mirror, NV_UNIQUE_NAME, 0) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN,
8654d0253136055bd4cc2423d87378e8a37f2eb5perrin VERIFY(nvlist_add_uint64(mirror, ZPOOL_CONFIG_IS_LOG, log) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < m; c++)
8654d0253136055bd4cc2423d87378e8a37f2eb5perrinmake_vdev_root(size_t size, int log, int r, int m, int t)
fa9e4066f08beec538e775443c5be79dd423fcabahrens child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < t; c++)
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_nvlist_array(root, ZPOOL_CONFIG_CHILDREN,
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < t; c++)
fa9e4066f08beec538e775443c5be79dd423fcabahrensztest_set_random_blocksize(objset_t *os, uint64_t object, dmu_tx_t *tx)
fa9e4066f08beec538e775443c5be79dd423fcabahrens ztest_random(SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT + 1);
fa9e4066f08beec538e775443c5be79dd423fcabahrens ztest_random(DN_MAX_INDBLKSHIFT - DN_MIN_INDBLKSHIFT + 1);
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = dmu_object_set_blocksize(os, object, 1ULL << bs, ibs, tx);
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "dmu_object_set_blocksize('%s', %llu, %d, %d) = %d",
fa9e4066f08beec538e775443c5be79dd423fcabahrens return ((uint8_t)ztest_random(ZIO_COMPRESS_FUNCTIONS));
fa9e4066f08beec538e775443c5be79dd423fcabahrenstypedef struct ztest_replay {
fa9e4066f08beec538e775443c5be79dd423fcabahrensztest_replay_create(ztest_replay_t *zr, lr_create_t *lr, boolean_t byteswap)
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = dmu_object_claim(os, lr->lr_doid, lr->lr_mode, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens " in txg %llu = %d\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrensztest_replay_remove(ztest_replay_t *zr, lr_remove_t *lr, boolean_t byteswap)
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_free(tx, lr->lr_doid, 0, DMU_OBJECT_END);
fa9e4066f08beec538e775443c5be79dd423fcabahrenszil_replay_func_t *ztest_replay_vector[TX_MAX_TYPE] = {
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can't destroy an active pool, create an existing pool,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * or create a pool with a bad vdev spec.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Attempt to create using a bad file.
228975cc44c2290cc190960e5894ac6ce0863855ek error = spa_create("ztest_bad_file", nvroot, NULL, NULL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Attempt to create using a bad mirror.
228975cc44c2290cc190960e5894ac6ce0863855ek error = spa_create("ztest_bad_mirror", nvroot, NULL, NULL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Attempt to create an existing pool. It shouldn't matter
fa9e4066f08beec538e775443c5be79dd423fcabahrens * what's in the nvroot; we should fail with EEXIST.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that vdev_add() works as expected.
8654d0253136055bd4cc2423d87378e8a37f2eb5perrin * Make 1/4 of the devices be log devices.
fa9e4066f08beec538e775443c5be79dd423fcabahrens else if (error != 0)
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) printf("spa_vdev_add = %d, as expected\n", error);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * For whole disks, the internal path has 's0', but the
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * path passed in by the user doesn't.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can attach and detach devices.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Decide whether to do an attach or a replace.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random top-level vdev.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random leaf within it.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Generate the path to this leaf. The filename will end with 'a'.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * We'll alternate replacements with a filename that ends with 'b'.
fa9e4066f08beec538e775443c5be79dd423fcabahrens ztest_dev_template, zopt_dir, zopt_pool, top * leaves + leaf);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If the 'a' file isn't part of the pool, the 'b' file must be.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * Now oldpath represents something that's already in the pool,
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * and newpath is the thing we'll try to attach.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * Make newsize a little bigger or smaller than oldsize.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If it's smaller, the attach should fail.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If it's larger, and we're doing a replace,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * we should get dynamic LUN growth when we're done.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If pvd is not a mirror or root, the attach should fail with ENOTSUP,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * unless it's a replace; in that case any non-replacing parent is OK.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * If newvd is already part of the pool, it should fail with EBUSY.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * If newvd is too small, it should fail with EOVERFLOW.
fa9e4066f08beec538e775443c5be79dd423fcabahrens (!replacing || pvd->vdev_ops == &vdev_replacing_ops))
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * If newvd isn't already part of the pool, create it.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock fd = open(newpath, O_RDWR | O_CREAT | O_TRUNC, 0666);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * Build the nvlist describing newpath.
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_TYPE, VDEV_TYPE_FILE) == 0);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_PATH, newpath) == 0);
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick VERIFY(nvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_nvlist_array(root, ZPOOL_CONFIG_CHILDREN,
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock error = spa_vdev_attach(spa, oldvd->vdev_guid, root, replacing);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If our parent was the replacing vdev, but the replace completed,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * then instead of failing with ENOTSUP we may either succeed,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * fail with ENODEV, or fail with EOVERFLOW.
fa9e4066f08beec538e775443c5be79dd423fcabahrens (error == 0 || error == ENODEV || error == EOVERFLOW))
f0aa80d4da975c8ef3e34c15c60ea31e9b75f7a9bonwick * If someone grew the LUN, the replacement may be too small.
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "attach (%s, %s, %d) returned %d, expected %d",
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock oldpath, newpath, replacing, error, expected_error);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that dynamic LUN growth works as expected.
fa9e4066f08beec538e775443c5be79dd423fcabahrens/* ARGSUSED */
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random leaf vdev.
fa9e4066f08beec538e775443c5be79dd423fcabahrens vdev = ztest_random(spa->spa_root_vdev->vdev_children * leaves);
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) sprintf(dev_name, ztest_dev_template, zopt_dir, zopt_pool, vdev);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Determine the size.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If it's less than 2x the original size, grow by around 3%.
fa9e4066f08beec538e775443c5be79dd423fcabahrens/* ARGSUSED */
ecd6cf800b63704be73fb264c3f5b6e0dafc068dmarksztest_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create the directory object.
e05725b117836db173257fae43fb0746eb857fb5bonwick DMU_OT_UINT64_OTHER, 5 * sizeof (ztest_block_tag_t), tx) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that the dataset contains a directory object.
e19302335c33c8c6e0b0b5e426fc1f6352c84b5dbonwick /* We could have crashed in the middle of destroying it */
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Destroy the dataset.
1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrens return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that dmu_objset_{create,destroy,open,close} work as expected.
fa9e4066f08beec538e775443c5be79dd423fcabahrensztest_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t object, int mode)
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) sprintf(name, "ZOBJ_%llu", (u_longlong_t)object);
fa9e4066f08beec538e775443c5be79dd423fcabahrens itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize +
fa9e4066f08beec538e775443c5be79dd423fcabahrens bzero(lr + 1, lr->lr_common.lrc_reclen - sizeof (*lr));
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) snprintf(name, 100, "%s/%s_temp_%llu", za->za_pool, za->za_pool,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If this dataset exists from a previous run, process its replay log
fa9e4066f08beec538e775443c5be79dd423fcabahrens * half of the time. If we don't replay it, then dmu_objset_destroy()
fa9e4066f08beec538e775443c5be79dd423fcabahrens * (invoked from ztest_destroy_cb() below) should just throw it away.
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_objset_open(name, DMU_OST_OTHER, DS_MODE_PRIMARY, &os) == 0) {
893a6d32980d24be1349478f44169009d4801c25ahrens zil_replay(os, &zr, &zr.zr_assign, ztest_replay_vector);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * There may be an old instance of the dataset we're about to
fa9e4066f08beec538e775443c5be79dd423fcabahrens * create lying around from a previous run. If so, destroy it
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and all of its snapshots.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that the destroyed dataset is no longer in the namespace.
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = dmu_objset_open(name, DMU_OST_OTHER, basemode, &os);
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(1, "dmu_objset_open(%s) found destroyed dataset %p",
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can create a new dataset.
ab04eb8ef60d9dc9614d6cccffc474f24ca1d162timh error = dmu_objset_create(name, DMU_OST_OTHER, NULL, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = dmu_objset_open(name, DMU_OST_OTHER, basemode, &os);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Open the intent log for it.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Put a random number of objects in there.
fa9e4066f08beec538e775443c5be79dd423fcabahrens while (objects-- != 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, sizeof (name));
fa9e4066f08beec538e775443c5be79dd423fcabahrens object = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (error == 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we cannot create an existing dataset.
ab04eb8ef60d9dc9614d6cccffc474f24ca1d162timh error = dmu_objset_create(name, DMU_OST_OTHER, NULL, 0, NULL, NULL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "created existing dataset, error = %d", error);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that multiple dataset opens are allowed, but only when
fa9e4066f08beec538e775443c5be79dd423fcabahrens * the new access mode is compatible with the base mode.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * We use a mixture of typed and typeless opens, and when the
fa9e4066f08beec538e775443c5be79dd423fcabahrens * open succeeds, verify that the discovered type is correct.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (mode = DS_MODE_STANDARD; mode < DS_MODE_LEVELS; mode++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = dmu_objset_open(name, DMU_OST_OTHER, mode, &os2);
fa9e4066f08beec538e775443c5be79dd423fcabahrens expected_error = (basemode + mode < DS_MODE_LEVELS) ? 0 : EBUSY;
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "dmu_objset_destroy(%s) = %d", name, error);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that dmu_snapshot_{create,destroy,open,close} work as expected.
1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrens error = dmu_objset_snapshot(osname, strchr(snapname, '@')+1, FALSE);
fa9e4066f08beec538e775443c5be79dd423fcabahrensztest_blk_cb(traverse_blk_cache_t *bc, spa_t *spa, void *arg)
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * Level -1 indicates the objset_phys_t or something in its intent log.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Once in a while, abort the traverse. We only do this to odd
fa9e4066f08beec538e775443c5be79dd423fcabahrens * instance numbers to ensure that even ones can run to completion.
fa9e4066f08beec538e775443c5be79dd423fcabahrens if ((za->za_instance & 1) && ztest_random(10000) == 0)
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (zb->zb_level == 0 && !(th->th_advance & ADVANCE_DATA) &&
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * This is an expensive question, so don't ask it too often.
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (((za->za_random ^ th->th_callbacks) & 0xff) == 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens ASSERT3U(size, ==, dnp->dn_datablkszsec << DEV_BSHIFT);
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that live pool traversal works.
fa9e4066f08beec538e775443c5be79dd423fcabahrens th = za->za_th = traverse_init(spa, ztest_blk_cb, za, advance,
fa9e4066f08beec538e775443c5be79dd423fcabahrens cblimit = cbstart + ((advance & ADVANCE_DATA) ? 100 : 1000);
fa9e4066f08beec538e775443c5be79dd423fcabahrens while ((rc = traverse_more(th)) == EAGAIN && th->th_callbacks < cblimit)
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock "<%llu, %llu, %lld, %llx>%s\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that dmu_object_{alloc,free} work as expected.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create a batch object if necessary, and record it in the directory.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
fa9e4066f08beec538e775443c5be79dd423fcabahrens batchobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Destroy the previous batch of objects.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (b = 0; b < batchsize; b++) {
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(0 == dmu_read(os, batchobj, b * sizeof (uint64_t),
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Read and validate contents.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * We expect the nth byte of the bonus buffer to be n.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(0 == dmu_bonus_hold(os, object, FTAG, &db));
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (c = 0; c < bonuslen; c++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens "bad bonus: %s, obj %llu, off %d: %u != %u",
fa9e4066f08beec538e775443c5be79dd423fcabahrens * We expect the word at endoff to be our object number.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Destroy old object and clear batch entry.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Before creating the new batch of objects, generate a bunch of churn.
fa9e4066f08beec538e775443c5be79dd423fcabahrens object = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create a new batch of objects with randomly chosen
fa9e4066f08beec538e775443c5be79dd423fcabahrens * blocksizes and record them in the batch directory.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (b = 0; b < batchsize; b++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_write(tx, batchobj, b * sizeof (uint64_t),
fa9e4066f08beec538e775443c5be79dd423fcabahrens object = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Write to both the bonus buffer and the regular data.
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_object_size_from_db(db, &va_blksize, &va_nblocks);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * See comments above regarding the contents of
fa9e4066f08beec538e775443c5be79dd423fcabahrens * the bonus buffer and the word at endoff.
1934e92fc930c49429ad71a8ca97340f33227e78maybee for (c = 0; c < bonuslen; c++)
fa9e4066f08beec538e775443c5be79dd423fcabahrens ((uint8_t *)db->db_data)[c] = (uint8_t)(c + bonuslen);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Write to a large offset to increase indirection.
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_write(os, object, endoff, sizeof (uint64_t), &object, tx);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that dmu_{read,write} work as expected.
fa9e4066f08beec538e775443c5be79dd423fcabahrenstypedef struct bufwad {
fa9e4066f08beec538e775443c5be79dd423fcabahrenstypedef struct dmu_read_write_dir {
fa9e4066f08beec538e775443c5be79dd423fcabahrens * This test uses two objects, packobj and bigobj, that are always
fa9e4066f08beec538e775443c5be79dd423fcabahrens * updated together (i.e. in the same tx) so that their contents are
fa9e4066f08beec538e775443c5be79dd423fcabahrens * in sync and can be compared. Their contents relate to each other
fa9e4066f08beec538e775443c5be79dd423fcabahrens * in a simple way: packobj is a dense array of 'bufwad' structures,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * while bigobj is a sparse array of the same bufwads. Specifically,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * for any index n, there are three bufwads that should be identical:
fa9e4066f08beec538e775443c5be79dd423fcabahrens * packobj, at offset n * sizeof (bufwad_t)
fa9e4066f08beec538e775443c5be79dd423fcabahrens * bigobj, at the head of the nth chunk
fa9e4066f08beec538e775443c5be79dd423fcabahrens * bigobj, at the tail of the nth chunk
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The chunk size is arbitrary. It doesn't have to be a power of two,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and it doesn't have any relation to the object blocksize.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * The only requirement is that it can hold at least two bufwads.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Normally, we write the bufwad to each of these locations.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * However, free_percent of the time we instead write zeroes to
fa9e4066f08beec538e775443c5be79dd423fcabahrens * packobj and perform a dmu_free_range() on bigobj. By comparing
fa9e4066f08beec538e775443c5be79dd423fcabahrens * bigobj to packobj, we can verify that the DMU is correctly
fa9e4066f08beec538e775443c5be79dd423fcabahrens * tracking which parts of an object are allocated and free,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and that the contents of the allocated blocks are correct.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Read the directory info. If it's the first time, set things up.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (dd));
fa9e4066f08beec538e775443c5be79dd423fcabahrens dd.dd_packobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens dd.dd_bigobj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens dd.dd_chunk = (1000 + ztest_random(1000)) * sizeof (uint64_t);
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (dd), &dd,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Prefetch a random chunk of the big object.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Our aim here is to get some async reads in flight
fa9e4066f08beec538e775443c5be79dd423fcabahrens * for blocks that we may free below; the DMU should
fa9e4066f08beec538e775443c5be79dd423fcabahrens * handle this race correctly.
fa9e4066f08beec538e775443c5be79dd423fcabahrens n = ztest_random(regions) * stride + ztest_random(width);
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_prefetch(os, dd.dd_bigobj, n * dd.dd_chunk, s * dd.dd_chunk);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random index and compute the offsets into packobj and bigobj.
fa9e4066f08beec538e775443c5be79dd423fcabahrens n = ztest_random(regions) * stride + ztest_random(width);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * free_percent of the time, free a range of bigobj rather than
fa9e4066f08beec538e775443c5be79dd423fcabahrens * overwriting it.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Read the current contents of our objects.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock error = dmu_read(os, dd.dd_packobj, packoff, packsize, packbuf);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock error = dmu_read(os, dd.dd_bigobj, bigoff, bigsize, bigbuf);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Get a tx for the mods to both packobj and bigobj.
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_write(tx, dd.dd_packobj, packoff, packsize);
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_write(tx, dd.dd_bigobj, bigoff, bigsize);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * For each index from n to n + s, verify that the existing bufwad
fa9e4066f08beec538e775443c5be79dd423fcabahrens * in packobj matches the bufwads at the head and tail of the
fa9e4066f08beec538e775443c5be79dd423fcabahrens * corresponding chunk in bigobj. Then update all three bufwads
fa9e4066f08beec538e775443c5be79dd423fcabahrens * with the new values we want to write out.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (i = 0; i < s; i++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* LINTED */
fa9e4066f08beec538e775443c5be79dd423fcabahrens pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* LINTED */
fa9e4066f08beec538e775443c5be79dd423fcabahrens bigH = (bufwad_t *)((char *)bigbuf + i * dd.dd_chunk);
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* LINTED */
fa9e4066f08beec538e775443c5be79dd423fcabahrens ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
fa9e4066f08beec538e775443c5be79dd423fcabahrens ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * We've verified all the old bufwads, and made new ones.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Now write them out.
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_write(os, dd.dd_packobj, packoff, packsize, packbuf, tx);
fa9e4066f08beec538e775443c5be79dd423fcabahrens " txg %llx\n",
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(0 == dmu_free_range(os, dd.dd_bigobj, bigoff,
fa9e4066f08beec538e775443c5be79dd423fcabahrens " txg %llx\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_write(os, dd.dd_bigobj, bigoff, bigsize, bigbuf, tx);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Sanity check the stuff we just wrote.
4d31c452acf5d10173fb57db4d33ab750d0fd1c8maybee * Make sure that, if there is a write record in the bonus buffer
4d31c452acf5d10173fb57db4d33ab750d0fd1c8maybee * of the ZTEST_DIROBJ, that the txg for this record is <= the
4d31c452acf5d10173fb57db4d33ab750d0fd1c8maybee * last synced txg of the pool.
e05725b117836db173257fae43fb0746eb857fb5bonwick VERIFY(dmu_bonus_hold(os, ZTEST_DIROBJ, FTAG, &db) == 0);
e05725b117836db173257fae43fb0746eb857fb5bonwick VERIFY(dmu_object_info(os, ZTEST_DIROBJ, doi) == 0);
e05725b117836db173257fae43fb0746eb857fb5bonwick ASSERT3U(doi->doi_bonus_size % sizeof (*bt), ==, 0);
e05725b117836db173257fae43fb0746eb857fb5bonwick bt = (void *)((char *)db->db_data + doi->doi_bonus_size - sizeof (*bt));
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Have multiple threads write to large offsets in ZTEST_DIROBJ
fa9e4066f08beec538e775443c5be79dd423fcabahrens * to verify that having multiple threads writing to the same object
fa9e4066f08beec538e775443c5be79dd423fcabahrens * in parallel doesn't cause any trouble.
e05725b117836db173257fae43fb0746eb857fb5bonwick * Do the bonus buffer instead of a regular block.
e05725b117836db173257fae43fb0746eb857fb5bonwick * We need a lock to serialize resize vs. others,
e05725b117836db173257fae43fb0746eb857fb5bonwick * so we hash on the objset ID.
e05725b117836db173257fae43fb0746eb857fb5bonwick off = za->za_diroff_shared + (b << SPA_MAXBLOCKSHIFT);
e05725b117836db173257fae43fb0746eb857fb5bonwick txg_how = ztest_random(2) == 0 ? TXG_WAIT : TXG_NOWAIT;
e05725b117836db173257fae43fb0746eb857fb5bonwick wbt->bt_seq = ztest_shared->zs_seq[b]++; /* protected by lp */
e05725b117836db173257fae43fb0746eb857fb5bonwick VERIFY(dmu_bonus_hold(os, ZTEST_DIROBJ, FTAG, &db) == 0);
e05725b117836db173257fae43fb0746eb857fb5bonwick dboff = (char *)db->db_data + doi->doi_bonus_size - btsize;
e05725b117836db173257fae43fb0746eb857fb5bonwick } else if (do_free) {
e05725b117836db173257fae43fb0746eb857fb5bonwick VERIFY(dmu_free_range(os, ZTEST_DIROBJ, off, bs, tx) == 0);
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) poll(NULL, 0, 1); /* open dn_notxholds window */
e05725b117836db173257fae43fb0746eb857fb5bonwick * dmu_sync() the block we just wrote.
e05725b117836db173257fae43fb0746eb857fb5bonwick error = dmu_buf_hold(os, ZTEST_DIROBJ, blkoff, FTAG, &db);
e05725b117836db173257fae43fb0746eb857fb5bonwick error = dmu_sync(NULL, db, &blk, wbt->bt_txg, NULL, NULL);
e05725b117836db173257fae43fb0746eb857fb5bonwick ASSERT3U(BP_GET_TYPE(&blk), ==, DMU_OT_UINT64_OTHER);
e05725b117836db173257fae43fb0746eb857fb5bonwick * Read the block that dmu_sync() returned to make sure its contents
e05725b117836db173257fae43fb0746eb857fb5bonwick * match what we wrote. We do this while still txg_suspend()ed
e05725b117836db173257fae43fb0746eb857fb5bonwick * to ensure that the block can't be reused before we read it.
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zio_wait(zio_read(NULL, za->za_spa, &blk, iobuf, bs,
e05725b117836db173257fae43fb0746eb857fb5bonwick NULL, NULL, ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_MUSTSUCCEED, &zb));
e05725b117836db173257fae43fb0746eb857fb5bonwick * The semantic of dmu_sync() is that we always push the most recent
e05725b117836db173257fae43fb0746eb857fb5bonwick * version of the data, so in the face of concurrent updates we may
e05725b117836db173257fae43fb0746eb857fb5bonwick * see a newer version of the block. That's OK.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that zap_{create,destroy,add,remove,update} work as expected.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create a new object if necessary, and record it in the directory.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock VERIFY(0 == dmu_read(os, ZTEST_DIROBJ, za->za_diroff,
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (object == 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens object = zap_create(os, DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Generate a known hash collision, and verify that
fa9e4066f08beec538e775443c5be79dd423fcabahrens * we can lookup and remove both entries.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (i = 0; i < 2; i++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = zap_add(os, object, hc[i], sizeof (uint64_t),
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (i = 0; i < 2; i++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = zap_add(os, object, hc[i], sizeof (uint64_t),
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (i = 0; i < 2; i++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens ints = MAX(ZTEST_ZAP_MIN_INTS, object % ZTEST_ZAP_MAX_INTS);
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
e05725b117836db173257fae43fb0746eb857fb5bonwick * If these zap entries already exist, validate their contents.
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
e05725b117836db173257fae43fb0746eb857fb5bonwick if (error == 0) {
e05725b117836db173257fae43fb0746eb857fb5bonwick VERIFY(zap_length(os, object, propname, &zl_intsize,
e05725b117836db173257fae43fb0746eb857fb5bonwick for (i = 0; i < ints; i++) {
e05725b117836db173257fae43fb0746eb857fb5bonwick * Atomically update two entries in our zap object.
e05725b117836db173257fae43fb0746eb857fb5bonwick * The first is named txg_%llu, and contains the txg
e05725b117836db173257fae43fb0746eb857fb5bonwick * in which the property was last updated. The second
e05725b117836db173257fae43fb0746eb857fb5bonwick * is named prop_%llu, and the nth element of its value
e05725b117836db173257fae43fb0746eb857fb5bonwick * should be txg + object + n.
e05725b117836db173257fae43fb0746eb857fb5bonwick fatal(0, "zap future leak: old %llu new %llu", last_txg, txg);
e05725b117836db173257fae43fb0746eb857fb5bonwick for (i = 0; i < ints; i++)
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_update(os, object, txgname, sizeof (uint64_t), 1, &txg, tx);
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_update(os, object, propname, sizeof (uint64_t),
e05725b117836db173257fae43fb0746eb857fb5bonwick * Remove a random pair of entries.
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Once in a while, destroy the object.
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_tx_hold_write(tx, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t));
fa9e4066f08beec538e775443c5be79dd423fcabahrens dmu_write(os, ZTEST_DIROBJ, za->za_diroff, sizeof (uint64_t),
fa9e4066f08beec538e775443c5be79dd423fcabahrens uint64_t txg, object, count, wsize, wc, zl_wsize, zl_wc;
e05725b117836db173257fae43fb0746eb857fb5bonwick * Generate a random name of the form 'xxx.....' where each
e05725b117836db173257fae43fb0746eb857fb5bonwick * x is a random printable character and the dots are dots.
e05725b117836db173257fae43fb0746eb857fb5bonwick * There are 94 such characters, and the name length goes from
e05725b117836db173257fae43fb0746eb857fb5bonwick * 6 to 20, so there are 94^3 * 15 = 12,458,760 possible names.
e05725b117836db173257fae43fb0746eb857fb5bonwick for (i = 0; i < 3; i++)
e05725b117836db173257fae43fb0746eb857fb5bonwick if ((namelen & 1) || object == ZTEST_MICROZAP_OBJ) {
e05725b117836db173257fae43fb0746eb857fb5bonwick * Select an operation: length, lookup, add, update, remove.
e05725b117836db173257fae43fb0746eb857fb5bonwick if (i >= 2) {
e05725b117836db173257fae43fb0746eb857fb5bonwick switch (i) {
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_length(os, object, name, &zl_wsize, &zl_wc);
e05725b117836db173257fae43fb0746eb857fb5bonwick if (error == 0) {
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_lookup(os, object, name, wsize, wc, data);
e05725b117836db173257fae43fb0746eb857fb5bonwick if (error == 0) {
e05725b117836db173257fae43fb0746eb857fb5bonwick error = zap_add(os, object, name, wsize, wc, data, tx);
e05725b117836db173257fae43fb0746eb857fb5bonwick VERIFY(zap_update(os, object, name, wsize, wc, data, tx) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (i = 0; i < 2; i++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (i == 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (i == 0)
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrockztest_error_setup(vdev_t *vd, int mode, int mask, uint64_t arg)
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock ztest_error_setup(vd->vdev_child[c], mode, mask, arg);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Inject random faults into the on-disk data.
fa9e4066f08beec538e775443c5be79dd423fcabahrens int bshift = SPA_MAXBLOCKSHIFT + 2; /* don't scrog all labels */
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * We can't inject faults when we have no fault tolerance.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random top-level vdev.
fa9e4066f08beec538e775443c5be79dd423fcabahrens top = ztest_random(spa->spa_root_vdev->vdev_children);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random leaf.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * Generate paths to the first two leaves in this top-level vdev,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and to the random leaf we selected. We'll induce transient
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * I/O errors and random online/offline activity on leaf 0,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * and we'll write random garbage to the randomly chosen leaf.
fa9e4066f08beec538e775443c5be79dd423fcabahrens ztest_dev_template, zopt_dir, zopt_pool, top * leaves + 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens ztest_dev_template, zopt_dir, zopt_pool, top * leaves + leaf);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * If we can tolerate two or more faults, make vd0 fail randomly.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock vd0 = vdev_lookup_by_path(spa->spa_root_vdev, path0);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock (1U << ZIO_TYPE_READ) | (1U << ZIO_TYPE_WRITE), 100);
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * If we can tolerate two or more faults, randomly online/offline vd0.
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * We have at least single-fault tolerance, so inject data corruption.
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (fd == -1) /* we hit a gap in the device namespace */
fa9e4066f08beec538e775443c5be79dd423fcabahrens while (--iters != 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens if (pwrite(fd, &bad, sizeof (bad), offset) != sizeof (bad))
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Scrub the pool.
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) spa_scrub(spa, POOL_SCRUB_EVERYTHING, B_FALSE);
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) poll(NULL, 0, 1000); /* wait a second, then force a restart */
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) spa_scrub(spa, POOL_SCRUB_EVERYTHING, B_FALSE);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Rename the pool to a different name and then rename it back.
fa9e4066f08beec538e775443c5be79dd423fcabahrens newname = umem_alloc(strlen(oldname) + 5, UMEM_NOFAIL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Do the rename
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Try to open it under the old name, which shouldn't exist
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Open it under the new name and make sure it's still the same spa_t.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Rename it back to the original
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Make sure it can still be opened
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Completely obliterate one disk.
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) sprintf(dev_name, ztest_dev_template, zopt_dir, zopt_pool, vdev);
d80c45e0f58fa434ba37259ea2e2b12e0380c19abonwick (void) snprintf(copy_name, MAXPATHLEN, "%s.old", dev_name);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Determine the size.
d80c45e0f58fa434ba37259ea2e2b12e0380c19abonwick * Rename the old device to dev_name.old (useful for debugging).
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create a new one.
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY((fd = open(dev_name, O_RDWR | O_CREAT | O_TRUNC, 0666)) >= 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) sprintf(dev_name, ztest_dev_template, zopt_dir, zopt_pool, vdev);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Build the nvlist describing dev_name.
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_TYPE, VDEV_TYPE_FILE) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_PATH, dev_name) == 0);
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick VERIFY(nvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens VERIFY(nvlist_add_nvlist_array(root, ZPOOL_CONFIG_CHILDREN,
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock if ((vd = vdev_lookup_by_path(spa->spa_root_vdev, dev_name)) == NULL)
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick if (error != 0 &&
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* zdb lives in /usr/sbin, while ztest lives in /usr/bin */
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* LINTED */
3a57275a335306e90136ebd00a4689fe0ee72519ck "/usr/sbin%.*s/zdb -bc%s%s -U /tmp/zpool.cache -O %s %s",
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) printf("Executing %s\n", strstr(zdb, "zdb "));
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "'%s' exit code %d", zdb, WEXITSTATUS(status));
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "'%s' died with signal %d", zdb, WTERMSIG(status));
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Clean up from previous runs.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Get the pool's configuration and guid.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Export it.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Import it under the new name.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Try to import it again -- should fail with EEXIST.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Try to import it under a different name -- should fail with EEXIST.
fa9e4066f08beec538e775443c5be79dd423fcabahrens fatal(0, "spa_import('%s') under multiple names", newname);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that the pool is no longer visible under the old name.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can open and close the pool using the new name.
0a4e9518a44f226be6d39383330b5b1792d2f184gw/* ARGSUSED */
0a4e9518a44f226be6d39383330b5b1792d2f184gwstatic void *
0a4e9518a44f226be6d39383330b5b1792d2f184gw (void) printf("Unable to monitor pool '%s'\n", zopt_pool);
0a4e9518a44f226be6d39383330b5b1792d2f184gw while (!ztest_exiting && list_is_empty(&spa->spa_zio_list))
0a4e9518a44f226be6d39383330b5b1792d2f184gw * We don't hold the spa_config_lock since the pool is in
0a4e9518a44f226be6d39383330b5b1792d2f184gw * complete failure mode and there is no way for us to
0a4e9518a44f226be6d39383330b5b1792d2f184gw * change the vdev config when we're in this state.
fa9e4066f08beec538e775443c5be79dd423fcabahrensstatic void *
fa9e4066f08beec538e775443c5be79dd423fcabahrens * See if it's time to force a crash.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Pick a random function.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Decide whether to call it, based on the requested frequency.
fa9e4066f08beec538e775443c5be79dd423fcabahrens (double)(now - zs->zs_start_time) / (zopt_time * NANOSEC))
fa9e4066f08beec538e775443c5be79dd423fcabahrens za->za_diroff = (za->za_instance * ZTEST_FUNCS + f) *
fa9e4066f08beec538e775443c5be79dd423fcabahrens * If we're getting ENOSPC with some regularity, stop.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Kick off threads to run tests on all datasets in parallel.
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) _mutex_init(&zs->zs_vdev_lock, USYNC_THREAD, NULL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) rwlock_init(&zs->zs_name_lock, USYNC_THREAD, NULL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (t = 0; t < ZTEST_SYNC_LOCKS; t++)
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) _mutex_init(&zs->zs_sync_lock[t], USYNC_THREAD, NULL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Destroy one disk before we even start.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * It's mirrored, so everything should work just fine.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * This makes us exercise fault handling very early in spa_load().
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that the sum of the sizes of all blocks in the pool
fa9e4066f08beec538e775443c5be79dd423fcabahrens * equals the SPA's allocated space total.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Kick off a replacement of the disk we just obliterated.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can export the pool and reimport it under a
fa9e4066f08beec538e775443c5be79dd423fcabahrens * different name.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can loop over all pools.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (spa = spa_next(NULL); spa != NULL; spa = spa_next(spa)) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) printf("spa_next: found %s\n", spa_name(spa));
0a4e9518a44f226be6d39383330b5b1792d2f184gw * Create a thread to handling complete pool failures. This
0a4e9518a44f226be6d39383330b5b1792d2f184gw * thread will kickstart the I/Os when they suspend. We must
0a4e9518a44f226be6d39383330b5b1792d2f184gw * start the thread before setting the zio_io_fail_shift, which
0a4e9518a44f226be6d39383330b5b1792d2f184gw * will indicate our failure rate.
0a4e9518a44f226be6d39383330b5b1792d2f184gw error = thr_create(0, 0, ztest_suspend_monitor, NULL, THR_BOUND, &tid);
0a4e9518a44f226be6d39383330b5b1792d2f184gw fatal(0, "can't create suspend monitor thread: error %d",
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Open our pool.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Verify that we can safely inquire about about any object,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * whether it's allocated or not. To make it interesting,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * we probe a 5-wide window around each power of two.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * This hits all edge cases, including zero and the max.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (t = 0; t < 64; t++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Now kick off all the tests that run in parallel.
fa9e4066f08beec538e775443c5be79dd423fcabahrens za = umem_zalloc(zopt_threads * sizeof (ztest_args_t), UMEM_NOFAIL);
0a4e9518a44f226be6d39383330b5b1792d2f184gw /* Let failures begin */
fa9e4066f08beec538e775443c5be79dd423fcabahrens za[0].za_stop = za[0].za_start + zopt_passtime * NANOSEC;
fa9e4066f08beec538e775443c5be79dd423fcabahrens za[0].za_stop = MIN(za[0].za_stop, zs->zs_stop_time);
fa9e4066f08beec538e775443c5be79dd423fcabahrens za[0].za_kill -= ztest_random(zopt_passtime * NANOSEC);
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (t = 0; t < zopt_threads; t++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) snprintf(name, 100, "%s/%s_%d", pool, pool, d);
ab04eb8ef60d9dc9614d6cccffc474f24ca1d162timh error = dmu_objset_create(name, DMU_OST_OTHER, NULL, 0,
4d31c452acf5d10173fb57db4d33ab750d0fd1c8maybee } else if (error != 0) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens error = thr_create(0, 0, ztest_thread, &za[t], THR_BOUND,
fa9e4066f08beec538e775443c5be79dd423fcabahrens while (--t >= 0) {
e05725b117836db173257fae43fb0746eb857fb5bonwick * If we had out-of-space errors, destroy a random objset.
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) snprintf(name, 100, "%s/%s_%d", pool, pool, d);
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) printf("Destroying %s to free up space\n", name);
e05725b117836db173257fae43fb0746eb857fb5bonwick (void) dmu_objset_find(name, ztest_destroy_cb, &za[d],
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Right before closing the pool, kick off a bunch of async I/O;
fa9e4066f08beec538e775443c5be79dd423fcabahrens * spa_close() should wait for it to complete.
0a4e9518a44f226be6d39383330b5b1792d2f184gw /* Shutdown the suspend monitor thread */
e05725b117836db173257fae43fb0746eb857fb5bonwick umem_free(za, zopt_threads * sizeof (ztest_args_t));
fa9e4066f08beec538e775443c5be79dd423fcabahrens s -= m * 60;
fa9e4066f08beec538e775443c5be79dd423fcabahrens m -= h * 60;
fa9e4066f08beec538e775443c5be79dd423fcabahrens h -= d * 24;
fa9e4066f08beec538e775443c5be79dd423fcabahrens "%llud%02lluh%02llum%02llus", d, h, m, s);
fa9e4066f08beec538e775443c5be79dd423fcabahrens else if (h)
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) sprintf(timebuf, "%lluh%02llum%02llus", h, m, s);
fa9e4066f08beec538e775443c5be79dd423fcabahrens else if (m)
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create a storage pool with the given name and initial vdev size.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Then create the specified number of datasets in the pool.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create the storage pool.
8654d0253136055bd4cc2423d87378e8a37f2eb5perrin nvroot = make_vdev_root(zopt_vdev_size, 0, zopt_raidz, zopt_mirrors, 1);
fa9e4066f08beec538e775443c5be79dd423fcabahrens /* Override location of zpool.cache */
ea8dc4b6d2251b437950c0056bc626b311c73c27eschrock * Blow away any existing copy of zpool.cache
fa9e4066f08beec538e775443c5be79dd423fcabahrens PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
fa9e4066f08beec538e775443c5be79dd423fcabahrens " %llu seconds...\n",
ecc2d604e885a75cc75e647b5641af99d5a6f4a6bonwick (u_longlong_t)zopt_vdevs, zopt_datasets, zopt_threads,
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Create and initialize our storage pool.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Initialize the call targets for each function.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (f = 0; f < ZTEST_FUNCS; f++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens zs->zs_stop_time = zs->zs_start_time + zopt_time * NANOSEC;
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Run the tests in a loop. These tests include fault injection
fa9e4066f08beec538e775443c5be79dd423fcabahrens * to verify that self-healing data works, and forced crashes
fa9e4066f08beec538e775443c5be79dd423fcabahrens * to verify that we never lose on-disk consistency.
fa9e4066f08beec538e775443c5be79dd423fcabahrens * Initialize the workload counters for each function.
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (f = 0; f < ZTEST_FUNCS; f++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens "child exited with code %d\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrens "child died with signal %d\n",
5ad820458efd0fdb914baff9c1447c22b819fa23nd "to child\n");
fa9e4066f08beec538e775443c5be79dd423fcabahrens "%4.1f%% of %5s used, %3.0f%% done, %8s to go\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrens for (f = 0; f < ZTEST_FUNCS; f++) {
fa9e4066f08beec538e775443c5be79dd423fcabahrens * It's possible that we killed a child during a rename test, in
fa9e4066f08beec538e775443c5be79dd423fcabahrens * which case we'll have a 'ztest_tmp' pool lying around instead
fa9e4066f08beec538e775443c5be79dd423fcabahrens * of 'ztest'. Do a blind rename in case this happened.
fa9e4066f08beec538e775443c5be79dd423fcabahrens tmp = umem_alloc(strlen(zopt_pool) + 5, UMEM_NOFAIL);
fa9e4066f08beec538e775443c5be79dd423fcabahrens (void) printf("%d killed, %d completed, %.0f%% kill rate\n",
fa9e4066f08beec538e775443c5be79dd423fcabahrens kills, iters - kills, (100.0 * kills) / MAX(1, iters));
fa9e4066f08beec538e775443c5be79dd423fcabahrens return (0);