6922504383d2c50d870ad8cdeb17fcbe1a6ef613
[kopensolaris-gnu/glibc.git] / db2 / db / db_auto.c
1 /* Do not edit: automatically built by dist/db_gen.sh. */
2 #include "config.h"
3
4 #ifndef NO_SYSTEM_INCLUDES
5 #include <ctype.h>
6 #include <errno.h>
7 #include <stddef.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #endif
11
12 #include "db_int.h"
13 #include "shqueue.h"
14 #include "db_page.h"
15 #include "db_dispatch.h"
16 #include "db_am.h"
17 #include "common_ext.h"
18
19 /*
20  * PUBLIC: int __db_addrem_log
21  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
22  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, u_int32_t,
23  * PUBLIC:     size_t, DBT *, DBT *, DB_LSN *));
24  */
25 int __db_addrem_log(logp, txnid, ret_lsnp, flags,
26         opcode, fileid, pgno, indx, nbytes, hdr,
27         dbt, pagelsn)
28         DB_LOG *logp;
29         DB_TXN *txnid;
30         DB_LSN *ret_lsnp;
31         u_int32_t flags;
32         u_int32_t opcode;
33         u_int32_t fileid;
34         db_pgno_t pgno;
35         u_int32_t indx;
36         size_t nbytes;
37         DBT *hdr;
38         DBT *dbt;
39         DB_LSN * pagelsn;
40 {
41         DBT logrec;
42         DB_LSN *lsnp, null_lsn;
43         u_int32_t zero;
44         u_int32_t rectype, txn_num;
45         int ret;
46         u_int8_t *bp;
47
48         rectype = DB_db_addrem;
49         txn_num = txnid == NULL ? 0 : txnid->txnid;
50         if (txnid == NULL) {
51                 null_lsn.file = 0;
52                 null_lsn.offset = 0;
53                 lsnp = &null_lsn;
54         } else
55                 lsnp = &txnid->last_lsn;
56         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
57             + sizeof(opcode)
58             + sizeof(fileid)
59             + sizeof(pgno)
60             + sizeof(indx)
61             + sizeof(nbytes)
62             + sizeof(u_int32_t) + (hdr == NULL ? 0 : hdr->size)
63             + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
64             + sizeof(*pagelsn);
65         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
66                 return (ENOMEM);
67
68         bp = logrec.data;
69         memcpy(bp, &rectype, sizeof(rectype));
70         bp += sizeof(rectype);
71         memcpy(bp, &txn_num, sizeof(txn_num));
72         bp += sizeof(txn_num);
73         memcpy(bp, lsnp, sizeof(DB_LSN));
74         bp += sizeof(DB_LSN);
75         memcpy(bp, &opcode, sizeof(opcode));
76         bp += sizeof(opcode);
77         memcpy(bp, &fileid, sizeof(fileid));
78         bp += sizeof(fileid);
79         memcpy(bp, &pgno, sizeof(pgno));
80         bp += sizeof(pgno);
81         memcpy(bp, &indx, sizeof(indx));
82         bp += sizeof(indx);
83         memcpy(bp, &nbytes, sizeof(nbytes));
84         bp += sizeof(nbytes);
85         if (hdr == NULL) {
86                 zero = 0;
87                 memcpy(bp, &zero, sizeof(u_int32_t));
88                 bp += sizeof(u_int32_t);
89         } else {
90                 memcpy(bp, &hdr->size, sizeof(hdr->size));
91                 bp += sizeof(hdr->size);
92                 memcpy(bp, hdr->data, hdr->size);
93                 bp += hdr->size;
94         }
95         if (dbt == NULL) {
96                 zero = 0;
97                 memcpy(bp, &zero, sizeof(u_int32_t));
98                 bp += sizeof(u_int32_t);
99         } else {
100                 memcpy(bp, &dbt->size, sizeof(dbt->size));
101                 bp += sizeof(dbt->size);
102                 memcpy(bp, dbt->data, dbt->size);
103                 bp += dbt->size;
104         }
105         if (pagelsn != NULL)
106                 memcpy(bp, pagelsn, sizeof(*pagelsn));
107         else
108                 memset(bp, 0, sizeof(*pagelsn));
109         bp += sizeof(*pagelsn);
110 #ifdef DEBUG
111         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
112                 fprintf(stderr, "Error in log record length");
113 #endif
114         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
115         if (txnid != NULL)
116                 txnid->last_lsn = *ret_lsnp;
117         free(logrec.data);
118         return (ret);
119 }
120
121 /*
122  * PUBLIC: int __db_addrem_print
123  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
124  */
125
126 int
127 __db_addrem_print(notused1, dbtp, lsnp, notused3, notused4)
128         DB_LOG *notused1;
129         DBT *dbtp;
130         DB_LSN *lsnp;
131         int notused3;
132         void *notused4;
133 {
134         __db_addrem_args *argp;
135         u_int32_t i;
136         int c, ret;
137
138         i = 0;
139         c = 0;
140         notused1 = NULL;
141         notused3 = 0;
142         notused4 = NULL;
143
144         if ((ret = __db_addrem_read(dbtp->data, &argp)) != 0)
145                 return (ret);
146         printf("[%lu][%lu]db_addrem: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
147             (u_long)lsnp->file,
148             (u_long)lsnp->offset,
149             (u_long)argp->type,
150             (u_long)argp->txnid->txnid,
151             (u_long)argp->prev_lsn.file,
152             (u_long)argp->prev_lsn.offset);
153         printf("\topcode: %lu\n", (u_long)argp->opcode);
154         printf("\tfileid: %lu\n", (u_long)argp->fileid);
155         printf("\tpgno: %lu\n", (u_long)argp->pgno);
156         printf("\tindx: %lu\n", (u_long)argp->indx);
157         printf("\tnbytes: %lu\n", (u_long)argp->nbytes);
158         printf("\thdr: ");
159         for (i = 0; i < argp->hdr.size; i++) {
160                 c = ((char *)argp->hdr.data)[i];
161                 if (isprint(c) || c == 0xa)
162                         putchar(c);
163                 else
164                         printf("%#x ", c);
165         }
166         printf("\n");
167         printf("\tdbt: ");
168         for (i = 0; i < argp->dbt.size; i++) {
169                 c = ((char *)argp->dbt.data)[i];
170                 if (isprint(c) || c == 0xa)
171                         putchar(c);
172                 else
173                         printf("%#x ", c);
174         }
175         printf("\n");
176         printf("\tpagelsn: [%lu][%lu]\n",
177             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
178         printf("\n");
179         free(argp);
180         return (0);
181 }
182
183 /*
184  * PUBLIC: int __db_addrem_read __P((void *, __db_addrem_args **));
185  */
186 int
187 __db_addrem_read(recbuf, argpp)
188         void *recbuf;
189         __db_addrem_args **argpp;
190 {
191         __db_addrem_args *argp;
192         u_int8_t *bp;
193
194         argp = (__db_addrem_args *)malloc(sizeof(__db_addrem_args) +
195             sizeof(DB_TXN));
196         if (argp == NULL)
197                 return (ENOMEM);
198         argp->txnid = (DB_TXN *)&argp[1];
199         bp = recbuf;
200         memcpy(&argp->type, bp, sizeof(argp->type));
201         bp += sizeof(argp->type);
202         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
203         bp += sizeof(argp->txnid->txnid);
204         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
205         bp += sizeof(DB_LSN);
206         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
207         bp += sizeof(argp->opcode);
208         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
209         bp += sizeof(argp->fileid);
210         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
211         bp += sizeof(argp->pgno);
212         memcpy(&argp->indx, bp, sizeof(argp->indx));
213         bp += sizeof(argp->indx);
214         memcpy(&argp->nbytes, bp, sizeof(argp->nbytes));
215         bp += sizeof(argp->nbytes);
216         memcpy(&argp->hdr.size, bp, sizeof(u_int32_t));
217         bp += sizeof(u_int32_t);
218         argp->hdr.data = bp;
219         bp += argp->hdr.size;
220         memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
221         bp += sizeof(u_int32_t);
222         argp->dbt.data = bp;
223         bp += argp->dbt.size;
224         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
225         bp += sizeof(argp->pagelsn);
226         *argpp = argp;
227         return (0);
228 }
229
230 /*
231  * PUBLIC: int __db_split_log
232  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
233  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, DBT *,
234  * PUBLIC:     DB_LSN *));
235  */
236 int __db_split_log(logp, txnid, ret_lsnp, flags,
237         opcode, fileid, pgno, pageimage, pagelsn)
238         DB_LOG *logp;
239         DB_TXN *txnid;
240         DB_LSN *ret_lsnp;
241         u_int32_t flags;
242         u_int32_t opcode;
243         u_int32_t fileid;
244         db_pgno_t pgno;
245         DBT *pageimage;
246         DB_LSN * pagelsn;
247 {
248         DBT logrec;
249         DB_LSN *lsnp, null_lsn;
250         u_int32_t zero;
251         u_int32_t rectype, txn_num;
252         int ret;
253         u_int8_t *bp;
254
255         rectype = DB_db_split;
256         txn_num = txnid == NULL ? 0 : txnid->txnid;
257         if (txnid == NULL) {
258                 null_lsn.file = 0;
259                 null_lsn.offset = 0;
260                 lsnp = &null_lsn;
261         } else
262                 lsnp = &txnid->last_lsn;
263         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
264             + sizeof(opcode)
265             + sizeof(fileid)
266             + sizeof(pgno)
267             + sizeof(u_int32_t) + (pageimage == NULL ? 0 : pageimage->size)
268             + sizeof(*pagelsn);
269         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
270                 return (ENOMEM);
271
272         bp = logrec.data;
273         memcpy(bp, &rectype, sizeof(rectype));
274         bp += sizeof(rectype);
275         memcpy(bp, &txn_num, sizeof(txn_num));
276         bp += sizeof(txn_num);
277         memcpy(bp, lsnp, sizeof(DB_LSN));
278         bp += sizeof(DB_LSN);
279         memcpy(bp, &opcode, sizeof(opcode));
280         bp += sizeof(opcode);
281         memcpy(bp, &fileid, sizeof(fileid));
282         bp += sizeof(fileid);
283         memcpy(bp, &pgno, sizeof(pgno));
284         bp += sizeof(pgno);
285         if (pageimage == NULL) {
286                 zero = 0;
287                 memcpy(bp, &zero, sizeof(u_int32_t));
288                 bp += sizeof(u_int32_t);
289         } else {
290                 memcpy(bp, &pageimage->size, sizeof(pageimage->size));
291                 bp += sizeof(pageimage->size);
292                 memcpy(bp, pageimage->data, pageimage->size);
293                 bp += pageimage->size;
294         }
295         if (pagelsn != NULL)
296                 memcpy(bp, pagelsn, sizeof(*pagelsn));
297         else
298                 memset(bp, 0, sizeof(*pagelsn));
299         bp += sizeof(*pagelsn);
300 #ifdef DEBUG
301         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
302                 fprintf(stderr, "Error in log record length");
303 #endif
304         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
305         if (txnid != NULL)
306                 txnid->last_lsn = *ret_lsnp;
307         free(logrec.data);
308         return (ret);
309 }
310
311 /*
312  * PUBLIC: int __db_split_print
313  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
314  */
315
316 int
317 __db_split_print(notused1, dbtp, lsnp, notused3, notused4)
318         DB_LOG *notused1;
319         DBT *dbtp;
320         DB_LSN *lsnp;
321         int notused3;
322         void *notused4;
323 {
324         __db_split_args *argp;
325         u_int32_t i;
326         int c, ret;
327
328         i = 0;
329         c = 0;
330         notused1 = NULL;
331         notused3 = 0;
332         notused4 = NULL;
333
334         if ((ret = __db_split_read(dbtp->data, &argp)) != 0)
335                 return (ret);
336         printf("[%lu][%lu]db_split: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
337             (u_long)lsnp->file,
338             (u_long)lsnp->offset,
339             (u_long)argp->type,
340             (u_long)argp->txnid->txnid,
341             (u_long)argp->prev_lsn.file,
342             (u_long)argp->prev_lsn.offset);
343         printf("\topcode: %lu\n", (u_long)argp->opcode);
344         printf("\tfileid: %lu\n", (u_long)argp->fileid);
345         printf("\tpgno: %lu\n", (u_long)argp->pgno);
346         printf("\tpageimage: ");
347         for (i = 0; i < argp->pageimage.size; i++) {
348                 c = ((char *)argp->pageimage.data)[i];
349                 if (isprint(c) || c == 0xa)
350                         putchar(c);
351                 else
352                         printf("%#x ", c);
353         }
354         printf("\n");
355         printf("\tpagelsn: [%lu][%lu]\n",
356             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
357         printf("\n");
358         free(argp);
359         return (0);
360 }
361
362 /*
363  * PUBLIC: int __db_split_read __P((void *, __db_split_args **));
364  */
365 int
366 __db_split_read(recbuf, argpp)
367         void *recbuf;
368         __db_split_args **argpp;
369 {
370         __db_split_args *argp;
371         u_int8_t *bp;
372
373         argp = (__db_split_args *)malloc(sizeof(__db_split_args) +
374             sizeof(DB_TXN));
375         if (argp == NULL)
376                 return (ENOMEM);
377         argp->txnid = (DB_TXN *)&argp[1];
378         bp = recbuf;
379         memcpy(&argp->type, bp, sizeof(argp->type));
380         bp += sizeof(argp->type);
381         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
382         bp += sizeof(argp->txnid->txnid);
383         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
384         bp += sizeof(DB_LSN);
385         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
386         bp += sizeof(argp->opcode);
387         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
388         bp += sizeof(argp->fileid);
389         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
390         bp += sizeof(argp->pgno);
391         memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
392         bp += sizeof(u_int32_t);
393         argp->pageimage.data = bp;
394         bp += argp->pageimage.size;
395         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
396         bp += sizeof(argp->pagelsn);
397         *argpp = argp;
398         return (0);
399 }
400
401 /*
402  * PUBLIC: int __db_big_log
403  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
404  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, db_pgno_t,
405  * PUBLIC:     db_pgno_t, DBT *, DB_LSN *, DB_LSN *,
406  * PUBLIC:     DB_LSN *));
407  */
408 int __db_big_log(logp, txnid, ret_lsnp, flags,
409         opcode, fileid, pgno, prev_pgno, next_pgno, dbt,
410         pagelsn, prevlsn, nextlsn)
411         DB_LOG *logp;
412         DB_TXN *txnid;
413         DB_LSN *ret_lsnp;
414         u_int32_t flags;
415         u_int32_t opcode;
416         u_int32_t fileid;
417         db_pgno_t pgno;
418         db_pgno_t prev_pgno;
419         db_pgno_t next_pgno;
420         DBT *dbt;
421         DB_LSN * pagelsn;
422         DB_LSN * prevlsn;
423         DB_LSN * nextlsn;
424 {
425         DBT logrec;
426         DB_LSN *lsnp, null_lsn;
427         u_int32_t zero;
428         u_int32_t rectype, txn_num;
429         int ret;
430         u_int8_t *bp;
431
432         rectype = DB_db_big;
433         txn_num = txnid == NULL ? 0 : txnid->txnid;
434         if (txnid == NULL) {
435                 null_lsn.file = 0;
436                 null_lsn.offset = 0;
437                 lsnp = &null_lsn;
438         } else
439                 lsnp = &txnid->last_lsn;
440         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
441             + sizeof(opcode)
442             + sizeof(fileid)
443             + sizeof(pgno)
444             + sizeof(prev_pgno)
445             + sizeof(next_pgno)
446             + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
447             + sizeof(*pagelsn)
448             + sizeof(*prevlsn)
449             + sizeof(*nextlsn);
450         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
451                 return (ENOMEM);
452
453         bp = logrec.data;
454         memcpy(bp, &rectype, sizeof(rectype));
455         bp += sizeof(rectype);
456         memcpy(bp, &txn_num, sizeof(txn_num));
457         bp += sizeof(txn_num);
458         memcpy(bp, lsnp, sizeof(DB_LSN));
459         bp += sizeof(DB_LSN);
460         memcpy(bp, &opcode, sizeof(opcode));
461         bp += sizeof(opcode);
462         memcpy(bp, &fileid, sizeof(fileid));
463         bp += sizeof(fileid);
464         memcpy(bp, &pgno, sizeof(pgno));
465         bp += sizeof(pgno);
466         memcpy(bp, &prev_pgno, sizeof(prev_pgno));
467         bp += sizeof(prev_pgno);
468         memcpy(bp, &next_pgno, sizeof(next_pgno));
469         bp += sizeof(next_pgno);
470         if (dbt == NULL) {
471                 zero = 0;
472                 memcpy(bp, &zero, sizeof(u_int32_t));
473                 bp += sizeof(u_int32_t);
474         } else {
475                 memcpy(bp, &dbt->size, sizeof(dbt->size));
476                 bp += sizeof(dbt->size);
477                 memcpy(bp, dbt->data, dbt->size);
478                 bp += dbt->size;
479         }
480         if (pagelsn != NULL)
481                 memcpy(bp, pagelsn, sizeof(*pagelsn));
482         else
483                 memset(bp, 0, sizeof(*pagelsn));
484         bp += sizeof(*pagelsn);
485         if (prevlsn != NULL)
486                 memcpy(bp, prevlsn, sizeof(*prevlsn));
487         else
488                 memset(bp, 0, sizeof(*prevlsn));
489         bp += sizeof(*prevlsn);
490         if (nextlsn != NULL)
491                 memcpy(bp, nextlsn, sizeof(*nextlsn));
492         else
493                 memset(bp, 0, sizeof(*nextlsn));
494         bp += sizeof(*nextlsn);
495 #ifdef DEBUG
496         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
497                 fprintf(stderr, "Error in log record length");
498 #endif
499         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
500         if (txnid != NULL)
501                 txnid->last_lsn = *ret_lsnp;
502         free(logrec.data);
503         return (ret);
504 }
505
506 /*
507  * PUBLIC: int __db_big_print
508  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
509  */
510
511 int
512 __db_big_print(notused1, dbtp, lsnp, notused3, notused4)
513         DB_LOG *notused1;
514         DBT *dbtp;
515         DB_LSN *lsnp;
516         int notused3;
517         void *notused4;
518 {
519         __db_big_args *argp;
520         u_int32_t i;
521         int c, ret;
522
523         i = 0;
524         c = 0;
525         notused1 = NULL;
526         notused3 = 0;
527         notused4 = NULL;
528
529         if ((ret = __db_big_read(dbtp->data, &argp)) != 0)
530                 return (ret);
531         printf("[%lu][%lu]db_big: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
532             (u_long)lsnp->file,
533             (u_long)lsnp->offset,
534             (u_long)argp->type,
535             (u_long)argp->txnid->txnid,
536             (u_long)argp->prev_lsn.file,
537             (u_long)argp->prev_lsn.offset);
538         printf("\topcode: %lu\n", (u_long)argp->opcode);
539         printf("\tfileid: %lu\n", (u_long)argp->fileid);
540         printf("\tpgno: %lu\n", (u_long)argp->pgno);
541         printf("\tprev_pgno: %lu\n", (u_long)argp->prev_pgno);
542         printf("\tnext_pgno: %lu\n", (u_long)argp->next_pgno);
543         printf("\tdbt: ");
544         for (i = 0; i < argp->dbt.size; i++) {
545                 c = ((char *)argp->dbt.data)[i];
546                 if (isprint(c) || c == 0xa)
547                         putchar(c);
548                 else
549                         printf("%#x ", c);
550         }
551         printf("\n");
552         printf("\tpagelsn: [%lu][%lu]\n",
553             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
554         printf("\tprevlsn: [%lu][%lu]\n",
555             (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
556         printf("\tnextlsn: [%lu][%lu]\n",
557             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
558         printf("\n");
559         free(argp);
560         return (0);
561 }
562
563 /*
564  * PUBLIC: int __db_big_read __P((void *, __db_big_args **));
565  */
566 int
567 __db_big_read(recbuf, argpp)
568         void *recbuf;
569         __db_big_args **argpp;
570 {
571         __db_big_args *argp;
572         u_int8_t *bp;
573
574         argp = (__db_big_args *)malloc(sizeof(__db_big_args) +
575             sizeof(DB_TXN));
576         if (argp == NULL)
577                 return (ENOMEM);
578         argp->txnid = (DB_TXN *)&argp[1];
579         bp = recbuf;
580         memcpy(&argp->type, bp, sizeof(argp->type));
581         bp += sizeof(argp->type);
582         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
583         bp += sizeof(argp->txnid->txnid);
584         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
585         bp += sizeof(DB_LSN);
586         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
587         bp += sizeof(argp->opcode);
588         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
589         bp += sizeof(argp->fileid);
590         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
591         bp += sizeof(argp->pgno);
592         memcpy(&argp->prev_pgno, bp, sizeof(argp->prev_pgno));
593         bp += sizeof(argp->prev_pgno);
594         memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
595         bp += sizeof(argp->next_pgno);
596         memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
597         bp += sizeof(u_int32_t);
598         argp->dbt.data = bp;
599         bp += argp->dbt.size;
600         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
601         bp += sizeof(argp->pagelsn);
602         memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
603         bp += sizeof(argp->prevlsn);
604         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
605         bp += sizeof(argp->nextlsn);
606         *argpp = argp;
607         return (0);
608 }
609
610 /*
611  * PUBLIC: int __db_ovref_log
612  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
613  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *));
614  */
615 int __db_ovref_log(logp, txnid, ret_lsnp, flags,
616         fileid, pgno, lsn)
617         DB_LOG *logp;
618         DB_TXN *txnid;
619         DB_LSN *ret_lsnp;
620         u_int32_t flags;
621         u_int32_t fileid;
622         db_pgno_t pgno;
623         DB_LSN * lsn;
624 {
625         DBT logrec;
626         DB_LSN *lsnp, null_lsn;
627         u_int32_t rectype, txn_num;
628         int ret;
629         u_int8_t *bp;
630
631         rectype = DB_db_ovref;
632         txn_num = txnid == NULL ? 0 : txnid->txnid;
633         if (txnid == NULL) {
634                 null_lsn.file = 0;
635                 null_lsn.offset = 0;
636                 lsnp = &null_lsn;
637         } else
638                 lsnp = &txnid->last_lsn;
639         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
640             + sizeof(fileid)
641             + sizeof(pgno)
642             + sizeof(*lsn);
643         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
644                 return (ENOMEM);
645
646         bp = logrec.data;
647         memcpy(bp, &rectype, sizeof(rectype));
648         bp += sizeof(rectype);
649         memcpy(bp, &txn_num, sizeof(txn_num));
650         bp += sizeof(txn_num);
651         memcpy(bp, lsnp, sizeof(DB_LSN));
652         bp += sizeof(DB_LSN);
653         memcpy(bp, &fileid, sizeof(fileid));
654         bp += sizeof(fileid);
655         memcpy(bp, &pgno, sizeof(pgno));
656         bp += sizeof(pgno);
657         if (lsn != NULL)
658                 memcpy(bp, lsn, sizeof(*lsn));
659         else
660                 memset(bp, 0, sizeof(*lsn));
661         bp += sizeof(*lsn);
662 #ifdef DEBUG
663         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
664                 fprintf(stderr, "Error in log record length");
665 #endif
666         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
667         if (txnid != NULL)
668                 txnid->last_lsn = *ret_lsnp;
669         free(logrec.data);
670         return (ret);
671 }
672
673 /*
674  * PUBLIC: int __db_ovref_print
675  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
676  */
677
678 int
679 __db_ovref_print(notused1, dbtp, lsnp, notused3, notused4)
680         DB_LOG *notused1;
681         DBT *dbtp;
682         DB_LSN *lsnp;
683         int notused3;
684         void *notused4;
685 {
686         __db_ovref_args *argp;
687         u_int32_t i;
688         int c, ret;
689
690         i = 0;
691         c = 0;
692         notused1 = NULL;
693         notused3 = 0;
694         notused4 = NULL;
695
696         if ((ret = __db_ovref_read(dbtp->data, &argp)) != 0)
697                 return (ret);
698         printf("[%lu][%lu]db_ovref: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
699             (u_long)lsnp->file,
700             (u_long)lsnp->offset,
701             (u_long)argp->type,
702             (u_long)argp->txnid->txnid,
703             (u_long)argp->prev_lsn.file,
704             (u_long)argp->prev_lsn.offset);
705         printf("\tfileid: %lu\n", (u_long)argp->fileid);
706         printf("\tpgno: %lu\n", (u_long)argp->pgno);
707         printf("\tlsn: [%lu][%lu]\n",
708             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
709         printf("\n");
710         free(argp);
711         return (0);
712 }
713
714 /*
715  * PUBLIC: int __db_ovref_read __P((void *, __db_ovref_args **));
716  */
717 int
718 __db_ovref_read(recbuf, argpp)
719         void *recbuf;
720         __db_ovref_args **argpp;
721 {
722         __db_ovref_args *argp;
723         u_int8_t *bp;
724
725         argp = (__db_ovref_args *)malloc(sizeof(__db_ovref_args) +
726             sizeof(DB_TXN));
727         if (argp == NULL)
728                 return (ENOMEM);
729         argp->txnid = (DB_TXN *)&argp[1];
730         bp = recbuf;
731         memcpy(&argp->type, bp, sizeof(argp->type));
732         bp += sizeof(argp->type);
733         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
734         bp += sizeof(argp->txnid->txnid);
735         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
736         bp += sizeof(DB_LSN);
737         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
738         bp += sizeof(argp->fileid);
739         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
740         bp += sizeof(argp->pgno);
741         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
742         bp += sizeof(argp->lsn);
743         *argpp = argp;
744         return (0);
745 }
746
747 /*
748  * PUBLIC: int __db_relink_log
749  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
750  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
751  * PUBLIC:     DB_LSN *, db_pgno_t, DB_LSN *));
752  */
753 int __db_relink_log(logp, txnid, ret_lsnp, flags,
754         fileid, pgno, lsn, prev, lsn_prev, next,
755         lsn_next)
756         DB_LOG *logp;
757         DB_TXN *txnid;
758         DB_LSN *ret_lsnp;
759         u_int32_t flags;
760         u_int32_t fileid;
761         db_pgno_t pgno;
762         DB_LSN * lsn;
763         db_pgno_t prev;
764         DB_LSN * lsn_prev;
765         db_pgno_t next;
766         DB_LSN * lsn_next;
767 {
768         DBT logrec;
769         DB_LSN *lsnp, null_lsn;
770         u_int32_t rectype, txn_num;
771         int ret;
772         u_int8_t *bp;
773
774         rectype = DB_db_relink;
775         txn_num = txnid == NULL ? 0 : txnid->txnid;
776         if (txnid == NULL) {
777                 null_lsn.file = 0;
778                 null_lsn.offset = 0;
779                 lsnp = &null_lsn;
780         } else
781                 lsnp = &txnid->last_lsn;
782         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
783             + sizeof(fileid)
784             + sizeof(pgno)
785             + sizeof(*lsn)
786             + sizeof(prev)
787             + sizeof(*lsn_prev)
788             + sizeof(next)
789             + sizeof(*lsn_next);
790         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
791                 return (ENOMEM);
792
793         bp = logrec.data;
794         memcpy(bp, &rectype, sizeof(rectype));
795         bp += sizeof(rectype);
796         memcpy(bp, &txn_num, sizeof(txn_num));
797         bp += sizeof(txn_num);
798         memcpy(bp, lsnp, sizeof(DB_LSN));
799         bp += sizeof(DB_LSN);
800         memcpy(bp, &fileid, sizeof(fileid));
801         bp += sizeof(fileid);
802         memcpy(bp, &pgno, sizeof(pgno));
803         bp += sizeof(pgno);
804         if (lsn != NULL)
805                 memcpy(bp, lsn, sizeof(*lsn));
806         else
807                 memset(bp, 0, sizeof(*lsn));
808         bp += sizeof(*lsn);
809         memcpy(bp, &prev, sizeof(prev));
810         bp += sizeof(prev);
811         if (lsn_prev != NULL)
812                 memcpy(bp, lsn_prev, sizeof(*lsn_prev));
813         else
814                 memset(bp, 0, sizeof(*lsn_prev));
815         bp += sizeof(*lsn_prev);
816         memcpy(bp, &next, sizeof(next));
817         bp += sizeof(next);
818         if (lsn_next != NULL)
819                 memcpy(bp, lsn_next, sizeof(*lsn_next));
820         else
821                 memset(bp, 0, sizeof(*lsn_next));
822         bp += sizeof(*lsn_next);
823 #ifdef DEBUG
824         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
825                 fprintf(stderr, "Error in log record length");
826 #endif
827         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
828         if (txnid != NULL)
829                 txnid->last_lsn = *ret_lsnp;
830         free(logrec.data);
831         return (ret);
832 }
833
834 /*
835  * PUBLIC: int __db_relink_print
836  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
837  */
838
839 int
840 __db_relink_print(notused1, dbtp, lsnp, notused3, notused4)
841         DB_LOG *notused1;
842         DBT *dbtp;
843         DB_LSN *lsnp;
844         int notused3;
845         void *notused4;
846 {
847         __db_relink_args *argp;
848         u_int32_t i;
849         int c, ret;
850
851         i = 0;
852         c = 0;
853         notused1 = NULL;
854         notused3 = 0;
855         notused4 = NULL;
856
857         if ((ret = __db_relink_read(dbtp->data, &argp)) != 0)
858                 return (ret);
859         printf("[%lu][%lu]db_relink: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
860             (u_long)lsnp->file,
861             (u_long)lsnp->offset,
862             (u_long)argp->type,
863             (u_long)argp->txnid->txnid,
864             (u_long)argp->prev_lsn.file,
865             (u_long)argp->prev_lsn.offset);
866         printf("\tfileid: %lu\n", (u_long)argp->fileid);
867         printf("\tpgno: %lu\n", (u_long)argp->pgno);
868         printf("\tlsn: [%lu][%lu]\n",
869             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
870         printf("\tprev: %lu\n", (u_long)argp->prev);
871         printf("\tlsn_prev: [%lu][%lu]\n",
872             (u_long)argp->lsn_prev.file, (u_long)argp->lsn_prev.offset);
873         printf("\tnext: %lu\n", (u_long)argp->next);
874         printf("\tlsn_next: [%lu][%lu]\n",
875             (u_long)argp->lsn_next.file, (u_long)argp->lsn_next.offset);
876         printf("\n");
877         free(argp);
878         return (0);
879 }
880
881 /*
882  * PUBLIC: int __db_relink_read __P((void *, __db_relink_args **));
883  */
884 int
885 __db_relink_read(recbuf, argpp)
886         void *recbuf;
887         __db_relink_args **argpp;
888 {
889         __db_relink_args *argp;
890         u_int8_t *bp;
891
892         argp = (__db_relink_args *)malloc(sizeof(__db_relink_args) +
893             sizeof(DB_TXN));
894         if (argp == NULL)
895                 return (ENOMEM);
896         argp->txnid = (DB_TXN *)&argp[1];
897         bp = recbuf;
898         memcpy(&argp->type, bp, sizeof(argp->type));
899         bp += sizeof(argp->type);
900         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
901         bp += sizeof(argp->txnid->txnid);
902         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
903         bp += sizeof(DB_LSN);
904         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
905         bp += sizeof(argp->fileid);
906         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
907         bp += sizeof(argp->pgno);
908         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
909         bp += sizeof(argp->lsn);
910         memcpy(&argp->prev, bp, sizeof(argp->prev));
911         bp += sizeof(argp->prev);
912         memcpy(&argp->lsn_prev, bp,  sizeof(argp->lsn_prev));
913         bp += sizeof(argp->lsn_prev);
914         memcpy(&argp->next, bp, sizeof(argp->next));
915         bp += sizeof(argp->next);
916         memcpy(&argp->lsn_next, bp,  sizeof(argp->lsn_next));
917         bp += sizeof(argp->lsn_next);
918         *argpp = argp;
919         return (0);
920 }
921
922 /*
923  * PUBLIC: int __db_addpage_log
924  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
925  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
926  * PUBLIC:     DB_LSN *));
927  */
928 int __db_addpage_log(logp, txnid, ret_lsnp, flags,
929         fileid, pgno, lsn, nextpgno, nextlsn)
930         DB_LOG *logp;
931         DB_TXN *txnid;
932         DB_LSN *ret_lsnp;
933         u_int32_t flags;
934         u_int32_t fileid;
935         db_pgno_t pgno;
936         DB_LSN * lsn;
937         db_pgno_t nextpgno;
938         DB_LSN * nextlsn;
939 {
940         DBT logrec;
941         DB_LSN *lsnp, null_lsn;
942         u_int32_t rectype, txn_num;
943         int ret;
944         u_int8_t *bp;
945
946         rectype = DB_db_addpage;
947         txn_num = txnid == NULL ? 0 : txnid->txnid;
948         if (txnid == NULL) {
949                 null_lsn.file = 0;
950                 null_lsn.offset = 0;
951                 lsnp = &null_lsn;
952         } else
953                 lsnp = &txnid->last_lsn;
954         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
955             + sizeof(fileid)
956             + sizeof(pgno)
957             + sizeof(*lsn)
958             + sizeof(nextpgno)
959             + sizeof(*nextlsn);
960         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
961                 return (ENOMEM);
962
963         bp = logrec.data;
964         memcpy(bp, &rectype, sizeof(rectype));
965         bp += sizeof(rectype);
966         memcpy(bp, &txn_num, sizeof(txn_num));
967         bp += sizeof(txn_num);
968         memcpy(bp, lsnp, sizeof(DB_LSN));
969         bp += sizeof(DB_LSN);
970         memcpy(bp, &fileid, sizeof(fileid));
971         bp += sizeof(fileid);
972         memcpy(bp, &pgno, sizeof(pgno));
973         bp += sizeof(pgno);
974         if (lsn != NULL)
975                 memcpy(bp, lsn, sizeof(*lsn));
976         else
977                 memset(bp, 0, sizeof(*lsn));
978         bp += sizeof(*lsn);
979         memcpy(bp, &nextpgno, sizeof(nextpgno));
980         bp += sizeof(nextpgno);
981         if (nextlsn != NULL)
982                 memcpy(bp, nextlsn, sizeof(*nextlsn));
983         else
984                 memset(bp, 0, sizeof(*nextlsn));
985         bp += sizeof(*nextlsn);
986 #ifdef DEBUG
987         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
988                 fprintf(stderr, "Error in log record length");
989 #endif
990         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
991         if (txnid != NULL)
992                 txnid->last_lsn = *ret_lsnp;
993         free(logrec.data);
994         return (ret);
995 }
996
997 /*
998  * PUBLIC: int __db_addpage_print
999  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1000  */
1001
1002 int
1003 __db_addpage_print(notused1, dbtp, lsnp, notused3, notused4)
1004         DB_LOG *notused1;
1005         DBT *dbtp;
1006         DB_LSN *lsnp;
1007         int notused3;
1008         void *notused4;
1009 {
1010         __db_addpage_args *argp;
1011         u_int32_t i;
1012         int c, ret;
1013
1014         i = 0;
1015         c = 0;
1016         notused1 = NULL;
1017         notused3 = 0;
1018         notused4 = NULL;
1019
1020         if ((ret = __db_addpage_read(dbtp->data, &argp)) != 0)
1021                 return (ret);
1022         printf("[%lu][%lu]db_addpage: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1023             (u_long)lsnp->file,
1024             (u_long)lsnp->offset,
1025             (u_long)argp->type,
1026             (u_long)argp->txnid->txnid,
1027             (u_long)argp->prev_lsn.file,
1028             (u_long)argp->prev_lsn.offset);
1029         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1030         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1031         printf("\tlsn: [%lu][%lu]\n",
1032             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1033         printf("\tnextpgno: %lu\n", (u_long)argp->nextpgno);
1034         printf("\tnextlsn: [%lu][%lu]\n",
1035             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
1036         printf("\n");
1037         free(argp);
1038         return (0);
1039 }
1040
1041 /*
1042  * PUBLIC: int __db_addpage_read __P((void *, __db_addpage_args **));
1043  */
1044 int
1045 __db_addpage_read(recbuf, argpp)
1046         void *recbuf;
1047         __db_addpage_args **argpp;
1048 {
1049         __db_addpage_args *argp;
1050         u_int8_t *bp;
1051
1052         argp = (__db_addpage_args *)malloc(sizeof(__db_addpage_args) +
1053             sizeof(DB_TXN));
1054         if (argp == NULL)
1055                 return (ENOMEM);
1056         argp->txnid = (DB_TXN *)&argp[1];
1057         bp = recbuf;
1058         memcpy(&argp->type, bp, sizeof(argp->type));
1059         bp += sizeof(argp->type);
1060         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1061         bp += sizeof(argp->txnid->txnid);
1062         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1063         bp += sizeof(DB_LSN);
1064         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1065         bp += sizeof(argp->fileid);
1066         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1067         bp += sizeof(argp->pgno);
1068         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1069         bp += sizeof(argp->lsn);
1070         memcpy(&argp->nextpgno, bp, sizeof(argp->nextpgno));
1071         bp += sizeof(argp->nextpgno);
1072         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
1073         bp += sizeof(argp->nextlsn);
1074         *argpp = argp;
1075         return (0);
1076 }
1077
1078 /*
1079  * PUBLIC: int __db_debug_log
1080  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1081  * PUBLIC:     DBT *, u_int32_t, DBT *, DBT *,
1082  * PUBLIC:     u_int32_t));
1083  */
1084 int __db_debug_log(logp, txnid, ret_lsnp, flags,
1085         op, fileid, key, data, arg_flags)
1086         DB_LOG *logp;
1087         DB_TXN *txnid;
1088         DB_LSN *ret_lsnp;
1089         u_int32_t flags;
1090         DBT *op;
1091         u_int32_t fileid;
1092         DBT *key;
1093         DBT *data;
1094         u_int32_t arg_flags;
1095 {
1096         DBT logrec;
1097         DB_LSN *lsnp, null_lsn;
1098         u_int32_t zero;
1099         u_int32_t rectype, txn_num;
1100         int ret;
1101         u_int8_t *bp;
1102
1103         rectype = DB_db_debug;
1104         txn_num = txnid == NULL ? 0 : txnid->txnid;
1105         if (txnid == NULL) {
1106                 null_lsn.file = 0;
1107                 null_lsn.offset = 0;
1108                 lsnp = &null_lsn;
1109         } else
1110                 lsnp = &txnid->last_lsn;
1111         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1112             + sizeof(u_int32_t) + (op == NULL ? 0 : op->size)
1113             + sizeof(fileid)
1114             + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
1115             + sizeof(u_int32_t) + (data == NULL ? 0 : data->size)
1116             + sizeof(arg_flags);
1117         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
1118                 return (ENOMEM);
1119
1120         bp = logrec.data;
1121         memcpy(bp, &rectype, sizeof(rectype));
1122         bp += sizeof(rectype);
1123         memcpy(bp, &txn_num, sizeof(txn_num));
1124         bp += sizeof(txn_num);
1125         memcpy(bp, lsnp, sizeof(DB_LSN));
1126         bp += sizeof(DB_LSN);
1127         if (op == NULL) {
1128                 zero = 0;
1129                 memcpy(bp, &zero, sizeof(u_int32_t));
1130                 bp += sizeof(u_int32_t);
1131         } else {
1132                 memcpy(bp, &op->size, sizeof(op->size));
1133                 bp += sizeof(op->size);
1134                 memcpy(bp, op->data, op->size);
1135                 bp += op->size;
1136         }
1137         memcpy(bp, &fileid, sizeof(fileid));
1138         bp += sizeof(fileid);
1139         if (key == NULL) {
1140                 zero = 0;
1141                 memcpy(bp, &zero, sizeof(u_int32_t));
1142                 bp += sizeof(u_int32_t);
1143         } else {
1144                 memcpy(bp, &key->size, sizeof(key->size));
1145                 bp += sizeof(key->size);
1146                 memcpy(bp, key->data, key->size);
1147                 bp += key->size;
1148         }
1149         if (data == NULL) {
1150                 zero = 0;
1151                 memcpy(bp, &zero, sizeof(u_int32_t));
1152                 bp += sizeof(u_int32_t);
1153         } else {
1154                 memcpy(bp, &data->size, sizeof(data->size));
1155                 bp += sizeof(data->size);
1156                 memcpy(bp, data->data, data->size);
1157                 bp += data->size;
1158         }
1159         memcpy(bp, &arg_flags, sizeof(arg_flags));
1160         bp += sizeof(arg_flags);
1161 #ifdef DEBUG
1162         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1163                 fprintf(stderr, "Error in log record length");
1164 #endif
1165         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1166         if (txnid != NULL)
1167                 txnid->last_lsn = *ret_lsnp;
1168         free(logrec.data);
1169         return (ret);
1170 }
1171
1172 /*
1173  * PUBLIC: int __db_debug_print
1174  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1175  */
1176
1177 int
1178 __db_debug_print(notused1, dbtp, lsnp, notused3, notused4)
1179         DB_LOG *notused1;
1180         DBT *dbtp;
1181         DB_LSN *lsnp;
1182         int notused3;
1183         void *notused4;
1184 {
1185         __db_debug_args *argp;
1186         u_int32_t i;
1187         int c, ret;
1188
1189         i = 0;
1190         c = 0;
1191         notused1 = NULL;
1192         notused3 = 0;
1193         notused4 = NULL;
1194
1195         if ((ret = __db_debug_read(dbtp->data, &argp)) != 0)
1196                 return (ret);
1197         printf("[%lu][%lu]db_debug: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1198             (u_long)lsnp->file,
1199             (u_long)lsnp->offset,
1200             (u_long)argp->type,
1201             (u_long)argp->txnid->txnid,
1202             (u_long)argp->prev_lsn.file,
1203             (u_long)argp->prev_lsn.offset);
1204         printf("\top: ");
1205         for (i = 0; i < argp->op.size; i++) {
1206                 c = ((char *)argp->op.data)[i];
1207                 if (isprint(c) || c == 0xa)
1208                         putchar(c);
1209                 else
1210                         printf("%#x ", c);
1211         }
1212         printf("\n");
1213         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1214         printf("\tkey: ");
1215         for (i = 0; i < argp->key.size; i++) {
1216                 c = ((char *)argp->key.data)[i];
1217                 if (isprint(c) || c == 0xa)
1218                         putchar(c);
1219                 else
1220                         printf("%#x ", c);
1221         }
1222         printf("\n");
1223         printf("\tdata: ");
1224         for (i = 0; i < argp->data.size; i++) {
1225                 c = ((char *)argp->data.data)[i];
1226                 if (isprint(c) || c == 0xa)
1227                         putchar(c);
1228                 else
1229                         printf("%#x ", c);
1230         }
1231         printf("\n");
1232         printf("\targ_flags: %lu\n", (u_long)argp->arg_flags);
1233         printf("\n");
1234         free(argp);
1235         return (0);
1236 }
1237
1238 /*
1239  * PUBLIC: int __db_debug_read __P((void *, __db_debug_args **));
1240  */
1241 int
1242 __db_debug_read(recbuf, argpp)
1243         void *recbuf;
1244         __db_debug_args **argpp;
1245 {
1246         __db_debug_args *argp;
1247         u_int8_t *bp;
1248
1249         argp = (__db_debug_args *)malloc(sizeof(__db_debug_args) +
1250             sizeof(DB_TXN));
1251         if (argp == NULL)
1252                 return (ENOMEM);
1253         argp->txnid = (DB_TXN *)&argp[1];
1254         bp = recbuf;
1255         memcpy(&argp->type, bp, sizeof(argp->type));
1256         bp += sizeof(argp->type);
1257         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1258         bp += sizeof(argp->txnid->txnid);
1259         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1260         bp += sizeof(DB_LSN);
1261         memcpy(&argp->op.size, bp, sizeof(u_int32_t));
1262         bp += sizeof(u_int32_t);
1263         argp->op.data = bp;
1264         bp += argp->op.size;
1265         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1266         bp += sizeof(argp->fileid);
1267         memcpy(&argp->key.size, bp, sizeof(u_int32_t));
1268         bp += sizeof(u_int32_t);
1269         argp->key.data = bp;
1270         bp += argp->key.size;
1271         memcpy(&argp->data.size, bp, sizeof(u_int32_t));
1272         bp += sizeof(u_int32_t);
1273         argp->data.data = bp;
1274         bp += argp->data.size;
1275         memcpy(&argp->arg_flags, bp, sizeof(argp->arg_flags));
1276         bp += sizeof(argp->arg_flags);
1277         *argpp = argp;
1278         return (0);
1279 }
1280
1281 /*
1282  * PUBLIC: int __db_noop_log
1283  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t));
1284  */
1285 int __db_noop_log(logp, txnid, ret_lsnp, flags)
1286         DB_LOG *logp;
1287         DB_TXN *txnid;
1288         DB_LSN *ret_lsnp;
1289         u_int32_t flags;
1290 {
1291         DBT logrec;
1292         DB_LSN *lsnp, null_lsn;
1293         u_int32_t rectype, txn_num;
1294         int ret;
1295         u_int8_t *bp;
1296
1297         rectype = DB_db_noop;
1298         txn_num = txnid == NULL ? 0 : txnid->txnid;
1299         if (txnid == NULL) {
1300                 null_lsn.file = 0;
1301                 null_lsn.offset = 0;
1302                 lsnp = &null_lsn;
1303         } else
1304                 lsnp = &txnid->last_lsn;
1305         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN);
1306         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
1307                 return (ENOMEM);
1308
1309         bp = logrec.data;
1310         memcpy(bp, &rectype, sizeof(rectype));
1311         bp += sizeof(rectype);
1312         memcpy(bp, &txn_num, sizeof(txn_num));
1313         bp += sizeof(txn_num);
1314         memcpy(bp, lsnp, sizeof(DB_LSN));
1315         bp += sizeof(DB_LSN);
1316 #ifdef DEBUG
1317         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1318                 fprintf(stderr, "Error in log record length");
1319 #endif
1320         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1321         if (txnid != NULL)
1322                 txnid->last_lsn = *ret_lsnp;
1323         free(logrec.data);
1324         return (ret);
1325 }
1326
1327 /*
1328  * PUBLIC: int __db_noop_print
1329  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1330  */
1331
1332 int
1333 __db_noop_print(notused1, dbtp, lsnp, notused3, notused4)
1334         DB_LOG *notused1;
1335         DBT *dbtp;
1336         DB_LSN *lsnp;
1337         int notused3;
1338         void *notused4;
1339 {
1340         __db_noop_args *argp;
1341         u_int32_t i;
1342         int c, ret;
1343
1344         i = 0;
1345         c = 0;
1346         notused1 = NULL;
1347         notused3 = 0;
1348         notused4 = NULL;
1349
1350         if ((ret = __db_noop_read(dbtp->data, &argp)) != 0)
1351                 return (ret);
1352         printf("[%lu][%lu]db_noop: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1353             (u_long)lsnp->file,
1354             (u_long)lsnp->offset,
1355             (u_long)argp->type,
1356             (u_long)argp->txnid->txnid,
1357             (u_long)argp->prev_lsn.file,
1358             (u_long)argp->prev_lsn.offset);
1359         printf("\n");
1360         free(argp);
1361         return (0);
1362 }
1363
1364 /*
1365  * PUBLIC: int __db_noop_read __P((void *, __db_noop_args **));
1366  */
1367 int
1368 __db_noop_read(recbuf, argpp)
1369         void *recbuf;
1370         __db_noop_args **argpp;
1371 {
1372         __db_noop_args *argp;
1373         u_int8_t *bp;
1374
1375         argp = (__db_noop_args *)malloc(sizeof(__db_noop_args) +
1376             sizeof(DB_TXN));
1377         if (argp == NULL)
1378                 return (ENOMEM);
1379         argp->txnid = (DB_TXN *)&argp[1];
1380         bp = recbuf;
1381         memcpy(&argp->type, bp, sizeof(argp->type));
1382         bp += sizeof(argp->type);
1383         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1384         bp += sizeof(argp->txnid->txnid);
1385         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1386         bp += sizeof(DB_LSN);
1387         *argpp = argp;
1388         return (0);
1389 }
1390
1391 /*
1392  * PUBLIC: int __db_init_print __P((DB_ENV *));
1393  */
1394 int
1395 __db_init_print(dbenv)
1396         DB_ENV *dbenv;
1397 {
1398         int ret;
1399
1400         if ((ret = __db_add_recovery(dbenv,
1401             __db_addrem_print, DB_db_addrem)) != 0)
1402                 return (ret);
1403         if ((ret = __db_add_recovery(dbenv,
1404             __db_split_print, DB_db_split)) != 0)
1405                 return (ret);
1406         if ((ret = __db_add_recovery(dbenv,
1407             __db_big_print, DB_db_big)) != 0)
1408                 return (ret);
1409         if ((ret = __db_add_recovery(dbenv,
1410             __db_ovref_print, DB_db_ovref)) != 0)
1411                 return (ret);
1412         if ((ret = __db_add_recovery(dbenv,
1413             __db_relink_print, DB_db_relink)) != 0)
1414                 return (ret);
1415         if ((ret = __db_add_recovery(dbenv,
1416             __db_addpage_print, DB_db_addpage)) != 0)
1417                 return (ret);
1418         if ((ret = __db_add_recovery(dbenv,
1419             __db_debug_print, DB_db_debug)) != 0)
1420                 return (ret);
1421         if ((ret = __db_add_recovery(dbenv,
1422             __db_noop_print, DB_db_noop)) != 0)
1423                 return (ret);
1424         return (0);
1425 }
1426
1427 /*
1428  * PUBLIC: int __db_init_recover __P((DB_ENV *));
1429  */
1430 int
1431 __db_init_recover(dbenv)
1432         DB_ENV *dbenv;
1433 {
1434         int ret;
1435
1436         if ((ret = __db_add_recovery(dbenv,
1437             __db_addrem_recover, DB_db_addrem)) != 0)
1438                 return (ret);
1439         if ((ret = __db_add_recovery(dbenv,
1440             __db_split_recover, DB_db_split)) != 0)
1441                 return (ret);
1442         if ((ret = __db_add_recovery(dbenv,
1443             __db_big_recover, DB_db_big)) != 0)
1444                 return (ret);
1445         if ((ret = __db_add_recovery(dbenv,
1446             __db_ovref_recover, DB_db_ovref)) != 0)
1447                 return (ret);
1448         if ((ret = __db_add_recovery(dbenv,
1449             __db_relink_recover, DB_db_relink)) != 0)
1450                 return (ret);
1451         if ((ret = __db_add_recovery(dbenv,
1452             __db_addpage_recover, DB_db_addpage)) != 0)
1453                 return (ret);
1454         if ((ret = __db_add_recovery(dbenv,
1455             __db_debug_recover, DB_db_debug)) != 0)
1456                 return (ret);
1457         if ((ret = __db_add_recovery(dbenv,
1458             __db_noop_recover, DB_db_noop)) != 0)
1459                 return (ret);
1460         return (0);
1461 }
1462