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 super-journal file is used, then all writes to the database file
74 ** are synced prior to the super-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 ** The maximum allowed sector size. 64KiB. If the xSectorsize() method
411 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
412 ** This could conceivably cause corruption following a power failure on
413 ** such a system. This is currently an undocumented limit.
415 #define MAX_SECTOR_SIZE 0x10000
419 ** An instance of the following structure is allocated for each active
420 ** savepoint and statement transaction in the system. All such structures
421 ** are stored in the Pager.aSavepoint[] array, which is allocated and
422 ** resized using sqlite3Realloc().
424 ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
425 ** set to 0. If a journal-header is written into the main journal while
426 ** the savepoint is active, then iHdrOffset is set to the byte offset
427 ** immediately following the last journal record written into the main
428 ** journal before the journal-header. This is required during savepoint
429 ** rollback (see pagerPlaybackSavepoint()).
431 typedef struct PagerSavepoint PagerSavepoint
;
432 struct PagerSavepoint
{
433 i64 iOffset
; /* Starting offset in main journal */
434 i64 iHdrOffset
; /* See above */
435 Bitvec
*pInSavepoint
; /* Set of pages in this savepoint */
436 Pgno nOrig
; /* Original number of pages in file */
437 Pgno iSubRec
; /* Index of first record in sub-journal */
438 int bTruncateOnRelease
; /* If stmt journal may be truncated on RELEASE */
439 #ifndef SQLITE_OMIT_WAL
440 u32 aWalData
[WAL_SAVEPOINT_NDATA
]; /* WAL savepoint context */
445 ** Bits of the Pager.doNotSpill flag. See further description below.
447 #define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */
448 #define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */
449 #define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */
452 ** An open page cache is an instance of struct Pager. A description of
453 ** some of the more important member variables follows:
457 ** The current 'state' of the pager object. See the comment and state
458 ** diagram above for a description of the pager state.
462 ** For a real on-disk database, the current lock held on the database file -
463 ** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
465 ** For a temporary or in-memory database (neither of which require any
466 ** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
467 ** databases always have Pager.exclusiveMode==1, this tricks the pager
468 ** logic into thinking that it already has all the locks it will ever
469 ** need (and no reason to release them).
471 ** In some (obscure) circumstances, this variable may also be set to
472 ** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
477 ** This boolean variable is used to make sure that the change-counter
478 ** (the 4-byte header field at byte offset 24 of the database file) is
479 ** not updated more often than necessary.
481 ** It is set to true when the change-counter field is updated, which
482 ** can only happen if an exclusive lock is held on the database file.
483 ** It is cleared (set to false) whenever an exclusive lock is
484 ** relinquished on the database file. Each time a transaction is committed,
485 ** The changeCountDone flag is inspected. If it is true, the work of
486 ** updating the change-counter is omitted for the current transaction.
488 ** This mechanism means that when running in exclusive mode, a connection
489 ** need only update the change-counter once, for the first transaction
494 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
495 ** (or may not) specify a super-journal name to be written into the
496 ** journal file before it is synced to disk.
498 ** Whether or not a journal file contains a super-journal pointer affects
499 ** the way in which the journal file is finalized after the transaction is
500 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
501 ** If a journal file does not contain a super-journal pointer, it is
502 ** finalized by overwriting the first journal header with zeroes. If
503 ** it does contain a super-journal pointer the journal file is finalized
504 ** by truncating it to zero bytes, just as if the connection were
505 ** running in "journal_mode=truncate" mode.
507 ** Journal files that contain super-journal pointers cannot be finalized
508 ** simply by overwriting the first journal-header with zeroes, as the
509 ** super-journal pointer could interfere with hot-journal rollback of any
510 ** subsequently interrupted transaction that reuses the journal file.
512 ** The flag is cleared as soon as the journal file is finalized (either
513 ** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
514 ** journal file from being successfully finalized, the setSuper flag
515 ** is cleared anyway (and the pager will move to ERROR state).
519 ** This variables control the behavior of cache-spills (calls made by
520 ** the pcache module to the pagerStress() routine to write cached data
521 ** to the file-system in order to free up memory).
523 ** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
524 ** writing to the database from pagerStress() is disabled altogether.
525 ** The SPILLFLAG_ROLLBACK case is done in a very obscure case that
526 ** comes up during savepoint rollback that requires the pcache module
527 ** to allocate a new page to prevent the journal file from being written
528 ** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
529 ** case is a user preference.
531 ** If the SPILLFLAG_NOSYNC bit is set, writing to the database from
532 ** pagerStress() is permitted, but syncing the journal file is not.
533 ** This flag is set by sqlite3PagerWrite() when the file-system sector-size
534 ** is larger than the database page-size in order to prevent a journal sync
535 ** from happening in between the journalling of two pages on the same sector.
539 ** This is a boolean variable. If true, then any required sub-journal
540 ** is opened as an in-memory journal file. If false, then in-memory
541 ** sub-journals are only used for in-memory pager files.
543 ** This variable is updated by the upper layer each time a new
544 ** write-transaction is opened.
546 ** dbSize, dbOrigSize, dbFileSize
548 ** Variable dbSize is set to the number of pages in the database file.
549 ** It is valid in PAGER_READER and higher states (all states except for
552 ** dbSize is set based on the size of the database file, which may be
553 ** larger than the size of the database (the value stored at offset
554 ** 28 of the database header by the btree). If the size of the file
555 ** is not an integer multiple of the page-size, the value stored in
556 ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
557 ** Except, any file that is greater than 0 bytes in size is considered
558 ** to have at least one page. (i.e. a 1KB file with 2K page-size leads
561 ** During a write-transaction, if pages with page-numbers greater than
562 ** dbSize are modified in the cache, dbSize is updated accordingly.
563 ** Similarly, if the database is truncated using PagerTruncateImage(),
564 ** dbSize is updated.
566 ** Variables dbOrigSize and dbFileSize are valid in states
567 ** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
568 ** variable at the start of the transaction. It is used during rollback,
569 ** and to determine whether or not pages need to be journalled before
572 ** Throughout a write-transaction, dbFileSize contains the size of
573 ** the file on disk in pages. It is set to a copy of dbSize when the
574 ** write-transaction is first opened, and updated when VFS calls are made
575 ** to write or truncate the database file on disk.
577 ** The only reason the dbFileSize variable is required is to suppress
578 ** unnecessary calls to xTruncate() after committing a transaction. If,
579 ** when a transaction is committed, the dbFileSize variable indicates
580 ** that the database file is larger than the database image (Pager.dbSize),
581 ** pager_truncate() is called. The pager_truncate() call uses xFilesize()
582 ** to measure the database file on disk, and then truncates it if required.
583 ** dbFileSize is not used when rolling back a transaction. In this case
584 ** pager_truncate() is called unconditionally (which means there may be
585 ** a call to xFilesize() that is not strictly required). In either case,
586 ** pager_truncate() may cause the file to become smaller or larger.
590 ** The dbHintSize variable is used to limit the number of calls made to
591 ** the VFS xFileControl(FCNTL_SIZE_HINT) method.
593 ** dbHintSize is set to a copy of the dbSize variable when a
594 ** write-transaction is opened (at the same time as dbFileSize and
595 ** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
596 ** dbHintSize is increased to the number of pages that correspond to the
597 ** size-hint passed to the method call. See pager_write_pagelist() for
602 ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
603 ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
604 ** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
607 ** syncFlags, walSyncFlags
609 ** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03).
610 ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
611 ** and contains the flags used to sync the checkpoint operations in the
612 ** lower two bits, and sync flags used for transaction commits in the WAL
613 ** file in bits 0x04 and 0x08. In other words, to get the correct sync flags
614 ** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct
615 ** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note
616 ** that with synchronous=NORMAL in WAL mode, transaction commit is not synced
617 ** meaning that the 0x04 and 0x08 bits are both zero.
620 sqlite3_vfs
*pVfs
; /* OS functions to use for IO */
621 u8 exclusiveMode
; /* Boolean. True if locking_mode==EXCLUSIVE */
622 u8 journalMode
; /* One of the PAGER_JOURNALMODE_* values */
623 u8 useJournal
; /* Use a rollback journal on this file */
624 u8 noSync
; /* Do not sync the journal if true */
625 u8 fullSync
; /* Do extra syncs of the journal for robustness */
626 u8 extraSync
; /* sync directory after journal delete */
627 u8 syncFlags
; /* SYNC_NORMAL or SYNC_FULL otherwise */
628 u8 walSyncFlags
; /* See description above */
629 u8 tempFile
; /* zFilename is a temporary or immutable file */
630 u8 noLock
; /* Do not lock (except in WAL mode) */
631 u8 readOnly
; /* True for a read-only database */
632 u8 memDb
; /* True to inhibit all file I/O */
633 u8 memVfs
; /* VFS-implemented memory database */
635 /**************************************************************************
636 ** The following block contains those class members that change during
637 ** routine operation. Class members not in this block are either fixed
638 ** when the pager is first created or else only change when there is a
639 ** significant mode change (such as changing the page_size, locking_mode,
640 ** or the journal_mode). From another view, these class members describe
641 ** the "state" of the pager, while other class members describe the
642 ** "configuration" of the pager.
644 u8 eState
; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
645 u8 eLock
; /* Current lock held on database file */
646 u8 changeCountDone
; /* Set after incrementing the change-counter */
647 u8 setSuper
; /* Super-jrnl name is written into jrnl */
648 u8 doNotSpill
; /* Do not spill the cache when non-zero */
649 u8 subjInMemory
; /* True to use in-memory sub-journals */
650 u8 bUseFetch
; /* True to use xFetch() */
651 u8 hasHeldSharedLock
; /* True if a shared lock has ever been held */
652 Pgno dbSize
; /* Number of pages in the database */
653 Pgno dbOrigSize
; /* dbSize before the current transaction */
654 Pgno dbFileSize
; /* Number of pages in the database file */
655 Pgno dbHintSize
; /* Value passed to FCNTL_SIZE_HINT call */
656 int errCode
; /* One of several kinds of errors */
657 int nRec
; /* Pages journalled since last j-header written */
658 u32 cksumInit
; /* Quasi-random value added to every checksum */
659 u32 nSubRec
; /* Number of records written to sub-journal */
660 Bitvec
*pInJournal
; /* One bit for each page in the database file */
661 sqlite3_file
*fd
; /* File descriptor for database */
662 sqlite3_file
*jfd
; /* File descriptor for main journal */
663 sqlite3_file
*sjfd
; /* File descriptor for sub-journal */
664 i64 journalOff
; /* Current write offset in the journal file */
665 i64 journalHdr
; /* Byte offset to previous journal header */
666 sqlite3_backup
*pBackup
; /* Pointer to list of ongoing backup processes */
667 PagerSavepoint
*aSavepoint
; /* Array of active savepoints */
668 int nSavepoint
; /* Number of elements in aSavepoint[] */
669 u32 iDataVersion
; /* Changes whenever database content changes */
670 char dbFileVers
[16]; /* Changes whenever database file changes */
672 int nMmapOut
; /* Number of mmap pages currently outstanding */
673 sqlite3_int64 szMmap
; /* Desired maximum mmap size */
674 PgHdr
*pMmapFreelist
; /* List of free mmap page headers (pDirty) */
676 ** End of the routinely-changing class members
677 ***************************************************************************/
679 u16 nExtra
; /* Add this many bytes to each in-memory page */
680 i16 nReserve
; /* Number of unused bytes at end of each page */
681 u32 vfsFlags
; /* Flags for sqlite3_vfs.xOpen() */
682 u32 sectorSize
; /* Assumed sector size during rollback */
683 Pgno mxPgno
; /* Maximum allowed size of the database */
684 i64 pageSize
; /* Number of bytes in a page */
685 i64 journalSizeLimit
; /* Size limit for persistent journal files */
686 char *zFilename
; /* Name of the database file */
687 char *zJournal
; /* Name of the journal file */
688 int (*xBusyHandler
)(void*); /* Function to call when busy */
689 void *pBusyHandlerArg
; /* Context argument for xBusyHandler */
690 int aStat
[4]; /* Total cache hits, misses, writes, spills */
692 int nRead
; /* Database pages read */
694 void (*xReiniter
)(DbPage
*); /* Call this routine when reloading pages */
695 int (*xGet
)(Pager
*,Pgno
,DbPage
**,int); /* Routine to fetch a patch */
696 char *pTmpSpace
; /* Pager.pageSize bytes of space for tmp use */
697 PCache
*pPCache
; /* Pointer to page cache object */
698 #ifndef SQLITE_OMIT_WAL
699 Wal
*pWal
; /* Write-ahead log used by "journal_mode=wal" */
700 char *zWal
; /* File name for write-ahead log */
705 ** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains
706 ** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS
707 ** or CACHE_WRITE to sqlite3_db_status().
709 #define PAGER_STAT_HIT 0
710 #define PAGER_STAT_MISS 1
711 #define PAGER_STAT_WRITE 2
712 #define PAGER_STAT_SPILL 3
715 ** The following global variables hold counters used for
716 ** testing purposes only. These variables do not exist in
717 ** a non-testing build. These variables are not thread-safe.
720 int sqlite3_pager_readdb_count
= 0; /* Number of full pages read from DB */
721 int sqlite3_pager_writedb_count
= 0; /* Number of full pages written to DB */
722 int sqlite3_pager_writej_count
= 0; /* Number of pages written to journal */
723 # define PAGER_INCR(v) v++
725 # define PAGER_INCR(v)
731 ** Journal files begin with the following magic string. The data
732 ** was obtained from /dev/random. It is used only as a sanity check.
734 ** Since version 2.8.0, the journal format contains additional sanity
735 ** checking information. If the power fails while the journal is being
736 ** written, semi-random garbage data might appear in the journal
737 ** file after power is restored. If an attempt is then made
738 ** to roll the journal back, the database could be corrupted. The additional
739 ** sanity checking data is an attempt to discover the garbage in the
740 ** journal and ignore it.
742 ** The sanity checking information for the new journal format consists
743 ** of a 32-bit checksum on each page of data. The checksum covers both
744 ** the page number and the pPager->pageSize bytes of data for the page.
745 ** This cksum is initialized to a 32-bit random value that appears in the
746 ** journal file right after the header. The random initializer is important,
747 ** because garbage data that appears at the end of a journal is likely
748 ** data that was once in other files that have now been deleted. If the
749 ** garbage data came from an obsolete journal file, the checksums might
750 ** be correct. But by initializing the checksum to random value which
751 ** is different for every journal, we minimize that risk.
753 static const unsigned char aJournalMagic
[] = {
754 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
758 ** The size of the of each page record in the journal is given by
759 ** the following macro.
761 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
764 ** The journal header size for this pager. This is usually the same
765 ** size as a single disk sector. See also setSectorSize().
767 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
770 ** The macro MEMDB is true if we are dealing with an in-memory database.
771 ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
772 ** the value of MEMDB will be a constant and the compiler will optimize
773 ** out code that would never execute.
775 #ifdef SQLITE_OMIT_MEMORYDB
778 # define MEMDB pPager->memDb
782 ** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
783 ** interfaces to access the database using memory-mapped I/O.
785 #if SQLITE_MAX_MMAP_SIZE>0
786 # define USEFETCH(x) ((x)->bUseFetch)
788 # define USEFETCH(x) 0
792 ** The argument to this macro is a file descriptor (type sqlite3_file*).
793 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
795 ** This is so that expressions can be written as:
797 ** if( isOpen(pPager->jfd) ){ ...
801 ** if( pPager->jfd->pMethods ){ ...
803 #define isOpen(pFd) ((pFd)->pMethods!=0)
805 #ifdef SQLITE_DIRECT_OVERFLOW_READ
807 ** Return true if page pgno can be read directly from the database file
808 ** by the b-tree layer. This is the case if:
810 ** * the database file is open,
811 ** * there are no dirty pages in the cache, and
812 ** * the desired page is not currently in the wal file.
814 int sqlite3PagerDirectReadOk(Pager
*pPager
, Pgno pgno
){
815 if( pPager
->fd
->pMethods
==0 ) return 0;
816 if( sqlite3PCacheIsDirty(pPager
->pPCache
) ) return 0;
817 #ifndef SQLITE_OMIT_WAL
821 rc
= sqlite3WalFindFrame(pPager
->pWal
, pgno
, &iRead
);
822 return (rc
==SQLITE_OK
&& iRead
==0);
829 #ifndef SQLITE_OMIT_WAL
830 # define pagerUseWal(x) ((x)->pWal!=0)
832 # define pagerUseWal(x) 0
833 # define pagerRollbackWal(x) 0
834 # define pagerWalFrames(v,w,x,y) 0
835 # define pagerOpenWalIfPresent(z) SQLITE_OK
836 # define pagerBeginReadTransaction(z) SQLITE_OK
843 ** assert( assert_pager_state(pPager) );
845 ** This function runs many asserts to try to find inconsistencies in
846 ** the internal state of the Pager object.
848 static int assert_pager_state(Pager
*p
){
851 /* State must be valid. */
852 assert( p
->eState
==PAGER_OPEN
853 || p
->eState
==PAGER_READER
854 || p
->eState
==PAGER_WRITER_LOCKED
855 || p
->eState
==PAGER_WRITER_CACHEMOD
856 || p
->eState
==PAGER_WRITER_DBMOD
857 || p
->eState
==PAGER_WRITER_FINISHED
858 || p
->eState
==PAGER_ERROR
861 /* Regardless of the current state, a temp-file connection always behaves
862 ** as if it has an exclusive lock on the database file. It never updates
863 ** the change-counter field, so the changeCountDone flag is always set.
865 assert( p
->tempFile
==0 || p
->eLock
==EXCLUSIVE_LOCK
);
866 assert( p
->tempFile
==0 || pPager
->changeCountDone
);
868 /* If the useJournal flag is clear, the journal-mode must be "OFF".
869 ** And if the journal-mode is "OFF", the journal file must not be open.
871 assert( p
->journalMode
==PAGER_JOURNALMODE_OFF
|| p
->useJournal
);
872 assert( p
->journalMode
!=PAGER_JOURNALMODE_OFF
|| !isOpen(p
->jfd
) );
874 /* Check that MEMDB implies noSync. And an in-memory journal. Since
875 ** this means an in-memory pager performs no IO at all, it cannot encounter
876 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
877 ** a journal file. (although the in-memory journal implementation may
878 ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
879 ** is therefore not possible for an in-memory pager to enter the ERROR
883 assert( !isOpen(p
->fd
) );
885 assert( p
->journalMode
==PAGER_JOURNALMODE_OFF
886 || p
->journalMode
==PAGER_JOURNALMODE_MEMORY
888 assert( p
->eState
!=PAGER_ERROR
&& p
->eState
!=PAGER_OPEN
);
889 assert( pagerUseWal(p
)==0 );
892 /* If changeCountDone is set, a RESERVED lock or greater must be held
895 assert( pPager
->changeCountDone
==0 || pPager
->eLock
>=RESERVED_LOCK
);
896 assert( p
->eLock
!=PENDING_LOCK
);
901 assert( pPager
->errCode
==SQLITE_OK
);
902 assert( sqlite3PcacheRefCount(pPager
->pPCache
)==0 || pPager
->tempFile
);
906 assert( pPager
->errCode
==SQLITE_OK
);
907 assert( p
->eLock
!=UNKNOWN_LOCK
);
908 assert( p
->eLock
>=SHARED_LOCK
);
911 case PAGER_WRITER_LOCKED
:
912 assert( p
->eLock
!=UNKNOWN_LOCK
);
913 assert( pPager
->errCode
==SQLITE_OK
);
914 if( !pagerUseWal(pPager
) ){
915 assert( p
->eLock
>=RESERVED_LOCK
);
917 assert( pPager
->dbSize
==pPager
->dbOrigSize
);
918 assert( pPager
->dbOrigSize
==pPager
->dbFileSize
);
919 assert( pPager
->dbOrigSize
==pPager
->dbHintSize
);
920 assert( pPager
->setSuper
==0 );
923 case PAGER_WRITER_CACHEMOD
:
924 assert( p
->eLock
!=UNKNOWN_LOCK
);
925 assert( pPager
->errCode
==SQLITE_OK
);
926 if( !pagerUseWal(pPager
) ){
927 /* It is possible that if journal_mode=wal here that neither the
928 ** journal file nor the WAL file are open. This happens during
929 ** a rollback transaction that switches from journal_mode=off
930 ** to journal_mode=wal.
932 assert( p
->eLock
>=RESERVED_LOCK
);
933 assert( isOpen(p
->jfd
)
934 || p
->journalMode
==PAGER_JOURNALMODE_OFF
935 || p
->journalMode
==PAGER_JOURNALMODE_WAL
938 assert( pPager
->dbOrigSize
==pPager
->dbFileSize
);
939 assert( pPager
->dbOrigSize
==pPager
->dbHintSize
);
942 case PAGER_WRITER_DBMOD
:
943 assert( p
->eLock
==EXCLUSIVE_LOCK
);
944 assert( pPager
->errCode
==SQLITE_OK
);
945 assert( !pagerUseWal(pPager
) );
946 assert( p
->eLock
>=EXCLUSIVE_LOCK
);
947 assert( isOpen(p
->jfd
)
948 || p
->journalMode
==PAGER_JOURNALMODE_OFF
949 || p
->journalMode
==PAGER_JOURNALMODE_WAL
950 || (sqlite3OsDeviceCharacteristics(p
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
952 assert( pPager
->dbOrigSize
<=pPager
->dbHintSize
);
955 case PAGER_WRITER_FINISHED
:
956 assert( p
->eLock
==EXCLUSIVE_LOCK
);
957 assert( pPager
->errCode
==SQLITE_OK
);
958 assert( !pagerUseWal(pPager
) );
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
)
967 /* There must be at least one outstanding reference to the pager if
968 ** in ERROR state. Otherwise the pager should have already dropped
969 ** back to OPEN state.
971 assert( pPager
->errCode
!=SQLITE_OK
);
972 assert( sqlite3PcacheRefCount(pPager
->pPCache
)>0 || pPager
->tempFile
);
978 #endif /* ifndef NDEBUG */
982 ** Return a pointer to a human readable string in a static buffer
983 ** containing the state of the Pager object passed as an argument. This
984 ** is intended to be used within debuggers. For example, as an alternative
985 ** to "print *pPager" in gdb:
987 ** (gdb) printf "%s", print_pager_state(pPager)
989 ** This routine has external linkage in order to suppress compiler warnings
990 ** about an unused function. It is enclosed within SQLITE_DEBUG and so does
991 ** not appear in normal builds.
993 char *print_pager_state(Pager
*p
){
994 static char zRet
[1024];
996 sqlite3_snprintf(1024, zRet
,
998 "State: %s errCode=%d\n"
1000 "Locking mode: locking_mode=%s\n"
1001 "Journal mode: journal_mode=%s\n"
1002 "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
1003 "Journal: journalOff=%lld journalHdr=%lld\n"
1004 "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
1006 , p
->eState
==PAGER_OPEN
? "OPEN" :
1007 p
->eState
==PAGER_READER
? "READER" :
1008 p
->eState
==PAGER_WRITER_LOCKED
? "WRITER_LOCKED" :
1009 p
->eState
==PAGER_WRITER_CACHEMOD
? "WRITER_CACHEMOD" :
1010 p
->eState
==PAGER_WRITER_DBMOD
? "WRITER_DBMOD" :
1011 p
->eState
==PAGER_WRITER_FINISHED
? "WRITER_FINISHED" :
1012 p
->eState
==PAGER_ERROR
? "ERROR" : "?error?"
1014 , p
->eLock
==NO_LOCK
? "NO_LOCK" :
1015 p
->eLock
==RESERVED_LOCK
? "RESERVED" :
1016 p
->eLock
==EXCLUSIVE_LOCK
? "EXCLUSIVE" :
1017 p
->eLock
==SHARED_LOCK
? "SHARED" :
1018 p
->eLock
==UNKNOWN_LOCK
? "UNKNOWN" : "?error?"
1019 , p
->exclusiveMode
? "exclusive" : "normal"
1020 , p
->journalMode
==PAGER_JOURNALMODE_MEMORY
? "memory" :
1021 p
->journalMode
==PAGER_JOURNALMODE_OFF
? "off" :
1022 p
->journalMode
==PAGER_JOURNALMODE_DELETE
? "delete" :
1023 p
->journalMode
==PAGER_JOURNALMODE_PERSIST
? "persist" :
1024 p
->journalMode
==PAGER_JOURNALMODE_TRUNCATE
? "truncate" :
1025 p
->journalMode
==PAGER_JOURNALMODE_WAL
? "wal" : "?error?"
1026 , (int)p
->tempFile
, (int)p
->memDb
, (int)p
->useJournal
1027 , p
->journalOff
, p
->journalHdr
1028 , (int)p
->dbSize
, (int)p
->dbOrigSize
, (int)p
->dbFileSize
1035 /* Forward references to the various page getters */
1036 static int getPageNormal(Pager
*,Pgno
,DbPage
**,int);
1037 static int getPageError(Pager
*,Pgno
,DbPage
**,int);
1038 #if SQLITE_MAX_MMAP_SIZE>0
1039 static int getPageMMap(Pager
*,Pgno
,DbPage
**,int);
1043 ** Set the Pager.xGet method for the appropriate routine used to fetch
1044 ** content from the pager.
1046 static void setGetterMethod(Pager
*pPager
){
1047 if( pPager
->errCode
){
1048 pPager
->xGet
= getPageError
;
1049 #if SQLITE_MAX_MMAP_SIZE>0
1050 }else if( USEFETCH(pPager
) ){
1051 pPager
->xGet
= getPageMMap
;
1052 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
1054 pPager
->xGet
= getPageNormal
;
1059 ** Return true if it is necessary to write page *pPg into the sub-journal.
1060 ** A page needs to be written into the sub-journal if there exists one
1061 ** or more open savepoints for which:
1063 ** * The page-number is less than or equal to PagerSavepoint.nOrig, and
1064 ** * The bit corresponding to the page-number is not set in
1065 ** PagerSavepoint.pInSavepoint.
1067 static int subjRequiresPage(PgHdr
*pPg
){
1068 Pager
*pPager
= pPg
->pPager
;
1070 Pgno pgno
= pPg
->pgno
;
1072 for(i
=0; i
<pPager
->nSavepoint
; i
++){
1073 p
= &pPager
->aSavepoint
[i
];
1074 if( p
->nOrig
>=pgno
&& 0==sqlite3BitvecTestNotNull(p
->pInSavepoint
, pgno
) ){
1075 for(i
=i
+1; i
<pPager
->nSavepoint
; i
++){
1076 pPager
->aSavepoint
[i
].bTruncateOnRelease
= 0;
1086 ** Return true if the page is already in the journal file.
1088 static int pageInJournal(Pager
*pPager
, PgHdr
*pPg
){
1089 return sqlite3BitvecTest(pPager
->pInJournal
, pPg
->pgno
);
1094 ** Read a 32-bit integer from the given file descriptor. Store the integer
1095 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
1096 ** error code is something goes wrong.
1098 ** All values are stored on disk as big-endian.
1100 static int read32bits(sqlite3_file
*fd
, i64 offset
, u32
*pRes
){
1101 unsigned char ac
[4];
1102 int rc
= sqlite3OsRead(fd
, ac
, sizeof(ac
), offset
);
1103 if( rc
==SQLITE_OK
){
1104 *pRes
= sqlite3Get4byte(ac
);
1110 ** Write a 32-bit integer into a string buffer in big-endian byte order.
1112 #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
1116 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
1117 ** on success or an error code is something goes wrong.
1119 static int write32bits(sqlite3_file
*fd
, i64 offset
, u32 val
){
1122 return sqlite3OsWrite(fd
, ac
, 4, offset
);
1126 ** Unlock the database file to level eLock, which must be either NO_LOCK
1127 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
1128 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
1130 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1131 ** called, do not modify it. See the comment above the #define of
1132 ** UNKNOWN_LOCK for an explanation of this.
1134 static int pagerUnlockDb(Pager
*pPager
, int eLock
){
1137 assert( !pPager
->exclusiveMode
|| pPager
->eLock
==eLock
);
1138 assert( eLock
==NO_LOCK
|| eLock
==SHARED_LOCK
);
1139 assert( eLock
!=NO_LOCK
|| pagerUseWal(pPager
)==0 );
1140 if( isOpen(pPager
->fd
) ){
1141 assert( pPager
->eLock
>=eLock
);
1142 rc
= pPager
->noLock
? SQLITE_OK
: sqlite3OsUnlock(pPager
->fd
, eLock
);
1143 if( pPager
->eLock
!=UNKNOWN_LOCK
){
1144 pPager
->eLock
= (u8
)eLock
;
1146 IOTRACE(("UNLOCK %p %d\n", pPager
, eLock
))
1148 pPager
->changeCountDone
= pPager
->tempFile
; /* ticket fb3b3024ea238d5c */
1153 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
1154 ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
1155 ** Pager.eLock variable to the new locking state.
1157 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1158 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
1159 ** See the comment above the #define of UNKNOWN_LOCK for an explanation
1162 static int pagerLockDb(Pager
*pPager
, int eLock
){
1165 assert( eLock
==SHARED_LOCK
|| eLock
==RESERVED_LOCK
|| eLock
==EXCLUSIVE_LOCK
);
1166 if( pPager
->eLock
<eLock
|| pPager
->eLock
==UNKNOWN_LOCK
){
1167 rc
= pPager
->noLock
? SQLITE_OK
: sqlite3OsLock(pPager
->fd
, eLock
);
1168 if( rc
==SQLITE_OK
&& (pPager
->eLock
!=UNKNOWN_LOCK
||eLock
==EXCLUSIVE_LOCK
) ){
1169 pPager
->eLock
= (u8
)eLock
;
1170 IOTRACE(("LOCK %p %d\n", pPager
, eLock
))
1177 ** This function determines whether or not the atomic-write or
1178 ** atomic-batch-write optimizations can be used with this pager. The
1179 ** atomic-write optimization can be used if:
1181 ** (a) the value returned by OsDeviceCharacteristics() indicates that
1182 ** a database page may be written atomically, and
1183 ** (b) the value returned by OsSectorSize() is less than or equal
1184 ** to the page size.
1186 ** If it can be used, then the value returned is the size of the journal
1187 ** file when it contains rollback data for exactly one page.
1189 ** The atomic-batch-write optimization can be used if OsDeviceCharacteristics()
1190 ** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
1191 ** returned in this case.
1193 ** If neither optimization can be used, 0 is returned.
1195 static int jrnlBufferSize(Pager
*pPager
){
1198 #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
1199 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
1200 int dc
; /* Device characteristics */
1202 assert( isOpen(pPager
->fd
) );
1203 dc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
1205 UNUSED_PARAMETER(pPager
);
1208 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
1209 if( pPager
->dbSize
>0 && (dc
&SQLITE_IOCAP_BATCH_ATOMIC
) ){
1214 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
1216 int nSector
= pPager
->sectorSize
;
1217 int szPage
= pPager
->pageSize
;
1219 assert(SQLITE_IOCAP_ATOMIC512
==(512>>8));
1220 assert(SQLITE_IOCAP_ATOMIC64K
==(65536>>8));
1221 if( 0==(dc
&(SQLITE_IOCAP_ATOMIC
|(szPage
>>8)) || nSector
>szPage
) ){
1226 return JOURNAL_HDR_SZ(pPager
) + JOURNAL_PG_SZ(pPager
);
1233 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
1234 ** on the cache using a hash function. This is used for testing
1235 ** and debugging only.
1237 #ifdef SQLITE_CHECK_PAGES
1239 ** Return a 32-bit hash of the page data for pPage.
1241 static u32
pager_datahash(int nByte
, unsigned char *pData
){
1244 for(i
=0; i
<nByte
; i
++){
1245 hash
= (hash
*1039) + pData
[i
];
1249 static u32
pager_pagehash(PgHdr
*pPage
){
1250 return pager_datahash(pPage
->pPager
->pageSize
, (unsigned char *)pPage
->pData
);
1252 static void pager_set_pagehash(PgHdr
*pPage
){
1253 pPage
->pageHash
= pager_pagehash(pPage
);
1257 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
1258 ** is defined, and NDEBUG is not defined, an assert() statement checks
1259 ** that the page is either dirty or still matches the calculated page-hash.
1261 #define CHECK_PAGE(x) checkPage(x)
1262 static void checkPage(PgHdr
*pPg
){
1263 Pager
*pPager
= pPg
->pPager
;
1264 assert( pPager
->eState
!=PAGER_ERROR
);
1265 assert( (pPg
->flags
&PGHDR_DIRTY
) || pPg
->pageHash
==pager_pagehash(pPg
) );
1269 #define pager_datahash(X,Y) 0
1270 #define pager_pagehash(X) 0
1271 #define pager_set_pagehash(X)
1272 #define CHECK_PAGE(x)
1273 #endif /* SQLITE_CHECK_PAGES */
1276 ** When this is called the journal file for pager pPager must be open.
1277 ** This function attempts to read a super-journal file name from the
1278 ** end of the file and, if successful, copies it into memory supplied
1279 ** by the caller. See comments above writeSuperJournal() for the format
1280 ** used to store a super-journal file name at the end of a journal file.
1282 ** zSuper must point to a buffer of at least nSuper bytes allocated by
1283 ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
1284 ** enough space to write the super-journal name). If the super-journal
1285 ** name in the journal is longer than nSuper bytes (including a
1286 ** nul-terminator), then this is handled as if no super-journal name
1287 ** were present in the journal.
1289 ** If a super-journal file name is present at the end of the journal
1290 ** file, then it is copied into the buffer pointed to by zSuper. A
1291 ** nul-terminator byte is appended to the buffer following the
1292 ** super-journal file name.
1294 ** If it is determined that no super-journal file name is present
1295 ** zSuper[0] is set to 0 and SQLITE_OK returned.
1297 ** If an error occurs while reading from the journal file, an SQLite
1298 ** error code is returned.
1300 static int readSuperJournal(sqlite3_file
*pJrnl
, char *zSuper
, u32 nSuper
){
1301 int rc
; /* Return code */
1302 u32 len
; /* Length in bytes of super-journal name */
1303 i64 szJ
; /* Total size in bytes of journal file pJrnl */
1304 u32 cksum
; /* MJ checksum value read from journal */
1305 u32 u
; /* Unsigned loop counter */
1306 unsigned char aMagic
[8]; /* A buffer to hold the magic header */
1309 if( SQLITE_OK
!=(rc
= sqlite3OsFileSize(pJrnl
, &szJ
))
1311 || SQLITE_OK
!=(rc
= read32bits(pJrnl
, szJ
-16, &len
))
1315 || SQLITE_OK
!=(rc
= read32bits(pJrnl
, szJ
-12, &cksum
))
1316 || SQLITE_OK
!=(rc
= sqlite3OsRead(pJrnl
, aMagic
, 8, szJ
-8))
1317 || memcmp(aMagic
, aJournalMagic
, 8)
1318 || SQLITE_OK
!=(rc
= sqlite3OsRead(pJrnl
, zSuper
, len
, szJ
-16-len
))
1323 /* See if the checksum matches the super-journal name */
1324 for(u
=0; u
<len
; u
++){
1328 /* If the checksum doesn't add up, then one or more of the disk sectors
1329 ** containing the super-journal filename is corrupted. This means
1330 ** definitely roll back, so just return SQLITE_OK and report a (nul)
1331 ** super-journal filename.
1336 zSuper
[len
+1] = '\0';
1342 ** Return the offset of the sector boundary at or immediately
1343 ** following the value in pPager->journalOff, assuming a sector
1344 ** size of pPager->sectorSize bytes.
1346 ** i.e for a sector size of 512:
1348 ** Pager.journalOff Return value
1349 ** ---------------------------------------
1356 static i64
journalHdrOffset(Pager
*pPager
){
1358 i64 c
= pPager
->journalOff
;
1360 offset
= ((c
-1)/JOURNAL_HDR_SZ(pPager
) + 1) * JOURNAL_HDR_SZ(pPager
);
1362 assert( offset
%JOURNAL_HDR_SZ(pPager
)==0 );
1363 assert( offset
>=c
);
1364 assert( (offset
-c
)<JOURNAL_HDR_SZ(pPager
) );
1369 ** The journal file must be open when this function is called.
1371 ** This function is a no-op if the journal file has not been written to
1372 ** within the current transaction (i.e. if Pager.journalOff==0).
1374 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
1375 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
1376 ** zero the 28-byte header at the start of the journal file. In either case,
1377 ** if the pager is not in no-sync mode, sync the journal file immediately
1378 ** after writing or truncating it.
1380 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
1381 ** following the truncation or zeroing described above the size of the
1382 ** journal file in bytes is larger than this value, then truncate the
1383 ** journal file to Pager.journalSizeLimit bytes. The journal file does
1384 ** not need to be synced following this operation.
1386 ** If an IO error occurs, abandon processing and return the IO error code.
1387 ** Otherwise, return SQLITE_OK.
1389 static int zeroJournalHdr(Pager
*pPager
, int doTruncate
){
1390 int rc
= SQLITE_OK
; /* Return code */
1391 assert( isOpen(pPager
->jfd
) );
1392 assert( !sqlite3JournalIsInMemory(pPager
->jfd
) );
1393 if( pPager
->journalOff
){
1394 const i64 iLimit
= pPager
->journalSizeLimit
; /* Local cache of jsl */
1396 IOTRACE(("JZEROHDR %p\n", pPager
))
1397 if( doTruncate
|| iLimit
==0 ){
1398 rc
= sqlite3OsTruncate(pPager
->jfd
, 0);
1400 static const char zeroHdr
[28] = {0};
1401 rc
= sqlite3OsWrite(pPager
->jfd
, zeroHdr
, sizeof(zeroHdr
), 0);
1403 if( rc
==SQLITE_OK
&& !pPager
->noSync
){
1404 rc
= sqlite3OsSync(pPager
->jfd
, SQLITE_SYNC_DATAONLY
|pPager
->syncFlags
);
1407 /* At this point the transaction is committed but the write lock
1408 ** is still held on the file. If there is a size limit configured for
1409 ** the persistent journal and the journal file currently consumes more
1410 ** space than that limit allows for, truncate it now. There is no need
1411 ** to sync the file following this operation.
1413 if( rc
==SQLITE_OK
&& iLimit
>0 ){
1415 rc
= sqlite3OsFileSize(pPager
->jfd
, &sz
);
1416 if( rc
==SQLITE_OK
&& sz
>iLimit
){
1417 rc
= sqlite3OsTruncate(pPager
->jfd
, iLimit
);
1425 ** The journal file must be open when this routine is called. A journal
1426 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
1427 ** current location.
1429 ** The format for the journal header is as follows:
1430 ** - 8 bytes: Magic identifying journal format.
1431 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
1432 ** - 4 bytes: Random number used for page hash.
1433 ** - 4 bytes: Initial database page count.
1434 ** - 4 bytes: Sector size used by the process that wrote this journal.
1435 ** - 4 bytes: Database page size.
1437 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
1439 static int writeJournalHdr(Pager
*pPager
){
1440 int rc
= SQLITE_OK
; /* Return code */
1441 char *zHeader
= pPager
->pTmpSpace
; /* Temporary space used to build header */
1442 u32 nHeader
= (u32
)pPager
->pageSize
;/* Size of buffer pointed to by zHeader */
1443 u32 nWrite
; /* Bytes of header sector written */
1444 int ii
; /* Loop counter */
1446 assert( isOpen(pPager
->jfd
) ); /* Journal file must be open. */
1448 if( nHeader
>JOURNAL_HDR_SZ(pPager
) ){
1449 nHeader
= JOURNAL_HDR_SZ(pPager
);
1452 /* If there are active savepoints and any of them were created
1453 ** since the most recent journal header was written, update the
1454 ** PagerSavepoint.iHdrOffset fields now.
1456 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1457 if( pPager
->aSavepoint
[ii
].iHdrOffset
==0 ){
1458 pPager
->aSavepoint
[ii
].iHdrOffset
= pPager
->journalOff
;
1462 pPager
->journalHdr
= pPager
->journalOff
= journalHdrOffset(pPager
);
1465 ** Write the nRec Field - the number of page records that follow this
1466 ** journal header. Normally, zero is written to this value at this time.
1467 ** After the records are added to the journal (and the journal synced,
1468 ** if in full-sync mode), the zero is overwritten with the true number
1469 ** of records (see syncJournal()).
1471 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
1472 ** reading the journal this value tells SQLite to assume that the
1473 ** rest of the journal file contains valid page records. This assumption
1474 ** is dangerous, as if a failure occurred whilst writing to the journal
1475 ** file it may contain some garbage data. There are two scenarios
1476 ** where this risk can be ignored:
1478 ** * When the pager is in no-sync mode. Corruption can follow a
1479 ** power failure in this case anyway.
1481 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1482 ** that garbage data is never appended to the journal file.
1484 assert( isOpen(pPager
->fd
) || pPager
->noSync
);
1485 if( pPager
->noSync
|| (pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
)
1486 || (sqlite3OsDeviceCharacteristics(pPager
->fd
)&SQLITE_IOCAP_SAFE_APPEND
)
1488 memcpy(zHeader
, aJournalMagic
, sizeof(aJournalMagic
));
1489 put32bits(&zHeader
[sizeof(aJournalMagic
)], 0xffffffff);
1491 memset(zHeader
, 0, sizeof(aJournalMagic
)+4);
1494 /* The random check-hash initializer */
1495 sqlite3_randomness(sizeof(pPager
->cksumInit
), &pPager
->cksumInit
);
1496 put32bits(&zHeader
[sizeof(aJournalMagic
)+4], pPager
->cksumInit
);
1497 /* The initial database size */
1498 put32bits(&zHeader
[sizeof(aJournalMagic
)+8], pPager
->dbOrigSize
);
1499 /* The assumed sector size for this process */
1500 put32bits(&zHeader
[sizeof(aJournalMagic
)+12], pPager
->sectorSize
);
1503 put32bits(&zHeader
[sizeof(aJournalMagic
)+16], pPager
->pageSize
);
1505 /* Initializing the tail of the buffer is not necessary. Everything
1506 ** works find if the following memset() is omitted. But initializing
1507 ** the memory prevents valgrind from complaining, so we are willing to
1508 ** take the performance hit.
1510 memset(&zHeader
[sizeof(aJournalMagic
)+20], 0,
1511 nHeader
-(sizeof(aJournalMagic
)+20));
1513 /* In theory, it is only necessary to write the 28 bytes that the
1514 ** journal header consumes to the journal file here. Then increment the
1515 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
1516 ** record is written to the following sector (leaving a gap in the file
1517 ** that will be implicitly filled in by the OS).
1519 ** However it has been discovered that on some systems this pattern can
1520 ** be significantly slower than contiguously writing data to the file,
1521 ** even if that means explicitly writing data to the block of
1522 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
1525 ** The loop is required here in case the sector-size is larger than the
1526 ** database page size. Since the zHeader buffer is only Pager.pageSize
1527 ** bytes in size, more than one call to sqlite3OsWrite() may be required
1528 ** to populate the entire journal header sector.
1530 for(nWrite
=0; rc
==SQLITE_OK
&&nWrite
<JOURNAL_HDR_SZ(pPager
); nWrite
+=nHeader
){
1531 IOTRACE(("JHDR %p %lld %d\n", pPager
, pPager
->journalHdr
, nHeader
))
1532 rc
= sqlite3OsWrite(pPager
->jfd
, zHeader
, nHeader
, pPager
->journalOff
);
1533 assert( pPager
->journalHdr
<= pPager
->journalOff
);
1534 pPager
->journalOff
+= nHeader
;
1541 ** The journal file must be open when this is called. A journal header file
1542 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
1543 ** file. The current location in the journal file is given by
1544 ** pPager->journalOff. See comments above function writeJournalHdr() for
1545 ** a description of the journal header format.
1547 ** If the header is read successfully, *pNRec is set to the number of
1548 ** page records following this header and *pDbSize is set to the size of the
1549 ** database before the transaction began, in pages. Also, pPager->cksumInit
1550 ** is set to the value read from the journal header. SQLITE_OK is returned
1553 ** If the journal header file appears to be corrupted, SQLITE_DONE is
1554 ** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
1555 ** cannot be read from the journal file an error code is returned.
1557 static int readJournalHdr(
1558 Pager
*pPager
, /* Pager object */
1560 i64 journalSize
, /* Size of the open journal file in bytes */
1561 u32
*pNRec
, /* OUT: Value read from the nRec field */
1562 u32
*pDbSize
/* OUT: Value of original database size field */
1564 int rc
; /* Return code */
1565 unsigned char aMagic
[8]; /* A buffer to hold the magic header */
1566 i64 iHdrOff
; /* Offset of journal header being read */
1568 assert( isOpen(pPager
->jfd
) ); /* Journal file must be open. */
1570 /* Advance Pager.journalOff to the start of the next sector. If the
1571 ** journal file is too small for there to be a header stored at this
1572 ** point, return SQLITE_DONE.
1574 pPager
->journalOff
= journalHdrOffset(pPager
);
1575 if( pPager
->journalOff
+JOURNAL_HDR_SZ(pPager
) > journalSize
){
1578 iHdrOff
= pPager
->journalOff
;
1580 /* Read in the first 8 bytes of the journal header. If they do not match
1581 ** the magic string found at the start of each journal header, return
1582 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
1585 if( isHot
|| iHdrOff
!=pPager
->journalHdr
){
1586 rc
= sqlite3OsRead(pPager
->jfd
, aMagic
, sizeof(aMagic
), iHdrOff
);
1590 if( memcmp(aMagic
, aJournalMagic
, sizeof(aMagic
))!=0 ){
1595 /* Read the first three 32-bit fields of the journal header: The nRec
1596 ** field, the checksum-initializer and the database size at the start
1597 ** of the transaction. Return an error code if anything goes wrong.
1599 if( SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+8, pNRec
))
1600 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+12, &pPager
->cksumInit
))
1601 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+16, pDbSize
))
1606 if( pPager
->journalOff
==0 ){
1607 u32 iPageSize
; /* Page-size field of journal header */
1608 u32 iSectorSize
; /* Sector-size field of journal header */
1610 /* Read the page-size and sector-size journal header fields. */
1611 if( SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+20, &iSectorSize
))
1612 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+24, &iPageSize
))
1617 /* Versions of SQLite prior to 3.5.8 set the page-size field of the
1618 ** journal header to zero. In this case, assume that the Pager.pageSize
1619 ** variable is already set to the correct page size.
1622 iPageSize
= pPager
->pageSize
;
1625 /* Check that the values read from the page-size and sector-size fields
1626 ** are within range. To be 'in range', both values need to be a power
1627 ** of two greater than or equal to 512 or 32, and not greater than their
1628 ** respective compile time maximum limits.
1630 if( iPageSize
<512 || iSectorSize
<32
1631 || iPageSize
>SQLITE_MAX_PAGE_SIZE
|| iSectorSize
>MAX_SECTOR_SIZE
1632 || ((iPageSize
-1)&iPageSize
)!=0 || ((iSectorSize
-1)&iSectorSize
)!=0
1634 /* If the either the page-size or sector-size in the journal-header is
1635 ** invalid, then the process that wrote the journal-header must have
1636 ** crashed before the header was synced. In this case stop reading
1637 ** the journal file here.
1642 /* Update the page-size to match the value read from the journal.
1643 ** Use a testcase() macro to make sure that malloc failure within
1644 ** PagerSetPagesize() is tested.
1646 rc
= sqlite3PagerSetPagesize(pPager
, &iPageSize
, -1);
1647 testcase( rc
!=SQLITE_OK
);
1649 /* Update the assumed sector-size to match the value used by
1650 ** the process that created this journal. If this journal was
1651 ** created by a process other than this one, then this routine
1652 ** is being called from within pager_playback(). The local value
1653 ** of Pager.sectorSize is restored at the end of that routine.
1655 pPager
->sectorSize
= iSectorSize
;
1658 pPager
->journalOff
+= JOURNAL_HDR_SZ(pPager
);
1664 ** Write the supplied super-journal name into the journal file for pager
1665 ** pPager at the current location. The super-journal name must be the last
1666 ** thing written to a journal file. If the pager is in full-sync mode, the
1667 ** journal file descriptor is advanced to the next sector boundary before
1668 ** anything is written. The format is:
1670 ** + 4 bytes: PAGER_MJ_PGNO.
1671 ** + N bytes: super-journal filename in utf-8.
1672 ** + 4 bytes: N (length of super-journal name in bytes, no nul-terminator).
1673 ** + 4 bytes: super-journal name checksum.
1674 ** + 8 bytes: aJournalMagic[].
1676 ** The super-journal page checksum is the sum of the bytes in thesuper-journal
1677 ** name, where each byte is interpreted as a signed 8-bit integer.
1679 ** If zSuper is a NULL pointer (occurs for a single database transaction),
1680 ** this call is a no-op.
1682 static int writeSuperJournal(Pager
*pPager
, const char *zSuper
){
1683 int rc
; /* Return code */
1684 int nSuper
; /* Length of string zSuper */
1685 i64 iHdrOff
; /* Offset of header in journal file */
1686 i64 jrnlSize
; /* Size of journal file on disk */
1687 u32 cksum
= 0; /* Checksum of string zSuper */
1689 assert( pPager
->setSuper
==0 );
1690 assert( !pagerUseWal(pPager
) );
1693 || pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
1694 || !isOpen(pPager
->jfd
)
1698 pPager
->setSuper
= 1;
1699 assert( pPager
->journalHdr
<= pPager
->journalOff
);
1701 /* Calculate the length in bytes and the checksum of zSuper */
1702 for(nSuper
=0; zSuper
[nSuper
]; nSuper
++){
1703 cksum
+= zSuper
[nSuper
];
1706 /* If in full-sync mode, advance to the next disk sector before writing
1707 ** the super-journal name. This is in case the previous page written to
1708 ** the journal has already been synced.
1710 if( pPager
->fullSync
){
1711 pPager
->journalOff
= journalHdrOffset(pPager
);
1713 iHdrOff
= pPager
->journalOff
;
1715 /* Write the super-journal data to the end of the journal file. If
1716 ** an error occurs, return the error code to the caller.
1718 if( (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
, PAGER_MJ_PGNO(pPager
))))
1719 || (0 != (rc
= sqlite3OsWrite(pPager
->jfd
, zSuper
, nSuper
, iHdrOff
+4)))
1720 || (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
+4+nSuper
, nSuper
)))
1721 || (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
+4+nSuper
+4, cksum
)))
1722 || (0 != (rc
= sqlite3OsWrite(pPager
->jfd
, aJournalMagic
, 8,
1723 iHdrOff
+4+nSuper
+8)))
1727 pPager
->journalOff
+= (nSuper
+20);
1729 /* If the pager is in peristent-journal mode, then the physical
1730 ** journal-file may extend past the end of the super-journal name
1731 ** and 8 bytes of magic data just written to the file. This is
1732 ** dangerous because the code to rollback a hot-journal file
1733 ** will not be able to find the super-journal name to determine
1734 ** whether or not the journal is hot.
1736 ** Easiest thing to do in this scenario is to truncate the journal
1737 ** file to the required size.
1739 if( SQLITE_OK
==(rc
= sqlite3OsFileSize(pPager
->jfd
, &jrnlSize
))
1740 && jrnlSize
>pPager
->journalOff
1742 rc
= sqlite3OsTruncate(pPager
->jfd
, pPager
->journalOff
);
1748 ** Discard the entire contents of the in-memory page-cache.
1750 static void pager_reset(Pager
*pPager
){
1751 pPager
->iDataVersion
++;
1752 sqlite3BackupRestart(pPager
->pBackup
);
1753 sqlite3PcacheClear(pPager
->pPCache
);
1757 ** Return the pPager->iDataVersion value
1759 u32
sqlite3PagerDataVersion(Pager
*pPager
){
1760 return pPager
->iDataVersion
;
1764 ** Free all structures in the Pager.aSavepoint[] array and set both
1765 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1766 ** if it is open and the pager is not in exclusive mode.
1768 static void releaseAllSavepoints(Pager
*pPager
){
1769 int ii
; /* Iterator for looping through Pager.aSavepoint */
1770 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1771 sqlite3BitvecDestroy(pPager
->aSavepoint
[ii
].pInSavepoint
);
1773 if( !pPager
->exclusiveMode
|| sqlite3JournalIsInMemory(pPager
->sjfd
) ){
1774 sqlite3OsClose(pPager
->sjfd
);
1776 sqlite3_free(pPager
->aSavepoint
);
1777 pPager
->aSavepoint
= 0;
1778 pPager
->nSavepoint
= 0;
1779 pPager
->nSubRec
= 0;
1783 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1784 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
1785 ** or SQLITE_NOMEM if a malloc failure occurs.
1787 static int addToSavepointBitvecs(Pager
*pPager
, Pgno pgno
){
1788 int ii
; /* Loop counter */
1789 int rc
= SQLITE_OK
; /* Result code */
1791 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1792 PagerSavepoint
*p
= &pPager
->aSavepoint
[ii
];
1793 if( pgno
<=p
->nOrig
){
1794 rc
|= sqlite3BitvecSet(p
->pInSavepoint
, pgno
);
1795 testcase( rc
==SQLITE_NOMEM
);
1796 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
1803 ** This function is a no-op if the pager is in exclusive mode and not
1804 ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
1807 ** If the pager is not in exclusive-access mode, the database file is
1808 ** completely unlocked. If the file is unlocked and the file-system does
1809 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
1810 ** closed (if it is open).
1812 ** If the pager is in ERROR state when this function is called, the
1813 ** contents of the pager cache are discarded before switching back to
1814 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
1815 ** or not, any journal file left in the file-system will be treated
1816 ** as a hot-journal and rolled back the next time a read-transaction
1817 ** is opened (by this or by any other connection).
1819 static void pager_unlock(Pager
*pPager
){
1821 assert( pPager
->eState
==PAGER_READER
1822 || pPager
->eState
==PAGER_OPEN
1823 || pPager
->eState
==PAGER_ERROR
1826 sqlite3BitvecDestroy(pPager
->pInJournal
);
1827 pPager
->pInJournal
= 0;
1828 releaseAllSavepoints(pPager
);
1830 if( pagerUseWal(pPager
) ){
1831 assert( !isOpen(pPager
->jfd
) );
1832 sqlite3WalEndReadTransaction(pPager
->pWal
);
1833 pPager
->eState
= PAGER_OPEN
;
1834 }else if( !pPager
->exclusiveMode
){
1835 int rc
; /* Error code returned by pagerUnlockDb() */
1836 int iDc
= isOpen(pPager
->fd
)?sqlite3OsDeviceCharacteristics(pPager
->fd
):0;
1838 /* If the operating system support deletion of open files, then
1839 ** close the journal file when dropping the database lock. Otherwise
1840 ** another connection with journal_mode=delete might delete the file
1841 ** out from under us.
1843 assert( (PAGER_JOURNALMODE_MEMORY
& 5)!=1 );
1844 assert( (PAGER_JOURNALMODE_OFF
& 5)!=1 );
1845 assert( (PAGER_JOURNALMODE_WAL
& 5)!=1 );
1846 assert( (PAGER_JOURNALMODE_DELETE
& 5)!=1 );
1847 assert( (PAGER_JOURNALMODE_TRUNCATE
& 5)==1 );
1848 assert( (PAGER_JOURNALMODE_PERSIST
& 5)==1 );
1849 if( 0==(iDc
& SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
)
1850 || 1!=(pPager
->journalMode
& 5)
1852 sqlite3OsClose(pPager
->jfd
);
1855 /* If the pager is in the ERROR state and the call to unlock the database
1856 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
1857 ** above the #define for UNKNOWN_LOCK for an explanation of why this
1860 rc
= pagerUnlockDb(pPager
, NO_LOCK
);
1861 if( rc
!=SQLITE_OK
&& pPager
->eState
==PAGER_ERROR
){
1862 pPager
->eLock
= UNKNOWN_LOCK
;
1865 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
1866 ** without clearing the error code. This is intentional - the error
1867 ** code is cleared and the cache reset in the block below.
1869 assert( pPager
->errCode
|| pPager
->eState
!=PAGER_ERROR
);
1870 pPager
->eState
= PAGER_OPEN
;
1873 /* If Pager.errCode is set, the contents of the pager cache cannot be
1874 ** trusted. Now that there are no outstanding references to the pager,
1875 ** it can safely move back to PAGER_OPEN state. This happens in both
1876 ** normal and exclusive-locking mode.
1878 assert( pPager
->errCode
==SQLITE_OK
|| !MEMDB
);
1879 if( pPager
->errCode
){
1880 if( pPager
->tempFile
==0 ){
1881 pager_reset(pPager
);
1882 pPager
->changeCountDone
= 0;
1883 pPager
->eState
= PAGER_OPEN
;
1885 pPager
->eState
= (isOpen(pPager
->jfd
) ? PAGER_OPEN
: PAGER_READER
);
1887 if( USEFETCH(pPager
) ) sqlite3OsUnfetch(pPager
->fd
, 0, 0);
1888 pPager
->errCode
= SQLITE_OK
;
1889 setGetterMethod(pPager
);
1892 pPager
->journalOff
= 0;
1893 pPager
->journalHdr
= 0;
1894 pPager
->setSuper
= 0;
1898 ** This function is called whenever an IOERR or FULL error that requires
1899 ** the pager to transition into the ERROR state may ahve occurred.
1900 ** The first argument is a pointer to the pager structure, the second
1901 ** the error-code about to be returned by a pager API function. The
1902 ** value returned is a copy of the second argument to this function.
1904 ** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
1905 ** IOERR sub-codes, the pager enters the ERROR state and the error code
1906 ** is stored in Pager.errCode. While the pager remains in the ERROR state,
1907 ** all major API calls on the Pager will immediately return Pager.errCode.
1909 ** The ERROR state indicates that the contents of the pager-cache
1910 ** cannot be trusted. This state can be cleared by completely discarding
1911 ** the contents of the pager-cache. If a transaction was active when
1912 ** the persistent error occurred, then the rollback journal may need
1913 ** to be replayed to restore the contents of the database file (as if
1914 ** it were a hot-journal).
1916 static int pager_error(Pager
*pPager
, int rc
){
1917 int rc2
= rc
& 0xff;
1918 assert( rc
==SQLITE_OK
|| !MEMDB
);
1920 pPager
->errCode
==SQLITE_FULL
||
1921 pPager
->errCode
==SQLITE_OK
||
1922 (pPager
->errCode
& 0xff)==SQLITE_IOERR
1924 if( rc2
==SQLITE_FULL
|| rc2
==SQLITE_IOERR
){
1925 pPager
->errCode
= rc
;
1926 pPager
->eState
= PAGER_ERROR
;
1927 setGetterMethod(pPager
);
1932 static int pager_truncate(Pager
*pPager
, Pgno nPage
);
1935 ** The write transaction open on pPager is being committed (bCommit==1)
1936 ** or rolled back (bCommit==0).
1938 ** Return TRUE if and only if all dirty pages should be flushed to disk.
1942 ** * For non-TEMP databases, always sync to disk. This is necessary
1943 ** for transactions to be durable.
1945 ** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing
1946 ** file has been created already (via a spill on pagerStress()) and
1947 ** when the number of dirty pages in memory exceeds 25% of the total
1950 static int pagerFlushOnCommit(Pager
*pPager
, int bCommit
){
1951 if( pPager
->tempFile
==0 ) return 1;
1952 if( !bCommit
) return 0;
1953 if( !isOpen(pPager
->fd
) ) return 0;
1954 return (sqlite3PCachePercentDirty(pPager
->pPCache
)>=25);
1958 ** This routine ends a transaction. A transaction is usually ended by
1959 ** either a COMMIT or a ROLLBACK operation. This routine may be called
1960 ** after rollback of a hot-journal, or if an error occurs while opening
1961 ** the journal file or writing the very first journal-header of a
1962 ** database transaction.
1964 ** This routine is never called in PAGER_ERROR state. If it is called
1965 ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
1966 ** exclusive than a RESERVED lock, it is a no-op.
1968 ** Otherwise, any active savepoints are released.
1970 ** If the journal file is open, then it is "finalized". Once a journal
1971 ** file has been finalized it is not possible to use it to roll back a
1972 ** transaction. Nor will it be considered to be a hot-journal by this
1973 ** or any other database connection. Exactly how a journal is finalized
1974 ** depends on whether or not the pager is running in exclusive mode and
1975 ** the current journal-mode (Pager.journalMode value), as follows:
1977 ** journalMode==MEMORY
1978 ** Journal file descriptor is simply closed. This destroys an
1979 ** in-memory journal.
1981 ** journalMode==TRUNCATE
1982 ** Journal file is truncated to zero bytes in size.
1984 ** journalMode==PERSIST
1985 ** The first 28 bytes of the journal file are zeroed. This invalidates
1986 ** the first journal header in the file, and hence the entire journal
1987 ** file. An invalid journal file cannot be rolled back.
1989 ** journalMode==DELETE
1990 ** The journal file is closed and deleted using sqlite3OsDelete().
1992 ** If the pager is running in exclusive mode, this method of finalizing
1993 ** the journal file is never used. Instead, if the journalMode is
1994 ** DELETE and the pager is in exclusive mode, the method described under
1995 ** journalMode==PERSIST is used instead.
1997 ** After the journal is finalized, the pager moves to PAGER_READER state.
1998 ** If running in non-exclusive rollback mode, the lock on the file is
1999 ** downgraded to a SHARED_LOCK.
2001 ** SQLITE_OK is returned if no error occurs. If an error occurs during
2002 ** any of the IO operations to finalize the journal file or unlock the
2003 ** database then the IO error code is returned to the user. If the
2004 ** operation to finalize the journal file fails, then the code still
2005 ** tries to unlock the database file if not in exclusive mode. If the
2006 ** unlock operation fails as well, then the first error code related
2007 ** to the first error encountered (the journal finalization one) is
2010 static int pager_end_transaction(Pager
*pPager
, int hasSuper
, int bCommit
){
2011 int rc
= SQLITE_OK
; /* Error code from journal finalization operation */
2012 int rc2
= SQLITE_OK
; /* Error code from db file unlock operation */
2014 /* Do nothing if the pager does not have an open write transaction
2015 ** or at least a RESERVED lock. This function may be called when there
2016 ** is no write-transaction active but a RESERVED or greater lock is
2017 ** held under two circumstances:
2019 ** 1. After a successful hot-journal rollback, it is called with
2020 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
2022 ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
2023 ** lock switches back to locking_mode=normal and then executes a
2024 ** read-transaction, this function is called with eState==PAGER_READER
2025 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
2027 assert( assert_pager_state(pPager
) );
2028 assert( pPager
->eState
!=PAGER_ERROR
);
2029 if( pPager
->eState
<PAGER_WRITER_LOCKED
&& pPager
->eLock
<RESERVED_LOCK
){
2033 releaseAllSavepoints(pPager
);
2034 assert( isOpen(pPager
->jfd
) || pPager
->pInJournal
==0
2035 || (sqlite3OsDeviceCharacteristics(pPager
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
2037 if( isOpen(pPager
->jfd
) ){
2038 assert( !pagerUseWal(pPager
) );
2040 /* Finalize the journal file. */
2041 if( sqlite3JournalIsInMemory(pPager
->jfd
) ){
2042 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
2043 sqlite3OsClose(pPager
->jfd
);
2044 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_TRUNCATE
){
2045 if( pPager
->journalOff
==0 ){
2048 rc
= sqlite3OsTruncate(pPager
->jfd
, 0);
2049 if( rc
==SQLITE_OK
&& pPager
->fullSync
){
2050 /* Make sure the new file size is written into the inode right away.
2051 ** Otherwise the journal might resurrect following a power loss and
2052 ** cause the last transaction to roll back. See
2053 ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
2055 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
);
2058 pPager
->journalOff
= 0;
2059 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_PERSIST
2060 || (pPager
->exclusiveMode
&& pPager
->journalMode
!=PAGER_JOURNALMODE_WAL
)
2062 rc
= zeroJournalHdr(pPager
, hasSuper
||pPager
->tempFile
);
2063 pPager
->journalOff
= 0;
2065 /* This branch may be executed with Pager.journalMode==MEMORY if
2066 ** a hot-journal was just rolled back. In this case the journal
2067 ** file should be closed and deleted. If this connection writes to
2068 ** the database file, it will do so using an in-memory journal.
2070 int bDelete
= !pPager
->tempFile
;
2071 assert( sqlite3JournalIsInMemory(pPager
->jfd
)==0 );
2072 assert( pPager
->journalMode
==PAGER_JOURNALMODE_DELETE
2073 || pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
2074 || pPager
->journalMode
==PAGER_JOURNALMODE_WAL
2076 sqlite3OsClose(pPager
->jfd
);
2078 rc
= sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, pPager
->extraSync
);
2083 #ifdef SQLITE_CHECK_PAGES
2084 sqlite3PcacheIterateDirty(pPager
->pPCache
, pager_set_pagehash
);
2085 if( pPager
->dbSize
==0 && sqlite3PcacheRefCount(pPager
->pPCache
)>0 ){
2086 PgHdr
*p
= sqlite3PagerLookup(pPager
, 1);
2089 sqlite3PagerUnrefNotNull(p
);
2094 sqlite3BitvecDestroy(pPager
->pInJournal
);
2095 pPager
->pInJournal
= 0;
2097 if( rc
==SQLITE_OK
){
2098 if( MEMDB
|| pagerFlushOnCommit(pPager
, bCommit
) ){
2099 sqlite3PcacheCleanAll(pPager
->pPCache
);
2101 sqlite3PcacheClearWritable(pPager
->pPCache
);
2103 sqlite3PcacheTruncate(pPager
->pPCache
, pPager
->dbSize
);
2106 if( pagerUseWal(pPager
) ){
2107 /* Drop the WAL write-lock, if any. Also, if the connection was in
2108 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
2109 ** lock held on the database file.
2111 rc2
= sqlite3WalEndWriteTransaction(pPager
->pWal
);
2112 assert( rc2
==SQLITE_OK
);
2113 }else if( rc
==SQLITE_OK
&& bCommit
&& pPager
->dbFileSize
>pPager
->dbSize
){
2114 /* This branch is taken when committing a transaction in rollback-journal
2115 ** mode if the database file on disk is larger than the database image.
2116 ** At this point the journal has been finalized and the transaction
2117 ** successfully committed, but the EXCLUSIVE lock is still held on the
2118 ** file. So it is safe to truncate the database file to its minimum
2119 ** required size. */
2120 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
2121 rc
= pager_truncate(pPager
, pPager
->dbSize
);
2124 if( rc
==SQLITE_OK
&& bCommit
){
2125 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_COMMIT_PHASETWO
, 0);
2126 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
2129 if( !pPager
->exclusiveMode
2130 && (!pagerUseWal(pPager
) || sqlite3WalExclusiveMode(pPager
->pWal
, 0))
2132 rc2
= pagerUnlockDb(pPager
, SHARED_LOCK
);
2134 pPager
->eState
= PAGER_READER
;
2135 pPager
->setSuper
= 0;
2137 return (rc
==SQLITE_OK
?rc2
:rc
);
2141 ** Execute a rollback if a transaction is active and unlock the
2144 ** If the pager has already entered the ERROR state, do not attempt
2145 ** the rollback at this time. Instead, pager_unlock() is called. The
2146 ** call to pager_unlock() will discard all in-memory pages, unlock
2147 ** the database file and move the pager back to OPEN state. If this
2148 ** means that there is a hot-journal left in the file-system, the next
2149 ** connection to obtain a shared lock on the pager (which may be this one)
2150 ** will roll it back.
2152 ** If the pager has not already entered the ERROR state, but an IO or
2153 ** malloc error occurs during a rollback, then this will itself cause
2154 ** the pager to enter the ERROR state. Which will be cleared by the
2155 ** call to pager_unlock(), as described above.
2157 static void pagerUnlockAndRollback(Pager
*pPager
){
2158 if( pPager
->eState
!=PAGER_ERROR
&& pPager
->eState
!=PAGER_OPEN
){
2159 assert( assert_pager_state(pPager
) );
2160 if( pPager
->eState
>=PAGER_WRITER_LOCKED
){
2161 sqlite3BeginBenignMalloc();
2162 sqlite3PagerRollback(pPager
);
2163 sqlite3EndBenignMalloc();
2164 }else if( !pPager
->exclusiveMode
){
2165 assert( pPager
->eState
==PAGER_READER
);
2166 pager_end_transaction(pPager
, 0, 0);
2169 pager_unlock(pPager
);
2173 ** Parameter aData must point to a buffer of pPager->pageSize bytes
2174 ** of data. Compute and return a checksum based ont the contents of the
2175 ** page of data and the current value of pPager->cksumInit.
2177 ** This is not a real checksum. It is really just the sum of the
2178 ** random initial value (pPager->cksumInit) and every 200th byte
2179 ** of the page data, starting with byte offset (pPager->pageSize%200).
2180 ** Each byte is interpreted as an 8-bit unsigned integer.
2182 ** Changing the formula used to compute this checksum results in an
2183 ** incompatible journal file format.
2185 ** If journal corruption occurs due to a power failure, the most likely
2186 ** scenario is that one end or the other of the record will be changed.
2187 ** It is much less likely that the two ends of the journal record will be
2188 ** correct and the middle be corrupt. Thus, this "checksum" scheme,
2189 ** though fast and simple, catches the mostly likely kind of corruption.
2191 static u32
pager_cksum(Pager
*pPager
, const u8
*aData
){
2192 u32 cksum
= pPager
->cksumInit
; /* Checksum value to return */
2193 int i
= pPager
->pageSize
-200; /* Loop counter */
2202 ** Read a single page from either the journal file (if isMainJrnl==1) or
2203 ** from the sub-journal (if isMainJrnl==0) and playback that page.
2204 ** The page begins at offset *pOffset into the file. The *pOffset
2205 ** value is increased to the start of the next page in the journal.
2207 ** The main rollback journal uses checksums - the statement journal does
2210 ** If the page number of the page record read from the (sub-)journal file
2211 ** is greater than the current value of Pager.dbSize, then playback is
2212 ** skipped and SQLITE_OK is returned.
2214 ** If pDone is not NULL, then it is a record of pages that have already
2215 ** been played back. If the page at *pOffset has already been played back
2216 ** (if the corresponding pDone bit is set) then skip the playback.
2217 ** Make sure the pDone bit corresponding to the *pOffset page is set
2218 ** prior to returning.
2220 ** If the page record is successfully read from the (sub-)journal file
2221 ** and played back, then SQLITE_OK is returned. If an IO error occurs
2222 ** while reading the record from the (sub-)journal file or while writing
2223 ** to the database file, then the IO error code is returned. If data
2224 ** is successfully read from the (sub-)journal file but appears to be
2225 ** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
2226 ** two circumstances:
2228 ** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
2229 ** * If the record is being rolled back from the main journal file
2230 ** and the checksum field does not match the record content.
2232 ** Neither of these two scenarios are possible during a savepoint rollback.
2234 ** If this is a savepoint rollback, then memory may have to be dynamically
2235 ** allocated by this function. If this is the case and an allocation fails,
2236 ** SQLITE_NOMEM is returned.
2238 static int pager_playback_one_page(
2239 Pager
*pPager
, /* The pager being played back */
2240 i64
*pOffset
, /* Offset of record to playback */
2241 Bitvec
*pDone
, /* Bitvec of pages already played back */
2242 int isMainJrnl
, /* 1 -> main journal. 0 -> sub-journal. */
2243 int isSavepnt
/* True for a savepoint rollback */
2246 PgHdr
*pPg
; /* An existing page in the cache */
2247 Pgno pgno
; /* The page number of a page in journal */
2248 u32 cksum
; /* Checksum used for sanity checking */
2249 char *aData
; /* Temporary storage for the page */
2250 sqlite3_file
*jfd
; /* The file descriptor for the journal file */
2251 int isSynced
; /* True if journal page is synced */
2253 assert( (isMainJrnl
&~1)==0 ); /* isMainJrnl is 0 or 1 */
2254 assert( (isSavepnt
&~1)==0 ); /* isSavepnt is 0 or 1 */
2255 assert( isMainJrnl
|| pDone
); /* pDone always used on sub-journals */
2256 assert( isSavepnt
|| pDone
==0 ); /* pDone never used on non-savepoint */
2258 aData
= pPager
->pTmpSpace
;
2259 assert( aData
); /* Temp storage must have already been allocated */
2260 assert( pagerUseWal(pPager
)==0 || (!isMainJrnl
&& isSavepnt
) );
2262 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
2263 ** or savepoint rollback done at the request of the caller) or this is
2264 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
2265 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
2266 ** only reads from the main journal, not the sub-journal.
2268 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
2269 || (pPager
->eState
==PAGER_OPEN
&& pPager
->eLock
==EXCLUSIVE_LOCK
)
2271 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
|| isMainJrnl
);
2273 /* Read the page number and page data from the journal or sub-journal
2274 ** file. Return an error code to the caller if an IO error occurs.
2276 jfd
= isMainJrnl
? pPager
->jfd
: pPager
->sjfd
;
2277 rc
= read32bits(jfd
, *pOffset
, &pgno
);
2278 if( rc
!=SQLITE_OK
) return rc
;
2279 rc
= sqlite3OsRead(jfd
, (u8
*)aData
, pPager
->pageSize
, (*pOffset
)+4);
2280 if( rc
!=SQLITE_OK
) return rc
;
2281 *pOffset
+= pPager
->pageSize
+ 4 + isMainJrnl
*4;
2283 /* Sanity checking on the page. This is more important that I originally
2284 ** thought. If a power failure occurs while the journal is being written,
2285 ** it could cause invalid data to be written into the journal. We need to
2286 ** detect this invalid data (with high probability) and ignore it.
2288 if( pgno
==0 || pgno
==PAGER_MJ_PGNO(pPager
) ){
2289 assert( !isSavepnt
);
2292 if( pgno
>(Pgno
)pPager
->dbSize
|| sqlite3BitvecTest(pDone
, pgno
) ){
2296 rc
= read32bits(jfd
, (*pOffset
)-4, &cksum
);
2298 if( !isSavepnt
&& pager_cksum(pPager
, (u8
*)aData
)!=cksum
){
2303 /* If this page has already been played back before during the current
2304 ** rollback, then don't bother to play it back again.
2306 if( pDone
&& (rc
= sqlite3BitvecSet(pDone
, pgno
))!=SQLITE_OK
){
2310 /* When playing back page 1, restore the nReserve setting
2312 if( pgno
==1 && pPager
->nReserve
!=((u8
*)aData
)[20] ){
2313 pPager
->nReserve
= ((u8
*)aData
)[20];
2316 /* If the pager is in CACHEMOD state, then there must be a copy of this
2317 ** page in the pager cache. In this case just update the pager cache,
2318 ** not the database file. The page is left marked dirty in this case.
2320 ** An exception to the above rule: If the database is in no-sync mode
2321 ** and a page is moved during an incremental vacuum then the page may
2322 ** not be in the pager cache. Later: if a malloc() or IO error occurs
2323 ** during a Movepage() call, then the page may not be in the cache
2324 ** either. So the condition described in the above paragraph is not
2327 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
2328 ** pager cache if it exists and the main file. The page is then marked
2329 ** not dirty. Since this code is only executed in PAGER_OPEN state for
2330 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
2331 ** if the pager is in OPEN state.
2333 ** Ticket #1171: The statement journal might contain page content that is
2334 ** different from the page content at the start of the transaction.
2335 ** This occurs when a page is changed prior to the start of a statement
2336 ** then changed again within the statement. When rolling back such a
2337 ** statement we must not write to the original database unless we know
2338 ** for certain that original page contents are synced into the main rollback
2339 ** journal. Otherwise, a power loss might leave modified data in the
2340 ** database file without an entry in the rollback journal that can
2341 ** restore the database to its original form. Two conditions must be
2342 ** met before writing to the database files. (1) the database must be
2343 ** locked. (2) we know that the original page content is fully synced
2344 ** in the main journal either because the page is not in cache or else
2345 ** the page is marked as needSync==0.
2347 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
2348 ** is possible to fail a statement on a database that does not yet exist.
2349 ** Do not attempt to write if database file has never been opened.
2351 if( pagerUseWal(pPager
) ){
2354 pPg
= sqlite3PagerLookup(pPager
, pgno
);
2356 assert( pPg
|| !MEMDB
);
2357 assert( pPager
->eState
!=PAGER_OPEN
|| pPg
==0 || pPager
->tempFile
);
2358 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
2359 PAGERID(pPager
), pgno
, pager_datahash(pPager
->pageSize
, (u8
*)aData
),
2360 (isMainJrnl
?"main-journal":"sub-journal")
2363 isSynced
= pPager
->noSync
|| (*pOffset
<= pPager
->journalHdr
);
2365 isSynced
= (pPg
==0 || 0==(pPg
->flags
& PGHDR_NEED_SYNC
));
2367 if( isOpen(pPager
->fd
)
2368 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2371 i64 ofst
= (pgno
-1)*(i64
)pPager
->pageSize
;
2372 testcase( !isSavepnt
&& pPg
!=0 && (pPg
->flags
&PGHDR_NEED_SYNC
)!=0 );
2373 assert( !pagerUseWal(pPager
) );
2375 /* Write the data read from the journal back into the database file.
2376 ** This is usually safe even for an encrypted database - as the data
2377 ** was encrypted before it was written to the journal file. The exception
2378 ** is if the data was just read from an in-memory sub-journal. In that
2379 ** case it must be encrypted here before it is copied into the database
2381 rc
= sqlite3OsWrite(pPager
->fd
, (u8
*)aData
, pPager
->pageSize
, ofst
);
2383 if( pgno
>pPager
->dbFileSize
){
2384 pPager
->dbFileSize
= pgno
;
2386 if( pPager
->pBackup
){
2387 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)aData
);
2389 }else if( !isMainJrnl
&& pPg
==0 ){
2390 /* If this is a rollback of a savepoint and data was not written to
2391 ** the database and the page is not in-memory, there is a potential
2392 ** problem. When the page is next fetched by the b-tree layer, it
2393 ** will be read from the database file, which may or may not be
2396 ** There are a couple of different ways this can happen. All are quite
2397 ** obscure. When running in synchronous mode, this can only happen
2398 ** if the page is on the free-list at the start of the transaction, then
2399 ** populated, then moved using sqlite3PagerMovepage().
2401 ** The solution is to add an in-memory page to the cache containing
2402 ** the data just read from the sub-journal. Mark the page as dirty
2403 ** and if the pager requires a journal-sync, then mark the page as
2404 ** requiring a journal-sync before it is written.
2406 assert( isSavepnt
);
2407 assert( (pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
)==0 );
2408 pPager
->doNotSpill
|= SPILLFLAG_ROLLBACK
;
2409 rc
= sqlite3PagerGet(pPager
, pgno
, &pPg
, 1);
2410 assert( (pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
)!=0 );
2411 pPager
->doNotSpill
&= ~SPILLFLAG_ROLLBACK
;
2412 if( rc
!=SQLITE_OK
) return rc
;
2413 sqlite3PcacheMakeDirty(pPg
);
2416 /* No page should ever be explicitly rolled back that is in use, except
2417 ** for page 1 which is held in use in order to keep the lock on the
2418 ** database active. However such a page may be rolled back as a result
2419 ** of an internal error resulting in an automatic call to
2420 ** sqlite3PagerRollback().
2424 memcpy(pData
, (u8
*)aData
, pPager
->pageSize
);
2425 pPager
->xReiniter(pPg
);
2426 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
2427 ** that call was dangerous and had no detectable benefit since the cache
2428 ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so
2429 ** has been removed. */
2430 pager_set_pagehash(pPg
);
2432 /* If this was page 1, then restore the value of Pager.dbFileVers.
2433 ** Do this before any decoding. */
2435 memcpy(&pPager
->dbFileVers
, &((u8
*)pData
)[24],sizeof(pPager
->dbFileVers
));
2437 sqlite3PcacheRelease(pPg
);
2443 ** Parameter zSuper is the name of a super-journal file. A single journal
2444 ** file that referred to the super-journal file has just been rolled back.
2445 ** This routine checks if it is possible to delete the super-journal file,
2446 ** and does so if it is.
2448 ** Argument zSuper may point to Pager.pTmpSpace. So that buffer is not
2449 ** available for use within this function.
2451 ** When a super-journal file is created, it is populated with the names
2452 ** of all of its child journals, one after another, formatted as utf-8
2453 ** encoded text. The end of each child journal file is marked with a
2454 ** nul-terminator byte (0x00). i.e. the entire contents of a super-journal
2455 ** file for a transaction involving two databases might be:
2457 ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
2459 ** A super-journal file may only be deleted once all of its child
2460 ** journals have been rolled back.
2462 ** This function reads the contents of the super-journal file into
2463 ** memory and loops through each of the child journal names. For
2464 ** each child journal, it checks if:
2466 ** * if the child journal exists, and if so
2467 ** * if the child journal contains a reference to super-journal
2470 ** If a child journal can be found that matches both of the criteria
2471 ** above, this function returns without doing anything. Otherwise, if
2472 ** no such child journal can be found, file zSuper is deleted from
2473 ** the file-system using sqlite3OsDelete().
2475 ** If an IO error within this function, an error code is returned. This
2476 ** function allocates memory by calling sqlite3Malloc(). If an allocation
2477 ** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
2478 ** occur, SQLITE_OK is returned.
2480 ** TODO: This function allocates a single block of memory to load
2481 ** the entire contents of the super-journal file. This could be
2482 ** a couple of kilobytes or so - potentially larger than the page
2485 static int pager_delsuper(Pager
*pPager
, const char *zSuper
){
2486 sqlite3_vfs
*pVfs
= pPager
->pVfs
;
2487 int rc
; /* Return code */
2488 sqlite3_file
*pSuper
; /* Malloc'd super-journal file descriptor */
2489 sqlite3_file
*pJournal
; /* Malloc'd child-journal file descriptor */
2490 char *zSuperJournal
= 0; /* Contents of super-journal file */
2491 i64 nSuperJournal
; /* Size of super-journal file */
2492 char *zJournal
; /* Pointer to one journal within MJ file */
2493 char *zSuperPtr
; /* Space to hold super-journal filename */
2494 char *zFree
= 0; /* Free this buffer */
2495 int nSuperPtr
; /* Amount of space allocated to zSuperPtr[] */
2497 /* Allocate space for both the pJournal and pSuper file descriptors.
2498 ** If successful, open the super-journal file for reading.
2500 pSuper
= (sqlite3_file
*)sqlite3MallocZero(pVfs
->szOsFile
* 2);
2502 rc
= SQLITE_NOMEM_BKPT
;
2505 const int flags
= (SQLITE_OPEN_READONLY
|SQLITE_OPEN_SUPER_JOURNAL
);
2506 rc
= sqlite3OsOpen(pVfs
, zSuper
, pSuper
, flags
, 0);
2507 pJournal
= (sqlite3_file
*)(((u8
*)pSuper
) + pVfs
->szOsFile
);
2509 if( rc
!=SQLITE_OK
) goto delsuper_out
;
2511 /* Load the entire super-journal file into space obtained from
2512 ** sqlite3_malloc() and pointed to by zSuperJournal. Also obtain
2513 ** sufficient space (in zSuperPtr) to hold the names of super-journal
2514 ** files extracted from regular rollback-journals.
2516 rc
= sqlite3OsFileSize(pSuper
, &nSuperJournal
);
2517 if( rc
!=SQLITE_OK
) goto delsuper_out
;
2518 nSuperPtr
= pVfs
->mxPathname
+1;
2519 zFree
= sqlite3Malloc(4 + nSuperJournal
+ nSuperPtr
+ 2);
2521 rc
= SQLITE_NOMEM_BKPT
;
2524 zFree
[0] = zFree
[1] = zFree
[2] = zFree
[3] = 0;
2525 zSuperJournal
= &zFree
[4];
2526 zSuperPtr
= &zSuperJournal
[nSuperJournal
+2];
2527 rc
= sqlite3OsRead(pSuper
, zSuperJournal
, (int)nSuperJournal
, 0);
2528 if( rc
!=SQLITE_OK
) goto delsuper_out
;
2529 zSuperJournal
[nSuperJournal
] = 0;
2530 zSuperJournal
[nSuperJournal
+1] = 0;
2532 zJournal
= zSuperJournal
;
2533 while( (zJournal
-zSuperJournal
)<nSuperJournal
){
2535 rc
= sqlite3OsAccess(pVfs
, zJournal
, SQLITE_ACCESS_EXISTS
, &exists
);
2536 if( rc
!=SQLITE_OK
){
2540 /* One of the journals pointed to by the super-journal exists.
2541 ** Open it and check if it points at the super-journal. If
2542 ** so, return without deleting the super-journal file.
2543 ** NB: zJournal is really a MAIN_JOURNAL. But call it a
2544 ** SUPER_JOURNAL here so that the VFS will not send the zJournal
2545 ** name into sqlite3_database_file_object().
2548 int flags
= (SQLITE_OPEN_READONLY
|SQLITE_OPEN_SUPER_JOURNAL
);
2549 rc
= sqlite3OsOpen(pVfs
, zJournal
, pJournal
, flags
, 0);
2550 if( rc
!=SQLITE_OK
){
2554 rc
= readSuperJournal(pJournal
, zSuperPtr
, nSuperPtr
);
2555 sqlite3OsClose(pJournal
);
2556 if( rc
!=SQLITE_OK
){
2560 c
= zSuperPtr
[0]!=0 && strcmp(zSuperPtr
, zSuper
)==0;
2562 /* We have a match. Do not delete the super-journal file. */
2566 zJournal
+= (sqlite3Strlen30(zJournal
)+1);
2569 sqlite3OsClose(pSuper
);
2570 rc
= sqlite3OsDelete(pVfs
, zSuper
, 0);
2573 sqlite3_free(zFree
);
2575 sqlite3OsClose(pSuper
);
2576 assert( !isOpen(pJournal
) );
2577 sqlite3_free(pSuper
);
2584 ** This function is used to change the actual size of the database
2585 ** file in the file-system. This only happens when committing a transaction,
2586 ** or rolling back a transaction (including rolling back a hot-journal).
2588 ** If the main database file is not open, or the pager is not in either
2589 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
2590 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
2591 ** If the file on disk is currently larger than nPage pages, then use the VFS
2592 ** xTruncate() method to truncate it.
2594 ** Or, it might be the case that the file on disk is smaller than
2595 ** nPage pages. Some operating system implementations can get confused if
2596 ** you try to truncate a file to some size that is larger than it
2597 ** currently is, so detect this case and write a single zero byte to
2598 ** the end of the new file instead.
2600 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
2601 ** the database file, return the error code to the caller.
2603 static int pager_truncate(Pager
*pPager
, Pgno nPage
){
2605 assert( pPager
->eState
!=PAGER_ERROR
);
2606 assert( pPager
->eState
!=PAGER_READER
);
2608 if( isOpen(pPager
->fd
)
2609 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2611 i64 currentSize
, newSize
;
2612 int szPage
= pPager
->pageSize
;
2613 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
2614 /* TODO: Is it safe to use Pager.dbFileSize here? */
2615 rc
= sqlite3OsFileSize(pPager
->fd
, ¤tSize
);
2616 newSize
= szPage
*(i64
)nPage
;
2617 if( rc
==SQLITE_OK
&& currentSize
!=newSize
){
2618 if( currentSize
>newSize
){
2619 rc
= sqlite3OsTruncate(pPager
->fd
, newSize
);
2620 }else if( (currentSize
+szPage
)<=newSize
){
2621 char *pTmp
= pPager
->pTmpSpace
;
2622 memset(pTmp
, 0, szPage
);
2623 testcase( (newSize
-szPage
) == currentSize
);
2624 testcase( (newSize
-szPage
) > currentSize
);
2625 rc
= sqlite3OsWrite(pPager
->fd
, pTmp
, szPage
, newSize
-szPage
);
2627 if( rc
==SQLITE_OK
){
2628 pPager
->dbFileSize
= nPage
;
2636 ** Return a sanitized version of the sector-size of OS file pFile. The
2637 ** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
2639 int sqlite3SectorSize(sqlite3_file
*pFile
){
2640 int iRet
= sqlite3OsSectorSize(pFile
);
2643 }else if( iRet
>MAX_SECTOR_SIZE
){
2644 assert( MAX_SECTOR_SIZE
>=512 );
2645 iRet
= MAX_SECTOR_SIZE
;
2651 ** Set the value of the Pager.sectorSize variable for the given
2652 ** pager based on the value returned by the xSectorSize method
2653 ** of the open database file. The sector size will be used
2654 ** to determine the size and alignment of journal header and
2655 ** super-journal pointers within created journal files.
2657 ** For temporary files the effective sector size is always 512 bytes.
2659 ** Otherwise, for non-temporary files, the effective sector size is
2660 ** the value returned by the xSectorSize() method rounded up to 32 if
2661 ** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
2662 ** is greater than MAX_SECTOR_SIZE.
2664 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
2665 ** the effective sector size to its minimum value (512). The purpose of
2666 ** pPager->sectorSize is to define the "blast radius" of bytes that
2667 ** might change if a crash occurs while writing to a single byte in
2668 ** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
2669 ** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
2670 ** size. For backwards compatibility of the rollback journal file format,
2671 ** we cannot reduce the effective sector size below 512.
2673 static void setSectorSize(Pager
*pPager
){
2674 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
2676 if( pPager
->tempFile
2677 || (sqlite3OsDeviceCharacteristics(pPager
->fd
) &
2678 SQLITE_IOCAP_POWERSAFE_OVERWRITE
)!=0
2680 /* Sector size doesn't matter for temporary files. Also, the file
2681 ** may not have been opened yet, in which case the OsSectorSize()
2682 ** call will segfault. */
2683 pPager
->sectorSize
= 512;
2685 pPager
->sectorSize
= sqlite3SectorSize(pPager
->fd
);
2690 ** Playback the journal and thus restore the database file to
2691 ** the state it was in before we started making changes.
2693 ** The journal file format is as follows:
2695 ** (1) 8 byte prefix. A copy of aJournalMagic[].
2696 ** (2) 4 byte big-endian integer which is the number of valid page records
2697 ** in the journal. If this value is 0xffffffff, then compute the
2698 ** number of page records from the journal size.
2699 ** (3) 4 byte big-endian integer which is the initial value for the
2701 ** (4) 4 byte integer which is the number of pages to truncate the
2702 ** database to during a rollback.
2703 ** (5) 4 byte big-endian integer which is the sector size. The header
2704 ** is this many bytes in size.
2705 ** (6) 4 byte big-endian integer which is the page size.
2706 ** (7) zero padding out to the next sector size.
2707 ** (8) Zero or more pages instances, each as follows:
2708 ** + 4 byte page number.
2709 ** + pPager->pageSize bytes of data.
2710 ** + 4 byte checksum
2712 ** When we speak of the journal header, we mean the first 7 items above.
2713 ** Each entry in the journal is an instance of the 8th item.
2715 ** Call the value from the second bullet "nRec". nRec is the number of
2716 ** valid page entries in the journal. In most cases, you can compute the
2717 ** value of nRec from the size of the journal file. But if a power
2718 ** failure occurred while the journal was being written, it could be the
2719 ** case that the size of the journal file had already been increased but
2720 ** the extra entries had not yet made it safely to disk. In such a case,
2721 ** the value of nRec computed from the file size would be too large. For
2722 ** that reason, we always use the nRec value in the header.
2724 ** If the nRec value is 0xffffffff it means that nRec should be computed
2725 ** from the file size. This value is used when the user selects the
2726 ** no-sync option for the journal. A power failure could lead to corruption
2727 ** in this case. But for things like temporary table (which will be
2728 ** deleted when the power is restored) we don't care.
2730 ** If the file opened as the journal file is not a well-formed
2731 ** journal file then all pages up to the first corrupted page are rolled
2732 ** back (or no pages if the journal header is corrupted). The journal file
2733 ** is then deleted and SQLITE_OK returned, just as if no corruption had
2734 ** been encountered.
2736 ** If an I/O or malloc() error occurs, the journal-file is not deleted
2737 ** and an error code is returned.
2739 ** The isHot parameter indicates that we are trying to rollback a journal
2740 ** that might be a hot journal. Or, it could be that the journal is
2741 ** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
2742 ** If the journal really is hot, reset the pager cache prior rolling
2743 ** back any content. If the journal is merely persistent, no reset is
2746 static int pager_playback(Pager
*pPager
, int isHot
){
2747 sqlite3_vfs
*pVfs
= pPager
->pVfs
;
2748 i64 szJ
; /* Size of the journal file in bytes */
2749 u32 nRec
; /* Number of Records in the journal */
2750 u32 u
; /* Unsigned loop counter */
2751 Pgno mxPg
= 0; /* Size of the original file in pages */
2752 int rc
; /* Result code of a subroutine */
2753 int res
= 1; /* Value returned by sqlite3OsAccess() */
2754 char *zSuper
= 0; /* Name of super-journal file if any */
2755 int needPagerReset
; /* True to reset page prior to first page rollback */
2756 int nPlayback
= 0; /* Total number of pages restored from journal */
2757 u32 savedPageSize
= pPager
->pageSize
;
2759 /* Figure out how many records are in the journal. Abort early if
2760 ** the journal is empty.
2762 assert( isOpen(pPager
->jfd
) );
2763 rc
= sqlite3OsFileSize(pPager
->jfd
, &szJ
);
2764 if( rc
!=SQLITE_OK
){
2768 /* Read the super-journal name from the journal, if it is present.
2769 ** If a super-journal file name is specified, but the file is not
2770 ** present on disk, then the journal is not hot and does not need to be
2773 ** TODO: Technically the following is an error because it assumes that
2774 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2775 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
2776 ** mxPathname is 512, which is the same as the minimum allowable value
2779 zSuper
= pPager
->pTmpSpace
;
2780 rc
= readSuperJournal(pPager
->jfd
, zSuper
, pPager
->pVfs
->mxPathname
+1);
2781 if( rc
==SQLITE_OK
&& zSuper
[0] ){
2782 rc
= sqlite3OsAccess(pVfs
, zSuper
, SQLITE_ACCESS_EXISTS
, &res
);
2785 if( rc
!=SQLITE_OK
|| !res
){
2788 pPager
->journalOff
= 0;
2789 needPagerReset
= isHot
;
2791 /* This loop terminates either when a readJournalHdr() or
2792 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2796 /* Read the next journal header from the journal file. If there are
2797 ** not enough bytes left in the journal file for a complete header, or
2798 ** it is corrupted, then a process must have failed while writing it.
2799 ** This indicates nothing more needs to be rolled back.
2801 rc
= readJournalHdr(pPager
, isHot
, szJ
, &nRec
, &mxPg
);
2802 if( rc
!=SQLITE_OK
){
2803 if( rc
==SQLITE_DONE
){
2809 /* If nRec is 0xffffffff, then this journal was created by a process
2810 ** working in no-sync mode. This means that the rest of the journal
2811 ** file consists of pages, there are no more journal headers. Compute
2812 ** the value of nRec based on this assumption.
2814 if( nRec
==0xffffffff ){
2815 assert( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) );
2816 nRec
= (int)((szJ
- JOURNAL_HDR_SZ(pPager
))/JOURNAL_PG_SZ(pPager
));
2819 /* If nRec is 0 and this rollback is of a transaction created by this
2820 ** process and if this is the final header in the journal, then it means
2821 ** that this part of the journal was being filled but has not yet been
2822 ** synced to disk. Compute the number of pages based on the remaining
2823 ** size of the file.
2825 ** The third term of the test was added to fix ticket #2565.
2826 ** When rolling back a hot journal, nRec==0 always means that the next
2827 ** chunk of the journal contains zero pages to be rolled back. But
2828 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2829 ** the journal, it means that the journal might contain additional
2830 ** pages that need to be rolled back and that the number of pages
2831 ** should be computed based on the journal file size.
2833 if( nRec
==0 && !isHot
&&
2834 pPager
->journalHdr
+JOURNAL_HDR_SZ(pPager
)==pPager
->journalOff
){
2835 nRec
= (int)((szJ
- pPager
->journalOff
) / JOURNAL_PG_SZ(pPager
));
2838 /* If this is the first header read from the journal, truncate the
2839 ** database file back to its original size.
2841 if( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) ){
2842 rc
= pager_truncate(pPager
, mxPg
);
2843 if( rc
!=SQLITE_OK
){
2846 pPager
->dbSize
= mxPg
;
2849 /* Copy original pages out of the journal and back into the
2850 ** database file and/or page cache.
2852 for(u
=0; u
<nRec
; u
++){
2853 if( needPagerReset
){
2854 pager_reset(pPager
);
2857 rc
= pager_playback_one_page(pPager
,&pPager
->journalOff
,0,1,0);
2858 if( rc
==SQLITE_OK
){
2861 if( rc
==SQLITE_DONE
){
2862 pPager
->journalOff
= szJ
;
2864 }else if( rc
==SQLITE_IOERR_SHORT_READ
){
2865 /* If the journal has been truncated, simply stop reading and
2866 ** processing the journal. This might happen if the journal was
2867 ** not completely written and synced prior to a crash. In that
2868 ** case, the database should have never been written in the
2869 ** first place so it is OK to simply abandon the rollback. */
2873 /* If we are unable to rollback, quit and return the error
2874 ** code. This will cause the pager to enter the error state
2875 ** so that no further harm will be done. Perhaps the next
2876 ** process to come along will be able to rollback the database.
2887 if( rc
==SQLITE_OK
){
2888 rc
= sqlite3PagerSetPagesize(pPager
, &savedPageSize
, -1);
2890 /* Following a rollback, the database file should be back in its original
2891 ** state prior to the start of the transaction, so invoke the
2892 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
2893 ** assertion that the transaction counter was modified.
2896 sqlite3OsFileControlHint(pPager
->fd
,SQLITE_FCNTL_DB_UNCHANGED
,0);
2899 /* If this playback is happening automatically as a result of an IO or
2900 ** malloc error that occurred after the change-counter was updated but
2901 ** before the transaction was committed, then the change-counter
2902 ** modification may just have been reverted. If this happens in exclusive
2903 ** mode, then subsequent transactions performed by the connection will not
2904 ** update the change-counter at all. This may lead to cache inconsistency
2905 ** problems for other processes at some point in the future. So, just
2906 ** in case this has happened, clear the changeCountDone flag now.
2908 pPager
->changeCountDone
= pPager
->tempFile
;
2910 if( rc
==SQLITE_OK
){
2911 /* Leave 4 bytes of space before the super-journal filename in memory.
2912 ** This is because it may end up being passed to sqlite3OsOpen(), in
2913 ** which case it requires 4 0x00 bytes in memory immediately before
2915 zSuper
= &pPager
->pTmpSpace
[4];
2916 rc
= readSuperJournal(pPager
->jfd
, zSuper
, pPager
->pVfs
->mxPathname
+1);
2917 testcase( rc
!=SQLITE_OK
);
2920 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2922 rc
= sqlite3PagerSync(pPager
, 0);
2924 if( rc
==SQLITE_OK
){
2925 rc
= pager_end_transaction(pPager
, zSuper
[0]!='\0', 0);
2926 testcase( rc
!=SQLITE_OK
);
2928 if( rc
==SQLITE_OK
&& zSuper
[0] && res
){
2929 /* If there was a super-journal and this routine will return success,
2930 ** see if it is possible to delete the super-journal.
2932 assert( zSuper
==&pPager
->pTmpSpace
[4] );
2933 memset(&zSuper
[-4], 0, 4);
2934 rc
= pager_delsuper(pPager
, zSuper
);
2935 testcase( rc
!=SQLITE_OK
);
2937 if( isHot
&& nPlayback
){
2938 sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK
, "recovered %d pages from %s",
2939 nPlayback
, pPager
->zJournal
);
2942 /* The Pager.sectorSize variable may have been updated while rolling
2943 ** back a journal created by a process with a different sector size
2944 ** value. Reset it to the correct value for this process.
2946 setSectorSize(pPager
);
2952 ** Read the content for page pPg out of the database file (or out of
2953 ** the WAL if that is where the most recent copy if found) into
2954 ** pPg->pData. A shared lock or greater must be held on the database
2955 ** file before this function is called.
2957 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
2958 ** the value read from the database file.
2960 ** If an IO error occurs, then the IO error is returned to the caller.
2961 ** Otherwise, SQLITE_OK is returned.
2963 static int readDbPage(PgHdr
*pPg
){
2964 Pager
*pPager
= pPg
->pPager
; /* Pager object associated with page pPg */
2965 int rc
= SQLITE_OK
; /* Return code */
2967 #ifndef SQLITE_OMIT_WAL
2968 u32 iFrame
= 0; /* Frame of WAL containing pgno */
2970 assert( pPager
->eState
>=PAGER_READER
&& !MEMDB
);
2971 assert( isOpen(pPager
->fd
) );
2973 if( pagerUseWal(pPager
) ){
2974 rc
= sqlite3WalFindFrame(pPager
->pWal
, pPg
->pgno
, &iFrame
);
2978 rc
= sqlite3WalReadFrame(pPager
->pWal
, iFrame
,pPager
->pageSize
,pPg
->pData
);
2982 i64 iOffset
= (pPg
->pgno
-1)*(i64
)pPager
->pageSize
;
2983 rc
= sqlite3OsRead(pPager
->fd
, pPg
->pData
, pPager
->pageSize
, iOffset
);
2984 if( rc
==SQLITE_IOERR_SHORT_READ
){
2991 /* If the read is unsuccessful, set the dbFileVers[] to something
2992 ** that will never be a valid file version. dbFileVers[] is a copy
2993 ** of bytes 24..39 of the database. Bytes 28..31 should always be
2994 ** zero or the size of the database in page. Bytes 32..35 and 35..39
2995 ** should be page numbers which are never 0xffffffff. So filling
2996 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
2998 ** For an encrypted database, the situation is more complex: bytes
2999 ** 24..39 of the database are white noise. But the probability of
3000 ** white noise equaling 16 bytes of 0xff is vanishingly small so
3001 ** we should still be ok.
3003 memset(pPager
->dbFileVers
, 0xff, sizeof(pPager
->dbFileVers
));
3005 u8
*dbFileVers
= &((u8
*)pPg
->pData
)[24];
3006 memcpy(&pPager
->dbFileVers
, dbFileVers
, sizeof(pPager
->dbFileVers
));
3009 PAGER_INCR(sqlite3_pager_readdb_count
);
3010 PAGER_INCR(pPager
->nRead
);
3011 IOTRACE(("PGIN %p %d\n", pPager
, pPg
->pgno
));
3012 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
3013 PAGERID(pPager
), pPg
->pgno
, pager_pagehash(pPg
)));
3019 ** Update the value of the change-counter at offsets 24 and 92 in
3020 ** the header and the sqlite version number at offset 96.
3022 ** This is an unconditional update. See also the pager_incr_changecounter()
3023 ** routine which only updates the change-counter if the update is actually
3024 ** needed, as determined by the pPager->changeCountDone state variable.
3026 static void pager_write_changecounter(PgHdr
*pPg
){
3028 if( NEVER(pPg
==0) ) return;
3030 /* Increment the value just read and write it back to byte 24. */
3031 change_counter
= sqlite3Get4byte((u8
*)pPg
->pPager
->dbFileVers
)+1;
3032 put32bits(((char*)pPg
->pData
)+24, change_counter
);
3034 /* Also store the SQLite version number in bytes 96..99 and in
3035 ** bytes 92..95 store the change counter for which the version number
3037 put32bits(((char*)pPg
->pData
)+92, change_counter
);
3038 put32bits(((char*)pPg
->pData
)+96, SQLITE_VERSION_NUMBER
);
3041 #ifndef SQLITE_OMIT_WAL
3043 ** This function is invoked once for each page that has already been
3044 ** written into the log file when a WAL transaction is rolled back.
3045 ** Parameter iPg is the page number of said page. The pCtx argument
3046 ** is actually a pointer to the Pager structure.
3048 ** If page iPg is present in the cache, and has no outstanding references,
3049 ** it is discarded. Otherwise, if there are one or more outstanding
3050 ** references, the page content is reloaded from the database. If the
3051 ** attempt to reload content from the database is required and fails,
3052 ** return an SQLite error code. Otherwise, SQLITE_OK.
3054 static int pagerUndoCallback(void *pCtx
, Pgno iPg
){
3056 Pager
*pPager
= (Pager
*)pCtx
;
3059 assert( pagerUseWal(pPager
) );
3060 pPg
= sqlite3PagerLookup(pPager
, iPg
);
3062 if( sqlite3PcachePageRefcount(pPg
)==1 ){
3063 sqlite3PcacheDrop(pPg
);
3065 rc
= readDbPage(pPg
);
3066 if( rc
==SQLITE_OK
){
3067 pPager
->xReiniter(pPg
);
3069 sqlite3PagerUnrefNotNull(pPg
);
3073 /* Normally, if a transaction is rolled back, any backup processes are
3074 ** updated as data is copied out of the rollback journal and into the
3075 ** database. This is not generally possible with a WAL database, as
3076 ** rollback involves simply truncating the log file. Therefore, if one
3077 ** or more frames have already been written to the log (and therefore
3078 ** also copied into the backup databases) as part of this transaction,
3079 ** the backups must be restarted.
3081 sqlite3BackupRestart(pPager
->pBackup
);
3087 ** This function is called to rollback a transaction on a WAL database.
3089 static int pagerRollbackWal(Pager
*pPager
){
3090 int rc
; /* Return Code */
3091 PgHdr
*pList
; /* List of dirty pages to revert */
3093 /* For all pages in the cache that are currently dirty or have already
3094 ** been written (but not committed) to the log file, do one of the
3097 ** + Discard the cached page (if refcount==0), or
3098 ** + Reload page content from the database (if refcount>0).
3100 pPager
->dbSize
= pPager
->dbOrigSize
;
3101 rc
= sqlite3WalUndo(pPager
->pWal
, pagerUndoCallback
, (void *)pPager
);
3102 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
3103 while( pList
&& rc
==SQLITE_OK
){
3104 PgHdr
*pNext
= pList
->pDirty
;
3105 rc
= pagerUndoCallback((void *)pPager
, pList
->pgno
);
3113 ** This function is a wrapper around sqlite3WalFrames(). As well as logging
3114 ** the contents of the list of pages headed by pList (connected by pDirty),
3115 ** this function notifies any active backup processes that the pages have
3118 ** The list of pages passed into this routine is always sorted by page number.
3119 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
3121 static int pagerWalFrames(
3122 Pager
*pPager
, /* Pager object */
3123 PgHdr
*pList
, /* List of frames to log */
3124 Pgno nTruncate
, /* Database size after this commit */
3125 int isCommit
/* True if this is a commit */
3127 int rc
; /* Return code */
3128 int nList
; /* Number of pages in pList */
3129 PgHdr
*p
; /* For looping over pages */
3131 assert( pPager
->pWal
);
3134 /* Verify that the page list is in accending order */
3135 for(p
=pList
; p
&& p
->pDirty
; p
=p
->pDirty
){
3136 assert( p
->pgno
< p
->pDirty
->pgno
);
3140 assert( pList
->pDirty
==0 || isCommit
);
3142 /* If a WAL transaction is being committed, there is no point in writing
3143 ** any pages with page numbers greater than nTruncate into the WAL file.
3144 ** They will never be read by any client. So remove them from the pDirty
3146 PgHdr
**ppNext
= &pList
;
3148 for(p
=pList
; (*ppNext
= p
)!=0; p
=p
->pDirty
){
3149 if( p
->pgno
<=nTruncate
){
3150 ppNext
= &p
->pDirty
;
3158 pPager
->aStat
[PAGER_STAT_WRITE
] += nList
;
3160 if( pList
->pgno
==1 ) pager_write_changecounter(pList
);
3161 rc
= sqlite3WalFrames(pPager
->pWal
,
3162 pPager
->pageSize
, pList
, nTruncate
, isCommit
, pPager
->walSyncFlags
3164 if( rc
==SQLITE_OK
&& pPager
->pBackup
){
3165 for(p
=pList
; p
; p
=p
->pDirty
){
3166 sqlite3BackupUpdate(pPager
->pBackup
, p
->pgno
, (u8
*)p
->pData
);
3170 #ifdef SQLITE_CHECK_PAGES
3171 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
3172 for(p
=pList
; p
; p
=p
->pDirty
){
3173 pager_set_pagehash(p
);
3181 ** Begin a read transaction on the WAL.
3183 ** This routine used to be called "pagerOpenSnapshot()" because it essentially
3184 ** makes a snapshot of the database at the current point in time and preserves
3185 ** that snapshot for use by the reader in spite of concurrently changes by
3186 ** other writers or checkpointers.
3188 static int pagerBeginReadTransaction(Pager
*pPager
){
3189 int rc
; /* Return code */
3190 int changed
= 0; /* True if cache must be reset */
3192 assert( pagerUseWal(pPager
) );
3193 assert( pPager
->eState
==PAGER_OPEN
|| pPager
->eState
==PAGER_READER
);
3195 /* sqlite3WalEndReadTransaction() was not called for the previous
3196 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
3197 ** are in locking_mode=NORMAL and EndRead() was previously called,
3198 ** the duplicate call is harmless.
3200 sqlite3WalEndReadTransaction(pPager
->pWal
);
3202 rc
= sqlite3WalBeginReadTransaction(pPager
->pWal
, &changed
);
3203 if( rc
!=SQLITE_OK
|| changed
){
3204 pager_reset(pPager
);
3205 if( USEFETCH(pPager
) ) sqlite3OsUnfetch(pPager
->fd
, 0, 0);
3213 ** This function is called as part of the transition from PAGER_OPEN
3214 ** to PAGER_READER state to determine the size of the database file
3215 ** in pages (assuming the page size currently stored in Pager.pageSize).
3217 ** If no error occurs, SQLITE_OK is returned and the size of the database
3218 ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
3219 ** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
3221 static int pagerPagecount(Pager
*pPager
, Pgno
*pnPage
){
3222 Pgno nPage
; /* Value to return via *pnPage */
3224 /* Query the WAL sub-system for the database size. The WalDbsize()
3225 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
3226 ** if the database size is not available. The database size is not
3227 ** available from the WAL sub-system if the log file is empty or
3228 ** contains no valid committed transactions.
3230 assert( pPager
->eState
==PAGER_OPEN
);
3231 assert( pPager
->eLock
>=SHARED_LOCK
);
3232 assert( isOpen(pPager
->fd
) );
3233 assert( pPager
->tempFile
==0 );
3234 nPage
= sqlite3WalDbsize(pPager
->pWal
);
3236 /* If the number of pages in the database is not available from the
3237 ** WAL sub-system, determine the page count based on the size of
3238 ** the database file. If the size of the database file is not an
3239 ** integer multiple of the page-size, round up the result.
3241 if( nPage
==0 && ALWAYS(isOpen(pPager
->fd
)) ){
3242 i64 n
= 0; /* Size of db file in bytes */
3243 int rc
= sqlite3OsFileSize(pPager
->fd
, &n
);
3244 if( rc
!=SQLITE_OK
){
3247 nPage
= (Pgno
)((n
+pPager
->pageSize
-1) / pPager
->pageSize
);
3250 /* If the current number of pages in the file is greater than the
3251 ** configured maximum pager number, increase the allowed limit so
3252 ** that the file can be read.
3254 if( nPage
>pPager
->mxPgno
){
3255 pPager
->mxPgno
= (Pgno
)nPage
;
3262 #ifndef SQLITE_OMIT_WAL
3264 ** Check if the *-wal file that corresponds to the database opened by pPager
3265 ** exists if the database is not empy, or verify that the *-wal file does
3266 ** not exist (by deleting it) if the database file is empty.
3268 ** If the database is not empty and the *-wal file exists, open the pager
3269 ** in WAL mode. If the database is empty or if no *-wal file exists and
3270 ** if no error occurs, make sure Pager.journalMode is not set to
3271 ** PAGER_JOURNALMODE_WAL.
3273 ** Return SQLITE_OK or an error code.
3275 ** The caller must hold a SHARED lock on the database file to call this
3276 ** function. Because an EXCLUSIVE lock on the db file is required to delete
3277 ** a WAL on a none-empty database, this ensures there is no race condition
3278 ** between the xAccess() below and an xDelete() being executed by some
3279 ** other connection.
3281 static int pagerOpenWalIfPresent(Pager
*pPager
){
3283 assert( pPager
->eState
==PAGER_OPEN
);
3284 assert( pPager
->eLock
>=SHARED_LOCK
);
3286 if( !pPager
->tempFile
){
3287 int isWal
; /* True if WAL file exists */
3288 rc
= sqlite3OsAccess(
3289 pPager
->pVfs
, pPager
->zWal
, SQLITE_ACCESS_EXISTS
, &isWal
3291 if( rc
==SQLITE_OK
){
3293 Pgno nPage
; /* Size of the database file */
3295 rc
= pagerPagecount(pPager
, &nPage
);
3298 rc
= sqlite3OsDelete(pPager
->pVfs
, pPager
->zWal
, 0);
3300 testcase( sqlite3PcachePagecount(pPager
->pPCache
)==0 );
3301 rc
= sqlite3PagerOpenWal(pPager
, 0);
3303 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_WAL
){
3304 pPager
->journalMode
= PAGER_JOURNALMODE_DELETE
;
3313 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
3314 ** the entire super-journal file. The case pSavepoint==NULL occurs when
3315 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
3318 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
3319 ** being rolled back), then the rollback consists of up to three stages,
3320 ** performed in the order specified:
3322 ** * Pages are played back from the main journal starting at byte
3323 ** offset PagerSavepoint.iOffset and continuing to
3324 ** PagerSavepoint.iHdrOffset, or to the end of the main journal
3325 ** file if PagerSavepoint.iHdrOffset is zero.
3327 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
3328 ** back starting from the journal header immediately following
3329 ** PagerSavepoint.iHdrOffset to the end of the main journal file.
3331 ** * Pages are then played back from the sub-journal file, starting
3332 ** with the PagerSavepoint.iSubRec and continuing to the end of
3333 ** the journal file.
3335 ** Throughout the rollback process, each time a page is rolled back, the
3336 ** corresponding bit is set in a bitvec structure (variable pDone in the
3337 ** implementation below). This is used to ensure that a page is only
3338 ** rolled back the first time it is encountered in either journal.
3340 ** If pSavepoint is NULL, then pages are only played back from the main
3341 ** journal file. There is no need for a bitvec in this case.
3343 ** In either case, before playback commences the Pager.dbSize variable
3344 ** is reset to the value that it held at the start of the savepoint
3345 ** (or transaction). No page with a page-number greater than this value
3346 ** is played back. If one is encountered it is simply skipped.
3348 static int pagerPlaybackSavepoint(Pager
*pPager
, PagerSavepoint
*pSavepoint
){
3349 i64 szJ
; /* Effective size of the main journal */
3350 i64 iHdrOff
; /* End of first segment of main-journal records */
3351 int rc
= SQLITE_OK
; /* Return code */
3352 Bitvec
*pDone
= 0; /* Bitvec to ensure pages played back only once */
3354 assert( pPager
->eState
!=PAGER_ERROR
);
3355 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
3357 /* Allocate a bitvec to use to store the set of pages rolled back */
3359 pDone
= sqlite3BitvecCreate(pSavepoint
->nOrig
);
3361 return SQLITE_NOMEM_BKPT
;
3365 /* Set the database size back to the value it was before the savepoint
3366 ** being reverted was opened.
3368 pPager
->dbSize
= pSavepoint
? pSavepoint
->nOrig
: pPager
->dbOrigSize
;
3369 pPager
->changeCountDone
= pPager
->tempFile
;
3371 if( !pSavepoint
&& pagerUseWal(pPager
) ){
3372 return pagerRollbackWal(pPager
);
3375 /* Use pPager->journalOff as the effective size of the main rollback
3376 ** journal. The actual file might be larger than this in
3377 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
3378 ** past pPager->journalOff is off-limits to us.
3380 szJ
= pPager
->journalOff
;
3381 assert( pagerUseWal(pPager
)==0 || szJ
==0 );
3383 /* Begin by rolling back records from the main journal starting at
3384 ** PagerSavepoint.iOffset and continuing to the next journal header.
3385 ** There might be records in the main journal that have a page number
3386 ** greater than the current database size (pPager->dbSize) but those
3387 ** will be skipped automatically. Pages are added to pDone as they
3390 if( pSavepoint
&& !pagerUseWal(pPager
) ){
3391 iHdrOff
= pSavepoint
->iHdrOffset
? pSavepoint
->iHdrOffset
: szJ
;
3392 pPager
->journalOff
= pSavepoint
->iOffset
;
3393 while( rc
==SQLITE_OK
&& pPager
->journalOff
<iHdrOff
){
3394 rc
= pager_playback_one_page(pPager
, &pPager
->journalOff
, pDone
, 1, 1);
3396 assert( rc
!=SQLITE_DONE
);
3398 pPager
->journalOff
= 0;
3401 /* Continue rolling back records out of the main journal starting at
3402 ** the first journal header seen and continuing until the effective end
3403 ** of the main journal file. Continue to skip out-of-range pages and
3404 ** continue adding pages rolled back to pDone.
3406 while( rc
==SQLITE_OK
&& pPager
->journalOff
<szJ
){
3407 u32 ii
; /* Loop counter */
3408 u32 nJRec
= 0; /* Number of Journal Records */
3410 rc
= readJournalHdr(pPager
, 0, szJ
, &nJRec
, &dummy
);
3411 assert( rc
!=SQLITE_DONE
);
3414 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
3415 ** test is related to ticket #2565. See the discussion in the
3416 ** pager_playback() function for additional information.
3419 && pPager
->journalHdr
+JOURNAL_HDR_SZ(pPager
)==pPager
->journalOff
3421 nJRec
= (u32
)((szJ
- pPager
->journalOff
)/JOURNAL_PG_SZ(pPager
));
3423 for(ii
=0; rc
==SQLITE_OK
&& ii
<nJRec
&& pPager
->journalOff
<szJ
; ii
++){
3424 rc
= pager_playback_one_page(pPager
, &pPager
->journalOff
, pDone
, 1, 1);
3426 assert( rc
!=SQLITE_DONE
);
3428 assert( rc
!=SQLITE_OK
|| pPager
->journalOff
>=szJ
);
3430 /* Finally, rollback pages from the sub-journal. Page that were
3431 ** previously rolled back out of the main journal (and are hence in pDone)
3432 ** will be skipped. Out-of-range pages are also skipped.
3435 u32 ii
; /* Loop counter */
3436 i64 offset
= (i64
)pSavepoint
->iSubRec
*(4+pPager
->pageSize
);
3438 if( pagerUseWal(pPager
) ){
3439 rc
= sqlite3WalSavepointUndo(pPager
->pWal
, pSavepoint
->aWalData
);
3441 for(ii
=pSavepoint
->iSubRec
; rc
==SQLITE_OK
&& ii
<pPager
->nSubRec
; ii
++){
3442 assert( offset
==(i64
)ii
*(4+pPager
->pageSize
) );
3443 rc
= pager_playback_one_page(pPager
, &offset
, pDone
, 0, 1);
3445 assert( rc
!=SQLITE_DONE
);
3448 sqlite3BitvecDestroy(pDone
);
3449 if( rc
==SQLITE_OK
){
3450 pPager
->journalOff
= szJ
;
3457 ** Change the maximum number of in-memory pages that are allowed
3458 ** before attempting to recycle clean and unused pages.
3460 void sqlite3PagerSetCachesize(Pager
*pPager
, int mxPage
){
3461 sqlite3PcacheSetCachesize(pPager
->pPCache
, mxPage
);
3465 ** Change the maximum number of in-memory pages that are allowed
3466 ** before attempting to spill pages to journal.
3468 int sqlite3PagerSetSpillsize(Pager
*pPager
, int mxPage
){
3469 return sqlite3PcacheSetSpillsize(pPager
->pPCache
, mxPage
);
3473 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
3475 static void pagerFixMaplimit(Pager
*pPager
){
3476 #if SQLITE_MAX_MMAP_SIZE>0
3477 sqlite3_file
*fd
= pPager
->fd
;
3478 if( isOpen(fd
) && fd
->pMethods
->iVersion
>=3 ){
3480 sz
= pPager
->szMmap
;
3481 pPager
->bUseFetch
= (sz
>0);
3482 setGetterMethod(pPager
);
3483 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_MMAP_SIZE
, &sz
);
3489 ** Change the maximum size of any memory mapping made of the database file.
3491 void sqlite3PagerSetMmapLimit(Pager
*pPager
, sqlite3_int64 szMmap
){
3492 pPager
->szMmap
= szMmap
;
3493 pagerFixMaplimit(pPager
);
3497 ** Free as much memory as possible from the pager.
3499 void sqlite3PagerShrink(Pager
*pPager
){
3500 sqlite3PcacheShrink(pPager
->pPCache
);
3504 ** Adjust settings of the pager to those specified in the pgFlags parameter.
3506 ** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness
3507 ** of the database to damage due to OS crashes or power failures by
3508 ** changing the number of syncs()s when writing the journals.
3509 ** There are four levels:
3511 ** OFF sqlite3OsSync() is never called. This is the default
3512 ** for temporary and transient files.
3514 ** NORMAL The journal is synced once before writes begin on the
3515 ** database. This is normally adequate protection, but
3516 ** it is theoretically possible, though very unlikely,
3517 ** that an inopertune power failure could leave the journal
3518 ** in a state which would cause damage to the database
3519 ** when it is rolled back.
3521 ** FULL The journal is synced twice before writes begin on the
3522 ** database (with some additional information - the nRec field
3523 ** of the journal header - being written in between the two
3524 ** syncs). If we assume that writing a
3525 ** single disk sector is atomic, then this mode provides
3526 ** assurance that the journal will not be corrupted to the
3527 ** point of causing damage to the database during rollback.
3529 ** EXTRA This is like FULL except that is also syncs the directory
3530 ** that contains the rollback journal after the rollback
3531 ** journal is unlinked.
3533 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
3534 ** to mean that no syncs ever occur. NORMAL means that the WAL is synced
3535 ** prior to the start of checkpoint and that the database file is synced
3536 ** at the conclusion of the checkpoint if the entire content of the WAL
3537 ** was written back into the database. But no sync operations occur for
3538 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
3539 ** file is synced following each commit operation, in addition to the
3540 ** syncs associated with NORMAL. There is no difference between FULL
3541 ** and EXTRA for WAL mode.
3543 ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
3544 ** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
3545 ** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
3546 ** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
3547 ** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
3548 ** synchronous=FULL versus synchronous=NORMAL setting determines when
3549 ** the xSync primitive is called and is relevant to all platforms.
3551 ** Numeric values associated with these states are OFF==1, NORMAL=2,
3554 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
3555 void sqlite3PagerSetFlags(
3556 Pager
*pPager
, /* The pager to set safety level for */
3557 unsigned pgFlags
/* Various flags */
3559 unsigned level
= pgFlags
& PAGER_SYNCHRONOUS_MASK
;
3560 if( pPager
->tempFile
){
3562 pPager
->fullSync
= 0;
3563 pPager
->extraSync
= 0;
3565 pPager
->noSync
= level
==PAGER_SYNCHRONOUS_OFF
?1:0;
3566 pPager
->fullSync
= level
>=PAGER_SYNCHRONOUS_FULL
?1:0;
3567 pPager
->extraSync
= level
==PAGER_SYNCHRONOUS_EXTRA
?1:0;
3569 if( pPager
->noSync
){
3570 pPager
->syncFlags
= 0;
3571 }else if( pgFlags
& PAGER_FULLFSYNC
){
3572 pPager
->syncFlags
= SQLITE_SYNC_FULL
;
3574 pPager
->syncFlags
= SQLITE_SYNC_NORMAL
;
3576 pPager
->walSyncFlags
= (pPager
->syncFlags
<<2);
3577 if( pPager
->fullSync
){
3578 pPager
->walSyncFlags
|= pPager
->syncFlags
;
3580 if( (pgFlags
& PAGER_CKPT_FULLFSYNC
) && !pPager
->noSync
){
3581 pPager
->walSyncFlags
|= (SQLITE_SYNC_FULL
<<2);
3583 if( pgFlags
& PAGER_CACHESPILL
){
3584 pPager
->doNotSpill
&= ~SPILLFLAG_OFF
;
3586 pPager
->doNotSpill
|= SPILLFLAG_OFF
;
3592 ** The following global variable is incremented whenever the library
3593 ** attempts to open a temporary file. This information is used for
3594 ** testing and analysis only.
3597 int sqlite3_opentemp_count
= 0;
3601 ** Open a temporary file.
3603 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
3604 ** or some other error code if we fail. The OS will automatically
3605 ** delete the temporary file when it is closed.
3607 ** The flags passed to the VFS layer xOpen() call are those specified
3608 ** by parameter vfsFlags ORed with the following:
3610 ** SQLITE_OPEN_READWRITE
3611 ** SQLITE_OPEN_CREATE
3612 ** SQLITE_OPEN_EXCLUSIVE
3613 ** SQLITE_OPEN_DELETEONCLOSE
3615 static int pagerOpentemp(
3616 Pager
*pPager
, /* The pager object */
3617 sqlite3_file
*pFile
, /* Write the file descriptor here */
3618 int vfsFlags
/* Flags passed through to the VFS */
3620 int rc
; /* Return code */
3623 sqlite3_opentemp_count
++; /* Used for testing and analysis only */
3626 vfsFlags
|= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
|
3627 SQLITE_OPEN_EXCLUSIVE
| SQLITE_OPEN_DELETEONCLOSE
;
3628 rc
= sqlite3OsOpen(pPager
->pVfs
, 0, pFile
, vfsFlags
, 0);
3629 assert( rc
!=SQLITE_OK
|| isOpen(pFile
) );
3634 ** Set the busy handler function.
3636 ** The pager invokes the busy-handler if sqlite3OsLock() returns
3637 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
3638 ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
3639 ** lock. It does *not* invoke the busy handler when upgrading from
3640 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
3641 ** (which occurs during hot-journal rollback). Summary:
3643 ** Transition | Invokes xBusyHandler
3644 ** --------------------------------------------------------
3645 ** NO_LOCK -> SHARED_LOCK | Yes
3646 ** SHARED_LOCK -> RESERVED_LOCK | No
3647 ** SHARED_LOCK -> EXCLUSIVE_LOCK | No
3648 ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
3650 ** If the busy-handler callback returns non-zero, the lock is
3651 ** retried. If it returns zero, then the SQLITE_BUSY error is
3652 ** returned to the caller of the pager API function.
3654 void sqlite3PagerSetBusyHandler(
3655 Pager
*pPager
, /* Pager object */
3656 int (*xBusyHandler
)(void *), /* Pointer to busy-handler function */
3657 void *pBusyHandlerArg
/* Argument to pass to xBusyHandler */
3660 pPager
->xBusyHandler
= xBusyHandler
;
3661 pPager
->pBusyHandlerArg
= pBusyHandlerArg
;
3662 ap
= (void **)&pPager
->xBusyHandler
;
3663 assert( ((int(*)(void *))(ap
[0]))==xBusyHandler
);
3664 assert( ap
[1]==pBusyHandlerArg
);
3665 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_BUSYHANDLER
, (void *)ap
);
3669 ** Change the page size used by the Pager object. The new page size
3670 ** is passed in *pPageSize.
3672 ** If the pager is in the error state when this function is called, it
3673 ** is a no-op. The value returned is the error state error code (i.e.
3674 ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
3676 ** Otherwise, if all of the following are true:
3678 ** * the new page size (value of *pPageSize) is valid (a power
3679 ** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
3681 ** * there are no outstanding page references, and
3683 ** * the database is either not an in-memory database or it is
3684 ** an in-memory database that currently consists of zero pages.
3686 ** then the pager object page size is set to *pPageSize.
3688 ** If the page size is changed, then this function uses sqlite3PagerMalloc()
3689 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
3690 ** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
3691 ** In all other cases, SQLITE_OK is returned.
3693 ** If the page size is not changed, either because one of the enumerated
3694 ** conditions above is not true, the pager was in error state when this
3695 ** function was called, or because the memory allocation attempt failed,
3696 ** then *pPageSize is set to the old, retained page size before returning.
3698 int sqlite3PagerSetPagesize(Pager
*pPager
, u32
*pPageSize
, int nReserve
){
3701 /* It is not possible to do a full assert_pager_state() here, as this
3702 ** function may be called from within PagerOpen(), before the state
3703 ** of the Pager object is internally consistent.
3705 ** At one point this function returned an error if the pager was in
3706 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
3707 ** there is at least one outstanding page reference, this function
3708 ** is a no-op for that case anyhow.
3711 u32 pageSize
= *pPageSize
;
3712 assert( pageSize
==0 || (pageSize
>=512 && pageSize
<=SQLITE_MAX_PAGE_SIZE
) );
3713 if( (pPager
->memDb
==0 || pPager
->dbSize
==0)
3714 && sqlite3PcacheRefCount(pPager
->pPCache
)==0
3715 && pageSize
&& pageSize
!=(u32
)pPager
->pageSize
3717 char *pNew
= NULL
; /* New temp space */
3720 if( pPager
->eState
>PAGER_OPEN
&& isOpen(pPager
->fd
) ){
3721 rc
= sqlite3OsFileSize(pPager
->fd
, &nByte
);
3723 if( rc
==SQLITE_OK
){
3724 /* 8 bytes of zeroed overrun space is sufficient so that the b-tree
3725 * cell header parser will never run off the end of the allocation */
3726 pNew
= (char *)sqlite3PageMalloc(pageSize
+8);
3728 rc
= SQLITE_NOMEM_BKPT
;
3730 memset(pNew
+pageSize
, 0, 8);
3734 if( rc
==SQLITE_OK
){
3735 pager_reset(pPager
);
3736 rc
= sqlite3PcacheSetPageSize(pPager
->pPCache
, pageSize
);
3738 if( rc
==SQLITE_OK
){
3739 sqlite3PageFree(pPager
->pTmpSpace
);
3740 pPager
->pTmpSpace
= pNew
;
3741 pPager
->dbSize
= (Pgno
)((nByte
+pageSize
-1)/pageSize
);
3742 pPager
->pageSize
= pageSize
;
3744 sqlite3PageFree(pNew
);
3748 *pPageSize
= pPager
->pageSize
;
3749 if( rc
==SQLITE_OK
){
3750 if( nReserve
<0 ) nReserve
= pPager
->nReserve
;
3751 assert( nReserve
>=0 && nReserve
<1000 );
3752 pPager
->nReserve
= (i16
)nReserve
;
3753 pagerFixMaplimit(pPager
);
3759 ** Return a pointer to the "temporary page" buffer held internally
3760 ** by the pager. This is a buffer that is big enough to hold the
3761 ** entire content of a database page. This buffer is used internally
3762 ** during rollback and will be overwritten whenever a rollback
3763 ** occurs. But other modules are free to use it too, as long as
3764 ** no rollbacks are happening.
3766 void *sqlite3PagerTempSpace(Pager
*pPager
){
3767 return pPager
->pTmpSpace
;
3771 ** Attempt to set the maximum database page count if mxPage is positive.
3772 ** Make no changes if mxPage is zero or negative. And never reduce the
3773 ** maximum page count below the current size of the database.
3775 ** Regardless of mxPage, return the current maximum page count.
3777 Pgno
sqlite3PagerMaxPageCount(Pager
*pPager
, Pgno mxPage
){
3779 pPager
->mxPgno
= mxPage
;
3781 assert( pPager
->eState
!=PAGER_OPEN
); /* Called only by OP_MaxPgcnt */
3782 /* assert( pPager->mxPgno>=pPager->dbSize ); */
3783 /* OP_MaxPgcnt ensures that the parameter passed to this function is not
3784 ** less than the total number of valid pages in the database. But this
3785 ** may be less than Pager.dbSize, and so the assert() above is not valid */
3786 return pPager
->mxPgno
;
3790 ** The following set of routines are used to disable the simulated
3791 ** I/O error mechanism. These routines are used to avoid simulated
3792 ** errors in places where we do not care about errors.
3794 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
3795 ** and generate no code.
3798 extern int sqlite3_io_error_pending
;
3799 extern int sqlite3_io_error_hit
;
3800 static int saved_cnt
;
3801 void disable_simulated_io_errors(void){
3802 saved_cnt
= sqlite3_io_error_pending
;
3803 sqlite3_io_error_pending
= -1;
3805 void enable_simulated_io_errors(void){
3806 sqlite3_io_error_pending
= saved_cnt
;
3809 # define disable_simulated_io_errors()
3810 # define enable_simulated_io_errors()
3814 ** Read the first N bytes from the beginning of the file into memory
3815 ** that pDest points to.
3817 ** If the pager was opened on a transient file (zFilename==""), or
3818 ** opened on a file less than N bytes in size, the output buffer is
3819 ** zeroed and SQLITE_OK returned. The rationale for this is that this
3820 ** function is used to read database headers, and a new transient or
3821 ** zero sized database has a header than consists entirely of zeroes.
3823 ** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
3824 ** the error code is returned to the caller and the contents of the
3825 ** output buffer undefined.
3827 int sqlite3PagerReadFileheader(Pager
*pPager
, int N
, unsigned char *pDest
){
3829 memset(pDest
, 0, N
);
3830 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
3832 /* This routine is only called by btree immediately after creating
3833 ** the Pager object. There has not been an opportunity to transition
3836 assert( !pagerUseWal(pPager
) );
3838 if( isOpen(pPager
->fd
) ){
3839 IOTRACE(("DBHDR %p 0 %d\n", pPager
, N
))
3840 rc
= sqlite3OsRead(pPager
->fd
, pDest
, N
, 0);
3841 if( rc
==SQLITE_IOERR_SHORT_READ
){
3849 ** This function may only be called when a read-transaction is open on
3850 ** the pager. It returns the total number of pages in the database.
3852 ** However, if the file is between 1 and <page-size> bytes in size, then
3853 ** this is considered a 1 page file.
3855 void sqlite3PagerPagecount(Pager
*pPager
, int *pnPage
){
3856 assert( pPager
->eState
>=PAGER_READER
);
3857 assert( pPager
->eState
!=PAGER_WRITER_FINISHED
);
3858 *pnPage
= (int)pPager
->dbSize
;
3863 ** Try to obtain a lock of type locktype on the database file. If
3864 ** a similar or greater lock is already held, this function is a no-op
3865 ** (returning SQLITE_OK immediately).
3867 ** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
3868 ** the busy callback if the lock is currently not available. Repeat
3869 ** until the busy callback returns false or until the attempt to
3870 ** obtain the lock succeeds.
3872 ** Return SQLITE_OK on success and an error code if we cannot obtain
3873 ** the lock. If the lock is obtained successfully, set the Pager.state
3874 ** variable to locktype before returning.
3876 static int pager_wait_on_lock(Pager
*pPager
, int locktype
){
3877 int rc
; /* Return code */
3879 /* Check that this is either a no-op (because the requested lock is
3880 ** already held), or one of the transitions that the busy-handler
3881 ** may be invoked during, according to the comment above
3882 ** sqlite3PagerSetBusyhandler().
3884 assert( (pPager
->eLock
>=locktype
)
3885 || (pPager
->eLock
==NO_LOCK
&& locktype
==SHARED_LOCK
)
3886 || (pPager
->eLock
==RESERVED_LOCK
&& locktype
==EXCLUSIVE_LOCK
)
3890 rc
= pagerLockDb(pPager
, locktype
);
3891 }while( rc
==SQLITE_BUSY
&& pPager
->xBusyHandler(pPager
->pBusyHandlerArg
) );
3896 ** Function assertTruncateConstraint(pPager) checks that one of the
3897 ** following is true for all dirty pages currently in the page-cache:
3899 ** a) The page number is less than or equal to the size of the
3900 ** current database image, in pages, OR
3902 ** b) if the page content were written at this time, it would not
3903 ** be necessary to write the current content out to the sub-journal
3904 ** (as determined by function subjRequiresPage()).
3906 ** If the condition asserted by this function were not true, and the
3907 ** dirty page were to be discarded from the cache via the pagerStress()
3908 ** routine, pagerStress() would not write the current page content to
3909 ** the database file. If a savepoint transaction were rolled back after
3910 ** this happened, the correct behavior would be to restore the current
3911 ** content of the page. However, since this content is not present in either
3912 ** the database file or the portion of the rollback journal and
3913 ** sub-journal rolled back the content could not be restored and the
3914 ** database image would become corrupt. It is therefore fortunate that
3915 ** this circumstance cannot arise.
3917 #if defined(SQLITE_DEBUG)
3918 static void assertTruncateConstraintCb(PgHdr
*pPg
){
3919 assert( pPg
->flags
&PGHDR_DIRTY
);
3920 assert( pPg
->pgno
<=pPg
->pPager
->dbSize
|| !subjRequiresPage(pPg
) );
3922 static void assertTruncateConstraint(Pager
*pPager
){
3923 sqlite3PcacheIterateDirty(pPager
->pPCache
, assertTruncateConstraintCb
);
3926 # define assertTruncateConstraint(pPager)
3930 ** Truncate the in-memory database file image to nPage pages. This
3931 ** function does not actually modify the database file on disk. It
3932 ** just sets the internal state of the pager object so that the
3933 ** truncation will be done when the current transaction is committed.
3935 ** This function is only called right before committing a transaction.
3936 ** Once this function has been called, the transaction must either be
3937 ** rolled back or committed. It is not safe to call this function and
3938 ** then continue writing to the database.
3940 void sqlite3PagerTruncateImage(Pager
*pPager
, Pgno nPage
){
3941 assert( pPager
->dbSize
>=nPage
|| CORRUPT_DB
);
3942 testcase( pPager
->dbSize
<nPage
);
3943 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
);
3944 pPager
->dbSize
= nPage
;
3946 /* At one point the code here called assertTruncateConstraint() to
3947 ** ensure that all pages being truncated away by this operation are,
3948 ** if one or more savepoints are open, present in the savepoint
3949 ** journal so that they can be restored if the savepoint is rolled
3950 ** back. This is no longer necessary as this function is now only
3951 ** called right before committing a transaction. So although the
3952 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
3953 ** they cannot be rolled back. So the assertTruncateConstraint() call
3954 ** is no longer correct. */
3959 ** This function is called before attempting a hot-journal rollback. It
3960 ** syncs the journal file to disk, then sets pPager->journalHdr to the
3961 ** size of the journal file so that the pager_playback() routine knows
3962 ** that the entire journal file has been synced.
3964 ** Syncing a hot-journal to disk before attempting to roll it back ensures
3965 ** that if a power-failure occurs during the rollback, the process that
3966 ** attempts rollback following system recovery sees the same journal
3967 ** content as this process.
3969 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
3970 ** an SQLite error code.
3972 static int pagerSyncHotJournal(Pager
*pPager
){
3974 if( !pPager
->noSync
){
3975 rc
= sqlite3OsSync(pPager
->jfd
, SQLITE_SYNC_NORMAL
);
3977 if( rc
==SQLITE_OK
){
3978 rc
= sqlite3OsFileSize(pPager
->jfd
, &pPager
->journalHdr
);
3983 #if SQLITE_MAX_MMAP_SIZE>0
3985 ** Obtain a reference to a memory mapped page object for page number pgno.
3986 ** The new object will use the pointer pData, obtained from xFetch().
3987 ** If successful, set *ppPage to point to the new page reference
3988 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
3991 ** Page references obtained by calling this function should be released
3992 ** by calling pagerReleaseMapPage().
3994 static int pagerAcquireMapPage(
3995 Pager
*pPager
, /* Pager object */
3996 Pgno pgno
, /* Page number */
3997 void *pData
, /* xFetch()'d data for this page */
3998 PgHdr
**ppPage
/* OUT: Acquired page object */
4000 PgHdr
*p
; /* Memory mapped page to return */
4002 if( pPager
->pMmapFreelist
){
4003 *ppPage
= p
= pPager
->pMmapFreelist
;
4004 pPager
->pMmapFreelist
= p
->pDirty
;
4006 assert( pPager
->nExtra
>=8 );
4007 memset(p
->pExtra
, 0, 8);
4009 *ppPage
= p
= (PgHdr
*)sqlite3MallocZero(sizeof(PgHdr
) + pPager
->nExtra
);
4011 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pgno
-1) * pPager
->pageSize
, pData
);
4012 return SQLITE_NOMEM_BKPT
;
4014 p
->pExtra
= (void *)&p
[1];
4015 p
->flags
= PGHDR_MMAP
;
4020 assert( p
->pExtra
==(void *)&p
[1] );
4021 assert( p
->pPage
==0 );
4022 assert( p
->flags
==PGHDR_MMAP
);
4023 assert( p
->pPager
==pPager
);
4024 assert( p
->nRef
==1 );
4035 ** Release a reference to page pPg. pPg must have been returned by an
4036 ** earlier call to pagerAcquireMapPage().
4038 static void pagerReleaseMapPage(PgHdr
*pPg
){
4039 Pager
*pPager
= pPg
->pPager
;
4041 pPg
->pDirty
= pPager
->pMmapFreelist
;
4042 pPager
->pMmapFreelist
= pPg
;
4044 assert( pPager
->fd
->pMethods
->iVersion
>=3 );
4045 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pPg
->pgno
-1)*pPager
->pageSize
, pPg
->pData
);
4049 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
4051 static void pagerFreeMapHdrs(Pager
*pPager
){
4054 for(p
=pPager
->pMmapFreelist
; p
; p
=pNext
){
4060 /* Verify that the database file has not be deleted or renamed out from
4061 ** under the pager. Return SQLITE_OK if the database is still where it ought
4062 ** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
4063 ** code from sqlite3OsAccess()) if the database has gone missing.
4065 static int databaseIsUnmoved(Pager
*pPager
){
4069 if( pPager
->tempFile
) return SQLITE_OK
;
4070 if( pPager
->dbSize
==0 ) return SQLITE_OK
;
4071 assert( pPager
->zFilename
&& pPager
->zFilename
[0] );
4072 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_HAS_MOVED
, &bHasMoved
);
4073 if( rc
==SQLITE_NOTFOUND
){
4074 /* If the HAS_MOVED file-control is unimplemented, assume that the file
4075 ** has not been moved. That is the historical behavior of SQLite: prior to
4076 ** version 3.8.3, it never checked */
4078 }else if( rc
==SQLITE_OK
&& bHasMoved
){
4079 rc
= SQLITE_READONLY_DBMOVED
;
4086 ** Shutdown the page cache. Free all memory and close all files.
4088 ** If a transaction was in progress when this routine is called, that
4089 ** transaction is rolled back. All outstanding pages are invalidated
4090 ** and their memory is freed. Any attempt to use a page associated
4091 ** with this page cache after this function returns will likely
4092 ** result in a coredump.
4094 ** This function always succeeds. If a transaction is active an attempt
4095 ** is made to roll it back. If an error occurs during the rollback
4096 ** a hot journal may be left in the filesystem but no error is returned
4099 int sqlite3PagerClose(Pager
*pPager
, sqlite3
*db
){
4100 u8
*pTmp
= (u8
*)pPager
->pTmpSpace
;
4101 assert( db
|| pagerUseWal(pPager
)==0 );
4102 assert( assert_pager_state(pPager
) );
4103 disable_simulated_io_errors();
4104 sqlite3BeginBenignMalloc();
4105 pagerFreeMapHdrs(pPager
);
4106 /* pPager->errCode = 0; */
4107 pPager
->exclusiveMode
= 0;
4108 #ifndef SQLITE_OMIT_WAL
4111 assert( db
|| pPager
->pWal
==0 );
4112 if( db
&& 0==(db
->flags
& SQLITE_NoCkptOnClose
)
4113 && SQLITE_OK
==databaseIsUnmoved(pPager
)
4117 sqlite3WalClose(pPager
->pWal
, db
, pPager
->walSyncFlags
, pPager
->pageSize
,a
);
4121 pager_reset(pPager
);
4123 pager_unlock(pPager
);
4125 /* If it is open, sync the journal file before calling UnlockAndRollback.
4126 ** If this is not done, then an unsynced portion of the open journal
4127 ** file may be played back into the database. If a power failure occurs
4128 ** while this is happening, the database could become corrupt.
4130 ** If an error occurs while trying to sync the journal, shift the pager
4131 ** into the ERROR state. This causes UnlockAndRollback to unlock the
4132 ** database and close the journal file without attempting to roll it
4133 ** back or finalize it. The next database user will have to do hot-journal
4134 ** rollback before accessing the database file.
4136 if( isOpen(pPager
->jfd
) ){
4137 pager_error(pPager
, pagerSyncHotJournal(pPager
));
4139 pagerUnlockAndRollback(pPager
);
4141 sqlite3EndBenignMalloc();
4142 enable_simulated_io_errors();
4143 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager
)));
4144 IOTRACE(("CLOSE %p\n", pPager
))
4145 sqlite3OsClose(pPager
->jfd
);
4146 sqlite3OsClose(pPager
->fd
);
4147 sqlite3PageFree(pTmp
);
4148 sqlite3PcacheClose(pPager
->pPCache
);
4149 assert( !pPager
->aSavepoint
&& !pPager
->pInJournal
);
4150 assert( !isOpen(pPager
->jfd
) && !isOpen(pPager
->sjfd
) );
4152 sqlite3_free(pPager
);
4156 #if !defined(NDEBUG) || defined(SQLITE_TEST)
4158 ** Return the page number for page pPg.
4160 Pgno
sqlite3PagerPagenumber(DbPage
*pPg
){
4166 ** Increment the reference count for page pPg.
4168 void sqlite3PagerRef(DbPage
*pPg
){
4169 sqlite3PcacheRef(pPg
);
4173 ** Sync the journal. In other words, make sure all the pages that have
4174 ** been written to the journal have actually reached the surface of the
4175 ** disk and can be restored in the event of a hot-journal rollback.
4177 ** If the Pager.noSync flag is set, then this function is a no-op.
4178 ** Otherwise, the actions required depend on the journal-mode and the
4179 ** device characteristics of the file-system, as follows:
4181 ** * If the journal file is an in-memory journal file, no action need
4184 ** * Otherwise, if the device does not support the SAFE_APPEND property,
4185 ** then the nRec field of the most recently written journal header
4186 ** is updated to contain the number of journal records that have
4187 ** been written following it. If the pager is operating in full-sync
4188 ** mode, then the journal file is synced before this field is updated.
4190 ** * If the device does not support the SEQUENTIAL property, then
4191 ** journal file is synced.
4193 ** Or, in pseudo-code:
4195 ** if( NOT <in-memory journal> ){
4196 ** if( NOT SAFE_APPEND ){
4197 ** if( <full-sync mode> ) xSync(<journal file>);
4198 ** <update nRec field>
4200 ** if( NOT SEQUENTIAL ) xSync(<journal file>);
4203 ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
4204 ** page currently held in memory before returning SQLITE_OK. If an IO
4205 ** error is encountered, then the IO error code is returned to the caller.
4207 static int syncJournal(Pager
*pPager
, int newHdr
){
4208 int rc
; /* Return code */
4210 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
4211 || pPager
->eState
==PAGER_WRITER_DBMOD
4213 assert( assert_pager_state(pPager
) );
4214 assert( !pagerUseWal(pPager
) );
4216 rc
= sqlite3PagerExclusiveLock(pPager
);
4217 if( rc
!=SQLITE_OK
) return rc
;
4219 if( !pPager
->noSync
){
4220 assert( !pPager
->tempFile
);
4221 if( isOpen(pPager
->jfd
) && pPager
->journalMode
!=PAGER_JOURNALMODE_MEMORY
){
4222 const int iDc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
4223 assert( isOpen(pPager
->jfd
) );
4225 if( 0==(iDc
&SQLITE_IOCAP_SAFE_APPEND
) ){
4226 /* This block deals with an obscure problem. If the last connection
4227 ** that wrote to this database was operating in persistent-journal
4228 ** mode, then the journal file may at this point actually be larger
4229 ** than Pager.journalOff bytes. If the next thing in the journal
4230 ** file happens to be a journal-header (written as part of the
4231 ** previous connection's transaction), and a crash or power-failure
4232 ** occurs after nRec is updated but before this connection writes
4233 ** anything else to the journal file (or commits/rolls back its
4234 ** transaction), then SQLite may become confused when doing the
4235 ** hot-journal rollback following recovery. It may roll back all
4236 ** of this connections data, then proceed to rolling back the old,
4237 ** out-of-date data that follows it. Database corruption.
4239 ** To work around this, if the journal file does appear to contain
4240 ** a valid header following Pager.journalOff, then write a 0x00
4241 ** byte to the start of it to prevent it from being recognized.
4243 ** Variable iNextHdrOffset is set to the offset at which this
4244 ** problematic header will occur, if it exists. aMagic is used
4245 ** as a temporary buffer to inspect the first couple of bytes of
4246 ** the potential journal header.
4250 u8 zHeader
[sizeof(aJournalMagic
)+4];
4252 memcpy(zHeader
, aJournalMagic
, sizeof(aJournalMagic
));
4253 put32bits(&zHeader
[sizeof(aJournalMagic
)], pPager
->nRec
);
4255 iNextHdrOffset
= journalHdrOffset(pPager
);
4256 rc
= sqlite3OsRead(pPager
->jfd
, aMagic
, 8, iNextHdrOffset
);
4257 if( rc
==SQLITE_OK
&& 0==memcmp(aMagic
, aJournalMagic
, 8) ){
4258 static const u8 zerobyte
= 0;
4259 rc
= sqlite3OsWrite(pPager
->jfd
, &zerobyte
, 1, iNextHdrOffset
);
4261 if( rc
!=SQLITE_OK
&& rc
!=SQLITE_IOERR_SHORT_READ
){
4265 /* Write the nRec value into the journal file header. If in
4266 ** full-synchronous mode, sync the journal first. This ensures that
4267 ** all data has really hit the disk before nRec is updated to mark
4268 ** it as a candidate for rollback.
4270 ** This is not required if the persistent media supports the
4271 ** SAFE_APPEND property. Because in this case it is not possible
4272 ** for garbage data to be appended to the file, the nRec field
4273 ** is populated with 0xFFFFFFFF when the journal header is written
4274 ** and never needs to be updated.
4276 if( pPager
->fullSync
&& 0==(iDc
&SQLITE_IOCAP_SEQUENTIAL
) ){
4277 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager
)));
4278 IOTRACE(("JSYNC %p\n", pPager
))
4279 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
);
4280 if( rc
!=SQLITE_OK
) return rc
;
4282 IOTRACE(("JHDR %p %lld\n", pPager
, pPager
->journalHdr
));
4283 rc
= sqlite3OsWrite(
4284 pPager
->jfd
, zHeader
, sizeof(zHeader
), pPager
->journalHdr
4286 if( rc
!=SQLITE_OK
) return rc
;
4288 if( 0==(iDc
&SQLITE_IOCAP_SEQUENTIAL
) ){
4289 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager
)));
4290 IOTRACE(("JSYNC %p\n", pPager
))
4291 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
|
4292 (pPager
->syncFlags
==SQLITE_SYNC_FULL
?SQLITE_SYNC_DATAONLY
:0)
4294 if( rc
!=SQLITE_OK
) return rc
;
4297 pPager
->journalHdr
= pPager
->journalOff
;
4298 if( newHdr
&& 0==(iDc
&SQLITE_IOCAP_SAFE_APPEND
) ){
4300 rc
= writeJournalHdr(pPager
);
4301 if( rc
!=SQLITE_OK
) return rc
;
4304 pPager
->journalHdr
= pPager
->journalOff
;
4308 /* Unless the pager is in noSync mode, the journal file was just
4309 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
4312 sqlite3PcacheClearSyncFlags(pPager
->pPCache
);
4313 pPager
->eState
= PAGER_WRITER_DBMOD
;
4314 assert( assert_pager_state(pPager
) );
4319 ** The argument is the first in a linked list of dirty pages connected
4320 ** by the PgHdr.pDirty pointer. This function writes each one of the
4321 ** in-memory pages in the list to the database file. The argument may
4322 ** be NULL, representing an empty list. In this case this function is
4325 ** The pager must hold at least a RESERVED lock when this function
4326 ** is called. Before writing anything to the database file, this lock
4327 ** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
4328 ** SQLITE_BUSY is returned and no data is written to the database file.
4330 ** If the pager is a temp-file pager and the actual file-system file
4331 ** is not yet open, it is created and opened before any data is
4334 ** Once the lock has been upgraded and, if necessary, the file opened,
4335 ** the pages are written out to the database file in list order. Writing
4336 ** a page is skipped if it meets either of the following criteria:
4338 ** * The page number is greater than Pager.dbSize, or
4339 ** * The PGHDR_DONT_WRITE flag is set on the page.
4341 ** If writing out a page causes the database file to grow, Pager.dbFileSize
4342 ** is updated accordingly. If page 1 is written out, then the value cached
4343 ** in Pager.dbFileVers[] is updated to match the new value stored in
4344 ** the database file.
4346 ** If everything is successful, SQLITE_OK is returned. If an IO error
4347 ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
4348 ** be obtained, SQLITE_BUSY is returned.
4350 static int pager_write_pagelist(Pager
*pPager
, PgHdr
*pList
){
4351 int rc
= SQLITE_OK
; /* Return code */
4353 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
4354 assert( !pagerUseWal(pPager
) );
4355 assert( pPager
->tempFile
|| pPager
->eState
==PAGER_WRITER_DBMOD
);
4356 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
4357 assert( isOpen(pPager
->fd
) || pList
->pDirty
==0 );
4359 /* If the file is a temp-file has not yet been opened, open it now. It
4360 ** is not possible for rc to be other than SQLITE_OK if this branch
4361 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
4363 if( !isOpen(pPager
->fd
) ){
4364 assert( pPager
->tempFile
&& rc
==SQLITE_OK
);
4365 rc
= pagerOpentemp(pPager
, pPager
->fd
, pPager
->vfsFlags
);
4368 /* Before the first write, give the VFS a hint of what the final
4369 ** file size will be.
4371 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->fd
) );
4373 && pPager
->dbHintSize
<pPager
->dbSize
4374 && (pList
->pDirty
|| pList
->pgno
>pPager
->dbHintSize
)
4376 sqlite3_int64 szFile
= pPager
->pageSize
* (sqlite3_int64
)pPager
->dbSize
;
4377 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_SIZE_HINT
, &szFile
);
4378 pPager
->dbHintSize
= pPager
->dbSize
;
4381 while( rc
==SQLITE_OK
&& pList
){
4382 Pgno pgno
= pList
->pgno
;
4384 /* If there are dirty pages in the page cache with page numbers greater
4385 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
4386 ** make the file smaller (presumably by auto-vacuum code). Do not write
4387 ** any such pages to the file.
4389 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
4390 ** set (set by sqlite3PagerDontWrite()).
4392 if( pgno
<=pPager
->dbSize
&& 0==(pList
->flags
&PGHDR_DONT_WRITE
) ){
4393 i64 offset
= (pgno
-1)*(i64
)pPager
->pageSize
; /* Offset to write */
4394 char *pData
; /* Data to write */
4396 assert( (pList
->flags
&PGHDR_NEED_SYNC
)==0 );
4397 if( pList
->pgno
==1 ) pager_write_changecounter(pList
);
4399 pData
= pList
->pData
;
4401 /* Write out the page data. */
4402 rc
= sqlite3OsWrite(pPager
->fd
, pData
, pPager
->pageSize
, offset
);
4404 /* If page 1 was just written, update Pager.dbFileVers to match
4405 ** the value now stored in the database file. If writing this
4406 ** page caused the database file to grow, update dbFileSize.
4409 memcpy(&pPager
->dbFileVers
, &pData
[24], sizeof(pPager
->dbFileVers
));
4411 if( pgno
>pPager
->dbFileSize
){
4412 pPager
->dbFileSize
= pgno
;
4414 pPager
->aStat
[PAGER_STAT_WRITE
]++;
4416 /* Update any backup objects copying the contents of this pager. */
4417 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)pList
->pData
);
4419 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
4420 PAGERID(pPager
), pgno
, pager_pagehash(pList
)));
4421 IOTRACE(("PGOUT %p %d\n", pPager
, pgno
));
4422 PAGER_INCR(sqlite3_pager_writedb_count
);
4424 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager
), pgno
));
4426 pager_set_pagehash(pList
);
4427 pList
= pList
->pDirty
;
4434 ** Ensure that the sub-journal file is open. If it is already open, this
4435 ** function is a no-op.
4437 ** SQLITE_OK is returned if everything goes according to plan. An
4438 ** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
4441 static int openSubJournal(Pager
*pPager
){
4443 if( !isOpen(pPager
->sjfd
) ){
4444 const int flags
= SQLITE_OPEN_SUBJOURNAL
| SQLITE_OPEN_READWRITE
4445 | SQLITE_OPEN_CREATE
| SQLITE_OPEN_EXCLUSIVE
4446 | SQLITE_OPEN_DELETEONCLOSE
;
4447 int nStmtSpill
= sqlite3Config
.nStmtSpill
;
4448 if( pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
|| pPager
->subjInMemory
){
4451 rc
= sqlite3JournalOpen(pPager
->pVfs
, 0, pPager
->sjfd
, flags
, nStmtSpill
);
4457 ** Append a record of the current state of page pPg to the sub-journal.
4459 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
4460 ** for all open savepoints before returning.
4462 ** This function returns SQLITE_OK if everything is successful, an IO
4463 ** error code if the attempt to write to the sub-journal fails, or
4464 ** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
4467 static int subjournalPage(PgHdr
*pPg
){
4469 Pager
*pPager
= pPg
->pPager
;
4470 if( pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
4472 /* Open the sub-journal, if it has not already been opened */
4473 assert( pPager
->useJournal
);
4474 assert( isOpen(pPager
->jfd
) || pagerUseWal(pPager
) );
4475 assert( isOpen(pPager
->sjfd
) || pPager
->nSubRec
==0 );
4476 assert( pagerUseWal(pPager
)
4477 || pageInJournal(pPager
, pPg
)
4478 || pPg
->pgno
>pPager
->dbOrigSize
4480 rc
= openSubJournal(pPager
);
4482 /* If the sub-journal was opened successfully (or was already open),
4483 ** write the journal record into the file. */
4484 if( rc
==SQLITE_OK
){
4485 void *pData
= pPg
->pData
;
4486 i64 offset
= (i64
)pPager
->nSubRec
*(4+pPager
->pageSize
);
4489 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager
), pPg
->pgno
));
4490 rc
= write32bits(pPager
->sjfd
, offset
, pPg
->pgno
);
4491 if( rc
==SQLITE_OK
){
4492 rc
= sqlite3OsWrite(pPager
->sjfd
, pData2
, pPager
->pageSize
, offset
+4);
4496 if( rc
==SQLITE_OK
){
4498 assert( pPager
->nSavepoint
>0 );
4499 rc
= addToSavepointBitvecs(pPager
, pPg
->pgno
);
4503 static int subjournalPageIfRequired(PgHdr
*pPg
){
4504 if( subjRequiresPage(pPg
) ){
4505 return subjournalPage(pPg
);
4512 ** This function is called by the pcache layer when it has reached some
4513 ** soft memory limit. The first argument is a pointer to a Pager object
4514 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
4515 ** database). The second argument is a reference to a page that is
4516 ** currently dirty but has no outstanding references. The page
4517 ** is always associated with the Pager object passed as the first
4520 ** The job of this function is to make pPg clean by writing its contents
4521 ** out to the database file, if possible. This may involve syncing the
4524 ** If successful, sqlite3PcacheMakeClean() is called on the page and
4525 ** SQLITE_OK returned. If an IO error occurs while trying to make the
4526 ** page clean, the IO error code is returned. If the page cannot be
4527 ** made clean for some other reason, but no error occurs, then SQLITE_OK
4528 ** is returned by sqlite3PcacheMakeClean() is not called.
4530 static int pagerStress(void *p
, PgHdr
*pPg
){
4531 Pager
*pPager
= (Pager
*)p
;
4534 assert( pPg
->pPager
==pPager
);
4535 assert( pPg
->flags
&PGHDR_DIRTY
);
4537 /* The doNotSpill NOSYNC bit is set during times when doing a sync of
4538 ** journal (and adding a new header) is not allowed. This occurs
4539 ** during calls to sqlite3PagerWrite() while trying to journal multiple
4540 ** pages belonging to the same sector.
4542 ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
4543 ** regardless of whether or not a sync is required. This is set during
4544 ** a rollback or by user request, respectively.
4546 ** Spilling is also prohibited when in an error state since that could
4547 ** lead to database corruption. In the current implementation it
4548 ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
4549 ** while in the error state, hence it is impossible for this routine to
4550 ** be called in the error state. Nevertheless, we include a NEVER()
4551 ** test for the error state as a safeguard against future changes.
4553 if( NEVER(pPager
->errCode
) ) return SQLITE_OK
;
4554 testcase( pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
);
4555 testcase( pPager
->doNotSpill
& SPILLFLAG_OFF
);
4556 testcase( pPager
->doNotSpill
& SPILLFLAG_NOSYNC
);
4557 if( pPager
->doNotSpill
4558 && ((pPager
->doNotSpill
& (SPILLFLAG_ROLLBACK
|SPILLFLAG_OFF
))!=0
4559 || (pPg
->flags
& PGHDR_NEED_SYNC
)!=0)
4564 pPager
->aStat
[PAGER_STAT_SPILL
]++;
4566 if( pagerUseWal(pPager
) ){
4567 /* Write a single frame for this page to the log. */
4568 rc
= subjournalPageIfRequired(pPg
);
4569 if( rc
==SQLITE_OK
){
4570 rc
= pagerWalFrames(pPager
, pPg
, 0, 0);
4574 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
4575 if( pPager
->tempFile
==0 ){
4576 rc
= sqlite3JournalCreate(pPager
->jfd
);
4577 if( rc
!=SQLITE_OK
) return pager_error(pPager
, rc
);
4581 /* Sync the journal file if required. */
4582 if( pPg
->flags
&PGHDR_NEED_SYNC
4583 || pPager
->eState
==PAGER_WRITER_CACHEMOD
4585 rc
= syncJournal(pPager
, 1);
4588 /* Write the contents of the page out to the database file. */
4589 if( rc
==SQLITE_OK
){
4590 assert( (pPg
->flags
&PGHDR_NEED_SYNC
)==0 );
4591 rc
= pager_write_pagelist(pPager
, pPg
);
4595 /* Mark the page as clean. */
4596 if( rc
==SQLITE_OK
){
4597 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager
), pPg
->pgno
));
4598 sqlite3PcacheMakeClean(pPg
);
4601 return pager_error(pPager
, rc
);
4605 ** Flush all unreferenced dirty pages to disk.
4607 int sqlite3PagerFlush(Pager
*pPager
){
4608 int rc
= pPager
->errCode
;
4610 PgHdr
*pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
4611 assert( assert_pager_state(pPager
) );
4612 while( rc
==SQLITE_OK
&& pList
){
4613 PgHdr
*pNext
= pList
->pDirty
;
4614 if( pList
->nRef
==0 ){
4615 rc
= pagerStress((void*)pPager
, pList
);
4625 ** Allocate and initialize a new Pager object and put a pointer to it
4626 ** in *ppPager. The pager should eventually be freed by passing it
4627 ** to sqlite3PagerClose().
4629 ** The zFilename argument is the path to the database file to open.
4630 ** If zFilename is NULL then a randomly-named temporary file is created
4631 ** and used as the file to be cached. Temporary files are be deleted
4632 ** automatically when they are closed. If zFilename is ":memory:" then
4633 ** all information is held in cache. It is never written to disk.
4634 ** This can be used to implement an in-memory database.
4636 ** The nExtra parameter specifies the number of bytes of space allocated
4637 ** along with each page reference. This space is available to the user
4638 ** via the sqlite3PagerGetExtra() API. When a new page is allocated, the
4639 ** first 8 bytes of this space are zeroed but the remainder is uninitialized.
4640 ** (The extra space is used by btree as the MemPage object.)
4642 ** The flags argument is used to specify properties that affect the
4643 ** operation of the pager. It should be passed some bitwise combination
4644 ** of the PAGER_* flags.
4646 ** The vfsFlags parameter is a bitmask to pass to the flags parameter
4647 ** of the xOpen() method of the supplied VFS when opening files.
4649 ** If the pager object is allocated and the specified file opened
4650 ** successfully, SQLITE_OK is returned and *ppPager set to point to
4651 ** the new pager object. If an error occurs, *ppPager is set to NULL
4652 ** and error code returned. This function may return SQLITE_NOMEM
4653 ** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
4654 ** various SQLITE_IO_XXX errors.
4656 int sqlite3PagerOpen(
4657 sqlite3_vfs
*pVfs
, /* The virtual file system to use */
4658 Pager
**ppPager
, /* OUT: Return the Pager structure here */
4659 const char *zFilename
, /* Name of the database file to open */
4660 int nExtra
, /* Extra bytes append to each in-memory page */
4661 int flags
, /* flags controlling this file */
4662 int vfsFlags
, /* flags passed through to sqlite3_vfs.xOpen() */
4663 void (*xReinit
)(DbPage
*) /* Function to reinitialize pages */
4666 Pager
*pPager
= 0; /* Pager object to allocate and return */
4667 int rc
= SQLITE_OK
; /* Return code */
4668 int tempFile
= 0; /* True for temp files (incl. in-memory files) */
4669 int memDb
= 0; /* True if this is an in-memory file */
4670 #ifndef SQLITE_OMIT_DESERIALIZE
4671 int memJM
= 0; /* Memory journal mode */
4675 int readOnly
= 0; /* True if this is a read-only file */
4676 int journalFileSize
; /* Bytes to allocate for each journal fd */
4677 char *zPathname
= 0; /* Full path to database file */
4678 int nPathname
= 0; /* Number of bytes in zPathname */
4679 int useJournal
= (flags
& PAGER_OMIT_JOURNAL
)==0; /* False to omit journal */
4680 int pcacheSize
= sqlite3PcacheSize(); /* Bytes to allocate for PCache */
4681 u32 szPageDflt
= SQLITE_DEFAULT_PAGE_SIZE
; /* Default page size */
4682 const char *zUri
= 0; /* URI args to copy */
4683 int nUriByte
= 1; /* Number of bytes of URI args at *zUri */
4684 int nUri
= 0; /* Number of URI parameters */
4686 /* Figure out how much space is required for each journal file-handle
4687 ** (there are two of them, the main journal and the sub-journal). */
4688 journalFileSize
= ROUND8(sqlite3JournalSize(pVfs
));
4690 /* Set the output variable to NULL in case an error occurs. */
4693 #ifndef SQLITE_OMIT_MEMORYDB
4694 if( flags
& PAGER_MEMORY
){
4696 if( zFilename
&& zFilename
[0] ){
4697 zPathname
= sqlite3DbStrDup(0, zFilename
);
4698 if( zPathname
==0 ) return SQLITE_NOMEM_BKPT
;
4699 nPathname
= sqlite3Strlen30(zPathname
);
4705 /* Compute and store the full pathname in an allocated buffer pointed
4706 ** to by zPathname, length nPathname. Or, if this is a temporary file,
4707 ** leave both nPathname and zPathname set to 0.
4709 if( zFilename
&& zFilename
[0] ){
4711 nPathname
= pVfs
->mxPathname
+1;
4712 zPathname
= sqlite3DbMallocRaw(0, nPathname
*2);
4714 return SQLITE_NOMEM_BKPT
;
4716 zPathname
[0] = 0; /* Make sure initialized even if FullPathname() fails */
4717 rc
= sqlite3OsFullPathname(pVfs
, zFilename
, nPathname
, zPathname
);
4718 if( rc
!=SQLITE_OK
){
4719 if( rc
==SQLITE_OK_SYMLINK
){
4720 if( vfsFlags
& SQLITE_OPEN_NOFOLLOW
){
4721 rc
= SQLITE_CANTOPEN_SYMLINK
;
4727 nPathname
= sqlite3Strlen30(zPathname
);
4728 z
= zUri
= &zFilename
[sqlite3Strlen30(zFilename
)+1];
4734 nUriByte
= (int)(&z
[1] - zUri
);
4735 assert( nUriByte
>=1 );
4736 if( rc
==SQLITE_OK
&& nPathname
+8>pVfs
->mxPathname
){
4737 /* This branch is taken when the journal path required by
4738 ** the database being opened will be more than pVfs->mxPathname
4739 ** bytes in length. This means the database cannot be opened,
4740 ** as it will not be possible to open the journal file or even
4741 ** check for a hot-journal before reading.
4743 rc
= SQLITE_CANTOPEN_BKPT
;
4745 if( rc
!=SQLITE_OK
){
4746 sqlite3DbFree(0, zPathname
);
4751 /* Allocate memory for the Pager structure, PCache object, the
4752 ** three file descriptors, the database file name and the journal
4753 ** file name. The layout in memory is as follows:
4755 ** Pager object (sizeof(Pager) bytes)
4756 ** PCache object (sqlite3PcacheSize() bytes)
4757 ** Database file handle (pVfs->szOsFile bytes)
4758 ** Sub-journal file handle (journalFileSize bytes)
4759 ** Main journal file handle (journalFileSize bytes)
4760 ** Ptr back to the Pager (sizeof(Pager*) bytes)
4761 ** \0\0\0\0 database prefix (4 bytes)
4762 ** Database file name (nPathname+1 bytes)
4763 ** URI query parameters (nUriByte bytes)
4764 ** Journal filename (nPathname+8+1 bytes)
4765 ** WAL filename (nPathname+4+1 bytes)
4766 ** \0\0\0 terminator (3 bytes)
4768 ** Some 3rd-party software, over which we have no control, depends on
4769 ** the specific order of the filenames and the \0 separators between them
4770 ** so that it can (for example) find the database filename given the WAL
4771 ** filename without using the sqlite3_filename_database() API. This is a
4772 ** misuse of SQLite and a bug in the 3rd-party software, but the 3rd-party
4773 ** software is in widespread use, so we try to avoid changing the filename
4774 ** order and formatting if possible. In particular, the details of the
4775 ** filename format expected by 3rd-party software should be as follows:
4777 ** - Main Database Path
4779 ** - Multiple URI components consisting of:
4787 ** - WAL Path (zWALName)
4790 ** The sqlite3_create_filename() interface and the databaseFilename() utility
4791 ** that is used by sqlite3_filename_database() and kin also depend on the
4792 ** specific formatting and order of the various filenames, so if the format
4793 ** changes here, be sure to change it there as well.
4795 pPtr
= (u8
*)sqlite3MallocZero(
4796 ROUND8(sizeof(*pPager
)) + /* Pager structure */
4797 ROUND8(pcacheSize
) + /* PCache object */
4798 ROUND8(pVfs
->szOsFile
) + /* The main db file */
4799 journalFileSize
* 2 + /* The two journal files */
4800 sizeof(pPager
) + /* Space to hold a pointer */
4801 4 + /* Database prefix */
4802 nPathname
+ 1 + /* database filename */
4803 nUriByte
+ /* query parameters */
4804 nPathname
+ 8 + 1 + /* Journal filename */
4805 #ifndef SQLITE_OMIT_WAL
4806 nPathname
+ 4 + 1 + /* WAL filename */
4810 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize
)) );
4812 sqlite3DbFree(0, zPathname
);
4813 return SQLITE_NOMEM_BKPT
;
4815 pPager
= (Pager
*)pPtr
; pPtr
+= ROUND8(sizeof(*pPager
));
4816 pPager
->pPCache
= (PCache
*)pPtr
; pPtr
+= ROUND8(pcacheSize
);
4817 pPager
->fd
= (sqlite3_file
*)pPtr
; pPtr
+= ROUND8(pVfs
->szOsFile
);
4818 pPager
->sjfd
= (sqlite3_file
*)pPtr
; pPtr
+= journalFileSize
;
4819 pPager
->jfd
= (sqlite3_file
*)pPtr
; pPtr
+= journalFileSize
;
4820 assert( EIGHT_BYTE_ALIGNMENT(pPager
->jfd
) );
4821 memcpy(pPtr
, &pPager
, sizeof(pPager
)); pPtr
+= sizeof(pPager
);
4823 /* Fill in the Pager.zFilename and pPager.zQueryParam fields */
4824 pPtr
+= 4; /* Skip zero prefix */
4825 pPager
->zFilename
= (char*)pPtr
;
4827 memcpy(pPtr
, zPathname
, nPathname
); pPtr
+= nPathname
+ 1;
4829 memcpy(pPtr
, zUri
, nUriByte
); pPtr
+= nUriByte
;
4836 /* Fill in Pager.zJournal */
4838 pPager
->zJournal
= (char*)pPtr
;
4839 memcpy(pPtr
, zPathname
, nPathname
); pPtr
+= nPathname
;
4840 memcpy(pPtr
, "-journal",8); pPtr
+= 8 + 1;
4841 #ifdef SQLITE_ENABLE_8_3_NAMES
4842 sqlite3FileSuffix3(zFilename
,pPager
->zJournal
);
4843 pPtr
= (u8
*)(pPager
->zJournal
+ sqlite3Strlen30(pPager
->zJournal
)+1);
4846 pPager
->zJournal
= 0;
4849 #ifndef SQLITE_OMIT_WAL
4850 /* Fill in Pager.zWal */
4852 pPager
->zWal
= (char*)pPtr
;
4853 memcpy(pPtr
, zPathname
, nPathname
); pPtr
+= nPathname
;
4854 memcpy(pPtr
, "-wal", 4); pPtr
+= 4 + 1;
4855 #ifdef SQLITE_ENABLE_8_3_NAMES
4856 sqlite3FileSuffix3(zFilename
, pPager
->zWal
);
4857 pPtr
= (u8
*)(pPager
->zWal
+ sqlite3Strlen30(pPager
->zWal
)+1);
4863 (void)pPtr
; /* Suppress warning about unused pPtr value */
4865 if( nPathname
) sqlite3DbFree(0, zPathname
);
4866 pPager
->pVfs
= pVfs
;
4867 pPager
->vfsFlags
= vfsFlags
;
4869 /* Open the pager file.
4871 if( zFilename
&& zFilename
[0] ){
4872 int fout
= 0; /* VFS flags returned by xOpen() */
4873 rc
= sqlite3OsOpen(pVfs
, pPager
->zFilename
, pPager
->fd
, vfsFlags
, &fout
);
4875 #ifndef SQLITE_OMIT_DESERIALIZE
4876 pPager
->memVfs
= memJM
= (fout
&SQLITE_OPEN_MEMORY
)!=0;
4878 readOnly
= (fout
&SQLITE_OPEN_READONLY
)!=0;
4880 /* If the file was successfully opened for read/write access,
4881 ** choose a default page size in case we have to create the
4882 ** database file. The default page size is the maximum of:
4884 ** + SQLITE_DEFAULT_PAGE_SIZE,
4885 ** + The value returned by sqlite3OsSectorSize()
4886 ** + The largest page size that can be written atomically.
4888 if( rc
==SQLITE_OK
){
4889 int iDc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
4891 setSectorSize(pPager
);
4892 assert(SQLITE_DEFAULT_PAGE_SIZE
<=SQLITE_MAX_DEFAULT_PAGE_SIZE
);
4893 if( szPageDflt
<pPager
->sectorSize
){
4894 if( pPager
->sectorSize
>SQLITE_MAX_DEFAULT_PAGE_SIZE
){
4895 szPageDflt
= SQLITE_MAX_DEFAULT_PAGE_SIZE
;
4897 szPageDflt
= (u32
)pPager
->sectorSize
;
4900 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
4903 assert(SQLITE_IOCAP_ATOMIC512
==(512>>8));
4904 assert(SQLITE_IOCAP_ATOMIC64K
==(65536>>8));
4905 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE
<=65536);
4906 for(ii
=szPageDflt
; ii
<=SQLITE_MAX_DEFAULT_PAGE_SIZE
; ii
=ii
*2){
4907 if( iDc
&(SQLITE_IOCAP_ATOMIC
|(ii
>>8)) ){
4914 pPager
->noLock
= sqlite3_uri_boolean(pPager
->zFilename
, "nolock", 0);
4915 if( (iDc
& SQLITE_IOCAP_IMMUTABLE
)!=0
4916 || sqlite3_uri_boolean(pPager
->zFilename
, "immutable", 0) ){
4917 vfsFlags
|= SQLITE_OPEN_READONLY
;
4918 goto act_like_temp_file
;
4922 /* If a temporary file is requested, it is not opened immediately.
4923 ** In this case we accept the default page size and delay actually
4924 ** opening the file until the first call to OsWrite().
4926 ** This branch is also run for an in-memory database. An in-memory
4927 ** database is the same as a temp-file that is never written out to
4928 ** disk and uses an in-memory rollback journal.
4930 ** This branch also runs for files marked as immutable.
4934 pPager
->eState
= PAGER_READER
; /* Pretend we already have a lock */
4935 pPager
->eLock
= EXCLUSIVE_LOCK
; /* Pretend we are in EXCLUSIVE mode */
4936 pPager
->noLock
= 1; /* Do no locking */
4937 readOnly
= (vfsFlags
&SQLITE_OPEN_READONLY
);
4940 /* The following call to PagerSetPagesize() serves to set the value of
4941 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
4943 if( rc
==SQLITE_OK
){
4944 assert( pPager
->memDb
==0 );
4945 rc
= sqlite3PagerSetPagesize(pPager
, &szPageDflt
, -1);
4946 testcase( rc
!=SQLITE_OK
);
4949 /* Initialize the PCache object. */
4950 if( rc
==SQLITE_OK
){
4951 nExtra
= ROUND8(nExtra
);
4952 assert( nExtra
>=8 && nExtra
<1000 );
4953 rc
= sqlite3PcacheOpen(szPageDflt
, nExtra
, !memDb
,
4954 !memDb
?pagerStress
:0, (void *)pPager
, pPager
->pPCache
);
4957 /* If an error occurred above, free the Pager structure and close the file.
4959 if( rc
!=SQLITE_OK
){
4960 sqlite3OsClose(pPager
->fd
);
4961 sqlite3PageFree(pPager
->pTmpSpace
);
4962 sqlite3_free(pPager
);
4966 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager
->fd
), pPager
->zFilename
));
4967 IOTRACE(("OPEN %p %s\n", pPager
, pPager
->zFilename
))
4969 pPager
->useJournal
= (u8
)useJournal
;
4970 /* pPager->stmtOpen = 0; */
4971 /* pPager->stmtInUse = 0; */
4972 /* pPager->nRef = 0; */
4973 /* pPager->stmtSize = 0; */
4974 /* pPager->stmtJSize = 0; */
4975 /* pPager->nPage = 0; */
4976 pPager
->mxPgno
= SQLITE_MAX_PAGE_COUNT
;
4977 /* pPager->state = PAGER_UNLOCK; */
4978 /* pPager->errMask = 0; */
4979 pPager
->tempFile
= (u8
)tempFile
;
4980 assert( tempFile
==PAGER_LOCKINGMODE_NORMAL
4981 || tempFile
==PAGER_LOCKINGMODE_EXCLUSIVE
);
4982 assert( PAGER_LOCKINGMODE_EXCLUSIVE
==1 );
4983 pPager
->exclusiveMode
= (u8
)tempFile
;
4984 pPager
->changeCountDone
= pPager
->tempFile
;
4985 pPager
->memDb
= (u8
)memDb
;
4986 pPager
->readOnly
= (u8
)readOnly
;
4987 assert( useJournal
|| pPager
->tempFile
);
4988 pPager
->noSync
= pPager
->tempFile
;
4989 if( pPager
->noSync
){
4990 assert( pPager
->fullSync
==0 );
4991 assert( pPager
->extraSync
==0 );
4992 assert( pPager
->syncFlags
==0 );
4993 assert( pPager
->walSyncFlags
==0 );
4995 pPager
->fullSync
= 1;
4996 pPager
->extraSync
= 0;
4997 pPager
->syncFlags
= SQLITE_SYNC_NORMAL
;
4998 pPager
->walSyncFlags
= SQLITE_SYNC_NORMAL
| (SQLITE_SYNC_NORMAL
<<2);
5000 /* pPager->pFirst = 0; */
5001 /* pPager->pFirstSynced = 0; */
5002 /* pPager->pLast = 0; */
5003 pPager
->nExtra
= (u16
)nExtra
;
5004 pPager
->journalSizeLimit
= SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
;
5005 assert( isOpen(pPager
->fd
) || tempFile
);
5006 setSectorSize(pPager
);
5008 pPager
->journalMode
= PAGER_JOURNALMODE_OFF
;
5009 }else if( memDb
|| memJM
){
5010 pPager
->journalMode
= PAGER_JOURNALMODE_MEMORY
;
5012 /* pPager->xBusyHandler = 0; */
5013 /* pPager->pBusyHandlerArg = 0; */
5014 pPager
->xReiniter
= xReinit
;
5015 setGetterMethod(pPager
);
5016 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
5017 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
5024 ** Return the sqlite3_file for the main database given the name
5025 ** of the corresonding WAL or Journal name as passed into
5028 sqlite3_file
*sqlite3_database_file_object(const char *zName
){
5030 while( zName
[-1]!=0 || zName
[-2]!=0 || zName
[-3]!=0 || zName
[-4]!=0 ){
5033 pPager
= *(Pager
**)(zName
- 4 - sizeof(Pager
*));
5039 ** This function is called after transitioning from PAGER_UNLOCK to
5040 ** PAGER_SHARED state. It tests if there is a hot journal present in
5041 ** the file-system for the given pager. A hot journal is one that
5042 ** needs to be played back. According to this function, a hot-journal
5043 ** file exists if the following criteria are met:
5045 ** * The journal file exists in the file system, and
5046 ** * No process holds a RESERVED or greater lock on the database file, and
5047 ** * The database file itself is greater than 0 bytes in size, and
5048 ** * The first byte of the journal file exists and is not 0x00.
5050 ** If the current size of the database file is 0 but a journal file
5051 ** exists, that is probably an old journal left over from a prior
5052 ** database with the same name. In this case the journal file is
5053 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
5056 ** This routine does not check if there is a super-journal filename
5057 ** at the end of the file. If there is, and that super-journal file
5058 ** does not exist, then the journal file is not really hot. In this
5059 ** case this routine will return a false-positive. The pager_playback()
5060 ** routine will discover that the journal file is not really hot and
5061 ** will not roll it back.
5063 ** If a hot-journal file is found to exist, *pExists is set to 1 and
5064 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
5065 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
5066 ** to determine whether or not a hot-journal file exists, the IO error
5067 ** code is returned and the value of *pExists is undefined.
5069 static int hasHotJournal(Pager
*pPager
, int *pExists
){
5070 sqlite3_vfs
* const pVfs
= pPager
->pVfs
;
5071 int rc
= SQLITE_OK
; /* Return code */
5072 int exists
= 1; /* True if a journal file is present */
5073 int jrnlOpen
= !!isOpen(pPager
->jfd
);
5075 assert( pPager
->useJournal
);
5076 assert( isOpen(pPager
->fd
) );
5077 assert( pPager
->eState
==PAGER_OPEN
);
5079 assert( jrnlOpen
==0 || ( sqlite3OsDeviceCharacteristics(pPager
->jfd
) &
5080 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
5085 rc
= sqlite3OsAccess(pVfs
, pPager
->zJournal
, SQLITE_ACCESS_EXISTS
, &exists
);
5087 if( rc
==SQLITE_OK
&& exists
){
5088 int locked
= 0; /* True if some process holds a RESERVED lock */
5090 /* Race condition here: Another process might have been holding the
5091 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
5092 ** call above, but then delete the journal and drop the lock before
5093 ** we get to the following sqlite3OsCheckReservedLock() call. If that
5094 ** is the case, this routine might think there is a hot journal when
5095 ** in fact there is none. This results in a false-positive which will
5096 ** be dealt with by the playback routine. Ticket #3883.
5098 rc
= sqlite3OsCheckReservedLock(pPager
->fd
, &locked
);
5099 if( rc
==SQLITE_OK
&& !locked
){
5100 Pgno nPage
; /* Number of pages in database file */
5102 assert( pPager
->tempFile
==0 );
5103 rc
= pagerPagecount(pPager
, &nPage
);
5104 if( rc
==SQLITE_OK
){
5105 /* If the database is zero pages in size, that means that either (1) the
5106 ** journal is a remnant from a prior database with the same name where
5107 ** the database file but not the journal was deleted, or (2) the initial
5108 ** transaction that populates a new database is being rolled back.
5109 ** In either case, the journal file can be deleted. However, take care
5110 ** not to delete the journal file if it is already open due to
5111 ** journal_mode=PERSIST.
5113 if( nPage
==0 && !jrnlOpen
){
5114 sqlite3BeginBenignMalloc();
5115 if( pagerLockDb(pPager
, RESERVED_LOCK
)==SQLITE_OK
){
5116 sqlite3OsDelete(pVfs
, pPager
->zJournal
, 0);
5117 if( !pPager
->exclusiveMode
) pagerUnlockDb(pPager
, SHARED_LOCK
);
5119 sqlite3EndBenignMalloc();
5121 /* The journal file exists and no other connection has a reserved
5122 ** or greater lock on the database file. Now check that there is
5123 ** at least one non-zero bytes at the start of the journal file.
5124 ** If there is, then we consider this journal to be hot. If not,
5125 ** it can be ignored.
5128 int f
= SQLITE_OPEN_READONLY
|SQLITE_OPEN_MAIN_JOURNAL
;
5129 rc
= sqlite3OsOpen(pVfs
, pPager
->zJournal
, pPager
->jfd
, f
, &f
);
5131 if( rc
==SQLITE_OK
){
5133 rc
= sqlite3OsRead(pPager
->jfd
, (void *)&first
, 1, 0);
5134 if( rc
==SQLITE_IOERR_SHORT_READ
){
5138 sqlite3OsClose(pPager
->jfd
);
5140 *pExists
= (first
!=0);
5141 }else if( rc
==SQLITE_CANTOPEN
){
5142 /* If we cannot open the rollback journal file in order to see if
5143 ** it has a zero header, that might be due to an I/O error, or
5144 ** it might be due to the race condition described above and in
5145 ** ticket #3883. Either way, assume that the journal is hot.
5146 ** This might be a false positive. But if it is, then the
5147 ** automatic journal playback and recovery mechanism will deal
5148 ** with it under an EXCLUSIVE lock where we do not need to
5149 ** worry so much with race conditions.
5163 ** This function is called to obtain a shared lock on the database file.
5164 ** It is illegal to call sqlite3PagerGet() until after this function
5165 ** has been successfully called. If a shared-lock is already held when
5166 ** this function is called, it is a no-op.
5168 ** The following operations are also performed by this function.
5170 ** 1) If the pager is currently in PAGER_OPEN state (no lock held
5171 ** on the database file), then an attempt is made to obtain a
5172 ** SHARED lock on the database file. Immediately after obtaining
5173 ** the SHARED lock, the file-system is checked for a hot-journal,
5174 ** which is played back if present. Following any hot-journal
5175 ** rollback, the contents of the cache are validated by checking
5176 ** the 'change-counter' field of the database file header and
5177 ** discarded if they are found to be invalid.
5179 ** 2) If the pager is running in exclusive-mode, and there are currently
5180 ** no outstanding references to any pages, and is in the error state,
5181 ** then an attempt is made to clear the error state by discarding
5182 ** the contents of the page cache and rolling back any open journal
5185 ** If everything is successful, SQLITE_OK is returned. If an IO error
5186 ** occurs while locking the database, checking for a hot-journal file or
5187 ** rolling back a journal file, the IO error code is returned.
5189 int sqlite3PagerSharedLock(Pager
*pPager
){
5190 int rc
= SQLITE_OK
; /* Return code */
5192 /* This routine is only called from b-tree and only when there are no
5193 ** outstanding pages. This implies that the pager state should either
5194 ** be OPEN or READER. READER is only possible if the pager is or was in
5195 ** exclusive access mode. */
5196 assert( sqlite3PcacheRefCount(pPager
->pPCache
)==0 );
5197 assert( assert_pager_state(pPager
) );
5198 assert( pPager
->eState
==PAGER_OPEN
|| pPager
->eState
==PAGER_READER
);
5199 assert( pPager
->errCode
==SQLITE_OK
);
5201 if( !pagerUseWal(pPager
) && pPager
->eState
==PAGER_OPEN
){
5202 int bHotJournal
= 1; /* True if there exists a hot journal-file */
5205 assert( pPager
->tempFile
==0 || pPager
->eLock
==EXCLUSIVE_LOCK
);
5207 rc
= pager_wait_on_lock(pPager
, SHARED_LOCK
);
5208 if( rc
!=SQLITE_OK
){
5209 assert( pPager
->eLock
==NO_LOCK
|| pPager
->eLock
==UNKNOWN_LOCK
);
5213 /* If a journal file exists, and there is no RESERVED lock on the
5214 ** database file, then it either needs to be played back or deleted.
5216 if( pPager
->eLock
<=SHARED_LOCK
){
5217 rc
= hasHotJournal(pPager
, &bHotJournal
);
5219 if( rc
!=SQLITE_OK
){
5223 if( pPager
->readOnly
){
5224 rc
= SQLITE_READONLY_ROLLBACK
;
5228 /* Get an EXCLUSIVE lock on the database file. At this point it is
5229 ** important that a RESERVED lock is not obtained on the way to the
5230 ** EXCLUSIVE lock. If it were, another process might open the
5231 ** database file, detect the RESERVED lock, and conclude that the
5232 ** database is safe to read while this process is still rolling the
5233 ** hot-journal back.
5235 ** Because the intermediate RESERVED lock is not requested, any
5236 ** other process attempting to access the database file will get to
5237 ** this point in the code and fail to obtain its own EXCLUSIVE lock
5238 ** on the database file.
5240 ** Unless the pager is in locking_mode=exclusive mode, the lock is
5241 ** downgraded to SHARED_LOCK before this function returns.
5243 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
5244 if( rc
!=SQLITE_OK
){
5248 /* If it is not already open and the file exists on disk, open the
5249 ** journal for read/write access. Write access is required because
5250 ** in exclusive-access mode the file descriptor will be kept open
5251 ** and possibly used for a transaction later on. Also, write-access
5252 ** is usually required to finalize the journal in journal_mode=persist
5253 ** mode (and also for journal_mode=truncate on some systems).
5255 ** If the journal does not exist, it usually means that some
5256 ** other connection managed to get in and roll it back before
5257 ** this connection obtained the exclusive lock above. Or, it
5258 ** may mean that the pager was in the error-state when this
5259 ** function was called and the journal file does not exist.
5261 if( !isOpen(pPager
->jfd
) && pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
5262 sqlite3_vfs
* const pVfs
= pPager
->pVfs
;
5263 int bExists
; /* True if journal file exists */
5264 rc
= sqlite3OsAccess(
5265 pVfs
, pPager
->zJournal
, SQLITE_ACCESS_EXISTS
, &bExists
);
5266 if( rc
==SQLITE_OK
&& bExists
){
5268 int f
= SQLITE_OPEN_READWRITE
|SQLITE_OPEN_MAIN_JOURNAL
;
5269 assert( !pPager
->tempFile
);
5270 rc
= sqlite3OsOpen(pVfs
, pPager
->zJournal
, pPager
->jfd
, f
, &fout
);
5271 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->jfd
) );
5272 if( rc
==SQLITE_OK
&& fout
&SQLITE_OPEN_READONLY
){
5273 rc
= SQLITE_CANTOPEN_BKPT
;
5274 sqlite3OsClose(pPager
->jfd
);
5279 /* Playback and delete the journal. Drop the database write
5280 ** lock and reacquire the read lock. Purge the cache before
5281 ** playing back the hot-journal so that we don't end up with
5282 ** an inconsistent cache. Sync the hot journal before playing
5283 ** it back since the process that crashed and left the hot journal
5284 ** probably did not sync it and we are required to always sync
5285 ** the journal before playing it back.
5287 if( isOpen(pPager
->jfd
) ){
5288 assert( rc
==SQLITE_OK
);
5289 rc
= pagerSyncHotJournal(pPager
);
5290 if( rc
==SQLITE_OK
){
5291 rc
= pager_playback(pPager
, !pPager
->tempFile
);
5292 pPager
->eState
= PAGER_OPEN
;
5294 }else if( !pPager
->exclusiveMode
){
5295 pagerUnlockDb(pPager
, SHARED_LOCK
);
5298 if( rc
!=SQLITE_OK
){
5299 /* This branch is taken if an error occurs while trying to open
5300 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
5301 ** pager_unlock() routine will be called before returning to unlock
5302 ** the file. If the unlock attempt fails, then Pager.eLock must be
5303 ** set to UNKNOWN_LOCK (see the comment above the #define for
5304 ** UNKNOWN_LOCK above for an explanation).
5306 ** In order to get pager_unlock() to do this, set Pager.eState to
5307 ** PAGER_ERROR now. This is not actually counted as a transition
5308 ** to ERROR state in the state diagram at the top of this file,
5309 ** since we know that the same call to pager_unlock() will very
5310 ** shortly transition the pager object to the OPEN state. Calling
5311 ** assert_pager_state() would fail now, as it should not be possible
5312 ** to be in ERROR state when there are zero outstanding page
5315 pager_error(pPager
, rc
);
5319 assert( pPager
->eState
==PAGER_OPEN
);
5320 assert( (pPager
->eLock
==SHARED_LOCK
)
5321 || (pPager
->exclusiveMode
&& pPager
->eLock
>SHARED_LOCK
)
5325 if( !pPager
->tempFile
&& pPager
->hasHeldSharedLock
){
5326 /* The shared-lock has just been acquired then check to
5327 ** see if the database has been modified. If the database has changed,
5328 ** flush the cache. The hasHeldSharedLock flag prevents this from
5329 ** occurring on the very first access to a file, in order to save a
5330 ** single unnecessary sqlite3OsRead() call at the start-up.
5332 ** Database changes are detected by looking at 15 bytes beginning
5333 ** at offset 24 into the file. The first 4 of these 16 bytes are
5334 ** a 32-bit counter that is incremented with each change. The
5335 ** other bytes change randomly with each file change when
5336 ** a codec is in use.
5338 ** There is a vanishingly small chance that a change will not be
5339 ** detected. The chance of an undetected change is so small that
5340 ** it can be neglected.
5342 char dbFileVers
[sizeof(pPager
->dbFileVers
)];
5344 IOTRACE(("CKVERS %p %d\n", pPager
, sizeof(dbFileVers
)));
5345 rc
= sqlite3OsRead(pPager
->fd
, &dbFileVers
, sizeof(dbFileVers
), 24);
5346 if( rc
!=SQLITE_OK
){
5347 if( rc
!=SQLITE_IOERR_SHORT_READ
){
5350 memset(dbFileVers
, 0, sizeof(dbFileVers
));
5353 if( memcmp(pPager
->dbFileVers
, dbFileVers
, sizeof(dbFileVers
))!=0 ){
5354 pager_reset(pPager
);
5356 /* Unmap the database file. It is possible that external processes
5357 ** may have truncated the database file and then extended it back
5358 ** to its original size while this process was not holding a lock.
5359 ** In this case there may exist a Pager.pMap mapping that appears
5360 ** to be the right size but is not actually valid. Avoid this
5361 ** possibility by unmapping the db here. */
5362 if( USEFETCH(pPager
) ){
5363 sqlite3OsUnfetch(pPager
->fd
, 0, 0);
5368 /* If there is a WAL file in the file-system, open this database in WAL
5369 ** mode. Otherwise, the following function call is a no-op.
5371 rc
= pagerOpenWalIfPresent(pPager
);
5372 #ifndef SQLITE_OMIT_WAL
5373 assert( pPager
->pWal
==0 || rc
==SQLITE_OK
);
5377 if( pagerUseWal(pPager
) ){
5378 assert( rc
==SQLITE_OK
);
5379 rc
= pagerBeginReadTransaction(pPager
);
5382 if( pPager
->tempFile
==0 && pPager
->eState
==PAGER_OPEN
&& rc
==SQLITE_OK
){
5383 rc
= pagerPagecount(pPager
, &pPager
->dbSize
);
5387 if( rc
!=SQLITE_OK
){
5389 pager_unlock(pPager
);
5390 assert( pPager
->eState
==PAGER_OPEN
);
5392 pPager
->eState
= PAGER_READER
;
5393 pPager
->hasHeldSharedLock
= 1;
5399 ** If the reference count has reached zero, rollback any active
5400 ** transaction and unlock the pager.
5402 ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
5403 ** the rollback journal, the unlock is not performed and there is
5404 ** nothing to rollback, so this routine is a no-op.
5406 static void pagerUnlockIfUnused(Pager
*pPager
){
5407 if( sqlite3PcacheRefCount(pPager
->pPCache
)==0 ){
5408 assert( pPager
->nMmapOut
==0 ); /* because page1 is never memory mapped */
5409 pagerUnlockAndRollback(pPager
);
5414 ** The page getter methods each try to acquire a reference to a
5415 ** page with page number pgno. If the requested reference is
5416 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
5418 ** There are different implementations of the getter method depending
5419 ** on the current state of the pager.
5421 ** getPageNormal() -- The normal getter
5422 ** getPageError() -- Used if the pager is in an error state
5423 ** getPageMmap() -- Used if memory-mapped I/O is enabled
5425 ** If the requested page is already in the cache, it is returned.
5426 ** Otherwise, a new page object is allocated and populated with data
5427 ** read from the database file. In some cases, the pcache module may
5428 ** choose not to allocate a new page object and may reuse an existing
5429 ** object with no outstanding references.
5431 ** The extra data appended to a page is always initialized to zeros the
5432 ** first time a page is loaded into memory. If the page requested is
5433 ** already in the cache when this function is called, then the extra
5434 ** data is left as it was when the page object was last used.
5436 ** If the database image is smaller than the requested page or if
5437 ** the flags parameter contains the PAGER_GET_NOCONTENT bit and the
5438 ** requested page is not already stored in the cache, then no
5439 ** actual disk read occurs. In this case the memory image of the
5440 ** page is initialized to all zeros.
5442 ** If PAGER_GET_NOCONTENT is true, it means that we do not care about
5443 ** the contents of the page. This occurs in two scenarios:
5445 ** a) When reading a free-list leaf page from the database, and
5447 ** b) When a savepoint is being rolled back and we need to load
5448 ** a new page into the cache to be filled with the data read
5449 ** from the savepoint journal.
5451 ** If PAGER_GET_NOCONTENT is true, then the data returned is zeroed instead
5452 ** of being read from the database. Additionally, the bits corresponding
5453 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
5454 ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
5455 ** savepoints are set. This means if the page is made writable at any
5456 ** point in the future, using a call to sqlite3PagerWrite(), its contents
5457 ** will not be journaled. This saves IO.
5459 ** The acquisition might fail for several reasons. In all cases,
5460 ** an appropriate error code is returned and *ppPage is set to NULL.
5462 ** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
5463 ** to find a page in the in-memory cache first. If the page is not already
5464 ** in memory, this routine goes to disk to read it in whereas Lookup()
5465 ** just returns 0. This routine acquires a read-lock the first time it
5466 ** has to go to disk, and could also playback an old journal if necessary.
5467 ** Since Lookup() never goes to disk, it never has to deal with locks
5468 ** or journal files.
5470 static int getPageNormal(
5471 Pager
*pPager
, /* The pager open on the database file */
5472 Pgno pgno
, /* Page number to fetch */
5473 DbPage
**ppPage
, /* Write a pointer to the page here */
5474 int flags
/* PAGER_GET_XXX flags */
5478 u8 noContent
; /* True if PAGER_GET_NOCONTENT is set */
5479 sqlite3_pcache_page
*pBase
;
5481 assert( pPager
->errCode
==SQLITE_OK
);
5482 assert( pPager
->eState
>=PAGER_READER
);
5483 assert( assert_pager_state(pPager
) );
5484 assert( pPager
->hasHeldSharedLock
==1 );
5486 if( pgno
==0 ) return SQLITE_CORRUPT_BKPT
;
5487 pBase
= sqlite3PcacheFetch(pPager
->pPCache
, pgno
, 3);
5490 rc
= sqlite3PcacheFetchStress(pPager
->pPCache
, pgno
, &pBase
);
5491 if( rc
!=SQLITE_OK
) goto pager_acquire_err
;
5493 rc
= SQLITE_NOMEM_BKPT
;
5494 goto pager_acquire_err
;
5497 pPg
= *ppPage
= sqlite3PcacheFetchFinish(pPager
->pPCache
, pgno
, pBase
);
5498 assert( pPg
==(*ppPage
) );
5499 assert( pPg
->pgno
==pgno
);
5500 assert( pPg
->pPager
==pPager
|| pPg
->pPager
==0 );
5502 noContent
= (flags
& PAGER_GET_NOCONTENT
)!=0;
5503 if( pPg
->pPager
&& !noContent
){
5504 /* In this case the pcache already contains an initialized copy of
5505 ** the page. Return without further ado. */
5506 assert( pgno
!=PAGER_MJ_PGNO(pPager
) );
5507 pPager
->aStat
[PAGER_STAT_HIT
]++;
5511 /* The pager cache has created a new page. Its content needs to
5512 ** be initialized. But first some error checks:
5514 ** (*) obsolete. Was: maximum page number is 2^31
5515 ** (2) Never try to fetch the locking page
5517 if( pgno
==PAGER_MJ_PGNO(pPager
) ){
5518 rc
= SQLITE_CORRUPT_BKPT
;
5519 goto pager_acquire_err
;
5522 pPg
->pPager
= pPager
;
5524 assert( !isOpen(pPager
->fd
) || !MEMDB
);
5525 if( !isOpen(pPager
->fd
) || pPager
->dbSize
<pgno
|| noContent
){
5526 if( pgno
>pPager
->mxPgno
){
5528 goto pager_acquire_err
;
5531 /* Failure to set the bits in the InJournal bit-vectors is benign.
5532 ** It merely means that we might do some extra work to journal a
5533 ** page that does not need to be journaled. Nevertheless, be sure
5534 ** to test the case where a malloc error occurs while trying to set
5535 ** a bit in a bit vector.
5537 sqlite3BeginBenignMalloc();
5538 if( pgno
<=pPager
->dbOrigSize
){
5539 TESTONLY( rc
= ) sqlite3BitvecSet(pPager
->pInJournal
, pgno
);
5540 testcase( rc
==SQLITE_NOMEM
);
5542 TESTONLY( rc
= ) addToSavepointBitvecs(pPager
, pgno
);
5543 testcase( rc
==SQLITE_NOMEM
);
5544 sqlite3EndBenignMalloc();
5546 memset(pPg
->pData
, 0, pPager
->pageSize
);
5547 IOTRACE(("ZERO %p %d\n", pPager
, pgno
));
5549 assert( pPg
->pPager
==pPager
);
5550 pPager
->aStat
[PAGER_STAT_MISS
]++;
5551 rc
= readDbPage(pPg
);
5552 if( rc
!=SQLITE_OK
){
5553 goto pager_acquire_err
;
5556 pager_set_pagehash(pPg
);
5561 assert( rc
!=SQLITE_OK
);
5563 sqlite3PcacheDrop(pPg
);
5565 pagerUnlockIfUnused(pPager
);
5570 #if SQLITE_MAX_MMAP_SIZE>0
5571 /* The page getter for when memory-mapped I/O is enabled */
5572 static int getPageMMap(
5573 Pager
*pPager
, /* The pager open on the database file */
5574 Pgno pgno
, /* Page number to fetch */
5575 DbPage
**ppPage
, /* Write a pointer to the page here */
5576 int flags
/* PAGER_GET_XXX flags */
5580 u32 iFrame
= 0; /* Frame to read from WAL file */
5582 /* It is acceptable to use a read-only (mmap) page for any page except
5583 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
5584 ** flag was specified by the caller. And so long as the db is not a
5585 ** temporary or in-memory database. */
5586 const int bMmapOk
= (pgno
>1
5587 && (pPager
->eState
==PAGER_READER
|| (flags
& PAGER_GET_READONLY
))
5590 assert( USEFETCH(pPager
) );
5592 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
5593 ** allows the compiler optimizer to reuse the results of the "pgno>1"
5594 ** test in the previous statement, and avoid testing pgno==0 in the
5595 ** common case where pgno is large. */
5596 if( pgno
<=1 && pgno
==0 ){
5597 return SQLITE_CORRUPT_BKPT
;
5599 assert( pPager
->eState
>=PAGER_READER
);
5600 assert( assert_pager_state(pPager
) );
5601 assert( pPager
->hasHeldSharedLock
==1 );
5602 assert( pPager
->errCode
==SQLITE_OK
);
5604 if( bMmapOk
&& pagerUseWal(pPager
) ){
5605 rc
= sqlite3WalFindFrame(pPager
->pWal
, pgno
, &iFrame
);
5606 if( rc
!=SQLITE_OK
){
5611 if( bMmapOk
&& iFrame
==0 ){
5613 rc
= sqlite3OsFetch(pPager
->fd
,
5614 (i64
)(pgno
-1) * pPager
->pageSize
, pPager
->pageSize
, &pData
5616 if( rc
==SQLITE_OK
&& pData
){
5617 if( pPager
->eState
>PAGER_READER
|| pPager
->tempFile
){
5618 pPg
= sqlite3PagerLookup(pPager
, pgno
);
5621 rc
= pagerAcquireMapPage(pPager
, pgno
, pData
, &pPg
);
5623 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pgno
-1)*pPager
->pageSize
, pData
);
5626 assert( rc
==SQLITE_OK
);
5631 if( rc
!=SQLITE_OK
){
5636 return getPageNormal(pPager
, pgno
, ppPage
, flags
);
5638 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
5640 /* The page getter method for when the pager is an error state */
5641 static int getPageError(
5642 Pager
*pPager
, /* The pager open on the database file */
5643 Pgno pgno
, /* Page number to fetch */
5644 DbPage
**ppPage
, /* Write a pointer to the page here */
5645 int flags
/* PAGER_GET_XXX flags */
5647 UNUSED_PARAMETER(pgno
);
5648 UNUSED_PARAMETER(flags
);
5649 assert( pPager
->errCode
!=SQLITE_OK
);
5651 return pPager
->errCode
;
5655 /* Dispatch all page fetch requests to the appropriate getter method.
5657 int sqlite3PagerGet(
5658 Pager
*pPager
, /* The pager open on the database file */
5659 Pgno pgno
, /* Page number to fetch */
5660 DbPage
**ppPage
, /* Write a pointer to the page here */
5661 int flags
/* PAGER_GET_XXX flags */
5663 return pPager
->xGet(pPager
, pgno
, ppPage
, flags
);
5667 ** Acquire a page if it is already in the in-memory cache. Do
5668 ** not read the page from disk. Return a pointer to the page,
5669 ** or 0 if the page is not in cache.
5671 ** See also sqlite3PagerGet(). The difference between this routine
5672 ** and sqlite3PagerGet() is that _get() will go to the disk and read
5673 ** in the page if the page is not already in cache. This routine
5674 ** returns NULL if the page is not in cache or if a disk I/O error
5675 ** has ever happened.
5677 DbPage
*sqlite3PagerLookup(Pager
*pPager
, Pgno pgno
){
5678 sqlite3_pcache_page
*pPage
;
5679 assert( pPager
!=0 );
5681 assert( pPager
->pPCache
!=0 );
5682 pPage
= sqlite3PcacheFetch(pPager
->pPCache
, pgno
, 0);
5683 assert( pPage
==0 || pPager
->hasHeldSharedLock
);
5684 if( pPage
==0 ) return 0;
5685 return sqlite3PcacheFetchFinish(pPager
->pPCache
, pgno
, pPage
);
5689 ** Release a page reference.
5691 ** The sqlite3PagerUnref() and sqlite3PagerUnrefNotNull() may only be
5692 ** used if we know that the page being released is not the last page.
5693 ** The btree layer always holds page1 open until the end, so these first
5694 ** to routines can be used to release any page other than BtShared.pPage1.
5696 ** Use sqlite3PagerUnrefPageOne() to release page1. This latter routine
5697 ** checks the total number of outstanding pages and if the number of
5698 ** pages reaches zero it drops the database lock.
5700 void sqlite3PagerUnrefNotNull(DbPage
*pPg
){
5701 TESTONLY( Pager
*pPager
= pPg
->pPager
; )
5703 if( pPg
->flags
& PGHDR_MMAP
){
5704 assert( pPg
->pgno
!=1 ); /* Page1 is never memory mapped */
5705 pagerReleaseMapPage(pPg
);
5707 sqlite3PcacheRelease(pPg
);
5709 /* Do not use this routine to release the last reference to page1 */
5710 assert( sqlite3PcacheRefCount(pPager
->pPCache
)>0 );
5712 void sqlite3PagerUnref(DbPage
*pPg
){
5713 if( pPg
) sqlite3PagerUnrefNotNull(pPg
);
5715 void sqlite3PagerUnrefPageOne(DbPage
*pPg
){
5718 assert( pPg
->pgno
==1 );
5719 assert( (pPg
->flags
& PGHDR_MMAP
)==0 ); /* Page1 is never memory mapped */
5720 pPager
= pPg
->pPager
;
5721 sqlite3PcacheRelease(pPg
);
5722 pagerUnlockIfUnused(pPager
);
5726 ** This function is called at the start of every write transaction.
5727 ** There must already be a RESERVED or EXCLUSIVE lock on the database
5728 ** file when this routine is called.
5730 ** Open the journal file for pager pPager and write a journal header
5731 ** to the start of it. If there are active savepoints, open the sub-journal
5732 ** as well. This function is only used when the journal file is being
5733 ** opened to write a rollback log for a transaction. It is not used
5734 ** when opening a hot journal file to roll it back.
5736 ** If the journal file is already open (as it may be in exclusive mode),
5737 ** then this function just writes a journal header to the start of the
5738 ** already open file.
5740 ** Whether or not the journal file is opened by this function, the
5741 ** Pager.pInJournal bitvec structure is allocated.
5743 ** Return SQLITE_OK if everything is successful. Otherwise, return
5744 ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
5745 ** an IO error code if opening or writing the journal file fails.
5747 static int pager_open_journal(Pager
*pPager
){
5748 int rc
= SQLITE_OK
; /* Return code */
5749 sqlite3_vfs
* const pVfs
= pPager
->pVfs
; /* Local cache of vfs pointer */
5751 assert( pPager
->eState
==PAGER_WRITER_LOCKED
);
5752 assert( assert_pager_state(pPager
) );
5753 assert( pPager
->pInJournal
==0 );
5755 /* If already in the error state, this function is a no-op. But on
5756 ** the other hand, this routine is never called if we are already in
5757 ** an error state. */
5758 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
5760 if( !pagerUseWal(pPager
) && pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
5761 pPager
->pInJournal
= sqlite3BitvecCreate(pPager
->dbSize
);
5762 if( pPager
->pInJournal
==0 ){
5763 return SQLITE_NOMEM_BKPT
;
5766 /* Open the journal file if it is not already open. */
5767 if( !isOpen(pPager
->jfd
) ){
5768 if( pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
){
5769 sqlite3MemJournalOpen(pPager
->jfd
);
5771 int flags
= SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
;
5774 if( pPager
->tempFile
){
5775 flags
|= (SQLITE_OPEN_DELETEONCLOSE
|SQLITE_OPEN_TEMP_JOURNAL
);
5776 nSpill
= sqlite3Config
.nStmtSpill
;
5778 flags
|= SQLITE_OPEN_MAIN_JOURNAL
;
5779 nSpill
= jrnlBufferSize(pPager
);
5782 /* Verify that the database still has the same name as it did when
5783 ** it was originally opened. */
5784 rc
= databaseIsUnmoved(pPager
);
5785 if( rc
==SQLITE_OK
){
5786 rc
= sqlite3JournalOpen (
5787 pVfs
, pPager
->zJournal
, pPager
->jfd
, flags
, nSpill
5791 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->jfd
) );
5795 /* Write the first journal header to the journal file and open
5796 ** the sub-journal if necessary.
5798 if( rc
==SQLITE_OK
){
5799 /* TODO: Check if all of these are really required. */
5801 pPager
->journalOff
= 0;
5802 pPager
->setSuper
= 0;
5803 pPager
->journalHdr
= 0;
5804 rc
= writeJournalHdr(pPager
);
5808 if( rc
!=SQLITE_OK
){
5809 sqlite3BitvecDestroy(pPager
->pInJournal
);
5810 pPager
->pInJournal
= 0;
5812 assert( pPager
->eState
==PAGER_WRITER_LOCKED
);
5813 pPager
->eState
= PAGER_WRITER_CACHEMOD
;
5820 ** Begin a write-transaction on the specified pager object. If a
5821 ** write-transaction has already been opened, this function is a no-op.
5823 ** If the exFlag argument is false, then acquire at least a RESERVED
5824 ** lock on the database file. If exFlag is true, then acquire at least
5825 ** an EXCLUSIVE lock. If such a lock is already held, no locking
5826 ** functions need be called.
5828 ** If the subjInMemory argument is non-zero, then any sub-journal opened
5829 ** within this transaction will be opened as an in-memory file. This
5830 ** has no effect if the sub-journal is already opened (as it may be when
5831 ** running in exclusive mode) or if the transaction does not require a
5832 ** sub-journal. If the subjInMemory argument is zero, then any required
5833 ** sub-journal is implemented in-memory if pPager is an in-memory database,
5834 ** or using a temporary file otherwise.
5836 int sqlite3PagerBegin(Pager
*pPager
, int exFlag
, int subjInMemory
){
5839 if( pPager
->errCode
) return pPager
->errCode
;
5840 assert( pPager
->eState
>=PAGER_READER
&& pPager
->eState
<PAGER_ERROR
);
5841 pPager
->subjInMemory
= (u8
)subjInMemory
;
5843 if( pPager
->eState
==PAGER_READER
){
5844 assert( pPager
->pInJournal
==0 );
5846 if( pagerUseWal(pPager
) ){
5847 /* If the pager is configured to use locking_mode=exclusive, and an
5848 ** exclusive lock on the database is not already held, obtain it now.
5850 if( pPager
->exclusiveMode
&& sqlite3WalExclusiveMode(pPager
->pWal
, -1) ){
5851 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
5852 if( rc
!=SQLITE_OK
){
5855 (void)sqlite3WalExclusiveMode(pPager
->pWal
, 1);
5858 /* Grab the write lock on the log file. If successful, upgrade to
5859 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
5860 ** The busy-handler is not invoked if another connection already
5861 ** holds the write-lock. If possible, the upper layer will call it.
5863 rc
= sqlite3WalBeginWriteTransaction(pPager
->pWal
);
5865 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
5866 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
5867 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
5868 ** lock, but not when obtaining the RESERVED lock.
5870 rc
= pagerLockDb(pPager
, RESERVED_LOCK
);
5871 if( rc
==SQLITE_OK
&& exFlag
){
5872 rc
= pager_wait_on_lock(pPager
, EXCLUSIVE_LOCK
);
5876 if( rc
==SQLITE_OK
){
5877 /* Change to WRITER_LOCKED state.
5879 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
5880 ** when it has an open transaction, but never to DBMOD or FINISHED.
5881 ** This is because in those states the code to roll back savepoint
5882 ** transactions may copy data from the sub-journal into the database
5883 ** file as well as into the page cache. Which would be incorrect in
5886 pPager
->eState
= PAGER_WRITER_LOCKED
;
5887 pPager
->dbHintSize
= pPager
->dbSize
;
5888 pPager
->dbFileSize
= pPager
->dbSize
;
5889 pPager
->dbOrigSize
= pPager
->dbSize
;
5890 pPager
->journalOff
= 0;
5893 assert( rc
==SQLITE_OK
|| pPager
->eState
==PAGER_READER
);
5894 assert( rc
!=SQLITE_OK
|| pPager
->eState
==PAGER_WRITER_LOCKED
);
5895 assert( assert_pager_state(pPager
) );
5898 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager
)));
5903 ** Write page pPg onto the end of the rollback journal.
5905 static SQLITE_NOINLINE
int pagerAddPageToRollbackJournal(PgHdr
*pPg
){
5906 Pager
*pPager
= pPg
->pPager
;
5910 i64 iOff
= pPager
->journalOff
;
5912 /* We should never write to the journal file the page that
5913 ** contains the database locks. The following assert verifies
5914 ** that we do not. */
5915 assert( pPg
->pgno
!=PAGER_MJ_PGNO(pPager
) );
5917 assert( pPager
->journalHdr
<=pPager
->journalOff
);
5918 pData2
= pPg
->pData
;
5919 cksum
= pager_cksum(pPager
, (u8
*)pData2
);
5921 /* Even if an IO or diskfull error occurs while journalling the
5922 ** page in the block above, set the need-sync flag for the page.
5923 ** Otherwise, when the transaction is rolled back, the logic in
5924 ** playback_one_page() will think that the page needs to be restored
5925 ** in the database file. And if an IO error occurs while doing so,
5926 ** then corruption may follow.
5928 pPg
->flags
|= PGHDR_NEED_SYNC
;
5930 rc
= write32bits(pPager
->jfd
, iOff
, pPg
->pgno
);
5931 if( rc
!=SQLITE_OK
) return rc
;
5932 rc
= sqlite3OsWrite(pPager
->jfd
, pData2
, pPager
->pageSize
, iOff
+4);
5933 if( rc
!=SQLITE_OK
) return rc
;
5934 rc
= write32bits(pPager
->jfd
, iOff
+pPager
->pageSize
+4, cksum
);
5935 if( rc
!=SQLITE_OK
) return rc
;
5937 IOTRACE(("JOUT %p %d %lld %d\n", pPager
, pPg
->pgno
,
5938 pPager
->journalOff
, pPager
->pageSize
));
5939 PAGER_INCR(sqlite3_pager_writej_count
);
5940 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
5941 PAGERID(pPager
), pPg
->pgno
,
5942 ((pPg
->flags
&PGHDR_NEED_SYNC
)?1:0), pager_pagehash(pPg
)));
5944 pPager
->journalOff
+= 8 + pPager
->pageSize
;
5946 assert( pPager
->pInJournal
!=0 );
5947 rc
= sqlite3BitvecSet(pPager
->pInJournal
, pPg
->pgno
);
5948 testcase( rc
==SQLITE_NOMEM
);
5949 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
5950 rc
|= addToSavepointBitvecs(pPager
, pPg
->pgno
);
5951 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
5956 ** Mark a single data page as writeable. The page is written into the
5957 ** main journal or sub-journal as required. If the page is written into
5958 ** one of the journals, the corresponding bit is set in the
5959 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
5960 ** of any open savepoints as appropriate.
5962 static int pager_write(PgHdr
*pPg
){
5963 Pager
*pPager
= pPg
->pPager
;
5966 /* This routine is not called unless a write-transaction has already
5967 ** been started. The journal file may or may not be open at this point.
5968 ** It is never called in the ERROR state.
5970 assert( pPager
->eState
==PAGER_WRITER_LOCKED
5971 || pPager
->eState
==PAGER_WRITER_CACHEMOD
5972 || pPager
->eState
==PAGER_WRITER_DBMOD
5974 assert( assert_pager_state(pPager
) );
5975 assert( pPager
->errCode
==0 );
5976 assert( pPager
->readOnly
==0 );
5979 /* The journal file needs to be opened. Higher level routines have already
5980 ** obtained the necessary locks to begin the write-transaction, but the
5981 ** rollback journal might not yet be open. Open it now if this is the case.
5983 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
5984 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
5985 ** an error might occur and the pager would end up in WRITER_LOCKED state
5986 ** with pages marked as dirty in the cache.
5988 if( pPager
->eState
==PAGER_WRITER_LOCKED
){
5989 rc
= pager_open_journal(pPager
);
5990 if( rc
!=SQLITE_OK
) return rc
;
5992 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
);
5993 assert( assert_pager_state(pPager
) );
5995 /* Mark the page that is about to be modified as dirty. */
5996 sqlite3PcacheMakeDirty(pPg
);
5998 /* If a rollback journal is in use, them make sure the page that is about
5999 ** to change is in the rollback journal, or if the page is a new page off
6000 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
6002 assert( (pPager
->pInJournal
!=0) == isOpen(pPager
->jfd
) );
6003 if( pPager
->pInJournal
!=0
6004 && sqlite3BitvecTestNotNull(pPager
->pInJournal
, pPg
->pgno
)==0
6006 assert( pagerUseWal(pPager
)==0 );
6007 if( pPg
->pgno
<=pPager
->dbOrigSize
){
6008 rc
= pagerAddPageToRollbackJournal(pPg
);
6009 if( rc
!=SQLITE_OK
){
6013 if( pPager
->eState
!=PAGER_WRITER_DBMOD
){
6014 pPg
->flags
|= PGHDR_NEED_SYNC
;
6016 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
6017 PAGERID(pPager
), pPg
->pgno
,
6018 ((pPg
->flags
&PGHDR_NEED_SYNC
)?1:0)));
6022 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
6023 ** and before writing the page into the rollback journal. Wait until now,
6024 ** after the page has been successfully journalled, before setting the
6025 ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
6027 pPg
->flags
|= PGHDR_WRITEABLE
;
6029 /* If the statement journal is open and the page is not in it,
6030 ** then write the page into the statement journal.
6032 if( pPager
->nSavepoint
>0 ){
6033 rc
= subjournalPageIfRequired(pPg
);
6036 /* Update the database size and return. */
6037 if( pPager
->dbSize
<pPg
->pgno
){
6038 pPager
->dbSize
= pPg
->pgno
;
6044 ** This is a variant of sqlite3PagerWrite() that runs when the sector size
6045 ** is larger than the page size. SQLite makes the (reasonable) assumption that
6046 ** all bytes of a sector are written together by hardware. Hence, all bytes of
6047 ** a sector need to be journalled in case of a power loss in the middle of
6050 ** Usually, the sector size is less than or equal to the page size, in which
6051 ** case pages can be individually written. This routine only runs in the
6052 ** exceptional case where the page size is smaller than the sector size.
6054 static SQLITE_NOINLINE
int pagerWriteLargeSector(PgHdr
*pPg
){
6055 int rc
= SQLITE_OK
; /* Return code */
6056 Pgno nPageCount
; /* Total number of pages in database file */
6057 Pgno pg1
; /* First page of the sector pPg is located on. */
6058 int nPage
= 0; /* Number of pages starting at pg1 to journal */
6059 int ii
; /* Loop counter */
6060 int needSync
= 0; /* True if any page has PGHDR_NEED_SYNC */
6061 Pager
*pPager
= pPg
->pPager
; /* The pager that owns pPg */
6062 Pgno nPagePerSector
= (pPager
->sectorSize
/pPager
->pageSize
);
6064 /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
6065 ** a journal header to be written between the pages journaled by
6069 assert( (pPager
->doNotSpill
& SPILLFLAG_NOSYNC
)==0 );
6070 pPager
->doNotSpill
|= SPILLFLAG_NOSYNC
;
6072 /* This trick assumes that both the page-size and sector-size are
6073 ** an integer power of 2. It sets variable pg1 to the identifier
6074 ** of the first page of the sector pPg is located on.
6076 pg1
= ((pPg
->pgno
-1) & ~(nPagePerSector
-1)) + 1;
6078 nPageCount
= pPager
->dbSize
;
6079 if( pPg
->pgno
>nPageCount
){
6080 nPage
= (pPg
->pgno
- pg1
)+1;
6081 }else if( (pg1
+nPagePerSector
-1)>nPageCount
){
6082 nPage
= nPageCount
+1-pg1
;
6084 nPage
= nPagePerSector
;
6087 assert(pg1
<=pPg
->pgno
);
6088 assert((pg1
+nPage
)>pPg
->pgno
);
6090 for(ii
=0; ii
<nPage
&& rc
==SQLITE_OK
; ii
++){
6093 if( pg
==pPg
->pgno
|| !sqlite3BitvecTest(pPager
->pInJournal
, pg
) ){
6094 if( pg
!=PAGER_MJ_PGNO(pPager
) ){
6095 rc
= sqlite3PagerGet(pPager
, pg
, &pPage
, 0);
6096 if( rc
==SQLITE_OK
){
6097 rc
= pager_write(pPage
);
6098 if( pPage
->flags
&PGHDR_NEED_SYNC
){
6101 sqlite3PagerUnrefNotNull(pPage
);
6104 }else if( (pPage
= sqlite3PagerLookup(pPager
, pg
))!=0 ){
6105 if( pPage
->flags
&PGHDR_NEED_SYNC
){
6108 sqlite3PagerUnrefNotNull(pPage
);
6112 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
6113 ** starting at pg1, then it needs to be set for all of them. Because
6114 ** writing to any of these nPage pages may damage the others, the
6115 ** journal file must contain sync()ed copies of all of them
6116 ** before any of them can be written out to the database file.
6118 if( rc
==SQLITE_OK
&& needSync
){
6120 for(ii
=0; ii
<nPage
; ii
++){
6121 PgHdr
*pPage
= sqlite3PagerLookup(pPager
, pg1
+ii
);
6123 pPage
->flags
|= PGHDR_NEED_SYNC
;
6124 sqlite3PagerUnrefNotNull(pPage
);
6129 assert( (pPager
->doNotSpill
& SPILLFLAG_NOSYNC
)!=0 );
6130 pPager
->doNotSpill
&= ~SPILLFLAG_NOSYNC
;
6135 ** Mark a data page as writeable. This routine must be called before
6136 ** making changes to a page. The caller must check the return value
6137 ** of this function and be careful not to change any page data unless
6138 ** this routine returns SQLITE_OK.
6140 ** The difference between this function and pager_write() is that this
6141 ** function also deals with the special case where 2 or more pages
6142 ** fit on a single disk sector. In this case all co-resident pages
6143 ** must have been written to the journal file before returning.
6145 ** If an error occurs, SQLITE_NOMEM or an IO error code is returned
6146 ** as appropriate. Otherwise, SQLITE_OK.
6148 int sqlite3PagerWrite(PgHdr
*pPg
){
6149 Pager
*pPager
= pPg
->pPager
;
6150 assert( (pPg
->flags
& PGHDR_MMAP
)==0 );
6151 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6152 assert( assert_pager_state(pPager
) );
6153 if( (pPg
->flags
& PGHDR_WRITEABLE
)!=0 && pPager
->dbSize
>=pPg
->pgno
){
6154 if( pPager
->nSavepoint
) return subjournalPageIfRequired(pPg
);
6156 }else if( pPager
->errCode
){
6157 return pPager
->errCode
;
6158 }else if( pPager
->sectorSize
> (u32
)pPager
->pageSize
){
6159 assert( pPager
->tempFile
==0 );
6160 return pagerWriteLargeSector(pPg
);
6162 return pager_write(pPg
);
6167 ** Return TRUE if the page given in the argument was previously passed
6168 ** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
6169 ** to change the content of the page.
6172 int sqlite3PagerIswriteable(DbPage
*pPg
){
6173 return pPg
->flags
& PGHDR_WRITEABLE
;
6178 ** A call to this routine tells the pager that it is not necessary to
6179 ** write the information on page pPg back to the disk, even though
6180 ** that page might be marked as dirty. This happens, for example, when
6181 ** the page has been added as a leaf of the freelist and so its
6182 ** content no longer matters.
6184 ** The overlying software layer calls this routine when all of the data
6185 ** on the given page is unused. The pager marks the page as clean so
6186 ** that it does not get written to disk.
6188 ** Tests show that this optimization can quadruple the speed of large
6189 ** DELETE operations.
6191 ** This optimization cannot be used with a temp-file, as the page may
6192 ** have been dirty at the start of the transaction. In that case, if
6193 ** memory pressure forces page pPg out of the cache, the data does need
6194 ** to be written out to disk so that it may be read back in if the
6195 ** current transaction is rolled back.
6197 void sqlite3PagerDontWrite(PgHdr
*pPg
){
6198 Pager
*pPager
= pPg
->pPager
;
6199 if( !pPager
->tempFile
&& (pPg
->flags
&PGHDR_DIRTY
) && pPager
->nSavepoint
==0 ){
6200 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg
->pgno
, PAGERID(pPager
)));
6201 IOTRACE(("CLEAN %p %d\n", pPager
, pPg
->pgno
))
6202 pPg
->flags
|= PGHDR_DONT_WRITE
;
6203 pPg
->flags
&= ~PGHDR_WRITEABLE
;
6204 testcase( pPg
->flags
& PGHDR_NEED_SYNC
);
6205 pager_set_pagehash(pPg
);
6210 ** This routine is called to increment the value of the database file
6211 ** change-counter, stored as a 4-byte big-endian integer starting at
6212 ** byte offset 24 of the pager file. The secondary change counter at
6213 ** 92 is also updated, as is the SQLite version number at offset 96.
6215 ** But this only happens if the pPager->changeCountDone flag is false.
6216 ** To avoid excess churning of page 1, the update only happens once.
6217 ** See also the pager_write_changecounter() routine that does an
6218 ** unconditional update of the change counters.
6220 ** If the isDirectMode flag is zero, then this is done by calling
6221 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
6222 ** page data. In this case the file will be updated when the current
6223 ** transaction is committed.
6225 ** The isDirectMode flag may only be non-zero if the library was compiled
6226 ** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
6227 ** if isDirect is non-zero, then the database file is updated directly
6228 ** by writing an updated version of page 1 using a call to the
6229 ** sqlite3OsWrite() function.
6231 static int pager_incr_changecounter(Pager
*pPager
, int isDirectMode
){
6234 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
6235 || pPager
->eState
==PAGER_WRITER_DBMOD
6237 assert( assert_pager_state(pPager
) );
6239 /* Declare and initialize constant integer 'isDirect'. If the
6240 ** atomic-write optimization is enabled in this build, then isDirect
6241 ** is initialized to the value passed as the isDirectMode parameter
6242 ** to this function. Otherwise, it is always set to zero.
6244 ** The idea is that if the atomic-write optimization is not
6245 ** enabled at compile time, the compiler can omit the tests of
6246 ** 'isDirect' below, as well as the block enclosed in the
6247 ** "if( isDirect )" condition.
6249 #ifndef SQLITE_ENABLE_ATOMIC_WRITE
6250 # define DIRECT_MODE 0
6251 assert( isDirectMode
==0 );
6252 UNUSED_PARAMETER(isDirectMode
);
6254 # define DIRECT_MODE isDirectMode
6257 if( !pPager
->changeCountDone
&& ALWAYS(pPager
->dbSize
>0) ){
6258 PgHdr
*pPgHdr
; /* Reference to page 1 */
6260 assert( !pPager
->tempFile
&& isOpen(pPager
->fd
) );
6262 /* Open page 1 of the file for writing. */
6263 rc
= sqlite3PagerGet(pPager
, 1, &pPgHdr
, 0);
6264 assert( pPgHdr
==0 || rc
==SQLITE_OK
);
6266 /* If page one was fetched successfully, and this function is not
6267 ** operating in direct-mode, make page 1 writable. When not in
6268 ** direct mode, page 1 is always held in cache and hence the PagerGet()
6269 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
6271 if( !DIRECT_MODE
&& ALWAYS(rc
==SQLITE_OK
) ){
6272 rc
= sqlite3PagerWrite(pPgHdr
);
6275 if( rc
==SQLITE_OK
){
6276 /* Actually do the update of the change counter */
6277 pager_write_changecounter(pPgHdr
);
6279 /* If running in direct mode, write the contents of page 1 to the file. */
6282 assert( pPager
->dbFileSize
>0 );
6283 zBuf
= pPgHdr
->pData
;
6284 if( rc
==SQLITE_OK
){
6285 rc
= sqlite3OsWrite(pPager
->fd
, zBuf
, pPager
->pageSize
, 0);
6286 pPager
->aStat
[PAGER_STAT_WRITE
]++;
6288 if( rc
==SQLITE_OK
){
6289 /* Update the pager's copy of the change-counter. Otherwise, the
6290 ** next time a read transaction is opened the cache will be
6291 ** flushed (as the change-counter values will not match). */
6292 const void *pCopy
= (const void *)&((const char *)zBuf
)[24];
6293 memcpy(&pPager
->dbFileVers
, pCopy
, sizeof(pPager
->dbFileVers
));
6294 pPager
->changeCountDone
= 1;
6297 pPager
->changeCountDone
= 1;
6301 /* Release the page reference. */
6302 sqlite3PagerUnref(pPgHdr
);
6308 ** Sync the database file to disk. This is a no-op for in-memory databases
6309 ** or pages with the Pager.noSync flag set.
6311 ** If successful, or if called on a pager for which it is a no-op, this
6312 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
6314 int sqlite3PagerSync(Pager
*pPager
, const char *zSuper
){
6316 void *pArg
= (void*)zSuper
;
6317 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_SYNC
, pArg
);
6318 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
6319 if( rc
==SQLITE_OK
&& !pPager
->noSync
){
6321 rc
= sqlite3OsSync(pPager
->fd
, pPager
->syncFlags
);
6327 ** This function may only be called while a write-transaction is active in
6328 ** rollback. If the connection is in WAL mode, this call is a no-op.
6329 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
6330 ** the database file, an attempt is made to obtain one.
6332 ** If the EXCLUSIVE lock is already held or the attempt to obtain it is
6333 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
6334 ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
6337 int sqlite3PagerExclusiveLock(Pager
*pPager
){
6338 int rc
= pPager
->errCode
;
6339 assert( assert_pager_state(pPager
) );
6340 if( rc
==SQLITE_OK
){
6341 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
6342 || pPager
->eState
==PAGER_WRITER_DBMOD
6343 || pPager
->eState
==PAGER_WRITER_LOCKED
6345 assert( assert_pager_state(pPager
) );
6346 if( 0==pagerUseWal(pPager
) ){
6347 rc
= pager_wait_on_lock(pPager
, EXCLUSIVE_LOCK
);
6354 ** Sync the database file for the pager pPager. zSuper points to the name
6355 ** of a super-journal file that should be written into the individual
6356 ** journal file. zSuper may be NULL, which is interpreted as no
6357 ** super-journal (a single database transaction).
6359 ** This routine ensures that:
6361 ** * The database file change-counter is updated,
6362 ** * the journal is synced (unless the atomic-write optimization is used),
6363 ** * all dirty pages are written to the database file,
6364 ** * the database file is truncated (if required), and
6365 ** * the database file synced.
6367 ** The only thing that remains to commit the transaction is to finalize
6368 ** (delete, truncate or zero the first part of) the journal file (or
6369 ** delete the super-journal file if specified).
6371 ** Note that if zSuper==NULL, this does not overwrite a previous value
6372 ** passed to an sqlite3PagerCommitPhaseOne() call.
6374 ** If the final parameter - noSync - is true, then the database file itself
6375 ** is not synced. The caller must call sqlite3PagerSync() directly to
6376 ** sync the database file before calling CommitPhaseTwo() to delete the
6377 ** journal file in this case.
6379 int sqlite3PagerCommitPhaseOne(
6380 Pager
*pPager
, /* Pager object */
6381 const char *zSuper
, /* If not NULL, the super-journal name */
6382 int noSync
/* True to omit the xSync on the db file */
6384 int rc
= SQLITE_OK
; /* Return code */
6386 assert( pPager
->eState
==PAGER_WRITER_LOCKED
6387 || pPager
->eState
==PAGER_WRITER_CACHEMOD
6388 || pPager
->eState
==PAGER_WRITER_DBMOD
6389 || pPager
->eState
==PAGER_ERROR
6391 assert( assert_pager_state(pPager
) );
6393 /* If a prior error occurred, report that error again. */
6394 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
6396 /* Provide the ability to easily simulate an I/O error during testing */
6397 if( sqlite3FaultSim(400) ) return SQLITE_IOERR
;
6399 PAGERTRACE(("DATABASE SYNC: File=%s zSuper=%s nSize=%d\n",
6400 pPager
->zFilename
, zSuper
, pPager
->dbSize
));
6402 /* If no database changes have been made, return early. */
6403 if( pPager
->eState
<PAGER_WRITER_CACHEMOD
) return SQLITE_OK
;
6405 assert( MEMDB
==0 || pPager
->tempFile
);
6406 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
6407 if( 0==pagerFlushOnCommit(pPager
, 1) ){
6408 /* If this is an in-memory db, or no pages have been written to, or this
6409 ** function has already been called, it is mostly a no-op. However, any
6410 ** backup in progress needs to be restarted. */
6411 sqlite3BackupRestart(pPager
->pBackup
);
6414 if( pagerUseWal(pPager
) ){
6415 PgHdr
*pPageOne
= 0;
6416 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
6418 /* Must have at least one page for the WAL commit flag.
6419 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
6420 rc
= sqlite3PagerGet(pPager
, 1, &pPageOne
, 0);
6424 assert( rc
==SQLITE_OK
);
6425 if( ALWAYS(pList
) ){
6426 rc
= pagerWalFrames(pPager
, pList
, pPager
->dbSize
, 1);
6428 sqlite3PagerUnref(pPageOne
);
6429 if( rc
==SQLITE_OK
){
6430 sqlite3PcacheCleanAll(pPager
->pPCache
);
6433 /* The bBatch boolean is true if the batch-atomic-write commit method
6434 ** should be used. No rollback journal is created if batch-atomic-write
6437 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6438 sqlite3_file
*fd
= pPager
->fd
;
6439 int bBatch
= zSuper
==0 /* An SQLITE_IOCAP_BATCH_ATOMIC commit */
6440 && (sqlite3OsDeviceCharacteristics(fd
) & SQLITE_IOCAP_BATCH_ATOMIC
)
6442 && sqlite3JournalIsInMemory(pPager
->jfd
);
6447 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
6448 /* The following block updates the change-counter. Exactly how it
6449 ** does this depends on whether or not the atomic-update optimization
6450 ** was enabled at compile time, and if this transaction meets the
6451 ** runtime criteria to use the operation:
6453 ** * The file-system supports the atomic-write property for
6454 ** blocks of size page-size, and
6455 ** * This commit is not part of a multi-file transaction, and
6456 ** * Exactly one page has been modified and store in the journal file.
6458 ** If the optimization was not enabled at compile time, then the
6459 ** pager_incr_changecounter() function is called to update the change
6460 ** counter in 'indirect-mode'. If the optimization is compiled in but
6461 ** is not applicable to this transaction, call sqlite3JournalCreate()
6462 ** to make sure the journal file has actually been created, then call
6463 ** pager_incr_changecounter() to update the change-counter in indirect
6466 ** Otherwise, if the optimization is both enabled and applicable,
6467 ** then call pager_incr_changecounter() to update the change-counter
6468 ** in 'direct' mode. In this case the journal file will never be
6469 ** created for this transaction.
6473 assert( isOpen(pPager
->jfd
)
6474 || pPager
->journalMode
==PAGER_JOURNALMODE_OFF
6475 || pPager
->journalMode
==PAGER_JOURNALMODE_WAL
6477 if( !zSuper
&& isOpen(pPager
->jfd
)
6478 && pPager
->journalOff
==jrnlBufferSize(pPager
)
6479 && pPager
->dbSize
>=pPager
->dbOrigSize
6480 && (!(pPg
= sqlite3PcacheDirtyList(pPager
->pPCache
)) || 0==pPg
->pDirty
)
6482 /* Update the db file change counter via the direct-write method. The
6483 ** following call will modify the in-memory representation of page 1
6484 ** to include the updated change counter and then write page 1
6485 ** directly to the database file. Because of the atomic-write
6486 ** property of the host file-system, this is safe.
6488 rc
= pager_incr_changecounter(pPager
, 1);
6490 rc
= sqlite3JournalCreate(pPager
->jfd
);
6491 if( rc
==SQLITE_OK
){
6492 rc
= pager_incr_changecounter(pPager
, 0);
6496 #else /* SQLITE_ENABLE_ATOMIC_WRITE */
6497 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6499 rc
= sqlite3JournalCreate(pPager
->jfd
);
6500 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6501 assert( bBatch
==0 );
6504 rc
= pager_incr_changecounter(pPager
, 0);
6505 #endif /* !SQLITE_ENABLE_ATOMIC_WRITE */
6506 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6508 /* Write the super-journal name into the journal file. If a
6509 ** super-journal file name has already been written to the journal file,
6510 ** or if zSuper is NULL (no super-journal), then this call is a no-op.
6512 rc
= writeSuperJournal(pPager
, zSuper
);
6513 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6515 /* Sync the journal file and write all dirty pages to the database.
6516 ** If the atomic-update optimization is being used, this sync will not
6517 ** create the journal file or perform any real IO.
6519 ** Because the change-counter page was just modified, unless the
6520 ** atomic-update optimization is used it is almost certain that the
6521 ** journal requires a sync here. However, in locking_mode=exclusive
6522 ** on a system under memory pressure it is just possible that this is
6523 ** not the case. In this case it is likely enough that the redundant
6524 ** xSync() call will be changed to a no-op by the OS anyhow.
6526 rc
= syncJournal(pPager
, 0);
6527 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6529 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
6530 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6532 rc
= sqlite3OsFileControl(fd
, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE
, 0);
6533 if( rc
==SQLITE_OK
){
6534 rc
= pager_write_pagelist(pPager
, pList
);
6535 if( rc
==SQLITE_OK
){
6536 rc
= sqlite3OsFileControl(fd
, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE
, 0);
6538 if( rc
!=SQLITE_OK
){
6539 sqlite3OsFileControlHint(fd
, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE
, 0);
6543 if( (rc
&0xFF)==SQLITE_IOERR
&& rc
!=SQLITE_IOERR_NOMEM
){
6544 rc
= sqlite3JournalCreate(pPager
->jfd
);
6545 if( rc
!=SQLITE_OK
){
6546 sqlite3OsClose(pPager
->jfd
);
6547 goto commit_phase_one_exit
;
6551 sqlite3OsClose(pPager
->jfd
);
6554 #endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */
6557 rc
= pager_write_pagelist(pPager
, pList
);
6559 if( rc
!=SQLITE_OK
){
6560 assert( rc
!=SQLITE_IOERR_BLOCKED
);
6561 goto commit_phase_one_exit
;
6563 sqlite3PcacheCleanAll(pPager
->pPCache
);
6565 /* If the file on disk is smaller than the database image, use
6566 ** pager_truncate to grow the file here. This can happen if the database
6567 ** image was extended as part of the current transaction and then the
6568 ** last page in the db image moved to the free-list. In this case the
6569 ** last page is never written out to disk, leaving the database file
6570 ** undersized. Fix this now if it is the case. */
6571 if( pPager
->dbSize
>pPager
->dbFileSize
){
6572 Pgno nNew
= pPager
->dbSize
- (pPager
->dbSize
==PAGER_MJ_PGNO(pPager
));
6573 assert( pPager
->eState
==PAGER_WRITER_DBMOD
);
6574 rc
= pager_truncate(pPager
, nNew
);
6575 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6578 /* Finally, sync the database file. */
6580 rc
= sqlite3PagerSync(pPager
, zSuper
);
6582 IOTRACE(("DBSYNC %p\n", pPager
))
6586 commit_phase_one_exit
:
6587 if( rc
==SQLITE_OK
&& !pagerUseWal(pPager
) ){
6588 pPager
->eState
= PAGER_WRITER_FINISHED
;
6595 ** When this function is called, the database file has been completely
6596 ** updated to reflect the changes made by the current transaction and
6597 ** synced to disk. The journal file still exists in the file-system
6598 ** though, and if a failure occurs at this point it will eventually
6599 ** be used as a hot-journal and the current transaction rolled back.
6601 ** This function finalizes the journal file, either by deleting,
6602 ** truncating or partially zeroing it, so that it cannot be used
6603 ** for hot-journal rollback. Once this is done the transaction is
6604 ** irrevocably committed.
6606 ** If an error occurs, an IO error code is returned and the pager
6607 ** moves into the error state. Otherwise, SQLITE_OK is returned.
6609 int sqlite3PagerCommitPhaseTwo(Pager
*pPager
){
6610 int rc
= SQLITE_OK
; /* Return code */
6612 /* This routine should not be called if a prior error has occurred.
6613 ** But if (due to a coding error elsewhere in the system) it does get
6614 ** called, just return the same error code without doing anything. */
6615 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
6616 pPager
->iDataVersion
++;
6618 assert( pPager
->eState
==PAGER_WRITER_LOCKED
6619 || pPager
->eState
==PAGER_WRITER_FINISHED
6620 || (pagerUseWal(pPager
) && pPager
->eState
==PAGER_WRITER_CACHEMOD
)
6622 assert( assert_pager_state(pPager
) );
6624 /* An optimization. If the database was not actually modified during
6625 ** this transaction, the pager is running in exclusive-mode and is
6626 ** using persistent journals, then this function is a no-op.
6628 ** The start of the journal file currently contains a single journal
6629 ** header with the nRec field set to 0. If such a journal is used as
6630 ** a hot-journal during hot-journal rollback, 0 changes will be made
6631 ** to the database file. So there is no need to zero the journal
6632 ** header. Since the pager is in exclusive mode, there is no need
6633 ** to drop any locks either.
6635 if( pPager
->eState
==PAGER_WRITER_LOCKED
6636 && pPager
->exclusiveMode
6637 && pPager
->journalMode
==PAGER_JOURNALMODE_PERSIST
6639 assert( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) || !pPager
->journalOff
);
6640 pPager
->eState
= PAGER_READER
;
6644 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager
)));
6645 rc
= pager_end_transaction(pPager
, pPager
->setSuper
, 1);
6646 return pager_error(pPager
, rc
);
6650 ** If a write transaction is open, then all changes made within the
6651 ** transaction are reverted and the current write-transaction is closed.
6652 ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
6653 ** state if an error occurs.
6655 ** If the pager is already in PAGER_ERROR state when this function is called,
6656 ** it returns Pager.errCode immediately. No work is performed in this case.
6658 ** Otherwise, in rollback mode, this function performs two functions:
6660 ** 1) It rolls back the journal file, restoring all database file and
6661 ** in-memory cache pages to the state they were in when the transaction
6664 ** 2) It finalizes the journal file, so that it is not used for hot
6665 ** rollback at any point in the future.
6667 ** Finalization of the journal file (task 2) is only performed if the
6668 ** rollback is successful.
6670 ** In WAL mode, all cache-entries containing data modified within the
6671 ** current transaction are either expelled from the cache or reverted to
6672 ** their pre-transaction state by re-reading data from the database or
6673 ** WAL files. The WAL transaction is then closed.
6675 int sqlite3PagerRollback(Pager
*pPager
){
6676 int rc
= SQLITE_OK
; /* Return code */
6677 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager
)));
6679 /* PagerRollback() is a no-op if called in READER or OPEN state. If
6680 ** the pager is already in the ERROR state, the rollback is not
6681 ** attempted here. Instead, the error code is returned to the caller.
6683 assert( assert_pager_state(pPager
) );
6684 if( pPager
->eState
==PAGER_ERROR
) return pPager
->errCode
;
6685 if( pPager
->eState
<=PAGER_READER
) return SQLITE_OK
;
6687 if( pagerUseWal(pPager
) ){
6689 rc
= sqlite3PagerSavepoint(pPager
, SAVEPOINT_ROLLBACK
, -1);
6690 rc2
= pager_end_transaction(pPager
, pPager
->setSuper
, 0);
6691 if( rc
==SQLITE_OK
) rc
= rc2
;
6692 }else if( !isOpen(pPager
->jfd
) || pPager
->eState
==PAGER_WRITER_LOCKED
){
6693 int eState
= pPager
->eState
;
6694 rc
= pager_end_transaction(pPager
, 0, 0);
6695 if( !MEMDB
&& eState
>PAGER_WRITER_LOCKED
){
6696 /* This can happen using journal_mode=off. Move the pager to the error
6697 ** state to indicate that the contents of the cache may not be trusted.
6698 ** Any active readers will get SQLITE_ABORT.
6700 pPager
->errCode
= SQLITE_ABORT
;
6701 pPager
->eState
= PAGER_ERROR
;
6702 setGetterMethod(pPager
);
6706 rc
= pager_playback(pPager
, 0);
6709 assert( pPager
->eState
==PAGER_READER
|| rc
!=SQLITE_OK
);
6710 assert( rc
==SQLITE_OK
|| rc
==SQLITE_FULL
|| rc
==SQLITE_CORRUPT
6711 || rc
==SQLITE_NOMEM
|| (rc
&0xFF)==SQLITE_IOERR
6712 || rc
==SQLITE_CANTOPEN
6715 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
6716 ** cache. So call pager_error() on the way out to make any error persistent.
6718 return pager_error(pPager
, rc
);
6722 ** Return TRUE if the database file is opened read-only. Return FALSE
6723 ** if the database is (in theory) writable.
6725 u8
sqlite3PagerIsreadonly(Pager
*pPager
){
6726 return pPager
->readOnly
;
6731 ** Return the sum of the reference counts for all pages held by pPager.
6733 int sqlite3PagerRefcount(Pager
*pPager
){
6734 return sqlite3PcacheRefCount(pPager
->pPCache
);
6739 ** Return the approximate number of bytes of memory currently
6740 ** used by the pager and its associated cache.
6742 int sqlite3PagerMemUsed(Pager
*pPager
){
6743 int perPageSize
= pPager
->pageSize
+ pPager
->nExtra
6744 + (int)(sizeof(PgHdr
) + 5*sizeof(void*));
6745 return perPageSize
*sqlite3PcachePagecount(pPager
->pPCache
)
6746 + sqlite3MallocSize(pPager
)
6751 ** Return the number of references to the specified page.
6753 int sqlite3PagerPageRefcount(DbPage
*pPage
){
6754 return sqlite3PcachePageRefcount(pPage
);
6759 ** This routine is used for testing and analysis only.
6761 int *sqlite3PagerStats(Pager
*pPager
){
6763 a
[0] = sqlite3PcacheRefCount(pPager
->pPCache
);
6764 a
[1] = sqlite3PcachePagecount(pPager
->pPCache
);
6765 a
[2] = sqlite3PcacheGetCachesize(pPager
->pPCache
);
6766 a
[3] = pPager
->eState
==PAGER_OPEN
? -1 : (int) pPager
->dbSize
;
6767 a
[4] = pPager
->eState
;
6768 a
[5] = pPager
->errCode
;
6769 a
[6] = pPager
->aStat
[PAGER_STAT_HIT
];
6770 a
[7] = pPager
->aStat
[PAGER_STAT_MISS
];
6771 a
[8] = 0; /* Used to be pPager->nOvfl */
6772 a
[9] = pPager
->nRead
;
6773 a
[10] = pPager
->aStat
[PAGER_STAT_WRITE
];
6779 ** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE,
6780 ** or _WRITE+1. The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation
6781 ** of SQLITE_DBSTATUS_CACHE_SPILL. The _SPILL case is not contiguous because
6782 ** it was added later.
6784 ** Before returning, *pnVal is incremented by the
6785 ** current cache hit or miss count, according to the value of eStat. If the
6786 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
6789 void sqlite3PagerCacheStat(Pager
*pPager
, int eStat
, int reset
, int *pnVal
){
6791 assert( eStat
==SQLITE_DBSTATUS_CACHE_HIT
6792 || eStat
==SQLITE_DBSTATUS_CACHE_MISS
6793 || eStat
==SQLITE_DBSTATUS_CACHE_WRITE
6794 || eStat
==SQLITE_DBSTATUS_CACHE_WRITE
+1
6797 assert( SQLITE_DBSTATUS_CACHE_HIT
+1==SQLITE_DBSTATUS_CACHE_MISS
);
6798 assert( SQLITE_DBSTATUS_CACHE_HIT
+2==SQLITE_DBSTATUS_CACHE_WRITE
);
6799 assert( PAGER_STAT_HIT
==0 && PAGER_STAT_MISS
==1
6800 && PAGER_STAT_WRITE
==2 && PAGER_STAT_SPILL
==3 );
6802 eStat
-= SQLITE_DBSTATUS_CACHE_HIT
;
6803 *pnVal
+= pPager
->aStat
[eStat
];
6805 pPager
->aStat
[eStat
] = 0;
6810 ** Return true if this is an in-memory or temp-file backed pager.
6812 int sqlite3PagerIsMemdb(Pager
*pPager
){
6813 return pPager
->tempFile
|| pPager
->memVfs
;
6817 ** Check that there are at least nSavepoint savepoints open. If there are
6818 ** currently less than nSavepoints open, then open one or more savepoints
6819 ** to make up the difference. If the number of savepoints is already
6820 ** equal to nSavepoint, then this function is a no-op.
6822 ** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
6823 ** occurs while opening the sub-journal file, then an IO error code is
6824 ** returned. Otherwise, SQLITE_OK.
6826 static SQLITE_NOINLINE
int pagerOpenSavepoint(Pager
*pPager
, int nSavepoint
){
6827 int rc
= SQLITE_OK
; /* Return code */
6828 int nCurrent
= pPager
->nSavepoint
; /* Current number of savepoints */
6829 int ii
; /* Iterator variable */
6830 PagerSavepoint
*aNew
; /* New Pager.aSavepoint array */
6832 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6833 assert( assert_pager_state(pPager
) );
6834 assert( nSavepoint
>nCurrent
&& pPager
->useJournal
);
6836 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
6837 ** if the allocation fails. Otherwise, zero the new portion in case a
6838 ** malloc failure occurs while populating it in the for(...) loop below.
6840 aNew
= (PagerSavepoint
*)sqlite3Realloc(
6841 pPager
->aSavepoint
, sizeof(PagerSavepoint
)*nSavepoint
6844 return SQLITE_NOMEM_BKPT
;
6846 memset(&aNew
[nCurrent
], 0, (nSavepoint
-nCurrent
) * sizeof(PagerSavepoint
));
6847 pPager
->aSavepoint
= aNew
;
6849 /* Populate the PagerSavepoint structures just allocated. */
6850 for(ii
=nCurrent
; ii
<nSavepoint
; ii
++){
6851 aNew
[ii
].nOrig
= pPager
->dbSize
;
6852 if( isOpen(pPager
->jfd
) && pPager
->journalOff
>0 ){
6853 aNew
[ii
].iOffset
= pPager
->journalOff
;
6855 aNew
[ii
].iOffset
= JOURNAL_HDR_SZ(pPager
);
6857 aNew
[ii
].iSubRec
= pPager
->nSubRec
;
6858 aNew
[ii
].pInSavepoint
= sqlite3BitvecCreate(pPager
->dbSize
);
6859 aNew
[ii
].bTruncateOnRelease
= 1;
6860 if( !aNew
[ii
].pInSavepoint
){
6861 return SQLITE_NOMEM_BKPT
;
6863 if( pagerUseWal(pPager
) ){
6864 sqlite3WalSavepoint(pPager
->pWal
, aNew
[ii
].aWalData
);
6866 pPager
->nSavepoint
= ii
+1;
6868 assert( pPager
->nSavepoint
==nSavepoint
);
6869 assertTruncateConstraint(pPager
);
6872 int sqlite3PagerOpenSavepoint(Pager
*pPager
, int nSavepoint
){
6873 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6874 assert( assert_pager_state(pPager
) );
6876 if( nSavepoint
>pPager
->nSavepoint
&& pPager
->useJournal
){
6877 return pagerOpenSavepoint(pPager
, nSavepoint
);
6885 ** This function is called to rollback or release (commit) a savepoint.
6886 ** The savepoint to release or rollback need not be the most recently
6887 ** created savepoint.
6889 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
6890 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
6891 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
6892 ** that have occurred since the specified savepoint was created.
6894 ** The savepoint to rollback or release is identified by parameter
6895 ** iSavepoint. A value of 0 means to operate on the outermost savepoint
6896 ** (the first created). A value of (Pager.nSavepoint-1) means operate
6897 ** on the most recently created savepoint. If iSavepoint is greater than
6898 ** (Pager.nSavepoint-1), then this function is a no-op.
6900 ** If a negative value is passed to this function, then the current
6901 ** transaction is rolled back. This is different to calling
6902 ** sqlite3PagerRollback() because this function does not terminate
6903 ** the transaction or unlock the database, it just restores the
6904 ** contents of the database to its original state.
6906 ** In any case, all savepoints with an index greater than iSavepoint
6907 ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
6908 ** then savepoint iSavepoint is also destroyed.
6910 ** This function may return SQLITE_NOMEM if a memory allocation fails,
6911 ** or an IO error code if an IO error occurs while rolling back a
6912 ** savepoint. If no errors occur, SQLITE_OK is returned.
6914 int sqlite3PagerSavepoint(Pager
*pPager
, int op
, int iSavepoint
){
6915 int rc
= pPager
->errCode
;
6917 #ifdef SQLITE_ENABLE_ZIPVFS
6918 if( op
==SAVEPOINT_RELEASE
) rc
= SQLITE_OK
;
6921 assert( op
==SAVEPOINT_RELEASE
|| op
==SAVEPOINT_ROLLBACK
);
6922 assert( iSavepoint
>=0 || op
==SAVEPOINT_ROLLBACK
);
6924 if( rc
==SQLITE_OK
&& iSavepoint
<pPager
->nSavepoint
){
6925 int ii
; /* Iterator variable */
6926 int nNew
; /* Number of remaining savepoints after this op. */
6928 /* Figure out how many savepoints will still be active after this
6929 ** operation. Store this value in nNew. Then free resources associated
6930 ** with any savepoints that are destroyed by this operation.
6932 nNew
= iSavepoint
+ (( op
==SAVEPOINT_RELEASE
) ? 0 : 1);
6933 for(ii
=nNew
; ii
<pPager
->nSavepoint
; ii
++){
6934 sqlite3BitvecDestroy(pPager
->aSavepoint
[ii
].pInSavepoint
);
6936 pPager
->nSavepoint
= nNew
;
6938 /* Truncate the sub-journal so that it only includes the parts
6939 ** that are still in use. */
6940 if( op
==SAVEPOINT_RELEASE
){
6941 PagerSavepoint
*pRel
= &pPager
->aSavepoint
[nNew
];
6942 if( pRel
->bTruncateOnRelease
&& isOpen(pPager
->sjfd
) ){
6943 /* Only truncate if it is an in-memory sub-journal. */
6944 if( sqlite3JournalIsInMemory(pPager
->sjfd
) ){
6945 i64 sz
= (pPager
->pageSize
+4)*(i64
)pRel
->iSubRec
;
6946 rc
= sqlite3OsTruncate(pPager
->sjfd
, sz
);
6947 assert( rc
==SQLITE_OK
);
6949 pPager
->nSubRec
= pRel
->iSubRec
;
6952 /* Else this is a rollback operation, playback the specified savepoint.
6953 ** If this is a temp-file, it is possible that the journal file has
6954 ** not yet been opened. In this case there have been no changes to
6955 ** the database file, so the playback operation can be skipped.
6957 else if( pagerUseWal(pPager
) || isOpen(pPager
->jfd
) ){
6958 PagerSavepoint
*pSavepoint
= (nNew
==0)?0:&pPager
->aSavepoint
[nNew
-1];
6959 rc
= pagerPlaybackSavepoint(pPager
, pSavepoint
);
6960 assert(rc
!=SQLITE_DONE
);
6963 #ifdef SQLITE_ENABLE_ZIPVFS
6964 /* If the cache has been modified but the savepoint cannot be rolled
6965 ** back journal_mode=off, put the pager in the error state. This way,
6966 ** if the VFS used by this pager includes ZipVFS, the entire transaction
6967 ** can be rolled back at the ZipVFS level. */
6969 pPager
->journalMode
==PAGER_JOURNALMODE_OFF
6970 && pPager
->eState
>=PAGER_WRITER_CACHEMOD
6972 pPager
->errCode
= SQLITE_ABORT
;
6973 pPager
->eState
= PAGER_ERROR
;
6974 setGetterMethod(pPager
);
6983 ** Return the full pathname of the database file.
6985 ** Except, if the pager is in-memory only, then return an empty string if
6986 ** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when
6987 ** used to report the filename to the user, for compatibility with legacy
6988 ** behavior. But when the Btree needs to know the filename for matching to
6989 ** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
6990 ** participate in shared-cache.
6992 ** The return value to this routine is always safe to use with
6993 ** sqlite3_uri_parameter() and sqlite3_filename_database() and friends.
6995 const char *sqlite3PagerFilename(const Pager
*pPager
, int nullIfMemDb
){
6996 static const char zFake
[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
6997 return (nullIfMemDb
&& pPager
->memDb
) ? &zFake
[4] : pPager
->zFilename
;
7001 ** Return the VFS structure for the pager.
7003 sqlite3_vfs
*sqlite3PagerVfs(Pager
*pPager
){
7004 return pPager
->pVfs
;
7008 ** Return the file handle for the database file associated
7009 ** with the pager. This might return NULL if the file has
7010 ** not yet been opened.
7012 sqlite3_file
*sqlite3PagerFile(Pager
*pPager
){
7017 ** Return the file handle for the journal file (if it exists).
7018 ** This will be either the rollback journal or the WAL file.
7020 sqlite3_file
*sqlite3PagerJrnlFile(Pager
*pPager
){
7024 return pPager
->pWal
? sqlite3WalFile(pPager
->pWal
) : pPager
->jfd
;
7029 ** Return the full pathname of the journal file.
7031 const char *sqlite3PagerJournalname(Pager
*pPager
){
7032 return pPager
->zJournal
;
7035 #ifndef SQLITE_OMIT_AUTOVACUUM
7037 ** Move the page pPg to location pgno in the file.
7039 ** There must be no references to the page previously located at
7040 ** pgno (which we call pPgOld) though that page is allowed to be
7041 ** in cache. If the page previously located at pgno is not already
7042 ** in the rollback journal, it is not put there by by this routine.
7044 ** References to the page pPg remain valid. Updating any
7045 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
7046 ** allocated along with the page) is the responsibility of the caller.
7048 ** A transaction must be active when this routine is called. It used to be
7049 ** required that a statement transaction was not active, but this restriction
7050 ** has been removed (CREATE INDEX needs to move a page when a statement
7051 ** transaction is active).
7053 ** If the fourth argument, isCommit, is non-zero, then this page is being
7054 ** moved as part of a database reorganization just before the transaction
7055 ** is being committed. In this case, it is guaranteed that the database page
7056 ** pPg refers to will not be written to again within this transaction.
7058 ** This function may return SQLITE_NOMEM or an IO error code if an error
7059 ** occurs. Otherwise, it returns SQLITE_OK.
7061 int sqlite3PagerMovepage(Pager
*pPager
, DbPage
*pPg
, Pgno pgno
, int isCommit
){
7062 PgHdr
*pPgOld
; /* The page being overwritten. */
7063 Pgno needSyncPgno
= 0; /* Old value of pPg->pgno, if sync is required */
7064 int rc
; /* Return code */
7065 Pgno origPgno
; /* The original page number */
7067 assert( pPg
->nRef
>0 );
7068 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
7069 || pPager
->eState
==PAGER_WRITER_DBMOD
7071 assert( assert_pager_state(pPager
) );
7073 /* In order to be able to rollback, an in-memory database must journal
7074 ** the page we are moving from.
7076 assert( pPager
->tempFile
|| !MEMDB
);
7077 if( pPager
->tempFile
){
7078 rc
= sqlite3PagerWrite(pPg
);
7082 /* If the page being moved is dirty and has not been saved by the latest
7083 ** savepoint, then save the current contents of the page into the
7084 ** sub-journal now. This is required to handle the following scenario:
7087 ** <journal page X, then modify it in memory>
7089 ** <Move page X to location Y>
7092 ** If page X were not written to the sub-journal here, it would not
7093 ** be possible to restore its contents when the "ROLLBACK TO one"
7094 ** statement were is processed.
7096 ** subjournalPage() may need to allocate space to store pPg->pgno into
7097 ** one or more savepoint bitvecs. This is the reason this function
7098 ** may return SQLITE_NOMEM.
7100 if( (pPg
->flags
& PGHDR_DIRTY
)!=0
7101 && SQLITE_OK
!=(rc
= subjournalPageIfRequired(pPg
))
7106 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
7107 PAGERID(pPager
), pPg
->pgno
, (pPg
->flags
&PGHDR_NEED_SYNC
)?1:0, pgno
));
7108 IOTRACE(("MOVE %p %d %d\n", pPager
, pPg
->pgno
, pgno
))
7110 /* If the journal needs to be sync()ed before page pPg->pgno can
7111 ** be written to, store pPg->pgno in local variable needSyncPgno.
7113 ** If the isCommit flag is set, there is no need to remember that
7114 ** the journal needs to be sync()ed before database page pPg->pgno
7115 ** can be written to. The caller has already promised not to write to it.
7117 if( (pPg
->flags
&PGHDR_NEED_SYNC
) && !isCommit
){
7118 needSyncPgno
= pPg
->pgno
;
7119 assert( pPager
->journalMode
==PAGER_JOURNALMODE_OFF
||
7120 pageInJournal(pPager
, pPg
) || pPg
->pgno
>pPager
->dbOrigSize
);
7121 assert( pPg
->flags
&PGHDR_DIRTY
);
7124 /* If the cache contains a page with page-number pgno, remove it
7125 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
7126 ** page pgno before the 'move' operation, it needs to be retained
7127 ** for the page moved there.
7129 pPg
->flags
&= ~PGHDR_NEED_SYNC
;
7130 pPgOld
= sqlite3PagerLookup(pPager
, pgno
);
7131 assert( !pPgOld
|| pPgOld
->nRef
==1 || CORRUPT_DB
);
7133 if( NEVER(pPgOld
->nRef
>1) ){
7134 sqlite3PagerUnrefNotNull(pPgOld
);
7135 return SQLITE_CORRUPT_BKPT
;
7137 pPg
->flags
|= (pPgOld
->flags
&PGHDR_NEED_SYNC
);
7138 if( pPager
->tempFile
){
7139 /* Do not discard pages from an in-memory database since we might
7140 ** need to rollback later. Just move the page out of the way. */
7141 sqlite3PcacheMove(pPgOld
, pPager
->dbSize
+1);
7143 sqlite3PcacheDrop(pPgOld
);
7147 origPgno
= pPg
->pgno
;
7148 sqlite3PcacheMove(pPg
, pgno
);
7149 sqlite3PcacheMakeDirty(pPg
);
7151 /* For an in-memory database, make sure the original page continues
7152 ** to exist, in case the transaction needs to roll back. Use pPgOld
7153 ** as the original page since it has already been allocated.
7155 if( pPager
->tempFile
&& pPgOld
){
7156 sqlite3PcacheMove(pPgOld
, origPgno
);
7157 sqlite3PagerUnrefNotNull(pPgOld
);
7161 /* If needSyncPgno is non-zero, then the journal file needs to be
7162 ** sync()ed before any data is written to database file page needSyncPgno.
7163 ** Currently, no such page exists in the page-cache and the
7164 ** "is journaled" bitvec flag has been set. This needs to be remedied by
7165 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
7168 ** If the attempt to load the page into the page-cache fails, (due
7169 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
7170 ** array. Otherwise, if the page is loaded and written again in
7171 ** this transaction, it may be written to the database file before
7172 ** it is synced into the journal file. This way, it may end up in
7173 ** the journal file twice, but that is not a problem.
7176 rc
= sqlite3PagerGet(pPager
, needSyncPgno
, &pPgHdr
, 0);
7177 if( rc
!=SQLITE_OK
){
7178 if( needSyncPgno
<=pPager
->dbOrigSize
){
7179 assert( pPager
->pTmpSpace
!=0 );
7180 sqlite3BitvecClear(pPager
->pInJournal
, needSyncPgno
, pPager
->pTmpSpace
);
7184 pPgHdr
->flags
|= PGHDR_NEED_SYNC
;
7185 sqlite3PcacheMakeDirty(pPgHdr
);
7186 sqlite3PagerUnrefNotNull(pPgHdr
);
7194 ** The page handle passed as the first argument refers to a dirty page
7195 ** with a page number other than iNew. This function changes the page's
7196 ** page number to iNew and sets the value of the PgHdr.flags field to
7197 ** the value passed as the third parameter.
7199 void sqlite3PagerRekey(DbPage
*pPg
, Pgno iNew
, u16 flags
){
7200 assert( pPg
->pgno
!=iNew
);
7202 sqlite3PcacheMove(pPg
, iNew
);
7206 ** Return a pointer to the data for the specified page.
7208 void *sqlite3PagerGetData(DbPage
*pPg
){
7209 assert( pPg
->nRef
>0 || pPg
->pPager
->memDb
);
7214 ** Return a pointer to the Pager.nExtra bytes of "extra" space
7215 ** allocated along with the specified page.
7217 void *sqlite3PagerGetExtra(DbPage
*pPg
){
7222 ** Get/set the locking-mode for this pager. Parameter eMode must be one
7223 ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
7224 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
7225 ** the locking-mode is set to the value specified.
7227 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
7228 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
7231 int sqlite3PagerLockingMode(Pager
*pPager
, int eMode
){
7232 assert( eMode
==PAGER_LOCKINGMODE_QUERY
7233 || eMode
==PAGER_LOCKINGMODE_NORMAL
7234 || eMode
==PAGER_LOCKINGMODE_EXCLUSIVE
);
7235 assert( PAGER_LOCKINGMODE_QUERY
<0 );
7236 assert( PAGER_LOCKINGMODE_NORMAL
>=0 && PAGER_LOCKINGMODE_EXCLUSIVE
>=0 );
7237 assert( pPager
->exclusiveMode
|| 0==sqlite3WalHeapMemory(pPager
->pWal
) );
7238 if( eMode
>=0 && !pPager
->tempFile
&& !sqlite3WalHeapMemory(pPager
->pWal
) ){
7239 pPager
->exclusiveMode
= (u8
)eMode
;
7241 return (int)pPager
->exclusiveMode
;
7245 ** Set the journal-mode for this pager. Parameter eMode must be one of:
7247 ** PAGER_JOURNALMODE_DELETE
7248 ** PAGER_JOURNALMODE_TRUNCATE
7249 ** PAGER_JOURNALMODE_PERSIST
7250 ** PAGER_JOURNALMODE_OFF
7251 ** PAGER_JOURNALMODE_MEMORY
7252 ** PAGER_JOURNALMODE_WAL
7254 ** The journalmode is set to the value specified if the change is allowed.
7255 ** The change may be disallowed for the following reasons:
7257 ** * An in-memory database can only have its journal_mode set to _OFF
7260 ** * Temporary databases cannot have _WAL journalmode.
7262 ** The returned indicate the current (possibly updated) journal-mode.
7264 int sqlite3PagerSetJournalMode(Pager
*pPager
, int eMode
){
7265 u8 eOld
= pPager
->journalMode
; /* Prior journalmode */
7267 /* The eMode parameter is always valid */
7268 assert( eMode
==PAGER_JOURNALMODE_DELETE
7269 || eMode
==PAGER_JOURNALMODE_TRUNCATE
7270 || eMode
==PAGER_JOURNALMODE_PERSIST
7271 || eMode
==PAGER_JOURNALMODE_OFF
7272 || eMode
==PAGER_JOURNALMODE_WAL
7273 || eMode
==PAGER_JOURNALMODE_MEMORY
);
7275 /* This routine is only called from the OP_JournalMode opcode, and
7276 ** the logic there will never allow a temporary file to be changed
7279 assert( pPager
->tempFile
==0 || eMode
!=PAGER_JOURNALMODE_WAL
);
7281 /* Do allow the journalmode of an in-memory database to be set to
7282 ** anything other than MEMORY or OFF
7285 assert( eOld
==PAGER_JOURNALMODE_MEMORY
|| eOld
==PAGER_JOURNALMODE_OFF
);
7286 if( eMode
!=PAGER_JOURNALMODE_MEMORY
&& eMode
!=PAGER_JOURNALMODE_OFF
){
7293 /* Change the journal mode. */
7294 assert( pPager
->eState
!=PAGER_ERROR
);
7295 pPager
->journalMode
= (u8
)eMode
;
7297 /* When transistioning from TRUNCATE or PERSIST to any other journal
7298 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
7299 ** delete the journal file.
7301 assert( (PAGER_JOURNALMODE_TRUNCATE
& 5)==1 );
7302 assert( (PAGER_JOURNALMODE_PERSIST
& 5)==1 );
7303 assert( (PAGER_JOURNALMODE_DELETE
& 5)==0 );
7304 assert( (PAGER_JOURNALMODE_MEMORY
& 5)==4 );
7305 assert( (PAGER_JOURNALMODE_OFF
& 5)==0 );
7306 assert( (PAGER_JOURNALMODE_WAL
& 5)==5 );
7308 assert( isOpen(pPager
->fd
) || pPager
->exclusiveMode
);
7309 if( !pPager
->exclusiveMode
&& (eOld
& 5)==1 && (eMode
& 1)==0 ){
7311 /* In this case we would like to delete the journal file. If it is
7312 ** not possible, then that is not a problem. Deleting the journal file
7313 ** here is an optimization only.
7315 ** Before deleting the journal file, obtain a RESERVED lock on the
7316 ** database file. This ensures that the journal file is not deleted
7317 ** while it is in use by some other client.
7319 sqlite3OsClose(pPager
->jfd
);
7320 if( pPager
->eLock
>=RESERVED_LOCK
){
7321 sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, 0);
7324 int state
= pPager
->eState
;
7325 assert( state
==PAGER_OPEN
|| state
==PAGER_READER
);
7326 if( state
==PAGER_OPEN
){
7327 rc
= sqlite3PagerSharedLock(pPager
);
7329 if( pPager
->eState
==PAGER_READER
){
7330 assert( rc
==SQLITE_OK
);
7331 rc
= pagerLockDb(pPager
, RESERVED_LOCK
);
7333 if( rc
==SQLITE_OK
){
7334 sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, 0);
7336 if( rc
==SQLITE_OK
&& state
==PAGER_READER
){
7337 pagerUnlockDb(pPager
, SHARED_LOCK
);
7338 }else if( state
==PAGER_OPEN
){
7339 pager_unlock(pPager
);
7341 assert( state
==pPager
->eState
);
7343 }else if( eMode
==PAGER_JOURNALMODE_OFF
){
7344 sqlite3OsClose(pPager
->jfd
);
7348 /* Return the new journal mode */
7349 return (int)pPager
->journalMode
;
7353 ** Return the current journal mode.
7355 int sqlite3PagerGetJournalMode(Pager
*pPager
){
7356 return (int)pPager
->journalMode
;
7360 ** Return TRUE if the pager is in a state where it is OK to change the
7361 ** journalmode. Journalmode changes can only happen when the database
7364 int sqlite3PagerOkToChangeJournalMode(Pager
*pPager
){
7365 assert( assert_pager_state(pPager
) );
7366 if( pPager
->eState
>=PAGER_WRITER_CACHEMOD
) return 0;
7367 if( NEVER(isOpen(pPager
->jfd
) && pPager
->journalOff
>0) ) return 0;
7372 ** Get/set the size-limit used for persistent journal files.
7374 ** Setting the size limit to -1 means no limit is enforced.
7375 ** An attempt to set a limit smaller than -1 is a no-op.
7377 i64
sqlite3PagerJournalSizeLimit(Pager
*pPager
, i64 iLimit
){
7379 pPager
->journalSizeLimit
= iLimit
;
7380 sqlite3WalLimit(pPager
->pWal
, iLimit
);
7382 return pPager
->journalSizeLimit
;
7386 ** Return a pointer to the pPager->pBackup variable. The backup module
7387 ** in backup.c maintains the content of this variable. This module
7388 ** uses it opaquely as an argument to sqlite3BackupRestart() and
7389 ** sqlite3BackupUpdate() only.
7391 sqlite3_backup
**sqlite3PagerBackupPtr(Pager
*pPager
){
7392 return &pPager
->pBackup
;
7395 #ifndef SQLITE_OMIT_VACUUM
7397 ** Unless this is an in-memory or temporary database, clear the pager cache.
7399 void sqlite3PagerClearCache(Pager
*pPager
){
7400 assert( MEMDB
==0 || pPager
->tempFile
);
7401 if( pPager
->tempFile
==0 ) pager_reset(pPager
);
7406 #ifndef SQLITE_OMIT_WAL
7408 ** This function is called when the user invokes "PRAGMA wal_checkpoint",
7409 ** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
7410 ** or wal_blocking_checkpoint() API functions.
7412 ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
7414 int sqlite3PagerCheckpoint(
7415 Pager
*pPager
, /* Checkpoint on this pager */
7416 sqlite3
*db
, /* Db handle used to check for interrupts */
7417 int eMode
, /* Type of checkpoint */
7418 int *pnLog
, /* OUT: Final number of frames in log */
7419 int *pnCkpt
/* OUT: Final number of checkpointed frames */
7423 rc
= sqlite3WalCheckpoint(pPager
->pWal
, db
, eMode
,
7424 (eMode
==SQLITE_CHECKPOINT_PASSIVE
? 0 : pPager
->xBusyHandler
),
7425 pPager
->pBusyHandlerArg
,
7426 pPager
->walSyncFlags
, pPager
->pageSize
, (u8
*)pPager
->pTmpSpace
,
7433 int sqlite3PagerWalCallback(Pager
*pPager
){
7434 return sqlite3WalCallback(pPager
->pWal
);
7438 ** Return true if the underlying VFS for the given pager supports the
7439 ** primitives necessary for write-ahead logging.
7441 int sqlite3PagerWalSupported(Pager
*pPager
){
7442 const sqlite3_io_methods
*pMethods
= pPager
->fd
->pMethods
;
7443 if( pPager
->noLock
) return 0;
7444 return pPager
->exclusiveMode
|| (pMethods
->iVersion
>=2 && pMethods
->xShmMap
);
7448 ** Attempt to take an exclusive lock on the database file. If a PENDING lock
7449 ** is obtained instead, immediately release it.
7451 static int pagerExclusiveLock(Pager
*pPager
){
7452 int rc
; /* Return code */
7454 assert( pPager
->eLock
==SHARED_LOCK
|| pPager
->eLock
==EXCLUSIVE_LOCK
);
7455 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
7456 if( rc
!=SQLITE_OK
){
7457 /* If the attempt to grab the exclusive lock failed, release the
7458 ** pending lock that may have been obtained instead. */
7459 pagerUnlockDb(pPager
, SHARED_LOCK
);
7466 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
7467 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
7468 ** lock on the database file and use heap-memory to store the wal-index
7469 ** in. Otherwise, use the normal shared-memory.
7471 static int pagerOpenWal(Pager
*pPager
){
7474 assert( pPager
->pWal
==0 && pPager
->tempFile
==0 );
7475 assert( pPager
->eLock
==SHARED_LOCK
|| pPager
->eLock
==EXCLUSIVE_LOCK
);
7477 /* If the pager is already in exclusive-mode, the WAL module will use
7478 ** heap-memory for the wal-index instead of the VFS shared-memory
7479 ** implementation. Take the exclusive lock now, before opening the WAL
7480 ** file, to make sure this is safe.
7482 if( pPager
->exclusiveMode
){
7483 rc
= pagerExclusiveLock(pPager
);
7486 /* Open the connection to the log file. If this operation fails,
7487 ** (e.g. due to malloc() failure), return an error code.
7489 if( rc
==SQLITE_OK
){
7490 rc
= sqlite3WalOpen(pPager
->pVfs
,
7491 pPager
->fd
, pPager
->zWal
, pPager
->exclusiveMode
,
7492 pPager
->journalSizeLimit
, &pPager
->pWal
7495 pagerFixMaplimit(pPager
);
7502 ** The caller must be holding a SHARED lock on the database file to call
7505 ** If the pager passed as the first argument is open on a real database
7506 ** file (not a temp file or an in-memory database), and the WAL file
7507 ** is not already open, make an attempt to open it now. If successful,
7508 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
7509 ** not support the xShmXXX() methods, return an error code. *pbOpen is
7510 ** not modified in either case.
7512 ** If the pager is open on a temp-file (or in-memory database), or if
7513 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
7514 ** without doing anything.
7516 int sqlite3PagerOpenWal(
7517 Pager
*pPager
, /* Pager object */
7518 int *pbOpen
/* OUT: Set to true if call is a no-op */
7520 int rc
= SQLITE_OK
; /* Return code */
7522 assert( assert_pager_state(pPager
) );
7523 assert( pPager
->eState
==PAGER_OPEN
|| pbOpen
);
7524 assert( pPager
->eState
==PAGER_READER
|| !pbOpen
);
7525 assert( pbOpen
==0 || *pbOpen
==0 );
7526 assert( pbOpen
!=0 || (!pPager
->tempFile
&& !pPager
->pWal
) );
7528 if( !pPager
->tempFile
&& !pPager
->pWal
){
7529 if( !sqlite3PagerWalSupported(pPager
) ) return SQLITE_CANTOPEN
;
7531 /* Close any rollback journal previously open */
7532 sqlite3OsClose(pPager
->jfd
);
7534 rc
= pagerOpenWal(pPager
);
7535 if( rc
==SQLITE_OK
){
7536 pPager
->journalMode
= PAGER_JOURNALMODE_WAL
;
7537 pPager
->eState
= PAGER_OPEN
;
7547 ** This function is called to close the connection to the log file prior
7548 ** to switching from WAL to rollback mode.
7550 ** Before closing the log file, this function attempts to take an
7551 ** EXCLUSIVE lock on the database file. If this cannot be obtained, an
7552 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
7553 ** If successful, the EXCLUSIVE lock is not released before returning.
7555 int sqlite3PagerCloseWal(Pager
*pPager
, sqlite3
*db
){
7558 assert( pPager
->journalMode
==PAGER_JOURNALMODE_WAL
);
7560 /* If the log file is not already open, but does exist in the file-system,
7561 ** it may need to be checkpointed before the connection can switch to
7562 ** rollback mode. Open it now so this can happen.
7564 if( !pPager
->pWal
){
7566 rc
= pagerLockDb(pPager
, SHARED_LOCK
);
7567 if( rc
==SQLITE_OK
){
7568 rc
= sqlite3OsAccess(
7569 pPager
->pVfs
, pPager
->zWal
, SQLITE_ACCESS_EXISTS
, &logexists
7572 if( rc
==SQLITE_OK
&& logexists
){
7573 rc
= pagerOpenWal(pPager
);
7577 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
7578 ** the database file, the log and log-summary files will be deleted.
7580 if( rc
==SQLITE_OK
&& pPager
->pWal
){
7581 rc
= pagerExclusiveLock(pPager
);
7582 if( rc
==SQLITE_OK
){
7583 rc
= sqlite3WalClose(pPager
->pWal
, db
, pPager
->walSyncFlags
,
7584 pPager
->pageSize
, (u8
*)pPager
->pTmpSpace
);
7586 pagerFixMaplimit(pPager
);
7587 if( rc
&& !pPager
->exclusiveMode
) pagerUnlockDb(pPager
, SHARED_LOCK
);
7593 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
7595 ** If pager pPager is a wal-mode database not in exclusive locking mode,
7596 ** invoke the sqlite3WalWriteLock() function on the associated Wal object
7597 ** with the same db and bLock parameters as were passed to this function.
7598 ** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
7600 int sqlite3PagerWalWriteLock(Pager
*pPager
, int bLock
){
7602 if( pagerUseWal(pPager
) && pPager
->exclusiveMode
==0 ){
7603 rc
= sqlite3WalWriteLock(pPager
->pWal
, bLock
);
7609 ** Set the database handle used by the wal layer to determine if
7610 ** blocking locks are required.
7612 void sqlite3PagerWalDb(Pager
*pPager
, sqlite3
*db
){
7613 if( pagerUseWal(pPager
) ){
7614 sqlite3WalDb(pPager
->pWal
, db
);
7619 #ifdef SQLITE_ENABLE_SNAPSHOT
7621 ** If this is a WAL database, obtain a snapshot handle for the snapshot
7622 ** currently open. Otherwise, return an error.
7624 int sqlite3PagerSnapshotGet(Pager
*pPager
, sqlite3_snapshot
**ppSnapshot
){
7625 int rc
= SQLITE_ERROR
;
7627 rc
= sqlite3WalSnapshotGet(pPager
->pWal
, ppSnapshot
);
7633 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
7634 ** read transaction is opened, attempt to read from the snapshot it
7635 ** identifies. If this is not a WAL database, return an error.
7637 int sqlite3PagerSnapshotOpen(
7639 sqlite3_snapshot
*pSnapshot
7643 sqlite3WalSnapshotOpen(pPager
->pWal
, pSnapshot
);
7651 ** If this is a WAL database, call sqlite3WalSnapshotRecover(). If this
7652 ** is not a WAL database, return an error.
7654 int sqlite3PagerSnapshotRecover(Pager
*pPager
){
7657 rc
= sqlite3WalSnapshotRecover(pPager
->pWal
);
7665 ** The caller currently has a read transaction open on the database.
7666 ** If this is not a WAL database, SQLITE_ERROR is returned. Otherwise,
7667 ** this function takes a SHARED lock on the CHECKPOINTER slot and then
7668 ** checks if the snapshot passed as the second argument is still
7669 ** available. If so, SQLITE_OK is returned.
7671 ** If the snapshot is not available, SQLITE_ERROR is returned. Or, if
7672 ** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error
7673 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
7674 ** lock is released before returning.
7676 int sqlite3PagerSnapshotCheck(Pager
*pPager
, sqlite3_snapshot
*pSnapshot
){
7679 rc
= sqlite3WalSnapshotCheck(pPager
->pWal
, pSnapshot
);
7687 ** Release a lock obtained by an earlier successful call to
7688 ** sqlite3PagerSnapshotCheck().
7690 void sqlite3PagerSnapshotUnlock(Pager
*pPager
){
7691 assert( pPager
->pWal
);
7692 sqlite3WalSnapshotUnlock(pPager
->pWal
);
7695 #endif /* SQLITE_ENABLE_SNAPSHOT */
7696 #endif /* !SQLITE_OMIT_WAL */
7698 #ifdef SQLITE_ENABLE_ZIPVFS
7700 ** A read-lock must be held on the pager when this function is called. If
7701 ** the pager is in WAL mode and the WAL file currently contains one or more
7702 ** frames, return the size in bytes of the page images stored within the
7703 ** WAL frames. Otherwise, if this is not a WAL database or the WAL file
7704 ** is empty, return 0.
7706 int sqlite3PagerWalFramesize(Pager
*pPager
){
7707 assert( pPager
->eState
>=PAGER_READER
);
7708 return sqlite3WalFramesize(pPager
->pWal
);
7712 #endif /* SQLITE_OMIT_DISKIO */