1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5441d80aaSlling * Common Development and Distribution License (the "License"). 6441d80aaSlling * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 224f5064b7SMark J Musante * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens /* 27fa9e4066Sahrens * The objective of this program is to provide a DMU/ZAP/SPA stress test 28fa9e4066Sahrens * that runs entirely in userland, is easy to use, and easy to extend. 29fa9e4066Sahrens * 30fa9e4066Sahrens * The overall design of the ztest program is as follows: 31fa9e4066Sahrens * 32fa9e4066Sahrens * (1) For each major functional area (e.g. adding vdevs to a pool, 33fa9e4066Sahrens * creating and destroying datasets, reading and writing objects, etc) 34fa9e4066Sahrens * we have a simple routine to test that functionality. These 35fa9e4066Sahrens * individual routines do not have to do anything "stressful". 36fa9e4066Sahrens * 37fa9e4066Sahrens * (2) We turn these simple functionality tests into a stress test by 38fa9e4066Sahrens * running them all in parallel, with as many threads as desired, 39fa9e4066Sahrens * and spread across as many datasets, objects, and vdevs as desired. 40fa9e4066Sahrens * 41fa9e4066Sahrens * (3) While all this is happening, we inject faults into the pool to 42fa9e4066Sahrens * verify that self-healing data really works. 43fa9e4066Sahrens * 44fa9e4066Sahrens * (4) Every time we open a dataset, we change its checksum and compression 45fa9e4066Sahrens * functions. Thus even individual objects vary from block to block 46fa9e4066Sahrens * in which checksum they use and whether they're compressed. 47fa9e4066Sahrens * 48fa9e4066Sahrens * (5) To verify that we never lose on-disk consistency after a crash, 49fa9e4066Sahrens * we run the entire test in a child of the main process. 50fa9e4066Sahrens * At random times, the child self-immolates with a SIGKILL. 51fa9e4066Sahrens * This is the software equivalent of pulling the power cord. 52fa9e4066Sahrens * The parent then runs the test again, using the existing 53fa9e4066Sahrens * storage pool, as many times as desired. 54fa9e4066Sahrens * 55fa9e4066Sahrens * (6) To verify that we don't have future leaks or temporal incursions, 56fa9e4066Sahrens * many of the functional tests record the transaction group number 57fa9e4066Sahrens * as part of their data. When reading old data, they verify that 58fa9e4066Sahrens * the transaction group number is less than the current, open txg. 59fa9e4066Sahrens * If you add a new test, please do this if applicable. 60fa9e4066Sahrens * 61fa9e4066Sahrens * When run with no arguments, ztest runs for about five minutes and 62fa9e4066Sahrens * produces no output if successful. To get a little bit of information, 63fa9e4066Sahrens * specify -V. To get more information, specify -VV, and so on. 64fa9e4066Sahrens * 65fa9e4066Sahrens * To turn this into an overnight stress test, use -T to specify run time. 66fa9e4066Sahrens * 67fa9e4066Sahrens * You can ask more more vdevs [-v], datasets [-d], or threads [-t] 68fa9e4066Sahrens * to increase the pool capacity, fanout, and overall stress level. 69fa9e4066Sahrens * 70fa9e4066Sahrens * The -N(okill) option will suppress kills, so each child runs to completion. 71fa9e4066Sahrens * This can be useful when you're trying to distinguish temporal incursions 72fa9e4066Sahrens * from plain old race conditions. 73fa9e4066Sahrens */ 74fa9e4066Sahrens 75fa9e4066Sahrens #include <sys/zfs_context.h> 76fa9e4066Sahrens #include <sys/spa.h> 77fa9e4066Sahrens #include <sys/dmu.h> 78fa9e4066Sahrens #include <sys/txg.h> 792fdbea25SAleksandr Guzovskiy #include <sys/dbuf.h> 80fa9e4066Sahrens #include <sys/zap.h> 81fa9e4066Sahrens #include <sys/dmu_objset.h> 82fa9e4066Sahrens #include <sys/poll.h> 83fa9e4066Sahrens #include <sys/stat.h> 84fa9e4066Sahrens #include <sys/time.h> 85fa9e4066Sahrens #include <sys/wait.h> 86fa9e4066Sahrens #include <sys/mman.h> 87fa9e4066Sahrens #include <sys/resource.h> 88fa9e4066Sahrens #include <sys/zio.h> 89fa9e4066Sahrens #include <sys/zil.h> 90*b24ab676SJeff Bonwick #include <sys/zil_impl.h> 91fa9e4066Sahrens #include <sys/vdev_impl.h> 92e14bb325SJeff Bonwick #include <sys/vdev_file.h> 93fa9e4066Sahrens #include <sys/spa_impl.h> 9488ecc943SGeorge Wilson #include <sys/metaslab_impl.h> 95fa9e4066Sahrens #include <sys/dsl_prop.h> 964f5064b7SMark J Musante #include <sys/dsl_dataset.h> 97fa9e4066Sahrens #include <sys/refcount.h> 98fa9e4066Sahrens #include <stdio.h> 99004388ebScasper #include <stdio_ext.h> 100fa9e4066Sahrens #include <stdlib.h> 101fa9e4066Sahrens #include <unistd.h> 102fa9e4066Sahrens #include <signal.h> 103fa9e4066Sahrens #include <umem.h> 104fa9e4066Sahrens #include <dlfcn.h> 105fa9e4066Sahrens #include <ctype.h> 106fa9e4066Sahrens #include <math.h> 107fa9e4066Sahrens #include <sys/fs/zfs.h> 108*b24ab676SJeff Bonwick #include <libnvpair.h> 109fa9e4066Sahrens 110fa9e4066Sahrens static char cmdname[] = "ztest"; 111fa9e4066Sahrens static char *zopt_pool = cmdname; 112fa9e4066Sahrens 113fa9e4066Sahrens static uint64_t zopt_vdevs = 5; 114fa9e4066Sahrens static uint64_t zopt_vdevtime; 115ecc2d604Sbonwick static int zopt_ashift = SPA_MINBLOCKSHIFT; 116fa9e4066Sahrens static int zopt_mirrors = 2; 117fa9e4066Sahrens static int zopt_raidz = 4; 11899653d4eSeschrock static int zopt_raidz_parity = 1; 119fa9e4066Sahrens static size_t zopt_vdev_size = SPA_MINDEVSIZE; 120ecc2d604Sbonwick static int zopt_datasets = 7; 121fa9e4066Sahrens static int zopt_threads = 23; 122fa9e4066Sahrens static uint64_t zopt_passtime = 60; /* 60 seconds */ 123fa9e4066Sahrens static uint64_t zopt_killrate = 70; /* 70% kill rate */ 124fa9e4066Sahrens static int zopt_verbose = 0; 125fa9e4066Sahrens static int zopt_init = 1; 126fa9e4066Sahrens static char *zopt_dir = "/tmp"; 127fa9e4066Sahrens static uint64_t zopt_time = 300; /* 5 minutes */ 128fa9e4066Sahrens static int zopt_maxfaults; 129fa9e4066Sahrens 130*b24ab676SJeff Bonwick #define BT_MAGIC 0x123456789abcdefULL 131*b24ab676SJeff Bonwick 132*b24ab676SJeff Bonwick enum ztest_io_type { 133*b24ab676SJeff Bonwick ZTEST_IO_WRITE_TAG, 134*b24ab676SJeff Bonwick ZTEST_IO_WRITE_PATTERN, 135*b24ab676SJeff Bonwick ZTEST_IO_WRITE_ZEROES, 136*b24ab676SJeff Bonwick ZTEST_IO_TRUNCATE, 137*b24ab676SJeff Bonwick ZTEST_IO_SETATTR, 138*b24ab676SJeff Bonwick ZTEST_IO_TYPES 139*b24ab676SJeff Bonwick }; 140*b24ab676SJeff Bonwick 141e05725b1Sbonwick typedef struct ztest_block_tag { 142*b24ab676SJeff Bonwick uint64_t bt_magic; 143e05725b1Sbonwick uint64_t bt_objset; 144e05725b1Sbonwick uint64_t bt_object; 145e05725b1Sbonwick uint64_t bt_offset; 146*b24ab676SJeff Bonwick uint64_t bt_gen; 147e05725b1Sbonwick uint64_t bt_txg; 148*b24ab676SJeff Bonwick uint64_t bt_crtxg; 149e05725b1Sbonwick } ztest_block_tag_t; 150e05725b1Sbonwick 151*b24ab676SJeff Bonwick typedef struct bufwad { 152*b24ab676SJeff Bonwick uint64_t bw_index; 153*b24ab676SJeff Bonwick uint64_t bw_txg; 154*b24ab676SJeff Bonwick uint64_t bw_data; 155*b24ab676SJeff Bonwick } bufwad_t; 156*b24ab676SJeff Bonwick 157*b24ab676SJeff Bonwick /* 158*b24ab676SJeff Bonwick * XXX -- fix zfs range locks to be generic so we can use them here. 159*b24ab676SJeff Bonwick */ 160*b24ab676SJeff Bonwick typedef enum { 161*b24ab676SJeff Bonwick RL_READER, 162*b24ab676SJeff Bonwick RL_WRITER, 163*b24ab676SJeff Bonwick RL_APPEND 164*b24ab676SJeff Bonwick } rl_type_t; 165*b24ab676SJeff Bonwick 166*b24ab676SJeff Bonwick typedef struct rll { 167*b24ab676SJeff Bonwick void *rll_writer; 168*b24ab676SJeff Bonwick int rll_readers; 169*b24ab676SJeff Bonwick mutex_t rll_lock; 170*b24ab676SJeff Bonwick cond_t rll_cv; 171*b24ab676SJeff Bonwick } rll_t; 172*b24ab676SJeff Bonwick 173*b24ab676SJeff Bonwick typedef struct rl { 174*b24ab676SJeff Bonwick uint64_t rl_object; 175*b24ab676SJeff Bonwick uint64_t rl_offset; 176*b24ab676SJeff Bonwick uint64_t rl_size; 177*b24ab676SJeff Bonwick rll_t *rl_lock; 178*b24ab676SJeff Bonwick } rl_t; 179*b24ab676SJeff Bonwick 180*b24ab676SJeff Bonwick #define ZTEST_RANGE_LOCKS 64 181*b24ab676SJeff Bonwick #define ZTEST_OBJECT_LOCKS 64 182*b24ab676SJeff Bonwick 183*b24ab676SJeff Bonwick /* 184*b24ab676SJeff Bonwick * Object descriptor. Used as a template for object lookup/create/remove. 185*b24ab676SJeff Bonwick */ 186*b24ab676SJeff Bonwick typedef struct ztest_od { 187*b24ab676SJeff Bonwick uint64_t od_dir; 188*b24ab676SJeff Bonwick uint64_t od_object; 189*b24ab676SJeff Bonwick dmu_object_type_t od_type; 190*b24ab676SJeff Bonwick dmu_object_type_t od_crtype; 191*b24ab676SJeff Bonwick uint64_t od_blocksize; 192*b24ab676SJeff Bonwick uint64_t od_crblocksize; 193*b24ab676SJeff Bonwick uint64_t od_gen; 194*b24ab676SJeff Bonwick uint64_t od_crgen; 195*b24ab676SJeff Bonwick char od_name[MAXNAMELEN]; 196*b24ab676SJeff Bonwick } ztest_od_t; 197fa9e4066Sahrens 198*b24ab676SJeff Bonwick /* 199*b24ab676SJeff Bonwick * Per-dataset state. 200*b24ab676SJeff Bonwick */ 201*b24ab676SJeff Bonwick typedef struct ztest_ds { 202*b24ab676SJeff Bonwick objset_t *zd_os; 203*b24ab676SJeff Bonwick zilog_t *zd_zilog; 204*b24ab676SJeff Bonwick uint64_t zd_seq; 205*b24ab676SJeff Bonwick ztest_od_t *zd_od; /* debugging aid */ 206*b24ab676SJeff Bonwick char zd_name[MAXNAMELEN]; 207*b24ab676SJeff Bonwick mutex_t zd_dirobj_lock; 208*b24ab676SJeff Bonwick rll_t zd_object_lock[ZTEST_OBJECT_LOCKS]; 209*b24ab676SJeff Bonwick rll_t zd_range_lock[ZTEST_RANGE_LOCKS]; 210*b24ab676SJeff Bonwick } ztest_ds_t; 211*b24ab676SJeff Bonwick 212*b24ab676SJeff Bonwick /* 213*b24ab676SJeff Bonwick * Per-iteration state. 214*b24ab676SJeff Bonwick */ 215*b24ab676SJeff Bonwick typedef void ztest_func_t(ztest_ds_t *zd, uint64_t id); 216*b24ab676SJeff Bonwick 217*b24ab676SJeff Bonwick typedef struct ztest_info { 218*b24ab676SJeff Bonwick ztest_func_t *zi_func; /* test function */ 219*b24ab676SJeff Bonwick uint64_t zi_iters; /* iterations per execution */ 220*b24ab676SJeff Bonwick uint64_t *zi_interval; /* execute every <interval> seconds */ 221*b24ab676SJeff Bonwick uint64_t zi_call_count; /* per-pass count */ 222*b24ab676SJeff Bonwick uint64_t zi_call_time; /* per-pass time */ 223*b24ab676SJeff Bonwick uint64_t zi_call_next; /* next time to call this function */ 224*b24ab676SJeff Bonwick } ztest_info_t; 225fa9e4066Sahrens 226fa9e4066Sahrens /* 227fa9e4066Sahrens * Note: these aren't static because we want dladdr() to work. 228fa9e4066Sahrens */ 229fa9e4066Sahrens ztest_func_t ztest_dmu_read_write; 230fa9e4066Sahrens ztest_func_t ztest_dmu_write_parallel; 231fa9e4066Sahrens ztest_func_t ztest_dmu_object_alloc_free; 232d20e665cSRicardo M. Correia ztest_func_t ztest_dmu_commit_callbacks; 233fa9e4066Sahrens ztest_func_t ztest_zap; 234fa9e4066Sahrens ztest_func_t ztest_zap_parallel; 235*b24ab676SJeff Bonwick ztest_func_t ztest_zil_commit; 236*b24ab676SJeff Bonwick ztest_func_t ztest_dmu_read_write_zcopy; 237fa9e4066Sahrens ztest_func_t ztest_dmu_objset_create_destroy; 238*b24ab676SJeff Bonwick ztest_func_t ztest_dmu_prealloc; 239*b24ab676SJeff Bonwick ztest_func_t ztest_fzap; 240fa9e4066Sahrens ztest_func_t ztest_dmu_snapshot_create_destroy; 241*b24ab676SJeff Bonwick ztest_func_t ztest_dsl_prop_get_set; 242*b24ab676SJeff Bonwick ztest_func_t ztest_spa_prop_get_set; 243fa9e4066Sahrens ztest_func_t ztest_spa_create_destroy; 244fa9e4066Sahrens ztest_func_t ztest_fault_inject; 245*b24ab676SJeff Bonwick ztest_func_t ztest_ddt_repair; 246*b24ab676SJeff Bonwick ztest_func_t ztest_dmu_snapshot_hold; 247e14bb325SJeff Bonwick ztest_func_t ztest_spa_rename; 248*b24ab676SJeff Bonwick ztest_func_t ztest_scrub; 249*b24ab676SJeff Bonwick ztest_func_t ztest_dsl_dataset_promote_busy; 250fa9e4066Sahrens ztest_func_t ztest_vdev_attach_detach; 251fa9e4066Sahrens ztest_func_t ztest_vdev_LUN_growth; 252fa9e4066Sahrens ztest_func_t ztest_vdev_add_remove; 253e14bb325SJeff Bonwick ztest_func_t ztest_vdev_aux_add_remove; 254fa9e4066Sahrens 255*b24ab676SJeff Bonwick uint64_t zopt_always = 0ULL * NANOSEC; /* all the time */ 256*b24ab676SJeff Bonwick uint64_t zopt_incessant = 1ULL * NANOSEC / 10; /* every 1/10 second */ 257*b24ab676SJeff Bonwick uint64_t zopt_often = 1ULL * NANOSEC; /* every second */ 258*b24ab676SJeff Bonwick uint64_t zopt_sometimes = 10ULL * NANOSEC; /* every 10 seconds */ 259*b24ab676SJeff Bonwick uint64_t zopt_rarely = 60ULL * NANOSEC; /* every 60 seconds */ 260fa9e4066Sahrens 261fa9e4066Sahrens ztest_info_t ztest_info[] = { 262e05725b1Sbonwick { ztest_dmu_read_write, 1, &zopt_always }, 263*b24ab676SJeff Bonwick { ztest_dmu_write_parallel, 10, &zopt_always }, 264e05725b1Sbonwick { ztest_dmu_object_alloc_free, 1, &zopt_always }, 265*b24ab676SJeff Bonwick { ztest_dmu_commit_callbacks, 1, &zopt_always }, 266e05725b1Sbonwick { ztest_zap, 30, &zopt_always }, 267e05725b1Sbonwick { ztest_zap_parallel, 100, &zopt_always }, 268*b24ab676SJeff Bonwick { ztest_zil_commit, 1, &zopt_incessant }, 269*b24ab676SJeff Bonwick { ztest_dmu_read_write_zcopy, 1, &zopt_often }, 270*b24ab676SJeff Bonwick { ztest_dmu_objset_create_destroy, 1, &zopt_often }, 271*b24ab676SJeff Bonwick { ztest_dsl_prop_get_set, 1, &zopt_often }, 272*b24ab676SJeff Bonwick { ztest_spa_prop_get_set, 1, &zopt_sometimes }, 273*b24ab676SJeff Bonwick #if 0 274*b24ab676SJeff Bonwick { ztest_dmu_prealloc, 1, &zopt_sometimes }, 275*b24ab676SJeff Bonwick #endif 276*b24ab676SJeff Bonwick { ztest_fzap, 1, &zopt_sometimes }, 277*b24ab676SJeff Bonwick { ztest_dmu_snapshot_create_destroy, 1, &zopt_sometimes }, 278*b24ab676SJeff Bonwick { ztest_spa_create_destroy, 1, &zopt_sometimes }, 279e05725b1Sbonwick { ztest_fault_inject, 1, &zopt_sometimes }, 280*b24ab676SJeff Bonwick { ztest_ddt_repair, 1, &zopt_sometimes }, 2815c987a37SChris Kirby { ztest_dmu_snapshot_hold, 1, &zopt_sometimes }, 282e05725b1Sbonwick { ztest_spa_rename, 1, &zopt_rarely }, 283*b24ab676SJeff Bonwick { ztest_scrub, 1, &zopt_rarely }, 284*b24ab676SJeff Bonwick { ztest_dsl_dataset_promote_busy, 1, &zopt_rarely }, 285e14bb325SJeff Bonwick { ztest_vdev_attach_detach, 1, &zopt_rarely }, 286e14bb325SJeff Bonwick { ztest_vdev_LUN_growth, 1, &zopt_rarely }, 287e14bb325SJeff Bonwick { ztest_vdev_add_remove, 1, &zopt_vdevtime }, 288e14bb325SJeff Bonwick { ztest_vdev_aux_add_remove, 1, &zopt_vdevtime }, 289fa9e4066Sahrens }; 290fa9e4066Sahrens 291fa9e4066Sahrens #define ZTEST_FUNCS (sizeof (ztest_info) / sizeof (ztest_info_t)) 292fa9e4066Sahrens 293d20e665cSRicardo M. Correia /* 294d20e665cSRicardo M. Correia * The following struct is used to hold a list of uncalled commit callbacks. 295d20e665cSRicardo M. Correia * The callbacks are ordered by txg number. 296d20e665cSRicardo M. Correia */ 297d20e665cSRicardo M. Correia typedef struct ztest_cb_list { 298d20e665cSRicardo M. Correia mutex_t zcl_callbacks_lock; 299d20e665cSRicardo M. Correia list_t zcl_callbacks; 300d20e665cSRicardo M. Correia } ztest_cb_list_t; 301d20e665cSRicardo M. Correia 302fa9e4066Sahrens /* 303fa9e4066Sahrens * Stuff we need to share writably between parent and child. 304fa9e4066Sahrens */ 305fa9e4066Sahrens typedef struct ztest_shared { 306*b24ab676SJeff Bonwick char *zs_pool; 307*b24ab676SJeff Bonwick spa_t *zs_spa; 308*b24ab676SJeff Bonwick hrtime_t zs_proc_start; 309*b24ab676SJeff Bonwick hrtime_t zs_proc_stop; 310*b24ab676SJeff Bonwick hrtime_t zs_thread_start; 311*b24ab676SJeff Bonwick hrtime_t zs_thread_stop; 312*b24ab676SJeff Bonwick hrtime_t zs_thread_kill; 313*b24ab676SJeff Bonwick uint64_t zs_enospc_count; 31488ecc943SGeorge Wilson uint64_t zs_vdev_next_leaf; 315e14bb325SJeff Bonwick uint64_t zs_vdev_aux; 316fa9e4066Sahrens uint64_t zs_alloc; 317fa9e4066Sahrens uint64_t zs_space; 318*b24ab676SJeff Bonwick mutex_t zs_vdev_lock; 319*b24ab676SJeff Bonwick rwlock_t zs_name_lock; 320fa9e4066Sahrens ztest_info_t zs_info[ZTEST_FUNCS]; 321*b24ab676SJeff Bonwick ztest_ds_t zs_zd[]; 322fa9e4066Sahrens } ztest_shared_t; 323fa9e4066Sahrens 324*b24ab676SJeff Bonwick #define ID_PARALLEL -1ULL 325*b24ab676SJeff Bonwick 326fa9e4066Sahrens static char ztest_dev_template[] = "%s/%s.%llua"; 327e14bb325SJeff Bonwick static char ztest_aux_template[] = "%s/%s.%s.%llu"; 328*b24ab676SJeff Bonwick ztest_shared_t *ztest_shared; 329*b24ab676SJeff Bonwick uint64_t *ztest_seq; 330fa9e4066Sahrens 331fa9e4066Sahrens static int ztest_random_fd; 332fa9e4066Sahrens static int ztest_dump_core = 1; 333fa9e4066Sahrens 334e14bb325SJeff Bonwick static boolean_t ztest_exiting; 3350a4e9518Sgw 336d20e665cSRicardo M. Correia /* Global commit callback list */ 337d20e665cSRicardo M. Correia static ztest_cb_list_t zcl; 338d20e665cSRicardo M. Correia 339e05725b1Sbonwick extern uint64_t metaslab_gang_bang; 340d6e555bdSGeorge Wilson extern uint64_t metaslab_df_alloc_threshold; 341*b24ab676SJeff Bonwick static uint64_t metaslab_sz; 342fa9e4066Sahrens 343*b24ab676SJeff Bonwick enum ztest_object { 344*b24ab676SJeff Bonwick ZTEST_META_DNODE = 0, 345*b24ab676SJeff Bonwick ZTEST_DIROBJ, 346*b24ab676SJeff Bonwick ZTEST_OBJECTS 347*b24ab676SJeff Bonwick }; 348fa9e4066Sahrens 3491ce825d8Sraf static void usage(boolean_t) __NORETURN; 350f1b4288bSvb 351fa9e4066Sahrens /* 352fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 353fa9e4066Sahrens * debugging facilities. 354fa9e4066Sahrens */ 355fa9e4066Sahrens const char * 356fa9e4066Sahrens _umem_debug_init() 357fa9e4066Sahrens { 358fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 359fa9e4066Sahrens } 360fa9e4066Sahrens 361fa9e4066Sahrens const char * 362fa9e4066Sahrens _umem_logging_init(void) 363fa9e4066Sahrens { 364fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 365fa9e4066Sahrens } 366fa9e4066Sahrens 367fa9e4066Sahrens #define FATAL_MSG_SZ 1024 368fa9e4066Sahrens 369fa9e4066Sahrens char *fatal_msg; 370fa9e4066Sahrens 371fa9e4066Sahrens static void 372fa9e4066Sahrens fatal(int do_perror, char *message, ...) 373fa9e4066Sahrens { 374fa9e4066Sahrens va_list args; 375fa9e4066Sahrens int save_errno = errno; 376fa9e4066Sahrens char buf[FATAL_MSG_SZ]; 377fa9e4066Sahrens 378fa9e4066Sahrens (void) fflush(stdout); 379fa9e4066Sahrens 380fa9e4066Sahrens va_start(args, message); 381fa9e4066Sahrens (void) sprintf(buf, "ztest: "); 382fa9e4066Sahrens /* LINTED */ 383fa9e4066Sahrens (void) vsprintf(buf + strlen(buf), message, args); 384fa9e4066Sahrens va_end(args); 385fa9e4066Sahrens if (do_perror) { 386fa9e4066Sahrens (void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf), 387fa9e4066Sahrens ": %s", strerror(save_errno)); 388fa9e4066Sahrens } 389fa9e4066Sahrens (void) fprintf(stderr, "%s\n", buf); 390fa9e4066Sahrens fatal_msg = buf; /* to ease debugging */ 391fa9e4066Sahrens if (ztest_dump_core) 392fa9e4066Sahrens abort(); 393fa9e4066Sahrens exit(3); 394fa9e4066Sahrens } 395fa9e4066Sahrens 396fa9e4066Sahrens static int 397fa9e4066Sahrens str2shift(const char *buf) 398fa9e4066Sahrens { 399fa9e4066Sahrens const char *ends = "BKMGTPEZ"; 400fa9e4066Sahrens int i; 401fa9e4066Sahrens 402fa9e4066Sahrens if (buf[0] == '\0') 403fa9e4066Sahrens return (0); 404fa9e4066Sahrens for (i = 0; i < strlen(ends); i++) { 405fa9e4066Sahrens if (toupper(buf[0]) == ends[i]) 406fa9e4066Sahrens break; 407fa9e4066Sahrens } 408f1b4288bSvb if (i == strlen(ends)) { 409f1b4288bSvb (void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", 410f1b4288bSvb buf); 411f1b4288bSvb usage(B_FALSE); 412f1b4288bSvb } 413fa9e4066Sahrens if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0')) { 414fa9e4066Sahrens return (10*i); 415fa9e4066Sahrens } 416f1b4288bSvb (void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf); 417f1b4288bSvb usage(B_FALSE); 418f1b4288bSvb /* NOTREACHED */ 419fa9e4066Sahrens } 420fa9e4066Sahrens 421fa9e4066Sahrens static uint64_t 422fa9e4066Sahrens nicenumtoull(const char *buf) 423fa9e4066Sahrens { 424fa9e4066Sahrens char *end; 425fa9e4066Sahrens uint64_t val; 426fa9e4066Sahrens 427fa9e4066Sahrens val = strtoull(buf, &end, 0); 428fa9e4066Sahrens if (end == buf) { 429f1b4288bSvb (void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf); 430f1b4288bSvb usage(B_FALSE); 431fa9e4066Sahrens } else if (end[0] == '.') { 432fa9e4066Sahrens double fval = strtod(buf, &end); 433fa9e4066Sahrens fval *= pow(2, str2shift(end)); 434f1b4288bSvb if (fval > UINT64_MAX) { 435f1b4288bSvb (void) fprintf(stderr, "ztest: value too large: %s\n", 436f1b4288bSvb buf); 437f1b4288bSvb usage(B_FALSE); 438f1b4288bSvb } 439fa9e4066Sahrens val = (uint64_t)fval; 440fa9e4066Sahrens } else { 441fa9e4066Sahrens int shift = str2shift(end); 442f1b4288bSvb if (shift >= 64 || (val << shift) >> shift != val) { 443f1b4288bSvb (void) fprintf(stderr, "ztest: value too large: %s\n", 444f1b4288bSvb buf); 445f1b4288bSvb usage(B_FALSE); 446f1b4288bSvb } 447fa9e4066Sahrens val <<= shift; 448fa9e4066Sahrens } 449fa9e4066Sahrens return (val); 450fa9e4066Sahrens } 451fa9e4066Sahrens 452fa9e4066Sahrens static void 453f1b4288bSvb usage(boolean_t requested) 454fa9e4066Sahrens { 455fa9e4066Sahrens char nice_vdev_size[10]; 456fa9e4066Sahrens char nice_gang_bang[10]; 457f1b4288bSvb FILE *fp = requested ? stdout : stderr; 458fa9e4066Sahrens 459fa9e4066Sahrens nicenum(zopt_vdev_size, nice_vdev_size); 460e05725b1Sbonwick nicenum(metaslab_gang_bang, nice_gang_bang); 461fa9e4066Sahrens 462f1b4288bSvb (void) fprintf(fp, "Usage: %s\n" 463fa9e4066Sahrens "\t[-v vdevs (default: %llu)]\n" 464fa9e4066Sahrens "\t[-s size_of_each_vdev (default: %s)]\n" 465ecc2d604Sbonwick "\t[-a alignment_shift (default: %d) (use 0 for random)]\n" 466fa9e4066Sahrens "\t[-m mirror_copies (default: %d)]\n" 467fa9e4066Sahrens "\t[-r raidz_disks (default: %d)]\n" 46899653d4eSeschrock "\t[-R raidz_parity (default: %d)]\n" 469fa9e4066Sahrens "\t[-d datasets (default: %d)]\n" 470fa9e4066Sahrens "\t[-t threads (default: %d)]\n" 471fa9e4066Sahrens "\t[-g gang_block_threshold (default: %s)]\n" 472fa9e4066Sahrens "\t[-i initialize pool i times (default: %d)]\n" 473fa9e4066Sahrens "\t[-k kill percentage (default: %llu%%)]\n" 474fa9e4066Sahrens "\t[-p pool_name (default: %s)]\n" 475fa9e4066Sahrens "\t[-f file directory for vdev files (default: %s)]\n" 476fa9e4066Sahrens "\t[-V(erbose)] (use multiple times for ever more blather)\n" 477ecc2d604Sbonwick "\t[-E(xisting)] (use existing pool instead of creating new one)\n" 478fa9e4066Sahrens "\t[-T time] total run time (default: %llu sec)\n" 479fa9e4066Sahrens "\t[-P passtime] time per pass (default: %llu sec)\n" 480f1b4288bSvb "\t[-h] (print help)\n" 481fa9e4066Sahrens "", 482fa9e4066Sahrens cmdname, 4830a4e9518Sgw (u_longlong_t)zopt_vdevs, /* -v */ 4840a4e9518Sgw nice_vdev_size, /* -s */ 4850a4e9518Sgw zopt_ashift, /* -a */ 4860a4e9518Sgw zopt_mirrors, /* -m */ 4870a4e9518Sgw zopt_raidz, /* -r */ 4880a4e9518Sgw zopt_raidz_parity, /* -R */ 4890a4e9518Sgw zopt_datasets, /* -d */ 4900a4e9518Sgw zopt_threads, /* -t */ 4910a4e9518Sgw nice_gang_bang, /* -g */ 4920a4e9518Sgw zopt_init, /* -i */ 4930a4e9518Sgw (u_longlong_t)zopt_killrate, /* -k */ 4940a4e9518Sgw zopt_pool, /* -p */ 4950a4e9518Sgw zopt_dir, /* -f */ 4960a4e9518Sgw (u_longlong_t)zopt_time, /* -T */ 497e14bb325SJeff Bonwick (u_longlong_t)zopt_passtime); /* -P */ 498f1b4288bSvb exit(requested ? 0 : 1); 499fa9e4066Sahrens } 500fa9e4066Sahrens 501fa9e4066Sahrens static void 502fa9e4066Sahrens process_options(int argc, char **argv) 503fa9e4066Sahrens { 504fa9e4066Sahrens int opt; 505fa9e4066Sahrens uint64_t value; 506fa9e4066Sahrens 507fa9e4066Sahrens /* By default, test gang blocks for blocks 32K and greater */ 508e05725b1Sbonwick metaslab_gang_bang = 32 << 10; 509fa9e4066Sahrens 510fa9e4066Sahrens while ((opt = getopt(argc, argv, 511e14bb325SJeff Bonwick "v:s:a:m:r:R:d:t:g:i:k:p:f:VET:P:h")) != EOF) { 512fa9e4066Sahrens value = 0; 513fa9e4066Sahrens switch (opt) { 5143d7072f8Seschrock case 'v': 5153d7072f8Seschrock case 's': 5163d7072f8Seschrock case 'a': 5173d7072f8Seschrock case 'm': 5183d7072f8Seschrock case 'r': 5193d7072f8Seschrock case 'R': 5203d7072f8Seschrock case 'd': 5213d7072f8Seschrock case 't': 5223d7072f8Seschrock case 'g': 5233d7072f8Seschrock case 'i': 5243d7072f8Seschrock case 'k': 5253d7072f8Seschrock case 'T': 5263d7072f8Seschrock case 'P': 527fa9e4066Sahrens value = nicenumtoull(optarg); 528fa9e4066Sahrens } 529fa9e4066Sahrens switch (opt) { 5303d7072f8Seschrock case 'v': 531fa9e4066Sahrens zopt_vdevs = value; 532fa9e4066Sahrens break; 5333d7072f8Seschrock case 's': 534fa9e4066Sahrens zopt_vdev_size = MAX(SPA_MINDEVSIZE, value); 535fa9e4066Sahrens break; 5363d7072f8Seschrock case 'a': 537ecc2d604Sbonwick zopt_ashift = value; 538ecc2d604Sbonwick break; 5393d7072f8Seschrock case 'm': 540fa9e4066Sahrens zopt_mirrors = value; 541fa9e4066Sahrens break; 5423d7072f8Seschrock case 'r': 543fa9e4066Sahrens zopt_raidz = MAX(1, value); 544fa9e4066Sahrens break; 5453d7072f8Seschrock case 'R': 546f94275ceSAdam Leventhal zopt_raidz_parity = MIN(MAX(value, 1), 3); 54799653d4eSeschrock break; 5483d7072f8Seschrock case 'd': 549ecc2d604Sbonwick zopt_datasets = MAX(1, value); 550fa9e4066Sahrens break; 5513d7072f8Seschrock case 't': 552fa9e4066Sahrens zopt_threads = MAX(1, value); 553fa9e4066Sahrens break; 5543d7072f8Seschrock case 'g': 555e05725b1Sbonwick metaslab_gang_bang = MAX(SPA_MINBLOCKSIZE << 1, value); 556fa9e4066Sahrens break; 5573d7072f8Seschrock case 'i': 558fa9e4066Sahrens zopt_init = value; 559fa9e4066Sahrens break; 5603d7072f8Seschrock case 'k': 561fa9e4066Sahrens zopt_killrate = value; 562fa9e4066Sahrens break; 5633d7072f8Seschrock case 'p': 564fa9e4066Sahrens zopt_pool = strdup(optarg); 565fa9e4066Sahrens break; 5663d7072f8Seschrock case 'f': 567fa9e4066Sahrens zopt_dir = strdup(optarg); 568fa9e4066Sahrens break; 5693d7072f8Seschrock case 'V': 570fa9e4066Sahrens zopt_verbose++; 571fa9e4066Sahrens break; 5723d7072f8Seschrock case 'E': 573fa9e4066Sahrens zopt_init = 0; 574fa9e4066Sahrens break; 5753d7072f8Seschrock case 'T': 576fa9e4066Sahrens zopt_time = value; 577fa9e4066Sahrens break; 5783d7072f8Seschrock case 'P': 579fa9e4066Sahrens zopt_passtime = MAX(1, value); 580fa9e4066Sahrens break; 5813d7072f8Seschrock case 'h': 582f1b4288bSvb usage(B_TRUE); 583f1b4288bSvb break; 5843d7072f8Seschrock case '?': 5853d7072f8Seschrock default: 586f1b4288bSvb usage(B_FALSE); 587fa9e4066Sahrens break; 588fa9e4066Sahrens } 589fa9e4066Sahrens } 590fa9e4066Sahrens 59199653d4eSeschrock zopt_raidz_parity = MIN(zopt_raidz_parity, zopt_raidz - 1); 59299653d4eSeschrock 593*b24ab676SJeff Bonwick zopt_vdevtime = (zopt_vdevs > 0 ? zopt_time * NANOSEC / zopt_vdevs : 594*b24ab676SJeff Bonwick UINT64_MAX >> 2); 59599653d4eSeschrock zopt_maxfaults = MAX(zopt_mirrors, 1) * (zopt_raidz_parity + 1) - 1; 596fa9e4066Sahrens } 597fa9e4066Sahrens 598*b24ab676SJeff Bonwick static void 599*b24ab676SJeff Bonwick ztest_kill(ztest_shared_t *zs) 600*b24ab676SJeff Bonwick { 601*b24ab676SJeff Bonwick zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(zs->zs_spa)); 602*b24ab676SJeff Bonwick zs->zs_space = metaslab_class_get_space(spa_normal_class(zs->zs_spa)); 603*b24ab676SJeff Bonwick (void) kill(getpid(), SIGKILL); 604*b24ab676SJeff Bonwick } 605*b24ab676SJeff Bonwick 606*b24ab676SJeff Bonwick static uint64_t 607*b24ab676SJeff Bonwick ztest_random(uint64_t range) 608*b24ab676SJeff Bonwick { 609*b24ab676SJeff Bonwick uint64_t r; 610*b24ab676SJeff Bonwick 611*b24ab676SJeff Bonwick if (range == 0) 612*b24ab676SJeff Bonwick return (0); 613*b24ab676SJeff Bonwick 614*b24ab676SJeff Bonwick if (read(ztest_random_fd, &r, sizeof (r)) != sizeof (r)) 615*b24ab676SJeff Bonwick fatal(1, "short read from /dev/urandom"); 616*b24ab676SJeff Bonwick 617*b24ab676SJeff Bonwick return (r % range); 618*b24ab676SJeff Bonwick } 619*b24ab676SJeff Bonwick 620*b24ab676SJeff Bonwick /* ARGSUSED */ 621*b24ab676SJeff Bonwick static void 622*b24ab676SJeff Bonwick ztest_record_enospc(const char *s) 623*b24ab676SJeff Bonwick { 624*b24ab676SJeff Bonwick ztest_shared->zs_enospc_count++; 625*b24ab676SJeff Bonwick } 626*b24ab676SJeff Bonwick 627ecc2d604Sbonwick static uint64_t 628ecc2d604Sbonwick ztest_get_ashift(void) 629ecc2d604Sbonwick { 630ecc2d604Sbonwick if (zopt_ashift == 0) 631ecc2d604Sbonwick return (SPA_MINBLOCKSHIFT + ztest_random(3)); 632ecc2d604Sbonwick return (zopt_ashift); 633ecc2d604Sbonwick } 634ecc2d604Sbonwick 635fa9e4066Sahrens static nvlist_t * 636e14bb325SJeff Bonwick make_vdev_file(char *path, char *aux, size_t size, uint64_t ashift) 637fa9e4066Sahrens { 638e14bb325SJeff Bonwick char pathbuf[MAXPATHLEN]; 639fa9e4066Sahrens uint64_t vdev; 640fa9e4066Sahrens nvlist_t *file; 641fa9e4066Sahrens 642e14bb325SJeff Bonwick if (ashift == 0) 643e14bb325SJeff Bonwick ashift = ztest_get_ashift(); 644e14bb325SJeff Bonwick 645e14bb325SJeff Bonwick if (path == NULL) { 646e14bb325SJeff Bonwick path = pathbuf; 647fa9e4066Sahrens 648e14bb325SJeff Bonwick if (aux != NULL) { 649e14bb325SJeff Bonwick vdev = ztest_shared->zs_vdev_aux; 650e14bb325SJeff Bonwick (void) sprintf(path, ztest_aux_template, 651e14bb325SJeff Bonwick zopt_dir, zopt_pool, aux, vdev); 652e14bb325SJeff Bonwick } else { 65388ecc943SGeorge Wilson vdev = ztest_shared->zs_vdev_next_leaf++; 654e14bb325SJeff Bonwick (void) sprintf(path, ztest_dev_template, 655e14bb325SJeff Bonwick zopt_dir, zopt_pool, vdev); 656e14bb325SJeff Bonwick } 657e14bb325SJeff Bonwick } 658e14bb325SJeff Bonwick 659e14bb325SJeff Bonwick if (size != 0) { 660e14bb325SJeff Bonwick int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666); 661fa9e4066Sahrens if (fd == -1) 662e14bb325SJeff Bonwick fatal(1, "can't open %s", path); 663fa9e4066Sahrens if (ftruncate(fd, size) != 0) 664e14bb325SJeff Bonwick fatal(1, "can't ftruncate %s", path); 665fa9e4066Sahrens (void) close(fd); 666fa9e4066Sahrens } 667fa9e4066Sahrens 668fa9e4066Sahrens VERIFY(nvlist_alloc(&file, NV_UNIQUE_NAME, 0) == 0); 669fa9e4066Sahrens VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_TYPE, VDEV_TYPE_FILE) == 0); 670e14bb325SJeff Bonwick VERIFY(nvlist_add_string(file, ZPOOL_CONFIG_PATH, path) == 0); 671ecc2d604Sbonwick VERIFY(nvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift) == 0); 672fa9e4066Sahrens 673fa9e4066Sahrens return (file); 674fa9e4066Sahrens } 675fa9e4066Sahrens 676fa9e4066Sahrens static nvlist_t * 677e14bb325SJeff Bonwick make_vdev_raidz(char *path, char *aux, size_t size, uint64_t ashift, int r) 678fa9e4066Sahrens { 679fa9e4066Sahrens nvlist_t *raidz, **child; 680fa9e4066Sahrens int c; 681fa9e4066Sahrens 682fa9e4066Sahrens if (r < 2) 683e14bb325SJeff Bonwick return (make_vdev_file(path, aux, size, ashift)); 684fa9e4066Sahrens child = umem_alloc(r * sizeof (nvlist_t *), UMEM_NOFAIL); 685fa9e4066Sahrens 686fa9e4066Sahrens for (c = 0; c < r; c++) 687e14bb325SJeff Bonwick child[c] = make_vdev_file(path, aux, size, ashift); 688fa9e4066Sahrens 689fa9e4066Sahrens VERIFY(nvlist_alloc(&raidz, NV_UNIQUE_NAME, 0) == 0); 690fa9e4066Sahrens VERIFY(nvlist_add_string(raidz, ZPOOL_CONFIG_TYPE, 691fa9e4066Sahrens VDEV_TYPE_RAIDZ) == 0); 69299653d4eSeschrock VERIFY(nvlist_add_uint64(raidz, ZPOOL_CONFIG_NPARITY, 69399653d4eSeschrock zopt_raidz_parity) == 0); 694fa9e4066Sahrens VERIFY(nvlist_add_nvlist_array(raidz, ZPOOL_CONFIG_CHILDREN, 695fa9e4066Sahrens child, r) == 0); 696fa9e4066Sahrens 697fa9e4066Sahrens for (c = 0; c < r; c++) 698fa9e4066Sahrens nvlist_free(child[c]); 699fa9e4066Sahrens 700fa9e4066Sahrens umem_free(child, r * sizeof (nvlist_t *)); 701fa9e4066Sahrens 702fa9e4066Sahrens return (raidz); 703fa9e4066Sahrens } 704fa9e4066Sahrens 705fa9e4066Sahrens static nvlist_t * 706e14bb325SJeff Bonwick make_vdev_mirror(char *path, char *aux, size_t size, uint64_t ashift, 70731157203SJeff Bonwick int r, int m) 708fa9e4066Sahrens { 709fa9e4066Sahrens nvlist_t *mirror, **child; 710fa9e4066Sahrens int c; 711fa9e4066Sahrens 712fa9e4066Sahrens if (m < 1) 713e14bb325SJeff Bonwick return (make_vdev_raidz(path, aux, size, ashift, r)); 714fa9e4066Sahrens 715fa9e4066Sahrens child = umem_alloc(m * sizeof (nvlist_t *), UMEM_NOFAIL); 716fa9e4066Sahrens 717fa9e4066Sahrens for (c = 0; c < m; c++) 718e14bb325SJeff Bonwick child[c] = make_vdev_raidz(path, aux, size, ashift, r); 719fa9e4066Sahrens 720fa9e4066Sahrens VERIFY(nvlist_alloc(&mirror, NV_UNIQUE_NAME, 0) == 0); 721fa9e4066Sahrens VERIFY(nvlist_add_string(mirror, ZPOOL_CONFIG_TYPE, 722fa9e4066Sahrens VDEV_TYPE_MIRROR) == 0); 723fa9e4066Sahrens VERIFY(nvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN, 724fa9e4066Sahrens child, m) == 0); 725fa9e4066Sahrens 726fa9e4066Sahrens for (c = 0; c < m; c++) 727fa9e4066Sahrens nvlist_free(child[c]); 728fa9e4066Sahrens 729fa9e4066Sahrens umem_free(child, m * sizeof (nvlist_t *)); 730fa9e4066Sahrens 731fa9e4066Sahrens return (mirror); 732fa9e4066Sahrens } 733fa9e4066Sahrens 734fa9e4066Sahrens static nvlist_t * 735e14bb325SJeff Bonwick make_vdev_root(char *path, char *aux, size_t size, uint64_t ashift, 736e14bb325SJeff Bonwick int log, int r, int m, int t) 737fa9e4066Sahrens { 738fa9e4066Sahrens nvlist_t *root, **child; 739fa9e4066Sahrens int c; 740fa9e4066Sahrens 741fa9e4066Sahrens ASSERT(t > 0); 742fa9e4066Sahrens 743fa9e4066Sahrens child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL); 744fa9e4066Sahrens 74531157203SJeff Bonwick for (c = 0; c < t; c++) { 74631157203SJeff Bonwick child[c] = make_vdev_mirror(path, aux, size, ashift, r, m); 74731157203SJeff Bonwick VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 74831157203SJeff Bonwick log) == 0); 74931157203SJeff Bonwick } 750fa9e4066Sahrens 751fa9e4066Sahrens VERIFY(nvlist_alloc(&root, NV_UNIQUE_NAME, 0) == 0); 752fa9e4066Sahrens VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0); 753e14bb325SJeff Bonwick VERIFY(nvlist_add_nvlist_array(root, aux ? aux : ZPOOL_CONFIG_CHILDREN, 754fa9e4066Sahrens child, t) == 0); 755fa9e4066Sahrens 756fa9e4066Sahrens for (c = 0; c < t; c++) 757fa9e4066Sahrens nvlist_free(child[c]); 758fa9e4066Sahrens 759fa9e4066Sahrens umem_free(child, t * sizeof (nvlist_t *)); 760fa9e4066Sahrens 761fa9e4066Sahrens return (root); 762fa9e4066Sahrens } 763fa9e4066Sahrens 764*b24ab676SJeff Bonwick static int 765*b24ab676SJeff Bonwick ztest_random_blocksize(void) 766fa9e4066Sahrens { 767*b24ab676SJeff Bonwick return (1 << (SPA_MINBLOCKSHIFT + 768*b24ab676SJeff Bonwick ztest_random(SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT + 1))); 769*b24ab676SJeff Bonwick } 770fa9e4066Sahrens 771*b24ab676SJeff Bonwick static int 772*b24ab676SJeff Bonwick ztest_random_ibshift(void) 773*b24ab676SJeff Bonwick { 774*b24ab676SJeff Bonwick return (DN_MIN_INDBLKSHIFT + 775*b24ab676SJeff Bonwick ztest_random(DN_MAX_INDBLKSHIFT - DN_MIN_INDBLKSHIFT + 1)); 776fa9e4066Sahrens } 777fa9e4066Sahrens 778*b24ab676SJeff Bonwick static uint64_t 779*b24ab676SJeff Bonwick ztest_random_vdev_top(spa_t *spa, boolean_t log_ok) 780fa9e4066Sahrens { 781*b24ab676SJeff Bonwick uint64_t top; 782*b24ab676SJeff Bonwick vdev_t *rvd = spa->spa_root_vdev; 783*b24ab676SJeff Bonwick vdev_t *tvd; 784fa9e4066Sahrens 785*b24ab676SJeff Bonwick ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0); 786fa9e4066Sahrens 787*b24ab676SJeff Bonwick do { 788*b24ab676SJeff Bonwick top = ztest_random(rvd->vdev_children); 789*b24ab676SJeff Bonwick tvd = rvd->vdev_child[top]; 790*b24ab676SJeff Bonwick } while (tvd->vdev_ishole || (tvd->vdev_islog && !log_ok) || 791*b24ab676SJeff Bonwick tvd->vdev_mg == NULL || tvd->vdev_mg->mg_class == NULL); 792fa9e4066Sahrens 793*b24ab676SJeff Bonwick return (top); 794fa9e4066Sahrens } 795fa9e4066Sahrens 796*b24ab676SJeff Bonwick static uint64_t 797*b24ab676SJeff Bonwick ztest_random_dsl_prop(zfs_prop_t prop) 798fa9e4066Sahrens { 799*b24ab676SJeff Bonwick uint64_t value; 800*b24ab676SJeff Bonwick 801*b24ab676SJeff Bonwick do { 802*b24ab676SJeff Bonwick value = zfs_prop_random_value(prop, ztest_random(-1ULL)); 803*b24ab676SJeff Bonwick } while (prop == ZFS_PROP_CHECKSUM && value == ZIO_CHECKSUM_OFF); 804*b24ab676SJeff Bonwick 805*b24ab676SJeff Bonwick return (value); 806fa9e4066Sahrens } 807fa9e4066Sahrens 808fa9e4066Sahrens static int 809*b24ab676SJeff Bonwick ztest_dsl_prop_set_uint64(char *osname, zfs_prop_t prop, uint64_t value, 810*b24ab676SJeff Bonwick boolean_t inherit) 811fa9e4066Sahrens { 812*b24ab676SJeff Bonwick const char *propname = zfs_prop_to_name(prop); 813*b24ab676SJeff Bonwick const char *valname; 814*b24ab676SJeff Bonwick char setpoint[MAXPATHLEN]; 815*b24ab676SJeff Bonwick uint64_t curval; 816fa9e4066Sahrens int error; 817fa9e4066Sahrens 818*b24ab676SJeff Bonwick error = dsl_prop_set(osname, propname, sizeof (value), 819*b24ab676SJeff Bonwick inherit ? 0 : 1, &value); 820fa9e4066Sahrens 821*b24ab676SJeff Bonwick if (error == ENOSPC) { 822*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 823fa9e4066Sahrens return (error); 824fa9e4066Sahrens } 82599653d4eSeschrock ASSERT3U(error, ==, 0); 826fa9e4066Sahrens 827*b24ab676SJeff Bonwick VERIFY3U(dsl_prop_get(osname, propname, sizeof (curval), 828*b24ab676SJeff Bonwick 1, &curval, setpoint), ==, 0); 829*b24ab676SJeff Bonwick 830*b24ab676SJeff Bonwick if (zopt_verbose >= 6) { 831*b24ab676SJeff Bonwick VERIFY(zfs_prop_index_to_string(prop, curval, &valname) == 0); 832*b24ab676SJeff Bonwick (void) printf("%s %s = %s at '%s'\n", 833*b24ab676SJeff Bonwick osname, propname, valname, setpoint); 834fa9e4066Sahrens } 835fa9e4066Sahrens 836fa9e4066Sahrens return (error); 837fa9e4066Sahrens } 838fa9e4066Sahrens 839*b24ab676SJeff Bonwick #if 0 840fa9e4066Sahrens static int 841*b24ab676SJeff Bonwick ztest_spa_prop_set_uint64(ztest_shared_t *zs, zpool_prop_t prop, uint64_t value) 842fa9e4066Sahrens { 843*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 844*b24ab676SJeff Bonwick nvlist_t *props = NULL; 845fa9e4066Sahrens int error; 846fa9e4066Sahrens 847*b24ab676SJeff Bonwick VERIFY(nvlist_alloc(&props, NV_UNIQUE_NAME, 0) == 0); 848*b24ab676SJeff Bonwick VERIFY(nvlist_add_uint64(props, zpool_prop_to_name(prop), value) == 0); 849fa9e4066Sahrens 850*b24ab676SJeff Bonwick error = spa_prop_set(spa, props); 851*b24ab676SJeff Bonwick 852*b24ab676SJeff Bonwick nvlist_free(props); 853*b24ab676SJeff Bonwick 854*b24ab676SJeff Bonwick if (error == ENOSPC) { 855*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 856fa9e4066Sahrens return (error); 857fa9e4066Sahrens } 858*b24ab676SJeff Bonwick ASSERT3U(error, ==, 0); 859fa9e4066Sahrens 860fa9e4066Sahrens return (error); 861fa9e4066Sahrens } 862*b24ab676SJeff Bonwick #endif 863fa9e4066Sahrens 864*b24ab676SJeff Bonwick static void 865*b24ab676SJeff Bonwick ztest_rll_init(rll_t *rll) 866*b24ab676SJeff Bonwick { 867*b24ab676SJeff Bonwick rll->rll_writer = NULL; 868*b24ab676SJeff Bonwick rll->rll_readers = 0; 869*b24ab676SJeff Bonwick VERIFY(_mutex_init(&rll->rll_lock, USYNC_THREAD, NULL) == 0); 870*b24ab676SJeff Bonwick VERIFY(cond_init(&rll->rll_cv, USYNC_THREAD, NULL) == 0); 871*b24ab676SJeff Bonwick } 872fa9e4066Sahrens 873*b24ab676SJeff Bonwick static void 874*b24ab676SJeff Bonwick ztest_rll_destroy(rll_t *rll) 875fa9e4066Sahrens { 876*b24ab676SJeff Bonwick ASSERT(rll->rll_writer == NULL); 877*b24ab676SJeff Bonwick ASSERT(rll->rll_readers == 0); 878*b24ab676SJeff Bonwick VERIFY(_mutex_destroy(&rll->rll_lock) == 0); 879*b24ab676SJeff Bonwick VERIFY(cond_destroy(&rll->rll_cv) == 0); 880*b24ab676SJeff Bonwick } 881fa9e4066Sahrens 882*b24ab676SJeff Bonwick static void 883*b24ab676SJeff Bonwick ztest_rll_lock(rll_t *rll, rl_type_t type) 884*b24ab676SJeff Bonwick { 885*b24ab676SJeff Bonwick VERIFY(mutex_lock(&rll->rll_lock) == 0); 886fa9e4066Sahrens 887*b24ab676SJeff Bonwick if (type == RL_READER) { 888*b24ab676SJeff Bonwick while (rll->rll_writer != NULL) 889*b24ab676SJeff Bonwick (void) cond_wait(&rll->rll_cv, &rll->rll_lock); 890*b24ab676SJeff Bonwick rll->rll_readers++; 891*b24ab676SJeff Bonwick } else { 892*b24ab676SJeff Bonwick while (rll->rll_writer != NULL || rll->rll_readers) 893*b24ab676SJeff Bonwick (void) cond_wait(&rll->rll_cv, &rll->rll_lock); 894*b24ab676SJeff Bonwick rll->rll_writer = curthread; 895*b24ab676SJeff Bonwick } 896fa9e4066Sahrens 897*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&rll->rll_lock) == 0); 898*b24ab676SJeff Bonwick } 899fa9e4066Sahrens 900*b24ab676SJeff Bonwick static void 901*b24ab676SJeff Bonwick ztest_rll_unlock(rll_t *rll) 902*b24ab676SJeff Bonwick { 903*b24ab676SJeff Bonwick VERIFY(mutex_lock(&rll->rll_lock) == 0); 904fa9e4066Sahrens 905*b24ab676SJeff Bonwick if (rll->rll_writer) { 906*b24ab676SJeff Bonwick ASSERT(rll->rll_readers == 0); 907*b24ab676SJeff Bonwick rll->rll_writer = NULL; 908*b24ab676SJeff Bonwick } else { 909*b24ab676SJeff Bonwick ASSERT(rll->rll_readers != 0); 910*b24ab676SJeff Bonwick ASSERT(rll->rll_writer == NULL); 911*b24ab676SJeff Bonwick rll->rll_readers--; 912*b24ab676SJeff Bonwick } 913fa9e4066Sahrens 914*b24ab676SJeff Bonwick if (rll->rll_writer == NULL && rll->rll_readers == 0) 915*b24ab676SJeff Bonwick VERIFY(cond_broadcast(&rll->rll_cv) == 0); 916*b24ab676SJeff Bonwick 917*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&rll->rll_lock) == 0); 918fa9e4066Sahrens } 919fa9e4066Sahrens 920*b24ab676SJeff Bonwick static void 921*b24ab676SJeff Bonwick ztest_object_lock(ztest_ds_t *zd, uint64_t object, rl_type_t type) 92231157203SJeff Bonwick { 923*b24ab676SJeff Bonwick rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)]; 92431157203SJeff Bonwick 925*b24ab676SJeff Bonwick ztest_rll_lock(rll, type); 926*b24ab676SJeff Bonwick } 92731157203SJeff Bonwick 928*b24ab676SJeff Bonwick static void 929*b24ab676SJeff Bonwick ztest_object_unlock(ztest_ds_t *zd, uint64_t object) 930*b24ab676SJeff Bonwick { 931*b24ab676SJeff Bonwick rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)]; 93231157203SJeff Bonwick 933*b24ab676SJeff Bonwick ztest_rll_unlock(rll); 93431157203SJeff Bonwick } 93531157203SJeff Bonwick 936*b24ab676SJeff Bonwick static rl_t * 937*b24ab676SJeff Bonwick ztest_range_lock(ztest_ds_t *zd, uint64_t object, uint64_t offset, 938*b24ab676SJeff Bonwick uint64_t size, rl_type_t type) 93988ecc943SGeorge Wilson { 940*b24ab676SJeff Bonwick uint64_t hash = object ^ (offset % (ZTEST_RANGE_LOCKS + 1)); 941*b24ab676SJeff Bonwick rll_t *rll = &zd->zd_range_lock[hash & (ZTEST_RANGE_LOCKS - 1)]; 942*b24ab676SJeff Bonwick rl_t *rl; 94388ecc943SGeorge Wilson 944*b24ab676SJeff Bonwick rl = umem_alloc(sizeof (*rl), UMEM_NOFAIL); 945*b24ab676SJeff Bonwick rl->rl_object = object; 946*b24ab676SJeff Bonwick rl->rl_offset = offset; 947*b24ab676SJeff Bonwick rl->rl_size = size; 948*b24ab676SJeff Bonwick rl->rl_lock = rll; 94988ecc943SGeorge Wilson 950*b24ab676SJeff Bonwick ztest_rll_lock(rll, type); 95188ecc943SGeorge Wilson 952*b24ab676SJeff Bonwick return (rl); 95388ecc943SGeorge Wilson } 95488ecc943SGeorge Wilson 955*b24ab676SJeff Bonwick static void 956*b24ab676SJeff Bonwick ztest_range_unlock(rl_t *rl) 957fa9e4066Sahrens { 958*b24ab676SJeff Bonwick rll_t *rll = rl->rl_lock; 959fa9e4066Sahrens 960*b24ab676SJeff Bonwick ztest_rll_unlock(rll); 961fa9e4066Sahrens 962*b24ab676SJeff Bonwick umem_free(rl, sizeof (*rl)); 963*b24ab676SJeff Bonwick } 964fa9e4066Sahrens 965*b24ab676SJeff Bonwick static void 966*b24ab676SJeff Bonwick ztest_zd_init(ztest_ds_t *zd, objset_t *os) 967*b24ab676SJeff Bonwick { 968*b24ab676SJeff Bonwick zd->zd_os = os; 969*b24ab676SJeff Bonwick zd->zd_zilog = dmu_objset_zil(os); 970*b24ab676SJeff Bonwick zd->zd_seq = 0; 971*b24ab676SJeff Bonwick dmu_objset_name(os, zd->zd_name); 972fa9e4066Sahrens 973*b24ab676SJeff Bonwick VERIFY(_mutex_init(&zd->zd_dirobj_lock, USYNC_THREAD, NULL) == 0); 974*b24ab676SJeff Bonwick 975*b24ab676SJeff Bonwick for (int l = 0; l < ZTEST_OBJECT_LOCKS; l++) 976*b24ab676SJeff Bonwick ztest_rll_init(&zd->zd_object_lock[l]); 977*b24ab676SJeff Bonwick 978*b24ab676SJeff Bonwick for (int l = 0; l < ZTEST_RANGE_LOCKS; l++) 979*b24ab676SJeff Bonwick ztest_rll_init(&zd->zd_range_lock[l]); 980*b24ab676SJeff Bonwick } 981*b24ab676SJeff Bonwick 982*b24ab676SJeff Bonwick static void 983*b24ab676SJeff Bonwick ztest_zd_fini(ztest_ds_t *zd) 984*b24ab676SJeff Bonwick { 985*b24ab676SJeff Bonwick VERIFY(_mutex_destroy(&zd->zd_dirobj_lock) == 0); 986*b24ab676SJeff Bonwick 987*b24ab676SJeff Bonwick for (int l = 0; l < ZTEST_OBJECT_LOCKS; l++) 988*b24ab676SJeff Bonwick ztest_rll_destroy(&zd->zd_object_lock[l]); 989*b24ab676SJeff Bonwick 990*b24ab676SJeff Bonwick for (int l = 0; l < ZTEST_RANGE_LOCKS; l++) 991*b24ab676SJeff Bonwick ztest_rll_destroy(&zd->zd_range_lock[l]); 992*b24ab676SJeff Bonwick } 993*b24ab676SJeff Bonwick 994*b24ab676SJeff Bonwick #define TXG_MIGHTWAIT (ztest_random(10) == 0 ? TXG_NOWAIT : TXG_WAIT) 995*b24ab676SJeff Bonwick 996*b24ab676SJeff Bonwick static uint64_t 997*b24ab676SJeff Bonwick ztest_tx_assign(dmu_tx_t *tx, uint64_t txg_how, const char *tag) 998*b24ab676SJeff Bonwick { 999*b24ab676SJeff Bonwick uint64_t txg; 1000*b24ab676SJeff Bonwick int error; 1001*b24ab676SJeff Bonwick 1002*b24ab676SJeff Bonwick /* 1003*b24ab676SJeff Bonwick * Attempt to assign tx to some transaction group. 1004*b24ab676SJeff Bonwick */ 1005*b24ab676SJeff Bonwick error = dmu_tx_assign(tx, txg_how); 1006*b24ab676SJeff Bonwick if (error) { 1007*b24ab676SJeff Bonwick if (error == ERESTART) { 1008*b24ab676SJeff Bonwick ASSERT(txg_how == TXG_NOWAIT); 1009*b24ab676SJeff Bonwick dmu_tx_wait(tx); 1010*b24ab676SJeff Bonwick } else { 1011*b24ab676SJeff Bonwick ASSERT3U(error, ==, ENOSPC); 1012*b24ab676SJeff Bonwick ztest_record_enospc(tag); 1013*b24ab676SJeff Bonwick } 1014*b24ab676SJeff Bonwick dmu_tx_abort(tx); 1015*b24ab676SJeff Bonwick return (0); 1016*b24ab676SJeff Bonwick } 1017*b24ab676SJeff Bonwick txg = dmu_tx_get_txg(tx); 1018*b24ab676SJeff Bonwick ASSERT(txg != 0); 1019*b24ab676SJeff Bonwick return (txg); 1020*b24ab676SJeff Bonwick } 1021*b24ab676SJeff Bonwick 1022*b24ab676SJeff Bonwick static void 1023*b24ab676SJeff Bonwick ztest_pattern_set(void *buf, uint64_t size, uint64_t value) 1024*b24ab676SJeff Bonwick { 1025*b24ab676SJeff Bonwick uint64_t *ip = buf; 1026*b24ab676SJeff Bonwick uint64_t *ip_end = (uint64_t *)((uintptr_t)buf + (uintptr_t)size); 1027*b24ab676SJeff Bonwick 1028*b24ab676SJeff Bonwick while (ip < ip_end) 1029*b24ab676SJeff Bonwick *ip++ = value; 1030*b24ab676SJeff Bonwick } 1031*b24ab676SJeff Bonwick 1032*b24ab676SJeff Bonwick static boolean_t 1033*b24ab676SJeff Bonwick ztest_pattern_match(void *buf, uint64_t size, uint64_t value) 1034*b24ab676SJeff Bonwick { 1035*b24ab676SJeff Bonwick uint64_t *ip = buf; 1036*b24ab676SJeff Bonwick uint64_t *ip_end = (uint64_t *)((uintptr_t)buf + (uintptr_t)size); 1037*b24ab676SJeff Bonwick uint64_t diff = 0; 1038*b24ab676SJeff Bonwick 1039*b24ab676SJeff Bonwick while (ip < ip_end) 1040*b24ab676SJeff Bonwick diff |= (value - *ip++); 1041*b24ab676SJeff Bonwick 1042*b24ab676SJeff Bonwick return (diff == 0); 1043*b24ab676SJeff Bonwick } 1044*b24ab676SJeff Bonwick 1045*b24ab676SJeff Bonwick static void 1046*b24ab676SJeff Bonwick ztest_bt_generate(ztest_block_tag_t *bt, objset_t *os, uint64_t object, 1047*b24ab676SJeff Bonwick uint64_t offset, uint64_t gen, uint64_t txg, uint64_t crtxg) 1048*b24ab676SJeff Bonwick { 1049*b24ab676SJeff Bonwick bt->bt_magic = BT_MAGIC; 1050*b24ab676SJeff Bonwick bt->bt_objset = dmu_objset_id(os); 1051*b24ab676SJeff Bonwick bt->bt_object = object; 1052*b24ab676SJeff Bonwick bt->bt_offset = offset; 1053*b24ab676SJeff Bonwick bt->bt_gen = gen; 1054*b24ab676SJeff Bonwick bt->bt_txg = txg; 1055*b24ab676SJeff Bonwick bt->bt_crtxg = crtxg; 1056*b24ab676SJeff Bonwick } 1057*b24ab676SJeff Bonwick 1058*b24ab676SJeff Bonwick static void 1059*b24ab676SJeff Bonwick ztest_bt_verify(ztest_block_tag_t *bt, objset_t *os, uint64_t object, 1060*b24ab676SJeff Bonwick uint64_t offset, uint64_t gen, uint64_t txg, uint64_t crtxg) 1061*b24ab676SJeff Bonwick { 1062*b24ab676SJeff Bonwick ASSERT(bt->bt_magic == BT_MAGIC); 1063*b24ab676SJeff Bonwick ASSERT(bt->bt_objset == dmu_objset_id(os)); 1064*b24ab676SJeff Bonwick ASSERT(bt->bt_object == object); 1065*b24ab676SJeff Bonwick ASSERT(bt->bt_offset == offset); 1066*b24ab676SJeff Bonwick ASSERT(bt->bt_gen <= gen); 1067*b24ab676SJeff Bonwick ASSERT(bt->bt_txg <= txg); 1068*b24ab676SJeff Bonwick ASSERT(bt->bt_crtxg == crtxg); 1069*b24ab676SJeff Bonwick } 1070*b24ab676SJeff Bonwick 1071*b24ab676SJeff Bonwick static ztest_block_tag_t * 1072*b24ab676SJeff Bonwick ztest_bt_bonus(dmu_buf_t *db) 1073*b24ab676SJeff Bonwick { 1074*b24ab676SJeff Bonwick dmu_object_info_t doi; 1075*b24ab676SJeff Bonwick ztest_block_tag_t *bt; 1076*b24ab676SJeff Bonwick 1077*b24ab676SJeff Bonwick dmu_object_info_from_db(db, &doi); 1078*b24ab676SJeff Bonwick ASSERT3U(doi.doi_bonus_size, <=, db->db_size); 1079*b24ab676SJeff Bonwick ASSERT3U(doi.doi_bonus_size, >=, sizeof (*bt)); 1080*b24ab676SJeff Bonwick bt = (void *)((char *)db->db_data + doi.doi_bonus_size - sizeof (*bt)); 1081*b24ab676SJeff Bonwick 1082*b24ab676SJeff Bonwick return (bt); 1083*b24ab676SJeff Bonwick } 1084*b24ab676SJeff Bonwick 1085*b24ab676SJeff Bonwick /* 1086*b24ab676SJeff Bonwick * ZIL logging ops 1087*b24ab676SJeff Bonwick */ 1088*b24ab676SJeff Bonwick 1089*b24ab676SJeff Bonwick #define lrz_type lr_mode 1090*b24ab676SJeff Bonwick #define lrz_blocksize lr_uid 1091*b24ab676SJeff Bonwick #define lrz_ibshift lr_gid 1092*b24ab676SJeff Bonwick #define lrz_bonustype lr_rdev 1093*b24ab676SJeff Bonwick #define lrz_bonuslen lr_crtime[1] 1094*b24ab676SJeff Bonwick 1095*b24ab676SJeff Bonwick static uint64_t 1096*b24ab676SJeff Bonwick ztest_log_create(ztest_ds_t *zd, dmu_tx_t *tx, lr_create_t *lr) 1097*b24ab676SJeff Bonwick { 1098*b24ab676SJeff Bonwick char *name = (void *)(lr + 1); /* name follows lr */ 1099*b24ab676SJeff Bonwick size_t namesize = strlen(name) + 1; 1100*b24ab676SJeff Bonwick itx_t *itx; 1101*b24ab676SJeff Bonwick 1102*b24ab676SJeff Bonwick if (zil_replaying(zd->zd_zilog, tx)) 1103*b24ab676SJeff Bonwick return (0); 1104*b24ab676SJeff Bonwick 1105*b24ab676SJeff Bonwick itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize); 1106*b24ab676SJeff Bonwick bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, 1107*b24ab676SJeff Bonwick sizeof (*lr) + namesize - sizeof (lr_t)); 1108*b24ab676SJeff Bonwick 1109*b24ab676SJeff Bonwick return (zil_itx_assign(zd->zd_zilog, itx, tx)); 1110*b24ab676SJeff Bonwick } 1111*b24ab676SJeff Bonwick 1112*b24ab676SJeff Bonwick static uint64_t 1113*b24ab676SJeff Bonwick ztest_log_remove(ztest_ds_t *zd, dmu_tx_t *tx, lr_remove_t *lr) 1114*b24ab676SJeff Bonwick { 1115*b24ab676SJeff Bonwick char *name = (void *)(lr + 1); /* name follows lr */ 1116*b24ab676SJeff Bonwick size_t namesize = strlen(name) + 1; 1117*b24ab676SJeff Bonwick itx_t *itx; 1118*b24ab676SJeff Bonwick 1119*b24ab676SJeff Bonwick if (zil_replaying(zd->zd_zilog, tx)) 1120*b24ab676SJeff Bonwick return (0); 1121*b24ab676SJeff Bonwick 1122*b24ab676SJeff Bonwick itx = zil_itx_create(TX_REMOVE, sizeof (*lr) + namesize); 1123*b24ab676SJeff Bonwick bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, 1124*b24ab676SJeff Bonwick sizeof (*lr) + namesize - sizeof (lr_t)); 1125*b24ab676SJeff Bonwick 1126*b24ab676SJeff Bonwick return (zil_itx_assign(zd->zd_zilog, itx, tx)); 1127*b24ab676SJeff Bonwick } 1128*b24ab676SJeff Bonwick 1129*b24ab676SJeff Bonwick static uint64_t 1130*b24ab676SJeff Bonwick ztest_log_write(ztest_ds_t *zd, dmu_tx_t *tx, lr_write_t *lr) 1131*b24ab676SJeff Bonwick { 1132*b24ab676SJeff Bonwick itx_t *itx; 1133*b24ab676SJeff Bonwick itx_wr_state_t write_state = ztest_random(WR_NUM_STATES); 1134*b24ab676SJeff Bonwick 1135*b24ab676SJeff Bonwick if (zil_replaying(zd->zd_zilog, tx)) 1136*b24ab676SJeff Bonwick return (0); 1137*b24ab676SJeff Bonwick 1138*b24ab676SJeff Bonwick if (lr->lr_length > ZIL_MAX_LOG_DATA) 1139*b24ab676SJeff Bonwick write_state = WR_INDIRECT; 1140*b24ab676SJeff Bonwick 1141*b24ab676SJeff Bonwick itx = zil_itx_create(TX_WRITE, 1142*b24ab676SJeff Bonwick sizeof (*lr) + (write_state == WR_COPIED ? lr->lr_length : 0)); 1143*b24ab676SJeff Bonwick 1144*b24ab676SJeff Bonwick if (write_state == WR_COPIED && 1145*b24ab676SJeff Bonwick dmu_read(zd->zd_os, lr->lr_foid, lr->lr_offset, lr->lr_length, 1146*b24ab676SJeff Bonwick ((lr_write_t *)&itx->itx_lr) + 1, DMU_READ_NO_PREFETCH) != 0) { 1147*b24ab676SJeff Bonwick zil_itx_destroy(itx); 1148*b24ab676SJeff Bonwick itx = zil_itx_create(TX_WRITE, sizeof (*lr)); 1149*b24ab676SJeff Bonwick write_state = WR_NEED_COPY; 1150*b24ab676SJeff Bonwick } 1151*b24ab676SJeff Bonwick itx->itx_private = zd; 1152*b24ab676SJeff Bonwick itx->itx_wr_state = write_state; 1153*b24ab676SJeff Bonwick itx->itx_sync = (ztest_random(8) == 0); 1154*b24ab676SJeff Bonwick itx->itx_sod += (write_state == WR_NEED_COPY ? lr->lr_length : 0); 1155*b24ab676SJeff Bonwick 1156*b24ab676SJeff Bonwick bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, 1157*b24ab676SJeff Bonwick sizeof (*lr) - sizeof (lr_t)); 1158*b24ab676SJeff Bonwick 1159*b24ab676SJeff Bonwick return (zil_itx_assign(zd->zd_zilog, itx, tx)); 1160*b24ab676SJeff Bonwick } 1161*b24ab676SJeff Bonwick 1162*b24ab676SJeff Bonwick static uint64_t 1163*b24ab676SJeff Bonwick ztest_log_truncate(ztest_ds_t *zd, dmu_tx_t *tx, lr_truncate_t *lr) 1164*b24ab676SJeff Bonwick { 1165*b24ab676SJeff Bonwick itx_t *itx; 1166*b24ab676SJeff Bonwick 1167*b24ab676SJeff Bonwick if (zil_replaying(zd->zd_zilog, tx)) 1168*b24ab676SJeff Bonwick return (0); 1169*b24ab676SJeff Bonwick 1170*b24ab676SJeff Bonwick itx = zil_itx_create(TX_TRUNCATE, sizeof (*lr)); 1171*b24ab676SJeff Bonwick bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, 1172*b24ab676SJeff Bonwick sizeof (*lr) - sizeof (lr_t)); 1173*b24ab676SJeff Bonwick 1174*b24ab676SJeff Bonwick return (zil_itx_assign(zd->zd_zilog, itx, tx)); 1175*b24ab676SJeff Bonwick } 1176*b24ab676SJeff Bonwick 1177*b24ab676SJeff Bonwick static uint64_t 1178*b24ab676SJeff Bonwick ztest_log_setattr(ztest_ds_t *zd, dmu_tx_t *tx, lr_setattr_t *lr) 1179*b24ab676SJeff Bonwick { 1180*b24ab676SJeff Bonwick itx_t *itx; 1181*b24ab676SJeff Bonwick 1182*b24ab676SJeff Bonwick if (zil_replaying(zd->zd_zilog, tx)) 1183*b24ab676SJeff Bonwick return (0); 1184*b24ab676SJeff Bonwick 1185*b24ab676SJeff Bonwick itx = zil_itx_create(TX_SETATTR, sizeof (*lr)); 1186*b24ab676SJeff Bonwick bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, 1187*b24ab676SJeff Bonwick sizeof (*lr) - sizeof (lr_t)); 1188*b24ab676SJeff Bonwick 1189*b24ab676SJeff Bonwick return (zil_itx_assign(zd->zd_zilog, itx, tx)); 1190*b24ab676SJeff Bonwick } 1191*b24ab676SJeff Bonwick 1192*b24ab676SJeff Bonwick /* 1193*b24ab676SJeff Bonwick * ZIL replay ops 1194*b24ab676SJeff Bonwick */ 1195*b24ab676SJeff Bonwick static int 1196*b24ab676SJeff Bonwick ztest_replay_create(ztest_ds_t *zd, lr_create_t *lr, boolean_t byteswap) 1197*b24ab676SJeff Bonwick { 1198*b24ab676SJeff Bonwick char *name = (void *)(lr + 1); /* name follows lr */ 1199*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1200*b24ab676SJeff Bonwick ztest_block_tag_t *bbt; 1201*b24ab676SJeff Bonwick dmu_buf_t *db; 1202*b24ab676SJeff Bonwick dmu_tx_t *tx; 1203*b24ab676SJeff Bonwick uint64_t txg; 1204*b24ab676SJeff Bonwick int error = 0; 1205*b24ab676SJeff Bonwick 1206*b24ab676SJeff Bonwick if (byteswap) 1207*b24ab676SJeff Bonwick byteswap_uint64_array(lr, sizeof (*lr)); 1208*b24ab676SJeff Bonwick 1209*b24ab676SJeff Bonwick ASSERT(lr->lr_doid == ZTEST_DIROBJ); 1210*b24ab676SJeff Bonwick ASSERT(name[0] != '\0'); 1211*b24ab676SJeff Bonwick 1212*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 1213*b24ab676SJeff Bonwick 1214*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, lr->lr_doid, B_TRUE, name); 1215*b24ab676SJeff Bonwick 1216*b24ab676SJeff Bonwick if (lr->lrz_type == DMU_OT_ZAP_OTHER) { 1217*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, B_TRUE, NULL); 1218*b24ab676SJeff Bonwick } else { 1219*b24ab676SJeff Bonwick dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 1220*b24ab676SJeff Bonwick } 1221*b24ab676SJeff Bonwick 1222*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 1223*b24ab676SJeff Bonwick if (txg == 0) 1224*b24ab676SJeff Bonwick return (ENOSPC); 1225*b24ab676SJeff Bonwick 1226*b24ab676SJeff Bonwick ASSERT(dmu_objset_zil(os)->zl_replay == !!lr->lr_foid); 1227*b24ab676SJeff Bonwick 1228*b24ab676SJeff Bonwick if (lr->lrz_type == DMU_OT_ZAP_OTHER) { 1229*b24ab676SJeff Bonwick if (lr->lr_foid == 0) { 1230*b24ab676SJeff Bonwick lr->lr_foid = zap_create(os, 1231*b24ab676SJeff Bonwick lr->lrz_type, lr->lrz_bonustype, 1232*b24ab676SJeff Bonwick lr->lrz_bonuslen, tx); 1233*b24ab676SJeff Bonwick } else { 1234*b24ab676SJeff Bonwick error = zap_create_claim(os, lr->lr_foid, 1235*b24ab676SJeff Bonwick lr->lrz_type, lr->lrz_bonustype, 1236*b24ab676SJeff Bonwick lr->lrz_bonuslen, tx); 1237*b24ab676SJeff Bonwick } 1238*b24ab676SJeff Bonwick } else { 1239*b24ab676SJeff Bonwick if (lr->lr_foid == 0) { 1240*b24ab676SJeff Bonwick lr->lr_foid = dmu_object_alloc(os, 1241*b24ab676SJeff Bonwick lr->lrz_type, 0, lr->lrz_bonustype, 1242*b24ab676SJeff Bonwick lr->lrz_bonuslen, tx); 1243*b24ab676SJeff Bonwick } else { 1244*b24ab676SJeff Bonwick error = dmu_object_claim(os, lr->lr_foid, 1245*b24ab676SJeff Bonwick lr->lrz_type, 0, lr->lrz_bonustype, 1246*b24ab676SJeff Bonwick lr->lrz_bonuslen, tx); 1247*b24ab676SJeff Bonwick } 1248*b24ab676SJeff Bonwick } 1249*b24ab676SJeff Bonwick 1250*b24ab676SJeff Bonwick if (error) { 1251*b24ab676SJeff Bonwick ASSERT3U(error, ==, EEXIST); 1252*b24ab676SJeff Bonwick ASSERT(zd->zd_zilog->zl_replay); 1253*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1254*b24ab676SJeff Bonwick return (error); 1255*b24ab676SJeff Bonwick } 1256*b24ab676SJeff Bonwick 1257*b24ab676SJeff Bonwick ASSERT(lr->lr_foid != 0); 1258*b24ab676SJeff Bonwick 1259*b24ab676SJeff Bonwick if (lr->lrz_type != DMU_OT_ZAP_OTHER) 1260*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_object_set_blocksize(os, lr->lr_foid, 1261*b24ab676SJeff Bonwick lr->lrz_blocksize, lr->lrz_ibshift, tx)); 1262*b24ab676SJeff Bonwick 1263*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db)); 1264*b24ab676SJeff Bonwick bbt = ztest_bt_bonus(db); 1265*b24ab676SJeff Bonwick dmu_buf_will_dirty(db, tx); 1266*b24ab676SJeff Bonwick ztest_bt_generate(bbt, os, lr->lr_foid, -1ULL, lr->lr_gen, txg, txg); 1267*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1268*b24ab676SJeff Bonwick 1269*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_add(os, lr->lr_doid, name, sizeof (uint64_t), 1, 1270*b24ab676SJeff Bonwick &lr->lr_foid, tx)); 1271*b24ab676SJeff Bonwick 1272*b24ab676SJeff Bonwick (void) ztest_log_create(zd, tx, lr); 1273*b24ab676SJeff Bonwick 1274*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1275*b24ab676SJeff Bonwick 1276*b24ab676SJeff Bonwick return (0); 1277*b24ab676SJeff Bonwick } 1278*b24ab676SJeff Bonwick 1279*b24ab676SJeff Bonwick static int 1280*b24ab676SJeff Bonwick ztest_replay_remove(ztest_ds_t *zd, lr_remove_t *lr, boolean_t byteswap) 1281*b24ab676SJeff Bonwick { 1282*b24ab676SJeff Bonwick char *name = (void *)(lr + 1); /* name follows lr */ 1283*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1284*b24ab676SJeff Bonwick dmu_object_info_t doi; 1285*b24ab676SJeff Bonwick dmu_tx_t *tx; 1286*b24ab676SJeff Bonwick uint64_t object, txg; 1287*b24ab676SJeff Bonwick 1288*b24ab676SJeff Bonwick if (byteswap) 1289*b24ab676SJeff Bonwick byteswap_uint64_array(lr, sizeof (*lr)); 1290*b24ab676SJeff Bonwick 1291*b24ab676SJeff Bonwick ASSERT(lr->lr_doid == ZTEST_DIROBJ); 1292*b24ab676SJeff Bonwick ASSERT(name[0] != '\0'); 1293*b24ab676SJeff Bonwick 1294*b24ab676SJeff Bonwick VERIFY3U(0, ==, 1295*b24ab676SJeff Bonwick zap_lookup(os, lr->lr_doid, name, sizeof (object), 1, &object)); 1296*b24ab676SJeff Bonwick ASSERT(object != 0); 1297*b24ab676SJeff Bonwick 1298*b24ab676SJeff Bonwick ztest_object_lock(zd, object, RL_WRITER); 1299*b24ab676SJeff Bonwick 1300*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_object_info(os, object, &doi)); 1301*b24ab676SJeff Bonwick 1302*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 1303*b24ab676SJeff Bonwick 1304*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, lr->lr_doid, B_FALSE, name); 1305*b24ab676SJeff Bonwick dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END); 1306*b24ab676SJeff Bonwick 1307*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 1308*b24ab676SJeff Bonwick if (txg == 0) { 1309*b24ab676SJeff Bonwick ztest_object_unlock(zd, object); 1310*b24ab676SJeff Bonwick return (ENOSPC); 1311*b24ab676SJeff Bonwick } 1312*b24ab676SJeff Bonwick 1313*b24ab676SJeff Bonwick if (doi.doi_type == DMU_OT_ZAP_OTHER) { 1314*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_destroy(os, object, tx)); 1315*b24ab676SJeff Bonwick } else { 1316*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_object_free(os, object, tx)); 1317*b24ab676SJeff Bonwick } 1318*b24ab676SJeff Bonwick 1319*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_remove(os, lr->lr_doid, name, tx)); 1320*b24ab676SJeff Bonwick 1321*b24ab676SJeff Bonwick (void) ztest_log_remove(zd, tx, lr); 1322*b24ab676SJeff Bonwick 1323*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1324*b24ab676SJeff Bonwick 1325*b24ab676SJeff Bonwick ztest_object_unlock(zd, object); 1326*b24ab676SJeff Bonwick 1327*b24ab676SJeff Bonwick return (0); 1328*b24ab676SJeff Bonwick } 1329*b24ab676SJeff Bonwick 1330*b24ab676SJeff Bonwick static int 1331*b24ab676SJeff Bonwick ztest_replay_write(ztest_ds_t *zd, lr_write_t *lr, boolean_t byteswap) 1332*b24ab676SJeff Bonwick { 1333*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1334*b24ab676SJeff Bonwick void *data = lr + 1; /* data follows lr */ 1335*b24ab676SJeff Bonwick uint64_t offset, length; 1336*b24ab676SJeff Bonwick ztest_block_tag_t *bt = data; 1337*b24ab676SJeff Bonwick ztest_block_tag_t *bbt; 1338*b24ab676SJeff Bonwick uint64_t gen, txg, lrtxg, crtxg; 1339*b24ab676SJeff Bonwick dmu_object_info_t doi; 1340*b24ab676SJeff Bonwick dmu_tx_t *tx; 1341*b24ab676SJeff Bonwick dmu_buf_t *db; 1342*b24ab676SJeff Bonwick arc_buf_t *abuf = NULL; 1343*b24ab676SJeff Bonwick rl_t *rl; 1344*b24ab676SJeff Bonwick 1345*b24ab676SJeff Bonwick if (byteswap) 1346*b24ab676SJeff Bonwick byteswap_uint64_array(lr, sizeof (*lr)); 1347*b24ab676SJeff Bonwick 1348*b24ab676SJeff Bonwick offset = lr->lr_offset; 1349*b24ab676SJeff Bonwick length = lr->lr_length; 1350*b24ab676SJeff Bonwick 1351*b24ab676SJeff Bonwick /* If it's a dmu_sync() block, write the whole block */ 1352*b24ab676SJeff Bonwick if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) { 1353*b24ab676SJeff Bonwick uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr); 1354*b24ab676SJeff Bonwick if (length < blocksize) { 1355*b24ab676SJeff Bonwick offset -= offset % blocksize; 1356*b24ab676SJeff Bonwick length = blocksize; 1357*b24ab676SJeff Bonwick } 1358*b24ab676SJeff Bonwick } 1359*b24ab676SJeff Bonwick 1360*b24ab676SJeff Bonwick if (bt->bt_magic == BSWAP_64(BT_MAGIC)) 1361*b24ab676SJeff Bonwick byteswap_uint64_array(bt, sizeof (*bt)); 1362*b24ab676SJeff Bonwick 1363*b24ab676SJeff Bonwick if (bt->bt_magic != BT_MAGIC) 1364*b24ab676SJeff Bonwick bt = NULL; 1365*b24ab676SJeff Bonwick 1366*b24ab676SJeff Bonwick ztest_object_lock(zd, lr->lr_foid, RL_READER); 1367*b24ab676SJeff Bonwick rl = ztest_range_lock(zd, lr->lr_foid, offset, length, RL_WRITER); 1368*b24ab676SJeff Bonwick 1369*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db)); 1370*b24ab676SJeff Bonwick 1371*b24ab676SJeff Bonwick dmu_object_info_from_db(db, &doi); 1372*b24ab676SJeff Bonwick 1373*b24ab676SJeff Bonwick bbt = ztest_bt_bonus(db); 1374*b24ab676SJeff Bonwick ASSERT3U(bbt->bt_magic, ==, BT_MAGIC); 1375*b24ab676SJeff Bonwick gen = bbt->bt_gen; 1376*b24ab676SJeff Bonwick crtxg = bbt->bt_crtxg; 1377*b24ab676SJeff Bonwick lrtxg = lr->lr_common.lrc_txg; 1378*b24ab676SJeff Bonwick 1379*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 1380*b24ab676SJeff Bonwick 1381*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, lr->lr_foid, offset, length); 1382*b24ab676SJeff Bonwick 1383*b24ab676SJeff Bonwick if (ztest_random(8) == 0 && length == doi.doi_data_block_size && 1384*b24ab676SJeff Bonwick P2PHASE(offset, length) == 0) 1385*b24ab676SJeff Bonwick abuf = dmu_request_arcbuf(db, length); 1386*b24ab676SJeff Bonwick 1387*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 1388*b24ab676SJeff Bonwick if (txg == 0) { 1389*b24ab676SJeff Bonwick if (abuf != NULL) 1390*b24ab676SJeff Bonwick dmu_return_arcbuf(abuf); 1391*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1392*b24ab676SJeff Bonwick ztest_range_unlock(rl); 1393*b24ab676SJeff Bonwick ztest_object_unlock(zd, lr->lr_foid); 1394*b24ab676SJeff Bonwick return (ENOSPC); 1395*b24ab676SJeff Bonwick } 1396*b24ab676SJeff Bonwick 1397*b24ab676SJeff Bonwick if (bt != NULL) { 1398*b24ab676SJeff Bonwick /* 1399*b24ab676SJeff Bonwick * Usually, verify the old data before writing new data -- 1400*b24ab676SJeff Bonwick * but not always, because we also want to verify correct 1401*b24ab676SJeff Bonwick * behavior when the data was not recently read into cache. 1402*b24ab676SJeff Bonwick */ 1403*b24ab676SJeff Bonwick ASSERT(offset % doi.doi_data_block_size == 0); 1404*b24ab676SJeff Bonwick if (ztest_random(4) != 0) { 1405*b24ab676SJeff Bonwick int prefetch = ztest_random(2) ? 1406*b24ab676SJeff Bonwick DMU_READ_PREFETCH : DMU_READ_NO_PREFETCH; 1407*b24ab676SJeff Bonwick ztest_block_tag_t rbt; 1408*b24ab676SJeff Bonwick 1409*b24ab676SJeff Bonwick VERIFY(dmu_read(os, lr->lr_foid, offset, 1410*b24ab676SJeff Bonwick sizeof (rbt), &rbt, prefetch) == 0); 1411*b24ab676SJeff Bonwick if (rbt.bt_magic == BT_MAGIC) { 1412*b24ab676SJeff Bonwick ztest_bt_verify(&rbt, os, lr->lr_foid, 1413*b24ab676SJeff Bonwick offset, gen, txg, crtxg); 1414*b24ab676SJeff Bonwick } 1415*b24ab676SJeff Bonwick } 1416*b24ab676SJeff Bonwick 1417*b24ab676SJeff Bonwick /* 1418*b24ab676SJeff Bonwick * Writes can appear to be newer than the bonus buffer because 1419*b24ab676SJeff Bonwick * the ztest_get_data() callback does a dmu_read() of the 1420*b24ab676SJeff Bonwick * open-context data, which may be different than the data 1421*b24ab676SJeff Bonwick * as it was when the write was generated. 1422*b24ab676SJeff Bonwick */ 1423*b24ab676SJeff Bonwick if (zd->zd_zilog->zl_replay) { 1424*b24ab676SJeff Bonwick ztest_bt_verify(bt, os, lr->lr_foid, offset, 1425*b24ab676SJeff Bonwick MAX(gen, bt->bt_gen), MAX(txg, lrtxg), 1426*b24ab676SJeff Bonwick bt->bt_crtxg); 1427*b24ab676SJeff Bonwick } 1428*b24ab676SJeff Bonwick 1429*b24ab676SJeff Bonwick /* 1430*b24ab676SJeff Bonwick * Set the bt's gen/txg to the bonus buffer's gen/txg 1431*b24ab676SJeff Bonwick * so that all of the usual ASSERTs will work. 1432*b24ab676SJeff Bonwick */ 1433*b24ab676SJeff Bonwick ztest_bt_generate(bt, os, lr->lr_foid, offset, gen, txg, crtxg); 1434*b24ab676SJeff Bonwick } 1435*b24ab676SJeff Bonwick 1436*b24ab676SJeff Bonwick if (abuf == NULL) { 1437*b24ab676SJeff Bonwick dmu_write(os, lr->lr_foid, offset, length, data, tx); 1438*b24ab676SJeff Bonwick } else { 1439*b24ab676SJeff Bonwick bcopy(data, abuf->b_data, length); 1440*b24ab676SJeff Bonwick dmu_assign_arcbuf(db, offset, abuf, tx); 1441*b24ab676SJeff Bonwick } 1442*b24ab676SJeff Bonwick 1443*b24ab676SJeff Bonwick (void) ztest_log_write(zd, tx, lr); 1444*b24ab676SJeff Bonwick 1445*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1446*b24ab676SJeff Bonwick 1447*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1448*b24ab676SJeff Bonwick 1449*b24ab676SJeff Bonwick ztest_range_unlock(rl); 1450*b24ab676SJeff Bonwick ztest_object_unlock(zd, lr->lr_foid); 1451*b24ab676SJeff Bonwick 1452*b24ab676SJeff Bonwick return (0); 1453*b24ab676SJeff Bonwick } 1454*b24ab676SJeff Bonwick 1455*b24ab676SJeff Bonwick static int 1456*b24ab676SJeff Bonwick ztest_replay_truncate(ztest_ds_t *zd, lr_truncate_t *lr, boolean_t byteswap) 1457*b24ab676SJeff Bonwick { 1458*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1459*b24ab676SJeff Bonwick dmu_tx_t *tx; 1460*b24ab676SJeff Bonwick uint64_t txg; 1461*b24ab676SJeff Bonwick rl_t *rl; 1462*b24ab676SJeff Bonwick 1463*b24ab676SJeff Bonwick if (byteswap) 1464*b24ab676SJeff Bonwick byteswap_uint64_array(lr, sizeof (*lr)); 1465*b24ab676SJeff Bonwick 1466*b24ab676SJeff Bonwick ztest_object_lock(zd, lr->lr_foid, RL_READER); 1467*b24ab676SJeff Bonwick rl = ztest_range_lock(zd, lr->lr_foid, lr->lr_offset, lr->lr_length, 1468*b24ab676SJeff Bonwick RL_WRITER); 1469*b24ab676SJeff Bonwick 1470*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 1471*b24ab676SJeff Bonwick 1472*b24ab676SJeff Bonwick dmu_tx_hold_free(tx, lr->lr_foid, lr->lr_offset, lr->lr_length); 1473*b24ab676SJeff Bonwick 1474*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 1475*b24ab676SJeff Bonwick if (txg == 0) { 1476*b24ab676SJeff Bonwick ztest_range_unlock(rl); 1477*b24ab676SJeff Bonwick ztest_object_unlock(zd, lr->lr_foid); 1478*b24ab676SJeff Bonwick return (ENOSPC); 1479*b24ab676SJeff Bonwick } 1480*b24ab676SJeff Bonwick 1481*b24ab676SJeff Bonwick VERIFY(dmu_free_range(os, lr->lr_foid, lr->lr_offset, 1482*b24ab676SJeff Bonwick lr->lr_length, tx) == 0); 1483*b24ab676SJeff Bonwick 1484*b24ab676SJeff Bonwick (void) ztest_log_truncate(zd, tx, lr); 1485*b24ab676SJeff Bonwick 1486*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1487*b24ab676SJeff Bonwick 1488*b24ab676SJeff Bonwick ztest_range_unlock(rl); 1489*b24ab676SJeff Bonwick ztest_object_unlock(zd, lr->lr_foid); 1490*b24ab676SJeff Bonwick 1491*b24ab676SJeff Bonwick return (0); 1492*b24ab676SJeff Bonwick } 1493*b24ab676SJeff Bonwick 1494*b24ab676SJeff Bonwick static int 1495*b24ab676SJeff Bonwick ztest_replay_setattr(ztest_ds_t *zd, lr_setattr_t *lr, boolean_t byteswap) 1496*b24ab676SJeff Bonwick { 1497*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1498*b24ab676SJeff Bonwick dmu_tx_t *tx; 1499*b24ab676SJeff Bonwick dmu_buf_t *db; 1500*b24ab676SJeff Bonwick ztest_block_tag_t *bbt; 1501*b24ab676SJeff Bonwick uint64_t txg, lrtxg, crtxg; 1502*b24ab676SJeff Bonwick 1503*b24ab676SJeff Bonwick if (byteswap) 1504*b24ab676SJeff Bonwick byteswap_uint64_array(lr, sizeof (*lr)); 1505*b24ab676SJeff Bonwick 1506*b24ab676SJeff Bonwick ztest_object_lock(zd, lr->lr_foid, RL_WRITER); 1507*b24ab676SJeff Bonwick 1508*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db)); 1509*b24ab676SJeff Bonwick 1510*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 1511*b24ab676SJeff Bonwick dmu_tx_hold_bonus(tx, lr->lr_foid); 1512*b24ab676SJeff Bonwick 1513*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 1514*b24ab676SJeff Bonwick if (txg == 0) { 1515*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1516*b24ab676SJeff Bonwick ztest_object_unlock(zd, lr->lr_foid); 1517*b24ab676SJeff Bonwick return (ENOSPC); 1518*b24ab676SJeff Bonwick } 1519*b24ab676SJeff Bonwick 1520*b24ab676SJeff Bonwick bbt = ztest_bt_bonus(db); 1521*b24ab676SJeff Bonwick ASSERT3U(bbt->bt_magic, ==, BT_MAGIC); 1522*b24ab676SJeff Bonwick crtxg = bbt->bt_crtxg; 1523*b24ab676SJeff Bonwick lrtxg = lr->lr_common.lrc_txg; 1524*b24ab676SJeff Bonwick 1525*b24ab676SJeff Bonwick if (zd->zd_zilog->zl_replay) { 1526*b24ab676SJeff Bonwick ASSERT(lr->lr_size != 0); 1527*b24ab676SJeff Bonwick ASSERT(lr->lr_mode != 0); 1528*b24ab676SJeff Bonwick ASSERT(lrtxg != 0); 1529*b24ab676SJeff Bonwick } else { 1530*b24ab676SJeff Bonwick /* 1531*b24ab676SJeff Bonwick * Randomly change the size and increment the generation. 1532*b24ab676SJeff Bonwick */ 1533*b24ab676SJeff Bonwick lr->lr_size = (ztest_random(db->db_size / sizeof (*bbt)) + 1) * 1534*b24ab676SJeff Bonwick sizeof (*bbt); 1535*b24ab676SJeff Bonwick lr->lr_mode = bbt->bt_gen + 1; 1536*b24ab676SJeff Bonwick ASSERT(lrtxg == 0); 1537*b24ab676SJeff Bonwick } 1538*b24ab676SJeff Bonwick 1539*b24ab676SJeff Bonwick /* 1540*b24ab676SJeff Bonwick * Verify that the current bonus buffer is not newer than our txg. 1541*b24ab676SJeff Bonwick */ 1542*b24ab676SJeff Bonwick ztest_bt_verify(bbt, os, lr->lr_foid, -1ULL, lr->lr_mode, 1543*b24ab676SJeff Bonwick MAX(txg, lrtxg), crtxg); 1544*b24ab676SJeff Bonwick 1545*b24ab676SJeff Bonwick dmu_buf_will_dirty(db, tx); 1546*b24ab676SJeff Bonwick 1547*b24ab676SJeff Bonwick ASSERT3U(lr->lr_size, >=, sizeof (*bbt)); 1548*b24ab676SJeff Bonwick ASSERT3U(lr->lr_size, <=, db->db_size); 1549*b24ab676SJeff Bonwick VERIFY3U(dmu_set_bonus(db, lr->lr_size, tx), ==, 0); 1550*b24ab676SJeff Bonwick bbt = ztest_bt_bonus(db); 1551*b24ab676SJeff Bonwick 1552*b24ab676SJeff Bonwick ztest_bt_generate(bbt, os, lr->lr_foid, -1ULL, lr->lr_mode, txg, crtxg); 1553*b24ab676SJeff Bonwick 1554*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1555*b24ab676SJeff Bonwick 1556*b24ab676SJeff Bonwick (void) ztest_log_setattr(zd, tx, lr); 1557*b24ab676SJeff Bonwick 1558*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1559*b24ab676SJeff Bonwick 1560*b24ab676SJeff Bonwick ztest_object_unlock(zd, lr->lr_foid); 1561*b24ab676SJeff Bonwick 1562*b24ab676SJeff Bonwick return (0); 1563*b24ab676SJeff Bonwick } 1564*b24ab676SJeff Bonwick 1565*b24ab676SJeff Bonwick zil_replay_func_t *ztest_replay_vector[TX_MAX_TYPE] = { 1566*b24ab676SJeff Bonwick NULL, /* 0 no such transaction type */ 1567*b24ab676SJeff Bonwick ztest_replay_create, /* TX_CREATE */ 1568*b24ab676SJeff Bonwick NULL, /* TX_MKDIR */ 1569*b24ab676SJeff Bonwick NULL, /* TX_MKXATTR */ 1570*b24ab676SJeff Bonwick NULL, /* TX_SYMLINK */ 1571*b24ab676SJeff Bonwick ztest_replay_remove, /* TX_REMOVE */ 1572*b24ab676SJeff Bonwick NULL, /* TX_RMDIR */ 1573*b24ab676SJeff Bonwick NULL, /* TX_LINK */ 1574*b24ab676SJeff Bonwick NULL, /* TX_RENAME */ 1575*b24ab676SJeff Bonwick ztest_replay_write, /* TX_WRITE */ 1576*b24ab676SJeff Bonwick ztest_replay_truncate, /* TX_TRUNCATE */ 1577*b24ab676SJeff Bonwick ztest_replay_setattr, /* TX_SETATTR */ 1578*b24ab676SJeff Bonwick NULL, /* TX_ACL */ 1579*b24ab676SJeff Bonwick NULL, /* TX_CREATE_ACL */ 1580*b24ab676SJeff Bonwick NULL, /* TX_CREATE_ATTR */ 1581*b24ab676SJeff Bonwick NULL, /* TX_CREATE_ACL_ATTR */ 1582*b24ab676SJeff Bonwick NULL, /* TX_MKDIR_ACL */ 1583*b24ab676SJeff Bonwick NULL, /* TX_MKDIR_ATTR */ 1584*b24ab676SJeff Bonwick NULL, /* TX_MKDIR_ACL_ATTR */ 1585*b24ab676SJeff Bonwick NULL, /* TX_WRITE2 */ 1586*b24ab676SJeff Bonwick }; 1587*b24ab676SJeff Bonwick 1588*b24ab676SJeff Bonwick /* 1589*b24ab676SJeff Bonwick * ZIL get_data callbacks 1590*b24ab676SJeff Bonwick */ 1591*b24ab676SJeff Bonwick 1592*b24ab676SJeff Bonwick static void 1593*b24ab676SJeff Bonwick ztest_get_done(zgd_t *zgd, int error) 1594*b24ab676SJeff Bonwick { 1595*b24ab676SJeff Bonwick ztest_ds_t *zd = zgd->zgd_private; 1596*b24ab676SJeff Bonwick uint64_t object = zgd->zgd_rl->rl_object; 1597*b24ab676SJeff Bonwick 1598*b24ab676SJeff Bonwick if (zgd->zgd_db) 1599*b24ab676SJeff Bonwick dmu_buf_rele(zgd->zgd_db, zgd); 1600*b24ab676SJeff Bonwick 1601*b24ab676SJeff Bonwick ztest_range_unlock(zgd->zgd_rl); 1602*b24ab676SJeff Bonwick ztest_object_unlock(zd, object); 1603*b24ab676SJeff Bonwick 1604*b24ab676SJeff Bonwick if (error == 0 && zgd->zgd_bp) 1605*b24ab676SJeff Bonwick zil_add_block(zgd->zgd_zilog, zgd->zgd_bp); 1606*b24ab676SJeff Bonwick 1607*b24ab676SJeff Bonwick umem_free(zgd, sizeof (*zgd)); 1608*b24ab676SJeff Bonwick } 1609*b24ab676SJeff Bonwick 1610*b24ab676SJeff Bonwick static int 1611*b24ab676SJeff Bonwick ztest_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio) 1612*b24ab676SJeff Bonwick { 1613*b24ab676SJeff Bonwick ztest_ds_t *zd = arg; 1614*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1615*b24ab676SJeff Bonwick uint64_t object = lr->lr_foid; 1616*b24ab676SJeff Bonwick uint64_t offset = lr->lr_offset; 1617*b24ab676SJeff Bonwick uint64_t size = lr->lr_length; 1618*b24ab676SJeff Bonwick blkptr_t *bp = &lr->lr_blkptr; 1619*b24ab676SJeff Bonwick uint64_t txg = lr->lr_common.lrc_txg; 1620*b24ab676SJeff Bonwick uint64_t crtxg; 1621*b24ab676SJeff Bonwick dmu_object_info_t doi; 1622*b24ab676SJeff Bonwick dmu_buf_t *db; 1623*b24ab676SJeff Bonwick zgd_t *zgd; 1624*b24ab676SJeff Bonwick int error; 1625*b24ab676SJeff Bonwick 1626*b24ab676SJeff Bonwick ztest_object_lock(zd, object, RL_READER); 1627*b24ab676SJeff Bonwick error = dmu_bonus_hold(os, object, FTAG, &db); 1628*b24ab676SJeff Bonwick if (error) { 1629*b24ab676SJeff Bonwick ztest_object_unlock(zd, object); 1630*b24ab676SJeff Bonwick return (error); 1631*b24ab676SJeff Bonwick } 1632*b24ab676SJeff Bonwick 1633*b24ab676SJeff Bonwick crtxg = ztest_bt_bonus(db)->bt_crtxg; 1634*b24ab676SJeff Bonwick 1635*b24ab676SJeff Bonwick if (crtxg == 0 || crtxg > txg) { 1636*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1637*b24ab676SJeff Bonwick ztest_object_unlock(zd, object); 1638*b24ab676SJeff Bonwick return (ENOENT); 1639*b24ab676SJeff Bonwick } 1640*b24ab676SJeff Bonwick 1641*b24ab676SJeff Bonwick dmu_object_info_from_db(db, &doi); 1642*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1643*b24ab676SJeff Bonwick db = NULL; 1644*b24ab676SJeff Bonwick 1645*b24ab676SJeff Bonwick zgd = umem_zalloc(sizeof (*zgd), UMEM_NOFAIL); 1646*b24ab676SJeff Bonwick zgd->zgd_zilog = zd->zd_zilog; 1647*b24ab676SJeff Bonwick zgd->zgd_private = zd; 1648*b24ab676SJeff Bonwick 1649*b24ab676SJeff Bonwick if (buf != NULL) { /* immediate write */ 1650*b24ab676SJeff Bonwick zgd->zgd_rl = ztest_range_lock(zd, object, offset, size, 1651*b24ab676SJeff Bonwick RL_READER); 1652*b24ab676SJeff Bonwick 1653*b24ab676SJeff Bonwick error = dmu_read(os, object, offset, size, buf, 1654*b24ab676SJeff Bonwick DMU_READ_NO_PREFETCH); 1655*b24ab676SJeff Bonwick ASSERT(error == 0); 1656*b24ab676SJeff Bonwick } else { 1657*b24ab676SJeff Bonwick size = doi.doi_data_block_size; 1658*b24ab676SJeff Bonwick if (ISP2(size)) 1659*b24ab676SJeff Bonwick offset = P2ALIGN(offset, size); 1660*b24ab676SJeff Bonwick 1661*b24ab676SJeff Bonwick zgd->zgd_rl = ztest_range_lock(zd, object, offset, size, 1662*b24ab676SJeff Bonwick RL_READER); 1663*b24ab676SJeff Bonwick 1664*b24ab676SJeff Bonwick error = dmu_buf_hold(os, object, offset, zgd, &db); 1665*b24ab676SJeff Bonwick 1666*b24ab676SJeff Bonwick if (error == 0) { 1667*b24ab676SJeff Bonwick zgd->zgd_db = db; 1668*b24ab676SJeff Bonwick zgd->zgd_bp = bp; 1669*b24ab676SJeff Bonwick 1670*b24ab676SJeff Bonwick ASSERT(db->db_offset == offset); 1671*b24ab676SJeff Bonwick ASSERT(db->db_size == size); 1672*b24ab676SJeff Bonwick 1673*b24ab676SJeff Bonwick error = dmu_sync(zio, lr->lr_common.lrc_txg, 1674*b24ab676SJeff Bonwick ztest_get_done, zgd); 1675*b24ab676SJeff Bonwick 1676*b24ab676SJeff Bonwick if (error == 0) 1677*b24ab676SJeff Bonwick return (0); 1678*b24ab676SJeff Bonwick } 1679*b24ab676SJeff Bonwick } 1680*b24ab676SJeff Bonwick 1681*b24ab676SJeff Bonwick ztest_get_done(zgd, error); 1682*b24ab676SJeff Bonwick 1683*b24ab676SJeff Bonwick return (error); 1684*b24ab676SJeff Bonwick } 1685*b24ab676SJeff Bonwick 1686*b24ab676SJeff Bonwick static void * 1687*b24ab676SJeff Bonwick ztest_lr_alloc(size_t lrsize, char *name) 1688*b24ab676SJeff Bonwick { 1689*b24ab676SJeff Bonwick char *lr; 1690*b24ab676SJeff Bonwick size_t namesize = name ? strlen(name) + 1 : 0; 1691*b24ab676SJeff Bonwick 1692*b24ab676SJeff Bonwick lr = umem_zalloc(lrsize + namesize, UMEM_NOFAIL); 1693*b24ab676SJeff Bonwick 1694*b24ab676SJeff Bonwick if (name) 1695*b24ab676SJeff Bonwick bcopy(name, lr + lrsize, namesize); 1696*b24ab676SJeff Bonwick 1697*b24ab676SJeff Bonwick return (lr); 1698*b24ab676SJeff Bonwick } 1699*b24ab676SJeff Bonwick 1700*b24ab676SJeff Bonwick void 1701*b24ab676SJeff Bonwick ztest_lr_free(void *lr, size_t lrsize, char *name) 1702*b24ab676SJeff Bonwick { 1703*b24ab676SJeff Bonwick size_t namesize = name ? strlen(name) + 1 : 0; 1704*b24ab676SJeff Bonwick 1705*b24ab676SJeff Bonwick umem_free(lr, lrsize + namesize); 1706*b24ab676SJeff Bonwick } 1707*b24ab676SJeff Bonwick 1708*b24ab676SJeff Bonwick /* 1709*b24ab676SJeff Bonwick * Lookup a bunch of objects. Returns the number of objects not found. 1710*b24ab676SJeff Bonwick */ 1711*b24ab676SJeff Bonwick static int 1712*b24ab676SJeff Bonwick ztest_lookup(ztest_ds_t *zd, ztest_od_t *od, int count) 1713*b24ab676SJeff Bonwick { 1714*b24ab676SJeff Bonwick int missing = 0; 1715*b24ab676SJeff Bonwick int error; 1716*b24ab676SJeff Bonwick 1717*b24ab676SJeff Bonwick ASSERT(_mutex_held(&zd->zd_dirobj_lock)); 1718*b24ab676SJeff Bonwick 1719*b24ab676SJeff Bonwick for (int i = 0; i < count; i++, od++) { 1720*b24ab676SJeff Bonwick od->od_object = 0; 1721*b24ab676SJeff Bonwick error = zap_lookup(zd->zd_os, od->od_dir, od->od_name, 1722*b24ab676SJeff Bonwick sizeof (uint64_t), 1, &od->od_object); 1723*b24ab676SJeff Bonwick if (error) { 1724*b24ab676SJeff Bonwick ASSERT(error == ENOENT); 1725*b24ab676SJeff Bonwick ASSERT(od->od_object == 0); 1726*b24ab676SJeff Bonwick missing++; 1727*b24ab676SJeff Bonwick } else { 1728*b24ab676SJeff Bonwick dmu_buf_t *db; 1729*b24ab676SJeff Bonwick ztest_block_tag_t *bbt; 1730*b24ab676SJeff Bonwick dmu_object_info_t doi; 1731*b24ab676SJeff Bonwick 1732*b24ab676SJeff Bonwick ASSERT(od->od_object != 0); 1733*b24ab676SJeff Bonwick ASSERT(missing == 0); /* there should be no gaps */ 1734*b24ab676SJeff Bonwick 1735*b24ab676SJeff Bonwick ztest_object_lock(zd, od->od_object, RL_READER); 1736*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_bonus_hold(zd->zd_os, 1737*b24ab676SJeff Bonwick od->od_object, FTAG, &db)); 1738*b24ab676SJeff Bonwick dmu_object_info_from_db(db, &doi); 1739*b24ab676SJeff Bonwick bbt = ztest_bt_bonus(db); 1740*b24ab676SJeff Bonwick ASSERT3U(bbt->bt_magic, ==, BT_MAGIC); 1741*b24ab676SJeff Bonwick od->od_type = doi.doi_type; 1742*b24ab676SJeff Bonwick od->od_blocksize = doi.doi_data_block_size; 1743*b24ab676SJeff Bonwick od->od_gen = bbt->bt_gen; 1744*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 1745*b24ab676SJeff Bonwick ztest_object_unlock(zd, od->od_object); 1746*b24ab676SJeff Bonwick } 1747*b24ab676SJeff Bonwick } 1748*b24ab676SJeff Bonwick 1749*b24ab676SJeff Bonwick return (missing); 1750*b24ab676SJeff Bonwick } 1751*b24ab676SJeff Bonwick 1752*b24ab676SJeff Bonwick static int 1753*b24ab676SJeff Bonwick ztest_create(ztest_ds_t *zd, ztest_od_t *od, int count) 1754*b24ab676SJeff Bonwick { 1755*b24ab676SJeff Bonwick int missing = 0; 1756*b24ab676SJeff Bonwick 1757*b24ab676SJeff Bonwick ASSERT(_mutex_held(&zd->zd_dirobj_lock)); 1758*b24ab676SJeff Bonwick 1759*b24ab676SJeff Bonwick for (int i = 0; i < count; i++, od++) { 1760*b24ab676SJeff Bonwick if (missing) { 1761*b24ab676SJeff Bonwick od->od_object = 0; 1762*b24ab676SJeff Bonwick missing++; 1763*b24ab676SJeff Bonwick continue; 1764*b24ab676SJeff Bonwick } 1765*b24ab676SJeff Bonwick 1766*b24ab676SJeff Bonwick lr_create_t *lr = ztest_lr_alloc(sizeof (*lr), od->od_name); 1767*b24ab676SJeff Bonwick 1768*b24ab676SJeff Bonwick lr->lr_doid = od->od_dir; 1769*b24ab676SJeff Bonwick lr->lr_foid = 0; /* 0 to allocate, > 0 to claim */ 1770*b24ab676SJeff Bonwick lr->lrz_type = od->od_crtype; 1771*b24ab676SJeff Bonwick lr->lrz_blocksize = od->od_crblocksize; 1772*b24ab676SJeff Bonwick lr->lrz_ibshift = ztest_random_ibshift(); 1773*b24ab676SJeff Bonwick lr->lrz_bonustype = DMU_OT_UINT64_OTHER; 1774*b24ab676SJeff Bonwick lr->lrz_bonuslen = dmu_bonus_max(); 1775*b24ab676SJeff Bonwick lr->lr_gen = od->od_crgen; 1776*b24ab676SJeff Bonwick lr->lr_crtime[0] = time(NULL); 1777*b24ab676SJeff Bonwick 1778*b24ab676SJeff Bonwick if (ztest_replay_create(zd, lr, B_FALSE) != 0) { 1779*b24ab676SJeff Bonwick ASSERT(missing == 0); 1780*b24ab676SJeff Bonwick od->od_object = 0; 1781*b24ab676SJeff Bonwick missing++; 1782*b24ab676SJeff Bonwick } else { 1783*b24ab676SJeff Bonwick od->od_object = lr->lr_foid; 1784*b24ab676SJeff Bonwick od->od_type = od->od_crtype; 1785*b24ab676SJeff Bonwick od->od_blocksize = od->od_crblocksize; 1786*b24ab676SJeff Bonwick od->od_gen = od->od_crgen; 1787*b24ab676SJeff Bonwick ASSERT(od->od_object != 0); 1788*b24ab676SJeff Bonwick } 1789*b24ab676SJeff Bonwick 1790*b24ab676SJeff Bonwick ztest_lr_free(lr, sizeof (*lr), od->od_name); 1791*b24ab676SJeff Bonwick } 1792*b24ab676SJeff Bonwick 1793*b24ab676SJeff Bonwick return (missing); 1794*b24ab676SJeff Bonwick } 1795*b24ab676SJeff Bonwick 1796*b24ab676SJeff Bonwick static int 1797*b24ab676SJeff Bonwick ztest_remove(ztest_ds_t *zd, ztest_od_t *od, int count) 1798*b24ab676SJeff Bonwick { 1799*b24ab676SJeff Bonwick int missing = 0; 1800*b24ab676SJeff Bonwick int error; 1801*b24ab676SJeff Bonwick 1802*b24ab676SJeff Bonwick ASSERT(_mutex_held(&zd->zd_dirobj_lock)); 1803*b24ab676SJeff Bonwick 1804*b24ab676SJeff Bonwick od += count - 1; 1805*b24ab676SJeff Bonwick 1806*b24ab676SJeff Bonwick for (int i = count - 1; i >= 0; i--, od--) { 1807*b24ab676SJeff Bonwick if (missing) { 1808*b24ab676SJeff Bonwick missing++; 1809*b24ab676SJeff Bonwick continue; 1810*b24ab676SJeff Bonwick } 1811*b24ab676SJeff Bonwick 1812*b24ab676SJeff Bonwick if (od->od_object == 0) 1813*b24ab676SJeff Bonwick continue; 1814*b24ab676SJeff Bonwick 1815*b24ab676SJeff Bonwick lr_remove_t *lr = ztest_lr_alloc(sizeof (*lr), od->od_name); 1816*b24ab676SJeff Bonwick 1817*b24ab676SJeff Bonwick lr->lr_doid = od->od_dir; 1818*b24ab676SJeff Bonwick 1819*b24ab676SJeff Bonwick if ((error = ztest_replay_remove(zd, lr, B_FALSE)) != 0) { 1820*b24ab676SJeff Bonwick ASSERT3U(error, ==, ENOSPC); 1821*b24ab676SJeff Bonwick missing++; 1822*b24ab676SJeff Bonwick } else { 1823*b24ab676SJeff Bonwick od->od_object = 0; 1824*b24ab676SJeff Bonwick } 1825*b24ab676SJeff Bonwick ztest_lr_free(lr, sizeof (*lr), od->od_name); 1826*b24ab676SJeff Bonwick } 1827*b24ab676SJeff Bonwick 1828*b24ab676SJeff Bonwick return (missing); 1829*b24ab676SJeff Bonwick } 1830*b24ab676SJeff Bonwick 1831*b24ab676SJeff Bonwick static int 1832*b24ab676SJeff Bonwick ztest_write(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size, 1833*b24ab676SJeff Bonwick void *data) 1834*b24ab676SJeff Bonwick { 1835*b24ab676SJeff Bonwick lr_write_t *lr; 1836*b24ab676SJeff Bonwick int error; 1837*b24ab676SJeff Bonwick 1838*b24ab676SJeff Bonwick lr = ztest_lr_alloc(sizeof (*lr) + size, NULL); 1839*b24ab676SJeff Bonwick 1840*b24ab676SJeff Bonwick lr->lr_foid = object; 1841*b24ab676SJeff Bonwick lr->lr_offset = offset; 1842*b24ab676SJeff Bonwick lr->lr_length = size; 1843*b24ab676SJeff Bonwick lr->lr_blkoff = 0; 1844*b24ab676SJeff Bonwick BP_ZERO(&lr->lr_blkptr); 1845*b24ab676SJeff Bonwick 1846*b24ab676SJeff Bonwick bcopy(data, lr + 1, size); 1847*b24ab676SJeff Bonwick 1848*b24ab676SJeff Bonwick error = ztest_replay_write(zd, lr, B_FALSE); 1849*b24ab676SJeff Bonwick 1850*b24ab676SJeff Bonwick ztest_lr_free(lr, sizeof (*lr) + size, NULL); 1851*b24ab676SJeff Bonwick 1852*b24ab676SJeff Bonwick return (error); 1853*b24ab676SJeff Bonwick } 1854*b24ab676SJeff Bonwick 1855*b24ab676SJeff Bonwick static int 1856*b24ab676SJeff Bonwick ztest_truncate(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size) 1857*b24ab676SJeff Bonwick { 1858*b24ab676SJeff Bonwick lr_truncate_t *lr; 1859*b24ab676SJeff Bonwick int error; 1860*b24ab676SJeff Bonwick 1861*b24ab676SJeff Bonwick lr = ztest_lr_alloc(sizeof (*lr), NULL); 1862*b24ab676SJeff Bonwick 1863*b24ab676SJeff Bonwick lr->lr_foid = object; 1864*b24ab676SJeff Bonwick lr->lr_offset = offset; 1865*b24ab676SJeff Bonwick lr->lr_length = size; 1866*b24ab676SJeff Bonwick 1867*b24ab676SJeff Bonwick error = ztest_replay_truncate(zd, lr, B_FALSE); 1868*b24ab676SJeff Bonwick 1869*b24ab676SJeff Bonwick ztest_lr_free(lr, sizeof (*lr), NULL); 1870*b24ab676SJeff Bonwick 1871*b24ab676SJeff Bonwick return (error); 1872*b24ab676SJeff Bonwick } 1873*b24ab676SJeff Bonwick 1874*b24ab676SJeff Bonwick static int 1875*b24ab676SJeff Bonwick ztest_setattr(ztest_ds_t *zd, uint64_t object) 1876*b24ab676SJeff Bonwick { 1877*b24ab676SJeff Bonwick lr_setattr_t *lr; 1878*b24ab676SJeff Bonwick int error; 1879*b24ab676SJeff Bonwick 1880*b24ab676SJeff Bonwick lr = ztest_lr_alloc(sizeof (*lr), NULL); 1881*b24ab676SJeff Bonwick 1882*b24ab676SJeff Bonwick lr->lr_foid = object; 1883*b24ab676SJeff Bonwick lr->lr_size = 0; 1884*b24ab676SJeff Bonwick lr->lr_mode = 0; 1885*b24ab676SJeff Bonwick 1886*b24ab676SJeff Bonwick error = ztest_replay_setattr(zd, lr, B_FALSE); 1887*b24ab676SJeff Bonwick 1888*b24ab676SJeff Bonwick ztest_lr_free(lr, sizeof (*lr), NULL); 1889*b24ab676SJeff Bonwick 1890*b24ab676SJeff Bonwick return (error); 1891*b24ab676SJeff Bonwick } 1892*b24ab676SJeff Bonwick 1893*b24ab676SJeff Bonwick static void 1894*b24ab676SJeff Bonwick ztest_prealloc(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size) 1895*b24ab676SJeff Bonwick { 1896*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 1897*b24ab676SJeff Bonwick dmu_tx_t *tx; 1898*b24ab676SJeff Bonwick uint64_t txg; 1899*b24ab676SJeff Bonwick rl_t *rl; 1900*b24ab676SJeff Bonwick 1901*b24ab676SJeff Bonwick txg_wait_synced(dmu_objset_pool(os), 0); 1902*b24ab676SJeff Bonwick 1903*b24ab676SJeff Bonwick ztest_object_lock(zd, object, RL_READER); 1904*b24ab676SJeff Bonwick rl = ztest_range_lock(zd, object, offset, size, RL_WRITER); 1905*b24ab676SJeff Bonwick 1906*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 1907*b24ab676SJeff Bonwick 1908*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, object, offset, size); 1909*b24ab676SJeff Bonwick 1910*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 1911*b24ab676SJeff Bonwick 1912*b24ab676SJeff Bonwick if (txg != 0) { 1913*b24ab676SJeff Bonwick dmu_prealloc(os, object, offset, size, tx); 1914*b24ab676SJeff Bonwick dmu_tx_commit(tx); 1915*b24ab676SJeff Bonwick txg_wait_synced(dmu_objset_pool(os), txg); 1916*b24ab676SJeff Bonwick } else { 1917*b24ab676SJeff Bonwick (void) dmu_free_long_range(os, object, offset, size); 1918*b24ab676SJeff Bonwick } 1919*b24ab676SJeff Bonwick 1920*b24ab676SJeff Bonwick ztest_range_unlock(rl); 1921*b24ab676SJeff Bonwick ztest_object_unlock(zd, object); 1922*b24ab676SJeff Bonwick } 1923*b24ab676SJeff Bonwick 1924*b24ab676SJeff Bonwick static void 1925*b24ab676SJeff Bonwick ztest_io(ztest_ds_t *zd, uint64_t object, uint64_t offset) 1926*b24ab676SJeff Bonwick { 1927*b24ab676SJeff Bonwick ztest_block_tag_t wbt; 1928*b24ab676SJeff Bonwick dmu_object_info_t doi; 1929*b24ab676SJeff Bonwick enum ztest_io_type io_type; 1930*b24ab676SJeff Bonwick uint64_t blocksize; 1931*b24ab676SJeff Bonwick void *data; 1932*b24ab676SJeff Bonwick 1933*b24ab676SJeff Bonwick VERIFY(dmu_object_info(zd->zd_os, object, &doi) == 0); 1934*b24ab676SJeff Bonwick blocksize = doi.doi_data_block_size; 1935*b24ab676SJeff Bonwick data = umem_alloc(blocksize, UMEM_NOFAIL); 1936*b24ab676SJeff Bonwick 1937*b24ab676SJeff Bonwick /* 1938*b24ab676SJeff Bonwick * Pick an i/o type at random, biased toward writing block tags. 1939*b24ab676SJeff Bonwick */ 1940*b24ab676SJeff Bonwick io_type = ztest_random(ZTEST_IO_TYPES); 1941*b24ab676SJeff Bonwick if (ztest_random(2) == 0) 1942*b24ab676SJeff Bonwick io_type = ZTEST_IO_WRITE_TAG; 1943*b24ab676SJeff Bonwick 1944*b24ab676SJeff Bonwick switch (io_type) { 1945*b24ab676SJeff Bonwick 1946*b24ab676SJeff Bonwick case ZTEST_IO_WRITE_TAG: 1947*b24ab676SJeff Bonwick ztest_bt_generate(&wbt, zd->zd_os, object, offset, 0, 0, 0); 1948*b24ab676SJeff Bonwick (void) ztest_write(zd, object, offset, sizeof (wbt), &wbt); 1949*b24ab676SJeff Bonwick break; 1950*b24ab676SJeff Bonwick 1951*b24ab676SJeff Bonwick case ZTEST_IO_WRITE_PATTERN: 1952*b24ab676SJeff Bonwick (void) memset(data, 'a' + (object + offset) % 5, blocksize); 1953*b24ab676SJeff Bonwick if (ztest_random(2) == 0) { 1954*b24ab676SJeff Bonwick /* 1955*b24ab676SJeff Bonwick * Induce fletcher2 collisions to ensure that 1956*b24ab676SJeff Bonwick * zio_ddt_collision() detects and resolves them 1957*b24ab676SJeff Bonwick * when using fletcher2-verify for deduplication. 1958*b24ab676SJeff Bonwick */ 1959*b24ab676SJeff Bonwick ((uint64_t *)data)[0] ^= 1ULL << 63; 1960*b24ab676SJeff Bonwick ((uint64_t *)data)[4] ^= 1ULL << 63; 1961*b24ab676SJeff Bonwick } 1962*b24ab676SJeff Bonwick (void) ztest_write(zd, object, offset, blocksize, data); 1963*b24ab676SJeff Bonwick break; 1964*b24ab676SJeff Bonwick 1965*b24ab676SJeff Bonwick case ZTEST_IO_WRITE_ZEROES: 1966*b24ab676SJeff Bonwick bzero(data, blocksize); 1967*b24ab676SJeff Bonwick (void) ztest_write(zd, object, offset, blocksize, data); 1968*b24ab676SJeff Bonwick break; 1969*b24ab676SJeff Bonwick 1970*b24ab676SJeff Bonwick case ZTEST_IO_TRUNCATE: 1971*b24ab676SJeff Bonwick (void) ztest_truncate(zd, object, offset, blocksize); 1972*b24ab676SJeff Bonwick break; 1973*b24ab676SJeff Bonwick 1974*b24ab676SJeff Bonwick case ZTEST_IO_SETATTR: 1975*b24ab676SJeff Bonwick (void) ztest_setattr(zd, object); 1976*b24ab676SJeff Bonwick break; 1977*b24ab676SJeff Bonwick } 1978*b24ab676SJeff Bonwick 1979*b24ab676SJeff Bonwick umem_free(data, blocksize); 1980*b24ab676SJeff Bonwick } 1981*b24ab676SJeff Bonwick 1982*b24ab676SJeff Bonwick /* 1983*b24ab676SJeff Bonwick * Initialize an object description template. 1984*b24ab676SJeff Bonwick */ 1985*b24ab676SJeff Bonwick static void 1986*b24ab676SJeff Bonwick ztest_od_init(ztest_od_t *od, uint64_t id, char *tag, uint64_t index, 1987*b24ab676SJeff Bonwick dmu_object_type_t type, uint64_t blocksize, uint64_t gen) 1988*b24ab676SJeff Bonwick { 1989*b24ab676SJeff Bonwick od->od_dir = ZTEST_DIROBJ; 1990*b24ab676SJeff Bonwick od->od_object = 0; 1991*b24ab676SJeff Bonwick 1992*b24ab676SJeff Bonwick od->od_crtype = type; 1993*b24ab676SJeff Bonwick od->od_crblocksize = blocksize ? blocksize : ztest_random_blocksize(); 1994*b24ab676SJeff Bonwick od->od_crgen = gen; 1995*b24ab676SJeff Bonwick 1996*b24ab676SJeff Bonwick od->od_type = DMU_OT_NONE; 1997*b24ab676SJeff Bonwick od->od_blocksize = 0; 1998*b24ab676SJeff Bonwick od->od_gen = 0; 1999*b24ab676SJeff Bonwick 2000*b24ab676SJeff Bonwick (void) snprintf(od->od_name, sizeof (od->od_name), "%s(%lld)[%llu]", 2001*b24ab676SJeff Bonwick tag, (int64_t)id, index); 2002*b24ab676SJeff Bonwick } 2003*b24ab676SJeff Bonwick 2004*b24ab676SJeff Bonwick /* 2005*b24ab676SJeff Bonwick * Lookup or create the objects for a test using the od template. 2006*b24ab676SJeff Bonwick * If the objects do not all exist, or if 'remove' is specified, 2007*b24ab676SJeff Bonwick * remove any existing objects and create new ones. Otherwise, 2008*b24ab676SJeff Bonwick * use the existing objects. 2009*b24ab676SJeff Bonwick */ 2010*b24ab676SJeff Bonwick static int 2011*b24ab676SJeff Bonwick ztest_object_init(ztest_ds_t *zd, ztest_od_t *od, size_t size, boolean_t remove) 2012*b24ab676SJeff Bonwick { 2013*b24ab676SJeff Bonwick int count = size / sizeof (*od); 2014*b24ab676SJeff Bonwick int rv = 0; 2015*b24ab676SJeff Bonwick 2016*b24ab676SJeff Bonwick VERIFY(mutex_lock(&zd->zd_dirobj_lock) == 0); 2017*b24ab676SJeff Bonwick if ((ztest_lookup(zd, od, count) != 0 || remove) && 2018*b24ab676SJeff Bonwick (ztest_remove(zd, od, count) != 0 || 2019*b24ab676SJeff Bonwick ztest_create(zd, od, count) != 0)) 2020*b24ab676SJeff Bonwick rv = -1; 2021*b24ab676SJeff Bonwick zd->zd_od = od; 2022*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zd->zd_dirobj_lock) == 0); 2023*b24ab676SJeff Bonwick 2024*b24ab676SJeff Bonwick return (rv); 2025*b24ab676SJeff Bonwick } 2026*b24ab676SJeff Bonwick 2027*b24ab676SJeff Bonwick /* ARGSUSED */ 2028*b24ab676SJeff Bonwick void 2029*b24ab676SJeff Bonwick ztest_zil_commit(ztest_ds_t *zd, uint64_t id) 2030*b24ab676SJeff Bonwick { 2031*b24ab676SJeff Bonwick zilog_t *zilog = zd->zd_zilog; 2032*b24ab676SJeff Bonwick 2033*b24ab676SJeff Bonwick zil_commit(zilog, UINT64_MAX, ztest_random(ZTEST_OBJECTS)); 2034*b24ab676SJeff Bonwick 2035*b24ab676SJeff Bonwick /* 2036*b24ab676SJeff Bonwick * Remember the committed values in zd, which is in parent/child 2037*b24ab676SJeff Bonwick * shared memory. If we die, the next iteration of ztest_run() 2038*b24ab676SJeff Bonwick * will verify that the log really does contain this record. 2039*b24ab676SJeff Bonwick */ 2040*b24ab676SJeff Bonwick mutex_enter(&zilog->zl_lock); 2041*b24ab676SJeff Bonwick ASSERT(zd->zd_seq <= zilog->zl_commit_lr_seq); 2042*b24ab676SJeff Bonwick zd->zd_seq = zilog->zl_commit_lr_seq; 2043*b24ab676SJeff Bonwick mutex_exit(&zilog->zl_lock); 2044*b24ab676SJeff Bonwick } 2045*b24ab676SJeff Bonwick 2046*b24ab676SJeff Bonwick /* 2047*b24ab676SJeff Bonwick * Verify that we can't destroy an active pool, create an existing pool, 2048*b24ab676SJeff Bonwick * or create a pool with a bad vdev spec. 2049*b24ab676SJeff Bonwick */ 2050*b24ab676SJeff Bonwick /* ARGSUSED */ 2051*b24ab676SJeff Bonwick void 2052*b24ab676SJeff Bonwick ztest_spa_create_destroy(ztest_ds_t *zd, uint64_t id) 2053*b24ab676SJeff Bonwick { 2054*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2055*b24ab676SJeff Bonwick spa_t *spa; 2056*b24ab676SJeff Bonwick nvlist_t *nvroot; 2057*b24ab676SJeff Bonwick 2058*b24ab676SJeff Bonwick /* 2059*b24ab676SJeff Bonwick * Attempt to create using a bad file. 2060*b24ab676SJeff Bonwick */ 2061*b24ab676SJeff Bonwick nvroot = make_vdev_root("/dev/bogus", NULL, 0, 0, 0, 0, 0, 1); 2062*b24ab676SJeff Bonwick VERIFY3U(ENOENT, ==, 2063*b24ab676SJeff Bonwick spa_create("ztest_bad_file", nvroot, NULL, NULL, NULL)); 2064*b24ab676SJeff Bonwick nvlist_free(nvroot); 2065*b24ab676SJeff Bonwick 2066*b24ab676SJeff Bonwick /* 2067*b24ab676SJeff Bonwick * Attempt to create using a bad mirror. 2068*b24ab676SJeff Bonwick */ 2069*b24ab676SJeff Bonwick nvroot = make_vdev_root("/dev/bogus", NULL, 0, 0, 0, 0, 2, 1); 2070*b24ab676SJeff Bonwick VERIFY3U(ENOENT, ==, 2071*b24ab676SJeff Bonwick spa_create("ztest_bad_mirror", nvroot, NULL, NULL, NULL)); 2072*b24ab676SJeff Bonwick nvlist_free(nvroot); 2073*b24ab676SJeff Bonwick 2074*b24ab676SJeff Bonwick /* 2075*b24ab676SJeff Bonwick * Attempt to create an existing pool. It shouldn't matter 2076*b24ab676SJeff Bonwick * what's in the nvroot; we should fail with EEXIST. 2077*b24ab676SJeff Bonwick */ 2078*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 2079*b24ab676SJeff Bonwick nvroot = make_vdev_root("/dev/bogus", NULL, 0, 0, 0, 0, 0, 1); 2080*b24ab676SJeff Bonwick VERIFY3U(EEXIST, ==, spa_create(zs->zs_pool, nvroot, NULL, NULL, NULL)); 2081*b24ab676SJeff Bonwick nvlist_free(nvroot); 2082*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(zs->zs_pool, &spa, FTAG)); 2083*b24ab676SJeff Bonwick VERIFY3U(EBUSY, ==, spa_destroy(zs->zs_pool)); 2084*b24ab676SJeff Bonwick spa_close(spa, FTAG); 2085*b24ab676SJeff Bonwick 2086*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 2087*b24ab676SJeff Bonwick } 2088*b24ab676SJeff Bonwick 2089*b24ab676SJeff Bonwick static vdev_t * 2090*b24ab676SJeff Bonwick vdev_lookup_by_path(vdev_t *vd, const char *path) 2091*b24ab676SJeff Bonwick { 2092*b24ab676SJeff Bonwick vdev_t *mvd; 2093*b24ab676SJeff Bonwick 2094*b24ab676SJeff Bonwick if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0) 2095*b24ab676SJeff Bonwick return (vd); 2096*b24ab676SJeff Bonwick 2097*b24ab676SJeff Bonwick for (int c = 0; c < vd->vdev_children; c++) 2098*b24ab676SJeff Bonwick if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) != 2099*b24ab676SJeff Bonwick NULL) 2100*b24ab676SJeff Bonwick return (mvd); 2101*b24ab676SJeff Bonwick 2102*b24ab676SJeff Bonwick return (NULL); 2103*b24ab676SJeff Bonwick } 2104*b24ab676SJeff Bonwick 2105*b24ab676SJeff Bonwick /* 2106*b24ab676SJeff Bonwick * Find the first available hole which can be used as a top-level. 2107*b24ab676SJeff Bonwick */ 2108*b24ab676SJeff Bonwick int 2109*b24ab676SJeff Bonwick find_vdev_hole(spa_t *spa) 2110*b24ab676SJeff Bonwick { 2111*b24ab676SJeff Bonwick vdev_t *rvd = spa->spa_root_vdev; 2112*b24ab676SJeff Bonwick int c; 2113*b24ab676SJeff Bonwick 2114*b24ab676SJeff Bonwick ASSERT(spa_config_held(spa, SCL_VDEV, RW_READER) == SCL_VDEV); 2115*b24ab676SJeff Bonwick 2116*b24ab676SJeff Bonwick for (c = 0; c < rvd->vdev_children; c++) { 2117*b24ab676SJeff Bonwick vdev_t *cvd = rvd->vdev_child[c]; 2118*b24ab676SJeff Bonwick 2119*b24ab676SJeff Bonwick if (cvd->vdev_ishole) 2120*b24ab676SJeff Bonwick break; 2121*b24ab676SJeff Bonwick } 2122*b24ab676SJeff Bonwick return (c); 2123*b24ab676SJeff Bonwick } 2124*b24ab676SJeff Bonwick 2125*b24ab676SJeff Bonwick /* 2126*b24ab676SJeff Bonwick * Verify that vdev_add() works as expected. 2127*b24ab676SJeff Bonwick */ 2128*b24ab676SJeff Bonwick /* ARGSUSED */ 2129*b24ab676SJeff Bonwick void 2130*b24ab676SJeff Bonwick ztest_vdev_add_remove(ztest_ds_t *zd, uint64_t id) 2131*b24ab676SJeff Bonwick { 2132*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2133*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 2134*b24ab676SJeff Bonwick uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz; 2135*b24ab676SJeff Bonwick uint64_t guid; 2136*b24ab676SJeff Bonwick nvlist_t *nvroot; 2137*b24ab676SJeff Bonwick int error; 2138*b24ab676SJeff Bonwick 2139*b24ab676SJeff Bonwick VERIFY(mutex_lock(&zs->zs_vdev_lock) == 0); 2140*b24ab676SJeff Bonwick 2141*b24ab676SJeff Bonwick spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER); 2142*b24ab676SJeff Bonwick 2143*b24ab676SJeff Bonwick ztest_shared->zs_vdev_next_leaf = find_vdev_hole(spa) * leaves; 2144*b24ab676SJeff Bonwick 2145*b24ab676SJeff Bonwick /* 2146*b24ab676SJeff Bonwick * If we have slogs then remove them 1/4 of the time. 2147*b24ab676SJeff Bonwick */ 214888ecc943SGeorge Wilson if (spa_has_slogs(spa) && ztest_random(4) == 0) { 214988ecc943SGeorge Wilson /* 215088ecc943SGeorge Wilson * Grab the guid from the head of the log class rotor. 215188ecc943SGeorge Wilson */ 2152*b24ab676SJeff Bonwick guid = spa_log_class(spa)->mc_rotor->mg_vd->vdev_guid; 21538654d025Sperrin 215488ecc943SGeorge Wilson spa_config_exit(spa, SCL_VDEV, FTAG); 2155fa9e4066Sahrens 215688ecc943SGeorge Wilson /* 215788ecc943SGeorge Wilson * We have to grab the zs_name_lock as writer to 215888ecc943SGeorge Wilson * prevent a race between removing a slog (dmu_objset_find) 215988ecc943SGeorge Wilson * and destroying a dataset. Removing the slog will 216088ecc943SGeorge Wilson * grab a reference on the dataset which may cause 216188ecc943SGeorge Wilson * dmu_objset_destroy() to fail with EBUSY thus 216288ecc943SGeorge Wilson * leaving the dataset in an inconsistent state. 216388ecc943SGeorge Wilson */ 2164*b24ab676SJeff Bonwick VERIFY(rw_wrlock(&ztest_shared->zs_name_lock) == 0); 216588ecc943SGeorge Wilson error = spa_vdev_remove(spa, guid, B_FALSE); 2166*b24ab676SJeff Bonwick VERIFY(rw_unlock(&ztest_shared->zs_name_lock) == 0); 2167fa9e4066Sahrens 216888ecc943SGeorge Wilson if (error && error != EEXIST) 216988ecc943SGeorge Wilson fatal(0, "spa_vdev_remove() = %d", error); 217088ecc943SGeorge Wilson } else { 217188ecc943SGeorge Wilson spa_config_exit(spa, SCL_VDEV, FTAG); 217288ecc943SGeorge Wilson 217388ecc943SGeorge Wilson /* 217488ecc943SGeorge Wilson * Make 1/4 of the devices be log devices. 217588ecc943SGeorge Wilson */ 217688ecc943SGeorge Wilson nvroot = make_vdev_root(NULL, NULL, zopt_vdev_size, 0, 217788ecc943SGeorge Wilson ztest_random(4) == 0, zopt_raidz, zopt_mirrors, 1); 217888ecc943SGeorge Wilson 217988ecc943SGeorge Wilson error = spa_vdev_add(spa, nvroot); 218088ecc943SGeorge Wilson nvlist_free(nvroot); 218188ecc943SGeorge Wilson 218288ecc943SGeorge Wilson if (error == ENOSPC) 218388ecc943SGeorge Wilson ztest_record_enospc("spa_vdev_add"); 218488ecc943SGeorge Wilson else if (error != 0) 218588ecc943SGeorge Wilson fatal(0, "spa_vdev_add() = %d", error); 218688ecc943SGeorge Wilson } 218788ecc943SGeorge Wilson 2188*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&ztest_shared->zs_vdev_lock) == 0); 2189e14bb325SJeff Bonwick } 2190fa9e4066Sahrens 2191e14bb325SJeff Bonwick /* 2192e14bb325SJeff Bonwick * Verify that adding/removing aux devices (l2arc, hot spare) works as expected. 2193e14bb325SJeff Bonwick */ 2194*b24ab676SJeff Bonwick /* ARGSUSED */ 2195e14bb325SJeff Bonwick void 2196*b24ab676SJeff Bonwick ztest_vdev_aux_add_remove(ztest_ds_t *zd, uint64_t id) 2197e14bb325SJeff Bonwick { 2198*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2199*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 220031157203SJeff Bonwick vdev_t *rvd = spa->spa_root_vdev; 2201e14bb325SJeff Bonwick spa_aux_vdev_t *sav; 2202e14bb325SJeff Bonwick char *aux; 2203e14bb325SJeff Bonwick uint64_t guid = 0; 2204e14bb325SJeff Bonwick int error; 2205e14bb325SJeff Bonwick 220631157203SJeff Bonwick if (ztest_random(2) == 0) { 2207e14bb325SJeff Bonwick sav = &spa->spa_spares; 2208e14bb325SJeff Bonwick aux = ZPOOL_CONFIG_SPARES; 2209e14bb325SJeff Bonwick } else { 2210e14bb325SJeff Bonwick sav = &spa->spa_l2cache; 2211e14bb325SJeff Bonwick aux = ZPOOL_CONFIG_L2CACHE; 2212e14bb325SJeff Bonwick } 2213e14bb325SJeff Bonwick 2214*b24ab676SJeff Bonwick VERIFY(mutex_lock(&zs->zs_vdev_lock) == 0); 2215e14bb325SJeff Bonwick 2216e14bb325SJeff Bonwick spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER); 2217e14bb325SJeff Bonwick 2218e14bb325SJeff Bonwick if (sav->sav_count != 0 && ztest_random(4) == 0) { 2219e14bb325SJeff Bonwick /* 2220e14bb325SJeff Bonwick * Pick a random device to remove. 2221e14bb325SJeff Bonwick */ 2222e14bb325SJeff Bonwick guid = sav->sav_vdevs[ztest_random(sav->sav_count)]->vdev_guid; 2223e14bb325SJeff Bonwick } else { 2224e14bb325SJeff Bonwick /* 2225e14bb325SJeff Bonwick * Find an unused device we can add. 2226e14bb325SJeff Bonwick */ 2227*b24ab676SJeff Bonwick zs->zs_vdev_aux = 0; 2228e14bb325SJeff Bonwick for (;;) { 2229e14bb325SJeff Bonwick char path[MAXPATHLEN]; 2230e14bb325SJeff Bonwick int c; 2231e14bb325SJeff Bonwick (void) sprintf(path, ztest_aux_template, zopt_dir, 2232*b24ab676SJeff Bonwick zopt_pool, aux, zs->zs_vdev_aux); 2233e14bb325SJeff Bonwick for (c = 0; c < sav->sav_count; c++) 2234e14bb325SJeff Bonwick if (strcmp(sav->sav_vdevs[c]->vdev_path, 2235e14bb325SJeff Bonwick path) == 0) 2236e14bb325SJeff Bonwick break; 223731157203SJeff Bonwick if (c == sav->sav_count && 223831157203SJeff Bonwick vdev_lookup_by_path(rvd, path) == NULL) 2239e14bb325SJeff Bonwick break; 2240*b24ab676SJeff Bonwick zs->zs_vdev_aux++; 2241e14bb325SJeff Bonwick } 2242e14bb325SJeff Bonwick } 2243e14bb325SJeff Bonwick 2244e14bb325SJeff Bonwick spa_config_exit(spa, SCL_VDEV, FTAG); 2245e14bb325SJeff Bonwick 2246e14bb325SJeff Bonwick if (guid == 0) { 2247e14bb325SJeff Bonwick /* 2248e14bb325SJeff Bonwick * Add a new device. 2249e14bb325SJeff Bonwick */ 225031157203SJeff Bonwick nvlist_t *nvroot = make_vdev_root(NULL, aux, 225131157203SJeff Bonwick (zopt_vdev_size * 5) / 4, 0, 0, 0, 0, 1); 2252e14bb325SJeff Bonwick error = spa_vdev_add(spa, nvroot); 2253e14bb325SJeff Bonwick if (error != 0) 2254e14bb325SJeff Bonwick fatal(0, "spa_vdev_add(%p) = %d", nvroot, error); 2255e14bb325SJeff Bonwick nvlist_free(nvroot); 2256e14bb325SJeff Bonwick } else { 2257e14bb325SJeff Bonwick /* 2258e14bb325SJeff Bonwick * Remove an existing device. Sometimes, dirty its 2259e14bb325SJeff Bonwick * vdev state first to make sure we handle removal 2260e14bb325SJeff Bonwick * of devices that have pending state changes. 2261e14bb325SJeff Bonwick */ 2262e14bb325SJeff Bonwick if (ztest_random(2) == 0) 2263573ca77eSGeorge Wilson (void) vdev_online(spa, guid, 0, NULL); 2264e14bb325SJeff Bonwick 2265e14bb325SJeff Bonwick error = spa_vdev_remove(spa, guid, B_FALSE); 2266e14bb325SJeff Bonwick if (error != 0 && error != EBUSY) 2267e14bb325SJeff Bonwick fatal(0, "spa_vdev_remove(%llu) = %d", guid, error); 2268e14bb325SJeff Bonwick } 2269e14bb325SJeff Bonwick 2270*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 2271fa9e4066Sahrens } 2272fa9e4066Sahrens 2273fa9e4066Sahrens /* 2274fa9e4066Sahrens * Verify that we can attach and detach devices. 2275fa9e4066Sahrens */ 2276*b24ab676SJeff Bonwick /* ARGSUSED */ 2277fa9e4066Sahrens void 2278*b24ab676SJeff Bonwick ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id) 2279fa9e4066Sahrens { 2280*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2281*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 228231157203SJeff Bonwick spa_aux_vdev_t *sav = &spa->spa_spares; 2283fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 2284ea8dc4b6Seschrock vdev_t *oldvd, *newvd, *pvd; 2285e14bb325SJeff Bonwick nvlist_t *root; 2286fa9e4066Sahrens uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz; 2287fa9e4066Sahrens uint64_t leaf, top; 2288ecc2d604Sbonwick uint64_t ashift = ztest_get_ashift(); 22898ad4d6ddSJeff Bonwick uint64_t oldguid, pguid; 2290ea8dc4b6Seschrock size_t oldsize, newsize; 2291ea8dc4b6Seschrock char oldpath[MAXPATHLEN], newpath[MAXPATHLEN]; 2292fa9e4066Sahrens int replacing; 22939af0a4dfSJeff Bonwick int oldvd_has_siblings = B_FALSE; 229431157203SJeff Bonwick int newvd_is_spare = B_FALSE; 229531157203SJeff Bonwick int oldvd_is_log; 2296fa9e4066Sahrens int error, expected_error; 2297fa9e4066Sahrens 2298*b24ab676SJeff Bonwick VERIFY(mutex_lock(&zs->zs_vdev_lock) == 0); 2299fa9e4066Sahrens 2300e14bb325SJeff Bonwick spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER); 2301fa9e4066Sahrens 2302fa9e4066Sahrens /* 2303fa9e4066Sahrens * Decide whether to do an attach or a replace. 2304fa9e4066Sahrens */ 2305fa9e4066Sahrens replacing = ztest_random(2); 2306fa9e4066Sahrens 2307fa9e4066Sahrens /* 2308fa9e4066Sahrens * Pick a random top-level vdev. 2309fa9e4066Sahrens */ 2310*b24ab676SJeff Bonwick top = ztest_random_vdev_top(spa, B_TRUE); 2311fa9e4066Sahrens 2312fa9e4066Sahrens /* 2313fa9e4066Sahrens * Pick a random leaf within it. 2314fa9e4066Sahrens */ 2315fa9e4066Sahrens leaf = ztest_random(leaves); 2316fa9e4066Sahrens 2317fa9e4066Sahrens /* 231831157203SJeff Bonwick * Locate this vdev. 2319fa9e4066Sahrens */ 232031157203SJeff Bonwick oldvd = rvd->vdev_child[top]; 23218ad4d6ddSJeff Bonwick if (zopt_mirrors >= 1) { 23228ad4d6ddSJeff Bonwick ASSERT(oldvd->vdev_ops == &vdev_mirror_ops); 23238ad4d6ddSJeff Bonwick ASSERT(oldvd->vdev_children >= zopt_mirrors); 232431157203SJeff Bonwick oldvd = oldvd->vdev_child[leaf / zopt_raidz]; 23258ad4d6ddSJeff Bonwick } 23268ad4d6ddSJeff Bonwick if (zopt_raidz > 1) { 23278ad4d6ddSJeff Bonwick ASSERT(oldvd->vdev_ops == &vdev_raidz_ops); 23288ad4d6ddSJeff Bonwick ASSERT(oldvd->vdev_children == zopt_raidz); 232931157203SJeff Bonwick oldvd = oldvd->vdev_child[leaf % zopt_raidz]; 23308ad4d6ddSJeff Bonwick } 2331fa9e4066Sahrens 2332fa9e4066Sahrens /* 233331157203SJeff Bonwick * If we're already doing an attach or replace, oldvd may be a 233431157203SJeff Bonwick * mirror vdev -- in which case, pick a random child. 2335fa9e4066Sahrens */ 233631157203SJeff Bonwick while (oldvd->vdev_children != 0) { 23379af0a4dfSJeff Bonwick oldvd_has_siblings = B_TRUE; 23388ad4d6ddSJeff Bonwick ASSERT(oldvd->vdev_children >= 2); 23398ad4d6ddSJeff Bonwick oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)]; 234031157203SJeff Bonwick } 2341fa9e4066Sahrens 234231157203SJeff Bonwick oldguid = oldvd->vdev_guid; 2343573ca77eSGeorge Wilson oldsize = vdev_get_min_asize(oldvd); 234431157203SJeff Bonwick oldvd_is_log = oldvd->vdev_top->vdev_islog; 234531157203SJeff Bonwick (void) strcpy(oldpath, oldvd->vdev_path); 2346ea8dc4b6Seschrock pvd = oldvd->vdev_parent; 23478ad4d6ddSJeff Bonwick pguid = pvd->vdev_guid; 2348fa9e4066Sahrens 23499af0a4dfSJeff Bonwick /* 23509af0a4dfSJeff Bonwick * If oldvd has siblings, then half of the time, detach it. 23519af0a4dfSJeff Bonwick */ 23529af0a4dfSJeff Bonwick if (oldvd_has_siblings && ztest_random(2) == 0) { 23539af0a4dfSJeff Bonwick spa_config_exit(spa, SCL_VDEV, FTAG); 23548ad4d6ddSJeff Bonwick error = spa_vdev_detach(spa, oldguid, pguid, B_FALSE); 23558ad4d6ddSJeff Bonwick if (error != 0 && error != ENODEV && error != EBUSY && 23568ad4d6ddSJeff Bonwick error != ENOTSUP) 23578ad4d6ddSJeff Bonwick fatal(0, "detach (%s) returned %d", oldpath, error); 2358*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 23599af0a4dfSJeff Bonwick return; 23609af0a4dfSJeff Bonwick } 23619af0a4dfSJeff Bonwick 2362fa9e4066Sahrens /* 236331157203SJeff Bonwick * For the new vdev, choose with equal probability between the two 236431157203SJeff Bonwick * standard paths (ending in either 'a' or 'b') or a random hot spare. 2365fa9e4066Sahrens */ 236631157203SJeff Bonwick if (sav->sav_count != 0 && ztest_random(3) == 0) { 236731157203SJeff Bonwick newvd = sav->sav_vdevs[ztest_random(sav->sav_count)]; 236831157203SJeff Bonwick newvd_is_spare = B_TRUE; 236931157203SJeff Bonwick (void) strcpy(newpath, newvd->vdev_path); 237031157203SJeff Bonwick } else { 237131157203SJeff Bonwick (void) snprintf(newpath, sizeof (newpath), ztest_dev_template, 237231157203SJeff Bonwick zopt_dir, zopt_pool, top * leaves + leaf); 237331157203SJeff Bonwick if (ztest_random(2) == 0) 237431157203SJeff Bonwick newpath[strlen(newpath) - 1] = 'b'; 237531157203SJeff Bonwick newvd = vdev_lookup_by_path(rvd, newpath); 237631157203SJeff Bonwick } 237731157203SJeff Bonwick 237831157203SJeff Bonwick if (newvd) { 2379573ca77eSGeorge Wilson newsize = vdev_get_min_asize(newvd); 238031157203SJeff Bonwick } else { 238131157203SJeff Bonwick /* 238231157203SJeff Bonwick * Make newsize a little bigger or smaller than oldsize. 238331157203SJeff Bonwick * If it's smaller, the attach should fail. 238431157203SJeff Bonwick * If it's larger, and we're doing a replace, 238531157203SJeff Bonwick * we should get dynamic LUN growth when we're done. 238631157203SJeff Bonwick */ 238731157203SJeff Bonwick newsize = 10 * oldsize / (9 + ztest_random(3)); 238831157203SJeff Bonwick } 2389fa9e4066Sahrens 2390fa9e4066Sahrens /* 2391fa9e4066Sahrens * If pvd is not a mirror or root, the attach should fail with ENOTSUP, 2392fa9e4066Sahrens * unless it's a replace; in that case any non-replacing parent is OK. 2393fa9e4066Sahrens * 2394ea8dc4b6Seschrock * If newvd is already part of the pool, it should fail with EBUSY. 2395fa9e4066Sahrens * 2396ea8dc4b6Seschrock * If newvd is too small, it should fail with EOVERFLOW. 2397fa9e4066Sahrens */ 239831157203SJeff Bonwick if (pvd->vdev_ops != &vdev_mirror_ops && 239931157203SJeff Bonwick pvd->vdev_ops != &vdev_root_ops && (!replacing || 240031157203SJeff Bonwick pvd->vdev_ops == &vdev_replacing_ops || 240131157203SJeff Bonwick pvd->vdev_ops == &vdev_spare_ops)) 240231157203SJeff Bonwick expected_error = ENOTSUP; 240331157203SJeff Bonwick else if (newvd_is_spare && (!replacing || oldvd_is_log)) 2404fa9e4066Sahrens expected_error = ENOTSUP; 240531157203SJeff Bonwick else if (newvd == oldvd) 240631157203SJeff Bonwick expected_error = replacing ? 0 : EBUSY; 240731157203SJeff Bonwick else if (vdev_lookup_by_path(rvd, newpath) != NULL) 240831157203SJeff Bonwick expected_error = EBUSY; 2409ea8dc4b6Seschrock else if (newsize < oldsize) 2410fa9e4066Sahrens expected_error = EOVERFLOW; 2411ecc2d604Sbonwick else if (ashift > oldvd->vdev_top->vdev_ashift) 2412ecc2d604Sbonwick expected_error = EDOM; 2413fa9e4066Sahrens else 2414fa9e4066Sahrens expected_error = 0; 2415fa9e4066Sahrens 2416e14bb325SJeff Bonwick spa_config_exit(spa, SCL_VDEV, FTAG); 2417fa9e4066Sahrens 2418fa9e4066Sahrens /* 2419ea8dc4b6Seschrock * Build the nvlist describing newpath. 2420fa9e4066Sahrens */ 2421e14bb325SJeff Bonwick root = make_vdev_root(newpath, NULL, newvd == NULL ? newsize : 0, 2422e14bb325SJeff Bonwick ashift, 0, 0, 0, 1); 2423fa9e4066Sahrens 242431157203SJeff Bonwick error = spa_vdev_attach(spa, oldguid, root, replacing); 2425fa9e4066Sahrens 2426fa9e4066Sahrens nvlist_free(root); 2427fa9e4066Sahrens 2428fa9e4066Sahrens /* 2429fa9e4066Sahrens * If our parent was the replacing vdev, but the replace completed, 2430fa9e4066Sahrens * then instead of failing with ENOTSUP we may either succeed, 2431fa9e4066Sahrens * fail with ENODEV, or fail with EOVERFLOW. 2432fa9e4066Sahrens */ 2433fa9e4066Sahrens if (expected_error == ENOTSUP && 2434fa9e4066Sahrens (error == 0 || error == ENODEV || error == EOVERFLOW)) 2435fa9e4066Sahrens expected_error = error; 2436fa9e4066Sahrens 2437f0aa80d4Sbonwick /* 2438f0aa80d4Sbonwick * If someone grew the LUN, the replacement may be too small. 2439f0aa80d4Sbonwick */ 2440088f3894Sahrens if (error == EOVERFLOW || error == EBUSY) 2441f0aa80d4Sbonwick expected_error = error; 2442f0aa80d4Sbonwick 2443088f3894Sahrens /* XXX workaround 6690467 */ 2444088f3894Sahrens if (error != expected_error && expected_error != EBUSY) { 2445088f3894Sahrens fatal(0, "attach (%s %llu, %s %llu, %d) " 2446088f3894Sahrens "returned %d, expected %d", 2447088f3894Sahrens oldpath, (longlong_t)oldsize, newpath, 2448088f3894Sahrens (longlong_t)newsize, replacing, error, expected_error); 2449fa9e4066Sahrens } 2450fa9e4066Sahrens 2451*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 2452fa9e4066Sahrens } 2453fa9e4066Sahrens 2454573ca77eSGeorge Wilson /* 2455573ca77eSGeorge Wilson * Callback function which expands the physical size of the vdev. 2456573ca77eSGeorge Wilson */ 2457573ca77eSGeorge Wilson vdev_t * 2458573ca77eSGeorge Wilson grow_vdev(vdev_t *vd, void *arg) 2459573ca77eSGeorge Wilson { 2460573ca77eSGeorge Wilson spa_t *spa = vd->vdev_spa; 2461573ca77eSGeorge Wilson size_t *newsize = arg; 2462573ca77eSGeorge Wilson size_t fsize; 2463573ca77eSGeorge Wilson int fd; 2464573ca77eSGeorge Wilson 2465573ca77eSGeorge Wilson ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE); 2466573ca77eSGeorge Wilson ASSERT(vd->vdev_ops->vdev_op_leaf); 2467573ca77eSGeorge Wilson 2468573ca77eSGeorge Wilson if ((fd = open(vd->vdev_path, O_RDWR)) == -1) 2469573ca77eSGeorge Wilson return (vd); 2470573ca77eSGeorge Wilson 2471573ca77eSGeorge Wilson fsize = lseek(fd, 0, SEEK_END); 2472573ca77eSGeorge Wilson (void) ftruncate(fd, *newsize); 2473573ca77eSGeorge Wilson 2474573ca77eSGeorge Wilson if (zopt_verbose >= 6) { 2475573ca77eSGeorge Wilson (void) printf("%s grew from %lu to %lu bytes\n", 2476573ca77eSGeorge Wilson vd->vdev_path, (ulong_t)fsize, (ulong_t)*newsize); 2477573ca77eSGeorge Wilson } 2478573ca77eSGeorge Wilson (void) close(fd); 2479573ca77eSGeorge Wilson return (NULL); 2480573ca77eSGeorge Wilson } 2481573ca77eSGeorge Wilson 2482573ca77eSGeorge Wilson /* 2483573ca77eSGeorge Wilson * Callback function which expands a given vdev by calling vdev_online(). 2484573ca77eSGeorge Wilson */ 2485573ca77eSGeorge Wilson /* ARGSUSED */ 2486573ca77eSGeorge Wilson vdev_t * 2487573ca77eSGeorge Wilson online_vdev(vdev_t *vd, void *arg) 2488573ca77eSGeorge Wilson { 2489573ca77eSGeorge Wilson spa_t *spa = vd->vdev_spa; 2490573ca77eSGeorge Wilson vdev_t *tvd = vd->vdev_top; 2491573ca77eSGeorge Wilson uint64_t guid = vd->vdev_guid; 24928f18d1faSGeorge Wilson uint64_t generation = spa->spa_config_generation + 1; 2493095bcd66SGeorge Wilson vdev_state_t newstate = VDEV_STATE_UNKNOWN; 2494095bcd66SGeorge Wilson int error; 2495573ca77eSGeorge Wilson 2496573ca77eSGeorge Wilson ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE); 2497573ca77eSGeorge Wilson ASSERT(vd->vdev_ops->vdev_op_leaf); 2498573ca77eSGeorge Wilson 2499573ca77eSGeorge Wilson /* Calling vdev_online will initialize the new metaslabs */ 2500573ca77eSGeorge Wilson spa_config_exit(spa, SCL_STATE, spa); 2501095bcd66SGeorge Wilson error = vdev_online(spa, guid, ZFS_ONLINE_EXPAND, &newstate); 2502573ca77eSGeorge Wilson spa_config_enter(spa, SCL_STATE, spa, RW_READER); 2503573ca77eSGeorge Wilson 2504095bcd66SGeorge Wilson /* 2505095bcd66SGeorge Wilson * If vdev_online returned an error or the underlying vdev_open 2506095bcd66SGeorge Wilson * failed then we abort the expand. The only way to know that 2507095bcd66SGeorge Wilson * vdev_open fails is by checking the returned newstate. 2508095bcd66SGeorge Wilson */ 2509095bcd66SGeorge Wilson if (error || newstate != VDEV_STATE_HEALTHY) { 2510095bcd66SGeorge Wilson if (zopt_verbose >= 5) { 2511095bcd66SGeorge Wilson (void) printf("Unable to expand vdev, state %llu, " 2512095bcd66SGeorge Wilson "error %d\n", (u_longlong_t)newstate, error); 2513095bcd66SGeorge Wilson } 2514095bcd66SGeorge Wilson return (vd); 2515095bcd66SGeorge Wilson } 2516095bcd66SGeorge Wilson ASSERT3U(newstate, ==, VDEV_STATE_HEALTHY); 2517095bcd66SGeorge Wilson 2518573ca77eSGeorge Wilson /* 2519573ca77eSGeorge Wilson * Since we dropped the lock we need to ensure that we're 2520573ca77eSGeorge Wilson * still talking to the original vdev. It's possible this 2521573ca77eSGeorge Wilson * vdev may have been detached/replaced while we were 2522573ca77eSGeorge Wilson * trying to online it. 2523573ca77eSGeorge Wilson */ 25248f18d1faSGeorge Wilson if (generation != spa->spa_config_generation) { 25258f18d1faSGeorge Wilson if (zopt_verbose >= 5) { 25268f18d1faSGeorge Wilson (void) printf("vdev configuration has changed, " 25278f18d1faSGeorge Wilson "guid %llu, state %llu, expected gen %llu, " 2528*b24ab676SJeff Bonwick "got gen %llu\n", 2529*b24ab676SJeff Bonwick (u_longlong_t)guid, 25308f18d1faSGeorge Wilson (u_longlong_t)tvd->vdev_state, 25318f18d1faSGeorge Wilson (u_longlong_t)generation, 25328f18d1faSGeorge Wilson (u_longlong_t)spa->spa_config_generation); 2533573ca77eSGeorge Wilson } 2534573ca77eSGeorge Wilson return (vd); 2535573ca77eSGeorge Wilson } 2536573ca77eSGeorge Wilson return (NULL); 2537573ca77eSGeorge Wilson } 2538573ca77eSGeorge Wilson 2539573ca77eSGeorge Wilson /* 2540573ca77eSGeorge Wilson * Traverse the vdev tree calling the supplied function. 2541573ca77eSGeorge Wilson * We continue to walk the tree until we either have walked all 2542573ca77eSGeorge Wilson * children or we receive a non-NULL return from the callback. 2543573ca77eSGeorge Wilson * If a NULL callback is passed, then we just return back the first 2544573ca77eSGeorge Wilson * leaf vdev we encounter. 2545573ca77eSGeorge Wilson */ 2546573ca77eSGeorge Wilson vdev_t * 2547573ca77eSGeorge Wilson vdev_walk_tree(vdev_t *vd, vdev_t *(*func)(vdev_t *, void *), void *arg) 2548573ca77eSGeorge Wilson { 2549573ca77eSGeorge Wilson if (vd->vdev_ops->vdev_op_leaf) { 2550573ca77eSGeorge Wilson if (func == NULL) 2551573ca77eSGeorge Wilson return (vd); 2552573ca77eSGeorge Wilson else 2553573ca77eSGeorge Wilson return (func(vd, arg)); 2554573ca77eSGeorge Wilson } 2555573ca77eSGeorge Wilson 2556573ca77eSGeorge Wilson for (uint_t c = 0; c < vd->vdev_children; c++) { 2557573ca77eSGeorge Wilson vdev_t *cvd = vd->vdev_child[c]; 2558573ca77eSGeorge Wilson if ((cvd = vdev_walk_tree(cvd, func, arg)) != NULL) 2559573ca77eSGeorge Wilson return (cvd); 2560573ca77eSGeorge Wilson } 2561573ca77eSGeorge Wilson return (NULL); 2562573ca77eSGeorge Wilson } 2563573ca77eSGeorge Wilson 2564fa9e4066Sahrens /* 2565fa9e4066Sahrens * Verify that dynamic LUN growth works as expected. 2566fa9e4066Sahrens */ 2567*b24ab676SJeff Bonwick /* ARGSUSED */ 2568fa9e4066Sahrens void 2569*b24ab676SJeff Bonwick ztest_vdev_LUN_growth(ztest_ds_t *zd, uint64_t id) 2570fa9e4066Sahrens { 2571*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2572*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 2573*b24ab676SJeff Bonwick vdev_t *vd, *tvd; 2574*b24ab676SJeff Bonwick metaslab_class_t *mc; 2575*b24ab676SJeff Bonwick metaslab_group_t *mg; 2576573ca77eSGeorge Wilson size_t psize, newsize; 2577*b24ab676SJeff Bonwick uint64_t top; 2578*b24ab676SJeff Bonwick uint64_t old_class_space, new_class_space, old_ms_count, new_ms_count; 2579fa9e4066Sahrens 2580*b24ab676SJeff Bonwick VERIFY(mutex_lock(&zs->zs_vdev_lock) == 0); 2581573ca77eSGeorge Wilson spa_config_enter(spa, SCL_STATE, spa, RW_READER); 2582573ca77eSGeorge Wilson 2583*b24ab676SJeff Bonwick top = ztest_random_vdev_top(spa, B_TRUE); 2584573ca77eSGeorge Wilson 2585*b24ab676SJeff Bonwick tvd = spa->spa_root_vdev->vdev_child[top]; 2586*b24ab676SJeff Bonwick mg = tvd->vdev_mg; 2587*b24ab676SJeff Bonwick mc = mg->mg_class; 2588*b24ab676SJeff Bonwick old_ms_count = tvd->vdev_ms_count; 2589*b24ab676SJeff Bonwick old_class_space = metaslab_class_get_space(mc); 2590fa9e4066Sahrens 2591fa9e4066Sahrens /* 2592573ca77eSGeorge Wilson * Determine the size of the first leaf vdev associated with 2593573ca77eSGeorge Wilson * our top-level device. 2594fa9e4066Sahrens */ 2595573ca77eSGeorge Wilson vd = vdev_walk_tree(tvd, NULL, NULL); 2596573ca77eSGeorge Wilson ASSERT3P(vd, !=, NULL); 2597573ca77eSGeorge Wilson ASSERT(vd->vdev_ops->vdev_op_leaf); 2598fa9e4066Sahrens 2599573ca77eSGeorge Wilson psize = vd->vdev_psize; 2600fa9e4066Sahrens 2601573ca77eSGeorge Wilson /* 26028f18d1faSGeorge Wilson * We only try to expand the vdev if it's healthy, less than 4x its 26038f18d1faSGeorge Wilson * original size, and it has a valid psize. 2604573ca77eSGeorge Wilson */ 26058f18d1faSGeorge Wilson if (tvd->vdev_state != VDEV_STATE_HEALTHY || 26068f18d1faSGeorge Wilson psize == 0 || psize >= 4 * zopt_vdev_size) { 2607573ca77eSGeorge Wilson spa_config_exit(spa, SCL_STATE, spa); 2608*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 2609573ca77eSGeorge Wilson return; 2610573ca77eSGeorge Wilson } 2611573ca77eSGeorge Wilson ASSERT(psize > 0); 2612573ca77eSGeorge Wilson newsize = psize + psize / 8; 2613573ca77eSGeorge Wilson ASSERT3U(newsize, >, psize); 2614fa9e4066Sahrens 2615*b24ab676SJeff Bonwick if (zopt_verbose >= 6) { 2616*b24ab676SJeff Bonwick (void) printf("Expanding LUN %s from %lu to %lu\n", 2617573ca77eSGeorge Wilson vd->vdev_path, (ulong_t)psize, (ulong_t)newsize); 2618573ca77eSGeorge Wilson } 2619573ca77eSGeorge Wilson 2620573ca77eSGeorge Wilson /* 2621573ca77eSGeorge Wilson * Growing the vdev is a two step process: 2622573ca77eSGeorge Wilson * 1). expand the physical size (i.e. relabel) 2623573ca77eSGeorge Wilson * 2). online the vdev to create the new metaslabs 2624573ca77eSGeorge Wilson */ 2625573ca77eSGeorge Wilson if (vdev_walk_tree(tvd, grow_vdev, &newsize) != NULL || 2626573ca77eSGeorge Wilson vdev_walk_tree(tvd, online_vdev, NULL) != NULL || 2627573ca77eSGeorge Wilson tvd->vdev_state != VDEV_STATE_HEALTHY) { 2628573ca77eSGeorge Wilson if (zopt_verbose >= 5) { 2629*b24ab676SJeff Bonwick (void) printf("Could not expand LUN because " 2630*b24ab676SJeff Bonwick "the vdev configuration changed.\n"); 2631*b24ab676SJeff Bonwick } 2632*b24ab676SJeff Bonwick spa_config_exit(spa, SCL_STATE, spa); 2633*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 2634*b24ab676SJeff Bonwick return; 2635*b24ab676SJeff Bonwick } 2636*b24ab676SJeff Bonwick 2637*b24ab676SJeff Bonwick spa_config_exit(spa, SCL_STATE, spa); 2638*b24ab676SJeff Bonwick 2639*b24ab676SJeff Bonwick /* 2640*b24ab676SJeff Bonwick * Expanding the LUN will update the config asynchronously, 2641*b24ab676SJeff Bonwick * thus we must wait for the async thread to complete any 2642*b24ab676SJeff Bonwick * pending tasks before proceeding. 2643*b24ab676SJeff Bonwick */ 2644*b24ab676SJeff Bonwick for (;;) { 2645*b24ab676SJeff Bonwick boolean_t done; 2646*b24ab676SJeff Bonwick mutex_enter(&spa->spa_async_lock); 2647*b24ab676SJeff Bonwick done = (spa->spa_async_thread == NULL && !spa->spa_async_tasks); 2648*b24ab676SJeff Bonwick mutex_exit(&spa->spa_async_lock); 2649*b24ab676SJeff Bonwick if (done) 2650*b24ab676SJeff Bonwick break; 2651*b24ab676SJeff Bonwick txg_wait_synced(spa_get_dsl(spa), 0); 2652*b24ab676SJeff Bonwick (void) poll(NULL, 0, 100); 2653*b24ab676SJeff Bonwick } 2654*b24ab676SJeff Bonwick 2655*b24ab676SJeff Bonwick spa_config_enter(spa, SCL_STATE, spa, RW_READER); 2656*b24ab676SJeff Bonwick 2657*b24ab676SJeff Bonwick tvd = spa->spa_root_vdev->vdev_child[top]; 2658*b24ab676SJeff Bonwick new_ms_count = tvd->vdev_ms_count; 2659*b24ab676SJeff Bonwick new_class_space = metaslab_class_get_space(mc); 2660*b24ab676SJeff Bonwick 2661*b24ab676SJeff Bonwick if (tvd->vdev_mg != mg || mg->mg_class != mc) { 2662*b24ab676SJeff Bonwick if (zopt_verbose >= 5) { 2663*b24ab676SJeff Bonwick (void) printf("Could not verify LUN expansion due to " 2664*b24ab676SJeff Bonwick "intervening vdev offline or remove.\n"); 2665fa9e4066Sahrens } 2666*b24ab676SJeff Bonwick spa_config_exit(spa, SCL_STATE, spa); 2667*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 2668573ca77eSGeorge Wilson return; 2669fa9e4066Sahrens } 2670fa9e4066Sahrens 2671573ca77eSGeorge Wilson /* 2672*b24ab676SJeff Bonwick * Make sure we were able to grow the vdev. 2673573ca77eSGeorge Wilson */ 2674*b24ab676SJeff Bonwick if (new_ms_count <= old_ms_count) 2675*b24ab676SJeff Bonwick fatal(0, "LUN expansion failed: ms_count %llu <= %llu\n", 2676*b24ab676SJeff Bonwick old_ms_count, new_ms_count); 2677573ca77eSGeorge Wilson 2678573ca77eSGeorge Wilson /* 2679573ca77eSGeorge Wilson * Make sure we were able to grow the pool. 2680573ca77eSGeorge Wilson */ 2681*b24ab676SJeff Bonwick if (new_class_space <= old_class_space) 2682*b24ab676SJeff Bonwick fatal(0, "LUN expansion failed: class_space %llu <= %llu\n", 2683*b24ab676SJeff Bonwick old_class_space, new_class_space); 2684*b24ab676SJeff Bonwick 2685*b24ab676SJeff Bonwick if (zopt_verbose >= 5) { 2686573ca77eSGeorge Wilson char oldnumbuf[6], newnumbuf[6]; 2687573ca77eSGeorge Wilson 2688*b24ab676SJeff Bonwick nicenum(old_class_space, oldnumbuf); 2689*b24ab676SJeff Bonwick nicenum(new_class_space, newnumbuf); 2690573ca77eSGeorge Wilson (void) printf("%s grew from %s to %s\n", 2691573ca77eSGeorge Wilson spa->spa_name, oldnumbuf, newnumbuf); 2692573ca77eSGeorge Wilson } 2693*b24ab676SJeff Bonwick 2694573ca77eSGeorge Wilson spa_config_exit(spa, SCL_STATE, spa); 2695*b24ab676SJeff Bonwick VERIFY(mutex_unlock(&zs->zs_vdev_lock) == 0); 2696fa9e4066Sahrens } 2697fa9e4066Sahrens 2698*b24ab676SJeff Bonwick /* 2699*b24ab676SJeff Bonwick * Verify that dmu_objset_{create,destroy,open,close} work as expected. 2700*b24ab676SJeff Bonwick */ 2701fa9e4066Sahrens /* ARGSUSED */ 2702fa9e4066Sahrens static void 2703*b24ab676SJeff Bonwick ztest_objset_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx) 2704fa9e4066Sahrens { 2705fa9e4066Sahrens /* 2706*b24ab676SJeff Bonwick * Create the objects common to all ztest datasets. 2707fa9e4066Sahrens */ 2708*b24ab676SJeff Bonwick VERIFY(zap_create_claim(os, ZTEST_DIROBJ, 2709fa9e4066Sahrens DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx) == 0); 2710fa9e4066Sahrens } 2711fa9e4066Sahrens 2712*b24ab676SJeff Bonwick /* ARGSUSED */ 27131d452cf5Sahrens static int 2714*b24ab676SJeff Bonwick ztest_objset_destroy_cb(char *name, void *arg) 2715fa9e4066Sahrens { 2716fa9e4066Sahrens objset_t *os; 2717*b24ab676SJeff Bonwick dmu_object_info_t doi; 2718fa9e4066Sahrens int error; 2719fa9e4066Sahrens 2720fa9e4066Sahrens /* 2721fa9e4066Sahrens * Verify that the dataset contains a directory object. 2722fa9e4066Sahrens */ 2723*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_objset_hold(name, FTAG, &os)); 2724*b24ab676SJeff Bonwick error = dmu_object_info(os, ZTEST_DIROBJ, &doi); 2725e1930233Sbonwick if (error != ENOENT) { 2726e1930233Sbonwick /* We could have crashed in the middle of destroying it */ 2727e1930233Sbonwick ASSERT3U(error, ==, 0); 2728*b24ab676SJeff Bonwick ASSERT3U(doi.doi_type, ==, DMU_OT_ZAP_OTHER); 2729*b24ab676SJeff Bonwick ASSERT3S(doi.doi_physical_blocks_512, >=, 0); 2730e1930233Sbonwick } 2731503ad85cSMatthew Ahrens dmu_objset_rele(os, FTAG); 2732fa9e4066Sahrens 2733fa9e4066Sahrens /* 2734fa9e4066Sahrens * Destroy the dataset. 2735fa9e4066Sahrens */ 2736*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_objset_destroy(name, B_FALSE)); 27371d452cf5Sahrens return (0); 2738fa9e4066Sahrens } 2739fa9e4066Sahrens 2740*b24ab676SJeff Bonwick static boolean_t 2741*b24ab676SJeff Bonwick ztest_snapshot_create(char *osname, uint64_t id) 2742fa9e4066Sahrens { 2743*b24ab676SJeff Bonwick char snapname[MAXNAMELEN]; 2744*b24ab676SJeff Bonwick int error; 2745*b24ab676SJeff Bonwick 2746*b24ab676SJeff Bonwick (void) snprintf(snapname, MAXNAMELEN, "%s@%llu", osname, 2747*b24ab676SJeff Bonwick (u_longlong_t)id); 2748*b24ab676SJeff Bonwick 2749*b24ab676SJeff Bonwick error = dmu_objset_snapshot(osname, strchr(snapname, '@') + 1, 2750*b24ab676SJeff Bonwick NULL, B_FALSE); 2751*b24ab676SJeff Bonwick if (error == ENOSPC) { 2752*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 2753*b24ab676SJeff Bonwick return (B_FALSE); 2754*b24ab676SJeff Bonwick } 2755*b24ab676SJeff Bonwick if (error != 0 && error != EEXIST) 2756*b24ab676SJeff Bonwick fatal(0, "ztest_snapshot_create(%s) = %d", snapname, error); 2757*b24ab676SJeff Bonwick return (B_TRUE); 2758*b24ab676SJeff Bonwick } 2759*b24ab676SJeff Bonwick 2760*b24ab676SJeff Bonwick static boolean_t 2761*b24ab676SJeff Bonwick ztest_snapshot_destroy(char *osname, uint64_t id) 2762*b24ab676SJeff Bonwick { 2763*b24ab676SJeff Bonwick char snapname[MAXNAMELEN]; 2764*b24ab676SJeff Bonwick int error; 2765*b24ab676SJeff Bonwick 2766*b24ab676SJeff Bonwick (void) snprintf(snapname, MAXNAMELEN, "%s@%llu", osname, 2767*b24ab676SJeff Bonwick (u_longlong_t)id); 2768*b24ab676SJeff Bonwick 2769*b24ab676SJeff Bonwick error = dmu_objset_destroy(snapname, B_FALSE); 2770*b24ab676SJeff Bonwick if (error != 0 && error != ENOENT) 2771*b24ab676SJeff Bonwick fatal(0, "ztest_snapshot_destroy(%s) = %d", snapname, error); 2772*b24ab676SJeff Bonwick return (B_TRUE); 2773fa9e4066Sahrens } 2774fa9e4066Sahrens 2775*b24ab676SJeff Bonwick /* ARGSUSED */ 2776fa9e4066Sahrens void 2777*b24ab676SJeff Bonwick ztest_dmu_objset_create_destroy(ztest_ds_t *zd, uint64_t id) 2778fa9e4066Sahrens { 2779*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2780*b24ab676SJeff Bonwick ztest_ds_t zdtmp; 2781*b24ab676SJeff Bonwick int iters; 2782fa9e4066Sahrens int error; 2783745cd3c5Smaybee objset_t *os, *os2; 2784*b24ab676SJeff Bonwick char name[MAXNAMELEN]; 2785fa9e4066Sahrens zilog_t *zilog; 2786fa9e4066Sahrens 2787*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 2788*b24ab676SJeff Bonwick 2789*b24ab676SJeff Bonwick (void) snprintf(name, MAXNAMELEN, "%s/temp_%llu", 2790*b24ab676SJeff Bonwick zs->zs_pool, (u_longlong_t)id); 2791fa9e4066Sahrens 2792fa9e4066Sahrens /* 2793fa9e4066Sahrens * If this dataset exists from a previous run, process its replay log 2794fa9e4066Sahrens * half of the time. If we don't replay it, then dmu_objset_destroy() 2795*b24ab676SJeff Bonwick * (invoked from ztest_objset_destroy_cb()) should just throw it away. 2796fa9e4066Sahrens */ 2797fa9e4066Sahrens if (ztest_random(2) == 0 && 2798503ad85cSMatthew Ahrens dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os) == 0) { 2799*b24ab676SJeff Bonwick ztest_zd_init(&zdtmp, os); 2800*b24ab676SJeff Bonwick zil_replay(os, &zdtmp, ztest_replay_vector); 2801*b24ab676SJeff Bonwick ztest_zd_fini(&zdtmp); 2802503ad85cSMatthew Ahrens dmu_objset_disown(os, FTAG); 2803fa9e4066Sahrens } 2804fa9e4066Sahrens 2805fa9e4066Sahrens /* 2806fa9e4066Sahrens * There may be an old instance of the dataset we're about to 2807fa9e4066Sahrens * create lying around from a previous run. If so, destroy it 2808fa9e4066Sahrens * and all of its snapshots. 2809fa9e4066Sahrens */ 2810*b24ab676SJeff Bonwick (void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL, 28110b69c2f0Sahrens DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS); 2812fa9e4066Sahrens 2813fa9e4066Sahrens /* 2814fa9e4066Sahrens * Verify that the destroyed dataset is no longer in the namespace. 2815fa9e4066Sahrens */ 2816*b24ab676SJeff Bonwick VERIFY3U(ENOENT, ==, dmu_objset_hold(name, FTAG, &os)); 2817fa9e4066Sahrens 2818fa9e4066Sahrens /* 2819fa9e4066Sahrens * Verify that we can create a new dataset. 2820fa9e4066Sahrens */ 2821ae46e4c7SMatthew Ahrens error = dmu_objset_create(name, DMU_OST_OTHER, 0, 2822*b24ab676SJeff Bonwick ztest_objset_create_cb, NULL); 2823fa9e4066Sahrens if (error) { 2824fa9e4066Sahrens if (error == ENOSPC) { 2825*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 2826*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 2827fa9e4066Sahrens return; 2828fa9e4066Sahrens } 2829fa9e4066Sahrens fatal(0, "dmu_objset_create(%s) = %d", name, error); 2830fa9e4066Sahrens } 2831fa9e4066Sahrens 2832*b24ab676SJeff Bonwick VERIFY3U(0, ==, 2833*b24ab676SJeff Bonwick dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os)); 2834*b24ab676SJeff Bonwick 2835*b24ab676SJeff Bonwick ztest_zd_init(&zdtmp, os); 2836fa9e4066Sahrens 2837fa9e4066Sahrens /* 2838fa9e4066Sahrens * Open the intent log for it. 2839fa9e4066Sahrens */ 2840*b24ab676SJeff Bonwick zilog = zil_open(os, ztest_get_data); 2841fa9e4066Sahrens 2842fa9e4066Sahrens /* 2843*b24ab676SJeff Bonwick * Put some objects in there, do a little I/O to them, 2844*b24ab676SJeff Bonwick * and randomly take a couple of snapshots along the way. 2845fa9e4066Sahrens */ 2846*b24ab676SJeff Bonwick iters = ztest_random(5); 2847*b24ab676SJeff Bonwick for (int i = 0; i < iters; i++) { 2848*b24ab676SJeff Bonwick ztest_dmu_object_alloc_free(&zdtmp, id); 2849*b24ab676SJeff Bonwick if (ztest_random(iters) == 0) 2850*b24ab676SJeff Bonwick (void) ztest_snapshot_create(name, i); 2851fa9e4066Sahrens } 2852fa9e4066Sahrens 2853fa9e4066Sahrens /* 2854fa9e4066Sahrens * Verify that we cannot create an existing dataset. 2855fa9e4066Sahrens */ 2856*b24ab676SJeff Bonwick VERIFY3U(EEXIST, ==, 2857*b24ab676SJeff Bonwick dmu_objset_create(name, DMU_OST_OTHER, 0, NULL, NULL)); 2858fa9e4066Sahrens 2859fa9e4066Sahrens /* 2860503ad85cSMatthew Ahrens * Verify that we can hold an objset that is also owned. 2861745cd3c5Smaybee */ 2862*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_objset_hold(name, FTAG, &os2)); 2863503ad85cSMatthew Ahrens dmu_objset_rele(os2, FTAG); 2864503ad85cSMatthew Ahrens 2865503ad85cSMatthew Ahrens /* 2866*b24ab676SJeff Bonwick * Verify that we cannot own an objset that is already owned. 2867503ad85cSMatthew Ahrens */ 2868*b24ab676SJeff Bonwick VERIFY3U(EBUSY, ==, 2869*b24ab676SJeff Bonwick dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, FTAG, &os2)); 2870fa9e4066Sahrens 2871fa9e4066Sahrens zil_close(zilog); 2872503ad85cSMatthew Ahrens dmu_objset_disown(os, FTAG); 2873*b24ab676SJeff Bonwick ztest_zd_fini(&zdtmp); 2874fa9e4066Sahrens 2875*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 2876fa9e4066Sahrens } 2877fa9e4066Sahrens 2878fa9e4066Sahrens /* 2879fa9e4066Sahrens * Verify that dmu_snapshot_{create,destroy,open,close} work as expected. 2880fa9e4066Sahrens */ 2881fa9e4066Sahrens void 2882*b24ab676SJeff Bonwick ztest_dmu_snapshot_create_destroy(ztest_ds_t *zd, uint64_t id) 2883fa9e4066Sahrens { 2884*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 2885fa9e4066Sahrens 2886*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 2887*b24ab676SJeff Bonwick (void) ztest_snapshot_destroy(zd->zd_name, id); 2888*b24ab676SJeff Bonwick (void) ztest_snapshot_create(zd->zd_name, id); 2889*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 28904f5064b7SMark J Musante } 28914f5064b7SMark J Musante 2892718d718aSGeorge Wilson /* 2893718d718aSGeorge Wilson * Cleanup non-standard snapshots and clones. 2894718d718aSGeorge Wilson */ 2895718d718aSGeorge Wilson void 2896*b24ab676SJeff Bonwick ztest_dsl_dataset_cleanup(char *osname, uint64_t id) 2897718d718aSGeorge Wilson { 2898*b24ab676SJeff Bonwick char snap1name[MAXNAMELEN]; 2899*b24ab676SJeff Bonwick char clone1name[MAXNAMELEN]; 2900*b24ab676SJeff Bonwick char snap2name[MAXNAMELEN]; 2901*b24ab676SJeff Bonwick char clone2name[MAXNAMELEN]; 2902*b24ab676SJeff Bonwick char snap3name[MAXNAMELEN]; 2903718d718aSGeorge Wilson int error; 2904718d718aSGeorge Wilson 2905*b24ab676SJeff Bonwick (void) snprintf(snap1name, MAXNAMELEN, "%s@s1_%llu", osname, id); 2906*b24ab676SJeff Bonwick (void) snprintf(clone1name, MAXNAMELEN, "%s/c1_%llu", osname, id); 2907*b24ab676SJeff Bonwick (void) snprintf(snap2name, MAXNAMELEN, "%s@s2_%llu", clone1name, id); 2908*b24ab676SJeff Bonwick (void) snprintf(clone2name, MAXNAMELEN, "%s/c2_%llu", osname, id); 2909*b24ab676SJeff Bonwick (void) snprintf(snap3name, MAXNAMELEN, "%s@s3_%llu", clone1name, id); 2910718d718aSGeorge Wilson 2911842727c2SChris Kirby error = dmu_objset_destroy(clone2name, B_FALSE); 2912718d718aSGeorge Wilson if (error && error != ENOENT) 2913718d718aSGeorge Wilson fatal(0, "dmu_objset_destroy(%s) = %d", clone2name, error); 2914842727c2SChris Kirby error = dmu_objset_destroy(snap3name, B_FALSE); 2915718d718aSGeorge Wilson if (error && error != ENOENT) 2916718d718aSGeorge Wilson fatal(0, "dmu_objset_destroy(%s) = %d", snap3name, error); 2917842727c2SChris Kirby error = dmu_objset_destroy(snap2name, B_FALSE); 2918718d718aSGeorge Wilson if (error && error != ENOENT) 2919718d718aSGeorge Wilson fatal(0, "dmu_objset_destroy(%s) = %d", snap2name, error); 2920842727c2SChris Kirby error = dmu_objset_destroy(clone1name, B_FALSE); 2921718d718aSGeorge Wilson if (error && error != ENOENT) 2922718d718aSGeorge Wilson fatal(0, "dmu_objset_destroy(%s) = %d", clone1name, error); 2923842727c2SChris Kirby error = dmu_objset_destroy(snap1name, B_FALSE); 2924718d718aSGeorge Wilson if (error && error != ENOENT) 2925718d718aSGeorge Wilson fatal(0, "dmu_objset_destroy(%s) = %d", snap1name, error); 2926718d718aSGeorge Wilson } 2927718d718aSGeorge Wilson 29284f5064b7SMark J Musante /* 29294f5064b7SMark J Musante * Verify dsl_dataset_promote handles EBUSY 29304f5064b7SMark J Musante */ 29314f5064b7SMark J Musante void 2932*b24ab676SJeff Bonwick ztest_dsl_dataset_promote_busy(ztest_ds_t *zd, uint64_t id) 29334f5064b7SMark J Musante { 2934*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 29354f5064b7SMark J Musante objset_t *clone; 29364f5064b7SMark J Musante dsl_dataset_t *ds; 2937*b24ab676SJeff Bonwick char snap1name[MAXNAMELEN]; 2938*b24ab676SJeff Bonwick char clone1name[MAXNAMELEN]; 2939*b24ab676SJeff Bonwick char snap2name[MAXNAMELEN]; 2940*b24ab676SJeff Bonwick char clone2name[MAXNAMELEN]; 2941*b24ab676SJeff Bonwick char snap3name[MAXNAMELEN]; 2942*b24ab676SJeff Bonwick char *osname = zd->zd_name; 2943*b24ab676SJeff Bonwick int error; 29444f5064b7SMark J Musante 2945*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 29464f5064b7SMark J Musante 2947*b24ab676SJeff Bonwick ztest_dsl_dataset_cleanup(osname, id); 2948718d718aSGeorge Wilson 2949*b24ab676SJeff Bonwick (void) snprintf(snap1name, MAXNAMELEN, "%s@s1_%llu", osname, id); 2950*b24ab676SJeff Bonwick (void) snprintf(clone1name, MAXNAMELEN, "%s/c1_%llu", osname, id); 2951*b24ab676SJeff Bonwick (void) snprintf(snap2name, MAXNAMELEN, "%s@s2_%llu", clone1name, id); 2952*b24ab676SJeff Bonwick (void) snprintf(clone2name, MAXNAMELEN, "%s/c2_%llu", osname, id); 2953*b24ab676SJeff Bonwick (void) snprintf(snap3name, MAXNAMELEN, "%s@s3_%llu", clone1name, id); 295405312e2cSMark J Musante 2955ea2f5b9eSMatthew Ahrens error = dmu_objset_snapshot(osname, strchr(snap1name, '@')+1, 2956*b24ab676SJeff Bonwick NULL, B_FALSE); 2957b2d22b66SGeorge Wilson if (error && error != EEXIST) { 2958b2d22b66SGeorge Wilson if (error == ENOSPC) { 2959*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 2960b2d22b66SGeorge Wilson goto out; 2961b2d22b66SGeorge Wilson } 2962b2d22b66SGeorge Wilson fatal(0, "dmu_take_snapshot(%s) = %d", snap1name, error); 2963b2d22b66SGeorge Wilson } 29644f5064b7SMark J Musante 2965503ad85cSMatthew Ahrens error = dmu_objset_hold(snap1name, FTAG, &clone); 29664f5064b7SMark J Musante if (error) 29674f5064b7SMark J Musante fatal(0, "dmu_open_snapshot(%s) = %d", snap1name, error); 29684f5064b7SMark J Musante 2969ae46e4c7SMatthew Ahrens error = dmu_objset_clone(clone1name, dmu_objset_ds(clone), 0); 2970503ad85cSMatthew Ahrens dmu_objset_rele(clone, FTAG); 2971b2d22b66SGeorge Wilson if (error) { 2972b2d22b66SGeorge Wilson if (error == ENOSPC) { 2973*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 2974b2d22b66SGeorge Wilson goto out; 2975b2d22b66SGeorge Wilson } 2976b2d22b66SGeorge Wilson fatal(0, "dmu_objset_create(%s) = %d", clone1name, error); 2977b2d22b66SGeorge Wilson } 29784f5064b7SMark J Musante 29794f5064b7SMark J Musante error = dmu_objset_snapshot(clone1name, strchr(snap2name, '@')+1, 2980*b24ab676SJeff Bonwick NULL, B_FALSE); 2981b2d22b66SGeorge Wilson if (error && error != EEXIST) { 2982b2d22b66SGeorge Wilson if (error == ENOSPC) { 2983*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 2984b2d22b66SGeorge Wilson goto out; 2985b2d22b66SGeorge Wilson } 2986b2d22b66SGeorge Wilson fatal(0, "dmu_open_snapshot(%s) = %d", snap2name, error); 2987b2d22b66SGeorge Wilson } 29884f5064b7SMark J Musante 29894f5064b7SMark J Musante error = dmu_objset_snapshot(clone1name, strchr(snap3name, '@')+1, 2990*b24ab676SJeff Bonwick NULL, B_FALSE); 2991b2d22b66SGeorge Wilson if (error && error != EEXIST) { 2992b2d22b66SGeorge Wilson if (error == ENOSPC) { 2993*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 2994b2d22b66SGeorge Wilson goto out; 2995b2d22b66SGeorge Wilson } 2996b2d22b66SGeorge Wilson fatal(0, "dmu_open_snapshot(%s) = %d", snap3name, error); 2997b2d22b66SGeorge Wilson } 29984f5064b7SMark J Musante 2999503ad85cSMatthew Ahrens error = dmu_objset_hold(snap3name, FTAG, &clone); 30004f5064b7SMark J Musante if (error) 30014f5064b7SMark J Musante fatal(0, "dmu_open_snapshot(%s) = %d", snap3name, error); 30024f5064b7SMark J Musante 3003ae46e4c7SMatthew Ahrens error = dmu_objset_clone(clone2name, dmu_objset_ds(clone), 0); 3004503ad85cSMatthew Ahrens dmu_objset_rele(clone, FTAG); 3005b2d22b66SGeorge Wilson if (error) { 3006b2d22b66SGeorge Wilson if (error == ENOSPC) { 3007*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 3008b2d22b66SGeorge Wilson goto out; 3009b2d22b66SGeorge Wilson } 3010b2d22b66SGeorge Wilson fatal(0, "dmu_objset_create(%s) = %d", clone2name, error); 3011b2d22b66SGeorge Wilson } 30124f5064b7SMark J Musante 3013503ad85cSMatthew Ahrens error = dsl_dataset_own(snap1name, B_FALSE, FTAG, &ds); 30144f5064b7SMark J Musante if (error) 30154f5064b7SMark J Musante fatal(0, "dsl_dataset_own(%s) = %d", snap1name, error); 3016681d9761SEric Taylor error = dsl_dataset_promote(clone2name, NULL); 30174f5064b7SMark J Musante if (error != EBUSY) 30184f5064b7SMark J Musante fatal(0, "dsl_dataset_promote(%s), %d, not EBUSY", clone2name, 30194f5064b7SMark J Musante error); 30204f5064b7SMark J Musante dsl_dataset_disown(ds, FTAG); 30214f5064b7SMark J Musante 3022b2d22b66SGeorge Wilson out: 3023*b24ab676SJeff Bonwick ztest_dsl_dataset_cleanup(osname, id); 30244f5064b7SMark J Musante 3025*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 3026fa9e4066Sahrens } 3027fa9e4066Sahrens 3028fa9e4066Sahrens /* 3029fa9e4066Sahrens * Verify that dmu_object_{alloc,free} work as expected. 3030fa9e4066Sahrens */ 3031fa9e4066Sahrens void 3032*b24ab676SJeff Bonwick ztest_dmu_object_alloc_free(ztest_ds_t *zd, uint64_t id) 3033fa9e4066Sahrens { 3034*b24ab676SJeff Bonwick ztest_od_t od[4]; 3035*b24ab676SJeff Bonwick int batchsize = sizeof (od) / sizeof (od[0]); 3036fa9e4066Sahrens 3037*b24ab676SJeff Bonwick for (int b = 0; b < batchsize; b++) 3038*b24ab676SJeff Bonwick ztest_od_init(&od[b], id, FTAG, b, DMU_OT_UINT64_OTHER, 0, 0); 3039fa9e4066Sahrens 3040fa9e4066Sahrens /* 3041*b24ab676SJeff Bonwick * Destroy the previous batch of objects, create a new batch, 3042*b24ab676SJeff Bonwick * and do some I/O on the new objects. 3043fa9e4066Sahrens */ 3044*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_TRUE) != 0) 3045*b24ab676SJeff Bonwick return; 3046fa9e4066Sahrens 3047*b24ab676SJeff Bonwick while (ztest_random(4 * batchsize) != 0) 3048*b24ab676SJeff Bonwick ztest_io(zd, od[ztest_random(batchsize)].od_object, 3049*b24ab676SJeff Bonwick ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT); 3050fa9e4066Sahrens } 3051fa9e4066Sahrens 3052fa9e4066Sahrens /* 3053fa9e4066Sahrens * Verify that dmu_{read,write} work as expected. 3054fa9e4066Sahrens */ 3055fa9e4066Sahrens void 3056*b24ab676SJeff Bonwick ztest_dmu_read_write(ztest_ds_t *zd, uint64_t id) 3057fa9e4066Sahrens { 3058*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 3059*b24ab676SJeff Bonwick ztest_od_t od[2]; 3060fa9e4066Sahrens dmu_tx_t *tx; 3061fa9e4066Sahrens int i, freeit, error; 3062fa9e4066Sahrens uint64_t n, s, txg; 3063fa9e4066Sahrens bufwad_t *packbuf, *bigbuf, *pack, *bigH, *bigT; 3064*b24ab676SJeff Bonwick uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize; 3065*b24ab676SJeff Bonwick uint64_t chunksize = (1000 + ztest_random(1000)) * sizeof (uint64_t); 3066fa9e4066Sahrens uint64_t regions = 997; 3067fa9e4066Sahrens uint64_t stride = 123456789ULL; 3068fa9e4066Sahrens uint64_t width = 40; 3069fa9e4066Sahrens int free_percent = 5; 3070fa9e4066Sahrens 3071fa9e4066Sahrens /* 3072fa9e4066Sahrens * This test uses two objects, packobj and bigobj, that are always 3073fa9e4066Sahrens * updated together (i.e. in the same tx) so that their contents are 3074fa9e4066Sahrens * in sync and can be compared. Their contents relate to each other 3075fa9e4066Sahrens * in a simple way: packobj is a dense array of 'bufwad' structures, 3076fa9e4066Sahrens * while bigobj is a sparse array of the same bufwads. Specifically, 3077fa9e4066Sahrens * for any index n, there are three bufwads that should be identical: 3078fa9e4066Sahrens * 3079fa9e4066Sahrens * packobj, at offset n * sizeof (bufwad_t) 3080fa9e4066Sahrens * bigobj, at the head of the nth chunk 3081fa9e4066Sahrens * bigobj, at the tail of the nth chunk 3082fa9e4066Sahrens * 3083fa9e4066Sahrens * The chunk size is arbitrary. It doesn't have to be a power of two, 3084fa9e4066Sahrens * and it doesn't have any relation to the object blocksize. 3085fa9e4066Sahrens * The only requirement is that it can hold at least two bufwads. 3086fa9e4066Sahrens * 3087fa9e4066Sahrens * Normally, we write the bufwad to each of these locations. 3088fa9e4066Sahrens * However, free_percent of the time we instead write zeroes to 3089fa9e4066Sahrens * packobj and perform a dmu_free_range() on bigobj. By comparing 3090fa9e4066Sahrens * bigobj to packobj, we can verify that the DMU is correctly 3091fa9e4066Sahrens * tracking which parts of an object are allocated and free, 3092fa9e4066Sahrens * and that the contents of the allocated blocks are correct. 3093fa9e4066Sahrens */ 3094fa9e4066Sahrens 3095fa9e4066Sahrens /* 3096fa9e4066Sahrens * Read the directory info. If it's the first time, set things up. 3097fa9e4066Sahrens */ 3098*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, chunksize); 3099*b24ab676SJeff Bonwick ztest_od_init(&od[1], id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, chunksize); 3100fa9e4066Sahrens 3101*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0) 3102*b24ab676SJeff Bonwick return; 3103fa9e4066Sahrens 3104*b24ab676SJeff Bonwick bigobj = od[0].od_object; 3105*b24ab676SJeff Bonwick packobj = od[1].od_object; 3106*b24ab676SJeff Bonwick chunksize = od[0].od_gen; 3107*b24ab676SJeff Bonwick ASSERT(chunksize == od[1].od_gen); 3108fa9e4066Sahrens 3109fa9e4066Sahrens /* 3110fa9e4066Sahrens * Prefetch a random chunk of the big object. 3111fa9e4066Sahrens * Our aim here is to get some async reads in flight 3112fa9e4066Sahrens * for blocks that we may free below; the DMU should 3113fa9e4066Sahrens * handle this race correctly. 3114fa9e4066Sahrens */ 3115fa9e4066Sahrens n = ztest_random(regions) * stride + ztest_random(width); 3116fa9e4066Sahrens s = 1 + ztest_random(2 * width - 1); 3117*b24ab676SJeff Bonwick dmu_prefetch(os, bigobj, n * chunksize, s * chunksize); 3118fa9e4066Sahrens 3119fa9e4066Sahrens /* 3120fa9e4066Sahrens * Pick a random index and compute the offsets into packobj and bigobj. 3121fa9e4066Sahrens */ 3122fa9e4066Sahrens n = ztest_random(regions) * stride + ztest_random(width); 3123fa9e4066Sahrens s = 1 + ztest_random(width - 1); 3124fa9e4066Sahrens 3125fa9e4066Sahrens packoff = n * sizeof (bufwad_t); 3126fa9e4066Sahrens packsize = s * sizeof (bufwad_t); 3127fa9e4066Sahrens 3128*b24ab676SJeff Bonwick bigoff = n * chunksize; 3129*b24ab676SJeff Bonwick bigsize = s * chunksize; 3130fa9e4066Sahrens 3131fa9e4066Sahrens packbuf = umem_alloc(packsize, UMEM_NOFAIL); 3132fa9e4066Sahrens bigbuf = umem_alloc(bigsize, UMEM_NOFAIL); 3133fa9e4066Sahrens 3134fa9e4066Sahrens /* 3135fa9e4066Sahrens * free_percent of the time, free a range of bigobj rather than 3136fa9e4066Sahrens * overwriting it. 3137fa9e4066Sahrens */ 3138fa9e4066Sahrens freeit = (ztest_random(100) < free_percent); 3139fa9e4066Sahrens 3140fa9e4066Sahrens /* 3141fa9e4066Sahrens * Read the current contents of our objects. 3142fa9e4066Sahrens */ 3143*b24ab676SJeff Bonwick error = dmu_read(os, packobj, packoff, packsize, packbuf, 31447bfdf011SNeil Perrin DMU_READ_PREFETCH); 3145ea8dc4b6Seschrock ASSERT3U(error, ==, 0); 3146*b24ab676SJeff Bonwick error = dmu_read(os, bigobj, bigoff, bigsize, bigbuf, 31477bfdf011SNeil Perrin DMU_READ_PREFETCH); 3148ea8dc4b6Seschrock ASSERT3U(error, ==, 0); 3149fa9e4066Sahrens 3150fa9e4066Sahrens /* 3151fa9e4066Sahrens * Get a tx for the mods to both packobj and bigobj. 3152fa9e4066Sahrens */ 3153fa9e4066Sahrens tx = dmu_tx_create(os); 3154fa9e4066Sahrens 3155*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, packobj, packoff, packsize); 3156fa9e4066Sahrens 3157fa9e4066Sahrens if (freeit) 3158*b24ab676SJeff Bonwick dmu_tx_hold_free(tx, bigobj, bigoff, bigsize); 3159fa9e4066Sahrens else 3160*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, bigobj, bigoff, bigsize); 3161fa9e4066Sahrens 3162*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3163*b24ab676SJeff Bonwick if (txg == 0) { 3164fa9e4066Sahrens umem_free(packbuf, packsize); 3165fa9e4066Sahrens umem_free(bigbuf, bigsize); 3166fa9e4066Sahrens return; 3167fa9e4066Sahrens } 3168fa9e4066Sahrens 3169*b24ab676SJeff Bonwick dmu_object_set_checksum(os, bigobj, 3170*b24ab676SJeff Bonwick (enum zio_checksum)ztest_random_dsl_prop(ZFS_PROP_CHECKSUM), tx); 3171*b24ab676SJeff Bonwick 3172*b24ab676SJeff Bonwick dmu_object_set_compress(os, bigobj, 3173*b24ab676SJeff Bonwick (enum zio_compress)ztest_random_dsl_prop(ZFS_PROP_COMPRESSION), tx); 3174fa9e4066Sahrens 3175fa9e4066Sahrens /* 3176fa9e4066Sahrens * For each index from n to n + s, verify that the existing bufwad 3177fa9e4066Sahrens * in packobj matches the bufwads at the head and tail of the 3178fa9e4066Sahrens * corresponding chunk in bigobj. Then update all three bufwads 3179fa9e4066Sahrens * with the new values we want to write out. 3180fa9e4066Sahrens */ 3181fa9e4066Sahrens for (i = 0; i < s; i++) { 3182fa9e4066Sahrens /* LINTED */ 3183fa9e4066Sahrens pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t)); 3184fa9e4066Sahrens /* LINTED */ 3185*b24ab676SJeff Bonwick bigH = (bufwad_t *)((char *)bigbuf + i * chunksize); 3186fa9e4066Sahrens /* LINTED */ 3187*b24ab676SJeff Bonwick bigT = (bufwad_t *)((char *)bigH + chunksize) - 1; 3188fa9e4066Sahrens 3189fa9e4066Sahrens ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize); 3190fa9e4066Sahrens ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize); 3191fa9e4066Sahrens 3192fa9e4066Sahrens if (pack->bw_txg > txg) 3193fa9e4066Sahrens fatal(0, "future leak: got %llx, open txg is %llx", 3194fa9e4066Sahrens pack->bw_txg, txg); 3195fa9e4066Sahrens 3196fa9e4066Sahrens if (pack->bw_data != 0 && pack->bw_index != n + i) 3197fa9e4066Sahrens fatal(0, "wrong index: got %llx, wanted %llx+%llx", 3198fa9e4066Sahrens pack->bw_index, n, i); 3199fa9e4066Sahrens 3200fa9e4066Sahrens if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0) 3201fa9e4066Sahrens fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH); 3202fa9e4066Sahrens 3203fa9e4066Sahrens if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0) 3204fa9e4066Sahrens fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT); 3205fa9e4066Sahrens 3206fa9e4066Sahrens if (freeit) { 3207fa9e4066Sahrens bzero(pack, sizeof (bufwad_t)); 3208fa9e4066Sahrens } else { 3209fa9e4066Sahrens pack->bw_index = n + i; 3210fa9e4066Sahrens pack->bw_txg = txg; 3211fa9e4066Sahrens pack->bw_data = 1 + ztest_random(-2ULL); 3212fa9e4066Sahrens } 3213fa9e4066Sahrens *bigH = *pack; 3214fa9e4066Sahrens *bigT = *pack; 3215fa9e4066Sahrens } 3216fa9e4066Sahrens 3217fa9e4066Sahrens /* 3218fa9e4066Sahrens * We've verified all the old bufwads, and made new ones. 3219fa9e4066Sahrens * Now write them out. 3220fa9e4066Sahrens */ 3221*b24ab676SJeff Bonwick dmu_write(os, packobj, packoff, packsize, packbuf, tx); 3222fa9e4066Sahrens 3223fa9e4066Sahrens if (freeit) { 3224*b24ab676SJeff Bonwick if (zopt_verbose >= 7) { 3225fa9e4066Sahrens (void) printf("freeing offset %llx size %llx" 3226fa9e4066Sahrens " txg %llx\n", 3227fa9e4066Sahrens (u_longlong_t)bigoff, 3228fa9e4066Sahrens (u_longlong_t)bigsize, 3229fa9e4066Sahrens (u_longlong_t)txg); 3230fa9e4066Sahrens } 3231*b24ab676SJeff Bonwick VERIFY(0 == dmu_free_range(os, bigobj, bigoff, bigsize, tx)); 3232fa9e4066Sahrens } else { 3233*b24ab676SJeff Bonwick if (zopt_verbose >= 7) { 3234fa9e4066Sahrens (void) printf("writing offset %llx size %llx" 3235fa9e4066Sahrens " txg %llx\n", 3236fa9e4066Sahrens (u_longlong_t)bigoff, 3237fa9e4066Sahrens (u_longlong_t)bigsize, 3238fa9e4066Sahrens (u_longlong_t)txg); 3239fa9e4066Sahrens } 3240*b24ab676SJeff Bonwick dmu_write(os, bigobj, bigoff, bigsize, bigbuf, tx); 3241fa9e4066Sahrens } 3242fa9e4066Sahrens 3243fa9e4066Sahrens dmu_tx_commit(tx); 3244fa9e4066Sahrens 3245fa9e4066Sahrens /* 3246fa9e4066Sahrens * Sanity check the stuff we just wrote. 3247fa9e4066Sahrens */ 3248fa9e4066Sahrens { 3249fa9e4066Sahrens void *packcheck = umem_alloc(packsize, UMEM_NOFAIL); 3250fa9e4066Sahrens void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL); 3251fa9e4066Sahrens 3252*b24ab676SJeff Bonwick VERIFY(0 == dmu_read(os, packobj, packoff, 32537bfdf011SNeil Perrin packsize, packcheck, DMU_READ_PREFETCH)); 3254*b24ab676SJeff Bonwick VERIFY(0 == dmu_read(os, bigobj, bigoff, 32557bfdf011SNeil Perrin bigsize, bigcheck, DMU_READ_PREFETCH)); 3256fa9e4066Sahrens 3257fa9e4066Sahrens ASSERT(bcmp(packbuf, packcheck, packsize) == 0); 3258fa9e4066Sahrens ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0); 3259fa9e4066Sahrens 3260fa9e4066Sahrens umem_free(packcheck, packsize); 3261fa9e4066Sahrens umem_free(bigcheck, bigsize); 3262fa9e4066Sahrens } 3263fa9e4066Sahrens 3264fa9e4066Sahrens umem_free(packbuf, packsize); 3265fa9e4066Sahrens umem_free(bigbuf, bigsize); 3266fa9e4066Sahrens } 3267fa9e4066Sahrens 32682fdbea25SAleksandr Guzovskiy void 32692fdbea25SAleksandr Guzovskiy compare_and_update_pbbufs(uint64_t s, bufwad_t *packbuf, bufwad_t *bigbuf, 3270*b24ab676SJeff Bonwick uint64_t bigsize, uint64_t n, uint64_t chunksize, uint64_t txg) 32712fdbea25SAleksandr Guzovskiy { 32722fdbea25SAleksandr Guzovskiy uint64_t i; 32732fdbea25SAleksandr Guzovskiy bufwad_t *pack; 32742fdbea25SAleksandr Guzovskiy bufwad_t *bigH; 32752fdbea25SAleksandr Guzovskiy bufwad_t *bigT; 32762fdbea25SAleksandr Guzovskiy 32772fdbea25SAleksandr Guzovskiy /* 32782fdbea25SAleksandr Guzovskiy * For each index from n to n + s, verify that the existing bufwad 32792fdbea25SAleksandr Guzovskiy * in packobj matches the bufwads at the head and tail of the 32802fdbea25SAleksandr Guzovskiy * corresponding chunk in bigobj. Then update all three bufwads 32812fdbea25SAleksandr Guzovskiy * with the new values we want to write out. 32822fdbea25SAleksandr Guzovskiy */ 32832fdbea25SAleksandr Guzovskiy for (i = 0; i < s; i++) { 32842fdbea25SAleksandr Guzovskiy /* LINTED */ 32852fdbea25SAleksandr Guzovskiy pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t)); 32862fdbea25SAleksandr Guzovskiy /* LINTED */ 3287*b24ab676SJeff Bonwick bigH = (bufwad_t *)((char *)bigbuf + i * chunksize); 32882fdbea25SAleksandr Guzovskiy /* LINTED */ 3289*b24ab676SJeff Bonwick bigT = (bufwad_t *)((char *)bigH + chunksize) - 1; 32902fdbea25SAleksandr Guzovskiy 32912fdbea25SAleksandr Guzovskiy ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize); 32922fdbea25SAleksandr Guzovskiy ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize); 32932fdbea25SAleksandr Guzovskiy 32942fdbea25SAleksandr Guzovskiy if (pack->bw_txg > txg) 32952fdbea25SAleksandr Guzovskiy fatal(0, "future leak: got %llx, open txg is %llx", 32962fdbea25SAleksandr Guzovskiy pack->bw_txg, txg); 32972fdbea25SAleksandr Guzovskiy 32982fdbea25SAleksandr Guzovskiy if (pack->bw_data != 0 && pack->bw_index != n + i) 32992fdbea25SAleksandr Guzovskiy fatal(0, "wrong index: got %llx, wanted %llx+%llx", 33002fdbea25SAleksandr Guzovskiy pack->bw_index, n, i); 33012fdbea25SAleksandr Guzovskiy 33022fdbea25SAleksandr Guzovskiy if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0) 33032fdbea25SAleksandr Guzovskiy fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH); 33042fdbea25SAleksandr Guzovskiy 33052fdbea25SAleksandr Guzovskiy if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0) 33062fdbea25SAleksandr Guzovskiy fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT); 33072fdbea25SAleksandr Guzovskiy 33082fdbea25SAleksandr Guzovskiy pack->bw_index = n + i; 33092fdbea25SAleksandr Guzovskiy pack->bw_txg = txg; 33102fdbea25SAleksandr Guzovskiy pack->bw_data = 1 + ztest_random(-2ULL); 33112fdbea25SAleksandr Guzovskiy 33122fdbea25SAleksandr Guzovskiy *bigH = *pack; 33132fdbea25SAleksandr Guzovskiy *bigT = *pack; 33142fdbea25SAleksandr Guzovskiy } 33152fdbea25SAleksandr Guzovskiy } 33162fdbea25SAleksandr Guzovskiy 33172fdbea25SAleksandr Guzovskiy void 3318*b24ab676SJeff Bonwick ztest_dmu_read_write_zcopy(ztest_ds_t *zd, uint64_t id) 33192fdbea25SAleksandr Guzovskiy { 3320*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 3321*b24ab676SJeff Bonwick ztest_od_t od[2]; 33222fdbea25SAleksandr Guzovskiy dmu_tx_t *tx; 33232fdbea25SAleksandr Guzovskiy uint64_t i; 33242fdbea25SAleksandr Guzovskiy int error; 33252fdbea25SAleksandr Guzovskiy uint64_t n, s, txg; 33262fdbea25SAleksandr Guzovskiy bufwad_t *packbuf, *bigbuf; 3327*b24ab676SJeff Bonwick uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize; 3328*b24ab676SJeff Bonwick uint64_t blocksize = ztest_random_blocksize(); 3329*b24ab676SJeff Bonwick uint64_t chunksize = blocksize; 33302fdbea25SAleksandr Guzovskiy uint64_t regions = 997; 33312fdbea25SAleksandr Guzovskiy uint64_t stride = 123456789ULL; 33322fdbea25SAleksandr Guzovskiy uint64_t width = 9; 33332fdbea25SAleksandr Guzovskiy dmu_buf_t *bonus_db; 33342fdbea25SAleksandr Guzovskiy arc_buf_t **bigbuf_arcbufs; 3335*b24ab676SJeff Bonwick dmu_object_info_t doi; 33362fdbea25SAleksandr Guzovskiy 33372fdbea25SAleksandr Guzovskiy /* 33382fdbea25SAleksandr Guzovskiy * This test uses two objects, packobj and bigobj, that are always 33392fdbea25SAleksandr Guzovskiy * updated together (i.e. in the same tx) so that their contents are 33402fdbea25SAleksandr Guzovskiy * in sync and can be compared. Their contents relate to each other 33412fdbea25SAleksandr Guzovskiy * in a simple way: packobj is a dense array of 'bufwad' structures, 33422fdbea25SAleksandr Guzovskiy * while bigobj is a sparse array of the same bufwads. Specifically, 33432fdbea25SAleksandr Guzovskiy * for any index n, there are three bufwads that should be identical: 33442fdbea25SAleksandr Guzovskiy * 33452fdbea25SAleksandr Guzovskiy * packobj, at offset n * sizeof (bufwad_t) 33462fdbea25SAleksandr Guzovskiy * bigobj, at the head of the nth chunk 33472fdbea25SAleksandr Guzovskiy * bigobj, at the tail of the nth chunk 33482fdbea25SAleksandr Guzovskiy * 33492fdbea25SAleksandr Guzovskiy * The chunk size is set equal to bigobj block size so that 33502fdbea25SAleksandr Guzovskiy * dmu_assign_arcbuf() can be tested for object updates. 33512fdbea25SAleksandr Guzovskiy */ 33522fdbea25SAleksandr Guzovskiy 33532fdbea25SAleksandr Guzovskiy /* 33542fdbea25SAleksandr Guzovskiy * Read the directory info. If it's the first time, set things up. 33552fdbea25SAleksandr Guzovskiy */ 3356*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0); 3357*b24ab676SJeff Bonwick ztest_od_init(&od[1], id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, chunksize); 33582fdbea25SAleksandr Guzovskiy 3359*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0) 3360*b24ab676SJeff Bonwick return; 33612fdbea25SAleksandr Guzovskiy 3362*b24ab676SJeff Bonwick bigobj = od[0].od_object; 3363*b24ab676SJeff Bonwick packobj = od[1].od_object; 3364*b24ab676SJeff Bonwick blocksize = od[0].od_blocksize; 3365*b24ab676SJeff Bonwick chunksize = blocksize; 3366*b24ab676SJeff Bonwick ASSERT(chunksize == od[1].od_gen); 33672fdbea25SAleksandr Guzovskiy 3368*b24ab676SJeff Bonwick VERIFY(dmu_object_info(os, bigobj, &doi) == 0); 3369*b24ab676SJeff Bonwick VERIFY(ISP2(doi.doi_data_block_size)); 3370*b24ab676SJeff Bonwick VERIFY(chunksize == doi.doi_data_block_size); 3371*b24ab676SJeff Bonwick VERIFY(chunksize >= 2 * sizeof (bufwad_t)); 33722fdbea25SAleksandr Guzovskiy 33732fdbea25SAleksandr Guzovskiy /* 33742fdbea25SAleksandr Guzovskiy * Pick a random index and compute the offsets into packobj and bigobj. 33752fdbea25SAleksandr Guzovskiy */ 33762fdbea25SAleksandr Guzovskiy n = ztest_random(regions) * stride + ztest_random(width); 33772fdbea25SAleksandr Guzovskiy s = 1 + ztest_random(width - 1); 33782fdbea25SAleksandr Guzovskiy 33792fdbea25SAleksandr Guzovskiy packoff = n * sizeof (bufwad_t); 33802fdbea25SAleksandr Guzovskiy packsize = s * sizeof (bufwad_t); 33812fdbea25SAleksandr Guzovskiy 3382*b24ab676SJeff Bonwick bigoff = n * chunksize; 3383*b24ab676SJeff Bonwick bigsize = s * chunksize; 33842fdbea25SAleksandr Guzovskiy 33852fdbea25SAleksandr Guzovskiy packbuf = umem_zalloc(packsize, UMEM_NOFAIL); 33862fdbea25SAleksandr Guzovskiy bigbuf = umem_zalloc(bigsize, UMEM_NOFAIL); 33872fdbea25SAleksandr Guzovskiy 3388*b24ab676SJeff Bonwick VERIFY3U(0, ==, dmu_bonus_hold(os, bigobj, FTAG, &bonus_db)); 33892fdbea25SAleksandr Guzovskiy 33902fdbea25SAleksandr Guzovskiy bigbuf_arcbufs = umem_zalloc(2 * s * sizeof (arc_buf_t *), UMEM_NOFAIL); 33912fdbea25SAleksandr Guzovskiy 33922fdbea25SAleksandr Guzovskiy /* 33932fdbea25SAleksandr Guzovskiy * Iteration 0 test zcopy for DB_UNCACHED dbufs. 33942fdbea25SAleksandr Guzovskiy * Iteration 1 test zcopy to already referenced dbufs. 33952fdbea25SAleksandr Guzovskiy * Iteration 2 test zcopy to dirty dbuf in the same txg. 33962fdbea25SAleksandr Guzovskiy * Iteration 3 test zcopy to dbuf dirty in previous txg. 33972fdbea25SAleksandr Guzovskiy * Iteration 4 test zcopy when dbuf is no longer dirty. 33982fdbea25SAleksandr Guzovskiy * Iteration 5 test zcopy when it can't be done. 33992fdbea25SAleksandr Guzovskiy * Iteration 6 one more zcopy write. 34002fdbea25SAleksandr Guzovskiy */ 34012fdbea25SAleksandr Guzovskiy for (i = 0; i < 7; i++) { 34022fdbea25SAleksandr Guzovskiy uint64_t j; 34032fdbea25SAleksandr Guzovskiy uint64_t off; 34042fdbea25SAleksandr Guzovskiy 34052fdbea25SAleksandr Guzovskiy /* 34062fdbea25SAleksandr Guzovskiy * In iteration 5 (i == 5) use arcbufs 34072fdbea25SAleksandr Guzovskiy * that don't match bigobj blksz to test 34082fdbea25SAleksandr Guzovskiy * dmu_assign_arcbuf() when it can't directly 34092fdbea25SAleksandr Guzovskiy * assign an arcbuf to a dbuf. 34102fdbea25SAleksandr Guzovskiy */ 34112fdbea25SAleksandr Guzovskiy for (j = 0; j < s; j++) { 34122fdbea25SAleksandr Guzovskiy if (i != 5) { 34132fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[j] = 3414*b24ab676SJeff Bonwick dmu_request_arcbuf(bonus_db, chunksize); 34152fdbea25SAleksandr Guzovskiy } else { 34162fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j] = 3417*b24ab676SJeff Bonwick dmu_request_arcbuf(bonus_db, chunksize / 2); 34182fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j + 1] = 3419*b24ab676SJeff Bonwick dmu_request_arcbuf(bonus_db, chunksize / 2); 34202fdbea25SAleksandr Guzovskiy } 34212fdbea25SAleksandr Guzovskiy } 34222fdbea25SAleksandr Guzovskiy 34232fdbea25SAleksandr Guzovskiy /* 34242fdbea25SAleksandr Guzovskiy * Get a tx for the mods to both packobj and bigobj. 34252fdbea25SAleksandr Guzovskiy */ 34262fdbea25SAleksandr Guzovskiy tx = dmu_tx_create(os); 34272fdbea25SAleksandr Guzovskiy 3428*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, packobj, packoff, packsize); 3429*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, bigobj, bigoff, bigsize); 34302fdbea25SAleksandr Guzovskiy 3431*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3432*b24ab676SJeff Bonwick if (txg == 0) { 34332fdbea25SAleksandr Guzovskiy umem_free(packbuf, packsize); 34342fdbea25SAleksandr Guzovskiy umem_free(bigbuf, bigsize); 34352fdbea25SAleksandr Guzovskiy for (j = 0; j < s; j++) { 34362fdbea25SAleksandr Guzovskiy if (i != 5) { 34372fdbea25SAleksandr Guzovskiy dmu_return_arcbuf(bigbuf_arcbufs[j]); 34382fdbea25SAleksandr Guzovskiy } else { 34392fdbea25SAleksandr Guzovskiy dmu_return_arcbuf( 34402fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j]); 34412fdbea25SAleksandr Guzovskiy dmu_return_arcbuf( 34422fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j + 1]); 34432fdbea25SAleksandr Guzovskiy } 34442fdbea25SAleksandr Guzovskiy } 34452fdbea25SAleksandr Guzovskiy umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *)); 34462fdbea25SAleksandr Guzovskiy dmu_buf_rele(bonus_db, FTAG); 34472fdbea25SAleksandr Guzovskiy return; 34482fdbea25SAleksandr Guzovskiy } 34492fdbea25SAleksandr Guzovskiy 34502fdbea25SAleksandr Guzovskiy /* 34512fdbea25SAleksandr Guzovskiy * 50% of the time don't read objects in the 1st iteration to 34522fdbea25SAleksandr Guzovskiy * test dmu_assign_arcbuf() for the case when there're no 34532fdbea25SAleksandr Guzovskiy * existing dbufs for the specified offsets. 34542fdbea25SAleksandr Guzovskiy */ 34552fdbea25SAleksandr Guzovskiy if (i != 0 || ztest_random(2) != 0) { 3456*b24ab676SJeff Bonwick error = dmu_read(os, packobj, packoff, 34577bfdf011SNeil Perrin packsize, packbuf, DMU_READ_PREFETCH); 34582fdbea25SAleksandr Guzovskiy ASSERT3U(error, ==, 0); 3459*b24ab676SJeff Bonwick error = dmu_read(os, bigobj, bigoff, bigsize, 34607bfdf011SNeil Perrin bigbuf, DMU_READ_PREFETCH); 34612fdbea25SAleksandr Guzovskiy ASSERT3U(error, ==, 0); 34622fdbea25SAleksandr Guzovskiy } 34632fdbea25SAleksandr Guzovskiy compare_and_update_pbbufs(s, packbuf, bigbuf, bigsize, 3464*b24ab676SJeff Bonwick n, chunksize, txg); 34652fdbea25SAleksandr Guzovskiy 34662fdbea25SAleksandr Guzovskiy /* 34672fdbea25SAleksandr Guzovskiy * We've verified all the old bufwads, and made new ones. 34682fdbea25SAleksandr Guzovskiy * Now write them out. 34692fdbea25SAleksandr Guzovskiy */ 3470*b24ab676SJeff Bonwick dmu_write(os, packobj, packoff, packsize, packbuf, tx); 3471*b24ab676SJeff Bonwick if (zopt_verbose >= 7) { 34722fdbea25SAleksandr Guzovskiy (void) printf("writing offset %llx size %llx" 34732fdbea25SAleksandr Guzovskiy " txg %llx\n", 34742fdbea25SAleksandr Guzovskiy (u_longlong_t)bigoff, 34752fdbea25SAleksandr Guzovskiy (u_longlong_t)bigsize, 34762fdbea25SAleksandr Guzovskiy (u_longlong_t)txg); 34772fdbea25SAleksandr Guzovskiy } 3478*b24ab676SJeff Bonwick for (off = bigoff, j = 0; j < s; j++, off += chunksize) { 34792fdbea25SAleksandr Guzovskiy dmu_buf_t *dbt; 34802fdbea25SAleksandr Guzovskiy if (i != 5) { 34812fdbea25SAleksandr Guzovskiy bcopy((caddr_t)bigbuf + (off - bigoff), 3482*b24ab676SJeff Bonwick bigbuf_arcbufs[j]->b_data, chunksize); 34832fdbea25SAleksandr Guzovskiy } else { 34842fdbea25SAleksandr Guzovskiy bcopy((caddr_t)bigbuf + (off - bigoff), 34852fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j]->b_data, 3486*b24ab676SJeff Bonwick chunksize / 2); 34872fdbea25SAleksandr Guzovskiy bcopy((caddr_t)bigbuf + (off - bigoff) + 3488*b24ab676SJeff Bonwick chunksize / 2, 34892fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j + 1]->b_data, 3490*b24ab676SJeff Bonwick chunksize / 2); 34912fdbea25SAleksandr Guzovskiy } 34922fdbea25SAleksandr Guzovskiy 34932fdbea25SAleksandr Guzovskiy if (i == 1) { 3494*b24ab676SJeff Bonwick VERIFY(dmu_buf_hold(os, bigobj, off, 34952fdbea25SAleksandr Guzovskiy FTAG, &dbt) == 0); 34962fdbea25SAleksandr Guzovskiy } 34972fdbea25SAleksandr Guzovskiy if (i != 5) { 34982fdbea25SAleksandr Guzovskiy dmu_assign_arcbuf(bonus_db, off, 34992fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[j], tx); 35002fdbea25SAleksandr Guzovskiy } else { 35012fdbea25SAleksandr Guzovskiy dmu_assign_arcbuf(bonus_db, off, 35022fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j], tx); 35032fdbea25SAleksandr Guzovskiy dmu_assign_arcbuf(bonus_db, 3504*b24ab676SJeff Bonwick off + chunksize / 2, 35052fdbea25SAleksandr Guzovskiy bigbuf_arcbufs[2 * j + 1], tx); 35062fdbea25SAleksandr Guzovskiy } 35072fdbea25SAleksandr Guzovskiy if (i == 1) { 35082fdbea25SAleksandr Guzovskiy dmu_buf_rele(dbt, FTAG); 35092fdbea25SAleksandr Guzovskiy } 35102fdbea25SAleksandr Guzovskiy } 35112fdbea25SAleksandr Guzovskiy dmu_tx_commit(tx); 35122fdbea25SAleksandr Guzovskiy 35132fdbea25SAleksandr Guzovskiy /* 35142fdbea25SAleksandr Guzovskiy * Sanity check the stuff we just wrote. 35152fdbea25SAleksandr Guzovskiy */ 35162fdbea25SAleksandr Guzovskiy { 35172fdbea25SAleksandr Guzovskiy void *packcheck = umem_alloc(packsize, UMEM_NOFAIL); 35182fdbea25SAleksandr Guzovskiy void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL); 35192fdbea25SAleksandr Guzovskiy 3520*b24ab676SJeff Bonwick VERIFY(0 == dmu_read(os, packobj, packoff, 35217bfdf011SNeil Perrin packsize, packcheck, DMU_READ_PREFETCH)); 3522*b24ab676SJeff Bonwick VERIFY(0 == dmu_read(os, bigobj, bigoff, 35237bfdf011SNeil Perrin bigsize, bigcheck, DMU_READ_PREFETCH)); 35242fdbea25SAleksandr Guzovskiy 35252fdbea25SAleksandr Guzovskiy ASSERT(bcmp(packbuf, packcheck, packsize) == 0); 35262fdbea25SAleksandr Guzovskiy ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0); 35272fdbea25SAleksandr Guzovskiy 35282fdbea25SAleksandr Guzovskiy umem_free(packcheck, packsize); 35292fdbea25SAleksandr Guzovskiy umem_free(bigcheck, bigsize); 35302fdbea25SAleksandr Guzovskiy } 35312fdbea25SAleksandr Guzovskiy if (i == 2) { 3532*b24ab676SJeff Bonwick txg_wait_open(dmu_objset_pool(os), 0); 3533*b24ab676SJeff Bonwick } else if (i == 3) { 3534*b24ab676SJeff Bonwick txg_wait_synced(dmu_objset_pool(os), 0); 3535fa9e4066Sahrens } 3536e05725b1Sbonwick } 3537e05725b1Sbonwick 3538*b24ab676SJeff Bonwick dmu_buf_rele(bonus_db, FTAG); 3539*b24ab676SJeff Bonwick umem_free(packbuf, packsize); 3540*b24ab676SJeff Bonwick umem_free(bigbuf, bigsize); 3541*b24ab676SJeff Bonwick umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *)); 3542*b24ab676SJeff Bonwick } 3543fa9e4066Sahrens 3544*b24ab676SJeff Bonwick /* ARGSUSED */ 3545*b24ab676SJeff Bonwick void 3546*b24ab676SJeff Bonwick ztest_dmu_write_parallel(ztest_ds_t *zd, uint64_t id) 3547*b24ab676SJeff Bonwick { 3548*b24ab676SJeff Bonwick ztest_od_t od[1]; 3549*b24ab676SJeff Bonwick uint64_t offset = (1ULL << (ztest_random(20) + 43)) + 3550*b24ab676SJeff Bonwick (ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT); 3551fa9e4066Sahrens 3552e05725b1Sbonwick /* 3553*b24ab676SJeff Bonwick * Have multiple threads write to large offsets in an object 3554*b24ab676SJeff Bonwick * to verify that parallel writes to an object -- even to the 3555*b24ab676SJeff Bonwick * same blocks within the object -- doesn't cause any trouble. 3556e05725b1Sbonwick */ 3557*b24ab676SJeff Bonwick ztest_od_init(&od[0], ID_PARALLEL, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0); 3558fa9e4066Sahrens 3559*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0) 3560e05725b1Sbonwick return; 3561fa9e4066Sahrens 3562*b24ab676SJeff Bonwick while (ztest_random(10) != 0) 3563*b24ab676SJeff Bonwick ztest_io(zd, od[0].od_object, offset); 3564*b24ab676SJeff Bonwick } 3565fa9e4066Sahrens 3566*b24ab676SJeff Bonwick void 3567*b24ab676SJeff Bonwick ztest_dmu_prealloc(ztest_ds_t *zd, uint64_t id) 3568*b24ab676SJeff Bonwick { 3569*b24ab676SJeff Bonwick ztest_od_t od[1]; 3570*b24ab676SJeff Bonwick uint64_t offset = (1ULL << (ztest_random(4) + SPA_MAXBLOCKSHIFT)) + 3571*b24ab676SJeff Bonwick (ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT); 3572*b24ab676SJeff Bonwick uint64_t count = ztest_random(20) + 1; 3573*b24ab676SJeff Bonwick uint64_t blocksize = ztest_random_blocksize(); 3574*b24ab676SJeff Bonwick void *data; 3575fa9e4066Sahrens 3576*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0); 3577fa9e4066Sahrens 3578*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), !ztest_random(2)) != 0) 3579e05725b1Sbonwick return; 35800e34b6a7Sbonwick 3581*b24ab676SJeff Bonwick if (ztest_truncate(zd, od[0].od_object, offset, count * blocksize) != 0) 3582f4a72450SJeff Bonwick return; 3583f4a72450SJeff Bonwick 3584*b24ab676SJeff Bonwick ztest_prealloc(zd, od[0].od_object, offset, count * blocksize); 3585fa9e4066Sahrens 3586*b24ab676SJeff Bonwick data = umem_zalloc(blocksize, UMEM_NOFAIL); 3587*b24ab676SJeff Bonwick 3588*b24ab676SJeff Bonwick while (ztest_random(count) != 0) { 3589*b24ab676SJeff Bonwick uint64_t randoff = offset + (ztest_random(count) * blocksize); 3590*b24ab676SJeff Bonwick if (ztest_write(zd, od[0].od_object, randoff, blocksize, 3591*b24ab676SJeff Bonwick data) != 0) 3592*b24ab676SJeff Bonwick break; 3593*b24ab676SJeff Bonwick while (ztest_random(4) != 0) 3594*b24ab676SJeff Bonwick ztest_io(zd, od[0].od_object, randoff); 3595*b24ab676SJeff Bonwick } 3596*b24ab676SJeff Bonwick 3597*b24ab676SJeff Bonwick umem_free(data, blocksize); 3598fa9e4066Sahrens } 3599fa9e4066Sahrens 3600fa9e4066Sahrens /* 3601fa9e4066Sahrens * Verify that zap_{create,destroy,add,remove,update} work as expected. 3602fa9e4066Sahrens */ 3603fa9e4066Sahrens #define ZTEST_ZAP_MIN_INTS 1 3604fa9e4066Sahrens #define ZTEST_ZAP_MAX_INTS 4 3605fa9e4066Sahrens #define ZTEST_ZAP_MAX_PROPS 1000 3606fa9e4066Sahrens 3607fa9e4066Sahrens void 3608*b24ab676SJeff Bonwick ztest_zap(ztest_ds_t *zd, uint64_t id) 3609fa9e4066Sahrens { 3610*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 3611*b24ab676SJeff Bonwick ztest_od_t od[1]; 3612fa9e4066Sahrens uint64_t object; 3613fa9e4066Sahrens uint64_t txg, last_txg; 3614fa9e4066Sahrens uint64_t value[ZTEST_ZAP_MAX_INTS]; 3615fa9e4066Sahrens uint64_t zl_ints, zl_intsize, prop; 3616fa9e4066Sahrens int i, ints; 3617fa9e4066Sahrens dmu_tx_t *tx; 3618fa9e4066Sahrens char propname[100], txgname[100]; 3619fa9e4066Sahrens int error; 3620fa9e4066Sahrens char *hc[2] = { "s.acl.h", ".s.open.h.hyLZlg" }; 3621fa9e4066Sahrens 3622*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0); 3623fa9e4066Sahrens 3624*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), !ztest_random(2)) != 0) 3625*b24ab676SJeff Bonwick return; 3626fa9e4066Sahrens 3627*b24ab676SJeff Bonwick object = od[0].od_object; 3628fa9e4066Sahrens 3629*b24ab676SJeff Bonwick /* 3630*b24ab676SJeff Bonwick * Generate a known hash collision, and verify that 3631*b24ab676SJeff Bonwick * we can lookup and remove both entries. 3632*b24ab676SJeff Bonwick */ 3633*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 3634*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, object, B_TRUE, NULL); 3635*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3636*b24ab676SJeff Bonwick if (txg == 0) 3637*b24ab676SJeff Bonwick return; 3638*b24ab676SJeff Bonwick for (i = 0; i < 2; i++) { 3639*b24ab676SJeff Bonwick value[i] = i; 3640*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_add(os, object, hc[i], sizeof (uint64_t), 3641*b24ab676SJeff Bonwick 1, &value[i], tx)); 3642*b24ab676SJeff Bonwick } 3643*b24ab676SJeff Bonwick for (i = 0; i < 2; i++) { 3644*b24ab676SJeff Bonwick VERIFY3U(EEXIST, ==, zap_add(os, object, hc[i], 3645*b24ab676SJeff Bonwick sizeof (uint64_t), 1, &value[i], tx)); 3646*b24ab676SJeff Bonwick VERIFY3U(0, ==, 3647*b24ab676SJeff Bonwick zap_length(os, object, hc[i], &zl_intsize, &zl_ints)); 3648*b24ab676SJeff Bonwick ASSERT3U(zl_intsize, ==, sizeof (uint64_t)); 3649*b24ab676SJeff Bonwick ASSERT3U(zl_ints, ==, 1); 3650fa9e4066Sahrens } 3651*b24ab676SJeff Bonwick for (i = 0; i < 2; i++) { 3652*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_remove(os, object, hc[i], tx)); 3653*b24ab676SJeff Bonwick } 3654*b24ab676SJeff Bonwick dmu_tx_commit(tx); 3655fa9e4066Sahrens 3656*b24ab676SJeff Bonwick /* 3657*b24ab676SJeff Bonwick * Generate a buch of random entries. 3658*b24ab676SJeff Bonwick */ 3659fa9e4066Sahrens ints = MAX(ZTEST_ZAP_MIN_INTS, object % ZTEST_ZAP_MAX_INTS); 3660fa9e4066Sahrens 3661e05725b1Sbonwick prop = ztest_random(ZTEST_ZAP_MAX_PROPS); 3662e05725b1Sbonwick (void) sprintf(propname, "prop_%llu", (u_longlong_t)prop); 3663e05725b1Sbonwick (void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop); 3664e05725b1Sbonwick bzero(value, sizeof (value)); 3665e05725b1Sbonwick last_txg = 0; 3666fa9e4066Sahrens 3667e05725b1Sbonwick /* 3668e05725b1Sbonwick * If these zap entries already exist, validate their contents. 3669e05725b1Sbonwick */ 3670e05725b1Sbonwick error = zap_length(os, object, txgname, &zl_intsize, &zl_ints); 3671e05725b1Sbonwick if (error == 0) { 3672e05725b1Sbonwick ASSERT3U(zl_intsize, ==, sizeof (uint64_t)); 3673e05725b1Sbonwick ASSERT3U(zl_ints, ==, 1); 3674fa9e4066Sahrens 3675e05725b1Sbonwick VERIFY(zap_lookup(os, object, txgname, zl_intsize, 3676e05725b1Sbonwick zl_ints, &last_txg) == 0); 3677fa9e4066Sahrens 3678e05725b1Sbonwick VERIFY(zap_length(os, object, propname, &zl_intsize, 3679e05725b1Sbonwick &zl_ints) == 0); 3680fa9e4066Sahrens 3681e05725b1Sbonwick ASSERT3U(zl_intsize, ==, sizeof (uint64_t)); 3682e05725b1Sbonwick ASSERT3U(zl_ints, ==, ints); 3683fa9e4066Sahrens 3684e05725b1Sbonwick VERIFY(zap_lookup(os, object, propname, zl_intsize, 3685e05725b1Sbonwick zl_ints, value) == 0); 3686fa9e4066Sahrens 3687e05725b1Sbonwick for (i = 0; i < ints; i++) { 3688e05725b1Sbonwick ASSERT3U(value[i], ==, last_txg + object + i); 3689fa9e4066Sahrens } 3690e05725b1Sbonwick } else { 3691e05725b1Sbonwick ASSERT3U(error, ==, ENOENT); 3692e05725b1Sbonwick } 3693fa9e4066Sahrens 3694e05725b1Sbonwick /* 3695e05725b1Sbonwick * Atomically update two entries in our zap object. 3696e05725b1Sbonwick * The first is named txg_%llu, and contains the txg 3697e05725b1Sbonwick * in which the property was last updated. The second 3698e05725b1Sbonwick * is named prop_%llu, and the nth element of its value 3699e05725b1Sbonwick * should be txg + object + n. 3700e05725b1Sbonwick */ 3701e05725b1Sbonwick tx = dmu_tx_create(os); 3702*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, object, B_TRUE, NULL); 3703*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3704*b24ab676SJeff Bonwick if (txg == 0) 3705e05725b1Sbonwick return; 3706fa9e4066Sahrens 3707e05725b1Sbonwick if (last_txg > txg) 3708e05725b1Sbonwick fatal(0, "zap future leak: old %llu new %llu", last_txg, txg); 3709fa9e4066Sahrens 3710e05725b1Sbonwick for (i = 0; i < ints; i++) 3711e05725b1Sbonwick value[i] = txg + object + i; 3712fa9e4066Sahrens 3713*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_update(os, object, txgname, sizeof (uint64_t), 3714*b24ab676SJeff Bonwick 1, &txg, tx)); 3715*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_update(os, object, propname, sizeof (uint64_t), 3716*b24ab676SJeff Bonwick ints, value, tx)); 3717fa9e4066Sahrens 3718e05725b1Sbonwick dmu_tx_commit(tx); 3719fa9e4066Sahrens 3720e05725b1Sbonwick /* 3721e05725b1Sbonwick * Remove a random pair of entries. 3722e05725b1Sbonwick */ 3723e05725b1Sbonwick prop = ztest_random(ZTEST_ZAP_MAX_PROPS); 3724e05725b1Sbonwick (void) sprintf(propname, "prop_%llu", (u_longlong_t)prop); 3725e05725b1Sbonwick (void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop); 3726fa9e4066Sahrens 3727e05725b1Sbonwick error = zap_length(os, object, txgname, &zl_intsize, &zl_ints); 3728fa9e4066Sahrens 3729e05725b1Sbonwick if (error == ENOENT) 3730e05725b1Sbonwick return; 3731fa9e4066Sahrens 3732e05725b1Sbonwick ASSERT3U(error, ==, 0); 3733fa9e4066Sahrens 3734e05725b1Sbonwick tx = dmu_tx_create(os); 3735*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, object, B_TRUE, NULL); 3736*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3737*b24ab676SJeff Bonwick if (txg == 0) 373812a2833aSSanjeev Bagewadi return; 3739*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_remove(os, object, txgname, tx)); 3740*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_remove(os, object, propname, tx)); 374112a2833aSSanjeev Bagewadi dmu_tx_commit(tx); 374212a2833aSSanjeev Bagewadi } 374312a2833aSSanjeev Bagewadi 374412a2833aSSanjeev Bagewadi /* 374512a2833aSSanjeev Bagewadi * Testcase to test the upgrading of a microzap to fatzap. 374612a2833aSSanjeev Bagewadi */ 374712a2833aSSanjeev Bagewadi void 3748*b24ab676SJeff Bonwick ztest_fzap(ztest_ds_t *zd, uint64_t id) 374912a2833aSSanjeev Bagewadi { 3750*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 3751*b24ab676SJeff Bonwick ztest_od_t od[1]; 3752*b24ab676SJeff Bonwick uint64_t object, txg; 375312a2833aSSanjeev Bagewadi 3754*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0); 375512a2833aSSanjeev Bagewadi 3756*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), !ztest_random(2)) != 0) 3757*b24ab676SJeff Bonwick return; 375812a2833aSSanjeev Bagewadi 3759*b24ab676SJeff Bonwick object = od[0].od_object; 376012a2833aSSanjeev Bagewadi 376112a2833aSSanjeev Bagewadi /* 3762*b24ab676SJeff Bonwick * Add entries to this ZAP and make sure it spills over 376312a2833aSSanjeev Bagewadi * and gets upgraded to a fatzap. Also, since we are adding 3764*b24ab676SJeff Bonwick * 2050 entries we should see ptrtbl growth and leaf-block split. 376512a2833aSSanjeev Bagewadi */ 3766*b24ab676SJeff Bonwick for (int i = 0; i < 2050; i++) { 3767*b24ab676SJeff Bonwick char name[MAXNAMELEN]; 3768*b24ab676SJeff Bonwick uint64_t value = i; 3769*b24ab676SJeff Bonwick dmu_tx_t *tx; 3770*b24ab676SJeff Bonwick int error; 377112a2833aSSanjeev Bagewadi 3772*b24ab676SJeff Bonwick (void) snprintf(name, sizeof (name), "fzap-%llu-%llu", 3773*b24ab676SJeff Bonwick id, value); 377412a2833aSSanjeev Bagewadi 3775*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 3776*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, object, B_TRUE, name); 3777*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3778*b24ab676SJeff Bonwick if (txg == 0) 377912a2833aSSanjeev Bagewadi return; 3780*b24ab676SJeff Bonwick error = zap_add(os, object, name, sizeof (uint64_t), 1, 3781*b24ab676SJeff Bonwick &value, tx); 378212a2833aSSanjeev Bagewadi ASSERT(error == 0 || error == EEXIST); 378312a2833aSSanjeev Bagewadi dmu_tx_commit(tx); 378412a2833aSSanjeev Bagewadi } 3785fa9e4066Sahrens } 3786fa9e4066Sahrens 3787*b24ab676SJeff Bonwick /* ARGSUSED */ 3788fa9e4066Sahrens void 3789*b24ab676SJeff Bonwick ztest_zap_parallel(ztest_ds_t *zd, uint64_t id) 3790fa9e4066Sahrens { 3791*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 3792*b24ab676SJeff Bonwick ztest_od_t od[1]; 3793fa9e4066Sahrens uint64_t txg, object, count, wsize, wc, zl_wsize, zl_wc; 3794fa9e4066Sahrens dmu_tx_t *tx; 3795fa9e4066Sahrens int i, namelen, error; 3796*b24ab676SJeff Bonwick int micro = ztest_random(2); 3797fa9e4066Sahrens char name[20], string_value[20]; 3798fa9e4066Sahrens void *data; 3799fa9e4066Sahrens 3800*b24ab676SJeff Bonwick ztest_od_init(&od[0], ID_PARALLEL, FTAG, micro, DMU_OT_ZAP_OTHER, 0, 0); 3801*b24ab676SJeff Bonwick 3802*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0) 3803*b24ab676SJeff Bonwick return; 3804*b24ab676SJeff Bonwick 3805*b24ab676SJeff Bonwick object = od[0].od_object; 3806*b24ab676SJeff Bonwick 3807e05725b1Sbonwick /* 3808e05725b1Sbonwick * Generate a random name of the form 'xxx.....' where each 3809e05725b1Sbonwick * x is a random printable character and the dots are dots. 3810e05725b1Sbonwick * There are 94 such characters, and the name length goes from 3811e05725b1Sbonwick * 6 to 20, so there are 94^3 * 15 = 12,458,760 possible names. 3812e05725b1Sbonwick */ 3813e05725b1Sbonwick namelen = ztest_random(sizeof (name) - 5) + 5 + 1; 3814fa9e4066Sahrens 3815e05725b1Sbonwick for (i = 0; i < 3; i++) 3816e05725b1Sbonwick name[i] = '!' + ztest_random('~' - '!' + 1); 3817e05725b1Sbonwick for (; i < namelen - 1; i++) 3818e05725b1Sbonwick name[i] = '.'; 3819e05725b1Sbonwick name[i] = '\0'; 3820fa9e4066Sahrens 3821*b24ab676SJeff Bonwick if ((namelen & 1) || micro) { 3822e05725b1Sbonwick wsize = sizeof (txg); 3823e05725b1Sbonwick wc = 1; 3824e05725b1Sbonwick data = &txg; 3825e05725b1Sbonwick } else { 3826e05725b1Sbonwick wsize = 1; 3827e05725b1Sbonwick wc = namelen; 3828e05725b1Sbonwick data = string_value; 3829e05725b1Sbonwick } 3830fa9e4066Sahrens 3831e05725b1Sbonwick count = -1ULL; 3832e05725b1Sbonwick VERIFY(zap_count(os, object, &count) == 0); 3833e05725b1Sbonwick ASSERT(count != -1ULL); 3834fa9e4066Sahrens 3835e05725b1Sbonwick /* 3836e05725b1Sbonwick * Select an operation: length, lookup, add, update, remove. 3837e05725b1Sbonwick */ 3838e05725b1Sbonwick i = ztest_random(5); 3839e05725b1Sbonwick 3840e05725b1Sbonwick if (i >= 2) { 3841e05725b1Sbonwick tx = dmu_tx_create(os); 3842*b24ab676SJeff Bonwick dmu_tx_hold_zap(tx, object, B_TRUE, NULL); 3843*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG); 3844*b24ab676SJeff Bonwick if (txg == 0) 3845e05725b1Sbonwick return; 3846e05725b1Sbonwick bcopy(name, string_value, namelen); 3847e05725b1Sbonwick } else { 3848e05725b1Sbonwick tx = NULL; 3849e05725b1Sbonwick txg = 0; 3850e05725b1Sbonwick bzero(string_value, namelen); 3851e05725b1Sbonwick } 3852fa9e4066Sahrens 3853e05725b1Sbonwick switch (i) { 3854fa9e4066Sahrens 3855e05725b1Sbonwick case 0: 3856e05725b1Sbonwick error = zap_length(os, object, name, &zl_wsize, &zl_wc); 3857e05725b1Sbonwick if (error == 0) { 3858e05725b1Sbonwick ASSERT3U(wsize, ==, zl_wsize); 3859e05725b1Sbonwick ASSERT3U(wc, ==, zl_wc); 3860e05725b1Sbonwick } else { 3861e05725b1Sbonwick ASSERT3U(error, ==, ENOENT); 3862e05725b1Sbonwick } 3863e05725b1Sbonwick break; 3864fa9e4066Sahrens 3865e05725b1Sbonwick case 1: 3866e05725b1Sbonwick error = zap_lookup(os, object, name, wsize, wc, data); 3867e05725b1Sbonwick if (error == 0) { 3868e05725b1Sbonwick if (data == string_value && 3869e05725b1Sbonwick bcmp(name, data, namelen) != 0) 3870e05725b1Sbonwick fatal(0, "name '%s' != val '%s' len %d", 3871e05725b1Sbonwick name, data, namelen); 3872e05725b1Sbonwick } else { 3873e05725b1Sbonwick ASSERT3U(error, ==, ENOENT); 3874e05725b1Sbonwick } 3875e05725b1Sbonwick break; 3876fa9e4066Sahrens 3877e05725b1Sbonwick case 2: 3878e05725b1Sbonwick error = zap_add(os, object, name, wsize, wc, data, tx); 3879e05725b1Sbonwick ASSERT(error == 0 || error == EEXIST); 3880e05725b1Sbonwick break; 3881fa9e4066Sahrens 3882e05725b1Sbonwick case 3: 3883e05725b1Sbonwick VERIFY(zap_update(os, object, name, wsize, wc, data, tx) == 0); 3884e05725b1Sbonwick break; 3885fa9e4066Sahrens 3886e05725b1Sbonwick case 4: 3887e05725b1Sbonwick error = zap_remove(os, object, name, tx); 3888e05725b1Sbonwick ASSERT(error == 0 || error == ENOENT); 3889e05725b1Sbonwick break; 3890fa9e4066Sahrens } 3891e05725b1Sbonwick 3892e05725b1Sbonwick if (tx != NULL) 3893e05725b1Sbonwick dmu_tx_commit(tx); 3894fa9e4066Sahrens } 3895fa9e4066Sahrens 3896d20e665cSRicardo M. Correia /* 3897d20e665cSRicardo M. Correia * Commit callback data. 3898d20e665cSRicardo M. Correia */ 3899d20e665cSRicardo M. Correia typedef struct ztest_cb_data { 3900d20e665cSRicardo M. Correia list_node_t zcd_node; 3901d20e665cSRicardo M. Correia uint64_t zcd_txg; 3902d20e665cSRicardo M. Correia int zcd_expected_err; 3903d20e665cSRicardo M. Correia boolean_t zcd_added; 3904d20e665cSRicardo M. Correia boolean_t zcd_called; 3905d20e665cSRicardo M. Correia spa_t *zcd_spa; 3906d20e665cSRicardo M. Correia } ztest_cb_data_t; 3907d20e665cSRicardo M. Correia 3908d20e665cSRicardo M. Correia /* This is the actual commit callback function */ 3909d20e665cSRicardo M. Correia static void 3910d20e665cSRicardo M. Correia ztest_commit_callback(void *arg, int error) 3911d20e665cSRicardo M. Correia { 3912d20e665cSRicardo M. Correia ztest_cb_data_t *data = arg; 3913d20e665cSRicardo M. Correia uint64_t synced_txg; 3914d20e665cSRicardo M. Correia 3915d20e665cSRicardo M. Correia VERIFY(data != NULL); 3916d20e665cSRicardo M. Correia VERIFY3S(data->zcd_expected_err, ==, error); 3917d20e665cSRicardo M. Correia VERIFY(!data->zcd_called); 3918d20e665cSRicardo M. Correia 3919d20e665cSRicardo M. Correia synced_txg = spa_last_synced_txg(data->zcd_spa); 3920d20e665cSRicardo M. Correia if (data->zcd_txg > synced_txg) 3921d20e665cSRicardo M. Correia fatal(0, "commit callback of txg %" PRIu64 " called prematurely" 3922d20e665cSRicardo M. Correia ", last synced txg = %" PRIu64 "\n", data->zcd_txg, 3923d20e665cSRicardo M. Correia synced_txg); 3924d20e665cSRicardo M. Correia 3925d20e665cSRicardo M. Correia data->zcd_called = B_TRUE; 3926d20e665cSRicardo M. Correia 3927d20e665cSRicardo M. Correia if (error == ECANCELED) { 3928d20e665cSRicardo M. Correia ASSERT3U(data->zcd_txg, ==, 0); 3929d20e665cSRicardo M. Correia ASSERT(!data->zcd_added); 3930d20e665cSRicardo M. Correia 3931d20e665cSRicardo M. Correia /* 3932d20e665cSRicardo M. Correia * The private callback data should be destroyed here, but 3933d20e665cSRicardo M. Correia * since we are going to check the zcd_called field after 3934d20e665cSRicardo M. Correia * dmu_tx_abort(), we will destroy it there. 3935d20e665cSRicardo M. Correia */ 3936d20e665cSRicardo M. Correia return; 3937d20e665cSRicardo M. Correia } 3938d20e665cSRicardo M. Correia 3939d20e665cSRicardo M. Correia /* Was this callback added to the global callback list? */ 3940d20e665cSRicardo M. Correia if (!data->zcd_added) 3941d20e665cSRicardo M. Correia goto out; 3942d20e665cSRicardo M. Correia 3943d20e665cSRicardo M. Correia ASSERT3U(data->zcd_txg, !=, 0); 3944d20e665cSRicardo M. Correia 3945d20e665cSRicardo M. Correia /* Remove our callback from the list */ 3946d20e665cSRicardo M. Correia (void) mutex_lock(&zcl.zcl_callbacks_lock); 3947d20e665cSRicardo M. Correia list_remove(&zcl.zcl_callbacks, data); 3948d20e665cSRicardo M. Correia (void) mutex_unlock(&zcl.zcl_callbacks_lock); 3949d20e665cSRicardo M. Correia 3950d20e665cSRicardo M. Correia out: 3951d20e665cSRicardo M. Correia umem_free(data, sizeof (ztest_cb_data_t)); 3952d20e665cSRicardo M. Correia } 3953d20e665cSRicardo M. Correia 3954d20e665cSRicardo M. Correia /* Allocate and initialize callback data structure */ 3955d20e665cSRicardo M. Correia static ztest_cb_data_t * 3956d20e665cSRicardo M. Correia ztest_create_cb_data(objset_t *os, uint64_t txg) 3957d20e665cSRicardo M. Correia { 3958d20e665cSRicardo M. Correia ztest_cb_data_t *cb_data; 3959d20e665cSRicardo M. Correia 3960d20e665cSRicardo M. Correia cb_data = umem_zalloc(sizeof (ztest_cb_data_t), UMEM_NOFAIL); 3961d20e665cSRicardo M. Correia 3962d20e665cSRicardo M. Correia cb_data->zcd_txg = txg; 3963d20e665cSRicardo M. Correia cb_data->zcd_spa = dmu_objset_spa(os); 3964d20e665cSRicardo M. Correia 3965d20e665cSRicardo M. Correia return (cb_data); 3966d20e665cSRicardo M. Correia } 3967d20e665cSRicardo M. Correia 3968d20e665cSRicardo M. Correia /* 3969d20e665cSRicardo M. Correia * If a number of txgs equal to this threshold have been created after a commit 3970d20e665cSRicardo M. Correia * callback has been registered but not called, then we assume there is an 3971d20e665cSRicardo M. Correia * implementation bug. 3972d20e665cSRicardo M. Correia */ 3973d20e665cSRicardo M. Correia #define ZTEST_COMMIT_CALLBACK_THRESH (TXG_CONCURRENT_STATES + 2) 3974d20e665cSRicardo M. Correia 3975d20e665cSRicardo M. Correia /* 3976d20e665cSRicardo M. Correia * Commit callback test. 3977d20e665cSRicardo M. Correia */ 3978d20e665cSRicardo M. Correia void 3979*b24ab676SJeff Bonwick ztest_dmu_commit_callbacks(ztest_ds_t *zd, uint64_t id) 3980d20e665cSRicardo M. Correia { 3981*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 3982*b24ab676SJeff Bonwick ztest_od_t od[1]; 3983d20e665cSRicardo M. Correia dmu_tx_t *tx; 3984d20e665cSRicardo M. Correia ztest_cb_data_t *cb_data[3], *tmp_cb; 3985d20e665cSRicardo M. Correia uint64_t old_txg, txg; 3986d20e665cSRicardo M. Correia int i, error; 3987d20e665cSRicardo M. Correia 3988*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0); 3989*b24ab676SJeff Bonwick 3990*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0) 3991*b24ab676SJeff Bonwick return; 3992*b24ab676SJeff Bonwick 3993d20e665cSRicardo M. Correia tx = dmu_tx_create(os); 3994d20e665cSRicardo M. Correia 3995d20e665cSRicardo M. Correia cb_data[0] = ztest_create_cb_data(os, 0); 3996d20e665cSRicardo M. Correia dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[0]); 3997d20e665cSRicardo M. Correia 3998*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, od[0].od_object, 0, sizeof (uint64_t)); 3999d20e665cSRicardo M. Correia 4000d20e665cSRicardo M. Correia /* Every once in a while, abort the transaction on purpose */ 4001d20e665cSRicardo M. Correia if (ztest_random(100) == 0) 4002d20e665cSRicardo M. Correia error = -1; 4003d20e665cSRicardo M. Correia 4004d20e665cSRicardo M. Correia if (!error) 4005d20e665cSRicardo M. Correia error = dmu_tx_assign(tx, TXG_NOWAIT); 4006d20e665cSRicardo M. Correia 4007d20e665cSRicardo M. Correia txg = error ? 0 : dmu_tx_get_txg(tx); 4008d20e665cSRicardo M. Correia 4009d20e665cSRicardo M. Correia cb_data[0]->zcd_txg = txg; 4010d20e665cSRicardo M. Correia cb_data[1] = ztest_create_cb_data(os, txg); 4011d20e665cSRicardo M. Correia dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[1]); 4012d20e665cSRicardo M. Correia 4013d20e665cSRicardo M. Correia if (error) { 4014d20e665cSRicardo M. Correia /* 4015d20e665cSRicardo M. Correia * It's not a strict requirement to call the registered 4016d20e665cSRicardo M. Correia * callbacks from inside dmu_tx_abort(), but that's what 4017d20e665cSRicardo M. Correia * it's supposed to happen in the current implementation 4018d20e665cSRicardo M. Correia * so we will check for that. 4019d20e665cSRicardo M. Correia */ 4020d20e665cSRicardo M. Correia for (i = 0; i < 2; i++) { 4021d20e665cSRicardo M. Correia cb_data[i]->zcd_expected_err = ECANCELED; 4022d20e665cSRicardo M. Correia VERIFY(!cb_data[i]->zcd_called); 4023d20e665cSRicardo M. Correia } 4024d20e665cSRicardo M. Correia 4025d20e665cSRicardo M. Correia dmu_tx_abort(tx); 4026d20e665cSRicardo M. Correia 4027d20e665cSRicardo M. Correia for (i = 0; i < 2; i++) { 4028d20e665cSRicardo M. Correia VERIFY(cb_data[i]->zcd_called); 4029d20e665cSRicardo M. Correia umem_free(cb_data[i], sizeof (ztest_cb_data_t)); 4030d20e665cSRicardo M. Correia } 4031d20e665cSRicardo M. Correia 4032d20e665cSRicardo M. Correia return; 4033d20e665cSRicardo M. Correia } 4034d20e665cSRicardo M. Correia 4035d20e665cSRicardo M. Correia cb_data[2] = ztest_create_cb_data(os, txg); 4036d20e665cSRicardo M. Correia dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[2]); 4037d20e665cSRicardo M. Correia 4038d20e665cSRicardo M. Correia /* 4039d20e665cSRicardo M. Correia * Read existing data to make sure there isn't a future leak. 4040d20e665cSRicardo M. Correia */ 4041*b24ab676SJeff Bonwick VERIFY(0 == dmu_read(os, od[0].od_object, 0, sizeof (uint64_t), 4042d20e665cSRicardo M. Correia &old_txg, DMU_READ_PREFETCH)); 4043d20e665cSRicardo M. Correia 4044d20e665cSRicardo M. Correia if (old_txg > txg) 4045d20e665cSRicardo M. Correia fatal(0, "future leak: got %" PRIu64 ", open txg is %" PRIu64, 4046d20e665cSRicardo M. Correia old_txg, txg); 4047d20e665cSRicardo M. Correia 4048*b24ab676SJeff Bonwick dmu_write(os, od[0].od_object, 0, sizeof (uint64_t), &txg, tx); 4049d20e665cSRicardo M. Correia 4050d20e665cSRicardo M. Correia (void) mutex_lock(&zcl.zcl_callbacks_lock); 4051d20e665cSRicardo M. Correia 4052d20e665cSRicardo M. Correia /* 4053d20e665cSRicardo M. Correia * Since commit callbacks don't have any ordering requirement and since 4054d20e665cSRicardo M. Correia * it is theoretically possible for a commit callback to be called 4055d20e665cSRicardo M. Correia * after an arbitrary amount of time has elapsed since its txg has been 4056d20e665cSRicardo M. Correia * synced, it is difficult to reliably determine whether a commit 4057d20e665cSRicardo M. Correia * callback hasn't been called due to high load or due to a flawed 4058d20e665cSRicardo M. Correia * implementation. 4059d20e665cSRicardo M. Correia * 4060d20e665cSRicardo M. Correia * In practice, we will assume that if after a certain number of txgs a 4061d20e665cSRicardo M. Correia * commit callback hasn't been called, then most likely there's an 4062d20e665cSRicardo M. Correia * implementation bug.. 4063d20e665cSRicardo M. Correia */ 4064d20e665cSRicardo M. Correia tmp_cb = list_head(&zcl.zcl_callbacks); 4065d20e665cSRicardo M. Correia if (tmp_cb != NULL && 4066d20e665cSRicardo M. Correia tmp_cb->zcd_txg > txg - ZTEST_COMMIT_CALLBACK_THRESH) { 4067d20e665cSRicardo M. Correia fatal(0, "Commit callback threshold exceeded, oldest txg: %" 4068d20e665cSRicardo M. Correia PRIu64 ", open txg: %" PRIu64 "\n", tmp_cb->zcd_txg, txg); 4069d20e665cSRicardo M. Correia } 4070d20e665cSRicardo M. Correia 4071d20e665cSRicardo M. Correia /* 4072d20e665cSRicardo M. Correia * Let's find the place to insert our callbacks. 4073d20e665cSRicardo M. Correia * 4074d20e665cSRicardo M. Correia * Even though the list is ordered by txg, it is possible for the 4075d20e665cSRicardo M. Correia * insertion point to not be the end because our txg may already be 4076d20e665cSRicardo M. Correia * quiescing at this point and other callbacks in the open txg 4077d20e665cSRicardo M. Correia * (from other objsets) may have sneaked in. 4078d20e665cSRicardo M. Correia */ 4079d20e665cSRicardo M. Correia tmp_cb = list_tail(&zcl.zcl_callbacks); 4080d20e665cSRicardo M. Correia while (tmp_cb != NULL && tmp_cb->zcd_txg > txg) 4081d20e665cSRicardo M. Correia tmp_cb = list_prev(&zcl.zcl_callbacks, tmp_cb); 4082d20e665cSRicardo M. Correia 4083d20e665cSRicardo M. Correia /* Add the 3 callbacks to the list */ 4084d20e665cSRicardo M. Correia for (i = 0; i < 3; i++) { 4085d20e665cSRicardo M. Correia if (tmp_cb == NULL) 4086d20e665cSRicardo M. Correia list_insert_head(&zcl.zcl_callbacks, cb_data[i]); 4087d20e665cSRicardo M. Correia else 4088d20e665cSRicardo M. Correia list_insert_after(&zcl.zcl_callbacks, tmp_cb, 4089d20e665cSRicardo M. Correia cb_data[i]); 4090d20e665cSRicardo M. Correia 4091d20e665cSRicardo M. Correia cb_data[i]->zcd_added = B_TRUE; 4092d20e665cSRicardo M. Correia VERIFY(!cb_data[i]->zcd_called); 4093d20e665cSRicardo M. Correia 4094d20e665cSRicardo M. Correia tmp_cb = cb_data[i]; 4095d20e665cSRicardo M. Correia } 4096d20e665cSRicardo M. Correia 4097d20e665cSRicardo M. Correia (void) mutex_unlock(&zcl.zcl_callbacks_lock); 4098d20e665cSRicardo M. Correia 4099d20e665cSRicardo M. Correia dmu_tx_commit(tx); 4100d20e665cSRicardo M. Correia } 4101d20e665cSRicardo M. Correia 4102*b24ab676SJeff Bonwick /* ARGSUSED */ 4103fa9e4066Sahrens void 4104*b24ab676SJeff Bonwick ztest_dsl_prop_get_set(ztest_ds_t *zd, uint64_t id) 4105fa9e4066Sahrens { 4106*b24ab676SJeff Bonwick zfs_prop_t proplist[] = { 4107*b24ab676SJeff Bonwick ZFS_PROP_CHECKSUM, 4108*b24ab676SJeff Bonwick ZFS_PROP_COMPRESSION, 4109*b24ab676SJeff Bonwick ZFS_PROP_COPIES, 4110*b24ab676SJeff Bonwick ZFS_PROP_DEDUP 4111*b24ab676SJeff Bonwick }; 4112*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4113fa9e4066Sahrens 4114*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 4115fa9e4066Sahrens 4116*b24ab676SJeff Bonwick for (int p = 0; p < sizeof (proplist) / sizeof (proplist[0]); p++) 4117*b24ab676SJeff Bonwick (void) ztest_dsl_prop_set_uint64(zd->zd_name, proplist[p], 4118*b24ab676SJeff Bonwick ztest_random_dsl_prop(proplist[p]), (int)ztest_random(2)); 4119fa9e4066Sahrens 4120*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4121*b24ab676SJeff Bonwick } 4122fa9e4066Sahrens 4123*b24ab676SJeff Bonwick /* ARGSUSED */ 4124*b24ab676SJeff Bonwick void 4125*b24ab676SJeff Bonwick ztest_spa_prop_get_set(ztest_ds_t *zd, uint64_t id) 4126*b24ab676SJeff Bonwick { 4127*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4128*b24ab676SJeff Bonwick nvlist_t *props = NULL; 4129ea8dc4b6Seschrock 4130*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 4131ea8dc4b6Seschrock 4132*b24ab676SJeff Bonwick #if 0 4133*b24ab676SJeff Bonwick (void) ztest_spa_prop_set_uint64(zs, ZPOOL_PROP_DEDUPDITTO, 4134*b24ab676SJeff Bonwick ZIO_DEDUPDITTO_MIN + ztest_random(ZIO_DEDUPDITTO_MIN)); 4135*b24ab676SJeff Bonwick #endif 4136fa9e4066Sahrens 4137*b24ab676SJeff Bonwick VERIFY3U(spa_prop_get(zs->zs_spa, &props), ==, 0); 4138fa9e4066Sahrens 4139*b24ab676SJeff Bonwick if (zopt_verbose >= 6) 4140*b24ab676SJeff Bonwick dump_nvlist(props, 4); 4141fa9e4066Sahrens 4142*b24ab676SJeff Bonwick nvlist_free(props); 4143fa9e4066Sahrens 4144*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4145fa9e4066Sahrens } 4146fa9e4066Sahrens 41475c987a37SChris Kirby /* 41485c987a37SChris Kirby * Test snapshot hold/release and deferred destroy. 41495c987a37SChris Kirby */ 41505c987a37SChris Kirby void 4151*b24ab676SJeff Bonwick ztest_dmu_snapshot_hold(ztest_ds_t *zd, uint64_t id) 41525c987a37SChris Kirby { 41535c987a37SChris Kirby int error; 4154*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 41555c987a37SChris Kirby objset_t *origin; 41565c987a37SChris Kirby char snapname[100]; 41575c987a37SChris Kirby char fullname[100]; 41585c987a37SChris Kirby char clonename[100]; 41595c987a37SChris Kirby char tag[100]; 41605c987a37SChris Kirby char osname[MAXNAMELEN]; 41615c987a37SChris Kirby 41625c987a37SChris Kirby (void) rw_rdlock(&ztest_shared->zs_name_lock); 41635c987a37SChris Kirby 41645c987a37SChris Kirby dmu_objset_name(os, osname); 41655c987a37SChris Kirby 4166*b24ab676SJeff Bonwick (void) snprintf(snapname, 100, "sh1_%llu", id); 41675c987a37SChris Kirby (void) snprintf(fullname, 100, "%s@%s", osname, snapname); 4168*b24ab676SJeff Bonwick (void) snprintf(clonename, 100, "%s/ch1_%llu", osname, id); 4169*b24ab676SJeff Bonwick (void) snprintf(tag, 100, "%tag_%llu", id); 41705c987a37SChris Kirby 41715c987a37SChris Kirby /* 41725c987a37SChris Kirby * Clean up from any previous run. 41735c987a37SChris Kirby */ 41745c987a37SChris Kirby (void) dmu_objset_destroy(clonename, B_FALSE); 41755c987a37SChris Kirby (void) dsl_dataset_user_release(osname, snapname, tag, B_FALSE); 41765c987a37SChris Kirby (void) dmu_objset_destroy(fullname, B_FALSE); 41775c987a37SChris Kirby 41785c987a37SChris Kirby /* 41795c987a37SChris Kirby * Create snapshot, clone it, mark snap for deferred destroy, 41805c987a37SChris Kirby * destroy clone, verify snap was also destroyed. 41815c987a37SChris Kirby */ 41825c987a37SChris Kirby error = dmu_objset_snapshot(osname, snapname, NULL, FALSE); 41835c987a37SChris Kirby if (error) { 41845c987a37SChris Kirby if (error == ENOSPC) { 41855c987a37SChris Kirby ztest_record_enospc("dmu_objset_snapshot"); 41865c987a37SChris Kirby goto out; 41875c987a37SChris Kirby } 41885c987a37SChris Kirby fatal(0, "dmu_objset_snapshot(%s) = %d", fullname, error); 41895c987a37SChris Kirby } 41905c987a37SChris Kirby 41915c987a37SChris Kirby error = dmu_objset_hold(fullname, FTAG, &origin); 41925c987a37SChris Kirby if (error) 41935c987a37SChris Kirby fatal(0, "dmu_objset_hold(%s) = %d", fullname, error); 41945c987a37SChris Kirby 41955c987a37SChris Kirby error = dmu_objset_clone(clonename, dmu_objset_ds(origin), 0); 41965c987a37SChris Kirby dmu_objset_rele(origin, FTAG); 41975c987a37SChris Kirby if (error) { 41985c987a37SChris Kirby if (error == ENOSPC) { 41995c987a37SChris Kirby ztest_record_enospc("dmu_objset_clone"); 42005c987a37SChris Kirby goto out; 42015c987a37SChris Kirby } 42025c987a37SChris Kirby fatal(0, "dmu_objset_clone(%s) = %d", clonename, error); 42035c987a37SChris Kirby } 42045c987a37SChris Kirby 42055c987a37SChris Kirby error = dmu_objset_destroy(fullname, B_TRUE); 42065c987a37SChris Kirby if (error) { 42075c987a37SChris Kirby fatal(0, "dmu_objset_destroy(%s, B_TRUE) = %d", 42085c987a37SChris Kirby fullname, error); 42095c987a37SChris Kirby } 42105c987a37SChris Kirby 42115c987a37SChris Kirby error = dmu_objset_destroy(clonename, B_FALSE); 42125c987a37SChris Kirby if (error) 42135c987a37SChris Kirby fatal(0, "dmu_objset_destroy(%s) = %d", clonename, error); 42145c987a37SChris Kirby 42155c987a37SChris Kirby error = dmu_objset_hold(fullname, FTAG, &origin); 42165c987a37SChris Kirby if (error != ENOENT) 42175c987a37SChris Kirby fatal(0, "dmu_objset_hold(%s) = %d", fullname, error); 42185c987a37SChris Kirby 42195c987a37SChris Kirby /* 42205c987a37SChris Kirby * Create snapshot, add temporary hold, verify that we can't 42215c987a37SChris Kirby * destroy a held snapshot, mark for deferred destroy, 42225c987a37SChris Kirby * release hold, verify snapshot was destroyed. 42235c987a37SChris Kirby */ 42245c987a37SChris Kirby error = dmu_objset_snapshot(osname, snapname, NULL, FALSE); 42255c987a37SChris Kirby if (error) { 42265c987a37SChris Kirby if (error == ENOSPC) { 42275c987a37SChris Kirby ztest_record_enospc("dmu_objset_snapshot"); 42285c987a37SChris Kirby goto out; 42295c987a37SChris Kirby } 42305c987a37SChris Kirby fatal(0, "dmu_objset_snapshot(%s) = %d", fullname, error); 42315c987a37SChris Kirby } 42325c987a37SChris Kirby 42335c987a37SChris Kirby error = dsl_dataset_user_hold(osname, snapname, tag, B_FALSE, B_TRUE); 42345c987a37SChris Kirby if (error) 42355c987a37SChris Kirby fatal(0, "dsl_dataset_user_hold(%s)", fullname, tag); 42365c987a37SChris Kirby 42375c987a37SChris Kirby error = dmu_objset_destroy(fullname, B_FALSE); 42385c987a37SChris Kirby if (error != EBUSY) { 42395c987a37SChris Kirby fatal(0, "dmu_objset_destroy(%s, B_FALSE) = %d", 42405c987a37SChris Kirby fullname, error); 42415c987a37SChris Kirby } 42425c987a37SChris Kirby 42435c987a37SChris Kirby error = dmu_objset_destroy(fullname, B_TRUE); 42445c987a37SChris Kirby if (error) { 42455c987a37SChris Kirby fatal(0, "dmu_objset_destroy(%s, B_TRUE) = %d", 42465c987a37SChris Kirby fullname, error); 42475c987a37SChris Kirby } 42485c987a37SChris Kirby 42495c987a37SChris Kirby error = dsl_dataset_user_release(osname, snapname, tag, B_FALSE); 42505c987a37SChris Kirby if (error) 42515c987a37SChris Kirby fatal(0, "dsl_dataset_user_release(%s)", fullname, tag); 42525c987a37SChris Kirby 42535c987a37SChris Kirby VERIFY(dmu_objset_hold(fullname, FTAG, &origin) == ENOENT); 42545c987a37SChris Kirby 42555c987a37SChris Kirby out: 42565c987a37SChris Kirby (void) rw_unlock(&ztest_shared->zs_name_lock); 42575c987a37SChris Kirby } 42585c987a37SChris Kirby 4259fa9e4066Sahrens /* 4260fa9e4066Sahrens * Inject random faults into the on-disk data. 4261fa9e4066Sahrens */ 4262*b24ab676SJeff Bonwick /* ARGSUSED */ 4263fa9e4066Sahrens void 4264*b24ab676SJeff Bonwick ztest_fault_inject(ztest_ds_t *zd, uint64_t id) 4265fa9e4066Sahrens { 4266*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4267*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 4268fa9e4066Sahrens int fd; 4269fa9e4066Sahrens uint64_t offset; 4270fa9e4066Sahrens uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz; 4271fa9e4066Sahrens uint64_t bad = 0x1990c0ffeedecade; 4272fa9e4066Sahrens uint64_t top, leaf; 4273fa9e4066Sahrens char path0[MAXPATHLEN]; 4274fa9e4066Sahrens char pathrand[MAXPATHLEN]; 4275fa9e4066Sahrens size_t fsize; 4276fa9e4066Sahrens int bshift = SPA_MAXBLOCKSHIFT + 2; /* don't scrog all labels */ 4277fa9e4066Sahrens int iters = 1000; 4278e14bb325SJeff Bonwick int maxfaults = zopt_maxfaults; 4279e14bb325SJeff Bonwick vdev_t *vd0 = NULL; 4280ea8dc4b6Seschrock uint64_t guid0 = 0; 42818f18d1faSGeorge Wilson boolean_t islog = B_FALSE; 4282ea8dc4b6Seschrock 4283e14bb325SJeff Bonwick ASSERT(leaves >= 1); 4284fa9e4066Sahrens 4285fa9e4066Sahrens /* 4286e14bb325SJeff Bonwick * We need SCL_STATE here because we're going to look at vd0->vdev_tsd. 4287fa9e4066Sahrens */ 4288e14bb325SJeff Bonwick spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 4289fa9e4066Sahrens 4290e14bb325SJeff Bonwick if (ztest_random(2) == 0) { 4291e14bb325SJeff Bonwick /* 4292*b24ab676SJeff Bonwick * Inject errors on a normal data device or slog device. 4293e14bb325SJeff Bonwick */ 4294*b24ab676SJeff Bonwick top = ztest_random_vdev_top(spa, B_TRUE); 4295e14bb325SJeff Bonwick leaf = ztest_random(leaves); 4296fa9e4066Sahrens 4297e14bb325SJeff Bonwick /* 4298e14bb325SJeff Bonwick * Generate paths to the first leaf in this top-level vdev, 4299e14bb325SJeff Bonwick * and to the random leaf we selected. We'll induce transient 4300e14bb325SJeff Bonwick * write failures and random online/offline activity on leaf 0, 4301e14bb325SJeff Bonwick * and we'll write random garbage to the randomly chosen leaf. 4302e14bb325SJeff Bonwick */ 4303e14bb325SJeff Bonwick (void) snprintf(path0, sizeof (path0), ztest_dev_template, 4304e14bb325SJeff Bonwick zopt_dir, zopt_pool, top * leaves + 0); 4305e14bb325SJeff Bonwick (void) snprintf(pathrand, sizeof (pathrand), ztest_dev_template, 4306e14bb325SJeff Bonwick zopt_dir, zopt_pool, top * leaves + leaf); 4307fa9e4066Sahrens 4308e14bb325SJeff Bonwick vd0 = vdev_lookup_by_path(spa->spa_root_vdev, path0); 43098f18d1faSGeorge Wilson if (vd0 != NULL && vd0->vdev_top->vdev_islog) 43108f18d1faSGeorge Wilson islog = B_TRUE; 43118f18d1faSGeorge Wilson 4312e14bb325SJeff Bonwick if (vd0 != NULL && maxfaults != 1) { 4313e14bb325SJeff Bonwick /* 4314e14bb325SJeff Bonwick * Make vd0 explicitly claim to be unreadable, 4315e14bb325SJeff Bonwick * or unwriteable, or reach behind its back 4316e14bb325SJeff Bonwick * and close the underlying fd. We can do this if 4317e14bb325SJeff Bonwick * maxfaults == 0 because we'll fail and reexecute, 4318e14bb325SJeff Bonwick * and we can do it if maxfaults >= 2 because we'll 4319e14bb325SJeff Bonwick * have enough redundancy. If maxfaults == 1, the 4320e14bb325SJeff Bonwick * combination of this with injection of random data 4321e14bb325SJeff Bonwick * corruption below exceeds the pool's fault tolerance. 4322e14bb325SJeff Bonwick */ 4323e14bb325SJeff Bonwick vdev_file_t *vf = vd0->vdev_tsd; 4324e14bb325SJeff Bonwick 4325e14bb325SJeff Bonwick if (vf != NULL && ztest_random(3) == 0) { 4326e14bb325SJeff Bonwick (void) close(vf->vf_vnode->v_fd); 4327e14bb325SJeff Bonwick vf->vf_vnode->v_fd = -1; 4328e14bb325SJeff Bonwick } else if (ztest_random(2) == 0) { 4329e14bb325SJeff Bonwick vd0->vdev_cant_read = B_TRUE; 4330e14bb325SJeff Bonwick } else { 4331e14bb325SJeff Bonwick vd0->vdev_cant_write = B_TRUE; 4332e14bb325SJeff Bonwick } 4333e14bb325SJeff Bonwick guid0 = vd0->vdev_guid; 4334e14bb325SJeff Bonwick } 4335e14bb325SJeff Bonwick } else { 4336e14bb325SJeff Bonwick /* 4337e14bb325SJeff Bonwick * Inject errors on an l2cache device. 4338e14bb325SJeff Bonwick */ 4339e14bb325SJeff Bonwick spa_aux_vdev_t *sav = &spa->spa_l2cache; 4340fa9e4066Sahrens 4341e14bb325SJeff Bonwick if (sav->sav_count == 0) { 4342e14bb325SJeff Bonwick spa_config_exit(spa, SCL_STATE, FTAG); 4343e14bb325SJeff Bonwick return; 4344e14bb325SJeff Bonwick } 4345e14bb325SJeff Bonwick vd0 = sav->sav_vdevs[ztest_random(sav->sav_count)]; 4346ea8dc4b6Seschrock guid0 = vd0->vdev_guid; 4347e14bb325SJeff Bonwick (void) strcpy(path0, vd0->vdev_path); 4348e14bb325SJeff Bonwick (void) strcpy(pathrand, vd0->vdev_path); 4349e14bb325SJeff Bonwick 4350e14bb325SJeff Bonwick leaf = 0; 4351e14bb325SJeff Bonwick leaves = 1; 4352e14bb325SJeff Bonwick maxfaults = INT_MAX; /* no limit on cache devices */ 4353fa9e4066Sahrens } 4354fa9e4066Sahrens 4355e14bb325SJeff Bonwick spa_config_exit(spa, SCL_STATE, FTAG); 4356e14bb325SJeff Bonwick 4357fa9e4066Sahrens /* 43588f18d1faSGeorge Wilson * If we can tolerate two or more faults, or we're dealing 43598f18d1faSGeorge Wilson * with a slog, randomly online/offline vd0. 4360fa9e4066Sahrens */ 43618f18d1faSGeorge Wilson if ((maxfaults >= 2 || islog) && guid0 != 0) { 43628ad4d6ddSJeff Bonwick if (ztest_random(10) < 6) { 43638ad4d6ddSJeff Bonwick int flags = (ztest_random(2) == 0 ? 43648ad4d6ddSJeff Bonwick ZFS_OFFLINE_TEMPORARY : 0); 43658f18d1faSGeorge Wilson 43668f18d1faSGeorge Wilson /* 43678f18d1faSGeorge Wilson * We have to grab the zs_name_lock as writer to 43688f18d1faSGeorge Wilson * prevent a race between offlining a slog and 43698f18d1faSGeorge Wilson * destroying a dataset. Offlining the slog will 43708f18d1faSGeorge Wilson * grab a reference on the dataset which may cause 43718f18d1faSGeorge Wilson * dmu_objset_destroy() to fail with EBUSY thus 43728f18d1faSGeorge Wilson * leaving the dataset in an inconsistent state. 43738f18d1faSGeorge Wilson */ 43748f18d1faSGeorge Wilson if (islog) 43758f18d1faSGeorge Wilson (void) rw_wrlock(&ztest_shared->zs_name_lock); 43768f18d1faSGeorge Wilson 43778ad4d6ddSJeff Bonwick VERIFY(vdev_offline(spa, guid0, flags) != EBUSY); 43788f18d1faSGeorge Wilson 43798f18d1faSGeorge Wilson if (islog) 43808f18d1faSGeorge Wilson (void) rw_unlock(&ztest_shared->zs_name_lock); 43818ad4d6ddSJeff Bonwick } else { 43828ad4d6ddSJeff Bonwick (void) vdev_online(spa, guid0, 0, NULL); 43838ad4d6ddSJeff Bonwick } 4384fa9e4066Sahrens } 4385fa9e4066Sahrens 43868f18d1faSGeorge Wilson if (maxfaults == 0) 43878f18d1faSGeorge Wilson return; 43888f18d1faSGeorge Wilson 4389fa9e4066Sahrens /* 4390ea8dc4b6Seschrock * We have at least single-fault tolerance, so inject data corruption. 4391fa9e4066Sahrens */ 4392fa9e4066Sahrens fd = open(pathrand, O_RDWR); 4393fa9e4066Sahrens 4394fa9e4066Sahrens if (fd == -1) /* we hit a gap in the device namespace */ 4395fa9e4066Sahrens return; 4396fa9e4066Sahrens 4397fa9e4066Sahrens fsize = lseek(fd, 0, SEEK_END); 4398fa9e4066Sahrens 4399fa9e4066Sahrens while (--iters != 0) { 4400fa9e4066Sahrens offset = ztest_random(fsize / (leaves << bshift)) * 4401fa9e4066Sahrens (leaves << bshift) + (leaf << bshift) + 4402fa9e4066Sahrens (ztest_random(1ULL << (bshift - 1)) & -8ULL); 4403fa9e4066Sahrens 4404fa9e4066Sahrens if (offset >= fsize) 4405fa9e4066Sahrens continue; 4406fa9e4066Sahrens 4407*b24ab676SJeff Bonwick if (zopt_verbose >= 7) 4408fa9e4066Sahrens (void) printf("injecting bad word into %s," 4409fa9e4066Sahrens " offset 0x%llx\n", pathrand, (u_longlong_t)offset); 4410fa9e4066Sahrens 4411fa9e4066Sahrens if (pwrite(fd, &bad, sizeof (bad), offset) != sizeof (bad)) 4412fa9e4066Sahrens fatal(1, "can't inject bad word at 0x%llx in %s", 4413fa9e4066Sahrens offset, pathrand); 4414fa9e4066Sahrens } 4415fa9e4066Sahrens 4416fa9e4066Sahrens (void) close(fd); 4417fa9e4066Sahrens } 4418fa9e4066Sahrens 4419fa9e4066Sahrens /* 4420*b24ab676SJeff Bonwick * Verify that DDT repair works as expected. 4421fa9e4066Sahrens */ 4422fa9e4066Sahrens void 4423*b24ab676SJeff Bonwick ztest_ddt_repair(ztest_ds_t *zd, uint64_t id) 4424fa9e4066Sahrens { 4425*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4426*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 4427*b24ab676SJeff Bonwick objset_t *os = zd->zd_os; 4428*b24ab676SJeff Bonwick ztest_od_t od[1]; 4429*b24ab676SJeff Bonwick uint64_t object, blocksize, txg, pattern, psize; 4430*b24ab676SJeff Bonwick enum zio_checksum checksum = spa_dedup_checksum(spa); 4431*b24ab676SJeff Bonwick dmu_buf_t *db; 4432*b24ab676SJeff Bonwick dmu_tx_t *tx; 4433*b24ab676SJeff Bonwick void *buf; 4434*b24ab676SJeff Bonwick blkptr_t blk; 4435*b24ab676SJeff Bonwick int copies = 2 * ZIO_DEDUPDITTO_MIN; 4436fa9e4066Sahrens 4437*b24ab676SJeff Bonwick blocksize = ztest_random_blocksize(); 4438*b24ab676SJeff Bonwick blocksize = MIN(blocksize, 2048); /* because we write so many */ 4439fa9e4066Sahrens 4440*b24ab676SJeff Bonwick ztest_od_init(&od[0], id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0); 4441fa9e4066Sahrens 4442*b24ab676SJeff Bonwick if (ztest_object_init(zd, od, sizeof (od), B_FALSE) != 0) 4443*b24ab676SJeff Bonwick return; 4444fa9e4066Sahrens 4445fa9e4066Sahrens /* 4446*b24ab676SJeff Bonwick * Take the name lock as writer to prevent anyone else from changing 4447*b24ab676SJeff Bonwick * the pool and dataset properies we need to maintain during this test. 4448fa9e4066Sahrens */ 4449*b24ab676SJeff Bonwick (void) rw_wrlock(&zs->zs_name_lock); 4450fa9e4066Sahrens 4451*b24ab676SJeff Bonwick if (ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_DEDUP, checksum, 4452*b24ab676SJeff Bonwick B_FALSE) != 0 || 4453*b24ab676SJeff Bonwick ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_COPIES, 1, 4454*b24ab676SJeff Bonwick B_FALSE) != 0) { 4455*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4456*b24ab676SJeff Bonwick return; 4457*b24ab676SJeff Bonwick } 4458*b24ab676SJeff Bonwick 4459*b24ab676SJeff Bonwick object = od[0].od_object; 4460*b24ab676SJeff Bonwick blocksize = od[0].od_blocksize; 4461*b24ab676SJeff Bonwick pattern = spa_guid(spa) ^ dmu_objset_fsid_guid(os); 4462*b24ab676SJeff Bonwick 4463*b24ab676SJeff Bonwick ASSERT(object != 0); 4464*b24ab676SJeff Bonwick 4465*b24ab676SJeff Bonwick tx = dmu_tx_create(os); 4466*b24ab676SJeff Bonwick dmu_tx_hold_write(tx, object, 0, copies * blocksize); 4467*b24ab676SJeff Bonwick txg = ztest_tx_assign(tx, TXG_WAIT, FTAG); 4468*b24ab676SJeff Bonwick if (txg == 0) { 4469*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4470*b24ab676SJeff Bonwick return; 4471*b24ab676SJeff Bonwick } 4472fa9e4066Sahrens 4473fa9e4066Sahrens /* 4474*b24ab676SJeff Bonwick * Write all the copies of our block. 4475fa9e4066Sahrens */ 4476*b24ab676SJeff Bonwick for (int i = 0; i < copies; i++) { 4477*b24ab676SJeff Bonwick uint64_t offset = i * blocksize; 4478*b24ab676SJeff Bonwick VERIFY(dmu_buf_hold(os, object, offset, FTAG, &db) == 0); 4479*b24ab676SJeff Bonwick ASSERT(db->db_offset == offset); 4480*b24ab676SJeff Bonwick ASSERT(db->db_size == blocksize); 4481*b24ab676SJeff Bonwick ASSERT(ztest_pattern_match(db->db_data, db->db_size, pattern) || 4482*b24ab676SJeff Bonwick ztest_pattern_match(db->db_data, db->db_size, 0ULL)); 4483*b24ab676SJeff Bonwick dmu_buf_will_fill(db, tx); 4484*b24ab676SJeff Bonwick ztest_pattern_set(db->db_data, db->db_size, pattern); 4485*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 4486*b24ab676SJeff Bonwick } 4487fa9e4066Sahrens 4488*b24ab676SJeff Bonwick dmu_tx_commit(tx); 4489*b24ab676SJeff Bonwick txg_wait_synced(spa_get_dsl(spa), txg); 4490fa9e4066Sahrens 4491fa9e4066Sahrens /* 4492*b24ab676SJeff Bonwick * Find out what block we got. 4493fa9e4066Sahrens */ 4494*b24ab676SJeff Bonwick VERIFY(dmu_buf_hold(os, object, 0, FTAG, &db) == 0); 4495*b24ab676SJeff Bonwick blk = *((dmu_buf_impl_t *)db)->db_blkptr; 4496*b24ab676SJeff Bonwick dmu_buf_rele(db, FTAG); 4497fa9e4066Sahrens 4498fa9e4066Sahrens /* 4499*b24ab676SJeff Bonwick * Damage the block. Dedup-ditto will save us when we read it later. 4500fa9e4066Sahrens */ 4501*b24ab676SJeff Bonwick psize = BP_GET_PSIZE(&blk); 4502*b24ab676SJeff Bonwick buf = zio_buf_alloc(psize); 4503*b24ab676SJeff Bonwick ztest_pattern_set(buf, psize, ~pattern); 4504fa9e4066Sahrens 4505*b24ab676SJeff Bonwick (void) zio_wait(zio_rewrite(NULL, spa, 0, &blk, 4506*b24ab676SJeff Bonwick buf, psize, NULL, NULL, ZIO_PRIORITY_SYNC_WRITE, 4507*b24ab676SJeff Bonwick ZIO_FLAG_CANFAIL | ZIO_FLAG_INDUCE_DAMAGE, NULL)); 4508fa9e4066Sahrens 4509*b24ab676SJeff Bonwick zio_buf_free(buf, psize); 4510fa9e4066Sahrens 4511*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4512fa9e4066Sahrens } 4513fa9e4066Sahrens 4514fa9e4066Sahrens /* 4515*b24ab676SJeff Bonwick * Scrub the pool. 4516fa9e4066Sahrens */ 4517*b24ab676SJeff Bonwick /* ARGSUSED */ 4518*b24ab676SJeff Bonwick void 4519*b24ab676SJeff Bonwick ztest_scrub(ztest_ds_t *zd, uint64_t id) 4520fa9e4066Sahrens { 4521*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4522*b24ab676SJeff Bonwick spa_t *spa = zs->zs_spa; 4523fa9e4066Sahrens 4524*b24ab676SJeff Bonwick (void) spa_scrub(spa, POOL_SCRUB_EVERYTHING); 4525*b24ab676SJeff Bonwick (void) poll(NULL, 0, 100); /* wait a moment, then force a restart */ 4526*b24ab676SJeff Bonwick (void) spa_scrub(spa, POOL_SCRUB_EVERYTHING); 4527*b24ab676SJeff Bonwick } 4528fa9e4066Sahrens 4529*b24ab676SJeff Bonwick /* 4530*b24ab676SJeff Bonwick * Rename the pool to a different name and then rename it back. 4531*b24ab676SJeff Bonwick */ 4532*b24ab676SJeff Bonwick /* ARGSUSED */ 4533*b24ab676SJeff Bonwick void 4534*b24ab676SJeff Bonwick ztest_spa_rename(ztest_ds_t *zd, uint64_t id) 4535*b24ab676SJeff Bonwick { 4536*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4537*b24ab676SJeff Bonwick char *oldname, *newname; 4538*b24ab676SJeff Bonwick spa_t *spa; 4539fa9e4066Sahrens 4540*b24ab676SJeff Bonwick (void) rw_wrlock(&zs->zs_name_lock); 4541fa9e4066Sahrens 4542*b24ab676SJeff Bonwick oldname = zs->zs_pool; 4543*b24ab676SJeff Bonwick newname = umem_alloc(strlen(oldname) + 5, UMEM_NOFAIL); 4544*b24ab676SJeff Bonwick (void) strcpy(newname, oldname); 4545*b24ab676SJeff Bonwick (void) strcat(newname, "_tmp"); 4546fa9e4066Sahrens 4547fa9e4066Sahrens /* 4548*b24ab676SJeff Bonwick * Do the rename 4549fa9e4066Sahrens */ 4550*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_rename(oldname, newname)); 4551fa9e4066Sahrens 4552fa9e4066Sahrens /* 4553*b24ab676SJeff Bonwick * Try to open it under the old name, which shouldn't exist 4554fa9e4066Sahrens */ 4555*b24ab676SJeff Bonwick VERIFY3U(ENOENT, ==, spa_open(oldname, &spa, FTAG)); 4556fa9e4066Sahrens 4557fa9e4066Sahrens /* 4558*b24ab676SJeff Bonwick * Open it under the new name and make sure it's still the same spa_t. 4559fa9e4066Sahrens */ 4560*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(newname, &spa, FTAG)); 4561fa9e4066Sahrens 4562*b24ab676SJeff Bonwick ASSERT(spa == zs->zs_spa); 4563*b24ab676SJeff Bonwick spa_close(spa, FTAG); 4564fa9e4066Sahrens 4565*b24ab676SJeff Bonwick /* 4566*b24ab676SJeff Bonwick * Rename it back to the original 4567*b24ab676SJeff Bonwick */ 4568*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_rename(newname, oldname)); 4569fa9e4066Sahrens 4570fa9e4066Sahrens /* 4571*b24ab676SJeff Bonwick * Make sure it can still be opened 4572fa9e4066Sahrens */ 4573*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(oldname, &spa, FTAG)); 4574fa9e4066Sahrens 4575*b24ab676SJeff Bonwick ASSERT(spa == zs->zs_spa); 4576*b24ab676SJeff Bonwick spa_close(spa, FTAG); 4577fa9e4066Sahrens 4578*b24ab676SJeff Bonwick umem_free(newname, strlen(newname) + 1); 4579*b24ab676SJeff Bonwick 4580*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4581fa9e4066Sahrens } 4582fa9e4066Sahrens 4583*b24ab676SJeff Bonwick /* 4584*b24ab676SJeff Bonwick * Verify pool integrity by running zdb. 4585*b24ab676SJeff Bonwick */ 4586fa9e4066Sahrens static void 4587*b24ab676SJeff Bonwick ztest_run_zdb(char *pool) 4588fa9e4066Sahrens { 4589fa9e4066Sahrens int status; 4590fa9e4066Sahrens char zdb[MAXPATHLEN + MAXNAMELEN + 20]; 4591fa9e4066Sahrens char zbuf[1024]; 4592fa9e4066Sahrens char *bin; 45938654d025Sperrin char *ztest; 45948654d025Sperrin char *isa; 45958654d025Sperrin int isalen; 4596fa9e4066Sahrens FILE *fp; 4597fa9e4066Sahrens 4598fa9e4066Sahrens (void) realpath(getexecname(), zdb); 4599fa9e4066Sahrens 4600fa9e4066Sahrens /* zdb lives in /usr/sbin, while ztest lives in /usr/bin */ 4601fa9e4066Sahrens bin = strstr(zdb, "/usr/bin/"); 46028654d025Sperrin ztest = strstr(bin, "/ztest"); 46038654d025Sperrin isa = bin + 8; 46048654d025Sperrin isalen = ztest - isa; 46058654d025Sperrin isa = strdup(isa); 4606fa9e4066Sahrens /* LINTED */ 46073a57275aSck (void) sprintf(bin, 46086365109dSVictor Latushkin "/usr/sbin%.*s/zdb -bcc%s%s -U /tmp/zpool.cache %s", 46098654d025Sperrin isalen, 46108654d025Sperrin isa, 4611fa9e4066Sahrens zopt_verbose >= 3 ? "s" : "", 4612fa9e4066Sahrens zopt_verbose >= 4 ? "v" : "", 461388b7b0f2SMatthew Ahrens pool); 46148654d025Sperrin free(isa); 4615fa9e4066Sahrens 4616fa9e4066Sahrens if (zopt_verbose >= 5) 4617fa9e4066Sahrens (void) printf("Executing %s\n", strstr(zdb, "zdb ")); 4618fa9e4066Sahrens 4619fa9e4066Sahrens fp = popen(zdb, "r"); 4620fa9e4066Sahrens 4621fa9e4066Sahrens while (fgets(zbuf, sizeof (zbuf), fp) != NULL) 4622fa9e4066Sahrens if (zopt_verbose >= 3) 4623fa9e4066Sahrens (void) printf("%s", zbuf); 4624fa9e4066Sahrens 4625fa9e4066Sahrens status = pclose(fp); 4626fa9e4066Sahrens 4627fa9e4066Sahrens if (status == 0) 4628fa9e4066Sahrens return; 4629fa9e4066Sahrens 4630fa9e4066Sahrens ztest_dump_core = 0; 4631fa9e4066Sahrens if (WIFEXITED(status)) 4632fa9e4066Sahrens fatal(0, "'%s' exit code %d", zdb, WEXITSTATUS(status)); 4633fa9e4066Sahrens else 4634fa9e4066Sahrens fatal(0, "'%s' died with signal %d", zdb, WTERMSIG(status)); 4635fa9e4066Sahrens } 4636fa9e4066Sahrens 4637fa9e4066Sahrens static void 4638fa9e4066Sahrens ztest_walk_pool_directory(char *header) 4639fa9e4066Sahrens { 4640fa9e4066Sahrens spa_t *spa = NULL; 4641fa9e4066Sahrens 4642fa9e4066Sahrens if (zopt_verbose >= 6) 4643fa9e4066Sahrens (void) printf("%s\n", header); 4644fa9e4066Sahrens 4645fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 4646fa9e4066Sahrens while ((spa = spa_next(spa)) != NULL) 4647fa9e4066Sahrens if (zopt_verbose >= 6) 4648fa9e4066Sahrens (void) printf("\t%s\n", spa_name(spa)); 4649fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 4650fa9e4066Sahrens } 4651fa9e4066Sahrens 4652fa9e4066Sahrens static void 4653fa9e4066Sahrens ztest_spa_import_export(char *oldname, char *newname) 4654fa9e4066Sahrens { 46558ad4d6ddSJeff Bonwick nvlist_t *config, *newconfig; 4656fa9e4066Sahrens uint64_t pool_guid; 4657fa9e4066Sahrens spa_t *spa; 4658fa9e4066Sahrens 4659fa9e4066Sahrens if (zopt_verbose >= 4) { 4660fa9e4066Sahrens (void) printf("import/export: old = %s, new = %s\n", 4661fa9e4066Sahrens oldname, newname); 4662fa9e4066Sahrens } 4663fa9e4066Sahrens 4664fa9e4066Sahrens /* 4665fa9e4066Sahrens * Clean up from previous runs. 4666fa9e4066Sahrens */ 4667fa9e4066Sahrens (void) spa_destroy(newname); 4668fa9e4066Sahrens 4669fa9e4066Sahrens /* 4670fa9e4066Sahrens * Get the pool's configuration and guid. 4671fa9e4066Sahrens */ 4672*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(oldname, &spa, FTAG)); 4673fa9e4066Sahrens 46748ad4d6ddSJeff Bonwick /* 46758ad4d6ddSJeff Bonwick * Kick off a scrub to tickle scrub/export races. 46768ad4d6ddSJeff Bonwick */ 46778ad4d6ddSJeff Bonwick if (ztest_random(2) == 0) 46788ad4d6ddSJeff Bonwick (void) spa_scrub(spa, POOL_SCRUB_EVERYTHING); 46798ad4d6ddSJeff Bonwick 4680fa9e4066Sahrens pool_guid = spa_guid(spa); 4681fa9e4066Sahrens spa_close(spa, FTAG); 4682fa9e4066Sahrens 4683fa9e4066Sahrens ztest_walk_pool_directory("pools before export"); 4684fa9e4066Sahrens 4685fa9e4066Sahrens /* 4686fa9e4066Sahrens * Export it. 4687fa9e4066Sahrens */ 4688*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_export(oldname, &config, B_FALSE, B_FALSE)); 4689fa9e4066Sahrens 4690fa9e4066Sahrens ztest_walk_pool_directory("pools after export"); 4691fa9e4066Sahrens 46928ad4d6ddSJeff Bonwick /* 46938ad4d6ddSJeff Bonwick * Try to import it. 46948ad4d6ddSJeff Bonwick */ 46958ad4d6ddSJeff Bonwick newconfig = spa_tryimport(config); 46968ad4d6ddSJeff Bonwick ASSERT(newconfig != NULL); 46978ad4d6ddSJeff Bonwick nvlist_free(newconfig); 46988ad4d6ddSJeff Bonwick 4699fa9e4066Sahrens /* 4700fa9e4066Sahrens * Import it under the new name. 4701fa9e4066Sahrens */ 4702*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_import(newname, config, NULL)); 4703fa9e4066Sahrens 4704fa9e4066Sahrens ztest_walk_pool_directory("pools after import"); 4705fa9e4066Sahrens 4706fa9e4066Sahrens /* 4707fa9e4066Sahrens * Try to import it again -- should fail with EEXIST. 4708fa9e4066Sahrens */ 4709*b24ab676SJeff Bonwick VERIFY3U(EEXIST, ==, spa_import(newname, config, NULL)); 4710fa9e4066Sahrens 4711fa9e4066Sahrens /* 4712fa9e4066Sahrens * Try to import it under a different name -- should fail with EEXIST. 4713fa9e4066Sahrens */ 4714*b24ab676SJeff Bonwick VERIFY3U(EEXIST, ==, spa_import(oldname, config, NULL)); 4715fa9e4066Sahrens 4716fa9e4066Sahrens /* 4717fa9e4066Sahrens * Verify that the pool is no longer visible under the old name. 4718fa9e4066Sahrens */ 4719*b24ab676SJeff Bonwick VERIFY3U(ENOENT, ==, spa_open(oldname, &spa, FTAG)); 4720fa9e4066Sahrens 4721fa9e4066Sahrens /* 4722fa9e4066Sahrens * Verify that we can open and close the pool using the new name. 4723fa9e4066Sahrens */ 4724*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(newname, &spa, FTAG)); 4725fa9e4066Sahrens ASSERT(pool_guid == spa_guid(spa)); 4726fa9e4066Sahrens spa_close(spa, FTAG); 4727fa9e4066Sahrens 4728fa9e4066Sahrens nvlist_free(config); 4729fa9e4066Sahrens } 4730fa9e4066Sahrens 47318ad4d6ddSJeff Bonwick static void 47328ad4d6ddSJeff Bonwick ztest_resume(spa_t *spa) 47338ad4d6ddSJeff Bonwick { 4734*b24ab676SJeff Bonwick if (spa_suspended(spa) && zopt_verbose >= 6) 4735*b24ab676SJeff Bonwick (void) printf("resuming from suspended state\n"); 4736*b24ab676SJeff Bonwick spa_vdev_state_enter(spa, SCL_NONE); 4737*b24ab676SJeff Bonwick vdev_clear(spa, NULL); 4738*b24ab676SJeff Bonwick (void) spa_vdev_state_exit(spa, NULL, 0); 4739*b24ab676SJeff Bonwick (void) zio_resume(spa); 47408ad4d6ddSJeff Bonwick } 47418ad4d6ddSJeff Bonwick 47420a4e9518Sgw static void * 47438ad4d6ddSJeff Bonwick ztest_resume_thread(void *arg) 47440a4e9518Sgw { 4745e14bb325SJeff Bonwick spa_t *spa = arg; 47460a4e9518Sgw 47470a4e9518Sgw while (!ztest_exiting) { 4748*b24ab676SJeff Bonwick if (spa_suspended(spa)) 4749*b24ab676SJeff Bonwick ztest_resume(spa); 4750*b24ab676SJeff Bonwick (void) poll(NULL, 0, 100); 47510a4e9518Sgw } 47520a4e9518Sgw return (NULL); 47530a4e9518Sgw } 47540a4e9518Sgw 4755*b24ab676SJeff Bonwick static void * 4756*b24ab676SJeff Bonwick ztest_deadman_thread(void *arg) 4757*b24ab676SJeff Bonwick { 4758*b24ab676SJeff Bonwick ztest_shared_t *zs = arg; 4759*b24ab676SJeff Bonwick int grace = 300; 4760*b24ab676SJeff Bonwick hrtime_t delta; 4761*b24ab676SJeff Bonwick 4762*b24ab676SJeff Bonwick delta = (zs->zs_thread_stop - zs->zs_thread_start) / NANOSEC + grace; 4763*b24ab676SJeff Bonwick 4764*b24ab676SJeff Bonwick (void) poll(NULL, 0, (int)(1000 * delta)); 4765*b24ab676SJeff Bonwick 4766*b24ab676SJeff Bonwick fatal(0, "failed to complete within %d seconds of deadline", grace); 4767*b24ab676SJeff Bonwick 4768*b24ab676SJeff Bonwick return (NULL); 4769*b24ab676SJeff Bonwick } 4770*b24ab676SJeff Bonwick 4771*b24ab676SJeff Bonwick static void 4772*b24ab676SJeff Bonwick ztest_execute(ztest_info_t *zi, uint64_t id) 4773*b24ab676SJeff Bonwick { 4774*b24ab676SJeff Bonwick ztest_shared_t *zs = ztest_shared; 4775*b24ab676SJeff Bonwick ztest_ds_t *zd = &zs->zs_zd[id % zopt_datasets]; 4776*b24ab676SJeff Bonwick hrtime_t functime = gethrtime(); 4777*b24ab676SJeff Bonwick 4778*b24ab676SJeff Bonwick for (int i = 0; i < zi->zi_iters; i++) 4779*b24ab676SJeff Bonwick zi->zi_func(zd, id); 4780*b24ab676SJeff Bonwick 4781*b24ab676SJeff Bonwick functime = gethrtime() - functime; 4782*b24ab676SJeff Bonwick 4783*b24ab676SJeff Bonwick atomic_add_64(&zi->zi_call_count, 1); 4784*b24ab676SJeff Bonwick atomic_add_64(&zi->zi_call_time, functime); 4785*b24ab676SJeff Bonwick 4786*b24ab676SJeff Bonwick if (zopt_verbose >= 4) { 4787*b24ab676SJeff Bonwick Dl_info dli; 4788*b24ab676SJeff Bonwick (void) dladdr((void *)zi->zi_func, &dli); 4789*b24ab676SJeff Bonwick (void) printf("%6.2f sec in %s\n", 4790*b24ab676SJeff Bonwick (double)functime / NANOSEC, dli.dli_sname); 4791*b24ab676SJeff Bonwick } 4792*b24ab676SJeff Bonwick } 4793*b24ab676SJeff Bonwick 4794fa9e4066Sahrens static void * 4795fa9e4066Sahrens ztest_thread(void *arg) 4796fa9e4066Sahrens { 4797*b24ab676SJeff Bonwick uint64_t id = (uintptr_t)arg; 4798fa9e4066Sahrens ztest_shared_t *zs = ztest_shared; 4799*b24ab676SJeff Bonwick uint64_t call_next; 4800*b24ab676SJeff Bonwick hrtime_t now; 4801fa9e4066Sahrens ztest_info_t *zi; 4802fa9e4066Sahrens 4803*b24ab676SJeff Bonwick while ((now = gethrtime()) < zs->zs_thread_stop) { 4804fa9e4066Sahrens /* 4805fa9e4066Sahrens * See if it's time to force a crash. 4806fa9e4066Sahrens */ 4807*b24ab676SJeff Bonwick if (now > zs->zs_thread_kill) 4808*b24ab676SJeff Bonwick ztest_kill(zs); 4809fa9e4066Sahrens 4810fa9e4066Sahrens /* 4811*b24ab676SJeff Bonwick * If we're getting ENOSPC with some regularity, stop. 4812fa9e4066Sahrens */ 4813*b24ab676SJeff Bonwick if (zs->zs_enospc_count > 10) 4814*b24ab676SJeff Bonwick break; 4815fa9e4066Sahrens 4816fa9e4066Sahrens /* 4817*b24ab676SJeff Bonwick * Pick a random function to execute. 4818fa9e4066Sahrens */ 4819*b24ab676SJeff Bonwick zi = &zs->zs_info[ztest_random(ZTEST_FUNCS)]; 4820*b24ab676SJeff Bonwick call_next = zi->zi_call_next; 4821*b24ab676SJeff Bonwick 4822*b24ab676SJeff Bonwick if (now >= call_next && 4823*b24ab676SJeff Bonwick atomic_cas_64(&zi->zi_call_next, call_next, call_next + 4824*b24ab676SJeff Bonwick ztest_random(2 * zi->zi_interval[0] + 1)) == call_next) 4825*b24ab676SJeff Bonwick ztest_execute(zi, id); 4826*b24ab676SJeff Bonwick } 4827fa9e4066Sahrens 4828*b24ab676SJeff Bonwick return (NULL); 4829*b24ab676SJeff Bonwick } 4830fa9e4066Sahrens 4831*b24ab676SJeff Bonwick static void 4832*b24ab676SJeff Bonwick ztest_dataset_name(char *dsname, char *pool, int d) 4833*b24ab676SJeff Bonwick { 4834*b24ab676SJeff Bonwick (void) snprintf(dsname, MAXNAMELEN, "%s/ds_%d", pool, d); 4835*b24ab676SJeff Bonwick } 4836fa9e4066Sahrens 4837*b24ab676SJeff Bonwick static void 4838*b24ab676SJeff Bonwick ztest_dataset_destroy(ztest_shared_t *zs, int d) 4839*b24ab676SJeff Bonwick { 4840*b24ab676SJeff Bonwick char name[MAXNAMELEN]; 4841fa9e4066Sahrens 4842*b24ab676SJeff Bonwick ztest_dataset_name(name, zs->zs_pool, d); 4843fa9e4066Sahrens 4844*b24ab676SJeff Bonwick if (zopt_verbose >= 3) 4845*b24ab676SJeff Bonwick (void) printf("Destroying %s to free up space\n", name); 4846fa9e4066Sahrens 4847*b24ab676SJeff Bonwick /* 4848*b24ab676SJeff Bonwick * Cleanup any non-standard clones and snapshots. In general, 4849*b24ab676SJeff Bonwick * ztest thread t operates on dataset (t % zopt_datasets), 4850*b24ab676SJeff Bonwick * so there may be more than one thing to clean up. 4851*b24ab676SJeff Bonwick */ 4852*b24ab676SJeff Bonwick for (int t = d; t < zopt_threads; t += zopt_datasets) 4853*b24ab676SJeff Bonwick ztest_dsl_dataset_cleanup(name, t); 4854fa9e4066Sahrens 4855*b24ab676SJeff Bonwick (void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL, 4856*b24ab676SJeff Bonwick DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN); 4857*b24ab676SJeff Bonwick } 4858*b24ab676SJeff Bonwick 4859*b24ab676SJeff Bonwick static void 4860*b24ab676SJeff Bonwick ztest_dataset_dirobj_verify(ztest_ds_t *zd) 4861*b24ab676SJeff Bonwick { 4862*b24ab676SJeff Bonwick uint64_t usedobjs, dirobjs, scratch; 4863*b24ab676SJeff Bonwick 4864*b24ab676SJeff Bonwick /* 4865*b24ab676SJeff Bonwick * ZTEST_DIROBJ is the object directory for the entire dataset. 4866*b24ab676SJeff Bonwick * Therefore, the number of objects in use should equal the 4867*b24ab676SJeff Bonwick * number of ZTEST_DIROBJ entries, +1 for ZTEST_DIROBJ itself. 4868*b24ab676SJeff Bonwick * If not, we have an object leak. 4869*b24ab676SJeff Bonwick * 4870*b24ab676SJeff Bonwick * Note that we can only check this in ztest_dataset_open(), 4871*b24ab676SJeff Bonwick * when the open-context and syncing-context values agree. 4872*b24ab676SJeff Bonwick * That's because zap_count() returns the open-context value, 4873*b24ab676SJeff Bonwick * while dmu_objset_space() returns the rootbp fill count. 4874*b24ab676SJeff Bonwick */ 4875*b24ab676SJeff Bonwick VERIFY3U(0, ==, zap_count(zd->zd_os, ZTEST_DIROBJ, &dirobjs)); 4876*b24ab676SJeff Bonwick dmu_objset_space(zd->zd_os, &scratch, &scratch, &usedobjs, &scratch); 4877*b24ab676SJeff Bonwick ASSERT3U(dirobjs + 1, ==, usedobjs); 4878*b24ab676SJeff Bonwick } 4879*b24ab676SJeff Bonwick 4880*b24ab676SJeff Bonwick static int 4881*b24ab676SJeff Bonwick ztest_dataset_open(ztest_shared_t *zs, int d) 4882*b24ab676SJeff Bonwick { 4883*b24ab676SJeff Bonwick ztest_ds_t *zd = &zs->zs_zd[d]; 4884*b24ab676SJeff Bonwick uint64_t committed_seq = zd->zd_seq; 4885*b24ab676SJeff Bonwick objset_t *os; 4886*b24ab676SJeff Bonwick zilog_t *zilog; 4887*b24ab676SJeff Bonwick char name[MAXNAMELEN]; 4888*b24ab676SJeff Bonwick int error; 4889*b24ab676SJeff Bonwick 4890*b24ab676SJeff Bonwick ztest_dataset_name(name, zs->zs_pool, d); 4891*b24ab676SJeff Bonwick 4892*b24ab676SJeff Bonwick (void) rw_rdlock(&zs->zs_name_lock); 4893*b24ab676SJeff Bonwick 4894*b24ab676SJeff Bonwick error = dmu_objset_create(name, DMU_OST_OTHER, 0, 4895*b24ab676SJeff Bonwick ztest_objset_create_cb, NULL); 4896*b24ab676SJeff Bonwick if (error == ENOSPC) { 4897*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4898*b24ab676SJeff Bonwick ztest_record_enospc(FTAG); 4899*b24ab676SJeff Bonwick return (error); 4900fa9e4066Sahrens } 4901*b24ab676SJeff Bonwick ASSERT(error == 0 || error == EEXIST); 4902fa9e4066Sahrens 4903*b24ab676SJeff Bonwick VERIFY3U(dmu_objset_hold(name, zd, &os), ==, 0); 4904*b24ab676SJeff Bonwick (void) rw_unlock(&zs->zs_name_lock); 4905*b24ab676SJeff Bonwick 4906*b24ab676SJeff Bonwick ztest_zd_init(zd, os); 4907*b24ab676SJeff Bonwick 4908*b24ab676SJeff Bonwick zilog = zd->zd_zilog; 4909*b24ab676SJeff Bonwick 4910*b24ab676SJeff Bonwick if (zilog->zl_header->zh_claim_lr_seq != 0 && 4911*b24ab676SJeff Bonwick zilog->zl_header->zh_claim_lr_seq < committed_seq) 4912*b24ab676SJeff Bonwick fatal(0, "missing log records: claimed %llu < committed %llu", 4913*b24ab676SJeff Bonwick zilog->zl_header->zh_claim_lr_seq, committed_seq); 4914*b24ab676SJeff Bonwick 4915*b24ab676SJeff Bonwick ztest_dataset_dirobj_verify(zd); 4916*b24ab676SJeff Bonwick 4917*b24ab676SJeff Bonwick zil_replay(os, zd, ztest_replay_vector); 4918*b24ab676SJeff Bonwick 4919*b24ab676SJeff Bonwick ztest_dataset_dirobj_verify(zd); 4920*b24ab676SJeff Bonwick 4921*b24ab676SJeff Bonwick if (zopt_verbose >= 6) 4922*b24ab676SJeff Bonwick (void) printf("%s replay %llu blocks, %llu records, seq %llu\n", 4923*b24ab676SJeff Bonwick zd->zd_name, 4924*b24ab676SJeff Bonwick (u_longlong_t)zilog->zl_parse_blk_count, 4925*b24ab676SJeff Bonwick (u_longlong_t)zilog->zl_parse_lr_count, 4926*b24ab676SJeff Bonwick (u_longlong_t)zilog->zl_replaying_seq); 4927*b24ab676SJeff Bonwick 4928*b24ab676SJeff Bonwick zilog = zil_open(os, ztest_get_data); 4929*b24ab676SJeff Bonwick 4930*b24ab676SJeff Bonwick if (zilog->zl_replaying_seq != 0 && 4931*b24ab676SJeff Bonwick zilog->zl_replaying_seq < committed_seq) 4932*b24ab676SJeff Bonwick fatal(0, "missing log records: replayed %llu < committed %llu", 4933*b24ab676SJeff Bonwick zilog->zl_replaying_seq, committed_seq); 4934*b24ab676SJeff Bonwick 4935*b24ab676SJeff Bonwick return (0); 4936*b24ab676SJeff Bonwick } 4937*b24ab676SJeff Bonwick 4938*b24ab676SJeff Bonwick static void 4939*b24ab676SJeff Bonwick ztest_dataset_close(ztest_shared_t *zs, int d) 4940*b24ab676SJeff Bonwick { 4941*b24ab676SJeff Bonwick ztest_ds_t *zd = &zs->zs_zd[d]; 4942*b24ab676SJeff Bonwick 4943*b24ab676SJeff Bonwick zil_close(zd->zd_zilog); 4944*b24ab676SJeff Bonwick dmu_objset_rele(zd->zd_os, zd); 4945*b24ab676SJeff Bonwick 4946*b24ab676SJeff Bonwick ztest_zd_fini(zd); 4947fa9e4066Sahrens } 4948fa9e4066Sahrens 4949fa9e4066Sahrens /* 4950fa9e4066Sahrens * Kick off threads to run tests on all datasets in parallel. 4951fa9e4066Sahrens */ 4952fa9e4066Sahrens static void 4953*b24ab676SJeff Bonwick ztest_run(ztest_shared_t *zs) 4954fa9e4066Sahrens { 4955*b24ab676SJeff Bonwick thread_t *tid; 4956fa9e4066Sahrens spa_t *spa; 4957e14bb325SJeff Bonwick thread_t resume_tid; 4958*b24ab676SJeff Bonwick int error; 4959e14bb325SJeff Bonwick 4960e14bb325SJeff Bonwick ztest_exiting = B_FALSE; 4961fa9e4066Sahrens 4962fa9e4066Sahrens /* 4963*b24ab676SJeff Bonwick * Initialize parent/child shared state. 4964fa9e4066Sahrens */ 4965*b24ab676SJeff Bonwick VERIFY(_mutex_init(&zs->zs_vdev_lock, USYNC_THREAD, NULL) == 0); 4966*b24ab676SJeff Bonwick VERIFY(rwlock_init(&zs->zs_name_lock, USYNC_THREAD, NULL) == 0); 4967fa9e4066Sahrens 4968*b24ab676SJeff Bonwick zs->zs_thread_start = gethrtime(); 4969*b24ab676SJeff Bonwick zs->zs_thread_stop = zs->zs_thread_start + zopt_passtime * NANOSEC; 4970*b24ab676SJeff Bonwick zs->zs_thread_stop = MIN(zs->zs_thread_stop, zs->zs_proc_stop); 4971*b24ab676SJeff Bonwick zs->zs_thread_kill = zs->zs_thread_stop; 4972*b24ab676SJeff Bonwick if (ztest_random(100) < zopt_killrate) 4973*b24ab676SJeff Bonwick zs->zs_thread_kill -= ztest_random(zopt_passtime * NANOSEC); 4974fa9e4066Sahrens 4975*b24ab676SJeff Bonwick (void) _mutex_init(&zcl.zcl_callbacks_lock, USYNC_THREAD, NULL); 4976fa9e4066Sahrens 4977*b24ab676SJeff Bonwick list_create(&zcl.zcl_callbacks, sizeof (ztest_cb_data_t), 4978*b24ab676SJeff Bonwick offsetof(ztest_cb_data_t, zcd_node)); 4979fa9e4066Sahrens 49800a4e9518Sgw /* 4981e14bb325SJeff Bonwick * Open our pool. 49820a4e9518Sgw */ 4983*b24ab676SJeff Bonwick kernel_init(FREAD | FWRITE); 4984*b24ab676SJeff Bonwick VERIFY(spa_open(zs->zs_pool, &spa, FTAG) == 0); 4985*b24ab676SJeff Bonwick zs->zs_spa = spa; 4986*b24ab676SJeff Bonwick 4987*b24ab676SJeff Bonwick spa->spa_dedup_ditto = 2 * ZIO_DEDUPDITTO_MIN; 49880a4e9518Sgw 49898ad4d6ddSJeff Bonwick /* 49908ad4d6ddSJeff Bonwick * We don't expect the pool to suspend unless maxfaults == 0, 49918ad4d6ddSJeff Bonwick * in which case ztest_fault_inject() temporarily takes away 49928ad4d6ddSJeff Bonwick * the only valid replica. 49938ad4d6ddSJeff Bonwick */ 49948ad4d6ddSJeff Bonwick if (zopt_maxfaults == 0) 49958ad4d6ddSJeff Bonwick spa->spa_failmode = ZIO_FAILURE_MODE_WAIT; 49968ad4d6ddSJeff Bonwick else 49978ad4d6ddSJeff Bonwick spa->spa_failmode = ZIO_FAILURE_MODE_PANIC; 49988ad4d6ddSJeff Bonwick 4999fa9e4066Sahrens /* 5000e14bb325SJeff Bonwick * Create a thread to periodically resume suspended I/O. 5001fa9e4066Sahrens */ 50028ad4d6ddSJeff Bonwick VERIFY(thr_create(0, 0, ztest_resume_thread, spa, THR_BOUND, 5003e14bb325SJeff Bonwick &resume_tid) == 0); 5004fa9e4066Sahrens 5005*b24ab676SJeff Bonwick /* 5006*b24ab676SJeff Bonwick * Create a deadman thread to abort() if we hang. 5007*b24ab676SJeff Bonwick */ 5008*b24ab676SJeff Bonwick VERIFY(thr_create(0, 0, ztest_deadman_thread, zs, THR_BOUND, 5009*b24ab676SJeff Bonwick NULL) == 0); 5010*b24ab676SJeff Bonwick 5011fa9e4066Sahrens /* 5012fa9e4066Sahrens * Verify that we can safely inquire about about any object, 5013fa9e4066Sahrens * whether it's allocated or not. To make it interesting, 5014fa9e4066Sahrens * we probe a 5-wide window around each power of two. 5015fa9e4066Sahrens * This hits all edge cases, including zero and the max. 5016fa9e4066Sahrens */ 5017*b24ab676SJeff Bonwick for (int t = 0; t < 64; t++) { 5018*b24ab676SJeff Bonwick for (int d = -5; d <= 5; d++) { 5019fa9e4066Sahrens error = dmu_object_info(spa->spa_meta_objset, 5020fa9e4066Sahrens (1ULL << t) + d, NULL); 5021ea8dc4b6Seschrock ASSERT(error == 0 || error == ENOENT || 5022ea8dc4b6Seschrock error == EINVAL); 5023fa9e4066Sahrens } 5024fa9e4066Sahrens } 5025fa9e4066Sahrens 5026fa9e4066Sahrens /* 5027*b24ab676SJeff Bonwick * If we got any ENOSPC errors on the previous run, destroy something. 5028fa9e4066Sahrens */ 5029*b24ab676SJeff Bonwick if (zs->zs_enospc_count != 0) { 5030*b24ab676SJeff Bonwick int d = ztest_random(zopt_datasets); 5031*b24ab676SJeff Bonwick ztest_dataset_destroy(zs, d); 5032*b24ab676SJeff Bonwick } 5033fa9e4066Sahrens zs->zs_enospc_count = 0; 5034fa9e4066Sahrens 5035*b24ab676SJeff Bonwick tid = umem_zalloc(zopt_threads * sizeof (thread_t), UMEM_NOFAIL); 5036fa9e4066Sahrens 5037fa9e4066Sahrens if (zopt_verbose >= 4) 5038fa9e4066Sahrens (void) printf("starting main threads...\n"); 5039fa9e4066Sahrens 5040*b24ab676SJeff Bonwick /* 5041*b24ab676SJeff Bonwick * Kick off all the tests that run in parallel. 5042*b24ab676SJeff Bonwick */ 5043*b24ab676SJeff Bonwick for (int t = 0; t < zopt_threads; t++) { 5044*b24ab676SJeff Bonwick if (t < zopt_datasets && ztest_dataset_open(zs, t) != 0) 5045*b24ab676SJeff Bonwick return; 5046*b24ab676SJeff Bonwick VERIFY(thr_create(0, 0, ztest_thread, (void *)(uintptr_t)t, 5047*b24ab676SJeff Bonwick THR_BOUND, &tid[t]) == 0); 5048fa9e4066Sahrens } 5049fa9e4066Sahrens 5050*b24ab676SJeff Bonwick /* 5051*b24ab676SJeff Bonwick * Wait for all of the tests to complete. We go in reverse order 5052*b24ab676SJeff Bonwick * so we don't close datasets while threads are still using them. 5053*b24ab676SJeff Bonwick */ 5054*b24ab676SJeff Bonwick for (int t = zopt_threads - 1; t >= 0; t--) { 5055*b24ab676SJeff Bonwick VERIFY(thr_join(tid[t], NULL, NULL) == 0); 5056*b24ab676SJeff Bonwick if (t < zopt_datasets) 5057*b24ab676SJeff Bonwick ztest_dataset_close(zs, t); 5058fa9e4066Sahrens } 5059fa9e4066Sahrens 5060fa9e4066Sahrens txg_wait_synced(spa_get_dsl(spa), 0); 5061fa9e4066Sahrens 5062*b24ab676SJeff Bonwick zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(spa)); 5063*b24ab676SJeff Bonwick zs->zs_space = metaslab_class_get_space(spa_normal_class(spa)); 5064*b24ab676SJeff Bonwick 5065*b24ab676SJeff Bonwick umem_free(tid, zopt_threads * sizeof (thread_t)); 5066*b24ab676SJeff Bonwick 5067*b24ab676SJeff Bonwick /* Kill the resume thread */ 5068*b24ab676SJeff Bonwick ztest_exiting = B_TRUE; 5069*b24ab676SJeff Bonwick VERIFY(thr_join(resume_tid, NULL, NULL) == 0); 5070*b24ab676SJeff Bonwick ztest_resume(spa); 5071*b24ab676SJeff Bonwick 5072*b24ab676SJeff Bonwick /* 5073*b24ab676SJeff Bonwick * Right before closing the pool, kick off a bunch of async I/O; 5074*b24ab676SJeff Bonwick * spa_close() should wait for it to complete. 5075*b24ab676SJeff Bonwick */ 5076*b24ab676SJeff Bonwick for (uint64_t object = 1; object < 50; object++) 5077*b24ab676SJeff Bonwick dmu_prefetch(spa->spa_meta_objset, object, 0, 1ULL << 20); 5078*b24ab676SJeff Bonwick 5079*b24ab676SJeff Bonwick spa_close(spa, FTAG); 5080fa9e4066Sahrens 5081fa9e4066Sahrens /* 5082*b24ab676SJeff Bonwick * Verify that we can loop over all pools. 5083fa9e4066Sahrens */ 5084*b24ab676SJeff Bonwick mutex_enter(&spa_namespace_lock); 5085*b24ab676SJeff Bonwick for (spa = spa_next(NULL); spa != NULL; spa = spa_next(spa)) 5086*b24ab676SJeff Bonwick if (zopt_verbose > 3) 5087*b24ab676SJeff Bonwick (void) printf("spa_next: found %s\n", spa_name(spa)); 5088*b24ab676SJeff Bonwick mutex_exit(&spa_namespace_lock); 5089*b24ab676SJeff Bonwick 5090*b24ab676SJeff Bonwick /* 5091*b24ab676SJeff Bonwick * Verify that we can export the pool and reimport it under a 5092*b24ab676SJeff Bonwick * different name. 5093*b24ab676SJeff Bonwick */ 5094*b24ab676SJeff Bonwick if (ztest_random(2) == 0) { 5095*b24ab676SJeff Bonwick char name[MAXNAMELEN]; 5096*b24ab676SJeff Bonwick (void) snprintf(name, MAXNAMELEN, "%s_import", zs->zs_pool); 5097*b24ab676SJeff Bonwick ztest_spa_import_export(zs->zs_pool, name); 5098*b24ab676SJeff Bonwick ztest_spa_import_export(name, zs->zs_pool); 5099*b24ab676SJeff Bonwick } 5100*b24ab676SJeff Bonwick 5101*b24ab676SJeff Bonwick kernel_fini(); 5102*b24ab676SJeff Bonwick } 5103*b24ab676SJeff Bonwick 5104*b24ab676SJeff Bonwick static void 5105*b24ab676SJeff Bonwick ztest_freeze(ztest_shared_t *zs) 5106*b24ab676SJeff Bonwick { 5107*b24ab676SJeff Bonwick ztest_ds_t *zd = &zs->zs_zd[0]; 5108*b24ab676SJeff Bonwick spa_t *spa; 5109*b24ab676SJeff Bonwick 5110*b24ab676SJeff Bonwick if (zopt_verbose >= 3) 5111*b24ab676SJeff Bonwick (void) printf("testing spa_freeze()...\n"); 5112718d718aSGeorge Wilson 5113*b24ab676SJeff Bonwick kernel_init(FREAD | FWRITE); 5114*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(zs->zs_pool, &spa, FTAG)); 5115*b24ab676SJeff Bonwick VERIFY3U(0, ==, ztest_dataset_open(zs, 0)); 5116718d718aSGeorge Wilson 5117*b24ab676SJeff Bonwick /* 5118*b24ab676SJeff Bonwick * Force the first log block to be transactionally allocated. 5119*b24ab676SJeff Bonwick * We have to do this before we freeze the pool -- otherwise 5120*b24ab676SJeff Bonwick * the log chain won't be anchored. 5121*b24ab676SJeff Bonwick */ 5122*b24ab676SJeff Bonwick while (BP_IS_HOLE(&zd->zd_zilog->zl_header->zh_log)) { 5123*b24ab676SJeff Bonwick ztest_dmu_object_alloc_free(zd, 0); 5124*b24ab676SJeff Bonwick zil_commit(zd->zd_zilog, UINT64_MAX, 0); 5125fa9e4066Sahrens } 5126fa9e4066Sahrens 5127ea8dc4b6Seschrock txg_wait_synced(spa_get_dsl(spa), 0); 5128fa9e4066Sahrens 5129*b24ab676SJeff Bonwick /* 5130*b24ab676SJeff Bonwick * Freeze the pool. This stops spa_sync() from doing anything, 5131*b24ab676SJeff Bonwick * so that the only way to record changes from now on is the ZIL. 5132*b24ab676SJeff Bonwick */ 5133*b24ab676SJeff Bonwick spa_freeze(spa); 5134e14bb325SJeff Bonwick 5135*b24ab676SJeff Bonwick /* 5136*b24ab676SJeff Bonwick * Run tests that generate log records but don't alter the pool config 5137*b24ab676SJeff Bonwick * or depend on DSL sync tasks (snapshots, objset create/destroy, etc). 5138*b24ab676SJeff Bonwick * We do a txg_wait_synced() after each iteration to force the txg 5139*b24ab676SJeff Bonwick * to increase well beyond the last synced value in the uberblock. 5140*b24ab676SJeff Bonwick * The ZIL should be OK with that. 5141*b24ab676SJeff Bonwick */ 5142*b24ab676SJeff Bonwick while (ztest_random(20) != 0) { 5143*b24ab676SJeff Bonwick ztest_dmu_write_parallel(zd, 0); 5144*b24ab676SJeff Bonwick ztest_dmu_object_alloc_free(zd, 0); 5145*b24ab676SJeff Bonwick txg_wait_synced(spa_get_dsl(spa), 0); 5146*b24ab676SJeff Bonwick } 5147e14bb325SJeff Bonwick 5148fa9e4066Sahrens /* 5149*b24ab676SJeff Bonwick * Commit all of the changes we just generated. 5150fa9e4066Sahrens */ 5151*b24ab676SJeff Bonwick zil_commit(zd->zd_zilog, UINT64_MAX, 0); 5152*b24ab676SJeff Bonwick txg_wait_synced(spa_get_dsl(spa), 0); 5153fa9e4066Sahrens 5154*b24ab676SJeff Bonwick /* 5155*b24ab676SJeff Bonwick * Close our dataset and close the pool. 5156*b24ab676SJeff Bonwick */ 5157*b24ab676SJeff Bonwick ztest_dataset_close(zs, 0); 5158e05725b1Sbonwick spa_close(spa, FTAG); 5159*b24ab676SJeff Bonwick kernel_fini(); 5160e05725b1Sbonwick 5161*b24ab676SJeff Bonwick /* 5162*b24ab676SJeff Bonwick * Open and close the pool and dataset to induce log replay. 5163*b24ab676SJeff Bonwick */ 5164*b24ab676SJeff Bonwick kernel_init(FREAD | FWRITE); 5165*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(zs->zs_pool, &spa, FTAG)); 5166*b24ab676SJeff Bonwick VERIFY3U(0, ==, ztest_dataset_open(zs, 0)); 5167*b24ab676SJeff Bonwick ztest_dataset_close(zs, 0); 5168*b24ab676SJeff Bonwick spa_close(spa, FTAG); 5169fa9e4066Sahrens kernel_fini(); 5170d20e665cSRicardo M. Correia 5171d20e665cSRicardo M. Correia list_destroy(&zcl.zcl_callbacks); 5172d20e665cSRicardo M. Correia 5173d20e665cSRicardo M. Correia (void) _mutex_destroy(&zcl.zcl_callbacks_lock); 5174d20e665cSRicardo M. Correia 5175d20e665cSRicardo M. Correia (void) rwlock_destroy(&zs->zs_name_lock); 5176d20e665cSRicardo M. Correia (void) _mutex_destroy(&zs->zs_vdev_lock); 5177fa9e4066Sahrens } 5178fa9e4066Sahrens 5179fa9e4066Sahrens void 5180fa9e4066Sahrens print_time(hrtime_t t, char *timebuf) 5181fa9e4066Sahrens { 5182fa9e4066Sahrens hrtime_t s = t / NANOSEC; 5183fa9e4066Sahrens hrtime_t m = s / 60; 5184fa9e4066Sahrens hrtime_t h = m / 60; 5185fa9e4066Sahrens hrtime_t d = h / 24; 5186fa9e4066Sahrens 5187fa9e4066Sahrens s -= m * 60; 5188fa9e4066Sahrens m -= h * 60; 5189fa9e4066Sahrens h -= d * 24; 5190fa9e4066Sahrens 5191fa9e4066Sahrens timebuf[0] = '\0'; 5192fa9e4066Sahrens 5193fa9e4066Sahrens if (d) 5194fa9e4066Sahrens (void) sprintf(timebuf, 5195fa9e4066Sahrens "%llud%02lluh%02llum%02llus", d, h, m, s); 5196fa9e4066Sahrens else if (h) 5197fa9e4066Sahrens (void) sprintf(timebuf, "%lluh%02llum%02llus", h, m, s); 5198fa9e4066Sahrens else if (m) 5199fa9e4066Sahrens (void) sprintf(timebuf, "%llum%02llus", m, s); 5200fa9e4066Sahrens else 5201fa9e4066Sahrens (void) sprintf(timebuf, "%llus", s); 5202fa9e4066Sahrens } 5203fa9e4066Sahrens 5204fa9e4066Sahrens /* 5205fa9e4066Sahrens * Create a storage pool with the given name and initial vdev size. 5206*b24ab676SJeff Bonwick * Then test spa_freeze() functionality. 5207fa9e4066Sahrens */ 5208fa9e4066Sahrens static void 5209*b24ab676SJeff Bonwick ztest_init(ztest_shared_t *zs) 5210fa9e4066Sahrens { 5211fa9e4066Sahrens spa_t *spa; 5212fa9e4066Sahrens nvlist_t *nvroot; 5213fa9e4066Sahrens 5214*b24ab676SJeff Bonwick VERIFY(_mutex_init(&zs->zs_vdev_lock, USYNC_THREAD, NULL) == 0); 5215*b24ab676SJeff Bonwick VERIFY(rwlock_init(&zs->zs_name_lock, USYNC_THREAD, NULL) == 0); 5216*b24ab676SJeff Bonwick 5217fa9e4066Sahrens kernel_init(FREAD | FWRITE); 5218fa9e4066Sahrens 5219fa9e4066Sahrens /* 5220fa9e4066Sahrens * Create the storage pool. 5221fa9e4066Sahrens */ 5222*b24ab676SJeff Bonwick (void) spa_destroy(zs->zs_pool); 522388ecc943SGeorge Wilson ztest_shared->zs_vdev_next_leaf = 0; 5224e14bb325SJeff Bonwick nvroot = make_vdev_root(NULL, NULL, zopt_vdev_size, 0, 5225e14bb325SJeff Bonwick 0, zopt_raidz, zopt_mirrors, 1); 5226*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_create(zs->zs_pool, nvroot, NULL, NULL, NULL)); 5227fa9e4066Sahrens nvlist_free(nvroot); 5228fa9e4066Sahrens 5229*b24ab676SJeff Bonwick VERIFY3U(0, ==, spa_open(zs->zs_pool, &spa, FTAG)); 5230d6e555bdSGeorge Wilson metaslab_sz = 1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift; 5231fa9e4066Sahrens spa_close(spa, FTAG); 5232fa9e4066Sahrens 5233fa9e4066Sahrens kernel_fini(); 5234*b24ab676SJeff Bonwick 5235*b24ab676SJeff Bonwick ztest_run_zdb(zs->zs_pool); 5236*b24ab676SJeff Bonwick 5237*b24ab676SJeff Bonwick ztest_freeze(zs); 5238*b24ab676SJeff Bonwick 5239*b24ab676SJeff Bonwick ztest_run_zdb(zs->zs_pool); 5240fa9e4066Sahrens } 5241fa9e4066Sahrens 5242fa9e4066Sahrens int 5243fa9e4066Sahrens main(int argc, char **argv) 5244fa9e4066Sahrens { 5245fa9e4066Sahrens int kills = 0; 5246fa9e4066Sahrens int iters = 0; 5247fa9e4066Sahrens ztest_shared_t *zs; 5248*b24ab676SJeff Bonwick size_t shared_size; 5249fa9e4066Sahrens ztest_info_t *zi; 5250fa9e4066Sahrens char timebuf[100]; 5251fa9e4066Sahrens char numbuf[6]; 5252*b24ab676SJeff Bonwick spa_t *spa; 5253fa9e4066Sahrens 5254fa9e4066Sahrens (void) setvbuf(stdout, NULL, _IOLBF, 0); 5255fa9e4066Sahrens 5256fa9e4066Sahrens /* Override location of zpool.cache */ 5257c5904d13Seschrock spa_config_path = "/tmp/zpool.cache"; 5258fa9e4066Sahrens 5259fa9e4066Sahrens ztest_random_fd = open("/dev/urandom", O_RDONLY); 5260fa9e4066Sahrens 5261fa9e4066Sahrens process_options(argc, argv); 5262fa9e4066Sahrens 5263ea8dc4b6Seschrock /* 5264ea8dc4b6Seschrock * Blow away any existing copy of zpool.cache 5265ea8dc4b6Seschrock */ 5266ea8dc4b6Seschrock if (zopt_init != 0) 5267ea8dc4b6Seschrock (void) remove("/tmp/zpool.cache"); 5268ea8dc4b6Seschrock 5269*b24ab676SJeff Bonwick shared_size = sizeof (*zs) + zopt_datasets * sizeof (ztest_ds_t); 5270*b24ab676SJeff Bonwick 5271fa9e4066Sahrens zs = ztest_shared = (void *)mmap(0, 5272*b24ab676SJeff Bonwick P2ROUNDUP(shared_size, getpagesize()), 5273fa9e4066Sahrens PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); 5274fa9e4066Sahrens 5275fa9e4066Sahrens if (zopt_verbose >= 1) { 5276fa9e4066Sahrens (void) printf("%llu vdevs, %d datasets, %d threads," 5277fa9e4066Sahrens " %llu seconds...\n", 5278ecc2d604Sbonwick (u_longlong_t)zopt_vdevs, zopt_datasets, zopt_threads, 5279fa9e4066Sahrens (u_longlong_t)zopt_time); 5280fa9e4066Sahrens } 5281fa9e4066Sahrens 5282fa9e4066Sahrens /* 5283fa9e4066Sahrens * Create and initialize our storage pool. 5284fa9e4066Sahrens */ 5285*b24ab676SJeff Bonwick for (int i = 1; i <= zopt_init; i++) { 5286fa9e4066Sahrens bzero(zs, sizeof (ztest_shared_t)); 5287fa9e4066Sahrens if (zopt_verbose >= 3 && zopt_init != 1) 5288fa9e4066Sahrens (void) printf("ztest_init(), pass %d\n", i); 5289*b24ab676SJeff Bonwick zs->zs_pool = zopt_pool; 5290*b24ab676SJeff Bonwick ztest_init(zs); 5291fa9e4066Sahrens } 5292fa9e4066Sahrens 5293*b24ab676SJeff Bonwick zs->zs_pool = zopt_pool; 5294*b24ab676SJeff Bonwick zs->zs_proc_start = gethrtime(); 5295*b24ab676SJeff Bonwick zs->zs_proc_stop = zs->zs_proc_start + zopt_time * NANOSEC; 5296fa9e4066Sahrens 5297*b24ab676SJeff Bonwick for (int f = 0; f < ZTEST_FUNCS; f++) { 5298*b24ab676SJeff Bonwick zi = &zs->zs_info[f]; 5299fa9e4066Sahrens *zi = ztest_info[f]; 5300*b24ab676SJeff Bonwick if (zs->zs_proc_start + zi->zi_interval[0] > zs->zs_proc_stop) 5301*b24ab676SJeff Bonwick zi->zi_call_next = UINT64_MAX; 5302fa9e4066Sahrens else 5303*b24ab676SJeff Bonwick zi->zi_call_next = zs->zs_proc_start + 5304*b24ab676SJeff Bonwick ztest_random(2 * zi->zi_interval[0] + 1); 5305fa9e4066Sahrens } 5306fa9e4066Sahrens 5307fa9e4066Sahrens /* 5308fa9e4066Sahrens * Run the tests in a loop. These tests include fault injection 5309fa9e4066Sahrens * to verify that self-healing data works, and forced crashes 5310fa9e4066Sahrens * to verify that we never lose on-disk consistency. 5311fa9e4066Sahrens */ 5312*b24ab676SJeff Bonwick while (gethrtime() < zs->zs_proc_stop) { 5313fa9e4066Sahrens int status; 5314fa9e4066Sahrens pid_t pid; 5315fa9e4066Sahrens 5316fa9e4066Sahrens /* 5317fa9e4066Sahrens * Initialize the workload counters for each function. 5318fa9e4066Sahrens */ 5319*b24ab676SJeff Bonwick for (int f = 0; f < ZTEST_FUNCS; f++) { 5320fa9e4066Sahrens zi = &zs->zs_info[f]; 5321*b24ab676SJeff Bonwick zi->zi_call_count = 0; 5322fa9e4066Sahrens zi->zi_call_time = 0; 5323fa9e4066Sahrens } 5324fa9e4066Sahrens 5325d6e555bdSGeorge Wilson /* Set the allocation switch size */ 5326d6e555bdSGeorge Wilson metaslab_df_alloc_threshold = ztest_random(metaslab_sz / 4) + 1; 5327d6e555bdSGeorge Wilson 5328fa9e4066Sahrens pid = fork(); 5329fa9e4066Sahrens 5330fa9e4066Sahrens if (pid == -1) 5331fa9e4066Sahrens fatal(1, "fork failed"); 5332fa9e4066Sahrens 5333fa9e4066Sahrens if (pid == 0) { /* child */ 5334fa9e4066Sahrens struct rlimit rl = { 1024, 1024 }; 5335fa9e4066Sahrens (void) setrlimit(RLIMIT_NOFILE, &rl); 5336004388ebScasper (void) enable_extended_FILE_stdio(-1, -1); 5337*b24ab676SJeff Bonwick ztest_run(zs); 5338fa9e4066Sahrens exit(0); 5339fa9e4066Sahrens } 5340fa9e4066Sahrens 53415ad82045Snd while (waitpid(pid, &status, 0) != pid) 5342fa9e4066Sahrens continue; 5343fa9e4066Sahrens 5344fa9e4066Sahrens if (WIFEXITED(status)) { 5345fa9e4066Sahrens if (WEXITSTATUS(status) != 0) { 5346fa9e4066Sahrens (void) fprintf(stderr, 5347fa9e4066Sahrens "child exited with code %d\n", 5348fa9e4066Sahrens WEXITSTATUS(status)); 5349fa9e4066Sahrens exit(2); 5350fa9e4066Sahrens } 53515ad82045Snd } else if (WIFSIGNALED(status)) { 5352fa9e4066Sahrens if (WTERMSIG(status) != SIGKILL) { 5353fa9e4066Sahrens (void) fprintf(stderr, 5354fa9e4066Sahrens "child died with signal %d\n", 5355fa9e4066Sahrens WTERMSIG(status)); 5356fa9e4066Sahrens exit(3); 5357fa9e4066Sahrens } 5358fa9e4066Sahrens kills++; 53595ad82045Snd } else { 53605ad82045Snd (void) fprintf(stderr, "something strange happened " 53615ad82045Snd "to child\n"); 53625ad82045Snd exit(4); 5363fa9e4066Sahrens } 5364fa9e4066Sahrens 5365fa9e4066Sahrens iters++; 5366fa9e4066Sahrens 5367fa9e4066Sahrens if (zopt_verbose >= 1) { 5368fa9e4066Sahrens hrtime_t now = gethrtime(); 5369fa9e4066Sahrens 5370*b24ab676SJeff Bonwick now = MIN(now, zs->zs_proc_stop); 5371*b24ab676SJeff Bonwick print_time(zs->zs_proc_stop - now, timebuf); 5372fa9e4066Sahrens nicenum(zs->zs_space, numbuf); 5373fa9e4066Sahrens 5374fa9e4066Sahrens (void) printf("Pass %3d, %8s, %3llu ENOSPC, " 5375fa9e4066Sahrens "%4.1f%% of %5s used, %3.0f%% done, %8s to go\n", 5376fa9e4066Sahrens iters, 5377fa9e4066Sahrens WIFEXITED(status) ? "Complete" : "SIGKILL", 5378fa9e4066Sahrens (u_longlong_t)zs->zs_enospc_count, 5379fa9e4066Sahrens 100.0 * zs->zs_alloc / zs->zs_space, 5380fa9e4066Sahrens numbuf, 5381*b24ab676SJeff Bonwick 100.0 * (now - zs->zs_proc_start) / 5382fa9e4066Sahrens (zopt_time * NANOSEC), timebuf); 5383fa9e4066Sahrens } 5384fa9e4066Sahrens 5385fa9e4066Sahrens if (zopt_verbose >= 2) { 5386fa9e4066Sahrens (void) printf("\nWorkload summary:\n\n"); 5387fa9e4066Sahrens (void) printf("%7s %9s %s\n", 5388fa9e4066Sahrens "Calls", "Time", "Function"); 5389fa9e4066Sahrens (void) printf("%7s %9s %s\n", 5390fa9e4066Sahrens "-----", "----", "--------"); 5391*b24ab676SJeff Bonwick for (int f = 0; f < ZTEST_FUNCS; f++) { 5392fa9e4066Sahrens Dl_info dli; 5393fa9e4066Sahrens 5394fa9e4066Sahrens zi = &zs->zs_info[f]; 5395fa9e4066Sahrens print_time(zi->zi_call_time, timebuf); 5396fa9e4066Sahrens (void) dladdr((void *)zi->zi_func, &dli); 5397fa9e4066Sahrens (void) printf("%7llu %9s %s\n", 5398*b24ab676SJeff Bonwick (u_longlong_t)zi->zi_call_count, timebuf, 5399fa9e4066Sahrens dli.dli_sname); 5400fa9e4066Sahrens } 5401fa9e4066Sahrens (void) printf("\n"); 5402fa9e4066Sahrens } 5403fa9e4066Sahrens 5404fa9e4066Sahrens /* 5405*b24ab676SJeff Bonwick * It's possible that we killed a child during a rename test, 5406*b24ab676SJeff Bonwick * in which case we'll have a 'ztest_tmp' pool lying around 5407*b24ab676SJeff Bonwick * instead of 'ztest'. Do a blind rename in case this happened. 5408fa9e4066Sahrens */ 5409*b24ab676SJeff Bonwick kernel_init(FREAD); 5410*b24ab676SJeff Bonwick if (spa_open(zopt_pool, &spa, FTAG) == 0) { 5411*b24ab676SJeff Bonwick spa_close(spa, FTAG); 5412*b24ab676SJeff Bonwick } else { 5413*b24ab676SJeff Bonwick char tmpname[MAXNAMELEN]; 5414*b24ab676SJeff Bonwick kernel_fini(); 5415*b24ab676SJeff Bonwick kernel_init(FREAD | FWRITE); 5416*b24ab676SJeff Bonwick (void) snprintf(tmpname, sizeof (tmpname), "%s_tmp", 5417*b24ab676SJeff Bonwick zopt_pool); 5418*b24ab676SJeff Bonwick (void) spa_rename(tmpname, zopt_pool); 5419*b24ab676SJeff Bonwick } 5420fa9e4066Sahrens kernel_fini(); 5421fa9e4066Sahrens 5422*b24ab676SJeff Bonwick ztest_run_zdb(zopt_pool); 5423*b24ab676SJeff Bonwick } 5424fa9e4066Sahrens 5425fa9e4066Sahrens if (zopt_verbose >= 1) { 5426fa9e4066Sahrens (void) printf("%d killed, %d completed, %.0f%% kill rate\n", 5427fa9e4066Sahrens kills, iters - kills, (100.0 * kills) / MAX(1, iters)); 5428fa9e4066Sahrens } 5429fa9e4066Sahrens 5430fa9e4066Sahrens return (0); 5431fa9e4066Sahrens } 5432