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