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