Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes to src/pager.c.

   341    341   */
   342    342   #define PAGER_UNLOCK      0
   343    343   #define PAGER_SHARED      1   /* same as SHARED_LOCK */
   344    344   #define PAGER_RESERVED    2   /* same as RESERVED_LOCK */
   345    345   #define PAGER_EXCLUSIVE   4   /* same as EXCLUSIVE_LOCK */
   346    346   #define PAGER_SYNCED      5
   347    347   
          348  +#define UNKNOWN_LOCK      (EXCLUSIVE_LOCK+1)
          349  +
   348    350   /*
   349    351   ** A macro used for invoking the codec if there is one
   350    352   */
   351    353   #ifdef SQLITE_HAS_CODEC
   352    354   # define CODEC1(P,D,N,X,E) \
   353    355       if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
   354    356   # define CODEC2(P,D,N,X,E,O) \
................................................................................
   717    719     ** on the file.
   718    720     */
   719    721     assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
   720    722   
   721    723     switch( p->eState ){
   722    724       case PAGER_NONE:
   723    725         assert( !MEMDB );
   724         -      assert( !p->tempFile );
   725    726         assert( pPager->errCode==SQLITE_OK );
   726         -      assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
          727  +      assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
   727    728         break;
   728    729   
   729    730       case PAGER_READER:
   730    731         assert( pPager->errCode==SQLITE_OK );
          732  +      assert( p->eLock!=UNKNOWN_LOCK );
   731    733         assert( p->eLock>=SHARED_LOCK || p->noReadlock );
   732    734         break;
   733    735   
   734    736       case PAGER_WRITER_INITIAL:
          737  +      assert( p->eLock!=UNKNOWN_LOCK );
   735    738         assert( pPager->errCode==SQLITE_OK );
   736    739         if( !pagerUseWal(pPager) ){
   737    740           assert( p->eLock>=RESERVED_LOCK );
   738    741         }
   739    742         assert( pPager->dbSize==pPager->dbOrigSize );
   740    743         assert( pPager->dbOrigSize==pPager->dbFileSize );
   741    744         assert( pPager->setMaster==0 );
   742    745         break;
   743    746   
   744    747       case PAGER_WRITER_CACHEMOD:
          748  +      assert( p->eLock!=UNKNOWN_LOCK );
   745    749         assert( pPager->errCode==SQLITE_OK );
   746    750         if( !pagerUseWal(pPager) ){
   747    751           /* It is possible that if journal_mode=wal here that neither the
   748    752           ** journal file nor the WAL file are open. This happens during
   749    753           ** a rollback transaction that switches from journal_mode=off
   750    754           ** to journal_mode=wal.
   751    755           */
................................................................................
   755    759                || p->journalMode==PAGER_JOURNALMODE_WAL 
   756    760           );
   757    761         }
   758    762         assert( pPager->dbOrigSize==pPager->dbFileSize );
   759    763         break;
   760    764   
   761    765       case PAGER_WRITER_DBMOD:
          766  +      assert( p->eLock==EXCLUSIVE_LOCK );
   762    767         assert( pPager->errCode==SQLITE_OK );
   763    768         assert( !pagerUseWal(pPager) );
   764         -      assert( p->eLock>=EXCLUSIVE_LOCK || pagerUseWal(pPager) );
          769  +      assert( p->eLock>=EXCLUSIVE_LOCK );
   765    770         assert( isOpen(p->jfd) 
   766    771              || p->journalMode==PAGER_JOURNALMODE_OFF 
   767    772              || p->journalMode==PAGER_JOURNALMODE_WAL 
   768    773         );
   769    774         break;
   770    775   
   771    776       case PAGER_WRITER_FINISHED:
          777  +      assert( p->eLock==EXCLUSIVE_LOCK );
   772    778         assert( pPager->errCode==SQLITE_OK );
   773    779         assert( !pagerUseWal(pPager) );
   774         -      assert( p->eLock>=EXCLUSIVE_LOCK || pagerUseWal(pPager) );
   775    780         assert( isOpen(p->jfd) 
   776    781              || p->journalMode==PAGER_JOURNALMODE_OFF 
   777    782              || p->journalMode==PAGER_JOURNALMODE_WAL 
   778    783         );
   779    784         break;
   780    785   
   781    786       case PAGER_ERROR:
