Final byteswap handling

Signed-off-by: Paul Dagnelie <[email protected]>

Author: Paul Dagnelie

cmd/zdb/zdb.c

@@ -9590,7 +9590,7 @@ print_anyraid_mapping(vdev_t *vd, int child, int mapping,
 		uint32_t mo = off % SPA_MAXBLOCKSIZE;
 		anyraid_map_entry_t *entry =
 		    (anyraid_map_entry_t *)(map_buf + mo);
-		uint8_t type = entry->ame_u.ame_amle.amle_type;
+		uint8_t type = ame_get_type(entry);
 		uint8_t *buf;
 		boolean_t allocated = B_FALSE;
 		if (size > SPA_MAXBLOCKSIZE - mo) {
@@ -9628,8 +9628,8 @@ print_anyraid_mapping(vdev_t *vd, int child, int mapping,
 					(void) printf("loc %u:", cur_tile);
 					cur_tile++;
 				}
-				(void) printf("\td%u o%u,", amle->amle_disk,
-				    amle->amle_offset);
+				(void) printf("\td%u o%u,", amle_get_disk(amle),
+				    amle_get_offset(amle));
 				par_cnt = (par_cnt + 1) % (var->vd_nparity + 1);
 				if (par_cnt == 0)
 					(void) printf("\n");

include/sys/vdev_anyraid.h

@@ -157,51 +157,76 @@ typedef enum anyraid_map_entry_type {
 	AMET_TYPES
 } anyraid_map_entry_type_t;
 
+#define	AME_TYPE_BITS	8
+
 /*
  * ==========================================================================
  * Skip entry definitions and functions
  * ==========================================================================
  */
-typedef struct anyraid_map_skip_entry {
-	union {
-		uint8_t amse_type;
-		uint32_t amse_skip_count; // tile count to skip ahead
-	} amse_u;
-} anyraid_map_skip_entry_t;
+typedef uint32_t anyraid_map_skip_entry_t;
 
 #define	AMSE_TILE_BITS	24
 
 static inline void
 amse_set_type(anyraid_map_skip_entry_t *amse)
 {
-	amse->amse_u.amse_type = AMET_SKIP;
-	ASSERT3U(amse->amse_u.amse_type, ==,
-	    BF32_GET(amse->amse_u.amse_type, 0, 8));
+	BF32_SET(*amse, 0, AME_TYPE_BITS, AMET_SKIP);
 }
 
 static inline void
 amse_set_skip_count(anyraid_map_skip_entry_t *amse, uint32_t skip_count)
 {
-	BF32_SET(amse->amse_u.amse_skip_count, 8, AMSE_TILE_BITS, skip_count);
+	BF32_SET(*amse, AME_TYPE_BITS, AMSE_TILE_BITS, skip_count);
 }
 
 static inline uint32_t
 amse_get_skip_count(anyraid_map_skip_entry_t *amse)
 {
-	return (BF32_GET(amse->amse_u.amse_skip_count, 8, AMSE_TILE_BITS));
+	return (BF32_GET(*amse, AME_TYPE_BITS, AMSE_TILE_BITS));
 }
 
 /*
  * ==========================================================================
  * Location entry definitions and functions
  * ==========================================================================
  */
-typedef struct anyraid_map_loc_entry {
-	uint8_t amle_type;
-	uint8_t amle_disk;
-	uint16_t amle_offset;
-} anyraid_map_loc_entry_t;
-_Static_assert(sizeof (anyraid_map_loc_entry_t) == sizeof (uint32_t), "");
+typedef uint32_t anyraid_map_loc_entry_t;
+
+#define	AMLE_DISK_BITS		8
+#define	AMLE_OFFSET_BITS	16
+
+static inline void
+amle_set_type(anyraid_map_loc_entry_t *amle)
+{
+	BF32_SET(*amle, 0, AME_TYPE_BITS, AMET_LOC);
+}
+
+static inline void
+amle_set_disk(anyraid_map_loc_entry_t *amle, uint8_t disk)
+{
+	BF32_SET(*amle, AME_TYPE_BITS, AMLE_DISK_BITS, disk);
+}
+
+static inline uint32_t
+amle_get_disk(anyraid_map_loc_entry_t *amle)
+{
+	return (BF32_GET(*amle, AME_TYPE_BITS, AMLE_DISK_BITS));
+}
+
+static inline void
+amle_set_offset(anyraid_map_loc_entry_t *amle, uint8_t offset)
+{
+	BF32_SET(*amle, (AME_TYPE_BITS + AMLE_DISK_BITS), AMLE_OFFSET_BITS,
+	    offset);
+}
+
+static inline uint32_t
+amle_get_offset(anyraid_map_loc_entry_t *amle)
+{
+	return (BF32_GET(*amle, (AME_TYPE_BITS + AMLE_DISK_BITS),
+	    AMLE_OFFSET_BITS));
+}
 
 /*
  * ==========================================================================
@@ -216,28 +241,10 @@ typedef struct anyraid_map_entry {
 	} ame_u;
 } anyraid_map_entry_t;
 
-static inline void
-ame_byteswap(anyraid_map_entry_t *ame)
+static inline anyraid_map_entry_type_t
+ame_get_type(anyraid_map_entry_t *ame)
 {
-	uint8_t type = ame->ame_u.ame_amle.amle_type;
-	switch (type) {
-		case AMET_SKIP: {
-			anyraid_map_skip_entry_t *amse =
-			    &ame->ame_u.ame_amse;
-			amse->amse_u.amse_skip_count =
-			    BSWAP_32(amse_get_skip_count(amse)) >> NBBY;
-			amse->amse_u.amse_type = AMET_SKIP;
-			break;
-		}
-		case AMET_LOC: {
-			anyraid_map_loc_entry_t *amle =
-			    &ame->ame_u.ame_amle;
-			amle->amle_offset = BSWAP_16(amle->amle_offset);
-			break;
-		}
-		default:
-			PANIC("Invalid entry type %d", type);
-	}
+	return (BF32_GET(ame->ame_u.ame_amle, 0, AME_TYPE_BITS));
 }
 
 #define	VDEV_ANYRAID_MAX_DISKS	(1 << 8)

module/zfs/vdev_anyraid.c

@@ -238,8 +238,8 @@ static void
 create_tile_entry(vdev_anyraid_t *var, anyraid_map_loc_entry_t *amle,
     uint8_t *pat_cnt, anyraid_tile_t **out_ar, uint32_t *cur_tile)
 {
-	uint8_t disk = amle->amle_disk;
-	uint16_t offset = amle->amle_offset;
+	uint8_t disk = amle_get_disk(amle);
+	uint16_t offset = amle_get_offset(amle);
 	anyraid_tile_t *ar = *out_ar;
 
 	if (*pat_cnt == 0) {
@@ -459,16 +459,6 @@ vdev_anyraid_pick_best_mapping(vdev_t *cvd, uint64_t *out_txg,
 	return (error);
 }
 
-#ifdef _ZFS_BIG_ENDIAN
-static void
-byteswap_map_buf(void *buf, uint32_t length)
-{
-	for (size_t i = 0; i < length; i += sizeof (anyraid_map_entry_t)) {
-		ame_byteswap((anyraid_map_entry_t *)((char *)buf + i));
-	}
-}
-#endif
-
 static int
 anyraid_open_existing(vdev_t *vd, uint64_t child, uint16_t **child_capacities)
 {
@@ -606,13 +596,13 @@ anyraid_open_existing(vdev_t *vd, uint64_t child, uint16_t **child_capacities)
 #ifdef _ZFS_BIG_ENDIAN
 			uint32_t length = map_length -
 			    next_map * SPA_MAXBLOCKSIZE;
-			byteswap_map_buf(map_buf, (uint32_t)(length <
-			    SPA_MAXBLOCKSIZE ? length : SPA_MAXBLOCKSIZE));
+			byteswap_uint32_array(map_buf, MIN(length,
+			    SPA_MAXBLOCKSIZE));
 #endif
 		}
 		anyraid_map_entry_t *entry =
 		    (anyraid_map_entry_t *)(map_buf + (off % SPA_MAXBLOCKSIZE));
-		uint8_t type = entry->ame_u.ame_amle.amle_type;
+		uint8_t type = ame_get_type(entry);
 		switch (type) {
 			case AMET_SKIP: {
 				anyraid_map_skip_entry_t *amse =
@@ -1236,9 +1226,9 @@ static boolean_t
 map_write_loc_entry(anyraid_tile_node_t *arn, void *buf, uint32_t *offset)
 {
 	anyraid_map_loc_entry_t *entry = (void *)((char *)buf + *offset);
-	entry->amle_type = AMET_LOC;
-	entry->amle_disk = arn->atn_disk;
-	entry->amle_offset = arn->atn_offset;
+	amle_set_type(entry);
+	amle_set_disk(entry, arn->atn_disk);
+	amle_set_offset(entry, arn->atn_offset);
 	*offset += sizeof (*entry);
 	return (*offset == SPA_MAXBLOCKSIZE);
 }
@@ -1267,7 +1257,7 @@ map_write_issue(zio_t *zio, vdev_t *vd, uint64_t base_offset,
 {
 #ifdef _ZFS_BIG_ENDIAN
 	void *buf = abd_borrow_buf(abd, SPA_MAXBLOCKSIZE);
-	byteswap_map_buf(buf, length);
+	byteswap_uint32_array(buf, length);
 	abd_return_buf(abd, buf, SPA_MAXBLOCKSIZE);
 #else
 	(void) length;