upstream/illumos/illumos-gate: comparison usr/src/cmd/ztest/ztest.c

equal deleted inserted replaced

-:905db6a104b6
+:7d2fd61355d7
 	return (raidz);
 }
 static nvlist_t *
 make_vdev_mirror(char *path, char *aux, size_t size, uint64_t ashift,
-	int log, int r, int m)
+	int r, int m)
 {
 	nvlist_t *mirror, **child;
 	int c;
 	if (m < 1)
 	VERIFY(nvlist_alloc(&mirror, NV_UNIQUE_NAME, 0) == 0);
 	VERIFY(nvlist_add_string(mirror, ZPOOL_CONFIG_TYPE,
 	    VDEV_TYPE_MIRROR) == 0);
 	VERIFY(nvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN,
 	    child, m) == 0);
-	VERIFY(nvlist_add_uint64(mirror, ZPOOL_CONFIG_IS_LOG, log) == 0);
 	for (c = 0; c < m; c++)
 		nvlist_free(child[c]);
 	umem_free(child, m * sizeof (nvlist_t *));
 	ASSERT(t > 0);
 	child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL);
-	for (c = 0; c < t; c++)
+	for (c = 0; c < t; c++) {
-		child[c] = make_vdev_mirror(path, aux, size, ashift, log, r, m);
+		child[c] = make_vdev_mirror(path, aux, size, ashift, r, m);
+		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
+		    log) == 0);
+	}
 	VERIFY(nvlist_alloc(&root, NV_UNIQUE_NAME, 0) == 0);
 	VERIFY(nvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) == 0);
 	VERIFY(nvlist_add_nvlist_array(root, aux ? aux : ZPOOL_CONFIG_CHILDREN,
 	    child, t) == 0);
 	spa_close(spa, FTAG);
 	(void) rw_unlock(&ztest_shared->zs_name_lock);
 }
+static vdev_t *
+vdev_lookup_by_path(vdev_t *vd, const char *path)
+{
+	vdev_t *mvd;
+	if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0)
+		return (vd);
+	for (int c = 0; c < vd->vdev_children; c++)
+		if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
+		    NULL)
+			return (mvd);
+	return (NULL);
+}
 /*
 * Verify that vdev_add() works as expected.
 */
 void
 ztest_vdev_add_remove(ztest_args_t *za)
 */
 void
 ztest_vdev_aux_add_remove(ztest_args_t *za)
 {
 	spa_t *spa = za->za_spa;
+	vdev_t *rvd = spa->spa_root_vdev;
 	spa_aux_vdev_t *sav;
 	char *aux;
 	uint64_t guid = 0;
 	int error;
-	if (ztest_random(3) == 0) {
+	if (ztest_random(2) == 0) {
 		sav = &spa->spa_spares;
 		aux = ZPOOL_CONFIG_SPARES;
 	} else {
 		sav = &spa->spa_l2cache;
 		aux = ZPOOL_CONFIG_L2CACHE;
 			    zopt_pool, aux, ztest_shared->zs_vdev_aux);
 			for (c = 0; c < sav->sav_count; c++)
 				if (strcmp(sav->sav_vdevs[c]->vdev_path,
 				    path) == 0)
 					break;
-			if (c == sav->sav_count)
+			if (c == sav->sav_count &&
+			    vdev_lookup_by_path(rvd, path) == NULL)
 				break;
 			ztest_shared->zs_vdev_aux++;
 		}
 	}
 	if (guid == 0) {
 		/*
 		 * Add a new device.
 		 */
-		nvlist_t *nvroot = make_vdev_root(NULL, aux, zopt_vdev_size, 0,
+		nvlist_t *nvroot = make_vdev_root(NULL, aux,
-		    0, 0, 0, 1);
+		    (zopt_vdev_size * 5) / 4, 0, 0, 0, 0, 1);
 		error = spa_vdev_add(spa, nvroot);
 		if (error != 0)
 			fatal(0, "spa_vdev_add(%p) = %d", nvroot, error);
 		nvlist_free(nvroot);
 	} else {
 	}
 	(void) mutex_unlock(&ztest_shared->zs_vdev_lock);
 }
