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