cmd = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
realaltdir = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
- VERIFY(NULL != realpath(getexecname(), cmd));
+ VERIFY3P(NULL, !=, realpath(getexecname(), cmd));
if (0 != access(altdir, F_OK)) {
ztest_dump_core = B_FALSE;
fatal(B_TRUE, "invalid alternate ztest path: %s",
altdir);
}
- VERIFY(NULL != realpath(altdir, realaltdir));
+ VERIFY3P(NULL, !=, realpath(altdir, realaltdir));
/*
* 'cmd' should be of the form "<anything>/usr/bin/<isa>/ztest".
int c;
boolean_t log;
- ASSERT(t > 0);
+ ASSERT3S(t, >, 0);
log = (class != NULL && strcmp(class, "log") == 0);
static int
ztest_random_blocksize(void)
{
- ASSERT(ztest_spa->spa_max_ashift != 0);
+ ASSERT3U(ztest_spa->spa_max_ashift, !=, 0);
/*
* Choose a block size >= the ashift.
vdev_t *rvd = spa->spa_root_vdev;
vdev_t *tvd;
- ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
+ ASSERT3U(spa_config_held(spa, SCL_ALL, RW_READER), !=, 0);
do {
top = ztest_random(rvd->vdev_children);
static void
ztest_rll_destroy(rll_t *rll)
{
- ASSERT(rll->rll_writer == NULL);
- ASSERT(rll->rll_readers == 0);
+ ASSERT3P(rll->rll_writer, ==, NULL);
+ ASSERT0(rll->rll_readers);
mutex_destroy(&rll->rll_lock);
cv_destroy(&rll->rll_cv);
}
mutex_enter(&rll->rll_lock);
if (rll->rll_writer) {
- ASSERT(rll->rll_readers == 0);
+ ASSERT0(rll->rll_readers);
rll->rll_writer = NULL;
} else {
- ASSERT(rll->rll_readers != 0);
- ASSERT(rll->rll_writer == NULL);
+ ASSERT3S(rll->rll_readers, >, 0);
+ ASSERT3P(rll->rll_writer, ==, NULL);
rll->rll_readers--;
}
error = dmu_tx_assign(tx, txg_how);
if (error) {
if (error == ERESTART) {
- ASSERT(txg_how == TXG_NOWAIT);
+ ASSERT3U(txg_how, ==, TXG_NOWAIT);
dmu_tx_wait(tx);
} else {
ASSERT3U(error, ==, ENOSPC);
return (0);
}
txg = dmu_tx_get_txg(tx);
- ASSERT(txg != 0);
+ ASSERT3U(txg, !=, 0);
return (txg);
}
if (byteswap)
byteswap_uint64_array(lr, sizeof (*lr));
- ASSERT(lr->lr_doid == ZTEST_DIROBJ);
- ASSERT(name[0] != '\0');
+ ASSERT3U(lr->lr_doid, ==, ZTEST_DIROBJ);
+ ASSERT3S(name[0], !=, '\0');
tx = dmu_tx_create(os);
if (txg == 0)
return (ENOSPC);
- ASSERT(dmu_objset_zil(os)->zl_replay == !!lr->lr_foid);
+ ASSERT3U(dmu_objset_zil(os)->zl_replay, ==, !!lr->lr_foid);
bonuslen = DN_BONUS_SIZE(lr->lrz_dnodesize);
if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
return (error);
}
- ASSERT(lr->lr_foid != 0);
+ ASSERT3U(lr->lr_foid, !=, 0);
if (lr->lrz_type != DMU_OT_ZAP_OTHER)
- VERIFY3U(0, ==, dmu_object_set_blocksize(os, lr->lr_foid,
+ VERIFY0(dmu_object_set_blocksize(os, lr->lr_foid,
lr->lrz_blocksize, lr->lrz_ibshift, tx));
- VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
+ VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
bbt = ztest_bt_bonus(db);
dmu_buf_will_dirty(db, tx);
ztest_bt_generate(bbt, os, lr->lr_foid, lr->lrz_dnodesize, -1ULL,
ztest_fill_unused_bonus(db, bbt, lr->lr_foid, os, lr->lr_gen);
dmu_buf_rele(db, FTAG);
- VERIFY3U(0, ==, zap_add(os, lr->lr_doid, name, sizeof (uint64_t), 1,
+ VERIFY0(zap_add(os, lr->lr_doid, name, sizeof (uint64_t), 1,
&lr->lr_foid, tx));
(void) ztest_log_create(zd, tx, lr);
if (byteswap)
byteswap_uint64_array(lr, sizeof (*lr));
- ASSERT(lr->lr_doid == ZTEST_DIROBJ);
- ASSERT(name[0] != '\0');
+ ASSERT3U(lr->lr_doid, ==, ZTEST_DIROBJ);
+ ASSERT3S(name[0], !=, '\0');
- VERIFY3U(0, ==,
+ VERIFY0(
zap_lookup(os, lr->lr_doid, name, sizeof (object), 1, &object));
- ASSERT(object != 0);
+ ASSERT3U(object, !=, 0);
ztest_object_lock(zd, object, RL_WRITER);
- VERIFY3U(0, ==, dmu_object_info(os, object, &doi));
+ VERIFY0(dmu_object_info(os, object, &doi));
tx = dmu_tx_create(os);
}
if (doi.doi_type == DMU_OT_ZAP_OTHER) {
- VERIFY3U(0, ==, zap_destroy(os, object, tx));
+ VERIFY0(zap_destroy(os, object, tx));
} else {
- VERIFY3U(0, ==, dmu_object_free(os, object, tx));
+ VERIFY0(dmu_object_free(os, object, tx));
}
- VERIFY3U(0, ==, zap_remove(os, lr->lr_doid, name, tx));
+ VERIFY0(zap_remove(os, lr->lr_doid, name, tx));
(void) ztest_log_remove(zd, tx, lr, object);
ztest_object_lock(zd, lr->lr_foid, RL_READER);
rl = ztest_range_lock(zd, lr->lr_foid, offset, length, RL_WRITER);
- VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
+ VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
dmu_object_info_from_db(db, &doi);
* but not always, because we also want to verify correct
* behavior when the data was not recently read into cache.
*/
- ASSERT(offset % doi.doi_data_block_size == 0);
+ ASSERT0(offset % doi.doi_data_block_size);
if (ztest_random(4) != 0) {
int prefetch = ztest_random(2) ?
DMU_READ_PREFETCH : DMU_READ_NO_PREFETCH;
return (ENOSPC);
}
- VERIFY(dmu_free_range(os, lr->lr_foid, lr->lr_offset,
- lr->lr_length, tx) == 0);
+ VERIFY0(dmu_free_range(os, lr->lr_foid, lr->lr_offset,
+ lr->lr_length, tx));
(void) ztest_log_truncate(zd, tx, lr);
ztest_object_lock(zd, lr->lr_foid, RL_WRITER);
- VERIFY3U(0, ==, dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
+ VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
tx = dmu_tx_create(os);
dmu_tx_hold_bonus(tx, lr->lr_foid);
dnodesize = bbt->bt_dnodesize;
if (zd->zd_zilog->zl_replay) {
- ASSERT(lr->lr_size != 0);
- ASSERT(lr->lr_mode != 0);
- ASSERT(lrtxg != 0);
+ ASSERT3U(lr->lr_size, !=, 0);
+ ASSERT3U(lr->lr_mode, !=, 0);
+ ASSERT3U(lrtxg, !=, 0);
} else {
/*
* Randomly change the size and increment the generation.
lr->lr_size = (ztest_random(db->db_size / sizeof (*bbt)) + 1) *
sizeof (*bbt);
lr->lr_mode = bbt->bt_gen + 1;
- ASSERT(lrtxg == 0);
+ ASSERT0(lrtxg);
}
/*
error = dmu_read(os, object, offset, size, buf,
DMU_READ_NO_PREFETCH);
- ASSERT(error == 0);
+ ASSERT0(error);
} else {
size = doi.doi_data_block_size;
if (ISP2(size)) {
offset = P2ALIGN(offset, size);
} else {
- ASSERT(offset < size);
+ ASSERT3U(offset, <, size);
offset = 0;
}
zgd->zgd_db = db;
zgd->zgd_bp = bp;
- ASSERT(db->db_offset == offset);
- ASSERT(db->db_size == size);
+ ASSERT3U(db->db_offset, ==, offset);
+ ASSERT3U(db->db_size, ==, size);
error = dmu_sync(zio, lr->lr_common.lrc_txg,
ztest_get_done, zgd);
error = zap_lookup(zd->zd_os, od->od_dir, od->od_name,
sizeof (uint64_t), 1, &od->od_object);
if (error) {
- ASSERT(error == ENOENT);
- ASSERT(od->od_object == 0);
+ ASSERT3S(error, ==, ENOENT);
+ ASSERT0(od->od_object);
missing++;
} else {
dmu_buf_t *db;
ztest_block_tag_t *bbt;
dmu_object_info_t doi;
- ASSERT(od->od_object != 0);
- ASSERT(missing == 0); /* there should be no gaps */
+ ASSERT3U(od->od_object, !=, 0);
+ ASSERT0(missing); /* there should be no gaps */
ztest_object_lock(zd, od->od_object, RL_READER);
- VERIFY3U(0, ==, dmu_bonus_hold(zd->zd_os,
- od->od_object, FTAG, &db));
+ VERIFY0(dmu_bonus_hold(zd->zd_os, od->od_object,
+ FTAG, &db));
dmu_object_info_from_db(db, &doi);
bbt = ztest_bt_bonus(db);
ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
lr->lr_crtime[0] = time(NULL);
if (ztest_replay_create(zd, lr, B_FALSE) != 0) {
- ASSERT(missing == 0);
+ ASSERT0(missing);
od->od_object = 0;
missing++;
} else {
od->od_type = od->od_crtype;
od->od_blocksize = od->od_crblocksize;
od->od_gen = od->od_crgen;
- ASSERT(od->od_object != 0);
+ ASSERT3U(od->od_object, !=, 0);
}
ztest_lr_free(lr, sizeof (*lr), od->od_name);
uint64_t blocksize;
void *data;
- VERIFY(dmu_object_info(zd->zd_os, object, &doi) == 0);
+ VERIFY0(dmu_object_info(zd->zd_os, object, &doi));
blocksize = doi.doi_data_block_size;
data = umem_alloc(blocksize, UMEM_NOFAIL);
* will verify that the log really does contain this record.
*/
mutex_enter(&zilog->zl_lock);
- ASSERT(zd->zd_shared != NULL);
+ ASSERT3P(zd->zd_shared, !=, NULL);
ASSERT3U(zd->zd_shared->zd_seq, <=, zilog->zl_commit_lr_seq);
zd->zd_shared->zd_seq = zilog->zl_commit_lr_seq;
mutex_exit(&zilog->zl_lock);
zil_close(zd->zd_zilog);
/* zfsvfs_setup() */
- VERIFY(zil_open(os, ztest_get_data) == zd->zd_zilog);
+ VERIFY3P(zil_open(os, ztest_get_data), ==, zd->zd_zilog);
zil_replay(os, zd, ztest_replay_vector);
(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
* For the case that there is another ztest thread doing
* an export concurrently.
*/
- VERIFY3U(0, ==, spa_open(zo->zo_pool, &spa, FTAG));
+ VERIFY0(spa_open(zo->zo_pool, &spa, FTAG));
int error = spa_destroy(zo->zo_pool);
if (error != EBUSY && error != ZFS_ERR_EXPORT_IN_PROGRESS) {
fatal(0, "spa_destroy(%s) returned unexpected value %d",
props = fnvlist_alloc();
fnvlist_add_uint64(props,
zpool_prop_to_name(ZPOOL_PROP_VERSION), version);
- VERIFY3S(spa_create(name, nvroot, props, NULL, NULL), ==, 0);
+ VERIFY0(spa_create(name, nvroot, props, NULL, NULL));
fnvlist_free(nvroot);
fnvlist_free(props);
- VERIFY3S(spa_open(name, &spa, FTAG), ==, 0);
+ VERIFY0(spa_open(name, &spa, FTAG));
VERIFY3U(spa_version(spa), ==, version);
newversion = ztest_random_spa_version(version + 1);
/* pick a child from the mirror */
if (zs->zs_mirrors >= 1) {
- ASSERT(oldvd->vdev_ops == &vdev_mirror_ops);
- ASSERT(oldvd->vdev_children >= zs->zs_mirrors);
+ ASSERT3P(oldvd->vdev_ops, ==, &vdev_mirror_ops);
+ ASSERT3U(oldvd->vdev_children, >=, zs->zs_mirrors);
oldvd = oldvd->vdev_child[leaf / ztest_opts.zo_raid_children];
}
/* pick a child out of the raidz group */
if (ztest_opts.zo_raid_children > 1) {
if (strcmp(oldvd->vdev_ops->vdev_op_type, "raidz") == 0)
- ASSERT(oldvd->vdev_ops == &vdev_raidz_ops);
+ ASSERT3P(oldvd->vdev_ops, ==, &vdev_raidz_ops);
else
- ASSERT(oldvd->vdev_ops == &vdev_draid_ops);
- ASSERT(oldvd->vdev_children == ztest_opts.zo_raid_children);
+ ASSERT3P(oldvd->vdev_ops, ==, &vdev_draid_ops);
+ ASSERT3U(oldvd->vdev_children, ==, ztest_opts.zo_raid_children);
oldvd = oldvd->vdev_child[leaf % ztest_opts.zo_raid_children];
}
*/
while (oldvd->vdev_children != 0) {
oldvd_has_siblings = B_TRUE;
- ASSERT(oldvd->vdev_children >= 2);
+ ASSERT3U(oldvd->vdev_children, >=, 2);
oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)];
}
size_t fsize;
int fd;
- ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE);
+ ASSERT3S(spa_config_held(spa, SCL_STATE, RW_READER), ==, SCL_STATE);
ASSERT(vd->vdev_ops->vdev_op_leaf);
if ((fd = open(vd->vdev_path, O_RDWR)) == -1)
return (vd);
fsize = lseek(fd, 0, SEEK_END);
- VERIFY(ftruncate(fd, *newsize) == 0);
+ VERIFY0(ftruncate(fd, *newsize));
if (ztest_opts.zo_verbose >= 6) {
(void) printf("%s grew from %lu to %lu bytes\n",
vdev_state_t newstate = VDEV_STATE_UNKNOWN;
int error;
- ASSERT(spa_config_held(spa, SCL_STATE, RW_READER) == SCL_STATE);
+ ASSERT3S(spa_config_held(spa, SCL_STATE, RW_READER), ==, SCL_STATE);
ASSERT(vd->vdev_ops->vdev_op_leaf);
/* Calling vdev_online will initialize the new metaslabs */
mutex_exit(&ztest_checkpoint_lock);
return;
}
- ASSERT(psize > 0);
+ ASSERT3U(psize, >, 0);
newsize = psize + MAX(psize / 8, SPA_MAXBLOCKSIZE);
ASSERT3U(newsize, >, psize);
/*
* Create the objects common to all ztest datasets.
*/
- VERIFY(zap_create_claim(os, ZTEST_DIROBJ,
- DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx) == 0);
+ VERIFY0(zap_create_claim(os, ZTEST_DIROBJ,
+ DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx));
}
static int
/*
* Verify that we can hold an objset that is also owned.
*/
- VERIFY3U(0, ==, dmu_objset_hold(name, FTAG, &os2));
+ VERIFY0(dmu_objset_hold(name, FTAG, &os2));
dmu_objset_rele(os2, FTAG);
/*
bigobj = od[0].od_object;
packobj = od[1].od_object;
chunksize = od[0].od_gen;
- ASSERT(chunksize == od[1].od_gen);
+ ASSERT3U(chunksize, ==, od[1].od_gen);
/*
* Prefetch a random chunk of the big object.
/* LINTED */
bigT = (bufwad_t *)((char *)bigH + chunksize) - 1;
- ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
- ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
+ ASSERT3U((uintptr_t)bigH - (uintptr_t)bigbuf, <, bigsize);
+ ASSERT3U((uintptr_t)bigT - (uintptr_t)bigbuf, <, bigsize);
if (pack->bw_txg > txg)
fatal(0, "future leak: got %llx, open txg is %llx",
(u_longlong_t)bigsize,
(u_longlong_t)txg);
}
- VERIFY(0 == dmu_free_range(os, bigobj, bigoff, bigsize, tx));
+ VERIFY0(dmu_free_range(os, bigobj, bigoff, bigsize, tx));
} else {
if (ztest_opts.zo_verbose >= 7) {
(void) printf("writing offset %llx size %llx"
void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
- VERIFY(0 == dmu_read(os, packobj, packoff,
+ VERIFY0(dmu_read(os, packobj, packoff,
packsize, packcheck, DMU_READ_PREFETCH));
- VERIFY(0 == dmu_read(os, bigobj, bigoff,
+ VERIFY0(dmu_read(os, bigobj, bigoff,
bigsize, bigcheck, DMU_READ_PREFETCH));
- ASSERT(bcmp(packbuf, packcheck, packsize) == 0);
- ASSERT(bcmp(bigbuf, bigcheck, bigsize) == 0);
+ ASSERT0(bcmp(packbuf, packcheck, packsize));
+ ASSERT0(bcmp(bigbuf, bigcheck, bigsize));
umem_free(packcheck, packsize);
umem_free(bigcheck, bigsize);
/* LINTED */
bigT = (bufwad_t *)((char *)bigH + chunksize) - 1;
- ASSERT((uintptr_t)bigH - (uintptr_t)bigbuf < bigsize);
- ASSERT((uintptr_t)bigT - (uintptr_t)bigbuf < bigsize);
+ ASSERT3U((uintptr_t)bigH - (uintptr_t)bigbuf, <, bigsize);
+ ASSERT3U((uintptr_t)bigT - (uintptr_t)bigbuf, <, bigsize);
if (pack->bw_txg > txg)
fatal(0, "future leak: got %llx, open txg is %llx",
packobj = od[1].od_object;
blocksize = od[0].od_blocksize;
chunksize = blocksize;
- ASSERT(chunksize == od[1].od_gen);
+ ASSERT3U(chunksize, ==, od[1].od_gen);
- VERIFY(dmu_object_info(os, bigobj, &doi) == 0);
+ VERIFY0(dmu_object_info(os, bigobj, &doi));
VERIFY(ISP2(doi.doi_data_block_size));
- VERIFY(chunksize == doi.doi_data_block_size);
- VERIFY(chunksize >= 2 * sizeof (bufwad_t));
+ VERIFY3U(chunksize, ==, doi.doi_data_block_size);
+ VERIFY3U(chunksize, >=, 2 * sizeof (bufwad_t));
/*
* Pick a random index and compute the offsets into packobj and bigobj.
packbuf = umem_zalloc(packsize, UMEM_NOFAIL);
bigbuf = umem_zalloc(bigsize, UMEM_NOFAIL);
- VERIFY3U(0, ==, dmu_bonus_hold(os, bigobj, FTAG, &bonus_db));
+ VERIFY0(dmu_bonus_hold(os, bigobj, FTAG, &bonus_db));
bigbuf_arcbufs = umem_zalloc(2 * s * sizeof (arc_buf_t *), UMEM_NOFAIL);
goto out;
for (i = 0; i < 2; i++) {
value[i] = i;
- VERIFY3U(0, ==, zap_add(os, object, hc[i], sizeof (uint64_t),
+ VERIFY0(zap_add(os, object, hc[i], sizeof (uint64_t),
1, &value[i], tx));
}
for (i = 0; i < 2; i++) {
VERIFY3U(EEXIST, ==, zap_add(os, object, hc[i],
sizeof (uint64_t), 1, &value[i], tx));
- VERIFY3U(0, ==,
+ VERIFY0(
zap_length(os, object, hc[i], &zl_intsize, &zl_ints));
ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
ASSERT3U(zl_ints, ==, 1);
}
for (i = 0; i < 2; i++) {
- VERIFY3U(0, ==, zap_remove(os, object, hc[i], tx));
+ VERIFY0(zap_remove(os, object, hc[i], tx));
}
dmu_tx_commit(tx);
ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
ASSERT3U(zl_ints, ==, 1);
- VERIFY(zap_lookup(os, object, txgname, zl_intsize,
- zl_ints, &last_txg) == 0);
+ VERIFY0(zap_lookup(os, object, txgname, zl_intsize,
+ zl_ints, &last_txg));
- VERIFY(zap_length(os, object, propname, &zl_intsize,
- &zl_ints) == 0);
+ VERIFY0(zap_length(os, object, propname, &zl_intsize,
+ &zl_ints));
ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
ASSERT3U(zl_ints, ==, ints);
- VERIFY(zap_lookup(os, object, propname, zl_intsize,
- zl_ints, value) == 0);
+ VERIFY0(zap_lookup(os, object, propname, zl_intsize,
+ zl_ints, value));
for (i = 0; i < ints; i++) {
ASSERT3U(value[i], ==, last_txg + object + i);
for (i = 0; i < ints; i++)
value[i] = txg + object + i;
- VERIFY3U(0, ==, zap_update(os, object, txgname, sizeof (uint64_t),
+ VERIFY0(zap_update(os, object, txgname, sizeof (uint64_t),
1, &txg, tx));
- VERIFY3U(0, ==, zap_update(os, object, propname, sizeof (uint64_t),
+ VERIFY0(zap_update(os, object, propname, sizeof (uint64_t),
ints, value, tx));
dmu_tx_commit(tx);
txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
if (txg == 0)
goto out;
- VERIFY3U(0, ==, zap_remove(os, object, txgname, tx));
- VERIFY3U(0, ==, zap_remove(os, object, propname, tx));
+ VERIFY0(zap_remove(os, object, txgname, tx));
+ VERIFY0(zap_remove(os, object, propname, tx));
dmu_tx_commit(tx);
out:
umem_free(od, sizeof (ztest_od_t));
count = -1ULL;
VERIFY0(zap_count(os, object, &count));
- ASSERT(count != -1ULL);
+ ASSERT3S(count, !=, -1ULL);
/*
* Select an operation: length, lookup, add, update, remove.
break;
case 3:
- VERIFY(zap_update(os, object, name, wsize, wc, data, tx) == 0);
+ VERIFY0(zap_update(os, object, name, wsize, wc, data, tx));
break;
case 4:
ztest_cb_data_t *data = arg;
uint64_t synced_txg;
- VERIFY(data != NULL);
+ VERIFY3P(data, !=, NULL);
VERIFY3S(data->zcd_expected_err, ==, error);
VERIFY(!data->zcd_called);
/*
* Read existing data to make sure there isn't a future leak.
*/
- VERIFY(0 == dmu_read(os, od->od_object, 0, sizeof (uint64_t),
+ VERIFY0(dmu_read(os, od->od_object, 0, sizeof (uint64_t),
&old_txg, DMU_READ_PREFETCH));
if (old_txg > txg)
mirror_save = zs->zs_mirrors;
mutex_exit(&ztest_vdev_lock);
- ASSERT(leaves >= 1);
+ ASSERT3U(leaves, >=, 1);
/*
* While ztest is running the number of leaves will not change. This
if (islog)
(void) pthread_rwlock_wrlock(&ztest_name_lock);
- VERIFY(vdev_offline(spa, guid0, flags) != EBUSY);
+ VERIFY3U(vdev_offline(spa, guid0, flags), !=, EBUSY);
if (islog)
(void) pthread_rwlock_unlock(&ztest_name_lock);
return;
}
- VERIFY(realpath(getexecname(), bin) != NULL);
+ VERIFY3P(realpath(getexecname(), bin), !=, NULL);
if (strstr(bin, "/ztest/")) {
strstr(bin, "/ztest/")[0] = '\0'; /* In-tree */
strcat(bin, "/zdb/zdb");
eligible[eligible_idx++] = cvd;
}
}
- VERIFY(eligible_idx > 0);
+ VERIFY3S(eligible_idx, >, 0);
uint64_t child_no = ztest_random(eligible_idx);
return (ztest_random_concrete_vdev_leaf(eligible[child_no]));
/*
* Get the pool's configuration and guid.
*/
- VERIFY3U(0, ==, spa_open(oldname, &spa, FTAG));
+ VERIFY0(spa_open(oldname, &spa, FTAG));
/*
* Kick off a scrub to tickle scrub/export races.
/*
* Export it.
*/
- VERIFY3U(0, ==, spa_export(oldname, &config, B_FALSE, B_FALSE));
+ VERIFY0(spa_export(oldname, &config, B_FALSE, B_FALSE));
ztest_walk_pool_directory("pools after export");
* Try to import it.
*/
newconfig = spa_tryimport(config);
- ASSERT(newconfig != NULL);
+ ASSERT3P(newconfig, !=, NULL);
fnvlist_free(newconfig);
/*
/*
* Verify that we can open and close the pool using the new name.
*/
- VERIFY3U(0, ==, spa_open(newname, &spa, FTAG));
- ASSERT(pool_guid == spa_guid(spa));
+ VERIFY0(spa_open(newname, &spa, FTAG));
+ ASSERT3U(pool_guid, ==, spa_guid(spa));
spa_close(spa, FTAG);
fnvlist_free(config);
* That's because zap_count() returns the open-context value,
* while dmu_objset_space() returns the rootbp fill count.
*/
- VERIFY3U(0, ==, zap_count(zd->zd_os, ZTEST_DIROBJ, &dirobjs));
+ VERIFY0(zap_count(zd->zd_os, ZTEST_DIROBJ, &dirobjs));
dmu_objset_space(zd->zd_os, &scratch, &scratch, &usedobjs, &scratch);
ASSERT3U(dirobjs + 1, ==, usedobjs);
}
(void) printf("testing spa_freeze()...\n");
kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
- VERIFY3U(0, ==, spa_open(ztest_opts.zo_pool, &spa, FTAG));
- VERIFY3U(0, ==, ztest_dataset_open(0));
+ VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
+ VERIFY0(ztest_dataset_open(0));
ztest_spa = spa;
/*
* Open and close the pool and dataset to induce log replay.
*/
kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
- VERIFY3U(0, ==, spa_open(ztest_opts.zo_pool, &spa, FTAG));
- ASSERT(spa_freeze_txg(spa) == UINT64_MAX);
- VERIFY3U(0, ==, ztest_dataset_open(0));
+ VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
+ ASSERT3U(spa_freeze_txg(spa), ==, UINT64_MAX);
+ VERIFY0(ztest_dataset_open(0));
ztest_spa = spa;
txg_wait_synced(spa_get_dsl(spa), 0);
ztest_dataset_close(0);
fnvlist_free(nvroot);
fnvlist_free(props);
- VERIFY3U(0, ==, spa_open(ztest_opts.zo_pool, &spa, FTAG));
+ VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
zs->zs_metaslab_sz =
1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
spa_close(spa, FTAG);
hdr = (void *)mmap(0, P2ROUNDUP(sizeof (*hdr), getpagesize()),
PROT_READ | PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
- ASSERT(hdr != MAP_FAILED);
+ ASSERT3P(hdr, !=, MAP_FAILED);
- VERIFY3U(0, ==, ftruncate(ztest_fd_data, sizeof (ztest_shared_hdr_t)));
+ VERIFY0(ftruncate(ztest_fd_data, sizeof (ztest_shared_hdr_t)));
hdr->zh_hdr_size = sizeof (ztest_shared_hdr_t);
hdr->zh_opts_size = sizeof (ztest_shared_opts_t);
hdr->zh_ds_count = ztest_opts.zo_datasets;
size = shared_data_size(hdr);
- VERIFY3U(0, ==, ftruncate(ztest_fd_data, size));
+ VERIFY0(ftruncate(ztest_fd_data, size));
(void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
}
hdr = (void *)mmap(0, P2ROUNDUP(sizeof (*hdr), getpagesize()),
PROT_READ, MAP_SHARED, ztest_fd_data, 0);
- ASSERT(hdr != MAP_FAILED);
+ ASSERT3P(hdr, !=, MAP_FAILED);
size = shared_data_size(hdr);
(void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
hdr = ztest_shared_hdr = (void *)mmap(0, P2ROUNDUP(size, getpagesize()),
PROT_READ | PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
- ASSERT(hdr != MAP_FAILED);
+ ASSERT3P(hdr, !=, MAP_FAILED);
buf = (uint8_t *)hdr;
offset = hdr->zh_hdr_size;
(void) setrlimit(RLIMIT_NOFILE, &rl);
(void) close(ztest_fd_rand);
- VERIFY(11 >= snprintf(fd_data_str, 12, "%d", ztest_fd_data));
- VERIFY(0 == setenv("ZTEST_FD_DATA", fd_data_str, 1));
+ VERIFY3S(11, >=,
+ snprintf(fd_data_str, 12, "%d", ztest_fd_data));
+ VERIFY0(setenv("ZTEST_FD_DATA", fd_data_str, 1));
(void) enable_extended_FILE_stdio(-1, -1);
if (libpath != NULL)
- VERIFY(0 == setenv("LD_LIBRARY_PATH", libpath, 1));
+ VERIFY0(setenv("LD_LIBRARY_PATH", libpath, 1));
(void) execv(cmd, emptyargv);
ztest_dump_core = B_FALSE;
fatal(B_TRUE, "exec failed: %s", cmd);
ASSERT3U(ztest_opts.zo_datasets, ==, ztest_shared_hdr->zh_ds_count);
/* Override location of zpool.cache */
- VERIFY(asprintf((char **)&spa_config_path, "%s/zpool.cache",
- ztest_opts.zo_dir) != -1);
+ VERIFY3S(asprintf((char **)&spa_config_path, "%s/zpool.cache",
+ ztest_opts.zo_dir), !=, -1);
ztest_ds = umem_alloc(ztest_opts.zo_datasets * sizeof (ztest_ds_t),
UMEM_NOFAIL);
projects / mirror_zfs.git / commitdiff