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