#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_am.h"
#include "dbinc/log.h"
#define IS_PHASE1_DONE(rep) \
((rep)->sites >= (rep)->nsites && (rep)->w_priority > 0)
#define I_HAVE_WON(rep, winner) \
((rep)->votes >= (rep)->nvotes && winner == (rep)->eid)
static void __rep_cmp_vote __P((ENV *, REP *, int, DB_LSN *,
u_int32_t, u_int32_t, u_int32_t, u_int32_t));
static int __rep_elect_init
__P((ENV *, u_int32_t, u_int32_t, int *, u_int32_t *));
static int __rep_fire_elected __P((ENV *, REP *, u_int32_t));
static void __rep_elect_master __P((ENV *, REP *));
static int __rep_tally __P((ENV *, REP *, int, u_int32_t *, u_int32_t, roff_t));
static int __rep_wait __P((ENV *, db_timeout_t *, int *, int, u_int32_t));
int
__rep_elect(dbenv, given_nsites, nvotes, flags)
DB_ENV *dbenv;
u_int32_t given_nsites, nvotes;
u_int32_t flags;
{
DB_LOG *dblp;
DB_LSN lsn;
DB_REP *db_rep;
DB_THREAD_INFO *ip;
ENV *env;
LOG *lp;
REP *rep;
int done, eid, elected, full_elect, locked, in_progress, need_req;
int ret, send_vote, t_ret;
u_int32_t ack, ctlflags, egen, nsites, orig_tally, priority, realpri;
u_int32_t tiebreaker;
db_timeout_t timeout, to;
env = dbenv->env;
COMPQUIET(flags, 0);
COMPQUIET(egen, 0);
ENV_REQUIRES_CONFIG_XX(
env, rep_handle, "DB_ENV->rep_elect", DB_INIT_REP);
if (IS_USING_LEASES(env) && given_nsites != 0) {
__db_errx(env,
"DB_ENV->rep_elect: nsites must be zero if leases configured");
return (EINVAL);
}
db_rep = env->rep_handle;
rep = db_rep->region;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
elected = 0;
nsites = given_nsites == 0 ? rep->config_nsites : given_nsites;
ack = nvotes == 0 ? ELECTION_MAJORITY(nsites) : nvotes;
locked = 0;
if (ack <= (nsites / 2)) {
__db_errx(env,
"DB_ENV->rep_elect:WARNING: nvotes (%d) is sub-majority with nsites (%d)",
nvotes, nsites);
}
if (nsites < ack) {
__db_errx(env,
"DB_ENV->rep_elect: nvotes (%d) is larger than nsites (%d)",
ack, nsites);
return (EINVAL);
}
full_elect = 0;
timeout = rep->elect_timeout;
if (!F_ISSET(rep, REP_F_GROUP_ESTD) && rep->full_elect_timeout != 0) {
full_elect = 1;
timeout = rep->full_elect_timeout;
}
realpri = rep->priority;
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Start election nsites %d, ack %d, priority %d",
nsites, ack, realpri));
ctlflags = realpri != 0 ? REPCTL_ELECTABLE : 0;
ENV_ENTER(env, ip);
orig_tally = 0;
if ((ret = __rep_elect_init(env, nsites, ack,
&in_progress, &orig_tally)) != 0) {
if (ret == DB_REP_NEWMASTER)
ret = 0;
goto err;
}
if (in_progress)
goto edone;
priority = lp->persist.version != DB_LOGVERSION ? 0 : realpri;
#ifdef CONFIG_TEST
if (priority > 0 && priority <= 5) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Artificially setting priority 0 (ELECTABLE) for CONFIG_TEST mode"));
DB_ASSERT(env, ctlflags == REPCTL_ELECTABLE);
priority = 0;
}
#endif
__os_gettime(env, &rep->etime, 1);
REP_SYSTEM_LOCK(env);
if (IS_USING_LEASES(env)) {
to = __rep_lease_waittime(env);
if (to != 0) {
F_SET(rep, REP_F_EPHASE0);
REP_SYSTEM_UNLOCK(env);
(void)__rep_send_message(env, DB_EID_BROADCAST,
REP_MASTER_REQ, NULL, NULL, 0, 0);
ret = __rep_wait(env, &to, &eid,
0, REP_F_EPHASE0);
REP_SYSTEM_LOCK(env);
F_CLR(rep, REP_F_EPHASE0);
switch (ret) {
case DB_REP_EGENCHG:
case 0:
REP_SYSTEM_UNLOCK(env);
goto edone;
case DB_TIMEOUT:
break;
default:
goto lockdone;
}
}
}
if ((ret = __rep_lockout_apply(env, rep, 0)) != 0)
goto lockdone;
locked = 1;
to = timeout;
REP_SYSTEM_UNLOCK(env);
restart:
__os_unique_id(env, &tiebreaker);
LOG_SYSTEM_LOCK(env);
lsn = lp->lsn;
LOG_SYSTEM_UNLOCK(env);
REP_SYSTEM_LOCK(env);
F_SET(rep, REP_F_EPHASE1 | REP_F_NOARCHIVE);
F_CLR(rep, REP_F_TALLY);
if (IS_USING_LEASES(env) &&
__rep_islease_granted(env)) {
ret = 0;
goto lockdone;
}
if (F_ISSET(rep, REP_F_READY_API | REP_F_READY_OP |
REP_F_RECOVER_LOG | REP_F_RECOVER_PAGE | REP_F_RECOVER_UPDATE)) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Setting priority 0, unelectable, due to internal init/recovery"));
priority = 0;
ctlflags = 0;
}
if ((ret = __rep_write_egen(env, rep->egen + 1)) != 0)
goto lockdone;
if (__rep_tally(env, rep, rep->eid, &rep->sites, rep->egen,
rep->tally_off) != 0) {
ret = EINVAL;
goto lockdone;
}
__rep_cmp_vote(env, rep, rep->eid, &lsn, priority, rep->gen,
tiebreaker, ctlflags);
RPRINT(env, DB_VERB_REP_ELECT, (env, "Beginning an election"));
send_vote = DB_EID_INVALID;
egen = rep->egen;
done = IS_PHASE1_DONE(rep);
REP_SYSTEM_UNLOCK(env);
__rep_send_vote(env, &lsn, nsites, ack, priority, tiebreaker, egen,
DB_EID_BROADCAST, REP_VOTE1, ctlflags);
DB_ENV_TEST_RECOVERY(env, DB_TEST_ELECTVOTE1, ret, NULL);
if (done) {
REP_SYSTEM_LOCK(env);
goto vote;
}
ret = __rep_wait(env, &to, &eid, full_elect, REP_F_EPHASE1);
switch (ret) {
case 0:
if (eid != DB_EID_INVALID && !IN_ELECTION(rep)) {
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Ended election phase 1"));
goto edone;
}
goto phase2;
case DB_REP_EGENCHG:
if (to > timeout)
to = timeout;
to = (to * 8) / 10;
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Egen changed while waiting. Now %lu. New timeout %lu, orig timeout %lu",
(u_long)rep->egen, (u_long)to, (u_long)timeout));
goto restart;
case DB_TIMEOUT:
break;
default:
goto err;
}
REP_SYSTEM_LOCK(env);
if (egen != rep->egen) {
REP_SYSTEM_UNLOCK(env);
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Egen changed from %lu to %lu",
(u_long)egen, (u_long)rep->egen));
goto restart;
}
if (rep->sites >= rep->nvotes) {
vote:
send_vote = rep->winner;
if (rep->winner == rep->eid) {
(void)__rep_tally(env, rep, rep->eid, &rep->votes,
egen, rep->v2tally_off);
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Counted my vote %d", rep->votes));
}
F_SET(rep, REP_F_EPHASE2);
F_CLR(rep, REP_F_EPHASE1);
}
REP_SYSTEM_UNLOCK(env);
if (send_vote == DB_EID_INVALID) {
if (rep->sites >= rep->nvotes)
__db_errx(env,
"No electable site found: recvd %d of %d votes from %d sites",
rep->sites, rep->nvotes, rep->nsites);
else
__db_errx(env,
"Not enough votes to elect: recvd %d of %d from %d sites",
rep->sites, rep->nvotes, rep->nsites);
ret = DB_REP_UNAVAIL;
goto err;
}
if (send_vote != rep->eid) {
RPRINT(env, DB_VERB_REP_ELECT, (env, "Sending vote"));
__rep_send_vote(env, NULL, 0, 0, 0, 0, egen,
send_vote, REP_VOTE2, 0);
to = to * 2;
}
phase2:
if (I_HAVE_WON(rep, rep->winner)) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Skipping phase2 wait: already got %d votes", rep->votes));
REP_SYSTEM_LOCK(env);
goto i_won;
}
ret = __rep_wait(env, &to, &eid, full_elect, REP_F_EPHASE2);
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Ended election phase 2 %d", ret));
switch (ret) {
case 0:
if (eid != DB_EID_INVALID)
goto edone;
ret = DB_REP_UNAVAIL;
break;
case DB_REP_EGENCHG:
if (to > timeout)
to = timeout;
to = (to * 8) / 10;
RPRINT(env, DB_VERB_REP_ELECT, (env,
"While waiting egen changed to %lu. Phase 2 New timeout %lu, orig timeout %lu",
(u_long)rep->egen,
(u_long)to, (u_long)timeout));
goto restart;
case DB_TIMEOUT:
ret = DB_REP_UNAVAIL;
break;
default:
goto err;
}
REP_SYSTEM_LOCK(env);
if (egen != rep->egen) {
REP_SYSTEM_UNLOCK(env);
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Egen ph2 changed from %lu to %lu",
(u_long)egen, (u_long)rep->egen));
goto restart;
}
done = rep->votes >= rep->nvotes;
RPRINT(env, DB_VERB_REP_ELECT, (env,
"After phase 2: votes %d, nvotes %d, nsites %d",
rep->votes, rep->nvotes, rep->nsites));
if (I_HAVE_WON(rep, rep->winner)) {
i_won: __rep_elect_master(env, rep);
ret = 0;
elected = 1;
}
if (0) {
err: REP_SYSTEM_LOCK(env);
}
lockdone:
if (ret == 0 || ret == DB_REP_UNAVAIL)
__rep_elect_done(env, rep, 0);
else if (orig_tally)
F_SET(rep, orig_tally);
if (0) {
edone: REP_SYSTEM_LOCK(env);
}
F_CLR(rep, REP_F_INREPELECT);
if (locked) {
need_req = F_ISSET(rep, REP_F_SKIPPED_APPLY);
F_CLR(rep, REP_F_READY_APPLY | REP_F_SKIPPED_APPLY);
REP_SYSTEM_UNLOCK(env);
if (need_req && (t_ret = __rep_resend_req(env, 0)) != 0 &&
ret == 0)
ret = t_ret;
} else
REP_SYSTEM_UNLOCK(env);
if (elected)
ret = __rep_fire_elected(env, rep, egen);
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Ended election with %d, sites %d, egen %lu, flags 0x%lx",
ret, rep->sites, (u_long)rep->egen, (u_long)rep->flags));
DB_TEST_RECOVERY_LABEL
ENV_LEAVE(env, ip);
return (ret);
}
int
__rep_vote1(env, rp, rec, eid)
ENV *env;
__rep_control_args *rp;
DBT *rec;
int eid;
{
DBT data_dbt;
DB_LOG *dblp;
DB_LSN lsn;
DB_REP *db_rep;
LOG *lp;
REP *rep;
REP_OLD_VOTE_INFO *ovi;
__rep_egen_args egen_arg;
__rep_vote_info_args tmpvi, *vi;
u_int32_t egen;
int elected, master, ret;
u_int8_t buf[__REP_MAXMSG_SIZE];
size_t len;
COMPQUIET(egen, 0);
elected = ret = 0;
db_rep = env->rep_handle;
rep = db_rep->region;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
if (F_ISSET(rep, REP_F_MASTER)) {
RPRINT(env, DB_VERB_REP_ELECT, (env, "Master received vote"));
LOG_SYSTEM_LOCK(env);
lsn = lp->lsn;
LOG_SYSTEM_UNLOCK(env);
(void)__rep_send_message(env,
DB_EID_BROADCAST, REP_NEWMASTER, &lsn, NULL, 0, 0);
if (IS_USING_LEASES(env))
ret = __rep_lease_refresh(env);
return (ret);
}
if (rp->rep_version < DB_REPVERSION_47) {
ovi = (REP_OLD_VOTE_INFO *)rec->data;
tmpvi.egen = ovi->egen;
tmpvi.nsites = (u_int32_t)ovi->nsites;
tmpvi.nvotes = (u_int32_t)ovi->nvotes;
tmpvi.priority = (u_int32_t)ovi->priority;
tmpvi.tiebreaker = ovi->tiebreaker;
} else
if ((ret = __rep_vote_info_unmarshal(env,
&tmpvi, rec->data, rec->size, NULL)) != 0)
return (ret);
vi = &tmpvi;
REP_SYSTEM_LOCK(env);
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Received vote1 egen %lu, egen %lu",
(u_long)vi->egen, (u_long)rep->egen));
if (vi->egen < rep->egen) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Received old vote %lu, egen %lu, ignoring vote1",
(u_long)vi->egen, (u_long)rep->egen));
egen_arg.egen = rep->egen;
REP_SYSTEM_UNLOCK(env);
if (rep->version < DB_REPVERSION_47)
DB_INIT_DBT(data_dbt, &egen_arg.egen,
sizeof(egen_arg.egen));
else {
if ((ret = __rep_egen_marshal(env,
&egen_arg, buf, __REP_EGEN_SIZE, &len)) != 0)
return (ret);
DB_INIT_DBT(data_dbt, buf, len);
}
(void)__rep_send_message(env,
eid, REP_ALIVE, &rp->lsn, &data_dbt, 0, 0);
return (ret);
}
if (vi->egen > rep->egen) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Received VOTE1 from egen %lu, my egen %lu; reset",
(u_long)vi->egen, (u_long)rep->egen));
__rep_elect_done(env, rep, 0);
rep->egen = vi->egen;
F_SET(rep, REP_F_EGENUPDATE);
}
if (!IN_ELECTION_TALLY(rep)) {
F_SET(rep, REP_F_TALLY);
rep->nsites = vi->nsites;
rep->nvotes = vi->nvotes;
} else {
if (vi->nsites > rep->nsites)
rep->nsites = vi->nsites;
if (vi->nvotes > rep->nvotes)
rep->nvotes = vi->nvotes;
}
if (rep->sites + 1 > rep->nsites)
rep->nsites = rep->sites + 1;
if (rep->nsites > rep->asites &&
(ret = __rep_grow_sites(env, rep->nsites)) != 0) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Grow sites returned error %d", ret));
goto err;
}
if (F_ISSET(rep, REP_F_EPHASE2)) {
RPRINT(env, DB_VERB_REP_ELECT,
(env, "In phase 2, ignoring vote1"));
goto err;
}
if ((ret = __rep_tally(env, rep, eid, &rep->sites,
vi->egen, rep->tally_off)) != 0) {
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Tally returned %d, sites %d", ret, rep->sites));
ret = 0;
goto err;
}
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Incoming vote: (eid)%d (pri)%lu %s (gen)%lu (egen)%lu [%lu,%lu]",
eid, (u_long)vi->priority,
F_ISSET(rp, REPCTL_ELECTABLE) ? "ELECTABLE" : "",
(u_long)rp->gen, (u_long)vi->egen,
(u_long)rp->lsn.file, (u_long)rp->lsn.offset));
if (rep->sites > 1)
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Existing vote: (eid)%d (pri)%lu (gen)%lu (sites)%d [%lu,%lu]",
rep->winner, (u_long)rep->w_priority,
(u_long)rep->w_gen, rep->sites,
(u_long)rep->w_lsn.file,
(u_long)rep->w_lsn.offset));
__rep_cmp_vote(env, rep, eid, &rp->lsn, vi->priority,
rp->gen, vi->tiebreaker, rp->flags);
if (!IN_ELECTION(rep)) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Not in election, but received vote1 0x%x", rep->flags));
ret = DB_REP_HOLDELECTION;
goto err;
}
master = rep->winner;
lsn = rep->w_lsn;
if (IS_PHASE1_DONE(rep)) {
RPRINT(env, DB_VERB_REP_ELECT, (env, "Phase1 election done"));
RPRINT(env, DB_VERB_REP_ELECT, (env, "Voting for %d%s",
master, master == rep->eid ? "(self)" : ""));
egen = rep->egen;
F_SET(rep, REP_F_EPHASE2);
F_CLR(rep, REP_F_EPHASE1);
if (master == rep->eid) {
(void)__rep_tally(env, rep, rep->eid,
&rep->votes, egen, rep->v2tally_off);
RPRINT(env, DB_VERB_REP_ELECT, (env,
"After phase 1 done: counted vote %d of %d",
rep->votes, rep->nvotes));
if (I_HAVE_WON(rep, rep->winner)) {
__rep_elect_master(env, rep);
elected = 1;
}
goto err;
}
REP_SYSTEM_UNLOCK(env);
__rep_send_vote(env, NULL, 0, 0, 0, 0, egen,
master, REP_VOTE2, 0);
} else
err: REP_SYSTEM_UNLOCK(env);
if (elected)
ret = __rep_fire_elected(env, rep, egen);
return (ret);
}
int
__rep_vote2(env, rp, rec, eid)
ENV *env;
__rep_control_args *rp;
DBT *rec;
int eid;
{
DB_LOG *dblp;
DB_LSN lsn;
DB_REP *db_rep;
LOG *lp;
REP *rep;
REP_OLD_VOTE_INFO *ovi;
__rep_vote_info_args tmpvi, *vi;
u_int32_t egen;
int ret;
ret = 0;
db_rep = env->rep_handle;
rep = db_rep->region;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
RPRINT(env, DB_VERB_REP_ELECT, (env, "We received a vote%s",
F_ISSET(rep, REP_F_MASTER) ? " (master)" : ""));
if (F_ISSET(rep, REP_F_MASTER)) {
LOG_SYSTEM_LOCK(env);
lsn = lp->lsn;
LOG_SYSTEM_UNLOCK(env);
STAT(rep->stat.st_elections_won++);
(void)__rep_send_message(env,
DB_EID_BROADCAST, REP_NEWMASTER, &lsn, NULL, 0, 0);
if (IS_USING_LEASES(env))
ret = __rep_lease_refresh(env);
return (ret);
}
REP_SYSTEM_LOCK(env);
egen = rep->egen;
DB_ASSERT(env, rep->priority != 0);
if (rp->rep_version < DB_REPVERSION_47) {
ovi = (REP_OLD_VOTE_INFO *)rec->data;
tmpvi.egen = ovi->egen;
tmpvi.nsites = (u_int32_t)ovi->nsites;
tmpvi.nvotes = (u_int32_t)ovi->nvotes;
tmpvi.priority = (u_int32_t)ovi->priority;
tmpvi.tiebreaker = ovi->tiebreaker;
} else
if ((ret = __rep_vote_info_unmarshal(env,
&tmpvi, rec->data, rec->size, NULL)) != 0)
return (ret);
vi = &tmpvi;
if (!IN_ELECTION_TALLY(rep) && vi->egen >= rep->egen) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Not in election gen %lu, at %lu, got vote",
(u_long)vi->egen, (u_long)rep->egen));
ret = DB_REP_HOLDELECTION;
goto err;
}
if (vi->egen != rep->egen) {
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Bad vote egen %lu. Mine %lu",
(u_long)vi->egen, (u_long)rep->egen));
ret = 0;
goto err;
}
if ((ret = __rep_tally(env, rep, eid, &rep->votes,
vi->egen, rep->v2tally_off)) != 0) {
ret = 0;
goto err;
}
RPRINT(env, DB_VERB_REP_ELECT, (env, "Counted vote %d of %d",
rep->votes, rep->nvotes));
if (I_HAVE_WON(rep, rep->winner)) {
__rep_elect_master(env, rep);
ret = DB_REP_NEWMASTER;
}
err: REP_SYSTEM_UNLOCK(env);
if (ret == DB_REP_NEWMASTER)
ret = __rep_fire_elected(env, rep, egen);
return (ret);
}
static int
__rep_tally(env, rep, eid, countp, egen, vtoff)
ENV *env;
REP *rep;
int eid;
u_int32_t *countp;
u_int32_t egen;
roff_t vtoff;
{
REP_VTALLY *tally, *vtp;
u_int32_t i;
tally = R_ADDR(env->reginfo, vtoff);
vtp = &tally[0];
for (i = 0; i < *countp;) {
if (vtp->eid == eid) {
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Tally found[%d] (%d, %lu), this vote (%d, %lu)",
i, vtp->eid, (u_long)vtp->egen,
eid, (u_long)egen));
if (vtp->egen >= egen)
return (1);
else {
vtp->egen = egen;
return (0);
}
}
i++;
vtp = &tally[i];
}
RPRINT(env, DB_VERB_REP_ELECT, (env, "Tallying VOTE%c[%d] (%d, %lu)",
vtoff == rep->tally_off ? '1' : '2', i, eid, (u_long)egen));
vtp->eid = eid;
vtp->egen = egen;
(*countp)++;
return (0);
}
static void
__rep_cmp_vote(env, rep, eid, lsnp, priority, gen, tiebreaker, flags)
ENV *env;
REP *rep;
int eid;
DB_LSN *lsnp;
u_int32_t priority;
u_int32_t flags, gen, tiebreaker;
{
int cmp;
cmp = LOG_COMPARE(lsnp, &rep->w_lsn);
if (rep->sites > 1 &&
(priority != 0 || LF_ISSET(REPCTL_ELECTABLE))) {
if ((priority != 0 && rep->w_priority == 0) ||
(((priority == 0 && rep->w_priority == 0) ||
(priority != 0 && rep->w_priority != 0)) && cmp > 0) ||
(cmp == 0 && (priority > rep->w_priority ||
(priority == rep->w_priority &&
(tiebreaker > rep->w_tiebreaker))))) {
RPRINT(env, DB_VERB_REP_ELECT,
(env, "Accepting new vote"));
rep->winner = eid;
rep->w_priority = priority;
rep->w_lsn = *lsnp;
rep->w_gen = gen;
rep->w_tiebreaker = tiebreaker;
}
} else if (rep->sites == 1) {
if (priority != 0 || LF_ISSET(REPCTL_ELECTABLE)) {
rep->winner = eid;
rep->w_priority = priority;
rep->w_gen = gen;
rep->w_lsn = *lsnp;
rep->w_tiebreaker = tiebreaker;
} else {
rep->winner = DB_EID_INVALID;
rep->w_priority = 0;
rep->w_gen = 0;
ZERO_LSN(rep->w_lsn);
rep->w_tiebreaker = 0;
}
}
}
static int
__rep_elect_init(env, nsites, nvotes, beginp, otally)
ENV *env;
u_int32_t nsites, nvotes;
int *beginp;
u_int32_t *otally;
{
DB_LOG *dblp;
DB_LSN lsn;
DB_REP *db_rep;
LOG *lp;
REP *rep;
int ret;
db_rep = env->rep_handle;
rep = db_rep->region;
ret = 0;
STAT(rep->stat.st_elections++);
if (F_ISSET(rep, REP_F_MASTER)) {
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
LOG_SYSTEM_LOCK(env);
lsn = lp->lsn;
LOG_SYSTEM_UNLOCK(env);
(void)__rep_send_message(env,
DB_EID_BROADCAST, REP_NEWMASTER, &lsn, NULL, 0, 0);
if (IS_USING_LEASES(env))
ret = __rep_lease_refresh(env);
STAT(rep->stat.st_elections_won++);
return (DB_REP_NEWMASTER);
}
REP_SYSTEM_LOCK(env);
if (otally != NULL)
*otally = F_ISSET(rep, REP_F_TALLY);
*beginp = IN_ELECTION(rep) || F_ISSET(rep, REP_F_INREPELECT);
if (!*beginp) {
if (nsites > rep->asites &&
(ret = __rep_grow_sites(env, nsites)) != 0)
goto err;
DB_ENV_TEST_RECOVERY(env, DB_TEST_ELECTINIT, ret, NULL);
F_SET(rep, REP_F_INREPELECT);
F_CLR(rep, REP_F_EGENUPDATE);
if (!IN_ELECTION_TALLY(rep)) {
rep->nsites = nsites;
rep->nvotes = nvotes;
} else {
if (nsites > rep->nsites)
rep->nsites = nsites;
if (nvotes > rep->nvotes)
rep->nvotes = nvotes;
}
}
DB_TEST_RECOVERY_LABEL
err: REP_SYSTEM_UNLOCK(env);
return (ret);
}
static void
__rep_elect_master(env, rep)
ENV *env;
REP *rep;
{
rep->master_id = rep->eid;
if (F_ISSET(rep, REP_F_MASTERELECT | REP_F_MASTER)) {
return;
}
F_SET(rep, REP_F_MASTERELECT);
STAT(rep->stat.st_elections_won++);
RPRINT(env, DB_VERB_REP_ELECT, (env,
"Got enough votes to win; election done; winner is %d, gen %lu",
rep->master_id, (u_long)rep->gen));
}
static int
__rep_fire_elected(env, rep, egen)
ENV *env;
REP *rep;
u_int32_t egen;
{
REP_EVENT_LOCK(env);
if (rep->notified_egen < egen) {
__rep_fire_event(env, DB_EVENT_REP_ELECTED, NULL);
rep->notified_egen = egen;
}
REP_EVENT_UNLOCK(env);
return (0);
}
#define SLEEPTIME(timeout) \
(timeout > 5000000) ? 500000 : ((timeout >= 10) ? timeout / 10 : 1);
static int
__rep_wait(env, timeoutp, eidp, full_elect, flags)
ENV *env;
db_timeout_t *timeoutp;
int *eidp, full_elect;
u_int32_t flags;
{
DB_REP *db_rep;
REP *rep;
int done, echg, phase_over, ret;
u_int32_t egen, sleeptime, sleeptotal, timeout;
db_rep = env->rep_handle;
rep = db_rep->region;
egen = rep->egen;
done = echg = phase_over = ret = 0;
timeout = *timeoutp;
sleeptime = SLEEPTIME(timeout);
sleeptotal = 0;
while (sleeptotal < timeout) {
__os_yield(env, 0, sleeptime);
sleeptotal += sleeptime;
REP_SYSTEM_LOCK(env);
if (full_elect && F_ISSET(rep, REP_F_GROUP_ESTD)) {
*timeoutp = rep->elect_timeout;
timeout = *timeoutp;
if (sleeptotal >= timeout) {
done = 1;
ret = DB_TIMEOUT;
} else
sleeptime = SLEEPTIME(timeout);
}
echg = egen != rep->egen;
phase_over = !F_ISSET(rep, flags);
if (phase_over && echg &&
(IN_ELECTION_TALLY(rep) ||
F_ISSET(rep, REP_F_EGENUPDATE))) {
done = 1;
F_CLR(rep, REP_F_EGENUPDATE);
ret = DB_REP_EGENCHG;
} else if (phase_over) {
*eidp = rep->master_id;
done = 1;
ret = 0;
}
REP_SYSTEM_UNLOCK(env);
if (done)
return (ret);
}
return (DB_TIMEOUT);
}