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