................................................................................
   794    799   /*
   795    800   ** (gdb) printf "%s", print_pager_state(pPager)
   796    801   */
   797    802   static char *print_pager_state(Pager *p){
   798    803     static char zRet[1024];
   799    804   
   800    805     sqlite3_snprintf(1024, zRet,
   801         -      "State:         %s\n"
          806  +      "State:         %s errCode=%d\n"
   802    807         "Lock:          %s\n"
   803    808         "Locking mode:  locking_mode=%s\n"
   804    809         "Journal mode:  journal_mode=%s\n"
   805    810         "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
          811  +      "Journal:       journalOff=%lld journalHdr=%lld\n"
   806    812         , p->eState==PAGER_NONE            ? "NONE" :
   807    813           p->eState==PAGER_READER          ? "READER" :
   808    814           p->eState==PAGER_WRITER_INITIAL  ? "WRITER_INITIAL" :
   809    815           p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
   810    816           p->eState==PAGER_WRITER_DBMOD    ? "WRITER_DBMOD" :
   811    817           p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
   812    818           p->eState==PAGER_ERROR           ? "ERROR" : "?error?"
          819  +      , (int)p->errCode
   813    820         , p->eLock==NO_LOCK         ? "NONE" :
   814    821           p->eLock==RESERVED_LOCK   ? "RESERVED" :
   815    822           p->eLock==EXCLUSIVE_LOCK  ? "EXCLUSIVE" :
   816         -        p->eLock==SHARED_LOCK     ? "SHARED" : "?error?"
          823  +        p->eLock==SHARED_LOCK     ? "SHARED" :
          824  +        p->eLock==UNKNOWN_LOCK    ? "UNKNOWN" : "?error?"
   817    825         , p->exclusiveMode ? "exclusive" : "normal"
   818    826         , p->journalMode==PAGER_JOURNALMODE_MEMORY   ? "memory" :
   819    827           p->journalMode==PAGER_JOURNALMODE_OFF      ? "off" :
   820    828           p->journalMode==PAGER_JOURNALMODE_DELETE   ? "delete" :
   821    829           p->journalMode==PAGER_JOURNALMODE_PERSIST  ? "persist" :
   822    830           p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
   823    831           p->journalMode==PAGER_JOURNALMODE_WAL      ? "wal" : "?error?"
   824    832         , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
          833  +      , p->journalOff, p->journalHdr
   825    834     );
   826    835   
   827    836     return zRet;
   828    837   }
   829    838   #endif
   830    839   
   831    840   /*
................................................................................
   886    895   static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
   887    896     char ac[4];
   888    897     put32bits(ac, val);
   889    898     return sqlite3OsWrite(fd, ac, 4, offset);
   890    899   }
   891    900   
   892    901   /*
   893         -** If file pFd is open, call sqlite3OsUnlock() on it.
          902  +** This function and pagerLockDb() are wrappers around sqlite3OsLock() and
          903  +** sqlite3OsUnlock() that set the Pager.eLock variable to reflect the
          904  +** current lock held on the database file.
   894    905   */
   895         -static int osUnlock(Pager *pPager, int eLock){
          906  +static int pagerUnlockDb(Pager *pPager, int eLock){
   896    907     int rc = SQLITE_OK;
          908  +  assert( !pPager->exclusiveMode );
   897    909     if( isOpen(pPager->fd) ){
   898    910       assert( pPager->eLock>=eLock );
   899    911       assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
   900    912       rc = sqlite3OsUnlock(pPager->fd, eLock);
   901         -    if( rc==SQLITE_OK ){
          913  +    if( pPager->eLock!=UNKNOWN_LOCK ){
   902    914         pPager->eLock = eLock;
   903    915       }
          916  +    IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
   904    917     }
   905    918     return rc;
   906    919   }
   907    920   
   908         -static int osLock(Pager *pPager, int eLock){
          921  +static int pagerLockDb(Pager *pPager, int eLock){
   909    922     int rc;
   910    923     assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
   911         -  if( pPager->eLock>=eLock ){
          924  +  if( pPager->eLock>=eLock && pPager->eLock!=UNKNOWN_LOCK ){
   912    925       rc = SQLITE_OK;
   913    926     }else{
   914    927       rc = sqlite3OsLock(pPager->fd, eLock);
   915         -    if( rc==SQLITE_OK ){
          928  +    if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
   916    929         pPager->eLock = eLock;
   917         -      IOTRACE(("LOCK %p %d\n", pPager, locktype))
          930  +      IOTRACE(("LOCK %p %d\n", pPager, eLock))
   918    931       }
   919    932     }
   920    933     return rc;
   921    934   }
   922    935   
   923    936   /*
   924    937   ** This function determines whether or not the atomic-write optimization
................................................................................
  1546   1559     releaseAllSavepoints(pPager);
  1547   1560   
  1548   1561     if( pagerUseWal(pPager) ){
  1549   1562       assert( !isOpen(pPager->jfd) );
  1550   1563       sqlite3WalEndReadTransaction(pPager->pWal);
  1551   1564       pPager->eState = PAGER_NONE;
  1552   1565     }else if( !pPager->exclusiveMode ){
         1566  +    int rc;                       /* Error code returned by pagerUnlockDb() */
  1553   1567       int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
  1554   1568   
  1555   1569       /* If the operating system support deletion of open files, then
  1556   1570       ** close the journal file when dropping the database lock.  Otherwise
  1557   1571       ** another connection with journal_mode=delete might delete the file
  1558   1572       ** out from under us.
  1559   1573       */
................................................................................
  1564   1578       assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
  1565   1579       assert( (PAGER_JOURNALMODE_PERSIST  & 5)==1 );
  1566   1580       if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
  1567   1581        || 1!=(pPager->journalMode & 5)
  1568   1582       ){
  1569   1583         sqlite3OsClose(pPager->jfd);
  1570   1584       }
  1571         -    osUnlock(pPager, NO_LOCK);
         1585  +
         1586  +    rc = pagerUnlockDb(pPager, NO_LOCK);
         1587  +    if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
         1588  +      pPager->eLock = UNKNOWN_LOCK;
         1589  +    }
  1572   1590   
  1573   1591       /* The pager state may be changed from PAGER_ERROR to PAGER_NONE here
  1574   1592       ** without clearing the error code. This is intentional - the error
  1575   1593       ** code is cleared and the cache reset in the block below.
  1576   1594       */
  1577   1595       assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
  1578   1596       pPager->changeCountDone = 0;
  1579   1597       pPager->eState = PAGER_NONE;
  1580         -    IOTRACE(("UNLOCK %p\n", pPager))
  1581   1598     }
  1582   1599   
  1583   1600     /* If Pager.errCode is set, the contents of the pager cache cannot be
  1584   1601     ** trusted. Now that there are no outstanding references to the pager,
  1585   1602     ** it can safely move back to PAGER_NONE state. This happens in both
  1586   1603     ** normal and exclusive-locking mode.
  1587   1604     */
  1588         -  if( pPager->errCode && !pPager->tempFile ){
         1605  +  if( pPager->errCode && !MEMDB ){
  1589   1606       pager_reset(pPager);
  1590         -    pPager->changeCountDone = 0;
         1607  +    pPager->changeCountDone = pPager->tempFile;
  1591   1608       pPager->eState = PAGER_NONE;
  1592   1609       pPager->errCode = SQLITE_OK;
  1593   1610     }
         1611  +
         1612  +  pPager->journalOff = 0;
         1613  +  pPager->journalHdr = 0;
         1614  +  pPager->setMaster = 0;
  1594   1615   }
  1595   1616   
  1596   1617   /*
  1597   1618   ** This function should be called when an IOERR, CORRUPT or FULL error
  1598   1619   ** may have occurred. The first argument is a pointer to the pager 
  1599   1620   ** structure, the second the error-code about to be returned by a pager 
  1600   1621   ** API function. The value returned is a copy of the second argument 
................................................................................
  1748   1769       */
  1749   1770       rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
  1750   1771       assert( rc2==SQLITE_OK );
  1751   1772     }
  1752   1773     if( !pPager->exclusiveMode 
  1753   1774      && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
  1754   1775     ){
  1755         -    rc2 = osUnlock(pPager, SHARED_LOCK);
         1776  +    rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
  1756   1777       pPager->changeCountDone = 0;
  1757   1778     }
  1758   1779     pPager->eState = PAGER_READER;
  1759   1780     pPager->setMaster = 0;
  1760   1781   
  1761   1782     return (rc==SQLITE_OK?rc2:rc);
  1762   1783   }
