Anyraid implementation

Signed-off-by: Paul Dagnelie <[email protected]>
Sponsored-by: Eshtek, creators of HexOS
Sponsored-by: Klara, Inc.

Author: Paul Dagnelie

cmd/zdb/zdb.c

@@ -78,6 +78,7 @@
 #include "zpool_util.h"
 #include <sys/zfs_context.h>
 #include <sys/stat.h>
+#include <sys/vdev_anyraid.h>
 
 /*
  * For any given vdev specification, we can have multiple errors.  The
@@ -457,7 +458,8 @@ is_raidz_mirror(replication_level_t *a, replication_level_t *b,
 {
 	if ((strcmp(a->zprl_type, "raidz") == 0 ||
 	    strcmp(a->zprl_type, "draid") == 0) &&
-	    strcmp(b->zprl_type, "mirror") == 0) {
+	    (strcmp(b->zprl_type, "mirror") == 0 ||
+	    strcmp(b->zprl_type, "anyraid") == 0)) {
 		*raidz = a;
 		*mirror = b;
 		return (B_TRUE);
@@ -567,6 +569,7 @@ get_replication(nvlist_t *nvroot, boolean_t fatal)
 			 * already reported an error for this spec, so don't
 			 * bother doing it again.
 			 */
+			const char *orig_type = type;
 			type = NULL;
 			dontreport = 0;
 			vdev_size = -1LL;
@@ -666,7 +669,8 @@ get_replication(nvlist_t *nvroot, boolean_t fatal)
 				if (!dontreport &&
 				    (vdev_size != -1LL &&
 				    (llabs(size - vdev_size) >
-				    ZPOOL_FUZZ))) {
+				    ZPOOL_FUZZ)) && strcmp(orig_type,
+				    VDEV_TYPE_ANYRAID) != 0) {
 					if (ret != NULL)
 						free(ret);
 					ret = NULL;
@@ -746,19 +750,6 @@ get_replication(nvlist_t *nvroot, boolean_t fatal)
 					else
 						return (NULL);
 				}
-			} else if (strcmp(lastrep.zprl_type, rep.zprl_type) !=
-			    0) {
-				if (ret != NULL)
-					free(ret);
-				ret = NULL;
-				if (fatal)
-					vdev_error(gettext(
-					    "mismatched replication level: "
-					    "both %s and %s vdevs are "
-					    "present\n"),
-					    lastrep.zprl_type, rep.zprl_type);
-				else
-					return (NULL);
 			} else if (lastrep.zprl_parity != rep.zprl_parity) {
 				if (ret)
 					free(ret);
@@ -1220,7 +1211,7 @@ is_device_in_use(nvlist_t *config, nvlist_t *nv, boolean_t force,
 }
 
 /*
- * Returns the parity level extracted from a raidz or draid type.
+ * Returns the parity level extracted from a raidz, anyraid, or draid type.
  * If the parity cannot be determined zero is returned.
  */
 static int
@@ -1248,6 +1239,22 @@ get_parity(const char *type)
 				return (0);
 			}
 		}
