mdbxmou 0.1.26

package/deps/libmdbx/src/unaligned.h

@@ -0,0 +1,205 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+/*------------------------------------------------------------------------------
+ * Unaligned access */
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED static inline size_t field_alignment(size_t alignment_baseline,
+                                                                                   size_t field_offset) {
+  size_t merge = alignment_baseline | (size_t)field_offset;
+  return merge & -(int)merge;
+}
+
+/* read-thunk for UB-sanitizer */
+MDBX_NOTHROW_PURE_FUNCTION static inline uint8_t peek_u8(const uint8_t *__restrict ptr) { return *ptr; }
+
+/* write-thunk for UB-sanitizer */
+static inline void poke_u8(uint8_t *__restrict ptr, const uint8_t v) { *ptr = v; }
+
+static inline void *bcopy_2(void *__restrict dst, const void *__restrict src) {
+  uint8_t *__restrict d = (uint8_t *)dst;
+  const uint8_t *__restrict s = (uint8_t *)src;
+  d[0] = s[0];
+  d[1] = s[1];
+  return d;
+}
+
+static inline void *bcopy_4(void *const __restrict dst, const void *const __restrict src) {
+  uint8_t *__restrict d = (uint8_t *)dst;
+  const uint8_t *__restrict s = (uint8_t *)src;
+  d[0] = s[0];
+  d[1] = s[1];
+  d[2] = s[2];
+  d[3] = s[3];
+  return d;
+}
+
+static inline void *bcopy_8(void *const __restrict dst, const void *const __restrict src) {
+  uint8_t *__restrict d = (uint8_t *)dst;
+  const uint8_t *__restrict s = (uint8_t *)src;
+  d[0] = s[0];
+  d[1] = s[1];
+  d[2] = s[2];
+  d[3] = s[3];
+  d[4] = s[4];
+  d[5] = s[5];
+  d[6] = s[6];
+  d[7] = s[7];
+  return d;
+}
+
+MDBX_NOTHROW_PURE_FUNCTION static inline uint16_t unaligned_peek_u16(const size_t expected_alignment,
+                                                                     const void *const ptr) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  if (MDBX_UNALIGNED_OK >= 2 || (expected_alignment % sizeof(uint16_t)) == 0)
+    return *(const uint16_t *)ptr;
+  else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    return *(const __unaligned uint16_t *)ptr;
+#else
+    uint16_t v;
+    bcopy_2((uint8_t *)&v, (const uint8_t *)ptr);
+    return v;
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+static inline void unaligned_poke_u16(const size_t expected_alignment, void *const __restrict ptr, const uint16_t v) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  if (MDBX_UNALIGNED_OK >= 2 || (expected_alignment % sizeof(v)) == 0)
+    *(uint16_t *)ptr = v;
+  else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    *((uint16_t __unaligned *)ptr) = v;
+#else
+    bcopy_2((uint8_t *)ptr, (const uint8_t *)&v);
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+MDBX_NOTHROW_PURE_FUNCTION static inline uint32_t unaligned_peek_u32(const size_t expected_alignment,
+                                                                     const void *const __restrict ptr) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  if (MDBX_UNALIGNED_OK >= 4 || (expected_alignment % sizeof(uint32_t)) == 0)
+    return *(const uint32_t *)ptr;
+  else if ((expected_alignment % sizeof(uint16_t)) == 0) {
+    const uint16_t lo = ((const uint16_t *)ptr)[__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__];
+    const uint16_t hi = ((const uint16_t *)ptr)[__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__];
+    return lo | (uint32_t)hi << 16;
+  } else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    return *(const __unaligned uint32_t *)ptr;
+#else
+    uint32_t v;
+    bcopy_4((uint8_t *)&v, (const uint8_t *)ptr);
+    return v;
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+static inline void unaligned_poke_u32(const size_t expected_alignment, void *const __restrict ptr, const uint32_t v) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  if (MDBX_UNALIGNED_OK >= 4 || (expected_alignment % sizeof(v)) == 0)
+    *(uint32_t *)ptr = v;
+  else if ((expected_alignment % sizeof(uint16_t)) == 0) {
+    ((uint16_t *)ptr)[__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__] = (uint16_t)v;
+    ((uint16_t *)ptr)[__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__] = (uint16_t)(v >> 16);
+  } else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    *((uint32_t __unaligned *)ptr) = v;
+#else
+    bcopy_4((uint8_t *)ptr, (const uint8_t *)&v);
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+MDBX_NOTHROW_PURE_FUNCTION static inline uint64_t unaligned_peek_u64(const size_t expected_alignment,
+                                                                     const void *const __restrict ptr) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  if (MDBX_UNALIGNED_OK >= 8 || (expected_alignment % sizeof(uint64_t)) == 0)
+    return *(const uint64_t *)ptr;
+  else if ((expected_alignment % sizeof(uint32_t)) == 0) {
+    const uint32_t lo = ((const uint32_t *)ptr)[__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__];
+    const uint32_t hi = ((const uint32_t *)ptr)[__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__];
+    return lo | (uint64_t)hi << 32;
+  } else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    return *(const __unaligned uint64_t *)ptr;
+#else
+    uint64_t v;
+    bcopy_8((uint8_t *)&v, (const uint8_t *)ptr);
+    return v;
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+static inline uint64_t unaligned_peek_u64_volatile(const size_t expected_alignment,
+                                                   const volatile void *const __restrict ptr) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  assert(expected_alignment % sizeof(uint32_t) == 0);
+  if (MDBX_UNALIGNED_OK >= 8 || (expected_alignment % sizeof(uint64_t)) == 0)
+    return *(const volatile uint64_t *)ptr;
+  else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    return *(const volatile __unaligned uint64_t *)ptr;
+#else
+    const uint32_t lo = ((const volatile uint32_t *)ptr)[__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__];
+    const uint32_t hi = ((const volatile uint32_t *)ptr)[__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__];
+    return lo | (uint64_t)hi << 32;
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+static inline void unaligned_poke_u64(const size_t expected_alignment, void *const __restrict ptr, const uint64_t v) {
+  assert((uintptr_t)ptr % expected_alignment == 0);
+  if (MDBX_UNALIGNED_OK >= 8 || (expected_alignment % sizeof(v)) == 0)
+    *(uint64_t *)ptr = v;
+  else if ((expected_alignment % sizeof(uint32_t)) == 0) {
+    ((uint32_t *)ptr)[__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__] = (uint32_t)v;
+    ((uint32_t *)ptr)[__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__] = (uint32_t)(v >> 32);
+  } else {
+#if defined(__unaligned) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_X64) || defined(_M_IA64)
+    *((uint64_t __unaligned *)ptr) = v;
+#else
+    bcopy_8((uint8_t *)ptr, (const uint8_t *)&v);
+#endif /* _MSC_VER || __unaligned */
+  }
+}
+
+#define UNALIGNED_PEEK_8(ptr, struct, field) peek_u8(ptr_disp(ptr, offsetof(struct, field)))
+#define UNALIGNED_POKE_8(ptr, struct, field, value) poke_u8(ptr_disp(ptr, offsetof(struct, field)), value)
+
+#define UNALIGNED_PEEK_16(ptr, struct, field) unaligned_peek_u16(1, ptr_disp(ptr, offsetof(struct, field)))
+#define UNALIGNED_POKE_16(ptr, struct, field, value)                                                                   \
+  unaligned_poke_u16(1, ptr_disp(ptr, offsetof(struct, field)), value)
+
+#define UNALIGNED_PEEK_32(ptr, struct, field) unaligned_peek_u32(1, ptr_disp(ptr, offsetof(struct, field)))
+#define UNALIGNED_POKE_32(ptr, struct, field, value)                                                                   \
+  unaligned_poke_u32(1, ptr_disp(ptr, offsetof(struct, field)), value)
+
+#define UNALIGNED_PEEK_64(ptr, struct, field) unaligned_peek_u64(1, ptr_disp(ptr, offsetof(struct, field)))
+#define UNALIGNED_POKE_64(ptr, struct, field, value)                                                                   \
+  unaligned_poke_u64(1, ptr_disp(ptr, offsetof(struct, field)), value)
+
+MDBX_NOTHROW_PURE_FUNCTION static inline pgno_t peek_pgno(const void *const __restrict ptr) {
+  if (sizeof(pgno_t) == sizeof(uint32_t))
+    return (pgno_t)unaligned_peek_u32(1, ptr);
+  else if (sizeof(pgno_t) == sizeof(uint64_t))
+    return (pgno_t)unaligned_peek_u64(1, ptr);
+  else {
+    pgno_t pgno;
+    memcpy(&pgno, ptr, sizeof(pgno));
+    return pgno;
+  }
+}
+
+static inline void poke_pgno(void *const __restrict ptr, const pgno_t pgno) {
+  if (sizeof(pgno) == sizeof(uint32_t))
+    unaligned_poke_u32(1, ptr, pgno);
+  else if (sizeof(pgno) == sizeof(uint64_t))
+    unaligned_poke_u64(1, ptr, pgno);
+  else
+    memcpy(ptr, &pgno, sizeof(pgno));
+}

