hash_auto.c

Go to the documentation of this file.
00001 /* Do not edit: automatically built by gen_rec.awk. */
00002 #include "config.h"
00003 
00004 #ifndef NO_SYSTEM_INCLUDES
00005 #include <sys/types.h>
00006 
00007 #include <ctype.h>
00008 #include <errno.h>
00009 #include <string.h>
00010 #endif
00011 
00012 #include "db_int.h"
00013 #include "db_page.h"
00014 #include "db_dispatch.h"
00015 #include "db_am.h"
00016 #include "hash.h"
00017 #include "txn.h"
00018 
00019 int CDB___ham_insdel_log(dbenv, txnid, ret_lsnp, flags,
00020         opcode, fileid, pgno, ndx, pagelsn, key,
00021         data)
00022         DB_ENV *dbenv;
00023         DB_TXN *txnid;
00024         DB_LSN *ret_lsnp;
00025         u_int32_t flags;
00026         u_int32_t opcode;
00027         int32_t fileid;
00028         db_pgno_t pgno;
00029         u_int32_t ndx;
00030         DB_LSN * pagelsn;
00031         const DBT *key;
00032         const DBT *data;
00033 {
00034         DBT logrec;
00035         DB_LSN *lsnp, null_lsn;
00036         u_int32_t zero;
00037         u_int32_t rectype, txn_num;
00038         int ret;
00039         u_int8_t *bp;
00040 
00041         if (txnid != NULL &&
00042             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
00043                 return (CDB___db_child_active_err(dbenv));
00044         rectype = DB_ham_insdel;
00045         txn_num = txnid == NULL ? 0 : txnid->txnid;
00046         if (txnid == NULL) {
00047                 ZERO_LSN(null_lsn);
00048                 lsnp = &null_lsn;
00049         } else
00050                 lsnp = &txnid->last_lsn;
00051         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
00052             + sizeof(opcode)
00053             + sizeof(fileid)
00054             + sizeof(pgno)
00055             + sizeof(ndx)
00056             + sizeof(*pagelsn)
00057             + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
00058             + sizeof(u_int32_t) + (data == NULL ? 0 : data->size);
00059         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
00060                 return (ret);
00061 
00062         bp = logrec.data;
00063         memcpy(bp, &rectype, sizeof(rectype));
00064         bp += sizeof(rectype);
00065         memcpy(bp, &txn_num, sizeof(txn_num));
00066         bp += sizeof(txn_num);
00067         memcpy(bp, lsnp, sizeof(DB_LSN));
00068         bp += sizeof(DB_LSN);
00069         memcpy(bp, &opcode, sizeof(opcode));
00070         bp += sizeof(opcode);
00071         memcpy(bp, &fileid, sizeof(fileid));
00072         bp += sizeof(fileid);
00073         memcpy(bp, &pgno, sizeof(pgno));
00074         bp += sizeof(pgno);
00075         memcpy(bp, &ndx, sizeof(ndx));
00076         bp += sizeof(ndx);
00077         if (pagelsn != NULL)
00078                 memcpy(bp, pagelsn, sizeof(*pagelsn));
00079         else
00080                 memset(bp, 0, sizeof(*pagelsn));
00081         bp += sizeof(*pagelsn);
00082         if (key == NULL) {
00083                 zero = 0;
00084                 memcpy(bp, &zero, sizeof(u_int32_t));
00085                 bp += sizeof(u_int32_t);
00086         } else {
00087                 memcpy(bp, &key->size, sizeof(key->size));
00088                 bp += sizeof(key->size);
00089                 memcpy(bp, key->data, key->size);
00090                 bp += key->size;
00091         }
00092         if (data == NULL) {
00093                 zero = 0;
00094                 memcpy(bp, &zero, sizeof(u_int32_t));
00095                 bp += sizeof(u_int32_t);
00096         } else {
00097                 memcpy(bp, &data->size, sizeof(data->size));
00098                 bp += sizeof(data->size);
00099                 memcpy(bp, data->data, data->size);
00100                 bp += data->size;
00101         }
00102         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
00103         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
00104         if (txnid != NULL)
00105                 txnid->last_lsn = *ret_lsnp;
00106         CDB___os_free(logrec.data, logrec.size);
00107         return (ret);
00108 }
00109 
00110 int
00111 CDB___ham_insdel_print(dbenv, dbtp, lsnp, notused2, notused3)
00112         DB_ENV *dbenv;
00113         DBT *dbtp;
00114         DB_LSN *lsnp;
00115         db_recops notused2;
00116         void *notused3;
00117 {
00118         __ham_insdel_args *argp;
00119         u_int32_t i;
00120         u_int ch;
00121         int ret;
00122 
00123         i = 0;
00124         ch = 0;
00125         notused2 = 0;
00126         notused3 = NULL;
00127 
00128         if ((ret = CDB___ham_insdel_read(dbenv, dbtp->data, &argp)) != 0)
00129                 return (ret);
00130         printf("[%lu][%lu]ham_insdel: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00131             (u_long)lsnp->file,
00132             (u_long)lsnp->offset,
00133             (u_long)argp->type,
00134             (u_long)argp->txnid->txnid,
00135             (u_long)argp->prev_lsn.file,
00136             (u_long)argp->prev_lsn.offset);
00137         printf("\topcode: %lu\n", (u_long)argp->opcode);
00138         printf("\tfileid: %ld\n", (long)argp->fileid);
00139         printf("\tpgno: %lu\n", (u_long)argp->pgno);
00140         printf("\tndx: %lu\n", (u_long)argp->ndx);
00141         printf("\tpagelsn: [%lu][%lu]\n",
00142             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
00143         printf("\tkey: ");
00144         for (i = 0; i < argp->key.size; i++) {
00145                 ch = ((u_int8_t *)argp->key.data)[i];
00146                 if (isprint(ch) || ch == 0xa)
00147                         putchar(ch);
00148                 else
00149                         printf("%#x ", ch);
00150         }
00151         printf("\n");
00152         printf("\tdata: ");
00153         for (i = 0; i < argp->data.size; i++) {
00154                 ch = ((u_int8_t *)argp->data.data)[i];
00155                 if (isprint(ch) || ch == 0xa)
00156                         putchar(ch);
00157                 else
00158                         printf("%#x ", ch);
00159         }
00160         printf("\n");
00161         printf("\n");
00162         CDB___os_free(argp, 0);
00163         return (0);
00164 }
00165 
00166 int
00167 CDB___ham_insdel_read(dbenv, recbuf, argpp)
00168         DB_ENV *dbenv;
00169         void *recbuf;
00170         __ham_insdel_args **argpp;
00171 {
00172         __ham_insdel_args *argp;
00173         u_int8_t *bp;
00174         int ret;
00175 
00176         ret = CDB___os_malloc(dbenv, sizeof(__ham_insdel_args) +
00177             sizeof(DB_TXN), NULL, &argp);
00178         if (ret != 0)
00179                 return (ret);
00180         argp->txnid = (DB_TXN *)&argp[1];
00181         bp = recbuf;
00182         memcpy(&argp->type, bp, sizeof(argp->type));
00183         bp += sizeof(argp->type);
00184         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00185         bp += sizeof(argp->txnid->txnid);
00186         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00187         bp += sizeof(DB_LSN);
00188         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
00189         bp += sizeof(argp->opcode);
00190         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00191         bp += sizeof(argp->fileid);
00192         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
00193         bp += sizeof(argp->pgno);
00194         memcpy(&argp->ndx, bp, sizeof(argp->ndx));
00195         bp += sizeof(argp->ndx);
00196         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
00197         bp += sizeof(argp->pagelsn);
00198         memset(&argp->key, 0, sizeof(argp->key));
00199         memcpy(&argp->key.size, bp, sizeof(u_int32_t));
00200         bp += sizeof(u_int32_t);
00201         argp->key.data = bp;
00202         bp += argp->key.size;
00203         memset(&argp->data, 0, sizeof(argp->data));
00204         memcpy(&argp->data.size, bp, sizeof(u_int32_t));
00205         bp += sizeof(u_int32_t);
00206         argp->data.data = bp;
00207         bp += argp->data.size;
00208         *argpp = argp;
00209         return (0);
00210 }
00211 
00212 int CDB___ham_newpage_log(dbenv, txnid, ret_lsnp, flags,
00213         opcode, fileid, prev_pgno, prevlsn, new_pgno, pagelsn,
00214         next_pgno, nextlsn)
00215         DB_ENV *dbenv;
00216         DB_TXN *txnid;
00217         DB_LSN *ret_lsnp;
00218         u_int32_t flags;
00219         u_int32_t opcode;
00220         int32_t fileid;
00221         db_pgno_t prev_pgno;
00222         DB_LSN * prevlsn;
00223         db_pgno_t new_pgno;
00224         DB_LSN * pagelsn;
00225         db_pgno_t next_pgno;
00226         DB_LSN * nextlsn;
00227 {
00228         DBT logrec;
00229         DB_LSN *lsnp, null_lsn;
00230         u_int32_t rectype, txn_num;
00231         int ret;
00232         u_int8_t *bp;
00233 
00234         if (txnid != NULL &&
00235             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
00236                 return (CDB___db_child_active_err(dbenv));
00237         rectype = DB_ham_newpage;
00238         txn_num = txnid == NULL ? 0 : txnid->txnid;
00239         if (txnid == NULL) {
00240                 ZERO_LSN(null_lsn);
00241                 lsnp = &null_lsn;
00242         } else
00243                 lsnp = &txnid->last_lsn;
00244         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
00245             + sizeof(opcode)
00246             + sizeof(fileid)
00247             + sizeof(prev_pgno)
00248             + sizeof(*prevlsn)
00249             + sizeof(new_pgno)
00250             + sizeof(*pagelsn)
00251             + sizeof(next_pgno)
00252             + sizeof(*nextlsn);
00253         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
00254                 return (ret);
00255 
00256         bp = logrec.data;
00257         memcpy(bp, &rectype, sizeof(rectype));
00258         bp += sizeof(rectype);
00259         memcpy(bp, &txn_num, sizeof(txn_num));
00260         bp += sizeof(txn_num);
00261         memcpy(bp, lsnp, sizeof(DB_LSN));
00262         bp += sizeof(DB_LSN);
00263         memcpy(bp, &opcode, sizeof(opcode));
00264         bp += sizeof(opcode);
00265         memcpy(bp, &fileid, sizeof(fileid));
00266         bp += sizeof(fileid);
00267         memcpy(bp, &prev_pgno, sizeof(prev_pgno));
00268         bp += sizeof(prev_pgno);
00269         if (prevlsn != NULL)
00270                 memcpy(bp, prevlsn, sizeof(*prevlsn));
00271         else
00272                 memset(bp, 0, sizeof(*prevlsn));
00273         bp += sizeof(*prevlsn);
00274         memcpy(bp, &new_pgno, sizeof(new_pgno));
00275         bp += sizeof(new_pgno);
00276         if (pagelsn != NULL)
00277                 memcpy(bp, pagelsn, sizeof(*pagelsn));
00278         else
00279                 memset(bp, 0, sizeof(*pagelsn));
00280         bp += sizeof(*pagelsn);
00281         memcpy(bp, &next_pgno, sizeof(next_pgno));
00282         bp += sizeof(next_pgno);
00283         if (nextlsn != NULL)
00284                 memcpy(bp, nextlsn, sizeof(*nextlsn));
00285         else
00286                 memset(bp, 0, sizeof(*nextlsn));
00287         bp += sizeof(*nextlsn);
00288         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
00289         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
00290         if (txnid != NULL)
00291                 txnid->last_lsn = *ret_lsnp;
00292         CDB___os_free(logrec.data, logrec.size);
00293         return (ret);
00294 }
00295 
00296 int
00297 CDB___ham_newpage_print(dbenv, dbtp, lsnp, notused2, notused3)
00298         DB_ENV *dbenv;
00299         DBT *dbtp;
00300         DB_LSN *lsnp;
00301         db_recops notused2;
00302         void *notused3;
00303 {
00304         __ham_newpage_args *argp;
00305         u_int32_t i;
00306         u_int ch;
00307         int ret;
00308 
00309         i = 0;
00310         ch = 0;
00311         notused2 = 0;
00312         notused3 = NULL;
00313 
00314         if ((ret = CDB___ham_newpage_read(dbenv, dbtp->data, &argp)) != 0)
00315                 return (ret);
00316         printf("[%lu][%lu]ham_newpage: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00317             (u_long)lsnp->file,
00318             (u_long)lsnp->offset,
00319             (u_long)argp->type,
00320             (u_long)argp->txnid->txnid,
00321             (u_long)argp->prev_lsn.file,
00322             (u_long)argp->prev_lsn.offset);
00323         printf("\topcode: %lu\n", (u_long)argp->opcode);
00324         printf("\tfileid: %ld\n", (long)argp->fileid);
00325         printf("\tprev_pgno: %lu\n", (u_long)argp->prev_pgno);
00326         printf("\tprevlsn: [%lu][%lu]\n",
00327             (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
00328         printf("\tnew_pgno: %lu\n", (u_long)argp->new_pgno);
00329         printf("\tpagelsn: [%lu][%lu]\n",
00330             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
00331         printf("\tnext_pgno: %lu\n", (u_long)argp->next_pgno);
00332         printf("\tnextlsn: [%lu][%lu]\n",
00333             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
00334         printf("\n");
00335         CDB___os_free(argp, 0);
00336         return (0);
00337 }
00338 
00339 int
00340 CDB___ham_newpage_read(dbenv, recbuf, argpp)
00341         DB_ENV *dbenv;
00342         void *recbuf;
00343         __ham_newpage_args **argpp;
00344 {
00345         __ham_newpage_args *argp;
00346         u_int8_t *bp;
00347         int ret;
00348 
00349         ret = CDB___os_malloc(dbenv, sizeof(__ham_newpage_args) +
00350             sizeof(DB_TXN), NULL, &argp);
00351         if (ret != 0)
00352                 return (ret);
00353         argp->txnid = (DB_TXN *)&argp[1];
00354         bp = recbuf;
00355         memcpy(&argp->type, bp, sizeof(argp->type));
00356         bp += sizeof(argp->type);
00357         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00358         bp += sizeof(argp->txnid->txnid);
00359         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00360         bp += sizeof(DB_LSN);
00361         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
00362         bp += sizeof(argp->opcode);
00363         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00364         bp += sizeof(argp->fileid);
00365         memcpy(&argp->prev_pgno, bp, sizeof(argp->prev_pgno));
00366         bp += sizeof(argp->prev_pgno);
00367         memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
00368         bp += sizeof(argp->prevlsn);
00369         memcpy(&argp->new_pgno, bp, sizeof(argp->new_pgno));
00370         bp += sizeof(argp->new_pgno);
00371         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
00372         bp += sizeof(argp->pagelsn);
00373         memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
00374         bp += sizeof(argp->next_pgno);
00375         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
00376         bp += sizeof(argp->nextlsn);
00377         *argpp = argp;
00378         return (0);
00379 }
00380 
00381 int
00382 CDB___ham_splitmeta_print(dbenv, dbtp, lsnp, notused2, notused3)
00383         DB_ENV *dbenv;
00384         DBT *dbtp;
00385         DB_LSN *lsnp;
00386         db_recops notused2;
00387         void *notused3;
00388 {
00389         __ham_splitmeta_args *argp;
00390         u_int32_t i;
00391         u_int ch;
00392         int ret;
00393 
00394         i = 0;
00395         ch = 0;
00396         notused2 = 0;
00397         notused3 = NULL;
00398 
00399         if ((ret = CDB___ham_splitmeta_read(dbenv, dbtp->data, &argp)) != 0)
00400                 return (ret);
00401         printf("[%lu][%lu]ham_splitmeta: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00402             (u_long)lsnp->file,
00403             (u_long)lsnp->offset,
00404             (u_long)argp->type,
00405             (u_long)argp->txnid->txnid,
00406             (u_long)argp->prev_lsn.file,
00407             (u_long)argp->prev_lsn.offset);
00408         printf("\tfileid: %ld\n", (long)argp->fileid);
00409         printf("\tbucket: %lu\n", (u_long)argp->bucket);
00410         printf("\tovflpoint: %lu\n", (u_long)argp->ovflpoint);
00411         printf("\tspares: %lu\n", (u_long)argp->spares);
00412         printf("\tmetalsn: [%lu][%lu]\n",
00413             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
00414         printf("\n");
00415         CDB___os_free(argp, 0);
00416         return (0);
00417 }
00418 
00419 int
00420 CDB___ham_splitmeta_read(dbenv, recbuf, argpp)
00421         DB_ENV *dbenv;
00422         void *recbuf;
00423         __ham_splitmeta_args **argpp;
00424 {
00425         __ham_splitmeta_args *argp;
00426         u_int8_t *bp;
00427         int ret;
00428 
00429         ret = CDB___os_malloc(dbenv, sizeof(__ham_splitmeta_args) +
00430             sizeof(DB_TXN), NULL, &argp);
00431         if (ret != 0)
00432                 return (ret);
00433         argp->txnid = (DB_TXN *)&argp[1];
00434         bp = recbuf;
00435         memcpy(&argp->type, bp, sizeof(argp->type));
00436         bp += sizeof(argp->type);
00437         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00438         bp += sizeof(argp->txnid->txnid);
00439         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00440         bp += sizeof(DB_LSN);
00441         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00442         bp += sizeof(argp->fileid);
00443         memcpy(&argp->bucket, bp, sizeof(argp->bucket));
00444         bp += sizeof(argp->bucket);
00445         memcpy(&argp->ovflpoint, bp, sizeof(argp->ovflpoint));
00446         bp += sizeof(argp->ovflpoint);
00447         memcpy(&argp->spares, bp, sizeof(argp->spares));
00448         bp += sizeof(argp->spares);
00449         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
00450         bp += sizeof(argp->metalsn);
00451         *argpp = argp;
00452         return (0);
00453 }
00454 
00455 int CDB___ham_splitdata_log(dbenv, txnid, ret_lsnp, flags,
00456         fileid, opcode, pgno, pageimage, pagelsn)
00457         DB_ENV *dbenv;
00458         DB_TXN *txnid;
00459         DB_LSN *ret_lsnp;
00460         u_int32_t flags;
00461         int32_t fileid;
00462         u_int32_t opcode;
00463         db_pgno_t pgno;
00464         const DBT *pageimage;
00465         DB_LSN * pagelsn;
00466 {
00467         DBT logrec;
00468         DB_LSN *lsnp, null_lsn;
00469         u_int32_t zero;
00470         u_int32_t rectype, txn_num;
00471         int ret;
00472         u_int8_t *bp;
00473 
00474         if (txnid != NULL &&
00475             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
00476                 return (CDB___db_child_active_err(dbenv));
00477         rectype = DB_ham_splitdata;
00478         txn_num = txnid == NULL ? 0 : txnid->txnid;
00479         if (txnid == NULL) {
00480                 ZERO_LSN(null_lsn);
00481                 lsnp = &null_lsn;
00482         } else
00483                 lsnp = &txnid->last_lsn;
00484         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
00485             + sizeof(fileid)
00486             + sizeof(opcode)
00487             + sizeof(pgno)
00488             + sizeof(u_int32_t) + (pageimage == NULL ? 0 : pageimage->size)
00489             + sizeof(*pagelsn);
00490         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
00491                 return (ret);
00492 
00493         bp = logrec.data;
00494         memcpy(bp, &rectype, sizeof(rectype));
00495         bp += sizeof(rectype);
00496         memcpy(bp, &txn_num, sizeof(txn_num));
00497         bp += sizeof(txn_num);
00498         memcpy(bp, lsnp, sizeof(DB_LSN));
00499         bp += sizeof(DB_LSN);
00500         memcpy(bp, &fileid, sizeof(fileid));
00501         bp += sizeof(fileid);
00502         memcpy(bp, &opcode, sizeof(opcode));
00503         bp += sizeof(opcode);
00504         memcpy(bp, &pgno, sizeof(pgno));
00505         bp += sizeof(pgno);
00506         if (pageimage == NULL) {
00507                 zero = 0;
00508                 memcpy(bp, &zero, sizeof(u_int32_t));
00509                 bp += sizeof(u_int32_t);
00510         } else {
00511                 memcpy(bp, &pageimage->size, sizeof(pageimage->size));
00512                 bp += sizeof(pageimage->size);
00513                 memcpy(bp, pageimage->data, pageimage->size);
00514                 bp += pageimage->size;
00515         }
00516         if (pagelsn != NULL)
00517                 memcpy(bp, pagelsn, sizeof(*pagelsn));
00518         else
00519                 memset(bp, 0, sizeof(*pagelsn));
00520         bp += sizeof(*pagelsn);
00521         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
00522         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
00523         if (txnid != NULL)
00524                 txnid->last_lsn = *ret_lsnp;
00525         CDB___os_free(logrec.data, logrec.size);
00526         return (ret);
00527 }
00528 
00529 int
00530 CDB___ham_splitdata_print(dbenv, dbtp, lsnp, notused2, notused3)
00531         DB_ENV *dbenv;
00532         DBT *dbtp;
00533         DB_LSN *lsnp;
00534         db_recops notused2;
00535         void *notused3;
00536 {
00537         __ham_splitdata_args *argp;
00538         u_int32_t i;
00539         u_int ch;
00540         int ret;
00541 
00542         i = 0;
00543         ch = 0;
00544         notused2 = 0;
00545         notused3 = NULL;
00546 
00547         if ((ret = CDB___ham_splitdata_read(dbenv, dbtp->data, &argp)) != 0)
00548                 return (ret);
00549         printf("[%lu][%lu]ham_splitdata: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00550             (u_long)lsnp->file,
00551             (u_long)lsnp->offset,
00552             (u_long)argp->type,
00553             (u_long)argp->txnid->txnid,
00554             (u_long)argp->prev_lsn.file,
00555             (u_long)argp->prev_lsn.offset);
00556         printf("\tfileid: %ld\n", (long)argp->fileid);
00557         printf("\topcode: %lu\n", (u_long)argp->opcode);
00558         printf("\tpgno: %lu\n", (u_long)argp->pgno);
00559         printf("\tpageimage: ");
00560         for (i = 0; i < argp->pageimage.size; i++) {
00561                 ch = ((u_int8_t *)argp->pageimage.data)[i];
00562                 if (isprint(ch) || ch == 0xa)
00563                         putchar(ch);
00564                 else
00565                         printf("%#x ", ch);
00566         }
00567         printf("\n");
00568         printf("\tpagelsn: [%lu][%lu]\n",
00569             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
00570         printf("\n");
00571         CDB___os_free(argp, 0);
00572         return (0);
00573 }
00574 
00575 int
00576 CDB___ham_splitdata_read(dbenv, recbuf, argpp)
00577         DB_ENV *dbenv;
00578         void *recbuf;
00579         __ham_splitdata_args **argpp;
00580 {
00581         __ham_splitdata_args *argp;
00582         u_int8_t *bp;
00583         int ret;
00584 
00585         ret = CDB___os_malloc(dbenv, sizeof(__ham_splitdata_args) +
00586             sizeof(DB_TXN), NULL, &argp);
00587         if (ret != 0)
00588                 return (ret);
00589         argp->txnid = (DB_TXN *)&argp[1];
00590         bp = recbuf;
00591         memcpy(&argp->type, bp, sizeof(argp->type));
00592         bp += sizeof(argp->type);
00593         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00594         bp += sizeof(argp->txnid->txnid);
00595         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00596         bp += sizeof(DB_LSN);
00597         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00598         bp += sizeof(argp->fileid);
00599         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
00600         bp += sizeof(argp->opcode);
00601         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
00602         bp += sizeof(argp->pgno);
00603         memset(&argp->pageimage, 0, sizeof(argp->pageimage));
00604         memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
00605         bp += sizeof(u_int32_t);
00606         argp->pageimage.data = bp;
00607         bp += argp->pageimage.size;
00608         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
00609         bp += sizeof(argp->pagelsn);
00610         *argpp = argp;
00611         return (0);
00612 }
00613 
00614 int CDB___ham_replace_log(dbenv, txnid, ret_lsnp, flags,
00615         fileid, pgno, ndx, pagelsn, off, olditem,
00616         newitem, makedup)
00617         DB_ENV *dbenv;
00618         DB_TXN *txnid;
00619         DB_LSN *ret_lsnp;
00620         u_int32_t flags;
00621         int32_t fileid;
00622         db_pgno_t pgno;
00623         u_int32_t ndx;
00624         DB_LSN * pagelsn;
00625         int32_t off;
00626         const DBT *olditem;
00627         const DBT *newitem;
00628         u_int32_t makedup;
00629 {
00630         DBT logrec;
00631         DB_LSN *lsnp, null_lsn;
00632         u_int32_t zero;
00633         u_int32_t rectype, txn_num;
00634         int ret;
00635         u_int8_t *bp;
00636 
00637         if (txnid != NULL &&
00638             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
00639                 return (CDB___db_child_active_err(dbenv));
00640         rectype = DB_ham_replace;
00641         txn_num = txnid == NULL ? 0 : txnid->txnid;
00642         if (txnid == NULL) {
00643                 ZERO_LSN(null_lsn);
00644                 lsnp = &null_lsn;
00645         } else
00646                 lsnp = &txnid->last_lsn;
00647         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
00648             + sizeof(fileid)
00649             + sizeof(pgno)
00650             + sizeof(ndx)
00651             + sizeof(*pagelsn)
00652             + sizeof(off)
00653             + sizeof(u_int32_t) + (olditem == NULL ? 0 : olditem->size)
00654             + sizeof(u_int32_t) + (newitem == NULL ? 0 : newitem->size)
00655             + sizeof(makedup);
00656         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
00657                 return (ret);
00658 
00659         bp = logrec.data;
00660         memcpy(bp, &rectype, sizeof(rectype));
00661         bp += sizeof(rectype);
00662         memcpy(bp, &txn_num, sizeof(txn_num));
00663         bp += sizeof(txn_num);
00664         memcpy(bp, lsnp, sizeof(DB_LSN));
00665         bp += sizeof(DB_LSN);
00666         memcpy(bp, &fileid, sizeof(fileid));
00667         bp += sizeof(fileid);
00668         memcpy(bp, &pgno, sizeof(pgno));
00669         bp += sizeof(pgno);
00670         memcpy(bp, &ndx, sizeof(ndx));
00671         bp += sizeof(ndx);
00672         if (pagelsn != NULL)
00673                 memcpy(bp, pagelsn, sizeof(*pagelsn));
00674         else
00675                 memset(bp, 0, sizeof(*pagelsn));
00676         bp += sizeof(*pagelsn);
00677         memcpy(bp, &off, sizeof(off));
00678         bp += sizeof(off);
00679         if (olditem == NULL) {
00680                 zero = 0;
00681                 memcpy(bp, &zero, sizeof(u_int32_t));
00682                 bp += sizeof(u_int32_t);
00683         } else {
00684                 memcpy(bp, &olditem->size, sizeof(olditem->size));
00685                 bp += sizeof(olditem->size);
00686                 memcpy(bp, olditem->data, olditem->size);
00687                 bp += olditem->size;
00688         }
00689         if (newitem == NULL) {
00690                 zero = 0;
00691                 memcpy(bp, &zero, sizeof(u_int32_t));
00692                 bp += sizeof(u_int32_t);
00693         } else {
00694                 memcpy(bp, &newitem->size, sizeof(newitem->size));
00695                 bp += sizeof(newitem->size);
00696                 memcpy(bp, newitem->data, newitem->size);
00697                 bp += newitem->size;
00698         }
00699         memcpy(bp, &makedup, sizeof(makedup));
00700         bp += sizeof(makedup);
00701         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
00702         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
00703         if (txnid != NULL)
00704                 txnid->last_lsn = *ret_lsnp;
00705         CDB___os_free(logrec.data, logrec.size);
00706         return (ret);
00707 }
00708 
00709 int
00710 CDB___ham_replace_print(dbenv, dbtp, lsnp, notused2, notused3)
00711         DB_ENV *dbenv;
00712         DBT *dbtp;
00713         DB_LSN *lsnp;
00714         db_recops notused2;
00715         void *notused3;
00716 {
00717         __ham_replace_args *argp;
00718         u_int32_t i;
00719         u_int ch;
00720         int ret;
00721 
00722         i = 0;
00723         ch = 0;
00724         notused2 = 0;
00725         notused3 = NULL;
00726 
00727         if ((ret = CDB___ham_replace_read(dbenv, dbtp->data, &argp)) != 0)
00728                 return (ret);
00729         printf("[%lu][%lu]ham_replace: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00730             (u_long)lsnp->file,
00731             (u_long)lsnp->offset,
00732             (u_long)argp->type,
00733             (u_long)argp->txnid->txnid,
00734             (u_long)argp->prev_lsn.file,
00735             (u_long)argp->prev_lsn.offset);
00736         printf("\tfileid: %ld\n", (long)argp->fileid);
00737         printf("\tpgno: %lu\n", (u_long)argp->pgno);
00738         printf("\tndx: %lu\n", (u_long)argp->ndx);
00739         printf("\tpagelsn: [%lu][%lu]\n",
00740             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
00741         printf("\toff: %ld\n", (long)argp->off);
00742         printf("\tolditem: ");
00743         for (i = 0; i < argp->olditem.size; i++) {
00744                 ch = ((u_int8_t *)argp->olditem.data)[i];
00745                 if (isprint(ch) || ch == 0xa)
00746                         putchar(ch);
00747                 else
00748                         printf("%#x ", ch);
00749         }
00750         printf("\n");
00751         printf("\tnewitem: ");
00752         for (i = 0; i < argp->newitem.size; i++) {
00753                 ch = ((u_int8_t *)argp->newitem.data)[i];
00754                 if (isprint(ch) || ch == 0xa)
00755                         putchar(ch);
00756                 else
00757                         printf("%#x ", ch);
00758         }
00759         printf("\n");
00760         printf("\tmakedup: %lu\n", (u_long)argp->makedup);
00761         printf("\n");
00762         CDB___os_free(argp, 0);
00763         return (0);
00764 }
00765 
00766 int
00767 CDB___ham_replace_read(dbenv, recbuf, argpp)
00768         DB_ENV *dbenv;
00769         void *recbuf;
00770         __ham_replace_args **argpp;
00771 {
00772         __ham_replace_args *argp;
00773         u_int8_t *bp;
00774         int ret;
00775 
00776         ret = CDB___os_malloc(dbenv, sizeof(__ham_replace_args) +
00777             sizeof(DB_TXN), NULL, &argp);
00778         if (ret != 0)
00779                 return (ret);
00780         argp->txnid = (DB_TXN *)&argp[1];
00781         bp = recbuf;
00782         memcpy(&argp->type, bp, sizeof(argp->type));
00783         bp += sizeof(argp->type);
00784         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00785         bp += sizeof(argp->txnid->txnid);
00786         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00787         bp += sizeof(DB_LSN);
00788         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00789         bp += sizeof(argp->fileid);
00790         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
00791         bp += sizeof(argp->pgno);
00792         memcpy(&argp->ndx, bp, sizeof(argp->ndx));
00793         bp += sizeof(argp->ndx);
00794         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
00795         bp += sizeof(argp->pagelsn);
00796         memcpy(&argp->off, bp, sizeof(argp->off));
00797         bp += sizeof(argp->off);
00798         memset(&argp->olditem, 0, sizeof(argp->olditem));
00799         memcpy(&argp->olditem.size, bp, sizeof(u_int32_t));
00800         bp += sizeof(u_int32_t);
00801         argp->olditem.data = bp;
00802         bp += argp->olditem.size;
00803         memset(&argp->newitem, 0, sizeof(argp->newitem));
00804         memcpy(&argp->newitem.size, bp, sizeof(u_int32_t));
00805         bp += sizeof(u_int32_t);
00806         argp->newitem.data = bp;
00807         bp += argp->newitem.size;
00808         memcpy(&argp->makedup, bp, sizeof(argp->makedup));
00809         bp += sizeof(argp->makedup);
00810         *argpp = argp;
00811         return (0);
00812 }
00813 
00814 int
00815 CDB___ham_newpgno_print(dbenv, dbtp, lsnp, notused2, notused3)
00816         DB_ENV *dbenv;
00817         DBT *dbtp;
00818         DB_LSN *lsnp;
00819         db_recops notused2;
00820         void *notused3;
00821 {
00822         __ham_newpgno_args *argp;
00823         u_int32_t i;
00824         u_int ch;
00825         int ret;
00826 
00827         i = 0;
00828         ch = 0;
00829         notused2 = 0;
00830         notused3 = NULL;
00831 
00832         if ((ret = CDB___ham_newpgno_read(dbenv, dbtp->data, &argp)) != 0)
00833                 return (ret);
00834         printf("[%lu][%lu]ham_newpgno: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00835             (u_long)lsnp->file,
00836             (u_long)lsnp->offset,
00837             (u_long)argp->type,
00838             (u_long)argp->txnid->txnid,
00839             (u_long)argp->prev_lsn.file,
00840             (u_long)argp->prev_lsn.offset);
00841         printf("\topcode: %lu\n", (u_long)argp->opcode);
00842         printf("\tfileid: %ld\n", (long)argp->fileid);
00843         printf("\tpgno: %lu\n", (u_long)argp->pgno);
00844         printf("\tfree_pgno: %lu\n", (u_long)argp->free_pgno);
00845         printf("\told_type: %lu\n", (u_long)argp->old_type);
00846         printf("\told_pgno: %lu\n", (u_long)argp->old_pgno);
00847         printf("\tnew_type: %lu\n", (u_long)argp->new_type);
00848         printf("\tpagelsn: [%lu][%lu]\n",
00849             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
00850         printf("\tmetalsn: [%lu][%lu]\n",
00851             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
00852         printf("\n");
00853         CDB___os_free(argp, 0);
00854         return (0);
00855 }
00856 
00857 int
00858 CDB___ham_newpgno_read(dbenv, recbuf, argpp)
00859         DB_ENV *dbenv;
00860         void *recbuf;
00861         __ham_newpgno_args **argpp;
00862 {
00863         __ham_newpgno_args *argp;
00864         u_int8_t *bp;
00865         int ret;
00866 
00867         ret = CDB___os_malloc(dbenv, sizeof(__ham_newpgno_args) +
00868             sizeof(DB_TXN), NULL, &argp);
00869         if (ret != 0)
00870                 return (ret);
00871         argp->txnid = (DB_TXN *)&argp[1];
00872         bp = recbuf;
00873         memcpy(&argp->type, bp, sizeof(argp->type));
00874         bp += sizeof(argp->type);
00875         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00876         bp += sizeof(argp->txnid->txnid);
00877         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00878         bp += sizeof(DB_LSN);
00879         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
00880         bp += sizeof(argp->opcode);
00881         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00882         bp += sizeof(argp->fileid);
00883         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
00884         bp += sizeof(argp->pgno);
00885         memcpy(&argp->free_pgno, bp, sizeof(argp->free_pgno));
00886         bp += sizeof(argp->free_pgno);
00887         memcpy(&argp->old_type, bp, sizeof(argp->old_type));
00888         bp += sizeof(argp->old_type);
00889         memcpy(&argp->old_pgno, bp, sizeof(argp->old_pgno));
00890         bp += sizeof(argp->old_pgno);
00891         memcpy(&argp->new_type, bp, sizeof(argp->new_type));
00892         bp += sizeof(argp->new_type);
00893         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
00894         bp += sizeof(argp->pagelsn);
00895         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
00896         bp += sizeof(argp->metalsn);
00897         *argpp = argp;
00898         return (0);
00899 }
00900 
00901 int
00902 CDB___ham_ovfl_print(dbenv, dbtp, lsnp, notused2, notused3)
00903         DB_ENV *dbenv;
00904         DBT *dbtp;
00905         DB_LSN *lsnp;
00906         db_recops notused2;
00907         void *notused3;
00908 {
00909         __ham_ovfl_args *argp;
00910         u_int32_t i;
00911         u_int ch;
00912         int ret;
00913 
00914         i = 0;
00915         ch = 0;
00916         notused2 = 0;
00917         notused3 = NULL;
00918 
00919         if ((ret = CDB___ham_ovfl_read(dbenv, dbtp->data, &argp)) != 0)
00920                 return (ret);
00921         printf("[%lu][%lu]ham_ovfl: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
00922             (u_long)lsnp->file,
00923             (u_long)lsnp->offset,
00924             (u_long)argp->type,
00925             (u_long)argp->txnid->txnid,
00926             (u_long)argp->prev_lsn.file,
00927             (u_long)argp->prev_lsn.offset);
00928         printf("\tfileid: %ld\n", (long)argp->fileid);
00929         printf("\tstart_pgno: %lu\n", (u_long)argp->start_pgno);
00930         printf("\tnpages: %lu\n", (u_long)argp->npages);
00931         printf("\tfree_pgno: %lu\n", (u_long)argp->free_pgno);
00932         printf("\tovflpoint: %lu\n", (u_long)argp->ovflpoint);
00933         printf("\tmetalsn: [%lu][%lu]\n",
00934             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
00935         printf("\n");
00936         CDB___os_free(argp, 0);
00937         return (0);
00938 }
00939 
00940 int
00941 CDB___ham_ovfl_read(dbenv, recbuf, argpp)
00942         DB_ENV *dbenv;
00943         void *recbuf;
00944         __ham_ovfl_args **argpp;
00945 {
00946         __ham_ovfl_args *argp;
00947         u_int8_t *bp;
00948         int ret;
00949 
00950         ret = CDB___os_malloc(dbenv, sizeof(__ham_ovfl_args) +
00951             sizeof(DB_TXN), NULL, &argp);
00952         if (ret != 0)
00953                 return (ret);
00954         argp->txnid = (DB_TXN *)&argp[1];
00955         bp = recbuf;
00956         memcpy(&argp->type, bp, sizeof(argp->type));
00957         bp += sizeof(argp->type);
00958         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
00959         bp += sizeof(argp->txnid->txnid);
00960         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
00961         bp += sizeof(DB_LSN);
00962         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
00963         bp += sizeof(argp->fileid);
00964         memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
00965         bp += sizeof(argp->start_pgno);
00966         memcpy(&argp->npages, bp, sizeof(argp->npages));
00967         bp += sizeof(argp->npages);
00968         memcpy(&argp->free_pgno, bp, sizeof(argp->free_pgno));
00969         bp += sizeof(argp->free_pgno);
00970         memcpy(&argp->ovflpoint, bp, sizeof(argp->ovflpoint));
00971         bp += sizeof(argp->ovflpoint);
00972         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
00973         bp += sizeof(argp->metalsn);
00974         *argpp = argp;
00975         return (0);
00976 }
00977 
00978 int CDB___ham_copypage_log(dbenv, txnid, ret_lsnp, flags,
00979         fileid, pgno, pagelsn, next_pgno, nextlsn, nnext_pgno,
00980         nnextlsn, page)
00981         DB_ENV *dbenv;
00982         DB_TXN *txnid;
00983         DB_LSN *ret_lsnp;
00984         u_int32_t flags;
00985         int32_t fileid;
00986         db_pgno_t pgno;
00987         DB_LSN * pagelsn;
00988         db_pgno_t next_pgno;
00989         DB_LSN * nextlsn;
00990         db_pgno_t nnext_pgno;
00991         DB_LSN * nnextlsn;
00992         const DBT *page;
00993 {
00994         DBT logrec;
00995         DB_LSN *lsnp, null_lsn;
00996         u_int32_t zero;
00997         u_int32_t rectype, txn_num;
00998         int ret;
00999         u_int8_t *bp;
01000 
01001         if (txnid != NULL &&
01002             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
01003                 return (CDB___db_child_active_err(dbenv));
01004         rectype = DB_ham_copypage;
01005         txn_num = txnid == NULL ? 0 : txnid->txnid;
01006         if (txnid == NULL) {
01007                 ZERO_LSN(null_lsn);
01008                 lsnp = &null_lsn;
01009         } else
01010                 lsnp = &txnid->last_lsn;
01011         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
01012             + sizeof(fileid)
01013             + sizeof(pgno)
01014             + sizeof(*pagelsn)
01015             + sizeof(next_pgno)
01016             + sizeof(*nextlsn)
01017             + sizeof(nnext_pgno)
01018             + sizeof(*nnextlsn)
01019             + sizeof(u_int32_t) + (page == NULL ? 0 : page->size);
01020         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
01021                 return (ret);
01022 
01023         bp = logrec.data;
01024         memcpy(bp, &rectype, sizeof(rectype));
01025         bp += sizeof(rectype);
01026         memcpy(bp, &txn_num, sizeof(txn_num));
01027         bp += sizeof(txn_num);
01028         memcpy(bp, lsnp, sizeof(DB_LSN));
01029         bp += sizeof(DB_LSN);
01030         memcpy(bp, &fileid, sizeof(fileid));
01031         bp += sizeof(fileid);
01032         memcpy(bp, &pgno, sizeof(pgno));
01033         bp += sizeof(pgno);
01034         if (pagelsn != NULL)
01035                 memcpy(bp, pagelsn, sizeof(*pagelsn));
01036         else
01037                 memset(bp, 0, sizeof(*pagelsn));
01038         bp += sizeof(*pagelsn);
01039         memcpy(bp, &next_pgno, sizeof(next_pgno));
01040         bp += sizeof(next_pgno);
01041         if (nextlsn != NULL)
01042                 memcpy(bp, nextlsn, sizeof(*nextlsn));
01043         else
01044                 memset(bp, 0, sizeof(*nextlsn));
01045         bp += sizeof(*nextlsn);
01046         memcpy(bp, &nnext_pgno, sizeof(nnext_pgno));
01047         bp += sizeof(nnext_pgno);
01048         if (nnextlsn != NULL)
01049                 memcpy(bp, nnextlsn, sizeof(*nnextlsn));
01050         else
01051                 memset(bp, 0, sizeof(*nnextlsn));
01052         bp += sizeof(*nnextlsn);
01053         if (page == NULL) {
01054                 zero = 0;
01055                 memcpy(bp, &zero, sizeof(u_int32_t));
01056                 bp += sizeof(u_int32_t);
01057         } else {
01058                 memcpy(bp, &page->size, sizeof(page->size));
01059                 bp += sizeof(page->size);
01060                 memcpy(bp, page->data, page->size);
01061                 bp += page->size;
01062         }
01063         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
01064         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
01065         if (txnid != NULL)
01066                 txnid->last_lsn = *ret_lsnp;
01067         CDB___os_free(logrec.data, logrec.size);
01068         return (ret);
01069 }
01070 
01071 int
01072 CDB___ham_copypage_print(dbenv, dbtp, lsnp, notused2, notused3)
01073         DB_ENV *dbenv;
01074         DBT *dbtp;
01075         DB_LSN *lsnp;
01076         db_recops notused2;
01077         void *notused3;
01078 {
01079         __ham_copypage_args *argp;
01080         u_int32_t i;
01081         u_int ch;
01082         int ret;
01083 
01084         i = 0;
01085         ch = 0;
01086         notused2 = 0;
01087         notused3 = NULL;
01088 
01089         if ((ret = CDB___ham_copypage_read(dbenv, dbtp->data, &argp)) != 0)
01090                 return (ret);
01091         printf("[%lu][%lu]ham_copypage: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
01092             (u_long)lsnp->file,
01093             (u_long)lsnp->offset,
01094             (u_long)argp->type,
01095             (u_long)argp->txnid->txnid,
01096             (u_long)argp->prev_lsn.file,
01097             (u_long)argp->prev_lsn.offset);
01098         printf("\tfileid: %ld\n", (long)argp->fileid);
01099         printf("\tpgno: %lu\n", (u_long)argp->pgno);
01100         printf("\tpagelsn: [%lu][%lu]\n",
01101             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
01102         printf("\tnext_pgno: %lu\n", (u_long)argp->next_pgno);
01103         printf("\tnextlsn: [%lu][%lu]\n",
01104             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
01105         printf("\tnnext_pgno: %lu\n", (u_long)argp->nnext_pgno);
01106         printf("\tnnextlsn: [%lu][%lu]\n",
01107             (u_long)argp->nnextlsn.file, (u_long)argp->nnextlsn.offset);
01108         printf("\tpage: ");
01109         for (i = 0; i < argp->page.size; i++) {
01110                 ch = ((u_int8_t *)argp->page.data)[i];
01111                 if (isprint(ch) || ch == 0xa)
01112                         putchar(ch);
01113                 else
01114                         printf("%#x ", ch);
01115         }
01116         printf("\n");
01117         printf("\n");
01118         CDB___os_free(argp, 0);
01119         return (0);
01120 }
01121 
01122 int
01123 CDB___ham_copypage_read(dbenv, recbuf, argpp)
01124         DB_ENV *dbenv;
01125         void *recbuf;
01126         __ham_copypage_args **argpp;
01127 {
01128         __ham_copypage_args *argp;
01129         u_int8_t *bp;
01130         int ret;
01131 
01132         ret = CDB___os_malloc(dbenv, sizeof(__ham_copypage_args) +
01133             sizeof(DB_TXN), NULL, &argp);
01134         if (ret != 0)
01135                 return (ret);
01136         argp->txnid = (DB_TXN *)&argp[1];
01137         bp = recbuf;
01138         memcpy(&argp->type, bp, sizeof(argp->type));
01139         bp += sizeof(argp->type);
01140         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
01141         bp += sizeof(argp->txnid->txnid);
01142         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
01143         bp += sizeof(DB_LSN);
01144         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
01145         bp += sizeof(argp->fileid);
01146         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
01147         bp += sizeof(argp->pgno);
01148         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
01149         bp += sizeof(argp->pagelsn);
01150         memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
01151         bp += sizeof(argp->next_pgno);
01152         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
01153         bp += sizeof(argp->nextlsn);
01154         memcpy(&argp->nnext_pgno, bp, sizeof(argp->nnext_pgno));
01155         bp += sizeof(argp->nnext_pgno);
01156         memcpy(&argp->nnextlsn, bp,  sizeof(argp->nnextlsn));
01157         bp += sizeof(argp->nnextlsn);
01158         memset(&argp->page, 0, sizeof(argp->page));
01159         memcpy(&argp->page.size, bp, sizeof(u_int32_t));
01160         bp += sizeof(u_int32_t);
01161         argp->page.data = bp;
01162         bp += argp->page.size;
01163         *argpp = argp;
01164         return (0);
01165 }
01166 
01167 int CDB___ham_metagroup_log(dbenv, txnid, ret_lsnp, flags,
01168         fileid, bucket, pgno, metalsn, pagelsn)
01169         DB_ENV *dbenv;
01170         DB_TXN *txnid;
01171         DB_LSN *ret_lsnp;
01172         u_int32_t flags;
01173         int32_t fileid;
01174         u_int32_t bucket;
01175         db_pgno_t pgno;
01176         DB_LSN * metalsn;
01177         DB_LSN * pagelsn;
01178 {
01179         DBT logrec;
01180         DB_LSN *lsnp, null_lsn;
01181         u_int32_t rectype, txn_num;
01182         int ret;
01183         u_int8_t *bp;
01184 
01185         if (txnid != NULL &&
01186             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
01187                 return (CDB___db_child_active_err(dbenv));
01188         rectype = DB_ham_metagroup;
01189         txn_num = txnid == NULL ? 0 : txnid->txnid;
01190         if (txnid == NULL) {
01191                 ZERO_LSN(null_lsn);
01192                 lsnp = &null_lsn;
01193         } else
01194                 lsnp = &txnid->last_lsn;
01195         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
01196             + sizeof(fileid)
01197             + sizeof(bucket)
01198             + sizeof(pgno)
01199             + sizeof(*metalsn)
01200             + sizeof(*pagelsn);
01201         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
01202                 return (ret);
01203 
01204         bp = logrec.data;
01205         memcpy(bp, &rectype, sizeof(rectype));
01206         bp += sizeof(rectype);
01207         memcpy(bp, &txn_num, sizeof(txn_num));
01208         bp += sizeof(txn_num);
01209         memcpy(bp, lsnp, sizeof(DB_LSN));
01210         bp += sizeof(DB_LSN);
01211         memcpy(bp, &fileid, sizeof(fileid));
01212         bp += sizeof(fileid);
01213         memcpy(bp, &bucket, sizeof(bucket));
01214         bp += sizeof(bucket);
01215         memcpy(bp, &pgno, sizeof(pgno));
01216         bp += sizeof(pgno);
01217         if (metalsn != NULL)
01218                 memcpy(bp, metalsn, sizeof(*metalsn));
01219         else
01220                 memset(bp, 0, sizeof(*metalsn));
01221         bp += sizeof(*metalsn);
01222         if (pagelsn != NULL)
01223                 memcpy(bp, pagelsn, sizeof(*pagelsn));
01224         else
01225                 memset(bp, 0, sizeof(*pagelsn));
01226         bp += sizeof(*pagelsn);
01227         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
01228         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
01229         if (txnid != NULL)
01230                 txnid->last_lsn = *ret_lsnp;
01231         CDB___os_free(logrec.data, logrec.size);
01232         return (ret);
01233 }
01234 
01235 int
01236 CDB___ham_metagroup_print(dbenv, dbtp, lsnp, notused2, notused3)
01237         DB_ENV *dbenv;
01238         DBT *dbtp;
01239         DB_LSN *lsnp;
01240         db_recops notused2;
01241         void *notused3;
01242 {
01243         __ham_metagroup_args *argp;
01244         u_int32_t i;
01245         u_int ch;
01246         int ret;
01247 
01248         i = 0;
01249         ch = 0;
01250         notused2 = 0;
01251         notused3 = NULL;
01252 
01253         if ((ret = CDB___ham_metagroup_read(dbenv, dbtp->data, &argp)) != 0)
01254                 return (ret);
01255         printf("[%lu][%lu]ham_metagroup: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
01256             (u_long)lsnp->file,
01257             (u_long)lsnp->offset,
01258             (u_long)argp->type,
01259             (u_long)argp->txnid->txnid,
01260             (u_long)argp->prev_lsn.file,
01261             (u_long)argp->prev_lsn.offset);
01262         printf("\tfileid: %ld\n", (long)argp->fileid);
01263         printf("\tbucket: %lu\n", (u_long)argp->bucket);
01264         printf("\tpgno: %lu\n", (u_long)argp->pgno);
01265         printf("\tmetalsn: [%lu][%lu]\n",
01266             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
01267         printf("\tpagelsn: [%lu][%lu]\n",
01268             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
01269         printf("\n");
01270         CDB___os_free(argp, 0);
01271         return (0);
01272 }
01273 
01274 int
01275 CDB___ham_metagroup_read(dbenv, recbuf, argpp)
01276         DB_ENV *dbenv;
01277         void *recbuf;
01278         __ham_metagroup_args **argpp;
01279 {
01280         __ham_metagroup_args *argp;
01281         u_int8_t *bp;
01282         int ret;
01283 
01284         ret = CDB___os_malloc(dbenv, sizeof(__ham_metagroup_args) +
01285             sizeof(DB_TXN), NULL, &argp);
01286         if (ret != 0)
01287                 return (ret);
01288         argp->txnid = (DB_TXN *)&argp[1];
01289         bp = recbuf;
01290         memcpy(&argp->type, bp, sizeof(argp->type));
01291         bp += sizeof(argp->type);
01292         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
01293         bp += sizeof(argp->txnid->txnid);
01294         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
01295         bp += sizeof(DB_LSN);
01296         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
01297         bp += sizeof(argp->fileid);
01298         memcpy(&argp->bucket, bp, sizeof(argp->bucket));
01299         bp += sizeof(argp->bucket);
01300         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
01301         bp += sizeof(argp->pgno);
01302         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
01303         bp += sizeof(argp->metalsn);
01304         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
01305         bp += sizeof(argp->pagelsn);
01306         *argpp = argp;
01307         return (0);
01308 }
01309 
01310 int
01311 CDB___ham_groupalloc1_print(dbenv, dbtp, lsnp, notused2, notused3)
01312         DB_ENV *dbenv;
01313         DBT *dbtp;
01314         DB_LSN *lsnp;
01315         db_recops notused2;
01316         void *notused3;
01317 {
01318         __ham_groupalloc1_args *argp;
01319         u_int32_t i;
01320         u_int ch;
01321         int ret;
01322 
01323         i = 0;
01324         ch = 0;
01325         notused2 = 0;
01326         notused3 = NULL;
01327 
01328         if ((ret = CDB___ham_groupalloc1_read(dbenv, dbtp->data, &argp)) != 0)
01329                 return (ret);
01330         printf("[%lu][%lu]ham_groupalloc1: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
01331             (u_long)lsnp->file,
01332             (u_long)lsnp->offset,
01333             (u_long)argp->type,
01334             (u_long)argp->txnid->txnid,
01335             (u_long)argp->prev_lsn.file,
01336             (u_long)argp->prev_lsn.offset);
01337         printf("\tfileid: %ld\n", (long)argp->fileid);
01338         printf("\tpgno: %lu\n", (u_long)argp->pgno);
01339         printf("\tmetalsn: [%lu][%lu]\n",
01340             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
01341         printf("\tmmetalsn: [%lu][%lu]\n",
01342             (u_long)argp->mmetalsn.file, (u_long)argp->mmetalsn.offset);
01343         printf("\tstart_pgno: %lu\n", (u_long)argp->start_pgno);
01344         printf("\tnum: %lu\n", (u_long)argp->num);
01345         printf("\n");
01346         CDB___os_free(argp, 0);
01347         return (0);
01348 }
01349 
01350 int
01351 CDB___ham_groupalloc1_read(dbenv, recbuf, argpp)
01352         DB_ENV *dbenv;
01353         void *recbuf;
01354         __ham_groupalloc1_args **argpp;
01355 {
01356         __ham_groupalloc1_args *argp;
01357         u_int8_t *bp;
01358         int ret;
01359 
01360         ret = CDB___os_malloc(dbenv, sizeof(__ham_groupalloc1_args) +
01361             sizeof(DB_TXN), NULL, &argp);
01362         if (ret != 0)
01363                 return (ret);
01364         argp->txnid = (DB_TXN *)&argp[1];
01365         bp = recbuf;
01366         memcpy(&argp->type, bp, sizeof(argp->type));
01367         bp += sizeof(argp->type);
01368         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
01369         bp += sizeof(argp->txnid->txnid);
01370         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
01371         bp += sizeof(DB_LSN);
01372         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
01373         bp += sizeof(argp->fileid);
01374         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
01375         bp += sizeof(argp->pgno);
01376         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
01377         bp += sizeof(argp->metalsn);
01378         memcpy(&argp->mmetalsn, bp,  sizeof(argp->mmetalsn));
01379         bp += sizeof(argp->mmetalsn);
01380         memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
01381         bp += sizeof(argp->start_pgno);
01382         memcpy(&argp->num, bp, sizeof(argp->num));
01383         bp += sizeof(argp->num);
01384         *argpp = argp;
01385         return (0);
01386 }
01387 
01388 int CDB___ham_groupalloc_log(dbenv, txnid, ret_lsnp, flags,
01389         fileid, meta_lsn, alloc_lsn, start_pgno, num, free)
01390         DB_ENV *dbenv;
01391         DB_TXN *txnid;
01392         DB_LSN *ret_lsnp;
01393         u_int32_t flags;
01394         int32_t fileid;
01395         DB_LSN * meta_lsn;
01396         DB_LSN * alloc_lsn;
01397         db_pgno_t start_pgno;
01398         u_int32_t num;
01399         db_pgno_t free;
01400 {
01401         DBT logrec;
01402         DB_LSN *lsnp, null_lsn;
01403         u_int32_t rectype, txn_num;
01404         int ret;
01405         u_int8_t *bp;
01406 
01407         if (txnid != NULL &&
01408             TAILQ_FIRST(&txnid->kids) != NULL && CDB___txn_activekids(txnid) != 0)
01409                 return (CDB___db_child_active_err(dbenv));
01410         rectype = DB_ham_groupalloc;
01411         txn_num = txnid == NULL ? 0 : txnid->txnid;
01412         if (txnid == NULL) {
01413                 ZERO_LSN(null_lsn);
01414                 lsnp = &null_lsn;
01415         } else
01416                 lsnp = &txnid->last_lsn;
01417         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
01418             + sizeof(fileid)
01419             + sizeof(*meta_lsn)
01420             + sizeof(*alloc_lsn)
01421             + sizeof(start_pgno)
01422             + sizeof(num)
01423             + sizeof(free);
01424         if ((ret = CDB___os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
01425                 return (ret);
01426 
01427         bp = logrec.data;
01428         memcpy(bp, &rectype, sizeof(rectype));
01429         bp += sizeof(rectype);
01430         memcpy(bp, &txn_num, sizeof(txn_num));
01431         bp += sizeof(txn_num);
01432         memcpy(bp, lsnp, sizeof(DB_LSN));
01433         bp += sizeof(DB_LSN);
01434         memcpy(bp, &fileid, sizeof(fileid));
01435         bp += sizeof(fileid);
01436         if (meta_lsn != NULL)
01437                 memcpy(bp, meta_lsn, sizeof(*meta_lsn));
01438         else
01439                 memset(bp, 0, sizeof(*meta_lsn));
01440         bp += sizeof(*meta_lsn);
01441         if (alloc_lsn != NULL)
01442                 memcpy(bp, alloc_lsn, sizeof(*alloc_lsn));
01443         else
01444                 memset(bp, 0, sizeof(*alloc_lsn));
01445         bp += sizeof(*alloc_lsn);
01446         memcpy(bp, &start_pgno, sizeof(start_pgno));
01447         bp += sizeof(start_pgno);
01448         memcpy(bp, &num, sizeof(num));
01449         bp += sizeof(num);
01450         memcpy(bp, &free, sizeof(free));
01451         bp += sizeof(free);
01452         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
01453         ret = CDB_log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
01454         if (txnid != NULL)
01455                 txnid->last_lsn = *ret_lsnp;
01456         CDB___os_free(logrec.data, logrec.size);
01457         return (ret);
01458 }
01459 
01460 int
01461 CDB___ham_groupalloc_print(dbenv, dbtp, lsnp, notused2, notused3)
01462         DB_ENV *dbenv;
01463         DBT *dbtp;
01464         DB_LSN *lsnp;
01465         db_recops notused2;
01466         void *notused3;
01467 {
01468         __ham_groupalloc_args *argp;
01469         u_int32_t i;
01470         u_int ch;
01471         int ret;
01472 
01473         i = 0;
01474         ch = 0;
01475         notused2 = 0;
01476         notused3 = NULL;
01477 
01478         if ((ret = CDB___ham_groupalloc_read(dbenv, dbtp->data, &argp)) != 0)
01479                 return (ret);
01480         printf("[%lu][%lu]ham_groupalloc: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
01481             (u_long)lsnp->file,
01482             (u_long)lsnp->offset,
01483             (u_long)argp->type,
01484             (u_long)argp->txnid->txnid,
01485             (u_long)argp->prev_lsn.file,
01486             (u_long)argp->prev_lsn.offset);
01487         printf("\tfileid: %ld\n", (long)argp->fileid);
01488         printf("\tmeta_lsn: [%lu][%lu]\n",
01489             (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
01490         printf("\talloc_lsn: [%lu][%lu]\n",
01491             (u_long)argp->alloc_lsn.file, (u_long)argp->alloc_lsn.offset);
01492         printf("\tstart_pgno: %lu\n", (u_long)argp->start_pgno);
01493         printf("\tnum: %lu\n", (u_long)argp->num);
01494         printf("\tfree: %lu\n", (u_long)argp->free);
01495         printf("\n");
01496         CDB___os_free(argp, 0);
01497         return (0);
01498 }
01499 
01500 int
01501 CDB___ham_groupalloc_read(dbenv, recbuf, argpp)
01502         DB_ENV *dbenv;
01503         void *recbuf;
01504         __ham_groupalloc_args **argpp;
01505 {
01506         __ham_groupalloc_args *argp;
01507         u_int8_t *bp;
01508         int ret;
01509 
01510         ret = CDB___os_malloc(dbenv, sizeof(__ham_groupalloc_args) +
01511             sizeof(DB_TXN), NULL, &argp);
01512         if (ret != 0)
01513                 return (ret);
01514         argp->txnid = (DB_TXN *)&argp[1];
01515         bp = recbuf;
01516         memcpy(&argp->type, bp, sizeof(argp->type));
01517         bp += sizeof(argp->type);
01518         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
01519         bp += sizeof(argp->txnid->txnid);
01520         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
01521         bp += sizeof(DB_LSN);
01522         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
01523         bp += sizeof(argp->fileid);
01524         memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
01525         bp += sizeof(argp->meta_lsn);
01526         memcpy(&argp->alloc_lsn, bp,  sizeof(argp->alloc_lsn));
01527         bp += sizeof(argp->alloc_lsn);
01528         memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
01529         bp += sizeof(argp->start_pgno);
01530         memcpy(&argp->num, bp, sizeof(argp->num));
01531         bp += sizeof(argp->num);
01532         memcpy(&argp->free, bp, sizeof(argp->free));
01533         bp += sizeof(argp->free);
01534         *argpp = argp;
01535         return (0);
01536 }
01537 
01538 int
01539 CDB___ham_init_print(dbenv)
01540         DB_ENV *dbenv;
01541 {
01542         int ret;
01543 
01544         if ((ret = CDB___db_add_recovery(dbenv,
01545             CDB___ham_insdel_print, DB_ham_insdel)) != 0)
01546                 return (ret);
01547         if ((ret = CDB___db_add_recovery(dbenv,
01548             CDB___ham_newpage_print, DB_ham_newpage)) != 0)
01549                 return (ret);
01550         if ((ret = CDB___db_add_recovery(dbenv,
01551             CDB___ham_splitmeta_print, DB_ham_splitmeta)) != 0)
01552                 return (ret);
01553         if ((ret = CDB___db_add_recovery(dbenv,
01554             CDB___ham_splitdata_print, DB_ham_splitdata)) != 0)
01555                 return (ret);
01556         if ((ret = CDB___db_add_recovery(dbenv,
01557             CDB___ham_replace_print, DB_ham_replace)) != 0)
01558                 return (ret);
01559         if ((ret = CDB___db_add_recovery(dbenv,
01560             CDB___ham_newpgno_print, DB_ham_newpgno)) != 0)
01561                 return (ret);
01562         if ((ret = CDB___db_add_recovery(dbenv,
01563             CDB___ham_ovfl_print, DB_ham_ovfl)) != 0)
01564                 return (ret);
01565         if ((ret = CDB___db_add_recovery(dbenv,
01566             CDB___ham_copypage_print, DB_ham_copypage)) != 0)
01567                 return (ret);
01568         if ((ret = CDB___db_add_recovery(dbenv,
01569             CDB___ham_metagroup_print, DB_ham_metagroup)) != 0)
01570                 return (ret);
01571         if ((ret = CDB___db_add_recovery(dbenv,
01572             CDB___ham_groupalloc1_print, DB_ham_groupalloc1)) != 0)
01573                 return (ret);
01574         if ((ret = CDB___db_add_recovery(dbenv,
01575             CDB___ham_groupalloc_print, DB_ham_groupalloc)) != 0)
01576                 return (ret);
01577         return (0);
01578 }
01579 
01580 int
01581 CDB___ham_init_recover(dbenv)
01582         DB_ENV *dbenv;
01583 {
01584         int ret;
01585 
01586         if ((ret = CDB___db_add_recovery(dbenv,
01587             CDB___ham_insdel_recover, DB_ham_insdel)) != 0)
01588                 return (ret);
01589         if ((ret = CDB___db_add_recovery(dbenv,
01590             CDB___ham_newpage_recover, DB_ham_newpage)) != 0)
01591                 return (ret);
01592         if ((ret = CDB___db_add_recovery(dbenv,
01593             CDB___deprecated_recover, DB_ham_splitmeta)) != 0)
01594                 return (ret);
01595         if ((ret = CDB___db_add_recovery(dbenv,
01596             CDB___ham_splitdata_recover, DB_ham_splitdata)) != 0)
01597                 return (ret);
01598         if ((ret = CDB___db_add_recovery(dbenv,
01599             CDB___ham_replace_recover, DB_ham_replace)) != 0)
01600                 return (ret);
01601         if ((ret = CDB___db_add_recovery(dbenv,
01602             CDB___deprecated_recover, DB_ham_newpgno)) != 0)
01603                 return (ret);
01604         if ((ret = CDB___db_add_recovery(dbenv,
01605             CDB___deprecated_recover, DB_ham_ovfl)) != 0)
01606                 return (ret);
01607         if ((ret = CDB___db_add_recovery(dbenv,
01608             CDB___ham_copypage_recover, DB_ham_copypage)) != 0)
01609                 return (ret);
01610         if ((ret = CDB___db_add_recovery(dbenv,
01611             CDB___ham_metagroup_recover, DB_ham_metagroup)) != 0)
01612                 return (ret);
01613         if ((ret = CDB___db_add_recovery(dbenv,
01614             CDB___deprecated_recover, DB_ham_groupalloc1)) != 0)
01615                 return (ret);
01616         if ((ret = CDB___db_add_recovery(dbenv,
01617             CDB___ham_groupalloc_recover, DB_ham_groupalloc)) != 0)
01618                 return (ret);
01619         return (0);
01620 }
01621 

Generated on Sun Jun 8 10:56:37 2008 for GNUmifluz by  doxygen 1.5.5