sl@0: /* sl@0: ** 2001 September 15 sl@0: ** sl@0: ** The author disclaims copyright to this source code. In place of sl@0: ** a legal notice, here is a blessing: sl@0: ** sl@0: ** May you do good and not evil. sl@0: ** May you find forgiveness for yourself and forgive others. sl@0: ** May you share freely, never taking more than you give. sl@0: ** sl@0: ************************************************************************* sl@0: ** This is the implementation of the page cache subsystem or "pager". sl@0: ** sl@0: ** The pager is used to access a database disk file. It implements sl@0: ** atomic commit and rollback through the use of a journal file that sl@0: ** is separate from the database file. The pager also implements file sl@0: ** locking to prevent two processes from writing the same database sl@0: ** file simultaneously, or one process from reading the database while sl@0: ** another is writing. sl@0: ** sl@0: ** @(#) $Id: pager.c,v 1.497 2008/10/07 11:51:20 danielk1977 Exp $ sl@0: */ sl@0: #ifndef SQLITE_OMIT_DISKIO sl@0: #include "sqliteInt.h" sl@0: sl@0: /* sl@0: ** Macros for troubleshooting. Normally turned off sl@0: */ sl@0: #if 0 sl@0: #define sqlite3DebugPrintf printf sl@0: #define PAGERTRACE1(X) sqlite3DebugPrintf(X) sl@0: #define PAGERTRACE2(X,Y) sqlite3DebugPrintf(X,Y) sl@0: #define PAGERTRACE3(X,Y,Z) sqlite3DebugPrintf(X,Y,Z) sl@0: #define PAGERTRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W) sl@0: #define PAGERTRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V) sl@0: #else sl@0: #define PAGERTRACE1(X) sl@0: #define PAGERTRACE2(X,Y) sl@0: #define PAGERTRACE3(X,Y,Z) sl@0: #define PAGERTRACE4(X,Y,Z,W) sl@0: #define PAGERTRACE5(X,Y,Z,W,V) sl@0: #endif sl@0: sl@0: /* sl@0: ** The following two macros are used within the PAGERTRACEX() macros above sl@0: ** to print out file-descriptors. sl@0: ** sl@0: ** PAGERID() takes a pointer to a Pager struct as its argument. The sl@0: ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file sl@0: ** struct as its argument. sl@0: */ sl@0: #define PAGERID(p) ((int)(p->fd)) sl@0: #define FILEHANDLEID(fd) ((int)fd) sl@0: sl@0: /* sl@0: ** The page cache as a whole is always in one of the following sl@0: ** states: sl@0: ** sl@0: ** PAGER_UNLOCK The page cache is not currently reading or sl@0: ** writing the database file. There is no sl@0: ** data held in memory. This is the initial sl@0: ** state. sl@0: ** sl@0: ** PAGER_SHARED The page cache is reading the database. sl@0: ** Writing is not permitted. There can be sl@0: ** multiple readers accessing the same database sl@0: ** file at the same time. sl@0: ** sl@0: ** PAGER_RESERVED This process has reserved the database for writing sl@0: ** but has not yet made any changes. Only one process sl@0: ** at a time can reserve the database. The original sl@0: ** database file has not been modified so other sl@0: ** processes may still be reading the on-disk sl@0: ** database file. sl@0: ** sl@0: ** PAGER_EXCLUSIVE The page cache is writing the database. sl@0: ** Access is exclusive. No other processes or sl@0: ** threads can be reading or writing while one sl@0: ** process is writing. sl@0: ** sl@0: ** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE sl@0: ** after all dirty pages have been written to the sl@0: ** database file and the file has been synced to sl@0: ** disk. All that remains to do is to remove or sl@0: ** truncate the journal file and the transaction sl@0: ** will be committed. sl@0: ** sl@0: ** The page cache comes up in PAGER_UNLOCK. The first time a sl@0: ** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED. sl@0: ** After all pages have been released using sqlite_page_unref(), sl@0: ** the state transitions back to PAGER_UNLOCK. The first time sl@0: ** that sqlite3PagerWrite() is called, the state transitions to sl@0: ** PAGER_RESERVED. (Note that sqlite3PagerWrite() can only be sl@0: ** called on an outstanding page which means that the pager must sl@0: ** be in PAGER_SHARED before it transitions to PAGER_RESERVED.) sl@0: ** PAGER_RESERVED means that there is an open rollback journal. sl@0: ** The transition to PAGER_EXCLUSIVE occurs before any changes sl@0: ** are made to the database file, though writes to the rollback sl@0: ** journal occurs with just PAGER_RESERVED. After an sqlite3PagerRollback() sl@0: ** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED, sl@0: ** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode. sl@0: */ sl@0: #define PAGER_UNLOCK 0 sl@0: #define PAGER_SHARED 1 /* same as SHARED_LOCK */ sl@0: #define PAGER_RESERVED 2 /* same as RESERVED_LOCK */ sl@0: #define PAGER_EXCLUSIVE 4 /* same as EXCLUSIVE_LOCK */ sl@0: #define PAGER_SYNCED 5 sl@0: sl@0: /* sl@0: ** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time, sl@0: ** then failed attempts to get a reserved lock will invoke the busy callback. sl@0: ** This is off by default. To see why, consider the following scenario: sl@0: ** sl@0: ** Suppose thread A already has a shared lock and wants a reserved lock. sl@0: ** Thread B already has a reserved lock and wants an exclusive lock. If sl@0: ** both threads are using their busy callbacks, it might be a long time sl@0: ** be for one of the threads give up and allows the other to proceed. sl@0: ** But if the thread trying to get the reserved lock gives up quickly sl@0: ** (if it never invokes its busy callback) then the contention will be sl@0: ** resolved quickly. sl@0: */ sl@0: #ifndef SQLITE_BUSY_RESERVED_LOCK sl@0: # define SQLITE_BUSY_RESERVED_LOCK 0 sl@0: #endif sl@0: sl@0: /* sl@0: ** This macro rounds values up so that if the value is an address it sl@0: ** is guaranteed to be an address that is aligned to an 8-byte boundary. sl@0: */ sl@0: #define FORCE_ALIGNMENT(X) (((X)+7)&~7) sl@0: sl@0: /* sl@0: ** A macro used for invoking the codec if there is one sl@0: */ sl@0: #ifdef SQLITE_HAS_CODEC sl@0: # define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); } sl@0: # define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D)) sl@0: #else sl@0: # define CODEC1(P,D,N,X) /* NO-OP */ sl@0: # define CODEC2(P,D,N,X) ((char*)D) sl@0: #endif sl@0: sl@0: /* sl@0: ** A open page cache is an instance of the following structure. sl@0: ** sl@0: ** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or sl@0: ** or SQLITE_FULL. Once one of the first three errors occurs, it persists sl@0: ** and is returned as the result of every major pager API call. The sl@0: ** SQLITE_FULL return code is slightly different. It persists only until the sl@0: ** next successful rollback is performed on the pager cache. Also, sl@0: ** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup() sl@0: ** APIs, they may still be used successfully. sl@0: */ sl@0: struct Pager { sl@0: sqlite3_vfs *pVfs; /* OS functions to use for IO */ sl@0: u8 journalOpen; /* True if journal file descriptors is valid */ sl@0: u8 journalStarted; /* True if header of journal is synced */ sl@0: u8 useJournal; /* Use a rollback journal on this file */ sl@0: u8 noReadlock; /* Do not bother to obtain readlocks */ sl@0: u8 stmtOpen; /* True if the statement subjournal is open */ sl@0: u8 stmtInUse; /* True we are in a statement subtransaction */ sl@0: u8 stmtAutoopen; /* Open stmt journal when main journal is opened*/ sl@0: u8 noSync; /* Do not sync the journal if true */ sl@0: u8 fullSync; /* Do extra syncs of the journal for robustness */ sl@0: u8 sync_flags; /* One of SYNC_NORMAL or SYNC_FULL */ sl@0: u8 state; /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */ sl@0: u8 tempFile; /* zFilename is a temporary file */ sl@0: u8 readOnly; /* True for a read-only database */ sl@0: u8 needSync; /* True if an fsync() is needed on the journal */ sl@0: u8 dirtyCache; /* True if cached pages have changed */ sl@0: u8 alwaysRollback; /* Disable DontRollback() for all pages */ sl@0: u8 memDb; /* True to inhibit all file I/O */ sl@0: u8 setMaster; /* True if a m-j name has been written to jrnl */ sl@0: u8 doNotSync; /* Boolean. While true, do not spill the cache */ sl@0: u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */ sl@0: u8 journalMode; /* On of the PAGER_JOURNALMODE_* values */ sl@0: u8 dbModified; /* True if there are any changes to the Db */ sl@0: u8 changeCountDone; /* Set after incrementing the change-counter */ sl@0: u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */ sl@0: int errCode; /* One of several kinds of errors */ sl@0: int dbSize; /* Number of pages in the file */ sl@0: int origDbSize; /* dbSize before the current change */ sl@0: int stmtSize; /* Size of database (in pages) at stmt_begin() */ sl@0: int nRec; /* Number of pages written to the journal */ sl@0: u32 cksumInit; /* Quasi-random value added to every checksum */ sl@0: int stmtNRec; /* Number of records in stmt subjournal */ sl@0: int nExtra; /* Add this many bytes to each in-memory page */ sl@0: int pageSize; /* Number of bytes in a page */ sl@0: int nPage; /* Total number of in-memory pages */ sl@0: int mxPage; /* Maximum number of pages to hold in cache */ sl@0: Pgno mxPgno; /* Maximum allowed size of the database */ sl@0: Bitvec *pInJournal; /* One bit for each page in the database file */ sl@0: Bitvec *pInStmt; /* One bit for each page in the database */ sl@0: Bitvec *pAlwaysRollback; /* One bit for each page marked always-rollback */ sl@0: char *zFilename; /* Name of the database file */ sl@0: char *zJournal; /* Name of the journal file */ sl@0: char *zDirectory; /* Directory hold database and journal files */ sl@0: sqlite3_file *fd, *jfd; /* File descriptors for database and journal */ sl@0: sqlite3_file *stfd; /* File descriptor for the statement subjournal*/ sl@0: BusyHandler *pBusyHandler; /* Pointer to sqlite.busyHandler */ sl@0: i64 journalOff; /* Current byte offset in the journal file */ sl@0: i64 journalHdr; /* Byte offset to previous journal header */ sl@0: i64 stmtHdrOff; /* First journal header written this statement */ sl@0: i64 stmtCksum; /* cksumInit when statement was started */ sl@0: i64 stmtJSize; /* Size of journal at stmt_begin() */ sl@0: u32 sectorSize; /* Assumed sector size during rollback */ sl@0: #ifdef SQLITE_TEST sl@0: int nHit, nMiss; /* Cache hits and missing */ sl@0: int nRead, nWrite; /* Database pages read/written */ sl@0: #endif sl@0: void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */ sl@0: #ifdef SQLITE_HAS_CODEC sl@0: void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ sl@0: void *pCodecArg; /* First argument to xCodec() */ sl@0: #endif sl@0: char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ sl@0: char dbFileVers[16]; /* Changes whenever database file changes */ sl@0: i64 journalSizeLimit; /* Size limit for persistent journal files */ sl@0: PCache *pPCache; /* Pointer to page cache object */ sl@0: }; sl@0: sl@0: /* sl@0: ** The following global variables hold counters used for sl@0: ** testing purposes only. These variables do not exist in sl@0: ** a non-testing build. These variables are not thread-safe. sl@0: */ sl@0: #ifdef SQLITE_TEST sl@0: int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */ sl@0: int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */ sl@0: int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */ sl@0: # define PAGER_INCR(v) v++ sl@0: #else sl@0: # define PAGER_INCR(v) sl@0: #endif sl@0: sl@0: sl@0: sl@0: /* sl@0: ** Journal files begin with the following magic string. The data sl@0: ** was obtained from /dev/random. It is used only as a sanity check. sl@0: ** sl@0: ** Since version 2.8.0, the journal format contains additional sanity sl@0: ** checking information. If the power fails while the journal is begin sl@0: ** written, semi-random garbage data might appear in the journal sl@0: ** file after power is restored. If an attempt is then made sl@0: ** to roll the journal back, the database could be corrupted. The additional sl@0: ** sanity checking data is an attempt to discover the garbage in the sl@0: ** journal and ignore it. sl@0: ** sl@0: ** The sanity checking information for the new journal format consists sl@0: ** of a 32-bit checksum on each page of data. The checksum covers both sl@0: ** the page number and the pPager->pageSize bytes of data for the page. sl@0: ** This cksum is initialized to a 32-bit random value that appears in the sl@0: ** journal file right after the header. The random initializer is important, sl@0: ** because garbage data that appears at the end of a journal is likely sl@0: ** data that was once in other files that have now been deleted. If the sl@0: ** garbage data came from an obsolete journal file, the checksums might sl@0: ** be correct. But by initializing the checksum to random value which sl@0: ** is different for every journal, we minimize that risk. sl@0: */ sl@0: static const unsigned char aJournalMagic[] = { sl@0: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7, sl@0: }; sl@0: sl@0: /* sl@0: ** The size of the header and of each page in the journal is determined sl@0: ** by the following macros. sl@0: */ sl@0: #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8) sl@0: sl@0: /* sl@0: ** The journal header size for this pager. In the future, this could be sl@0: ** set to some value read from the disk controller. The important sl@0: ** characteristic is that it is the same size as a disk sector. sl@0: */ sl@0: #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize) sl@0: sl@0: /* sl@0: ** The macro MEMDB is true if we are dealing with an in-memory database. sl@0: ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set, sl@0: ** the value of MEMDB will be a constant and the compiler will optimize sl@0: ** out code that would never execute. sl@0: */ sl@0: #ifdef SQLITE_OMIT_MEMORYDB sl@0: # define MEMDB 0 sl@0: #else sl@0: # define MEMDB pPager->memDb sl@0: #endif sl@0: sl@0: /* sl@0: ** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is sl@0: ** reserved for working around a windows/posix incompatibility). It is sl@0: ** used in the journal to signify that the remainder of the journal file sl@0: ** is devoted to storing a master journal name - there are no more pages to sl@0: ** roll back. See comments for function writeMasterJournal() for details. sl@0: */ sl@0: /* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */ sl@0: #define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1) sl@0: sl@0: /* sl@0: ** The maximum legal page number is (2^31 - 1). sl@0: */ sl@0: #define PAGER_MAX_PGNO 2147483647 sl@0: sl@0: /* sl@0: ** Return true if page *pPg has already been written to the statement sl@0: ** journal (or statement snapshot has been created, if *pPg is part sl@0: ** of an in-memory database). sl@0: */ sl@0: static int pageInStatement(PgHdr *pPg){ sl@0: Pager *pPager = pPg->pPager; sl@0: if( MEMDB ){ sl@0: return pPg->apSave[1]!=0; sl@0: }else{ sl@0: return sqlite3BitvecTest(pPager->pInStmt, pPg->pgno); sl@0: } sl@0: } sl@0: sl@0: /* sl@0: ** Read a 32-bit integer from the given file descriptor. Store the integer sl@0: ** that is read in *pRes. Return SQLITE_OK if everything worked, or an sl@0: ** error code is something goes wrong. sl@0: ** sl@0: ** All values are stored on disk as big-endian. sl@0: */ sl@0: static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){ sl@0: unsigned char ac[4]; sl@0: int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset); sl@0: if( rc==SQLITE_OK ){ sl@0: *pRes = sqlite3Get4byte(ac); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Write a 32-bit integer into a string buffer in big-endian byte order. sl@0: */ sl@0: #define put32bits(A,B) sqlite3Put4byte((u8*)A,B) sl@0: sl@0: /* sl@0: ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK sl@0: ** on success or an error code is something goes wrong. sl@0: */ sl@0: static int write32bits(sqlite3_file *fd, i64 offset, u32 val){ sl@0: char ac[4]; sl@0: put32bits(ac, val); sl@0: return sqlite3OsWrite(fd, ac, 4, offset); sl@0: } sl@0: sl@0: /* sl@0: ** If file pFd is open, call sqlite3OsUnlock() on it. sl@0: */ sl@0: static int osUnlock(sqlite3_file *pFd, int eLock){ sl@0: if( !pFd->pMethods ){ sl@0: return SQLITE_OK; sl@0: } sl@0: return sqlite3OsUnlock(pFd, eLock); sl@0: } sl@0: sl@0: /* sl@0: ** This function determines whether or not the atomic-write optimization sl@0: ** can be used with this pager. The optimization can be used if: sl@0: ** sl@0: ** (a) the value returned by OsDeviceCharacteristics() indicates that sl@0: ** a database page may be written atomically, and sl@0: ** (b) the value returned by OsSectorSize() is less than or equal sl@0: ** to the page size. sl@0: ** sl@0: ** If the optimization cannot be used, 0 is returned. If it can be used, sl@0: ** then the value returned is the size of the journal file when it sl@0: ** contains rollback data for exactly one page. sl@0: */ sl@0: #ifdef SQLITE_ENABLE_ATOMIC_WRITE sl@0: static int jrnlBufferSize(Pager *pPager){ sl@0: int dc; /* Device characteristics */ sl@0: int nSector; /* Sector size */ sl@0: int szPage; /* Page size */ sl@0: sqlite3_file *fd = pPager->fd; sl@0: sl@0: if( fd->pMethods ){ sl@0: dc = sqlite3OsDeviceCharacteristics(fd); sl@0: nSector = sqlite3OsSectorSize(fd); sl@0: szPage = pPager->pageSize; sl@0: } sl@0: sl@0: assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); sl@0: assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); sl@0: sl@0: if( !fd->pMethods || sl@0: (dc & (SQLITE_IOCAP_ATOMIC|(szPage>>8)) && nSector<=szPage) ){ sl@0: return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager); sl@0: } sl@0: return 0; sl@0: } sl@0: #endif sl@0: sl@0: /* sl@0: ** This function should be called when an error occurs within the pager sl@0: ** code. The first argument is a pointer to the pager structure, the sl@0: ** second the error-code about to be returned by a pager API function. sl@0: ** The value returned is a copy of the second argument to this function. sl@0: ** sl@0: ** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL sl@0: ** the error becomes persistent. Until the persisten error is cleared, sl@0: ** subsequent API calls on this Pager will immediately return the same sl@0: ** error code. sl@0: ** sl@0: ** A persistent error indicates that the contents of the pager-cache sl@0: ** cannot be trusted. This state can be cleared by completely discarding sl@0: ** the contents of the pager-cache. If a transaction was active when sl@0: ** the persistent error occured, then the rollback journal may need sl@0: ** to be replayed. sl@0: */ sl@0: static void pager_unlock(Pager *pPager); sl@0: static int pager_error(Pager *pPager, int rc){ sl@0: int rc2 = rc & 0xff; sl@0: assert( sl@0: pPager->errCode==SQLITE_FULL || sl@0: pPager->errCode==SQLITE_OK || sl@0: (pPager->errCode & 0xff)==SQLITE_IOERR sl@0: ); sl@0: if( sl@0: rc2==SQLITE_FULL || sl@0: rc2==SQLITE_IOERR || sl@0: rc2==SQLITE_CORRUPT sl@0: ){ sl@0: pPager->errCode = rc; sl@0: if( pPager->state==PAGER_UNLOCK sl@0: && sqlite3PcacheRefCount(pPager->pPCache)==0 sl@0: ){ sl@0: /* If the pager is already unlocked, call pager_unlock() now to sl@0: ** clear the error state and ensure that the pager-cache is sl@0: ** completely empty. sl@0: */ sl@0: pager_unlock(pPager); sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking sl@0: ** on the cache using a hash function. This is used for testing sl@0: ** and debugging only. sl@0: */ sl@0: #ifdef SQLITE_CHECK_PAGES sl@0: /* sl@0: ** Return a 32-bit hash of the page data for pPage. sl@0: */ sl@0: static u32 pager_datahash(int nByte, unsigned char *pData){ sl@0: u32 hash = 0; sl@0: int i; sl@0: for(i=0; ipPager->pageSize, (unsigned char *)pPage->pData); sl@0: } sl@0: static u32 pager_set_pagehash(PgHdr *pPage){ sl@0: pPage->pageHash = pager_pagehash(pPage); sl@0: } sl@0: sl@0: /* sl@0: ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES sl@0: ** is defined, and NDEBUG is not defined, an assert() statement checks sl@0: ** that the page is either dirty or still matches the calculated page-hash. sl@0: */ sl@0: #define CHECK_PAGE(x) checkPage(x) sl@0: static void checkPage(PgHdr *pPg){ sl@0: Pager *pPager = pPg->pPager; sl@0: assert( !pPg->pageHash || pPager->errCode || MEMDB sl@0: || (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) ); sl@0: } sl@0: sl@0: #else sl@0: #define pager_datahash(X,Y) 0 sl@0: #define pager_pagehash(X) 0 sl@0: #define CHECK_PAGE(x) sl@0: #endif /* SQLITE_CHECK_PAGES */ sl@0: sl@0: /* sl@0: ** When this is called the journal file for pager pPager must be open. sl@0: ** The master journal file name is read from the end of the file and sl@0: ** written into memory supplied by the caller. sl@0: ** sl@0: ** zMaster must point to a buffer of at least nMaster bytes allocated by sl@0: ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is sl@0: ** enough space to write the master journal name). If the master journal sl@0: ** name in the journal is longer than nMaster bytes (including a sl@0: ** nul-terminator), then this is handled as if no master journal name sl@0: ** were present in the journal. sl@0: ** sl@0: ** If no master journal file name is present zMaster[0] is set to 0 and sl@0: ** SQLITE_OK returned. sl@0: */ sl@0: static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, int nMaster){ sl@0: int rc; sl@0: u32 len; sl@0: i64 szJ; sl@0: u32 cksum; sl@0: u32 u; /* Unsigned loop counter */ sl@0: unsigned char aMagic[8]; /* A buffer to hold the magic header */ sl@0: sl@0: zMaster[0] = '\0'; sl@0: sl@0: rc = sqlite3OsFileSize(pJrnl, &szJ); sl@0: if( rc!=SQLITE_OK || szJ<16 ) return rc; sl@0: sl@0: rc = read32bits(pJrnl, szJ-16, &len); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: sl@0: if( len>=nMaster ){ sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: rc = read32bits(pJrnl, szJ-12, &cksum); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: sl@0: rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8); sl@0: if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc; sl@0: sl@0: rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: zMaster[len] = '\0'; sl@0: sl@0: /* See if the checksum matches the master journal name */ sl@0: for(u=0; ujournalOff; sl@0: if( c ){ sl@0: offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); sl@0: } sl@0: assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); sl@0: assert( offset>=c ); sl@0: assert( (offset-c)journalOff = journalHdrOffset(pPager); sl@0: } sl@0: sl@0: /* sl@0: ** Write zeros over the header of the journal file. This has the sl@0: ** effect of invalidating the journal file and committing the sl@0: ** transaction. sl@0: */ sl@0: static int zeroJournalHdr(Pager *pPager, int doTruncate){ sl@0: int rc = SQLITE_OK; sl@0: static const char zeroHdr[28] = {0}; sl@0: sl@0: if( pPager->journalOff ){ sl@0: i64 iLimit = pPager->journalSizeLimit; sl@0: sl@0: IOTRACE(("JZEROHDR %p\n", pPager)) sl@0: if( doTruncate || iLimit==0 ){ sl@0: rc = sqlite3OsTruncate(pPager->jfd, 0); sl@0: }else{ sl@0: rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0); sl@0: } sl@0: if( rc==SQLITE_OK && !pPager->noSync ){ sl@0: rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->sync_flags); sl@0: } sl@0: sl@0: /* At this point the transaction is committed but the write lock sl@0: ** is still held on the file. If there is a size limit configured for sl@0: ** the persistent journal and the journal file currently consumes more sl@0: ** space than that limit allows for, truncate it now. There is no need sl@0: ** to sync the file following this operation. sl@0: */ sl@0: if( rc==SQLITE_OK && iLimit>0 ){ sl@0: i64 sz; sl@0: rc = sqlite3OsFileSize(pPager->jfd, &sz); sl@0: if( rc==SQLITE_OK && sz>iLimit ){ sl@0: rc = sqlite3OsTruncate(pPager->jfd, iLimit); sl@0: } sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** The journal file must be open when this routine is called. A journal sl@0: ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the sl@0: ** current location. sl@0: ** sl@0: ** The format for the journal header is as follows: sl@0: ** - 8 bytes: Magic identifying journal format. sl@0: ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on. sl@0: ** - 4 bytes: Random number used for page hash. sl@0: ** - 4 bytes: Initial database page count. sl@0: ** - 4 bytes: Sector size used by the process that wrote this journal. sl@0: ** - 4 bytes: Database page size. sl@0: ** sl@0: ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space. sl@0: */ sl@0: static int writeJournalHdr(Pager *pPager){ sl@0: int rc = SQLITE_OK; sl@0: char *zHeader = pPager->pTmpSpace; sl@0: int nHeader = pPager->pageSize; sl@0: int nWrite; sl@0: sl@0: if( nHeader>JOURNAL_HDR_SZ(pPager) ){ sl@0: nHeader = JOURNAL_HDR_SZ(pPager); sl@0: } sl@0: sl@0: if( pPager->stmtHdrOff==0 ){ sl@0: pPager->stmtHdrOff = pPager->journalOff; sl@0: } sl@0: sl@0: seekJournalHdr(pPager); sl@0: pPager->journalHdr = pPager->journalOff; sl@0: sl@0: memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); sl@0: sl@0: /* sl@0: ** Write the nRec Field - the number of page records that follow this sl@0: ** journal header. Normally, zero is written to this value at this time. sl@0: ** After the records are added to the journal (and the journal synced, sl@0: ** if in full-sync mode), the zero is overwritten with the true number sl@0: ** of records (see syncJournal()). sl@0: ** sl@0: ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When sl@0: ** reading the journal this value tells SQLite to assume that the sl@0: ** rest of the journal file contains valid page records. This assumption sl@0: ** is dangerous, as if a failure occured whilst writing to the journal sl@0: ** file it may contain some garbage data. There are two scenarios sl@0: ** where this risk can be ignored: sl@0: ** sl@0: ** * When the pager is in no-sync mode. Corruption can follow a sl@0: ** power failure in this case anyway. sl@0: ** sl@0: ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees sl@0: ** that garbage data is never appended to the journal file. sl@0: */ sl@0: assert(pPager->fd->pMethods||pPager->noSync); sl@0: if( (pPager->noSync) sl@0: || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) sl@0: ){ sl@0: put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff); sl@0: }else{ sl@0: put32bits(&zHeader[sizeof(aJournalMagic)], 0); sl@0: } sl@0: sl@0: /* The random check-hash initialiser */ sl@0: sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit); sl@0: put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit); sl@0: /* The initial database size */ sl@0: put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize); sl@0: /* The assumed sector size for this process */ sl@0: put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize); sl@0: if( pPager->journalHdr==0 ){ sl@0: /* The page size */ sl@0: put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize); sl@0: } sl@0: sl@0: for(nWrite=0; rc==SQLITE_OK&&nWritejournalHdr, nHeader)) sl@0: rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff); sl@0: pPager->journalOff += nHeader; sl@0: } sl@0: sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** The journal file must be open when this is called. A journal header file sl@0: ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal sl@0: ** file. See comments above function writeJournalHdr() for a description of sl@0: ** the journal header format. sl@0: ** sl@0: ** If the header is read successfully, *nRec is set to the number of sl@0: ** page records following this header and *dbSize is set to the size of the sl@0: ** database before the transaction began, in pages. Also, pPager->cksumInit sl@0: ** is set to the value read from the journal header. SQLITE_OK is returned sl@0: ** in this case. sl@0: ** sl@0: ** If the journal header file appears to be corrupted, SQLITE_DONE is sl@0: ** returned and *nRec and *dbSize are not set. If JOURNAL_HDR_SZ bytes sl@0: ** cannot be read from the journal file an error code is returned. sl@0: */ sl@0: static int readJournalHdr( sl@0: Pager *pPager, sl@0: i64 journalSize, sl@0: u32 *pNRec, sl@0: u32 *pDbSize sl@0: ){ sl@0: int rc; sl@0: unsigned char aMagic[8]; /* A buffer to hold the magic header */ sl@0: i64 jrnlOff; sl@0: int iPageSize; sl@0: sl@0: seekJournalHdr(pPager); sl@0: if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){ sl@0: return SQLITE_DONE; sl@0: } sl@0: jrnlOff = pPager->journalOff; sl@0: sl@0: rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), jrnlOff); sl@0: if( rc ) return rc; sl@0: jrnlOff += sizeof(aMagic); sl@0: sl@0: if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){ sl@0: return SQLITE_DONE; sl@0: } sl@0: sl@0: rc = read32bits(pPager->jfd, jrnlOff, pNRec); sl@0: if( rc ) return rc; sl@0: sl@0: rc = read32bits(pPager->jfd, jrnlOff+4, &pPager->cksumInit); sl@0: if( rc ) return rc; sl@0: sl@0: rc = read32bits(pPager->jfd, jrnlOff+8, pDbSize); sl@0: if( rc ) return rc; sl@0: sl@0: rc = read32bits(pPager->jfd, jrnlOff+16, (u32 *)&iPageSize); sl@0: if( rc==SQLITE_OK sl@0: && iPageSize>=512 sl@0: && iPageSize<=SQLITE_MAX_PAGE_SIZE sl@0: && ((iPageSize-1)&iPageSize)==0 sl@0: ){ sl@0: u16 pagesize = iPageSize; sl@0: rc = sqlite3PagerSetPagesize(pPager, &pagesize); sl@0: } sl@0: if( rc ) return rc; sl@0: sl@0: /* Update the assumed sector-size to match the value used by sl@0: ** the process that created this journal. If this journal was sl@0: ** created by a process other than this one, then this routine sl@0: ** is being called from within pager_playback(). The local value sl@0: ** of Pager.sectorSize is restored at the end of that routine. sl@0: */ sl@0: rc = read32bits(pPager->jfd, jrnlOff+12, &pPager->sectorSize); sl@0: if( rc ) return rc; sl@0: if( (pPager->sectorSize & (pPager->sectorSize-1))!=0 sl@0: || pPager->sectorSize>0x1000000 ){ sl@0: return SQLITE_DONE; sl@0: } sl@0: sl@0: pPager->journalOff += JOURNAL_HDR_SZ(pPager); sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: sl@0: /* sl@0: ** Write the supplied master journal name into the journal file for pager sl@0: ** pPager at the current location. The master journal name must be the last sl@0: ** thing written to a journal file. If the pager is in full-sync mode, the sl@0: ** journal file descriptor is advanced to the next sector boundary before sl@0: ** anything is written. The format is: sl@0: ** sl@0: ** + 4 bytes: PAGER_MJ_PGNO. sl@0: ** + N bytes: length of master journal name. sl@0: ** + 4 bytes: N sl@0: ** + 4 bytes: Master journal name checksum. sl@0: ** + 8 bytes: aJournalMagic[]. sl@0: ** sl@0: ** The master journal page checksum is the sum of the bytes in the master sl@0: ** journal name. sl@0: ** sl@0: ** If zMaster is a NULL pointer (occurs for a single database transaction), sl@0: ** this call is a no-op. sl@0: */ sl@0: static int writeMasterJournal(Pager *pPager, const char *zMaster){ sl@0: int rc; sl@0: int len; sl@0: int i; sl@0: i64 jrnlOff; sl@0: i64 jrnlSize; sl@0: u32 cksum = 0; sl@0: char zBuf[sizeof(aJournalMagic)+2*4]; sl@0: sl@0: if( !zMaster || pPager->setMaster) return SQLITE_OK; sl@0: pPager->setMaster = 1; sl@0: sl@0: len = strlen(zMaster); sl@0: for(i=0; ifullSync ){ sl@0: seekJournalHdr(pPager); sl@0: } sl@0: jrnlOff = pPager->journalOff; sl@0: pPager->journalOff += (len+20); sl@0: sl@0: rc = write32bits(pPager->jfd, jrnlOff, PAGER_MJ_PGNO(pPager)); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: jrnlOff += 4; sl@0: sl@0: rc = sqlite3OsWrite(pPager->jfd, zMaster, len, jrnlOff); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: jrnlOff += len; sl@0: sl@0: put32bits(zBuf, len); sl@0: put32bits(&zBuf[4], cksum); sl@0: memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic)); sl@0: rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic), jrnlOff); sl@0: jrnlOff += 8+sizeof(aJournalMagic); sl@0: pPager->needSync = !pPager->noSync; sl@0: sl@0: /* If the pager is in peristent-journal mode, then the physical sl@0: ** journal-file may extend past the end of the master-journal name sl@0: ** and 8 bytes of magic data just written to the file. This is sl@0: ** dangerous because the code to rollback a hot-journal file sl@0: ** will not be able to find the master-journal name to determine sl@0: ** whether or not the journal is hot. sl@0: ** sl@0: ** Easiest thing to do in this scenario is to truncate the journal sl@0: ** file to the required size. sl@0: */ sl@0: if( (rc==SQLITE_OK) sl@0: && (rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))==SQLITE_OK sl@0: && jrnlSize>jrnlOff sl@0: ){ sl@0: rc = sqlite3OsTruncate(pPager->jfd, jrnlOff); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Find a page in the hash table given its page number. Return sl@0: ** a pointer to the page or NULL if not found. sl@0: */ sl@0: static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){ sl@0: PgHdr *p; sl@0: sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p); sl@0: return p; sl@0: } sl@0: sl@0: /* sl@0: ** Clear the in-memory cache. This routine sl@0: ** sets the state of the pager back to what it was when it was first sl@0: ** opened. Any outstanding pages are invalidated and subsequent attempts sl@0: ** to access those pages will likely result in a coredump. sl@0: */ sl@0: static void pager_reset(Pager *pPager){ sl@0: if( pPager->errCode ) return; sl@0: sqlite3PcacheClear(pPager->pPCache); sl@0: } sl@0: sl@0: /* sl@0: ** Unlock the database file. sl@0: ** sl@0: ** If the pager is currently in error state, discard the contents of sl@0: ** the cache and reset the Pager structure internal state. If there is sl@0: ** an open journal-file, then the next time a shared-lock is obtained sl@0: ** on the pager file (by this or any other process), it will be sl@0: ** treated as a hot-journal and rolled back. sl@0: */ sl@0: static void pager_unlock(Pager *pPager){ sl@0: if( !pPager->exclusiveMode ){ sl@0: if( !MEMDB ){ sl@0: int rc = osUnlock(pPager->fd, NO_LOCK); sl@0: if( rc ) pPager->errCode = rc; sl@0: pPager->dbSize = -1; sl@0: IOTRACE(("UNLOCK %p\n", pPager)) sl@0: sl@0: /* Always close the journal file when dropping the database lock. sl@0: ** Otherwise, another connection with journal_mode=delete might sl@0: ** delete the file out from under us. sl@0: */ sl@0: if( pPager->journalOpen ){ sl@0: sqlite3OsClose(pPager->jfd); sl@0: pPager->journalOpen = 0; sl@0: sqlite3BitvecDestroy(pPager->pInJournal); sl@0: pPager->pInJournal = 0; sl@0: sqlite3BitvecDestroy(pPager->pAlwaysRollback); sl@0: pPager->pAlwaysRollback = 0; sl@0: } sl@0: sl@0: /* If Pager.errCode is set, the contents of the pager cache cannot be sl@0: ** trusted. Now that the pager file is unlocked, the contents of the sl@0: ** cache can be discarded and the error code safely cleared. sl@0: */ sl@0: if( pPager->errCode ){ sl@0: if( rc==SQLITE_OK ) pPager->errCode = SQLITE_OK; sl@0: pager_reset(pPager); sl@0: if( pPager->stmtOpen ){ sl@0: sqlite3OsClose(pPager->stfd); sl@0: sqlite3BitvecDestroy(pPager->pInStmt); sl@0: pPager->pInStmt = 0; sl@0: } sl@0: pPager->stmtOpen = 0; sl@0: pPager->stmtInUse = 0; sl@0: pPager->journalOff = 0; sl@0: pPager->journalStarted = 0; sl@0: pPager->stmtAutoopen = 0; sl@0: pPager->origDbSize = 0; sl@0: } sl@0: } sl@0: sl@0: if( !MEMDB || pPager->errCode==SQLITE_OK ){ sl@0: pPager->state = PAGER_UNLOCK; sl@0: pPager->changeCountDone = 0; sl@0: } sl@0: } sl@0: } sl@0: sl@0: /* sl@0: ** Execute a rollback if a transaction is active and unlock the sl@0: ** database file. If the pager has already entered the error state, sl@0: ** do not attempt the rollback. sl@0: */ sl@0: static void pagerUnlockAndRollback(Pager *p){ sl@0: if( p->errCode==SQLITE_OK && p->state>=PAGER_RESERVED ){ sl@0: sqlite3BeginBenignMalloc(); sl@0: sqlite3PagerRollback(p); sl@0: sqlite3EndBenignMalloc(); sl@0: } sl@0: pager_unlock(p); sl@0: } sl@0: sl@0: /* sl@0: ** This routine ends a transaction. A transaction is ended by either sl@0: ** a COMMIT or a ROLLBACK. sl@0: ** sl@0: ** When this routine is called, the pager has the journal file open and sl@0: ** a RESERVED or EXCLUSIVE lock on the database. This routine will release sl@0: ** the database lock and acquires a SHARED lock in its place if that is sl@0: ** the appropriate thing to do. Release locks usually is appropriate, sl@0: ** unless we are in exclusive access mode or unless this is a sl@0: ** COMMIT AND BEGIN or ROLLBACK AND BEGIN operation. sl@0: ** sl@0: ** The journal file is either deleted or truncated. sl@0: ** sl@0: ** TODO: Consider keeping the journal file open for temporary databases. sl@0: ** This might give a performance improvement on windows where opening sl@0: ** a file is an expensive operation. sl@0: */ sl@0: static int pager_end_transaction(Pager *pPager, int hasMaster){ sl@0: int rc = SQLITE_OK; sl@0: int rc2 = SQLITE_OK; sl@0: assert( !MEMDB ); sl@0: if( pPager->statestmtOpen && !pPager->exclusiveMode ){ sl@0: sqlite3OsClose(pPager->stfd); sl@0: pPager->stmtOpen = 0; sl@0: } sl@0: if( pPager->journalOpen ){ sl@0: if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE sl@0: && (rc = sqlite3OsTruncate(pPager->jfd, 0))==SQLITE_OK ){ sl@0: pPager->journalOff = 0; sl@0: pPager->journalStarted = 0; sl@0: }else if( pPager->exclusiveMode sl@0: || pPager->journalMode==PAGER_JOURNALMODE_PERSIST sl@0: ){ sl@0: rc = zeroJournalHdr(pPager, hasMaster); sl@0: pager_error(pPager, rc); sl@0: pPager->journalOff = 0; sl@0: pPager->journalStarted = 0; sl@0: }else{ sl@0: assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE || rc ); sl@0: sqlite3OsClose(pPager->jfd); sl@0: pPager->journalOpen = 0; sl@0: if( rc==SQLITE_OK && !pPager->tempFile ){ sl@0: rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); sl@0: } sl@0: } sl@0: sqlite3BitvecDestroy(pPager->pInJournal); sl@0: pPager->pInJournal = 0; sl@0: sqlite3BitvecDestroy(pPager->pAlwaysRollback); sl@0: pPager->pAlwaysRollback = 0; sl@0: sqlite3PcacheCleanAll(pPager->pPCache); sl@0: #ifdef SQLITE_CHECK_PAGES sl@0: sqlite3PcacheIterate(pPager->pPCache, pager_set_pagehash); sl@0: #endif sl@0: sqlite3PcacheClearFlags(pPager->pPCache, sl@0: PGHDR_IN_JOURNAL | PGHDR_NEED_SYNC sl@0: ); sl@0: pPager->dirtyCache = 0; sl@0: pPager->nRec = 0; sl@0: }else{ sl@0: assert( pPager->pInJournal==0 ); sl@0: } sl@0: sl@0: if( !pPager->exclusiveMode ){ sl@0: rc2 = osUnlock(pPager->fd, SHARED_LOCK); sl@0: pPager->state = PAGER_SHARED; sl@0: }else if( pPager->state==PAGER_SYNCED ){ sl@0: pPager->state = PAGER_EXCLUSIVE; sl@0: } sl@0: pPager->origDbSize = 0; sl@0: pPager->setMaster = 0; sl@0: pPager->needSync = 0; sl@0: /* lruListSetFirstSynced(pPager); */ sl@0: pPager->dbSize = -1; sl@0: pPager->dbModified = 0; sl@0: sl@0: return (rc==SQLITE_OK?rc2:rc); sl@0: } sl@0: sl@0: /* sl@0: ** Compute and return a checksum for the page of data. sl@0: ** sl@0: ** This is not a real checksum. It is really just the sum of the sl@0: ** random initial value and the page number. We experimented with sl@0: ** a checksum of the entire data, but that was found to be too slow. sl@0: ** sl@0: ** Note that the page number is stored at the beginning of data and sl@0: ** the checksum is stored at the end. This is important. If journal sl@0: ** corruption occurs due to a power failure, the most likely scenario sl@0: ** is that one end or the other of the record will be changed. It is sl@0: ** much less likely that the two ends of the journal record will be sl@0: ** correct and the middle be corrupt. Thus, this "checksum" scheme, sl@0: ** though fast and simple, catches the mostly likely kind of corruption. sl@0: ** sl@0: ** FIX ME: Consider adding every 200th (or so) byte of the data to the sl@0: ** checksum. That way if a single page spans 3 or more disk sectors and sl@0: ** only the middle sector is corrupt, we will still have a reasonable sl@0: ** chance of failing the checksum and thus detecting the problem. sl@0: */ sl@0: static u32 pager_cksum(Pager *pPager, const u8 *aData){ sl@0: u32 cksum = pPager->cksumInit; sl@0: int i = pPager->pageSize-200; sl@0: while( i>0 ){ sl@0: cksum += aData[i]; sl@0: i -= 200; sl@0: } sl@0: return cksum; sl@0: } sl@0: sl@0: /* sl@0: ** Read a single page from the journal file opened on file descriptor sl@0: ** jfd. Playback this one page. sl@0: ** sl@0: ** The isMainJrnl flag is true if this is the main rollback journal and sl@0: ** false for the statement journal. The main rollback journal uses sl@0: ** checksums - the statement journal does not. sl@0: */ sl@0: static int pager_playback_one_page( sl@0: Pager *pPager, /* The pager being played back */ sl@0: sqlite3_file *jfd, /* The file that is the journal being rolled back */ sl@0: i64 offset, /* Offset of the page within the journal */ sl@0: int isMainJrnl, /* True for main rollback journal. False for Stmt jrnl */ sl@0: int isUnsync /* True if reading from usynced main journal */ sl@0: ){ sl@0: int rc; sl@0: PgHdr *pPg; /* An existing page in the cache */ sl@0: Pgno pgno; /* The page number of a page in journal */ sl@0: u32 cksum; /* Checksum used for sanity checking */ sl@0: u8 *aData = (u8 *)pPager->pTmpSpace; /* Temp storage for a page */ sl@0: sl@0: /* isMainJrnl should be true for the main journal and false for sl@0: ** statement journals. Verify that this is always the case sl@0: */ sl@0: assert( jfd == (isMainJrnl ? pPager->jfd : pPager->stfd) ); sl@0: assert( aData ); sl@0: sl@0: rc = read32bits(jfd, offset, &pgno); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: rc = sqlite3OsRead(jfd, aData, pPager->pageSize, offset+4); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: pPager->journalOff += pPager->pageSize + 4; sl@0: sl@0: /* Sanity checking on the page. This is more important that I originally sl@0: ** thought. If a power failure occurs while the journal is being written, sl@0: ** it could cause invalid data to be written into the journal. We need to sl@0: ** detect this invalid data (with high probability) and ignore it. sl@0: */ sl@0: if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ sl@0: return SQLITE_DONE; sl@0: } sl@0: if( pgno>(unsigned)pPager->dbSize ){ sl@0: return SQLITE_OK; sl@0: } sl@0: if( isMainJrnl ){ sl@0: rc = read32bits(jfd, offset+pPager->pageSize+4, &cksum); sl@0: if( rc ) return rc; sl@0: pPager->journalOff += 4; sl@0: if( pager_cksum(pPager, aData)!=cksum ){ sl@0: return SQLITE_DONE; sl@0: } sl@0: } sl@0: sl@0: assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE ); sl@0: sl@0: /* If the pager is in RESERVED state, then there must be a copy of this sl@0: ** page in the pager cache. In this case just update the pager cache, sl@0: ** not the database file. The page is left marked dirty in this case. sl@0: ** sl@0: ** An exception to the above rule: If the database is in no-sync mode sl@0: ** and a page is moved during an incremental vacuum then the page may sl@0: ** not be in the pager cache. Later: if a malloc() or IO error occurs sl@0: ** during a Movepage() call, then the page may not be in the cache sl@0: ** either. So the condition described in the above paragraph is not sl@0: ** assert()able. sl@0: ** sl@0: ** If in EXCLUSIVE state, then we update the pager cache if it exists sl@0: ** and the main file. The page is then marked not dirty. sl@0: ** sl@0: ** Ticket #1171: The statement journal might contain page content that is sl@0: ** different from the page content at the start of the transaction. sl@0: ** This occurs when a page is changed prior to the start of a statement sl@0: ** then changed again within the statement. When rolling back such a sl@0: ** statement we must not write to the original database unless we know sl@0: ** for certain that original page contents are synced into the main rollback sl@0: ** journal. Otherwise, a power loss might leave modified data in the sl@0: ** database file without an entry in the rollback journal that can sl@0: ** restore the database to its original form. Two conditions must be sl@0: ** met before writing to the database files. (1) the database must be sl@0: ** locked. (2) we know that the original page content is fully synced sl@0: ** in the main journal either because the page is not in cache or else sl@0: ** the page is marked as needSync==0. sl@0: ** sl@0: ** 2008-04-14: When attempting to vacuum a corrupt database file, it sl@0: ** is possible to fail a statement on a database that does not yet exist. sl@0: ** Do not attempt to write if database file has never been opened. sl@0: */ sl@0: pPg = pager_lookup(pPager, pgno); sl@0: PAGERTRACE4("PLAYBACK %d page %d hash(%08x)\n", sl@0: PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData)); sl@0: if( (pPager->state>=PAGER_EXCLUSIVE) sl@0: && (pPg==0 || 0==(pPg->flags&PGHDR_NEED_SYNC)) sl@0: && (pPager->fd->pMethods) sl@0: && !isUnsync sl@0: ){ sl@0: i64 ofst = (pgno-1)*(i64)pPager->pageSize; sl@0: rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, ofst); sl@0: } sl@0: if( pPg ){ sl@0: /* No page should ever be explicitly rolled back that is in use, except sl@0: ** for page 1 which is held in use in order to keep the lock on the sl@0: ** database active. However such a page may be rolled back as a result sl@0: ** of an internal error resulting in an automatic call to sl@0: ** sqlite3PagerRollback(). sl@0: */ sl@0: void *pData; sl@0: pData = pPg->pData; sl@0: memcpy(pData, aData, pPager->pageSize); sl@0: if( pPager->xReiniter ){ sl@0: pPager->xReiniter(pPg); sl@0: } sl@0: if( isMainJrnl ) sqlite3PcacheMakeClean(pPg); sl@0: #ifdef SQLITE_CHECK_PAGES sl@0: pPg->pageHash = pager_pagehash(pPg); sl@0: #endif sl@0: /* If this was page 1, then restore the value of Pager.dbFileVers. sl@0: ** Do this before any decoding. */ sl@0: if( pgno==1 ){ sl@0: memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers)); sl@0: } sl@0: sl@0: /* Decode the page just read from disk */ sl@0: CODEC1(pPager, pData, pPg->pgno, 3); sl@0: sqlite3PcacheRelease(pPg); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Parameter zMaster is the name of a master journal file. A single journal sl@0: ** file that referred to the master journal file has just been rolled back. sl@0: ** This routine checks if it is possible to delete the master journal file, sl@0: ** and does so if it is. sl@0: ** sl@0: ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not sl@0: ** available for use within this function. sl@0: ** sl@0: ** sl@0: ** The master journal file contains the names of all child journals. sl@0: ** To tell if a master journal can be deleted, check to each of the sl@0: ** children. If all children are either missing or do not refer to sl@0: ** a different master journal, then this master journal can be deleted. sl@0: */ sl@0: static int pager_delmaster(Pager *pPager, const char *zMaster){ sl@0: sqlite3_vfs *pVfs = pPager->pVfs; sl@0: int rc; sl@0: int master_open = 0; sl@0: sqlite3_file *pMaster; sl@0: sqlite3_file *pJournal; sl@0: char *zMasterJournal = 0; /* Contents of master journal file */ sl@0: i64 nMasterJournal; /* Size of master journal file */ sl@0: sl@0: /* Open the master journal file exclusively in case some other process sl@0: ** is running this routine also. Not that it makes too much difference. sl@0: */ sl@0: pMaster = (sqlite3_file *)sqlite3Malloc(pVfs->szOsFile * 2); sl@0: pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile); sl@0: if( !pMaster ){ sl@0: rc = SQLITE_NOMEM; sl@0: }else{ sl@0: int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL); sl@0: rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0); sl@0: } sl@0: if( rc!=SQLITE_OK ) goto delmaster_out; sl@0: master_open = 1; sl@0: sl@0: rc = sqlite3OsFileSize(pMaster, &nMasterJournal); sl@0: if( rc!=SQLITE_OK ) goto delmaster_out; sl@0: sl@0: if( nMasterJournal>0 ){ sl@0: char *zJournal; sl@0: char *zMasterPtr = 0; sl@0: int nMasterPtr = pPager->pVfs->mxPathname+1; sl@0: sl@0: /* Load the entire master journal file into space obtained from sl@0: ** sqlite3_malloc() and pointed to by zMasterJournal. sl@0: */ sl@0: zMasterJournal = (char *)sqlite3Malloc(nMasterJournal + nMasterPtr); sl@0: if( !zMasterJournal ){ sl@0: rc = SQLITE_NOMEM; sl@0: goto delmaster_out; sl@0: } sl@0: zMasterPtr = &zMasterJournal[nMasterJournal]; sl@0: rc = sqlite3OsRead(pMaster, zMasterJournal, nMasterJournal, 0); sl@0: if( rc!=SQLITE_OK ) goto delmaster_out; sl@0: sl@0: zJournal = zMasterJournal; sl@0: while( (zJournal-zMasterJournal)state>=PAGER_EXCLUSIVE && pPager->fd->pMethods ){ sl@0: i64 currentSize, newSize; sl@0: rc = sqlite3OsFileSize(pPager->fd, ¤tSize); sl@0: newSize = pPager->pageSize*(i64)nPage; sl@0: if( rc==SQLITE_OK && currentSize!=newSize ){ sl@0: if( currentSize>newSize ){ sl@0: rc = sqlite3OsTruncate(pPager->fd, newSize); sl@0: }else{ sl@0: rc = sqlite3OsWrite(pPager->fd, "", 1, newSize-1); sl@0: } sl@0: } sl@0: } sl@0: if( rc==SQLITE_OK ){ sl@0: pPager->dbSize = nPage; sl@0: pager_truncate_cache(pPager); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Set the sectorSize for the given pager. sl@0: ** sl@0: ** The sector size is at least as big as the sector size reported sl@0: ** by sqlite3OsSectorSize(). The minimum sector size is 512. sl@0: */ sl@0: static void setSectorSize(Pager *pPager){ sl@0: assert(pPager->fd->pMethods||pPager->tempFile); sl@0: if( !pPager->tempFile ){ sl@0: /* Sector size doesn't matter for temporary files. Also, the file sl@0: ** may not have been opened yet, in whcih case the OsSectorSize() sl@0: ** call will segfault. sl@0: */ sl@0: pPager->sectorSize = sqlite3OsSectorSize(pPager->fd); sl@0: } sl@0: if( pPager->sectorSize<512 ){ sl@0: pPager->sectorSize = 512; sl@0: } sl@0: } sl@0: sl@0: /* sl@0: ** Playback the journal and thus restore the database file to sl@0: ** the state it was in before we started making changes. sl@0: ** sl@0: ** The journal file format is as follows: sl@0: ** sl@0: ** (1) 8 byte prefix. A copy of aJournalMagic[]. sl@0: ** (2) 4 byte big-endian integer which is the number of valid page records sl@0: ** in the journal. If this value is 0xffffffff, then compute the sl@0: ** number of page records from the journal size. sl@0: ** (3) 4 byte big-endian integer which is the initial value for the sl@0: ** sanity checksum. sl@0: ** (4) 4 byte integer which is the number of pages to truncate the sl@0: ** database to during a rollback. sl@0: ** (5) 4 byte big-endian integer which is the sector size. The header sl@0: ** is this many bytes in size. sl@0: ** (6) 4 byte big-endian integer which is the page case. sl@0: ** (7) 4 byte integer which is the number of bytes in the master journal sl@0: ** name. The value may be zero (indicate that there is no master sl@0: ** journal.) sl@0: ** (8) N bytes of the master journal name. The name will be nul-terminated sl@0: ** and might be shorter than the value read from (5). If the first byte sl@0: ** of the name is \000 then there is no master journal. The master sl@0: ** journal name is stored in UTF-8. sl@0: ** (9) Zero or more pages instances, each as follows: sl@0: ** + 4 byte page number. sl@0: ** + pPager->pageSize bytes of data. sl@0: ** + 4 byte checksum sl@0: ** sl@0: ** When we speak of the journal header, we mean the first 8 items above. sl@0: ** Each entry in the journal is an instance of the 9th item. sl@0: ** sl@0: ** Call the value from the second bullet "nRec". nRec is the number of sl@0: ** valid page entries in the journal. In most cases, you can compute the sl@0: ** value of nRec from the size of the journal file. But if a power sl@0: ** failure occurred while the journal was being written, it could be the sl@0: ** case that the size of the journal file had already been increased but sl@0: ** the extra entries had not yet made it safely to disk. In such a case, sl@0: ** the value of nRec computed from the file size would be too large. For sl@0: ** that reason, we always use the nRec value in the header. sl@0: ** sl@0: ** If the nRec value is 0xffffffff it means that nRec should be computed sl@0: ** from the file size. This value is used when the user selects the sl@0: ** no-sync option for the journal. A power failure could lead to corruption sl@0: ** in this case. But for things like temporary table (which will be sl@0: ** deleted when the power is restored) we don't care. sl@0: ** sl@0: ** If the file opened as the journal file is not a well-formed sl@0: ** journal file then all pages up to the first corrupted page are rolled sl@0: ** back (or no pages if the journal header is corrupted). The journal file sl@0: ** is then deleted and SQLITE_OK returned, just as if no corruption had sl@0: ** been encountered. sl@0: ** sl@0: ** If an I/O or malloc() error occurs, the journal-file is not deleted sl@0: ** and an error code is returned. sl@0: */ sl@0: static int pager_playback(Pager *pPager, int isHot){ sl@0: sqlite3_vfs *pVfs = pPager->pVfs; sl@0: i64 szJ; /* Size of the journal file in bytes */ sl@0: u32 nRec; /* Number of Records in the journal */ sl@0: u32 u; /* Unsigned loop counter */ sl@0: Pgno mxPg = 0; /* Size of the original file in pages */ sl@0: int rc; /* Result code of a subroutine */ sl@0: int res = 1; /* Value returned by sqlite3OsAccess() */ sl@0: char *zMaster = 0; /* Name of master journal file if any */ sl@0: sl@0: /* Figure out how many records are in the journal. Abort early if sl@0: ** the journal is empty. sl@0: */ sl@0: assert( pPager->journalOpen ); sl@0: rc = sqlite3OsFileSize(pPager->jfd, &szJ); sl@0: if( rc!=SQLITE_OK || szJ==0 ){ sl@0: goto end_playback; sl@0: } sl@0: sl@0: /* Read the master journal name from the journal, if it is present. sl@0: ** If a master journal file name is specified, but the file is not sl@0: ** present on disk, then the journal is not hot and does not need to be sl@0: ** played back. sl@0: */ sl@0: zMaster = pPager->pTmpSpace; sl@0: rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); sl@0: if( rc==SQLITE_OK && zMaster[0] ){ sl@0: rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res); sl@0: } sl@0: zMaster = 0; sl@0: if( rc!=SQLITE_OK || !res ){ sl@0: goto end_playback; sl@0: } sl@0: pPager->journalOff = 0; sl@0: sl@0: /* This loop terminates either when the readJournalHdr() call returns sl@0: ** SQLITE_DONE or an IO error occurs. */ sl@0: while( 1 ){ sl@0: int isUnsync = 0; sl@0: sl@0: /* Read the next journal header from the journal file. If there are sl@0: ** not enough bytes left in the journal file for a complete header, or sl@0: ** it is corrupted, then a process must of failed while writing it. sl@0: ** This indicates nothing more needs to be rolled back. sl@0: */ sl@0: rc = readJournalHdr(pPager, szJ, &nRec, &mxPg); sl@0: if( rc!=SQLITE_OK ){ sl@0: if( rc==SQLITE_DONE ){ sl@0: rc = SQLITE_OK; sl@0: } sl@0: goto end_playback; sl@0: } sl@0: sl@0: /* If nRec is 0xffffffff, then this journal was created by a process sl@0: ** working in no-sync mode. This means that the rest of the journal sl@0: ** file consists of pages, there are no more journal headers. Compute sl@0: ** the value of nRec based on this assumption. sl@0: */ sl@0: if( nRec==0xffffffff ){ sl@0: assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ); sl@0: nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager); sl@0: } sl@0: sl@0: /* If nRec is 0 and this rollback is of a transaction created by this sl@0: ** process and if this is the final header in the journal, then it means sl@0: ** that this part of the journal was being filled but has not yet been sl@0: ** synced to disk. Compute the number of pages based on the remaining sl@0: ** size of the file. sl@0: ** sl@0: ** The third term of the test was added to fix ticket #2565. sl@0: */ sl@0: if( nRec==0 && !isHot && sl@0: pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){ sl@0: nRec = (szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager); sl@0: isUnsync = 1; sl@0: } sl@0: sl@0: /* If this is the first header read from the journal, truncate the sl@0: ** database file back to its original size. sl@0: */ sl@0: if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){ sl@0: rc = pager_truncate(pPager, mxPg); sl@0: if( rc!=SQLITE_OK ){ sl@0: goto end_playback; sl@0: } sl@0: } sl@0: sl@0: /* Copy original pages out of the journal and back into the database file. sl@0: */ sl@0: for(u=0; ujfd, pPager->journalOff, 1, sl@0: isUnsync); sl@0: if( rc!=SQLITE_OK ){ sl@0: if( rc==SQLITE_DONE ){ sl@0: rc = SQLITE_OK; sl@0: pPager->journalOff = szJ; sl@0: break; sl@0: }else{ sl@0: /* If we are unable to rollback, then the database is probably sl@0: ** going to end up being corrupt. It is corrupt to us, anyhow. sl@0: ** Perhaps the next process to come along can fix it.... sl@0: */ sl@0: rc = SQLITE_CORRUPT_BKPT; sl@0: goto end_playback; sl@0: } sl@0: } sl@0: } sl@0: } sl@0: /*NOTREACHED*/ sl@0: assert( 0 ); sl@0: sl@0: end_playback: sl@0: /* If this playback is happening automatically as a result of an IO or sl@0: ** malloc error that occured after the change-counter was updated but sl@0: ** before the transaction was committed, then the change-counter sl@0: ** modification may just have been reverted. If this happens in exclusive sl@0: ** mode, then subsequent transactions performed by the connection will not sl@0: ** update the change-counter at all. This may lead to cache inconsistency sl@0: ** problems for other processes at some point in the future. So, just sl@0: ** in case this has happened, clear the changeCountDone flag now. sl@0: */ sl@0: pPager->changeCountDone = 0; sl@0: sl@0: if( rc==SQLITE_OK ){ sl@0: zMaster = pPager->pTmpSpace; sl@0: rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); sl@0: } sl@0: if( rc==SQLITE_OK ){ sl@0: rc = pager_end_transaction(pPager, zMaster[0]!='\0'); sl@0: } sl@0: if( rc==SQLITE_OK && zMaster[0] && res ){ sl@0: /* If there was a master journal and this routine will return success, sl@0: ** see if it is possible to delete the master journal. sl@0: */ sl@0: rc = pager_delmaster(pPager, zMaster); sl@0: } sl@0: sl@0: /* The Pager.sectorSize variable may have been updated while rolling sl@0: ** back a journal created by a process with a different sector size sl@0: ** value. Reset it to the correct value for this process. sl@0: */ sl@0: setSectorSize(pPager); sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Playback the statement journal. sl@0: ** sl@0: ** This is similar to playing back the transaction journal but with sl@0: ** a few extra twists. sl@0: ** sl@0: ** (1) The number of pages in the database file at the start of sl@0: ** the statement is stored in pPager->stmtSize, not in the sl@0: ** journal file itself. sl@0: ** sl@0: ** (2) In addition to playing back the statement journal, also sl@0: ** playback all pages of the transaction journal beginning sl@0: ** at offset pPager->stmtJSize. sl@0: */ sl@0: static int pager_stmt_playback(Pager *pPager){ sl@0: i64 szJ; /* Size of the full journal */ sl@0: i64 hdrOff; sl@0: int nRec; /* Number of Records */ sl@0: int i; /* Loop counter */ sl@0: int rc; sl@0: sl@0: szJ = pPager->journalOff; sl@0: sl@0: /* Set hdrOff to be the offset just after the end of the last journal sl@0: ** page written before the first journal-header for this statement sl@0: ** transaction was written, or the end of the file if no journal sl@0: ** header was written. sl@0: */ sl@0: hdrOff = pPager->stmtHdrOff; sl@0: assert( pPager->fullSync || !hdrOff ); sl@0: if( !hdrOff ){ sl@0: hdrOff = szJ; sl@0: } sl@0: sl@0: /* Truncate the database back to its original size. sl@0: */ sl@0: rc = pager_truncate(pPager, pPager->stmtSize); sl@0: assert( pPager->state>=PAGER_SHARED ); sl@0: sl@0: /* Figure out how many records are in the statement journal. sl@0: */ sl@0: assert( pPager->stmtInUse && pPager->journalOpen ); sl@0: nRec = pPager->stmtNRec; sl@0: sl@0: /* Copy original pages out of the statement journal and back into the sl@0: ** database file. Note that the statement journal omits checksums from sl@0: ** each record since power-failure recovery is not important to statement sl@0: ** journals. sl@0: */ sl@0: for(i=0; ipageSize); sl@0: rc = pager_playback_one_page(pPager, pPager->stfd, offset, 0, 0); sl@0: assert( rc!=SQLITE_DONE ); sl@0: if( rc!=SQLITE_OK ) goto end_stmt_playback; sl@0: } sl@0: sl@0: /* Now roll some pages back from the transaction journal. Pager.stmtJSize sl@0: ** was the size of the journal file when this statement was started, so sl@0: ** everything after that needs to be rolled back, either into the sl@0: ** database, the memory cache, or both. sl@0: ** sl@0: ** If it is not zero, then Pager.stmtHdrOff is the offset to the start sl@0: ** of the first journal header written during this statement transaction. sl@0: */ sl@0: pPager->journalOff = pPager->stmtJSize; sl@0: pPager->cksumInit = pPager->stmtCksum; sl@0: while( pPager->journalOff < hdrOff ){ sl@0: rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1, 0); sl@0: assert( rc!=SQLITE_DONE ); sl@0: if( rc!=SQLITE_OK ) goto end_stmt_playback; sl@0: } sl@0: sl@0: while( pPager->journalOff < szJ ){ sl@0: u32 nJRec; /* Number of Journal Records */ sl@0: u32 dummy; sl@0: rc = readJournalHdr(pPager, szJ, &nJRec, &dummy); sl@0: if( rc!=SQLITE_OK ){ sl@0: assert( rc!=SQLITE_DONE ); sl@0: goto end_stmt_playback; sl@0: } sl@0: if( nJRec==0 ){ sl@0: nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8); sl@0: } sl@0: for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){ sl@0: rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff,1,0); sl@0: assert( rc!=SQLITE_DONE ); sl@0: if( rc!=SQLITE_OK ) goto end_stmt_playback; sl@0: } sl@0: } sl@0: sl@0: pPager->journalOff = szJ; sl@0: sl@0: end_stmt_playback: sl@0: if( rc==SQLITE_OK) { sl@0: pPager->journalOff = szJ; sl@0: /* pager_reload_cache(pPager); */ sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Change the maximum number of in-memory pages that are allowed. sl@0: */ sl@0: void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){ sl@0: sqlite3PcacheSetCachesize(pPager->pPCache, mxPage); sl@0: } sl@0: sl@0: /* sl@0: ** Adjust the robustness of the database to damage due to OS crashes sl@0: ** or power failures by changing the number of syncs()s when writing sl@0: ** the rollback journal. There are three levels: sl@0: ** sl@0: ** OFF sqlite3OsSync() is never called. This is the default sl@0: ** for temporary and transient files. sl@0: ** sl@0: ** NORMAL The journal is synced once before writes begin on the sl@0: ** database. This is normally adequate protection, but sl@0: ** it is theoretically possible, though very unlikely, sl@0: ** that an inopertune power failure could leave the journal sl@0: ** in a state which would cause damage to the database sl@0: ** when it is rolled back. sl@0: ** sl@0: ** FULL The journal is synced twice before writes begin on the sl@0: ** database (with some additional information - the nRec field sl@0: ** of the journal header - being written in between the two sl@0: ** syncs). If we assume that writing a sl@0: ** single disk sector is atomic, then this mode provides sl@0: ** assurance that the journal will not be corrupted to the sl@0: ** point of causing damage to the database during rollback. sl@0: ** sl@0: ** Numeric values associated with these states are OFF==1, NORMAL=2, sl@0: ** and FULL=3. sl@0: */ sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){ sl@0: pPager->noSync = level==1 || pPager->tempFile || MEMDB; sl@0: pPager->fullSync = level==3 && !pPager->tempFile; sl@0: pPager->sync_flags = (bFullFsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL); sl@0: if( pPager->noSync ) pPager->needSync = 0; sl@0: } sl@0: #endif sl@0: sl@0: /* sl@0: ** The following global variable is incremented whenever the library sl@0: ** attempts to open a temporary file. This information is used for sl@0: ** testing and analysis only. sl@0: */ sl@0: #ifdef SQLITE_TEST sl@0: int sqlite3_opentemp_count = 0; sl@0: #endif sl@0: sl@0: /* sl@0: ** Open a temporary file. sl@0: ** sl@0: ** Write the file descriptor into *fd. Return SQLITE_OK on success or some sl@0: ** other error code if we fail. The OS will automatically delete the temporary sl@0: ** file when it is closed. sl@0: */ sl@0: static int sqlite3PagerOpentemp( sl@0: Pager *pPager, /* The pager object */ sl@0: sqlite3_file *pFile, /* Write the file descriptor here */ sl@0: int vfsFlags /* Flags passed through to the VFS */ sl@0: ){ sl@0: int rc; sl@0: sl@0: #ifdef SQLITE_TEST sl@0: sqlite3_opentemp_count++; /* Used for testing and analysis only */ sl@0: #endif sl@0: sl@0: vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | sl@0: SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE; sl@0: rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0); sl@0: assert( rc!=SQLITE_OK || pFile->pMethods ); sl@0: return rc; sl@0: } sl@0: sl@0: static int pagerStress(void *,PgHdr *); sl@0: sl@0: /* sl@0: ** Create a new page cache and put a pointer to the page cache in *ppPager. sl@0: ** The file to be cached need not exist. The file is not locked until sl@0: ** the first call to sqlite3PagerGet() and is only held open until the sl@0: ** last page is released using sqlite3PagerUnref(). sl@0: ** sl@0: ** If zFilename is NULL then a randomly-named temporary file is created sl@0: ** and used as the file to be cached. The file will be deleted sl@0: ** automatically when it is closed. sl@0: ** sl@0: ** If zFilename is ":memory:" then all information is held in cache. sl@0: ** It is never written to disk. This can be used to implement an sl@0: ** in-memory database. sl@0: */ sl@0: int sqlite3PagerOpen( sl@0: sqlite3_vfs *pVfs, /* The virtual file system to use */ sl@0: Pager **ppPager, /* Return the Pager structure here */ sl@0: const char *zFilename, /* Name of the database file to open */ sl@0: int nExtra, /* Extra bytes append to each in-memory page */ sl@0: int flags, /* flags controlling this file */ sl@0: int vfsFlags /* flags passed through to sqlite3_vfs.xOpen() */ sl@0: ){ sl@0: u8 *pPtr; sl@0: Pager *pPager = 0; sl@0: int rc = SQLITE_OK; sl@0: int i; sl@0: int tempFile = 0; sl@0: int memDb = 0; sl@0: int readOnly = 0; sl@0: int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; sl@0: int noReadlock = (flags & PAGER_NO_READLOCK)!=0; sl@0: int journalFileSize = sqlite3JournalSize(pVfs); sl@0: int pcacheSize = sqlite3PcacheSize(); sl@0: int szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; sl@0: char *zPathname = 0; sl@0: int nPathname = 0; sl@0: sl@0: /* The default return is a NULL pointer */ sl@0: *ppPager = 0; sl@0: sl@0: /* Compute and store the full pathname in an allocated buffer pointed sl@0: ** to by zPathname, length nPathname. Or, if this is a temporary file, sl@0: ** leave both nPathname and zPathname set to 0. sl@0: */ sl@0: if( zFilename && zFilename[0] ){ sl@0: nPathname = pVfs->mxPathname+1; sl@0: zPathname = sqlite3Malloc(nPathname*2); sl@0: if( zPathname==0 ){ sl@0: return SQLITE_NOMEM; sl@0: } sl@0: #ifndef SQLITE_OMIT_MEMORYDB sl@0: if( strcmp(zFilename,":memory:")==0 ){ sl@0: memDb = 1; sl@0: zPathname[0] = 0; sl@0: useJournal = 0; sl@0: }else sl@0: #endif sl@0: { sl@0: rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname); sl@0: } sl@0: if( rc!=SQLITE_OK ){ sl@0: sqlite3_free(zPathname); sl@0: return rc; sl@0: } sl@0: nPathname = strlen(zPathname); sl@0: } sl@0: sl@0: /* Allocate memory for the pager structure */ sl@0: pPager = sqlite3MallocZero( sl@0: sizeof(*pPager) + /* Pager structure */ sl@0: pcacheSize + /* PCache object */ sl@0: journalFileSize + /* The journal file structure */ sl@0: pVfs->szOsFile * 3 + /* The main db and two journal files */ sl@0: 3*nPathname + 40 /* zFilename, zDirectory, zJournal */ sl@0: ); sl@0: if( !pPager ){ sl@0: sqlite3_free(zPathname); sl@0: return SQLITE_NOMEM; sl@0: } sl@0: pPager->pPCache = (PCache *)&pPager[1]; sl@0: pPtr = ((u8 *)&pPager[1]) + pcacheSize; sl@0: pPager->vfsFlags = vfsFlags; sl@0: pPager->fd = (sqlite3_file*)&pPtr[pVfs->szOsFile*0]; sl@0: pPager->stfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*1]; sl@0: pPager->jfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*2]; sl@0: pPager->zFilename = (char*)&pPtr[pVfs->szOsFile*2+journalFileSize]; sl@0: pPager->zDirectory = &pPager->zFilename[nPathname+1]; sl@0: pPager->zJournal = &pPager->zDirectory[nPathname+1]; sl@0: pPager->pVfs = pVfs; sl@0: if( zPathname ){ sl@0: memcpy(pPager->zFilename, zPathname, nPathname+1); sl@0: sqlite3_free(zPathname); sl@0: } sl@0: sl@0: /* Open the pager file. sl@0: */ sl@0: if( zFilename && zFilename[0] && !memDb ){ sl@0: if( nPathname>(pVfs->mxPathname - sizeof("-journal")) ){ sl@0: rc = SQLITE_CANTOPEN; sl@0: }else{ sl@0: int fout = 0; sl@0: rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, sl@0: pPager->vfsFlags, &fout); sl@0: readOnly = (fout&SQLITE_OPEN_READONLY); sl@0: sl@0: /* If the file was successfully opened for read/write access, sl@0: ** choose a default page size in case we have to create the sl@0: ** database file. The default page size is the maximum of: sl@0: ** sl@0: ** + SQLITE_DEFAULT_PAGE_SIZE, sl@0: ** + The value returned by sqlite3OsSectorSize() sl@0: ** + The largest page size that can be written atomically. sl@0: */ sl@0: if( rc==SQLITE_OK && !readOnly ){ sl@0: int iSectorSize = sqlite3OsSectorSize(pPager->fd); sl@0: if( szPageDfltfd); sl@0: int ii; sl@0: assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); sl@0: assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); sl@0: assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536); sl@0: for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){ sl@0: if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ) szPageDflt = ii; sl@0: } sl@0: } sl@0: #endif sl@0: if( szPageDflt>SQLITE_MAX_DEFAULT_PAGE_SIZE ){ sl@0: szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE; sl@0: } sl@0: } sl@0: } sl@0: }else if( !memDb ){ sl@0: /* If a temporary file is requested, it is not opened immediately. sl@0: ** In this case we accept the default page size and delay actually sl@0: ** opening the file until the first call to OsWrite(). sl@0: */ sl@0: tempFile = 1; sl@0: pPager->state = PAGER_EXCLUSIVE; sl@0: } sl@0: sl@0: if( pPager && rc==SQLITE_OK ){ sl@0: pPager->pTmpSpace = sqlite3PageMalloc(szPageDflt); sl@0: } sl@0: sl@0: /* If an error occured in either of the blocks above. sl@0: ** Free the Pager structure and close the file. sl@0: ** Since the pager is not allocated there is no need to set sl@0: ** any Pager.errMask variables. sl@0: */ sl@0: if( !pPager || !pPager->pTmpSpace ){ sl@0: sqlite3OsClose(pPager->fd); sl@0: sqlite3_free(pPager); sl@0: return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc); sl@0: } sl@0: nExtra = FORCE_ALIGNMENT(nExtra); sl@0: sqlite3PcacheOpen(szPageDflt, nExtra, !memDb, sl@0: !memDb?pagerStress:0, (void *)pPager, pPager->pPCache); sl@0: sl@0: PAGERTRACE3("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename); sl@0: IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename)) sl@0: sl@0: /* Fill in Pager.zDirectory[] */ sl@0: memcpy(pPager->zDirectory, pPager->zFilename, nPathname+1); sl@0: for(i=strlen(pPager->zDirectory); i>0 && pPager->zDirectory[i-1]!='/'; i--){} sl@0: if( i>0 ) pPager->zDirectory[i-1] = 0; sl@0: sl@0: /* Fill in Pager.zJournal[] */ sl@0: if( zPathname ){ sl@0: memcpy(pPager->zJournal, pPager->zFilename, nPathname); sl@0: memcpy(&pPager->zJournal[nPathname], "-journal", 9); sl@0: }else{ sl@0: pPager->zJournal = 0; sl@0: } sl@0: sl@0: /* pPager->journalOpen = 0; */ sl@0: pPager->useJournal = useJournal; sl@0: pPager->noReadlock = noReadlock && readOnly; sl@0: /* pPager->stmtOpen = 0; */ sl@0: /* pPager->stmtInUse = 0; */ sl@0: /* pPager->nRef = 0; */ sl@0: pPager->dbSize = memDb-1; sl@0: pPager->pageSize = szPageDflt; sl@0: /* pPager->stmtSize = 0; */ sl@0: /* pPager->stmtJSize = 0; */ sl@0: /* pPager->nPage = 0; */ sl@0: pPager->mxPage = 100; sl@0: pPager->mxPgno = SQLITE_MAX_PAGE_COUNT; sl@0: /* pPager->state = PAGER_UNLOCK; */ sl@0: assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) ); sl@0: /* pPager->errMask = 0; */ sl@0: pPager->tempFile = tempFile; sl@0: assert( tempFile==PAGER_LOCKINGMODE_NORMAL sl@0: || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE ); sl@0: assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 ); sl@0: pPager->exclusiveMode = tempFile; sl@0: pPager->memDb = memDb; sl@0: pPager->readOnly = readOnly; sl@0: /* pPager->needSync = 0; */ sl@0: pPager->noSync = pPager->tempFile || !useJournal; sl@0: pPager->fullSync = (pPager->noSync?0:1); sl@0: pPager->sync_flags = SQLITE_SYNC_NORMAL; sl@0: /* pPager->pFirst = 0; */ sl@0: /* pPager->pFirstSynced = 0; */ sl@0: /* pPager->pLast = 0; */ sl@0: pPager->nExtra = nExtra; sl@0: pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT; sl@0: assert(pPager->fd->pMethods||memDb||tempFile); sl@0: if( !memDb ){ sl@0: setSectorSize(pPager); sl@0: } sl@0: /* pPager->pBusyHandler = 0; */ sl@0: /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ sl@0: *ppPager = pPager; sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** Set the busy handler function. sl@0: */ sl@0: void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){ sl@0: pPager->pBusyHandler = pBusyHandler; sl@0: } sl@0: sl@0: /* sl@0: ** Set the reinitializer for this pager. If not NULL, the reinitializer sl@0: ** is called when the content of a page in cache is restored to its original sl@0: ** value as a result of a rollback. The callback gives higher-level code sl@0: ** an opportunity to restore the EXTRA section to agree with the restored sl@0: ** page data. sl@0: */ sl@0: void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*)){ sl@0: pPager->xReiniter = xReinit; sl@0: } sl@0: sl@0: /* sl@0: ** Set the page size to *pPageSize. If the suggest new page size is sl@0: ** inappropriate, then an alternative page size is set to that sl@0: ** value before returning. sl@0: */ sl@0: int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize){ sl@0: int rc = pPager->errCode; sl@0: if( rc==SQLITE_OK ){ sl@0: u16 pageSize = *pPageSize; sl@0: assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) ); sl@0: if( pageSize && pageSize!=pPager->pageSize sl@0: && (pPager->memDb==0 || pPager->dbSize==0) sl@0: && sqlite3PcacheRefCount(pPager->pPCache)==0 sl@0: ){ sl@0: char *pNew = (char *)sqlite3PageMalloc(pageSize); sl@0: if( !pNew ){ sl@0: rc = SQLITE_NOMEM; sl@0: }else{ sl@0: pager_reset(pPager); sl@0: pPager->pageSize = pageSize; sl@0: if( !pPager->memDb ) setSectorSize(pPager); sl@0: sqlite3PageFree(pPager->pTmpSpace); sl@0: pPager->pTmpSpace = pNew; sl@0: sqlite3PcacheSetPageSize(pPager->pPCache, pageSize); sl@0: } sl@0: } sl@0: *pPageSize = pPager->pageSize; sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Return a pointer to the "temporary page" buffer held internally sl@0: ** by the pager. This is a buffer that is big enough to hold the sl@0: ** entire content of a database page. This buffer is used internally sl@0: ** during rollback and will be overwritten whenever a rollback sl@0: ** occurs. But other modules are free to use it too, as long as sl@0: ** no rollbacks are happening. sl@0: */ sl@0: void *sqlite3PagerTempSpace(Pager *pPager){ sl@0: return pPager->pTmpSpace; sl@0: } sl@0: sl@0: /* sl@0: ** Attempt to set the maximum database page count if mxPage is positive. sl@0: ** Make no changes if mxPage is zero or negative. And never reduce the sl@0: ** maximum page count below the current size of the database. sl@0: ** sl@0: ** Regardless of mxPage, return the current maximum page count. sl@0: */ sl@0: int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){ sl@0: if( mxPage>0 ){ sl@0: pPager->mxPgno = mxPage; sl@0: } sl@0: sqlite3PagerPagecount(pPager, 0); sl@0: return pPager->mxPgno; sl@0: } sl@0: sl@0: /* sl@0: ** The following set of routines are used to disable the simulated sl@0: ** I/O error mechanism. These routines are used to avoid simulated sl@0: ** errors in places where we do not care about errors. sl@0: ** sl@0: ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops sl@0: ** and generate no code. sl@0: */ sl@0: #ifdef SQLITE_TEST sl@0: extern int sqlite3_io_error_pending; sl@0: extern int sqlite3_io_error_hit; sl@0: static int saved_cnt; sl@0: void disable_simulated_io_errors(void){ sl@0: saved_cnt = sqlite3_io_error_pending; sl@0: sqlite3_io_error_pending = -1; sl@0: } sl@0: void enable_simulated_io_errors(void){ sl@0: sqlite3_io_error_pending = saved_cnt; sl@0: } sl@0: #else sl@0: # define disable_simulated_io_errors() sl@0: # define enable_simulated_io_errors() sl@0: #endif sl@0: sl@0: /* sl@0: ** Read the first N bytes from the beginning of the file into memory sl@0: ** that pDest points to. sl@0: ** sl@0: ** No error checking is done. The rational for this is that this function sl@0: ** may be called even if the file does not exist or contain a header. In sl@0: ** these cases sqlite3OsRead() will return an error, to which the correct sl@0: ** response is to zero the memory at pDest and continue. A real IO error sl@0: ** will presumably recur and be picked up later (Todo: Think about this). sl@0: */ sl@0: int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){ sl@0: int rc = SQLITE_OK; sl@0: memset(pDest, 0, N); sl@0: assert(MEMDB||pPager->fd->pMethods||pPager->tempFile); sl@0: if( pPager->fd->pMethods ){ sl@0: IOTRACE(("DBHDR %p 0 %d\n", pPager, N)) sl@0: rc = sqlite3OsRead(pPager->fd, pDest, N, 0); sl@0: if( rc==SQLITE_IOERR_SHORT_READ ){ sl@0: rc = SQLITE_OK; sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Return the total number of pages in the disk file associated with sl@0: ** pPager. sl@0: ** sl@0: ** If the PENDING_BYTE lies on the page directly after the end of the sl@0: ** file, then consider this page part of the file too. For example, if sl@0: ** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the sl@0: ** file is 4096 bytes, 5 is returned instead of 4. sl@0: */ sl@0: int sqlite3PagerPagecount(Pager *pPager, int *pnPage){ sl@0: i64 n = 0; sl@0: int rc; sl@0: assert( pPager!=0 ); sl@0: if( pPager->errCode ){ sl@0: rc = pPager->errCode; sl@0: return rc; sl@0: } sl@0: if( pPager->dbSize>=0 ){ sl@0: n = pPager->dbSize; sl@0: } else { sl@0: assert(pPager->fd->pMethods||pPager->tempFile); sl@0: if( (pPager->fd->pMethods) sl@0: && (rc = sqlite3OsFileSize(pPager->fd, &n))!=SQLITE_OK ){ sl@0: pager_error(pPager, rc); sl@0: return rc; sl@0: } sl@0: if( n>0 && npageSize ){ sl@0: n = 1; sl@0: }else{ sl@0: n /= pPager->pageSize; sl@0: } sl@0: if( pPager->state!=PAGER_UNLOCK ){ sl@0: pPager->dbSize = n; sl@0: } sl@0: } sl@0: if( n==(PENDING_BYTE/pPager->pageSize) ){ sl@0: n++; sl@0: } sl@0: if( n>pPager->mxPgno ){ sl@0: pPager->mxPgno = n; sl@0: } sl@0: if( pnPage ){ sl@0: *pnPage = n; sl@0: } sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** Forward declaration sl@0: */ sl@0: static int syncJournal(Pager*); sl@0: sl@0: /* sl@0: ** This routine is used to truncate the cache when a database sl@0: ** is truncated. Drop from the cache all pages whose pgno is sl@0: ** larger than pPager->dbSize and is unreferenced. sl@0: ** sl@0: ** Referenced pages larger than pPager->dbSize are zeroed. sl@0: ** sl@0: ** Actually, at the point this routine is called, it would be sl@0: ** an error to have a referenced page. But rather than delete sl@0: ** that page and guarantee a subsequent segfault, it seems better sl@0: ** to zero it and hope that we error out sanely. sl@0: */ sl@0: static void pager_truncate_cache(Pager *pPager){ sl@0: sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize); sl@0: } sl@0: sl@0: /* sl@0: ** Try to obtain a lock on a file. Invoke the busy callback if the lock sl@0: ** is currently not available. Repeat until the busy callback returns sl@0: ** false or until the lock succeeds. sl@0: ** sl@0: ** Return SQLITE_OK on success and an error code if we cannot obtain sl@0: ** the lock. sl@0: */ sl@0: static int pager_wait_on_lock(Pager *pPager, int locktype){ sl@0: int rc; sl@0: sl@0: /* The OS lock values must be the same as the Pager lock values */ sl@0: assert( PAGER_SHARED==SHARED_LOCK ); sl@0: assert( PAGER_RESERVED==RESERVED_LOCK ); sl@0: assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK ); sl@0: sl@0: /* If the file is currently unlocked then the size must be unknown */ sl@0: assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB ); sl@0: sl@0: if( pPager->state>=locktype ){ sl@0: rc = SQLITE_OK; sl@0: }else{ sl@0: if( pPager->pBusyHandler ) pPager->pBusyHandler->nBusy = 0; sl@0: do { sl@0: rc = sqlite3OsLock(pPager->fd, locktype); sl@0: }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) ); sl@0: if( rc==SQLITE_OK ){ sl@0: pPager->state = locktype; sl@0: IOTRACE(("LOCK %p %d\n", pPager, locktype)) sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Truncate the file to the number of pages specified. sl@0: */ sl@0: int sqlite3PagerTruncate(Pager *pPager, Pgno nPage){ sl@0: int rc = SQLITE_OK; sl@0: assert( pPager->state>=PAGER_SHARED || MEMDB ); sl@0: sl@0: sl@0: sqlite3PagerPagecount(pPager, 0); sl@0: if( pPager->errCode ){ sl@0: rc = pPager->errCode; sl@0: }else if( nPage<(unsigned)pPager->dbSize ){ sl@0: if( MEMDB ){ sl@0: pPager->dbSize = nPage; sl@0: pager_truncate_cache(pPager); sl@0: }else{ sl@0: rc = syncJournal(pPager); sl@0: if( rc==SQLITE_OK ){ sl@0: /* Get an exclusive lock on the database before truncating. */ sl@0: rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); sl@0: } sl@0: if( rc==SQLITE_OK ){ sl@0: rc = pager_truncate(pPager, nPage); sl@0: } sl@0: } sl@0: } sl@0: sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Shutdown the page cache. Free all memory and close all files. sl@0: ** sl@0: ** If a transaction was in progress when this routine is called, that sl@0: ** transaction is rolled back. All outstanding pages are invalidated sl@0: ** and their memory is freed. Any attempt to use a page associated sl@0: ** with this page cache after this function returns will likely sl@0: ** result in a coredump. sl@0: ** sl@0: ** This function always succeeds. If a transaction is active an attempt sl@0: ** is made to roll it back. If an error occurs during the rollback sl@0: ** a hot journal may be left in the filesystem but no error is returned sl@0: ** to the caller. sl@0: */ sl@0: int sqlite3PagerClose(Pager *pPager){ sl@0: sl@0: disable_simulated_io_errors(); sl@0: sqlite3BeginBenignMalloc(); sl@0: pPager->errCode = 0; sl@0: pPager->exclusiveMode = 0; sl@0: pager_reset(pPager); sl@0: pagerUnlockAndRollback(pPager); sl@0: enable_simulated_io_errors(); sl@0: sqlite3EndBenignMalloc(); sl@0: PAGERTRACE2("CLOSE %d\n", PAGERID(pPager)); sl@0: IOTRACE(("CLOSE %p\n", pPager)) sl@0: if( pPager->journalOpen ){ sl@0: sqlite3OsClose(pPager->jfd); sl@0: } sl@0: sqlite3BitvecDestroy(pPager->pInJournal); sl@0: sqlite3BitvecDestroy(pPager->pAlwaysRollback); sl@0: if( pPager->stmtOpen ){ sl@0: sqlite3OsClose(pPager->stfd); sl@0: } sl@0: sqlite3OsClose(pPager->fd); sl@0: /* Temp files are automatically deleted by the OS sl@0: ** if( pPager->tempFile ){ sl@0: ** sqlite3OsDelete(pPager->zFilename); sl@0: ** } sl@0: */ sl@0: sl@0: sqlite3PageFree(pPager->pTmpSpace); sl@0: sqlite3PcacheClose(pPager->pPCache); sl@0: sqlite3_free(pPager); sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: #if !defined(NDEBUG) || defined(SQLITE_TEST) sl@0: /* sl@0: ** Return the page number for the given page data. sl@0: */ sl@0: Pgno sqlite3PagerPagenumber(DbPage *p){ sl@0: return p->pgno; sl@0: } sl@0: #endif sl@0: sl@0: /* sl@0: ** Increment the reference count for a page. The input pointer is sl@0: ** a reference to the page data. sl@0: */ sl@0: int sqlite3PagerRef(DbPage *pPg){ sl@0: sqlite3PcacheRef(pPg); sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** Sync the journal. In other words, make sure all the pages that have sl@0: ** been written to the journal have actually reached the surface of the sl@0: ** disk. It is not safe to modify the original database file until after sl@0: ** the journal has been synced. If the original database is modified before sl@0: ** the journal is synced and a power failure occurs, the unsynced journal sl@0: ** data would be lost and we would be unable to completely rollback the sl@0: ** database changes. Database corruption would occur. sl@0: ** sl@0: ** This routine also updates the nRec field in the header of the journal. sl@0: ** (See comments on the pager_playback() routine for additional information.) sl@0: ** If the sync mode is FULL, two syncs will occur. First the whole journal sl@0: ** is synced, then the nRec field is updated, then a second sync occurs. sl@0: ** sl@0: ** For temporary databases, we do not care if we are able to rollback sl@0: ** after a power failure, so no sync occurs. sl@0: ** sl@0: ** If the IOCAP_SEQUENTIAL flag is set for the persistent media on which sl@0: ** the database is stored, then OsSync() is never called on the journal sl@0: ** file. In this case all that is required is to update the nRec field in sl@0: ** the journal header. sl@0: ** sl@0: ** This routine clears the needSync field of every page current held in sl@0: ** memory. sl@0: */ sl@0: static int syncJournal(Pager *pPager){ sl@0: int rc = SQLITE_OK; sl@0: sl@0: /* Sync the journal before modifying the main database sl@0: ** (assuming there is a journal and it needs to be synced.) sl@0: */ sl@0: if( pPager->needSync ){ sl@0: if( !pPager->tempFile ){ sl@0: int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); sl@0: assert( pPager->journalOpen ); sl@0: sl@0: if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ sl@0: i64 jrnlOff = journalHdrOffset(pPager); sl@0: u8 zMagic[8]; sl@0: sl@0: /* This block deals with an obscure problem. If the last connection sl@0: ** that wrote to this database was operating in persistent-journal sl@0: ** mode, then the journal file may at this point actually be larger sl@0: ** than Pager.journalOff bytes. If the next thing in the journal sl@0: ** file happens to be a journal-header (written as part of the sl@0: ** previous connections transaction), and a crash or power-failure sl@0: ** occurs after nRec is updated but before this connection writes sl@0: ** anything else to the journal file (or commits/rolls back its sl@0: ** transaction), then SQLite may become confused when doing the sl@0: ** hot-journal rollback following recovery. It may roll back all sl@0: ** of this connections data, then proceed to rolling back the old, sl@0: ** out-of-date data that follows it. Database corruption. sl@0: ** sl@0: ** To work around this, if the journal file does appear to contain sl@0: ** a valid header following Pager.journalOff, then write a 0x00 sl@0: ** byte to the start of it to prevent it from being recognized. sl@0: */ sl@0: rc = sqlite3OsRead(pPager->jfd, zMagic, 8, jrnlOff); sl@0: if( rc==SQLITE_OK && 0==memcmp(zMagic, aJournalMagic, 8) ){ sl@0: static const u8 zerobyte = 0; sl@0: rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, jrnlOff); sl@0: } sl@0: if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ sl@0: return rc; sl@0: } sl@0: sl@0: /* Write the nRec value into the journal file header. If in sl@0: ** full-synchronous mode, sync the journal first. This ensures that sl@0: ** all data has really hit the disk before nRec is updated to mark sl@0: ** it as a candidate for rollback. sl@0: ** sl@0: ** This is not required if the persistent media supports the sl@0: ** SAFE_APPEND property. Because in this case it is not possible sl@0: ** for garbage data to be appended to the file, the nRec field sl@0: ** is populated with 0xFFFFFFFF when the journal header is written sl@0: ** and never needs to be updated. sl@0: */ sl@0: if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ sl@0: PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager)); sl@0: IOTRACE(("JSYNC %p\n", pPager)) sl@0: rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags); sl@0: if( rc!=0 ) return rc; sl@0: } sl@0: sl@0: jrnlOff = pPager->journalHdr + sizeof(aJournalMagic); sl@0: IOTRACE(("JHDR %p %lld %d\n", pPager, jrnlOff, 4)); sl@0: rc = write32bits(pPager->jfd, jrnlOff, pPager->nRec); sl@0: if( rc ) return rc; sl@0: } sl@0: if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ sl@0: PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager)); sl@0: IOTRACE(("JSYNC %p\n", pPager)) sl@0: rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags| sl@0: (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0) sl@0: ); sl@0: if( rc!=0 ) return rc; sl@0: } sl@0: pPager->journalStarted = 1; sl@0: } sl@0: pPager->needSync = 0; sl@0: sl@0: /* Erase the needSync flag from every page. sl@0: */ sl@0: sqlite3PcacheClearFlags(pPager->pPCache, PGHDR_NEED_SYNC); sl@0: } sl@0: sl@0: #ifndef NDEBUG sl@0: /* If the Pager.needSync flag is clear then the PgHdr.needSync sl@0: ** flag must also be clear for all pages. Verify that this sl@0: ** invariant is true. sl@0: */ sl@0: else{ sl@0: sqlite3PcacheAssertFlags(pPager->pPCache, 0, PGHDR_NEED_SYNC); sl@0: } sl@0: #endif sl@0: sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Given a list of pages (connected by the PgHdr.pDirty pointer) write sl@0: ** every one of those pages out to the database file. No calls are made sl@0: ** to the page-cache to mark the pages as clean. It is the responsibility sl@0: ** of the caller to use PcacheCleanAll() or PcacheMakeClean() to mark sl@0: ** the pages as clean. sl@0: */ sl@0: static int pager_write_pagelist(PgHdr *pList){ sl@0: Pager *pPager; sl@0: int rc; sl@0: sl@0: if( pList==0 ) return SQLITE_OK; sl@0: pPager = pList->pPager; sl@0: sl@0: /* At this point there may be either a RESERVED or EXCLUSIVE lock on the sl@0: ** database file. If there is already an EXCLUSIVE lock, the following sl@0: ** calls to sqlite3OsLock() are no-ops. sl@0: ** sl@0: ** Moving the lock from RESERVED to EXCLUSIVE actually involves going sl@0: ** through an intermediate state PENDING. A PENDING lock prevents new sl@0: ** readers from attaching to the database but is unsufficient for us to sl@0: ** write. The idea of a PENDING lock is to prevent new readers from sl@0: ** coming in while we wait for existing readers to clear. sl@0: ** sl@0: ** While the pager is in the RESERVED state, the original database file sl@0: ** is unchanged and we can rollback without having to playback the sl@0: ** journal into the original database file. Once we transition to sl@0: ** EXCLUSIVE, it means the database file has been changed and any rollback sl@0: ** will require a journal playback. sl@0: */ sl@0: rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: sl@0: while( pList ){ sl@0: sl@0: /* If the file has not yet been opened, open it now. */ sl@0: if( !pPager->fd->pMethods ){ sl@0: assert(pPager->tempFile); sl@0: rc = sqlite3PagerOpentemp(pPager, pPager->fd, pPager->vfsFlags); sl@0: if( rc ) return rc; sl@0: } sl@0: sl@0: /* If there are dirty pages in the page cache with page numbers greater sl@0: ** than Pager.dbSize, this means sqlite3PagerTruncate() was called to sl@0: ** make the file smaller (presumably by auto-vacuum code). Do not write sl@0: ** any such pages to the file. sl@0: */ sl@0: if( pList->pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){ sl@0: i64 offset = (pList->pgno-1)*(i64)pPager->pageSize; sl@0: char *pData = CODEC2(pPager, pList->pData, pList->pgno, 6); sl@0: PAGERTRACE4("STORE %d page %d hash(%08x)\n", sl@0: PAGERID(pPager), pList->pgno, pager_pagehash(pList)); sl@0: IOTRACE(("PGOUT %p %d\n", pPager, pList->pgno)); sl@0: rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset); sl@0: PAGER_INCR(sqlite3_pager_writedb_count); sl@0: PAGER_INCR(pPager->nWrite); sl@0: if( pList->pgno==1 ){ sl@0: memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); sl@0: } sl@0: } sl@0: #ifndef NDEBUG sl@0: else{ sl@0: PAGERTRACE3("NOSTORE %d page %d\n", PAGERID(pPager), pList->pgno); sl@0: } sl@0: #endif sl@0: if( rc ) return rc; sl@0: #ifdef SQLITE_CHECK_PAGES sl@0: pList->pageHash = pager_pagehash(pList); sl@0: #endif sl@0: pList = pList->pDirty; sl@0: } sl@0: sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** This function is called by the pcache layer when it has reached some sl@0: ** soft memory limit. The argument is a pointer to a purgeable Pager sl@0: ** object. This function attempts to make a single dirty page that has no sl@0: ** outstanding references (if one exists) clean so that it can be recycled sl@0: ** by the pcache layer. sl@0: */ sl@0: static int pagerStress(void *p, PgHdr *pPg){ sl@0: Pager *pPager = (Pager *)p; sl@0: int rc = SQLITE_OK; sl@0: sl@0: if( pPager->doNotSync ){ sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: assert( pPg->flags&PGHDR_DIRTY ); sl@0: if( pPager->errCode==SQLITE_OK ){ sl@0: if( pPg->flags&PGHDR_NEED_SYNC ){ sl@0: rc = syncJournal(pPager); sl@0: if( rc==SQLITE_OK && pPager->fullSync && sl@0: !(sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) sl@0: ){ sl@0: pPager->nRec = 0; sl@0: rc = writeJournalHdr(pPager); sl@0: } sl@0: } sl@0: if( rc==SQLITE_OK ){ sl@0: pPg->pDirty = 0; sl@0: rc = pager_write_pagelist(pPg); sl@0: } sl@0: if( rc!=SQLITE_OK ){ sl@0: pager_error(pPager, rc); sl@0: } sl@0: } sl@0: sl@0: if( rc==SQLITE_OK ){ sl@0: sqlite3PcacheMakeClean(pPg); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: sl@0: /* sl@0: ** Return 1 if there is a hot journal on the given pager. sl@0: ** A hot journal is one that needs to be played back. sl@0: ** sl@0: ** If the current size of the database file is 0 but a journal file sl@0: ** exists, that is probably an old journal left over from a prior sl@0: ** database with the same name. Just delete the journal. sl@0: ** sl@0: ** Return negative if unable to determine the status of the journal. sl@0: ** sl@0: ** This routine does not open the journal file to examine its sl@0: ** content. Hence, the journal might contain the name of a master sl@0: ** journal file that has been deleted, and hence not be hot. Or sl@0: ** the header of the journal might be zeroed out. This routine sl@0: ** does not discover these cases of a non-hot journal - if the sl@0: ** journal file exists and is not empty this routine assumes it sl@0: ** is hot. The pager_playback() routine will discover that the sl@0: ** journal file is not really hot and will no-op. sl@0: */ sl@0: static int hasHotJournal(Pager *pPager, int *pExists){ sl@0: sqlite3_vfs *pVfs = pPager->pVfs; sl@0: int rc = SQLITE_OK; sl@0: int exists; sl@0: int locked; sl@0: assert( pPager!=0 ); sl@0: assert( pPager->useJournal ); sl@0: assert( pPager->fd->pMethods ); sl@0: *pExists = 0; sl@0: rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists); sl@0: if( rc==SQLITE_OK && exists ){ sl@0: rc = sqlite3OsCheckReservedLock(pPager->fd, &locked); sl@0: } sl@0: if( rc==SQLITE_OK && exists && !locked ){ sl@0: int nPage; sl@0: rc = sqlite3PagerPagecount(pPager, &nPage); sl@0: if( rc==SQLITE_OK ){ sl@0: if( nPage==0 ){ sl@0: sqlite3OsDelete(pVfs, pPager->zJournal, 0); sl@0: }else{ sl@0: *pExists = 1; sl@0: } sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Read the content of page pPg out of the database file. sl@0: */ sl@0: static int readDbPage(Pager *pPager, PgHdr *pPg, Pgno pgno){ sl@0: int rc; sl@0: i64 offset; sl@0: assert( MEMDB==0 ); sl@0: assert(pPager->fd->pMethods||pPager->tempFile); sl@0: if( !pPager->fd->pMethods ){ sl@0: return SQLITE_IOERR_SHORT_READ; sl@0: } sl@0: offset = (pgno-1)*(i64)pPager->pageSize; sl@0: rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, offset); sl@0: PAGER_INCR(sqlite3_pager_readdb_count); sl@0: PAGER_INCR(pPager->nRead); sl@0: IOTRACE(("PGIN %p %d\n", pPager, pgno)); sl@0: if( pgno==1 ){ sl@0: memcpy(&pPager->dbFileVers, &((u8*)pPg->pData)[24], sl@0: sizeof(pPager->dbFileVers)); sl@0: } sl@0: CODEC1(pPager, pPg->pData, pPg->pgno, 3); sl@0: PAGERTRACE4("FETCH %d page %d hash(%08x)\n", sl@0: PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)); sl@0: return rc; sl@0: } sl@0: sl@0: sl@0: /* sl@0: ** This function is called to obtain the shared lock required before sl@0: ** data may be read from the pager cache. If the shared lock has already sl@0: ** been obtained, this function is a no-op. sl@0: ** sl@0: ** Immediately after obtaining the shared lock (if required), this function sl@0: ** checks for a hot-journal file. If one is found, an emergency rollback sl@0: ** is performed immediately. sl@0: */ sl@0: static int pagerSharedLock(Pager *pPager){ sl@0: int rc = SQLITE_OK; sl@0: int isErrorReset = 0; sl@0: sl@0: /* If this database is opened for exclusive access, has no outstanding sl@0: ** page references and is in an error-state, now is the chance to clear sl@0: ** the error. Discard the contents of the pager-cache and treat any sl@0: ** open journal file as a hot-journal. sl@0: */ sl@0: if( !MEMDB && pPager->exclusiveMode sl@0: && sqlite3PcacheRefCount(pPager->pPCache)==0 && pPager->errCode sl@0: ){ sl@0: if( pPager->journalOpen ){ sl@0: isErrorReset = 1; sl@0: } sl@0: pPager->errCode = SQLITE_OK; sl@0: pager_reset(pPager); sl@0: } sl@0: sl@0: /* If the pager is still in an error state, do not proceed. The error sl@0: ** state will be cleared at some point in the future when all page sl@0: ** references are dropped and the cache can be discarded. sl@0: */ sl@0: if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ sl@0: return pPager->errCode; sl@0: } sl@0: sl@0: if( pPager->state==PAGER_UNLOCK || isErrorReset ){ sl@0: sqlite3_vfs *pVfs = pPager->pVfs; sl@0: if( !MEMDB ){ sl@0: int isHotJournal; sl@0: assert( sqlite3PcacheRefCount(pPager->pPCache)==0 ); sl@0: if( !pPager->noReadlock ){ sl@0: rc = pager_wait_on_lock(pPager, SHARED_LOCK); sl@0: if( rc!=SQLITE_OK ){ sl@0: assert( pPager->state==PAGER_UNLOCK ); sl@0: return pager_error(pPager, rc); sl@0: } sl@0: assert( pPager->state>=SHARED_LOCK ); sl@0: } sl@0: sl@0: /* If a journal file exists, and there is no RESERVED lock on the sl@0: ** database file, then it either needs to be played back or deleted. sl@0: */ sl@0: if( !isErrorReset ){ sl@0: rc = hasHotJournal(pPager, &isHotJournal); sl@0: if( rc!=SQLITE_OK ){ sl@0: goto failed; sl@0: } sl@0: } sl@0: if( isErrorReset || isHotJournal ){ sl@0: /* Get an EXCLUSIVE lock on the database file. At this point it is sl@0: ** important that a RESERVED lock is not obtained on the way to the sl@0: ** EXCLUSIVE lock. If it were, another process might open the sl@0: ** database file, detect the RESERVED lock, and conclude that the sl@0: ** database is safe to read while this process is still rolling it sl@0: ** back. sl@0: ** sl@0: ** Because the intermediate RESERVED lock is not requested, the sl@0: ** second process will get to this point in the code and fail to sl@0: ** obtain its own EXCLUSIVE lock on the database file. sl@0: */ sl@0: if( pPager->statefd, EXCLUSIVE_LOCK); sl@0: if( rc!=SQLITE_OK ){ sl@0: rc = pager_error(pPager, rc); sl@0: goto failed; sl@0: } sl@0: pPager->state = PAGER_EXCLUSIVE; sl@0: } sl@0: sl@0: /* Open the journal for read/write access. This is because in sl@0: ** exclusive-access mode the file descriptor will be kept open and sl@0: ** possibly used for a transaction later on. On some systems, the sl@0: ** OsTruncate() call used in exclusive-access mode also requires sl@0: ** a read/write file handle. sl@0: */ sl@0: if( !isErrorReset && pPager->journalOpen==0 ){ sl@0: int res; sl@0: rc = sqlite3OsAccess(pVfs,pPager->zJournal,SQLITE_ACCESS_EXISTS,&res); sl@0: if( rc==SQLITE_OK ){ sl@0: if( res ){ sl@0: int fout = 0; sl@0: int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL; sl@0: assert( !pPager->tempFile ); sl@0: rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout); sl@0: assert( rc!=SQLITE_OK || pPager->jfd->pMethods ); sl@0: if( fout&SQLITE_OPEN_READONLY ){ sl@0: rc = SQLITE_BUSY; sl@0: sqlite3OsClose(pPager->jfd); sl@0: } sl@0: }else{ sl@0: /* If the journal does not exist, that means some other process sl@0: ** has already rolled it back */ sl@0: rc = SQLITE_BUSY; sl@0: } sl@0: } sl@0: } sl@0: if( rc!=SQLITE_OK ){ sl@0: if( rc!=SQLITE_NOMEM && rc!=SQLITE_IOERR_UNLOCK sl@0: && rc!=SQLITE_IOERR_NOMEM sl@0: ){ sl@0: rc = SQLITE_BUSY; sl@0: } sl@0: goto failed; sl@0: } sl@0: pPager->journalOpen = 1; sl@0: pPager->journalStarted = 0; sl@0: pPager->journalOff = 0; sl@0: pPager->setMaster = 0; sl@0: pPager->journalHdr = 0; sl@0: sl@0: /* Playback and delete the journal. Drop the database write sl@0: ** lock and reacquire the read lock. Purge the cache before sl@0: ** playing back the hot-journal so that we don't end up with sl@0: */ sl@0: sqlite3PcacheClear(pPager->pPCache); sl@0: rc = pager_playback(pPager, 1); sl@0: if( rc!=SQLITE_OK ){ sl@0: rc = pager_error(pPager, rc); sl@0: goto failed; sl@0: } sl@0: assert(pPager->state==PAGER_SHARED || sl@0: (pPager->exclusiveMode && pPager->state>PAGER_SHARED) sl@0: ); sl@0: } sl@0: sl@0: if( sqlite3PcachePagecount(pPager->pPCache)>0 ){ sl@0: /* The shared-lock has just been acquired on the database file sl@0: ** and there are already pages in the cache (from a previous sl@0: ** read or write transaction). Check to see if the database sl@0: ** has been modified. If the database has changed, flush the sl@0: ** cache. sl@0: ** sl@0: ** Database changes is detected by looking at 15 bytes beginning sl@0: ** at offset 24 into the file. The first 4 of these 16 bytes are sl@0: ** a 32-bit counter that is incremented with each change. The sl@0: ** other bytes change randomly with each file change when sl@0: ** a codec is in use. sl@0: ** sl@0: ** There is a vanishingly small chance that a change will not be sl@0: ** detected. The chance of an undetected change is so small that sl@0: ** it can be neglected. sl@0: */ sl@0: char dbFileVers[sizeof(pPager->dbFileVers)]; sl@0: sqlite3PagerPagecount(pPager, 0); sl@0: sl@0: if( pPager->errCode ){ sl@0: rc = pPager->errCode; sl@0: goto failed; sl@0: } sl@0: sl@0: if( pPager->dbSize>0 ){ sl@0: IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers))); sl@0: rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24); sl@0: if( rc!=SQLITE_OK ){ sl@0: goto failed; sl@0: } sl@0: }else{ sl@0: memset(dbFileVers, 0, sizeof(dbFileVers)); sl@0: } sl@0: sl@0: if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){ sl@0: pager_reset(pPager); sl@0: } sl@0: } sl@0: } sl@0: assert( pPager->exclusiveMode || pPager->state<=PAGER_SHARED ); sl@0: if( pPager->state==PAGER_UNLOCK ){ sl@0: pPager->state = PAGER_SHARED; sl@0: } sl@0: } sl@0: sl@0: failed: sl@0: if( rc!=SQLITE_OK ){ sl@0: /* pager_unlock() is a no-op for exclusive mode and in-memory databases. */ sl@0: pager_unlock(pPager); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Make sure we have the content for a page. If the page was sl@0: ** previously acquired with noContent==1, then the content was sl@0: ** just initialized to zeros instead of being read from disk. sl@0: ** But now we need the real data off of disk. So make sure we sl@0: ** have it. Read it in if we do not have it already. sl@0: */ sl@0: static int pager_get_content(PgHdr *pPg){ sl@0: if( pPg->flags&PGHDR_NEED_READ ){ sl@0: int rc = readDbPage(pPg->pPager, pPg, pPg->pgno); sl@0: if( rc==SQLITE_OK ){ sl@0: pPg->flags &= ~PGHDR_NEED_READ; sl@0: }else{ sl@0: return rc; sl@0: } sl@0: } sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** If the reference count has reached zero, and the pager is not in the sl@0: ** middle of a write transaction or opened in exclusive mode, unlock it. sl@0: */ sl@0: static void pagerUnlockIfUnused(Pager *pPager){ sl@0: if( (sqlite3PcacheRefCount(pPager->pPCache)==0) sl@0: && (!pPager->exclusiveMode || pPager->journalOff>0) sl@0: ){ sl@0: pagerUnlockAndRollback(pPager); sl@0: } sl@0: } sl@0: sl@0: /* sl@0: ** Drop a page from the cache using sqlite3PcacheDrop(). sl@0: ** sl@0: ** If this means there are now no pages with references to them, a rollback sl@0: ** occurs and the lock on the database is removed. sl@0: */ sl@0: static void pagerDropPage(DbPage *pPg){ sl@0: Pager *pPager = pPg->pPager; sl@0: sqlite3PcacheDrop(pPg); sl@0: pagerUnlockIfUnused(pPager); sl@0: } sl@0: sl@0: /* sl@0: ** Acquire a page. sl@0: ** sl@0: ** A read lock on the disk file is obtained when the first page is acquired. sl@0: ** This read lock is dropped when the last page is released. sl@0: ** sl@0: ** This routine works for any page number greater than 0. If the database sl@0: ** file is smaller than the requested page, then no actual disk sl@0: ** read occurs and the memory image of the page is initialized to sl@0: ** all zeros. The extra data appended to a page is always initialized sl@0: ** to zeros the first time a page is loaded into memory. sl@0: ** sl@0: ** The acquisition might fail for several reasons. In all cases, sl@0: ** an appropriate error code is returned and *ppPage is set to NULL. sl@0: ** sl@0: ** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt sl@0: ** to find a page in the in-memory cache first. If the page is not already sl@0: ** in memory, this routine goes to disk to read it in whereas Lookup() sl@0: ** just returns 0. This routine acquires a read-lock the first time it sl@0: ** has to go to disk, and could also playback an old journal if necessary. sl@0: ** Since Lookup() never goes to disk, it never has to deal with locks sl@0: ** or journal files. sl@0: ** sl@0: ** If noContent is false, the page contents are actually read from disk. sl@0: ** If noContent is true, it means that we do not care about the contents sl@0: ** of the page at this time, so do not do a disk read. Just fill in the sl@0: ** page content with zeros. But mark the fact that we have not read the sl@0: ** content by setting the PgHdr.needRead flag. Later on, if sl@0: ** sqlite3PagerWrite() is called on this page or if this routine is sl@0: ** called again with noContent==0, that means that the content is needed sl@0: ** and the disk read should occur at that point. sl@0: */ sl@0: int sqlite3PagerAcquire( sl@0: Pager *pPager, /* The pager open on the database file */ sl@0: Pgno pgno, /* Page number to fetch */ sl@0: DbPage **ppPage, /* Write a pointer to the page here */ sl@0: int noContent /* Do not bother reading content from disk if true */ sl@0: ){ sl@0: PgHdr *pPg = 0; sl@0: int rc; sl@0: sl@0: assert( pPager->state==PAGER_UNLOCK sl@0: || sqlite3PcacheRefCount(pPager->pPCache)>0 sl@0: || pgno==1 sl@0: ); sl@0: sl@0: /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page sl@0: ** number greater than this, or zero, is requested. sl@0: */ sl@0: if( pgno>PAGER_MAX_PGNO || pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ sl@0: return SQLITE_CORRUPT_BKPT; sl@0: } sl@0: sl@0: /* Make sure we have not hit any critical errors. sl@0: */ sl@0: assert( pPager!=0 ); sl@0: *ppPage = 0; sl@0: sl@0: /* If this is the first page accessed, then get a SHARED lock sl@0: ** on the database file. pagerSharedLock() is a no-op if sl@0: ** a database lock is already held. sl@0: */ sl@0: rc = pagerSharedLock(pPager); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: assert( pPager->state!=PAGER_UNLOCK ); sl@0: sl@0: rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, &pPg); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: if( pPg->pPager==0 ){ sl@0: /* The pager cache has created a new page. Its content needs to sl@0: ** be initialized. sl@0: */ sl@0: int nMax; sl@0: PAGER_INCR(pPager->nMiss); sl@0: pPg->pPager = pPager; sl@0: if( sqlite3BitvecTest(pPager->pInJournal, pgno) ){ sl@0: assert( !MEMDB ); sl@0: pPg->flags |= PGHDR_IN_JOURNAL; sl@0: } sl@0: memset(pPg->pExtra, 0, pPager->nExtra); sl@0: sl@0: rc = sqlite3PagerPagecount(pPager, &nMax); sl@0: if( rc!=SQLITE_OK ){ sl@0: sqlite3PagerUnref(pPg); sl@0: return rc; sl@0: } sl@0: sl@0: if( nMax<(int)pgno || MEMDB || noContent ){ sl@0: if( pgno>pPager->mxPgno ){ sl@0: sqlite3PagerUnref(pPg); sl@0: return SQLITE_FULL; sl@0: } sl@0: memset(pPg->pData, 0, pPager->pageSize); sl@0: if( noContent ){ sl@0: pPg->flags |= PGHDR_NEED_READ; sl@0: } sl@0: IOTRACE(("ZERO %p %d\n", pPager, pgno)); sl@0: }else{ sl@0: rc = readDbPage(pPager, pPg, pgno); sl@0: if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ sl@0: /* sqlite3PagerUnref(pPg); */ sl@0: pagerDropPage(pPg); sl@0: return rc; sl@0: } sl@0: } sl@0: #ifdef SQLITE_CHECK_PAGES sl@0: pPg->pageHash = pager_pagehash(pPg); sl@0: #endif sl@0: }else{ sl@0: /* The requested page is in the page cache. */ sl@0: assert(sqlite3PcacheRefCount(pPager->pPCache)>0 || pgno==1); sl@0: PAGER_INCR(pPager->nHit); sl@0: if( !noContent ){ sl@0: rc = pager_get_content(pPg); sl@0: if( rc ){ sl@0: sqlite3PagerUnref(pPg); sl@0: return rc; sl@0: } sl@0: } sl@0: } sl@0: sl@0: *ppPage = pPg; sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** Acquire a page if it is already in the in-memory cache. Do sl@0: ** not read the page from disk. Return a pointer to the page, sl@0: ** or 0 if the page is not in cache. sl@0: ** sl@0: ** See also sqlite3PagerGet(). The difference between this routine sl@0: ** and sqlite3PagerGet() is that _get() will go to the disk and read sl@0: ** in the page if the page is not already in cache. This routine sl@0: ** returns NULL if the page is not in cache or if a disk I/O error sl@0: ** has ever happened. sl@0: */ sl@0: DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){ sl@0: PgHdr *pPg = 0; sl@0: assert( pPager!=0 ); sl@0: assert( pgno!=0 ); sl@0: sl@0: if( (pPager->state!=PAGER_UNLOCK) sl@0: && (pPager->errCode==SQLITE_OK || pPager->errCode==SQLITE_FULL) sl@0: ){ sl@0: sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg); sl@0: } sl@0: sl@0: return pPg; sl@0: } sl@0: sl@0: /* sl@0: ** Release a page. sl@0: ** sl@0: ** If the number of references to the page drop to zero, then the sl@0: ** page is added to the LRU list. When all references to all pages sl@0: ** are released, a rollback occurs and the lock on the database is sl@0: ** removed. sl@0: */ sl@0: int sqlite3PagerUnref(DbPage *pPg){ sl@0: if( pPg ){ sl@0: Pager *pPager = pPg->pPager; sl@0: sqlite3PcacheRelease(pPg); sl@0: pagerUnlockIfUnused(pPager); sl@0: } sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** Create a journal file for pPager. There should already be a RESERVED sl@0: ** or EXCLUSIVE lock on the database file when this routine is called. sl@0: ** sl@0: ** Return SQLITE_OK if everything. Return an error code and release the sl@0: ** write lock if anything goes wrong. sl@0: */ sl@0: static int pager_open_journal(Pager *pPager){ sl@0: sqlite3_vfs *pVfs = pPager->pVfs; sl@0: int flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_CREATE); sl@0: sl@0: int rc; sl@0: assert( !MEMDB ); sl@0: assert( pPager->state>=PAGER_RESERVED ); sl@0: assert( pPager->useJournal ); sl@0: assert( pPager->pInJournal==0 ); sl@0: sqlite3PagerPagecount(pPager, 0); sl@0: pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize); sl@0: if( pPager->pInJournal==0 ){ sl@0: rc = SQLITE_NOMEM; sl@0: goto failed_to_open_journal; sl@0: } sl@0: sl@0: if( pPager->journalOpen==0 ){ sl@0: if( pPager->tempFile ){ sl@0: flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL); sl@0: }else{ sl@0: flags |= (SQLITE_OPEN_MAIN_JOURNAL); sl@0: } sl@0: #ifdef SQLITE_ENABLE_ATOMIC_WRITE sl@0: rc = sqlite3JournalOpen( sl@0: pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager) sl@0: ); sl@0: #else sl@0: rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0); sl@0: #endif sl@0: assert( rc!=SQLITE_OK || pPager->jfd->pMethods ); sl@0: pPager->journalOff = 0; sl@0: pPager->setMaster = 0; sl@0: pPager->journalHdr = 0; sl@0: if( rc!=SQLITE_OK ){ sl@0: if( rc==SQLITE_NOMEM ){ sl@0: sqlite3OsDelete(pVfs, pPager->zJournal, 0); sl@0: } sl@0: goto failed_to_open_journal; sl@0: } sl@0: } sl@0: pPager->journalOpen = 1; sl@0: pPager->journalStarted = 0; sl@0: pPager->needSync = 0; sl@0: pPager->nRec = 0; sl@0: if( pPager->errCode ){ sl@0: rc = pPager->errCode; sl@0: goto failed_to_open_journal; sl@0: } sl@0: pPager->origDbSize = pPager->dbSize; sl@0: sl@0: rc = writeJournalHdr(pPager); sl@0: sl@0: if( pPager->stmtAutoopen && rc==SQLITE_OK ){ sl@0: rc = sqlite3PagerStmtBegin(pPager); sl@0: } sl@0: if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && rc!=SQLITE_IOERR_NOMEM ){ sl@0: rc = pager_end_transaction(pPager, 0); sl@0: if( rc==SQLITE_OK ){ sl@0: rc = SQLITE_FULL; sl@0: } sl@0: } sl@0: return rc; sl@0: sl@0: failed_to_open_journal: sl@0: sqlite3BitvecDestroy(pPager->pInJournal); sl@0: pPager->pInJournal = 0; sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Acquire a write-lock on the database. The lock is removed when sl@0: ** the any of the following happen: sl@0: ** sl@0: ** * sqlite3PagerCommitPhaseTwo() is called. sl@0: ** * sqlite3PagerRollback() is called. sl@0: ** * sqlite3PagerClose() is called. sl@0: ** * sqlite3PagerUnref() is called to on every outstanding page. sl@0: ** sl@0: ** The first parameter to this routine is a pointer to any open page of the sl@0: ** database file. Nothing changes about the page - it is used merely to sl@0: ** acquire a pointer to the Pager structure and as proof that there is sl@0: ** already a read-lock on the database. sl@0: ** sl@0: ** The second parameter indicates how much space in bytes to reserve for a sl@0: ** master journal file-name at the start of the journal when it is created. sl@0: ** sl@0: ** A journal file is opened if this is not a temporary file. For temporary sl@0: ** files, the opening of the journal file is deferred until there is an sl@0: ** actual need to write to the journal. sl@0: ** sl@0: ** If the database is already reserved for writing, this routine is a no-op. sl@0: ** sl@0: ** If exFlag is true, go ahead and get an EXCLUSIVE lock on the file sl@0: ** immediately instead of waiting until we try to flush the cache. The sl@0: ** exFlag is ignored if a transaction is already active. sl@0: */ sl@0: int sqlite3PagerBegin(DbPage *pPg, int exFlag){ sl@0: Pager *pPager = pPg->pPager; sl@0: int rc = SQLITE_OK; sl@0: assert( pPg->nRef>0 ); sl@0: assert( pPager->state!=PAGER_UNLOCK ); sl@0: if( pPager->state==PAGER_SHARED ){ sl@0: assert( pPager->pInJournal==0 ); sl@0: sqlite3PcacheAssertFlags(pPager->pPCache, 0, PGHDR_IN_JOURNAL); sl@0: if( MEMDB ){ sl@0: pPager->state = PAGER_EXCLUSIVE; sl@0: pPager->origDbSize = pPager->dbSize; sl@0: }else{ sl@0: rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK); sl@0: if( rc==SQLITE_OK ){ sl@0: pPager->state = PAGER_RESERVED; sl@0: if( exFlag ){ sl@0: rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); sl@0: } sl@0: } sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: pPager->dirtyCache = 0; sl@0: PAGERTRACE2("TRANSACTION %d\n", PAGERID(pPager)); sl@0: if( pPager->useJournal && !pPager->tempFile sl@0: && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ sl@0: rc = pager_open_journal(pPager); sl@0: } sl@0: } sl@0: }else if( pPager->journalOpen && pPager->journalOff==0 ){ sl@0: /* This happens when the pager was in exclusive-access mode the last sl@0: ** time a (read or write) transaction was successfully concluded sl@0: ** by this connection. Instead of deleting the journal file it was sl@0: ** kept open and either was truncated to 0 bytes or its header was sl@0: ** overwritten with zeros. sl@0: */ sl@0: assert( pPager->nRec==0 ); sl@0: assert( pPager->origDbSize==0 ); sl@0: assert( pPager->pInJournal==0 ); sl@0: sqlite3PagerPagecount(pPager, 0); sl@0: pPager->pInJournal = sqlite3BitvecCreate( pPager->dbSize ); sl@0: if( !pPager->pInJournal ){ sl@0: rc = SQLITE_NOMEM; sl@0: }else{ sl@0: pPager->origDbSize = pPager->dbSize; sl@0: rc = writeJournalHdr(pPager); sl@0: } sl@0: } sl@0: assert( !pPager->journalOpen || pPager->journalOff>0 || rc!=SQLITE_OK ); sl@0: return rc; sl@0: } sl@0: sl@0: sl@0: /* sl@0: ** Mark a data page as writeable. The page is written into the journal sl@0: ** if it is not there already. This routine must be called before making sl@0: ** changes to a page. sl@0: ** sl@0: ** The first time this routine is called, the pager creates a new sl@0: ** journal and acquires a RESERVED lock on the database. If the RESERVED sl@0: ** lock could not be acquired, this routine returns SQLITE_BUSY. The sl@0: ** calling routine must check for that return value and be careful not to sl@0: ** change any page data until this routine returns SQLITE_OK. sl@0: ** sl@0: ** If the journal file could not be written because the disk is full, sl@0: ** then this routine returns SQLITE_FULL and does an immediate rollback. sl@0: ** All subsequent write attempts also return SQLITE_FULL until there sl@0: ** is a call to sqlite3PagerCommit() or sqlite3PagerRollback() to sl@0: ** reset. sl@0: */ sl@0: static int pager_write(PgHdr *pPg){ sl@0: void *pData = pPg->pData; sl@0: Pager *pPager = pPg->pPager; sl@0: int rc = SQLITE_OK; sl@0: sl@0: /* Check for errors sl@0: */ sl@0: if( pPager->errCode ){ sl@0: return pPager->errCode; sl@0: } sl@0: if( pPager->readOnly ){ sl@0: return SQLITE_PERM; sl@0: } sl@0: sl@0: assert( !pPager->setMaster ); sl@0: sl@0: CHECK_PAGE(pPg); sl@0: sl@0: /* If this page was previously acquired with noContent==1, that means sl@0: ** we didn't really read in the content of the page. This can happen sl@0: ** (for example) when the page is being moved to the freelist. But sl@0: ** now we are (perhaps) moving the page off of the freelist for sl@0: ** reuse and we need to know its original content so that content sl@0: ** can be stored in the rollback journal. So do the read at this sl@0: ** time. sl@0: */ sl@0: rc = pager_get_content(pPg); sl@0: if( rc ){ sl@0: return rc; sl@0: } sl@0: sl@0: /* Mark the page as dirty. If the page has already been written sl@0: ** to the journal then we can return right away. sl@0: */ sl@0: sqlite3PcacheMakeDirty(pPg); sl@0: if( (pPg->flags&PGHDR_IN_JOURNAL) sl@0: && (pageInStatement(pPg) || pPager->stmtInUse==0) sl@0: ){ sl@0: pPager->dirtyCache = 1; sl@0: pPager->dbModified = 1; sl@0: }else{ sl@0: sl@0: /* If we get this far, it means that the page needs to be sl@0: ** written to the transaction journal or the ckeckpoint journal sl@0: ** or both. sl@0: ** sl@0: ** First check to see that the transaction journal exists and sl@0: ** create it if it does not. sl@0: */ sl@0: assert( pPager->state!=PAGER_UNLOCK ); sl@0: rc = sqlite3PagerBegin(pPg, 0); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: assert( pPager->state>=PAGER_RESERVED ); sl@0: if( !pPager->journalOpen && pPager->useJournal sl@0: && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ sl@0: rc = pager_open_journal(pPager); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: } sl@0: pPager->dirtyCache = 1; sl@0: pPager->dbModified = 1; sl@0: sl@0: /* The transaction journal now exists and we have a RESERVED or an sl@0: ** EXCLUSIVE lock on the main database file. Write the current page to sl@0: ** the transaction journal if it is not there already. sl@0: */ sl@0: if( !(pPg->flags&PGHDR_IN_JOURNAL) && (pPager->journalOpen || MEMDB) ){ sl@0: if( (int)pPg->pgno <= pPager->origDbSize ){ sl@0: if( MEMDB ){ sl@0: PAGERTRACE3("JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); sl@0: rc = sqlite3PcachePreserve(pPg, 0); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: }else{ sl@0: u32 cksum; sl@0: char *pData2; sl@0: sl@0: /* We should never write to the journal file the page that sl@0: ** contains the database locks. The following assert verifies sl@0: ** that we do not. */ sl@0: assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) ); sl@0: pData2 = CODEC2(pPager, pData, pPg->pgno, 7); sl@0: cksum = pager_cksum(pPager, (u8*)pData2); sl@0: rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno); sl@0: if( rc==SQLITE_OK ){ sl@0: rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, sl@0: pPager->journalOff + 4); sl@0: pPager->journalOff += pPager->pageSize+4; sl@0: } sl@0: if( rc==SQLITE_OK ){ sl@0: rc = write32bits(pPager->jfd, pPager->journalOff, cksum); sl@0: pPager->journalOff += 4; sl@0: } sl@0: IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, sl@0: pPager->journalOff, pPager->pageSize)); sl@0: PAGER_INCR(sqlite3_pager_writej_count); sl@0: PAGERTRACE5("JOURNAL %d page %d needSync=%d hash(%08x)\n", sl@0: PAGERID(pPager), pPg->pgno, sl@0: ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)); sl@0: sl@0: /* An error has occured writing to the journal file. The sl@0: ** transaction will be rolled back by the layer above. sl@0: */ sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: sl@0: pPager->nRec++; sl@0: assert( pPager->pInJournal!=0 ); sl@0: sqlite3BitvecSet(pPager->pInJournal, pPg->pgno); sl@0: if( !pPager->noSync ){ sl@0: pPg->flags |= PGHDR_NEED_SYNC; sl@0: } sl@0: if( pPager->stmtInUse ){ sl@0: sqlite3BitvecSet(pPager->pInStmt, pPg->pgno); sl@0: } sl@0: } sl@0: }else{ sl@0: if( !pPager->journalStarted && !pPager->noSync ){ sl@0: pPg->flags |= PGHDR_NEED_SYNC; sl@0: } sl@0: PAGERTRACE4("APPEND %d page %d needSync=%d\n", sl@0: PAGERID(pPager), pPg->pgno, sl@0: ((pPg->flags&PGHDR_NEED_SYNC)?1:0)); sl@0: } sl@0: if( pPg->flags&PGHDR_NEED_SYNC ){ sl@0: pPager->needSync = 1; sl@0: } sl@0: pPg->flags |= PGHDR_IN_JOURNAL; sl@0: } sl@0: sl@0: /* If the statement journal is open and the page is not in it, sl@0: ** then write the current page to the statement journal. Note that sl@0: ** the statement journal format differs from the standard journal format sl@0: ** in that it omits the checksums and the header. sl@0: */ sl@0: if( pPager->stmtInUse sl@0: && !pageInStatement(pPg) sl@0: && (int)pPg->pgno<=pPager->stmtSize sl@0: ){ sl@0: assert( (pPg->flags&PGHDR_IN_JOURNAL) sl@0: || (int)pPg->pgno>pPager->origDbSize ); sl@0: if( MEMDB ){ sl@0: rc = sqlite3PcachePreserve(pPg, 1); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); sl@0: }else{ sl@0: i64 offset = pPager->stmtNRec*(4+pPager->pageSize); sl@0: char *pData2 = CODEC2(pPager, pData, pPg->pgno, 7); sl@0: rc = write32bits(pPager->stfd, offset, pPg->pgno); sl@0: if( rc==SQLITE_OK ){ sl@0: rc = sqlite3OsWrite(pPager->stfd, pData2, pPager->pageSize, offset+4); sl@0: } sl@0: PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); sl@0: if( rc!=SQLITE_OK ){ sl@0: return rc; sl@0: } sl@0: pPager->stmtNRec++; sl@0: assert( pPager->pInStmt!=0 ); sl@0: sqlite3BitvecSet(pPager->pInStmt, pPg->pgno); sl@0: } sl@0: } sl@0: } sl@0: sl@0: /* Update the database size and return. sl@0: */ sl@0: assert( pPager->state>=PAGER_SHARED ); sl@0: if( pPager->dbSize<(int)pPg->pgno ){ sl@0: pPager->dbSize = pPg->pgno; sl@0: if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){ sl@0: pPager->dbSize++; sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** This function is used to mark a data-page as writable. It uses sl@0: ** pager_write() to open a journal file (if it is not already open) sl@0: ** and write the page *pData to the journal. sl@0: ** sl@0: ** The difference between this function and pager_write() is that this sl@0: ** function also deals with the special case where 2 or more pages sl@0: ** fit on a single disk sector. In this case all co-resident pages sl@0: ** must have been written to the journal file before returning. sl@0: */ sl@0: int sqlite3PagerWrite(DbPage *pDbPage){ sl@0: int rc = SQLITE_OK; sl@0: sl@0: PgHdr *pPg = pDbPage; sl@0: Pager *pPager = pPg->pPager; sl@0: Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize); sl@0: sl@0: if( !MEMDB && nPagePerSector>1 ){ sl@0: Pgno nPageCount; /* Total number of pages in database file */ sl@0: Pgno pg1; /* First page of the sector pPg is located on. */ sl@0: int nPage; /* Number of pages starting at pg1 to journal */ sl@0: int ii; sl@0: int needSync = 0; sl@0: sl@0: /* Set the doNotSync flag to 1. This is because we cannot allow a journal sl@0: ** header to be written between the pages journaled by this function. sl@0: */ sl@0: assert( pPager->doNotSync==0 ); sl@0: pPager->doNotSync = 1; sl@0: sl@0: /* This trick assumes that both the page-size and sector-size are sl@0: ** an integer power of 2. It sets variable pg1 to the identifier sl@0: ** of the first page of the sector pPg is located on. sl@0: */ sl@0: pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1; sl@0: sl@0: sqlite3PagerPagecount(pPager, (int *)&nPageCount); sl@0: if( pPg->pgno>nPageCount ){ sl@0: nPage = (pPg->pgno - pg1)+1; sl@0: }else if( (pg1+nPagePerSector-1)>nPageCount ){ sl@0: nPage = nPageCount+1-pg1; sl@0: }else{ sl@0: nPage = nPagePerSector; sl@0: } sl@0: assert(nPage>0); sl@0: assert(pg1<=pPg->pgno); sl@0: assert((pg1+nPage)>pPg->pgno); sl@0: sl@0: for(ii=0; iipgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){ sl@0: if( pg!=PAGER_MJ_PGNO(pPager) ){ sl@0: rc = sqlite3PagerGet(pPager, pg, &pPage); sl@0: if( rc==SQLITE_OK ){ sl@0: rc = pager_write(pPage); sl@0: if( pPage->flags&PGHDR_NEED_SYNC ){ sl@0: needSync = 1; sl@0: } sl@0: sqlite3PagerUnref(pPage); sl@0: } sl@0: } sl@0: }else if( (pPage = pager_lookup(pPager, pg))!=0 ){ sl@0: if( pPage->flags&PGHDR_NEED_SYNC ){ sl@0: needSync = 1; sl@0: } sl@0: sqlite3PagerUnref(pPage); sl@0: } sl@0: } sl@0: sl@0: /* If the PgHdr.needSync flag is set for any of the nPage pages sl@0: ** starting at pg1, then it needs to be set for all of them. Because sl@0: ** writing to any of these nPage pages may damage the others, the sl@0: ** journal file must contain sync()ed copies of all of them sl@0: ** before any of them can be written out to the database file. sl@0: */ sl@0: if( needSync ){ sl@0: assert( !MEMDB && pPager->noSync==0 ); sl@0: for(ii=0; iiflags |= PGHDR_NEED_SYNC; sl@0: sqlite3PagerUnref(pPage); sl@0: } sl@0: assert(pPager->needSync); sl@0: } sl@0: sl@0: assert( pPager->doNotSync==1 ); sl@0: pPager->doNotSync = 0; sl@0: }else{ sl@0: rc = pager_write(pDbPage); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Return TRUE if the page given in the argument was previously passed sl@0: ** to sqlite3PagerWrite(). In other words, return TRUE if it is ok sl@0: ** to change the content of the page. sl@0: */ sl@0: #ifndef NDEBUG sl@0: int sqlite3PagerIswriteable(DbPage *pPg){ sl@0: return pPg->flags&PGHDR_DIRTY; sl@0: } sl@0: #endif sl@0: sl@0: /* sl@0: ** A call to this routine tells the pager that it is not necessary to sl@0: ** write the information on page pPg back to the disk, even though sl@0: ** that page might be marked as dirty. sl@0: ** sl@0: ** The overlying software layer calls this routine when all of the data sl@0: ** on the given page is unused. The pager marks the page as clean so sl@0: ** that it does not get written to disk. sl@0: ** sl@0: ** Tests show that this optimization, together with the sl@0: ** sqlite3PagerDontRollback() below, more than double the speed sl@0: ** of large INSERT operations and quadruple the speed of large DELETEs. sl@0: ** sl@0: ** When this routine is called, set the alwaysRollback flag to true. sl@0: ** Subsequent calls to sqlite3PagerDontRollback() for the same page sl@0: ** will thereafter be ignored. This is necessary to avoid a problem sl@0: ** where a page with data is added to the freelist during one part of sl@0: ** a transaction then removed from the freelist during a later part sl@0: ** of the same transaction and reused for some other purpose. When it sl@0: ** is first added to the freelist, this routine is called. When reused, sl@0: ** the sqlite3PagerDontRollback() routine is called. But because the sl@0: ** page contains critical data, we still need to be sure it gets sl@0: ** rolled back in spite of the sqlite3PagerDontRollback() call. sl@0: */ sl@0: int sqlite3PagerDontWrite(DbPage *pDbPage){ sl@0: PgHdr *pPg = pDbPage; sl@0: Pager *pPager = pPg->pPager; sl@0: int rc; sl@0: sl@0: if( MEMDB || pPg->pgno>pPager->origDbSize ){ sl@0: return SQLITE_OK; sl@0: } sl@0: if( pPager->pAlwaysRollback==0 ){ sl@0: assert( pPager->pInJournal ); sl@0: pPager->pAlwaysRollback = sqlite3BitvecCreate(pPager->origDbSize); sl@0: if( !pPager->pAlwaysRollback ){ sl@0: return SQLITE_NOMEM; sl@0: } sl@0: } sl@0: rc = sqlite3BitvecSet(pPager->pAlwaysRollback, pPg->pgno); sl@0: sl@0: if( rc==SQLITE_OK && (pPg->flags&PGHDR_DIRTY) && !pPager->stmtInUse ){ sl@0: assert( pPager->state>=PAGER_SHARED ); sl@0: if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSizedbSize ){ sl@0: /* If this pages is the last page in the file and the file has grown sl@0: ** during the current transaction, then do NOT mark the page as clean. sl@0: ** When the database file grows, we must make sure that the last page sl@0: ** gets written at least once so that the disk file will be the correct sl@0: ** size. If you do not write this page and the size of the file sl@0: ** on the disk ends up being too small, that can lead to database sl@0: ** corruption during the next transaction. sl@0: */ sl@0: }else{ sl@0: PAGERTRACE3("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)); sl@0: IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno)) sl@0: pPg->flags |= PGHDR_DONT_WRITE; sl@0: #ifdef SQLITE_CHECK_PAGES sl@0: pPg->pageHash = pager_pagehash(pPg); sl@0: #endif sl@0: } sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** A call to this routine tells the pager that if a rollback occurs, sl@0: ** it is not necessary to restore the data on the given page. This sl@0: ** means that the pager does not have to record the given page in the sl@0: ** rollback journal. sl@0: ** sl@0: ** If we have not yet actually read the content of this page (if sl@0: ** the PgHdr.needRead flag is set) then this routine acts as a promise sl@0: ** that we will never need to read the page content in the future. sl@0: ** so the needRead flag can be cleared at this point. sl@0: */ sl@0: void sqlite3PagerDontRollback(DbPage *pPg){ sl@0: Pager *pPager = pPg->pPager; sl@0: sl@0: assert( pPager->state>=PAGER_RESERVED ); sl@0: sl@0: /* If the journal file is not open, or DontWrite() has been called on sl@0: ** this page (DontWrite() sets the alwaysRollback flag), then this sl@0: ** function is a no-op. sl@0: */ sl@0: if( pPager->journalOpen==0 sl@0: || sqlite3BitvecTest(pPager->pAlwaysRollback, pPg->pgno) sl@0: || pPg->pgno>pPager->origDbSize sl@0: ){ sl@0: return; sl@0: } sl@0: assert( !MEMDB ); /* For a memdb, pPager->journalOpen is always 0 */ sl@0: sl@0: #ifdef SQLITE_SECURE_DELETE sl@0: if( (pPg->flags & PGHDR_IN_JOURNAL)!=0 || (int)pPg->pgno>pPager->origDbSize ){ sl@0: return; sl@0: } sl@0: #endif sl@0: sl@0: /* If SECURE_DELETE is disabled, then there is no way that this sl@0: ** routine can be called on a page for which sqlite3PagerDontWrite() sl@0: ** has not been previously called during the same transaction. sl@0: ** And if DontWrite() has previously been called, the following sl@0: ** conditions must be met. sl@0: ** sl@0: ** (Later:) Not true. If the database is corrupted by having duplicate sl@0: ** pages on the freelist (ex: corrupt9.test) then the following is not sl@0: ** necessarily true: sl@0: */ sl@0: /* assert( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ); */ sl@0: sl@0: assert( pPager->pInJournal!=0 ); sl@0: sqlite3BitvecSet(pPager->pInJournal, pPg->pgno); sl@0: pPg->flags |= PGHDR_IN_JOURNAL; sl@0: pPg->flags &= ~PGHDR_NEED_READ; sl@0: if( pPager->stmtInUse ){ sl@0: assert( pPager->stmtSize >= pPager->origDbSize ); sl@0: sqlite3BitvecSet(pPager->pInStmt, pPg->pgno); sl@0: } sl@0: PAGERTRACE3("DONT_ROLLBACK page %d of %d\n", pPg->pgno, PAGERID(pPager)); sl@0: IOTRACE(("GARBAGE %p %d\n", pPager, pPg->pgno)) sl@0: } sl@0: sl@0: sl@0: /* sl@0: ** This routine is called to increment the database file change-counter, sl@0: ** stored at byte 24 of the pager file. sl@0: */ sl@0: static int pager_incr_changecounter(Pager *pPager, int isDirect){ sl@0: PgHdr *pPgHdr; sl@0: u32 change_counter; sl@0: int rc = SQLITE_OK; sl@0: sl@0: #ifndef SQLITE_ENABLE_ATOMIC_WRITE sl@0: assert( isDirect==0 ); /* isDirect is only true for atomic writes */ sl@0: #endif sl@0: if( !pPager->changeCountDone ){ sl@0: /* Open page 1 of the file for writing. */ sl@0: rc = sqlite3PagerGet(pPager, 1, &pPgHdr); sl@0: if( rc!=SQLITE_OK ) return rc; sl@0: sl@0: if( !isDirect ){ sl@0: rc = sqlite3PagerWrite(pPgHdr); sl@0: if( rc!=SQLITE_OK ){ sl@0: sqlite3PagerUnref(pPgHdr); sl@0: return rc; sl@0: } sl@0: } sl@0: sl@0: /* Increment the value just read and write it back to byte 24. */ sl@0: change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers); sl@0: change_counter++; sl@0: put32bits(((char*)pPgHdr->pData)+24, change_counter); sl@0: sl@0: #ifdef SQLITE_ENABLE_ATOMIC_WRITE sl@0: if( isDirect && pPager->fd->pMethods ){ sl@0: const void *zBuf = pPgHdr->pData; sl@0: rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0); sl@0: } sl@0: #endif sl@0: sl@0: /* Release the page reference. */ sl@0: sqlite3PagerUnref(pPgHdr); sl@0: pPager->changeCountDone = 1; sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Sync the pager file to disk. sl@0: */ sl@0: int sqlite3PagerSync(Pager *pPager){ sl@0: int rc; sl@0: if( MEMDB ){ sl@0: rc = SQLITE_OK; sl@0: }else{ sl@0: rc = sqlite3OsSync(pPager->fd, pPager->sync_flags); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Sync the database file for the pager pPager. zMaster points to the name sl@0: ** of a master journal file that should be written into the individual sl@0: ** journal file. zMaster may be NULL, which is interpreted as no master sl@0: ** journal (a single database transaction). sl@0: ** sl@0: ** This routine ensures that the journal is synced, all dirty pages written sl@0: ** to the database file and the database file synced. The only thing that sl@0: ** remains to commit the transaction is to delete the journal file (or sl@0: ** master journal file if specified). sl@0: ** sl@0: ** Note that if zMaster==NULL, this does not overwrite a previous value sl@0: ** passed to an sqlite3PagerCommitPhaseOne() call. sl@0: ** sl@0: ** If parameter nTrunc is non-zero, then the pager file is truncated to sl@0: ** nTrunc pages (this is used by auto-vacuum databases). sl@0: ** sl@0: ** If the final parameter - noSync - is true, then the database file itself sl@0: ** is not synced. The caller must call sqlite3PagerSync() directly to sl@0: ** sync the database file before calling CommitPhaseTwo() to delete the sl@0: ** journal file in this case. sl@0: */ sl@0: int sqlite3PagerCommitPhaseOne( sl@0: Pager *pPager, sl@0: const char *zMaster, sl@0: Pgno nTrunc, sl@0: int noSync sl@0: ){ sl@0: int rc = SQLITE_OK; sl@0: sl@0: if( pPager->errCode ){ sl@0: return pPager->errCode; sl@0: } sl@0: sl@0: /* If no changes have been made, we can leave the transaction early. sl@0: */ sl@0: if( pPager->dbModified==0 && sl@0: (pPager->journalMode!=PAGER_JOURNALMODE_DELETE || sl@0: pPager->exclusiveMode!=0) ){ sl@0: assert( pPager->dirtyCache==0 || pPager->journalOpen==0 ); sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: PAGERTRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%d\n", sl@0: pPager->zFilename, zMaster, nTrunc); sl@0: sl@0: /* If this is an in-memory db, or no pages have been written to, or this sl@0: ** function has already been called, it is a no-op. sl@0: */ sl@0: if( pPager->state!=PAGER_SYNCED && !MEMDB && pPager->dirtyCache ){ sl@0: PgHdr *pPg; sl@0: sl@0: #ifdef SQLITE_ENABLE_ATOMIC_WRITE sl@0: /* The atomic-write optimization can be used if all of the sl@0: ** following are true: sl@0: ** sl@0: ** + The file-system supports the atomic-write property for sl@0: ** blocks of size page-size, and sl@0: ** + This commit is not part of a multi-file transaction, and sl@0: ** + Exactly one page has been modified and store in the journal file. sl@0: ** sl@0: ** If the optimization can be used, then the journal file will never sl@0: ** be created for this transaction. sl@0: */ sl@0: int useAtomicWrite; sl@0: pPg = sqlite3PcacheDirtyList(pPager->pPCache); sl@0: useAtomicWrite = ( sl@0: !zMaster && sl@0: pPager->journalOpen && sl@0: pPager->journalOff==jrnlBufferSize(pPager) && sl@0: nTrunc==0 && sl@0: (pPg==0 || pPg->pDirty==0) sl@0: ); sl@0: assert( pPager->journalOpen || pPager->journalMode==PAGER_JOURNALMODE_OFF ); sl@0: if( useAtomicWrite ){ sl@0: /* Update the nRec field in the journal file. */ sl@0: int offset = pPager->journalHdr + sizeof(aJournalMagic); sl@0: assert(pPager->nRec==1); sl@0: rc = write32bits(pPager->jfd, offset, pPager->nRec); sl@0: sl@0: /* Update the db file change counter. The following call will modify sl@0: ** the in-memory representation of page 1 to include the updated sl@0: ** change counter and then write page 1 directly to the database sl@0: ** file. Because of the atomic-write property of the host file-system, sl@0: ** this is safe. sl@0: */ sl@0: if( rc==SQLITE_OK ){ sl@0: rc = pager_incr_changecounter(pPager, 1); sl@0: } sl@0: }else{ sl@0: rc = sqlite3JournalCreate(pPager->jfd); sl@0: } sl@0: sl@0: if( !useAtomicWrite && rc==SQLITE_OK ) sl@0: #endif sl@0: sl@0: /* If a master journal file name has already been written to the sl@0: ** journal file, then no sync is required. This happens when it is sl@0: ** written, then the process fails to upgrade from a RESERVED to an sl@0: ** EXCLUSIVE lock. The next time the process tries to commit the sl@0: ** transaction the m-j name will have already been written. sl@0: */ sl@0: if( !pPager->setMaster ){ sl@0: rc = pager_incr_changecounter(pPager, 0); sl@0: if( rc!=SQLITE_OK ) goto sync_exit; sl@0: if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ sl@0: #ifndef SQLITE_OMIT_AUTOVACUUM sl@0: if( nTrunc!=0 ){ sl@0: /* If this transaction has made the database smaller, then all pages sl@0: ** being discarded by the truncation must be written to the journal sl@0: ** file. sl@0: */ sl@0: Pgno i; sl@0: int iSkip = PAGER_MJ_PGNO(pPager); sl@0: for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){ sl@0: if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){ sl@0: rc = sqlite3PagerGet(pPager, i, &pPg); sl@0: if( rc!=SQLITE_OK ) goto sync_exit; sl@0: rc = sqlite3PagerWrite(pPg); sl@0: sqlite3PagerUnref(pPg); sl@0: if( rc!=SQLITE_OK ) goto sync_exit; sl@0: } sl@0: } sl@0: } sl@0: #endif sl@0: rc = writeMasterJournal(pPager, zMaster); sl@0: if( rc!=SQLITE_OK ) goto sync_exit; sl@0: rc = syncJournal(pPager); sl@0: } sl@0: } sl@0: if( rc!=SQLITE_OK ) goto sync_exit; sl@0: sl@0: #ifndef SQLITE_OMIT_AUTOVACUUM sl@0: if( nTrunc!=0 ){ sl@0: rc = sqlite3PagerTruncate(pPager, nTrunc); sl@0: if( rc!=SQLITE_OK ) goto sync_exit; sl@0: } sl@0: #endif sl@0: sl@0: /* Write all dirty pages to the database file */ sl@0: pPg = sqlite3PcacheDirtyList(pPager->pPCache); sl@0: rc = pager_write_pagelist(pPg); sl@0: if( rc!=SQLITE_OK ){ sl@0: assert( rc!=SQLITE_IOERR_BLOCKED ); sl@0: /* The error might have left the dirty list all fouled up here, sl@0: ** but that does not matter because if the if the dirty list did sl@0: ** get corrupted, then the transaction will roll back and sl@0: ** discard the dirty list. There is an assert in sl@0: ** pager_get_all_dirty_pages() that verifies that no attempt sl@0: ** is made to use an invalid dirty list. sl@0: */ sl@0: goto sync_exit; sl@0: } sl@0: sqlite3PcacheCleanAll(pPager->pPCache); sl@0: sl@0: /* Sync the database file. */ sl@0: if( !pPager->noSync && !noSync ){ sl@0: rc = sqlite3OsSync(pPager->fd, pPager->sync_flags); sl@0: } sl@0: IOTRACE(("DBSYNC %p\n", pPager)) sl@0: sl@0: pPager->state = PAGER_SYNCED; sl@0: }else if( MEMDB && nTrunc!=0 ){ sl@0: rc = sqlite3PagerTruncate(pPager, nTrunc); sl@0: } sl@0: sl@0: sync_exit: sl@0: if( rc==SQLITE_IOERR_BLOCKED ){ sl@0: /* pager_incr_changecounter() may attempt to obtain an exclusive sl@0: * lock to spill the cache and return IOERR_BLOCKED. But since sl@0: * there is no chance the cache is inconsistent, it is sl@0: * better to return SQLITE_BUSY. sl@0: */ sl@0: rc = SQLITE_BUSY; sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: sl@0: /* sl@0: ** Commit all changes to the database and release the write lock. sl@0: ** sl@0: ** If the commit fails for any reason, a rollback attempt is made sl@0: ** and an error code is returned. If the commit worked, SQLITE_OK sl@0: ** is returned. sl@0: */ sl@0: int sqlite3PagerCommitPhaseTwo(Pager *pPager){ sl@0: int rc = SQLITE_OK; sl@0: sl@0: if( pPager->errCode ){ sl@0: return pPager->errCode; sl@0: } sl@0: if( pPager->statedbModified==0 && sl@0: (pPager->journalMode!=PAGER_JOURNALMODE_DELETE || sl@0: pPager->exclusiveMode!=0) ){ sl@0: assert( pPager->dirtyCache==0 || pPager->journalOpen==0 ); sl@0: return SQLITE_OK; sl@0: } sl@0: PAGERTRACE2("COMMIT %d\n", PAGERID(pPager)); sl@0: if( MEMDB ){ sl@0: sqlite3PcacheCommit(pPager->pPCache, 0); sl@0: sqlite3PcacheCleanAll(pPager->pPCache); sl@0: sqlite3PcacheAssertFlags(pPager->pPCache, 0, PGHDR_IN_JOURNAL); sl@0: pPager->state = PAGER_SHARED; sl@0: }else{ sl@0: assert( pPager->state==PAGER_SYNCED || !pPager->dirtyCache ); sl@0: rc = pager_end_transaction(pPager, pPager->setMaster); sl@0: rc = pager_error(pPager, rc); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Rollback all changes. The database falls back to PAGER_SHARED mode. sl@0: ** All in-memory cache pages revert to their original data contents. sl@0: ** The journal is deleted. sl@0: ** sl@0: ** This routine cannot fail unless some other process is not following sl@0: ** the correct locking protocol or unless some other sl@0: ** process is writing trash into the journal file (SQLITE_CORRUPT) or sl@0: ** unless a prior malloc() failed (SQLITE_NOMEM). Appropriate error sl@0: ** codes are returned for all these occasions. Otherwise, sl@0: ** SQLITE_OK is returned. sl@0: */ sl@0: int sqlite3PagerRollback(Pager *pPager){ sl@0: int rc = SQLITE_OK; sl@0: PAGERTRACE2("ROLLBACK %d\n", PAGERID(pPager)); sl@0: if( MEMDB ){ sl@0: sqlite3PcacheRollback(pPager->pPCache, 1, pPager->xReiniter); sl@0: sqlite3PcacheRollback(pPager->pPCache, 0, pPager->xReiniter); sl@0: sqlite3PcacheCleanAll(pPager->pPCache); sl@0: sqlite3PcacheAssertFlags(pPager->pPCache, 0, PGHDR_IN_JOURNAL); sl@0: pPager->dbSize = pPager->origDbSize; sl@0: pager_truncate_cache(pPager); sl@0: pPager->stmtInUse = 0; sl@0: pPager->state = PAGER_SHARED; sl@0: }else if( !pPager->dirtyCache || !pPager->journalOpen ){ sl@0: rc = pager_end_transaction(pPager, pPager->setMaster); sl@0: }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ sl@0: if( pPager->state>=PAGER_EXCLUSIVE ){ sl@0: pager_playback(pPager, 0); sl@0: } sl@0: rc = pPager->errCode; sl@0: }else{ sl@0: if( pPager->state==PAGER_RESERVED ){ sl@0: int rc2; sl@0: rc = pager_playback(pPager, 0); sl@0: rc2 = pager_end_transaction(pPager, pPager->setMaster); sl@0: if( rc==SQLITE_OK ){ sl@0: rc = rc2; sl@0: } sl@0: }else{ sl@0: rc = pager_playback(pPager, 0); sl@0: } sl@0: sl@0: pPager->dbSize = -1; sl@0: sl@0: /* If an error occurs during a ROLLBACK, we can no longer trust the pager sl@0: ** cache. So call pager_error() on the way out to make any error sl@0: ** persistent. sl@0: */ sl@0: rc = pager_error(pPager, rc); sl@0: } sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Return TRUE if the database file is opened read-only. Return FALSE sl@0: ** if the database is (in theory) writable. sl@0: */ sl@0: int sqlite3PagerIsreadonly(Pager *pPager){ sl@0: return pPager->readOnly; sl@0: } sl@0: sl@0: /* sl@0: ** Return the number of references to the pager. sl@0: */ sl@0: int sqlite3PagerRefcount(Pager *pPager){ sl@0: return sqlite3PcacheRefCount(pPager->pPCache); sl@0: } sl@0: sl@0: /* sl@0: ** Return the number of references to the specified page. sl@0: */ sl@0: int sqlite3PagerPageRefcount(DbPage *pPage){ sl@0: return sqlite3PcachePageRefcount(pPage); sl@0: } sl@0: sl@0: #ifdef SQLITE_TEST sl@0: /* sl@0: ** This routine is used for testing and analysis only. sl@0: */ sl@0: int *sqlite3PagerStats(Pager *pPager){ sl@0: static int a[11]; sl@0: a[0] = sqlite3PcacheRefCount(pPager->pPCache); sl@0: a[1] = sqlite3PcachePagecount(pPager->pPCache); sl@0: a[2] = sqlite3PcacheGetCachesize(pPager->pPCache); sl@0: a[3] = pPager->dbSize; sl@0: a[4] = pPager->state; sl@0: a[5] = pPager->errCode; sl@0: a[6] = pPager->nHit; sl@0: a[7] = pPager->nMiss; sl@0: a[8] = 0; /* Used to be pPager->nOvfl */ sl@0: a[9] = pPager->nRead; sl@0: a[10] = pPager->nWrite; sl@0: return a; sl@0: } sl@0: int sqlite3PagerIsMemdb(Pager *pPager){ sl@0: return MEMDB; sl@0: } sl@0: #endif sl@0: sl@0: /* sl@0: ** Set the statement rollback point. sl@0: ** sl@0: ** This routine should be called with the transaction journal already sl@0: ** open. A new statement journal is created that can be used to rollback sl@0: ** changes of a single SQL command within a larger transaction. sl@0: */ sl@0: static int pagerStmtBegin(Pager *pPager){ sl@0: int rc; sl@0: assert( !pPager->stmtInUse ); sl@0: assert( pPager->state>=PAGER_SHARED ); sl@0: assert( pPager->dbSize>=0 ); sl@0: PAGERTRACE2("STMT-BEGIN %d\n", PAGERID(pPager)); sl@0: if( MEMDB ){ sl@0: pPager->stmtInUse = 1; sl@0: pPager->stmtSize = pPager->dbSize; sl@0: return SQLITE_OK; sl@0: } sl@0: if( !pPager->journalOpen ){ sl@0: pPager->stmtAutoopen = 1; sl@0: return SQLITE_OK; sl@0: } sl@0: assert( pPager->journalOpen ); sl@0: assert( pPager->pInStmt==0 ); sl@0: pPager->pInStmt = sqlite3BitvecCreate(pPager->dbSize); sl@0: if( pPager->pInStmt==0 ){ sl@0: /* sqlite3OsLock(pPager->fd, SHARED_LOCK); */ sl@0: return SQLITE_NOMEM; sl@0: } sl@0: pPager->stmtJSize = pPager->journalOff; sl@0: pPager->stmtSize = pPager->dbSize; sl@0: pPager->stmtHdrOff = 0; sl@0: pPager->stmtCksum = pPager->cksumInit; sl@0: if( !pPager->stmtOpen ){ sl@0: rc = sqlite3PagerOpentemp(pPager, pPager->stfd, SQLITE_OPEN_SUBJOURNAL); sl@0: if( rc ){ sl@0: goto stmt_begin_failed; sl@0: } sl@0: pPager->stmtOpen = 1; sl@0: pPager->stmtNRec = 0; sl@0: } sl@0: pPager->stmtInUse = 1; sl@0: return SQLITE_OK; sl@0: sl@0: stmt_begin_failed: sl@0: if( pPager->pInStmt ){ sl@0: sqlite3BitvecDestroy(pPager->pInStmt); sl@0: pPager->pInStmt = 0; sl@0: } sl@0: return rc; sl@0: } sl@0: int sqlite3PagerStmtBegin(Pager *pPager){ sl@0: int rc; sl@0: rc = pagerStmtBegin(pPager); sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Commit a statement. sl@0: */ sl@0: int sqlite3PagerStmtCommit(Pager *pPager){ sl@0: if( pPager->stmtInUse ){ sl@0: PAGERTRACE2("STMT-COMMIT %d\n", PAGERID(pPager)); sl@0: if( !MEMDB ){ sl@0: sqlite3BitvecDestroy(pPager->pInStmt); sl@0: pPager->pInStmt = 0; sl@0: }else{ sl@0: sqlite3PcacheCommit(pPager->pPCache, 1); sl@0: } sl@0: pPager->stmtNRec = 0; sl@0: pPager->stmtInUse = 0; sl@0: } sl@0: pPager->stmtAutoopen = 0; sl@0: return SQLITE_OK; sl@0: } sl@0: sl@0: /* sl@0: ** Rollback a statement. sl@0: */ sl@0: int sqlite3PagerStmtRollback(Pager *pPager){ sl@0: int rc; sl@0: if( pPager->stmtInUse ){ sl@0: PAGERTRACE2("STMT-ROLLBACK %d\n", PAGERID(pPager)); sl@0: if( MEMDB ){ sl@0: sqlite3PcacheRollback(pPager->pPCache, 1, pPager->xReiniter); sl@0: pPager->dbSize = pPager->stmtSize; sl@0: pager_truncate_cache(pPager); sl@0: rc = SQLITE_OK; sl@0: }else{ sl@0: rc = pager_stmt_playback(pPager); sl@0: } sl@0: sqlite3PagerStmtCommit(pPager); sl@0: }else{ sl@0: rc = SQLITE_OK; sl@0: } sl@0: pPager->stmtAutoopen = 0; sl@0: return rc; sl@0: } sl@0: sl@0: /* sl@0: ** Return the full pathname of the database file. sl@0: */ sl@0: const char *sqlite3PagerFilename(Pager *pPager){ sl@0: return pPager->zFilename; sl@0: } sl@0: sl@0: /* sl@0: ** Return the VFS structure for the pager. sl@0: */ sl@0: const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){ sl@0: return pPager->pVfs; sl@0: } sl@0: sl@0: /* sl@0: ** Return the file handle for the database file associated sl@0: ** with the pager. This might return NULL if the file has sl@0: ** not yet been opened. sl@0: */ sl@0: sqlite3_file *sqlite3PagerFile(Pager *pPager){ sl@0: return pPager->fd; sl@0: } sl@0: sl@0: /* sl@0: ** Return the directory of the database file. sl@0: */ sl@0: const char *sqlite3PagerDirname(Pager *pPager){ sl@0: return pPager->zDirectory; sl@0: } sl@0: sl@0: /* sl@0: ** Return the full pathname of the journal file. sl@0: */ sl@0: const char *sqlite3PagerJournalname(Pager *pPager){ sl@0: return pPager->zJournal; sl@0: } sl@0: sl@0: /* sl@0: ** Return true if fsync() calls are disabled for this pager. Return FALSE sl@0: ** if fsync()s are executed normally. sl@0: */ sl@0: int sqlite3PagerNosync(Pager *pPager){ sl@0: return pPager->noSync; sl@0: } sl@0: sl@0: #ifdef SQLITE_HAS_CODEC sl@0: /* sl@0: ** Set the codec for this pager sl@0: */ sl@0: void sqlite3PagerSetCodec( sl@0: Pager *pPager, sl@0: void *(*xCodec)(void*,void*,Pgno,int), sl@0: void *pCodecArg sl@0: ){ sl@0: pPager->xCodec = xCodec; sl@0: pPager->pCodecArg = pCodecArg; sl@0: } sl@0: #endif sl@0: sl@0: #ifndef SQLITE_OMIT_AUTOVACUUM sl@0: /* sl@0: ** Move the page pPg to location pgno in the file. sl@0: ** sl@0: ** There must be no references to the page previously located at sl@0: ** pgno (which we call pPgOld) though that page is allowed to be sl@0: ** in cache. If the page previously located at pgno is not already sl@0: ** in the rollback journal, it is not put there by by this routine. sl@0: ** sl@0: ** References to the page pPg remain valid. Updating any sl@0: ** meta-data associated with pPg (i.e. data stored in the nExtra bytes sl@0: ** allocated along with the page) is the responsibility of the caller. sl@0: ** sl@0: ** A transaction must be active when this routine is called. It used to be sl@0: ** required that a statement transaction was not active, but this restriction sl@0: ** has been removed (CREATE INDEX needs to move a page when a statement sl@0: ** transaction is active). sl@0: ** sl@0: ** If the fourth argument, isCommit, is non-zero, then this page is being sl@0: ** moved as part of a database reorganization just before the transaction sl@0: ** is being committed. In this case, it is guaranteed that the database page sl@0: ** pPg refers to will not be written to again within this transaction. sl@0: */ sl@0: int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){ sl@0: PgHdr *pPgOld; /* The page being overwritten. */ sl@0: Pgno needSyncPgno = 0; sl@0: sl@0: assert( pPg->nRef>0 ); sl@0: sl@0: PAGERTRACE5("MOVE %d page %d (needSync=%d) moves to %d\n", sl@0: PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno); sl@0: IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno)) sl@0: sl@0: pager_get_content(pPg); sl@0: sl@0: /* If the journal needs to be sync()ed before page pPg->pgno can sl@0: ** be written to, store pPg->pgno in local variable needSyncPgno. sl@0: ** sl@0: ** If the isCommit flag is set, there is no need to remember that sl@0: ** the journal needs to be sync()ed before database page pPg->pgno sl@0: ** can be written to. The caller has already promised not to write to it. sl@0: */ sl@0: if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){ sl@0: needSyncPgno = pPg->pgno; sl@0: assert( (pPg->flags&PGHDR_IN_JOURNAL) || (int)pgno>pPager->origDbSize ); sl@0: assert( pPg->flags&PGHDR_DIRTY ); sl@0: assert( pPager->needSync ); sl@0: } sl@0: sl@0: /* If the cache contains a page with page-number pgno, remove it sl@0: ** from its hash chain. Also, if the PgHdr.needSync was set for sl@0: ** page pgno before the 'move' operation, it needs to be retained sl@0: ** for the page moved there. sl@0: */ sl@0: pPg->flags &= ~(PGHDR_NEED_SYNC|PGHDR_IN_JOURNAL); sl@0: pPgOld = pager_lookup(pPager, pgno); sl@0: assert( !pPgOld || pPgOld->nRef==1 ); sl@0: if( pPgOld ){ sl@0: pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC); sl@0: } sl@0: if( sqlite3BitvecTest(pPager->pInJournal, pgno) ){ sl@0: assert( !MEMDB ); sl@0: pPg->flags |= PGHDR_IN_JOURNAL; sl@0: } sl@0: sl@0: sqlite3PcacheMove(pPg, pgno); sl@0: if( pPgOld ){ sl@0: sqlite3PcacheMove(pPgOld, 0); sl@0: sqlite3PcacheRelease(pPgOld); sl@0: } sl@0: sl@0: sqlite3PcacheMakeDirty(pPg); sl@0: pPager->dirtyCache = 1; sl@0: pPager->dbModified = 1; sl@0: sl@0: if( needSyncPgno ){ sl@0: /* If needSyncPgno is non-zero, then the journal file needs to be sl@0: ** sync()ed before any data is written to database file page needSyncPgno. sl@0: ** Currently, no such page exists in the page-cache and the sl@0: ** "is journaled" bitvec flag has been set. This needs to be remedied by sl@0: ** loading the page into the pager-cache and setting the PgHdr.needSync sl@0: ** flag. sl@0: ** sl@0: ** If the attempt to load the page into the page-cache fails, (due sl@0: ** to a malloc() or IO failure), clear the bit in the pInJournal[] sl@0: ** array. Otherwise, if the page is loaded and written again in sl@0: ** this transaction, it may be written to the database file before sl@0: ** it is synced into the journal file. This way, it may end up in sl@0: ** the journal file twice, but that is not a problem. sl@0: ** sl@0: ** The sqlite3PagerGet() call may cause the journal to sync. So make sl@0: ** sure the Pager.needSync flag is set too. sl@0: */ sl@0: int rc; sl@0: PgHdr *pPgHdr; sl@0: assert( pPager->needSync ); sl@0: rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr); sl@0: if( rc!=SQLITE_OK ){ sl@0: if( pPager->pInJournal && (int)needSyncPgno<=pPager->origDbSize ){ sl@0: sqlite3BitvecClear(pPager->pInJournal, needSyncPgno); sl@0: } sl@0: return rc; sl@0: } sl@0: pPager->needSync = 1; sl@0: assert( pPager->noSync==0 && !MEMDB ); sl@0: pPgHdr->flags |= PGHDR_NEED_SYNC; sl@0: pPgHdr->flags |= PGHDR_IN_JOURNAL; sl@0: sqlite3PcacheMakeDirty(pPgHdr); sl@0: sqlite3PagerUnref(pPgHdr); sl@0: } sl@0: sl@0: return SQLITE_OK; sl@0: } sl@0: #endif sl@0: sl@0: /* sl@0: ** Return a pointer to the data for the specified page. sl@0: */ sl@0: void *sqlite3PagerGetData(DbPage *pPg){ sl@0: assert( pPg->nRef>0 || pPg->pPager->memDb ); sl@0: return pPg->pData; sl@0: } sl@0: sl@0: /* sl@0: ** Return a pointer to the Pager.nExtra bytes of "extra" space sl@0: ** allocated along with the specified page. sl@0: */ sl@0: void *sqlite3PagerGetExtra(DbPage *pPg){ sl@0: Pager *pPager = pPg->pPager; sl@0: return (pPager?pPg->pExtra:0); sl@0: } sl@0: sl@0: /* sl@0: ** Get/set the locking-mode for this pager. Parameter eMode must be one sl@0: ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or sl@0: ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then sl@0: ** the locking-mode is set to the value specified. sl@0: ** sl@0: ** The returned value is either PAGER_LOCKINGMODE_NORMAL or sl@0: ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated) sl@0: ** locking-mode. sl@0: */ sl@0: int sqlite3PagerLockingMode(Pager *pPager, int eMode){ sl@0: assert( eMode==PAGER_LOCKINGMODE_QUERY sl@0: || eMode==PAGER_LOCKINGMODE_NORMAL sl@0: || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); sl@0: assert( PAGER_LOCKINGMODE_QUERY<0 ); sl@0: assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 ); sl@0: if( eMode>=0 && !pPager->tempFile ){ sl@0: pPager->exclusiveMode = eMode; sl@0: } sl@0: return (int)pPager->exclusiveMode; sl@0: } sl@0: sl@0: /* sl@0: ** Get/set the journal-mode for this pager. Parameter eMode must be one of: sl@0: ** sl@0: ** PAGER_JOURNALMODE_QUERY sl@0: ** PAGER_JOURNALMODE_DELETE sl@0: ** PAGER_JOURNALMODE_TRUNCATE sl@0: ** PAGER_JOURNALMODE_PERSIST sl@0: ** PAGER_JOURNALMODE_OFF sl@0: ** sl@0: ** If the parameter is not _QUERY, then the journal-mode is set to the sl@0: ** value specified. sl@0: ** sl@0: ** The returned indicate the current (possibly updated) sl@0: ** journal-mode. sl@0: */ sl@0: int sqlite3PagerJournalMode(Pager *pPager, int eMode){ sl@0: assert( eMode==PAGER_JOURNALMODE_QUERY sl@0: || eMode==PAGER_JOURNALMODE_DELETE sl@0: || eMode==PAGER_JOURNALMODE_TRUNCATE sl@0: || eMode==PAGER_JOURNALMODE_PERSIST sl@0: || eMode==PAGER_JOURNALMODE_OFF ); sl@0: assert( PAGER_JOURNALMODE_QUERY<0 ); sl@0: if( eMode>=0 ){ sl@0: pPager->journalMode = eMode; sl@0: }else{ sl@0: assert( eMode==PAGER_JOURNALMODE_QUERY ); sl@0: } sl@0: return (int)pPager->journalMode; sl@0: } sl@0: sl@0: /* sl@0: ** Get/set the size-limit used for persistent journal files. sl@0: */ sl@0: i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){ sl@0: if( iLimit>=-1 ){ sl@0: pPager->journalSizeLimit = iLimit; sl@0: } sl@0: return pPager->journalSizeLimit; sl@0: } sl@0: sl@0: #endif /* SQLITE_OMIT_DISKIO */