package/deps/libmdbx/src/utils.c

@@ -0,0 +1,32 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#include "internals.h"
+
+MDBX_MAYBE_UNUSED MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL unsigned log2n_powerof2(size_t value_uintptr) {
+  assert(value_uintptr > 0 && value_uintptr < INT32_MAX && is_powerof2(value_uintptr));
+  assert((value_uintptr & -(intptr_t)value_uintptr) == value_uintptr);
+  const uint32_t value_uint32 = (uint32_t)value_uintptr;
+#if __GNUC_PREREQ(4, 1) || __has_builtin(__builtin_ctz)
+  STATIC_ASSERT(sizeof(value_uint32) <= sizeof(unsigned));
+  return __builtin_ctz(value_uint32);
+#elif defined(_MSC_VER)
+  unsigned long index;
+  STATIC_ASSERT(sizeof(value_uint32) <= sizeof(long));
+  _BitScanForward(&index, value_uint32);
+  return index;
+#else
+  static const uint8_t debruijn_ctz32[32] = {0,  1,  28, 2,  29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4,  8,
+                                             31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6,  11, 5,  10, 9};
+  return debruijn_ctz32[(uint32_t)(value_uint32 * 0x077CB531ul) >> 27];
+#endif
+}
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL uint64_t rrxmrrxmsx_0(uint64_t v) {
+  /* Pelle Evensen's mixer, https://bit.ly/2HOfynt */
+  v ^= (v << 39 | v >> 25) ^ (v << 14 | v >> 50);
+  v *= UINT64_C(0xA24BAED4963EE407);
+  v ^= (v << 40 | v >> 24) ^ (v << 15 | v >> 49);
+  v *= UINT64_C(0x9FB21C651E98DF25);
+  return v ^ v >> 28;
+}