+	} else if (strncmp(type, VDEV_TYPE_ANYRAID,
+	    strlen(VDEV_TYPE_ANYRAID)) == 0) {
+		p = type + strlen(VDEV_TYPE_ANYRAID);
+
+		if (*p == '\0') {
+			/* when unspecified default to 1-parity mirror */
+			return (1);
+		} else {
+			char *end;
+			errno = 0;
+			parity = strtol(p, &end, 10);
+			if (errno != 0 || *end != '\0' ||
+			    parity < 0 || parity > VDEV_ANYRAID_MAXPARITY) {
+				return (0);
+			}
+		}
 	} else if (strncmp(type, VDEV_TYPE_DRAID,
 	    strlen(VDEV_TYPE_DRAID)) == 0) {
 		p = type + strlen(VDEV_TYPE_DRAID);
@@ -1305,6 +1312,15 @@ is_grouping(const char *type, int *mindev, int *maxdev)
 	if (maxdev != NULL)
 		*maxdev = INT_MAX;
 
+	if (strncmp(type, VDEV_TYPE_ANYRAID, strlen(VDEV_TYPE_ANYRAID)) == 0) {
+		nparity = get_parity(type);
+		if (mindev != NULL)
+			*mindev = nparity + 1;
+		if (maxdev != NULL)
+			*maxdev = 255;
+		return (VDEV_TYPE_ANYRAID);
+	}
+
 	if (strcmp(type, "mirror") == 0) {
 		if (mindev != NULL)
 			*mindev = 2;
@@ -1339,6 +1355,22 @@ is_grouping(const char *type, int *mindev, int *maxdev)
 	return (NULL);
 }
 
+static int
+anyraid_config_by_type(nvlist_t *nv, const char *type)
+{
+	uint64_t nparity = 0;
+
+	if (strncmp(type, VDEV_TYPE_ANYRAID, strlen(VDEV_TYPE_ANYRAID)) != 0)
+		return (EINVAL);
+
+	nparity = (uint64_t)get_parity(type);
+
+	fnvlist_add_uint8(nv, ZPOOL_CONFIG_ANYRAID_PARITY_TYPE, VAP_MIRROR);
+	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, nparity);
+
+	return (0);
+}
+
 /*
  * Extract the configuration parameters encoded in the dRAID type and
  * use them to generate a dRAID configuration.  The expected format is:
@@ -1524,9 +1556,9 @@ construct_spec(nvlist_t *props, int argc, char **argv)
 		nv = NULL;
 
 		/*
-		 * If it's a mirror, raidz, or draid the subsequent arguments
-		 * are its leaves -- until we encounter the next mirror,
-		 * raidz or draid.
+		 * If it's a mirror, raidz, anyraid, or draid the subsequent
+		 * arguments are its leaves -- until we encounter the next
+		 * mirror, raidz, anyraid, or draid.
 		 */
 		if ((type = is_grouping(fulltype, &mindev, &maxdev)) != NULL) {
 			nvlist_t **child = NULL;
@@ -1593,7 +1625,12 @@ construct_spec(nvlist_t *props, int argc, char **argv)
 			}
 
 			if (is_log) {
-				if (strcmp(type, VDEV_TYPE_MIRROR) != 0) {
+				/*
+				 * TODO: only AnyRAID mirror is expected to be
+				 * allowed.
+				 */
+				if (strcmp(type, VDEV_TYPE_MIRROR) != 0 &&
+				    strcmp(type, VDEV_TYPE_ANYRAID) != 0) {
 					(void) fprintf(stderr,
 					    gettext("invalid vdev "
 					    "specification: unsupported 'log' "
@@ -1683,6 +1720,15 @@ construct_spec(nvlist_t *props, int argc, char **argv)
 					    ZPOOL_CONFIG_NPARITY,
 					    mindev - 1) == 0);
 				}
+				if (strcmp(type, VDEV_TYPE_ANYRAID) == 0) {
+					if (anyraid_config_by_type(nv, fulltype)
+					    != 0) {
+						for (c = 0; c < children; c++)
+							nvlist_free(child[c]);
+						free(child);
+						goto spec_out;
+					}
+				}
 				if (strcmp(type, VDEV_TYPE_DRAID) == 0) {
 					if (draid_config_by_type(nv,
 					    fulltype, children) != 0) {

cmd/zpool/zpool_vdev.c

@@ -106,6 +106,7 @@
 #include <sys/zio.h>
 #include <sys/zil.h>
 #include <sys/zil_impl.h>
+#include <sys/vdev_anyraid.h>
 #include <sys/vdev_draid.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_file.h>
@@ -278,6 +279,7 @@ extern uint64_t raidz_expand_max_reflow_bytes;
 extern uint_t raidz_expand_pause_point;
 extern boolean_t ddt_prune_artificial_age;
 extern boolean_t ddt_dump_prune_histogram;
+extern uint64_t zfs_anyraid_min_tile_size;
 
 
 static ztest_shared_opts_t *ztest_shared_opts;
@@ -673,10 +675,12 @@ fatal(int do_perror, const char *message, ...)
 	fatal_msg = buf;			/* to ease debugging */
 
 out:
-	if (ztest_dump_core)
+	if (ztest_dump_core) {
 		abort();
-	else
+	} else {
+		// NOTE: Not safe if we've called kernel_fini already
 		dump_debug_buffer();
+	}
 
 	exit(3);
 }
@@ -769,7 +773,7 @@ static ztest_option_t option_table[] = {
 	    DEFAULT_RAID_CHILDREN, NULL},
 	{ 'R',	"raid-parity", "INTEGER", "Raid parity",
 	    DEFAULT_RAID_PARITY, NULL},
-	{ 'K',  "raid-kind", "raidz|eraidz|draid|random", "Raid kind",
+	{ 'K',  "raid-kind", "raidz|eraidz|draid|anyraid|random", "Raid kind",
 	    NO_DEFAULT, "random"},
 	{ 'D',	"draid-data", "INTEGER", "Number of draid data drives",
 	    DEFAULT_DRAID_DATA, NULL},
@@ -1119,7 +1123,7 @@ process_options(int argc, char **argv)
 	}
 
 	if (strcmp(raid_kind, "random") == 0) {
-		switch (ztest_random(3)) {
+		switch (ztest_random(4)) {
 		case 0:
 			raid_kind = "raidz";
 			break;
@@ -1129,6 +1133,9 @@ process_options(int argc, char **argv)
 		case 2:
 			raid_kind = "draid";
 			break;
+		case 3:
+			raid_kind = "anyraid";
+			break;
 		}
 
 		if (ztest_opts.zo_verbose >= 3)
@@ -1180,11 +1187,25 @@ process_options(int argc, char **argv)
 		zo->zo_raid_parity = MIN(zo->zo_raid_parity,
 		    zo->zo_raid_children - 1);
 
-	} else /* using raidz */ {
-		ASSERT0(strcmp(raid_kind, "raidz"));
+	} else if (strcmp(raid_kind, "raidz") == 0) {
+		zo->zo_raid_parity = MIN(zo->zo_raid_parity,
+		    zo->zo_raid_children - 1);
+	} else if (strcmp(raid_kind, "anyraid") == 0) {
+		uint64_t min_devsize;
+
+		/* With fewer disks use 1G, otherwise 512M is OK */
+		min_devsize = (ztest_opts.zo_raid_children < 16) ?
+		    (1ULL << 30) : (512ULL << 20);
+		if (zo->zo_vdev_size < min_devsize)
+			zo->zo_vdev_size = min_devsize;
 
 		zo->zo_raid_parity = MIN(zo->zo_raid_parity,
 		    zo->zo_raid_children - 1);
+
+		(void) strlcpy(zo->zo_raid_type, VDEV_TYPE_ANYRAID,
+		    sizeof (zo->zo_raid_type));
+	} else {
+		fatal(B_FALSE, "invalid raid kind %s", raid_kind);
 	}
 
 	zo->zo_vdevtime =
@@ -1375,6 +1396,9 @@ make_vdev_raid(const char *path, const char *aux, const char *pool, size_t size,
 		fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NDATA, ndata);
 		fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NSPARES, nspares);
 		fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NGROUPS, ngroups);
+	} else if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_ANYRAID) == 0) {
+		fnvlist_add_uint8(raid, ZPOOL_CONFIG_ANYRAID_PARITY_TYPE,
+		    VAP_MIRROR);
 	}
 
 	for (c = 0; c < r; c++)
