From e5faf242de85d07fd95d210f90d01951c92e173b Mon Sep 17 00:00:00 2001 From: skimo Date: Fri, 2 Nov 2001 11:52:06 +0000 Subject: [PATCH] Generated log functions and dummy recovery functions. --- common/common.h | 3 +- common/vi.src | 35 +++ common/vi_auto.c | 766 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ common/vi_auto.h | 37 +++ common/vi_rec.c | 123 +++++++++ 5 files changed, 963 insertions(+), 1 deletion(-) create mode 100644 common/vi.src create mode 100644 common/vi_auto.c create mode 100644 common/vi_auto.h create mode 100644 common/vi_rec.c diff --git a/common/common.h b/common/common.h index 1522ab1f..0201a062 100644 --- a/common/common.h +++ b/common/common.h @@ -6,7 +6,7 @@ * * See the LICENSE file for redistribution information. * - * $Id: common.h,v 10.18 2001/04/23 22:46:55 skimo Exp $ (Berkeley) $Date: 2001/04/23 22:46:55 $ + * $Id: common.h,v 10.19 2001/11/02 11:52:06 skimo Exp $ (Berkeley) $Date: 2001/11/02 11:52:06 $ */ /* @@ -102,5 +102,6 @@ typedef enum { SEQ_ABBREV, SEQ_COMMAND, SEQ_INPUT } seq_t; #include "exf.h" #include "log.h" #include "mem.h" +#include "vi_auto.h" #include "extern.h" diff --git a/common/vi.src b/common/vi.src new file mode 100644 index 00000000..bb319cd7 --- /dev/null +++ b/common/vi.src @@ -0,0 +1,35 @@ +PREFIX vi + +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include +INCLUDE #include "common.h" +INCLUDE #include +INCLUDE #include "db_page.h" +INCLUDE #include "db_am.h" +INCLUDE #include "rep.h" +INCLUDE #include "txn.h" + +BEGIN marker 200 +ARG opcode u_int32_t lu +END + +BEGIN cursor 201 +ARG lno db_recno_t lu +ARG cno size_t d +END + +BEGIN mark 202 +PTR lmp LMARK +END + +BEGIN change 203 +ARG opcode u_int32_t lu +END diff --git a/common/vi_auto.c b/common/vi_auto.c new file mode 100644 index 00000000..977a7500 --- /dev/null +++ b/common/vi_auto.c @@ -0,0 +1,766 @@ +/* Do not edit: automatically built by gen_rec.awk. */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "common.h" +#include +#include "db_page.h" +#include "db_am.h" +#include "rep.h" +#include "txn.h" +/* + * PUBLIC: int __vi_marker_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t, + * PUBLIC: u_int32_t)); + */ +int +__vi_marker_log(dbenv, txnid, ret_lsnp, flags, + opcode) + DB_ENV *dbenv; + DB_TXN *txnid; + DB_LSN *ret_lsnp; + u_int32_t flags; + u_int32_t opcode; +{ + DBT logrec; + DB_LSN *lsnp, null_lsn; + u_int32_t uinttmp; + u_int32_t rectype, txn_num; + int ret; + u_int8_t *bp; + + rectype = DB_vi_marker; + if (txnid != NULL && + TAILQ_FIRST(&txnid->kids) != NULL && + (ret = __txn_activekids(dbenv, rectype, txnid)) != 0) + return (ret); + txn_num = txnid == NULL ? 0 : txnid->txnid; + if (txnid == NULL) { + ZERO_LSN(null_lsn); + lsnp = &null_lsn; + } else + lsnp = &txnid->last_lsn; + logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN) + + sizeof(u_int32_t); + if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0) + return (ret); + + bp = logrec.data; + + memcpy(bp, &rectype, sizeof(rectype)); + bp += sizeof(rectype); + + memcpy(bp, &txn_num, sizeof(txn_num)); + bp += sizeof(txn_num); + + memcpy(bp, lsnp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + uinttmp = (u_int32_t)opcode; + memcpy(bp, &uinttmp, sizeof(uinttmp)); + bp += sizeof(uinttmp); + + DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size); + ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags); + if (txnid != NULL && ret == 0) + txnid->last_lsn = *ret_lsnp; +#ifdef LOG_DIAGNOSTIC + if (ret != 0) + (void)__vi_marker_print(dbenv, + (DBT *)&logrec, ret_lsnp, NULL, NULL); +#endif + __os_free(dbenv, logrec.data, logrec.size); + return (ret); +} + +/* + * PUBLIC: int __vi_marker_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_marker_getpgnos(dbenv, rec, lsnp, notused1, summary) + DB_ENV *dbenv; + DBT *rec; + DB_LSN *lsnp; + db_recops notused1; + void *summary; +{ + TXN_RECS *t; + int ret; + COMPQUIET(rec, NULL); + COMPQUIET(notused1, DB_TXN_ABORT); + + t = (TXN_RECS *)summary; + + if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0) + return (ret); + + t->array[t->npages].flags = LSN_PAGE_NOLOCK; + t->array[t->npages].lsn = *lsnp; + t->array[t->npages].fid = DB_LOGFILEID_INVALID; + memset(&t->array[t->npages].pgdesc, 0, + sizeof(t->array[t->npages].pgdesc)); + + t->npages++; + + return (0); +} + +/* + * PUBLIC: int __vi_marker_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_marker_print(dbenv, dbtp, lsnp, notused2, notused3) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops notused2; + void *notused3; +{ + __vi_marker_args *argp; + int ret; + + notused2 = DB_TXN_ABORT; + notused3 = NULL; + + if ((ret = __vi_marker_read(dbenv, dbtp->data, &argp)) != 0) + return (ret); + (void)printf( + "[%lu][%lu]vi_marker: rec: %lu txnid %lx prevlsn [%lu][%lu]\n", + (u_long)lsnp->file, + (u_long)lsnp->offset, + (u_long)argp->type, + (u_long)argp->txnid->txnid, + (u_long)argp->prev_lsn.file, + (u_long)argp->prev_lsn.offset); + (void)printf("\topcode: %lu\n", (u_long)argp->opcode); + (void)printf("\n"); + __os_free(dbenv, argp, 0); + return (0); +} + +/* + * PUBLIC: int __vi_marker_read __P((DB_ENV *, void *, __vi_marker_args **)); + */ +int +__vi_marker_read(dbenv, recbuf, argpp) + DB_ENV *dbenv; + void *recbuf; + __vi_marker_args **argpp; +{ + __vi_marker_args *argp; + int ret; + u_int32_t uinttmp; + u_int8_t *bp; + + ret = __os_malloc(dbenv, sizeof(__vi_marker_args) + + sizeof(DB_TXN), &argp); + if (ret != 0) + return (ret); + argp->txnid = (DB_TXN *)&argp[1]; + + bp = recbuf; + memcpy(&argp->type, bp, sizeof(argp->type)); + bp += sizeof(argp->type); + + memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid)); + bp += sizeof(argp->txnid->txnid); + + memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + memcpy(&uinttmp, bp, sizeof(uinttmp)); + argp->opcode = (u_int32_t)uinttmp; + bp += sizeof(uinttmp); + + *argpp = argp; + return (0); +} + +/* + * PUBLIC: int __vi_cursor_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t, + * PUBLIC: db_recno_t, size_t)); + */ +int +__vi_cursor_log(dbenv, txnid, ret_lsnp, flags, + lno, cno) + DB_ENV *dbenv; + DB_TXN *txnid; + DB_LSN *ret_lsnp; + u_int32_t flags; + db_recno_t lno; + size_t cno; +{ + DBT logrec; + DB_LSN *lsnp, null_lsn; + u_int32_t uinttmp; + u_int32_t rectype, txn_num; + int ret; + u_int8_t *bp; + + rectype = DB_vi_cursor; + if (txnid != NULL && + TAILQ_FIRST(&txnid->kids) != NULL && + (ret = __txn_activekids(dbenv, rectype, txnid)) != 0) + return (ret); + txn_num = txnid == NULL ? 0 : txnid->txnid; + if (txnid == NULL) { + ZERO_LSN(null_lsn); + lsnp = &null_lsn; + } else + lsnp = &txnid->last_lsn; + logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN) + + sizeof(u_int32_t) + + sizeof(u_int32_t); + if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0) + return (ret); + + bp = logrec.data; + + memcpy(bp, &rectype, sizeof(rectype)); + bp += sizeof(rectype); + + memcpy(bp, &txn_num, sizeof(txn_num)); + bp += sizeof(txn_num); + + memcpy(bp, lsnp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + uinttmp = (u_int32_t)lno; + memcpy(bp, &uinttmp, sizeof(uinttmp)); + bp += sizeof(uinttmp); + + uinttmp = (u_int32_t)cno; + memcpy(bp, &uinttmp, sizeof(uinttmp)); + bp += sizeof(uinttmp); + + DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size); + ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags); + if (txnid != NULL && ret == 0) + txnid->last_lsn = *ret_lsnp; +#ifdef LOG_DIAGNOSTIC + if (ret != 0) + (void)__vi_cursor_print(dbenv, + (DBT *)&logrec, ret_lsnp, NULL, NULL); +#endif + __os_free(dbenv, logrec.data, logrec.size); + return (ret); +} + +/* + * PUBLIC: int __vi_cursor_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_cursor_getpgnos(dbenv, rec, lsnp, notused1, summary) + DB_ENV *dbenv; + DBT *rec; + DB_LSN *lsnp; + db_recops notused1; + void *summary; +{ + TXN_RECS *t; + int ret; + COMPQUIET(rec, NULL); + COMPQUIET(notused1, DB_TXN_ABORT); + + t = (TXN_RECS *)summary; + + if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0) + return (ret); + + t->array[t->npages].flags = LSN_PAGE_NOLOCK; + t->array[t->npages].lsn = *lsnp; + t->array[t->npages].fid = DB_LOGFILEID_INVALID; + memset(&t->array[t->npages].pgdesc, 0, + sizeof(t->array[t->npages].pgdesc)); + + t->npages++; + + return (0); +} + +/* + * PUBLIC: int __vi_cursor_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_cursor_print(dbenv, dbtp, lsnp, notused2, notused3) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops notused2; + void *notused3; +{ + __vi_cursor_args *argp; + int ret; + + notused2 = DB_TXN_ABORT; + notused3 = NULL; + + if ((ret = __vi_cursor_read(dbenv, dbtp->data, &argp)) != 0) + return (ret); + (void)printf( + "[%lu][%lu]vi_cursor: rec: %lu txnid %lx prevlsn [%lu][%lu]\n", + (u_long)lsnp->file, + (u_long)lsnp->offset, + (u_long)argp->type, + (u_long)argp->txnid->txnid, + (u_long)argp->prev_lsn.file, + (u_long)argp->prev_lsn.offset); + (void)printf("\tlno: %lu\n", (u_long)argp->lno); + (void)printf("\tcno: %d\n", argp->cno); + (void)printf("\n"); + __os_free(dbenv, argp, 0); + return (0); +} + +/* + * PUBLIC: int __vi_cursor_read __P((DB_ENV *, void *, __vi_cursor_args **)); + */ +int +__vi_cursor_read(dbenv, recbuf, argpp) + DB_ENV *dbenv; + void *recbuf; + __vi_cursor_args **argpp; +{ + __vi_cursor_args *argp; + int ret; + u_int32_t uinttmp; + u_int8_t *bp; + + ret = __os_malloc(dbenv, sizeof(__vi_cursor_args) + + sizeof(DB_TXN), &argp); + if (ret != 0) + return (ret); + argp->txnid = (DB_TXN *)&argp[1]; + + bp = recbuf; + memcpy(&argp->type, bp, sizeof(argp->type)); + bp += sizeof(argp->type); + + memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid)); + bp += sizeof(argp->txnid->txnid); + + memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + memcpy(&uinttmp, bp, sizeof(uinttmp)); + argp->lno = (db_recno_t)uinttmp; + bp += sizeof(uinttmp); + + memcpy(&uinttmp, bp, sizeof(uinttmp)); + argp->cno = (size_t)uinttmp; + bp += sizeof(uinttmp); + + *argpp = argp; + return (0); +} + +/* + * PUBLIC: int __vi_mark_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t)); + */ +int +__vi_mark_log(dbenv, txnid, ret_lsnp, flags) + DB_ENV *dbenv; + DB_TXN *txnid; + DB_LSN *ret_lsnp; + u_int32_t flags; +{ + DBT logrec; + DB_LSN *lsnp, null_lsn; + u_int32_t rectype, txn_num; + int ret; + u_int8_t *bp; + + rectype = DB_vi_mark; + if (txnid != NULL && + TAILQ_FIRST(&txnid->kids) != NULL && + (ret = __txn_activekids(dbenv, rectype, txnid)) != 0) + return (ret); + txn_num = txnid == NULL ? 0 : txnid->txnid; + if (txnid == NULL) { + ZERO_LSN(null_lsn); + lsnp = &null_lsn; + } else + lsnp = &txnid->last_lsn; + logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN); + if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0) + return (ret); + + bp = logrec.data; + + memcpy(bp, &rectype, sizeof(rectype)); + bp += sizeof(rectype); + + memcpy(bp, &txn_num, sizeof(txn_num)); + bp += sizeof(txn_num); + + memcpy(bp, lsnp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size); + ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags); + if (txnid != NULL && ret == 0) + txnid->last_lsn = *ret_lsnp; +#ifdef LOG_DIAGNOSTIC + if (ret != 0) + (void)__vi_mark_print(dbenv, + (DBT *)&logrec, ret_lsnp, NULL, NULL); +#endif + __os_free(dbenv, logrec.data, logrec.size); + return (ret); +} + +/* + * PUBLIC: int __vi_mark_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_mark_getpgnos(dbenv, rec, lsnp, notused1, summary) + DB_ENV *dbenv; + DBT *rec; + DB_LSN *lsnp; + db_recops notused1; + void *summary; +{ + TXN_RECS *t; + int ret; + COMPQUIET(rec, NULL); + COMPQUIET(notused1, DB_TXN_ABORT); + + t = (TXN_RECS *)summary; + + if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0) + return (ret); + + t->array[t->npages].flags = LSN_PAGE_NOLOCK; + t->array[t->npages].lsn = *lsnp; + t->array[t->npages].fid = DB_LOGFILEID_INVALID; + memset(&t->array[t->npages].pgdesc, 0, + sizeof(t->array[t->npages].pgdesc)); + + t->npages++; + + return (0); +} + +/* + * PUBLIC: int __vi_mark_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_mark_print(dbenv, dbtp, lsnp, notused2, notused3) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops notused2; + void *notused3; +{ + __vi_mark_args *argp; + int ret; + + notused2 = DB_TXN_ABORT; + notused3 = NULL; + + if ((ret = __vi_mark_read(dbenv, dbtp->data, &argp)) != 0) + return (ret); + (void)printf( + "[%lu][%lu]vi_mark: rec: %lu txnid %lx prevlsn [%lu][%lu]\n", + (u_long)lsnp->file, + (u_long)lsnp->offset, + (u_long)argp->type, + (u_long)argp->txnid->txnid, + (u_long)argp->prev_lsn.file, + (u_long)argp->prev_lsn.offset); + (void)printf("\n"); + __os_free(dbenv, argp, 0); + return (0); +} + +/* + * PUBLIC: int __vi_mark_read __P((DB_ENV *, void *, __vi_mark_args **)); + */ +int +__vi_mark_read(dbenv, recbuf, argpp) + DB_ENV *dbenv; + void *recbuf; + __vi_mark_args **argpp; +{ + __vi_mark_args *argp; + int ret; + u_int8_t *bp; + + ret = __os_malloc(dbenv, sizeof(__vi_mark_args) + + sizeof(DB_TXN), &argp); + if (ret != 0) + return (ret); + argp->txnid = (DB_TXN *)&argp[1]; + + bp = recbuf; + memcpy(&argp->type, bp, sizeof(argp->type)); + bp += sizeof(argp->type); + + memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid)); + bp += sizeof(argp->txnid->txnid); + + memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + *argpp = argp; + return (0); +} + +/* + * PUBLIC: int __vi_change_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t, + * PUBLIC: u_int32_t)); + */ +int +__vi_change_log(dbenv, txnid, ret_lsnp, flags, + opcode) + DB_ENV *dbenv; + DB_TXN *txnid; + DB_LSN *ret_lsnp; + u_int32_t flags; + u_int32_t opcode; +{ + DBT logrec; + DB_LSN *lsnp, null_lsn; + u_int32_t uinttmp; + u_int32_t rectype, txn_num; + int ret; + u_int8_t *bp; + + rectype = DB_vi_change; + if (txnid != NULL && + TAILQ_FIRST(&txnid->kids) != NULL && + (ret = __txn_activekids(dbenv, rectype, txnid)) != 0) + return (ret); + txn_num = txnid == NULL ? 0 : txnid->txnid; + if (txnid == NULL) { + ZERO_LSN(null_lsn); + lsnp = &null_lsn; + } else + lsnp = &txnid->last_lsn; + logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN) + + sizeof(u_int32_t); + if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0) + return (ret); + + bp = logrec.data; + + memcpy(bp, &rectype, sizeof(rectype)); + bp += sizeof(rectype); + + memcpy(bp, &txn_num, sizeof(txn_num)); + bp += sizeof(txn_num); + + memcpy(bp, lsnp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + uinttmp = (u_int32_t)opcode; + memcpy(bp, &uinttmp, sizeof(uinttmp)); + bp += sizeof(uinttmp); + + DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size); + ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags); + if (txnid != NULL && ret == 0) + txnid->last_lsn = *ret_lsnp; +#ifdef LOG_DIAGNOSTIC + if (ret != 0) + (void)__vi_change_print(dbenv, + (DBT *)&logrec, ret_lsnp, NULL, NULL); +#endif + __os_free(dbenv, logrec.data, logrec.size); + return (ret); +} + +/* + * PUBLIC: int __vi_change_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_change_getpgnos(dbenv, rec, lsnp, notused1, summary) + DB_ENV *dbenv; + DBT *rec; + DB_LSN *lsnp; + db_recops notused1; + void *summary; +{ + TXN_RECS *t; + int ret; + COMPQUIET(rec, NULL); + COMPQUIET(notused1, DB_TXN_ABORT); + + t = (TXN_RECS *)summary; + + if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0) + return (ret); + + t->array[t->npages].flags = LSN_PAGE_NOLOCK; + t->array[t->npages].lsn = *lsnp; + t->array[t->npages].fid = DB_LOGFILEID_INVALID; + memset(&t->array[t->npages].pgdesc, 0, + sizeof(t->array[t->npages].pgdesc)); + + t->npages++; + + return (0); +} + +/* + * PUBLIC: int __vi_change_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops, + * PUBLIC: void *)); + */ +int +__vi_change_print(dbenv, dbtp, lsnp, notused2, notused3) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops notused2; + void *notused3; +{ + __vi_change_args *argp; + int ret; + + notused2 = DB_TXN_ABORT; + notused3 = NULL; + + if ((ret = __vi_change_read(dbenv, dbtp->data, &argp)) != 0) + return (ret); + (void)printf( + "[%lu][%lu]vi_change: rec: %lu txnid %lx prevlsn [%lu][%lu]\n", + (u_long)lsnp->file, + (u_long)lsnp->offset, + (u_long)argp->type, + (u_long)argp->txnid->txnid, + (u_long)argp->prev_lsn.file, + (u_long)argp->prev_lsn.offset); + (void)printf("\topcode: %lu\n", (u_long)argp->opcode); + (void)printf("\n"); + __os_free(dbenv, argp, 0); + return (0); +} + +/* + * PUBLIC: int __vi_change_read __P((DB_ENV *, void *, __vi_change_args **)); + */ +int +__vi_change_read(dbenv, recbuf, argpp) + DB_ENV *dbenv; + void *recbuf; + __vi_change_args **argpp; +{ + __vi_change_args *argp; + int ret; + u_int32_t uinttmp; + u_int8_t *bp; + + ret = __os_malloc(dbenv, sizeof(__vi_change_args) + + sizeof(DB_TXN), &argp); + if (ret != 0) + return (ret); + argp->txnid = (DB_TXN *)&argp[1]; + + bp = recbuf; + memcpy(&argp->type, bp, sizeof(argp->type)); + bp += sizeof(argp->type); + + memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid)); + bp += sizeof(argp->txnid->txnid); + + memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN)); + bp += sizeof(DB_LSN); + + memcpy(&uinttmp, bp, sizeof(uinttmp)); + argp->opcode = (u_int32_t)uinttmp; + bp += sizeof(uinttmp); + + *argpp = argp; + return (0); +} + +/* + * PUBLIC: int __vi_init_print __P((DB_ENV *, int (***)(DB_ENV *, DBT *, + * PUBLIC: DB_LSN *, db_recops, void *), size_t *)); + */ +int +__vi_init_print(dbenv, dtabp, dtabsizep) + DB_ENV *dbenv; + int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *)); + size_t *dtabsizep; +{ + int ret; + + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_marker_print, DB_vi_marker)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_cursor_print, DB_vi_cursor)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_mark_print, DB_vi_mark)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_change_print, DB_vi_change)) != 0) + return (ret); + return (0); +} + +/* + * PUBLIC: int __vi_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *, DBT *, + * PUBLIC: DB_LSN *, db_recops, void *), size_t *)); + */ +int +__vi_init_getpgnos(dbenv, dtabp, dtabsizep) + DB_ENV *dbenv; + int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *)); + size_t *dtabsizep; +{ + int ret; + + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_marker_getpgnos, DB_vi_marker)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_cursor_getpgnos, DB_vi_cursor)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_mark_getpgnos, DB_vi_mark)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep, + __vi_change_getpgnos, DB_vi_change)) != 0) + return (ret); + return (0); +} + +/* + * PUBLIC: int __vi_init_recover __P((DB_ENV *)); + */ +int +__vi_init_recover(dbenv) + DB_ENV *dbenv; +{ + int ret; + + if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size, + __vi_marker_recover, DB_vi_marker)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size, + __vi_cursor_recover, DB_vi_cursor)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size, + __vi_mark_recover, DB_vi_mark)) != 0) + return (ret); + if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size, + __vi_change_recover, DB_vi_change)) != 0) + return (ret); + return (0); +} diff --git a/common/vi_auto.h b/common/vi_auto.h new file mode 100644 index 00000000..7348ec8d --- /dev/null +++ b/common/vi_auto.h @@ -0,0 +1,37 @@ +/* Do not edit: automatically built by gen_rec.awk. */ + +#ifndef vi_AUTO_H +#define vi_AUTO_H +#define DB_vi_marker 200 +typedef struct _vi_marker_args { + u_int32_t type; + DB_TXN *txnid; + DB_LSN prev_lsn; + u_int32_t opcode; +} __vi_marker_args; + +#define DB_vi_cursor 201 +typedef struct _vi_cursor_args { + u_int32_t type; + DB_TXN *txnid; + DB_LSN prev_lsn; + db_recno_t lno; + size_t cno; +} __vi_cursor_args; + +#define DB_vi_mark 202 +typedef struct _vi_mark_args { + u_int32_t type; + DB_TXN *txnid; + DB_LSN prev_lsn; +} __vi_mark_args; + +#define DB_vi_change 203 +typedef struct _vi_change_args { + u_int32_t type; + DB_TXN *txnid; + DB_LSN prev_lsn; + u_int32_t opcode; +} __vi_change_args; + +#endif diff --git a/common/vi_rec.c b/common/vi_rec.c new file mode 100644 index 00000000..d3d98ec0 --- /dev/null +++ b/common/vi_rec.c @@ -0,0 +1,123 @@ +#include "db_config.h" + +#ifndef NO_SYSTEM_INCLUDES +#include + +#include +#endif + +#include "common.h" + +#include "db_int.h" +#include "db_page.h" +#include "log.h" +#include "hash.h" + +/* + * __vi_marker_recover -- + * Recovery function for marker. + * + * PUBLIC: int __vi_marker_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *)); + */ +int +__vi_marker_recover(dbenv, dbtp, lsnp, op, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops op; + void *info; +{ + __vi_marker_args *argp; + int ret; + + REC_PRINT(__vi_marker_print); + REC_NOOP_INTRO(__vi_marker_read); + + *lsnp = argp->prev_lsn; + ret = 0; + + REC_NOOP_CLOSE; +} + +/* + * __vi_cursor_recover -- + * Recovery function for cursor. + * + * PUBLIC: int __vi_cursor_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *)); + */ +int +__vi_cursor_recover(dbenv, dbtp, lsnp, op, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops op; + void *info; +{ + __vi_cursor_args *argp; + int ret; + + REC_PRINT(__vi_cursor_print); + REC_NOOP_INTRO(__vi_cursor_read); + + *lsnp = argp->prev_lsn; + ret = 0; + + REC_NOOP_CLOSE; +} + +/* + * __vi_mark_recover -- + * Recovery function for mark. + * + * PUBLIC: int __vi_mark_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *)); + */ +int +__vi_mark_recover(dbenv, dbtp, lsnp, op, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops op; + void *info; +{ + __vi_mark_args *argp; + int ret; + + REC_PRINT(__vi_mark_print); + REC_NOOP_INTRO(__vi_mark_read); + + *lsnp = argp->prev_lsn; + ret = 0; + + REC_NOOP_CLOSE; +} + +/* + * __vi_change_recover -- + * Recovery function for change. + * + * PUBLIC: int __vi_change_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *)); + */ +int +__vi_change_recover(dbenv, dbtp, lsnp, op, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + db_recops op; + void *info; +{ + __vi_change_args *argp; + int ret; + + REC_PRINT(__vi_change_print); + REC_NOOP_INTRO(__vi_change_read); + + *lsnp = argp->prev_lsn; + ret = 0; + + REC_NOOP_CLOSE; +} + -- 2.11.4.GIT