#include "db_config.h"
#include "db_int.h"
#include "dbinc/crypto.h"
#include "dbinc/db_page.h"
#include "dbinc/hmac.h"
#include "dbinc/log.h"
#include "dbinc/hash.h"
typedef enum { L_ALREADY, L_ACQUIRED, L_NONE } RLOCK;
static int __logc_close_pp __P((DB_LOGC *, u_int32_t));
static int __logc_get_pp __P((DB_LOGC *, DB_LSN *, DBT *, u_int32_t));
static int __logc_get_int __P((DB_LOGC *, DB_LSN *, DBT *, u_int32_t));
static int __logc_hdrchk __P((DB_LOGC *, DB_LSN *, HDR *, int *));
static int __logc_incursor __P((DB_LOGC *, DB_LSN *, HDR *, u_int8_t **));
static int __logc_inregion __P((DB_LOGC *,
DB_LSN *, RLOCK *, DB_LSN *, HDR *, u_int8_t **, int *));
static int __logc_io __P((DB_LOGC *,
u_int32_t, u_int32_t, void *, size_t *, int *));
static int __logc_ondisk __P((DB_LOGC *,
DB_LSN *, DB_LSN *, u_int32_t, HDR *, u_int8_t **, int *));
static int __logc_set_maxrec __P((DB_LOGC *, char *));
static int __logc_shortread __P((DB_LOGC *, DB_LSN *, int));
static int __logc_version_pp __P((DB_LOGC *, u_int32_t *, u_int32_t));
int
__log_cursor_pp(dbenv, logcp, flags)
DB_ENV *dbenv;
DB_LOGC **logcp;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
ENV *env;
int ret;
env = dbenv->env;
ENV_REQUIRES_CONFIG(env,
env->lg_handle, "DB_ENV->log_cursor", DB_INIT_LOG);
if ((ret = __db_fchk(env, "DB_ENV->log_cursor", flags, 0)) != 0)
return (ret);
ENV_ENTER(env, ip);
REPLICATION_WRAP(env, (__log_cursor(env, logcp)), 0, ret);
ENV_LEAVE(env, ip);
return (ret);
}
int
__log_cursor(env, logcp)
ENV *env;
DB_LOGC **logcp;
{
DB_LOGC *logc;
int ret;
*logcp = NULL;
if ((ret = __os_calloc(env, 1, sizeof(DB_LOGC), &logc)) != 0)
return (ret);
logc->bp_size = LG_CURSOR_BUF_SIZE;
logc->bp_maxrec = MEGABYTE;
if ((ret = __os_malloc(env, logc->bp_size, &logc->bp)) != 0) {
__os_free(env, logc);
return (ret);
}
logc->env = env;
logc->close = __logc_close_pp;
logc->get = __logc_get_pp;
logc->version = __logc_version_pp;
*logcp = logc;
return (0);
}
static int
__logc_close_pp(logc, flags)
DB_LOGC *logc;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
ENV *env;
int ret;
env = logc->env;
if ((ret = __db_fchk(env, "DB_LOGC->close", flags, 0)) != 0)
return (ret);
ENV_ENTER(env, ip);
REPLICATION_WRAP(env, (__logc_close(logc)), 0, ret);
ENV_LEAVE(env, ip);
return (ret);
}
int
__logc_close(logc)
DB_LOGC *logc;
{
ENV *env;
env = logc->env;
if (logc->fhp != NULL) {
(void)__os_closehandle(env, logc->fhp);
logc->fhp = NULL;
}
if (logc->dbt.data != NULL)
__os_free(env, logc->dbt.data);
__os_free(env, logc->bp);
__os_free(env, logc);
return (0);
}
static int
__logc_version_pp(logc, versionp, flags)
DB_LOGC *logc;
u_int32_t *versionp;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
ENV *env;
int ret;
env = logc->env;
if ((ret = __db_fchk(env, "DB_LOGC->version", flags, 0)) != 0)
return (ret);
ENV_ENTER(env, ip);
REPLICATION_WRAP(env, (__logc_version(logc, versionp)), 0, ret);
ENV_LEAVE(env, ip);
return (ret);
}
int
__logc_version(logc, versionp)
DB_LOGC *logc;
u_int32_t *versionp;
{
DBT hdrdbt;
DB_LOGC *plogc;
DB_LSN plsn;
ENV *env;
LOGP *persist;
int ret, t_ret;
env = logc->env;
if (IS_ZERO_LSN(logc->lsn)) {
__db_errx(env, "DB_LOGC->get: unset cursor");
return (EINVAL);
}
ret = 0;
if (logc->lsn.file != logc->p_lsn.file) {
if ((ret = __log_cursor(env, &plogc)) != 0)
return (ret);
plsn.file = logc->lsn.file;
plsn.offset = 0;
plogc->lsn = plsn;
memset(&hdrdbt, 0, sizeof(DBT));
if ((ret = __logc_get_int(plogc,
&plsn, &hdrdbt, DB_SET)) == 0) {
persist = (LOGP *)hdrdbt.data;
if (LOG_SWAPPED(env))
__log_persistswap(persist);
logc->p_lsn = logc->lsn;
logc->p_version = persist->version;
}
if ((t_ret = __logc_close(plogc)) != 0 && ret == 0)
ret = t_ret;
}
if (ret == 0)
*versionp = logc->p_version;
return (ret);
}
static int
__logc_get_pp(logc, alsn, dbt, flags)
DB_LOGC *logc;
DB_LSN *alsn;
DBT *dbt;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
ENV *env;
int ret;
env = logc->env;
switch (flags) {
case DB_CURRENT:
case DB_FIRST:
case DB_LAST:
case DB_NEXT:
case DB_PREV:
break;
case DB_SET:
if (IS_ZERO_LSN(*alsn)) {
__db_errx(env, "DB_LOGC->get: invalid LSN: %lu/%lu",
(u_long)alsn->file, (u_long)alsn->offset);
return (EINVAL);
}
break;
default:
return (__db_ferr(env, "DB_LOGC->get", 1));
}
ENV_ENTER(env, ip);
REPLICATION_WRAP(env, (__logc_get(logc, alsn, dbt, flags)), 0, ret);
ENV_LEAVE(env, ip);
return (ret);
}
int
__logc_get(logc, alsn, dbt, flags)
DB_LOGC *logc;
DB_LSN *alsn;
DBT *dbt;
u_int32_t flags;
{
DB_LSN saved_lsn;
ENV *env;
LOGP *persist;
int ret;
env = logc->env;
saved_lsn = *alsn;
if ((ret = __logc_get_int(logc, alsn, dbt, flags)) != 0) {
*alsn = saved_lsn;
return (ret);
}
if (alsn->offset == 0 && (flags == DB_FIRST ||
flags == DB_NEXT || flags == DB_LAST || flags == DB_PREV)) {
switch (flags) {
case DB_FIRST:
flags = DB_NEXT;
break;
case DB_LAST:
flags = DB_PREV;
break;
case DB_NEXT:
case DB_PREV:
default:
break;
}
persist = (LOGP *)dbt->data;
if (LOG_SWAPPED(env))
__log_persistswap(persist);
logc->p_lsn = *alsn;
logc->p_version = persist->version;
if (F_ISSET(dbt, DB_DBT_MALLOC)) {
__os_free(env, dbt->data);
dbt->data = NULL;
}
if ((ret = __logc_get_int(logc, alsn, dbt, flags)) != 0) {
*alsn = saved_lsn;
return (ret);
}
}
return (0);
}
static int
__logc_get_int(logc, alsn, dbt, flags)
DB_LOGC *logc;
DB_LSN *alsn;
DBT *dbt;
u_int32_t flags;
{
DB_CIPHER *db_cipher;
DB_LOG *dblp;
DB_LSN last_lsn, nlsn;
ENV *env;
HDR hdr;
LOG *lp;
RLOCK rlock;
logfile_validity status;
u_int32_t cnt;
u_int8_t *rp;
int eof, is_hmac, need_cksum, ret;
env = logc->env;
db_cipher = env->crypto_handle;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
is_hmac = 0;
rlock = F_ISSET(logc, DB_LOG_LOCKED) ? L_ALREADY : L_NONE;
nlsn = logc->lsn;
switch (flags) {
case DB_NEXT:
if (!IS_ZERO_LSN(nlsn)) {
nlsn.offset += logc->len;
break;
}
flags = DB_FIRST;
case DB_FIRST:
if ((ret = __log_find(dblp, 1, &cnt, &status)) != 0)
goto err;
switch (status) {
case DB_LV_INCOMPLETE:
DB_ASSERT(env, lp->lsn.file == cnt);
case DB_LV_NORMAL:
case DB_LV_OLD_READABLE:
nlsn.file = cnt;
break;
case DB_LV_NONEXISTENT:
nlsn.file = 1;
DB_ASSERT(env, lp->lsn.file == nlsn.file);
break;
case DB_LV_OLD_UNREADABLE:
nlsn.file = cnt + 1;
DB_ASSERT(env, lp->lsn.file == nlsn.file);
break;
}
nlsn.offset = 0;
break;
case DB_CURRENT:
break;
case DB_PREV:
if (!IS_ZERO_LSN(nlsn)) {
if (nlsn.offset == 0) {
if (nlsn.file == 1) {
ret = DB_NOTFOUND;
goto err;
}
if ((!lp->db_log_inmemory &&
(__log_valid(dblp, nlsn.file - 1, 0, NULL,
0, &status, NULL) != 0 ||
(status != DB_LV_NORMAL &&
status != DB_LV_OLD_READABLE)))) {
ret = DB_NOTFOUND;
goto err;
}
--nlsn.file;
}
nlsn.offset = logc->prev;
break;
}
case DB_LAST:
if (rlock == L_NONE) {
rlock = L_ACQUIRED;
LOG_SYSTEM_LOCK(env);
}
nlsn.file = lp->lsn.file;
nlsn.offset = lp->lsn.offset - lp->len;
break;
case DB_SET:
nlsn = *alsn;
break;
default:
ret = __db_unknown_path(env, "__logc_get_int");
goto err;
}
if (0) {
next_file: ++nlsn.file;
nlsn.offset = 0;
}
if (CRYPTO_ON(env)) {
hdr.size = HDR_CRYPTO_SZ;
is_hmac = 1;
} else {
hdr.size = HDR_NORMAL_SZ;
is_hmac = 0;
}
if ((ret = __logc_incursor(logc, &nlsn, &hdr, &rp)) != 0)
goto err;
if (rp != NULL)
goto cksum;
ZERO_LSN(last_lsn);
if (!F_ISSET(logc, DB_LOG_DISK) ||
LOG_COMPARE(&nlsn, &logc->lsn) > 0) {
F_CLR(logc, DB_LOG_DISK);
if ((ret = __logc_inregion(logc,
&nlsn, &rlock, &last_lsn, &hdr, &rp, &need_cksum)) != 0)
goto err;
if (rp != NULL) {
if (need_cksum)
goto cksum;
goto from_memory;
}
if (lp->db_log_inmemory)
goto nohdr;
}
if (rlock == L_ACQUIRED) {
rlock = L_NONE;
LOG_SYSTEM_UNLOCK(env);
}
if ((ret = __logc_ondisk(
logc, &nlsn, &last_lsn, flags, &hdr, &rp, &eof)) != 0)
goto err;
if (eof || hdr.len == 0) {
nohdr: switch (flags) {
case DB_LAST:
case DB_PREV:
__db_errx(env,
"Encountered zero length records while traversing backwards");
ret = __env_panic(env, DB_RUNRECOVERY);
goto err;
case DB_FIRST:
case DB_NEXT:
if (nlsn.offset != 0)
goto next_file;
case DB_SET:
default:
ret = DB_NOTFOUND;
goto err;
}
}
F_SET(logc, DB_LOG_DISK);
cksum:
if (rlock == L_ACQUIRED) {
rlock = L_NONE;
LOG_SYSTEM_UNLOCK(env);
}
if ((ret = __db_check_chksum(env, &hdr, db_cipher,
hdr.chksum, rp + hdr.size, hdr.len - hdr.size, is_hmac)) != 0) {
if (F_ISSET(logc, DB_LOG_SILENT_ERR)) {
if (ret == 0 || ret == -1)
ret = EIO;
} else if (ret == -1) {
__db_errx(env,
"DB_LOGC->get: log record LSN %lu/%lu: checksum mismatch",
(u_long)nlsn.file, (u_long)nlsn.offset);
__db_errx(env,
"DB_LOGC->get: catastrophic recovery may be required");
ret = __env_panic(env, DB_RUNRECOVERY);
}
goto err;
}
from_memory:
if (rlock == L_ACQUIRED) {
rlock = L_NONE;
LOG_SYSTEM_UNLOCK(env);
}
if ((ret = __db_retcopy(env, dbt, rp + hdr.size,
(u_int32_t)(hdr.len - hdr.size),
&logc->dbt.data, &logc->dbt.ulen)) != 0)
goto err;
if (CRYPTO_ON(env)) {
if ((ret = db_cipher->decrypt(env, db_cipher->data,
hdr.iv, dbt->data, hdr.len - hdr.size)) != 0) {
ret = EAGAIN;
goto err;
}
dbt->size = hdr.orig_size;
}
*alsn = nlsn;
logc->lsn = nlsn;
logc->len = hdr.len;
logc->prev = hdr.prev;
err: if (rlock == L_ACQUIRED)
LOG_SYSTEM_UNLOCK(env);
return (ret);
}
static int
__logc_incursor(logc, lsn, hdr, pp)
DB_LOGC *logc;
DB_LSN *lsn;
HDR *hdr;
u_int8_t **pp;
{
ENV *env;
u_int8_t *p;
int eof;
env = logc->env;
*pp = NULL;
if (logc->bp_lsn.file != lsn->file)
return (0);
if (logc->bp_lsn.offset > lsn->offset)
return (0);
if (logc->bp_lsn.offset + logc->bp_rlen <= lsn->offset + hdr->size)
return (0);
p = logc->bp + (lsn->offset - logc->bp_lsn.offset);
memcpy(hdr, p, hdr->size);
if (LOG_SWAPPED(env))
__log_hdrswap(hdr, CRYPTO_ON(env));
if (__logc_hdrchk(logc, lsn, hdr, &eof))
return (DB_NOTFOUND);
if (eof || logc->bp_lsn.offset + logc->bp_rlen < lsn->offset + hdr->len)
return (0);
*pp = p;
return (0);
}
static int
__logc_inregion(logc, lsn, rlockp, last_lsn, hdr, pp, need_cksump)
DB_LOGC *logc;
DB_LSN *lsn, *last_lsn;
RLOCK *rlockp;
HDR *hdr;
u_int8_t **pp;
int *need_cksump;
{
DB_LOG *dblp;
ENV *env;
LOG *lp;
size_t b_region, len, nr;
u_int32_t b_disk;
int eof, ret;
u_int8_t *p;
env = logc->env;
dblp = env->lg_handle;
lp = env->lg_handle->reginfo.primary;
ret = 0;
b_region = 0;
*pp = NULL;
*need_cksump = 0;
if (*rlockp == L_NONE) {
*rlockp = L_ACQUIRED;
LOG_SYSTEM_LOCK(env);
}
*last_lsn = lp->lsn;
if (!lp->db_log_inmemory && last_lsn->offset > lp->w_off)
last_lsn->offset = lp->w_off;
if (IS_ZERO_LSN(lp->lsn))
return (0);
if (LOG_COMPARE(lsn, &lp->lsn) >= 0)
return (DB_NOTFOUND);
else if (lp->db_log_inmemory) {
if ((ret = __log_inmem_lsnoff(dblp, lsn, &b_region)) != 0)
return (ret);
} else if (lp->b_off == 0 || LOG_COMPARE(lsn, &lp->f_lsn) < 0)
return (0);
logc->bp_rlen = 0;
if (lp->db_log_inmemory || LOG_COMPARE(lsn, &lp->f_lsn) > 0) {
if (!lp->db_log_inmemory)
b_region = lsn->offset - lp->w_off;
__log_inmem_copyout(dblp, b_region, hdr, hdr->size);
if (LOG_SWAPPED(env))
__log_hdrswap(hdr, CRYPTO_ON(env));
if (__logc_hdrchk(logc, lsn, hdr, &eof) != 0)
return (DB_NOTFOUND);
if (eof)
return (0);
if (lp->db_log_inmemory) {
if (RINGBUF_LEN(lp, b_region, lp->b_off) < hdr->len)
return (DB_NOTFOUND);
} else if (lsn->offset + hdr->len > lp->w_off + lp->buffer_size)
return (DB_NOTFOUND);
if (logc->bp_size <= hdr->len) {
len = (size_t)DB_ALIGN((uintmax_t)hdr->len * 2, 128);
if ((ret =
__os_realloc(logc->env, len, &logc->bp)) != 0)
return (ret);
logc->bp_size = (u_int32_t)len;
}
__log_inmem_copyout(dblp, b_region, logc->bp, hdr->len);
*pp = logc->bp;
return (0);
}
DB_ASSERT(env, !lp->db_log_inmemory);
b_disk = lp->w_off - lsn->offset;
if (lp->b_off <= lp->len)
b_region = (u_int32_t)lp->b_off;
else
for (p = dblp->bufp + (lp->b_off - lp->len);;) {
memcpy(hdr, p, hdr->size);
if (LOG_SWAPPED(env))
__log_hdrswap(hdr, CRYPTO_ON(env));
if (hdr->prev == lsn->offset) {
b_region = (u_int32_t)(p - dblp->bufp);
break;
}
p = dblp->bufp + (hdr->prev - lp->w_off);
}
if (logc->bp_size <= b_region + b_disk) {
len = (size_t)DB_ALIGN((uintmax_t)(b_region + b_disk) * 2, 128);
if ((ret = __os_realloc(logc->env, len, &logc->bp)) != 0)
return (ret);
logc->bp_size = (u_int32_t)len;
}
p = (logc->bp + logc->bp_size) - b_region;
memcpy(p, dblp->bufp, b_region);
if (*rlockp == L_ACQUIRED) {
*rlockp = L_NONE;
LOG_SYSTEM_UNLOCK(env);
}
if (b_disk != 0) {
p -= b_disk;
nr = b_disk;
if ((ret = __logc_io(
logc, lsn->file, lsn->offset, p, &nr, NULL)) != 0)
return (ret);
if (nr < b_disk)
return (__logc_shortread(logc, lsn, 0));
*need_cksump = 1;
}
memcpy(hdr, p, hdr->size);
if (LOG_SWAPPED(env))
__log_hdrswap(hdr, CRYPTO_ON(env));
*pp = p;
return (0);
}
void
__log_hdrswap(hdr, is_hmac)
HDR *hdr;
int is_hmac;
{
M_32_SWAP(hdr->prev);
M_32_SWAP(hdr->len);
if (!is_hmac)
P_32_SWAP(hdr->chksum);
}
void
__log_persistswap(persist)
LOGP *persist;
{
M_32_SWAP(persist->magic);
M_32_SWAP(persist->version);
M_32_SWAP(persist->log_size);
M_32_SWAP(persist->notused);
}
static int
__logc_ondisk(logc, lsn, last_lsn, flags, hdr, pp, eofp)
DB_LOGC *logc;
DB_LSN *lsn, *last_lsn;
u_int32_t flags;
int *eofp;
HDR *hdr;
u_int8_t **pp;
{
ENV *env;
size_t len, nr;
u_int32_t offset;
int ret;
env = logc->env;
*eofp = 0;
nr = hdr->size;
if ((ret =
__logc_io(logc, lsn->file, lsn->offset, hdr, &nr, eofp)) != 0)
return (ret);
if (*eofp)
return (0);
if (LOG_SWAPPED(env))
__log_hdrswap(hdr, CRYPTO_ON(env));
if (nr < hdr->size) {
*eofp = 1;
return (0);
}
if ((ret = __logc_hdrchk(logc, lsn, hdr, eofp)) != 0)
return (ret);
if (*eofp)
return (0);
logc->bp_rlen = 0;
if (logc->bp_size <= hdr->len) {
len = (size_t)DB_ALIGN((uintmax_t)hdr->len * 2, 128);
if ((ret = __os_realloc(env, len, &logc->bp)) != 0)
return (ret);
logc->bp_size = (u_int32_t)len;
}
if (flags == DB_FIRST || flags == DB_NEXT)
offset = lsn->offset;
else if (lsn->offset + hdr->len < logc->bp_size)
offset = 0;
else
offset = (lsn->offset + hdr->len) - logc->bp_size;
nr = logc->bp_size;
if (lsn->file == last_lsn->file && offset + nr >= last_lsn->offset)
nr = last_lsn->offset - offset;
if ((ret =
__logc_io(logc, lsn->file, offset, logc->bp, &nr, eofp)) != 0)
return (ret);
if (nr < (lsn->offset + hdr->len) - offset)
return (__logc_shortread(logc, lsn, 1));
logc->bp_rlen = (u_int32_t)nr;
logc->bp_lsn.offset = offset;
*pp = logc->bp + (lsn->offset - offset);
return (0);
}
static int
__logc_hdrchk(logc, lsn, hdr, eofp)
DB_LOGC *logc;
DB_LSN *lsn;
HDR *hdr;
int *eofp;
{
ENV *env;
int ret;
env = logc->env;
if (eofp != NULL) {
if (hdr->prev == 0 && hdr->chksum[0] == 0 && hdr->len == 0) {
*eofp = 1;
return (0);
}
*eofp = 0;
}
if (hdr->len <= hdr->size)
goto err;
if (logc->bp_maxrec != 0 && hdr->len > logc->bp_maxrec) {
if ((ret = __logc_set_maxrec(logc, NULL)) != 0) {
__db_err(env, ret, "DB_LOGC->get");
return (ret);
}
if (logc->bp_maxrec != 0 && hdr->len > logc->bp_maxrec)
goto err;
}
return (0);
err: if (!F_ISSET(logc, DB_LOG_SILENT_ERR))
__db_errx(env,
"DB_LOGC->get: LSN %lu/%lu: invalid log record header",
(u_long)lsn->file, (u_long)lsn->offset);
return (EIO);
}
static int
__logc_io(logc, fnum, offset, p, nrp, eofp)
DB_LOGC *logc;
u_int32_t fnum, offset;
void *p;
size_t *nrp;
int *eofp;
{
DB_LOG *dblp;
ENV *env;
LOG *lp;
int ret;
char *np;
env = logc->env;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
if (logc->fhp != NULL && logc->bp_lsn.file != fnum) {
ret = __os_closehandle(env, logc->fhp);
logc->fhp = NULL;
logc->bp_lsn.file = 0;
if (ret != 0)
return (ret);
}
if (logc->fhp == NULL) {
if ((ret = __log_name(dblp, fnum,
&np, &logc->fhp, DB_OSO_RDONLY | DB_OSO_SEQ)) != 0) {
if (eofp != NULL) {
*eofp = 1;
ret = 0;
} else if (!F_ISSET(logc, DB_LOG_SILENT_ERR))
__db_err(env, ret, "DB_LOGC->get: %s",
np == NULL ? "__log_name failed" : np);
__os_free(env, np);
return (ret);
}
if ((ret = __logc_set_maxrec(logc, np)) != 0) {
__db_err(env, ret, "DB_LOGC->get: %s", np);
__os_free(env, np);
return (ret);
}
__os_free(env, np);
logc->bp_lsn.file = fnum;
}
STAT(++lp->stat.st_rcount);
if ((ret = __os_io(env, DB_IO_READ,
logc->fhp, 0, 0, offset, (u_int32_t)*nrp, p, nrp)) != 0) {
if (!F_ISSET(logc, DB_LOG_SILENT_ERR))
__db_err(env, ret,
"DB_LOGC->get: LSN: %lu/%lu: read",
(u_long)fnum, (u_long)offset);
return (ret);
}
return (0);
}
static int
__logc_shortread(logc, lsn, check_silent)
DB_LOGC *logc;
DB_LSN *lsn;
int check_silent;
{
if (!check_silent || !F_ISSET(logc, DB_LOG_SILENT_ERR))
__db_errx(logc->env, "DB_LOGC->get: LSN: %lu/%lu: short read",
(u_long)lsn->file, (u_long)lsn->offset);
return (EIO);
}
static int
__logc_set_maxrec(logc, np)
DB_LOGC *logc;
char *np;
{
DB_LOG *dblp;
ENV *env;
LOG *lp;
u_int32_t mbytes, bytes;
int ret;
env = logc->env;
dblp = env->lg_handle;
if (logc->fhp != NULL) {
if ((ret = __os_ioinfo(env, np, logc->fhp,
&mbytes, &bytes, NULL)) != 0)
return (ret);
if (logc->bp_maxrec < (mbytes * MEGABYTE + bytes))
logc->bp_maxrec = mbytes * MEGABYTE + bytes;
}
lp = dblp->reginfo.primary;
if (logc->bp_maxrec < lp->buffer_size)
logc->bp_maxrec = lp->buffer_size;
return (0);
}
#ifdef HAVE_REPLICATION
int
__log_rep_split(env, ip, rp, rec, ret_lsnp, last_lsnp)
ENV *env;
DB_THREAD_INFO *ip;
__rep_control_args *rp;
DBT *rec;
DB_LSN *ret_lsnp;
DB_LSN *last_lsnp;
{
DBT logrec;
DB_LSN save_lsn, tmp_lsn;
__rep_control_args tmprp;
__rep_bulk_args b_args;
int ret, save_ret;
u_int32_t save_flags;
u_int8_t *p, *ep;
memset(&logrec, 0, sizeof(logrec));
memset(&save_lsn, 0, sizeof(save_lsn));
memset(&tmp_lsn, 0, sizeof(tmp_lsn));
memcpy(&tmprp, rp, sizeof(tmprp));
save_flags = F_ISSET(rp, REPCTL_LOG_END | REPCTL_PERM);
F_CLR(&tmprp, REPCTL_LOG_END | REPCTL_PERM);
ret = save_ret = 0;
for (ep = (u_int8_t *)rec->data + rec->size, p = (u_int8_t *)rec->data;
p < ep; ) {
if (rp->rep_version < DB_REPVERSION_47) {
memcpy(&b_args.len, p, sizeof(b_args.len));
p += sizeof(b_args.len);
memcpy(&tmprp.lsn, p, sizeof(DB_LSN));
p += sizeof(DB_LSN);
logrec.data = p;
logrec.size = b_args.len;
p += b_args.len;
} else {
if ((ret = __rep_bulk_unmarshal(env,
&b_args, p, rec->size, &p)) != 0)
return (ret);
tmprp.lsn = b_args.lsn;
logrec.data = b_args.bulkdata.data;
logrec.size = b_args.len;
}
RPRINT(env, DB_VERB_REP_MISC, (env,
"log_rep_split: Processing LSN [%lu][%lu]",
(u_long)tmprp.lsn.file, (u_long)tmprp.lsn.offset));
RPRINT(env, DB_VERB_REP_MISC, (env,
"log_rep_split: p %#lx ep %#lx logrec data %#lx, size %lu (%#lx)",
P_TO_ULONG(p), P_TO_ULONG(ep), P_TO_ULONG(logrec.data),
(u_long)logrec.size, (u_long)logrec.size));
if (p >= ep && save_flags)
F_SET(&tmprp, save_flags);
ret = __rep_apply(env, ip,
&tmprp, &logrec, &tmp_lsn, NULL, last_lsnp);
RPRINT(env, DB_VERB_REP_MISC, (env,
"log_split: rep_apply ret %d, tmp_lsn [%lu][%lu]",
ret, (u_long)tmp_lsn.file, (u_long)tmp_lsn.offset));
switch (ret) {
case DB_REP_LOGREADY:
goto out;
case DB_REP_ISPERM:
case DB_REP_NOTPERM:
save_ret = ret;
save_lsn = tmp_lsn;
ret = 0;
break;
case 0:
break;
default:
goto out;
}
}
out:
if (ret == 0) {
ret = save_ret;
*ret_lsnp = save_lsn;
}
return (ret);
}
#endif