4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This is the implementation of the page cache subsystem or "pager".
14 ** The pager is used to access a database disk file. It implements
15 ** atomic commit and rollback through the use of a journal file that
16 ** is separate from the database file. The pager also implements file
17 ** locking to prevent two processes from writing the same database
18 ** file simultaneously, or one process from reading the database while
19 ** another is writing.
21 #ifndef SQLITE_OMIT_DISKIO
22 #include "sqliteInt.h"
26 /******************* NOTES ON THE DESIGN OF THE PAGER ************************
28 ** This comment block describes invariants that hold when using a rollback
29 ** journal. These invariants do not apply for journal_mode=WAL,
30 ** journal_mode=MEMORY, or journal_mode=OFF.
32 ** Within this comment block, a page is deemed to have been synced
33 ** automatically as soon as it is written when PRAGMA synchronous=OFF.
34 ** Otherwise, the page is not synced until the xSync method of the VFS
35 ** is called successfully on the file containing the page.
37 ** Definition: A page of the database file is said to be "overwriteable" if
38 ** one or more of the following are true about the page:
40 ** (a) The original content of the page as it was at the beginning of
41 ** the transaction has been written into the rollback journal and
44 ** (b) The page was a freelist leaf page at the start of the transaction.
46 ** (c) The page number is greater than the largest page that existed in
47 ** the database file at the start of the transaction.
49 ** (1) A page of the database file is never overwritten unless one of the
50 ** following are true:
52 ** (a) The page and all other pages on the same sector are overwriteable.
54 ** (b) The atomic page write optimization is enabled, and the entire
55 ** transaction other than the update of the transaction sequence
56 ** number consists of a single page change.
58 ** (2) The content of a page written into the rollback journal exactly matches
59 ** both the content in the database when the rollback journal was written
60 ** and the content in the database at the beginning of the current
63 ** (3) Writes to the database file are an integer multiple of the page size
64 ** in length and are aligned on a page boundary.
66 ** (4) Reads from the database file are either aligned on a page boundary and
67 ** an integer multiple of the page size in length or are taken from the
68 ** first 100 bytes of the database file.
70 ** (5) All writes to the database file are synced prior to the rollback journal
71 ** being deleted, truncated, or zeroed.
73 ** (6) If a master journal file is used, then all writes to the database file
74 ** are synced prior to the master journal being deleted.
76 ** Definition: Two databases (or the same database at two points it time)
77 ** are said to be "logically equivalent" if they give the same answer to
78 ** all queries. Note in particular the content of freelist leaf
79 ** pages can be changed arbitrarily without affecting the logical equivalence
82 ** (7) At any time, if any subset, including the empty set and the total set,
83 ** of the unsynced changes to a rollback journal are removed and the
84 ** journal is rolled back, the resulting database file will be logically
85 ** equivalent to the database file at the beginning of the transaction.
87 ** (8) When a transaction is rolled back, the xTruncate method of the VFS
88 ** is called to restore the database file to the same size it was at
89 ** the beginning of the transaction. (In some VFSes, the xTruncate
90 ** method is a no-op, but that does not change the fact the SQLite will
93 ** (9) Whenever the database file is modified, at least one bit in the range
94 ** of bytes from 24 through 39 inclusive will be changed prior to releasing
95 ** the EXCLUSIVE lock, thus signaling other connections on the same
96 ** database to flush their caches.
98 ** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
99 ** than one billion transactions.
101 ** (11) A database file is well-formed at the beginning and at the conclusion
102 ** of every transaction.
104 ** (12) An EXCLUSIVE lock is held on the database file when writing to
105 ** the database file.
107 ** (13) A SHARED lock is held on the database file while reading any
108 ** content out of the database file.
110 ******************************************************************************/
113 ** Macros for troubleshooting. Normally turned off
116 int sqlite3PagerTrace
=1; /* True to enable tracing */
117 #define sqlite3DebugPrintf printf
118 #define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }
120 #define PAGERTRACE(X)
124 ** The following two macros are used within the PAGERTRACE() macros above
125 ** to print out file-descriptors.
127 ** PAGERID() takes a pointer to a Pager struct as its argument. The
128 ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
129 ** struct as its argument.
131 #define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd))
132 #define FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd))
135 ** The Pager.eState variable stores the current 'state' of a pager. A
136 ** pager may be in any one of the seven states shown in the following
139 ** OPEN <------+------+
142 ** +---------> READER-------+ |
145 ** |<-------WRITER_LOCKED------> ERROR
148 ** |<------WRITER_CACHEMOD-------->|
151 ** |<-------WRITER_DBMOD---------->|
154 ** +<------WRITER_FINISHED-------->+
157 ** List of state transitions and the C [function] that performs each:
159 ** OPEN -> READER [sqlite3PagerSharedLock]
160 ** READER -> OPEN [pager_unlock]
162 ** READER -> WRITER_LOCKED [sqlite3PagerBegin]
163 ** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
164 ** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
165 ** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
166 ** WRITER_*** -> READER [pager_end_transaction]
168 ** WRITER_*** -> ERROR [pager_error]
169 ** ERROR -> OPEN [pager_unlock]
174 ** The pager starts up in this state. Nothing is guaranteed in this
175 ** state - the file may or may not be locked and the database size is
176 ** unknown. The database may not be read or written.
178 ** * No read or write transaction is active.
179 ** * Any lock, or no lock at all, may be held on the database file.
180 ** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
184 ** In this state all the requirements for reading the database in
185 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
186 ** was) in exclusive-locking mode, a user-level read transaction is
187 ** open. The database size is known in this state.
189 ** A connection running with locking_mode=normal enters this state when
190 ** it opens a read-transaction on the database and returns to state
191 ** OPEN after the read-transaction is completed. However a connection
192 ** running in locking_mode=exclusive (including temp databases) remains in
193 ** this state even after the read-transaction is closed. The only way
194 ** a locking_mode=exclusive connection can transition from READER to OPEN
195 ** is via the ERROR state (see below).
197 ** * A read transaction may be active (but a write-transaction cannot).
198 ** * A SHARED or greater lock is held on the database file.
199 ** * The dbSize variable may be trusted (even if a user-level read
200 ** transaction is not active). The dbOrigSize and dbFileSize variables
201 ** may not be trusted at this point.
202 ** * If the database is a WAL database, then the WAL connection is open.
203 ** * Even if a read-transaction is not open, it is guaranteed that
204 ** there is no hot-journal in the file-system.
208 ** The pager moves to this state from READER when a write-transaction
209 ** is first opened on the database. In WRITER_LOCKED state, all locks
210 ** required to start a write-transaction are held, but no actual
211 ** modifications to the cache or database have taken place.
213 ** In rollback mode, a RESERVED or (if the transaction was opened with
214 ** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when
215 ** moving to this state, but the journal file is not written to or opened
216 ** to in this state. If the transaction is committed or rolled back while
217 ** in WRITER_LOCKED state, all that is required is to unlock the database
220 ** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
221 ** If the connection is running with locking_mode=exclusive, an attempt
222 ** is made to obtain an EXCLUSIVE lock on the database file.
224 ** * A write transaction is active.
225 ** * If the connection is open in rollback-mode, a RESERVED or greater
226 ** lock is held on the database file.
227 ** * If the connection is open in WAL-mode, a WAL write transaction
228 ** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully
230 ** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
231 ** * The contents of the pager cache have not been modified.
232 ** * The journal file may or may not be open.
233 ** * Nothing (not even the first header) has been written to the journal.
237 ** A pager moves from WRITER_LOCKED state to this state when a page is
238 ** first modified by the upper layer. In rollback mode the journal file
239 ** is opened (if it is not already open) and a header written to the
240 ** start of it. The database file on disk has not been modified.
242 ** * A write transaction is active.
243 ** * A RESERVED or greater lock is held on the database file.
244 ** * The journal file is open and the first header has been written
245 ** to it, but the header has not been synced to disk.
246 ** * The contents of the page cache have been modified.
250 ** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
251 ** when it modifies the contents of the database file. WAL connections
252 ** never enter this state (since they do not modify the database file,
253 ** just the log file).
255 ** * A write transaction is active.
256 ** * An EXCLUSIVE or greater lock is held on the database file.
257 ** * The journal file is open and the first header has been written
258 ** and synced to disk.
259 ** * The contents of the page cache have been modified (and possibly
264 ** It is not possible for a WAL connection to enter this state.
266 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
267 ** state after the entire transaction has been successfully written into the
268 ** database file. In this state the transaction may be committed simply
269 ** by finalizing the journal file. Once in WRITER_FINISHED state, it is
270 ** not possible to modify the database further. At this point, the upper
271 ** layer must either commit or rollback the transaction.
273 ** * A write transaction is active.
274 ** * An EXCLUSIVE or greater lock is held on the database file.
275 ** * All writing and syncing of journal and database data has finished.
276 ** If no error occurred, all that remains is to finalize the journal to
277 ** commit the transaction. If an error did occur, the caller will need
278 ** to rollback the transaction.
282 ** The ERROR state is entered when an IO or disk-full error (including
283 ** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it
284 ** difficult to be sure that the in-memory pager state (cache contents,
285 ** db size etc.) are consistent with the contents of the file-system.
287 ** Temporary pager files may enter the ERROR state, but in-memory pagers
290 ** For example, if an IO error occurs while performing a rollback,
291 ** the contents of the page-cache may be left in an inconsistent state.
292 ** At this point it would be dangerous to change back to READER state
293 ** (as usually happens after a rollback). Any subsequent readers might
294 ** report database corruption (due to the inconsistent cache), and if
295 ** they upgrade to writers, they may inadvertently corrupt the database
296 ** file. To avoid this hazard, the pager switches into the ERROR state
297 ** instead of READER following such an error.
299 ** Once it has entered the ERROR state, any attempt to use the pager
300 ** to read or write data returns an error. Eventually, once all
301 ** outstanding transactions have been abandoned, the pager is able to
302 ** transition back to OPEN state, discarding the contents of the
303 ** page-cache and any other in-memory state at the same time. Everything
304 ** is reloaded from disk (and, if necessary, hot-journal rollback peformed)
305 ** when a read-transaction is next opened on the pager (transitioning
306 ** the pager into READER state). At that point the system has recovered
309 ** Specifically, the pager jumps into the ERROR state if:
311 ** 1. An error occurs while attempting a rollback. This happens in
312 ** function sqlite3PagerRollback().
314 ** 2. An error occurs while attempting to finalize a journal file
315 ** following a commit in function sqlite3PagerCommitPhaseTwo().
317 ** 3. An error occurs while attempting to write to the journal or
318 ** database file in function pagerStress() in order to free up
321 ** In other cases, the error is returned to the b-tree layer. The b-tree
322 ** layer then attempts a rollback operation. If the error condition
323 ** persists, the pager enters the ERROR state via condition (1) above.
325 ** Condition (3) is necessary because it can be triggered by a read-only
326 ** statement executed within a transaction. In this case, if the error
327 ** code were simply returned to the user, the b-tree layer would not
328 ** automatically attempt a rollback, as it assumes that an error in a
329 ** read-only statement cannot leave the pager in an internally inconsistent
332 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
333 ** * There are one or more outstanding references to pages (after the
334 ** last reference is dropped the pager should move back to OPEN state).
335 ** * The pager is not an in-memory pager.
340 ** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the
341 ** connection is open in WAL mode. A WAL connection is always in one
342 ** of the first four states.
344 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
345 ** state. There are two exceptions: immediately after exclusive-mode has
346 ** been turned on (and before any read or write transactions are
347 ** executed), and when the pager is leaving the "error state".
349 ** * See also: assert_pager_state().
352 #define PAGER_READER 1
353 #define PAGER_WRITER_LOCKED 2
354 #define PAGER_WRITER_CACHEMOD 3
355 #define PAGER_WRITER_DBMOD 4
356 #define PAGER_WRITER_FINISHED 5
357 #define PAGER_ERROR 6
360 ** The Pager.eLock variable is almost always set to one of the
361 ** following locking-states, according to the lock currently held on
362 ** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
363 ** This variable is kept up to date as locks are taken and released by
364 ** the pagerLockDb() and pagerUnlockDb() wrappers.
366 ** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY
367 ** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
368 ** the operation was successful. In these circumstances pagerLockDb() and
369 ** pagerUnlockDb() take a conservative approach - eLock is always updated
370 ** when unlocking the file, and only updated when locking the file if the
371 ** VFS call is successful. This way, the Pager.eLock variable may be set
372 ** to a less exclusive (lower) value than the lock that is actually held
373 ** at the system level, but it is never set to a more exclusive value.
375 ** This is usually safe. If an xUnlock fails or appears to fail, there may
376 ** be a few redundant xLock() calls or a lock may be held for longer than
377 ** required, but nothing really goes wrong.
379 ** The exception is when the database file is unlocked as the pager moves
380 ** from ERROR to OPEN state. At this point there may be a hot-journal file
381 ** in the file-system that needs to be rolled back (as part of an OPEN->SHARED
382 ** transition, by the same pager or any other). If the call to xUnlock()
383 ** fails at this point and the pager is left holding an EXCLUSIVE lock, this
384 ** can confuse the call to xCheckReservedLock() call made later as part
385 ** of hot-journal detection.
387 ** xCheckReservedLock() is defined as returning true "if there is a RESERVED
388 ** lock held by this process or any others". So xCheckReservedLock may
389 ** return true because the caller itself is holding an EXCLUSIVE lock (but
390 ** doesn't know it because of a previous error in xUnlock). If this happens
391 ** a hot-journal may be mistaken for a journal being created by an active
392 ** transaction in another process, causing SQLite to read from the database
393 ** without rolling it back.
395 ** To work around this, if a call to xUnlock() fails when unlocking the
396 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
397 ** is only changed back to a real locking state after a successful call
398 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
399 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
400 ** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
401 ** lock on the database file before attempting to roll it back. See function
402 ** PagerSharedLock() for more detail.
404 ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
407 #define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)
410 ** A macro used for invoking the codec if there is one
412 #ifdef SQLITE_HAS_CODEC
413 # define CODEC1(P,D,N,X,E) \
414 if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
415 # define CODEC2(P,D,N,X,E,O) \
416 if( P->xCodec==0 ){ O=(char*)D; }else \
417 if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
419 # define CODEC1(P,D,N,X,E) /* NO-OP */
420 # define CODEC2(P,D,N,X,E,O) O=(char*)D
424 ** The maximum allowed sector size. 64KiB. If the xSectorsize() method
425 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
426 ** This could conceivably cause corruption following a power failure on
427 ** such a system. This is currently an undocumented limit.
429 #define MAX_SECTOR_SIZE 0x10000
433 ** An instance of the following structure is allocated for each active
434 ** savepoint and statement transaction in the system. All such structures
435 ** are stored in the Pager.aSavepoint[] array, which is allocated and
436 ** resized using sqlite3Realloc().
438 ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
439 ** set to 0. If a journal-header is written into the main journal while
440 ** the savepoint is active, then iHdrOffset is set to the byte offset
441 ** immediately following the last journal record written into the main
442 ** journal before the journal-header. This is required during savepoint
443 ** rollback (see pagerPlaybackSavepoint()).
445 typedef struct PagerSavepoint PagerSavepoint
;
446 struct PagerSavepoint
{
447 i64 iOffset
; /* Starting offset in main journal */
448 i64 iHdrOffset
; /* See above */
449 Bitvec
*pInSavepoint
; /* Set of pages in this savepoint */
450 Pgno nOrig
; /* Original number of pages in file */
451 Pgno iSubRec
; /* Index of first record in sub-journal */
452 #ifndef SQLITE_OMIT_WAL
453 u32 aWalData
[WAL_SAVEPOINT_NDATA
]; /* WAL savepoint context */
458 ** Bits of the Pager.doNotSpill flag. See further description below.
460 #define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */
461 #define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */
462 #define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */
465 ** An open page cache is an instance of struct Pager. A description of
466 ** some of the more important member variables follows:
470 ** The current 'state' of the pager object. See the comment and state
471 ** diagram above for a description of the pager state.
475 ** For a real on-disk database, the current lock held on the database file -
476 ** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
478 ** For a temporary or in-memory database (neither of which require any
479 ** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
480 ** databases always have Pager.exclusiveMode==1, this tricks the pager
481 ** logic into thinking that it already has all the locks it will ever
482 ** need (and no reason to release them).
484 ** In some (obscure) circumstances, this variable may also be set to
485 ** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
490 ** This boolean variable is used to make sure that the change-counter
491 ** (the 4-byte header field at byte offset 24 of the database file) is
492 ** not updated more often than necessary.
494 ** It is set to true when the change-counter field is updated, which
495 ** can only happen if an exclusive lock is held on the database file.
496 ** It is cleared (set to false) whenever an exclusive lock is
497 ** relinquished on the database file. Each time a transaction is committed,
498 ** The changeCountDone flag is inspected. If it is true, the work of
499 ** updating the change-counter is omitted for the current transaction.
501 ** This mechanism means that when running in exclusive mode, a connection
502 ** need only update the change-counter once, for the first transaction
507 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
508 ** (or may not) specify a master-journal name to be written into the
509 ** journal file before it is synced to disk.
511 ** Whether or not a journal file contains a master-journal pointer affects
512 ** the way in which the journal file is finalized after the transaction is
513 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
514 ** If a journal file does not contain a master-journal pointer, it is
515 ** finalized by overwriting the first journal header with zeroes. If
516 ** it does contain a master-journal pointer the journal file is finalized
517 ** by truncating it to zero bytes, just as if the connection were
518 ** running in "journal_mode=truncate" mode.
520 ** Journal files that contain master journal pointers cannot be finalized
521 ** simply by overwriting the first journal-header with zeroes, as the
522 ** master journal pointer could interfere with hot-journal rollback of any
523 ** subsequently interrupted transaction that reuses the journal file.
525 ** The flag is cleared as soon as the journal file is finalized (either
526 ** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
527 ** journal file from being successfully finalized, the setMaster flag
528 ** is cleared anyway (and the pager will move to ERROR state).
532 ** This variables control the behavior of cache-spills (calls made by
533 ** the pcache module to the pagerStress() routine to write cached data
534 ** to the file-system in order to free up memory).
536 ** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
537 ** writing to the database from pagerStress() is disabled altogether.
538 ** The SPILLFLAG_ROLLBACK case is done in a very obscure case that
539 ** comes up during savepoint rollback that requires the pcache module
540 ** to allocate a new page to prevent the journal file from being written
541 ** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
542 ** case is a user preference.
544 ** If the SPILLFLAG_NOSYNC bit is set, writing to the database from
545 ** pagerStress() is permitted, but syncing the journal file is not.
546 ** This flag is set by sqlite3PagerWrite() when the file-system sector-size
547 ** is larger than the database page-size in order to prevent a journal sync
548 ** from happening in between the journalling of two pages on the same sector.
552 ** This is a boolean variable. If true, then any required sub-journal
553 ** is opened as an in-memory journal file. If false, then in-memory
554 ** sub-journals are only used for in-memory pager files.
556 ** This variable is updated by the upper layer each time a new
557 ** write-transaction is opened.
559 ** dbSize, dbOrigSize, dbFileSize
561 ** Variable dbSize is set to the number of pages in the database file.
562 ** It is valid in PAGER_READER and higher states (all states except for
565 ** dbSize is set based on the size of the database file, which may be
566 ** larger than the size of the database (the value stored at offset
567 ** 28 of the database header by the btree). If the size of the file
568 ** is not an integer multiple of the page-size, the value stored in
569 ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
570 ** Except, any file that is greater than 0 bytes in size is considered
571 ** to have at least one page. (i.e. a 1KB file with 2K page-size leads
574 ** During a write-transaction, if pages with page-numbers greater than
575 ** dbSize are modified in the cache, dbSize is updated accordingly.
576 ** Similarly, if the database is truncated using PagerTruncateImage(),
577 ** dbSize is updated.
579 ** Variables dbOrigSize and dbFileSize are valid in states
580 ** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
581 ** variable at the start of the transaction. It is used during rollback,
582 ** and to determine whether or not pages need to be journalled before
585 ** Throughout a write-transaction, dbFileSize contains the size of
586 ** the file on disk in pages. It is set to a copy of dbSize when the
587 ** write-transaction is first opened, and updated when VFS calls are made
588 ** to write or truncate the database file on disk.
590 ** The only reason the dbFileSize variable is required is to suppress
591 ** unnecessary calls to xTruncate() after committing a transaction. If,
592 ** when a transaction is committed, the dbFileSize variable indicates
593 ** that the database file is larger than the database image (Pager.dbSize),
594 ** pager_truncate() is called. The pager_truncate() call uses xFilesize()
595 ** to measure the database file on disk, and then truncates it if required.
596 ** dbFileSize is not used when rolling back a transaction. In this case
597 ** pager_truncate() is called unconditionally (which means there may be
598 ** a call to xFilesize() that is not strictly required). In either case,
599 ** pager_truncate() may cause the file to become smaller or larger.
603 ** The dbHintSize variable is used to limit the number of calls made to
604 ** the VFS xFileControl(FCNTL_SIZE_HINT) method.
606 ** dbHintSize is set to a copy of the dbSize variable when a
607 ** write-transaction is opened (at the same time as dbFileSize and
608 ** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
609 ** dbHintSize is increased to the number of pages that correspond to the
610 ** size-hint passed to the method call. See pager_write_pagelist() for
615 ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
616 ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
617 ** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
620 ** syncFlags, walSyncFlags
622 ** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03).
623 ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
624 ** and contains the flags used to sync the checkpoint operations in the
625 ** lower two bits, and sync flags used for transaction commits in the WAL
626 ** file in bits 0x04 and 0x08. In other words, to get the correct sync flags
627 ** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct
628 ** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note
629 ** that with synchronous=NORMAL in WAL mode, transaction commit is not synced
630 ** meaning that the 0x04 and 0x08 bits are both zero.
633 sqlite3_vfs
*pVfs
; /* OS functions to use for IO */
634 u8 exclusiveMode
; /* Boolean. True if locking_mode==EXCLUSIVE */
635 u8 journalMode
; /* One of the PAGER_JOURNALMODE_* values */
636 u8 useJournal
; /* Use a rollback journal on this file */
637 u8 noSync
; /* Do not sync the journal if true */
638 u8 fullSync
; /* Do extra syncs of the journal for robustness */
639 u8 extraSync
; /* sync directory after journal delete */
640 u8 syncFlags
; /* SYNC_NORMAL or SYNC_FULL otherwise */
641 u8 walSyncFlags
; /* See description above */
642 u8 tempFile
; /* zFilename is a temporary or immutable file */
643 u8 noLock
; /* Do not lock (except in WAL mode) */
644 u8 readOnly
; /* True for a read-only database */
645 u8 memDb
; /* True to inhibit all file I/O */
647 /**************************************************************************
648 ** The following block contains those class members that change during
649 ** routine operation. Class members not in this block are either fixed
650 ** when the pager is first created or else only change when there is a
651 ** significant mode change (such as changing the page_size, locking_mode,
652 ** or the journal_mode). From another view, these class members describe
653 ** the "state" of the pager, while other class members describe the
654 ** "configuration" of the pager.
656 u8 eState
; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
657 u8 eLock
; /* Current lock held on database file */
658 u8 changeCountDone
; /* Set after incrementing the change-counter */
659 u8 setMaster
; /* True if a m-j name has been written to jrnl */
660 u8 doNotSpill
; /* Do not spill the cache when non-zero */
661 u8 subjInMemory
; /* True to use in-memory sub-journals */
662 u8 bUseFetch
; /* True to use xFetch() */
663 u8 hasHeldSharedLock
; /* True if a shared lock has ever been held */
664 Pgno dbSize
; /* Number of pages in the database */
665 Pgno dbOrigSize
; /* dbSize before the current transaction */
666 Pgno dbFileSize
; /* Number of pages in the database file */
667 Pgno dbHintSize
; /* Value passed to FCNTL_SIZE_HINT call */
668 int errCode
; /* One of several kinds of errors */
669 int nRec
; /* Pages journalled since last j-header written */
670 u32 cksumInit
; /* Quasi-random value added to every checksum */
671 u32 nSubRec
; /* Number of records written to sub-journal */
672 Bitvec
*pInJournal
; /* One bit for each page in the database file */
673 sqlite3_file
*fd
; /* File descriptor for database */
674 sqlite3_file
*jfd
; /* File descriptor for main journal */
675 sqlite3_file
*sjfd
; /* File descriptor for sub-journal */
676 i64 journalOff
; /* Current write offset in the journal file */
677 i64 journalHdr
; /* Byte offset to previous journal header */
678 sqlite3_backup
*pBackup
; /* Pointer to list of ongoing backup processes */
679 PagerSavepoint
*aSavepoint
; /* Array of active savepoints */
680 int nSavepoint
; /* Number of elements in aSavepoint[] */
681 u32 iDataVersion
; /* Changes whenever database content changes */
682 char dbFileVers
[16]; /* Changes whenever database file changes */
684 int nMmapOut
; /* Number of mmap pages currently outstanding */
685 sqlite3_int64 szMmap
; /* Desired maximum mmap size */
686 PgHdr
*pMmapFreelist
; /* List of free mmap page headers (pDirty) */
688 ** End of the routinely-changing class members
689 ***************************************************************************/
691 u16 nExtra
; /* Add this many bytes to each in-memory page */
692 i16 nReserve
; /* Number of unused bytes at end of each page */
693 u32 vfsFlags
; /* Flags for sqlite3_vfs.xOpen() */
694 u32 sectorSize
; /* Assumed sector size during rollback */
695 int pageSize
; /* Number of bytes in a page */
696 Pgno mxPgno
; /* Maximum allowed size of the database */
697 i64 journalSizeLimit
; /* Size limit for persistent journal files */
698 char *zFilename
; /* Name of the database file */
699 char *zJournal
; /* Name of the journal file */
700 int (*xBusyHandler
)(void*); /* Function to call when busy */
701 void *pBusyHandlerArg
; /* Context argument for xBusyHandler */
702 int aStat
[4]; /* Total cache hits, misses, writes, spills */
704 int nRead
; /* Database pages read */
706 void (*xReiniter
)(DbPage
*); /* Call this routine when reloading pages */
707 int (*xGet
)(Pager
*,Pgno
,DbPage
**,int); /* Routine to fetch a patch */
708 #ifdef SQLITE_HAS_CODEC
709 void *(*xCodec
)(void*,void*,Pgno
,int); /* Routine for en/decoding data */
710 void (*xCodecSizeChng
)(void*,int,int); /* Notify of page size changes */
711 void (*xCodecFree
)(void*); /* Destructor for the codec */
712 void *pCodec
; /* First argument to xCodec... methods */
714 char *pTmpSpace
; /* Pager.pageSize bytes of space for tmp use */
715 PCache
*pPCache
; /* Pointer to page cache object */
716 #ifndef SQLITE_OMIT_WAL
717 Wal
*pWal
; /* Write-ahead log used by "journal_mode=wal" */
718 char *zWal
; /* File name for write-ahead log */
723 ** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains
724 ** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS
725 ** or CACHE_WRITE to sqlite3_db_status().
727 #define PAGER_STAT_HIT 0
728 #define PAGER_STAT_MISS 1
729 #define PAGER_STAT_WRITE 2
730 #define PAGER_STAT_SPILL 3
733 ** The following global variables hold counters used for
734 ** testing purposes only. These variables do not exist in
735 ** a non-testing build. These variables are not thread-safe.
738 int sqlite3_pager_readdb_count
= 0; /* Number of full pages read from DB */
739 int sqlite3_pager_writedb_count
= 0; /* Number of full pages written to DB */
740 int sqlite3_pager_writej_count
= 0; /* Number of pages written to journal */
741 # define PAGER_INCR(v) v++
743 # define PAGER_INCR(v)
749 ** Journal files begin with the following magic string. The data
750 ** was obtained from /dev/random. It is used only as a sanity check.
752 ** Since version 2.8.0, the journal format contains additional sanity
753 ** checking information. If the power fails while the journal is being
754 ** written, semi-random garbage data might appear in the journal
755 ** file after power is restored. If an attempt is then made
756 ** to roll the journal back, the database could be corrupted. The additional
757 ** sanity checking data is an attempt to discover the garbage in the
758 ** journal and ignore it.
760 ** The sanity checking information for the new journal format consists
761 ** of a 32-bit checksum on each page of data. The checksum covers both
762 ** the page number and the pPager->pageSize bytes of data for the page.
763 ** This cksum is initialized to a 32-bit random value that appears in the
764 ** journal file right after the header. The random initializer is important,
765 ** because garbage data that appears at the end of a journal is likely
766 ** data that was once in other files that have now been deleted. If the
767 ** garbage data came from an obsolete journal file, the checksums might
768 ** be correct. But by initializing the checksum to random value which
769 ** is different for every journal, we minimize that risk.
771 static const unsigned char aJournalMagic
[] = {
772 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
776 ** The size of the of each page record in the journal is given by
777 ** the following macro.
779 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
782 ** The journal header size for this pager. This is usually the same
783 ** size as a single disk sector. See also setSectorSize().
785 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
788 ** The macro MEMDB is true if we are dealing with an in-memory database.
789 ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
790 ** the value of MEMDB will be a constant and the compiler will optimize
791 ** out code that would never execute.
793 #ifdef SQLITE_OMIT_MEMORYDB
796 # define MEMDB pPager->memDb
800 ** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
801 ** interfaces to access the database using memory-mapped I/O.
803 #if SQLITE_MAX_MMAP_SIZE>0
804 # define USEFETCH(x) ((x)->bUseFetch)
806 # define USEFETCH(x) 0
810 ** The maximum legal page number is (2^31 - 1).
812 #define PAGER_MAX_PGNO 2147483647
815 ** The argument to this macro is a file descriptor (type sqlite3_file*).
816 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
818 ** This is so that expressions can be written as:
820 ** if( isOpen(pPager->jfd) ){ ...
824 ** if( pPager->jfd->pMethods ){ ...
826 #define isOpen(pFd) ((pFd)->pMethods!=0)
829 ** Return true if this pager uses a write-ahead log to read page pgno.
830 ** Return false if the pager reads pgno directly from the database.
832 #if !defined(SQLITE_OMIT_WAL) && defined(SQLITE_DIRECT_OVERFLOW_READ)
833 int sqlite3PagerUseWal(Pager
*pPager
, Pgno pgno
){
836 if( pPager
->pWal
==0 ) return 0;
837 rc
= sqlite3WalFindFrame(pPager
->pWal
, pgno
, &iRead
);
841 #ifndef SQLITE_OMIT_WAL
842 # define pagerUseWal(x) ((x)->pWal!=0)
844 # define pagerUseWal(x) 0
845 # define pagerRollbackWal(x) 0
846 # define pagerWalFrames(v,w,x,y) 0
847 # define pagerOpenWalIfPresent(z) SQLITE_OK
848 # define pagerBeginReadTransaction(z) SQLITE_OK
855 ** assert( assert_pager_state(pPager) );
857 ** This function runs many asserts to try to find inconsistencies in
858 ** the internal state of the Pager object.
860 static int assert_pager_state(Pager
*p
){
863 /* State must be valid. */
864 assert( p
->eState
==PAGER_OPEN
865 || p
->eState
==PAGER_READER
866 || p
->eState
==PAGER_WRITER_LOCKED
867 || p
->eState
==PAGER_WRITER_CACHEMOD
868 || p
->eState
==PAGER_WRITER_DBMOD
869 || p
->eState
==PAGER_WRITER_FINISHED
870 || p
->eState
==PAGER_ERROR
873 /* Regardless of the current state, a temp-file connection always behaves
874 ** as if it has an exclusive lock on the database file. It never updates
875 ** the change-counter field, so the changeCountDone flag is always set.
877 assert( p
->tempFile
==0 || p
->eLock
==EXCLUSIVE_LOCK
);
878 assert( p
->tempFile
==0 || pPager
->changeCountDone
);
880 /* If the useJournal flag is clear, the journal-mode must be "OFF".
881 ** And if the journal-mode is "OFF", the journal file must not be open.
883 assert( p
->journalMode
==PAGER_JOURNALMODE_OFF
|| p
->useJournal
);
884 assert( p
->journalMode
!=PAGER_JOURNALMODE_OFF
|| !isOpen(p
->jfd
) );
886 /* Check that MEMDB implies noSync. And an in-memory journal. Since
887 ** this means an in-memory pager performs no IO at all, it cannot encounter
888 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
889 ** a journal file. (although the in-memory journal implementation may
890 ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
891 ** is therefore not possible for an in-memory pager to enter the ERROR
895 assert( !isOpen(p
->fd
) );
897 assert( p
->journalMode
==PAGER_JOURNALMODE_OFF
898 || p
->journalMode
==PAGER_JOURNALMODE_MEMORY
900 assert( p
->eState
!=PAGER_ERROR
&& p
->eState
!=PAGER_OPEN
);
901 assert( pagerUseWal(p
)==0 );
904 /* If changeCountDone is set, a RESERVED lock or greater must be held
907 assert( pPager
->changeCountDone
==0 || pPager
->eLock
>=RESERVED_LOCK
);
908 assert( p
->eLock
!=PENDING_LOCK
);
913 assert( pPager
->errCode
==SQLITE_OK
);
914 assert( sqlite3PcacheRefCount(pPager
->pPCache
)==0 || pPager
->tempFile
);
918 assert( pPager
->errCode
==SQLITE_OK
);
919 assert( p
->eLock
!=UNKNOWN_LOCK
);
920 assert( p
->eLock
>=SHARED_LOCK
);
923 case PAGER_WRITER_LOCKED
:
924 assert( p
->eLock
!=UNKNOWN_LOCK
);
925 assert( pPager
->errCode
==SQLITE_OK
);
926 if( !pagerUseWal(pPager
) ){
927 assert( p
->eLock
>=RESERVED_LOCK
);
929 assert( pPager
->dbSize
==pPager
->dbOrigSize
);
930 assert( pPager
->dbOrigSize
==pPager
->dbFileSize
);
931 assert( pPager
->dbOrigSize
==pPager
->dbHintSize
);
932 assert( pPager
->setMaster
==0 );
935 case PAGER_WRITER_CACHEMOD
:
936 assert( p
->eLock
!=UNKNOWN_LOCK
);
937 assert( pPager
->errCode
==SQLITE_OK
);
938 if( !pagerUseWal(pPager
) ){
939 /* It is possible that if journal_mode=wal here that neither the
940 ** journal file nor the WAL file are open. This happens during
941 ** a rollback transaction that switches from journal_mode=off
942 ** to journal_mode=wal.
944 assert( p
->eLock
>=RESERVED_LOCK
);
945 assert( isOpen(p
->jfd
)
946 || p
->journalMode
==PAGER_JOURNALMODE_OFF
947 || p
->journalMode
==PAGER_JOURNALMODE_WAL
950 assert( pPager
->dbOrigSize
==pPager
->dbFileSize
);
951 assert( pPager
->dbOrigSize
==pPager
->dbHintSize
);
954 case PAGER_WRITER_DBMOD
:
955 assert( p
->eLock
==EXCLUSIVE_LOCK
);
956 assert( pPager
->errCode
==SQLITE_OK
);
957 assert( !pagerUseWal(pPager
) );
958 assert( p
->eLock
>=EXCLUSIVE_LOCK
);
959 assert( isOpen(p
->jfd
)
960 || p
->journalMode
==PAGER_JOURNALMODE_OFF
961 || p
->journalMode
==PAGER_JOURNALMODE_WAL
962 || (sqlite3OsDeviceCharacteristics(p
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
964 assert( pPager
->dbOrigSize
<=pPager
->dbHintSize
);
967 case PAGER_WRITER_FINISHED
:
968 assert( p
->eLock
==EXCLUSIVE_LOCK
);
969 assert( pPager
->errCode
==SQLITE_OK
);
970 assert( !pagerUseWal(pPager
) );
971 assert( isOpen(p
->jfd
)
972 || p
->journalMode
==PAGER_JOURNALMODE_OFF
973 || p
->journalMode
==PAGER_JOURNALMODE_WAL
974 || (sqlite3OsDeviceCharacteristics(p
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
979 /* There must be at least one outstanding reference to the pager if
980 ** in ERROR state. Otherwise the pager should have already dropped
981 ** back to OPEN state.
983 assert( pPager
->errCode
!=SQLITE_OK
);
984 assert( sqlite3PcacheRefCount(pPager
->pPCache
)>0 || pPager
->tempFile
);
990 #endif /* ifndef NDEBUG */
994 ** Return a pointer to a human readable string in a static buffer
995 ** containing the state of the Pager object passed as an argument. This
996 ** is intended to be used within debuggers. For example, as an alternative
997 ** to "print *pPager" in gdb:
999 ** (gdb) printf "%s", print_pager_state(pPager)
1001 static char *print_pager_state(Pager
*p
){
1002 static char zRet
[1024];
1004 sqlite3_snprintf(1024, zRet
,
1006 "State: %s errCode=%d\n"
1008 "Locking mode: locking_mode=%s\n"
1009 "Journal mode: journal_mode=%s\n"
1010 "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
1011 "Journal: journalOff=%lld journalHdr=%lld\n"
1012 "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
1014 , p
->eState
==PAGER_OPEN
? "OPEN" :
1015 p
->eState
==PAGER_READER
? "READER" :
1016 p
->eState
==PAGER_WRITER_LOCKED
? "WRITER_LOCKED" :
1017 p
->eState
==PAGER_WRITER_CACHEMOD
? "WRITER_CACHEMOD" :
1018 p
->eState
==PAGER_WRITER_DBMOD
? "WRITER_DBMOD" :
1019 p
->eState
==PAGER_WRITER_FINISHED
? "WRITER_FINISHED" :
1020 p
->eState
==PAGER_ERROR
? "ERROR" : "?error?"
1022 , p
->eLock
==NO_LOCK
? "NO_LOCK" :
1023 p
->eLock
==RESERVED_LOCK
? "RESERVED" :
1024 p
->eLock
==EXCLUSIVE_LOCK
? "EXCLUSIVE" :
1025 p
->eLock
==SHARED_LOCK
? "SHARED" :
1026 p
->eLock
==UNKNOWN_LOCK
? "UNKNOWN" : "?error?"
1027 , p
->exclusiveMode
? "exclusive" : "normal"
1028 , p
->journalMode
==PAGER_JOURNALMODE_MEMORY
? "memory" :
1029 p
->journalMode
==PAGER_JOURNALMODE_OFF
? "off" :
1030 p
->journalMode
==PAGER_JOURNALMODE_DELETE
? "delete" :
1031 p
->journalMode
==PAGER_JOURNALMODE_PERSIST
? "persist" :
1032 p
->journalMode
==PAGER_JOURNALMODE_TRUNCATE
? "truncate" :
1033 p
->journalMode
==PAGER_JOURNALMODE_WAL
? "wal" : "?error?"
1034 , (int)p
->tempFile
, (int)p
->memDb
, (int)p
->useJournal
1035 , p
->journalOff
, p
->journalHdr
1036 , (int)p
->dbSize
, (int)p
->dbOrigSize
, (int)p
->dbFileSize
1043 /* Forward references to the various page getters */
1044 static int getPageNormal(Pager
*,Pgno
,DbPage
**,int);
1045 static int getPageError(Pager
*,Pgno
,DbPage
**,int);
1046 #if SQLITE_MAX_MMAP_SIZE>0
1047 static int getPageMMap(Pager
*,Pgno
,DbPage
**,int);
1051 ** Set the Pager.xGet method for the appropriate routine used to fetch
1052 ** content from the pager.
1054 static void setGetterMethod(Pager
*pPager
){
1055 if( pPager
->errCode
){
1056 pPager
->xGet
= getPageError
;
1057 #if SQLITE_MAX_MMAP_SIZE>0
1058 }else if( USEFETCH(pPager
)
1059 #ifdef SQLITE_HAS_CODEC
1060 && pPager
->xCodec
==0
1063 pPager
->xGet
= getPageMMap
;
1064 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
1066 pPager
->xGet
= getPageNormal
;
1071 ** Return true if it is necessary to write page *pPg into the sub-journal.
1072 ** A page needs to be written into the sub-journal if there exists one
1073 ** or more open savepoints for which:
1075 ** * The page-number is less than or equal to PagerSavepoint.nOrig, and
1076 ** * The bit corresponding to the page-number is not set in
1077 ** PagerSavepoint.pInSavepoint.
1079 static int subjRequiresPage(PgHdr
*pPg
){
1080 Pager
*pPager
= pPg
->pPager
;
1082 Pgno pgno
= pPg
->pgno
;
1084 for(i
=0; i
<pPager
->nSavepoint
; i
++){
1085 p
= &pPager
->aSavepoint
[i
];
1086 if( p
->nOrig
>=pgno
&& 0==sqlite3BitvecTestNotNull(p
->pInSavepoint
, pgno
) ){
1095 ** Return true if the page is already in the journal file.
1097 static int pageInJournal(Pager
*pPager
, PgHdr
*pPg
){
1098 return sqlite3BitvecTest(pPager
->pInJournal
, pPg
->pgno
);
1103 ** Read a 32-bit integer from the given file descriptor. Store the integer
1104 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
1105 ** error code is something goes wrong.
1107 ** All values are stored on disk as big-endian.
1109 static int read32bits(sqlite3_file
*fd
, i64 offset
, u32
*pRes
){
1110 unsigned char ac
[4];
1111 int rc
= sqlite3OsRead(fd
, ac
, sizeof(ac
), offset
);
1112 if( rc
==SQLITE_OK
){
1113 *pRes
= sqlite3Get4byte(ac
);
1119 ** Write a 32-bit integer into a string buffer in big-endian byte order.
1121 #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
1125 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
1126 ** on success or an error code is something goes wrong.
1128 static int write32bits(sqlite3_file
*fd
, i64 offset
, u32 val
){
1131 return sqlite3OsWrite(fd
, ac
, 4, offset
);
1135 ** Unlock the database file to level eLock, which must be either NO_LOCK
1136 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
1137 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
1139 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1140 ** called, do not modify it. See the comment above the #define of
1141 ** UNKNOWN_LOCK for an explanation of this.
1143 static int pagerUnlockDb(Pager
*pPager
, int eLock
){
1146 assert( !pPager
->exclusiveMode
|| pPager
->eLock
==eLock
);
1147 assert( eLock
==NO_LOCK
|| eLock
==SHARED_LOCK
);
1148 assert( eLock
!=NO_LOCK
|| pagerUseWal(pPager
)==0 );
1149 if( isOpen(pPager
->fd
) ){
1150 assert( pPager
->eLock
>=eLock
);
1151 rc
= pPager
->noLock
? SQLITE_OK
: sqlite3OsUnlock(pPager
->fd
, eLock
);
1152 if( pPager
->eLock
!=UNKNOWN_LOCK
){
1153 pPager
->eLock
= (u8
)eLock
;
1155 IOTRACE(("UNLOCK %p %d\n", pPager
, eLock
))
1161 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
1162 ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
1163 ** Pager.eLock variable to the new locking state.
1165 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1166 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
1167 ** See the comment above the #define of UNKNOWN_LOCK for an explanation
1170 static int pagerLockDb(Pager
*pPager
, int eLock
){
1173 assert( eLock
==SHARED_LOCK
|| eLock
==RESERVED_LOCK
|| eLock
==EXCLUSIVE_LOCK
);
1174 if( pPager
->eLock
<eLock
|| pPager
->eLock
==UNKNOWN_LOCK
){
1175 rc
= pPager
->noLock
? SQLITE_OK
: sqlite3OsLock(pPager
->fd
, eLock
);
1176 if( rc
==SQLITE_OK
&& (pPager
->eLock
!=UNKNOWN_LOCK
||eLock
==EXCLUSIVE_LOCK
) ){
1177 pPager
->eLock
= (u8
)eLock
;
1178 IOTRACE(("LOCK %p %d\n", pPager
, eLock
))
1185 ** This function determines whether or not the atomic-write or
1186 ** atomic-batch-write optimizations can be used with this pager. The
1187 ** atomic-write optimization can be used if:
1189 ** (a) the value returned by OsDeviceCharacteristics() indicates that
1190 ** a database page may be written atomically, and
1191 ** (b) the value returned by OsSectorSize() is less than or equal
1192 ** to the page size.
1194 ** If it can be used, then the value returned is the size of the journal
1195 ** file when it contains rollback data for exactly one page.
1197 ** The atomic-batch-write optimization can be used if OsDeviceCharacteristics()
1198 ** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
1199 ** returned in this case.
1201 ** If neither optimization can be used, 0 is returned.
1203 static int jrnlBufferSize(Pager
*pPager
){
1206 #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
1207 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
1208 int dc
; /* Device characteristics */
1210 assert( isOpen(pPager
->fd
) );
1211 dc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
1213 UNUSED_PARAMETER(pPager
);
1216 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
1217 if( pPager
->dbSize
>0 && (dc
&SQLITE_IOCAP_BATCH_ATOMIC
) ){
1222 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
1224 int nSector
= pPager
->sectorSize
;
1225 int szPage
= pPager
->pageSize
;
1227 assert(SQLITE_IOCAP_ATOMIC512
==(512>>8));
1228 assert(SQLITE_IOCAP_ATOMIC64K
==(65536>>8));
1229 if( 0==(dc
&(SQLITE_IOCAP_ATOMIC
|(szPage
>>8)) || nSector
>szPage
) ){
1234 return JOURNAL_HDR_SZ(pPager
) + JOURNAL_PG_SZ(pPager
);
1241 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
1242 ** on the cache using a hash function. This is used for testing
1243 ** and debugging only.
1245 #ifdef SQLITE_CHECK_PAGES
1247 ** Return a 32-bit hash of the page data for pPage.
1249 static u32
pager_datahash(int nByte
, unsigned char *pData
){
1252 for(i
=0; i
<nByte
; i
++){
1253 hash
= (hash
*1039) + pData
[i
];
1257 static u32
pager_pagehash(PgHdr
*pPage
){
1258 return pager_datahash(pPage
->pPager
->pageSize
, (unsigned char *)pPage
->pData
);
1260 static void pager_set_pagehash(PgHdr
*pPage
){
1261 pPage
->pageHash
= pager_pagehash(pPage
);
1265 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
1266 ** is defined, and NDEBUG is not defined, an assert() statement checks
1267 ** that the page is either dirty or still matches the calculated page-hash.
1269 #define CHECK_PAGE(x) checkPage(x)
1270 static void checkPage(PgHdr
*pPg
){
1271 Pager
*pPager
= pPg
->pPager
;
1272 assert( pPager
->eState
!=PAGER_ERROR
);
1273 assert( (pPg
->flags
&PGHDR_DIRTY
) || pPg
->pageHash
==pager_pagehash(pPg
) );
1277 #define pager_datahash(X,Y) 0
1278 #define pager_pagehash(X) 0
1279 #define pager_set_pagehash(X)
1280 #define CHECK_PAGE(x)
1281 #endif /* SQLITE_CHECK_PAGES */
1284 ** When this is called the journal file for pager pPager must be open.
1285 ** This function attempts to read a master journal file name from the
1286 ** end of the file and, if successful, copies it into memory supplied
1287 ** by the caller. See comments above writeMasterJournal() for the format
1288 ** used to store a master journal file name at the end of a journal file.
1290 ** zMaster must point to a buffer of at least nMaster bytes allocated by
1291 ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
1292 ** enough space to write the master journal name). If the master journal
1293 ** name in the journal is longer than nMaster bytes (including a
1294 ** nul-terminator), then this is handled as if no master journal name
1295 ** were present in the journal.
1297 ** If a master journal file name is present at the end of the journal
1298 ** file, then it is copied into the buffer pointed to by zMaster. A
1299 ** nul-terminator byte is appended to the buffer following the master
1300 ** journal file name.
1302 ** If it is determined that no master journal file name is present
1303 ** zMaster[0] is set to 0 and SQLITE_OK returned.
1305 ** If an error occurs while reading from the journal file, an SQLite
1306 ** error code is returned.
1308 static int readMasterJournal(sqlite3_file
*pJrnl
, char *zMaster
, u32 nMaster
){
1309 int rc
; /* Return code */
1310 u32 len
; /* Length in bytes of master journal name */
1311 i64 szJ
; /* Total size in bytes of journal file pJrnl */
1312 u32 cksum
; /* MJ checksum value read from journal */
1313 u32 u
; /* Unsigned loop counter */
1314 unsigned char aMagic
[8]; /* A buffer to hold the magic header */
1317 if( SQLITE_OK
!=(rc
= sqlite3OsFileSize(pJrnl
, &szJ
))
1319 || SQLITE_OK
!=(rc
= read32bits(pJrnl
, szJ
-16, &len
))
1323 || SQLITE_OK
!=(rc
= read32bits(pJrnl
, szJ
-12, &cksum
))
1324 || SQLITE_OK
!=(rc
= sqlite3OsRead(pJrnl
, aMagic
, 8, szJ
-8))
1325 || memcmp(aMagic
, aJournalMagic
, 8)
1326 || SQLITE_OK
!=(rc
= sqlite3OsRead(pJrnl
, zMaster
, len
, szJ
-16-len
))
1331 /* See if the checksum matches the master journal name */
1332 for(u
=0; u
<len
; u
++){
1333 cksum
-= zMaster
[u
];
1336 /* If the checksum doesn't add up, then one or more of the disk sectors
1337 ** containing the master journal filename is corrupted. This means
1338 ** definitely roll back, so just return SQLITE_OK and report a (nul)
1339 ** master-journal filename.
1343 zMaster
[len
] = '\0';
1349 ** Return the offset of the sector boundary at or immediately
1350 ** following the value in pPager->journalOff, assuming a sector
1351 ** size of pPager->sectorSize bytes.
1353 ** i.e for a sector size of 512:
1355 ** Pager.journalOff Return value
1356 ** ---------------------------------------
1363 static i64
journalHdrOffset(Pager
*pPager
){
1365 i64 c
= pPager
->journalOff
;
1367 offset
= ((c
-1)/JOURNAL_HDR_SZ(pPager
) + 1) * JOURNAL_HDR_SZ(pPager
);
1369 assert( offset
%JOURNAL_HDR_SZ(pPager
)==0 );
1370 assert( offset
>=c
);
1371 assert( (offset
-c
)<JOURNAL_HDR_SZ(pPager
) );
1376 ** The journal file must be open when this function is called.
1378 ** This function is a no-op if the journal file has not been written to
1379 ** within the current transaction (i.e. if Pager.journalOff==0).
1381 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
1382 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
1383 ** zero the 28-byte header at the start of the journal file. In either case,
1384 ** if the pager is not in no-sync mode, sync the journal file immediately
1385 ** after writing or truncating it.
1387 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
1388 ** following the truncation or zeroing described above the size of the
1389 ** journal file in bytes is larger than this value, then truncate the
1390 ** journal file to Pager.journalSizeLimit bytes. The journal file does
1391 ** not need to be synced following this operation.
1393 ** If an IO error occurs, abandon processing and return the IO error code.
1394 ** Otherwise, return SQLITE_OK.
1396 static int zeroJournalHdr(Pager
*pPager
, int doTruncate
){
1397 int rc
= SQLITE_OK
; /* Return code */
1398 assert( isOpen(pPager
->jfd
) );
1399 assert( !sqlite3JournalIsInMemory(pPager
->jfd
) );
1400 if( pPager
->journalOff
){
1401 const i64 iLimit
= pPager
->journalSizeLimit
; /* Local cache of jsl */
1403 IOTRACE(("JZEROHDR %p\n", pPager
))
1404 if( doTruncate
|| iLimit
==0 ){
1405 rc
= sqlite3OsTruncate(pPager
->jfd
, 0);
1407 static const char zeroHdr
[28] = {0};
1408 rc
= sqlite3OsWrite(pPager
->jfd
, zeroHdr
, sizeof(zeroHdr
), 0);
1410 if( rc
==SQLITE_OK
&& !pPager
->noSync
){
1411 rc
= sqlite3OsSync(pPager
->jfd
, SQLITE_SYNC_DATAONLY
|pPager
->syncFlags
);
1414 /* At this point the transaction is committed but the write lock
1415 ** is still held on the file. If there is a size limit configured for
1416 ** the persistent journal and the journal file currently consumes more
1417 ** space than that limit allows for, truncate it now. There is no need
1418 ** to sync the file following this operation.
1420 if( rc
==SQLITE_OK
&& iLimit
>0 ){
1422 rc
= sqlite3OsFileSize(pPager
->jfd
, &sz
);
1423 if( rc
==SQLITE_OK
&& sz
>iLimit
){
1424 rc
= sqlite3OsTruncate(pPager
->jfd
, iLimit
);
1432 ** The journal file must be open when this routine is called. A journal
1433 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
1434 ** current location.
1436 ** The format for the journal header is as follows:
1437 ** - 8 bytes: Magic identifying journal format.
1438 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
1439 ** - 4 bytes: Random number used for page hash.
1440 ** - 4 bytes: Initial database page count.
1441 ** - 4 bytes: Sector size used by the process that wrote this journal.
1442 ** - 4 bytes: Database page size.
1444 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
1446 static int writeJournalHdr(Pager
*pPager
){
1447 int rc
= SQLITE_OK
; /* Return code */
1448 char *zHeader
= pPager
->pTmpSpace
; /* Temporary space used to build header */
1449 u32 nHeader
= (u32
)pPager
->pageSize
;/* Size of buffer pointed to by zHeader */
1450 u32 nWrite
; /* Bytes of header sector written */
1451 int ii
; /* Loop counter */
1453 assert( isOpen(pPager
->jfd
) ); /* Journal file must be open. */
1455 if( nHeader
>JOURNAL_HDR_SZ(pPager
) ){
1456 nHeader
= JOURNAL_HDR_SZ(pPager
);
1459 /* If there are active savepoints and any of them were created
1460 ** since the most recent journal header was written, update the
1461 ** PagerSavepoint.iHdrOffset fields now.
1463 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1464 if( pPager
->aSavepoint
[ii
].iHdrOffset
==0 ){
1465 pPager
->aSavepoint
[ii
].iHdrOffset
= pPager
->journalOff
;
1469 pPager
->journalHdr
= pPager
->journalOff
= journalHdrOffset(pPager
);
1472 ** Write the nRec Field - the number of page records that follow this
1473 ** journal header. Normally, zero is written to this value at this time.
1474 ** After the records are added to the journal (and the journal synced,
1475 ** if in full-sync mode), the zero is overwritten with the true number
1476 ** of records (see syncJournal()).
1478 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
1479 ** reading the journal this value tells SQLite to assume that the
1480 ** rest of the journal file contains valid page records. This assumption
1481 ** is dangerous, as if a failure occurred whilst writing to the journal
1482 ** file it may contain some garbage data. There are two scenarios
1483 ** where this risk can be ignored:
1485 ** * When the pager is in no-sync mode. Corruption can follow a
1486 ** power failure in this case anyway.
1488 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1489 ** that garbage data is never appended to the journal file.
1491 assert( isOpen(pPager
->fd
) || pPager
->noSync
);
1492 if( pPager
->noSync
|| (pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
)
1493 || (sqlite3OsDeviceCharacteristics(pPager
->fd
)&SQLITE_IOCAP_SAFE_APPEND
)
1495 memcpy(zHeader
, aJournalMagic
, sizeof(aJournalMagic
));
1496 put32bits(&zHeader
[sizeof(aJournalMagic
)], 0xffffffff);
1498 memset(zHeader
, 0, sizeof(aJournalMagic
)+4);
1501 /* The random check-hash initializer */
1502 sqlite3_randomness(sizeof(pPager
->cksumInit
), &pPager
->cksumInit
);
1503 put32bits(&zHeader
[sizeof(aJournalMagic
)+4], pPager
->cksumInit
);
1504 /* The initial database size */
1505 put32bits(&zHeader
[sizeof(aJournalMagic
)+8], pPager
->dbOrigSize
);
1506 /* The assumed sector size for this process */
1507 put32bits(&zHeader
[sizeof(aJournalMagic
)+12], pPager
->sectorSize
);
1510 put32bits(&zHeader
[sizeof(aJournalMagic
)+16], pPager
->pageSize
);
1512 /* Initializing the tail of the buffer is not necessary. Everything
1513 ** works find if the following memset() is omitted. But initializing
1514 ** the memory prevents valgrind from complaining, so we are willing to
1515 ** take the performance hit.
1517 memset(&zHeader
[sizeof(aJournalMagic
)+20], 0,
1518 nHeader
-(sizeof(aJournalMagic
)+20));
1520 /* In theory, it is only necessary to write the 28 bytes that the
1521 ** journal header consumes to the journal file here. Then increment the
1522 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
1523 ** record is written to the following sector (leaving a gap in the file
1524 ** that will be implicitly filled in by the OS).
1526 ** However it has been discovered that on some systems this pattern can
1527 ** be significantly slower than contiguously writing data to the file,
1528 ** even if that means explicitly writing data to the block of
1529 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
1532 ** The loop is required here in case the sector-size is larger than the
1533 ** database page size. Since the zHeader buffer is only Pager.pageSize
1534 ** bytes in size, more than one call to sqlite3OsWrite() may be required
1535 ** to populate the entire journal header sector.
1537 for(nWrite
=0; rc
==SQLITE_OK
&&nWrite
<JOURNAL_HDR_SZ(pPager
); nWrite
+=nHeader
){
1538 IOTRACE(("JHDR %p %lld %d\n", pPager
, pPager
->journalHdr
, nHeader
))
1539 rc
= sqlite3OsWrite(pPager
->jfd
, zHeader
, nHeader
, pPager
->journalOff
);
1540 assert( pPager
->journalHdr
<= pPager
->journalOff
);
1541 pPager
->journalOff
+= nHeader
;
1548 ** The journal file must be open when this is called. A journal header file
1549 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
1550 ** file. The current location in the journal file is given by
1551 ** pPager->journalOff. See comments above function writeJournalHdr() for
1552 ** a description of the journal header format.
1554 ** If the header is read successfully, *pNRec is set to the number of
1555 ** page records following this header and *pDbSize is set to the size of the
1556 ** database before the transaction began, in pages. Also, pPager->cksumInit
1557 ** is set to the value read from the journal header. SQLITE_OK is returned
1560 ** If the journal header file appears to be corrupted, SQLITE_DONE is
1561 ** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
1562 ** cannot be read from the journal file an error code is returned.
1564 static int readJournalHdr(
1565 Pager
*pPager
, /* Pager object */
1567 i64 journalSize
, /* Size of the open journal file in bytes */
1568 u32
*pNRec
, /* OUT: Value read from the nRec field */
1569 u32
*pDbSize
/* OUT: Value of original database size field */
1571 int rc
; /* Return code */
1572 unsigned char aMagic
[8]; /* A buffer to hold the magic header */
1573 i64 iHdrOff
; /* Offset of journal header being read */
1575 assert( isOpen(pPager
->jfd
) ); /* Journal file must be open. */
1577 /* Advance Pager.journalOff to the start of the next sector. If the
1578 ** journal file is too small for there to be a header stored at this
1579 ** point, return SQLITE_DONE.
1581 pPager
->journalOff
= journalHdrOffset(pPager
);
1582 if( pPager
->journalOff
+JOURNAL_HDR_SZ(pPager
) > journalSize
){
1585 iHdrOff
= pPager
->journalOff
;
1587 /* Read in the first 8 bytes of the journal header. If they do not match
1588 ** the magic string found at the start of each journal header, return
1589 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
1592 if( isHot
|| iHdrOff
!=pPager
->journalHdr
){
1593 rc
= sqlite3OsRead(pPager
->jfd
, aMagic
, sizeof(aMagic
), iHdrOff
);
1597 if( memcmp(aMagic
, aJournalMagic
, sizeof(aMagic
))!=0 ){
1602 /* Read the first three 32-bit fields of the journal header: The nRec
1603 ** field, the checksum-initializer and the database size at the start
1604 ** of the transaction. Return an error code if anything goes wrong.
1606 if( SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+8, pNRec
))
1607 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+12, &pPager
->cksumInit
))
1608 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+16, pDbSize
))
1613 if( pPager
->journalOff
==0 ){
1614 u32 iPageSize
; /* Page-size field of journal header */
1615 u32 iSectorSize
; /* Sector-size field of journal header */
1617 /* Read the page-size and sector-size journal header fields. */
1618 if( SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+20, &iSectorSize
))
1619 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+24, &iPageSize
))
1624 /* Versions of SQLite prior to 3.5.8 set the page-size field of the
1625 ** journal header to zero. In this case, assume that the Pager.pageSize
1626 ** variable is already set to the correct page size.
1629 iPageSize
= pPager
->pageSize
;
1632 /* Check that the values read from the page-size and sector-size fields
1633 ** are within range. To be 'in range', both values need to be a power
1634 ** of two greater than or equal to 512 or 32, and not greater than their
1635 ** respective compile time maximum limits.
1637 if( iPageSize
<512 || iSectorSize
<32
1638 || iPageSize
>SQLITE_MAX_PAGE_SIZE
|| iSectorSize
>MAX_SECTOR_SIZE
1639 || ((iPageSize
-1)&iPageSize
)!=0 || ((iSectorSize
-1)&iSectorSize
)!=0
1641 /* If the either the page-size or sector-size in the journal-header is
1642 ** invalid, then the process that wrote the journal-header must have
1643 ** crashed before the header was synced. In this case stop reading
1644 ** the journal file here.
1649 /* Update the page-size to match the value read from the journal.
1650 ** Use a testcase() macro to make sure that malloc failure within
1651 ** PagerSetPagesize() is tested.
1653 rc
= sqlite3PagerSetPagesize(pPager
, &iPageSize
, -1);
1654 testcase( rc
!=SQLITE_OK
);
1656 /* Update the assumed sector-size to match the value used by
1657 ** the process that created this journal. If this journal was
1658 ** created by a process other than this one, then this routine
1659 ** is being called from within pager_playback(). The local value
1660 ** of Pager.sectorSize is restored at the end of that routine.
1662 pPager
->sectorSize
= iSectorSize
;
1665 pPager
->journalOff
+= JOURNAL_HDR_SZ(pPager
);
1671 ** Write the supplied master journal name into the journal file for pager
1672 ** pPager at the current location. The master journal name must be the last
1673 ** thing written to a journal file. If the pager is in full-sync mode, the
1674 ** journal file descriptor is advanced to the next sector boundary before
1675 ** anything is written. The format is:
1677 ** + 4 bytes: PAGER_MJ_PGNO.
1678 ** + N bytes: Master journal filename in utf-8.
1679 ** + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
1680 ** + 4 bytes: Master journal name checksum.
1681 ** + 8 bytes: aJournalMagic[].
1683 ** The master journal page checksum is the sum of the bytes in the master
1684 ** journal name, where each byte is interpreted as a signed 8-bit integer.
1686 ** If zMaster is a NULL pointer (occurs for a single database transaction),
1687 ** this call is a no-op.
1689 static int writeMasterJournal(Pager
*pPager
, const char *zMaster
){
1690 int rc
; /* Return code */
1691 int nMaster
; /* Length of string zMaster */
1692 i64 iHdrOff
; /* Offset of header in journal file */
1693 i64 jrnlSize
; /* Size of journal file on disk */
1694 u32 cksum
= 0; /* Checksum of string zMaster */
1696 assert( pPager
->setMaster
==0 );
1697 assert( !pagerUseWal(pPager
) );
1700 || pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
1701 || !isOpen(pPager
->jfd
)
1705 pPager
->setMaster
= 1;
1706 assert( pPager
->journalHdr
<= pPager
->journalOff
);
1708 /* Calculate the length in bytes and the checksum of zMaster */
1709 for(nMaster
=0; zMaster
[nMaster
]; nMaster
++){
1710 cksum
+= zMaster
[nMaster
];
1713 /* If in full-sync mode, advance to the next disk sector before writing
1714 ** the master journal name. This is in case the previous page written to
1715 ** the journal has already been synced.
1717 if( pPager
->fullSync
){
1718 pPager
->journalOff
= journalHdrOffset(pPager
);
1720 iHdrOff
= pPager
->journalOff
;
1722 /* Write the master journal data to the end of the journal file. If
1723 ** an error occurs, return the error code to the caller.
1725 if( (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
, PAGER_MJ_PGNO(pPager
))))
1726 || (0 != (rc
= sqlite3OsWrite(pPager
->jfd
, zMaster
, nMaster
, iHdrOff
+4)))
1727 || (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
+4+nMaster
, nMaster
)))
1728 || (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
+4+nMaster
+4, cksum
)))
1729 || (0 != (rc
= sqlite3OsWrite(pPager
->jfd
, aJournalMagic
, 8,
1730 iHdrOff
+4+nMaster
+8)))
1734 pPager
->journalOff
+= (nMaster
+20);
1736 /* If the pager is in peristent-journal mode, then the physical
1737 ** journal-file may extend past the end of the master-journal name
1738 ** and 8 bytes of magic data just written to the file. This is
1739 ** dangerous because the code to rollback a hot-journal file
1740 ** will not be able to find the master-journal name to determine
1741 ** whether or not the journal is hot.
1743 ** Easiest thing to do in this scenario is to truncate the journal
1744 ** file to the required size.
1746 if( SQLITE_OK
==(rc
= sqlite3OsFileSize(pPager
->jfd
, &jrnlSize
))
1747 && jrnlSize
>pPager
->journalOff
1749 rc
= sqlite3OsTruncate(pPager
->jfd
, pPager
->journalOff
);
1755 ** Discard the entire contents of the in-memory page-cache.
1757 static void pager_reset(Pager
*pPager
){
1758 pPager
->iDataVersion
++;
1759 sqlite3BackupRestart(pPager
->pBackup
);
1760 sqlite3PcacheClear(pPager
->pPCache
);
1764 ** Return the pPager->iDataVersion value
1766 u32
sqlite3PagerDataVersion(Pager
*pPager
){
1767 assert( pPager
->eState
>PAGER_OPEN
);
1768 return pPager
->iDataVersion
;
1772 ** Free all structures in the Pager.aSavepoint[] array and set both
1773 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1774 ** if it is open and the pager is not in exclusive mode.
1776 static void releaseAllSavepoints(Pager
*pPager
){
1777 int ii
; /* Iterator for looping through Pager.aSavepoint */
1778 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1779 sqlite3BitvecDestroy(pPager
->aSavepoint
[ii
].pInSavepoint
);
1781 if( !pPager
->exclusiveMode
|| sqlite3JournalIsInMemory(pPager
->sjfd
) ){
1782 sqlite3OsClose(pPager
->sjfd
);
1784 sqlite3_free(pPager
->aSavepoint
);
1785 pPager
->aSavepoint
= 0;
1786 pPager
->nSavepoint
= 0;
1787 pPager
->nSubRec
= 0;
1791 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1792 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
1793 ** or SQLITE_NOMEM if a malloc failure occurs.
1795 static int addToSavepointBitvecs(Pager
*pPager
, Pgno pgno
){
1796 int ii
; /* Loop counter */
1797 int rc
= SQLITE_OK
; /* Result code */
1799 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1800 PagerSavepoint
*p
= &pPager
->aSavepoint
[ii
];
1801 if( pgno
<=p
->nOrig
){
1802 rc
|= sqlite3BitvecSet(p
->pInSavepoint
, pgno
);
1803 testcase( rc
==SQLITE_NOMEM
);
1804 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
1811 ** This function is a no-op if the pager is in exclusive mode and not
1812 ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
1815 ** If the pager is not in exclusive-access mode, the database file is
1816 ** completely unlocked. If the file is unlocked and the file-system does
1817 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
1818 ** closed (if it is open).
1820 ** If the pager is in ERROR state when this function is called, the
1821 ** contents of the pager cache are discarded before switching back to
1822 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
1823 ** or not, any journal file left in the file-system will be treated
1824 ** as a hot-journal and rolled back the next time a read-transaction
1825 ** is opened (by this or by any other connection).
1827 static void pager_unlock(Pager
*pPager
){
1829 assert( pPager
->eState
==PAGER_READER
1830 || pPager
->eState
==PAGER_OPEN
1831 || pPager
->eState
==PAGER_ERROR
1834 sqlite3BitvecDestroy(pPager
->pInJournal
);
1835 pPager
->pInJournal
= 0;
1836 releaseAllSavepoints(pPager
);
1838 if( pagerUseWal(pPager
) ){
1839 assert( !isOpen(pPager
->jfd
) );
1840 sqlite3WalEndReadTransaction(pPager
->pWal
);
1841 pPager
->eState
= PAGER_OPEN
;
1842 }else if( !pPager
->exclusiveMode
){
1843 int rc
; /* Error code returned by pagerUnlockDb() */
1844 int iDc
= isOpen(pPager
->fd
)?sqlite3OsDeviceCharacteristics(pPager
->fd
):0;
1846 /* If the operating system support deletion of open files, then
1847 ** close the journal file when dropping the database lock. Otherwise
1848 ** another connection with journal_mode=delete might delete the file
1849 ** out from under us.
1851 assert( (PAGER_JOURNALMODE_MEMORY
& 5)!=1 );
1852 assert( (PAGER_JOURNALMODE_OFF
& 5)!=1 );
1853 assert( (PAGER_JOURNALMODE_WAL
& 5)!=1 );
1854 assert( (PAGER_JOURNALMODE_DELETE
& 5)!=1 );
1855 assert( (PAGER_JOURNALMODE_TRUNCATE
& 5)==1 );
1856 assert( (PAGER_JOURNALMODE_PERSIST
& 5)==1 );
1857 if( 0==(iDc
& SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
)
1858 || 1!=(pPager
->journalMode
& 5)
1860 sqlite3OsClose(pPager
->jfd
);
1863 /* If the pager is in the ERROR state and the call to unlock the database
1864 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
1865 ** above the #define for UNKNOWN_LOCK for an explanation of why this
1868 rc
= pagerUnlockDb(pPager
, NO_LOCK
);
1869 if( rc
!=SQLITE_OK
&& pPager
->eState
==PAGER_ERROR
){
1870 pPager
->eLock
= UNKNOWN_LOCK
;
1873 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
1874 ** without clearing the error code. This is intentional - the error
1875 ** code is cleared and the cache reset in the block below.
1877 assert( pPager
->errCode
|| pPager
->eState
!=PAGER_ERROR
);
1878 pPager
->changeCountDone
= 0;
1879 pPager
->eState
= PAGER_OPEN
;
1882 /* If Pager.errCode is set, the contents of the pager cache cannot be
1883 ** trusted. Now that there are no outstanding references to the pager,
1884 ** it can safely move back to PAGER_OPEN state. This happens in both
1885 ** normal and exclusive-locking mode.
1887 assert( pPager
->errCode
==SQLITE_OK
|| !MEMDB
);
1888 if( pPager
->errCode
){
1889 if( pPager
->tempFile
==0 ){
1890 pager_reset(pPager
);
1891 pPager
->changeCountDone
= 0;
1892 pPager
->eState
= PAGER_OPEN
;
1894 pPager
->eState
= (isOpen(pPager
->jfd
) ? PAGER_OPEN
: PAGER_READER
);
1896 if( USEFETCH(pPager
) ) sqlite3OsUnfetch(pPager
->fd
, 0, 0);
1897 pPager
->errCode
= SQLITE_OK
;
1898 setGetterMethod(pPager
);
1901 pPager
->journalOff
= 0;
1902 pPager
->journalHdr
= 0;
1903 pPager
->setMaster
= 0;
1907 ** This function is called whenever an IOERR or FULL error that requires
1908 ** the pager to transition into the ERROR state may ahve occurred.
1909 ** The first argument is a pointer to the pager structure, the second
1910 ** the error-code about to be returned by a pager API function. The
1911 ** value returned is a copy of the second argument to this function.
1913 ** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
1914 ** IOERR sub-codes, the pager enters the ERROR state and the error code
1915 ** is stored in Pager.errCode. While the pager remains in the ERROR state,
1916 ** all major API calls on the Pager will immediately return Pager.errCode.
1918 ** The ERROR state indicates that the contents of the pager-cache
1919 ** cannot be trusted. This state can be cleared by completely discarding
1920 ** the contents of the pager-cache. If a transaction was active when
1921 ** the persistent error occurred, then the rollback journal may need
1922 ** to be replayed to restore the contents of the database file (as if
1923 ** it were a hot-journal).
1925 static int pager_error(Pager
*pPager
, int rc
){
1926 int rc2
= rc
& 0xff;
1927 assert( rc
==SQLITE_OK
|| !MEMDB
);
1929 pPager
->errCode
==SQLITE_FULL
||
1930 pPager
->errCode
==SQLITE_OK
||
1931 (pPager
->errCode
& 0xff)==SQLITE_IOERR
1933 if( rc2
==SQLITE_FULL
|| rc2
==SQLITE_IOERR
){
1934 pPager
->errCode
= rc
;
1935 pPager
->eState
= PAGER_ERROR
;
1936 setGetterMethod(pPager
);
1941 static int pager_truncate(Pager
*pPager
, Pgno nPage
);
1944 ** The write transaction open on pPager is being committed (bCommit==1)
1945 ** or rolled back (bCommit==0).
1947 ** Return TRUE if and only if all dirty pages should be flushed to disk.
1951 ** * For non-TEMP databases, always sync to disk. This is necessary
1952 ** for transactions to be durable.
1954 ** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing
1955 ** file has been created already (via a spill on pagerStress()) and
1956 ** when the number of dirty pages in memory exceeds 25% of the total
1959 static int pagerFlushOnCommit(Pager
*pPager
, int bCommit
){
1960 if( pPager
->tempFile
==0 ) return 1;
1961 if( !bCommit
) return 0;
1962 if( !isOpen(pPager
->fd
) ) return 0;
1963 return (sqlite3PCachePercentDirty(pPager
->pPCache
)>=25);
1967 ** This routine ends a transaction. A transaction is usually ended by
1968 ** either a COMMIT or a ROLLBACK operation. This routine may be called
1969 ** after rollback of a hot-journal, or if an error occurs while opening
1970 ** the journal file or writing the very first journal-header of a
1971 ** database transaction.
1973 ** This routine is never called in PAGER_ERROR state. If it is called
1974 ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
1975 ** exclusive than a RESERVED lock, it is a no-op.
1977 ** Otherwise, any active savepoints are released.
1979 ** If the journal file is open, then it is "finalized". Once a journal
1980 ** file has been finalized it is not possible to use it to roll back a
1981 ** transaction. Nor will it be considered to be a hot-journal by this
1982 ** or any other database connection. Exactly how a journal is finalized
1983 ** depends on whether or not the pager is running in exclusive mode and
1984 ** the current journal-mode (Pager.journalMode value), as follows:
1986 ** journalMode==MEMORY
1987 ** Journal file descriptor is simply closed. This destroys an
1988 ** in-memory journal.
1990 ** journalMode==TRUNCATE
1991 ** Journal file is truncated to zero bytes in size.
1993 ** journalMode==PERSIST
1994 ** The first 28 bytes of the journal file are zeroed. This invalidates
1995 ** the first journal header in the file, and hence the entire journal
1996 ** file. An invalid journal file cannot be rolled back.
1998 ** journalMode==DELETE
1999 ** The journal file is closed and deleted using sqlite3OsDelete().
2001 ** If the pager is running in exclusive mode, this method of finalizing
2002 ** the journal file is never used. Instead, if the journalMode is
2003 ** DELETE and the pager is in exclusive mode, the method described under
2004 ** journalMode==PERSIST is used instead.
2006 ** After the journal is finalized, the pager moves to PAGER_READER state.
2007 ** If running in non-exclusive rollback mode, the lock on the file is
2008 ** downgraded to a SHARED_LOCK.
2010 ** SQLITE_OK is returned if no error occurs. If an error occurs during
2011 ** any of the IO operations to finalize the journal file or unlock the
2012 ** database then the IO error code is returned to the user. If the
2013 ** operation to finalize the journal file fails, then the code still
2014 ** tries to unlock the database file if not in exclusive mode. If the
2015 ** unlock operation fails as well, then the first error code related
2016 ** to the first error encountered (the journal finalization one) is
2019 static int pager_end_transaction(Pager
*pPager
, int hasMaster
, int bCommit
){
2020 int rc
= SQLITE_OK
; /* Error code from journal finalization operation */
2021 int rc2
= SQLITE_OK
; /* Error code from db file unlock operation */
2023 /* Do nothing if the pager does not have an open write transaction
2024 ** or at least a RESERVED lock. This function may be called when there
2025 ** is no write-transaction active but a RESERVED or greater lock is
2026 ** held under two circumstances:
2028 ** 1. After a successful hot-journal rollback, it is called with
2029 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
2031 ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
2032 ** lock switches back to locking_mode=normal and then executes a
2033 ** read-transaction, this function is called with eState==PAGER_READER
2034 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
2036 assert( assert_pager_state(pPager
) );
2037 assert( pPager
->eState
!=PAGER_ERROR
);
2038 if( pPager
->eState
<PAGER_WRITER_LOCKED
&& pPager
->eLock
<RESERVED_LOCK
){
2042 releaseAllSavepoints(pPager
);
2043 assert( isOpen(pPager
->jfd
) || pPager
->pInJournal
==0
2044 || (sqlite3OsDeviceCharacteristics(pPager
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
2046 if( isOpen(pPager
->jfd
) ){
2047 assert( !pagerUseWal(pPager
) );
2049 /* Finalize the journal file. */
2050 if( sqlite3JournalIsInMemory(pPager
->jfd
) ){
2051 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
2052 sqlite3OsClose(pPager
->jfd
);
2053 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_TRUNCATE
){
2054 if( pPager
->journalOff
==0 ){
2057 rc
= sqlite3OsTruncate(pPager
->jfd
, 0);
2058 if( rc
==SQLITE_OK
&& pPager
->fullSync
){
2059 /* Make sure the new file size is written into the inode right away.
2060 ** Otherwise the journal might resurrect following a power loss and
2061 ** cause the last transaction to roll back. See
2062 ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
2064 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
);
2067 pPager
->journalOff
= 0;
2068 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_PERSIST
2069 || (pPager
->exclusiveMode
&& pPager
->journalMode
!=PAGER_JOURNALMODE_WAL
)
2071 rc
= zeroJournalHdr(pPager
, hasMaster
||pPager
->tempFile
);
2072 pPager
->journalOff
= 0;
2074 /* This branch may be executed with Pager.journalMode==MEMORY if
2075 ** a hot-journal was just rolled back. In this case the journal
2076 ** file should be closed and deleted. If this connection writes to
2077 ** the database file, it will do so using an in-memory journal.
2079 int bDelete
= !pPager
->tempFile
;
2080 assert( sqlite3JournalIsInMemory(pPager
->jfd
)==0 );
2081 assert( pPager
->journalMode
==PAGER_JOURNALMODE_DELETE
2082 || pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
2083 || pPager
->journalMode
==PAGER_JOURNALMODE_WAL
2085 sqlite3OsClose(pPager
->jfd
);
2087 rc
= sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, pPager
->extraSync
);
2092 #ifdef SQLITE_CHECK_PAGES
2093 sqlite3PcacheIterateDirty(pPager
->pPCache
, pager_set_pagehash
);
2094 if( pPager
->dbSize
==0 && sqlite3PcacheRefCount(pPager
->pPCache
)>0 ){
2095 PgHdr
*p
= sqlite3PagerLookup(pPager
, 1);
2098 sqlite3PagerUnrefNotNull(p
);
2103 sqlite3BitvecDestroy(pPager
->pInJournal
);
2104 pPager
->pInJournal
= 0;
2106 if( rc
==SQLITE_OK
){
2107 if( MEMDB
|| pagerFlushOnCommit(pPager
, bCommit
) ){
2108 sqlite3PcacheCleanAll(pPager
->pPCache
);
2110 sqlite3PcacheClearWritable(pPager
->pPCache
);
2112 sqlite3PcacheTruncate(pPager
->pPCache
, pPager
->dbSize
);
2115 if( pagerUseWal(pPager
) ){
2116 /* Drop the WAL write-lock, if any. Also, if the connection was in
2117 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
2118 ** lock held on the database file.
2120 rc2
= sqlite3WalEndWriteTransaction(pPager
->pWal
);
2121 assert( rc2
==SQLITE_OK
);
2122 }else if( rc
==SQLITE_OK
&& bCommit
&& pPager
->dbFileSize
>pPager
->dbSize
){
2123 /* This branch is taken when committing a transaction in rollback-journal
2124 ** mode if the database file on disk is larger than the database image.
2125 ** At this point the journal has been finalized and the transaction
2126 ** successfully committed, but the EXCLUSIVE lock is still held on the
2127 ** file. So it is safe to truncate the database file to its minimum
2128 ** required size. */
2129 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
2130 rc
= pager_truncate(pPager
, pPager
->dbSize
);
2133 if( rc
==SQLITE_OK
&& bCommit
){
2134 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_COMMIT_PHASETWO
, 0);
2135 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
2138 if( !pPager
->exclusiveMode
2139 && (!pagerUseWal(pPager
) || sqlite3WalExclusiveMode(pPager
->pWal
, 0))
2141 rc2
= pagerUnlockDb(pPager
, SHARED_LOCK
);
2142 pPager
->changeCountDone
= 0;
2144 pPager
->eState
= PAGER_READER
;
2145 pPager
->setMaster
= 0;
2147 return (rc
==SQLITE_OK
?rc2
:rc
);
2151 ** Execute a rollback if a transaction is active and unlock the
2154 ** If the pager has already entered the ERROR state, do not attempt
2155 ** the rollback at this time. Instead, pager_unlock() is called. The
2156 ** call to pager_unlock() will discard all in-memory pages, unlock
2157 ** the database file and move the pager back to OPEN state. If this
2158 ** means that there is a hot-journal left in the file-system, the next
2159 ** connection to obtain a shared lock on the pager (which may be this one)
2160 ** will roll it back.
2162 ** If the pager has not already entered the ERROR state, but an IO or
2163 ** malloc error occurs during a rollback, then this will itself cause
2164 ** the pager to enter the ERROR state. Which will be cleared by the
2165 ** call to pager_unlock(), as described above.
2167 static void pagerUnlockAndRollback(Pager
*pPager
){
2168 if( pPager
->eState
!=PAGER_ERROR
&& pPager
->eState
!=PAGER_OPEN
){
2169 assert( assert_pager_state(pPager
) );
2170 if( pPager
->eState
>=PAGER_WRITER_LOCKED
){
2171 sqlite3BeginBenignMalloc();
2172 sqlite3PagerRollback(pPager
);
2173 sqlite3EndBenignMalloc();
2174 }else if( !pPager
->exclusiveMode
){
2175 assert( pPager
->eState
==PAGER_READER
);
2176 pager_end_transaction(pPager
, 0, 0);
2179 pager_unlock(pPager
);
2183 ** Parameter aData must point to a buffer of pPager->pageSize bytes
2184 ** of data. Compute and return a checksum based ont the contents of the
2185 ** page of data and the current value of pPager->cksumInit.
2187 ** This is not a real checksum. It is really just the sum of the
2188 ** random initial value (pPager->cksumInit) and every 200th byte
2189 ** of the page data, starting with byte offset (pPager->pageSize%200).
2190 ** Each byte is interpreted as an 8-bit unsigned integer.
2192 ** Changing the formula used to compute this checksum results in an
2193 ** incompatible journal file format.
2195 ** If journal corruption occurs due to a power failure, the most likely
2196 ** scenario is that one end or the other of the record will be changed.
2197 ** It is much less likely that the two ends of the journal record will be
2198 ** correct and the middle be corrupt. Thus, this "checksum" scheme,
2199 ** though fast and simple, catches the mostly likely kind of corruption.
2201 static u32
pager_cksum(Pager
*pPager
, const u8
*aData
){
2202 u32 cksum
= pPager
->cksumInit
; /* Checksum value to return */
2203 int i
= pPager
->pageSize
-200; /* Loop counter */
2212 ** Report the current page size and number of reserved bytes back
2215 #ifdef SQLITE_HAS_CODEC
2216 static void pagerReportSize(Pager
*pPager
){
2217 if( pPager
->xCodecSizeChng
){
2218 pPager
->xCodecSizeChng(pPager
->pCodec
, pPager
->pageSize
,
2219 (int)pPager
->nReserve
);
2223 # define pagerReportSize(X) /* No-op if we do not support a codec */
2226 #ifdef SQLITE_HAS_CODEC
2228 ** Make sure the number of reserved bits is the same in the destination
2229 ** pager as it is in the source. This comes up when a VACUUM changes the
2230 ** number of reserved bits to the "optimal" amount.
2232 void sqlite3PagerAlignReserve(Pager
*pDest
, Pager
*pSrc
){
2233 if( pDest
->nReserve
!=pSrc
->nReserve
){
2234 pDest
->nReserve
= pSrc
->nReserve
;
2235 pagerReportSize(pDest
);
2241 ** Read a single page from either the journal file (if isMainJrnl==1) or
2242 ** from the sub-journal (if isMainJrnl==0) and playback that page.
2243 ** The page begins at offset *pOffset into the file. The *pOffset
2244 ** value is increased to the start of the next page in the journal.
2246 ** The main rollback journal uses checksums - the statement journal does
2249 ** If the page number of the page record read from the (sub-)journal file
2250 ** is greater than the current value of Pager.dbSize, then playback is
2251 ** skipped and SQLITE_OK is returned.
2253 ** If pDone is not NULL, then it is a record of pages that have already
2254 ** been played back. If the page at *pOffset has already been played back
2255 ** (if the corresponding pDone bit is set) then skip the playback.
2256 ** Make sure the pDone bit corresponding to the *pOffset page is set
2257 ** prior to returning.
2259 ** If the page record is successfully read from the (sub-)journal file
2260 ** and played back, then SQLITE_OK is returned. If an IO error occurs
2261 ** while reading the record from the (sub-)journal file or while writing
2262 ** to the database file, then the IO error code is returned. If data
2263 ** is successfully read from the (sub-)journal file but appears to be
2264 ** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
2265 ** two circumstances:
2267 ** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
2268 ** * If the record is being rolled back from the main journal file
2269 ** and the checksum field does not match the record content.
2271 ** Neither of these two scenarios are possible during a savepoint rollback.
2273 ** If this is a savepoint rollback, then memory may have to be dynamically
2274 ** allocated by this function. If this is the case and an allocation fails,
2275 ** SQLITE_NOMEM is returned.
2277 static int pager_playback_one_page(
2278 Pager
*pPager
, /* The pager being played back */
2279 i64
*pOffset
, /* Offset of record to playback */
2280 Bitvec
*pDone
, /* Bitvec of pages already played back */
2281 int isMainJrnl
, /* 1 -> main journal. 0 -> sub-journal. */
2282 int isSavepnt
/* True for a savepoint rollback */
2285 PgHdr
*pPg
; /* An existing page in the cache */
2286 Pgno pgno
; /* The page number of a page in journal */
2287 u32 cksum
; /* Checksum used for sanity checking */
2288 char *aData
; /* Temporary storage for the page */
2289 sqlite3_file
*jfd
; /* The file descriptor for the journal file */
2290 int isSynced
; /* True if journal page is synced */
2291 #ifdef SQLITE_HAS_CODEC
2292 /* The jrnlEnc flag is true if Journal pages should be passed through
2293 ** the codec. It is false for pure in-memory journals. */
2294 const int jrnlEnc
= (isMainJrnl
|| pPager
->subjInMemory
==0);
2297 assert( (isMainJrnl
&~1)==0 ); /* isMainJrnl is 0 or 1 */
2298 assert( (isSavepnt
&~1)==0 ); /* isSavepnt is 0 or 1 */
2299 assert( isMainJrnl
|| pDone
); /* pDone always used on sub-journals */
2300 assert( isSavepnt
|| pDone
==0 ); /* pDone never used on non-savepoint */
2302 aData
= pPager
->pTmpSpace
;
2303 assert( aData
); /* Temp storage must have already been allocated */
2304 assert( pagerUseWal(pPager
)==0 || (!isMainJrnl
&& isSavepnt
) );
2306 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
2307 ** or savepoint rollback done at the request of the caller) or this is
2308 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
2309 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
2310 ** only reads from the main journal, not the sub-journal.
2312 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
2313 || (pPager
->eState
==PAGER_OPEN
&& pPager
->eLock
==EXCLUSIVE_LOCK
)
2315 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
|| isMainJrnl
);
2317 /* Read the page number and page data from the journal or sub-journal
2318 ** file. Return an error code to the caller if an IO error occurs.
2320 jfd
= isMainJrnl
? pPager
->jfd
: pPager
->sjfd
;
2321 rc
= read32bits(jfd
, *pOffset
, &pgno
);
2322 if( rc
!=SQLITE_OK
) return rc
;
2323 rc
= sqlite3OsRead(jfd
, (u8
*)aData
, pPager
->pageSize
, (*pOffset
)+4);
2324 if( rc
!=SQLITE_OK
) return rc
;
2325 *pOffset
+= pPager
->pageSize
+ 4 + isMainJrnl
*4;
2327 /* Sanity checking on the page. This is more important that I originally
2328 ** thought. If a power failure occurs while the journal is being written,
2329 ** it could cause invalid data to be written into the journal. We need to
2330 ** detect this invalid data (with high probability) and ignore it.
2332 if( pgno
==0 || pgno
==PAGER_MJ_PGNO(pPager
) ){
2333 assert( !isSavepnt
);
2336 if( pgno
>(Pgno
)pPager
->dbSize
|| sqlite3BitvecTest(pDone
, pgno
) ){
2340 rc
= read32bits(jfd
, (*pOffset
)-4, &cksum
);
2342 if( !isSavepnt
&& pager_cksum(pPager
, (u8
*)aData
)!=cksum
){
2347 /* If this page has already been played back before during the current
2348 ** rollback, then don't bother to play it back again.
2350 if( pDone
&& (rc
= sqlite3BitvecSet(pDone
, pgno
))!=SQLITE_OK
){
2354 /* When playing back page 1, restore the nReserve setting
2356 if( pgno
==1 && pPager
->nReserve
!=((u8
*)aData
)[20] ){
2357 pPager
->nReserve
= ((u8
*)aData
)[20];
2358 pagerReportSize(pPager
);
2361 /* If the pager is in CACHEMOD state, then there must be a copy of this
2362 ** page in the pager cache. In this case just update the pager cache,
2363 ** not the database file. The page is left marked dirty in this case.
2365 ** An exception to the above rule: If the database is in no-sync mode
2366 ** and a page is moved during an incremental vacuum then the page may
2367 ** not be in the pager cache. Later: if a malloc() or IO error occurs
2368 ** during a Movepage() call, then the page may not be in the cache
2369 ** either. So the condition described in the above paragraph is not
2372 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
2373 ** pager cache if it exists and the main file. The page is then marked
2374 ** not dirty. Since this code is only executed in PAGER_OPEN state for
2375 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
2376 ** if the pager is in OPEN state.
2378 ** Ticket #1171: The statement journal might contain page content that is
2379 ** different from the page content at the start of the transaction.
2380 ** This occurs when a page is changed prior to the start of a statement
2381 ** then changed again within the statement. When rolling back such a
2382 ** statement we must not write to the original database unless we know
2383 ** for certain that original page contents are synced into the main rollback
2384 ** journal. Otherwise, a power loss might leave modified data in the
2385 ** database file without an entry in the rollback journal that can
2386 ** restore the database to its original form. Two conditions must be
2387 ** met before writing to the database files. (1) the database must be
2388 ** locked. (2) we know that the original page content is fully synced
2389 ** in the main journal either because the page is not in cache or else
2390 ** the page is marked as needSync==0.
2392 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
2393 ** is possible to fail a statement on a database that does not yet exist.
2394 ** Do not attempt to write if database file has never been opened.
2396 if( pagerUseWal(pPager
) ){
2399 pPg
= sqlite3PagerLookup(pPager
, pgno
);
2401 assert( pPg
|| !MEMDB
);
2402 assert( pPager
->eState
!=PAGER_OPEN
|| pPg
==0 || pPager
->tempFile
);
2403 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
2404 PAGERID(pPager
), pgno
, pager_datahash(pPager
->pageSize
, (u8
*)aData
),
2405 (isMainJrnl
?"main-journal":"sub-journal")
2408 isSynced
= pPager
->noSync
|| (*pOffset
<= pPager
->journalHdr
);
2410 isSynced
= (pPg
==0 || 0==(pPg
->flags
& PGHDR_NEED_SYNC
));
2412 if( isOpen(pPager
->fd
)
2413 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2416 i64 ofst
= (pgno
-1)*(i64
)pPager
->pageSize
;
2417 testcase( !isSavepnt
&& pPg
!=0 && (pPg
->flags
&PGHDR_NEED_SYNC
)!=0 );
2418 assert( !pagerUseWal(pPager
) );
2420 /* Write the data read from the journal back into the database file.
2421 ** This is usually safe even for an encrypted database - as the data
2422 ** was encrypted before it was written to the journal file. The exception
2423 ** is if the data was just read from an in-memory sub-journal. In that
2424 ** case it must be encrypted here before it is copied into the database
2426 #ifdef SQLITE_HAS_CODEC
2428 CODEC2(pPager
, aData
, pgno
, 7, rc
=SQLITE_NOMEM_BKPT
, aData
);
2429 rc
= sqlite3OsWrite(pPager
->fd
, (u8
*)aData
, pPager
->pageSize
, ofst
);
2430 CODEC1(pPager
, aData
, pgno
, 3, rc
=SQLITE_NOMEM_BKPT
);
2433 rc
= sqlite3OsWrite(pPager
->fd
, (u8
*)aData
, pPager
->pageSize
, ofst
);
2435 if( pgno
>pPager
->dbFileSize
){
2436 pPager
->dbFileSize
= pgno
;
2438 if( pPager
->pBackup
){
2439 #ifdef SQLITE_HAS_CODEC
2441 CODEC1(pPager
, aData
, pgno
, 3, rc
=SQLITE_NOMEM_BKPT
);
2442 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)aData
);
2443 CODEC2(pPager
, aData
, pgno
, 7, rc
=SQLITE_NOMEM_BKPT
,aData
);
2446 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)aData
);
2448 }else if( !isMainJrnl
&& pPg
==0 ){
2449 /* If this is a rollback of a savepoint and data was not written to
2450 ** the database and the page is not in-memory, there is a potential
2451 ** problem. When the page is next fetched by the b-tree layer, it
2452 ** will be read from the database file, which may or may not be
2455 ** There are a couple of different ways this can happen. All are quite
2456 ** obscure. When running in synchronous mode, this can only happen
2457 ** if the page is on the free-list at the start of the transaction, then
2458 ** populated, then moved using sqlite3PagerMovepage().
2460 ** The solution is to add an in-memory page to the cache containing
2461 ** the data just read from the sub-journal. Mark the page as dirty
2462 ** and if the pager requires a journal-sync, then mark the page as
2463 ** requiring a journal-sync before it is written.
2465 assert( isSavepnt
);
2466 assert( (pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
)==0 );
2467 pPager
->doNotSpill
|= SPILLFLAG_ROLLBACK
;
2468 rc
= sqlite3PagerGet(pPager
, pgno
, &pPg
, 1);
2469 assert( (pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
)!=0 );
2470 pPager
->doNotSpill
&= ~SPILLFLAG_ROLLBACK
;
2471 if( rc
!=SQLITE_OK
) return rc
;
2472 sqlite3PcacheMakeDirty(pPg
);
2475 /* No page should ever be explicitly rolled back that is in use, except
2476 ** for page 1 which is held in use in order to keep the lock on the
2477 ** database active. However such a page may be rolled back as a result
2478 ** of an internal error resulting in an automatic call to
2479 ** sqlite3PagerRollback().
2483 memcpy(pData
, (u8
*)aData
, pPager
->pageSize
);
2484 pPager
->xReiniter(pPg
);
2485 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
2486 ** that call was dangerous and had no detectable benefit since the cache
2487 ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so
2488 ** has been removed. */
2489 pager_set_pagehash(pPg
);
2491 /* If this was page 1, then restore the value of Pager.dbFileVers.
2492 ** Do this before any decoding. */
2494 memcpy(&pPager
->dbFileVers
, &((u8
*)pData
)[24],sizeof(pPager
->dbFileVers
));
2497 /* Decode the page just read from disk */
2498 #if SQLITE_HAS_CODEC
2499 if( jrnlEnc
){ CODEC1(pPager
, pData
, pPg
->pgno
, 3, rc
=SQLITE_NOMEM_BKPT
); }
2501 sqlite3PcacheRelease(pPg
);
2507 ** Parameter zMaster is the name of a master journal file. A single journal
2508 ** file that referred to the master journal file has just been rolled back.
2509 ** This routine checks if it is possible to delete the master journal file,
2510 ** and does so if it is.
2512 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
2513 ** available for use within this function.
2515 ** When a master journal file is created, it is populated with the names
2516 ** of all of its child journals, one after another, formatted as utf-8
2517 ** encoded text. The end of each child journal file is marked with a
2518 ** nul-terminator byte (0x00). i.e. the entire contents of a master journal
2519 ** file for a transaction involving two databases might be:
2521 ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
2523 ** A master journal file may only be deleted once all of its child
2524 ** journals have been rolled back.
2526 ** This function reads the contents of the master-journal file into
2527 ** memory and loops through each of the child journal names. For
2528 ** each child journal, it checks if:
2530 ** * if the child journal exists, and if so
2531 ** * if the child journal contains a reference to master journal
2534 ** If a child journal can be found that matches both of the criteria
2535 ** above, this function returns without doing anything. Otherwise, if
2536 ** no such child journal can be found, file zMaster is deleted from
2537 ** the file-system using sqlite3OsDelete().
2539 ** If an IO error within this function, an error code is returned. This
2540 ** function allocates memory by calling sqlite3Malloc(). If an allocation
2541 ** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
2542 ** occur, SQLITE_OK is returned.
2544 ** TODO: This function allocates a single block of memory to load
2545 ** the entire contents of the master journal file. This could be
2546 ** a couple of kilobytes or so - potentially larger than the page
2549 static int pager_delmaster(Pager
*pPager
, const char *zMaster
){
2550 sqlite3_vfs
*pVfs
= pPager
->pVfs
;
2551 int rc
; /* Return code */
2552 sqlite3_file
*pMaster
; /* Malloc'd master-journal file descriptor */
2553 sqlite3_file
*pJournal
; /* Malloc'd child-journal file descriptor */
2554 char *zMasterJournal
= 0; /* Contents of master journal file */
2555 i64 nMasterJournal
; /* Size of master journal file */
2556 char *zJournal
; /* Pointer to one journal within MJ file */
2557 char *zMasterPtr
; /* Space to hold MJ filename from a journal file */
2558 int nMasterPtr
; /* Amount of space allocated to zMasterPtr[] */
2560 /* Allocate space for both the pJournal and pMaster file descriptors.
2561 ** If successful, open the master journal file for reading.
2563 pMaster
= (sqlite3_file
*)sqlite3MallocZero(pVfs
->szOsFile
* 2);
2564 pJournal
= (sqlite3_file
*)(((u8
*)pMaster
) + pVfs
->szOsFile
);
2566 rc
= SQLITE_NOMEM_BKPT
;
2568 const int flags
= (SQLITE_OPEN_READONLY
|SQLITE_OPEN_MASTER_JOURNAL
);
2569 rc
= sqlite3OsOpen(pVfs
, zMaster
, pMaster
, flags
, 0);
2571 if( rc
!=SQLITE_OK
) goto delmaster_out
;
2573 /* Load the entire master journal file into space obtained from
2574 ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain
2575 ** sufficient space (in zMasterPtr) to hold the names of master
2576 ** journal files extracted from regular rollback-journals.
2578 rc
= sqlite3OsFileSize(pMaster
, &nMasterJournal
);
2579 if( rc
!=SQLITE_OK
) goto delmaster_out
;
2580 nMasterPtr
= pVfs
->mxPathname
+1;
2581 zMasterJournal
= sqlite3Malloc(nMasterJournal
+ nMasterPtr
+ 1);
2582 if( !zMasterJournal
){
2583 rc
= SQLITE_NOMEM_BKPT
;
2586 zMasterPtr
= &zMasterJournal
[nMasterJournal
+1];
2587 rc
= sqlite3OsRead(pMaster
, zMasterJournal
, (int)nMasterJournal
, 0);
2588 if( rc
!=SQLITE_OK
) goto delmaster_out
;
2589 zMasterJournal
[nMasterJournal
] = 0;
2591 zJournal
= zMasterJournal
;
2592 while( (zJournal
-zMasterJournal
)<nMasterJournal
){
2594 rc
= sqlite3OsAccess(pVfs
, zJournal
, SQLITE_ACCESS_EXISTS
, &exists
);
2595 if( rc
!=SQLITE_OK
){
2599 /* One of the journals pointed to by the master journal exists.
2600 ** Open it and check if it points at the master journal. If
2601 ** so, return without deleting the master journal file.
2604 int flags
= (SQLITE_OPEN_READONLY
|SQLITE_OPEN_MAIN_JOURNAL
);
2605 rc
= sqlite3OsOpen(pVfs
, zJournal
, pJournal
, flags
, 0);
2606 if( rc
!=SQLITE_OK
){
2610 rc
= readMasterJournal(pJournal
, zMasterPtr
, nMasterPtr
);
2611 sqlite3OsClose(pJournal
);
2612 if( rc
!=SQLITE_OK
){
2616 c
= zMasterPtr
[0]!=0 && strcmp(zMasterPtr
, zMaster
)==0;
2618 /* We have a match. Do not delete the master journal file. */
2622 zJournal
+= (sqlite3Strlen30(zJournal
)+1);
2625 sqlite3OsClose(pMaster
);
2626 rc
= sqlite3OsDelete(pVfs
, zMaster
, 0);
2629 sqlite3_free(zMasterJournal
);
2631 sqlite3OsClose(pMaster
);
2632 assert( !isOpen(pJournal
) );
2633 sqlite3_free(pMaster
);
2640 ** This function is used to change the actual size of the database
2641 ** file in the file-system. This only happens when committing a transaction,
2642 ** or rolling back a transaction (including rolling back a hot-journal).
2644 ** If the main database file is not open, or the pager is not in either
2645 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
2646 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
2647 ** If the file on disk is currently larger than nPage pages, then use the VFS
2648 ** xTruncate() method to truncate it.
2650 ** Or, it might be the case that the file on disk is smaller than
2651 ** nPage pages. Some operating system implementations can get confused if
2652 ** you try to truncate a file to some size that is larger than it
2653 ** currently is, so detect this case and write a single zero byte to
2654 ** the end of the new file instead.
2656 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
2657 ** the database file, return the error code to the caller.
2659 static int pager_truncate(Pager
*pPager
, Pgno nPage
){
2661 assert( pPager
->eState
!=PAGER_ERROR
);
2662 assert( pPager
->eState
!=PAGER_READER
);
2664 if( isOpen(pPager
->fd
)
2665 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2667 i64 currentSize
, newSize
;
2668 int szPage
= pPager
->pageSize
;
2669 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
2670 /* TODO: Is it safe to use Pager.dbFileSize here? */
2671 rc
= sqlite3OsFileSize(pPager
->fd
, ¤tSize
);
2672 newSize
= szPage
*(i64
)nPage
;
2673 if( rc
==SQLITE_OK
&& currentSize
!=newSize
){
2674 if( currentSize
>newSize
){
2675 rc
= sqlite3OsTruncate(pPager
->fd
, newSize
);
2676 }else if( (currentSize
+szPage
)<=newSize
){
2677 char *pTmp
= pPager
->pTmpSpace
;
2678 memset(pTmp
, 0, szPage
);
2679 testcase( (newSize
-szPage
) == currentSize
);
2680 testcase( (newSize
-szPage
) > currentSize
);
2681 rc
= sqlite3OsWrite(pPager
->fd
, pTmp
, szPage
, newSize
-szPage
);
2683 if( rc
==SQLITE_OK
){
2684 pPager
->dbFileSize
= nPage
;
2692 ** Return a sanitized version of the sector-size of OS file pFile. The
2693 ** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
2695 int sqlite3SectorSize(sqlite3_file
*pFile
){
2696 int iRet
= sqlite3OsSectorSize(pFile
);
2699 }else if( iRet
>MAX_SECTOR_SIZE
){
2700 assert( MAX_SECTOR_SIZE
>=512 );
2701 iRet
= MAX_SECTOR_SIZE
;
2707 ** Set the value of the Pager.sectorSize variable for the given
2708 ** pager based on the value returned by the xSectorSize method
2709 ** of the open database file. The sector size will be used
2710 ** to determine the size and alignment of journal header and
2711 ** master journal pointers within created journal files.
2713 ** For temporary files the effective sector size is always 512 bytes.
2715 ** Otherwise, for non-temporary files, the effective sector size is
2716 ** the value returned by the xSectorSize() method rounded up to 32 if
2717 ** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
2718 ** is greater than MAX_SECTOR_SIZE.
2720 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
2721 ** the effective sector size to its minimum value (512). The purpose of
2722 ** pPager->sectorSize is to define the "blast radius" of bytes that
2723 ** might change if a crash occurs while writing to a single byte in
2724 ** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
2725 ** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
2726 ** size. For backwards compatibility of the rollback journal file format,
2727 ** we cannot reduce the effective sector size below 512.
2729 static void setSectorSize(Pager
*pPager
){
2730 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
2732 if( pPager
->tempFile
2733 || (sqlite3OsDeviceCharacteristics(pPager
->fd
) &
2734 SQLITE_IOCAP_POWERSAFE_OVERWRITE
)!=0
2736 /* Sector size doesn't matter for temporary files. Also, the file
2737 ** may not have been opened yet, in which case the OsSectorSize()
2738 ** call will segfault. */
2739 pPager
->sectorSize
= 512;
2741 pPager
->sectorSize
= sqlite3SectorSize(pPager
->fd
);
2746 ** Playback the journal and thus restore the database file to
2747 ** the state it was in before we started making changes.
2749 ** The journal file format is as follows:
2751 ** (1) 8 byte prefix. A copy of aJournalMagic[].
2752 ** (2) 4 byte big-endian integer which is the number of valid page records
2753 ** in the journal. If this value is 0xffffffff, then compute the
2754 ** number of page records from the journal size.
2755 ** (3) 4 byte big-endian integer which is the initial value for the
2757 ** (4) 4 byte integer which is the number of pages to truncate the
2758 ** database to during a rollback.
2759 ** (5) 4 byte big-endian integer which is the sector size. The header
2760 ** is this many bytes in size.
2761 ** (6) 4 byte big-endian integer which is the page size.
2762 ** (7) zero padding out to the next sector size.
2763 ** (8) Zero or more pages instances, each as follows:
2764 ** + 4 byte page number.
2765 ** + pPager->pageSize bytes of data.
2766 ** + 4 byte checksum
2768 ** When we speak of the journal header, we mean the first 7 items above.
2769 ** Each entry in the journal is an instance of the 8th item.
2771 ** Call the value from the second bullet "nRec". nRec is the number of
2772 ** valid page entries in the journal. In most cases, you can compute the
2773 ** value of nRec from the size of the journal file. But if a power
2774 ** failure occurred while the journal was being written, it could be the
2775 ** case that the size of the journal file had already been increased but
2776 ** the extra entries had not yet made it safely to disk. In such a case,
2777 ** the value of nRec computed from the file size would be too large. For
2778 ** that reason, we always use the nRec value in the header.
2780 ** If the nRec value is 0xffffffff it means that nRec should be computed
2781 ** from the file size. This value is used when the user selects the
2782 ** no-sync option for the journal. A power failure could lead to corruption
2783 ** in this case. But for things like temporary table (which will be
2784 ** deleted when the power is restored) we don't care.
2786 ** If the file opened as the journal file is not a well-formed
2787 ** journal file then all pages up to the first corrupted page are rolled
2788 ** back (or no pages if the journal header is corrupted). The journal file
2789 ** is then deleted and SQLITE_OK returned, just as if no corruption had
2790 ** been encountered.
2792 ** If an I/O or malloc() error occurs, the journal-file is not deleted
2793 ** and an error code is returned.
2795 ** The isHot parameter indicates that we are trying to rollback a journal
2796 ** that might be a hot journal. Or, it could be that the journal is
2797 ** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
2798 ** If the journal really is hot, reset the pager cache prior rolling
2799 ** back any content. If the journal is merely persistent, no reset is
2802 static int pager_playback(Pager
*pPager
, int isHot
){
2803 sqlite3_vfs
*pVfs
= pPager
->pVfs
;
2804 i64 szJ
; /* Size of the journal file in bytes */
2805 u32 nRec
; /* Number of Records in the journal */
2806 u32 u
; /* Unsigned loop counter */
2807 Pgno mxPg
= 0; /* Size of the original file in pages */
2808 int rc
; /* Result code of a subroutine */
2809 int res
= 1; /* Value returned by sqlite3OsAccess() */
2810 char *zMaster
= 0; /* Name of master journal file if any */
2811 int needPagerReset
; /* True to reset page prior to first page rollback */
2812 int nPlayback
= 0; /* Total number of pages restored from journal */
2813 u32 savedPageSize
= pPager
->pageSize
;
2815 /* Figure out how many records are in the journal. Abort early if
2816 ** the journal is empty.
2818 assert( isOpen(pPager
->jfd
) );
2819 rc
= sqlite3OsFileSize(pPager
->jfd
, &szJ
);
2820 if( rc
!=SQLITE_OK
){
2824 /* Read the master journal name from the journal, if it is present.
2825 ** If a master journal file name is specified, but the file is not
2826 ** present on disk, then the journal is not hot and does not need to be
2829 ** TODO: Technically the following is an error because it assumes that
2830 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2831 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
2832 ** mxPathname is 512, which is the same as the minimum allowable value
2835 zMaster
= pPager
->pTmpSpace
;
2836 rc
= readMasterJournal(pPager
->jfd
, zMaster
, pPager
->pVfs
->mxPathname
+1);
2837 if( rc
==SQLITE_OK
&& zMaster
[0] ){
2838 rc
= sqlite3OsAccess(pVfs
, zMaster
, SQLITE_ACCESS_EXISTS
, &res
);
2841 if( rc
!=SQLITE_OK
|| !res
){
2844 pPager
->journalOff
= 0;
2845 needPagerReset
= isHot
;
2847 /* This loop terminates either when a readJournalHdr() or
2848 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2852 /* Read the next journal header from the journal file. If there are
2853 ** not enough bytes left in the journal file for a complete header, or
2854 ** it is corrupted, then a process must have failed while writing it.
2855 ** This indicates nothing more needs to be rolled back.
2857 rc
= readJournalHdr(pPager
, isHot
, szJ
, &nRec
, &mxPg
);
2858 if( rc
!=SQLITE_OK
){
2859 if( rc
==SQLITE_DONE
){
2865 /* If nRec is 0xffffffff, then this journal was created by a process
2866 ** working in no-sync mode. This means that the rest of the journal
2867 ** file consists of pages, there are no more journal headers. Compute
2868 ** the value of nRec based on this assumption.
2870 if( nRec
==0xffffffff ){
2871 assert( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) );
2872 nRec
= (int)((szJ
- JOURNAL_HDR_SZ(pPager
))/JOURNAL_PG_SZ(pPager
));
2875 /* If nRec is 0 and this rollback is of a transaction created by this
2876 ** process and if this is the final header in the journal, then it means
2877 ** that this part of the journal was being filled but has not yet been
2878 ** synced to disk. Compute the number of pages based on the remaining
2879 ** size of the file.
2881 ** The third term of the test was added to fix ticket #2565.
2882 ** When rolling back a hot journal, nRec==0 always means that the next
2883 ** chunk of the journal contains zero pages to be rolled back. But
2884 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2885 ** the journal, it means that the journal might contain additional
2886 ** pages that need to be rolled back and that the number of pages
2887 ** should be computed based on the journal file size.
2889 if( nRec
==0 && !isHot
&&
2890 pPager
->journalHdr
+JOURNAL_HDR_SZ(pPager
)==pPager
->journalOff
){
2891 nRec
= (int)((szJ
- pPager
->journalOff
) / JOURNAL_PG_SZ(pPager
));
2894 /* If this is the first header read from the journal, truncate the
2895 ** database file back to its original size.
2897 if( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) ){
2898 rc
= pager_truncate(pPager
, mxPg
);
2899 if( rc
!=SQLITE_OK
){
2902 pPager
->dbSize
= mxPg
;
2905 /* Copy original pages out of the journal and back into the
2906 ** database file and/or page cache.
2908 for(u
=0; u
<nRec
; u
++){
2909 if( needPagerReset
){
2910 pager_reset(pPager
);
2913 rc
= pager_playback_one_page(pPager
,&pPager
->journalOff
,0,1,0);
2914 if( rc
==SQLITE_OK
){
2917 if( rc
==SQLITE_DONE
){
2918 pPager
->journalOff
= szJ
;
2920 }else if( rc
==SQLITE_IOERR_SHORT_READ
){
2921 /* If the journal has been truncated, simply stop reading and
2922 ** processing the journal. This might happen if the journal was
2923 ** not completely written and synced prior to a crash. In that
2924 ** case, the database should have never been written in the
2925 ** first place so it is OK to simply abandon the rollback. */
2929 /* If we are unable to rollback, quit and return the error
2930 ** code. This will cause the pager to enter the error state
2931 ** so that no further harm will be done. Perhaps the next
2932 ** process to come along will be able to rollback the database.
2943 if( rc
==SQLITE_OK
){
2944 rc
= sqlite3PagerSetPagesize(pPager
, &savedPageSize
, -1);
2946 /* Following a rollback, the database file should be back in its original
2947 ** state prior to the start of the transaction, so invoke the
2948 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
2949 ** assertion that the transaction counter was modified.
2952 sqlite3OsFileControlHint(pPager
->fd
,SQLITE_FCNTL_DB_UNCHANGED
,0);
2955 /* If this playback is happening automatically as a result of an IO or
2956 ** malloc error that occurred after the change-counter was updated but
2957 ** before the transaction was committed, then the change-counter
2958 ** modification may just have been reverted. If this happens in exclusive
2959 ** mode, then subsequent transactions performed by the connection will not
2960 ** update the change-counter at all. This may lead to cache inconsistency
2961 ** problems for other processes at some point in the future. So, just
2962 ** in case this has happened, clear the changeCountDone flag now.
2964 pPager
->changeCountDone
= pPager
->tempFile
;
2966 if( rc
==SQLITE_OK
){
2967 zMaster
= pPager
->pTmpSpace
;
2968 rc
= readMasterJournal(pPager
->jfd
, zMaster
, pPager
->pVfs
->mxPathname
+1);
2969 testcase( rc
!=SQLITE_OK
);
2972 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2974 rc
= sqlite3PagerSync(pPager
, 0);
2976 if( rc
==SQLITE_OK
){
2977 rc
= pager_end_transaction(pPager
, zMaster
[0]!='\0', 0);
2978 testcase( rc
!=SQLITE_OK
);
2980 if( rc
==SQLITE_OK
&& zMaster
[0] && res
){
2981 /* If there was a master journal and this routine will return success,
2982 ** see if it is possible to delete the master journal.
2984 rc
= pager_delmaster(pPager
, zMaster
);
2985 testcase( rc
!=SQLITE_OK
);
2987 if( isHot
&& nPlayback
){
2988 sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK
, "recovered %d pages from %s",
2989 nPlayback
, pPager
->zJournal
);
2992 /* The Pager.sectorSize variable may have been updated while rolling
2993 ** back a journal created by a process with a different sector size
2994 ** value. Reset it to the correct value for this process.
2996 setSectorSize(pPager
);
3002 ** Read the content for page pPg out of the database file (or out of
3003 ** the WAL if that is where the most recent copy if found) into
3004 ** pPg->pData. A shared lock or greater must be held on the database
3005 ** file before this function is called.
3007 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
3008 ** the value read from the database file.
3010 ** If an IO error occurs, then the IO error is returned to the caller.
3011 ** Otherwise, SQLITE_OK is returned.
3013 static int readDbPage(PgHdr
*pPg
){
3014 Pager
*pPager
= pPg
->pPager
; /* Pager object associated with page pPg */
3015 int rc
= SQLITE_OK
; /* Return code */
3017 #ifndef SQLITE_OMIT_WAL
3018 u32 iFrame
= 0; /* Frame of WAL containing pgno */
3020 assert( pPager
->eState
>=PAGER_READER
&& !MEMDB
);
3021 assert( isOpen(pPager
->fd
) );
3023 if( pagerUseWal(pPager
) ){
3024 rc
= sqlite3WalFindFrame(pPager
->pWal
, pPg
->pgno
, &iFrame
);
3028 rc
= sqlite3WalReadFrame(pPager
->pWal
, iFrame
,pPager
->pageSize
,pPg
->pData
);
3032 i64 iOffset
= (pPg
->pgno
-1)*(i64
)pPager
->pageSize
;
3033 rc
= sqlite3OsRead(pPager
->fd
, pPg
->pData
, pPager
->pageSize
, iOffset
);
3034 if( rc
==SQLITE_IOERR_SHORT_READ
){
3041 /* If the read is unsuccessful, set the dbFileVers[] to something
3042 ** that will never be a valid file version. dbFileVers[] is a copy
3043 ** of bytes 24..39 of the database. Bytes 28..31 should always be
3044 ** zero or the size of the database in page. Bytes 32..35 and 35..39
3045 ** should be page numbers which are never 0xffffffff. So filling
3046 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
3048 ** For an encrypted database, the situation is more complex: bytes
3049 ** 24..39 of the database are white noise. But the probability of
3050 ** white noise equaling 16 bytes of 0xff is vanishingly small so
3051 ** we should still be ok.
3053 memset(pPager
->dbFileVers
, 0xff, sizeof(pPager
->dbFileVers
));
3055 u8
*dbFileVers
= &((u8
*)pPg
->pData
)[24];
3056 memcpy(&pPager
->dbFileVers
, dbFileVers
, sizeof(pPager
->dbFileVers
));
3059 CODEC1(pPager
, pPg
->pData
, pPg
->pgno
, 3, rc
= SQLITE_NOMEM_BKPT
);
3061 PAGER_INCR(sqlite3_pager_readdb_count
);
3062 PAGER_INCR(pPager
->nRead
);
3063 IOTRACE(("PGIN %p %d\n", pPager
, pPg
->pgno
));
3064 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
3065 PAGERID(pPager
), pPg
->pgno
, pager_pagehash(pPg
)));
3071 ** Update the value of the change-counter at offsets 24 and 92 in
3072 ** the header and the sqlite version number at offset 96.
3074 ** This is an unconditional update. See also the pager_incr_changecounter()
3075 ** routine which only updates the change-counter if the update is actually
3076 ** needed, as determined by the pPager->changeCountDone state variable.
3078 static void pager_write_changecounter(PgHdr
*pPg
){
3081 /* Increment the value just read and write it back to byte 24. */
3082 change_counter
= sqlite3Get4byte((u8
*)pPg
->pPager
->dbFileVers
)+1;
3083 put32bits(((char*)pPg
->pData
)+24, change_counter
);
3085 /* Also store the SQLite version number in bytes 96..99 and in
3086 ** bytes 92..95 store the change counter for which the version number
3088 put32bits(((char*)pPg
->pData
)+92, change_counter
);
3089 put32bits(((char*)pPg
->pData
)+96, SQLITE_VERSION_NUMBER
);
3092 #ifndef SQLITE_OMIT_WAL
3094 ** This function is invoked once for each page that has already been
3095 ** written into the log file when a WAL transaction is rolled back.
3096 ** Parameter iPg is the page number of said page. The pCtx argument
3097 ** is actually a pointer to the Pager structure.
3099 ** If page iPg is present in the cache, and has no outstanding references,
3100 ** it is discarded. Otherwise, if there are one or more outstanding
3101 ** references, the page content is reloaded from the database. If the
3102 ** attempt to reload content from the database is required and fails,
3103 ** return an SQLite error code. Otherwise, SQLITE_OK.
3105 static int pagerUndoCallback(void *pCtx
, Pgno iPg
){
3107 Pager
*pPager
= (Pager
*)pCtx
;
3110 assert( pagerUseWal(pPager
) );
3111 pPg
= sqlite3PagerLookup(pPager
, iPg
);
3113 if( sqlite3PcachePageRefcount(pPg
)==1 ){
3114 sqlite3PcacheDrop(pPg
);
3116 rc
= readDbPage(pPg
);
3117 if( rc
==SQLITE_OK
){
3118 pPager
->xReiniter(pPg
);
3120 sqlite3PagerUnrefNotNull(pPg
);
3124 /* Normally, if a transaction is rolled back, any backup processes are
3125 ** updated as data is copied out of the rollback journal and into the
3126 ** database. This is not generally possible with a WAL database, as
3127 ** rollback involves simply truncating the log file. Therefore, if one
3128 ** or more frames have already been written to the log (and therefore
3129 ** also copied into the backup databases) as part of this transaction,
3130 ** the backups must be restarted.
3132 sqlite3BackupRestart(pPager
->pBackup
);
3138 ** This function is called to rollback a transaction on a WAL database.
3140 static int pagerRollbackWal(Pager
*pPager
){
3141 int rc
; /* Return Code */
3142 PgHdr
*pList
; /* List of dirty pages to revert */
3144 /* For all pages in the cache that are currently dirty or have already
3145 ** been written (but not committed) to the log file, do one of the
3148 ** + Discard the cached page (if refcount==0), or
3149 ** + Reload page content from the database (if refcount>0).
3151 pPager
->dbSize
= pPager
->dbOrigSize
;
3152 rc
= sqlite3WalUndo(pPager
->pWal
, pagerUndoCallback
, (void *)pPager
);
3153 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
3154 while( pList
&& rc
==SQLITE_OK
){
3155 PgHdr
*pNext
= pList
->pDirty
;
3156 rc
= pagerUndoCallback((void *)pPager
, pList
->pgno
);
3164 ** This function is a wrapper around sqlite3WalFrames(). As well as logging
3165 ** the contents of the list of pages headed by pList (connected by pDirty),
3166 ** this function notifies any active backup processes that the pages have
3169 ** The list of pages passed into this routine is always sorted by page number.
3170 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
3172 static int pagerWalFrames(
3173 Pager
*pPager
, /* Pager object */
3174 PgHdr
*pList
, /* List of frames to log */
3175 Pgno nTruncate
, /* Database size after this commit */
3176 int isCommit
/* True if this is a commit */
3178 int rc
; /* Return code */
3179 int nList
; /* Number of pages in pList */
3180 PgHdr
*p
; /* For looping over pages */
3182 assert( pPager
->pWal
);
3185 /* Verify that the page list is in accending order */
3186 for(p
=pList
; p
&& p
->pDirty
; p
=p
->pDirty
){
3187 assert( p
->pgno
< p
->pDirty
->pgno
);
3191 assert( pList
->pDirty
==0 || isCommit
);
3193 /* If a WAL transaction is being committed, there is no point in writing
3194 ** any pages with page numbers greater than nTruncate into the WAL file.
3195 ** They will never be read by any client. So remove them from the pDirty
3197 PgHdr
**ppNext
= &pList
;
3199 for(p
=pList
; (*ppNext
= p
)!=0; p
=p
->pDirty
){
3200 if( p
->pgno
<=nTruncate
){
3201 ppNext
= &p
->pDirty
;
3209 pPager
->aStat
[PAGER_STAT_WRITE
] += nList
;
3211 if( pList
->pgno
==1 ) pager_write_changecounter(pList
);
3212 rc
= sqlite3WalFrames(pPager
->pWal
,
3213 pPager
->pageSize
, pList
, nTruncate
, isCommit
, pPager
->walSyncFlags
3215 if( rc
==SQLITE_OK
&& pPager
->pBackup
){
3216 for(p
=pList
; p
; p
=p
->pDirty
){
3217 sqlite3BackupUpdate(pPager
->pBackup
, p
->pgno
, (u8
*)p
->pData
);
3221 #ifdef SQLITE_CHECK_PAGES
3222 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
3223 for(p
=pList
; p
; p
=p
->pDirty
){
3224 pager_set_pagehash(p
);
3232 ** Begin a read transaction on the WAL.
3234 ** This routine used to be called "pagerOpenSnapshot()" because it essentially
3235 ** makes a snapshot of the database at the current point in time and preserves
3236 ** that snapshot for use by the reader in spite of concurrently changes by
3237 ** other writers or checkpointers.
3239 static int pagerBeginReadTransaction(Pager
*pPager
){
3240 int rc
; /* Return code */
3241 int changed
= 0; /* True if cache must be reset */
3243 assert( pagerUseWal(pPager
) );
3244 assert( pPager
->eState
==PAGER_OPEN
|| pPager
->eState
==PAGER_READER
);
3246 /* sqlite3WalEndReadTransaction() was not called for the previous
3247 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
3248 ** are in locking_mode=NORMAL and EndRead() was previously called,
3249 ** the duplicate call is harmless.
3251 sqlite3WalEndReadTransaction(pPager
->pWal
);
3253 rc
= sqlite3WalBeginReadTransaction(pPager
->pWal
, &changed
);
3254 if( rc
!=SQLITE_OK
|| changed
){
3255 pager_reset(pPager
);
3256 if( USEFETCH(pPager
) ) sqlite3OsUnfetch(pPager
->fd
, 0, 0);
3264 ** This function is called as part of the transition from PAGER_OPEN
3265 ** to PAGER_READER state to determine the size of the database file
3266 ** in pages (assuming the page size currently stored in Pager.pageSize).
3268 ** If no error occurs, SQLITE_OK is returned and the size of the database
3269 ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
3270 ** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
3272 static int pagerPagecount(Pager
*pPager
, Pgno
*pnPage
){
3273 Pgno nPage
; /* Value to return via *pnPage */
3275 /* Query the WAL sub-system for the database size. The WalDbsize()
3276 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
3277 ** if the database size is not available. The database size is not
3278 ** available from the WAL sub-system if the log file is empty or
3279 ** contains no valid committed transactions.
3281 assert( pPager
->eState
==PAGER_OPEN
);
3282 assert( pPager
->eLock
>=SHARED_LOCK
);
3283 assert( isOpen(pPager
->fd
) );
3284 assert( pPager
->tempFile
==0 );
3285 nPage
= sqlite3WalDbsize(pPager
->pWal
);
3287 /* If the number of pages in the database is not available from the
3288 ** WAL sub-system, determine the page count based on the size of
3289 ** the database file. If the size of the database file is not an
3290 ** integer multiple of the page-size, round up the result.
3292 if( nPage
==0 && ALWAYS(isOpen(pPager
->fd
)) ){
3293 i64 n
= 0; /* Size of db file in bytes */
3294 int rc
= sqlite3OsFileSize(pPager
->fd
, &n
);
3295 if( rc
!=SQLITE_OK
){
3298 nPage
= (Pgno
)((n
+pPager
->pageSize
-1) / pPager
->pageSize
);
3301 /* If the current number of pages in the file is greater than the
3302 ** configured maximum pager number, increase the allowed limit so
3303 ** that the file can be read.
3305 if( nPage
>pPager
->mxPgno
){
3306 pPager
->mxPgno
= (Pgno
)nPage
;
3313 #ifndef SQLITE_OMIT_WAL
3315 ** Check if the *-wal file that corresponds to the database opened by pPager
3316 ** exists if the database is not empy, or verify that the *-wal file does
3317 ** not exist (by deleting it) if the database file is empty.
3319 ** If the database is not empty and the *-wal file exists, open the pager
3320 ** in WAL mode. If the database is empty or if no *-wal file exists and
3321 ** if no error occurs, make sure Pager.journalMode is not set to
3322 ** PAGER_JOURNALMODE_WAL.
3324 ** Return SQLITE_OK or an error code.
3326 ** The caller must hold a SHARED lock on the database file to call this
3327 ** function. Because an EXCLUSIVE lock on the db file is required to delete
3328 ** a WAL on a none-empty database, this ensures there is no race condition
3329 ** between the xAccess() below and an xDelete() being executed by some
3330 ** other connection.
3332 static int pagerOpenWalIfPresent(Pager
*pPager
){
3334 assert( pPager
->eState
==PAGER_OPEN
);
3335 assert( pPager
->eLock
>=SHARED_LOCK
);
3337 if( !pPager
->tempFile
){
3338 int isWal
; /* True if WAL file exists */
3339 rc
= sqlite3OsAccess(
3340 pPager
->pVfs
, pPager
->zWal
, SQLITE_ACCESS_EXISTS
, &isWal
3342 if( rc
==SQLITE_OK
){
3344 Pgno nPage
; /* Size of the database file */
3346 rc
= pagerPagecount(pPager
, &nPage
);
3349 rc
= sqlite3OsDelete(pPager
->pVfs
, pPager
->zWal
, 0);
3351 testcase( sqlite3PcachePagecount(pPager
->pPCache
)==0 );
3352 rc
= sqlite3PagerOpenWal(pPager
, 0);
3354 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_WAL
){
3355 pPager
->journalMode
= PAGER_JOURNALMODE_DELETE
;
3364 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
3365 ** the entire master journal file. The case pSavepoint==NULL occurs when
3366 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
3369 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
3370 ** being rolled back), then the rollback consists of up to three stages,
3371 ** performed in the order specified:
3373 ** * Pages are played back from the main journal starting at byte
3374 ** offset PagerSavepoint.iOffset and continuing to
3375 ** PagerSavepoint.iHdrOffset, or to the end of the main journal
3376 ** file if PagerSavepoint.iHdrOffset is zero.
3378 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
3379 ** back starting from the journal header immediately following
3380 ** PagerSavepoint.iHdrOffset to the end of the main journal file.
3382 ** * Pages are then played back from the sub-journal file, starting
3383 ** with the PagerSavepoint.iSubRec and continuing to the end of
3384 ** the journal file.
3386 ** Throughout the rollback process, each time a page is rolled back, the
3387 ** corresponding bit is set in a bitvec structure (variable pDone in the
3388 ** implementation below). This is used to ensure that a page is only
3389 ** rolled back the first time it is encountered in either journal.
3391 ** If pSavepoint is NULL, then pages are only played back from the main
3392 ** journal file. There is no need for a bitvec in this case.
3394 ** In either case, before playback commences the Pager.dbSize variable
3395 ** is reset to the value that it held at the start of the savepoint
3396 ** (or transaction). No page with a page-number greater than this value
3397 ** is played back. If one is encountered it is simply skipped.
3399 static int pagerPlaybackSavepoint(Pager
*pPager
, PagerSavepoint
*pSavepoint
){
3400 i64 szJ
; /* Effective size of the main journal */
3401 i64 iHdrOff
; /* End of first segment of main-journal records */
3402 int rc
= SQLITE_OK
; /* Return code */
3403 Bitvec
*pDone
= 0; /* Bitvec to ensure pages played back only once */
3405 assert( pPager
->eState
!=PAGER_ERROR
);
3406 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
3408 /* Allocate a bitvec to use to store the set of pages rolled back */
3410 pDone
= sqlite3BitvecCreate(pSavepoint
->nOrig
);
3412 return SQLITE_NOMEM_BKPT
;
3416 /* Set the database size back to the value it was before the savepoint
3417 ** being reverted was opened.
3419 pPager
->dbSize
= pSavepoint
? pSavepoint
->nOrig
: pPager
->dbOrigSize
;
3420 pPager
->changeCountDone
= pPager
->tempFile
;
3422 if( !pSavepoint
&& pagerUseWal(pPager
) ){
3423 return pagerRollbackWal(pPager
);
3426 /* Use pPager->journalOff as the effective size of the main rollback
3427 ** journal. The actual file might be larger than this in
3428 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
3429 ** past pPager->journalOff is off-limits to us.
3431 szJ
= pPager
->journalOff
;
3432 assert( pagerUseWal(pPager
)==0 || szJ
==0 );
3434 /* Begin by rolling back records from the main journal starting at
3435 ** PagerSavepoint.iOffset and continuing to the next journal header.
3436 ** There might be records in the main journal that have a page number
3437 ** greater than the current database size (pPager->dbSize) but those
3438 ** will be skipped automatically. Pages are added to pDone as they
3441 if( pSavepoint
&& !pagerUseWal(pPager
) ){
3442 iHdrOff
= pSavepoint
->iHdrOffset
? pSavepoint
->iHdrOffset
: szJ
;
3443 pPager
->journalOff
= pSavepoint
->iOffset
;
3444 while( rc
==SQLITE_OK
&& pPager
->journalOff
<iHdrOff
){
3445 rc
= pager_playback_one_page(pPager
, &pPager
->journalOff
, pDone
, 1, 1);
3447 assert( rc
!=SQLITE_DONE
);
3449 pPager
->journalOff
= 0;
3452 /* Continue rolling back records out of the main journal starting at
3453 ** the first journal header seen and continuing until the effective end
3454 ** of the main journal file. Continue to skip out-of-range pages and
3455 ** continue adding pages rolled back to pDone.
3457 while( rc
==SQLITE_OK
&& pPager
->journalOff
<szJ
){
3458 u32 ii
; /* Loop counter */
3459 u32 nJRec
= 0; /* Number of Journal Records */
3461 rc
= readJournalHdr(pPager
, 0, szJ
, &nJRec
, &dummy
);
3462 assert( rc
!=SQLITE_DONE
);
3465 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
3466 ** test is related to ticket #2565. See the discussion in the
3467 ** pager_playback() function for additional information.
3470 && pPager
->journalHdr
+JOURNAL_HDR_SZ(pPager
)==pPager
->journalOff
3472 nJRec
= (u32
)((szJ
- pPager
->journalOff
)/JOURNAL_PG_SZ(pPager
));
3474 for(ii
=0; rc
==SQLITE_OK
&& ii
<nJRec
&& pPager
->journalOff
<szJ
; ii
++){
3475 rc
= pager_playback_one_page(pPager
, &pPager
->journalOff
, pDone
, 1, 1);
3477 assert( rc
!=SQLITE_DONE
);
3479 assert( rc
!=SQLITE_OK
|| pPager
->journalOff
>=szJ
);
3481 /* Finally, rollback pages from the sub-journal. Page that were
3482 ** previously rolled back out of the main journal (and are hence in pDone)
3483 ** will be skipped. Out-of-range pages are also skipped.
3486 u32 ii
; /* Loop counter */
3487 i64 offset
= (i64
)pSavepoint
->iSubRec
*(4+pPager
->pageSize
);
3489 if( pagerUseWal(pPager
) ){
3490 rc
= sqlite3WalSavepointUndo(pPager
->pWal
, pSavepoint
->aWalData
);
3492 for(ii
=pSavepoint
->iSubRec
; rc
==SQLITE_OK
&& ii
<pPager
->nSubRec
; ii
++){
3493 assert( offset
==(i64
)ii
*(4+pPager
->pageSize
) );
3494 rc
= pager_playback_one_page(pPager
, &offset
, pDone
, 0, 1);
3496 assert( rc
!=SQLITE_DONE
);
3499 sqlite3BitvecDestroy(pDone
);
3500 if( rc
==SQLITE_OK
){
3501 pPager
->journalOff
= szJ
;
3508 ** Change the maximum number of in-memory pages that are allowed
3509 ** before attempting to recycle clean and unused pages.
3511 void sqlite3PagerSetCachesize(Pager
*pPager
, int mxPage
){
3512 sqlite3PcacheSetCachesize(pPager
->pPCache
, mxPage
);
3516 ** Change the maximum number of in-memory pages that are allowed
3517 ** before attempting to spill pages to journal.
3519 int sqlite3PagerSetSpillsize(Pager
*pPager
, int mxPage
){
3520 return sqlite3PcacheSetSpillsize(pPager
->pPCache
, mxPage
);
3524 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
3526 static void pagerFixMaplimit(Pager
*pPager
){
3527 #if SQLITE_MAX_MMAP_SIZE>0
3528 sqlite3_file
*fd
= pPager
->fd
;
3529 if( isOpen(fd
) && fd
->pMethods
->iVersion
>=3 ){
3531 sz
= pPager
->szMmap
;
3532 pPager
->bUseFetch
= (sz
>0);
3533 setGetterMethod(pPager
);
3534 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_MMAP_SIZE
, &sz
);
3540 ** Change the maximum size of any memory mapping made of the database file.
3542 void sqlite3PagerSetMmapLimit(Pager
*pPager
, sqlite3_int64 szMmap
){
3543 pPager
->szMmap
= szMmap
;
3544 pagerFixMaplimit(pPager
);
3548 ** Free as much memory as possible from the pager.
3550 void sqlite3PagerShrink(Pager
*pPager
){
3551 sqlite3PcacheShrink(pPager
->pPCache
);
3555 ** Adjust settings of the pager to those specified in the pgFlags parameter.
3557 ** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness
3558 ** of the database to damage due to OS crashes or power failures by
3559 ** changing the number of syncs()s when writing the journals.
3560 ** There are four levels:
3562 ** OFF sqlite3OsSync() is never called. This is the default
3563 ** for temporary and transient files.
3565 ** NORMAL The journal is synced once before writes begin on the
3566 ** database. This is normally adequate protection, but
3567 ** it is theoretically possible, though very unlikely,
3568 ** that an inopertune power failure could leave the journal
3569 ** in a state which would cause damage to the database
3570 ** when it is rolled back.
3572 ** FULL The journal is synced twice before writes begin on the
3573 ** database (with some additional information - the nRec field
3574 ** of the journal header - being written in between the two
3575 ** syncs). If we assume that writing a
3576 ** single disk sector is atomic, then this mode provides
3577 ** assurance that the journal will not be corrupted to the
3578 ** point of causing damage to the database during rollback.
3580 ** EXTRA This is like FULL except that is also syncs the directory
3581 ** that contains the rollback journal after the rollback
3582 ** journal is unlinked.
3584 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
3585 ** to mean that no syncs ever occur. NORMAL means that the WAL is synced
3586 ** prior to the start of checkpoint and that the database file is synced
3587 ** at the conclusion of the checkpoint if the entire content of the WAL
3588 ** was written back into the database. But no sync operations occur for
3589 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
3590 ** file is synced following each commit operation, in addition to the
3591 ** syncs associated with NORMAL. There is no difference between FULL
3592 ** and EXTRA for WAL mode.
3594 ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
3595 ** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
3596 ** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
3597 ** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
3598 ** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
3599 ** synchronous=FULL versus synchronous=NORMAL setting determines when
3600 ** the xSync primitive is called and is relevant to all platforms.
3602 ** Numeric values associated with these states are OFF==1, NORMAL=2,
3605 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
3606 void sqlite3PagerSetFlags(
3607 Pager
*pPager
, /* The pager to set safety level for */
3608 unsigned pgFlags
/* Various flags */
3610 unsigned level
= pgFlags
& PAGER_SYNCHRONOUS_MASK
;
3611 if( pPager
->tempFile
){
3613 pPager
->fullSync
= 0;
3614 pPager
->extraSync
= 0;
3616 pPager
->noSync
= level
==PAGER_SYNCHRONOUS_OFF
?1:0;
3617 pPager
->fullSync
= level
>=PAGER_SYNCHRONOUS_FULL
?1:0;
3618 pPager
->extraSync
= level
==PAGER_SYNCHRONOUS_EXTRA
?1:0;
3620 if( pPager
->noSync
){
3621 pPager
->syncFlags
= 0;
3622 }else if( pgFlags
& PAGER_FULLFSYNC
){
3623 pPager
->syncFlags
= SQLITE_SYNC_FULL
;
3625 pPager
->syncFlags
= SQLITE_SYNC_NORMAL
;
3627 pPager
->walSyncFlags
= (pPager
->syncFlags
<<2);
3628 if( pPager
->fullSync
){
3629 pPager
->walSyncFlags
|= pPager
->syncFlags
;
3631 if( (pgFlags
& PAGER_CKPT_FULLFSYNC
) && !pPager
->noSync
){
3632 pPager
->walSyncFlags
|= (SQLITE_SYNC_FULL
<<2);
3634 if( pgFlags
& PAGER_CACHESPILL
){
3635 pPager
->doNotSpill
&= ~SPILLFLAG_OFF
;
3637 pPager
->doNotSpill
|= SPILLFLAG_OFF
;
3643 ** The following global variable is incremented whenever the library
3644 ** attempts to open a temporary file. This information is used for
3645 ** testing and analysis only.
3648 int sqlite3_opentemp_count
= 0;
3652 ** Open a temporary file.
3654 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
3655 ** or some other error code if we fail. The OS will automatically
3656 ** delete the temporary file when it is closed.
3658 ** The flags passed to the VFS layer xOpen() call are those specified
3659 ** by parameter vfsFlags ORed with the following:
3661 ** SQLITE_OPEN_READWRITE
3662 ** SQLITE_OPEN_CREATE
3663 ** SQLITE_OPEN_EXCLUSIVE
3664 ** SQLITE_OPEN_DELETEONCLOSE
3666 static int pagerOpentemp(
3667 Pager
*pPager
, /* The pager object */
3668 sqlite3_file
*pFile
, /* Write the file descriptor here */
3669 int vfsFlags
/* Flags passed through to the VFS */
3671 int rc
; /* Return code */
3674 sqlite3_opentemp_count
++; /* Used for testing and analysis only */
3677 vfsFlags
|= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
|
3678 SQLITE_OPEN_EXCLUSIVE
| SQLITE_OPEN_DELETEONCLOSE
;
3679 rc
= sqlite3OsOpen(pPager
->pVfs
, 0, pFile
, vfsFlags
, 0);
3680 assert( rc
!=SQLITE_OK
|| isOpen(pFile
) );
3685 ** Set the busy handler function.
3687 ** The pager invokes the busy-handler if sqlite3OsLock() returns
3688 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
3689 ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
3690 ** lock. It does *not* invoke the busy handler when upgrading from
3691 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
3692 ** (which occurs during hot-journal rollback). Summary:
3694 ** Transition | Invokes xBusyHandler
3695 ** --------------------------------------------------------
3696 ** NO_LOCK -> SHARED_LOCK | Yes
3697 ** SHARED_LOCK -> RESERVED_LOCK | No
3698 ** SHARED_LOCK -> EXCLUSIVE_LOCK | No
3699 ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
3701 ** If the busy-handler callback returns non-zero, the lock is
3702 ** retried. If it returns zero, then the SQLITE_BUSY error is
3703 ** returned to the caller of the pager API function.
3705 void sqlite3PagerSetBusyHandler(
3706 Pager
*pPager
, /* Pager object */
3707 int (*xBusyHandler
)(void *), /* Pointer to busy-handler function */
3708 void *pBusyHandlerArg
/* Argument to pass to xBusyHandler */
3711 pPager
->xBusyHandler
= xBusyHandler
;
3712 pPager
->pBusyHandlerArg
= pBusyHandlerArg
;
3713 ap
= (void **)&pPager
->xBusyHandler
;
3714 assert( ((int(*)(void *))(ap
[0]))==xBusyHandler
);
3715 assert( ap
[1]==pBusyHandlerArg
);
3716 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_BUSYHANDLER
, (void *)ap
);
3720 ** Change the page size used by the Pager object. The new page size
3721 ** is passed in *pPageSize.
3723 ** If the pager is in the error state when this function is called, it
3724 ** is a no-op. The value returned is the error state error code (i.e.
3725 ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
3727 ** Otherwise, if all of the following are true:
3729 ** * the new page size (value of *pPageSize) is valid (a power
3730 ** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
3732 ** * there are no outstanding page references, and
3734 ** * the database is either not an in-memory database or it is
3735 ** an in-memory database that currently consists of zero pages.
3737 ** then the pager object page size is set to *pPageSize.
3739 ** If the page size is changed, then this function uses sqlite3PagerMalloc()
3740 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
3741 ** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
3742 ** In all other cases, SQLITE_OK is returned.
3744 ** If the page size is not changed, either because one of the enumerated
3745 ** conditions above is not true, the pager was in error state when this
3746 ** function was called, or because the memory allocation attempt failed,
3747 ** then *pPageSize is set to the old, retained page size before returning.
3749 int sqlite3PagerSetPagesize(Pager
*pPager
, u32
*pPageSize
, int nReserve
){
3752 /* It is not possible to do a full assert_pager_state() here, as this
3753 ** function may be called from within PagerOpen(), before the state
3754 ** of the Pager object is internally consistent.
3756 ** At one point this function returned an error if the pager was in
3757 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
3758 ** there is at least one outstanding page reference, this function
3759 ** is a no-op for that case anyhow.
3762 u32 pageSize
= *pPageSize
;
3763 assert( pageSize
==0 || (pageSize
>=512 && pageSize
<=SQLITE_MAX_PAGE_SIZE
) );
3764 if( (pPager
->memDb
==0 || pPager
->dbSize
==0)
3765 && sqlite3PcacheRefCount(pPager
->pPCache
)==0
3766 && pageSize
&& pageSize
!=(u32
)pPager
->pageSize
3768 char *pNew
= NULL
; /* New temp space */
3771 if( pPager
->eState
>PAGER_OPEN
&& isOpen(pPager
->fd
) ){
3772 rc
= sqlite3OsFileSize(pPager
->fd
, &nByte
);
3774 if( rc
==SQLITE_OK
){
3775 pNew
= (char *)sqlite3PageMalloc(pageSize
);
3776 if( !pNew
) rc
= SQLITE_NOMEM_BKPT
;
3779 if( rc
==SQLITE_OK
){
3780 pager_reset(pPager
);
3781 rc
= sqlite3PcacheSetPageSize(pPager
->pPCache
, pageSize
);
3783 if( rc
==SQLITE_OK
){
3784 sqlite3PageFree(pPager
->pTmpSpace
);
3785 pPager
->pTmpSpace
= pNew
;
3786 pPager
->dbSize
= (Pgno
)((nByte
+pageSize
-1)/pageSize
);
3787 pPager
->pageSize
= pageSize
;
3789 sqlite3PageFree(pNew
);
3793 *pPageSize
= pPager
->pageSize
;
3794 if( rc
==SQLITE_OK
){
3795 if( nReserve
<0 ) nReserve
= pPager
->nReserve
;
3796 assert( nReserve
>=0 && nReserve
<1000 );
3797 pPager
->nReserve
= (i16
)nReserve
;
3798 pagerReportSize(pPager
);
3799 pagerFixMaplimit(pPager
);
3805 ** Return a pointer to the "temporary page" buffer held internally
3806 ** by the pager. This is a buffer that is big enough to hold the
3807 ** entire content of a database page. This buffer is used internally
3808 ** during rollback and will be overwritten whenever a rollback
3809 ** occurs. But other modules are free to use it too, as long as
3810 ** no rollbacks are happening.
3812 void *sqlite3PagerTempSpace(Pager
*pPager
){
3813 return pPager
->pTmpSpace
;
3817 ** Attempt to set the maximum database page count if mxPage is positive.
3818 ** Make no changes if mxPage is zero or negative. And never reduce the
3819 ** maximum page count below the current size of the database.
3821 ** Regardless of mxPage, return the current maximum page count.
3823 int sqlite3PagerMaxPageCount(Pager
*pPager
, int mxPage
){
3825 pPager
->mxPgno
= mxPage
;
3827 assert( pPager
->eState
!=PAGER_OPEN
); /* Called only by OP_MaxPgcnt */
3828 assert( pPager
->mxPgno
>=pPager
->dbSize
); /* OP_MaxPgcnt enforces this */
3829 return pPager
->mxPgno
;
3833 ** The following set of routines are used to disable the simulated
3834 ** I/O error mechanism. These routines are used to avoid simulated
3835 ** errors in places where we do not care about errors.
3837 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
3838 ** and generate no code.
3841 extern int sqlite3_io_error_pending
;
3842 extern int sqlite3_io_error_hit
;
3843 static int saved_cnt
;
3844 void disable_simulated_io_errors(void){
3845 saved_cnt
= sqlite3_io_error_pending
;
3846 sqlite3_io_error_pending
= -1;
3848 void enable_simulated_io_errors(void){
3849 sqlite3_io_error_pending
= saved_cnt
;
3852 # define disable_simulated_io_errors()
3853 # define enable_simulated_io_errors()
3857 ** Read the first N bytes from the beginning of the file into memory
3858 ** that pDest points to.
3860 ** If the pager was opened on a transient file (zFilename==""), or
3861 ** opened on a file less than N bytes in size, the output buffer is
3862 ** zeroed and SQLITE_OK returned. The rationale for this is that this
3863 ** function is used to read database headers, and a new transient or
3864 ** zero sized database has a header than consists entirely of zeroes.
3866 ** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
3867 ** the error code is returned to the caller and the contents of the
3868 ** output buffer undefined.
3870 int sqlite3PagerReadFileheader(Pager
*pPager
, int N
, unsigned char *pDest
){
3872 memset(pDest
, 0, N
);
3873 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
3875 /* This routine is only called by btree immediately after creating
3876 ** the Pager object. There has not been an opportunity to transition
3879 assert( !pagerUseWal(pPager
) );
3881 if( isOpen(pPager
->fd
) ){
3882 IOTRACE(("DBHDR %p 0 %d\n", pPager
, N
))
3883 rc
= sqlite3OsRead(pPager
->fd
, pDest
, N
, 0);
3884 if( rc
==SQLITE_IOERR_SHORT_READ
){
3892 ** This function may only be called when a read-transaction is open on
3893 ** the pager. It returns the total number of pages in the database.
3895 ** However, if the file is between 1 and <page-size> bytes in size, then
3896 ** this is considered a 1 page file.
3898 void sqlite3PagerPagecount(Pager
*pPager
, int *pnPage
){
3899 assert( pPager
->eState
>=PAGER_READER
);
3900 assert( pPager
->eState
!=PAGER_WRITER_FINISHED
);
3901 *pnPage
= (int)pPager
->dbSize
;
3906 ** Try to obtain a lock of type locktype on the database file. If
3907 ** a similar or greater lock is already held, this function is a no-op
3908 ** (returning SQLITE_OK immediately).
3910 ** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
3911 ** the busy callback if the lock is currently not available. Repeat
3912 ** until the busy callback returns false or until the attempt to
3913 ** obtain the lock succeeds.
3915 ** Return SQLITE_OK on success and an error code if we cannot obtain
3916 ** the lock. If the lock is obtained successfully, set the Pager.state
3917 ** variable to locktype before returning.
3919 static int pager_wait_on_lock(Pager
*pPager
, int locktype
){
3920 int rc
; /* Return code */
3922 /* Check that this is either a no-op (because the requested lock is
3923 ** already held), or one of the transitions that the busy-handler
3924 ** may be invoked during, according to the comment above
3925 ** sqlite3PagerSetBusyhandler().
3927 assert( (pPager
->eLock
>=locktype
)
3928 || (pPager
->eLock
==NO_LOCK
&& locktype
==SHARED_LOCK
)
3929 || (pPager
->eLock
==RESERVED_LOCK
&& locktype
==EXCLUSIVE_LOCK
)
3933 rc
= pagerLockDb(pPager
, locktype
);
3934 }while( rc
==SQLITE_BUSY
&& pPager
->xBusyHandler(pPager
->pBusyHandlerArg
) );
3939 ** Function assertTruncateConstraint(pPager) checks that one of the
3940 ** following is true for all dirty pages currently in the page-cache:
3942 ** a) The page number is less than or equal to the size of the
3943 ** current database image, in pages, OR
3945 ** b) if the page content were written at this time, it would not
3946 ** be necessary to write the current content out to the sub-journal
3947 ** (as determined by function subjRequiresPage()).
3949 ** If the condition asserted by this function were not true, and the
3950 ** dirty page were to be discarded from the cache via the pagerStress()
3951 ** routine, pagerStress() would not write the current page content to
3952 ** the database file. If a savepoint transaction were rolled back after
3953 ** this happened, the correct behavior would be to restore the current
3954 ** content of the page. However, since this content is not present in either
3955 ** the database file or the portion of the rollback journal and
3956 ** sub-journal rolled back the content could not be restored and the
3957 ** database image would become corrupt. It is therefore fortunate that
3958 ** this circumstance cannot arise.
3960 #if defined(SQLITE_DEBUG)
3961 static void assertTruncateConstraintCb(PgHdr
*pPg
){
3962 assert( pPg
->flags
&PGHDR_DIRTY
);
3963 assert( !subjRequiresPage(pPg
) || pPg
->pgno
<=pPg
->pPager
->dbSize
);
3965 static void assertTruncateConstraint(Pager
*pPager
){
3966 sqlite3PcacheIterateDirty(pPager
->pPCache
, assertTruncateConstraintCb
);
3969 # define assertTruncateConstraint(pPager)
3973 ** Truncate the in-memory database file image to nPage pages. This
3974 ** function does not actually modify the database file on disk. It
3975 ** just sets the internal state of the pager object so that the
3976 ** truncation will be done when the current transaction is committed.
3978 ** This function is only called right before committing a transaction.
3979 ** Once this function has been called, the transaction must either be
3980 ** rolled back or committed. It is not safe to call this function and
3981 ** then continue writing to the database.
3983 void sqlite3PagerTruncateImage(Pager
*pPager
, Pgno nPage
){
3984 assert( pPager
->dbSize
>=nPage
);
3985 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
);
3986 pPager
->dbSize
= nPage
;
3988 /* At one point the code here called assertTruncateConstraint() to
3989 ** ensure that all pages being truncated away by this operation are,
3990 ** if one or more savepoints are open, present in the savepoint
3991 ** journal so that they can be restored if the savepoint is rolled
3992 ** back. This is no longer necessary as this function is now only
3993 ** called right before committing a transaction. So although the
3994 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
3995 ** they cannot be rolled back. So the assertTruncateConstraint() call
3996 ** is no longer correct. */
4001 ** This function is called before attempting a hot-journal rollback. It
4002 ** syncs the journal file to disk, then sets pPager->journalHdr to the
4003 ** size of the journal file so that the pager_playback() routine knows
4004 ** that the entire journal file has been synced.
4006 ** Syncing a hot-journal to disk before attempting to roll it back ensures
4007 ** that if a power-failure occurs during the rollback, the process that
4008 ** attempts rollback following system recovery sees the same journal
4009 ** content as this process.
4011 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
4012 ** an SQLite error code.
4014 static int pagerSyncHotJournal(Pager
*pPager
){
4016 if( !pPager
->noSync
){
4017 rc
= sqlite3OsSync(pPager
->jfd
, SQLITE_SYNC_NORMAL
);
4019 if( rc
==SQLITE_OK
){
4020 rc
= sqlite3OsFileSize(pPager
->jfd
, &pPager
->journalHdr
);
4025 #if SQLITE_MAX_MMAP_SIZE>0
4027 ** Obtain a reference to a memory mapped page object for page number pgno.
4028 ** The new object will use the pointer pData, obtained from xFetch().
4029 ** If successful, set *ppPage to point to the new page reference
4030 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
4033 ** Page references obtained by calling this function should be released
4034 ** by calling pagerReleaseMapPage().
4036 static int pagerAcquireMapPage(
4037 Pager
*pPager
, /* Pager object */
4038 Pgno pgno
, /* Page number */
4039 void *pData
, /* xFetch()'d data for this page */
4040 PgHdr
**ppPage
/* OUT: Acquired page object */
4042 PgHdr
*p
; /* Memory mapped page to return */
4044 if( pPager
->pMmapFreelist
){
4045 *ppPage
= p
= pPager
->pMmapFreelist
;
4046 pPager
->pMmapFreelist
= p
->pDirty
;
4048 assert( pPager
->nExtra
>=8 );
4049 memset(p
->pExtra
, 0, 8);
4051 *ppPage
= p
= (PgHdr
*)sqlite3MallocZero(sizeof(PgHdr
) + pPager
->nExtra
);
4053 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pgno
-1) * pPager
->pageSize
, pData
);
4054 return SQLITE_NOMEM_BKPT
;
4056 p
->pExtra
= (void *)&p
[1];
4057 p
->flags
= PGHDR_MMAP
;
4062 assert( p
->pExtra
==(void *)&p
[1] );
4063 assert( p
->pPage
==0 );
4064 assert( p
->flags
==PGHDR_MMAP
);
4065 assert( p
->pPager
==pPager
);
4066 assert( p
->nRef
==1 );
4077 ** Release a reference to page pPg. pPg must have been returned by an
4078 ** earlier call to pagerAcquireMapPage().
4080 static void pagerReleaseMapPage(PgHdr
*pPg
){
4081 Pager
*pPager
= pPg
->pPager
;
4083 pPg
->pDirty
= pPager
->pMmapFreelist
;
4084 pPager
->pMmapFreelist
= pPg
;
4086 assert( pPager
->fd
->pMethods
->iVersion
>=3 );
4087 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pPg
->pgno
-1)*pPager
->pageSize
, pPg
->pData
);
4091 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
4093 static void pagerFreeMapHdrs(Pager
*pPager
){
4096 for(p
=pPager
->pMmapFreelist
; p
; p
=pNext
){
4102 /* Verify that the database file has not be deleted or renamed out from
4103 ** under the pager. Return SQLITE_OK if the database is still where it ought
4104 ** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
4105 ** code from sqlite3OsAccess()) if the database has gone missing.
4107 static int databaseIsUnmoved(Pager
*pPager
){
4111 if( pPager
->tempFile
) return SQLITE_OK
;
4112 if( pPager
->dbSize
==0 ) return SQLITE_OK
;
4113 assert( pPager
->zFilename
&& pPager
->zFilename
[0] );
4114 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_HAS_MOVED
, &bHasMoved
);
4115 if( rc
==SQLITE_NOTFOUND
){
4116 /* If the HAS_MOVED file-control is unimplemented, assume that the file
4117 ** has not been moved. That is the historical behavior of SQLite: prior to
4118 ** version 3.8.3, it never checked */
4120 }else if( rc
==SQLITE_OK
&& bHasMoved
){
4121 rc
= SQLITE_READONLY_DBMOVED
;
4128 ** Shutdown the page cache. Free all memory and close all files.
4130 ** If a transaction was in progress when this routine is called, that
4131 ** transaction is rolled back. All outstanding pages are invalidated
4132 ** and their memory is freed. Any attempt to use a page associated
4133 ** with this page cache after this function returns will likely
4134 ** result in a coredump.
4136 ** This function always succeeds. If a transaction is active an attempt
4137 ** is made to roll it back. If an error occurs during the rollback
4138 ** a hot journal may be left in the filesystem but no error is returned
4141 int sqlite3PagerClose(Pager
*pPager
, sqlite3
*db
){
4142 u8
*pTmp
= (u8
*)pPager
->pTmpSpace
;
4143 assert( db
|| pagerUseWal(pPager
)==0 );
4144 assert( assert_pager_state(pPager
) );
4145 disable_simulated_io_errors();
4146 sqlite3BeginBenignMalloc();
4147 pagerFreeMapHdrs(pPager
);
4148 /* pPager->errCode = 0; */
4149 pPager
->exclusiveMode
= 0;
4150 #ifndef SQLITE_OMIT_WAL
4153 assert( db
|| pPager
->pWal
==0 );
4154 if( db
&& 0==(db
->flags
& SQLITE_NoCkptOnClose
)
4155 && SQLITE_OK
==databaseIsUnmoved(pPager
)
4159 sqlite3WalClose(pPager
->pWal
, db
, pPager
->walSyncFlags
, pPager
->pageSize
,a
);
4163 pager_reset(pPager
);
4165 pager_unlock(pPager
);
4167 /* If it is open, sync the journal file before calling UnlockAndRollback.
4168 ** If this is not done, then an unsynced portion of the open journal
4169 ** file may be played back into the database. If a power failure occurs
4170 ** while this is happening, the database could become corrupt.
4172 ** If an error occurs while trying to sync the journal, shift the pager
4173 ** into the ERROR state. This causes UnlockAndRollback to unlock the
4174 ** database and close the journal file without attempting to roll it
4175 ** back or finalize it. The next database user will have to do hot-journal
4176 ** rollback before accessing the database file.
4178 if( isOpen(pPager
->jfd
) ){
4179 pager_error(pPager
, pagerSyncHotJournal(pPager
));
4181 pagerUnlockAndRollback(pPager
);
4183 sqlite3EndBenignMalloc();
4184 enable_simulated_io_errors();
4185 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager
)));
4186 IOTRACE(("CLOSE %p\n", pPager
))
4187 sqlite3OsClose(pPager
->jfd
);
4188 sqlite3OsClose(pPager
->fd
);
4189 sqlite3PageFree(pTmp
);
4190 sqlite3PcacheClose(pPager
->pPCache
);
4192 #ifdef SQLITE_HAS_CODEC
4193 if( pPager
->xCodecFree
) pPager
->xCodecFree(pPager
->pCodec
);
4196 assert( !pPager
->aSavepoint
&& !pPager
->pInJournal
);
4197 assert( !isOpen(pPager
->jfd
) && !isOpen(pPager
->sjfd
) );
4199 sqlite3_free(pPager
);
4203 #if !defined(NDEBUG) || defined(SQLITE_TEST)
4205 ** Return the page number for page pPg.
4207 Pgno
sqlite3PagerPagenumber(DbPage
*pPg
){
4213 ** Increment the reference count for page pPg.
4215 void sqlite3PagerRef(DbPage
*pPg
){
4216 sqlite3PcacheRef(pPg
);
4220 ** Sync the journal. In other words, make sure all the pages that have
4221 ** been written to the journal have actually reached the surface of the
4222 ** disk and can be restored in the event of a hot-journal rollback.
4224 ** If the Pager.noSync flag is set, then this function is a no-op.
4225 ** Otherwise, the actions required depend on the journal-mode and the
4226 ** device characteristics of the file-system, as follows:
4228 ** * If the journal file is an in-memory journal file, no action need
4231 ** * Otherwise, if the device does not support the SAFE_APPEND property,
4232 ** then the nRec field of the most recently written journal header
4233 ** is updated to contain the number of journal records that have
4234 ** been written following it. If the pager is operating in full-sync
4235 ** mode, then the journal file is synced before this field is updated.
4237 ** * If the device does not support the SEQUENTIAL property, then
4238 ** journal file is synced.
4240 ** Or, in pseudo-code:
4242 ** if( NOT <in-memory journal> ){
4243 ** if( NOT SAFE_APPEND ){
4244 ** if( <full-sync mode> ) xSync(<journal file>);
4245 ** <update nRec field>
4247 ** if( NOT SEQUENTIAL ) xSync(<journal file>);
4250 ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
4251 ** page currently held in memory before returning SQLITE_OK. If an IO
4252 ** error is encountered, then the IO error code is returned to the caller.
4254 static int syncJournal(Pager
*pPager
, int newHdr
){
4255 int rc
; /* Return code */
4257 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
4258 || pPager
->eState
==PAGER_WRITER_DBMOD
4260 assert( assert_pager_state(pPager
) );
4261 assert( !pagerUseWal(pPager
) );
4263 rc
= sqlite3PagerExclusiveLock(pPager
);
4264 if( rc
!=SQLITE_OK
) return rc
;
4266 if( !pPager
->noSync
){
4267 assert( !pPager
->tempFile
);
4268 if( isOpen(pPager
->jfd
) && pPager
->journalMode
!=PAGER_JOURNALMODE_MEMORY
){
4269 const int iDc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
4270 assert( isOpen(pPager
->jfd
) );
4272 if( 0==(iDc
&SQLITE_IOCAP_SAFE_APPEND
) ){
4273 /* This block deals with an obscure problem. If the last connection
4274 ** that wrote to this database was operating in persistent-journal
4275 ** mode, then the journal file may at this point actually be larger
4276 ** than Pager.journalOff bytes. If the next thing in the journal
4277 ** file happens to be a journal-header (written as part of the
4278 ** previous connection's transaction), and a crash or power-failure
4279 ** occurs after nRec is updated but before this connection writes
4280 ** anything else to the journal file (or commits/rolls back its
4281 ** transaction), then SQLite may become confused when doing the
4282 ** hot-journal rollback following recovery. It may roll back all
4283 ** of this connections data, then proceed to rolling back the old,
4284 ** out-of-date data that follows it. Database corruption.
4286 ** To work around this, if the journal file does appear to contain
4287 ** a valid header following Pager.journalOff, then write a 0x00
4288 ** byte to the start of it to prevent it from being recognized.
4290 ** Variable iNextHdrOffset is set to the offset at which this
4291 ** problematic header will occur, if it exists. aMagic is used
4292 ** as a temporary buffer to inspect the first couple of bytes of
4293 ** the potential journal header.
4297 u8 zHeader
[sizeof(aJournalMagic
)+4];
4299 memcpy(zHeader
, aJournalMagic
, sizeof(aJournalMagic
));
4300 put32bits(&zHeader
[sizeof(aJournalMagic
)], pPager
->nRec
);
4302 iNextHdrOffset
= journalHdrOffset(pPager
);
4303 rc
= sqlite3OsRead(pPager
->jfd
, aMagic
, 8, iNextHdrOffset
);
4304 if( rc
==SQLITE_OK
&& 0==memcmp(aMagic
, aJournalMagic
, 8) ){
4305 static const u8 zerobyte
= 0;
4306 rc
= sqlite3OsWrite(pPager
->jfd
, &zerobyte
, 1, iNextHdrOffset
);
4308 if( rc
!=SQLITE_OK
&& rc
!=SQLITE_IOERR_SHORT_READ
){
4312 /* Write the nRec value into the journal file header. If in
4313 ** full-synchronous mode, sync the journal first. This ensures that
4314 ** all data has really hit the disk before nRec is updated to mark
4315 ** it as a candidate for rollback.
4317 ** This is not required if the persistent media supports the
4318 ** SAFE_APPEND property. Because in this case it is not possible
4319 ** for garbage data to be appended to the file, the nRec field
4320 ** is populated with 0xFFFFFFFF when the journal header is written
4321 ** and never needs to be updated.
4323 if( pPager
->fullSync
&& 0==(iDc
&SQLITE_IOCAP_SEQUENTIAL
) ){
4324 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager
)));
4325 IOTRACE(("JSYNC %p\n", pPager
))
4326 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
);
4327 if( rc
!=SQLITE_OK
) return rc
;
4329 IOTRACE(("JHDR %p %lld\n", pPager
, pPager
->journalHdr
));
4330 rc
= sqlite3OsWrite(
4331 pPager
->jfd
, zHeader
, sizeof(zHeader
), pPager
->journalHdr
4333 if( rc
!=SQLITE_OK
) return rc
;
4335 if( 0==(iDc
&SQLITE_IOCAP_SEQUENTIAL
) ){
4336 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager
)));
4337 IOTRACE(("JSYNC %p\n", pPager
))
4338 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
|
4339 (pPager
->syncFlags
==SQLITE_SYNC_FULL
?SQLITE_SYNC_DATAONLY
:0)
4341 if( rc
!=SQLITE_OK
) return rc
;
4344 pPager
->journalHdr
= pPager
->journalOff
;
4345 if( newHdr
&& 0==(iDc
&SQLITE_IOCAP_SAFE_APPEND
) ){
4347 rc
= writeJournalHdr(pPager
);
4348 if( rc
!=SQLITE_OK
) return rc
;
4351 pPager
->journalHdr
= pPager
->journalOff
;
4355 /* Unless the pager is in noSync mode, the journal file was just
4356 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
4359 sqlite3PcacheClearSyncFlags(pPager
->pPCache
);
4360 pPager
->eState
= PAGER_WRITER_DBMOD
;
4361 assert( assert_pager_state(pPager
) );
4366 ** The argument is the first in a linked list of dirty pages connected
4367 ** by the PgHdr.pDirty pointer. This function writes each one of the
4368 ** in-memory pages in the list to the database file. The argument may
4369 ** be NULL, representing an empty list. In this case this function is
4372 ** The pager must hold at least a RESERVED lock when this function
4373 ** is called. Before writing anything to the database file, this lock
4374 ** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
4375 ** SQLITE_BUSY is returned and no data is written to the database file.
4377 ** If the pager is a temp-file pager and the actual file-system file
4378 ** is not yet open, it is created and opened before any data is
4381 ** Once the lock has been upgraded and, if necessary, the file opened,
4382 ** the pages are written out to the database file in list order. Writing
4383 ** a page is skipped if it meets either of the following criteria:
4385 ** * The page number is greater than Pager.dbSize, or
4386 ** * The PGHDR_DONT_WRITE flag is set on the page.
4388 ** If writing out a page causes the database file to grow, Pager.dbFileSize
4389 ** is updated accordingly. If page 1 is written out, then the value cached
4390 ** in Pager.dbFileVers[] is updated to match the new value stored in
4391 ** the database file.
4393 ** If everything is successful, SQLITE_OK is returned. If an IO error
4394 ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
4395 ** be obtained, SQLITE_BUSY is returned.
4397 static int pager_write_pagelist(Pager
*pPager
, PgHdr
*pList
){
4398 int rc
= SQLITE_OK
; /* Return code */
4400 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
4401 assert( !pagerUseWal(pPager
) );
4402 assert( pPager
->tempFile
|| pPager
->eState
==PAGER_WRITER_DBMOD
);
4403 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
4404 assert( isOpen(pPager
->fd
) || pList
->pDirty
==0 );
4406 /* If the file is a temp-file has not yet been opened, open it now. It
4407 ** is not possible for rc to be other than SQLITE_OK if this branch
4408 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
4410 if( !isOpen(pPager
->fd
) ){
4411 assert( pPager
->tempFile
&& rc
==SQLITE_OK
);
4412 rc
= pagerOpentemp(pPager
, pPager
->fd
, pPager
->vfsFlags
);
4415 /* Before the first write, give the VFS a hint of what the final
4416 ** file size will be.
4418 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->fd
) );
4420 && pPager
->dbHintSize
<pPager
->dbSize
4421 && (pList
->pDirty
|| pList
->pgno
>pPager
->dbHintSize
)
4423 sqlite3_int64 szFile
= pPager
->pageSize
* (sqlite3_int64
)pPager
->dbSize
;
4424 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_SIZE_HINT
, &szFile
);
4425 pPager
->dbHintSize
= pPager
->dbSize
;
4428 while( rc
==SQLITE_OK
&& pList
){
4429 Pgno pgno
= pList
->pgno
;
4431 /* If there are dirty pages in the page cache with page numbers greater
4432 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
4433 ** make the file smaller (presumably by auto-vacuum code). Do not write
4434 ** any such pages to the file.
4436 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
4437 ** set (set by sqlite3PagerDontWrite()).
4439 if( pgno
<=pPager
->dbSize
&& 0==(pList
->flags
&PGHDR_DONT_WRITE
) ){
4440 i64 offset
= (pgno
-1)*(i64
)pPager
->pageSize
; /* Offset to write */
4441 char *pData
; /* Data to write */
4443 assert( (pList
->flags
&PGHDR_NEED_SYNC
)==0 );
4444 if( pList
->pgno
==1 ) pager_write_changecounter(pList
);
4446 /* Encode the database */
4447 CODEC2(pPager
, pList
->pData
, pgno
, 6, return SQLITE_NOMEM_BKPT
, pData
);
4449 /* Write out the page data. */
4450 rc
= sqlite3OsWrite(pPager
->fd
, pData
, pPager
->pageSize
, offset
);
4452 /* If page 1 was just written, update Pager.dbFileVers to match
4453 ** the value now stored in the database file. If writing this
4454 ** page caused the database file to grow, update dbFileSize.
4457 memcpy(&pPager
->dbFileVers
, &pData
[24], sizeof(pPager
->dbFileVers
));
4459 if( pgno
>pPager
->dbFileSize
){
4460 pPager
->dbFileSize
= pgno
;
4462 pPager
->aStat
[PAGER_STAT_WRITE
]++;
4464 /* Update any backup objects copying the contents of this pager. */
4465 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)pList
->pData
);
4467 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
4468 PAGERID(pPager
), pgno
, pager_pagehash(pList
)));
4469 IOTRACE(("PGOUT %p %d\n", pPager
, pgno
));
4470 PAGER_INCR(sqlite3_pager_writedb_count
);
4472 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager
), pgno
));
4474 pager_set_pagehash(pList
);
4475 pList
= pList
->pDirty
;
4482 ** Ensure that the sub-journal file is open. If it is already open, this
4483 ** function is a no-op.
4485 ** SQLITE_OK is returned if everything goes according to plan. An
4486 ** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
4489 static int openSubJournal(Pager
*pPager
){
4491 if( !isOpen(pPager
->sjfd
) ){
4492 const int flags
= SQLITE_OPEN_SUBJOURNAL
| SQLITE_OPEN_READWRITE
4493 | SQLITE_OPEN_CREATE
| SQLITE_OPEN_EXCLUSIVE
4494 | SQLITE_OPEN_DELETEONCLOSE
;
4495 int nStmtSpill
= sqlite3Config
.nStmtSpill
;
4496 if( pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
|| pPager
->subjInMemory
){
4499 rc
= sqlite3JournalOpen(pPager
->pVfs
, 0, pPager
->sjfd
, flags
, nStmtSpill
);
4505 ** Append a record of the current state of page pPg to the sub-journal.
4507 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
4508 ** for all open savepoints before returning.
4510 ** This function returns SQLITE_OK if everything is successful, an IO
4511 ** error code if the attempt to write to the sub-journal fails, or
4512 ** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
4515 static int subjournalPage(PgHdr
*pPg
){
4517 Pager
*pPager
= pPg
->pPager
;
4518 if( pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
4520 /* Open the sub-journal, if it has not already been opened */
4521 assert( pPager
->useJournal
);
4522 assert( isOpen(pPager
->jfd
) || pagerUseWal(pPager
) );
4523 assert( isOpen(pPager
->sjfd
) || pPager
->nSubRec
==0 );
4524 assert( pagerUseWal(pPager
)
4525 || pageInJournal(pPager
, pPg
)
4526 || pPg
->pgno
>pPager
->dbOrigSize
4528 rc
= openSubJournal(pPager
);
4530 /* If the sub-journal was opened successfully (or was already open),
4531 ** write the journal record into the file. */
4532 if( rc
==SQLITE_OK
){
4533 void *pData
= pPg
->pData
;
4534 i64 offset
= (i64
)pPager
->nSubRec
*(4+pPager
->pageSize
);
4537 #if SQLITE_HAS_CODEC
4538 if( !pPager
->subjInMemory
){
4539 CODEC2(pPager
, pData
, pPg
->pgno
, 7, return SQLITE_NOMEM_BKPT
, pData2
);
4543 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager
), pPg
->pgno
));
4544 rc
= write32bits(pPager
->sjfd
, offset
, pPg
->pgno
);
4545 if( rc
==SQLITE_OK
){
4546 rc
= sqlite3OsWrite(pPager
->sjfd
, pData2
, pPager
->pageSize
, offset
+4);
4550 if( rc
==SQLITE_OK
){
4552 assert( pPager
->nSavepoint
>0 );
4553 rc
= addToSavepointBitvecs(pPager
, pPg
->pgno
);
4557 static int subjournalPageIfRequired(PgHdr
*pPg
){
4558 if( subjRequiresPage(pPg
) ){
4559 return subjournalPage(pPg
);
4566 ** This function is called by the pcache layer when it has reached some
4567 ** soft memory limit. The first argument is a pointer to a Pager object
4568 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
4569 ** database). The second argument is a reference to a page that is
4570 ** currently dirty but has no outstanding references. The page
4571 ** is always associated with the Pager object passed as the first
4574 ** The job of this function is to make pPg clean by writing its contents
4575 ** out to the database file, if possible. This may involve syncing the
4578 ** If successful, sqlite3PcacheMakeClean() is called on the page and
4579 ** SQLITE_OK returned. If an IO error occurs while trying to make the
4580 ** page clean, the IO error code is returned. If the page cannot be
4581 ** made clean for some other reason, but no error occurs, then SQLITE_OK
4582 ** is returned by sqlite3PcacheMakeClean() is not called.
4584 static int pagerStress(void *p
, PgHdr
*pPg
){
4585 Pager
*pPager
= (Pager
*)p
;
4588 assert( pPg
->pPager
==pPager
);
4589 assert( pPg
->flags
&PGHDR_DIRTY
);
4591 /* The doNotSpill NOSYNC bit is set during times when doing a sync of
4592 ** journal (and adding a new header) is not allowed. This occurs
4593 ** during calls to sqlite3PagerWrite() while trying to journal multiple
4594 ** pages belonging to the same sector.
4596 ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
4597 ** regardless of whether or not a sync is required. This is set during
4598 ** a rollback or by user request, respectively.
4600 ** Spilling is also prohibited when in an error state since that could
4601 ** lead to database corruption. In the current implementation it
4602 ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
4603 ** while in the error state, hence it is impossible for this routine to
4604 ** be called in the error state. Nevertheless, we include a NEVER()
4605 ** test for the error state as a safeguard against future changes.
4607 if( NEVER(pPager
->errCode
) ) return SQLITE_OK
;
4608 testcase( pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
);
4609 testcase( pPager
->doNotSpill
& SPILLFLAG_OFF
);
4610 testcase( pPager
->doNotSpill
& SPILLFLAG_NOSYNC
);
4611 if( pPager
->doNotSpill
4612 && ((pPager
->doNotSpill
& (SPILLFLAG_ROLLBACK
|SPILLFLAG_OFF
))!=0
4613 || (pPg
->flags
& PGHDR_NEED_SYNC
)!=0)
4618 pPager
->aStat
[PAGER_STAT_SPILL
]++;
4620 if( pagerUseWal(pPager
) ){
4621 /* Write a single frame for this page to the log. */
4622 rc
= subjournalPageIfRequired(pPg
);
4623 if( rc
==SQLITE_OK
){
4624 rc
= pagerWalFrames(pPager
, pPg
, 0, 0);
4628 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
4629 if( pPager
->tempFile
==0 ){
4630 rc
= sqlite3JournalCreate(pPager
->jfd
);
4631 if( rc
!=SQLITE_OK
) return pager_error(pPager
, rc
);
4635 /* Sync the journal file if required. */
4636 if( pPg
->flags
&PGHDR_NEED_SYNC
4637 || pPager
->eState
==PAGER_WRITER_CACHEMOD
4639 rc
= syncJournal(pPager
, 1);
4642 /* Write the contents of the page out to the database file. */
4643 if( rc
==SQLITE_OK
){
4644 assert( (pPg
->flags
&PGHDR_NEED_SYNC
)==0 );
4645 rc
= pager_write_pagelist(pPager
, pPg
);
4649 /* Mark the page as clean. */
4650 if( rc
==SQLITE_OK
){
4651 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager
), pPg
->pgno
));
4652 sqlite3PcacheMakeClean(pPg
);
4655 return pager_error(pPager
, rc
);
4659 ** Flush all unreferenced dirty pages to disk.
4661 int sqlite3PagerFlush(Pager
*pPager
){
4662 int rc
= pPager
->errCode
;
4664 PgHdr
*pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
4665 assert( assert_pager_state(pPager
) );
4666 while( rc
==SQLITE_OK
&& pList
){
4667 PgHdr
*pNext
= pList
->pDirty
;
4668 if( pList
->nRef
==0 ){
4669 rc
= pagerStress((void*)pPager
, pList
);
4679 ** Allocate and initialize a new Pager object and put a pointer to it
4680 ** in *ppPager. The pager should eventually be freed by passing it
4681 ** to sqlite3PagerClose().
4683 ** The zFilename argument is the path to the database file to open.
4684 ** If zFilename is NULL then a randomly-named temporary file is created
4685 ** and used as the file to be cached. Temporary files are be deleted
4686 ** automatically when they are closed. If zFilename is ":memory:" then
4687 ** all information is held in cache. It is never written to disk.
4688 ** This can be used to implement an in-memory database.
4690 ** The nExtra parameter specifies the number of bytes of space allocated
4691 ** along with each page reference. This space is available to the user
4692 ** via the sqlite3PagerGetExtra() API. When a new page is allocated, the
4693 ** first 8 bytes of this space are zeroed but the remainder is uninitialized.
4694 ** (The extra space is used by btree as the MemPage object.)
4696 ** The flags argument is used to specify properties that affect the
4697 ** operation of the pager. It should be passed some bitwise combination
4698 ** of the PAGER_* flags.
4700 ** The vfsFlags parameter is a bitmask to pass to the flags parameter
4701 ** of the xOpen() method of the supplied VFS when opening files.
4703 ** If the pager object is allocated and the specified file opened
4704 ** successfully, SQLITE_OK is returned and *ppPager set to point to
4705 ** the new pager object. If an error occurs, *ppPager is set to NULL
4706 ** and error code returned. This function may return SQLITE_NOMEM
4707 ** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
4708 ** various SQLITE_IO_XXX errors.
4710 int sqlite3PagerOpen(
4711 sqlite3_vfs
*pVfs
, /* The virtual file system to use */
4712 Pager
**ppPager
, /* OUT: Return the Pager structure here */
4713 const char *zFilename
, /* Name of the database file to open */
4714 int nExtra
, /* Extra bytes append to each in-memory page */
4715 int flags
, /* flags controlling this file */
4716 int vfsFlags
, /* flags passed through to sqlite3_vfs.xOpen() */
4717 void (*xReinit
)(DbPage
*) /* Function to reinitialize pages */
4720 Pager
*pPager
= 0; /* Pager object to allocate and return */
4721 int rc
= SQLITE_OK
; /* Return code */
4722 int tempFile
= 0; /* True for temp files (incl. in-memory files) */
4723 int memDb
= 0; /* True if this is an in-memory file */
4724 #ifdef SQLITE_ENABLE_DESERIALIZE
4725 int memJM
= 0; /* Memory journal mode */
4729 int readOnly
= 0; /* True if this is a read-only file */
4730 int journalFileSize
; /* Bytes to allocate for each journal fd */
4731 char *zPathname
= 0; /* Full path to database file */
4732 int nPathname
= 0; /* Number of bytes in zPathname */
4733 int useJournal
= (flags
& PAGER_OMIT_JOURNAL
)==0; /* False to omit journal */
4734 int pcacheSize
= sqlite3PcacheSize(); /* Bytes to allocate for PCache */
4735 u32 szPageDflt
= SQLITE_DEFAULT_PAGE_SIZE
; /* Default page size */
4736 const char *zUri
= 0; /* URI args to copy */
4737 int nUri
= 0; /* Number of bytes of URI args at *zUri */
4739 /* Figure out how much space is required for each journal file-handle
4740 ** (there are two of them, the main journal and the sub-journal). */
4741 journalFileSize
= ROUND8(sqlite3JournalSize(pVfs
));
4743 /* Set the output variable to NULL in case an error occurs. */
4746 #ifndef SQLITE_OMIT_MEMORYDB
4747 if( flags
& PAGER_MEMORY
){
4749 if( zFilename
&& zFilename
[0] ){
4750 zPathname
= sqlite3DbStrDup(0, zFilename
);
4751 if( zPathname
==0 ) return SQLITE_NOMEM_BKPT
;
4752 nPathname
= sqlite3Strlen30(zPathname
);
4758 /* Compute and store the full pathname in an allocated buffer pointed
4759 ** to by zPathname, length nPathname. Or, if this is a temporary file,
4760 ** leave both nPathname and zPathname set to 0.
4762 if( zFilename
&& zFilename
[0] ){
4764 nPathname
= pVfs
->mxPathname
+1;
4765 zPathname
= sqlite3DbMallocRaw(0, nPathname
*2);
4767 return SQLITE_NOMEM_BKPT
;
4769 zPathname
[0] = 0; /* Make sure initialized even if FullPathname() fails */
4770 rc
= sqlite3OsFullPathname(pVfs
, zFilename
, nPathname
, zPathname
);
4771 nPathname
= sqlite3Strlen30(zPathname
);
4772 z
= zUri
= &zFilename
[sqlite3Strlen30(zFilename
)+1];
4774 z
+= sqlite3Strlen30(z
)+1;
4775 z
+= sqlite3Strlen30(z
)+1;
4777 nUri
= (int)(&z
[1] - zUri
);
4779 if( rc
==SQLITE_OK
&& nPathname
+8>pVfs
->mxPathname
){
4780 /* This branch is taken when the journal path required by
4781 ** the database being opened will be more than pVfs->mxPathname
4782 ** bytes in length. This means the database cannot be opened,
4783 ** as it will not be possible to open the journal file or even
4784 ** check for a hot-journal before reading.
4786 rc
= SQLITE_CANTOPEN_BKPT
;
4788 if( rc
!=SQLITE_OK
){
4789 sqlite3DbFree(0, zPathname
);
4794 /* Allocate memory for the Pager structure, PCache object, the
4795 ** three file descriptors, the database file name and the journal
4796 ** file name. The layout in memory is as follows:
4798 ** Pager object (sizeof(Pager) bytes)
4799 ** PCache object (sqlite3PcacheSize() bytes)
4800 ** Database file handle (pVfs->szOsFile bytes)
4801 ** Sub-journal file handle (journalFileSize bytes)
4802 ** Main journal file handle (journalFileSize bytes)
4803 ** Database file name (nPathname+1 bytes)
4804 ** Journal file name (nPathname+8+1 bytes)
4806 pPtr
= (u8
*)sqlite3MallocZero(
4807 ROUND8(sizeof(*pPager
)) + /* Pager structure */
4808 ROUND8(pcacheSize
) + /* PCache object */
4809 ROUND8(pVfs
->szOsFile
) + /* The main db file */
4810 journalFileSize
* 2 + /* The two journal files */
4811 nPathname
+ 1 + nUri
+ /* zFilename */
4812 nPathname
+ 8 + 2 /* zJournal */
4813 #ifndef SQLITE_OMIT_WAL
4814 + nPathname
+ 4 + 2 /* zWal */
4817 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize
)) );
4819 sqlite3DbFree(0, zPathname
);
4820 return SQLITE_NOMEM_BKPT
;
4822 pPager
= (Pager
*)(pPtr
);
4823 pPager
->pPCache
= (PCache
*)(pPtr
+= ROUND8(sizeof(*pPager
)));
4824 pPager
->fd
= (sqlite3_file
*)(pPtr
+= ROUND8(pcacheSize
));
4825 pPager
->sjfd
= (sqlite3_file
*)(pPtr
+= ROUND8(pVfs
->szOsFile
));
4826 pPager
->jfd
= (sqlite3_file
*)(pPtr
+= journalFileSize
);
4827 pPager
->zFilename
= (char*)(pPtr
+= journalFileSize
);
4828 assert( EIGHT_BYTE_ALIGNMENT(pPager
->jfd
) );
4830 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
4832 assert( nPathname
>0 );
4833 pPager
->zJournal
= (char*)(pPtr
+= nPathname
+ 1 + nUri
);
4834 memcpy(pPager
->zFilename
, zPathname
, nPathname
);
4835 if( nUri
) memcpy(&pPager
->zFilename
[nPathname
+1], zUri
, nUri
);
4836 memcpy(pPager
->zJournal
, zPathname
, nPathname
);
4837 memcpy(&pPager
->zJournal
[nPathname
], "-journal\000", 8+2);
4838 sqlite3FileSuffix3(pPager
->zFilename
, pPager
->zJournal
);
4839 #ifndef SQLITE_OMIT_WAL
4840 pPager
->zWal
= &pPager
->zJournal
[nPathname
+8+1];
4841 memcpy(pPager
->zWal
, zPathname
, nPathname
);
4842 memcpy(&pPager
->zWal
[nPathname
], "-wal\000", 4+1);
4843 sqlite3FileSuffix3(pPager
->zFilename
, pPager
->zWal
);
4845 sqlite3DbFree(0, zPathname
);
4847 pPager
->pVfs
= pVfs
;
4848 pPager
->vfsFlags
= vfsFlags
;
4850 /* Open the pager file.
4852 if( zFilename
&& zFilename
[0] ){
4853 int fout
= 0; /* VFS flags returned by xOpen() */
4854 rc
= sqlite3OsOpen(pVfs
, pPager
->zFilename
, pPager
->fd
, vfsFlags
, &fout
);
4856 #ifdef SQLITE_ENABLE_DESERIALIZE
4857 memJM
= (fout
&SQLITE_OPEN_MEMORY
)!=0;
4859 readOnly
= (fout
&SQLITE_OPEN_READONLY
)!=0;
4861 /* If the file was successfully opened for read/write access,
4862 ** choose a default page size in case we have to create the
4863 ** database file. The default page size is the maximum of:
4865 ** + SQLITE_DEFAULT_PAGE_SIZE,
4866 ** + The value returned by sqlite3OsSectorSize()
4867 ** + The largest page size that can be written atomically.
4869 if( rc
==SQLITE_OK
){
4870 int iDc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
4872 setSectorSize(pPager
);
4873 assert(SQLITE_DEFAULT_PAGE_SIZE
<=SQLITE_MAX_DEFAULT_PAGE_SIZE
);
4874 if( szPageDflt
<pPager
->sectorSize
){
4875 if( pPager
->sectorSize
>SQLITE_MAX_DEFAULT_PAGE_SIZE
){
4876 szPageDflt
= SQLITE_MAX_DEFAULT_PAGE_SIZE
;
4878 szPageDflt
= (u32
)pPager
->sectorSize
;
4881 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
4884 assert(SQLITE_IOCAP_ATOMIC512
==(512>>8));
4885 assert(SQLITE_IOCAP_ATOMIC64K
==(65536>>8));
4886 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE
<=65536);
4887 for(ii
=szPageDflt
; ii
<=SQLITE_MAX_DEFAULT_PAGE_SIZE
; ii
=ii
*2){
4888 if( iDc
&(SQLITE_IOCAP_ATOMIC
|(ii
>>8)) ){
4895 pPager
->noLock
= sqlite3_uri_boolean(zFilename
, "nolock", 0);
4896 if( (iDc
& SQLITE_IOCAP_IMMUTABLE
)!=0
4897 || sqlite3_uri_boolean(zFilename
, "immutable", 0) ){
4898 vfsFlags
|= SQLITE_OPEN_READONLY
;
4899 goto act_like_temp_file
;
4903 /* If a temporary file is requested, it is not opened immediately.
4904 ** In this case we accept the default page size and delay actually
4905 ** opening the file until the first call to OsWrite().
4907 ** This branch is also run for an in-memory database. An in-memory
4908 ** database is the same as a temp-file that is never written out to
4909 ** disk and uses an in-memory rollback journal.
4911 ** This branch also runs for files marked as immutable.
4915 pPager
->eState
= PAGER_READER
; /* Pretend we already have a lock */
4916 pPager
->eLock
= EXCLUSIVE_LOCK
; /* Pretend we are in EXCLUSIVE mode */
4917 pPager
->noLock
= 1; /* Do no locking */
4918 readOnly
= (vfsFlags
&SQLITE_OPEN_READONLY
);
4921 /* The following call to PagerSetPagesize() serves to set the value of
4922 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
4924 if( rc
==SQLITE_OK
){
4925 assert( pPager
->memDb
==0 );
4926 rc
= sqlite3PagerSetPagesize(pPager
, &szPageDflt
, -1);
4927 testcase( rc
!=SQLITE_OK
);
4930 /* Initialize the PCache object. */
4931 if( rc
==SQLITE_OK
){
4932 nExtra
= ROUND8(nExtra
);
4933 assert( nExtra
>=8 && nExtra
<1000 );
4934 rc
= sqlite3PcacheOpen(szPageDflt
, nExtra
, !memDb
,
4935 !memDb
?pagerStress
:0, (void *)pPager
, pPager
->pPCache
);
4938 /* If an error occurred above, free the Pager structure and close the file.
4940 if( rc
!=SQLITE_OK
){
4941 sqlite3OsClose(pPager
->fd
);
4942 sqlite3PageFree(pPager
->pTmpSpace
);
4943 sqlite3_free(pPager
);
4947 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager
->fd
), pPager
->zFilename
));
4948 IOTRACE(("OPEN %p %s\n", pPager
, pPager
->zFilename
))
4950 pPager
->useJournal
= (u8
)useJournal
;
4951 /* pPager->stmtOpen = 0; */
4952 /* pPager->stmtInUse = 0; */
4953 /* pPager->nRef = 0; */
4954 /* pPager->stmtSize = 0; */
4955 /* pPager->stmtJSize = 0; */
4956 /* pPager->nPage = 0; */
4957 pPager
->mxPgno
= SQLITE_MAX_PAGE_COUNT
;
4958 /* pPager->state = PAGER_UNLOCK; */
4959 /* pPager->errMask = 0; */
4960 pPager
->tempFile
= (u8
)tempFile
;
4961 assert( tempFile
==PAGER_LOCKINGMODE_NORMAL
4962 || tempFile
==PAGER_LOCKINGMODE_EXCLUSIVE
);
4963 assert( PAGER_LOCKINGMODE_EXCLUSIVE
==1 );
4964 pPager
->exclusiveMode
= (u8
)tempFile
;
4965 pPager
->changeCountDone
= pPager
->tempFile
;
4966 pPager
->memDb
= (u8
)memDb
;
4967 pPager
->readOnly
= (u8
)readOnly
;
4968 assert( useJournal
|| pPager
->tempFile
);
4969 pPager
->noSync
= pPager
->tempFile
;
4970 if( pPager
->noSync
){
4971 assert( pPager
->fullSync
==0 );
4972 assert( pPager
->extraSync
==0 );
4973 assert( pPager
->syncFlags
==0 );
4974 assert( pPager
->walSyncFlags
==0 );
4976 pPager
->fullSync
= 1;
4977 pPager
->extraSync
= 0;
4978 pPager
->syncFlags
= SQLITE_SYNC_NORMAL
;
4979 pPager
->walSyncFlags
= SQLITE_SYNC_NORMAL
| (SQLITE_SYNC_NORMAL
<<2);
4981 /* pPager->pFirst = 0; */
4982 /* pPager->pFirstSynced = 0; */
4983 /* pPager->pLast = 0; */
4984 pPager
->nExtra
= (u16
)nExtra
;
4985 pPager
->journalSizeLimit
= SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
;
4986 assert( isOpen(pPager
->fd
) || tempFile
);
4987 setSectorSize(pPager
);
4989 pPager
->journalMode
= PAGER_JOURNALMODE_OFF
;
4990 }else if( memDb
|| memJM
){
4991 pPager
->journalMode
= PAGER_JOURNALMODE_MEMORY
;
4993 /* pPager->xBusyHandler = 0; */
4994 /* pPager->pBusyHandlerArg = 0; */
4995 pPager
->xReiniter
= xReinit
;
4996 setGetterMethod(pPager
);
4997 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
4998 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
5007 ** This function is called after transitioning from PAGER_UNLOCK to
5008 ** PAGER_SHARED state. It tests if there is a hot journal present in
5009 ** the file-system for the given pager. A hot journal is one that
5010 ** needs to be played back. According to this function, a hot-journal
5011 ** file exists if the following criteria are met:
5013 ** * The journal file exists in the file system, and
5014 ** * No process holds a RESERVED or greater lock on the database file, and
5015 ** * The database file itself is greater than 0 bytes in size, and
5016 ** * The first byte of the journal file exists and is not 0x00.
5018 ** If the current size of the database file is 0 but a journal file
5019 ** exists, that is probably an old journal left over from a prior
5020 ** database with the same name. In this case the journal file is
5021 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
5024 ** This routine does not check if there is a master journal filename
5025 ** at the end of the file. If there is, and that master journal file
5026 ** does not exist, then the journal file is not really hot. In this
5027 ** case this routine will return a false-positive. The pager_playback()
5028 ** routine will discover that the journal file is not really hot and
5029 ** will not roll it back.
5031 ** If a hot-journal file is found to exist, *pExists is set to 1 and
5032 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
5033 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
5034 ** to determine whether or not a hot-journal file exists, the IO error
5035 ** code is returned and the value of *pExists is undefined.
5037 static int hasHotJournal(Pager
*pPager
, int *pExists
){
5038 sqlite3_vfs
* const pVfs
= pPager
->pVfs
;
5039 int rc
= SQLITE_OK
; /* Return code */
5040 int exists
= 1; /* True if a journal file is present */
5041 int jrnlOpen
= !!isOpen(pPager
->jfd
);
5043 assert( pPager
->useJournal
);
5044 assert( isOpen(pPager
->fd
) );
5045 assert( pPager
->eState
==PAGER_OPEN
);
5047 assert( jrnlOpen
==0 || ( sqlite3OsDeviceCharacteristics(pPager
->jfd
) &
5048 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
5053 rc
= sqlite3OsAccess(pVfs
, pPager
->zJournal
, SQLITE_ACCESS_EXISTS
, &exists
);
5055 if( rc
==SQLITE_OK
&& exists
){
5056 int locked
= 0; /* True if some process holds a RESERVED lock */
5058 /* Race condition here: Another process might have been holding the
5059 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
5060 ** call above, but then delete the journal and drop the lock before
5061 ** we get to the following sqlite3OsCheckReservedLock() call. If that
5062 ** is the case, this routine might think there is a hot journal when
5063 ** in fact there is none. This results in a false-positive which will
5064 ** be dealt with by the playback routine. Ticket #3883.
5066 rc
= sqlite3OsCheckReservedLock(pPager
->fd
, &locked
);
5067 if( rc
==SQLITE_OK
&& !locked
){
5068 Pgno nPage
; /* Number of pages in database file */
5070 assert( pPager
->tempFile
==0 );
5071 rc
= pagerPagecount(pPager
, &nPage
);
5072 if( rc
==SQLITE_OK
){
5073 /* If the database is zero pages in size, that means that either (1) the
5074 ** journal is a remnant from a prior database with the same name where
5075 ** the database file but not the journal was deleted, or (2) the initial
5076 ** transaction that populates a new database is being rolled back.
5077 ** In either case, the journal file can be deleted. However, take care
5078 ** not to delete the journal file if it is already open due to
5079 ** journal_mode=PERSIST.
5081 if( nPage
==0 && !jrnlOpen
){
5082 sqlite3BeginBenignMalloc();
5083 if( pagerLockDb(pPager
, RESERVED_LOCK
)==SQLITE_OK
){
5084 sqlite3OsDelete(pVfs
, pPager
->zJournal
, 0);
5085 if( !pPager
->exclusiveMode
) pagerUnlockDb(pPager
, SHARED_LOCK
);
5087 sqlite3EndBenignMalloc();
5089 /* The journal file exists and no other connection has a reserved
5090 ** or greater lock on the database file. Now check that there is
5091 ** at least one non-zero bytes at the start of the journal file.
5092 ** If there is, then we consider this journal to be hot. If not,
5093 ** it can be ignored.
5096 int f
= SQLITE_OPEN_READONLY
|SQLITE_OPEN_MAIN_JOURNAL
;
5097 rc
= sqlite3OsOpen(pVfs
, pPager
->zJournal
, pPager
->jfd
, f
, &f
);
5099 if( rc
==SQLITE_OK
){
5101 rc
= sqlite3OsRead(pPager
->jfd
, (void *)&first
, 1, 0);
5102 if( rc
==SQLITE_IOERR_SHORT_READ
){
5106 sqlite3OsClose(pPager
->jfd
);
5108 *pExists
= (first
!=0);
5109 }else if( rc
==SQLITE_CANTOPEN
){
5110 /* If we cannot open the rollback journal file in order to see if
5111 ** it has a zero header, that might be due to an I/O error, or
5112 ** it might be due to the race condition described above and in
5113 ** ticket #3883. Either way, assume that the journal is hot.
5114 ** This might be a false positive. But if it is, then the
5115 ** automatic journal playback and recovery mechanism will deal
5116 ** with it under an EXCLUSIVE lock where we do not need to
5117 ** worry so much with race conditions.
5131 ** This function is called to obtain a shared lock on the database file.
5132 ** It is illegal to call sqlite3PagerGet() until after this function
5133 ** has been successfully called. If a shared-lock is already held when
5134 ** this function is called, it is a no-op.
5136 ** The following operations are also performed by this function.
5138 ** 1) If the pager is currently in PAGER_OPEN state (no lock held
5139 ** on the database file), then an attempt is made to obtain a
5140 ** SHARED lock on the database file. Immediately after obtaining
5141 ** the SHARED lock, the file-system is checked for a hot-journal,
5142 ** which is played back if present. Following any hot-journal
5143 ** rollback, the contents of the cache are validated by checking
5144 ** the 'change-counter' field of the database file header and
5145 ** discarded if they are found to be invalid.
5147 ** 2) If the pager is running in exclusive-mode, and there are currently
5148 ** no outstanding references to any pages, and is in the error state,
5149 ** then an attempt is made to clear the error state by discarding
5150 ** the contents of the page cache and rolling back any open journal
5153 ** If everything is successful, SQLITE_OK is returned. If an IO error
5154 ** occurs while locking the database, checking for a hot-journal file or
5155 ** rolling back a journal file, the IO error code is returned.
5157 int sqlite3PagerSharedLock(Pager
*pPager
){
5158 int rc
= SQLITE_OK
; /* Return code */
5160 /* This routine is only called from b-tree and only when there are no
5161 ** outstanding pages. This implies that the pager state should either
5162 ** be OPEN or READER. READER is only possible if the pager is or was in
5163 ** exclusive access mode. */
5164 assert( sqlite3PcacheRefCount(pPager
->pPCache
)==0 );
5165 assert( assert_pager_state(pPager
) );
5166 assert( pPager
->eState
==PAGER_OPEN
|| pPager
->eState
==PAGER_READER
);
5167 assert( pPager
->errCode
==SQLITE_OK
);
5169 if( !pagerUseWal(pPager
) && pPager
->eState
==PAGER_OPEN
){
5170 int bHotJournal
= 1; /* True if there exists a hot journal-file */
5173 assert( pPager
->tempFile
==0 || pPager
->eLock
==EXCLUSIVE_LOCK
);
5175 rc
= pager_wait_on_lock(pPager
, SHARED_LOCK
);
5176 if( rc
!=SQLITE_OK
){
5177 assert( pPager
->eLock
==NO_LOCK
|| pPager
->eLock
==UNKNOWN_LOCK
);
5181 /* If a journal file exists, and there is no RESERVED lock on the
5182 ** database file, then it either needs to be played back or deleted.
5184 if( pPager
->eLock
<=SHARED_LOCK
){
5185 rc
= hasHotJournal(pPager
, &bHotJournal
);
5187 if( rc
!=SQLITE_OK
){
5191 if( pPager
->readOnly
){
5192 rc
= SQLITE_READONLY_ROLLBACK
;
5196 /* Get an EXCLUSIVE lock on the database file. At this point it is
5197 ** important that a RESERVED lock is not obtained on the way to the
5198 ** EXCLUSIVE lock. If it were, another process might open the
5199 ** database file, detect the RESERVED lock, and conclude that the
5200 ** database is safe to read while this process is still rolling the
5201 ** hot-journal back.
5203 ** Because the intermediate RESERVED lock is not requested, any
5204 ** other process attempting to access the database file will get to
5205 ** this point in the code and fail to obtain its own EXCLUSIVE lock
5206 ** on the database file.
5208 ** Unless the pager is in locking_mode=exclusive mode, the lock is
5209 ** downgraded to SHARED_LOCK before this function returns.
5211 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
5212 if( rc
!=SQLITE_OK
){
5216 /* If it is not already open and the file exists on disk, open the
5217 ** journal for read/write access. Write access is required because
5218 ** in exclusive-access mode the file descriptor will be kept open
5219 ** and possibly used for a transaction later on. Also, write-access
5220 ** is usually required to finalize the journal in journal_mode=persist
5221 ** mode (and also for journal_mode=truncate on some systems).
5223 ** If the journal does not exist, it usually means that some
5224 ** other connection managed to get in and roll it back before
5225 ** this connection obtained the exclusive lock above. Or, it
5226 ** may mean that the pager was in the error-state when this
5227 ** function was called and the journal file does not exist.
5229 if( !isOpen(pPager
->jfd
) ){
5230 sqlite3_vfs
* const pVfs
= pPager
->pVfs
;
5231 int bExists
; /* True if journal file exists */
5232 rc
= sqlite3OsAccess(
5233 pVfs
, pPager
->zJournal
, SQLITE_ACCESS_EXISTS
, &bExists
);
5234 if( rc
==SQLITE_OK
&& bExists
){
5236 int f
= SQLITE_OPEN_READWRITE
|SQLITE_OPEN_MAIN_JOURNAL
;
5237 assert( !pPager
->tempFile
);
5238 rc
= sqlite3OsOpen(pVfs
, pPager
->zJournal
, pPager
->jfd
, f
, &fout
);
5239 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->jfd
) );
5240 if( rc
==SQLITE_OK
&& fout
&SQLITE_OPEN_READONLY
){
5241 rc
= SQLITE_CANTOPEN_BKPT
;
5242 sqlite3OsClose(pPager
->jfd
);
5247 /* Playback and delete the journal. Drop the database write
5248 ** lock and reacquire the read lock. Purge the cache before
5249 ** playing back the hot-journal so that we don't end up with
5250 ** an inconsistent cache. Sync the hot journal before playing
5251 ** it back since the process that crashed and left the hot journal
5252 ** probably did not sync it and we are required to always sync
5253 ** the journal before playing it back.
5255 if( isOpen(pPager
->jfd
) ){
5256 assert( rc
==SQLITE_OK
);
5257 rc
= pagerSyncHotJournal(pPager
);
5258 if( rc
==SQLITE_OK
){
5259 rc
= pager_playback(pPager
, !pPager
->tempFile
);
5260 pPager
->eState
= PAGER_OPEN
;
5262 }else if( !pPager
->exclusiveMode
){
5263 pagerUnlockDb(pPager
, SHARED_LOCK
);
5266 if( rc
!=SQLITE_OK
){
5267 /* This branch is taken if an error occurs while trying to open
5268 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
5269 ** pager_unlock() routine will be called before returning to unlock
5270 ** the file. If the unlock attempt fails, then Pager.eLock must be
5271 ** set to UNKNOWN_LOCK (see the comment above the #define for
5272 ** UNKNOWN_LOCK above for an explanation).
5274 ** In order to get pager_unlock() to do this, set Pager.eState to
5275 ** PAGER_ERROR now. This is not actually counted as a transition
5276 ** to ERROR state in the state diagram at the top of this file,
5277 ** since we know that the same call to pager_unlock() will very
5278 ** shortly transition the pager object to the OPEN state. Calling
5279 ** assert_pager_state() would fail now, as it should not be possible
5280 ** to be in ERROR state when there are zero outstanding page
5283 pager_error(pPager
, rc
);
5287 assert( pPager
->eState
==PAGER_OPEN
);
5288 assert( (pPager
->eLock
==SHARED_LOCK
)
5289 || (pPager
->exclusiveMode
&& pPager
->eLock
>SHARED_LOCK
)
5293 if( !pPager
->tempFile
&& pPager
->hasHeldSharedLock
){
5294 /* The shared-lock has just been acquired then check to
5295 ** see if the database has been modified. If the database has changed,
5296 ** flush the cache. The hasHeldSharedLock flag prevents this from
5297 ** occurring on the very first access to a file, in order to save a
5298 ** single unnecessary sqlite3OsRead() call at the start-up.
5300 ** Database changes are detected by looking at 15 bytes beginning
5301 ** at offset 24 into the file. The first 4 of these 16 bytes are
5302 ** a 32-bit counter that is incremented with each change. The
5303 ** other bytes change randomly with each file change when
5304 ** a codec is in use.
5306 ** There is a vanishingly small chance that a change will not be
5307 ** detected. The chance of an undetected change is so small that
5308 ** it can be neglected.
5310 char dbFileVers
[sizeof(pPager
->dbFileVers
)];
5312 IOTRACE(("CKVERS %p %d\n", pPager
, sizeof(dbFileVers
)));
5313 rc
= sqlite3OsRead(pPager
->fd
, &dbFileVers
, sizeof(dbFileVers
), 24);
5314 if( rc
!=SQLITE_OK
){
5315 if( rc
!=SQLITE_IOERR_SHORT_READ
){
5318 memset(dbFileVers
, 0, sizeof(dbFileVers
));
5321 if( memcmp(pPager
->dbFileVers
, dbFileVers
, sizeof(dbFileVers
))!=0 ){
5322 pager_reset(pPager
);
5324 /* Unmap the database file. It is possible that external processes
5325 ** may have truncated the database file and then extended it back
5326 ** to its original size while this process was not holding a lock.
5327 ** In this case there may exist a Pager.pMap mapping that appears
5328 ** to be the right size but is not actually valid. Avoid this
5329 ** possibility by unmapping the db here. */
5330 if( USEFETCH(pPager
) ){
5331 sqlite3OsUnfetch(pPager
->fd
, 0, 0);
5336 /* If there is a WAL file in the file-system, open this database in WAL
5337 ** mode. Otherwise, the following function call is a no-op.
5339 rc
= pagerOpenWalIfPresent(pPager
);
5340 #ifndef SQLITE_OMIT_WAL
5341 assert( pPager
->pWal
==0 || rc
==SQLITE_OK
);
5345 if( pagerUseWal(pPager
) ){
5346 assert( rc
==SQLITE_OK
);
5347 rc
= pagerBeginReadTransaction(pPager
);
5350 if( pPager
->tempFile
==0 && pPager
->eState
==PAGER_OPEN
&& rc
==SQLITE_OK
){
5351 rc
= pagerPagecount(pPager
, &pPager
->dbSize
);
5355 if( rc
!=SQLITE_OK
){
5357 pager_unlock(pPager
);
5358 assert( pPager
->eState
==PAGER_OPEN
);
5360 pPager
->eState
= PAGER_READER
;
5361 pPager
->hasHeldSharedLock
= 1;
5367 ** If the reference count has reached zero, rollback any active
5368 ** transaction and unlock the pager.
5370 ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
5371 ** the rollback journal, the unlock is not performed and there is
5372 ** nothing to rollback, so this routine is a no-op.
5374 static void pagerUnlockIfUnused(Pager
*pPager
){
5375 if( sqlite3PcacheRefCount(pPager
->pPCache
)==0 ){
5376 assert( pPager
->nMmapOut
==0 ); /* because page1 is never memory mapped */
5377 pagerUnlockAndRollback(pPager
);
5382 ** The page getter methods each try to acquire a reference to a
5383 ** page with page number pgno. If the requested reference is
5384 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
5386 ** There are different implementations of the getter method depending
5387 ** on the current state of the pager.
5389 ** getPageNormal() -- The normal getter
5390 ** getPageError() -- Used if the pager is in an error state
5391 ** getPageMmap() -- Used if memory-mapped I/O is enabled
5393 ** If the requested page is already in the cache, it is returned.
5394 ** Otherwise, a new page object is allocated and populated with data
5395 ** read from the database file. In some cases, the pcache module may
5396 ** choose not to allocate a new page object and may reuse an existing
5397 ** object with no outstanding references.
5399 ** The extra data appended to a page is always initialized to zeros the
5400 ** first time a page is loaded into memory. If the page requested is
5401 ** already in the cache when this function is called, then the extra
5402 ** data is left as it was when the page object was last used.
5404 ** If the database image is smaller than the requested page or if
5405 ** the flags parameter contains the PAGER_GET_NOCONTENT bit and the
5406 ** requested page is not already stored in the cache, then no
5407 ** actual disk read occurs. In this case the memory image of the
5408 ** page is initialized to all zeros.
5410 ** If PAGER_GET_NOCONTENT is true, it means that we do not care about
5411 ** the contents of the page. This occurs in two scenarios:
5413 ** a) When reading a free-list leaf page from the database, and
5415 ** b) When a savepoint is being rolled back and we need to load
5416 ** a new page into the cache to be filled with the data read
5417 ** from the savepoint journal.
5419 ** If PAGER_GET_NOCONTENT is true, then the data returned is zeroed instead
5420 ** of being read from the database. Additionally, the bits corresponding
5421 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
5422 ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
5423 ** savepoints are set. This means if the page is made writable at any
5424 ** point in the future, using a call to sqlite3PagerWrite(), its contents
5425 ** will not be journaled. This saves IO.
5427 ** The acquisition might fail for several reasons. In all cases,
5428 ** an appropriate error code is returned and *ppPage is set to NULL.
5430 ** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
5431 ** to find a page in the in-memory cache first. If the page is not already
5432 ** in memory, this routine goes to disk to read it in whereas Lookup()
5433 ** just returns 0. This routine acquires a read-lock the first time it
5434 ** has to go to disk, and could also playback an old journal if necessary.
5435 ** Since Lookup() never goes to disk, it never has to deal with locks
5436 ** or journal files.
5438 static int getPageNormal(
5439 Pager
*pPager
, /* The pager open on the database file */
5440 Pgno pgno
, /* Page number to fetch */
5441 DbPage
**ppPage
, /* Write a pointer to the page here */
5442 int flags
/* PAGER_GET_XXX flags */
5446 u8 noContent
; /* True if PAGER_GET_NOCONTENT is set */
5447 sqlite3_pcache_page
*pBase
;
5449 assert( pPager
->errCode
==SQLITE_OK
);
5450 assert( pPager
->eState
>=PAGER_READER
);
5451 assert( assert_pager_state(pPager
) );
5452 assert( pPager
->hasHeldSharedLock
==1 );
5454 if( pgno
==0 ) return SQLITE_CORRUPT_BKPT
;
5455 pBase
= sqlite3PcacheFetch(pPager
->pPCache
, pgno
, 3);
5458 rc
= sqlite3PcacheFetchStress(pPager
->pPCache
, pgno
, &pBase
);
5459 if( rc
!=SQLITE_OK
) goto pager_acquire_err
;
5461 rc
= SQLITE_NOMEM_BKPT
;
5462 goto pager_acquire_err
;
5465 pPg
= *ppPage
= sqlite3PcacheFetchFinish(pPager
->pPCache
, pgno
, pBase
);
5466 assert( pPg
==(*ppPage
) );
5467 assert( pPg
->pgno
==pgno
);
5468 assert( pPg
->pPager
==pPager
|| pPg
->pPager
==0 );
5470 noContent
= (flags
& PAGER_GET_NOCONTENT
)!=0;
5471 if( pPg
->pPager
&& !noContent
){
5472 /* In this case the pcache already contains an initialized copy of
5473 ** the page. Return without further ado. */
5474 assert( pgno
<=PAGER_MAX_PGNO
&& pgno
!=PAGER_MJ_PGNO(pPager
) );
5475 pPager
->aStat
[PAGER_STAT_HIT
]++;
5479 /* The pager cache has created a new page. Its content needs to
5480 ** be initialized. But first some error checks:
5482 ** (1) The maximum page number is 2^31
5483 ** (2) Never try to fetch the locking page
5485 if( pgno
>PAGER_MAX_PGNO
|| pgno
==PAGER_MJ_PGNO(pPager
) ){
5486 rc
= SQLITE_CORRUPT_BKPT
;
5487 goto pager_acquire_err
;
5490 pPg
->pPager
= pPager
;
5492 assert( !isOpen(pPager
->fd
) || !MEMDB
);
5493 if( !isOpen(pPager
->fd
) || pPager
->dbSize
<pgno
|| noContent
){
5494 if( pgno
>pPager
->mxPgno
){
5496 goto pager_acquire_err
;
5499 /* Failure to set the bits in the InJournal bit-vectors is benign.
5500 ** It merely means that we might do some extra work to journal a
5501 ** page that does not need to be journaled. Nevertheless, be sure
5502 ** to test the case where a malloc error occurs while trying to set
5503 ** a bit in a bit vector.
5505 sqlite3BeginBenignMalloc();
5506 if( pgno
<=pPager
->dbOrigSize
){
5507 TESTONLY( rc
= ) sqlite3BitvecSet(pPager
->pInJournal
, pgno
);
5508 testcase( rc
==SQLITE_NOMEM
);
5510 TESTONLY( rc
= ) addToSavepointBitvecs(pPager
, pgno
);
5511 testcase( rc
==SQLITE_NOMEM
);
5512 sqlite3EndBenignMalloc();
5514 memset(pPg
->pData
, 0, pPager
->pageSize
);
5515 IOTRACE(("ZERO %p %d\n", pPager
, pgno
));
5517 assert( pPg
->pPager
==pPager
);
5518 pPager
->aStat
[PAGER_STAT_MISS
]++;
5519 rc
= readDbPage(pPg
);
5520 if( rc
!=SQLITE_OK
){
5521 goto pager_acquire_err
;
5524 pager_set_pagehash(pPg
);
5529 assert( rc
!=SQLITE_OK
);
5531 sqlite3PcacheDrop(pPg
);
5533 pagerUnlockIfUnused(pPager
);
5538 #if SQLITE_MAX_MMAP_SIZE>0
5539 /* The page getter for when memory-mapped I/O is enabled */
5540 static int getPageMMap(
5541 Pager
*pPager
, /* The pager open on the database file */
5542 Pgno pgno
, /* Page number to fetch */
5543 DbPage
**ppPage
, /* Write a pointer to the page here */
5544 int flags
/* PAGER_GET_XXX flags */
5548 u32 iFrame
= 0; /* Frame to read from WAL file */
5550 /* It is acceptable to use a read-only (mmap) page for any page except
5551 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
5552 ** flag was specified by the caller. And so long as the db is not a
5553 ** temporary or in-memory database. */
5554 const int bMmapOk
= (pgno
>1
5555 && (pPager
->eState
==PAGER_READER
|| (flags
& PAGER_GET_READONLY
))
5558 assert( USEFETCH(pPager
) );
5559 #ifdef SQLITE_HAS_CODEC
5560 assert( pPager
->xCodec
==0 );
5563 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
5564 ** allows the compiler optimizer to reuse the results of the "pgno>1"
5565 ** test in the previous statement, and avoid testing pgno==0 in the
5566 ** common case where pgno is large. */
5567 if( pgno
<=1 && pgno
==0 ){
5568 return SQLITE_CORRUPT_BKPT
;
5570 assert( pPager
->eState
>=PAGER_READER
);
5571 assert( assert_pager_state(pPager
) );
5572 assert( pPager
->hasHeldSharedLock
==1 );
5573 assert( pPager
->errCode
==SQLITE_OK
);
5575 if( bMmapOk
&& pagerUseWal(pPager
) ){
5576 rc
= sqlite3WalFindFrame(pPager
->pWal
, pgno
, &iFrame
);
5577 if( rc
!=SQLITE_OK
){
5582 if( bMmapOk
&& iFrame
==0 ){
5584 rc
= sqlite3OsFetch(pPager
->fd
,
5585 (i64
)(pgno
-1) * pPager
->pageSize
, pPager
->pageSize
, &pData
5587 if( rc
==SQLITE_OK
&& pData
){
5588 if( pPager
->eState
>PAGER_READER
|| pPager
->tempFile
){
5589 pPg
= sqlite3PagerLookup(pPager
, pgno
);
5592 rc
= pagerAcquireMapPage(pPager
, pgno
, pData
, &pPg
);
5594 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pgno
-1)*pPager
->pageSize
, pData
);
5597 assert( rc
==SQLITE_OK
);
5602 if( rc
!=SQLITE_OK
){
5607 return getPageNormal(pPager
, pgno
, ppPage
, flags
);
5609 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
5611 /* The page getter method for when the pager is an error state */
5612 static int getPageError(
5613 Pager
*pPager
, /* The pager open on the database file */
5614 Pgno pgno
, /* Page number to fetch */
5615 DbPage
**ppPage
, /* Write a pointer to the page here */
5616 int flags
/* PAGER_GET_XXX flags */
5618 UNUSED_PARAMETER(pgno
);
5619 UNUSED_PARAMETER(flags
);
5620 assert( pPager
->errCode
!=SQLITE_OK
);
5622 return pPager
->errCode
;
5626 /* Dispatch all page fetch requests to the appropriate getter method.
5628 int sqlite3PagerGet(
5629 Pager
*pPager
, /* The pager open on the database file */
5630 Pgno pgno
, /* Page number to fetch */
5631 DbPage
**ppPage
, /* Write a pointer to the page here */
5632 int flags
/* PAGER_GET_XXX flags */
5634 return pPager
->xGet(pPager
, pgno
, ppPage
, flags
);
5638 ** Acquire a page if it is already in the in-memory cache. Do
5639 ** not read the page from disk. Return a pointer to the page,
5640 ** or 0 if the page is not in cache.
5642 ** See also sqlite3PagerGet(). The difference between this routine
5643 ** and sqlite3PagerGet() is that _get() will go to the disk and read
5644 ** in the page if the page is not already in cache. This routine
5645 ** returns NULL if the page is not in cache or if a disk I/O error
5646 ** has ever happened.
5648 DbPage
*sqlite3PagerLookup(Pager
*pPager
, Pgno pgno
){
5649 sqlite3_pcache_page
*pPage
;
5650 assert( pPager
!=0 );
5652 assert( pPager
->pPCache
!=0 );
5653 pPage
= sqlite3PcacheFetch(pPager
->pPCache
, pgno
, 0);
5654 assert( pPage
==0 || pPager
->hasHeldSharedLock
);
5655 if( pPage
==0 ) return 0;
5656 return sqlite3PcacheFetchFinish(pPager
->pPCache
, pgno
, pPage
);
5660 ** Release a page reference.
5662 ** The sqlite3PagerUnref() and sqlite3PagerUnrefNotNull() may only be
5663 ** used if we know that the page being released is not the last page.
5664 ** The btree layer always holds page1 open until the end, so these first
5665 ** to routines can be used to release any page other than BtShared.pPage1.
5667 ** Use sqlite3PagerUnrefPageOne() to release page1. This latter routine
5668 ** checks the total number of outstanding pages and if the number of
5669 ** pages reaches zero it drops the database lock.
5671 void sqlite3PagerUnrefNotNull(DbPage
*pPg
){
5672 TESTONLY( Pager
*pPager
= pPg
->pPager
; )
5674 if( pPg
->flags
& PGHDR_MMAP
){
5675 assert( pPg
->pgno
!=1 ); /* Page1 is never memory mapped */
5676 pagerReleaseMapPage(pPg
);
5678 sqlite3PcacheRelease(pPg
);
5680 /* Do not use this routine to release the last reference to page1 */
5681 assert( sqlite3PcacheRefCount(pPager
->pPCache
)>0 );
5683 void sqlite3PagerUnref(DbPage
*pPg
){
5684 if( pPg
) sqlite3PagerUnrefNotNull(pPg
);
5686 void sqlite3PagerUnrefPageOne(DbPage
*pPg
){
5689 assert( pPg
->pgno
==1 );
5690 assert( (pPg
->flags
& PGHDR_MMAP
)==0 ); /* Page1 is never memory mapped */
5691 pPager
= pPg
->pPager
;
5692 sqlite3PagerResetLockTimeout(pPager
);
5693 sqlite3PcacheRelease(pPg
);
5694 pagerUnlockIfUnused(pPager
);
5698 ** This function is called at the start of every write transaction.
5699 ** There must already be a RESERVED or EXCLUSIVE lock on the database
5700 ** file when this routine is called.
5702 ** Open the journal file for pager pPager and write a journal header
5703 ** to the start of it. If there are active savepoints, open the sub-journal
5704 ** as well. This function is only used when the journal file is being
5705 ** opened to write a rollback log for a transaction. It is not used
5706 ** when opening a hot journal file to roll it back.
5708 ** If the journal file is already open (as it may be in exclusive mode),
5709 ** then this function just writes a journal header to the start of the
5710 ** already open file.
5712 ** Whether or not the journal file is opened by this function, the
5713 ** Pager.pInJournal bitvec structure is allocated.
5715 ** Return SQLITE_OK if everything is successful. Otherwise, return
5716 ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
5717 ** an IO error code if opening or writing the journal file fails.
5719 static int pager_open_journal(Pager
*pPager
){
5720 int rc
= SQLITE_OK
; /* Return code */
5721 sqlite3_vfs
* const pVfs
= pPager
->pVfs
; /* Local cache of vfs pointer */
5723 assert( pPager
->eState
==PAGER_WRITER_LOCKED
);
5724 assert( assert_pager_state(pPager
) );
5725 assert( pPager
->pInJournal
==0 );
5727 /* If already in the error state, this function is a no-op. But on
5728 ** the other hand, this routine is never called if we are already in
5729 ** an error state. */
5730 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
5732 if( !pagerUseWal(pPager
) && pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
5733 pPager
->pInJournal
= sqlite3BitvecCreate(pPager
->dbSize
);
5734 if( pPager
->pInJournal
==0 ){
5735 return SQLITE_NOMEM_BKPT
;
5738 /* Open the journal file if it is not already open. */
5739 if( !isOpen(pPager
->jfd
) ){
5740 if( pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
){
5741 sqlite3MemJournalOpen(pPager
->jfd
);
5743 int flags
= SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
;
5746 if( pPager
->tempFile
){
5747 flags
|= (SQLITE_OPEN_DELETEONCLOSE
|SQLITE_OPEN_TEMP_JOURNAL
);
5748 nSpill
= sqlite3Config
.nStmtSpill
;
5750 flags
|= SQLITE_OPEN_MAIN_JOURNAL
;
5751 nSpill
= jrnlBufferSize(pPager
);
5754 /* Verify that the database still has the same name as it did when
5755 ** it was originally opened. */
5756 rc
= databaseIsUnmoved(pPager
);
5757 if( rc
==SQLITE_OK
){
5758 rc
= sqlite3JournalOpen (
5759 pVfs
, pPager
->zJournal
, pPager
->jfd
, flags
, nSpill
5763 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->jfd
) );
5767 /* Write the first journal header to the journal file and open
5768 ** the sub-journal if necessary.
5770 if( rc
==SQLITE_OK
){
5771 /* TODO: Check if all of these are really required. */
5773 pPager
->journalOff
= 0;
5774 pPager
->setMaster
= 0;
5775 pPager
->journalHdr
= 0;
5776 rc
= writeJournalHdr(pPager
);
5780 if( rc
!=SQLITE_OK
){
5781 sqlite3BitvecDestroy(pPager
->pInJournal
);
5782 pPager
->pInJournal
= 0;
5784 assert( pPager
->eState
==PAGER_WRITER_LOCKED
);
5785 pPager
->eState
= PAGER_WRITER_CACHEMOD
;
5792 ** Begin a write-transaction on the specified pager object. If a
5793 ** write-transaction has already been opened, this function is a no-op.
5795 ** If the exFlag argument is false, then acquire at least a RESERVED
5796 ** lock on the database file. If exFlag is true, then acquire at least
5797 ** an EXCLUSIVE lock. If such a lock is already held, no locking
5798 ** functions need be called.
5800 ** If the subjInMemory argument is non-zero, then any sub-journal opened
5801 ** within this transaction will be opened as an in-memory file. This
5802 ** has no effect if the sub-journal is already opened (as it may be when
5803 ** running in exclusive mode) or if the transaction does not require a
5804 ** sub-journal. If the subjInMemory argument is zero, then any required
5805 ** sub-journal is implemented in-memory if pPager is an in-memory database,
5806 ** or using a temporary file otherwise.
5808 int sqlite3PagerBegin(Pager
*pPager
, int exFlag
, int subjInMemory
){
5811 if( pPager
->errCode
) return pPager
->errCode
;
5812 assert( pPager
->eState
>=PAGER_READER
&& pPager
->eState
<PAGER_ERROR
);
5813 pPager
->subjInMemory
= (u8
)subjInMemory
;
5815 if( ALWAYS(pPager
->eState
==PAGER_READER
) ){
5816 assert( pPager
->pInJournal
==0 );
5818 if( pagerUseWal(pPager
) ){
5819 /* If the pager is configured to use locking_mode=exclusive, and an
5820 ** exclusive lock on the database is not already held, obtain it now.
5822 if( pPager
->exclusiveMode
&& sqlite3WalExclusiveMode(pPager
->pWal
, -1) ){
5823 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
5824 if( rc
!=SQLITE_OK
){
5827 (void)sqlite3WalExclusiveMode(pPager
->pWal
, 1);
5830 /* Grab the write lock on the log file. If successful, upgrade to
5831 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
5832 ** The busy-handler is not invoked if another connection already
5833 ** holds the write-lock. If possible, the upper layer will call it.
5835 rc
= sqlite3WalBeginWriteTransaction(pPager
->pWal
);
5837 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
5838 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
5839 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
5840 ** lock, but not when obtaining the RESERVED lock.
5842 rc
= pagerLockDb(pPager
, RESERVED_LOCK
);
5843 if( rc
==SQLITE_OK
&& exFlag
){
5844 rc
= pager_wait_on_lock(pPager
, EXCLUSIVE_LOCK
);
5848 if( rc
==SQLITE_OK
){
5849 /* Change to WRITER_LOCKED state.
5851 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
5852 ** when it has an open transaction, but never to DBMOD or FINISHED.
5853 ** This is because in those states the code to roll back savepoint
5854 ** transactions may copy data from the sub-journal into the database
5855 ** file as well as into the page cache. Which would be incorrect in
5858 pPager
->eState
= PAGER_WRITER_LOCKED
;
5859 pPager
->dbHintSize
= pPager
->dbSize
;
5860 pPager
->dbFileSize
= pPager
->dbSize
;
5861 pPager
->dbOrigSize
= pPager
->dbSize
;
5862 pPager
->journalOff
= 0;
5865 assert( rc
==SQLITE_OK
|| pPager
->eState
==PAGER_READER
);
5866 assert( rc
!=SQLITE_OK
|| pPager
->eState
==PAGER_WRITER_LOCKED
);
5867 assert( assert_pager_state(pPager
) );
5870 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager
)));
5875 ** Write page pPg onto the end of the rollback journal.
5877 static SQLITE_NOINLINE
int pagerAddPageToRollbackJournal(PgHdr
*pPg
){
5878 Pager
*pPager
= pPg
->pPager
;
5882 i64 iOff
= pPager
->journalOff
;
5884 /* We should never write to the journal file the page that
5885 ** contains the database locks. The following assert verifies
5886 ** that we do not. */
5887 assert( pPg
->pgno
!=PAGER_MJ_PGNO(pPager
) );
5889 assert( pPager
->journalHdr
<=pPager
->journalOff
);
5890 CODEC2(pPager
, pPg
->pData
, pPg
->pgno
, 7, return SQLITE_NOMEM_BKPT
, pData2
);
5891 cksum
= pager_cksum(pPager
, (u8
*)pData2
);
5893 /* Even if an IO or diskfull error occurs while journalling the
5894 ** page in the block above, set the need-sync flag for the page.
5895 ** Otherwise, when the transaction is rolled back, the logic in
5896 ** playback_one_page() will think that the page needs to be restored
5897 ** in the database file. And if an IO error occurs while doing so,
5898 ** then corruption may follow.
5900 pPg
->flags
|= PGHDR_NEED_SYNC
;
5902 rc
= write32bits(pPager
->jfd
, iOff
, pPg
->pgno
);
5903 if( rc
!=SQLITE_OK
) return rc
;
5904 rc
= sqlite3OsWrite(pPager
->jfd
, pData2
, pPager
->pageSize
, iOff
+4);
5905 if( rc
!=SQLITE_OK
) return rc
;
5906 rc
= write32bits(pPager
->jfd
, iOff
+pPager
->pageSize
+4, cksum
);
5907 if( rc
!=SQLITE_OK
) return rc
;
5909 IOTRACE(("JOUT %p %d %lld %d\n", pPager
, pPg
->pgno
,
5910 pPager
->journalOff
, pPager
->pageSize
));
5911 PAGER_INCR(sqlite3_pager_writej_count
);
5912 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
5913 PAGERID(pPager
), pPg
->pgno
,
5914 ((pPg
->flags
&PGHDR_NEED_SYNC
)?1:0), pager_pagehash(pPg
)));
5916 pPager
->journalOff
+= 8 + pPager
->pageSize
;
5918 assert( pPager
->pInJournal
!=0 );
5919 rc
= sqlite3BitvecSet(pPager
->pInJournal
, pPg
->pgno
);
5920 testcase( rc
==SQLITE_NOMEM
);
5921 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
5922 rc
|= addToSavepointBitvecs(pPager
, pPg
->pgno
);
5923 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
5928 ** Mark a single data page as writeable. The page is written into the
5929 ** main journal or sub-journal as required. If the page is written into
5930 ** one of the journals, the corresponding bit is set in the
5931 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
5932 ** of any open savepoints as appropriate.
5934 static int pager_write(PgHdr
*pPg
){
5935 Pager
*pPager
= pPg
->pPager
;
5938 /* This routine is not called unless a write-transaction has already
5939 ** been started. The journal file may or may not be open at this point.
5940 ** It is never called in the ERROR state.
5942 assert( pPager
->eState
==PAGER_WRITER_LOCKED
5943 || pPager
->eState
==PAGER_WRITER_CACHEMOD
5944 || pPager
->eState
==PAGER_WRITER_DBMOD
5946 assert( assert_pager_state(pPager
) );
5947 assert( pPager
->errCode
==0 );
5948 assert( pPager
->readOnly
==0 );
5951 /* The journal file needs to be opened. Higher level routines have already
5952 ** obtained the necessary locks to begin the write-transaction, but the
5953 ** rollback journal might not yet be open. Open it now if this is the case.
5955 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
5956 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
5957 ** an error might occur and the pager would end up in WRITER_LOCKED state
5958 ** with pages marked as dirty in the cache.
5960 if( pPager
->eState
==PAGER_WRITER_LOCKED
){
5961 rc
= pager_open_journal(pPager
);
5962 if( rc
!=SQLITE_OK
) return rc
;
5964 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
);
5965 assert( assert_pager_state(pPager
) );
5967 /* Mark the page that is about to be modified as dirty. */
5968 sqlite3PcacheMakeDirty(pPg
);
5970 /* If a rollback journal is in use, them make sure the page that is about
5971 ** to change is in the rollback journal, or if the page is a new page off
5972 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
5974 assert( (pPager
->pInJournal
!=0) == isOpen(pPager
->jfd
) );
5975 if( pPager
->pInJournal
!=0
5976 && sqlite3BitvecTestNotNull(pPager
->pInJournal
, pPg
->pgno
)==0
5978 assert( pagerUseWal(pPager
)==0 );
5979 if( pPg
->pgno
<=pPager
->dbOrigSize
){
5980 rc
= pagerAddPageToRollbackJournal(pPg
);
5981 if( rc
!=SQLITE_OK
){
5985 if( pPager
->eState
!=PAGER_WRITER_DBMOD
){
5986 pPg
->flags
|= PGHDR_NEED_SYNC
;
5988 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
5989 PAGERID(pPager
), pPg
->pgno
,
5990 ((pPg
->flags
&PGHDR_NEED_SYNC
)?1:0)));
5994 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
5995 ** and before writing the page into the rollback journal. Wait until now,
5996 ** after the page has been successfully journalled, before setting the
5997 ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
5999 pPg
->flags
|= PGHDR_WRITEABLE
;
6001 /* If the statement journal is open and the page is not in it,
6002 ** then write the page into the statement journal.
6004 if( pPager
->nSavepoint
>0 ){
6005 rc
= subjournalPageIfRequired(pPg
);
6008 /* Update the database size and return. */
6009 if( pPager
->dbSize
<pPg
->pgno
){
6010 pPager
->dbSize
= pPg
->pgno
;
6016 ** This is a variant of sqlite3PagerWrite() that runs when the sector size
6017 ** is larger than the page size. SQLite makes the (reasonable) assumption that
6018 ** all bytes of a sector are written together by hardware. Hence, all bytes of
6019 ** a sector need to be journalled in case of a power loss in the middle of
6022 ** Usually, the sector size is less than or equal to the page size, in which
6023 ** case pages can be individually written. This routine only runs in the
6024 ** exceptional case where the page size is smaller than the sector size.
6026 static SQLITE_NOINLINE
int pagerWriteLargeSector(PgHdr
*pPg
){
6027 int rc
= SQLITE_OK
; /* Return code */
6028 Pgno nPageCount
; /* Total number of pages in database file */
6029 Pgno pg1
; /* First page of the sector pPg is located on. */
6030 int nPage
= 0; /* Number of pages starting at pg1 to journal */
6031 int ii
; /* Loop counter */
6032 int needSync
= 0; /* True if any page has PGHDR_NEED_SYNC */
6033 Pager
*pPager
= pPg
->pPager
; /* The pager that owns pPg */
6034 Pgno nPagePerSector
= (pPager
->sectorSize
/pPager
->pageSize
);
6036 /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
6037 ** a journal header to be written between the pages journaled by
6041 assert( (pPager
->doNotSpill
& SPILLFLAG_NOSYNC
)==0 );
6042 pPager
->doNotSpill
|= SPILLFLAG_NOSYNC
;
6044 /* This trick assumes that both the page-size and sector-size are
6045 ** an integer power of 2. It sets variable pg1 to the identifier
6046 ** of the first page of the sector pPg is located on.
6048 pg1
= ((pPg
->pgno
-1) & ~(nPagePerSector
-1)) + 1;
6050 nPageCount
= pPager
->dbSize
;
6051 if( pPg
->pgno
>nPageCount
){
6052 nPage
= (pPg
->pgno
- pg1
)+1;
6053 }else if( (pg1
+nPagePerSector
-1)>nPageCount
){
6054 nPage
= nPageCount
+1-pg1
;
6056 nPage
= nPagePerSector
;
6059 assert(pg1
<=pPg
->pgno
);
6060 assert((pg1
+nPage
)>pPg
->pgno
);
6062 for(ii
=0; ii
<nPage
&& rc
==SQLITE_OK
; ii
++){
6065 if( pg
==pPg
->pgno
|| !sqlite3BitvecTest(pPager
->pInJournal
, pg
) ){
6066 if( pg
!=PAGER_MJ_PGNO(pPager
) ){
6067 rc
= sqlite3PagerGet(pPager
, pg
, &pPage
, 0);
6068 if( rc
==SQLITE_OK
){
6069 rc
= pager_write(pPage
);
6070 if( pPage
->flags
&PGHDR_NEED_SYNC
){
6073 sqlite3PagerUnrefNotNull(pPage
);
6076 }else if( (pPage
= sqlite3PagerLookup(pPager
, pg
))!=0 ){
6077 if( pPage
->flags
&PGHDR_NEED_SYNC
){
6080 sqlite3PagerUnrefNotNull(pPage
);
6084 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
6085 ** starting at pg1, then it needs to be set for all of them. Because
6086 ** writing to any of these nPage pages may damage the others, the
6087 ** journal file must contain sync()ed copies of all of them
6088 ** before any of them can be written out to the database file.
6090 if( rc
==SQLITE_OK
&& needSync
){
6092 for(ii
=0; ii
<nPage
; ii
++){
6093 PgHdr
*pPage
= sqlite3PagerLookup(pPager
, pg1
+ii
);
6095 pPage
->flags
|= PGHDR_NEED_SYNC
;
6096 sqlite3PagerUnrefNotNull(pPage
);
6101 assert( (pPager
->doNotSpill
& SPILLFLAG_NOSYNC
)!=0 );
6102 pPager
->doNotSpill
&= ~SPILLFLAG_NOSYNC
;
6107 ** Mark a data page as writeable. This routine must be called before
6108 ** making changes to a page. The caller must check the return value
6109 ** of this function and be careful not to change any page data unless
6110 ** this routine returns SQLITE_OK.
6112 ** The difference between this function and pager_write() is that this
6113 ** function also deals with the special case where 2 or more pages
6114 ** fit on a single disk sector. In this case all co-resident pages
6115 ** must have been written to the journal file before returning.
6117 ** If an error occurs, SQLITE_NOMEM or an IO error code is returned
6118 ** as appropriate. Otherwise, SQLITE_OK.
6120 int sqlite3PagerWrite(PgHdr
*pPg
){
6121 Pager
*pPager
= pPg
->pPager
;
6122 assert( (pPg
->flags
& PGHDR_MMAP
)==0 );
6123 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6124 assert( assert_pager_state(pPager
) );
6125 if( (pPg
->flags
& PGHDR_WRITEABLE
)!=0 && pPager
->dbSize
>=pPg
->pgno
){
6126 if( pPager
->nSavepoint
) return subjournalPageIfRequired(pPg
);
6128 }else if( pPager
->errCode
){
6129 return pPager
->errCode
;
6130 }else if( pPager
->sectorSize
> (u32
)pPager
->pageSize
){
6131 assert( pPager
->tempFile
==0 );
6132 return pagerWriteLargeSector(pPg
);
6134 return pager_write(pPg
);
6139 ** Return TRUE if the page given in the argument was previously passed
6140 ** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
6141 ** to change the content of the page.
6144 int sqlite3PagerIswriteable(DbPage
*pPg
){
6145 return pPg
->flags
& PGHDR_WRITEABLE
;
6150 ** A call to this routine tells the pager that it is not necessary to
6151 ** write the information on page pPg back to the disk, even though
6152 ** that page might be marked as dirty. This happens, for example, when
6153 ** the page has been added as a leaf of the freelist and so its
6154 ** content no longer matters.
6156 ** The overlying software layer calls this routine when all of the data
6157 ** on the given page is unused. The pager marks the page as clean so
6158 ** that it does not get written to disk.
6160 ** Tests show that this optimization can quadruple the speed of large
6161 ** DELETE operations.
6163 ** This optimization cannot be used with a temp-file, as the page may
6164 ** have been dirty at the start of the transaction. In that case, if
6165 ** memory pressure forces page pPg out of the cache, the data does need
6166 ** to be written out to disk so that it may be read back in if the
6167 ** current transaction is rolled back.
6169 void sqlite3PagerDontWrite(PgHdr
*pPg
){
6170 Pager
*pPager
= pPg
->pPager
;
6171 if( !pPager
->tempFile
&& (pPg
->flags
&PGHDR_DIRTY
) && pPager
->nSavepoint
==0 ){
6172 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg
->pgno
, PAGERID(pPager
)));
6173 IOTRACE(("CLEAN %p %d\n", pPager
, pPg
->pgno
))
6174 pPg
->flags
|= PGHDR_DONT_WRITE
;
6175 pPg
->flags
&= ~PGHDR_WRITEABLE
;
6176 testcase( pPg
->flags
& PGHDR_NEED_SYNC
);
6177 pager_set_pagehash(pPg
);
6182 ** This routine is called to increment the value of the database file
6183 ** change-counter, stored as a 4-byte big-endian integer starting at
6184 ** byte offset 24 of the pager file. The secondary change counter at
6185 ** 92 is also updated, as is the SQLite version number at offset 96.
6187 ** But this only happens if the pPager->changeCountDone flag is false.
6188 ** To avoid excess churning of page 1, the update only happens once.
6189 ** See also the pager_write_changecounter() routine that does an
6190 ** unconditional update of the change counters.
6192 ** If the isDirectMode flag is zero, then this is done by calling
6193 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
6194 ** page data. In this case the file will be updated when the current
6195 ** transaction is committed.
6197 ** The isDirectMode flag may only be non-zero if the library was compiled
6198 ** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
6199 ** if isDirect is non-zero, then the database file is updated directly
6200 ** by writing an updated version of page 1 using a call to the
6201 ** sqlite3OsWrite() function.
6203 static int pager_incr_changecounter(Pager
*pPager
, int isDirectMode
){
6206 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
6207 || pPager
->eState
==PAGER_WRITER_DBMOD
6209 assert( assert_pager_state(pPager
) );
6211 /* Declare and initialize constant integer 'isDirect'. If the
6212 ** atomic-write optimization is enabled in this build, then isDirect
6213 ** is initialized to the value passed as the isDirectMode parameter
6214 ** to this function. Otherwise, it is always set to zero.
6216 ** The idea is that if the atomic-write optimization is not
6217 ** enabled at compile time, the compiler can omit the tests of
6218 ** 'isDirect' below, as well as the block enclosed in the
6219 ** "if( isDirect )" condition.
6221 #ifndef SQLITE_ENABLE_ATOMIC_WRITE
6222 # define DIRECT_MODE 0
6223 assert( isDirectMode
==0 );
6224 UNUSED_PARAMETER(isDirectMode
);
6226 # define DIRECT_MODE isDirectMode
6229 if( !pPager
->changeCountDone
&& ALWAYS(pPager
->dbSize
>0) ){
6230 PgHdr
*pPgHdr
; /* Reference to page 1 */
6232 assert( !pPager
->tempFile
&& isOpen(pPager
->fd
) );
6234 /* Open page 1 of the file for writing. */
6235 rc
= sqlite3PagerGet(pPager
, 1, &pPgHdr
, 0);
6236 assert( pPgHdr
==0 || rc
==SQLITE_OK
);
6238 /* If page one was fetched successfully, and this function is not
6239 ** operating in direct-mode, make page 1 writable. When not in
6240 ** direct mode, page 1 is always held in cache and hence the PagerGet()
6241 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
6243 if( !DIRECT_MODE
&& ALWAYS(rc
==SQLITE_OK
) ){
6244 rc
= sqlite3PagerWrite(pPgHdr
);
6247 if( rc
==SQLITE_OK
){
6248 /* Actually do the update of the change counter */
6249 pager_write_changecounter(pPgHdr
);
6251 /* If running in direct mode, write the contents of page 1 to the file. */
6254 assert( pPager
->dbFileSize
>0 );
6255 CODEC2(pPager
, pPgHdr
->pData
, 1, 6, rc
=SQLITE_NOMEM_BKPT
, zBuf
);
6256 if( rc
==SQLITE_OK
){
6257 rc
= sqlite3OsWrite(pPager
->fd
, zBuf
, pPager
->pageSize
, 0);
6258 pPager
->aStat
[PAGER_STAT_WRITE
]++;
6260 if( rc
==SQLITE_OK
){
6261 /* Update the pager's copy of the change-counter. Otherwise, the
6262 ** next time a read transaction is opened the cache will be
6263 ** flushed (as the change-counter values will not match). */
6264 const void *pCopy
= (const void *)&((const char *)zBuf
)[24];
6265 memcpy(&pPager
->dbFileVers
, pCopy
, sizeof(pPager
->dbFileVers
));
6266 pPager
->changeCountDone
= 1;
6269 pPager
->changeCountDone
= 1;
6273 /* Release the page reference. */
6274 sqlite3PagerUnref(pPgHdr
);
6280 ** Sync the database file to disk. This is a no-op for in-memory databases
6281 ** or pages with the Pager.noSync flag set.
6283 ** If successful, or if called on a pager for which it is a no-op, this
6284 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
6286 int sqlite3PagerSync(Pager
*pPager
, const char *zMaster
){
6288 void *pArg
= (void*)zMaster
;
6289 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_SYNC
, pArg
);
6290 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
6291 if( rc
==SQLITE_OK
&& !pPager
->noSync
){
6293 rc
= sqlite3OsSync(pPager
->fd
, pPager
->syncFlags
);
6299 ** This function may only be called while a write-transaction is active in
6300 ** rollback. If the connection is in WAL mode, this call is a no-op.
6301 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
6302 ** the database file, an attempt is made to obtain one.
6304 ** If the EXCLUSIVE lock is already held or the attempt to obtain it is
6305 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
6306 ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
6309 int sqlite3PagerExclusiveLock(Pager
*pPager
){
6310 int rc
= pPager
->errCode
;
6311 assert( assert_pager_state(pPager
) );
6312 if( rc
==SQLITE_OK
){
6313 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
6314 || pPager
->eState
==PAGER_WRITER_DBMOD
6315 || pPager
->eState
==PAGER_WRITER_LOCKED
6317 assert( assert_pager_state(pPager
) );
6318 if( 0==pagerUseWal(pPager
) ){
6319 rc
= pager_wait_on_lock(pPager
, EXCLUSIVE_LOCK
);
6326 ** Sync the database file for the pager pPager. zMaster points to the name
6327 ** of a master journal file that should be written into the individual
6328 ** journal file. zMaster may be NULL, which is interpreted as no master
6329 ** journal (a single database transaction).
6331 ** This routine ensures that:
6333 ** * The database file change-counter is updated,
6334 ** * the journal is synced (unless the atomic-write optimization is used),
6335 ** * all dirty pages are written to the database file,
6336 ** * the database file is truncated (if required), and
6337 ** * the database file synced.
6339 ** The only thing that remains to commit the transaction is to finalize
6340 ** (delete, truncate or zero the first part of) the journal file (or
6341 ** delete the master journal file if specified).
6343 ** Note that if zMaster==NULL, this does not overwrite a previous value
6344 ** passed to an sqlite3PagerCommitPhaseOne() call.
6346 ** If the final parameter - noSync - is true, then the database file itself
6347 ** is not synced. The caller must call sqlite3PagerSync() directly to
6348 ** sync the database file before calling CommitPhaseTwo() to delete the
6349 ** journal file in this case.
6351 int sqlite3PagerCommitPhaseOne(
6352 Pager
*pPager
, /* Pager object */
6353 const char *zMaster
, /* If not NULL, the master journal name */
6354 int noSync
/* True to omit the xSync on the db file */
6356 int rc
= SQLITE_OK
; /* Return code */
6358 assert( pPager
->eState
==PAGER_WRITER_LOCKED
6359 || pPager
->eState
==PAGER_WRITER_CACHEMOD
6360 || pPager
->eState
==PAGER_WRITER_DBMOD
6361 || pPager
->eState
==PAGER_ERROR
6363 assert( assert_pager_state(pPager
) );
6365 /* If a prior error occurred, report that error again. */
6366 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
6368 /* Provide the ability to easily simulate an I/O error during testing */
6369 if( sqlite3FaultSim(400) ) return SQLITE_IOERR
;
6371 PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
6372 pPager
->zFilename
, zMaster
, pPager
->dbSize
));
6374 /* If no database changes have been made, return early. */
6375 if( pPager
->eState
<PAGER_WRITER_CACHEMOD
) return SQLITE_OK
;
6377 assert( MEMDB
==0 || pPager
->tempFile
);
6378 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
6379 if( 0==pagerFlushOnCommit(pPager
, 1) ){
6380 /* If this is an in-memory db, or no pages have been written to, or this
6381 ** function has already been called, it is mostly a no-op. However, any
6382 ** backup in progress needs to be restarted. */
6383 sqlite3BackupRestart(pPager
->pBackup
);
6385 if( pagerUseWal(pPager
) ){
6386 PgHdr
*pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
6387 PgHdr
*pPageOne
= 0;
6389 /* Must have at least one page for the WAL commit flag.
6390 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
6391 rc
= sqlite3PagerGet(pPager
, 1, &pPageOne
, 0);
6395 assert( rc
==SQLITE_OK
);
6396 if( ALWAYS(pList
) ){
6397 rc
= pagerWalFrames(pPager
, pList
, pPager
->dbSize
, 1);
6399 sqlite3PagerUnref(pPageOne
);
6400 if( rc
==SQLITE_OK
){
6401 sqlite3PcacheCleanAll(pPager
->pPCache
);
6404 /* The bBatch boolean is true if the batch-atomic-write commit method
6405 ** should be used. No rollback journal is created if batch-atomic-write
6408 sqlite3_file
*fd
= pPager
->fd
;
6409 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6410 const int bBatch
= zMaster
==0 /* An SQLITE_IOCAP_BATCH_ATOMIC commit */
6411 && (sqlite3OsDeviceCharacteristics(fd
) & SQLITE_IOCAP_BATCH_ATOMIC
)
6413 && sqlite3JournalIsInMemory(pPager
->jfd
);
6418 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
6419 /* The following block updates the change-counter. Exactly how it
6420 ** does this depends on whether or not the atomic-update optimization
6421 ** was enabled at compile time, and if this transaction meets the
6422 ** runtime criteria to use the operation:
6424 ** * The file-system supports the atomic-write property for
6425 ** blocks of size page-size, and
6426 ** * This commit is not part of a multi-file transaction, and
6427 ** * Exactly one page has been modified and store in the journal file.
6429 ** If the optimization was not enabled at compile time, then the
6430 ** pager_incr_changecounter() function is called to update the change
6431 ** counter in 'indirect-mode'. If the optimization is compiled in but
6432 ** is not applicable to this transaction, call sqlite3JournalCreate()
6433 ** to make sure the journal file has actually been created, then call
6434 ** pager_incr_changecounter() to update the change-counter in indirect
6437 ** Otherwise, if the optimization is both enabled and applicable,
6438 ** then call pager_incr_changecounter() to update the change-counter
6439 ** in 'direct' mode. In this case the journal file will never be
6440 ** created for this transaction.
6444 assert( isOpen(pPager
->jfd
)
6445 || pPager
->journalMode
==PAGER_JOURNALMODE_OFF
6446 || pPager
->journalMode
==PAGER_JOURNALMODE_WAL
6448 if( !zMaster
&& isOpen(pPager
->jfd
)
6449 && pPager
->journalOff
==jrnlBufferSize(pPager
)
6450 && pPager
->dbSize
>=pPager
->dbOrigSize
6451 && (!(pPg
= sqlite3PcacheDirtyList(pPager
->pPCache
)) || 0==pPg
->pDirty
)
6453 /* Update the db file change counter via the direct-write method. The
6454 ** following call will modify the in-memory representation of page 1
6455 ** to include the updated change counter and then write page 1
6456 ** directly to the database file. Because of the atomic-write
6457 ** property of the host file-system, this is safe.
6459 rc
= pager_incr_changecounter(pPager
, 1);
6461 rc
= sqlite3JournalCreate(pPager
->jfd
);
6462 if( rc
==SQLITE_OK
){
6463 rc
= pager_incr_changecounter(pPager
, 0);
6468 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6470 rc
= sqlite3JournalCreate(pPager
->jfd
);
6471 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6474 rc
= pager_incr_changecounter(pPager
, 0);
6476 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6478 /* Write the master journal name into the journal file. If a master
6479 ** journal file name has already been written to the journal file,
6480 ** or if zMaster is NULL (no master journal), then this call is a no-op.
6482 rc
= writeMasterJournal(pPager
, zMaster
);
6483 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6485 /* Sync the journal file and write all dirty pages to the database.
6486 ** If the atomic-update optimization is being used, this sync will not
6487 ** create the journal file or perform any real IO.
6489 ** Because the change-counter page was just modified, unless the
6490 ** atomic-update optimization is used it is almost certain that the
6491 ** journal requires a sync here. However, in locking_mode=exclusive
6492 ** on a system under memory pressure it is just possible that this is
6493 ** not the case. In this case it is likely enough that the redundant
6494 ** xSync() call will be changed to a no-op by the OS anyhow.
6496 rc
= syncJournal(pPager
, 0);
6497 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6500 /* The pager is now in DBMOD state. But regardless of what happens
6501 ** next, attempting to play the journal back into the database would
6502 ** be unsafe. Close it now to make sure that does not happen. */
6503 sqlite3OsClose(pPager
->jfd
);
6504 rc
= sqlite3OsFileControl(fd
, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE
, 0);
6505 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6507 rc
= pager_write_pagelist(pPager
,sqlite3PcacheDirtyList(pPager
->pPCache
));
6509 if( rc
==SQLITE_OK
){
6510 rc
= sqlite3OsFileControl(fd
, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE
, 0);
6512 if( rc
!=SQLITE_OK
){
6513 sqlite3OsFileControlHint(fd
, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE
, 0);
6517 if( rc
!=SQLITE_OK
){
6518 assert( rc
!=SQLITE_IOERR_BLOCKED
);
6519 goto commit_phase_one_exit
;
6521 sqlite3PcacheCleanAll(pPager
->pPCache
);
6523 /* If the file on disk is smaller than the database image, use
6524 ** pager_truncate to grow the file here. This can happen if the database
6525 ** image was extended as part of the current transaction and then the
6526 ** last page in the db image moved to the free-list. In this case the
6527 ** last page is never written out to disk, leaving the database file
6528 ** undersized. Fix this now if it is the case. */
6529 if( pPager
->dbSize
>pPager
->dbFileSize
){
6530 Pgno nNew
= pPager
->dbSize
- (pPager
->dbSize
==PAGER_MJ_PGNO(pPager
));
6531 assert( pPager
->eState
==PAGER_WRITER_DBMOD
);
6532 rc
= pager_truncate(pPager
, nNew
);
6533 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6536 /* Finally, sync the database file. */
6538 rc
= sqlite3PagerSync(pPager
, zMaster
);
6540 IOTRACE(("DBSYNC %p\n", pPager
))
6544 commit_phase_one_exit
:
6545 if( rc
==SQLITE_OK
&& !pagerUseWal(pPager
) ){
6546 pPager
->eState
= PAGER_WRITER_FINISHED
;
6553 ** When this function is called, the database file has been completely
6554 ** updated to reflect the changes made by the current transaction and
6555 ** synced to disk. The journal file still exists in the file-system
6556 ** though, and if a failure occurs at this point it will eventually
6557 ** be used as a hot-journal and the current transaction rolled back.
6559 ** This function finalizes the journal file, either by deleting,
6560 ** truncating or partially zeroing it, so that it cannot be used
6561 ** for hot-journal rollback. Once this is done the transaction is
6562 ** irrevocably committed.
6564 ** If an error occurs, an IO error code is returned and the pager
6565 ** moves into the error state. Otherwise, SQLITE_OK is returned.
6567 int sqlite3PagerCommitPhaseTwo(Pager
*pPager
){
6568 int rc
= SQLITE_OK
; /* Return code */
6570 /* This routine should not be called if a prior error has occurred.
6571 ** But if (due to a coding error elsewhere in the system) it does get
6572 ** called, just return the same error code without doing anything. */
6573 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
6575 assert( pPager
->eState
==PAGER_WRITER_LOCKED
6576 || pPager
->eState
==PAGER_WRITER_FINISHED
6577 || (pagerUseWal(pPager
) && pPager
->eState
==PAGER_WRITER_CACHEMOD
)
6579 assert( assert_pager_state(pPager
) );
6581 /* An optimization. If the database was not actually modified during
6582 ** this transaction, the pager is running in exclusive-mode and is
6583 ** using persistent journals, then this function is a no-op.
6585 ** The start of the journal file currently contains a single journal
6586 ** header with the nRec field set to 0. If such a journal is used as
6587 ** a hot-journal during hot-journal rollback, 0 changes will be made
6588 ** to the database file. So there is no need to zero the journal
6589 ** header. Since the pager is in exclusive mode, there is no need
6590 ** to drop any locks either.
6592 if( pPager
->eState
==PAGER_WRITER_LOCKED
6593 && pPager
->exclusiveMode
6594 && pPager
->journalMode
==PAGER_JOURNALMODE_PERSIST
6596 assert( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) || !pPager
->journalOff
);
6597 pPager
->eState
= PAGER_READER
;
6601 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager
)));
6602 pPager
->iDataVersion
++;
6603 rc
= pager_end_transaction(pPager
, pPager
->setMaster
, 1);
6604 return pager_error(pPager
, rc
);
6608 ** If a write transaction is open, then all changes made within the
6609 ** transaction are reverted and the current write-transaction is closed.
6610 ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
6611 ** state if an error occurs.
6613 ** If the pager is already in PAGER_ERROR state when this function is called,
6614 ** it returns Pager.errCode immediately. No work is performed in this case.
6616 ** Otherwise, in rollback mode, this function performs two functions:
6618 ** 1) It rolls back the journal file, restoring all database file and
6619 ** in-memory cache pages to the state they were in when the transaction
6622 ** 2) It finalizes the journal file, so that it is not used for hot
6623 ** rollback at any point in the future.
6625 ** Finalization of the journal file (task 2) is only performed if the
6626 ** rollback is successful.
6628 ** In WAL mode, all cache-entries containing data modified within the
6629 ** current transaction are either expelled from the cache or reverted to
6630 ** their pre-transaction state by re-reading data from the database or
6631 ** WAL files. The WAL transaction is then closed.
6633 int sqlite3PagerRollback(Pager
*pPager
){
6634 int rc
= SQLITE_OK
; /* Return code */
6635 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager
)));
6637 /* PagerRollback() is a no-op if called in READER or OPEN state. If
6638 ** the pager is already in the ERROR state, the rollback is not
6639 ** attempted here. Instead, the error code is returned to the caller.
6641 assert( assert_pager_state(pPager
) );
6642 if( pPager
->eState
==PAGER_ERROR
) return pPager
->errCode
;
6643 if( pPager
->eState
<=PAGER_READER
) return SQLITE_OK
;
6645 if( pagerUseWal(pPager
) ){
6647 rc
= sqlite3PagerSavepoint(pPager
, SAVEPOINT_ROLLBACK
, -1);
6648 rc2
= pager_end_transaction(pPager
, pPager
->setMaster
, 0);
6649 if( rc
==SQLITE_OK
) rc
= rc2
;
6650 }else if( !isOpen(pPager
->jfd
) || pPager
->eState
==PAGER_WRITER_LOCKED
){
6651 int eState
= pPager
->eState
;
6652 rc
= pager_end_transaction(pPager
, 0, 0);
6653 if( !MEMDB
&& eState
>PAGER_WRITER_LOCKED
){
6654 /* This can happen using journal_mode=off. Move the pager to the error
6655 ** state to indicate that the contents of the cache may not be trusted.
6656 ** Any active readers will get SQLITE_ABORT.
6658 pPager
->errCode
= SQLITE_ABORT
;
6659 pPager
->eState
= PAGER_ERROR
;
6660 setGetterMethod(pPager
);
6664 rc
= pager_playback(pPager
, 0);
6667 assert( pPager
->eState
==PAGER_READER
|| rc
!=SQLITE_OK
);
6668 assert( rc
==SQLITE_OK
|| rc
==SQLITE_FULL
|| rc
==SQLITE_CORRUPT
6669 || rc
==SQLITE_NOMEM
|| (rc
&0xFF)==SQLITE_IOERR
6670 || rc
==SQLITE_CANTOPEN
6673 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
6674 ** cache. So call pager_error() on the way out to make any error persistent.
6676 return pager_error(pPager
, rc
);
6680 ** Return TRUE if the database file is opened read-only. Return FALSE
6681 ** if the database is (in theory) writable.
6683 u8
sqlite3PagerIsreadonly(Pager
*pPager
){
6684 return pPager
->readOnly
;
6689 ** Return the sum of the reference counts for all pages held by pPager.
6691 int sqlite3PagerRefcount(Pager
*pPager
){
6692 return sqlite3PcacheRefCount(pPager
->pPCache
);
6697 ** Return the approximate number of bytes of memory currently
6698 ** used by the pager and its associated cache.
6700 int sqlite3PagerMemUsed(Pager
*pPager
){
6701 int perPageSize
= pPager
->pageSize
+ pPager
->nExtra
+ sizeof(PgHdr
)
6703 return perPageSize
*sqlite3PcachePagecount(pPager
->pPCache
)
6704 + sqlite3MallocSize(pPager
)
6709 ** Return the number of references to the specified page.
6711 int sqlite3PagerPageRefcount(DbPage
*pPage
){
6712 return sqlite3PcachePageRefcount(pPage
);
6717 ** This routine is used for testing and analysis only.
6719 int *sqlite3PagerStats(Pager
*pPager
){
6721 a
[0] = sqlite3PcacheRefCount(pPager
->pPCache
);
6722 a
[1] = sqlite3PcachePagecount(pPager
->pPCache
);
6723 a
[2] = sqlite3PcacheGetCachesize(pPager
->pPCache
);
6724 a
[3] = pPager
->eState
==PAGER_OPEN
? -1 : (int) pPager
->dbSize
;
6725 a
[4] = pPager
->eState
;
6726 a
[5] = pPager
->errCode
;
6727 a
[6] = pPager
->aStat
[PAGER_STAT_HIT
];
6728 a
[7] = pPager
->aStat
[PAGER_STAT_MISS
];
6729 a
[8] = 0; /* Used to be pPager->nOvfl */
6730 a
[9] = pPager
->nRead
;
6731 a
[10] = pPager
->aStat
[PAGER_STAT_WRITE
];
6737 ** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE,
6738 ** or _WRITE+1. The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation
6739 ** of SQLITE_DBSTATUS_CACHE_SPILL. The _SPILL case is not contiguous because
6740 ** it was added later.
6742 ** Before returning, *pnVal is incremented by the
6743 ** current cache hit or miss count, according to the value of eStat. If the
6744 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
6747 void sqlite3PagerCacheStat(Pager
*pPager
, int eStat
, int reset
, int *pnVal
){
6749 assert( eStat
==SQLITE_DBSTATUS_CACHE_HIT
6750 || eStat
==SQLITE_DBSTATUS_CACHE_MISS
6751 || eStat
==SQLITE_DBSTATUS_CACHE_WRITE
6752 || eStat
==SQLITE_DBSTATUS_CACHE_WRITE
+1
6755 assert( SQLITE_DBSTATUS_CACHE_HIT
+1==SQLITE_DBSTATUS_CACHE_MISS
);
6756 assert( SQLITE_DBSTATUS_CACHE_HIT
+2==SQLITE_DBSTATUS_CACHE_WRITE
);
6757 assert( PAGER_STAT_HIT
==0 && PAGER_STAT_MISS
==1
6758 && PAGER_STAT_WRITE
==2 && PAGER_STAT_SPILL
==3 );
6760 eStat
-= SQLITE_DBSTATUS_CACHE_HIT
;
6761 *pnVal
+= pPager
->aStat
[eStat
];
6763 pPager
->aStat
[eStat
] = 0;
6768 ** Return true if this is an in-memory or temp-file backed pager.
6770 int sqlite3PagerIsMemdb(Pager
*pPager
){
6771 return pPager
->tempFile
;
6775 ** Check that there are at least nSavepoint savepoints open. If there are
6776 ** currently less than nSavepoints open, then open one or more savepoints
6777 ** to make up the difference. If the number of savepoints is already
6778 ** equal to nSavepoint, then this function is a no-op.
6780 ** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
6781 ** occurs while opening the sub-journal file, then an IO error code is
6782 ** returned. Otherwise, SQLITE_OK.
6784 static SQLITE_NOINLINE
int pagerOpenSavepoint(Pager
*pPager
, int nSavepoint
){
6785 int rc
= SQLITE_OK
; /* Return code */
6786 int nCurrent
= pPager
->nSavepoint
; /* Current number of savepoints */
6787 int ii
; /* Iterator variable */
6788 PagerSavepoint
*aNew
; /* New Pager.aSavepoint array */
6790 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6791 assert( assert_pager_state(pPager
) );
6792 assert( nSavepoint
>nCurrent
&& pPager
->useJournal
);
6794 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
6795 ** if the allocation fails. Otherwise, zero the new portion in case a
6796 ** malloc failure occurs while populating it in the for(...) loop below.
6798 aNew
= (PagerSavepoint
*)sqlite3Realloc(
6799 pPager
->aSavepoint
, sizeof(PagerSavepoint
)*nSavepoint
6802 return SQLITE_NOMEM_BKPT
;
6804 memset(&aNew
[nCurrent
], 0, (nSavepoint
-nCurrent
) * sizeof(PagerSavepoint
));
6805 pPager
->aSavepoint
= aNew
;
6807 /* Populate the PagerSavepoint structures just allocated. */
6808 for(ii
=nCurrent
; ii
<nSavepoint
; ii
++){
6809 aNew
[ii
].nOrig
= pPager
->dbSize
;
6810 if( isOpen(pPager
->jfd
) && pPager
->journalOff
>0 ){
6811 aNew
[ii
].iOffset
= pPager
->journalOff
;
6813 aNew
[ii
].iOffset
= JOURNAL_HDR_SZ(pPager
);
6815 aNew
[ii
].iSubRec
= pPager
->nSubRec
;
6816 aNew
[ii
].pInSavepoint
= sqlite3BitvecCreate(pPager
->dbSize
);
6817 if( !aNew
[ii
].pInSavepoint
){
6818 return SQLITE_NOMEM_BKPT
;
6820 if( pagerUseWal(pPager
) ){
6821 sqlite3WalSavepoint(pPager
->pWal
, aNew
[ii
].aWalData
);
6823 pPager
->nSavepoint
= ii
+1;
6825 assert( pPager
->nSavepoint
==nSavepoint
);
6826 assertTruncateConstraint(pPager
);
6829 int sqlite3PagerOpenSavepoint(Pager
*pPager
, int nSavepoint
){
6830 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6831 assert( assert_pager_state(pPager
) );
6833 if( nSavepoint
>pPager
->nSavepoint
&& pPager
->useJournal
){
6834 return pagerOpenSavepoint(pPager
, nSavepoint
);
6842 ** This function is called to rollback or release (commit) a savepoint.
6843 ** The savepoint to release or rollback need not be the most recently
6844 ** created savepoint.
6846 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
6847 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
6848 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
6849 ** that have occurred since the specified savepoint was created.
6851 ** The savepoint to rollback or release is identified by parameter
6852 ** iSavepoint. A value of 0 means to operate on the outermost savepoint
6853 ** (the first created). A value of (Pager.nSavepoint-1) means operate
6854 ** on the most recently created savepoint. If iSavepoint is greater than
6855 ** (Pager.nSavepoint-1), then this function is a no-op.
6857 ** If a negative value is passed to this function, then the current
6858 ** transaction is rolled back. This is different to calling
6859 ** sqlite3PagerRollback() because this function does not terminate
6860 ** the transaction or unlock the database, it just restores the
6861 ** contents of the database to its original state.
6863 ** In any case, all savepoints with an index greater than iSavepoint
6864 ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
6865 ** then savepoint iSavepoint is also destroyed.
6867 ** This function may return SQLITE_NOMEM if a memory allocation fails,
6868 ** or an IO error code if an IO error occurs while rolling back a
6869 ** savepoint. If no errors occur, SQLITE_OK is returned.
6871 int sqlite3PagerSavepoint(Pager
*pPager
, int op
, int iSavepoint
){
6872 int rc
= pPager
->errCode
;
6874 #ifdef SQLITE_ENABLE_ZIPVFS
6875 if( op
==SAVEPOINT_RELEASE
) rc
= SQLITE_OK
;
6878 assert( op
==SAVEPOINT_RELEASE
|| op
==SAVEPOINT_ROLLBACK
);
6879 assert( iSavepoint
>=0 || op
==SAVEPOINT_ROLLBACK
);
6881 if( rc
==SQLITE_OK
&& iSavepoint
<pPager
->nSavepoint
){
6882 int ii
; /* Iterator variable */
6883 int nNew
; /* Number of remaining savepoints after this op. */
6885 /* Figure out how many savepoints will still be active after this
6886 ** operation. Store this value in nNew. Then free resources associated
6887 ** with any savepoints that are destroyed by this operation.
6889 nNew
= iSavepoint
+ (( op
==SAVEPOINT_RELEASE
) ? 0 : 1);
6890 for(ii
=nNew
; ii
<pPager
->nSavepoint
; ii
++){
6891 sqlite3BitvecDestroy(pPager
->aSavepoint
[ii
].pInSavepoint
);
6893 pPager
->nSavepoint
= nNew
;
6895 /* If this is a release of the outermost savepoint, truncate
6896 ** the sub-journal to zero bytes in size. */
6897 if( op
==SAVEPOINT_RELEASE
){
6898 if( nNew
==0 && isOpen(pPager
->sjfd
) ){
6899 /* Only truncate if it is an in-memory sub-journal. */
6900 if( sqlite3JournalIsInMemory(pPager
->sjfd
) ){
6901 rc
= sqlite3OsTruncate(pPager
->sjfd
, 0);
6902 assert( rc
==SQLITE_OK
);
6904 pPager
->nSubRec
= 0;
6907 /* Else this is a rollback operation, playback the specified savepoint.
6908 ** If this is a temp-file, it is possible that the journal file has
6909 ** not yet been opened. In this case there have been no changes to
6910 ** the database file, so the playback operation can be skipped.
6912 else if( pagerUseWal(pPager
) || isOpen(pPager
->jfd
) ){
6913 PagerSavepoint
*pSavepoint
= (nNew
==0)?0:&pPager
->aSavepoint
[nNew
-1];
6914 rc
= pagerPlaybackSavepoint(pPager
, pSavepoint
);
6915 assert(rc
!=SQLITE_DONE
);
6918 #ifdef SQLITE_ENABLE_ZIPVFS
6919 /* If the cache has been modified but the savepoint cannot be rolled
6920 ** back journal_mode=off, put the pager in the error state. This way,
6921 ** if the VFS used by this pager includes ZipVFS, the entire transaction
6922 ** can be rolled back at the ZipVFS level. */
6924 pPager
->journalMode
==PAGER_JOURNALMODE_OFF
6925 && pPager
->eState
>=PAGER_WRITER_CACHEMOD
6927 pPager
->errCode
= SQLITE_ABORT
;
6928 pPager
->eState
= PAGER_ERROR
;
6929 setGetterMethod(pPager
);
6938 ** Return the full pathname of the database file.
6940 ** Except, if the pager is in-memory only, then return an empty string if
6941 ** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when
6942 ** used to report the filename to the user, for compatibility with legacy
6943 ** behavior. But when the Btree needs to know the filename for matching to
6944 ** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
6945 ** participate in shared-cache.
6947 const char *sqlite3PagerFilename(Pager
*pPager
, int nullIfMemDb
){
6948 return (nullIfMemDb
&& pPager
->memDb
) ? "" : pPager
->zFilename
;
6952 ** Return the VFS structure for the pager.
6954 sqlite3_vfs
*sqlite3PagerVfs(Pager
*pPager
){
6955 return pPager
->pVfs
;
6959 ** Return the file handle for the database file associated
6960 ** with the pager. This might return NULL if the file has
6961 ** not yet been opened.
6963 sqlite3_file
*sqlite3PagerFile(Pager
*pPager
){
6967 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
6969 ** Reset the lock timeout for pager.
6971 void sqlite3PagerResetLockTimeout(Pager
*pPager
){
6973 sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_LOCK_TIMEOUT
, &x
);
6978 ** Return the file handle for the journal file (if it exists).
6979 ** This will be either the rollback journal or the WAL file.
6981 sqlite3_file
*sqlite3PagerJrnlFile(Pager
*pPager
){
6985 return pPager
->pWal
? sqlite3WalFile(pPager
->pWal
) : pPager
->jfd
;
6990 ** Return the full pathname of the journal file.
6992 const char *sqlite3PagerJournalname(Pager
*pPager
){
6993 return pPager
->zJournal
;
6996 #ifdef SQLITE_HAS_CODEC
6998 ** Set or retrieve the codec for this pager
7000 void sqlite3PagerSetCodec(
7002 void *(*xCodec
)(void*,void*,Pgno
,int),
7003 void (*xCodecSizeChng
)(void*,int,int),
7004 void (*xCodecFree
)(void*),
7007 if( pPager
->xCodecFree
) pPager
->xCodecFree(pPager
->pCodec
);
7008 pPager
->xCodec
= pPager
->memDb
? 0 : xCodec
;
7009 pPager
->xCodecSizeChng
= xCodecSizeChng
;
7010 pPager
->xCodecFree
= xCodecFree
;
7011 pPager
->pCodec
= pCodec
;
7012 setGetterMethod(pPager
);
7013 pagerReportSize(pPager
);
7015 void *sqlite3PagerGetCodec(Pager
*pPager
){
7016 return pPager
->pCodec
;
7020 ** This function is called by the wal module when writing page content
7021 ** into the log file.
7023 ** This function returns a pointer to a buffer containing the encrypted
7024 ** page content. If a malloc fails, this function may return NULL.
7026 void *sqlite3PagerCodec(PgHdr
*pPg
){
7028 CODEC2(pPg
->pPager
, pPg
->pData
, pPg
->pgno
, 6, return 0, aData
);
7033 ** Return the current pager state
7035 int sqlite3PagerState(Pager
*pPager
){
7036 return pPager
->eState
;
7038 #endif /* SQLITE_HAS_CODEC */
7040 #ifndef SQLITE_OMIT_AUTOVACUUM
7042 ** Move the page pPg to location pgno in the file.
7044 ** There must be no references to the page previously located at
7045 ** pgno (which we call pPgOld) though that page is allowed to be
7046 ** in cache. If the page previously located at pgno is not already
7047 ** in the rollback journal, it is not put there by by this routine.
7049 ** References to the page pPg remain valid. Updating any
7050 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
7051 ** allocated along with the page) is the responsibility of the caller.
7053 ** A transaction must be active when this routine is called. It used to be
7054 ** required that a statement transaction was not active, but this restriction
7055 ** has been removed (CREATE INDEX needs to move a page when a statement
7056 ** transaction is active).
7058 ** If the fourth argument, isCommit, is non-zero, then this page is being
7059 ** moved as part of a database reorganization just before the transaction
7060 ** is being committed. In this case, it is guaranteed that the database page
7061 ** pPg refers to will not be written to again within this transaction.
7063 ** This function may return SQLITE_NOMEM or an IO error code if an error
7064 ** occurs. Otherwise, it returns SQLITE_OK.
7066 int sqlite3PagerMovepage(Pager
*pPager
, DbPage
*pPg
, Pgno pgno
, int isCommit
){
7067 PgHdr
*pPgOld
; /* The page being overwritten. */
7068 Pgno needSyncPgno
= 0; /* Old value of pPg->pgno, if sync is required */
7069 int rc
; /* Return code */
7070 Pgno origPgno
; /* The original page number */
7072 assert( pPg
->nRef
>0 );
7073 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
7074 || pPager
->eState
==PAGER_WRITER_DBMOD
7076 assert( assert_pager_state(pPager
) );
7078 /* In order to be able to rollback, an in-memory database must journal
7079 ** the page we are moving from.
7081 assert( pPager
->tempFile
|| !MEMDB
);
7082 if( pPager
->tempFile
){
7083 rc
= sqlite3PagerWrite(pPg
);
7087 /* If the page being moved is dirty and has not been saved by the latest
7088 ** savepoint, then save the current contents of the page into the
7089 ** sub-journal now. This is required to handle the following scenario:
7092 ** <journal page X, then modify it in memory>
7094 ** <Move page X to location Y>
7097 ** If page X were not written to the sub-journal here, it would not
7098 ** be possible to restore its contents when the "ROLLBACK TO one"
7099 ** statement were is processed.
7101 ** subjournalPage() may need to allocate space to store pPg->pgno into
7102 ** one or more savepoint bitvecs. This is the reason this function
7103 ** may return SQLITE_NOMEM.
7105 if( (pPg
->flags
& PGHDR_DIRTY
)!=0
7106 && SQLITE_OK
!=(rc
= subjournalPageIfRequired(pPg
))
7111 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
7112 PAGERID(pPager
), pPg
->pgno
, (pPg
->flags
&PGHDR_NEED_SYNC
)?1:0, pgno
));
7113 IOTRACE(("MOVE %p %d %d\n", pPager
, pPg
->pgno
, pgno
))
7115 /* If the journal needs to be sync()ed before page pPg->pgno can
7116 ** be written to, store pPg->pgno in local variable needSyncPgno.
7118 ** If the isCommit flag is set, there is no need to remember that
7119 ** the journal needs to be sync()ed before database page pPg->pgno
7120 ** can be written to. The caller has already promised not to write to it.
7122 if( (pPg
->flags
&PGHDR_NEED_SYNC
) && !isCommit
){
7123 needSyncPgno
= pPg
->pgno
;
7124 assert( pPager
->journalMode
==PAGER_JOURNALMODE_OFF
||
7125 pageInJournal(pPager
, pPg
) || pPg
->pgno
>pPager
->dbOrigSize
);
7126 assert( pPg
->flags
&PGHDR_DIRTY
);
7129 /* If the cache contains a page with page-number pgno, remove it
7130 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
7131 ** page pgno before the 'move' operation, it needs to be retained
7132 ** for the page moved there.
7134 pPg
->flags
&= ~PGHDR_NEED_SYNC
;
7135 pPgOld
= sqlite3PagerLookup(pPager
, pgno
);
7136 assert( !pPgOld
|| pPgOld
->nRef
==1 );
7138 pPg
->flags
|= (pPgOld
->flags
&PGHDR_NEED_SYNC
);
7139 if( pPager
->tempFile
){
7140 /* Do not discard pages from an in-memory database since we might
7141 ** need to rollback later. Just move the page out of the way. */
7142 sqlite3PcacheMove(pPgOld
, pPager
->dbSize
+1);
7144 sqlite3PcacheDrop(pPgOld
);
7148 origPgno
= pPg
->pgno
;
7149 sqlite3PcacheMove(pPg
, pgno
);
7150 sqlite3PcacheMakeDirty(pPg
);
7152 /* For an in-memory database, make sure the original page continues
7153 ** to exist, in case the transaction needs to roll back. Use pPgOld
7154 ** as the original page since it has already been allocated.
7156 if( pPager
->tempFile
&& pPgOld
){
7157 sqlite3PcacheMove(pPgOld
, origPgno
);
7158 sqlite3PagerUnrefNotNull(pPgOld
);
7162 /* If needSyncPgno is non-zero, then the journal file needs to be
7163 ** sync()ed before any data is written to database file page needSyncPgno.
7164 ** Currently, no such page exists in the page-cache and the
7165 ** "is journaled" bitvec flag has been set. This needs to be remedied by
7166 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
7169 ** If the attempt to load the page into the page-cache fails, (due
7170 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
7171 ** array. Otherwise, if the page is loaded and written again in
7172 ** this transaction, it may be written to the database file before
7173 ** it is synced into the journal file. This way, it may end up in
7174 ** the journal file twice, but that is not a problem.
7177 rc
= sqlite3PagerGet(pPager
, needSyncPgno
, &pPgHdr
, 0);
7178 if( rc
!=SQLITE_OK
){
7179 if( needSyncPgno
<=pPager
->dbOrigSize
){
7180 assert( pPager
->pTmpSpace
!=0 );
7181 sqlite3BitvecClear(pPager
->pInJournal
, needSyncPgno
, pPager
->pTmpSpace
);
7185 pPgHdr
->flags
|= PGHDR_NEED_SYNC
;
7186 sqlite3PcacheMakeDirty(pPgHdr
);
7187 sqlite3PagerUnrefNotNull(pPgHdr
);
7195 ** The page handle passed as the first argument refers to a dirty page
7196 ** with a page number other than iNew. This function changes the page's
7197 ** page number to iNew and sets the value of the PgHdr.flags field to
7198 ** the value passed as the third parameter.
7200 void sqlite3PagerRekey(DbPage
*pPg
, Pgno iNew
, u16 flags
){
7201 assert( pPg
->pgno
!=iNew
);
7203 sqlite3PcacheMove(pPg
, iNew
);
7207 ** Return a pointer to the data for the specified page.
7209 void *sqlite3PagerGetData(DbPage
*pPg
){
7210 assert( pPg
->nRef
>0 || pPg
->pPager
->memDb
);
7215 ** Return a pointer to the Pager.nExtra bytes of "extra" space
7216 ** allocated along with the specified page.
7218 void *sqlite3PagerGetExtra(DbPage
*pPg
){
7223 ** Get/set the locking-mode for this pager. Parameter eMode must be one
7224 ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
7225 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
7226 ** the locking-mode is set to the value specified.
7228 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
7229 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
7232 int sqlite3PagerLockingMode(Pager
*pPager
, int eMode
){
7233 assert( eMode
==PAGER_LOCKINGMODE_QUERY
7234 || eMode
==PAGER_LOCKINGMODE_NORMAL
7235 || eMode
==PAGER_LOCKINGMODE_EXCLUSIVE
);
7236 assert( PAGER_LOCKINGMODE_QUERY
<0 );
7237 assert( PAGER_LOCKINGMODE_NORMAL
>=0 && PAGER_LOCKINGMODE_EXCLUSIVE
>=0 );
7238 assert( pPager
->exclusiveMode
|| 0==sqlite3WalHeapMemory(pPager
->pWal
) );
7239 if( eMode
>=0 && !pPager
->tempFile
&& !sqlite3WalHeapMemory(pPager
->pWal
) ){
7240 pPager
->exclusiveMode
= (u8
)eMode
;
7242 return (int)pPager
->exclusiveMode
;
7246 ** Set the journal-mode for this pager. Parameter eMode must be one of:
7248 ** PAGER_JOURNALMODE_DELETE
7249 ** PAGER_JOURNALMODE_TRUNCATE
7250 ** PAGER_JOURNALMODE_PERSIST
7251 ** PAGER_JOURNALMODE_OFF
7252 ** PAGER_JOURNALMODE_MEMORY
7253 ** PAGER_JOURNALMODE_WAL
7255 ** The journalmode is set to the value specified if the change is allowed.
7256 ** The change may be disallowed for the following reasons:
7258 ** * An in-memory database can only have its journal_mode set to _OFF
7261 ** * Temporary databases cannot have _WAL journalmode.
7263 ** The returned indicate the current (possibly updated) journal-mode.
7265 int sqlite3PagerSetJournalMode(Pager
*pPager
, int eMode
){
7266 u8 eOld
= pPager
->journalMode
; /* Prior journalmode */
7269 /* The print_pager_state() routine is intended to be used by the debugger
7270 ** only. We invoke it once here to suppress a compiler warning. */
7271 print_pager_state(pPager
);
7275 /* The eMode parameter is always valid */
7276 assert( eMode
==PAGER_JOURNALMODE_DELETE
7277 || eMode
==PAGER_JOURNALMODE_TRUNCATE
7278 || eMode
==PAGER_JOURNALMODE_PERSIST
7279 || eMode
==PAGER_JOURNALMODE_OFF
7280 || eMode
==PAGER_JOURNALMODE_WAL
7281 || eMode
==PAGER_JOURNALMODE_MEMORY
);
7283 /* This routine is only called from the OP_JournalMode opcode, and
7284 ** the logic there will never allow a temporary file to be changed
7287 assert( pPager
->tempFile
==0 || eMode
!=PAGER_JOURNALMODE_WAL
);
7289 /* Do allow the journalmode of an in-memory database to be set to
7290 ** anything other than MEMORY or OFF
7293 assert( eOld
==PAGER_JOURNALMODE_MEMORY
|| eOld
==PAGER_JOURNALMODE_OFF
);
7294 if( eMode
!=PAGER_JOURNALMODE_MEMORY
&& eMode
!=PAGER_JOURNALMODE_OFF
){
7301 /* Change the journal mode. */
7302 assert( pPager
->eState
!=PAGER_ERROR
);
7303 pPager
->journalMode
= (u8
)eMode
;
7305 /* When transistioning from TRUNCATE or PERSIST to any other journal
7306 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
7307 ** delete the journal file.
7309 assert( (PAGER_JOURNALMODE_TRUNCATE
& 5)==1 );
7310 assert( (PAGER_JOURNALMODE_PERSIST
& 5)==1 );
7311 assert( (PAGER_JOURNALMODE_DELETE
& 5)==0 );
7312 assert( (PAGER_JOURNALMODE_MEMORY
& 5)==4 );
7313 assert( (PAGER_JOURNALMODE_OFF
& 5)==0 );
7314 assert( (PAGER_JOURNALMODE_WAL
& 5)==5 );
7316 assert( isOpen(pPager
->fd
) || pPager
->exclusiveMode
);
7317 if( !pPager
->exclusiveMode
&& (eOld
& 5)==1 && (eMode
& 1)==0 ){
7319 /* In this case we would like to delete the journal file. If it is
7320 ** not possible, then that is not a problem. Deleting the journal file
7321 ** here is an optimization only.
7323 ** Before deleting the journal file, obtain a RESERVED lock on the
7324 ** database file. This ensures that the journal file is not deleted
7325 ** while it is in use by some other client.
7327 sqlite3OsClose(pPager
->jfd
);
7328 if( pPager
->eLock
>=RESERVED_LOCK
){
7329 sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, 0);
7332 int state
= pPager
->eState
;
7333 assert( state
==PAGER_OPEN
|| state
==PAGER_READER
);
7334 if( state
==PAGER_OPEN
){
7335 rc
= sqlite3PagerSharedLock(pPager
);
7337 if( pPager
->eState
==PAGER_READER
){
7338 assert( rc
==SQLITE_OK
);
7339 rc
= pagerLockDb(pPager
, RESERVED_LOCK
);
7341 if( rc
==SQLITE_OK
){
7342 sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, 0);
7344 if( rc
==SQLITE_OK
&& state
==PAGER_READER
){
7345 pagerUnlockDb(pPager
, SHARED_LOCK
);
7346 }else if( state
==PAGER_OPEN
){
7347 pager_unlock(pPager
);
7349 assert( state
==pPager
->eState
);
7351 }else if( eMode
==PAGER_JOURNALMODE_OFF
){
7352 sqlite3OsClose(pPager
->jfd
);
7356 /* Return the new journal mode */
7357 return (int)pPager
->journalMode
;
7361 ** Return the current journal mode.
7363 int sqlite3PagerGetJournalMode(Pager
*pPager
){
7364 return (int)pPager
->journalMode
;
7368 ** Return TRUE if the pager is in a state where it is OK to change the
7369 ** journalmode. Journalmode changes can only happen when the database
7372 int sqlite3PagerOkToChangeJournalMode(Pager
*pPager
){
7373 assert( assert_pager_state(pPager
) );
7374 if( pPager
->eState
>=PAGER_WRITER_CACHEMOD
) return 0;
7375 if( NEVER(isOpen(pPager
->jfd
) && pPager
->journalOff
>0) ) return 0;
7380 ** Get/set the size-limit used for persistent journal files.
7382 ** Setting the size limit to -1 means no limit is enforced.
7383 ** An attempt to set a limit smaller than -1 is a no-op.
7385 i64
sqlite3PagerJournalSizeLimit(Pager
*pPager
, i64 iLimit
){
7387 pPager
->journalSizeLimit
= iLimit
;
7388 sqlite3WalLimit(pPager
->pWal
, iLimit
);
7390 return pPager
->journalSizeLimit
;
7394 ** Return a pointer to the pPager->pBackup variable. The backup module
7395 ** in backup.c maintains the content of this variable. This module
7396 ** uses it opaquely as an argument to sqlite3BackupRestart() and
7397 ** sqlite3BackupUpdate() only.
7399 sqlite3_backup
**sqlite3PagerBackupPtr(Pager
*pPager
){
7400 return &pPager
->pBackup
;
7403 #ifndef SQLITE_OMIT_VACUUM
7405 ** Unless this is an in-memory or temporary database, clear the pager cache.
7407 void sqlite3PagerClearCache(Pager
*pPager
){
7408 assert( MEMDB
==0 || pPager
->tempFile
);
7409 if( pPager
->tempFile
==0 ) pager_reset(pPager
);
7414 #ifndef SQLITE_OMIT_WAL
7416 ** This function is called when the user invokes "PRAGMA wal_checkpoint",
7417 ** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
7418 ** or wal_blocking_checkpoint() API functions.
7420 ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
7422 int sqlite3PagerCheckpoint(
7423 Pager
*pPager
, /* Checkpoint on this pager */
7424 sqlite3
*db
, /* Db handle used to check for interrupts */
7425 int eMode
, /* Type of checkpoint */
7426 int *pnLog
, /* OUT: Final number of frames in log */
7427 int *pnCkpt
/* OUT: Final number of checkpointed frames */
7431 rc
= sqlite3WalCheckpoint(pPager
->pWal
, db
, eMode
,
7432 (eMode
==SQLITE_CHECKPOINT_PASSIVE
? 0 : pPager
->xBusyHandler
),
7433 pPager
->pBusyHandlerArg
,
7434 pPager
->walSyncFlags
, pPager
->pageSize
, (u8
*)pPager
->pTmpSpace
,
7437 sqlite3PagerResetLockTimeout(pPager
);
7442 int sqlite3PagerWalCallback(Pager
*pPager
){
7443 return sqlite3WalCallback(pPager
->pWal
);
7447 ** Return true if the underlying VFS for the given pager supports the
7448 ** primitives necessary for write-ahead logging.
7450 int sqlite3PagerWalSupported(Pager
*pPager
){
7451 const sqlite3_io_methods
*pMethods
= pPager
->fd
->pMethods
;
7452 if( pPager
->noLock
) return 0;
7453 return pPager
->exclusiveMode
|| (pMethods
->iVersion
>=2 && pMethods
->xShmMap
);
7457 ** Attempt to take an exclusive lock on the database file. If a PENDING lock
7458 ** is obtained instead, immediately release it.
7460 static int pagerExclusiveLock(Pager
*pPager
){
7461 int rc
; /* Return code */
7463 assert( pPager
->eLock
==SHARED_LOCK
|| pPager
->eLock
==EXCLUSIVE_LOCK
);
7464 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
7465 if( rc
!=SQLITE_OK
){
7466 /* If the attempt to grab the exclusive lock failed, release the
7467 ** pending lock that may have been obtained instead. */
7468 pagerUnlockDb(pPager
, SHARED_LOCK
);
7475 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
7476 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
7477 ** lock on the database file and use heap-memory to store the wal-index
7478 ** in. Otherwise, use the normal shared-memory.
7480 static int pagerOpenWal(Pager
*pPager
){
7483 assert( pPager
->pWal
==0 && pPager
->tempFile
==0 );
7484 assert( pPager
->eLock
==SHARED_LOCK
|| pPager
->eLock
==EXCLUSIVE_LOCK
);
7486 /* If the pager is already in exclusive-mode, the WAL module will use
7487 ** heap-memory for the wal-index instead of the VFS shared-memory
7488 ** implementation. Take the exclusive lock now, before opening the WAL
7489 ** file, to make sure this is safe.
7491 if( pPager
->exclusiveMode
){
7492 rc
= pagerExclusiveLock(pPager
);
7495 /* Open the connection to the log file. If this operation fails,
7496 ** (e.g. due to malloc() failure), return an error code.
7498 if( rc
==SQLITE_OK
){
7499 rc
= sqlite3WalOpen(pPager
->pVfs
,
7500 pPager
->fd
, pPager
->zWal
, pPager
->exclusiveMode
,
7501 pPager
->journalSizeLimit
, &pPager
->pWal
7504 pagerFixMaplimit(pPager
);
7511 ** The caller must be holding a SHARED lock on the database file to call
7514 ** If the pager passed as the first argument is open on a real database
7515 ** file (not a temp file or an in-memory database), and the WAL file
7516 ** is not already open, make an attempt to open it now. If successful,
7517 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
7518 ** not support the xShmXXX() methods, return an error code. *pbOpen is
7519 ** not modified in either case.
7521 ** If the pager is open on a temp-file (or in-memory database), or if
7522 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
7523 ** without doing anything.
7525 int sqlite3PagerOpenWal(
7526 Pager
*pPager
, /* Pager object */
7527 int *pbOpen
/* OUT: Set to true if call is a no-op */
7529 int rc
= SQLITE_OK
; /* Return code */
7531 assert( assert_pager_state(pPager
) );
7532 assert( pPager
->eState
==PAGER_OPEN
|| pbOpen
);
7533 assert( pPager
->eState
==PAGER_READER
|| !pbOpen
);
7534 assert( pbOpen
==0 || *pbOpen
==0 );
7535 assert( pbOpen
!=0 || (!pPager
->tempFile
&& !pPager
->pWal
) );
7537 if( !pPager
->tempFile
&& !pPager
->pWal
){
7538 if( !sqlite3PagerWalSupported(pPager
) ) return SQLITE_CANTOPEN
;
7540 /* Close any rollback journal previously open */
7541 sqlite3OsClose(pPager
->jfd
);
7543 rc
= pagerOpenWal(pPager
);
7544 if( rc
==SQLITE_OK
){
7545 pPager
->journalMode
= PAGER_JOURNALMODE_WAL
;
7546 pPager
->eState
= PAGER_OPEN
;
7556 ** This function is called to close the connection to the log file prior
7557 ** to switching from WAL to rollback mode.
7559 ** Before closing the log file, this function attempts to take an
7560 ** EXCLUSIVE lock on the database file. If this cannot be obtained, an
7561 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
7562 ** If successful, the EXCLUSIVE lock is not released before returning.
7564 int sqlite3PagerCloseWal(Pager
*pPager
, sqlite3
*db
){
7567 assert( pPager
->journalMode
==PAGER_JOURNALMODE_WAL
);
7569 /* If the log file is not already open, but does exist in the file-system,
7570 ** it may need to be checkpointed before the connection can switch to
7571 ** rollback mode. Open it now so this can happen.
7573 if( !pPager
->pWal
){
7575 rc
= pagerLockDb(pPager
, SHARED_LOCK
);
7576 if( rc
==SQLITE_OK
){
7577 rc
= sqlite3OsAccess(
7578 pPager
->pVfs
, pPager
->zWal
, SQLITE_ACCESS_EXISTS
, &logexists
7581 if( rc
==SQLITE_OK
&& logexists
){
7582 rc
= pagerOpenWal(pPager
);
7586 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
7587 ** the database file, the log and log-summary files will be deleted.
7589 if( rc
==SQLITE_OK
&& pPager
->pWal
){
7590 rc
= pagerExclusiveLock(pPager
);
7591 if( rc
==SQLITE_OK
){
7592 rc
= sqlite3WalClose(pPager
->pWal
, db
, pPager
->walSyncFlags
,
7593 pPager
->pageSize
, (u8
*)pPager
->pTmpSpace
);
7595 pagerFixMaplimit(pPager
);
7596 if( rc
&& !pPager
->exclusiveMode
) pagerUnlockDb(pPager
, SHARED_LOCK
);
7602 #ifdef SQLITE_ENABLE_SNAPSHOT
7604 ** If this is a WAL database, obtain a snapshot handle for the snapshot
7605 ** currently open. Otherwise, return an error.
7607 int sqlite3PagerSnapshotGet(Pager
*pPager
, sqlite3_snapshot
**ppSnapshot
){
7608 int rc
= SQLITE_ERROR
;
7610 rc
= sqlite3WalSnapshotGet(pPager
->pWal
, ppSnapshot
);
7616 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
7617 ** read transaction is opened, attempt to read from the snapshot it
7618 ** identifies. If this is not a WAL database, return an error.
7620 int sqlite3PagerSnapshotOpen(Pager
*pPager
, sqlite3_snapshot
*pSnapshot
){
7623 sqlite3WalSnapshotOpen(pPager
->pWal
, pSnapshot
);
7631 ** If this is a WAL database, call sqlite3WalSnapshotRecover(). If this
7632 ** is not a WAL database, return an error.
7634 int sqlite3PagerSnapshotRecover(Pager
*pPager
){
7637 rc
= sqlite3WalSnapshotRecover(pPager
->pWal
);
7643 #endif /* SQLITE_ENABLE_SNAPSHOT */
7644 #endif /* !SQLITE_OMIT_WAL */
7646 #ifdef SQLITE_ENABLE_ZIPVFS
7648 ** A read-lock must be held on the pager when this function is called. If
7649 ** the pager is in WAL mode and the WAL file currently contains one or more
7650 ** frames, return the size in bytes of the page images stored within the
7651 ** WAL frames. Otherwise, if this is not a WAL database or the WAL file
7652 ** is empty, return 0.
7654 int sqlite3PagerWalFramesize(Pager
*pPager
){
7655 assert( pPager
->eState
>=PAGER_READER
);
7656 return sqlite3WalFramesize(pPager
->pWal
);
7660 #endif /* SQLITE_OMIT_DISKIO */