/*
* __session_commit_transaction --
* WT_SESSION->commit_transaction method.
*/
static int
__session_commit_transaction(WT_SESSION *wt_session, const char *config)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
WT_TXN *txn;
session = (WT_SESSION_IMPL *)wt_session;
SESSION_API_CALL(session, commit_transaction, config, cfg);
WT_CSTAT_INCR(session, txn_commit);
txn = &session->txn;
if (F_ISSET(txn, TXN_ERROR)) {
__wt_errx(session, "failed transaction requires rollback");
ret = EINVAL;
}
WT_TRET(__session_reset_cursors(session));
if (ret == 0)
ret = __wt_txn_commit(session, cfg);
else
(void)__wt_txn_rollback(session, cfg);
err: API_END(session);
return (ret);
}
/*
* __wt_txn_commit --
* Commit the current transaction.
*/
int
__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_OP *op;
u_int i;
WT_UNUSED(cfg);
txn = &session->txn;
WT_ASSERT(session, !F_ISSET(txn, TXN_ERROR));
if (!F_ISSET(txn, TXN_RUNNING))
WT_RET_MSG(session, EINVAL, "No transaction is active");
/* Commit notification. */
if (txn->notify != NULL)
WT_TRET(txn->notify->notify(txn->notify,
(WT_SESSION *)session, txn->id, 1));
/* If we are logging, write a commit log record. */
if (ret == 0 &&
txn->mod_count > 0 && S2C(session)->logging &&
!F_ISSET(session, WT_SESSION_LOGGING_DISABLED))
ret = __wt_txn_log_commit(session, cfg);
/*
* If anything went wrong, roll back.
*
* !!!
* Nothing can fail after this point.
*/
if (ret != 0) {
WT_TRET(__wt_txn_rollback(session, cfg));
return (ret);
}
/* Free memory associated with updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++)
__wt_txn_op_free(session, op);
/*
* Auto-commit transactions need a new transaction snapshot so that the
* committed changes are visible to subsequent reads. However, cursor
* keys and values will point to the data that was just modified, so
* the snapshot cannot be so new that updates could be freed underneath
* the cursor. Get the new snapshot before releasing the ID for the
* commit.
*/
if (session->ncursors > 0 && txn->isolation != TXN_ISO_READ_UNCOMMITTED)
__wt_txn_refresh(session, txn->id + 1, 1);
__wt_txn_release(session);
return (0);
}
/*
* __session_rollback_transaction --
* WT_SESSION->rollback_transaction method.
*/
static int
__session_rollback_transaction(WT_SESSION *wt_session, const char *config)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
session = (WT_SESSION_IMPL *)wt_session;
SESSION_API_CALL(session, rollback_transaction, config, cfg);
WT_CSTAT_INCR(session, txn_rollback);
WT_TRET(__session_reset_cursors(session));
WT_TRET(__wt_txn_rollback(session, cfg));
err: API_END(session);
return (ret);
}
/*
* __wt_txn_commit --
* Commit the current transaction.
*/
int
__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_OP *op;
u_int i;
txn = &session->txn;
conn = S2C(session);
WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) || txn->mod_count == 0);
if (!F_ISSET(txn, WT_TXN_RUNNING))
WT_RET_MSG(session, EINVAL, "No transaction is active");
/*
* The default sync setting is inherited from the connection, but can
* be overridden by an explicit "sync" setting for this transaction.
*/
WT_RET(__wt_config_gets_def(session, cfg, "sync", 0, &cval));
/*
* If the user chose the default setting, check whether sync is enabled
* for this transaction (either inherited or via begin_transaction).
* If sync is disabled, clear the field to avoid the log write being
* flushed.
*
* Otherwise check for specific settings. We don't need to check for
* "on" because that is the default inherited from the connection. If
* the user set anything in begin_transaction, we only override with an
* explicit setting.
*/
if (cval.len == 0) {
if (!FLD_ISSET(txn->txn_logsync, WT_LOG_FLUSH) &&
!F_ISSET(txn, WT_TXN_SYNC_SET))
txn->txn_logsync = 0;
} else {
/*
* If the caller already set sync on begin_transaction then
* they should not be using sync on commit_transaction.
* Flag that as an error.
*/
if (F_ISSET(txn, WT_TXN_SYNC_SET))
WT_RET_MSG(session, EINVAL,
"Sync already set during begin_transaction.");
if (WT_STRING_MATCH("background", cval.str, cval.len))
txn->txn_logsync = WT_LOG_BACKGROUND;
else if (WT_STRING_MATCH("off", cval.str, cval.len))
txn->txn_logsync = 0;
/*
* We don't need to check for "on" here because that is the
* default to inherit from the connection setting.
*/
}
/* Commit notification. */
if (txn->notify != NULL)
WT_TRET(txn->notify->notify(txn->notify,
(WT_SESSION *)session, txn->id, 1));
/* If we are logging, write a commit log record. */
if (ret == 0 && txn->mod_count > 0 &&
FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) &&
!F_ISSET(session, WT_SESSION_NO_LOGGING)) {
/*
* We are about to block on I/O writing the log.
* Release our snapshot in case it is keeping data pinned.
* This is particularly important for checkpoints.
*/
__wt_txn_release_snapshot(session);
ret = __wt_txn_log_commit(session, cfg);
WT_ASSERT(session, ret == 0);
}
/*
* If anything went wrong, roll back.
*
* !!!
* Nothing can fail after this point.
*/
if (ret != 0) {
WT_TRET(__wt_txn_rollback(session, cfg));
return (ret);
}
/* Free memory associated with updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++)
__wt_txn_op_free(session, op);
txn->mod_count = 0;
/*
* We are about to release the snapshot: copy values into any
* positioned cursors so they don't point to updates that could be
* freed once we don't have a transaction ID pinned.
*/
if (session->ncursors > 0)
WT_RET(__wt_session_copy_values(session));
__wt_txn_release(session);
return (0);
}
/*
* __wt_meta_track_off --
* Turn off metadata operation tracking, unrolling on error.
*/
int
__wt_meta_track_off(WT_SESSION_IMPL *session, bool need_sync, bool unroll)
{
WT_DECL_RET;
WT_META_TRACK *trk, *trk_orig;
WT_SESSION_IMPL *ckpt_session;
int saved_ret;
bool did_drop;
saved_ret = 0;
WT_ASSERT(session,
WT_META_TRACKING(session) && session->meta_track_nest > 0);
trk_orig = session->meta_track;
trk = session->meta_track_next;
/* If it was a nested transaction, there is nothing to do. */
if (--session->meta_track_nest != 0)
return (0);
/* Turn off tracking for unroll. */
session->meta_track_next = session->meta_track_sub = NULL;
/*
* If there were no operations logged, skip unnecessary metadata
* checkpoints. For example, this happens if attempting to create a
* data source that already exists (or drop one that doesn't).
*/
if (trk == trk_orig)
goto err;
/* Unrolling doesn't require syncing the metadata. */
if (unroll)
goto err;
if (F_ISSET(session, WT_SESSION_SCHEMA_TXN)) {
F_CLR(session, WT_SESSION_SCHEMA_TXN);
#ifdef WT_ENABLE_SCHEMA_TXN
WT_ERR(__wt_txn_commit(session, NULL));
__wt_errx(session, "TRACK: Commit internal schema txn");
#endif
}
/*
* If we don't have the metadata cursor (e.g, we're in the process of
* creating the metadata), we can't sync it.
*/
if (!need_sync || session->meta_cursor == NULL ||
F_ISSET(S2C(session), WT_CONN_IN_MEMORY))
goto err;
/* If we're logging, make sure the metadata update was flushed. */
if (FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_ENABLED))
WT_WITH_DHANDLE(session,
WT_SESSION_META_DHANDLE(session),
ret = __wt_txn_checkpoint_log(
session, false, WT_TXN_LOG_CKPT_SYNC, NULL));
else {
WT_ASSERT(session, F_ISSET(session, WT_SESSION_LOCKED_SCHEMA));
ckpt_session = S2C(session)->meta_ckpt_session;
/*
* If this operation is part of a running transaction, that
* should be included in the checkpoint.
*/
ckpt_session->txn.id = session->txn.id;
WT_ASSERT(session,
!F_ISSET(session, WT_SESSION_LOCKED_METADATA));
WT_WITH_DHANDLE(ckpt_session, WT_SESSION_META_DHANDLE(session),
WT_WITH_METADATA_LOCK(ckpt_session,
ret = __wt_checkpoint(ckpt_session, NULL)));
ckpt_session->txn.id = WT_TXN_NONE;
if (ret == 0)
WT_WITH_DHANDLE(session,
WT_SESSION_META_DHANDLE(session),
ret = __wt_checkpoint_sync(session, NULL));
}
err: /*
* Undo any tracked operations on failure.
* Apply any tracked operations post-commit.
*/
did_drop = false;
if (unroll || ret != 0) {
saved_ret = ret;
ret = 0;
while (--trk >= trk_orig) {
did_drop = did_drop || trk->op == WT_ST_DROP_COMMIT;
WT_TRET(__meta_track_unroll(session, trk));
}
} else
for (; trk_orig < trk; trk_orig++) {
did_drop = did_drop ||
trk_orig->op == WT_ST_DROP_COMMIT;
WT_TRET(__meta_track_apply(session, trk_orig));
}
if (F_ISSET(session, WT_SESSION_SCHEMA_TXN)) {
F_CLR(session, WT_SESSION_SCHEMA_TXN);
/*
* We should have committed above unless we're unrolling, there
* was an error or the operation was a noop.
*/
WT_ASSERT(session, unroll || saved_ret != 0 ||
session->txn.mod_count == 0);
#ifdef WT_ENABLE_SCHEMA_TXN
__wt_err(session, saved_ret,
"TRACK: Abort internal schema txn");
WT_TRET(__wt_txn_rollback(session, NULL));
#endif
}
/*
* Wake up the sweep thread: particularly for the in-memory
* storage engine, we want to reclaim space immediately.
*/
if (did_drop && S2C(session)->sweep_cond != NULL)
__wt_cond_signal(session, S2C(session)->sweep_cond);
if (ret != 0)
WT_PANIC_RET(session, ret,
"failed to apply or unroll all tracked operations");
return (saved_ret == 0 ? 0 : saved_ret);
}
/*
* __wt_txn_commit --
* Commit the current transaction.
*/
int
__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_OP *op;
u_int i;
bool locked, readonly;
#ifdef HAVE_TIMESTAMPS
wt_timestamp_t prev_commit_timestamp, ts;
bool update_timestamp;
#endif
txn = &session->txn;
conn = S2C(session);
txn_global = &conn->txn_global;
locked = false;
WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));
WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) ||
txn->mod_count == 0);
readonly = txn->mod_count == 0;
/*
* Look for a commit timestamp.
*/
WT_ERR(
__wt_config_gets_def(session, cfg, "commit_timestamp", 0, &cval));
if (cval.len != 0) {
#ifdef HAVE_TIMESTAMPS
WT_ERR(__wt_txn_parse_timestamp(session, "commit", &ts, &cval));
WT_ERR(__wt_timestamp_validate(session,
"commit", &ts, &cval, true, true, true));
__wt_timestamp_set(&txn->commit_timestamp, &ts);
__wt_txn_set_commit_timestamp(session);
#else
WT_ERR_MSG(session, EINVAL, "commit_timestamp requires a "
"version of WiredTiger built with timestamp support");
#endif
}
#ifdef HAVE_TIMESTAMPS
/*
* Debugging checks on timestamps, if user requested them.
*/
if (F_ISSET(txn, WT_TXN_TS_COMMIT_ALWAYS) &&
!F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
txn->mod_count != 0)
WT_ERR_MSG(session, EINVAL, "commit_timestamp required and "
"none set on this transaction");
if (F_ISSET(txn, WT_TXN_TS_COMMIT_NEVER) &&
F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
txn->mod_count != 0)
WT_ERR_MSG(session, EINVAL, "no commit_timestamp required and "
"timestamp set on this transaction");
#endif
/*
* The default sync setting is inherited from the connection, but can
* be overridden by an explicit "sync" setting for this transaction.
*/
WT_ERR(__wt_config_gets_def(session, cfg, "sync", 0, &cval));
/*
* If the user chose the default setting, check whether sync is enabled
* for this transaction (either inherited or via begin_transaction).
* If sync is disabled, clear the field to avoid the log write being
* flushed.
*
* Otherwise check for specific settings. We don't need to check for
* "on" because that is the default inherited from the connection. If
* the user set anything in begin_transaction, we only override with an
* explicit setting.
*/
if (cval.len == 0) {
if (!FLD_ISSET(txn->txn_logsync, WT_LOG_SYNC_ENABLED) &&
!F_ISSET(txn, WT_TXN_SYNC_SET))
txn->txn_logsync = 0;
} else {
/*
* If the caller already set sync on begin_transaction then
* they should not be using sync on commit_transaction.
* Flag that as an error.
*/
if (F_ISSET(txn, WT_TXN_SYNC_SET))
WT_ERR_MSG(session, EINVAL,
"Sync already set during begin_transaction");
if (WT_STRING_MATCH("background", cval.str, cval.len))
txn->txn_logsync = WT_LOG_BACKGROUND;
else if (WT_STRING_MATCH("off", cval.str, cval.len))
txn->txn_logsync = 0;
/*
* We don't need to check for "on" here because that is the
* default to inherit from the connection setting.
*/
}
/* Commit notification. */
if (txn->notify != NULL)
WT_ERR(txn->notify->notify(txn->notify,
(WT_SESSION *)session, txn->id, 1));
/*
* We are about to release the snapshot: copy values into any
* positioned cursors so they don't point to updates that could be
* freed once we don't have a snapshot.
*/
if (session->ncursors > 0) {
WT_DIAGNOSTIC_YIELD;
WT_ERR(__wt_session_copy_values(session));
}
/* If we are logging, write a commit log record. */
if (txn->logrec != NULL &&
FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) &&
!F_ISSET(session, WT_SESSION_NO_LOGGING)) {
/*
* We are about to block on I/O writing the log.
* Release our snapshot in case it is keeping data pinned.
* This is particularly important for checkpoints.
*/
__wt_txn_release_snapshot(session);
/*
* We hold the visibility lock for reading from the time
* we write our log record until the time we release our
* transaction so that the LSN any checkpoint gets will
* always reflect visible data.
*/
__wt_readlock(session, &txn_global->visibility_rwlock);
locked = true;
WT_ERR(__wt_txn_log_commit(session, cfg));
}
/* Note: we're going to commit: nothing can fail after this point. */
/* Process and free updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {
switch (op->type) {
case WT_TXN_OP_BASIC:
case WT_TXN_OP_BASIC_TS:
case WT_TXN_OP_INMEM:
/*
* Switch reserved operations to abort to
* simplify obsolete update list truncation.
*/
if (op->u.upd->type == WT_UPDATE_RESERVED) {
op->u.upd->txnid = WT_TXN_ABORTED;
break;
}
/*
* Writes to the lookaside file can be evicted as soon
* as they commit.
*/
if (conn->cache->las_fileid != 0 &&
op->fileid == conn->cache->las_fileid) {
op->u.upd->txnid = WT_TXN_NONE;
break;
}
#ifdef HAVE_TIMESTAMPS
if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
op->type != WT_TXN_OP_BASIC_TS) {
WT_ASSERT(session,
op->fileid != WT_METAFILE_ID);
__wt_timestamp_set(&op->u.upd->timestamp,
&txn->commit_timestamp);
}
#endif
break;
case WT_TXN_OP_REF:
#ifdef HAVE_TIMESTAMPS
if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT))
__wt_timestamp_set(
&op->u.ref->page_del->timestamp,
&txn->commit_timestamp);
#endif
break;
case WT_TXN_OP_TRUNCATE_COL:
case WT_TXN_OP_TRUNCATE_ROW:
/* Other operations don't need timestamps. */
break;
}
__wt_txn_op_free(session, op);
}
txn->mod_count = 0;
#ifdef HAVE_TIMESTAMPS
/*
* Track the largest commit timestamp we have seen.
*
* We don't actually clear the local commit timestamp, just the flag.
* That said, we can't update the global commit timestamp until this
* transaction is visible, which happens when we release it.
*/
update_timestamp = F_ISSET(txn, WT_TXN_HAS_TS_COMMIT);
#endif
__wt_txn_release(session);
if (locked)
__wt_readunlock(session, &txn_global->visibility_rwlock);
#ifdef HAVE_TIMESTAMPS
/* First check if we've already committed something in the future. */
if (update_timestamp) {
WT_WITH_TIMESTAMP_READLOCK(session, &txn_global->rwlock,
__wt_timestamp_set(
&prev_commit_timestamp, &txn_global->commit_timestamp));
update_timestamp = __wt_timestamp_cmp(
&txn->commit_timestamp, &prev_commit_timestamp) > 0;
}
/*
* If it looks like we need to move the global commit timestamp,
* write lock and re-check.
*/
if (update_timestamp) {
#if WT_TIMESTAMP_SIZE == 8
while (__wt_timestamp_cmp(
&txn->commit_timestamp, &prev_commit_timestamp) > 0) {
if (__wt_atomic_cas64(
&txn_global->commit_timestamp.val,
prev_commit_timestamp.val,
txn->commit_timestamp.val)) {
txn_global->has_commit_timestamp = true;
break;
}
__wt_timestamp_set(
&prev_commit_timestamp, &txn_global->commit_timestamp);
}
#else
__wt_writelock(session, &txn_global->rwlock);
if (__wt_timestamp_cmp(&txn->commit_timestamp,
&txn_global->commit_timestamp) > 0) {
__wt_timestamp_set(&txn_global->commit_timestamp,
&txn->commit_timestamp);
txn_global->has_commit_timestamp = true;
}
__wt_writeunlock(session, &txn_global->rwlock);
#endif
}
#endif
/*
* We're between transactions, if we need to block for eviction, it's
* a good time to do so. Note that we must ignore any error return
* because the user's data is committed.
*/
if (!readonly)
(void)__wt_cache_eviction_check(session, false, false, NULL);
return (0);
err: /*
* If anything went wrong, roll back.
*
* !!!
* Nothing can fail after this point.
*/
if (locked)
__wt_readunlock(session, &txn_global->visibility_rwlock);
WT_TRET(__wt_txn_rollback(session, cfg));
return (ret);
}
