Annotation of embedaddon/php/ext/sqlite/libsqlite/src/pager.c, revision 1.1.1.1

1.1       misho       1: /*
                      2: ** 2001 September 15
                      3: **
                      4: ** The author disclaims copyright to this source code.  In place of
                      5: ** a legal notice, here is a blessing:
                      6: **
                      7: **    May you do good and not evil.
                      8: **    May you find forgiveness for yourself and forgive others.
                      9: **    May you share freely, never taking more than you give.
                     10: **
                     11: *************************************************************************
                     12: ** This is the implementation of the page cache subsystem or "pager".
                     13: ** 
                     14: ** The pager is used to access a database disk file.  It implements
                     15: ** atomic commit and rollback through the use of a journal file that
                     16: ** is separate from the database file.  The pager also implements file
                     17: ** locking to prevent two processes from writing the same database
                     18: ** file simultaneously, or one process from reading the database while
                     19: ** another is writing.
                     20: **
                     21: ** @(#) $Id: pager.c 203289 2005-12-20 15:26:26Z iliaa $
                     22: */
                     23: #include "os.h"         /* Must be first to enable large file support */
                     24: #include "sqliteInt.h"
                     25: #include "pager.h"
                     26: #include <assert.h>
                     27: #include <string.h>
                     28: 
                     29: /*
                     30: ** Macros for troubleshooting.  Normally turned off
                     31: */
                     32: #if 0
                     33: static Pager *mainPager = 0;
                     34: #define SET_PAGER(X)  if( mainPager==0 ) mainPager = (X)
                     35: #define CLR_PAGER(X)  if( mainPager==(X) ) mainPager = 0
                     36: #define TRACE1(X)     if( pPager==mainPager ) fprintf(stderr,X)
                     37: #define TRACE2(X,Y)   if( pPager==mainPager ) fprintf(stderr,X,Y)
                     38: #define TRACE3(X,Y,Z) if( pPager==mainPager ) fprintf(stderr,X,Y,Z)
                     39: #else
                     40: #define SET_PAGER(X)
                     41: #define CLR_PAGER(X)
                     42: #define TRACE1(X)
                     43: #define TRACE2(X,Y)
                     44: #define TRACE3(X,Y,Z)
                     45: #endif
                     46: 
                     47: 
                     48: /*
                     49: ** The page cache as a whole is always in one of the following
                     50: ** states:
                     51: **
                     52: **   SQLITE_UNLOCK       The page cache is not currently reading or 
                     53: **                       writing the database file.  There is no
                     54: **                       data held in memory.  This is the initial
                     55: **                       state.
                     56: **
                     57: **   SQLITE_READLOCK     The page cache is reading the database.
                     58: **                       Writing is not permitted.  There can be
                     59: **                       multiple readers accessing the same database
                     60: **                       file at the same time.
                     61: **
                     62: **   SQLITE_WRITELOCK    The page cache is writing the database.
                     63: **                       Access is exclusive.  No other processes or
                     64: **                       threads can be reading or writing while one
                     65: **                       process is writing.
                     66: **
                     67: ** The page cache comes up in SQLITE_UNLOCK.  The first time a
                     68: ** sqlite_page_get() occurs, the state transitions to SQLITE_READLOCK.
                     69: ** After all pages have been released using sqlite_page_unref(),
                     70: ** the state transitions back to SQLITE_UNLOCK.  The first time
                     71: ** that sqlite_page_write() is called, the state transitions to
                     72: ** SQLITE_WRITELOCK.  (Note that sqlite_page_write() can only be
                     73: ** called on an outstanding page which means that the pager must
                     74: ** be in SQLITE_READLOCK before it transitions to SQLITE_WRITELOCK.)
                     75: ** The sqlite_page_rollback() and sqlite_page_commit() functions 
                     76: ** transition the state from SQLITE_WRITELOCK back to SQLITE_READLOCK.
                     77: */
                     78: #define SQLITE_UNLOCK      0
                     79: #define SQLITE_READLOCK    1
                     80: #define SQLITE_WRITELOCK   2
                     81: 
                     82: 
                     83: /*
                     84: ** Each in-memory image of a page begins with the following header.
                     85: ** This header is only visible to this pager module.  The client
                     86: ** code that calls pager sees only the data that follows the header.
                     87: **
                     88: ** Client code should call sqlitepager_write() on a page prior to making
                     89: ** any modifications to that page.  The first time sqlitepager_write()
                     90: ** is called, the original page contents are written into the rollback
                     91: ** journal and PgHdr.inJournal and PgHdr.needSync are set.  Later, once
                     92: ** the journal page has made it onto the disk surface, PgHdr.needSync
                     93: ** is cleared.  The modified page cannot be written back into the original
                     94: ** database file until the journal pages has been synced to disk and the
                     95: ** PgHdr.needSync has been cleared.
                     96: **
                     97: ** The PgHdr.dirty flag is set when sqlitepager_write() is called and
                     98: ** is cleared again when the page content is written back to the original
                     99: ** database file.
                    100: */
                    101: typedef struct PgHdr PgHdr;
                    102: struct PgHdr {
                    103:   Pager *pPager;                 /* The pager to which this page belongs */
                    104:   Pgno pgno;                     /* The page number for this page */
                    105:   PgHdr *pNextHash, *pPrevHash;  /* Hash collision chain for PgHdr.pgno */
                    106:   int nRef;                      /* Number of users of this page */
                    107:   PgHdr *pNextFree, *pPrevFree;  /* Freelist of pages where nRef==0 */
                    108:   PgHdr *pNextAll, *pPrevAll;    /* A list of all pages */
                    109:   PgHdr *pNextCkpt, *pPrevCkpt;  /* List of pages in the checkpoint journal */
                    110:   u8 inJournal;                  /* TRUE if has been written to journal */
                    111:   u8 inCkpt;                     /* TRUE if written to the checkpoint journal */
                    112:   u8 dirty;                      /* TRUE if we need to write back changes */
                    113:   u8 needSync;                   /* Sync journal before writing this page */
                    114:   u8 alwaysRollback;             /* Disable dont_rollback() for this page */
                    115:   PgHdr *pDirty;                 /* Dirty pages sorted by PgHdr.pgno */
                    116:   /* SQLITE_PAGE_SIZE bytes of page data follow this header */
                    117:   /* Pager.nExtra bytes of local data follow the page data */
                    118: };
                    119: 
                    120: 
                    121: /*
                    122: ** A macro used for invoking the codec if there is one
                    123: */
                    124: #ifdef SQLITE_HAS_CODEC
                    125: # define CODEC(P,D,N,X) if( P->xCodec ){ P->xCodec(P->pCodecArg,D,N,X); }
                    126: #else
                    127: # define CODEC(P,D,N,X)
                    128: #endif
                    129: 
                    130: /*
                    131: ** Convert a pointer to a PgHdr into a pointer to its data
                    132: ** and back again.
                    133: */
                    134: #define PGHDR_TO_DATA(P)  ((void*)(&(P)[1]))
                    135: #define DATA_TO_PGHDR(D)  (&((PgHdr*)(D))[-1])
                    136: #define PGHDR_TO_EXTRA(P) ((void*)&((char*)(&(P)[1]))[SQLITE_PAGE_SIZE])
                    137: 
                    138: /*
                    139: ** How big to make the hash table used for locating in-memory pages
                    140: ** by page number.
                    141: */
                    142: #define N_PG_HASH 2048
                    143: 
                    144: /*
                    145: ** Hash a page number
                    146: */
                    147: #define pager_hash(PN)  ((PN)&(N_PG_HASH-1))
                    148: 
                    149: /*
                    150: ** A open page cache is an instance of the following structure.
                    151: */
                    152: struct Pager {
                    153:   char *zFilename;            /* Name of the database file */
                    154:   char *zJournal;             /* Name of the journal file */
                    155:   char *zDirectory;           /* Directory hold database and journal files */
                    156:   OsFile fd, jfd;             /* File descriptors for database and journal */
                    157:   OsFile cpfd;                /* File descriptor for the checkpoint journal */
                    158:   int dbSize;                 /* Number of pages in the file */
                    159:   int origDbSize;             /* dbSize before the current change */
                    160:   int ckptSize;               /* Size of database (in pages) at ckpt_begin() */
                    161:   off_t ckptJSize;            /* Size of journal at ckpt_begin() */
                    162:   int nRec;                   /* Number of pages written to the journal */
                    163:   u32 cksumInit;              /* Quasi-random value added to every checksum */
                    164:   int ckptNRec;               /* Number of records in the checkpoint journal */
                    165:   int nExtra;                 /* Add this many bytes to each in-memory page */
                    166:   void (*xDestructor)(void*); /* Call this routine when freeing pages */
                    167:   int nPage;                  /* Total number of in-memory pages */
                    168:   int nRef;                   /* Number of in-memory pages with PgHdr.nRef>0 */
                    169:   int mxPage;                 /* Maximum number of pages to hold in cache */
                    170:   int nHit, nMiss, nOvfl;     /* Cache hits, missing, and LRU overflows */
                    171:   void (*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
                    172:   void *pCodecArg;            /* First argument to xCodec() */
                    173:   u8 journalOpen;             /* True if journal file descriptors is valid */
                    174:   u8 journalStarted;          /* True if header of journal is synced */
                    175:   u8 useJournal;              /* Use a rollback journal on this file */
                    176:   u8 ckptOpen;                /* True if the checkpoint journal is open */
                    177:   u8 ckptInUse;               /* True we are in a checkpoint */
                    178:   u8 ckptAutoopen;            /* Open ckpt journal when main journal is opened*/
                    179:   u8 noSync;                  /* Do not sync the journal if true */
                    180:   u8 fullSync;                /* Do extra syncs of the journal for robustness */
                    181:   u8 state;                   /* SQLITE_UNLOCK, _READLOCK or _WRITELOCK */
                    182:   u8 errMask;                 /* One of several kinds of errors */
                    183:   u8 tempFile;                /* zFilename is a temporary file */
                    184:   u8 readOnly;                /* True for a read-only database */
                    185:   u8 needSync;                /* True if an fsync() is needed on the journal */
                    186:   u8 dirtyFile;               /* True if database file has changed in any way */
                    187:   u8 alwaysRollback;          /* Disable dont_rollback() for all pages */
                    188:   u8 *aInJournal;             /* One bit for each page in the database file */
                    189:   u8 *aInCkpt;                /* One bit for each page in the database */
                    190:   PgHdr *pFirst, *pLast;      /* List of free pages */
                    191:   PgHdr *pFirstSynced;        /* First free page with PgHdr.needSync==0 */
                    192:   PgHdr *pAll;                /* List of all pages */
                    193:   PgHdr *pCkpt;               /* List of pages in the checkpoint journal */
                    194:   PgHdr *aHash[N_PG_HASH];    /* Hash table to map page number of PgHdr */
                    195: };
                    196: 
                    197: /*
                    198: ** These are bits that can be set in Pager.errMask.
                    199: */
                    200: #define PAGER_ERR_FULL     0x01  /* a write() failed */
                    201: #define PAGER_ERR_MEM      0x02  /* malloc() failed */
                    202: #define PAGER_ERR_LOCK     0x04  /* error in the locking protocol */
                    203: #define PAGER_ERR_CORRUPT  0x08  /* database or journal corruption */
                    204: #define PAGER_ERR_DISK     0x10  /* general disk I/O error - bad hard drive? */
                    205: 
                    206: /*
                    207: ** The journal file contains page records in the following
                    208: ** format.
                    209: **
                    210: ** Actually, this structure is the complete page record for pager
                    211: ** formats less than 3.  Beginning with format 3, this record is surrounded
                    212: ** by two checksums.
                    213: */
                    214: typedef struct PageRecord PageRecord;
                    215: struct PageRecord {
                    216:   Pgno pgno;                      /* The page number */
                    217:   char aData[SQLITE_PAGE_SIZE];   /* Original data for page pgno */
                    218: };
                    219: 
                    220: /*
                    221: ** Journal files begin with the following magic string.  The data
                    222: ** was obtained from /dev/random.  It is used only as a sanity check.
                    223: **
                    224: ** There are three journal formats (so far). The 1st journal format writes
                    225: ** 32-bit integers in the byte-order of the host machine.  New
                    226: ** formats writes integers as big-endian.  All new journals use the
                    227: ** new format, but we have to be able to read an older journal in order
                    228: ** to rollback journals created by older versions of the library.
                    229: **
                    230: ** The 3rd journal format (added for 2.8.0) adds additional sanity
                    231: ** checking information to the journal.  If the power fails while the
                    232: ** journal is being written, semi-random garbage data might appear in
                    233: ** the journal file after power is restored.  If an attempt is then made
                    234: ** to roll the journal back, the database could be corrupted.  The additional
                    235: ** sanity checking data is an attempt to discover the garbage in the
                    236: ** journal and ignore it.
                    237: **
                    238: ** The sanity checking information for the 3rd journal format consists
                    239: ** of a 32-bit checksum on each page of data.  The checksum covers both
                    240: ** the page number and the SQLITE_PAGE_SIZE bytes of data for the page.
                    241: ** This cksum is initialized to a 32-bit random value that appears in the
                    242: ** journal file right after the header.  The random initializer is important,
                    243: ** because garbage data that appears at the end of a journal is likely
                    244: ** data that was once in other files that have now been deleted.  If the
                    245: ** garbage data came from an obsolete journal file, the checksums might
                    246: ** be correct.  But by initializing the checksum to random value which
                    247: ** is different for every journal, we minimize that risk.
                    248: */
                    249: static const unsigned char aJournalMagic1[] = {
                    250:   0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd4,
                    251: };
                    252: static const unsigned char aJournalMagic2[] = {
                    253:   0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd5,
                    254: };
                    255: static const unsigned char aJournalMagic3[] = {
                    256:   0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd6,
                    257: };
                    258: #define JOURNAL_FORMAT_1 1
                    259: #define JOURNAL_FORMAT_2 2
                    260: #define JOURNAL_FORMAT_3 3
                    261: 
                    262: /*
                    263: ** The following integer determines what format to use when creating
                    264: ** new primary journal files.  By default we always use format 3.
                    265: ** When testing, we can set this value to older journal formats in order to
                    266: ** make sure that newer versions of the library are able to rollback older
                    267: ** journal files.
                    268: **
                    269: ** Note that checkpoint journals always use format 2 and omit the header.
                    270: */
                    271: #ifdef SQLITE_TEST
                    272: int journal_format = 3;
                    273: #else
                    274: # define journal_format 3
                    275: #endif
                    276: 
                    277: /*
                    278: ** The size of the header and of each page in the journal varies according
                    279: ** to which journal format is being used.  The following macros figure out
                    280: ** the sizes based on format numbers.
                    281: */
                    282: #define JOURNAL_HDR_SZ(X) \
                    283:    (sizeof(aJournalMagic1) + sizeof(Pgno) + ((X)>=3)*2*sizeof(u32))
                    284: #define JOURNAL_PG_SZ(X) \
                    285:    (SQLITE_PAGE_SIZE + sizeof(Pgno) + ((X)>=3)*sizeof(u32))
                    286: 
                    287: /*
                    288: ** Enable reference count tracking here:
                    289: */
                    290: #ifdef SQLITE_TEST
                    291:   int pager_refinfo_enable = 0;
                    292:   static void pager_refinfo(PgHdr *p){
                    293:     static int cnt = 0;
                    294:     if( !pager_refinfo_enable ) return;
                    295:     printf(
                    296:        "REFCNT: %4d addr=0x%08x nRef=%d\n",
                    297:        p->pgno, (int)PGHDR_TO_DATA(p), p->nRef
                    298:     );
                    299:     cnt++;   /* Something to set a breakpoint on */
                    300:   }
                    301: # define REFINFO(X)  pager_refinfo(X)
                    302: #else
                    303: # define REFINFO(X)
                    304: #endif
                    305: 
                    306: /*
                    307: ** Read a 32-bit integer from the given file descriptor.  Store the integer
                    308: ** that is read in *pRes.  Return SQLITE_OK if everything worked, or an
                    309: ** error code is something goes wrong.
                    310: **
                    311: ** If the journal format is 2 or 3, read a big-endian integer.  If the
                    312: ** journal format is 1, read an integer in the native byte-order of the
                    313: ** host machine.
                    314: */
                    315: static int read32bits(int format, OsFile *fd, u32 *pRes){
                    316:   u32 res;
                    317:   int rc;
                    318:   rc = sqliteOsRead(fd, &res, sizeof(res));
                    319:   if( rc==SQLITE_OK && format>JOURNAL_FORMAT_1 ){
                    320:     unsigned char ac[4];
                    321:     memcpy(ac, &res, 4);
                    322:     res = (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3];
                    323:   }
                    324:   *pRes = res;
                    325:   return rc;
                    326: }
                    327: 
                    328: /*
                    329: ** Write a 32-bit integer into the given file descriptor.  Return SQLITE_OK
                    330: ** on success or an error code is something goes wrong.
                    331: **
                    332: ** If the journal format is 2 or 3, write the integer as 4 big-endian
                    333: ** bytes.  If the journal format is 1, write the integer in the native
                    334: ** byte order.  In normal operation, only formats 2 and 3 are used.
                    335: ** Journal format 1 is only used for testing.
                    336: */
                    337: static int write32bits(OsFile *fd, u32 val){
                    338:   unsigned char ac[4];
                    339:   if( journal_format<=1 ){
                    340:     return sqliteOsWrite(fd, &val, 4);
                    341:   }
                    342:   ac[0] = (val>>24) & 0xff;
                    343:   ac[1] = (val>>16) & 0xff;
                    344:   ac[2] = (val>>8) & 0xff;
                    345:   ac[3] = val & 0xff;
                    346:   return sqliteOsWrite(fd, ac, 4);
                    347: }
                    348: 
                    349: /*
                    350: ** Write a 32-bit integer into a page header right before the
                    351: ** page data.  This will overwrite the PgHdr.pDirty pointer.
                    352: **
                    353: ** The integer is big-endian for formats 2 and 3 and native byte order
                    354: ** for journal format 1.
                    355: */
                    356: static void store32bits(u32 val, PgHdr *p, int offset){
                    357:   unsigned char *ac;
                    358:   ac = &((unsigned char*)PGHDR_TO_DATA(p))[offset];
                    359:   if( journal_format<=1 ){
                    360:     memcpy(ac, &val, 4);
                    361:   }else{
                    362:     ac[0] = (val>>24) & 0xff;
                    363:     ac[1] = (val>>16) & 0xff;
                    364:     ac[2] = (val>>8) & 0xff;
                    365:     ac[3] = val & 0xff;
                    366:   }
                    367: }
                    368: 
                    369: 
                    370: /*
                    371: ** Convert the bits in the pPager->errMask into an approprate
                    372: ** return code.
                    373: */
                    374: static int pager_errcode(Pager *pPager){
                    375:   int rc = SQLITE_OK;
                    376:   if( pPager->errMask & PAGER_ERR_LOCK )    rc = SQLITE_PROTOCOL;
                    377:   if( pPager->errMask & PAGER_ERR_DISK )    rc = SQLITE_IOERR;
                    378:   if( pPager->errMask & PAGER_ERR_FULL )    rc = SQLITE_FULL;
                    379:   if( pPager->errMask & PAGER_ERR_MEM )     rc = SQLITE_NOMEM;
                    380:   if( pPager->errMask & PAGER_ERR_CORRUPT ) rc = SQLITE_CORRUPT;
                    381:   return rc;
                    382: }
                    383: 
                    384: /*
                    385: ** Add or remove a page from the list of all pages that are in the
                    386: ** checkpoint journal.
                    387: **
                    388: ** The Pager keeps a separate list of pages that are currently in
                    389: ** the checkpoint journal.  This helps the sqlitepager_ckpt_commit()
                    390: ** routine run MUCH faster for the common case where there are many
                    391: ** pages in memory but only a few are in the checkpoint journal.
                    392: */
                    393: static void page_add_to_ckpt_list(PgHdr *pPg){
                    394:   Pager *pPager = pPg->pPager;
                    395:   if( pPg->inCkpt ) return;
                    396:   assert( pPg->pPrevCkpt==0 && pPg->pNextCkpt==0 );
                    397:   pPg->pPrevCkpt = 0;
                    398:   if( pPager->pCkpt ){
                    399:     pPager->pCkpt->pPrevCkpt = pPg;
                    400:   }
                    401:   pPg->pNextCkpt = pPager->pCkpt;
                    402:   pPager->pCkpt = pPg;
                    403:   pPg->inCkpt = 1;
                    404: }
                    405: static void page_remove_from_ckpt_list(PgHdr *pPg){
                    406:   if( !pPg->inCkpt ) return;
                    407:   if( pPg->pPrevCkpt ){
                    408:     assert( pPg->pPrevCkpt->pNextCkpt==pPg );
                    409:     pPg->pPrevCkpt->pNextCkpt = pPg->pNextCkpt;
                    410:   }else{
                    411:     assert( pPg->pPager->pCkpt==pPg );
                    412:     pPg->pPager->pCkpt = pPg->pNextCkpt;
                    413:   }
                    414:   if( pPg->pNextCkpt ){
                    415:     assert( pPg->pNextCkpt->pPrevCkpt==pPg );
                    416:     pPg->pNextCkpt->pPrevCkpt = pPg->pPrevCkpt;
                    417:   }
                    418:   pPg->pNextCkpt = 0;
                    419:   pPg->pPrevCkpt = 0;
                    420:   pPg->inCkpt = 0;
                    421: }
                    422: 
                    423: /*
                    424: ** Find a page in the hash table given its page number.  Return
                    425: ** a pointer to the page or NULL if not found.
                    426: */
                    427: static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
                    428:   PgHdr *p = pPager->aHash[pager_hash(pgno)];
                    429:   while( p && p->pgno!=pgno ){
                    430:     p = p->pNextHash;
                    431:   }
                    432:   return p;
                    433: }
                    434: 
                    435: /*
                    436: ** Unlock the database and clear the in-memory cache.  This routine
                    437: ** sets the state of the pager back to what it was when it was first
                    438: ** opened.  Any outstanding pages are invalidated and subsequent attempts
                    439: ** to access those pages will likely result in a coredump.
                    440: */
                    441: static void pager_reset(Pager *pPager){
                    442:   PgHdr *pPg, *pNext;
                    443:   for(pPg=pPager->pAll; pPg; pPg=pNext){
                    444:     pNext = pPg->pNextAll;
                    445:     sqliteFree(pPg);
                    446:   }
                    447:   pPager->pFirst = 0;
                    448:   pPager->pFirstSynced = 0;
                    449:   pPager->pLast = 0;
                    450:   pPager->pAll = 0;
                    451:   memset(pPager->aHash, 0, sizeof(pPager->aHash));
                    452:   pPager->nPage = 0;
                    453:   if( pPager->state>=SQLITE_WRITELOCK ){
                    454:     sqlitepager_rollback(pPager);
                    455:   }
                    456:   sqliteOsUnlock(&pPager->fd);
                    457:   pPager->state = SQLITE_UNLOCK;
                    458:   pPager->dbSize = -1;
                    459:   pPager->nRef = 0;
                    460:   assert( pPager->journalOpen==0 );
                    461: }
                    462: 
                    463: /*
                    464: ** When this routine is called, the pager has the journal file open and
                    465: ** a write lock on the database.  This routine releases the database
                    466: ** write lock and acquires a read lock in its place.  The journal file
                    467: ** is deleted and closed.
                    468: **
                    469: ** TODO: Consider keeping the journal file open for temporary databases.
                    470: ** This might give a performance improvement on windows where opening
                    471: ** a file is an expensive operation.
                    472: */
                    473: static int pager_unwritelock(Pager *pPager){
                    474:   int rc;
                    475:   PgHdr *pPg;
                    476:   if( pPager->state<SQLITE_WRITELOCK ) return SQLITE_OK;
                    477:   sqlitepager_ckpt_commit(pPager);
                    478:   if( pPager->ckptOpen ){
                    479:     sqliteOsClose(&pPager->cpfd);
                    480:     pPager->ckptOpen = 0;
                    481:   }
                    482:   if( pPager->journalOpen ){
                    483:     sqliteOsClose(&pPager->jfd);
                    484:     pPager->journalOpen = 0;
                    485:     sqliteOsDelete(pPager->zJournal);
                    486:     sqliteFree( pPager->aInJournal );
                    487:     pPager->aInJournal = 0;
                    488:     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
                    489:       pPg->inJournal = 0;
                    490:       pPg->dirty = 0;
                    491:       pPg->needSync = 0;
                    492:     }
                    493:   }else{
                    494:     assert( pPager->dirtyFile==0 || pPager->useJournal==0 );
                    495:   }
                    496:   rc = sqliteOsReadLock(&pPager->fd);
                    497:   if( rc==SQLITE_OK ){
                    498:     pPager->state = SQLITE_READLOCK;
                    499:   }else{
                    500:     /* This can only happen if a process does a BEGIN, then forks and the
                    501:     ** child process does the COMMIT.  Because of the semantics of unix
                    502:     ** file locking, the unlock will fail.
                    503:     */
                    504:     pPager->state = SQLITE_UNLOCK;
                    505:   }
                    506:   return rc;
                    507: }
                    508: 
                    509: /*
                    510: ** Compute and return a checksum for the page of data.
                    511: **
                    512: ** This is not a real checksum.  It is really just the sum of the 
                    513: ** random initial value and the page number.  We considered do a checksum
                    514: ** of the database, but that was found to be too slow.
                    515: */
                    516: static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){
                    517:   u32 cksum = pPager->cksumInit + pgno;
                    518:   return cksum;
                    519: }
                    520: 
                    521: /*
                    522: ** Read a single page from the journal file opened on file descriptor
                    523: ** jfd.  Playback this one page.
                    524: **
                    525: ** There are three different journal formats.  The format parameter determines
                    526: ** which format is used by the journal that is played back.
                    527: */
                    528: static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int format){
                    529:   int rc;
                    530:   PgHdr *pPg;              /* An existing page in the cache */
                    531:   PageRecord pgRec;
                    532:   u32 cksum;
                    533: 
                    534:   rc = read32bits(format, jfd, &pgRec.pgno);
                    535:   if( rc!=SQLITE_OK ) return rc;
                    536:   rc = sqliteOsRead(jfd, &pgRec.aData, sizeof(pgRec.aData));
                    537:   if( rc!=SQLITE_OK ) return rc;
                    538: 
                    539:   /* Sanity checking on the page.  This is more important that I originally
                    540:   ** thought.  If a power failure occurs while the journal is being written,
                    541:   ** it could cause invalid data to be written into the journal.  We need to
                    542:   ** detect this invalid data (with high probability) and ignore it.
                    543:   */
                    544:   if( pgRec.pgno==0 ){
                    545:     return SQLITE_DONE;
                    546:   }
                    547:   if( pgRec.pgno>(unsigned)pPager->dbSize ){
                    548:     return SQLITE_OK;
                    549:   }
                    550:   if( format>=JOURNAL_FORMAT_3 ){
                    551:     rc = read32bits(format, jfd, &cksum);
                    552:     if( rc ) return rc;
                    553:     if( pager_cksum(pPager, pgRec.pgno, pgRec.aData)!=cksum ){
                    554:       return SQLITE_DONE;
                    555:     }
                    556:   }
                    557: 
                    558:   /* Playback the page.  Update the in-memory copy of the page
                    559:   ** at the same time, if there is one.
                    560:   */
                    561:   pPg = pager_lookup(pPager, pgRec.pgno);
                    562:   TRACE2("PLAYBACK %d\n", pgRec.pgno);
                    563:   sqliteOsSeek(&pPager->fd, (pgRec.pgno-1)*(off_t)SQLITE_PAGE_SIZE);
                    564:   rc = sqliteOsWrite(&pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE);
                    565:   if( pPg ){
                    566:     /* No page should ever be rolled back that is in use, except for page
                    567:     ** 1 which is held in use in order to keep the lock on the database
                    568:     ** active.
                    569:     */
                    570:     assert( pPg->nRef==0 || pPg->pgno==1 );
                    571:     memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE);
                    572:     memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
                    573:     pPg->dirty = 0;
                    574:     pPg->needSync = 0;
                    575:     CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
                    576:   }
                    577:   return rc;
                    578: }
                    579: 
                    580: /*
                    581: ** Playback the journal and thus restore the database file to
                    582: ** the state it was in before we started making changes.  
                    583: **
                    584: ** The journal file format is as follows: 
                    585: **
                    586: **    *  8 byte prefix.  One of the aJournalMagic123 vectors defined
                    587: **       above.  The format of the journal file is determined by which
                    588: **       of the three prefix vectors is seen.
                    589: **    *  4 byte big-endian integer which is the number of valid page records
                    590: **       in the journal.  If this value is 0xffffffff, then compute the
                    591: **       number of page records from the journal size.  This field appears
                    592: **       in format 3 only.
                    593: **    *  4 byte big-endian integer which is the initial value for the 
                    594: **       sanity checksum.  This field appears in format 3 only.
                    595: **    *  4 byte integer which is the number of pages to truncate the
                    596: **       database to during a rollback.
                    597: **    *  Zero or more pages instances, each as follows:
                    598: **        +  4 byte page number.
                    599: **        +  SQLITE_PAGE_SIZE bytes of data.
                    600: **        +  4 byte checksum (format 3 only)
                    601: **
                    602: ** When we speak of the journal header, we mean the first 4 bullets above.
                    603: ** Each entry in the journal is an instance of the 5th bullet.  Note that
                    604: ** bullets 2 and 3 only appear in format-3 journals.
                    605: **
                    606: ** Call the value from the second bullet "nRec".  nRec is the number of
                    607: ** valid page entries in the journal.  In most cases, you can compute the
                    608: ** value of nRec from the size of the journal file.  But if a power
                    609: ** failure occurred while the journal was being written, it could be the
                    610: ** case that the size of the journal file had already been increased but
                    611: ** the extra entries had not yet made it safely to disk.  In such a case,
                    612: ** the value of nRec computed from the file size would be too large.  For
                    613: ** that reason, we always use the nRec value in the header.
                    614: **
                    615: ** If the nRec value is 0xffffffff it means that nRec should be computed
                    616: ** from the file size.  This value is used when the user selects the
                    617: ** no-sync option for the journal.  A power failure could lead to corruption
                    618: ** in this case.  But for things like temporary table (which will be
                    619: ** deleted when the power is restored) we don't care.  
                    620: **
                    621: ** Journal formats 1 and 2 do not have an nRec value in the header so we
                    622: ** have to compute nRec from the file size.  This has risks (as described
                    623: ** above) which is why all persistent tables have been changed to use
                    624: ** format 3.
                    625: **
                    626: ** If the file opened as the journal file is not a well-formed
                    627: ** journal file then the database will likely already be
                    628: ** corrupted, so the PAGER_ERR_CORRUPT bit is set in pPager->errMask
                    629: ** and SQLITE_CORRUPT is returned.  If it all works, then this routine
                    630: ** returns SQLITE_OK.
                    631: */
                    632: static int pager_playback(Pager *pPager, int useJournalSize){
                    633:   off_t szJ;               /* Size of the journal file in bytes */
                    634:   int nRec;                /* Number of Records in the journal */
                    635:   int i;                   /* Loop counter */
                    636:   Pgno mxPg = 0;           /* Size of the original file in pages */
                    637:   int format;              /* Format of the journal file. */
                    638:   unsigned char aMagic[sizeof(aJournalMagic1)];
                    639:   int rc;
                    640: 
                    641:   /* Figure out how many records are in the journal.  Abort early if
                    642:   ** the journal is empty.
                    643:   */
                    644:   assert( pPager->journalOpen );
                    645:   sqliteOsSeek(&pPager->jfd, 0);
                    646:   rc = sqliteOsFileSize(&pPager->jfd, &szJ);
                    647:   if( rc!=SQLITE_OK ){
                    648:     goto end_playback;
                    649:   }
                    650: 
                    651:   /* If the journal file is too small to contain a complete header,
                    652:   ** it must mean that the process that created the journal was just
                    653:   ** beginning to write the journal file when it died.  In that case,
                    654:   ** the database file should have still been completely unchanged.
                    655:   ** Nothing needs to be rolled back.  We can safely ignore this journal.
                    656:   */
                    657:   if( szJ < sizeof(aMagic)+sizeof(Pgno) ){
                    658:     goto end_playback;
                    659:   }
                    660: 
                    661:   /* Read the beginning of the journal and truncate the
                    662:   ** database file back to its original size.
                    663:   */
                    664:   rc = sqliteOsRead(&pPager->jfd, aMagic, sizeof(aMagic));
                    665:   if( rc!=SQLITE_OK ){
                    666:     rc = SQLITE_PROTOCOL;
                    667:     goto end_playback;
                    668:   }
                    669:   if( memcmp(aMagic, aJournalMagic3, sizeof(aMagic))==0 ){
                    670:     format = JOURNAL_FORMAT_3;
                    671:   }else if( memcmp(aMagic, aJournalMagic2, sizeof(aMagic))==0 ){
                    672:     format = JOURNAL_FORMAT_2;
                    673:   }else if( memcmp(aMagic, aJournalMagic1, sizeof(aMagic))==0 ){
                    674:     format = JOURNAL_FORMAT_1;
                    675:   }else{
                    676:     rc = SQLITE_PROTOCOL;
                    677:     goto end_playback;
                    678:   }
                    679:   if( format>=JOURNAL_FORMAT_3 ){
                    680:     if( szJ < sizeof(aMagic) + 3*sizeof(u32) ){
                    681:       /* Ignore the journal if it is too small to contain a complete
                    682:       ** header.  We already did this test once above, but at the prior
                    683:       ** test, we did not know the journal format and so we had to assume
                    684:       ** the smallest possible header.  Now we know the header is bigger
                    685:       ** than the minimum so we test again.
                    686:       */
                    687:       goto end_playback;
                    688:     }
                    689:     rc = read32bits(format, &pPager->jfd, (u32*)&nRec);
                    690:     if( rc ) goto end_playback;
                    691:     rc = read32bits(format, &pPager->jfd, &pPager->cksumInit);
                    692:     if( rc ) goto end_playback;
                    693:     if( nRec==0xffffffff || useJournalSize ){
                    694:       nRec = (szJ - JOURNAL_HDR_SZ(3))/JOURNAL_PG_SZ(3);
                    695:     }
                    696:   }else{
                    697:     nRec = (szJ - JOURNAL_HDR_SZ(2))/JOURNAL_PG_SZ(2);
                    698:     assert( nRec*JOURNAL_PG_SZ(2)+JOURNAL_HDR_SZ(2)==szJ );
                    699:   }
                    700:   rc = read32bits(format, &pPager->jfd, &mxPg);
                    701:   if( rc!=SQLITE_OK ){
                    702:     goto end_playback;
                    703:   }
                    704:   assert( pPager->origDbSize==0 || pPager->origDbSize==mxPg );
                    705:   rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)mxPg);
                    706:   if( rc!=SQLITE_OK ){
                    707:     goto end_playback;
                    708:   }
                    709:   pPager->dbSize = mxPg;
                    710:   
                    711:   /* Copy original pages out of the journal and back into the database file.
                    712:   */
                    713:   for(i=0; i<nRec; i++){
                    714:     rc = pager_playback_one_page(pPager, &pPager->jfd, format);
                    715:     if( rc!=SQLITE_OK ){
                    716:       if( rc==SQLITE_DONE ){
                    717:         rc = SQLITE_OK;
                    718:       }
                    719:       break;
                    720:     }
                    721:   }
                    722: 
                    723:   /* Pages that have been written to the journal but never synced
                    724:   ** where not restored by the loop above.  We have to restore those
                    725:   ** pages by reading them back from the original database.
                    726:   */
                    727:   if( rc==SQLITE_OK ){
                    728:     PgHdr *pPg;
                    729:     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
                    730:       char zBuf[SQLITE_PAGE_SIZE];
                    731:       if( !pPg->dirty ) continue;
                    732:       if( (int)pPg->pgno <= pPager->origDbSize ){
                    733:         sqliteOsSeek(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)(pPg->pgno-1));
                    734:         rc = sqliteOsRead(&pPager->fd, zBuf, SQLITE_PAGE_SIZE);
                    735:         TRACE2("REFETCH %d\n", pPg->pgno);
                    736:         CODEC(pPager, zBuf, pPg->pgno, 2);
                    737:         if( rc ) break;
                    738:       }else{
                    739:         memset(zBuf, 0, SQLITE_PAGE_SIZE);
                    740:       }
                    741:       if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE) ){
                    742:         memcpy(PGHDR_TO_DATA(pPg), zBuf, SQLITE_PAGE_SIZE);
                    743:         memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
                    744:       }
                    745:       pPg->needSync = 0;
                    746:       pPg->dirty = 0;
                    747:     }
                    748:   }
                    749: 
                    750: end_playback:
                    751:   if( rc!=SQLITE_OK ){
                    752:     pager_unwritelock(pPager);
                    753:     pPager->errMask |= PAGER_ERR_CORRUPT;
                    754:     rc = SQLITE_CORRUPT;
                    755:   }else{
                    756:     rc = pager_unwritelock(pPager);
                    757:   }
                    758:   return rc;
                    759: }
                    760: 
                    761: /*
                    762: ** Playback the checkpoint journal.
                    763: **
                    764: ** This is similar to playing back the transaction journal but with
                    765: ** a few extra twists.
                    766: **
                    767: **    (1)  The number of pages in the database file at the start of
                    768: **         the checkpoint is stored in pPager->ckptSize, not in the
                    769: **         journal file itself.
                    770: **
                    771: **    (2)  In addition to playing back the checkpoint journal, also
                    772: **         playback all pages of the transaction journal beginning
                    773: **         at offset pPager->ckptJSize.
                    774: */
                    775: static int pager_ckpt_playback(Pager *pPager){
                    776:   off_t szJ;               /* Size of the full journal */
                    777:   int nRec;                /* Number of Records */
                    778:   int i;                   /* Loop counter */
                    779:   int rc;
                    780: 
                    781:   /* Truncate the database back to its original size.
                    782:   */
                    783:   rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)pPager->ckptSize);
                    784:   pPager->dbSize = pPager->ckptSize;
                    785: 
                    786:   /* Figure out how many records are in the checkpoint journal.
                    787:   */
                    788:   assert( pPager->ckptInUse && pPager->journalOpen );
                    789:   sqliteOsSeek(&pPager->cpfd, 0);
                    790:   nRec = pPager->ckptNRec;
                    791:   
                    792:   /* Copy original pages out of the checkpoint journal and back into the
                    793:   ** database file.  Note that the checkpoint journal always uses format
                    794:   ** 2 instead of format 3 since it does not need to be concerned with
                    795:   ** power failures corrupting the journal and can thus omit the checksums.
                    796:   */
                    797:   for(i=nRec-1; i>=0; i--){
                    798:     rc = pager_playback_one_page(pPager, &pPager->cpfd, 2);
                    799:     assert( rc!=SQLITE_DONE );
                    800:     if( rc!=SQLITE_OK ) goto end_ckpt_playback;
                    801:   }
                    802: 
                    803:   /* Figure out how many pages need to be copied out of the transaction
                    804:   ** journal.
                    805:   */
                    806:   rc = sqliteOsSeek(&pPager->jfd, pPager->ckptJSize);
                    807:   if( rc!=SQLITE_OK ){
                    808:     goto end_ckpt_playback;
                    809:   }
                    810:   rc = sqliteOsFileSize(&pPager->jfd, &szJ);
                    811:   if( rc!=SQLITE_OK ){
                    812:     goto end_ckpt_playback;
                    813:   }
                    814:   nRec = (szJ - pPager->ckptJSize)/JOURNAL_PG_SZ(journal_format);
                    815:   for(i=nRec-1; i>=0; i--){
                    816:     rc = pager_playback_one_page(pPager, &pPager->jfd, journal_format);
                    817:     if( rc!=SQLITE_OK ){
                    818:       assert( rc!=SQLITE_DONE );
                    819:       goto end_ckpt_playback;
                    820:     }
                    821:   }
                    822:   
                    823: end_ckpt_playback:
                    824:   if( rc!=SQLITE_OK ){
                    825:     pPager->errMask |= PAGER_ERR_CORRUPT;
                    826:     rc = SQLITE_CORRUPT;
                    827:   }
                    828:   return rc;
                    829: }
                    830: 
                    831: /*
                    832: ** Change the maximum number of in-memory pages that are allowed.
                    833: **
                    834: ** The maximum number is the absolute value of the mxPage parameter.
                    835: ** If mxPage is negative, the noSync flag is also set.  noSync bypasses
                    836: ** calls to sqliteOsSync().  The pager runs much faster with noSync on,
                    837: ** but if the operating system crashes or there is an abrupt power 
                    838: ** failure, the database file might be left in an inconsistent and
                    839: ** unrepairable state.  
                    840: */
                    841: void sqlitepager_set_cachesize(Pager *pPager, int mxPage){
                    842:   if( mxPage>=0 ){
                    843:     pPager->noSync = pPager->tempFile;
                    844:     if( pPager->noSync==0 ) pPager->needSync = 0;
                    845:   }else{
                    846:     pPager->noSync = 1;
                    847:     mxPage = -mxPage;
                    848:   }
                    849:   if( mxPage>10 ){
                    850:     pPager->mxPage = mxPage;
                    851:   }
                    852: }
                    853: 
                    854: /*
                    855: ** Adjust the robustness of the database to damage due to OS crashes
                    856: ** or power failures by changing the number of syncs()s when writing
                    857: ** the rollback journal.  There are three levels:
                    858: **
                    859: **    OFF       sqliteOsSync() is never called.  This is the default
                    860: **              for temporary and transient files.
                    861: **
                    862: **    NORMAL    The journal is synced once before writes begin on the
                    863: **              database.  This is normally adequate protection, but
                    864: **              it is theoretically possible, though very unlikely,
                    865: **              that an inopertune power failure could leave the journal
                    866: **              in a state which would cause damage to the database
                    867: **              when it is rolled back.
                    868: **
                    869: **    FULL      The journal is synced twice before writes begin on the
                    870: **              database (with some additional information - the nRec field
                    871: **              of the journal header - being written in between the two
                    872: **              syncs).  If we assume that writing a
                    873: **              single disk sector is atomic, then this mode provides
                    874: **              assurance that the journal will not be corrupted to the
                    875: **              point of causing damage to the database during rollback.
                    876: **
                    877: ** Numeric values associated with these states are OFF==1, NORMAL=2,
                    878: ** and FULL=3.
                    879: */
                    880: void sqlitepager_set_safety_level(Pager *pPager, int level){
                    881:   pPager->noSync =  level==1 || pPager->tempFile;
                    882:   pPager->fullSync = level==3 && !pPager->tempFile;
                    883:   if( pPager->noSync==0 ) pPager->needSync = 0;
                    884: }
                    885: 
                    886: /*
                    887: ** Open a temporary file.  Write the name of the file into zName
                    888: ** (zName must be at least SQLITE_TEMPNAME_SIZE bytes long.)  Write
                    889: ** the file descriptor into *fd.  Return SQLITE_OK on success or some
                    890: ** other error code if we fail.
                    891: **
                    892: ** The OS will automatically delete the temporary file when it is
                    893: ** closed.
                    894: */
                    895: static int sqlitepager_opentemp(char *zFile, OsFile *fd){
                    896:   int cnt = 8;
                    897:   int rc;
                    898:   do{
                    899:     cnt--;
                    900:     sqliteOsTempFileName(zFile);
                    901:     rc = sqliteOsOpenExclusive(zFile, fd, 1);
                    902:   }while( cnt>0 && rc!=SQLITE_OK );
                    903:   return rc;
                    904: }
                    905: 
                    906: /*
                    907: ** Create a new page cache and put a pointer to the page cache in *ppPager.
                    908: ** The file to be cached need not exist.  The file is not locked until
                    909: ** the first call to sqlitepager_get() and is only held open until the
                    910: ** last page is released using sqlitepager_unref().
                    911: **
                    912: ** If zFilename is NULL then a randomly-named temporary file is created
                    913: ** and used as the file to be cached.  The file will be deleted
                    914: ** automatically when it is closed.
                    915: */
                    916: int sqlitepager_open(
                    917:   Pager **ppPager,         /* Return the Pager structure here */
                    918:   const char *zFilename,   /* Name of the database file to open */
                    919:   int mxPage,              /* Max number of in-memory cache pages */
                    920:   int nExtra,              /* Extra bytes append to each in-memory page */
                    921:   int useJournal           /* TRUE to use a rollback journal on this file */
                    922: ){
                    923:   Pager *pPager;
                    924:   char *zFullPathname;
                    925:   int nameLen;
                    926:   OsFile fd;
                    927:   int rc, i;
                    928:   int tempFile;
                    929:   int readOnly = 0;
                    930:   char zTemp[SQLITE_TEMPNAME_SIZE];
                    931: 
                    932:   *ppPager = 0;
                    933:   if( sqlite_malloc_failed ){
                    934:     return SQLITE_NOMEM;
                    935:   }
                    936:   if( zFilename && zFilename[0] ){
                    937:     zFullPathname = sqliteOsFullPathname(zFilename);
                    938:     rc = sqliteOsOpenReadWrite(zFullPathname, &fd, &readOnly);
                    939:     tempFile = 0;
                    940:   }else{
                    941:     rc = sqlitepager_opentemp(zTemp, &fd);
                    942:     zFilename = zTemp;
                    943:     zFullPathname = sqliteOsFullPathname(zFilename);
                    944:     tempFile = 1;
                    945:   }
                    946:   if( sqlite_malloc_failed ){
                    947:     return SQLITE_NOMEM;
                    948:   }
                    949:   if( rc!=SQLITE_OK ){
                    950:     sqliteFree(zFullPathname);
                    951:     return SQLITE_CANTOPEN;
                    952:   }
                    953:   nameLen = strlen(zFullPathname);
                    954:   pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 );
                    955:   if( pPager==0 ){
                    956:     sqliteOsClose(&fd);
                    957:     sqliteFree(zFullPathname);
                    958:     return SQLITE_NOMEM;
                    959:   }
                    960:   SET_PAGER(pPager);
                    961:   pPager->zFilename = (char*)&pPager[1];
                    962:   pPager->zDirectory = &pPager->zFilename[nameLen+1];
                    963:   pPager->zJournal = &pPager->zDirectory[nameLen+1];
                    964:   strcpy(pPager->zFilename, zFullPathname);
                    965:   strcpy(pPager->zDirectory, zFullPathname);
                    966:   for(i=nameLen; i>0 && pPager->zDirectory[i-1]!='/'; i--){}
                    967:   if( i>0 ) pPager->zDirectory[i-1] = 0;
                    968:   strcpy(pPager->zJournal, zFullPathname);
                    969:   sqliteFree(zFullPathname);
                    970:   strcpy(&pPager->zJournal[nameLen], "-journal");
                    971:   pPager->fd = fd;
                    972:   pPager->journalOpen = 0;
                    973:   pPager->useJournal = useJournal;
                    974:   pPager->ckptOpen = 0;
                    975:   pPager->ckptInUse = 0;
                    976:   pPager->nRef = 0;
                    977:   pPager->dbSize = -1;
                    978:   pPager->ckptSize = 0;
                    979:   pPager->ckptJSize = 0;
                    980:   pPager->nPage = 0;
                    981:   pPager->mxPage = mxPage>5 ? mxPage : 10;
                    982:   pPager->state = SQLITE_UNLOCK;
                    983:   pPager->errMask = 0;
                    984:   pPager->tempFile = tempFile;
                    985:   pPager->readOnly = readOnly;
                    986:   pPager->needSync = 0;
                    987:   pPager->noSync = pPager->tempFile || !useJournal;
                    988:   pPager->pFirst = 0;
                    989:   pPager->pFirstSynced = 0;
                    990:   pPager->pLast = 0;
                    991:   pPager->nExtra = nExtra;
                    992:   memset(pPager->aHash, 0, sizeof(pPager->aHash));
                    993:   *ppPager = pPager;
                    994:   return SQLITE_OK;
                    995: }
                    996: 
                    997: /*
                    998: ** Set the destructor for this pager.  If not NULL, the destructor is called
                    999: ** when the reference count on each page reaches zero.  The destructor can
                   1000: ** be used to clean up information in the extra segment appended to each page.
                   1001: **
                   1002: ** The destructor is not called as a result sqlitepager_close().  
                   1003: ** Destructors are only called by sqlitepager_unref().
                   1004: */
                   1005: void sqlitepager_set_destructor(Pager *pPager, void (*xDesc)(void*)){
                   1006:   pPager->xDestructor = xDesc;
                   1007: }
                   1008: 
                   1009: /*
                   1010: ** Return the total number of pages in the disk file associated with
                   1011: ** pPager.
                   1012: */
                   1013: int sqlitepager_pagecount(Pager *pPager){
                   1014:   off_t n;
                   1015:   assert( pPager!=0 );
                   1016:   if( pPager->dbSize>=0 ){
                   1017:     return pPager->dbSize;
                   1018:   }
                   1019:   if( sqliteOsFileSize(&pPager->fd, &n)!=SQLITE_OK ){
                   1020:     pPager->errMask |= PAGER_ERR_DISK;
                   1021:     return 0;
                   1022:   }
                   1023:   n /= SQLITE_PAGE_SIZE;
                   1024:   if( pPager->state!=SQLITE_UNLOCK ){
                   1025:     pPager->dbSize = n;
                   1026:   }
                   1027:   return n;
                   1028: }
                   1029: 
                   1030: /*
                   1031: ** Forward declaration
                   1032: */
                   1033: static int syncJournal(Pager*);
                   1034: 
                   1035: /*
                   1036: ** Truncate the file to the number of pages specified.
                   1037: */
                   1038: int sqlitepager_truncate(Pager *pPager, Pgno nPage){
                   1039:   int rc;
                   1040:   if( pPager->dbSize<0 ){
                   1041:     sqlitepager_pagecount(pPager);
                   1042:   }
                   1043:   if( pPager->errMask!=0 ){
                   1044:     rc = pager_errcode(pPager);
                   1045:     return rc;
                   1046:   }
                   1047:   if( nPage>=(unsigned)pPager->dbSize ){
                   1048:     return SQLITE_OK;
                   1049:   }
                   1050:   syncJournal(pPager);
                   1051:   rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)nPage);
                   1052:   if( rc==SQLITE_OK ){
                   1053:     pPager->dbSize = nPage;
                   1054:   }
                   1055:   return rc;
                   1056: }
                   1057: 
                   1058: /*
                   1059: ** Shutdown the page cache.  Free all memory and close all files.
                   1060: **
                   1061: ** If a transaction was in progress when this routine is called, that
                   1062: ** transaction is rolled back.  All outstanding pages are invalidated
                   1063: ** and their memory is freed.  Any attempt to use a page associated
                   1064: ** with this page cache after this function returns will likely
                   1065: ** result in a coredump.
                   1066: */
                   1067: int sqlitepager_close(Pager *pPager){
                   1068:   PgHdr *pPg, *pNext;
                   1069:   switch( pPager->state ){
                   1070:     case SQLITE_WRITELOCK: {
                   1071:       sqlitepager_rollback(pPager);
                   1072:       sqliteOsUnlock(&pPager->fd);
                   1073:       assert( pPager->journalOpen==0 );
                   1074:       break;
                   1075:     }
                   1076:     case SQLITE_READLOCK: {
                   1077:       sqliteOsUnlock(&pPager->fd);
                   1078:       break;
                   1079:     }
                   1080:     default: {
                   1081:       /* Do nothing */
                   1082:       break;
                   1083:     }
                   1084:   }
                   1085:   for(pPg=pPager->pAll; pPg; pPg=pNext){
                   1086:     pNext = pPg->pNextAll;
                   1087:     sqliteFree(pPg);
                   1088:   }
                   1089:   sqliteOsClose(&pPager->fd);
                   1090:   assert( pPager->journalOpen==0 );
                   1091:   /* Temp files are automatically deleted by the OS
                   1092:   ** if( pPager->tempFile ){
                   1093:   **   sqliteOsDelete(pPager->zFilename);
                   1094:   ** }
                   1095:   */
                   1096:   CLR_PAGER(pPager);
                   1097:   if( pPager->zFilename!=(char*)&pPager[1] ){
                   1098:     assert( 0 );  /* Cannot happen */
                   1099:     sqliteFree(pPager->zFilename);
                   1100:     sqliteFree(pPager->zJournal);
                   1101:     sqliteFree(pPager->zDirectory);
                   1102:   }
                   1103:   sqliteFree(pPager);
                   1104:   return SQLITE_OK;
                   1105: }
                   1106: 
                   1107: /*
                   1108: ** Return the page number for the given page data.
                   1109: */
                   1110: Pgno sqlitepager_pagenumber(void *pData){
                   1111:   PgHdr *p = DATA_TO_PGHDR(pData);
                   1112:   return p->pgno;
                   1113: }
                   1114: 
                   1115: /*
                   1116: ** Increment the reference count for a page.  If the page is
                   1117: ** currently on the freelist (the reference count is zero) then
                   1118: ** remove it from the freelist.
                   1119: */
                   1120: #define page_ref(P)   ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++)
                   1121: static void _page_ref(PgHdr *pPg){
                   1122:   if( pPg->nRef==0 ){
                   1123:     /* The page is currently on the freelist.  Remove it. */
                   1124:     if( pPg==pPg->pPager->pFirstSynced ){
                   1125:       PgHdr *p = pPg->pNextFree;
                   1126:       while( p && p->needSync ){ p = p->pNextFree; }
                   1127:       pPg->pPager->pFirstSynced = p;
                   1128:     }
                   1129:     if( pPg->pPrevFree ){
                   1130:       pPg->pPrevFree->pNextFree = pPg->pNextFree;
                   1131:     }else{
                   1132:       pPg->pPager->pFirst = pPg->pNextFree;
                   1133:     }
                   1134:     if( pPg->pNextFree ){
                   1135:       pPg->pNextFree->pPrevFree = pPg->pPrevFree;
                   1136:     }else{
                   1137:       pPg->pPager->pLast = pPg->pPrevFree;
                   1138:     }
                   1139:     pPg->pPager->nRef++;
                   1140:   }
                   1141:   pPg->nRef++;
                   1142:   REFINFO(pPg);
                   1143: }
                   1144: 
                   1145: /*
                   1146: ** Increment the reference count for a page.  The input pointer is
                   1147: ** a reference to the page data.
                   1148: */
                   1149: int sqlitepager_ref(void *pData){
                   1150:   PgHdr *pPg = DATA_TO_PGHDR(pData);
                   1151:   page_ref(pPg);
                   1152:   return SQLITE_OK;
                   1153: }
                   1154: 
                   1155: /*
                   1156: ** Sync the journal.  In other words, make sure all the pages that have
                   1157: ** been written to the journal have actually reached the surface of the
                   1158: ** disk.  It is not safe to modify the original database file until after
                   1159: ** the journal has been synced.  If the original database is modified before
                   1160: ** the journal is synced and a power failure occurs, the unsynced journal
                   1161: ** data would be lost and we would be unable to completely rollback the
                   1162: ** database changes.  Database corruption would occur.
                   1163: ** 
                   1164: ** This routine also updates the nRec field in the header of the journal.
                   1165: ** (See comments on the pager_playback() routine for additional information.)
                   1166: ** If the sync mode is FULL, two syncs will occur.  First the whole journal
                   1167: ** is synced, then the nRec field is updated, then a second sync occurs.
                   1168: **
                   1169: ** For temporary databases, we do not care if we are able to rollback
                   1170: ** after a power failure, so sync occurs.
                   1171: **
                   1172: ** This routine clears the needSync field of every page current held in
                   1173: ** memory.
                   1174: */
                   1175: static int syncJournal(Pager *pPager){
                   1176:   PgHdr *pPg;
                   1177:   int rc = SQLITE_OK;
                   1178: 
                   1179:   /* Sync the journal before modifying the main database
                   1180:   ** (assuming there is a journal and it needs to be synced.)
                   1181:   */
                   1182:   if( pPager->needSync ){
                   1183:     if( !pPager->tempFile ){
                   1184:       assert( pPager->journalOpen );
                   1185:       /* assert( !pPager->noSync ); // noSync might be set if synchronous
                   1186:       ** was turned off after the transaction was started.  Ticket #615 */
                   1187: #ifndef NDEBUG
                   1188:       {
                   1189:         /* Make sure the pPager->nRec counter we are keeping agrees
                   1190:         ** with the nRec computed from the size of the journal file.
                   1191:         */
                   1192:         off_t hdrSz, pgSz, jSz;
                   1193:         hdrSz = JOURNAL_HDR_SZ(journal_format);
                   1194:         pgSz = JOURNAL_PG_SZ(journal_format);
                   1195:         rc = sqliteOsFileSize(&pPager->jfd, &jSz);
                   1196:         if( rc!=0 ) return rc;
                   1197:         assert( pPager->nRec*pgSz+hdrSz==jSz );
                   1198:       }
                   1199: #endif
                   1200:       if( journal_format>=3 ){
                   1201:         /* Write the nRec value into the journal file header */
                   1202:         off_t szJ;
                   1203:         if( pPager->fullSync ){
                   1204:           TRACE1("SYNC\n");
                   1205:           rc = sqliteOsSync(&pPager->jfd);
                   1206:           if( rc!=0 ) return rc;
                   1207:         }
                   1208:         sqliteOsSeek(&pPager->jfd, sizeof(aJournalMagic1));
                   1209:         rc = write32bits(&pPager->jfd, pPager->nRec);
                   1210:         if( rc ) return rc;
                   1211:         szJ = JOURNAL_HDR_SZ(journal_format) +
                   1212:                  pPager->nRec*JOURNAL_PG_SZ(journal_format);
                   1213:         sqliteOsSeek(&pPager->jfd, szJ);
                   1214:       }
                   1215:       TRACE1("SYNC\n");
                   1216:       rc = sqliteOsSync(&pPager->jfd);
                   1217:       if( rc!=0 ) return rc;
                   1218:       pPager->journalStarted = 1;
                   1219:     }
                   1220:     pPager->needSync = 0;
                   1221: 
                   1222:     /* Erase the needSync flag from every page.
                   1223:     */
                   1224:     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
                   1225:       pPg->needSync = 0;
                   1226:     }
                   1227:     pPager->pFirstSynced = pPager->pFirst;
                   1228:   }
                   1229: 
                   1230: #ifndef NDEBUG
                   1231:   /* If the Pager.needSync flag is clear then the PgHdr.needSync
                   1232:   ** flag must also be clear for all pages.  Verify that this
                   1233:   ** invariant is true.
                   1234:   */
                   1235:   else{
                   1236:     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
                   1237:       assert( pPg->needSync==0 );
                   1238:     }
                   1239:     assert( pPager->pFirstSynced==pPager->pFirst );
                   1240:   }
                   1241: #endif
                   1242: 
                   1243:   return rc;
                   1244: }
                   1245: 
                   1246: /*
                   1247: ** Given a list of pages (connected by the PgHdr.pDirty pointer) write
                   1248: ** every one of those pages out to the database file and mark them all
                   1249: ** as clean.
                   1250: */
                   1251: static int pager_write_pagelist(PgHdr *pList){
                   1252:   Pager *pPager;
                   1253:   int rc;
                   1254: 
                   1255:   if( pList==0 ) return SQLITE_OK;
                   1256:   pPager = pList->pPager;
                   1257:   while( pList ){
                   1258:     assert( pList->dirty );
                   1259:     sqliteOsSeek(&pPager->fd, (pList->pgno-1)*(off_t)SQLITE_PAGE_SIZE);
                   1260:     CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);
                   1261:     TRACE2("STORE %d\n", pList->pgno);
                   1262:     rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pList), SQLITE_PAGE_SIZE);
                   1263:     CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 0);
                   1264:     if( rc ) return rc;
                   1265:     pList->dirty = 0;
                   1266:     pList = pList->pDirty;
                   1267:   }
                   1268:   return SQLITE_OK;
                   1269: }
                   1270: 
                   1271: /*
                   1272: ** Collect every dirty page into a dirty list and
                   1273: ** return a pointer to the head of that list.  All pages are
                   1274: ** collected even if they are still in use.
                   1275: */
                   1276: static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
                   1277:   PgHdr *p, *pList;
                   1278:   pList = 0;
                   1279:   for(p=pPager->pAll; p; p=p->pNextAll){
                   1280:     if( p->dirty ){
                   1281:       p->pDirty = pList;
                   1282:       pList = p;
                   1283:     }
                   1284:   }
                   1285:   return pList;
                   1286: }
                   1287: 
                   1288: /*
                   1289: ** Acquire a page.
                   1290: **
                   1291: ** A read lock on the disk file is obtained when the first page is acquired. 
                   1292: ** This read lock is dropped when the last page is released.
                   1293: **
                   1294: ** A _get works for any page number greater than 0.  If the database
                   1295: ** file is smaller than the requested page, then no actual disk
                   1296: ** read occurs and the memory image of the page is initialized to
                   1297: ** all zeros.  The extra data appended to a page is always initialized
                   1298: ** to zeros the first time a page is loaded into memory.
                   1299: **
                   1300: ** The acquisition might fail for several reasons.  In all cases,
                   1301: ** an appropriate error code is returned and *ppPage is set to NULL.
                   1302: **
                   1303: ** See also sqlitepager_lookup().  Both this routine and _lookup() attempt
                   1304: ** to find a page in the in-memory cache first.  If the page is not already
                   1305: ** in memory, this routine goes to disk to read it in whereas _lookup()
                   1306: ** just returns 0.  This routine acquires a read-lock the first time it
                   1307: ** has to go to disk, and could also playback an old journal if necessary.
                   1308: ** Since _lookup() never goes to disk, it never has to deal with locks
                   1309: ** or journal files.
                   1310: */
                   1311: int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
                   1312:   PgHdr *pPg;
                   1313:   int rc;
                   1314: 
                   1315:   /* Make sure we have not hit any critical errors.
                   1316:   */ 
                   1317:   assert( pPager!=0 );
                   1318:   assert( pgno!=0 );
                   1319:   *ppPage = 0;
                   1320:   if( pPager->errMask & ~(PAGER_ERR_FULL) ){
                   1321:     return pager_errcode(pPager);
                   1322:   }
                   1323: 
                   1324:   /* If this is the first page accessed, then get a read lock
                   1325:   ** on the database file.
                   1326:   */
                   1327:   if( pPager->nRef==0 ){
                   1328:     rc = sqliteOsReadLock(&pPager->fd);
                   1329:     if( rc!=SQLITE_OK ){
                   1330:       return rc;
                   1331:     }
                   1332:     pPager->state = SQLITE_READLOCK;
                   1333: 
                   1334:     /* If a journal file exists, try to play it back.
                   1335:     */
                   1336:     if( pPager->useJournal && sqliteOsFileExists(pPager->zJournal) ){
                   1337:        int rc;
                   1338: 
                   1339:        /* Get a write lock on the database
                   1340:        */
                   1341:        rc = sqliteOsWriteLock(&pPager->fd);
                   1342:        if( rc!=SQLITE_OK ){
                   1343:          if( sqliteOsUnlock(&pPager->fd)!=SQLITE_OK ){
                   1344:            /* This should never happen! */
                   1345:            rc = SQLITE_INTERNAL;
                   1346:          }
                   1347:          return rc;
                   1348:        }
                   1349:        pPager->state = SQLITE_WRITELOCK;
                   1350: 
                   1351:        /* Open the journal for reading only.  Return SQLITE_BUSY if
                   1352:        ** we are unable to open the journal file. 
                   1353:        **
                   1354:        ** The journal file does not need to be locked itself.  The
                   1355:        ** journal file is never open unless the main database file holds
                   1356:        ** a write lock, so there is never any chance of two or more
                   1357:        ** processes opening the journal at the same time.
                   1358:        */
                   1359:        rc = sqliteOsOpenReadOnly(pPager->zJournal, &pPager->jfd);
                   1360:        if( rc!=SQLITE_OK ){
                   1361:          rc = sqliteOsUnlock(&pPager->fd);
                   1362:          assert( rc==SQLITE_OK );
                   1363:          return SQLITE_BUSY;
                   1364:        }
                   1365:        pPager->journalOpen = 1;
                   1366:        pPager->journalStarted = 0;
                   1367: 
                   1368:        /* Playback and delete the journal.  Drop the database write
                   1369:        ** lock and reacquire the read lock.
                   1370:        */
                   1371:        rc = pager_playback(pPager, 0);
                   1372:        if( rc!=SQLITE_OK ){
                   1373:          return rc;
                   1374:        }
                   1375:     }
                   1376:     pPg = 0;
                   1377:   }else{
                   1378:     /* Search for page in cache */
                   1379:     pPg = pager_lookup(pPager, pgno);
                   1380:   }
                   1381:   if( pPg==0 ){
                   1382:     /* The requested page is not in the page cache. */
                   1383:     int h;
                   1384:     pPager->nMiss++;
                   1385:     if( pPager->nPage<pPager->mxPage || pPager->pFirst==0 ){
                   1386:       /* Create a new page */
                   1387:       pPg = sqliteMallocRaw( sizeof(*pPg) + SQLITE_PAGE_SIZE 
                   1388:                               + sizeof(u32) + pPager->nExtra );
                   1389:       if( pPg==0 ){
                   1390:         pager_unwritelock(pPager);
                   1391:         pPager->errMask |= PAGER_ERR_MEM;
                   1392:         return SQLITE_NOMEM;
                   1393:       }
                   1394:       memset(pPg, 0, sizeof(*pPg));
                   1395:       pPg->pPager = pPager;
                   1396:       pPg->pNextAll = pPager->pAll;
                   1397:       if( pPager->pAll ){
                   1398:         pPager->pAll->pPrevAll = pPg;
                   1399:       }
                   1400:       pPg->pPrevAll = 0;
                   1401:       pPager->pAll = pPg;
                   1402:       pPager->nPage++;
                   1403:     }else{
                   1404:       /* Find a page to recycle.  Try to locate a page that does not
                   1405:       ** require us to do an fsync() on the journal.
                   1406:       */
                   1407:       pPg = pPager->pFirstSynced;
                   1408: 
                   1409:       /* If we could not find a page that does not require an fsync()
                   1410:       ** on the journal file then fsync the journal file.  This is a
                   1411:       ** very slow operation, so we work hard to avoid it.  But sometimes
                   1412:       ** it can't be helped.
                   1413:       */
                   1414:       if( pPg==0 ){
                   1415:         int rc = syncJournal(pPager);
                   1416:         if( rc!=0 ){
                   1417:           sqlitepager_rollback(pPager);
                   1418:           return SQLITE_IOERR;
                   1419:         }
                   1420:         pPg = pPager->pFirst;
                   1421:       }
                   1422:       assert( pPg->nRef==0 );
                   1423: 
                   1424:       /* Write the page to the database file if it is dirty.
                   1425:       */
                   1426:       if( pPg->dirty ){
                   1427:         assert( pPg->needSync==0 );
                   1428:         pPg->pDirty = 0;
                   1429:         rc = pager_write_pagelist( pPg );
                   1430:         if( rc!=SQLITE_OK ){
                   1431:           sqlitepager_rollback(pPager);
                   1432:           return SQLITE_IOERR;
                   1433:         }
                   1434:       }
                   1435:       assert( pPg->dirty==0 );
                   1436: 
                   1437:       /* If the page we are recycling is marked as alwaysRollback, then
                   1438:       ** set the global alwaysRollback flag, thus disabling the
                   1439:       ** sqlite_dont_rollback() optimization for the rest of this transaction.
                   1440:       ** It is necessary to do this because the page marked alwaysRollback
                   1441:       ** might be reloaded at a later time but at that point we won't remember
                   1442:       ** that is was marked alwaysRollback.  This means that all pages must
                   1443:       ** be marked as alwaysRollback from here on out.
                   1444:       */
                   1445:       if( pPg->alwaysRollback ){
                   1446:         pPager->alwaysRollback = 1;
                   1447:       }
                   1448: 
                   1449:       /* Unlink the old page from the free list and the hash table
                   1450:       */
                   1451:       if( pPg==pPager->pFirstSynced ){
                   1452:         PgHdr *p = pPg->pNextFree;
                   1453:         while( p && p->needSync ){ p = p->pNextFree; }
                   1454:         pPager->pFirstSynced = p;
                   1455:       }
                   1456:       if( pPg->pPrevFree ){
                   1457:         pPg->pPrevFree->pNextFree = pPg->pNextFree;
                   1458:       }else{
                   1459:         assert( pPager->pFirst==pPg );
                   1460:         pPager->pFirst = pPg->pNextFree;
                   1461:       }
                   1462:       if( pPg->pNextFree ){
                   1463:         pPg->pNextFree->pPrevFree = pPg->pPrevFree;
                   1464:       }else{
                   1465:         assert( pPager->pLast==pPg );
                   1466:         pPager->pLast = pPg->pPrevFree;
                   1467:       }
                   1468:       pPg->pNextFree = pPg->pPrevFree = 0;
                   1469:       if( pPg->pNextHash ){
                   1470:         pPg->pNextHash->pPrevHash = pPg->pPrevHash;
                   1471:       }
                   1472:       if( pPg->pPrevHash ){
                   1473:         pPg->pPrevHash->pNextHash = pPg->pNextHash;
                   1474:       }else{
                   1475:         h = pager_hash(pPg->pgno);
                   1476:         assert( pPager->aHash[h]==pPg );
                   1477:         pPager->aHash[h] = pPg->pNextHash;
                   1478:       }
                   1479:       pPg->pNextHash = pPg->pPrevHash = 0;
                   1480:       pPager->nOvfl++;
                   1481:     }
                   1482:     pPg->pgno = pgno;
                   1483:     if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
                   1484:       sqliteCheckMemory(pPager->aInJournal, pgno/8);
                   1485:       assert( pPager->journalOpen );
                   1486:       pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
                   1487:       pPg->needSync = 0;
                   1488:     }else{
                   1489:       pPg->inJournal = 0;
                   1490:       pPg->needSync = 0;
                   1491:     }
                   1492:     if( pPager->aInCkpt && (int)pgno<=pPager->ckptSize
                   1493:              && (pPager->aInCkpt[pgno/8] & (1<<(pgno&7)))!=0 ){
                   1494:       page_add_to_ckpt_list(pPg);
                   1495:     }else{
                   1496:       page_remove_from_ckpt_list(pPg);
                   1497:     }
                   1498:     pPg->dirty = 0;
                   1499:     pPg->nRef = 1;
                   1500:     REFINFO(pPg);
                   1501:     pPager->nRef++;
                   1502:     h = pager_hash(pgno);
                   1503:     pPg->pNextHash = pPager->aHash[h];
                   1504:     pPager->aHash[h] = pPg;
                   1505:     if( pPg->pNextHash ){
                   1506:       assert( pPg->pNextHash->pPrevHash==0 );
                   1507:       pPg->pNextHash->pPrevHash = pPg;
                   1508:     }
                   1509:     if( pPager->nExtra>0 ){
                   1510:       memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
                   1511:     }
                   1512:     if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager);
                   1513:     if( pPager->errMask!=0 ){
                   1514:       sqlitepager_unref(PGHDR_TO_DATA(pPg));
                   1515:       rc = pager_errcode(pPager);
                   1516:       return rc;
                   1517:     }
                   1518:     if( pPager->dbSize<(int)pgno ){
                   1519:       memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE);
                   1520:     }else{
                   1521:       int rc;
                   1522:       sqliteOsSeek(&pPager->fd, (pgno-1)*(off_t)SQLITE_PAGE_SIZE);
                   1523:       rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE);
                   1524:       TRACE2("FETCH %d\n", pPg->pgno);
                   1525:       CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
                   1526:       if( rc!=SQLITE_OK ){
                   1527:         off_t fileSize;
                   1528:         if( sqliteOsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK
                   1529:                || fileSize>=pgno*SQLITE_PAGE_SIZE ){
                   1530:           sqlitepager_unref(PGHDR_TO_DATA(pPg));
                   1531:           return rc;
                   1532:         }else{
                   1533:           memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE);
                   1534:         }
                   1535:       }
                   1536:     }
                   1537:   }else{
                   1538:     /* The requested page is in the page cache. */
                   1539:     pPager->nHit++;
                   1540:     page_ref(pPg);
                   1541:   }
                   1542:   *ppPage = PGHDR_TO_DATA(pPg);
                   1543:   return SQLITE_OK;
                   1544: }
                   1545: 
                   1546: /*
                   1547: ** Acquire a page if it is already in the in-memory cache.  Do
                   1548: ** not read the page from disk.  Return a pointer to the page,
                   1549: ** or 0 if the page is not in cache.
                   1550: **
                   1551: ** See also sqlitepager_get().  The difference between this routine
                   1552: ** and sqlitepager_get() is that _get() will go to the disk and read
                   1553: ** in the page if the page is not already in cache.  This routine
                   1554: ** returns NULL if the page is not in cache or if a disk I/O error 
                   1555: ** has ever happened.
                   1556: */
                   1557: void *sqlitepager_lookup(Pager *pPager, Pgno pgno){
                   1558:   PgHdr *pPg;
                   1559: 
                   1560:   assert( pPager!=0 );
                   1561:   assert( pgno!=0 );
                   1562:   if( pPager->errMask & ~(PAGER_ERR_FULL) ){
                   1563:     return 0;
                   1564:   }
                   1565:   /* if( pPager->nRef==0 ){
                   1566:   **  return 0;
                   1567:   ** }
                   1568:   */
                   1569:   pPg = pager_lookup(pPager, pgno);
                   1570:   if( pPg==0 ) return 0;
                   1571:   page_ref(pPg);
                   1572:   return PGHDR_TO_DATA(pPg);
                   1573: }
                   1574: 
                   1575: /*
                   1576: ** Release a page.
                   1577: **
                   1578: ** If the number of references to the page drop to zero, then the
                   1579: ** page is added to the LRU list.  When all references to all pages
                   1580: ** are released, a rollback occurs and the lock on the database is
                   1581: ** removed.
                   1582: */
                   1583: int sqlitepager_unref(void *pData){
                   1584:   PgHdr *pPg;
                   1585: 
                   1586:   /* Decrement the reference count for this page
                   1587:   */
                   1588:   pPg = DATA_TO_PGHDR(pData);
                   1589:   assert( pPg->nRef>0 );
                   1590:   pPg->nRef--;
                   1591:   REFINFO(pPg);
                   1592: 
                   1593:   /* When the number of references to a page reach 0, call the
                   1594:   ** destructor and add the page to the freelist.
                   1595:   */
                   1596:   if( pPg->nRef==0 ){
                   1597:     Pager *pPager;
                   1598:     pPager = pPg->pPager;
                   1599:     pPg->pNextFree = 0;
                   1600:     pPg->pPrevFree = pPager->pLast;
                   1601:     pPager->pLast = pPg;
                   1602:     if( pPg->pPrevFree ){
                   1603:       pPg->pPrevFree->pNextFree = pPg;
                   1604:     }else{
                   1605:       pPager->pFirst = pPg;
                   1606:     }
                   1607:     if( pPg->needSync==0 && pPager->pFirstSynced==0 ){
                   1608:       pPager->pFirstSynced = pPg;
                   1609:     }
                   1610:     if( pPager->xDestructor ){
                   1611:       pPager->xDestructor(pData);
                   1612:     }
                   1613:   
                   1614:     /* When all pages reach the freelist, drop the read lock from
                   1615:     ** the database file.
                   1616:     */
                   1617:     pPager->nRef--;
                   1618:     assert( pPager->nRef>=0 );
                   1619:     if( pPager->nRef==0 ){
                   1620:       pager_reset(pPager);
                   1621:     }
                   1622:   }
                   1623:   return SQLITE_OK;
                   1624: }
                   1625: 
                   1626: /*
                   1627: ** Create a journal file for pPager.  There should already be a write
                   1628: ** lock on the database file when this routine is called.
                   1629: **
                   1630: ** Return SQLITE_OK if everything.  Return an error code and release the
                   1631: ** write lock if anything goes wrong.
                   1632: */
                   1633: static int pager_open_journal(Pager *pPager){
                   1634:   int rc;
                   1635:   assert( pPager->state==SQLITE_WRITELOCK );
                   1636:   assert( pPager->journalOpen==0 );
                   1637:   assert( pPager->useJournal );
                   1638:   sqlitepager_pagecount(pPager);
                   1639:   pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 );
                   1640:   if( pPager->aInJournal==0 ){
                   1641:     sqliteOsReadLock(&pPager->fd);
                   1642:     pPager->state = SQLITE_READLOCK;
                   1643:     return SQLITE_NOMEM;
                   1644:   }
                   1645:   rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd,pPager->tempFile);
                   1646:   if( rc!=SQLITE_OK ){
                   1647:     sqliteFree(pPager->aInJournal);
                   1648:     pPager->aInJournal = 0;
                   1649:     sqliteOsReadLock(&pPager->fd);
                   1650:     pPager->state = SQLITE_READLOCK;
                   1651:     return SQLITE_CANTOPEN;
                   1652:   }
                   1653:   sqliteOsOpenDirectory(pPager->zDirectory, &pPager->jfd);
                   1654:   pPager->journalOpen = 1;
                   1655:   pPager->journalStarted = 0;
                   1656:   pPager->needSync = 0;
                   1657:   pPager->alwaysRollback = 0;
                   1658:   pPager->nRec = 0;
                   1659:   if( pPager->errMask!=0 ){
                   1660:     rc = pager_errcode(pPager);
                   1661:     return rc;
                   1662:   }
                   1663:   pPager->origDbSize = pPager->dbSize;
                   1664:   if( journal_format==JOURNAL_FORMAT_3 ){
                   1665:     rc = sqliteOsWrite(&pPager->jfd, aJournalMagic3, sizeof(aJournalMagic3));
                   1666:     if( rc==SQLITE_OK ){
                   1667:       rc = write32bits(&pPager->jfd, pPager->noSync ? 0xffffffff : 0);
                   1668:     }
                   1669:     if( rc==SQLITE_OK ){
                   1670:       sqliteRandomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
                   1671:       rc = write32bits(&pPager->jfd, pPager->cksumInit);
                   1672:     }
                   1673:   }else if( journal_format==JOURNAL_FORMAT_2 ){
                   1674:     rc = sqliteOsWrite(&pPager->jfd, aJournalMagic2, sizeof(aJournalMagic2));
                   1675:   }else{
                   1676:     assert( journal_format==JOURNAL_FORMAT_1 );
                   1677:     rc = sqliteOsWrite(&pPager->jfd, aJournalMagic1, sizeof(aJournalMagic1));
                   1678:   }
                   1679:   if( rc==SQLITE_OK ){
                   1680:     rc = write32bits(&pPager->jfd, pPager->dbSize);
                   1681:   }
                   1682:   if( pPager->ckptAutoopen && rc==SQLITE_OK ){
                   1683:     rc = sqlitepager_ckpt_begin(pPager);
                   1684:   }
                   1685:   if( rc!=SQLITE_OK ){
                   1686:     rc = pager_unwritelock(pPager);
                   1687:     if( rc==SQLITE_OK ){
                   1688:       rc = SQLITE_FULL;
                   1689:     }
                   1690:   }
                   1691:   return rc;  
                   1692: }
                   1693: 
                   1694: /*
                   1695: ** Acquire a write-lock on the database.  The lock is removed when
                   1696: ** the any of the following happen:
                   1697: **
                   1698: **   *  sqlitepager_commit() is called.
                   1699: **   *  sqlitepager_rollback() is called.
                   1700: **   *  sqlitepager_close() is called.
                   1701: **   *  sqlitepager_unref() is called to on every outstanding page.
                   1702: **
                   1703: ** The parameter to this routine is a pointer to any open page of the
                   1704: ** database file.  Nothing changes about the page - it is used merely
                   1705: ** to acquire a pointer to the Pager structure and as proof that there
                   1706: ** is already a read-lock on the database.
                   1707: **
                   1708: ** A journal file is opened if this is not a temporary file.  For
                   1709: ** temporary files, the opening of the journal file is deferred until
                   1710: ** there is an actual need to write to the journal.
                   1711: **
                   1712: ** If the database is already write-locked, this routine is a no-op.
                   1713: */
                   1714: int sqlitepager_begin(void *pData){
                   1715:   PgHdr *pPg = DATA_TO_PGHDR(pData);
                   1716:   Pager *pPager = pPg->pPager;
                   1717:   int rc = SQLITE_OK;
                   1718:   assert( pPg->nRef>0 );
                   1719:   assert( pPager->state!=SQLITE_UNLOCK );
                   1720:   if( pPager->state==SQLITE_READLOCK ){
                   1721:     assert( pPager->aInJournal==0 );
                   1722:     rc = sqliteOsWriteLock(&pPager->fd);
                   1723:     if( rc!=SQLITE_OK ){
                   1724:       return rc;
                   1725:     }
                   1726:     pPager->state = SQLITE_WRITELOCK;
                   1727:     pPager->dirtyFile = 0;
                   1728:     TRACE1("TRANSACTION\n");
                   1729:     if( pPager->useJournal && !pPager->tempFile ){
                   1730:       rc = pager_open_journal(pPager);
                   1731:     }
                   1732:   }
                   1733:   return rc;
                   1734: }
                   1735: 
                   1736: /*
                   1737: ** Mark a data page as writeable.  The page is written into the journal 
                   1738: ** if it is not there already.  This routine must be called before making
                   1739: ** changes to a page.
                   1740: **
                   1741: ** The first time this routine is called, the pager creates a new
                   1742: ** journal and acquires a write lock on the database.  If the write
                   1743: ** lock could not be acquired, this routine returns SQLITE_BUSY.  The
                   1744: ** calling routine must check for that return value and be careful not to
                   1745: ** change any page data until this routine returns SQLITE_OK.
                   1746: **
                   1747: ** If the journal file could not be written because the disk is full,
                   1748: ** then this routine returns SQLITE_FULL and does an immediate rollback.
                   1749: ** All subsequent write attempts also return SQLITE_FULL until there
                   1750: ** is a call to sqlitepager_commit() or sqlitepager_rollback() to
                   1751: ** reset.
                   1752: */
                   1753: int sqlitepager_write(void *pData){
                   1754:   PgHdr *pPg = DATA_TO_PGHDR(pData);
                   1755:   Pager *pPager = pPg->pPager;
                   1756:   int rc = SQLITE_OK;
                   1757: 
                   1758:   /* Check for errors
                   1759:   */
                   1760:   if( pPager->errMask ){ 
                   1761:     return pager_errcode(pPager);
                   1762:   }
                   1763:   if( pPager->readOnly ){
                   1764:     return SQLITE_PERM;
                   1765:   }
                   1766: 
                   1767:   /* Mark the page as dirty.  If the page has already been written
                   1768:   ** to the journal then we can return right away.
                   1769:   */
                   1770:   pPg->dirty = 1;
                   1771:   if( pPg->inJournal && (pPg->inCkpt || pPager->ckptInUse==0) ){
                   1772:     pPager->dirtyFile = 1;
                   1773:     return SQLITE_OK;
                   1774:   }
                   1775: 
                   1776:   /* If we get this far, it means that the page needs to be
                   1777:   ** written to the transaction journal or the ckeckpoint journal
                   1778:   ** or both.
                   1779:   **
                   1780:   ** First check to see that the transaction journal exists and
                   1781:   ** create it if it does not.
                   1782:   */
                   1783:   assert( pPager->state!=SQLITE_UNLOCK );
                   1784:   rc = sqlitepager_begin(pData);
                   1785:   if( rc!=SQLITE_OK ){
                   1786:     return rc;
                   1787:   }
                   1788:   assert( pPager->state==SQLITE_WRITELOCK );
                   1789:   if( !pPager->journalOpen && pPager->useJournal ){
                   1790:     rc = pager_open_journal(pPager);
                   1791:     if( rc!=SQLITE_OK ) return rc;
                   1792:   }
                   1793:   assert( pPager->journalOpen || !pPager->useJournal );
                   1794:   pPager->dirtyFile = 1;
                   1795: 
                   1796:   /* The transaction journal now exists and we have a write lock on the
                   1797:   ** main database file.  Write the current page to the transaction 
                   1798:   ** journal if it is not there already.
                   1799:   */
                   1800:   if( !pPg->inJournal && pPager->useJournal ){
                   1801:     if( (int)pPg->pgno <= pPager->origDbSize ){
                   1802:       int szPg;
                   1803:       u32 saved;
                   1804:       if( journal_format>=JOURNAL_FORMAT_3 ){
                   1805:         u32 cksum = pager_cksum(pPager, pPg->pgno, pData);
                   1806:         saved = *(u32*)PGHDR_TO_EXTRA(pPg);
                   1807:         store32bits(cksum, pPg, SQLITE_PAGE_SIZE);
                   1808:         szPg = SQLITE_PAGE_SIZE+8;
                   1809:       }else{
                   1810:         szPg = SQLITE_PAGE_SIZE+4;
                   1811:       }
                   1812:       store32bits(pPg->pgno, pPg, -4);
                   1813:       CODEC(pPager, pData, pPg->pgno, 7);
                   1814:       rc = sqliteOsWrite(&pPager->jfd, &((char*)pData)[-4], szPg);
                   1815:       TRACE3("JOURNAL %d %d\n", pPg->pgno, pPg->needSync);
                   1816:       CODEC(pPager, pData, pPg->pgno, 0);
                   1817:       if( journal_format>=JOURNAL_FORMAT_3 ){
                   1818:         *(u32*)PGHDR_TO_EXTRA(pPg) = saved;
                   1819:       }
                   1820:       if( rc!=SQLITE_OK ){
                   1821:         sqlitepager_rollback(pPager);
                   1822:         pPager->errMask |= PAGER_ERR_FULL;
                   1823:         return rc;
                   1824:       }
                   1825:       pPager->nRec++;
                   1826:       assert( pPager->aInJournal!=0 );
                   1827:       pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
                   1828:       pPg->needSync = !pPager->noSync;
                   1829:       pPg->inJournal = 1;
                   1830:       if( pPager->ckptInUse ){
                   1831:         pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
                   1832:         page_add_to_ckpt_list(pPg);
                   1833:       }
                   1834:     }else{
                   1835:       pPg->needSync = !pPager->journalStarted && !pPager->noSync;
                   1836:       TRACE3("APPEND %d %d\n", pPg->pgno, pPg->needSync);
                   1837:     }
                   1838:     if( pPg->needSync ){
                   1839:       pPager->needSync = 1;
                   1840:     }
                   1841:   }
                   1842: 
                   1843:   /* If the checkpoint journal is open and the page is not in it,
                   1844:   ** then write the current page to the checkpoint journal.  Note that
                   1845:   ** the checkpoint journal always uses the simplier format 2 that lacks
                   1846:   ** checksums.  The header is also omitted from the checkpoint journal.
                   1847:   */
                   1848:   if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){
                   1849:     assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
                   1850:     store32bits(pPg->pgno, pPg, -4);
                   1851:     CODEC(pPager, pData, pPg->pgno, 7);
                   1852:     rc = sqliteOsWrite(&pPager->cpfd, &((char*)pData)[-4], SQLITE_PAGE_SIZE+4);
                   1853:     TRACE2("CKPT-JOURNAL %d\n", pPg->pgno);
                   1854:     CODEC(pPager, pData, pPg->pgno, 0);
                   1855:     if( rc!=SQLITE_OK ){
                   1856:       sqlitepager_rollback(pPager);
                   1857:       pPager->errMask |= PAGER_ERR_FULL;
                   1858:       return rc;
                   1859:     }
                   1860:     pPager->ckptNRec++;
                   1861:     assert( pPager->aInCkpt!=0 );
                   1862:     pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
                   1863:     page_add_to_ckpt_list(pPg);
                   1864:   }
                   1865: 
                   1866:   /* Update the database size and return.
                   1867:   */
                   1868:   if( pPager->dbSize<(int)pPg->pgno ){
                   1869:     pPager->dbSize = pPg->pgno;
                   1870:   }
                   1871:   return rc;
                   1872: }
                   1873: 
                   1874: /*
                   1875: ** Return TRUE if the page given in the argument was previously passed
                   1876: ** to sqlitepager_write().  In other words, return TRUE if it is ok
                   1877: ** to change the content of the page.
                   1878: */
                   1879: int sqlitepager_iswriteable(void *pData){
                   1880:   PgHdr *pPg = DATA_TO_PGHDR(pData);
                   1881:   return pPg->dirty;
                   1882: }
                   1883: 
                   1884: /*
                   1885: ** Replace the content of a single page with the information in the third
                   1886: ** argument.
                   1887: */
                   1888: int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){
                   1889:   void *pPage;
                   1890:   int rc;
                   1891: 
                   1892:   rc = sqlitepager_get(pPager, pgno, &pPage);
                   1893:   if( rc==SQLITE_OK ){
                   1894:     rc = sqlitepager_write(pPage);
                   1895:     if( rc==SQLITE_OK ){
                   1896:       memcpy(pPage, pData, SQLITE_PAGE_SIZE);
                   1897:     }
                   1898:     sqlitepager_unref(pPage);
                   1899:   }
                   1900:   return rc;
                   1901: }
                   1902: 
                   1903: /*
                   1904: ** A call to this routine tells the pager that it is not necessary to
                   1905: ** write the information on page "pgno" back to the disk, even though
                   1906: ** that page might be marked as dirty.
                   1907: **
                   1908: ** The overlying software layer calls this routine when all of the data
                   1909: ** on the given page is unused.  The pager marks the page as clean so
                   1910: ** that it does not get written to disk.
                   1911: **
                   1912: ** Tests show that this optimization, together with the
                   1913: ** sqlitepager_dont_rollback() below, more than double the speed
                   1914: ** of large INSERT operations and quadruple the speed of large DELETEs.
                   1915: **
                   1916: ** When this routine is called, set the alwaysRollback flag to true.
                   1917: ** Subsequent calls to sqlitepager_dont_rollback() for the same page
                   1918: ** will thereafter be ignored.  This is necessary to avoid a problem
                   1919: ** where a page with data is added to the freelist during one part of
                   1920: ** a transaction then removed from the freelist during a later part
                   1921: ** of the same transaction and reused for some other purpose.  When it
                   1922: ** is first added to the freelist, this routine is called.  When reused,
                   1923: ** the dont_rollback() routine is called.  But because the page contains
                   1924: ** critical data, we still need to be sure it gets rolled back in spite
                   1925: ** of the dont_rollback() call.
                   1926: */
                   1927: void sqlitepager_dont_write(Pager *pPager, Pgno pgno){
                   1928:   PgHdr *pPg;
                   1929: 
                   1930:   pPg = pager_lookup(pPager, pgno);
                   1931:   pPg->alwaysRollback = 1;
                   1932:   if( pPg && pPg->dirty && !pPager->ckptInUse ){
                   1933:     if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){
                   1934:       /* If this pages is the last page in the file and the file has grown
                   1935:       ** during the current transaction, then do NOT mark the page as clean.
                   1936:       ** When the database file grows, we must make sure that the last page
                   1937:       ** gets written at least once so that the disk file will be the correct
                   1938:       ** size. If you do not write this page and the size of the file
                   1939:       ** on the disk ends up being too small, that can lead to database
                   1940:       ** corruption during the next transaction.
                   1941:       */
                   1942:     }else{
                   1943:       TRACE2("DONT_WRITE %d\n", pgno);
                   1944:       pPg->dirty = 0;
                   1945:     }
                   1946:   }
                   1947: }
                   1948: 
                   1949: /*
                   1950: ** A call to this routine tells the pager that if a rollback occurs,
                   1951: ** it is not necessary to restore the data on the given page.  This
                   1952: ** means that the pager does not have to record the given page in the
                   1953: ** rollback journal.
                   1954: */
                   1955: void sqlitepager_dont_rollback(void *pData){
                   1956:   PgHdr *pPg = DATA_TO_PGHDR(pData);
                   1957:   Pager *pPager = pPg->pPager;
                   1958: 
                   1959:   if( pPager->state!=SQLITE_WRITELOCK || pPager->journalOpen==0 ) return;
                   1960:   if( pPg->alwaysRollback || pPager->alwaysRollback ) return;
                   1961:   if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){
                   1962:     assert( pPager->aInJournal!=0 );
                   1963:     pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
                   1964:     pPg->inJournal = 1;
                   1965:     if( pPager->ckptInUse ){
                   1966:       pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
                   1967:       page_add_to_ckpt_list(pPg);
                   1968:     }
                   1969:     TRACE2("DONT_ROLLBACK %d\n", pPg->pgno);
                   1970:   }
                   1971:   if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){
                   1972:     assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
                   1973:     assert( pPager->aInCkpt!=0 );
                   1974:     pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
                   1975:     page_add_to_ckpt_list(pPg);
                   1976:   }
                   1977: }
                   1978: 
                   1979: /*
                   1980: ** Commit all changes to the database and release the write lock.
                   1981: **
                   1982: ** If the commit fails for any reason, a rollback attempt is made
                   1983: ** and an error code is returned.  If the commit worked, SQLITE_OK
                   1984: ** is returned.
                   1985: */
                   1986: int sqlitepager_commit(Pager *pPager){
                   1987:   int rc;
                   1988:   PgHdr *pPg;
                   1989: 
                   1990:   if( pPager->errMask==PAGER_ERR_FULL ){
                   1991:     rc = sqlitepager_rollback(pPager);
                   1992:     if( rc==SQLITE_OK ){
                   1993:       rc = SQLITE_FULL;
                   1994:     }
                   1995:     return rc;
                   1996:   }
                   1997:   if( pPager->errMask!=0 ){
                   1998:     rc = pager_errcode(pPager);
                   1999:     return rc;
                   2000:   }
                   2001:   if( pPager->state!=SQLITE_WRITELOCK ){
                   2002:     return SQLITE_ERROR;
                   2003:   }
                   2004:   TRACE1("COMMIT\n");
                   2005:   if( pPager->dirtyFile==0 ){
                   2006:     /* Exit early (without doing the time-consuming sqliteOsSync() calls)
                   2007:     ** if there have been no changes to the database file. */
                   2008:     assert( pPager->needSync==0 );
                   2009:     rc = pager_unwritelock(pPager);
                   2010:     pPager->dbSize = -1;
                   2011:     return rc;
                   2012:   }
                   2013:   assert( pPager->journalOpen );
                   2014:   rc = syncJournal(pPager);
                   2015:   if( rc!=SQLITE_OK ){
                   2016:     goto commit_abort;
                   2017:   }
                   2018:   pPg = pager_get_all_dirty_pages(pPager);
                   2019:   if( pPg ){
                   2020:     rc = pager_write_pagelist(pPg);
                   2021:     if( rc || (!pPager->noSync && sqliteOsSync(&pPager->fd)!=SQLITE_OK) ){
                   2022:       goto commit_abort;
                   2023:     }
                   2024:   }
                   2025:   rc = pager_unwritelock(pPager);
                   2026:   pPager->dbSize = -1;
                   2027:   return rc;
                   2028: 
                   2029:   /* Jump here if anything goes wrong during the commit process.
                   2030:   */
                   2031: commit_abort:
                   2032:   rc = sqlitepager_rollback(pPager);
                   2033:   if( rc==SQLITE_OK ){
                   2034:     rc = SQLITE_FULL;
                   2035:   }
                   2036:   return rc;
                   2037: }
                   2038: 
                   2039: /*
                   2040: ** Rollback all changes.  The database falls back to read-only mode.
                   2041: ** All in-memory cache pages revert to their original data contents.
                   2042: ** The journal is deleted.
                   2043: **
                   2044: ** This routine cannot fail unless some other process is not following
                   2045: ** the correct locking protocol (SQLITE_PROTOCOL) or unless some other
                   2046: ** process is writing trash into the journal file (SQLITE_CORRUPT) or
                   2047: ** unless a prior malloc() failed (SQLITE_NOMEM).  Appropriate error
                   2048: ** codes are returned for all these occasions.  Otherwise,
                   2049: ** SQLITE_OK is returned.
                   2050: */
                   2051: int sqlitepager_rollback(Pager *pPager){
                   2052:   int rc;
                   2053:   TRACE1("ROLLBACK\n");
                   2054:   if( !pPager->dirtyFile || !pPager->journalOpen ){
                   2055:     rc = pager_unwritelock(pPager);
                   2056:     pPager->dbSize = -1;
                   2057:     return rc;
                   2058:   }
                   2059: 
                   2060:   if( pPager->errMask!=0 && pPager->errMask!=PAGER_ERR_FULL ){
                   2061:     if( pPager->state>=SQLITE_WRITELOCK ){
                   2062:       pager_playback(pPager, 1);
                   2063:     }
                   2064:     return pager_errcode(pPager);
                   2065:   }
                   2066:   if( pPager->state!=SQLITE_WRITELOCK ){
                   2067:     return SQLITE_OK;
                   2068:   }
                   2069:   rc = pager_playback(pPager, 1);
                   2070:   if( rc!=SQLITE_OK ){
                   2071:     rc = SQLITE_CORRUPT;
                   2072:     pPager->errMask |= PAGER_ERR_CORRUPT;
                   2073:   }
                   2074:   pPager->dbSize = -1;
                   2075:   return rc;
                   2076: }
                   2077: 
                   2078: /*
                   2079: ** Return TRUE if the database file is opened read-only.  Return FALSE
                   2080: ** if the database is (in theory) writable.
                   2081: */
                   2082: int sqlitepager_isreadonly(Pager *pPager){
                   2083:   return pPager->readOnly;
                   2084: }
                   2085: 
                   2086: /*
                   2087: ** This routine is used for testing and analysis only.
                   2088: */
                   2089: int *sqlitepager_stats(Pager *pPager){
                   2090:   static int a[9];
                   2091:   a[0] = pPager->nRef;
                   2092:   a[1] = pPager->nPage;
                   2093:   a[2] = pPager->mxPage;
                   2094:   a[3] = pPager->dbSize;
                   2095:   a[4] = pPager->state;
                   2096:   a[5] = pPager->errMask;
                   2097:   a[6] = pPager->nHit;
                   2098:   a[7] = pPager->nMiss;
                   2099:   a[8] = pPager->nOvfl;
                   2100:   return a;
                   2101: }
                   2102: 
                   2103: /*
                   2104: ** Set the checkpoint.
                   2105: **
                   2106: ** This routine should be called with the transaction journal already
                   2107: ** open.  A new checkpoint journal is created that can be used to rollback
                   2108: ** changes of a single SQL command within a larger transaction.
                   2109: */
                   2110: int sqlitepager_ckpt_begin(Pager *pPager){
                   2111:   int rc;
                   2112:   char zTemp[SQLITE_TEMPNAME_SIZE];
                   2113:   if( !pPager->journalOpen ){
                   2114:     pPager->ckptAutoopen = 1;
                   2115:     return SQLITE_OK;
                   2116:   }
                   2117:   assert( pPager->journalOpen );
                   2118:   assert( !pPager->ckptInUse );
                   2119:   pPager->aInCkpt = sqliteMalloc( pPager->dbSize/8 + 1 );
                   2120:   if( pPager->aInCkpt==0 ){
                   2121:     sqliteOsReadLock(&pPager->fd);
                   2122:     return SQLITE_NOMEM;
                   2123:   }
                   2124: #ifndef NDEBUG
                   2125:   rc = sqliteOsFileSize(&pPager->jfd, &pPager->ckptJSize);
                   2126:   if( rc ) goto ckpt_begin_failed;
                   2127:   assert( pPager->ckptJSize == 
                   2128:     pPager->nRec*JOURNAL_PG_SZ(journal_format)+JOURNAL_HDR_SZ(journal_format) );
                   2129: #endif
                   2130:   pPager->ckptJSize = pPager->nRec*JOURNAL_PG_SZ(journal_format)
                   2131:                          + JOURNAL_HDR_SZ(journal_format);
                   2132:   pPager->ckptSize = pPager->dbSize;
                   2133:   if( !pPager->ckptOpen ){
                   2134:     rc = sqlitepager_opentemp(zTemp, &pPager->cpfd);
                   2135:     if( rc ) goto ckpt_begin_failed;
                   2136:     pPager->ckptOpen = 1;
                   2137:     pPager->ckptNRec = 0;
                   2138:   }
                   2139:   pPager->ckptInUse = 1;
                   2140:   return SQLITE_OK;
                   2141:  
                   2142: ckpt_begin_failed:
                   2143:   if( pPager->aInCkpt ){
                   2144:     sqliteFree(pPager->aInCkpt);
                   2145:     pPager->aInCkpt = 0;
                   2146:   }
                   2147:   return rc;
                   2148: }
                   2149: 
                   2150: /*
                   2151: ** Commit a checkpoint.
                   2152: */
                   2153: int sqlitepager_ckpt_commit(Pager *pPager){
                   2154:   if( pPager->ckptInUse ){
                   2155:     PgHdr *pPg, *pNext;
                   2156:     sqliteOsSeek(&pPager->cpfd, 0);
                   2157:     /* sqliteOsTruncate(&pPager->cpfd, 0); */
                   2158:     pPager->ckptNRec = 0;
                   2159:     pPager->ckptInUse = 0;
                   2160:     sqliteFree( pPager->aInCkpt );
                   2161:     pPager->aInCkpt = 0;
                   2162:     for(pPg=pPager->pCkpt; pPg; pPg=pNext){
                   2163:       pNext = pPg->pNextCkpt;
                   2164:       assert( pPg->inCkpt );
                   2165:       pPg->inCkpt = 0;
                   2166:       pPg->pPrevCkpt = pPg->pNextCkpt = 0;
                   2167:     }
                   2168:     pPager->pCkpt = 0;
                   2169:   }
                   2170:   pPager->ckptAutoopen = 0;
                   2171:   return SQLITE_OK;
                   2172: }
                   2173: 
                   2174: /*
                   2175: ** Rollback a checkpoint.
                   2176: */
                   2177: int sqlitepager_ckpt_rollback(Pager *pPager){
                   2178:   int rc;
                   2179:   if( pPager->ckptInUse ){
                   2180:     rc = pager_ckpt_playback(pPager);
                   2181:     sqlitepager_ckpt_commit(pPager);
                   2182:   }else{
                   2183:     rc = SQLITE_OK;
                   2184:   }
                   2185:   pPager->ckptAutoopen = 0;
                   2186:   return rc;
                   2187: }
                   2188: 
                   2189: /*
                   2190: ** Return the full pathname of the database file.
                   2191: */
                   2192: const char *sqlitepager_filename(Pager *pPager){
                   2193:   return pPager->zFilename;
                   2194: }
                   2195: 
                   2196: /*
                   2197: ** Set the codec for this pager
                   2198: */
                   2199: void sqlitepager_set_codec(
                   2200:   Pager *pPager,
                   2201:   void (*xCodec)(void*,void*,Pgno,int),
                   2202:   void *pCodecArg
                   2203: ){
                   2204:   pPager->xCodec = xCodec;
                   2205:   pPager->pCodecArg = pCodecArg;
                   2206: }
                   2207: 
                   2208: #ifdef SQLITE_TEST
                   2209: /*
                   2210: ** Print a listing of all referenced pages and their ref count.
                   2211: */
                   2212: void sqlitepager_refdump(Pager *pPager){
                   2213:   PgHdr *pPg;
                   2214:   for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
                   2215:     if( pPg->nRef<=0 ) continue;
                   2216:     printf("PAGE %3d addr=0x%08x nRef=%d\n", 
                   2217:        pPg->pgno, (int)PGHDR_TO_DATA(pPg), pPg->nRef);
                   2218:   }
                   2219: }
                   2220: #endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>