4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This is the implementation of the page cache subsystem or "pager".
14 ** The pager is used to access a database disk file. It implements
15 ** atomic commit and rollback through the use of a journal file that
16 ** is separate from the database file. The pager also implements file
17 ** locking to prevent two processes from writing the same database
18 ** file simultaneously, or one process from reading the database while
19 ** another is writing.
21 #ifndef SQLITE_OMIT_DISKIO
22 #include "sqliteInt.h"
26 /******************* NOTES ON THE DESIGN OF THE PAGER ************************
28 ** This comment block describes invariants that hold when using a rollback
29 ** journal. These invariants do not apply for journal_mode=WAL,
30 ** journal_mode=MEMORY, or journal_mode=OFF.
32 ** Within this comment block, a page is deemed to have been synced
33 ** automatically as soon as it is written when PRAGMA synchronous=OFF.
34 ** Otherwise, the page is not synced until the xSync method of the VFS
35 ** is called successfully on the file containing the page.
37 ** Definition: A page of the database file is said to be "overwriteable" if
38 ** one or more of the following are true about the page:
40 ** (a) The original content of the page as it was at the beginning of
41 ** the transaction has been written into the rollback journal and
44 ** (b) The page was a freelist leaf page at the start of the transaction.
46 ** (c) The page number is greater than the largest page that existed in
47 ** the database file at the start of the transaction.
49 ** (1) A page of the database file is never overwritten unless one of the
50 ** following are true:
52 ** (a) The page and all other pages on the same sector are overwriteable.
54 ** (b) The atomic page write optimization is enabled, and the entire
55 ** transaction other than the update of the transaction sequence
56 ** number consists of a single page change.
58 ** (2) The content of a page written into the rollback journal exactly matches
59 ** both the content in the database when the rollback journal was written
60 ** and the content in the database at the beginning of the current
63 ** (3) Writes to the database file are an integer multiple of the page size
64 ** in length and are aligned on a page boundary.
66 ** (4) Reads from the database file are either aligned on a page boundary and
67 ** an integer multiple of the page size in length or are taken from the
68 ** first 100 bytes of the database file.
70 ** (5) All writes to the database file are synced prior to the rollback journal
71 ** being deleted, truncated, or zeroed.
73 ** (6) If a master journal file is used, then all writes to the database file
74 ** are synced prior to the master journal being deleted.
76 ** Definition: Two databases (or the same database at two points it time)
77 ** are said to be "logically equivalent" if they give the same answer to
78 ** all queries. Note in particular the content of freelist leaf
79 ** pages can be changed arbitrarily without affecting the logical equivalence
82 ** (7) At any time, if any subset, including the empty set and the total set,
83 ** of the unsynced changes to a rollback journal are removed and the
84 ** journal is rolled back, the resulting database file will be logically
85 ** equivalent to the database file at the beginning of the transaction.
87 ** (8) When a transaction is rolled back, the xTruncate method of the VFS
88 ** is called to restore the database file to the same size it was at
89 ** the beginning of the transaction. (In some VFSes, the xTruncate
90 ** method is a no-op, but that does not change the fact the SQLite will
93 ** (9) Whenever the database file is modified, at least one bit in the range
94 ** of bytes from 24 through 39 inclusive will be changed prior to releasing
95 ** the EXCLUSIVE lock, thus signaling other connections on the same
96 ** database to flush their caches.
98 ** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
99 ** than one billion transactions.
101 ** (11) A database file is well-formed at the beginning and at the conclusion
102 ** of every transaction.
104 ** (12) An EXCLUSIVE lock is held on the database file when writing to
105 ** the database file.
107 ** (13) A SHARED lock is held on the database file while reading any
108 ** content out of the database file.
110 ******************************************************************************/
113 ** Macros for troubleshooting. Normally turned off
116 int sqlite3PagerTrace
=1; /* True to enable tracing */
117 #define sqlite3DebugPrintf printf
118 #define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }
120 #define PAGERTRACE(X)
124 ** The following two macros are used within the PAGERTRACE() macros above
125 ** to print out file-descriptors.
127 ** PAGERID() takes a pointer to a Pager struct as its argument. The
128 ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
129 ** struct as its argument.
131 #define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd))
132 #define FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd))
135 ** The Pager.eState variable stores the current 'state' of a pager. A
136 ** pager may be in any one of the seven states shown in the following
139 ** OPEN <------+------+
142 ** +---------> READER-------+ |
145 ** |<-------WRITER_LOCKED------> ERROR
148 ** |<------WRITER_CACHEMOD-------->|
151 ** |<-------WRITER_DBMOD---------->|
154 ** +<------WRITER_FINISHED-------->+
157 ** List of state transitions and the C [function] that performs each:
159 ** OPEN -> READER [sqlite3PagerSharedLock]
160 ** READER -> OPEN [pager_unlock]
162 ** READER -> WRITER_LOCKED [sqlite3PagerBegin]
163 ** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
164 ** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
165 ** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
166 ** WRITER_*** -> READER [pager_end_transaction]
168 ** WRITER_*** -> ERROR [pager_error]
169 ** ERROR -> OPEN [pager_unlock]
174 ** The pager starts up in this state. Nothing is guaranteed in this
175 ** state - the file may or may not be locked and the database size is
176 ** unknown. The database may not be read or written.
178 ** * No read or write transaction is active.
179 ** * Any lock, or no lock at all, may be held on the database file.
180 ** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
184 ** In this state all the requirements for reading the database in
185 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
186 ** was) in exclusive-locking mode, a user-level read transaction is
187 ** open. The database size is known in this state.
189 ** A connection running with locking_mode=normal enters this state when
190 ** it opens a read-transaction on the database and returns to state
191 ** OPEN after the read-transaction is completed. However a connection
192 ** running in locking_mode=exclusive (including temp databases) remains in
193 ** this state even after the read-transaction is closed. The only way
194 ** a locking_mode=exclusive connection can transition from READER to OPEN
195 ** is via the ERROR state (see below).
197 ** * A read transaction may be active (but a write-transaction cannot).
198 ** * A SHARED or greater lock is held on the database file.
199 ** * The dbSize variable may be trusted (even if a user-level read
200 ** transaction is not active). The dbOrigSize and dbFileSize variables
201 ** may not be trusted at this point.
202 ** * If the database is a WAL database, then the WAL connection is open.
203 ** * Even if a read-transaction is not open, it is guaranteed that
204 ** there is no hot-journal in the file-system.
208 ** The pager moves to this state from READER when a write-transaction
209 ** is first opened on the database. In WRITER_LOCKED state, all locks
210 ** required to start a write-transaction are held, but no actual
211 ** modifications to the cache or database have taken place.
213 ** In rollback mode, a RESERVED or (if the transaction was opened with
214 ** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when
215 ** moving to this state, but the journal file is not written to or opened
216 ** to in this state. If the transaction is committed or rolled back while
217 ** in WRITER_LOCKED state, all that is required is to unlock the database
220 ** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
221 ** If the connection is running with locking_mode=exclusive, an attempt
222 ** is made to obtain an EXCLUSIVE lock on the database file.
224 ** * A write transaction is active.
225 ** * If the connection is open in rollback-mode, a RESERVED or greater
226 ** lock is held on the database file.
227 ** * If the connection is open in WAL-mode, a WAL write transaction
228 ** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully
230 ** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
231 ** * The contents of the pager cache have not been modified.
232 ** * The journal file may or may not be open.
233 ** * Nothing (not even the first header) has been written to the journal.
237 ** A pager moves from WRITER_LOCKED state to this state when a page is
238 ** first modified by the upper layer. In rollback mode the journal file
239 ** is opened (if it is not already open) and a header written to the
240 ** start of it. The database file on disk has not been modified.
242 ** * A write transaction is active.
243 ** * A RESERVED or greater lock is held on the database file.
244 ** * The journal file is open and the first header has been written
245 ** to it, but the header has not been synced to disk.
246 ** * The contents of the page cache have been modified.
250 ** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
251 ** when it modifies the contents of the database file. WAL connections
252 ** never enter this state (since they do not modify the database file,
253 ** just the log file).
255 ** * A write transaction is active.
256 ** * An EXCLUSIVE or greater lock is held on the database file.
257 ** * The journal file is open and the first header has been written
258 ** and synced to disk.
259 ** * The contents of the page cache have been modified (and possibly
264 ** It is not possible for a WAL connection to enter this state.
266 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
267 ** state after the entire transaction has been successfully written into the
268 ** database file. In this state the transaction may be committed simply
269 ** by finalizing the journal file. Once in WRITER_FINISHED state, it is
270 ** not possible to modify the database further. At this point, the upper
271 ** layer must either commit or rollback the transaction.
273 ** * A write transaction is active.
274 ** * An EXCLUSIVE or greater lock is held on the database file.
275 ** * All writing and syncing of journal and database data has finished.
276 ** If no error occurred, all that remains is to finalize the journal to
277 ** commit the transaction. If an error did occur, the caller will need
278 ** to rollback the transaction.
282 ** The ERROR state is entered when an IO or disk-full error (including
283 ** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it
284 ** difficult to be sure that the in-memory pager state (cache contents,
285 ** db size etc.) are consistent with the contents of the file-system.
287 ** Temporary pager files may enter the ERROR state, but in-memory pagers
290 ** For example, if an IO error occurs while performing a rollback,
291 ** the contents of the page-cache may be left in an inconsistent state.
292 ** At this point it would be dangerous to change back to READER state
293 ** (as usually happens after a rollback). Any subsequent readers might
294 ** report database corruption (due to the inconsistent cache), and if
295 ** they upgrade to writers, they may inadvertently corrupt the database
296 ** file. To avoid this hazard, the pager switches into the ERROR state
297 ** instead of READER following such an error.
299 ** Once it has entered the ERROR state, any attempt to use the pager
300 ** to read or write data returns an error. Eventually, once all
301 ** outstanding transactions have been abandoned, the pager is able to
302 ** transition back to OPEN state, discarding the contents of the
303 ** page-cache and any other in-memory state at the same time. Everything
304 ** is reloaded from disk (and, if necessary, hot-journal rollback peformed)
305 ** when a read-transaction is next opened on the pager (transitioning
306 ** the pager into READER state). At that point the system has recovered
309 ** Specifically, the pager jumps into the ERROR state if:
311 ** 1. An error occurs while attempting a rollback. This happens in
312 ** function sqlite3PagerRollback().
314 ** 2. An error occurs while attempting to finalize a journal file
315 ** following a commit in function sqlite3PagerCommitPhaseTwo().
317 ** 3. An error occurs while attempting to write to the journal or
318 ** database file in function pagerStress() in order to free up
321 ** In other cases, the error is returned to the b-tree layer. The b-tree
322 ** layer then attempts a rollback operation. If the error condition
323 ** persists, the pager enters the ERROR state via condition (1) above.
325 ** Condition (3) is necessary because it can be triggered by a read-only
326 ** statement executed within a transaction. In this case, if the error
327 ** code were simply returned to the user, the b-tree layer would not
328 ** automatically attempt a rollback, as it assumes that an error in a
329 ** read-only statement cannot leave the pager in an internally inconsistent
332 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
333 ** * There are one or more outstanding references to pages (after the
334 ** last reference is dropped the pager should move back to OPEN state).
335 ** * The pager is not an in-memory pager.
340 ** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the
341 ** connection is open in WAL mode. A WAL connection is always in one
342 ** of the first four states.
344 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
345 ** state. There are two exceptions: immediately after exclusive-mode has
346 ** been turned on (and before any read or write transactions are
347 ** executed), and when the pager is leaving the "error state".
349 ** * See also: assert_pager_state().
352 #define PAGER_READER 1
353 #define PAGER_WRITER_LOCKED 2
354 #define PAGER_WRITER_CACHEMOD 3
355 #define PAGER_WRITER_DBMOD 4
356 #define PAGER_WRITER_FINISHED 5
357 #define PAGER_ERROR 6
360 ** The Pager.eLock variable is almost always set to one of the
361 ** following locking-states, according to the lock currently held on
362 ** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
363 ** This variable is kept up to date as locks are taken and released by
364 ** the pagerLockDb() and pagerUnlockDb() wrappers.
366 ** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY
367 ** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
368 ** the operation was successful. In these circumstances pagerLockDb() and
369 ** pagerUnlockDb() take a conservative approach - eLock is always updated
370 ** when unlocking the file, and only updated when locking the file if the
371 ** VFS call is successful. This way, the Pager.eLock variable may be set
372 ** to a less exclusive (lower) value than the lock that is actually held
373 ** at the system level, but it is never set to a more exclusive value.
375 ** This is usually safe. If an xUnlock fails or appears to fail, there may
376 ** be a few redundant xLock() calls or a lock may be held for longer than
377 ** required, but nothing really goes wrong.
379 ** The exception is when the database file is unlocked as the pager moves
380 ** from ERROR to OPEN state. At this point there may be a hot-journal file
381 ** in the file-system that needs to be rolled back (as part of an OPEN->SHARED
382 ** transition, by the same pager or any other). If the call to xUnlock()
383 ** fails at this point and the pager is left holding an EXCLUSIVE lock, this
384 ** can confuse the call to xCheckReservedLock() call made later as part
385 ** of hot-journal detection.
387 ** xCheckReservedLock() is defined as returning true "if there is a RESERVED
388 ** lock held by this process or any others". So xCheckReservedLock may
389 ** return true because the caller itself is holding an EXCLUSIVE lock (but
390 ** doesn't know it because of a previous error in xUnlock). If this happens
391 ** a hot-journal may be mistaken for a journal being created by an active
392 ** transaction in another process, causing SQLite to read from the database
393 ** without rolling it back.
395 ** To work around this, if a call to xUnlock() fails when unlocking the
396 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
397 ** is only changed back to a real locking state after a successful call
398 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
399 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
400 ** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
401 ** lock on the database file before attempting to roll it back. See function
402 ** PagerSharedLock() for more detail.
404 ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
407 #define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)
410 ** A macro used for invoking the codec if there is one
412 #ifdef SQLITE_HAS_CODEC
413 # define CODEC1(P,D,N,X,E) \
414 if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
415 # define CODEC2(P,D,N,X,E,O) \
416 if( P->xCodec==0 ){ O=(char*)D; }else \
417 if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
419 # define CODEC1(P,D,N,X,E) /* NO-OP */
420 # define CODEC2(P,D,N,X,E,O) O=(char*)D
424 ** The maximum allowed sector size. 64KiB. If the xSectorsize() method
425 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
426 ** This could conceivably cause corruption following a power failure on
427 ** such a system. This is currently an undocumented limit.
429 #define MAX_SECTOR_SIZE 0x10000
433 ** An instance of the following structure is allocated for each active
434 ** savepoint and statement transaction in the system. All such structures
435 ** are stored in the Pager.aSavepoint[] array, which is allocated and
436 ** resized using sqlite3Realloc().
438 ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
439 ** set to 0. If a journal-header is written into the main journal while
440 ** the savepoint is active, then iHdrOffset is set to the byte offset
441 ** immediately following the last journal record written into the main
442 ** journal before the journal-header. This is required during savepoint
443 ** rollback (see pagerPlaybackSavepoint()).
445 typedef struct PagerSavepoint PagerSavepoint
;
446 struct PagerSavepoint
{
447 i64 iOffset
; /* Starting offset in main journal */
448 i64 iHdrOffset
; /* See above */
449 Bitvec
*pInSavepoint
; /* Set of pages in this savepoint */
450 Pgno nOrig
; /* Original number of pages in file */
451 Pgno iSubRec
; /* Index of first record in sub-journal */
452 #ifndef SQLITE_OMIT_WAL
453 u32 aWalData
[WAL_SAVEPOINT_NDATA
]; /* WAL savepoint context */
458 ** Bits of the Pager.doNotSpill flag. See further description below.
460 #define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */
461 #define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */
462 #define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */
465 ** An open page cache is an instance of struct Pager. A description of
466 ** some of the more important member variables follows:
470 ** The current 'state' of the pager object. See the comment and state
471 ** diagram above for a description of the pager state.
475 ** For a real on-disk database, the current lock held on the database file -
476 ** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
478 ** For a temporary or in-memory database (neither of which require any
479 ** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
480 ** databases always have Pager.exclusiveMode==1, this tricks the pager
481 ** logic into thinking that it already has all the locks it will ever
482 ** need (and no reason to release them).
484 ** In some (obscure) circumstances, this variable may also be set to
485 ** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
490 ** This boolean variable is used to make sure that the change-counter
491 ** (the 4-byte header field at byte offset 24 of the database file) is
492 ** not updated more often than necessary.
494 ** It is set to true when the change-counter field is updated, which
495 ** can only happen if an exclusive lock is held on the database file.
496 ** It is cleared (set to false) whenever an exclusive lock is
497 ** relinquished on the database file. Each time a transaction is committed,
498 ** The changeCountDone flag is inspected. If it is true, the work of
499 ** updating the change-counter is omitted for the current transaction.
501 ** This mechanism means that when running in exclusive mode, a connection
502 ** need only update the change-counter once, for the first transaction
507 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
508 ** (or may not) specify a master-journal name to be written into the
509 ** journal file before it is synced to disk.
511 ** Whether or not a journal file contains a master-journal pointer affects
512 ** the way in which the journal file is finalized after the transaction is
513 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
514 ** If a journal file does not contain a master-journal pointer, it is
515 ** finalized by overwriting the first journal header with zeroes. If
516 ** it does contain a master-journal pointer the journal file is finalized
517 ** by truncating it to zero bytes, just as if the connection were
518 ** running in "journal_mode=truncate" mode.
520 ** Journal files that contain master journal pointers cannot be finalized
521 ** simply by overwriting the first journal-header with zeroes, as the
522 ** master journal pointer could interfere with hot-journal rollback of any
523 ** subsequently interrupted transaction that reuses the journal file.
525 ** The flag is cleared as soon as the journal file is finalized (either
526 ** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
527 ** journal file from being successfully finalized, the setMaster flag
528 ** is cleared anyway (and the pager will move to ERROR state).
532 ** This variables control the behavior of cache-spills (calls made by
533 ** the pcache module to the pagerStress() routine to write cached data
534 ** to the file-system in order to free up memory).
536 ** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
537 ** writing to the database from pagerStress() is disabled altogether.
538 ** The SPILLFLAG_ROLLBACK case is done in a very obscure case that
539 ** comes up during savepoint rollback that requires the pcache module
540 ** to allocate a new page to prevent the journal file from being written
541 ** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
542 ** case is a user preference.
544 ** If the SPILLFLAG_NOSYNC bit is set, writing to the database from
545 ** pagerStress() is permitted, but syncing the journal file is not.
546 ** This flag is set by sqlite3PagerWrite() when the file-system sector-size
547 ** is larger than the database page-size in order to prevent a journal sync
548 ** from happening in between the journalling of two pages on the same sector.
552 ** This is a boolean variable. If true, then any required sub-journal
553 ** is opened as an in-memory journal file. If false, then in-memory
554 ** sub-journals are only used for in-memory pager files.
556 ** This variable is updated by the upper layer each time a new
557 ** write-transaction is opened.
559 ** dbSize, dbOrigSize, dbFileSize
561 ** Variable dbSize is set to the number of pages in the database file.
562 ** It is valid in PAGER_READER and higher states (all states except for
565 ** dbSize is set based on the size of the database file, which may be
566 ** larger than the size of the database (the value stored at offset
567 ** 28 of the database header by the btree). If the size of the file
568 ** is not an integer multiple of the page-size, the value stored in
569 ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
570 ** Except, any file that is greater than 0 bytes in size is considered
571 ** to have at least one page. (i.e. a 1KB file with 2K page-size leads
574 ** During a write-transaction, if pages with page-numbers greater than
575 ** dbSize are modified in the cache, dbSize is updated accordingly.
576 ** Similarly, if the database is truncated using PagerTruncateImage(),
577 ** dbSize is updated.
579 ** Variables dbOrigSize and dbFileSize are valid in states
580 ** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
581 ** variable at the start of the transaction. It is used during rollback,
582 ** and to determine whether or not pages need to be journalled before
585 ** Throughout a write-transaction, dbFileSize contains the size of
586 ** the file on disk in pages. It is set to a copy of dbSize when the
587 ** write-transaction is first opened, and updated when VFS calls are made
588 ** to write or truncate the database file on disk.
590 ** The only reason the dbFileSize variable is required is to suppress
591 ** unnecessary calls to xTruncate() after committing a transaction. If,
592 ** when a transaction is committed, the dbFileSize variable indicates
593 ** that the database file is larger than the database image (Pager.dbSize),
594 ** pager_truncate() is called. The pager_truncate() call uses xFilesize()
595 ** to measure the database file on disk, and then truncates it if required.
596 ** dbFileSize is not used when rolling back a transaction. In this case
597 ** pager_truncate() is called unconditionally (which means there may be
598 ** a call to xFilesize() that is not strictly required). In either case,
599 ** pager_truncate() may cause the file to become smaller or larger.
603 ** The dbHintSize variable is used to limit the number of calls made to
604 ** the VFS xFileControl(FCNTL_SIZE_HINT) method.
606 ** dbHintSize is set to a copy of the dbSize variable when a
607 ** write-transaction is opened (at the same time as dbFileSize and
608 ** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
609 ** dbHintSize is increased to the number of pages that correspond to the
610 ** size-hint passed to the method call. See pager_write_pagelist() for
615 ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
616 ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
617 ** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
620 ** syncFlags, walSyncFlags
622 ** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03).
623 ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
624 ** and contains the flags used to sync the checkpoint operations in the
625 ** lower two bits, and sync flags used for transaction commits in the WAL
626 ** file in bits 0x04 and 0x08. In other words, to get the correct sync flags
627 ** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct
628 ** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note
629 ** that with synchronous=NORMAL in WAL mode, transaction commit is not synced
630 ** meaning that the 0x04 and 0x08 bits are both zero.
633 sqlite3_vfs
*pVfs
; /* OS functions to use for IO */
634 u8 exclusiveMode
; /* Boolean. True if locking_mode==EXCLUSIVE */
635 u8 journalMode
; /* One of the PAGER_JOURNALMODE_* values */
636 u8 useJournal
; /* Use a rollback journal on this file */
637 u8 noSync
; /* Do not sync the journal if true */
638 u8 fullSync
; /* Do extra syncs of the journal for robustness */
639 u8 extraSync
; /* sync directory after journal delete */
640 u8 syncFlags
; /* SYNC_NORMAL or SYNC_FULL otherwise */
641 u8 walSyncFlags
; /* See description above */
642 u8 tempFile
; /* zFilename is a temporary or immutable file */
643 u8 noLock
; /* Do not lock (except in WAL mode) */
644 u8 readOnly
; /* True for a read-only database */
645 u8 memDb
; /* True to inhibit all file I/O */
647 /**************************************************************************
648 ** The following block contains those class members that change during
649 ** routine operation. Class members not in this block are either fixed
650 ** when the pager is first created or else only change when there is a
651 ** significant mode change (such as changing the page_size, locking_mode,
652 ** or the journal_mode). From another view, these class members describe
653 ** the "state" of the pager, while other class members describe the
654 ** "configuration" of the pager.
656 u8 eState
; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
657 u8 eLock
; /* Current lock held on database file */
658 u8 changeCountDone
; /* Set after incrementing the change-counter */
659 u8 setMaster
; /* True if a m-j name has been written to jrnl */
660 u8 doNotSpill
; /* Do not spill the cache when non-zero */
661 u8 subjInMemory
; /* True to use in-memory sub-journals */
662 u8 bUseFetch
; /* True to use xFetch() */
663 u8 hasHeldSharedLock
; /* True if a shared lock has ever been held */
664 Pgno dbSize
; /* Number of pages in the database */
665 Pgno dbOrigSize
; /* dbSize before the current transaction */
666 Pgno dbFileSize
; /* Number of pages in the database file */
667 Pgno dbHintSize
; /* Value passed to FCNTL_SIZE_HINT call */
668 int errCode
; /* One of several kinds of errors */
669 int nRec
; /* Pages journalled since last j-header written */
670 u32 cksumInit
; /* Quasi-random value added to every checksum */
671 u32 nSubRec
; /* Number of records written to sub-journal */
672 Bitvec
*pInJournal
; /* One bit for each page in the database file */
673 sqlite3_file
*fd
; /* File descriptor for database */
674 sqlite3_file
*jfd
; /* File descriptor for main journal */
675 sqlite3_file
*sjfd
; /* File descriptor for sub-journal */
676 i64 journalOff
; /* Current write offset in the journal file */
677 i64 journalHdr
; /* Byte offset to previous journal header */
678 sqlite3_backup
*pBackup
; /* Pointer to list of ongoing backup processes */
679 PagerSavepoint
*aSavepoint
; /* Array of active savepoints */
680 int nSavepoint
; /* Number of elements in aSavepoint[] */
681 u32 iDataVersion
; /* Changes whenever database content changes */
682 char dbFileVers
[16]; /* Changes whenever database file changes */
684 int nMmapOut
; /* Number of mmap pages currently outstanding */
685 sqlite3_int64 szMmap
; /* Desired maximum mmap size */
686 PgHdr
*pMmapFreelist
; /* List of free mmap page headers (pDirty) */
688 ** End of the routinely-changing class members
689 ***************************************************************************/
691 u16 nExtra
; /* Add this many bytes to each in-memory page */
692 i16 nReserve
; /* Number of unused bytes at end of each page */
693 u32 vfsFlags
; /* Flags for sqlite3_vfs.xOpen() */
694 u32 sectorSize
; /* Assumed sector size during rollback */
695 int pageSize
; /* Number of bytes in a page */
696 Pgno mxPgno
; /* Maximum allowed size of the database */
697 i64 journalSizeLimit
; /* Size limit for persistent journal files */
698 char *zFilename
; /* Name of the database file */
699 char *zJournal
; /* Name of the journal file */
700 int (*xBusyHandler
)(void*); /* Function to call when busy */
701 void *pBusyHandlerArg
; /* Context argument for xBusyHandler */
702 int aStat
[3]; /* Total cache hits, misses and writes */
704 int nRead
; /* Database pages read */
706 void (*xReiniter
)(DbPage
*); /* Call this routine when reloading pages */
707 int (*xGet
)(Pager
*,Pgno
,DbPage
**,int); /* Routine to fetch a patch */
708 #ifdef SQLITE_HAS_CODEC
709 void *(*xCodec
)(void*,void*,Pgno
,int); /* Routine for en/decoding data */
710 void (*xCodecSizeChng
)(void*,int,int); /* Notify of page size changes */
711 void (*xCodecFree
)(void*); /* Destructor for the codec */
712 void *pCodec
; /* First argument to xCodec... methods */
714 char *pTmpSpace
; /* Pager.pageSize bytes of space for tmp use */
715 PCache
*pPCache
; /* Pointer to page cache object */
716 #ifndef SQLITE_OMIT_WAL
717 Wal
*pWal
; /* Write-ahead log used by "journal_mode=wal" */
718 char *zWal
; /* File name for write-ahead log */
723 ** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains
724 ** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS
725 ** or CACHE_WRITE to sqlite3_db_status().
727 #define PAGER_STAT_HIT 0
728 #define PAGER_STAT_MISS 1
729 #define PAGER_STAT_WRITE 2
732 ** The following global variables hold counters used for
733 ** testing purposes only. These variables do not exist in
734 ** a non-testing build. These variables are not thread-safe.
737 int sqlite3_pager_readdb_count
= 0; /* Number of full pages read from DB */
738 int sqlite3_pager_writedb_count
= 0; /* Number of full pages written to DB */
739 int sqlite3_pager_writej_count
= 0; /* Number of pages written to journal */
740 # define PAGER_INCR(v) v++
742 # define PAGER_INCR(v)
748 ** Journal files begin with the following magic string. The data
749 ** was obtained from /dev/random. It is used only as a sanity check.
751 ** Since version 2.8.0, the journal format contains additional sanity
752 ** checking information. If the power fails while the journal is being
753 ** written, semi-random garbage data might appear in the journal
754 ** file after power is restored. If an attempt is then made
755 ** to roll the journal back, the database could be corrupted. The additional
756 ** sanity checking data is an attempt to discover the garbage in the
757 ** journal and ignore it.
759 ** The sanity checking information for the new journal format consists
760 ** of a 32-bit checksum on each page of data. The checksum covers both
761 ** the page number and the pPager->pageSize bytes of data for the page.
762 ** This cksum is initialized to a 32-bit random value that appears in the
763 ** journal file right after the header. The random initializer is important,
764 ** because garbage data that appears at the end of a journal is likely
765 ** data that was once in other files that have now been deleted. If the
766 ** garbage data came from an obsolete journal file, the checksums might
767 ** be correct. But by initializing the checksum to random value which
768 ** is different for every journal, we minimize that risk.
770 static const unsigned char aJournalMagic
[] = {
771 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
775 ** The size of the of each page record in the journal is given by
776 ** the following macro.
778 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
781 ** The journal header size for this pager. This is usually the same
782 ** size as a single disk sector. See also setSectorSize().
784 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
787 ** The macro MEMDB is true if we are dealing with an in-memory database.
788 ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
789 ** the value of MEMDB will be a constant and the compiler will optimize
790 ** out code that would never execute.
792 #ifdef SQLITE_OMIT_MEMORYDB
795 # define MEMDB pPager->memDb
799 ** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
800 ** interfaces to access the database using memory-mapped I/O.
802 #if SQLITE_MAX_MMAP_SIZE>0
803 # define USEFETCH(x) ((x)->bUseFetch)
805 # define USEFETCH(x) 0
809 ** The maximum legal page number is (2^31 - 1).
811 #define PAGER_MAX_PGNO 2147483647
814 ** The argument to this macro is a file descriptor (type sqlite3_file*).
815 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
817 ** This is so that expressions can be written as:
819 ** if( isOpen(pPager->jfd) ){ ...
823 ** if( pPager->jfd->pMethods ){ ...
825 #define isOpen(pFd) ((pFd)->pMethods!=0)
828 ** Return true if this pager uses a write-ahead log to read page pgno.
829 ** Return false if the pager reads pgno directly from the database.
831 #if !defined(SQLITE_OMIT_WAL) && defined(SQLITE_DIRECT_OVERFLOW_READ)
832 int sqlite3PagerUseWal(Pager
*pPager
, Pgno pgno
){
835 if( pPager
->pWal
==0 ) return 0;
836 rc
= sqlite3WalFindFrame(pPager
->pWal
, pgno
, &iRead
);
840 #ifndef SQLITE_OMIT_WAL
841 # define pagerUseWal(x) ((x)->pWal!=0)
843 # define pagerUseWal(x) 0
844 # define pagerRollbackWal(x) 0
845 # define pagerWalFrames(v,w,x,y) 0
846 # define pagerOpenWalIfPresent(z) SQLITE_OK
847 # define pagerBeginReadTransaction(z) SQLITE_OK
854 ** assert( assert_pager_state(pPager) );
856 ** This function runs many asserts to try to find inconsistencies in
857 ** the internal state of the Pager object.
859 static int assert_pager_state(Pager
*p
){
862 /* State must be valid. */
863 assert( p
->eState
==PAGER_OPEN
864 || p
->eState
==PAGER_READER
865 || p
->eState
==PAGER_WRITER_LOCKED
866 || p
->eState
==PAGER_WRITER_CACHEMOD
867 || p
->eState
==PAGER_WRITER_DBMOD
868 || p
->eState
==PAGER_WRITER_FINISHED
869 || p
->eState
==PAGER_ERROR
872 /* Regardless of the current state, a temp-file connection always behaves
873 ** as if it has an exclusive lock on the database file. It never updates
874 ** the change-counter field, so the changeCountDone flag is always set.
876 assert( p
->tempFile
==0 || p
->eLock
==EXCLUSIVE_LOCK
);
877 assert( p
->tempFile
==0 || pPager
->changeCountDone
);
879 /* If the useJournal flag is clear, the journal-mode must be "OFF".
880 ** And if the journal-mode is "OFF", the journal file must not be open.
882 assert( p
->journalMode
==PAGER_JOURNALMODE_OFF
|| p
->useJournal
);
883 assert( p
->journalMode
!=PAGER_JOURNALMODE_OFF
|| !isOpen(p
->jfd
) );
885 /* Check that MEMDB implies noSync. And an in-memory journal. Since
886 ** this means an in-memory pager performs no IO at all, it cannot encounter
887 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
888 ** a journal file. (although the in-memory journal implementation may
889 ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
890 ** is therefore not possible for an in-memory pager to enter the ERROR
894 assert( !isOpen(p
->fd
) );
896 assert( p
->journalMode
==PAGER_JOURNALMODE_OFF
897 || p
->journalMode
==PAGER_JOURNALMODE_MEMORY
899 assert( p
->eState
!=PAGER_ERROR
&& p
->eState
!=PAGER_OPEN
);
900 assert( pagerUseWal(p
)==0 );
903 /* If changeCountDone is set, a RESERVED lock or greater must be held
906 assert( pPager
->changeCountDone
==0 || pPager
->eLock
>=RESERVED_LOCK
);
907 assert( p
->eLock
!=PENDING_LOCK
);
912 assert( pPager
->errCode
==SQLITE_OK
);
913 assert( sqlite3PcacheRefCount(pPager
->pPCache
)==0 || pPager
->tempFile
);
917 assert( pPager
->errCode
==SQLITE_OK
);
918 assert( p
->eLock
!=UNKNOWN_LOCK
);
919 assert( p
->eLock
>=SHARED_LOCK
);
922 case PAGER_WRITER_LOCKED
:
923 assert( p
->eLock
!=UNKNOWN_LOCK
);
924 assert( pPager
->errCode
==SQLITE_OK
);
925 if( !pagerUseWal(pPager
) ){
926 assert( p
->eLock
>=RESERVED_LOCK
);
928 assert( pPager
->dbSize
==pPager
->dbOrigSize
);
929 assert( pPager
->dbOrigSize
==pPager
->dbFileSize
);
930 assert( pPager
->dbOrigSize
==pPager
->dbHintSize
);
931 assert( pPager
->setMaster
==0 );
934 case PAGER_WRITER_CACHEMOD
:
935 assert( p
->eLock
!=UNKNOWN_LOCK
);
936 assert( pPager
->errCode
==SQLITE_OK
);
937 if( !pagerUseWal(pPager
) ){
938 /* It is possible that if journal_mode=wal here that neither the
939 ** journal file nor the WAL file are open. This happens during
940 ** a rollback transaction that switches from journal_mode=off
941 ** to journal_mode=wal.
943 assert( p
->eLock
>=RESERVED_LOCK
);
944 assert( isOpen(p
->jfd
)
945 || p
->journalMode
==PAGER_JOURNALMODE_OFF
946 || p
->journalMode
==PAGER_JOURNALMODE_WAL
949 assert( pPager
->dbOrigSize
==pPager
->dbFileSize
);
950 assert( pPager
->dbOrigSize
==pPager
->dbHintSize
);
953 case PAGER_WRITER_DBMOD
:
954 assert( p
->eLock
==EXCLUSIVE_LOCK
);
955 assert( pPager
->errCode
==SQLITE_OK
);
956 assert( !pagerUseWal(pPager
) );
957 assert( p
->eLock
>=EXCLUSIVE_LOCK
);
958 assert( isOpen(p
->jfd
)
959 || p
->journalMode
==PAGER_JOURNALMODE_OFF
960 || p
->journalMode
==PAGER_JOURNALMODE_WAL
961 || (sqlite3OsDeviceCharacteristics(p
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
963 assert( pPager
->dbOrigSize
<=pPager
->dbHintSize
);
966 case PAGER_WRITER_FINISHED
:
967 assert( p
->eLock
==EXCLUSIVE_LOCK
);
968 assert( pPager
->errCode
==SQLITE_OK
);
969 assert( !pagerUseWal(pPager
) );
970 assert( isOpen(p
->jfd
)
971 || p
->journalMode
==PAGER_JOURNALMODE_OFF
972 || p
->journalMode
==PAGER_JOURNALMODE_WAL
973 || (sqlite3OsDeviceCharacteristics(p
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
978 /* There must be at least one outstanding reference to the pager if
979 ** in ERROR state. Otherwise the pager should have already dropped
980 ** back to OPEN state.
982 assert( pPager
->errCode
!=SQLITE_OK
);
983 assert( sqlite3PcacheRefCount(pPager
->pPCache
)>0 || pPager
->tempFile
);
989 #endif /* ifndef NDEBUG */
993 ** Return a pointer to a human readable string in a static buffer
994 ** containing the state of the Pager object passed as an argument. This
995 ** is intended to be used within debuggers. For example, as an alternative
996 ** to "print *pPager" in gdb:
998 ** (gdb) printf "%s", print_pager_state(pPager)
1000 static char *print_pager_state(Pager
*p
){
1001 static char zRet
[1024];
1003 sqlite3_snprintf(1024, zRet
,
1005 "State: %s errCode=%d\n"
1007 "Locking mode: locking_mode=%s\n"
1008 "Journal mode: journal_mode=%s\n"
1009 "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
1010 "Journal: journalOff=%lld journalHdr=%lld\n"
1011 "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
1013 , p
->eState
==PAGER_OPEN
? "OPEN" :
1014 p
->eState
==PAGER_READER
? "READER" :
1015 p
->eState
==PAGER_WRITER_LOCKED
? "WRITER_LOCKED" :
1016 p
->eState
==PAGER_WRITER_CACHEMOD
? "WRITER_CACHEMOD" :
1017 p
->eState
==PAGER_WRITER_DBMOD
? "WRITER_DBMOD" :
1018 p
->eState
==PAGER_WRITER_FINISHED
? "WRITER_FINISHED" :
1019 p
->eState
==PAGER_ERROR
? "ERROR" : "?error?"
1021 , p
->eLock
==NO_LOCK
? "NO_LOCK" :
1022 p
->eLock
==RESERVED_LOCK
? "RESERVED" :
1023 p
->eLock
==EXCLUSIVE_LOCK
? "EXCLUSIVE" :
1024 p
->eLock
==SHARED_LOCK
? "SHARED" :
1025 p
->eLock
==UNKNOWN_LOCK
? "UNKNOWN" : "?error?"
1026 , p
->exclusiveMode
? "exclusive" : "normal"
1027 , p
->journalMode
==PAGER_JOURNALMODE_MEMORY
? "memory" :
1028 p
->journalMode
==PAGER_JOURNALMODE_OFF
? "off" :
1029 p
->journalMode
==PAGER_JOURNALMODE_DELETE
? "delete" :
1030 p
->journalMode
==PAGER_JOURNALMODE_PERSIST
? "persist" :
1031 p
->journalMode
==PAGER_JOURNALMODE_TRUNCATE
? "truncate" :
1032 p
->journalMode
==PAGER_JOURNALMODE_WAL
? "wal" : "?error?"
1033 , (int)p
->tempFile
, (int)p
->memDb
, (int)p
->useJournal
1034 , p
->journalOff
, p
->journalHdr
1035 , (int)p
->dbSize
, (int)p
->dbOrigSize
, (int)p
->dbFileSize
1042 /* Forward references to the various page getters */
1043 static int getPageNormal(Pager
*,Pgno
,DbPage
**,int);
1044 static int getPageError(Pager
*,Pgno
,DbPage
**,int);
1045 #if SQLITE_MAX_MMAP_SIZE>0
1046 static int getPageMMap(Pager
*,Pgno
,DbPage
**,int);
1050 ** Set the Pager.xGet method for the appropriate routine used to fetch
1051 ** content from the pager.
1053 static void setGetterMethod(Pager
*pPager
){
1054 if( pPager
->errCode
){
1055 pPager
->xGet
= getPageError
;
1056 #if SQLITE_MAX_MMAP_SIZE>0
1057 }else if( USEFETCH(pPager
)
1058 #ifdef SQLITE_HAS_CODEC
1059 && pPager
->xCodec
==0
1062 pPager
->xGet
= getPageMMap
;
1063 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
1065 pPager
->xGet
= getPageNormal
;
1070 ** Return true if it is necessary to write page *pPg into the sub-journal.
1071 ** A page needs to be written into the sub-journal if there exists one
1072 ** or more open savepoints for which:
1074 ** * The page-number is less than or equal to PagerSavepoint.nOrig, and
1075 ** * The bit corresponding to the page-number is not set in
1076 ** PagerSavepoint.pInSavepoint.
1078 static int subjRequiresPage(PgHdr
*pPg
){
1079 Pager
*pPager
= pPg
->pPager
;
1081 Pgno pgno
= pPg
->pgno
;
1083 for(i
=0; i
<pPager
->nSavepoint
; i
++){
1084 p
= &pPager
->aSavepoint
[i
];
1085 if( p
->nOrig
>=pgno
&& 0==sqlite3BitvecTestNotNull(p
->pInSavepoint
, pgno
) ){
1094 ** Return true if the page is already in the journal file.
1096 static int pageInJournal(Pager
*pPager
, PgHdr
*pPg
){
1097 return sqlite3BitvecTest(pPager
->pInJournal
, pPg
->pgno
);
1102 ** Read a 32-bit integer from the given file descriptor. Store the integer
1103 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
1104 ** error code is something goes wrong.
1106 ** All values are stored on disk as big-endian.
1108 static int read32bits(sqlite3_file
*fd
, i64 offset
, u32
*pRes
){
1109 unsigned char ac
[4];
1110 int rc
= sqlite3OsRead(fd
, ac
, sizeof(ac
), offset
);
1111 if( rc
==SQLITE_OK
){
1112 *pRes
= sqlite3Get4byte(ac
);
1118 ** Write a 32-bit integer into a string buffer in big-endian byte order.
1120 #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
1124 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
1125 ** on success or an error code is something goes wrong.
1127 static int write32bits(sqlite3_file
*fd
, i64 offset
, u32 val
){
1130 return sqlite3OsWrite(fd
, ac
, 4, offset
);
1134 ** Unlock the database file to level eLock, which must be either NO_LOCK
1135 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
1136 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
1138 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1139 ** called, do not modify it. See the comment above the #define of
1140 ** UNKNOWN_LOCK for an explanation of this.
1142 static int pagerUnlockDb(Pager
*pPager
, int eLock
){
1145 assert( !pPager
->exclusiveMode
|| pPager
->eLock
==eLock
);
1146 assert( eLock
==NO_LOCK
|| eLock
==SHARED_LOCK
);
1147 assert( eLock
!=NO_LOCK
|| pagerUseWal(pPager
)==0 );
1148 if( isOpen(pPager
->fd
) ){
1149 assert( pPager
->eLock
>=eLock
);
1150 rc
= pPager
->noLock
? SQLITE_OK
: sqlite3OsUnlock(pPager
->fd
, eLock
);
1151 if( pPager
->eLock
!=UNKNOWN_LOCK
){
1152 pPager
->eLock
= (u8
)eLock
;
1154 IOTRACE(("UNLOCK %p %d\n", pPager
, eLock
))
1160 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
1161 ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
1162 ** Pager.eLock variable to the new locking state.
1164 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1165 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
1166 ** See the comment above the #define of UNKNOWN_LOCK for an explanation
1169 static int pagerLockDb(Pager
*pPager
, int eLock
){
1172 assert( eLock
==SHARED_LOCK
|| eLock
==RESERVED_LOCK
|| eLock
==EXCLUSIVE_LOCK
);
1173 if( pPager
->eLock
<eLock
|| pPager
->eLock
==UNKNOWN_LOCK
){
1174 rc
= pPager
->noLock
? SQLITE_OK
: sqlite3OsLock(pPager
->fd
, eLock
);
1175 if( rc
==SQLITE_OK
&& (pPager
->eLock
!=UNKNOWN_LOCK
||eLock
==EXCLUSIVE_LOCK
) ){
1176 pPager
->eLock
= (u8
)eLock
;
1177 IOTRACE(("LOCK %p %d\n", pPager
, eLock
))
1184 ** This function determines whether or not the atomic-write or
1185 ** atomic-batch-write optimizations can be used with this pager. The
1186 ** atomic-write optimization can be used if:
1188 ** (a) the value returned by OsDeviceCharacteristics() indicates that
1189 ** a database page may be written atomically, and
1190 ** (b) the value returned by OsSectorSize() is less than or equal
1191 ** to the page size.
1193 ** If it can be used, then the value returned is the size of the journal
1194 ** file when it contains rollback data for exactly one page.
1196 ** The atomic-batch-write optimization can be used if OsDeviceCharacteristics()
1197 ** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
1198 ** returned in this case.
1200 ** If neither optimization can be used, 0 is returned.
1202 static int jrnlBufferSize(Pager
*pPager
){
1205 #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
1206 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
1207 int dc
; /* Device characteristics */
1209 assert( isOpen(pPager
->fd
) );
1210 dc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
1212 UNUSED_PARAMETER(pPager
);
1215 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
1216 if( dc
&SQLITE_IOCAP_BATCH_ATOMIC
){
1221 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
1223 int nSector
= pPager
->sectorSize
;
1224 int szPage
= pPager
->pageSize
;
1226 assert(SQLITE_IOCAP_ATOMIC512
==(512>>8));
1227 assert(SQLITE_IOCAP_ATOMIC64K
==(65536>>8));
1228 if( 0==(dc
&(SQLITE_IOCAP_ATOMIC
|(szPage
>>8)) || nSector
>szPage
) ){
1233 return JOURNAL_HDR_SZ(pPager
) + JOURNAL_PG_SZ(pPager
);
1240 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
1241 ** on the cache using a hash function. This is used for testing
1242 ** and debugging only.
1244 #ifdef SQLITE_CHECK_PAGES
1246 ** Return a 32-bit hash of the page data for pPage.
1248 static u32
pager_datahash(int nByte
, unsigned char *pData
){
1251 for(i
=0; i
<nByte
; i
++){
1252 hash
= (hash
*1039) + pData
[i
];
1256 static u32
pager_pagehash(PgHdr
*pPage
){
1257 return pager_datahash(pPage
->pPager
->pageSize
, (unsigned char *)pPage
->pData
);
1259 static void pager_set_pagehash(PgHdr
*pPage
){
1260 pPage
->pageHash
= pager_pagehash(pPage
);
1264 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
1265 ** is defined, and NDEBUG is not defined, an assert() statement checks
1266 ** that the page is either dirty or still matches the calculated page-hash.
1268 #define CHECK_PAGE(x) checkPage(x)
1269 static void checkPage(PgHdr
*pPg
){
1270 Pager
*pPager
= pPg
->pPager
;
1271 assert( pPager
->eState
!=PAGER_ERROR
);
1272 assert( (pPg
->flags
&PGHDR_DIRTY
) || pPg
->pageHash
==pager_pagehash(pPg
) );
1276 #define pager_datahash(X,Y) 0
1277 #define pager_pagehash(X) 0
1278 #define pager_set_pagehash(X)
1279 #define CHECK_PAGE(x)
1280 #endif /* SQLITE_CHECK_PAGES */
1283 ** When this is called the journal file for pager pPager must be open.
1284 ** This function attempts to read a master journal file name from the
1285 ** end of the file and, if successful, copies it into memory supplied
1286 ** by the caller. See comments above writeMasterJournal() for the format
1287 ** used to store a master journal file name at the end of a journal file.
1289 ** zMaster must point to a buffer of at least nMaster bytes allocated by
1290 ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
1291 ** enough space to write the master journal name). If the master journal
1292 ** name in the journal is longer than nMaster bytes (including a
1293 ** nul-terminator), then this is handled as if no master journal name
1294 ** were present in the journal.
1296 ** If a master journal file name is present at the end of the journal
1297 ** file, then it is copied into the buffer pointed to by zMaster. A
1298 ** nul-terminator byte is appended to the buffer following the master
1299 ** journal file name.
1301 ** If it is determined that no master journal file name is present
1302 ** zMaster[0] is set to 0 and SQLITE_OK returned.
1304 ** If an error occurs while reading from the journal file, an SQLite
1305 ** error code is returned.
1307 static int readMasterJournal(sqlite3_file
*pJrnl
, char *zMaster
, u32 nMaster
){
1308 int rc
; /* Return code */
1309 u32 len
; /* Length in bytes of master journal name */
1310 i64 szJ
; /* Total size in bytes of journal file pJrnl */
1311 u32 cksum
; /* MJ checksum value read from journal */
1312 u32 u
; /* Unsigned loop counter */
1313 unsigned char aMagic
[8]; /* A buffer to hold the magic header */
1316 if( SQLITE_OK
!=(rc
= sqlite3OsFileSize(pJrnl
, &szJ
))
1318 || SQLITE_OK
!=(rc
= read32bits(pJrnl
, szJ
-16, &len
))
1322 || SQLITE_OK
!=(rc
= read32bits(pJrnl
, szJ
-12, &cksum
))
1323 || SQLITE_OK
!=(rc
= sqlite3OsRead(pJrnl
, aMagic
, 8, szJ
-8))
1324 || memcmp(aMagic
, aJournalMagic
, 8)
1325 || SQLITE_OK
!=(rc
= sqlite3OsRead(pJrnl
, zMaster
, len
, szJ
-16-len
))
1330 /* See if the checksum matches the master journal name */
1331 for(u
=0; u
<len
; u
++){
1332 cksum
-= zMaster
[u
];
1335 /* If the checksum doesn't add up, then one or more of the disk sectors
1336 ** containing the master journal filename is corrupted. This means
1337 ** definitely roll back, so just return SQLITE_OK and report a (nul)
1338 ** master-journal filename.
1342 zMaster
[len
] = '\0';
1348 ** Return the offset of the sector boundary at or immediately
1349 ** following the value in pPager->journalOff, assuming a sector
1350 ** size of pPager->sectorSize bytes.
1352 ** i.e for a sector size of 512:
1354 ** Pager.journalOff Return value
1355 ** ---------------------------------------
1362 static i64
journalHdrOffset(Pager
*pPager
){
1364 i64 c
= pPager
->journalOff
;
1366 offset
= ((c
-1)/JOURNAL_HDR_SZ(pPager
) + 1) * JOURNAL_HDR_SZ(pPager
);
1368 assert( offset
%JOURNAL_HDR_SZ(pPager
)==0 );
1369 assert( offset
>=c
);
1370 assert( (offset
-c
)<JOURNAL_HDR_SZ(pPager
) );
1375 ** The journal file must be open when this function is called.
1377 ** This function is a no-op if the journal file has not been written to
1378 ** within the current transaction (i.e. if Pager.journalOff==0).
1380 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
1381 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
1382 ** zero the 28-byte header at the start of the journal file. In either case,
1383 ** if the pager is not in no-sync mode, sync the journal file immediately
1384 ** after writing or truncating it.
1386 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
1387 ** following the truncation or zeroing described above the size of the
1388 ** journal file in bytes is larger than this value, then truncate the
1389 ** journal file to Pager.journalSizeLimit bytes. The journal file does
1390 ** not need to be synced following this operation.
1392 ** If an IO error occurs, abandon processing and return the IO error code.
1393 ** Otherwise, return SQLITE_OK.
1395 static int zeroJournalHdr(Pager
*pPager
, int doTruncate
){
1396 int rc
= SQLITE_OK
; /* Return code */
1397 assert( isOpen(pPager
->jfd
) );
1398 assert( !sqlite3JournalIsInMemory(pPager
->jfd
) );
1399 if( pPager
->journalOff
){
1400 const i64 iLimit
= pPager
->journalSizeLimit
; /* Local cache of jsl */
1402 IOTRACE(("JZEROHDR %p\n", pPager
))
1403 if( doTruncate
|| iLimit
==0 ){
1404 rc
= sqlite3OsTruncate(pPager
->jfd
, 0);
1406 static const char zeroHdr
[28] = {0};
1407 rc
= sqlite3OsWrite(pPager
->jfd
, zeroHdr
, sizeof(zeroHdr
), 0);
1409 if( rc
==SQLITE_OK
&& !pPager
->noSync
){
1410 rc
= sqlite3OsSync(pPager
->jfd
, SQLITE_SYNC_DATAONLY
|pPager
->syncFlags
);
1413 /* At this point the transaction is committed but the write lock
1414 ** is still held on the file. If there is a size limit configured for
1415 ** the persistent journal and the journal file currently consumes more
1416 ** space than that limit allows for, truncate it now. There is no need
1417 ** to sync the file following this operation.
1419 if( rc
==SQLITE_OK
&& iLimit
>0 ){
1421 rc
= sqlite3OsFileSize(pPager
->jfd
, &sz
);
1422 if( rc
==SQLITE_OK
&& sz
>iLimit
){
1423 rc
= sqlite3OsTruncate(pPager
->jfd
, iLimit
);
1431 ** The journal file must be open when this routine is called. A journal
1432 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
1433 ** current location.
1435 ** The format for the journal header is as follows:
1436 ** - 8 bytes: Magic identifying journal format.
1437 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
1438 ** - 4 bytes: Random number used for page hash.
1439 ** - 4 bytes: Initial database page count.
1440 ** - 4 bytes: Sector size used by the process that wrote this journal.
1441 ** - 4 bytes: Database page size.
1443 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
1445 static int writeJournalHdr(Pager
*pPager
){
1446 int rc
= SQLITE_OK
; /* Return code */
1447 char *zHeader
= pPager
->pTmpSpace
; /* Temporary space used to build header */
1448 u32 nHeader
= (u32
)pPager
->pageSize
;/* Size of buffer pointed to by zHeader */
1449 u32 nWrite
; /* Bytes of header sector written */
1450 int ii
; /* Loop counter */
1452 assert( isOpen(pPager
->jfd
) ); /* Journal file must be open. */
1454 if( nHeader
>JOURNAL_HDR_SZ(pPager
) ){
1455 nHeader
= JOURNAL_HDR_SZ(pPager
);
1458 /* If there are active savepoints and any of them were created
1459 ** since the most recent journal header was written, update the
1460 ** PagerSavepoint.iHdrOffset fields now.
1462 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1463 if( pPager
->aSavepoint
[ii
].iHdrOffset
==0 ){
1464 pPager
->aSavepoint
[ii
].iHdrOffset
= pPager
->journalOff
;
1468 pPager
->journalHdr
= pPager
->journalOff
= journalHdrOffset(pPager
);
1471 ** Write the nRec Field - the number of page records that follow this
1472 ** journal header. Normally, zero is written to this value at this time.
1473 ** After the records are added to the journal (and the journal synced,
1474 ** if in full-sync mode), the zero is overwritten with the true number
1475 ** of records (see syncJournal()).
1477 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
1478 ** reading the journal this value tells SQLite to assume that the
1479 ** rest of the journal file contains valid page records. This assumption
1480 ** is dangerous, as if a failure occurred whilst writing to the journal
1481 ** file it may contain some garbage data. There are two scenarios
1482 ** where this risk can be ignored:
1484 ** * When the pager is in no-sync mode. Corruption can follow a
1485 ** power failure in this case anyway.
1487 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1488 ** that garbage data is never appended to the journal file.
1490 assert( isOpen(pPager
->fd
) || pPager
->noSync
);
1491 if( pPager
->noSync
|| (pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
)
1492 || (sqlite3OsDeviceCharacteristics(pPager
->fd
)&SQLITE_IOCAP_SAFE_APPEND
)
1494 memcpy(zHeader
, aJournalMagic
, sizeof(aJournalMagic
));
1495 put32bits(&zHeader
[sizeof(aJournalMagic
)], 0xffffffff);
1497 memset(zHeader
, 0, sizeof(aJournalMagic
)+4);
1500 /* The random check-hash initializer */
1501 sqlite3_randomness(sizeof(pPager
->cksumInit
), &pPager
->cksumInit
);
1502 put32bits(&zHeader
[sizeof(aJournalMagic
)+4], pPager
->cksumInit
);
1503 /* The initial database size */
1504 put32bits(&zHeader
[sizeof(aJournalMagic
)+8], pPager
->dbOrigSize
);
1505 /* The assumed sector size for this process */
1506 put32bits(&zHeader
[sizeof(aJournalMagic
)+12], pPager
->sectorSize
);
1509 put32bits(&zHeader
[sizeof(aJournalMagic
)+16], pPager
->pageSize
);
1511 /* Initializing the tail of the buffer is not necessary. Everything
1512 ** works find if the following memset() is omitted. But initializing
1513 ** the memory prevents valgrind from complaining, so we are willing to
1514 ** take the performance hit.
1516 memset(&zHeader
[sizeof(aJournalMagic
)+20], 0,
1517 nHeader
-(sizeof(aJournalMagic
)+20));
1519 /* In theory, it is only necessary to write the 28 bytes that the
1520 ** journal header consumes to the journal file here. Then increment the
1521 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
1522 ** record is written to the following sector (leaving a gap in the file
1523 ** that will be implicitly filled in by the OS).
1525 ** However it has been discovered that on some systems this pattern can
1526 ** be significantly slower than contiguously writing data to the file,
1527 ** even if that means explicitly writing data to the block of
1528 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
1531 ** The loop is required here in case the sector-size is larger than the
1532 ** database page size. Since the zHeader buffer is only Pager.pageSize
1533 ** bytes in size, more than one call to sqlite3OsWrite() may be required
1534 ** to populate the entire journal header sector.
1536 for(nWrite
=0; rc
==SQLITE_OK
&&nWrite
<JOURNAL_HDR_SZ(pPager
); nWrite
+=nHeader
){
1537 IOTRACE(("JHDR %p %lld %d\n", pPager
, pPager
->journalHdr
, nHeader
))
1538 rc
= sqlite3OsWrite(pPager
->jfd
, zHeader
, nHeader
, pPager
->journalOff
);
1539 assert( pPager
->journalHdr
<= pPager
->journalOff
);
1540 pPager
->journalOff
+= nHeader
;
1547 ** The journal file must be open when this is called. A journal header file
1548 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
1549 ** file. The current location in the journal file is given by
1550 ** pPager->journalOff. See comments above function writeJournalHdr() for
1551 ** a description of the journal header format.
1553 ** If the header is read successfully, *pNRec is set to the number of
1554 ** page records following this header and *pDbSize is set to the size of the
1555 ** database before the transaction began, in pages. Also, pPager->cksumInit
1556 ** is set to the value read from the journal header. SQLITE_OK is returned
1559 ** If the journal header file appears to be corrupted, SQLITE_DONE is
1560 ** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
1561 ** cannot be read from the journal file an error code is returned.
1563 static int readJournalHdr(
1564 Pager
*pPager
, /* Pager object */
1566 i64 journalSize
, /* Size of the open journal file in bytes */
1567 u32
*pNRec
, /* OUT: Value read from the nRec field */
1568 u32
*pDbSize
/* OUT: Value of original database size field */
1570 int rc
; /* Return code */
1571 unsigned char aMagic
[8]; /* A buffer to hold the magic header */
1572 i64 iHdrOff
; /* Offset of journal header being read */
1574 assert( isOpen(pPager
->jfd
) ); /* Journal file must be open. */
1576 /* Advance Pager.journalOff to the start of the next sector. If the
1577 ** journal file is too small for there to be a header stored at this
1578 ** point, return SQLITE_DONE.
1580 pPager
->journalOff
= journalHdrOffset(pPager
);
1581 if( pPager
->journalOff
+JOURNAL_HDR_SZ(pPager
) > journalSize
){
1584 iHdrOff
= pPager
->journalOff
;
1586 /* Read in the first 8 bytes of the journal header. If they do not match
1587 ** the magic string found at the start of each journal header, return
1588 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
1591 if( isHot
|| iHdrOff
!=pPager
->journalHdr
){
1592 rc
= sqlite3OsRead(pPager
->jfd
, aMagic
, sizeof(aMagic
), iHdrOff
);
1596 if( memcmp(aMagic
, aJournalMagic
, sizeof(aMagic
))!=0 ){
1601 /* Read the first three 32-bit fields of the journal header: The nRec
1602 ** field, the checksum-initializer and the database size at the start
1603 ** of the transaction. Return an error code if anything goes wrong.
1605 if( SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+8, pNRec
))
1606 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+12, &pPager
->cksumInit
))
1607 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+16, pDbSize
))
1612 if( pPager
->journalOff
==0 ){
1613 u32 iPageSize
; /* Page-size field of journal header */
1614 u32 iSectorSize
; /* Sector-size field of journal header */
1616 /* Read the page-size and sector-size journal header fields. */
1617 if( SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+20, &iSectorSize
))
1618 || SQLITE_OK
!=(rc
= read32bits(pPager
->jfd
, iHdrOff
+24, &iPageSize
))
1623 /* Versions of SQLite prior to 3.5.8 set the page-size field of the
1624 ** journal header to zero. In this case, assume that the Pager.pageSize
1625 ** variable is already set to the correct page size.
1628 iPageSize
= pPager
->pageSize
;
1631 /* Check that the values read from the page-size and sector-size fields
1632 ** are within range. To be 'in range', both values need to be a power
1633 ** of two greater than or equal to 512 or 32, and not greater than their
1634 ** respective compile time maximum limits.
1636 if( iPageSize
<512 || iSectorSize
<32
1637 || iPageSize
>SQLITE_MAX_PAGE_SIZE
|| iSectorSize
>MAX_SECTOR_SIZE
1638 || ((iPageSize
-1)&iPageSize
)!=0 || ((iSectorSize
-1)&iSectorSize
)!=0
1640 /* If the either the page-size or sector-size in the journal-header is
1641 ** invalid, then the process that wrote the journal-header must have
1642 ** crashed before the header was synced. In this case stop reading
1643 ** the journal file here.
1648 /* Update the page-size to match the value read from the journal.
1649 ** Use a testcase() macro to make sure that malloc failure within
1650 ** PagerSetPagesize() is tested.
1652 rc
= sqlite3PagerSetPagesize(pPager
, &iPageSize
, -1);
1653 testcase( rc
!=SQLITE_OK
);
1655 /* Update the assumed sector-size to match the value used by
1656 ** the process that created this journal. If this journal was
1657 ** created by a process other than this one, then this routine
1658 ** is being called from within pager_playback(). The local value
1659 ** of Pager.sectorSize is restored at the end of that routine.
1661 pPager
->sectorSize
= iSectorSize
;
1664 pPager
->journalOff
+= JOURNAL_HDR_SZ(pPager
);
1670 ** Write the supplied master journal name into the journal file for pager
1671 ** pPager at the current location. The master journal name must be the last
1672 ** thing written to a journal file. If the pager is in full-sync mode, the
1673 ** journal file descriptor is advanced to the next sector boundary before
1674 ** anything is written. The format is:
1676 ** + 4 bytes: PAGER_MJ_PGNO.
1677 ** + N bytes: Master journal filename in utf-8.
1678 ** + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
1679 ** + 4 bytes: Master journal name checksum.
1680 ** + 8 bytes: aJournalMagic[].
1682 ** The master journal page checksum is the sum of the bytes in the master
1683 ** journal name, where each byte is interpreted as a signed 8-bit integer.
1685 ** If zMaster is a NULL pointer (occurs for a single database transaction),
1686 ** this call is a no-op.
1688 static int writeMasterJournal(Pager
*pPager
, const char *zMaster
){
1689 int rc
; /* Return code */
1690 int nMaster
; /* Length of string zMaster */
1691 i64 iHdrOff
; /* Offset of header in journal file */
1692 i64 jrnlSize
; /* Size of journal file on disk */
1693 u32 cksum
= 0; /* Checksum of string zMaster */
1695 assert( pPager
->setMaster
==0 );
1696 assert( !pagerUseWal(pPager
) );
1699 || pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
1700 || !isOpen(pPager
->jfd
)
1704 pPager
->setMaster
= 1;
1705 assert( pPager
->journalHdr
<= pPager
->journalOff
);
1707 /* Calculate the length in bytes and the checksum of zMaster */
1708 for(nMaster
=0; zMaster
[nMaster
]; nMaster
++){
1709 cksum
+= zMaster
[nMaster
];
1712 /* If in full-sync mode, advance to the next disk sector before writing
1713 ** the master journal name. This is in case the previous page written to
1714 ** the journal has already been synced.
1716 if( pPager
->fullSync
){
1717 pPager
->journalOff
= journalHdrOffset(pPager
);
1719 iHdrOff
= pPager
->journalOff
;
1721 /* Write the master journal data to the end of the journal file. If
1722 ** an error occurs, return the error code to the caller.
1724 if( (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
, PAGER_MJ_PGNO(pPager
))))
1725 || (0 != (rc
= sqlite3OsWrite(pPager
->jfd
, zMaster
, nMaster
, iHdrOff
+4)))
1726 || (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
+4+nMaster
, nMaster
)))
1727 || (0 != (rc
= write32bits(pPager
->jfd
, iHdrOff
+4+nMaster
+4, cksum
)))
1728 || (0 != (rc
= sqlite3OsWrite(pPager
->jfd
, aJournalMagic
, 8,
1729 iHdrOff
+4+nMaster
+8)))
1733 pPager
->journalOff
+= (nMaster
+20);
1735 /* If the pager is in peristent-journal mode, then the physical
1736 ** journal-file may extend past the end of the master-journal name
1737 ** and 8 bytes of magic data just written to the file. This is
1738 ** dangerous because the code to rollback a hot-journal file
1739 ** will not be able to find the master-journal name to determine
1740 ** whether or not the journal is hot.
1742 ** Easiest thing to do in this scenario is to truncate the journal
1743 ** file to the required size.
1745 if( SQLITE_OK
==(rc
= sqlite3OsFileSize(pPager
->jfd
, &jrnlSize
))
1746 && jrnlSize
>pPager
->journalOff
1748 rc
= sqlite3OsTruncate(pPager
->jfd
, pPager
->journalOff
);
1754 ** Discard the entire contents of the in-memory page-cache.
1756 static void pager_reset(Pager
*pPager
){
1757 pPager
->iDataVersion
++;
1758 sqlite3BackupRestart(pPager
->pBackup
);
1759 sqlite3PcacheClear(pPager
->pPCache
);
1763 ** Return the pPager->iDataVersion value
1765 u32
sqlite3PagerDataVersion(Pager
*pPager
){
1766 assert( pPager
->eState
>PAGER_OPEN
);
1767 return pPager
->iDataVersion
;
1771 ** Free all structures in the Pager.aSavepoint[] array and set both
1772 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1773 ** if it is open and the pager is not in exclusive mode.
1775 static void releaseAllSavepoints(Pager
*pPager
){
1776 int ii
; /* Iterator for looping through Pager.aSavepoint */
1777 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1778 sqlite3BitvecDestroy(pPager
->aSavepoint
[ii
].pInSavepoint
);
1780 if( !pPager
->exclusiveMode
|| sqlite3JournalIsInMemory(pPager
->sjfd
) ){
1781 sqlite3OsClose(pPager
->sjfd
);
1783 sqlite3_free(pPager
->aSavepoint
);
1784 pPager
->aSavepoint
= 0;
1785 pPager
->nSavepoint
= 0;
1786 pPager
->nSubRec
= 0;
1790 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1791 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
1792 ** or SQLITE_NOMEM if a malloc failure occurs.
1794 static int addToSavepointBitvecs(Pager
*pPager
, Pgno pgno
){
1795 int ii
; /* Loop counter */
1796 int rc
= SQLITE_OK
; /* Result code */
1798 for(ii
=0; ii
<pPager
->nSavepoint
; ii
++){
1799 PagerSavepoint
*p
= &pPager
->aSavepoint
[ii
];
1800 if( pgno
<=p
->nOrig
){
1801 rc
|= sqlite3BitvecSet(p
->pInSavepoint
, pgno
);
1802 testcase( rc
==SQLITE_NOMEM
);
1803 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
1810 ** This function is a no-op if the pager is in exclusive mode and not
1811 ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
1814 ** If the pager is not in exclusive-access mode, the database file is
1815 ** completely unlocked. If the file is unlocked and the file-system does
1816 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
1817 ** closed (if it is open).
1819 ** If the pager is in ERROR state when this function is called, the
1820 ** contents of the pager cache are discarded before switching back to
1821 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
1822 ** or not, any journal file left in the file-system will be treated
1823 ** as a hot-journal and rolled back the next time a read-transaction
1824 ** is opened (by this or by any other connection).
1826 static void pager_unlock(Pager
*pPager
){
1828 assert( pPager
->eState
==PAGER_READER
1829 || pPager
->eState
==PAGER_OPEN
1830 || pPager
->eState
==PAGER_ERROR
1833 sqlite3BitvecDestroy(pPager
->pInJournal
);
1834 pPager
->pInJournal
= 0;
1835 releaseAllSavepoints(pPager
);
1837 if( pagerUseWal(pPager
) ){
1838 assert( !isOpen(pPager
->jfd
) );
1839 sqlite3WalEndReadTransaction(pPager
->pWal
);
1840 pPager
->eState
= PAGER_OPEN
;
1841 }else if( !pPager
->exclusiveMode
){
1842 int rc
; /* Error code returned by pagerUnlockDb() */
1843 int iDc
= isOpen(pPager
->fd
)?sqlite3OsDeviceCharacteristics(pPager
->fd
):0;
1845 /* If the operating system support deletion of open files, then
1846 ** close the journal file when dropping the database lock. Otherwise
1847 ** another connection with journal_mode=delete might delete the file
1848 ** out from under us.
1850 assert( (PAGER_JOURNALMODE_MEMORY
& 5)!=1 );
1851 assert( (PAGER_JOURNALMODE_OFF
& 5)!=1 );
1852 assert( (PAGER_JOURNALMODE_WAL
& 5)!=1 );
1853 assert( (PAGER_JOURNALMODE_DELETE
& 5)!=1 );
1854 assert( (PAGER_JOURNALMODE_TRUNCATE
& 5)==1 );
1855 assert( (PAGER_JOURNALMODE_PERSIST
& 5)==1 );
1856 if( 0==(iDc
& SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
)
1857 || 1!=(pPager
->journalMode
& 5)
1859 sqlite3OsClose(pPager
->jfd
);
1862 /* If the pager is in the ERROR state and the call to unlock the database
1863 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
1864 ** above the #define for UNKNOWN_LOCK for an explanation of why this
1867 rc
= pagerUnlockDb(pPager
, NO_LOCK
);
1868 if( rc
!=SQLITE_OK
&& pPager
->eState
==PAGER_ERROR
){
1869 pPager
->eLock
= UNKNOWN_LOCK
;
1872 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
1873 ** without clearing the error code. This is intentional - the error
1874 ** code is cleared and the cache reset in the block below.
1876 assert( pPager
->errCode
|| pPager
->eState
!=PAGER_ERROR
);
1877 pPager
->changeCountDone
= 0;
1878 pPager
->eState
= PAGER_OPEN
;
1881 /* If Pager.errCode is set, the contents of the pager cache cannot be
1882 ** trusted. Now that there are no outstanding references to the pager,
1883 ** it can safely move back to PAGER_OPEN state. This happens in both
1884 ** normal and exclusive-locking mode.
1886 assert( pPager
->errCode
==SQLITE_OK
|| !MEMDB
);
1887 if( pPager
->errCode
){
1888 if( pPager
->tempFile
==0 ){
1889 pager_reset(pPager
);
1890 pPager
->changeCountDone
= 0;
1891 pPager
->eState
= PAGER_OPEN
;
1893 pPager
->eState
= (isOpen(pPager
->jfd
) ? PAGER_OPEN
: PAGER_READER
);
1895 if( USEFETCH(pPager
) ) sqlite3OsUnfetch(pPager
->fd
, 0, 0);
1896 pPager
->errCode
= SQLITE_OK
;
1897 setGetterMethod(pPager
);
1900 pPager
->journalOff
= 0;
1901 pPager
->journalHdr
= 0;
1902 pPager
->setMaster
= 0;
1906 ** This function is called whenever an IOERR or FULL error that requires
1907 ** the pager to transition into the ERROR state may ahve occurred.
1908 ** The first argument is a pointer to the pager structure, the second
1909 ** the error-code about to be returned by a pager API function. The
1910 ** value returned is a copy of the second argument to this function.
1912 ** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
1913 ** IOERR sub-codes, the pager enters the ERROR state and the error code
1914 ** is stored in Pager.errCode. While the pager remains in the ERROR state,
1915 ** all major API calls on the Pager will immediately return Pager.errCode.
1917 ** The ERROR state indicates that the contents of the pager-cache
1918 ** cannot be trusted. This state can be cleared by completely discarding
1919 ** the contents of the pager-cache. If a transaction was active when
1920 ** the persistent error occurred, then the rollback journal may need
1921 ** to be replayed to restore the contents of the database file (as if
1922 ** it were a hot-journal).
1924 static int pager_error(Pager
*pPager
, int rc
){
1925 int rc2
= rc
& 0xff;
1926 assert( rc
==SQLITE_OK
|| !MEMDB
);
1928 pPager
->errCode
==SQLITE_FULL
||
1929 pPager
->errCode
==SQLITE_OK
||
1930 (pPager
->errCode
& 0xff)==SQLITE_IOERR
1932 if( rc2
==SQLITE_FULL
|| rc2
==SQLITE_IOERR
){
1933 pPager
->errCode
= rc
;
1934 pPager
->eState
= PAGER_ERROR
;
1935 setGetterMethod(pPager
);
1940 static int pager_truncate(Pager
*pPager
, Pgno nPage
);
1943 ** The write transaction open on pPager is being committed (bCommit==1)
1944 ** or rolled back (bCommit==0).
1946 ** Return TRUE if and only if all dirty pages should be flushed to disk.
1950 ** * For non-TEMP databases, always sync to disk. This is necessary
1951 ** for transactions to be durable.
1953 ** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing
1954 ** file has been created already (via a spill on pagerStress()) and
1955 ** when the number of dirty pages in memory exceeds 25% of the total
1958 static int pagerFlushOnCommit(Pager
*pPager
, int bCommit
){
1959 if( pPager
->tempFile
==0 ) return 1;
1960 if( !bCommit
) return 0;
1961 if( !isOpen(pPager
->fd
) ) return 0;
1962 return (sqlite3PCachePercentDirty(pPager
->pPCache
)>=25);
1966 ** This routine ends a transaction. A transaction is usually ended by
1967 ** either a COMMIT or a ROLLBACK operation. This routine may be called
1968 ** after rollback of a hot-journal, or if an error occurs while opening
1969 ** the journal file or writing the very first journal-header of a
1970 ** database transaction.
1972 ** This routine is never called in PAGER_ERROR state. If it is called
1973 ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
1974 ** exclusive than a RESERVED lock, it is a no-op.
1976 ** Otherwise, any active savepoints are released.
1978 ** If the journal file is open, then it is "finalized". Once a journal
1979 ** file has been finalized it is not possible to use it to roll back a
1980 ** transaction. Nor will it be considered to be a hot-journal by this
1981 ** or any other database connection. Exactly how a journal is finalized
1982 ** depends on whether or not the pager is running in exclusive mode and
1983 ** the current journal-mode (Pager.journalMode value), as follows:
1985 ** journalMode==MEMORY
1986 ** Journal file descriptor is simply closed. This destroys an
1987 ** in-memory journal.
1989 ** journalMode==TRUNCATE
1990 ** Journal file is truncated to zero bytes in size.
1992 ** journalMode==PERSIST
1993 ** The first 28 bytes of the journal file are zeroed. This invalidates
1994 ** the first journal header in the file, and hence the entire journal
1995 ** file. An invalid journal file cannot be rolled back.
1997 ** journalMode==DELETE
1998 ** The journal file is closed and deleted using sqlite3OsDelete().
2000 ** If the pager is running in exclusive mode, this method of finalizing
2001 ** the journal file is never used. Instead, if the journalMode is
2002 ** DELETE and the pager is in exclusive mode, the method described under
2003 ** journalMode==PERSIST is used instead.
2005 ** After the journal is finalized, the pager moves to PAGER_READER state.
2006 ** If running in non-exclusive rollback mode, the lock on the file is
2007 ** downgraded to a SHARED_LOCK.
2009 ** SQLITE_OK is returned if no error occurs. If an error occurs during
2010 ** any of the IO operations to finalize the journal file or unlock the
2011 ** database then the IO error code is returned to the user. If the
2012 ** operation to finalize the journal file fails, then the code still
2013 ** tries to unlock the database file if not in exclusive mode. If the
2014 ** unlock operation fails as well, then the first error code related
2015 ** to the first error encountered (the journal finalization one) is
2018 static int pager_end_transaction(Pager
*pPager
, int hasMaster
, int bCommit
){
2019 int rc
= SQLITE_OK
; /* Error code from journal finalization operation */
2020 int rc2
= SQLITE_OK
; /* Error code from db file unlock operation */
2022 /* Do nothing if the pager does not have an open write transaction
2023 ** or at least a RESERVED lock. This function may be called when there
2024 ** is no write-transaction active but a RESERVED or greater lock is
2025 ** held under two circumstances:
2027 ** 1. After a successful hot-journal rollback, it is called with
2028 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
2030 ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
2031 ** lock switches back to locking_mode=normal and then executes a
2032 ** read-transaction, this function is called with eState==PAGER_READER
2033 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
2035 assert( assert_pager_state(pPager
) );
2036 assert( pPager
->eState
!=PAGER_ERROR
);
2037 if( pPager
->eState
<PAGER_WRITER_LOCKED
&& pPager
->eLock
<RESERVED_LOCK
){
2041 releaseAllSavepoints(pPager
);
2042 assert( isOpen(pPager
->jfd
) || pPager
->pInJournal
==0
2043 || (sqlite3OsDeviceCharacteristics(pPager
->fd
)&SQLITE_IOCAP_BATCH_ATOMIC
)
2045 if( isOpen(pPager
->jfd
) ){
2046 assert( !pagerUseWal(pPager
) );
2048 /* Finalize the journal file. */
2049 if( sqlite3JournalIsInMemory(pPager
->jfd
) ){
2050 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
2051 sqlite3OsClose(pPager
->jfd
);
2052 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_TRUNCATE
){
2053 if( pPager
->journalOff
==0 ){
2056 rc
= sqlite3OsTruncate(pPager
->jfd
, 0);
2057 if( rc
==SQLITE_OK
&& pPager
->fullSync
){
2058 /* Make sure the new file size is written into the inode right away.
2059 ** Otherwise the journal might resurrect following a power loss and
2060 ** cause the last transaction to roll back. See
2061 ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
2063 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
);
2066 pPager
->journalOff
= 0;
2067 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_PERSIST
2068 || (pPager
->exclusiveMode
&& pPager
->journalMode
!=PAGER_JOURNALMODE_WAL
)
2070 rc
= zeroJournalHdr(pPager
, hasMaster
||pPager
->tempFile
);
2071 pPager
->journalOff
= 0;
2073 /* This branch may be executed with Pager.journalMode==MEMORY if
2074 ** a hot-journal was just rolled back. In this case the journal
2075 ** file should be closed and deleted. If this connection writes to
2076 ** the database file, it will do so using an in-memory journal.
2078 int bDelete
= !pPager
->tempFile
;
2079 assert( sqlite3JournalIsInMemory(pPager
->jfd
)==0 );
2080 assert( pPager
->journalMode
==PAGER_JOURNALMODE_DELETE
2081 || pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
2082 || pPager
->journalMode
==PAGER_JOURNALMODE_WAL
2084 sqlite3OsClose(pPager
->jfd
);
2086 rc
= sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, pPager
->extraSync
);
2091 #ifdef SQLITE_CHECK_PAGES
2092 sqlite3PcacheIterateDirty(pPager
->pPCache
, pager_set_pagehash
);
2093 if( pPager
->dbSize
==0 && sqlite3PcacheRefCount(pPager
->pPCache
)>0 ){
2094 PgHdr
*p
= sqlite3PagerLookup(pPager
, 1);
2097 sqlite3PagerUnrefNotNull(p
);
2102 sqlite3BitvecDestroy(pPager
->pInJournal
);
2103 pPager
->pInJournal
= 0;
2105 if( rc
==SQLITE_OK
){
2106 if( MEMDB
|| pagerFlushOnCommit(pPager
, bCommit
) ){
2107 sqlite3PcacheCleanAll(pPager
->pPCache
);
2109 sqlite3PcacheClearWritable(pPager
->pPCache
);
2111 sqlite3PcacheTruncate(pPager
->pPCache
, pPager
->dbSize
);
2114 if( pagerUseWal(pPager
) ){
2115 /* Drop the WAL write-lock, if any. Also, if the connection was in
2116 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
2117 ** lock held on the database file.
2119 rc2
= sqlite3WalEndWriteTransaction(pPager
->pWal
);
2120 assert( rc2
==SQLITE_OK
);
2121 }else if( rc
==SQLITE_OK
&& bCommit
&& pPager
->dbFileSize
>pPager
->dbSize
){
2122 /* This branch is taken when committing a transaction in rollback-journal
2123 ** mode if the database file on disk is larger than the database image.
2124 ** At this point the journal has been finalized and the transaction
2125 ** successfully committed, but the EXCLUSIVE lock is still held on the
2126 ** file. So it is safe to truncate the database file to its minimum
2127 ** required size. */
2128 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
2129 rc
= pager_truncate(pPager
, pPager
->dbSize
);
2132 if( rc
==SQLITE_OK
&& bCommit
&& isOpen(pPager
->fd
) ){
2133 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_COMMIT_PHASETWO
, 0);
2134 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
2137 if( !pPager
->exclusiveMode
2138 && (!pagerUseWal(pPager
) || sqlite3WalExclusiveMode(pPager
->pWal
, 0))
2140 rc2
= pagerUnlockDb(pPager
, SHARED_LOCK
);
2141 pPager
->changeCountDone
= 0;
2143 pPager
->eState
= PAGER_READER
;
2144 pPager
->setMaster
= 0;
2146 return (rc
==SQLITE_OK
?rc2
:rc
);
2150 ** Execute a rollback if a transaction is active and unlock the
2153 ** If the pager has already entered the ERROR state, do not attempt
2154 ** the rollback at this time. Instead, pager_unlock() is called. The
2155 ** call to pager_unlock() will discard all in-memory pages, unlock
2156 ** the database file and move the pager back to OPEN state. If this
2157 ** means that there is a hot-journal left in the file-system, the next
2158 ** connection to obtain a shared lock on the pager (which may be this one)
2159 ** will roll it back.
2161 ** If the pager has not already entered the ERROR state, but an IO or
2162 ** malloc error occurs during a rollback, then this will itself cause
2163 ** the pager to enter the ERROR state. Which will be cleared by the
2164 ** call to pager_unlock(), as described above.
2166 static void pagerUnlockAndRollback(Pager
*pPager
){
2167 if( pPager
->eState
!=PAGER_ERROR
&& pPager
->eState
!=PAGER_OPEN
){
2168 assert( assert_pager_state(pPager
) );
2169 if( pPager
->eState
>=PAGER_WRITER_LOCKED
){
2170 sqlite3BeginBenignMalloc();
2171 sqlite3PagerRollback(pPager
);
2172 sqlite3EndBenignMalloc();
2173 }else if( !pPager
->exclusiveMode
){
2174 assert( pPager
->eState
==PAGER_READER
);
2175 pager_end_transaction(pPager
, 0, 0);
2178 pager_unlock(pPager
);
2182 ** Parameter aData must point to a buffer of pPager->pageSize bytes
2183 ** of data. Compute and return a checksum based ont the contents of the
2184 ** page of data and the current value of pPager->cksumInit.
2186 ** This is not a real checksum. It is really just the sum of the
2187 ** random initial value (pPager->cksumInit) and every 200th byte
2188 ** of the page data, starting with byte offset (pPager->pageSize%200).
2189 ** Each byte is interpreted as an 8-bit unsigned integer.
2191 ** Changing the formula used to compute this checksum results in an
2192 ** incompatible journal file format.
2194 ** If journal corruption occurs due to a power failure, the most likely
2195 ** scenario is that one end or the other of the record will be changed.
2196 ** It is much less likely that the two ends of the journal record will be
2197 ** correct and the middle be corrupt. Thus, this "checksum" scheme,
2198 ** though fast and simple, catches the mostly likely kind of corruption.
2200 static u32
pager_cksum(Pager
*pPager
, const u8
*aData
){
2201 u32 cksum
= pPager
->cksumInit
; /* Checksum value to return */
2202 int i
= pPager
->pageSize
-200; /* Loop counter */
2211 ** Report the current page size and number of reserved bytes back
2214 #ifdef SQLITE_HAS_CODEC
2215 static void pagerReportSize(Pager
*pPager
){
2216 if( pPager
->xCodecSizeChng
){
2217 pPager
->xCodecSizeChng(pPager
->pCodec
, pPager
->pageSize
,
2218 (int)pPager
->nReserve
);
2222 # define pagerReportSize(X) /* No-op if we do not support a codec */
2225 #ifdef SQLITE_HAS_CODEC
2227 ** Make sure the number of reserved bits is the same in the destination
2228 ** pager as it is in the source. This comes up when a VACUUM changes the
2229 ** number of reserved bits to the "optimal" amount.
2231 void sqlite3PagerAlignReserve(Pager
*pDest
, Pager
*pSrc
){
2232 if( pDest
->nReserve
!=pSrc
->nReserve
){
2233 pDest
->nReserve
= pSrc
->nReserve
;
2234 pagerReportSize(pDest
);
2240 ** Read a single page from either the journal file (if isMainJrnl==1) or
2241 ** from the sub-journal (if isMainJrnl==0) and playback that page.
2242 ** The page begins at offset *pOffset into the file. The *pOffset
2243 ** value is increased to the start of the next page in the journal.
2245 ** The main rollback journal uses checksums - the statement journal does
2248 ** If the page number of the page record read from the (sub-)journal file
2249 ** is greater than the current value of Pager.dbSize, then playback is
2250 ** skipped and SQLITE_OK is returned.
2252 ** If pDone is not NULL, then it is a record of pages that have already
2253 ** been played back. If the page at *pOffset has already been played back
2254 ** (if the corresponding pDone bit is set) then skip the playback.
2255 ** Make sure the pDone bit corresponding to the *pOffset page is set
2256 ** prior to returning.
2258 ** If the page record is successfully read from the (sub-)journal file
2259 ** and played back, then SQLITE_OK is returned. If an IO error occurs
2260 ** while reading the record from the (sub-)journal file or while writing
2261 ** to the database file, then the IO error code is returned. If data
2262 ** is successfully read from the (sub-)journal file but appears to be
2263 ** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
2264 ** two circumstances:
2266 ** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
2267 ** * If the record is being rolled back from the main journal file
2268 ** and the checksum field does not match the record content.
2270 ** Neither of these two scenarios are possible during a savepoint rollback.
2272 ** If this is a savepoint rollback, then memory may have to be dynamically
2273 ** allocated by this function. If this is the case and an allocation fails,
2274 ** SQLITE_NOMEM is returned.
2276 static int pager_playback_one_page(
2277 Pager
*pPager
, /* The pager being played back */
2278 i64
*pOffset
, /* Offset of record to playback */
2279 Bitvec
*pDone
, /* Bitvec of pages already played back */
2280 int isMainJrnl
, /* 1 -> main journal. 0 -> sub-journal. */
2281 int isSavepnt
/* True for a savepoint rollback */
2284 PgHdr
*pPg
; /* An existing page in the cache */
2285 Pgno pgno
; /* The page number of a page in journal */
2286 u32 cksum
; /* Checksum used for sanity checking */
2287 char *aData
; /* Temporary storage for the page */
2288 sqlite3_file
*jfd
; /* The file descriptor for the journal file */
2289 int isSynced
; /* True if journal page is synced */
2290 #ifdef SQLITE_HAS_CODEC
2291 /* The jrnlEnc flag is true if Journal pages should be passed through
2292 ** the codec. It is false for pure in-memory journals. */
2293 const int jrnlEnc
= (isMainJrnl
|| pPager
->subjInMemory
==0);
2296 assert( (isMainJrnl
&~1)==0 ); /* isMainJrnl is 0 or 1 */
2297 assert( (isSavepnt
&~1)==0 ); /* isSavepnt is 0 or 1 */
2298 assert( isMainJrnl
|| pDone
); /* pDone always used on sub-journals */
2299 assert( isSavepnt
|| pDone
==0 ); /* pDone never used on non-savepoint */
2301 aData
= pPager
->pTmpSpace
;
2302 assert( aData
); /* Temp storage must have already been allocated */
2303 assert( pagerUseWal(pPager
)==0 || (!isMainJrnl
&& isSavepnt
) );
2305 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
2306 ** or savepoint rollback done at the request of the caller) or this is
2307 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
2308 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
2309 ** only reads from the main journal, not the sub-journal.
2311 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
2312 || (pPager
->eState
==PAGER_OPEN
&& pPager
->eLock
==EXCLUSIVE_LOCK
)
2314 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
|| isMainJrnl
);
2316 /* Read the page number and page data from the journal or sub-journal
2317 ** file. Return an error code to the caller if an IO error occurs.
2319 jfd
= isMainJrnl
? pPager
->jfd
: pPager
->sjfd
;
2320 rc
= read32bits(jfd
, *pOffset
, &pgno
);
2321 if( rc
!=SQLITE_OK
) return rc
;
2322 rc
= sqlite3OsRead(jfd
, (u8
*)aData
, pPager
->pageSize
, (*pOffset
)+4);
2323 if( rc
!=SQLITE_OK
) return rc
;
2324 *pOffset
+= pPager
->pageSize
+ 4 + isMainJrnl
*4;
2326 /* Sanity checking on the page. This is more important that I originally
2327 ** thought. If a power failure occurs while the journal is being written,
2328 ** it could cause invalid data to be written into the journal. We need to
2329 ** detect this invalid data (with high probability) and ignore it.
2331 if( pgno
==0 || pgno
==PAGER_MJ_PGNO(pPager
) ){
2332 assert( !isSavepnt
);
2335 if( pgno
>(Pgno
)pPager
->dbSize
|| sqlite3BitvecTest(pDone
, pgno
) ){
2339 rc
= read32bits(jfd
, (*pOffset
)-4, &cksum
);
2341 if( !isSavepnt
&& pager_cksum(pPager
, (u8
*)aData
)!=cksum
){
2346 /* If this page has already been played back before during the current
2347 ** rollback, then don't bother to play it back again.
2349 if( pDone
&& (rc
= sqlite3BitvecSet(pDone
, pgno
))!=SQLITE_OK
){
2353 /* When playing back page 1, restore the nReserve setting
2355 if( pgno
==1 && pPager
->nReserve
!=((u8
*)aData
)[20] ){
2356 pPager
->nReserve
= ((u8
*)aData
)[20];
2357 pagerReportSize(pPager
);
2360 /* If the pager is in CACHEMOD state, then there must be a copy of this
2361 ** page in the pager cache. In this case just update the pager cache,
2362 ** not the database file. The page is left marked dirty in this case.
2364 ** An exception to the above rule: If the database is in no-sync mode
2365 ** and a page is moved during an incremental vacuum then the page may
2366 ** not be in the pager cache. Later: if a malloc() or IO error occurs
2367 ** during a Movepage() call, then the page may not be in the cache
2368 ** either. So the condition described in the above paragraph is not
2371 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
2372 ** pager cache if it exists and the main file. The page is then marked
2373 ** not dirty. Since this code is only executed in PAGER_OPEN state for
2374 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
2375 ** if the pager is in OPEN state.
2377 ** Ticket #1171: The statement journal might contain page content that is
2378 ** different from the page content at the start of the transaction.
2379 ** This occurs when a page is changed prior to the start of a statement
2380 ** then changed again within the statement. When rolling back such a
2381 ** statement we must not write to the original database unless we know
2382 ** for certain that original page contents are synced into the main rollback
2383 ** journal. Otherwise, a power loss might leave modified data in the
2384 ** database file without an entry in the rollback journal that can
2385 ** restore the database to its original form. Two conditions must be
2386 ** met before writing to the database files. (1) the database must be
2387 ** locked. (2) we know that the original page content is fully synced
2388 ** in the main journal either because the page is not in cache or else
2389 ** the page is marked as needSync==0.
2391 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
2392 ** is possible to fail a statement on a database that does not yet exist.
2393 ** Do not attempt to write if database file has never been opened.
2395 if( pagerUseWal(pPager
) ){
2398 pPg
= sqlite3PagerLookup(pPager
, pgno
);
2400 assert( pPg
|| !MEMDB
);
2401 assert( pPager
->eState
!=PAGER_OPEN
|| pPg
==0 || pPager
->tempFile
);
2402 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
2403 PAGERID(pPager
), pgno
, pager_datahash(pPager
->pageSize
, (u8
*)aData
),
2404 (isMainJrnl
?"main-journal":"sub-journal")
2407 isSynced
= pPager
->noSync
|| (*pOffset
<= pPager
->journalHdr
);
2409 isSynced
= (pPg
==0 || 0==(pPg
->flags
& PGHDR_NEED_SYNC
));
2411 if( isOpen(pPager
->fd
)
2412 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2415 i64 ofst
= (pgno
-1)*(i64
)pPager
->pageSize
;
2416 testcase( !isSavepnt
&& pPg
!=0 && (pPg
->flags
&PGHDR_NEED_SYNC
)!=0 );
2417 assert( !pagerUseWal(pPager
) );
2419 /* Write the data read from the journal back into the database file.
2420 ** This is usually safe even for an encrypted database - as the data
2421 ** was encrypted before it was written to the journal file. The exception
2422 ** is if the data was just read from an in-memory sub-journal. In that
2423 ** case it must be encrypted here before it is copied into the database
2425 #ifdef SQLITE_HAS_CODEC
2427 CODEC2(pPager
, aData
, pgno
, 7, rc
=SQLITE_NOMEM_BKPT
, aData
);
2428 rc
= sqlite3OsWrite(pPager
->fd
, (u8
*)aData
, pPager
->pageSize
, ofst
);
2429 CODEC1(pPager
, aData
, pgno
, 3, rc
=SQLITE_NOMEM_BKPT
);
2432 rc
= sqlite3OsWrite(pPager
->fd
, (u8
*)aData
, pPager
->pageSize
, ofst
);
2434 if( pgno
>pPager
->dbFileSize
){
2435 pPager
->dbFileSize
= pgno
;
2437 if( pPager
->pBackup
){
2438 #ifdef SQLITE_HAS_CODEC
2440 CODEC1(pPager
, aData
, pgno
, 3, rc
=SQLITE_NOMEM_BKPT
);
2441 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)aData
);
2442 CODEC2(pPager
, aData
, pgno
, 7, rc
=SQLITE_NOMEM_BKPT
,aData
);
2445 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)aData
);
2447 }else if( !isMainJrnl
&& pPg
==0 ){
2448 /* If this is a rollback of a savepoint and data was not written to
2449 ** the database and the page is not in-memory, there is a potential
2450 ** problem. When the page is next fetched by the b-tree layer, it
2451 ** will be read from the database file, which may or may not be
2454 ** There are a couple of different ways this can happen. All are quite
2455 ** obscure. When running in synchronous mode, this can only happen
2456 ** if the page is on the free-list at the start of the transaction, then
2457 ** populated, then moved using sqlite3PagerMovepage().
2459 ** The solution is to add an in-memory page to the cache containing
2460 ** the data just read from the sub-journal. Mark the page as dirty
2461 ** and if the pager requires a journal-sync, then mark the page as
2462 ** requiring a journal-sync before it is written.
2464 assert( isSavepnt
);
2465 assert( (pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
)==0 );
2466 pPager
->doNotSpill
|= SPILLFLAG_ROLLBACK
;
2467 rc
= sqlite3PagerGet(pPager
, pgno
, &pPg
, 1);
2468 assert( (pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
)!=0 );
2469 pPager
->doNotSpill
&= ~SPILLFLAG_ROLLBACK
;
2470 if( rc
!=SQLITE_OK
) return rc
;
2471 sqlite3PcacheMakeDirty(pPg
);
2474 /* No page should ever be explicitly rolled back that is in use, except
2475 ** for page 1 which is held in use in order to keep the lock on the
2476 ** database active. However such a page may be rolled back as a result
2477 ** of an internal error resulting in an automatic call to
2478 ** sqlite3PagerRollback().
2482 memcpy(pData
, (u8
*)aData
, pPager
->pageSize
);
2483 pPager
->xReiniter(pPg
);
2484 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
2485 ** that call was dangerous and had no detectable benefit since the cache
2486 ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so
2487 ** has been removed. */
2488 pager_set_pagehash(pPg
);
2490 /* If this was page 1, then restore the value of Pager.dbFileVers.
2491 ** Do this before any decoding. */
2493 memcpy(&pPager
->dbFileVers
, &((u8
*)pData
)[24],sizeof(pPager
->dbFileVers
));
2496 /* Decode the page just read from disk */
2497 #if SQLITE_HAS_CODEC
2498 if( jrnlEnc
){ CODEC1(pPager
, pData
, pPg
->pgno
, 3, rc
=SQLITE_NOMEM_BKPT
); }
2500 sqlite3PcacheRelease(pPg
);
2506 ** Parameter zMaster is the name of a master journal file. A single journal
2507 ** file that referred to the master journal file has just been rolled back.
2508 ** This routine checks if it is possible to delete the master journal file,
2509 ** and does so if it is.
2511 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
2512 ** available for use within this function.
2514 ** When a master journal file is created, it is populated with the names
2515 ** of all of its child journals, one after another, formatted as utf-8
2516 ** encoded text. The end of each child journal file is marked with a
2517 ** nul-terminator byte (0x00). i.e. the entire contents of a master journal
2518 ** file for a transaction involving two databases might be:
2520 ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
2522 ** A master journal file may only be deleted once all of its child
2523 ** journals have been rolled back.
2525 ** This function reads the contents of the master-journal file into
2526 ** memory and loops through each of the child journal names. For
2527 ** each child journal, it checks if:
2529 ** * if the child journal exists, and if so
2530 ** * if the child journal contains a reference to master journal
2533 ** If a child journal can be found that matches both of the criteria
2534 ** above, this function returns without doing anything. Otherwise, if
2535 ** no such child journal can be found, file zMaster is deleted from
2536 ** the file-system using sqlite3OsDelete().
2538 ** If an IO error within this function, an error code is returned. This
2539 ** function allocates memory by calling sqlite3Malloc(). If an allocation
2540 ** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
2541 ** occur, SQLITE_OK is returned.
2543 ** TODO: This function allocates a single block of memory to load
2544 ** the entire contents of the master journal file. This could be
2545 ** a couple of kilobytes or so - potentially larger than the page
2548 static int pager_delmaster(Pager
*pPager
, const char *zMaster
){
2549 sqlite3_vfs
*pVfs
= pPager
->pVfs
;
2550 int rc
; /* Return code */
2551 sqlite3_file
*pMaster
; /* Malloc'd master-journal file descriptor */
2552 sqlite3_file
*pJournal
; /* Malloc'd child-journal file descriptor */
2553 char *zMasterJournal
= 0; /* Contents of master journal file */
2554 i64 nMasterJournal
; /* Size of master journal file */
2555 char *zJournal
; /* Pointer to one journal within MJ file */
2556 char *zMasterPtr
; /* Space to hold MJ filename from a journal file */
2557 int nMasterPtr
; /* Amount of space allocated to zMasterPtr[] */
2559 /* Allocate space for both the pJournal and pMaster file descriptors.
2560 ** If successful, open the master journal file for reading.
2562 pMaster
= (sqlite3_file
*)sqlite3MallocZero(pVfs
->szOsFile
* 2);
2563 pJournal
= (sqlite3_file
*)(((u8
*)pMaster
) + pVfs
->szOsFile
);
2565 rc
= SQLITE_NOMEM_BKPT
;
2567 const int flags
= (SQLITE_OPEN_READONLY
|SQLITE_OPEN_MASTER_JOURNAL
);
2568 rc
= sqlite3OsOpen(pVfs
, zMaster
, pMaster
, flags
, 0);
2570 if( rc
!=SQLITE_OK
) goto delmaster_out
;
2572 /* Load the entire master journal file into space obtained from
2573 ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain
2574 ** sufficient space (in zMasterPtr) to hold the names of master
2575 ** journal files extracted from regular rollback-journals.
2577 rc
= sqlite3OsFileSize(pMaster
, &nMasterJournal
);
2578 if( rc
!=SQLITE_OK
) goto delmaster_out
;
2579 nMasterPtr
= pVfs
->mxPathname
+1;
2580 zMasterJournal
= sqlite3Malloc(nMasterJournal
+ nMasterPtr
+ 1);
2581 if( !zMasterJournal
){
2582 rc
= SQLITE_NOMEM_BKPT
;
2585 zMasterPtr
= &zMasterJournal
[nMasterJournal
+1];
2586 rc
= sqlite3OsRead(pMaster
, zMasterJournal
, (int)nMasterJournal
, 0);
2587 if( rc
!=SQLITE_OK
) goto delmaster_out
;
2588 zMasterJournal
[nMasterJournal
] = 0;
2590 zJournal
= zMasterJournal
;
2591 while( (zJournal
-zMasterJournal
)<nMasterJournal
){
2593 rc
= sqlite3OsAccess(pVfs
, zJournal
, SQLITE_ACCESS_EXISTS
, &exists
);
2594 if( rc
!=SQLITE_OK
){
2598 /* One of the journals pointed to by the master journal exists.
2599 ** Open it and check if it points at the master journal. If
2600 ** so, return without deleting the master journal file.
2603 int flags
= (SQLITE_OPEN_READONLY
|SQLITE_OPEN_MAIN_JOURNAL
);
2604 rc
= sqlite3OsOpen(pVfs
, zJournal
, pJournal
, flags
, 0);
2605 if( rc
!=SQLITE_OK
){
2609 rc
= readMasterJournal(pJournal
, zMasterPtr
, nMasterPtr
);
2610 sqlite3OsClose(pJournal
);
2611 if( rc
!=SQLITE_OK
){
2615 c
= zMasterPtr
[0]!=0 && strcmp(zMasterPtr
, zMaster
)==0;
2617 /* We have a match. Do not delete the master journal file. */
2621 zJournal
+= (sqlite3Strlen30(zJournal
)+1);
2624 sqlite3OsClose(pMaster
);
2625 rc
= sqlite3OsDelete(pVfs
, zMaster
, 0);
2628 sqlite3_free(zMasterJournal
);
2630 sqlite3OsClose(pMaster
);
2631 assert( !isOpen(pJournal
) );
2632 sqlite3_free(pMaster
);
2639 ** This function is used to change the actual size of the database
2640 ** file in the file-system. This only happens when committing a transaction,
2641 ** or rolling back a transaction (including rolling back a hot-journal).
2643 ** If the main database file is not open, or the pager is not in either
2644 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
2645 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
2646 ** If the file on disk is currently larger than nPage pages, then use the VFS
2647 ** xTruncate() method to truncate it.
2649 ** Or, it might be the case that the file on disk is smaller than
2650 ** nPage pages. Some operating system implementations can get confused if
2651 ** you try to truncate a file to some size that is larger than it
2652 ** currently is, so detect this case and write a single zero byte to
2653 ** the end of the new file instead.
2655 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
2656 ** the database file, return the error code to the caller.
2658 static int pager_truncate(Pager
*pPager
, Pgno nPage
){
2660 assert( pPager
->eState
!=PAGER_ERROR
);
2661 assert( pPager
->eState
!=PAGER_READER
);
2663 if( isOpen(pPager
->fd
)
2664 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2666 i64 currentSize
, newSize
;
2667 int szPage
= pPager
->pageSize
;
2668 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
2669 /* TODO: Is it safe to use Pager.dbFileSize here? */
2670 rc
= sqlite3OsFileSize(pPager
->fd
, ¤tSize
);
2671 newSize
= szPage
*(i64
)nPage
;
2672 if( rc
==SQLITE_OK
&& currentSize
!=newSize
){
2673 if( currentSize
>newSize
){
2674 rc
= sqlite3OsTruncate(pPager
->fd
, newSize
);
2675 }else if( (currentSize
+szPage
)<=newSize
){
2676 char *pTmp
= pPager
->pTmpSpace
;
2677 memset(pTmp
, 0, szPage
);
2678 testcase( (newSize
-szPage
) == currentSize
);
2679 testcase( (newSize
-szPage
) > currentSize
);
2680 rc
= sqlite3OsWrite(pPager
->fd
, pTmp
, szPage
, newSize
-szPage
);
2682 if( rc
==SQLITE_OK
){
2683 pPager
->dbFileSize
= nPage
;
2691 ** Return a sanitized version of the sector-size of OS file pFile. The
2692 ** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
2694 int sqlite3SectorSize(sqlite3_file
*pFile
){
2695 int iRet
= sqlite3OsSectorSize(pFile
);
2698 }else if( iRet
>MAX_SECTOR_SIZE
){
2699 assert( MAX_SECTOR_SIZE
>=512 );
2700 iRet
= MAX_SECTOR_SIZE
;
2706 ** Set the value of the Pager.sectorSize variable for the given
2707 ** pager based on the value returned by the xSectorSize method
2708 ** of the open database file. The sector size will be used
2709 ** to determine the size and alignment of journal header and
2710 ** master journal pointers within created journal files.
2712 ** For temporary files the effective sector size is always 512 bytes.
2714 ** Otherwise, for non-temporary files, the effective sector size is
2715 ** the value returned by the xSectorSize() method rounded up to 32 if
2716 ** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
2717 ** is greater than MAX_SECTOR_SIZE.
2719 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
2720 ** the effective sector size to its minimum value (512). The purpose of
2721 ** pPager->sectorSize is to define the "blast radius" of bytes that
2722 ** might change if a crash occurs while writing to a single byte in
2723 ** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
2724 ** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
2725 ** size. For backwards compatibility of the rollback journal file format,
2726 ** we cannot reduce the effective sector size below 512.
2728 static void setSectorSize(Pager
*pPager
){
2729 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
2731 if( pPager
->tempFile
2732 || (sqlite3OsDeviceCharacteristics(pPager
->fd
) &
2733 SQLITE_IOCAP_POWERSAFE_OVERWRITE
)!=0
2735 /* Sector size doesn't matter for temporary files. Also, the file
2736 ** may not have been opened yet, in which case the OsSectorSize()
2737 ** call will segfault. */
2738 pPager
->sectorSize
= 512;
2740 pPager
->sectorSize
= sqlite3SectorSize(pPager
->fd
);
2745 ** Playback the journal and thus restore the database file to
2746 ** the state it was in before we started making changes.
2748 ** The journal file format is as follows:
2750 ** (1) 8 byte prefix. A copy of aJournalMagic[].
2751 ** (2) 4 byte big-endian integer which is the number of valid page records
2752 ** in the journal. If this value is 0xffffffff, then compute the
2753 ** number of page records from the journal size.
2754 ** (3) 4 byte big-endian integer which is the initial value for the
2756 ** (4) 4 byte integer which is the number of pages to truncate the
2757 ** database to during a rollback.
2758 ** (5) 4 byte big-endian integer which is the sector size. The header
2759 ** is this many bytes in size.
2760 ** (6) 4 byte big-endian integer which is the page size.
2761 ** (7) zero padding out to the next sector size.
2762 ** (8) Zero or more pages instances, each as follows:
2763 ** + 4 byte page number.
2764 ** + pPager->pageSize bytes of data.
2765 ** + 4 byte checksum
2767 ** When we speak of the journal header, we mean the first 7 items above.
2768 ** Each entry in the journal is an instance of the 8th item.
2770 ** Call the value from the second bullet "nRec". nRec is the number of
2771 ** valid page entries in the journal. In most cases, you can compute the
2772 ** value of nRec from the size of the journal file. But if a power
2773 ** failure occurred while the journal was being written, it could be the
2774 ** case that the size of the journal file had already been increased but
2775 ** the extra entries had not yet made it safely to disk. In such a case,
2776 ** the value of nRec computed from the file size would be too large. For
2777 ** that reason, we always use the nRec value in the header.
2779 ** If the nRec value is 0xffffffff it means that nRec should be computed
2780 ** from the file size. This value is used when the user selects the
2781 ** no-sync option for the journal. A power failure could lead to corruption
2782 ** in this case. But for things like temporary table (which will be
2783 ** deleted when the power is restored) we don't care.
2785 ** If the file opened as the journal file is not a well-formed
2786 ** journal file then all pages up to the first corrupted page are rolled
2787 ** back (or no pages if the journal header is corrupted). The journal file
2788 ** is then deleted and SQLITE_OK returned, just as if no corruption had
2789 ** been encountered.
2791 ** If an I/O or malloc() error occurs, the journal-file is not deleted
2792 ** and an error code is returned.
2794 ** The isHot parameter indicates that we are trying to rollback a journal
2795 ** that might be a hot journal. Or, it could be that the journal is
2796 ** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
2797 ** If the journal really is hot, reset the pager cache prior rolling
2798 ** back any content. If the journal is merely persistent, no reset is
2801 static int pager_playback(Pager
*pPager
, int isHot
){
2802 sqlite3_vfs
*pVfs
= pPager
->pVfs
;
2803 i64 szJ
; /* Size of the journal file in bytes */
2804 u32 nRec
; /* Number of Records in the journal */
2805 u32 u
; /* Unsigned loop counter */
2806 Pgno mxPg
= 0; /* Size of the original file in pages */
2807 int rc
; /* Result code of a subroutine */
2808 int res
= 1; /* Value returned by sqlite3OsAccess() */
2809 char *zMaster
= 0; /* Name of master journal file if any */
2810 int needPagerReset
; /* True to reset page prior to first page rollback */
2811 int nPlayback
= 0; /* Total number of pages restored from journal */
2812 u32 savedPageSize
= pPager
->pageSize
;
2814 /* Figure out how many records are in the journal. Abort early if
2815 ** the journal is empty.
2817 assert( isOpen(pPager
->jfd
) );
2818 rc
= sqlite3OsFileSize(pPager
->jfd
, &szJ
);
2819 if( rc
!=SQLITE_OK
){
2823 /* Read the master journal name from the journal, if it is present.
2824 ** If a master journal file name is specified, but the file is not
2825 ** present on disk, then the journal is not hot and does not need to be
2828 ** TODO: Technically the following is an error because it assumes that
2829 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2830 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
2831 ** mxPathname is 512, which is the same as the minimum allowable value
2834 zMaster
= pPager
->pTmpSpace
;
2835 rc
= readMasterJournal(pPager
->jfd
, zMaster
, pPager
->pVfs
->mxPathname
+1);
2836 if( rc
==SQLITE_OK
&& zMaster
[0] ){
2837 rc
= sqlite3OsAccess(pVfs
, zMaster
, SQLITE_ACCESS_EXISTS
, &res
);
2840 if( rc
!=SQLITE_OK
|| !res
){
2843 pPager
->journalOff
= 0;
2844 needPagerReset
= isHot
;
2846 /* This loop terminates either when a readJournalHdr() or
2847 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2851 /* Read the next journal header from the journal file. If there are
2852 ** not enough bytes left in the journal file for a complete header, or
2853 ** it is corrupted, then a process must have failed while writing it.
2854 ** This indicates nothing more needs to be rolled back.
2856 rc
= readJournalHdr(pPager
, isHot
, szJ
, &nRec
, &mxPg
);
2857 if( rc
!=SQLITE_OK
){
2858 if( rc
==SQLITE_DONE
){
2864 /* If nRec is 0xffffffff, then this journal was created by a process
2865 ** working in no-sync mode. This means that the rest of the journal
2866 ** file consists of pages, there are no more journal headers. Compute
2867 ** the value of nRec based on this assumption.
2869 if( nRec
==0xffffffff ){
2870 assert( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) );
2871 nRec
= (int)((szJ
- JOURNAL_HDR_SZ(pPager
))/JOURNAL_PG_SZ(pPager
));
2874 /* If nRec is 0 and this rollback is of a transaction created by this
2875 ** process and if this is the final header in the journal, then it means
2876 ** that this part of the journal was being filled but has not yet been
2877 ** synced to disk. Compute the number of pages based on the remaining
2878 ** size of the file.
2880 ** The third term of the test was added to fix ticket #2565.
2881 ** When rolling back a hot journal, nRec==0 always means that the next
2882 ** chunk of the journal contains zero pages to be rolled back. But
2883 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2884 ** the journal, it means that the journal might contain additional
2885 ** pages that need to be rolled back and that the number of pages
2886 ** should be computed based on the journal file size.
2888 if( nRec
==0 && !isHot
&&
2889 pPager
->journalHdr
+JOURNAL_HDR_SZ(pPager
)==pPager
->journalOff
){
2890 nRec
= (int)((szJ
- pPager
->journalOff
) / JOURNAL_PG_SZ(pPager
));
2893 /* If this is the first header read from the journal, truncate the
2894 ** database file back to its original size.
2896 if( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) ){
2897 rc
= pager_truncate(pPager
, mxPg
);
2898 if( rc
!=SQLITE_OK
){
2901 pPager
->dbSize
= mxPg
;
2904 /* Copy original pages out of the journal and back into the
2905 ** database file and/or page cache.
2907 for(u
=0; u
<nRec
; u
++){
2908 if( needPagerReset
){
2909 pager_reset(pPager
);
2912 rc
= pager_playback_one_page(pPager
,&pPager
->journalOff
,0,1,0);
2913 if( rc
==SQLITE_OK
){
2916 if( rc
==SQLITE_DONE
){
2917 pPager
->journalOff
= szJ
;
2919 }else if( rc
==SQLITE_IOERR_SHORT_READ
){
2920 /* If the journal has been truncated, simply stop reading and
2921 ** processing the journal. This might happen if the journal was
2922 ** not completely written and synced prior to a crash. In that
2923 ** case, the database should have never been written in the
2924 ** first place so it is OK to simply abandon the rollback. */
2928 /* If we are unable to rollback, quit and return the error
2929 ** code. This will cause the pager to enter the error state
2930 ** so that no further harm will be done. Perhaps the next
2931 ** process to come along will be able to rollback the database.
2942 if( rc
==SQLITE_OK
){
2943 rc
= sqlite3PagerSetPagesize(pPager
, &savedPageSize
, -1);
2945 /* Following a rollback, the database file should be back in its original
2946 ** state prior to the start of the transaction, so invoke the
2947 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
2948 ** assertion that the transaction counter was modified.
2951 if( pPager
->fd
->pMethods
){
2952 sqlite3OsFileControlHint(pPager
->fd
,SQLITE_FCNTL_DB_UNCHANGED
,0);
2956 /* If this playback is happening automatically as a result of an IO or
2957 ** malloc error that occurred after the change-counter was updated but
2958 ** before the transaction was committed, then the change-counter
2959 ** modification may just have been reverted. If this happens in exclusive
2960 ** mode, then subsequent transactions performed by the connection will not
2961 ** update the change-counter at all. This may lead to cache inconsistency
2962 ** problems for other processes at some point in the future. So, just
2963 ** in case this has happened, clear the changeCountDone flag now.
2965 pPager
->changeCountDone
= pPager
->tempFile
;
2967 if( rc
==SQLITE_OK
){
2968 zMaster
= pPager
->pTmpSpace
;
2969 rc
= readMasterJournal(pPager
->jfd
, zMaster
, pPager
->pVfs
->mxPathname
+1);
2970 testcase( rc
!=SQLITE_OK
);
2973 && (pPager
->eState
>=PAGER_WRITER_DBMOD
|| pPager
->eState
==PAGER_OPEN
)
2975 rc
= sqlite3PagerSync(pPager
, 0);
2977 if( rc
==SQLITE_OK
){
2978 rc
= pager_end_transaction(pPager
, zMaster
[0]!='\0', 0);
2979 testcase( rc
!=SQLITE_OK
);
2981 if( rc
==SQLITE_OK
&& zMaster
[0] && res
){
2982 /* If there was a master journal and this routine will return success,
2983 ** see if it is possible to delete the master journal.
2985 rc
= pager_delmaster(pPager
, zMaster
);
2986 testcase( rc
!=SQLITE_OK
);
2988 if( isHot
&& nPlayback
){
2989 sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK
, "recovered %d pages from %s",
2990 nPlayback
, pPager
->zJournal
);
2993 /* The Pager.sectorSize variable may have been updated while rolling
2994 ** back a journal created by a process with a different sector size
2995 ** value. Reset it to the correct value for this process.
2997 setSectorSize(pPager
);
3003 ** Read the content for page pPg out of the database file (or out of
3004 ** the WAL if that is where the most recent copy if found) into
3005 ** pPg->pData. A shared lock or greater must be held on the database
3006 ** file before this function is called.
3008 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
3009 ** the value read from the database file.
3011 ** If an IO error occurs, then the IO error is returned to the caller.
3012 ** Otherwise, SQLITE_OK is returned.
3014 static int readDbPage(PgHdr
*pPg
){
3015 Pager
*pPager
= pPg
->pPager
; /* Pager object associated with page pPg */
3016 int rc
= SQLITE_OK
; /* Return code */
3018 #ifndef SQLITE_OMIT_WAL
3019 u32 iFrame
= 0; /* Frame of WAL containing pgno */
3021 assert( pPager
->eState
>=PAGER_READER
&& !MEMDB
);
3022 assert( isOpen(pPager
->fd
) );
3024 if( pagerUseWal(pPager
) ){
3025 rc
= sqlite3WalFindFrame(pPager
->pWal
, pPg
->pgno
, &iFrame
);
3029 rc
= sqlite3WalReadFrame(pPager
->pWal
, iFrame
,pPager
->pageSize
,pPg
->pData
);
3033 i64 iOffset
= (pPg
->pgno
-1)*(i64
)pPager
->pageSize
;
3034 rc
= sqlite3OsRead(pPager
->fd
, pPg
->pData
, pPager
->pageSize
, iOffset
);
3035 if( rc
==SQLITE_IOERR_SHORT_READ
){
3042 /* If the read is unsuccessful, set the dbFileVers[] to something
3043 ** that will never be a valid file version. dbFileVers[] is a copy
3044 ** of bytes 24..39 of the database. Bytes 28..31 should always be
3045 ** zero or the size of the database in page. Bytes 32..35 and 35..39
3046 ** should be page numbers which are never 0xffffffff. So filling
3047 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
3049 ** For an encrypted database, the situation is more complex: bytes
3050 ** 24..39 of the database are white noise. But the probability of
3051 ** white noise equaling 16 bytes of 0xff is vanishingly small so
3052 ** we should still be ok.
3054 memset(pPager
->dbFileVers
, 0xff, sizeof(pPager
->dbFileVers
));
3056 u8
*dbFileVers
= &((u8
*)pPg
->pData
)[24];
3057 memcpy(&pPager
->dbFileVers
, dbFileVers
, sizeof(pPager
->dbFileVers
));
3060 CODEC1(pPager
, pPg
->pData
, pPg
->pgno
, 3, rc
= SQLITE_NOMEM_BKPT
);
3062 PAGER_INCR(sqlite3_pager_readdb_count
);
3063 PAGER_INCR(pPager
->nRead
);
3064 IOTRACE(("PGIN %p %d\n", pPager
, pPg
->pgno
));
3065 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
3066 PAGERID(pPager
), pPg
->pgno
, pager_pagehash(pPg
)));
3072 ** Update the value of the change-counter at offsets 24 and 92 in
3073 ** the header and the sqlite version number at offset 96.
3075 ** This is an unconditional update. See also the pager_incr_changecounter()
3076 ** routine which only updates the change-counter if the update is actually
3077 ** needed, as determined by the pPager->changeCountDone state variable.
3079 static void pager_write_changecounter(PgHdr
*pPg
){
3082 /* Increment the value just read and write it back to byte 24. */
3083 change_counter
= sqlite3Get4byte((u8
*)pPg
->pPager
->dbFileVers
)+1;
3084 put32bits(((char*)pPg
->pData
)+24, change_counter
);
3086 /* Also store the SQLite version number in bytes 96..99 and in
3087 ** bytes 92..95 store the change counter for which the version number
3089 put32bits(((char*)pPg
->pData
)+92, change_counter
);
3090 put32bits(((char*)pPg
->pData
)+96, SQLITE_VERSION_NUMBER
);
3093 #ifndef SQLITE_OMIT_WAL
3095 ** This function is invoked once for each page that has already been
3096 ** written into the log file when a WAL transaction is rolled back.
3097 ** Parameter iPg is the page number of said page. The pCtx argument
3098 ** is actually a pointer to the Pager structure.
3100 ** If page iPg is present in the cache, and has no outstanding references,
3101 ** it is discarded. Otherwise, if there are one or more outstanding
3102 ** references, the page content is reloaded from the database. If the
3103 ** attempt to reload content from the database is required and fails,
3104 ** return an SQLite error code. Otherwise, SQLITE_OK.
3106 static int pagerUndoCallback(void *pCtx
, Pgno iPg
){
3108 Pager
*pPager
= (Pager
*)pCtx
;
3111 assert( pagerUseWal(pPager
) );
3112 pPg
= sqlite3PagerLookup(pPager
, iPg
);
3114 if( sqlite3PcachePageRefcount(pPg
)==1 ){
3115 sqlite3PcacheDrop(pPg
);
3117 rc
= readDbPage(pPg
);
3118 if( rc
==SQLITE_OK
){
3119 pPager
->xReiniter(pPg
);
3121 sqlite3PagerUnrefNotNull(pPg
);
3125 /* Normally, if a transaction is rolled back, any backup processes are
3126 ** updated as data is copied out of the rollback journal and into the
3127 ** database. This is not generally possible with a WAL database, as
3128 ** rollback involves simply truncating the log file. Therefore, if one
3129 ** or more frames have already been written to the log (and therefore
3130 ** also copied into the backup databases) as part of this transaction,
3131 ** the backups must be restarted.
3133 sqlite3BackupRestart(pPager
->pBackup
);
3139 ** This function is called to rollback a transaction on a WAL database.
3141 static int pagerRollbackWal(Pager
*pPager
){
3142 int rc
; /* Return Code */
3143 PgHdr
*pList
; /* List of dirty pages to revert */
3145 /* For all pages in the cache that are currently dirty or have already
3146 ** been written (but not committed) to the log file, do one of the
3149 ** + Discard the cached page (if refcount==0), or
3150 ** + Reload page content from the database (if refcount>0).
3152 pPager
->dbSize
= pPager
->dbOrigSize
;
3153 rc
= sqlite3WalUndo(pPager
->pWal
, pagerUndoCallback
, (void *)pPager
);
3154 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
3155 while( pList
&& rc
==SQLITE_OK
){
3156 PgHdr
*pNext
= pList
->pDirty
;
3157 rc
= pagerUndoCallback((void *)pPager
, pList
->pgno
);
3165 ** This function is a wrapper around sqlite3WalFrames(). As well as logging
3166 ** the contents of the list of pages headed by pList (connected by pDirty),
3167 ** this function notifies any active backup processes that the pages have
3170 ** The list of pages passed into this routine is always sorted by page number.
3171 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
3173 static int pagerWalFrames(
3174 Pager
*pPager
, /* Pager object */
3175 PgHdr
*pList
, /* List of frames to log */
3176 Pgno nTruncate
, /* Database size after this commit */
3177 int isCommit
/* True if this is a commit */
3179 int rc
; /* Return code */
3180 int nList
; /* Number of pages in pList */
3181 PgHdr
*p
; /* For looping over pages */
3183 assert( pPager
->pWal
);
3186 /* Verify that the page list is in accending order */
3187 for(p
=pList
; p
&& p
->pDirty
; p
=p
->pDirty
){
3188 assert( p
->pgno
< p
->pDirty
->pgno
);
3192 assert( pList
->pDirty
==0 || isCommit
);
3194 /* If a WAL transaction is being committed, there is no point in writing
3195 ** any pages with page numbers greater than nTruncate into the WAL file.
3196 ** They will never be read by any client. So remove them from the pDirty
3198 PgHdr
**ppNext
= &pList
;
3200 for(p
=pList
; (*ppNext
= p
)!=0; p
=p
->pDirty
){
3201 if( p
->pgno
<=nTruncate
){
3202 ppNext
= &p
->pDirty
;
3210 pPager
->aStat
[PAGER_STAT_WRITE
] += nList
;
3212 if( pList
->pgno
==1 ) pager_write_changecounter(pList
);
3213 rc
= sqlite3WalFrames(pPager
->pWal
,
3214 pPager
->pageSize
, pList
, nTruncate
, isCommit
, pPager
->walSyncFlags
3216 if( rc
==SQLITE_OK
&& pPager
->pBackup
){
3217 for(p
=pList
; p
; p
=p
->pDirty
){
3218 sqlite3BackupUpdate(pPager
->pBackup
, p
->pgno
, (u8
*)p
->pData
);
3222 #ifdef SQLITE_CHECK_PAGES
3223 pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
3224 for(p
=pList
; p
; p
=p
->pDirty
){
3225 pager_set_pagehash(p
);
3233 ** Begin a read transaction on the WAL.
3235 ** This routine used to be called "pagerOpenSnapshot()" because it essentially
3236 ** makes a snapshot of the database at the current point in time and preserves
3237 ** that snapshot for use by the reader in spite of concurrently changes by
3238 ** other writers or checkpointers.
3240 static int pagerBeginReadTransaction(Pager
*pPager
){
3241 int rc
; /* Return code */
3242 int changed
= 0; /* True if cache must be reset */
3244 assert( pagerUseWal(pPager
) );
3245 assert( pPager
->eState
==PAGER_OPEN
|| pPager
->eState
==PAGER_READER
);
3247 /* sqlite3WalEndReadTransaction() was not called for the previous
3248 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
3249 ** are in locking_mode=NORMAL and EndRead() was previously called,
3250 ** the duplicate call is harmless.
3252 sqlite3WalEndReadTransaction(pPager
->pWal
);
3254 rc
= sqlite3WalBeginReadTransaction(pPager
->pWal
, &changed
);
3255 if( rc
!=SQLITE_OK
|| changed
){
3256 pager_reset(pPager
);
3257 if( USEFETCH(pPager
) ) sqlite3OsUnfetch(pPager
->fd
, 0, 0);
3265 ** This function is called as part of the transition from PAGER_OPEN
3266 ** to PAGER_READER state to determine the size of the database file
3267 ** in pages (assuming the page size currently stored in Pager.pageSize).
3269 ** If no error occurs, SQLITE_OK is returned and the size of the database
3270 ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
3271 ** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
3273 static int pagerPagecount(Pager
*pPager
, Pgno
*pnPage
){
3274 Pgno nPage
; /* Value to return via *pnPage */
3276 /* Query the WAL sub-system for the database size. The WalDbsize()
3277 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
3278 ** if the database size is not available. The database size is not
3279 ** available from the WAL sub-system if the log file is empty or
3280 ** contains no valid committed transactions.
3282 assert( pPager
->eState
==PAGER_OPEN
);
3283 assert( pPager
->eLock
>=SHARED_LOCK
);
3284 assert( isOpen(pPager
->fd
) );
3285 assert( pPager
->tempFile
==0 );
3286 nPage
= sqlite3WalDbsize(pPager
->pWal
);
3288 /* If the number of pages in the database is not available from the
3289 ** WAL sub-system, determine the page count based on the size of
3290 ** the database file. If the size of the database file is not an
3291 ** integer multiple of the page-size, round up the result.
3293 if( nPage
==0 && ALWAYS(isOpen(pPager
->fd
)) ){
3294 i64 n
= 0; /* Size of db file in bytes */
3295 int rc
= sqlite3OsFileSize(pPager
->fd
, &n
);
3296 if( rc
!=SQLITE_OK
){
3299 nPage
= (Pgno
)((n
+pPager
->pageSize
-1) / pPager
->pageSize
);
3302 /* If the current number of pages in the file is greater than the
3303 ** configured maximum pager number, increase the allowed limit so
3304 ** that the file can be read.
3306 if( nPage
>pPager
->mxPgno
){
3307 pPager
->mxPgno
= (Pgno
)nPage
;
3314 #ifndef SQLITE_OMIT_WAL
3316 ** Check if the *-wal file that corresponds to the database opened by pPager
3317 ** exists if the database is not empy, or verify that the *-wal file does
3318 ** not exist (by deleting it) if the database file is empty.
3320 ** If the database is not empty and the *-wal file exists, open the pager
3321 ** in WAL mode. If the database is empty or if no *-wal file exists and
3322 ** if no error occurs, make sure Pager.journalMode is not set to
3323 ** PAGER_JOURNALMODE_WAL.
3325 ** Return SQLITE_OK or an error code.
3327 ** The caller must hold a SHARED lock on the database file to call this
3328 ** function. Because an EXCLUSIVE lock on the db file is required to delete
3329 ** a WAL on a none-empty database, this ensures there is no race condition
3330 ** between the xAccess() below and an xDelete() being executed by some
3331 ** other connection.
3333 static int pagerOpenWalIfPresent(Pager
*pPager
){
3335 assert( pPager
->eState
==PAGER_OPEN
);
3336 assert( pPager
->eLock
>=SHARED_LOCK
);
3338 if( !pPager
->tempFile
){
3339 int isWal
; /* True if WAL file exists */
3340 rc
= sqlite3OsAccess(
3341 pPager
->pVfs
, pPager
->zWal
, SQLITE_ACCESS_EXISTS
, &isWal
3343 if( rc
==SQLITE_OK
){
3345 Pgno nPage
; /* Size of the database file */
3347 rc
= pagerPagecount(pPager
, &nPage
);
3350 rc
= sqlite3OsDelete(pPager
->pVfs
, pPager
->zWal
, 0);
3352 testcase( sqlite3PcachePagecount(pPager
->pPCache
)==0 );
3353 rc
= sqlite3PagerOpenWal(pPager
, 0);
3355 }else if( pPager
->journalMode
==PAGER_JOURNALMODE_WAL
){
3356 pPager
->journalMode
= PAGER_JOURNALMODE_DELETE
;
3365 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
3366 ** the entire master journal file. The case pSavepoint==NULL occurs when
3367 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
3370 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
3371 ** being rolled back), then the rollback consists of up to three stages,
3372 ** performed in the order specified:
3374 ** * Pages are played back from the main journal starting at byte
3375 ** offset PagerSavepoint.iOffset and continuing to
3376 ** PagerSavepoint.iHdrOffset, or to the end of the main journal
3377 ** file if PagerSavepoint.iHdrOffset is zero.
3379 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
3380 ** back starting from the journal header immediately following
3381 ** PagerSavepoint.iHdrOffset to the end of the main journal file.
3383 ** * Pages are then played back from the sub-journal file, starting
3384 ** with the PagerSavepoint.iSubRec and continuing to the end of
3385 ** the journal file.
3387 ** Throughout the rollback process, each time a page is rolled back, the
3388 ** corresponding bit is set in a bitvec structure (variable pDone in the
3389 ** implementation below). This is used to ensure that a page is only
3390 ** rolled back the first time it is encountered in either journal.
3392 ** If pSavepoint is NULL, then pages are only played back from the main
3393 ** journal file. There is no need for a bitvec in this case.
3395 ** In either case, before playback commences the Pager.dbSize variable
3396 ** is reset to the value that it held at the start of the savepoint
3397 ** (or transaction). No page with a page-number greater than this value
3398 ** is played back. If one is encountered it is simply skipped.
3400 static int pagerPlaybackSavepoint(Pager
*pPager
, PagerSavepoint
*pSavepoint
){
3401 i64 szJ
; /* Effective size of the main journal */
3402 i64 iHdrOff
; /* End of first segment of main-journal records */
3403 int rc
= SQLITE_OK
; /* Return code */
3404 Bitvec
*pDone
= 0; /* Bitvec to ensure pages played back only once */
3406 assert( pPager
->eState
!=PAGER_ERROR
);
3407 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
3409 /* Allocate a bitvec to use to store the set of pages rolled back */
3411 pDone
= sqlite3BitvecCreate(pSavepoint
->nOrig
);
3413 return SQLITE_NOMEM_BKPT
;
3417 /* Set the database size back to the value it was before the savepoint
3418 ** being reverted was opened.
3420 pPager
->dbSize
= pSavepoint
? pSavepoint
->nOrig
: pPager
->dbOrigSize
;
3421 pPager
->changeCountDone
= pPager
->tempFile
;
3423 if( !pSavepoint
&& pagerUseWal(pPager
) ){
3424 return pagerRollbackWal(pPager
);
3427 /* Use pPager->journalOff as the effective size of the main rollback
3428 ** journal. The actual file might be larger than this in
3429 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
3430 ** past pPager->journalOff is off-limits to us.
3432 szJ
= pPager
->journalOff
;
3433 assert( pagerUseWal(pPager
)==0 || szJ
==0 );
3435 /* Begin by rolling back records from the main journal starting at
3436 ** PagerSavepoint.iOffset and continuing to the next journal header.
3437 ** There might be records in the main journal that have a page number
3438 ** greater than the current database size (pPager->dbSize) but those
3439 ** will be skipped automatically. Pages are added to pDone as they
3442 if( pSavepoint
&& !pagerUseWal(pPager
) ){
3443 iHdrOff
= pSavepoint
->iHdrOffset
? pSavepoint
->iHdrOffset
: szJ
;
3444 pPager
->journalOff
= pSavepoint
->iOffset
;
3445 while( rc
==SQLITE_OK
&& pPager
->journalOff
<iHdrOff
){
3446 rc
= pager_playback_one_page(pPager
, &pPager
->journalOff
, pDone
, 1, 1);
3448 assert( rc
!=SQLITE_DONE
);
3450 pPager
->journalOff
= 0;
3453 /* Continue rolling back records out of the main journal starting at
3454 ** the first journal header seen and continuing until the effective end
3455 ** of the main journal file. Continue to skip out-of-range pages and
3456 ** continue adding pages rolled back to pDone.
3458 while( rc
==SQLITE_OK
&& pPager
->journalOff
<szJ
){
3459 u32 ii
; /* Loop counter */
3460 u32 nJRec
= 0; /* Number of Journal Records */
3462 rc
= readJournalHdr(pPager
, 0, szJ
, &nJRec
, &dummy
);
3463 assert( rc
!=SQLITE_DONE
);
3466 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
3467 ** test is related to ticket #2565. See the discussion in the
3468 ** pager_playback() function for additional information.
3471 && pPager
->journalHdr
+JOURNAL_HDR_SZ(pPager
)==pPager
->journalOff
3473 nJRec
= (u32
)((szJ
- pPager
->journalOff
)/JOURNAL_PG_SZ(pPager
));
3475 for(ii
=0; rc
==SQLITE_OK
&& ii
<nJRec
&& pPager
->journalOff
<szJ
; ii
++){
3476 rc
= pager_playback_one_page(pPager
, &pPager
->journalOff
, pDone
, 1, 1);
3478 assert( rc
!=SQLITE_DONE
);
3480 assert( rc
!=SQLITE_OK
|| pPager
->journalOff
>=szJ
);
3482 /* Finally, rollback pages from the sub-journal. Page that were
3483 ** previously rolled back out of the main journal (and are hence in pDone)
3484 ** will be skipped. Out-of-range pages are also skipped.
3487 u32 ii
; /* Loop counter */
3488 i64 offset
= (i64
)pSavepoint
->iSubRec
*(4+pPager
->pageSize
);
3490 if( pagerUseWal(pPager
) ){
3491 rc
= sqlite3WalSavepointUndo(pPager
->pWal
, pSavepoint
->aWalData
);
3493 for(ii
=pSavepoint
->iSubRec
; rc
==SQLITE_OK
&& ii
<pPager
->nSubRec
; ii
++){
3494 assert( offset
==(i64
)ii
*(4+pPager
->pageSize
) );
3495 rc
= pager_playback_one_page(pPager
, &offset
, pDone
, 0, 1);
3497 assert( rc
!=SQLITE_DONE
);
3500 sqlite3BitvecDestroy(pDone
);
3501 if( rc
==SQLITE_OK
){
3502 pPager
->journalOff
= szJ
;
3509 ** Change the maximum number of in-memory pages that are allowed
3510 ** before attempting to recycle clean and unused pages.
3512 void sqlite3PagerSetCachesize(Pager
*pPager
, int mxPage
){
3513 sqlite3PcacheSetCachesize(pPager
->pPCache
, mxPage
);
3517 ** Change the maximum number of in-memory pages that are allowed
3518 ** before attempting to spill pages to journal.
3520 int sqlite3PagerSetSpillsize(Pager
*pPager
, int mxPage
){
3521 return sqlite3PcacheSetSpillsize(pPager
->pPCache
, mxPage
);
3525 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
3527 static void pagerFixMaplimit(Pager
*pPager
){
3528 #if SQLITE_MAX_MMAP_SIZE>0
3529 sqlite3_file
*fd
= pPager
->fd
;
3530 if( isOpen(fd
) && fd
->pMethods
->iVersion
>=3 ){
3532 sz
= pPager
->szMmap
;
3533 pPager
->bUseFetch
= (sz
>0);
3534 setGetterMethod(pPager
);
3535 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_MMAP_SIZE
, &sz
);
3541 ** Change the maximum size of any memory mapping made of the database file.
3543 void sqlite3PagerSetMmapLimit(Pager
*pPager
, sqlite3_int64 szMmap
){
3544 pPager
->szMmap
= szMmap
;
3545 pagerFixMaplimit(pPager
);
3549 ** Free as much memory as possible from the pager.
3551 void sqlite3PagerShrink(Pager
*pPager
){
3552 sqlite3PcacheShrink(pPager
->pPCache
);
3556 ** Adjust settings of the pager to those specified in the pgFlags parameter.
3558 ** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness
3559 ** of the database to damage due to OS crashes or power failures by
3560 ** changing the number of syncs()s when writing the journals.
3561 ** There are four levels:
3563 ** OFF sqlite3OsSync() is never called. This is the default
3564 ** for temporary and transient files.
3566 ** NORMAL The journal is synced once before writes begin on the
3567 ** database. This is normally adequate protection, but
3568 ** it is theoretically possible, though very unlikely,
3569 ** that an inopertune power failure could leave the journal
3570 ** in a state which would cause damage to the database
3571 ** when it is rolled back.
3573 ** FULL The journal is synced twice before writes begin on the
3574 ** database (with some additional information - the nRec field
3575 ** of the journal header - being written in between the two
3576 ** syncs). If we assume that writing a
3577 ** single disk sector is atomic, then this mode provides
3578 ** assurance that the journal will not be corrupted to the
3579 ** point of causing damage to the database during rollback.
3581 ** EXTRA This is like FULL except that is also syncs the directory
3582 ** that contains the rollback journal after the rollback
3583 ** journal is unlinked.
3585 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
3586 ** to mean that no syncs ever occur. NORMAL means that the WAL is synced
3587 ** prior to the start of checkpoint and that the database file is synced
3588 ** at the conclusion of the checkpoint if the entire content of the WAL
3589 ** was written back into the database. But no sync operations occur for
3590 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
3591 ** file is synced following each commit operation, in addition to the
3592 ** syncs associated with NORMAL. There is no difference between FULL
3593 ** and EXTRA for WAL mode.
3595 ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
3596 ** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
3597 ** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
3598 ** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
3599 ** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
3600 ** synchronous=FULL versus synchronous=NORMAL setting determines when
3601 ** the xSync primitive is called and is relevant to all platforms.
3603 ** Numeric values associated with these states are OFF==1, NORMAL=2,
3606 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
3607 void sqlite3PagerSetFlags(
3608 Pager
*pPager
, /* The pager to set safety level for */
3609 unsigned pgFlags
/* Various flags */
3611 unsigned level
= pgFlags
& PAGER_SYNCHRONOUS_MASK
;
3612 if( pPager
->tempFile
){
3614 pPager
->fullSync
= 0;
3615 pPager
->extraSync
= 0;
3617 pPager
->noSync
= level
==PAGER_SYNCHRONOUS_OFF
?1:0;
3618 pPager
->fullSync
= level
>=PAGER_SYNCHRONOUS_FULL
?1:0;
3619 pPager
->extraSync
= level
==PAGER_SYNCHRONOUS_EXTRA
?1:0;
3621 if( pPager
->noSync
){
3622 pPager
->syncFlags
= 0;
3623 }else if( pgFlags
& PAGER_FULLFSYNC
){
3624 pPager
->syncFlags
= SQLITE_SYNC_FULL
;
3626 pPager
->syncFlags
= SQLITE_SYNC_NORMAL
;
3628 pPager
->walSyncFlags
= (pPager
->syncFlags
<<2);
3629 if( pPager
->fullSync
){
3630 pPager
->walSyncFlags
|= pPager
->syncFlags
;
3632 if( (pgFlags
& PAGER_CKPT_FULLFSYNC
) && !pPager
->noSync
){
3633 pPager
->walSyncFlags
|= (SQLITE_SYNC_FULL
<<2);
3635 if( pgFlags
& PAGER_CACHESPILL
){
3636 pPager
->doNotSpill
&= ~SPILLFLAG_OFF
;
3638 pPager
->doNotSpill
|= SPILLFLAG_OFF
;
3644 ** The following global variable is incremented whenever the library
3645 ** attempts to open a temporary file. This information is used for
3646 ** testing and analysis only.
3649 int sqlite3_opentemp_count
= 0;
3653 ** Open a temporary file.
3655 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
3656 ** or some other error code if we fail. The OS will automatically
3657 ** delete the temporary file when it is closed.
3659 ** The flags passed to the VFS layer xOpen() call are those specified
3660 ** by parameter vfsFlags ORed with the following:
3662 ** SQLITE_OPEN_READWRITE
3663 ** SQLITE_OPEN_CREATE
3664 ** SQLITE_OPEN_EXCLUSIVE
3665 ** SQLITE_OPEN_DELETEONCLOSE
3667 static int pagerOpentemp(
3668 Pager
*pPager
, /* The pager object */
3669 sqlite3_file
*pFile
, /* Write the file descriptor here */
3670 int vfsFlags
/* Flags passed through to the VFS */
3672 int rc
; /* Return code */
3675 sqlite3_opentemp_count
++; /* Used for testing and analysis only */
3678 vfsFlags
|= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
|
3679 SQLITE_OPEN_EXCLUSIVE
| SQLITE_OPEN_DELETEONCLOSE
;
3680 rc
= sqlite3OsOpen(pPager
->pVfs
, 0, pFile
, vfsFlags
, 0);
3681 assert( rc
!=SQLITE_OK
|| isOpen(pFile
) );
3686 ** Set the busy handler function.
3688 ** The pager invokes the busy-handler if sqlite3OsLock() returns
3689 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
3690 ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
3691 ** lock. It does *not* invoke the busy handler when upgrading from
3692 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
3693 ** (which occurs during hot-journal rollback). Summary:
3695 ** Transition | Invokes xBusyHandler
3696 ** --------------------------------------------------------
3697 ** NO_LOCK -> SHARED_LOCK | Yes
3698 ** SHARED_LOCK -> RESERVED_LOCK | No
3699 ** SHARED_LOCK -> EXCLUSIVE_LOCK | No
3700 ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
3702 ** If the busy-handler callback returns non-zero, the lock is
3703 ** retried. If it returns zero, then the SQLITE_BUSY error is
3704 ** returned to the caller of the pager API function.
3706 void sqlite3PagerSetBusyhandler(
3707 Pager
*pPager
, /* Pager object */
3708 int (*xBusyHandler
)(void *), /* Pointer to busy-handler function */
3709 void *pBusyHandlerArg
/* Argument to pass to xBusyHandler */
3711 pPager
->xBusyHandler
= xBusyHandler
;
3712 pPager
->pBusyHandlerArg
= pBusyHandlerArg
;
3714 if( isOpen(pPager
->fd
) ){
3715 void **ap
= (void **)&pPager
->xBusyHandler
;
3716 assert( ((int(*)(void *))(ap
[0]))==xBusyHandler
);
3717 assert( ap
[1]==pBusyHandlerArg
);
3718 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_BUSYHANDLER
, (void *)ap
);
3723 ** Change the page size used by the Pager object. The new page size
3724 ** is passed in *pPageSize.
3726 ** If the pager is in the error state when this function is called, it
3727 ** is a no-op. The value returned is the error state error code (i.e.
3728 ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
3730 ** Otherwise, if all of the following are true:
3732 ** * the new page size (value of *pPageSize) is valid (a power
3733 ** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
3735 ** * there are no outstanding page references, and
3737 ** * the database is either not an in-memory database or it is
3738 ** an in-memory database that currently consists of zero pages.
3740 ** then the pager object page size is set to *pPageSize.
3742 ** If the page size is changed, then this function uses sqlite3PagerMalloc()
3743 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
3744 ** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
3745 ** In all other cases, SQLITE_OK is returned.
3747 ** If the page size is not changed, either because one of the enumerated
3748 ** conditions above is not true, the pager was in error state when this
3749 ** function was called, or because the memory allocation attempt failed,
3750 ** then *pPageSize is set to the old, retained page size before returning.
3752 int sqlite3PagerSetPagesize(Pager
*pPager
, u32
*pPageSize
, int nReserve
){
3755 /* It is not possible to do a full assert_pager_state() here, as this
3756 ** function may be called from within PagerOpen(), before the state
3757 ** of the Pager object is internally consistent.
3759 ** At one point this function returned an error if the pager was in
3760 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
3761 ** there is at least one outstanding page reference, this function
3762 ** is a no-op for that case anyhow.
3765 u32 pageSize
= *pPageSize
;
3766 assert( pageSize
==0 || (pageSize
>=512 && pageSize
<=SQLITE_MAX_PAGE_SIZE
) );
3767 if( (pPager
->memDb
==0 || pPager
->dbSize
==0)
3768 && sqlite3PcacheRefCount(pPager
->pPCache
)==0
3769 && pageSize
&& pageSize
!=(u32
)pPager
->pageSize
3771 char *pNew
= NULL
; /* New temp space */
3774 if( pPager
->eState
>PAGER_OPEN
&& isOpen(pPager
->fd
) ){
3775 rc
= sqlite3OsFileSize(pPager
->fd
, &nByte
);
3777 if( rc
==SQLITE_OK
){
3778 pNew
= (char *)sqlite3PageMalloc(pageSize
);
3779 if( !pNew
) rc
= SQLITE_NOMEM_BKPT
;
3782 if( rc
==SQLITE_OK
){
3783 pager_reset(pPager
);
3784 rc
= sqlite3PcacheSetPageSize(pPager
->pPCache
, pageSize
);
3786 if( rc
==SQLITE_OK
){
3787 sqlite3PageFree(pPager
->pTmpSpace
);
3788 pPager
->pTmpSpace
= pNew
;
3789 pPager
->dbSize
= (Pgno
)((nByte
+pageSize
-1)/pageSize
);
3790 pPager
->pageSize
= pageSize
;
3792 sqlite3PageFree(pNew
);
3796 *pPageSize
= pPager
->pageSize
;
3797 if( rc
==SQLITE_OK
){
3798 if( nReserve
<0 ) nReserve
= pPager
->nReserve
;
3799 assert( nReserve
>=0 && nReserve
<1000 );
3800 pPager
->nReserve
= (i16
)nReserve
;
3801 pagerReportSize(pPager
);
3802 pagerFixMaplimit(pPager
);
3808 ** Return a pointer to the "temporary page" buffer held internally
3809 ** by the pager. This is a buffer that is big enough to hold the
3810 ** entire content of a database page. This buffer is used internally
3811 ** during rollback and will be overwritten whenever a rollback
3812 ** occurs. But other modules are free to use it too, as long as
3813 ** no rollbacks are happening.
3815 void *sqlite3PagerTempSpace(Pager
*pPager
){
3816 return pPager
->pTmpSpace
;
3820 ** Attempt to set the maximum database page count if mxPage is positive.
3821 ** Make no changes if mxPage is zero or negative. And never reduce the
3822 ** maximum page count below the current size of the database.
3824 ** Regardless of mxPage, return the current maximum page count.
3826 int sqlite3PagerMaxPageCount(Pager
*pPager
, int mxPage
){
3828 pPager
->mxPgno
= mxPage
;
3830 assert( pPager
->eState
!=PAGER_OPEN
); /* Called only by OP_MaxPgcnt */
3831 assert( pPager
->mxPgno
>=pPager
->dbSize
); /* OP_MaxPgcnt enforces this */
3832 return pPager
->mxPgno
;
3836 ** The following set of routines are used to disable the simulated
3837 ** I/O error mechanism. These routines are used to avoid simulated
3838 ** errors in places where we do not care about errors.
3840 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
3841 ** and generate no code.
3844 extern int sqlite3_io_error_pending
;
3845 extern int sqlite3_io_error_hit
;
3846 static int saved_cnt
;
3847 void disable_simulated_io_errors(void){
3848 saved_cnt
= sqlite3_io_error_pending
;
3849 sqlite3_io_error_pending
= -1;
3851 void enable_simulated_io_errors(void){
3852 sqlite3_io_error_pending
= saved_cnt
;
3855 # define disable_simulated_io_errors()
3856 # define enable_simulated_io_errors()
3860 ** Read the first N bytes from the beginning of the file into memory
3861 ** that pDest points to.
3863 ** If the pager was opened on a transient file (zFilename==""), or
3864 ** opened on a file less than N bytes in size, the output buffer is
3865 ** zeroed and SQLITE_OK returned. The rationale for this is that this
3866 ** function is used to read database headers, and a new transient or
3867 ** zero sized database has a header than consists entirely of zeroes.
3869 ** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
3870 ** the error code is returned to the caller and the contents of the
3871 ** output buffer undefined.
3873 int sqlite3PagerReadFileheader(Pager
*pPager
, int N
, unsigned char *pDest
){
3875 memset(pDest
, 0, N
);
3876 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
3878 /* This routine is only called by btree immediately after creating
3879 ** the Pager object. There has not been an opportunity to transition
3882 assert( !pagerUseWal(pPager
) );
3884 if( isOpen(pPager
->fd
) ){
3885 IOTRACE(("DBHDR %p 0 %d\n", pPager
, N
))
3886 rc
= sqlite3OsRead(pPager
->fd
, pDest
, N
, 0);
3887 if( rc
==SQLITE_IOERR_SHORT_READ
){
3895 ** This function may only be called when a read-transaction is open on
3896 ** the pager. It returns the total number of pages in the database.
3898 ** However, if the file is between 1 and <page-size> bytes in size, then
3899 ** this is considered a 1 page file.
3901 void sqlite3PagerPagecount(Pager
*pPager
, int *pnPage
){
3902 assert( pPager
->eState
>=PAGER_READER
);
3903 assert( pPager
->eState
!=PAGER_WRITER_FINISHED
);
3904 *pnPage
= (int)pPager
->dbSize
;
3909 ** Try to obtain a lock of type locktype on the database file. If
3910 ** a similar or greater lock is already held, this function is a no-op
3911 ** (returning SQLITE_OK immediately).
3913 ** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
3914 ** the busy callback if the lock is currently not available. Repeat
3915 ** until the busy callback returns false or until the attempt to
3916 ** obtain the lock succeeds.
3918 ** Return SQLITE_OK on success and an error code if we cannot obtain
3919 ** the lock. If the lock is obtained successfully, set the Pager.state
3920 ** variable to locktype before returning.
3922 static int pager_wait_on_lock(Pager
*pPager
, int locktype
){
3923 int rc
; /* Return code */
3925 /* Check that this is either a no-op (because the requested lock is
3926 ** already held), or one of the transitions that the busy-handler
3927 ** may be invoked during, according to the comment above
3928 ** sqlite3PagerSetBusyhandler().
3930 assert( (pPager
->eLock
>=locktype
)
3931 || (pPager
->eLock
==NO_LOCK
&& locktype
==SHARED_LOCK
)
3932 || (pPager
->eLock
==RESERVED_LOCK
&& locktype
==EXCLUSIVE_LOCK
)
3936 rc
= pagerLockDb(pPager
, locktype
);
3937 }while( rc
==SQLITE_BUSY
&& pPager
->xBusyHandler(pPager
->pBusyHandlerArg
) );
3942 ** Function assertTruncateConstraint(pPager) checks that one of the
3943 ** following is true for all dirty pages currently in the page-cache:
3945 ** a) The page number is less than or equal to the size of the
3946 ** current database image, in pages, OR
3948 ** b) if the page content were written at this time, it would not
3949 ** be necessary to write the current content out to the sub-journal
3950 ** (as determined by function subjRequiresPage()).
3952 ** If the condition asserted by this function were not true, and the
3953 ** dirty page were to be discarded from the cache via the pagerStress()
3954 ** routine, pagerStress() would not write the current page content to
3955 ** the database file. If a savepoint transaction were rolled back after
3956 ** this happened, the correct behavior would be to restore the current
3957 ** content of the page. However, since this content is not present in either
3958 ** the database file or the portion of the rollback journal and
3959 ** sub-journal rolled back the content could not be restored and the
3960 ** database image would become corrupt. It is therefore fortunate that
3961 ** this circumstance cannot arise.
3963 #if defined(SQLITE_DEBUG)
3964 static void assertTruncateConstraintCb(PgHdr
*pPg
){
3965 assert( pPg
->flags
&PGHDR_DIRTY
);
3966 assert( !subjRequiresPage(pPg
) || pPg
->pgno
<=pPg
->pPager
->dbSize
);
3968 static void assertTruncateConstraint(Pager
*pPager
){
3969 sqlite3PcacheIterateDirty(pPager
->pPCache
, assertTruncateConstraintCb
);
3972 # define assertTruncateConstraint(pPager)
3976 ** Truncate the in-memory database file image to nPage pages. This
3977 ** function does not actually modify the database file on disk. It
3978 ** just sets the internal state of the pager object so that the
3979 ** truncation will be done when the current transaction is committed.
3981 ** This function is only called right before committing a transaction.
3982 ** Once this function has been called, the transaction must either be
3983 ** rolled back or committed. It is not safe to call this function and
3984 ** then continue writing to the database.
3986 void sqlite3PagerTruncateImage(Pager
*pPager
, Pgno nPage
){
3987 assert( pPager
->dbSize
>=nPage
);
3988 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
);
3989 pPager
->dbSize
= nPage
;
3991 /* At one point the code here called assertTruncateConstraint() to
3992 ** ensure that all pages being truncated away by this operation are,
3993 ** if one or more savepoints are open, present in the savepoint
3994 ** journal so that they can be restored if the savepoint is rolled
3995 ** back. This is no longer necessary as this function is now only
3996 ** called right before committing a transaction. So although the
3997 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
3998 ** they cannot be rolled back. So the assertTruncateConstraint() call
3999 ** is no longer correct. */
4004 ** This function is called before attempting a hot-journal rollback. It
4005 ** syncs the journal file to disk, then sets pPager->journalHdr to the
4006 ** size of the journal file so that the pager_playback() routine knows
4007 ** that the entire journal file has been synced.
4009 ** Syncing a hot-journal to disk before attempting to roll it back ensures
4010 ** that if a power-failure occurs during the rollback, the process that
4011 ** attempts rollback following system recovery sees the same journal
4012 ** content as this process.
4014 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
4015 ** an SQLite error code.
4017 static int pagerSyncHotJournal(Pager
*pPager
){
4019 if( !pPager
->noSync
){
4020 rc
= sqlite3OsSync(pPager
->jfd
, SQLITE_SYNC_NORMAL
);
4022 if( rc
==SQLITE_OK
){
4023 rc
= sqlite3OsFileSize(pPager
->jfd
, &pPager
->journalHdr
);
4028 #if SQLITE_MAX_MMAP_SIZE>0
4030 ** Obtain a reference to a memory mapped page object for page number pgno.
4031 ** The new object will use the pointer pData, obtained from xFetch().
4032 ** If successful, set *ppPage to point to the new page reference
4033 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
4036 ** Page references obtained by calling this function should be released
4037 ** by calling pagerReleaseMapPage().
4039 static int pagerAcquireMapPage(
4040 Pager
*pPager
, /* Pager object */
4041 Pgno pgno
, /* Page number */
4042 void *pData
, /* xFetch()'d data for this page */
4043 PgHdr
**ppPage
/* OUT: Acquired page object */
4045 PgHdr
*p
; /* Memory mapped page to return */
4047 if( pPager
->pMmapFreelist
){
4048 *ppPage
= p
= pPager
->pMmapFreelist
;
4049 pPager
->pMmapFreelist
= p
->pDirty
;
4051 assert( pPager
->nExtra
>=8 );
4052 memset(p
->pExtra
, 0, 8);
4054 *ppPage
= p
= (PgHdr
*)sqlite3MallocZero(sizeof(PgHdr
) + pPager
->nExtra
);
4056 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pgno
-1) * pPager
->pageSize
, pData
);
4057 return SQLITE_NOMEM_BKPT
;
4059 p
->pExtra
= (void *)&p
[1];
4060 p
->flags
= PGHDR_MMAP
;
4065 assert( p
->pExtra
==(void *)&p
[1] );
4066 assert( p
->pPage
==0 );
4067 assert( p
->flags
==PGHDR_MMAP
);
4068 assert( p
->pPager
==pPager
);
4069 assert( p
->nRef
==1 );
4080 ** Release a reference to page pPg. pPg must have been returned by an
4081 ** earlier call to pagerAcquireMapPage().
4083 static void pagerReleaseMapPage(PgHdr
*pPg
){
4084 Pager
*pPager
= pPg
->pPager
;
4086 pPg
->pDirty
= pPager
->pMmapFreelist
;
4087 pPager
->pMmapFreelist
= pPg
;
4089 assert( pPager
->fd
->pMethods
->iVersion
>=3 );
4090 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pPg
->pgno
-1)*pPager
->pageSize
, pPg
->pData
);
4094 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
4096 static void pagerFreeMapHdrs(Pager
*pPager
){
4099 for(p
=pPager
->pMmapFreelist
; p
; p
=pNext
){
4107 ** Shutdown the page cache. Free all memory and close all files.
4109 ** If a transaction was in progress when this routine is called, that
4110 ** transaction is rolled back. All outstanding pages are invalidated
4111 ** and their memory is freed. Any attempt to use a page associated
4112 ** with this page cache after this function returns will likely
4113 ** result in a coredump.
4115 ** This function always succeeds. If a transaction is active an attempt
4116 ** is made to roll it back. If an error occurs during the rollback
4117 ** a hot journal may be left in the filesystem but no error is returned
4120 int sqlite3PagerClose(Pager
*pPager
, sqlite3
*db
){
4121 u8
*pTmp
= (u8
*)pPager
->pTmpSpace
;
4123 assert( db
|| pagerUseWal(pPager
)==0 );
4124 assert( assert_pager_state(pPager
) );
4125 disable_simulated_io_errors();
4126 sqlite3BeginBenignMalloc();
4127 pagerFreeMapHdrs(pPager
);
4128 /* pPager->errCode = 0; */
4129 pPager
->exclusiveMode
= 0;
4130 #ifndef SQLITE_OMIT_WAL
4131 assert( db
|| pPager
->pWal
==0 );
4132 sqlite3WalClose(pPager
->pWal
, db
, pPager
->walSyncFlags
, pPager
->pageSize
,
4133 (db
&& (db
->flags
& SQLITE_NoCkptOnClose
) ? 0 : pTmp
)
4137 pager_reset(pPager
);
4139 pager_unlock(pPager
);
4141 /* If it is open, sync the journal file before calling UnlockAndRollback.
4142 ** If this is not done, then an unsynced portion of the open journal
4143 ** file may be played back into the database. If a power failure occurs
4144 ** while this is happening, the database could become corrupt.
4146 ** If an error occurs while trying to sync the journal, shift the pager
4147 ** into the ERROR state. This causes UnlockAndRollback to unlock the
4148 ** database and close the journal file without attempting to roll it
4149 ** back or finalize it. The next database user will have to do hot-journal
4150 ** rollback before accessing the database file.
4152 if( isOpen(pPager
->jfd
) ){
4153 pager_error(pPager
, pagerSyncHotJournal(pPager
));
4155 pagerUnlockAndRollback(pPager
);
4157 sqlite3EndBenignMalloc();
4158 enable_simulated_io_errors();
4159 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager
)));
4160 IOTRACE(("CLOSE %p\n", pPager
))
4161 sqlite3OsClose(pPager
->jfd
);
4162 sqlite3OsClose(pPager
->fd
);
4163 sqlite3PageFree(pTmp
);
4164 sqlite3PcacheClose(pPager
->pPCache
);
4166 #ifdef SQLITE_HAS_CODEC
4167 if( pPager
->xCodecFree
) pPager
->xCodecFree(pPager
->pCodec
);
4170 assert( !pPager
->aSavepoint
&& !pPager
->pInJournal
);
4171 assert( !isOpen(pPager
->jfd
) && !isOpen(pPager
->sjfd
) );
4173 sqlite3_free(pPager
);
4177 #if !defined(NDEBUG) || defined(SQLITE_TEST)
4179 ** Return the page number for page pPg.
4181 Pgno
sqlite3PagerPagenumber(DbPage
*pPg
){
4187 ** Increment the reference count for page pPg.
4189 void sqlite3PagerRef(DbPage
*pPg
){
4190 sqlite3PcacheRef(pPg
);
4194 ** Sync the journal. In other words, make sure all the pages that have
4195 ** been written to the journal have actually reached the surface of the
4196 ** disk and can be restored in the event of a hot-journal rollback.
4198 ** If the Pager.noSync flag is set, then this function is a no-op.
4199 ** Otherwise, the actions required depend on the journal-mode and the
4200 ** device characteristics of the file-system, as follows:
4202 ** * If the journal file is an in-memory journal file, no action need
4205 ** * Otherwise, if the device does not support the SAFE_APPEND property,
4206 ** then the nRec field of the most recently written journal header
4207 ** is updated to contain the number of journal records that have
4208 ** been written following it. If the pager is operating in full-sync
4209 ** mode, then the journal file is synced before this field is updated.
4211 ** * If the device does not support the SEQUENTIAL property, then
4212 ** journal file is synced.
4214 ** Or, in pseudo-code:
4216 ** if( NOT <in-memory journal> ){
4217 ** if( NOT SAFE_APPEND ){
4218 ** if( <full-sync mode> ) xSync(<journal file>);
4219 ** <update nRec field>
4221 ** if( NOT SEQUENTIAL ) xSync(<journal file>);
4224 ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
4225 ** page currently held in memory before returning SQLITE_OK. If an IO
4226 ** error is encountered, then the IO error code is returned to the caller.
4228 static int syncJournal(Pager
*pPager
, int newHdr
){
4229 int rc
; /* Return code */
4231 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
4232 || pPager
->eState
==PAGER_WRITER_DBMOD
4234 assert( assert_pager_state(pPager
) );
4235 assert( !pagerUseWal(pPager
) );
4237 rc
= sqlite3PagerExclusiveLock(pPager
);
4238 if( rc
!=SQLITE_OK
) return rc
;
4240 if( !pPager
->noSync
){
4241 assert( !pPager
->tempFile
);
4242 if( isOpen(pPager
->jfd
) && pPager
->journalMode
!=PAGER_JOURNALMODE_MEMORY
){
4243 const int iDc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
4244 assert( isOpen(pPager
->jfd
) );
4246 if( 0==(iDc
&SQLITE_IOCAP_SAFE_APPEND
) ){
4247 /* This block deals with an obscure problem. If the last connection
4248 ** that wrote to this database was operating in persistent-journal
4249 ** mode, then the journal file may at this point actually be larger
4250 ** than Pager.journalOff bytes. If the next thing in the journal
4251 ** file happens to be a journal-header (written as part of the
4252 ** previous connection's transaction), and a crash or power-failure
4253 ** occurs after nRec is updated but before this connection writes
4254 ** anything else to the journal file (or commits/rolls back its
4255 ** transaction), then SQLite may become confused when doing the
4256 ** hot-journal rollback following recovery. It may roll back all
4257 ** of this connections data, then proceed to rolling back the old,
4258 ** out-of-date data that follows it. Database corruption.
4260 ** To work around this, if the journal file does appear to contain
4261 ** a valid header following Pager.journalOff, then write a 0x00
4262 ** byte to the start of it to prevent it from being recognized.
4264 ** Variable iNextHdrOffset is set to the offset at which this
4265 ** problematic header will occur, if it exists. aMagic is used
4266 ** as a temporary buffer to inspect the first couple of bytes of
4267 ** the potential journal header.
4271 u8 zHeader
[sizeof(aJournalMagic
)+4];
4273 memcpy(zHeader
, aJournalMagic
, sizeof(aJournalMagic
));
4274 put32bits(&zHeader
[sizeof(aJournalMagic
)], pPager
->nRec
);
4276 iNextHdrOffset
= journalHdrOffset(pPager
);
4277 rc
= sqlite3OsRead(pPager
->jfd
, aMagic
, 8, iNextHdrOffset
);
4278 if( rc
==SQLITE_OK
&& 0==memcmp(aMagic
, aJournalMagic
, 8) ){
4279 static const u8 zerobyte
= 0;
4280 rc
= sqlite3OsWrite(pPager
->jfd
, &zerobyte
, 1, iNextHdrOffset
);
4282 if( rc
!=SQLITE_OK
&& rc
!=SQLITE_IOERR_SHORT_READ
){
4286 /* Write the nRec value into the journal file header. If in
4287 ** full-synchronous mode, sync the journal first. This ensures that
4288 ** all data has really hit the disk before nRec is updated to mark
4289 ** it as a candidate for rollback.
4291 ** This is not required if the persistent media supports the
4292 ** SAFE_APPEND property. Because in this case it is not possible
4293 ** for garbage data to be appended to the file, the nRec field
4294 ** is populated with 0xFFFFFFFF when the journal header is written
4295 ** and never needs to be updated.
4297 if( pPager
->fullSync
&& 0==(iDc
&SQLITE_IOCAP_SEQUENTIAL
) ){
4298 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager
)));
4299 IOTRACE(("JSYNC %p\n", pPager
))
4300 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
);
4301 if( rc
!=SQLITE_OK
) return rc
;
4303 IOTRACE(("JHDR %p %lld\n", pPager
, pPager
->journalHdr
));
4304 rc
= sqlite3OsWrite(
4305 pPager
->jfd
, zHeader
, sizeof(zHeader
), pPager
->journalHdr
4307 if( rc
!=SQLITE_OK
) return rc
;
4309 if( 0==(iDc
&SQLITE_IOCAP_SEQUENTIAL
) ){
4310 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager
)));
4311 IOTRACE(("JSYNC %p\n", pPager
))
4312 rc
= sqlite3OsSync(pPager
->jfd
, pPager
->syncFlags
|
4313 (pPager
->syncFlags
==SQLITE_SYNC_FULL
?SQLITE_SYNC_DATAONLY
:0)
4315 if( rc
!=SQLITE_OK
) return rc
;
4318 pPager
->journalHdr
= pPager
->journalOff
;
4319 if( newHdr
&& 0==(iDc
&SQLITE_IOCAP_SAFE_APPEND
) ){
4321 rc
= writeJournalHdr(pPager
);
4322 if( rc
!=SQLITE_OK
) return rc
;
4325 pPager
->journalHdr
= pPager
->journalOff
;
4329 /* Unless the pager is in noSync mode, the journal file was just
4330 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
4333 sqlite3PcacheClearSyncFlags(pPager
->pPCache
);
4334 pPager
->eState
= PAGER_WRITER_DBMOD
;
4335 assert( assert_pager_state(pPager
) );
4340 ** The argument is the first in a linked list of dirty pages connected
4341 ** by the PgHdr.pDirty pointer. This function writes each one of the
4342 ** in-memory pages in the list to the database file. The argument may
4343 ** be NULL, representing an empty list. In this case this function is
4346 ** The pager must hold at least a RESERVED lock when this function
4347 ** is called. Before writing anything to the database file, this lock
4348 ** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
4349 ** SQLITE_BUSY is returned and no data is written to the database file.
4351 ** If the pager is a temp-file pager and the actual file-system file
4352 ** is not yet open, it is created and opened before any data is
4355 ** Once the lock has been upgraded and, if necessary, the file opened,
4356 ** the pages are written out to the database file in list order. Writing
4357 ** a page is skipped if it meets either of the following criteria:
4359 ** * The page number is greater than Pager.dbSize, or
4360 ** * The PGHDR_DONT_WRITE flag is set on the page.
4362 ** If writing out a page causes the database file to grow, Pager.dbFileSize
4363 ** is updated accordingly. If page 1 is written out, then the value cached
4364 ** in Pager.dbFileVers[] is updated to match the new value stored in
4365 ** the database file.
4367 ** If everything is successful, SQLITE_OK is returned. If an IO error
4368 ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
4369 ** be obtained, SQLITE_BUSY is returned.
4371 static int pager_write_pagelist(Pager
*pPager
, PgHdr
*pList
){
4372 int rc
= SQLITE_OK
; /* Return code */
4374 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
4375 assert( !pagerUseWal(pPager
) );
4376 assert( pPager
->tempFile
|| pPager
->eState
==PAGER_WRITER_DBMOD
);
4377 assert( pPager
->eLock
==EXCLUSIVE_LOCK
);
4378 assert( isOpen(pPager
->fd
) || pList
->pDirty
==0 );
4380 /* If the file is a temp-file has not yet been opened, open it now. It
4381 ** is not possible for rc to be other than SQLITE_OK if this branch
4382 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
4384 if( !isOpen(pPager
->fd
) ){
4385 assert( pPager
->tempFile
&& rc
==SQLITE_OK
);
4386 rc
= pagerOpentemp(pPager
, pPager
->fd
, pPager
->vfsFlags
);
4389 /* Before the first write, give the VFS a hint of what the final
4390 ** file size will be.
4392 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->fd
) );
4394 && pPager
->dbHintSize
<pPager
->dbSize
4395 && (pList
->pDirty
|| pList
->pgno
>pPager
->dbHintSize
)
4397 sqlite3_int64 szFile
= pPager
->pageSize
* (sqlite3_int64
)pPager
->dbSize
;
4398 sqlite3OsFileControlHint(pPager
->fd
, SQLITE_FCNTL_SIZE_HINT
, &szFile
);
4399 pPager
->dbHintSize
= pPager
->dbSize
;
4402 while( rc
==SQLITE_OK
&& pList
){
4403 Pgno pgno
= pList
->pgno
;
4405 /* If there are dirty pages in the page cache with page numbers greater
4406 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
4407 ** make the file smaller (presumably by auto-vacuum code). Do not write
4408 ** any such pages to the file.
4410 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
4411 ** set (set by sqlite3PagerDontWrite()).
4413 if( pgno
<=pPager
->dbSize
&& 0==(pList
->flags
&PGHDR_DONT_WRITE
) ){
4414 i64 offset
= (pgno
-1)*(i64
)pPager
->pageSize
; /* Offset to write */
4415 char *pData
; /* Data to write */
4417 assert( (pList
->flags
&PGHDR_NEED_SYNC
)==0 );
4418 if( pList
->pgno
==1 ) pager_write_changecounter(pList
);
4420 /* Encode the database */
4421 CODEC2(pPager
, pList
->pData
, pgno
, 6, return SQLITE_NOMEM_BKPT
, pData
);
4423 /* Write out the page data. */
4424 rc
= sqlite3OsWrite(pPager
->fd
, pData
, pPager
->pageSize
, offset
);
4426 /* If page 1 was just written, update Pager.dbFileVers to match
4427 ** the value now stored in the database file. If writing this
4428 ** page caused the database file to grow, update dbFileSize.
4431 memcpy(&pPager
->dbFileVers
, &pData
[24], sizeof(pPager
->dbFileVers
));
4433 if( pgno
>pPager
->dbFileSize
){
4434 pPager
->dbFileSize
= pgno
;
4436 pPager
->aStat
[PAGER_STAT_WRITE
]++;
4438 /* Update any backup objects copying the contents of this pager. */
4439 sqlite3BackupUpdate(pPager
->pBackup
, pgno
, (u8
*)pList
->pData
);
4441 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
4442 PAGERID(pPager
), pgno
, pager_pagehash(pList
)));
4443 IOTRACE(("PGOUT %p %d\n", pPager
, pgno
));
4444 PAGER_INCR(sqlite3_pager_writedb_count
);
4446 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager
), pgno
));
4448 pager_set_pagehash(pList
);
4449 pList
= pList
->pDirty
;
4456 ** Ensure that the sub-journal file is open. If it is already open, this
4457 ** function is a no-op.
4459 ** SQLITE_OK is returned if everything goes according to plan. An
4460 ** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
4463 static int openSubJournal(Pager
*pPager
){
4465 if( !isOpen(pPager
->sjfd
) ){
4466 const int flags
= SQLITE_OPEN_SUBJOURNAL
| SQLITE_OPEN_READWRITE
4467 | SQLITE_OPEN_CREATE
| SQLITE_OPEN_EXCLUSIVE
4468 | SQLITE_OPEN_DELETEONCLOSE
;
4469 int nStmtSpill
= sqlite3Config
.nStmtSpill
;
4470 if( pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
|| pPager
->subjInMemory
){
4473 rc
= sqlite3JournalOpen(pPager
->pVfs
, 0, pPager
->sjfd
, flags
, nStmtSpill
);
4479 ** Append a record of the current state of page pPg to the sub-journal.
4481 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
4482 ** for all open savepoints before returning.
4484 ** This function returns SQLITE_OK if everything is successful, an IO
4485 ** error code if the attempt to write to the sub-journal fails, or
4486 ** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
4489 static int subjournalPage(PgHdr
*pPg
){
4491 Pager
*pPager
= pPg
->pPager
;
4492 if( pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
4494 /* Open the sub-journal, if it has not already been opened */
4495 assert( pPager
->useJournal
);
4496 assert( isOpen(pPager
->jfd
) || pagerUseWal(pPager
) );
4497 assert( isOpen(pPager
->sjfd
) || pPager
->nSubRec
==0 );
4498 assert( pagerUseWal(pPager
)
4499 || pageInJournal(pPager
, pPg
)
4500 || pPg
->pgno
>pPager
->dbOrigSize
4502 rc
= openSubJournal(pPager
);
4504 /* If the sub-journal was opened successfully (or was already open),
4505 ** write the journal record into the file. */
4506 if( rc
==SQLITE_OK
){
4507 void *pData
= pPg
->pData
;
4508 i64 offset
= (i64
)pPager
->nSubRec
*(4+pPager
->pageSize
);
4511 #if SQLITE_HAS_CODEC
4512 if( !pPager
->subjInMemory
){
4513 CODEC2(pPager
, pData
, pPg
->pgno
, 7, return SQLITE_NOMEM_BKPT
, pData2
);
4517 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager
), pPg
->pgno
));
4518 rc
= write32bits(pPager
->sjfd
, offset
, pPg
->pgno
);
4519 if( rc
==SQLITE_OK
){
4520 rc
= sqlite3OsWrite(pPager
->sjfd
, pData2
, pPager
->pageSize
, offset
+4);
4524 if( rc
==SQLITE_OK
){
4526 assert( pPager
->nSavepoint
>0 );
4527 rc
= addToSavepointBitvecs(pPager
, pPg
->pgno
);
4531 static int subjournalPageIfRequired(PgHdr
*pPg
){
4532 if( subjRequiresPage(pPg
) ){
4533 return subjournalPage(pPg
);
4540 ** This function is called by the pcache layer when it has reached some
4541 ** soft memory limit. The first argument is a pointer to a Pager object
4542 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
4543 ** database). The second argument is a reference to a page that is
4544 ** currently dirty but has no outstanding references. The page
4545 ** is always associated with the Pager object passed as the first
4548 ** The job of this function is to make pPg clean by writing its contents
4549 ** out to the database file, if possible. This may involve syncing the
4552 ** If successful, sqlite3PcacheMakeClean() is called on the page and
4553 ** SQLITE_OK returned. If an IO error occurs while trying to make the
4554 ** page clean, the IO error code is returned. If the page cannot be
4555 ** made clean for some other reason, but no error occurs, then SQLITE_OK
4556 ** is returned by sqlite3PcacheMakeClean() is not called.
4558 static int pagerStress(void *p
, PgHdr
*pPg
){
4559 Pager
*pPager
= (Pager
*)p
;
4562 assert( pPg
->pPager
==pPager
);
4563 assert( pPg
->flags
&PGHDR_DIRTY
);
4565 /* The doNotSpill NOSYNC bit is set during times when doing a sync of
4566 ** journal (and adding a new header) is not allowed. This occurs
4567 ** during calls to sqlite3PagerWrite() while trying to journal multiple
4568 ** pages belonging to the same sector.
4570 ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
4571 ** regardless of whether or not a sync is required. This is set during
4572 ** a rollback or by user request, respectively.
4574 ** Spilling is also prohibited when in an error state since that could
4575 ** lead to database corruption. In the current implementation it
4576 ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
4577 ** while in the error state, hence it is impossible for this routine to
4578 ** be called in the error state. Nevertheless, we include a NEVER()
4579 ** test for the error state as a safeguard against future changes.
4581 if( NEVER(pPager
->errCode
) ) return SQLITE_OK
;
4582 testcase( pPager
->doNotSpill
& SPILLFLAG_ROLLBACK
);
4583 testcase( pPager
->doNotSpill
& SPILLFLAG_OFF
);
4584 testcase( pPager
->doNotSpill
& SPILLFLAG_NOSYNC
);
4585 if( pPager
->doNotSpill
4586 && ((pPager
->doNotSpill
& (SPILLFLAG_ROLLBACK
|SPILLFLAG_OFF
))!=0
4587 || (pPg
->flags
& PGHDR_NEED_SYNC
)!=0)
4593 if( pagerUseWal(pPager
) ){
4594 /* Write a single frame for this page to the log. */
4595 rc
= subjournalPageIfRequired(pPg
);
4596 if( rc
==SQLITE_OK
){
4597 rc
= pagerWalFrames(pPager
, pPg
, 0, 0);
4601 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
4602 if( pPager
->tempFile
==0 ){
4603 rc
= sqlite3JournalCreate(pPager
->jfd
);
4604 if( rc
!=SQLITE_OK
) return pager_error(pPager
, rc
);
4608 /* Sync the journal file if required. */
4609 if( pPg
->flags
&PGHDR_NEED_SYNC
4610 || pPager
->eState
==PAGER_WRITER_CACHEMOD
4612 rc
= syncJournal(pPager
, 1);
4615 /* Write the contents of the page out to the database file. */
4616 if( rc
==SQLITE_OK
){
4617 assert( (pPg
->flags
&PGHDR_NEED_SYNC
)==0 );
4618 rc
= pager_write_pagelist(pPager
, pPg
);
4622 /* Mark the page as clean. */
4623 if( rc
==SQLITE_OK
){
4624 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager
), pPg
->pgno
));
4625 sqlite3PcacheMakeClean(pPg
);
4628 return pager_error(pPager
, rc
);
4632 ** Flush all unreferenced dirty pages to disk.
4634 int sqlite3PagerFlush(Pager
*pPager
){
4635 int rc
= pPager
->errCode
;
4637 PgHdr
*pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
4638 assert( assert_pager_state(pPager
) );
4639 while( rc
==SQLITE_OK
&& pList
){
4640 PgHdr
*pNext
= pList
->pDirty
;
4641 if( pList
->nRef
==0 ){
4642 rc
= pagerStress((void*)pPager
, pList
);
4652 ** Allocate and initialize a new Pager object and put a pointer to it
4653 ** in *ppPager. The pager should eventually be freed by passing it
4654 ** to sqlite3PagerClose().
4656 ** The zFilename argument is the path to the database file to open.
4657 ** If zFilename is NULL then a randomly-named temporary file is created
4658 ** and used as the file to be cached. Temporary files are be deleted
4659 ** automatically when they are closed. If zFilename is ":memory:" then
4660 ** all information is held in cache. It is never written to disk.
4661 ** This can be used to implement an in-memory database.
4663 ** The nExtra parameter specifies the number of bytes of space allocated
4664 ** along with each page reference. This space is available to the user
4665 ** via the sqlite3PagerGetExtra() API. When a new page is allocated, the
4666 ** first 8 bytes of this space are zeroed but the remainder is uninitialized.
4667 ** (The extra space is used by btree as the MemPage object.)
4669 ** The flags argument is used to specify properties that affect the
4670 ** operation of the pager. It should be passed some bitwise combination
4671 ** of the PAGER_* flags.
4673 ** The vfsFlags parameter is a bitmask to pass to the flags parameter
4674 ** of the xOpen() method of the supplied VFS when opening files.
4676 ** If the pager object is allocated and the specified file opened
4677 ** successfully, SQLITE_OK is returned and *ppPager set to point to
4678 ** the new pager object. If an error occurs, *ppPager is set to NULL
4679 ** and error code returned. This function may return SQLITE_NOMEM
4680 ** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
4681 ** various SQLITE_IO_XXX errors.
4683 int sqlite3PagerOpen(
4684 sqlite3_vfs
*pVfs
, /* The virtual file system to use */
4685 Pager
**ppPager
, /* OUT: Return the Pager structure here */
4686 const char *zFilename
, /* Name of the database file to open */
4687 int nExtra
, /* Extra bytes append to each in-memory page */
4688 int flags
, /* flags controlling this file */
4689 int vfsFlags
, /* flags passed through to sqlite3_vfs.xOpen() */
4690 void (*xReinit
)(DbPage
*) /* Function to reinitialize pages */
4693 Pager
*pPager
= 0; /* Pager object to allocate and return */
4694 int rc
= SQLITE_OK
; /* Return code */
4695 int tempFile
= 0; /* True for temp files (incl. in-memory files) */
4696 int memDb
= 0; /* True if this is an in-memory file */
4697 int readOnly
= 0; /* True if this is a read-only file */
4698 int journalFileSize
; /* Bytes to allocate for each journal fd */
4699 char *zPathname
= 0; /* Full path to database file */
4700 int nPathname
= 0; /* Number of bytes in zPathname */
4701 int useJournal
= (flags
& PAGER_OMIT_JOURNAL
)==0; /* False to omit journal */
4702 int pcacheSize
= sqlite3PcacheSize(); /* Bytes to allocate for PCache */
4703 u32 szPageDflt
= SQLITE_DEFAULT_PAGE_SIZE
; /* Default page size */
4704 const char *zUri
= 0; /* URI args to copy */
4705 int nUri
= 0; /* Number of bytes of URI args at *zUri */
4707 /* Figure out how much space is required for each journal file-handle
4708 ** (there are two of them, the main journal and the sub-journal). */
4709 journalFileSize
= ROUND8(sqlite3JournalSize(pVfs
));
4711 /* Set the output variable to NULL in case an error occurs. */
4714 #ifndef SQLITE_OMIT_MEMORYDB
4715 if( flags
& PAGER_MEMORY
){
4717 if( zFilename
&& zFilename
[0] ){
4718 zPathname
= sqlite3DbStrDup(0, zFilename
);
4719 if( zPathname
==0 ) return SQLITE_NOMEM_BKPT
;
4720 nPathname
= sqlite3Strlen30(zPathname
);
4726 /* Compute and store the full pathname in an allocated buffer pointed
4727 ** to by zPathname, length nPathname. Or, if this is a temporary file,
4728 ** leave both nPathname and zPathname set to 0.
4730 if( zFilename
&& zFilename
[0] ){
4732 nPathname
= pVfs
->mxPathname
+1;
4733 zPathname
= sqlite3DbMallocRaw(0, nPathname
*2);
4735 return SQLITE_NOMEM_BKPT
;
4737 zPathname
[0] = 0; /* Make sure initialized even if FullPathname() fails */
4738 rc
= sqlite3OsFullPathname(pVfs
, zFilename
, nPathname
, zPathname
);
4739 nPathname
= sqlite3Strlen30(zPathname
);
4740 z
= zUri
= &zFilename
[sqlite3Strlen30(zFilename
)+1];
4742 z
+= sqlite3Strlen30(z
)+1;
4743 z
+= sqlite3Strlen30(z
)+1;
4745 nUri
= (int)(&z
[1] - zUri
);
4747 if( rc
==SQLITE_OK
&& nPathname
+8>pVfs
->mxPathname
){
4748 /* This branch is taken when the journal path required by
4749 ** the database being opened will be more than pVfs->mxPathname
4750 ** bytes in length. This means the database cannot be opened,
4751 ** as it will not be possible to open the journal file or even
4752 ** check for a hot-journal before reading.
4754 rc
= SQLITE_CANTOPEN_BKPT
;
4756 if( rc
!=SQLITE_OK
){
4757 sqlite3DbFree(0, zPathname
);
4762 /* Allocate memory for the Pager structure, PCache object, the
4763 ** three file descriptors, the database file name and the journal
4764 ** file name. The layout in memory is as follows:
4766 ** Pager object (sizeof(Pager) bytes)
4767 ** PCache object (sqlite3PcacheSize() bytes)
4768 ** Database file handle (pVfs->szOsFile bytes)
4769 ** Sub-journal file handle (journalFileSize bytes)
4770 ** Main journal file handle (journalFileSize bytes)
4771 ** Database file name (nPathname+1 bytes)
4772 ** Journal file name (nPathname+8+1 bytes)
4774 pPtr
= (u8
*)sqlite3MallocZero(
4775 ROUND8(sizeof(*pPager
)) + /* Pager structure */
4776 ROUND8(pcacheSize
) + /* PCache object */
4777 ROUND8(pVfs
->szOsFile
) + /* The main db file */
4778 journalFileSize
* 2 + /* The two journal files */
4779 nPathname
+ 1 + nUri
+ /* zFilename */
4780 nPathname
+ 8 + 2 /* zJournal */
4781 #ifndef SQLITE_OMIT_WAL
4782 + nPathname
+ 4 + 2 /* zWal */
4785 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize
)) );
4787 sqlite3DbFree(0, zPathname
);
4788 return SQLITE_NOMEM_BKPT
;
4790 pPager
= (Pager
*)(pPtr
);
4791 pPager
->pPCache
= (PCache
*)(pPtr
+= ROUND8(sizeof(*pPager
)));
4792 pPager
->fd
= (sqlite3_file
*)(pPtr
+= ROUND8(pcacheSize
));
4793 pPager
->sjfd
= (sqlite3_file
*)(pPtr
+= ROUND8(pVfs
->szOsFile
));
4794 pPager
->jfd
= (sqlite3_file
*)(pPtr
+= journalFileSize
);
4795 pPager
->zFilename
= (char*)(pPtr
+= journalFileSize
);
4796 assert( EIGHT_BYTE_ALIGNMENT(pPager
->jfd
) );
4798 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
4800 assert( nPathname
>0 );
4801 pPager
->zJournal
= (char*)(pPtr
+= nPathname
+ 1 + nUri
);
4802 memcpy(pPager
->zFilename
, zPathname
, nPathname
);
4803 if( nUri
) memcpy(&pPager
->zFilename
[nPathname
+1], zUri
, nUri
);
4804 memcpy(pPager
->zJournal
, zPathname
, nPathname
);
4805 memcpy(&pPager
->zJournal
[nPathname
], "-journal\000", 8+2);
4806 sqlite3FileSuffix3(pPager
->zFilename
, pPager
->zJournal
);
4807 #ifndef SQLITE_OMIT_WAL
4808 pPager
->zWal
= &pPager
->zJournal
[nPathname
+8+1];
4809 memcpy(pPager
->zWal
, zPathname
, nPathname
);
4810 memcpy(&pPager
->zWal
[nPathname
], "-wal\000", 4+1);
4811 sqlite3FileSuffix3(pPager
->zFilename
, pPager
->zWal
);
4813 sqlite3DbFree(0, zPathname
);
4815 pPager
->pVfs
= pVfs
;
4816 pPager
->vfsFlags
= vfsFlags
;
4818 /* Open the pager file.
4820 if( zFilename
&& zFilename
[0] ){
4821 int fout
= 0; /* VFS flags returned by xOpen() */
4822 rc
= sqlite3OsOpen(pVfs
, pPager
->zFilename
, pPager
->fd
, vfsFlags
, &fout
);
4824 readOnly
= (fout
&SQLITE_OPEN_READONLY
);
4826 /* If the file was successfully opened for read/write access,
4827 ** choose a default page size in case we have to create the
4828 ** database file. The default page size is the maximum of:
4830 ** + SQLITE_DEFAULT_PAGE_SIZE,
4831 ** + The value returned by sqlite3OsSectorSize()
4832 ** + The largest page size that can be written atomically.
4834 if( rc
==SQLITE_OK
){
4835 int iDc
= sqlite3OsDeviceCharacteristics(pPager
->fd
);
4837 setSectorSize(pPager
);
4838 assert(SQLITE_DEFAULT_PAGE_SIZE
<=SQLITE_MAX_DEFAULT_PAGE_SIZE
);
4839 if( szPageDflt
<pPager
->sectorSize
){
4840 if( pPager
->sectorSize
>SQLITE_MAX_DEFAULT_PAGE_SIZE
){
4841 szPageDflt
= SQLITE_MAX_DEFAULT_PAGE_SIZE
;
4843 szPageDflt
= (u32
)pPager
->sectorSize
;
4846 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
4849 assert(SQLITE_IOCAP_ATOMIC512
==(512>>8));
4850 assert(SQLITE_IOCAP_ATOMIC64K
==(65536>>8));
4851 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE
<=65536);
4852 for(ii
=szPageDflt
; ii
<=SQLITE_MAX_DEFAULT_PAGE_SIZE
; ii
=ii
*2){
4853 if( iDc
&(SQLITE_IOCAP_ATOMIC
|(ii
>>8)) ){
4860 pPager
->noLock
= sqlite3_uri_boolean(zFilename
, "nolock", 0);
4861 if( (iDc
& SQLITE_IOCAP_IMMUTABLE
)!=0
4862 || sqlite3_uri_boolean(zFilename
, "immutable", 0) ){
4863 vfsFlags
|= SQLITE_OPEN_READONLY
;
4864 goto act_like_temp_file
;
4868 /* If a temporary file is requested, it is not opened immediately.
4869 ** In this case we accept the default page size and delay actually
4870 ** opening the file until the first call to OsWrite().
4872 ** This branch is also run for an in-memory database. An in-memory
4873 ** database is the same as a temp-file that is never written out to
4874 ** disk and uses an in-memory rollback journal.
4876 ** This branch also runs for files marked as immutable.
4880 pPager
->eState
= PAGER_READER
; /* Pretend we already have a lock */
4881 pPager
->eLock
= EXCLUSIVE_LOCK
; /* Pretend we are in EXCLUSIVE mode */
4882 pPager
->noLock
= 1; /* Do no locking */
4883 readOnly
= (vfsFlags
&SQLITE_OPEN_READONLY
);
4886 /* The following call to PagerSetPagesize() serves to set the value of
4887 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
4889 if( rc
==SQLITE_OK
){
4890 assert( pPager
->memDb
==0 );
4891 rc
= sqlite3PagerSetPagesize(pPager
, &szPageDflt
, -1);
4892 testcase( rc
!=SQLITE_OK
);
4895 /* Initialize the PCache object. */
4896 if( rc
==SQLITE_OK
){
4897 nExtra
= ROUND8(nExtra
);
4898 assert( nExtra
>=8 && nExtra
<1000 );
4899 rc
= sqlite3PcacheOpen(szPageDflt
, nExtra
, !memDb
,
4900 !memDb
?pagerStress
:0, (void *)pPager
, pPager
->pPCache
);
4903 /* If an error occurred above, free the Pager structure and close the file.
4905 if( rc
!=SQLITE_OK
){
4906 sqlite3OsClose(pPager
->fd
);
4907 sqlite3PageFree(pPager
->pTmpSpace
);
4908 sqlite3_free(pPager
);
4912 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager
->fd
), pPager
->zFilename
));
4913 IOTRACE(("OPEN %p %s\n", pPager
, pPager
->zFilename
))
4915 pPager
->useJournal
= (u8
)useJournal
;
4916 /* pPager->stmtOpen = 0; */
4917 /* pPager->stmtInUse = 0; */
4918 /* pPager->nRef = 0; */
4919 /* pPager->stmtSize = 0; */
4920 /* pPager->stmtJSize = 0; */
4921 /* pPager->nPage = 0; */
4922 pPager
->mxPgno
= SQLITE_MAX_PAGE_COUNT
;
4923 /* pPager->state = PAGER_UNLOCK; */
4924 /* pPager->errMask = 0; */
4925 pPager
->tempFile
= (u8
)tempFile
;
4926 assert( tempFile
==PAGER_LOCKINGMODE_NORMAL
4927 || tempFile
==PAGER_LOCKINGMODE_EXCLUSIVE
);
4928 assert( PAGER_LOCKINGMODE_EXCLUSIVE
==1 );
4929 pPager
->exclusiveMode
= (u8
)tempFile
;
4930 pPager
->changeCountDone
= pPager
->tempFile
;
4931 pPager
->memDb
= (u8
)memDb
;
4932 pPager
->readOnly
= (u8
)readOnly
;
4933 assert( useJournal
|| pPager
->tempFile
);
4934 pPager
->noSync
= pPager
->tempFile
;
4935 if( pPager
->noSync
){
4936 assert( pPager
->fullSync
==0 );
4937 assert( pPager
->extraSync
==0 );
4938 assert( pPager
->syncFlags
==0 );
4939 assert( pPager
->walSyncFlags
==0 );
4941 pPager
->fullSync
= 1;
4942 pPager
->extraSync
= 0;
4943 pPager
->syncFlags
= SQLITE_SYNC_NORMAL
;
4944 pPager
->walSyncFlags
= SQLITE_SYNC_NORMAL
| (SQLITE_SYNC_NORMAL
<<2);
4946 /* pPager->pFirst = 0; */
4947 /* pPager->pFirstSynced = 0; */
4948 /* pPager->pLast = 0; */
4949 pPager
->nExtra
= (u16
)nExtra
;
4950 pPager
->journalSizeLimit
= SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
;
4951 assert( isOpen(pPager
->fd
) || tempFile
);
4952 setSectorSize(pPager
);
4954 pPager
->journalMode
= PAGER_JOURNALMODE_OFF
;
4956 pPager
->journalMode
= PAGER_JOURNALMODE_MEMORY
;
4958 /* pPager->xBusyHandler = 0; */
4959 /* pPager->pBusyHandlerArg = 0; */
4960 pPager
->xReiniter
= xReinit
;
4961 setGetterMethod(pPager
);
4962 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
4963 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
4970 /* Verify that the database file has not be deleted or renamed out from
4971 ** under the pager. Return SQLITE_OK if the database is still were it ought
4972 ** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
4973 ** code from sqlite3OsAccess()) if the database has gone missing.
4975 static int databaseIsUnmoved(Pager
*pPager
){
4979 if( pPager
->tempFile
) return SQLITE_OK
;
4980 if( pPager
->dbSize
==0 ) return SQLITE_OK
;
4981 assert( pPager
->zFilename
&& pPager
->zFilename
[0] );
4982 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_HAS_MOVED
, &bHasMoved
);
4983 if( rc
==SQLITE_NOTFOUND
){
4984 /* If the HAS_MOVED file-control is unimplemented, assume that the file
4985 ** has not been moved. That is the historical behavior of SQLite: prior to
4986 ** version 3.8.3, it never checked */
4988 }else if( rc
==SQLITE_OK
&& bHasMoved
){
4989 rc
= SQLITE_READONLY_DBMOVED
;
4996 ** This function is called after transitioning from PAGER_UNLOCK to
4997 ** PAGER_SHARED state. It tests if there is a hot journal present in
4998 ** the file-system for the given pager. A hot journal is one that
4999 ** needs to be played back. According to this function, a hot-journal
5000 ** file exists if the following criteria are met:
5002 ** * The journal file exists in the file system, and
5003 ** * No process holds a RESERVED or greater lock on the database file, and
5004 ** * The database file itself is greater than 0 bytes in size, and
5005 ** * The first byte of the journal file exists and is not 0x00.
5007 ** If the current size of the database file is 0 but a journal file
5008 ** exists, that is probably an old journal left over from a prior
5009 ** database with the same name. In this case the journal file is
5010 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
5013 ** This routine does not check if there is a master journal filename
5014 ** at the end of the file. If there is, and that master journal file
5015 ** does not exist, then the journal file is not really hot. In this
5016 ** case this routine will return a false-positive. The pager_playback()
5017 ** routine will discover that the journal file is not really hot and
5018 ** will not roll it back.
5020 ** If a hot-journal file is found to exist, *pExists is set to 1 and
5021 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
5022 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
5023 ** to determine whether or not a hot-journal file exists, the IO error
5024 ** code is returned and the value of *pExists is undefined.
5026 static int hasHotJournal(Pager
*pPager
, int *pExists
){
5027 sqlite3_vfs
* const pVfs
= pPager
->pVfs
;
5028 int rc
= SQLITE_OK
; /* Return code */
5029 int exists
= 1; /* True if a journal file is present */
5030 int jrnlOpen
= !!isOpen(pPager
->jfd
);
5032 assert( pPager
->useJournal
);
5033 assert( isOpen(pPager
->fd
) );
5034 assert( pPager
->eState
==PAGER_OPEN
);
5036 assert( jrnlOpen
==0 || ( sqlite3OsDeviceCharacteristics(pPager
->jfd
) &
5037 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
5042 rc
= sqlite3OsAccess(pVfs
, pPager
->zJournal
, SQLITE_ACCESS_EXISTS
, &exists
);
5044 if( rc
==SQLITE_OK
&& exists
){
5045 int locked
= 0; /* True if some process holds a RESERVED lock */
5047 /* Race condition here: Another process might have been holding the
5048 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
5049 ** call above, but then delete the journal and drop the lock before
5050 ** we get to the following sqlite3OsCheckReservedLock() call. If that
5051 ** is the case, this routine might think there is a hot journal when
5052 ** in fact there is none. This results in a false-positive which will
5053 ** be dealt with by the playback routine. Ticket #3883.
5055 rc
= sqlite3OsCheckReservedLock(pPager
->fd
, &locked
);
5056 if( rc
==SQLITE_OK
&& !locked
){
5057 Pgno nPage
; /* Number of pages in database file */
5059 assert( pPager
->tempFile
==0 );
5060 rc
= pagerPagecount(pPager
, &nPage
);
5061 if( rc
==SQLITE_OK
){
5062 /* If the database is zero pages in size, that means that either (1) the
5063 ** journal is a remnant from a prior database with the same name where
5064 ** the database file but not the journal was deleted, or (2) the initial
5065 ** transaction that populates a new database is being rolled back.
5066 ** In either case, the journal file can be deleted. However, take care
5067 ** not to delete the journal file if it is already open due to
5068 ** journal_mode=PERSIST.
5070 if( nPage
==0 && !jrnlOpen
){
5071 sqlite3BeginBenignMalloc();
5072 if( pagerLockDb(pPager
, RESERVED_LOCK
)==SQLITE_OK
){
5073 sqlite3OsDelete(pVfs
, pPager
->zJournal
, 0);
5074 if( !pPager
->exclusiveMode
) pagerUnlockDb(pPager
, SHARED_LOCK
);
5076 sqlite3EndBenignMalloc();
5078 /* The journal file exists and no other connection has a reserved
5079 ** or greater lock on the database file. Now check that there is
5080 ** at least one non-zero bytes at the start of the journal file.
5081 ** If there is, then we consider this journal to be hot. If not,
5082 ** it can be ignored.
5085 int f
= SQLITE_OPEN_READONLY
|SQLITE_OPEN_MAIN_JOURNAL
;
5086 rc
= sqlite3OsOpen(pVfs
, pPager
->zJournal
, pPager
->jfd
, f
, &f
);
5088 if( rc
==SQLITE_OK
){
5090 rc
= sqlite3OsRead(pPager
->jfd
, (void *)&first
, 1, 0);
5091 if( rc
==SQLITE_IOERR_SHORT_READ
){
5095 sqlite3OsClose(pPager
->jfd
);
5097 *pExists
= (first
!=0);
5098 }else if( rc
==SQLITE_CANTOPEN
){
5099 /* If we cannot open the rollback journal file in order to see if
5100 ** it has a zero header, that might be due to an I/O error, or
5101 ** it might be due to the race condition described above and in
5102 ** ticket #3883. Either way, assume that the journal is hot.
5103 ** This might be a false positive. But if it is, then the
5104 ** automatic journal playback and recovery mechanism will deal
5105 ** with it under an EXCLUSIVE lock where we do not need to
5106 ** worry so much with race conditions.
5120 ** This function is called to obtain a shared lock on the database file.
5121 ** It is illegal to call sqlite3PagerGet() until after this function
5122 ** has been successfully called. If a shared-lock is already held when
5123 ** this function is called, it is a no-op.
5125 ** The following operations are also performed by this function.
5127 ** 1) If the pager is currently in PAGER_OPEN state (no lock held
5128 ** on the database file), then an attempt is made to obtain a
5129 ** SHARED lock on the database file. Immediately after obtaining
5130 ** the SHARED lock, the file-system is checked for a hot-journal,
5131 ** which is played back if present. Following any hot-journal
5132 ** rollback, the contents of the cache are validated by checking
5133 ** the 'change-counter' field of the database file header and
5134 ** discarded if they are found to be invalid.
5136 ** 2) If the pager is running in exclusive-mode, and there are currently
5137 ** no outstanding references to any pages, and is in the error state,
5138 ** then an attempt is made to clear the error state by discarding
5139 ** the contents of the page cache and rolling back any open journal
5142 ** If everything is successful, SQLITE_OK is returned. If an IO error
5143 ** occurs while locking the database, checking for a hot-journal file or
5144 ** rolling back a journal file, the IO error code is returned.
5146 int sqlite3PagerSharedLock(Pager
*pPager
){
5147 int rc
= SQLITE_OK
; /* Return code */
5149 /* This routine is only called from b-tree and only when there are no
5150 ** outstanding pages. This implies that the pager state should either
5151 ** be OPEN or READER. READER is only possible if the pager is or was in
5152 ** exclusive access mode. */
5153 assert( sqlite3PcacheRefCount(pPager
->pPCache
)==0 );
5154 assert( assert_pager_state(pPager
) );
5155 assert( pPager
->eState
==PAGER_OPEN
|| pPager
->eState
==PAGER_READER
);
5156 assert( pPager
->errCode
==SQLITE_OK
);
5158 if( !pagerUseWal(pPager
) && pPager
->eState
==PAGER_OPEN
){
5159 int bHotJournal
= 1; /* True if there exists a hot journal-file */
5162 assert( pPager
->tempFile
==0 || pPager
->eLock
==EXCLUSIVE_LOCK
);
5164 rc
= pager_wait_on_lock(pPager
, SHARED_LOCK
);
5165 if( rc
!=SQLITE_OK
){
5166 assert( pPager
->eLock
==NO_LOCK
|| pPager
->eLock
==UNKNOWN_LOCK
);
5170 /* If a journal file exists, and there is no RESERVED lock on the
5171 ** database file, then it either needs to be played back or deleted.
5173 if( pPager
->eLock
<=SHARED_LOCK
){
5174 rc
= hasHotJournal(pPager
, &bHotJournal
);
5176 if( rc
!=SQLITE_OK
){
5180 if( pPager
->readOnly
){
5181 rc
= SQLITE_READONLY_ROLLBACK
;
5185 /* Get an EXCLUSIVE lock on the database file. At this point it is
5186 ** important that a RESERVED lock is not obtained on the way to the
5187 ** EXCLUSIVE lock. If it were, another process might open the
5188 ** database file, detect the RESERVED lock, and conclude that the
5189 ** database is safe to read while this process is still rolling the
5190 ** hot-journal back.
5192 ** Because the intermediate RESERVED lock is not requested, any
5193 ** other process attempting to access the database file will get to
5194 ** this point in the code and fail to obtain its own EXCLUSIVE lock
5195 ** on the database file.
5197 ** Unless the pager is in locking_mode=exclusive mode, the lock is
5198 ** downgraded to SHARED_LOCK before this function returns.
5200 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
5201 if( rc
!=SQLITE_OK
){
5205 /* If it is not already open and the file exists on disk, open the
5206 ** journal for read/write access. Write access is required because
5207 ** in exclusive-access mode the file descriptor will be kept open
5208 ** and possibly used for a transaction later on. Also, write-access
5209 ** is usually required to finalize the journal in journal_mode=persist
5210 ** mode (and also for journal_mode=truncate on some systems).
5212 ** If the journal does not exist, it usually means that some
5213 ** other connection managed to get in and roll it back before
5214 ** this connection obtained the exclusive lock above. Or, it
5215 ** may mean that the pager was in the error-state when this
5216 ** function was called and the journal file does not exist.
5218 if( !isOpen(pPager
->jfd
) ){
5219 sqlite3_vfs
* const pVfs
= pPager
->pVfs
;
5220 int bExists
; /* True if journal file exists */
5221 rc
= sqlite3OsAccess(
5222 pVfs
, pPager
->zJournal
, SQLITE_ACCESS_EXISTS
, &bExists
);
5223 if( rc
==SQLITE_OK
&& bExists
){
5225 int f
= SQLITE_OPEN_READWRITE
|SQLITE_OPEN_MAIN_JOURNAL
;
5226 assert( !pPager
->tempFile
);
5227 rc
= sqlite3OsOpen(pVfs
, pPager
->zJournal
, pPager
->jfd
, f
, &fout
);
5228 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->jfd
) );
5229 if( rc
==SQLITE_OK
&& fout
&SQLITE_OPEN_READONLY
){
5230 rc
= SQLITE_CANTOPEN_BKPT
;
5231 sqlite3OsClose(pPager
->jfd
);
5236 /* Playback and delete the journal. Drop the database write
5237 ** lock and reacquire the read lock. Purge the cache before
5238 ** playing back the hot-journal so that we don't end up with
5239 ** an inconsistent cache. Sync the hot journal before playing
5240 ** it back since the process that crashed and left the hot journal
5241 ** probably did not sync it and we are required to always sync
5242 ** the journal before playing it back.
5244 if( isOpen(pPager
->jfd
) ){
5245 assert( rc
==SQLITE_OK
);
5246 rc
= pagerSyncHotJournal(pPager
);
5247 if( rc
==SQLITE_OK
){
5248 rc
= pager_playback(pPager
, !pPager
->tempFile
);
5249 pPager
->eState
= PAGER_OPEN
;
5251 }else if( !pPager
->exclusiveMode
){
5252 pagerUnlockDb(pPager
, SHARED_LOCK
);
5255 if( rc
!=SQLITE_OK
){
5256 /* This branch is taken if an error occurs while trying to open
5257 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
5258 ** pager_unlock() routine will be called before returning to unlock
5259 ** the file. If the unlock attempt fails, then Pager.eLock must be
5260 ** set to UNKNOWN_LOCK (see the comment above the #define for
5261 ** UNKNOWN_LOCK above for an explanation).
5263 ** In order to get pager_unlock() to do this, set Pager.eState to
5264 ** PAGER_ERROR now. This is not actually counted as a transition
5265 ** to ERROR state in the state diagram at the top of this file,
5266 ** since we know that the same call to pager_unlock() will very
5267 ** shortly transition the pager object to the OPEN state. Calling
5268 ** assert_pager_state() would fail now, as it should not be possible
5269 ** to be in ERROR state when there are zero outstanding page
5272 pager_error(pPager
, rc
);
5276 assert( pPager
->eState
==PAGER_OPEN
);
5277 assert( (pPager
->eLock
==SHARED_LOCK
)
5278 || (pPager
->exclusiveMode
&& pPager
->eLock
>SHARED_LOCK
)
5282 if( !pPager
->tempFile
&& pPager
->hasHeldSharedLock
){
5283 /* The shared-lock has just been acquired then check to
5284 ** see if the database has been modified. If the database has changed,
5285 ** flush the cache. The hasHeldSharedLock flag prevents this from
5286 ** occurring on the very first access to a file, in order to save a
5287 ** single unnecessary sqlite3OsRead() call at the start-up.
5289 ** Database changes are detected by looking at 15 bytes beginning
5290 ** at offset 24 into the file. The first 4 of these 16 bytes are
5291 ** a 32-bit counter that is incremented with each change. The
5292 ** other bytes change randomly with each file change when
5293 ** a codec is in use.
5295 ** There is a vanishingly small chance that a change will not be
5296 ** detected. The chance of an undetected change is so small that
5297 ** it can be neglected.
5299 char dbFileVers
[sizeof(pPager
->dbFileVers
)];
5301 IOTRACE(("CKVERS %p %d\n", pPager
, sizeof(dbFileVers
)));
5302 rc
= sqlite3OsRead(pPager
->fd
, &dbFileVers
, sizeof(dbFileVers
), 24);
5303 if( rc
!=SQLITE_OK
){
5304 if( rc
!=SQLITE_IOERR_SHORT_READ
){
5307 memset(dbFileVers
, 0, sizeof(dbFileVers
));
5310 if( memcmp(pPager
->dbFileVers
, dbFileVers
, sizeof(dbFileVers
))!=0 ){
5311 pager_reset(pPager
);
5313 /* Unmap the database file. It is possible that external processes
5314 ** may have truncated the database file and then extended it back
5315 ** to its original size while this process was not holding a lock.
5316 ** In this case there may exist a Pager.pMap mapping that appears
5317 ** to be the right size but is not actually valid. Avoid this
5318 ** possibility by unmapping the db here. */
5319 if( USEFETCH(pPager
) ){
5320 sqlite3OsUnfetch(pPager
->fd
, 0, 0);
5325 /* If there is a WAL file in the file-system, open this database in WAL
5326 ** mode. Otherwise, the following function call is a no-op.
5328 rc
= pagerOpenWalIfPresent(pPager
);
5329 #ifndef SQLITE_OMIT_WAL
5330 assert( pPager
->pWal
==0 || rc
==SQLITE_OK
);
5334 if( pagerUseWal(pPager
) ){
5335 assert( rc
==SQLITE_OK
);
5336 rc
= pagerBeginReadTransaction(pPager
);
5339 if( pPager
->tempFile
==0 && pPager
->eState
==PAGER_OPEN
&& rc
==SQLITE_OK
){
5340 rc
= pagerPagecount(pPager
, &pPager
->dbSize
);
5344 if( rc
!=SQLITE_OK
){
5346 pager_unlock(pPager
);
5347 assert( pPager
->eState
==PAGER_OPEN
);
5349 pPager
->eState
= PAGER_READER
;
5350 pPager
->hasHeldSharedLock
= 1;
5356 ** If the reference count has reached zero, rollback any active
5357 ** transaction and unlock the pager.
5359 ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
5360 ** the rollback journal, the unlock is not performed and there is
5361 ** nothing to rollback, so this routine is a no-op.
5363 static void pagerUnlockIfUnused(Pager
*pPager
){
5364 if( sqlite3PcacheRefCount(pPager
->pPCache
)==0 ){
5365 assert( pPager
->nMmapOut
==0 ); /* because page1 is never memory mapped */
5366 pagerUnlockAndRollback(pPager
);
5371 ** The page getter methods each try to acquire a reference to a
5372 ** page with page number pgno. If the requested reference is
5373 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
5375 ** There are different implementations of the getter method depending
5376 ** on the current state of the pager.
5378 ** getPageNormal() -- The normal getter
5379 ** getPageError() -- Used if the pager is in an error state
5380 ** getPageMmap() -- Used if memory-mapped I/O is enabled
5382 ** If the requested page is already in the cache, it is returned.
5383 ** Otherwise, a new page object is allocated and populated with data
5384 ** read from the database file. In some cases, the pcache module may
5385 ** choose not to allocate a new page object and may reuse an existing
5386 ** object with no outstanding references.
5388 ** The extra data appended to a page is always initialized to zeros the
5389 ** first time a page is loaded into memory. If the page requested is
5390 ** already in the cache when this function is called, then the extra
5391 ** data is left as it was when the page object was last used.
5393 ** If the database image is smaller than the requested page or if
5394 ** the flags parameter contains the PAGER_GET_NOCONTENT bit and the
5395 ** requested page is not already stored in the cache, then no
5396 ** actual disk read occurs. In this case the memory image of the
5397 ** page is initialized to all zeros.
5399 ** If PAGER_GET_NOCONTENT is true, it means that we do not care about
5400 ** the contents of the page. This occurs in two scenarios:
5402 ** a) When reading a free-list leaf page from the database, and
5404 ** b) When a savepoint is being rolled back and we need to load
5405 ** a new page into the cache to be filled with the data read
5406 ** from the savepoint journal.
5408 ** If PAGER_GET_NOCONTENT is true, then the data returned is zeroed instead
5409 ** of being read from the database. Additionally, the bits corresponding
5410 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
5411 ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
5412 ** savepoints are set. This means if the page is made writable at any
5413 ** point in the future, using a call to sqlite3PagerWrite(), its contents
5414 ** will not be journaled. This saves IO.
5416 ** The acquisition might fail for several reasons. In all cases,
5417 ** an appropriate error code is returned and *ppPage is set to NULL.
5419 ** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
5420 ** to find a page in the in-memory cache first. If the page is not already
5421 ** in memory, this routine goes to disk to read it in whereas Lookup()
5422 ** just returns 0. This routine acquires a read-lock the first time it
5423 ** has to go to disk, and could also playback an old journal if necessary.
5424 ** Since Lookup() never goes to disk, it never has to deal with locks
5425 ** or journal files.
5427 static int getPageNormal(
5428 Pager
*pPager
, /* The pager open on the database file */
5429 Pgno pgno
, /* Page number to fetch */
5430 DbPage
**ppPage
, /* Write a pointer to the page here */
5431 int flags
/* PAGER_GET_XXX flags */
5435 u8 noContent
; /* True if PAGER_GET_NOCONTENT is set */
5436 sqlite3_pcache_page
*pBase
;
5438 assert( pPager
->errCode
==SQLITE_OK
);
5439 assert( pPager
->eState
>=PAGER_READER
);
5440 assert( assert_pager_state(pPager
) );
5441 assert( pPager
->hasHeldSharedLock
==1 );
5443 if( pgno
==0 ) return SQLITE_CORRUPT_BKPT
;
5444 pBase
= sqlite3PcacheFetch(pPager
->pPCache
, pgno
, 3);
5447 rc
= sqlite3PcacheFetchStress(pPager
->pPCache
, pgno
, &pBase
);
5448 if( rc
!=SQLITE_OK
) goto pager_acquire_err
;
5450 rc
= SQLITE_NOMEM_BKPT
;
5451 goto pager_acquire_err
;
5454 pPg
= *ppPage
= sqlite3PcacheFetchFinish(pPager
->pPCache
, pgno
, pBase
);
5455 assert( pPg
==(*ppPage
) );
5456 assert( pPg
->pgno
==pgno
);
5457 assert( pPg
->pPager
==pPager
|| pPg
->pPager
==0 );
5459 noContent
= (flags
& PAGER_GET_NOCONTENT
)!=0;
5460 if( pPg
->pPager
&& !noContent
){
5461 /* In this case the pcache already contains an initialized copy of
5462 ** the page. Return without further ado. */
5463 assert( pgno
<=PAGER_MAX_PGNO
&& pgno
!=PAGER_MJ_PGNO(pPager
) );
5464 pPager
->aStat
[PAGER_STAT_HIT
]++;
5468 /* The pager cache has created a new page. Its content needs to
5469 ** be initialized. But first some error checks:
5471 ** (1) The maximum page number is 2^31
5472 ** (2) Never try to fetch the locking page
5474 if( pgno
>PAGER_MAX_PGNO
|| pgno
==PAGER_MJ_PGNO(pPager
) ){
5475 rc
= SQLITE_CORRUPT_BKPT
;
5476 goto pager_acquire_err
;
5479 pPg
->pPager
= pPager
;
5481 assert( !isOpen(pPager
->fd
) || !MEMDB
);
5482 if( !isOpen(pPager
->fd
) || pPager
->dbSize
<pgno
|| noContent
){
5483 if( pgno
>pPager
->mxPgno
){
5485 goto pager_acquire_err
;
5488 /* Failure to set the bits in the InJournal bit-vectors is benign.
5489 ** It merely means that we might do some extra work to journal a
5490 ** page that does not need to be journaled. Nevertheless, be sure
5491 ** to test the case where a malloc error occurs while trying to set
5492 ** a bit in a bit vector.
5494 sqlite3BeginBenignMalloc();
5495 if( pgno
<=pPager
->dbOrigSize
){
5496 TESTONLY( rc
= ) sqlite3BitvecSet(pPager
->pInJournal
, pgno
);
5497 testcase( rc
==SQLITE_NOMEM
);
5499 TESTONLY( rc
= ) addToSavepointBitvecs(pPager
, pgno
);
5500 testcase( rc
==SQLITE_NOMEM
);
5501 sqlite3EndBenignMalloc();
5503 memset(pPg
->pData
, 0, pPager
->pageSize
);
5504 IOTRACE(("ZERO %p %d\n", pPager
, pgno
));
5506 assert( pPg
->pPager
==pPager
);
5507 pPager
->aStat
[PAGER_STAT_MISS
]++;
5508 rc
= readDbPage(pPg
);
5509 if( rc
!=SQLITE_OK
){
5510 goto pager_acquire_err
;
5513 pager_set_pagehash(pPg
);
5518 assert( rc
!=SQLITE_OK
);
5520 sqlite3PcacheDrop(pPg
);
5522 pagerUnlockIfUnused(pPager
);
5527 #if SQLITE_MAX_MMAP_SIZE>0
5528 /* The page getter for when memory-mapped I/O is enabled */
5529 static int getPageMMap(
5530 Pager
*pPager
, /* The pager open on the database file */
5531 Pgno pgno
, /* Page number to fetch */
5532 DbPage
**ppPage
, /* Write a pointer to the page here */
5533 int flags
/* PAGER_GET_XXX flags */
5537 u32 iFrame
= 0; /* Frame to read from WAL file */
5539 /* It is acceptable to use a read-only (mmap) page for any page except
5540 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
5541 ** flag was specified by the caller. And so long as the db is not a
5542 ** temporary or in-memory database. */
5543 const int bMmapOk
= (pgno
>1
5544 && (pPager
->eState
==PAGER_READER
|| (flags
& PAGER_GET_READONLY
))
5547 assert( USEFETCH(pPager
) );
5548 #ifdef SQLITE_HAS_CODEC
5549 assert( pPager
->xCodec
==0 );
5552 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
5553 ** allows the compiler optimizer to reuse the results of the "pgno>1"
5554 ** test in the previous statement, and avoid testing pgno==0 in the
5555 ** common case where pgno is large. */
5556 if( pgno
<=1 && pgno
==0 ){
5557 return SQLITE_CORRUPT_BKPT
;
5559 assert( pPager
->eState
>=PAGER_READER
);
5560 assert( assert_pager_state(pPager
) );
5561 assert( pPager
->hasHeldSharedLock
==1 );
5562 assert( pPager
->errCode
==SQLITE_OK
);
5564 if( bMmapOk
&& pagerUseWal(pPager
) ){
5565 rc
= sqlite3WalFindFrame(pPager
->pWal
, pgno
, &iFrame
);
5566 if( rc
!=SQLITE_OK
){
5571 if( bMmapOk
&& iFrame
==0 ){
5573 rc
= sqlite3OsFetch(pPager
->fd
,
5574 (i64
)(pgno
-1) * pPager
->pageSize
, pPager
->pageSize
, &pData
5576 if( rc
==SQLITE_OK
&& pData
){
5577 if( pPager
->eState
>PAGER_READER
|| pPager
->tempFile
){
5578 pPg
= sqlite3PagerLookup(pPager
, pgno
);
5581 rc
= pagerAcquireMapPage(pPager
, pgno
, pData
, &pPg
);
5583 sqlite3OsUnfetch(pPager
->fd
, (i64
)(pgno
-1)*pPager
->pageSize
, pData
);
5586 assert( rc
==SQLITE_OK
);
5591 if( rc
!=SQLITE_OK
){
5596 return getPageNormal(pPager
, pgno
, ppPage
, flags
);
5598 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
5600 /* The page getter method for when the pager is an error state */
5601 static int getPageError(
5602 Pager
*pPager
, /* The pager open on the database file */
5603 Pgno pgno
, /* Page number to fetch */
5604 DbPage
**ppPage
, /* Write a pointer to the page here */
5605 int flags
/* PAGER_GET_XXX flags */
5607 UNUSED_PARAMETER(pgno
);
5608 UNUSED_PARAMETER(flags
);
5609 assert( pPager
->errCode
!=SQLITE_OK
);
5611 return pPager
->errCode
;
5615 /* Dispatch all page fetch requests to the appropriate getter method.
5617 int sqlite3PagerGet(
5618 Pager
*pPager
, /* The pager open on the database file */
5619 Pgno pgno
, /* Page number to fetch */
5620 DbPage
**ppPage
, /* Write a pointer to the page here */
5621 int flags
/* PAGER_GET_XXX flags */
5623 return pPager
->xGet(pPager
, pgno
, ppPage
, flags
);
5627 ** Acquire a page if it is already in the in-memory cache. Do
5628 ** not read the page from disk. Return a pointer to the page,
5629 ** or 0 if the page is not in cache.
5631 ** See also sqlite3PagerGet(). The difference between this routine
5632 ** and sqlite3PagerGet() is that _get() will go to the disk and read
5633 ** in the page if the page is not already in cache. This routine
5634 ** returns NULL if the page is not in cache or if a disk I/O error
5635 ** has ever happened.
5637 DbPage
*sqlite3PagerLookup(Pager
*pPager
, Pgno pgno
){
5638 sqlite3_pcache_page
*pPage
;
5639 assert( pPager
!=0 );
5641 assert( pPager
->pPCache
!=0 );
5642 pPage
= sqlite3PcacheFetch(pPager
->pPCache
, pgno
, 0);
5643 assert( pPage
==0 || pPager
->hasHeldSharedLock
);
5644 if( pPage
==0 ) return 0;
5645 return sqlite3PcacheFetchFinish(pPager
->pPCache
, pgno
, pPage
);
5649 ** Release a page reference.
5651 ** The sqlite3PagerUnref() and sqlite3PagerUnrefNotNull() may only be
5652 ** used if we know that the page being released is not the last page.
5653 ** The btree layer always holds page1 open until the end, so these first
5654 ** to routines can be used to release any page other than BtShared.pPage1.
5656 ** Use sqlite3PagerUnrefPageOne() to release page1. This latter routine
5657 ** checks the total number of outstanding pages and if the number of
5658 ** pages reaches zero it drops the database lock.
5660 void sqlite3PagerUnrefNotNull(DbPage
*pPg
){
5661 TESTONLY( Pager
*pPager
= pPg
->pPager
; )
5663 if( pPg
->flags
& PGHDR_MMAP
){
5664 assert( pPg
->pgno
!=1 ); /* Page1 is never memory mapped */
5665 pagerReleaseMapPage(pPg
);
5667 sqlite3PcacheRelease(pPg
);
5669 /* Do not use this routine to release the last reference to page1 */
5670 assert( sqlite3PcacheRefCount(pPager
->pPCache
)>0 );
5672 void sqlite3PagerUnref(DbPage
*pPg
){
5673 if( pPg
) sqlite3PagerUnrefNotNull(pPg
);
5675 void sqlite3PagerUnrefPageOne(DbPage
*pPg
){
5678 assert( pPg
->pgno
==1 );
5679 assert( (pPg
->flags
& PGHDR_MMAP
)==0 ); /* Page1 is never memory mapped */
5680 pPager
= pPg
->pPager
;
5681 sqlite3PcacheRelease(pPg
);
5682 pagerUnlockIfUnused(pPager
);
5686 ** This function is called at the start of every write transaction.
5687 ** There must already be a RESERVED or EXCLUSIVE lock on the database
5688 ** file when this routine is called.
5690 ** Open the journal file for pager pPager and write a journal header
5691 ** to the start of it. If there are active savepoints, open the sub-journal
5692 ** as well. This function is only used when the journal file is being
5693 ** opened to write a rollback log for a transaction. It is not used
5694 ** when opening a hot journal file to roll it back.
5696 ** If the journal file is already open (as it may be in exclusive mode),
5697 ** then this function just writes a journal header to the start of the
5698 ** already open file.
5700 ** Whether or not the journal file is opened by this function, the
5701 ** Pager.pInJournal bitvec structure is allocated.
5703 ** Return SQLITE_OK if everything is successful. Otherwise, return
5704 ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
5705 ** an IO error code if opening or writing the journal file fails.
5707 static int pager_open_journal(Pager
*pPager
){
5708 int rc
= SQLITE_OK
; /* Return code */
5709 sqlite3_vfs
* const pVfs
= pPager
->pVfs
; /* Local cache of vfs pointer */
5711 assert( pPager
->eState
==PAGER_WRITER_LOCKED
);
5712 assert( assert_pager_state(pPager
) );
5713 assert( pPager
->pInJournal
==0 );
5715 /* If already in the error state, this function is a no-op. But on
5716 ** the other hand, this routine is never called if we are already in
5717 ** an error state. */
5718 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
5720 if( !pagerUseWal(pPager
) && pPager
->journalMode
!=PAGER_JOURNALMODE_OFF
){
5721 pPager
->pInJournal
= sqlite3BitvecCreate(pPager
->dbSize
);
5722 if( pPager
->pInJournal
==0 ){
5723 return SQLITE_NOMEM_BKPT
;
5726 /* Open the journal file if it is not already open. */
5727 if( !isOpen(pPager
->jfd
) ){
5728 if( pPager
->journalMode
==PAGER_JOURNALMODE_MEMORY
){
5729 sqlite3MemJournalOpen(pPager
->jfd
);
5731 int flags
= SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
;
5734 if( pPager
->tempFile
){
5735 flags
|= (SQLITE_OPEN_DELETEONCLOSE
|SQLITE_OPEN_TEMP_JOURNAL
);
5736 nSpill
= sqlite3Config
.nStmtSpill
;
5738 flags
|= SQLITE_OPEN_MAIN_JOURNAL
;
5739 nSpill
= jrnlBufferSize(pPager
);
5742 /* Verify that the database still has the same name as it did when
5743 ** it was originally opened. */
5744 rc
= databaseIsUnmoved(pPager
);
5745 if( rc
==SQLITE_OK
){
5746 rc
= sqlite3JournalOpen (
5747 pVfs
, pPager
->zJournal
, pPager
->jfd
, flags
, nSpill
5751 assert( rc
!=SQLITE_OK
|| isOpen(pPager
->jfd
) );
5755 /* Write the first journal header to the journal file and open
5756 ** the sub-journal if necessary.
5758 if( rc
==SQLITE_OK
){
5759 /* TODO: Check if all of these are really required. */
5761 pPager
->journalOff
= 0;
5762 pPager
->setMaster
= 0;
5763 pPager
->journalHdr
= 0;
5764 rc
= writeJournalHdr(pPager
);
5768 if( rc
!=SQLITE_OK
){
5769 sqlite3BitvecDestroy(pPager
->pInJournal
);
5770 pPager
->pInJournal
= 0;
5772 assert( pPager
->eState
==PAGER_WRITER_LOCKED
);
5773 pPager
->eState
= PAGER_WRITER_CACHEMOD
;
5780 ** Begin a write-transaction on the specified pager object. If a
5781 ** write-transaction has already been opened, this function is a no-op.
5783 ** If the exFlag argument is false, then acquire at least a RESERVED
5784 ** lock on the database file. If exFlag is true, then acquire at least
5785 ** an EXCLUSIVE lock. If such a lock is already held, no locking
5786 ** functions need be called.
5788 ** If the subjInMemory argument is non-zero, then any sub-journal opened
5789 ** within this transaction will be opened as an in-memory file. This
5790 ** has no effect if the sub-journal is already opened (as it may be when
5791 ** running in exclusive mode) or if the transaction does not require a
5792 ** sub-journal. If the subjInMemory argument is zero, then any required
5793 ** sub-journal is implemented in-memory if pPager is an in-memory database,
5794 ** or using a temporary file otherwise.
5796 int sqlite3PagerBegin(Pager
*pPager
, int exFlag
, int subjInMemory
){
5799 if( pPager
->errCode
) return pPager
->errCode
;
5800 assert( pPager
->eState
>=PAGER_READER
&& pPager
->eState
<PAGER_ERROR
);
5801 pPager
->subjInMemory
= (u8
)subjInMemory
;
5803 if( ALWAYS(pPager
->eState
==PAGER_READER
) ){
5804 assert( pPager
->pInJournal
==0 );
5806 if( pagerUseWal(pPager
) ){
5807 /* If the pager is configured to use locking_mode=exclusive, and an
5808 ** exclusive lock on the database is not already held, obtain it now.
5810 if( pPager
->exclusiveMode
&& sqlite3WalExclusiveMode(pPager
->pWal
, -1) ){
5811 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
5812 if( rc
!=SQLITE_OK
){
5815 (void)sqlite3WalExclusiveMode(pPager
->pWal
, 1);
5818 /* Grab the write lock on the log file. If successful, upgrade to
5819 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
5820 ** The busy-handler is not invoked if another connection already
5821 ** holds the write-lock. If possible, the upper layer will call it.
5823 rc
= sqlite3WalBeginWriteTransaction(pPager
->pWal
);
5825 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
5826 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
5827 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
5828 ** lock, but not when obtaining the RESERVED lock.
5830 rc
= pagerLockDb(pPager
, RESERVED_LOCK
);
5831 if( rc
==SQLITE_OK
&& exFlag
){
5832 rc
= pager_wait_on_lock(pPager
, EXCLUSIVE_LOCK
);
5836 if( rc
==SQLITE_OK
){
5837 /* Change to WRITER_LOCKED state.
5839 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
5840 ** when it has an open transaction, but never to DBMOD or FINISHED.
5841 ** This is because in those states the code to roll back savepoint
5842 ** transactions may copy data from the sub-journal into the database
5843 ** file as well as into the page cache. Which would be incorrect in
5846 pPager
->eState
= PAGER_WRITER_LOCKED
;
5847 pPager
->dbHintSize
= pPager
->dbSize
;
5848 pPager
->dbFileSize
= pPager
->dbSize
;
5849 pPager
->dbOrigSize
= pPager
->dbSize
;
5850 pPager
->journalOff
= 0;
5853 assert( rc
==SQLITE_OK
|| pPager
->eState
==PAGER_READER
);
5854 assert( rc
!=SQLITE_OK
|| pPager
->eState
==PAGER_WRITER_LOCKED
);
5855 assert( assert_pager_state(pPager
) );
5858 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager
)));
5863 ** Write page pPg onto the end of the rollback journal.
5865 static SQLITE_NOINLINE
int pagerAddPageToRollbackJournal(PgHdr
*pPg
){
5866 Pager
*pPager
= pPg
->pPager
;
5870 i64 iOff
= pPager
->journalOff
;
5872 /* We should never write to the journal file the page that
5873 ** contains the database locks. The following assert verifies
5874 ** that we do not. */
5875 assert( pPg
->pgno
!=PAGER_MJ_PGNO(pPager
) );
5877 assert( pPager
->journalHdr
<=pPager
->journalOff
);
5878 CODEC2(pPager
, pPg
->pData
, pPg
->pgno
, 7, return SQLITE_NOMEM_BKPT
, pData2
);
5879 cksum
= pager_cksum(pPager
, (u8
*)pData2
);
5881 /* Even if an IO or diskfull error occurs while journalling the
5882 ** page in the block above, set the need-sync flag for the page.
5883 ** Otherwise, when the transaction is rolled back, the logic in
5884 ** playback_one_page() will think that the page needs to be restored
5885 ** in the database file. And if an IO error occurs while doing so,
5886 ** then corruption may follow.
5888 pPg
->flags
|= PGHDR_NEED_SYNC
;
5890 rc
= write32bits(pPager
->jfd
, iOff
, pPg
->pgno
);
5891 if( rc
!=SQLITE_OK
) return rc
;
5892 rc
= sqlite3OsWrite(pPager
->jfd
, pData2
, pPager
->pageSize
, iOff
+4);
5893 if( rc
!=SQLITE_OK
) return rc
;
5894 rc
= write32bits(pPager
->jfd
, iOff
+pPager
->pageSize
+4, cksum
);
5895 if( rc
!=SQLITE_OK
) return rc
;
5897 IOTRACE(("JOUT %p %d %lld %d\n", pPager
, pPg
->pgno
,
5898 pPager
->journalOff
, pPager
->pageSize
));
5899 PAGER_INCR(sqlite3_pager_writej_count
);
5900 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
5901 PAGERID(pPager
), pPg
->pgno
,
5902 ((pPg
->flags
&PGHDR_NEED_SYNC
)?1:0), pager_pagehash(pPg
)));
5904 pPager
->journalOff
+= 8 + pPager
->pageSize
;
5906 assert( pPager
->pInJournal
!=0 );
5907 rc
= sqlite3BitvecSet(pPager
->pInJournal
, pPg
->pgno
);
5908 testcase( rc
==SQLITE_NOMEM
);
5909 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
5910 rc
|= addToSavepointBitvecs(pPager
, pPg
->pgno
);
5911 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
5916 ** Mark a single data page as writeable. The page is written into the
5917 ** main journal or sub-journal as required. If the page is written into
5918 ** one of the journals, the corresponding bit is set in the
5919 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
5920 ** of any open savepoints as appropriate.
5922 static int pager_write(PgHdr
*pPg
){
5923 Pager
*pPager
= pPg
->pPager
;
5926 /* This routine is not called unless a write-transaction has already
5927 ** been started. The journal file may or may not be open at this point.
5928 ** It is never called in the ERROR state.
5930 assert( pPager
->eState
==PAGER_WRITER_LOCKED
5931 || pPager
->eState
==PAGER_WRITER_CACHEMOD
5932 || pPager
->eState
==PAGER_WRITER_DBMOD
5934 assert( assert_pager_state(pPager
) );
5935 assert( pPager
->errCode
==0 );
5936 assert( pPager
->readOnly
==0 );
5939 /* The journal file needs to be opened. Higher level routines have already
5940 ** obtained the necessary locks to begin the write-transaction, but the
5941 ** rollback journal might not yet be open. Open it now if this is the case.
5943 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
5944 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
5945 ** an error might occur and the pager would end up in WRITER_LOCKED state
5946 ** with pages marked as dirty in the cache.
5948 if( pPager
->eState
==PAGER_WRITER_LOCKED
){
5949 rc
= pager_open_journal(pPager
);
5950 if( rc
!=SQLITE_OK
) return rc
;
5952 assert( pPager
->eState
>=PAGER_WRITER_CACHEMOD
);
5953 assert( assert_pager_state(pPager
) );
5955 /* Mark the page that is about to be modified as dirty. */
5956 sqlite3PcacheMakeDirty(pPg
);
5958 /* If a rollback journal is in use, them make sure the page that is about
5959 ** to change is in the rollback journal, or if the page is a new page off
5960 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
5962 assert( (pPager
->pInJournal
!=0) == isOpen(pPager
->jfd
) );
5963 if( pPager
->pInJournal
!=0
5964 && sqlite3BitvecTestNotNull(pPager
->pInJournal
, pPg
->pgno
)==0
5966 assert( pagerUseWal(pPager
)==0 );
5967 if( pPg
->pgno
<=pPager
->dbOrigSize
){
5968 rc
= pagerAddPageToRollbackJournal(pPg
);
5969 if( rc
!=SQLITE_OK
){
5973 if( pPager
->eState
!=PAGER_WRITER_DBMOD
){
5974 pPg
->flags
|= PGHDR_NEED_SYNC
;
5976 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
5977 PAGERID(pPager
), pPg
->pgno
,
5978 ((pPg
->flags
&PGHDR_NEED_SYNC
)?1:0)));
5982 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
5983 ** and before writing the page into the rollback journal. Wait until now,
5984 ** after the page has been successfully journalled, before setting the
5985 ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
5987 pPg
->flags
|= PGHDR_WRITEABLE
;
5989 /* If the statement journal is open and the page is not in it,
5990 ** then write the page into the statement journal.
5992 if( pPager
->nSavepoint
>0 ){
5993 rc
= subjournalPageIfRequired(pPg
);
5996 /* Update the database size and return. */
5997 if( pPager
->dbSize
<pPg
->pgno
){
5998 pPager
->dbSize
= pPg
->pgno
;
6004 ** This is a variant of sqlite3PagerWrite() that runs when the sector size
6005 ** is larger than the page size. SQLite makes the (reasonable) assumption that
6006 ** all bytes of a sector are written together by hardware. Hence, all bytes of
6007 ** a sector need to be journalled in case of a power loss in the middle of
6010 ** Usually, the sector size is less than or equal to the page size, in which
6011 ** case pages can be individually written. This routine only runs in the
6012 ** exceptional case where the page size is smaller than the sector size.
6014 static SQLITE_NOINLINE
int pagerWriteLargeSector(PgHdr
*pPg
){
6015 int rc
= SQLITE_OK
; /* Return code */
6016 Pgno nPageCount
; /* Total number of pages in database file */
6017 Pgno pg1
; /* First page of the sector pPg is located on. */
6018 int nPage
= 0; /* Number of pages starting at pg1 to journal */
6019 int ii
; /* Loop counter */
6020 int needSync
= 0; /* True if any page has PGHDR_NEED_SYNC */
6021 Pager
*pPager
= pPg
->pPager
; /* The pager that owns pPg */
6022 Pgno nPagePerSector
= (pPager
->sectorSize
/pPager
->pageSize
);
6024 /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
6025 ** a journal header to be written between the pages journaled by
6029 assert( (pPager
->doNotSpill
& SPILLFLAG_NOSYNC
)==0 );
6030 pPager
->doNotSpill
|= SPILLFLAG_NOSYNC
;
6032 /* This trick assumes that both the page-size and sector-size are
6033 ** an integer power of 2. It sets variable pg1 to the identifier
6034 ** of the first page of the sector pPg is located on.
6036 pg1
= ((pPg
->pgno
-1) & ~(nPagePerSector
-1)) + 1;
6038 nPageCount
= pPager
->dbSize
;
6039 if( pPg
->pgno
>nPageCount
){
6040 nPage
= (pPg
->pgno
- pg1
)+1;
6041 }else if( (pg1
+nPagePerSector
-1)>nPageCount
){
6042 nPage
= nPageCount
+1-pg1
;
6044 nPage
= nPagePerSector
;
6047 assert(pg1
<=pPg
->pgno
);
6048 assert((pg1
+nPage
)>pPg
->pgno
);
6050 for(ii
=0; ii
<nPage
&& rc
==SQLITE_OK
; ii
++){
6053 if( pg
==pPg
->pgno
|| !sqlite3BitvecTest(pPager
->pInJournal
, pg
) ){
6054 if( pg
!=PAGER_MJ_PGNO(pPager
) ){
6055 rc
= sqlite3PagerGet(pPager
, pg
, &pPage
, 0);
6056 if( rc
==SQLITE_OK
){
6057 rc
= pager_write(pPage
);
6058 if( pPage
->flags
&PGHDR_NEED_SYNC
){
6061 sqlite3PagerUnrefNotNull(pPage
);
6064 }else if( (pPage
= sqlite3PagerLookup(pPager
, pg
))!=0 ){
6065 if( pPage
->flags
&PGHDR_NEED_SYNC
){
6068 sqlite3PagerUnrefNotNull(pPage
);
6072 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
6073 ** starting at pg1, then it needs to be set for all of them. Because
6074 ** writing to any of these nPage pages may damage the others, the
6075 ** journal file must contain sync()ed copies of all of them
6076 ** before any of them can be written out to the database file.
6078 if( rc
==SQLITE_OK
&& needSync
){
6080 for(ii
=0; ii
<nPage
; ii
++){
6081 PgHdr
*pPage
= sqlite3PagerLookup(pPager
, pg1
+ii
);
6083 pPage
->flags
|= PGHDR_NEED_SYNC
;
6084 sqlite3PagerUnrefNotNull(pPage
);
6089 assert( (pPager
->doNotSpill
& SPILLFLAG_NOSYNC
)!=0 );
6090 pPager
->doNotSpill
&= ~SPILLFLAG_NOSYNC
;
6095 ** Mark a data page as writeable. This routine must be called before
6096 ** making changes to a page. The caller must check the return value
6097 ** of this function and be careful not to change any page data unless
6098 ** this routine returns SQLITE_OK.
6100 ** The difference between this function and pager_write() is that this
6101 ** function also deals with the special case where 2 or more pages
6102 ** fit on a single disk sector. In this case all co-resident pages
6103 ** must have been written to the journal file before returning.
6105 ** If an error occurs, SQLITE_NOMEM or an IO error code is returned
6106 ** as appropriate. Otherwise, SQLITE_OK.
6108 int sqlite3PagerWrite(PgHdr
*pPg
){
6109 Pager
*pPager
= pPg
->pPager
;
6110 assert( (pPg
->flags
& PGHDR_MMAP
)==0 );
6111 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6112 assert( assert_pager_state(pPager
) );
6113 if( (pPg
->flags
& PGHDR_WRITEABLE
)!=0 && pPager
->dbSize
>=pPg
->pgno
){
6114 if( pPager
->nSavepoint
) return subjournalPageIfRequired(pPg
);
6116 }else if( pPager
->errCode
){
6117 return pPager
->errCode
;
6118 }else if( pPager
->sectorSize
> (u32
)pPager
->pageSize
){
6119 assert( pPager
->tempFile
==0 );
6120 return pagerWriteLargeSector(pPg
);
6122 return pager_write(pPg
);
6127 ** Return TRUE if the page given in the argument was previously passed
6128 ** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
6129 ** to change the content of the page.
6132 int sqlite3PagerIswriteable(DbPage
*pPg
){
6133 return pPg
->flags
& PGHDR_WRITEABLE
;
6138 ** A call to this routine tells the pager that it is not necessary to
6139 ** write the information on page pPg back to the disk, even though
6140 ** that page might be marked as dirty. This happens, for example, when
6141 ** the page has been added as a leaf of the freelist and so its
6142 ** content no longer matters.
6144 ** The overlying software layer calls this routine when all of the data
6145 ** on the given page is unused. The pager marks the page as clean so
6146 ** that it does not get written to disk.
6148 ** Tests show that this optimization can quadruple the speed of large
6149 ** DELETE operations.
6151 ** This optimization cannot be used with a temp-file, as the page may
6152 ** have been dirty at the start of the transaction. In that case, if
6153 ** memory pressure forces page pPg out of the cache, the data does need
6154 ** to be written out to disk so that it may be read back in if the
6155 ** current transaction is rolled back.
6157 void sqlite3PagerDontWrite(PgHdr
*pPg
){
6158 Pager
*pPager
= pPg
->pPager
;
6159 if( !pPager
->tempFile
&& (pPg
->flags
&PGHDR_DIRTY
) && pPager
->nSavepoint
==0 ){
6160 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg
->pgno
, PAGERID(pPager
)));
6161 IOTRACE(("CLEAN %p %d\n", pPager
, pPg
->pgno
))
6162 pPg
->flags
|= PGHDR_DONT_WRITE
;
6163 pPg
->flags
&= ~PGHDR_WRITEABLE
;
6164 testcase( pPg
->flags
& PGHDR_NEED_SYNC
);
6165 pager_set_pagehash(pPg
);
6170 ** This routine is called to increment the value of the database file
6171 ** change-counter, stored as a 4-byte big-endian integer starting at
6172 ** byte offset 24 of the pager file. The secondary change counter at
6173 ** 92 is also updated, as is the SQLite version number at offset 96.
6175 ** But this only happens if the pPager->changeCountDone flag is false.
6176 ** To avoid excess churning of page 1, the update only happens once.
6177 ** See also the pager_write_changecounter() routine that does an
6178 ** unconditional update of the change counters.
6180 ** If the isDirectMode flag is zero, then this is done by calling
6181 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
6182 ** page data. In this case the file will be updated when the current
6183 ** transaction is committed.
6185 ** The isDirectMode flag may only be non-zero if the library was compiled
6186 ** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
6187 ** if isDirect is non-zero, then the database file is updated directly
6188 ** by writing an updated version of page 1 using a call to the
6189 ** sqlite3OsWrite() function.
6191 static int pager_incr_changecounter(Pager
*pPager
, int isDirectMode
){
6194 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
6195 || pPager
->eState
==PAGER_WRITER_DBMOD
6197 assert( assert_pager_state(pPager
) );
6199 /* Declare and initialize constant integer 'isDirect'. If the
6200 ** atomic-write optimization is enabled in this build, then isDirect
6201 ** is initialized to the value passed as the isDirectMode parameter
6202 ** to this function. Otherwise, it is always set to zero.
6204 ** The idea is that if the atomic-write optimization is not
6205 ** enabled at compile time, the compiler can omit the tests of
6206 ** 'isDirect' below, as well as the block enclosed in the
6207 ** "if( isDirect )" condition.
6209 #ifndef SQLITE_ENABLE_ATOMIC_WRITE
6210 # define DIRECT_MODE 0
6211 assert( isDirectMode
==0 );
6212 UNUSED_PARAMETER(isDirectMode
);
6214 # define DIRECT_MODE isDirectMode
6217 if( !pPager
->changeCountDone
&& ALWAYS(pPager
->dbSize
>0) ){
6218 PgHdr
*pPgHdr
; /* Reference to page 1 */
6220 assert( !pPager
->tempFile
&& isOpen(pPager
->fd
) );
6222 /* Open page 1 of the file for writing. */
6223 rc
= sqlite3PagerGet(pPager
, 1, &pPgHdr
, 0);
6224 assert( pPgHdr
==0 || rc
==SQLITE_OK
);
6226 /* If page one was fetched successfully, and this function is not
6227 ** operating in direct-mode, make page 1 writable. When not in
6228 ** direct mode, page 1 is always held in cache and hence the PagerGet()
6229 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
6231 if( !DIRECT_MODE
&& ALWAYS(rc
==SQLITE_OK
) ){
6232 rc
= sqlite3PagerWrite(pPgHdr
);
6235 if( rc
==SQLITE_OK
){
6236 /* Actually do the update of the change counter */
6237 pager_write_changecounter(pPgHdr
);
6239 /* If running in direct mode, write the contents of page 1 to the file. */
6242 assert( pPager
->dbFileSize
>0 );
6243 CODEC2(pPager
, pPgHdr
->pData
, 1, 6, rc
=SQLITE_NOMEM_BKPT
, zBuf
);
6244 if( rc
==SQLITE_OK
){
6245 rc
= sqlite3OsWrite(pPager
->fd
, zBuf
, pPager
->pageSize
, 0);
6246 pPager
->aStat
[PAGER_STAT_WRITE
]++;
6248 if( rc
==SQLITE_OK
){
6249 /* Update the pager's copy of the change-counter. Otherwise, the
6250 ** next time a read transaction is opened the cache will be
6251 ** flushed (as the change-counter values will not match). */
6252 const void *pCopy
= (const void *)&((const char *)zBuf
)[24];
6253 memcpy(&pPager
->dbFileVers
, pCopy
, sizeof(pPager
->dbFileVers
));
6254 pPager
->changeCountDone
= 1;
6257 pPager
->changeCountDone
= 1;
6261 /* Release the page reference. */
6262 sqlite3PagerUnref(pPgHdr
);
6268 ** Sync the database file to disk. This is a no-op for in-memory databases
6269 ** or pages with the Pager.noSync flag set.
6271 ** If successful, or if called on a pager for which it is a no-op, this
6272 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
6274 int sqlite3PagerSync(Pager
*pPager
, const char *zMaster
){
6277 if( isOpen(pPager
->fd
) ){
6278 void *pArg
= (void*)zMaster
;
6279 rc
= sqlite3OsFileControl(pPager
->fd
, SQLITE_FCNTL_SYNC
, pArg
);
6280 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
6282 if( rc
==SQLITE_OK
&& !pPager
->noSync
){
6284 rc
= sqlite3OsSync(pPager
->fd
, pPager
->syncFlags
);
6290 ** This function may only be called while a write-transaction is active in
6291 ** rollback. If the connection is in WAL mode, this call is a no-op.
6292 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
6293 ** the database file, an attempt is made to obtain one.
6295 ** If the EXCLUSIVE lock is already held or the attempt to obtain it is
6296 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
6297 ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
6300 int sqlite3PagerExclusiveLock(Pager
*pPager
){
6301 int rc
= pPager
->errCode
;
6302 assert( assert_pager_state(pPager
) );
6303 if( rc
==SQLITE_OK
){
6304 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
6305 || pPager
->eState
==PAGER_WRITER_DBMOD
6306 || pPager
->eState
==PAGER_WRITER_LOCKED
6308 assert( assert_pager_state(pPager
) );
6309 if( 0==pagerUseWal(pPager
) ){
6310 rc
= pager_wait_on_lock(pPager
, EXCLUSIVE_LOCK
);
6317 ** Sync the database file for the pager pPager. zMaster points to the name
6318 ** of a master journal file that should be written into the individual
6319 ** journal file. zMaster may be NULL, which is interpreted as no master
6320 ** journal (a single database transaction).
6322 ** This routine ensures that:
6324 ** * The database file change-counter is updated,
6325 ** * the journal is synced (unless the atomic-write optimization is used),
6326 ** * all dirty pages are written to the database file,
6327 ** * the database file is truncated (if required), and
6328 ** * the database file synced.
6330 ** The only thing that remains to commit the transaction is to finalize
6331 ** (delete, truncate or zero the first part of) the journal file (or
6332 ** delete the master journal file if specified).
6334 ** Note that if zMaster==NULL, this does not overwrite a previous value
6335 ** passed to an sqlite3PagerCommitPhaseOne() call.
6337 ** If the final parameter - noSync - is true, then the database file itself
6338 ** is not synced. The caller must call sqlite3PagerSync() directly to
6339 ** sync the database file before calling CommitPhaseTwo() to delete the
6340 ** journal file in this case.
6342 int sqlite3PagerCommitPhaseOne(
6343 Pager
*pPager
, /* Pager object */
6344 const char *zMaster
, /* If not NULL, the master journal name */
6345 int noSync
/* True to omit the xSync on the db file */
6347 int rc
= SQLITE_OK
; /* Return code */
6349 assert( pPager
->eState
==PAGER_WRITER_LOCKED
6350 || pPager
->eState
==PAGER_WRITER_CACHEMOD
6351 || pPager
->eState
==PAGER_WRITER_DBMOD
6352 || pPager
->eState
==PAGER_ERROR
6354 assert( assert_pager_state(pPager
) );
6356 /* If a prior error occurred, report that error again. */
6357 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
6359 /* Provide the ability to easily simulate an I/O error during testing */
6360 if( sqlite3FaultSim(400) ) return SQLITE_IOERR
;
6362 PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
6363 pPager
->zFilename
, zMaster
, pPager
->dbSize
));
6365 /* If no database changes have been made, return early. */
6366 if( pPager
->eState
<PAGER_WRITER_CACHEMOD
) return SQLITE_OK
;
6368 assert( MEMDB
==0 || pPager
->tempFile
);
6369 assert( isOpen(pPager
->fd
) || pPager
->tempFile
);
6370 if( 0==pagerFlushOnCommit(pPager
, 1) ){
6371 /* If this is an in-memory db, or no pages have been written to, or this
6372 ** function has already been called, it is mostly a no-op. However, any
6373 ** backup in progress needs to be restarted. */
6374 sqlite3BackupRestart(pPager
->pBackup
);
6376 if( pagerUseWal(pPager
) ){
6377 PgHdr
*pList
= sqlite3PcacheDirtyList(pPager
->pPCache
);
6378 PgHdr
*pPageOne
= 0;
6380 /* Must have at least one page for the WAL commit flag.
6381 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
6382 rc
= sqlite3PagerGet(pPager
, 1, &pPageOne
, 0);
6386 assert( rc
==SQLITE_OK
);
6387 if( ALWAYS(pList
) ){
6388 rc
= pagerWalFrames(pPager
, pList
, pPager
->dbSize
, 1);
6390 sqlite3PagerUnref(pPageOne
);
6391 if( rc
==SQLITE_OK
){
6392 sqlite3PcacheCleanAll(pPager
->pPCache
);
6395 /* The bBatch boolean is true if the batch-atomic-write commit method
6396 ** should be used. No rollback journal is created if batch-atomic-write
6399 sqlite3_file
*fd
= pPager
->fd
;
6400 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6401 const int bBatch
= zMaster
==0 /* An SQLITE_IOCAP_BATCH_ATOMIC commit */
6402 && (sqlite3OsDeviceCharacteristics(fd
) & SQLITE_IOCAP_BATCH_ATOMIC
)
6404 && sqlite3JournalIsInMemory(pPager
->jfd
);
6409 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
6410 /* The following block updates the change-counter. Exactly how it
6411 ** does this depends on whether or not the atomic-update optimization
6412 ** was enabled at compile time, and if this transaction meets the
6413 ** runtime criteria to use the operation:
6415 ** * The file-system supports the atomic-write property for
6416 ** blocks of size page-size, and
6417 ** * This commit is not part of a multi-file transaction, and
6418 ** * Exactly one page has been modified and store in the journal file.
6420 ** If the optimization was not enabled at compile time, then the
6421 ** pager_incr_changecounter() function is called to update the change
6422 ** counter in 'indirect-mode'. If the optimization is compiled in but
6423 ** is not applicable to this transaction, call sqlite3JournalCreate()
6424 ** to make sure the journal file has actually been created, then call
6425 ** pager_incr_changecounter() to update the change-counter in indirect
6428 ** Otherwise, if the optimization is both enabled and applicable,
6429 ** then call pager_incr_changecounter() to update the change-counter
6430 ** in 'direct' mode. In this case the journal file will never be
6431 ** created for this transaction.
6435 assert( isOpen(pPager
->jfd
)
6436 || pPager
->journalMode
==PAGER_JOURNALMODE_OFF
6437 || pPager
->journalMode
==PAGER_JOURNALMODE_WAL
6439 if( !zMaster
&& isOpen(pPager
->jfd
)
6440 && pPager
->journalOff
==jrnlBufferSize(pPager
)
6441 && pPager
->dbSize
>=pPager
->dbOrigSize
6442 && (!(pPg
= sqlite3PcacheDirtyList(pPager
->pPCache
)) || 0==pPg
->pDirty
)
6444 /* Update the db file change counter via the direct-write method. The
6445 ** following call will modify the in-memory representation of page 1
6446 ** to include the updated change counter and then write page 1
6447 ** directly to the database file. Because of the atomic-write
6448 ** property of the host file-system, this is safe.
6450 rc
= pager_incr_changecounter(pPager
, 1);
6452 rc
= sqlite3JournalCreate(pPager
->jfd
);
6453 if( rc
==SQLITE_OK
){
6454 rc
= pager_incr_changecounter(pPager
, 0);
6459 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
6461 rc
= sqlite3JournalCreate(pPager
->jfd
);
6462 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6465 rc
= pager_incr_changecounter(pPager
, 0);
6467 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6469 /* Write the master journal name into the journal file. If a master
6470 ** journal file name has already been written to the journal file,
6471 ** or if zMaster is NULL (no master journal), then this call is a no-op.
6473 rc
= writeMasterJournal(pPager
, zMaster
);
6474 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6476 /* Sync the journal file and write all dirty pages to the database.
6477 ** If the atomic-update optimization is being used, this sync will not
6478 ** create the journal file or perform any real IO.
6480 ** Because the change-counter page was just modified, unless the
6481 ** atomic-update optimization is used it is almost certain that the
6482 ** journal requires a sync here. However, in locking_mode=exclusive
6483 ** on a system under memory pressure it is just possible that this is
6484 ** not the case. In this case it is likely enough that the redundant
6485 ** xSync() call will be changed to a no-op by the OS anyhow.
6487 rc
= syncJournal(pPager
, 0);
6488 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6491 /* The pager is now in DBMOD state. But regardless of what happens
6492 ** next, attempting to play the journal back into the database would
6493 ** be unsafe. Close it now to make sure that does not happen. */
6494 sqlite3OsClose(pPager
->jfd
);
6495 rc
= sqlite3OsFileControl(fd
, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE
, 0);
6496 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6498 rc
= pager_write_pagelist(pPager
,sqlite3PcacheDirtyList(pPager
->pPCache
));
6500 if( rc
==SQLITE_OK
){
6501 rc
= sqlite3OsFileControl(fd
, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE
, 0);
6503 sqlite3OsFileControl(fd
, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE
, 0);
6507 if( rc
!=SQLITE_OK
){
6508 assert( rc
!=SQLITE_IOERR_BLOCKED
);
6509 goto commit_phase_one_exit
;
6511 sqlite3PcacheCleanAll(pPager
->pPCache
);
6513 /* If the file on disk is smaller than the database image, use
6514 ** pager_truncate to grow the file here. This can happen if the database
6515 ** image was extended as part of the current transaction and then the
6516 ** last page in the db image moved to the free-list. In this case the
6517 ** last page is never written out to disk, leaving the database file
6518 ** undersized. Fix this now if it is the case. */
6519 if( pPager
->dbSize
>pPager
->dbFileSize
){
6520 Pgno nNew
= pPager
->dbSize
- (pPager
->dbSize
==PAGER_MJ_PGNO(pPager
));
6521 assert( pPager
->eState
==PAGER_WRITER_DBMOD
);
6522 rc
= pager_truncate(pPager
, nNew
);
6523 if( rc
!=SQLITE_OK
) goto commit_phase_one_exit
;
6526 /* Finally, sync the database file. */
6528 rc
= sqlite3PagerSync(pPager
, zMaster
);
6530 IOTRACE(("DBSYNC %p\n", pPager
))
6534 commit_phase_one_exit
:
6535 if( rc
==SQLITE_OK
&& !pagerUseWal(pPager
) ){
6536 pPager
->eState
= PAGER_WRITER_FINISHED
;
6543 ** When this function is called, the database file has been completely
6544 ** updated to reflect the changes made by the current transaction and
6545 ** synced to disk. The journal file still exists in the file-system
6546 ** though, and if a failure occurs at this point it will eventually
6547 ** be used as a hot-journal and the current transaction rolled back.
6549 ** This function finalizes the journal file, either by deleting,
6550 ** truncating or partially zeroing it, so that it cannot be used
6551 ** for hot-journal rollback. Once this is done the transaction is
6552 ** irrevocably committed.
6554 ** If an error occurs, an IO error code is returned and the pager
6555 ** moves into the error state. Otherwise, SQLITE_OK is returned.
6557 int sqlite3PagerCommitPhaseTwo(Pager
*pPager
){
6558 int rc
= SQLITE_OK
; /* Return code */
6560 /* This routine should not be called if a prior error has occurred.
6561 ** But if (due to a coding error elsewhere in the system) it does get
6562 ** called, just return the same error code without doing anything. */
6563 if( NEVER(pPager
->errCode
) ) return pPager
->errCode
;
6565 assert( pPager
->eState
==PAGER_WRITER_LOCKED
6566 || pPager
->eState
==PAGER_WRITER_FINISHED
6567 || (pagerUseWal(pPager
) && pPager
->eState
==PAGER_WRITER_CACHEMOD
)
6569 assert( assert_pager_state(pPager
) );
6571 /* An optimization. If the database was not actually modified during
6572 ** this transaction, the pager is running in exclusive-mode and is
6573 ** using persistent journals, then this function is a no-op.
6575 ** The start of the journal file currently contains a single journal
6576 ** header with the nRec field set to 0. If such a journal is used as
6577 ** a hot-journal during hot-journal rollback, 0 changes will be made
6578 ** to the database file. So there is no need to zero the journal
6579 ** header. Since the pager is in exclusive mode, there is no need
6580 ** to drop any locks either.
6582 if( pPager
->eState
==PAGER_WRITER_LOCKED
6583 && pPager
->exclusiveMode
6584 && pPager
->journalMode
==PAGER_JOURNALMODE_PERSIST
6586 assert( pPager
->journalOff
==JOURNAL_HDR_SZ(pPager
) || !pPager
->journalOff
);
6587 pPager
->eState
= PAGER_READER
;
6591 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager
)));
6592 pPager
->iDataVersion
++;
6593 rc
= pager_end_transaction(pPager
, pPager
->setMaster
, 1);
6594 return pager_error(pPager
, rc
);
6598 ** If a write transaction is open, then all changes made within the
6599 ** transaction are reverted and the current write-transaction is closed.
6600 ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
6601 ** state if an error occurs.
6603 ** If the pager is already in PAGER_ERROR state when this function is called,
6604 ** it returns Pager.errCode immediately. No work is performed in this case.
6606 ** Otherwise, in rollback mode, this function performs two functions:
6608 ** 1) It rolls back the journal file, restoring all database file and
6609 ** in-memory cache pages to the state they were in when the transaction
6612 ** 2) It finalizes the journal file, so that it is not used for hot
6613 ** rollback at any point in the future.
6615 ** Finalization of the journal file (task 2) is only performed if the
6616 ** rollback is successful.
6618 ** In WAL mode, all cache-entries containing data modified within the
6619 ** current transaction are either expelled from the cache or reverted to
6620 ** their pre-transaction state by re-reading data from the database or
6621 ** WAL files. The WAL transaction is then closed.
6623 int sqlite3PagerRollback(Pager
*pPager
){
6624 int rc
= SQLITE_OK
; /* Return code */
6625 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager
)));
6627 /* PagerRollback() is a no-op if called in READER or OPEN state. If
6628 ** the pager is already in the ERROR state, the rollback is not
6629 ** attempted here. Instead, the error code is returned to the caller.
6631 assert( assert_pager_state(pPager
) );
6632 if( pPager
->eState
==PAGER_ERROR
) return pPager
->errCode
;
6633 if( pPager
->eState
<=PAGER_READER
) return SQLITE_OK
;
6635 if( pagerUseWal(pPager
) ){
6637 rc
= sqlite3PagerSavepoint(pPager
, SAVEPOINT_ROLLBACK
, -1);
6638 rc2
= pager_end_transaction(pPager
, pPager
->setMaster
, 0);
6639 if( rc
==SQLITE_OK
) rc
= rc2
;
6640 }else if( !isOpen(pPager
->jfd
) || pPager
->eState
==PAGER_WRITER_LOCKED
){
6641 int eState
= pPager
->eState
;
6642 rc
= pager_end_transaction(pPager
, 0, 0);
6643 if( !MEMDB
&& eState
>PAGER_WRITER_LOCKED
){
6644 /* This can happen using journal_mode=off. Move the pager to the error
6645 ** state to indicate that the contents of the cache may not be trusted.
6646 ** Any active readers will get SQLITE_ABORT.
6648 pPager
->errCode
= SQLITE_ABORT
;
6649 pPager
->eState
= PAGER_ERROR
;
6650 setGetterMethod(pPager
);
6654 rc
= pager_playback(pPager
, 0);
6657 assert( pPager
->eState
==PAGER_READER
|| rc
!=SQLITE_OK
);
6658 assert( rc
==SQLITE_OK
|| rc
==SQLITE_FULL
|| rc
==SQLITE_CORRUPT
6659 || rc
==SQLITE_NOMEM
|| (rc
&0xFF)==SQLITE_IOERR
6660 || rc
==SQLITE_CANTOPEN
6663 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
6664 ** cache. So call pager_error() on the way out to make any error persistent.
6666 return pager_error(pPager
, rc
);
6670 ** Return TRUE if the database file is opened read-only. Return FALSE
6671 ** if the database is (in theory) writable.
6673 u8
sqlite3PagerIsreadonly(Pager
*pPager
){
6674 return pPager
->readOnly
;
6679 ** Return the sum of the reference counts for all pages held by pPager.
6681 int sqlite3PagerRefcount(Pager
*pPager
){
6682 return sqlite3PcacheRefCount(pPager
->pPCache
);
6687 ** Return the approximate number of bytes of memory currently
6688 ** used by the pager and its associated cache.
6690 int sqlite3PagerMemUsed(Pager
*pPager
){
6691 int perPageSize
= pPager
->pageSize
+ pPager
->nExtra
+ sizeof(PgHdr
)
6693 return perPageSize
*sqlite3PcachePagecount(pPager
->pPCache
)
6694 + sqlite3MallocSize(pPager
)
6699 ** Return the number of references to the specified page.
6701 int sqlite3PagerPageRefcount(DbPage
*pPage
){
6702 return sqlite3PcachePageRefcount(pPage
);
6707 ** This routine is used for testing and analysis only.
6709 int *sqlite3PagerStats(Pager
*pPager
){
6711 a
[0] = sqlite3PcacheRefCount(pPager
->pPCache
);
6712 a
[1] = sqlite3PcachePagecount(pPager
->pPCache
);
6713 a
[2] = sqlite3PcacheGetCachesize(pPager
->pPCache
);
6714 a
[3] = pPager
->eState
==PAGER_OPEN
? -1 : (int) pPager
->dbSize
;
6715 a
[4] = pPager
->eState
;
6716 a
[5] = pPager
->errCode
;
6717 a
[6] = pPager
->aStat
[PAGER_STAT_HIT
];
6718 a
[7] = pPager
->aStat
[PAGER_STAT_MISS
];
6719 a
[8] = 0; /* Used to be pPager->nOvfl */
6720 a
[9] = pPager
->nRead
;
6721 a
[10] = pPager
->aStat
[PAGER_STAT_WRITE
];
6727 ** Parameter eStat must be either SQLITE_DBSTATUS_CACHE_HIT or
6728 ** SQLITE_DBSTATUS_CACHE_MISS. Before returning, *pnVal is incremented by the
6729 ** current cache hit or miss count, according to the value of eStat. If the
6730 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
6733 void sqlite3PagerCacheStat(Pager
*pPager
, int eStat
, int reset
, int *pnVal
){
6735 assert( eStat
==SQLITE_DBSTATUS_CACHE_HIT
6736 || eStat
==SQLITE_DBSTATUS_CACHE_MISS
6737 || eStat
==SQLITE_DBSTATUS_CACHE_WRITE
6740 assert( SQLITE_DBSTATUS_CACHE_HIT
+1==SQLITE_DBSTATUS_CACHE_MISS
);
6741 assert( SQLITE_DBSTATUS_CACHE_HIT
+2==SQLITE_DBSTATUS_CACHE_WRITE
);
6742 assert( PAGER_STAT_HIT
==0 && PAGER_STAT_MISS
==1 && PAGER_STAT_WRITE
==2 );
6744 *pnVal
+= pPager
->aStat
[eStat
- SQLITE_DBSTATUS_CACHE_HIT
];
6746 pPager
->aStat
[eStat
- SQLITE_DBSTATUS_CACHE_HIT
] = 0;
6751 ** Return true if this is an in-memory or temp-file backed pager.
6753 int sqlite3PagerIsMemdb(Pager
*pPager
){
6754 return pPager
->tempFile
;
6758 ** Check that there are at least nSavepoint savepoints open. If there are
6759 ** currently less than nSavepoints open, then open one or more savepoints
6760 ** to make up the difference. If the number of savepoints is already
6761 ** equal to nSavepoint, then this function is a no-op.
6763 ** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
6764 ** occurs while opening the sub-journal file, then an IO error code is
6765 ** returned. Otherwise, SQLITE_OK.
6767 static SQLITE_NOINLINE
int pagerOpenSavepoint(Pager
*pPager
, int nSavepoint
){
6768 int rc
= SQLITE_OK
; /* Return code */
6769 int nCurrent
= pPager
->nSavepoint
; /* Current number of savepoints */
6770 int ii
; /* Iterator variable */
6771 PagerSavepoint
*aNew
; /* New Pager.aSavepoint array */
6773 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6774 assert( assert_pager_state(pPager
) );
6775 assert( nSavepoint
>nCurrent
&& pPager
->useJournal
);
6777 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
6778 ** if the allocation fails. Otherwise, zero the new portion in case a
6779 ** malloc failure occurs while populating it in the for(...) loop below.
6781 aNew
= (PagerSavepoint
*)sqlite3Realloc(
6782 pPager
->aSavepoint
, sizeof(PagerSavepoint
)*nSavepoint
6785 return SQLITE_NOMEM_BKPT
;
6787 memset(&aNew
[nCurrent
], 0, (nSavepoint
-nCurrent
) * sizeof(PagerSavepoint
));
6788 pPager
->aSavepoint
= aNew
;
6790 /* Populate the PagerSavepoint structures just allocated. */
6791 for(ii
=nCurrent
; ii
<nSavepoint
; ii
++){
6792 aNew
[ii
].nOrig
= pPager
->dbSize
;
6793 if( isOpen(pPager
->jfd
) && pPager
->journalOff
>0 ){
6794 aNew
[ii
].iOffset
= pPager
->journalOff
;
6796 aNew
[ii
].iOffset
= JOURNAL_HDR_SZ(pPager
);
6798 aNew
[ii
].iSubRec
= pPager
->nSubRec
;
6799 aNew
[ii
].pInSavepoint
= sqlite3BitvecCreate(pPager
->dbSize
);
6800 if( !aNew
[ii
].pInSavepoint
){
6801 return SQLITE_NOMEM_BKPT
;
6803 if( pagerUseWal(pPager
) ){
6804 sqlite3WalSavepoint(pPager
->pWal
, aNew
[ii
].aWalData
);
6806 pPager
->nSavepoint
= ii
+1;
6808 assert( pPager
->nSavepoint
==nSavepoint
);
6809 assertTruncateConstraint(pPager
);
6812 int sqlite3PagerOpenSavepoint(Pager
*pPager
, int nSavepoint
){
6813 assert( pPager
->eState
>=PAGER_WRITER_LOCKED
);
6814 assert( assert_pager_state(pPager
) );
6816 if( nSavepoint
>pPager
->nSavepoint
&& pPager
->useJournal
){
6817 return pagerOpenSavepoint(pPager
, nSavepoint
);
6825 ** This function is called to rollback or release (commit) a savepoint.
6826 ** The savepoint to release or rollback need not be the most recently
6827 ** created savepoint.
6829 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
6830 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
6831 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
6832 ** that have occurred since the specified savepoint was created.
6834 ** The savepoint to rollback or release is identified by parameter
6835 ** iSavepoint. A value of 0 means to operate on the outermost savepoint
6836 ** (the first created). A value of (Pager.nSavepoint-1) means operate
6837 ** on the most recently created savepoint. If iSavepoint is greater than
6838 ** (Pager.nSavepoint-1), then this function is a no-op.
6840 ** If a negative value is passed to this function, then the current
6841 ** transaction is rolled back. This is different to calling
6842 ** sqlite3PagerRollback() because this function does not terminate
6843 ** the transaction or unlock the database, it just restores the
6844 ** contents of the database to its original state.
6846 ** In any case, all savepoints with an index greater than iSavepoint
6847 ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
6848 ** then savepoint iSavepoint is also destroyed.
6850 ** This function may return SQLITE_NOMEM if a memory allocation fails,
6851 ** or an IO error code if an IO error occurs while rolling back a
6852 ** savepoint. If no errors occur, SQLITE_OK is returned.
6854 int sqlite3PagerSavepoint(Pager
*pPager
, int op
, int iSavepoint
){
6855 int rc
= pPager
->errCode
;
6857 #ifdef SQLITE_ENABLE_ZIPVFS
6858 if( op
==SAVEPOINT_RELEASE
) rc
= SQLITE_OK
;
6861 assert( op
==SAVEPOINT_RELEASE
|| op
==SAVEPOINT_ROLLBACK
);
6862 assert( iSavepoint
>=0 || op
==SAVEPOINT_ROLLBACK
);
6864 if( rc
==SQLITE_OK
&& iSavepoint
<pPager
->nSavepoint
){
6865 int ii
; /* Iterator variable */
6866 int nNew
; /* Number of remaining savepoints after this op. */
6868 /* Figure out how many savepoints will still be active after this
6869 ** operation. Store this value in nNew. Then free resources associated
6870 ** with any savepoints that are destroyed by this operation.
6872 nNew
= iSavepoint
+ (( op
==SAVEPOINT_RELEASE
) ? 0 : 1);
6873 for(ii
=nNew
; ii
<pPager
->nSavepoint
; ii
++){
6874 sqlite3BitvecDestroy(pPager
->aSavepoint
[ii
].pInSavepoint
);
6876 pPager
->nSavepoint
= nNew
;
6878 /* If this is a release of the outermost savepoint, truncate
6879 ** the sub-journal to zero bytes in size. */
6880 if( op
==SAVEPOINT_RELEASE
){
6881 if( nNew
==0 && isOpen(pPager
->sjfd
) ){
6882 /* Only truncate if it is an in-memory sub-journal. */
6883 if( sqlite3JournalIsInMemory(pPager
->sjfd
) ){
6884 rc
= sqlite3OsTruncate(pPager
->sjfd
, 0);
6885 assert( rc
==SQLITE_OK
);
6887 pPager
->nSubRec
= 0;
6890 /* Else this is a rollback operation, playback the specified savepoint.
6891 ** If this is a temp-file, it is possible that the journal file has
6892 ** not yet been opened. In this case there have been no changes to
6893 ** the database file, so the playback operation can be skipped.
6895 else if( pagerUseWal(pPager
) || isOpen(pPager
->jfd
) ){
6896 PagerSavepoint
*pSavepoint
= (nNew
==0)?0:&pPager
->aSavepoint
[nNew
-1];
6897 rc
= pagerPlaybackSavepoint(pPager
, pSavepoint
);
6898 assert(rc
!=SQLITE_DONE
);
6901 #ifdef SQLITE_ENABLE_ZIPVFS
6902 /* If the cache has been modified but the savepoint cannot be rolled
6903 ** back journal_mode=off, put the pager in the error state. This way,
6904 ** if the VFS used by this pager includes ZipVFS, the entire transaction
6905 ** can be rolled back at the ZipVFS level. */
6907 pPager
->journalMode
==PAGER_JOURNALMODE_OFF
6908 && pPager
->eState
>=PAGER_WRITER_CACHEMOD
6910 pPager
->errCode
= SQLITE_ABORT
;
6911 pPager
->eState
= PAGER_ERROR
;
6912 setGetterMethod(pPager
);
6921 ** Return the full pathname of the database file.
6923 ** Except, if the pager is in-memory only, then return an empty string if
6924 ** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when
6925 ** used to report the filename to the user, for compatibility with legacy
6926 ** behavior. But when the Btree needs to know the filename for matching to
6927 ** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
6928 ** participate in shared-cache.
6930 const char *sqlite3PagerFilename(Pager
*pPager
, int nullIfMemDb
){
6931 return (nullIfMemDb
&& pPager
->memDb
) ? "" : pPager
->zFilename
;
6935 ** Return the VFS structure for the pager.
6937 sqlite3_vfs
*sqlite3PagerVfs(Pager
*pPager
){
6938 return pPager
->pVfs
;
6942 ** Return the file handle for the database file associated
6943 ** with the pager. This might return NULL if the file has
6944 ** not yet been opened.
6946 sqlite3_file
*sqlite3PagerFile(Pager
*pPager
){
6951 ** Return the file handle for the journal file (if it exists).
6952 ** This will be either the rollback journal or the WAL file.
6954 sqlite3_file
*sqlite3PagerJrnlFile(Pager
*pPager
){
6958 return pPager
->pWal
? sqlite3WalFile(pPager
->pWal
) : pPager
->jfd
;
6963 ** Return the full pathname of the journal file.
6965 const char *sqlite3PagerJournalname(Pager
*pPager
){
6966 return pPager
->zJournal
;
6969 #ifdef SQLITE_HAS_CODEC
6971 ** Set or retrieve the codec for this pager
6973 void sqlite3PagerSetCodec(
6975 void *(*xCodec
)(void*,void*,Pgno
,int),
6976 void (*xCodecSizeChng
)(void*,int,int),
6977 void (*xCodecFree
)(void*),
6980 if( pPager
->xCodecFree
) pPager
->xCodecFree(pPager
->pCodec
);
6981 pPager
->xCodec
= pPager
->memDb
? 0 : xCodec
;
6982 pPager
->xCodecSizeChng
= xCodecSizeChng
;
6983 pPager
->xCodecFree
= xCodecFree
;
6984 pPager
->pCodec
= pCodec
;
6985 setGetterMethod(pPager
);
6986 pagerReportSize(pPager
);
6988 void *sqlite3PagerGetCodec(Pager
*pPager
){
6989 return pPager
->pCodec
;
6993 ** This function is called by the wal module when writing page content
6994 ** into the log file.
6996 ** This function returns a pointer to a buffer containing the encrypted
6997 ** page content. If a malloc fails, this function may return NULL.
6999 void *sqlite3PagerCodec(PgHdr
*pPg
){
7001 CODEC2(pPg
->pPager
, pPg
->pData
, pPg
->pgno
, 6, return 0, aData
);
7006 ** Return the current pager state
7008 int sqlite3PagerState(Pager
*pPager
){
7009 return pPager
->eState
;
7011 #endif /* SQLITE_HAS_CODEC */
7013 #ifndef SQLITE_OMIT_AUTOVACUUM
7015 ** Move the page pPg to location pgno in the file.
7017 ** There must be no references to the page previously located at
7018 ** pgno (which we call pPgOld) though that page is allowed to be
7019 ** in cache. If the page previously located at pgno is not already
7020 ** in the rollback journal, it is not put there by by this routine.
7022 ** References to the page pPg remain valid. Updating any
7023 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
7024 ** allocated along with the page) is the responsibility of the caller.
7026 ** A transaction must be active when this routine is called. It used to be
7027 ** required that a statement transaction was not active, but this restriction
7028 ** has been removed (CREATE INDEX needs to move a page when a statement
7029 ** transaction is active).
7031 ** If the fourth argument, isCommit, is non-zero, then this page is being
7032 ** moved as part of a database reorganization just before the transaction
7033 ** is being committed. In this case, it is guaranteed that the database page
7034 ** pPg refers to will not be written to again within this transaction.
7036 ** This function may return SQLITE_NOMEM or an IO error code if an error
7037 ** occurs. Otherwise, it returns SQLITE_OK.
7039 int sqlite3PagerMovepage(Pager
*pPager
, DbPage
*pPg
, Pgno pgno
, int isCommit
){
7040 PgHdr
*pPgOld
; /* The page being overwritten. */
7041 Pgno needSyncPgno
= 0; /* Old value of pPg->pgno, if sync is required */
7042 int rc
; /* Return code */
7043 Pgno origPgno
; /* The original page number */
7045 assert( pPg
->nRef
>0 );
7046 assert( pPager
->eState
==PAGER_WRITER_CACHEMOD
7047 || pPager
->eState
==PAGER_WRITER_DBMOD
7049 assert( assert_pager_state(pPager
) );
7051 /* In order to be able to rollback, an in-memory database must journal
7052 ** the page we are moving from.
7054 assert( pPager
->tempFile
|| !MEMDB
);
7055 if( pPager
->tempFile
){
7056 rc
= sqlite3PagerWrite(pPg
);
7060 /* If the page being moved is dirty and has not been saved by the latest
7061 ** savepoint, then save the current contents of the page into the
7062 ** sub-journal now. This is required to handle the following scenario:
7065 ** <journal page X, then modify it in memory>
7067 ** <Move page X to location Y>
7070 ** If page X were not written to the sub-journal here, it would not
7071 ** be possible to restore its contents when the "ROLLBACK TO one"
7072 ** statement were is processed.
7074 ** subjournalPage() may need to allocate space to store pPg->pgno into
7075 ** one or more savepoint bitvecs. This is the reason this function
7076 ** may return SQLITE_NOMEM.
7078 if( (pPg
->flags
& PGHDR_DIRTY
)!=0
7079 && SQLITE_OK
!=(rc
= subjournalPageIfRequired(pPg
))
7084 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
7085 PAGERID(pPager
), pPg
->pgno
, (pPg
->flags
&PGHDR_NEED_SYNC
)?1:0, pgno
));
7086 IOTRACE(("MOVE %p %d %d\n", pPager
, pPg
->pgno
, pgno
))
7088 /* If the journal needs to be sync()ed before page pPg->pgno can
7089 ** be written to, store pPg->pgno in local variable needSyncPgno.
7091 ** If the isCommit flag is set, there is no need to remember that
7092 ** the journal needs to be sync()ed before database page pPg->pgno
7093 ** can be written to. The caller has already promised not to write to it.
7095 if( (pPg
->flags
&PGHDR_NEED_SYNC
) && !isCommit
){
7096 needSyncPgno
= pPg
->pgno
;
7097 assert( pPager
->journalMode
==PAGER_JOURNALMODE_OFF
||
7098 pageInJournal(pPager
, pPg
) || pPg
->pgno
>pPager
->dbOrigSize
);
7099 assert( pPg
->flags
&PGHDR_DIRTY
);
7102 /* If the cache contains a page with page-number pgno, remove it
7103 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
7104 ** page pgno before the 'move' operation, it needs to be retained
7105 ** for the page moved there.
7107 pPg
->flags
&= ~PGHDR_NEED_SYNC
;
7108 pPgOld
= sqlite3PagerLookup(pPager
, pgno
);
7109 assert( !pPgOld
|| pPgOld
->nRef
==1 );
7111 pPg
->flags
|= (pPgOld
->flags
&PGHDR_NEED_SYNC
);
7112 if( pPager
->tempFile
){
7113 /* Do not discard pages from an in-memory database since we might
7114 ** need to rollback later. Just move the page out of the way. */
7115 sqlite3PcacheMove(pPgOld
, pPager
->dbSize
+1);
7117 sqlite3PcacheDrop(pPgOld
);
7121 origPgno
= pPg
->pgno
;
7122 sqlite3PcacheMove(pPg
, pgno
);
7123 sqlite3PcacheMakeDirty(pPg
);
7125 /* For an in-memory database, make sure the original page continues
7126 ** to exist, in case the transaction needs to roll back. Use pPgOld
7127 ** as the original page since it has already been allocated.
7129 if( pPager
->tempFile
&& pPgOld
){
7130 sqlite3PcacheMove(pPgOld
, origPgno
);
7131 sqlite3PagerUnrefNotNull(pPgOld
);
7135 /* If needSyncPgno is non-zero, then the journal file needs to be
7136 ** sync()ed before any data is written to database file page needSyncPgno.
7137 ** Currently, no such page exists in the page-cache and the
7138 ** "is journaled" bitvec flag has been set. This needs to be remedied by
7139 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
7142 ** If the attempt to load the page into the page-cache fails, (due
7143 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
7144 ** array. Otherwise, if the page is loaded and written again in
7145 ** this transaction, it may be written to the database file before
7146 ** it is synced into the journal file. This way, it may end up in
7147 ** the journal file twice, but that is not a problem.
7150 rc
= sqlite3PagerGet(pPager
, needSyncPgno
, &pPgHdr
, 0);
7151 if( rc
!=SQLITE_OK
){
7152 if( needSyncPgno
<=pPager
->dbOrigSize
){
7153 assert( pPager
->pTmpSpace
!=0 );
7154 sqlite3BitvecClear(pPager
->pInJournal
, needSyncPgno
, pPager
->pTmpSpace
);
7158 pPgHdr
->flags
|= PGHDR_NEED_SYNC
;
7159 sqlite3PcacheMakeDirty(pPgHdr
);
7160 sqlite3PagerUnrefNotNull(pPgHdr
);
7168 ** The page handle passed as the first argument refers to a dirty page
7169 ** with a page number other than iNew. This function changes the page's
7170 ** page number to iNew and sets the value of the PgHdr.flags field to
7171 ** the value passed as the third parameter.
7173 void sqlite3PagerRekey(DbPage
*pPg
, Pgno iNew
, u16 flags
){
7174 assert( pPg
->pgno
!=iNew
);
7176 sqlite3PcacheMove(pPg
, iNew
);
7180 ** Return a pointer to the data for the specified page.
7182 void *sqlite3PagerGetData(DbPage
*pPg
){
7183 assert( pPg
->nRef
>0 || pPg
->pPager
->memDb
);
7188 ** Return a pointer to the Pager.nExtra bytes of "extra" space
7189 ** allocated along with the specified page.
7191 void *sqlite3PagerGetExtra(DbPage
*pPg
){
7196 ** Get/set the locking-mode for this pager. Parameter eMode must be one
7197 ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
7198 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
7199 ** the locking-mode is set to the value specified.
7201 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
7202 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
7205 int sqlite3PagerLockingMode(Pager
*pPager
, int eMode
){
7206 assert( eMode
==PAGER_LOCKINGMODE_QUERY
7207 || eMode
==PAGER_LOCKINGMODE_NORMAL
7208 || eMode
==PAGER_LOCKINGMODE_EXCLUSIVE
);
7209 assert( PAGER_LOCKINGMODE_QUERY
<0 );
7210 assert( PAGER_LOCKINGMODE_NORMAL
>=0 && PAGER_LOCKINGMODE_EXCLUSIVE
>=0 );
7211 assert( pPager
->exclusiveMode
|| 0==sqlite3WalHeapMemory(pPager
->pWal
) );
7212 if( eMode
>=0 && !pPager
->tempFile
&& !sqlite3WalHeapMemory(pPager
->pWal
) ){
7213 pPager
->exclusiveMode
= (u8
)eMode
;
7215 return (int)pPager
->exclusiveMode
;
7219 ** Set the journal-mode for this pager. Parameter eMode must be one of:
7221 ** PAGER_JOURNALMODE_DELETE
7222 ** PAGER_JOURNALMODE_TRUNCATE
7223 ** PAGER_JOURNALMODE_PERSIST
7224 ** PAGER_JOURNALMODE_OFF
7225 ** PAGER_JOURNALMODE_MEMORY
7226 ** PAGER_JOURNALMODE_WAL
7228 ** The journalmode is set to the value specified if the change is allowed.
7229 ** The change may be disallowed for the following reasons:
7231 ** * An in-memory database can only have its journal_mode set to _OFF
7234 ** * Temporary databases cannot have _WAL journalmode.
7236 ** The returned indicate the current (possibly updated) journal-mode.
7238 int sqlite3PagerSetJournalMode(Pager
*pPager
, int eMode
){
7239 u8 eOld
= pPager
->journalMode
; /* Prior journalmode */
7242 /* The print_pager_state() routine is intended to be used by the debugger
7243 ** only. We invoke it once here to suppress a compiler warning. */
7244 print_pager_state(pPager
);
7248 /* The eMode parameter is always valid */
7249 assert( eMode
==PAGER_JOURNALMODE_DELETE
7250 || eMode
==PAGER_JOURNALMODE_TRUNCATE
7251 || eMode
==PAGER_JOURNALMODE_PERSIST
7252 || eMode
==PAGER_JOURNALMODE_OFF
7253 || eMode
==PAGER_JOURNALMODE_WAL
7254 || eMode
==PAGER_JOURNALMODE_MEMORY
);
7256 /* This routine is only called from the OP_JournalMode opcode, and
7257 ** the logic there will never allow a temporary file to be changed
7260 assert( pPager
->tempFile
==0 || eMode
!=PAGER_JOURNALMODE_WAL
);
7262 /* Do allow the journalmode of an in-memory database to be set to
7263 ** anything other than MEMORY or OFF
7266 assert( eOld
==PAGER_JOURNALMODE_MEMORY
|| eOld
==PAGER_JOURNALMODE_OFF
);
7267 if( eMode
!=PAGER_JOURNALMODE_MEMORY
&& eMode
!=PAGER_JOURNALMODE_OFF
){
7274 /* Change the journal mode. */
7275 assert( pPager
->eState
!=PAGER_ERROR
);
7276 pPager
->journalMode
= (u8
)eMode
;
7278 /* When transistioning from TRUNCATE or PERSIST to any other journal
7279 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
7280 ** delete the journal file.
7282 assert( (PAGER_JOURNALMODE_TRUNCATE
& 5)==1 );
7283 assert( (PAGER_JOURNALMODE_PERSIST
& 5)==1 );
7284 assert( (PAGER_JOURNALMODE_DELETE
& 5)==0 );
7285 assert( (PAGER_JOURNALMODE_MEMORY
& 5)==4 );
7286 assert( (PAGER_JOURNALMODE_OFF
& 5)==0 );
7287 assert( (PAGER_JOURNALMODE_WAL
& 5)==5 );
7289 assert( isOpen(pPager
->fd
) || pPager
->exclusiveMode
);
7290 if( !pPager
->exclusiveMode
&& (eOld
& 5)==1 && (eMode
& 1)==0 ){
7292 /* In this case we would like to delete the journal file. If it is
7293 ** not possible, then that is not a problem. Deleting the journal file
7294 ** here is an optimization only.
7296 ** Before deleting the journal file, obtain a RESERVED lock on the
7297 ** database file. This ensures that the journal file is not deleted
7298 ** while it is in use by some other client.
7300 sqlite3OsClose(pPager
->jfd
);
7301 if( pPager
->eLock
>=RESERVED_LOCK
){
7302 sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, 0);
7305 int state
= pPager
->eState
;
7306 assert( state
==PAGER_OPEN
|| state
==PAGER_READER
);
7307 if( state
==PAGER_OPEN
){
7308 rc
= sqlite3PagerSharedLock(pPager
);
7310 if( pPager
->eState
==PAGER_READER
){
7311 assert( rc
==SQLITE_OK
);
7312 rc
= pagerLockDb(pPager
, RESERVED_LOCK
);
7314 if( rc
==SQLITE_OK
){
7315 sqlite3OsDelete(pPager
->pVfs
, pPager
->zJournal
, 0);
7317 if( rc
==SQLITE_OK
&& state
==PAGER_READER
){
7318 pagerUnlockDb(pPager
, SHARED_LOCK
);
7319 }else if( state
==PAGER_OPEN
){
7320 pager_unlock(pPager
);
7322 assert( state
==pPager
->eState
);
7324 }else if( eMode
==PAGER_JOURNALMODE_OFF
){
7325 sqlite3OsClose(pPager
->jfd
);
7329 /* Return the new journal mode */
7330 return (int)pPager
->journalMode
;
7334 ** Return the current journal mode.
7336 int sqlite3PagerGetJournalMode(Pager
*pPager
){
7337 return (int)pPager
->journalMode
;
7341 ** Return TRUE if the pager is in a state where it is OK to change the
7342 ** journalmode. Journalmode changes can only happen when the database
7345 int sqlite3PagerOkToChangeJournalMode(Pager
*pPager
){
7346 assert( assert_pager_state(pPager
) );
7347 if( pPager
->eState
>=PAGER_WRITER_CACHEMOD
) return 0;
7348 if( NEVER(isOpen(pPager
->jfd
) && pPager
->journalOff
>0) ) return 0;
7353 ** Get/set the size-limit used for persistent journal files.
7355 ** Setting the size limit to -1 means no limit is enforced.
7356 ** An attempt to set a limit smaller than -1 is a no-op.
7358 i64
sqlite3PagerJournalSizeLimit(Pager
*pPager
, i64 iLimit
){
7360 pPager
->journalSizeLimit
= iLimit
;
7361 sqlite3WalLimit(pPager
->pWal
, iLimit
);
7363 return pPager
->journalSizeLimit
;
7367 ** Return a pointer to the pPager->pBackup variable. The backup module
7368 ** in backup.c maintains the content of this variable. This module
7369 ** uses it opaquely as an argument to sqlite3BackupRestart() and
7370 ** sqlite3BackupUpdate() only.
7372 sqlite3_backup
**sqlite3PagerBackupPtr(Pager
*pPager
){
7373 return &pPager
->pBackup
;
7376 #ifndef SQLITE_OMIT_VACUUM
7378 ** Unless this is an in-memory or temporary database, clear the pager cache.
7380 void sqlite3PagerClearCache(Pager
*pPager
){
7381 assert( MEMDB
==0 || pPager
->tempFile
);
7382 if( pPager
->tempFile
==0 ) pager_reset(pPager
);
7387 #ifndef SQLITE_OMIT_WAL
7389 ** This function is called when the user invokes "PRAGMA wal_checkpoint",
7390 ** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
7391 ** or wal_blocking_checkpoint() API functions.
7393 ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
7395 int sqlite3PagerCheckpoint(
7396 Pager
*pPager
, /* Checkpoint on this pager */
7397 sqlite3
*db
, /* Db handle used to check for interrupts */
7398 int eMode
, /* Type of checkpoint */
7399 int *pnLog
, /* OUT: Final number of frames in log */
7400 int *pnCkpt
/* OUT: Final number of checkpointed frames */
7404 rc
= sqlite3WalCheckpoint(pPager
->pWal
, db
, eMode
,
7405 (eMode
==SQLITE_CHECKPOINT_PASSIVE
? 0 : pPager
->xBusyHandler
),
7406 pPager
->pBusyHandlerArg
,
7407 pPager
->walSyncFlags
, pPager
->pageSize
, (u8
*)pPager
->pTmpSpace
,
7414 int sqlite3PagerWalCallback(Pager
*pPager
){
7415 return sqlite3WalCallback(pPager
->pWal
);
7419 ** Return true if the underlying VFS for the given pager supports the
7420 ** primitives necessary for write-ahead logging.
7422 int sqlite3PagerWalSupported(Pager
*pPager
){
7423 const sqlite3_io_methods
*pMethods
= pPager
->fd
->pMethods
;
7424 if( pPager
->noLock
) return 0;
7425 return pPager
->exclusiveMode
|| (pMethods
->iVersion
>=2 && pMethods
->xShmMap
);
7429 ** Attempt to take an exclusive lock on the database file. If a PENDING lock
7430 ** is obtained instead, immediately release it.
7432 static int pagerExclusiveLock(Pager
*pPager
){
7433 int rc
; /* Return code */
7435 assert( pPager
->eLock
==SHARED_LOCK
|| pPager
->eLock
==EXCLUSIVE_LOCK
);
7436 rc
= pagerLockDb(pPager
, EXCLUSIVE_LOCK
);
7437 if( rc
!=SQLITE_OK
){
7438 /* If the attempt to grab the exclusive lock failed, release the
7439 ** pending lock that may have been obtained instead. */
7440 pagerUnlockDb(pPager
, SHARED_LOCK
);
7447 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
7448 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
7449 ** lock on the database file and use heap-memory to store the wal-index
7450 ** in. Otherwise, use the normal shared-memory.
7452 static int pagerOpenWal(Pager
*pPager
){
7455 assert( pPager
->pWal
==0 && pPager
->tempFile
==0 );
7456 assert( pPager
->eLock
==SHARED_LOCK
|| pPager
->eLock
==EXCLUSIVE_LOCK
);
7458 /* If the pager is already in exclusive-mode, the WAL module will use
7459 ** heap-memory for the wal-index instead of the VFS shared-memory
7460 ** implementation. Take the exclusive lock now, before opening the WAL
7461 ** file, to make sure this is safe.
7463 if( pPager
->exclusiveMode
){
7464 rc
= pagerExclusiveLock(pPager
);
7467 /* Open the connection to the log file. If this operation fails,
7468 ** (e.g. due to malloc() failure), return an error code.
7470 if( rc
==SQLITE_OK
){
7471 rc
= sqlite3WalOpen(pPager
->pVfs
,
7472 pPager
->fd
, pPager
->zWal
, pPager
->exclusiveMode
,
7473 pPager
->journalSizeLimit
, &pPager
->pWal
7476 pagerFixMaplimit(pPager
);
7483 ** The caller must be holding a SHARED lock on the database file to call
7486 ** If the pager passed as the first argument is open on a real database
7487 ** file (not a temp file or an in-memory database), and the WAL file
7488 ** is not already open, make an attempt to open it now. If successful,
7489 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
7490 ** not support the xShmXXX() methods, return an error code. *pbOpen is
7491 ** not modified in either case.
7493 ** If the pager is open on a temp-file (or in-memory database), or if
7494 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
7495 ** without doing anything.
7497 int sqlite3PagerOpenWal(
7498 Pager
*pPager
, /* Pager object */
7499 int *pbOpen
/* OUT: Set to true if call is a no-op */
7501 int rc
= SQLITE_OK
; /* Return code */
7503 assert( assert_pager_state(pPager
) );
7504 assert( pPager
->eState
==PAGER_OPEN
|| pbOpen
);
7505 assert( pPager
->eState
==PAGER_READER
|| !pbOpen
);
7506 assert( pbOpen
==0 || *pbOpen
==0 );
7507 assert( pbOpen
!=0 || (!pPager
->tempFile
&& !pPager
->pWal
) );
7509 if( !pPager
->tempFile
&& !pPager
->pWal
){
7510 if( !sqlite3PagerWalSupported(pPager
) ) return SQLITE_CANTOPEN
;
7512 /* Close any rollback journal previously open */
7513 sqlite3OsClose(pPager
->jfd
);
7515 rc
= pagerOpenWal(pPager
);
7516 if( rc
==SQLITE_OK
){
7517 pPager
->journalMode
= PAGER_JOURNALMODE_WAL
;
7518 pPager
->eState
= PAGER_OPEN
;
7528 ** This function is called to close the connection to the log file prior
7529 ** to switching from WAL to rollback mode.
7531 ** Before closing the log file, this function attempts to take an
7532 ** EXCLUSIVE lock on the database file. If this cannot be obtained, an
7533 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
7534 ** If successful, the EXCLUSIVE lock is not released before returning.
7536 int sqlite3PagerCloseWal(Pager
*pPager
, sqlite3
*db
){
7539 assert( pPager
->journalMode
==PAGER_JOURNALMODE_WAL
);
7541 /* If the log file is not already open, but does exist in the file-system,
7542 ** it may need to be checkpointed before the connection can switch to
7543 ** rollback mode. Open it now so this can happen.
7545 if( !pPager
->pWal
){
7547 rc
= pagerLockDb(pPager
, SHARED_LOCK
);
7548 if( rc
==SQLITE_OK
){
7549 rc
= sqlite3OsAccess(
7550 pPager
->pVfs
, pPager
->zWal
, SQLITE_ACCESS_EXISTS
, &logexists
7553 if( rc
==SQLITE_OK
&& logexists
){
7554 rc
= pagerOpenWal(pPager
);
7558 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
7559 ** the database file, the log and log-summary files will be deleted.
7561 if( rc
==SQLITE_OK
&& pPager
->pWal
){
7562 rc
= pagerExclusiveLock(pPager
);
7563 if( rc
==SQLITE_OK
){
7564 rc
= sqlite3WalClose(pPager
->pWal
, db
, pPager
->walSyncFlags
,
7565 pPager
->pageSize
, (u8
*)pPager
->pTmpSpace
);
7567 pagerFixMaplimit(pPager
);
7568 if( rc
&& !pPager
->exclusiveMode
) pagerUnlockDb(pPager
, SHARED_LOCK
);
7574 #ifdef SQLITE_ENABLE_SNAPSHOT
7576 ** If this is a WAL database, obtain a snapshot handle for the snapshot
7577 ** currently open. Otherwise, return an error.
7579 int sqlite3PagerSnapshotGet(Pager
*pPager
, sqlite3_snapshot
**ppSnapshot
){
7580 int rc
= SQLITE_ERROR
;
7582 rc
= sqlite3WalSnapshotGet(pPager
->pWal
, ppSnapshot
);
7588 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
7589 ** read transaction is opened, attempt to read from the snapshot it
7590 ** identifies. If this is not a WAL database, return an error.
7592 int sqlite3PagerSnapshotOpen(Pager
*pPager
, sqlite3_snapshot
*pSnapshot
){
7595 sqlite3WalSnapshotOpen(pPager
->pWal
, pSnapshot
);
7603 ** If this is a WAL database, call sqlite3WalSnapshotRecover(). If this
7604 ** is not a WAL database, return an error.
7606 int sqlite3PagerSnapshotRecover(Pager
*pPager
){
7609 rc
= sqlite3WalSnapshotRecover(pPager
->pWal
);
7615 #endif /* SQLITE_ENABLE_SNAPSHOT */
7616 #endif /* !SQLITE_OMIT_WAL */
7618 #ifdef SQLITE_ENABLE_ZIPVFS
7620 ** A read-lock must be held on the pager when this function is called. If
7621 ** the pager is in WAL mode and the WAL file currently contains one or more
7622 ** frames, return the size in bytes of the page images stored within the
7623 ** WAL frames. Otherwise, if this is not a WAL database or the WAL file
7624 ** is empty, return 0.
7626 int sqlite3PagerWalFramesize(Pager
*pPager
){
7627 assert( pPager
->eState
>=PAGER_READER
);
7628 return sqlite3WalFramesize(pPager
->pWal
);
7632 #endif /* SQLITE_OMIT_DISKIO */