Update to db 2.3.10.
[kopensolaris-gnu/glibc.git] / db2 / btree / btree_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 "btree.h"
17 #include "db_am.h"
18 #include "common_ext.h"
19
20 /*
21  * PUBLIC: int __bam_pg_alloc_log
22  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
23  * PUBLIC:     u_int32_t, DB_LSN *, DB_LSN *, db_pgno_t,
24  * PUBLIC:     u_int32_t, db_pgno_t));
25  */
26 int __bam_pg_alloc_log(logp, txnid, ret_lsnp, flags,
27         fileid, meta_lsn, page_lsn, pgno, ptype, next)
28         DB_LOG *logp;
29         DB_TXN *txnid;
30         DB_LSN *ret_lsnp;
31         u_int32_t flags;
32         u_int32_t fileid;
33         DB_LSN * meta_lsn;
34         DB_LSN * page_lsn;
35         db_pgno_t pgno;
36         u_int32_t ptype;
37         db_pgno_t next;
38 {
39         DBT logrec;
40         DB_LSN *lsnp, null_lsn;
41         u_int32_t rectype, txn_num;
42         int ret;
43         u_int8_t *bp;
44
45         rectype = DB_bam_pg_alloc;
46         txn_num = txnid == NULL ? 0 : txnid->txnid;
47         if (txnid == NULL) {
48                 null_lsn.file = 0;
49                 null_lsn.offset = 0;
50                 lsnp = &null_lsn;
51         } else
52                 lsnp = &txnid->last_lsn;
53         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
54             + sizeof(fileid)
55             + sizeof(*meta_lsn)
56             + sizeof(*page_lsn)
57             + sizeof(pgno)
58             + sizeof(ptype)
59             + sizeof(next);
60         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
61                 return (ENOMEM);
62
63         bp = logrec.data;
64         memcpy(bp, &rectype, sizeof(rectype));
65         bp += sizeof(rectype);
66         memcpy(bp, &txn_num, sizeof(txn_num));
67         bp += sizeof(txn_num);
68         memcpy(bp, lsnp, sizeof(DB_LSN));
69         bp += sizeof(DB_LSN);
70         memcpy(bp, &fileid, sizeof(fileid));
71         bp += sizeof(fileid);
72         if (meta_lsn != NULL)
73                 memcpy(bp, meta_lsn, sizeof(*meta_lsn));
74         else
75                 memset(bp, 0, sizeof(*meta_lsn));
76         bp += sizeof(*meta_lsn);
77         if (page_lsn != NULL)
78                 memcpy(bp, page_lsn, sizeof(*page_lsn));
79         else
80                 memset(bp, 0, sizeof(*page_lsn));
81         bp += sizeof(*page_lsn);
82         memcpy(bp, &pgno, sizeof(pgno));
83         bp += sizeof(pgno);
84         memcpy(bp, &ptype, sizeof(ptype));
85         bp += sizeof(ptype);
86         memcpy(bp, &next, sizeof(next));
87         bp += sizeof(next);
88 #ifdef DEBUG
89         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
90                 fprintf(stderr, "Error in log record length");
91 #endif
92         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
93         if (txnid != NULL)
94                 txnid->last_lsn = *ret_lsnp;
95         free(logrec.data);
96         return (ret);
97 }
98
99 /*
100  * PUBLIC: int __bam_pg_alloc_print
101  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
102  */
103
104 int
105 __bam_pg_alloc_print(notused1, dbtp, lsnp, notused3, notused4)
106         DB_LOG *notused1;
107         DBT *dbtp;
108         DB_LSN *lsnp;
109         int notused3;
110         void *notused4;
111 {
112         __bam_pg_alloc_args *argp;
113         u_int32_t i;
114         int c, ret;
115
116         i = 0;
117         c = 0;
118         notused1 = NULL;
119         notused3 = 0;
120         notused4 = NULL;
121
122         if ((ret = __bam_pg_alloc_read(dbtp->data, &argp)) != 0)
123                 return (ret);
124         printf("[%lu][%lu]bam_pg_alloc: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
125             (u_long)lsnp->file,
126             (u_long)lsnp->offset,
127             (u_long)argp->type,
128             (u_long)argp->txnid->txnid,
129             (u_long)argp->prev_lsn.file,
130             (u_long)argp->prev_lsn.offset);
131         printf("\tfileid: %lu\n", (u_long)argp->fileid);
132         printf("\tmeta_lsn: [%lu][%lu]\n",
133             (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
134         printf("\tpage_lsn: [%lu][%lu]\n",
135             (u_long)argp->page_lsn.file, (u_long)argp->page_lsn.offset);
136         printf("\tpgno: %lu\n", (u_long)argp->pgno);
137         printf("\tptype: %lu\n", (u_long)argp->ptype);
138         printf("\tnext: %lu\n", (u_long)argp->next);
139         printf("\n");
140         free(argp);
141         return (0);
142 }
143
144 /*
145  * PUBLIC: int __bam_pg_alloc_read __P((void *, __bam_pg_alloc_args **));
146  */
147 int
148 __bam_pg_alloc_read(recbuf, argpp)
149         void *recbuf;
150         __bam_pg_alloc_args **argpp;
151 {
152         __bam_pg_alloc_args *argp;
153         u_int8_t *bp;
154
155         argp = (__bam_pg_alloc_args *)malloc(sizeof(__bam_pg_alloc_args) +
156             sizeof(DB_TXN));
157         if (argp == NULL)
158                 return (ENOMEM);
159         argp->txnid = (DB_TXN *)&argp[1];
160         bp = recbuf;
161         memcpy(&argp->type, bp, sizeof(argp->type));
162         bp += sizeof(argp->type);
163         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
164         bp += sizeof(argp->txnid->txnid);
165         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
166         bp += sizeof(DB_LSN);
167         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
168         bp += sizeof(argp->fileid);
169         memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
170         bp += sizeof(argp->meta_lsn);
171         memcpy(&argp->page_lsn, bp,  sizeof(argp->page_lsn));
172         bp += sizeof(argp->page_lsn);
173         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
174         bp += sizeof(argp->pgno);
175         memcpy(&argp->ptype, bp, sizeof(argp->ptype));
176         bp += sizeof(argp->ptype);
177         memcpy(&argp->next, bp, sizeof(argp->next));
178         bp += sizeof(argp->next);
179         *argpp = argp;
180         return (0);
181 }
182
183 /*
184  * PUBLIC: int __bam_pg_free_log
185  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
186  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, DBT *,
187  * PUBLIC:     db_pgno_t));
188  */
189 int __bam_pg_free_log(logp, txnid, ret_lsnp, flags,
190         fileid, pgno, meta_lsn, header, next)
191         DB_LOG *logp;
192         DB_TXN *txnid;
193         DB_LSN *ret_lsnp;
194         u_int32_t flags;
195         u_int32_t fileid;
196         db_pgno_t pgno;
197         DB_LSN * meta_lsn;
198         DBT *header;
199         db_pgno_t next;
200 {
201         DBT logrec;
202         DB_LSN *lsnp, null_lsn;
203         u_int32_t zero;
204         u_int32_t rectype, txn_num;
205         int ret;
206         u_int8_t *bp;
207
208         rectype = DB_bam_pg_free;
209         txn_num = txnid == NULL ? 0 : txnid->txnid;
210         if (txnid == NULL) {
211                 null_lsn.file = 0;
212                 null_lsn.offset = 0;
213                 lsnp = &null_lsn;
214         } else
215                 lsnp = &txnid->last_lsn;
216         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
217             + sizeof(fileid)
218             + sizeof(pgno)
219             + sizeof(*meta_lsn)
220             + sizeof(u_int32_t) + (header == NULL ? 0 : header->size)
221             + sizeof(next);
222         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
223                 return (ENOMEM);
224
225         bp = logrec.data;
226         memcpy(bp, &rectype, sizeof(rectype));
227         bp += sizeof(rectype);
228         memcpy(bp, &txn_num, sizeof(txn_num));
229         bp += sizeof(txn_num);
230         memcpy(bp, lsnp, sizeof(DB_LSN));
231         bp += sizeof(DB_LSN);
232         memcpy(bp, &fileid, sizeof(fileid));
233         bp += sizeof(fileid);
234         memcpy(bp, &pgno, sizeof(pgno));
235         bp += sizeof(pgno);
236         if (meta_lsn != NULL)
237                 memcpy(bp, meta_lsn, sizeof(*meta_lsn));
238         else
239                 memset(bp, 0, sizeof(*meta_lsn));
240         bp += sizeof(*meta_lsn);
241         if (header == NULL) {
242                 zero = 0;
243                 memcpy(bp, &zero, sizeof(u_int32_t));
244                 bp += sizeof(u_int32_t);
245         } else {
246                 memcpy(bp, &header->size, sizeof(header->size));
247                 bp += sizeof(header->size);
248                 memcpy(bp, header->data, header->size);
249                 bp += header->size;
250         }
251         memcpy(bp, &next, sizeof(next));
252         bp += sizeof(next);
253 #ifdef DEBUG
254         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
255                 fprintf(stderr, "Error in log record length");
256 #endif
257         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
258         if (txnid != NULL)
259                 txnid->last_lsn = *ret_lsnp;
260         free(logrec.data);
261         return (ret);
262 }
263
264 /*
265  * PUBLIC: int __bam_pg_free_print
266  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
267  */
268
269 int
270 __bam_pg_free_print(notused1, dbtp, lsnp, notused3, notused4)
271         DB_LOG *notused1;
272         DBT *dbtp;
273         DB_LSN *lsnp;
274         int notused3;
275         void *notused4;
276 {
277         __bam_pg_free_args *argp;
278         u_int32_t i;
279         int c, ret;
280
281         i = 0;
282         c = 0;
283         notused1 = NULL;
284         notused3 = 0;
285         notused4 = NULL;
286
287         if ((ret = __bam_pg_free_read(dbtp->data, &argp)) != 0)
288                 return (ret);
289         printf("[%lu][%lu]bam_pg_free: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
290             (u_long)lsnp->file,
291             (u_long)lsnp->offset,
292             (u_long)argp->type,
293             (u_long)argp->txnid->txnid,
294             (u_long)argp->prev_lsn.file,
295             (u_long)argp->prev_lsn.offset);
296         printf("\tfileid: %lu\n", (u_long)argp->fileid);
297         printf("\tpgno: %lu\n", (u_long)argp->pgno);
298         printf("\tmeta_lsn: [%lu][%lu]\n",
299             (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
300         printf("\theader: ");
301         for (i = 0; i < argp->header.size; i++) {
302                 c = ((char *)argp->header.data)[i];
303                 if (isprint(c) || c == 0xa)
304                         putchar(c);
305                 else
306                         printf("%#x ", c);
307         }
308         printf("\n");
309         printf("\tnext: %lu\n", (u_long)argp->next);
310         printf("\n");
311         free(argp);
312         return (0);
313 }
314
315 /*
316  * PUBLIC: int __bam_pg_free_read __P((void *, __bam_pg_free_args **));
317  */
318 int
319 __bam_pg_free_read(recbuf, argpp)
320         void *recbuf;
321         __bam_pg_free_args **argpp;
322 {
323         __bam_pg_free_args *argp;
324         u_int8_t *bp;
325
326         argp = (__bam_pg_free_args *)malloc(sizeof(__bam_pg_free_args) +
327             sizeof(DB_TXN));
328         if (argp == NULL)
329                 return (ENOMEM);
330         argp->txnid = (DB_TXN *)&argp[1];
331         bp = recbuf;
332         memcpy(&argp->type, bp, sizeof(argp->type));
333         bp += sizeof(argp->type);
334         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
335         bp += sizeof(argp->txnid->txnid);
336         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
337         bp += sizeof(DB_LSN);
338         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
339         bp += sizeof(argp->fileid);
340         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
341         bp += sizeof(argp->pgno);
342         memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
343         bp += sizeof(argp->meta_lsn);
344         memcpy(&argp->header.size, bp, sizeof(u_int32_t));
345         bp += sizeof(u_int32_t);
346         argp->header.data = bp;
347         bp += argp->header.size;
348         memcpy(&argp->next, bp, sizeof(argp->next));
349         bp += sizeof(argp->next);
350         *argpp = argp;
351         return (0);
352 }
353
354 /*
355  * PUBLIC: int __bam_split_log
356  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
357  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
358  * PUBLIC:     DB_LSN *, u_int32_t, db_pgno_t, DB_LSN *,
359  * PUBLIC:     DBT *));
360  */
361 int __bam_split_log(logp, txnid, ret_lsnp, flags,
362         fileid, left, llsn, right, rlsn, indx,
363         npgno, nlsn, pg)
364         DB_LOG *logp;
365         DB_TXN *txnid;
366         DB_LSN *ret_lsnp;
367         u_int32_t flags;
368         u_int32_t fileid;
369         db_pgno_t left;
370         DB_LSN * llsn;
371         db_pgno_t right;
372         DB_LSN * rlsn;
373         u_int32_t indx;
374         db_pgno_t npgno;
375         DB_LSN * nlsn;
376         DBT *pg;
377 {
378         DBT logrec;
379         DB_LSN *lsnp, null_lsn;
380         u_int32_t zero;
381         u_int32_t rectype, txn_num;
382         int ret;
383         u_int8_t *bp;
384
385         rectype = DB_bam_split;
386         txn_num = txnid == NULL ? 0 : txnid->txnid;
387         if (txnid == NULL) {
388                 null_lsn.file = 0;
389                 null_lsn.offset = 0;
390                 lsnp = &null_lsn;
391         } else
392                 lsnp = &txnid->last_lsn;
393         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
394             + sizeof(fileid)
395             + sizeof(left)
396             + sizeof(*llsn)
397             + sizeof(right)
398             + sizeof(*rlsn)
399             + sizeof(indx)
400             + sizeof(npgno)
401             + sizeof(*nlsn)
402             + sizeof(u_int32_t) + (pg == NULL ? 0 : pg->size);
403         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
404                 return (ENOMEM);
405
406         bp = logrec.data;
407         memcpy(bp, &rectype, sizeof(rectype));
408         bp += sizeof(rectype);
409         memcpy(bp, &txn_num, sizeof(txn_num));
410         bp += sizeof(txn_num);
411         memcpy(bp, lsnp, sizeof(DB_LSN));
412         bp += sizeof(DB_LSN);
413         memcpy(bp, &fileid, sizeof(fileid));
414         bp += sizeof(fileid);
415         memcpy(bp, &left, sizeof(left));
416         bp += sizeof(left);
417         if (llsn != NULL)
418                 memcpy(bp, llsn, sizeof(*llsn));
419         else
420                 memset(bp, 0, sizeof(*llsn));
421         bp += sizeof(*llsn);
422         memcpy(bp, &right, sizeof(right));
423         bp += sizeof(right);
424         if (rlsn != NULL)
425                 memcpy(bp, rlsn, sizeof(*rlsn));
426         else
427                 memset(bp, 0, sizeof(*rlsn));
428         bp += sizeof(*rlsn);
429         memcpy(bp, &indx, sizeof(indx));
430         bp += sizeof(indx);
431         memcpy(bp, &npgno, sizeof(npgno));
432         bp += sizeof(npgno);
433         if (nlsn != NULL)
434                 memcpy(bp, nlsn, sizeof(*nlsn));
435         else
436                 memset(bp, 0, sizeof(*nlsn));
437         bp += sizeof(*nlsn);
438         if (pg == NULL) {
439                 zero = 0;
440                 memcpy(bp, &zero, sizeof(u_int32_t));
441                 bp += sizeof(u_int32_t);
442         } else {
443                 memcpy(bp, &pg->size, sizeof(pg->size));
444                 bp += sizeof(pg->size);
445                 memcpy(bp, pg->data, pg->size);
446                 bp += pg->size;
447         }
448 #ifdef DEBUG
449         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
450                 fprintf(stderr, "Error in log record length");
451 #endif
452         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
453         if (txnid != NULL)
454                 txnid->last_lsn = *ret_lsnp;
455         free(logrec.data);
456         return (ret);
457 }
458
459 /*
460  * PUBLIC: int __bam_split_print
461  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
462  */
463
464 int
465 __bam_split_print(notused1, dbtp, lsnp, notused3, notused4)
466         DB_LOG *notused1;
467         DBT *dbtp;
468         DB_LSN *lsnp;
469         int notused3;
470         void *notused4;
471 {
472         __bam_split_args *argp;
473         u_int32_t i;
474         int c, ret;
475
476         i = 0;
477         c = 0;
478         notused1 = NULL;
479         notused3 = 0;
480         notused4 = NULL;
481
482         if ((ret = __bam_split_read(dbtp->data, &argp)) != 0)
483                 return (ret);
484         printf("[%lu][%lu]bam_split: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
485             (u_long)lsnp->file,
486             (u_long)lsnp->offset,
487             (u_long)argp->type,
488             (u_long)argp->txnid->txnid,
489             (u_long)argp->prev_lsn.file,
490             (u_long)argp->prev_lsn.offset);
491         printf("\tfileid: %lu\n", (u_long)argp->fileid);
492         printf("\tleft: %lu\n", (u_long)argp->left);
493         printf("\tllsn: [%lu][%lu]\n",
494             (u_long)argp->llsn.file, (u_long)argp->llsn.offset);
495         printf("\tright: %lu\n", (u_long)argp->right);
496         printf("\trlsn: [%lu][%lu]\n",
497             (u_long)argp->rlsn.file, (u_long)argp->rlsn.offset);
498         printf("\tindx: %lu\n", (u_long)argp->indx);
499         printf("\tnpgno: %lu\n", (u_long)argp->npgno);
500         printf("\tnlsn: [%lu][%lu]\n",
501             (u_long)argp->nlsn.file, (u_long)argp->nlsn.offset);
502         printf("\tpg: ");
503         for (i = 0; i < argp->pg.size; i++) {
504                 c = ((char *)argp->pg.data)[i];
505                 if (isprint(c) || c == 0xa)
506                         putchar(c);
507                 else
508                         printf("%#x ", c);
509         }
510         printf("\n");
511         printf("\n");
512         free(argp);
513         return (0);
514 }
515
516 /*
517  * PUBLIC: int __bam_split_read __P((void *, __bam_split_args **));
518  */
519 int
520 __bam_split_read(recbuf, argpp)
521         void *recbuf;
522         __bam_split_args **argpp;
523 {
524         __bam_split_args *argp;
525         u_int8_t *bp;
526
527         argp = (__bam_split_args *)malloc(sizeof(__bam_split_args) +
528             sizeof(DB_TXN));
529         if (argp == NULL)
530                 return (ENOMEM);
531         argp->txnid = (DB_TXN *)&argp[1];
532         bp = recbuf;
533         memcpy(&argp->type, bp, sizeof(argp->type));
534         bp += sizeof(argp->type);
535         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
536         bp += sizeof(argp->txnid->txnid);
537         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
538         bp += sizeof(DB_LSN);
539         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
540         bp += sizeof(argp->fileid);
541         memcpy(&argp->left, bp, sizeof(argp->left));
542         bp += sizeof(argp->left);
543         memcpy(&argp->llsn, bp,  sizeof(argp->llsn));
544         bp += sizeof(argp->llsn);
545         memcpy(&argp->right, bp, sizeof(argp->right));
546         bp += sizeof(argp->right);
547         memcpy(&argp->rlsn, bp,  sizeof(argp->rlsn));
548         bp += sizeof(argp->rlsn);
549         memcpy(&argp->indx, bp, sizeof(argp->indx));
550         bp += sizeof(argp->indx);
551         memcpy(&argp->npgno, bp, sizeof(argp->npgno));
552         bp += sizeof(argp->npgno);
553         memcpy(&argp->nlsn, bp,  sizeof(argp->nlsn));
554         bp += sizeof(argp->nlsn);
555         memcpy(&argp->pg.size, bp, sizeof(u_int32_t));
556         bp += sizeof(u_int32_t);
557         argp->pg.data = bp;
558         bp += argp->pg.size;
559         *argpp = argp;
560         return (0);
561 }
562
563 /*
564  * PUBLIC: int __bam_rsplit_log
565  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
566  * PUBLIC:     u_int32_t, db_pgno_t, DBT *, DBT *,
567  * PUBLIC:     DB_LSN *));
568  */
569 int __bam_rsplit_log(logp, txnid, ret_lsnp, flags,
570         fileid, pgno, pgdbt, rootent, rootlsn)
571         DB_LOG *logp;
572         DB_TXN *txnid;
573         DB_LSN *ret_lsnp;
574         u_int32_t flags;
575         u_int32_t fileid;
576         db_pgno_t pgno;
577         DBT *pgdbt;
578         DBT *rootent;
579         DB_LSN * rootlsn;
580 {
581         DBT logrec;
582         DB_LSN *lsnp, null_lsn;
583         u_int32_t zero;
584         u_int32_t rectype, txn_num;
585         int ret;
586         u_int8_t *bp;
587
588         rectype = DB_bam_rsplit;
589         txn_num = txnid == NULL ? 0 : txnid->txnid;
590         if (txnid == NULL) {
591                 null_lsn.file = 0;
592                 null_lsn.offset = 0;
593                 lsnp = &null_lsn;
594         } else
595                 lsnp = &txnid->last_lsn;
596         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
597             + sizeof(fileid)
598             + sizeof(pgno)
599             + sizeof(u_int32_t) + (pgdbt == NULL ? 0 : pgdbt->size)
600             + sizeof(u_int32_t) + (rootent == NULL ? 0 : rootent->size)
601             + sizeof(*rootlsn);
602         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
603                 return (ENOMEM);
604
605         bp = logrec.data;
606         memcpy(bp, &rectype, sizeof(rectype));
607         bp += sizeof(rectype);
608         memcpy(bp, &txn_num, sizeof(txn_num));
609         bp += sizeof(txn_num);
610         memcpy(bp, lsnp, sizeof(DB_LSN));
611         bp += sizeof(DB_LSN);
612         memcpy(bp, &fileid, sizeof(fileid));
613         bp += sizeof(fileid);
614         memcpy(bp, &pgno, sizeof(pgno));
615         bp += sizeof(pgno);
616         if (pgdbt == NULL) {
617                 zero = 0;
618                 memcpy(bp, &zero, sizeof(u_int32_t));
619                 bp += sizeof(u_int32_t);
620         } else {
621                 memcpy(bp, &pgdbt->size, sizeof(pgdbt->size));
622                 bp += sizeof(pgdbt->size);
623                 memcpy(bp, pgdbt->data, pgdbt->size);
624                 bp += pgdbt->size;
625         }
626         if (rootent == NULL) {
627                 zero = 0;
628                 memcpy(bp, &zero, sizeof(u_int32_t));
629                 bp += sizeof(u_int32_t);
630         } else {
631                 memcpy(bp, &rootent->size, sizeof(rootent->size));
632                 bp += sizeof(rootent->size);
633                 memcpy(bp, rootent->data, rootent->size);
634                 bp += rootent->size;
635         }
636         if (rootlsn != NULL)
637                 memcpy(bp, rootlsn, sizeof(*rootlsn));
638         else
639                 memset(bp, 0, sizeof(*rootlsn));
640         bp += sizeof(*rootlsn);
641 #ifdef DEBUG
642         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
643                 fprintf(stderr, "Error in log record length");
644 #endif
645         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
646         if (txnid != NULL)
647                 txnid->last_lsn = *ret_lsnp;
648         free(logrec.data);
649         return (ret);
650 }
651
652 /*
653  * PUBLIC: int __bam_rsplit_print
654  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
655  */
656
657 int
658 __bam_rsplit_print(notused1, dbtp, lsnp, notused3, notused4)
659         DB_LOG *notused1;
660         DBT *dbtp;
661         DB_LSN *lsnp;
662         int notused3;
663         void *notused4;
664 {
665         __bam_rsplit_args *argp;
666         u_int32_t i;
667         int c, ret;
668
669         i = 0;
670         c = 0;
671         notused1 = NULL;
672         notused3 = 0;
673         notused4 = NULL;
674
675         if ((ret = __bam_rsplit_read(dbtp->data, &argp)) != 0)
676                 return (ret);
677         printf("[%lu][%lu]bam_rsplit: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
678             (u_long)lsnp->file,
679             (u_long)lsnp->offset,
680             (u_long)argp->type,
681             (u_long)argp->txnid->txnid,
682             (u_long)argp->prev_lsn.file,
683             (u_long)argp->prev_lsn.offset);
684         printf("\tfileid: %lu\n", (u_long)argp->fileid);
685         printf("\tpgno: %lu\n", (u_long)argp->pgno);
686         printf("\tpgdbt: ");
687         for (i = 0; i < argp->pgdbt.size; i++) {
688                 c = ((char *)argp->pgdbt.data)[i];
689                 if (isprint(c) || c == 0xa)
690                         putchar(c);
691                 else
692                         printf("%#x ", c);
693         }
694         printf("\n");
695         printf("\trootent: ");
696         for (i = 0; i < argp->rootent.size; i++) {
697                 c = ((char *)argp->rootent.data)[i];
698                 if (isprint(c) || c == 0xa)
699                         putchar(c);
700                 else
701                         printf("%#x ", c);
702         }
703         printf("\n");
704         printf("\trootlsn: [%lu][%lu]\n",
705             (u_long)argp->rootlsn.file, (u_long)argp->rootlsn.offset);
706         printf("\n");
707         free(argp);
708         return (0);
709 }
710
711 /*
712  * PUBLIC: int __bam_rsplit_read __P((void *, __bam_rsplit_args **));
713  */
714 int
715 __bam_rsplit_read(recbuf, argpp)
716         void *recbuf;
717         __bam_rsplit_args **argpp;
718 {
719         __bam_rsplit_args *argp;
720         u_int8_t *bp;
721
722         argp = (__bam_rsplit_args *)malloc(sizeof(__bam_rsplit_args) +
723             sizeof(DB_TXN));
724         if (argp == NULL)
725                 return (ENOMEM);
726         argp->txnid = (DB_TXN *)&argp[1];
727         bp = recbuf;
728         memcpy(&argp->type, bp, sizeof(argp->type));
729         bp += sizeof(argp->type);
730         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
731         bp += sizeof(argp->txnid->txnid);
732         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
733         bp += sizeof(DB_LSN);
734         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
735         bp += sizeof(argp->fileid);
736         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
737         bp += sizeof(argp->pgno);
738         memcpy(&argp->pgdbt.size, bp, sizeof(u_int32_t));
739         bp += sizeof(u_int32_t);
740         argp->pgdbt.data = bp;
741         bp += argp->pgdbt.size;
742         memcpy(&argp->rootent.size, bp, sizeof(u_int32_t));
743         bp += sizeof(u_int32_t);
744         argp->rootent.data = bp;
745         bp += argp->rootent.size;
746         memcpy(&argp->rootlsn, bp,  sizeof(argp->rootlsn));
747         bp += sizeof(argp->rootlsn);
748         *argpp = argp;
749         return (0);
750 }
751
752 /*
753  * PUBLIC: int __bam_adj_log
754  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
755  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
756  * PUBLIC:     u_int32_t, u_int32_t));
757  */
758 int __bam_adj_log(logp, txnid, ret_lsnp, flags,
759         fileid, pgno, lsn, indx, indx_copy, is_insert)
760         DB_LOG *logp;
761         DB_TXN *txnid;
762         DB_LSN *ret_lsnp;
763         u_int32_t flags;
764         u_int32_t fileid;
765         db_pgno_t pgno;
766         DB_LSN * lsn;
767         u_int32_t indx;
768         u_int32_t indx_copy;
769         u_int32_t is_insert;
770 {
771         DBT logrec;
772         DB_LSN *lsnp, null_lsn;
773         u_int32_t rectype, txn_num;
774         int ret;
775         u_int8_t *bp;
776
777         rectype = DB_bam_adj;
778         txn_num = txnid == NULL ? 0 : txnid->txnid;
779         if (txnid == NULL) {
780                 null_lsn.file = 0;
781                 null_lsn.offset = 0;
782                 lsnp = &null_lsn;
783         } else
784                 lsnp = &txnid->last_lsn;
785         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
786             + sizeof(fileid)
787             + sizeof(pgno)
788             + sizeof(*lsn)
789             + sizeof(indx)
790             + sizeof(indx_copy)
791             + sizeof(is_insert);
792         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
793                 return (ENOMEM);
794
795         bp = logrec.data;
796         memcpy(bp, &rectype, sizeof(rectype));
797         bp += sizeof(rectype);
798         memcpy(bp, &txn_num, sizeof(txn_num));
799         bp += sizeof(txn_num);
800         memcpy(bp, lsnp, sizeof(DB_LSN));
801         bp += sizeof(DB_LSN);
802         memcpy(bp, &fileid, sizeof(fileid));
803         bp += sizeof(fileid);
804         memcpy(bp, &pgno, sizeof(pgno));
805         bp += sizeof(pgno);
806         if (lsn != NULL)
807                 memcpy(bp, lsn, sizeof(*lsn));
808         else
809                 memset(bp, 0, sizeof(*lsn));
810         bp += sizeof(*lsn);
811         memcpy(bp, &indx, sizeof(indx));
812         bp += sizeof(indx);
813         memcpy(bp, &indx_copy, sizeof(indx_copy));
814         bp += sizeof(indx_copy);
815         memcpy(bp, &is_insert, sizeof(is_insert));
816         bp += sizeof(is_insert);
817 #ifdef DEBUG
818         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
819                 fprintf(stderr, "Error in log record length");
820 #endif
821         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
822         if (txnid != NULL)
823                 txnid->last_lsn = *ret_lsnp;
824         free(logrec.data);
825         return (ret);
826 }
827
828 /*
829  * PUBLIC: int __bam_adj_print
830  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
831  */
832
833 int
834 __bam_adj_print(notused1, dbtp, lsnp, notused3, notused4)
835         DB_LOG *notused1;
836         DBT *dbtp;
837         DB_LSN *lsnp;
838         int notused3;
839         void *notused4;
840 {
841         __bam_adj_args *argp;
842         u_int32_t i;
843         int c, ret;
844
845         i = 0;
846         c = 0;
847         notused1 = NULL;
848         notused3 = 0;
849         notused4 = NULL;
850
851         if ((ret = __bam_adj_read(dbtp->data, &argp)) != 0)
852                 return (ret);
853         printf("[%lu][%lu]bam_adj: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
854             (u_long)lsnp->file,
855             (u_long)lsnp->offset,
856             (u_long)argp->type,
857             (u_long)argp->txnid->txnid,
858             (u_long)argp->prev_lsn.file,
859             (u_long)argp->prev_lsn.offset);
860         printf("\tfileid: %lu\n", (u_long)argp->fileid);
861         printf("\tpgno: %lu\n", (u_long)argp->pgno);
862         printf("\tlsn: [%lu][%lu]\n",
863             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
864         printf("\tindx: %lu\n", (u_long)argp->indx);
865         printf("\tindx_copy: %lu\n", (u_long)argp->indx_copy);
866         printf("\tis_insert: %lu\n", (u_long)argp->is_insert);
867         printf("\n");
868         free(argp);
869         return (0);
870 }
871
872 /*
873  * PUBLIC: int __bam_adj_read __P((void *, __bam_adj_args **));
874  */
875 int
876 __bam_adj_read(recbuf, argpp)
877         void *recbuf;
878         __bam_adj_args **argpp;
879 {
880         __bam_adj_args *argp;
881         u_int8_t *bp;
882
883         argp = (__bam_adj_args *)malloc(sizeof(__bam_adj_args) +
884             sizeof(DB_TXN));
885         if (argp == NULL)
886                 return (ENOMEM);
887         argp->txnid = (DB_TXN *)&argp[1];
888         bp = recbuf;
889         memcpy(&argp->type, bp, sizeof(argp->type));
890         bp += sizeof(argp->type);
891         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
892         bp += sizeof(argp->txnid->txnid);
893         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
894         bp += sizeof(DB_LSN);
895         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
896         bp += sizeof(argp->fileid);
897         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
898         bp += sizeof(argp->pgno);
899         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
900         bp += sizeof(argp->lsn);
901         memcpy(&argp->indx, bp, sizeof(argp->indx));
902         bp += sizeof(argp->indx);
903         memcpy(&argp->indx_copy, bp, sizeof(argp->indx_copy));
904         bp += sizeof(argp->indx_copy);
905         memcpy(&argp->is_insert, bp, sizeof(argp->is_insert));
906         bp += sizeof(argp->is_insert);
907         *argpp = argp;
908         return (0);
909 }
910
911 /*
912  * PUBLIC: int __bam_cadjust_log
913  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
914  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
915  * PUBLIC:     int32_t, int32_t));
916  */
917 int __bam_cadjust_log(logp, txnid, ret_lsnp, flags,
918         fileid, pgno, lsn, indx, adjust, total)
919         DB_LOG *logp;
920         DB_TXN *txnid;
921         DB_LSN *ret_lsnp;
922         u_int32_t flags;
923         u_int32_t fileid;
924         db_pgno_t pgno;
925         DB_LSN * lsn;
926         u_int32_t indx;
927         int32_t adjust;
928         int32_t total;
929 {
930         DBT logrec;
931         DB_LSN *lsnp, null_lsn;
932         u_int32_t rectype, txn_num;
933         int ret;
934         u_int8_t *bp;
935
936         rectype = DB_bam_cadjust;
937         txn_num = txnid == NULL ? 0 : txnid->txnid;
938         if (txnid == NULL) {
939                 null_lsn.file = 0;
940                 null_lsn.offset = 0;
941                 lsnp = &null_lsn;
942         } else
943                 lsnp = &txnid->last_lsn;
944         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
945             + sizeof(fileid)
946             + sizeof(pgno)
947             + sizeof(*lsn)
948             + sizeof(indx)
949             + sizeof(adjust)
950             + sizeof(total);
951         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
952                 return (ENOMEM);
953
954         bp = logrec.data;
955         memcpy(bp, &rectype, sizeof(rectype));
956         bp += sizeof(rectype);
957         memcpy(bp, &txn_num, sizeof(txn_num));
958         bp += sizeof(txn_num);
959         memcpy(bp, lsnp, sizeof(DB_LSN));
960         bp += sizeof(DB_LSN);
961         memcpy(bp, &fileid, sizeof(fileid));
962         bp += sizeof(fileid);
963         memcpy(bp, &pgno, sizeof(pgno));
964         bp += sizeof(pgno);
965         if (lsn != NULL)
966                 memcpy(bp, lsn, sizeof(*lsn));
967         else
968                 memset(bp, 0, sizeof(*lsn));
969         bp += sizeof(*lsn);
970         memcpy(bp, &indx, sizeof(indx));
971         bp += sizeof(indx);
972         memcpy(bp, &adjust, sizeof(adjust));
973         bp += sizeof(adjust);
974         memcpy(bp, &total, sizeof(total));
975         bp += sizeof(total);
976 #ifdef DEBUG
977         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
978                 fprintf(stderr, "Error in log record length");
979 #endif
980         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
981         if (txnid != NULL)
982                 txnid->last_lsn = *ret_lsnp;
983         free(logrec.data);
984         return (ret);
985 }
986
987 /*
988  * PUBLIC: int __bam_cadjust_print
989  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
990  */
991
992 int
993 __bam_cadjust_print(notused1, dbtp, lsnp, notused3, notused4)
994         DB_LOG *notused1;
995         DBT *dbtp;
996         DB_LSN *lsnp;
997         int notused3;
998         void *notused4;
999 {
1000         __bam_cadjust_args *argp;
1001         u_int32_t i;
1002         int c, ret;
1003
1004         i = 0;
1005         c = 0;
1006         notused1 = NULL;
1007         notused3 = 0;
1008         notused4 = NULL;
1009
1010         if ((ret = __bam_cadjust_read(dbtp->data, &argp)) != 0)
1011                 return (ret);
1012         printf("[%lu][%lu]bam_cadjust: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1013             (u_long)lsnp->file,
1014             (u_long)lsnp->offset,
1015             (u_long)argp->type,
1016             (u_long)argp->txnid->txnid,
1017             (u_long)argp->prev_lsn.file,
1018             (u_long)argp->prev_lsn.offset);
1019         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1020         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1021         printf("\tlsn: [%lu][%lu]\n",
1022             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1023         printf("\tindx: %lu\n", (u_long)argp->indx);
1024         printf("\tadjust: %ld\n", (long)argp->adjust);
1025         printf("\ttotal: %ld\n", (long)argp->total);
1026         printf("\n");
1027         free(argp);
1028         return (0);
1029 }
1030
1031 /*
1032  * PUBLIC: int __bam_cadjust_read __P((void *, __bam_cadjust_args **));
1033  */
1034 int
1035 __bam_cadjust_read(recbuf, argpp)
1036         void *recbuf;
1037         __bam_cadjust_args **argpp;
1038 {
1039         __bam_cadjust_args *argp;
1040         u_int8_t *bp;
1041
1042         argp = (__bam_cadjust_args *)malloc(sizeof(__bam_cadjust_args) +
1043             sizeof(DB_TXN));
1044         if (argp == NULL)
1045                 return (ENOMEM);
1046         argp->txnid = (DB_TXN *)&argp[1];
1047         bp = recbuf;
1048         memcpy(&argp->type, bp, sizeof(argp->type));
1049         bp += sizeof(argp->type);
1050         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1051         bp += sizeof(argp->txnid->txnid);
1052         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1053         bp += sizeof(DB_LSN);
1054         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1055         bp += sizeof(argp->fileid);
1056         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1057         bp += sizeof(argp->pgno);
1058         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1059         bp += sizeof(argp->lsn);
1060         memcpy(&argp->indx, bp, sizeof(argp->indx));
1061         bp += sizeof(argp->indx);
1062         memcpy(&argp->adjust, bp, sizeof(argp->adjust));
1063         bp += sizeof(argp->adjust);
1064         memcpy(&argp->total, bp, sizeof(argp->total));
1065         bp += sizeof(argp->total);
1066         *argpp = argp;
1067         return (0);
1068 }
1069
1070 /*
1071  * PUBLIC: int __bam_cdel_log
1072  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1073  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t));
1074  */
1075 int __bam_cdel_log(logp, txnid, ret_lsnp, flags,
1076         fileid, pgno, lsn, indx)
1077         DB_LOG *logp;
1078         DB_TXN *txnid;
1079         DB_LSN *ret_lsnp;
1080         u_int32_t flags;
1081         u_int32_t fileid;
1082         db_pgno_t pgno;
1083         DB_LSN * lsn;
1084         u_int32_t indx;
1085 {
1086         DBT logrec;
1087         DB_LSN *lsnp, null_lsn;
1088         u_int32_t rectype, txn_num;
1089         int ret;
1090         u_int8_t *bp;
1091
1092         rectype = DB_bam_cdel;
1093         txn_num = txnid == NULL ? 0 : txnid->txnid;
1094         if (txnid == NULL) {
1095                 null_lsn.file = 0;
1096                 null_lsn.offset = 0;
1097                 lsnp = &null_lsn;
1098         } else
1099                 lsnp = &txnid->last_lsn;
1100         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1101             + sizeof(fileid)
1102             + sizeof(pgno)
1103             + sizeof(*lsn)
1104             + sizeof(indx);
1105         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
1106                 return (ENOMEM);
1107
1108         bp = logrec.data;
1109         memcpy(bp, &rectype, sizeof(rectype));
1110         bp += sizeof(rectype);
1111         memcpy(bp, &txn_num, sizeof(txn_num));
1112         bp += sizeof(txn_num);
1113         memcpy(bp, lsnp, sizeof(DB_LSN));
1114         bp += sizeof(DB_LSN);
1115         memcpy(bp, &fileid, sizeof(fileid));
1116         bp += sizeof(fileid);
1117         memcpy(bp, &pgno, sizeof(pgno));
1118         bp += sizeof(pgno);
1119         if (lsn != NULL)
1120                 memcpy(bp, lsn, sizeof(*lsn));
1121         else
1122                 memset(bp, 0, sizeof(*lsn));
1123         bp += sizeof(*lsn);
1124         memcpy(bp, &indx, sizeof(indx));
1125         bp += sizeof(indx);
1126 #ifdef DEBUG
1127         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1128                 fprintf(stderr, "Error in log record length");
1129 #endif
1130         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1131         if (txnid != NULL)
1132                 txnid->last_lsn = *ret_lsnp;
1133         free(logrec.data);
1134         return (ret);
1135 }
1136
1137 /*
1138  * PUBLIC: int __bam_cdel_print
1139  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1140  */
1141
1142 int
1143 __bam_cdel_print(notused1, dbtp, lsnp, notused3, notused4)
1144         DB_LOG *notused1;
1145         DBT *dbtp;
1146         DB_LSN *lsnp;
1147         int notused3;
1148         void *notused4;
1149 {
1150         __bam_cdel_args *argp;
1151         u_int32_t i;
1152         int c, ret;
1153
1154         i = 0;
1155         c = 0;
1156         notused1 = NULL;
1157         notused3 = 0;
1158         notused4 = NULL;
1159
1160         if ((ret = __bam_cdel_read(dbtp->data, &argp)) != 0)
1161                 return (ret);
1162         printf("[%lu][%lu]bam_cdel: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1163             (u_long)lsnp->file,
1164             (u_long)lsnp->offset,
1165             (u_long)argp->type,
1166             (u_long)argp->txnid->txnid,
1167             (u_long)argp->prev_lsn.file,
1168             (u_long)argp->prev_lsn.offset);
1169         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1170         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1171         printf("\tlsn: [%lu][%lu]\n",
1172             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1173         printf("\tindx: %lu\n", (u_long)argp->indx);
1174         printf("\n");
1175         free(argp);
1176         return (0);
1177 }
1178
1179 /*
1180  * PUBLIC: int __bam_cdel_read __P((void *, __bam_cdel_args **));
1181  */
1182 int
1183 __bam_cdel_read(recbuf, argpp)
1184         void *recbuf;
1185         __bam_cdel_args **argpp;
1186 {
1187         __bam_cdel_args *argp;
1188         u_int8_t *bp;
1189
1190         argp = (__bam_cdel_args *)malloc(sizeof(__bam_cdel_args) +
1191             sizeof(DB_TXN));
1192         if (argp == NULL)
1193                 return (ENOMEM);
1194         argp->txnid = (DB_TXN *)&argp[1];
1195         bp = recbuf;
1196         memcpy(&argp->type, bp, sizeof(argp->type));
1197         bp += sizeof(argp->type);
1198         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1199         bp += sizeof(argp->txnid->txnid);
1200         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1201         bp += sizeof(DB_LSN);
1202         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1203         bp += sizeof(argp->fileid);
1204         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1205         bp += sizeof(argp->pgno);
1206         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1207         bp += sizeof(argp->lsn);
1208         memcpy(&argp->indx, bp, sizeof(argp->indx));
1209         bp += sizeof(argp->indx);
1210         *argpp = argp;
1211         return (0);
1212 }
1213
1214 /*
1215  * PUBLIC: int __bam_init_print __P((DB_ENV *));
1216  */
1217 int
1218 __bam_init_print(dbenv)
1219         DB_ENV *dbenv;
1220 {
1221         int ret;
1222
1223         if ((ret = __db_add_recovery(dbenv,
1224             __bam_pg_alloc_print, DB_bam_pg_alloc)) != 0)
1225                 return (ret);
1226         if ((ret = __db_add_recovery(dbenv,
1227             __bam_pg_free_print, DB_bam_pg_free)) != 0)
1228                 return (ret);
1229         if ((ret = __db_add_recovery(dbenv,
1230             __bam_split_print, DB_bam_split)) != 0)
1231                 return (ret);
1232         if ((ret = __db_add_recovery(dbenv,
1233             __bam_rsplit_print, DB_bam_rsplit)) != 0)
1234                 return (ret);
1235         if ((ret = __db_add_recovery(dbenv,
1236             __bam_adj_print, DB_bam_adj)) != 0)
1237                 return (ret);
1238         if ((ret = __db_add_recovery(dbenv,
1239             __bam_cadjust_print, DB_bam_cadjust)) != 0)
1240                 return (ret);
1241         if ((ret = __db_add_recovery(dbenv,
1242             __bam_cdel_print, DB_bam_cdel)) != 0)
1243                 return (ret);
1244         return (0);
1245 }
1246
1247 /*
1248  * PUBLIC: int __bam_init_recover __P((DB_ENV *));
1249  */
1250 int
1251 __bam_init_recover(dbenv)
1252         DB_ENV *dbenv;
1253 {
1254         int ret;
1255
1256         if ((ret = __db_add_recovery(dbenv,
1257             __bam_pg_alloc_recover, DB_bam_pg_alloc)) != 0)
1258                 return (ret);
1259         if ((ret = __db_add_recovery(dbenv,
1260             __bam_pg_free_recover, DB_bam_pg_free)) != 0)
1261                 return (ret);
1262         if ((ret = __db_add_recovery(dbenv,
1263             __bam_split_recover, DB_bam_split)) != 0)
1264                 return (ret);
1265         if ((ret = __db_add_recovery(dbenv,
1266             __bam_rsplit_recover, DB_bam_rsplit)) != 0)
1267                 return (ret);
1268         if ((ret = __db_add_recovery(dbenv,
1269             __bam_adj_recover, DB_bam_adj)) != 0)
1270                 return (ret);
1271         if ((ret = __db_add_recovery(dbenv,
1272             __bam_cadjust_recover, DB_bam_cadjust)) != 0)
1273                 return (ret);
1274         if ((ret = __db_add_recovery(dbenv,
1275             __bam_cdel_recover, DB_bam_cdel)) != 0)
1276                 return (ret);
1277         return (0);
1278 }
1279