zap: TinyZAP for multi-uint64 entries.

MicroZAP is limited to 1×uint64 values and 49-char keys, any wider
entry forces a full FatZAP upgrade.  TinyZAP avoids this for the
common case of multi-integer values (e.g. Lustre FIDs) and long keys.

Introduce TinyZAP, a MicroZAP variant reuses mzap_phys_t, repurposing
the padding bytes after mz_normflags as three independent
uint8_t fields:

  mz_flags        bit 0 = MZAP_FLAG_TINY
  mz_chunk_shift  log2(chunk): 6=64B, 7=128B, 8=256B
  mz_value_ints   stride / 8  (number of uint64 values per entry)

Geometry is stamped automatically on the first zap_add() based on
observed entry shape. no create-time hint is required.  Subsequent
adds must match the stamped geometry or a FatZAP upgrade is triggered.

All ZAP operations (add, update, remove, lookup, cursor, byteswap,
upgrade to FatZAP) dispatch to TinyZAP paths when zap_stride != 0.

Signed-off-by: Akash B <akash-b@hpe.com>

Author: akashb-22

cmd/zdb/zdb.c

@@ -37,6 +37,7 @@
  * Copyright (c) 2023, 2024, Klara Inc.
  * Copyright (c) 2023, Rob Norris <robn@despairlabs.com>
  * Copyright (c) 2026, TrueNAS.
+ * Copyright (c) 2026, Hewlett Packard Enterprise Development LP.
  */
 
 #include <stdio.h>
@@ -1032,9 +1033,21 @@ dump_zap_stats(objset_t *os, uint64_t object)
 
 	if (zs.zs_ptrtbl_len == 0) {
 		ASSERT(zs.zs_num_blocks == 1);
-		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
-		    (u_longlong_t)zs.zs_blocksize,
-		    (u_longlong_t)zs.zs_num_entries);
+		if (zs.zs_is_tinyzap) {
+			/* TinyZAP */
+			(void) printf("\ttinyzap: %llu bytes, %llu entries, "
+			    "stride %llu chunk=%llu num_chunks=%llu\n",
+			    (u_longlong_t)zs.zs_blocksize,
+			    (u_longlong_t)zs.zs_num_entries,
+			    (u_longlong_t)zs.zs_tinyzap_stride,
+			    (u_longlong_t)zs.zs_tinyzap_chunk,
+			    (u_longlong_t)zs.zs_tinyzap_num_chunks);
+		} else {
+			/* Plain MicroZAP */
+			(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
+			    (u_longlong_t)zs.zs_blocksize,
+			    (u_longlong_t)zs.zs_num_entries);
+		}
 		return;
 	}
 

include/sys/zap.h

@@ -25,6 +25,7 @@
  * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
  * Copyright 2017 Nexenta Systems, Inc.
  * Copyright (c) 2026, TrueNAS.
+ * Copyright (c) 2026, Hewlett Packard Enterprise Development LP.
  */
 
 #ifndef	_SYS_ZAP_H
@@ -61,11 +62,24 @@
  *
  * Implementation / Performance Notes:
  *
- * The ZAP is intended to operate most efficiently on attributes with
- * short (49 bytes or less) names and single 8-byte values, for which
- * the microzap will be used.  The ZAP should be efficient enough so
+ * The ZAP operates in three modes, selected automatically:
+ *
+ * MicroZAP: most efficient for attributes with short names (up to 49
+ * characters, 50 bytes including NULL ('\0')) and a single 8-byte value.
+ * Fixed 64-byte chunk layout.  The ZAP should be efficient enough
  * that the user does not need to cache these attributes.
  *
+ * TinyZAP: used when an entry cannot fit MicroZAP, i.e. when either
+ * condition is true:
+ *    - num_integers > 1 (value too wide for MicroZAP), OR
+ *    - strlen(key) >= MZAP_NAME_LEN (name too long for MicroZAP)
+ * AND at least one chunk size (64/128/256 bytes) can accommodate the
+ * entry.  The chunk size and stride are stamped automatically on the
+ * first zap_add().  No create-time hint is required.
+ *
+ * FatZAP: used for all other cases, or when the ZAP grows beyond the
+ * capacity of a single block.  Supports arbitrary name/value sizes.
+ *
  * The ZAP's locking scheme makes its routines thread-safe.  Operations
  * on different zapobjs will be processed concurrently.  Operations on
  * the same zapobj which only read data will be processed concurrently.
@@ -181,7 +195,7 @@ int zap_create_claim_norm_dnsize(objset_t *os, uint64_t obj,
     dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx);
 
 /*
- * All operations on a zapobj take either the the objset/objectid pair
+ * All operations on a zapobj take either the objset/objectid pair
  * that "names" the object, or an existing dnode_t for the object. The
  * zapobj passed in must be a valid ZAP object.
  */
@@ -262,7 +276,7 @@ int zap_contains(objset_t *os, uint64_t zapobj, const char *name);
 
 /*
  * Prefetch the blocks within the ZAP where the given key is stored. The
- * prefetch IO will occure in the background.
+ * prefetch IO will occur in the background.
  */
 int zap_prefetch(objset_t *os, uint64_t zapobj, const char *name);
 
@@ -533,6 +547,20 @@ typedef struct zap_stats {
 	uint64_t zs_num_entries;	/* The number of zap entries */
 	uint64_t zs_salt;		/* salt to stir into hash function */
 
+	/*
+	 * TinyZAP statistics. Only meaningful when zs_is_tinyzap is B_TRUE.
+	 *
+	 * zs_is_tinyzap:	B_TRUE if MZAP_FLAG_TINYZAP is set.
+	 * zs_tinyzap_stride:	value width in bytes (8..255, mult of 8).
+	 * zs_tinyzap_chunk:	chunk size in bytes (1 << mz_chunk_shift).
+	 * zs_tinyzap_flags:	raw mz_flags uint8 (for zdb diagnostics).
+	 */
+	boolean_t zs_is_tinyzap;
+	uint64_t zs_tinyzap_stride;		/* value width: 8..255 bytes */
+	uint64_t zs_tinyzap_chunk;		/* chunk size: 64 / 128 / 256 */
+	uint64_t zs_tinyzap_num_chunks;		/* number of chunks used */
+	uint64_t zs_tinyzap_flags;		/* raw mz_flags for zdb */
+
 	/*
 	 * Histograms.  For all histograms, the last index
 	 * (ZAP_HISTOGRAM_SIZE-1) includes any values which are greater