#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_am.h"
#include "dbinc/log.h"
#include "dbinc/txn.h"
static int __rep_dorecovery __P((DB_ENV *, DB_LSN *, DB_LSN *));
int
__rep_verify(dbenv, rp, rec, eid, savetime)
DB_ENV *dbenv;
REP_CONTROL *rp;
DBT *rec;
int eid;
time_t savetime;
{
DB_LOG *dblp;
DB_LOGC *logc;
DB_LSN lsn;
DB_REP *db_rep;
DBT mylog;
LOG *lp;
REP *rep;
u_int32_t rectype;
int match, ret, t_ret;
ret = 0;
db_rep = dbenv->rep_handle;
rep = db_rep->region;
dblp = dbenv->lg_handle;
lp = dblp->reginfo.primary;
MUTEX_LOCK(dbenv, rep->mtx_clientdb);
lsn = lp->verify_lsn;
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
if (IS_ZERO_LSN(lsn))
return (ret);
if (IS_USING_LEASES(dbenv)) {
REP_SYSTEM_LOCK(dbenv);
DB_ASSERT(dbenv, __rep_islease_granted(dbenv) == 0);
REP_SYSTEM_UNLOCK(dbenv);
}
if ((ret = __log_cursor(dbenv, &logc)) != 0)
return (ret);
memset(&mylog, 0, sizeof(mylog));
if ((ret = __logc_get(logc, &rp->lsn, &mylog, DB_SET)) != 0)
goto err;
match = 0;
memcpy(&rectype, mylog.data, sizeof(rectype));
if (mylog.size == rec->size &&
memcmp(mylog.data, rec->data, rec->size) == 0)
match = 1;
if (match == 0) {
ZERO_LSN(lsn);
if ((ret = __rep_log_backup(dbenv, rep, logc, &lsn)) == 0) {
MUTEX_LOCK(dbenv, rep->mtx_clientdb);
lp->verify_lsn = lsn;
lp->rcvd_recs = 0;
lp->wait_recs = rep->request_gap;
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
(void)__rep_send_message(dbenv, eid, REP_VERIFY_REQ,
&lsn, NULL, 0, DB_REP_ANYWHERE);
} else if (ret == DB_NOTFOUND) {
if (rp->lsn.file == 1) {
__db_errx(dbenv,
"Client was never part of master's environment");
ret = DB_REP_JOIN_FAILURE;
} else {
STAT(rep->stat.st_outdated++);
REP_SYSTEM_LOCK(dbenv);
F_CLR(rep, REP_F_RECOVER_VERIFY);
if (FLD_ISSET(rep->config, REP_C_NOAUTOINIT) ||
rep->version == DB_REPVERSION_42)
ret = DB_REP_JOIN_FAILURE;
else {
F_SET(rep, REP_F_RECOVER_UPDATE);
ZERO_LSN(rep->first_lsn);
ret = 0;
}
REP_SYSTEM_UNLOCK(dbenv);
if (ret == 0)
(void)__rep_send_message(dbenv,
eid, REP_UPDATE_REQ, NULL,
NULL, 0, 0);
}
}
} else
ret = __rep_verify_match(dbenv, &rp->lsn, savetime);
err: if ((t_ret = __logc_close(logc)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__rep_verify_fail(dbenv, rp, eid)
DB_ENV *dbenv;
REP_CONTROL *rp;
int eid;
{
DB_LOG *dblp;
DB_REP *db_rep;
LOG *lp;
REP *rep;
int ret;
ret = 0;
db_rep = dbenv->rep_handle;
rep = db_rep->region;
dblp = dbenv->lg_handle;
lp = dblp->reginfo.primary;
if (F_ISSET(rep, REP_F_RECOVER_MASK) &&
!F_ISSET(rep, REP_F_RECOVER_VERIFY))
return (0);
MUTEX_LOCK(dbenv, rep->mtx_clientdb);
REP_SYSTEM_LOCK(dbenv);
DB_ASSERT(dbenv,
!IS_USING_LEASES(dbenv) || __rep_islease_granted(dbenv) == 0);
STAT(rep->stat.st_outdated++);
if (FLD_ISSET(rep->config, REP_C_NOAUTOINIT) &&
((F_ISSET(rep, REP_F_RECOVER_VERIFY) &&
LOG_COMPARE(&rp->lsn, &lp->verify_lsn) == 0) ||
(F_ISSET(rep, REP_F_RECOVER_MASK) == 0 &&
LOG_COMPARE(&rp->lsn, &lp->ready_lsn) >= 0))) {
ret = DB_REP_JOIN_FAILURE;
goto unlock;
}
if (((F_ISSET(rep, REP_F_RECOVER_VERIFY)) &&
LOG_COMPARE(&rp->lsn, &lp->verify_lsn) == 0) ||
(F_ISSET(rep, REP_F_RECOVER_MASK) == 0 &&
LOG_COMPARE(&rp->lsn, &lp->ready_lsn) >= 0)) {
F_CLR(rep, REP_F_RECOVER_VERIFY);
F_SET(rep, REP_F_RECOVER_UPDATE);
ZERO_LSN(rep->first_lsn);
lp->wait_recs = rep->request_gap;
REP_SYSTEM_UNLOCK(dbenv);
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
(void)__rep_send_message(dbenv,
eid, REP_UPDATE_REQ, NULL, NULL, 0, 0);
} else {
unlock: REP_SYSTEM_UNLOCK(dbenv);
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
}
return (ret);
}
int
__rep_verify_req(dbenv, rp, eid)
DB_ENV *dbenv;
REP_CONTROL *rp;
int eid;
{
DB_LOGC *logc;
DB_REP *db_rep;
DBT *d, data_dbt;
REP *rep;
u_int32_t type;
int old, ret;
ret = 0;
db_rep = dbenv->rep_handle;
rep = db_rep->region;
type = REP_VERIFY;
if ((ret = __log_cursor(dbenv, &logc)) != 0)
return (ret);
d = &data_dbt;
memset(d, 0, sizeof(data_dbt));
F_SET(logc, DB_LOG_SILENT_ERR);
ret = __logc_get(logc, &rp->lsn, d, DB_SET);
if (ret == DB_NOTFOUND) {
if (F_ISSET(rep, REP_F_CLIENT)) {
(void)__logc_close(logc);
return (DB_NOTFOUND);
}
if (__log_is_outdated(dbenv, rp->lsn.file, &old) == 0 &&
old != 0)
type = REP_VERIFY_FAIL;
}
if (ret != 0)
d = NULL;
(void)__rep_send_message(dbenv, eid, type, &rp->lsn, d, 0, 0);
return (__logc_close(logc));
}
static int
__rep_dorecovery(dbenv, lsnp, trunclsnp)
DB_ENV *dbenv;
DB_LSN *lsnp, *trunclsnp;
{
DB_LSN last_ckp, lsn;
DB_REP *db_rep;
DBT mylog;
DB_LOGC *logc;
REP *rep;
int ret, skip_rec, t_ret, update;
u_int32_t rectype, opcode;
__txn_regop_args *txnrec;
__txn_regop_42_args *txn42rec;
db_rep = dbenv->rep_handle;
rep = db_rep->region;
if ((ret = __log_cursor(dbenv, &logc)) != 0)
return (ret);
memset(&mylog, 0, sizeof(mylog));
if (F_ISSET(rep, REP_F_RECOVER_LOG)) {
skip_rec = 0;
update = 1;
} else {
skip_rec = 1;
update = 0;
}
while (update == 0 &&
(ret = __logc_get(logc, &lsn, &mylog, DB_PREV)) == 0 &&
LOG_COMPARE(&lsn, lsnp) > 0) {
memcpy(&rectype, mylog.data, sizeof(rectype));
DB_ASSERT(dbenv, rep->op_cnt == 0);
DB_ASSERT(dbenv, rep->msg_th == 1);
if (rectype == DB___txn_regop || rectype == DB___txn_ckp ||
rectype == DB___dbreg_register)
skip_rec = 0;
if (rectype == DB___txn_regop) {
if (rep->version >= DB_REPVERSION_44) {
if ((ret = __txn_regop_read(dbenv,
mylog.data, &txnrec)) != 0)
goto err;
opcode = txnrec->opcode;
__os_free(dbenv, txnrec);
} else {
if ((ret = __txn_regop_42_read(dbenv,
mylog.data, &txn42rec)) != 0)
goto err;
opcode = txn42rec->opcode;
__os_free(dbenv, txn42rec);
}
if (opcode != TXN_ABORT)
update = 1;
}
}
if (ret != 0)
goto err;
if (skip_rec) {
if ((ret = __log_get_stable_lsn(dbenv, &last_ckp)) != 0) {
if (ret != DB_NOTFOUND)
goto err;
ZERO_LSN(last_ckp);
}
RPRINT(dbenv, (dbenv,
"Skip sync-up rec. Truncate log to [%lu][%lu], ckp [%lu][%lu]",
(u_long)lsnp->file, (u_long)lsnp->offset,
(u_long)last_ckp.file, (u_long)last_ckp.offset));
ret = __log_vtruncate(dbenv, lsnp, &last_ckp, trunclsnp);
} else
ret = __db_apprec(dbenv, lsnp, trunclsnp, update, 0);
if (ret != 0)
goto err;
F_SET(db_rep, DBREP_OPENFILES);
err: if ((t_ret = __logc_close(logc)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__rep_verify_match(dbenv, reclsnp, savetime)
DB_ENV *dbenv;
DB_LSN *reclsnp;
time_t savetime;
{
DB_LOG *dblp;
DB_LSN trunclsn;
DB_REP *db_rep;
LOG *lp;
REGENV *renv;
REGINFO *infop;
REP *rep;
int done, master, ret;
u_int32_t unused;
dblp = dbenv->lg_handle;
db_rep = dbenv->rep_handle;
rep = db_rep->region;
lp = dblp->reginfo.primary;
ret = 0;
infop = dbenv->reginfo;
renv = infop->primary;
MUTEX_LOCK(dbenv, rep->mtx_clientdb);
done = savetime != renv->rep_timestamp;
if (done) {
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
return (0);
}
ZERO_LSN(lp->verify_lsn);
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
REP_SYSTEM_LOCK(dbenv);
if (F_ISSET(rep, REP_F_READY_MSG) ||
(!F_ISSET(rep, REP_F_RECOVER_LOG) &&
F_ISSET(rep, REP_F_READY_API | REP_F_READY_OP))) {
STAT(rep->stat.st_msgs_recover++);
goto errunlock;
}
if ((ret = __rep_lockout_msg(dbenv, rep, 1)) != 0)
goto errunlock;
if ((ret = __rep_lockout_api(dbenv, rep)) != 0)
goto errunlock;
REP_SYSTEM_UNLOCK(dbenv);
if ((ret = __rep_dorecovery(dbenv, reclsnp, &trunclsn)) != 0 ||
(ret = __rep_remove_init_file(dbenv)) != 0) {
REP_SYSTEM_LOCK(dbenv);
F_CLR(rep, REP_F_READY_API | REP_F_READY_MSG | REP_F_READY_OP);
goto errunlock;
}
MUTEX_LOCK(dbenv, rep->mtx_clientdb);
lp->ready_lsn = trunclsn;
ZERO_LSN(lp->waiting_lsn);
ZERO_LSN(lp->max_wait_lsn);
lp->max_perm_lsn = *reclsnp;
lp->wait_recs = 0;
lp->rcvd_recs = 0;
ZERO_LSN(lp->verify_lsn);
if (db_rep->rep_db == NULL &&
(ret = __rep_client_dbinit(dbenv, 0, REP_DB)) != 0) {
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
goto out;
}
F_SET(db_rep->rep_db, DB_AM_RECOVER);
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
ret = __db_truncate(db_rep->rep_db, NULL, &unused);
MUTEX_LOCK(dbenv, rep->mtx_clientdb);
F_CLR(db_rep->rep_db, DB_AM_RECOVER);
REP_SYSTEM_LOCK(dbenv);
rep->stat.st_log_queued = 0;
F_CLR(rep, REP_F_NOARCHIVE | REP_F_RECOVER_MASK | REP_F_READY_MSG);
if (ret != 0)
goto errunlock2;
master = rep->master_id;
REP_SYSTEM_UNLOCK(dbenv);
if (master == DB_EID_INVALID) {
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
ret = 0;
} else {
lp->wait_recs = rep->max_gap;
MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
(void)__rep_send_message(dbenv,
master, REP_ALL_REQ, reclsnp, NULL, 0, DB_REP_ANYWHERE);
}
if (0) {
errunlock2: MUTEX_UNLOCK(dbenv, rep->mtx_clientdb);
errunlock: REP_SYSTEM_UNLOCK(dbenv);
}
out: return (ret);
}
int
__rep_log_backup(dbenv, rep, logc, lsn)
DB_ENV *dbenv;
REP *rep;
DB_LOGC *logc;
DB_LSN *lsn;
{
DBT mylog;
u_int32_t rectype;
int ret;
COMPQUIET(dbenv, NULL);
ret = 0;
memset(&mylog, 0, sizeof(mylog));
while ((ret = __logc_get(logc, lsn, &mylog, DB_PREV)) == 0) {
memcpy(&rectype, mylog.data, sizeof(rectype));
if (rep->version == DB_REPVERSION_42 &&
rectype != DB___txn_ckp && rectype != DB___txn_recycle &&
rectype != DB___dbreg_register)
break;
if (rep->version == DB_REPVERSION_43 &&
rectype == DB___txn_ckp)
break;
if (rep->version >= DB_REPVERSION_44 &&
(rectype == DB___txn_ckp || rectype == DB___txn_regop))
break;
}
return (ret);
}