................................................................................
  1930   1951   
  1931   1952     /* If this page has already been played by before during the current
  1932   1953     ** rollback, then don't bother to play it back again.
  1933   1954     */
  1934   1955     if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
  1935   1956       return rc;
  1936   1957     }
  1937         -  assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
         1958  +  assert( pPager->eState>=PAGER_WRITER_CACHEMOD 
         1959  +       || (pPager->eState==PAGER_NONE && isMainJrnl)
         1960  +  );
  1938   1961   
  1939   1962     /* When playing back page 1, restore the nReserve setting
  1940   1963     */
  1941   1964     if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
  1942   1965       pPager->nReserve = ((u8*)aData)[20];
  1943   1966       pagerReportSize(pPager);
  1944   1967     }
................................................................................
  1986   2009              (isMainJrnl?"main-journal":"sub-journal")
  1987   2010     ));
  1988   2011     if( isMainJrnl ){
  1989   2012       isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
  1990   2013     }else{
  1991   2014       isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
  1992   2015     }
  1993         -  if( (pPager->eState>=PAGER_WRITER_DBMOD)
         2016  +  if( (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_NONE)
  1994   2017      && isOpen(pPager->fd)
  1995   2018      && isSynced
  1996   2019     ){
  1997   2020       i64 ofst = (pgno-1)*(i64)pPager->pageSize;
  1998   2021       testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
  1999   2022       assert( !pagerUseWal(pPager) );
  2000   2023       rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
................................................................................
  2235   2258   **
  2236   2259   ** If successful, return SQLITE_OK. If an IO error occurs while modifying
  2237   2260   ** the database file, return the error code to the caller.
  2238   2261   */
  2239   2262   static int pager_truncate(Pager *pPager, Pgno nPage){
  2240   2263     int rc = SQLITE_OK;
  2241   2264     assert( pPager->eState!=PAGER_ERROR );
  2242         -  if( pPager->eState>=PAGER_WRITER_DBMOD && isOpen(pPager->fd) ){
         2265  +  assert( pPager->eState!=PAGER_READER );
         2266  +  
         2267  +  if( isOpen(pPager->fd) 
         2268  +   && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_NONE) 
         2269  +  ){
  2243   2270       i64 currentSize, newSize;
  2244   2271       /* TODO: Is it safe to use Pager.dbFileSize here? */
  2245   2272       rc = sqlite3OsFileSize(pPager->fd, &currentSize);
  2246   2273       newSize = pPager->pageSize*(i64)nPage;
  2247   2274       if( rc==SQLITE_OK && currentSize!=newSize ){
  2248   2275         if( currentSize>newSize ){
  2249   2276           rc = sqlite3OsTruncate(pPager->fd, newSize);
................................................................................
  2813   2840       }else{
  2814   2841         rc = sqlite3OsAccess(
  2815   2842             pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
  2816   2843         );
  2817   2844       }
  2818   2845       if( rc==SQLITE_OK ){
  2819   2846         if( isWal ){
  2820         -        assert( sqlite3PcachePagecount(pPager->pPCache)==0 );
         2847  +        testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
  2821   2848           rc = sqlite3PagerOpenWal(pPager, 0);
  2822   2849           if( rc==SQLITE_OK ){
  2823   2850             rc = pagerBeginReadTransaction(pPager);
  2824   2851           }
  2825   2852         }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
  2826   2853           pPager->journalMode = PAGER_JOURNALMODE_DELETE;
  2827   2854         }
................................................................................
  3140   3167           rc = sqlite3OsFileSize(pPager->fd, &nByte);
  3141   3168           if( rc!=SQLITE_OK ) return rc;
  3142   3169         }
  3143   3170         pNew = (char *)sqlite3PageMalloc(pageSize);
  3144   3171         if( !pNew ){
  3145   3172           rc = SQLITE_NOMEM;
  3146   3173         }else{
  3147         -        assert( pPager->eState==PAGER_NONE || pPager->eState==PAGER_READER );
  3148   3174           pager_reset(pPager);
  3149   3175           pPager->dbSize = nByte/pageSize;
  3150   3176           pPager->pageSize = pageSize;
  3151   3177           sqlite3PageFree(pPager->pTmpSpace);
  3152   3178           pPager->pTmpSpace = pNew;
  3153   3179           sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
  3154   3180         }
................................................................................
  3293   3319     ** sqlite3PagerSetBusyhandler().
  3294   3320     */
  3295   3321     assert( (pPager->eLock>=locktype)
  3296   3322          || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
  3297   3323          || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
  3298   3324     );
  3299   3325   
  3300         -  if( pPager->eLock>=locktype ){
  3301         -    rc = SQLITE_OK;
  3302         -  }else{
  3303         -    do {
  3304         -      rc = osLock(pPager, locktype);
  3305         -    }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
  3306         -  }
         3326  +  do {
         3327  +    rc = pagerLockDb(pPager, locktype);
         3328  +  }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
  3307   3329     return rc;
  3308   3330   }
  3309   3331   
  3310   3332   /*
  3311   3333   ** Function assertTruncateConstraint(pPager) checks that one of the 
  3312   3334   ** following is true for all dirty pages currently in the page-cache:
  3313   3335   **
................................................................................
  4296   4318         ** a RESERVED lock to avoid race conditions and to avoid violating
  4297   4319         ** [H33020].
  4298   4320         */
  4299   4321         rc = pagerPagecount(pPager, &nPage);
  4300   4322         if( rc==SQLITE_OK ){
  4301   4323           if( nPage==0 ){
  4302   4324             sqlite3BeginBenignMalloc();
  4303         -          if( osLock(pPager, RESERVED_LOCK)==SQLITE_OK ){
         4325  +          if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
  4304   4326               sqlite3OsDelete(pVfs, pPager->zJournal, 0);
  4305         -            osUnlock(pPager, SHARED_LOCK);
         4327  +            pagerUnlockDb(pPager, SHARED_LOCK);
  4306   4328             }
  4307   4329             sqlite3EndBenignMalloc();
  4308   4330           }else{
  4309   4331             /* The journal file exists and no other connection has a reserved
  4310   4332             ** or greater lock on the database file. Now check that there is
  4311   4333             ** at least one non-zero bytes at the start of the journal file.
  4312   4334             ** If there is, then we consider this journal to be hot. If not, 
................................................................................
  4384   4406   
  4385   4407     /* This routine is only called from b-tree and only when there are no
  4386   4408     ** outstanding pages. This implies that the pager state should either
  4387   4409     ** be NONE or READER. READER is only possible if the pager is or was in 
  4388   4410     ** exclusive access mode.
  4389   4411     */
  4390   4412     assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
         4413  +  assert( assert_pager_state(pPager) );
  4391   4414     assert( pPager->eState==PAGER_NONE || pPager->eState==PAGER_READER );
  4392         -  assert( assert_pager_state(pPager) );
  4393   4415     if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
  4394   4416   
  4395   4417     if( !pagerUseWal(pPager) && pPager->eState==PAGER_NONE ){
  4396   4418       int bHotJournal = 1;          /* True if there exists a hot journal-file */
  4397   4419   
  4398         -    assert( !MEMDB && !pPager->tempFile );
         4420  +    assert( !MEMDB );
  4399   4421       assert( pPager->noReadlock==0 || pPager->readOnly );
  4400   4422   
  4401   4423       if( pPager->noReadlock==0 ){
  4402   4424         rc = pager_wait_on_lock(pPager, SHARED_LOCK);
  4403   4425         if( rc!=SQLITE_OK ){
  4404   4426           assert( pPager->eLock==PAGER_UNLOCK );
  4405   4427           goto failed;
................................................................................
  4427   4449         ** other process attempting to access the database file will get to 
  4428   4450         ** this point in the code and fail to obtain its own EXCLUSIVE lock 
  4429   4451         ** on the database file.
  4430   4452         **
  4431   4453         ** Unless the pager is in locking_mode=exclusive mode, the lock is
  4432   4454         ** downgraded to SHARED_LOCK before this function returns.
  4433   4455         */
  4434         -      rc = osLock(pPager, EXCLUSIVE_LOCK);
         4456  +      rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
  4435   4457         if( rc!=SQLITE_OK ){
  4436   4458           goto failed;
  4437   4459         }
  4438   4460    
  4439   4461         /* If it is not already open and the file exists on disk, open the 
  4440   4462         ** journal for read/write access. Write access is required because 
  4441   4463         ** in exclusive-access mode the file descriptor will be kept open 
................................................................................
  4462   4484             assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
  4463   4485             if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
  4464   4486               rc = SQLITE_CANTOPEN_BKPT;
  4465   4487               sqlite3OsClose(pPager->jfd);
  4466   4488             }
  4467   4489           }
  4468   4490         }
  4469         -      if( rc!=SQLITE_OK ){
  4470         -        goto failed;
  4471         -      }
  4472         -
  4473         -      /* Reset the journal status fields to indicates that we have no
  4474         -      ** rollback journal at this time. */
  4475         -      pPager->journalOff = 0;
  4476         -      pPager->setMaster = 0;
  4477         -      pPager->journalHdr = 0;
  4478         - 
  4479         -      /* Make sure the journal file has been synced to disk. */
  4480   4491    
  4481   4492         /* Playback and delete the journal.  Drop the database write
  4482   4493         ** lock and reacquire the read lock. Purge the cache before
  4483   4494         ** playing back the hot-journal so that we don't end up with
  4484   4495         ** an inconsistent cache.  Sync the hot journal before playing
  4485   4496         ** it back since the process that crashed and left the hot journal
  4486   4497         ** probably did not sync it and we are required to always sync
  4487   4498         ** the journal before playing it back.
  4488         -      **
  4489         -      ** Even if an error occurs while syncing or rolling back the 
  4490         -      ** hot-journal, there is no need to enter the ERROR state here, as
  4491         -      ** the pager never left state NONE anyhow.
  4492   4499         */
  4493   4500         if( isOpen(pPager->jfd) ){
         4501  +        assert( rc==SQLITE_OK );
  4494   4502           rc = pagerSyncHotJournal(pPager);
  4495   4503           if( rc==SQLITE_OK ){
  4496         -          assert( pPager->eState==PAGER_NONE );
  4497         -          pPager->eState = PAGER_WRITER_FINISHED;
  4498   4504             rc = pager_playback(pPager, 1);
  4499   4505             pPager->eState = PAGER_NONE;
  4500   4506           }
  4501         -        if( rc!=SQLITE_OK ){
  4502         -          goto failed;
  4503         -        }
  4504         -      }else{
  4505         -        osUnlock(pPager, SHARED_LOCK);
         4507  +      }else if( !pPager->exclusiveMode ){
         4508  +        pagerUnlockDb(pPager, SHARED_LOCK);
         4509  +      }
         4510  +
         4511  +      if( rc!=SQLITE_OK ){
         4512  +        pager_error(pPager, rc);
         4513  +        goto failed;
  4506   4514         }
  4507   4515   
  4508   4516         assert( pPager->eState==PAGER_NONE );
  4509   4517         assert( (pPager->eLock==SHARED_LOCK)
  4510   4518              || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
  4511   4519         );
  4512   4520       }
  4513   4521   
  4514         -    if( pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0 ){
         4522  +    if( !pPager->tempFile 
         4523  +     && (pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0) 
         4524  +    ){
  4515   4525         /* The shared-lock has just been acquired on the database file
  4516   4526         ** and there are already pages in the cache (from a previous
  4517   4527         ** read or write transaction).  Check to see if the database
  4518   4528         ** has been modified.  If the database has changed, flush the
  4519   4529         ** cache.
  4520   4530         **
  4521   4531         ** Database changes is detected by looking at 15 bytes beginning
................................................................................
  4902   4912       assert( pPager->pInJournal==0 );
  4903   4913   
  4904   4914       if( pagerUseWal(pPager) ){
  4905   4915         /* If the pager is configured to use locking_mode=exclusive, and an
  4906   4916         ** exclusive lock on the database is not already held, obtain it now.
  4907   4917         */
  4908   4918         if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
  4909         -        rc = osLock(pPager, EXCLUSIVE_LOCK);
         4919  +        rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
  4910   4920           if( rc!=SQLITE_OK ){
  4911   4921             return rc;
  4912   4922           }
  4913   4923           sqlite3WalExclusiveMode(pPager->pWal, 1);
  4914   4924         }
  4915   4925   
  4916   4926         /* Grab the write lock on the log file. If successful, upgrade to
................................................................................
  4921   4931         rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
  4922   4932       }else{
  4923   4933         /* Obtain a RESERVED lock on the database file. If the exFlag parameter
  4924   4934         ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
  4925   4935         ** busy-handler callback can be used when upgrading to the EXCLUSIVE
  4926   4936         ** lock, but not when obtaining the RESERVED lock.
  4927   4937         */
  4928         -      rc = osLock(pPager, RESERVED_LOCK);
         4938  +      rc = pagerLockDb(pPager, RESERVED_LOCK);
  4929   4939         if( rc==SQLITE_OK && exFlag ){
  4930   4940           rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
  4931   4941         }
  4932   4942       }
  4933   4943   
  4934   4944   
  4935   4945       if( rc==SQLITE_OK ){
................................................................................
  5870   5880   ** then savepoint iSavepoint is also destroyed.
  5871   5881   **
  5872   5882   ** This function may return SQLITE_NOMEM if a memory allocation fails,
  5873   5883   ** or an IO error code if an IO error occurs while rolling back a 
  5874   5884   ** savepoint. If no errors occur, SQLITE_OK is returned.
  5875   5885   */ 
  5876   5886   int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
  5877         -  int rc = SQLITE_OK;
         5887  +  int rc = pPager->errCode;       /* Return code */
  5878   5888   
  5879   5889     assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
  5880   5890     assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
  5881   5891   
  5882         -  if( iSavepoint<pPager->nSavepoint ){
         5892  +  if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
  5883   5893       int ii;            /* Iterator variable */
  5884   5894       int nNew;          /* Number of remaining savepoints after this op. */
  5885   5895   
  5886   5896       /* Figure out how many savepoints will still be active after this
  5887   5897       ** operation. Store this value in nNew. Then free resources associated 
  5888   5898       ** with any savepoints that are destroyed by this operation.
  5889   5899       */
................................................................................
  5911   5921       ** the database file, so the playback operation can be skipped.
  5912   5922       */
  5913   5923       else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
  5914   5924         PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
  5915   5925         rc = pagerPlaybackSavepoint(pPager, pSavepoint);
  5916   5926         assert(rc!=SQLITE_DONE);
  5917   5927       }
  5918         -  
  5919   5928     }
         5929  +
  5920   5930     return rc;
  5921   5931   }
  5922   5932   
  5923   5933   /*
  5924   5934   ** Return the full pathname of the database file.
  5925   5935   */
  5926   5936   const char *sqlite3PagerFilename(Pager *pPager){
................................................................................
  6087   6097         sqlite3PcacheDrop(pPgOld);
  6088   6098       }
  6089   6099     }
  6090   6100   
  6091   6101     origPgno = pPg->pgno;
  6092   6102     sqlite3PcacheMove(pPg, pgno);
  6093   6103     sqlite3PcacheMakeDirty(pPg);
         6104  +
         6105  +  /* For an in-memory database, make sure the original page continues
         6106  +  ** to exist, in case the transaction needs to roll back.  Use pPgOld
         6107  +  ** as the original page since it has already been allocated.
         6108  +  */
         6109  +  if( MEMDB ){
         6110  +    assert( pPgOld );
         6111  +    sqlite3PcacheMove(pPgOld, origPgno);
         6112  +    sqlite3PagerUnref(pPgOld);
         6113  +  }
  6094   6114   
  6095   6115     if( needSyncPgno ){
  6096   6116       /* If needSyncPgno is non-zero, then the journal file needs to be 
  6097   6117       ** sync()ed before any data is written to database file page needSyncPgno.
  6098   6118       ** Currently, no such page exists in the page-cache and the 
  6099   6119       ** "is journaled" bitvec flag has been set. This needs to be remedied by
  6100   6120       ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
................................................................................
  6117   6137         return rc;
  6118   6138       }
  6119   6139       pPgHdr->flags |= PGHDR_NEED_SYNC;
  6120   6140       sqlite3PcacheMakeDirty(pPgHdr);
  6121   6141       sqlite3PagerUnref(pPgHdr);
  6122   6142     }
  6123   6143   
  6124         -  /*
  6125         -  ** For an in-memory database, make sure the original page continues
  6126         -  ** to exist, in case the transaction needs to roll back.  Use pPgOld
  6127         -  ** as the original page since it has already been allocated.
  6128         -  */
  6129         -  if( MEMDB ){
  6130         -    sqlite3PcacheMove(pPgOld, origPgno);
  6131         -    sqlite3PagerUnref(pPgOld);
  6132         -  }
  6133         -
  6134   6144     return SQLITE_OK;
  6135   6145   }
  6136   6146   #endif
  6137   6147   
  6138   6148   /*
  6139   6149   ** Return a pointer to the data for the specified page.
  6140   6150   */
................................................................................
  6217   6227       assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
  6218   6228       if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
  6219   6229         eMode = eOld;
  6220   6230       }
  6221   6231     }
  6222   6232   
  6223   6233     if( eMode!=eOld ){
  6224         -    /* When changing between rollback modes, close the journal file prior
  6225         -    ** to the change.  But when changing from a rollback mode to WAL, keep
  6226         -    ** the journal open since there is a rollback-style transaction in play
  6227         -    ** used to convert the version numbers in the btree header.
  6228         -    */
  6229         -    if( isOpen(pPager->jfd) && eMode!=PAGER_JOURNALMODE_WAL ){
  6230         -      sqlite3OsClose(pPager->jfd);
  6231         -    }
  6232   6234   
  6233   6235       /* Change the journal mode. */
  6234   6236       pPager->journalMode = (u8)eMode;
  6235   6237   
  6236   6238       /* When transistioning from TRUNCATE or PERSIST to any other journal
  6237   6239       ** mode except WAL (and we are not in locking_mode=EXCLUSIVE) then 
  6238   6240       ** delete the journal file.
................................................................................
  6242   6244       assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
  6243   6245       assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
  6244   6246       assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
  6245   6247       assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
  6246   6248   
  6247   6249       assert( isOpen(pPager->fd) || pPager->exclusiveMode );
  6248   6250       if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
         6251  +
         6252  +      sqlite3OsClose(pPager->jfd);
  6249   6253   
  6250   6254         /* In this case we would like to delete the journal file. If it is
  6251   6255         ** not possible, then that is not a problem. Deleting the journal file
  6252   6256         ** here is an optimization only.
  6253   6257         **
  6254   6258         ** Before deleting the journal file, obtain a RESERVED lock on the
  6255   6259         ** database file. This ensures that the journal file is not deleted
................................................................................
  6258   6262         int rc = SQLITE_OK;
  6259   6263         int state = pPager->eState;
  6260   6264         if( state==PAGER_NONE ){
  6261   6265           rc = sqlite3PagerSharedLock(pPager);
  6262   6266         }
  6263   6267         if( pPager->eState==PAGER_READER ){
  6264   6268           assert( rc==SQLITE_OK );
  6265         -        rc = osLock(pPager, RESERVED_LOCK);
         6269  +        rc = pagerLockDb(pPager, RESERVED_LOCK);
  6266   6270         }
  6267   6271         if( rc==SQLITE_OK ){
  6268   6272           sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
  6269   6273         }
  6270   6274         if( rc==SQLITE_OK && state==PAGER_READER ){
  6271         -        osUnlock(pPager, SHARED_LOCK);
         6275  +        pagerUnlockDb(pPager, SHARED_LOCK);
  6272   6276         }else if( state==PAGER_NONE ){
  6273   6277           pager_unlock(pPager);
  6274   6278         }
  6275   6279         assert( state==pPager->eState );
  6276   6280       }
  6277   6281     }
  6278   6282   
................................................................................
  6289   6293   
  6290   6294   /*
  6291   6295   ** Return TRUE if the pager is in a state where it is OK to change the
  6292   6296   ** journalmode.  Journalmode changes can only happen when the database
  6293   6297   ** is unmodified.
  6294   6298   */
  6295   6299   int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
         6300  +  assert( assert_pager_state(pPager) );
  6296   6301     if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
  6297   6302     if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
  6298   6303     return 1;
  6299   6304   }
  6300   6305   
  6301   6306   /*
  6302   6307   ** Get/set the size-limit used for persistent journal files.
................................................................................
  6375   6380     assert( pPager->eState==PAGER_NONE   || pbOpen );
  6376   6381     assert( pPager->eState==PAGER_READER || !pbOpen );
  6377   6382     assert( pbOpen==0 || *pbOpen==0 );
  6378   6383     assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
  6379   6384   
  6380   6385     if( !pPager->tempFile && !pPager->pWal ){
  6381   6386       if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
         6387  +
         6388  +    if( isOpen(pPager->jfd) ){
         6389  +      sqlite3OsClose(pPager->jfd);
         6390  +    }
  6382   6391   
  6383   6392       /* Open the connection to the log file. If this operation fails, 
  6384   6393       ** (e.g. due to malloc() failure), unlock the database file and 
  6385   6394       ** return an error code.
  6386   6395       */
  6387   6396       rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, &pPager->pWal);
  6388   6397       if( rc==SQLITE_OK ){
................................................................................
  6412   6421   
  6413   6422     /* If the log file is not already open, but does exist in the file-system,
  6414   6423     ** it may need to be checkpointed before the connection can switch to
  6415   6424     ** rollback mode. Open it now so this can happen.
  6416   6425     */
  6417   6426     if( !pPager->pWal ){
  6418   6427       int logexists = 0;
  6419         -    rc = osLock(pPager, SHARED_LOCK);
         6428  +    rc = pagerLockDb(pPager, SHARED_LOCK);
  6420   6429       if( rc==SQLITE_OK ){
  6421   6430         rc = sqlite3OsAccess(
  6422   6431             pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
  6423   6432         );
  6424   6433       }
  6425   6434       if( rc==SQLITE_OK && logexists ){
  6426   6435         rc = sqlite3WalOpen(pPager->pVfs, pPager->fd,
................................................................................
  6428   6437       }
  6429   6438     }
  6430   6439       
  6431   6440     /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
  6432   6441     ** the database file, the log and log-summary files will be deleted.
  6433   6442     */
  6434   6443     if( rc==SQLITE_OK && pPager->pWal ){
  6435         -    rc = osLock(pPager, EXCLUSIVE_LOCK);
         6444  +    rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
  6436   6445       if( rc==SQLITE_OK ){
  6437   6446         rc = sqlite3WalClose(pPager->pWal,
  6438   6447                              (pPager->noSync ? 0 : pPager->sync_flags), 
  6439   6448           pPager->pageSize, (u8*)pPager->pTmpSpace
  6440   6449         );
  6441   6450         pPager->pWal = 0;
  6442   6451       }else{
  6443   6452         /* If we cannot get an EXCLUSIVE lock, downgrade the PENDING lock
  6444   6453         ** that we did get back to SHARED. */
  6445         -      osUnlock(pPager, SQLITE_LOCK_SHARED);
         6454  +      pagerUnlockDb(pPager, SQLITE_LOCK_SHARED);
  6446   6455       }
  6447   6456     }
  6448   6457     return rc;
  6449   6458   }
  6450   6459   
  6451   6460   #ifdef SQLITE_HAS_CODEC
  6452   6461   /*