package/deps/libmdbx/src/utils.h

@@ -0,0 +1,76 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+/* Test if the flags f are set in a flag word w. */
+#define F_ISSET(w, f) (((w) & (f)) == (f))
+
+/* Round n up to an even number. */
+#define EVEN_CEIL(n) (((n) + 1UL) & -2L) /* sign-extending -2 to match n+1U */
+
+/* Round n down to an even number. */
+#define EVEN_FLOOR(n) ((n) & ~(size_t)1)
+
+/*
+ *                /
+ *                | -1, a < b
+ * CMP2INT(a,b) = <  0, a == b
+ *                |  1, a > b
+ *                \
+ */
+#define CMP2INT(a, b) (((a) != (b)) ? (((a) < (b)) ? -1 : 1) : 0)
+
+/* Pointer displacement without casting to char* to avoid pointer-aliasing */
+#define ptr_disp(ptr, disp) ((void *)(((intptr_t)(ptr)) + ((intptr_t)(disp))))
+
+/* Pointer distance as signed number of bytes */
+#define ptr_dist(more, less) (((intptr_t)(more)) - ((intptr_t)(less)))
+
+#define MDBX_ASAN_POISON_MEMORY_REGION(addr, size)                                                                     \
+  do {                                                                                                                 \
+    TRACE("POISON_MEMORY_REGION(%p, %zu) at %u", (void *)(addr), (size_t)(size), __LINE__);                            \
+    ASAN_POISON_MEMORY_REGION(addr, size);                                                                             \
+  } while (0)
+
+#define MDBX_ASAN_UNPOISON_MEMORY_REGION(addr, size)                                                                   \
+  do {                                                                                                                 \
+    TRACE("UNPOISON_MEMORY_REGION(%p, %zu) at %u", (void *)(addr), (size_t)(size), __LINE__);                          \
+    ASAN_UNPOISON_MEMORY_REGION(addr, size);                                                                           \
+  } while (0)
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED static inline size_t branchless_abs(intptr_t value) {
+  assert(value > INT_MIN);
+  const size_t expanded_sign = (size_t)(value >> (sizeof(value) * CHAR_BIT - 1));
+  return ((size_t)value + expanded_sign) ^ expanded_sign;
+}
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED static inline bool is_powerof2(size_t x) { return (x & (x - 1)) == 0; }
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED static inline size_t floor_powerof2(size_t value, size_t granularity) {
+  assert(is_powerof2(granularity));
+  return value & ~(granularity - 1);
+}
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED static inline size_t ceil_powerof2(size_t value, size_t granularity) {
+  return floor_powerof2(value + granularity - 1, granularity);
+}
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_MAYBE_UNUSED MDBX_INTERNAL unsigned log2n_powerof2(size_t value_uintptr);
+
+MDBX_NOTHROW_CONST_FUNCTION MDBX_INTERNAL uint64_t rrxmrrxmsx_0(uint64_t v);
+
+struct monotime_cache {
+  uint64_t value;
+  int expire_countdown;
+};
+
+MDBX_MAYBE_UNUSED static inline uint64_t monotime_since_cached(uint64_t begin_timestamp, struct monotime_cache *cache) {
+  if (cache->expire_countdown)
+    cache->expire_countdown -= 1;
+  else {
+    cache->value = osal_monotime();
+    cache->expire_countdown = 42 / 3;
+  }
+  return cache->value - begin_timestamp;
+}

