pager.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:172k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2001 September 15
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This is the implementation of the page cache subsystem or "pager".
  13. ** 
  14. ** The pager is used to access a database disk file.  It implements
  15. ** atomic commit and rollback through the use of a journal file that
  16. ** is separate from the database file.  The pager also implements file
  17. ** locking to prevent two processes from writing the same database
  18. ** file simultaneously, or one process from reading the database while
  19. ** another is writing.
  20. **
  21. ** @(#) $Id: pager.c,v 1.426 2008/04/14 23:13:46 drh Exp $
  22. */
  23. #ifndef SQLITE_OMIT_DISKIO
  24. #include "sqliteInt.h"
  25. #include <assert.h>
  26. #include <string.h>
  27. /*
  28. ** Macros for troubleshooting.  Normally turned off
  29. */
  30. #if 0
  31. #define sqlite3DebugPrintf printf
  32. #define PAGERTRACE1(X)       sqlite3DebugPrintf(X)
  33. #define PAGERTRACE2(X,Y)     sqlite3DebugPrintf(X,Y)
  34. #define PAGERTRACE3(X,Y,Z)   sqlite3DebugPrintf(X,Y,Z)
  35. #define PAGERTRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W)
  36. #define PAGERTRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V)
  37. #else
  38. #define PAGERTRACE1(X)
  39. #define PAGERTRACE2(X,Y)
  40. #define PAGERTRACE3(X,Y,Z)
  41. #define PAGERTRACE4(X,Y,Z,W)
  42. #define PAGERTRACE5(X,Y,Z,W,V)
  43. #endif
  44. /*
  45. ** The following two macros are used within the PAGERTRACEX() macros above
  46. ** to print out file-descriptors. 
  47. **
  48. ** PAGERID() takes a pointer to a Pager struct as its argument. The
  49. ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
  50. ** struct as its argument.
  51. */
  52. #define PAGERID(p) ((int)(p->fd))
  53. #define FILEHANDLEID(fd) ((int)fd)
  54. /*
  55. ** The page cache as a whole is always in one of the following
  56. ** states:
  57. **
  58. **   PAGER_UNLOCK        The page cache is not currently reading or 
  59. **                       writing the database file.  There is no
  60. **                       data held in memory.  This is the initial
  61. **                       state.
  62. **
  63. **   PAGER_SHARED        The page cache is reading the database.
  64. **                       Writing is not permitted.  There can be
  65. **                       multiple readers accessing the same database
  66. **                       file at the same time.
  67. **
  68. **   PAGER_RESERVED      This process has reserved the database for writing
  69. **                       but has not yet made any changes.  Only one process
  70. **                       at a time can reserve the database.  The original
  71. **                       database file has not been modified so other
  72. **                       processes may still be reading the on-disk
  73. **                       database file.
  74. **
  75. **   PAGER_EXCLUSIVE     The page cache is writing the database.
  76. **                       Access is exclusive.  No other processes or
  77. **                       threads can be reading or writing while one
  78. **                       process is writing.
  79. **
  80. **   PAGER_SYNCED        The pager moves to this state from PAGER_EXCLUSIVE
  81. **                       after all dirty pages have been written to the
  82. **                       database file and the file has been synced to
  83. **                       disk. All that remains to do is to remove or
  84. **                       truncate the journal file and the transaction 
  85. **                       will be committed.
  86. **
  87. ** The page cache comes up in PAGER_UNLOCK.  The first time a
  88. ** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED.
  89. ** After all pages have been released using sqlite_page_unref(),
  90. ** the state transitions back to PAGER_UNLOCK.  The first time
  91. ** that sqlite3PagerWrite() is called, the state transitions to
  92. ** PAGER_RESERVED.  (Note that sqlite3PagerWrite() can only be
  93. ** called on an outstanding page which means that the pager must
  94. ** be in PAGER_SHARED before it transitions to PAGER_RESERVED.)
  95. ** PAGER_RESERVED means that there is an open rollback journal.
  96. ** The transition to PAGER_EXCLUSIVE occurs before any changes
  97. ** are made to the database file, though writes to the rollback
  98. ** journal occurs with just PAGER_RESERVED.  After an sqlite3PagerRollback()
  99. ** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED,
  100. ** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode.
  101. */
  102. #define PAGER_UNLOCK      0
  103. #define PAGER_SHARED      1   /* same as SHARED_LOCK */
  104. #define PAGER_RESERVED    2   /* same as RESERVED_LOCK */
  105. #define PAGER_EXCLUSIVE   4   /* same as EXCLUSIVE_LOCK */
  106. #define PAGER_SYNCED      5
  107. /*
  108. ** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time,
  109. ** then failed attempts to get a reserved lock will invoke the busy callback.
  110. ** This is off by default.  To see why, consider the following scenario:
  111. ** 
  112. ** Suppose thread A already has a shared lock and wants a reserved lock.
  113. ** Thread B already has a reserved lock and wants an exclusive lock.  If
  114. ** both threads are using their busy callbacks, it might be a long time
  115. ** be for one of the threads give up and allows the other to proceed.
  116. ** But if the thread trying to get the reserved lock gives up quickly
  117. ** (if it never invokes its busy callback) then the contention will be
  118. ** resolved quickly.
  119. */
  120. #ifndef SQLITE_BUSY_RESERVED_LOCK
  121. # define SQLITE_BUSY_RESERVED_LOCK 0
  122. #endif
  123. /*
  124. ** This macro rounds values up so that if the value is an address it
  125. ** is guaranteed to be an address that is aligned to an 8-byte boundary.
  126. */
  127. #define FORCE_ALIGNMENT(X)   (((X)+7)&~7)
  128. typedef struct PgHdr PgHdr;
  129. /*
  130. ** Each pager stores all currently unreferenced pages in a list sorted
  131. ** in least-recently-used (LRU) order (i.e. the first item on the list has 
  132. ** not been referenced in a long time, the last item has been recently
  133. ** used). An instance of this structure is included as part of each
  134. ** pager structure for this purpose (variable Pager.lru).
  135. **
  136. ** Additionally, if memory-management is enabled, all unreferenced pages 
  137. ** are stored in a global LRU list (global variable sqlite3LruPageList).
  138. **
  139. ** In both cases, the PagerLruList.pFirstSynced variable points to
  140. ** the first page in the corresponding list that does not require an
  141. ** fsync() operation before its memory can be reclaimed. If no such
  142. ** page exists, PagerLruList.pFirstSynced is set to NULL.
  143. */
  144. typedef struct PagerLruList PagerLruList;
  145. struct PagerLruList {
  146.   PgHdr *pFirst;         /* First page in LRU list */
  147.   PgHdr *pLast;          /* Last page in LRU list (the most recently used) */
  148.   PgHdr *pFirstSynced;   /* First page in list with PgHdr.needSync==0 */
  149. };
  150. /*
  151. ** The following structure contains the next and previous pointers used
  152. ** to link a PgHdr structure into a PagerLruList linked list. 
  153. */
  154. typedef struct PagerLruLink PagerLruLink;
  155. struct PagerLruLink {
  156.   PgHdr *pNext;
  157.   PgHdr *pPrev;
  158. };
  159. /*
  160. ** Each in-memory image of a page begins with the following header.
  161. ** This header is only visible to this pager module.  The client
  162. ** code that calls pager sees only the data that follows the header.
  163. **
  164. ** Client code should call sqlite3PagerWrite() on a page prior to making
  165. ** any modifications to that page.  The first time sqlite3PagerWrite()
  166. ** is called, the original page contents are written into the rollback
  167. ** journal and PgHdr.inJournal and PgHdr.needSync are set.  Later, once
  168. ** the journal page has made it onto the disk surface, PgHdr.needSync
  169. ** is cleared.  The modified page cannot be written back into the original
  170. ** database file until the journal pages has been synced to disk and the
  171. ** PgHdr.needSync has been cleared.
  172. **
  173. ** The PgHdr.dirty flag is set when sqlite3PagerWrite() is called and
  174. ** is cleared again when the page content is written back to the original
  175. ** database file.
  176. **
  177. ** Details of important structure elements:
  178. **
  179. ** needSync
  180. **
  181. **     If this is true, this means that it is not safe to write the page
  182. **     content to the database because the original content needed
  183. **     for rollback has not by synced to the main rollback journal.
  184. **     The original content may have been written to the rollback journal
  185. **     but it has not yet been synced.  So we cannot write to the database
  186. **     file because power failure might cause the page in the journal file
  187. **     to never reach the disk.  It is as if the write to the journal file
  188. **     does not occur until the journal file is synced.
  189. **     
  190. **     This flag is false if the page content exactly matches what
  191. **     currently exists in the database file.  The needSync flag is also
  192. **     false if the original content has been written to the main rollback
  193. **     journal and synced.  If the page represents a new page that has
  194. **     been added onto the end of the database during the current
  195. **     transaction, the needSync flag is true until the original database
  196. **     size in the journal header has been synced to disk.
  197. **
  198. ** inJournal
  199. **
  200. **     This is true if the original page has been written into the main
  201. **     rollback journal.  This is always false for new pages added to
  202. **     the end of the database file during the current transaction.
  203. **     And this flag says nothing about whether or not the journal
  204. **     has been synced to disk.  For pages that are in the original
  205. **     database file, the following expression should always be true:
  206. **
  207. **       inJournal = sqlite3BitvecTest(pPager->pInJournal, pgno)
  208. **
  209. **     The pPager->pInJournal object is only valid for the original
  210. **     pages of the database, not new pages that are added to the end
  211. **     of the database, so obviously the above expression cannot be
  212. **     valid for new pages.  For new pages inJournal is always 0.
  213. **
  214. ** dirty
  215. **
  216. **     When true, this means that the content of the page has been
  217. **     modified and needs to be written back to the database file.
  218. **     If false, it means that either the content of the page is
  219. **     unchanged or else the content is unimportant and we do not
  220. **     care whether or not it is preserved.
  221. **
  222. ** alwaysRollback
  223. **
  224. **     This means that the sqlite3PagerDontRollback() API should be
  225. **     ignored for this page.  The DontRollback() API attempts to say
  226. **     that the content of the page on disk is unimportant (it is an
  227. **     unused page on the freelist) so that it is unnecessary to 
  228. **     rollback changes to this page because the content of the page
  229. **     can change without changing the meaning of the database.  This
  230. **     flag overrides any DontRollback() attempt.  This flag is set
  231. **     when a page that originally contained valid data is added to
  232. **     the freelist.  Later in the same transaction, this page might
  233. **     be pulled from the freelist and reused for something different
  234. **     and at that point the DontRollback() API will be called because
  235. **     pages taken from the freelist do not need to be protected by
  236. **     the rollback journal.  But this flag says that the page was
  237. **     not originally part of the freelist so that it still needs to
  238. **     be rolled back in spite of any subsequent DontRollback() calls.
  239. **
  240. ** needRead 
  241. **
  242. **     This flag means (when true) that the content of the page has
  243. **     not yet been loaded from disk.  The in-memory content is just
  244. **     garbage.  (Actually, we zero the content, but you should not
  245. **     make any assumptions about the content nevertheless.)  If the
  246. **     content is needed in the future, it should be read from the
  247. **     original database file.
  248. */
  249. struct PgHdr {
  250.   Pager *pPager;                 /* The pager to which this page belongs */
  251.   Pgno pgno;                     /* The page number for this page */
  252.   PgHdr *pNextHash, *pPrevHash;  /* Hash collision chain for PgHdr.pgno */
  253.   PagerLruLink free;             /* Next and previous free pages */
  254.   PgHdr *pNextAll;               /* A list of all pages */
  255.   u8 inJournal;                  /* TRUE if has been written to journal */
  256.   u8 dirty;                      /* TRUE if we need to write back changes */
  257.   u8 needSync;                   /* Sync journal before writing this page */
  258.   u8 alwaysRollback;             /* Disable DontRollback() for this page */
  259.   u8 needRead;                   /* Read content if PagerWrite() is called */
  260.   short int nRef;                /* Number of users of this page */
  261.   PgHdr *pDirty, *pPrevDirty;    /* Dirty pages */
  262. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  263.   PagerLruLink gfree;            /* Global list of nRef==0 pages */
  264. #endif
  265. #ifdef SQLITE_CHECK_PAGES
  266.   u32 pageHash;
  267. #endif
  268.   void *pData;                   /* Page data */
  269.   /* Pager.nExtra bytes of local data appended to this header */
  270. };
  271. /*
  272. ** For an in-memory only database, some extra information is recorded about
  273. ** each page so that changes can be rolled back.  (Journal files are not
  274. ** used for in-memory databases.)  The following information is added to
  275. ** the end of every EXTRA block for in-memory databases.
  276. **
  277. ** This information could have been added directly to the PgHdr structure.
  278. ** But then it would take up an extra 8 bytes of storage on every PgHdr
  279. ** even for disk-based databases.  Splitting it out saves 8 bytes.  This
  280. ** is only a savings of 0.8% but those percentages add up.
  281. */
  282. typedef struct PgHistory PgHistory;
  283. struct PgHistory {
  284.   u8 *pOrig;     /* Original page text.  Restore to this on a full rollback */
  285.   u8 *pStmt;     /* Text as it was at the beginning of the current statement */
  286.   PgHdr *pNextStmt, *pPrevStmt;  /* List of pages in the statement journal */
  287.   u8 inStmt;                     /* TRUE if in the statement subjournal */
  288. };
  289. /*
  290. ** A macro used for invoking the codec if there is one
  291. */
  292. #ifdef SQLITE_HAS_CODEC
  293. # define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); }
  294. # define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D))
  295. #else
  296. # define CODEC1(P,D,N,X) /* NO-OP */
  297. # define CODEC2(P,D,N,X) ((char*)D)
  298. #endif
  299. /*
  300. ** Convert a pointer to a PgHdr into a pointer to its data
  301. ** and back again.
  302. */
  303. #define PGHDR_TO_DATA(P)    ((P)->pData)
  304. #define PGHDR_TO_EXTRA(G,P) ((void*)&((G)[1]))
  305. #define PGHDR_TO_HIST(P,PGR)  
  306.             ((PgHistory*)&((char*)(&(P)[1]))[(PGR)->nExtra])
  307. /*
  308. ** A open page cache is an instance of the following structure.
  309. **
  310. ** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
  311. ** or SQLITE_FULL. Once one of the first three errors occurs, it persists
  312. ** and is returned as the result of every major pager API call.  The
  313. ** SQLITE_FULL return code is slightly different. It persists only until the
  314. ** next successful rollback is performed on the pager cache. Also,
  315. ** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()
  316. ** APIs, they may still be used successfully.
  317. */
  318. struct Pager {
  319.   sqlite3_vfs *pVfs;          /* OS functions to use for IO */
  320.   u8 journalOpen;             /* True if journal file descriptors is valid */
  321.   u8 journalStarted;          /* True if header of journal is synced */
  322.   u8 useJournal;              /* Use a rollback journal on this file */
  323.   u8 noReadlock;              /* Do not bother to obtain readlocks */
  324.   u8 stmtOpen;                /* True if the statement subjournal is open */
  325.   u8 stmtInUse;               /* True we are in a statement subtransaction */
  326.   u8 stmtAutoopen;            /* Open stmt journal when main journal is opened*/
  327.   u8 noSync;                  /* Do not sync the journal if true */
  328.   u8 fullSync;                /* Do extra syncs of the journal for robustness */
  329.   u8 sync_flags;              /* One of SYNC_NORMAL or SYNC_FULL */
  330.   u8 state;                   /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */
  331.   u8 tempFile;                /* zFilename is a temporary file */
  332.   u8 readOnly;                /* True for a read-only database */
  333.   u8 needSync;                /* True if an fsync() is needed on the journal */
  334.   u8 dirtyCache;              /* True if cached pages have changed */
  335.   u8 alwaysRollback;          /* Disable DontRollback() for all pages */
  336.   u8 memDb;                   /* True to inhibit all file I/O */
  337.   u8 setMaster;               /* True if a m-j name has been written to jrnl */
  338.   u8 doNotSync;               /* Boolean. While true, do not spill the cache */
  339.   u8 exclusiveMode;           /* Boolean. True if locking_mode==EXCLUSIVE */
  340.   u8 changeCountDone;         /* Set after incrementing the change-counter */
  341.   u32 vfsFlags;               /* Flags for sqlite3_vfs.xOpen() */
  342.   int errCode;                /* One of several kinds of errors */
  343.   int dbSize;                 /* Number of pages in the file */
  344.   int origDbSize;             /* dbSize before the current change */
  345.   int stmtSize;               /* Size of database (in pages) at stmt_begin() */
  346.   int nRec;                   /* Number of pages written to the journal */
  347.   u32 cksumInit;              /* Quasi-random value added to every checksum */
  348.   int stmtNRec;               /* Number of records in stmt subjournal */
  349.   int nExtra;                 /* Add this many bytes to each in-memory page */
  350.   int pageSize;               /* Number of bytes in a page */
  351.   int nPage;                  /* Total number of in-memory pages */
  352.   int nRef;                   /* Number of in-memory pages with PgHdr.nRef>0 */
  353.   int mxPage;                 /* Maximum number of pages to hold in cache */
  354.   Pgno mxPgno;                /* Maximum allowed size of the database */
  355.   Bitvec *pInJournal;         /* One bit for each page in the database file */
  356.   Bitvec *pInStmt;            /* One bit for each page in the database */
  357.   char *zFilename;            /* Name of the database file */
  358.   char *zJournal;             /* Name of the journal file */
  359.   char *zDirectory;           /* Directory hold database and journal files */
  360.   char *zStmtJrnl;            /* Name of the statement journal file */
  361.   sqlite3_file *fd, *jfd;     /* File descriptors for database and journal */
  362.   sqlite3_file *stfd;         /* File descriptor for the statement subjournal*/
  363.   BusyHandler *pBusyHandler;  /* Pointer to sqlite.busyHandler */
  364.   PagerLruList lru;           /* LRU list of free pages */
  365.   PgHdr *pAll;                /* List of all pages */
  366.   PgHdr *pStmt;               /* List of pages in the statement subjournal */
  367.   PgHdr *pDirty;              /* List of all dirty pages */
  368.   i64 journalOff;             /* Current byte offset in the journal file */
  369.   i64 journalHdr;             /* Byte offset to previous journal header */
  370.   i64 stmtHdrOff;             /* First journal header written this statement */
  371.   i64 stmtCksum;              /* cksumInit when statement was started */
  372.   i64 stmtJSize;              /* Size of journal at stmt_begin() */
  373.   int sectorSize;             /* Assumed sector size during rollback */
  374. #ifdef SQLITE_TEST
  375.   int nHit, nMiss;            /* Cache hits and missing */
  376.   int nRead, nWrite;          /* Database pages read/written */
  377. #endif
  378.   void (*xDestructor)(DbPage*,int); /* Call this routine when freeing pages */
  379.   void (*xReiniter)(DbPage*,int);   /* Call this routine when reloading pages */
  380. #ifdef SQLITE_HAS_CODEC
  381.   void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
  382.   void *pCodecArg;            /* First argument to xCodec() */
  383. #endif
  384.   int nHash;                  /* Size of the pager hash table */
  385.   PgHdr **aHash;              /* Hash table to map page number to PgHdr */
  386. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  387.   Pager *pNext;               /* Doubly linked list of pagers on which */
  388.   Pager *pPrev;               /* sqlite3_release_memory() will work */
  389.   int iInUseMM;               /* Non-zero if unavailable to MM */
  390.   int iInUseDB;               /* Non-zero if in sqlite3_release_memory() */
  391. #endif
  392.   char *pTmpSpace;            /* Pager.pageSize bytes of space for tmp use */
  393.   char dbFileVers[16];        /* Changes whenever database file changes */
  394. };
  395. /*
  396. ** The following global variables hold counters used for
  397. ** testing purposes only.  These variables do not exist in
  398. ** a non-testing build.  These variables are not thread-safe.
  399. */
  400. #ifdef SQLITE_TEST
  401. int sqlite3_pager_readdb_count = 0;    /* Number of full pages read from DB */
  402. int sqlite3_pager_writedb_count = 0;   /* Number of full pages written to DB */
  403. int sqlite3_pager_writej_count = 0;    /* Number of pages written to journal */
  404. int sqlite3_pager_pgfree_count = 0;    /* Number of cache pages freed */
  405. # define PAGER_INCR(v)  v++
  406. #else
  407. # define PAGER_INCR(v)
  408. #endif
  409. /*
  410. ** The following variable points to the head of a double-linked list
  411. ** of all pagers that are eligible for page stealing by the
  412. ** sqlite3_release_memory() interface.  Access to this list is
  413. ** protected by the SQLITE_MUTEX_STATIC_MEM2 mutex.
  414. */
  415. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  416. static Pager *sqlite3PagerList = 0;
  417. static PagerLruList sqlite3LruPageList = {0, 0, 0};
  418. #endif
  419. /*
  420. ** Journal files begin with the following magic string.  The data
  421. ** was obtained from /dev/random.  It is used only as a sanity check.
  422. **
  423. ** Since version 2.8.0, the journal format contains additional sanity
  424. ** checking information.  If the power fails while the journal is begin
  425. ** written, semi-random garbage data might appear in the journal
  426. ** file after power is restored.  If an attempt is then made
  427. ** to roll the journal back, the database could be corrupted.  The additional
  428. ** sanity checking data is an attempt to discover the garbage in the
  429. ** journal and ignore it.
  430. **
  431. ** The sanity checking information for the new journal format consists
  432. ** of a 32-bit checksum on each page of data.  The checksum covers both
  433. ** the page number and the pPager->pageSize bytes of data for the page.
  434. ** This cksum is initialized to a 32-bit random value that appears in the
  435. ** journal file right after the header.  The random initializer is important,
  436. ** because garbage data that appears at the end of a journal is likely
  437. ** data that was once in other files that have now been deleted.  If the
  438. ** garbage data came from an obsolete journal file, the checksums might
  439. ** be correct.  But by initializing the checksum to random value which
  440. ** is different for every journal, we minimize that risk.
  441. */
  442. static const unsigned char aJournalMagic[] = {
  443.   0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
  444. };
  445. /*
  446. ** The size of the header and of each page in the journal is determined
  447. ** by the following macros.
  448. */
  449. #define JOURNAL_PG_SZ(pPager)  ((pPager->pageSize) + 8)
  450. /*
  451. ** The journal header size for this pager. In the future, this could be
  452. ** set to some value read from the disk controller. The important
  453. ** characteristic is that it is the same size as a disk sector.
  454. */
  455. #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
  456. /*
  457. ** The macro MEMDB is true if we are dealing with an in-memory database.
  458. ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
  459. ** the value of MEMDB will be a constant and the compiler will optimize
  460. ** out code that would never execute.
  461. */
  462. #ifdef SQLITE_OMIT_MEMORYDB
  463. # define MEMDB 0
  464. #else
  465. # define MEMDB pPager->memDb
  466. #endif
  467. /*
  468. ** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
  469. ** reserved for working around a windows/posix incompatibility). It is
  470. ** used in the journal to signify that the remainder of the journal file 
  471. ** is devoted to storing a master journal name - there are no more pages to
  472. ** roll back. See comments for function writeMasterJournal() for details.
  473. */
  474. /* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */
  475. #define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1)
  476. /*
  477. ** The maximum legal page number is (2^31 - 1).
  478. */
  479. #define PAGER_MAX_PGNO 2147483647
  480. /*
  481. ** The pagerEnter() and pagerLeave() routines acquire and release
  482. ** a mutex on each pager.  The mutex is recursive.
  483. **
  484. ** This is a special-purpose mutex.  It only provides mutual exclusion
  485. ** between the Btree and the Memory Management sqlite3_release_memory()
  486. ** function.  It does not prevent, for example, two Btrees from accessing
  487. ** the same pager at the same time.  Other general-purpose mutexes in
  488. ** the btree layer handle that chore.
  489. */
  490. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  491.   static void pagerEnter(Pager *p){
  492.     p->iInUseDB++;
  493.     if( p->iInUseMM && p->iInUseDB==1 ){
  494.       sqlite3_mutex *mutex;
  495.       mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
  496.       p->iInUseDB = 0;
  497.       sqlite3_mutex_enter(mutex);
  498.       p->iInUseDB = 1;
  499.       sqlite3_mutex_leave(mutex);
  500.     }
  501.     assert( p->iInUseMM==0 );
  502.   }
  503.   static void pagerLeave(Pager *p){
  504.     p->iInUseDB--;
  505.     assert( p->iInUseDB>=0 );
  506.   }
  507. #else
  508. # define pagerEnter(X)
  509. # define pagerLeave(X)
  510. #endif
  511. /*
  512. ** Add page pPg to the end of the linked list managed by structure
  513. ** pList (pPg becomes the last entry in the list - the most recently 
  514. ** used). Argument pLink should point to either pPg->free or pPg->gfree,
  515. ** depending on whether pPg is being added to the pager-specific or
  516. ** global LRU list.
  517. */
  518. static void listAdd(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){
  519.   pLink->pNext = 0;
  520.   pLink->pPrev = pList->pLast;
  521. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  522.   assert(pLink==&pPg->free || pLink==&pPg->gfree);
  523.   assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);
  524. #endif
  525.   if( pList->pLast ){
  526.     int iOff = (char *)pLink - (char *)pPg;
  527.     PagerLruLink *pLastLink = (PagerLruLink *)(&((u8 *)pList->pLast)[iOff]);
  528.     pLastLink->pNext = pPg;
  529.   }else{
  530.     assert(!pList->pFirst);
  531.     pList->pFirst = pPg;
  532.   }
  533.   pList->pLast = pPg;
  534.   if( !pList->pFirstSynced && pPg->needSync==0 ){
  535.     pList->pFirstSynced = pPg;
  536.   }
  537. }
  538. /*
  539. ** Remove pPg from the list managed by the structure pointed to by pList.
  540. **
  541. ** Argument pLink should point to either pPg->free or pPg->gfree, depending 
  542. ** on whether pPg is being added to the pager-specific or global LRU list.
  543. */
  544. static void listRemove(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){
  545.   int iOff = (char *)pLink - (char *)pPg;
  546. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  547.   assert(pLink==&pPg->free || pLink==&pPg->gfree);
  548.   assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);
  549. #endif
  550.   if( pPg==pList->pFirst ){
  551.     pList->pFirst = pLink->pNext;
  552.   }
  553.   if( pPg==pList->pLast ){
  554.     pList->pLast = pLink->pPrev;
  555.   }
  556.   if( pLink->pPrev ){
  557.     PagerLruLink *pPrevLink = (PagerLruLink *)(&((u8 *)pLink->pPrev)[iOff]);
  558.     pPrevLink->pNext = pLink->pNext;
  559.   }
  560.   if( pLink->pNext ){
  561.     PagerLruLink *pNextLink = (PagerLruLink *)(&((u8 *)pLink->pNext)[iOff]);
  562.     pNextLink->pPrev = pLink->pPrev;
  563.   }
  564.   if( pPg==pList->pFirstSynced ){
  565.     PgHdr *p = pLink->pNext;
  566.     while( p && p->needSync ){
  567.       PagerLruLink *pL = (PagerLruLink *)(&((u8 *)p)[iOff]);
  568.       p = pL->pNext;
  569.     }
  570.     pList->pFirstSynced = p;
  571.   }
  572.   pLink->pNext = pLink->pPrev = 0;
  573. }
  574. /* 
  575. ** Add page pPg to the list of free pages for the pager. If 
  576. ** memory-management is enabled, also add the page to the global 
  577. ** list of free pages.
  578. */
  579. static void lruListAdd(PgHdr *pPg){
  580.   listAdd(&pPg->pPager->lru, &pPg->free, pPg);
  581. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  582.   if( !pPg->pPager->memDb ){
  583.     sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  584.     listAdd(&sqlite3LruPageList, &pPg->gfree, pPg);
  585.     sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  586.   }
  587. #endif
  588. }
  589. /* 
  590. ** Remove page pPg from the list of free pages for the associated pager.
  591. ** If memory-management is enabled, also remove pPg from the global list
  592. ** of free pages.
  593. */
  594. static void lruListRemove(PgHdr *pPg){
  595.   listRemove(&pPg->pPager->lru, &pPg->free, pPg);
  596. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  597.   if( !pPg->pPager->memDb ){
  598.     sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  599.     listRemove(&sqlite3LruPageList, &pPg->gfree, pPg);
  600.     sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  601.   }
  602. #endif
  603. }
  604. /* 
  605. ** This function is called just after the needSync flag has been cleared
  606. ** from all pages managed by pPager (usually because the journal file
  607. ** has just been synced). It updates the pPager->lru.pFirstSynced variable
  608. ** and, if memory-management is enabled, the sqlite3LruPageList.pFirstSynced
  609. ** variable also.
  610. */
  611. static void lruListSetFirstSynced(Pager *pPager){
  612.   pPager->lru.pFirstSynced = pPager->lru.pFirst;
  613. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  614.   if( !pPager->memDb ){
  615.     PgHdr *p;
  616.     sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  617.     for(p=sqlite3LruPageList.pFirst; p && p->needSync; p=p->gfree.pNext);
  618.     assert(p==pPager->lru.pFirstSynced || p==sqlite3LruPageList.pFirstSynced);
  619.     sqlite3LruPageList.pFirstSynced = p;
  620.     sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  621.   }
  622. #endif
  623. }
  624. /*
  625. ** Return true if page *pPg has already been written to the statement
  626. ** journal (or statement snapshot has been created, if *pPg is part
  627. ** of an in-memory database).
  628. */
  629. static int pageInStatement(PgHdr *pPg){
  630.   Pager *pPager = pPg->pPager;
  631.   if( MEMDB ){
  632.     return PGHDR_TO_HIST(pPg, pPager)->inStmt;
  633.   }else{
  634.     return sqlite3BitvecTest(pPager->pInStmt, pPg->pgno);
  635.   }
  636. }
  637. /*
  638. ** Change the size of the pager hash table to N.  N must be a power
  639. ** of two.
  640. */
  641. static void pager_resize_hash_table(Pager *pPager, int N){
  642.   PgHdr **aHash, *pPg;
  643.   assert( N>0 && (N&(N-1))==0 );
  644. #ifdef SQLITE_MALLOC_SOFT_LIMIT
  645.   if( N*sizeof(aHash[0])>SQLITE_MALLOC_SOFT_LIMIT ){
  646.     N = SQLITE_MALLOC_SOFT_LIMIT/sizeof(aHash[0]);
  647.   }
  648.   if( N==pPager->nHash ) return;
  649. #endif
  650.   pagerLeave(pPager);
  651.   sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, pPager->aHash!=0);
  652.   aHash = sqlite3MallocZero( sizeof(aHash[0])*N );
  653.   sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 0);
  654.   pagerEnter(pPager);
  655.   if( aHash==0 ){
  656.     /* Failure to rehash is not an error.  It is only a performance hit. */
  657.     return;
  658.   }
  659.   sqlite3_free(pPager->aHash);
  660.   pPager->nHash = N;
  661.   pPager->aHash = aHash;
  662.   for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
  663.     int h;
  664.     if( pPg->pgno==0 ){
  665.       assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );
  666.       continue;
  667.     }
  668.     h = pPg->pgno & (N-1);
  669.     pPg->pNextHash = aHash[h];
  670.     if( aHash[h] ){
  671.       aHash[h]->pPrevHash = pPg;
  672.     }
  673.     aHash[h] = pPg;
  674.     pPg->pPrevHash = 0;
  675.   }
  676. }
  677. /*
  678. ** Read a 32-bit integer from the given file descriptor.  Store the integer
  679. ** that is read in *pRes.  Return SQLITE_OK if everything worked, or an
  680. ** error code is something goes wrong.
  681. **
  682. ** All values are stored on disk as big-endian.
  683. */
  684. static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
  685.   unsigned char ac[4];
  686.   int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
  687.   if( rc==SQLITE_OK ){
  688.     *pRes = sqlite3Get4byte(ac);
  689.   }
  690.   return rc;
  691. }
  692. /*
  693. ** Write a 32-bit integer into a string buffer in big-endian byte order.
  694. */
  695. #define put32bits(A,B)  sqlite3Put4byte((u8*)A,B)
  696. /*
  697. ** Write a 32-bit integer into the given file descriptor.  Return SQLITE_OK
  698. ** on success or an error code is something goes wrong.
  699. */
  700. static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
  701.   char ac[4];
  702.   put32bits(ac, val);
  703.   return sqlite3OsWrite(fd, ac, 4, offset);
  704. }
  705. /*
  706. ** If file pFd is open, call sqlite3OsUnlock() on it.
  707. */
  708. static int osUnlock(sqlite3_file *pFd, int eLock){
  709.   if( !pFd->pMethods ){
  710.     return SQLITE_OK;
  711.   }
  712.   return sqlite3OsUnlock(pFd, eLock);
  713. }
  714. /*
  715. ** This function determines whether or not the atomic-write optimization
  716. ** can be used with this pager. The optimization can be used if:
  717. **
  718. **  (a) the value returned by OsDeviceCharacteristics() indicates that
  719. **      a database page may be written atomically, and
  720. **  (b) the value returned by OsSectorSize() is less than or equal
  721. **      to the page size.
  722. **
  723. ** If the optimization cannot be used, 0 is returned. If it can be used,
  724. ** then the value returned is the size of the journal file when it
  725. ** contains rollback data for exactly one page.
  726. */
  727. #ifdef SQLITE_ENABLE_ATOMIC_WRITE
  728. static int jrnlBufferSize(Pager *pPager){
  729.   int dc;           /* Device characteristics */
  730.   int nSector;      /* Sector size */
  731.   int nPage;        /* Page size */
  732.   sqlite3_file *fd = pPager->fd;
  733.   if( fd->pMethods ){
  734.     dc = sqlite3OsDeviceCharacteristics(fd);
  735.     nSector = sqlite3OsSectorSize(fd);
  736.     nPage = pPager->pageSize;
  737.   }
  738.   assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
  739.   assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
  740.   if( !fd->pMethods || (dc&(SQLITE_IOCAP_ATOMIC|(nPage>>8))&&nSector<=nPage) ){
  741.     return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
  742.   }
  743.   return 0;
  744. }
  745. #endif
  746. /*
  747. ** This function should be called when an error occurs within the pager
  748. ** code. The first argument is a pointer to the pager structure, the
  749. ** second the error-code about to be returned by a pager API function. 
  750. ** The value returned is a copy of the second argument to this function. 
  751. **
  752. ** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL
  753. ** the error becomes persistent. Until the persisten error is cleared,
  754. ** subsequent API calls on this Pager will immediately return the same 
  755. ** error code.
  756. **
  757. ** A persistent error indicates that the contents of the pager-cache 
  758. ** cannot be trusted. This state can be cleared by completely discarding 
  759. ** the contents of the pager-cache. If a transaction was active when
  760. ** the persistent error occured, then the rollback journal may need
  761. ** to be replayed.
  762. */
  763. static void pager_unlock(Pager *pPager);
  764. static int pager_error(Pager *pPager, int rc){
  765.   int rc2 = rc & 0xff;
  766.   assert(
  767.        pPager->errCode==SQLITE_FULL ||
  768.        pPager->errCode==SQLITE_OK ||
  769.        (pPager->errCode & 0xff)==SQLITE_IOERR
  770.   );
  771.   if(
  772.     rc2==SQLITE_FULL ||
  773.     rc2==SQLITE_IOERR ||
  774.     rc2==SQLITE_CORRUPT
  775.   ){
  776.     pPager->errCode = rc;
  777.     if( pPager->state==PAGER_UNLOCK && pPager->nRef==0 ){
  778.       /* If the pager is already unlocked, call pager_unlock() now to
  779.       ** clear the error state and ensure that the pager-cache is 
  780.       ** completely empty.
  781.       */
  782.       pager_unlock(pPager);
  783.     }
  784.   }
  785.   return rc;
  786. }
  787. /*
  788. ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
  789. ** on the cache using a hash function.  This is used for testing
  790. ** and debugging only.
  791. */
  792. #ifdef SQLITE_CHECK_PAGES
  793. /*
  794. ** Return a 32-bit hash of the page data for pPage.
  795. */
  796. static u32 pager_datahash(int nByte, unsigned char *pData){
  797.   u32 hash = 0;
  798.   int i;
  799.   for(i=0; i<nByte; i++){
  800.     hash = (hash*1039) + pData[i];
  801.   }
  802.   return hash;
  803. }
  804. static u32 pager_pagehash(PgHdr *pPage){
  805.   return pager_datahash(pPage->pPager->pageSize, 
  806.                         (unsigned char *)PGHDR_TO_DATA(pPage));
  807. }
  808. /*
  809. ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
  810. ** is defined, and NDEBUG is not defined, an assert() statement checks
  811. ** that the page is either dirty or still matches the calculated page-hash.
  812. */
  813. #define CHECK_PAGE(x) checkPage(x)
  814. static void checkPage(PgHdr *pPg){
  815.   Pager *pPager = pPg->pPager;
  816.   assert( !pPg->pageHash || pPager->errCode || MEMDB || pPg->dirty || 
  817.       pPg->pageHash==pager_pagehash(pPg) );
  818. }
  819. #else
  820. #define pager_datahash(X,Y)  0
  821. #define pager_pagehash(X)  0
  822. #define CHECK_PAGE(x)
  823. #endif
  824. /*
  825. ** When this is called the journal file for pager pPager must be open.
  826. ** The master journal file name is read from the end of the file and 
  827. ** written into memory supplied by the caller. 
  828. **
  829. ** zMaster must point to a buffer of at least nMaster bytes allocated by
  830. ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
  831. ** enough space to write the master journal name). If the master journal
  832. ** name in the journal is longer than nMaster bytes (including a
  833. ** nul-terminator), then this is handled as if no master journal name
  834. ** were present in the journal.
  835. **
  836. ** If no master journal file name is present zMaster[0] is set to 0 and
  837. ** SQLITE_OK returned.
  838. */
  839. static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, int nMaster){
  840.   int rc;
  841.   u32 len;
  842.   i64 szJ;
  843.   u32 cksum;
  844.   int i;
  845.   unsigned char aMagic[8]; /* A buffer to hold the magic header */
  846.   zMaster[0] = '';
  847.   rc = sqlite3OsFileSize(pJrnl, &szJ);
  848.   if( rc!=SQLITE_OK || szJ<16 ) return rc;
  849.   rc = read32bits(pJrnl, szJ-16, &len);
  850.   if( rc!=SQLITE_OK ) return rc;
  851.   if( len>=nMaster ){
  852.     return SQLITE_OK;
  853.   }
  854.   rc = read32bits(pJrnl, szJ-12, &cksum);
  855.   if( rc!=SQLITE_OK ) return rc;
  856.   rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8);
  857.   if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc;
  858.   rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len);
  859.   if( rc!=SQLITE_OK ){
  860.     return rc;
  861.   }
  862.   zMaster[len] = '';
  863.   /* See if the checksum matches the master journal name */
  864.   for(i=0; i<len; i++){
  865.     cksum -= zMaster[i];
  866.    }
  867.   if( cksum ){
  868.     /* If the checksum doesn't add up, then one or more of the disk sectors
  869.     ** containing the master journal filename is corrupted. This means
  870.     ** definitely roll back, so just return SQLITE_OK and report a (nul)
  871.     ** master-journal filename.
  872.     */
  873.     zMaster[0] = '';
  874.   }
  875.    
  876.   return SQLITE_OK;
  877. }
  878. /*
  879. ** Seek the journal file descriptor to the next sector boundary where a
  880. ** journal header may be read or written. Pager.journalOff is updated with
  881. ** the new seek offset.
  882. **
  883. ** i.e for a sector size of 512:
  884. **
  885. ** Input Offset              Output Offset
  886. ** ---------------------------------------
  887. ** 0                         0
  888. ** 512                       512
  889. ** 100                       512
  890. ** 2000                      2048
  891. ** 
  892. */
  893. static void seekJournalHdr(Pager *pPager){
  894.   i64 offset = 0;
  895.   i64 c = pPager->journalOff;
  896.   if( c ){
  897.     offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
  898.   }
  899.   assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
  900.   assert( offset>=c );
  901.   assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
  902.   pPager->journalOff = offset;
  903. }
  904. /*
  905. ** The journal file must be open when this routine is called. A journal
  906. ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
  907. ** current location.
  908. **
  909. ** The format for the journal header is as follows:
  910. ** - 8 bytes: Magic identifying journal format.
  911. ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
  912. ** - 4 bytes: Random number used for page hash.
  913. ** - 4 bytes: Initial database page count.
  914. ** - 4 bytes: Sector size used by the process that wrote this journal.
  915. ** - 4 bytes: Database page size.
  916. ** 
  917. ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
  918. */
  919. static int writeJournalHdr(Pager *pPager){
  920.   char zHeader[sizeof(aJournalMagic)+20];
  921.   int rc;
  922.   if( pPager->stmtHdrOff==0 ){
  923.     pPager->stmtHdrOff = pPager->journalOff;
  924.   }
  925.   seekJournalHdr(pPager);
  926.   pPager->journalHdr = pPager->journalOff;
  927.   memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
  928.   /* 
  929.   ** Write the nRec Field - the number of page records that follow this
  930.   ** journal header. Normally, zero is written to this value at this time.
  931.   ** After the records are added to the journal (and the journal synced, 
  932.   ** if in full-sync mode), the zero is overwritten with the true number
  933.   ** of records (see syncJournal()).
  934.   **
  935.   ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
  936.   ** reading the journal this value tells SQLite to assume that the
  937.   ** rest of the journal file contains valid page records. This assumption
  938.   ** is dangerous, as if a failure occured whilst writing to the journal
  939.   ** file it may contain some garbage data. There are two scenarios
  940.   ** where this risk can be ignored:
  941.   **
  942.   **   * When the pager is in no-sync mode. Corruption can follow a
  943.   **     power failure in this case anyway.
  944.   **
  945.   **   * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
  946.   **     that garbage data is never appended to the journal file.
  947.   */
  948.   assert(pPager->fd->pMethods||pPager->noSync);
  949.   if( (pPager->noSync) 
  950.    || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) 
  951.   ){
  952.     put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
  953.   }else{
  954.     put32bits(&zHeader[sizeof(aJournalMagic)], 0);
  955.   }
  956.   /* The random check-hash initialiser */ 
  957.   sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
  958.   put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
  959.   /* The initial database size */
  960.   put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize);
  961.   /* The assumed sector size for this process */
  962.   put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
  963.   if( pPager->journalHdr==0 ){
  964.     /* The page size */
  965.     put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
  966.   }
  967.   IOTRACE(("JHDR %p %lld %dn", pPager, pPager->journalHdr, sizeof(zHeader)))
  968.   rc = sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader),pPager->journalOff);
  969.   pPager->journalOff += JOURNAL_HDR_SZ(pPager);
  970.   /* The journal header has been written successfully. Seek the journal
  971.   ** file descriptor to the end of the journal header sector.
  972.   */
  973.   if( rc==SQLITE_OK ){
  974.     IOTRACE(("JTAIL %p %lldn", pPager, pPager->journalOff-1))
  975.     rc = sqlite3OsWrite(pPager->jfd, "00", 1, pPager->journalOff-1);
  976.   }
  977.   return rc;
  978. }
  979. /*
  980. ** The journal file must be open when this is called. A journal header file
  981. ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
  982. ** file. See comments above function writeJournalHdr() for a description of
  983. ** the journal header format.
  984. **
  985. ** If the header is read successfully, *nRec is set to the number of
  986. ** page records following this header and *dbSize is set to the size of the
  987. ** database before the transaction began, in pages. Also, pPager->cksumInit
  988. ** is set to the value read from the journal header. SQLITE_OK is returned
  989. ** in this case.
  990. **
  991. ** If the journal header file appears to be corrupted, SQLITE_DONE is
  992. ** returned and *nRec and *dbSize are not set.  If JOURNAL_HDR_SZ bytes
  993. ** cannot be read from the journal file an error code is returned.
  994. */
  995. static int readJournalHdr(
  996.   Pager *pPager, 
  997.   i64 journalSize,
  998.   u32 *pNRec, 
  999.   u32 *pDbSize
  1000. ){
  1001.   int rc;
  1002.   unsigned char aMagic[8]; /* A buffer to hold the magic header */
  1003.   i64 jrnlOff;
  1004.   int iPageSize;
  1005.   seekJournalHdr(pPager);
  1006.   if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
  1007.     return SQLITE_DONE;
  1008.   }
  1009.   jrnlOff = pPager->journalOff;
  1010.   rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), jrnlOff);
  1011.   if( rc ) return rc;
  1012.   jrnlOff += sizeof(aMagic);
  1013.   if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
  1014.     return SQLITE_DONE;
  1015.   }
  1016.   rc = read32bits(pPager->jfd, jrnlOff, pNRec);
  1017.   if( rc ) return rc;
  1018.   rc = read32bits(pPager->jfd, jrnlOff+4, &pPager->cksumInit);
  1019.   if( rc ) return rc;
  1020.   rc = read32bits(pPager->jfd, jrnlOff+8, pDbSize);
  1021.   if( rc ) return rc;
  1022.   rc = read32bits(pPager->jfd, jrnlOff+16, (u32 *)&iPageSize);
  1023.   if( rc==SQLITE_OK 
  1024.    && iPageSize>=512 
  1025.    && iPageSize<=SQLITE_MAX_PAGE_SIZE 
  1026.    && ((iPageSize-1)&iPageSize)==0 
  1027.   ){
  1028.     u16 pagesize = iPageSize;
  1029.     rc = sqlite3PagerSetPagesize(pPager, &pagesize);
  1030.   }
  1031.   if( rc ) return rc;
  1032.   /* Update the assumed sector-size to match the value used by 
  1033.   ** the process that created this journal. If this journal was
  1034.   ** created by a process other than this one, then this routine
  1035.   ** is being called from within pager_playback(). The local value
  1036.   ** of Pager.sectorSize is restored at the end of that routine.
  1037.   */
  1038.   rc = read32bits(pPager->jfd, jrnlOff+12, (u32 *)&pPager->sectorSize);
  1039.   if( rc ) return rc;
  1040.   pPager->journalOff += JOURNAL_HDR_SZ(pPager);
  1041.   return SQLITE_OK;
  1042. }
  1043. /*
  1044. ** Write the supplied master journal name into the journal file for pager
  1045. ** pPager at the current location. The master journal name must be the last
  1046. ** thing written to a journal file. If the pager is in full-sync mode, the
  1047. ** journal file descriptor is advanced to the next sector boundary before
  1048. ** anything is written. The format is:
  1049. **
  1050. ** + 4 bytes: PAGER_MJ_PGNO.
  1051. ** + N bytes: length of master journal name.
  1052. ** + 4 bytes: N
  1053. ** + 4 bytes: Master journal name checksum.
  1054. ** + 8 bytes: aJournalMagic[].
  1055. **
  1056. ** The master journal page checksum is the sum of the bytes in the master
  1057. ** journal name.
  1058. **
  1059. ** If zMaster is a NULL pointer (occurs for a single database transaction), 
  1060. ** this call is a no-op.
  1061. */
  1062. static int writeMasterJournal(Pager *pPager, const char *zMaster){
  1063.   int rc;
  1064.   int len; 
  1065.   int i; 
  1066.   i64 jrnlOff;
  1067.   u32 cksum = 0;
  1068.   char zBuf[sizeof(aJournalMagic)+2*4];
  1069.   if( !zMaster || pPager->setMaster) return SQLITE_OK;
  1070.   pPager->setMaster = 1;
  1071.   len = strlen(zMaster);
  1072.   for(i=0; i<len; i++){
  1073.     cksum += zMaster[i];
  1074.   }
  1075.   /* If in full-sync mode, advance to the next disk sector before writing
  1076.   ** the master journal name. This is in case the previous page written to
  1077.   ** the journal has already been synced.
  1078.   */
  1079.   if( pPager->fullSync ){
  1080.     seekJournalHdr(pPager);
  1081.   }
  1082.   jrnlOff = pPager->journalOff;
  1083.   pPager->journalOff += (len+20);
  1084.   rc = write32bits(pPager->jfd, jrnlOff, PAGER_MJ_PGNO(pPager));
  1085.   if( rc!=SQLITE_OK ) return rc;
  1086.   jrnlOff += 4;
  1087.   rc = sqlite3OsWrite(pPager->jfd, zMaster, len, jrnlOff);
  1088.   if( rc!=SQLITE_OK ) return rc;
  1089.   jrnlOff += len;
  1090.   put32bits(zBuf, len);
  1091.   put32bits(&zBuf[4], cksum);
  1092.   memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic));
  1093.   rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic), jrnlOff);
  1094.   pPager->needSync = !pPager->noSync;
  1095.   return rc;
  1096. }
  1097. /*
  1098. ** Add or remove a page from the list of all pages that are in the
  1099. ** statement journal.
  1100. **
  1101. ** The Pager keeps a separate list of pages that are currently in
  1102. ** the statement journal.  This helps the sqlite3PagerStmtCommit()
  1103. ** routine run MUCH faster for the common case where there are many
  1104. ** pages in memory but only a few are in the statement journal.
  1105. */
  1106. static void page_add_to_stmt_list(PgHdr *pPg){
  1107.   Pager *pPager = pPg->pPager;
  1108.   PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
  1109.   assert( MEMDB );
  1110.   if( !pHist->inStmt ){
  1111.     assert( pHist->pPrevStmt==0 && pHist->pNextStmt==0 );
  1112.     if( pPager->pStmt ){
  1113.       PGHDR_TO_HIST(pPager->pStmt, pPager)->pPrevStmt = pPg;
  1114.     }
  1115.     pHist->pNextStmt = pPager->pStmt;
  1116.     pPager->pStmt = pPg;
  1117.     pHist->inStmt = 1;
  1118.   }
  1119. }
  1120. /*
  1121. ** Find a page in the hash table given its page number.  Return
  1122. ** a pointer to the page or NULL if not found.
  1123. */
  1124. static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
  1125.   PgHdr *p;
  1126.   if( pPager->aHash==0 ) return 0;
  1127.   p = pPager->aHash[pgno & (pPager->nHash-1)];
  1128.   while( p && p->pgno!=pgno ){
  1129.     p = p->pNextHash;
  1130.   }
  1131.   return p;
  1132. }
  1133. /*
  1134. ** Clear the in-memory cache.  This routine
  1135. ** sets the state of the pager back to what it was when it was first
  1136. ** opened.  Any outstanding pages are invalidated and subsequent attempts
  1137. ** to access those pages will likely result in a coredump.
  1138. */
  1139. static void pager_reset(Pager *pPager){
  1140.   PgHdr *pPg, *pNext;
  1141.   if( pPager->errCode ) return;
  1142.   for(pPg=pPager->pAll; pPg; pPg=pNext){
  1143.     IOTRACE(("PGFREE %p %dn", pPager, pPg->pgno));
  1144.     PAGER_INCR(sqlite3_pager_pgfree_count);
  1145.     pNext = pPg->pNextAll;
  1146.     lruListRemove(pPg);
  1147.     sqlite3_free(pPg->pData);
  1148.     sqlite3_free(pPg);
  1149.   }
  1150.   assert(pPager->lru.pFirst==0);
  1151.   assert(pPager->lru.pFirstSynced==0);
  1152.   assert(pPager->lru.pLast==0);
  1153.   pPager->pStmt = 0;
  1154.   pPager->pAll = 0;
  1155.   pPager->pDirty = 0;
  1156.   pPager->nHash = 0;
  1157.   sqlite3_free(pPager->aHash);
  1158.   pPager->nPage = 0;
  1159.   pPager->aHash = 0;
  1160.   pPager->nRef = 0;
  1161. }
  1162. /*
  1163. ** Unlock the database file. 
  1164. **
  1165. ** If the pager is currently in error state, discard the contents of 
  1166. ** the cache and reset the Pager structure internal state. If there is
  1167. ** an open journal-file, then the next time a shared-lock is obtained
  1168. ** on the pager file (by this or any other process), it will be
  1169. ** treated as a hot-journal and rolled back.
  1170. */
  1171. static void pager_unlock(Pager *pPager){
  1172.   if( !pPager->exclusiveMode ){
  1173.     if( !MEMDB ){
  1174.       int rc = osUnlock(pPager->fd, NO_LOCK);
  1175.       if( rc ) pPager->errCode = rc;
  1176.       pPager->dbSize = -1;
  1177.       IOTRACE(("UNLOCK %pn", pPager))
  1178.       /* If Pager.errCode is set, the contents of the pager cache cannot be
  1179.       ** trusted. Now that the pager file is unlocked, the contents of the
  1180.       ** cache can be discarded and the error code safely cleared.
  1181.       */
  1182.       if( pPager->errCode ){
  1183.         if( rc==SQLITE_OK ) pPager->errCode = SQLITE_OK;
  1184.         pager_reset(pPager);
  1185.         if( pPager->stmtOpen ){
  1186.           sqlite3OsClose(pPager->stfd);
  1187.           sqlite3BitvecDestroy(pPager->pInStmt);
  1188.           pPager->pInStmt = 0;
  1189.         }
  1190.         if( pPager->journalOpen ){
  1191.           sqlite3OsClose(pPager->jfd);
  1192.           pPager->journalOpen = 0;
  1193.           sqlite3BitvecDestroy(pPager->pInJournal);
  1194.           pPager->pInJournal = 0;
  1195.         }
  1196.         pPager->stmtOpen = 0;
  1197.         pPager->stmtInUse = 0;
  1198.         pPager->journalOff = 0;
  1199.         pPager->journalStarted = 0;
  1200.         pPager->stmtAutoopen = 0;
  1201.         pPager->origDbSize = 0;
  1202.       }
  1203.     }
  1204.     if( !MEMDB || pPager->errCode==SQLITE_OK ){
  1205.       pPager->state = PAGER_UNLOCK;
  1206.       pPager->changeCountDone = 0;
  1207.     }
  1208.   }
  1209. }
  1210. /*
  1211. ** Execute a rollback if a transaction is active and unlock the 
  1212. ** database file. If the pager has already entered the error state, 
  1213. ** do not attempt the rollback.
  1214. */
  1215. static void pagerUnlockAndRollback(Pager *p){
  1216.   assert( p->state>=PAGER_RESERVED || p->journalOpen==0 );
  1217.   if( p->errCode==SQLITE_OK && p->state>=PAGER_RESERVED ){
  1218.     sqlite3PagerRollback(p);
  1219.   }
  1220.   pager_unlock(p);
  1221.   assert( p->errCode || !p->journalOpen || (p->exclusiveMode&&!p->journalOff) );
  1222.   assert( p->errCode || !p->stmtOpen || p->exclusiveMode );
  1223. }
  1224. /*
  1225. ** This routine ends a transaction.  A transaction is ended by either
  1226. ** a COMMIT or a ROLLBACK.
  1227. **
  1228. ** When this routine is called, the pager has the journal file open and
  1229. ** a RESERVED or EXCLUSIVE lock on the database.  This routine will release
  1230. ** the database lock and acquires a SHARED lock in its place if that is
  1231. ** the appropriate thing to do.  Release locks usually is appropriate,
  1232. ** unless we are in exclusive access mode or unless this is a 
  1233. ** COMMIT AND BEGIN or ROLLBACK AND BEGIN operation.
  1234. **
  1235. ** The journal file is either deleted or truncated.
  1236. **
  1237. ** TODO: Consider keeping the journal file open for temporary databases.
  1238. ** This might give a performance improvement on windows where opening
  1239. ** a file is an expensive operation.
  1240. */
  1241. static int pager_end_transaction(Pager *pPager){
  1242.   PgHdr *pPg;
  1243.   int rc = SQLITE_OK;
  1244.   int rc2 = SQLITE_OK;
  1245.   assert( !MEMDB );
  1246.   if( pPager->state<PAGER_RESERVED ){
  1247.     return SQLITE_OK;
  1248.   }
  1249.   sqlite3PagerStmtCommit(pPager);
  1250.   if( pPager->stmtOpen && !pPager->exclusiveMode ){
  1251.     sqlite3OsClose(pPager->stfd);
  1252.     pPager->stmtOpen = 0;
  1253.   }
  1254.   if( pPager->journalOpen ){
  1255.     if( pPager->exclusiveMode 
  1256.           && (rc = sqlite3OsTruncate(pPager->jfd, 0))==SQLITE_OK ){;
  1257.       pPager->journalOff = 0;
  1258.       pPager->journalStarted = 0;
  1259.     }else{
  1260.       sqlite3OsClose(pPager->jfd);
  1261.       pPager->journalOpen = 0;
  1262.       if( rc==SQLITE_OK ){
  1263.         rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
  1264.       }
  1265.     }
  1266.     sqlite3BitvecDestroy(pPager->pInJournal);
  1267.     pPager->pInJournal = 0;
  1268.     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
  1269.       pPg->inJournal = 0;
  1270.       pPg->dirty = 0;
  1271.       pPg->needSync = 0;
  1272.       pPg->alwaysRollback = 0;
  1273. #ifdef SQLITE_CHECK_PAGES
  1274.       pPg->pageHash = pager_pagehash(pPg);
  1275. #endif
  1276.     }
  1277.     pPager->pDirty = 0;
  1278.     pPager->dirtyCache = 0;
  1279.     pPager->nRec = 0;
  1280.   }else{
  1281.     assert( pPager->pInJournal==0 );
  1282.     assert( pPager->dirtyCache==0 || pPager->useJournal==0 );
  1283.   }
  1284.   if( !pPager->exclusiveMode ){
  1285.     rc2 = osUnlock(pPager->fd, SHARED_LOCK);
  1286.     pPager->state = PAGER_SHARED;
  1287.   }else if( pPager->state==PAGER_SYNCED ){
  1288.     pPager->state = PAGER_EXCLUSIVE;
  1289.   }
  1290.   pPager->origDbSize = 0;
  1291.   pPager->setMaster = 0;
  1292.   pPager->needSync = 0;
  1293.   lruListSetFirstSynced(pPager);
  1294.   pPager->dbSize = -1;
  1295.   return (rc==SQLITE_OK?rc2:rc);
  1296. }
  1297. /*
  1298. ** Compute and return a checksum for the page of data.
  1299. **
  1300. ** This is not a real checksum.  It is really just the sum of the 
  1301. ** random initial value and the page number.  We experimented with
  1302. ** a checksum of the entire data, but that was found to be too slow.
  1303. **
  1304. ** Note that the page number is stored at the beginning of data and
  1305. ** the checksum is stored at the end.  This is important.  If journal
  1306. ** corruption occurs due to a power failure, the most likely scenario
  1307. ** is that one end or the other of the record will be changed.  It is
  1308. ** much less likely that the two ends of the journal record will be
  1309. ** correct and the middle be corrupt.  Thus, this "checksum" scheme,
  1310. ** though fast and simple, catches the mostly likely kind of corruption.
  1311. **
  1312. ** FIX ME:  Consider adding every 200th (or so) byte of the data to the
  1313. ** checksum.  That way if a single page spans 3 or more disk sectors and
  1314. ** only the middle sector is corrupt, we will still have a reasonable
  1315. ** chance of failing the checksum and thus detecting the problem.
  1316. */
  1317. static u32 pager_cksum(Pager *pPager, const u8 *aData){
  1318.   u32 cksum = pPager->cksumInit;
  1319.   int i = pPager->pageSize-200;
  1320.   while( i>0 ){
  1321.     cksum += aData[i];
  1322.     i -= 200;
  1323.   }
  1324.   return cksum;
  1325. }
  1326. /* Forward declaration */
  1327. static void makeClean(PgHdr*);
  1328. /*
  1329. ** Read a single page from the journal file opened on file descriptor
  1330. ** jfd.  Playback this one page.
  1331. **
  1332. ** If useCksum==0 it means this journal does not use checksums.  Checksums
  1333. ** are not used in statement journals because statement journals do not
  1334. ** need to survive power failures.
  1335. */
  1336. static int pager_playback_one_page(
  1337.   Pager *pPager, 
  1338.   sqlite3_file *jfd,
  1339.   i64 offset,
  1340.   int useCksum
  1341. ){
  1342.   int rc;
  1343.   PgHdr *pPg;                   /* An existing page in the cache */
  1344.   Pgno pgno;                    /* The page number of a page in journal */
  1345.   u32 cksum;                    /* Checksum used for sanity checking */
  1346.   u8 *aData = (u8 *)pPager->pTmpSpace;   /* Temp storage for a page */
  1347.   /* useCksum should be true for the main journal and false for
  1348.   ** statement journals.  Verify that this is always the case
  1349.   */
  1350.   assert( jfd == (useCksum ? pPager->jfd : pPager->stfd) );
  1351.   assert( aData );
  1352.   rc = read32bits(jfd, offset, &pgno);
  1353.   if( rc!=SQLITE_OK ) return rc;
  1354.   rc = sqlite3OsRead(jfd, aData, pPager->pageSize, offset+4);
  1355.   if( rc!=SQLITE_OK ) return rc;
  1356.   pPager->journalOff += pPager->pageSize + 4;
  1357.   /* Sanity checking on the page.  This is more important that I originally
  1358.   ** thought.  If a power failure occurs while the journal is being written,
  1359.   ** it could cause invalid data to be written into the journal.  We need to
  1360.   ** detect this invalid data (with high probability) and ignore it.
  1361.   */
  1362.   if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
  1363.     return SQLITE_DONE;
  1364.   }
  1365.   if( pgno>(unsigned)pPager->dbSize ){
  1366.     return SQLITE_OK;
  1367.   }
  1368.   if( useCksum ){
  1369.     rc = read32bits(jfd, offset+pPager->pageSize+4, &cksum);
  1370.     if( rc ) return rc;
  1371.     pPager->journalOff += 4;
  1372.     if( pager_cksum(pPager, aData)!=cksum ){
  1373.       return SQLITE_DONE;
  1374.     }
  1375.   }
  1376.   assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );
  1377.   /* If the pager is in RESERVED state, then there must be a copy of this
  1378.   ** page in the pager cache. In this case just update the pager cache,
  1379.   ** not the database file. The page is left marked dirty in this case.
  1380.   **
  1381.   ** An exception to the above rule: If the database is in no-sync mode
  1382.   ** and a page is moved during an incremental vacuum then the page may
  1383.   ** not be in the pager cache. Later: if a malloc() or IO error occurs
  1384.   ** during a Movepage() call, then the page may not be in the cache
  1385.   ** either. So the condition described in the above paragraph is not
  1386.   ** assert()able.
  1387.   **
  1388.   ** If in EXCLUSIVE state, then we update the pager cache if it exists
  1389.   ** and the main file. The page is then marked not dirty.
  1390.   **
  1391.   ** Ticket #1171:  The statement journal might contain page content that is
  1392.   ** different from the page content at the start of the transaction.
  1393.   ** This occurs when a page is changed prior to the start of a statement
  1394.   ** then changed again within the statement.  When rolling back such a
  1395.   ** statement we must not write to the original database unless we know
  1396.   ** for certain that original page contents are synced into the main rollback
  1397.   ** journal.  Otherwise, a power loss might leave modified data in the
  1398.   ** database file without an entry in the rollback journal that can
  1399.   ** restore the database to its original form.  Two conditions must be
  1400.   ** met before writing to the database files. (1) the database must be
  1401.   ** locked.  (2) we know that the original page content is fully synced
  1402.   ** in the main journal either because the page is not in cache or else
  1403.   ** the page is marked as needSync==0.
  1404.   **
  1405.   ** 2008-04-14:  When attempting to vacuum a corrupt database file, it
  1406.   ** is possible to fail a statement on a database that does not yet exist.
  1407.   ** Do not attempt to write if database file has never been opened.
  1408.   */
  1409.   pPg = pager_lookup(pPager, pgno);
  1410.   PAGERTRACE4("PLAYBACK %d page %d hash(%08x)n",
  1411.                PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData));
  1412.   if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0)
  1413.         && pPager->fd->pMethods ){
  1414.     i64 offset = (pgno-1)*(i64)pPager->pageSize;
  1415.     rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, offset);
  1416.     if( pPg ){
  1417.       makeClean(pPg);
  1418.     }
  1419.   }
  1420.   if( pPg ){
  1421.     /* No page should ever be explicitly rolled back that is in use, except
  1422.     ** for page 1 which is held in use in order to keep the lock on the
  1423.     ** database active. However such a page may be rolled back as a result
  1424.     ** of an internal error resulting in an automatic call to
  1425.     ** sqlite3PagerRollback().
  1426.     */
  1427.     void *pData;
  1428.     /* assert( pPg->nRef==0 || pPg->pgno==1 ); */
  1429.     pData = PGHDR_TO_DATA(pPg);
  1430.     memcpy(pData, aData, pPager->pageSize);
  1431.     if( pPager->xReiniter ){
  1432.       pPager->xReiniter(pPg, pPager->pageSize);
  1433.     }
  1434. #ifdef SQLITE_CHECK_PAGES
  1435.     pPg->pageHash = pager_pagehash(pPg);
  1436. #endif
  1437.     /* If this was page 1, then restore the value of Pager.dbFileVers.
  1438.     ** Do this before any decoding. */
  1439.     if( pgno==1 ){
  1440.       memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
  1441.     }
  1442.     /* Decode the page just read from disk */
  1443.     CODEC1(pPager, pData, pPg->pgno, 3);
  1444.   }
  1445.   return rc;
  1446. }
  1447. /*
  1448. ** Parameter zMaster is the name of a master journal file. A single journal
  1449. ** file that referred to the master journal file has just been rolled back.
  1450. ** This routine checks if it is possible to delete the master journal file,
  1451. ** and does so if it is.
  1452. **
  1453. ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not 
  1454. ** available for use within this function.
  1455. **
  1456. **
  1457. ** The master journal file contains the names of all child journals.
  1458. ** To tell if a master journal can be deleted, check to each of the
  1459. ** children.  If all children are either missing or do not refer to
  1460. ** a different master journal, then this master journal can be deleted.
  1461. */
  1462. static int pager_delmaster(Pager *pPager, const char *zMaster){
  1463.   sqlite3_vfs *pVfs = pPager->pVfs;
  1464.   int rc;
  1465.   int master_open = 0;
  1466.   sqlite3_file *pMaster;
  1467.   sqlite3_file *pJournal;
  1468.   char *zMasterJournal = 0; /* Contents of master journal file */
  1469.   i64 nMasterJournal;       /* Size of master journal file */
  1470.   /* Open the master journal file exclusively in case some other process
  1471.   ** is running this routine also. Not that it makes too much difference.
  1472.   */
  1473.   pMaster = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile * 2);
  1474.   pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
  1475.   if( !pMaster ){
  1476.     rc = SQLITE_NOMEM;
  1477.   }else{
  1478.     int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
  1479.     rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
  1480.   }
  1481.   if( rc!=SQLITE_OK ) goto delmaster_out;
  1482.   master_open = 1;
  1483.   rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
  1484.   if( rc!=SQLITE_OK ) goto delmaster_out;
  1485.   if( nMasterJournal>0 ){
  1486.     char *zJournal;
  1487.     char *zMasterPtr = 0;
  1488.     int nMasterPtr = pPager->pVfs->mxPathname+1;
  1489.     /* Load the entire master journal file into space obtained from
  1490.     ** sqlite3_malloc() and pointed to by zMasterJournal. 
  1491.     */
  1492.     zMasterJournal = (char *)sqlite3_malloc(nMasterJournal + nMasterPtr);
  1493.     if( !zMasterJournal ){
  1494.       rc = SQLITE_NOMEM;
  1495.       goto delmaster_out;
  1496.     }
  1497.     zMasterPtr = &zMasterJournal[nMasterJournal];
  1498.     rc = sqlite3OsRead(pMaster, zMasterJournal, nMasterJournal, 0);
  1499.     if( rc!=SQLITE_OK ) goto delmaster_out;
  1500.     zJournal = zMasterJournal;
  1501.     while( (zJournal-zMasterJournal)<nMasterJournal ){
  1502.       rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS);
  1503.       if( rc!=0 && rc!=1 ){
  1504.         rc = SQLITE_IOERR_NOMEM;
  1505.         goto delmaster_out;
  1506.       }
  1507.       if( rc==1 ){
  1508.         /* One of the journals pointed to by the master journal exists.
  1509.         ** Open it and check if it points at the master journal. If
  1510.         ** so, return without deleting the master journal file.
  1511.         */
  1512.         int c;
  1513.         int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
  1514.         rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
  1515.         if( rc!=SQLITE_OK ){
  1516.           goto delmaster_out;
  1517.         }
  1518.         rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
  1519.         sqlite3OsClose(pJournal);
  1520.         if( rc!=SQLITE_OK ){
  1521.           goto delmaster_out;
  1522.         }
  1523.         c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
  1524.         if( c ){
  1525.           /* We have a match. Do not delete the master journal file. */
  1526.           goto delmaster_out;
  1527.         }
  1528.       }
  1529.       zJournal += (strlen(zJournal)+1);
  1530.     }
  1531.   }
  1532.   
  1533.   rc = sqlite3OsDelete(pVfs, zMaster, 0);
  1534. delmaster_out:
  1535.   if( zMasterJournal ){
  1536.     sqlite3_free(zMasterJournal);
  1537.   }  
  1538.   if( master_open ){
  1539.     sqlite3OsClose(pMaster);
  1540.   }
  1541.   sqlite3_free(pMaster);
  1542.   return rc;
  1543. }
  1544. static void pager_truncate_cache(Pager *pPager);
  1545. /*
  1546. ** Truncate the main file of the given pager to the number of pages
  1547. ** indicated. Also truncate the cached representation of the file.
  1548. **
  1549. ** Might might be the case that the file on disk is smaller than nPage.
  1550. ** This can happen, for example, if we are in the middle of a transaction
  1551. ** which has extended the file size and the new pages are still all held
  1552. ** in cache, then an INSERT or UPDATE does a statement rollback.  Some
  1553. ** operating system implementations can get confused if you try to
  1554. ** truncate a file to some size that is larger than it currently is,
  1555. ** so detect this case and do not do the truncation.
  1556. */
  1557. static int pager_truncate(Pager *pPager, int nPage){
  1558.   int rc = SQLITE_OK;
  1559.   if( pPager->state>=PAGER_EXCLUSIVE && pPager->fd->pMethods ){
  1560.     i64 currentSize, newSize;
  1561.     rc = sqlite3OsFileSize(pPager->fd, &currentSize);
  1562.     newSize = pPager->pageSize*(i64)nPage;
  1563.     if( rc==SQLITE_OK && currentSize>newSize ){
  1564.       rc = sqlite3OsTruncate(pPager->fd, newSize);
  1565.     }
  1566.   }
  1567.   if( rc==SQLITE_OK ){
  1568.     pPager->dbSize = nPage;
  1569.     pager_truncate_cache(pPager);
  1570.   }
  1571.   return rc;
  1572. }
  1573. /*
  1574. ** Set the sectorSize for the given pager.
  1575. **
  1576. ** The sector size is at least as big as the sector size reported
  1577. ** by sqlite3OsSectorSize().  The minimum sector size is 512.
  1578. */
  1579. static void setSectorSize(Pager *pPager){
  1580.   assert(pPager->fd->pMethods||pPager->tempFile);
  1581.   if( !pPager->tempFile ){
  1582.     /* Sector size doesn't matter for temporary files. Also, the file
  1583.     ** may not have been opened yet, in whcih case the OsSectorSize()
  1584.     ** call will segfault.
  1585.     */
  1586.     pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
  1587.   }
  1588.   if( pPager->sectorSize<512 ){
  1589.     pPager->sectorSize = 512;
  1590.   }
  1591. }
  1592. /*
  1593. ** Playback the journal and thus restore the database file to
  1594. ** the state it was in before we started making changes.  
  1595. **
  1596. ** The journal file format is as follows: 
  1597. **
  1598. **  (1)  8 byte prefix.  A copy of aJournalMagic[].
  1599. **  (2)  4 byte big-endian integer which is the number of valid page records
  1600. **       in the journal.  If this value is 0xffffffff, then compute the
  1601. **       number of page records from the journal size.
  1602. **  (3)  4 byte big-endian integer which is the initial value for the 
  1603. **       sanity checksum.
  1604. **  (4)  4 byte integer which is the number of pages to truncate the
  1605. **       database to during a rollback.
  1606. **  (5)  4 byte big-endian integer which is the sector size.  The header
  1607. **       is this many bytes in size.
  1608. **  (6)  4 byte big-endian integer which is the page case.
  1609. **  (7)  4 byte integer which is the number of bytes in the master journal
  1610. **       name.  The value may be zero (indicate that there is no master
  1611. **       journal.)
  1612. **  (8)  N bytes of the master journal name.  The name will be nul-terminated
  1613. **       and might be shorter than the value read from (5).  If the first byte
  1614. **       of the name is 00 then there is no master journal.  The master
  1615. **       journal name is stored in UTF-8.
  1616. **  (9)  Zero or more pages instances, each as follows:
  1617. **        +  4 byte page number.
  1618. **        +  pPager->pageSize bytes of data.
  1619. **        +  4 byte checksum
  1620. **
  1621. ** When we speak of the journal header, we mean the first 8 items above.
  1622. ** Each entry in the journal is an instance of the 9th item.
  1623. **
  1624. ** Call the value from the second bullet "nRec".  nRec is the number of
  1625. ** valid page entries in the journal.  In most cases, you can compute the
  1626. ** value of nRec from the size of the journal file.  But if a power
  1627. ** failure occurred while the journal was being written, it could be the
  1628. ** case that the size of the journal file had already been increased but
  1629. ** the extra entries had not yet made it safely to disk.  In such a case,
  1630. ** the value of nRec computed from the file size would be too large.  For
  1631. ** that reason, we always use the nRec value in the header.
  1632. **
  1633. ** If the nRec value is 0xffffffff it means that nRec should be computed
  1634. ** from the file size.  This value is used when the user selects the
  1635. ** no-sync option for the journal.  A power failure could lead to corruption
  1636. ** in this case.  But for things like temporary table (which will be
  1637. ** deleted when the power is restored) we don't care.  
  1638. **
  1639. ** If the file opened as the journal file is not a well-formed
  1640. ** journal file then all pages up to the first corrupted page are rolled
  1641. ** back (or no pages if the journal header is corrupted). The journal file
  1642. ** is then deleted and SQLITE_OK returned, just as if no corruption had
  1643. ** been encountered.
  1644. **
  1645. ** If an I/O or malloc() error occurs, the journal-file is not deleted
  1646. ** and an error code is returned.
  1647. */
  1648. static int pager_playback(Pager *pPager, int isHot){
  1649.   sqlite3_vfs *pVfs = pPager->pVfs;
  1650.   i64 szJ;                 /* Size of the journal file in bytes */
  1651.   u32 nRec;                /* Number of Records in the journal */
  1652.   int i;                   /* Loop counter */
  1653.   Pgno mxPg = 0;           /* Size of the original file in pages */
  1654.   int rc;                  /* Result code of a subroutine */
  1655.   int res = 0;             /* Value returned by sqlite3OsAccess() */
  1656.   char *zMaster = 0;       /* Name of master journal file if any */
  1657.   /* Figure out how many records are in the journal.  Abort early if
  1658.   ** the journal is empty.
  1659.   */
  1660.   assert( pPager->journalOpen );
  1661.   rc = sqlite3OsFileSize(pPager->jfd, &szJ);
  1662.   if( rc!=SQLITE_OK || szJ==0 ){
  1663.     goto end_playback;
  1664.   }
  1665.   /* Read the master journal name from the journal, if it is present.
  1666.   ** If a master journal file name is specified, but the file is not
  1667.   ** present on disk, then the journal is not hot and does not need to be
  1668.   ** played back.
  1669.   */
  1670.   zMaster = pPager->pTmpSpace;
  1671.   rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
  1672.   if( rc!=SQLITE_OK || (zMaster[0] 
  1673.    && (res=sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS))==0 ) 
  1674.   ){
  1675.     zMaster = 0;
  1676.     goto end_playback;
  1677.   }
  1678.   zMaster = 0;
  1679.   if( res<0 ){
  1680.     rc = SQLITE_IOERR_NOMEM;
  1681.     goto end_playback;
  1682.   }
  1683.   pPager->journalOff = 0;
  1684.   /* This loop terminates either when the readJournalHdr() call returns
  1685.   ** SQLITE_DONE or an IO error occurs. */
  1686.   while( 1 ){
  1687.     /* Read the next journal header from the journal file.  If there are
  1688.     ** not enough bytes left in the journal file for a complete header, or
  1689.     ** it is corrupted, then a process must of failed while writing it.
  1690.     ** This indicates nothing more needs to be rolled back.
  1691.     */
  1692.     rc = readJournalHdr(pPager, szJ, &nRec, &mxPg);
  1693.     if( rc!=SQLITE_OK ){ 
  1694.       if( rc==SQLITE_DONE ){
  1695.         rc = SQLITE_OK;
  1696.       }
  1697.       goto end_playback;
  1698.     }
  1699.     /* If nRec is 0xffffffff, then this journal was created by a process
  1700.     ** working in no-sync mode. This means that the rest of the journal
  1701.     ** file consists of pages, there are no more journal headers. Compute
  1702.     ** the value of nRec based on this assumption.
  1703.     */
  1704.     if( nRec==0xffffffff ){
  1705.       assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
  1706.       nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager);
  1707.     }
  1708.     /* If nRec is 0 and this rollback is of a transaction created by this
  1709.     ** process and if this is the final header in the journal, then it means
  1710.     ** that this part of the journal was being filled but has not yet been
  1711.     ** synced to disk.  Compute the number of pages based on the remaining
  1712.     ** size of the file.
  1713.     **
  1714.     ** The third term of the test was added to fix ticket #2565.
  1715.     */
  1716.     if( nRec==0 && !isHot &&
  1717.         pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
  1718.       nRec = (szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager);
  1719.     }
  1720.     /* If this is the first header read from the journal, truncate the
  1721.     ** database file back to its original size.
  1722.     */
  1723.     if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
  1724.       rc = pager_truncate(pPager, mxPg);
  1725.       if( rc!=SQLITE_OK ){
  1726.         goto end_playback;
  1727.       }
  1728.     }
  1729.     /* Copy original pages out of the journal and back into the database file.
  1730.     */
  1731.     for(i=0; i<nRec; i++){
  1732.       rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
  1733.       if( rc!=SQLITE_OK ){
  1734.         if( rc==SQLITE_DONE ){
  1735.           rc = SQLITE_OK;
  1736.           pPager->journalOff = szJ;
  1737.           break;
  1738.         }else{
  1739.           goto end_playback;
  1740.         }
  1741.       }
  1742.     }
  1743.   }
  1744.   /*NOTREACHED*/
  1745.   assert( 0 );
  1746. end_playback:
  1747.   if( rc==SQLITE_OK ){
  1748.     zMaster = pPager->pTmpSpace;
  1749.     rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
  1750.   }
  1751.   if( rc==SQLITE_OK ){
  1752.     rc = pager_end_transaction(pPager);
  1753.   }
  1754.   if( rc==SQLITE_OK && zMaster[0] ){
  1755.     /* If there was a master journal and this routine will return success,
  1756.     ** see if it is possible to delete the master journal.
  1757.     */
  1758.     rc = pager_delmaster(pPager, zMaster);
  1759.   }
  1760.   /* The Pager.sectorSize variable may have been updated while rolling
  1761.   ** back a journal created by a process with a different sector size
  1762.   ** value. Reset it to the correct value for this process.
  1763.   */
  1764.   setSectorSize(pPager);
  1765.   return rc;
  1766. }
  1767. /*
  1768. ** Playback the statement journal.
  1769. **
  1770. ** This is similar to playing back the transaction journal but with
  1771. ** a few extra twists.
  1772. **
  1773. **    (1)  The number of pages in the database file at the start of
  1774. **         the statement is stored in pPager->stmtSize, not in the
  1775. **         journal file itself.
  1776. **
  1777. **    (2)  In addition to playing back the statement journal, also
  1778. **         playback all pages of the transaction journal beginning
  1779. **         at offset pPager->stmtJSize.
  1780. */
  1781. static int pager_stmt_playback(Pager *pPager){
  1782.   i64 szJ;                 /* Size of the full journal */
  1783.   i64 hdrOff;
  1784.   int nRec;                /* Number of Records */
  1785.   int i;                   /* Loop counter */
  1786.   int rc;
  1787.   szJ = pPager->journalOff;
  1788. #ifndef NDEBUG 
  1789.   {
  1790.     i64 os_szJ;
  1791.     rc = sqlite3OsFileSize(pPager->jfd, &os_szJ);
  1792.     if( rc!=SQLITE_OK ) return rc;
  1793.     assert( szJ==os_szJ );
  1794.   }
  1795. #endif
  1796.   /* Set hdrOff to be the offset just after the end of the last journal
  1797.   ** page written before the first journal-header for this statement
  1798.   ** transaction was written, or the end of the file if no journal
  1799.   ** header was written.
  1800.   */
  1801.   hdrOff = pPager->stmtHdrOff;
  1802.   assert( pPager->fullSync || !hdrOff );
  1803.   if( !hdrOff ){
  1804.     hdrOff = szJ;
  1805.   }
  1806.   
  1807.   /* Truncate the database back to its original size.
  1808.   */
  1809.   rc = pager_truncate(pPager, pPager->stmtSize);
  1810.   assert( pPager->state>=PAGER_SHARED );
  1811.   /* Figure out how many records are in the statement journal.
  1812.   */
  1813.   assert( pPager->stmtInUse && pPager->journalOpen );
  1814.   nRec = pPager->stmtNRec;
  1815.   
  1816.   /* Copy original pages out of the statement journal and back into the
  1817.   ** database file.  Note that the statement journal omits checksums from
  1818.   ** each record since power-failure recovery is not important to statement
  1819.   ** journals.
  1820.   */
  1821.   for(i=0; i<nRec; i++){
  1822.     i64 offset = i*(4+pPager->pageSize);
  1823.     rc = pager_playback_one_page(pPager, pPager->stfd, offset, 0);
  1824.     assert( rc!=SQLITE_DONE );
  1825.     if( rc!=SQLITE_OK ) goto end_stmt_playback;
  1826.   }
  1827.   /* Now roll some pages back from the transaction journal. Pager.stmtJSize
  1828.   ** was the size of the journal file when this statement was started, so
  1829.   ** everything after that needs to be rolled back, either into the
  1830.   ** database, the memory cache, or both.
  1831.   **
  1832.   ** If it is not zero, then Pager.stmtHdrOff is the offset to the start
  1833.   ** of the first journal header written during this statement transaction.
  1834.   */
  1835.   pPager->journalOff = pPager->stmtJSize;
  1836.   pPager->cksumInit = pPager->stmtCksum;
  1837.   while( pPager->journalOff < hdrOff ){
  1838.     rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
  1839.     assert( rc!=SQLITE_DONE );
  1840.     if( rc!=SQLITE_OK ) goto end_stmt_playback;
  1841.   }
  1842.   while( pPager->journalOff < szJ ){
  1843.     u32 nJRec;         /* Number of Journal Records */
  1844.     u32 dummy;
  1845.     rc = readJournalHdr(pPager, szJ, &nJRec, &dummy);
  1846.     if( rc!=SQLITE_OK ){
  1847.       assert( rc!=SQLITE_DONE );
  1848.       goto end_stmt_playback;
  1849.     }
  1850.     if( nJRec==0 ){
  1851.       nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8);
  1852.     }
  1853.     for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){
  1854.       rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
  1855.       assert( rc!=SQLITE_DONE );
  1856.       if( rc!=SQLITE_OK ) goto end_stmt_playback;
  1857.     }
  1858.   }
  1859.   pPager->journalOff = szJ;
  1860.   
  1861. end_stmt_playback:
  1862.   if( rc==SQLITE_OK) {
  1863.     pPager->journalOff = szJ;
  1864.     /* pager_reload_cache(pPager); */
  1865.   }
  1866.   return rc;
  1867. }
  1868. /*
  1869. ** Change the maximum number of in-memory pages that are allowed.
  1870. */
  1871. void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
  1872.   if( mxPage>10 ){
  1873.     pPager->mxPage = mxPage;
  1874.   }else{
  1875.     pPager->mxPage = 10;
  1876.   }
  1877. }
  1878. /*
  1879. ** Adjust the robustness of the database to damage due to OS crashes
  1880. ** or power failures by changing the number of syncs()s when writing
  1881. ** the rollback journal.  There are three levels:
  1882. **
  1883. **    OFF       sqlite3OsSync() is never called.  This is the default
  1884. **              for temporary and transient files.
  1885. **
  1886. **    NORMAL    The journal is synced once before writes begin on the
  1887. **              database.  This is normally adequate protection, but
  1888. **              it is theoretically possible, though very unlikely,
  1889. **              that an inopertune power failure could leave the journal
  1890. **              in a state which would cause damage to the database
  1891. **              when it is rolled back.
  1892. **
  1893. **    FULL      The journal is synced twice before writes begin on the
  1894. **              database (with some additional information - the nRec field
  1895. **              of the journal header - being written in between the two
  1896. **              syncs).  If we assume that writing a
  1897. **              single disk sector is atomic, then this mode provides
  1898. **              assurance that the journal will not be corrupted to the
  1899. **              point of causing damage to the database during rollback.
  1900. **
  1901. ** Numeric values associated with these states are OFF==1, NORMAL=2,
  1902. ** and FULL=3.
  1903. */
  1904. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  1905. void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int full_fsync){
  1906.   pPager->noSync =  level==1 || pPager->tempFile;
  1907.   pPager->fullSync = level==3 && !pPager->tempFile;
  1908.   pPager->sync_flags = (full_fsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);
  1909.   if( pPager->noSync ) pPager->needSync = 0;
  1910. }
  1911. #endif
  1912. /*
  1913. ** The following global variable is incremented whenever the library
  1914. ** attempts to open a temporary file.  This information is used for
  1915. ** testing and analysis only.  
  1916. */
  1917. #ifdef SQLITE_TEST
  1918. int sqlite3_opentemp_count = 0;
  1919. #endif
  1920. /*
  1921. ** Open a temporary file. 
  1922. **
  1923. ** Write the file descriptor into *fd.  Return SQLITE_OK on success or some
  1924. ** other error code if we fail. The OS will automatically delete the temporary
  1925. ** file when it is closed.
  1926. */
  1927. static int sqlite3PagerOpentemp(
  1928.   sqlite3_vfs *pVfs,    /* The virtual file system layer */
  1929.   sqlite3_file *pFile,  /* Write the file descriptor here */
  1930.   char *zFilename,      /* Name of the file.  Might be NULL */
  1931.   int vfsFlags          /* Flags passed through to the VFS */
  1932. ){
  1933.   int rc;
  1934.   assert( zFilename!=0 );
  1935. #ifdef SQLITE_TEST
  1936.   sqlite3_opentemp_count++;  /* Used for testing and analysis only */
  1937. #endif
  1938.   vfsFlags |=  SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
  1939.             SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
  1940.   rc = sqlite3OsOpen(pVfs, zFilename, pFile, vfsFlags, 0);
  1941.   assert( rc!=SQLITE_OK || pFile->pMethods );
  1942.   return rc;
  1943. }
  1944. /*
  1945. ** Create a new page cache and put a pointer to the page cache in *ppPager.
  1946. ** The file to be cached need not exist.  The file is not locked until
  1947. ** the first call to sqlite3PagerGet() and is only held open until the
  1948. ** last page is released using sqlite3PagerUnref().
  1949. **
  1950. ** If zFilename is NULL then a randomly-named temporary file is created
  1951. ** and used as the file to be cached.  The file will be deleted
  1952. ** automatically when it is closed.
  1953. **
  1954. ** If zFilename is ":memory:" then all information is held in cache.
  1955. ** It is never written to disk.  This can be used to implement an
  1956. ** in-memory database.
  1957. */
  1958. int sqlite3PagerOpen(
  1959.   sqlite3_vfs *pVfs,       /* The virtual file system to use */
  1960.   Pager **ppPager,         /* Return the Pager structure here */
  1961.   const char *zFilename,   /* Name of the database file to open */
  1962.   int nExtra,              /* Extra bytes append to each in-memory page */
  1963.   int flags,               /* flags controlling this file */
  1964.   int vfsFlags             /* flags passed through to sqlite3_vfs.xOpen() */
  1965. ){
  1966.   u8 *pPtr;
  1967.   Pager *pPager = 0;
  1968.   int rc = SQLITE_OK;
  1969.   int i;
  1970.   int tempFile = 0;
  1971.   int memDb = 0;
  1972.   int readOnly = 0;
  1973.   int useJournal = (flags & PAGER_OMIT_JOURNAL)==0;
  1974.   int noReadlock = (flags & PAGER_NO_READLOCK)!=0;
  1975.   int journalFileSize = sqlite3JournalSize(pVfs);
  1976.   int nDefaultPage = SQLITE_DEFAULT_PAGE_SIZE;
  1977.   char *zPathname;
  1978.   int nPathname;
  1979.   char *zStmtJrnl;
  1980.   int nStmtJrnl;
  1981.   /* The default return is a NULL pointer */
  1982.   *ppPager = 0;
  1983.   /* Compute the full pathname */
  1984.   nPathname = pVfs->mxPathname+1;
  1985.   zPathname = sqlite3_malloc(nPathname*2);
  1986.   if( zPathname==0 ){
  1987.     return SQLITE_NOMEM;
  1988.   }
  1989.   if( zFilename && zFilename[0] ){
  1990. #ifndef SQLITE_OMIT_MEMORYDB
  1991.     if( strcmp(zFilename,":memory:")==0 ){
  1992.       memDb = 1;
  1993.       zPathname[0] = 0;
  1994.     }else
  1995. #endif
  1996.     {
  1997.       rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
  1998.     }
  1999.   }else{
  2000.     rc = sqlite3OsGetTempname(pVfs, nPathname, zPathname);
  2001.   }
  2002.   if( rc!=SQLITE_OK ){
  2003.     sqlite3_free(zPathname);
  2004.     return rc;
  2005.   }
  2006.   nPathname = strlen(zPathname);
  2007.   /* Put the statement journal in temporary disk space since this is
  2008.   ** sometimes RAM disk or other optimized storage.  Unlikely the main
  2009.   ** main journal file, the statement journal does not need to be 
  2010.   ** colocated with the database nor does it need to be persistent.
  2011.   */
  2012.   zStmtJrnl = &zPathname[nPathname+1];
  2013.   rc = sqlite3OsGetTempname(pVfs, pVfs->mxPathname+1, zStmtJrnl);
  2014.   if( rc!=SQLITE_OK ){
  2015.     sqlite3_free(zPathname);
  2016.     return rc;
  2017.   }
  2018.   nStmtJrnl = strlen(zStmtJrnl);
  2019.   /* Allocate memory for the pager structure */
  2020.   pPager = sqlite3MallocZero(
  2021.     sizeof(*pPager) +           /* Pager structure */
  2022.     journalFileSize +           /* The journal file structure */ 
  2023.     pVfs->szOsFile * 3 +        /* The main db and two journal files */ 
  2024.     3*nPathname + 40 +          /* zFilename, zDirectory, zJournal */
  2025.     nStmtJrnl                   /* zStmtJrnl */
  2026.   );
  2027.   if( !pPager ){
  2028.     sqlite3_free(zPathname);
  2029.     return SQLITE_NOMEM;
  2030.   }
  2031.   pPtr = (u8 *)&pPager[1];
  2032.   pPager->vfsFlags = vfsFlags;
  2033.   pPager->fd = (sqlite3_file*)&pPtr[pVfs->szOsFile*0];
  2034.   pPager->stfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*1];
  2035.   pPager->jfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*2];
  2036.   pPager->zFilename = (char*)&pPtr[pVfs->szOsFile*2+journalFileSize];
  2037.   pPager->zDirectory = &pPager->zFilename[nPathname+1];
  2038.   pPager->zJournal = &pPager->zDirectory[nPathname+1];
  2039.   pPager->zStmtJrnl = &pPager->zJournal[nPathname+10];
  2040.   pPager->pVfs = pVfs;
  2041.   memcpy(pPager->zFilename, zPathname, nPathname+1);
  2042.   memcpy(pPager->zStmtJrnl, zStmtJrnl, nStmtJrnl+1);
  2043.   sqlite3_free(zPathname);
  2044.   /* Open the pager file.
  2045.   */
  2046.   if( zFilename && zFilename[0] && !memDb ){
  2047.     if( nPathname>(pVfs->mxPathname - sizeof("-journal")) ){
  2048.       rc = SQLITE_CANTOPEN;
  2049.     }else{
  2050.       int fout = 0;
  2051.       rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd,
  2052.                          pPager->vfsFlags, &fout);
  2053.       readOnly = (fout&SQLITE_OPEN_READONLY);
  2054.       /* If the file was successfully opened for read/write access,
  2055.       ** choose a default page size in case we have to create the
  2056.       ** database file. The default page size is the maximum of:
  2057.       **
  2058.       **    + SQLITE_DEFAULT_PAGE_SIZE,
  2059.       **    + The value returned by sqlite3OsSectorSize()
  2060.       **    + The largest page size that can be written atomically.
  2061.       */
  2062.       if( rc==SQLITE_OK && !readOnly ){
  2063.         int iSectorSize = sqlite3OsSectorSize(pPager->fd);
  2064.         if( nDefaultPage<iSectorSize ){
  2065.           nDefaultPage = iSectorSize;
  2066.         }
  2067. #ifdef SQLITE_ENABLE_ATOMIC_WRITE
  2068.         {
  2069.           int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
  2070.           int ii;
  2071.           assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
  2072.           assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
  2073.           assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
  2074.           for(ii=nDefaultPage; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
  2075.             if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ) nDefaultPage = ii;
  2076.           }
  2077.         }
  2078. #endif
  2079.         if( nDefaultPage>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
  2080.           nDefaultPage = SQLITE_MAX_DEFAULT_PAGE_SIZE;
  2081.         }
  2082.       }
  2083.     }
  2084.   }else if( !memDb ){
  2085.     /* If a temporary file is requested, it is not opened immediately.
  2086.     ** In this case we accept the default page size and delay actually
  2087.     ** opening the file until the first call to OsWrite().
  2088.     */ 
  2089.     tempFile = 1;
  2090.     pPager->state = PAGER_EXCLUSIVE;
  2091.   }
  2092.   if( pPager && rc==SQLITE_OK ){
  2093.     pPager->pTmpSpace = (char *)sqlite3_malloc(nDefaultPage);
  2094.   }
  2095.   /* If an error occured in either of the blocks above.
  2096.   ** Free the Pager structure and close the file.
  2097.   ** Since the pager is not allocated there is no need to set 
  2098.   ** any Pager.errMask variables.
  2099.   */
  2100.   if( !pPager || !pPager->pTmpSpace ){
  2101.     sqlite3OsClose(pPager->fd);
  2102.     sqlite3_free(pPager);
  2103.     return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc);
  2104.   }
  2105.   PAGERTRACE3("OPEN %d %sn", FILEHANDLEID(pPager->fd), pPager->zFilename);
  2106.   IOTRACE(("OPEN %p %sn", pPager, pPager->zFilename))
  2107.   /* Fill in Pager.zDirectory[] */
  2108.   memcpy(pPager->zDirectory, pPager->zFilename, nPathname+1);
  2109.   for(i=strlen(pPager->zDirectory); i>0 && pPager->zDirectory[i-1]!='/'; i--){}
  2110.   if( i>0 ) pPager->zDirectory[i-1] = 0;
  2111.   /* Fill in Pager.zJournal[] */
  2112.   memcpy(pPager->zJournal, pPager->zFilename, nPathname);
  2113.   memcpy(&pPager->zJournal[nPathname], "-journal", 9);
  2114.   /* pPager->journalOpen = 0; */
  2115.   pPager->useJournal = useJournal && !memDb;
  2116.   pPager->noReadlock = noReadlock && readOnly;
  2117.   /* pPager->stmtOpen = 0; */
  2118.   /* pPager->stmtInUse = 0; */
  2119.   /* pPager->nRef = 0; */
  2120.   pPager->dbSize = memDb-1;
  2121.   pPager->pageSize = nDefaultPage;
  2122.   /* pPager->stmtSize = 0; */
  2123.   /* pPager->stmtJSize = 0; */
  2124.   /* pPager->nPage = 0; */
  2125.   pPager->mxPage = 100;
  2126.   pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
  2127.   /* pPager->state = PAGER_UNLOCK; */
  2128.   assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
  2129.   /* pPager->errMask = 0; */
  2130.   pPager->tempFile = tempFile;
  2131.   assert( tempFile==PAGER_LOCKINGMODE_NORMAL 
  2132.           || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
  2133.   assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
  2134.   pPager->exclusiveMode = tempFile; 
  2135.   pPager->memDb = memDb;
  2136.   pPager->readOnly = readOnly;
  2137.   /* pPager->needSync = 0; */
  2138.   pPager->noSync = pPager->tempFile || !useJournal;
  2139.   pPager->fullSync = (pPager->noSync?0:1);
  2140.   pPager->sync_flags = SQLITE_SYNC_NORMAL;
  2141.   /* pPager->pFirst = 0; */
  2142.   /* pPager->pFirstSynced = 0; */
  2143.   /* pPager->pLast = 0; */
  2144.   pPager->nExtra = FORCE_ALIGNMENT(nExtra);
  2145.   assert(pPager->fd->pMethods||memDb||tempFile);
  2146.   if( !memDb ){
  2147.     setSectorSize(pPager);
  2148.   }
  2149.   /* pPager->pBusyHandler = 0; */
  2150.   /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
  2151.   *ppPager = pPager;
  2152. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  2153.   pPager->iInUseMM = 0;
  2154.   pPager->iInUseDB = 0;
  2155.   if( !memDb ){
  2156.     sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
  2157.     sqlite3_mutex_enter(mutex);
  2158.     pPager->pNext = sqlite3PagerList;
  2159.     if( sqlite3PagerList ){
  2160.       assert( sqlite3PagerList->pPrev==0 );
  2161.       sqlite3PagerList->pPrev = pPager;
  2162.     }
  2163.     pPager->pPrev = 0;
  2164.     sqlite3PagerList = pPager;
  2165.     sqlite3_mutex_leave(mutex);
  2166.   }
  2167. #endif
  2168.   return SQLITE_OK;
  2169. }
  2170. /*
  2171. ** Set the busy handler function.
  2172. */
  2173. void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){
  2174.   pPager->pBusyHandler = pBusyHandler;
  2175. }
  2176. /*
  2177. ** Set the destructor for this pager.  If not NULL, the destructor is called
  2178. ** when the reference count on each page reaches zero.  The destructor can
  2179. ** be used to clean up information in the extra segment appended to each page.
  2180. **
  2181. ** The destructor is not called as a result sqlite3PagerClose().  
  2182. ** Destructors are only called by sqlite3PagerUnref().
  2183. */
  2184. void sqlite3PagerSetDestructor(Pager *pPager, void (*xDesc)(DbPage*,int)){
  2185.   pPager->xDestructor = xDesc;
  2186. }
  2187. /*
  2188. ** Set the reinitializer for this pager.  If not NULL, the reinitializer
  2189. ** is called when the content of a page in cache is restored to its original
  2190. ** value as a result of a rollback.  The callback gives higher-level code
  2191. ** an opportunity to restore the EXTRA section to agree with the restored
  2192. ** page data.
  2193. */
  2194. void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*,int)){
  2195.   pPager->xReiniter = xReinit;
  2196. }
  2197. /*
  2198. ** Set the page size to *pPageSize. If the suggest new page size is
  2199. ** inappropriate, then an alternative page size is set to that
  2200. ** value before returning.
  2201. */
  2202. int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize){
  2203.   int rc = SQLITE_OK;
  2204.   u16 pageSize = *pPageSize;
  2205.   assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
  2206.   if( pageSize && pageSize!=pPager->pageSize 
  2207.    && !pPager->memDb && pPager->nRef==0 
  2208.   ){
  2209.     char *pNew = (char *)sqlite3_malloc(pageSize);
  2210.     if( !pNew ){
  2211.       rc = SQLITE_NOMEM;
  2212.     }else{
  2213.       pagerEnter(pPager);
  2214.       pager_reset(pPager);
  2215.       pPager->pageSize = pageSize;
  2216.       setSectorSize(pPager);
  2217.       sqlite3_free(pPager->pTmpSpace);
  2218.       pPager->pTmpSpace = pNew;
  2219.       pagerLeave(pPager);
  2220.     }
  2221.   }
  2222.   *pPageSize = pPager->pageSize;
  2223.   return rc;
  2224. }
  2225. /*
  2226. ** Return a pointer to the "temporary page" buffer held internally
  2227. ** by the pager.  This is a buffer that is big enough to hold the
  2228. ** entire content of a database page.  This buffer is used internally
  2229. ** during rollback and will be overwritten whenever a rollback
  2230. ** occurs.  But other modules are free to use it too, as long as
  2231. ** no rollbacks are happening.
  2232. */
  2233. void *sqlite3PagerTempSpace(Pager *pPager){
  2234.   return pPager->pTmpSpace;
  2235. }
  2236. /*
  2237. ** Attempt to set the maximum database page count if mxPage is positive. 
  2238. ** Make no changes if mxPage is zero or negative.  And never reduce the
  2239. ** maximum page count below the current size of the database.
  2240. **
  2241. ** Regardless of mxPage, return the current maximum page count.
  2242. */
  2243. int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
  2244.   if( mxPage>0 ){
  2245.     pPager->mxPgno = mxPage;
  2246.   }
  2247.   sqlite3PagerPagecount(pPager);
  2248.   return pPager->mxPgno;
  2249. }
  2250. /*
  2251. ** The following set of routines are used to disable the simulated
  2252. ** I/O error mechanism.  These routines are used to avoid simulated
  2253. ** errors in places where we do not care about errors.
  2254. **
  2255. ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
  2256. ** and generate no code.
  2257. */
  2258. #ifdef SQLITE_TEST
  2259. extern int sqlite3_io_error_pending;
  2260. extern int sqlite3_io_error_hit;
  2261. static int saved_cnt;
  2262. void disable_simulated_io_errors(void){
  2263.   saved_cnt = sqlite3_io_error_pending;
  2264.   sqlite3_io_error_pending = -1;
  2265. }
  2266. void enable_simulated_io_errors(void){
  2267.   sqlite3_io_error_pending = saved_cnt;
  2268. }
  2269. #else
  2270. # define disable_simulated_io_errors()
  2271. # define enable_simulated_io_errors()
  2272. #endif
  2273. /*
  2274. ** Read the first N bytes from the beginning of the file into memory
  2275. ** that pDest points to. 
  2276. **
  2277. ** No error checking is done. The rational for this is that this function 
  2278. ** may be called even if the file does not exist or contain a header. In 
  2279. ** these cases sqlite3OsRead() will return an error, to which the correct 
  2280. ** response is to zero the memory at pDest and continue.  A real IO error 
  2281. ** will presumably recur and be picked up later (Todo: Think about this).
  2282. */
  2283. int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
  2284.   int rc = SQLITE_OK;
  2285.   memset(pDest, 0, N);
  2286.   assert(MEMDB||pPager->fd->pMethods||pPager->tempFile);
  2287.   if( pPager->fd->pMethods ){
  2288.     IOTRACE(("DBHDR %p 0 %dn", pPager, N))
  2289.     rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
  2290.     if( rc==SQLITE_IOERR_SHORT_READ ){
  2291.       rc = SQLITE_OK;
  2292.     }
  2293.   }
  2294.   return rc;
  2295. }
  2296. /*
  2297. ** Return the total number of pages in the disk file associated with
  2298. ** pPager. 
  2299. **
  2300. ** If the PENDING_BYTE lies on the page directly after the end of the
  2301. ** file, then consider this page part of the file too. For example, if
  2302. ** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the
  2303. ** file is 4096 bytes, 5 is returned instead of 4.
  2304. */
  2305. int sqlite3PagerPagecount(Pager *pPager){
  2306.   i64 n = 0;
  2307.   int rc;
  2308.   assert( pPager!=0 );
  2309.   if( pPager->errCode ){
  2310.     return -1;
  2311.   }
  2312.   if( pPager->dbSize>=0 ){
  2313.     n = pPager->dbSize;
  2314.   } else {
  2315.     assert(pPager->fd->pMethods||pPager->tempFile);
  2316.     if( (pPager->fd->pMethods)
  2317.      && (rc = sqlite3OsFileSize(pPager->fd, &n))!=SQLITE_OK ){
  2318.       pPager->nRef++;
  2319.       pager_error(pPager, rc);
  2320.       pPager->nRef--;
  2321.       return -1;
  2322.     }
  2323.     if( n>0 && n<pPager->pageSize ){
  2324.       n = 1;
  2325.     }else{
  2326.       n /= pPager->pageSize;
  2327.     }
  2328.     if( pPager->state!=PAGER_UNLOCK ){
  2329.       pPager->dbSize = n;
  2330.     }
  2331.   }
  2332.   if( n==(PENDING_BYTE/pPager->pageSize) ){
  2333.     n++;
  2334.   }
  2335.   if( n>pPager->mxPgno ){
  2336.     pPager->mxPgno = n;
  2337.   }
  2338.   return n;
  2339. }
  2340. #ifndef SQLITE_OMIT_MEMORYDB
  2341. /*
  2342. ** Clear a PgHistory block
  2343. */
  2344. static void clearHistory(PgHistory *pHist){
  2345.   sqlite3_free(pHist->pOrig);
  2346.   sqlite3_free(pHist->pStmt);
  2347.   pHist->pOrig = 0;
  2348.   pHist->pStmt = 0;
  2349. }
  2350. #else
  2351. #define clearHistory(x)
  2352. #endif
  2353. /*
  2354. ** Forward declaration
  2355. */
  2356. static int syncJournal(Pager*);
  2357. /*
  2358. ** Unlink pPg from its hash chain. Also set the page number to 0 to indicate
  2359. ** that the page is not part of any hash chain. This is required because the
  2360. ** sqlite3PagerMovepage() routine can leave a page in the 
  2361. ** pNextFree/pPrevFree list that is not a part of any hash-chain.
  2362. */
  2363. static void unlinkHashChain(Pager *pPager, PgHdr *pPg){
  2364.   if( pPg->pgno==0 ){
  2365.     assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );
  2366.     return;
  2367.   }
  2368.   if( pPg->pNextHash ){
  2369.     pPg->pNextHash->pPrevHash = pPg->pPrevHash;
  2370.   }
  2371.   if( pPg->pPrevHash ){
  2372.     assert( pPager->aHash[pPg->pgno & (pPager->nHash-1)]!=pPg );
  2373.     pPg->pPrevHash->pNextHash = pPg->pNextHash;
  2374.   }else{
  2375.     int h = pPg->pgno & (pPager->nHash-1);
  2376.     pPager->aHash[h] = pPg->pNextHash;
  2377.   }
  2378.   if( MEMDB ){
  2379.     clearHistory(PGHDR_TO_HIST(pPg, pPager));
  2380.   }
  2381.   pPg->pgno = 0;
  2382.   pPg->pNextHash = pPg->pPrevHash = 0;
  2383. }
  2384. /*
  2385. ** Unlink a page from the free list (the list of all pages where nRef==0)
  2386. ** and from its hash collision chain.
  2387. */
  2388. static void unlinkPage(PgHdr *pPg){
  2389.   Pager *pPager = pPg->pPager;
  2390.   /* Unlink from free page list */
  2391.   lruListRemove(pPg);
  2392.   /* Unlink from the pgno hash table */
  2393.   unlinkHashChain(pPager, pPg);
  2394. }
  2395. /*
  2396. ** This routine is used to truncate the cache when a database
  2397. ** is truncated.  Drop from the cache all pages whose pgno is
  2398. ** larger than pPager->dbSize and is unreferenced.
  2399. **
  2400. ** Referenced pages larger than pPager->dbSize are zeroed.
  2401. **
  2402. ** Actually, at the point this routine is called, it would be
  2403. ** an error to have a referenced page.  But rather than delete
  2404. ** that page and guarantee a subsequent segfault, it seems better
  2405. ** to zero it and hope that we error out sanely.
  2406. */
  2407. static void pager_truncate_cache(Pager *pPager){
  2408.   PgHdr *pPg;
  2409.   PgHdr **ppPg;
  2410.   int dbSize = pPager->dbSize;
  2411.   ppPg = &pPager->pAll;
  2412.   while( (pPg = *ppPg)!=0 ){
  2413.     if( pPg->pgno<=dbSize ){
  2414.       ppPg = &pPg->pNextAll;
  2415.     }else if( pPg->nRef>0 ){
  2416.       memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
  2417.       ppPg = &pPg->pNextAll;
  2418.     }else{
  2419.       *ppPg = pPg->pNextAll;
  2420.       IOTRACE(("PGFREE %p %dn", pPager, pPg->pgno));
  2421.       PAGER_INCR(sqlite3_pager_pgfree_count);
  2422.       unlinkPage(pPg);
  2423.       makeClean(pPg);
  2424.       sqlite3_free(pPg->pData);
  2425.       sqlite3_free(pPg);
  2426.       pPager->nPage--;
  2427.     }
  2428.   }
  2429. }
  2430. /*
  2431. ** Try to obtain a lock on a file.  Invoke the busy callback if the lock
  2432. ** is currently not available.  Repeat until the busy callback returns
  2433. ** false or until the lock succeeds.
  2434. **
  2435. ** Return SQLITE_OK on success and an error code if we cannot obtain
  2436. ** the lock.
  2437. */
  2438. static int pager_wait_on_lock(Pager *pPager, int locktype){
  2439.   int rc;
  2440.   /* The OS lock values must be the same as the Pager lock values */
  2441.   assert( PAGER_SHARED==SHARED_LOCK );
  2442.   assert( PAGER_RESERVED==RESERVED_LOCK );
  2443.   assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
  2444.   /* If the file is currently unlocked then the size must be unknown */