Lines Matching defs:pWal
34114 SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *);
34123 SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *);
34124 SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal);
34127 SQLITE_PRIVATE int sqlite3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
34130 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal);
34133 SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal);
34134 SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal);
34137 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
34141 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
34145 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
34148 SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
34152 Wal *pWal, /* Write-ahead log connection */
34163 SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal);
34168 SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op);
34837 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
34934 return (pPager->pWal!=0);
35886 sqlite3WalEndReadTransaction(pPager->pWal);
36116 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
36120 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
36955 rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
37055 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
37081 assert( pPager->pWal );
37082 rc = sqlite3WalFrames(pPager->pWal,
37122 sqlite3WalEndReadTransaction(pPager->pWal);
37124 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
37145 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
37152 nPage = sqlite3WalDbsize(pPager->pWal);
37365 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
37805 sqlite3WalClose(pPager->pWal,
37809 pPager->pWal = 0;
38932 assert( pPager->pWal==0 || rc==SQLITE_OK );
39277 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
39282 sqlite3WalExclusiveMode(pPager->pWal, 1);
39290 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
40171 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
40673 if( pPager->pWal ){
40675 rc = sqlite3WalCheckpoint(pPager->pWal,
40684 return sqlite3WalCallback(pPager->pWal);
40721 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
40723 if( !pPager->tempFile && !pPager->pWal ){
40733 rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, &pPager->pWal);
40763 if( !pPager->pWal ){
40773 pPager->zWal, &pPager->pWal);
40780 if( rc==SQLITE_OK && pPager->pWal ){
40783 rc = sqlite3WalClose(pPager->pWal,
40787 pPager->pWal = 0;
41313 static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){
41316 /* Enlarge the pWal->apWiData[] array if required */
41317 if( pWal->nWiData<=iPage ){
41320 apNew = (volatile u32 **)sqlite3_realloc((void *)pWal->apWiData, nByte);
41325 memset((void*)&apNew[pWal->nWiData], 0,
41326 sizeof(u32*)*(iPage+1-pWal->nWiData));
41327 pWal->apWiData = apNew;
41328 pWal->nWiData = iPage+1;
41332 if( pWal->apWiData[iPage]==0 ){
41333 rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
41334 pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
41338 *ppPage = pWal->apWiData[iPage];
41346 static volatile WalCkptInfo *walCkptInfo(Wal *pWal){
41347 assert( pWal->nWiData>0 && pWal->apWiData[0] );
41348 return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
41354 static volatile WalIndexHdr *walIndexHdr(Wal *pWal){
41355 assert( pWal->nWiData>0 && pWal->apWiData[0] );
41356 return (volatile WalIndexHdr*)pWal->apWiData[0];
41419 ** Write the header information in pWal->hdr into the wal-index.
41421 ** The checksum on pWal->hdr is updated before it is written.
41423 static void walIndexWriteHdr(Wal *pWal){
41424 volatile WalIndexHdr *aHdr = walIndexHdr(pWal);
41427 assert( pWal->writeLock );
41428 pWal->hdr.isInit = 1;
41429 pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
41430 walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
41431 memcpy((void *)&aHdr[1], (void *)&pWal->hdr, sizeof(WalIndexHdr));
41432 sqlite3OsShmBarrier(pWal->pDbFd);
41433 memcpy((void *)&aHdr[0], (void *)&pWal->hdr, sizeof(WalIndexHdr));
41450 Wal *pWal, /* The write-ahead log */
41457 u32 *aCksum = pWal->hdr.aFrameCksum;
41461 memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
41463 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
41465 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
41477 Wal *pWal, /* The write-ahead log */
41484 u32 *aCksum = pWal->hdr.aFrameCksum;
41491 if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
41507 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
41509 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
41555 static int walLockShared(Wal *pWal, int lockIdx){
41557 if( pWal->exclusiveMode ) return SQLITE_OK;
41558 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
41560 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
41562 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
41565 static void walUnlockShared(Wal *pWal, int lockIdx){
41566 if( pWal->exclusiveMode ) return;
41567 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
41569 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
41571 static int walLockExclusive(Wal *pWal, int lockIdx, int n){
41573 if( pWal->exclusiveMode ) return SQLITE_OK;
41574 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
41576 WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,
41578 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
41581 static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){
41582 if( pWal->exclusiveMode ) return;
41583 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
41585 WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,
41618 Wal *pWal, /* WAL handle */
41627 rc = walIndexPage(pWal, iHash, &aPgno);
41669 static u32 walFramePgno(Wal *pWal, u32 iFrame){
41672 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
41674 return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
41679 ** than pWal->hdr.mxFrame.
41681 ** This function is called whenever pWal->hdr.mxFrame is decreased due
41684 ** At most only the hash table containing pWal->hdr.mxFrame needs to be
41686 ** pWal->hdr.mxFrame advances to the point where those hash tables are
41689 static void walCleanupHash(Wal *pWal){
41697 assert( pWal->writeLock );
41698 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
41699 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
41700 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
41702 if( pWal->hdr.mxFrame==0 ) return;
41705 ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
41708 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
41709 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
41710 walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &aHash, &aPgno, &iZero);
41713 ** than pWal->hdr.mxFrame.
41715 iLimit = pWal->hdr.mxFrame - iZero;
41724 ** frame numbers greater than pWal->hdr.mxFrame.
41751 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
41757 rc = walHashGet(pWal, walFramePage(iFrame), &aHash, &aPgno, &iZero);
41785 walCleanupHash(pWal);
41840 static int walIndexRecover(Wal *pWal){
41853 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
41856 assert( pWal->writeLock );
41857 iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
41859 rc = walLockExclusive(pWal, iLock, nLock);
41863 WALTRACE(("WAL%p: recovery begin...\n", pWal));
41865 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
41867 rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
41884 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
41903 pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
41904 pWal->szPage = szPage;
41905 pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
41906 memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
41909 walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,
41910 aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
41912 if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
41913 || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
41943 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
41945 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
41947 rc = walIndexAppend(pWal, ++iFrame, pgno);
41952 pWal->hdr.mxFrame = iFrame;
41953 pWal->hdr.nPage = nTruncate;
41954 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
41957 aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
41958 aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
41969 pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
41970 pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
41971 walIndexWriteHdr(pWal);
41977 pInfo = walCkptInfo(pWal);
41987 if( pWal->hdr.nPage ){
41989 pWal->hdr.nPage, pWal->zWalName
41995 WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));
41996 walUnlockExclusive(pWal, iLock, nLock);
42003 static void walIndexClose(Wal *pWal, int isDelete){
42004 sqlite3OsShmUnmap(pWal->pDbFd, isDelete);
42238 static int walIteratorInit(Wal *pWal, WalIterator **pp){
42250 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
42251 iLast = pWal->hdr.mxFrame;
42280 rc = walHashGet(pWal, i, &aHash, &aPgno, &iZero);
42346 Wal *pWal, /* Wal connection */
42361 szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
42364 if( pWal->hdr.mxFrame==0 ) return SQLITE_OK;
42367 rc = walIteratorInit(pWal, &pIter);
42384 mxSafeFrame = pWal->hdr.mxFrame;
42385 mxPage = pWal->hdr.nPage;
42386 pInfo = walCkptInfo(pWal);
42390 assert( y<=pWal->hdr.mxFrame );
42391 rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
42394 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
42404 && (rc = walLockExclusive(pWal, WAL_READ_LOCK(0), 1))==SQLITE_OK
42411 rc = sqlite3OsSync(pWal->pWalFd, sync_flags);
42419 rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
42421 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT, &nReq);
42428 assert( walFramePgno(pWal, iFrame)==iDbpage );
42432 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
42436 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
42442 if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
42443 i64 szDb = pWal->hdr.nPage*(i64)szPage;
42445 rc = sqlite3OsTruncate(pWal->pDbFd, szDb);
42447 rc = sqlite3OsSync(pWal->pDbFd, sync_flags);
42456 walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
42473 Wal *pWal, /* Wal to close */
42479 if( pWal ){
42490 rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE);
42492 pWal->exclusiveMode = 1;
42493 rc = sqlite3WalCheckpoint(pWal, sync_flags, nBuf, zBuf);
42499 walIndexClose(pWal, isDelete);
42500 sqlite3OsClose(pWal->pWalFd);
42502 sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
42504 WALTRACE(("WAL%p: closed\n", pWal));
42505 sqlite3_free((void *)pWal->apWiData);
42506 sqlite3_free(pWal);
42522 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
42528 static int walIndexTryHdr(Wal *pWal, int *pChanged){
42534 assert( pWal->nWiData>0 && pWal->apWiData[0] );
42546 aHdr = walIndexHdr(pWal);
42548 sqlite3OsShmBarrier(pWal->pDbFd);
42562 if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){
42564 memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
42565 pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
42566 testcase( pWal->szPage<=32768 );
42567 testcase( pWal->szPage>=65536 );
42575 ** Read the wal-index header from the wal-index and into pWal->hdr.
42579 ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is
42580 ** changed by this opertion. If pWal->hdr is unchanged, set *pChanged
42586 static int walIndexReadHdr(Wal *pWal, int *pChanged){
42595 rc = walIndexPage(pWal, 0, &page0);
42599 assert( page0 || pWal->writeLock==0 );
42606 badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1);
42611 assert( badHdr==0 || pWal->writeLock==0 );
42612 if( badHdr && SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
42613 pWal->writeLock = 1;
42614 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
42615 badHdr = walIndexTryHdr(pWal, pChanged);
42621 rc = walIndexRecover(pWal);
42625 pWal->writeLock = 0;
42626 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
42633 if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
42658 ** to make a copy of the wal-index header into pWal->hdr. If the
42676 ** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is
42677 ** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1)
42680 ** including frame number aReadMark[pWal->readLock]. The reader will
42681 ** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0
42682 ** Or if pWal->readLock==0, then the reader will ignore the WAL
42685 ** this routine will always set pWal->readLock>0 on success.
42687 ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.
42696 static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){
42703 assert( pWal->readLock<0 ); /* Not currently locked */
42708 sqlite3OsSleep(pWal->pVfs, 1);
42712 rc = walIndexReadHdr(pWal, pChanged);
42722 if( pWal->apWiData[0]==0 ){
42731 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
42732 walUnlockShared(pWal, WAL_RECOVER_LOCK);
42743 pInfo = walCkptInfo(pWal);
42744 if( !useWal && pInfo->nBackfill==pWal->hdr.mxFrame ){
42748 rc = walLockShared(pWal, WAL_READ_LOCK(0));
42749 sqlite3OsShmBarrier(pWal->pDbFd);
42751 if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){
42765 walUnlockShared(pWal, WAL_READ_LOCK(0));
42768 pWal->readLock = 0;
42778 ** but not exceeding pWal->hdr.mxFrame and lock that entry.
42784 if( mxReadMark<=thisMark && thisMark<=pWal->hdr.mxFrame ){
42795 rc = walLockExclusive(pWal, WAL_READ_LOCK(1), 1);
42797 pInfo->aReadMark[1] = pWal->hdr.mxFrame;
42798 walUnlockExclusive(pWal, WAL_READ_LOCK(1), 1);
42805 if( mxReadMark < pWal->hdr.mxFrame ){
42807 rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
42809 mxReadMark = pInfo->aReadMark[i] = pWal->hdr.mxFrame;
42811 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
42819 rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
42831 ** that occur later in the log than pWal->hdr.mxFrame may have been
42834 ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry
42843 sqlite3OsShmBarrier(pWal->pDbFd);
42845 || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
42847 walUnlockShared(pWal, WAL_READ_LOCK(mxI));
42850 assert( mxReadMark<=pWal->hdr.mxFrame );
42851 pWal->readLock = (i16)mxI;
42871 SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){
42876 rc = walTryBeginRead(pWal, pChanged, 0, ++cnt);
42885 SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){
42886 sqlite3WalEndWriteTransaction(pWal);
42887 if( pWal->readLock>=0 ){
42888 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
42889 pWal->readLock = -1;
42902 Wal *pWal, /* WAL handle */
42909 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
42913 assert( pWal->readLock>=0 || pWal->lockError );
42917 ** in this case as an optimization. Likewise, if pWal->readLock==0,
42921 if( iLast==0 || pWal->readLock==0 ){
42959 rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);
42984 if( walFramePgno(pWal, iTest)==pgno ){
42999 sz = pWal->hdr.szPage;
43000 sz = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
43006 return sqlite3OsRead(pWal->pWalFd, pOut, nOut, iOffset);
43017 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){
43018 if( pWal && ALWAYS(pWal->readLock>=0) ){
43019 return pWal->hdr.nPage;
43038 SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){
43043 assert( pWal->readLock>=0 );
43045 if( pWal->readOnly ){
43052 rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
43056 pWal->writeLock = 1;
43062 if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
43063 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
43064 pWal->writeLock = 0;
43075 SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
43076 if( pWal->writeLock ){
43077 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
43078 pWal->writeLock = 0;
43095 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
43097 if( ALWAYS(pWal->writeLock) ){
43098 Pgno iMax = pWal->hdr.mxFrame;
43104 memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
43106 for(iFrame=pWal->hdr.mxFrame+1;
43121 assert( walFramePgno(pWal, iFrame)!=1 );
43122 rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));
43124 walCleanupHash(pWal);
43136 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
43137 assert( pWal->writeLock );
43138 aWalData[0] = pWal->hdr.mxFrame;
43139 aWalData[1] = pWal->hdr.aFrameCksum[0];
43140 aWalData[2] = pWal->hdr.aFrameCksum[1];
43141 aWalData[3] = pWal->nCkpt;
43150 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
43153 assert( pWal->writeLock );
43154 assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
43156 if( aWalData[3]!=pWal->nCkpt ){
43162 aWalData[3] = pWal->nCkpt;
43165 if( aWalData[0]<pWal->hdr.mxFrame ){
43166 pWal->hdr.mxFrame = aWalData[0];
43167 pWal->hdr.aFrameCksum[0] = aWalData[1];
43168 pWal->hdr.aFrameCksum[1] = aWalData[2];
43169 walCleanupHash(pWal);
43180 ** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left
43184 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
43187 static int walRestartLog(Wal *pWal){
43191 if( pWal->readLock==0 ){
43192 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
43193 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
43195 rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
43208 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
43209 pWal->nCkpt++;
43210 pWal->hdr.mxFrame = 0;
43213 walIndexWriteHdr(pWal);
43217 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
43220 walUnlockShared(pWal, WAL_READ_LOCK(0));
43221 pWal->readLock = -1;
43225 rc = walTryBeginRead(pWal, ¬Used, 1, ++cnt);
43236 Wal *pWal, /* Wal handle to write to */
43251 assert( pWal->writeLock );
43256 pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
43261 ** log file, instead of appending to it at pWal->hdr.mxFrame.
43263 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
43271 iFrame = pWal->hdr.mxFrame;
43279 sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);
43280 sqlite3_randomness(8, pWal->hdr.aSalt);
43281 memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
43286 pWal->szPage = szPage;
43287 pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN;
43288 pWal->hdr.aFrameCksum[0] = aCksum[0];
43289 pWal->hdr.aFrameCksum[1] = aCksum[1];
43291 rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
43292 WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
43297 assert( pWal->szPage==szPage );
43315 walEncodeFrame(pWal, p->pgno, nDbsize, pData, aFrame);
43316 rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
43322 rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOffset+sizeof(aFrame));
43331 i64 iSegment = sqlite3OsSectorSize(pWal->pWalFd);
43345 walEncodeFrame(pWal, pLast->pgno, nTruncate, pData, aFrame);
43347 rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
43352 rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOffset);
43360 rc = sqlite3OsSync(pWal->pWalFd, sync_flags);
43368 iFrame = pWal->hdr.mxFrame;
43371 rc = walIndexAppend(pWal, iFrame, p->pgno);
43376 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
43381 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
43384 pWal->hdr.mxFrame = iFrame;
43386 pWal->hdr.iChange++;
43387 pWal->hdr.nPage = nTruncate;
43391 walIndexWriteHdr(pWal);
43392 pWal->iCallback = iFrame;
43396 WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok"));
43408 Wal *pWal, /* Wal connection */
43416 assert( pWal->ckptLock==0 );
43418 WALTRACE(("WAL%p: checkpoint begins\n", pWal));
43419 rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
43426 pWal->ckptLock = 1;
43429 rc = walIndexReadHdr(pWal, &isChanged);
43431 rc = walCheckpoint(pWal, sync_flags, nBuf, zBuf);
43435 ** performed, then the pager-cache associated with pWal is now
43440 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
43444 walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
43445 pWal->ckptLock = 0;
43446 WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok"));
43455 SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal){
43457 if( pWal ){
43458 ret = pWal->iCallback;
43459 pWal->iCallback = 0;
43470 ** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL
43477 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
43488 SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){
43490 assert( pWal->writeLock==0 );
43492 /* pWal->readLock is usually set, but might be -1 if there was a
43498 assert( pWal->readLock>=0 || pWal->lockError );
43499 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
43502 if( pWal->exclusiveMode ){
43503 pWal->exclusiveMode = 0;
43504 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
43505 pWal->exclusiveMode = 1;
43507 rc = pWal->exclusiveMode==0;
43513 assert( pWal->exclusiveMode==0 );
43514 assert( pWal->readLock>=0 );
43515 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
43516 pWal->exclusiveMode = 1;
43519 rc = pWal->exclusiveMode==0;