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