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