common/vi_rec.c

   1 #include "db_config.h"
   2
   3 #ifndef NO_SYSTEM_INCLUDES
   4 #include <sys/types.h>
   5
   6 #include <string.h>
   7 #endif
   8
   9 #include "common.h"
  10
  11 #include "db_int.h"
  12 #include "db_page.h"
  13 #include <log.h>
  14 #include "hash.h"
  15 #include "btree.h"
  16
  17 #define LOG_CURSOR_HIT      -1000
  18
  19 /*
  20  * __vi_marker_recover --
  21  *      Recovery function for marker.
  22  *
  23  * PUBLIC: int __vi_marker_recover
  24  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  25  */
  26 int
  27 __vi_marker_recover(dbenv, dbtp, lsnp, op, info)
  28         DB_ENV *dbenv;
  29         DBT *dbtp;
  30         DB_LSN *lsnp;
  31         db_recops op;
  32         void *info;
  33 {
  34         __vi_marker_args *argp;
  35         int ret;
  36
  37         REC_PRINT(__vi_marker_print);
  38         REC_NOOP_INTRO(__vi_marker_read);
  39
  40         *lsnp = argp->prev_lsn;
  41         ret = 0;
  42
  43         REC_NOOP_CLOSE;
  44 }
  45
  46 /*
  47  * __vi_cursor_recover --
  48  *      Recovery function for cursor.
  49  *
  50  * PUBLIC: int __vi_cursor_recover
  51  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  52  */
  53 int
  54 __vi_cursor_recover(dbenv, dbtp, lsnp, op, info)
  55         DB_ENV *dbenv;
  56         DBT *dbtp;
  57         DB_LSN *lsnp;
  58         db_recops op;
  59         void *info;
  60 {
  61         __vi_cursor_args *argp;
  62         int ret;
  63         SCR *sp;
  64
  65         REC_PRINT(__vi_cursor_print);
  66         REC_NOOP_INTRO(__vi_cursor_read);
  67
  68         sp = (SCR *)dbenv->app_private;
  69
  70         *lsnp = argp->prev_lsn;
  71         if (sp->state.undo == UNDO_SETLINE) {
  72                 /* Why the check for ep->l_cur ? (copied from log.c)
  73                  */
  74                 ret = (argp->lno != sp->lno ||
  75                     (argp->opcode == LOG_CURSOR_INIT && sp->ep->l_cur == 1))
  76                           ? LOG_CURSOR_HIT : 0;
  77         }
  78         else {
  79                 ret = argp->opcode ==
  80                         (DB_UNDO(op) ? LOG_CURSOR_INIT : LOG_CURSOR_END)
  81                           ? LOG_CURSOR_HIT : 0;
  82                 if (ret) {
  83                         sp->state.pos.lno = argp->lno;
  84                         sp->state.pos.cno = argp->cno;
  85                 }
  86         }
  87
  88         REC_NOOP_CLOSE;
  89 }
  90
  91 /*
  92  * __vi_mark_recover --
  93  *      Recovery function for mark.
  94  *
  95  * PUBLIC: int __vi_mark_recover
  96  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  97  */
  98 int
  99 __vi_mark_recover(dbenv, dbtp, lsnp, op, info)
 100         DB_ENV *dbenv;
 101         DBT *dbtp;
 102         DB_LSN *lsnp;
 103         db_recops op;
 104         void *info;
 105 {
 106         __vi_mark_args *argp;
 107         int ret;
 108         MARK m;
 109         SCR *sp;
 110
 111         REC_PRINT(__vi_mark_print);
 112         REC_NOOP_INTRO(__vi_mark_read);
 113
 114         sp = (SCR *)dbenv->app_private;
 115         *lsnp = argp->prev_lsn;
 116         m.lno = argp->lmp.lno;
 117         m.cno = argp->lmp.cno;
 118         ret = mark_set(sp, argp->lmp.name, &m, 0);
 119
 120         REC_NOOP_CLOSE;
 121 }
 122
 123 /*
 124  * __vi_change_recover --
 125  *      Recovery function for change.
 126  *
 127  * PUBLIC: int __vi_change_recover
 128  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
 129  */
 130 int
 131 __vi_change_recover(dbenv, dbtp, lsnp, op, info)
 132         DB_ENV *dbenv;
 133         DBT *dbtp;
 134         DB_LSN *lsnp;
 135         db_recops op;
 136         void *info;
 137 {
 138         __vi_change_args *argp;
 139         int ret;
 140         SCR *sp;
 141
 142         REC_PRINT(__vi_change_print);
 143         REC_NOOP_INTRO(__vi_change_read);
 144
 145         ret = 0;
 146
 147         sp = (SCR *)dbenv->app_private;
 148         if (DB_UNDO(op) != (argp->opcode & 1))
 149             switch (argp->opcode) {
 150             case LOG_LINE_RESET_B:
 151             case LOG_LINE_RESET_F:
 152                     ret = line_insdel(sp, LINE_RESET, argp->lno);
 153                     update_cache(sp, LINE_RESET, argp->lno);
 154                     ret = scr_update(sp, argp->lno, LINE_RESET, 1) || ret;
 155                     break;
 156             case LOG_LINE_APPEND_B:
 157             case LOG_LINE_DELETE_F:
 158                     ret = line_insdel(sp, LINE_DELETE, argp->lno);
 159                     update_cache(sp, LINE_DELETE, argp->lno);
 160                     ret = scr_update(sp, argp->lno, LINE_DELETE, 1) || ret;
 161                     break;
 162             case LOG_LINE_DELETE_B:
 163             case LOG_LINE_APPEND_F:
 164                     ret = line_insdel(sp, LINE_INSERT, argp->lno);
 165                     update_cache(sp, LINE_INSERT, argp->lno);
 166                     ret = scr_update(sp, argp->lno, LINE_INSERT, 1) || ret;
 167                     break;
 168             }
 169
 170         *lsnp = argp->prev_lsn;
 171
 172         REC_NOOP_CLOSE;
 173 }
 174
 175 /*
 176  *
 177  * PUBLIC: int __vi_log_truncate __P((EXF *ep));
 178  */
 179 int
 180 __vi_log_truncate(EXF *ep)
 181 {
 182         DB_LSN ckplsn;
 183
 184         ZERO_LSN(ckplsn);
 185         return __log_vtruncate(ep->env, &ep->lsn_cur, &ckplsn);
 186         /*return __log_vtruncate(ep->env, &ep->lsn_cur, &ep->lsn_first);*/
 187 }
 188
 189 /*
 190  *
 191  * PUBLIC: int __vi_log_dispatch __P((DB_ENV *dbenv, DBT *data, DB_LSN *lsn, db_recops ops));
 192  */
 193 int
 194 __vi_log_dispatch(DB_ENV *dbenv, DBT *data, DB_LSN *lsn, db_recops ops)
 195 {
 196         u_int32_t rectype;
 197         char    s[100];
 198
 199         memcpy(&rectype, data->data, sizeof(rectype));
 200         snprintf(s,100,"%d\n", rectype);
 201         return dbenv->dtab[rectype](dbenv, data, lsn, ops, NULL);
 202 }
 203
 204 static int
 205 vi_log_get(SCR *sp, DB_LOGC *logc, DBT *data, u_int32_t which)
 206 {
 207         size_t nlen;
 208         EXF *ep;
 209
 210         ep = sp->ep;
 211
 212         nlen = 1024;
 213 retry:
 214         BINC_GOTO(sp, sp->wp->l_lp, sp->wp->l_len, nlen);
 215         memset(data, 0, sizeof(*data));
 216         data->data = sp->wp->l_lp;
 217         data->ulen = sp->wp->l_len;
 218         data->flags = DB_DBT_USERMEM;
 219         switch ((sp->db_error = logc->get(logc, &ep->lsn_cur, data, which))) {
 220         case ENOMEM:
 221                 nlen = data->size;
 222                 goto retry;
 223         default:
 224 alloc_err:
 225                 msgq(sp, M_DBERR, "logc->get");
 226                 F_SET(ep, F_NOLOG);
 227                 return (1);
 228         case 0:
 229                 ;
 230         }
 231         return 0;
 232 }
 233
 234 /*
 235  *
 236  * PUBLIC: int __vi_log_traverse __P((SCR *sp, undo_t undo, MARK *));
 237  */
 238 int
 239 __vi_log_traverse(SCR *sp, undo_t undo, MARK *rp)
 240 {
 241         DB_LOGC *logc;
 242         DBT data;
 243         EXF *ep;
 244         int         ret;
 245         DB_LSN      lsn;
 246         u_int32_t   which;
 247         db_recops   ops;
 248
 249         ep = sp->ep;
 250
 251         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 252
 253         sp->state.undo = undo;
 254         ep->env->app_private = sp;
 255         if ((sp->db_error = ep->env->log_cursor(ep->env, &logc, 0))
 256                     != 0) {
 257                 msgq(sp, M_DBERR, "env->log_cursor");
 258                 return (1);
 259         }
 260         if (vi_log_get(sp, logc, &data, DB_SET))
 261                 return 1;
 262         if (undo == UNDO_FORWARD) {
 263                 ops = DB_TXN_FORWARD_ROLL;
 264                 which = DB_NEXT;
 265                 if (vi_log_get(sp, logc, &data, DB_NEXT))
 266                         return 1;
 267         } else {
 268                 ops = DB_TXN_BACKWARD_ROLL;
 269                 which = DB_PREV;
 270         }
 271
 272         for (;;) {
 273                 MEMCPY(&lsn, &ep->lsn_cur, 1);
 274                 ret = __vi_log_dispatch(ep->env, &data, &lsn, ops);
 275                 if (ret != 0) {
 276                         if (ret == LOG_CURSOR_HIT)
 277                                 break;
 278                 }
 279
 280                 if (vi_log_get(sp, logc, &data, which))
 281                         return 1;
 282                 if (undo == UNDO_SETLINE &&
 283                     log_compare(&ep->lsn_cur, &ep->lsn_first) <= 0) {
 284                         /* Move to previous record without dispatching. */
 285                         undo = UNDO_BACKWARD;
 286                         break;
 287                 }
 288         }
 289         if (undo == UNDO_BACKWARD)
 290                 if (vi_log_get(sp, logc, &data, DB_PREV))
 291                         return 1;
 292
 293         logc->close(logc, 0);
 294
 295         ep->env->app_private = NULL;
 296
 297         MEMMOVE(rp, &sp->state.pos, 1);
 298
 299         F_CLR(ep, F_NOLOG);
 300
 301         return 0;
 302 }
 303
 304 int
 305 vi_db_init_recover(DB_ENV *dbenv)
 306 {
 307         int     ret;
 308
 309         if ((ret = __db_init_recover(dbenv)) != 0)
 310                 return (ret);
 311         if ((ret = __bam_init_recover(dbenv)) != 0)
 312                 return (ret);
 313
 314         return 0;
 315 }