Import wiredtiger: 9100f9e52aeb9873984497fc41b445ff40f3832e from branch mongodb-master (#44842)

Co-authored-by: wt-vendoring-bot <wt-vendoring-bot@mongodb.com>
GitOrigin-RevId: 92fe18033e1ed185437770a2f270af119e026d4c

src/third_party/wiredtiger/dist/api_data.py

@@ -2177,6 +2177,8 @@ methods = {
 ),
 'WT_CONNECTION.set_file_system' : Method([]),
 
+'WT_CONNECTION.set_key_provider' : Method([]),
+
 'WT_CONNECTION.load_extension' : Method([
     Config('config', '', r'''
         configuration string passed to the entry point of the extension as its WT_CONFIG_ARG

src/third_party/wiredtiger/dist/s_define.list

@@ -119,6 +119,7 @@ WT_STAT_SET_BASE
 WT_STAT_WRITE
 WT_STATP_DSRC_DECR
 WT_STATP_DSRC_DECRV
+WT_ATOMIC_STATS_MFUNC
 WT_TIMEDIFF_US
 WT_TRACK_OP
 WT_TRACK_OP_END

src/third_party/wiredtiger/dist/s_string

@@ -77,7 +77,7 @@ while :
         # that building a replacement list of words with the newer version of aspell will omit them
         # from our custom words file, and subsequently running s_string with older aspell version will
         # report spelling errors. Manually whitelist these names to address this.
-        whitelist_words="AWS AWS's MongoDB MONGODB PostgreSQL Reify sanitizer sanitizers"
+        whitelist_words="AWS AWS's MongoDB MONGODB PostgreSQL Reify sanitizer sanitizers dylib"
         for name in $whitelist_words; do
             echo $name >> $t
         done

src/third_party/wiredtiger/dist/s_string.ok

@@ -147,7 +147,6 @@ FNV
 FOREACH
 FS
 FULLFSYNC
-FUNC
 FUNCSIG
 Failpoint
 FindClose
@@ -212,7 +211,6 @@ Keyedness
 Kounavis
 LANGID
 LF
-LLVM
 LLVMFuzzerTestOneInput
 LMDB
 LOGOP
@@ -255,7 +253,6 @@ MSan
 MUTEX
 MacOS
 MapViewOfFile
-Marsaglia
 Marsaglia's
 Mellor
 Mitzenmacher
@@ -297,7 +294,6 @@ PALI
 PDEATHSIG
 PFX
 PID
-PINDEX
 POS
 POSIX
 PPC
@@ -305,7 +301,6 @@ PREFETCH
 PREV
 PRId
 PRIu
-PRIx
 PRNG
 PSD
 PSE
@@ -344,7 +339,6 @@ RETRYABLE
 RHEL
 RLE
 RLEs
-RMW
 RNG
 RNGs
 RPC
@@ -482,7 +476,6 @@ WiredTigerShared
 WiredTigerSharedHS
 WiredTigerTmplog
 WithSeeds
-Wl
 Wmissing
 WriteFile
 Wundef
@@ -490,7 +483,6 @@ Wuninitialized
 Wunused
 XP
 XXXXXX
-Xorshift
 YCSB
 ZSTD
 Zlib
@@ -566,7 +558,6 @@ bool
 boolean
 booleans
 boption
-bpack
 br
 breakpoint
 bs
@@ -961,6 +952,7 @@ keyid
 keyids
 keylen
 keyv
+kp
 kv
 kvraw
 kvs
@@ -992,9 +984,7 @@ linux
 llll
 llu
 llvm
-loadbool
 loadtext
-loadvbool
 loc
 localTime
 localkey
@@ -1036,7 +1026,6 @@ maxv
 mb
 mbll
 mbss
-md
 mem
 membar
 memcmp
@@ -1061,7 +1050,6 @@ mn
 mnt
 mongod
 mrs
-msan
 msecs
 msg
 msvc
@@ -1171,6 +1159,7 @@ pid
 pindexp
 plh
 plhandle
+pluggable
 pmem
 poptable
 popthreads
@@ -1332,8 +1321,6 @@ stepp
 stlr
 stlrb
 stlrh
-storebool
-storevbool
 str
 strace
 strcat
@@ -1482,7 +1469,6 @@ vPodir
 vW
 va
 validator
-vals
 valuep
 valuev
 vanishingly

src/third_party/wiredtiger/dist/stat_data.py

@@ -372,6 +372,7 @@ conn_stats = [
     EvictStat('eviction_internal_pages_queued', 'internal pages queued for eviction'),
     EvictStat('eviction_internal_pages_seen', 'internal pages seen by eviction walk'),
     EvictStat('eviction_interupted_by_app', 'application requested eviction interrupt'),
+    EvictStat('eviction_maximum_attempts_to_evict_page', 'maximum number of times a page tried to be evicted', 'no_clear,no_scale,size'),
     EvictStat('eviction_maximum_attempts_to_queue_page', 'maximum number of times a page tried to be added to eviction queue but fail', 'no_clear,no_scale,size'),
     EvictStat('eviction_maximum_clean_page_size_per_checkpoint', 'maximum clean page size seen at eviction per checkpoint', 'no_clear,no_scale,size'),
     EvictStat('eviction_maximum_dirty_page_size_per_checkpoint', 'maximum dirty page size seen at eviction per checkpoint', 'no_clear,no_scale,size'),

src/third_party/wiredtiger/examples/c/ex_key_provider.c

@@ -0,0 +1,192 @@
+/*-
+ * Public Domain 2014-present MongoDB, Inc.
+ * Public Domain 2008-2014 WiredTiger, Inc.
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ex_key_provider.c
+ * 	demonstrates how to use the key provider API.
+ */
+#include <test_util.h>
+
+/*
+ * Extension initialization function.
+ */
+#ifdef _WIN32
+/*
+ * Explicitly export this function so it is visible when loading extensions.
+ */
+__declspec(dllexport)
+#endif
+  int set_my_key_provider(WT_CONNECTION *, WT_CONFIG_ARG *);
+
+typedef struct {
+    int id;
+    int data;
+} MY_CRYPT_DATA;
+
+/*! [key provider struct implementation] */
+typedef struct {
+    WT_KEY_PROVIDER kp; /* Must come first */
+
+    /* This example stores a fixed size blob in the key provider struct. It is not required. */
+    MY_CRYPT_DATA *encryption_data;
+    uint64_t returned_lsn;
+} MY_KEY_PROVIDER;
+
+/*
+ * my_load_key --
+ *     A simple example of set_key call.
+ */
+static int
+my_load_key(WT_KEY_PROVIDER *kp, const WT_CRYPT_KEYS *key)
+{
+    MY_KEY_PROVIDER *my_kp = (MY_KEY_PROVIDER *)kp;
+
+    /* Update the returned LSN and copy the encryption key data. */
+    MY_CRYPT_DATA *encryption_data;
+    if ((encryption_data = calloc(1, sizeof(MY_CRYPT_DATA))) == NULL)
+        return (ENOMEM);
+
+    /* Free old encryption data. */
+    free(my_kp->encryption_data);
+
+    /* Assign new encryption data. */
+    memcpy((uint8_t *)encryption_data, key->data, key->size);
+    my_kp->encryption_data = encryption_data;
+    return (0);
+}
+
+/*
+ * my_get_key --
+ *     An simple example of key rotation done on get_key call.
+ */
+static int
+my_get_key(WT_KEY_PROVIDER *kp, WT_CRYPT_KEYS *key)
+{
+    MY_KEY_PROVIDER *my_kp = (MY_KEY_PROVIDER *)kp;
+
+    if ((key = calloc(1, sizeof(WT_CRYPT_KEYS) + sizeof(MY_CRYPT_DATA))) == NULL)
+        return (ENOMEM);
+
+    /* Populate the data field in the WT_CRYPT_KEYS structure. */
+    MY_CRYPT_DATA *crypt_data = (MY_CRYPT_DATA *)key->data;
+
+    /* Set fields in the MY_CRYPT_DATA structure. */
+    crypt_data->data = my_kp->encryption_data->data;
+    crypt_data->id = my_kp->encryption_data->id;
+
+    /* Set the WT_CRYPT_KEYS size field to match the allocation. */
+    key->size = sizeof(MY_CRYPT_DATA);
+    return (0);
+}
+
+/*
+ * my_on_key_update --
+ *     A simple example of on_key_update call.
+ */
+static int
+my_on_key_update(WT_KEY_PROVIDER *kp, WT_CRYPT_KEYS *key)
+{
+    MY_KEY_PROVIDER *my_kp = (MY_KEY_PROVIDER *)kp;
+
+    /* Check size field to determine that the key was successfully persisted. */
+    if (key->size != 0) {
+        my_kp->returned_lsn = key->r.lsn;
+
+        /* On success, free the allocated key. */
+        free(key);
+    } else
+        return (key->r.error);
+    return (0);
+}
+
+/*
+ * set_my_key_provider --
+ *     A simple example of setting the key provider system.
+ */
+int
+set_my_key_provider(WT_CONNECTION *conn, WT_CONFIG_ARG *config)
+{
+    MY_KEY_PROVIDER *kps;
+    WT_KEY_PROVIDER *wt;
+    WT_EXTENSION_API *wtext;
+
+    WT_UNUSED(config);
+    wtext = conn->get_extension_api(conn);
+    /* Initialize our key provider system. */
+    if ((kps = calloc(1, sizeof(MY_KEY_PROVIDER))) == NULL) {
+        (void)wtext->err_printf(
+          wtext, NULL, "set_my_key_provider: %s", wtext->strerror(wtext, NULL, ENOMEM));
+        return (ENOMEM);
+    }
+    wt = (WT_KEY_PROVIDER *)&kps->kp;
+    wt->load_key = my_load_key;
+    wt->get_key = my_get_key;
+    wt->on_key_update = my_on_key_update;
+
+    error_check(conn->set_key_provider(conn, (WT_KEY_PROVIDER *)kps, NULL));
+    return (0);
+}
+
+static const char *home;
+
+int
+main(int argc, char *argv[])
+{
+    WT_CONNECTION *conn;
+    const char *open_config;
+    int ret = 0;
+
+    WT_UNUSED(argc);
+    WT_UNUSED(argv);
+
+    /*
+     * Create a clean test directory for this run of the test program if the environment variable
+     * isn't already set (as is done by make check).
+     */
+    if (getenv("WIREDTIGER_HOME") == NULL) {
+        home = "WT_HOME";
+        ret = system("rm -rf WT_HOME && mkdir WT_HOME");
+    } else
+        home = NULL;
+
+    /*! [WT_KEY_PROVIDER register] */
+    /*
+     * Setup a configuration string that will load our key provider system. Use the special local
+     * extension to indicate that the entry point is in the same executable. Also enable early load
+     * for this extension, since WiredTiger needs to be able to find it before doing any operations.
+     */
+    open_config =
+      "create,log=(enabled=true),extensions=(local={entry=set_my_key_provider,early_load=true})";
+    /* Open a connection to the database, creating it if necessary. */
+    if ((ret = wiredtiger_open(home, NULL, open_config, &conn)) != 0) {
+        fprintf(stderr, "Error connecting to %s: %s\n", home == NULL ? "." : home,
+          wiredtiger_strerror(ret));
+        return (EXIT_FAILURE);
+    }
+    /*! [WT_KEY_PROVIDER register] */
+
+    return (EXIT_SUCCESS);
+}

src/third_party/wiredtiger/ext/page_log/palite/palite.cpp

@@ -767,6 +767,9 @@ class Connection {
 
     /* Common configuration parameters for connections */
     constexpr static std::string_view config_statements[] = {
+
+      /* Set busy timeout to 10 seconds. */
+      "PRAGMA busy_timeout = 10000;"
       /*
        * The WAL journaling mode uses a write-ahead log instead of a rollback journal to implement
        * transactions. This significantly improves performance.
@@ -780,10 +783,7 @@ class Connection {
       "PRAGMA synchronous = OFF;",
 
       /* For temporary store use memory instead of disk. */
-      "PRAGMA temp_store = MEMORY;",
+      "PRAGMA temp_store = MEMORY;"};
-
-      /* Set busy timeout to 10 seconds. */
-      "PRAGMA busy_timeout = 10000;"};
 
 public:
     using StatementPtr = std::unique_ptr<sqlite3_stmt, std::function<decltype(sqlite3_reset)>>;

src/third_party/wiredtiger/import.data

@@ -2,5 +2,5 @@
     "vendor": "wiredtiger",
     "github": "wiredtiger/wiredtiger",
     "branch": "mongodb-master",
-    "commit": "72f62877d77553a9bcf32c43342065cdcc936af5"
+    "commit": "9100f9e52aeb9873984497fc41b445ff40f3832e"
 }

src/third_party/wiredtiger/lang/python/wiredtiger.i

@@ -1480,6 +1480,7 @@ int standalone_build();
 %ignore __wt_connection::add_data_source;
 %ignore __wt_connection::add_encryptor;
 %ignore __wt_connection::get_extension_api;
+%ignore __wt_connection::set_key_provider;
 %ignore __wt_session::log_printf;
 
 OVERRIDE_METHOD(__wt_session, WT_SESSION, log_printf, (self, msg))

src/third_party/wiredtiger/src/block_disagg/block_disagg_ckpt.c

@@ -105,11 +105,11 @@ __wti_block_disagg_checkpoint(WT_BM *bm, WT_SESSION_IMPL *session, WT_ITEM *root
 }
 
 /*
- * __wti_block_disagg_checkpoint_resolve --
+ * __block_disagg_checkpoint_resolve --
- *     Resolve the checkpoint.
+ *     Resolve the checkpoint. Assumes that the relevant locks are already acquired.
  */
-int
+static int
-__wti_block_disagg_checkpoint_resolve(WT_BM *bm, WT_SESSION_IMPL *session, bool failed)
+__block_disagg_checkpoint_resolve(WT_BM *bm, WT_SESSION_IMPL *session, bool failed)
 {
     WT_BLOCK_DISAGG *block_disagg;
     WT_CONFIG_ITEM cval;
@@ -127,6 +127,13 @@ __wti_block_disagg_checkpoint_resolve(WT_BM *bm, WT_SESSION_IMPL *session, bool
     md_cursor = NULL;
     md_key = NULL;
 
+    /*
+     * This requires schema lock to ensure that we capture a consistent snapshot of metadata entries
+     * related to the given shared table, e.g., the various file, colgroup, table, and layered
+     * entries.
+     */
+    WT_ASSERT_SPINLOCK_OWNED(session, &conn->schema_lock);
+
     if (failed)
         return (0);
 
@@ -185,6 +192,18 @@ err:
     return (ret);
 }
 
+/*
+ * __wti_block_disagg_checkpoint_resolve --
+ *     Resolve the checkpoint.
+ */
+int
+__wti_block_disagg_checkpoint_resolve(WT_BM *bm, WT_SESSION_IMPL *session, bool failed)
+{
+    WT_DECL_RET;
+    WT_WITH_SCHEMA_LOCK(session, ret = __block_disagg_checkpoint_resolve(bm, session, failed));
+    return (ret);
+}
+
 /*
  * __wti_block_disagg_checkpoint_load --
  *     Load a checkpoint. This involves (1) cracking the checkpoint cookie open (2) loading the root

src/third_party/wiredtiger/src/btree/bt_handle.c

@@ -1031,6 +1031,7 @@ __btree_page_sizes(WT_SESSION_IMPL *session)
     WT_BTREE *btree;
     WT_CONFIG_ITEM cval;
     WT_CONNECTION_IMPL *conn;
+    double dirty_trigger;
     uint64_t cache_size;
     uint32_t leaf_split_size, max;
     const char **cfg;
@@ -1105,9 +1106,11 @@ __btree_page_sizes(WT_SESSION_IMPL *session)
     btree->maxmempage = (uint64_t)cval.val;
 
 #define WT_MIN_PAGES 10
-    if (!F_ISSET_ATOMIC_32(conn, WT_CONN_CACHE_POOL) && (cache_size = conn->cache_size) > 0)
+    if (!F_ISSET_ATOMIC_32(conn, WT_CONN_CACHE_POOL) && (cache_size = conn->cache_size) > 0) {
-        btree->maxmempage = (uint64_t)WT_MIN(btree->maxmempage,
+        dirty_trigger = __wt_atomic_load_double_relaxed(&conn->evict->eviction_dirty_trigger);
-          ((conn->evict->eviction_dirty_trigger * cache_size) / 100) / WT_MIN_PAGES);
+        btree->maxmempage =
+          (uint64_t)WT_MIN(btree->maxmempage, ((dirty_trigger * cache_size) / 100) / WT_MIN_PAGES);
+    }
 
     /* Enforce a lower bound of a single disk leaf page */
     btree->maxmempage = WT_MAX(btree->maxmempage, btree->maxleafpage);

src/third_party/wiredtiger/src/checkpoint/checkpoint_txn.c

@@ -687,8 +687,8 @@ __wt_checkpoint_verbose_timer_started(WT_SESSION_IMPL *session)
 static void
 __checkpoint_timer_stats_set(WTI_CKPT_TIMER *timer, uint64_t msec)
 {
-    __wt_atomic_stats_max(&timer->max, msec);
+    __wt_atomic_stats_max_uint64(&timer->max, msec);
-    __wt_atomic_stats_min(&timer->min, msec);
+    __wt_atomic_stats_min_uint64(&timer->min, msec);
     __wt_atomic_store_uint64_relaxed(&timer->recent, msec);
     (void)__wt_atomic_add_uint64_relaxed(&timer->total, msec);
 }
@@ -1193,7 +1193,8 @@ __checkpoint_db_internal(WT_SESSION_IMPL *session, const char *cfg[])
     __wt_atomic_store_uint64_relaxed(&evict->evict_max_dirty_page_size_per_checkpoint, 0);
     __wt_atomic_store_uint64_relaxed(&evict->evict_max_updates_page_size_per_checkpoint, 0);
     __wt_atomic_store_uint64_relaxed(&evict->evict_max_ms_per_checkpoint, 0);
-    __wt_atomic_store_uint64_relaxed(&evict->evict_max_eviction_queue_attempts, 0);
+    __wt_atomic_store_uint16_relaxed(&evict->evict_max_eviction_queue_attempts, 0);
+    __wt_atomic_store_uint16_relaxed(&evict->evict_max_evict_page_attempts, 0);
     __wt_atomic_store_uint64_relaxed(&evict->reentry_hs_eviction_ms, 0);
     __wt_atomic_store_uint32_relaxed(&conn->heuristic_controls.obsolete_tw_btree_count, 0);
     __wt_atomic_store_uint64_relaxed(&conn->rec_maximum_hs_wrapup_milliseconds, 0);
@@ -1356,8 +1357,10 @@ __checkpoint_db_internal(WT_SESSION_IMPL *session, const char *cfg[])
      * a protection against someone creating a layered table, dropping the table, and then
      * recreating a local table with the same name.
      */
-    if (__wt_conn_is_disagg(session) && conn->layered_table_manager.leader)
+    if (__wt_conn_is_disagg(session) && conn->layered_table_manager.leader) {
-        WT_ERR(__wt_disagg_copy_metadata_process(session));
+        WT_WITH_SCHEMA_LOCK(session, ret = __wt_disagg_copy_metadata_process(session));
+        WT_ERR(ret);
+    }
 
     /* Wait prior to checkpointing the history store to simulate checkpoint slowness. */
     __checkpoint_timing_stress(session, WT_TIMING_STRESS_HS_CHECKPOINT_DELAY, &tsp);

src/third_party/wiredtiger/src/config/config_def.c

@@ -4072,16 +4072,17 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     confchk_WT_CONNECTION_rollback_to_stable, 2, confchk_WT_CONNECTION_rollback_to_stable_jump, 12,
     WT_CONF_SIZING_NONE, false},
   {"WT_CONNECTION.set_file_system", "", NULL, 0, NULL, 13, WT_CONF_SIZING_NONE, false},
+  {"WT_CONNECTION.set_key_provider", "", NULL, 0, NULL, 14, WT_CONF_SIZING_NONE, false},
   {"WT_CONNECTION.set_timestamp",
     "durable_timestamp=,force=false,oldest_timestamp=,"
     "stable_timestamp=",
-    confchk_WT_CONNECTION_set_timestamp, 4, confchk_WT_CONNECTION_set_timestamp_jump, 14,
+    confchk_WT_CONNECTION_set_timestamp, 4, confchk_WT_CONNECTION_set_timestamp_jump, 15,
     WT_CONF_SIZING_NONE, false},
   {"WT_CURSOR.bound", "action=set,bound=,inclusive=true", confchk_WT_CURSOR_bound, 3,
-    confchk_WT_CURSOR_bound_jump, 15, WT_CONF_SIZING_INITIALIZE(WT_CURSOR, bound), true},
+    confchk_WT_CURSOR_bound_jump, 16, WT_CONF_SIZING_INITIALIZE(WT_CURSOR, bound), true},
-  {"WT_CURSOR.close", "", NULL, 0, NULL, 16, WT_CONF_SIZING_NONE, false},
+  {"WT_CURSOR.close", "", NULL, 0, NULL, 17, WT_CONF_SIZING_NONE, false},
   {"WT_CURSOR.reconfigure", "append=false,overwrite=true,prefix_search=false",
-    confchk_WT_CURSOR_reconfigure, 3, confchk_WT_CURSOR_reconfigure_jump, 17, WT_CONF_SIZING_NONE,
+    confchk_WT_CURSOR_reconfigure, 3, confchk_WT_CURSOR_reconfigure_jump, 18, WT_CONF_SIZING_NONE,
     false},
   {"WT_SESSION.alter",
     "access_pattern_hint=none,app_metadata=,"
@@ -4090,30 +4091,30 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "checkpoint=,exclusive_refreshed=true,log=(enabled=true),"
     "os_cache_dirty_max=0,os_cache_max=0,verbose=[],"
     "write_timestamp_usage=none",
-    confchk_WT_SESSION_alter, 11, confchk_WT_SESSION_alter_jump, 18, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_alter, 11, confchk_WT_SESSION_alter_jump, 19, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.begin_transaction",
     "claim_prepared_id=,ignore_prepare=false,isolation=,name=,"
     "no_timestamp=false,operation_timeout_ms=0,priority=0,"
     "read_timestamp=,roundup_timestamps=(prepared=false,read=false),"
     "sync=",
-    confchk_WT_SESSION_begin_transaction, 10, confchk_WT_SESSION_begin_transaction_jump, 19,
+    confchk_WT_SESSION_begin_transaction, 10, confchk_WT_SESSION_begin_transaction_jump, 20,
     WT_CONF_SIZING_INITIALIZE(WT_SESSION, begin_transaction), true},
   {"WT_SESSION.checkpoint",
     "debug=(checkpoint_cleanup=false,checkpoint_crash_point=-1),drop="
     ",flush_tier=(enabled=false,force=false,sync=true,timeout=0),"
     "force=false,name=,use_timestamp=true",
-    confchk_WT_SESSION_checkpoint, 6, confchk_WT_SESSION_checkpoint_jump, 20, WT_CONF_SIZING_NONE,
+    confchk_WT_SESSION_checkpoint, 6, confchk_WT_SESSION_checkpoint_jump, 21, WT_CONF_SIZING_NONE,
     false},
-  {"WT_SESSION.close", "", NULL, 0, NULL, 21, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.close", "", NULL, 0, NULL, 22, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.commit_transaction",
     "commit_timestamp=,durable_timestamp=,operation_timeout_ms=0,"
     "sync=",
-    confchk_WT_SESSION_commit_transaction, 4, confchk_WT_SESSION_commit_transaction_jump, 22,
+    confchk_WT_SESSION_commit_transaction, 4, confchk_WT_SESSION_commit_transaction_jump, 23,
     WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.compact",
     "background=,dryrun=false,exclude=,free_space_target=20MB,"
     "run_once=false,timeout=1200",
-    confchk_WT_SESSION_compact, 6, confchk_WT_SESSION_compact_jump, 23, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_compact, 6, confchk_WT_SESSION_compact_jump, 24, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.create",
     "access_pattern_hint=none,allocation_size=4KB,app_metadata=,"
     "assert=(commit_timestamp=none,durable_timestamp=none,"
@@ -4139,14 +4140,14 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "cache_directory=,local_retention=300,name=,object_target_size=0,"
     "shared=false),type=file,value_format=u,verbose=[],"
     "write_timestamp_usage=none",
-    confchk_WT_SESSION_create, 53, confchk_WT_SESSION_create_jump, 24, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_create, 53, confchk_WT_SESSION_create_jump, 25, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.drop",
     "checkpoint_wait=true,force=false,lock_wait=true,"
     "remove_files=true,remove_shared=false",
-    confchk_WT_SESSION_drop, 5, confchk_WT_SESSION_drop_jump, 25, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_drop, 5, confchk_WT_SESSION_drop_jump, 26, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.log_flush", "sync=on", confchk_WT_SESSION_log_flush, 1,
-    confchk_WT_SESSION_log_flush_jump, 26, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_log_flush_jump, 27, WT_CONF_SIZING_NONE, false},
-  {"WT_SESSION.log_printf", "", NULL, 0, NULL, 27, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.log_printf", "", NULL, 0, NULL, 28, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.open_cursor",
     "append=false,bulk=false,checkpoint=,checkpoint_use_history=true,"
     "checkpoint_wait=true,debug=(checkpoint_read_timestamp=,"
@@ -4156,50 +4157,50 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "next_random=false,next_random_sample_size=0,next_random_seed=0,"
     "overwrite=true,prefix_search=false,raw=false,read_once=false,"
     "readonly=false,skip_sort_check=false,statistics=,target=",
-    confchk_WT_SESSION_open_cursor, 19, confchk_WT_SESSION_open_cursor_jump, 28,
+    confchk_WT_SESSION_open_cursor, 19, confchk_WT_SESSION_open_cursor_jump, 29,
     WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.prepare_transaction",
     "prepare_timestamp=,prepared_id=", confchk_WT_SESSION_prepare_transaction, 2,
-    confchk_WT_SESSION_prepare_transaction_jump, 29, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_prepare_transaction_jump, 30, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.prepared_id_transaction", "prepared_id=", confchk_WT_SESSION_prepared_id_transaction,
-    1, confchk_WT_SESSION_prepared_id_transaction_jump, 30, WT_CONF_SIZING_NONE, false},
+    1, confchk_WT_SESSION_prepared_id_transaction_jump, 31, WT_CONF_SIZING_NONE, false},
-  {"WT_SESSION.prepared_id_transaction_uint", "", NULL, 0, NULL, 31, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.prepared_id_transaction_uint", "", NULL, 0, NULL, 32, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.query_timestamp", "get=read", confchk_WT_SESSION_query_timestamp, 1,
-    confchk_WT_SESSION_query_timestamp_jump, 32, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_query_timestamp_jump, 33, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.reconfigure",
     "cache_cursors=true,cache_max_wait_ms=0,"
     "debug=(checkpoint_fail_before_turtle_update=false,"
     "release_evict_page=false),ignore_cache_size=false,"
     "isolation=snapshot,prefetch=(enabled=false)",
-    confchk_WT_SESSION_reconfigure, 6, confchk_WT_SESSION_reconfigure_jump, 33,
+    confchk_WT_SESSION_reconfigure, 6, confchk_WT_SESSION_reconfigure_jump, 34,
     WT_CONF_SIZING_INITIALIZE(WT_SESSION, reconfigure), true},
-  {"WT_SESSION.reset", "", NULL, 0, NULL, 34, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.reset", "", NULL, 0, NULL, 35, WT_CONF_SIZING_NONE, false},
-  {"WT_SESSION.reset_snapshot", "", NULL, 0, NULL, 35, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.reset_snapshot", "", NULL, 0, NULL, 36, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.rollback_transaction",
     "operation_timeout_ms=0,rollback_timestamp=", confchk_WT_SESSION_rollback_transaction, 2,
-    confchk_WT_SESSION_rollback_transaction_jump, 36, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_rollback_transaction_jump, 37, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.salvage", "force=false", confchk_WT_SESSION_salvage, 1,
-    confchk_WT_SESSION_salvage_jump, 37, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_salvage_jump, 38, WT_CONF_SIZING_NONE, false},
-  {"WT_SESSION.strerror", "", NULL, 0, NULL, 38, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.strerror", "", NULL, 0, NULL, 39, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.timestamp_transaction",
     "commit_timestamp=,durable_timestamp=,prepare_timestamp=,"
     "read_timestamp=,rollback_timestamp=",
-    confchk_WT_SESSION_timestamp_transaction, 5, confchk_WT_SESSION_timestamp_transaction_jump, 39,
+    confchk_WT_SESSION_timestamp_transaction, 5, confchk_WT_SESSION_timestamp_transaction_jump, 40,
     WT_CONF_SIZING_NONE, false},
-  {"WT_SESSION.timestamp_transaction_uint", "", NULL, 0, NULL, 40, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.timestamp_transaction_uint", "", NULL, 0, NULL, 41, WT_CONF_SIZING_NONE, false},
-  {"WT_SESSION.truncate", "", NULL, 0, NULL, 41, WT_CONF_SIZING_NONE, false},
+  {"WT_SESSION.truncate", "", NULL, 0, NULL, 42, WT_CONF_SIZING_NONE, false},
   {"WT_SESSION.verify",
     "do_not_clear_txn_id=false,dump_address=false,dump_all_data=false"
     ",dump_blocks=false,dump_key_data=false,dump_layout=false,"
     "dump_offsets=,dump_pages=false,dump_tree_shape=false,"
     "read_corrupt=false,stable_timestamp=false,strict=false",
-    confchk_WT_SESSION_verify, 12, confchk_WT_SESSION_verify_jump, 42, WT_CONF_SIZING_NONE, false},
+    confchk_WT_SESSION_verify, 12, confchk_WT_SESSION_verify_jump, 43, WT_CONF_SIZING_NONE, false},
   {"colgroup.meta",
     "app_metadata=,assert=(commit_timestamp=none,"
     "durable_timestamp=none,read_timestamp=none,write_timestamp=off),"
     "collator=,columns=,source=,type=file,verbose=[],"
     "write_timestamp_usage=none",
-    confchk_colgroup_meta, 8, confchk_colgroup_meta_jump, 43, WT_CONF_SIZING_NONE, false},
+    confchk_colgroup_meta, 8, confchk_colgroup_meta_jump, 44, WT_CONF_SIZING_NONE, false},
   {"file.config",
     "access_pattern_hint=none,allocation_size=4KB,app_metadata=,"
     "assert=(commit_timestamp=none,durable_timestamp=none,"
@@ -4219,7 +4220,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "cache_directory=,local_retention=300,name=,object_target_size=0,"
     "shared=false),value_format=u,verbose=[],"
     "write_timestamp_usage=none",
-    confchk_file_config, 43, confchk_file_config_jump, 44, WT_CONF_SIZING_NONE, false},
+    confchk_file_config, 43, confchk_file_config_jump, 45, WT_CONF_SIZING_NONE, false},
   {"file.meta",
     "access_pattern_hint=none,allocation_size=4KB,app_metadata=,"
     "assert=(commit_timestamp=none,durable_timestamp=none,"
@@ -4241,14 +4242,14 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "cache_directory=,local_retention=300,name=,object_target_size=0,"
     "shared=false),value_format=u,verbose=[],version=(major=0,"
     "minor=0),write_timestamp_usage=none",
-    confchk_file_meta, 51, confchk_file_meta_jump, 45, WT_CONF_SIZING_NONE, false},
+    confchk_file_meta, 51, confchk_file_meta_jump, 46, WT_CONF_SIZING_NONE, false},
   {"index.meta",
     "app_metadata=,assert=(commit_timestamp=none,"
     "durable_timestamp=none,read_timestamp=none,write_timestamp=off),"
     "collator=,columns=,extractor=,immutable=false,key_format=u,"
     "source=,type=file,value_format=u,verbose=[],"
     "write_timestamp_usage=none",
-    confchk_index_meta, 12, confchk_index_meta_jump, 46, WT_CONF_SIZING_NONE, false},
+    confchk_index_meta, 12, confchk_index_meta_jump, 47, WT_CONF_SIZING_NONE, false},
   {"layered.meta",
     "app_metadata=,assert=(commit_timestamp=none,"
     "durable_timestamp=none,read_timestamp=none,write_timestamp=off),"
@@ -4257,7 +4258,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "lose_all_my_data=false,page_log=,role=),ingest=,key_format=u,"
     "log=(enabled=true),stable=,value_format=u,verbose=[],"
     "write_timestamp_usage=none",
-    confchk_layered_meta, 12, confchk_layered_meta_jump, 47, WT_CONF_SIZING_NONE, false},
+    confchk_layered_meta, 12, confchk_layered_meta_jump, 48, WT_CONF_SIZING_NONE, false},
   {"object.meta",
     "access_pattern_hint=none,allocation_size=4KB,app_metadata=,"
     "assert=(commit_timestamp=none,durable_timestamp=none,"
@@ -4280,13 +4281,13 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "cache_directory=,local_retention=300,name=,object_target_size=0,"
     "shared=false),value_format=u,verbose=[],version=(major=0,"
     "minor=0),write_timestamp_usage=none",
-    confchk_object_meta, 53, confchk_object_meta_jump, 48, WT_CONF_SIZING_NONE, false},
+    confchk_object_meta, 53, confchk_object_meta_jump, 49, WT_CONF_SIZING_NONE, false},
   {"table.meta",
     "app_metadata=,assert=(commit_timestamp=none,"
     "durable_timestamp=none,read_timestamp=none,write_timestamp=off),"
     "colgroups=,collator=,columns=,key_format=u,value_format=u,"
     "verbose=[],write_timestamp_usage=none",
-    confchk_table_meta, 9, confchk_table_meta_jump, 49, WT_CONF_SIZING_NONE, false},
+    confchk_table_meta, 9, confchk_table_meta_jump, 50, WT_CONF_SIZING_NONE, false},
   {"tier.meta",
     "access_pattern_hint=none,allocation_size=4KB,app_metadata=,"
     "assert=(commit_timestamp=none,durable_timestamp=none,"
@@ -4309,7 +4310,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "cache_directory=,local_retention=300,name=,object_target_size=0,"
     "shared=false),value_format=u,verbose=[],version=(major=0,"
     "minor=0),write_timestamp_usage=none",
-    confchk_tier_meta, 54, confchk_tier_meta_jump, 50, WT_CONF_SIZING_NONE, false},
+    confchk_tier_meta, 54, confchk_tier_meta_jump, 51, WT_CONF_SIZING_NONE, false},
   {"tiered.meta",
     "access_pattern_hint=none,allocation_size=4KB,app_metadata=,"
     "assert=(commit_timestamp=none,durable_timestamp=none,"
@@ -4332,7 +4333,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "bucket=,bucket_prefix=,cache_directory=,local_retention=300,"
     "name=,object_target_size=0,shared=false),tiers=,value_format=u,"
     "verbose=[],version=(major=0,minor=0),write_timestamp_usage=none",
-    confchk_tiered_meta, 56, confchk_tiered_meta_jump, 51, WT_CONF_SIZING_NONE, false},
+    confchk_tiered_meta, 56, confchk_tiered_meta_jump, 52, WT_CONF_SIZING_NONE, false},
   {"wiredtiger_open",
     "backup_restore_target=,"
     "block_cache=(blkcache_eviction_aggression=1800,"
@@ -4399,7 +4400,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "transaction_sync=(enabled=false,method=fsync),"
     "use_environment=true,use_environment_priv=false,verbose=[],"
     "verify_metadata=false,write_through=",
-    confchk_wiredtiger_open, 71, confchk_wiredtiger_open_jump, 52, WT_CONF_SIZING_NONE, false},
+    confchk_wiredtiger_open, 71, confchk_wiredtiger_open_jump, 53, WT_CONF_SIZING_NONE, false},
   {"wiredtiger_open_all",
     "backup_restore_target=,"
     "block_cache=(blkcache_eviction_aggression=1800,"
@@ -4466,7 +4467,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "transaction_sync=(enabled=false,method=fsync),"
     "use_environment=true,use_environment_priv=false,verbose=[],"
     "verify_metadata=false,version=(major=0,minor=0),write_through=",
-    confchk_wiredtiger_open_all, 72, confchk_wiredtiger_open_all_jump, 53, WT_CONF_SIZING_NONE,
+    confchk_wiredtiger_open_all, 72, confchk_wiredtiger_open_all_jump, 54, WT_CONF_SIZING_NONE,
     false},
   {"wiredtiger_open_basecfg",
     "backup_restore_target=,"
@@ -4533,7 +4534,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "shared=false),timing_stress_for_test=,"
     "transaction_sync=(enabled=false,method=fsync),verbose=[],"
     "verify_metadata=false,version=(major=0,minor=0),write_through=",
-    confchk_wiredtiger_open_basecfg, 66, confchk_wiredtiger_open_basecfg_jump, 54,
+    confchk_wiredtiger_open_basecfg, 66, confchk_wiredtiger_open_basecfg_jump, 55,
     WT_CONF_SIZING_NONE, false},
   {"wiredtiger_open_usercfg",
     "backup_restore_target=,"
@@ -4600,7 +4601,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
     "shared=false),timing_stress_for_test=,"
     "transaction_sync=(enabled=false,method=fsync),verbose=[],"
     "verify_metadata=false,write_through=",
-    confchk_wiredtiger_open_usercfg, 65, confchk_wiredtiger_open_usercfg_jump, 55,
+    confchk_wiredtiger_open_usercfg, 65, confchk_wiredtiger_open_usercfg_jump, 56,
     WT_CONF_SIZING_NONE, false},
   {NULL, NULL, NULL, 0, NULL, 0, WT_CONF_SIZING_NONE, false}};
 

src/third_party/wiredtiger/src/conn/conn_api.c

@@ -2701,6 +2701,36 @@ err:
     return (ret);
 }
 
+/*
+ * __conn_set_key_provider --
+ *     Configure a custom key provider implementation on database open.
+ */
+static int
+__conn_set_key_provider(WT_CONNECTION *wt_conn, WT_KEY_PROVIDER *key_provider, const char *config)
+{
+    WT_CONNECTION_IMPL *conn;
+    WT_DECL_RET;
+    WT_SESSION_IMPL *session;
+
+    conn = (WT_CONNECTION_IMPL *)wt_conn;
+    CONNECTION_API_CALL_NOCONF(conn, session, set_key_provider);
+
+    /* The configuration string has no use but may be useful at a later time. */
+    if (config != NULL)
+        WT_ERR_MSG(session, EINVAL, "key provider configuration currently not supported.");
+
+    /*
+     * You can only configure the key provider system with early-load set.
+     */
+    if (conn->file_system != NULL)
+        WT_ERR_MSG(session, EINVAL, "key provider system must be configured with early_load set");
+
+    conn->key_provider = key_provider;
+
+err:
+    API_END_RET(session, ret);
+}
+
 /*
  * __conn_set_file_system --
  *     Configure a custom file system implementation on database open.
@@ -3007,7 +3037,7 @@ wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler, const char *c
       __conn_load_extension, __conn_add_data_source, __conn_add_collator, __conn_add_compressor,
       __conn_add_encryptor, __conn_set_file_system, __conn_add_page_log, __conn_add_storage_source,
       __conn_get_page_log, __conn_get_storage_source, __conn_set_context_uint,
-      __conn_dump_error_log, __conn_get_extension_api};
+      __conn_dump_error_log, __conn_set_key_provider, __conn_get_extension_api};
     static const WT_NAME_FLAG file_types[] = {
       {"data", WT_FILE_TYPE_DATA}, {"log", WT_FILE_TYPE_LOG}, {NULL, 0}};
 

src/third_party/wiredtiger/src/conn/conn_dhandle.c

@@ -654,7 +654,7 @@ __wt_conn_dhandle_open(WT_SESSION_IMPL *session, const char *cfg[], uint32_t fla
      * allowed to be relocked by the same session.
      */
     if (F_ISSET(dhandle, WT_DHANDLE_EXCLUSIVE) && !LF_ISSET(WT_BTREE_BULK)) {
-        dhandle->excl_session = session;
+        __wt_tsan_suppress_store_pointer((void *)&dhandle->excl_session, (void *)session);
         dhandle->excl_ref = 1;
     }
     F_SET(dhandle, WT_DHANDLE_OPEN);

src/third_party/wiredtiger/src/conn/conn_layered.c

@@ -975,6 +975,13 @@ __wt_disagg_copy_metadata_process(WT_SESSION_IMPL *session)
 
     conn = S2C(session);
 
+    /*
+     * This requires schema lock to ensure that we capture a consistent snapshot of metadata entries
+     * related to the given shared table, e.g., the various file, colgroup, table, and layered
+     * entries.
+     */
+    WT_ASSERT_SPINLOCK_OWNED(session, &conn->schema_lock);
+
     __wt_spin_lock(session, &conn->disaggregated_storage.copy_metadata_lock);
 
     TAILQ_FOREACH_SAFE(entry, &conn->disaggregated_storage.copy_metadata_qh, q, tmp)

src/third_party/wiredtiger/src/evict/evict.h

@@ -26,9 +26,7 @@ struct __wt_evict {
                                                                       eviction per checkpoint */
     wt_shared uint64_t evict_max_ms; /* Longest milliseconds spent at a single eviction */
     wt_shared uint64_t
-      evict_max_ms_per_checkpoint; /* Longest milliseconds spent at a single eviction */
+      evict_max_ms_per_checkpoint;   /* Longest milliseconds spent at a single eviction */
-    wt_shared uint64_t evict_max_eviction_queue_attempts; /* Maximum number of attempts to add a
-                                                             page to eviction queue */
     uint64_t reentry_hs_eviction_ms; /* Total milliseconds spent inside a nested eviction */
     struct timespec stuck_time;      /* Stuck time */
 
@@ -74,14 +72,19 @@ struct __wt_evict {
     /*
      * Eviction thread tuning information.
      */
-    uint32_t evict_tune_datapts_needed;          /* Data needed to tune */
+    uint32_t evict_tune_datapts_needed;                   /* Data needed to tune */
+    wt_shared uint16_t evict_max_eviction_queue_attempts; /* Maximum number of attempts to add a
+                                                             page to eviction queue */
+    wt_shared uint16_t evict_max_evict_page_attempts;     /* Maximum number of attempts
+                                                             to evict a page */
+
     struct timespec evict_tune_last_action_time; /* Time of last action */
     struct timespec evict_tune_last_time;        /* Time of last check */
-    uint32_t evict_tune_num_points;              /* Number of values tried */
     uint64_t evict_tune_progress_last;           /* Progress counter */
     uint64_t evict_tune_progress_rate_max;       /* Max progress rate */
     bool evict_tune_stable;                      /* Are we stable? */
     uint32_t evict_tune_workers_best;            /* Best performing value */
+    uint32_t evict_tune_num_points;              /* Number of values tried */
 
     /*
      * Pass interrupt counter.

src/third_party/wiredtiger/src/evict/evict_conn.c

@@ -439,7 +439,10 @@ __wt_evict_stats_update(WT_SESSION_IMPL *session)
     WT_STATP_CONN_SET(session, stats, eviction_stable_state_workers,
       __wt_atomic_load_uint32_relaxed(&evict->evict_tune_workers_best));
     WT_STATP_CONN_SET(session, stats, eviction_maximum_attempts_to_queue_page,
-      __wt_atomic_load_uint64_relaxed(&evict->evict_max_eviction_queue_attempts));
+      __wt_atomic_load_uint16_relaxed(&evict->evict_max_eviction_queue_attempts));
+    WT_STATP_CONN_SET(session, stats, eviction_maximum_attempts_to_evict_page,
+      __wt_atomic_load_uint16_relaxed(&evict->evict_max_evict_page_attempts));
+
     /*
      * The number of files with active walks ~= number of hazard pointers in the walk session. Note:
      * reading without locking.

src/third_party/wiredtiger/src/evict/evict_lru.c

@@ -2707,13 +2707,14 @@ __evict_walk_tree(WT_SESSION_IMPL *session, WTI_EVICT_QUEUE *queue, u_int max_en
         if (page->evict_pass_gen == 0) {
             const uint64_t gen_gap =
               __wt_atomic_load_uint64_relaxed(&evict->evict_pass_gen) - page->cache_create_gen;
-            __wt_atomic_stats_max(&evict->evict_max_unvisited_gen_gap, gen_gap);
+            __wt_atomic_stats_max_uint64(&evict->evict_max_unvisited_gen_gap, gen_gap);
-            __wt_atomic_stats_max(&evict->evict_max_unvisited_gen_gap_per_checkpoint, gen_gap);
+            __wt_atomic_stats_max_uint64(
+              &evict->evict_max_unvisited_gen_gap_per_checkpoint, gen_gap);
         } else {
             const uint64_t gen_gap =
               __wt_atomic_load_uint64_relaxed(&evict->evict_pass_gen) - page->evict_pass_gen;
-            __wt_atomic_stats_max(&evict->evict_max_visited_gen_gap, gen_gap);
+            __wt_atomic_stats_max_uint64(&evict->evict_max_visited_gen_gap, gen_gap);
-            __wt_atomic_stats_max(&evict->evict_max_visited_gen_gap_per_checkpoint, gen_gap);
+            __wt_atomic_stats_max_uint64(&evict->evict_max_visited_gen_gap_per_checkpoint, gen_gap);
         }
 
         page->evict_pass_gen = __wt_atomic_load_uint64_relaxed(&evict->evict_pass_gen);
@@ -2739,7 +2740,7 @@ __evict_walk_tree(WT_SESSION_IMPL *session, WTI_EVICT_QUEUE *queue, u_int max_en
 
         /* update number of attempts this page has been evicted */
         ++page->evict_queue_attempts;
-        __wt_atomic_stats_max(
+        __wt_atomic_stats_max_uint16(
           &evict->evict_max_eviction_queue_attempts, page->evict_queue_attempts);
 
         __evict_try_queue_page(
@@ -2997,7 +2998,9 @@ static int
 __evict_page(WT_SESSION_IMPL *session, bool is_server)
 {
     WT_BTREE *btree;
+    WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
+    WT_EVICT *evict;
     WT_REF *ref;
     WT_REF_STATE previous_state;
     WT_TRACK_OP_DECL;
@@ -3007,6 +3010,9 @@ __evict_page(WT_SESSION_IMPL *session, bool is_server)
 
     WT_TRACK_OP_INIT(session);
 
+    conn = S2C(session);
+    evict = conn->evict;
+
     WT_RET_TRACK(__evict_get_ref(session, is_server, &btree, &ref, &previous_state));
     WT_ASSERT(session, WT_REF_GET_STATE(ref) == WT_REF_LOCKED);
 
@@ -3028,7 +3034,7 @@ __evict_page(WT_SESSION_IMPL *session, bool is_server)
             WT_STAT_CONN_INCR(session, eviction_app_dirty_attempt);
         }
         WT_STAT_CONN_INCR(session, eviction_app_attempt);
-        S2C(session)->evict->app_evicts++;
+        ++evict->app_evicts;
         time_start = WT_STAT_ENABLED(session) ? __wt_clock(session) : 0;
     }
 
@@ -3051,6 +3057,11 @@ __evict_page(WT_SESSION_IMPL *session, bool is_server)
     }
 
     if (WT_UNLIKELY(ret != 0)) {
+        ++ref->page->evict_page_attempts;
+
+        __wt_atomic_stats_max_uint16(
+          &evict->evict_max_evict_page_attempts, ref->page->evict_page_attempts);
+
         if (is_server)
             WT_STAT_CONN_INCR(session, eviction_server_evict_fail);
         else if (F_ISSET(session, WT_SESSION_INTERNAL))

src/third_party/wiredtiger/src/evict/evict_page.c

@@ -101,9 +101,9 @@ __evict_stats_update(WT_SESSION_IMPL *session, uint8_t flags)
     }
     if (!session->evict_timeline.reentry_hs_eviction) {
         eviction_time_milliseconds = eviction_time / WT_THOUSAND;
-        __wt_atomic_stats_max(
+        __wt_atomic_stats_max_uint64(
           &conn->evict->evict_max_ms_per_checkpoint, eviction_time_milliseconds);
-        __wt_atomic_stats_max(&conn->evict->evict_max_ms, eviction_time_milliseconds);
+        __wt_atomic_stats_max_uint64(&conn->evict->evict_max_ms, eviction_time_milliseconds);
         if (eviction_time_milliseconds > WT_MINUTE * WT_THOUSAND)
             __wt_verbose_warning(session, WT_VERB_EVICTION,
               "Eviction took more than 1 minute (%" PRIu64 "us). Building disk image took %" PRIu64
@@ -263,18 +263,21 @@ __wt_evict(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF_STATE previous_state, u
      * statistic.
      */
     page_size = __wt_atomic_load_size_relaxed(&page->memory_footprint);
-    __wt_atomic_stats_max(&conn->evict->evict_max_page_size, page_size);
+    __wt_atomic_stats_max_uint64(&conn->evict->evict_max_page_size, page_size);
 
     /* Clean page */
     if (!is_dirty) {
-        __wt_atomic_stats_max(&conn->evict->evict_max_clean_page_size_per_checkpoint, page_size);
+        __wt_atomic_stats_max_uint64(
+          &conn->evict->evict_max_clean_page_size_per_checkpoint, page_size);
     } else {
         /* Dirty page */
-        __wt_atomic_stats_max(&conn->evict->evict_max_dirty_page_size_per_checkpoint, page_size);
+        __wt_atomic_stats_max_uint64(
+          &conn->evict->evict_max_dirty_page_size_per_checkpoint, page_size);
     }
     /* Check if the page has updates */
     if (page->modify != NULL) {
-        __wt_atomic_stats_max(&conn->evict->evict_max_updates_page_size_per_checkpoint, page_size);
+        __wt_atomic_stats_max_uint64(
+          &conn->evict->evict_max_updates_page_size_per_checkpoint, page_size);
     }
 
     /* Figure out whether reconciliation was done on the page */

src/third_party/wiredtiger/src/include/btmem.h

@@ -847,10 +847,14 @@ struct __wt_page {
 #define WT_READGEN_STEP 100
     uint64_t read_gen;
 
-    uint64_t cache_create_gen;     /* Page create timestamp */
+    uint64_t cache_create_gen; /* Page create timestamp */
-    uint64_t evict_pass_gen;       /* Eviction pass generation */
+    uint64_t evict_pass_gen;   /* Eviction pass generation */
-    uint64_t evict_queue_attempts; /* Number of times eviction tries to queue a page for eviction
+
+    uint16_t evict_queue_attempts; /* Number of times eviction tries to queue a page for eviction
                                       but fails */
+    uint16_t evict_page_attempts;  /* Number of times eviction tries to evict a page */
+    /* 2 uint16_t hole expected. */
+
     WT_PAGE_DISAGG_INFO *disagg_info;
 
 #ifdef HAVE_DIAGNOSTIC

src/third_party/wiredtiger/src/include/conf.h

@@ -191,7 +191,7 @@ WT_CONF_API_DECLARE(GLOBAL, wiredtiger_open_all, 25, 198);
 WT_CONF_API_DECLARE(GLOBAL, wiredtiger_open_basecfg, 25, 192);
 WT_CONF_API_DECLARE(GLOBAL, wiredtiger_open_usercfg, 25, 191);
 
-#define WT_CONF_API_ELEMENTS 56
+#define WT_CONF_API_ELEMENTS 57
 
 /*
  * Per-API configuration structure declarations: END

src/third_party/wiredtiger/src/include/config.h

@@ -119,48 +119,49 @@ struct __wt_config_parser_impl {
 #define WT_CONFIG_ENTRY_WT_CONNECTION_reconfigure 11
 #define WT_CONFIG_ENTRY_WT_CONNECTION_rollback_to_stable 12
 #define WT_CONFIG_ENTRY_WT_CONNECTION_set_file_system 13
-#define WT_CONFIG_ENTRY_WT_CONNECTION_set_timestamp 14
+#define WT_CONFIG_ENTRY_WT_CONNECTION_set_key_provider 14
-#define WT_CONFIG_ENTRY_WT_CURSOR_bound 15
+#define WT_CONFIG_ENTRY_WT_CONNECTION_set_timestamp 15
-#define WT_CONFIG_ENTRY_WT_CURSOR_close 16
+#define WT_CONFIG_ENTRY_WT_CURSOR_bound 16
-#define WT_CONFIG_ENTRY_WT_CURSOR_reconfigure 17
+#define WT_CONFIG_ENTRY_WT_CURSOR_close 17
-#define WT_CONFIG_ENTRY_WT_SESSION_alter 18
+#define WT_CONFIG_ENTRY_WT_CURSOR_reconfigure 18
-#define WT_CONFIG_ENTRY_WT_SESSION_begin_transaction 19
+#define WT_CONFIG_ENTRY_WT_SESSION_alter 19
-#define WT_CONFIG_ENTRY_WT_SESSION_checkpoint 20
+#define WT_CONFIG_ENTRY_WT_SESSION_begin_transaction 20
-#define WT_CONFIG_ENTRY_WT_SESSION_close 21
+#define WT_CONFIG_ENTRY_WT_SESSION_checkpoint 21
-#define WT_CONFIG_ENTRY_WT_SESSION_commit_transaction 22
+#define WT_CONFIG_ENTRY_WT_SESSION_close 22
-#define WT_CONFIG_ENTRY_WT_SESSION_compact 23
+#define WT_CONFIG_ENTRY_WT_SESSION_commit_transaction 23
-#define WT_CONFIG_ENTRY_WT_SESSION_create 24
+#define WT_CONFIG_ENTRY_WT_SESSION_compact 24
-#define WT_CONFIG_ENTRY_WT_SESSION_drop 25
+#define WT_CONFIG_ENTRY_WT_SESSION_create 25
-#define WT_CONFIG_ENTRY_WT_SESSION_log_flush 26
+#define WT_CONFIG_ENTRY_WT_SESSION_drop 26
-#define WT_CONFIG_ENTRY_WT_SESSION_log_printf 27
+#define WT_CONFIG_ENTRY_WT_SESSION_log_flush 27
-#define WT_CONFIG_ENTRY_WT_SESSION_open_cursor 28
+#define WT_CONFIG_ENTRY_WT_SESSION_log_printf 28
-#define WT_CONFIG_ENTRY_WT_SESSION_prepare_transaction 29
+#define WT_CONFIG_ENTRY_WT_SESSION_open_cursor 29
-#define WT_CONFIG_ENTRY_WT_SESSION_prepared_id_transaction 30
+#define WT_CONFIG_ENTRY_WT_SESSION_prepare_transaction 30
-#define WT_CONFIG_ENTRY_WT_SESSION_prepared_id_transaction_uint 31
+#define WT_CONFIG_ENTRY_WT_SESSION_prepared_id_transaction 31
-#define WT_CONFIG_ENTRY_WT_SESSION_query_timestamp 32
+#define WT_CONFIG_ENTRY_WT_SESSION_prepared_id_transaction_uint 32
-#define WT_CONFIG_ENTRY_WT_SESSION_reconfigure 33
+#define WT_CONFIG_ENTRY_WT_SESSION_query_timestamp 33
-#define WT_CONFIG_ENTRY_WT_SESSION_reset 34
+#define WT_CONFIG_ENTRY_WT_SESSION_reconfigure 34
-#define WT_CONFIG_ENTRY_WT_SESSION_reset_snapshot 35
+#define WT_CONFIG_ENTRY_WT_SESSION_reset 35
-#define WT_CONFIG_ENTRY_WT_SESSION_rollback_transaction 36
+#define WT_CONFIG_ENTRY_WT_SESSION_reset_snapshot 36
-#define WT_CONFIG_ENTRY_WT_SESSION_salvage 37
+#define WT_CONFIG_ENTRY_WT_SESSION_rollback_transaction 37
-#define WT_CONFIG_ENTRY_WT_SESSION_strerror 38
+#define WT_CONFIG_ENTRY_WT_SESSION_salvage 38
-#define WT_CONFIG_ENTRY_WT_SESSION_timestamp_transaction 39
+#define WT_CONFIG_ENTRY_WT_SESSION_strerror 39
-#define WT_CONFIG_ENTRY_WT_SESSION_timestamp_transaction_uint 40
+#define WT_CONFIG_ENTRY_WT_SESSION_timestamp_transaction 40
-#define WT_CONFIG_ENTRY_WT_SESSION_truncate 41
+#define WT_CONFIG_ENTRY_WT_SESSION_timestamp_transaction_uint 41
-#define WT_CONFIG_ENTRY_WT_SESSION_verify 42
+#define WT_CONFIG_ENTRY_WT_SESSION_truncate 42
-#define WT_CONFIG_ENTRY_colgroup_meta 43
+#define WT_CONFIG_ENTRY_WT_SESSION_verify 43
-#define WT_CONFIG_ENTRY_file_config 44
+#define WT_CONFIG_ENTRY_colgroup_meta 44
-#define WT_CONFIG_ENTRY_file_meta 45
+#define WT_CONFIG_ENTRY_file_config 45
-#define WT_CONFIG_ENTRY_index_meta 46
+#define WT_CONFIG_ENTRY_file_meta 46
-#define WT_CONFIG_ENTRY_layered_meta 47
+#define WT_CONFIG_ENTRY_index_meta 47
-#define WT_CONFIG_ENTRY_object_meta 48
+#define WT_CONFIG_ENTRY_layered_meta 48
-#define WT_CONFIG_ENTRY_table_meta 49
+#define WT_CONFIG_ENTRY_object_meta 49
-#define WT_CONFIG_ENTRY_tier_meta 50
+#define WT_CONFIG_ENTRY_table_meta 50
-#define WT_CONFIG_ENTRY_tiered_meta 51
+#define WT_CONFIG_ENTRY_tier_meta 51
-#define WT_CONFIG_ENTRY_wiredtiger_open 52
+#define WT_CONFIG_ENTRY_tiered_meta 52
-#define WT_CONFIG_ENTRY_wiredtiger_open_all 53
+#define WT_CONFIG_ENTRY_wiredtiger_open 53
-#define WT_CONFIG_ENTRY_wiredtiger_open_basecfg 54
+#define WT_CONFIG_ENTRY_wiredtiger_open_all 54
-#define WT_CONFIG_ENTRY_wiredtiger_open_usercfg 55
+#define WT_CONFIG_ENTRY_wiredtiger_open_basecfg 55
+#define WT_CONFIG_ENTRY_wiredtiger_open_usercfg 56
 
 extern const char __WT_CONFIG_CHOICE_NULL[]; /* not set in configuration */
 extern const char __WT_CONFIG_CHOICE_DRAM[];

src/third_party/wiredtiger/src/include/connection.h

@@ -985,6 +985,11 @@ struct __wt_connection_impl {
      */
     WT_FILE_SYSTEM *file_system;
 
+    /*
+     * Key management interface abstracted to support pluggable key management implementations.
+     */
+    WT_KEY_PROVIDER *key_provider;
+
 /*
  * Server subsystem flags.
  */

src/third_party/wiredtiger/src/include/misc.h

@@ -510,29 +510,21 @@ __wt_atomic_decrement_if_positive(uint32_t *valuep)
 }
 
 /*
- * __wt_atomic_stats_max --
+ *    Calculate max/min statistic values. Currently we use load + store for that purpose since
- *     Calculate max statistic values. Currently we use load + store for that purpose since
  *     statistic is allowed to be fuzzy. FIXME-WT-15755: Consider using relaxed CAS instead to
  *     ensure it is lossless.
  */
-static inline void
+#define WT_ATOMIC_STATS_MFUNC(suffix, _type)                                    \
-__wt_atomic_stats_max(uint64_t *stat, uint64_t value)
+    static inline void __wt_atomic_stats_max_##suffix(_type *stat, _type value) \
-{
+    {                                                                           \
-    if (value > __wt_atomic_load_uint64_relaxed(stat)) {
+        if (value > __wt_atomic_load_##suffix##_relaxed(stat))                  \
-        __wt_atomic_store_uint64_relaxed(stat, value);
+            __wt_atomic_store_##suffix##_relaxed(stat, value);                  \
+    }                                                                           \
+    static inline void __wt_atomic_stats_min_##suffix(_type *stat, _type value) \
+    {                                                                           \
+        if (value < __wt_atomic_load_##suffix##_relaxed(stat))                  \
+            __wt_atomic_store_##suffix##_relaxed(stat, value);                  \
     }
-}
 
-/*
+WT_ATOMIC_STATS_MFUNC(uint16, uint16_t)
- * __wt_atomic_stats_min --
+WT_ATOMIC_STATS_MFUNC(uint64, uint64_t)
- *     Calculate min statistic values. Currently we use load + store for that purpose since
- *     statistic is allowed to be fuzzy. FIXME-WT-15755: Consider using relaxed CAS instead to
- *     ensure it is lossless.
- */
-static inline void
-__wt_atomic_stats_min(uint64_t *stat, uint64_t value)
-{
-    if (value < __wt_atomic_load_uint64_relaxed(stat)) {
-        __wt_atomic_store_uint64_relaxed(stat, value);
-    }
-}

src/third_party/wiredtiger/src/include/stat.h

@@ -673,6 +673,7 @@ struct __wt_connection_stats {
     int64_t eviction_maximum_milliseconds;
     int64_t eviction_maximum_milliseconds_per_checkpoint;
     int64_t eviction_maximum_attempts_to_queue_page;
+    int64_t eviction_maximum_attempts_to_evict_page;
     int64_t eviction_maximum_page_size;
     int64_t eviction_maximum_updates_page_size_per_checkpoint;
     int64_t eviction_app_dirty_attempt;

src/third_party/wiredtiger/src/support/stat.c

@@ -2053,6 +2053,7 @@ static const char *const __stats_connection_desc[] = {
   "cache: maximum milliseconds spent at a single eviction",
   "cache: maximum milliseconds spent at a single eviction per checkpoint",
   "cache: maximum number of times a page tried to be added to eviction queue but fail",
+  "cache: maximum number of times a page tried to be evicted",
   "cache: maximum page size seen at eviction",
   "cache: maximum updates page size seen at eviction per checkpoint",
   "cache: modified page evict attempts by application threads",
@@ -3065,6 +3066,7 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats)
     /* not clearing eviction_maximum_milliseconds */
     /* not clearing eviction_maximum_milliseconds_per_checkpoint */
     /* not clearing eviction_maximum_attempts_to_queue_page */
+    /* not clearing eviction_maximum_attempts_to_evict_page */
     /* not clearing eviction_maximum_page_size */
     /* not clearing eviction_maximum_updates_page_size_per_checkpoint */
     stats->eviction_app_dirty_attempt = 0;
@@ -4123,6 +4125,8 @@ __wt_stat_connection_aggregate(WT_CONNECTION_STATS **from, WT_CONNECTION_STATS *
       WT_STAT_CONN_READ(from, eviction_maximum_milliseconds_per_checkpoint);
     to->eviction_maximum_attempts_to_queue_page +=
       WT_STAT_CONN_READ(from, eviction_maximum_attempts_to_queue_page);
+    to->eviction_maximum_attempts_to_evict_page +=
+      WT_STAT_CONN_READ(from, eviction_maximum_attempts_to_evict_page);
     to->eviction_maximum_page_size += WT_STAT_CONN_READ(from, eviction_maximum_page_size);
     to->eviction_maximum_updates_page_size_per_checkpoint +=
       WT_STAT_CONN_READ(from, eviction_maximum_updates_page_size_per_checkpoint);

src/third_party/wiredtiger/src/txn/txn_recover.c

@@ -1232,7 +1232,8 @@ done:
         /* Although rollback to stable is not needed, we still need to set the durable timestamp. */
         WT_TXN_GLOBAL *txn_global = &conn->txn_global;
         txn_global->has_durable_timestamp = txn_global->has_stable_timestamp;
-        txn_global->durable_timestamp = txn_global->stable_timestamp;
+        __wt_atomic_store_uint64_relaxed(
+          &txn_global->durable_timestamp, txn_global->stable_timestamp);
 
         if (disagg)
             __wt_verbose_info(session, WT_VERB_RTS, "%s", "skipped recovery RTS due to disagg");

src/third_party/wiredtiger/test/evergreen.yml

@@ -1650,17 +1650,6 @@ variables:
           format_args: disagg.mode=follower runs.timer=5:10
           times: 5
 
-  - &format-stress-test-disagg-switch-palm
-    depends_on:
-      - name: compile
-    commands:
-      - func: "fetch artifacts"
-      - func: "format test disagg"
-        vars:
-          # FIXME-WT-14566 Limit the runs for now.
-          format_args: disagg.page_log=palm disagg.mode=switch runs.rows=100000:300000 runs.tables=1:3 runs.ops=300000
-          times: 5
-
   - &format-stress-test-disagg-switch
     depends_on:
       - name: compile
@@ -4600,17 +4589,6 @@ tasks:
     name: format-stress-test-disagg-follower-2
     tags: ["stress-test-disagg"]
 
-  # FIXME-WT-14566: Enable disagg switch mode on all platforms once failures have been resolved.
-  - <<: *format-stress-test-disagg-switch-palm
-    name: format-stress-test-disagg-switch-palm-1
-    tags: ["stress-test-disagg-fail"]
-  - <<: *format-stress-test-disagg-switch-palm
-    name: format-stress-test-disagg-switch-palm-2
-    tags: ["stress-test-disagg-fail"]
-  - <<: *format-stress-test-disagg-switch-palm
-    name: format-stress-test-disagg-switch-palm-3
-    tags: ["stress-test-disagg-fail"]
-
   # FIXME-WT-14566: Enable disagg switch mode on all platforms once failures have been resolved.
   - <<: *format-stress-test-disagg-switch
     name: format-stress-test-disagg-switch-1

src/third_party/wiredtiger/test/format/follower.c

@@ -28,6 +28,48 @@
 
 #include "format.h"
 
+/*
+ * follower_read_latest_checkpoint --
+ *     Read the latest checkpoint. Only followers should be able to do so.
+ */
+void
+follower_read_latest_checkpoint(void)
+{
+    SAP sap;
+    WT_CONNECTION *conn;
+    WT_DECL_RET;
+    WT_PAGE_LOG *page_log;
+    WT_SESSION *session;
+    const char *disagg_page_log;
+    WT_ITEM checkpoint_metadata;
+    uint64_t checkpoint_ts;
+    char config[128];
+
+    conn = g.wts_conn;
+    disagg_page_log = (char *)GVS(DISAGG_PAGE_LOG);
+    memset(&checkpoint_metadata, 0, sizeof(checkpoint_metadata));
+
+    /* Only follower can pickup checkpoints. */
+    testutil_assert(!g.disagg_leader);
+    testutil_check(conn->get_page_log(conn, disagg_page_log, &page_log));
+
+    wt_wrap_open_session(conn, &sap, NULL, NULL, &session);
+    ret = page_log->pl_get_complete_checkpoint_ext(
+      page_log, session, NULL, NULL, &checkpoint_ts, &checkpoint_metadata);
+    testutil_check_error_ok(ret, WT_NOTFOUND);
+    if (ret != WT_NOTFOUND) {
+        testutil_snprintf(config, sizeof(config), "disaggregated=(checkpoint_meta=\"%.*s\")",
+          (int)checkpoint_metadata.size, (const char *)checkpoint_metadata.data);
+        testutil_check(conn->reconfigure(conn, config));
+        printf("--- [Follower] Picked up checkpoint (metadata=[%.*s],timestamp(hex)=%" PRIx64
+               ") ---\n",
+          (int)checkpoint_metadata.size, (const char *)checkpoint_metadata.data, checkpoint_ts);
+    }
+    free(checkpoint_metadata.mem);
+    wt_wrap_close_session(session);
+    testutil_check(page_log->terminate(page_log, NULL));
+}
+
 /*
  * follower --
  *     Periodically check for a new checkpoint from the leader, and reconfigure to use it.
@@ -37,6 +79,7 @@ follower(void *arg)
 {
     SAP sap;
     WT_CONNECTION *conn;
+    WT_DECL_RET;
     WT_ITEM checkpoint_metadata;
     WT_PAGE_LOG *page_log;
     WT_SESSION *session;
@@ -60,16 +103,26 @@ follower(void *arg)
          * shared memory or pipe) so it can be picked up. Required once we start running against the
          * library version of PALI, which doesn't implement pl_get_complete_checkpoint_ext().
          */
-        testutil_check(page_log->pl_get_complete_checkpoint_ext(
+        ret = page_log->pl_get_complete_checkpoint_ext(
-          page_log, session, NULL, NULL, &checkpoint_ts, &checkpoint_metadata));
+          page_log, session, NULL, NULL, &checkpoint_ts, &checkpoint_metadata);
+        testutil_check_error_ok(ret, WT_NOTFOUND);
         /* Only reconfigure if there's a new checkpoint. */
-        if (g.last_checkpoint_ts != checkpoint_ts) {
+        if (ret != WT_NOTFOUND) {
-            testutil_snprintf(config, sizeof(config), "disaggregated=(checkpoint_meta=\"%.*s\")",
+            if (g.checkpoint_metadata[0] == '\0' ||
-              (int)checkpoint_metadata.size, (const char *)checkpoint_metadata.data);
+              memcmp(g.checkpoint_metadata, (const char *)checkpoint_metadata.data,
-            testutil_check(conn->reconfigure(conn, config));
+                checkpoint_metadata.size) != 0) {
-            printf("--- [Follower] Picked up checkpoint (LSN=%.*s,timestamp=%" PRIu64 ") ---\n",
+                testutil_snprintf(config, sizeof(config),
-              (int)checkpoint_metadata.size, (const char *)checkpoint_metadata.data, checkpoint_ts);
+                  "disaggregated=(checkpoint_meta=\"%.*s\")", (int)checkpoint_metadata.size,
-            g.last_checkpoint_ts = checkpoint_ts;
+                  (const char *)checkpoint_metadata.data);
+                testutil_check(conn->reconfigure(conn, config));
+                printf(
+                  "--- [Follower] Picked up checkpoint (metadata=[%.*s],timestamp(hex)=%" PRIx64
+                  ") ---\n",
+                  (int)checkpoint_metadata.size, (const char *)checkpoint_metadata.data,
+                  checkpoint_ts);
+                testutil_snprintf(g.checkpoint_metadata, sizeof(g.checkpoint_metadata), "%.*s",
+                  (int)checkpoint_metadata.size, (const char *)checkpoint_metadata.data);
+            }
         }
         period = mmrand(&g.extra_rnd, 1, 3);
         while (period > 0 && !g.workers_finished) {
@@ -77,8 +130,9 @@ follower(void *arg)
             __wt_sleep(1, 0);
         }
     }
-
+    free(checkpoint_metadata.mem);
     wt_wrap_close_session(session);
+    testutil_check(page_log->terminate(page_log, NULL));
 
     return (WT_THREAD_RET_VALUE);
 }

src/third_party/wiredtiger/test/format/format.h

@@ -310,9 +310,9 @@ typedef struct {
 #define PREFIX_LEN_CONFIG_MAX 80
     uint32_t prefix_len_max;
 
-    bool disagg_leader;          /* If disaggregated storage role is configured as a leader. */
+    bool disagg_leader; /* If disaggregated storage role is configured as a leader. */
-    pid_t follower_pid;          /* For multi-node disagg follower process */
+    pid_t follower_pid; /* For multi-node disagg follower process */
-    uint64_t last_checkpoint_ts; /* Last checkpoint timestamp picked up by follower. */
+    char checkpoint_metadata[FILENAME_MAX]; /* Last checkpoint metadata picked up by follower. */
 
     bool column_store_config;           /* At least one column-store table configured */
     bool disagg_storage_config;         /* If disaggregated storage is configured */
@@ -463,10 +463,11 @@ void cursor_dump_page(WT_CURSOR *, const char *);
 bool disagg_is_mode_switch(void);
 bool disagg_is_multi_node(void);
 void disagg_setup_multi_node(void);
-int disagg_switch_roles(void);
+void disagg_switch_roles(void);
 void disagg_teardown_multi_node(void);
 bool enable_session_prefetch(void);
 void fclose_and_clear(FILE **);
+void follower_read_latest_checkpoint(void);
 void key_gen_common(TABLE *, WT_ITEM *, uint64_t, const char *);
 void key_gen_init(WT_ITEM *);
 void key_gen_teardown(WT_ITEM *);

src/third_party/wiredtiger/test/format/format_disagg.c

@@ -83,6 +83,7 @@ disagg_setup_multi_node(void)
         return;
 
     testutil_snprintf(follower_home, sizeof(follower_home), "%s/follower", g.home);
+    memset(&g.checkpoint_metadata, 0, sizeof(g.checkpoint_metadata));
 
     /*
      * Create required dir before forking to avoid parent/child races. Skip on reopen, since the run
@@ -143,21 +144,24 @@ disagg_is_mode_switch(void)
  * disagg_switch_roles --
  *     Toggle the current disagg role between "leader" and "follower",
  */
-int
+void
 disagg_switch_roles(void)
 {
     char disagg_cfg[64];
 
-    g.disagg_leader = !g.disagg_leader;
     /*
      * FIXME-WT-15763: WT does not yet support graceful step-downs. Simply reconfiguring WT to step
      * down may cause issues, so we reopen the connection when switching to follower mode.
      */
-    if (!g.disagg_leader)
+    if (g.disagg_leader)
         wts_reopen();
 
+    /* Perform step-up or step-down. */
+    g.disagg_leader = !g.disagg_leader;
     testutil_snprintf(disagg_cfg, sizeof(disagg_cfg), "disaggregated=(role=\"%s\")",
       g.disagg_leader ? "leader" : "follower");
+    testutil_check(g.wts_conn->reconfigure(g.wts_conn, disagg_cfg));
 
-    return (g.wts_conn->reconfigure(g.wts_conn, disagg_cfg));
+    if (!g.disagg_leader)
+        follower_read_latest_checkpoint();
 }

src/third_party/wiredtiger/test/format/format_disagg_multi.sh

@@ -41,8 +41,6 @@ fi
 PROG="./t"
 CONFIG="../../../test/format/CONFIG.disagg"
 DISAGG_MULTI_CONFIG="disagg.multi=1 runs.predictable_replay=1 "
-# FIXME-WT-14566 Limit some configs for now.
-LIMIT_CONFIG="runs.timer=1 runs.rows=10000"
 LEADER_LOG="$home_dir/leader.out"
 FOLLOWER_LOG="$home_dir/follower/follower.out"
 SESSION_NAME="format_disagg_multi_node"

src/third_party/wiredtiger/test/format/format_util.c

@@ -123,7 +123,7 @@ track_ops(TINFO *tinfo)
           track_ts_dots(cur_dot_cnt));
     }
     testutil_snprintf_len_set(msg, sizeof(msg), &len,
-      "ops: "
+      "ops%s: "
       "S %" PRIu64
       "%s, "
       "I %" PRIu64
@@ -135,6 +135,7 @@ track_ops(TINFO *tinfo)
       "M %" PRIu64
       "%s, "
       "T %" PRIu64 "%s%s",
+      g.disagg_storage_config ? g.disagg_leader ? "[Leader]" : "[Follower]" : "",
       tinfo->search > M(9) ? tinfo->search / M(1) : tinfo->search, tinfo->search > M(9) ? "M" : "",
       tinfo->insert > M(9) ? tinfo->insert / M(1) : tinfo->insert, tinfo->insert > M(9) ? "M" : "",
       tinfo->update > M(9) ? tinfo->update / M(1) : tinfo->update, tinfo->update > M(9) ? "M" : "",

src/third_party/wiredtiger/test/format/t.c

@@ -405,7 +405,7 @@ main(int argc, char *argv[])
         for (reps = 1; reps <= (FORMAT_OPERATION_REPS * 2); ++reps) {
             ops_seconds = g.disagg_leader ? leader_ops_seconds : DISAGG_SWITCH_FOLLOWER_OPS_SEC;
             operations(ops_seconds, reps, (FORMAT_OPERATION_REPS * 2));
-            testutil_check(disagg_switch_roles());
+            disagg_switch_roles();
         }
     }
 

src/third_party/wiredtiger/test/format/wts.c

@@ -868,6 +868,16 @@ wts_close(WT_CONNECTION **connp)
 void
 wts_reopen(void)
 {
+    SAP sap;
+    WT_SESSION *session;
+
+    if (GV(PRECISE_CHECKPOINT)) {
+        memset(&sap, 0, sizeof(sap));
+        wt_wrap_open_session(g.wts_conn, &sap, NULL, NULL, &session);
+        timestamp_once(session, false, false);
+        wt_wrap_close_session(session);
+    }
+
     wts_close(&g.wts_conn);
     wts_open(g.home, &g.wts_conn, false);
 }

src/third_party/wiredtiger/test/suite/hook_disagg.fail

@@ -2,29 +2,12 @@
 # This list are test files that are not run, they are known failures. The reasons for the failures are not known,
 # they'll need to be triaged. When we know something about the failure, they are commented.
 test_autoclose.py
-test_base02.py
-test_base04.py  # FIXME: WT-15417
-test_bug003.py
-test_bug004.py  # page verify failed
-test_bug005.py
-test_bug006.py
-test_bug010.py
-test_bug027.py
-test_bulk01.py
-test_bulk02.py
 test_checkpoint06.py # FIXME: WT-15507
 test_config02.py
 test_config09.py
-test_config10.py
-test_config12.py
-test_cursor01.py
-test_cursor06.py  # FIXME: WT-15417
 test_cursor17.py  # FIXME: WT-15418
 test_cursor21.py  # FIXME: WT-15369
-test_debug_mode08.py
-test_drop.py
 test_drop03.py
-test_drop_create.py
 test_dump.py
 test_dump01.py
 test_dump02.py
@@ -32,7 +15,6 @@ test_dump03.py
 test_dump04.py
 test_dump05.py
 test_dupc.py
-test_durability01.py
 test_durable_ts01.py  # FIXME: WT-15370
 test_durable_ts03.py
 test_empty.py
@@ -40,58 +22,30 @@ test_encrypt06.py
 test_env01.py
 test_error_info01.py
 test_error_info03.py
-test_eviction02.py
-test_eviction03.py
 test_hs01.py  # FIXME: WT-15371
-test_hs06.py
-test_hs09.py
 test_hs18.py
 test_hs21.py
 test_hs24.py
 test_hs30.py
-test_hs32.py
 test_hs_evict_race01.py
 test_log03.py
 test_metadata_cursor01.py
-test_metadata_cursor02.py
-test_metadata_cursor03.py
 test_metadata_cursor04.py
-test_prefetch01.py
-test_prefetch02.py
 test_prepare03.py
-test_prepare11.py
-test_prepare13.py
 test_prepare28.py
 test_prepare29.py
 test_prepare_cursor01.py
-test_prepare_hs02.py
 test_prepare_hs03.py
 test_prepare_hs04.py
 test_readonly01.py
 test_readonly03.py  # WT-14582
 test_shared_cache01.py
 test_stat01.py
-test_stat02.py
-test_stat03.py
-test_stat04.py
-test_stat05.py
-test_stat13.py
-test_stat_log01.py
 test_stat_log02.py
-test_sweep03.py  # FIXME: WT-15417
-test_timestamp20.py
 test_truncate01.py # FIXME: WT-15474
 test_truncate21.py # FIXME: WT-15472
 test_truncate24.py # FIXME: WT-15473
-test_txn02.py
-test_txn04.py
 test_txn06.py
-test_txn08.py
-test_txn09.py
-test_txn10.py
-test_txn14.py
-test_txn16.py
-test_txn18.py
 test_txn22.py
 test_util01.py
 test_util02.py
@@ -104,9 +58,6 @@ test_util13.py
 test_util14.py
 test_util15.py
 test_util17.py
-test_util18.py
-test_util22.py
 test_verbose01.py  # FIXME: WT-15372
 test_verbose02.py
-test_verbose03.py
 test_verbose04.py

src/third_party/wiredtiger/test/suite/hook_tiered.py

@@ -296,7 +296,9 @@ class TieredHookCreator(wthooks.WiredTigerHookCreator):
     def should_skip(self, test) -> (bool, str):
         skip_categories = [
             ("backup",               "Can't backup a tiered table"),
+            ("disagg",               "Disagg tests are not supported with tiered storage"),
             ("inmem",                "In memory tests don't make sense with tiered storage"),
+            ("layered",              "Layered tests are not supported with tiered storage"),
             ("live_restore",         "Live restore is not supported with tiered storage"),
             ("modify_smoke_recover", "Copying WT dir doesn't copy the bucket directory"),
             ("test_config_json",     "Tiered hook's create function can't handle a json config string"),

src/third_party/wiredtiger/test/suite/test_layered15.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered15.py
 #    Start without local files.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered15(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered17.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered17.py
 #    Check timestamps.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered17(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered18.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered18.py
 #    Create long delta chains.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered18(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered25.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered25.py
 #    Start without local files and test historical reads.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered25(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered26.py

@@ -33,7 +33,6 @@ from wtscenario import make_scenarios
 # test_layered26.py
 #    Make sure a secondary picking up a checkpoint adds in the stable
 #    component of the table.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered26(wttest.WiredTigerTestCase):
     nitems = 5000

src/third_party/wiredtiger/test/suite/test_layered27.py

@@ -33,7 +33,6 @@ from wtscenario import make_scenarios
 
 # test_layered27.py
 # Test draining the ingest table
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered27(wttest.WiredTigerTestCase):
     conn_base_config = ',create,statistics=(all),statistics_log=(wait=1,json=true,on_close=true),' \

src/third_party/wiredtiger/test/suite/test_layered30.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered30.py
 #    Test creating empty tables.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered30(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered34.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered34.py
 #    Test materialization frontier.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered34(wttest.WiredTigerTestCase):
     conn_base_config = 'statistics=(all),' \

src/third_party/wiredtiger/test/suite/test_layered36.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered36.py
 #    Test creating missing stable tables.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered36(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered38.py

@@ -33,7 +33,6 @@ from wtscenario import make_scenarios
 
 # test_layered38.py
 # Test garbage collecting redundant content in the ingest table
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered38(wttest.WiredTigerTestCase):
     conn_base_config = ',create,cache_size=10GB,statistics=(all),statistics_log=(wait=1,json=true,on_close=true),' \

src/third_party/wiredtiger/test/suite/test_layered40.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered40.py
 #    Test layered table metadata has logging disabled.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered40(wttest.WiredTigerTestCase):
     conn_config = 'log=(enabled=true),disaggregated=(role="leader"),'

src/third_party/wiredtiger/test/suite/test_layered43.py

@@ -33,7 +33,6 @@ from wiredtiger import stat
 
 # test_layered43.py
 #    Test disaggregated storage with block cache.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered43(wttest.WiredTigerTestCase):
     nitems = 500

src/third_party/wiredtiger/test/suite/test_layered60.py

@@ -32,7 +32,6 @@ from wtscenario import make_scenarios
 
 # test_layered60.py
 #    Test creating empty tables while a checkpoint is running.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered60(wttest.WiredTigerTestCase):
     conn_base_config = 'statistics=(all),' \

src/third_party/wiredtiger/test/suite/test_layered62.py

@@ -44,7 +44,6 @@ from wtscenario import make_scenarios
 # change happened after the checkpoint started.
 #
 @disagg_test_class
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 class test_layered62(wttest.WiredTigerTestCase):
     conn_base_config = 'statistics=(all),' \
                      + 'statistics_log=(wait=1,json=true,on_close=true),' \

src/third_party/wiredtiger/test/suite/test_layered64.py

@@ -33,7 +33,6 @@ from wtscenario import make_scenarios
 # test_layered64.py
 #    Test the checksum part of the checkpoint metadata.
 @disagg_test_class
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 class test_layered64(wttest.WiredTigerTestCase):
     conn_base_config = 'statistics=(all),' \
                      + 'statistics_log=(wait=1,json=true,on_close=true),' \

src/third_party/wiredtiger/test/suite/test_layered65.py

@@ -35,7 +35,6 @@ from wiredtiger import stat
 #    Test garbage collection ensures that prepared updates and aborted
 #    prepared updates are not removed if the rollback timestamps are newer than
 #    the checkpoint timestamp of the stable table.
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 @disagg_test_class
 class test_layered65(wttest.WiredTigerTestCase):
     base_config = 'statistics=(all),precise_checkpoint=true,preserve_prepared=true,'

src/third_party/wiredtiger/test/suite/test_layered68.py

@@ -33,7 +33,6 @@ from wtscenario import make_scenarios
 # test_layered68.py
 #    Test that address cookies in disaggregated storage can be upgraded/downgraded safely.
 @disagg_test_class
-@wttest.skip_for_hook("tiered", "FIXME-WT-14938: crashing with tiered hook.")
 class test_layered68(wttest.WiredTigerTestCase):
     conn_base_config = 'statistics=(all),' \
                      + 'statistics_log=(wait=1,json=true,on_close=true),' \

src/third_party/wiredtiger/test/suite/tsan.fail

@@ -64,3 +64,4 @@ test_truncate11.py
 test_truncate15.py
 test_truncate19.py
 test_txn24.py
+test_verbose03.py # FIXME-WT-15978