1 /* Do not edit: automatically built by gen_rec.awk. */
2 #include <sys/types.h>
3 #include <sys/queue.h>
4 #include <sys/stat.h>
5 #include <bitstring.h>
6 #include <errno.h>
7 #include <fcntl.h>
8 #include <limits.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include "common.h"
13 #include <db_int.h>
14 #include "db_page.h"
15 #include "db_am.h"
16 #include "rep.h"
17 #include "txn.h"
18 /*
19 * PUBLIC: #ifdef USE_DB4_LOGGING
20 */
21 /*
22 * PUBLIC: int __vi_marker_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
23 * PUBLIC: u_int32_t));
24 */
25 int
__vi_marker_log(dbenv,txnid,ret_lsnp,flags,opcode)26 __vi_marker_log(dbenv, txnid, ret_lsnp, flags,
27 opcode)
28 DB_ENV *dbenv;
29 DB_TXN *txnid;
30 DB_LSN *ret_lsnp;
31 u_int32_t flags;
32 u_int32_t opcode;
33 {
34 DBT logrec;
35 DB_LSN *lsnp, null_lsn;
36 u_int32_t uinttmp;
37 u_int32_t rectype, txn_num;
38 int ret;
39 u_int8_t *bp;
40
41 rectype = DB_vi_marker;
42 if (txnid != NULL &&
43 TAILQ_FIRST(&txnid->kids) != NULL &&
44 (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
45 return (ret);
46 txn_num = txnid == NULL ? 0 : txnid->txnid;
47 if (txnid == NULL) {
48 ZERO_LSN(null_lsn);
49 lsnp = &null_lsn;
50 } else
51 lsnp = &txnid->last_lsn;
52 logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
53 + sizeof(u_int32_t);
54 if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
55 return (ret);
56
57 bp = logrec.data;
58
59 memcpy(bp, &rectype, sizeof(rectype));
60 bp += sizeof(rectype);
61
62 memcpy(bp, &txn_num, sizeof(txn_num));
63 bp += sizeof(txn_num);
64
65 memcpy(bp, lsnp, sizeof(DB_LSN));
66 bp += sizeof(DB_LSN);
67
68 uinttmp = (u_int32_t)opcode;
69 memcpy(bp, &uinttmp, sizeof(uinttmp));
70 bp += sizeof(uinttmp);
71
72 DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
73 ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
74 if (txnid != NULL && ret == 0)
75 txnid->last_lsn = *ret_lsnp;
76 #ifdef LOG_DIAGNOSTIC
77 if (ret != 0)
78 (void)__vi_marker_print(dbenv,
79 (DBT *)&logrec, ret_lsnp, NULL, NULL);
80 #endif
81 __os_free(dbenv, logrec.data, logrec.size);
82 return (ret);
83 }
84
85 /*
86 * PUBLIC: int __vi_marker_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
87 * PUBLIC: void *));
88 */
89 int
__vi_marker_getpgnos(dbenv,rec,lsnp,notused1,summary)90 __vi_marker_getpgnos(dbenv, rec, lsnp, notused1, summary)
91 DB_ENV *dbenv;
92 DBT *rec;
93 DB_LSN *lsnp;
94 db_recops notused1;
95 void *summary;
96 {
97 TXN_RECS *t;
98 int ret;
99 COMPQUIET(rec, NULL);
100 COMPQUIET(notused1, DB_TXN_ABORT);
101
102 t = (TXN_RECS *)summary;
103
104 if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
105 return (ret);
106
107 t->array[t->npages].flags = LSN_PAGE_NOLOCK;
108 t->array[t->npages].lsn = *lsnp;
109 t->array[t->npages].fid = DB_LOGFILEID_INVALID;
110 memset(&t->array[t->npages].pgdesc, 0,
111 sizeof(t->array[t->npages].pgdesc));
112
113 t->npages++;
114
115 return (0);
116 }
117
118 /*
119 * PUBLIC: int __vi_marker_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
120 * PUBLIC: void *));
121 */
122 int
__vi_marker_print(dbenv,dbtp,lsnp,notused2,notused3)123 __vi_marker_print(dbenv, dbtp, lsnp, notused2, notused3)
124 DB_ENV *dbenv;
125 DBT *dbtp;
126 DB_LSN *lsnp;
127 db_recops notused2;
128 void *notused3;
129 {
130 __vi_marker_args *argp;
131 int ret;
132
133 notused2 = DB_TXN_ABORT;
134 notused3 = NULL;
135
136 if ((ret = __vi_marker_read(dbenv, dbtp->data, &argp)) != 0)
137 return (ret);
138 (void)printf(
139 "[%lu][%lu]vi_marker: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
140 (u_long)lsnp->file,
141 (u_long)lsnp->offset,
142 (u_long)argp->type,
143 (u_long)argp->txnid->txnid,
144 (u_long)argp->prev_lsn.file,
145 (u_long)argp->prev_lsn.offset);
146 (void)printf("\topcode: %lu\n", (u_long)argp->opcode);
147 (void)printf("\n");
148 __os_free(dbenv, argp, 0);
149 return (0);
150 }
151
152 /*
153 * PUBLIC: int __vi_marker_read __P((DB_ENV *, void *, __vi_marker_args **));
154 */
155 int
__vi_marker_read(dbenv,recbuf,argpp)156 __vi_marker_read(dbenv, recbuf, argpp)
157 DB_ENV *dbenv;
158 void *recbuf;
159 __vi_marker_args **argpp;
160 {
161 __vi_marker_args *argp;
162 int ret;
163 u_int32_t uinttmp;
164 u_int8_t *bp;
165
166 ret = __os_malloc(dbenv, sizeof(__vi_marker_args) +
167 sizeof(DB_TXN), &argp);
168 if (ret != 0)
169 return (ret);
170 argp->txnid = (DB_TXN *)&argp[1];
171
172 bp = recbuf;
173 memcpy(&argp->type, bp, sizeof(argp->type));
174 bp += sizeof(argp->type);
175
176 memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid));
177 bp += sizeof(argp->txnid->txnid);
178
179 memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
180 bp += sizeof(DB_LSN);
181
182 memcpy(&uinttmp, bp, sizeof(uinttmp));
183 argp->opcode = (u_int32_t)uinttmp;
184 bp += sizeof(uinttmp);
185
186 *argpp = argp;
187 return (0);
188 }
189
190 /*
191 * PUBLIC: int __vi_cursor_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
192 * PUBLIC: u_int32_t, db_recno_t, size_t));
193 */
194 int
__vi_cursor_log(dbenv,txnid,ret_lsnp,flags,opcode,lno,cno)195 __vi_cursor_log(dbenv, txnid, ret_lsnp, flags,
196 opcode, lno, cno)
197 DB_ENV *dbenv;
198 DB_TXN *txnid;
199 DB_LSN *ret_lsnp;
200 u_int32_t flags;
201 u_int32_t opcode;
202 db_recno_t lno;
203 size_t cno;
204 {
205 DBT logrec;
206 DB_LSN *lsnp, null_lsn;
207 u_int32_t uinttmp;
208 u_int32_t rectype, txn_num;
209 int ret;
210 u_int8_t *bp;
211
212 rectype = DB_vi_cursor;
213 if (txnid != NULL &&
214 TAILQ_FIRST(&txnid->kids) != NULL &&
215 (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
216 return (ret);
217 txn_num = txnid == NULL ? 0 : txnid->txnid;
218 if (txnid == NULL) {
219 ZERO_LSN(null_lsn);
220 lsnp = &null_lsn;
221 } else
222 lsnp = &txnid->last_lsn;
223 logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
224 + sizeof(u_int32_t)
225 + sizeof(u_int32_t)
226 + sizeof(u_int32_t);
227 if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
228 return (ret);
229
230 bp = logrec.data;
231
232 memcpy(bp, &rectype, sizeof(rectype));
233 bp += sizeof(rectype);
234
235 memcpy(bp, &txn_num, sizeof(txn_num));
236 bp += sizeof(txn_num);
237
238 memcpy(bp, lsnp, sizeof(DB_LSN));
239 bp += sizeof(DB_LSN);
240
241 uinttmp = (u_int32_t)opcode;
242 memcpy(bp, &uinttmp, sizeof(uinttmp));
243 bp += sizeof(uinttmp);
244
245 uinttmp = (u_int32_t)lno;
246 memcpy(bp, &uinttmp, sizeof(uinttmp));
247 bp += sizeof(uinttmp);
248
249 uinttmp = (u_int32_t)cno;
250 memcpy(bp, &uinttmp, sizeof(uinttmp));
251 bp += sizeof(uinttmp);
252
253 DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
254 ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
255 if (txnid != NULL && ret == 0)
256 txnid->last_lsn = *ret_lsnp;
257 #ifdef LOG_DIAGNOSTIC
258 if (ret != 0)
259 (void)__vi_cursor_print(dbenv,
260 (DBT *)&logrec, ret_lsnp, NULL, NULL);
261 #endif
262 __os_free(dbenv, logrec.data, logrec.size);
263 return (ret);
264 }
265
266 /*
267 * PUBLIC: int __vi_cursor_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
268 * PUBLIC: void *));
269 */
270 int
__vi_cursor_getpgnos(dbenv,rec,lsnp,notused1,summary)271 __vi_cursor_getpgnos(dbenv, rec, lsnp, notused1, summary)
272 DB_ENV *dbenv;
273 DBT *rec;
274 DB_LSN *lsnp;
275 db_recops notused1;
276 void *summary;
277 {
278 TXN_RECS *t;
279 int ret;
280 COMPQUIET(rec, NULL);
281 COMPQUIET(notused1, DB_TXN_ABORT);
282
283 t = (TXN_RECS *)summary;
284
285 if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
286 return (ret);
287
288 t->array[t->npages].flags = LSN_PAGE_NOLOCK;
289 t->array[t->npages].lsn = *lsnp;
290 t->array[t->npages].fid = DB_LOGFILEID_INVALID;
291 memset(&t->array[t->npages].pgdesc, 0,
292 sizeof(t->array[t->npages].pgdesc));
293
294 t->npages++;
295
296 return (0);
297 }
298
299 /*
300 * PUBLIC: int __vi_cursor_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
301 * PUBLIC: void *));
302 */
303 int
__vi_cursor_print(dbenv,dbtp,lsnp,notused2,notused3)304 __vi_cursor_print(dbenv, dbtp, lsnp, notused2, notused3)
305 DB_ENV *dbenv;
306 DBT *dbtp;
307 DB_LSN *lsnp;
308 db_recops notused2;
309 void *notused3;
310 {
311 __vi_cursor_args *argp;
312 int ret;
313
314 notused2 = DB_TXN_ABORT;
315 notused3 = NULL;
316
317 if ((ret = __vi_cursor_read(dbenv, dbtp->data, &argp)) != 0)
318 return (ret);
319 (void)printf(
320 "[%lu][%lu]vi_cursor: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
321 (u_long)lsnp->file,
322 (u_long)lsnp->offset,
323 (u_long)argp->type,
324 (u_long)argp->txnid->txnid,
325 (u_long)argp->prev_lsn.file,
326 (u_long)argp->prev_lsn.offset);
327 (void)printf("\topcode: %lu\n", (u_long)argp->opcode);
328 (void)printf("\tlno: %lu\n", (u_long)argp->lno);
329 (void)printf("\tcno: %d\n", argp->cno);
330 (void)printf("\n");
331 __os_free(dbenv, argp, 0);
332 return (0);
333 }
334
335 /*
336 * PUBLIC: int __vi_cursor_read __P((DB_ENV *, void *, __vi_cursor_args **));
337 */
338 int
__vi_cursor_read(dbenv,recbuf,argpp)339 __vi_cursor_read(dbenv, recbuf, argpp)
340 DB_ENV *dbenv;
341 void *recbuf;
342 __vi_cursor_args **argpp;
343 {
344 __vi_cursor_args *argp;
345 int ret;
346 u_int32_t uinttmp;
347 u_int8_t *bp;
348
349 ret = __os_malloc(dbenv, sizeof(__vi_cursor_args) +
350 sizeof(DB_TXN), &argp);
351 if (ret != 0)
352 return (ret);
353 argp->txnid = (DB_TXN *)&argp[1];
354
355 bp = recbuf;
356 memcpy(&argp->type, bp, sizeof(argp->type));
357 bp += sizeof(argp->type);
358
359 memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid));
360 bp += sizeof(argp->txnid->txnid);
361
362 memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
363 bp += sizeof(DB_LSN);
364
365 memcpy(&uinttmp, bp, sizeof(uinttmp));
366 argp->opcode = (u_int32_t)uinttmp;
367 bp += sizeof(uinttmp);
368
369 memcpy(&uinttmp, bp, sizeof(uinttmp));
370 argp->lno = (db_recno_t)uinttmp;
371 bp += sizeof(uinttmp);
372
373 memcpy(&uinttmp, bp, sizeof(uinttmp));
374 argp->cno = (size_t)uinttmp;
375 bp += sizeof(uinttmp);
376
377 *argpp = argp;
378 return (0);
379 }
380
381 /*
382 * PUBLIC: int __vi_mark_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
383 * PUBLIC: LMARK *));
384 */
385 int
__vi_mark_log(dbenv,txnid,ret_lsnp,flags,lmp)386 __vi_mark_log(dbenv, txnid, ret_lsnp, flags,
387 lmp)
388 DB_ENV *dbenv;
389 DB_TXN *txnid;
390 DB_LSN *ret_lsnp;
391 u_int32_t flags;
392 LMARK * lmp;
393 {
394 DBT logrec;
395 DB_LSN *lsnp, null_lsn;
396 u_int32_t rectype, txn_num;
397 int ret;
398 u_int8_t *bp;
399
400 rectype = DB_vi_mark;
401 if (txnid != NULL &&
402 TAILQ_FIRST(&txnid->kids) != NULL &&
403 (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
404 return (ret);
405 txn_num = txnid == NULL ? 0 : txnid->txnid;
406 if (txnid == NULL) {
407 ZERO_LSN(null_lsn);
408 lsnp = &null_lsn;
409 } else
410 lsnp = &txnid->last_lsn;
411 logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
412 + sizeof(*lmp);
413 if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
414 return (ret);
415
416 bp = logrec.data;
417
418 memcpy(bp, &rectype, sizeof(rectype));
419 bp += sizeof(rectype);
420
421 memcpy(bp, &txn_num, sizeof(txn_num));
422 bp += sizeof(txn_num);
423
424 memcpy(bp, lsnp, sizeof(DB_LSN));
425 bp += sizeof(DB_LSN);
426
427 if (lmp != NULL)
428 memcpy(bp, lmp, sizeof(*lmp));
429 else
430 memset(bp, 0, sizeof(*lmp));
431 bp += sizeof(*lmp);
432
433 DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
434 ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
435 if (txnid != NULL && ret == 0)
436 txnid->last_lsn = *ret_lsnp;
437 #ifdef LOG_DIAGNOSTIC
438 if (ret != 0)
439 (void)__vi_mark_print(dbenv,
440 (DBT *)&logrec, ret_lsnp, NULL, NULL);
441 #endif
442 __os_free(dbenv, logrec.data, logrec.size);
443 return (ret);
444 }
445
446 /*
447 * PUBLIC: int __vi_mark_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
448 * PUBLIC: void *));
449 */
450 int
__vi_mark_getpgnos(dbenv,rec,lsnp,notused1,summary)451 __vi_mark_getpgnos(dbenv, rec, lsnp, notused1, summary)
452 DB_ENV *dbenv;
453 DBT *rec;
454 DB_LSN *lsnp;
455 db_recops notused1;
456 void *summary;
457 {
458 TXN_RECS *t;
459 int ret;
460 COMPQUIET(rec, NULL);
461 COMPQUIET(notused1, DB_TXN_ABORT);
462
463 t = (TXN_RECS *)summary;
464
465 if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
466 return (ret);
467
468 t->array[t->npages].flags = LSN_PAGE_NOLOCK;
469 t->array[t->npages].lsn = *lsnp;
470 t->array[t->npages].fid = DB_LOGFILEID_INVALID;
471 memset(&t->array[t->npages].pgdesc, 0,
472 sizeof(t->array[t->npages].pgdesc));
473
474 t->npages++;
475
476 return (0);
477 }
478
479 /*
480 * PUBLIC: int __vi_mark_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
481 * PUBLIC: void *));
482 */
483 int
__vi_mark_print(dbenv,dbtp,lsnp,notused2,notused3)484 __vi_mark_print(dbenv, dbtp, lsnp, notused2, notused3)
485 DB_ENV *dbenv;
486 DBT *dbtp;
487 DB_LSN *lsnp;
488 db_recops notused2;
489 void *notused3;
490 {
491 __vi_mark_args *argp;
492 int ret;
493
494 notused2 = DB_TXN_ABORT;
495 notused3 = NULL;
496
497 if ((ret = __vi_mark_read(dbenv, dbtp->data, &argp)) != 0)
498 return (ret);
499 (void)printf(
500 "[%lu][%lu]vi_mark: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
501 (u_long)lsnp->file,
502 (u_long)lsnp->offset,
503 (u_long)argp->type,
504 (u_long)argp->txnid->txnid,
505 (u_long)argp->prev_lsn.file,
506 (u_long)argp->prev_lsn.offset);
507 (void)printf("\tlmp: %%\n", argp->lmp);
508 (void)printf("\n");
509 __os_free(dbenv, argp, 0);
510 return (0);
511 }
512
513 /*
514 * PUBLIC: int __vi_mark_read __P((DB_ENV *, void *, __vi_mark_args **));
515 */
516 int
__vi_mark_read(dbenv,recbuf,argpp)517 __vi_mark_read(dbenv, recbuf, argpp)
518 DB_ENV *dbenv;
519 void *recbuf;
520 __vi_mark_args **argpp;
521 {
522 __vi_mark_args *argp;
523 int ret;
524 u_int8_t *bp;
525
526 ret = __os_malloc(dbenv, sizeof(__vi_mark_args) +
527 sizeof(DB_TXN), &argp);
528 if (ret != 0)
529 return (ret);
530 argp->txnid = (DB_TXN *)&argp[1];
531
532 bp = recbuf;
533 memcpy(&argp->type, bp, sizeof(argp->type));
534 bp += sizeof(argp->type);
535
536 memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid));
537 bp += sizeof(argp->txnid->txnid);
538
539 memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
540 bp += sizeof(DB_LSN);
541
542 memcpy(&argp->lmp, bp, sizeof(argp->lmp));
543 bp += sizeof(argp->lmp);
544
545 *argpp = argp;
546 return (0);
547 }
548
549 /*
550 * PUBLIC: int __vi_change_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
551 * PUBLIC: u_int32_t, db_recno_t));
552 */
553 int
__vi_change_log(dbenv,txnid,ret_lsnp,flags,opcode,lno)554 __vi_change_log(dbenv, txnid, ret_lsnp, flags,
555 opcode, lno)
556 DB_ENV *dbenv;
557 DB_TXN *txnid;
558 DB_LSN *ret_lsnp;
559 u_int32_t flags;
560 u_int32_t opcode;
561 db_recno_t lno;
562 {
563 DBT logrec;
564 DB_LSN *lsnp, null_lsn;
565 u_int32_t uinttmp;
566 u_int32_t rectype, txn_num;
567 int ret;
568 u_int8_t *bp;
569
570 rectype = DB_vi_change;
571 if (txnid != NULL &&
572 TAILQ_FIRST(&txnid->kids) != NULL &&
573 (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
574 return (ret);
575 txn_num = txnid == NULL ? 0 : txnid->txnid;
576 if (txnid == NULL) {
577 ZERO_LSN(null_lsn);
578 lsnp = &null_lsn;
579 } else
580 lsnp = &txnid->last_lsn;
581 logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
582 + sizeof(u_int32_t)
583 + sizeof(u_int32_t);
584 if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
585 return (ret);
586
587 bp = logrec.data;
588
589 memcpy(bp, &rectype, sizeof(rectype));
590 bp += sizeof(rectype);
591
592 memcpy(bp, &txn_num, sizeof(txn_num));
593 bp += sizeof(txn_num);
594
595 memcpy(bp, lsnp, sizeof(DB_LSN));
596 bp += sizeof(DB_LSN);
597
598 uinttmp = (u_int32_t)opcode;
599 memcpy(bp, &uinttmp, sizeof(uinttmp));
600 bp += sizeof(uinttmp);
601
602 uinttmp = (u_int32_t)lno;
603 memcpy(bp, &uinttmp, sizeof(uinttmp));
604 bp += sizeof(uinttmp);
605
606 DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
607 ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
608 if (txnid != NULL && ret == 0)
609 txnid->last_lsn = *ret_lsnp;
610 #ifdef LOG_DIAGNOSTIC
611 if (ret != 0)
612 (void)__vi_change_print(dbenv,
613 (DBT *)&logrec, ret_lsnp, NULL, NULL);
614 #endif
615 __os_free(dbenv, logrec.data, logrec.size);
616 return (ret);
617 }
618
619 /*
620 * PUBLIC: int __vi_change_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
621 * PUBLIC: void *));
622 */
623 int
__vi_change_getpgnos(dbenv,rec,lsnp,notused1,summary)624 __vi_change_getpgnos(dbenv, rec, lsnp, notused1, summary)
625 DB_ENV *dbenv;
626 DBT *rec;
627 DB_LSN *lsnp;
628 db_recops notused1;
629 void *summary;
630 {
631 TXN_RECS *t;
632 int ret;
633 COMPQUIET(rec, NULL);
634 COMPQUIET(notused1, DB_TXN_ABORT);
635
636 t = (TXN_RECS *)summary;
637
638 if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
639 return (ret);
640
641 t->array[t->npages].flags = LSN_PAGE_NOLOCK;
642 t->array[t->npages].lsn = *lsnp;
643 t->array[t->npages].fid = DB_LOGFILEID_INVALID;
644 memset(&t->array[t->npages].pgdesc, 0,
645 sizeof(t->array[t->npages].pgdesc));
646
647 t->npages++;
648
649 return (0);
650 }
651
652 /*
653 * PUBLIC: int __vi_change_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
654 * PUBLIC: void *));
655 */
656 int
__vi_change_print(dbenv,dbtp,lsnp,notused2,notused3)657 __vi_change_print(dbenv, dbtp, lsnp, notused2, notused3)
658 DB_ENV *dbenv;
659 DBT *dbtp;
660 DB_LSN *lsnp;
661 db_recops notused2;
662 void *notused3;
663 {
664 __vi_change_args *argp;
665 int ret;
666
667 notused2 = DB_TXN_ABORT;
668 notused3 = NULL;
669
670 if ((ret = __vi_change_read(dbenv, dbtp->data, &argp)) != 0)
671 return (ret);
672 (void)printf(
673 "[%lu][%lu]vi_change: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
674 (u_long)lsnp->file,
675 (u_long)lsnp->offset,
676 (u_long)argp->type,
677 (u_long)argp->txnid->txnid,
678 (u_long)argp->prev_lsn.file,
679 (u_long)argp->prev_lsn.offset);
680 (void)printf("\topcode: %lu\n", (u_long)argp->opcode);
681 (void)printf("\tlno: %lu\n", (u_long)argp->lno);
682 (void)printf("\n");
683 __os_free(dbenv, argp, 0);
684 return (0);
685 }
686
687 /*
688 * PUBLIC: int __vi_change_read __P((DB_ENV *, void *, __vi_change_args **));
689 */
690 int
__vi_change_read(dbenv,recbuf,argpp)691 __vi_change_read(dbenv, recbuf, argpp)
692 DB_ENV *dbenv;
693 void *recbuf;
694 __vi_change_args **argpp;
695 {
696 __vi_change_args *argp;
697 int ret;
698 u_int32_t uinttmp;
699 u_int8_t *bp;
700
701 ret = __os_malloc(dbenv, sizeof(__vi_change_args) +
702 sizeof(DB_TXN), &argp);
703 if (ret != 0)
704 return (ret);
705 argp->txnid = (DB_TXN *)&argp[1];
706
707 bp = recbuf;
708 memcpy(&argp->type, bp, sizeof(argp->type));
709 bp += sizeof(argp->type);
710
711 memcpy(&argp->txnid->txnid, bp, sizeof(argp->txnid->txnid));
712 bp += sizeof(argp->txnid->txnid);
713
714 memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
715 bp += sizeof(DB_LSN);
716
717 memcpy(&uinttmp, bp, sizeof(uinttmp));
718 argp->opcode = (u_int32_t)uinttmp;
719 bp += sizeof(uinttmp);
720
721 memcpy(&uinttmp, bp, sizeof(uinttmp));
722 argp->lno = (db_recno_t)uinttmp;
723 bp += sizeof(uinttmp);
724
725 *argpp = argp;
726 return (0);
727 }
728
729 /*
730 * PUBLIC: int __vi_init_print __P((DB_ENV *, int (***)(DB_ENV *, DBT *,
731 * PUBLIC: DB_LSN *, db_recops, void *), size_t *));
732 */
733 int
__vi_init_print(dbenv,dtabp,dtabsizep)734 __vi_init_print(dbenv, dtabp, dtabsizep)
735 DB_ENV *dbenv;
736 int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
737 size_t *dtabsizep;
738 {
739 int ret;
740
741 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
742 __vi_marker_print, DB_vi_marker)) != 0)
743 return (ret);
744 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
745 __vi_cursor_print, DB_vi_cursor)) != 0)
746 return (ret);
747 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
748 __vi_mark_print, DB_vi_mark)) != 0)
749 return (ret);
750 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
751 __vi_change_print, DB_vi_change)) != 0)
752 return (ret);
753 return (0);
754 }
755
756 /*
757 * PUBLIC: int __vi_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *, DBT *,
758 * PUBLIC: DB_LSN *, db_recops, void *), size_t *));
759 */
760 int
__vi_init_getpgnos(dbenv,dtabp,dtabsizep)761 __vi_init_getpgnos(dbenv, dtabp, dtabsizep)
762 DB_ENV *dbenv;
763 int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
764 size_t *dtabsizep;
765 {
766 int ret;
767
768 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
769 __vi_marker_getpgnos, DB_vi_marker)) != 0)
770 return (ret);
771 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
772 __vi_cursor_getpgnos, DB_vi_cursor)) != 0)
773 return (ret);
774 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
775 __vi_mark_getpgnos, DB_vi_mark)) != 0)
776 return (ret);
777 if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
778 __vi_change_getpgnos, DB_vi_change)) != 0)
779 return (ret);
780 return (0);
781 }
782
783 /*
784 * PUBLIC: int __vi_init_recover __P((DB_ENV *));
785 */
786 int
__vi_init_recover(dbenv)787 __vi_init_recover(dbenv)
788 DB_ENV *dbenv;
789 {
790 int ret;
791
792 if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
793 __vi_marker_recover, DB_vi_marker)) != 0)
794 return (ret);
795 if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
796 __vi_cursor_recover, DB_vi_cursor)) != 0)
797 return (ret);
798 if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
799 __vi_mark_recover, DB_vi_mark)) != 0)
800 return (ret);
801 if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
802 __vi_change_recover, DB_vi_change)) != 0)
803 return (ret);
804 return (0);
805 }
806 /*
807 * PUBLIC: #endif
808 */
809