/*

 ** 2001 September 15

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** This is the implementation of the page cache subsystem or "pager".

 ** 

 ** The pager is used to access a database disk file.  It implements

 ** atomic commit and rollback through the use of a journal file that

 ** is separate from the database file.  The pager also implements file

 ** locking to prevent two processes from writing the same database

 ** file simultaneously, or one process from reading the database while

 ** another is writing.

 **

 ** @(#) $Id: pager.c,v 1.469 2008/08/02 03:50:39 drh Exp $

 */

 #ifndef SQLITE_OMIT_DISKIO

 #include "sqliteInt.h"

 #include <assert.h>

 #include <string.h>

 /*

 ** Macros for troubleshooting.  Normally turned off

 */

 #if 0

 #define sqlite3DebugPrintf printf

 #define PAGERTRACE1(X)       sqlite3DebugPrintf(X)

 #define PAGERTRACE2(X,Y)     sqlite3DebugPrintf(X,Y)

 #define PAGERTRACE3(X,Y,Z)   sqlite3DebugPrintf(X,Y,Z)

 #define PAGERTRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W)

 #define PAGERTRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V)

 #else

 #define PAGERTRACE1(X)

 #define PAGERTRACE2(X,Y)

 #define PAGERTRACE3(X,Y,Z)

 #define PAGERTRACE4(X,Y,Z,W)

 #define PAGERTRACE5(X,Y,Z,W,V)

 #endif

 /*

 ** The following two macros are used within the PAGERTRACEX() macros above

 ** to print out file-descriptors. 

 **

 ** PAGERID() takes a pointer to a Pager struct as its argument. The

 ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file

 ** struct as its argument.

 */

 #define PAGERID(p) ((int)(p->fd))

 #define FILEHANDLEID(fd) ((int)fd)

 /*

 ** The page cache as a whole is always in one of the following

 ** states:

 **

 **   PAGER_UNLOCK        The page cache is not currently reading or 

 **                       writing the database file.  There is no

 **                       data held in memory.  This is the initial

 **                       state.

 **

 **   PAGER_SHARED        The page cache is reading the database.

 **                       Writing is not permitted.  There can be

 **                       multiple readers accessing the same database

 **                       file at the same time.

 **

 **   PAGER_RESERVED      This process has reserved the database for writing

 **                       but has not yet made any changes.  Only one process

 **                       at a time can reserve the database.  The original

 **                       database file has not been modified so other

 **                       processes may still be reading the on-disk

 **                       database file.

 **

 **   PAGER_EXCLUSIVE     The page cache is writing the database.

 **                       Access is exclusive.  No other processes or

 **                       threads can be reading or writing while one

 **                       process is writing.

 **

 **   PAGER_SYNCED        The pager moves to this state from PAGER_EXCLUSIVE

 **                       after all dirty pages have been written to the

 **                       database file and the file has been synced to

 **                       disk. All that remains to do is to remove or

 **                       truncate the journal file and the transaction 

 **                       will be committed.

 **

 ** The page cache comes up in PAGER_UNLOCK.  The first time a

 ** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED.

 ** After all pages have been released using sqlite_page_unref(),

 ** the state transitions back to PAGER_UNLOCK.  The first time

 ** that sqlite3PagerWrite() is called, the state transitions to

 ** PAGER_RESERVED.  (Note that sqlite3PagerWrite() can only be

 ** called on an outstanding page which means that the pager must

 ** be in PAGER_SHARED before it transitions to PAGER_RESERVED.)

 ** PAGER_RESERVED means that there is an open rollback journal.

 ** The transition to PAGER_EXCLUSIVE occurs before any changes

 ** are made to the database file, though writes to the rollback

 ** journal occurs with just PAGER_RESERVED.  After an sqlite3PagerRollback()

 ** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED,

 ** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode.

 */

 #define PAGER_UNLOCK      0

 #define PAGER_SHARED      1   /* same as SHARED_LOCK */

 #define PAGER_RESERVED    2   /* same as RESERVED_LOCK */

 #define PAGER_EXCLUSIVE   4   /* same as EXCLUSIVE_LOCK */

 #define PAGER_SYNCED      5

 /*

 ** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time,

 ** then failed attempts to get a reserved lock will invoke the busy callback.

 ** This is off by default.  To see why, consider the following scenario:

 ** 

 ** Suppose thread A already has a shared lock and wants a reserved lock.

 ** Thread B already has a reserved lock and wants an exclusive lock.  If

 ** both threads are using their busy callbacks, it might be a long time

 ** be for one of the threads give up and allows the other to proceed.

 ** But if the thread trying to get the reserved lock gives up quickly

 ** (if it never invokes its busy callback) then the contention will be

 ** resolved quickly.

 */

 #ifndef SQLITE_BUSY_RESERVED_LOCK

 # define SQLITE_BUSY_RESERVED_LOCK 0

 #endif

 /*

 ** This macro rounds values up so that if the value is an address it

 ** is guaranteed to be an address that is aligned to an 8-byte boundary.

 */

 #define FORCE_ALIGNMENT(X)   (((X)+7)&~7)

 typedef struct PgHdr PgHdr;

 /*

 ** Each pager stores all currently unreferenced pages in a list sorted

 ** in least-recently-used (LRU) order (i.e. the first item on the list has 

 ** not been referenced in a long time, the last item has been recently

 ** used). An instance of this structure is included as part of each

 ** pager structure for this purpose (variable Pager.lru).

 **

 ** Additionally, if memory-management is enabled, all unreferenced pages 

 ** are stored in a global LRU list (global variable sqlite3LruPageList).

 **

 ** In both cases, the PagerLruList.pFirstSynced variable points to

 ** the first page in the corresponding list that does not require an

 ** fsync() operation before its memory can be reclaimed. If no such

 ** page exists, PagerLruList.pFirstSynced is set to NULL.

 */

 typedef struct PagerLruList PagerLruList;

 struct PagerLruList {

   PgHdr *pFirst;         /* First page in LRU list */

   PgHdr *pLast;          /* Last page in LRU list (the most recently used) */

   PgHdr *pFirstSynced;   /* First page in list with PgHdr.needSync==0 */

 };

 /*

 ** The following structure contains the next and previous pointers used

 ** to link a PgHdr structure into a PagerLruList linked list. 

 */

 typedef struct PagerLruLink PagerLruLink;

 struct PagerLruLink {

   PgHdr *pNext;

   PgHdr *pPrev;

 };

 /*

 ** Each in-memory image of a page begins with the following header.

 ** This header is only visible to this pager module.  The client

 ** code that calls pager sees only the data that follows the header.

 **

 ** Client code should call sqlite3PagerWrite() on a page prior to making

 ** any modifications to that page.  The first time sqlite3PagerWrite()

 ** is called, the original page contents are written into the rollback

 ** journal and PgHdr.inJournal and PgHdr.needSync are set.  Later, once

 ** the journal page has made it onto the disk surface, PgHdr.needSync

 ** is cleared.  The modified page cannot be written back into the original

 ** database file until the journal pages has been synced to disk and the

 ** PgHdr.needSync has been cleared.

 **

 ** The PgHdr.dirty flag is set when sqlite3PagerWrite() is called and

 ** is cleared again when the page content is written back to the original

 ** database file.

 **

 ** Details of important structure elements:

 **

 ** needSync

 **

 **     If this is true, this means that it is not safe to write the page

 **     content to the database because the original content needed

 **     for rollback has not by synced to the main rollback journal.

 **     The original content may have been written to the rollback journal

 **     but it has not yet been synced.  So we cannot write to the database

 **     file because power failure might cause the page in the journal file

 **     to never reach the disk.  It is as if the write to the journal file

 **     does not occur until the journal file is synced.

 **     

 **     This flag is false if the page content exactly matches what

 **     currently exists in the database file.  The needSync flag is also

 **     false if the original content has been written to the main rollback

 **     journal and synced.  If the page represents a new page that has

 **     been added onto the end of the database during the current

 **     transaction, the needSync flag is true until the original database

 **     size in the journal header has been synced to disk.

 **

 ** inJournal

 **

 **     This is true if the original page has been written into the main

 **     rollback journal.  This is always false for new pages added to

 **     the end of the database file during the current transaction.

 **     And this flag says nothing about whether or not the journal

 **     has been synced to disk.  For pages that are in the original

 **     database file, the following expression should always be true:

 **

 **       inJournal = sqlite3BitvecTest(pPager->pInJournal, pgno)

 **

 **     The pPager->pInJournal object is only valid for the original

 **     pages of the database, not new pages that are added to the end

 **     of the database, so obviously the above expression cannot be

 **     valid for new pages.  For new pages inJournal is always 0.

 **

 ** dirty

 **

 **     When true, this means that the content of the page has been

 **     modified and needs to be written back to the database file.

 **     If false, it means that either the content of the page is

 **     unchanged or else the content is unimportant and we do not

 **     care whether or not it is preserved.

 **

 ** alwaysRollback

 **

 **     This means that the sqlite3PagerDontRollback() API should be

 **     ignored for this page.  The DontRollback() API attempts to say

 **     that the content of the page on disk is unimportant (it is an

 **     unused page on the freelist) so that it is unnecessary to 

 **     rollback changes to this page because the content of the page

 **     can change without changing the meaning of the database.  This

 **     flag overrides any DontRollback() attempt.  This flag is set

 **     when a page that originally contained valid data is added to

 **     the freelist.  Later in the same transaction, this page might

 **     be pulled from the freelist and reused for something different

 **     and at that point the DontRollback() API will be called because

 **     pages taken from the freelist do not need to be protected by

 **     the rollback journal.  But this flag says that the page was

 **     not originally part of the freelist so that it still needs to

 **     be rolled back in spite of any subsequent DontRollback() calls.

 **

 ** needRead 

 **

 **     This flag means (when true) that the content of the page has

 **     not yet been loaded from disk.  The in-memory content is just

 **     garbage.  (Actually, we zero the content, but you should not

 **     make any assumptions about the content nevertheless.)  If the

 **     content is needed in the future, it should be read from the

 **     original database file.

 */

 struct PgHdr {

   Pager *pPager;                 /* The pager to which this page belongs */

   Pgno pgno;                     /* The page number for this page */

   PgHdr *pNextHash, *pPrevHash;  /* Hash collision chain for PgHdr.pgno */

   PagerLruLink free;             /* Next and previous free pages */

   PgHdr *pNextAll;               /* A list of all pages */

   u8 inJournal;                  /* TRUE if has been written to journal */

   u8 dirty;                      /* TRUE if we need to write back changes */

   u8 needSync;                   /* Sync journal before writing this page */

   u8 alwaysRollback;             /* Disable DontRollback() for this page */

   u8 needRead;                   /* Read content if PagerWrite() is called */

   short int nRef;                /* Number of users of this page */

   PgHdr *pDirty, *pPrevDirty;    /* Dirty pages */

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   PgHdr *pPrevAll;               /* A list of all pages */

   PagerLruLink gfree;            /* Global list of nRef==0 pages */

 #endif

 #ifdef SQLITE_CHECK_PAGES

   u32 pageHash;

 #endif

   void *pData;                   /* Page data */

   /* Pager.nExtra bytes of local data appended to this header */

 };

 /*

 ** For an in-memory only database, some extra information is recorded about

 ** each page so that changes can be rolled back.  (Journal files are not

 ** used for in-memory databases.)  The following information is added to

 ** the end of every EXTRA block for in-memory databases.

 **

 ** This information could have been added directly to the PgHdr structure.

 ** But then it would take up an extra 8 bytes of storage on every PgHdr

 ** even for disk-based databases.  Splitting it out saves 8 bytes.  This

 ** is only a savings of 0.8% but those percentages add up.

 */

 typedef struct PgHistory PgHistory;

 struct PgHistory {

   u8 *pOrig;     /* Original page text.  Restore to this on a full rollback */

   u8 *pStmt;     /* Text as it was at the beginning of the current statement */

   PgHdr *pNextStmt, *pPrevStmt;  /* List of pages in the statement journal */

   u8 inStmt;                     /* TRUE if in the statement subjournal */

 };

 /*

 ** A macro used for invoking the codec if there is one

 */

 #ifdef SQLITE_HAS_CODEC

 # define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); }

 # define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D))

 #else

 # define CODEC1(P,D,N,X) /* NO-OP */

 # define CODEC2(P,D,N,X) ((char*)D)

 #endif

 /*

 ** Convert a pointer to a PgHdr into a pointer to its data

 ** and back again.

 */

 #define PGHDR_TO_DATA(P)    ((P)->pData)

 #define PGHDR_TO_EXTRA(G,P) ((void*)&((G)[1]))

 #define PGHDR_TO_HIST(P,PGR)  \

             ((PgHistory*)&((char*)(&(P)[1]))[(PGR)->nExtra])

 /*

 ** A open page cache is an instance of the following structure.

 **

 ** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or

 ** or SQLITE_FULL. Once one of the first three errors occurs, it persists

 ** and is returned as the result of every major pager API call.  The

 ** SQLITE_FULL return code is slightly different. It persists only until the

 ** next successful rollback is performed on the pager cache. Also,

 ** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()

 ** APIs, they may still be used successfully.

 */

 struct Pager {

   sqlite3_vfs *pVfs;          /* OS functions to use for IO */

   u8 journalOpen;             /* True if journal file descriptors is valid */

   u8 journalStarted;          /* True if header of journal is synced */

   u8 useJournal;              /* Use a rollback journal on this file */

   u8 noReadlock;              /* Do not bother to obtain readlocks */

   u8 stmtOpen;                /* True if the statement subjournal is open */

   u8 stmtInUse;               /* True we are in a statement subtransaction */

   u8 stmtAutoopen;            /* Open stmt journal when main journal is opened*/

   u8 noSync;                  /* Do not sync the journal if true */

   u8 fullSync;                /* Do extra syncs of the journal for robustness */

   u8 sync_flags;              /* One of SYNC_NORMAL or SYNC_FULL */

   u8 state;                   /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */

   u8 tempFile;                /* zFilename is a temporary file */

   u8 readOnly;                /* True for a read-only database */

   u8 needSync;                /* True if an fsync() is needed on the journal */

   u8 dirtyCache;              /* True if cached pages have changed */

   u8 alwaysRollback;          /* Disable DontRollback() for all pages */

   u8 memDb;                   /* True to inhibit all file I/O */

   u8 setMaster;               /* True if a m-j name has been written to jrnl */

   u8 doNotSync;               /* Boolean. While true, do not spill the cache */

   u8 exclusiveMode;           /* Boolean. True if locking_mode==EXCLUSIVE */

   u8 journalMode;             /* On of the PAGER_JOURNALMODE_* values */

   u8 dbModified;              /* True if there are any changes to the Db */

   u8 changeCountDone;         /* Set after incrementing the change-counter */

   u32 vfsFlags;               /* Flags for sqlite3_vfs.xOpen() */

   int errCode;                /* One of several kinds of errors */

   int dbSize;                 /* Number of pages in the file */

   int origDbSize;             /* dbSize before the current change */

   int stmtSize;               /* Size of database (in pages) at stmt_begin() */

   int nRec;                   /* Number of pages written to the journal */

   u32 cksumInit;              /* Quasi-random value added to every checksum */

   int stmtNRec;               /* Number of records in stmt subjournal */

   int nExtra;                 /* Add this many bytes to each in-memory page */

   int pageSize;               /* Number of bytes in a page */

   int nPage;                  /* Total number of in-memory pages */

   int nRef;                   /* Number of in-memory pages with PgHdr.nRef>0 */

   int mxPage;                 /* Maximum number of pages to hold in cache */

   Pgno mxPgno;                /* Maximum allowed size of the database */

   Bitvec *pInJournal;         /* One bit for each page in the database file */

   Bitvec *pInStmt;            /* One bit for each page in the database */

   char *zFilename;            /* Name of the database file */

   char *zJournal;             /* Name of the journal file */

   char *zDirectory;           /* Directory hold database and journal files */

   sqlite3_file *fd, *jfd;     /* File descriptors for database and journal */

   sqlite3_file *stfd;         /* File descriptor for the statement subjournal*/

   BusyHandler *pBusyHandler;  /* Pointer to sqlite.busyHandler */

   PagerLruList lru;           /* LRU list of free pages */

   PgHdr *pAll;                /* List of all pages */

   PgHdr *pStmt;               /* List of pages in the statement subjournal */

   PgHdr *pDirty;              /* List of all dirty pages */

   i64 journalOff;             /* Current byte offset in the journal file */

   i64 journalHdr;             /* Byte offset to previous journal header */

   i64 stmtHdrOff;             /* First journal header written this statement */

   i64 stmtCksum;              /* cksumInit when statement was started */

   i64 stmtJSize;              /* Size of journal at stmt_begin() */

   int sectorSize;             /* Assumed sector size during rollback */

 #ifdef SQLITE_TEST

   int nHit, nMiss;            /* Cache hits and missing */

   int nRead, nWrite;          /* Database pages read/written */

 #endif

   void (*xDestructor)(DbPage*,int); /* Call this routine when freeing pages */

   void (*xReiniter)(DbPage*,int);   /* Call this routine when reloading pages */

 #ifdef SQLITE_HAS_CODEC

   void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */

   void *pCodecArg;            /* First argument to xCodec() */

 #endif

   int nHash;                  /* Size of the pager hash table */

   PgHdr **aHash;              /* Hash table to map page number to PgHdr */

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   Pager *pNext;               /* Doubly linked list of pagers on which */

   Pager *pPrev;               /* sqlite3_release_memory() will work */

   volatile int iInUseMM;      /* Non-zero if unavailable to MM */

   volatile int iInUseDB;      /* Non-zero if in sqlite3_release_memory() */

 #endif

   char *pTmpSpace;            /* Pager.pageSize bytes of space for tmp use */

   char dbFileVers[16];        /* Changes whenever database file changes */

   i64 journalSizeLimit;       /* Size limit for persistent journal files */

 };

 /*

 ** The following global variables hold counters used for

 ** testing purposes only.  These variables do not exist in

 ** a non-testing build.  These variables are not thread-safe.

 */

 #ifdef SQLITE_TEST

 int sqlite3_pager_readdb_count = 0;    /* Number of full pages read from DB */

 int sqlite3_pager_writedb_count = 0;   /* Number of full pages written to DB */

 int sqlite3_pager_writej_count = 0;    /* Number of pages written to journal */

 int sqlite3_pager_pgfree_count = 0;    /* Number of cache pages freed */

 # define PAGER_INCR(v)  v++

 #else

 # define PAGER_INCR(v)

 #endif

 /*

 ** The following variable points to the head of a double-linked list

 ** of all pagers that are eligible for page stealing by the

 ** sqlite3_release_memory() interface.  Access to this list is

 ** protected by the SQLITE_MUTEX_STATIC_MEM2 mutex.

 */

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

 static Pager *sqlite3PagerList = 0;

 static PagerLruList sqlite3LruPageList = {0, 0, 0};

 #endif

 /*

 ** Journal files begin with the following magic string.  The data

 ** was obtained from /dev/random.  It is used only as a sanity check.

 **

 ** Since version 2.8.0, the journal format contains additional sanity

 ** checking information.  If the power fails while the journal is begin

 ** written, semi-random garbage data might appear in the journal

 ** file after power is restored.  If an attempt is then made

 ** to roll the journal back, the database could be corrupted.  The additional

 ** sanity checking data is an attempt to discover the garbage in the

 ** journal and ignore it.

 **

 ** The sanity checking information for the new journal format consists

 ** of a 32-bit checksum on each page of data.  The checksum covers both

 ** the page number and the pPager->pageSize bytes of data for the page.

 ** This cksum is initialized to a 32-bit random value that appears in the

 ** journal file right after the header.  The random initializer is important,

 ** because garbage data that appears at the end of a journal is likely

 ** data that was once in other files that have now been deleted.  If the

 ** garbage data came from an obsolete journal file, the checksums might

 ** be correct.  But by initializing the checksum to random value which

 ** is different for every journal, we minimize that risk.

 */

 static const unsigned char aJournalMagic[] = {

   0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,

 };

 /*

 ** The size of the header and of each page in the journal is determined

 ** by the following macros.

 */

 #define JOURNAL_PG_SZ(pPager)  ((pPager->pageSize) + 8)

 /*

 ** The journal header size for this pager. In the future, this could be

 ** set to some value read from the disk controller. The important

 ** characteristic is that it is the same size as a disk sector.

 */

 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)

 /*

 ** The macro MEMDB is true if we are dealing with an in-memory database.

 ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,

 ** the value of MEMDB will be a constant and the compiler will optimize

 ** out code that would never execute.

 */

 #ifdef SQLITE_OMIT_MEMORYDB

 # define MEMDB 0

 #else

 # define MEMDB pPager->memDb

 #endif

 /*

 ** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is

 ** reserved for working around a windows/posix incompatibility). It is

 ** used in the journal to signify that the remainder of the journal file 

 ** is devoted to storing a master journal name - there are no more pages to

 ** roll back. See comments for function writeMasterJournal() for details.

 */

 /* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */

 #define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1)

 /*

 ** The maximum legal page number is (2^31 - 1).

 */

 #define PAGER_MAX_PGNO 2147483647

 /*

 ** The pagerEnter() and pagerLeave() routines acquire and release

 ** a mutex on each pager.  The mutex is recursive.

 **

 ** This is a special-purpose mutex.  It only provides mutual exclusion

 ** between the Btree and the Memory Management sqlite3_release_memory()

 ** function.  It does not prevent, for example, two Btrees from accessing

 ** the same pager at the same time.  Other general-purpose mutexes in

 ** the btree layer handle that chore.

 */

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   static void pagerEnter(Pager *p){

     p->iInUseDB++;

     if( p->iInUseMM && p->iInUseDB==1 ){

 #ifndef SQLITE_MUTEX_NOOP

       sqlite3_mutex *mutex;

       mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM2);

 #endif

       p->iInUseDB = 0;

       sqlite3_mutex_enter(mutex);

       p->iInUseDB = 1;

       sqlite3_mutex_leave(mutex);

     }

     assert( p->iInUseMM==0 );

   }

   static void pagerLeave(Pager *p){

     p->iInUseDB--;

     assert( p->iInUseDB>=0 );

   }

 #else

 # define pagerEnter(X)

 # define pagerLeave(X)

 #endif

 /*

 ** Add page pPg to the end of the linked list managed by structure

 ** pList (pPg becomes the last entry in the list - the most recently 

 ** used). Argument pLink should point to either pPg->free or pPg->gfree,

 ** depending on whether pPg is being added to the pager-specific or

 ** global LRU list.

 */

 static void listAdd(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){

   pLink->pNext = 0;

   pLink->pPrev = pList->pLast;

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   assert(pLink==&pPg->free || pLink==&pPg->gfree);

   assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);

 #endif

   if( pList->pLast ){

     int iOff = (char *)pLink - (char *)pPg;

     PagerLruLink *pLastLink = (PagerLruLink *)(&((u8 *)pList->pLast)[iOff]);

     pLastLink->pNext = pPg;

   }else{

     assert(!pList->pFirst);

     pList->pFirst = pPg;

   }

   pList->pLast = pPg;

   if( !pList->pFirstSynced && pPg->needSync==0 ){

     pList->pFirstSynced = pPg;

   }

 }

 /*

 ** Remove pPg from the list managed by the structure pointed to by pList.

 **

 ** Argument pLink should point to either pPg->free or pPg->gfree, depending 

 ** on whether pPg is being added to the pager-specific or global LRU list.

 */

 static void listRemove(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){

   int iOff = (char *)pLink - (char *)pPg;

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   assert(pLink==&pPg->free || pLink==&pPg->gfree);

   assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);

 #endif

   if( pPg==pList->pFirst ){

     pList->pFirst = pLink->pNext;

   }

   if( pPg==pList->pLast ){

     pList->pLast = pLink->pPrev;

   }

   if( pLink->pPrev ){

     PagerLruLink *pPrevLink = (PagerLruLink *)(&((u8 *)pLink->pPrev)[iOff]);

     pPrevLink->pNext = pLink->pNext;

   }

   if( pLink->pNext ){

     PagerLruLink *pNextLink = (PagerLruLink *)(&((u8 *)pLink->pNext)[iOff]);

     pNextLink->pPrev = pLink->pPrev;

   }

   if( pPg==pList->pFirstSynced ){

     PgHdr *p = pLink->pNext;

     while( p && p->needSync ){

       PagerLruLink *pL = (PagerLruLink *)(&((u8 *)p)[iOff]);

       p = pL->pNext;

     }

     pList->pFirstSynced = p;

   }

   pLink->pNext = pLink->pPrev = 0;

 }

 /* 

 ** Add page pPg to the list of free pages for the pager. If 

 ** memory-management is enabled, also add the page to the global 

 ** list of free pages.

 */

 static void lruListAdd(PgHdr *pPg){

   listAdd(&pPg->pPager->lru, &pPg->free, pPg);

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   if( !pPg->pPager->memDb ){

     sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU));

     listAdd(&sqlite3LruPageList, &pPg->gfree, pPg);

     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU));

   }

 #endif

 }

 /* 

 ** Remove page pPg from the list of free pages for the associated pager.

 ** If memory-management is enabled, also remove pPg from the global list

 ** of free pages.

 */

 static void lruListRemove(PgHdr *pPg){

   listRemove(&pPg->pPager->lru, &pPg->free, pPg);

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   if( !pPg->pPager->memDb ){

     sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU));

     listRemove(&sqlite3LruPageList, &pPg->gfree, pPg);

     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU));

   }

 #endif

 }

 /* 

 ** This function is called just after the needSync flag has been cleared

 ** from all pages managed by pPager (usually because the journal file

 ** has just been synced). It updates the pPager->lru.pFirstSynced variable

 ** and, if memory-management is enabled, the sqlite3LruPageList.pFirstSynced

 ** variable also.

 */

 static void lruListSetFirstSynced(Pager *pPager){

   pPager->lru.pFirstSynced = pPager->lru.pFirst;

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   if( !pPager->memDb ){

     PgHdr *p;

     sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU));

     for(p=sqlite3LruPageList.pFirst; p && p->needSync; p=p->gfree.pNext);

     assert(p==pPager->lru.pFirstSynced || p==sqlite3LruPageList.pFirstSynced);

     sqlite3LruPageList.pFirstSynced = p;

     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU));

   }

 #endif

 }

 /*

 ** Return true if page *pPg has already been written to the statement

 ** journal (or statement snapshot has been created, if *pPg is part

 ** of an in-memory database).

 */

 static int pageInStatement(PgHdr *pPg){

   Pager *pPager = pPg->pPager;

   if( MEMDB ){

     return PGHDR_TO_HIST(pPg, pPager)->inStmt;

   }else{

     return sqlite3BitvecTest(pPager->pInStmt, pPg->pgno);

   }

 }

 /*

 ** Change the size of the pager hash table to N.  N must be a power

 ** of two.

 */

 static void pager_resize_hash_table(Pager *pPager, int N){

   PgHdr **aHash, *pPg;

   assert( N>0 && (N&(N-1))==0 );

 #ifdef SQLITE_MALLOC_SOFT_LIMIT

   if( N*sizeof(aHash[0])>SQLITE_MALLOC_SOFT_LIMIT ){

     N = SQLITE_MALLOC_SOFT_LIMIT/sizeof(aHash[0]);

   }

   if( N==pPager->nHash ) return;

 #endif

   pagerLeave(pPager);

   if( pPager->aHash!=0 ) sqlite3BeginBenignMalloc();

   aHash = sqlite3MallocZero( sizeof(aHash[0])*N );

   if( pPager->aHash!=0 ) sqlite3EndBenignMalloc();

   pagerEnter(pPager);

   if( aHash==0 ){

     /* Failure to rehash is not an error.  It is only a performance hit. */

     return;

   }

   sqlite3_free(pPager->aHash);

   pPager->nHash = N;

   pPager->aHash = aHash;

   for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){

     int h;

     if( pPg->pgno==0 ){

       assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );

       continue;

     }

     h = pPg->pgno & (N-1);

     pPg->pNextHash = aHash[h];

     if( aHash[h] ){

       aHash[h]->pPrevHash = pPg;

     }

     aHash[h] = pPg;

     pPg->pPrevHash = 0;

   }

 }

 /*

 ** Read a 32-bit integer from the given file descriptor.  Store the integer

 ** that is read in *pRes.  Return SQLITE_OK if everything worked, or an

 ** error code is something goes wrong.

 **

 ** All values are stored on disk as big-endian.

 */

 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){

   unsigned char ac[4];

   int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);

   if( rc==SQLITE_OK ){

     *pRes = sqlite3Get4byte(ac);

   }

   return rc;

 }

 /*

 ** Write a 32-bit integer into a string buffer in big-endian byte order.

 */

 #define put32bits(A,B)  sqlite3Put4byte((u8*)A,B)

 /*

 ** Write a 32-bit integer into the given file descriptor.  Return SQLITE_OK

 ** on success or an error code is something goes wrong.

 */

 static int write32bits(sqlite3_file *fd, i64 offset, u32 val){

   char ac[4];

   put32bits(ac, val);

   return sqlite3OsWrite(fd, ac, 4, offset);

 }

 /*

 ** If file pFd is open, call sqlite3OsUnlock() on it.

 */

 static int osUnlock(sqlite3_file *pFd, int eLock){

   if( !pFd->pMethods ){

     return SQLITE_OK;

   }

   return sqlite3OsUnlock(pFd, eLock);

 }

 /*

 ** This function determines whether or not the atomic-write optimization

 ** can be used with this pager. The optimization can be used if:

 **

 **  (a) the value returned by OsDeviceCharacteristics() indicates that

 **      a database page may be written atomically, and

 **  (b) the value returned by OsSectorSize() is less than or equal

 **      to the page size.

 **

 ** If the optimization cannot be used, 0 is returned. If it can be used,

 ** then the value returned is the size of the journal file when it

 ** contains rollback data for exactly one page.

 */

 #ifdef SQLITE_ENABLE_ATOMIC_WRITE

 static int jrnlBufferSize(Pager *pPager){

   int dc;           /* Device characteristics */

   int nSector;      /* Sector size */

   int szPage;        /* Page size */

   sqlite3_file *fd = pPager->fd;

   if( fd->pMethods ){

     dc = sqlite3OsDeviceCharacteristics(fd);

     nSector = sqlite3OsSectorSize(fd);

     szPage = pPager->pageSize;

   }

   assert(SQLITE_IOCAP_ATOMIC512==(512>>8));

   assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));

   if( !fd->pMethods || 

        (dc & (SQLITE_IOCAP_ATOMIC|(szPage>>8)) && nSector<=szPage) ){

     return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);

   }

   return 0;

 }

 #endif

 /*

 ** This function should be called when an error occurs within the pager

 ** code. The first argument is a pointer to the pager structure, the

 ** second the error-code about to be returned by a pager API function. 

 ** The value returned is a copy of the second argument to this function. 

 **

 ** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL

 ** the error becomes persistent. Until the persisten error is cleared,

 ** subsequent API calls on this Pager will immediately return the same 

 ** error code.

 **

 ** A persistent error indicates that the contents of the pager-cache 

 ** cannot be trusted. This state can be cleared by completely discarding 

 ** the contents of the pager-cache. If a transaction was active when

 ** the persistent error occured, then the rollback journal may need

 ** to be replayed.

 */

 static void pager_unlock(Pager *pPager);

 static int pager_error(Pager *pPager, int rc){

   int rc2 = rc & 0xff;

   assert(

        pPager->errCode==SQLITE_FULL ||

        pPager->errCode==SQLITE_OK ||

        (pPager->errCode & 0xff)==SQLITE_IOERR

   );

   if(

     rc2==SQLITE_FULL ||

     rc2==SQLITE_IOERR ||

     rc2==SQLITE_CORRUPT

   ){

     pPager->errCode = rc;

     if( pPager->state==PAGER_UNLOCK && pPager->nRef==0 ){

       /* If the pager is already unlocked, call pager_unlock() now to

       ** clear the error state and ensure that the pager-cache is 

       ** completely empty.

       */

       pager_unlock(pPager);

     }

   }

   return rc;

 }

 /*

 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking

 ** on the cache using a hash function.  This is used for testing

 ** and debugging only.

 */

 #ifdef SQLITE_CHECK_PAGES

 /*

 ** Return a 32-bit hash of the page data for pPage.

 */

 static u32 pager_datahash(int nByte, unsigned char *pData){

   u32 hash = 0;

   int i;

   for(i=0; i<nByte; i++){

     hash = (hash*1039) + pData[i];

   }

   return hash;

 }

 static u32 pager_pagehash(PgHdr *pPage){

   return pager_datahash(pPage->pPager->pageSize, 

                         (unsigned char *)PGHDR_TO_DATA(pPage));

 }

 /*

 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES

 ** is defined, and NDEBUG is not defined, an assert() statement checks

 ** that the page is either dirty or still matches the calculated page-hash.

 */

 #define CHECK_PAGE(x) checkPage(x)

 static void checkPage(PgHdr *pPg){

   Pager *pPager = pPg->pPager;

   assert( !pPg->pageHash || pPager->errCode || MEMDB || pPg->dirty || 

       pPg->pageHash==pager_pagehash(pPg) );

 }

 #else

 #define pager_datahash(X,Y)  0

 #define pager_pagehash(X)  0

 #define CHECK_PAGE(x)

 #endif

 /*

 ** When this is called the journal file for pager pPager must be open.

 ** The master journal file name is read from the end of the file and 

 ** written into memory supplied by the caller. 

 **

 ** zMaster must point to a buffer of at least nMaster bytes allocated by

 ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is

 ** enough space to write the master journal name). If the master journal

 ** name in the journal is longer than nMaster bytes (including a

 ** nul-terminator), then this is handled as if no master journal name

 ** were present in the journal.

 **

 ** If no master journal file name is present zMaster[0] is set to 0 and

 ** SQLITE_OK returned.

 */

 static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, int nMaster){

   int rc;

   u32 len;

   i64 szJ;

   u32 cksum;

   u32 u;                   /* Unsigned loop counter */

   unsigned char aMagic[8]; /* A buffer to hold the magic header */

   zMaster[0] = '\0';

   rc = sqlite3OsFileSize(pJrnl, &szJ);

   if( rc!=SQLITE_OK || szJ<16 ) return rc;

   rc = read32bits(pJrnl, szJ-16, &len);

   if( rc!=SQLITE_OK ) return rc;

   if( len>=nMaster ){

     return SQLITE_OK;

   }

   rc = read32bits(pJrnl, szJ-12, &cksum);

   if( rc!=SQLITE_OK ) return rc;

   rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8);

   if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc;

   rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len);

   if( rc!=SQLITE_OK ){

     return rc;

   }

   zMaster[len] = '\0';

   /* See if the checksum matches the master journal name */

   for(u=0; u<len; u++){

     cksum -= zMaster[u];

    }

   if( cksum ){

     /* If the checksum doesn't add up, then one or more of the disk sectors

     ** containing the master journal filename is corrupted. This means

     ** definitely roll back, so just return SQLITE_OK and report a (nul)

     ** master-journal filename.

     */

     zMaster[0] = '\0';

   }

   return SQLITE_OK;

 }

 /*

 ** Seek the journal file descriptor to the next sector boundary where a

 ** journal header may be read or written. Pager.journalOff is updated with

 ** the new seek offset.

 **

 ** i.e for a sector size of 512:

 **

 ** Input Offset              Output Offset

 ** ---------------------------------------

 ** 0                         0

 ** 512                       512

 ** 100                       512

 ** 2000                      2048

 ** 

 */

 static void seekJournalHdr(Pager *pPager){

   i64 offset = 0;

   i64 c = pPager->journalOff;

   if( c ){

     offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);

   }

   assert( offset%JOURNAL_HDR_SZ(pPager)==0 );

   assert( offset>=c );

   assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );

   pPager->journalOff = offset;

 }

 /*

 ** Write zeros over the header of the journal file.  This has the

 ** effect of invalidating the journal file and committing the

 ** transaction.

 */

 static int zeroJournalHdr(Pager *pPager, int doTruncate){

   int rc = SQLITE_OK;

   static const char zeroHdr[28];

   if( pPager->journalOff ){

     i64 iLimit = pPager->journalSizeLimit;

     IOTRACE(("JZEROHDR %p\n", pPager))

     if( doTruncate || iLimit==0 ){

       rc = sqlite3OsTruncate(pPager->jfd, 0);

     }else{

       rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);

     }

     if( rc==SQLITE_OK && !pPager->noSync ){

       rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->sync_flags);

     }

     /* At this point the transaction is committed but the write lock 

     ** is still held on the file. If there is a size limit configured for 

     ** the persistent journal and the journal file currently consumes more

     ** space than that limit allows for, truncate it now. There is no need

     ** to sync the file following this operation.

     */

     if( rc==SQLITE_OK && iLimit>0 ){

       i64 sz;

       rc = sqlite3OsFileSize(pPager->jfd, &sz);

       if( rc==SQLITE_OK && sz>iLimit ){

         rc = sqlite3OsTruncate(pPager->jfd, iLimit);

       }

     }

   }

   return rc;

 }

 /*

 ** The journal file must be open when this routine is called. A journal

 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the

 ** current location.

 **

 ** The format for the journal header is as follows:

 ** - 8 bytes: Magic identifying journal format.

 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.

 ** - 4 bytes: Random number used for page hash.

 ** - 4 bytes: Initial database page count.

 ** - 4 bytes: Sector size used by the process that wrote this journal.

 ** - 4 bytes: Database page size.

 ** 

 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.

 */

 static int writeJournalHdr(Pager *pPager){

   int rc = SQLITE_OK;

   char *zHeader = pPager->pTmpSpace;

   int nHeader = pPager->pageSize;

   int nWrite;

   if( nHeader>JOURNAL_HDR_SZ(pPager) ){

     nHeader = JOURNAL_HDR_SZ(pPager);

   }

   if( pPager->stmtHdrOff==0 ){

     pPager->stmtHdrOff = pPager->journalOff;

   }

   seekJournalHdr(pPager);

   pPager->journalHdr = pPager->journalOff;

   memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));

   /* 

   ** Write the nRec Field - the number of page records that follow this

   ** journal header. Normally, zero is written to this value at this time.

   ** After the records are added to the journal (and the journal synced, 

   ** if in full-sync mode), the zero is overwritten with the true number

   ** of records (see syncJournal()).

   **

   ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When

   ** reading the journal this value tells SQLite to assume that the

   ** rest of the journal file contains valid page records. This assumption

   ** is dangerous, as if a failure occured whilst writing to the journal

   ** file it may contain some garbage data. There are two scenarios

   ** where this risk can be ignored:

   **

   **   * When the pager is in no-sync mode. Corruption can follow a

   **     power failure in this case anyway.

   **

   **   * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees

   **     that garbage data is never appended to the journal file.

   */

   assert(pPager->fd->pMethods||pPager->noSync);

   if( (pPager->noSync) 

    || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) 

   ){

     put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);

   }else{

     put32bits(&zHeader[sizeof(aJournalMagic)], 0);

   }

   /* The random check-hash initialiser */ 

   sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);

   put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);

   /* The initial database size */

   put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize);

   /* The assumed sector size for this process */

   put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);

   if( pPager->journalHdr==0 ){

     /* The page size */

     put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);

   }

   for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){

     IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))

     rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);

     pPager->journalOff += nHeader;

   }

   return rc;

 }

 /*

 ** The journal file must be open when this is called. A journal header file

 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal

 ** file. See comments above function writeJournalHdr() for a description of

 ** the journal header format.

 **

 ** If the header is read successfully, *nRec is set to the number of

 ** page records following this header and *dbSize is set to the size of the

 ** database before the transaction began, in pages. Also, pPager->cksumInit

 ** is set to the value read from the journal header. SQLITE_OK is returned

 ** in this case.

 **

 ** If the journal header file appears to be corrupted, SQLITE_DONE is

 ** returned and *nRec and *dbSize are not set.  If JOURNAL_HDR_SZ bytes

 ** cannot be read from the journal file an error code is returned.

 */

 static int readJournalHdr(

   Pager *pPager, 

   i64 journalSize,

   u32 *pNRec, 

   u32 *pDbSize

 ){

   int rc;

   unsigned char aMagic[8]; /* A buffer to hold the magic header */

   i64 jrnlOff;

   int iPageSize;

   seekJournalHdr(pPager);

   if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){

     return SQLITE_DONE;

   }

   jrnlOff = pPager->journalOff;

   rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), jrnlOff);

   if( rc ) return rc;

   jrnlOff += sizeof(aMagic);

   if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){

     return SQLITE_DONE;

   }

   rc = read32bits(pPager->jfd, jrnlOff, pNRec);

   if( rc ) return rc;

   rc = read32bits(pPager->jfd, jrnlOff+4, &pPager->cksumInit);

   if( rc ) return rc;

   rc = read32bits(pPager->jfd, jrnlOff+8, pDbSize);

   if( rc ) return rc;

   rc = read32bits(pPager->jfd, jrnlOff+16, (u32 *)&iPageSize);

   if( rc==SQLITE_OK 

    && iPageSize>=512 

    && iPageSize<=SQLITE_MAX_PAGE_SIZE 

    && ((iPageSize-1)&iPageSize)==0 

   ){

     u16 pagesize = iPageSize;

     rc = sqlite3PagerSetPagesize(pPager, &pagesize);

   }

   if( rc ) return rc;

   /* Update the assumed sector-size to match the value used by 

   ** the process that created this journal. If this journal was

   ** created by a process other than this one, then this routine

   ** is being called from within pager_playback(). The local value

   ** of Pager.sectorSize is restored at the end of that routine.

   */

   rc = read32bits(pPager->jfd, jrnlOff+12, (u32 *)&pPager->sectorSize);

   if( rc ) return rc;

   pPager->journalOff += JOURNAL_HDR_SZ(pPager);

   return SQLITE_OK;

 }

 /*

 ** Write the supplied master journal name into the journal file for pager

 ** pPager at the current location. The master journal name must be the last

 ** thing written to a journal file. If the pager is in full-sync mode, the

 ** journal file descriptor is advanced to the next sector boundary before

 ** anything is written. The format is:

 **

 ** + 4 bytes: PAGER_MJ_PGNO.

 ** + N bytes: length of master journal name.

 ** + 4 bytes: N

 ** + 4 bytes: Master journal name checksum.

 ** + 8 bytes: aJournalMagic[].

 **

 ** The master journal page checksum is the sum of the bytes in the master

 ** journal name.

 **

 ** If zMaster is a NULL pointer (occurs for a single database transaction), 

 ** this call is a no-op.

 */

 static int writeMasterJournal(Pager *pPager, const char *zMaster){

   int rc;

   int len; 

   int i; 

   i64 jrnlOff;

   i64 jrnlSize;

   u32 cksum = 0;

   char zBuf[sizeof(aJournalMagic)+2*4];

   if( !zMaster || pPager->setMaster) return SQLITE_OK;

   pPager->setMaster = 1;

   len = strlen(zMaster);

   for(i=0; i<len; i++){

     cksum += zMaster[i];

   }

   /* If in full-sync mode, advance to the next disk sector before writing

   ** the master journal name. This is in case the previous page written to

   ** the journal has already been synced.

   */

   if( pPager->fullSync ){

     seekJournalHdr(pPager);

   }

   jrnlOff = pPager->journalOff;

   pPager->journalOff += (len+20);

   rc = write32bits(pPager->jfd, jrnlOff, PAGER_MJ_PGNO(pPager));

   if( rc!=SQLITE_OK ) return rc;

   jrnlOff += 4;

   rc = sqlite3OsWrite(pPager->jfd, zMaster, len, jrnlOff);

   if( rc!=SQLITE_OK ) return rc;

   jrnlOff += len;

   put32bits(zBuf, len);

   put32bits(&zBuf[4], cksum);

   memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic));

   rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic), jrnlOff);

   jrnlOff += 8+sizeof(aJournalMagic);

   pPager->needSync = !pPager->noSync;

   /* If the pager is in peristent-journal mode, then the physical 

   ** journal-file may extend past the end of the master-journal name

   ** and 8 bytes of magic data just written to the file. This is 

   ** dangerous because the code to rollback a hot-journal file

   ** will not be able to find the master-journal name to determine 

   ** whether or not the journal is hot. 

   **

   ** Easiest thing to do in this scenario is to truncate the journal 

   ** file to the required size.

   */ 

   if( (rc==SQLITE_OK)

    && (rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))==SQLITE_OK

    && jrnlSize>jrnlOff

   ){

     rc = sqlite3OsTruncate(pPager->jfd, jrnlOff);

   }

   return rc;

 }

 /*

 ** Add or remove a page from the list of all pages that are in the

 ** statement journal.

 **

 ** The Pager keeps a separate list of pages that are currently in

 ** the statement journal.  This helps the sqlite3PagerStmtCommit()

 ** routine run MUCH faster for the common case where there are many

 ** pages in memory but only a few are in the statement journal.

 */

 static void page_add_to_stmt_list(PgHdr *pPg){

   Pager *pPager = pPg->pPager;

   PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);

   assert( MEMDB );

   if( !pHist->inStmt ){

     assert( pHist->pPrevStmt==0 && pHist->pNextStmt==0 );

     if( pPager->pStmt ){

       PGHDR_TO_HIST(pPager->pStmt, pPager)->pPrevStmt = pPg;

     }

     pHist->pNextStmt = pPager->pStmt;

     pPager->pStmt = pPg;

     pHist->inStmt = 1;

   }

 }

 /*

 ** Find a page in the hash table given its page number.  Return

 ** a pointer to the page or NULL if not found.

 */

 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){

   PgHdr *p;

   if( pPager->aHash==0 ) return 0;

   p = pPager->aHash[pgno & (pPager->nHash-1)];

   while( p && p->pgno!=pgno ){

     p = p->pNextHash;

   }

   return p;

 }

 /*

 ** Clear the in-memory cache.  This routine

 ** sets the state of the pager back to what it was when it was first

 ** opened.  Any outstanding pages are invalidated and subsequent attempts

 ** to access those pages will likely result in a coredump.

 */

 static void pager_reset(Pager *pPager){

   PgHdr *pPg, *pNext;

   if( pPager->errCode ) return;

   for(pPg=pPager->pAll; pPg; pPg=pNext){

     IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno));

     PAGER_INCR(sqlite3_pager_pgfree_count);

     pNext = pPg->pNextAll;

     lruListRemove(pPg);

     sqlite3PageFree(pPg->pData);

     sqlite3_free(pPg);

   }

   assert(pPager->lru.pFirst==0);

   assert(pPager->lru.pFirstSynced==0);

   assert(pPager->lru.pLast==0);

   pPager->pStmt = 0;

   pPager->pAll = 0;

   pPager->pDirty = 0;

   pPager->nHash = 0;

   sqlite3_free(pPager->aHash);

   pPager->nPage = 0;

   pPager->aHash = 0;

   pPager->nRef = 0;

 }

 /*

 ** Unlock the database file. 

 **

 ** If the pager is currently in error state, discard the contents of 

 ** the cache and reset the Pager structure internal state. If there is

 ** an open journal-file, then the next time a shared-lock is obtained

 ** on the pager file (by this or any other process), it will be

 ** treated as a hot-journal and rolled back.

 */

 static void pager_unlock(Pager *pPager){

   if( !pPager->exclusiveMode ){

     if( !MEMDB ){

       int rc = osUnlock(pPager->fd, NO_LOCK);

       if( rc ) pPager->errCode = rc;

       pPager->dbSize = -1;

       IOTRACE(("UNLOCK %p\n", pPager))

       /* Always close the journal file when dropping the database lock.

       ** Otherwise, another connection with journal_mode=delete might

       ** delete the file out from under us.

       */

       if( pPager->journalOpen ){

         sqlite3OsClose(pPager->jfd);

         pPager->journalOpen = 0;

         sqlite3BitvecDestroy(pPager->pInJournal);

         pPager->pInJournal = 0;

       }

       /* If Pager.errCode is set, the contents of the pager cache cannot be

       ** trusted. Now that the pager file is unlocked, the contents of the

       ** cache can be discarded and the error code safely cleared.

       */

       if( pPager->errCode ){

         if( rc==SQLITE_OK ) pPager->errCode = SQLITE_OK;

         pager_reset(pPager);

         if( pPager->stmtOpen ){

           sqlite3OsClose(pPager->stfd);

           sqlite3BitvecDestroy(pPager->pInStmt);

           pPager->pInStmt = 0;

         }

         pPager->stmtOpen = 0;

         pPager->stmtInUse = 0;

         pPager->journalOff = 0;

         pPager->journalStarted = 0;

         pPager->stmtAutoopen = 0;

         pPager->origDbSize = 0;

       }

     }

     if( !MEMDB || pPager->errCode==SQLITE_OK ){

       pPager->state = PAGER_UNLOCK;

       pPager->changeCountDone = 0;

     }

   }

 }

 /*

 ** Execute a rollback if a transaction is active and unlock the 

 ** database file. If the pager has already entered the error state, 

 ** do not attempt the rollback.

 */

 static void pagerUnlockAndRollback(Pager *p){

   /* assert( p->state>=PAGER_RESERVED || p->journalOpen==0 ); */

   if( p->errCode==SQLITE_OK && p->state>=PAGER_RESERVED ){

     sqlite3BeginBenignMalloc();

     sqlite3PagerRollback(p);

     sqlite3EndBenignMalloc();

   }

   pager_unlock(p);

 #if 0

   assert( p->errCode || !p->journalOpen || (p->exclusiveMode&&!p->journalOff) );

   assert( p->errCode || !p->stmtOpen || p->exclusiveMode );

 #endif

 }

 /*

 ** This routine ends a transaction.  A transaction is ended by either

 ** a COMMIT or a ROLLBACK.

 **

 ** When this routine is called, the pager has the journal file open and

 ** a RESERVED or EXCLUSIVE lock on the database.  This routine will release

 ** the database lock and acquires a SHARED lock in its place if that is

 ** the appropriate thing to do.  Release locks usually is appropriate,

 ** unless we are in exclusive access mode or unless this is a 

 ** COMMIT AND BEGIN or ROLLBACK AND BEGIN operation.

 **

 ** The journal file is either deleted or truncated.

 **

 ** TODO: Consider keeping the journal file open for temporary databases.

 ** This might give a performance improvement on windows where opening

 ** a file is an expensive operation.

 */

 static int pager_end_transaction(Pager *pPager, int hasMaster){

   PgHdr *pPg;

   int rc = SQLITE_OK;

   int rc2 = SQLITE_OK;

   assert( !MEMDB );

   if( pPager->state<PAGER_RESERVED ){

     return SQLITE_OK;

   }

   sqlite3PagerStmtCommit(pPager);

   if( pPager->stmtOpen && !pPager->exclusiveMode ){

     sqlite3OsClose(pPager->stfd);

     pPager->stmtOpen = 0;

   }

   if( pPager->journalOpen ){

     if( pPager->exclusiveMode 

      || pPager->journalMode==PAGER_JOURNALMODE_PERSIST

     ){

       rc = zeroJournalHdr(pPager, hasMaster);

       pager_error(pPager, rc);

       pPager->journalOff = 0;

       pPager->journalStarted = 0;

     }else{

       sqlite3OsClose(pPager->jfd);

       pPager->journalOpen = 0;

       if( rc==SQLITE_OK && !pPager->tempFile ){

         rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);

       }

     }

     sqlite3BitvecDestroy(pPager->pInJournal);

     pPager->pInJournal = 0;

     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){

       pPg->inJournal = 0;

       pPg->dirty = 0;

       pPg->needSync = 0;

       pPg->alwaysRollback = 0;

 #ifdef SQLITE_CHECK_PAGES

       pPg->pageHash = pager_pagehash(pPg);

 #endif

     }

     pPager->pDirty = 0;

     pPager->dirtyCache = 0;

     pPager->nRec = 0;

   }else{

     assert( pPager->pInJournal==0 );

   }

   if( !pPager->exclusiveMode ){

     rc2 = osUnlock(pPager->fd, SHARED_LOCK);

     pPager->state = PAGER_SHARED;

   }else if( pPager->state==PAGER_SYNCED ){

     pPager->state = PAGER_EXCLUSIVE;

   }

   pPager->origDbSize = 0;

   pPager->setMaster = 0;

   pPager->needSync = 0;

   lruListSetFirstSynced(pPager);

   pPager->dbSize = -1;

   pPager->dbModified = 0;

   return (rc==SQLITE_OK?rc2:rc);

 }

 /*

 ** Compute and return a checksum for the page of data.

 **

 ** This is not a real checksum.  It is really just the sum of the 

 ** random initial value and the page number.  We experimented with

 ** a checksum of the entire data, but that was found to be too slow.

 **

 ** Note that the page number is stored at the beginning of data and

 ** the checksum is stored at the end.  This is important.  If journal

 ** corruption occurs due to a power failure, the most likely scenario

 ** is that one end or the other of the record will be changed.  It is

 ** much less likely that the two ends of the journal record will be

 ** correct and the middle be corrupt.  Thus, this "checksum" scheme,

 ** though fast and simple, catches the mostly likely kind of corruption.

 **

 ** FIX ME:  Consider adding every 200th (or so) byte of the data to the

 ** checksum.  That way if a single page spans 3 or more disk sectors and

 ** only the middle sector is corrupt, we will still have a reasonable

 ** chance of failing the checksum and thus detecting the problem.

 */

 static u32 pager_cksum(Pager *pPager, const u8 *aData){

   u32 cksum = pPager->cksumInit;

   int i = pPager->pageSize-200;

   while( i>0 ){

     cksum += aData[i];

     i -= 200;

   }

   return cksum;

 }

 /* Forward declaration */

 static void makeClean(PgHdr*);

 /*

 ** Read a single page from the journal file opened on file descriptor

 ** jfd.  Playback this one page.

 **

 ** If useCksum==0 it means this journal does not use checksums.  Checksums

 ** are not used in statement journals because statement journals do not

 ** need to survive power failures.

 */

 static int pager_playback_one_page(

   Pager *pPager, 

   sqlite3_file *jfd,

   i64 offset,

   int useCksum

 ){

   int rc;

   PgHdr *pPg;                   /* An existing page in the cache */

   Pgno pgno;                    /* The page number of a page in journal */

   u32 cksum;                    /* Checksum used for sanity checking */

   u8 *aData = (u8 *)pPager->pTmpSpace;   /* Temp storage for a page */

   /* useCksum should be true for the main journal and false for

   ** statement journals.  Verify that this is always the case

   */

   assert( jfd == (useCksum ? pPager->jfd : pPager->stfd) );

   assert( aData );

   rc = read32bits(jfd, offset, &pgno);

   if( rc!=SQLITE_OK ) return rc;

   rc = sqlite3OsRead(jfd, aData, pPager->pageSize, offset+4);

   if( rc!=SQLITE_OK ) return rc;

   pPager->journalOff += pPager->pageSize + 4;

   /* Sanity checking on the page.  This is more important that I originally

   ** thought.  If a power failure occurs while the journal is being written,

   ** it could cause invalid data to be written into the journal.  We need to

   ** detect this invalid data (with high probability) and ignore it.

   */

   if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){

     return SQLITE_DONE;

   }

   if( pgno>(unsigned)pPager->dbSize ){

     return SQLITE_OK;

   }

   if( useCksum ){

     rc = read32bits(jfd, offset+pPager->pageSize+4, &cksum);

     if( rc ) return rc;

     pPager->journalOff += 4;

     if( pager_cksum(pPager, aData)!=cksum ){

       return SQLITE_DONE;

     }

   }

   assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );

   /* If the pager is in RESERVED state, then there must be a copy of this

   ** page in the pager cache. In this case just update the pager cache,

   ** not the database file. The page is left marked dirty in this case.

   **

   ** An exception to the above rule: If the database is in no-sync mode

   ** and a page is moved during an incremental vacuum then the page may

   ** not be in the pager cache. Later: if a malloc() or IO error occurs

   ** during a Movepage() call, then the page may not be in the cache

   ** either. So the condition described in the above paragraph is not

   ** assert()able.

   **

   ** If in EXCLUSIVE state, then we update the pager cache if it exists

   ** and the main file. The page is then marked not dirty.

   **

   ** Ticket #1171:  The statement journal might contain page content that is

   ** different from the page content at the start of the transaction.

   ** This occurs when a page is changed prior to the start of a statement

   ** then changed again within the statement.  When rolling back such a

   ** statement we must not write to the original database unless we know

   ** for certain that original page contents are synced into the main rollback

   ** journal.  Otherwise, a power loss might leave modified data in the

   ** database file without an entry in the rollback journal that can

   ** restore the database to its original form.  Two conditions must be

   ** met before writing to the database files. (1) the database must be

   ** locked.  (2) we know that the original page content is fully synced

   ** in the main journal either because the page is not in cache or else

   ** the page is marked as needSync==0.

   **

   ** 2008-04-14:  When attempting to vacuum a corrupt database file, it

   ** is possible to fail a statement on a database that does not yet exist.

   ** Do not attempt to write if database file has never been opened.

   */

   pPg = pager_lookup(pPager, pgno);

   PAGERTRACE4("PLAYBACK %d page %d hash(%08x)\n",

                PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData));

   if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0)

         && pPager->fd->pMethods ){

     i64 offset = (pgno-1)*(i64)pPager->pageSize;

     rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, offset);

     if( pPg ){

       makeClean(pPg);

     }

   }

   if( pPg ){

     /* No page should ever be explicitly rolled back that is in use, except

     ** for page 1 which is held in use in order to keep the lock on the

     ** database active. However such a page may be rolled back as a result

     ** of an internal error resulting in an automatic call to

     ** sqlite3PagerRollback().

     */

     void *pData;

     /* assert( pPg->nRef==0 || pPg->pgno==1 ); */

     pData = PGHDR_TO_DATA(pPg);

     memcpy(pData, aData, pPager->pageSize);

     if( pPager->xReiniter ){

       pPager->xReiniter(pPg, pPager->pageSize);

     }

 #ifdef SQLITE_CHECK_PAGES

     pPg->pageHash = pager_pagehash(pPg);

 #endif

     /* If this was page 1, then restore the value of Pager.dbFileVers.

     ** Do this before any decoding. */

     if( pgno==1 ){

       memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));

     }

     /* Decode the page just read from disk */

     CODEC1(pPager, pData, pPg->pgno, 3);

   }

   return rc;

 }

 /*

 ** Parameter zMaster is the name of a master journal file. A single journal

 ** file that referred to the master journal file has just been rolled back.

 ** This routine checks if it is possible to delete the master journal file,

 ** and does so if it is.

 **

 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not 

 ** available for use within this function.

 **

 **

 ** The master journal file contains the names of all child journals.

 ** To tell if a master journal can be deleted, check to each of the

 ** children.  If all children are either missing or do not refer to

 ** a different master journal, then this master journal can be deleted.

 */

 static int pager_delmaster(Pager *pPager, const char *zMaster){

   sqlite3_vfs *pVfs = pPager->pVfs;

   int rc;

   int master_open = 0;

   sqlite3_file *pMaster;

   sqlite3_file *pJournal;

   char *zMasterJournal = 0; /* Contents of master journal file */

   i64 nMasterJournal;       /* Size of master journal file */

   /* Open the master journal file exclusively in case some other process

   ** is running this routine also. Not that it makes too much difference.

   */

   pMaster = (sqlite3_file *)sqlite3Malloc(pVfs->szOsFile * 2);

   pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);

   if( !pMaster ){

     rc = SQLITE_NOMEM;

   }else{

     int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);

     rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);

   }

   if( rc!=SQLITE_OK ) goto delmaster_out;

   master_open = 1;

   rc = sqlite3OsFileSize(pMaster, &nMasterJournal);

   if( rc!=SQLITE_OK ) goto delmaster_out;

   if( nMasterJournal>0 ){

     char *zJournal;

     char *zMasterPtr = 0;

     int nMasterPtr = pPager->pVfs->mxPathname+1;

     /* Load the entire master journal file into space obtained from

     ** sqlite3_malloc() and pointed to by zMasterJournal. 

     */

     zMasterJournal = (char *)sqlite3Malloc(nMasterJournal + nMasterPtr);

     if( !zMasterJournal ){

       rc = SQLITE_NOMEM;

       goto delmaster_out;

     }

     zMasterPtr = &zMasterJournal[nMasterJournal];

     rc = sqlite3OsRead(pMaster, zMasterJournal, nMasterJournal, 0);

     if( rc!=SQLITE_OK ) goto delmaster_out;

     zJournal = zMasterJournal;

     while( (zJournal-zMasterJournal)<nMasterJournal ){

       int exists;

       rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);

       if( rc!=SQLITE_OK ){

         goto delmaster_out;

       }

       if( exists ){

         /* One of the journals pointed to by the master journal exists.

         ** Open it and check if it points at the master journal. If

         ** so, return without deleting the master journal file.

         */

         int c;

         int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);

         rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);

         if( rc!=SQLITE_OK ){

           goto delmaster_out;

         }

         rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);

         sqlite3OsClose(pJournal);

         if( rc!=SQLITE_OK ){

           goto delmaster_out;

         }

         c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;

         if( c ){

           /* We have a match. Do not delete the master journal file. */

           goto delmaster_out;

         }

       }

       zJournal += (strlen(zJournal)+1);

     }

   }

   rc = sqlite3OsDelete(pVfs, zMaster, 0);

 delmaster_out:

   if( zMasterJournal ){

     sqlite3_free(zMasterJournal);

   }  

   if( master_open ){

     sqlite3OsClose(pMaster);

   }

   sqlite3_free(pMaster);

   return rc;

 }

 static void pager_truncate_cache(Pager *pPager);

 /*

 ** Truncate the main file of the given pager to the number of pages

 ** indicated. Also truncate the cached representation of the file.

 **

 ** Might might be the case that the file on disk is smaller than nPage.

 ** This can happen, for example, if we are in the middle of a transaction

 ** which has extended the file size and the new pages are still all held

 ** in cache, then an INSERT or UPDATE does a statement rollback.  Some

 ** operating system implementations can get confused if you try to

 ** truncate a file to some size that is larger than it currently is,

 ** so detect this case and write a single zero byte to the end of the new

 ** file instead.

 */

 static int pager_truncate(Pager *pPager, int nPage){

   int rc = SQLITE_OK;

   if( pPager->state>=PAGER_EXCLUSIVE && pPager->fd->pMethods ){

     i64 currentSize, newSize;

     rc = sqlite3OsFileSize(pPager->fd, &currentSize);

     newSize = pPager->pageSize*(i64)nPage;

     if( rc==SQLITE_OK && currentSize!=newSize ){

       if( currentSize>newSize ){

         rc = sqlite3OsTruncate(pPager->fd, newSize);

       }else{

         rc = sqlite3OsWrite(pPager->fd, "", 1, newSize-1);

       }

     }

   }

   if( rc==SQLITE_OK ){

     pPager->dbSize = nPage;

     pager_truncate_cache(pPager);

   }

   return rc;

 }

 /*

 ** Set the sectorSize for the given pager.

 **

 ** The sector size is at least as big as the sector size reported

 ** by sqlite3OsSectorSize().  The minimum sector size is 512.

 */

 static void setSectorSize(Pager *pPager){

   assert(pPager->fd->pMethods||pPager->tempFile);

   if( !pPager->tempFile ){

     /* Sector size doesn't matter for temporary files. Also, the file

     ** may not have been opened yet, in whcih case the OsSectorSize()

     ** call will segfault.

     */

     pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);

   }

   if( pPager->sectorSize<512 ){

     pPager->sectorSize = 512;

   }

 }

 /*

 ** Playback the journal and thus restore the database file to

 ** the state it was in before we started making changes.  

 **

 ** The journal file format is as follows: 

 **

 **  (1)  8 byte prefix.  A copy of aJournalMagic[].

 **  (2)  4 byte big-endian integer which is the number of valid page records

 **       in the journal.  If this value is 0xffffffff, then compute the

 **       number of page records from the journal size.

 **  (3)  4 byte big-endian integer which is the initial value for the 

 **       sanity checksum.

 **  (4)  4 byte integer which is the number of pages to truncate the

 **       database to during a rollback.

 **  (5)  4 byte big-endian integer which is the sector size.  The header

 **       is this many bytes in size.

 **  (6)  4 byte big-endian integer which is the page case.

 **  (7)  4 byte integer which is the number of bytes in the master journal

 **       name.  The value may be zero (indicate that there is no master

 **       journal.)

 **  (8)  N bytes of the master journal name.  The name will be nul-terminated

 **       and might be shorter than the value read from (5).  If the first byte

 **       of the name is \000 then there is no master journal.  The master

 **       journal name is stored in UTF-8.

 **  (9)  Zero or more pages instances, each as follows:

 **        +  4 byte page number.

 **        +  pPager->pageSize bytes of data.

 **        +  4 byte checksum

 **

 ** When we speak of the journal header, we mean the first 8 items above.

 ** Each entry in the journal is an instance of the 9th item.

 **

 ** Call the value from the second bullet "nRec".  nRec is the number of

 ** valid page entries in the journal.  In most cases, you can compute the

 ** value of nRec from the size of the journal file.  But if a power

 ** failure occurred while the journal was being written, it could be the

 ** case that the size of the journal file had already been increased but

 ** the extra entries had not yet made it safely to disk.  In such a case,

 ** the value of nRec computed from the file size would be too large.  For

 ** that reason, we always use the nRec value in the header.

 **

 ** If the nRec value is 0xffffffff it means that nRec should be computed

 ** from the file size.  This value is used when the user selects the

 ** no-sync option for the journal.  A power failure could lead to corruption

 ** in this case.  But for things like temporary table (which will be

 ** deleted when the power is restored) we don't care.  

 **

 ** If the file opened as the journal file is not a well-formed

 ** journal file then all pages up to the first corrupted page are rolled

 ** back (or no pages if the journal header is corrupted). The journal file

 ** is then deleted and SQLITE_OK returned, just as if no corruption had

 ** been encountered.

 **

 ** If an I/O or malloc() error occurs, the journal-file is not deleted

 ** and an error code is returned.

 */

 static int pager_playback(Pager *pPager, int isHot){

   sqlite3_vfs *pVfs = pPager->pVfs;

   i64 szJ;                 /* Size of the journal file in bytes */

   u32 nRec;                /* Number of Records in the journal */

   u32 u;                   /* Unsigned loop counter */

   Pgno mxPg = 0;           /* Size of the original file in pages */

   int rc;                  /* Result code of a subroutine */

   int res = 1;             /* Value returned by sqlite3OsAccess() */

   char *zMaster = 0;       /* Name of master journal file if any */

   /* Figure out how many records are in the journal.  Abort early if

   ** the journal is empty.

   */

   assert( pPager->journalOpen );

   rc = sqlite3OsFileSize(pPager->jfd, &szJ);

   if( rc!=SQLITE_OK || szJ==0 ){

     goto end_playback;

   }

   /* Read the master journal name from the journal, if it is present.

   ** If a master journal file name is specified, but the file is not

   ** present on disk, then the journal is not hot and does not need to be

   ** played back.

   */

   zMaster = pPager->pTmpSpace;

   rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);

   if( rc==SQLITE_OK && zMaster[0] ){

     rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);

   }

   zMaster = 0;

   if( rc!=SQLITE_OK || !res ){

     goto end_playback;

   }

   pPager->journalOff = 0;

   /* This loop terminates either when the readJournalHdr() call returns

   ** SQLITE_DONE or an IO error occurs. */

   while( 1 ){

     /* Read the next journal header from the journal file.  If there are

     ** not enough bytes left in the journal file for a complete header, or

     ** it is corrupted, then a process must of failed while writing it.

     ** This indicates nothing more needs to be rolled back.

     */

     rc = readJournalHdr(pPager, szJ, &nRec, &mxPg);

     if( rc!=SQLITE_OK ){ 

       if( rc==SQLITE_DONE ){

         rc = SQLITE_OK;

       }

       goto end_playback;

     }

     /* If nRec is 0xffffffff, then this journal was created by a process

     ** working in no-sync mode. This means that the rest of the journal

     ** file consists of pages, there are no more journal headers. Compute

     ** the value of nRec based on this assumption.

     */

     if( nRec==0xffffffff ){

       assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );

       nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager);

     }

     /* If nRec is 0 and this rollback is of a transaction created by this

     ** process and if this is the final header in the journal, then it means

     ** that this part of the journal was being filled but has not yet been

     ** synced to disk.  Compute the number of pages based on the remaining

     ** size of the file.

     **

     ** The third term of the test was added to fix ticket #2565.

     */

     if( nRec==0 && !isHot &&

         pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){

       nRec = (szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager);

     }

     /* If this is the first header read from the journal, truncate the

     ** database file back to its original size.

     */

     if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){

       rc = pager_truncate(pPager, mxPg);

       if( rc!=SQLITE_OK ){

         goto end_playback;

       }

     }

     /* Copy original pages out of the journal and back into the database file.

     */

     for(u=0; u<nRec; u++){

       rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);

       if( rc!=SQLITE_OK ){

         if( rc==SQLITE_DONE ){

           rc = SQLITE_OK;

           pPager->journalOff = szJ;

           break;

         }else{

           goto end_playback;

         }

       }

     }

   }

   /*NOTREACHED*/

   assert( 0 );

 end_playback:

   if( rc==SQLITE_OK ){

     zMaster = pPager->pTmpSpace;

     rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);

   }

   if( rc==SQLITE_OK ){

     rc = pager_end_transaction(pPager, zMaster[0]!='\0');

   }

   if( rc==SQLITE_OK && zMaster[0] ){

     /* If there was a master journal and this routine will return success,

     ** see if it is possible to delete the master journal.

     */

     rc = pager_delmaster(pPager, zMaster);

   }

   /* The Pager.sectorSize variable may have been updated while rolling

   ** back a journal created by a process with a different sector size

   ** value. Reset it to the correct value for this process.

   */

   setSectorSize(pPager);

   return rc;

 }

 /*

 ** Playback the statement journal.

 **

 ** This is similar to playing back the transaction journal but with

 ** a few extra twists.

 **

 **    (1)  The number of pages in the database file at the start of

 **         the statement is stored in pPager->stmtSize, not in the

 **         journal file itself.

 **

 **    (2)  In addition to playing back the statement journal, also

 **         playback all pages of the transaction journal beginning

 **         at offset pPager->stmtJSize.

 */

 static int pager_stmt_playback(Pager *pPager){

   i64 szJ;                 /* Size of the full journal */

   i64 hdrOff;

   int nRec;                /* Number of Records */

   int i;                   /* Loop counter */

   int rc;

   szJ = pPager->journalOff;

   /* Set hdrOff to be the offset just after the end of the last journal

   ** page written before the first journal-header for this statement

   ** transaction was written, or the end of the file if no journal

   ** header was written.

   */

   hdrOff = pPager->stmtHdrOff;

   assert( pPager->fullSync || !hdrOff );

   if( !hdrOff ){

     hdrOff = szJ;

   }

   /* Truncate the database back to its original size.

   */

   rc = pager_truncate(pPager, pPager->stmtSize);

   assert( pPager->state>=PAGER_SHARED );

   /* Figure out how many records are in the statement journal.

   */

   assert( pPager->stmtInUse && pPager->journalOpen );

   nRec = pPager->stmtNRec;

   /* Copy original pages out of the statement journal and back into the

   ** database file.  Note that the statement journal omits checksums from

   ** each record since power-failure recovery is not important to statement

   ** journals.

   */

   for(i=0; i<nRec; i++){

     i64 offset = i*(4+pPager->pageSize);

     rc = pager_playback_one_page(pPager, pPager->stfd, offset, 0);

     assert( rc!=SQLITE_DONE );

     if( rc!=SQLITE_OK ) goto end_stmt_playback;

   }

   /* Now roll some pages back from the transaction journal. Pager.stmtJSize

   ** was the size of the journal file when this statement was started, so

   ** everything after that needs to be rolled back, either into the

   ** database, the memory cache, or both.

   **

   ** If it is not zero, then Pager.stmtHdrOff is the offset to the start

   ** of the first journal header written during this statement transaction.

   */

   pPager->journalOff = pPager->stmtJSize;

   pPager->cksumInit = pPager->stmtCksum;

   while( pPager->journalOff < hdrOff ){

     rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);

     assert( rc!=SQLITE_DONE );

     if( rc!=SQLITE_OK ) goto end_stmt_playback;

   }

   while( pPager->journalOff < szJ ){

     u32 nJRec;         /* Number of Journal Records */

     u32 dummy;

     rc = readJournalHdr(pPager, szJ, &nJRec, &dummy);

     if( rc!=SQLITE_OK ){

       assert( rc!=SQLITE_DONE );

       goto end_stmt_playback;

     }

     if( nJRec==0 ){

       nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8);

     }

     for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){

       rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);

       assert( rc!=SQLITE_DONE );

       if( rc!=SQLITE_OK ) goto end_stmt_playback;

     }

   }

   pPager->journalOff = szJ;

 end_stmt_playback:

   if( rc==SQLITE_OK) {

     pPager->journalOff = szJ;

     /* pager_reload_cache(pPager); */

   }

   return rc;

 }

 /*

 ** Change the maximum number of in-memory pages that are allowed.

 */

 void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){

   if( mxPage>10 ){

     pPager->mxPage = mxPage;

   }else{

     pPager->mxPage = 10;

   }

 }

 /*

 ** Adjust the robustness of the database to damage due to OS crashes

 ** or power failures by changing the number of syncs()s when writing

 ** the rollback journal.  There are three levels:

 **

 **    OFF       sqlite3OsSync() is never called.  This is the default

 **              for temporary and transient files.

 **

 **    NORMAL    The journal is synced once before writes begin on the

 **              database.  This is normally adequate protection, but

 **              it is theoretically possible, though very unlikely,

 **              that an inopertune power failure could leave the journal

 **              in a state which would cause damage to the database

 **              when it is rolled back.

 **

 **    FULL      The journal is synced twice before writes begin on the

 **              database (with some additional information - the nRec field

 **              of the journal header - being written in between the two

 **              syncs).  If we assume that writing a

 **              single disk sector is atomic, then this mode provides

 **              assurance that the journal will not be corrupted to the

 **              point of causing damage to the database during rollback.

 **

 ** Numeric values associated with these states are OFF==1, NORMAL=2,

 ** and FULL=3.

 */

 #ifndef SQLITE_OMIT_PAGER_PRAGMAS

 void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int full_fsync){

   pPager->noSync =  level==1 || pPager->tempFile;

   pPager->fullSync = level==3 && !pPager->tempFile;

   pPager->sync_flags = (full_fsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);

   if( pPager->noSync ) pPager->needSync = 0;

 }

 #endif

 /*

 ** The following global variable is incremented whenever the library

 ** attempts to open a temporary file.  This information is used for

 ** testing and analysis only.  

 */

 #ifdef SQLITE_TEST

 int sqlite3_opentemp_count = 0;

 #endif

 /*

 ** Open a temporary file. 

 **

 ** Write the file descriptor into *fd.  Return SQLITE_OK on success or some

 ** other error code if we fail. The OS will automatically delete the temporary

 ** file when it is closed.

 */

 static int sqlite3PagerOpentemp(

   Pager *pPager,        /* The pager object */

   sqlite3_file *pFile,  /* Write the file descriptor here */

   int vfsFlags          /* Flags passed through to the VFS */

 ){

   int rc;

 #ifdef SQLITE_TEST

   sqlite3_opentemp_count++;  /* Used for testing and analysis only */

 #endif

   vfsFlags |=  SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |

             SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;

   rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);

   assert( rc!=SQLITE_OK || pFile->pMethods );

   return rc;

 }

 /*

 ** Create a new page cache and put a pointer to the page cache in *ppPager.

 ** The file to be cached need not exist.  The file is not locked until

 ** the first call to sqlite3PagerGet() and is only held open until the

 ** last page is released using sqlite3PagerUnref().

 **

 ** If zFilename is NULL then a randomly-named temporary file is created

 ** and used as the file to be cached.  The file will be deleted

 ** automatically when it is closed.

 **

 ** If zFilename is ":memory:" then all information is held in cache.

 ** It is never written to disk.  This can be used to implement an

 ** in-memory database.

 */

 int sqlite3PagerOpen(

   sqlite3_vfs *pVfs,       /* The virtual file system to use */

   Pager **ppPager,         /* Return the Pager structure here */

   const char *zFilename,   /* Name of the database file to open */

   int nExtra,              /* Extra bytes append to each in-memory page */

   int flags,               /* flags controlling this file */

   int vfsFlags             /* flags passed through to sqlite3_vfs.xOpen() */

 ){

   u8 *pPtr;

   Pager *pPager = 0;

   int rc = SQLITE_OK;

   int i;

   int tempFile = 0;

   int memDb = 0;

   int readOnly = 0;

   int useJournal = (flags & PAGER_OMIT_JOURNAL)==0;

   int noReadlock = (flags & PAGER_NO_READLOCK)!=0;

   int journalFileSize = sqlite3JournalSize(pVfs);

   int szPageDflt = SQLITE_DEFAULT_PAGE_SIZE;

   char *zPathname = 0;

   int nPathname = 0;

   /* The default return is a NULL pointer */

   *ppPager = 0;

   /* Compute and store the full pathname in an allocated buffer pointed

   ** to by zPathname, length nPathname. Or, if this is a temporary file,

   ** leave both nPathname and zPathname set to 0.

   */

   if( zFilename && zFilename[0] ){

     nPathname = pVfs->mxPathname+1;

     zPathname = sqlite3Malloc(nPathname*2);

     if( zPathname==0 ){

       return SQLITE_NOMEM;

     }

 #ifndef SQLITE_OMIT_MEMORYDB

     if( strcmp(zFilename,":memory:")==0 ){

       memDb = 1;

       zPathname[0] = 0;

     }else

 #endif

     {

       rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);

     }

     if( rc!=SQLITE_OK ){

       sqlite3_free(zPathname);

       return rc;

     }

     nPathname = strlen(zPathname);

   }

   /* Allocate memory for the pager structure */

   pPager = sqlite3MallocZero(

     sizeof(*pPager) +           /* Pager structure */

     journalFileSize +           /* The journal file structure */ 

     pVfs->szOsFile * 3 +        /* The main db and two journal files */ 

     3*nPathname + 40            /* zFilename, zDirectory, zJournal */

   );

   if( !pPager ){

     sqlite3_free(zPathname);

     return SQLITE_NOMEM;

   }

   pPtr = (u8 *)&pPager[1];

   pPager->vfsFlags = vfsFlags;

   pPager->fd = (sqlite3_file*)&pPtr[pVfs->szOsFile*0];

   pPager->stfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*1];

   pPager->jfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*2];

   pPager->zFilename = (char*)&pPtr[pVfs->szOsFile*2+journalFileSize];

   pPager->zDirectory = &pPager->zFilename[nPathname+1];

   pPager->zJournal = &pPager->zDirectory[nPathname+1];

   pPager->pVfs = pVfs;

   if( zPathname ){

     memcpy(pPager->zFilename, zPathname, nPathname+1);

     sqlite3_free(zPathname);

   }

   /* Open the pager file.

   */

   if( zFilename && zFilename[0] && !memDb ){

     if( nPathname>(pVfs->mxPathname - sizeof("-journal")) ){

       rc = SQLITE_CANTOPEN;

     }else{

       int fout = 0;

       rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd,

                          pPager->vfsFlags, &fout);

       readOnly = (fout&SQLITE_OPEN_READONLY);

       /* If the file was successfully opened for read/write access,

       ** choose a default page size in case we have to create the

       ** database file. The default page size is the maximum of:

       **

       **    + SQLITE_DEFAULT_PAGE_SIZE,

       **    + The value returned by sqlite3OsSectorSize()

       **    + The largest page size that can be written atomically.

       */

       if( rc==SQLITE_OK && !readOnly ){

         int iSectorSize = sqlite3OsSectorSize(pPager->fd);

         if( szPageDflt<iSectorSize ){

           szPageDflt = iSectorSize;

         }

 #ifdef SQLITE_ENABLE_ATOMIC_WRITE

         {

           int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);

           int ii;

           assert(SQLITE_IOCAP_ATOMIC512==(512>>8));

           assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));

           assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);

           for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){

             if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ) szPageDflt = ii;

           }

         }

 #endif

         if( szPageDflt>SQLITE_MAX_DEFAULT_PAGE_SIZE ){

           szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;

         }

       }

     }

   }else if( !memDb ){

     /* If a temporary file is requested, it is not opened immediately.

     ** In this case we accept the default page size and delay actually

     ** opening the file until the first call to OsWrite().

     */ 

     tempFile = 1;

     pPager->state = PAGER_EXCLUSIVE;

   }

   if( pPager && rc==SQLITE_OK ){

     pPager->pTmpSpace = sqlite3PageMalloc(szPageDflt);

   }

   /* If an error occured in either of the blocks above.

   ** Free the Pager structure and close the file.

   ** Since the pager is not allocated there is no need to set 

   ** any Pager.errMask variables.

   */

   if( !pPager || !pPager->pTmpSpace ){

     sqlite3OsClose(pPager->fd);

     sqlite3_free(pPager);

     return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc);

   }

   PAGERTRACE3("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename);

   IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))

   /* Fill in Pager.zDirectory[] */

   memcpy(pPager->zDirectory, pPager->zFilename, nPathname+1);

   for(i=strlen(pPager->zDirectory); i>0 && pPager->zDirectory[i-1]!='/'; i--){}

   if( i>0 ) pPager->zDirectory[i-1] = 0;

   /* Fill in Pager.zJournal[] */

   if( zPathname ){

     memcpy(pPager->zJournal, pPager->zFilename, nPathname);

     memcpy(&pPager->zJournal[nPathname], "-journal", 9);

   }else{

     pPager->zJournal = 0;

   }

   /* pPager->journalOpen = 0; */

   pPager->useJournal = useJournal && !memDb;

   pPager->noReadlock = noReadlock && readOnly;

   /* pPager->stmtOpen = 0; */

   /* pPager->stmtInUse = 0; */

   /* pPager->nRef = 0; */

   pPager->dbSize = memDb-1;

   pPager->pageSize = szPageDflt;

   /* pPager->stmtSize = 0; */

   /* pPager->stmtJSize = 0; */

   /* pPager->nPage = 0; */

   pPager->mxPage = 100;

   pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;

   /* pPager->state = PAGER_UNLOCK; */

   assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );

   /* pPager->errMask = 0; */

   pPager->tempFile = tempFile;

   assert( tempFile==PAGER_LOCKINGMODE_NORMAL 

           || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );

   assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );

   pPager->exclusiveMode = tempFile; 

   pPager->memDb = memDb;

   pPager->readOnly = readOnly;

   /* pPager->needSync = 0; */

   pPager->noSync = pPager->tempFile || !useJournal;

   pPager->fullSync = (pPager->noSync?0:1);

   pPager->sync_flags = SQLITE_SYNC_NORMAL;

   /* pPager->pFirst = 0; */

   /* pPager->pFirstSynced = 0; */

   /* pPager->pLast = 0; */

   pPager->nExtra = FORCE_ALIGNMENT(nExtra);

   pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;

   assert(pPager->fd->pMethods||memDb||tempFile);

   if( !memDb ){

     setSectorSize(pPager);

   }

   /* pPager->pBusyHandler = 0; */

   /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */

   *ppPager = pPager;

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   pPager->iInUseMM = 0;

   pPager->iInUseDB = 0;

   if( !memDb ){

 #ifndef SQLITE_MUTEX_NOOP

     sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM2);

 #endif

     sqlite3_mutex_enter(mutex);

     pPager->pNext = sqlite3PagerList;

     if( sqlite3PagerList ){

       assert( sqlite3PagerList->pPrev==0 );

       sqlite3PagerList->pPrev = pPager;

     }

     pPager->pPrev = 0;

     sqlite3PagerList = pPager;

     sqlite3_mutex_leave(mutex);

   }

 #endif

   return SQLITE_OK;

 }

 /*

 ** Set the busy handler function.

 */

 void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){

   pPager->pBusyHandler = pBusyHandler;

 }

 /*

 ** Set the destructor for this pager.  If not NULL, the destructor is called

 ** when the reference count on each page reaches zero.  The destructor can

 ** be used to clean up information in the extra segment appended to each page.

 **

 ** The destructor is not called as a result sqlite3PagerClose().  

 ** Destructors are only called by sqlite3PagerUnref().

 */

 void sqlite3PagerSetDestructor(Pager *pPager, void (*xDesc)(DbPage*,int)){

   pPager->xDestructor = xDesc;

 }

 /*

 ** Set the reinitializer for this pager.  If not NULL, the reinitializer

 ** is called when the content of a page in cache is restored to its original

 ** value as a result of a rollback.  The callback gives higher-level code

 ** an opportunity to restore the EXTRA section to agree with the restored

 ** page data.

 */

 void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*,int)){

   pPager->xReiniter = xReinit;

 }

 /*

 ** Set the page size to *pPageSize. If the suggest new page size is

 ** inappropriate, then an alternative page size is set to that

 ** value before returning.

 */

 int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize){

   int rc = SQLITE_OK;

   u16 pageSize = *pPageSize;

   assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );

   if( pageSize && pageSize!=pPager->pageSize 

    && !pPager->memDb && pPager->nRef==0 

   ){

     char *pNew = (char *)sqlite3PageMalloc(pageSize);

     if( !pNew ){

       rc = SQLITE_NOMEM;

     }else{

       pagerEnter(pPager);

       pager_reset(pPager);

       pPager->pageSize = pageSize;

       setSectorSize(pPager);

       sqlite3PageFree(pPager->pTmpSpace);

       pPager->pTmpSpace = pNew;

       pagerLeave(pPager);

     }

   }

   *pPageSize = pPager->pageSize;

   return rc;

 }

 /*

 ** Return a pointer to the "temporary page" buffer held internally

 ** by the pager.  This is a buffer that is big enough to hold the

 ** entire content of a database page.  This buffer is used internally

 ** during rollback and will be overwritten whenever a rollback

 ** occurs.  But other modules are free to use it too, as long as

 ** no rollbacks are happening.

 */

 void *sqlite3PagerTempSpace(Pager *pPager){

   return pPager->pTmpSpace;

 }

 /*

 ** Attempt to set the maximum database page count if mxPage is positive. 

 ** Make no changes if mxPage is zero or negative.  And never reduce the

 ** maximum page count below the current size of the database.

 **

 ** Regardless of mxPage, return the current maximum page count.

 */

 int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){

   if( mxPage>0 ){

     pPager->mxPgno = mxPage;

   }

   sqlite3PagerPagecount(pPager, 0);

   return pPager->mxPgno;

 }

 /*

 ** The following set of routines are used to disable the simulated

 ** I/O error mechanism.  These routines are used to avoid simulated

 ** errors in places where we do not care about errors.

 **

 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops

 ** and generate no code.

 */

 #ifdef SQLITE_TEST

 extern int sqlite3_io_error_pending;

 extern int sqlite3_io_error_hit;

 static int saved_cnt;

 void disable_simulated_io_errors(void){

   saved_cnt = sqlite3_io_error_pending;

   sqlite3_io_error_pending = -1;

 }

 void enable_simulated_io_errors(void){

   sqlite3_io_error_pending = saved_cnt;

 }

 #else

 # define disable_simulated_io_errors()

 # define enable_simulated_io_errors()

 #endif

 /*

 ** Read the first N bytes from the beginning of the file into memory

 ** that pDest points to. 

 **

 ** No error checking is done. The rational for this is that this function 

 ** may be called even if the file does not exist or contain a header. In 

 ** these cases sqlite3OsRead() will return an error, to which the correct 

 ** response is to zero the memory at pDest and continue.  A real IO error 

 ** will presumably recur and be picked up later (Todo: Think about this).

 */

 int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){

   int rc = SQLITE_OK;

   memset(pDest, 0, N);

   assert(MEMDB||pPager->fd->pMethods||pPager->tempFile);

   if( pPager->fd->pMethods ){

     IOTRACE(("DBHDR %p 0 %d\n", pPager, N))

     rc = sqlite3OsRead(pPager->fd, pDest, N, 0);

     if( rc==SQLITE_IOERR_SHORT_READ ){

       rc = SQLITE_OK;

     }

   }

   return rc;

 }

 /*

 ** Return the total number of pages in the disk file associated with

 ** pPager. 

 **

 ** If the PENDING_BYTE lies on the page directly after the end of the

 ** file, then consider this page part of the file too. For example, if

 ** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the

 ** file is 4096 bytes, 5 is returned instead of 4.

 */

 int sqlite3PagerPagecount(Pager *pPager, int *pnPage){

   i64 n = 0;

   int rc;

   assert( pPager!=0 );

   if( pPager->errCode ){

     return pPager->errCode;

   }

   if( pPager->dbSize>=0 ){

     n = pPager->dbSize;

   } else {

     assert(pPager->fd->pMethods||pPager->tempFile);

     if( (pPager->fd->pMethods)

      && (rc = sqlite3OsFileSize(pPager->fd, &n))!=SQLITE_OK ){

       pPager->nRef++;

       pager_error(pPager, rc);

       pPager->nRef--;

       return rc;

     }

     if( n>0 && n<pPager->pageSize ){

       n = 1;

     }else{

       n /= pPager->pageSize;

     }

     if( pPager->state!=PAGER_UNLOCK ){

       pPager->dbSize = n;

     }

   }

   if( n==(PENDING_BYTE/pPager->pageSize) ){

     n++;

   }

   if( n>pPager->mxPgno ){

     pPager->mxPgno = n;

   }

   if( pnPage ){

     *pnPage = n;

   }

   return SQLITE_OK;

 }

 #ifndef SQLITE_OMIT_MEMORYDB

 /*

 ** Clear a PgHistory block

 */

 static void clearHistory(PgHistory *pHist){

   sqlite3PageFree(pHist->pOrig);

   sqlite3PageFree(pHist->pStmt);

   pHist->pOrig = 0;

   pHist->pStmt = 0;

 }

 #else

 #define clearHistory(x)

 #endif

 /*

 ** Forward declaration

 */

 static int syncJournal(Pager*);

 /*

 ** Unlink pPg from its hash chain. Also set the page number to 0 to indicate

 ** that the page is not part of any hash chain. This is required because the

 ** sqlite3PagerMovepage() routine can leave a page in the 

 ** pNextFree/pPrevFree list that is not a part of any hash-chain.

 */

 static void unlinkHashChain(Pager *pPager, PgHdr *pPg){

   if( pPg->pgno==0 ){

     assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );

     return;

   }

   if( pPg->pNextHash ){

     pPg->pNextHash->pPrevHash = pPg->pPrevHash;

   }

   if( pPg->pPrevHash ){

     assert( pPager->aHash[pPg->pgno & (pPager->nHash-1)]!=pPg );

     pPg->pPrevHash->pNextHash = pPg->pNextHash;

   }else{

     int h = pPg->pgno & (pPager->nHash-1);

     pPager->aHash[h] = pPg->pNextHash;

   }

   if( MEMDB ){

     clearHistory(PGHDR_TO_HIST(pPg, pPager));

   }

   pPg->pgno = 0;

   pPg->pNextHash = pPg->pPrevHash = 0;

 }

 /*

 ** Unlink a page from the free list (the list of all pages where nRef==0)

 ** and from its hash collision chain.

 */

 static void unlinkPage(PgHdr *pPg){

   Pager *pPager = pPg->pPager;

   /* Unlink from free page list */

   lruListRemove(pPg);

   /* Unlink from the pgno hash table */

   unlinkHashChain(pPager, pPg);

 }

 /*

 ** This routine is used to truncate the cache when a database

 ** is truncated.  Drop from the cache all pages whose pgno is

 ** larger than pPager->dbSize and is unreferenced.

 **

 ** Referenced pages larger than pPager->dbSize are zeroed.

 **

 ** Actually, at the point this routine is called, it would be

 ** an error to have a referenced page.  But rather than delete

 ** that page and guarantee a subsequent segfault, it seems better

 ** to zero it and hope that we error out sanely.

 */

 static void pager_truncate_cache(Pager *pPager){

   PgHdr *pPg;

   PgHdr **ppPg;

   int dbSize = pPager->dbSize;

   ppPg = &pPager->pAll;

   while( (pPg = *ppPg)!=0 ){

     if( pPg->pgno<=dbSize ){

       ppPg = &pPg->pNextAll;

     }else if( pPg->nRef>0 ){

       memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);

       ppPg = &pPg->pNextAll;

     }else{

       *ppPg = pPg->pNextAll;