package/deps/libmdbx/src/version.c.in

@@ -0,0 +1,44 @@
+/* This is CMake-template for libmdbx's version.c
+ ******************************************************************************/
+
+#include "internals.h"
+
+#if MDBX_VERSION_MAJOR != ${MDBX_VERSION_MAJOR} || MDBX_VERSION_MINOR != ${MDBX_VERSION_MINOR}
+#error "API version mismatch! Had `git fetch --tags` done?"
+#endif
+
+static const char sourcery[] = MDBX_STRINGIFY(MDBX_BUILD_SOURCERY);
+
+__dll_export
+#ifdef __attribute_used__
+    __attribute_used__
+#elif defined(__GNUC__) || __has_attribute(__used__)
+    __attribute__((__used__))
+#endif
+#ifdef __attribute_externally_visible__
+        __attribute_externally_visible__
+#elif (defined(__GNUC__) && !defined(__clang__)) || __has_attribute(__externally_visible__)
+    __attribute__((__externally_visible__))
+#endif
+    const struct MDBX_version_info mdbx_version = {
+        ${MDBX_VERSION_MAJOR},
+        ${MDBX_VERSION_MINOR},
+        ${MDBX_VERSION_PATCH},
+        ${MDBX_VERSION_TWEAK},
+        "@MDBX_VERSION_PRERELEASE@", /* pre-release suffix of SemVer
+                                        @MDBX_VERSION_PURE@ */
+        {"@MDBX_GIT_TIMESTAMP@", "@MDBX_GIT_TREE@", "@MDBX_GIT_COMMIT@", "@MDBX_GIT_DESCRIBE@"},
+        sourcery};
+
+__dll_export
+#ifdef __attribute_used__
+    __attribute_used__
+#elif defined(__GNUC__) || __has_attribute(__used__)
+    __attribute__((__used__))
+#endif
+#ifdef __attribute_externally_visible__
+        __attribute_externally_visible__
+#elif (defined(__GNUC__) && !defined(__clang__)) || __has_attribute(__externally_visible__)
+    __attribute__((__externally_visible__))
+#endif
+    const char *const mdbx_sourcery_anchor = sourcery;

package/deps/libmdbx/src/walk.c

