Lines Matching refs:pWal
57978 SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, sqlite3*, int sync_flags, int, u8 *);
57990 SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *);
57991 SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal);
57998 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal);
58001 SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal);
58002 SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal);
58005 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
58009 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
58013 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
58016 SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
58020 Wal *pWal, /* Write-ahead log connection */
58037 SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal);
58042 SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op);
58048 SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal);
58051 SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot);
58052 SQLITE_PRIVATE void sqlite3WalSnapshotOpen(Wal *pWal, sqlite3_snapshot *pSnapshot);
58053 SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal);
58054 SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot);
58055 SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal);
58062 SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal);
58066 SQLITE_PRIVATE sqlite3_file *sqlite3WalFile(Wal *pWal);
58069 SQLITE_PRIVATE int sqlite3WalWriteLock(Wal *pWal, int bLock);
58070 SQLITE_PRIVATE void sqlite3WalDb(Wal *pWal, sqlite3 *db);
58758 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */ member
58869 if( pPager->pWal ){
58871 (void)sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
58885 # define pagerUseWal(x) ((x)->pWal!=0)
59917 sqlite3WalEndWriteTransaction(pPager->pWal);
59919 sqlite3WalEndReadTransaction(pPager->pWal);
60198 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
60217 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
61088 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
61092 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
61215 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
61245 assert( pPager->pWal );
61275 rc = sqlite3WalFrames(pPager->pWal,
61314 sqlite3WalEndReadTransaction(pPager->pWal);
61316 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
61348 nPage = sqlite3WalDbsize(pPager->pWal);
61553 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
62231 assert( db || pPager->pWal==0 );
62237 sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
62238 pPager->pWal = 0;
63479 assert( pPager->pWal==0 || rc==SQLITE_OK );
63715 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
63977 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
63982 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
63990 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
64998 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
65162 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
65375 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
65376 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
65517 sqlite3WalLimit(pPager->pWal, iLimit);
65559 if( pPager->pWal==0 && pPager->journalMode==PAGER_JOURNALMODE_WAL ){
65571 if( pPager->pWal ){
65572 rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
65583 return sqlite3WalCallback(pPager->pWal);
65625 assert( pPager->pWal==0 && pPager->tempFile==0 );
65643 pPager->journalSizeLimit, &pPager->pWal
65647 sqlite3WalDb(pPager->pWal, pPager->dbWal);
65682 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
65684 if( !pPager->tempFile && !pPager->pWal ){
65720 if( !pPager->pWal ){
65736 if( rc==SQLITE_OK && pPager->pWal ){
65739 rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
65741 pPager->pWal = 0;
65759 rc = sqlite3WalWriteLock(pPager->pWal, bLock);
65771 sqlite3WalDb(pPager->pWal, db);
65783 if( pPager->pWal ){
65784 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
65799 if( pPager->pWal ){
65800 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
65813 if( pPager->pWal ){
65814 rc = sqlite3WalSnapshotRecover(pPager->pWal);
65835 if( pPager->pWal ){
65836 rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot);
65848 assert( pPager->pWal );
65849 sqlite3WalSnapshotUnlock(pPager->pWal);
65865 return sqlite3WalFramesize(pPager->pWal);
65871 return sqlite3WalSystemErrno(pPager->pWal);
66525 assert( walAssertLockmask(pWal) && pWal->nSehTry==0 ); \
66526 VVA_ONLY(pWal->nSehTry++);
66530 VVA_ONLY(pWal->nSehTry--); \
66531 assert( pWal->nSehTry==0 ); \
66532 } __except( sehExceptionFilter(pWal, GetExceptionCode(), GetExceptionInformation() ) ){ X }
66535 # define SEH_INJECT_FAULT sehInjectFault(pWal)
66543 static int sehExceptionFilter(Wal *pWal, int eCode, EXCEPTION_POINTERS *p){
66544 VVA_ONLY(pWal->nSehTry--);
66552 pWal->iSysErrno = (int)p->ExceptionRecord->ExceptionInformation[2];
66565 static void sehInjectFault(Wal *pWal){
66567 assert( pWal->nSehTry>0 );
66593 assert( (X==0 || Y==0) && pWal->pFree==X ); pWal->pFree = Y
66605 #define SEH_SET_ON_ERROR(X,Y) pWal->iWiPg = X; pWal->pWiValue = Y
66608 # define SEH_TRY VVA_ONLY(pWal->nSehTry++);
66609 # define SEH_EXCEPT(X) VVA_ONLY(pWal->nSehTry--); assert( pWal->nSehTry==0 );
66610 # define SEH_INJECT_FAULT assert( pWal->nSehTry>0 );
66635 Wal *pWal, /* The WAL context */
66642 if( pWal->nWiData<=iPage ){
66645 apNew = (volatile u32 **)sqlite3Realloc((void *)pWal->apWiData, nByte);
66650 memset((void*)&apNew[pWal->nWiData], 0,
66651 sizeof(u32*)*(iPage+1-pWal->nWiData));
66652 pWal->apWiData = apNew;
66653 pWal->nWiData = iPage+1;
66657 assert( pWal->apWiData[iPage]==0 );
66658 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
66659 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
66660 if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT;
66662 rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
66663 pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
66665 assert( pWal->apWiData[iPage]!=0
66667 || (pWal->writeLock==0 && iPage==0) );
66668 testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
66672 pWal->readOnly |= WAL_SHM_RDONLY;
66679 *ppPage = pWal->apWiData[iPage];
66684 Wal *pWal, /* The WAL context */
66689 if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){
66690 return walIndexPageRealloc(pWal, iPage, ppPage);
66698 static volatile WalCkptInfo *walCkptInfo(Wal *pWal){
66699 assert( pWal->nWiData>0 && pWal->apWiData[0] );
66701 return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
66707 static volatile WalIndexHdr *walIndexHdr(Wal *pWal){
66708 assert( pWal->nWiData>0 && pWal->apWiData[0] );
66710 return (volatile WalIndexHdr*)pWal->apWiData[0];
66796 static void walShmBarrier(Wal *pWal){
66797 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
66798 sqlite3OsShmBarrier(pWal->pDbFd);
66820 static SQLITE_NO_TSAN void walIndexWriteHdr(Wal *pWal){
66821 volatile WalIndexHdr *aHdr = walIndexHdr(pWal);
66824 assert( pWal->writeLock );
66825 pWal->hdr.isInit = 1;
66826 pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
66827 walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
66829 memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
66830 walShmBarrier(pWal);
66831 memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
66848 Wal *pWal, /* The write-ahead log */
66855 u32 *aCksum = pWal->hdr.aFrameCksum;
66859 if( pWal->iReCksum==0 ){
66860 memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
66862 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
66864 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
66879 Wal *pWal, /* The write-ahead log */
66886 u32 *aCksum = pWal->hdr.aFrameCksum;
66893 if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
66909 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
66911 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
66957 static int walLockShared(Wal *pWal, int lockIdx){
66959 if( pWal->exclusiveMode ) return SQLITE_OK;
66960 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
66962 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
66964 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
66966 if( rc==SQLITE_OK ) pWal->lockMask |= (1 << lockIdx);
66970 static void walUnlockShared(Wal *pWal, int lockIdx){
66971 if( pWal->exclusiveMode ) return;
66972 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
66975 pWal->lockMask &= ~(1 << lockIdx);
66977 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
66979 static int walLockExclusive(Wal *pWal, int lockIdx, int n){
66981 if( pWal->exclusiveMode ) return SQLITE_OK;
66982 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
66984 WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,
66986 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
66989 pWal->lockMask |= (((1<<n)-1) << (SQLITE_SHM_NLOCK+lockIdx));
66994 static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){
66995 if( pWal->exclusiveMode ) return;
66996 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
66999 pWal->lockMask &= ~(((1<<n)-1) << (SQLITE_SHM_NLOCK+lockIdx));
67001 WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,
67046 Wal *pWal, /* WAL handle */
67052 rc = walIndexPage(pWal, iHash, &pLoc->aPgno);
67090 static u32 walFramePgno(Wal *pWal, u32 iFrame){
67094 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
67096 return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
67111 static void walCleanupHash(Wal *pWal){
67117 assert( pWal->writeLock );
67118 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
67119 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
67120 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
67122 if( pWal->hdr.mxFrame==0 ) return;
67128 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
67129 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
67130 i = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);
67136 iLimit = pWal->hdr.mxFrame - sLoc.iZero;
67173 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
67177 rc = walHashGet(pWal, walFramePage(iFrame), &sLoc);
67206 walCleanupHash(pWal);
67262 static int walIndexRecover(Wal *pWal){
67274 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
67277 assert( pWal->writeLock );
67278 iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
67279 rc = walLockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);
67284 WALTRACE(("WAL%p: recovery begin...\n", pWal));
67286 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
67288 rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
67307 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
67326 pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
67327 pWal->szPage = szPage;
67328 pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
67329 memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
67332 walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,
67333 aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
67335 if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
67336 || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
67368 rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare);
67372 pWal->apWiData[iPg] = aPrivate;
67380 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
67382 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
67384 rc = walIndexAppend(pWal, iFrame, pgno);
67389 pWal->hdr.mxFrame = iFrame;
67390 pWal->hdr.nPage = nTruncate;
67391 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
67394 aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
67395 aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
67398 pWal->apWiData[iPg] = aShare;
67442 pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
67443 pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
67444 walIndexWriteHdr(pWal);
67450 pInfo = walCkptInfo(pWal);
67452 pInfo->nBackfillAttempted = pWal->hdr.mxFrame;
67455 rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
67457 if( i==1 && pWal->hdr.mxFrame ){
67458 pInfo->aReadMark[i] = pWal->hdr.mxFrame;
67463 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
67474 if( pWal->hdr.nPage ){
67477 pWal->hdr.mxFrame, pWal->zWalName
67483 WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));
67484 walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);
67491 static void walIndexClose(Wal *pWal, int isDelete){
67492 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){
67494 for(i=0; i<pWal->nWiData; i++){
67495 sqlite3_free((void *)pWal->apWiData[i]);
67496 pWal->apWiData[i] = 0;
67499 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
67500 sqlite3OsShmUnmap(pWal->pDbFd, isDelete);
67622 SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){
67623 if( pWal ) pWal->mxWalSize = iLimit;
67826 static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
67838 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
67839 iLast = pWal->hdr.mxFrame;
67858 rc = walHashGet(pWal, i, &sLoc);
67898 static int walEnableBlockingMs(Wal *pWal, int nMs){
67900 pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&nMs
67911 static int walEnableBlocking(Wal *pWal){
67913 if( pWal->db ){
67914 int tmout = pWal->db->setlkTimeout;
67916 res = walEnableBlockingMs(pWal, tmout);
67925 static void walDisableBlocking(Wal *pWal){
67927 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&tmout);
67939 SQLITE_PRIVATE int sqlite3WalWriteLock(Wal *pWal, int bLock){
67941 assert( pWal->readLock<0 || bLock==0 );
67943 assert( pWal->db );
67944 if( walEnableBlocking(pWal) ){
67945 rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
67947 pWal->writeLock = 1;
67949 walDisableBlocking(pWal);
67951 }else if( pWal->writeLock ){
67952 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
67953 pWal->writeLock = 0;
67961 SQLITE_PRIVATE void sqlite3WalDb(Wal *pWal, sqlite3 *db){
67962 pWal->db = db;
67968 # define walEnableBlockingMs(pWal, ms) 0 argument
67969 # define sqlite3WalDb(pWal, db) argument
67980 Wal *pWal, /* WAL connection */
67988 rc = walLockExclusive(pWal, lockIdx, n);
67992 walDisableBlocking(pWal);
68003 static int walPagesize(Wal *pWal){
68004 return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
68024 static void walRestartHdr(Wal *pWal, u32 salt1){
68025 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
68027 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
68028 pWal->nCkpt++;
68029 pWal->hdr.mxFrame = 0;
68031 memcpy(&pWal->hdr.aSalt[1], &salt1, 4);
68032 walIndexWriteHdr(pWal);
68072 Wal *pWal, /* Wal connection */
68090 szPage = walPagesize(pWal);
68093 pInfo = walCkptInfo(pWal);
68094 if( pInfo->nBackfill<pWal->hdr.mxFrame ){
68105 mxSafeFrame = pWal->hdr.mxFrame;
68106 mxPage = pWal->hdr.nPage;
68110 assert( y<=pWal->hdr.mxFrame );
68111 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
68115 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
68127 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
68132 && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
68138 rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
68146 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0);
68147 rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
68149 if( (nSize+65536+(i64)pWal->hdr.mxFrame*szPage)<nReq ){
68156 sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT,&nReq);
68165 assert( walFramePgno(pWal, iFrame)==iDbpage );
68176 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
68180 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
68183 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_DONE, 0);
68187 if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
68188 i64 szDb = pWal->hdr.nPage*(i64)szPage;
68190 rc = sqlite3OsTruncate(pWal->pDbFd, szDb);
68192 rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags));
68201 walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
68217 assert( pWal->writeLock );
68219 if( pInfo->nBackfill<pWal->hdr.mxFrame ){
68224 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
68225 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);
68241 walRestartHdr(pWal, salt1);
68242 rc = sqlite3OsTruncate(pWal->pWalFd, 0);
68244 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
68259 static void walLimitSize(Wal *pWal, i64 nMax){
68263 rx = sqlite3OsFileSize(pWal->pWalFd, &sz);
68265 rx = sqlite3OsTruncate(pWal->pWalFd, nMax);
68269 sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
68295 static int walHandleException(Wal *pWal){
68296 if( pWal->exclusiveMode==0 ){
68301 if( pWal->writeLock==2 ) pWal->writeLock = 0;
68302 mUnlock = pWal->lockMask & ~(
68303 (pWal->readLock<0 ? 0 : (S << WAL_READ_LOCK(pWal->readLock)))
68304 | (pWal->writeLock ? (E << WAL_WRITE_LOCK) : 0)
68305 | (pWal->ckptLock ? (E << WAL_CKPT_LOCK) : 0)
68308 if( (S<<ii) & mUnlock ) walUnlockShared(pWal, ii);
68309 if( (E<<ii) & mUnlock ) walUnlockExclusive(pWal, ii, 1);
68312 sqlite3_free(pWal->pFree);
68313 pWal->pFree = 0;
68314 if( pWal->pWiValue ){
68315 pWal->apWiData[pWal->iWiPg] = pWal->pWiValue;
68316 pWal->pWiValue = 0;
68328 static int walAssertLockmask(Wal *pWal){
68329 if( pWal->exclusiveMode==0 ){
68333 (pWal->readLock<0 ? 0 : (S << WAL_READ_LOCK(pWal->readLock)))
68334 | (pWal->writeLock ? (E << WAL_WRITE_LOCK) : 0)
68335 | (pWal->ckptLock ? (E << WAL_CKPT_LOCK) : 0)
68337 | (pWal->pSnapshot ? (pWal->lockMask & (1 << WAL_CKPT_LOCK)) : 0)
68340 assert( mExpect==pWal->lockMask );
68349 SQLITE_PRIVATE int sqlite3WalSystemErrno(Wal *pWal){
68351 if( pWal ){
68352 iRet = pWal->iSysErrno;
68353 pWal->iSysErrno = 0;
68366 Wal *pWal, /* Wal to close */
68373 if( pWal ){
68376 assert( walAssertLockmask(pWal) );
68387 && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
68389 if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
68390 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
68392 rc = sqlite3WalCheckpoint(pWal, db,
68398 pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist
68405 }else if( pWal->mxWalSize>=0 ){
68412 walLimitSize(pWal, 0);
68417 walIndexClose(pWal, isDelete);
68418 sqlite3OsClose(pWal->pWalFd);
68421 sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
68424 WALTRACE(("WAL%p: closed\n", pWal));
68425 sqlite3_free((void *)pWal->apWiData);
68426 sqlite3_free(pWal);
68448 static SQLITE_NO_TSAN int walIndexTryHdr(Wal *pWal, int *pChanged){
68454 assert( pWal->nWiData>0 && pWal->apWiData[0] );
68472 aHdr = walIndexHdr(pWal);
68474 walShmBarrier(pWal);
68488 if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){
68490 memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
68491 pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
68492 testcase( pWal->szPage<=32768 );
68493 testcase( pWal->szPage>=65536 );
68518 static int walIndexReadHdr(Wal *pWal, int *pChanged){
68527 rc = walIndexPage(pWal, 0, &page0);
68538 assert( pWal->writeLock==0 );
68539 assert( pWal->readOnly & WAL_SHM_RDONLY );
68540 pWal->bShmUnreliable = 1;
68541 pWal->exclusiveMode = WAL_HEAPMEMORY_MODE;
68551 assert( page0!=0 || pWal->writeLock==0 );
68558 badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1);
68564 if( pWal->bShmUnreliable==0 && (pWal->readOnly & WAL_SHM_RDONLY) ){
68565 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
68566 walUnlockShared(pWal, WAL_WRITE_LOCK);
68570 int bWriteLock = pWal->writeLock;
68572 || SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1))
68579 if( !bWriteLock ) pWal->writeLock = 2;
68580 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
68581 badHdr = walIndexTryHdr(pWal, pChanged);
68587 walDisableBlocking(pWal);
68588 rc = walIndexRecover(pWal);
68593 pWal->writeLock = 0;
68594 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
68604 if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
68607 if( pWal->bShmUnreliable ){
68609 walIndexClose(pWal, 0);
68610 pWal->bShmUnreliable = 0;
68611 assert( pWal->nWiData>0 && pWal->apWiData[0]==0 );
68617 pWal->exclusiveMode = WAL_NORMAL_MODE;
68650 static int walBeginShmUnreliable(Wal *pWal, int *pChanged){
68661 assert( pWal->bShmUnreliable );
68662 assert( pWal->readOnly & WAL_SHM_RDONLY );
68663 assert( pWal->nWiData>0 && pWal->apWiData[0] );
68668 rc = walLockShared(pWal, WAL_READ_LOCK(0));
68673 pWal->readLock = 0;
68697 rc = sqlite3OsShmMap(pWal->pDbFd, 0, WALINDEX_PGSZ, 0, &pDummy);
68708 memcpy(&pWal->hdr, (void*)walIndexHdr(pWal), sizeof(WalIndexHdr));
68713 rc = sqlite3OsFileSize(pWal->pWalFd, &szWal);
68725 rc = (pWal->hdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY);
68730 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
68734 if( memcmp(&pWal->hdr.aSalt, &aBuf[16], 8) ){
68743 assert( (pWal->szPage & (pWal->szPage-1))==0 );
68744 assert( pWal->szPage>=512 && pWal->szPage<=65536 );
68745 szFrame = pWal->szPage + WAL_FRAME_HDRSIZE;
68757 aSaveCksum[0] = pWal->hdr.aFrameCksum[0];
68758 aSaveCksum[1] = pWal->hdr.aFrameCksum[1];
68759 for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->szPage);
68767 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
68769 if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break;
68779 pWal->hdr.aFrameCksum[0] = aSaveCksum[0];
68780 pWal->hdr.aFrameCksum[1] = aSaveCksum[1];
68786 for(i=0; i<pWal->nWiData; i++){
68787 sqlite3_free((void*)pWal->apWiData[i]);
68788 pWal->apWiData[i] = 0;
68790 pWal->bShmUnreliable = 0;
68791 sqlite3WalEndReadTransaction(pWal);
68878 static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int *pCnt){
68885 assert( pWal->readLock<0 ); /* Not currently locked */
68888 assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 );
68912 VVA_ONLY( pWal->lockError = 1; )
68929 if( !useWal && walEnableBlockingMs(pWal, nBlockTmout) ){
68933 sqlite3OsSleep(pWal->pVfs, nDelay);
68939 if( pWal->bShmUnreliable==0 ){
68940 rc = walIndexReadHdr(pWal, pChanged);
68957 (void)walEnableBlocking(pWal);
68958 if( pWal->apWiData[0]==0 ){
68967 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
68968 walUnlockShared(pWal, WAL_RECOVER_LOCK);
68974 walDisableBlocking(pWal);
68978 else if( pWal->bShmUnreliable ){
68979 return walBeginShmUnreliable(pWal, pChanged);
68983 assert( pWal->nWiData>0 );
68984 assert( pWal->apWiData[0]!=0 );
68985 pInfo = walCkptInfo(pWal);
68992 if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame
68994 && ((pWal->bGetSnapshot==0 && pWal->pSnapshot==0) || pWal->hdr.mxFrame==0)
69000 rc = walLockShared(pWal, WAL_READ_LOCK(0));
69001 walShmBarrier(pWal);
69003 if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr,sizeof(WalIndexHdr)) ){
69017 walUnlockShared(pWal, WAL_READ_LOCK(0));
69020 pWal->readLock = 0;
69034 mxFrame = pWal->hdr.mxFrame;
69036 if( pWal->pSnapshot && pWal->pSnapshot->mxFrame<mxFrame ){
69037 mxFrame = pWal->pSnapshot->mxFrame;
69048 if( (pWal->readOnly & WAL_SHM_RDONLY)==0
69052 rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
69057 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
69065 assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
69069 (void)walEnableBlockingMs(pWal, nBlockTmout);
69070 rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
69071 walDisableBlocking(pWal);
69117 pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1; SEH_INJECT_FAULT;
69118 walShmBarrier(pWal);
69120 || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
69122 walUnlockShared(pWal, WAL_READ_LOCK(mxI));
69125 assert( mxReadMark<=pWal->hdr.mxFrame );
69126 pWal->readLock = (i16)mxI;
69137 Wal *pWal, /* WAL handle */
69141 int szPage = (int)pWal->szPage;
69145 rc = sqlite3OsFileSize(pWal->pDbFd, &szDb);
69147 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
69155 rc = walHashGet(pWal, walFramePage(i), &sLoc);
69163 rc = sqlite3OsRead(pWal->pWalFd, pBuf1, szPage, iWalOff);
69166 rc = sqlite3OsRead(pWal->pDbFd, pBuf2, szPage, iDbOff);
69200 SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){
69203 assert( pWal->readLock>=0 );
69204 rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
69206 void *pBuf1 = sqlite3_malloc(pWal->szPage);
69207 void *pBuf2 = sqlite3_malloc(pWal->szPage);
69211 pWal->ckptLock = 1;
69213 rc = walSnapshotRecover(pWal, pBuf1, pBuf2);
69216 pWal->ckptLock = 0;
69221 walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
69232 static int walBeginReadTransaction(Wal *pWal, int *pChanged){
69238 WalIndexHdr *pSnapshot = pWal->pSnapshot;
69241 assert( pWal->ckptLock==0 );
69242 assert( pWal->nSehTry>0 );
69246 if( memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
69258 (void)walEnableBlocking(pWal);
69259 rc = walLockShared(pWal, WAL_CKPT_LOCK);
69260 walDisableBlocking(pWal);
69270 rc = walTryBeginRead(pWal, pChanged, 0, &cnt);
69279 if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
69293 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
69295 assert( pWal->readLock>0 || pWal->hdr.mxFrame==0 );
69296 assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame );
69304 if( !memcmp(pSnapshot->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
69307 assert( pWal->readLock>0 );
69308 memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr));
69320 pWal->minFrame = 1;
69323 sqlite3WalEndReadTransaction(pWal);
69331 walUnlockShared(pWal, WAL_CKPT_LOCK);
69351 SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){
69354 rc = walBeginReadTransaction(pWal, pChanged);
69356 SEH_EXCEPT( rc = walHandleException(pWal); )
69364 SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){
69366 assert( pWal->writeLock==0 || pWal->readLock<0 );
69368 if( pWal->readLock>=0 ){
69369 sqlite3WalEndWriteTransaction(pWal);
69370 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
69371 pWal->readLock = -1;
69384 Wal *pWal, /* WAL handle */
69389 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
69394 assert( pWal->readLock>=0 || pWal->lockError );
69402 if( iLast==0 || (pWal->readLock==0 && pWal->bShmUnreliable==0) ){
69432 iMinHash = walFramePage(pWal->minFrame);
69440 rc = walHashGet(pWal, iHash, &sLoc);
69449 if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){
69469 assert( pWal->bShmUnreliable || pWal->minFrame>0 );
69470 for(iTest=iLast; iTest>=pWal->minFrame && iTest>0; iTest--){
69471 if( walFramePgno(pWal, iTest)==pgno ){
69496 Wal *pWal, /* WAL handle */
69502 rc = walFindFrame(pWal, pgno, piRead);
69514 Wal *pWal, /* WAL handle */
69521 sz = pWal->hdr.szPage;
69527 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
69533 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){
69534 if( pWal && ALWAYS(pWal->readLock>=0) ){
69535 return pWal->hdr.nPage;
69554 SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){
69561 if( pWal->writeLock ){
69562 assert( !memcmp(&pWal->hdr,(void*)pWal->apWiData[0],sizeof(WalIndexHdr)) );
69569 assert( pWal->readLock>=0 );
69570 assert( pWal->writeLock==0 && pWal->iReCksum==0 );
69572 if( pWal->readOnly ){
69579 rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
69583 pWal->writeLock = 1;
69590 if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
69597 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
69598 pWal->writeLock = 0;
69607 SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
69608 if( pWal->writeLock ){
69609 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
69610 pWal->writeLock = 0;
69611 pWal->iReCksum = 0;
69612 pWal->truncateOnCommit = 0;
69629 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
69631 if( ALWAYS(pWal->writeLock) ){
69632 Pgno iMax = pWal->hdr.mxFrame;
69639 memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
69641 for(iFrame=pWal->hdr.mxFrame+1;
69656 assert( walFramePgno(pWal, iFrame)!=1 );
69657 rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));
69659 if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal);
69662 pWal->iReCksum = 0;
69673 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
69674 assert( pWal->writeLock );
69675 aWalData[0] = pWal->hdr.mxFrame;
69676 aWalData[1] = pWal->hdr.aFrameCksum[0];
69677 aWalData[2] = pWal->hdr.aFrameCksum[1];
69678 aWalData[3] = pWal->nCkpt;
69687 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
69690 assert( pWal->writeLock );
69691 assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
69693 if( aWalData[3]!=pWal->nCkpt ){
69699 aWalData[3] = pWal->nCkpt;
69702 if( aWalData[0]<pWal->hdr.mxFrame ){
69703 pWal->hdr.mxFrame = aWalData[0];
69704 pWal->hdr.aFrameCksum[0] = aWalData[1];
69705 pWal->hdr.aFrameCksum[1] = aWalData[2];
69707 walCleanupHash(pWal);
69710 if( pWal->iReCksum>pWal->hdr.mxFrame ){
69711 pWal->iReCksum = 0;
69730 static int walRestartLog(Wal *pWal){
69734 if( pWal->readLock==0 ){
69735 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
69736 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
69740 rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
69751 walRestartHdr(pWal, salt1);
69752 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
69757 walUnlockShared(pWal, WAL_READ_LOCK(0));
69758 pWal->readLock = -1;
69762 rc = walTryBeginRead(pWal, ¬Used, 1, &cnt);
69778 Wal *pWal; /* The complete WAL information */ member
69828 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
69844 static int walRewriteChecksums(Wal *pWal, u32 iLast){
69845 const int szPage = pWal->szPage;/* Database page size */
69860 assert( pWal->iReCksum>0 );
69861 if( pWal->iReCksum==1 ){
69864 iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16;
69866 rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff);
69867 pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf);
69868 pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]);
69870 iRead = pWal->iReCksum;
69871 pWal->iReCksum = 0;
69874 rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff);
69880 walEncodeFrame(pWal, iPgno, nDbSize, &aBuf[WAL_FRAME_HDRSIZE], aFrame);
69881 rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff);
69894 Wal *pWal, /* Wal handle to write to */
69913 assert( pWal->writeLock );
69922 pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
69926 pLive = (WalIndexHdr*)walIndexHdr(pWal);
69927 if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){
69934 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
69942 iFrame = pWal->hdr.mxFrame;
69950 sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);
69951 if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt);
69952 memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
69957 pWal->szPage = szPage;
69958 pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN;
69959 pWal->hdr.aFrameCksum[0] = aCksum[0];
69960 pWal->hdr.aFrameCksum[1] = aCksum[1];
69961 pWal->truncateOnCommit = 1;
69963 rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
69964 WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
69976 if( pWal->syncHeader ){
69977 rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
69981 if( (int)pWal->szPage!=szPage ){
69986 w.pWal = pWal;
69987 w.pFd = pWal->pWalFd;
70004 VVA_ONLY(rc =) walFindFrame(pWal, p->pgno, &iWrite);
70009 if( pWal->iReCksum==0 || iWrite<pWal->iReCksum ){
70010 pWal->iReCksum = iWrite;
70013 rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
70031 if( isCommit && pWal->iReCksum ){
70032 rc = walRewriteChecksums(pWal, iFrame);
70052 if( pWal->padToSectorBoundary ){
70053 int sectorSize = sqlite3SectorSize(pWal->pWalFd);
70075 if( isCommit && pWal->truncateOnCommit && pWal->mxWalSize>=0 ){
70076 i64 sz = pWal->mxWalSize;
70077 if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){
70080 walLimitSize(pWal, sz);
70081 pWal->truncateOnCommit = 0;
70089 iFrame = pWal->hdr.mxFrame;
70093 rc = walIndexAppend(pWal, iFrame, p->pgno);
70099 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
70104 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
70107 pWal->hdr.mxFrame = iFrame;
70109 pWal->hdr.iChange++;
70110 pWal->hdr.nPage = nTruncate;
70114 walIndexWriteHdr(pWal);
70115 pWal->iCallback = iFrame;
70119 WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok"));
70131 Wal *pWal, /* Wal handle to write to */
70140 rc = walFrames(pWal, szPage, pList, nTruncate, isCommit, sync_flags);
70142 SEH_EXCEPT( rc = walHandleException(pWal); )
70157 Wal *pWal, /* Wal connection */
70173 assert( pWal->ckptLock==0 );
70174 assert( pWal->writeLock==0 );
70180 if( pWal->readOnly ) return SQLITE_READONLY;
70181 WALTRACE(("WAL%p: checkpoint begins\n", pWal));
70184 sqlite3WalDb(pWal, db);
70185 if( xBusy2 ) (void)walEnableBlocking(pWal);
70195 rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
70199 pWal->ckptLock = 1;
70211 rc = walBusyLock(pWal, xBusy2, pBusyArg, WAL_WRITE_LOCK, 1);
70213 pWal->writeLock = 1;
70231 walDisableBlocking(pWal);
70232 rc = walIndexReadHdr(pWal, &isChanged);
70233 if( eMode2!=SQLITE_CHECKPOINT_PASSIVE ) (void)walEnableBlocking(pWal);
70234 if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){
70235 sqlite3OsUnfetch(pWal->pDbFd, 0, 0);
70241 if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
70244 rc = walCheckpoint(pWal, db, eMode2, xBusy2, pBusyArg, sync_flags,zBuf);
70249 if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
70251 if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
70255 SEH_EXCEPT( rc = walHandleException(pWal); )
70264 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
70267 walDisableBlocking(pWal);
70268 sqlite3WalDb(pWal, 0);
70271 sqlite3WalEndWriteTransaction(pWal);
70272 if( pWal->ckptLock ){
70273 walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
70274 pWal->ckptLock = 0;
70276 WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok"));
70288 SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal){
70290 if( pWal ){
70291 ret = pWal->iCallback;
70292 pWal->iCallback = 0;
70321 SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){
70323 assert( pWal->writeLock==0 );
70324 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
70333 assert( pWal->readLock>=0 || pWal->lockError );
70335 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
70338 if( pWal->exclusiveMode!=WAL_NORMAL_MODE ){
70339 pWal->exclusiveMode = WAL_NORMAL_MODE;
70340 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
70341 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
70343 rc = pWal->exclusiveMode==WAL_NORMAL_MODE;
70349 assert( pWal->exclusiveMode==WAL_NORMAL_MODE );
70350 assert( pWal->readLock>=0 );
70351 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
70352 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
70355 rc = pWal->exclusiveMode==WAL_NORMAL_MODE;
70365 SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal){
70366 return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );
70374 SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot){
70379 assert( pWal->readLock>=0 && pWal->writeLock==0 );
70381 if( memcmp(&pWal->hdr.aFrameCksum[0],aZero,16)==0 ){
70389 memcpy(pRet, &pWal->hdr, sizeof(WalIndexHdr));
70399 Wal *pWal,
70411 pWal->bGetSnapshot = 1;
70413 pWal->pSnapshot = (WalIndexHdr*)pSnapshot;
70414 pWal->bGetSnapshot = 0;
70446 SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot){
70449 rc = walLockShared(pWal, WAL_CKPT_LOCK);
70452 if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
70453 || pNew->mxFrame<walCkptInfo(pWal)->nBackfillAttempted
70456 walUnlockShared(pWal, WAL_CKPT_LOCK);
70460 SEH_EXCEPT( rc = walHandleException(pWal); )
70468 SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal){
70469 assert( pWal );
70470 walUnlockShared(pWal, WAL_CKPT_LOCK);
70482 SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal){
70483 assert( pWal==0 || pWal->readLock>=0 );
70484 return (pWal ? pWal->szPage : 0);
70490 SQLITE_PRIVATE sqlite3_file *sqlite3WalFile(Wal *pWal){
70491 return pWal->pWalFd;
224364 sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
224377 p->rc = pWal->pMethods->xSync(pWal, SQLITE_SYNC_NORMAL);
224430 sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
224436 p->rc = pWal->pMethods->xRead(pWal, p->aBuf, p->pgsz, iOff);