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