#include "db_config.h"
#include "db_int.h"
#include "dbinc/crypto.h"
#include "dbinc/hmac.h"
#include "dbinc/db_page.h"
#include "dbinc/hash.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/txn.h"
#define LOG_FLAGS(txn) \
(DB_LOG_COMMIT | (F_ISSET(txn, TXN_SYNC) ? \
DB_FLUSH : (F_ISSET(txn, TXN_WRITE_NOSYNC) ? \
DB_LOG_WRNOSYNC : 0)))
typedef enum {
TXN_OP_ABORT,
TXN_OP_COMMIT,
TXN_OP_DISCARD,
TXN_OP_PREPARE
} txnop_t;
static int __txn_abort_pp __P((DB_TXN *));
static int __txn_begin_int __P((DB_TXN *));
static int __txn_commit_pp __P((DB_TXN *, u_int32_t));
static int __txn_discard __P((DB_TXN *, u_int32_t));
static int __txn_dispatch_undo
__P((DB_ENV *, DB_TXN *, DBT *, DB_LSN *, DB_TXNHEAD *));
static int __txn_end __P((DB_TXN *, int));
static int __txn_isvalid __P((const DB_TXN *, txnop_t));
static int __txn_undo __P((DB_TXN *));
static void __txn_set_txn_lsnp __P((DB_TXN *, DB_LSN **, DB_LSN **));
int
__txn_begin_pp(dbenv, parent, txnpp, flags)
DB_ENV *dbenv;
DB_TXN *parent, **txnpp;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
int rep_check, ret;
PANIC_CHECK(dbenv);
ENV_REQUIRES_CONFIG(dbenv, dbenv->tx_handle, "txn_begin", DB_INIT_TXN);
if ((ret = __db_fchk(dbenv,
"txn_begin", flags,
DB_READ_COMMITTED | DB_READ_UNCOMMITTED |
DB_TXN_NOSYNC | DB_TXN_SNAPSHOT | DB_TXN_SYNC |
DB_TXN_WAIT | DB_TXN_WRITE_NOSYNC | DB_TXN_NOWAIT)) != 0)
return (ret);
if ((ret = __db_fcchk(dbenv, "txn_begin", flags,
DB_TXN_WRITE_NOSYNC | DB_TXN_NOSYNC, DB_TXN_SYNC)) != 0)
return (ret);
if ((ret = __db_fcchk(dbenv, "txn_begin",
flags, DB_TXN_WRITE_NOSYNC, DB_TXN_NOSYNC)) != 0)
return (ret);
if (parent != NULL && !F_ISSET(parent, TXN_SNAPSHOT) &&
LF_ISSET(DB_TXN_SNAPSHOT)) {
__db_errx(dbenv,
"Child transaction snapshot setting must match parent");
return (EINVAL);
}
ENV_ENTER(dbenv, ip);
if (parent == NULL) {
rep_check = IS_ENV_REPLICATED(dbenv) ? 1 : 0;
if (rep_check && (ret = __op_rep_enter(dbenv)) != 0)
goto err;
} else
rep_check = 0;
ret = __txn_begin(dbenv, parent, txnpp, flags);
if (ret != 0 && rep_check)
(void)__op_rep_exit(dbenv);
err: ENV_LEAVE(dbenv, ip);
return (ret);
}
int
__txn_begin(dbenv, parent, txnpp, flags)
DB_ENV *dbenv;
DB_TXN *parent, **txnpp;
u_int32_t flags;
{
DB_LOCKREGION *region;
DB_TXN *txn;
TXN_DETAIL *ptd, *td;
int ret;
*txnpp = NULL;
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_TXN), &txn)) != 0)
return (ret);
txn->mgrp = dbenv->tx_handle;
txn->parent = parent;
TAILQ_INIT(&txn->kids);
TAILQ_INIT(&txn->events);
STAILQ_INIT(&txn->logs);
txn->flags = TXN_MALLOC;
if (LF_ISSET(DB_TXN_SYNC))
F_SET(txn, TXN_SYNC);
else if (LF_ISSET(DB_TXN_NOSYNC))
F_SET(txn, TXN_NOSYNC);
else if (LF_ISSET(DB_TXN_WRITE_NOSYNC))
F_SET(txn, TXN_WRITE_NOSYNC);
else if (F_ISSET(dbenv, DB_ENV_TXN_NOSYNC))
F_SET(txn, TXN_NOSYNC);
else if (F_ISSET(dbenv, DB_ENV_TXN_WRITE_NOSYNC))
F_SET(txn, TXN_WRITE_NOSYNC);
else
F_SET(txn, TXN_SYNC);
if (LF_ISSET(DB_TXN_NOWAIT) ||
(F_ISSET(dbenv, DB_ENV_TXN_NOWAIT) && !LF_ISSET(DB_TXN_WAIT)))
F_SET(txn, TXN_NOWAIT);
if (LF_ISSET(DB_READ_COMMITTED))
F_SET(txn, TXN_READ_COMMITTED);
if (LF_ISSET(DB_READ_UNCOMMITTED))
F_SET(txn, TXN_READ_UNCOMMITTED);
if (LF_ISSET(DB_TXN_SNAPSHOT) || F_ISSET(dbenv, DB_ENV_TXN_SNAPSHOT) ||
(parent != NULL && F_ISSET(parent, TXN_SNAPSHOT)))
F_SET(txn, TXN_SNAPSHOT);
if ((ret = __txn_begin_int(txn)) != 0)
goto err;
td = txn->td;
if (parent != NULL) {
ptd = parent->td;
TAILQ_INSERT_HEAD(&parent->kids, txn, klinks);
SH_TAILQ_INSERT_HEAD(&ptd->kids, td, klinks, __txn_detail);
}
if (LOCKING_ON(dbenv)) {
region = dbenv->lk_handle->reginfo.primary;
if (parent != NULL) {
ret = __lock_inherit_timeout(dbenv,
parent->locker, txn->locker);
if (ret == EINVAL) {
parent = NULL;
ret = 0;
}
if (ret != 0)
goto err;
}
if (parent == NULL && region->tx_timeout != 0)
if ((ret = __lock_set_timeout(dbenv, txn->locker,
region->tx_timeout, DB_SET_TXN_TIMEOUT)) != 0)
goto err;
}
*txnpp = txn;
return (0);
err:
__os_free(dbenv, txn);
return (ret);
}
int
__txn_xa_begin(dbenv, txn)
DB_ENV *dbenv;
DB_TXN *txn;
{
PANIC_CHECK(dbenv);
txn->mgrp = dbenv->tx_handle;
TAILQ_INIT(&txn->kids);
TAILQ_INIT(&txn->events);
STAILQ_INIT(&txn->logs);
txn->parent = NULL;
txn->txnid = TXN_INVALID;
txn->cursors = 0;
memset(&txn->lock_timeout, 0, sizeof(db_timeout_t));
memset(&txn->expire, 0, sizeof(db_timeout_t));
return (__txn_begin_int(txn));
}
int
__txn_recycle_id(dbenv)
DB_ENV *dbenv;
{
DB_LSN null_lsn;
DB_TXNMGR *mgr;
DB_TXNREGION *region;
TXN_DETAIL *td;
u_int32_t *ids;
int nids, ret;
mgr = dbenv->tx_handle;
region = mgr->reginfo.primary;
if ((ret = __os_malloc(dbenv,
sizeof(u_int32_t) * region->maxtxns, &ids)) != 0)
return (ret);
nids = 0;
SH_TAILQ_FOREACH(td, ®ion->active_txn, links, __txn_detail)
ids[nids++] = td->txnid;
region->last_txnid = TXN_MINIMUM - 1;
region->cur_maxid = TXN_MAXIMUM;
if (nids != 0)
__db_idspace(ids, nids,
®ion->last_txnid, ®ion->cur_maxid);
__os_free(dbenv, ids);
if (LOGGING_ON(dbenv))
ret = __txn_recycle_log(dbenv, NULL, &null_lsn,
0, region->last_txnid + 1, region->cur_maxid);
return (ret);
}
int
__txn_compensate_begin(dbenv, txnpp)
DB_ENV *dbenv;
DB_TXN **txnpp;
{
DB_TXN *txn;
int ret;
PANIC_CHECK(dbenv);
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_TXN), &txn)) != 0)
return (ret);
txn->mgrp = dbenv->tx_handle;
TAILQ_INIT(&txn->kids);
TAILQ_INIT(&txn->events);
STAILQ_INIT(&txn->logs);
txn->flags = TXN_COMPENSATE | TXN_MALLOC;
*txnpp = txn;
return (__txn_begin_int(txn));
}
static int
__txn_begin_int(txn)
DB_TXN *txn;
{
DB_ENV *dbenv;
DB_TXNMGR *mgr;
DB_TXNREGION *region;
TXN_DETAIL *td;
u_int32_t id;
int ret;
mgr = txn->mgrp;
dbenv = mgr->dbenv;
region = mgr->reginfo.primary;
TXN_SYSTEM_LOCK(dbenv);
if (!F_ISSET(txn, TXN_COMPENSATE) && F_ISSET(region, TXN_IN_RECOVERY)) {
__db_errx(dbenv, "operation not permitted during recovery");
ret = EINVAL;
goto err;
}
if (region->last_txnid == TXN_MAXIMUM &&
region->cur_maxid != TXN_MAXIMUM)
region->last_txnid = TXN_MINIMUM - 1;
if (region->last_txnid == region->cur_maxid &&
(ret = __txn_recycle_id(dbenv)) != 0)
goto err;
if ((ret =
__env_alloc(&mgr->reginfo, sizeof(TXN_DETAIL), &td)) != 0) {
__db_errx(dbenv,
"Unable to allocate memory for transaction detail");
goto err;
}
SH_TAILQ_INSERT_HEAD(®ion->active_txn, td, links, __txn_detail);
id = ++region->last_txnid;
#ifdef HAVE_STATISTICS
++region->stat.st_nbegins;
if (++region->stat.st_nactive > region->stat.st_maxnactive)
region->stat.st_maxnactive = region->stat.st_nactive;
#endif
td->txnid = id;
dbenv->thread_id(dbenv, &td->pid, &td->tid);
if (LOCKING_ON(dbenv) && (ret =
__lock_getlocker(dbenv->lk_handle, id, 1, &txn->locker)) != 0)
goto err;
ZERO_LSN(td->last_lsn);
ZERO_LSN(td->begin_lsn);
SH_TAILQ_INIT(&td->kids);
if (txn->parent != NULL)
td->parent = R_OFFSET(&mgr->reginfo, txn->parent->td);
else
td->parent = INVALID_ROFF;
td->name = INVALID_ROFF;
MAX_LSN(td->read_lsn);
MAX_LSN(td->visible_lsn);
td->mvcc_ref = 0;
td->mvcc_mtx = MUTEX_INVALID;
td->status = TXN_RUNNING;
td->flags = 0;
td->xa_status = 0;
td->nlog_dbs = 0;
td->nlog_slots = TXN_NSLOTS;
td->log_dbs = R_OFFSET(&mgr->reginfo, td->slots);
TXN_SYSTEM_UNLOCK(dbenv);
txn->txnid = id;
txn->td = td;
txn->abort = __txn_abort_pp;
txn->commit = __txn_commit_pp;
txn->discard = __txn_discard;
txn->get_name = __txn_get_name;
txn->id = __txn_id;
txn->prepare = __txn_prepare;
txn->set_txn_lsnp = __txn_set_txn_lsnp;
txn->set_name = __txn_set_name;
txn->set_timeout = __txn_set_timeout;
if (txn->parent != NULL && LOCKING_ON(dbenv))
if ((ret = __lock_addfamilylocker(dbenv,
txn->parent->txnid, txn->txnid)) != 0)
return (ret);
if (F_ISSET(txn, TXN_MALLOC)) {
MUTEX_LOCK(dbenv, mgr->mutex);
TAILQ_INSERT_TAIL(&mgr->txn_chain, txn, links);
MUTEX_UNLOCK(dbenv, mgr->mutex);
}
return (0);
err: TXN_SYSTEM_UNLOCK(dbenv);
return (ret);
}
int
__txn_continue(env, txn, td)
DB_ENV *env;
DB_TXN *txn;
TXN_DETAIL *td;
{
int ret;
ret = 0;
txn->mgrp = env->tx_handle;
txn->parent = NULL;
txn->txnid = td->txnid;
txn->td = td;
txn->abort = __txn_abort_pp;
txn->commit = __txn_commit_pp;
txn->discard = __txn_discard;
txn->get_name = __txn_get_name;
txn->id = __txn_id;
txn->prepare = __txn_prepare;
txn->set_name = __txn_set_name;
txn->flags = 0;
if (F_ISSET(td, TXN_DTL_RESTORED))
F_SET(txn, TXN_RESTORED);
else
ret = __lock_getlocker(env->lk_handle,
txn->txnid, 0, &txn->locker);
return (ret);
}
static int
__txn_commit_pp(txn, flags)
DB_TXN *txn;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_THREAD_INFO *ip;
int not_child, ret, t_ret;
dbenv = txn->mgrp->dbenv;
not_child = txn->parent == NULL;
ENV_ENTER(dbenv, ip);
ret = __txn_commit(txn, flags);
if (not_child && IS_ENV_REPLICATED(dbenv) &&
(t_ret = __op_rep_exit(dbenv)) != 0 && ret == 0)
ret = t_ret;
ENV_LEAVE(dbenv, ip);
return (ret);
}
int
__txn_commit(txn, flags)
DB_TXN *txn;
u_int32_t flags;
{
DBT list_dbt;
DB_ENV *dbenv;
DB_LOCKREQ request;
DB_TXN *kid;
REGENV *renv;
REGINFO *infop;
TXN_DETAIL *td;
u_int32_t id;
int ret, t_ret;
dbenv = txn->mgrp->dbenv;
td = txn->td;
PANIC_CHECK(dbenv);
if (F_ISSET(txn, TXN_DEADLOCK)) {
ret = __db_txn_deadlock_err(dbenv, txn);
goto err;
}
if ((ret = __txn_isvalid(txn, TXN_OP_COMMIT)) != 0)
return (ret);
infop = dbenv->reginfo;
renv = infop->primary;
id = renv->envid;
if (__db_fchk(dbenv, "DB_TXN->commit", flags,
DB_TXN_NOSYNC | DB_TXN_SYNC | DB_TXN_WRITE_NOSYNC) != 0)
flags = DB_TXN_SYNC;
if (__db_fcchk(dbenv, "DB_TXN->commit", flags,
DB_TXN_SYNC, DB_TXN_NOSYNC | DB_TXN_WRITE_NOSYNC) != 0)
flags = DB_TXN_SYNC;
if (LF_ISSET(DB_TXN_WRITE_NOSYNC)) {
F_CLR(txn, TXN_SYNC_FLAGS);
F_SET(txn, TXN_WRITE_NOSYNC);
}
if (LF_ISSET(DB_TXN_NOSYNC)) {
F_CLR(txn, TXN_SYNC_FLAGS);
F_SET(txn, TXN_NOSYNC);
}
if (LF_ISSET(DB_TXN_SYNC)) {
F_CLR(txn, TXN_SYNC_FLAGS);
F_SET(txn, TXN_SYNC);
}
while ((kid = TAILQ_FIRST(&txn->kids)) != NULL)
if ((ret = __txn_commit(kid, flags)) != 0)
while ((kid = TAILQ_FIRST(&txn->kids)) != NULL)
if ((t_ret = __txn_abort(kid)) != 0)
return (__db_panic(dbenv, t_ret));
if (DBENV_LOGGING(dbenv) && (!IS_ZERO_LSN(td->last_lsn) ||
STAILQ_FIRST(&txn->logs) != NULL)) {
if (txn->parent == NULL) {
if ((ret =
__txn_doevents(dbenv, txn, TXN_PREPARE, 1)) != 0)
goto err;
memset(&request, 0, sizeof(request));
if (LOCKING_ON(dbenv)) {
request.op = DB_LOCK_PUT_READ;
if (IS_REP_MASTER(dbenv) &&
!IS_ZERO_LSN(td->last_lsn)) {
memset(&list_dbt, 0, sizeof(list_dbt));
request.obj = &list_dbt;
}
ret = __lock_vec(dbenv,
txn->locker, 0, &request, 1, NULL);
}
if (ret == 0 && !IS_ZERO_LSN(td->last_lsn)) {
ret = __txn_regop_log(dbenv, txn,
&td->visible_lsn, LOG_FLAGS(txn),
TXN_COMMIT,
(int32_t)time(NULL), id, request.obj);
if (ret == 0)
td->last_lsn = td->visible_lsn;
#ifdef DIAGNOSTIC
if (ret == 0) {
DB_LSN s_lsn;
DB_ASSERT(dbenv, __log_current_lsn(
dbenv, &s_lsn, NULL, NULL) == 0);
DB_ASSERT(dbenv, LOG_COMPARE(
&td->visible_lsn, &s_lsn) <= 0);
COMPQUIET(s_lsn.file, 0);
}
#endif
}
if (request.obj != NULL && request.obj->data != NULL)
__os_free(dbenv, request.obj->data);
if (ret != 0)
goto err;
} else {
if (!IS_ZERO_LSN(td->last_lsn) &&
(ret = __txn_child_log(dbenv, txn->parent,
&((TXN_DETAIL *)txn->parent->td)->last_lsn,
0, txn->txnid, &td->last_lsn)) != 0) {
goto err;
}
if (STAILQ_FIRST(&txn->logs) != NULL) {
STAILQ_CONCAT(&txn->logs, &txn->parent->logs);
txn->parent->logs = txn->logs;
STAILQ_INIT(&txn->logs);
}
F_SET(txn->parent, TXN_CHILDCOMMIT);
}
}
if (txn->txn_list != NULL) {
#ifndef HAVE_FTRUNCATE
t_ret = __db_do_the_limbo(dbenv,
NULL, txn, txn->txn_list, LIMBO_NORMAL);
if (t_ret != 0 && ret == 0)
ret = t_ret;
#endif
__db_txnlist_end(dbenv, txn->txn_list);
txn->txn_list = NULL;
}
if (ret != 0)
goto err;
return (__txn_end(txn, 1));
err:
if (td->status == TXN_PREPARED)
return (__db_panic(dbenv, ret));
if ((t_ret = __txn_abort(txn)) != 0)
ret = t_ret;
return (ret);
}
static int
__txn_abort_pp(txn)
DB_TXN *txn;
{
DB_ENV *dbenv;
DB_THREAD_INFO *ip;
int not_child, ret, t_ret;
dbenv = txn->mgrp->dbenv;
not_child = txn->parent == NULL;
ENV_ENTER(dbenv, ip);
ret = __txn_abort(txn);
if (not_child && IS_ENV_REPLICATED(dbenv) &&
(t_ret = __op_rep_exit(dbenv)) != 0 && ret == 0)
ret = t_ret;
ENV_LEAVE(dbenv, ip);
return (ret);
}
int
__txn_abort(txn)
DB_TXN *txn;
{
DB_ENV *dbenv;
DB_LOCKREQ request;
DB_TXN *kid;
REGENV *renv;
REGINFO *infop;
TXN_DETAIL *td;
u_int32_t id;
int ret;
dbenv = txn->mgrp->dbenv;
td = txn->td;
PANIC_CHECK(dbenv);
if ((ret = __txn_isvalid(txn, TXN_OP_ABORT)) != 0)
return (__db_panic(dbenv, ret));
while ((kid = TAILQ_FIRST(&txn->kids)) != NULL)
if ((ret = __txn_abort(kid)) != 0)
return (ret);
infop = dbenv->reginfo;
renv = infop->primary;
id = renv->envid;
if (IS_ZERO_LSN(td->last_lsn) && STAILQ_FIRST(&txn->logs) == NULL) {
if (txn->txn_list == NULL)
goto done;
else
goto undo;
}
if (LOCKING_ON(dbenv)) {
if (txn->locker == NULL &&
(ret = __lock_getlocker(dbenv->lk_handle,
txn->txnid, 1, &txn->locker)) != 0)
return (__db_panic(dbenv, ret));
if ((ret = __txn_doevents(dbenv, txn, TXN_ABORT, 1)) != 0)
return (__db_panic(dbenv, ret));
if ((ret = __lock_set_timeout(dbenv,
txn->locker, 0, DB_SET_TXN_TIMEOUT)) != 0)
return (__db_panic(dbenv, ret));
if ((ret = __lock_set_timeout(dbenv,
txn->locker, 0, DB_SET_LOCK_TIMEOUT)) != 0)
return (__db_panic(dbenv, ret));
request.op = DB_LOCK_UPGRADE_WRITE;
request.obj = NULL;
if ((ret = __lock_vec(
dbenv, txn->locker, DB_LOCK_ABORT, &request, 1, NULL)) != 0)
return (__db_panic(dbenv, ret));
}
undo: if ((ret = __txn_undo(txn)) != 0)
return (__db_panic(dbenv, ret));
done: if (DBENV_LOGGING(dbenv) && td->status == TXN_PREPARED &&
(ret = __txn_regop_log(dbenv, txn, &td->last_lsn,
LOG_FLAGS(txn), TXN_ABORT, (int32_t)time(NULL), id, NULL)) != 0)
return (__db_panic(dbenv, ret));
return (__txn_end(txn, 0));
}
static int
__txn_discard(txn, flags)
DB_TXN *txn;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_THREAD_INFO *ip;
int ret, t_ret;
dbenv = txn->mgrp->dbenv;
ENV_ENTER(dbenv, ip);
ret = __txn_discard_int(txn, flags);
if (IS_ENV_REPLICATED(dbenv) &&
(t_ret = __op_rep_exit(dbenv)) != 0 && ret == 0)
ret = t_ret;
ENV_LEAVE(dbenv, ip);
return (ret);
}
int
__txn_discard_int(txn, flags)
DB_TXN *txn;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_TXN *freep;
DB_TXNMGR *mgr;
int ret;
COMPQUIET(flags, 0);
mgr = txn->mgrp;
dbenv = mgr->dbenv;
freep = NULL;
PANIC_CHECK(dbenv);
if ((ret = __txn_isvalid(txn, TXN_OP_DISCARD)) != 0)
return (ret);
DB_ASSERT(dbenv, TAILQ_FIRST(&txn->kids) == NULL);
MUTEX_LOCK(dbenv, mgr->mutex);
mgr->n_discards++;
if (F_ISSET(txn, TXN_MALLOC)) {
TAILQ_REMOVE(&mgr->txn_chain, txn, links);
freep = txn;
}
MUTEX_UNLOCK(dbenv, mgr->mutex);
if (freep != NULL)
__os_free(dbenv, freep);
return (0);
}
int
__txn_prepare(txn, gid)
DB_TXN *txn;
u_int8_t *gid;
{
DBT list_dbt, xid;
DB_ENV *dbenv;
DB_LOCKREQ request;
DB_THREAD_INFO *ip;
DB_TXN *kid;
TXN_DETAIL *td;
u_int32_t lflags;
int ret;
dbenv = txn->mgrp->dbenv;
td = txn->td;
PANIC_CHECK(dbenv);
if ((ret = __txn_isvalid(txn, TXN_OP_PREPARE)) != 0)
return (ret);
if (F_ISSET(txn, TXN_DEADLOCK))
return (__db_txn_deadlock_err(dbenv, txn));
ENV_ENTER(dbenv, ip);
while ((kid = TAILQ_FIRST(&txn->kids)) != NULL)
if ((ret = __txn_commit(kid, DB_TXN_NOSYNC)) != 0)
goto err;
#ifndef HAVE_FTRUNCATE
if (txn->txn_list != NULL &&
(ret = __db_do_the_limbo(dbenv,
NULL, txn, txn->txn_list, LIMBO_PREPARE)) != 0)
goto err;
#endif
if ((ret = __txn_doevents(dbenv, txn, TXN_PREPARE, 1)) != 0)
goto err;
memset(&request, 0, sizeof(request));
if (LOCKING_ON(dbenv)) {
request.op = DB_LOCK_PUT_READ;
if (!IS_ZERO_LSN(td->last_lsn)) {
memset(&list_dbt, 0, sizeof(list_dbt));
request.obj = &list_dbt;
}
if ((ret = __lock_vec(dbenv,
txn->locker, 0, &request, 1, NULL)) != 0)
goto err;
}
if (DBENV_LOGGING(dbenv)) {
memset(&xid, 0, sizeof(xid));
if (td->xa_status != TXN_XA_ENDED &&
td->xa_status != TXN_XA_SUSPENDED)
memcpy(td->xid, gid, sizeof(td->xid));
xid.size = sizeof(td->xid);
xid.data = td->xid;
lflags = DB_LOG_COMMIT | DB_FLUSH;
if ((ret = __txn_xa_regop_log(dbenv, txn, &td->last_lsn,
lflags, TXN_PREPARE, &xid, td->format, td->gtrid, td->bqual,
&td->begin_lsn, request.obj)) != 0)
__db_err(
dbenv, ret, "DB_TXN->prepare: log_write failed");
if (request.obj != NULL && request.obj->data != NULL)
__os_free(dbenv, request.obj->data);
if (ret != 0)
goto err;
}
MUTEX_LOCK(dbenv, txn->mgrp->mutex);
td->status = TXN_PREPARED;
MUTEX_UNLOCK(dbenv, txn->mgrp->mutex);
err: ENV_LEAVE(dbenv, ip);
return (ret);
}
u_int32_t
__txn_id(txn)
DB_TXN *txn;
{
return (txn->txnid);
}
int
__txn_get_name(txn, namep)
DB_TXN *txn;
const char **namep;
{
*namep = txn->name;
return (0);
}
int
__txn_set_name(txn, name)
DB_TXN *txn;
const char *name;
{
DB_ENV *dbenv;
DB_THREAD_INFO *ip;
DB_TXNMGR *mgr;
TXN_DETAIL *td;
size_t len;
int ret;
char *p;
mgr = txn->mgrp;
dbenv = mgr->dbenv;
td = txn->td;
len = strlen(name) + 1;
if ((ret = __os_realloc(dbenv, len, &txn->name)) != 0)
return (ret);
memcpy(txn->name, name, len);
ENV_ENTER(dbenv, ip);
TXN_SYSTEM_LOCK(dbenv);
if (td->name != INVALID_ROFF) {
__env_alloc_free(
&mgr->reginfo, R_ADDR(&mgr->reginfo, td->name));
td->name = INVALID_ROFF;
}
if ((ret = __env_alloc(&mgr->reginfo, len, &p)) != 0) {
TXN_SYSTEM_UNLOCK(dbenv);
__db_errx(dbenv,
"Unable to allocate memory for transaction name");
__os_free(dbenv, txn->name);
txn->name = NULL;
ENV_LEAVE(dbenv, ip);
return (ret);
}
TXN_SYSTEM_UNLOCK(dbenv);
td->name = R_OFFSET(&mgr->reginfo, p);
memcpy(p, name, len);
#ifdef DIAGNOSTIC
if (DBENV_LOGGING(dbenv))
(void)__log_printf(dbenv, txn,
"transaction %#lx named %s", (u_long)txn->txnid, name);
#endif
ENV_LEAVE(dbenv, ip);
return (0);
}
int
__txn_set_timeout(txn, timeout, op)
DB_TXN *txn;
db_timeout_t timeout;
u_int32_t op;
{
DB_ENV *dbenv;
DB_THREAD_INFO *ip;
int ret;
dbenv = txn->mgrp->dbenv;
if (op != DB_SET_TXN_TIMEOUT && op != DB_SET_LOCK_TIMEOUT)
return (__db_ferr(dbenv, "DB_TXN->set_timeout", 0));
ENV_ENTER(dbenv, ip);
ret = __lock_set_timeout( dbenv, txn->locker, timeout, op);
ENV_LEAVE(txn->mgrp->dbenv, ip);
return (ret);
}
static int
__txn_isvalid(txn, op)
const DB_TXN *txn;
txnop_t op;
{
DB_ENV *dbenv;
DB_TXNMGR *mgr;
DB_TXNREGION *region;
TXN_DETAIL *td;
mgr = txn->mgrp;
dbenv = mgr->dbenv;
region = mgr->reginfo.primary;
if (!F_ISSET(txn, TXN_COMPENSATE) &&
F_ISSET(region, TXN_IN_RECOVERY)) {
__db_errx(dbenv, "operation not permitted during recovery");
goto err;
}
if (txn->cursors != 0) {
__db_errx(dbenv, "transaction has active cursors");
goto err;
}
td = txn->td;
switch (op) {
case TXN_OP_DISCARD:
if (txn->txnid != td->txnid)
return (0);
if (td->status != TXN_PREPARED &&
!F_ISSET(td, TXN_DTL_RESTORED)) {
__db_errx(dbenv, "not a restored transaction");
return (__db_panic(dbenv, EINVAL));
}
return (0);
case TXN_OP_PREPARE:
if (txn->parent != NULL) {
__db_errx(dbenv,
"Prepare disallowed on child transactions");
return (EINVAL);
}
break;
case TXN_OP_ABORT:
case TXN_OP_COMMIT:
default:
break;
}
switch (td->status) {
case TXN_PREPARED:
if (op == TXN_OP_PREPARE) {
__db_errx(dbenv, "transaction already prepared");
return (EINVAL);
}
break;
case TXN_RUNNING:
break;
case TXN_ABORTED:
case TXN_COMMITTED:
default:
__db_errx(dbenv, "transaction already %s",
td->status == TXN_COMMITTED ? "committed" : "aborted");
goto err;
}
return (0);
err:
return (__db_panic(dbenv, EINVAL));
}
static int
__txn_end(txn, is_commit)
DB_TXN *txn;
int is_commit;
{
DB_ENV *dbenv;
DB_LOCKREQ request;
DB_TXNLOGREC *lr;
DB_TXNMGR *mgr;
DB_TXNREGION *region;
TXN_DETAIL *ptd, *td;
db_mutex_t mvcc_mtx;
int do_closefiles, ret;
mgr = txn->mgrp;
dbenv = mgr->dbenv;
region = mgr->reginfo.primary;
do_closefiles = 0;
if ((ret = __txn_doevents(dbenv,
txn, is_commit ? TXN_COMMIT : TXN_ABORT, 0)) != 0)
return (__db_panic(dbenv, ret));
if (LOCKING_ON(dbenv)) {
if (txn->locker == NULL &&
(ret = __lock_getlocker(dbenv->lk_handle,
txn->txnid, 1, &txn->locker)) != 0)
return (__db_panic(dbenv, ret));
request.op = txn->parent == NULL ||
is_commit == 0 ? DB_LOCK_PUT_ALL : DB_LOCK_INHERIT;
request.obj = NULL;
if ((ret = __lock_vec(dbenv,
txn->locker, 0, &request, 1, NULL)) != 0)
return (__db_panic(dbenv, ret));
}
td = txn->td;
if (td->nlog_dbs != 0 && (ret = __txn_dref_fname(dbenv, txn)) != 0)
return (__db_panic(dbenv, ret));
if (td->mvcc_ref != 0 && IS_MAX_LSN(td->visible_lsn)) {
DB_ASSERT(dbenv, !is_commit);
if ((ret = __log_current_lsn(dbenv, &td->visible_lsn,
NULL, NULL)) != 0)
return (__db_panic(dbenv, ret));
}
TXN_SYSTEM_LOCK(dbenv);
td->status = is_commit ? TXN_COMMITTED : TXN_ABORTED;
SH_TAILQ_REMOVE(®ion->active_txn, td, links, __txn_detail);
if (F_ISSET(td, TXN_DTL_RESTORED)) {
region->stat.st_nrestores--;
do_closefiles = region->stat.st_nrestores == 0;
}
if (td->name != INVALID_ROFF) {
__env_alloc_free(
&mgr->reginfo, R_ADDR(&mgr->reginfo, td->name));
td->name = INVALID_ROFF;
}
if (txn->parent != NULL) {
ptd = txn->parent->td;
SH_TAILQ_REMOVE(&ptd->kids, td, klinks, __txn_detail);
} else if ((mvcc_mtx = td->mvcc_mtx) != MUTEX_INVALID) {
MUTEX_LOCK(dbenv, mvcc_mtx);
if (td->mvcc_ref != 0) {
SH_TAILQ_INSERT_HEAD(®ion->mvcc_txn,
td, links, __txn_detail);
#ifdef HAVE_STATISTICS
if (++region->stat.st_nsnapshot >
region->stat.st_maxnsnapshot)
region->stat.st_maxnsnapshot =
region->stat.st_nsnapshot;
#endif
td = NULL;
}
MUTEX_UNLOCK(dbenv, mvcc_mtx);
if (td != NULL)
if ((ret = __mutex_free(dbenv, &td->mvcc_mtx)) != 0)
return (__db_panic(dbenv, ret));
}
if (td != NULL) {
if (td->nlog_slots != TXN_NSLOTS)
__env_alloc_free(&mgr->reginfo,
R_ADDR(&mgr->reginfo, td->log_dbs));
__env_alloc_free(&mgr->reginfo, td);
}
#ifdef HAVE_STATISTICS
if (is_commit)
region->stat.st_ncommits++;
else
region->stat.st_naborts++;
--region->stat.st_nactive;
#endif
TXN_SYSTEM_UNLOCK(dbenv);
if (LOCKING_ON(dbenv) && (ret =
__lock_freefamilylocker(dbenv->lk_handle, txn->locker)) != 0)
return (__db_panic(dbenv, ret));
if (txn->parent != NULL)
TAILQ_REMOVE(&txn->parent->kids, txn, klinks);
while ((lr = STAILQ_FIRST(&txn->logs)) != NULL) {
STAILQ_REMOVE(&txn->logs, lr, __txn_logrec, links);
__os_free(dbenv, lr);
}
if (txn->name != NULL) {
__os_free(dbenv, txn->name);
txn->name = NULL;
}
if (F_ISSET(txn, TXN_MALLOC)) {
MUTEX_LOCK(dbenv, mgr->mutex);
TAILQ_REMOVE(&mgr->txn_chain, txn, links);
MUTEX_UNLOCK(dbenv, mgr->mutex);
__os_free(dbenv, txn);
}
if (do_closefiles) {
(void)__dbreg_invalidate_files(dbenv, 1);
(void)__dbreg_close_files(dbenv, 1);
if (IS_REP_MASTER(dbenv))
F_CLR(dbenv->rep_handle, DBREP_OPENFILES);
F_CLR(dbenv->lg_handle, DBLOG_OPENFILES);
mgr->n_discards = 0;
(void)__txn_checkpoint(dbenv, 0, 0,
DB_CKP_INTERNAL | DB_FORCE);
}
return (0);
}
static int
__txn_dispatch_undo(dbenv, txn, rdbt, key_lsn, txnlist)
DB_ENV *dbenv;
DB_TXN *txn;
DBT *rdbt;
DB_LSN *key_lsn;
DB_TXNHEAD *txnlist;
{
int ret;
txnlist->td = txn->td;
ret = __db_dispatch(dbenv, dbenv->recover_dtab,
dbenv->recover_dtab_size, rdbt, key_lsn, DB_TXN_ABORT, txnlist);
if (ret == DB_SURPRISE_KID) {
F_SET(txn, TXN_CHILDCOMMIT);
ret = 0;
}
if (ret == 0 && F_ISSET(txn, TXN_CHILDCOMMIT) && IS_ZERO_LSN(*key_lsn))
ret = __db_txnlist_lsnget(dbenv, txnlist, key_lsn, 0);
return (ret);
}
static int
__txn_undo(txn)
DB_TXN *txn;
{
DBT rdbt;
DB_ENV *dbenv;
DB_LOGC *logc;
DB_LSN key_lsn;
DB_TXN *ptxn;
DB_TXNHEAD *txnlist;
DB_TXNLOGREC *lr;
DB_TXNMGR *mgr;
int ret, t_ret;
mgr = txn->mgrp;
dbenv = mgr->dbenv;
logc = NULL;
txnlist = NULL;
ret = 0;
if (!LOGGING_ON(dbenv))
return (0);
memset(&rdbt, 0, sizeof(rdbt));
for (ptxn = txn->parent; ptxn != NULL && ptxn->parent != NULL;)
ptxn = ptxn->parent;
if (ptxn != NULL && ptxn->txn_list != NULL)
txnlist = ptxn->txn_list;
else if (txn->txn_list != NULL)
txnlist = txn->txn_list;
else if ((ret = __db_txnlist_init(dbenv, 0, 0, NULL, &txnlist)) != 0)
return (ret);
else if (ptxn != NULL)
ptxn->txn_list = txnlist;
STAILQ_FOREACH(lr, &txn->logs, links) {
rdbt.data = lr->data;
rdbt.size = 0;
LSN_NOT_LOGGED(key_lsn);
ret =
__txn_dispatch_undo(dbenv, txn, &rdbt, &key_lsn, txnlist);
if (ret != 0) {
__db_err(dbenv, ret,
"DB_TXN->abort: in-memory log undo failed");
goto err;
}
}
key_lsn = ((TXN_DETAIL *)txn->td)->last_lsn;
if (!IS_ZERO_LSN(key_lsn) &&
(ret = __log_cursor(dbenv, &logc)) != 0)
goto err;
while (!IS_ZERO_LSN(key_lsn)) {
if ((ret = __logc_get(logc, &key_lsn, &rdbt, DB_SET)) == 0) {
ret = __txn_dispatch_undo(dbenv,
txn, &rdbt, &key_lsn, txnlist);
}
if (ret != 0) {
__db_err(dbenv, ret,
"DB_TXN->abort: log undo failed for LSN: %lu %lu",
(u_long)key_lsn.file, (u_long)key_lsn.offset);
goto err;
}
}
#ifndef HAVE_FTRUNCATE
ret = __db_do_the_limbo(dbenv, ptxn, txn, txnlist, LIMBO_NORMAL);
#endif
err: if (logc != NULL && (t_ret = __logc_close(logc)) != 0 && ret == 0)
ret = t_ret;
if (ptxn == NULL && txnlist != NULL)
__db_txnlist_end(dbenv, txnlist);
return (ret);
}
int
__txn_activekids(dbenv, rectype, txn)
DB_ENV *dbenv;
u_int32_t rectype;
DB_TXN *txn;
{
if (F_ISSET(txn, TXN_COMPENSATE) || rectype == DB___txn_child)
return (0);
if (TAILQ_FIRST(&txn->kids) != NULL) {
__db_errx(dbenv, "Child transaction is active");
return (EPERM);
}
return (0);
}
int
__txn_force_abort(dbenv, buffer)
DB_ENV *dbenv;
u_int8_t *buffer;
{
DB_CIPHER *db_cipher;
HDR hdr, *hdrp;
u_int32_t offset, opcode, sum_len;
u_int8_t *bp, *key, chksum[DB_MAC_KEY];
size_t hdrsize, rec_len;
int ret;
db_cipher = dbenv->crypto_handle;
hdrsize = CRYPTO_ON(dbenv) ? HDR_CRYPTO_SZ : HDR_NORMAL_SZ;
hdrp = (HDR *)buffer;
memcpy(&hdr.prev, buffer + SSZ(HDR, prev), sizeof(hdr.prev));
memcpy(&hdr.len, buffer + SSZ(HDR, len), sizeof(hdr.len));
rec_len = hdr.len - hdrsize;
offset = sizeof(u_int32_t) + sizeof(u_int32_t) + sizeof(DB_LSN);
if (CRYPTO_ON(dbenv)) {
key = db_cipher->mac_key;
sum_len = DB_MAC_KEY;
if ((ret = db_cipher->decrypt(dbenv, db_cipher->data,
&hdrp->iv[0], buffer + hdrsize, rec_len)) != 0)
return (__db_panic(dbenv, ret));
} else {
key = NULL;
sum_len = sizeof(u_int32_t);
}
bp = buffer + hdrsize + offset;
opcode = TXN_ABORT;
memcpy(bp, &opcode, sizeof(opcode));
if (CRYPTO_ON(dbenv) &&
(ret = db_cipher->encrypt(dbenv,
db_cipher->data, &hdrp->iv[0], buffer + hdrsize, rec_len)) != 0)
return (__db_panic(dbenv, ret));
__db_chksum(&hdr, buffer + hdrsize, rec_len, key, chksum);
memcpy(buffer + SSZA(HDR, chksum), chksum, sum_len);
return (0);
}
int
__txn_preclose(dbenv)
DB_ENV *dbenv;
{
DB_TXNMGR *mgr;
DB_TXNREGION *region;
int do_closefiles, ret;
mgr = dbenv->tx_handle;
region = mgr->reginfo.primary;
do_closefiles = 0;
TXN_SYSTEM_LOCK(dbenv);
if (region != NULL &&
region->stat.st_nrestores <= mgr->n_discards &&
mgr->n_discards != 0)
do_closefiles = 1;
TXN_SYSTEM_UNLOCK(dbenv);
if (do_closefiles) {
F_SET(dbenv->lg_handle, DBLOG_RECOVER);
ret = __dbreg_close_files(dbenv, 0);
F_CLR(dbenv->lg_handle, DBLOG_RECOVER);
} else
ret = 0;
return (ret);
}
int
__txn_reset(dbenv)
DB_ENV *dbenv;
{
DB_LSN scrap;
DB_TXNREGION *region;
region = dbenv->tx_handle->reginfo.primary;
region->last_txnid = TXN_MINIMUM;
DB_ASSERT(dbenv, LOGGING_ON(dbenv));
return (__txn_recycle_log(dbenv,
NULL, &scrap, 0, TXN_MINIMUM, TXN_MAXIMUM));
}
static void
__txn_set_txn_lsnp(txn, blsnp, llsnp)
DB_TXN *txn;
DB_LSN **blsnp, **llsnp;
{
TXN_DETAIL *td;
td = txn->td;
*llsnp = &td->last_lsn;
while (txn->parent != NULL)
txn = txn->parent;
td = txn->td;
if (IS_ZERO_LSN(td->begin_lsn))
*blsnp = &td->begin_lsn;
}