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

数据库系统

开发平台:

C/C++

  1.   assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB );
  2.   if( pPager->state>=locktype ){
  3.     rc = SQLITE_OK;
  4.   }else{
  5.     if( pPager->pBusyHandler ) pPager->pBusyHandler->nBusy = 0;
  6.     do {
  7.       rc = sqlite3OsLock(pPager->fd, locktype);
  8.     }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) );
  9.     if( rc==SQLITE_OK ){
  10.       pPager->state = locktype;
  11.       IOTRACE(("LOCK %p %dn", pPager, locktype))
  12.     }
  13.   }
  14.   return rc;
  15. }
  16. /*
  17. ** Truncate the file to the number of pages specified.
  18. */
  19. int sqlite3PagerTruncate(Pager *pPager, Pgno nPage){
  20.   int rc;
  21.   assert( pPager->state>=PAGER_SHARED || MEMDB );
  22.   sqlite3PagerPagecount(pPager);
  23.   if( pPager->errCode ){
  24.     rc = pPager->errCode;
  25.     return rc;
  26.   }
  27.   if( nPage>=(unsigned)pPager->dbSize ){
  28.     return SQLITE_OK;
  29.   }
  30.   if( MEMDB ){
  31.     pPager->dbSize = nPage;
  32.     pager_truncate_cache(pPager);
  33.     return SQLITE_OK;
  34.   }
  35.   pagerEnter(pPager);
  36.   rc = syncJournal(pPager);
  37.   pagerLeave(pPager);
  38.   if( rc!=SQLITE_OK ){
  39.     return rc;
  40.   }
  41.   /* Get an exclusive lock on the database before truncating. */
  42.   pagerEnter(pPager);
  43.   rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
  44.   pagerLeave(pPager);
  45.   if( rc!=SQLITE_OK ){
  46.     return rc;
  47.   }
  48.   rc = pager_truncate(pPager, nPage);
  49.   return rc;
  50. }
  51. /*
  52. ** Shutdown the page cache.  Free all memory and close all files.
  53. **
  54. ** If a transaction was in progress when this routine is called, that
  55. ** transaction is rolled back.  All outstanding pages are invalidated
  56. ** and their memory is freed.  Any attempt to use a page associated
  57. ** with this page cache after this function returns will likely
  58. ** result in a coredump.
  59. **
  60. ** This function always succeeds. If a transaction is active an attempt
  61. ** is made to roll it back. If an error occurs during the rollback 
  62. ** a hot journal may be left in the filesystem but no error is returned
  63. ** to the caller.
  64. */
  65. int sqlite3PagerClose(Pager *pPager){
  66. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  67.   if( !MEMDB ){
  68.     sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
  69.     sqlite3_mutex_enter(mutex);
  70.     if( pPager->pPrev ){
  71.       pPager->pPrev->pNext = pPager->pNext;
  72.     }else{
  73.       sqlite3PagerList = pPager->pNext;
  74.     }
  75.     if( pPager->pNext ){
  76.       pPager->pNext->pPrev = pPager->pPrev;
  77.     }
  78.     sqlite3_mutex_leave(mutex);
  79.   }
  80. #endif
  81.   disable_simulated_io_errors();
  82.   pPager->errCode = 0;
  83.   pPager->exclusiveMode = 0;
  84.   pager_reset(pPager);
  85.   pagerUnlockAndRollback(pPager);
  86.   enable_simulated_io_errors();
  87.   PAGERTRACE2("CLOSE %dn", PAGERID(pPager));
  88.   IOTRACE(("CLOSE %pn", pPager))
  89.   assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) );
  90.   if( pPager->journalOpen ){
  91.     sqlite3OsClose(pPager->jfd);
  92.   }
  93.   sqlite3BitvecDestroy(pPager->pInJournal);
  94.   if( pPager->stmtOpen ){
  95.     sqlite3OsClose(pPager->stfd);
  96.   }
  97.   sqlite3OsClose(pPager->fd);
  98.   /* Temp files are automatically deleted by the OS
  99.   ** if( pPager->tempFile ){
  100.   **   sqlite3OsDelete(pPager->zFilename);
  101.   ** }
  102.   */
  103.   sqlite3_free(pPager->aHash);
  104.   sqlite3_free(pPager->pTmpSpace);
  105.   sqlite3_free(pPager);
  106.   return SQLITE_OK;
  107. }
  108. #if !defined(NDEBUG) || defined(SQLITE_TEST)
  109. /*
  110. ** Return the page number for the given page data.
  111. */
  112. Pgno sqlite3PagerPagenumber(DbPage *p){
  113.   return p->pgno;
  114. }
  115. #endif
  116. /*
  117. ** The page_ref() function increments the reference count for a page.
  118. ** If the page is currently on the freelist (the reference count is zero) then
  119. ** remove it from the freelist.
  120. **
  121. ** For non-test systems, page_ref() is a macro that calls _page_ref()
  122. ** online of the reference count is zero.  For test systems, page_ref()
  123. ** is a real function so that we can set breakpoints and trace it.
  124. */
  125. static void _page_ref(PgHdr *pPg){
  126.   if( pPg->nRef==0 ){
  127.     /* The page is currently on the freelist.  Remove it. */
  128.     lruListRemove(pPg);
  129.     pPg->pPager->nRef++;
  130.   }
  131.   pPg->nRef++;
  132. }
  133. #ifdef SQLITE_DEBUG
  134.   static void page_ref(PgHdr *pPg){
  135.     if( pPg->nRef==0 ){
  136.       _page_ref(pPg);
  137.     }else{
  138.       pPg->nRef++;
  139.     }
  140.   }
  141. #else
  142. # define page_ref(P)   ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++)
  143. #endif
  144. /*
  145. ** Increment the reference count for a page.  The input pointer is
  146. ** a reference to the page data.
  147. */
  148. int sqlite3PagerRef(DbPage *pPg){
  149.   pagerEnter(pPg->pPager);
  150.   page_ref(pPg);
  151.   pagerLeave(pPg->pPager);
  152.   return SQLITE_OK;
  153. }
  154. /*
  155. ** Sync the journal.  In other words, make sure all the pages that have
  156. ** been written to the journal have actually reached the surface of the
  157. ** disk.  It is not safe to modify the original database file until after
  158. ** the journal has been synced.  If the original database is modified before
  159. ** the journal is synced and a power failure occurs, the unsynced journal
  160. ** data would be lost and we would be unable to completely rollback the
  161. ** database changes.  Database corruption would occur.
  162. ** 
  163. ** This routine also updates the nRec field in the header of the journal.
  164. ** (See comments on the pager_playback() routine for additional information.)
  165. ** If the sync mode is FULL, two syncs will occur.  First the whole journal
  166. ** is synced, then the nRec field is updated, then a second sync occurs.
  167. **
  168. ** For temporary databases, we do not care if we are able to rollback
  169. ** after a power failure, so no sync occurs.
  170. **
  171. ** If the IOCAP_SEQUENTIAL flag is set for the persistent media on which
  172. ** the database is stored, then OsSync() is never called on the journal
  173. ** file. In this case all that is required is to update the nRec field in
  174. ** the journal header.
  175. **
  176. ** This routine clears the needSync field of every page current held in
  177. ** memory.
  178. */
  179. static int syncJournal(Pager *pPager){
  180.   PgHdr *pPg;
  181.   int rc = SQLITE_OK;
  182.   /* Sync the journal before modifying the main database
  183.   ** (assuming there is a journal and it needs to be synced.)
  184.   */
  185.   if( pPager->needSync ){
  186.     if( !pPager->tempFile ){
  187.       int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
  188.       assert( pPager->journalOpen );
  189.       /* assert( !pPager->noSync ); // noSync might be set if synchronous
  190.       ** was turned off after the transaction was started.  Ticket #615 */
  191. #ifndef NDEBUG
  192.       {
  193.         /* Make sure the pPager->nRec counter we are keeping agrees
  194.         ** with the nRec computed from the size of the journal file.
  195.         */
  196.         i64 jSz;
  197.         rc = sqlite3OsFileSize(pPager->jfd, &jSz);
  198.         if( rc!=0 ) return rc;
  199.         assert( pPager->journalOff==jSz );
  200.       }
  201. #endif
  202.       if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
  203.         /* Write the nRec value into the journal file header. If in
  204.         ** full-synchronous mode, sync the journal first. This ensures that
  205.         ** all data has really hit the disk before nRec is updated to mark
  206.         ** it as a candidate for rollback.
  207.         **
  208.         ** This is not required if the persistent media supports the
  209.         ** SAFE_APPEND property. Because in this case it is not possible 
  210.         ** for garbage data to be appended to the file, the nRec field
  211.         ** is populated with 0xFFFFFFFF when the journal header is written
  212.         ** and never needs to be updated.
  213.         */
  214.         i64 jrnlOff;
  215.         if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
  216.           PAGERTRACE2("SYNC journal of %dn", PAGERID(pPager));
  217.           IOTRACE(("JSYNC %pn", pPager))
  218.           rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags);
  219.           if( rc!=0 ) return rc;
  220.         }
  221.         jrnlOff = pPager->journalHdr + sizeof(aJournalMagic);
  222.         IOTRACE(("JHDR %p %lld %dn", pPager, jrnlOff, 4));
  223.         rc = write32bits(pPager->jfd, jrnlOff, pPager->nRec);
  224.         if( rc ) return rc;
  225.       }
  226.       if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
  227.         PAGERTRACE2("SYNC journal of %dn", PAGERID(pPager));
  228.         IOTRACE(("JSYNC %pn", pPager))
  229.         rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags| 
  230.           (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
  231.         );
  232.         if( rc!=0 ) return rc;
  233.       }
  234.       pPager->journalStarted = 1;
  235.     }
  236.     pPager->needSync = 0;
  237.     /* Erase the needSync flag from every page.
  238.     */
  239.     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
  240.       pPg->needSync = 0;
  241.     }
  242.     lruListSetFirstSynced(pPager);
  243.   }
  244. #ifndef NDEBUG
  245.   /* If the Pager.needSync flag is clear then the PgHdr.needSync
  246.   ** flag must also be clear for all pages.  Verify that this
  247.   ** invariant is true.
  248.   */
  249.   else{
  250.     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
  251.       assert( pPg->needSync==0 );
  252.     }
  253.     assert( pPager->lru.pFirstSynced==pPager->lru.pFirst );
  254.   }
  255. #endif
  256.   return rc;
  257. }
  258. /*
  259. ** Merge two lists of pages connected by pDirty and in pgno order.
  260. ** Do not both fixing the pPrevDirty pointers.
  261. */
  262. static PgHdr *merge_pagelist(PgHdr *pA, PgHdr *pB){
  263.   PgHdr result, *pTail;
  264.   pTail = &result;
  265.   while( pA && pB ){
  266.     if( pA->pgno<pB->pgno ){
  267.       pTail->pDirty = pA;
  268.       pTail = pA;
  269.       pA = pA->pDirty;
  270.     }else{
  271.       pTail->pDirty = pB;
  272.       pTail = pB;
  273.       pB = pB->pDirty;
  274.     }
  275.   }
  276.   if( pA ){
  277.     pTail->pDirty = pA;
  278.   }else if( pB ){
  279.     pTail->pDirty = pB;
  280.   }else{
  281.     pTail->pDirty = 0;
  282.   }
  283.   return result.pDirty;
  284. }
  285. /*
  286. ** Sort the list of pages in accending order by pgno.  Pages are
  287. ** connected by pDirty pointers.  The pPrevDirty pointers are
  288. ** corrupted by this sort.
  289. */
  290. #define N_SORT_BUCKET_ALLOC 25
  291. #define N_SORT_BUCKET       25
  292. #ifdef SQLITE_TEST
  293.   int sqlite3_pager_n_sort_bucket = 0;
  294.   #undef N_SORT_BUCKET
  295.   #define N_SORT_BUCKET 
  296.    (sqlite3_pager_n_sort_bucket?sqlite3_pager_n_sort_bucket:N_SORT_BUCKET_ALLOC)
  297. #endif
  298. static PgHdr *sort_pagelist(PgHdr *pIn){
  299.   PgHdr *a[N_SORT_BUCKET_ALLOC], *p;
  300.   int i;
  301.   memset(a, 0, sizeof(a));
  302.   while( pIn ){
  303.     p = pIn;
  304.     pIn = p->pDirty;
  305.     p->pDirty = 0;
  306.     for(i=0; i<N_SORT_BUCKET-1; i++){
  307.       if( a[i]==0 ){
  308.         a[i] = p;
  309.         break;
  310.       }else{
  311.         p = merge_pagelist(a[i], p);
  312.         a[i] = 0;
  313.       }
  314.     }
  315.     if( i==N_SORT_BUCKET-1 ){
  316.       /* Coverage: To get here, there need to be 2^(N_SORT_BUCKET) 
  317.       ** elements in the input list. This is possible, but impractical.
  318.       ** Testing this line is the point of global variable
  319.       ** sqlite3_pager_n_sort_bucket.
  320.       */
  321.       a[i] = merge_pagelist(a[i], p);
  322.     }
  323.   }
  324.   p = a[0];
  325.   for(i=1; i<N_SORT_BUCKET; i++){
  326.     p = merge_pagelist(p, a[i]);
  327.   }
  328.   return p;
  329. }
  330. /*
  331. ** Given a list of pages (connected by the PgHdr.pDirty pointer) write
  332. ** every one of those pages out to the database file and mark them all
  333. ** as clean.
  334. */
  335. static int pager_write_pagelist(PgHdr *pList){
  336.   Pager *pPager;
  337.   PgHdr *p;
  338.   int rc;
  339.   if( pList==0 ) return SQLITE_OK;
  340.   pPager = pList->pPager;
  341.   /* At this point there may be either a RESERVED or EXCLUSIVE lock on the
  342.   ** database file. If there is already an EXCLUSIVE lock, the following
  343.   ** calls to sqlite3OsLock() are no-ops.
  344.   **
  345.   ** Moving the lock from RESERVED to EXCLUSIVE actually involves going
  346.   ** through an intermediate state PENDING.   A PENDING lock prevents new
  347.   ** readers from attaching to the database but is unsufficient for us to
  348.   ** write.  The idea of a PENDING lock is to prevent new readers from
  349.   ** coming in while we wait for existing readers to clear.
  350.   **
  351.   ** While the pager is in the RESERVED state, the original database file
  352.   ** is unchanged and we can rollback without having to playback the
  353.   ** journal into the original database file.  Once we transition to
  354.   ** EXCLUSIVE, it means the database file has been changed and any rollback
  355.   ** will require a journal playback.
  356.   */
  357.   rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
  358.   if( rc!=SQLITE_OK ){
  359.     return rc;
  360.   }
  361.   pList = sort_pagelist(pList);
  362.   for(p=pList; p; p=p->pDirty){
  363.     assert( p->dirty );
  364.     p->dirty = 0;
  365.   }
  366.   while( pList ){
  367.     /* If the file has not yet been opened, open it now. */
  368.     if( !pPager->fd->pMethods ){
  369.       assert(pPager->tempFile);
  370.       rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->fd, pPager->zFilename,
  371.                                 pPager->vfsFlags);
  372.       if( rc ) return rc;
  373.     }
  374.     /* If there are dirty pages in the page cache with page numbers greater
  375.     ** than Pager.dbSize, this means sqlite3PagerTruncate() was called to
  376.     ** make the file smaller (presumably by auto-vacuum code). Do not write
  377.     ** any such pages to the file.
  378.     */
  379.     if( pList->pgno<=pPager->dbSize ){
  380.       i64 offset = (pList->pgno-1)*(i64)pPager->pageSize;
  381.       char *pData = CODEC2(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);
  382.       PAGERTRACE4("STORE %d page %d hash(%08x)n",
  383.                    PAGERID(pPager), pList->pgno, pager_pagehash(pList));
  384.       IOTRACE(("PGOUT %p %dn", pPager, pList->pgno));
  385.       rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
  386.       PAGER_INCR(sqlite3_pager_writedb_count);
  387.       PAGER_INCR(pPager->nWrite);
  388.       if( pList->pgno==1 ){
  389.         memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
  390.       }
  391.     }
  392. #ifndef NDEBUG
  393.     else{
  394.       PAGERTRACE3("NOSTORE %d page %dn", PAGERID(pPager), pList->pgno);
  395.     }
  396. #endif
  397.     if( rc ) return rc;
  398. #ifdef SQLITE_CHECK_PAGES
  399.     pList->pageHash = pager_pagehash(pList);
  400. #endif
  401.     pList = pList->pDirty;
  402.   }
  403.   return SQLITE_OK;
  404. }
  405. /*
  406. ** Collect every dirty page into a dirty list and
  407. ** return a pointer to the head of that list.  All pages are
  408. ** collected even if they are still in use.
  409. */
  410. static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
  411. #ifndef NDEBUG
  412.   /* Verify the sanity of the dirty list when we are running
  413.   ** in debugging mode.  This is expensive, so do not
  414.   ** do this on a normal build. */
  415.   int n1 = 0;
  416.   int n2 = 0;
  417.   PgHdr *p;
  418.   for(p=pPager->pAll; p; p=p->pNextAll){ if( p->dirty ) n1++; }
  419.   for(p=pPager->pDirty; p; p=p->pDirty){ n2++; }
  420.   assert( n1==n2 );
  421. #endif
  422.   return pPager->pDirty;
  423. }
  424. /*
  425. ** Return 1 if there is a hot journal on the given pager.
  426. ** A hot journal is one that needs to be played back.
  427. **
  428. ** If the current size of the database file is 0 but a journal file
  429. ** exists, that is probably an old journal left over from a prior
  430. ** database with the same name.  Just delete the journal.
  431. **
  432. ** Return negative if unable to determine the status of the journal.
  433. */
  434. static int hasHotJournal(Pager *pPager){
  435.   sqlite3_vfs *pVfs = pPager->pVfs;
  436.   int rc;
  437.   if( !pPager->useJournal ) return 0;
  438.   if( !pPager->fd->pMethods ) return 0;
  439.   rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS);
  440.   if( rc<=0 ){
  441.     return rc;
  442.   }
  443.   if( sqlite3OsCheckReservedLock(pPager->fd) ){
  444.     return 0;
  445.   }
  446.   if( sqlite3PagerPagecount(pPager)==0 ){
  447.     sqlite3OsDelete(pVfs, pPager->zJournal, 0);
  448.     return 0;
  449.   }else{
  450.     return 1;
  451.   }
  452. }
  453. /*
  454. ** Try to find a page in the cache that can be recycled. 
  455. **
  456. ** This routine may return SQLITE_IOERR, SQLITE_FULL or SQLITE_OK. It 
  457. ** does not set the pPager->errCode variable.
  458. */
  459. static int pager_recycle(Pager *pPager, PgHdr **ppPg){
  460.   PgHdr *pPg;
  461.   *ppPg = 0;
  462.   /* It is illegal to call this function unless the pager object
  463.   ** pointed to by pPager has at least one free page (page with nRef==0).
  464.   */ 
  465.   assert(!MEMDB);
  466.   assert(pPager->lru.pFirst);
  467.   /* Find a page to recycle.  Try to locate a page that does not
  468.   ** require us to do an fsync() on the journal.
  469.   */
  470.   pPg = pPager->lru.pFirstSynced;
  471.   /* If we could not find a page that does not require an fsync()
  472.   ** on the journal file then fsync the journal file.  This is a
  473.   ** very slow operation, so we work hard to avoid it.  But sometimes
  474.   ** it can't be helped.
  475.   */
  476.   if( pPg==0 && pPager->lru.pFirst){
  477.     int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
  478.     int rc = syncJournal(pPager);
  479.     if( rc!=0 ){
  480.       return rc;
  481.     }
  482.     if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
  483.       /* If in full-sync mode, write a new journal header into the
  484.       ** journal file. This is done to avoid ever modifying a journal
  485.       ** header that is involved in the rollback of pages that have
  486.       ** already been written to the database (in case the header is
  487.       ** trashed when the nRec field is updated).
  488.       */
  489.       pPager->nRec = 0;
  490.       assert( pPager->journalOff > 0 );
  491.       assert( pPager->doNotSync==0 );
  492.       rc = writeJournalHdr(pPager);
  493.       if( rc!=0 ){
  494.         return rc;
  495.       }
  496.     }
  497.     pPg = pPager->lru.pFirst;
  498.   }
  499.   assert( pPg->nRef==0 );
  500.   /* Write the page to the database file if it is dirty.
  501.   */
  502.   if( pPg->dirty ){
  503.     int rc;
  504.     assert( pPg->needSync==0 );
  505.     makeClean(pPg);
  506.     pPg->dirty = 1;
  507.     pPg->pDirty = 0;
  508.     rc = pager_write_pagelist( pPg );
  509.     pPg->dirty = 0;
  510.     if( rc!=SQLITE_OK ){
  511.       return rc;
  512.     }
  513.   }
  514.   assert( pPg->dirty==0 );
  515.   /* If the page we are recycling is marked as alwaysRollback, then
  516.   ** set the global alwaysRollback flag, thus disabling the
  517.   ** sqlite3PagerDontRollback() optimization for the rest of this transaction.
  518.   ** It is necessary to do this because the page marked alwaysRollback
  519.   ** might be reloaded at a later time but at that point we won't remember
  520.   ** that is was marked alwaysRollback.  This means that all pages must
  521.   ** be marked as alwaysRollback from here on out.
  522.   */
  523.   if( pPg->alwaysRollback ){
  524.     IOTRACE(("ALWAYS_ROLLBACK %pn", pPager))
  525.     pPager->alwaysRollback = 1;
  526.   }
  527.   /* Unlink the old page from the free list and the hash table
  528.   */
  529.   unlinkPage(pPg);
  530.   assert( pPg->pgno==0 );
  531.   *ppPg = pPg;
  532.   return SQLITE_OK;
  533. }
  534. #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  535. /*
  536. ** This function is called to free superfluous dynamically allocated memory
  537. ** held by the pager system. Memory in use by any SQLite pager allocated
  538. ** by the current thread may be sqlite3_free()ed.
  539. **
  540. ** nReq is the number of bytes of memory required. Once this much has
  541. ** been released, the function returns. The return value is the total number 
  542. ** of bytes of memory released.
  543. */
  544. int sqlite3PagerReleaseMemory(int nReq){
  545.   int nReleased = 0;          /* Bytes of memory released so far */
  546.   sqlite3_mutex *mutex;       /* The MEM2 mutex */
  547.   Pager *pPager;              /* For looping over pagers */
  548.   BusyHandler *savedBusy;     /* Saved copy of the busy handler */
  549.   int rc = SQLITE_OK;
  550.   /* Acquire the memory-management mutex
  551.   */
  552.   mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
  553.   sqlite3_mutex_enter(mutex);
  554.   /* Signal all database connections that memory management wants
  555.   ** to have access to the pagers.
  556.   */
  557.   for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){
  558.      pPager->iInUseMM = 1;
  559.   }
  560.   while( rc==SQLITE_OK && (nReq<0 || nReleased<nReq) ){
  561.     PgHdr *pPg;
  562.     PgHdr *pRecycled;
  563.  
  564.     /* Try to find a page to recycle that does not require a sync(). If
  565.     ** this is not possible, find one that does require a sync().
  566.     */
  567.     sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  568.     pPg = sqlite3LruPageList.pFirstSynced;
  569.     while( pPg && (pPg->needSync || pPg->pPager->iInUseDB) ){
  570.       pPg = pPg->gfree.pNext;
  571.     }
  572.     if( !pPg ){
  573.       pPg = sqlite3LruPageList.pFirst;
  574.       while( pPg && pPg->pPager->iInUseDB ){
  575.         pPg = pPg->gfree.pNext;
  576.       }
  577.     }
  578.     sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
  579.     /* If pPg==0, then the block above has failed to find a page to
  580.     ** recycle. In this case return early - no further memory will
  581.     ** be released.
  582.     */
  583.     if( !pPg ) break;
  584.     pPager = pPg->pPager;
  585.     assert(!pPg->needSync || pPg==pPager->lru.pFirst);
  586.     assert(pPg->needSync || pPg==pPager->lru.pFirstSynced);
  587.   
  588.     savedBusy = pPager->pBusyHandler;
  589.     pPager->pBusyHandler = 0;
  590.     rc = pager_recycle(pPager, &pRecycled);
  591.     pPager->pBusyHandler = savedBusy;
  592.     assert(pRecycled==pPg || rc!=SQLITE_OK);
  593.     if( rc==SQLITE_OK ){
  594.       /* We've found a page to free. At this point the page has been 
  595.       ** removed from the page hash-table, free-list and synced-list 
  596.       ** (pFirstSynced). It is still in the all pages (pAll) list. 
  597.       ** Remove it from this list before freeing.
  598.       **
  599.       ** Todo: Check the Pager.pStmt list to make sure this is Ok. It 
  600.       ** probably is though.
  601.       */
  602.       PgHdr *pTmp;
  603.       assert( pPg );
  604.       if( pPg==pPager->pAll ){
  605.          pPager->pAll = pPg->pNextAll;
  606.       }else{
  607.         for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){}
  608.         pTmp->pNextAll = pPg->pNextAll;
  609.       }
  610.       nReleased += (
  611.           sizeof(*pPg) + pPager->pageSize
  612.           + sizeof(u32) + pPager->nExtra
  613.           + MEMDB*sizeof(PgHistory) 
  614.       );
  615.       IOTRACE(("PGFREE %p %d *n", pPager, pPg->pgno));
  616.       PAGER_INCR(sqlite3_pager_pgfree_count);
  617.       sqlite3_free(pPg->pData);
  618.       sqlite3_free(pPg);
  619.       pPager->nPage--;
  620.     }else{
  621.       /* An error occured whilst writing to the database file or 
  622.       ** journal in pager_recycle(). The error is not returned to the 
  623.       ** caller of this function. Instead, set the Pager.errCode variable.
  624.       ** The error will be returned to the user (or users, in the case 
  625.       ** of a shared pager cache) of the pager for which the error occured.
  626.       */
  627.       assert(
  628.           (rc&0xff)==SQLITE_IOERR ||
  629.           rc==SQLITE_FULL ||
  630.           rc==SQLITE_BUSY
  631.       );
  632.       assert( pPager->state>=PAGER_RESERVED );
  633.       pager_error(pPager, rc);
  634.     }
  635.   }
  636.   /* Clear the memory management flags and release the mutex
  637.   */
  638.   for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){
  639.      pPager->iInUseMM = 0;
  640.   }
  641.   sqlite3_mutex_leave(mutex);
  642.   /* Return the number of bytes released
  643.   */
  644.   return nReleased;
  645. }
  646. #endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
  647. /*
  648. ** Read the content of page pPg out of the database file.
  649. */
  650. static int readDbPage(Pager *pPager, PgHdr *pPg, Pgno pgno){
  651.   int rc;
  652.   i64 offset;
  653.   assert( MEMDB==0 );
  654.   assert(pPager->fd->pMethods||pPager->tempFile);
  655.   if( !pPager->fd->pMethods ){
  656.     return SQLITE_IOERR_SHORT_READ;
  657.   }
  658.   offset = (pgno-1)*(i64)pPager->pageSize;
  659.   rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg), pPager->pageSize, offset);
  660.   PAGER_INCR(sqlite3_pager_readdb_count);
  661.   PAGER_INCR(pPager->nRead);
  662.   IOTRACE(("PGIN %p %dn", pPager, pgno));
  663.   if( pgno==1 ){
  664.     memcpy(&pPager->dbFileVers, &((u8*)PGHDR_TO_DATA(pPg))[24],
  665.                                               sizeof(pPager->dbFileVers));
  666.   }
  667.   CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
  668.   PAGERTRACE4("FETCH %d page %d hash(%08x)n",
  669.                PAGERID(pPager), pPg->pgno, pager_pagehash(pPg));
  670.   return rc;
  671. }
  672. /*
  673. ** This function is called to obtain the shared lock required before
  674. ** data may be read from the pager cache. If the shared lock has already
  675. ** been obtained, this function is a no-op.
  676. **
  677. ** Immediately after obtaining the shared lock (if required), this function
  678. ** checks for a hot-journal file. If one is found, an emergency rollback
  679. ** is performed immediately.
  680. */
  681. static int pagerSharedLock(Pager *pPager){
  682.   int rc = SQLITE_OK;
  683.   int isHot = 0;
  684.   /* If this database is opened for exclusive access, has no outstanding 
  685.   ** page references and is in an error-state, now is the chance to clear
  686.   ** the error. Discard the contents of the pager-cache and treat any
  687.   ** open journal file as a hot-journal.
  688.   */
  689.   if( !MEMDB && pPager->exclusiveMode && pPager->nRef==0 && pPager->errCode ){
  690.     if( pPager->journalOpen ){
  691.       isHot = 1;
  692.     }
  693.     pager_reset(pPager);
  694.     pPager->errCode = SQLITE_OK;
  695.   }
  696.   /* If the pager is still in an error state, do not proceed. The error 
  697.   ** state will be cleared at some point in the future when all page 
  698.   ** references are dropped and the cache can be discarded.
  699.   */
  700.   if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
  701.     return pPager->errCode;
  702.   }
  703.   if( pPager->state==PAGER_UNLOCK || isHot ){
  704.     sqlite3_vfs *pVfs = pPager->pVfs;
  705.     if( !MEMDB ){
  706.       assert( pPager->nRef==0 );
  707.       if( !pPager->noReadlock ){
  708.         rc = pager_wait_on_lock(pPager, SHARED_LOCK);
  709.         if( rc!=SQLITE_OK ){
  710.           return pager_error(pPager, rc);
  711.         }
  712.         assert( pPager->state>=SHARED_LOCK );
  713.       }
  714.   
  715.       /* If a journal file exists, and there is no RESERVED lock on the
  716.       ** database file, then it either needs to be played back or deleted.
  717.       */
  718.       rc = hasHotJournal(pPager);
  719.       if( rc<0 ){
  720.         return SQLITE_IOERR_NOMEM;
  721.       }
  722.       if( rc==1 || isHot ){
  723.         /* Get an EXCLUSIVE lock on the database file. At this point it is
  724.         ** important that a RESERVED lock is not obtained on the way to the
  725.         ** EXCLUSIVE lock. If it were, another process might open the
  726.         ** database file, detect the RESERVED lock, and conclude that the
  727.         ** database is safe to read while this process is still rolling it 
  728.         ** back.
  729.         ** 
  730.         ** Because the intermediate RESERVED lock is not requested, the
  731.         ** second process will get to this point in the code and fail to
  732.         ** obtain its own EXCLUSIVE lock on the database file.
  733.         */
  734.         if( pPager->state<EXCLUSIVE_LOCK ){
  735.           rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
  736.           if( rc!=SQLITE_OK ){
  737.             pager_unlock(pPager);
  738.             return pager_error(pPager, rc);
  739.           }
  740.           pPager->state = PAGER_EXCLUSIVE;
  741.         }
  742.  
  743.         /* Open the journal for reading only.  Return SQLITE_BUSY if
  744.         ** we are unable to open the journal file. 
  745.         **
  746.         ** The journal file does not need to be locked itself.  The
  747.         ** journal file is never open unless the main database file holds
  748.         ** a write lock, so there is never any chance of two or more
  749.         ** processes opening the journal at the same time.
  750.         **
  751.         ** Open the journal for read/write access. This is because in 
  752.         ** exclusive-access mode the file descriptor will be kept open and
  753.         ** possibly used for a transaction later on. On some systems, the
  754.         ** OsTruncate() call used in exclusive-access mode also requires
  755.         ** a read/write file handle.
  756.         */
  757.         if( !isHot ){
  758.           int res = sqlite3OsAccess(pVfs,pPager->zJournal,SQLITE_ACCESS_EXISTS);
  759.           if( res==1 ){
  760.             int fout = 0;
  761.             int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
  762.             assert( !pPager->tempFile );
  763.             rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
  764.             assert( rc!=SQLITE_OK || pPager->jfd->pMethods );
  765.             if( fout&SQLITE_OPEN_READONLY ){
  766.               rc = SQLITE_BUSY;
  767.               sqlite3OsClose(pPager->jfd);
  768.             }
  769.           }else{
  770.             rc = (res==0?SQLITE_BUSY:SQLITE_IOERR_NOMEM);
  771.           }
  772.         }
  773.         if( rc!=SQLITE_OK ){
  774.           pager_unlock(pPager);
  775.           switch( rc ){
  776.             case SQLITE_NOMEM:
  777.             case SQLITE_IOERR_UNLOCK:
  778.             case SQLITE_IOERR_NOMEM:
  779.               return rc;
  780.             default:
  781.               return SQLITE_BUSY;
  782.           }
  783.         }
  784.         pPager->journalOpen = 1;
  785.         pPager->journalStarted = 0;
  786.         pPager->journalOff = 0;
  787.         pPager->setMaster = 0;
  788.         pPager->journalHdr = 0;
  789.  
  790.         /* Playback and delete the journal.  Drop the database write
  791.         ** lock and reacquire the read lock.
  792.         */
  793.         rc = pager_playback(pPager, 1);
  794.         if( rc!=SQLITE_OK ){
  795.           return pager_error(pPager, rc);
  796.         }
  797.         assert(pPager->state==PAGER_SHARED || 
  798.             (pPager->exclusiveMode && pPager->state>PAGER_SHARED)
  799.         );
  800.       }
  801.       if( pPager->pAll ){
  802.         /* The shared-lock has just been acquired on the database file
  803.         ** and there are already pages in the cache (from a previous
  804.         ** read or write transaction).  Check to see if the database
  805.         ** has been modified.  If the database has changed, flush the
  806.         ** cache.
  807.         **
  808.         ** Database changes is detected by looking at 15 bytes beginning
  809.         ** at offset 24 into the file.  The first 4 of these 16 bytes are
  810.         ** a 32-bit counter that is incremented with each change.  The
  811.         ** other bytes change randomly with each file change when
  812.         ** a codec is in use.
  813.         ** 
  814.         ** There is a vanishingly small chance that a change will not be 
  815.         ** detected.  The chance of an undetected change is so small that
  816.         ** it can be neglected.
  817.         */
  818.         char dbFileVers[sizeof(pPager->dbFileVers)];
  819.         sqlite3PagerPagecount(pPager);
  820.         if( pPager->errCode ){
  821.           return pPager->errCode;
  822.         }
  823.         if( pPager->dbSize>0 ){
  824.           IOTRACE(("CKVERS %p %dn", pPager, sizeof(dbFileVers)));
  825.           rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
  826.           if( rc!=SQLITE_OK ){
  827.             return rc;
  828.           }
  829.         }else{
  830.           memset(dbFileVers, 0, sizeof(dbFileVers));
  831.         }
  832.         if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
  833.           pager_reset(pPager);
  834.         }
  835.       }
  836.     }
  837.     assert( pPager->exclusiveMode || pPager->state<=PAGER_SHARED );
  838.     if( pPager->state==PAGER_UNLOCK ){
  839.       pPager->state = PAGER_SHARED;
  840.     }
  841.   }
  842.   return rc;
  843. }
  844. /*
  845. ** Allocate a PgHdr object.   Either create a new one or reuse
  846. ** an existing one that is not otherwise in use.
  847. **
  848. ** A new PgHdr structure is created if any of the following are
  849. ** true:
  850. **
  851. **     (1)  We have not exceeded our maximum allocated cache size
  852. **          as set by the "PRAGMA cache_size" command.
  853. **
  854. **     (2)  There are no unused PgHdr objects available at this time.
  855. **
  856. **     (3)  This is an in-memory database.
  857. **
  858. **     (4)  There are no PgHdr objects that do not require a journal
  859. **          file sync and a sync of the journal file is currently
  860. **          prohibited.
  861. **
  862. ** Otherwise, reuse an existing PgHdr.  In other words, reuse an
  863. ** existing PgHdr if all of the following are true:
  864. **
  865. **     (1)  We have reached or exceeded the maximum cache size
  866. **          allowed by "PRAGMA cache_size".
  867. **
  868. **     (2)  There is a PgHdr available with PgHdr->nRef==0
  869. **
  870. **     (3)  We are not in an in-memory database
  871. **
  872. **     (4)  Either there is an available PgHdr that does not need
  873. **          to be synced to disk or else disk syncing is currently
  874. **          allowed.
  875. */
  876. static int pagerAllocatePage(Pager *pPager, PgHdr **ppPg){
  877.   int rc = SQLITE_OK;
  878.   PgHdr *pPg;
  879.   int nByteHdr;
  880.   /* Create a new PgHdr if any of the four conditions defined 
  881.   ** above are met: */
  882.   if( pPager->nPage<pPager->mxPage
  883.    || pPager->lru.pFirst==0 
  884.    || MEMDB
  885.    || (pPager->lru.pFirstSynced==0 && pPager->doNotSync)
  886.   ){
  887.     void *pData;
  888.     if( pPager->nPage>=pPager->nHash ){
  889.       pager_resize_hash_table(pPager,
  890.          pPager->nHash<256 ? 256 : pPager->nHash*2);
  891.       if( pPager->nHash==0 ){
  892.         rc = SQLITE_NOMEM;
  893.         goto pager_allocate_out;
  894.       }
  895.     }
  896.     pagerLeave(pPager);
  897.     nByteHdr = sizeof(*pPg) + sizeof(u32) + pPager->nExtra
  898.               + MEMDB*sizeof(PgHistory);
  899.     pPg = sqlite3_malloc( nByteHdr );
  900.     if( pPg ){
  901.       pData = sqlite3_malloc( pPager->pageSize );
  902.       if( pData==0 ){
  903.         sqlite3_free(pPg);
  904.         pPg = 0;
  905.       }
  906.     }
  907.     pagerEnter(pPager);
  908.     if( pPg==0 ){
  909.       rc = SQLITE_NOMEM;
  910.       goto pager_allocate_out;
  911.     }
  912.     memset(pPg, 0, nByteHdr);
  913.     pPg->pData = pData;
  914.     pPg->pPager = pPager;
  915.     pPg->pNextAll = pPager->pAll;
  916.     pPager->pAll = pPg;
  917.     pPager->nPage++;
  918.   }else{
  919.     /* Recycle an existing page with a zero ref-count. */
  920.     rc = pager_recycle(pPager, &pPg);
  921.     if( rc==SQLITE_BUSY ){
  922.       rc = SQLITE_IOERR_BLOCKED;
  923.     }
  924.     if( rc!=SQLITE_OK ){
  925.       goto pager_allocate_out;
  926.     }
  927.     assert( pPager->state>=SHARED_LOCK );
  928.     assert(pPg);
  929.   }
  930.   *ppPg = pPg;
  931. pager_allocate_out:
  932.   return rc;
  933. }
  934. /*
  935. ** Make sure we have the content for a page.  If the page was
  936. ** previously acquired with noContent==1, then the content was
  937. ** just initialized to zeros instead of being read from disk.
  938. ** But now we need the real data off of disk.  So make sure we
  939. ** have it.  Read it in if we do not have it already.
  940. */
  941. static int pager_get_content(PgHdr *pPg){
  942.   if( pPg->needRead ){
  943.     int rc = readDbPage(pPg->pPager, pPg, pPg->pgno);
  944.     if( rc==SQLITE_OK ){
  945.       pPg->needRead = 0;
  946.     }else{
  947.       return rc;
  948.     }
  949.   }
  950.   return SQLITE_OK;
  951. }
  952. /*
  953. ** Acquire a page.
  954. **
  955. ** A read lock on the disk file is obtained when the first page is acquired. 
  956. ** This read lock is dropped when the last page is released.
  957. **
  958. ** This routine works for any page number greater than 0.  If the database
  959. ** file is smaller than the requested page, then no actual disk
  960. ** read occurs and the memory image of the page is initialized to
  961. ** all zeros.  The extra data appended to a page is always initialized
  962. ** to zeros the first time a page is loaded into memory.
  963. **
  964. ** The acquisition might fail for several reasons.  In all cases,
  965. ** an appropriate error code is returned and *ppPage is set to NULL.
  966. **
  967. ** See also sqlite3PagerLookup().  Both this routine and Lookup() attempt
  968. ** to find a page in the in-memory cache first.  If the page is not already
  969. ** in memory, this routine goes to disk to read it in whereas Lookup()
  970. ** just returns 0.  This routine acquires a read-lock the first time it
  971. ** has to go to disk, and could also playback an old journal if necessary.
  972. ** Since Lookup() never goes to disk, it never has to deal with locks
  973. ** or journal files.
  974. **
  975. ** If noContent is false, the page contents are actually read from disk.
  976. ** If noContent is true, it means that we do not care about the contents
  977. ** of the page at this time, so do not do a disk read.  Just fill in the
  978. ** page content with zeros.  But mark the fact that we have not read the
  979. ** content by setting the PgHdr.needRead flag.  Later on, if 
  980. ** sqlite3PagerWrite() is called on this page or if this routine is
  981. ** called again with noContent==0, that means that the content is needed
  982. ** and the disk read should occur at that point.
  983. */
  984. static int pagerAcquire(
  985.   Pager *pPager,      /* The pager open on the database file */
  986.   Pgno pgno,          /* Page number to fetch */
  987.   DbPage **ppPage,    /* Write a pointer to the page here */
  988.   int noContent       /* Do not bother reading content from disk if true */
  989. ){
  990.   PgHdr *pPg;
  991.   int rc;
  992.   assert( pPager->state==PAGER_UNLOCK || pPager->nRef>0 || pgno==1 );
  993.   /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
  994.   ** number greater than this, or zero, is requested.
  995.   */
  996.   if( pgno>PAGER_MAX_PGNO || pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
  997.     return SQLITE_CORRUPT_BKPT;
  998.   }
  999.   /* Make sure we have not hit any critical errors.
  1000.   */ 
  1001.   assert( pPager!=0 );
  1002.   *ppPage = 0;
  1003.   /* If this is the first page accessed, then get a SHARED lock
  1004.   ** on the database file. pagerSharedLock() is a no-op if 
  1005.   ** a database lock is already held.
  1006.   */
  1007.   rc = pagerSharedLock(pPager);
  1008.   if( rc!=SQLITE_OK ){
  1009.     return rc;
  1010.   }
  1011.   assert( pPager->state!=PAGER_UNLOCK );
  1012.   pPg = pager_lookup(pPager, pgno);
  1013.   if( pPg==0 ){
  1014.     /* The requested page is not in the page cache. */
  1015.     int nMax;
  1016.     int h;
  1017.     PAGER_INCR(pPager->nMiss);
  1018.     rc = pagerAllocatePage(pPager, &pPg);
  1019.     if( rc!=SQLITE_OK ){
  1020.       return rc;
  1021.     }
  1022.     pPg->pgno = pgno;
  1023.     assert( !MEMDB || pgno>pPager->stmtSize );
  1024.     pPg->inJournal = sqlite3BitvecTest(pPager->pInJournal, pgno);
  1025.     pPg->needSync = 0;
  1026.     makeClean(pPg);
  1027.     pPg->nRef = 1;
  1028.     pPager->nRef++;
  1029.     if( pPager->nExtra>0 ){
  1030.       memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra);
  1031.     }
  1032.     nMax = sqlite3PagerPagecount(pPager);
  1033.     if( pPager->errCode ){
  1034.       rc = pPager->errCode;
  1035.       sqlite3PagerUnref(pPg);
  1036.       return rc;
  1037.     }
  1038.     /* Populate the page with data, either by reading from the database
  1039.     ** file, or by setting the entire page to zero.
  1040.     */
  1041.     if( nMax<(int)pgno || MEMDB || (noContent && !pPager->alwaysRollback) ){
  1042.       if( pgno>pPager->mxPgno ){
  1043.         sqlite3PagerUnref(pPg);
  1044.         return SQLITE_FULL;
  1045.       }
  1046.       memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
  1047.       pPg->needRead = noContent && !pPager->alwaysRollback;
  1048.       IOTRACE(("ZERO %p %dn", pPager, pgno));
  1049.     }else{
  1050.       rc = readDbPage(pPager, pPg, pgno);
  1051.       if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
  1052.         pPg->pgno = 0;
  1053.         sqlite3PagerUnref(pPg);
  1054.         return rc;
  1055.       }
  1056.       pPg->needRead = 0;
  1057.     }
  1058.     /* Link the page into the page hash table */
  1059.     h = pgno & (pPager->nHash-1);
  1060.     assert( pgno!=0 );
  1061.     pPg->pNextHash = pPager->aHash[h];
  1062.     pPager->aHash[h] = pPg;
  1063.     if( pPg->pNextHash ){
  1064.       assert( pPg->pNextHash->pPrevHash==0 );
  1065.       pPg->pNextHash->pPrevHash = pPg;
  1066.     }
  1067. #ifdef SQLITE_CHECK_PAGES
  1068.     pPg->pageHash = pager_pagehash(pPg);
  1069. #endif
  1070.   }else{
  1071.     /* The requested page is in the page cache. */
  1072.     assert(pPager->nRef>0 || pgno==1);
  1073.     PAGER_INCR(pPager->nHit);
  1074.     if( !noContent ){
  1075.       rc = pager_get_content(pPg);
  1076.       if( rc ){
  1077.         return rc;
  1078.       }
  1079.     }
  1080.     page_ref(pPg);
  1081.   }
  1082.   *ppPage = pPg;
  1083.   return SQLITE_OK;
  1084. }
  1085. int sqlite3PagerAcquire(
  1086.   Pager *pPager,      /* The pager open on the database file */
  1087.   Pgno pgno,          /* Page number to fetch */
  1088.   DbPage **ppPage,    /* Write a pointer to the page here */
  1089.   int noContent       /* Do not bother reading content from disk if true */
  1090. ){
  1091.   int rc;
  1092.   pagerEnter(pPager);
  1093.   rc = pagerAcquire(pPager, pgno, ppPage, noContent);
  1094.   pagerLeave(pPager);
  1095.   return rc;
  1096. }
  1097. /*
  1098. ** Acquire a page if it is already in the in-memory cache.  Do
  1099. ** not read the page from disk.  Return a pointer to the page,
  1100. ** or 0 if the page is not in cache.
  1101. **
  1102. ** See also sqlite3PagerGet().  The difference between this routine
  1103. ** and sqlite3PagerGet() is that _get() will go to the disk and read
  1104. ** in the page if the page is not already in cache.  This routine
  1105. ** returns NULL if the page is not in cache or if a disk I/O error 
  1106. ** has ever happened.
  1107. */
  1108. DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
  1109.   PgHdr *pPg = 0;
  1110.   assert( pPager!=0 );
  1111.   assert( pgno!=0 );
  1112.   pagerEnter(pPager);
  1113.   if( pPager->state==PAGER_UNLOCK ){
  1114.     assert( !pPager->pAll || pPager->exclusiveMode );
  1115.   }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
  1116.     /* Do nothing */
  1117.   }else if( (pPg = pager_lookup(pPager, pgno))!=0 ){
  1118.     page_ref(pPg);
  1119.   }
  1120.   pagerLeave(pPager);
  1121.   return pPg;
  1122. }
  1123. /*
  1124. ** Release a page.
  1125. **
  1126. ** If the number of references to the page drop to zero, then the
  1127. ** page is added to the LRU list.  When all references to all pages
  1128. ** are released, a rollback occurs and the lock on the database is
  1129. ** removed.
  1130. */
  1131. int sqlite3PagerUnref(DbPage *pPg){
  1132.   Pager *pPager = pPg->pPager;
  1133.   /* Decrement the reference count for this page
  1134.   */
  1135.   assert( pPg->nRef>0 );
  1136.   pagerEnter(pPg->pPager);
  1137.   pPg->nRef--;
  1138.   CHECK_PAGE(pPg);
  1139.   /* When the number of references to a page reach 0, call the
  1140.   ** destructor and add the page to the freelist.
  1141.   */
  1142.   if( pPg->nRef==0 ){
  1143.     lruListAdd(pPg);
  1144.     if( pPager->xDestructor ){
  1145.       pPager->xDestructor(pPg, pPager->pageSize);
  1146.     }
  1147.   
  1148.     /* When all pages reach the freelist, drop the read lock from
  1149.     ** the database file.
  1150.     */
  1151.     pPager->nRef--;
  1152.     assert( pPager->nRef>=0 );
  1153.     if( pPager->nRef==0 && (!pPager->exclusiveMode || pPager->journalOff>0) ){
  1154.       pagerUnlockAndRollback(pPager);
  1155.     }
  1156.   }
  1157.   pagerLeave(pPager);
  1158.   return SQLITE_OK;
  1159. }
  1160. /*
  1161. ** Create a journal file for pPager.  There should already be a RESERVED
  1162. ** or EXCLUSIVE lock on the database file when this routine is called.
  1163. **
  1164. ** Return SQLITE_OK if everything.  Return an error code and release the
  1165. ** write lock if anything goes wrong.
  1166. */
  1167. static int pager_open_journal(Pager *pPager){
  1168.   sqlite3_vfs *pVfs = pPager->pVfs;
  1169.   int flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_CREATE);
  1170.   int rc;
  1171.   assert( !MEMDB );
  1172.   assert( pPager->state>=PAGER_RESERVED );
  1173.   assert( pPager->journalOpen==0 );
  1174.   assert( pPager->useJournal );
  1175.   assert( pPager->pInJournal==0 );
  1176.   sqlite3PagerPagecount(pPager);
  1177.   pagerLeave(pPager);
  1178.   pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
  1179.   pagerEnter(pPager);
  1180.   if( pPager->pInJournal==0 ){
  1181.     rc = SQLITE_NOMEM;
  1182.     goto failed_to_open_journal;
  1183.   }
  1184.   if( pPager->tempFile ){
  1185.     flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
  1186.   }else{
  1187.     flags |= (SQLITE_OPEN_MAIN_JOURNAL);
  1188.   }
  1189. #ifdef SQLITE_ENABLE_ATOMIC_WRITE
  1190.   rc = sqlite3JournalOpen(
  1191.       pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
  1192.   );
  1193. #else
  1194.   rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
  1195. #endif
  1196.   assert( rc!=SQLITE_OK || pPager->jfd->pMethods );
  1197.   pPager->journalOff = 0;
  1198.   pPager->setMaster = 0;
  1199.   pPager->journalHdr = 0;
  1200.   if( rc!=SQLITE_OK ){
  1201.     if( rc==SQLITE_NOMEM ){
  1202.       sqlite3OsDelete(pVfs, pPager->zJournal, 0);
  1203.     }
  1204.     goto failed_to_open_journal;
  1205.   }
  1206.   pPager->journalOpen = 1;
  1207.   pPager->journalStarted = 0;
  1208.   pPager->needSync = 0;
  1209.   pPager->alwaysRollback = 0;
  1210.   pPager->nRec = 0;
  1211.   if( pPager->errCode ){
  1212.     rc = pPager->errCode;
  1213.     goto failed_to_open_journal;
  1214.   }
  1215.   pPager->origDbSize = pPager->dbSize;
  1216.   rc = writeJournalHdr(pPager);
  1217.   if( pPager->stmtAutoopen && rc==SQLITE_OK ){
  1218.     rc = sqlite3PagerStmtBegin(pPager);
  1219.   }
  1220.   if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && rc!=SQLITE_IOERR_NOMEM ){
  1221.     rc = pager_end_transaction(pPager);
  1222.     if( rc==SQLITE_OK ){
  1223.       rc = SQLITE_FULL;
  1224.     }
  1225.   }
  1226.   return rc;
  1227. failed_to_open_journal:
  1228.   sqlite3BitvecDestroy(pPager->pInJournal);
  1229.   pPager->pInJournal = 0;
  1230.   return rc;
  1231. }
  1232. /*
  1233. ** Acquire a write-lock on the database.  The lock is removed when
  1234. ** the any of the following happen:
  1235. **
  1236. **   *  sqlite3PagerCommitPhaseTwo() is called.
  1237. **   *  sqlite3PagerRollback() is called.
  1238. **   *  sqlite3PagerClose() is called.
  1239. **   *  sqlite3PagerUnref() is called to on every outstanding page.
  1240. **
  1241. ** The first parameter to this routine is a pointer to any open page of the
  1242. ** database file.  Nothing changes about the page - it is used merely to
  1243. ** acquire a pointer to the Pager structure and as proof that there is
  1244. ** already a read-lock on the database.
  1245. **
  1246. ** The second parameter indicates how much space in bytes to reserve for a
  1247. ** master journal file-name at the start of the journal when it is created.
  1248. **
  1249. ** A journal file is opened if this is not a temporary file.  For temporary
  1250. ** files, the opening of the journal file is deferred until there is an
  1251. ** actual need to write to the journal.
  1252. **
  1253. ** If the database is already reserved for writing, this routine is a no-op.
  1254. **
  1255. ** If exFlag is true, go ahead and get an EXCLUSIVE lock on the file
  1256. ** immediately instead of waiting until we try to flush the cache.  The
  1257. ** exFlag is ignored if a transaction is already active.
  1258. */
  1259. int sqlite3PagerBegin(DbPage *pPg, int exFlag){
  1260.   Pager *pPager = pPg->pPager;
  1261.   int rc = SQLITE_OK;
  1262.   pagerEnter(pPager);
  1263.   assert( pPg->nRef>0 );
  1264.   assert( pPager->state!=PAGER_UNLOCK );
  1265.   if( pPager->state==PAGER_SHARED ){
  1266.     assert( pPager->pInJournal==0 );
  1267.     if( MEMDB ){
  1268.       pPager->state = PAGER_EXCLUSIVE;
  1269.       pPager->origDbSize = pPager->dbSize;
  1270.     }else{
  1271.       rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK);
  1272.       if( rc==SQLITE_OK ){
  1273.         pPager->state = PAGER_RESERVED;
  1274.         if( exFlag ){
  1275.           rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
  1276.         }
  1277.       }
  1278.       if( rc!=SQLITE_OK ){
  1279.         pagerLeave(pPager);
  1280.         return rc;
  1281.       }
  1282.       pPager->dirtyCache = 0;
  1283.       PAGERTRACE2("TRANSACTION %dn", PAGERID(pPager));
  1284.       if( pPager->useJournal && !pPager->tempFile ){
  1285.         rc = pager_open_journal(pPager);
  1286.       }
  1287.     }
  1288.   }else if( pPager->journalOpen && pPager->journalOff==0 ){
  1289.     /* This happens when the pager was in exclusive-access mode last
  1290.     ** time a (read or write) transaction was successfully concluded
  1291.     ** by this connection. Instead of deleting the journal file it was 
  1292.     ** kept open and truncated to 0 bytes.
  1293.     */
  1294.     assert( pPager->nRec==0 );
  1295.     assert( pPager->origDbSize==0 );
  1296.     assert( pPager->pInJournal==0 );
  1297.     sqlite3PagerPagecount(pPager);
  1298.     pagerLeave(pPager);
  1299.     pPager->pInJournal = sqlite3BitvecCreate( pPager->dbSize );
  1300.     pagerEnter(pPager);
  1301.     if( !pPager->pInJournal ){
  1302.       rc = SQLITE_NOMEM;
  1303.     }else{
  1304.       pPager->origDbSize = pPager->dbSize;
  1305.       rc = writeJournalHdr(pPager);
  1306.     }
  1307.   }
  1308.   assert( !pPager->journalOpen || pPager->journalOff>0 || rc!=SQLITE_OK );
  1309.   pagerLeave(pPager);
  1310.   return rc;
  1311. }
  1312. /*
  1313. ** Make a page dirty.  Set its dirty flag and add it to the dirty
  1314. ** page list.
  1315. */
  1316. static void makeDirty(PgHdr *pPg){
  1317.   if( pPg->dirty==0 ){
  1318.     Pager *pPager = pPg->pPager;
  1319.     pPg->dirty = 1;
  1320.     pPg->pDirty = pPager->pDirty;
  1321.     if( pPager->pDirty ){
  1322.       pPager->pDirty->pPrevDirty = pPg;
  1323.     }
  1324.     pPg->pPrevDirty = 0;
  1325.     pPager->pDirty = pPg;
  1326.   }
  1327. }
  1328. /*
  1329. ** Make a page clean.  Clear its dirty bit and remove it from the
  1330. ** dirty page list.
  1331. */
  1332. static void makeClean(PgHdr *pPg){
  1333.   if( pPg->dirty ){
  1334.     pPg->dirty = 0;
  1335.     if( pPg->pDirty ){
  1336.       assert( pPg->pDirty->pPrevDirty==pPg );
  1337.       pPg->pDirty->pPrevDirty = pPg->pPrevDirty;
  1338.     }
  1339.     if( pPg->pPrevDirty ){
  1340.       assert( pPg->pPrevDirty->pDirty==pPg );
  1341.       pPg->pPrevDirty->pDirty = pPg->pDirty;
  1342.     }else{
  1343.       assert( pPg->pPager->pDirty==pPg );
  1344.       pPg->pPager->pDirty = pPg->pDirty;
  1345.     }
  1346.   }
  1347. }
  1348. /*
  1349. ** Mark a data page as writeable.  The page is written into the journal 
  1350. ** if it is not there already.  This routine must be called before making
  1351. ** changes to a page.
  1352. **
  1353. ** The first time this routine is called, the pager creates a new
  1354. ** journal and acquires a RESERVED lock on the database.  If the RESERVED
  1355. ** lock could not be acquired, this routine returns SQLITE_BUSY.  The
  1356. ** calling routine must check for that return value and be careful not to
  1357. ** change any page data until this routine returns SQLITE_OK.
  1358. **
  1359. ** If the journal file could not be written because the disk is full,
  1360. ** then this routine returns SQLITE_FULL and does an immediate rollback.
  1361. ** All subsequent write attempts also return SQLITE_FULL until there
  1362. ** is a call to sqlite3PagerCommit() or sqlite3PagerRollback() to
  1363. ** reset.
  1364. */
  1365. static int pager_write(PgHdr *pPg){
  1366.   void *pData = PGHDR_TO_DATA(pPg);
  1367.   Pager *pPager = pPg->pPager;
  1368.   int rc = SQLITE_OK;
  1369.   /* Check for errors
  1370.   */
  1371.   if( pPager->errCode ){ 
  1372.     return pPager->errCode;
  1373.   }
  1374.   if( pPager->readOnly ){
  1375.     return SQLITE_PERM;
  1376.   }
  1377.   assert( !pPager->setMaster );
  1378.   CHECK_PAGE(pPg);
  1379.   /* If this page was previously acquired with noContent==1, that means
  1380.   ** we didn't really read in the content of the page.  This can happen
  1381.   ** (for example) when the page is being moved to the freelist.  But
  1382.   ** now we are (perhaps) moving the page off of the freelist for
  1383.   ** reuse and we need to know its original content so that content
  1384.   ** can be stored in the rollback journal.  So do the read at this
  1385.   ** time.
  1386.   */
  1387.   rc = pager_get_content(pPg);
  1388.   if( rc ){
  1389.     return rc;
  1390.   }
  1391.   /* Mark the page as dirty.  If the page has already been written
  1392.   ** to the journal then we can return right away.
  1393.   */
  1394.   makeDirty(pPg);
  1395.   if( pPg->inJournal && (pageInStatement(pPg) || pPager->stmtInUse==0) ){
  1396.     pPager->dirtyCache = 1;
  1397.   }else{
  1398.     /* If we get this far, it means that the page needs to be
  1399.     ** written to the transaction journal or the ckeckpoint journal
  1400.     ** or both.
  1401.     **
  1402.     ** First check to see that the transaction journal exists and
  1403.     ** create it if it does not.
  1404.     */
  1405.     assert( pPager->state!=PAGER_UNLOCK );
  1406.     rc = sqlite3PagerBegin(pPg, 0);
  1407.     if( rc!=SQLITE_OK ){
  1408.       return rc;
  1409.     }
  1410.     assert( pPager->state>=PAGER_RESERVED );
  1411.     if( !pPager->journalOpen && pPager->useJournal ){
  1412.       rc = pager_open_journal(pPager);
  1413.       if( rc!=SQLITE_OK ) return rc;
  1414.     }
  1415.     assert( pPager->journalOpen || !pPager->useJournal );
  1416.     pPager->dirtyCache = 1;
  1417.   
  1418.     /* The transaction journal now exists and we have a RESERVED or an
  1419.     ** EXCLUSIVE lock on the main database file.  Write the current page to
  1420.     ** the transaction journal if it is not there already.
  1421.     */
  1422.     if( !pPg->inJournal && (pPager->useJournal || MEMDB) ){
  1423.       if( (int)pPg->pgno <= pPager->origDbSize ){
  1424.         if( MEMDB ){
  1425.           PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
  1426.           PAGERTRACE3("JOURNAL %d page %dn", PAGERID(pPager), pPg->pgno);
  1427.           assert( pHist->pOrig==0 );
  1428.           pHist->pOrig = sqlite3_malloc( pPager->pageSize );
  1429.           if( !pHist->pOrig ){
  1430.             return SQLITE_NOMEM;
  1431.           }
  1432.           memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize);
  1433.         }else{
  1434.           u32 cksum;
  1435.           char *pData2;
  1436.           /* We should never write to the journal file the page that
  1437.           ** contains the database locks.  The following assert verifies
  1438.           ** that we do not. */
  1439.           assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
  1440.           pData2 = CODEC2(pPager, pData, pPg->pgno, 7);
  1441.           cksum = pager_cksum(pPager, (u8*)pData2);
  1442.           rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno);
  1443.           if( rc==SQLITE_OK ){
  1444.             rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize,
  1445.                                 pPager->journalOff + 4);
  1446.             pPager->journalOff += pPager->pageSize+4;
  1447.           }
  1448.           if( rc==SQLITE_OK ){
  1449.             rc = write32bits(pPager->jfd, pPager->journalOff, cksum);
  1450.             pPager->journalOff += 4;
  1451.           }
  1452.           IOTRACE(("JOUT %p %d %lld %dn", pPager, pPg->pgno, 
  1453.                    pPager->journalOff, pPager->pageSize));
  1454.           PAGER_INCR(sqlite3_pager_writej_count);
  1455.           PAGERTRACE5("JOURNAL %d page %d needSync=%d hash(%08x)n",
  1456.                PAGERID(pPager), pPg->pgno, pPg->needSync, pager_pagehash(pPg));
  1457.           /* An error has occured writing to the journal file. The 
  1458.           ** transaction will be rolled back by the layer above.
  1459.           */
  1460.           if( rc!=SQLITE_OK ){
  1461.             return rc;
  1462.           }
  1463.           pPager->nRec++;
  1464.           assert( pPager->pInJournal!=0 );
  1465.           sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
  1466.           pPg->needSync = !pPager->noSync;
  1467.           if( pPager->stmtInUse ){
  1468.             sqlite3BitvecSet(pPager->pInStmt, pPg->pgno);
  1469.           }
  1470.         }
  1471.       }else{
  1472.         pPg->needSync = !pPager->journalStarted && !pPager->noSync;
  1473.         PAGERTRACE4("APPEND %d page %d needSync=%dn",
  1474.                 PAGERID(pPager), pPg->pgno, pPg->needSync);
  1475.       }
  1476.       if( pPg->needSync ){
  1477.         pPager->needSync = 1;
  1478.       }
  1479.       pPg->inJournal = 1;
  1480.     }
  1481.   
  1482.     /* If the statement journal is open and the page is not in it,
  1483.     ** then write the current page to the statement journal.  Note that
  1484.     ** the statement journal format differs from the standard journal format
  1485.     ** in that it omits the checksums and the header.
  1486.     */
  1487.     if( pPager->stmtInUse 
  1488.      && !pageInStatement(pPg) 
  1489.      && (int)pPg->pgno<=pPager->stmtSize 
  1490.     ){
  1491.       assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
  1492.       if( MEMDB ){
  1493.         PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
  1494.         assert( pHist->pStmt==0 );
  1495.         pHist->pStmt = sqlite3_malloc( pPager->pageSize );
  1496.         if( pHist->pStmt ){
  1497.           memcpy(pHist->pStmt, PGHDR_TO_DATA(pPg), pPager->pageSize);
  1498.         }
  1499.         PAGERTRACE3("STMT-JOURNAL %d page %dn", PAGERID(pPager), pPg->pgno);
  1500.         page_add_to_stmt_list(pPg);
  1501.       }else{
  1502.         i64 offset = pPager->stmtNRec*(4+pPager->pageSize);
  1503.         char *pData2 = CODEC2(pPager, pData, pPg->pgno, 7);
  1504.         rc = write32bits(pPager->stfd, offset, pPg->pgno);
  1505.         if( rc==SQLITE_OK ){
  1506.           rc = sqlite3OsWrite(pPager->stfd, pData2, pPager->pageSize, offset+4);
  1507.         }
  1508.         PAGERTRACE3("STMT-JOURNAL %d page %dn", PAGERID(pPager), pPg->pgno);
  1509.         if( rc!=SQLITE_OK ){
  1510.           return rc;
  1511.         }
  1512.         pPager->stmtNRec++;
  1513.         assert( pPager->pInStmt!=0 );
  1514.         sqlite3BitvecSet(pPager->pInStmt, pPg->pgno);
  1515.       }
  1516.     }
  1517.   }
  1518.   /* Update the database size and return.
  1519.   */
  1520.   assert( pPager->state>=PAGER_SHARED );
  1521.   if( pPager->dbSize<(int)pPg->pgno ){
  1522.     pPager->dbSize = pPg->pgno;
  1523.     if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){
  1524.       pPager->dbSize++;
  1525.     }
  1526.   }
  1527.   return rc;
  1528. }
  1529. /*
  1530. ** This function is used to mark a data-page as writable. It uses 
  1531. ** pager_write() to open a journal file (if it is not already open)
  1532. ** and write the page *pData to the journal.
  1533. **
  1534. ** The difference between this function and pager_write() is that this
  1535. ** function also deals with the special case where 2 or more pages
  1536. ** fit on a single disk sector. In this case all co-resident pages
  1537. ** must have been written to the journal file before returning.
  1538. */
  1539. int sqlite3PagerWrite(DbPage *pDbPage){
  1540.   int rc = SQLITE_OK;
  1541.   PgHdr *pPg = pDbPage;
  1542.   Pager *pPager = pPg->pPager;
  1543.   Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
  1544.   pagerEnter(pPager);
  1545.   if( !MEMDB && nPagePerSector>1 ){
  1546.     Pgno nPageCount;          /* Total number of pages in database file */
  1547.     Pgno pg1;                 /* First page of the sector pPg is located on. */
  1548.     int nPage;                /* Number of pages starting at pg1 to journal */
  1549.     int ii;
  1550.     int needSync = 0;
  1551.     /* Set the doNotSync flag to 1. This is because we cannot allow a journal
  1552.     ** header to be written between the pages journaled by this function.
  1553.     */
  1554.     assert( pPager->doNotSync==0 );
  1555.     pPager->doNotSync = 1;
  1556.     /* This trick assumes that both the page-size and sector-size are
  1557.     ** an integer power of 2. It sets variable pg1 to the identifier
  1558.     ** of the first page of the sector pPg is located on.
  1559.     */
  1560.     pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
  1561.     nPageCount = sqlite3PagerPagecount(pPager);
  1562.     if( pPg->pgno>nPageCount ){
  1563.       nPage = (pPg->pgno - pg1)+1;
  1564.     }else if( (pg1+nPagePerSector-1)>nPageCount ){
  1565.       nPage = nPageCount+1-pg1;
  1566.     }else{
  1567.       nPage = nPagePerSector;
  1568.     }
  1569.     assert(nPage>0);
  1570.     assert(pg1<=pPg->pgno);
  1571.     assert((pg1+nPage)>pPg->pgno);
  1572.     for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
  1573.       Pgno pg = pg1+ii;
  1574.       PgHdr *pPage;
  1575.       if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
  1576.         if( pg!=PAGER_MJ_PGNO(pPager) ){
  1577.           rc = sqlite3PagerGet(pPager, pg, &pPage);
  1578.           if( rc==SQLITE_OK ){
  1579.             rc = pager_write(pPage);
  1580.             if( pPage->needSync ){
  1581.               needSync = 1;
  1582.             }
  1583.             sqlite3PagerUnref(pPage);
  1584.           }
  1585.         }
  1586.       }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
  1587.         if( pPage->needSync ){
  1588.           needSync = 1;
  1589.         }
  1590.       }
  1591.     }
  1592.     /* If the PgHdr.needSync flag is set for any of the nPage pages 
  1593.     ** starting at pg1, then it needs to be set for all of them. Because
  1594.     ** writing to any of these nPage pages may damage the others, the
  1595.     ** journal file must contain sync()ed copies of all of them
  1596.     ** before any of them can be written out to the database file.
  1597.     */
  1598.     if( needSync ){
  1599.       for(ii=0; ii<nPage && needSync; ii++){
  1600.         PgHdr *pPage = pager_lookup(pPager, pg1+ii);
  1601.         if( pPage ) pPage->needSync = 1;
  1602.       }
  1603.       assert(pPager->needSync);
  1604.     }
  1605.     assert( pPager->doNotSync==1 );
  1606.     pPager->doNotSync = 0;
  1607.   }else{
  1608.     rc = pager_write(pDbPage);
  1609.   }
  1610.   pagerLeave(pPager);
  1611.   return rc;
  1612. }
  1613. /*
  1614. ** Return TRUE if the page given in the argument was previously passed
  1615. ** to sqlite3PagerWrite().  In other words, return TRUE if it is ok
  1616. ** to change the content of the page.
  1617. */
  1618. #ifndef NDEBUG
  1619. int sqlite3PagerIswriteable(DbPage *pPg){
  1620.   return pPg->dirty;
  1621. }
  1622. #endif
  1623. #ifndef SQLITE_OMIT_VACUUM
  1624. /*
  1625. ** Replace the content of a single page with the information in the third
  1626. ** argument.
  1627. */
  1628. int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void *pData){
  1629.   PgHdr *pPg;
  1630.   int rc;
  1631.   pagerEnter(pPager);
  1632.   rc = sqlite3PagerGet(pPager, pgno, &pPg);
  1633.   if( rc==SQLITE_OK ){
  1634.     rc = sqlite3PagerWrite(pPg);
  1635.     if( rc==SQLITE_OK ){
  1636.       memcpy(sqlite3PagerGetData(pPg), pData, pPager->pageSize);
  1637.     }
  1638.     sqlite3PagerUnref(pPg);
  1639.   }
  1640.   pagerLeave(pPager);
  1641.   return rc;
  1642. }
  1643. #endif
  1644. /*
  1645. ** A call to this routine tells the pager that it is not necessary to
  1646. ** write the information on page pPg back to the disk, even though
  1647. ** that page might be marked as dirty.
  1648. **
  1649. ** The overlying software layer calls this routine when all of the data
  1650. ** on the given page is unused.  The pager marks the page as clean so
  1651. ** that it does not get written to disk.
  1652. **
  1653. ** Tests show that this optimization, together with the
  1654. ** sqlite3PagerDontRollback() below, more than double the speed
  1655. ** of large INSERT operations and quadruple the speed of large DELETEs.
  1656. **
  1657. ** When this routine is called, set the alwaysRollback flag to true.
  1658. ** Subsequent calls to sqlite3PagerDontRollback() for the same page
  1659. ** will thereafter be ignored.  This is necessary to avoid a problem
  1660. ** where a page with data is added to the freelist during one part of
  1661. ** a transaction then removed from the freelist during a later part
  1662. ** of the same transaction and reused for some other purpose.  When it
  1663. ** is first added to the freelist, this routine is called.  When reused,
  1664. ** the sqlite3PagerDontRollback() routine is called.  But because the
  1665. ** page contains critical data, we still need to be sure it gets
  1666. ** rolled back in spite of the sqlite3PagerDontRollback() call.
  1667. */
  1668. void sqlite3PagerDontWrite(DbPage *pDbPage){
  1669.   PgHdr *pPg = pDbPage;
  1670.   Pager *pPager = pPg->pPager;
  1671.   if( MEMDB ) return;
  1672.   pagerEnter(pPager);
  1673.   pPg->alwaysRollback = 1;
  1674.   if( pPg->dirty && !pPager->stmtInUse ){
  1675.     assert( pPager->state>=PAGER_SHARED );
  1676.     if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){
  1677.       /* If this pages is the last page in the file and the file has grown
  1678.       ** during the current transaction, then do NOT mark the page as clean.
  1679.       ** When the database file grows, we must make sure that the last page
  1680.       ** gets written at least once so that the disk file will be the correct
  1681.       ** size. If you do not write this page and the size of the file
  1682.       ** on the disk ends up being too small, that can lead to database
  1683.       ** corruption during the next transaction.
  1684.       */
  1685.     }else{
  1686.       PAGERTRACE3("DONT_WRITE page %d of %dn", pPg->pgno, PAGERID(pPager));
  1687.       IOTRACE(("CLEAN %p %dn", pPager, pPg->pgno))
  1688.       makeClean(pPg);
  1689. #ifdef SQLITE_CHECK_PAGES
  1690.       pPg->pageHash = pager_pagehash(pPg);
  1691. #endif
  1692.     }
  1693.   }
  1694.   pagerLeave(pPager);
  1695. }
  1696. /*
  1697. ** A call to this routine tells the pager that if a rollback occurs,
  1698. ** it is not necessary to restore the data on the given page.  This
  1699. ** means that the pager does not have to record the given page in the
  1700. ** rollback journal.
  1701. **
  1702. ** If we have not yet actually read the content of this page (if
  1703. ** the PgHdr.needRead flag is set) then this routine acts as a promise
  1704. ** that we will never need to read the page content in the future.
  1705. ** so the needRead flag can be cleared at this point.
  1706. */
  1707. void sqlite3PagerDontRollback(DbPage *pPg){
  1708.   Pager *pPager = pPg->pPager;
  1709.   pagerEnter(pPager);
  1710.   assert( pPager->state>=PAGER_RESERVED );
  1711.   /* If the journal file is not open, or DontWrite() has been called on
  1712.   ** this page (DontWrite() sets the alwaysRollback flag), then this
  1713.   ** function is a no-op.
  1714.   */
  1715.   if( pPager->journalOpen==0 || pPg->alwaysRollback || pPager->alwaysRollback ){
  1716.     pagerLeave(pPager);
  1717.     return;
  1718.   }
  1719.   assert( !MEMDB );    /* For a memdb, pPager->journalOpen is always 0 */
  1720. #ifdef SQLITE_SECURE_DELETE
  1721.   if( pPg->inJournal || (int)pPg->pgno > pPager->origDbSize ){
  1722.     return;
  1723.   }
  1724. #endif
  1725.   /* If SECURE_DELETE is disabled, then there is no way that this
  1726.   ** routine can be called on a page for which sqlite3PagerDontWrite()
  1727.   ** has not been previously called during the same transaction.
  1728.   ** And if DontWrite() has previously been called, the following
  1729.   ** conditions must be met.
  1730.   */
  1731.   assert( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize );
  1732.   assert( pPager->pInJournal!=0 );
  1733.   sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
  1734.   pPg->inJournal = 1;
  1735.   pPg->needRead = 0;
  1736.   if( pPager->stmtInUse ){
  1737.     assert( pPager->stmtSize >= pPager->origDbSize );
  1738.     sqlite3BitvecSet(pPager->pInStmt, pPg->pgno);
  1739.   }
  1740.   PAGERTRACE3("DONT_ROLLBACK page %d of %dn", pPg->pgno, PAGERID(pPager));
  1741.   IOTRACE(("GARBAGE %p %dn", pPager, pPg->pgno))
  1742.   pagerLeave(pPager);
  1743. }
  1744. /*
  1745. ** This routine is called to increment the database file change-counter,
  1746. ** stored at byte 24 of the pager file.
  1747. */
  1748. static int pager_incr_changecounter(Pager *pPager, int isDirect){
  1749.   PgHdr *pPgHdr;
  1750.   u32 change_counter;
  1751.   int rc = SQLITE_OK;
  1752.   if( !pPager->changeCountDone ){
  1753.     /* Open page 1 of the file for writing. */
  1754.     rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
  1755.     if( rc!=SQLITE_OK ) return rc;
  1756.     if( !isDirect ){
  1757.       rc = sqlite3PagerWrite(pPgHdr);
  1758.       if( rc!=SQLITE_OK ){
  1759.         sqlite3PagerUnref(pPgHdr);
  1760.         return rc;
  1761.       }
  1762.     }
  1763.     /* Increment the value just read and write it back to byte 24. */
  1764.     change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers);
  1765.     change_counter++;
  1766.     put32bits(((char*)PGHDR_TO_DATA(pPgHdr))+24, change_counter);
  1767.     if( isDirect && pPager->fd->pMethods ){
  1768.       const void *zBuf = PGHDR_TO_DATA(pPgHdr);
  1769.       rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
  1770.     }
  1771.     /* Release the page reference. */
  1772.     sqlite3PagerUnref(pPgHdr);
  1773.     pPager->changeCountDone = 1;
  1774.   }
  1775.   return rc;
  1776. }
  1777. /*
  1778. ** Sync the pager file to disk.
  1779. */
  1780. int sqlite3PagerSync(Pager *pPager){
  1781.   int rc;
  1782.   pagerEnter(pPager);
  1783.   rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
  1784.   pagerLeave(pPager);
  1785.   return rc;
  1786. }
  1787. /*
  1788. ** Sync the database file for the pager pPager. zMaster points to the name
  1789. ** of a master journal file that should be written into the individual
  1790. ** journal file. zMaster may be NULL, which is interpreted as no master
  1791. ** journal (a single database transaction).
  1792. **
  1793. ** This routine ensures that the journal is synced, all dirty pages written
  1794. ** to the database file and the database file synced. The only thing that
  1795. ** remains to commit the transaction is to delete the journal file (or
  1796. ** master journal file if specified).
  1797. **
  1798. ** Note that if zMaster==NULL, this does not overwrite a previous value
  1799. ** passed to an sqlite3PagerCommitPhaseOne() call.
  1800. **
  1801. ** If parameter nTrunc is non-zero, then the pager file is truncated to
  1802. ** nTrunc pages (this is used by auto-vacuum databases).
  1803. **
  1804. ** If the final parameter - noSync - is true, then the database file itself
  1805. ** is not synced. The caller must call sqlite3PagerSync() directly to
  1806. ** sync the database file before calling CommitPhaseTwo() to delete the
  1807. ** journal file in this case.
  1808. */
  1809. int sqlite3PagerCommitPhaseOne(
  1810.   Pager *pPager, 
  1811.   const char *zMaster, 
  1812.   Pgno nTrunc,
  1813.   int noSync
  1814. ){
  1815.   int rc = SQLITE_OK;
  1816.   PAGERTRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%dn", 
  1817.       pPager->zFilename, zMaster, nTrunc);
  1818.   pagerEnter(pPager);
  1819.   /* If this is an in-memory db, or no pages have been written to, or this
  1820.   ** function has already been called, it is a no-op.
  1821.   */
  1822.   if( pPager->state!=PAGER_SYNCED && !MEMDB && pPager->dirtyCache ){
  1823.     PgHdr *pPg;
  1824. #ifdef SQLITE_ENABLE_ATOMIC_WRITE
  1825.     /* The atomic-write optimization can be used if all of the
  1826.     ** following are true:
  1827.     **
  1828.     **    + The file-system supports the atomic-write property for
  1829.     **      blocks of size page-size, and
  1830.     **    + This commit is not part of a multi-file transaction, and
  1831.     **    + Exactly one page has been modified and store in the journal file.
  1832.     **
  1833.     ** If the optimization can be used, then the journal file will never
  1834.     ** be created for this transaction.
  1835.     */
  1836.     int useAtomicWrite = (
  1837.         !zMaster && 
  1838.         pPager->journalOff==jrnlBufferSize(pPager) && 
  1839.         nTrunc==0 && 
  1840.         (0==pPager->pDirty || 0==pPager->pDirty->pDirty)
  1841.     );
  1842.     if( useAtomicWrite ){
  1843.       /* Update the nRec field in the journal file. */
  1844.       int offset = pPager->journalHdr + sizeof(aJournalMagic);
  1845.       assert(pPager->nRec==1);
  1846.       rc = write32bits(pPager->jfd, offset, pPager->nRec);
  1847.       /* Update the db file change counter. The following call will modify
  1848.       ** the in-memory representation of page 1 to include the updated
  1849.       ** change counter and then write page 1 directly to the database
  1850.       ** file. Because of the atomic-write property of the host file-system, 
  1851.       ** this is safe.
  1852.       */
  1853.       if( rc==SQLITE_OK ){
  1854.         rc = pager_incr_changecounter(pPager, 1);
  1855.       }
  1856.     }else{
  1857.       rc = sqlite3JournalCreate(pPager->jfd);
  1858.     }
  1859.     if( !useAtomicWrite && rc==SQLITE_OK )
  1860. #endif
  1861.     /* If a master journal file name has already been written to the
  1862.     ** journal file, then no sync is required. This happens when it is
  1863.     ** written, then the process fails to upgrade from a RESERVED to an
  1864.     ** EXCLUSIVE lock. The next time the process tries to commit the
  1865.     ** transaction the m-j name will have already been written.
  1866.     */
  1867.     if( !pPager->setMaster ){
  1868.       assert( pPager->journalOpen );
  1869.       rc = pager_incr_changecounter(pPager, 0);
  1870.       if( rc!=SQLITE_OK ) goto sync_exit;
  1871. #ifndef SQLITE_OMIT_AUTOVACUUM
  1872.       if( nTrunc!=0 ){
  1873.         /* If this transaction has made the database smaller, then all pages
  1874.         ** being discarded by the truncation must be written to the journal
  1875.         ** file.
  1876.         */
  1877.         Pgno i;
  1878.         int iSkip = PAGER_MJ_PGNO(pPager);
  1879.         for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){
  1880.           if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
  1881.             rc = sqlite3PagerGet(pPager, i, &pPg);
  1882.             if( rc!=SQLITE_OK ) goto sync_exit;
  1883.             rc = sqlite3PagerWrite(pPg);
  1884.             sqlite3PagerUnref(pPg);
  1885.             if( rc!=SQLITE_OK ) goto sync_exit;
  1886.           }
  1887.         } 
  1888.       }
  1889. #endif
  1890.       rc = writeMasterJournal(pPager, zMaster);
  1891.       if( rc!=SQLITE_OK ) goto sync_exit;
  1892.       rc = syncJournal(pPager);
  1893.     }
  1894.     if( rc!=SQLITE_OK ) goto sync_exit;
  1895. #ifndef SQLITE_OMIT_AUTOVACUUM
  1896.     if( nTrunc!=0 ){
  1897.       rc = sqlite3PagerTruncate(pPager, nTrunc);
  1898.       if( rc!=SQLITE_OK ) goto sync_exit;
  1899.     }
  1900. #endif
  1901.     /* Write all dirty pages to the database file */
  1902.     pPg = pager_get_all_dirty_pages(pPager);
  1903.     rc = pager_write_pagelist(pPg);
  1904.     if( rc!=SQLITE_OK ){
  1905.       assert( rc!=SQLITE_IOERR_BLOCKED );
  1906.       /* The error might have left the dirty list all fouled up here,
  1907.       ** but that does not matter because if the if the dirty list did
  1908.       ** get corrupted, then the transaction will roll back and
  1909.       ** discard the dirty list.  There is an assert in
  1910.       ** pager_get_all_dirty_pages() that verifies that no attempt
  1911.       ** is made to use an invalid dirty list.
  1912.       */
  1913.       goto sync_exit;
  1914.     }
  1915.     pPager->pDirty = 0;
  1916.     /* Sync the database file. */
  1917.     if( !pPager->noSync && !noSync ){
  1918.       rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
  1919.     }
  1920.     IOTRACE(("DBSYNC %pn", pPager))
  1921.     pPager->state = PAGER_SYNCED;
  1922.   }else if( MEMDB && nTrunc!=0 ){
  1923.     rc = sqlite3PagerTruncate(pPager, nTrunc);
  1924.   }
  1925. sync_exit:
  1926.   if( rc==SQLITE_IOERR_BLOCKED ){
  1927.     /* pager_incr_changecounter() may attempt to obtain an exclusive
  1928.      * lock to spill the cache and return IOERR_BLOCKED. But since 
  1929.      * there is no chance the cache is inconsistent, it is
  1930.      * better to return SQLITE_BUSY.
  1931.      */
  1932.     rc = SQLITE_BUSY;
  1933.   }
  1934.   pagerLeave(pPager);
  1935.   return rc;
  1936. }
  1937. /*
  1938. ** Commit all changes to the database and release the write lock.
  1939. **
  1940. ** If the commit fails for any reason, a rollback attempt is made
  1941. ** and an error code is returned.  If the commit worked, SQLITE_OK
  1942. ** is returned.
  1943. */
  1944. int sqlite3PagerCommitPhaseTwo(Pager *pPager){
  1945.   int rc;
  1946.   PgHdr *pPg;
  1947.   if( pPager->errCode ){
  1948.     return pPager->errCode;
  1949.   }
  1950.   if( pPager->state<PAGER_RESERVED ){
  1951.     return SQLITE_ERROR;
  1952.   }
  1953.   pagerEnter(pPager);
  1954.   PAGERTRACE2("COMMIT %dn", PAGERID(pPager));
  1955.   if( MEMDB ){
  1956.     pPg = pager_get_all_dirty_pages(pPager);
  1957.     while( pPg ){
  1958.       PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
  1959.       clearHistory(pHist);
  1960.       pPg->dirty = 0;
  1961.       pPg->inJournal = 0;
  1962.       pHist->inStmt = 0;
  1963.       pPg->needSync = 0;
  1964.       pHist->pPrevStmt = pHist->pNextStmt = 0;
  1965.       pPg = pPg->pDirty;
  1966.     }
  1967.     pPager->pDirty = 0;
  1968. #ifndef NDEBUG
  1969.     for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
  1970.       PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
  1971.       assert( !pPg->alwaysRollback );
  1972.       assert( !pHist->pOrig );
  1973.       assert( !pHist->pStmt );
  1974.     }
  1975. #endif
  1976.     pPager->pStmt = 0;
  1977.     pPager->state = PAGER_SHARED;
  1978.     pagerLeave(pPager);
  1979.     return SQLITE_OK;
  1980.   }
  1981.   assert( pPager->journalOpen || !pPager->dirtyCache );
  1982.   assert( pPager->state==PAGER_SYNCED || !pPager->dirtyCache );
  1983.   rc = pager_end_transaction(pPager);
  1984.   rc = pager_error(pPager, rc);
  1985.   pagerLeave(pPager);
  1986.   return rc;
  1987. }
  1988. /*
  1989. ** Rollback all changes.  The database falls back to PAGER_SHARED mode.
  1990. ** All in-memory cache pages revert to their original data contents.
  1991. ** The journal is deleted.
  1992. **
  1993. ** This routine cannot fail unless some other process is not following
  1994. ** the correct locking protocol or unless some other
  1995. ** process is writing trash into the journal file (SQLITE_CORRUPT) or
  1996. ** unless a prior malloc() failed (SQLITE_NOMEM).  Appropriate error
  1997. ** codes are returned for all these occasions.  Otherwise,
  1998. ** SQLITE_OK is returned.
  1999. */
  2000. int sqlite3PagerRollback(Pager *pPager){
  2001.   int rc;
  2002.   PAGERTRACE2("ROLLBACK %dn", PAGERID(pPager));
  2003.   if( MEMDB ){
  2004.     PgHdr *p;
  2005.     for(p=pPager->pAll; p; p=p->pNextAll){
  2006.       PgHistory *pHist;
  2007.       assert( !p->alwaysRollback );
  2008.       if( !p->dirty ){
  2009.         assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pOrig );
  2010.         assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pStmt );
  2011.         continue;
  2012.       }
  2013.       pHist = PGHDR_TO_HIST(p, pPager);
  2014.       if( pHist->pOrig ){
  2015.         memcpy(PGHDR_TO_DATA(p), pHist->pOrig, pPager->pageSize);
  2016.         PAGERTRACE3("ROLLBACK-PAGE %d of %dn", p->pgno, PAGERID(pPager));
  2017.       }else{
  2018.         PAGERTRACE3("PAGE %d is clean on %dn", p->pgno, PAGERID(pPager));
  2019.       }
  2020.       clearHistory(pHist);
  2021.       p->dirty = 0;
  2022.       p->inJournal = 0;
  2023.       pHist->inStmt = 0;
  2024.       pHist->pPrevStmt = pHist->pNextStmt = 0;
  2025.       if( pPager->xReiniter ){
  2026.         pPager->xReiniter(p, pPager->pageSize);
  2027.       }
  2028.     }
  2029.     pPager->pDirty = 0;
  2030.     pPager->pStmt = 0;
  2031.     pPager->dbSize = pPager->origDbSize;
  2032.     pager_truncate_cache(pPager);
  2033.     pPager->stmtInUse = 0;
  2034.     pPager->state = PAGER_SHARED;
  2035.     return SQLITE_OK;
  2036.   }
  2037.   pagerEnter(pPager);
  2038.   if( !pPager->dirtyCache || !pPager->journalOpen ){
  2039.     rc = pager_end_transaction(pPager);
  2040.     pagerLeave(pPager);
  2041.     return rc;
  2042.   }
  2043.   if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
  2044.     if( pPager->state>=PAGER_EXCLUSIVE ){
  2045.       pager_playback(pPager, 0);
  2046.     }
  2047.     pagerLeave(pPager);
  2048.     return pPager->errCode;
  2049.   }
  2050.   if( pPager->state==PAGER_RESERVED ){
  2051.     int rc2;
  2052.     rc = pager_playback(pPager, 0);
  2053.     rc2 = pager_end_transaction(pPager);
  2054.     if( rc==SQLITE_OK ){
  2055.       rc = rc2;
  2056.     }
  2057.   }else{
  2058.     rc = pager_playback(pPager, 0);
  2059.   }
  2060.   /* pager_reset(pPager); */
  2061.   pPager->dbSize = -1;
  2062.   /* If an error occurs during a ROLLBACK, we can no longer trust the pager
  2063.   ** cache. So call pager_error() on the way out to make any error 
  2064.   ** persistent.
  2065.   */
  2066.   rc = pager_error(pPager, rc);
  2067.   pagerLeave(pPager);
  2068.   return rc;
  2069. }
  2070. /*
  2071. ** Return TRUE if the database file is opened read-only.  Return FALSE
  2072. ** if the database is (in theory) writable.
  2073. */
  2074. int sqlite3PagerIsreadonly(Pager *pPager){
  2075.   return pPager->readOnly;
  2076. }
  2077. /*
  2078. ** Return the number of references to the pager.
  2079. */
  2080. int sqlite3PagerRefcount(Pager *pPager){
  2081.   return pPager->nRef;
  2082. }
  2083. #ifdef SQLITE_TEST
  2084. /*
  2085. ** This routine is used for testing and analysis only.
  2086. */
  2087. int *sqlite3PagerStats(Pager *pPager){
  2088.   static int a[11];
  2089.   a[0] = pPager->nRef;
  2090.   a[1] = pPager->nPage;
  2091.   a[2] = pPager->mxPage;
  2092.   a[3] = pPager->dbSize;
  2093.   a[4] = pPager->state;
  2094.   a[5] = pPager->errCode;
  2095.   a[6] = pPager->nHit;
  2096.   a[7] = pPager->nMiss;
  2097.   a[8] = 0;  /* Used to be pPager->nOvfl */
  2098.   a[9] = pPager->nRead;
  2099.   a[10] = pPager->nWrite;
  2100.   return a;
  2101. }
  2102. #endif
  2103. /*
  2104. ** Set the statement rollback point.
  2105. **
  2106. ** This routine should be called with the transaction journal already
  2107. ** open.  A new statement journal is created that can be used to rollback
  2108. ** changes of a single SQL command within a larger transaction.
  2109. */
  2110. static int pagerStmtBegin(Pager *pPager){
  2111.   int rc;
  2112.   assert( !pPager->stmtInUse );
  2113.   assert( pPager->state>=PAGER_SHARED );
  2114.   assert( pPager->dbSize>=0 );
  2115.   PAGERTRACE2("STMT-BEGIN %dn", PAGERID(pPager));
  2116.   if( MEMDB ){
  2117.     pPager->stmtInUse = 1;
  2118.     pPager->stmtSize = pPager->dbSize;
  2119.     return SQLITE_OK;
  2120.   }
  2121.   if( !pPager->journalOpen ){
  2122.     pPager->stmtAutoopen = 1;
  2123.     return SQLITE_OK;
  2124.   }
  2125.   assert( pPager->journalOpen );
  2126.   pagerLeave(pPager);
  2127.   assert( pPager->pInStmt==0 );
  2128.   pPager->pInStmt = sqlite3BitvecCreate(pPager->dbSize);
  2129.   pagerEnter(pPager);
  2130.   if( pPager->pInStmt==0 ){
  2131.     /* sqlite3OsLock(pPager->fd, SHARED_LOCK); */
  2132.     return SQLITE_NOMEM;
  2133.   }
  2134. #ifndef NDEBUG
  2135.   rc = sqlite3OsFileSize(pPager->jfd, &pPager->stmtJSize);
  2136.   if( rc ) goto stmt_begin_failed;
  2137.   assert( pPager->stmtJSize == pPager->journalOff );
  2138. #endif
  2139.   pPager->stmtJSize = pPager->journalOff;
  2140.   pPager->stmtSize = pPager->dbSize;
  2141.   pPager->stmtHdrOff = 0;
  2142.   pPager->stmtCksum = pPager->cksumInit;
  2143.   if( !pPager->stmtOpen ){
  2144.     rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->stfd, pPager->zStmtJrnl,
  2145.                               SQLITE_OPEN_SUBJOURNAL);
  2146.     if( rc ){
  2147.       goto stmt_begin_failed;
  2148.     }
  2149.     pPager->stmtOpen = 1;
  2150.     pPager->stmtNRec = 0;
  2151.   }
  2152.   pPager->stmtInUse = 1;
  2153.   return SQLITE_OK;
  2154.  
  2155. stmt_begin_failed:
  2156.   if( pPager->pInStmt ){
  2157.     sqlite3BitvecDestroy(pPager->pInStmt);
  2158.     pPager->pInStmt = 0;
  2159.   }
  2160.   return rc;
  2161. }
  2162. int sqlite3PagerStmtBegin(Pager *pPager){
  2163.   int rc;
  2164.   pagerEnter(pPager);
  2165.   rc = pagerStmtBegin(pPager);
  2166.   pagerLeave(pPager);
  2167.   return rc;
  2168. }
  2169. /*
  2170. ** Commit a statement.
  2171. */
  2172. int sqlite3PagerStmtCommit(Pager *pPager){
  2173.   pagerEnter(pPager);
  2174.   if( pPager->stmtInUse ){
  2175.     PgHdr *pPg, *pNext;
  2176.     PAGERTRACE2("STMT-COMMIT %dn", PAGERID(pPager));
  2177.     if( !MEMDB ){
  2178.       /* sqlite3OsTruncate(pPager->stfd, 0); */
  2179.       sqlite3BitvecDestroy(pPager->pInStmt);
  2180.       pPager->pInStmt = 0;
  2181.     }else{
  2182.       for(pPg=pPager->pStmt; pPg; pPg=pNext){
  2183.         PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
  2184.         pNext = pHist->pNextStmt;
  2185.         assert( pHist->inStmt );
  2186.         pHist->inStmt = 0;
  2187.         pHist->pPrevStmt = pHist->pNextStmt = 0;
  2188.         sqlite3_free(pHist->pStmt);
  2189.         pHist->pStmt = 0;
  2190.       }
  2191.     }
  2192.     pPager->stmtNRec = 0;
  2193.     pPager->stmtInUse = 0;
  2194.     pPager->pStmt = 0;
  2195.   }
  2196.   pPager->stmtAutoopen = 0;
  2197.   pagerLeave(pPager);
  2198.   return SQLITE_OK;
  2199. }
  2200. /*
  2201. ** Rollback a statement.
  2202. */
  2203. int sqlite3PagerStmtRollback(Pager *pPager){
  2204.   int rc;
  2205.   pagerEnter(pPager);
  2206.   if( pPager->stmtInUse ){
  2207.     PAGERTRACE2("STMT-ROLLBACK %dn", PAGERID(pPager));
  2208.     if( MEMDB ){
  2209.       PgHdr *pPg;
  2210.       PgHistory *pHist;
  2211.       for(pPg=pPager->pStmt; pPg; pPg=pHist->pNextStmt){
  2212.         pHist = PGHDR_TO_HIST(pPg, pPager);
  2213.         if( pHist->pStmt ){
  2214.           memcpy(PGHDR_TO_DATA(pPg), pHist->pStmt, pPager->pageSize);
  2215.           sqlite3_free(pHist->pStmt);
  2216.           pHist->pStmt = 0;
  2217.         }
  2218.       }
  2219.       pPager->dbSize = pPager->stmtSize;
  2220.       pager_truncate_cache(pPager);
  2221.       rc = SQLITE_OK;
  2222.     }else{
  2223.       rc = pager_stmt_playback(pPager);
  2224.     }
  2225.     sqlite3PagerStmtCommit(pPager);
  2226.   }else{
  2227.     rc = SQLITE_OK;
  2228.   }
  2229.   pPager->stmtAutoopen = 0;
  2230.   pagerLeave(pPager);
  2231.   return rc;
  2232. }
  2233. /*
  2234. ** Return the full pathname of the database file.
  2235. */
  2236. const char *sqlite3PagerFilename(Pager *pPager){
  2237.   return pPager->zFilename;
  2238. }
  2239. /*
  2240. ** Return the VFS structure for the pager.
  2241. */
  2242. const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
  2243.   return pPager->pVfs;
  2244. }
  2245. /*
  2246. ** Return the file handle for the database file associated
  2247. ** with the pager.  This might return NULL if the file has
  2248. ** not yet been opened.
  2249. */
  2250. sqlite3_file *sqlite3PagerFile(Pager *pPager){
  2251.   return pPager->fd;
  2252. }
  2253. /*
  2254. ** Return the directory of the database file.
  2255. */
  2256. const char *sqlite3PagerDirname(Pager *pPager){
  2257.   return pPager->zDirectory;
  2258. }
  2259. /*
  2260. ** Return the full pathname of the journal file.
  2261. */
  2262. const char *sqlite3PagerJournalname(Pager *pPager){
  2263.   return pPager->zJournal;
  2264. }
  2265. /*
  2266. ** Return true if fsync() calls are disabled for this pager.  Return FALSE
  2267. ** if fsync()s are executed normally.
  2268. */
  2269. int sqlite3PagerNosync(Pager *pPager){
  2270.   return pPager->noSync;
  2271. }
  2272. #ifdef SQLITE_HAS_CODEC
  2273. /*
  2274. ** Set the codec for this pager
  2275. */
  2276. void sqlite3PagerSetCodec(
  2277.   Pager *pPager,
  2278.   void *(*xCodec)(void*,void*,Pgno,int),
  2279.   void *pCodecArg
  2280. ){
  2281.   pPager->xCodec = xCodec;
  2282.   pPager->pCodecArg = pCodecArg;
  2283. }
  2284. #endif
  2285. #ifndef SQLITE_OMIT_AUTOVACUUM
  2286. /*
  2287. ** Move the page pPg to location pgno in the file.
  2288. **
  2289. ** There must be no references to the page previously located at
  2290. ** pgno (which we call pPgOld) though that page is allowed to be
  2291. ** in cache.  If the page previous located at pgno is not already
  2292. ** in the rollback journal, it is not put there by by this routine.
  2293. **
  2294. ** References to the page pPg remain valid. Updating any
  2295. ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
  2296. ** allocated along with the page) is the responsibility of the caller.
  2297. **
  2298. ** A transaction must be active when this routine is called. It used to be
  2299. ** required that a statement transaction was not active, but this restriction
  2300. ** has been removed (CREATE INDEX needs to move a page when a statement
  2301. ** transaction is active).
  2302. */
  2303. int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno){
  2304.   PgHdr *pPgOld;  /* The page being overwritten. */
  2305.   int h;
  2306.   Pgno needSyncPgno = 0;
  2307.   pagerEnter(pPager);
  2308.   assert( pPg->nRef>0 );
  2309.   PAGERTRACE5("MOVE %d page %d (needSync=%d) moves to %dn", 
  2310.       PAGERID(pPager), pPg->pgno, pPg->needSync, pgno);
  2311.   IOTRACE(("MOVE %p %d %dn", pPager, pPg->pgno, pgno))
  2312.   pager_get_content(pPg);
  2313.   if( pPg->needSync ){
  2314.     needSyncPgno = pPg->pgno;
  2315.     assert( pPg->inJournal || (int)pgno>pPager->origDbSize );
  2316.     assert( pPg->dirty );
  2317.     assert( pPager->needSync );
  2318.   }
  2319.   /* Unlink pPg from its hash-chain */
  2320.   unlinkHashChain(pPager, pPg);
  2321.   /* If the cache contains a page with page-number pgno, remove it
  2322.   ** from its hash chain. Also, if the PgHdr.needSync was set for 
  2323.   ** page pgno before the 'move' operation, it needs to be retained 
  2324.   ** for the page moved there.
  2325.   */
  2326.   pPg->needSync = 0;
  2327.   pPgOld = pager_lookup(pPager, pgno);
  2328.   if( pPgOld ){
  2329.     assert( pPgOld->nRef==0 );
  2330.     unlinkHashChain(pPager, pPgOld);
  2331.     makeClean(pPgOld);
  2332.     pPg->needSync = pPgOld->needSync;
  2333.   }else{
  2334.     pPg->needSync = 0;
  2335.   }
  2336.   pPg->inJournal = sqlite3BitvecTest(pPager->pInJournal, pgno);
  2337.   /* Change the page number for pPg and insert it into the new hash-chain. */
  2338.   assert( pgno!=0 );
  2339.   pPg->pgno = pgno;
  2340.   h = pgno & (pPager->nHash-1);
  2341.   if( pPager->aHash[h] ){
  2342.     assert( pPager->aHash[h]->pPrevHash==0 );
  2343.     pPager->aHash[h]->pPrevHash = pPg;
  2344.   }
  2345.   pPg->pNextHash = pPager->aHash[h];
  2346.   pPager->aHash[h] = pPg;
  2347.   pPg->pPrevHash = 0;
  2348.   makeDirty(pPg);
  2349.   pPager->dirtyCache = 1;
  2350.   if( needSyncPgno ){
  2351.     /* If needSyncPgno is non-zero, then the journal file needs to be 
  2352.     ** sync()ed before any data is written to database file page needSyncPgno.
  2353.     ** Currently, no such page exists in the page-cache and the 
  2354.     ** Pager.pInJournal bit has been set. This needs to be remedied by loading
  2355.     ** the page into the pager-cache and setting the PgHdr.needSync flag.
  2356.     **
  2357.     ** If the attempt to load the page into the page-cache fails, (due
  2358.     ** to a malloc() or IO failure), clear the bit in the pInJournal[]
  2359.     ** array. Otherwise, if the page is loaded and written again in
  2360.     ** this transaction, it may be written to the database file before
  2361.     ** it is synced into the journal file. This way, it may end up in
  2362.     ** the journal file twice, but that is not a problem.
  2363.     **
  2364.     ** The sqlite3PagerGet() call may cause the journal to sync. So make
  2365.     ** sure the Pager.needSync flag is set too.
  2366.     */
  2367.     int rc;
  2368.     PgHdr *pPgHdr;
  2369.     assert( pPager->needSync );
  2370.     rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
  2371.     if( rc!=SQLITE_OK ){
  2372.       if( pPager->pInJournal && (int)needSyncPgno<=pPager->origDbSize ){
  2373.         sqlite3BitvecClear(pPager->pInJournal, needSyncPgno);
  2374.       }
  2375.       pagerLeave(pPager);
  2376.       return rc;
  2377.     }
  2378.     pPager->needSync = 1;
  2379.     pPgHdr->needSync = 1;
  2380.     pPgHdr->inJournal = 1;
  2381.     makeDirty(pPgHdr);
  2382.     sqlite3PagerUnref(pPgHdr);
  2383.   }
  2384.   pagerLeave(pPager);
  2385.   return SQLITE_OK;
  2386. }
  2387. #endif
  2388. /*
  2389. ** Return a pointer to the data for the specified page.
  2390. */
  2391. void *sqlite3PagerGetData(DbPage *pPg){
  2392.   return PGHDR_TO_DATA(pPg);
  2393. }
  2394. /*
  2395. ** Return a pointer to the Pager.nExtra bytes of "extra" space 
  2396. ** allocated along with the specified page.
  2397. */
  2398. void *sqlite3PagerGetExtra(DbPage *pPg){
  2399.   Pager *pPager = pPg->pPager;
  2400.   return (pPager?PGHDR_TO_EXTRA(pPg, pPager):0);
  2401. }
  2402. /*
  2403. ** Get/set the locking-mode for this pager. Parameter eMode must be one
  2404. ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or 
  2405. ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
  2406. ** the locking-mode is set to the value specified.
  2407. **
  2408. ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
  2409. ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
  2410. ** locking-mode.
  2411. */
  2412. int sqlite3PagerLockingMode(Pager *pPager, int eMode){
  2413.   assert( eMode==PAGER_LOCKINGMODE_QUERY
  2414.             || eMode==PAGER_LOCKINGMODE_NORMAL
  2415.             || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
  2416.   assert( PAGER_LOCKINGMODE_QUERY<0 );
  2417.   assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
  2418.   if( eMode>=0 && !pPager->tempFile ){
  2419.     pPager->exclusiveMode = eMode;
  2420.   }
  2421.   return (int)pPager->exclusiveMode;
  2422. }
  2423. #ifdef SQLITE_TEST
  2424. /*
  2425. ** Print a listing of all referenced pages and their ref count.
  2426. */
  2427. void sqlite3PagerRefdump(Pager *pPager){
  2428.   PgHdr *pPg;
  2429.   for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
  2430.     if( pPg->nRef<=0 ) continue;
  2431.     sqlite3DebugPrintf("PAGE %3d addr=%p nRef=%dn", 
  2432.        pPg->pgno, PGHDR_TO_DATA(pPg), pPg->nRef);
  2433.   }
  2434. }
  2435. #endif
  2436. #endif /* SQLITE_OMIT_DISKIO */