@@ -0,0 +1,290 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#include "internals.h"
+
+typedef struct walk_ctx {
+  void *userctx;
+  walk_options_t options;
+  int deep;
+  walk_func *visitor;
+  MDBX_txn *txn;
+  MDBX_cursor *cursor;
+} walk_ctx_t;
+
+__cold static int walk_tbl(walk_ctx_t *ctx, walk_tbl_t *tbl);
+
+static page_type_t walk_page_type(const page_t *mp) {
+  if (mp)
+    switch (mp->flags & ~P_SPILLED) {
+    case P_BRANCH:
+      return page_branch;
+    case P_LEAF:
+      return page_leaf;
+    case P_LEAF | P_DUPFIX:
+      return page_dupfix_leaf;
+    case P_LARGE:
+      return page_large;
+    }
+  return page_broken;
+}
+
+static page_type_t walk_subpage_type(const page_t *sp) {
+  switch (sp->flags & /* ignore legacy P_DIRTY flag */ ~P_LEGACY_DIRTY) {
+  case P_LEAF | P_SUBP:
+    return page_sub_leaf;
+  case P_LEAF | P_DUPFIX | P_SUBP:
+    return page_sub_dupfix_leaf;
+  default:
+    return page_sub_broken;
+  }
+}
+
+/* Depth-first tree traversal. */
+__cold static int walk_pgno(walk_ctx_t *ctx, walk_tbl_t *tbl, const pgno_t pgno, txnid_t parent_txnid) {
+  assert(pgno != P_INVALID);
+  page_t *mp = nullptr;
+  int err = page_get(ctx->cursor, pgno, &mp, parent_txnid);
+
+  const page_type_t type = walk_page_type(mp);
+  const size_t nentries = mp ? page_numkeys(mp) : 0;
+  size_t header_size = (mp && !is_dupfix_leaf(mp)) ? PAGEHDRSZ + mp->lower : PAGEHDRSZ;
+  size_t payload_size = 0;
+  size_t unused_size = (mp ? page_room(mp) : ctx->txn->env->ps - header_size) - payload_size;
+  size_t align_bytes = 0;
+
+  for (size_t i = 0; err == MDBX_SUCCESS && i < nentries; ++i) {
+    if (type == page_dupfix_leaf) {
+      /* DUPFIX pages have no entries[] or node headers */
+      payload_size += mp->dupfix_ksize;
+      continue;
+    }
+
+    const node_t *node = page_node(mp, i);
+    header_size += NODESIZE;
+    const size_t node_key_size = node_ks(node);
+    payload_size += node_key_size;
+
+    if (type == page_branch) {
+      assert(i > 0 || node_ks(node) == 0);
+      align_bytes += node_key_size & 1;
+      continue;
+    }
+
+    const size_t node_data_size = node_ds(node);
+    assert(type == page_leaf);
+    switch (node_flags(node)) {
+    case 0 /* usual node */:
+      payload_size += node_data_size;
+      align_bytes += (node_key_size + node_data_size) & 1;
+      break;
+
+    case N_BIG /* long data on the large/overflow page */: {
+      const pgno_t large_pgno = node_largedata_pgno(node);
+      const size_t over_payload = node_data_size;
+      const size_t over_header = PAGEHDRSZ;
+
+      assert(err == MDBX_SUCCESS);
+      pgr_t lp = page_get_large(ctx->cursor, large_pgno, mp->txnid);
+      const size_t npages = ((err = lp.err) == MDBX_SUCCESS) ? lp.page->pages : 1;
+      const size_t pagesize = pgno2bytes(ctx->txn->env, npages);
+      const size_t over_unused = pagesize - over_payload - over_header;
+      const int rc = ctx->visitor(large_pgno, npages, ctx->userctx, ctx->deep, tbl, pagesize, page_large, err, 1,
+                                  over_payload, over_header, over_unused);
+      if (unlikely(rc != MDBX_SUCCESS))
+        return (rc == MDBX_RESULT_TRUE) ? MDBX_SUCCESS : rc;
+      payload_size += sizeof(pgno_t);
+      align_bytes += node_key_size & 1;
+    } break;
+
+    case N_TREE /* sub-db */: {
+      if (unlikely(node_data_size != sizeof(tree_t))) {
+        ERROR("%s/%d: %s %u", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid table node size", (unsigned)node_data_size);
+        assert(err == MDBX_CORRUPTED);
+        err = MDBX_CORRUPTED;
+      }
+      header_size += node_data_size;
+      align_bytes += (node_key_size + node_data_size) & 1;
+    } break;
+
+    case N_TREE | N_DUP /* dupsorted sub-tree */:
+      if (unlikely(node_data_size != sizeof(tree_t))) {
+        ERROR("%s/%d: %s %u", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid sub-tree node size", (unsigned)node_data_size);
+        assert(err == MDBX_CORRUPTED);
+        err = MDBX_CORRUPTED;
+      }
+      header_size += node_data_size;
+      align_bytes += (node_key_size + node_data_size) & 1;
+      break;
+
+    case N_DUP /* short sub-page */: {
+      if (unlikely(node_data_size <= PAGEHDRSZ || (node_data_size & 1))) {
+        ERROR("%s/%d: %s %u", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid sub-page node size", (unsigned)node_data_size);
+        assert(err == MDBX_CORRUPTED);
+        err = MDBX_CORRUPTED;
+        break;
+      }
+
+      const page_t *const sp = node_data(node);
+      const page_type_t subtype = walk_subpage_type(sp);
+      const size_t nsubkeys = page_numkeys(sp);
+      if (unlikely(subtype == page_sub_broken)) {
+        ERROR("%s/%d: %s 0x%x", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid sub-page flags", sp->flags);
+        assert(err == MDBX_CORRUPTED);
+        err = MDBX_CORRUPTED;
+      }
+
+      size_t subheader_size = is_dupfix_leaf(sp) ? PAGEHDRSZ : PAGEHDRSZ + sp->lower;
+      size_t subunused_size = page_room(sp);
+      size_t subpayload_size = 0;
+      size_t subalign_bytes = 0;
+
+      for (size_t ii = 0; err == MDBX_SUCCESS && ii < nsubkeys; ++ii) {
+        if (subtype == page_sub_dupfix_leaf) {
+          /* DUPFIX pages have no entries[] or node headers */
+          subpayload_size += sp->dupfix_ksize;
+        } else {
+          assert(subtype == page_sub_leaf);
+          const node_t *subnode = page_node(sp, ii);
+          const size_t subnode_size = node_ks(subnode) + node_ds(subnode);
+          subheader_size += NODESIZE;
+          subpayload_size += subnode_size;
+          subalign_bytes += subnode_size & 1;
+          if (unlikely(node_flags(subnode) != 0)) {
+            ERROR("%s/%d: %s 0x%x", "MDBX_CORRUPTED", MDBX_CORRUPTED, "unexpected sub-node flags", node_flags(subnode));
+            assert(err == MDBX_CORRUPTED);
+            err = MDBX_CORRUPTED;
+          }
+        }
+      }
+
+      const int rc = ctx->visitor(pgno, 0, ctx->userctx, ctx->deep + 1, tbl, node_data_size, subtype, err, nsubkeys,
+                                  subpayload_size, subheader_size, subunused_size + subalign_bytes);
+      if (unlikely(rc != MDBX_SUCCESS))
+        return (rc == MDBX_RESULT_TRUE) ? MDBX_SUCCESS : rc;
+      header_size += subheader_size;
+      unused_size += subunused_size;
+      payload_size += subpayload_size;
+      align_bytes += subalign_bytes + (node_key_size & 1);
+    } break;
+
+    default:
+      ERROR("%s/%d: %s 0x%x", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid node flags", node_flags(node));
+      assert(err == MDBX_CORRUPTED);
+      err = MDBX_CORRUPTED;
+    }
+  }
+
+  const int rc = ctx->visitor(pgno, 1, ctx->userctx, ctx->deep, tbl, ctx->txn->env->ps, type, err, nentries,
+                              payload_size, header_size, unused_size + align_bytes);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return (rc == MDBX_RESULT_TRUE) ? MDBX_SUCCESS : rc;
+
+  for (size_t i = 0; err == MDBX_SUCCESS && i < nentries; ++i) {
+    if (type == page_dupfix_leaf)
+      continue;
+
+    node_t *node = page_node(mp, i);
+    if (type == page_branch) {
+      assert(err == MDBX_SUCCESS);
+      ctx->deep += 1;
+      err = walk_pgno(ctx, tbl, node_pgno(node), mp->txnid);
+      ctx->deep -= 1;
+      if (unlikely(err != MDBX_SUCCESS)) {
+        if (err == MDBX_RESULT_TRUE)
+          break;
+        return err;
+      }
+      continue;
+    }
+
+    assert(type == page_leaf);
+    switch (node_flags(node)) {
+    default:
+      continue;
+
+    case N_TREE /* sub-db */:
+      if (unlikely(node_ds(node) != sizeof(tree_t))) {
+        ERROR("%s/%d: %s %u", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid sub-tree node size", (unsigned)node_ds(node));
+        assert(err == MDBX_CORRUPTED);
+        err = MDBX_CORRUPTED;
+      } else {
+        tree_t aligned_db;
+        memcpy(&aligned_db, node_data(node), sizeof(aligned_db));
+        walk_tbl_t table = {{node_key(node), node_ks(node)}, nullptr, nullptr};
+        table.internal = &aligned_db;
+        assert(err == MDBX_SUCCESS);
+        ctx->deep += 1;
+        err = walk_tbl(ctx, &table);
+        ctx->deep -= 1;
+      }
+      break;
+
+    case N_TREE | N_DUP /* dupsorted sub-tree */:
+      if (unlikely(node_ds(node) != sizeof(tree_t))) {
+        ERROR("%s/%d: %s %u", "MDBX_CORRUPTED", MDBX_CORRUPTED, "invalid dupsort sub-tree node size",
+              (unsigned)node_ds(node));
+        assert(err == MDBX_CORRUPTED);
+        err = MDBX_CORRUPTED;
+      } else {
+        tree_t aligned_db;
+        memcpy(&aligned_db, node_data(node), sizeof(aligned_db));
+        assert(err == MDBX_SUCCESS);
+        err = cursor_dupsort_setup(ctx->cursor, node, mp);
+        if (likely(err == MDBX_SUCCESS)) {
+          assert(ctx->cursor->subcur == &container_of(ctx->cursor, cursor_couple_t, outer)->inner);
+          ctx->cursor = &ctx->cursor->subcur->cursor;
+          ctx->deep += 1;
+          tbl->nested = &aligned_db;
+          err = walk_pgno(ctx, tbl, aligned_db.root, mp->txnid);
+          tbl->nested = nullptr;
+          ctx->deep -= 1;
+          subcur_t *inner_xcursor = container_of(ctx->cursor, subcur_t, cursor);
+          cursor_couple_t *couple = container_of(inner_xcursor, cursor_couple_t, inner);
+          ctx->cursor = &couple->outer;
+        }
+      }
+      break;
+    }
+  }
+
+  return MDBX_SUCCESS;
+}
+
+__cold static int walk_tbl(walk_ctx_t *ctx, walk_tbl_t *tbl) {
+  tree_t *const db = tbl->internal;
+  if (unlikely(db->root == P_INVALID))
+    return MDBX_SUCCESS; /* empty db */
+
+  kvx_t kvx = {.clc = {.k = {.lmin = INT_MAX}, .v = {.lmin = INT_MAX}}};
+  cursor_couple_t couple;
+  int rc = cursor_init4walk(&couple, ctx->txn, db, &kvx);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  const uint8_t cursor_checking = (ctx->options & dont_check_keys_ordering) ? z_pagecheck | z_ignord : z_pagecheck;
+  couple.outer.checking |= cursor_checking;
+  couple.inner.cursor.checking |= cursor_checking;
+  couple.outer.next = ctx->cursor;
+  couple.outer.top_and_flags = z_disable_tree_search_fastpath;
+  ctx->cursor = &couple.outer;
+  rc = walk_pgno(ctx, tbl, db->root, db->mod_txnid ? db->mod_txnid : ctx->txn->txnid);
+  ctx->cursor = couple.outer.next;
+  return rc;
+}
+
+__cold int walk_pages(MDBX_txn *txn, walk_func *visitor, void *user, walk_options_t options) {
+  int rc = check_txn(txn, MDBX_TXN_BLOCKED);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  walk_ctx_t ctx = {.txn = txn, .userctx = user, .visitor = visitor, .options = options};
+  walk_tbl_t tbl = {.name = {.iov_base = MDBX_CHK_GC}, .internal = &txn->dbs[FREE_DBI]};
+  rc = walk_tbl(&ctx, &tbl);
+  if (!MDBX_IS_ERROR(rc)) {
+    tbl.name.iov_base = MDBX_CHK_MAIN;
+    tbl.internal = &txn->dbs[MAIN_DBI];
+    rc = walk_tbl(&ctx, &tbl);
+  }
+  return rc;
+}

package/deps/libmdbx/src/walk.h

@@ -0,0 +1,20 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+#include "essentials.h"
+
+typedef struct walk_tbl {
+  MDBX_val name;
+  tree_t *internal, *nested;
+} walk_tbl_t;
+
+typedef int walk_func(const size_t pgno, const unsigned number, void *const ctx, const int deep,
+                      const walk_tbl_t *table, const size_t page_size, const page_type_t page_type,
+                      const MDBX_error_t err, const size_t nentries, const size_t payload_bytes,
+                      const size_t header_bytes, const size_t unused_bytes);
+
+typedef enum walk_options { dont_check_keys_ordering = 1 } walk_options_t;
+
+MDBX_INTERNAL int walk_pages(MDBX_txn *txn, walk_func *visitor, void *user, walk_options_t options);