← Back to branch summary

~ubuntu-branches/ubuntu/edgy/rpm/edgy

« back to all changes in this revision

Viewing changes to db/db/db_auto.c

  • Committer: Bazaar Package Importer
  • Author(s): Joey Hess
  • Date: 2002-01-22 20:56:57 UTC
  • Revision ID: james.westby@ubuntu.com-20020122205657-l74j50mr9z8ofcl5
Tags: upstream-4.0.3
Import upstream version 4.0.3

Show diffs side-by-side

added added

removed removed

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