@@ -3165,7 +3189,8 @@ ztest_spa_upgrade(ztest_ds_t *zd, uint64_t id)
 		return;
 
 	/* dRAID added after feature flags, skip upgrade test. */
-	if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_DRAID) == 0)
+	if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_DRAID) == 0 ||
+	    strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_ANYRAID) == 0)
 		return;
 
 	mutex_enter(&ztest_vdev_lock);
@@ -3789,28 +3814,47 @@ ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
 	if (ztest_opts.zo_raid_children > 1) {
 		if (strcmp(oldvd->vdev_ops->vdev_op_type, "raidz") == 0)
 			ASSERT3P(oldvd->vdev_ops, ==, &vdev_raidz_ops);
+		else if (strcmp(oldvd->vdev_ops->vdev_op_type, "anyraid") == 0)
+			ASSERT3P(oldvd->vdev_ops, ==, &vdev_anyraid_ops);
 		else
 			ASSERT3P(oldvd->vdev_ops, ==, &vdev_draid_ops);
 		oldvd = oldvd->vdev_child[leaf % raidz_children];
 	}
 
+	if (!replacing && oldvd->vdev_parent->vdev_ops == &vdev_anyraid_ops) {
+		oldvd = oldvd->vdev_parent;
+	}
+
 	/*
 	 * If we're already doing an attach or replace, oldvd may be a
-	 * mirror vdev -- in which case, pick a random child.
+	 * mirror vdev -- in which case, pick a random child. For anyraid vdevs,
+	 * attachment occurs at the parent level.
 	 */
-	while (oldvd->vdev_children != 0) {
+	while (oldvd->vdev_children != 0 && oldvd->vdev_ops !=
+	    &vdev_anyraid_ops) {
 		oldvd_has_siblings = B_TRUE;
 		ASSERT3U(oldvd->vdev_children, >=, 2);
 		oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)];
 	}
 
 	oldguid = oldvd->vdev_guid;