-static vdev_t *
-vdev_lookup_by_path(vdev_t *vd, const char *path)
-{
-	int c;
-	vdev_t *mvd;
-	if (vd->vdev_path != NULL) {
-		if (vd->vdev_wholedisk == 1) {
-			/*
-			 * For whole disks, the internal path has 's0', but the
-			 * path passed in by the user doesn't.
-			 */
-			if (strlen(path) == strlen(vd->vdev_path) - 2 &&
-			    strncmp(path, vd->vdev_path, strlen(path)) == 0)
-				return (vd);
-		} else if (strcmp(path, vd->vdev_path) == 0) {
-			return (vd);
-		}
-	}
-	for (c = 0; c < vd->vdev_children; c++)
-		if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
-		    NULL)
-			return (mvd);
-	return (NULL);
-}
 /*
 * Verify that we can attach and detach devices.
 */
 void
 ztest_vdev_attach_detach(ztest_args_t *za)
 {
 	spa_t *spa = za->za_spa;
+	spa_aux_vdev_t *sav = &spa->spa_spares;
 	vdev_t *rvd = spa->spa_root_vdev;
 	vdev_t *oldvd, *newvd, *pvd;
 	nvlist_t *root;
 	uint64_t leaves = MAX(zopt_mirrors, 1) * zopt_raidz;
 	uint64_t leaf, top;
 	uint64_t ashift = ztest_get_ashift();
+	uint64_t oldguid;
 	size_t oldsize, newsize;
 	char oldpath[MAXPATHLEN], newpath[MAXPATHLEN];
 	int replacing;
+	int newvd_is_spare = B_FALSE;
+	int oldvd_is_log;
 	int error, expected_error;
 	(void) mutex_lock(&ztest_shared->zs_vdev_lock);
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 	 * Pick a random leaf within it.
 	 */
 	leaf = ztest_random(leaves);
 	/*
-	 * Generate the path to this leaf.  The filename will end with 'a'.
+	 * Locate this vdev.
-	 * We'll alternate replacements with a filename that ends with 'b'.
+	 */
-	 */
+	oldvd = rvd->vdev_child[top];
-	(void) snprintf(oldpath, sizeof (oldpath),
+	if (zopt_mirrors >= 1)
-	    ztest_dev_template, zopt_dir, zopt_pool, top * leaves + leaf);
+		oldvd = oldvd->vdev_child[leaf / zopt_raidz];
+	if (zopt_raidz > 1)
-	bcopy(oldpath, newpath, MAXPATHLEN);
+		oldvd = oldvd->vdev_child[leaf % zopt_raidz];
 	/*
-	 * If the 'a' file isn't part of the pool, the 'b' file must be.
+	 * If we're already doing an attach or replace, oldvd may be a
-	 */
+	 * mirror vdev -- in which case, pick a random child.
-	if (vdev_lookup_by_path(rvd, oldpath) == NULL)
+	 */
-		oldpath[strlen(oldpath) - 1] = 'b';
+	while (oldvd->vdev_children != 0) {
-	else
+		ASSERT(oldvd->vdev_children == 2);
-		newpath[strlen(newpath) - 1] = 'b';
+		oldvd = oldvd->vdev_child[ztest_random(2)];
+	}
-	/*
-	 * Now oldpath represents something that's already in the pool,
+	oldguid = oldvd->vdev_guid;
-	 * and newpath is the thing we'll try to attach.
+	oldsize = vdev_get_rsize(oldvd);
-	 */
+	oldvd_is_log = oldvd->vdev_top->vdev_islog;
-	oldvd = vdev_lookup_by_path(rvd, oldpath);
+	(void) strcpy(oldpath, oldvd->vdev_path);
-	newvd = vdev_lookup_by_path(rvd, newpath);
-	ASSERT(oldvd != NULL);
 	pvd = oldvd->vdev_parent;
 	/*
-	 * Make newsize a little bigger or smaller than oldsize.
+	 * For the new vdev, choose with equal probability between the two
-	 * If it's smaller, the attach should fail.
+	 * standard paths (ending in either 'a' or 'b') or a random hot spare.
-	 * If it's larger, and we're doing a replace,
+	 */
-	 * we should get dynamic LUN growth when we're done.
+	if (sav->sav_count != 0 && ztest_random(3) == 0) {
-	 */
+		newvd = sav->sav_vdevs[ztest_random(sav->sav_count)];
-	oldsize = vdev_get_rsize(oldvd);
+		newvd_is_spare = B_TRUE;
-	newsize = 10 * oldsize / (9 + ztest_random(3));
+		(void) strcpy(newpath, newvd->vdev_path);
+	} else {
+		(void) snprintf(newpath, sizeof (newpath), ztest_dev_template,
+		    zopt_dir, zopt_pool, top * leaves + leaf);
+		if (ztest_random(2) == 0)
+			newpath[strlen(newpath) - 1] = 'b';
+		newvd = vdev_lookup_by_path(rvd, newpath);
+	}
+	if (newvd) {
+		newsize = vdev_get_rsize(newvd);
+	} else {
+		/*
+		 * Make newsize a little bigger or smaller than oldsize.
+		 * If it's smaller, the attach should fail.
+		 * If it's larger, and we're doing a replace,
+		 * we should get dynamic LUN growth when we're done.
+		 */
+		newsize = 10 * oldsize / (9 + ztest_random(3));
+	}
 	/*
 	 * If pvd is not a mirror or root, the attach should fail with ENOTSUP,
 	 * unless it's a replace; in that case any non-replacing parent is OK.
 	 *
 	 * If newvd is already part of the pool, it should fail with EBUSY.
 	 *
 	 * If newvd is too small, it should fail with EOVERFLOW.
 	 */
-	if (newvd != NULL)
+	if (pvd->vdev_ops != &vdev_mirror_ops &&
+	    pvd->vdev_ops != &vdev_root_ops && (!replacing ||
+	    pvd->vdev_ops == &vdev_replacing_ops ||
+	    pvd->vdev_ops == &vdev_spare_ops))
+		expected_error = ENOTSUP;
+	else if (newvd_is_spare && (!replacing || oldvd_is_log))
+		expected_error = ENOTSUP;
+	else if (newvd == oldvd)
+		expected_error = replacing ? 0 : EBUSY;
+	else if (vdev_lookup_by_path(rvd, newpath) != NULL)
 		expected_error = EBUSY;
-	else if (pvd->vdev_ops != &vdev_mirror_ops &&
-	    pvd->vdev_ops != &vdev_root_ops &&
-	    (!replacing || pvd->vdev_ops == &vdev_replacing_ops))
-		expected_error = ENOTSUP;
 	else if (newsize < oldsize)
 		expected_error = EOVERFLOW;
 	else if (ashift > oldvd->vdev_top->vdev_ashift)
 		expected_error = EDOM;
 	else
 	 * Build the nvlist describing newpath.
 	 */
 	root = make_vdev_root(newpath, NULL, newvd == NULL ? newsize : 0,
 	    ashift, 0, 0, 0, 1);
-	error = spa_vdev_attach(spa, oldvd->vdev_guid, root, replacing);
+	error = spa_vdev_attach(spa, oldguid, root, replacing);
 	nvlist_free(root);
 	/*
 	 * If our parent was the replacing vdev, but the replace completed,

changeset 7768	7d2fd61355d7
parent 7762	067dd33ef32c
child 7793	4dbbc0a3f135