Import wiredtiger: 7bfbedde948aee7a58f325dac6bb3e4b18d5a871 from branch mongodb-7.0 (#31884)

GitOrigin-RevId: 9365884c2e63715cadda89fcaba9036a069cb161

Author: wt-vendoring-bot[bot]

src/third_party/wiredtiger/dist/s_string.ok

@@ -1124,6 +1124,7 @@ recurse
 reentrant
 refp
 regionp
+reinstantiated
 relocked
 repl
 repositioned

src/third_party/wiredtiger/import.data

@@ -2,5 +2,5 @@
     "vendor": "wiredtiger",
     "github": "wiredtiger/wiredtiger",
     "branch": "mongodb-7.0",
-    "commit": "f49c810f58d706c592a7aa54ae44c3dd0c3f3bb9"
+    "commit": "7bfbedde948aee7a58f325dac6bb3e4b18d5a871"
 }

src/third_party/wiredtiger/src/btree/bt_page.c

@@ -143,7 +143,6 @@ __page_inmem_prepare_update(WT_SESSION_IMPL *session, WT_ITEM *value, WT_CELL_UN
     upd->durable_ts = unpack->tw.durable_start_ts;
     upd->start_ts = unpack->tw.start_ts;
     upd->txnid = unpack->tw.start_txn;
-    F_SET(upd, WT_UPDATE_PREPARE_RESTORED_FROM_DS);
 
     /*
      * Instantiate both update and tombstone if the prepared update is a tombstone. This is required
@@ -169,13 +168,16 @@ __page_inmem_prepare_update(WT_SESSION_IMPL *session, WT_ITEM *value, WT_CELL_UN
           unpack->tw.start_txn == unpack->tw.stop_txn) {
             upd->durable_ts = WT_TS_NONE;
             upd->prepare_state = WT_PREPARE_INPROGRESS;
-        }
+            F_SET(upd, WT_UPDATE_PREPARE_RESTORED_FROM_DS);
+        } else
+            F_SET(upd, WT_UPDATE_RESTORED_FROM_DS);
 
         tombstone->next = upd;
         *updp = tombstone;
     } else {
         upd->durable_ts = WT_TS_NONE;
         upd->prepare_state = WT_PREPARE_INPROGRESS;
+        F_SET(upd, WT_UPDATE_PREPARE_RESTORED_FROM_DS);
         *updp = upd;
     }
 

src/third_party/wiredtiger/src/include/extern.h

@@ -2525,6 +2525,8 @@ extern int __ut_ovfl_discard_verbose(WT_SESSION_IMPL *session, WT_PAGE *page, WT
   const char *tag) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __ut_ovfl_discard_wrapup(WT_SESSION_IMPL *session, WT_PAGE *page)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __ut_session_config_int(WT_SESSION_IMPL *session, const char *config)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern void __ut_block_off_srch(WT_EXT **head, wt_off_t off, WT_EXT ***stack, bool skip_off);
 extern void __ut_block_size_srch(WT_SIZE **head, wt_off_t size, WT_SIZE ***stack);
 

src/third_party/wiredtiger/src/reconcile/rec_visibility.c

@@ -70,12 +70,15 @@ static int
 __rec_append_orig_value(
   WT_SESSION_IMPL *session, WT_PAGE *page, WT_UPDATE *upd, WT_CELL_UNPACK_KV *unpack)
 {
+    WT_CONNECTION_IMPL *conn;
     WT_DECL_ITEM(tmp);
     WT_DECL_RET;
     WT_UPDATE *append, *oldest_upd, *tombstone;
     size_t size, total_size;
     bool tombstone_globally_visible;
 
+    conn = S2C(session);
+
     WT_ASSERT_ALWAYS(session,
       upd != NULL && unpack != NULL && unpack->type != WT_CELL_DEL && !unpack->tw.prepare,
       "__rec_append_orig_value requires an onpage, non-prepared update");
@@ -105,7 +108,7 @@ __rec_append_orig_value(
          * its transaction id to WT_TXN_NONE and its timestamps to WT_TS_NONE when we write the
          * update to the time window.
          */
-        if (F_ISSET(S2C(session), WT_CONN_IN_MEMORY) && unpack->tw.start_ts == upd->start_ts &&
+        if (F_ISSET(conn, WT_CONN_IN_MEMORY) && unpack->tw.start_ts == upd->start_ts &&
           unpack->tw.start_txn == upd->txnid && upd->type != WT_UPDATE_TOMBSTONE)
             return (0);
 
@@ -160,7 +163,15 @@ __rec_append_orig_value(
 
             WT_ERR(__wt_upd_alloc_tombstone(session, &tombstone, &size));
             total_size += size;
-            tombstone->txnid = unpack->tw.stop_txn;
+            /*
+             * When reconciling during recovery, we need to clear the transaction id as we haven't
+             * done so when we read the page into memory to avoid using the transaction id from the
+             * previous run.
+             */
+            if (F_ISSET(conn, WT_CONN_RECOVERING))
+                tombstone->txnid = WT_TXN_NONE;
+            else
+                tombstone->txnid = unpack->tw.stop_txn;
             tombstone->start_ts = unpack->tw.stop_ts;
             tombstone->durable_ts = unpack->tw.durable_stop_ts;
             F_SET(tombstone, WT_UPDATE_RESTORED_FROM_DS);
@@ -190,7 +201,15 @@ __rec_append_orig_value(
           unpack->cell == NULL || __wt_cell_type_raw(unpack->cell) != WT_CELL_VALUE_OVFL_RM);
         WT_ERR(__wt_upd_alloc(session, tmp, WT_UPDATE_STANDARD, &append, &size));
         total_size += size;
-        append->txnid = unpack->tw.start_txn;
+        /*
+         * When reconciling during recovery, we need to clear the transaction id as we haven't done
+         * so when we read the page into memory to avoid using the transaction id from the previous
+         * run.
+         */
+        if (F_ISSET(conn, WT_CONN_RECOVERING))
+            append->txnid = WT_TXN_NONE;
+        else
+            append->txnid = unpack->tw.start_txn;
         append->start_ts = unpack->tw.start_ts;
         append->durable_ts = unpack->tw.durable_start_ts;
         F_SET(append, WT_UPDATE_RESTORED_FROM_DS);
@@ -758,7 +777,8 @@ __rec_fill_tw_from_upd_select(
          */
         if (last_upd->next != NULL) {
             WT_ASSERT_ALWAYS(session,
-              last_upd->next->txnid == vpack->tw.start_txn &&
+              last_upd->next->txnid ==
+                  (F_ISSET(S2C(session), WT_CONN_RECOVERING) ? WT_TXN_NONE : vpack->tw.start_txn) &&
                 last_upd->next->start_ts == vpack->tw.start_ts &&
                 last_upd->next->type == WT_UPDATE_STANDARD && last_upd->next->next == NULL,
               "Tombstone is globally visible, but the tombstoned update is on the update "

src/third_party/wiredtiger/src/rollback_to_stable/rts_btree.c

@@ -68,12 +68,28 @@ __rts_btree_abort_update(WT_SESSION_IMPL *session, WT_ITEM *key, WT_UPDATE *firs
         }
     }
 
-    /*
-     * Clear the history store flags for the stable update to indicate that this update should be
-     * written to the history store later. The next time when this update is moved into the history
-     * store, it will have a different stop time point.
-     */
     if (stable_upd != NULL) {
+        /*
+         * During recovery, there shouldn't be any updates in the update chain except when the
+         * updates are from a prepared transaction or from a reinstantiated fast deleted page. Reset
+         * the transaction ID of the stable update that was restored. Ignore the history store as we
+         * cannot have a prepared transaction on it and a fast deleted page in the history store
+         * should never be reinstantiated as it is globally visible.
+         */
+        if (F_ISSET(S2C(session), WT_CONN_RECOVERING) && !WT_IS_HS(session->dhandle)) {
+            WT_ASSERT(session, first_upd->type == WT_UPDATE_TOMBSTONE);
+            WT_ASSERT(session,
+              F_ISSET(
+                first_upd, WT_UPDATE_PREPARE_RESTORED_FROM_DS | WT_UPDATE_RESTORED_FAST_TRUNCATE));
+            WT_ASSERT(session, stable_upd->next == NULL);
+            stable_upd->txnid = WT_TXN_NONE;
+        }
+
+        /*
+         * Clear the history store flags for the stable update to indicate that this update should
+         * be written to the history store later. The next time when this update is moved into the
+         * history store, it will have a different stop time point.
+         */
         if (F_ISSET(stable_upd, WT_UPDATE_HS | WT_UPDATE_TO_DELETE_FROM_HS)) {
             /* Find the update following a stable tombstone. */
             if (stable_upd->type == WT_UPDATE_TOMBSTONE) {

src/third_party/wiredtiger/src/session/session_api.c

@@ -427,48 +427,32 @@ __wt_session_close_internal(WT_SESSION_IMPL *session)
 }
 
 /*
- * __session_reconfigure --
- *     WT_SESSION->reconfigure method.
+ * __session_config_int --
+ *     Configure basic flags and values on the session. Tested via a unit test.
  */
 static int
-__session_reconfigure(WT_SESSION *wt_session, const char *config)
+__session_config_int(WT_SESSION_IMPL *session, const char *config)
 {
     WT_CONFIG_ITEM cval;
     WT_DECL_RET;
-    WT_SESSION_IMPL *session;
-
-    session = (WT_SESSION_IMPL *)wt_session;
-    SESSION_API_CALL_PREPARE_NOT_ALLOWED(session, reconfigure, config, cfg);
-    WT_UNUSED(cfg);
-
-    WT_ERR(__wt_txn_context_check(session, false));
 
-    WT_ERR(__wt_session_reset_cursors(session, false));
-
-    /*
-     * Note that this method only checks keys that are passed in by the application: we don't want
-     * to reset other session settings to their default values.
-     */
-    WT_ERR(__wt_txn_reconfigure(session, config));
-
-    ret = __wt_config_getones(session, config, "ignore_cache_size", &cval);
-    if (ret == 0) {
+    if ((ret = __wt_config_getones(session, config, "ignore_cache_size", &cval)) == 0) {
         if (cval.val)
             F_SET(session, WT_SESSION_IGNORE_CACHE_SIZE);
         else
             F_CLR(session, WT_SESSION_IGNORE_CACHE_SIZE);
     }
-    WT_ERR_NOTFOUND_OK(ret, false);
+    WT_RET_NOTFOUND_OK(ret);
 
-    ret = __wt_config_getones(session, config, "cache_cursors", &cval);
-    if (ret == 0) {
+    if ((ret = __wt_config_getones(session, config, "cache_cursors", &cval)) == 0) {
         if (cval.val)
             F_SET(session, WT_SESSION_CACHE_CURSORS);
         else {
             F_CLR(session, WT_SESSION_CACHE_CURSORS);
-            WT_ERR(__session_close_cached_cursors(session));
+            WT_RET(__session_close_cached_cursors(session));
         }
     }
+    WT_RET_NOTFOUND_OK(ret);
 
     /*
      * There is a session debug configuration which can be set to evict pages as they are released
@@ -480,15 +464,41 @@ __session_reconfigure(WT_SESSION *wt_session, const char *config)
         else
             F_CLR(session, WT_SESSION_DEBUG_RELEASE_EVICT);
     }
+    WT_RET_NOTFOUND_OK(ret);
 
-    WT_ERR_NOTFOUND_OK(ret, false);
-
-    ret = __wt_config_getones(session, config, "cache_max_wait_ms", &cval);
-    if (ret == 0 && cval.val)
+    if ((ret = __wt_config_getones(session, config, "cache_max_wait_ms", &cval)) == 0)
         session->cache_max_wait_us = (uint64_t)(cval.val * WT_THOUSAND);
-    WT_ERR_NOTFOUND_OK(ret, false);
+    WT_RET_NOTFOUND_OK(ret);
+
+    return (0);
+}
+
+/*
+ * __session_reconfigure --
+ *     WT_SESSION->reconfigure method.
+ */
+static int
+__session_reconfigure(WT_SESSION *wt_session, const char *config)
+{
+    WT_DECL_RET;
+    WT_SESSION_IMPL *session;
+
+    session = (WT_SESSION_IMPL *)wt_session;
+    SESSION_API_CALL_PREPARE_NOT_ALLOWED(session, reconfigure, config, cfg);
+    WT_UNUSED(cfg);
+
+    WT_ERR(__wt_txn_context_check(session, false));
+
+    WT_ERR(__wt_session_reset_cursors(session, false));
+
+    /*
+     * Note that this method only checks keys that are passed in by the application: we don't want
+     * to reset other session settings to their default values.
+     */
+    WT_ERR(__wt_txn_reconfigure(session, config));
+
+    WT_ERR(__session_config_int(session, config));
 
-    WT_ERR_NOTFOUND_OK(ret, false);
 err:
     API_END_RET_NOTFOUND_MAP(session, ret);
 }
@@ -2688,3 +2698,11 @@ __wt_open_internal_session(WT_CONNECTION_IMPL *conn, const char *name, bool open
     *sessionp = session;
     return (0);
 }
+
+#ifdef HAVE_UNITTEST
+int
+__ut_session_config_int(WT_SESSION_IMPL *session, const char *config)
+{
+    return (__session_config_int(session, config));
+}
+#endif

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

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+#
+# 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.
+
+import wttest
+from helper import simulate_crash_restart
+from wtscenario import make_scenarios
+
+# test_prepare29.py
+# Test that updates preceding an unstable prepared tombstone are restored with the correct
+# transaction IDs.
+class test_prepare29(wttest.WiredTigerTestCase):
+
+    format_values = [
+        ('column', dict(key_format='r', key=1, value_format='S')),
+        ('column-fix', dict(key_format='r', key=1, value_format='8t')),
+        ('string-row', dict(key_format='S', key=str(1), value_format='S')),
+    ]
+
+    scenarios = make_scenarios(format_values)
+
+    def evict_cursor(self, uri, key):
+        session_evict = self.conn.open_session("debug=(release_evict_page=true)")
+        session_evict.begin_transaction("ignore_prepare=true")
+        cursor = session_evict.open_cursor(uri, None, None)
+        cursor.set_key(key)
+        cursor.search()
+        cursor.reset()
+        cursor.close()
+        session_evict.rollback_transaction()
+
+    def test_prepare29(self):
+        uri = 'table:test_prepare29'
+        create_params = 'key_format={},value_format={}'.format(self.key_format, self.value_format)
+        self.session.create(uri, create_params)
+
+        if self.value_format == '8t':
+            value1 = 97
+        else:
+            value1 = 'a' * 5
+
+        # Pin oldest timestamp.
+        self.conn.set_timestamp('oldest_timestamp=' + self.timestamp_str(1))
+
+        # Insert some data.
+        ts = 100
+        cursor = self.session.open_cursor(uri)
+        key = self.key
+        self.session.begin_transaction()
+        cursor[key] = value1
+        self.session.commit_transaction('commit_timestamp=' + self.timestamp_str(ts))
+
+        # Update stable timestamp and checkpoint.
+        ts = 200
+        self.conn.set_timestamp('stable_timestamp=' + self.timestamp_str(ts))
+        self.session.checkpoint()
+
+        # Remove the previously inserted key in a prepared transaction.
+        ts = 300
+        self.session.begin_transaction()
+        cursor.set_key(key)
+        cursor.remove()
+        self.session.prepare_transaction('prepare_timestamp=' + self.timestamp_str(ts))
+        cursor.reset()
+        cursor.close()
+
+        # Evict the key.
+        self.evict_cursor(uri, key)
+        session = self.conn.open_session("")
+        session.checkpoint()
+
+        # Perform an unclean shutdown. The last remove operation is unstable and unresolved.
+        simulate_crash_restart(self, '.', 'RESTART')
+
+        # Try to perform an operation in a transaction that is after the stable timestamp.
+        # We should get a WT_ROLLBACK error due to the write conflict if we don't properly
+        # reset the txn ID.
+        cursor = self.session.open_cursor(uri)
+        self.session.begin_transaction()
+        cursor.set_key(key)
+        cursor.remove()
+
+        self.session.commit_transaction('commit_timestamp=' + self.timestamp_str(201))