Lines Matching refs:bp
26 u_int8_t *bp;
32 bp = recbuf;
37 LOGCOPY_32(env, &argp->type, bp);
38 bp += sizeof(argp->type);
40 LOGCOPY_32(env, &argp->txnp->txnid, bp);
41 bp += sizeof(argp->txnp->txnid);
43 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
44 bp += sizeof(DB_LSN);
46 LOGCOPY_32(env, &argp->opcode, bp);
47 bp += sizeof(argp->opcode);
49 LOGCOPY_32(env, &uinttmp, bp);
51 bp += sizeof(uinttmp);
58 LOGCOPY_32(env, &uinttmp, bp);
60 bp += sizeof(uinttmp);
62 LOGCOPY_32(env, &argp->indx, bp);
63 bp += sizeof(argp->indx);
65 LOGCOPY_32(env, &argp->nbytes, bp);
66 bp += sizeof(argp->nbytes);
69 LOGCOPY_32(env,&argp->hdr.size, bp);
70 bp += sizeof(u_int32_t);
71 argp->hdr.data = bp;
72 bp += argp->hdr.size;
75 LOGCOPY_32(env,&argp->dbt.size, bp);
76 bp += sizeof(u_int32_t);
77 argp->dbt.data = bp;
78 bp += argp->dbt.size;
80 LOGCOPY_TOLSN(env, &argp->pagelsn, bp);
81 bp += sizeof(DB_LSN);
114 u_int8_t *bp;
191 bp = logrec.data;
193 LOGCOPY_32(env, bp, &rectype);
194 bp += sizeof(rectype);
196 LOGCOPY_32(env, bp, &txn_num);
197 bp += sizeof(txn_num);
199 LOGCOPY_FROMLSN(env, bp, lsnp);
200 bp += sizeof(DB_LSN);
202 LOGCOPY_32(env, bp, &opcode);
203 bp += sizeof(opcode);
206 LOGCOPY_32(env, bp, &uinttmp);
207 bp += sizeof(uinttmp);
210 LOGCOPY_32(env,bp, &uinttmp);
211 bp += sizeof(uinttmp);
213 LOGCOPY_32(env, bp, &indx);
214 bp += sizeof(indx);
216 LOGCOPY_32(env, bp, &nbytes);
217 bp += sizeof(nbytes);
221 LOGCOPY_32(env, bp, &zero);
222 bp += sizeof(u_int32_t);
224 LOGCOPY_32(env, bp, &hdr->size);
225 bp += sizeof(hdr->size);
226 memcpy(bp, hdr->data, hdr->size);
227 bp += hdr->size;
232 LOGCOPY_32(env, bp, &zero);
233 bp += sizeof(u_int32_t);
235 LOGCOPY_32(env, bp, &dbt->size);
236 bp += sizeof(dbt->size);
237 memcpy(bp, dbt->data, dbt->size);
238 bp += dbt->size;
248 LOGCOPY_FROMLSN(env, bp, pagelsn);
250 memset(bp, 0, sizeof(*pagelsn));
251 bp += sizeof(*pagelsn);
254 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
312 u_int8_t *bp;
318 bp = recbuf;
323 LOGCOPY_32(env, &argp->type, bp);
324 bp += sizeof(argp->type);
326 LOGCOPY_32(env, &argp->txnp->txnid, bp);
327 bp += sizeof(argp->txnp->txnid);
329 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
330 bp += sizeof(DB_LSN);
332 LOGCOPY_32(env, &argp->opcode, bp);
333 bp += sizeof(argp->opcode);
335 LOGCOPY_32(env, &uinttmp, bp);
337 bp += sizeof(uinttmp);
344 LOGCOPY_32(env, &uinttmp, bp);
346 bp += sizeof(uinttmp);
348 LOGCOPY_32(env, &uinttmp, bp);
350 bp += sizeof(uinttmp);
352 LOGCOPY_32(env, &uinttmp, bp);
354 bp += sizeof(uinttmp);
357 LOGCOPY_32(env,&argp->dbt.size, bp);
358 bp += sizeof(u_int32_t);
359 argp->dbt.data = bp;
360 bp += argp->dbt.size;
362 LOGCOPY_TOLSN(env, &argp->pagelsn, bp);
363 bp += sizeof(DB_LSN);
365 LOGCOPY_TOLSN(env, &argp->prevlsn, bp);
366 bp += sizeof(DB_LSN);
368 LOGCOPY_TOLSN(env, &argp->nextlsn, bp);
369 bp += sizeof(DB_LSN);
403 u_int8_t *bp;
481 bp = logrec.data;
483 LOGCOPY_32(env, bp, &rectype);
484 bp += sizeof(rectype);
486 LOGCOPY_32(env, bp, &txn_num);
487 bp += sizeof(txn_num);
489 LOGCOPY_FROMLSN(env, bp, lsnp);
490 bp += sizeof(DB_LSN);
492 LOGCOPY_32(env, bp, &opcode);
493 bp += sizeof(opcode);
496 LOGCOPY_32(env, bp, &uinttmp);
497 bp += sizeof(uinttmp);
500 LOGCOPY_32(env,bp, &uinttmp);
501 bp += sizeof(uinttmp);
504 LOGCOPY_32(env,bp, &uinttmp);
505 bp += sizeof(uinttmp);
508 LOGCOPY_32(env,bp, &uinttmp);
509 bp += sizeof(uinttmp);
513 LOGCOPY_32(env, bp, &zero);
514 bp += sizeof(u_int32_t);
516 LOGCOPY_32(env, bp, &dbt->size);
517 bp += sizeof(dbt->size);
518 memcpy(bp, dbt->data, dbt->size);
519 bp += dbt->size;
529 LOGCOPY_FROMLSN(env, bp, pagelsn);
531 memset(bp, 0, sizeof(*pagelsn));
532 bp += sizeof(*pagelsn);
541 LOGCOPY_FROMLSN(env, bp, prevlsn);
543 memset(bp, 0, sizeof(*prevlsn));
544 bp += sizeof(*prevlsn);
553 LOGCOPY_FROMLSN(env, bp, nextlsn);
555 memset(bp, 0, sizeof(*nextlsn));
556 bp += sizeof(*nextlsn);
559 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
617 u_int8_t *bp;
623 bp = recbuf;
628 LOGCOPY_32(env, &argp->type, bp);
629 bp += sizeof(argp->type);
631 LOGCOPY_32(env, &argp->txnp->txnid, bp);
632 bp += sizeof(argp->txnp->txnid);
634 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
635 bp += sizeof(DB_LSN);
637 LOGCOPY_32(env, &uinttmp, bp);
639 bp += sizeof(uinttmp);
646 LOGCOPY_32(env, &uinttmp, bp);
648 bp += sizeof(uinttmp);
650 LOGCOPY_32(env, &uinttmp, bp);
652 bp += sizeof(uinttmp);
654 LOGCOPY_TOLSN(env, &argp->lsn, bp);
655 bp += sizeof(DB_LSN);
681 u_int8_t *bp;
754 bp = logrec.data;
756 LOGCOPY_32(env, bp, &rectype);
757 bp += sizeof(rectype);
759 LOGCOPY_32(env, bp, &txn_num);
760 bp += sizeof(txn_num);
762 LOGCOPY_FROMLSN(env, bp, lsnp);
763 bp += sizeof(DB_LSN);
766 LOGCOPY_32(env, bp, &uinttmp);
767 bp += sizeof(uinttmp);
770 LOGCOPY_32(env,bp, &uinttmp);
771 bp += sizeof(uinttmp);
774 LOGCOPY_32(env,bp, &uinttmp);
775 bp += sizeof(uinttmp);
784 LOGCOPY_FROMLSN(env, bp, lsn);
786 memset(bp, 0, sizeof(*lsn));
787 bp += sizeof(*lsn);
790 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
848 u_int8_t *bp;
854 bp = recbuf;
859 LOGCOPY_32(env, &argp->type, bp);
860 bp += sizeof(argp->type);
862 LOGCOPY_32(env, &argp->txnp->txnid, bp);
863 bp += sizeof(argp->txnp->txnid);
865 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
866 bp += sizeof(DB_LSN);
868 LOGCOPY_32(env, &argp->opcode, bp);
869 bp += sizeof(argp->opcode);
871 LOGCOPY_32(env, &uinttmp, bp);
873 bp += sizeof(uinttmp);
880 LOGCOPY_32(env, &uinttmp, bp);
882 bp += sizeof(uinttmp);
884 LOGCOPY_TOLSN(env, &argp->lsn, bp);
885 bp += sizeof(DB_LSN);
887 LOGCOPY_32(env, &uinttmp, bp);
889 bp += sizeof(uinttmp);
891 LOGCOPY_TOLSN(env, &argp->lsn_prev, bp);
892 bp += sizeof(DB_LSN);
894 LOGCOPY_32(env, &uinttmp, bp);
896 bp += sizeof(uinttmp);
898 LOGCOPY_TOLSN(env, &argp->lsn_next, bp);
899 bp += sizeof(DB_LSN);
916 u_int8_t *bp;
922 bp = recbuf;
926 LOGCOPY_32(env, &argp->type, bp);
927 bp += sizeof(argp->type);
929 LOGCOPY_32(env, &argp->txnp->txnid, bp);
930 bp += sizeof(argp->txnp->txnid);
932 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
933 bp += sizeof(DB_LSN);
936 LOGCOPY_32(env,&argp->op.size, bp);
937 bp += sizeof(u_int32_t);
938 argp->op.data = bp;
939 bp += argp->op.size;
941 LOGCOPY_32(env, &uinttmp, bp);
943 bp += sizeof(uinttmp);
946 LOGCOPY_32(env,&argp->key.size, bp);
947 bp += sizeof(u_int32_t);
948 argp->key.data = bp;
949 bp += argp->key.size;
952 LOGCOPY_32(env,&argp->data.size, bp);
953 bp += sizeof(u_int32_t);
954 argp->data.data = bp;
955 bp += argp->data.size;
957 LOGCOPY_32(env, &argp->arg_flags, bp);
958 bp += sizeof(argp->arg_flags);
987 u_int8_t *bp;
1053 bp = logrec.data;
1055 LOGCOPY_32(env, bp, &rectype);
1056 bp += sizeof(rectype);
1058 LOGCOPY_32(env, bp, &txn_num);
1059 bp += sizeof(txn_num);
1061 LOGCOPY_FROMLSN(env, bp, lsnp);
1062 bp += sizeof(DB_LSN);
1066 LOGCOPY_32(env, bp, &zero);
1067 bp += sizeof(u_int32_t);
1069 LOGCOPY_32(env, bp, &op->size);
1070 bp += sizeof(op->size);
1071 memcpy(bp, op->data, op->size);
1072 bp += op->size;
1076 LOGCOPY_32(env,bp, &uinttmp);
1077 bp += sizeof(uinttmp);
1081 LOGCOPY_32(env, bp, &zero);
1082 bp += sizeof(u_int32_t);
1084 LOGCOPY_32(env, bp, &key->size);
1085 bp += sizeof(key->size);
1086 memcpy(bp, key->data, key->size);
1087 bp += key->size;
1092 LOGCOPY_32(env, bp, &zero);
1093 bp += sizeof(u_int32_t);
1095 LOGCOPY_32(env, bp, &data->size);
1096 bp += sizeof(data->size);
1097 memcpy(bp, data->data, data->size);
1098 bp += data->size;
1101 LOGCOPY_32(env, bp, &arg_flags);
1102 bp += sizeof(arg_flags);
1105 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
1163 u_int8_t *bp;
1169 bp = recbuf;
1174 LOGCOPY_32(env, &argp->type, bp);
1175 bp += sizeof(argp->type);
1177 LOGCOPY_32(env, &argp->txnp->txnid, bp);
1178 bp += sizeof(argp->txnp->txnid);
1180 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
1181 bp += sizeof(DB_LSN);
1183 LOGCOPY_32(env, &uinttmp, bp);
1185 bp += sizeof(uinttmp);
1192 LOGCOPY_32(env, &uinttmp, bp);
1194 bp += sizeof(uinttmp);
1196 LOGCOPY_TOLSN(env, &argp->prevlsn, bp);
1197 bp += sizeof(DB_LSN);
1222 u_int8_t *bp;
1294 bp = logrec.data;
1296 LOGCOPY_32(env, bp, &rectype);
1297 bp += sizeof(rectype);
1299 LOGCOPY_32(env, bp, &txn_num);
1300 bp += sizeof(txn_num);
1302 LOGCOPY_FROMLSN(env, bp, lsnp);
1303 bp += sizeof(DB_LSN);
1306 LOGCOPY_32(env, bp, &uinttmp);
1307 bp += sizeof(uinttmp);
1310 LOGCOPY_32(env,bp, &uinttmp);
1311 bp += sizeof(uinttmp);
1320 LOGCOPY_FROMLSN(env, bp, prevlsn);
1322 memset(bp, 0, sizeof(*prevlsn));
1323 bp += sizeof(*prevlsn);
1326 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
1384 u_int8_t *bp;
1390 bp = recbuf;
1395 LOGCOPY_32(env, &argp->type, bp);
1396 bp += sizeof(argp->type);
1398 LOGCOPY_32(env, &argp->txnp->txnid, bp);
1399 bp += sizeof(argp->txnp->txnid);
1401 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
1402 bp += sizeof(DB_LSN);
1404 LOGCOPY_32(env, &uinttmp, bp);
1406 bp += sizeof(uinttmp);
1413 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
1414 bp += sizeof(DB_LSN);
1416 LOGCOPY_32(env, &uinttmp, bp);
1418 bp += sizeof(uinttmp);
1420 LOGCOPY_TOLSN(env, &argp->page_lsn, bp);
1421 bp += sizeof(DB_LSN);
1423 LOGCOPY_32(env, &uinttmp, bp);
1425 bp += sizeof(uinttmp);
1427 LOGCOPY_32(env, &argp->ptype, bp);
1428 bp += sizeof(argp->ptype);
1430 LOGCOPY_32(env, &uinttmp, bp);
1432 bp += sizeof(uinttmp);
1452 u_int8_t *bp;
1458 bp = recbuf;
1463 LOGCOPY_32(env, &argp->type, bp);
1464 bp += sizeof(argp->type);
1466 LOGCOPY_32(env, &argp->txnp->txnid, bp);
1467 bp += sizeof(argp->txnp->txnid);
1469 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
1470 bp += sizeof(DB_LSN);
1472 LOGCOPY_32(env, &uinttmp, bp);
1474 bp += sizeof(uinttmp);
1481 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
1482 bp += sizeof(DB_LSN);
1484 LOGCOPY_32(env, &uinttmp, bp);
1486 bp += sizeof(uinttmp);
1488 LOGCOPY_TOLSN(env, &argp->page_lsn, bp);
1489 bp += sizeof(DB_LSN);
1491 LOGCOPY_32(env, &uinttmp, bp);
1493 bp += sizeof(uinttmp);
1495 LOGCOPY_32(env, &argp->ptype, bp);
1496 bp += sizeof(argp->ptype);
1498 LOGCOPY_32(env, &uinttmp, bp);
1500 bp += sizeof(uinttmp);
1502 LOGCOPY_32(env, &uinttmp, bp);
1504 bp += sizeof(uinttmp);
1536 u_int8_t *bp;
1613 bp = logrec.data;
1615 LOGCOPY_32(env, bp, &rectype);
1616 bp += sizeof(rectype);
1618 LOGCOPY_32(env, bp, &txn_num);
1619 bp += sizeof(txn_num);
1621 LOGCOPY_FROMLSN(env, bp, lsnp);
1622 bp += sizeof(DB_LSN);
1625 LOGCOPY_32(env, bp, &uinttmp);
1626 bp += sizeof(uinttmp);
1635 LOGCOPY_FROMLSN(env, bp, meta_lsn);
1637 memset(bp, 0, sizeof(*meta_lsn));
1638 bp += sizeof(*meta_lsn);
1641 LOGCOPY_32(env,bp, &uinttmp);
1642 bp += sizeof(uinttmp);
1651 LOGCOPY_FROMLSN(env, bp, page_lsn);
1653 memset(bp, 0, sizeof(*page_lsn));
1654 bp += sizeof(*page_lsn);
1657 LOGCOPY_32(env,bp, &uinttmp);
1658 bp += sizeof(uinttmp);
1660 LOGCOPY_32(env, bp, &ptype);
1661 bp += sizeof(ptype);
1664 LOGCOPY_32(env,bp, &uinttmp);
1665 bp += sizeof(uinttmp);
1668 LOGCOPY_32(env,bp, &uinttmp);
1669 bp += sizeof(uinttmp);
1672 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
1730 u_int8_t *bp;
1736 bp = recbuf;
1741 LOGCOPY_32(env, &argp->type, bp);
1742 bp += sizeof(argp->type);
1744 LOGCOPY_32(env, &argp->txnp->txnid, bp);
1745 bp += sizeof(argp->txnp->txnid);
1747 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
1748 bp += sizeof(DB_LSN);
1750 LOGCOPY_32(env, &uinttmp, bp);
1752 bp += sizeof(uinttmp);
1759 LOGCOPY_32(env, &uinttmp, bp);
1761 bp += sizeof(uinttmp);
1763 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
1764 bp += sizeof(DB_LSN);
1766 LOGCOPY_32(env, &uinttmp, bp);
1768 bp += sizeof(uinttmp);
1771 LOGCOPY_32(env,&argp->header.size, bp);
1772 bp += sizeof(u_int32_t);
1773 argp->header.data = bp;
1774 bp += argp->header.size;
1776 LOGCOPY_32(env, &uinttmp, bp);
1778 bp += sizeof(uinttmp);
1798 u_int8_t *bp;
1804 bp = recbuf;
1809 LOGCOPY_32(env, &argp->type, bp);
1810 bp += sizeof(argp->type);
1812 LOGCOPY_32(env, &argp->txnp->txnid, bp);
1813 bp += sizeof(argp->txnp->txnid);
1815 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
1816 bp += sizeof(DB_LSN);
1818 LOGCOPY_32(env, &uinttmp, bp);
1820 bp += sizeof(uinttmp);
1827 LOGCOPY_32(env, &uinttmp, bp);
1829 bp += sizeof(uinttmp);
1831 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
1832 bp += sizeof(DB_LSN);
1834 LOGCOPY_32(env, &uinttmp, bp);
1836 bp += sizeof(uinttmp);
1839 LOGCOPY_32(env,&argp->header.size, bp);
1840 bp += sizeof(u_int32_t);
1841 argp->header.data = bp;
1842 bp += argp->header.size;
1850 LOGCOPY_32(env, &uinttmp, bp);
1852 bp += sizeof(uinttmp);
1854 LOGCOPY_32(env, &uinttmp, bp);
1856 bp += sizeof(uinttmp);
1887 u_int8_t *bp;
1963 bp = logrec.data;
1965 LOGCOPY_32(env, bp, &rectype);
1966 bp += sizeof(rectype);
1968 LOGCOPY_32(env, bp, &txn_num);
1969 bp += sizeof(txn_num);
1971 LOGCOPY_FROMLSN(env, bp, lsnp);
1972 bp += sizeof(DB_LSN);
1975 LOGCOPY_32(env, bp, &uinttmp);
1976 bp += sizeof(uinttmp);
1979 LOGCOPY_32(env,bp, &uinttmp);
1980 bp += sizeof(uinttmp);
1989 LOGCOPY_FROMLSN(env, bp, meta_lsn);
1991 memset(bp, 0, sizeof(*meta_lsn));
1992 bp += sizeof(*meta_lsn);
1995 LOGCOPY_32(env,bp, &uinttmp);
1996 bp += sizeof(uinttmp);
2000 LOGCOPY_32(env, bp, &zero);
2001 bp += sizeof(u_int32_t);
2003 LOGCOPY_32(env, bp, &header->size);
2004 bp += sizeof(header->size);
2005 memcpy(bp, header->data, header->size);
2008 (PAGE *)bp, (size_t)header->size, (DBT *)NULL, 0)) != 0)
2010 bp += header->size;
2014 LOGCOPY_32(env,bp, &uinttmp);
2015 bp += sizeof(uinttmp);
2018 LOGCOPY_32(env,bp, &uinttmp);
2019 bp += sizeof(uinttmp);
2022 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
2076 u_int8_t *bp;
2082 bp = recbuf;
2086 LOGCOPY_32(env, &argp->type, bp);
2087 bp += sizeof(argp->type);
2089 LOGCOPY_32(env, &argp->txnp->txnid, bp);
2090 bp += sizeof(argp->txnp->txnid);
2092 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
2093 bp += sizeof(DB_LSN);
2114 u_int8_t *bp;
2178 bp = logrec.data;
2180 LOGCOPY_32(env, bp, &rectype);
2181 bp += sizeof(rectype);
2183 LOGCOPY_32(env, bp, &txn_num);
2184 bp += sizeof(txn_num);
2186 LOGCOPY_FROMLSN(env, bp, lsnp);
2187 bp += sizeof(DB_LSN);
2190 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
2248 u_int8_t *bp;
2254 bp = recbuf;
2259 LOGCOPY_32(env, &argp->type, bp);
2260 bp += sizeof(argp->type);
2262 LOGCOPY_32(env, &argp->txnp->txnid, bp);
2263 bp += sizeof(argp->txnp->txnid);
2265 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
2266 bp += sizeof(DB_LSN);
2268 LOGCOPY_32(env, &uinttmp, bp);
2270 bp += sizeof(uinttmp);
2277 LOGCOPY_32(env, &uinttmp, bp);
2279 bp += sizeof(uinttmp);
2281 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
2282 bp += sizeof(DB_LSN);
2284 LOGCOPY_32(env, &uinttmp, bp);
2286 bp += sizeof(uinttmp);
2289 LOGCOPY_32(env,&argp->header.size, bp);
2290 bp += sizeof(u_int32_t);
2291 argp->header.data = bp;
2292 bp += argp->header.size;
2294 LOGCOPY_32(env, &uinttmp, bp);
2296 bp += sizeof(uinttmp);
2299 LOGCOPY_32(env,&argp->data.size, bp);
2300 bp += sizeof(u_int32_t);
2301 argp->data.data = bp;
2302 bp += argp->data.size;
2322 u_int8_t *bp;
2328 bp = recbuf;
2333 LOGCOPY_32(env, &argp->type, bp);
2334 bp += sizeof(argp->type);
2336 LOGCOPY_32(env, &argp->txnp->txnid, bp);
2337 bp += sizeof(argp->txnp->txnid);
2339 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
2340 bp += sizeof(DB_LSN);
2342 LOGCOPY_32(env, &uinttmp, bp);
2344 bp += sizeof(uinttmp);
2351 LOGCOPY_32(env, &uinttmp, bp);
2353 bp += sizeof(uinttmp);
2355 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
2356 bp += sizeof(DB_LSN);
2358 LOGCOPY_32(env, &uinttmp, bp);
2360 bp += sizeof(uinttmp);
2363 LOGCOPY_32(env,&argp->header.size, bp);
2364 bp += sizeof(u_int32_t);
2365 argp->header.data = bp;
2366 bp += argp->header.size;
2368 LOGCOPY_32(env, &uinttmp, bp);
2370 bp += sizeof(uinttmp);
2372 LOGCOPY_32(env, &uinttmp, bp);
2374 bp += sizeof(uinttmp);
2377 LOGCOPY_32(env,&argp->data.size, bp);
2378 bp += sizeof(u_int32_t);
2379 argp->data.data = bp;
2380 bp += argp->data.size;
2419 u_int8_t *bp;
2496 bp = logrec.data;
2498 LOGCOPY_32(env, bp, &rectype);
2499 bp += sizeof(rectype);
2501 LOGCOPY_32(env, bp, &txn_num);
2502 bp += sizeof(txn_num);
2504 LOGCOPY_FROMLSN(env, bp, lsnp);
2505 bp += sizeof(DB_LSN);
2508 LOGCOPY_32(env, bp, &uinttmp);
2509 bp += sizeof(uinttmp);
2512 LOGCOPY_32(env,bp, &uinttmp);
2513 bp += sizeof(uinttmp);
2522 LOGCOPY_FROMLSN(env, bp, meta_lsn);
2524 memset(bp, 0, sizeof(*meta_lsn));
2525 bp += sizeof(*meta_lsn);
2528 LOGCOPY_32(env,bp, &uinttmp);
2529 bp += sizeof(uinttmp);
2533 LOGCOPY_32(env, bp, &zero);
2534 bp += sizeof(u_int32_t);
2536 LOGCOPY_32(env, bp, &header->size);
2537 bp += sizeof(header->size);
2538 memcpy(bp, header->data, header->size);
2541 (PAGE *)bp, (size_t)header->size, (DBT *)data, 0)) != 0)
2543 bp += header->size;
2547 LOGCOPY_32(env,bp, &uinttmp);
2548 bp += sizeof(uinttmp);
2551 LOGCOPY_32(env,bp, &uinttmp);
2552 bp += sizeof(uinttmp);
2556 LOGCOPY_32(env, bp, &zero);
2557 bp += sizeof(u_int32_t);
2559 LOGCOPY_32(env, bp, &data->size);
2560 bp += sizeof(data->size);
2561 memcpy(bp, data->data, data->size);
2564 bp += data->size;
2568 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
2626 u_int8_t *bp;
2632 bp = recbuf;
2637 LOGCOPY_32(env, &argp->type, bp);
2638 bp += sizeof(argp->type);
2640 LOGCOPY_32(env, &argp->txnp->txnid, bp);
2641 bp += sizeof(argp->txnp->txnid);
2643 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
2644 bp += sizeof(DB_LSN);
2646 LOGCOPY_32(env, &uinttmp, bp);
2648 bp += sizeof(uinttmp);
2655 LOGCOPY_32(env, &uinttmp, bp);
2657 bp += sizeof(uinttmp);
2660 LOGCOPY_32(env,&argp->header.size, bp);
2661 bp += sizeof(u_int32_t);
2662 argp->header.data = bp;
2663 bp += argp->header.size;
2666 LOGCOPY_32(env,&argp->data.size, bp);
2667 bp += sizeof(u_int32_t);
2668 argp->data.data = bp;
2669 bp += argp->data.size;
2702 u_int8_t *bp;
2775 bp = logrec.data;
2777 LOGCOPY_32(env, bp, &rectype);
2778 bp += sizeof(rectype);
2780 LOGCOPY_32(env, bp, &txn_num);
2781 bp += sizeof(txn_num);
2783 LOGCOPY_FROMLSN(env, bp, lsnp);
2784 bp += sizeof(DB_LSN);
2787 LOGCOPY_32(env, bp, &uinttmp);
2788 bp += sizeof(uinttmp);
2791 LOGCOPY_32(env,bp, &uinttmp);
2792 bp += sizeof(uinttmp);
2796 LOGCOPY_32(env, bp, &zero);
2797 bp += sizeof(u_int32_t);
2799 LOGCOPY_32(env, bp, &header->size);
2800 bp += sizeof(header->size);
2801 memcpy(bp, header->data, header->size);
2804 (PAGE *)bp, (size_t)header->size, (DBT *)data, 0)) != 0)
2806 bp += header->size;
2811 LOGCOPY_32(env, bp, &zero);
2812 bp += sizeof(u_int32_t);
2814 LOGCOPY_32(env, bp, &data->size);
2815 bp += sizeof(data->size);
2816 memcpy(bp, data->data, data->size);
2819 bp += data->size;
2823 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
2881 u_int8_t *bp;
2887 bp = recbuf;
2892 LOGCOPY_32(env, &argp->type, bp);
2893 bp += sizeof(argp->type);
2895 LOGCOPY_32(env, &argp->txnp->txnid, bp);
2896 bp += sizeof(argp->txnp->txnid);
2898 LOGCOPY_TOLSN(env, &argp->prev_lsn, bp);
2899 bp += sizeof(DB_LSN);
2901 LOGCOPY_32(env, &uinttmp, bp);
2903 bp += sizeof(uinttmp);
2910 LOGCOPY_32(env, &uinttmp, bp);
2912 bp += sizeof(uinttmp);
2914 LOGCOPY_TOLSN(env, &argp->meta_lsn, bp);
2915 bp += sizeof(DB_LSN);
2917 LOGCOPY_32(env, &uinttmp, bp);
2919 bp += sizeof(uinttmp);
2921 LOGCOPY_TOLSN(env, &argp->last_lsn, bp);
2922 bp += sizeof(DB_LSN);
2924 LOGCOPY_32(env, &uinttmp, bp);
2926 bp += sizeof(uinttmp);
2929 LOGCOPY_32(env,&argp->list.size, bp);
2930 bp += sizeof(u_int32_t);
2931 argp->list.data = bp;
2932 bp += argp->list.size;
2963 u_int8_t *bp;
3039 bp = logrec.data;
3041 LOGCOPY_32(env, bp, &rectype);
3042 bp += sizeof(rectype);
3044 LOGCOPY_32(env, bp, &txn_num);
3045 bp += sizeof(txn_num);
3047 LOGCOPY_FROMLSN(env, bp, lsnp);
3048 bp += sizeof(DB_LSN);
3051 LOGCOPY_32(env, bp, &uinttmp);
3052 bp += sizeof(uinttmp);
3055 LOGCOPY_32(env,bp, &uinttmp);
3056 bp += sizeof(uinttmp);
3065 LOGCOPY_FROMLSN(env, bp, meta_lsn);
3067 memset(bp, 0, sizeof(*meta_lsn));
3068 bp += sizeof(*meta_lsn);
3071 LOGCOPY_32(env,bp, &uinttmp);
3072 bp += sizeof(uinttmp);
3081 LOGCOPY_FROMLSN(env, bp, last_lsn);
3083 memset(bp, 0, sizeof(*last_lsn));
3084 bp += sizeof(*last_lsn);
3087 LOGCOPY_32(env,bp, &uinttmp);
3088 bp += sizeof(uinttmp);
3092 LOGCOPY_32(env, bp, &zero);
3093 bp += sizeof(u_int32_t);
3095 LOGCOPY_32(env, bp, &list->size);
3096 bp += sizeof(list->size);
3097 memcpy(bp, list->data, list->size);
3098 bp += list->size;
3102 (u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);