-	oldsize = vdev_get_min_asize(oldvd);
+	if (oldvd->vdev_ops != &vdev_anyraid_ops)
+		oldsize = vdev_get_min_asize(oldvd);
+	else
+		oldsize = oldvd->vdev_child[
+		    ztest_random(oldvd->vdev_children)]->vdev_asize;
 	oldvd_is_log = oldvd->vdev_top->vdev_islog;
 	oldvd_is_special =
 	    oldvd->vdev_top->vdev_alloc_bias == VDEV_BIAS_SPECIAL ||
 	    oldvd->vdev_top->vdev_alloc_bias == VDEV_BIAS_DEDUP;
-	(void) strlcpy(oldpath, oldvd->vdev_path, MAXPATHLEN);
+	if (oldvd->vdev_path == NULL) {
+		ASSERT3P(oldvd->vdev_ops, ==, &vdev_anyraid_ops);
+		snprintf(oldpath, MAXPATHLEN, "%s-%llu",
+		    oldvd->vdev_ops->vdev_op_type,
+		    (u_longlong_t)oldvd->vdev_id);
+	} else {
+		(void) strlcpy(oldpath, oldvd->vdev_path, MAXPATHLEN);
+	}
 	pvd = oldvd->vdev_parent;
 	pguid = pvd->vdev_guid;
 
@@ -3819,7 +3863,8 @@ ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
 	 * to the detach the pool is scrubbed in order to prevent creating
 	 * unrepairable blocks as a result of the data corruption injection.
 	 */
-	if (oldvd_has_siblings && ztest_random(2) == 0) {
+	if (oldvd_has_siblings && oldvd->vdev_ops != &vdev_anyraid_ops &&
+	    ztest_random(2) == 0) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 
 		error = ztest_scrub_impl(spa);
@@ -3883,7 +3928,9 @@ ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
 	 * If newvd is a distributed spare and it's being attached to a
 	 * dRAID which is not its parent it should fail with ENOTSUP.
 	 */
-	if (pvd->vdev_ops != &vdev_mirror_ops &&
+	if (oldvd->vdev_ops == &vdev_anyraid_ops)
+		expected_error = 0;
+	else 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))
@@ -3895,7 +3942,9 @@ ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
 		expected_error = replacing ? 0 : EBUSY;
 	else if (vdev_lookup_by_path(rvd, newpath) != NULL)
 		expected_error = EBUSY;
-	else if (!newvd_is_dspare && newsize < oldsize)
+	else if (newsize < oldsize && !(newvd_is_dspare ||
+	    (pvd->vdev_ops == &vdev_anyraid_ops &&
+	    newsize < pvd->vdev_ops->vdev_op_min_asize(pvd, oldvd))))
 		expected_error = EOVERFLOW;
 	else if (ashift > oldvd->vdev_top->vdev_ashift)
 		expected_error = EDOM;
@@ -3916,8 +3965,9 @@ ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
 	 * When supported select either a healing or sequential resilver.
 	 */
 	boolean_t rebuilding = B_FALSE;
-	if (pvd->vdev_ops == &vdev_mirror_ops ||
-	    pvd->vdev_ops ==  &vdev_root_ops) {
+	if (oldvd->vdev_ops != &vdev_anyraid_ops &&
+	    (pvd->vdev_ops == &vdev_mirror_ops ||
+	    pvd->vdev_ops == &vdev_root_ops)) {
 		rebuilding = !!ztest_random(2);
 	}
 
@@ -8994,6 +9044,9 @@ main(int argc, char **argv)
 		metaslab_df_alloc_threshold =
 		    zs->zs_metaslab_df_alloc_threshold;
 
+		zfs_anyraid_min_tile_size = MIN(zfs_anyraid_min_tile_size,
+		    ztest_opts.zo_vdev_size / 8);
+
 		if (zs->zs_do_init)
 			ztest_run_init();
 		else

cmd/ztest.c

@@ -100,6 +100,7 @@ COMMON_H = \
 	sys/unique.h \
 	sys/uuid.h \
 	sys/vdev.h \
+	sys/vdev_anyraid.h \
 	sys/vdev_disk.h \
 	sys/vdev_draid.h \
 	sys/vdev_file.h \

include/Makefile.am

@@ -38,6 +38,7 @@ typedef const struct kernel_param zfs_kernel_param_t;
 
 enum scope_prefix_types {
 	zfs,
+	zfs_anyraid,
 	zfs_arc,
 	zfs_brt,
 	zfs_condense,