Update from db-2.3.12.
[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 *)__db_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         __db_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         __db_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 *)__db_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 *)__db_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         __db_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         __db_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 *)__db_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 *)__db_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         __db_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         __db_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 *)__db_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 *, db_pgno_t,
567  * PUBLIC:     DBT *, DB_LSN *));
568  */
569 int __bam_rsplit_log(logp, txnid, ret_lsnp, flags,
570         fileid, pgno, pgdbt, nrec, 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         db_pgno_t nrec;
579         DBT *rootent;
580         DB_LSN * rootlsn;
581 {
582         DBT logrec;
583         DB_LSN *lsnp, null_lsn;
584         u_int32_t zero;
585         u_int32_t rectype, txn_num;
586         int ret;
587         u_int8_t *bp;
588
589         rectype = DB_bam_rsplit;
590         txn_num = txnid == NULL ? 0 : txnid->txnid;
591         if (txnid == NULL) {
592                 null_lsn.file = 0;
593                 null_lsn.offset = 0;
594                 lsnp = &null_lsn;
595         } else
596                 lsnp = &txnid->last_lsn;
597         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
598             + sizeof(fileid)
599             + sizeof(pgno)
600             + sizeof(u_int32_t) + (pgdbt == NULL ? 0 : pgdbt->size)
601             + sizeof(nrec)
602             + sizeof(u_int32_t) + (rootent == NULL ? 0 : rootent->size)
603             + sizeof(*rootlsn);
604         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
605                 return (ENOMEM);
606
607         bp = logrec.data;
608         memcpy(bp, &rectype, sizeof(rectype));
609         bp += sizeof(rectype);
610         memcpy(bp, &txn_num, sizeof(txn_num));
611         bp += sizeof(txn_num);
612         memcpy(bp, lsnp, sizeof(DB_LSN));
613         bp += sizeof(DB_LSN);
614         memcpy(bp, &fileid, sizeof(fileid));
615         bp += sizeof(fileid);
616         memcpy(bp, &pgno, sizeof(pgno));
617         bp += sizeof(pgno);
618         if (pgdbt == NULL) {
619                 zero = 0;
620                 memcpy(bp, &zero, sizeof(u_int32_t));
621                 bp += sizeof(u_int32_t);
622         } else {
623                 memcpy(bp, &pgdbt->size, sizeof(pgdbt->size));
624                 bp += sizeof(pgdbt->size);
625                 memcpy(bp, pgdbt->data, pgdbt->size);
626                 bp += pgdbt->size;
627         }
628         memcpy(bp, &nrec, sizeof(nrec));
629         bp += sizeof(nrec);
630         if (rootent == NULL) {
631                 zero = 0;
632                 memcpy(bp, &zero, sizeof(u_int32_t));
633                 bp += sizeof(u_int32_t);
634         } else {
635                 memcpy(bp, &rootent->size, sizeof(rootent->size));
636                 bp += sizeof(rootent->size);
637                 memcpy(bp, rootent->data, rootent->size);
638                 bp += rootent->size;
639         }
640         if (rootlsn != NULL)
641                 memcpy(bp, rootlsn, sizeof(*rootlsn));
642         else
643                 memset(bp, 0, sizeof(*rootlsn));
644         bp += sizeof(*rootlsn);
645 #ifdef DEBUG
646         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
647                 fprintf(stderr, "Error in log record length");
648 #endif
649         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
650         if (txnid != NULL)
651                 txnid->last_lsn = *ret_lsnp;
652         __db_free(logrec.data);
653         return (ret);
654 }
655
656 /*
657  * PUBLIC: int __bam_rsplit_print
658  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
659  */
660
661 int
662 __bam_rsplit_print(notused1, dbtp, lsnp, notused3, notused4)
663         DB_LOG *notused1;
664         DBT *dbtp;
665         DB_LSN *lsnp;
666         int notused3;
667         void *notused4;
668 {
669         __bam_rsplit_args *argp;
670         u_int32_t i;
671         int c, ret;
672
673         i = 0;
674         c = 0;
675         notused1 = NULL;
676         notused3 = 0;
677         notused4 = NULL;
678
679         if ((ret = __bam_rsplit_read(dbtp->data, &argp)) != 0)
680                 return (ret);
681         printf("[%lu][%lu]bam_rsplit: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
682             (u_long)lsnp->file,
683             (u_long)lsnp->offset,
684             (u_long)argp->type,
685             (u_long)argp->txnid->txnid,
686             (u_long)argp->prev_lsn.file,
687             (u_long)argp->prev_lsn.offset);
688         printf("\tfileid: %lu\n", (u_long)argp->fileid);
689         printf("\tpgno: %lu\n", (u_long)argp->pgno);
690         printf("\tpgdbt: ");
691         for (i = 0; i < argp->pgdbt.size; i++) {
692                 c = ((char *)argp->pgdbt.data)[i];
693                 if (isprint(c) || c == 0xa)
694                         putchar(c);
695                 else
696                         printf("%#x ", c);
697         }
698         printf("\n");
699         printf("\tnrec: %lu\n", (u_long)argp->nrec);
700         printf("\trootent: ");
701         for (i = 0; i < argp->rootent.size; i++) {
702                 c = ((char *)argp->rootent.data)[i];
703                 if (isprint(c) || c == 0xa)
704                         putchar(c);
705                 else
706                         printf("%#x ", c);
707         }
708         printf("\n");
709         printf("\trootlsn: [%lu][%lu]\n",
710             (u_long)argp->rootlsn.file, (u_long)argp->rootlsn.offset);
711         printf("\n");
712         __db_free(argp);
713         return (0);
714 }
715
716 /*
717  * PUBLIC: int __bam_rsplit_read __P((void *, __bam_rsplit_args **));
718  */
719 int
720 __bam_rsplit_read(recbuf, argpp)
721         void *recbuf;
722         __bam_rsplit_args **argpp;
723 {
724         __bam_rsplit_args *argp;
725         u_int8_t *bp;
726
727         argp = (__bam_rsplit_args *)__db_malloc(sizeof(__bam_rsplit_args) +
728             sizeof(DB_TXN));
729         if (argp == NULL)
730                 return (ENOMEM);
731         argp->txnid = (DB_TXN *)&argp[1];
732         bp = recbuf;
733         memcpy(&argp->type, bp, sizeof(argp->type));
734         bp += sizeof(argp->type);
735         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
736         bp += sizeof(argp->txnid->txnid);
737         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
738         bp += sizeof(DB_LSN);
739         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
740         bp += sizeof(argp->fileid);
741         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
742         bp += sizeof(argp->pgno);
743         memcpy(&argp->pgdbt.size, bp, sizeof(u_int32_t));
744         bp += sizeof(u_int32_t);
745         argp->pgdbt.data = bp;
746         bp += argp->pgdbt.size;
747         memcpy(&argp->nrec, bp, sizeof(argp->nrec));
748         bp += sizeof(argp->nrec);
749         memcpy(&argp->rootent.size, bp, sizeof(u_int32_t));
750         bp += sizeof(u_int32_t);
751         argp->rootent.data = bp;
752         bp += argp->rootent.size;
753         memcpy(&argp->rootlsn, bp,  sizeof(argp->rootlsn));
754         bp += sizeof(argp->rootlsn);
755         *argpp = argp;
756         return (0);
757 }
758
759 /*
760  * PUBLIC: int __bam_adj_log
761  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
762  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
763  * PUBLIC:     u_int32_t, u_int32_t));
764  */
765 int __bam_adj_log(logp, txnid, ret_lsnp, flags,
766         fileid, pgno, lsn, indx, indx_copy, is_insert)
767         DB_LOG *logp;
768         DB_TXN *txnid;
769         DB_LSN *ret_lsnp;
770         u_int32_t flags;
771         u_int32_t fileid;
772         db_pgno_t pgno;
773         DB_LSN * lsn;
774         u_int32_t indx;
775         u_int32_t indx_copy;
776         u_int32_t is_insert;
777 {
778         DBT logrec;
779         DB_LSN *lsnp, null_lsn;
780         u_int32_t rectype, txn_num;
781         int ret;
782         u_int8_t *bp;
783
784         rectype = DB_bam_adj;
785         txn_num = txnid == NULL ? 0 : txnid->txnid;
786         if (txnid == NULL) {
787                 null_lsn.file = 0;
788                 null_lsn.offset = 0;
789                 lsnp = &null_lsn;
790         } else
791                 lsnp = &txnid->last_lsn;
792         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
793             + sizeof(fileid)
794             + sizeof(pgno)
795             + sizeof(*lsn)
796             + sizeof(indx)
797             + sizeof(indx_copy)
798             + sizeof(is_insert);
799         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
800                 return (ENOMEM);
801
802         bp = logrec.data;
803         memcpy(bp, &rectype, sizeof(rectype));
804         bp += sizeof(rectype);
805         memcpy(bp, &txn_num, sizeof(txn_num));
806         bp += sizeof(txn_num);
807         memcpy(bp, lsnp, sizeof(DB_LSN));
808         bp += sizeof(DB_LSN);
809         memcpy(bp, &fileid, sizeof(fileid));
810         bp += sizeof(fileid);
811         memcpy(bp, &pgno, sizeof(pgno));
812         bp += sizeof(pgno);
813         if (lsn != NULL)
814                 memcpy(bp, lsn, sizeof(*lsn));
815         else
816                 memset(bp, 0, sizeof(*lsn));
817         bp += sizeof(*lsn);
818         memcpy(bp, &indx, sizeof(indx));
819         bp += sizeof(indx);
820         memcpy(bp, &indx_copy, sizeof(indx_copy));
821         bp += sizeof(indx_copy);
822         memcpy(bp, &is_insert, sizeof(is_insert));
823         bp += sizeof(is_insert);
824 #ifdef DEBUG
825         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
826                 fprintf(stderr, "Error in log record length");
827 #endif
828         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
829         if (txnid != NULL)
830                 txnid->last_lsn = *ret_lsnp;
831         __db_free(logrec.data);
832         return (ret);
833 }
834
835 /*
836  * PUBLIC: int __bam_adj_print
837  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
838  */
839
840 int
841 __bam_adj_print(notused1, dbtp, lsnp, notused3, notused4)
842         DB_LOG *notused1;
843         DBT *dbtp;
844         DB_LSN *lsnp;
845         int notused3;
846         void *notused4;
847 {
848         __bam_adj_args *argp;
849         u_int32_t i;
850         int c, ret;
851
852         i = 0;
853         c = 0;
854         notused1 = NULL;
855         notused3 = 0;
856         notused4 = NULL;
857
858         if ((ret = __bam_adj_read(dbtp->data, &argp)) != 0)
859                 return (ret);
860         printf("[%lu][%lu]bam_adj: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
861             (u_long)lsnp->file,
862             (u_long)lsnp->offset,
863             (u_long)argp->type,
864             (u_long)argp->txnid->txnid,
865             (u_long)argp->prev_lsn.file,
866             (u_long)argp->prev_lsn.offset);
867         printf("\tfileid: %lu\n", (u_long)argp->fileid);
868         printf("\tpgno: %lu\n", (u_long)argp->pgno);
869         printf("\tlsn: [%lu][%lu]\n",
870             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
871         printf("\tindx: %lu\n", (u_long)argp->indx);
872         printf("\tindx_copy: %lu\n", (u_long)argp->indx_copy);
873         printf("\tis_insert: %lu\n", (u_long)argp->is_insert);
874         printf("\n");
875         __db_free(argp);
876         return (0);
877 }
878
879 /*
880  * PUBLIC: int __bam_adj_read __P((void *, __bam_adj_args **));
881  */
882 int
883 __bam_adj_read(recbuf, argpp)
884         void *recbuf;
885         __bam_adj_args **argpp;
886 {
887         __bam_adj_args *argp;
888         u_int8_t *bp;
889
890         argp = (__bam_adj_args *)__db_malloc(sizeof(__bam_adj_args) +
891             sizeof(DB_TXN));
892         if (argp == NULL)
893                 return (ENOMEM);
894         argp->txnid = (DB_TXN *)&argp[1];
895         bp = recbuf;
896         memcpy(&argp->type, bp, sizeof(argp->type));
897         bp += sizeof(argp->type);
898         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
899         bp += sizeof(argp->txnid->txnid);
900         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
901         bp += sizeof(DB_LSN);
902         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
903         bp += sizeof(argp->fileid);
904         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
905         bp += sizeof(argp->pgno);
906         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
907         bp += sizeof(argp->lsn);
908         memcpy(&argp->indx, bp, sizeof(argp->indx));
909         bp += sizeof(argp->indx);
910         memcpy(&argp->indx_copy, bp, sizeof(argp->indx_copy));
911         bp += sizeof(argp->indx_copy);
912         memcpy(&argp->is_insert, bp, sizeof(argp->is_insert));
913         bp += sizeof(argp->is_insert);
914         *argpp = argp;
915         return (0);
916 }
917
918 /*
919  * PUBLIC: int __bam_cadjust_log
920  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
921  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
922  * PUBLIC:     int32_t, int32_t));
923  */
924 int __bam_cadjust_log(logp, txnid, ret_lsnp, flags,
925         fileid, pgno, lsn, indx, adjust, total)
926         DB_LOG *logp;
927         DB_TXN *txnid;
928         DB_LSN *ret_lsnp;
929         u_int32_t flags;
930         u_int32_t fileid;
931         db_pgno_t pgno;
932         DB_LSN * lsn;
933         u_int32_t indx;
934         int32_t adjust;
935         int32_t total;
936 {
937         DBT logrec;
938         DB_LSN *lsnp, null_lsn;
939         u_int32_t rectype, txn_num;
940         int ret;
941         u_int8_t *bp;
942
943         rectype = DB_bam_cadjust;
944         txn_num = txnid == NULL ? 0 : txnid->txnid;
945         if (txnid == NULL) {
946                 null_lsn.file = 0;
947                 null_lsn.offset = 0;
948                 lsnp = &null_lsn;
949         } else
950                 lsnp = &txnid->last_lsn;
951         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
952             + sizeof(fileid)
953             + sizeof(pgno)
954             + sizeof(*lsn)
955             + sizeof(indx)
956             + sizeof(adjust)
957             + sizeof(total);
958         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
959                 return (ENOMEM);
960
961         bp = logrec.data;
962         memcpy(bp, &rectype, sizeof(rectype));
963         bp += sizeof(rectype);
964         memcpy(bp, &txn_num, sizeof(txn_num));
965         bp += sizeof(txn_num);
966         memcpy(bp, lsnp, sizeof(DB_LSN));
967         bp += sizeof(DB_LSN);
968         memcpy(bp, &fileid, sizeof(fileid));
969         bp += sizeof(fileid);
970         memcpy(bp, &pgno, sizeof(pgno));
971         bp += sizeof(pgno);
972         if (lsn != NULL)
973                 memcpy(bp, lsn, sizeof(*lsn));
974         else
975                 memset(bp, 0, sizeof(*lsn));
976         bp += sizeof(*lsn);
977         memcpy(bp, &indx, sizeof(indx));
978         bp += sizeof(indx);
979         memcpy(bp, &adjust, sizeof(adjust));
980         bp += sizeof(adjust);
981         memcpy(bp, &total, sizeof(total));
982         bp += sizeof(total);
983 #ifdef DEBUG
984         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
985                 fprintf(stderr, "Error in log record length");
986 #endif
987         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
988         if (txnid != NULL)
989                 txnid->last_lsn = *ret_lsnp;
990         __db_free(logrec.data);
991         return (ret);
992 }
993
994 /*
995  * PUBLIC: int __bam_cadjust_print
996  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
997  */
998
999 int
1000 __bam_cadjust_print(notused1, dbtp, lsnp, notused3, notused4)
1001         DB_LOG *notused1;
1002         DBT *dbtp;
1003         DB_LSN *lsnp;
1004         int notused3;
1005         void *notused4;
1006 {
1007         __bam_cadjust_args *argp;
1008         u_int32_t i;
1009         int c, ret;
1010
1011         i = 0;
1012         c = 0;
1013         notused1 = NULL;
1014         notused3 = 0;
1015         notused4 = NULL;
1016
1017         if ((ret = __bam_cadjust_read(dbtp->data, &argp)) != 0)
1018                 return (ret);
1019         printf("[%lu][%lu]bam_cadjust: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1020             (u_long)lsnp->file,
1021             (u_long)lsnp->offset,
1022             (u_long)argp->type,
1023             (u_long)argp->txnid->txnid,
1024             (u_long)argp->prev_lsn.file,
1025             (u_long)argp->prev_lsn.offset);
1026         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1027         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1028         printf("\tlsn: [%lu][%lu]\n",
1029             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1030         printf("\tindx: %lu\n", (u_long)argp->indx);
1031         printf("\tadjust: %ld\n", (long)argp->adjust);
1032         printf("\ttotal: %ld\n", (long)argp->total);
1033         printf("\n");
1034         __db_free(argp);
1035         return (0);
1036 }
1037
1038 /*
1039  * PUBLIC: int __bam_cadjust_read __P((void *, __bam_cadjust_args **));
1040  */
1041 int
1042 __bam_cadjust_read(recbuf, argpp)
1043         void *recbuf;
1044         __bam_cadjust_args **argpp;
1045 {
1046         __bam_cadjust_args *argp;
1047         u_int8_t *bp;
1048
1049         argp = (__bam_cadjust_args *)__db_malloc(sizeof(__bam_cadjust_args) +
1050             sizeof(DB_TXN));
1051         if (argp == NULL)
1052                 return (ENOMEM);
1053         argp->txnid = (DB_TXN *)&argp[1];
1054         bp = recbuf;
1055         memcpy(&argp->type, bp, sizeof(argp->type));
1056         bp += sizeof(argp->type);
1057         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1058         bp += sizeof(argp->txnid->txnid);
1059         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1060         bp += sizeof(DB_LSN);
1061         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1062         bp += sizeof(argp->fileid);
1063         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1064         bp += sizeof(argp->pgno);
1065         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1066         bp += sizeof(argp->lsn);
1067         memcpy(&argp->indx, bp, sizeof(argp->indx));
1068         bp += sizeof(argp->indx);
1069         memcpy(&argp->adjust, bp, sizeof(argp->adjust));
1070         bp += sizeof(argp->adjust);
1071         memcpy(&argp->total, bp, sizeof(argp->total));
1072         bp += sizeof(argp->total);
1073         *argpp = argp;
1074         return (0);
1075 }
1076
1077 /*
1078  * PUBLIC: int __bam_cdel_log
1079  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1080  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t));
1081  */
1082 int __bam_cdel_log(logp, txnid, ret_lsnp, flags,
1083         fileid, pgno, lsn, indx)
1084         DB_LOG *logp;
1085         DB_TXN *txnid;
1086         DB_LSN *ret_lsnp;
1087         u_int32_t flags;
1088         u_int32_t fileid;
1089         db_pgno_t pgno;
1090         DB_LSN * lsn;
1091         u_int32_t indx;
1092 {
1093         DBT logrec;
1094         DB_LSN *lsnp, null_lsn;
1095         u_int32_t rectype, txn_num;
1096         int ret;
1097         u_int8_t *bp;
1098
1099         rectype = DB_bam_cdel;
1100         txn_num = txnid == NULL ? 0 : txnid->txnid;
1101         if (txnid == NULL) {
1102                 null_lsn.file = 0;
1103                 null_lsn.offset = 0;
1104                 lsnp = &null_lsn;
1105         } else
1106                 lsnp = &txnid->last_lsn;
1107         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1108             + sizeof(fileid)
1109             + sizeof(pgno)
1110             + sizeof(*lsn)
1111             + sizeof(indx);
1112         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
1113                 return (ENOMEM);
1114
1115         bp = logrec.data;
1116         memcpy(bp, &rectype, sizeof(rectype));
1117         bp += sizeof(rectype);
1118         memcpy(bp, &txn_num, sizeof(txn_num));
1119         bp += sizeof(txn_num);
1120         memcpy(bp, lsnp, sizeof(DB_LSN));
1121         bp += sizeof(DB_LSN);
1122         memcpy(bp, &fileid, sizeof(fileid));
1123         bp += sizeof(fileid);
1124         memcpy(bp, &pgno, sizeof(pgno));
1125         bp += sizeof(pgno);
1126         if (lsn != NULL)
1127                 memcpy(bp, lsn, sizeof(*lsn));
1128         else
1129                 memset(bp, 0, sizeof(*lsn));
1130         bp += sizeof(*lsn);
1131         memcpy(bp, &indx, sizeof(indx));
1132         bp += sizeof(indx);
1133 #ifdef DEBUG
1134         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1135                 fprintf(stderr, "Error in log record length");
1136 #endif
1137         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1138         if (txnid != NULL)
1139                 txnid->last_lsn = *ret_lsnp;
1140         __db_free(logrec.data);
1141         return (ret);
1142 }
1143
1144 /*
1145  * PUBLIC: int __bam_cdel_print
1146  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1147  */
1148
1149 int
1150 __bam_cdel_print(notused1, dbtp, lsnp, notused3, notused4)
1151         DB_LOG *notused1;
1152         DBT *dbtp;
1153         DB_LSN *lsnp;
1154         int notused3;
1155         void *notused4;
1156 {
1157         __bam_cdel_args *argp;
1158         u_int32_t i;
1159         int c, ret;
1160
1161         i = 0;
1162         c = 0;
1163         notused1 = NULL;
1164         notused3 = 0;
1165         notused4 = NULL;
1166
1167         if ((ret = __bam_cdel_read(dbtp->data, &argp)) != 0)
1168                 return (ret);
1169         printf("[%lu][%lu]bam_cdel: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1170             (u_long)lsnp->file,
1171             (u_long)lsnp->offset,
1172             (u_long)argp->type,
1173             (u_long)argp->txnid->txnid,
1174             (u_long)argp->prev_lsn.file,
1175             (u_long)argp->prev_lsn.offset);
1176         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1177         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1178         printf("\tlsn: [%lu][%lu]\n",
1179             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1180         printf("\tindx: %lu\n", (u_long)argp->indx);
1181         printf("\n");
1182         __db_free(argp);
1183         return (0);
1184 }
1185
1186 /*
1187  * PUBLIC: int __bam_cdel_read __P((void *, __bam_cdel_args **));
1188  */
1189 int
1190 __bam_cdel_read(recbuf, argpp)
1191         void *recbuf;
1192         __bam_cdel_args **argpp;
1193 {
1194         __bam_cdel_args *argp;
1195         u_int8_t *bp;
1196
1197         argp = (__bam_cdel_args *)__db_malloc(sizeof(__bam_cdel_args) +
1198             sizeof(DB_TXN));
1199         if (argp == NULL)
1200                 return (ENOMEM);
1201         argp->txnid = (DB_TXN *)&argp[1];
1202         bp = recbuf;
1203         memcpy(&argp->type, bp, sizeof(argp->type));
1204         bp += sizeof(argp->type);
1205         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1206         bp += sizeof(argp->txnid->txnid);
1207         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1208         bp += sizeof(DB_LSN);
1209         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1210         bp += sizeof(argp->fileid);
1211         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1212         bp += sizeof(argp->pgno);
1213         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1214         bp += sizeof(argp->lsn);
1215         memcpy(&argp->indx, bp, sizeof(argp->indx));
1216         bp += sizeof(argp->indx);
1217         *argpp = argp;
1218         return (0);
1219 }
1220
1221 /*
1222  * PUBLIC: int __bam_repl_log
1223  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1224  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
1225  * PUBLIC:     u_int32_t, DBT *, DBT *, u_int32_t,
1226  * PUBLIC:     u_int32_t));
1227  */
1228 int __bam_repl_log(logp, txnid, ret_lsnp, flags,
1229         fileid, pgno, lsn, indx, isdeleted, orig,
1230         repl, prefix, suffix)
1231         DB_LOG *logp;
1232         DB_TXN *txnid;
1233         DB_LSN *ret_lsnp;
1234         u_int32_t flags;
1235         u_int32_t fileid;
1236         db_pgno_t pgno;
1237         DB_LSN * lsn;
1238         u_int32_t indx;
1239         u_int32_t isdeleted;
1240         DBT *orig;
1241         DBT *repl;
1242         u_int32_t prefix;
1243         u_int32_t suffix;
1244 {
1245         DBT logrec;
1246         DB_LSN *lsnp, null_lsn;
1247         u_int32_t zero;
1248         u_int32_t rectype, txn_num;
1249         int ret;
1250         u_int8_t *bp;
1251
1252         rectype = DB_bam_repl;
1253         txn_num = txnid == NULL ? 0 : txnid->txnid;
1254         if (txnid == NULL) {
1255                 null_lsn.file = 0;
1256                 null_lsn.offset = 0;
1257                 lsnp = &null_lsn;
1258         } else
1259                 lsnp = &txnid->last_lsn;
1260         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1261             + sizeof(fileid)
1262             + sizeof(pgno)
1263             + sizeof(*lsn)
1264             + sizeof(indx)
1265             + sizeof(isdeleted)
1266             + sizeof(u_int32_t) + (orig == NULL ? 0 : orig->size)
1267             + sizeof(u_int32_t) + (repl == NULL ? 0 : repl->size)
1268             + sizeof(prefix)
1269             + sizeof(suffix);
1270         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
1271                 return (ENOMEM);
1272
1273         bp = logrec.data;
1274         memcpy(bp, &rectype, sizeof(rectype));
1275         bp += sizeof(rectype);
1276         memcpy(bp, &txn_num, sizeof(txn_num));
1277         bp += sizeof(txn_num);
1278         memcpy(bp, lsnp, sizeof(DB_LSN));
1279         bp += sizeof(DB_LSN);
1280         memcpy(bp, &fileid, sizeof(fileid));
1281         bp += sizeof(fileid);
1282         memcpy(bp, &pgno, sizeof(pgno));
1283         bp += sizeof(pgno);
1284         if (lsn != NULL)
1285                 memcpy(bp, lsn, sizeof(*lsn));
1286         else
1287                 memset(bp, 0, sizeof(*lsn));
1288         bp += sizeof(*lsn);
1289         memcpy(bp, &indx, sizeof(indx));
1290         bp += sizeof(indx);
1291         memcpy(bp, &isdeleted, sizeof(isdeleted));
1292         bp += sizeof(isdeleted);
1293         if (orig == NULL) {
1294                 zero = 0;
1295                 memcpy(bp, &zero, sizeof(u_int32_t));
1296                 bp += sizeof(u_int32_t);
1297         } else {
1298                 memcpy(bp, &orig->size, sizeof(orig->size));
1299                 bp += sizeof(orig->size);
1300                 memcpy(bp, orig->data, orig->size);
1301                 bp += orig->size;
1302         }
1303         if (repl == NULL) {
1304                 zero = 0;
1305                 memcpy(bp, &zero, sizeof(u_int32_t));
1306                 bp += sizeof(u_int32_t);
1307         } else {
1308                 memcpy(bp, &repl->size, sizeof(repl->size));
1309                 bp += sizeof(repl->size);
1310                 memcpy(bp, repl->data, repl->size);
1311                 bp += repl->size;
1312         }
1313         memcpy(bp, &prefix, sizeof(prefix));
1314         bp += sizeof(prefix);
1315         memcpy(bp, &suffix, sizeof(suffix));
1316         bp += sizeof(suffix);
1317 #ifdef DEBUG
1318         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1319                 fprintf(stderr, "Error in log record length");
1320 #endif
1321         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1322         if (txnid != NULL)
1323                 txnid->last_lsn = *ret_lsnp;
1324         __db_free(logrec.data);
1325         return (ret);
1326 }
1327
1328 /*
1329  * PUBLIC: int __bam_repl_print
1330  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1331  */
1332
1333 int
1334 __bam_repl_print(notused1, dbtp, lsnp, notused3, notused4)
1335         DB_LOG *notused1;
1336         DBT *dbtp;
1337         DB_LSN *lsnp;
1338         int notused3;
1339         void *notused4;
1340 {
1341         __bam_repl_args *argp;
1342         u_int32_t i;
1343         int c, ret;
1344
1345         i = 0;
1346         c = 0;
1347         notused1 = NULL;
1348         notused3 = 0;
1349         notused4 = NULL;
1350
1351         if ((ret = __bam_repl_read(dbtp->data, &argp)) != 0)
1352                 return (ret);
1353         printf("[%lu][%lu]bam_repl: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1354             (u_long)lsnp->file,
1355             (u_long)lsnp->offset,
1356             (u_long)argp->type,
1357             (u_long)argp->txnid->txnid,
1358             (u_long)argp->prev_lsn.file,
1359             (u_long)argp->prev_lsn.offset);
1360         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1361         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1362         printf("\tlsn: [%lu][%lu]\n",
1363             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1364         printf("\tindx: %lu\n", (u_long)argp->indx);
1365         printf("\tisdeleted: %lu\n", (u_long)argp->isdeleted);
1366         printf("\torig: ");
1367         for (i = 0; i < argp->orig.size; i++) {
1368                 c = ((char *)argp->orig.data)[i];
1369                 if (isprint(c) || c == 0xa)
1370                         putchar(c);
1371                 else
1372                         printf("%#x ", c);
1373         }
1374         printf("\n");
1375         printf("\trepl: ");
1376         for (i = 0; i < argp->repl.size; i++) {
1377                 c = ((char *)argp->repl.data)[i];
1378                 if (isprint(c) || c == 0xa)
1379                         putchar(c);
1380                 else
1381                         printf("%#x ", c);
1382         }
1383         printf("\n");
1384         printf("\tprefix: %lu\n", (u_long)argp->prefix);
1385         printf("\tsuffix: %lu\n", (u_long)argp->suffix);
1386         printf("\n");
1387         __db_free(argp);
1388         return (0);
1389 }
1390
1391 /*
1392  * PUBLIC: int __bam_repl_read __P((void *, __bam_repl_args **));
1393  */
1394 int
1395 __bam_repl_read(recbuf, argpp)
1396         void *recbuf;
1397         __bam_repl_args **argpp;
1398 {
1399         __bam_repl_args *argp;
1400         u_int8_t *bp;
1401
1402         argp = (__bam_repl_args *)__db_malloc(sizeof(__bam_repl_args) +
1403             sizeof(DB_TXN));
1404         if (argp == NULL)
1405                 return (ENOMEM);
1406         argp->txnid = (DB_TXN *)&argp[1];
1407         bp = recbuf;
1408         memcpy(&argp->type, bp, sizeof(argp->type));
1409         bp += sizeof(argp->type);
1410         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1411         bp += sizeof(argp->txnid->txnid);
1412         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1413         bp += sizeof(DB_LSN);
1414         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1415         bp += sizeof(argp->fileid);
1416         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1417         bp += sizeof(argp->pgno);
1418         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1419         bp += sizeof(argp->lsn);
1420         memcpy(&argp->indx, bp, sizeof(argp->indx));
1421         bp += sizeof(argp->indx);
1422         memcpy(&argp->isdeleted, bp, sizeof(argp->isdeleted));
1423         bp += sizeof(argp->isdeleted);
1424         memcpy(&argp->orig.size, bp, sizeof(u_int32_t));
1425         bp += sizeof(u_int32_t);
1426         argp->orig.data = bp;
1427         bp += argp->orig.size;
1428         memcpy(&argp->repl.size, bp, sizeof(u_int32_t));
1429         bp += sizeof(u_int32_t);
1430         argp->repl.data = bp;
1431         bp += argp->repl.size;
1432         memcpy(&argp->prefix, bp, sizeof(argp->prefix));
1433         bp += sizeof(argp->prefix);
1434         memcpy(&argp->suffix, bp, sizeof(argp->suffix));
1435         bp += sizeof(argp->suffix);
1436         *argpp = argp;
1437         return (0);
1438 }
1439
1440 /*
1441  * PUBLIC: int __bam_init_print __P((DB_ENV *));
1442  */
1443 int
1444 __bam_init_print(dbenv)
1445         DB_ENV *dbenv;
1446 {
1447         int ret;
1448
1449         if ((ret = __db_add_recovery(dbenv,
1450             __bam_pg_alloc_print, DB_bam_pg_alloc)) != 0)
1451                 return (ret);
1452         if ((ret = __db_add_recovery(dbenv,
1453             __bam_pg_free_print, DB_bam_pg_free)) != 0)
1454                 return (ret);
1455         if ((ret = __db_add_recovery(dbenv,
1456             __bam_split_print, DB_bam_split)) != 0)
1457                 return (ret);
1458         if ((ret = __db_add_recovery(dbenv,
1459             __bam_rsplit_print, DB_bam_rsplit)) != 0)
1460                 return (ret);
1461         if ((ret = __db_add_recovery(dbenv,
1462             __bam_adj_print, DB_bam_adj)) != 0)
1463                 return (ret);
1464         if ((ret = __db_add_recovery(dbenv,
1465             __bam_cadjust_print, DB_bam_cadjust)) != 0)
1466                 return (ret);
1467         if ((ret = __db_add_recovery(dbenv,
1468             __bam_cdel_print, DB_bam_cdel)) != 0)
1469                 return (ret);
1470         if ((ret = __db_add_recovery(dbenv,
1471             __bam_repl_print, DB_bam_repl)) != 0)
1472                 return (ret);
1473         return (0);
1474 }
1475
1476 /*
1477  * PUBLIC: int __bam_init_recover __P((DB_ENV *));
1478  */
1479 int
1480 __bam_init_recover(dbenv)
1481         DB_ENV *dbenv;
1482 {
1483         int ret;
1484
1485         if ((ret = __db_add_recovery(dbenv,
1486             __bam_pg_alloc_recover, DB_bam_pg_alloc)) != 0)
1487                 return (ret);
1488         if ((ret = __db_add_recovery(dbenv,
1489             __bam_pg_free_recover, DB_bam_pg_free)) != 0)
1490                 return (ret);
1491         if ((ret = __db_add_recovery(dbenv,
1492             __bam_split_recover, DB_bam_split)) != 0)
1493                 return (ret);
1494         if ((ret = __db_add_recovery(dbenv,
1495             __bam_rsplit_recover, DB_bam_rsplit)) != 0)
1496                 return (ret);
1497         if ((ret = __db_add_recovery(dbenv,
1498             __bam_adj_recover, DB_bam_adj)) != 0)
1499                 return (ret);
1500         if ((ret = __db_add_recovery(dbenv,
1501             __bam_cadjust_recover, DB_bam_cadjust)) != 0)
1502                 return (ret);
1503         if ((ret = __db_add_recovery(dbenv,
1504             __bam_cdel_recover, DB_bam_cdel)) != 0)
1505                 return (ret);
1506         if ((ret = __db_add_recovery(dbenv,
1507             __bam_repl_recover, DB_bam_repl)) != 0)
1508                 return (ret);
1509         return (0);
1510 }
1511