summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJosef Ahmad <josef.ahmad@mongodb.com>2022-01-28 11:07:58 +0000
committerEvergreen Agent <no-reply@evergreen.mongodb.com>2023-01-18 11:34:36 +0000
commit1b7e12704065cfd1e85189d05f73b9e9f2e7d90f (patch)
tree0be180174830fbd68b59cf736e6d84474ef8b33e
parent49aae350729f4ef6d46904b7cf53ac51a7bf7ca2 (diff)
downloadmongo-1b7e12704065cfd1e85189d05f73b9e9f2e7d90f.tar.gz
SERVER-72910: Partial backport SERVER-60839 Make wtRCToStatus require a WT_SESSION pointer
This is groundwork for further differentiating WT return codes. (cherry picked from commit f4aaa34d623e7385b2ac5b332ee07ece1f22c428)
Diffstat
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp7
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp5
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_cursor.cpp2
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp69
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_index.h6
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp99
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp102
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test_harness.cpp4
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp12
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp27
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp33
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_session_cache_test.cpp2
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.cpp12
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp6
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp2
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp21
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_util.h60
-rw-r--r--src/mongo/db/storage/wiredtiger/wiredtiger_util_test.cpp10
18 files changed, 259 insertions, 220 deletions
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp
index 45acf82f307..c157a280009 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp
@@ -72,14 +72,14 @@ WiredTigerBeginTxnBlock::WiredTigerBeginTxnBlock(
}
const std::string beginTxnConfigString = builder;
- invariantWTOK(_session->begin_transaction(_session, beginTxnConfigString.c_str()));
+ invariantWTOK(_session->begin_transaction(_session, beginTxnConfigString.c_str()), _session);
_rollback = true;
}
WiredTigerBeginTxnBlock::WiredTigerBeginTxnBlock(WT_SESSION* session, const char* config)
: _session(session) {
invariant(!_rollback);
- invariantWTOK(_session->begin_transaction(_session, config));
+ invariantWTOK(_session->begin_transaction(_session, config), _session);
_rollback = true;
}
@@ -92,7 +92,8 @@ WiredTigerBeginTxnBlock::~WiredTigerBeginTxnBlock() {
Status WiredTigerBeginTxnBlock::setReadSnapshot(Timestamp readTimestamp) {
invariant(_rollback);
return wtRCToStatus(
- _session->timestamp_transaction_uint(_session, WT_TS_TXN_TYPE_READ, readTimestamp.asULL()));
+ _session->timestamp_transaction_uint(_session, WT_TS_TXN_TYPE_READ, readTimestamp.asULL()),
+ _session);
}
void WiredTigerBeginTxnBlock::done() {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp
index 933b5aa2990..63252e2ffb6 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp
@@ -57,7 +57,7 @@ public:
ss << extraStrings;
std::string config = ss.str();
int ret = wiredtiger_open(dbpath.toString().c_str(), nullptr, config.c_str(), &_conn);
- invariant(wtRCToStatus(ret).isOK());
+ invariant(wtRCToStatus(ret, nullptr).isOK());
}
~WiredTigerConnection() {
_conn->close(_conn, nullptr);
@@ -79,7 +79,8 @@ public:
_opCtx.reset(newOperationContext());
auto ru = WiredTigerRecoveryUnit::get(_opCtx.get());
_wtSession = ru->getSession()->getSession();
- invariant(wtRCToStatus(_wtSession->create(_wtSession, "table:mytable", nullptr)).isOK());
+ invariant(wtRCToStatus(_wtSession->create(_wtSession, "table:mytable", nullptr), _wtSession)
+ .isOK());
ru->abandonSnapshot();
}
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_cursor.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_cursor.cpp
index f65f0b4d674..6d39a8cfb3a 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_cursor.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_cursor.cpp
@@ -78,6 +78,6 @@ WiredTigerCursor::~WiredTigerCursor() {
}
void WiredTigerCursor::reset() {
- invariantWTOK(_cursor->reset(_cursor));
+ invariantWTOK(_cursor->reset(_cursor), _cursor->session);
}
} // namespace mongo
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
index 504d945445a..dceca914609 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
@@ -110,7 +110,7 @@ void WiredTigerIndex::setKey(WT_CURSOR* cursor, const WT_ITEM* item) {
}
void WiredTigerIndex::getKey(OperationContext* opCtx, WT_CURSOR* cursor, WT_ITEM* key) {
- invariantWTOK(cursor->get_key(cursor, key));
+ invariantWTOK(cursor->get_key(cursor, key), cursor->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneIdxEntryRead(key->size);
@@ -222,22 +222,22 @@ StatusWith<std::string> WiredTigerIndex::generateCreateString(
return StatusWith<std::string>(ss);
}
-int WiredTigerIndex::Create(OperationContext* opCtx,
- const std::string& uri,
- const std::string& config) {
+Status WiredTigerIndex::Create(OperationContext* opCtx,
+ const std::string& uri,
+ const std::string& config) {
// Don't use the session from the recovery unit: create should not be used in a transaction
WiredTigerSession session(WiredTigerRecoveryUnit::get(opCtx)->getSessionCache()->conn());
WT_SESSION* s = session.getSession();
LOGV2_DEBUG(
51780, 1, "create uri: {uri} config: {config}", "uri"_attr = uri, "config"_attr = config);
- return s->create(s, uri.c_str(), config.c_str());
+ return wtRCToStatus(s->create(s, uri.c_str(), config.c_str()), s);
}
-int WiredTigerIndex::Drop(OperationContext* opCtx, const std::string& uri) {
+Status WiredTigerIndex::Drop(OperationContext* opCtx, const std::string& uri) {
WiredTigerSession session(WiredTigerRecoveryUnit::get(opCtx)->getSessionCache()->conn());
WT_SESSION* s = session.getSession();
- return s->drop(s, uri.c_str(), nullptr);
+ return wtRCToStatus(s->drop(s, uri.c_str(), nullptr), s);
}
WiredTigerIndex::WiredTigerIndex(OperationContext* ctx,
@@ -423,7 +423,7 @@ bool WiredTigerIndex::isEmpty(OperationContext* opCtx) {
int ret = wiredTigerPrepareConflictRetry(opCtx, [&] { return c->next(c); });
if (ret == WT_NOTFOUND)
return true;
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
return false;
}
@@ -496,7 +496,7 @@ Status WiredTigerIndex::compact(OperationContext* opCtx) {
str::stream() << "Compaction interrupted on " << uri().c_str()
<< " due to cache eviction pressure");
}
- invariantWTOK(ret);
+ invariantWTOK(ret, s);
}
return Status::OK();
}
@@ -594,7 +594,8 @@ protected:
"error"_attr = wiredtiger_strerror(err),
"index"_attr = idx->uri());
- invariantWTOK(session->open_cursor(session, idx->uri().c_str(), nullptr, nullptr, &cursor));
+ invariantWTOK(session->open_cursor(session, idx->uri().c_str(), nullptr, nullptr, &cursor),
+ session);
return cursor;
}
@@ -631,7 +632,7 @@ public:
_cursor->set_value(_cursor, valueItem.Get());
- invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor));
+ invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor), _cursor->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneIdxEntryWritten(item.size);
@@ -697,7 +698,7 @@ public:
_cursor->set_value(_cursor, valueItem.Get());
- invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor));
+ invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor), _cursor->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
@@ -749,7 +750,7 @@ public:
setKey(_cursor, keyItem.Get());
_cursor->set_value(_cursor, valueItem.Get());
- invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor));
+ invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor), _cursor->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
@@ -962,7 +963,7 @@ protected:
// Don't expect WT_PREPARE_CONFLICT either.
auto ret = c->get_value(c, &item);
invariant(ret != WT_ROLLBACK && ret != WT_PREPARE_CONFLICT);
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
BufReader br(item.data, item.size);
_typeBits.resetFromBuffer(&br);
}
@@ -972,7 +973,7 @@ protected:
}
void getKey(WT_CURSOR* cursor, WT_ITEM* key) {
- invariantWTOK(cursor->get_key(cursor, key));
+ invariantWTOK(cursor->get_key(cursor, key), cursor->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneIdxEntryRead(key->size);
@@ -1026,7 +1027,7 @@ protected:
_cursorAtEof = true;
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
_cursorAtEof = false;
}
@@ -1047,7 +1048,7 @@ protected:
LOGV2_TRACE_CURSOR(20088, "not found");
return false;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneCursorSeek();
@@ -1320,7 +1321,7 @@ private:
// Don't expect WT_PREPARE_CONFLICT either.
auto ret = c->get_value(c, &item);
invariant(ret != WT_ROLLBACK && ret != WT_PREPARE_CONFLICT);
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
BufReader br(item.data, item.size);
_id = KeyString::decodeRecordIdLong(&br);
@@ -1352,7 +1353,7 @@ public:
WT_ITEM item;
auto ret = c->get_value(c, &item);
invariant(ret != WT_ROLLBACK && ret != WT_PREPARE_CONFLICT);
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
BufReader br(item.data, item.size);
_id = KeyString::decodeRecordIdLong(&br);
@@ -1418,7 +1419,7 @@ bool WiredTigerIndexUnique::_keyExists(OperationContext* opCtx,
if (ret == WT_NOTFOUND)
return false;
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
if (cmp == 0)
return true;
@@ -1442,7 +1443,7 @@ bool WiredTigerIndexUnique::_keyExists(OperationContext* opCtx,
if (ret == WT_NOTFOUND) {
return false;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
getKey(opCtx, c, &item);
return std::memcmp(buffer, item.data, std::min(size, item.size)) == 0;
@@ -1474,7 +1475,7 @@ bool WiredTigerIndexUnique::isDup(OperationContext* opCtx,
return false;
}
- fassertFailedWithStatus(40685, wtRCToStatus(ret));
+ fassertFailedWithStatus(40685, wtRCToStatus(ret, c->session));
MONGO_UNREACHABLE;
}
@@ -1521,7 +1522,7 @@ StatusWith<bool> WiredTigerIdIndex::_insert(OperationContext* opCtx,
if (!ret) {
return true;
} else if (ret != WT_DUPLICATE_KEY) {
- return wtRCToStatus(ret);
+ return wtRCToStatus(ret, c->session);
}
auto key = KeyString::toBson(keyString, _ordering);
@@ -1562,14 +1563,14 @@ StatusWith<bool> WiredTigerIndexUnique::_insert(OperationContext* opCtx,
_keyPattern,
_collation);
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
// Remove the prefix key, our entry will continue to conflict with any concurrent
// transactions, but will not conflict with any transaction that begins after this
// operation commits.
setKey(c, prefixKeyItem.Get());
ret = WT_OP_CHECK(wiredTigerCursorRemove(opCtx, c));
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
// Second phase looks up for existence of key to avoid insertion of duplicate key
// The usage of 'prefix_search=true' enables an optimization that allows this search to
@@ -1618,7 +1619,7 @@ StatusWith<bool> WiredTigerIndexUnique::_insert(OperationContext* opCtx,
return false;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
return true;
}
@@ -1643,7 +1644,7 @@ void WiredTigerIdIndex::_unindex(OperationContext* opCtx,
if (ret == WT_NOTFOUND) {
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
@@ -1657,13 +1658,13 @@ void WiredTigerIdIndex::_unindex(OperationContext* opCtx,
if (ret == WT_NOTFOUND) {
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneCursorSeek();
WT_ITEM old;
- invariantWTOK(c->get_value(c, &old));
+ invariantWTOK(c->get_value(c, &old), c->session);
BufReader br(old.data, old.size);
invariant(br.remaining());
@@ -1682,7 +1683,7 @@ void WiredTigerIdIndex::_unindex(OperationContext* opCtx,
// The RecordId matches, so remove the entry.
if (id == idInIndex) {
- invariantWTOK(WT_OP_CHECK(wiredTigerCursorRemove(opCtx, c)));
+ invariantWTOK(WT_OP_CHECK(wiredTigerCursorRemove(opCtx, c)), c->session);
metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
return;
}
@@ -1713,7 +1714,7 @@ void WiredTigerIndexUnique::_unindex(OperationContext* opCtx,
metricsCollector.incrementOneIdxEntryWritten(item.size);
if (ret != WT_NOTFOUND) {
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
return;
}
@@ -1730,7 +1731,7 @@ void WiredTigerIndexUnique::_unindex(OperationContext* opCtx,
if (ret == WT_NOTFOUND) {
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
}
// ------------------------------
@@ -1780,7 +1781,7 @@ StatusWith<bool> WiredTigerIndexStandard::_insert(OperationContext* opCtx,
if (ret == WT_DUPLICATE_KEY) {
return false;
} else if (ret) {
- return wtRCToStatus(ret);
+ return wtRCToStatus(ret, c->session);
}
return true;
@@ -1798,7 +1799,7 @@ void WiredTigerIndexStandard::_unindex(OperationContext* opCtx,
if (ret == WT_NOTFOUND) {
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneIdxEntryWritten(item.size);
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_index.h b/src/mongo/db/storage/wiredtiger/wiredtiger_index.h
index 8c6275593df..3c7c15b961c 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_index.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_index.h
@@ -82,12 +82,14 @@ public:
* Creates a WiredTiger table suitable for implementing a MongoDB index.
* 'config' should be created with generateCreateString().
*/
- static int Create(OperationContext* opCtx, const std::string& uri, const std::string& config);
+ static Status Create(OperationContext* opCtx,
+ const std::string& uri,
+ const std::string& config);
/**
* Drops the specified WiredTiger table. This should only be used for resuming index builds.
*/
- static int Drop(OperationContext* opCtx, const std::string& uri);
+ static Status Drop(OperationContext* opCtx, const std::string& uri);
/**
* Constructs an index. The rsKeyFormat is the RecordId key format of the related RecordStore.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp
index d7d5850290e..f5f69897479 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp
@@ -430,11 +430,11 @@ WiredTigerKVEngine::WiredTigerKVEngine(const std::string& canonicalName,
if (ret == EINVAL) {
fassertFailedNoTrace(28717);
} else if (ret != 0) {
- Status s(wtRCToStatus(ret));
+ Status s(wtRCToStatus(ret, nullptr));
msgasserted(28718, s.reason());
}
start = Date_t::now();
- invariantWTOK(_conn->close(_conn, nullptr));
+ invariantWTOK(_conn->close(_conn, nullptr), nullptr);
LOGV2(4795910,
"WiredTiger closed. Removing journal files",
"duration"_attr = Date_t::now() - start);
@@ -467,7 +467,7 @@ WiredTigerKVEngine::WiredTigerKVEngine(const std::string& canonicalName,
{
char buf[(2 * 8 /*bytes in hex*/) + 1 /*nul terminator*/];
- invariantWTOK(_conn->query_timestamp(_conn, buf, "get=recovery"));
+ invariantWTOK(_conn->query_timestamp(_conn, buf, "get=recovery"), nullptr);
std::uint64_t tmp;
fassert(50758, NumberParser().base(16)(buf, &tmp));
@@ -482,7 +482,7 @@ WiredTigerKVEngine::WiredTigerKVEngine(const std::string& canonicalName,
char buf[(2 * 8 /*bytes in hex*/) + 1 /*nul terminator*/];
int ret = _conn->query_timestamp(_conn, buf, "get=oldest");
if (ret != WT_NOTFOUND) {
- invariantWTOK(ret);
+ invariantWTOK(ret, nullptr);
std::uint64_t tmp;
fassert(5380107, NumberParser().base(16)(buf, &tmp));
@@ -684,7 +684,8 @@ void WiredTigerKVEngine::_openWiredTiger(const std::string& path, const std::str
}
if (!_inRepairMode) {
- LOGV2_FATAL_NOTRACE(28595, "Terminating.", "reason"_attr = wtRCToStatus(ret).reason());
+ LOGV2_FATAL_NOTRACE(
+ 28595, "Terminating.", "reason"_attr = wtRCToStatus(ret, nullptr).reason());
}
// Always attempt to salvage metadata regardless of error code when in repair mode.
@@ -699,7 +700,7 @@ void WiredTigerKVEngine::_openWiredTiger(const std::string& path, const std::str
LOGV2_FATAL_NOTRACE(50947,
"Failed to salvage WiredTiger metadata",
- "details"_attr = wtRCToStatus(ret).reason());
+ "details"_attr = wtRCToStatus(ret, nullptr).reason());
}
void WiredTigerKVEngine::cleanShutdown() {
@@ -772,23 +773,26 @@ void WiredTigerKVEngine::cleanShutdown() {
LOGV2(22324,
"Closing WiredTiger in preparation for reconfiguring",
"closeConfig"_attr = closeConfig);
- invariantWTOK(_conn->close(_conn, closeConfig.c_str()));
+ invariantWTOK(_conn->close(_conn, closeConfig.c_str()), nullptr);
LOGV2(4795905, "WiredTiger closed", "duration"_attr = Date_t::now() - startTime);
startTime = Date_t::now();
- invariantWTOK(wiredtiger_open(
- _path.c_str(), _eventHandler.getWtEventHandler(), _wtOpenConfig.c_str(), &_conn));
+ invariantWTOK(
+ wiredtiger_open(
+ _path.c_str(), _eventHandler.getWtEventHandler(), _wtOpenConfig.c_str(), &_conn),
+ nullptr);
LOGV2(4795904, "WiredTiger re-opened", "duration"_attr = Date_t::now() - startTime);
startTime = Date_t::now();
LOGV2(22325, "Reconfiguring", "newConfig"_attr = _fileVersion.getDowngradeString());
- invariantWTOK(_conn->reconfigure(_conn, _fileVersion.getDowngradeString().c_str()));
+ invariantWTOK(_conn->reconfigure(_conn, _fileVersion.getDowngradeString().c_str()),
+ nullptr);
LOGV2(4795903, "Reconfigure complete", "duration"_attr = Date_t::now() - startTime);
}
auto startTime = Date_t::now();
LOGV2(4795902, "Closing WiredTiger", "closeConfig"_attr = closeConfig);
- invariantWTOK(_conn->close(_conn, closeConfig.c_str()));
+ invariantWTOK(_conn->close(_conn, closeConfig.c_str()), nullptr);
LOGV2(4795901, "WiredTiger closed", "duration"_attr = Date_t::now() - startTime);
_conn = nullptr;
}
@@ -842,7 +846,7 @@ Status WiredTigerKVEngine::_salvageIfNeeded(const char* uri) {
}
LOGV2(22328, "Verify failed. Running a salvage operation.", "uri"_attr = uri);
- auto status = wtRCToStatus(session->salvage(session, uri, nullptr), "Salvage failed:");
+ auto status = wtRCToStatus(session->salvage(session, uri, nullptr), session, "Salvage failed:");
if (status.isOK()) {
return {ErrorCodes::DataModifiedByRepair, str::stream() << "Salvaged data for " << uri};
}
@@ -895,7 +899,7 @@ Status WiredTigerKVEngine::_rebuildIdent(WT_SESSION* session, const char* uri) {
int rc = session->drop(session, uri, nullptr);
if (rc != 0) {
- auto status = wtRCToStatus(rc);
+ auto status = wtRCToStatus(rc, session);
LOGV2_ERROR(22358,
"Failed to drop {uri}",
"Rebuilding ident failed: failed to drop",
@@ -906,7 +910,7 @@ Status WiredTigerKVEngine::_rebuildIdent(WT_SESSION* session, const char* uri) {
rc = session->create(session, uri, swMetadata.getValue().c_str());
if (rc != 0) {
- auto status = wtRCToStatus(rc);
+ auto status = wtRCToStatus(rc, session);
LOGV2_ERROR(22359,
"Failed to create {uri} with config: {config}",
"Rebuilding ident failed: failed to create with config",
@@ -961,7 +965,7 @@ Status WiredTigerKVEngine::beginBackup(OperationContext* opCtx) {
WT_SESSION* s = session->getSession();
int ret = WT_OP_CHECK(s->open_cursor(s, "backup:", nullptr, nullptr, &c));
if (ret != 0) {
- return wtRCToStatus(ret);
+ return wtRCToStatus(ret, s);
}
_backupSession = std::move(session);
return Status::OK();
@@ -990,7 +994,7 @@ Status WiredTigerKVEngine::disableIncrementalBackup(OperationContext* opCtx) {
session->open_cursor(session, "backup:", nullptr, "incremental=(force_stop=true)", &cursor);
if (wtRet != 0) {
LOGV2_ERROR(22360, "Could not open a backup cursor to disable incremental backups");
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, session);
}
return Status::OK();
@@ -1056,7 +1060,8 @@ public:
}
const char* filename;
- invariantWTOK((_wtBackup->cursor)->get_key(_wtBackup->cursor, &filename));
+ invariantWTOK((_wtBackup->cursor)->get_key(_wtBackup->cursor, &filename),
+ _wtBackup->cursor->session);
const boost::filesystem::path filePath = constructFilePath(_path, {filename});
const auto wiredTigerLogFilePrefix = "WiredTigerLog";
@@ -1101,7 +1106,7 @@ public:
}
if (wtRet != WT_NOTFOUND && backupBlocks.size() != batchSize) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, _session);
}
return backupBlocks;
@@ -1124,7 +1129,7 @@ private:
wtRet = (_session)->open_cursor(
_session, nullptr, _wtBackup->cursor, config.c_str(), &_wtBackup->dupCursor);
if (wtRet != 0) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, _session);
}
fileUnchangedFlag = true;
}
@@ -1134,12 +1139,13 @@ private:
if (wtRet == WT_NOTFOUND) {
break;
}
- invariantWTOK(wtRet);
+ invariantWTOK(wtRet, _wtBackup->dupCursor->session);
fileUnchangedFlag = false;
uint64_t offset, size, type;
invariantWTOK(
- (_wtBackup->dupCursor)->get_key(_wtBackup->dupCursor, &offset, &size, &type));
+ (_wtBackup->dupCursor)->get_key(_wtBackup->dupCursor, &offset, &size, &type),
+ _wtBackup->dupCursor->session);
LOGV2_DEBUG(22311,
2,
"Block to copy for incremental backup: filename: {filePath_string}, "
@@ -1162,7 +1168,7 @@ private:
if (wtRet != 0) {
if (wtRet != WT_NOTFOUND ||
(wtRet = (_wtBackup->dupCursor)->close(_wtBackup->dupCursor)) != 0) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, _session);
}
_wtBackup->dupCursor = nullptr;
(_wtBackup->wtBackupDupCursorCV).notify_one();
@@ -1216,7 +1222,7 @@ WiredTigerKVEngine::beginNonBlockingBackup(OperationContext* opCtx,
const std::string config = ss.str();
int wtRet = session->open_cursor(session, "backup:", nullptr, config.c_str(), &cursor);
if (wtRet != 0) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, session);
}
// A nullptr indicates that no duplicate cursor is open during an incremental backup.
@@ -1269,14 +1275,14 @@ StatusWith<std::deque<std::string>> WiredTigerKVEngine::extendBackupCursor(
int wtRet =
session->open_cursor(session, nullptr, _wtBackup.cursor, "target=(\"log:\")", &cursor);
if (wtRet != 0) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, session);
}
const char* filename;
std::vector<std::string> filePaths;
while ((wtRet = cursor->next(cursor)) == 0) {
- invariantWTOK(cursor->get_key(cursor, &filename));
+ invariantWTOK(cursor->get_key(cursor, &filename), cursor->session);
std::string name(filename);
const boost::filesystem::path filePath = constructFilePath(_path, name);
filePaths.push_back(filePath.string());
@@ -1284,12 +1290,12 @@ StatusWith<std::deque<std::string>> WiredTigerKVEngine::extendBackupCursor(
}
if (wtRet != WT_NOTFOUND) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, session);
}
wtRet = cursor->close(cursor);
if (wtRet != 0) {
- return wtRCToStatus(wtRet);
+ return wtRCToStatus(wtRet, session);
}
// Once all the backup cursors have been opened on a sharded cluster, we need to ensure that the
@@ -1351,7 +1357,7 @@ Status WiredTigerKVEngine::createRecordStore(OperationContext* opCtx,
"ns"_attr = ns,
"uri"_attr = uri,
"config"_attr = config);
- return wtRCToStatus(s->create(s, uri.c_str(), config.c_str()));
+ return wtRCToStatus(s->create(s, uri.c_str(), config.c_str()), s);
}
Status WiredTigerKVEngine::importRecordStore(OperationContext* opCtx,
@@ -1370,7 +1376,8 @@ Status WiredTigerKVEngine::importRecordStore(OperationContext* opCtx,
"WiredTigerKVEngine::importRecordStore",
"uri"_attr = uri,
"config"_attr = config);
- return wtRCToStatus(s->create(s, uri.c_str(), config.c_str()));
+
+ return wtRCToStatus(s->create(s, uri.c_str(), config.c_str()), s);
}
Status WiredTigerKVEngine::recoverOrphanedIdent(OperationContext* opCtx,
@@ -1439,8 +1446,8 @@ Status WiredTigerKVEngine::recoverOrphanedIdent(OperationContext* opCtx,
WiredTigerSession sessionWrapper(_conn);
WT_SESSION* session = sessionWrapper.getSession();
- status =
- wtRCToStatus(session->salvage(session, _uri(ident).c_str(), nullptr), "Salvage failed: ");
+ status = wtRCToStatus(
+ session->salvage(session, _uri(ident).c_str(), nullptr), session, "Salvage failed: ");
LOGV2(4795907, "Salvage complete", "duration"_attr = Date_t::now() - start);
if (status.isOK()) {
return {ErrorCodes::DataModifiedByRepair,
@@ -1539,7 +1546,7 @@ Status WiredTigerKVEngine::createSortedDataInterface(OperationContext* opCtx,
"collection_uuid"_attr = collOptions.uuid,
"ident"_attr = ident,
"config"_attr = config);
- return wtRCToStatus(WiredTigerIndex::Create(opCtx, _uri(ident), config));
+ return WiredTigerIndex::Create(opCtx, _uri(ident), config);
}
Status WiredTigerKVEngine::importSortedDataInterface(OperationContext* opCtx,
@@ -1555,11 +1562,11 @@ Status WiredTigerKVEngine::importSortedDataInterface(OperationContext* opCtx,
"WiredTigerKVEngine::importSortedDataInterface",
"ident"_attr = ident,
"config"_attr = config);
- return wtRCToStatus(WiredTigerIndex::Create(opCtx, _uri(ident), config));
+ return WiredTigerIndex::Create(opCtx, _uri(ident), config);
}
Status WiredTigerKVEngine::dropSortedDataInterface(OperationContext* opCtx, StringData ident) {
- return wtRCToStatus(WiredTigerIndex::Drop(opCtx, _uri(ident)));
+ return WiredTigerIndex::Drop(opCtx, _uri(ident));
}
std::unique_ptr<SortedDataInterface> WiredTigerKVEngine::getSortedDataInterface(
@@ -1602,7 +1609,7 @@ std::unique_ptr<RecordStore> WiredTigerKVEngine::makeTemporaryRecordStore(Operat
"WiredTigerKVEngine::makeTemporaryRecordStore",
"uri"_attr = uri,
"config"_attr = config);
- uassertStatusOK(wtRCToStatus(session->create(session, uri.c_str(), config.c_str())));
+ uassertStatusOK(wtRCToStatus(session->create(session, uri.c_str(), config.c_str()), session));
WiredTigerRecordStore::Params params;
params.ns = "";
@@ -1660,7 +1667,7 @@ Status WiredTigerKVEngine::dropIdent(RecoveryUnit* ru,
return Status::OK();
}
- invariantWTOK(ret);
+ invariantWTOK(ret, session.getSession());
return Status::OK();
}
@@ -1697,7 +1704,7 @@ void WiredTigerKVEngine::dropIdentForImport(OperationContext* opCtx, StringData
"config"_attr = config,
"ret"_attr = ret);
} while (ret == EBUSY);
- invariantWTOK(ret);
+ invariantWTOK(ret, session.getSession());
}
std::list<WiredTigerCachedCursor> WiredTigerKVEngine::filterCursorsWithQueuedDrops(
@@ -1780,7 +1787,7 @@ void WiredTigerKVEngine::dropSomeQueuedIdents() {
stdx::lock_guard<Latch> lk(_identToDropMutex);
_identToDrop.push_back(std::move(identToDrop));
} else {
- invariantWTOK(ret);
+ invariantWTOK(ret, session.getSession());
if (identToDrop.callback) {
identToDrop.callback();
}
@@ -1826,7 +1833,7 @@ void WiredTigerKVEngine::checkpoint() {
if (initialDataTimestamp.asULL() <= 1) {
UniqueWiredTigerSession session = _sessionCache->getSession();
WT_SESSION* s = session->getSession();
- invariantWTOK(s->checkpoint(s, "use_timestamp=false"));
+ invariantWTOK(s->checkpoint(s, "use_timestamp=false"), s);
LOGV2_FOR_RECOVERY(5576602,
2,
"Completed unstable checkpoint.",
@@ -1849,7 +1856,7 @@ void WiredTigerKVEngine::checkpoint() {
UniqueWiredTigerSession session = _sessionCache->getSession();
WT_SESSION* s = session->getSession();
- invariantWTOK(s->checkpoint(s, "use_timestamp=true"));
+ invariantWTOK(s->checkpoint(s, "use_timestamp=true"), s);
if (oplogNeededForRollback.isOK()) {
// Now that the checkpoint is durable, publish the oplog needed to recover from it.
@@ -1875,7 +1882,7 @@ bool WiredTigerKVEngine::_hasUri(WT_SESSION* session, const std::string& uri) co
int ret = session->open_cursor(session, "metadata:", nullptr, nullptr, &c);
if (ret == ENOENT)
return false;
- invariantWTOK(ret);
+ invariantWTOK(ret, session);
ON_BLOCK_EXIT([&] { c->close(c); });
c->set_key(c, uri.c_str());
@@ -2012,7 +2019,7 @@ void WiredTigerKVEngine::setStableTimestamp(Timestamp stableTimestamp, bool forc
} else {
stableTSConfigString = "stable_timestamp={:x}"_format(ts);
}
- invariantWTOK(_conn->set_timestamp(_conn, stableTSConfigString.c_str()));
+ invariantWTOK(_conn->set_timestamp(_conn, stableTSConfigString.c_str()), nullptr);
// After publishing a stable timestamp to WT, we can record the updated stable timestamp value
// for the necessary oplog to keep.
@@ -2081,7 +2088,7 @@ void WiredTigerKVEngine::setOldestTimestamp(Timestamp newOldestTimestamp, bool f
auto oldestTSConfigString =
"force=true,oldest_timestamp={0:x},commit_timestamp={0:x}"_format(
newOldestTimestamp.asULL());
- invariantWTOK(_conn->set_timestamp(_conn, oldestTSConfigString.c_str()));
+ invariantWTOK(_conn->set_timestamp(_conn, oldestTSConfigString.c_str()), nullptr);
_oldestTimestamp.store(newOldestTimestamp.asULL());
stdx::lock_guard<Latch> lk(_highestDurableTimestampMutex);
_highestSeenDurableTimestamp = newOldestTimestamp.asULL();
@@ -2091,7 +2098,7 @@ void WiredTigerKVEngine::setOldestTimestamp(Timestamp newOldestTimestamp, bool f
"newOldestTimestamp"_attr = newOldestTimestamp);
} else {
auto oldestTSConfigString = "oldest_timestamp={:x}"_format(newOldestTimestamp.asULL());
- invariantWTOK(_conn->set_timestamp(_conn, oldestTSConfigString.c_str()));
+ invariantWTOK(_conn->set_timestamp(_conn, oldestTSConfigString.c_str()), nullptr);
// set_timestamp above ignores backwards in time if 'force' is not set.
if (_oldestTimestamp.load() < newOldestTimestamp.asULL())
_oldestTimestamp.store(newOldestTimestamp.asULL());
@@ -2226,7 +2233,7 @@ uint64_t _fetchAllDurableValue(WT_CONNECTION* conn) {
// (timestamped) data.
return StorageEngine::kMinimumTimestamp;
} else {
- invariantWTOK(wtstatus);
+ invariantWTOK(wtstatus, nullptr);
}
uint64_t tmp;
@@ -2499,7 +2506,7 @@ Timestamp WiredTigerKVEngine::getCheckpointTimestamp() const {
std::uint64_t WiredTigerKVEngine::_getCheckpointTimestamp() const {
char buf[(2 * 8 /*bytes in hex*/) + 1 /*nul terminator*/];
- invariantWTOK(_conn->query_timestamp(_conn, buf, "get=last_checkpoint"));
+ invariantWTOK(_conn->query_timestamp(_conn, buf, "get=last_checkpoint"), nullptr);
std::uint64_t tmp;
fassert(50963, NumberParser().base(16)(buf, &tmp));
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
index 56d10abba70..e84f2a2c14e 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
@@ -678,21 +678,21 @@ public:
wiredTigerPrepareConflictRetry(_opCtx, [&] { return _cursor->next(_cursor); });
if (advanceRet == WT_NOTFOUND)
return {};
- invariantWTOK(advanceRet);
+ invariantWTOK(advanceRet, _cursor->session);
RecordId id;
if (_rs->keyFormat() == KeyFormat::String) {
WT_ITEM item;
- invariantWTOK(_cursor->get_key(_cursor, &item));
+ invariantWTOK(_cursor->get_key(_cursor, &item), _cursor->session);
id = RecordId(static_cast<const char*>(item.data), item.size);
} else {
int64_t key;
- invariantWTOK(_cursor->get_key(_cursor, &key));
+ invariantWTOK(_cursor->get_key(_cursor, &key), _cursor->session);
id = RecordId(key);
}
WT_ITEM value;
- invariantWTOK(_cursor->get_value(_cursor, &value));
+ invariantWTOK(_cursor->get_value(_cursor, &value), _cursor->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneDocRead(value.size);
@@ -716,8 +716,10 @@ public:
WT_SESSION* session = WiredTigerRecoveryUnit::get(_opCtx)->getSession()->getSession();
if (!_cursor) {
- auto status = wtRCToStatus(session->open_cursor(
- session, _rs->_uri.c_str(), nullptr, _config.c_str(), &_cursor));
+ auto status =
+ wtRCToStatus(session->open_cursor(
+ session, _rs->_uri.c_str(), nullptr, _config.c_str(), &_cursor),
+ session);
if (status == ErrorCodes::ObjectIsBusy) {
// This can happen if you try to open a cursor on the oplog table and a verify is
// currently running on it.
@@ -735,7 +737,7 @@ public:
invariant(_opCtx);
_opCtx = nullptr;
if (_cursor) {
- invariantWTOK(_cursor->close(_cursor));
+ invariantWTOK(_cursor->close(_cursor), _cursor->session);
}
_cursor = nullptr;
}
@@ -1038,7 +1040,7 @@ int64_t WiredTigerRecordStore::freeStorageSize(OperationContext* opCtx) const {
// Retrieve the value from a positioned cursor.
RecordData WiredTigerRecordStore::_getData(const WiredTigerCursor& cursor) const {
WT_ITEM value;
- invariantWTOK(cursor->get_value(cursor.get(), &value));
+ invariantWTOK(cursor->get_value(cursor.get(), &value), cursor->session);
return RecordData(static_cast<const char*>(value.data), value.size).getOwned();
}
@@ -1056,7 +1058,7 @@ bool WiredTigerRecordStore::findRecord(OperationContext* opCtx,
if (ret == WT_NOTFOUND) {
return false;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneCursorSeek();
@@ -1083,19 +1085,19 @@ void WiredTigerRecordStore::deleteRecord(OperationContext* opCtx, const RecordId
CursorKey key = makeCursorKey(id, _keyFormat);
setKey(c, &key);
int ret = wiredTigerPrepareConflictRetry(opCtx, [&] { return c->search(c); });
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneCursorSeek();
WT_ITEM old_value;
ret = c->get_value(c, &old_value);
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
int64_t old_length = old_value.size;
ret = WT_OP_CHECK(wiredTigerCursorRemove(opCtx, c));
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
metricsCollector.incrementOneDocWritten(old_length);
@@ -1172,7 +1174,7 @@ void WiredTigerRecordStore::reclaimOplog(OperationContext* opCtx, Timestamp mayT
// The first record in the oplog should be within the truncate range.
int ret = wiredTigerPrepareConflictRetry(opCtx, [&] { return cursor->next(cursor); });
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
RecordId firstRecord = getKey(cursor);
if (firstRecord < _oplogStones->firstRecord || firstRecord > stone->lastRecord) {
LOGV2_WARNING(22407,
@@ -1191,7 +1193,7 @@ void WiredTigerRecordStore::reclaimOplog(OperationContext* opCtx, Timestamp mayT
int cmp;
ret = wiredTigerPrepareConflictRetry(opCtx,
[&] { return cursor->search_near(cursor, &cmp); });
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
// Check 'cmp' to determine if we landed on the requested record. While it is often the
// case that stones represent a perfect partitioning of the oplog, it's not guaranteed.
@@ -1207,7 +1209,7 @@ void WiredTigerRecordStore::reclaimOplog(OperationContext* opCtx, Timestamp mayT
LOGV2_DEBUG(5140900, 0, "Will not truncate entire oplog");
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
}
RecordId nextRecord = getKey(cursor);
if (static_cast<std::uint64_t>(nextRecord.getLong()) > mayTruncateUpTo.asULL()) {
@@ -1222,9 +1224,9 @@ void WiredTigerRecordStore::reclaimOplog(OperationContext* opCtx, Timestamp mayT
// After checking whether or not we should truncate, reposition the cursor back to the
// current stone's lastRecord.
- invariantWTOK(cursor->reset(cursor));
+ invariantWTOK(cursor->reset(cursor), cursor->session);
setKey(cursor, &truncateUpToKey);
- invariantWTOK(session->truncate(session, nullptr, nullptr, cursor, nullptr));
+ invariantWTOK(session->truncate(session, nullptr, nullptr, cursor, nullptr), session);
_changeNumRecords(opCtx, -stone->records);
_increaseDataSize(opCtx, -stone->bytes);
@@ -1343,7 +1345,7 @@ Status WiredTigerRecordStore::_insertRecords(OperationContext* opCtx,
}
if (ret)
- return wtRCToStatus(ret, "WiredTigerRecordStore::insertRecord");
+ return wtRCToStatus(ret, c->session, "WiredTigerRecordStore::insertRecord");
// Increment metrics for each insert separately, as opposed to outside of the loop. The API
// requires that each record be accounted for separately.
@@ -1402,7 +1404,7 @@ StatusWith<Timestamp> WiredTigerRecordStore::getLatestOplogTimestamp(
if (ret == WT_NOTFOUND) {
return Status(ErrorCodes::CollectionIsEmpty, "oplog is empty");
}
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
RecordId recordId = getKey(cursor);
@@ -1427,7 +1429,7 @@ StatusWith<Timestamp> WiredTigerRecordStore::getEarliestOplogTimestamp(Operation
if (ret == WT_NOTFOUND) {
return Status(ErrorCodes::CollectionIsEmpty, "oplog is empty");
}
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
_oplogFirstRecord = getKey(cursor);
}
@@ -1451,6 +1453,7 @@ Status WiredTigerRecordStore::updateRecord(OperationContext* opCtx,
int ret = wiredTigerPrepareConflictRetry(opCtx, [&] { return c->search(c); });
invariantWTOK(ret,
+ c->session,
str::stream() << "Namespace: " << ns() << "; Key: " << getKey(c)
<< "; Read Timestamp: "
<< opCtx->recoveryUnit()
@@ -1463,7 +1466,7 @@ Status WiredTigerRecordStore::updateRecord(OperationContext* opCtx,
WT_ITEM old_value;
ret = c->get_value(c, &old_value);
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
int64_t old_length = old_value.size;
@@ -1491,9 +1494,10 @@ Status WiredTigerRecordStore::updateRecord(OperationContext* opCtx,
if ((ret = wiredtiger_calc_modify(
c->session, &old_value, value.Get(), kMaxDiffBytes, entries.data(), &nentries)) ==
0) {
- invariantWTOK(WT_OP_CHECK(
- nentries == 0 ? c->reserve(c)
- : wiredTigerCursorModify(opCtx, c, entries.data(), nentries)));
+ invariantWTOK(WT_OP_CHECK(nentries == 0 ? c->reserve(c)
+ : wiredTigerCursorModify(
+ opCtx, c, entries.data(), nentries)),
+ c->session);
size_t modifiedDataSize = 0;
// Don't perform a range-based for loop because there may be fewer calculated entries
@@ -1511,7 +1515,7 @@ Status WiredTigerRecordStore::updateRecord(OperationContext* opCtx,
memcmp(data, new_value.data, len) == 0));
skip_update = true;
} else if (ret != WT_NOTFOUND) {
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
}
}
@@ -1520,7 +1524,7 @@ Status WiredTigerRecordStore::updateRecord(OperationContext* opCtx,
ret = WT_OP_CHECK(wiredTigerCursorInsert(opCtx, c));
metricsCollector.incrementOneDocWritten(value.size);
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
_increaseDataSize(opCtx, len - old_length);
return Status::OK();
@@ -1562,15 +1566,16 @@ StatusWith<RecordData> WiredTigerRecordStore::updateWithDamages(
// The test harness calls us with empty damage vectors which WiredTiger doesn't allow.
if (nentries == 0)
- invariantWTOK(WT_OP_CHECK(c->search(c)));
+ invariantWTOK(WT_OP_CHECK(c->search(c)), c->session);
else
- invariantWTOK(WT_OP_CHECK(wiredTigerCursorModify(opCtx, c, entries.data(), nentries)));
+ invariantWTOK(WT_OP_CHECK(wiredTigerCursorModify(opCtx, c, entries.data(), nentries)),
+ c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
metricsCollector.incrementOneDocWritten(modifiedDataSize);
WT_ITEM value;
- invariantWTOK(c->get_value(c, &value));
+ invariantWTOK(c->get_value(c, &value), c->session);
return RecordData(static_cast<const char*>(value.data), value.size).getOwned();
}
@@ -1589,10 +1594,11 @@ Status WiredTigerRecordStore::truncate(OperationContext* opCtx) {
if (ret == WT_NOTFOUND) {
return Status::OK();
}
- invariantWTOK(ret);
+ invariantWTOK(ret, start->session);
WT_SESSION* session = WiredTigerRecoveryUnit::get(opCtx)->getSession()->getSession();
- invariantWTOK(WT_OP_CHECK(session->truncate(session, nullptr, start, nullptr, nullptr)));
+ invariantWTOK(WT_OP_CHECK(session->truncate(session, nullptr, start, nullptr, nullptr)),
+ session);
_changeNumRecords(opCtx, -numRecords(opCtx));
_increaseDataSize(opCtx, -dataSize(opCtx));
@@ -1620,7 +1626,7 @@ Status WiredTigerRecordStore::compact(OperationContext* opCtx) {
str::stream() << "Compaction interrupted on " << getURI().c_str()
<< " due to cache eviction pressure");
}
- invariantWTOK(ret);
+ invariantWTOK(ret, s);
}
return Status::OK();
}
@@ -1784,7 +1790,7 @@ void WiredTigerRecordStore::_initNextIdIfNeeded(OperationContext* opCtx) {
// that the other session owned by this thread may be the one that needs to be rolled back. If
// this does time out, we will receive a WT_CACHE_FULL and throw an error.
auto wtSession = sessRaii.getSession();
- invariantWTOK(wtSession->reconfigure(wtSession, "cache_max_wait_ms=1000"));
+ invariantWTOK(wtSession->reconfigure(wtSession, "cache_max_wait_ms=1000"), wtSession);
auto cursor = sessRaii.getNewCursor(_uri);
@@ -1796,7 +1802,7 @@ void WiredTigerRecordStore::_initNextIdIfNeeded(OperationContext* opCtx) {
// Force the caller to rollback its transaction if we can't make progess with eviction.
throw WriteConflictException();
} else if (ret != WT_NOTFOUND) {
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
auto recordId = getKey(cursor);
nextId = recordId.getLong() + 1;
}
@@ -1954,7 +1960,7 @@ void WiredTigerRecordStore::cappedTruncateAfter(OperationContext* opCtx,
setKey(start, &key);
WT_SESSION* session = WiredTigerRecoveryUnit::get(opCtx)->getSession()->getSession();
- invariantWTOK(session->truncate(session, nullptr, start, nullptr, nullptr));
+ invariantWTOK(session->truncate(session, nullptr, start, nullptr, nullptr), session);
_changeNumRecords(opCtx, -recordsRemoved);
_increaseDataSize(opCtx, -bytesRemoved);
@@ -1977,7 +1983,7 @@ void WiredTigerRecordStore::cappedTruncateAfter(OperationContext* opCtx,
} else {
auto conn = WiredTigerRecoveryUnit::get(opCtx)->getSessionCache()->conn();
auto commitTSConfigString = "commit_timestamp={:x}"_format(truncTs.asULL());
- invariantWTOK(conn->set_timestamp(conn, commitTSConfigString.c_str()));
+ invariantWTOK(conn->set_timestamp(conn, commitTSConfigString.c_str()), session);
}
_kvEngine->getOplogManager()->setOplogReadTimestamp(truncTs);
@@ -2048,7 +2054,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::next() {
_eof = true;
return {};
}
- invariantWTOK(advanceRet);
+ invariantWTOK(advanceRet, c->session);
id = getKey(c);
}
@@ -2079,7 +2085,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::next() {
}
WT_ITEM value;
- invariantWTOK(c->get_value(c, &value));
+ invariantWTOK(c->get_value(c, &value), c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneDocRead(value.size);
@@ -2110,13 +2116,13 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekExact(const RecordI
_eof = true;
return {};
}
- invariantWTOK(seekRet);
+ invariantWTOK(seekRet, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneCursorSeek();
WT_ITEM value;
- invariantWTOK(c->get_value(c, &value));
+ invariantWTOK(c->get_value(c, &value), c->session);
metricsCollector.incrementOneDocRead(value.size);
@@ -2147,7 +2153,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekNear(const RecordId
_eof = true;
return boost::none;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
metricsCollector.incrementOneCursorSeek();
@@ -2173,7 +2179,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekNear(const RecordId
ret = wiredTigerPrepareConflictRetry(_opCtx, [&] { return c->prev(c); });
}
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
curId = getKey(c);
@@ -2185,7 +2191,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekNear(const RecordId
}
WT_ITEM value;
- invariantWTOK(c->get_value(c, &value));
+ invariantWTOK(c->get_value(c, &value), c->session);
metricsCollector.incrementOneDocRead(value.size);
@@ -2252,7 +2258,7 @@ bool WiredTigerRecordStoreCursorBase::restore(bool tolerateCappedRepositioning)
}
return true;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, c->session);
id = getKey(c);
if (cmp == 0)
@@ -2299,11 +2305,11 @@ StandardWiredTigerRecordStore::StandardWiredTigerRecordStore(WiredTigerKVEngine*
RecordId StandardWiredTigerRecordStore::getKey(WT_CURSOR* cursor) const {
if (_keyFormat == KeyFormat::String) {
WT_ITEM item;
- invariantWTOK(cursor->get_key(cursor, &item));
+ invariantWTOK(cursor->get_key(cursor, &item), cursor->session);
return RecordId(static_cast<const char*>(item.data), item.size);
} else {
std::int64_t recordId;
- invariantWTOK(cursor->get_key(cursor, &recordId));
+ invariantWTOK(cursor->get_key(cursor, &recordId), cursor->session);
return RecordId(recordId);
}
}
@@ -2352,11 +2358,11 @@ void WiredTigerRecordStoreStandardCursor::setKey(
RecordId WiredTigerRecordStoreStandardCursor::getKey(WT_CURSOR* cursor) const {
if (_rs.keyFormat() == KeyFormat::String) {
WT_ITEM item;
- invariantWTOK(cursor->get_key(cursor, &item));
+ invariantWTOK(cursor->get_key(cursor, &item), cursor->session);
return RecordId(static_cast<const char*>(item.data), item.size);
} else {
std::int64_t recordId;
- invariantWTOK(cursor->get_key(cursor, &recordId));
+ invariantWTOK(cursor->get_key(cursor, &recordId), cursor->session);
return RecordId(recordId);
}
}
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test_harness.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test_harness.cpp
index 5d9f038bcbe..a5cd86bd7e9 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test_harness.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test_harness.cpp
@@ -66,7 +66,7 @@ std::unique_ptr<RecordStore> WiredTigerHarnessHelper::newNonCappedRecordStore(
{
WriteUnitOfWork uow(&opCtx);
WT_SESSION* s = ru->getSession()->getSession();
- invariantWTOK(s->create(s, uri.c_str(), config.c_str()));
+ invariantWTOK(s->create(s, uri.c_str(), config.c_str()), s);
uow.commit();
}
@@ -115,7 +115,7 @@ std::unique_ptr<RecordStore> WiredTigerHarnessHelper::newOplogRecordStoreNoInit(
{
WriteUnitOfWork uow(&opCtx);
WT_SESSION* s = ru->getSession()->getSession();
- invariantWTOK(s->create(s, uri.c_str(), config.c_str()));
+ invariantWTOK(s->create(s, uri.c_str(), config.c_str()), s);
uow.commit();
}
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
index 7eab1f6c797..d4c0e84c43a 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
@@ -99,7 +99,7 @@ void WiredTigerOperationStats::fetchStats(WT_SESSION* session,
}
// Reset the statistics so that the next fetch gives the recent values.
- invariantWTOK(c->reset(c));
+ invariantWTOK(c->reset(c), c->session);
}
BSONObj WiredTigerOperationStats::toBSON() {
@@ -235,7 +235,7 @@ void WiredTigerRecoveryUnit::prepareUnitOfWork() {
const std::string conf = "prepare_timestamp=" + unsignedHex(_prepareTimestamp.asULL());
// Prepare the transaction.
- invariantWTOK(s->prepare_transaction(s, conf.c_str()));
+ invariantWTOK(s->prepare_transaction(s, conf.c_str()), s);
}
void WiredTigerRecoveryUnit::doCommitUnitOfWork() {
@@ -380,7 +380,7 @@ void WiredTigerRecoveryUnit::refreshSnapshot() {
// Now end the previous transaction.
auto wtSession = _session->getSession();
auto wtRet = wtSession->rollback_transaction(wtSession, nullptr);
- invariantWTOK(wtRet);
+ invariantWTOK(wtRet, wtSession);
LOGV2_DEBUG(5035301,
3,
"WT begin_transaction & rollback_transaction",
@@ -471,7 +471,7 @@ void WiredTigerRecoveryUnit::_txnClose(bool commit) {
}
_isTimestamped = false;
}
- invariantWTOK(wtRet);
+ invariantWTOK(wtRet, s);
invariant(!_lastTimestampSet || _commitTimestamp.isNull(),
str::stream() << "Cannot have both a _lastTimestampSet and a "
@@ -755,7 +755,7 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSI
Timestamp WiredTigerRecoveryUnit::_getTransactionReadTimestamp(WT_SESSION* session) {
char buf[(2 * 8 /*bytes in hex*/) + 1 /*nul terminator*/];
auto wtstatus = session->query_timestamp(session, buf, "get=read");
- invariantWTOK(wtstatus);
+ invariantWTOK(wtstatus, session);
uint64_t read_timestamp;
fassert(50949, NumberParser().base(16)(buf, &read_timestamp));
return Timestamp(read_timestamp);
@@ -804,7 +804,7 @@ Status WiredTigerRecoveryUnit::setTimestamp(Timestamp timestamp) {
if (rc == 0) {
_isTimestamped = true;
}
- return wtRCToStatus(rc, "timestamp_transaction");
+ return wtRCToStatus(rc, session, "timestamp_transaction");
}
void WiredTigerRecoveryUnit::setCommitTimestamp(Timestamp timestamp) {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp
index 7ab0f68bd5f..de9ac660cb7 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp
@@ -89,7 +89,7 @@ public:
WiredTigerRecoveryUnit* ru =
checked_cast<WiredTigerRecoveryUnit*>(opCtx->recoveryUnit());
WT_SESSION* s = ru->getSession()->getSession();
- invariantWTOK(s->create(s, uri.c_str(), config.c_str()));
+ invariantWTOK(s->create(s, uri.c_str(), config.c_str()), s);
uow.commit();
}
@@ -147,8 +147,9 @@ public:
void getCursor(WiredTigerRecoveryUnit* ru, WT_CURSOR** cursor) {
WT_SESSION* wt_session = ru->getSession()->getSession();
- invariantWTOK(wt_session->create(wt_session, wt_uri, wt_config));
- invariantWTOK(wt_session->open_cursor(wt_session, wt_uri, nullptr, nullptr, cursor));
+ invariantWTOK(wt_session->create(wt_session, wt_uri, wt_config), wt_session);
+ invariantWTOK(wt_session->open_cursor(wt_session, wt_uri, nullptr, nullptr, cursor),
+ wt_session);
}
void setUp() override {
@@ -274,7 +275,7 @@ TEST_F(WiredTigerRecoveryUnitTestFixture,
getCursor(ru1, &cursor);
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
- invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor));
+ invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor), cursor->session);
ru1->setPrepareTimestamp({1, 1});
ru1->prepareUnitOfWork();
@@ -297,7 +298,7 @@ TEST_F(WiredTigerRecoveryUnitTestFixture,
getCursor(ru1, &cursor);
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
- invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor));
+ invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor), cursor->session);
ru1->setPrepareTimestamp({1, 1});
ru1->prepareUnitOfWork();
@@ -321,7 +322,7 @@ TEST_F(WiredTigerRecoveryUnitTestFixture, WriteAllowedWhileIgnorePrepareFalse) {
getCursor(ru1, &cursor);
cursor->set_key(cursor, "key1");
cursor->set_value(cursor, "value1");
- invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor));
+ invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor), cursor->session);
ru1->setPrepareTimestamp({1, 1});
ru1->prepareUnitOfWork();
@@ -340,7 +341,7 @@ TEST_F(WiredTigerRecoveryUnitTestFixture, WriteAllowedWhileIgnorePrepareFalse) {
cursor->set_value(cursor, "value2");
// The write is allowed.
- invariantWTOK(wiredTigerCursorInsert(clientAndCtx2.second.get(), cursor));
+ invariantWTOK(wiredTigerCursorInsert(clientAndCtx2.second.get(), cursor), cursor->session);
ru1->abortUnitOfWork();
ru2->abortUnitOfWork();
@@ -353,7 +354,7 @@ TEST_F(WiredTigerRecoveryUnitTestFixture, WriteOnADocumentBeingPreparedTriggersW
getCursor(ru1, &cursor);
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
- invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor));
+ invariantWTOK(wiredTigerCursorInsert(clientAndCtx1.second.get(), cursor), cursor->session);
ru1->setPrepareTimestamp({1, 1});
ru1->prepareUnitOfWork();
@@ -789,13 +790,13 @@ TEST_F(WiredTigerRecoveryUnitTestFixture, MultiTimestampConstraintsInternalState
getCursor(ru1, &cursor);
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
- invariantWTOK(wiredTigerCursorInsert(opCtx, cursor));
+ invariantWTOK(wiredTigerCursorInsert(opCtx, cursor), cursor->session);
// Perform a write at ts1.
cursor->set_key(cursor, "key2");
cursor->set_value(cursor, "value");
ASSERT_OK(ru1->setTimestamp(ts1));
- invariantWTOK(wiredTigerCursorInsert(opCtx, cursor));
+ invariantWTOK(wiredTigerCursorInsert(opCtx, cursor), cursor->session);
// Setting the timestamp again to the same value should not fail.
ASSERT_OK(ru1->setTimestamp(ts1));
@@ -809,7 +810,7 @@ TEST_F(WiredTigerRecoveryUnitTestFixture, MultiTimestampConstraintsInternalState
cursor->set_key(cursor, "key3");
cursor->set_value(cursor, "value");
ASSERT_OK(ru1->setTimestamp(ts2));
- invariantWTOK(wiredTigerCursorInsert(opCtx, cursor));
+ invariantWTOK(wiredTigerCursorInsert(opCtx, cursor), cursor->session);
ru1->commitUnitOfWork();
}
@@ -828,13 +829,13 @@ DEATH_TEST_REGEX_F(WiredTigerRecoveryUnitTestFixture,
getCursor(ru1, &cursor);
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
- invariantWTOK(wiredTigerCursorInsert(opCtx, cursor));
+ invariantWTOK(wiredTigerCursorInsert(opCtx, cursor), cursor->session);
// Perform a write at ts1.
cursor->set_key(cursor, "key2");
cursor->set_value(cursor, "value");
ASSERT_OK(ru1->setTimestamp(ts1));
- invariantWTOK(wiredTigerCursorInsert(opCtx, cursor));
+ invariantWTOK(wiredTigerCursorInsert(opCtx, cursor), cursor->session);
// Setting the timestamp again to a different value should detect that we're trying to set
// multiple timestamps with the first write being non timestamped.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
index 9bedb789f1d..58e4d09e055 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
@@ -56,7 +56,7 @@ WiredTigerSession::WiredTigerSession(WT_CONNECTION* conn, uint64_t epoch, uint64
_cursorGen(0),
_cursorsOut(0),
_idleExpireTime(Date_t::min()) {
- invariantWTOK(conn->open_session(conn, nullptr, "isolation=snapshot", &_session));
+ invariantWTOK(conn->open_session(conn, nullptr, "isolation=snapshot", &_session), nullptr);
}
WiredTigerSession::WiredTigerSession(WT_CONNECTION* conn,
@@ -70,12 +70,12 @@ WiredTigerSession::WiredTigerSession(WT_CONNECTION* conn,
_cursorGen(0),
_cursorsOut(0),
_idleExpireTime(Date_t::min()) {
- invariantWTOK(conn->open_session(conn, nullptr, "isolation=snapshot", &_session));
+ invariantWTOK(conn->open_session(conn, nullptr, "isolation=snapshot", &_session), nullptr);
}
WiredTigerSession::~WiredTigerSession() {
if (_session) {
- invariantWTOK(_session->close(_session, nullptr));
+ invariantWTOK(_session->close(_session, nullptr), nullptr);
}
}
@@ -92,7 +92,7 @@ void _openCursor(WT_SESSION* session,
}
if (ret != 0) {
- auto status = wtRCToStatus(ret);
+ auto status = wtRCToStatus(ret, session);
std::string cursorErrMsg = str::stream()
<< "Failed to open a WiredTiger cursor. Reason: " << status << ", uri: " << uri
<< ", config: " << config;
@@ -148,7 +148,7 @@ void WiredTigerSession::releaseCursor(uint64_t id, WT_CURSOR* cursor, const std:
invariant(cursor);
_cursorsOut--;
- invariantWTOK(cursor->reset(cursor));
+ invariantWTOK(cursor->reset(cursor), _session);
// Cursors are pushed to the front of the list and removed from the back
_cursors.push_front(WiredTigerCachedCursor(id, _cursorGen++, cursor, config));
@@ -159,7 +159,7 @@ void WiredTigerSession::releaseCursor(uint64_t id, WT_CURSOR* cursor, const std:
while (!_cursors.empty() && _cursorGen - _cursors.back()._gen > cacheSize) {
cursor = _cursors.back()._cursor;
_cursors.pop_back();
- invariantWTOK(cursor->close(cursor));
+ invariantWTOK(cursor->close(cursor), _session);
}
}
@@ -168,7 +168,7 @@ void WiredTigerSession::closeCursor(WT_CURSOR* cursor) {
invariant(cursor);
_cursorsOut--;
- invariantWTOK(cursor->close(cursor));
+ invariantWTOK(cursor->close(cursor), _session);
}
void WiredTigerSession::closeAllCursors(const std::string& uri) {
@@ -178,7 +178,7 @@ void WiredTigerSession::closeAllCursors(const std::string& uri) {
for (auto i = _cursors.begin(); i != _cursors.end();) {
WT_CURSOR* cursor = i->_cursor;
if (cursor && (all || uri == cursor->uri)) {
- invariantWTOK(cursor->close(cursor));
+ invariantWTOK(cursor->close(cursor), _session);
i = _cursors.erase(i);
} else
++i;
@@ -194,7 +194,7 @@ void WiredTigerSession::closeCursorsForQueuedDrops(WiredTigerKVEngine* engine) {
for (auto i = toDrop.begin(); i != toDrop.end(); i++) {
WT_CURSOR* cursor = i->_cursor;
if (cursor) {
- invariantWTOK(cursor->close(cursor));
+ invariantWTOK(cursor->close(cursor), _session);
}
}
}
@@ -307,7 +307,7 @@ void WiredTigerSessionCache::waitUntilDurable(OperationContext* opCtx,
auto config = syncType == Fsync::kCheckpointStableTimestamp ? "use_timestamp=true"
: "use_timestamp=false";
- invariantWTOK(s->checkpoint(s, config));
+ invariantWTOK(s->checkpoint(s, config), s);
if (token) {
journalListener->onDurable(token.get());
@@ -349,15 +349,18 @@ void WiredTigerSessionCache::waitUntilDurable(OperationContext* opCtx,
// Initialize on first use.
if (!_waitUntilDurableSession) {
invariantWTOK(
- _conn->open_session(_conn, nullptr, "isolation=snapshot", &_waitUntilDurableSession));
+ _conn->open_session(_conn, nullptr, "isolation=snapshot", &_waitUntilDurableSession),
+ nullptr);
}
// Use the journal when available, or a checkpoint otherwise.
if (_engine && _engine->isDurable()) {
- invariantWTOK(_waitUntilDurableSession->log_flush(_waitUntilDurableSession, "sync=on"));
+ invariantWTOK(_waitUntilDurableSession->log_flush(_waitUntilDurableSession, "sync=on"),
+ _waitUntilDurableSession);
LOGV2_DEBUG(22419, 4, "flushed journal");
} else {
- invariantWTOK(_waitUntilDurableSession->checkpoint(_waitUntilDurableSession, nullptr));
+ invariantWTOK(_waitUntilDurableSession->checkpoint(_waitUntilDurableSession, nullptr),
+ _waitUntilDurableSession);
LOGV2_DEBUG(22420, 4, "created checkpoint");
}
@@ -502,7 +505,7 @@ void WiredTigerSessionCache::releaseSession(WiredTigerSession* session) {
uint64_t range;
// This checks that we are only caching idle sessions and not something which might hold
// locks or otherwise prevent truncation.
- invariantWTOK(ss->transaction_pinned_range(ss, &range));
+ invariantWTOK(ss->transaction_pinned_range(ss, &range), ss);
invariant(range == 0);
// Release resources in the session we're about to cache.
@@ -511,7 +514,7 @@ void WiredTigerSessionCache::releaseSession(WiredTigerSession* session) {
if (gWiredTigerCursorCacheSize.load() < 0) {
session->closeAllCursors("");
}
- invariantWTOK(ss->reset(ss));
+ invariantWTOK(ss->reset(ss), ss);
}
// If the cursor epoch has moved on, close all cursors in the session.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache_test.cpp
index a71110a7cdd..de95fcce0e7 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache_test.cpp
@@ -54,7 +54,7 @@ public:
string config = ss.str();
_fastClockSource = std::make_unique<SystemClockSource>();
int ret = wiredtiger_open(dbpath.toString().c_str(), nullptr, config.c_str(), &_conn);
- ASSERT_OK(wtRCToStatus(ret));
+ ASSERT_OK(wtRCToStatus(ret, nullptr));
ASSERT(_conn);
}
~WiredTigerConnection() {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.cpp
index a7ba50a759c..59a4e92e6a0 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.cpp
@@ -63,7 +63,8 @@ WiredTigerSizeStorer::WiredTigerSizeStorer(WT_CONNECTION* conn,
WiredTigerSession session(_conn);
invariantWTOK(
- session.getSession()->create(session.getSession(), _storageUri.c_str(), config.c_str()));
+ session.getSession()->create(session.getSession(), _storageUri.c_str(), config.c_str()),
+ session.getSession());
}
void WiredTigerSizeStorer::store(StringData uri, std::shared_ptr<SizeInfo> sizeInfo) {
@@ -107,11 +108,11 @@ std::shared_ptr<WiredTigerSizeStorer::SizeInfo> WiredTigerSizeStorer::load(Opera
int ret = cursor->search(cursor.get());
if (ret == WT_NOTFOUND)
return std::make_shared<SizeInfo>();
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
}
WT_ITEM value;
- invariantWTOK(cursor->get_value(cursor.get(), &value));
+ invariantWTOK(cursor->get_value(cursor.get(), &value), cursor->session);
BSONObj data(reinterpret_cast<const char*>(value.data));
LOGV2_DEBUG(
@@ -187,10 +188,11 @@ void WiredTigerSizeStorer::flush(bool syncToDisk) {
// skip flushing.
return;
}
- invariantWTOK(ret);
+ invariantWTOK(ret, cursor->session);
}
txnOpen.done();
- invariantWTOK(session.getSession()->commit_transaction(session.getSession(), nullptr));
+ invariantWTOK(session.getSession()->commit_transaction(session.getSession(), nullptr),
+ session.getSession());
buffer.clear();
}
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp
index f3b2f963b53..a932bcb46fd 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp
@@ -58,7 +58,7 @@ public:
WiredTigerIndexHarnessHelper() : _dbpath("wt_test"), _conn(nullptr) {
const char* config = "create,cache_size=1G,";
int ret = wiredtiger_open(_dbpath.path().c_str(), nullptr, config, &_conn);
- invariantWTOK(ret);
+ invariantWTOK(ret, nullptr);
_fastClockSource = std::make_unique<SystemClockSource>();
_sessionCache = new WiredTigerSessionCache(_conn, _fastClockSource.get());
@@ -87,7 +87,7 @@ public:
ASSERT_OK(result.getStatus());
string uri = "table:" + ns;
- invariantWTOK(WiredTigerIndex::Create(&opCtx, uri, result.getValue()));
+ invariant(Status::OK() == WiredTigerIndex::Create(&opCtx, uri, result.getValue()));
return std::make_unique<WiredTigerIdIndex>(&opCtx, uri, "" /* ident */, &desc);
}
@@ -119,7 +119,7 @@ public:
ASSERT_OK(result.getStatus());
string uri = "table:" + ns;
- invariantWTOK(WiredTigerIndex::Create(&opCtx, uri, result.getValue()));
+ invariant(Status::OK() == WiredTigerIndex::Create(&opCtx, uri, result.getValue()));
if (unique) {
invariant(keyFormat == KeyFormat::Long);
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
index a6c88a7d4d9..fa3bf562a1c 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
@@ -135,7 +135,7 @@ TEST(WiredTigerRecordStoreTest, SizeStorer1) {
{
WriteUnitOfWork uow(opCtx.get());
WT_SESSION* s = ru->getSession()->getSession();
- invariantWTOK(s->create(s, indexUri.c_str(), ""));
+ invariantWTOK(s->create(s, indexUri.c_str(), ""), s);
uow.commit();
}
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp
index 49a87209b4e..ad1484435bd 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp
@@ -85,7 +85,7 @@ void removeTableChecksFile() {
using std::string;
-Status wtRCToStatus_slow(int retCode, const char* prefix) {
+Status wtRCToStatus_slow(int retCode, WT_SESSION* session, const char* prefix) {
if (retCode == 0)
return Status::OK();
@@ -149,12 +149,12 @@ StatusWith<std::string> _getMetadata(WT_CURSOR* cursor, StringData uri) {
return StatusWith<std::string>(ErrorCodes::NoSuchKey,
str::stream() << "Unable to find metadata for " << uri);
} else if (ret != 0) {
- return StatusWith<std::string>(wtRCToStatus(ret));
+ return StatusWith<std::string>(wtRCToStatus(ret, cursor->session));
}
const char* metadata = nullptr;
ret = cursor->get_value(cursor, &metadata);
if (ret != 0) {
- return StatusWith<std::string>(wtRCToStatus(ret));
+ return StatusWith<std::string>(wtRCToStatus(ret, cursor->session));
}
invariant(metadata);
return StatusWith<std::string>(metadata);
@@ -163,9 +163,9 @@ StatusWith<std::string> _getMetadata(WT_CURSOR* cursor, StringData uri) {
StatusWith<std::string> WiredTigerUtil::getMetadataCreate(WT_SESSION* session, StringData uri) {
WT_CURSOR* cursor;
- invariantWTOK(session->open_cursor(session, "metadata:create", nullptr, "", &cursor));
+ invariantWTOK(session->open_cursor(session, "metadata:create", nullptr, "", &cursor), session);
invariant(cursor);
- ON_BLOCK_EXIT([cursor] { invariantWTOK(cursor->close(cursor)); });
+ ON_BLOCK_EXIT([cursor, session] { invariantWTOK(cursor->close(cursor), session); });
return _getMetadata(cursor, uri);
}
@@ -194,9 +194,9 @@ StatusWith<std::string> WiredTigerUtil::getMetadataCreate(OperationContext* opCt
StatusWith<std::string> WiredTigerUtil::getMetadata(WT_SESSION* session, StringData uri) {
WT_CURSOR* cursor;
- invariantWTOK(session->open_cursor(session, "metadata:", nullptr, "", &cursor));
+ invariantWTOK(session->open_cursor(session, "metadata:", nullptr, "", &cursor), session);
invariant(cursor);
- ON_BLOCK_EXIT([cursor] { invariantWTOK(cursor->close(cursor)); });
+ ON_BLOCK_EXIT([cursor, session] { invariantWTOK(cursor->close(cursor), session); });
return _getMetadata(cursor, uri);
}
@@ -270,7 +270,7 @@ Status WiredTigerUtil::getApplicationMetadata(OperationContext* opCtx,
}
}
if (ret != WT_NOTFOUND) {
- return wtRCToStatus(ret);
+ return wtRCToStatus(ret, nullptr);
}
return Status::OK();
@@ -362,7 +362,8 @@ Status WiredTigerUtil::checkTableCreationOptions(const BSONElement& configElem)
}
Status status = wtRCToStatus(
- wiredtiger_config_validate(nullptr, &eventHandler, "WT_SESSION.create", config.rawData()));
+ wiredtiger_config_validate(nullptr, &eventHandler, "WT_SESSION.create", config.rawData()),
+ nullptr);
if (!status.isOK()) {
StringBuilder errorMsg;
errorMsg << status.reason();
@@ -609,7 +610,7 @@ int WiredTigerUtil::verifyTable(OperationContext* opCtx,
// Open a new session with custom error handlers.
WT_CONNECTION* conn = WiredTigerRecoveryUnit::get(opCtx)->getSessionCache()->conn();
WT_SESSION* session;
- invariantWTOK(conn->open_session(conn, &eventHandler, nullptr, &session));
+ invariantWTOK(conn->open_session(conn, &eventHandler, nullptr, &session), nullptr);
ON_BLOCK_EXIT([&] { session->close(session, ""); });
// Do the verify. Weird parens prevent treating "verify" as a macro.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_util.h b/src/mongo/db/storage/wiredtiger/wiredtiger_util.h
index 04ab25365e6..ff936dd9ee5 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_util.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_util.h
@@ -46,37 +46,49 @@ class WiredTigerConfigParser;
class WiredTigerKVEngine;
class WiredTigerSession;
-Status wtRCToStatus_slow(int retCode, const char* prefix);
+Status wtRCToStatus_slow(int retCode, WT_SESSION* session, const char* prefix);
/**
* converts wiredtiger return codes to mongodb statuses.
*/
-inline Status wtRCToStatus(int retCode, const char* prefix = nullptr) {
+inline Status wtRCToStatus(int retCode, WT_SESSION* session, const char* prefix = nullptr) {
if (MONGO_likely(retCode == 0))
return Status::OK();
- return wtRCToStatus_slow(retCode, prefix);
+ return wtRCToStatus_slow(retCode, session, prefix);
}
-#define MONGO_invariantWTOK_1(expression) \
- do { \
- int _invariantWTOK_retCode = expression; \
- if (MONGO_unlikely(_invariantWTOK_retCode != 0)) { \
- invariantOKFailed( \
- #expression, wtRCToStatus(_invariantWTOK_retCode), __FILE__, __LINE__); \
- } \
+template <typename ContextExpr>
+Status wtRCToStatus(int retCode, WT_SESSION* session, ContextExpr&& contextExpr) {
+ if (MONGO_likely(retCode == 0))
+ return Status::OK();
+
+ return wtRCToStatus_slow(retCode, session, std::forward<ContextExpr>(contextExpr)());
+}
+
+inline void uassertWTOK(int ret, WT_SESSION* session) {
+ uassertStatusOK(wtRCToStatus(ret, session));
+}
+
+#define MONGO_invariantWTOK_2(expression, session) \
+ do { \
+ int _invariantWTOK_retCode = expression; \
+ if (MONGO_unlikely(_invariantWTOK_retCode != 0)) { \
+ invariantOKFailed( \
+ #expression, wtRCToStatus(_invariantWTOK_retCode, session), __FILE__, __LINE__); \
+ } \
} while (false)
-#define MONGO_invariantWTOK_2(expression, contextExpr) \
- do { \
- int _invariantWTOK_retCode = expression; \
- if (MONGO_unlikely(_invariantWTOK_retCode != 0)) { \
- invariantOKFailedWithMsg(#expression, \
- wtRCToStatus(_invariantWTOK_retCode), \
- contextExpr, \
- __FILE__, \
- __LINE__); \
- } \
+#define MONGO_invariantWTOK_3(expression, session, contextExpr) \
+ do { \
+ int _invariantWTOK_retCode = expression; \
+ if (MONGO_unlikely(_invariantWTOK_retCode != 0)) { \
+ invariantOKFailedWithMsg(#expression, \
+ wtRCToStatus(_invariantWTOK_retCode, session), \
+ contextExpr, \
+ __FILE__, \
+ __LINE__); \
+ } \
} while (false)
#define invariantWTOK(...) \
@@ -314,16 +326,18 @@ class WiredTigerConfigParser {
public:
WiredTigerConfigParser(StringData config) {
invariantWTOK(
- wiredtiger_config_parser_open(nullptr, config.rawData(), config.size(), &_parser));
+ wiredtiger_config_parser_open(nullptr, config.rawData(), config.size(), &_parser),
+ nullptr);
}
WiredTigerConfigParser(const WT_CONFIG_ITEM& nested) {
invariant(nested.type == WT_CONFIG_ITEM::WT_CONFIG_ITEM_STRUCT);
- invariantWTOK(wiredtiger_config_parser_open(nullptr, nested.str, nested.len, &_parser));
+ invariantWTOK(wiredtiger_config_parser_open(nullptr, nested.str, nested.len, &_parser),
+ nullptr);
}
~WiredTigerConfigParser() {
- invariantWTOK(_parser->close(_parser));
+ invariantWTOK(_parser->close(_parser), nullptr);
}
int next(WT_CONFIG_ITEM* key, WT_CONFIG_ITEM* value) {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_util_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_util_test.cpp
index 4decabddcba..2fab1cb3e96 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_util_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_util_test.cpp
@@ -56,7 +56,7 @@ public:
string config = ss.str();
_fastClockSource = std::make_unique<SystemClockSource>();
int ret = wiredtiger_open(dbpath.toString().c_str(), nullptr, config.c_str(), &_conn);
- ASSERT_OK(wtRCToStatus(ret));
+ ASSERT_OK(wtRCToStatus(ret, nullptr));
ASSERT(_conn);
}
~WiredTigerConnection() {
@@ -127,7 +127,7 @@ protected:
void createSession(const char* config) {
WT_SESSION* wtSession =
WiredTigerRecoveryUnit::get(_opCtx.get())->getSession()->getSession();
- ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, getURI(), config)));
+ ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, getURI(), config), wtSession));
}
private:
@@ -306,7 +306,7 @@ TEST(WiredTigerUtilTest, GetStatisticsValueStatisticsDisabled) {
harnessHelper.getOplogManager());
WiredTigerSession* session = recoveryUnit.getSession();
WT_SESSION* wtSession = session->getSession();
- ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, "table:mytable", nullptr)));
+ ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, "table:mytable", nullptr), wtSession));
auto result = WiredTigerUtil::getStatisticsValue(session->getSession(),
"statistics:table:mytable",
"statistics=(fast)",
@@ -321,7 +321,7 @@ TEST(WiredTigerUtilTest, GetStatisticsValueInvalidKey) {
harnessHelper.getOplogManager());
WiredTigerSession* session = recoveryUnit.getSession();
WT_SESSION* wtSession = session->getSession();
- ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, "table:mytable", nullptr)));
+ ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, "table:mytable", nullptr), wtSession));
// Use connection statistics key which does not apply to a table.
auto result = WiredTigerUtil::getStatisticsValue(session->getSession(),
"statistics:table:mytable",
@@ -337,7 +337,7 @@ TEST(WiredTigerUtilTest, GetStatisticsValueValidKey) {
harnessHelper.getOplogManager());
WiredTigerSession* session = recoveryUnit.getSession();
WT_SESSION* wtSession = session->getSession();
- ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, "table:mytable", nullptr)));
+ ASSERT_OK(wtRCToStatus(wtSession->create(wtSession, "table:mytable", nullptr), wtSession));
// Use connection statistics key which does not apply to a table.
auto result = WiredTigerUtil::getStatisticsValue(session->getSession(),
"statistics:table:mytable",
View Lorry Controller Status