spa_min_alloc should be GCD, not min

Since spa_min_alloc may not be a power of 2, unlike ashifts, in the
case of DRAID, we should not select the minimal value among several
vdevs. Rounding to a multiple of it is unlikely to work for other
vdevs. Instead, using the greatest common divisor produces smaller
yet more reasonable results.

Signed-off-by: Ameer Hamza <[email protected]>

Author: ixhamza

include/sys/spa_impl.h

@@ -250,6 +250,7 @@ struct spa {
 	uint64_t	spa_min_ashift;		/* of vdevs in normal class */
 	uint64_t	spa_max_ashift;		/* of vdevs in normal class */
 	uint64_t	spa_min_alloc;		/* of vdevs in normal class */
+	uint64_t	spa_gcd_alloc;		/* of vdevs in normal class */
 	uint64_t	spa_config_guid;	/* config pool guid */
 	uint64_t	spa_load_guid;		/* spa_load initialized guid */
 	uint64_t	spa_last_synced_guid;	/* last synced guid */

module/zfs/spa_misc.c

@@ -772,6 +772,7 @@ spa_add(const char *name, nvlist_t *config, const char *altroot)
 	spa->spa_min_ashift = INT_MAX;
 	spa->spa_max_ashift = 0;
 	spa->spa_min_alloc = INT_MAX;
+	spa->spa_gcd_alloc = INT_MAX;
 
 	/* Reset cached value */
 	spa->spa_dedup_dspace = ~0ULL;

module/zfs/vdev.c

@@ -1393,6 +1393,20 @@ vdev_remove_parent(vdev_t *cvd)
 	vdev_free(mvd);
 }
 
+/*
+ * Choose GCD for spa_gcd_alloc.
+ */
+static uint64_t
+vdev_gcd(uint64_t a, uint64_t b)
+{
+	while (b != 0) {
+		uint64_t t = b;
+		b = a % b;
+		a = t;
+	}
+	return (a);
+}
+
 void
 vdev_metaslab_group_create(vdev_t *vd)
 {
@@ -1445,8 +1459,16 @@ vdev_metaslab_group_create(vdev_t *vd)
 				spa->spa_min_ashift = vd->vdev_ashift;
 
 			uint64_t min_alloc = vdev_get_min_alloc(vd);
-			if (min_alloc < spa->spa_min_alloc)
+			if (spa->spa_min_alloc == INT_MAX &&
+			    spa->spa_gcd_alloc == INT_MAX) {
 				spa->spa_min_alloc = min_alloc;
+				spa->spa_gcd_alloc = min_alloc;
+			} else {
+				if (min_alloc < spa->spa_min_alloc)
+					spa->spa_min_alloc = min_alloc;
+				spa->spa_gcd_alloc = vdev_gcd(min_alloc,
+				    spa->spa_gcd_alloc);
+			}
 		}
 	}
 }
@@ -2207,8 +2229,16 @@ vdev_open(vdev_t *vd)
 	if (vd->vdev_top == vd && vd->vdev_ashift != 0 &&
 	    vd->vdev_islog == 0 && vd->vdev_aux == NULL) {
 		uint64_t min_alloc = vdev_get_min_alloc(vd);
-		if (min_alloc < spa->spa_min_alloc)
+		if (spa->spa_min_alloc == INT_MAX &&
+		    spa->spa_gcd_alloc == INT_MAX) {
 			spa->spa_min_alloc = min_alloc;
+			spa->spa_gcd_alloc = min_alloc;
+		} else {
+			if (min_alloc < spa->spa_min_alloc)
+				spa->spa_min_alloc = min_alloc;
+			spa->spa_gcd_alloc = vdev_gcd(min_alloc,
+			    spa->spa_gcd_alloc);
+		}
 	}
 
 	/*

module/zfs/zio.c

@@ -89,6 +89,11 @@ static uint_t zio_slow_io_ms = (30 * MILLISEC);
 #define	BP_SPANB(indblkshift, level) \
 	(((uint64_t)1) << ((level) * ((indblkshift) - SPA_BLKPTRSHIFT)))
 #define	COMPARE_META_LEVEL	0x80000000ul
+
+/* Get allocation size between spa_min_alloc and spa_gcd_alloc */
+#define SPA_ALLOC_SIZE(size, min_alloc, gcd_alloc) \
+	((size > min_alloc) ? gcd_alloc : min_alloc)
+
 /*
  * The following actions directly effect the spa's sync-to-convergence logic.
  * The values below define the sync pass when we start performing the action.
@@ -1802,9 +1807,11 @@ zio_write_compress(zio_t *zio)
 			 * in that we charge for the padding used to fill out
 			 * the last sector.
 			 */
-			ASSERT3U(spa->spa_min_alloc, >=, SPA_MINBLOCKSHIFT);
+			uint64_t spa_alloc_size = SPA_ALLOC_SIZE(psize,
+			    spa->spa_min_alloc, spa->spa_gcd_alloc);
+			ASSERT3U(spa_alloc_size, >=, SPA_MINBLOCKSHIFT);
 			size_t rounded = (size_t)roundup(psize,
-			    spa->spa_min_alloc);
+			    spa_alloc_size);
 			if (rounded >= lsize) {
 				compress = ZIO_COMPRESS_OFF;
 				zio_buf_free(cbuf, lsize);
@@ -1847,8 +1854,8 @@ zio_write_compress(zio_t *zio)
 		 * take this codepath because it will change the on-disk block
 		 * and decryption will fail.
 		 */
-		size_t rounded = MIN((size_t)roundup(psize,
-		    spa->spa_min_alloc), lsize);
+		size_t rounded = MIN((size_t)roundup(psize, SPA_ALLOC_SIZE(
+		    psize, spa->spa_min_alloc, spa->spa_gcd_alloc)), lsize);
 
 		if (rounded != psize) {
 			abd_t *cdata = abd_alloc_linear(rounded, B_TRUE);