blob: ce17b8fe62d79c36ad73b649e501c4c0c43eb8ea [file] [log] [blame]
drhed7c8552001-04-11 14:29:21 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhed7c8552001-04-11 14:29:21 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhed7c8552001-04-11 14:29:21 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drhed7c8552001-04-11 14:29:21 +000010**
11*************************************************************************
drhb19a2bc2001-09-16 00:13:26 +000012** This is the implementation of the page cache subsystem or "pager".
drhed7c8552001-04-11 14:29:21 +000013**
drhb19a2bc2001-09-16 00:13:26 +000014** 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.
drhed7c8552001-04-11 14:29:21 +000020*/
drh2e66f0b2005-04-28 17:18:48 +000021#ifndef SQLITE_OMIT_DISKIO
drhd9b02572001-04-15 00:37:09 +000022#include "sqliteInt.h"
drhc438efd2010-04-26 00:19:45 +000023#include "wal.h"
drhed7c8552001-04-11 14:29:21 +000024
drhe5918c62010-08-14 12:42:45 +000025
26/******************* NOTES ON THE DESIGN OF THE PAGER ************************
27**
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.
drh91781bd2010-04-10 17:52:57 +000031**
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.
36**
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:
39**
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
42** synced.
43**
44** (b) The page was a freelist leaf page at the start of the transaction.
45**
46** (c) The page number is greater than the largest page that existed in
47** the database file at the start of the transaction.
48**
49** (1) A page of the database file is never overwritten unless one of the
50** following are true:
51**
52** (a) The page and all other pages on the same sector are overwriteable.
53**
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.
57**
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
61** transaction.
62**
63** (3) Writes to the database file are an integer multiple of the page size
drhe5918c62010-08-14 12:42:45 +000064** in length and are aligned on a page boundary.
drh91781bd2010-04-10 17:52:57 +000065**
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.
69**
70** (5) All writes to the database file are synced prior to the rollback journal
71** being deleted, truncated, or zeroed.
72**
drh067b92b2020-06-19 15:24:12 +000073** (6) If a super-journal file is used, then all writes to the database file
74** are synced prior to the super-journal being deleted.
drh91781bd2010-04-10 17:52:57 +000075**
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
mistachkind5578432012-08-25 10:01:29 +000078** all queries. Note in particular the content of freelist leaf
peter.d.reid60ec9142014-09-06 16:39:46 +000079** pages can be changed arbitrarily without affecting the logical equivalence
drh91781bd2010-04-10 17:52:57 +000080** of the database.
81**
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
peter.d.reid60ec9142014-09-06 16:39:46 +000084** journal is rolled back, the resulting database file will be logically
drh91781bd2010-04-10 17:52:57 +000085** equivalent to the database file at the beginning of the transaction.
86**
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
91** invoke it.)
92**
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
drhe5918c62010-08-14 12:42:45 +000095** the EXCLUSIVE lock, thus signaling other connections on the same
96** database to flush their caches.
drh91781bd2010-04-10 17:52:57 +000097**
98** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
99** than one billion transactions.
100**
101** (11) A database file is well-formed at the beginning and at the conclusion
102** of every transaction.
103**
104** (12) An EXCLUSIVE lock is held on the database file when writing to
105** the database file.
106**
107** (13) A SHARED lock is held on the database file while reading any
108** content out of the database file.
drhe5918c62010-08-14 12:42:45 +0000109**
110******************************************************************************/
drh91781bd2010-04-10 17:52:57 +0000111
112/*
drhdb48ee02003-01-16 13:42:43 +0000113** Macros for troubleshooting. Normally turned off
114*/
danielk1977466be562004-06-10 02:16:01 +0000115#if 0
danielk1977f2c31ad2009-01-06 13:40:08 +0000116int sqlite3PagerTrace=1; /* True to enable tracing */
drhd3627af2006-12-18 18:34:51 +0000117#define sqlite3DebugPrintf printf
drh30d53702009-01-06 15:58:57 +0000118#define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }
drhdb48ee02003-01-16 13:42:43 +0000119#else
drh30d53702009-01-06 15:58:57 +0000120#define PAGERTRACE(X)
drhdb48ee02003-01-16 13:42:43 +0000121#endif
122
danielk1977599fcba2004-11-08 07:13:13 +0000123/*
drh30d53702009-01-06 15:58:57 +0000124** The following two macros are used within the PAGERTRACE() macros above
drhd86959f2005-11-26 03:51:18 +0000125** to print out file-descriptors.
danielk1977599fcba2004-11-08 07:13:13 +0000126**
drh85b623f2007-12-13 21:54:09 +0000127** PAGERID() takes a pointer to a Pager struct as its argument. The
danielk197762079062007-08-15 17:08:46 +0000128** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
drh85b623f2007-12-13 21:54:09 +0000129** struct as its argument.
danielk1977599fcba2004-11-08 07:13:13 +0000130*/
drhb7f4b6c2017-08-11 18:59:00 +0000131#define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd))
132#define FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd))
drhdb48ee02003-01-16 13:42:43 +0000133
134/*
dand0864082010-08-02 14:32:52 +0000135** The Pager.eState variable stores the current 'state' of a pager. A
dan431b0b42010-08-04 19:14:22 +0000136** pager may be in any one of the seven states shown in the following
137** state diagram.
138**
dande1ae342010-08-06 12:00:27 +0000139** OPEN <------+------+
dan431b0b42010-08-04 19:14:22 +0000140** | | |
141** V | |
142** +---------> READER-------+ |
143** | | |
144** | V |
dande1ae342010-08-06 12:00:27 +0000145** |<-------WRITER_LOCKED------> ERROR
dan431b0b42010-08-04 19:14:22 +0000146** | | ^
147** | V |
148** |<------WRITER_CACHEMOD-------->|
149** | | |
150** | V |
151** |<-------WRITER_DBMOD---------->|
152** | | |
153** | V |
154** +<------WRITER_FINISHED-------->+
dand0864082010-08-02 14:32:52 +0000155**
dan11f47a92010-08-06 06:54:47 +0000156**
157** List of state transitions and the C [function] that performs each:
158**
dande1ae342010-08-06 12:00:27 +0000159** OPEN -> READER [sqlite3PagerSharedLock]
160** READER -> OPEN [pager_unlock]
dan11f47a92010-08-06 06:54:47 +0000161**
dande1ae342010-08-06 12:00:27 +0000162** READER -> WRITER_LOCKED [sqlite3PagerBegin]
163** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
dan11f47a92010-08-06 06:54:47 +0000164** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
165** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
166** WRITER_*** -> READER [pager_end_transaction]
167**
168** WRITER_*** -> ERROR [pager_error]
dande1ae342010-08-06 12:00:27 +0000169** ERROR -> OPEN [pager_unlock]
dan11f47a92010-08-06 06:54:47 +0000170**
171**
dande1ae342010-08-06 12:00:27 +0000172** OPEN:
dan937ac9d2010-08-03 12:48:45 +0000173**
dan763afe62010-08-03 06:42:39 +0000174** 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.
177**
dand0864082010-08-02 14:32:52 +0000178** * No read or write transaction is active.
179** * Any lock, or no lock at all, may be held on the database file.
dan763afe62010-08-03 06:42:39 +0000180** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
dand0864082010-08-02 14:32:52 +0000181**
182** READER:
danb22aa4a2010-08-03 15:57:09 +0000183**
dan763afe62010-08-03 06:42:39 +0000184** 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.
dan54919f82010-08-05 18:53:26 +0000188**
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
dande1ae342010-08-06 12:00:27 +0000191** OPEN after the read-transaction is completed. However a connection
dan54919f82010-08-05 18:53:26 +0000192** running in locking_mode=exclusive (including temp databases) remains in
193** this state even after the read-transaction is closed. The only way
dande1ae342010-08-06 12:00:27 +0000194** a locking_mode=exclusive connection can transition from READER to OPEN
dan54919f82010-08-05 18:53:26 +0000195** is via the ERROR state (see below).
dan763afe62010-08-03 06:42:39 +0000196**
dan54919f82010-08-05 18:53:26 +0000197** * A read transaction may be active (but a write-transaction cannot).
dand0864082010-08-02 14:32:52 +0000198** * A SHARED or greater lock is held on the database file.
dan763afe62010-08-03 06:42:39 +0000199** * The dbSize variable may be trusted (even if a user-level read
dan937ac9d2010-08-03 12:48:45 +0000200** transaction is not active). The dbOrigSize and dbFileSize variables
201** may not be trusted at this point.
dan54919f82010-08-05 18:53:26 +0000202** * 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.
dand0864082010-08-02 14:32:52 +0000205**
dande1ae342010-08-06 12:00:27 +0000206** WRITER_LOCKED:
danb22aa4a2010-08-03 15:57:09 +0000207**
dan11f47a92010-08-06 06:54:47 +0000208** The pager moves to this state from READER when a write-transaction
dande1ae342010-08-06 12:00:27 +0000209** 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.
212**
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
218** file.
219**
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.
dan11f47a92010-08-06 06:54:47 +0000223**
dand0864082010-08-02 14:32:52 +0000224** * A write transaction is active.
dan11f47a92010-08-06 06:54:47 +0000225** * 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
229** called).
dand0864082010-08-02 14:32:52 +0000230** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
231** * The contents of the pager cache have not been modified.
danb22aa4a2010-08-03 15:57:09 +0000232** * The journal file may or may not be open.
233** * Nothing (not even the first header) has been written to the journal.
dand0864082010-08-02 14:32:52 +0000234**
235** WRITER_CACHEMOD:
danb22aa4a2010-08-03 15:57:09 +0000236**
dande1ae342010-08-06 12:00:27 +0000237** 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.
241**
dand0864082010-08-02 14:32:52 +0000242** * 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.
247**
248** WRITER_DBMOD:
danb22aa4a2010-08-03 15:57:09 +0000249**
dande5fd222010-08-09 19:17:29 +0000250** 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).
254**
dand0864082010-08-02 14:32:52 +0000255** * 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
260** written to disk).
261**
262** WRITER_FINISHED:
danb22aa4a2010-08-03 15:57:09 +0000263**
dande5fd222010-08-09 19:17:29 +0000264** It is not possible for a WAL connection to enter this state.
265**
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.
272**
dand0864082010-08-02 14:32:52 +0000273** * 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.
mistachkin48864df2013-03-21 21:20:32 +0000276** If no error occurred, all that remains is to finalize the journal to
dand0864082010-08-02 14:32:52 +0000277** commit the transaction. If an error did occur, the caller will need
278** to rollback the transaction.
279**
danb22aa4a2010-08-03 15:57:09 +0000280** ERROR:
281**
dan22b328b2010-08-11 18:56:45 +0000282** 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.
286**
287** Temporary pager files may enter the ERROR state, but in-memory pagers
288** cannot.
danb22aa4a2010-08-03 15:57:09 +0000289**
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.
298**
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
dande1ae342010-08-06 12:00:27 +0000302** transition back to OPEN state, discarding the contents of the
danb22aa4a2010-08-03 15:57:09 +0000303** 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
307** from the error.
308**
309** Specifically, the pager jumps into the ERROR state if:
310**
311** 1. An error occurs while attempting a rollback. This happens in
312** function sqlite3PagerRollback().
313**
314** 2. An error occurs while attempting to finalize a journal file
315** following a commit in function sqlite3PagerCommitPhaseTwo().
316**
317** 3. An error occurs while attempting to write to the journal or
318** database file in function pagerStress() in order to free up
319** memory.
320**
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.
324**
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
330** state.
dande1ae342010-08-06 12:00:27 +0000331**
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).
dan22b328b2010-08-11 18:56:45 +0000335** * The pager is not an in-memory pager.
danb22aa4a2010-08-03 15:57:09 +0000336**
337**
dan763afe62010-08-03 06:42:39 +0000338** Notes:
339**
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.
343**
dande1ae342010-08-06 12:00:27 +0000344** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
dan763afe62010-08-03 06:42:39 +0000345** 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".
348**
349** * See also: assert_pager_state().
dand0864082010-08-02 14:32:52 +0000350*/
dande1ae342010-08-06 12:00:27 +0000351#define PAGER_OPEN 0
dand0864082010-08-02 14:32:52 +0000352#define PAGER_READER 1
dande1ae342010-08-06 12:00:27 +0000353#define PAGER_WRITER_LOCKED 2
dand0864082010-08-02 14:32:52 +0000354#define PAGER_WRITER_CACHEMOD 3
355#define PAGER_WRITER_DBMOD 4
356#define PAGER_WRITER_FINISHED 5
dana42c66b2010-08-03 18:18:41 +0000357#define PAGER_ERROR 6
dand0864082010-08-02 14:32:52 +0000358
dand0864082010-08-02 14:32:52 +0000359/*
dan54919f82010-08-05 18:53:26 +0000360** 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.
drhed7c8552001-04-11 14:29:21 +0000365**
dan54919f82010-08-05 18:53:26 +0000366** 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.
drhed7c8552001-04-11 14:29:21 +0000374**
dan54919f82010-08-05 18:53:26 +0000375** 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.
drhed7c8552001-04-11 14:29:21 +0000378**
dan54919f82010-08-05 18:53:26 +0000379** The exception is when the database file is unlocked as the pager moves
dande1ae342010-08-06 12:00:27 +0000380** from ERROR to OPEN state. At this point there may be a hot-journal file
peter.d.reid60ec9142014-09-06 16:39:46 +0000381** in the file-system that needs to be rolled back (as part of an OPEN->SHARED
dan54919f82010-08-05 18:53:26 +0000382** 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.
drha6abd042004-06-09 17:37:22 +0000386**
dan54919f82010-08-05 18:53:26 +0000387** 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.
drhed7c8552001-04-11 14:29:21 +0000394**
dan54919f82010-08-05 18:53:26 +0000395** 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
dande1ae342010-08-06 12:00:27 +0000398** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
dan54919f82010-08-05 18:53:26 +0000399** 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.
danielk1977aa5ccdf2004-06-14 05:10:42 +0000403**
dan54919f82010-08-05 18:53:26 +0000404** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
dande1ae342010-08-06 12:00:27 +0000405** PAGER_OPEN state.
drhed7c8552001-04-11 14:29:21 +0000406*/
dan54919f82010-08-05 18:53:26 +0000407#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)
dan4e004aa2010-08-05 15:30:22 +0000408
drh684917c2004-10-05 02:41:42 +0000409/*
drh1a5c00f2009-08-10 17:48:57 +0000410** The maximum allowed sector size. 64KiB. If the xSectorsize() method
danielk19777cbd5892009-01-10 16:15:09 +0000411** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
412** This could conceivably cause corruption following a power failure on
413** such a system. This is currently an undocumented limit.
414*/
drh1a5c00f2009-08-10 17:48:57 +0000415#define MAX_SECTOR_SIZE 0x10000
danielk19777cbd5892009-01-10 16:15:09 +0000416
drh164c9572016-01-25 13:55:47 +0000417
418/*
danielk1977fd7f0452008-12-17 17:30:26 +0000419** An instance of the following structure is allocated for each active
420** savepoint and statement transaction in the system. All such structures
421** are stored in the Pager.aSavepoint[] array, which is allocated and
422** resized using sqlite3Realloc().
423**
424** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
425** set to 0. If a journal-header is written into the main journal while
426** the savepoint is active, then iHdrOffset is set to the byte offset
427** immediately following the last journal record written into the main
428** journal before the journal-header. This is required during savepoint
429** rollback (see pagerPlaybackSavepoint()).
430*/
431typedef struct PagerSavepoint PagerSavepoint;
432struct PagerSavepoint {
433 i64 iOffset; /* Starting offset in main journal */
434 i64 iHdrOffset; /* See above */
435 Bitvec *pInSavepoint; /* Set of pages in this savepoint */
436 Pgno nOrig; /* Original number of pages in file */
437 Pgno iSubRec; /* Index of first record in sub-journal */
danf43fef22021-02-22 15:44:45 +0000438 int bTruncateOnRelease; /* If stmt journal may be truncated on RELEASE */
dan38e1a272010-06-28 11:23:09 +0000439#ifndef SQLITE_OMIT_WAL
dan71d89912010-05-24 13:57:42 +0000440 u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
dan38e1a272010-06-28 11:23:09 +0000441#endif
danielk1977fd7f0452008-12-17 17:30:26 +0000442};
443
444/*
drh40c39412013-08-16 20:42:20 +0000445** Bits of the Pager.doNotSpill flag. See further description below.
446*/
drhe399ac22015-06-29 18:14:02 +0000447#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */
448#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */
449#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */
drh40c39412013-08-16 20:42:20 +0000450
451/*
peter.d.reid60ec9142014-09-06 16:39:46 +0000452** An open page cache is an instance of struct Pager. A description of
dande1ae342010-08-06 12:00:27 +0000453** some of the more important member variables follows:
danielk1977efaaf572006-01-16 11:29:19 +0000454**
dande1ae342010-08-06 12:00:27 +0000455** eState
danielk19773460d192008-12-27 15:23:13 +0000456**
dande1ae342010-08-06 12:00:27 +0000457** The current 'state' of the pager object. See the comment and state
458** diagram above for a description of the pager state.
danielk1977bea2a942009-01-20 17:06:27 +0000459**
dande1ae342010-08-06 12:00:27 +0000460** eLock
danielk1977bea2a942009-01-20 17:06:27 +0000461**
dande1ae342010-08-06 12:00:27 +0000462** For a real on-disk database, the current lock held on the database file -
463** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
464**
465** For a temporary or in-memory database (neither of which require any
466** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
467** databases always have Pager.exclusiveMode==1, this tricks the pager
468** logic into thinking that it already has all the locks it will ever
469** need (and no reason to release them).
470**
471** In some (obscure) circumstances, this variable may also be set to
472** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
473** details.
danielk1977bea2a942009-01-20 17:06:27 +0000474**
475** changeCountDone
476**
477** This boolean variable is used to make sure that the change-counter
478** (the 4-byte header field at byte offset 24 of the database file) is
479** not updated more often than necessary.
480**
481** It is set to true when the change-counter field is updated, which
482** can only happen if an exclusive lock is held on the database file.
483** It is cleared (set to false) whenever an exclusive lock is
484** relinquished on the database file. Each time a transaction is committed,
485** The changeCountDone flag is inspected. If it is true, the work of
486** updating the change-counter is omitted for the current transaction.
487**
488** This mechanism means that when running in exclusive mode, a connection
489** need only update the change-counter once, for the first transaction
490** committed.
491**
drh067b92b2020-06-19 15:24:12 +0000492** setSuper
danielk1977bea2a942009-01-20 17:06:27 +0000493**
dan1e01cf12010-07-30 11:31:12 +0000494** When PagerCommitPhaseOne() is called to commit a transaction, it may
drh067b92b2020-06-19 15:24:12 +0000495** (or may not) specify a super-journal name to be written into the
dan1e01cf12010-07-30 11:31:12 +0000496** journal file before it is synced to disk.
danielk1977bea2a942009-01-20 17:06:27 +0000497**
drh067b92b2020-06-19 15:24:12 +0000498** Whether or not a journal file contains a super-journal pointer affects
dan1e01cf12010-07-30 11:31:12 +0000499** the way in which the journal file is finalized after the transaction is
500** committed or rolled back when running in "journal_mode=PERSIST" mode.
drh067b92b2020-06-19 15:24:12 +0000501** If a journal file does not contain a super-journal pointer, it is
dande1ae342010-08-06 12:00:27 +0000502** finalized by overwriting the first journal header with zeroes. If
drh067b92b2020-06-19 15:24:12 +0000503** it does contain a super-journal pointer the journal file is finalized
dande1ae342010-08-06 12:00:27 +0000504** by truncating it to zero bytes, just as if the connection were
505** running in "journal_mode=truncate" mode.
dan1e01cf12010-07-30 11:31:12 +0000506**
drh067b92b2020-06-19 15:24:12 +0000507** Journal files that contain super-journal pointers cannot be finalized
dan1e01cf12010-07-30 11:31:12 +0000508** simply by overwriting the first journal-header with zeroes, as the
drh067b92b2020-06-19 15:24:12 +0000509** super-journal pointer could interfere with hot-journal rollback of any
dan1e01cf12010-07-30 11:31:12 +0000510** subsequently interrupted transaction that reuses the journal file.
511**
512** The flag is cleared as soon as the journal file is finalized (either
513** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
drh067b92b2020-06-19 15:24:12 +0000514** journal file from being successfully finalized, the setSuper flag
dande1ae342010-08-06 12:00:27 +0000515** is cleared anyway (and the pager will move to ERROR state).
danielk1977bea2a942009-01-20 17:06:27 +0000516**
drh40c39412013-08-16 20:42:20 +0000517** doNotSpill
danielk1977bea2a942009-01-20 17:06:27 +0000518**
drh40c39412013-08-16 20:42:20 +0000519** This variables control the behavior of cache-spills (calls made by
520** the pcache module to the pagerStress() routine to write cached data
521** to the file-system in order to free up memory).
dan85d14ed2010-08-06 17:18:00 +0000522**
drh40c39412013-08-16 20:42:20 +0000523** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
524** writing to the database from pagerStress() is disabled altogether.
525** The SPILLFLAG_ROLLBACK case is done in a very obscure case that
dan85d14ed2010-08-06 17:18:00 +0000526** comes up during savepoint rollback that requires the pcache module
527** to allocate a new page to prevent the journal file from being written
drh40c39412013-08-16 20:42:20 +0000528** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
529** case is a user preference.
dan85d14ed2010-08-06 17:18:00 +0000530**
drhe399ac22015-06-29 18:14:02 +0000531** If the SPILLFLAG_NOSYNC bit is set, writing to the database from
532** pagerStress() is permitted, but syncing the journal file is not.
533** This flag is set by sqlite3PagerWrite() when the file-system sector-size
534** is larger than the database page-size in order to prevent a journal sync
535** from happening in between the journalling of two pages on the same sector.
danielk1977bea2a942009-01-20 17:06:27 +0000536**
danielk1977d8293352009-04-30 09:10:37 +0000537** subjInMemory
538**
539** This is a boolean variable. If true, then any required sub-journal
540** is opened as an in-memory journal file. If false, then in-memory
541** sub-journals are only used for in-memory pager files.
dande1ae342010-08-06 12:00:27 +0000542**
543** This variable is updated by the upper layer each time a new
544** write-transaction is opened.
545**
546** dbSize, dbOrigSize, dbFileSize
547**
548** Variable dbSize is set to the number of pages in the database file.
549** It is valid in PAGER_READER and higher states (all states except for
550** OPEN and ERROR).
551**
552** dbSize is set based on the size of the database file, which may be
553** larger than the size of the database (the value stored at offset
554** 28 of the database header by the btree). If the size of the file
555** is not an integer multiple of the page-size, the value stored in
556** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
557** Except, any file that is greater than 0 bytes in size is considered
558** to have at least one page. (i.e. a 1KB file with 2K page-size leads
559** to dbSize==1).
560**
561** During a write-transaction, if pages with page-numbers greater than
562** dbSize are modified in the cache, dbSize is updated accordingly.
563** Similarly, if the database is truncated using PagerTruncateImage(),
564** dbSize is updated.
565**
566** Variables dbOrigSize and dbFileSize are valid in states
567** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
568** variable at the start of the transaction. It is used during rollback,
569** and to determine whether or not pages need to be journalled before
570** being modified.
571**
572** Throughout a write-transaction, dbFileSize contains the size of
573** the file on disk in pages. It is set to a copy of dbSize when the
574** write-transaction is first opened, and updated when VFS calls are made
danc8649122010-08-10 09:58:57 +0000575** to write or truncate the database file on disk.
576**
577** The only reason the dbFileSize variable is required is to suppress
578** unnecessary calls to xTruncate() after committing a transaction. If,
579** when a transaction is committed, the dbFileSize variable indicates
580** that the database file is larger than the database image (Pager.dbSize),
581** pager_truncate() is called. The pager_truncate() call uses xFilesize()
582** to measure the database file on disk, and then truncates it if required.
583** dbFileSize is not used when rolling back a transaction. In this case
584** pager_truncate() is called unconditionally (which means there may be
585** a call to xFilesize() that is not strictly required). In either case,
586** pager_truncate() may cause the file to become smaller or larger.
587**
588** dbHintSize
589**
590** The dbHintSize variable is used to limit the number of calls made to
591** the VFS xFileControl(FCNTL_SIZE_HINT) method.
592**
593** dbHintSize is set to a copy of the dbSize variable when a
594** write-transaction is opened (at the same time as dbFileSize and
595** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
596** dbHintSize is increased to the number of pages that correspond to the
597** size-hint passed to the method call. See pager_write_pagelist() for
598** details.
dande1ae342010-08-06 12:00:27 +0000599**
600** errCode
601**
602** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
603** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
604** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
605** sub-codes.
drhdaaae7b2017-08-25 01:14:43 +0000606**
607** syncFlags, walSyncFlags
608**
609** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03).
610** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
611** and contains the flags used to sync the checkpoint operations in the
612** lower two bits, and sync flags used for transaction commits in the WAL
613** file in bits 0x04 and 0x08. In other words, to get the correct sync flags
614** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct
615** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note
616** that with synchronous=NORMAL in WAL mode, transaction commit is not synced
617** meaning that the 0x04 and 0x08 bits are both zero.
drhed7c8552001-04-11 14:29:21 +0000618*/
619struct Pager {
danielk1977b4b47412007-08-17 15:53:36 +0000620 sqlite3_vfs *pVfs; /* OS functions to use for IO */
danielk1977bea2a942009-01-20 17:06:27 +0000621 u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
dan4d9c1b72010-07-30 07:26:51 +0000622 u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */
drh34e79ce2004-02-08 06:05:46 +0000623 u8 useJournal; /* Use a rollback journal on this file */
drh603240c2002-03-05 01:11:12 +0000624 u8 noSync; /* Do not sync the journal if true */
drh968af522003-02-11 14:55:40 +0000625 u8 fullSync; /* Do extra syncs of the journal for robustness */
drh6841b1c2016-02-03 19:20:15 +0000626 u8 extraSync; /* sync directory after journal delete */
drhc97d8462010-11-19 18:23:35 +0000627 u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */
drhdaaae7b2017-08-25 01:14:43 +0000628 u8 walSyncFlags; /* See description above */
drh57fe1362014-05-01 01:49:22 +0000629 u8 tempFile; /* zFilename is a temporary or immutable file */
630 u8 noLock; /* Do not lock (except in WAL mode) */
drh603240c2002-03-05 01:11:12 +0000631 u8 readOnly; /* True for a read-only database */
danielk197745d68822009-01-16 16:23:38 +0000632 u8 memDb; /* True to inhibit all file I/O */
drh021e2282021-10-23 20:32:27 +0000633 u8 memVfs; /* VFS-implemented memory database */
danielk1977bea2a942009-01-20 17:06:27 +0000634
drhe5918c62010-08-14 12:42:45 +0000635 /**************************************************************************
636 ** The following block contains those class members that change during
peter.d.reid60ec9142014-09-06 16:39:46 +0000637 ** routine operation. Class members not in this block are either fixed
drhe5918c62010-08-14 12:42:45 +0000638 ** when the pager is first created or else only change when there is a
639 ** significant mode change (such as changing the page_size, locking_mode,
640 ** or the journal_mode). From another view, these class members describe
641 ** the "state" of the pager, while other class members describe the
642 ** "configuration" of the pager.
danielk1977bea2a942009-01-20 17:06:27 +0000643 */
dande1ae342010-08-06 12:00:27 +0000644 u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
dand0864082010-08-02 14:32:52 +0000645 u8 eLock; /* Current lock held on database file */
danielk1977bea2a942009-01-20 17:06:27 +0000646 u8 changeCountDone; /* Set after incrementing the change-counter */
drh067b92b2020-06-19 15:24:12 +0000647 u8 setSuper; /* Super-jrnl name is written into jrnl */
drh7cf4c7a2010-06-24 14:52:25 +0000648 u8 doNotSpill; /* Do not spill the cache when non-zero */
danielk1977d8293352009-04-30 09:10:37 +0000649 u8 subjInMemory; /* True to use in-memory sub-journals */
drh91618562014-12-19 19:28:02 +0000650 u8 bUseFetch; /* True to use xFetch() */
drhc98a4cc2015-09-03 17:54:32 +0000651 u8 hasHeldSharedLock; /* True if a shared lock has ever been held */
danielk19773460d192008-12-27 15:23:13 +0000652 Pgno dbSize; /* Number of pages in the database */
653 Pgno dbOrigSize; /* dbSize before the current transaction */
654 Pgno dbFileSize; /* Number of pages in the database file */
danc8649122010-08-10 09:58:57 +0000655 Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
danielk197745d68822009-01-16 16:23:38 +0000656 int errCode; /* One of several kinds of errors */
danielk1977bea2a942009-01-20 17:06:27 +0000657 int nRec; /* Pages journalled since last j-header written */
danielk197745d68822009-01-16 16:23:38 +0000658 u32 cksumInit; /* Quasi-random value added to every checksum */
danielk1977bea2a942009-01-20 17:06:27 +0000659 u32 nSubRec; /* Number of records written to sub-journal */
danielk197745d68822009-01-16 16:23:38 +0000660 Bitvec *pInJournal; /* One bit for each page in the database file */
drh01be4632015-09-03 15:17:12 +0000661#ifndef SQLITE_OMIT_CONCURRENT
danbf3cf572015-08-24 19:56:04 +0000662 Bitvec *pAllRead; /* Pages read within current CONCURRENT trans. */
dan7b3d71e2015-08-19 20:27:05 +0000663#endif
danielk1977bea2a942009-01-20 17:06:27 +0000664 sqlite3_file *fd; /* File descriptor for database */
665 sqlite3_file *jfd; /* File descriptor for main journal */
666 sqlite3_file *sjfd; /* File descriptor for sub-journal */
667 i64 journalOff; /* Current write offset in the journal file */
668 i64 journalHdr; /* Byte offset to previous journal header */
drhe5918c62010-08-14 12:42:45 +0000669 sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
danielk1977bea2a942009-01-20 17:06:27 +0000670 PagerSavepoint *aSavepoint; /* Array of active savepoints */
671 int nSavepoint; /* Number of elements in aSavepoint[] */
drhd7107b32014-12-20 14:34:02 +0000672 u32 iDataVersion; /* Changes whenever database content changes */
danielk1977bea2a942009-01-20 17:06:27 +0000673 char dbFileVers[16]; /* Changes whenever database file changes */
danb2d3de32013-03-14 18:34:37 +0000674
danb2d3de32013-03-14 18:34:37 +0000675 int nMmapOut; /* Number of mmap pages currently outstanding */
drh9b4c59f2013-04-15 17:03:42 +0000676 sqlite3_int64 szMmap; /* Desired maximum mmap size */
drhc86e5132013-03-26 14:36:11 +0000677 PgHdr *pMmapFreelist; /* List of free mmap page headers (pDirty) */
drhe5918c62010-08-14 12:42:45 +0000678 /*
679 ** End of the routinely-changing class members
680 ***************************************************************************/
danielk1977bea2a942009-01-20 17:06:27 +0000681
drhfa9601a2009-06-18 17:22:39 +0000682 u16 nExtra; /* Add this many bytes to each in-memory page */
683 i16 nReserve; /* Number of unused bytes at end of each page */
danielk1977bea2a942009-01-20 17:06:27 +0000684 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
drhe5918c62010-08-14 12:42:45 +0000685 u32 sectorSize; /* Assumed sector size during rollback */
danielk1977bea2a942009-01-20 17:06:27 +0000686 Pgno mxPgno; /* Maximum allowed size of the database */
drh584bfca2022-02-23 17:00:44 +0000687 Pgno lckPgno; /* Page number for the locking page */
drh57dd7e62021-09-13 13:53:13 +0000688 i64 pageSize; /* Number of bytes in a page */
drhe5918c62010-08-14 12:42:45 +0000689 i64 journalSizeLimit; /* Size limit for persistent journal files */
drhfcd35c72005-05-21 02:48:08 +0000690 char *zFilename; /* Name of the database file */
691 char *zJournal; /* Name of the journal file */
danielk19771ceedd32008-11-19 10:22:33 +0000692 int (*xBusyHandler)(void*); /* Function to call when busy */
693 void *pBusyHandlerArg; /* Context argument for xBusyHandler */
drhffc78a42018-03-14 14:53:50 +0000694 int aStat[4]; /* Total cache hits, misses, writes, spills */
drhfcd35c72005-05-21 02:48:08 +0000695#ifdef SQLITE_TEST
drh9ad3ee42012-03-24 20:06:14 +0000696 int nRead; /* Database pages read */
drhfcd35c72005-05-21 02:48:08 +0000697#endif
danielk1977eaa06f62008-09-18 17:34:44 +0000698 void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
drh12e6f682016-12-13 14:32:47 +0000699 int (*xGet)(Pager*,Pgno,DbPage**,int); /* Routine to fetch a patch */
danielk19778186df82007-03-06 13:45:59 +0000700 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
danielk19778c0a7912008-08-20 14:49:23 +0000701 PCache *pPCache; /* Pointer to page cache object */
dan5cf53532010-05-01 16:40:20 +0000702#ifndef SQLITE_OMIT_WAL
drh7ed91f22010-04-29 22:34:07 +0000703 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
dan3e875ef2010-07-05 19:03:35 +0000704 char *zWal; /* File name for write-ahead log */
dan5cf53532010-05-01 16:40:20 +0000705#endif
drhd9b02572001-04-15 00:37:09 +0000706};
707
708/*
drh9ad3ee42012-03-24 20:06:14 +0000709** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains
710** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS
711** or CACHE_WRITE to sqlite3_db_status().
712*/
713#define PAGER_STAT_HIT 0
714#define PAGER_STAT_MISS 1
715#define PAGER_STAT_WRITE 2
drhffc78a42018-03-14 14:53:50 +0000716#define PAGER_STAT_SPILL 3
drh9ad3ee42012-03-24 20:06:14 +0000717
718/*
drh538f5702007-04-13 02:14:30 +0000719** The following global variables hold counters used for
720** testing purposes only. These variables do not exist in
721** a non-testing build. These variables are not thread-safe.
drhfcd35c72005-05-21 02:48:08 +0000722*/
723#ifdef SQLITE_TEST
drh538f5702007-04-13 02:14:30 +0000724int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
725int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
726int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
drh538f5702007-04-13 02:14:30 +0000727# define PAGER_INCR(v) v++
drhfcd35c72005-05-21 02:48:08 +0000728#else
drh538f5702007-04-13 02:14:30 +0000729# define PAGER_INCR(v)
drhfcd35c72005-05-21 02:48:08 +0000730#endif
731
drh538f5702007-04-13 02:14:30 +0000732
733
drhfcd35c72005-05-21 02:48:08 +0000734/*
drh5e00f6c2001-09-13 13:46:56 +0000735** Journal files begin with the following magic string. The data
736** was obtained from /dev/random. It is used only as a sanity check.
drh94f33312002-08-12 12:29:56 +0000737**
drhae2b40c2004-06-09 19:03:54 +0000738** Since version 2.8.0, the journal format contains additional sanity
drh30d53702009-01-06 15:58:57 +0000739** checking information. If the power fails while the journal is being
drhae2b40c2004-06-09 19:03:54 +0000740** written, semi-random garbage data might appear in the journal
741** file after power is restored. If an attempt is then made
drh968af522003-02-11 14:55:40 +0000742** to roll the journal back, the database could be corrupted. The additional
743** sanity checking data is an attempt to discover the garbage in the
744** journal and ignore it.
745**
drhae2b40c2004-06-09 19:03:54 +0000746** The sanity checking information for the new journal format consists
drh968af522003-02-11 14:55:40 +0000747** of a 32-bit checksum on each page of data. The checksum covers both
drh90f5ecb2004-07-22 01:19:35 +0000748** the page number and the pPager->pageSize bytes of data for the page.
drh968af522003-02-11 14:55:40 +0000749** This cksum is initialized to a 32-bit random value that appears in the
750** journal file right after the header. The random initializer is important,
751** because garbage data that appears at the end of a journal is likely
752** data that was once in other files that have now been deleted. If the
753** garbage data came from an obsolete journal file, the checksums might
754** be correct. But by initializing the checksum to random value which
755** is different for every journal, we minimize that risk.
drhd9b02572001-04-15 00:37:09 +0000756*/
drhae2b40c2004-06-09 19:03:54 +0000757static const unsigned char aJournalMagic[] = {
758 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
drhed7c8552001-04-11 14:29:21 +0000759};
760
761/*
danielk1977bea2a942009-01-20 17:06:27 +0000762** The size of the of each page record in the journal is given by
763** the following macro.
drh968af522003-02-11 14:55:40 +0000764*/
drhae2b40c2004-06-09 19:03:54 +0000765#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
drh968af522003-02-11 14:55:40 +0000766
danielk197776572402004-06-25 02:38:54 +0000767/*
danielk1977bea2a942009-01-20 17:06:27 +0000768** The journal header size for this pager. This is usually the same
769** size as a single disk sector. See also setSectorSize().
danielk197776572402004-06-25 02:38:54 +0000770*/
771#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
772
drhb7f91642004-10-31 02:22:47 +0000773/*
774** The macro MEMDB is true if we are dealing with an in-memory database.
775** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
776** the value of MEMDB will be a constant and the compiler will optimize
777** out code that would never execute.
778*/
779#ifdef SQLITE_OMIT_MEMORYDB
780# define MEMDB 0
781#else
782# define MEMDB pPager->memDb
783#endif
784
785/*
drh188d4882013-04-08 20:47:49 +0000786** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
787** interfaces to access the database using memory-mapped I/O.
788*/
drh9b4c59f2013-04-15 17:03:42 +0000789#if SQLITE_MAX_MMAP_SIZE>0
drh188d4882013-04-08 20:47:49 +0000790# define USEFETCH(x) ((x)->bUseFetch)
drh9b4c59f2013-04-15 17:03:42 +0000791#else
792# define USEFETCH(x) 0
drh188d4882013-04-08 20:47:49 +0000793#endif
794
795/*
dand0864082010-08-02 14:32:52 +0000796** The argument to this macro is a file descriptor (type sqlite3_file*).
797** Return 0 if it is not open, or non-zero (but not 1) if it is.
798**
799** This is so that expressions can be written as:
800**
801** if( isOpen(pPager->jfd) ){ ...
802**
803** instead of
804**
805** if( pPager->jfd->pMethods ){ ...
806*/
drh82ef8772015-06-29 14:11:50 +0000807#define isOpen(pFd) ((pFd)->pMethods!=0)
dand0864082010-08-02 14:32:52 +0000808
dan09236752018-11-22 19:10:14 +0000809#ifdef SQLITE_DIRECT_OVERFLOW_READ
810/*
811** Return true if page pgno can be read directly from the database file
812** by the b-tree layer. This is the case if:
813**
814** * the database file is open,
815** * there are no dirty pages in the cache, and
816** * the desired page is not currently in the wal file.
817*/
818int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
819 if( pPager->fd->pMethods==0 ) return 0;
820 if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
821#ifndef SQLITE_OMIT_WAL
822 if( pPager->pWal ){
823 u32 iRead = 0;
824 int rc;
825 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
826 return (rc==SQLITE_OK && iRead==0);
827 }
828#endif
829 return 1;
830}
831#endif
832
drhd930b5c2017-01-26 02:26:02 +0000833#ifndef SQLITE_OMIT_WAL
834# define pagerUseWal(x) ((x)->pWal!=0)
dand0864082010-08-02 14:32:52 +0000835#else
836# define pagerUseWal(x) 0
837# define pagerRollbackWal(x) 0
drh4eb02a42011-12-16 21:26:26 +0000838# define pagerWalFrames(v,w,x,y) 0
dand0864082010-08-02 14:32:52 +0000839# define pagerOpenWalIfPresent(z) SQLITE_OK
840# define pagerBeginReadTransaction(z) SQLITE_OK
841#endif
842
danielk1977bea2a942009-01-20 17:06:27 +0000843#ifndef NDEBUG
844/*
845** Usage:
846**
847** assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +0000848**
849** This function runs many asserts to try to find inconsistencies in
850** the internal state of the Pager object.
danielk1977bea2a942009-01-20 17:06:27 +0000851*/
dand0864082010-08-02 14:32:52 +0000852static int assert_pager_state(Pager *p){
853 Pager *pPager = p;
danielk1977bea2a942009-01-20 17:06:27 +0000854
dand0864082010-08-02 14:32:52 +0000855 /* State must be valid. */
dande1ae342010-08-06 12:00:27 +0000856 assert( p->eState==PAGER_OPEN
dand0864082010-08-02 14:32:52 +0000857 || p->eState==PAGER_READER
dande1ae342010-08-06 12:00:27 +0000858 || p->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +0000859 || p->eState==PAGER_WRITER_CACHEMOD
860 || p->eState==PAGER_WRITER_DBMOD
861 || p->eState==PAGER_WRITER_FINISHED
dana42c66b2010-08-03 18:18:41 +0000862 || p->eState==PAGER_ERROR
dand0864082010-08-02 14:32:52 +0000863 );
danielk1977bea2a942009-01-20 17:06:27 +0000864
dand0864082010-08-02 14:32:52 +0000865 /* Regardless of the current state, a temp-file connection always behaves
866 ** as if it has an exclusive lock on the database file. It never updates
867 ** the change-counter field, so the changeCountDone flag is always set.
868 */
869 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
870 assert( p->tempFile==0 || pPager->changeCountDone );
871
872 /* If the useJournal flag is clear, the journal-mode must be "OFF".
873 ** And if the journal-mode is "OFF", the journal file must not be open.
874 */
875 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
876 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
877
dan22b328b2010-08-11 18:56:45 +0000878 /* Check that MEMDB implies noSync. And an in-memory journal. Since
879 ** this means an in-memory pager performs no IO at all, it cannot encounter
880 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
881 ** a journal file. (although the in-memory journal implementation may
882 ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
883 ** is therefore not possible for an in-memory pager to enter the ERROR
884 ** state.
885 */
886 if( MEMDB ){
drh835f22d2016-04-25 19:20:56 +0000887 assert( !isOpen(p->fd) );
dan22b328b2010-08-11 18:56:45 +0000888 assert( p->noSync );
889 assert( p->journalMode==PAGER_JOURNALMODE_OFF
890 || p->journalMode==PAGER_JOURNALMODE_MEMORY
891 );
892 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
893 assert( pagerUseWal(p)==0 );
894 }
dand0864082010-08-02 14:32:52 +0000895
dan431b0b42010-08-04 19:14:22 +0000896 /* If changeCountDone is set, a RESERVED lock or greater must be held
897 ** on the file.
898 */
899 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
dan54919f82010-08-05 18:53:26 +0000900 assert( p->eLock!=PENDING_LOCK );
dan431b0b42010-08-04 19:14:22 +0000901
dand0864082010-08-02 14:32:52 +0000902 switch( p->eState ){
dande1ae342010-08-06 12:00:27 +0000903 case PAGER_OPEN:
dand0864082010-08-02 14:32:52 +0000904 assert( !MEMDB );
dana42c66b2010-08-03 18:18:41 +0000905 assert( pPager->errCode==SQLITE_OK );
dan4e004aa2010-08-05 15:30:22 +0000906 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
dand0864082010-08-02 14:32:52 +0000907 break;
908
909 case PAGER_READER:
dana42c66b2010-08-03 18:18:41 +0000910 assert( pPager->errCode==SQLITE_OK );
dan4e004aa2010-08-05 15:30:22 +0000911 assert( p->eLock!=UNKNOWN_LOCK );
drh33f111d2012-01-17 15:29:14 +0000912 assert( p->eLock>=SHARED_LOCK );
dand0864082010-08-02 14:32:52 +0000913 break;
914
dande1ae342010-08-06 12:00:27 +0000915 case PAGER_WRITER_LOCKED:
dan4e004aa2010-08-05 15:30:22 +0000916 assert( p->eLock!=UNKNOWN_LOCK );
dana42c66b2010-08-03 18:18:41 +0000917 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000918 if( !pagerUseWal(pPager) ){
919 assert( p->eLock>=RESERVED_LOCK );
920 }
drh01be4632015-09-03 15:17:12 +0000921#ifndef SQLITE_OMIT_CONCURRENT
danf6cf5ea2015-08-26 18:54:45 +0000922 assert( pPager->dbSize==pPager->dbOrigSize || pPager->pAllRead );
drh3f531da2015-09-01 17:48:54 +0000923#endif
dan937ac9d2010-08-03 12:48:45 +0000924 assert( pPager->dbOrigSize==pPager->dbFileSize );
danc8649122010-08-10 09:58:57 +0000925 assert( pPager->dbOrigSize==pPager->dbHintSize );
drh067b92b2020-06-19 15:24:12 +0000926 assert( pPager->setSuper==0 );
dand0864082010-08-02 14:32:52 +0000927 break;
928
929 case PAGER_WRITER_CACHEMOD:
dan4e004aa2010-08-05 15:30:22 +0000930 assert( p->eLock!=UNKNOWN_LOCK );
dana42c66b2010-08-03 18:18:41 +0000931 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000932 if( !pagerUseWal(pPager) ){
933 /* It is possible that if journal_mode=wal here that neither the
934 ** journal file nor the WAL file are open. This happens during
935 ** a rollback transaction that switches from journal_mode=off
936 ** to journal_mode=wal.
937 */
938 assert( p->eLock>=RESERVED_LOCK );
939 assert( isOpen(p->jfd)
940 || p->journalMode==PAGER_JOURNALMODE_OFF
941 || p->journalMode==PAGER_JOURNALMODE_WAL
942 );
943 }
dan937ac9d2010-08-03 12:48:45 +0000944 assert( pPager->dbOrigSize==pPager->dbFileSize );
danc8649122010-08-10 09:58:57 +0000945 assert( pPager->dbOrigSize==pPager->dbHintSize );
dand0864082010-08-02 14:32:52 +0000946 break;
947
948 case PAGER_WRITER_DBMOD:
dan4e004aa2010-08-05 15:30:22 +0000949 assert( p->eLock==EXCLUSIVE_LOCK );
dana42c66b2010-08-03 18:18:41 +0000950 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000951 assert( !pagerUseWal(pPager) );
dan4e004aa2010-08-05 15:30:22 +0000952 assert( p->eLock>=EXCLUSIVE_LOCK );
dand0864082010-08-02 14:32:52 +0000953 assert( isOpen(p->jfd)
954 || p->journalMode==PAGER_JOURNALMODE_OFF
955 || p->journalMode==PAGER_JOURNALMODE_WAL
dand67a9772017-07-20 21:00:03 +0000956 || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
dand0864082010-08-02 14:32:52 +0000957 );
danc8649122010-08-10 09:58:57 +0000958 assert( pPager->dbOrigSize<=pPager->dbHintSize );
dand0864082010-08-02 14:32:52 +0000959 break;
960
961 case PAGER_WRITER_FINISHED:
dan4e004aa2010-08-05 15:30:22 +0000962 assert( p->eLock==EXCLUSIVE_LOCK );
dana42c66b2010-08-03 18:18:41 +0000963 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000964 assert( !pagerUseWal(pPager) );
dand0864082010-08-02 14:32:52 +0000965 assert( isOpen(p->jfd)
966 || p->journalMode==PAGER_JOURNALMODE_OFF
967 || p->journalMode==PAGER_JOURNALMODE_WAL
danefe16972017-07-20 19:49:14 +0000968 || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
dand0864082010-08-02 14:32:52 +0000969 );
970 break;
dana42c66b2010-08-03 18:18:41 +0000971
972 case PAGER_ERROR:
973 /* There must be at least one outstanding reference to the pager if
974 ** in ERROR state. Otherwise the pager should have already dropped
dande1ae342010-08-06 12:00:27 +0000975 ** back to OPEN state.
dana42c66b2010-08-03 18:18:41 +0000976 */
977 assert( pPager->errCode!=SQLITE_OK );
dan67330a12016-04-11 18:07:47 +0000978 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );
dana42c66b2010-08-03 18:18:41 +0000979 break;
dand0864082010-08-02 14:32:52 +0000980 }
danielk1977bea2a942009-01-20 17:06:27 +0000981
982 return 1;
983}
dan6a88adc2010-11-04 04:47:42 +0000984#endif /* ifndef NDEBUG */
dand0864082010-08-02 14:32:52 +0000985
dan6a88adc2010-11-04 04:47:42 +0000986#ifdef SQLITE_DEBUG
dand0864082010-08-02 14:32:52 +0000987/*
dande1ae342010-08-06 12:00:27 +0000988** Return a pointer to a human readable string in a static buffer
989** containing the state of the Pager object passed as an argument. This
990** is intended to be used within debuggers. For example, as an alternative
991** to "print *pPager" in gdb:
992**
dand0864082010-08-02 14:32:52 +0000993** (gdb) printf "%s", print_pager_state(pPager)
drhed927212018-08-30 18:53:09 +0000994**
995** This routine has external linkage in order to suppress compiler warnings
996** about an unused function. It is enclosed within SQLITE_DEBUG and so does
997** not appear in normal builds.
dand0864082010-08-02 14:32:52 +0000998*/
drhed927212018-08-30 18:53:09 +0000999char *print_pager_state(Pager *p){
dand0864082010-08-02 14:32:52 +00001000 static char zRet[1024];
1001
1002 sqlite3_snprintf(1024, zRet,
dan11f47a92010-08-06 06:54:47 +00001003 "Filename: %s\n"
dan4e004aa2010-08-05 15:30:22 +00001004 "State: %s errCode=%d\n"
dan937ac9d2010-08-03 12:48:45 +00001005 "Lock: %s\n"
dand0864082010-08-02 14:32:52 +00001006 "Locking mode: locking_mode=%s\n"
dan937ac9d2010-08-03 12:48:45 +00001007 "Journal mode: journal_mode=%s\n"
1008 "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
dan4e004aa2010-08-05 15:30:22 +00001009 "Journal: journalOff=%lld journalHdr=%lld\n"
dan73d66fd2010-08-07 16:17:48 +00001010 "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
dan11f47a92010-08-06 06:54:47 +00001011 , p->zFilename
dande1ae342010-08-06 12:00:27 +00001012 , p->eState==PAGER_OPEN ? "OPEN" :
dand0864082010-08-02 14:32:52 +00001013 p->eState==PAGER_READER ? "READER" :
dande1ae342010-08-06 12:00:27 +00001014 p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
dand0864082010-08-02 14:32:52 +00001015 p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
1016 p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
dana42c66b2010-08-03 18:18:41 +00001017 p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
1018 p->eState==PAGER_ERROR ? "ERROR" : "?error?"
dan4e004aa2010-08-05 15:30:22 +00001019 , (int)p->errCode
dan5198bea2010-08-09 16:12:51 +00001020 , p->eLock==NO_LOCK ? "NO_LOCK" :
dand0864082010-08-02 14:32:52 +00001021 p->eLock==RESERVED_LOCK ? "RESERVED" :
1022 p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
dan4e004aa2010-08-05 15:30:22 +00001023 p->eLock==SHARED_LOCK ? "SHARED" :
1024 p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
dand0864082010-08-02 14:32:52 +00001025 , p->exclusiveMode ? "exclusive" : "normal"
dan937ac9d2010-08-03 12:48:45 +00001026 , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
1027 p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
1028 p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
1029 p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
1030 p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
1031 p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
1032 , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
dan4e004aa2010-08-05 15:30:22 +00001033 , p->journalOff, p->journalHdr
dan73d66fd2010-08-07 16:17:48 +00001034 , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
dand0864082010-08-02 14:32:52 +00001035 );
1036
1037 return zRet;
1038}
danielk1977bea2a942009-01-20 17:06:27 +00001039#endif
1040
drh12e6f682016-12-13 14:32:47 +00001041/* Forward references to the various page getters */
1042static int getPageNormal(Pager*,Pgno,DbPage**,int);
drh12e6f682016-12-13 14:32:47 +00001043static int getPageError(Pager*,Pgno,DbPage**,int);
drhd5df3ff2016-12-13 15:53:22 +00001044#if SQLITE_MAX_MMAP_SIZE>0
1045static int getPageMMap(Pager*,Pgno,DbPage**,int);
1046#endif
drh12e6f682016-12-13 14:32:47 +00001047
1048/*
1049** Set the Pager.xGet method for the appropriate routine used to fetch
1050** content from the pager.
1051*/
1052static void setGetterMethod(Pager *pPager){
1053 if( pPager->errCode ){
1054 pPager->xGet = getPageError;
drhd5df3ff2016-12-13 15:53:22 +00001055#if SQLITE_MAX_MMAP_SIZE>0
drhb48c0d52020-02-07 01:12:53 +00001056 }else if( USEFETCH(pPager) ){
drh12e6f682016-12-13 14:32:47 +00001057 pPager->xGet = getPageMMap;
drhd5df3ff2016-12-13 15:53:22 +00001058#endif /* SQLITE_MAX_MMAP_SIZE>0 */
drh12e6f682016-12-13 14:32:47 +00001059 }else{
1060 pPager->xGet = getPageNormal;
1061 }
1062}
1063
danielk197726836652005-01-17 01:33:13 +00001064/*
danielk19773460d192008-12-27 15:23:13 +00001065** Return true if it is necessary to write page *pPg into the sub-journal.
1066** A page needs to be written into the sub-journal if there exists one
1067** or more open savepoints for which:
danielk1977fd7f0452008-12-17 17:30:26 +00001068**
danielk19773460d192008-12-27 15:23:13 +00001069** * The page-number is less than or equal to PagerSavepoint.nOrig, and
1070** * The bit corresponding to the page-number is not set in
1071** PagerSavepoint.pInSavepoint.
danielk1977f35843b2007-04-07 15:03:17 +00001072*/
danielk19773460d192008-12-27 15:23:13 +00001073static int subjRequiresPage(PgHdr *pPg){
danielk1977f35843b2007-04-07 15:03:17 +00001074 Pager *pPager = pPg->pPager;
drh9d1ab072013-08-21 22:54:55 +00001075 PagerSavepoint *p;
drh16f9a812013-12-13 19:48:04 +00001076 Pgno pgno = pPg->pgno;
danielk19773460d192008-12-27 15:23:13 +00001077 int i;
drh16f9a812013-12-13 19:48:04 +00001078 for(i=0; i<pPager->nSavepoint; i++){
1079 p = &pPager->aSavepoint[i];
drh82ef8772015-06-29 14:11:50 +00001080 if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
danf43fef22021-02-22 15:44:45 +00001081 for(i=i+1; i<pPager->nSavepoint; i++){
1082 pPager->aSavepoint[i].bTruncateOnRelease = 0;
1083 }
drh16f9a812013-12-13 19:48:04 +00001084 return 1;
danielk19773460d192008-12-27 15:23:13 +00001085 }
danielk1977fd7f0452008-12-17 17:30:26 +00001086 }
danielk19773460d192008-12-27 15:23:13 +00001087 return 0;
danielk1977f35843b2007-04-07 15:03:17 +00001088}
drh8ca0c722006-05-07 17:49:38 +00001089
drh82ef8772015-06-29 14:11:50 +00001090#ifdef SQLITE_DEBUG
danielk19773460d192008-12-27 15:23:13 +00001091/*
1092** Return true if the page is already in the journal file.
1093*/
drh5dee6af2013-12-13 20:45:50 +00001094static int pageInJournal(Pager *pPager, PgHdr *pPg){
1095 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
danielk1977bc2ca9e2008-11-13 14:28:28 +00001096}
drh82ef8772015-06-29 14:11:50 +00001097#endif
danielk1977bc2ca9e2008-11-13 14:28:28 +00001098
drh8ca0c722006-05-07 17:49:38 +00001099/*
drh34e79ce2004-02-08 06:05:46 +00001100** Read a 32-bit integer from the given file descriptor. Store the integer
1101** that is read in *pRes. Return SQLITE_OK if everything worked, or an
1102** error code is something goes wrong.
drh726de592004-06-10 23:35:50 +00001103**
1104** All values are stored on disk as big-endian.
drh94f33312002-08-12 12:29:56 +00001105*/
danielk197762079062007-08-15 17:08:46 +00001106static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
drh3b59a5c2006-01-15 20:28:28 +00001107 unsigned char ac[4];
danielk197762079062007-08-15 17:08:46 +00001108 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
drhae2b40c2004-06-09 19:03:54 +00001109 if( rc==SQLITE_OK ){
drha3152892007-05-05 11:48:52 +00001110 *pRes = sqlite3Get4byte(ac);
drh94f33312002-08-12 12:29:56 +00001111 }
drh94f33312002-08-12 12:29:56 +00001112 return rc;
1113}
1114
1115/*
drh97b57482006-01-10 20:32:32 +00001116** Write a 32-bit integer into a string buffer in big-endian byte order.
1117*/
drha3152892007-05-05 11:48:52 +00001118#define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
drh97b57482006-01-10 20:32:32 +00001119
dand0864082010-08-02 14:32:52 +00001120
drh97b57482006-01-10 20:32:32 +00001121/*
drh34e79ce2004-02-08 06:05:46 +00001122** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
1123** on success or an error code is something goes wrong.
drh94f33312002-08-12 12:29:56 +00001124*/
danielk197762079062007-08-15 17:08:46 +00001125static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
danielk1977bab45c62006-01-16 15:14:27 +00001126 char ac[4];
drh97b57482006-01-10 20:32:32 +00001127 put32bits(ac, val);
danielk197762079062007-08-15 17:08:46 +00001128 return sqlite3OsWrite(fd, ac, 4, offset);
drh94f33312002-08-12 12:29:56 +00001129}
1130
drh2554f8b2003-01-22 01:26:44 +00001131/*
dan54919f82010-08-05 18:53:26 +00001132** Unlock the database file to level eLock, which must be either NO_LOCK
1133** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
1134** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
1135**
1136** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1137** called, do not modify it. See the comment above the #define of
1138** UNKNOWN_LOCK for an explanation of this.
danielk19777a2b1ee2007-08-21 14:27:01 +00001139*/
dan4e004aa2010-08-05 15:30:22 +00001140static int pagerUnlockDb(Pager *pPager, int eLock){
dan431b0b42010-08-04 19:14:22 +00001141 int rc = SQLITE_OK;
dan54919f82010-08-05 18:53:26 +00001142
dan8c408002010-11-01 17:38:24 +00001143 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
dan54919f82010-08-05 18:53:26 +00001144 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
1145 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
drh57fe1362014-05-01 01:49:22 +00001146 if( isOpen(pPager->fd) ){
dan431b0b42010-08-04 19:14:22 +00001147 assert( pPager->eLock>=eLock );
drh57fe1362014-05-01 01:49:22 +00001148 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
dan4e004aa2010-08-05 15:30:22 +00001149 if( pPager->eLock!=UNKNOWN_LOCK ){
shaneh1df2db72010-08-18 02:28:48 +00001150 pPager->eLock = (u8)eLock;
dan431b0b42010-08-04 19:14:22 +00001151 }
dan4e004aa2010-08-05 15:30:22 +00001152 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
danielk19777a2b1ee2007-08-21 14:27:01 +00001153 }
drhfce81652019-12-27 01:50:46 +00001154 pPager->changeCountDone = pPager->tempFile; /* ticket fb3b3024ea238d5c */
dan431b0b42010-08-04 19:14:22 +00001155 return rc;
1156}
1157
dan54919f82010-08-05 18:53:26 +00001158/*
1159** Lock the database file to level eLock, which must be either SHARED_LOCK,
1160** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
1161** Pager.eLock variable to the new locking state.
1162**
1163** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1164** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
1165** See the comment above the #define of UNKNOWN_LOCK for an explanation
1166** of this.
1167*/
dan4e004aa2010-08-05 15:30:22 +00001168static int pagerLockDb(Pager *pPager, int eLock){
dan54919f82010-08-05 18:53:26 +00001169 int rc = SQLITE_OK;
1170
dan431b0b42010-08-04 19:14:22 +00001171 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
dan54919f82010-08-05 18:53:26 +00001172 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
drh57fe1362014-05-01 01:49:22 +00001173 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
dan4e004aa2010-08-05 15:30:22 +00001174 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
shaneh1df2db72010-08-18 02:28:48 +00001175 pPager->eLock = (u8)eLock;
dan4e004aa2010-08-05 15:30:22 +00001176 IOTRACE(("LOCK %p %d\n", pPager, eLock))
dan431b0b42010-08-04 19:14:22 +00001177 }
1178 }
1179 return rc;
danielk19777a2b1ee2007-08-21 14:27:01 +00001180}
1181
1182/*
dand67a9772017-07-20 21:00:03 +00001183** This function determines whether or not the atomic-write or
1184** atomic-batch-write optimizations can be used with this pager. The
1185** atomic-write optimization can be used if:
danielk1977c7b60172007-08-22 11:22:03 +00001186**
1187** (a) the value returned by OsDeviceCharacteristics() indicates that
1188** a database page may be written atomically, and
1189** (b) the value returned by OsSectorSize() is less than or equal
1190** to the page size.
1191**
dand67a9772017-07-20 21:00:03 +00001192** If it can be used, then the value returned is the size of the journal
1193** file when it contains rollback data for exactly one page.
danielk1977bea2a942009-01-20 17:06:27 +00001194**
dand67a9772017-07-20 21:00:03 +00001195** The atomic-batch-write optimization can be used if OsDeviceCharacteristics()
1196** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
1197** returned in this case.
1198**
1199** If neither optimization can be used, 0 is returned.
danielk1977c7b60172007-08-22 11:22:03 +00001200*/
danielk1977c7b60172007-08-22 11:22:03 +00001201static int jrnlBufferSize(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00001202 assert( !MEMDB );
danielk1977c7b60172007-08-22 11:22:03 +00001203
dand67a9772017-07-20 21:00:03 +00001204#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
1205 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
1206 int dc; /* Device characteristics */
danefe16972017-07-20 19:49:14 +00001207
dand67a9772017-07-20 21:00:03 +00001208 assert( isOpen(pPager->fd) );
1209 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
drh6235ee52017-10-12 14:18:38 +00001210#else
1211 UNUSED_PARAMETER(pPager);
dand67a9772017-07-20 21:00:03 +00001212#endif
1213
1214#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
danb8fff292018-01-23 14:01:51 +00001215 if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){
dand67a9772017-07-20 21:00:03 +00001216 return -1;
1217 }
1218#endif
1219
1220#ifdef SQLITE_ENABLE_ATOMIC_WRITE
1221 {
1222 int nSector = pPager->sectorSize;
1223 int szPage = pPager->pageSize;
danielk1977c7b60172007-08-22 11:22:03 +00001224
danielk1977bea2a942009-01-20 17:06:27 +00001225 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
1226 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
1227 if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
1228 return 0;
danielk1977ae72d982007-10-03 08:46:44 +00001229 }
danielk1977aef0bf62005-12-30 16:28:01 +00001230 }
danielk1977bea2a942009-01-20 17:06:27 +00001231
1232 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00001233#endif
danielk1977aef0bf62005-12-30 16:28:01 +00001234
dand67a9772017-07-20 21:00:03 +00001235 return 0;
1236}
1237
drh477731b2007-06-16 03:06:27 +00001238/*
1239** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
1240** on the cache using a hash function. This is used for testing
1241** and debugging only.
1242*/
danielk19773c407372005-02-15 02:54:14 +00001243#ifdef SQLITE_CHECK_PAGES
1244/*
1245** Return a 32-bit hash of the page data for pPage.
1246*/
drh477731b2007-06-16 03:06:27 +00001247static u32 pager_datahash(int nByte, unsigned char *pData){
danielk19773c407372005-02-15 02:54:14 +00001248 u32 hash = 0;
1249 int i;
drh477731b2007-06-16 03:06:27 +00001250 for(i=0; i<nByte; i++){
1251 hash = (hash*1039) + pData[i];
danielk19773c407372005-02-15 02:54:14 +00001252 }
1253 return hash;
1254}
drh477731b2007-06-16 03:06:27 +00001255static u32 pager_pagehash(PgHdr *pPage){
danielk19778c0a7912008-08-20 14:49:23 +00001256 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
1257}
danielk1977bc2ca9e2008-11-13 14:28:28 +00001258static void pager_set_pagehash(PgHdr *pPage){
danielk19778c0a7912008-08-20 14:49:23 +00001259 pPage->pageHash = pager_pagehash(pPage);
drh477731b2007-06-16 03:06:27 +00001260}
danielk19773c407372005-02-15 02:54:14 +00001261
1262/*
1263** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
1264** is defined, and NDEBUG is not defined, an assert() statement checks
1265** that the page is either dirty or still matches the calculated page-hash.
1266*/
1267#define CHECK_PAGE(x) checkPage(x)
1268static void checkPage(PgHdr *pPg){
1269 Pager *pPager = pPg->pPager;
dan5f848c32010-08-23 18:19:31 +00001270 assert( pPager->eState!=PAGER_ERROR );
1271 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
danielk19773c407372005-02-15 02:54:14 +00001272}
1273
1274#else
drh8ffa8172007-06-18 17:25:17 +00001275#define pager_datahash(X,Y) 0
drh477731b2007-06-16 03:06:27 +00001276#define pager_pagehash(X) 0
dan5f848c32010-08-23 18:19:31 +00001277#define pager_set_pagehash(X)
danielk19773c407372005-02-15 02:54:14 +00001278#define CHECK_PAGE(x)
drh41d30272008-08-20 21:47:45 +00001279#endif /* SQLITE_CHECK_PAGES */
danielk19773c407372005-02-15 02:54:14 +00001280
drhed7c8552001-04-11 14:29:21 +00001281/*
danielk197776572402004-06-25 02:38:54 +00001282** When this is called the journal file for pager pPager must be open.
drh067b92b2020-06-19 15:24:12 +00001283** This function attempts to read a super-journal file name from the
danielk1977bea2a942009-01-20 17:06:27 +00001284** end of the file and, if successful, copies it into memory supplied
drh067b92b2020-06-19 15:24:12 +00001285** by the caller. See comments above writeSuperJournal() for the format
1286** used to store a super-journal file name at the end of a journal file.
danielk197776572402004-06-25 02:38:54 +00001287**
drh067b92b2020-06-19 15:24:12 +00001288** zSuper must point to a buffer of at least nSuper bytes allocated by
danielk197765839c62007-08-30 08:08:17 +00001289** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
drh067b92b2020-06-19 15:24:12 +00001290** enough space to write the super-journal name). If the super-journal
1291** name in the journal is longer than nSuper bytes (including a
1292** nul-terminator), then this is handled as if no super-journal name
danielk197765839c62007-08-30 08:08:17 +00001293** were present in the journal.
1294**
drh067b92b2020-06-19 15:24:12 +00001295** If a super-journal file name is present at the end of the journal
1296** file, then it is copied into the buffer pointed to by zSuper. A
1297** nul-terminator byte is appended to the buffer following the
1298** super-journal file name.
danielk1977bea2a942009-01-20 17:06:27 +00001299**
drh067b92b2020-06-19 15:24:12 +00001300** If it is determined that no super-journal file name is present
1301** zSuper[0] is set to 0 and SQLITE_OK returned.
danielk1977bea2a942009-01-20 17:06:27 +00001302**
1303** If an error occurs while reading from the journal file, an SQLite
1304** error code is returned.
danielk197776572402004-06-25 02:38:54 +00001305*/
drh067b92b2020-06-19 15:24:12 +00001306static int readSuperJournal(sqlite3_file *pJrnl, char *zSuper, u32 nSuper){
danielk1977bea2a942009-01-20 17:06:27 +00001307 int rc; /* Return code */
drh067b92b2020-06-19 15:24:12 +00001308 u32 len; /* Length in bytes of super-journal name */
danielk1977bea2a942009-01-20 17:06:27 +00001309 i64 szJ; /* Total size in bytes of journal file pJrnl */
1310 u32 cksum; /* MJ checksum value read from journal */
1311 u32 u; /* Unsigned loop counter */
1312 unsigned char aMagic[8]; /* A buffer to hold the magic header */
drh067b92b2020-06-19 15:24:12 +00001313 zSuper[0] = '\0';
danielk197776572402004-06-25 02:38:54 +00001314
danielk1977bea2a942009-01-20 17:06:27 +00001315 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
1316 || szJ<16
1317 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
drh067b92b2020-06-19 15:24:12 +00001318 || len>=nSuper
drh05f1ba02017-09-07 09:56:37 +00001319 || len>szJ-16
dan999cd082013-12-09 20:42:03 +00001320 || len==0
danielk1977bea2a942009-01-20 17:06:27 +00001321 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
1322 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
1323 || memcmp(aMagic, aJournalMagic, 8)
drh067b92b2020-06-19 15:24:12 +00001324 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len))
danielk1977bea2a942009-01-20 17:06:27 +00001325 ){
danielk197776572402004-06-25 02:38:54 +00001326 return rc;
1327 }
danielk1977cafadba2004-06-25 11:11:54 +00001328
drh067b92b2020-06-19 15:24:12 +00001329 /* See if the checksum matches the super-journal name */
shane0b8d2762008-07-22 05:18:00 +00001330 for(u=0; u<len; u++){
drh067b92b2020-06-19 15:24:12 +00001331 cksum -= zSuper[u];
danielk1977bea2a942009-01-20 17:06:27 +00001332 }
danielk19778191bff2004-06-28 04:52:30 +00001333 if( cksum ){
1334 /* If the checksum doesn't add up, then one or more of the disk sectors
drh067b92b2020-06-19 15:24:12 +00001335 ** containing the super-journal filename is corrupted. This means
danielk19778191bff2004-06-28 04:52:30 +00001336 ** definitely roll back, so just return SQLITE_OK and report a (nul)
drh067b92b2020-06-19 15:24:12 +00001337 ** super-journal filename.
danielk19778191bff2004-06-28 04:52:30 +00001338 */
danielk1977bea2a942009-01-20 17:06:27 +00001339 len = 0;
danielk1977cafadba2004-06-25 11:11:54 +00001340 }
drh067b92b2020-06-19 15:24:12 +00001341 zSuper[len] = '\0';
1342 zSuper[len+1] = '\0';
danielk197776572402004-06-25 02:38:54 +00001343
1344 return SQLITE_OK;
1345}
1346
1347/*
danielk1977bea2a942009-01-20 17:06:27 +00001348** 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.
danielk197776572402004-06-25 02:38:54 +00001351**
1352** i.e for a sector size of 512:
1353**
danielk1977bea2a942009-01-20 17:06:27 +00001354** Pager.journalOff Return value
1355** ---------------------------------------
1356** 0 0
1357** 512 512
1358** 100 512
1359** 2000 2048
danielk197776572402004-06-25 02:38:54 +00001360**
1361*/
danielk1977112f7522009-01-08 17:50:45 +00001362static i64 journalHdrOffset(Pager *pPager){
drheb206252004-10-01 02:00:31 +00001363 i64 offset = 0;
1364 i64 c = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001365 if( c ){
1366 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
1367 }
1368 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
1369 assert( offset>=c );
1370 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
danielk1977112f7522009-01-08 17:50:45 +00001371 return offset;
1372}
danielk197776572402004-06-25 02:38:54 +00001373
1374/*
danielk1977bea2a942009-01-20 17:06:27 +00001375** The journal file must be open when this function is called.
1376**
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).
1379**
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.
1385**
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.
1391**
1392** If an IO error occurs, abandon processing and return the IO error code.
1393** Otherwise, return SQLITE_OK.
drhf3a87622008-04-17 14:16:42 +00001394*/
danielk1977df2566a2008-05-07 19:11:03 +00001395static int zeroJournalHdr(Pager *pPager, int doTruncate){
danielk1977bea2a942009-01-20 17:06:27 +00001396 int rc = SQLITE_OK; /* Return code */
1397 assert( isOpen(pPager->jfd) );
dan5f37ed52016-02-29 20:00:13 +00001398 assert( !sqlite3JournalIsInMemory(pPager->jfd) );
danielk1977df2566a2008-05-07 19:11:03 +00001399 if( pPager->journalOff ){
danielk1977bea2a942009-01-20 17:06:27 +00001400 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
danielk1977b53e4962008-06-04 06:45:59 +00001401
danielk1977df2566a2008-05-07 19:11:03 +00001402 IOTRACE(("JZEROHDR %p\n", pPager))
danielk1977b53e4962008-06-04 06:45:59 +00001403 if( doTruncate || iLimit==0 ){
danielk1977df2566a2008-05-07 19:11:03 +00001404 rc = sqlite3OsTruncate(pPager->jfd, 0);
1405 }else{
danielk1977bea2a942009-01-20 17:06:27 +00001406 static const char zeroHdr[28] = {0};
danielk1977df2566a2008-05-07 19:11:03 +00001407 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
1408 }
danielk197781620542008-06-07 05:19:37 +00001409 if( rc==SQLITE_OK && !pPager->noSync ){
drhc97d8462010-11-19 18:23:35 +00001410 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
danielk1977df2566a2008-05-07 19:11:03 +00001411 }
danielk1977b53e4962008-06-04 06:45:59 +00001412
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.
1418 */
1419 if( rc==SQLITE_OK && iLimit>0 ){
1420 i64 sz;
1421 rc = sqlite3OsFileSize(pPager->jfd, &sz);
1422 if( rc==SQLITE_OK && sz>iLimit ){
1423 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
1424 }
1425 }
drha06ecba2008-04-22 17:15:17 +00001426 }
drhf3a87622008-04-17 14:16:42 +00001427 return rc;
1428}
1429
1430/*
danielk197776572402004-06-25 02:38:54 +00001431** 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.
1434**
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.
danielk197767c007b2008-03-20 04:45:49 +00001441** - 4 bytes: Database page size.
danielk197776572402004-06-25 02:38:54 +00001442**
danielk197767c007b2008-03-20 04:45:49 +00001443** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
danielk197776572402004-06-25 02:38:54 +00001444*/
1445static int writeJournalHdr(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00001446 int rc = SQLITE_OK; /* Return code */
1447 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
drh43b18e12010-08-17 19:40:08 +00001448 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
danielk1977bea2a942009-01-20 17:06:27 +00001449 u32 nWrite; /* Bytes of header sector written */
1450 int ii; /* Loop counter */
1451
1452 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
danielk1977a664f8e2008-04-22 14:31:48 +00001453
1454 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
1455 nHeader = JOURNAL_HDR_SZ(pPager);
1456 }
danielk197776572402004-06-25 02:38:54 +00001457
danielk1977bea2a942009-01-20 17:06:27 +00001458 /* 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.
danielk1977fd7f0452008-12-17 17:30:26 +00001461 */
1462 for(ii=0; ii<pPager->nSavepoint; ii++){
1463 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
1464 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
1465 }
danielk19774099f6e2007-03-19 11:25:20 +00001466 }
1467
danielk1977bea2a942009-01-20 17:06:27 +00001468 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
danielk19774cd2cd52007-08-23 14:48:23 +00001469
1470 /*
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()).
1476 **
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
shanebe217792009-03-05 04:20:31 +00001480 ** is dangerous, as if a failure occurred whilst writing to the journal
danielk19774cd2cd52007-08-23 14:48:23 +00001481 ** file it may contain some garbage data. There are two scenarios
1482 ** where this risk can be ignored:
1483 **
1484 ** * When the pager is in no-sync mode. Corruption can follow a
1485 ** power failure in this case anyway.
1486 **
1487 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1488 ** that garbage data is never appended to the journal file.
1489 */
danielk1977bea2a942009-01-20 17:06:27 +00001490 assert( isOpen(pPager->fd) || pPager->noSync );
dand0864082010-08-02 14:32:52 +00001491 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
danielk19774cd2cd52007-08-23 14:48:23 +00001492 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
1493 ){
danielk19776f4c73e2009-06-26 07:12:06 +00001494 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
danielk19774cd2cd52007-08-23 14:48:23 +00001495 put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
1496 }else{
drh5ec53192009-08-31 16:09:58 +00001497 memset(zHeader, 0, sizeof(aJournalMagic)+4);
danielk19774cd2cd52007-08-23 14:48:23 +00001498 }
1499
mistachkin48864df2013-03-21 21:20:32 +00001500 /* The random check-hash initializer */
drh2fa18682008-03-19 14:15:34 +00001501 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
drh97b57482006-01-10 20:32:32 +00001502 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
1503 /* The initial database size */
danielk19773460d192008-12-27 15:23:13 +00001504 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
drh97b57482006-01-10 20:32:32 +00001505 /* The assumed sector size for this process */
1506 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
drh08609ce2008-11-29 22:49:23 +00001507
danielk1977bea2a942009-01-20 17:06:27 +00001508 /* The page size */
1509 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
1510
drh08609ce2008-11-29 22:49:23 +00001511 /* 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.
1515 */
danielk1977bea2a942009-01-20 17:06:27 +00001516 memset(&zHeader[sizeof(aJournalMagic)+20], 0,
1517 nHeader-(sizeof(aJournalMagic)+20));
drh08609ce2008-11-29 22:49:23 +00001518
danielk1977bea2a942009-01-20 17:06:27 +00001519 /* 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).
1524 **
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
1529 ** is done.
1530 **
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.
1535 */
danielk1977a664f8e2008-04-22 14:31:48 +00001536 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);
drh91781bd2010-04-10 17:52:57 +00001539 assert( pPager->journalHdr <= pPager->journalOff );
danielk1977a664f8e2008-04-22 14:31:48 +00001540 pPager->journalOff += nHeader;
danielk197776572402004-06-25 02:38:54 +00001541 }
danielk1977a664f8e2008-04-22 14:31:48 +00001542
danielk197776572402004-06-25 02:38:54 +00001543 return rc;
1544}
1545
1546/*
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
drhd6e5e092009-01-07 02:03:35 +00001549** file. The current location in the journal file is given by
danielk1977bea2a942009-01-20 17:06:27 +00001550** pPager->journalOff. See comments above function writeJournalHdr() for
drhd6e5e092009-01-07 02:03:35 +00001551** a description of the journal header format.
danielk197776572402004-06-25 02:38:54 +00001552**
danielk1977bea2a942009-01-20 17:06:27 +00001553** 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
danielk197776572402004-06-25 02:38:54 +00001555** 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
1557** in this case.
1558**
1559** If the journal header file appears to be corrupted, SQLITE_DONE is
danielk1977bea2a942009-01-20 17:06:27 +00001560** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
danielk197776572402004-06-25 02:38:54 +00001561** cannot be read from the journal file an error code is returned.
1562*/
1563static int readJournalHdr(
danielk1977bea2a942009-01-20 17:06:27 +00001564 Pager *pPager, /* Pager object */
danielk19776f4c73e2009-06-26 07:12:06 +00001565 int isHot,
danielk1977bea2a942009-01-20 17:06:27 +00001566 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 */
danielk197776572402004-06-25 02:38:54 +00001569){
danielk1977bea2a942009-01-20 17:06:27 +00001570 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 */
danielk197776572402004-06-25 02:38:54 +00001573
danielk1977bea2a942009-01-20 17:06:27 +00001574 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
1575
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.
1579 */
1580 pPager->journalOff = journalHdrOffset(pPager);
danielk197776572402004-06-25 02:38:54 +00001581 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
1582 return SQLITE_DONE;
1583 }
danielk1977bea2a942009-01-20 17:06:27 +00001584 iHdrOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001585
danielk1977bea2a942009-01-20 17:06:27 +00001586 /* 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,
1589 ** proceed.
1590 */
danielk19776f4c73e2009-06-26 07:12:06 +00001591 if( isHot || iHdrOff!=pPager->journalHdr ){
1592 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
1593 if( rc ){
1594 return rc;
1595 }
1596 if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
1597 return SQLITE_DONE;
1598 }
danielk197776572402004-06-25 02:38:54 +00001599 }
1600
danielk1977bea2a942009-01-20 17:06:27 +00001601 /* 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.
1604 */
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))
1608 ){
1609 return rc;
1610 }
danielk197776572402004-06-25 02:38:54 +00001611
danielk19777cbd5892009-01-10 16:15:09 +00001612 if( pPager->journalOff==0 ){
danielk1977bea2a942009-01-20 17:06:27 +00001613 u32 iPageSize; /* Page-size field of journal header */
1614 u32 iSectorSize; /* Sector-size field of journal header */
danielk197767c007b2008-03-20 04:45:49 +00001615
danielk1977bea2a942009-01-20 17:06:27 +00001616 /* 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))
danielk19777cbd5892009-01-10 16:15:09 +00001619 ){
danielk1977bea2a942009-01-20 17:06:27 +00001620 return rc;
danielk1977443c0592009-01-16 15:21:05 +00001621 }
danielk1977bea2a942009-01-20 17:06:27 +00001622
dana35dafc2010-08-19 15:11:34 +00001623 /* 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.
1626 */
1627 if( iPageSize==0 ){
1628 iPageSize = pPager->pageSize;
1629 }
1630
danielk1977bea2a942009-01-20 17:06:27 +00001631 /* 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
drh3c99d682009-11-11 13:17:08 +00001633 ** of two greater than or equal to 512 or 32, and not greater than their
danielk1977bea2a942009-01-20 17:06:27 +00001634 ** respective compile time maximum limits.
1635 */
drh3c99d682009-11-11 13:17:08 +00001636 if( iPageSize<512 || iSectorSize<32
danielk1977bea2a942009-01-20 17:06:27 +00001637 || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
1638 || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
1639 ){
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.
1644 */
1645 return SQLITE_DONE;
1646 }
1647
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.
1651 */
drhb2eced52010-08-12 02:41:12 +00001652 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
danielk1977bea2a942009-01-20 17:06:27 +00001653 testcase( rc!=SQLITE_OK );
danielk1977bea2a942009-01-20 17:06:27 +00001654
danielk19777cbd5892009-01-10 16:15:09 +00001655 /* 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.
1660 */
danielk19777cbd5892009-01-10 16:15:09 +00001661 pPager->sectorSize = iSectorSize;
drh98c58352008-11-07 00:24:53 +00001662 }
danielk197776572402004-06-25 02:38:54 +00001663
1664 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00001665 return rc;
danielk197776572402004-06-25 02:38:54 +00001666}
1667
1668
1669/*
drh067b92b2020-06-19 15:24:12 +00001670** Write the supplied super-journal name into the journal file for pager
1671** pPager at the current location. The super-journal name must be the last
danielk1977cafadba2004-06-25 11:11:54 +00001672** 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:
1675**
drh584bfca2022-02-23 17:00:44 +00001676** + 4 bytes: PAGER_SJ_PGNO.
drh067b92b2020-06-19 15:24:12 +00001677** + N bytes: super-journal filename in utf-8.
1678** + 4 bytes: N (length of super-journal name in bytes, no nul-terminator).
1679** + 4 bytes: super-journal name checksum.
danielk1977bea2a942009-01-20 17:06:27 +00001680** + 8 bytes: aJournalMagic[].
danielk1977cafadba2004-06-25 11:11:54 +00001681**
drh067b92b2020-06-19 15:24:12 +00001682** The super-journal page checksum is the sum of the bytes in thesuper-journal
1683** name, where each byte is interpreted as a signed 8-bit integer.
danielk1977aef0bf62005-12-30 16:28:01 +00001684**
drh067b92b2020-06-19 15:24:12 +00001685** If zSuper is a NULL pointer (occurs for a single database transaction),
danielk1977aef0bf62005-12-30 16:28:01 +00001686** this call is a no-op.
danielk197776572402004-06-25 02:38:54 +00001687*/
drh067b92b2020-06-19 15:24:12 +00001688static int writeSuperJournal(Pager *pPager, const char *zSuper){
danielk1977bea2a942009-01-20 17:06:27 +00001689 int rc; /* Return code */
drh067b92b2020-06-19 15:24:12 +00001690 int nSuper; /* Length of string zSuper */
danielk1977bea2a942009-01-20 17:06:27 +00001691 i64 iHdrOff; /* Offset of header in journal file */
1692 i64 jrnlSize; /* Size of journal file on disk */
drh067b92b2020-06-19 15:24:12 +00001693 u32 cksum = 0; /* Checksum of string zSuper */
danielk197776572402004-06-25 02:38:54 +00001694
drh067b92b2020-06-19 15:24:12 +00001695 assert( pPager->setSuper==0 );
dand0864082010-08-02 14:32:52 +00001696 assert( !pagerUseWal(pPager) );
dan1e01cf12010-07-30 11:31:12 +00001697
drh067b92b2020-06-19 15:24:12 +00001698 if( !zSuper
danielk1977bea2a942009-01-20 17:06:27 +00001699 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
drh1fb6a112014-04-04 14:12:52 +00001700 || !isOpen(pPager->jfd)
danielk1977bea2a942009-01-20 17:06:27 +00001701 ){
1702 return SQLITE_OK;
1703 }
drh067b92b2020-06-19 15:24:12 +00001704 pPager->setSuper = 1;
drh91781bd2010-04-10 17:52:57 +00001705 assert( pPager->journalHdr <= pPager->journalOff );
danielk197776572402004-06-25 02:38:54 +00001706
drh067b92b2020-06-19 15:24:12 +00001707 /* Calculate the length in bytes and the checksum of zSuper */
1708 for(nSuper=0; zSuper[nSuper]; nSuper++){
1709 cksum += zSuper[nSuper];
danielk1977cafadba2004-06-25 11:11:54 +00001710 }
danielk197776572402004-06-25 02:38:54 +00001711
1712 /* If in full-sync mode, advance to the next disk sector before writing
drh067b92b2020-06-19 15:24:12 +00001713 ** the super-journal name. This is in case the previous page written to
danielk197776572402004-06-25 02:38:54 +00001714 ** the journal has already been synced.
1715 */
1716 if( pPager->fullSync ){
danielk1977bea2a942009-01-20 17:06:27 +00001717 pPager->journalOff = journalHdrOffset(pPager);
danielk197776572402004-06-25 02:38:54 +00001718 }
danielk1977bea2a942009-01-20 17:06:27 +00001719 iHdrOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001720
drh067b92b2020-06-19 15:24:12 +00001721 /* Write the super-journal data to the end of the journal file. If
danielk1977bea2a942009-01-20 17:06:27 +00001722 ** an error occurs, return the error code to the caller.
1723 */
drh584bfca2022-02-23 17:00:44 +00001724 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_SJ_PGNO(pPager))))
drh067b92b2020-06-19 15:24:12 +00001725 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4)))
1726 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper)))
1727 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum)))
drhe399ac22015-06-29 18:14:02 +00001728 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
drh067b92b2020-06-19 15:24:12 +00001729 iHdrOff+4+nSuper+8)))
danielk1977bea2a942009-01-20 17:06:27 +00001730 ){
1731 return rc;
1732 }
drh067b92b2020-06-19 15:24:12 +00001733 pPager->journalOff += (nSuper+20);
danielk1977df2566a2008-05-07 19:11:03 +00001734
1735 /* If the pager is in peristent-journal mode, then the physical
drh067b92b2020-06-19 15:24:12 +00001736 ** journal-file may extend past the end of the super-journal name
danielk1977df2566a2008-05-07 19:11:03 +00001737 ** and 8 bytes of magic data just written to the file. This is
1738 ** dangerous because the code to rollback a hot-journal file
drh067b92b2020-06-19 15:24:12 +00001739 ** will not be able to find the super-journal name to determine
danielk1977df2566a2008-05-07 19:11:03 +00001740 ** whether or not the journal is hot.
1741 **
1742 ** Easiest thing to do in this scenario is to truncate the journal
1743 ** file to the required size.
1744 */
danielk1977bea2a942009-01-20 17:06:27 +00001745 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
1746 && jrnlSize>pPager->journalOff
danielk1977df2566a2008-05-07 19:11:03 +00001747 ){
danielk1977bea2a942009-01-20 17:06:27 +00001748 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
danielk1977df2566a2008-05-07 19:11:03 +00001749 }
danielk197776572402004-06-25 02:38:54 +00001750 return rc;
1751}
1752
1753/*
dana42c66b2010-08-03 18:18:41 +00001754** Discard the entire contents of the in-memory page-cache.
drhed7c8552001-04-11 14:29:21 +00001755*/
drhd9b02572001-04-15 00:37:09 +00001756static void pager_reset(Pager *pPager){
drhd7107b32014-12-20 14:34:02 +00001757 pPager->iDataVersion++;
dana42c66b2010-08-03 18:18:41 +00001758 sqlite3BackupRestart(pPager->pBackup);
1759 sqlite3PcacheClear(pPager->pPCache);
danielk1977e277be02007-03-23 18:12:06 +00001760}
1761
danielk197734cf35d2008-12-18 18:31:38 +00001762/*
drhd7107b32014-12-20 14:34:02 +00001763** Return the pPager->iDataVersion value
drh91618562014-12-19 19:28:02 +00001764*/
1765u32 sqlite3PagerDataVersion(Pager *pPager){
drhd7107b32014-12-20 14:34:02 +00001766 return pPager->iDataVersion;
drh91618562014-12-19 19:28:02 +00001767}
1768
1769/*
danielk197734cf35d2008-12-18 18:31:38 +00001770** Free all structures in the Pager.aSavepoint[] array and set both
1771** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1772** if it is open and the pager is not in exclusive mode.
1773*/
danielk1977bea2a942009-01-20 17:06:27 +00001774static void releaseAllSavepoints(Pager *pPager){
1775 int ii; /* Iterator for looping through Pager.aSavepoint */
danielk1977fd7f0452008-12-17 17:30:26 +00001776 for(ii=0; ii<pPager->nSavepoint; ii++){
1777 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
1778 }
dan2491de22016-02-27 20:14:55 +00001779 if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){
danielk1977fd7f0452008-12-17 17:30:26 +00001780 sqlite3OsClose(pPager->sjfd);
1781 }
1782 sqlite3_free(pPager->aSavepoint);
1783 pPager->aSavepoint = 0;
1784 pPager->nSavepoint = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001785 pPager->nSubRec = 0;
danielk1977fd7f0452008-12-17 17:30:26 +00001786}
1787
danielk197734cf35d2008-12-18 18:31:38 +00001788/*
danielk1977bea2a942009-01-20 17:06:27 +00001789** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1790** bitvecs of all open savepoints. Return SQLITE_OK if successful
1791** or SQLITE_NOMEM if a malloc failure occurs.
danielk197734cf35d2008-12-18 18:31:38 +00001792*/
danielk1977fd7f0452008-12-17 17:30:26 +00001793static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
drh7539b6b2009-01-02 21:39:39 +00001794 int ii; /* Loop counter */
1795 int rc = SQLITE_OK; /* Result code */
1796
danielk1977fd7f0452008-12-17 17:30:26 +00001797 for(ii=0; ii<pPager->nSavepoint; ii++){
1798 PagerSavepoint *p = &pPager->aSavepoint[ii];
1799 if( pgno<=p->nOrig ){
drh7539b6b2009-01-02 21:39:39 +00001800 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
danielk1977bea2a942009-01-20 17:06:27 +00001801 testcase( rc==SQLITE_NOMEM );
drh7539b6b2009-01-02 21:39:39 +00001802 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
danielk1977fd7f0452008-12-17 17:30:26 +00001803 }
1804 }
drh7539b6b2009-01-02 21:39:39 +00001805 return rc;
danielk1977fd7f0452008-12-17 17:30:26 +00001806}
1807
drh01be4632015-09-03 15:17:12 +00001808#ifndef SQLITE_OMIT_CONCURRENT
danc8a9d152015-08-27 19:57:16 +00001809/*
1810** If they are not already, begin recording all pages read from the pager layer
1811** by the b-tree layer This is used by concurrent transactions. Return
1812** SQLITE_OK if successful, or an SQLite error code (SQLITE_NOMEM) if an error
1813** occurs.
1814*/
dan987f8212015-08-27 17:42:38 +00001815int sqlite3PagerBeginConcurrent(Pager *pPager){
1816 int rc = SQLITE_OK;
1817 if( pPager->pAllRead==0 ){
1818 pPager->pAllRead = sqlite3BitvecCreate(pPager->dbSize);
dan6dbb4522017-05-18 20:47:31 +00001819 pPager->dbOrigSize = pPager->dbSize;
dan987f8212015-08-27 17:42:38 +00001820 if( pPager->pAllRead==0 ){
1821 rc = SQLITE_NOMEM;
1822 }
1823 }
1824 return rc;
1825}
1826
drh01be4632015-09-03 15:17:12 +00001827/* !defined(SQLITE_OMIT_CONCURRENT)
1828**
danc8a9d152015-08-27 19:57:16 +00001829** Stop recording all pages read from the pager layer by the b-tree layer
1830** and discard any current records.
1831*/
dan987f8212015-08-27 17:42:38 +00001832void sqlite3PagerEndConcurrent(Pager *pPager){
1833 sqlite3BitvecDestroy(pPager->pAllRead);
1834 pPager->pAllRead = 0;
1835}
1836
drh01be4632015-09-03 15:17:12 +00001837/* !defined(SQLITE_OMIT_CONCURRENT)
1838**
danc8a9d152015-08-27 19:57:16 +00001839** Return true if the database is in wal mode. False otherwise.
1840*/
dan987f8212015-08-27 17:42:38 +00001841int sqlite3PagerIsWal(Pager *pPager){
1842 return pPager->pWal!=0;
1843}
drh01be4632015-09-03 15:17:12 +00001844#endif /* SQLITE_OMIT_CONCURRENT */
dan987f8212015-08-27 17:42:38 +00001845
danielk1977e277be02007-03-23 18:12:06 +00001846/*
dan773d2d62015-07-29 12:14:28 +00001847** Free the Pager.pInJournal and Pager.pAllRead bitvec objects.
1848*/
1849static void pagerFreeBitvecs(Pager *pPager){
1850 sqlite3BitvecDestroy(pPager->pInJournal);
dan773d2d62015-07-29 12:14:28 +00001851 pPager->pInJournal = 0;
dan987f8212015-08-27 17:42:38 +00001852 sqlite3PagerEndConcurrent(pPager);
dan773d2d62015-07-29 12:14:28 +00001853}
1854
1855/*
dande5fd222010-08-09 19:17:29 +00001856** This function is a no-op if the pager is in exclusive mode and not
1857** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
1858** state.
danielk1977ae72d982007-10-03 08:46:44 +00001859**
dande5fd222010-08-09 19:17:29 +00001860** If the pager is not in exclusive-access mode, the database file is
1861** completely unlocked. If the file is unlocked and the file-system does
1862** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
1863** closed (if it is open).
1864**
1865** If the pager is in ERROR state when this function is called, the
1866** contents of the pager cache are discarded before switching back to
1867** the OPEN state. Regardless of whether the pager is in exclusive-mode
1868** or not, any journal file left in the file-system will be treated
1869** as a hot-journal and rolled back the next time a read-transaction
1870** is opened (by this or by any other connection).
danielk1977ae72d982007-10-03 08:46:44 +00001871*/
1872static void pager_unlock(Pager *pPager){
dana42c66b2010-08-03 18:18:41 +00001873
dande5fd222010-08-09 19:17:29 +00001874 assert( pPager->eState==PAGER_READER
1875 || pPager->eState==PAGER_OPEN
1876 || pPager->eState==PAGER_ERROR
1877 );
1878
dan773d2d62015-07-29 12:14:28 +00001879 pagerFreeBitvecs(pPager);
dana42c66b2010-08-03 18:18:41 +00001880 releaseAllSavepoints(pPager);
1881
1882 if( pagerUseWal(pPager) ){
1883 assert( !isOpen(pPager->jfd) );
1884 sqlite3WalEndReadTransaction(pPager->pWal);
dande1ae342010-08-06 12:00:27 +00001885 pPager->eState = PAGER_OPEN;
dana42c66b2010-08-03 18:18:41 +00001886 }else if( !pPager->exclusiveMode ){
dan4e004aa2010-08-05 15:30:22 +00001887 int rc; /* Error code returned by pagerUnlockDb() */
dane08341c2010-06-21 12:34:29 +00001888 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
danielk1977ae72d982007-10-03 08:46:44 +00001889
drhde3c3012010-06-21 20:19:25 +00001890 /* If the operating system support deletion of open files, then
1891 ** close the journal file when dropping the database lock. Otherwise
1892 ** another connection with journal_mode=delete might delete the file
1893 ** out from under us.
danielk1977b3175382008-10-17 18:51:52 +00001894 */
dane08341c2010-06-21 12:34:29 +00001895 assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
1896 assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
1897 assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
1898 assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
1899 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
1900 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
1901 if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
1902 || 1!=(pPager->journalMode & 5)
dan2a321c72010-06-16 19:04:23 +00001903 ){
1904 sqlite3OsClose(pPager->jfd);
1905 }
dan4e004aa2010-08-05 15:30:22 +00001906
dan54919f82010-08-05 18:53:26 +00001907 /* If the pager is in the ERROR state and the call to unlock the database
1908 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
1909 ** above the #define for UNKNOWN_LOCK for an explanation of why this
1910 ** is necessary.
1911 */
dan4e004aa2010-08-05 15:30:22 +00001912 rc = pagerUnlockDb(pPager, NO_LOCK);
1913 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
1914 pPager->eLock = UNKNOWN_LOCK;
1915 }
dan2a321c72010-06-16 19:04:23 +00001916
dande1ae342010-08-06 12:00:27 +00001917 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
dana42c66b2010-08-03 18:18:41 +00001918 ** without clearing the error code. This is intentional - the error
1919 ** code is cleared and the cache reset in the block below.
danielk1977b3175382008-10-17 18:51:52 +00001920 */
dana42c66b2010-08-03 18:18:41 +00001921 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
dande1ae342010-08-06 12:00:27 +00001922 pPager->eState = PAGER_OPEN;
dana42c66b2010-08-03 18:18:41 +00001923 }
1924
1925 /* If Pager.errCode is set, the contents of the pager cache cannot be
1926 ** trusted. Now that there are no outstanding references to the pager,
dande1ae342010-08-06 12:00:27 +00001927 ** it can safely move back to PAGER_OPEN state. This happens in both
dana42c66b2010-08-03 18:18:41 +00001928 ** normal and exclusive-locking mode.
1929 */
dan67330a12016-04-11 18:07:47 +00001930 assert( pPager->errCode==SQLITE_OK || !MEMDB );
dan22b328b2010-08-11 18:56:45 +00001931 if( pPager->errCode ){
dan6572c162016-04-23 14:55:28 +00001932 if( pPager->tempFile==0 ){
1933 pager_reset(pPager);
1934 pPager->changeCountDone = 0;
1935 pPager->eState = PAGER_OPEN;
1936 }else{
1937 pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
1938 }
dan789efdb2013-07-06 17:57:39 +00001939 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
dan6572c162016-04-23 14:55:28 +00001940 pPager->errCode = SQLITE_OK;
drh12e6f682016-12-13 14:32:47 +00001941 setGetterMethod(pPager);
danielk1977ae72d982007-10-03 08:46:44 +00001942 }
dan4e004aa2010-08-05 15:30:22 +00001943
1944 pPager->journalOff = 0;
1945 pPager->journalHdr = 0;
drh067b92b2020-06-19 15:24:12 +00001946 pPager->setSuper = 0;
danielk1977ae72d982007-10-03 08:46:44 +00001947}
1948
1949/*
dande5fd222010-08-09 19:17:29 +00001950** This function is called whenever an IOERR or FULL error that requires
1951** the pager to transition into the ERROR state may ahve occurred.
1952** The first argument is a pointer to the pager structure, the second
1953** the error-code about to be returned by a pager API function. The
1954** value returned is a copy of the second argument to this function.
danielk1977bea2a942009-01-20 17:06:27 +00001955**
dande5fd222010-08-09 19:17:29 +00001956** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
1957** IOERR sub-codes, the pager enters the ERROR state and the error code
1958** is stored in Pager.errCode. While the pager remains in the ERROR state,
1959** all major API calls on the Pager will immediately return Pager.errCode.
danielk1977bea2a942009-01-20 17:06:27 +00001960**
dande5fd222010-08-09 19:17:29 +00001961** The ERROR state indicates that the contents of the pager-cache
danielk1977bea2a942009-01-20 17:06:27 +00001962** cannot be trusted. This state can be cleared by completely discarding
1963** the contents of the pager-cache. If a transaction was active when
shanebe217792009-03-05 04:20:31 +00001964** the persistent error occurred, then the rollback journal may need
danielk1977bea2a942009-01-20 17:06:27 +00001965** to be replayed to restore the contents of the database file (as if
1966** it were a hot-journal).
1967*/
1968static int pager_error(Pager *pPager, int rc){
1969 int rc2 = rc & 0xff;
danielk1977c7ca8752009-07-25 17:39:13 +00001970 assert( rc==SQLITE_OK || !MEMDB );
danielk1977bea2a942009-01-20 17:06:27 +00001971 assert(
1972 pPager->errCode==SQLITE_FULL ||
1973 pPager->errCode==SQLITE_OK ||
1974 (pPager->errCode & 0xff)==SQLITE_IOERR
1975 );
drhb75d5702009-07-25 17:08:35 +00001976 if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){
danielk1977bea2a942009-01-20 17:06:27 +00001977 pPager->errCode = rc;
dana42c66b2010-08-03 18:18:41 +00001978 pPager->eState = PAGER_ERROR;
drh12e6f682016-12-13 14:32:47 +00001979 setGetterMethod(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00001980 }
1981 return rc;
1982}
1983
danbc1a3c62013-02-23 16:40:46 +00001984static int pager_truncate(Pager *pPager, Pgno nPage);
1985
danielk1977bea2a942009-01-20 17:06:27 +00001986/*
drh4bf7d212016-05-13 12:12:38 +00001987** The write transaction open on pPager is being committed (bCommit==1)
1988** or rolled back (bCommit==0).
dan0f524552016-04-13 16:52:11 +00001989**
drh4bf7d212016-05-13 12:12:38 +00001990** Return TRUE if and only if all dirty pages should be flushed to disk.
dan0f524552016-04-13 16:52:11 +00001991**
drh4bf7d212016-05-13 12:12:38 +00001992** Rules:
dan0f524552016-04-13 16:52:11 +00001993**
drh4bf7d212016-05-13 12:12:38 +00001994** * For non-TEMP databases, always sync to disk. This is necessary
1995** for transactions to be durable.
1996**
1997** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing
1998** file has been created already (via a spill on pagerStress()) and
1999** when the number of dirty pages in memory exceeds 25% of the total
2000** cache size.
dan0f524552016-04-13 16:52:11 +00002001*/
drh4bf7d212016-05-13 12:12:38 +00002002static int pagerFlushOnCommit(Pager *pPager, int bCommit){
dan0f524552016-04-13 16:52:11 +00002003 if( pPager->tempFile==0 ) return 1;
drh4bf7d212016-05-13 12:12:38 +00002004 if( !bCommit ) return 0;
dan0f524552016-04-13 16:52:11 +00002005 if( !isOpen(pPager->fd) ) return 0;
2006 return (sqlite3PCachePercentDirty(pPager->pPCache)>=25);
2007}
2008
2009/*
danielk1977bea2a942009-01-20 17:06:27 +00002010** This routine ends a transaction. A transaction is usually ended by
2011** either a COMMIT or a ROLLBACK operation. This routine may be called
2012** after rollback of a hot-journal, or if an error occurs while opening
2013** the journal file or writing the very first journal-header of a
2014** database transaction.
2015**
dan85d14ed2010-08-06 17:18:00 +00002016** This routine is never called in PAGER_ERROR state. If it is called
2017** in PAGER_NONE or PAGER_SHARED state and the lock held is less
2018** exclusive than a RESERVED lock, it is a no-op.
drh80e35f42007-03-30 14:06:34 +00002019**
danielk1977bea2a942009-01-20 17:06:27 +00002020** Otherwise, any active savepoints are released.
drh80e35f42007-03-30 14:06:34 +00002021**
danielk1977bea2a942009-01-20 17:06:27 +00002022** If the journal file is open, then it is "finalized". Once a journal
2023** file has been finalized it is not possible to use it to roll back a
2024** transaction. Nor will it be considered to be a hot-journal by this
2025** or any other database connection. Exactly how a journal is finalized
2026** depends on whether or not the pager is running in exclusive mode and
2027** the current journal-mode (Pager.journalMode value), as follows:
drh50457892003-09-06 01:10:47 +00002028**
danielk1977bea2a942009-01-20 17:06:27 +00002029** journalMode==MEMORY
2030** Journal file descriptor is simply closed. This destroys an
2031** in-memory journal.
2032**
2033** journalMode==TRUNCATE
2034** Journal file is truncated to zero bytes in size.
2035**
2036** journalMode==PERSIST
2037** The first 28 bytes of the journal file are zeroed. This invalidates
2038** the first journal header in the file, and hence the entire journal
2039** file. An invalid journal file cannot be rolled back.
2040**
2041** journalMode==DELETE
2042** The journal file is closed and deleted using sqlite3OsDelete().
2043**
2044** If the pager is running in exclusive mode, this method of finalizing
2045** the journal file is never used. Instead, if the journalMode is
2046** DELETE and the pager is in exclusive mode, the method described under
2047** journalMode==PERSIST is used instead.
2048**
dan85d14ed2010-08-06 17:18:00 +00002049** After the journal is finalized, the pager moves to PAGER_READER state.
2050** If running in non-exclusive rollback mode, the lock on the file is
2051** downgraded to a SHARED_LOCK.
danielk1977bea2a942009-01-20 17:06:27 +00002052**
2053** SQLITE_OK is returned if no error occurs. If an error occurs during
2054** any of the IO operations to finalize the journal file or unlock the
2055** database then the IO error code is returned to the user. If the
2056** operation to finalize the journal file fails, then the code still
2057** tries to unlock the database file if not in exclusive mode. If the
2058** unlock operation fails as well, then the first error code related
2059** to the first error encountered (the journal finalization one) is
2060** returned.
drhed7c8552001-04-11 14:29:21 +00002061*/
drh067b92b2020-06-19 15:24:12 +00002062static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){
danielk1977bea2a942009-01-20 17:06:27 +00002063 int rc = SQLITE_OK; /* Error code from journal finalization operation */
2064 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
2065
dan85d14ed2010-08-06 17:18:00 +00002066 /* Do nothing if the pager does not have an open write transaction
2067 ** or at least a RESERVED lock. This function may be called when there
2068 ** is no write-transaction active but a RESERVED or greater lock is
2069 ** held under two circumstances:
2070 **
2071 ** 1. After a successful hot-journal rollback, it is called with
2072 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
2073 **
2074 ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
2075 ** lock switches back to locking_mode=normal and then executes a
2076 ** read-transaction, this function is called with eState==PAGER_READER
2077 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
2078 */
dand0864082010-08-02 14:32:52 +00002079 assert( assert_pager_state(pPager) );
dana42c66b2010-08-03 18:18:41 +00002080 assert( pPager->eState!=PAGER_ERROR );
dande1ae342010-08-06 12:00:27 +00002081 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
drha6abd042004-06-09 17:37:22 +00002082 return SQLITE_OK;
2083 }
danielk1977bea2a942009-01-20 17:06:27 +00002084
dand0864082010-08-02 14:32:52 +00002085 releaseAllSavepoints(pPager);
danefe16972017-07-20 19:49:14 +00002086 assert( isOpen(pPager->jfd) || pPager->pInJournal==0
2087 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
2088 );
danielk1977bea2a942009-01-20 17:06:27 +00002089 if( isOpen(pPager->jfd) ){
drh7ed91f22010-04-29 22:34:07 +00002090 assert( !pagerUseWal(pPager) );
danielk1977bea2a942009-01-20 17:06:27 +00002091
danielk1977bea2a942009-01-20 17:06:27 +00002092 /* Finalize the journal file. */
dan2491de22016-02-27 20:14:55 +00002093 if( sqlite3JournalIsInMemory(pPager->jfd) ){
2094 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
danielk1977b3175382008-10-17 18:51:52 +00002095 sqlite3OsClose(pPager->jfd);
drh9e7ba7c2009-02-04 19:16:23 +00002096 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
drh59813952009-04-20 11:34:26 +00002097 if( pPager->journalOff==0 ){
2098 rc = SQLITE_OK;
2099 }else{
2100 rc = sqlite3OsTruncate(pPager->jfd, 0);
drh442c5cd2014-10-21 21:56:06 +00002101 if( rc==SQLITE_OK && pPager->fullSync ){
2102 /* Make sure the new file size is written into the inode right away.
2103 ** Otherwise the journal might resurrect following a power loss and
2104 ** cause the last transaction to roll back. See
2105 ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
2106 */
2107 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
2108 }
drh59813952009-04-20 11:34:26 +00002109 }
drh04335882008-09-26 21:08:08 +00002110 pPager->journalOff = 0;
dan55437592010-05-11 12:19:26 +00002111 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
2112 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
danielk197793f7af92008-05-09 16:57:50 +00002113 ){
drh067b92b2020-06-19 15:24:12 +00002114 rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile);
danielk197741483462007-03-24 16:45:04 +00002115 pPager->journalOff = 0;
2116 }else{
danielk1977ded6d0f2009-07-27 14:15:44 +00002117 /* This branch may be executed with Pager.journalMode==MEMORY if
2118 ** a hot-journal was just rolled back. In this case the journal
2119 ** file should be closed and deleted. If this connection writes to
dan5f37ed52016-02-29 20:00:13 +00002120 ** the database file, it will do so using an in-memory journal.
dane04dc882010-04-20 18:53:15 +00002121 */
dan5f37ed52016-02-29 20:00:13 +00002122 int bDelete = !pPager->tempFile;
2123 assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
danielk1977ded6d0f2009-07-27 14:15:44 +00002124 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
2125 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
dane04dc882010-04-20 18:53:15 +00002126 || pPager->journalMode==PAGER_JOURNALMODE_WAL
danielk1977ded6d0f2009-07-27 14:15:44 +00002127 );
danielk1977b4b47412007-08-17 15:53:36 +00002128 sqlite3OsClose(pPager->jfd);
dan3de0f182012-12-05 10:01:35 +00002129 if( bDelete ){
drh6841b1c2016-02-03 19:20:15 +00002130 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
danielk19777152de82007-03-29 17:28:14 +00002131 }
danielk197741483462007-03-24 16:45:04 +00002132 }
dan5f848c32010-08-23 18:19:31 +00002133 }
danielk1977bea2a942009-01-20 17:06:27 +00002134
danielk19773c407372005-02-15 02:54:14 +00002135#ifdef SQLITE_CHECK_PAGES
dan5f848c32010-08-23 18:19:31 +00002136 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
2137 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
drhc1378072014-08-25 11:33:41 +00002138 PgHdr *p = sqlite3PagerLookup(pPager, 1);
dan5f848c32010-08-23 18:19:31 +00002139 if( p ){
2140 p->pageHash = 0;
drhda8a3302013-12-13 19:35:21 +00002141 sqlite3PagerUnrefNotNull(p);
dan5f848c32010-08-23 18:19:31 +00002142 }
drhd9b02572001-04-15 00:37:09 +00002143 }
dan5f848c32010-08-23 18:19:31 +00002144#endif
2145
dan773d2d62015-07-29 12:14:28 +00002146 pagerFreeBitvecs(pPager);
drhe9c2d342010-03-19 16:52:53 +00002147 pPager->nRec = 0;
drha37e0cf2016-05-11 12:47:46 +00002148 if( rc==SQLITE_OK ){
drh65e1ba32016-11-17 21:52:08 +00002149 if( MEMDB || pagerFlushOnCommit(pPager, bCommit) ){
drha37e0cf2016-05-11 12:47:46 +00002150 sqlite3PcacheCleanAll(pPager->pPCache);
2151 }else{
2152 sqlite3PcacheClearWritable(pPager->pPCache);
2153 }
2154 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
dan41113b62016-04-05 21:07:58 +00002155 }
danielk1977979f38e2007-03-27 16:19:51 +00002156
drh7ed91f22010-04-29 22:34:07 +00002157 if( pagerUseWal(pPager) ){
dand0864082010-08-02 14:32:52 +00002158 /* Drop the WAL write-lock, if any. Also, if the connection was in
2159 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
2160 ** lock held on the database file.
2161 */
drh73b64e42010-05-30 19:55:15 +00002162 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
drh0350c7f2010-06-10 01:07:42 +00002163 assert( rc2==SQLITE_OK );
danbc1a3c62013-02-23 16:40:46 +00002164 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
2165 /* This branch is taken when committing a transaction in rollback-journal
2166 ** mode if the database file on disk is larger than the database image.
2167 ** At this point the journal has been finalized and the transaction
2168 ** successfully committed, but the EXCLUSIVE lock is still held on the
2169 ** file. So it is safe to truncate the database file to its minimum
2170 ** required size. */
2171 assert( pPager->eLock==EXCLUSIVE_LOCK );
2172 rc = pager_truncate(pPager, pPager->dbSize);
dan431b0b42010-08-04 19:14:22 +00002173 }
danbc1a3c62013-02-23 16:40:46 +00002174
drhafb39a42018-03-29 13:47:01 +00002175 if( rc==SQLITE_OK && bCommit ){
dan999cd082013-12-09 20:42:03 +00002176 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
2177 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
2178 }
2179
dan431b0b42010-08-04 19:14:22 +00002180 if( !pPager->exclusiveMode
2181 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
2182 ){
dan4e004aa2010-08-05 15:30:22 +00002183 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
danielk197741483462007-03-24 16:45:04 +00002184 }
dand0864082010-08-02 14:32:52 +00002185 pPager->eState = PAGER_READER;
drh067b92b2020-06-19 15:24:12 +00002186 pPager->setSuper = 0;
danielk1977979f38e2007-03-27 16:19:51 +00002187
2188 return (rc==SQLITE_OK?rc2:rc);
drhed7c8552001-04-11 14:29:21 +00002189}
2190
drhed7c8552001-04-11 14:29:21 +00002191/*
dand0864082010-08-02 14:32:52 +00002192** Execute a rollback if a transaction is active and unlock the
2193** database file.
2194**
dan85d14ed2010-08-06 17:18:00 +00002195** If the pager has already entered the ERROR state, do not attempt
dand0864082010-08-02 14:32:52 +00002196** the rollback at this time. Instead, pager_unlock() is called. The
2197** call to pager_unlock() will discard all in-memory pages, unlock
dan85d14ed2010-08-06 17:18:00 +00002198** the database file and move the pager back to OPEN state. If this
2199** means that there is a hot-journal left in the file-system, the next
2200** connection to obtain a shared lock on the pager (which may be this one)
2201** will roll it back.
dand0864082010-08-02 14:32:52 +00002202**
dan85d14ed2010-08-06 17:18:00 +00002203** If the pager has not already entered the ERROR state, but an IO or
dand0864082010-08-02 14:32:52 +00002204** malloc error occurs during a rollback, then this will itself cause
dan85d14ed2010-08-06 17:18:00 +00002205** the pager to enter the ERROR state. Which will be cleared by the
dand0864082010-08-02 14:32:52 +00002206** call to pager_unlock(), as described above.
2207*/
2208static void pagerUnlockAndRollback(Pager *pPager){
dande1ae342010-08-06 12:00:27 +00002209 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
dana42c66b2010-08-03 18:18:41 +00002210 assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +00002211 if( pPager->eState>=PAGER_WRITER_LOCKED ){
dand0864082010-08-02 14:32:52 +00002212 sqlite3BeginBenignMalloc();
2213 sqlite3PagerRollback(pPager);
2214 sqlite3EndBenignMalloc();
dan85d14ed2010-08-06 17:18:00 +00002215 }else if( !pPager->exclusiveMode ){
dan11f47a92010-08-06 06:54:47 +00002216 assert( pPager->eState==PAGER_READER );
danbc1a3c62013-02-23 16:40:46 +00002217 pager_end_transaction(pPager, 0, 0);
dand0864082010-08-02 14:32:52 +00002218 }
2219 }
2220 pager_unlock(pPager);
2221}
2222
2223/*
danielk1977bea2a942009-01-20 17:06:27 +00002224** Parameter aData must point to a buffer of pPager->pageSize bytes
2225** of data. Compute and return a checksum based ont the contents of the
2226** page of data and the current value of pPager->cksumInit.
drh34e79ce2004-02-08 06:05:46 +00002227**
danielk1977bea2a942009-01-20 17:06:27 +00002228** This is not a real checksum. It is really just the sum of the
2229** random initial value (pPager->cksumInit) and every 200th byte
2230** of the page data, starting with byte offset (pPager->pageSize%200).
2231** Each byte is interpreted as an 8-bit unsigned integer.
drh726de592004-06-10 23:35:50 +00002232**
danielk1977bea2a942009-01-20 17:06:27 +00002233** Changing the formula used to compute this checksum results in an
2234** incompatible journal file format.
2235**
2236** If journal corruption occurs due to a power failure, the most likely
2237** scenario is that one end or the other of the record will be changed.
2238** It is much less likely that the two ends of the journal record will be
drh726de592004-06-10 23:35:50 +00002239** correct and the middle be corrupt. Thus, this "checksum" scheme,
2240** though fast and simple, catches the mostly likely kind of corruption.
drh968af522003-02-11 14:55:40 +00002241*/
drh74161702006-02-24 02:53:49 +00002242static u32 pager_cksum(Pager *pPager, const u8 *aData){
danielk1977bea2a942009-01-20 17:06:27 +00002243 u32 cksum = pPager->cksumInit; /* Checksum value to return */
2244 int i = pPager->pageSize-200; /* Loop counter */
danielk1977ef317ab2004-06-23 10:43:10 +00002245 while( i>0 ){
2246 cksum += aData[i];
2247 i -= 200;
2248 }
drh968af522003-02-11 14:55:40 +00002249 return cksum;
2250}
2251
2252/*
drhd6e5e092009-01-07 02:03:35 +00002253** Read a single page from either the journal file (if isMainJrnl==1) or
2254** from the sub-journal (if isMainJrnl==0) and playback that page.
danielk1977bea2a942009-01-20 17:06:27 +00002255** The page begins at offset *pOffset into the file. The *pOffset
drhd6e5e092009-01-07 02:03:35 +00002256** value is increased to the start of the next page in the journal.
drh968af522003-02-11 14:55:40 +00002257**
dan85d14ed2010-08-06 17:18:00 +00002258** The main rollback journal uses checksums - the statement journal does
2259** not.
drhd6e5e092009-01-07 02:03:35 +00002260**
danielk1977bea2a942009-01-20 17:06:27 +00002261** If the page number of the page record read from the (sub-)journal file
2262** is greater than the current value of Pager.dbSize, then playback is
2263** skipped and SQLITE_OK is returned.
2264**
drhd6e5e092009-01-07 02:03:35 +00002265** If pDone is not NULL, then it is a record of pages that have already
2266** been played back. If the page at *pOffset has already been played back
2267** (if the corresponding pDone bit is set) then skip the playback.
2268** Make sure the pDone bit corresponding to the *pOffset page is set
2269** prior to returning.
danielk1977bea2a942009-01-20 17:06:27 +00002270**
2271** If the page record is successfully read from the (sub-)journal file
2272** and played back, then SQLITE_OK is returned. If an IO error occurs
2273** while reading the record from the (sub-)journal file or while writing
2274** to the database file, then the IO error code is returned. If data
2275** is successfully read from the (sub-)journal file but appears to be
2276** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
2277** two circumstances:
2278**
drh584bfca2022-02-23 17:00:44 +00002279** * If the record page-number is illegal (0 or PAGER_SJ_PGNO), or
danielk1977bea2a942009-01-20 17:06:27 +00002280** * If the record is being rolled back from the main journal file
2281** and the checksum field does not match the record content.
2282**
2283** Neither of these two scenarios are possible during a savepoint rollback.
2284**
2285** If this is a savepoint rollback, then memory may have to be dynamically
2286** allocated by this function. If this is the case and an allocation fails,
2287** SQLITE_NOMEM is returned.
drhfa86c412002-02-02 15:01:15 +00002288*/
danielk197762079062007-08-15 17:08:46 +00002289static int pager_playback_one_page(
danielk1977fd7f0452008-12-17 17:30:26 +00002290 Pager *pPager, /* The pager being played back */
drhd6e5e092009-01-07 02:03:35 +00002291 i64 *pOffset, /* Offset of record to playback */
drh91781bd2010-04-10 17:52:57 +00002292 Bitvec *pDone, /* Bitvec of pages already played back */
2293 int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
2294 int isSavepnt /* True for a savepoint rollback */
danielk197762079062007-08-15 17:08:46 +00002295){
drhfa86c412002-02-02 15:01:15 +00002296 int rc;
drhae2b40c2004-06-09 19:03:54 +00002297 PgHdr *pPg; /* An existing page in the cache */
2298 Pgno pgno; /* The page number of a page in journal */
2299 u32 cksum; /* Checksum used for sanity checking */
drhbfcb4ad2009-11-21 01:33:50 +00002300 char *aData; /* Temporary storage for the page */
drhd6e5e092009-01-07 02:03:35 +00002301 sqlite3_file *jfd; /* The file descriptor for the journal file */
drh91781bd2010-04-10 17:52:57 +00002302 int isSynced; /* True if journal page is synced */
drhfa86c412002-02-02 15:01:15 +00002303
drhd6e5e092009-01-07 02:03:35 +00002304 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
2305 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
2306 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
2307 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
drh96362842005-03-20 22:47:56 +00002308
drhbfcb4ad2009-11-21 01:33:50 +00002309 aData = pPager->pTmpSpace;
drhd6e5e092009-01-07 02:03:35 +00002310 assert( aData ); /* Temp storage must have already been allocated */
drh7ed91f22010-04-29 22:34:07 +00002311 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
drhd6e5e092009-01-07 02:03:35 +00002312
dan85d14ed2010-08-06 17:18:00 +00002313 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
2314 ** or savepoint rollback done at the request of the caller) or this is
2315 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
2316 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
2317 ** only reads from the main journal, not the sub-journal.
2318 */
2319 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
2320 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
2321 );
2322 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
2323
danielk1977bea2a942009-01-20 17:06:27 +00002324 /* Read the page number and page data from the journal or sub-journal
2325 ** file. Return an error code to the caller if an IO error occurs.
2326 */
drhd6e5e092009-01-07 02:03:35 +00002327 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
drhd6e5e092009-01-07 02:03:35 +00002328 rc = read32bits(jfd, *pOffset, &pgno);
drh99ee3602003-02-16 19:13:36 +00002329 if( rc!=SQLITE_OK ) return rc;
drhbfcb4ad2009-11-21 01:33:50 +00002330 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
drh99ee3602003-02-16 19:13:36 +00002331 if( rc!=SQLITE_OK ) return rc;
drhd6e5e092009-01-07 02:03:35 +00002332 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
drhfa86c412002-02-02 15:01:15 +00002333
drh968af522003-02-11 14:55:40 +00002334 /* Sanity checking on the page. This is more important that I originally
2335 ** thought. If a power failure occurs while the journal is being written,
2336 ** it could cause invalid data to be written into the journal. We need to
2337 ** detect this invalid data (with high probability) and ignore it.
2338 */
drh584bfca2022-02-23 17:00:44 +00002339 if( pgno==0 || pgno==PAGER_SJ_PGNO(pPager) ){
danielk1977bea2a942009-01-20 17:06:27 +00002340 assert( !isSavepnt );
drh968af522003-02-11 14:55:40 +00002341 return SQLITE_DONE;
2342 }
danielk1977fd7f0452008-12-17 17:30:26 +00002343 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
drh968af522003-02-11 14:55:40 +00002344 return SQLITE_OK;
2345 }
drhc13148f2008-08-27 18:03:20 +00002346 if( isMainJrnl ){
drhd6e5e092009-01-07 02:03:35 +00002347 rc = read32bits(jfd, (*pOffset)-4, &cksum);
drh99ee3602003-02-16 19:13:36 +00002348 if( rc ) return rc;
drhbfcb4ad2009-11-21 01:33:50 +00002349 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
drh968af522003-02-11 14:55:40 +00002350 return SQLITE_DONE;
2351 }
2352 }
danielk1977bea2a942009-01-20 17:06:27 +00002353
drhb3475532015-06-29 20:53:18 +00002354 /* If this page has already been played back before during the current
drh8220da72010-07-05 17:43:32 +00002355 ** rollback, then don't bother to play it back again.
2356 */
danielk1977859546c2009-01-22 17:12:39 +00002357 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
danielk1977fd7f0452008-12-17 17:30:26 +00002358 return rc;
2359 }
danielk1977a3f3a5f2004-06-10 04:32:16 +00002360
drh8220da72010-07-05 17:43:32 +00002361 /* When playing back page 1, restore the nReserve setting
2362 */
2363 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
2364 pPager->nReserve = ((u8*)aData)[20];
drh8220da72010-07-05 17:43:32 +00002365 }
2366
dande5fd222010-08-09 19:17:29 +00002367 /* If the pager is in CACHEMOD state, then there must be a copy of this
danielk1977a3f3a5f2004-06-10 04:32:16 +00002368 ** page in the pager cache. In this case just update the pager cache,
danielk19770de0bb32004-06-10 05:59:24 +00002369 ** not the database file. The page is left marked dirty in this case.
2370 **
danielk19772df71c72007-05-24 07:22:42 +00002371 ** An exception to the above rule: If the database is in no-sync mode
2372 ** and a page is moved during an incremental vacuum then the page may
danielk1977369f3a02007-05-24 09:41:20 +00002373 ** not be in the pager cache. Later: if a malloc() or IO error occurs
2374 ** during a Movepage() call, then the page may not be in the cache
2375 ** either. So the condition described in the above paragraph is not
2376 ** assert()able.
danielk19772df71c72007-05-24 07:22:42 +00002377 **
dande5fd222010-08-09 19:17:29 +00002378 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
2379 ** pager cache if it exists and the main file. The page is then marked
2380 ** not dirty. Since this code is only executed in PAGER_OPEN state for
2381 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
2382 ** if the pager is in OPEN state.
drh96362842005-03-20 22:47:56 +00002383 **
2384 ** Ticket #1171: The statement journal might contain page content that is
2385 ** different from the page content at the start of the transaction.
2386 ** This occurs when a page is changed prior to the start of a statement
2387 ** then changed again within the statement. When rolling back such a
2388 ** statement we must not write to the original database unless we know
drh5e385312007-06-16 04:42:12 +00002389 ** for certain that original page contents are synced into the main rollback
2390 ** journal. Otherwise, a power loss might leave modified data in the
2391 ** database file without an entry in the rollback journal that can
2392 ** restore the database to its original form. Two conditions must be
2393 ** met before writing to the database files. (1) the database must be
2394 ** locked. (2) we know that the original page content is fully synced
2395 ** in the main journal either because the page is not in cache or else
2396 ** the page is marked as needSync==0.
drh4c02a232008-04-14 23:13:45 +00002397 **
2398 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
2399 ** is possible to fail a statement on a database that does not yet exist.
2400 ** Do not attempt to write if database file has never been opened.
drhfa86c412002-02-02 15:01:15 +00002401 */
drh7ed91f22010-04-29 22:34:07 +00002402 if( pagerUseWal(pPager) ){
dan4cd78b42010-04-26 16:57:10 +00002403 pPg = 0;
2404 }else{
drhc1378072014-08-25 11:33:41 +00002405 pPg = sqlite3PagerLookup(pPager, pgno);
dan4cd78b42010-04-26 16:57:10 +00002406 }
drh86655a12009-03-31 02:54:40 +00002407 assert( pPg || !MEMDB );
dan6572c162016-04-23 14:55:28 +00002408 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
drh30d53702009-01-06 15:58:57 +00002409 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
drhbfcb4ad2009-11-21 01:33:50 +00002410 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
2411 (isMainJrnl?"main-journal":"sub-journal")
drh30d53702009-01-06 15:58:57 +00002412 ));
drh91781bd2010-04-10 17:52:57 +00002413 if( isMainJrnl ){
2414 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
2415 }else{
2416 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
2417 }
drh719e3a72010-08-17 17:25:15 +00002418 if( isOpen(pPager->fd)
2419 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
drh91781bd2010-04-10 17:52:57 +00002420 && isSynced
danielk19778c0a7912008-08-20 14:49:23 +00002421 ){
drh281b21d2008-08-22 12:57:08 +00002422 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
drh05f69dd2010-04-09 15:34:06 +00002423 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
drh7ed91f22010-04-29 22:34:07 +00002424 assert( !pagerUseWal(pPager) );
dan2617c9b2017-05-08 18:29:36 +00002425
2426 /* Write the data read from the journal back into the database file.
2427 ** This is usually safe even for an encrypted database - as the data
2428 ** was encrypted before it was written to the journal file. The exception
2429 ** is if the data was just read from an in-memory sub-journal. In that
2430 ** case it must be encrypted here before it is copied into the database
2431 ** file. */
danf23da962013-03-23 21:00:41 +00002432 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
dan2617c9b2017-05-08 18:29:36 +00002433
danielk19773460d192008-12-27 15:23:13 +00002434 if( pgno>pPager->dbFileSize ){
2435 pPager->dbFileSize = pgno;
2436 }
drh0719ee22009-06-18 20:52:47 +00002437 if( pPager->pBackup ){
drhbfcb4ad2009-11-21 01:33:50 +00002438 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
drh0719ee22009-06-18 20:52:47 +00002439 }
danielk1977f2c31ad2009-01-06 13:40:08 +00002440 }else if( !isMainJrnl && pPg==0 ){
2441 /* If this is a rollback of a savepoint and data was not written to
2442 ** the database and the page is not in-memory, there is a potential
2443 ** problem. When the page is next fetched by the b-tree layer, it
2444 ** will be read from the database file, which may or may not be
2445 ** current.
2446 **
2447 ** There are a couple of different ways this can happen. All are quite
danielk1977401b65e2009-01-06 14:34:34 +00002448 ** obscure. When running in synchronous mode, this can only happen
danielk1977f2c31ad2009-01-06 13:40:08 +00002449 ** if the page is on the free-list at the start of the transaction, then
2450 ** populated, then moved using sqlite3PagerMovepage().
2451 **
2452 ** The solution is to add an in-memory page to the cache containing
2453 ** the data just read from the sub-journal. Mark the page as dirty
2454 ** and if the pager requires a journal-sync, then mark the page as
2455 ** requiring a journal-sync before it is written.
2456 */
2457 assert( isSavepnt );
drh40c39412013-08-16 20:42:20 +00002458 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
2459 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
drh9584f582015-11-04 20:22:37 +00002460 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
drh40c39412013-08-16 20:42:20 +00002461 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
2462 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
drh7cf4c7a2010-06-24 14:52:25 +00002463 if( rc!=SQLITE_OK ) return rc;
danielk1977f2c31ad2009-01-06 13:40:08 +00002464 sqlite3PcacheMakeDirty(pPg);
danielk1977a3f3a5f2004-06-10 04:32:16 +00002465 }
drhfa86c412002-02-02 15:01:15 +00002466 if( pPg ){
danielk197728129562005-01-11 10:25:06 +00002467 /* No page should ever be explicitly rolled back that is in use, except
2468 ** for page 1 which is held in use in order to keep the lock on the
2469 ** database active. However such a page may be rolled back as a result
2470 ** of an internal error resulting in an automatic call to
danielk19773b8a05f2007-03-19 17:44:26 +00002471 ** sqlite3PagerRollback().
drhacf4ac92003-12-17 23:57:34 +00002472 */
drhb6f41482004-05-14 01:58:11 +00002473 void *pData;
danielk19778c0a7912008-08-20 14:49:23 +00002474 pData = pPg->pData;
drhbfcb4ad2009-11-21 01:33:50 +00002475 memcpy(pData, (u8*)aData, pPager->pageSize);
drh4775ecd2009-07-24 19:01:19 +00002476 pPager->xReiniter(pPg);
drh42bee5f2016-05-12 12:01:20 +00002477 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
2478 ** that call was dangerous and had no detectable benefit since the cache
2479 ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so
2480 ** has been removed. */
dan5f848c32010-08-23 18:19:31 +00002481 pager_set_pagehash(pPg);
2482
drh86a88112007-04-16 15:02:19 +00002483 /* If this was page 1, then restore the value of Pager.dbFileVers.
2484 ** Do this before any decoding. */
danielk197741483462007-03-24 16:45:04 +00002485 if( pgno==1 ){
drh86a88112007-04-16 15:02:19 +00002486 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
danielk197741483462007-03-24 16:45:04 +00002487 }
danielk19778c0a7912008-08-20 14:49:23 +00002488 sqlite3PcacheRelease(pPg);
drhfa86c412002-02-02 15:01:15 +00002489 }
2490 return rc;
2491}
2492
2493/*
drh067b92b2020-06-19 15:24:12 +00002494** Parameter zSuper is the name of a super-journal file. A single journal
2495** file that referred to the super-journal file has just been rolled back.
2496** This routine checks if it is possible to delete the super-journal file,
danielk197713adf8a2004-06-03 16:08:41 +00002497** and does so if it is.
drh726de592004-06-10 23:35:50 +00002498**
drh067b92b2020-06-19 15:24:12 +00002499** Argument zSuper may point to Pager.pTmpSpace. So that buffer is not
danielk197765839c62007-08-30 08:08:17 +00002500** available for use within this function.
2501**
drh067b92b2020-06-19 15:24:12 +00002502** When a super-journal file is created, it is populated with the names
danielk1977bea2a942009-01-20 17:06:27 +00002503** of all of its child journals, one after another, formatted as utf-8
2504** encoded text. The end of each child journal file is marked with a
drh067b92b2020-06-19 15:24:12 +00002505** nul-terminator byte (0x00). i.e. the entire contents of a super-journal
danielk1977bea2a942009-01-20 17:06:27 +00002506** file for a transaction involving two databases might be:
danielk197765839c62007-08-30 08:08:17 +00002507**
danielk1977bea2a942009-01-20 17:06:27 +00002508** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
2509**
drh067b92b2020-06-19 15:24:12 +00002510** A super-journal file may only be deleted once all of its child
danielk1977bea2a942009-01-20 17:06:27 +00002511** journals have been rolled back.
2512**
drh067b92b2020-06-19 15:24:12 +00002513** This function reads the contents of the super-journal file into
danielk1977bea2a942009-01-20 17:06:27 +00002514** memory and loops through each of the child journal names. For
2515** each child journal, it checks if:
2516**
2517** * if the child journal exists, and if so
drh067b92b2020-06-19 15:24:12 +00002518** * if the child journal contains a reference to super-journal
2519** file zSuper
danielk1977bea2a942009-01-20 17:06:27 +00002520**
2521** If a child journal can be found that matches both of the criteria
2522** above, this function returns without doing anything. Otherwise, if
drh067b92b2020-06-19 15:24:12 +00002523** no such child journal can be found, file zSuper is deleted from
danielk1977bea2a942009-01-20 17:06:27 +00002524** the file-system using sqlite3OsDelete().
2525**
2526** If an IO error within this function, an error code is returned. This
2527** function allocates memory by calling sqlite3Malloc(). If an allocation
2528** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
2529** occur, SQLITE_OK is returned.
2530**
2531** TODO: This function allocates a single block of memory to load
drh067b92b2020-06-19 15:24:12 +00002532** the entire contents of the super-journal file. This could be
danielk1977bea2a942009-01-20 17:06:27 +00002533** a couple of kilobytes or so - potentially larger than the page
2534** size.
danielk197713adf8a2004-06-03 16:08:41 +00002535*/
drh067b92b2020-06-19 15:24:12 +00002536static int pager_delsuper(Pager *pPager, const char *zSuper){
danielk1977b4b47412007-08-17 15:53:36 +00002537 sqlite3_vfs *pVfs = pPager->pVfs;
danielk1977bea2a942009-01-20 17:06:27 +00002538 int rc; /* Return code */
drh067b92b2020-06-19 15:24:12 +00002539 sqlite3_file *pSuper; /* Malloc'd super-journal file descriptor */
danielk1977bea2a942009-01-20 17:06:27 +00002540 sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
drh067b92b2020-06-19 15:24:12 +00002541 char *zSuperJournal = 0; /* Contents of super-journal file */
2542 i64 nSuperJournal; /* Size of super-journal file */
drha64febe2010-06-23 15:04:27 +00002543 char *zJournal; /* Pointer to one journal within MJ file */
drh067b92b2020-06-19 15:24:12 +00002544 char *zSuperPtr; /* Space to hold super-journal filename */
dan2e3cb132020-11-24 16:44:09 +00002545 char *zFree = 0; /* Free this buffer */
drh067b92b2020-06-19 15:24:12 +00002546 int nSuperPtr; /* Amount of space allocated to zSuperPtr[] */
danielk197713adf8a2004-06-03 16:08:41 +00002547
drh067b92b2020-06-19 15:24:12 +00002548 /* Allocate space for both the pJournal and pSuper file descriptors.
2549 ** If successful, open the super-journal file for reading.
danielk197713adf8a2004-06-03 16:08:41 +00002550 */
drh067b92b2020-06-19 15:24:12 +00002551 pSuper = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
drh067b92b2020-06-19 15:24:12 +00002552 if( !pSuper ){
mistachkinfad30392016-02-13 23:43:46 +00002553 rc = SQLITE_NOMEM_BKPT;
drh14d093f2020-08-09 17:58:45 +00002554 pJournal = 0;
danielk1977b4b47412007-08-17 15:53:36 +00002555 }else{
drhccb21132020-06-19 11:34:57 +00002556 const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
drh067b92b2020-06-19 15:24:12 +00002557 rc = sqlite3OsOpen(pVfs, zSuper, pSuper, flags, 0);
drh8afc09d2020-08-08 20:15:16 +00002558 pJournal = (sqlite3_file *)(((u8 *)pSuper) + pVfs->szOsFile);
danielk1977b4b47412007-08-17 15:53:36 +00002559 }
drh067b92b2020-06-19 15:24:12 +00002560 if( rc!=SQLITE_OK ) goto delsuper_out;
danielk1977b4b47412007-08-17 15:53:36 +00002561
drh067b92b2020-06-19 15:24:12 +00002562 /* Load the entire super-journal file into space obtained from
2563 ** sqlite3_malloc() and pointed to by zSuperJournal. Also obtain
2564 ** sufficient space (in zSuperPtr) to hold the names of super-journal
2565 ** files extracted from regular rollback-journals.
drha64febe2010-06-23 15:04:27 +00002566 */
drh067b92b2020-06-19 15:24:12 +00002567 rc = sqlite3OsFileSize(pSuper, &nSuperJournal);
2568 if( rc!=SQLITE_OK ) goto delsuper_out;
2569 nSuperPtr = pVfs->mxPathname+1;
dan2e3cb132020-11-24 16:44:09 +00002570 zFree = sqlite3Malloc(4 + nSuperJournal + nSuperPtr + 2);
danf5c3a752020-11-24 17:55:34 +00002571 if( !zFree ){
mistachkinfad30392016-02-13 23:43:46 +00002572 rc = SQLITE_NOMEM_BKPT;
drh067b92b2020-06-19 15:24:12 +00002573 goto delsuper_out;
drha64febe2010-06-23 15:04:27 +00002574 }
danf5c3a752020-11-24 17:55:34 +00002575 zFree[0] = zFree[1] = zFree[2] = zFree[3] = 0;
2576 zSuperJournal = &zFree[4];
drh067b92b2020-06-19 15:24:12 +00002577 zSuperPtr = &zSuperJournal[nSuperJournal+2];
2578 rc = sqlite3OsRead(pSuper, zSuperJournal, (int)nSuperJournal, 0);
2579 if( rc!=SQLITE_OK ) goto delsuper_out;
2580 zSuperJournal[nSuperJournal] = 0;
2581 zSuperJournal[nSuperJournal+1] = 0;
danielk197713adf8a2004-06-03 16:08:41 +00002582
drh067b92b2020-06-19 15:24:12 +00002583 zJournal = zSuperJournal;
2584 while( (zJournal-zSuperJournal)<nSuperJournal ){
drha64febe2010-06-23 15:04:27 +00002585 int exists;
2586 rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
2587 if( rc!=SQLITE_OK ){
drh067b92b2020-06-19 15:24:12 +00002588 goto delsuper_out;
danielk197713adf8a2004-06-03 16:08:41 +00002589 }
drha64febe2010-06-23 15:04:27 +00002590 if( exists ){
drh067b92b2020-06-19 15:24:12 +00002591 /* One of the journals pointed to by the super-journal exists.
2592 ** Open it and check if it points at the super-journal. If
2593 ** so, return without deleting the super-journal file.
drhab2172e2020-04-24 18:20:30 +00002594 ** NB: zJournal is really a MAIN_JOURNAL. But call it a
drhccb21132020-06-19 11:34:57 +00002595 ** SUPER_JOURNAL here so that the VFS will not send the zJournal
drhab2172e2020-04-24 18:20:30 +00002596 ** name into sqlite3_database_file_object().
drha64febe2010-06-23 15:04:27 +00002597 */
2598 int c;
drhccb21132020-06-19 11:34:57 +00002599 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
drha64febe2010-06-23 15:04:27 +00002600 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
danielk1977861f7452008-06-05 11:39:11 +00002601 if( rc!=SQLITE_OK ){
drh067b92b2020-06-19 15:24:12 +00002602 goto delsuper_out;
drh19db9352008-03-27 22:42:51 +00002603 }
danielk197713adf8a2004-06-03 16:08:41 +00002604
drh067b92b2020-06-19 15:24:12 +00002605 rc = readSuperJournal(pJournal, zSuperPtr, nSuperPtr);
drha64febe2010-06-23 15:04:27 +00002606 sqlite3OsClose(pJournal);
2607 if( rc!=SQLITE_OK ){
drh067b92b2020-06-19 15:24:12 +00002608 goto delsuper_out;
danielk197713adf8a2004-06-03 16:08:41 +00002609 }
drha64febe2010-06-23 15:04:27 +00002610
drh067b92b2020-06-19 15:24:12 +00002611 c = zSuperPtr[0]!=0 && strcmp(zSuperPtr, zSuper)==0;
drha64febe2010-06-23 15:04:27 +00002612 if( c ){
drh067b92b2020-06-19 15:24:12 +00002613 /* We have a match. Do not delete the super-journal file. */
2614 goto delsuper_out;
drha64febe2010-06-23 15:04:27 +00002615 }
danielk197713adf8a2004-06-03 16:08:41 +00002616 }
drha64febe2010-06-23 15:04:27 +00002617 zJournal += (sqlite3Strlen30(zJournal)+1);
danielk197713adf8a2004-06-03 16:08:41 +00002618 }
drhde3c3012010-06-21 20:19:25 +00002619
drh067b92b2020-06-19 15:24:12 +00002620 sqlite3OsClose(pSuper);
2621 rc = sqlite3OsDelete(pVfs, zSuper, 0);
danielk197713adf8a2004-06-03 16:08:41 +00002622
drh067b92b2020-06-19 15:24:12 +00002623delsuper_out:
dan2e3cb132020-11-24 16:44:09 +00002624 sqlite3_free(zFree);
drh067b92b2020-06-19 15:24:12 +00002625 if( pSuper ){
2626 sqlite3OsClose(pSuper);
danielk1977bea2a942009-01-20 17:06:27 +00002627 assert( !isOpen(pJournal) );
drh067b92b2020-06-19 15:24:12 +00002628 sqlite3_free(pSuper);
danielk197713adf8a2004-06-03 16:08:41 +00002629 }
2630 return rc;
2631}
2632
drha6abd042004-06-09 17:37:22 +00002633
drha6abd042004-06-09 17:37:22 +00002634/*
danielk1977bea2a942009-01-20 17:06:27 +00002635** This function is used to change the actual size of the database
2636** file in the file-system. This only happens when committing a transaction,
2637** or rolling back a transaction (including rolling back a hot-journal).
drh7fe3f7e2007-11-29 18:44:27 +00002638**
dande5fd222010-08-09 19:17:29 +00002639** If the main database file is not open, or the pager is not in either
2640** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
2641** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
2642** If the file on disk is currently larger than nPage pages, then use the VFS
danielk1977bea2a942009-01-20 17:06:27 +00002643** xTruncate() method to truncate it.
2644**
peter.d.reid60ec9142014-09-06 16:39:46 +00002645** Or, it might be the case that the file on disk is smaller than
danielk1977bea2a942009-01-20 17:06:27 +00002646** nPage pages. Some operating system implementations can get confused if
2647** you try to truncate a file to some size that is larger than it
2648** currently is, so detect this case and write a single zero byte to
2649** the end of the new file instead.
2650**
2651** If successful, return SQLITE_OK. If an IO error occurs while modifying
2652** the database file, return the error code to the caller.
drhcb4c40b2004-08-18 19:09:43 +00002653*/
danielk1977d92db532008-11-17 04:56:24 +00002654static int pager_truncate(Pager *pPager, Pgno nPage){
danielk1977e180dd92007-04-05 17:15:52 +00002655 int rc = SQLITE_OK;
dana42c66b2010-08-03 18:18:41 +00002656 assert( pPager->eState!=PAGER_ERROR );
dan4e004aa2010-08-05 15:30:22 +00002657 assert( pPager->eState!=PAGER_READER );
2658
2659 if( isOpen(pPager->fd)
dande1ae342010-08-06 12:00:27 +00002660 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
dan4e004aa2010-08-05 15:30:22 +00002661 ){
drh7fe3f7e2007-11-29 18:44:27 +00002662 i64 currentSize, newSize;
drhbd1334d2011-01-28 15:46:14 +00002663 int szPage = pPager->pageSize;
dande5fd222010-08-09 19:17:29 +00002664 assert( pPager->eLock==EXCLUSIVE_LOCK );
danielk1977bea2a942009-01-20 17:06:27 +00002665 /* TODO: Is it safe to use Pager.dbFileSize here? */
drh7fe3f7e2007-11-29 18:44:27 +00002666 rc = sqlite3OsFileSize(pPager->fd, &currentSize);
drhbd1334d2011-01-28 15:46:14 +00002667 newSize = szPage*(i64)nPage;
danielk197706e11af2008-05-06 18:13:26 +00002668 if( rc==SQLITE_OK && currentSize!=newSize ){
2669 if( currentSize>newSize ){
2670 rc = sqlite3OsTruncate(pPager->fd, newSize);
drh935de7e2012-01-11 15:47:42 +00002671 }else if( (currentSize+szPage)<=newSize ){
danfb3828c2011-01-28 15:07:55 +00002672 char *pTmp = pPager->pTmpSpace;
drhbd1334d2011-01-28 15:46:14 +00002673 memset(pTmp, 0, szPage);
drhbd1334d2011-01-28 15:46:14 +00002674 testcase( (newSize-szPage) == currentSize );
2675 testcase( (newSize-szPage) > currentSize );
danbbf71132022-06-14 21:34:13 +00002676 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &newSize);
drhbd1334d2011-01-28 15:46:14 +00002677 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
danielk197706e11af2008-05-06 18:13:26 +00002678 }
danielk19773460d192008-12-27 15:23:13 +00002679 if( rc==SQLITE_OK ){
2680 pPager->dbFileSize = nPage;
2681 }
drh7fe3f7e2007-11-29 18:44:27 +00002682 }
danielk1977e180dd92007-04-05 17:15:52 +00002683 }
danielk1977e180dd92007-04-05 17:15:52 +00002684 return rc;
drhcb4c40b2004-08-18 19:09:43 +00002685}
2686
2687/*
danc9a53262012-10-01 06:50:55 +00002688** Return a sanitized version of the sector-size of OS file pFile. The
2689** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
2690*/
2691int sqlite3SectorSize(sqlite3_file *pFile){
2692 int iRet = sqlite3OsSectorSize(pFile);
2693 if( iRet<32 ){
2694 iRet = 512;
2695 }else if( iRet>MAX_SECTOR_SIZE ){
2696 assert( MAX_SECTOR_SIZE>=512 );
2697 iRet = MAX_SECTOR_SIZE;
2698 }
2699 return iRet;
2700}
2701
2702/*
danielk1977bea2a942009-01-20 17:06:27 +00002703** Set the value of the Pager.sectorSize variable for the given
2704** pager based on the value returned by the xSectorSize method
peter.d.reid60ec9142014-09-06 16:39:46 +00002705** of the open database file. The sector size will be used
danielk1977bea2a942009-01-20 17:06:27 +00002706** to determine the size and alignment of journal header and
drh067b92b2020-06-19 15:24:12 +00002707** super-journal pointers within created journal files.
drhc80f0582007-05-01 16:59:48 +00002708**
danielk1977bea2a942009-01-20 17:06:27 +00002709** For temporary files the effective sector size is always 512 bytes.
2710**
2711** Otherwise, for non-temporary files, the effective sector size is
drh3c99d682009-11-11 13:17:08 +00002712** the value returned by the xSectorSize() method rounded up to 32 if
2713** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
danielk1977bea2a942009-01-20 17:06:27 +00002714** is greater than MAX_SECTOR_SIZE.
drh8bbaa892011-12-17 19:49:02 +00002715**
drhcb15f352011-12-23 01:04:17 +00002716** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
2717** the effective sector size to its minimum value (512). The purpose of
drh8bbaa892011-12-17 19:49:02 +00002718** pPager->sectorSize is to define the "blast radius" of bytes that
2719** might change if a crash occurs while writing to a single byte in
drhcb15f352011-12-23 01:04:17 +00002720** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
2721** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
2722** size. For backwards compatibility of the rollback journal file format,
2723** we cannot reduce the effective sector size below 512.
drhc80f0582007-05-01 16:59:48 +00002724*/
2725static void setSectorSize(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00002726 assert( isOpen(pPager->fd) || pPager->tempFile );
2727
drh374f4a02011-12-17 20:02:11 +00002728 if( pPager->tempFile
drhcb15f352011-12-23 01:04:17 +00002729 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
2730 SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0
drh8bbaa892011-12-17 19:49:02 +00002731 ){
danielk19777a2b1ee2007-08-21 14:27:01 +00002732 /* Sector size doesn't matter for temporary files. Also, the file
danielk1977bea2a942009-01-20 17:06:27 +00002733 ** may not have been opened yet, in which case the OsSectorSize()
drh374f4a02011-12-17 20:02:11 +00002734 ** call will segfault. */
drhae2a3482009-11-11 23:58:06 +00002735 pPager->sectorSize = 512;
drh374f4a02011-12-17 20:02:11 +00002736 }else{
danc9a53262012-10-01 06:50:55 +00002737 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
danielk19777cbd5892009-01-10 16:15:09 +00002738 }
drhc80f0582007-05-01 16:59:48 +00002739}
2740
2741/*
drhed7c8552001-04-11 14:29:21 +00002742** Playback the journal and thus restore the database file to
2743** the state it was in before we started making changes.
2744**
drh34e79ce2004-02-08 06:05:46 +00002745** The journal file format is as follows:
2746**
drhae2b40c2004-06-09 19:03:54 +00002747** (1) 8 byte prefix. A copy of aJournalMagic[].
2748** (2) 4 byte big-endian integer which is the number of valid page records
drh34e79ce2004-02-08 06:05:46 +00002749** in the journal. If this value is 0xffffffff, then compute the
drhae2b40c2004-06-09 19:03:54 +00002750** number of page records from the journal size.
2751** (3) 4 byte big-endian integer which is the initial value for the
2752** sanity checksum.
2753** (4) 4 byte integer which is the number of pages to truncate the
drh34e79ce2004-02-08 06:05:46 +00002754** database to during a rollback.
drh334c80d2008-03-28 17:41:13 +00002755** (5) 4 byte big-endian integer which is the sector size. The header
2756** is this many bytes in size.
drhe7ae4e22009-11-02 15:51:52 +00002757** (6) 4 byte big-endian integer which is the page size.
2758** (7) zero padding out to the next sector size.
2759** (8) Zero or more pages instances, each as follows:
drh34e79ce2004-02-08 06:05:46 +00002760** + 4 byte page number.
drhae2b40c2004-06-09 19:03:54 +00002761** + pPager->pageSize bytes of data.
2762** + 4 byte checksum
drh34e79ce2004-02-08 06:05:46 +00002763**
drhe7ae4e22009-11-02 15:51:52 +00002764** When we speak of the journal header, we mean the first 7 items above.
2765** Each entry in the journal is an instance of the 8th item.
drh34e79ce2004-02-08 06:05:46 +00002766**
2767** Call the value from the second bullet "nRec". nRec is the number of
2768** valid page entries in the journal. In most cases, you can compute the
2769** value of nRec from the size of the journal file. But if a power
2770** failure occurred while the journal was being written, it could be the
2771** case that the size of the journal file had already been increased but
2772** the extra entries had not yet made it safely to disk. In such a case,
2773** the value of nRec computed from the file size would be too large. For
2774** that reason, we always use the nRec value in the header.
2775**
2776** If the nRec value is 0xffffffff it means that nRec should be computed
2777** from the file size. This value is used when the user selects the
2778** no-sync option for the journal. A power failure could lead to corruption
2779** in this case. But for things like temporary table (which will be
2780** deleted when the power is restored) we don't care.
2781**
drhd9b02572001-04-15 00:37:09 +00002782** If the file opened as the journal file is not a well-formed
danielk1977ece80f12004-06-23 01:05:26 +00002783** journal file then all pages up to the first corrupted page are rolled
2784** back (or no pages if the journal header is corrupted). The journal file
2785** is then deleted and SQLITE_OK returned, just as if no corruption had
2786** been encountered.
2787**
2788** If an I/O or malloc() error occurs, the journal-file is not deleted
2789** and an error code is returned.
drhd3a5c502009-02-03 22:51:06 +00002790**
2791** The isHot parameter indicates that we are trying to rollback a journal
2792** that might be a hot journal. Or, it could be that the journal is
2793** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
2794** If the journal really is hot, reset the pager cache prior rolling
2795** back any content. If the journal is merely persistent, no reset is
2796** needed.
drhed7c8552001-04-11 14:29:21 +00002797*/
danielk1977e277be02007-03-23 18:12:06 +00002798static int pager_playback(Pager *pPager, int isHot){
danielk1977b4b47412007-08-17 15:53:36 +00002799 sqlite3_vfs *pVfs = pPager->pVfs;
drheb206252004-10-01 02:00:31 +00002800 i64 szJ; /* Size of the journal file in bytes */
danielk1977c3e8f5e2004-06-28 01:16:46 +00002801 u32 nRec; /* Number of Records in the journal */
shane0b8d2762008-07-22 05:18:00 +00002802 u32 u; /* Unsigned loop counter */
drhd9b02572001-04-15 00:37:09 +00002803 Pgno mxPg = 0; /* Size of the original file in pages */
drhae2b40c2004-06-09 19:03:54 +00002804 int rc; /* Result code of a subroutine */
danielk1977861f7452008-06-05 11:39:11 +00002805 int res = 1; /* Value returned by sqlite3OsAccess() */
drh067b92b2020-06-19 15:24:12 +00002806 char *zSuper = 0; /* Name of super-journal file if any */
drhd3a5c502009-02-03 22:51:06 +00002807 int needPagerReset; /* True to reset page prior to first page rollback */
drhab755ac2013-04-09 18:36:36 +00002808 int nPlayback = 0; /* Total number of pages restored from journal */
drhedea4a72017-09-18 09:40:46 +00002809 u32 savedPageSize = pPager->pageSize;
drhed7c8552001-04-11 14:29:21 +00002810
drhc3a64ba2001-11-22 00:01:27 +00002811 /* Figure out how many records are in the journal. Abort early if
2812 ** the journal is empty.
drhed7c8552001-04-11 14:29:21 +00002813 */
dan22b328b2010-08-11 18:56:45 +00002814 assert( isOpen(pPager->jfd) );
drh054889e2005-11-30 03:20:31 +00002815 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
drh719e3a72010-08-17 17:25:15 +00002816 if( rc!=SQLITE_OK ){
drhc3a64ba2001-11-22 00:01:27 +00002817 goto end_playback;
2818 }
drh240c5792004-02-08 00:40:52 +00002819
drh067b92b2020-06-19 15:24:12 +00002820 /* Read the super-journal name from the journal, if it is present.
2821 ** If a super-journal file name is specified, but the file is not
danielk197776572402004-06-25 02:38:54 +00002822 ** present on disk, then the journal is not hot and does not need to be
2823 ** played back.
danielk1977bea2a942009-01-20 17:06:27 +00002824 **
2825 ** TODO: Technically the following is an error because it assumes that
2826 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2827 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
dan5f37ed52016-02-29 20:00:13 +00002828 ** mxPathname is 512, which is the same as the minimum allowable value
danielk1977bea2a942009-01-20 17:06:27 +00002829 ** for pageSize.
drh240c5792004-02-08 00:40:52 +00002830 */
drh067b92b2020-06-19 15:24:12 +00002831 zSuper = pPager->pTmpSpace;
2832 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
2833 if( rc==SQLITE_OK && zSuper[0] ){
2834 rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res);
drhc3a64ba2001-11-22 00:01:27 +00002835 }
drh067b92b2020-06-19 15:24:12 +00002836 zSuper = 0;
danielk1977861f7452008-06-05 11:39:11 +00002837 if( rc!=SQLITE_OK || !res ){
danielk1977ce98bba2008-04-03 10:13:01 +00002838 goto end_playback;
2839 }
2840 pPager->journalOff = 0;
drhd3a5c502009-02-03 22:51:06 +00002841 needPagerReset = isHot;
drhc3a64ba2001-11-22 00:01:27 +00002842
danielk1977bea2a942009-01-20 17:06:27 +00002843 /* This loop terminates either when a readJournalHdr() or
2844 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2845 ** occurs.
2846 */
danielk197776572402004-06-25 02:38:54 +00002847 while( 1 ){
danielk197776572402004-06-25 02:38:54 +00002848 /* Read the next journal header from the journal file. If there are
2849 ** not enough bytes left in the journal file for a complete header, or
drh719e3a72010-08-17 17:25:15 +00002850 ** it is corrupted, then a process must have failed while writing it.
danielk197776572402004-06-25 02:38:54 +00002851 ** This indicates nothing more needs to be rolled back.
2852 */
danielk19776f4c73e2009-06-26 07:12:06 +00002853 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
danielk197776572402004-06-25 02:38:54 +00002854 if( rc!=SQLITE_OK ){
drh968af522003-02-11 14:55:40 +00002855 if( rc==SQLITE_DONE ){
drh968af522003-02-11 14:55:40 +00002856 rc = SQLITE_OK;
2857 }
danielk197776572402004-06-25 02:38:54 +00002858 goto end_playback;
2859 }
2860
2861 /* If nRec is 0xffffffff, then this journal was created by a process
2862 ** working in no-sync mode. This means that the rest of the journal
2863 ** file consists of pages, there are no more journal headers. Compute
2864 ** the value of nRec based on this assumption.
2865 */
2866 if( nRec==0xffffffff ){
2867 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
drh4f21c4a2008-12-10 22:15:00 +00002868 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
danielk197776572402004-06-25 02:38:54 +00002869 }
2870
danielk1977e277be02007-03-23 18:12:06 +00002871 /* If nRec is 0 and this rollback is of a transaction created by this
drh8940f4e2007-08-11 00:26:20 +00002872 ** process and if this is the final header in the journal, then it means
2873 ** that this part of the journal was being filled but has not yet been
2874 ** synced to disk. Compute the number of pages based on the remaining
2875 ** size of the file.
2876 **
2877 ** The third term of the test was added to fix ticket #2565.
drhd6e5e092009-01-07 02:03:35 +00002878 ** When rolling back a hot journal, nRec==0 always means that the next
2879 ** chunk of the journal contains zero pages to be rolled back. But
2880 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2881 ** the journal, it means that the journal might contain additional
2882 ** pages that need to be rolled back and that the number of pages
drhee03d622009-01-07 15:33:45 +00002883 ** should be computed based on the journal file size.
danielk1977e277be02007-03-23 18:12:06 +00002884 */
drh8940f4e2007-08-11 00:26:20 +00002885 if( nRec==0 && !isHot &&
2886 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
drh4f21c4a2008-12-10 22:15:00 +00002887 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
danielk1977e277be02007-03-23 18:12:06 +00002888 }
2889
danielk197776572402004-06-25 02:38:54 +00002890 /* If this is the first header read from the journal, truncate the
drh85b623f2007-12-13 21:54:09 +00002891 ** database file back to its original size.
danielk197776572402004-06-25 02:38:54 +00002892 */
danielk1977e180dd92007-04-05 17:15:52 +00002893 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
drhcb4c40b2004-08-18 19:09:43 +00002894 rc = pager_truncate(pPager, mxPg);
danielk197776572402004-06-25 02:38:54 +00002895 if( rc!=SQLITE_OK ){
2896 goto end_playback;
2897 }
danielk1977f90b7262009-01-07 15:18:20 +00002898 pPager->dbSize = mxPg;
drh90368c52022-03-01 14:13:32 +00002899 if( pPager->mxPgno<mxPg ){
2900 pPager->mxPgno = mxPg;
2901 }
danielk197776572402004-06-25 02:38:54 +00002902 }
2903
danielk1977bea2a942009-01-20 17:06:27 +00002904 /* Copy original pages out of the journal and back into the
2905 ** database file and/or page cache.
danielk197776572402004-06-25 02:38:54 +00002906 */
shane0b8d2762008-07-22 05:18:00 +00002907 for(u=0; u<nRec; u++){
drhd3a5c502009-02-03 22:51:06 +00002908 if( needPagerReset ){
2909 pager_reset(pPager);
2910 needPagerReset = 0;
2911 }
drh91781bd2010-04-10 17:52:57 +00002912 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
drhab755ac2013-04-09 18:36:36 +00002913 if( rc==SQLITE_OK ){
2914 nPlayback++;
2915 }else{
danielk197776572402004-06-25 02:38:54 +00002916 if( rc==SQLITE_DONE ){
danielk197776572402004-06-25 02:38:54 +00002917 pPager->journalOff = szJ;
2918 break;
drh8d83c0f2010-04-03 13:08:09 +00002919 }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. */
2925 rc = SQLITE_OK;
2926 goto end_playback;
danielk197776572402004-06-25 02:38:54 +00002927 }else{
drh66fd2162009-04-11 16:27:49 +00002928 /* 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.
drha9625ea2008-09-03 00:08:29 +00002932 */
danielk197776572402004-06-25 02:38:54 +00002933 goto end_playback;
2934 }
2935 }
drh968af522003-02-11 14:55:40 +00002936 }
drhed7c8552001-04-11 14:29:21 +00002937 }
drh580eeaf2006-02-24 03:09:37 +00002938 /*NOTREACHED*/
2939 assert( 0 );
drh4a0681e2003-02-13 01:58:20 +00002940
2941end_playback:
drhedea4a72017-09-18 09:40:46 +00002942 if( rc==SQLITE_OK ){
2943 rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1);
2944 }
drh8f941bc2009-01-14 23:03:40 +00002945 /* 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.
2949 */
drhc02372c2012-01-10 17:59:59 +00002950#ifdef SQLITE_DEBUG
drhafb39a42018-03-29 13:47:01 +00002951 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
drhc02372c2012-01-10 17:59:59 +00002952#endif
drh8f941bc2009-01-14 23:03:40 +00002953
danielk1977db340392009-01-16 16:40:14 +00002954 /* If this playback is happening automatically as a result of an IO or
shanebe217792009-03-05 04:20:31 +00002955 ** malloc error that occurred after the change-counter was updated but
danielk1977db340392009-01-16 16:40:14 +00002956 ** before the transaction was committed, then the change-counter
2957 ** modification may just have been reverted. If this happens in exclusive
2958 ** mode, then subsequent transactions performed by the connection will not
2959 ** update the change-counter at all. This may lead to cache inconsistency
2960 ** problems for other processes at some point in the future. So, just
2961 ** in case this has happened, clear the changeCountDone flag now.
2962 */
danielk1977bea2a942009-01-20 17:06:27 +00002963 pPager->changeCountDone = pPager->tempFile;
danielk1977db340392009-01-16 16:40:14 +00002964
danielk19778191bff2004-06-28 04:52:30 +00002965 if( rc==SQLITE_OK ){
dan2e3cb132020-11-24 16:44:09 +00002966 /* Leave 4 bytes of space before the super-journal filename in memory.
2967 ** This is because it may end up being passed to sqlite3OsOpen(), in
2968 ** which case it requires 4 0x00 bytes in memory immediately before
2969 ** the filename. */
2970 zSuper = &pPager->pTmpSpace[4];
drh067b92b2020-06-19 15:24:12 +00002971 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
danielk1977bea2a942009-01-20 17:06:27 +00002972 testcase( rc!=SQLITE_OK );
danielk197765839c62007-08-30 08:08:17 +00002973 }
dan354bfe02011-01-11 17:39:37 +00002974 if( rc==SQLITE_OK
dan7e684232010-08-10 15:46:06 +00002975 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
2976 ){
dan999cd082013-12-09 20:42:03 +00002977 rc = sqlite3PagerSync(pPager, 0);
dan7c246102010-04-12 19:00:29 +00002978 }
danielk197765839c62007-08-30 08:08:17 +00002979 if( rc==SQLITE_OK ){
drh067b92b2020-06-19 15:24:12 +00002980 rc = pager_end_transaction(pPager, zSuper[0]!='\0', 0);
danielk1977bea2a942009-01-20 17:06:27 +00002981 testcase( rc!=SQLITE_OK );
danielk19778191bff2004-06-28 04:52:30 +00002982 }
drh067b92b2020-06-19 15:24:12 +00002983 if( rc==SQLITE_OK && zSuper[0] && res ){
2984 /* If there was a super-journal and this routine will return success,
2985 ** see if it is possible to delete the super-journal.
danielk197713adf8a2004-06-03 16:08:41 +00002986 */
dan2e3cb132020-11-24 16:44:09 +00002987 assert( zSuper==&pPager->pTmpSpace[4] );
drhf6483892023-01-23 21:41:41 +00002988 memset(pPager->pTmpSpace, 0, 4);
drh067b92b2020-06-19 15:24:12 +00002989 rc = pager_delsuper(pPager, zSuper);
danielk1977bea2a942009-01-20 17:06:27 +00002990 testcase( rc!=SQLITE_OK );
danielk197713adf8a2004-06-03 16:08:41 +00002991 }
drhab755ac2013-04-09 18:36:36 +00002992 if( isHot && nPlayback ){
drhd040e762013-04-10 23:48:37 +00002993 sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s",
drhab755ac2013-04-09 18:36:36 +00002994 nPlayback, pPager->zJournal);
2995 }
danielk197776572402004-06-25 02:38:54 +00002996
2997 /* The Pager.sectorSize variable may have been updated while rolling
drh3ceeb752007-03-29 18:19:52 +00002998 ** back a journal created by a process with a different sector size
danielk197776572402004-06-25 02:38:54 +00002999 ** value. Reset it to the correct value for this process.
3000 */
drhc80f0582007-05-01 16:59:48 +00003001 setSectorSize(pPager);
drhd9b02572001-04-15 00:37:09 +00003002 return rc;
drhed7c8552001-04-11 14:29:21 +00003003}
3004
dan7c246102010-04-12 19:00:29 +00003005
3006/*
drh56520ab2017-08-18 21:14:50 +00003007** Read the content for page pPg out of the database file (or out of
3008** the WAL if that is where the most recent copy if found) into
dan7c246102010-04-12 19:00:29 +00003009** pPg->pData. A shared lock or greater must be held on the database
3010** file before this function is called.
3011**
3012** If page 1 is read, then the value of Pager.dbFileVers[] is set to
3013** the value read from the database file.
3014**
3015** If an IO error occurs, then the IO error is returned to the caller.
3016** Otherwise, SQLITE_OK is returned.
3017*/
drh56520ab2017-08-18 21:14:50 +00003018static int readDbPage(PgHdr *pPg){
dan7c246102010-04-12 19:00:29 +00003019 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
drh622194c2010-04-13 15:30:53 +00003020 int rc = SQLITE_OK; /* Return code */
dan5f54e2b2017-10-05 20:02:49 +00003021
3022#ifndef SQLITE_OMIT_WAL
drh56520ab2017-08-18 21:14:50 +00003023 u32 iFrame = 0; /* Frame of WAL containing pgno */
dan7c246102010-04-12 19:00:29 +00003024
dand0864082010-08-02 14:32:52 +00003025 assert( pPager->eState>=PAGER_READER && !MEMDB );
dan7c246102010-04-12 19:00:29 +00003026 assert( isOpen(pPager->fd) );
3027
drh56520ab2017-08-18 21:14:50 +00003028 if( pagerUseWal(pPager) ){
drh251866d2017-08-18 22:30:20 +00003029 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
drh56520ab2017-08-18 21:14:50 +00003030 if( rc ) return rc;
3031 }
dan99bd1092013-03-22 18:20:14 +00003032 if( iFrame ){
drh251866d2017-08-18 22:30:20 +00003033 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
dan5f54e2b2017-10-05 20:02:49 +00003034 }else
3035#endif
3036 {
drh251866d2017-08-18 22:30:20 +00003037 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
3038 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
danf23da962013-03-23 21:00:41 +00003039 if( rc==SQLITE_IOERR_SHORT_READ ){
3040 rc = SQLITE_OK;
dan7c246102010-04-12 19:00:29 +00003041 }
3042 }
3043
drh251866d2017-08-18 22:30:20 +00003044 if( pPg->pgno==1 ){
dan7c246102010-04-12 19:00:29 +00003045 if( rc ){
3046 /* If the read is unsuccessful, set the dbFileVers[] to something
3047 ** that will never be a valid file version. dbFileVers[] is a copy
3048 ** of bytes 24..39 of the database. Bytes 28..31 should always be
drhb28e59b2010-06-17 02:13:39 +00003049 ** zero or the size of the database in page. Bytes 32..35 and 35..39
3050 ** should be page numbers which are never 0xffffffff. So filling
3051 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
dan7c246102010-04-12 19:00:29 +00003052 **
3053 ** For an encrypted database, the situation is more complex: bytes
3054 ** 24..39 of the database are white noise. But the probability of
drh113762a2014-11-19 16:36:25 +00003055 ** white noise equaling 16 bytes of 0xff is vanishingly small so
dan7c246102010-04-12 19:00:29 +00003056 ** we should still be ok.
3057 */
3058 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
3059 }else{
3060 u8 *dbFileVers = &((u8*)pPg->pData)[24];
3061 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
3062 }
3063 }
dan7c246102010-04-12 19:00:29 +00003064 PAGER_INCR(sqlite3_pager_readdb_count);
3065 PAGER_INCR(pPager->nRead);
drh251866d2017-08-18 22:30:20 +00003066 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
dan7c246102010-04-12 19:00:29 +00003067 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
drh251866d2017-08-18 22:30:20 +00003068 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
dan7c246102010-04-12 19:00:29 +00003069
3070 return rc;
3071}
3072
dan6d311fb2011-02-01 18:00:43 +00003073/*
3074** Update the value of the change-counter at offsets 24 and 92 in
3075** the header and the sqlite version number at offset 96.
3076**
3077** This is an unconditional update. See also the pager_incr_changecounter()
3078** routine which only updates the change-counter if the update is actually
3079** needed, as determined by the pPager->changeCountDone state variable.
3080*/
3081static void pager_write_changecounter(PgHdr *pPg){
3082 u32 change_counter;
drhaa6fe5b2021-10-04 13:18:44 +00003083 if( NEVER(pPg==0) ) return;
dan6d311fb2011-02-01 18:00:43 +00003084
3085 /* Increment the value just read and write it back to byte 24. */
3086 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
3087 put32bits(((char*)pPg->pData)+24, change_counter);
3088
3089 /* Also store the SQLite version number in bytes 96..99 and in
3090 ** bytes 92..95 store the change counter for which the version number
3091 ** is valid. */
3092 put32bits(((char*)pPg->pData)+92, change_counter);
3093 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
3094}
3095
dan5cf53532010-05-01 16:40:20 +00003096#ifndef SQLITE_OMIT_WAL
dan3306c4a2010-04-23 19:15:00 +00003097/*
dan74d6cd82010-04-24 18:44:05 +00003098** This function is invoked once for each page that has already been
3099** written into the log file when a WAL transaction is rolled back.
3100** Parameter iPg is the page number of said page. The pCtx argument
3101** is actually a pointer to the Pager structure.
dan3306c4a2010-04-23 19:15:00 +00003102**
dan74d6cd82010-04-24 18:44:05 +00003103** If page iPg is present in the cache, and has no outstanding references,
3104** it is discarded. Otherwise, if there are one or more outstanding
3105** references, the page content is reloaded from the database. If the
3106** attempt to reload content from the database is required and fails,
3107** return an SQLite error code. Otherwise, SQLITE_OK.
3108*/
3109static int pagerUndoCallback(void *pCtx, Pgno iPg){
3110 int rc = SQLITE_OK;
3111 Pager *pPager = (Pager *)pCtx;
3112 PgHdr *pPg;
3113
drh092d9932013-04-02 00:41:18 +00003114 assert( pagerUseWal(pPager) );
dan74d6cd82010-04-24 18:44:05 +00003115 pPg = sqlite3PagerLookup(pPager, iPg);
3116 if( pPg ){
3117 if( sqlite3PcachePageRefcount(pPg)==1 ){
3118 sqlite3PcacheDrop(pPg);
3119 }else{
drh56520ab2017-08-18 21:14:50 +00003120 rc = readDbPage(pPg);
dan74d6cd82010-04-24 18:44:05 +00003121 if( rc==SQLITE_OK ){
3122 pPager->xReiniter(pPg);
3123 }
drhda8a3302013-12-13 19:35:21 +00003124 sqlite3PagerUnrefNotNull(pPg);
dan74d6cd82010-04-24 18:44:05 +00003125 }
3126 }
3127
dan4c97b532010-04-30 09:52:17 +00003128 /* Normally, if a transaction is rolled back, any backup processes are
3129 ** updated as data is copied out of the rollback journal and into the
3130 ** database. This is not generally possible with a WAL database, as
3131 ** rollback involves simply truncating the log file. Therefore, if one
3132 ** or more frames have already been written to the log (and therefore
3133 ** also copied into the backup databases) as part of this transaction,
3134 ** the backups must be restarted.
3135 */
3136 sqlite3BackupRestart(pPager->pBackup);
3137
dan74d6cd82010-04-24 18:44:05 +00003138 return rc;
3139}
3140
3141/*
3142** This function is called to rollback a transaction on a WAL database.
dan3306c4a2010-04-23 19:15:00 +00003143*/
drh7ed91f22010-04-29 22:34:07 +00003144static int pagerRollbackWal(Pager *pPager){
dan74d6cd82010-04-24 18:44:05 +00003145 int rc; /* Return Code */
3146 PgHdr *pList; /* List of dirty pages to revert */
dan3306c4a2010-04-23 19:15:00 +00003147
dan74d6cd82010-04-24 18:44:05 +00003148 /* For all pages in the cache that are currently dirty or have already
3149 ** been written (but not committed) to the log file, do one of the
3150 ** following:
3151 **
3152 ** + Discard the cached page (if refcount==0), or
3153 ** + Reload page content from the database (if refcount>0).
3154 */
dan7c246102010-04-12 19:00:29 +00003155 pPager->dbSize = pPager->dbOrigSize;
danff9e9b22018-12-29 20:42:12 +00003156 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager,
3157#ifdef SQLITE_OMIT_CONCURRENT
3158 0
3159#else
3160 pPager->pAllRead!=0
3161#endif
3162 );
dan74d6cd82010-04-24 18:44:05 +00003163 pList = sqlite3PcacheDirtyList(pPager->pPCache);
dan04085292015-08-24 16:00:08 +00003164
drh01be4632015-09-03 15:17:12 +00003165#ifndef SQLITE_OMIT_CONCURRENT
danbf3cf572015-08-24 19:56:04 +00003166 /* If this is an CONCURRENT transaction, then page 1 must be reread from
dan04085292015-08-24 16:00:08 +00003167 ** the db file, even if it is not dirty. This is because the b-tree layer
3168 ** may have already zeroed the nFree and iTrunk header fields. */
dan04085292015-08-24 16:00:08 +00003169 if( rc==SQLITE_OK && (pList==0 || pList->pgno!=1) && pPager->pAllRead ){
3170 rc = pagerUndoCallback((void*)pPager, 1);
3171 }
3172#endif
3173
dan7c246102010-04-12 19:00:29 +00003174 while( pList && rc==SQLITE_OK ){
3175 PgHdr *pNext = pList->pDirty;
dan74d6cd82010-04-24 18:44:05 +00003176 rc = pagerUndoCallback((void *)pPager, pList->pgno);
dan7c246102010-04-12 19:00:29 +00003177 pList = pNext;
3178 }
dan74d6cd82010-04-24 18:44:05 +00003179
dan7c246102010-04-12 19:00:29 +00003180 return rc;
3181}
3182
drhed7c8552001-04-11 14:29:21 +00003183/*
dan5cf53532010-05-01 16:40:20 +00003184** This function is a wrapper around sqlite3WalFrames(). As well as logging
3185** the contents of the list of pages headed by pList (connected by pDirty),
3186** this function notifies any active backup processes that the pages have
3187** changed.
drh104a7bb2011-01-15 17:12:59 +00003188**
3189** The list of pages passed into this routine is always sorted by page number.
3190** Hence, if page 1 appears anywhere on the list, it will be the first page.
dan5cf53532010-05-01 16:40:20 +00003191*/
3192static int pagerWalFrames(
3193 Pager *pPager, /* Pager object */
3194 PgHdr *pList, /* List of frames to log */
3195 Pgno nTruncate, /* Database size after this commit */
drh4eb02a42011-12-16 21:26:26 +00003196 int isCommit /* True if this is a commit */
dan5cf53532010-05-01 16:40:20 +00003197){
3198 int rc; /* Return code */
drh9ad3ee42012-03-24 20:06:14 +00003199 int nList; /* Number of pages in pList */
drh104a7bb2011-01-15 17:12:59 +00003200 PgHdr *p; /* For looping over pages */
dan5cf53532010-05-01 16:40:20 +00003201
3202 assert( pPager->pWal );
drhb07028f2011-10-14 21:49:18 +00003203 assert( pList );
drh104a7bb2011-01-15 17:12:59 +00003204#ifdef SQLITE_DEBUG
3205 /* Verify that the page list is in accending order */
3206 for(p=pList; p && p->pDirty; p=p->pDirty){
3207 assert( p->pgno < p->pDirty->pgno );
3208 }
3209#endif
3210
drh9ad3ee42012-03-24 20:06:14 +00003211 assert( pList->pDirty==0 || isCommit );
dance8e5ff2011-04-05 16:09:08 +00003212 if( isCommit ){
3213 /* If a WAL transaction is being committed, there is no point in writing
3214 ** any pages with page numbers greater than nTruncate into the WAL file.
3215 ** They will never be read by any client. So remove them from the pDirty
3216 ** list here. */
dance8e5ff2011-04-05 16:09:08 +00003217 PgHdr **ppNext = &pList;
drh9ad3ee42012-03-24 20:06:14 +00003218 nList = 0;
drha4c58602012-04-27 16:38:11 +00003219 for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
drh9ad3ee42012-03-24 20:06:14 +00003220 if( p->pgno<=nTruncate ){
3221 ppNext = &p->pDirty;
3222 nList++;
drh741802e2017-08-11 19:31:53 +00003223 PAGERTRACE(("TO-WAL %d page %d hash(%08x)\n",
3224 PAGERID(pPager), p->pgno, pager_pagehash(p)));
drh9ad3ee42012-03-24 20:06:14 +00003225 }
dance8e5ff2011-04-05 16:09:08 +00003226 }
3227 assert( pList );
drh9ad3ee42012-03-24 20:06:14 +00003228 }else{
3229 nList = 1;
dance8e5ff2011-04-05 16:09:08 +00003230 }
drh9ad3ee42012-03-24 20:06:14 +00003231 pPager->aStat[PAGER_STAT_WRITE] += nList;
dance8e5ff2011-04-05 16:09:08 +00003232
drh54a73472011-01-15 18:11:12 +00003233 if( pList->pgno==1 ) pager_write_changecounter(pList);
dan5cf53532010-05-01 16:40:20 +00003234 rc = sqlite3WalFrames(pPager->pWal,
drh4eb02a42011-12-16 21:26:26 +00003235 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
dan5cf53532010-05-01 16:40:20 +00003236 );
3237 if( rc==SQLITE_OK && pPager->pBackup ){
dan5cf53532010-05-01 16:40:20 +00003238 for(p=pList; p; p=p->pDirty){
3239 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
3240 }
3241 }
dan5f848c32010-08-23 18:19:31 +00003242
3243#ifdef SQLITE_CHECK_PAGES
dance8e5ff2011-04-05 16:09:08 +00003244 pList = sqlite3PcacheDirtyList(pPager->pPCache);
drh104a7bb2011-01-15 17:12:59 +00003245 for(p=pList; p; p=p->pDirty){
3246 pager_set_pagehash(p);
dan5f848c32010-08-23 18:19:31 +00003247 }
3248#endif
3249
dan5cf53532010-05-01 16:40:20 +00003250 return rc;
3251}
3252
3253/*
drh73b64e42010-05-30 19:55:15 +00003254** Begin a read transaction on the WAL.
3255**
3256** This routine used to be called "pagerOpenSnapshot()" because it essentially
3257** makes a snapshot of the database at the current point in time and preserves
3258** that snapshot for use by the reader in spite of concurrently changes by
3259** other writers or checkpointers.
dan5cf53532010-05-01 16:40:20 +00003260*/
drh73b64e42010-05-30 19:55:15 +00003261static int pagerBeginReadTransaction(Pager *pPager){
dan5cf53532010-05-01 16:40:20 +00003262 int rc; /* Return code */
3263 int changed = 0; /* True if cache must be reset */
3264
3265 assert( pagerUseWal(pPager) );
dande1ae342010-08-06 12:00:27 +00003266 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
dan5cf53532010-05-01 16:40:20 +00003267
drh61e4ace2010-05-31 20:28:37 +00003268 /* sqlite3WalEndReadTransaction() was not called for the previous
3269 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
3270 ** are in locking_mode=NORMAL and EndRead() was previously called,
3271 ** the duplicate call is harmless.
3272 */
3273 sqlite3WalEndReadTransaction(pPager->pWal);
3274
drh73b64e42010-05-30 19:55:15 +00003275 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
drh92683f52010-09-18 19:36:40 +00003276 if( rc!=SQLITE_OK || changed ){
dan763afe62010-08-03 06:42:39 +00003277 pager_reset(pPager);
drh188d4882013-04-08 20:47:49 +00003278 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
dan5cf53532010-05-01 16:40:20 +00003279 }
dan5cf53532010-05-01 16:40:20 +00003280
3281 return rc;
3282}
shaneh9091f772010-08-24 18:35:12 +00003283#endif
dan5cf53532010-05-01 16:40:20 +00003284
dan763afe62010-08-03 06:42:39 +00003285/*
dan85d14ed2010-08-06 17:18:00 +00003286** This function is called as part of the transition from PAGER_OPEN
3287** to PAGER_READER state to determine the size of the database file
3288** in pages (assuming the page size currently stored in Pager.pageSize).
3289**
3290** If no error occurs, SQLITE_OK is returned and the size of the database
3291** in pages is stored in *pnPage. Otherwise, an error code (perhaps
3292** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
dan763afe62010-08-03 06:42:39 +00003293*/
3294static int pagerPagecount(Pager *pPager, Pgno *pnPage){
3295 Pgno nPage; /* Value to return via *pnPage */
3296
dan85d14ed2010-08-06 17:18:00 +00003297 /* Query the WAL sub-system for the database size. The WalDbsize()
3298 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
3299 ** if the database size is not available. The database size is not
3300 ** available from the WAL sub-system if the log file is empty or
3301 ** contains no valid committed transactions.
3302 */
dande1ae342010-08-06 12:00:27 +00003303 assert( pPager->eState==PAGER_OPEN );
drh33f111d2012-01-17 15:29:14 +00003304 assert( pPager->eLock>=SHARED_LOCK );
drh835f22d2016-04-25 19:20:56 +00003305 assert( isOpen(pPager->fd) );
3306 assert( pPager->tempFile==0 );
dan763afe62010-08-03 06:42:39 +00003307 nPage = sqlite3WalDbsize(pPager->pWal);
dan85d14ed2010-08-06 17:18:00 +00003308
drhaf80a1c2015-05-25 10:29:52 +00003309 /* If the number of pages in the database is not available from the
drh8abc54e2017-05-29 14:30:46 +00003310 ** WAL sub-system, determine the page count based on the size of
drhaf80a1c2015-05-25 10:29:52 +00003311 ** the database file. If the size of the database file is not an
3312 ** integer multiple of the page-size, round up the result.
dan85d14ed2010-08-06 17:18:00 +00003313 */
drh835f22d2016-04-25 19:20:56 +00003314 if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
dan763afe62010-08-03 06:42:39 +00003315 i64 n = 0; /* Size of db file in bytes */
drh835f22d2016-04-25 19:20:56 +00003316 int rc = sqlite3OsFileSize(pPager->fd, &n);
3317 if( rc!=SQLITE_OK ){
3318 return rc;
dan763afe62010-08-03 06:42:39 +00003319 }
drh935de7e2012-01-11 15:47:42 +00003320 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
dan763afe62010-08-03 06:42:39 +00003321 }
dan937ac9d2010-08-03 12:48:45 +00003322
dan85d14ed2010-08-06 17:18:00 +00003323 /* If the current number of pages in the file is greater than the
dan937ac9d2010-08-03 12:48:45 +00003324 ** configured maximum pager number, increase the allowed limit so
3325 ** that the file can be read.
3326 */
3327 if( nPage>pPager->mxPgno ){
3328 pPager->mxPgno = (Pgno)nPage;
3329 }
3330
dan763afe62010-08-03 06:42:39 +00003331 *pnPage = nPage;
3332 return SQLITE_OK;
3333}
3334
shaneh9091f772010-08-24 18:35:12 +00003335#ifndef SQLITE_OMIT_WAL
dan5cf53532010-05-01 16:40:20 +00003336/*
dan5cf53532010-05-01 16:40:20 +00003337** Check if the *-wal file that corresponds to the database opened by pPager
drh32f29642010-07-01 19:45:34 +00003338** exists if the database is not empy, or verify that the *-wal file does
3339** not exist (by deleting it) if the database file is empty.
3340**
3341** If the database is not empty and the *-wal file exists, open the pager
3342** in WAL mode. If the database is empty or if no *-wal file exists and
3343** if no error occurs, make sure Pager.journalMode is not set to
3344** PAGER_JOURNALMODE_WAL.
3345**
3346** Return SQLITE_OK or an error code.
dan5cf53532010-05-01 16:40:20 +00003347**
dan5cf53532010-05-01 16:40:20 +00003348** The caller must hold a SHARED lock on the database file to call this
3349** function. Because an EXCLUSIVE lock on the db file is required to delete
drh32f29642010-07-01 19:45:34 +00003350** a WAL on a none-empty database, this ensures there is no race condition
3351** between the xAccess() below and an xDelete() being executed by some
3352** other connection.
dan5cf53532010-05-01 16:40:20 +00003353*/
3354static int pagerOpenWalIfPresent(Pager *pPager){
3355 int rc = SQLITE_OK;
dan85d14ed2010-08-06 17:18:00 +00003356 assert( pPager->eState==PAGER_OPEN );
drh33f111d2012-01-17 15:29:14 +00003357 assert( pPager->eLock>=SHARED_LOCK );
dan85d14ed2010-08-06 17:18:00 +00003358
dan5cf53532010-05-01 16:40:20 +00003359 if( !pPager->tempFile ){
3360 int isWal; /* True if WAL file exists */
drh77f6af22017-05-29 16:45:45 +00003361 rc = sqlite3OsAccess(
3362 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
3363 );
dan5cf53532010-05-01 16:40:20 +00003364 if( rc==SQLITE_OK ){
3365 if( isWal ){
drh77f6af22017-05-29 16:45:45 +00003366 Pgno nPage; /* Size of the database file */
3367
3368 rc = pagerPagecount(pPager, &nPage);
3369 if( rc ) return rc;
3370 if( nPage==0 ){
3371 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
3372 }else{
3373 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
3374 rc = sqlite3PagerOpenWal(pPager, 0);
3375 }
dan5cf53532010-05-01 16:40:20 +00003376 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
3377 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
3378 }
3379 }
3380 }
3381 return rc;
3382}
3383#endif
3384
3385/*
danielk1977bea2a942009-01-20 17:06:27 +00003386** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
drh067b92b2020-06-19 15:24:12 +00003387** the entire super-journal file. The case pSavepoint==NULL occurs when
danielk1977bea2a942009-01-20 17:06:27 +00003388** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
3389** savepoint.
drhd6e5e092009-01-07 02:03:35 +00003390**
danielk1977bea2a942009-01-20 17:06:27 +00003391** When pSavepoint is not NULL (meaning a non-transaction savepoint is
3392** being rolled back), then the rollback consists of up to three stages,
3393** performed in the order specified:
3394**
3395** * Pages are played back from the main journal starting at byte
3396** offset PagerSavepoint.iOffset and continuing to
3397** PagerSavepoint.iHdrOffset, or to the end of the main journal
3398** file if PagerSavepoint.iHdrOffset is zero.
3399**
3400** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
3401** back starting from the journal header immediately following
3402** PagerSavepoint.iHdrOffset to the end of the main journal file.
3403**
3404** * Pages are then played back from the sub-journal file, starting
3405** with the PagerSavepoint.iSubRec and continuing to the end of
3406** the journal file.
3407**
3408** Throughout the rollback process, each time a page is rolled back, the
3409** corresponding bit is set in a bitvec structure (variable pDone in the
3410** implementation below). This is used to ensure that a page is only
3411** rolled back the first time it is encountered in either journal.
3412**
3413** If pSavepoint is NULL, then pages are only played back from the main
3414** journal file. There is no need for a bitvec in this case.
3415**
3416** In either case, before playback commences the Pager.dbSize variable
3417** is reset to the value that it held at the start of the savepoint
3418** (or transaction). No page with a page-number greater than this value
3419** is played back. If one is encountered it is simply skipped.
drhfa86c412002-02-02 15:01:15 +00003420*/
danielk1977fd7f0452008-12-17 17:30:26 +00003421static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
drhd6e5e092009-01-07 02:03:35 +00003422 i64 szJ; /* Effective size of the main journal */
danielk1977fd7f0452008-12-17 17:30:26 +00003423 i64 iHdrOff; /* End of first segment of main-journal records */
danielk1977f2c31ad2009-01-06 13:40:08 +00003424 int rc = SQLITE_OK; /* Return code */
danielk1977fd7f0452008-12-17 17:30:26 +00003425 Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
drhfa86c412002-02-02 15:01:15 +00003426
dana42c66b2010-08-03 18:18:41 +00003427 assert( pPager->eState!=PAGER_ERROR );
dande1ae342010-08-06 12:00:27 +00003428 assert( pPager->eState>=PAGER_WRITER_LOCKED );
danielk1977bea2a942009-01-20 17:06:27 +00003429
danielk1977fd7f0452008-12-17 17:30:26 +00003430 /* Allocate a bitvec to use to store the set of pages rolled back */
3431 if( pSavepoint ){
3432 pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
3433 if( !pDone ){
mistachkinfad30392016-02-13 23:43:46 +00003434 return SQLITE_NOMEM_BKPT;
danielk1977fd7f0452008-12-17 17:30:26 +00003435 }
danielk197776572402004-06-25 02:38:54 +00003436 }
danielk1977fd7f0452008-12-17 17:30:26 +00003437
danielk1977bea2a942009-01-20 17:06:27 +00003438 /* Set the database size back to the value it was before the savepoint
3439 ** being reverted was opened.
drhfa86c412002-02-02 15:01:15 +00003440 */
drhd6e5e092009-01-07 02:03:35 +00003441 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
danab7e8d82010-07-07 17:53:51 +00003442 pPager->changeCountDone = pPager->tempFile;
drhfa86c412002-02-02 15:01:15 +00003443
drh7ed91f22010-04-29 22:34:07 +00003444 if( !pSavepoint && pagerUseWal(pPager) ){
3445 return pagerRollbackWal(pPager);
dan7c246102010-04-12 19:00:29 +00003446 }
3447
drhd6e5e092009-01-07 02:03:35 +00003448 /* Use pPager->journalOff as the effective size of the main rollback
3449 ** journal. The actual file might be larger than this in
3450 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
3451 ** past pPager->journalOff is off-limits to us.
drhfa86c412002-02-02 15:01:15 +00003452 */
danielk1977fd7f0452008-12-17 17:30:26 +00003453 szJ = pPager->journalOff;
drh7ed91f22010-04-29 22:34:07 +00003454 assert( pagerUseWal(pPager)==0 || szJ==0 );
drhd6e5e092009-01-07 02:03:35 +00003455
3456 /* Begin by rolling back records from the main journal starting at
3457 ** PagerSavepoint.iOffset and continuing to the next journal header.
3458 ** There might be records in the main journal that have a page number
3459 ** greater than the current database size (pPager->dbSize) but those
3460 ** will be skipped automatically. Pages are added to pDone as they
3461 ** are played back.
3462 */
drh7ed91f22010-04-29 22:34:07 +00003463 if( pSavepoint && !pagerUseWal(pPager) ){
danielk1977fd7f0452008-12-17 17:30:26 +00003464 iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
3465 pPager->journalOff = pSavepoint->iOffset;
3466 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
drh91781bd2010-04-10 17:52:57 +00003467 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
danielk1977fd7f0452008-12-17 17:30:26 +00003468 }
danielk1977bea2a942009-01-20 17:06:27 +00003469 assert( rc!=SQLITE_DONE );
danielk1977fd7f0452008-12-17 17:30:26 +00003470 }else{
3471 pPager->journalOff = 0;
drhfa86c412002-02-02 15:01:15 +00003472 }
drhd6e5e092009-01-07 02:03:35 +00003473
3474 /* Continue rolling back records out of the main journal starting at
3475 ** the first journal header seen and continuing until the effective end
3476 ** of the main journal file. Continue to skip out-of-range pages and
3477 ** continue adding pages rolled back to pDone.
3478 */
danielk1977fd7f0452008-12-17 17:30:26 +00003479 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
danielk1977bea2a942009-01-20 17:06:27 +00003480 u32 ii; /* Loop counter */
danielk1977c81806f2009-01-01 15:20:37 +00003481 u32 nJRec = 0; /* Number of Journal Records */
danielk197776572402004-06-25 02:38:54 +00003482 u32 dummy;
danielk19776f4c73e2009-06-26 07:12:06 +00003483 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
danielk1977fd7f0452008-12-17 17:30:26 +00003484 assert( rc!=SQLITE_DONE );
drhd6e5e092009-01-07 02:03:35 +00003485
3486 /*
3487 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
3488 ** test is related to ticket #2565. See the discussion in the
3489 ** pager_playback() function for additional information.
3490 */
drhd6e5e092009-01-07 02:03:35 +00003491 if( nJRec==0
3492 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
3493 ){
shaned87897d2009-01-30 05:40:27 +00003494 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
danielk197775edc162004-06-26 01:48:18 +00003495 }
danielk197712dd5492008-12-18 15:45:07 +00003496 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
drh91781bd2010-04-10 17:52:57 +00003497 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
danielk1977fd7f0452008-12-17 17:30:26 +00003498 }
danielk1977bea2a942009-01-20 17:06:27 +00003499 assert( rc!=SQLITE_DONE );
danielk1977fd7f0452008-12-17 17:30:26 +00003500 }
drh39cf5102010-06-21 21:45:37 +00003501 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
danielk1977fd7f0452008-12-17 17:30:26 +00003502
drhd6e5e092009-01-07 02:03:35 +00003503 /* Finally, rollback pages from the sub-journal. Page that were
3504 ** previously rolled back out of the main journal (and are hence in pDone)
3505 ** will be skipped. Out-of-range pages are also skipped.
3506 */
danielk1977fd7f0452008-12-17 17:30:26 +00003507 if( pSavepoint ){
danielk1977bea2a942009-01-20 17:06:27 +00003508 u32 ii; /* Loop counter */
dan7c3210e2011-12-21 18:04:41 +00003509 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
dan4cd78b42010-04-26 16:57:10 +00003510
drh7ed91f22010-04-29 22:34:07 +00003511 if( pagerUseWal(pPager) ){
dan71d89912010-05-24 13:57:42 +00003512 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
dan4cd78b42010-04-26 16:57:10 +00003513 }
danielk1977bea2a942009-01-20 17:06:27 +00003514 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
dan7c3210e2011-12-21 18:04:41 +00003515 assert( offset==(i64)ii*(4+pPager->pageSize) );
drh91781bd2010-04-10 17:52:57 +00003516 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
danielk197776572402004-06-25 02:38:54 +00003517 }
danielk1977bea2a942009-01-20 17:06:27 +00003518 assert( rc!=SQLITE_DONE );
drhfa86c412002-02-02 15:01:15 +00003519 }
danielk197776572402004-06-25 02:38:54 +00003520
danielk1977fd7f0452008-12-17 17:30:26 +00003521 sqlite3BitvecDestroy(pDone);
3522 if( rc==SQLITE_OK ){
danielk197775edc162004-06-26 01:48:18 +00003523 pPager->journalOff = szJ;
drhfa86c412002-02-02 15:01:15 +00003524 }
dan4cd78b42010-04-26 16:57:10 +00003525
drhfa86c412002-02-02 15:01:15 +00003526 return rc;
3527}
3528
3529/*
drh9b0cf342015-11-12 14:57:19 +00003530** Change the maximum number of in-memory pages that are allowed
3531** before attempting to recycle clean and unused pages.
drhf57b14a2001-09-14 18:54:08 +00003532*/
danielk19773b8a05f2007-03-19 17:44:26 +00003533void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
danielk19778c0a7912008-08-20 14:49:23 +00003534 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
drhf57b14a2001-09-14 18:54:08 +00003535}
3536
3537/*
drh9b0cf342015-11-12 14:57:19 +00003538** Change the maximum number of in-memory pages that are allowed
3539** before attempting to spill pages to journal.
3540*/
3541int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){
3542 return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage);
3543}
3544
3545/*
drh9b4c59f2013-04-15 17:03:42 +00003546** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
dan5d8a1372013-03-19 19:28:06 +00003547*/
3548static void pagerFixMaplimit(Pager *pPager){
drh9b4c59f2013-04-15 17:03:42 +00003549#if SQLITE_MAX_MMAP_SIZE>0
danf23da962013-03-23 21:00:41 +00003550 sqlite3_file *fd = pPager->fd;
dan789efdb2013-07-06 17:57:39 +00003551 if( isOpen(fd) && fd->pMethods->iVersion>=3 ){
drh9b4c59f2013-04-15 17:03:42 +00003552 sqlite3_int64 sz;
drh9b4c59f2013-04-15 17:03:42 +00003553 sz = pPager->szMmap;
dan789efdb2013-07-06 17:57:39 +00003554 pPager->bUseFetch = (sz>0);
drh12e6f682016-12-13 14:32:47 +00003555 setGetterMethod(pPager);
drh9b4c59f2013-04-15 17:03:42 +00003556 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
dan5d8a1372013-03-19 19:28:06 +00003557 }
drh188d4882013-04-08 20:47:49 +00003558#endif
dan5d8a1372013-03-19 19:28:06 +00003559}
3560
3561/*
3562** Change the maximum size of any memory mapping made of the database file.
3563*/
drh9b4c59f2013-04-15 17:03:42 +00003564void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
3565 pPager->szMmap = szMmap;
dan5d8a1372013-03-19 19:28:06 +00003566 pagerFixMaplimit(pPager);
3567}
3568
3569/*
drh09419b42011-11-16 19:29:17 +00003570** Free as much memory as possible from the pager.
3571*/
3572void sqlite3PagerShrink(Pager *pPager){
3573 sqlite3PcacheShrink(pPager->pPCache);
3574}
3575
3576/*
drh40c39412013-08-16 20:42:20 +00003577** Adjust settings of the pager to those specified in the pgFlags parameter.
3578**
3579** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness
3580** of the database to damage due to OS crashes or power failures by
3581** changing the number of syncs()s when writing the journals.
drh0dba3302016-03-08 13:56:02 +00003582** There are four levels:
drh973b6e32003-02-12 14:09:42 +00003583**
drh054889e2005-11-30 03:20:31 +00003584** OFF sqlite3OsSync() is never called. This is the default
drh973b6e32003-02-12 14:09:42 +00003585** for temporary and transient files.
3586**
3587** NORMAL The journal is synced once before writes begin on the
3588** database. This is normally adequate protection, but
3589** it is theoretically possible, though very unlikely,
3590** that an inopertune power failure could leave the journal
3591** in a state which would cause damage to the database
3592** when it is rolled back.
3593**
3594** FULL The journal is synced twice before writes begin on the
drh34e79ce2004-02-08 06:05:46 +00003595** database (with some additional information - the nRec field
3596** of the journal header - being written in between the two
3597** syncs). If we assume that writing a
drh973b6e32003-02-12 14:09:42 +00003598** single disk sector is atomic, then this mode provides
3599** assurance that the journal will not be corrupted to the
3600** point of causing damage to the database during rollback.
3601**
drh0dba3302016-03-08 13:56:02 +00003602** EXTRA This is like FULL except that is also syncs the directory
3603** that contains the rollback journal after the rollback
3604** journal is unlinked.
3605**
drhc97d8462010-11-19 18:23:35 +00003606** The above is for a rollback-journal mode. For WAL mode, OFF continues
3607** to mean that no syncs ever occur. NORMAL means that the WAL is synced
3608** prior to the start of checkpoint and that the database file is synced
3609** at the conclusion of the checkpoint if the entire content of the WAL
3610** was written back into the database. But no sync operations occur for
3611** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
3612** file is synced following each commit operation, in addition to the
drh0dba3302016-03-08 13:56:02 +00003613** syncs associated with NORMAL. There is no difference between FULL
3614** and EXTRA for WAL mode.
drhc97d8462010-11-19 18:23:35 +00003615**
3616** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
3617** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
3618** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
3619** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
3620** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
3621** synchronous=FULL versus synchronous=NORMAL setting determines when
3622** the xSync primitive is called and is relevant to all platforms.
3623**
drh973b6e32003-02-12 14:09:42 +00003624** Numeric values associated with these states are OFF==1, NORMAL=2,
3625** and FULL=3.
3626*/
danielk197793758c82005-01-21 08:13:14 +00003627#ifndef SQLITE_OMIT_PAGER_PRAGMAS
drh40c39412013-08-16 20:42:20 +00003628void sqlite3PagerSetFlags(
drhc97d8462010-11-19 18:23:35 +00003629 Pager *pPager, /* The pager to set safety level for */
drh40c39412013-08-16 20:42:20 +00003630 unsigned pgFlags /* Various flags */
drhc97d8462010-11-19 18:23:35 +00003631){
drh40c39412013-08-16 20:42:20 +00003632 unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK;
drh6841b1c2016-02-03 19:20:15 +00003633 if( pPager->tempFile ){
3634 pPager->noSync = 1;
3635 pPager->fullSync = 0;
3636 pPager->extraSync = 0;
3637 }else{
3638 pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0;
3639 pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
3640 pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
3641 }
drhc97d8462010-11-19 18:23:35 +00003642 if( pPager->noSync ){
3643 pPager->syncFlags = 0;
drh40c39412013-08-16 20:42:20 +00003644 }else if( pgFlags & PAGER_FULLFSYNC ){
drhc97d8462010-11-19 18:23:35 +00003645 pPager->syncFlags = SQLITE_SYNC_FULL;
drhc97d8462010-11-19 18:23:35 +00003646 }else{
3647 pPager->syncFlags = SQLITE_SYNC_NORMAL;
drhc97d8462010-11-19 18:23:35 +00003648 }
drhdaaae7b2017-08-25 01:14:43 +00003649 pPager->walSyncFlags = (pPager->syncFlags<<2);
drh4eb02a42011-12-16 21:26:26 +00003650 if( pPager->fullSync ){
drhdaaae7b2017-08-25 01:14:43 +00003651 pPager->walSyncFlags |= pPager->syncFlags;
3652 }
3653 if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){
3654 pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2);
drh4eb02a42011-12-16 21:26:26 +00003655 }
drh40c39412013-08-16 20:42:20 +00003656 if( pgFlags & PAGER_CACHESPILL ){
3657 pPager->doNotSpill &= ~SPILLFLAG_OFF;
3658 }else{
3659 pPager->doNotSpill |= SPILLFLAG_OFF;
3660 }
drh973b6e32003-02-12 14:09:42 +00003661}
danielk197793758c82005-01-21 08:13:14 +00003662#endif
drh973b6e32003-02-12 14:09:42 +00003663
3664/*
drhaf6df112005-06-07 02:12:30 +00003665** The following global variable is incremented whenever the library
3666** attempts to open a temporary file. This information is used for
3667** testing and analysis only.
3668*/
drh0f7eb612006-08-08 13:51:43 +00003669#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00003670int sqlite3_opentemp_count = 0;
drh0f7eb612006-08-08 13:51:43 +00003671#endif
drhaf6df112005-06-07 02:12:30 +00003672
3673/*
danielk1977bea2a942009-01-20 17:06:27 +00003674** Open a temporary file.
drh3f56e6e2007-03-15 01:16:47 +00003675**
danielk1977bea2a942009-01-20 17:06:27 +00003676** Write the file descriptor into *pFile. Return SQLITE_OK on success
3677** or some other error code if we fail. The OS will automatically
3678** delete the temporary file when it is closed.
3679**
3680** The flags passed to the VFS layer xOpen() call are those specified
3681** by parameter vfsFlags ORed with the following:
3682**
3683** SQLITE_OPEN_READWRITE
3684** SQLITE_OPEN_CREATE
3685** SQLITE_OPEN_EXCLUSIVE
3686** SQLITE_OPEN_DELETEONCLOSE
drhfa86c412002-02-02 15:01:15 +00003687*/
danielk1977bea2a942009-01-20 17:06:27 +00003688static int pagerOpentemp(
danielk197717b90b52008-06-06 11:11:25 +00003689 Pager *pPager, /* The pager object */
drh33f4e022007-09-03 15:19:34 +00003690 sqlite3_file *pFile, /* Write the file descriptor here */
drh33f4e022007-09-03 15:19:34 +00003691 int vfsFlags /* Flags passed through to the VFS */
danielk1977b4b47412007-08-17 15:53:36 +00003692){
danielk1977bea2a942009-01-20 17:06:27 +00003693 int rc; /* Return code */
drh3f56e6e2007-03-15 01:16:47 +00003694
drh0f7eb612006-08-08 13:51:43 +00003695#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00003696 sqlite3_opentemp_count++; /* Used for testing and analysis only */
drh0f7eb612006-08-08 13:51:43 +00003697#endif
danielk1977b4b47412007-08-17 15:53:36 +00003698
drh33f4e022007-09-03 15:19:34 +00003699 vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
3700 SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
danielk197717b90b52008-06-06 11:11:25 +00003701 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
danielk1977bea2a942009-01-20 17:06:27 +00003702 assert( rc!=SQLITE_OK || isOpen(pFile) );
drhfa86c412002-02-02 15:01:15 +00003703 return rc;
3704}
3705
drhed7c8552001-04-11 14:29:21 +00003706/*
drh90f5ecb2004-07-22 01:19:35 +00003707** Set the busy handler function.
danielk1977bea2a942009-01-20 17:06:27 +00003708**
3709** The pager invokes the busy-handler if sqlite3OsLock() returns
3710** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
3711** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
3712** lock. It does *not* invoke the busy handler when upgrading from
3713** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
3714** (which occurs during hot-journal rollback). Summary:
3715**
3716** Transition | Invokes xBusyHandler
3717** --------------------------------------------------------
3718** NO_LOCK -> SHARED_LOCK | Yes
3719** SHARED_LOCK -> RESERVED_LOCK | No
3720** SHARED_LOCK -> EXCLUSIVE_LOCK | No
3721** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
3722**
3723** If the busy-handler callback returns non-zero, the lock is
3724** retried. If it returns zero, then the SQLITE_BUSY error is
3725** returned to the caller of the pager API function.
drh90f5ecb2004-07-22 01:19:35 +00003726*/
drh80262892018-03-26 16:37:53 +00003727void sqlite3PagerSetBusyHandler(
danielk1977bea2a942009-01-20 17:06:27 +00003728 Pager *pPager, /* Pager object */
3729 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
3730 void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
dan80bb6f82012-10-01 18:44:33 +00003731){
drhafb39a42018-03-29 13:47:01 +00003732 void **ap;
danielk19771ceedd32008-11-19 10:22:33 +00003733 pPager->xBusyHandler = xBusyHandler;
3734 pPager->pBusyHandlerArg = pBusyHandlerArg;
drhafb39a42018-03-29 13:47:01 +00003735 ap = (void **)&pPager->xBusyHandler;
3736 assert( ((int(*)(void *))(ap[0]))==xBusyHandler );
3737 assert( ap[1]==pBusyHandlerArg );
3738 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
drh90f5ecb2004-07-22 01:19:35 +00003739}
3740
3741/*
danielk1977bea2a942009-01-20 17:06:27 +00003742** Change the page size used by the Pager object. The new page size
3743** is passed in *pPageSize.
3744**
3745** If the pager is in the error state when this function is called, it
3746** is a no-op. The value returned is the error state error code (i.e.
dana81a2202010-08-17 18:15:48 +00003747** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
danielk1977bea2a942009-01-20 17:06:27 +00003748**
3749** Otherwise, if all of the following are true:
3750**
3751** * the new page size (value of *pPageSize) is valid (a power
3752** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
3753**
3754** * there are no outstanding page references, and
3755**
3756** * the database is either not an in-memory database or it is
3757** an in-memory database that currently consists of zero pages.
3758**
3759** then the pager object page size is set to *pPageSize.
3760**
3761** If the page size is changed, then this function uses sqlite3PagerMalloc()
3762** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
3763** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
3764** In all other cases, SQLITE_OK is returned.
3765**
3766** If the page size is not changed, either because one of the enumerated
3767** conditions above is not true, the pager was in error state when this
3768** function was called, or because the memory allocation attempt failed,
3769** then *pPageSize is set to the old, retained page size before returning.
drh90f5ecb2004-07-22 01:19:35 +00003770*/
drhb2eced52010-08-12 02:41:12 +00003771int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
dan1879b082010-08-12 16:36:34 +00003772 int rc = SQLITE_OK;
3773
dana42c66b2010-08-03 18:18:41 +00003774 /* It is not possible to do a full assert_pager_state() here, as this
3775 ** function may be called from within PagerOpen(), before the state
3776 ** of the Pager object is internally consistent.
dan22b328b2010-08-11 18:56:45 +00003777 **
3778 ** At one point this function returned an error if the pager was in
3779 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
3780 ** there is at least one outstanding page reference, this function
3781 ** is a no-op for that case anyhow.
dana42c66b2010-08-03 18:18:41 +00003782 */
dana42c66b2010-08-03 18:18:41 +00003783
drhb2eced52010-08-12 02:41:12 +00003784 u32 pageSize = *pPageSize;
dan22b328b2010-08-11 18:56:45 +00003785 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
3786 if( (pPager->memDb==0 || pPager->dbSize==0)
3787 && sqlite3PcacheRefCount(pPager->pPCache)==0
drh43b18e12010-08-17 19:40:08 +00003788 && pageSize && pageSize!=(u32)pPager->pageSize
dan22b328b2010-08-11 18:56:45 +00003789 ){
shaneh1df2db72010-08-18 02:28:48 +00003790 char *pNew = NULL; /* New temp space */
dan22b328b2010-08-11 18:56:45 +00003791 i64 nByte = 0;
dan1879b082010-08-12 16:36:34 +00003792
dan22b328b2010-08-11 18:56:45 +00003793 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
dan1879b082010-08-12 16:36:34 +00003794 rc = sqlite3OsFileSize(pPager->fd, &nByte);
danielk1977a1644fd2007-08-29 12:31:25 +00003795 }
dan1879b082010-08-12 16:36:34 +00003796 if( rc==SQLITE_OK ){
drh5cb1ffc2019-02-26 17:49:07 +00003797 /* 8 bytes of zeroed overrun space is sufficient so that the b-tree
3798 * cell header parser will never run off the end of the allocation */
3799 pNew = (char *)sqlite3PageMalloc(pageSize+8);
3800 if( !pNew ){
3801 rc = SQLITE_NOMEM_BKPT;
3802 }else{
3803 memset(pNew+pageSize, 0, 8);
3804 }
dan1879b082010-08-12 16:36:34 +00003805 }
3806
3807 if( rc==SQLITE_OK ){
dan22b328b2010-08-11 18:56:45 +00003808 pager_reset(pPager);
drhc3031c62014-08-26 15:06:49 +00003809 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
dan22b328b2010-08-11 18:56:45 +00003810 }
drh60da7272014-09-06 03:38:51 +00003811 if( rc==SQLITE_OK ){
drh6a154402014-10-08 13:34:21 +00003812 sqlite3PageFree(pPager->pTmpSpace);
3813 pPager->pTmpSpace = pNew;
drh60da7272014-09-06 03:38:51 +00003814 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
3815 pPager->pageSize = pageSize;
drh584bfca2022-02-23 17:00:44 +00003816 pPager->lckPgno = (Pgno)(PENDING_BYTE/pageSize) + 1;
drh6a154402014-10-08 13:34:21 +00003817 }else{
3818 sqlite3PageFree(pNew);
drh60da7272014-09-06 03:38:51 +00003819 }
drh1c7880e2005-05-20 20:01:55 +00003820 }
dan22b328b2010-08-11 18:56:45 +00003821
drhb2eced52010-08-12 02:41:12 +00003822 *pPageSize = pPager->pageSize;
dan1879b082010-08-12 16:36:34 +00003823 if( rc==SQLITE_OK ){
3824 if( nReserve<0 ) nReserve = pPager->nReserve;
3825 assert( nReserve>=0 && nReserve<1000 );
3826 pPager->nReserve = (i16)nReserve;
dan5d8a1372013-03-19 19:28:06 +00003827 pagerFixMaplimit(pPager);
dan1879b082010-08-12 16:36:34 +00003828 }
3829 return rc;
drh90f5ecb2004-07-22 01:19:35 +00003830}
3831
3832/*
drh26b79942007-11-28 16:19:56 +00003833** Return a pointer to the "temporary page" buffer held internally
3834** by the pager. This is a buffer that is big enough to hold the
3835** entire content of a database page. This buffer is used internally
3836** during rollback and will be overwritten whenever a rollback
3837** occurs. But other modules are free to use it too, as long as
3838** no rollbacks are happening.
3839*/
3840void *sqlite3PagerTempSpace(Pager *pPager){
3841 return pPager->pTmpSpace;
3842}
3843
3844/*
drhf8e632b2007-05-08 14:51:36 +00003845** Attempt to set the maximum database page count if mxPage is positive.
3846** Make no changes if mxPage is zero or negative. And never reduce the
3847** maximum page count below the current size of the database.
3848**
3849** Regardless of mxPage, return the current maximum page count.
3850*/
drhe9261db2020-07-20 12:47:32 +00003851Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){
drhf8e632b2007-05-08 14:51:36 +00003852 if( mxPage>0 ){
3853 pPager->mxPgno = mxPage;
3854 }
drhc84e0332010-11-23 20:25:08 +00003855 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
danb8852ae2019-01-19 15:27:09 +00003856 /* assert( pPager->mxPgno>=pPager->dbSize ); */
3857 /* OP_MaxPgcnt ensures that the parameter passed to this function is not
3858 ** less than the total number of valid pages in the database. But this
3859 ** may be less than Pager.dbSize, and so the assert() above is not valid */
drhf8e632b2007-05-08 14:51:36 +00003860 return pPager->mxPgno;
3861}
3862
3863/*
drhc9ac5ca2005-11-04 22:03:30 +00003864** The following set of routines are used to disable the simulated
3865** I/O error mechanism. These routines are used to avoid simulated
3866** errors in places where we do not care about errors.
3867**
3868** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
3869** and generate no code.
3870*/
3871#ifdef SQLITE_TEST
3872extern int sqlite3_io_error_pending;
3873extern int sqlite3_io_error_hit;
3874static int saved_cnt;
drhc9ac5ca2005-11-04 22:03:30 +00003875void disable_simulated_io_errors(void){
3876 saved_cnt = sqlite3_io_error_pending;
3877 sqlite3_io_error_pending = -1;
3878}
3879void enable_simulated_io_errors(void){
3880 sqlite3_io_error_pending = saved_cnt;
3881}
3882#else
drh152410f2005-11-05 15:11:22 +00003883# define disable_simulated_io_errors()
3884# define enable_simulated_io_errors()
drhc9ac5ca2005-11-04 22:03:30 +00003885#endif
3886
3887/*
drh90f5ecb2004-07-22 01:19:35 +00003888** Read the first N bytes from the beginning of the file into memory
danielk1977aef0bf62005-12-30 16:28:01 +00003889** that pDest points to.
3890**
danielk1977bea2a942009-01-20 17:06:27 +00003891** If the pager was opened on a transient file (zFilename==""), or
3892** opened on a file less than N bytes in size, the output buffer is
3893** zeroed and SQLITE_OK returned. The rationale for this is that this
3894** function is used to read database headers, and a new transient or
3895** zero sized database has a header than consists entirely of zeroes.
3896**
3897** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
3898** the error code is returned to the caller and the contents of the
3899** output buffer undefined.
drh90f5ecb2004-07-22 01:19:35 +00003900*/
danielk19773b8a05f2007-03-19 17:44:26 +00003901int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
drh551b7732006-11-06 21:20:25 +00003902 int rc = SQLITE_OK;
drh90f5ecb2004-07-22 01:19:35 +00003903 memset(pDest, 0, N);
danielk1977bea2a942009-01-20 17:06:27 +00003904 assert( isOpen(pPager->fd) || pPager->tempFile );
danb6e099a2010-05-04 14:47:39 +00003905
drh82043b32010-05-25 02:24:01 +00003906 /* This routine is only called by btree immediately after creating
3907 ** the Pager object. There has not been an opportunity to transition
3908 ** to WAL mode yet.
3909 */
3910 assert( !pagerUseWal(pPager) );
danb6e099a2010-05-04 14:47:39 +00003911
danielk1977bea2a942009-01-20 17:06:27 +00003912 if( isOpen(pPager->fd) ){
drhb0603412007-02-28 04:47:26 +00003913 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
danielk197762079062007-08-15 17:08:46 +00003914 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
drh551b7732006-11-06 21:20:25 +00003915 if( rc==SQLITE_IOERR_SHORT_READ ){
3916 rc = SQLITE_OK;
3917 }
drh90f5ecb2004-07-22 01:19:35 +00003918 }
drh551b7732006-11-06 21:20:25 +00003919 return rc;
drh90f5ecb2004-07-22 01:19:35 +00003920}
3921
3922/*
dan937ac9d2010-08-03 12:48:45 +00003923** This function may only be called when a read-transaction is open on
3924** the pager. It returns the total number of pages in the database.
3925**
danielk1977bea2a942009-01-20 17:06:27 +00003926** However, if the file is between 1 and <page-size> bytes in size, then
3927** this is considered a 1 page file.
drhed7c8552001-04-11 14:29:21 +00003928*/
drh8fb8b532010-08-14 17:12:04 +00003929void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
dan54919f82010-08-05 18:53:26 +00003930 assert( pPager->eState>=PAGER_READER );
dan763afe62010-08-03 06:42:39 +00003931 assert( pPager->eState!=PAGER_WRITER_FINISHED );
dan937ac9d2010-08-03 12:48:45 +00003932 *pnPage = (int)pPager->dbSize;
drhed7c8552001-04-11 14:29:21 +00003933}
3934
drhac69b052004-05-12 13:30:07 +00003935
3936/*
danielk1977bea2a942009-01-20 17:06:27 +00003937** Try to obtain a lock of type locktype on the database file. If
3938** a similar or greater lock is already held, this function is a no-op
3939** (returning SQLITE_OK immediately).
3940**
3941** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
3942** the busy callback if the lock is currently not available. Repeat
3943** until the busy callback returns false or until the attempt to
3944** obtain the lock succeeds.
danielk197717221812005-02-15 03:38:05 +00003945**
3946** Return SQLITE_OK on success and an error code if we cannot obtain
danielk1977bea2a942009-01-20 17:06:27 +00003947** the lock. If the lock is obtained successfully, set the Pager.state
3948** variable to locktype before returning.
danielk197717221812005-02-15 03:38:05 +00003949*/
3950static int pager_wait_on_lock(Pager *pPager, int locktype){
danielk1977bea2a942009-01-20 17:06:27 +00003951 int rc; /* Return code */
drh1aa2d8b2007-01-03 15:34:29 +00003952
danielk1977bea2a942009-01-20 17:06:27 +00003953 /* Check that this is either a no-op (because the requested lock is
peter.d.reid60ec9142014-09-06 16:39:46 +00003954 ** already held), or one of the transitions that the busy-handler
danielk1977bea2a942009-01-20 17:06:27 +00003955 ** may be invoked during, according to the comment above
3956 ** sqlite3PagerSetBusyhandler().
3957 */
dand0864082010-08-02 14:32:52 +00003958 assert( (pPager->eLock>=locktype)
3959 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
3960 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
danielk1977bea2a942009-01-20 17:06:27 +00003961 );
3962
dan4e004aa2010-08-05 15:30:22 +00003963 do {
3964 rc = pagerLockDb(pPager, locktype);
3965 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
danielk197717221812005-02-15 03:38:05 +00003966 return rc;
3967}
3968
danielk19773460d192008-12-27 15:23:13 +00003969/*
danielk19779f0b6be2009-07-25 11:40:07 +00003970** Function assertTruncateConstraint(pPager) checks that one of the
3971** following is true for all dirty pages currently in the page-cache:
3972**
3973** a) The page number is less than or equal to the size of the
3974** current database image, in pages, OR
3975**
3976** b) if the page content were written at this time, it would not
dan4ce289d2022-01-01 20:02:58 +00003977** be necessary to write the current content out to the sub-journal.
danielk19779f0b6be2009-07-25 11:40:07 +00003978**
3979** If the condition asserted by this function were not true, and the
3980** dirty page were to be discarded from the cache via the pagerStress()
3981** routine, pagerStress() would not write the current page content to
3982** the database file. If a savepoint transaction were rolled back after
mistachkin48864df2013-03-21 21:20:32 +00003983** this happened, the correct behavior would be to restore the current
danielk19779f0b6be2009-07-25 11:40:07 +00003984** content of the page. However, since this content is not present in either
3985** the database file or the portion of the rollback journal and
3986** sub-journal rolled back the content could not be restored and the
3987** database image would become corrupt. It is therefore fortunate that
3988** this circumstance cannot arise.
3989*/
3990#if defined(SQLITE_DEBUG)
3991static void assertTruncateConstraintCb(PgHdr *pPg){
dan4ce289d2022-01-01 20:02:58 +00003992 Pager *pPager = pPg->pPager;
danielk19779f0b6be2009-07-25 11:40:07 +00003993 assert( pPg->flags&PGHDR_DIRTY );
dan4ce289d2022-01-01 20:02:58 +00003994 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
3995 Pgno pgno = pPg->pgno;
3996 int i;
3997 for(i=0; i<pPg->pPager->nSavepoint; i++){
3998 PagerSavepoint *p = &pPager->aSavepoint[i];
3999 assert( p->nOrig<pgno || sqlite3BitvecTestNotNull(p->pInSavepoint,pgno) );
4000 }
4001 }
danielk19779f0b6be2009-07-25 11:40:07 +00004002}
4003static void assertTruncateConstraint(Pager *pPager){
4004 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
4005}
4006#else
4007# define assertTruncateConstraint(pPager)
4008#endif
4009
4010/*
danielk1977f90b7262009-01-07 15:18:20 +00004011** Truncate the in-memory database file image to nPage pages. This
4012** function does not actually modify the database file on disk. It
4013** just sets the internal state of the pager object so that the
4014** truncation will be done when the current transaction is committed.
dane0ac3632013-03-04 16:35:06 +00004015**
4016** This function is only called right before committing a transaction.
4017** Once this function has been called, the transaction must either be
4018** rolled back or committed. It is not safe to call this function and
4019** then continue writing to the database.
danielk19773460d192008-12-27 15:23:13 +00004020*/
4021void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
drh4ba1c5c2022-02-11 17:33:02 +00004022 assert( pPager->dbSize>=nPage || CORRUPT_DB );
dand0864082010-08-02 14:32:52 +00004023 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
danielk19773460d192008-12-27 15:23:13 +00004024 pPager->dbSize = nPage;
dane0ac3632013-03-04 16:35:06 +00004025
4026 /* At one point the code here called assertTruncateConstraint() to
4027 ** ensure that all pages being truncated away by this operation are,
4028 ** if one or more savepoints are open, present in the savepoint
4029 ** journal so that they can be restored if the savepoint is rolled
4030 ** back. This is no longer necessary as this function is now only
4031 ** called right before committing a transaction. So although the
4032 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
4033 ** they cannot be rolled back. So the assertTruncateConstraint() call
4034 ** is no longer correct. */
danielk19773460d192008-12-27 15:23:13 +00004035}
danielk19773460d192008-12-27 15:23:13 +00004036
dan7c246102010-04-12 19:00:29 +00004037
drhf7c57532003-04-25 13:22:51 +00004038/*
daneada58a2010-04-12 17:08:44 +00004039** This function is called before attempting a hot-journal rollback. It
4040** syncs the journal file to disk, then sets pPager->journalHdr to the
4041** size of the journal file so that the pager_playback() routine knows
4042** that the entire journal file has been synced.
4043**
4044** Syncing a hot-journal to disk before attempting to roll it back ensures
4045** that if a power-failure occurs during the rollback, the process that
4046** attempts rollback following system recovery sees the same journal
4047** content as this process.
4048**
4049** If everything goes as planned, SQLITE_OK is returned. Otherwise,
4050** an SQLite error code.
4051*/
4052static int pagerSyncHotJournal(Pager *pPager){
4053 int rc = SQLITE_OK;
4054 if( !pPager->noSync ){
4055 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
4056 }
4057 if( rc==SQLITE_OK ){
4058 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
4059 }
4060 return rc;
4061}
4062
drh9c4dc222016-12-30 12:06:22 +00004063#if SQLITE_MAX_MMAP_SIZE>0
danb2d3de32013-03-14 18:34:37 +00004064/*
dan5d8a1372013-03-19 19:28:06 +00004065** Obtain a reference to a memory mapped page object for page number pgno.
danf23da962013-03-23 21:00:41 +00004066** The new object will use the pointer pData, obtained from xFetch().
4067** If successful, set *ppPage to point to the new page reference
dan5d8a1372013-03-19 19:28:06 +00004068** and return SQLITE_OK. Otherwise, return an SQLite error code and set
4069** *ppPage to zero.
4070**
4071** Page references obtained by calling this function should be released
4072** by calling pagerReleaseMapPage().
4073*/
danf23da962013-03-23 21:00:41 +00004074static int pagerAcquireMapPage(
4075 Pager *pPager, /* Pager object */
4076 Pgno pgno, /* Page number */
4077 void *pData, /* xFetch()'d data for this page */
4078 PgHdr **ppPage /* OUT: Acquired page object */
4079){
dan5d8a1372013-03-19 19:28:06 +00004080 PgHdr *p; /* Memory mapped page to return */
drh542d5582014-12-31 14:18:48 +00004081
drhc86e5132013-03-26 14:36:11 +00004082 if( pPager->pMmapFreelist ){
4083 *ppPage = p = pPager->pMmapFreelist;
4084 pPager->pMmapFreelist = p->pDirty;
dan5d8a1372013-03-19 19:28:06 +00004085 p->pDirty = 0;
drha2ee5892016-12-09 16:02:00 +00004086 assert( pPager->nExtra>=8 );
4087 memset(p->pExtra, 0, 8);
dan5d8a1372013-03-19 19:28:06 +00004088 }else{
4089 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
4090 if( p==0 ){
dandf737fe2013-03-25 17:00:24 +00004091 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
mistachkinfad30392016-02-13 23:43:46 +00004092 return SQLITE_NOMEM_BKPT;
danb2d3de32013-03-14 18:34:37 +00004093 }
dan5d8a1372013-03-19 19:28:06 +00004094 p->pExtra = (void *)&p[1];
4095 p->flags = PGHDR_MMAP;
4096 p->nRef = 1;
4097 p->pPager = pPager;
danb2d3de32013-03-14 18:34:37 +00004098 }
4099
dan5d8a1372013-03-19 19:28:06 +00004100 assert( p->pExtra==(void *)&p[1] );
4101 assert( p->pPage==0 );
4102 assert( p->flags==PGHDR_MMAP );
4103 assert( p->pPager==pPager );
4104 assert( p->nRef==1 );
4105
dan5d8a1372013-03-19 19:28:06 +00004106 p->pgno = pgno;
danf23da962013-03-23 21:00:41 +00004107 p->pData = pData;
dan5d8a1372013-03-19 19:28:06 +00004108 pPager->nMmapOut++;
4109
danb2d3de32013-03-14 18:34:37 +00004110 return SQLITE_OK;
4111}
drh9c4dc222016-12-30 12:06:22 +00004112#endif
danb2d3de32013-03-14 18:34:37 +00004113
dan5d8a1372013-03-19 19:28:06 +00004114/*
4115** Release a reference to page pPg. pPg must have been returned by an
4116** earlier call to pagerAcquireMapPage().
4117*/
danb2d3de32013-03-14 18:34:37 +00004118static void pagerReleaseMapPage(PgHdr *pPg){
4119 Pager *pPager = pPg->pPager;
4120 pPager->nMmapOut--;
drhc86e5132013-03-26 14:36:11 +00004121 pPg->pDirty = pPager->pMmapFreelist;
4122 pPager->pMmapFreelist = pPg;
danf23da962013-03-23 21:00:41 +00004123
4124 assert( pPager->fd->pMethods->iVersion>=3 );
dandf737fe2013-03-25 17:00:24 +00004125 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
danb2d3de32013-03-14 18:34:37 +00004126}
4127
dan5d8a1372013-03-19 19:28:06 +00004128/*
drhc86e5132013-03-26 14:36:11 +00004129** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
dan5d8a1372013-03-19 19:28:06 +00004130*/
danb2d3de32013-03-14 18:34:37 +00004131static void pagerFreeMapHdrs(Pager *pPager){
4132 PgHdr *p;
4133 PgHdr *pNext;
drhc86e5132013-03-26 14:36:11 +00004134 for(p=pPager->pMmapFreelist; p; p=pNext){
danb2d3de32013-03-14 18:34:37 +00004135 pNext = p->pDirty;
4136 sqlite3_free(p);
4137 }
4138}
4139
danfa688152018-02-07 16:14:41 +00004140/* Verify that the database file has not be deleted or renamed out from
mistachkinb189e412018-02-07 18:45:00 +00004141** under the pager. Return SQLITE_OK if the database is still where it ought
danfa688152018-02-07 16:14:41 +00004142** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
4143** code from sqlite3OsAccess()) if the database has gone missing.
4144*/
4145static int databaseIsUnmoved(Pager *pPager){
4146 int bHasMoved = 0;
4147 int rc;
4148
4149 if( pPager->tempFile ) return SQLITE_OK;
4150 if( pPager->dbSize==0 ) return SQLITE_OK;
4151 assert( pPager->zFilename && pPager->zFilename[0] );
4152 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
4153 if( rc==SQLITE_NOTFOUND ){
4154 /* If the HAS_MOVED file-control is unimplemented, assume that the file
4155 ** has not been moved. That is the historical behavior of SQLite: prior to
4156 ** version 3.8.3, it never checked */
4157 rc = SQLITE_OK;
4158 }else if( rc==SQLITE_OK && bHasMoved ){
4159 rc = SQLITE_READONLY_DBMOVED;
4160 }
4161 return rc;
4162}
4163
danb2d3de32013-03-14 18:34:37 +00004164
daneada58a2010-04-12 17:08:44 +00004165/*
drhed7c8552001-04-11 14:29:21 +00004166** Shutdown the page cache. Free all memory and close all files.
4167**
4168** If a transaction was in progress when this routine is called, that
4169** transaction is rolled back. All outstanding pages are invalidated
4170** and their memory is freed. Any attempt to use a page associated
4171** with this page cache after this function returns will likely
4172** result in a coredump.
danielk1977aef0bf62005-12-30 16:28:01 +00004173**
4174** This function always succeeds. If a transaction is active an attempt
4175** is made to roll it back. If an error occurs during the rollback
4176** a hot journal may be left in the filesystem but no error is returned
4177** to the caller.
drhed7c8552001-04-11 14:29:21 +00004178*/
dan7fb89902016-08-12 16:21:15 +00004179int sqlite3PagerClose(Pager *pPager, sqlite3 *db){
danfa688152018-02-07 16:14:41 +00004180 u8 *pTmp = (u8*)pPager->pTmpSpace;
dan7fb89902016-08-12 16:21:15 +00004181 assert( db || pagerUseWal(pPager)==0 );
drh2a5d9902011-08-26 00:34:45 +00004182 assert( assert_pager_state(pPager) );
drhbafda092007-01-03 23:36:22 +00004183 disable_simulated_io_errors();
danielk19772d1d86f2008-06-20 14:59:51 +00004184 sqlite3BeginBenignMalloc();
danb2d3de32013-03-14 18:34:37 +00004185 pagerFreeMapHdrs(pPager);
dana42c66b2010-08-03 18:18:41 +00004186 /* pPager->errCode = 0; */
danielk197741483462007-03-24 16:45:04 +00004187 pPager->exclusiveMode = 0;
dan5cf53532010-05-01 16:40:20 +00004188#ifndef SQLITE_OMIT_WAL
danfa688152018-02-07 16:14:41 +00004189 {
4190 u8 *a = 0;
4191 assert( db || pPager->pWal==0 );
4192 if( db && 0==(db->flags & SQLITE_NoCkptOnClose)
4193 && SQLITE_OK==databaseIsUnmoved(pPager)
4194 ){
4195 a = pTmp;
4196 }
4197 sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
4198 pPager->pWal = 0;
4199 }
dan5cf53532010-05-01 16:40:20 +00004200#endif
drhbafda092007-01-03 23:36:22 +00004201 pager_reset(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00004202 if( MEMDB ){
4203 pager_unlock(pPager);
4204 }else{
dana42c66b2010-08-03 18:18:41 +00004205 /* If it is open, sync the journal file before calling UnlockAndRollback.
4206 ** If this is not done, then an unsynced portion of the open journal
4207 ** file may be played back into the database. If a power failure occurs
4208 ** while this is happening, the database could become corrupt.
4209 **
4210 ** If an error occurs while trying to sync the journal, shift the pager
4211 ** into the ERROR state. This causes UnlockAndRollback to unlock the
4212 ** database and close the journal file without attempting to roll it
4213 ** back or finalize it. The next database user will have to do hot-journal
4214 ** rollback before accessing the database file.
danielk1977f2c31ad2009-01-06 13:40:08 +00004215 */
daneada58a2010-04-12 17:08:44 +00004216 if( isOpen(pPager->jfd) ){
dana42c66b2010-08-03 18:18:41 +00004217 pager_error(pPager, pagerSyncHotJournal(pPager));
daneada58a2010-04-12 17:08:44 +00004218 }
danielk1977b3175382008-10-17 18:51:52 +00004219 pagerUnlockAndRollback(pPager);
4220 }
danielk197745d68822009-01-16 16:23:38 +00004221 sqlite3EndBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00004222 enable_simulated_io_errors();
drh30d53702009-01-06 15:58:57 +00004223 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
drhb0603412007-02-28 04:47:26 +00004224 IOTRACE(("CLOSE %p\n", pPager))
dane08341c2010-06-21 12:34:29 +00004225 sqlite3OsClose(pPager->jfd);
danielk1977b4b47412007-08-17 15:53:36 +00004226 sqlite3OsClose(pPager->fd);
dan7c246102010-04-12 19:00:29 +00004227 sqlite3PageFree(pTmp);
danielk19778c0a7912008-08-20 14:49:23 +00004228 sqlite3PcacheClose(pPager->pPCache);
danielk1977bea2a942009-01-20 17:06:27 +00004229 assert( !pPager->aSavepoint && !pPager->pInJournal );
4230 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
4231
drh17435752007-08-16 04:30:38 +00004232 sqlite3_free(pPager);
drhed7c8552001-04-11 14:29:21 +00004233 return SQLITE_OK;
4234}
4235
drh87cc3b32007-05-08 21:45:27 +00004236#if !defined(NDEBUG) || defined(SQLITE_TEST)
drhed7c8552001-04-11 14:29:21 +00004237/*
danielk1977bea2a942009-01-20 17:06:27 +00004238** Return the page number for page pPg.
drhed7c8552001-04-11 14:29:21 +00004239*/
danielk1977bea2a942009-01-20 17:06:27 +00004240Pgno sqlite3PagerPagenumber(DbPage *pPg){
4241 return pPg->pgno;
drhed7c8552001-04-11 14:29:21 +00004242}
drh87cc3b32007-05-08 21:45:27 +00004243#endif
drhed7c8552001-04-11 14:29:21 +00004244
4245/*
danielk1977bea2a942009-01-20 17:06:27 +00004246** Increment the reference count for page pPg.
drhdf0b3b02001-06-23 11:36:20 +00004247*/
danielk1977bea2a942009-01-20 17:06:27 +00004248void sqlite3PagerRef(DbPage *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004249 sqlite3PcacheRef(pPg);
drh7e3b0a02001-04-28 16:52:40 +00004250}
4251
4252/*
danielk1977bea2a942009-01-20 17:06:27 +00004253** Sync the journal. In other words, make sure all the pages that have
drh34e79ce2004-02-08 06:05:46 +00004254** been written to the journal have actually reached the surface of the
danielk1977bea2a942009-01-20 17:06:27 +00004255** disk and can be restored in the event of a hot-journal rollback.
drhb19a2bc2001-09-16 00:13:26 +00004256**
dan937ac9d2010-08-03 12:48:45 +00004257** If the Pager.noSync flag is set, then this function is a no-op.
dan51133ea2010-07-30 15:43:13 +00004258** Otherwise, the actions required depend on the journal-mode and the
mistachkind5578432012-08-25 10:01:29 +00004259** device characteristics of the file-system, as follows:
danielk19774cd2cd52007-08-23 14:48:23 +00004260**
danielk1977bea2a942009-01-20 17:06:27 +00004261** * If the journal file is an in-memory journal file, no action need
4262** be taken.
drhfa86c412002-02-02 15:01:15 +00004263**
danielk1977bea2a942009-01-20 17:06:27 +00004264** * Otherwise, if the device does not support the SAFE_APPEND property,
4265** then the nRec field of the most recently written journal header
4266** is updated to contain the number of journal records that have
4267** been written following it. If the pager is operating in full-sync
4268** mode, then the journal file is synced before this field is updated.
4269**
4270** * If the device does not support the SEQUENTIAL property, then
4271** journal file is synced.
4272**
4273** Or, in pseudo-code:
4274**
4275** if( NOT <in-memory journal> ){
4276** if( NOT SAFE_APPEND ){
4277** if( <full-sync mode> ) xSync(<journal file>);
4278** <update nRec field>
4279** }
4280** if( NOT SEQUENTIAL ) xSync(<journal file>);
4281** }
4282**
danielk1977bea2a942009-01-20 17:06:27 +00004283** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
4284** page currently held in memory before returning SQLITE_OK. If an IO
4285** error is encountered, then the IO error code is returned to the caller.
drh50e5dad2001-09-15 00:57:28 +00004286*/
dan937ac9d2010-08-03 12:48:45 +00004287static int syncJournal(Pager *pPager, int newHdr){
dand0864082010-08-02 14:32:52 +00004288 int rc; /* Return code */
4289
4290 assert( pPager->eState==PAGER_WRITER_CACHEMOD
4291 || pPager->eState==PAGER_WRITER_DBMOD
4292 );
4293 assert( assert_pager_state(pPager) );
dan937ac9d2010-08-03 12:48:45 +00004294 assert( !pagerUseWal(pPager) );
dand0864082010-08-02 14:32:52 +00004295
dan995b2452017-05-29 19:23:56 +00004296 rc = sqlite3PagerExclusiveLock(pPager, 0, 0);
dand0864082010-08-02 14:32:52 +00004297 if( rc!=SQLITE_OK ) return rc;
4298
dan51133ea2010-07-30 15:43:13 +00004299 if( !pPager->noSync ){
danielk1977b3175382008-10-17 18:51:52 +00004300 assert( !pPager->tempFile );
dand0864082010-08-02 14:32:52 +00004301 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
danielk1977bea2a942009-01-20 17:06:27 +00004302 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
4303 assert( isOpen(pPager->jfd) );
danielk19774cd2cd52007-08-23 14:48:23 +00004304
danielk19774cd2cd52007-08-23 14:48:23 +00004305 if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
danielk1977112f7522009-01-08 17:50:45 +00004306 /* This block deals with an obscure problem. If the last connection
4307 ** that wrote to this database was operating in persistent-journal
4308 ** mode, then the journal file may at this point actually be larger
4309 ** than Pager.journalOff bytes. If the next thing in the journal
4310 ** file happens to be a journal-header (written as part of the
drh91781bd2010-04-10 17:52:57 +00004311 ** previous connection's transaction), and a crash or power-failure
danielk1977112f7522009-01-08 17:50:45 +00004312 ** occurs after nRec is updated but before this connection writes
4313 ** anything else to the journal file (or commits/rolls back its
4314 ** transaction), then SQLite may become confused when doing the
4315 ** hot-journal rollback following recovery. It may roll back all
4316 ** of this connections data, then proceed to rolling back the old,
4317 ** out-of-date data that follows it. Database corruption.
4318 **
4319 ** To work around this, if the journal file does appear to contain
4320 ** a valid header following Pager.journalOff, then write a 0x00
4321 ** byte to the start of it to prevent it from being recognized.
danielk1977bea2a942009-01-20 17:06:27 +00004322 **
4323 ** Variable iNextHdrOffset is set to the offset at which this
4324 ** problematic header will occur, if it exists. aMagic is used
4325 ** as a temporary buffer to inspect the first couple of bytes of
4326 ** the potential journal header.
danielk1977112f7522009-01-08 17:50:45 +00004327 */
drh7b746032009-06-26 12:15:22 +00004328 i64 iNextHdrOffset;
danielk1977bea2a942009-01-20 17:06:27 +00004329 u8 aMagic[8];
danb9780022010-04-21 18:37:57 +00004330 u8 zHeader[sizeof(aJournalMagic)+4];
drh7b746032009-06-26 12:15:22 +00004331
danb9780022010-04-21 18:37:57 +00004332 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
4333 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
drh7b746032009-06-26 12:15:22 +00004334
4335 iNextHdrOffset = journalHdrOffset(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00004336 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
4337 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
danielk1977112f7522009-01-08 17:50:45 +00004338 static const u8 zerobyte = 0;
danielk1977bea2a942009-01-20 17:06:27 +00004339 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
danielk1977112f7522009-01-08 17:50:45 +00004340 }
4341 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
4342 return rc;
4343 }
4344
danielk197776572402004-06-25 02:38:54 +00004345 /* Write the nRec value into the journal file header. If in
4346 ** full-synchronous mode, sync the journal first. This ensures that
4347 ** all data has really hit the disk before nRec is updated to mark
danielk19774cd2cd52007-08-23 14:48:23 +00004348 ** it as a candidate for rollback.
4349 **
4350 ** This is not required if the persistent media supports the
4351 ** SAFE_APPEND property. Because in this case it is not possible
4352 ** for garbage data to be appended to the file, the nRec field
4353 ** is populated with 0xFFFFFFFF when the journal header is written
4354 ** and never needs to be updated.
danielk197776572402004-06-25 02:38:54 +00004355 */
danielk19774cd2cd52007-08-23 14:48:23 +00004356 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh30d53702009-01-06 15:58:57 +00004357 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
drhb0603412007-02-28 04:47:26 +00004358 IOTRACE(("JSYNC %p\n", pPager))
drhc97d8462010-11-19 18:23:35 +00004359 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
danielk1977bea2a942009-01-20 17:06:27 +00004360 if( rc!=SQLITE_OK ) return rc;
drhd8d66e82003-02-12 02:10:15 +00004361 }
drh7b746032009-06-26 12:15:22 +00004362 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
danielk19776f4c73e2009-06-26 07:12:06 +00004363 rc = sqlite3OsWrite(
4364 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
danb9780022010-04-21 18:37:57 +00004365 );
danielk1977bea2a942009-01-20 17:06:27 +00004366 if( rc!=SQLITE_OK ) return rc;
drh968af522003-02-11 14:55:40 +00004367 }
danielk19774cd2cd52007-08-23 14:48:23 +00004368 if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh30d53702009-01-06 15:58:57 +00004369 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
danielk19774cd2cd52007-08-23 14:48:23 +00004370 IOTRACE(("JSYNC %p\n", pPager))
drhc97d8462010-11-19 18:23:35 +00004371 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
4372 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
danielk19774cd2cd52007-08-23 14:48:23 +00004373 );
danielk1977bea2a942009-01-20 17:06:27 +00004374 if( rc!=SQLITE_OK ) return rc;
danielk19774cd2cd52007-08-23 14:48:23 +00004375 }
danielk197745d68822009-01-16 16:23:38 +00004376
dan937ac9d2010-08-03 12:48:45 +00004377 pPager->journalHdr = pPager->journalOff;
4378 if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
4379 pPager->nRec = 0;
4380 rc = writeJournalHdr(pPager);
dan5761dbe2010-08-05 16:08:26 +00004381 if( rc!=SQLITE_OK ) return rc;
dan937ac9d2010-08-03 12:48:45 +00004382 }
4383 }else{
4384 pPager->journalHdr = pPager->journalOff;
4385 }
drh50e5dad2001-09-15 00:57:28 +00004386 }
drh03eb96a2002-11-10 23:32:56 +00004387
dand0864082010-08-02 14:32:52 +00004388 /* Unless the pager is in noSync mode, the journal file was just
4389 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
4390 ** all pages.
4391 */
4392 sqlite3PcacheClearSyncFlags(pPager->pPCache);
4393 pPager->eState = PAGER_WRITER_DBMOD;
4394 assert( assert_pager_state(pPager) );
danielk1977bea2a942009-01-20 17:06:27 +00004395 return SQLITE_OK;
drh50e5dad2001-09-15 00:57:28 +00004396}
4397
4398/*
danielk1977bea2a942009-01-20 17:06:27 +00004399** The argument is the first in a linked list of dirty pages connected
4400** by the PgHdr.pDirty pointer. This function writes each one of the
4401** in-memory pages in the list to the database file. The argument may
4402** be NULL, representing an empty list. In this case this function is
4403** a no-op.
4404**
4405** The pager must hold at least a RESERVED lock when this function
4406** is called. Before writing anything to the database file, this lock
4407** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
4408** SQLITE_BUSY is returned and no data is written to the database file.
4409**
4410** If the pager is a temp-file pager and the actual file-system file
4411** is not yet open, it is created and opened before any data is
4412** written out.
4413**
4414** Once the lock has been upgraded and, if necessary, the file opened,
4415** the pages are written out to the database file in list order. Writing
4416** a page is skipped if it meets either of the following criteria:
4417**
4418** * The page number is greater than Pager.dbSize, or
4419** * The PGHDR_DONT_WRITE flag is set on the page.
4420**
4421** If writing out a page causes the database file to grow, Pager.dbFileSize
4422** is updated accordingly. If page 1 is written out, then the value cached
4423** in Pager.dbFileVers[] is updated to match the new value stored in
4424** the database file.
4425**
4426** If everything is successful, SQLITE_OK is returned. If an IO error
4427** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
4428** be obtained, SQLITE_BUSY is returned.
drh2554f8b2003-01-22 01:26:44 +00004429*/
drh146151c2010-07-07 14:19:13 +00004430static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
danc8649122010-08-10 09:58:57 +00004431 int rc = SQLITE_OK; /* Return code */
drh2554f8b2003-01-22 01:26:44 +00004432
danc8649122010-08-10 09:58:57 +00004433 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
drh146151c2010-07-07 14:19:13 +00004434 assert( !pagerUseWal(pPager) );
dan41113b62016-04-05 21:07:58 +00004435 assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
danc8649122010-08-10 09:58:57 +00004436 assert( pPager->eLock==EXCLUSIVE_LOCK );
dan199f56b2016-04-12 19:09:29 +00004437 assert( isOpen(pPager->fd) || pList->pDirty==0 );
danielk1977bea2a942009-01-20 17:06:27 +00004438
4439 /* If the file is a temp-file has not yet been opened, open it now. It
4440 ** is not possible for rc to be other than SQLITE_OK if this branch
4441 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
4442 */
4443 if( !isOpen(pPager->fd) ){
4444 assert( pPager->tempFile && rc==SQLITE_OK );
4445 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
danielk19779eed5052004-06-04 10:38:30 +00004446 }
4447
drh9ff27ec2010-05-19 19:26:05 +00004448 /* Before the first write, give the VFS a hint of what the final
4449 ** file size will be.
4450 */
dan7fb574e2010-07-07 16:18:45 +00004451 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
daneb97b292013-03-20 14:26:59 +00004452 if( rc==SQLITE_OK
dan3719f5f2013-05-23 10:13:18 +00004453 && pPager->dbHintSize<pPager->dbSize
4454 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
daneb97b292013-03-20 14:26:59 +00004455 ){
drh9ff27ec2010-05-19 19:26:05 +00004456 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
drhc02372c2012-01-10 17:59:59 +00004457 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
danc8649122010-08-10 09:58:57 +00004458 pPager->dbHintSize = pPager->dbSize;
drh9ff27ec2010-05-19 19:26:05 +00004459 }
4460
danielk1977bea2a942009-01-20 17:06:27 +00004461 while( rc==SQLITE_OK && pList ){
4462 Pgno pgno = pList->pgno;
danielk19777a2b1ee2007-08-21 14:27:01 +00004463
danielk1977687566d2004-11-02 12:56:41 +00004464 /* If there are dirty pages in the page cache with page numbers greater
danielk1977f90b7262009-01-07 15:18:20 +00004465 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
danielk1977687566d2004-11-02 12:56:41 +00004466 ** make the file smaller (presumably by auto-vacuum code). Do not write
4467 ** any such pages to the file.
danielk1977bea2a942009-01-20 17:06:27 +00004468 **
4469 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
drh5b47efa2010-02-12 18:18:39 +00004470 ** set (set by sqlite3PagerDontWrite()).
danielk1977687566d2004-11-02 12:56:41 +00004471 */
danielk1977bea2a942009-01-20 17:06:27 +00004472 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
drh85d2bd22009-06-11 00:47:20 +00004473 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
4474 char *pData; /* Data to write */
4475
dan51133ea2010-07-30 15:43:13 +00004476 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
drhd40d7ec2011-01-16 00:56:19 +00004477 if( pList->pgno==1 ) pager_write_changecounter(pList);
dan51133ea2010-07-30 15:43:13 +00004478
drhb48c0d52020-02-07 01:12:53 +00004479 pData = pList->pData;
danielk1977443c0592009-01-16 15:21:05 +00004480
danielk1977bea2a942009-01-20 17:06:27 +00004481 /* Write out the page data. */
danf23da962013-03-23 21:00:41 +00004482 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
danielk1977bea2a942009-01-20 17:06:27 +00004483
4484 /* If page 1 was just written, update Pager.dbFileVers to match
4485 ** the value now stored in the database file. If writing this
4486 ** page caused the database file to grow, update dbFileSize.
4487 */
4488 if( pgno==1 ){
danielk197745d68822009-01-16 16:23:38 +00004489 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
4490 }
danielk1977bea2a942009-01-20 17:06:27 +00004491 if( pgno>pPager->dbFileSize ){
4492 pPager->dbFileSize = pgno;
danielk197745d68822009-01-16 16:23:38 +00004493 }
drh9ad3ee42012-03-24 20:06:14 +00004494 pPager->aStat[PAGER_STAT_WRITE]++;
danielk1977bea2a942009-01-20 17:06:27 +00004495
danielk197704103022009-02-03 16:51:24 +00004496 /* Update any backup objects copying the contents of this pager. */
drh0719ee22009-06-18 20:52:47 +00004497 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
danielk197704103022009-02-03 16:51:24 +00004498
danielk1977bea2a942009-01-20 17:06:27 +00004499 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
4500 PAGERID(pPager), pgno, pager_pagehash(pList)));
4501 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
4502 PAGER_INCR(sqlite3_pager_writedb_count);
danielk1977bea2a942009-01-20 17:06:27 +00004503 }else{
4504 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
danielk1977687566d2004-11-02 12:56:41 +00004505 }
dan5f848c32010-08-23 18:19:31 +00004506 pager_set_pagehash(pList);
drh2554f8b2003-01-22 01:26:44 +00004507 pList = pList->pDirty;
4508 }
danielk19778c0a7912008-08-20 14:49:23 +00004509
danielk1977bea2a942009-01-20 17:06:27 +00004510 return rc;
drh2554f8b2003-01-22 01:26:44 +00004511}
4512
4513/*
dan459564f2010-06-03 12:35:28 +00004514** Ensure that the sub-journal file is open. If it is already open, this
4515** function is a no-op.
4516**
4517** SQLITE_OK is returned if everything goes according to plan. An
4518** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
4519** fails.
4520*/
4521static int openSubJournal(Pager *pPager){
4522 int rc = SQLITE_OK;
4523 if( !isOpen(pPager->sjfd) ){
dan6e763262016-02-29 20:18:21 +00004524 const int flags = SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_READWRITE
4525 | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE
4526 | SQLITE_OPEN_DELETEONCLOSE;
drh8c71a982016-03-07 17:37:37 +00004527 int nStmtSpill = sqlite3Config.nStmtSpill;
dan459564f2010-06-03 12:35:28 +00004528 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
drh8c71a982016-03-07 17:37:37 +00004529 nStmtSpill = -1;
dan459564f2010-06-03 12:35:28 +00004530 }
drh8c71a982016-03-07 17:37:37 +00004531 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
dan459564f2010-06-03 12:35:28 +00004532 }
4533 return rc;
4534}
4535
4536/*
danielk1977bea2a942009-01-20 17:06:27 +00004537** Append a record of the current state of page pPg to the sub-journal.
danielk1977bea2a942009-01-20 17:06:27 +00004538**
4539** If successful, set the bit corresponding to pPg->pgno in the bitvecs
4540** for all open savepoints before returning.
4541**
4542** This function returns SQLITE_OK if everything is successful, an IO
4543** error code if the attempt to write to the sub-journal fails, or
4544** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
4545** bitvec.
danielk1977f2c31ad2009-01-06 13:40:08 +00004546*/
4547static int subjournalPage(PgHdr *pPg){
danielk1977651a52f2009-02-04 10:09:04 +00004548 int rc = SQLITE_OK;
danielk1977f2c31ad2009-01-06 13:40:08 +00004549 Pager *pPager = pPg->pPager;
dan459564f2010-06-03 12:35:28 +00004550 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
drh85d2bd22009-06-11 00:47:20 +00004551
dan459564f2010-06-03 12:35:28 +00004552 /* Open the sub-journal, if it has not already been opened */
4553 assert( pPager->useJournal );
4554 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
4555 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
drh7ed91f22010-04-29 22:34:07 +00004556 assert( pagerUseWal(pPager)
drh5dee6af2013-12-13 20:45:50 +00004557 || pageInJournal(pPager, pPg)
dan7c246102010-04-12 19:00:29 +00004558 || pPg->pgno>pPager->dbOrigSize
4559 );
dan459564f2010-06-03 12:35:28 +00004560 rc = openSubJournal(pPager);
4561
4562 /* If the sub-journal was opened successfully (or was already open),
4563 ** write the journal record into the file. */
danielk1977651a52f2009-02-04 10:09:04 +00004564 if( rc==SQLITE_OK ){
dan459564f2010-06-03 12:35:28 +00004565 void *pData = pPg->pData;
dan7c3210e2011-12-21 18:04:41 +00004566 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
dan459564f2010-06-03 12:35:28 +00004567 char *pData2;
drh614c6a02017-05-10 12:49:50 +00004568 pData2 = pData;
dan459564f2010-06-03 12:35:28 +00004569 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
4570 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
4571 if( rc==SQLITE_OK ){
4572 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
4573 }
danielk1977651a52f2009-02-04 10:09:04 +00004574 }
danielk1977f2c31ad2009-01-06 13:40:08 +00004575 }
4576 if( rc==SQLITE_OK ){
danielk1977bea2a942009-01-20 17:06:27 +00004577 pPager->nSubRec++;
danielk1977f2c31ad2009-01-06 13:40:08 +00004578 assert( pPager->nSavepoint>0 );
4579 rc = addToSavepointBitvecs(pPager, pPg->pgno);
4580 }
4581 return rc;
4582}
drh60e32ed2015-06-29 19:08:18 +00004583static int subjournalPageIfRequired(PgHdr *pPg){
4584 if( subjRequiresPage(pPg) ){
4585 return subjournalPage(pPg);
4586 }else{
4587 return SQLITE_OK;
4588 }
4589}
danielk1977f2c31ad2009-01-06 13:40:08 +00004590
dan3306c4a2010-04-23 19:15:00 +00004591/*
danielk19778c0a7912008-08-20 14:49:23 +00004592** This function is called by the pcache layer when it has reached some
danielk1977bea2a942009-01-20 17:06:27 +00004593** soft memory limit. The first argument is a pointer to a Pager object
4594** (cast as a void*). The pager is always 'purgeable' (not an in-memory
4595** database). The second argument is a reference to a page that is
4596** currently dirty but has no outstanding references. The page
4597** is always associated with the Pager object passed as the first
4598** argument.
4599**
4600** The job of this function is to make pPg clean by writing its contents
4601** out to the database file, if possible. This may involve syncing the
4602** journal file.
4603**
4604** If successful, sqlite3PcacheMakeClean() is called on the page and
4605** SQLITE_OK returned. If an IO error occurs while trying to make the
4606** page clean, the IO error code is returned. If the page cannot be
4607** made clean for some other reason, but no error occurs, then SQLITE_OK
4608** is returned by sqlite3PcacheMakeClean() is not called.
drh2554f8b2003-01-22 01:26:44 +00004609*/
danielk1977a858aa22008-08-22 16:22:17 +00004610static int pagerStress(void *p, PgHdr *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004611 Pager *pPager = (Pager *)p;
danielk19778c0a7912008-08-20 14:49:23 +00004612 int rc = SQLITE_OK;
drh8f2e9a12008-02-26 14:46:04 +00004613
danielk1977bea2a942009-01-20 17:06:27 +00004614 assert( pPg->pPager==pPager );
4615 assert( pPg->flags&PGHDR_DIRTY );
4616
drh40c39412013-08-16 20:42:20 +00004617 /* The doNotSpill NOSYNC bit is set during times when doing a sync of
drh314f30d2010-06-24 18:36:33 +00004618 ** journal (and adding a new header) is not allowed. This occurs
4619 ** during calls to sqlite3PagerWrite() while trying to journal multiple
4620 ** pages belonging to the same sector.
drh7cf4c7a2010-06-24 14:52:25 +00004621 **
drh40c39412013-08-16 20:42:20 +00004622 ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
4623 ** regardless of whether or not a sync is required. This is set during
4624 ** a rollback or by user request, respectively.
drh314f30d2010-06-24 18:36:33 +00004625 **
drh00284862010-08-17 18:37:12 +00004626 ** Spilling is also prohibited when in an error state since that could
peter.d.reid60ec9142014-09-06 16:39:46 +00004627 ** lead to database corruption. In the current implementation it
drhc3031c62014-08-26 15:06:49 +00004628 ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
drh00284862010-08-17 18:37:12 +00004629 ** while in the error state, hence it is impossible for this routine to
4630 ** be called in the error state. Nevertheless, we include a NEVER()
4631 ** test for the error state as a safeguard against future changes.
drh7cf4c7a2010-06-24 14:52:25 +00004632 */
drh00284862010-08-17 18:37:12 +00004633 if( NEVER(pPager->errCode) ) return SQLITE_OK;
drh40c39412013-08-16 20:42:20 +00004634 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
4635 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
4636 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
4637 if( pPager->doNotSpill
4638 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
4639 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
4640 ){
drh7cf4c7a2010-06-24 14:52:25 +00004641 return SQLITE_OK;
4642 }
4643
drhffc78a42018-03-14 14:53:50 +00004644 pPager->aStat[PAGER_STAT_SPILL]++;
dan4a4b01d2010-04-16 11:30:18 +00004645 pPg->pDirty = 0;
drh7ed91f22010-04-29 22:34:07 +00004646 if( pagerUseWal(pPager) ){
drh01be4632015-09-03 15:17:12 +00004647#ifndef SQLITE_OMIT_CONCURRENT
danbf3cf572015-08-24 19:56:04 +00004648 /* If the transaction is a "BEGIN CONCURRENT" transaction, the page
dan3d394342015-07-27 19:31:45 +00004649 ** cannot be flushed to disk. Return early in this case. */
dan773d2d62015-07-29 12:14:28 +00004650 if( pPager->pAllRead ) return SQLITE_OK;
dan04085292015-08-24 16:00:08 +00004651#endif
dan3d394342015-07-27 19:31:45 +00004652
dan4cc6fb62010-04-15 16:45:34 +00004653 /* Write a single frame for this page to the log. */
drh60e32ed2015-06-29 19:08:18 +00004654 rc = subjournalPageIfRequired(pPg);
dan4cd78b42010-04-26 16:57:10 +00004655 if( rc==SQLITE_OK ){
drh4eb02a42011-12-16 21:26:26 +00004656 rc = pagerWalFrames(pPager, pPg, 0, 0);
dan4cd78b42010-04-26 16:57:10 +00004657 }
dan4cc6fb62010-04-15 16:45:34 +00004658 }else{
danefe16972017-07-20 19:49:14 +00004659
dand67a9772017-07-20 21:00:03 +00004660#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
danefe16972017-07-20 19:49:14 +00004661 if( pPager->tempFile==0 ){
4662 rc = sqlite3JournalCreate(pPager->jfd);
4663 if( rc!=SQLITE_OK ) return pager_error(pPager, rc);
4664 }
4665#endif
dan4cc6fb62010-04-15 16:45:34 +00004666
4667 /* Sync the journal file if required. */
danc8649122010-08-10 09:58:57 +00004668 if( pPg->flags&PGHDR_NEED_SYNC
4669 || pPager->eState==PAGER_WRITER_CACHEMOD
4670 ){
dan937ac9d2010-08-03 12:48:45 +00004671 rc = syncJournal(pPager, 1);
dan4cc6fb62010-04-15 16:45:34 +00004672 }
4673
dan4cc6fb62010-04-15 16:45:34 +00004674 /* Write the contents of the page out to the database file. */
4675 if( rc==SQLITE_OK ){
dan51133ea2010-07-30 15:43:13 +00004676 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
drh146151c2010-07-07 14:19:13 +00004677 rc = pager_write_pagelist(pPager, pPg);
dan4cc6fb62010-04-15 16:45:34 +00004678 }
danielk1977bea2a942009-01-20 17:06:27 +00004679 }
4680
4681 /* Mark the page as clean. */
danielk1977a858aa22008-08-22 16:22:17 +00004682 if( rc==SQLITE_OK ){
drh30d53702009-01-06 15:58:57 +00004683 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
danielk1977a858aa22008-08-22 16:22:17 +00004684 sqlite3PcacheMakeClean(pPg);
danielk19778c0a7912008-08-20 14:49:23 +00004685 }
danielk1977bea2a942009-01-20 17:06:27 +00004686
dan5653e4d2010-08-12 11:25:47 +00004687 return pager_error(pPager, rc);
drh2554f8b2003-01-22 01:26:44 +00004688}
4689
dan6fa255f2015-10-28 19:46:57 +00004690/*
4691** Flush all unreferenced dirty pages to disk.
4692*/
4693int sqlite3PagerFlush(Pager *pPager){
dandbf67732015-10-29 18:16:40 +00004694 int rc = pPager->errCode;
dan9fb13ab2015-10-29 21:11:22 +00004695 if( !MEMDB ){
4696 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
4697 assert( assert_pager_state(pPager) );
4698 while( rc==SQLITE_OK && pList ){
4699 PgHdr *pNext = pList->pDirty;
4700 if( pList->nRef==0 ){
4701 rc = pagerStress((void*)pPager, pList);
4702 }
4703 pList = pNext;
dan6fa255f2015-10-28 19:46:57 +00004704 }
dan6fa255f2015-10-28 19:46:57 +00004705 }
4706
4707 return rc;
4708}
danielk19778c0a7912008-08-20 14:49:23 +00004709
drh2554f8b2003-01-22 01:26:44 +00004710/*
danielk1977bea2a942009-01-20 17:06:27 +00004711** Allocate and initialize a new Pager object and put a pointer to it
4712** in *ppPager. The pager should eventually be freed by passing it
4713** to sqlite3PagerClose().
4714**
4715** The zFilename argument is the path to the database file to open.
4716** If zFilename is NULL then a randomly-named temporary file is created
4717** and used as the file to be cached. Temporary files are be deleted
4718** automatically when they are closed. If zFilename is ":memory:" then
4719** all information is held in cache. It is never written to disk.
4720** This can be used to implement an in-memory database.
4721**
4722** The nExtra parameter specifies the number of bytes of space allocated
4723** along with each page reference. This space is available to the user
drha2ee5892016-12-09 16:02:00 +00004724** via the sqlite3PagerGetExtra() API. When a new page is allocated, the
4725** first 8 bytes of this space are zeroed but the remainder is uninitialized.
4726** (The extra space is used by btree as the MemPage object.)
danielk1977bea2a942009-01-20 17:06:27 +00004727**
4728** The flags argument is used to specify properties that affect the
4729** operation of the pager. It should be passed some bitwise combination
drh33f111d2012-01-17 15:29:14 +00004730** of the PAGER_* flags.
danielk1977bea2a942009-01-20 17:06:27 +00004731**
4732** The vfsFlags parameter is a bitmask to pass to the flags parameter
4733** of the xOpen() method of the supplied VFS when opening files.
4734**
4735** If the pager object is allocated and the specified file opened
4736** successfully, SQLITE_OK is returned and *ppPager set to point to
4737** the new pager object. If an error occurs, *ppPager is set to NULL
4738** and error code returned. This function may return SQLITE_NOMEM
4739** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
4740** various SQLITE_IO_XXX errors.
4741*/
4742int sqlite3PagerOpen(
4743 sqlite3_vfs *pVfs, /* The virtual file system to use */
4744 Pager **ppPager, /* OUT: Return the Pager structure here */
4745 const char *zFilename, /* Name of the database file to open */
4746 int nExtra, /* Extra bytes append to each in-memory page */
4747 int flags, /* flags controlling this file */
drh4775ecd2009-07-24 19:01:19 +00004748 int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */
4749 void (*xReinit)(DbPage*) /* Function to reinitialize pages */
danielk1977bea2a942009-01-20 17:06:27 +00004750){
4751 u8 *pPtr;
4752 Pager *pPager = 0; /* Pager object to allocate and return */
4753 int rc = SQLITE_OK; /* Return code */
4754 int tempFile = 0; /* True for temp files (incl. in-memory files) */
4755 int memDb = 0; /* True if this is an in-memory file */
drh8d889af2021-05-08 17:18:23 +00004756#ifndef SQLITE_OMIT_DESERIALIZE
drhac442f42018-01-03 01:28:46 +00004757 int memJM = 0; /* Memory journal mode */
drh9c6396e2018-03-06 21:43:19 +00004758#else
4759# define memJM 0
4760#endif
danielk1977bea2a942009-01-20 17:06:27 +00004761 int readOnly = 0; /* True if this is a read-only file */
4762 int journalFileSize; /* Bytes to allocate for each journal fd */
4763 char *zPathname = 0; /* Full path to database file */
4764 int nPathname = 0; /* Number of bytes in zPathname */
4765 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
danielk1977bea2a942009-01-20 17:06:27 +00004766 int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */
drhb2eced52010-08-12 02:41:12 +00004767 u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
dancd74b612011-04-22 19:37:32 +00004768 const char *zUri = 0; /* URI args to copy */
drh746461f2019-11-12 14:43:47 +00004769 int nUriByte = 1; /* Number of bytes of URI args at *zUri */
danielk1977bea2a942009-01-20 17:06:27 +00004770
4771 /* Figure out how much space is required for each journal file-handle
dan2491de22016-02-27 20:14:55 +00004772 ** (there are two of them, the main journal and the sub-journal). */
4773 journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
danielk1977bea2a942009-01-20 17:06:27 +00004774
4775 /* Set the output variable to NULL in case an error occurs. */
4776 *ppPager = 0;
4777
drh75c014c2010-08-30 15:02:28 +00004778#ifndef SQLITE_OMIT_MEMORYDB
4779 if( flags & PAGER_MEMORY ){
4780 memDb = 1;
drhd4e0bb02012-05-27 01:19:04 +00004781 if( zFilename && zFilename[0] ){
drh4ab9d252012-05-26 20:08:49 +00004782 zPathname = sqlite3DbStrDup(0, zFilename);
mistachkinfad30392016-02-13 23:43:46 +00004783 if( zPathname==0 ) return SQLITE_NOMEM_BKPT;
drh4ab9d252012-05-26 20:08:49 +00004784 nPathname = sqlite3Strlen30(zPathname);
4785 zFilename = 0;
4786 }
drh75c014c2010-08-30 15:02:28 +00004787 }
4788#endif
4789
danielk1977bea2a942009-01-20 17:06:27 +00004790 /* Compute and store the full pathname in an allocated buffer pointed
4791 ** to by zPathname, length nPathname. Or, if this is a temporary file,
4792 ** leave both nPathname and zPathname set to 0.
4793 */
4794 if( zFilename && zFilename[0] ){
dancd74b612011-04-22 19:37:32 +00004795 const char *z;
danielk1977bea2a942009-01-20 17:06:27 +00004796 nPathname = pVfs->mxPathname+1;
dana8793422012-06-07 07:24:04 +00004797 zPathname = sqlite3DbMallocRaw(0, nPathname*2);
danielk1977bea2a942009-01-20 17:06:27 +00004798 if( zPathname==0 ){
mistachkinfad30392016-02-13 23:43:46 +00004799 return SQLITE_NOMEM_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00004800 }
drh75c014c2010-08-30 15:02:28 +00004801 zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
4802 rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
drhc398c652019-11-22 00:42:01 +00004803 if( rc!=SQLITE_OK ){
4804 if( rc==SQLITE_OK_SYMLINK ){
4805 if( vfsFlags & SQLITE_OPEN_NOFOLLOW ){
4806 rc = SQLITE_CANTOPEN_SYMLINK;
4807 }else{
4808 rc = SQLITE_OK;
4809 }
4810 }
4811 }
danielk1977bea2a942009-01-20 17:06:27 +00004812 nPathname = sqlite3Strlen30(zPathname);
dancd74b612011-04-22 19:37:32 +00004813 z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
4814 while( *z ){
drh746461f2019-11-12 14:43:47 +00004815 z += strlen(z)+1;
4816 z += strlen(z)+1;
dancd74b612011-04-22 19:37:32 +00004817 }
dan879f1a12019-12-20 20:03:21 +00004818 nUriByte = (int)(&z[1] - zUri);
drh746461f2019-11-12 14:43:47 +00004819 assert( nUriByte>=1 );
danielk1977bea2a942009-01-20 17:06:27 +00004820 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
4821 /* This branch is taken when the journal path required by
4822 ** the database being opened will be more than pVfs->mxPathname
4823 ** bytes in length. This means the database cannot be opened,
4824 ** as it will not be possible to open the journal file or even
4825 ** check for a hot-journal before reading.
4826 */
drh9978c972010-02-23 17:36:32 +00004827 rc = SQLITE_CANTOPEN_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00004828 }
4829 if( rc!=SQLITE_OK ){
dana8793422012-06-07 07:24:04 +00004830 sqlite3DbFree(0, zPathname);
danielk1977bea2a942009-01-20 17:06:27 +00004831 return rc;
4832 }
4833 }
4834
4835 /* Allocate memory for the Pager structure, PCache object, the
4836 ** three file descriptors, the database file name and the journal
4837 ** file name. The layout in memory is as follows:
4838 **
4839 ** Pager object (sizeof(Pager) bytes)
4840 ** PCache object (sqlite3PcacheSize() bytes)
4841 ** Database file handle (pVfs->szOsFile bytes)
4842 ** Sub-journal file handle (journalFileSize bytes)
4843 ** Main journal file handle (journalFileSize bytes)
drh480620c2020-04-21 01:06:35 +00004844 ** Ptr back to the Pager (sizeof(Pager*) bytes)
drh532b0d22020-01-27 14:40:44 +00004845 ** \0\0\0\0 database prefix (4 bytes)
danielk1977bea2a942009-01-20 17:06:27 +00004846 ** Database file name (nPathname+1 bytes)
drh8875b9e2020-01-10 18:05:55 +00004847 ** URI query parameters (nUriByte bytes)
drh532b0d22020-01-27 14:40:44 +00004848 ** Journal filename (nPathname+8+1 bytes)
4849 ** WAL filename (nPathname+4+1 bytes)
4850 ** \0\0\0 terminator (3 bytes)
4851 **
4852 ** Some 3rd-party software, over which we have no control, depends on
4853 ** the specific order of the filenames and the \0 separators between them
4854 ** so that it can (for example) find the database filename given the WAL
4855 ** filename without using the sqlite3_filename_database() API. This is a
4856 ** misuse of SQLite and a bug in the 3rd-party software, but the 3rd-party
4857 ** software is in widespread use, so we try to avoid changing the filename
4858 ** order and formatting if possible. In particular, the details of the
4859 ** filename format expected by 3rd-party software should be as follows:
4860 **
4861 ** - Main Database Path
4862 ** - \0
4863 ** - Multiple URI components consisting of:
4864 ** - Key
4865 ** - \0
4866 ** - Value
4867 ** - \0
4868 ** - \0
4869 ** - Journal Path
4870 ** - \0
4871 ** - WAL Path (zWALName)
4872 ** - \0
drh4defddd2020-02-18 19:49:48 +00004873 **
4874 ** The sqlite3_create_filename() interface and the databaseFilename() utility
4875 ** that is used by sqlite3_filename_database() and kin also depend on the
4876 ** specific formatting and order of the various filenames, so if the format
4877 ** changes here, be sure to change it there as well.
danielk1977bea2a942009-01-20 17:06:27 +00004878 */
4879 pPtr = (u8 *)sqlite3MallocZero(
drh8875b9e2020-01-10 18:05:55 +00004880 ROUND8(sizeof(*pPager)) + /* Pager structure */
4881 ROUND8(pcacheSize) + /* PCache object */
4882 ROUND8(pVfs->szOsFile) + /* The main db file */
4883 journalFileSize * 2 + /* The two journal files */
drh480620c2020-04-21 01:06:35 +00004884 sizeof(pPager) + /* Space to hold a pointer */
drh532b0d22020-01-27 14:40:44 +00004885 4 + /* Database prefix */
drh80804032020-01-11 16:08:31 +00004886 nPathname + 1 + /* database filename */
4887 nUriByte + /* query parameters */
drh532b0d22020-01-27 14:40:44 +00004888 nPathname + 8 + 1 + /* Journal filename */
4889#ifndef SQLITE_OMIT_WAL
4890 nPathname + 4 + 1 + /* WAL filename */
4891#endif
4892 3 /* Terminator */
danielk1977bea2a942009-01-20 17:06:27 +00004893 );
shane60a4b532009-05-06 18:57:09 +00004894 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
danielk1977bea2a942009-01-20 17:06:27 +00004895 if( !pPtr ){
dana8793422012-06-07 07:24:04 +00004896 sqlite3DbFree(0, zPathname);
mistachkinfad30392016-02-13 23:43:46 +00004897 return SQLITE_NOMEM_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00004898 }
drh8875b9e2020-01-10 18:05:55 +00004899 pPager = (Pager*)pPtr; pPtr += ROUND8(sizeof(*pPager));
4900 pPager->pPCache = (PCache*)pPtr; pPtr += ROUND8(pcacheSize);
4901 pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile);
4902 pPager->sjfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
4903 pPager->jfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
drhea598cb2009-04-05 12:22:08 +00004904 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
drh480620c2020-04-21 01:06:35 +00004905 memcpy(pPtr, &pPager, sizeof(pPager)); pPtr += sizeof(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00004906
drh532b0d22020-01-27 14:40:44 +00004907 /* Fill in the Pager.zFilename and pPager.zQueryParam fields */
4908 pPtr += 4; /* Skip zero prefix */
4909 pPager->zFilename = (char*)pPtr;
4910 if( nPathname>0 ){
4911 memcpy(pPtr, zPathname, nPathname); pPtr += nPathname + 1;
4912 if( zUri ){
4913 memcpy(pPtr, zUri, nUriByte); pPtr += nUriByte;
4914 }else{
4915 pPtr++;
4916 }
4917 }
4918
drh80804032020-01-11 16:08:31 +00004919
4920 /* Fill in Pager.zJournal */
drh80804032020-01-11 16:08:31 +00004921 if( nPathname>0 ){
4922 pPager->zJournal = (char*)pPtr;
4923 memcpy(pPtr, zPathname, nPathname); pPtr += nPathname;
4924 memcpy(pPtr, "-journal",8); pPtr += 8 + 1;
4925#ifdef SQLITE_ENABLE_8_3_NAMES
4926 sqlite3FileSuffix3(zFilename,pPager->zJournal);
4927 pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1);
dan3e875ef2010-07-05 19:03:35 +00004928#endif
drh80804032020-01-11 16:08:31 +00004929 }else{
4930 pPager->zJournal = 0;
danielk1977bea2a942009-01-20 17:06:27 +00004931 }
drh8875b9e2020-01-10 18:05:55 +00004932
danielk1977bea2a942009-01-20 17:06:27 +00004933#ifndef SQLITE_OMIT_WAL
drh8875b9e2020-01-10 18:05:55 +00004934 /* Fill in Pager.zWal */
drh80804032020-01-11 16:08:31 +00004935 if( nPathname>0 ){
4936 pPager->zWal = (char*)pPtr;
4937 memcpy(pPtr, zPathname, nPathname); pPtr += nPathname;
4938 memcpy(pPtr, "-wal", 4); pPtr += 4 + 1;
4939#ifdef SQLITE_ENABLE_8_3_NAMES
4940 sqlite3FileSuffix3(zFilename, pPager->zWal);
4941 pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1);
4942#endif
4943 }else{
4944 pPager->zWal = 0;
drh80804032020-01-11 16:08:31 +00004945 }
danielk1977bea2a942009-01-20 17:06:27 +00004946#endif
drhe85e1da2021-10-01 21:01:07 +00004947 (void)pPtr; /* Suppress warning about unused pPtr value */
drh8875b9e2020-01-10 18:05:55 +00004948
drh8875b9e2020-01-10 18:05:55 +00004949 if( nPathname ) sqlite3DbFree(0, zPathname);
danielk1977bea2a942009-01-20 17:06:27 +00004950 pPager->pVfs = pVfs;
4951 pPager->vfsFlags = vfsFlags;
4952
4953 /* Open the pager file.
4954 */
drh8c96a6e2010-08-31 01:09:15 +00004955 if( zFilename && zFilename[0] ){
danielk1977bea2a942009-01-20 17:06:27 +00004956 int fout = 0; /* VFS flags returned by xOpen() */
4957 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
drh8c96a6e2010-08-31 01:09:15 +00004958 assert( !memDb );
drh8d889af2021-05-08 17:18:23 +00004959#ifndef SQLITE_OMIT_DESERIALIZE
drh021e2282021-10-23 20:32:27 +00004960 pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
drh9c6396e2018-03-06 21:43:19 +00004961#endif
drhac442f42018-01-03 01:28:46 +00004962 readOnly = (fout&SQLITE_OPEN_READONLY)!=0;
danielk1977bea2a942009-01-20 17:06:27 +00004963
4964 /* If the file was successfully opened for read/write access,
4965 ** choose a default page size in case we have to create the
4966 ** database file. The default page size is the maximum of:
4967 **
4968 ** + SQLITE_DEFAULT_PAGE_SIZE,
4969 ** + The value returned by sqlite3OsSectorSize()
4970 ** + The largest page size that can be written atomically.
4971 */
drhd1ae96d2014-05-01 01:13:08 +00004972 if( rc==SQLITE_OK ){
drh6451c2b2014-05-07 15:32:03 +00004973 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
drhd1ae96d2014-05-01 01:13:08 +00004974 if( !readOnly ){
drhd1ae96d2014-05-01 01:13:08 +00004975 setSectorSize(pPager);
4976 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
4977 if( szPageDflt<pPager->sectorSize ){
4978 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
4979 szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
4980 }else{
4981 szPageDflt = (u32)pPager->sectorSize;
danielk1977bea2a942009-01-20 17:06:27 +00004982 }
4983 }
drhd1ae96d2014-05-01 01:13:08 +00004984#ifdef SQLITE_ENABLE_ATOMIC_WRITE
4985 {
4986 int ii;
4987 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
4988 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
4989 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
4990 for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
4991 if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
4992 szPageDflt = ii;
4993 }
4994 }
4995 }
danielk1977bea2a942009-01-20 17:06:27 +00004996#endif
drh6451c2b2014-05-07 15:32:03 +00004997 }
drh8875b9e2020-01-10 18:05:55 +00004998 pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0);
drh6451c2b2014-05-07 15:32:03 +00004999 if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0
drh8875b9e2020-01-10 18:05:55 +00005000 || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){
drh6451c2b2014-05-07 15:32:03 +00005001 vfsFlags |= SQLITE_OPEN_READONLY;
5002 goto act_like_temp_file;
drhd1ae96d2014-05-01 01:13:08 +00005003 }
danielk1977bea2a942009-01-20 17:06:27 +00005004 }
5005 }else{
5006 /* If a temporary file is requested, it is not opened immediately.
5007 ** In this case we accept the default page size and delay actually
5008 ** opening the file until the first call to OsWrite().
5009 **
5010 ** This branch is also run for an in-memory database. An in-memory
5011 ** database is the same as a temp-file that is never written out to
5012 ** disk and uses an in-memory rollback journal.
drh57fe1362014-05-01 01:49:22 +00005013 **
5014 ** This branch also runs for files marked as immutable.
danielk1977bea2a942009-01-20 17:06:27 +00005015 */
drhd1ae96d2014-05-01 01:13:08 +00005016act_like_temp_file:
danielk1977bea2a942009-01-20 17:06:27 +00005017 tempFile = 1;
drh57fe1362014-05-01 01:49:22 +00005018 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
drhe399ac22015-06-29 18:14:02 +00005019 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
drh57fe1362014-05-01 01:49:22 +00005020 pPager->noLock = 1; /* Do no locking */
drhaed24602009-06-11 17:32:45 +00005021 readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
danielk1977bea2a942009-01-20 17:06:27 +00005022 }
5023
5024 /* The following call to PagerSetPagesize() serves to set the value of
5025 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
5026 */
5027 if( rc==SQLITE_OK ){
5028 assert( pPager->memDb==0 );
drhfa9601a2009-06-18 17:22:39 +00005029 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
danielk1977bea2a942009-01-20 17:06:27 +00005030 testcase( rc!=SQLITE_OK );
5031 }
5032
drhc3031c62014-08-26 15:06:49 +00005033 /* Initialize the PCache object. */
5034 if( rc==SQLITE_OK ){
drhc3031c62014-08-26 15:06:49 +00005035 nExtra = ROUND8(nExtra);
drha2ee5892016-12-09 16:02:00 +00005036 assert( nExtra>=8 && nExtra<1000 );
drhc3031c62014-08-26 15:06:49 +00005037 rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb,
drhe399ac22015-06-29 18:14:02 +00005038 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
drhc3031c62014-08-26 15:06:49 +00005039 }
5040
5041 /* If an error occurred above, free the Pager structure and close the file.
danielk1977bea2a942009-01-20 17:06:27 +00005042 */
5043 if( rc!=SQLITE_OK ){
danielk1977bea2a942009-01-20 17:06:27 +00005044 sqlite3OsClose(pPager->fd);
drhc3031c62014-08-26 15:06:49 +00005045 sqlite3PageFree(pPager->pTmpSpace);
danielk1977bea2a942009-01-20 17:06:27 +00005046 sqlite3_free(pPager);
5047 return rc;
5048 }
5049
danielk1977bea2a942009-01-20 17:06:27 +00005050 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
5051 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
5052
5053 pPager->useJournal = (u8)useJournal;
danielk1977bea2a942009-01-20 17:06:27 +00005054 /* pPager->stmtOpen = 0; */
5055 /* pPager->stmtInUse = 0; */
5056 /* pPager->nRef = 0; */
danielk1977bea2a942009-01-20 17:06:27 +00005057 /* pPager->stmtSize = 0; */
5058 /* pPager->stmtJSize = 0; */
5059 /* pPager->nPage = 0; */
5060 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
5061 /* pPager->state = PAGER_UNLOCK; */
danielk1977bea2a942009-01-20 17:06:27 +00005062 /* pPager->errMask = 0; */
5063 pPager->tempFile = (u8)tempFile;
5064 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
5065 || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
5066 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
5067 pPager->exclusiveMode = (u8)tempFile;
5068 pPager->changeCountDone = pPager->tempFile;
5069 pPager->memDb = (u8)memDb;
5070 pPager->readOnly = (u8)readOnly;
drh4775ecd2009-07-24 19:01:19 +00005071 assert( useJournal || pPager->tempFile );
5072 pPager->noSync = pPager->tempFile;
drh4eb02a42011-12-16 21:26:26 +00005073 if( pPager->noSync ){
5074 assert( pPager->fullSync==0 );
drh6841b1c2016-02-03 19:20:15 +00005075 assert( pPager->extraSync==0 );
drh4eb02a42011-12-16 21:26:26 +00005076 assert( pPager->syncFlags==0 );
5077 assert( pPager->walSyncFlags==0 );
drh4eb02a42011-12-16 21:26:26 +00005078 }else{
5079 pPager->fullSync = 1;
drh6841b1c2016-02-03 19:20:15 +00005080 pPager->extraSync = 0;
drh4eb02a42011-12-16 21:26:26 +00005081 pPager->syncFlags = SQLITE_SYNC_NORMAL;
drhdaaae7b2017-08-25 01:14:43 +00005082 pPager->walSyncFlags = SQLITE_SYNC_NORMAL | (SQLITE_SYNC_NORMAL<<2);
drh4eb02a42011-12-16 21:26:26 +00005083 }
danielk1977bea2a942009-01-20 17:06:27 +00005084 /* pPager->pFirst = 0; */
5085 /* pPager->pFirstSynced = 0; */
5086 /* pPager->pLast = 0; */
drhfa9601a2009-06-18 17:22:39 +00005087 pPager->nExtra = (u16)nExtra;
danielk1977bea2a942009-01-20 17:06:27 +00005088 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
5089 assert( isOpen(pPager->fd) || tempFile );
5090 setSectorSize(pPager);
drh4775ecd2009-07-24 19:01:19 +00005091 if( !useJournal ){
5092 pPager->journalMode = PAGER_JOURNALMODE_OFF;
drhac442f42018-01-03 01:28:46 +00005093 }else if( memDb || memJM ){
danielk1977bea2a942009-01-20 17:06:27 +00005094 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
5095 }
5096 /* pPager->xBusyHandler = 0; */
5097 /* pPager->pBusyHandlerArg = 0; */
drh4775ecd2009-07-24 19:01:19 +00005098 pPager->xReiniter = xReinit;
drh12e6f682016-12-13 14:32:47 +00005099 setGetterMethod(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00005100 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
drh9b4c59f2013-04-15 17:03:42 +00005101 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
drh29391c52010-03-05 20:17:45 +00005102
danielk1977bea2a942009-01-20 17:06:27 +00005103 *ppPager = pPager;
5104 return SQLITE_OK;
5105}
5106
drh480620c2020-04-21 01:06:35 +00005107/*
5108** Return the sqlite3_file for the main database given the name
5109** of the corresonding WAL or Journal name as passed into
5110** xOpen.
5111*/
5112sqlite3_file *sqlite3_database_file_object(const char *zName){
5113 Pager *pPager;
5114 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
5115 zName--;
5116 }
5117 pPager = *(Pager**)(zName - 4 - sizeof(Pager*));
5118 return pPager->fd;
5119}
danielk1977bea2a942009-01-20 17:06:27 +00005120
5121
5122/*
5123** This function is called after transitioning from PAGER_UNLOCK to
5124** PAGER_SHARED state. It tests if there is a hot journal present in
5125** the file-system for the given pager. A hot journal is one that
5126** needs to be played back. According to this function, a hot-journal
danielk1977ee8b7992009-03-26 17:13:06 +00005127** file exists if the following criteria are met:
danielk1977bea2a942009-01-20 17:06:27 +00005128**
5129** * The journal file exists in the file system, and
5130** * No process holds a RESERVED or greater lock on the database file, and
danielk1977ee8b7992009-03-26 17:13:06 +00005131** * The database file itself is greater than 0 bytes in size, and
5132** * The first byte of the journal file exists and is not 0x00.
drh165ffe92005-03-15 17:09:30 +00005133**
5134** If the current size of the database file is 0 but a journal file
5135** exists, that is probably an old journal left over from a prior
danielk1977bea2a942009-01-20 17:06:27 +00005136** database with the same name. In this case the journal file is
5137** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
5138** is returned.
drh82ed1e52008-04-25 12:25:42 +00005139**
drh067b92b2020-06-19 15:24:12 +00005140** This routine does not check if there is a super-journal filename
5141** at the end of the file. If there is, and that super-journal file
danielk1977ee8b7992009-03-26 17:13:06 +00005142** does not exist, then the journal file is not really hot. In this
5143** case this routine will return a false-positive. The pager_playback()
5144** routine will discover that the journal file is not really hot and
5145** will not roll it back.
danielk1977bea2a942009-01-20 17:06:27 +00005146**
5147** If a hot-journal file is found to exist, *pExists is set to 1 and
5148** SQLITE_OK returned. If no hot-journal file is present, *pExists is
5149** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
5150** to determine whether or not a hot-journal file exists, the IO error
5151** code is returned and the value of *pExists is undefined.
drh165ffe92005-03-15 17:09:30 +00005152*/
danielk1977d300b8a2008-08-01 10:50:23 +00005153static int hasHotJournal(Pager *pPager, int *pExists){
danielk1977bea2a942009-01-20 17:06:27 +00005154 sqlite3_vfs * const pVfs = pPager->pVfs;
dan2a321c72010-06-16 19:04:23 +00005155 int rc = SQLITE_OK; /* Return code */
5156 int exists = 1; /* True if a journal file is present */
5157 int jrnlOpen = !!isOpen(pPager->jfd);
danielk1977bea2a942009-01-20 17:06:27 +00005158
drhd05c2232009-07-24 21:23:15 +00005159 assert( pPager->useJournal );
danielk1977bea2a942009-01-20 17:06:27 +00005160 assert( isOpen(pPager->fd) );
dande1ae342010-08-06 12:00:27 +00005161 assert( pPager->eState==PAGER_OPEN );
dand0864082010-08-02 14:32:52 +00005162
dan8ce49d62010-06-19 18:12:02 +00005163 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
5164 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
5165 ));
danielk1977bea2a942009-01-20 17:06:27 +00005166
danielk1977d300b8a2008-08-01 10:50:23 +00005167 *pExists = 0;
dan2a321c72010-06-16 19:04:23 +00005168 if( !jrnlOpen ){
5169 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
5170 }
drh0a846f92008-08-25 17:23:29 +00005171 if( rc==SQLITE_OK && exists ){
dan431b0b42010-08-04 19:14:22 +00005172 int locked = 0; /* True if some process holds a RESERVED lock */
drhf0039ad2009-05-29 00:30:30 +00005173
5174 /* Race condition here: Another process might have been holding the
5175 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
5176 ** call above, but then delete the journal and drop the lock before
5177 ** we get to the following sqlite3OsCheckReservedLock() call. If that
5178 ** is the case, this routine might think there is a hot journal when
5179 ** in fact there is none. This results in a false-positive which will
drh9fe769f2009-05-29 11:57:38 +00005180 ** be dealt with by the playback routine. Ticket #3883.
drhf0039ad2009-05-29 00:30:30 +00005181 */
drh0a846f92008-08-25 17:23:29 +00005182 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
danielk1977bea2a942009-01-20 17:06:27 +00005183 if( rc==SQLITE_OK && !locked ){
dan763afe62010-08-03 06:42:39 +00005184 Pgno nPage; /* Number of pages in database file */
danielk1977ee8b7992009-03-26 17:13:06 +00005185
drh835f22d2016-04-25 19:20:56 +00005186 assert( pPager->tempFile==0 );
dan763afe62010-08-03 06:42:39 +00005187 rc = pagerPagecount(pPager, &nPage);
danielk1977bea2a942009-01-20 17:06:27 +00005188 if( rc==SQLITE_OK ){
drhf3ccc382014-03-07 14:57:07 +00005189 /* If the database is zero pages in size, that means that either (1) the
5190 ** journal is a remnant from a prior database with the same name where
5191 ** the database file but not the journal was deleted, or (2) the initial
5192 ** transaction that populates a new database is being rolled back.
5193 ** In either case, the journal file can be deleted. However, take care
5194 ** not to delete the journal file if it is already open due to
5195 ** journal_mode=PERSIST.
5196 */
mistachkineb443922014-03-07 03:31:35 +00005197 if( nPage==0 && !jrnlOpen ){
drhcc0acb22009-05-29 10:55:29 +00005198 sqlite3BeginBenignMalloc();
dan4e004aa2010-08-05 15:30:22 +00005199 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
drhf0039ad2009-05-29 00:30:30 +00005200 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
dan76de8a72010-10-22 13:55:50 +00005201 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
drhf0039ad2009-05-29 00:30:30 +00005202 }
drhcc0acb22009-05-29 10:55:29 +00005203 sqlite3EndBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00005204 }else{
danielk1977ee8b7992009-03-26 17:13:06 +00005205 /* The journal file exists and no other connection has a reserved
5206 ** or greater lock on the database file. Now check that there is
5207 ** at least one non-zero bytes at the start of the journal file.
5208 ** If there is, then we consider this journal to be hot. If not,
5209 ** it can be ignored.
5210 */
dan2a321c72010-06-16 19:04:23 +00005211 if( !jrnlOpen ){
5212 int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
5213 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
5214 }
danielk1977ee8b7992009-03-26 17:13:06 +00005215 if( rc==SQLITE_OK ){
5216 u8 first = 0;
5217 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
5218 if( rc==SQLITE_IOERR_SHORT_READ ){
5219 rc = SQLITE_OK;
5220 }
dan2a321c72010-06-16 19:04:23 +00005221 if( !jrnlOpen ){
5222 sqlite3OsClose(pPager->jfd);
5223 }
danielk1977ee8b7992009-03-26 17:13:06 +00005224 *pExists = (first!=0);
drhcc0acb22009-05-29 10:55:29 +00005225 }else if( rc==SQLITE_CANTOPEN ){
drhf0039ad2009-05-29 00:30:30 +00005226 /* If we cannot open the rollback journal file in order to see if
peter.d.reid60ec9142014-09-06 16:39:46 +00005227 ** it has a zero header, that might be due to an I/O error, or
drhf0039ad2009-05-29 00:30:30 +00005228 ** it might be due to the race condition described above and in
5229 ** ticket #3883. Either way, assume that the journal is hot.
5230 ** This might be a false positive. But if it is, then the
5231 ** automatic journal playback and recovery mechanism will deal
5232 ** with it under an EXCLUSIVE lock where we do not need to
5233 ** worry so much with race conditions.
5234 */
5235 *pExists = 1;
5236 rc = SQLITE_OK;
danielk1977ee8b7992009-03-26 17:13:06 +00005237 }
danielk1977bea2a942009-01-20 17:06:27 +00005238 }
danielk1977861f7452008-06-05 11:39:11 +00005239 }
5240 }
drhbb5f18d2007-04-06 18:23:17 +00005241 }
danielk1977ee8b7992009-03-26 17:13:06 +00005242
danielk1977d300b8a2008-08-01 10:50:23 +00005243 return rc;
drh165ffe92005-03-15 17:09:30 +00005244}
5245
dana470aeb2010-04-21 11:43:38 +00005246/*
danielk197789bc4bc2009-07-21 19:25:24 +00005247** This function is called to obtain a shared lock on the database file.
drh9584f582015-11-04 20:22:37 +00005248** It is illegal to call sqlite3PagerGet() until after this function
danielk197789bc4bc2009-07-21 19:25:24 +00005249** has been successfully called. If a shared-lock is already held when
5250** this function is called, it is a no-op.
5251**
5252** The following operations are also performed by this function.
danielk1977393f0682007-03-31 10:00:48 +00005253**
dana81a2202010-08-17 18:15:48 +00005254** 1) If the pager is currently in PAGER_OPEN state (no lock held
danielk1977bea2a942009-01-20 17:06:27 +00005255** on the database file), then an attempt is made to obtain a
5256** SHARED lock on the database file. Immediately after obtaining
5257** the SHARED lock, the file-system is checked for a hot-journal,
5258** which is played back if present. Following any hot-journal
5259** rollback, the contents of the cache are validated by checking
5260** the 'change-counter' field of the database file header and
5261** discarded if they are found to be invalid.
5262**
5263** 2) If the pager is running in exclusive-mode, and there are currently
5264** no outstanding references to any pages, and is in the error state,
5265** then an attempt is made to clear the error state by discarding
5266** the contents of the page cache and rolling back any open journal
5267** file.
5268**
dana81a2202010-08-17 18:15:48 +00005269** If everything is successful, SQLITE_OK is returned. If an IO error
5270** occurs while locking the database, checking for a hot-journal file or
5271** rolling back a journal file, the IO error code is returned.
danielk1977e277be02007-03-23 18:12:06 +00005272*/
danielk197789bc4bc2009-07-21 19:25:24 +00005273int sqlite3PagerSharedLock(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00005274 int rc = SQLITE_OK; /* Return code */
danielk1977e277be02007-03-23 18:12:06 +00005275
drh8a938f92009-07-25 04:12:02 +00005276 /* This routine is only called from b-tree and only when there are no
dan763afe62010-08-03 06:42:39 +00005277 ** outstanding pages. This implies that the pager state should either
dande1ae342010-08-06 12:00:27 +00005278 ** be OPEN or READER. READER is only possible if the pager is or was in
dan6572c162016-04-23 14:55:28 +00005279 ** exclusive access mode. */
drh8a938f92009-07-25 04:12:02 +00005280 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
dan763afe62010-08-03 06:42:39 +00005281 assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +00005282 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
dan6572c162016-04-23 14:55:28 +00005283 assert( pPager->errCode==SQLITE_OK );
drh8a938f92009-07-25 04:12:02 +00005284
dande1ae342010-08-06 12:00:27 +00005285 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
dan431b0b42010-08-04 19:14:22 +00005286 int bHotJournal = 1; /* True if there exists a hot journal-file */
dand0864082010-08-02 14:32:52 +00005287
dan4e004aa2010-08-05 15:30:22 +00005288 assert( !MEMDB );
dan6572c162016-04-23 14:55:28 +00005289 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
dand0864082010-08-02 14:32:52 +00005290
drh33f111d2012-01-17 15:29:14 +00005291 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
5292 if( rc!=SQLITE_OK ){
5293 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
5294 goto failed;
dan9281bf22010-04-13 11:18:40 +00005295 }
danielk1977b3175382008-10-17 18:51:52 +00005296
5297 /* If a journal file exists, and there is no RESERVED lock on the
5298 ** database file, then it either needs to be played back or deleted.
5299 */
dan431b0b42010-08-04 19:14:22 +00005300 if( pPager->eLock<=SHARED_LOCK ){
5301 rc = hasHotJournal(pPager, &bHotJournal);
danielk1977b3175382008-10-17 18:51:52 +00005302 }
dan431b0b42010-08-04 19:14:22 +00005303 if( rc!=SQLITE_OK ){
5304 goto failed;
5305 }
5306 if( bHotJournal ){
dane3664fb2013-03-05 15:09:25 +00005307 if( pPager->readOnly ){
5308 rc = SQLITE_READONLY_ROLLBACK;
5309 goto failed;
5310 }
5311
danielk1977b3175382008-10-17 18:51:52 +00005312 /* Get an EXCLUSIVE lock on the database file. At this point it is
5313 ** important that a RESERVED lock is not obtained on the way to the
5314 ** EXCLUSIVE lock. If it were, another process might open the
5315 ** database file, detect the RESERVED lock, and conclude that the
danielk1977bea2a942009-01-20 17:06:27 +00005316 ** database is safe to read while this process is still rolling the
5317 ** hot-journal back.
danielk1977b3175382008-10-17 18:51:52 +00005318 **
danielk1977bea2a942009-01-20 17:06:27 +00005319 ** Because the intermediate RESERVED lock is not requested, any
5320 ** other process attempting to access the database file will get to
5321 ** this point in the code and fail to obtain its own EXCLUSIVE lock
5322 ** on the database file.
dand0864082010-08-02 14:32:52 +00005323 **
5324 ** Unless the pager is in locking_mode=exclusive mode, the lock is
5325 ** downgraded to SHARED_LOCK before this function returns.
danielk1977e277be02007-03-23 18:12:06 +00005326 */
dan4e004aa2010-08-05 15:30:22 +00005327 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
dand0864082010-08-02 14:32:52 +00005328 if( rc!=SQLITE_OK ){
dand0864082010-08-02 14:32:52 +00005329 goto failed;
danielk1977b3175382008-10-17 18:51:52 +00005330 }
5331
dand0864082010-08-02 14:32:52 +00005332 /* If it is not already open and the file exists on disk, open the
5333 ** journal for read/write access. Write access is required because
5334 ** in exclusive-access mode the file descriptor will be kept open
5335 ** and possibly used for a transaction later on. Also, write-access
5336 ** is usually required to finalize the journal in journal_mode=persist
5337 ** mode (and also for journal_mode=truncate on some systems).
5338 **
5339 ** If the journal does not exist, it usually means that some
5340 ** other connection managed to get in and roll it back before
5341 ** this connection obtained the exclusive lock above. Or, it
5342 ** may mean that the pager was in the error-state when this
5343 ** function was called and the journal file does not exist.
danielk1977b3175382008-10-17 18:51:52 +00005344 */
drhbda4d202022-01-02 19:32:43 +00005345 if( !isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
dan431b0b42010-08-04 19:14:22 +00005346 sqlite3_vfs * const pVfs = pPager->pVfs;
5347 int bExists; /* True if journal file exists */
5348 rc = sqlite3OsAccess(
5349 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
5350 if( rc==SQLITE_OK && bExists ){
5351 int fout = 0;
5352 int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
5353 assert( !pPager->tempFile );
5354 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
5355 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
5356 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
5357 rc = SQLITE_CANTOPEN_BKPT;
5358 sqlite3OsClose(pPager->jfd);
danielk1977b3175382008-10-17 18:51:52 +00005359 }
5360 }
5361 }
danielk1977b3175382008-10-17 18:51:52 +00005362
5363 /* Playback and delete the journal. Drop the database write
danielk1977112f7522009-01-08 17:50:45 +00005364 ** lock and reacquire the read lock. Purge the cache before
5365 ** playing back the hot-journal so that we don't end up with
drh91781bd2010-04-10 17:52:57 +00005366 ** an inconsistent cache. Sync the hot journal before playing
5367 ** it back since the process that crashed and left the hot journal
5368 ** probably did not sync it and we are required to always sync
5369 ** the journal before playing it back.
danielk1977b3175382008-10-17 18:51:52 +00005370 */
danielk1977641a0bd2009-06-20 11:54:39 +00005371 if( isOpen(pPager->jfd) ){
dan4e004aa2010-08-05 15:30:22 +00005372 assert( rc==SQLITE_OK );
daneada58a2010-04-12 17:08:44 +00005373 rc = pagerSyncHotJournal(pPager);
drh91781bd2010-04-10 17:52:57 +00005374 if( rc==SQLITE_OK ){
dan6572c162016-04-23 14:55:28 +00005375 rc = pager_playback(pPager, !pPager->tempFile);
dande1ae342010-08-06 12:00:27 +00005376 pPager->eState = PAGER_OPEN;
drh91781bd2010-04-10 17:52:57 +00005377 }
dan4e004aa2010-08-05 15:30:22 +00005378 }else if( !pPager->exclusiveMode ){
5379 pagerUnlockDb(pPager, SHARED_LOCK);
5380 }
5381
5382 if( rc!=SQLITE_OK ){
dande1ae342010-08-06 12:00:27 +00005383 /* This branch is taken if an error occurs while trying to open
5384 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
5385 ** pager_unlock() routine will be called before returning to unlock
5386 ** the file. If the unlock attempt fails, then Pager.eLock must be
5387 ** set to UNKNOWN_LOCK (see the comment above the #define for
5388 ** UNKNOWN_LOCK above for an explanation).
5389 **
5390 ** In order to get pager_unlock() to do this, set Pager.eState to
5391 ** PAGER_ERROR now. This is not actually counted as a transition
5392 ** to ERROR state in the state diagram at the top of this file,
5393 ** since we know that the same call to pager_unlock() will very
5394 ** shortly transition the pager object to the OPEN state. Calling
5395 ** assert_pager_state() would fail now, as it should not be possible
5396 ** to be in ERROR state when there are zero outstanding page
5397 ** references.
5398 */
dan4e004aa2010-08-05 15:30:22 +00005399 pager_error(pPager, rc);
5400 goto failed;
danielk1977b3175382008-10-17 18:51:52 +00005401 }
dand0864082010-08-02 14:32:52 +00005402
dande1ae342010-08-06 12:00:27 +00005403 assert( pPager->eState==PAGER_OPEN );
dand0864082010-08-02 14:32:52 +00005404 assert( (pPager->eLock==SHARED_LOCK)
5405 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
danielk1977b3175382008-10-17 18:51:52 +00005406 );
5407 }
5408
drhc98a4cc2015-09-03 17:54:32 +00005409 if( !pPager->tempFile && pPager->hasHeldSharedLock ){
drh542d5582014-12-31 14:18:48 +00005410 /* The shared-lock has just been acquired then check to
5411 ** see if the database has been modified. If the database has changed,
drhc98a4cc2015-09-03 17:54:32 +00005412 ** flush the cache. The hasHeldSharedLock flag prevents this from
drh542d5582014-12-31 14:18:48 +00005413 ** occurring on the very first access to a file, in order to save a
5414 ** single unnecessary sqlite3OsRead() call at the start-up.
danielk1977b3175382008-10-17 18:51:52 +00005415 **
drhb84c14d2015-06-28 17:33:11 +00005416 ** Database changes are detected by looking at 15 bytes beginning
danielk1977b3175382008-10-17 18:51:52 +00005417 ** at offset 24 into the file. The first 4 of these 16 bytes are
5418 ** a 32-bit counter that is incremented with each change. The
5419 ** other bytes change randomly with each file change when
5420 ** a codec is in use.
5421 **
5422 ** There is a vanishingly small chance that a change will not be
5423 ** detected. The chance of an undetected change is so small that
5424 ** it can be neglected.
5425 */
5426 char dbFileVers[sizeof(pPager->dbFileVers)];
danielk1977b3175382008-10-17 18:51:52 +00005427
drh5f5a2d12017-05-29 14:57:23 +00005428 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
5429 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
5430 if( rc!=SQLITE_OK ){
5431 if( rc!=SQLITE_IOERR_SHORT_READ ){
danielk197752b472a2008-05-05 16:23:55 +00005432 goto failed;
danielk1977e277be02007-03-23 18:12:06 +00005433 }
danielk1977b3175382008-10-17 18:51:52 +00005434 memset(dbFileVers, 0, sizeof(dbFileVers));
5435 }
danielk1977e277be02007-03-23 18:12:06 +00005436
danielk1977b3175382008-10-17 18:51:52 +00005437 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
5438 pager_reset(pPager);
dan11dcd112013-03-15 18:29:18 +00005439
5440 /* Unmap the database file. It is possible that external processes
5441 ** may have truncated the database file and then extended it back
5442 ** to its original size while this process was not holding a lock.
5443 ** In this case there may exist a Pager.pMap mapping that appears
5444 ** to be the right size but is not actually valid. Avoid this
5445 ** possibility by unmapping the db here. */
drh188d4882013-04-08 20:47:49 +00005446 if( USEFETCH(pPager) ){
dandf737fe2013-03-25 17:00:24 +00005447 sqlite3OsUnfetch(pPager->fd, 0, 0);
danf23da962013-03-23 21:00:41 +00005448 }
danielk1977e277be02007-03-23 18:12:06 +00005449 }
5450 }
dane04dc882010-04-20 18:53:15 +00005451
dan5cf53532010-05-01 16:40:20 +00005452 /* If there is a WAL file in the file-system, open this database in WAL
5453 ** mode. Otherwise, the following function call is a no-op.
5454 */
5455 rc = pagerOpenWalIfPresent(pPager);
shaneh9091f772010-08-24 18:35:12 +00005456#ifndef SQLITE_OMIT_WAL
dan22b328b2010-08-11 18:56:45 +00005457 assert( pPager->pWal==0 || rc==SQLITE_OK );
shaneh9091f772010-08-24 18:35:12 +00005458#endif
danielk1977e277be02007-03-23 18:12:06 +00005459 }
5460
dan22b328b2010-08-11 18:56:45 +00005461 if( pagerUseWal(pPager) ){
5462 assert( rc==SQLITE_OK );
dan763afe62010-08-03 06:42:39 +00005463 rc = pagerBeginReadTransaction(pPager);
5464 }
5465
dan6572c162016-04-23 14:55:28 +00005466 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
dan763afe62010-08-03 06:42:39 +00005467 rc = pagerPagecount(pPager, &pPager->dbSize);
5468 }
5469
danielk197752b472a2008-05-05 16:23:55 +00005470 failed:
5471 if( rc!=SQLITE_OK ){
dan22b328b2010-08-11 18:56:45 +00005472 assert( !MEMDB );
danielk197752b472a2008-05-05 16:23:55 +00005473 pager_unlock(pPager);
dande1ae342010-08-06 12:00:27 +00005474 assert( pPager->eState==PAGER_OPEN );
dan763afe62010-08-03 06:42:39 +00005475 }else{
5476 pPager->eState = PAGER_READER;
drhc98a4cc2015-09-03 17:54:32 +00005477 pPager->hasHeldSharedLock = 1;
danielk197752b472a2008-05-05 16:23:55 +00005478 }
danielk1977e277be02007-03-23 18:12:06 +00005479 return rc;
5480}
5481
5482/*
danielk1977bea2a942009-01-20 17:06:27 +00005483** If the reference count has reached zero, rollback any active
5484** transaction and unlock the pager.
drh59813952009-04-20 11:34:26 +00005485**
5486** Except, in locking_mode=EXCLUSIVE when there is nothing to in
5487** the rollback journal, the unlock is not performed and there is
5488** nothing to rollback, so this routine is a no-op.
danielk19778c0a7912008-08-20 14:49:23 +00005489*/
5490static void pagerUnlockIfUnused(Pager *pPager){
drh3908fe92017-09-01 14:50:19 +00005491 if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){
5492 assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */
danielk19778c0a7912008-08-20 14:49:23 +00005493 pagerUnlockAndRollback(pPager);
5494 }
5495}
5496
5497/*
drhd5df3ff2016-12-13 15:53:22 +00005498** The page getter methods each try to acquire a reference to a
5499** page with page number pgno. If the requested reference is
danielk1977bea2a942009-01-20 17:06:27 +00005500** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
drhd9b02572001-04-15 00:37:09 +00005501**
drhd5df3ff2016-12-13 15:53:22 +00005502** There are different implementations of the getter method depending
5503** on the current state of the pager.
5504**
5505** getPageNormal() -- The normal getter
5506** getPageError() -- Used if the pager is in an error state
5507** getPageMmap() -- Used if memory-mapped I/O is enabled
5508**
danielk1977bea2a942009-01-20 17:06:27 +00005509** If the requested page is already in the cache, it is returned.
5510** Otherwise, a new page object is allocated and populated with data
5511** read from the database file. In some cases, the pcache module may
5512** choose not to allocate a new page object and may reuse an existing
5513** object with no outstanding references.
5514**
5515** The extra data appended to a page is always initialized to zeros the
5516** first time a page is loaded into memory. If the page requested is
5517** already in the cache when this function is called, then the extra
5518** data is left as it was when the page object was last used.
5519**
drhd5df3ff2016-12-13 15:53:22 +00005520** If the database image is smaller than the requested page or if
5521** the flags parameter contains the PAGER_GET_NOCONTENT bit and the
danielk1977bea2a942009-01-20 17:06:27 +00005522** requested page is not already stored in the cache, then no
5523** actual disk read occurs. In this case the memory image of the
5524** page is initialized to all zeros.
5525**
drhd5df3ff2016-12-13 15:53:22 +00005526** If PAGER_GET_NOCONTENT is true, it means that we do not care about
5527** the contents of the page. This occurs in two scenarios:
danielk1977bea2a942009-01-20 17:06:27 +00005528**
5529** a) When reading a free-list leaf page from the database, and
5530**
5531** b) When a savepoint is being rolled back and we need to load
drh91781bd2010-04-10 17:52:57 +00005532** a new page into the cache to be filled with the data read
danielk1977bea2a942009-01-20 17:06:27 +00005533** from the savepoint journal.
5534**
drhd5df3ff2016-12-13 15:53:22 +00005535** If PAGER_GET_NOCONTENT is true, then the data returned is zeroed instead
5536** of being read from the database. Additionally, the bits corresponding
danielk1977bea2a942009-01-20 17:06:27 +00005537** to pgno in Pager.pInJournal (bitvec of pages already written to the
5538** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
5539** savepoints are set. This means if the page is made writable at any
5540** point in the future, using a call to sqlite3PagerWrite(), its contents
5541** will not be journaled. This saves IO.
drh306dc212001-05-21 13:45:10 +00005542**
drhd9b02572001-04-15 00:37:09 +00005543** The acquisition might fail for several reasons. In all cases,
5544** an appropriate error code is returned and *ppPage is set to NULL.
drh7e3b0a02001-04-28 16:52:40 +00005545**
drhd33d5a82007-04-26 12:11:28 +00005546** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
drh7e3b0a02001-04-28 16:52:40 +00005547** to find a page in the in-memory cache first. If the page is not already
drhd33d5a82007-04-26 12:11:28 +00005548** in memory, this routine goes to disk to read it in whereas Lookup()
drh7e3b0a02001-04-28 16:52:40 +00005549** just returns 0. This routine acquires a read-lock the first time it
5550** has to go to disk, and could also playback an old journal if necessary.
drhd33d5a82007-04-26 12:11:28 +00005551** Since Lookup() never goes to disk, it never has to deal with locks
drh7e3b0a02001-04-28 16:52:40 +00005552** or journal files.
drhed7c8552001-04-11 14:29:21 +00005553*/
drh12e6f682016-12-13 14:32:47 +00005554static int getPageNormal(
drh538f5702007-04-13 02:14:30 +00005555 Pager *pPager, /* The pager open on the database file */
5556 Pgno pgno, /* Page number to fetch */
5557 DbPage **ppPage, /* Write a pointer to the page here */
drhb00fc3b2013-08-21 23:42:32 +00005558 int flags /* PAGER_GET_XXX flags */
drh538f5702007-04-13 02:14:30 +00005559){
dan11dcd112013-03-15 18:29:18 +00005560 int rc = SQLITE_OK;
drhd5df3ff2016-12-13 15:53:22 +00005561 PgHdr *pPg;
5562 u8 noContent; /* True if PAGER_GET_NOCONTENT is set */
drh12e6f682016-12-13 14:32:47 +00005563 sqlite3_pcache_page *pBase;
dan11dcd112013-03-15 18:29:18 +00005564
drh12e6f682016-12-13 14:32:47 +00005565 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +00005566 assert( pPager->eState>=PAGER_READER );
danielk1977bea2a942009-01-20 17:06:27 +00005567 assert( assert_pager_state(pPager) );
drhc98a4cc2015-09-03 17:54:32 +00005568 assert( pPager->hasHeldSharedLock==1 );
danielk197726836652005-01-17 01:33:13 +00005569
drh01be4632015-09-03 15:17:12 +00005570#ifndef SQLITE_OMIT_CONCURRENT
danbf3cf572015-08-24 19:56:04 +00005571 /* If this is an CONCURRENT transaction and the page being read was
dan773d2d62015-07-29 12:14:28 +00005572 ** present in the database file when the transaction was opened,
5573 ** mark it as read in the pAllRead vector. */
drh0a2afca2017-07-20 19:08:35 +00005574 pPg = 0;
dan773d2d62015-07-29 12:14:28 +00005575 if( pPager->pAllRead && pgno<=pPager->dbOrigSize ){
drh9f16a962017-08-11 20:22:30 +00005576 PAGERTRACE(("USING page %d\n", pgno));
dan773d2d62015-07-29 12:14:28 +00005577 rc = sqlite3BitvecSet(pPager->pAllRead, pgno);
5578 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5579 }
dan04085292015-08-24 16:00:08 +00005580#endif
dan773d2d62015-07-29 12:14:28 +00005581
drh5f4ade02016-12-30 14:25:42 +00005582 if( pgno==0 ) return SQLITE_CORRUPT_BKPT;
drh12e6f682016-12-13 14:32:47 +00005583 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
5584 if( pBase==0 ){
danielk197789bc4bc2009-07-21 19:25:24 +00005585 pPg = 0;
drh12e6f682016-12-13 14:32:47 +00005586 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
5587 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5588 if( pBase==0 ){
drh12e6f682016-12-13 14:32:47 +00005589 rc = SQLITE_NOMEM_BKPT;
5590 goto pager_acquire_err;
danielk1977e277be02007-03-23 18:12:06 +00005591 }
danielk19778c0a7912008-08-20 14:49:23 +00005592 }
drh12e6f682016-12-13 14:32:47 +00005593 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
drhb84c14d2015-06-28 17:33:11 +00005594 assert( pPg==(*ppPage) );
5595 assert( pPg->pgno==pgno );
5596 assert( pPg->pPager==pPager || pPg->pPager==0 );
danielk197789bc4bc2009-07-21 19:25:24 +00005597
drh8a123d62016-12-14 10:30:12 +00005598 noContent = (flags & PAGER_GET_NOCONTENT)!=0;
drhb84c14d2015-06-28 17:33:11 +00005599 if( pPg->pPager && !noContent ){
danielk197789bc4bc2009-07-21 19:25:24 +00005600 /* In this case the pcache already contains an initialized copy of
5601 ** the page. Return without further ado. */
drh584bfca2022-02-23 17:00:44 +00005602 assert( pgno!=PAGER_SJ_PGNO(pPager) );
drh9ad3ee42012-03-24 20:06:14 +00005603 pPager->aStat[PAGER_STAT_HIT]++;
danielk197789bc4bc2009-07-21 19:25:24 +00005604 return SQLITE_OK;
5605
5606 }else{
danielk19778c0a7912008-08-20 14:49:23 +00005607 /* The pager cache has created a new page. Its content needs to
drhcbed6042016-12-13 18:34:01 +00005608 ** be initialized. But first some error checks:
5609 **
drhabc38152020-07-22 13:38:04 +00005610 ** (*) obsolete. Was: maximum page number is 2^31
drh5f4ade02016-12-30 14:25:42 +00005611 ** (2) Never try to fetch the locking page
drhcbed6042016-12-13 18:34:01 +00005612 */
drhe3994f22022-03-02 11:39:11 +00005613 if( pgno==PAGER_SJ_PGNO(pPager) ){
danielk197789bc4bc2009-07-21 19:25:24 +00005614 rc = SQLITE_CORRUPT_BKPT;
5615 goto pager_acquire_err;
5616 }
5617
drhcbed6042016-12-13 18:34:01 +00005618 pPg->pPager = pPager;
5619
drh835f22d2016-04-25 19:20:56 +00005620 assert( !isOpen(pPager->fd) || !MEMDB );
5621 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
drhf8e632b2007-05-08 14:51:36 +00005622 if( pgno>pPager->mxPgno ){
dan7c246102010-04-12 19:00:29 +00005623 rc = SQLITE_FULL;
5624 goto pager_acquire_err;
drhf8e632b2007-05-08 14:51:36 +00005625 }
danielk1977a1fa00d2008-08-27 15:16:33 +00005626 if( noContent ){
danielk1977bea2a942009-01-20 17:06:27 +00005627 /* Failure to set the bits in the InJournal bit-vectors is benign.
5628 ** It merely means that we might do some extra work to journal a
5629 ** page that does not need to be journaled. Nevertheless, be sure
5630 ** to test the case where a malloc error occurs while trying to set
5631 ** a bit in a bit vector.
5632 */
5633 sqlite3BeginBenignMalloc();
drh8a938f92009-07-25 04:12:02 +00005634 if( pgno<=pPager->dbOrigSize ){
danielk1977bea2a942009-01-20 17:06:27 +00005635 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
5636 testcase( rc==SQLITE_NOMEM );
5637 }
5638 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
5639 testcase( rc==SQLITE_NOMEM );
5640 sqlite3EndBenignMalloc();
danielk19778c0a7912008-08-20 14:49:23 +00005641 }
drh39187952010-01-05 13:40:35 +00005642 memset(pPg->pData, 0, pPager->pageSize);
drh538f5702007-04-13 02:14:30 +00005643 IOTRACE(("ZERO %p %d\n", pPager, pgno));
drh306dc212001-05-21 13:45:10 +00005644 }else{
danielk1977bea2a942009-01-20 17:06:27 +00005645 assert( pPg->pPager==pPager );
drh9ad3ee42012-03-24 20:06:14 +00005646 pPager->aStat[PAGER_STAT_MISS]++;
drh56520ab2017-08-18 21:14:50 +00005647 rc = readDbPage(pPg);
danielk1977546820e2009-03-28 06:59:41 +00005648 if( rc!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00005649 goto pager_acquire_err;
drh81a20f22001-10-12 17:30:04 +00005650 }
drh306dc212001-05-21 13:45:10 +00005651 }
dan5f848c32010-08-23 18:19:31 +00005652 pager_set_pagehash(pPg);
drhed7c8552001-04-11 14:29:21 +00005653 }
drhed7c8552001-04-11 14:29:21 +00005654 return SQLITE_OK;
danielk197789bc4bc2009-07-21 19:25:24 +00005655
5656pager_acquire_err:
5657 assert( rc!=SQLITE_OK );
danielk1977e878a2f2009-07-22 16:41:15 +00005658 if( pPg ){
5659 sqlite3PcacheDrop(pPg);
5660 }
danielk197789bc4bc2009-07-21 19:25:24 +00005661 pagerUnlockIfUnused(pPager);
5662 *ppPage = 0;
5663 return rc;
drhed7c8552001-04-11 14:29:21 +00005664}
danielk19778c0a7912008-08-20 14:49:23 +00005665
drhd5df3ff2016-12-13 15:53:22 +00005666#if SQLITE_MAX_MMAP_SIZE>0
drh12e6f682016-12-13 14:32:47 +00005667/* The page getter for when memory-mapped I/O is enabled */
5668static int getPageMMap(
5669 Pager *pPager, /* The pager open on the database file */
5670 Pgno pgno, /* Page number to fetch */
5671 DbPage **ppPage, /* Write a pointer to the page here */
5672 int flags /* PAGER_GET_XXX flags */
5673){
5674 int rc = SQLITE_OK;
5675 PgHdr *pPg = 0;
5676 u32 iFrame = 0; /* Frame to read from WAL file */
5677
drh12e6f682016-12-13 14:32:47 +00005678 /* It is acceptable to use a read-only (mmap) page for any page except
5679 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
5680 ** flag was specified by the caller. And so long as the db is not a
5681 ** temporary or in-memory database. */
5682 const int bMmapOk = (pgno>1
5683 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
5684 );
5685
drh380c08e2016-12-13 20:30:29 +00005686 assert( USEFETCH(pPager) );
drh380c08e2016-12-13 20:30:29 +00005687
drh12e6f682016-12-13 14:32:47 +00005688 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
5689 ** allows the compiler optimizer to reuse the results of the "pgno>1"
5690 ** test in the previous statement, and avoid testing pgno==0 in the
5691 ** common case where pgno is large. */
5692 if( pgno<=1 && pgno==0 ){
5693 return SQLITE_CORRUPT_BKPT;
5694 }
5695 assert( pPager->eState>=PAGER_READER );
5696 assert( assert_pager_state(pPager) );
5697 assert( pPager->hasHeldSharedLock==1 );
5698 assert( pPager->errCode==SQLITE_OK );
5699
5700 if( bMmapOk && pagerUseWal(pPager) ){
5701 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
5702 if( rc!=SQLITE_OK ){
5703 *ppPage = 0;
5704 return rc;
5705 }
5706 }
5707 if( bMmapOk && iFrame==0 ){
5708 void *pData = 0;
5709 rc = sqlite3OsFetch(pPager->fd,
5710 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
5711 );
5712 if( rc==SQLITE_OK && pData ){
5713 if( pPager->eState>PAGER_READER || pPager->tempFile ){
5714 pPg = sqlite3PagerLookup(pPager, pgno);
5715 }
5716 if( pPg==0 ){
5717 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
drhd9620b82018-01-02 21:29:42 +00005718 }else{
drh12e6f682016-12-13 14:32:47 +00005719 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
5720 }
5721 if( pPg ){
5722 assert( rc==SQLITE_OK );
5723 *ppPage = pPg;
5724 return SQLITE_OK;
5725 }
5726 }
5727 if( rc!=SQLITE_OK ){
5728 *ppPage = 0;
5729 return rc;
5730 }
5731 }
5732 return getPageNormal(pPager, pgno, ppPage, flags);
5733}
drhd5df3ff2016-12-13 15:53:22 +00005734#endif /* SQLITE_MAX_MMAP_SIZE>0 */
drh12e6f682016-12-13 14:32:47 +00005735
5736/* The page getter method for when the pager is an error state */
5737static int getPageError(
5738 Pager *pPager, /* The pager open on the database file */
5739 Pgno pgno, /* Page number to fetch */
5740 DbPage **ppPage, /* Write a pointer to the page here */
5741 int flags /* PAGER_GET_XXX flags */
5742){
drh380c08e2016-12-13 20:30:29 +00005743 UNUSED_PARAMETER(pgno);
5744 UNUSED_PARAMETER(flags);
drh12e6f682016-12-13 14:32:47 +00005745 assert( pPager->errCode!=SQLITE_OK );
5746 *ppPage = 0;
5747 return pPager->errCode;
5748}
5749
5750
5751/* Dispatch all page fetch requests to the appropriate getter method.
5752*/
5753int sqlite3PagerGet(
5754 Pager *pPager, /* The pager open on the database file */
5755 Pgno pgno, /* Page number to fetch */
5756 DbPage **ppPage, /* Write a pointer to the page here */
5757 int flags /* PAGER_GET_XXX flags */
5758){
drh5622c7f2022-01-08 21:50:00 +00005759 /* printf("PAGE %u\n", pgno); fflush(stdout); */
drh12e6f682016-12-13 14:32:47 +00005760 return pPager->xGet(pPager, pgno, ppPage, flags);
5761}
5762
drhed7c8552001-04-11 14:29:21 +00005763/*
drh7e3b0a02001-04-28 16:52:40 +00005764** Acquire a page if it is already in the in-memory cache. Do
5765** not read the page from disk. Return a pointer to the page,
dana81a2202010-08-17 18:15:48 +00005766** or 0 if the page is not in cache.
drh7e3b0a02001-04-28 16:52:40 +00005767**
danielk19773b8a05f2007-03-19 17:44:26 +00005768** See also sqlite3PagerGet(). The difference between this routine
5769** and sqlite3PagerGet() is that _get() will go to the disk and read
drh7e3b0a02001-04-28 16:52:40 +00005770** in the page if the page is not already in cache. This routine
drh5e00f6c2001-09-13 13:46:56 +00005771** returns NULL if the page is not in cache or if a disk I/O error
5772** has ever happened.
drh7e3b0a02001-04-28 16:52:40 +00005773*/
danielk19773b8a05f2007-03-19 17:44:26 +00005774DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
drhbc59ac02014-08-27 23:18:01 +00005775 sqlite3_pcache_page *pPage;
drh836faa42003-01-11 13:30:57 +00005776 assert( pPager!=0 );
5777 assert( pgno!=0 );
drhad7516c2009-07-24 16:32:00 +00005778 assert( pPager->pPCache!=0 );
drhbc59ac02014-08-27 23:18:01 +00005779 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
drhc98a4cc2015-09-03 17:54:32 +00005780 assert( pPage==0 || pPager->hasHeldSharedLock );
drhd8c0ba32015-06-30 03:57:59 +00005781 if( pPage==0 ) return 0;
drhbc59ac02014-08-27 23:18:01 +00005782 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
drh7e3b0a02001-04-28 16:52:40 +00005783}
5784
5785/*
danielk1977bea2a942009-01-20 17:06:27 +00005786** Release a page reference.
drhed7c8552001-04-11 14:29:21 +00005787**
drh3908fe92017-09-01 14:50:19 +00005788** The sqlite3PagerUnref() and sqlite3PagerUnrefNotNull() may only be
5789** used if we know that the page being released is not the last page.
5790** The btree layer always holds page1 open until the end, so these first
5791** to routines can be used to release any page other than BtShared.pPage1.
5792**
5793** Use sqlite3PagerUnrefPageOne() to release page1. This latter routine
5794** checks the total number of outstanding pages and if the number of
5795** pages reaches zero it drops the database lock.
drhed7c8552001-04-11 14:29:21 +00005796*/
drhda8a3302013-12-13 19:35:21 +00005797void sqlite3PagerUnrefNotNull(DbPage *pPg){
drh3908fe92017-09-01 14:50:19 +00005798 TESTONLY( Pager *pPager = pPg->pPager; )
drhda8a3302013-12-13 19:35:21 +00005799 assert( pPg!=0 );
drhda8a3302013-12-13 19:35:21 +00005800 if( pPg->flags & PGHDR_MMAP ){
drh3908fe92017-09-01 14:50:19 +00005801 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
drhda8a3302013-12-13 19:35:21 +00005802 pagerReleaseMapPage(pPg);
5803 }else{
5804 sqlite3PcacheRelease(pPg);
drhed7c8552001-04-11 14:29:21 +00005805 }
drh3908fe92017-09-01 14:50:19 +00005806 /* Do not use this routine to release the last reference to page1 */
5807 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
drhda8a3302013-12-13 19:35:21 +00005808}
5809void sqlite3PagerUnref(DbPage *pPg){
5810 if( pPg ) sqlite3PagerUnrefNotNull(pPg);
drhed7c8552001-04-11 14:29:21 +00005811}
drh3908fe92017-09-01 14:50:19 +00005812void sqlite3PagerUnrefPageOne(DbPage *pPg){
5813 Pager *pPager;
5814 assert( pPg!=0 );
5815 assert( pPg->pgno==1 );
5816 assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
5817 pPager = pPg->pPager;
5818 sqlite3PcacheRelease(pPg);
5819 pagerUnlockIfUnused(pPager);
5820}
drhed7c8552001-04-11 14:29:21 +00005821
danielk19779153d852009-01-07 10:52:56 +00005822/*
danielk1977bea2a942009-01-20 17:06:27 +00005823** This function is called at the start of every write transaction.
5824** There must already be a RESERVED or EXCLUSIVE lock on the database
5825** file when this routine is called.
drhda47d772002-12-02 04:25:19 +00005826**
danielk1977bea2a942009-01-20 17:06:27 +00005827** Open the journal file for pager pPager and write a journal header
5828** to the start of it. If there are active savepoints, open the sub-journal
5829** as well. This function is only used when the journal file is being
5830** opened to write a rollback log for a transaction. It is not used
5831** when opening a hot journal file to roll it back.
5832**
5833** If the journal file is already open (as it may be in exclusive mode),
5834** then this function just writes a journal header to the start of the
5835** already open file.
5836**
5837** Whether or not the journal file is opened by this function, the
5838** Pager.pInJournal bitvec structure is allocated.
5839**
5840** Return SQLITE_OK if everything is successful. Otherwise, return
5841** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
5842** an IO error code if opening or writing the journal file fails.
drhda47d772002-12-02 04:25:19 +00005843*/
5844static int pager_open_journal(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00005845 int rc = SQLITE_OK; /* Return code */
5846 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
danielk1977b4b47412007-08-17 15:53:36 +00005847
dande1ae342010-08-06 12:00:27 +00005848 assert( pPager->eState==PAGER_WRITER_LOCKED );
dand0864082010-08-02 14:32:52 +00005849 assert( assert_pager_state(pPager) );
drhf5e7bb52008-02-18 14:47:33 +00005850 assert( pPager->pInJournal==0 );
danielk1977bea2a942009-01-20 17:06:27 +00005851
drhad7516c2009-07-24 16:32:00 +00005852 /* If already in the error state, this function is a no-op. But on
5853 ** the other hand, this routine is never called if we are already in
5854 ** an error state. */
5855 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977b4b47412007-08-17 15:53:36 +00005856
dand0864082010-08-02 14:32:52 +00005857 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
dan937ac9d2010-08-03 12:48:45 +00005858 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
dand0864082010-08-02 14:32:52 +00005859 if( pPager->pInJournal==0 ){
mistachkinfad30392016-02-13 23:43:46 +00005860 return SQLITE_NOMEM_BKPT;
danielk1977b3175382008-10-17 18:51:52 +00005861 }
dand0864082010-08-02 14:32:52 +00005862
5863 /* Open the journal file if it is not already open. */
5864 if( !isOpen(pPager->jfd) ){
5865 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
5866 sqlite3MemJournalOpen(pPager->jfd);
5867 }else{
dan9131ab92016-04-06 18:20:51 +00005868 int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
5869 int nSpill;
drh3fee8a62013-12-06 17:23:38 +00005870
dan9131ab92016-04-06 18:20:51 +00005871 if( pPager->tempFile ){
5872 flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
dan2756f802022-08-16 10:52:35 +00005873 flags |= SQLITE_OPEN_EXCLUSIVE;
dan9131ab92016-04-06 18:20:51 +00005874 nSpill = sqlite3Config.nStmtSpill;
5875 }else{
5876 flags |= SQLITE_OPEN_MAIN_JOURNAL;
5877 nSpill = jrnlBufferSize(pPager);
5878 }
5879
drh3fee8a62013-12-06 17:23:38 +00005880 /* Verify that the database still has the same name as it did when
5881 ** it was originally opened. */
5882 rc = databaseIsUnmoved(pPager);
5883 if( rc==SQLITE_OK ){
dan9131ab92016-04-06 18:20:51 +00005884 rc = sqlite3JournalOpen (
5885 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
drh3fee8a62013-12-06 17:23:38 +00005886 );
drh3fee8a62013-12-06 17:23:38 +00005887 }
dand0864082010-08-02 14:32:52 +00005888 }
5889 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
5890 }
5891
5892
5893 /* Write the first journal header to the journal file and open
5894 ** the sub-journal if necessary.
5895 */
5896 if( rc==SQLITE_OK ){
5897 /* TODO: Check if all of these are really required. */
dand0864082010-08-02 14:32:52 +00005898 pPager->nRec = 0;
5899 pPager->journalOff = 0;
drh067b92b2020-06-19 15:24:12 +00005900 pPager->setSuper = 0;
dand0864082010-08-02 14:32:52 +00005901 pPager->journalHdr = 0;
5902 rc = writeJournalHdr(pPager);
5903 }
drhda47d772002-12-02 04:25:19 +00005904 }
drh9c105bb2004-10-02 20:38:28 +00005905
danielk1977bea2a942009-01-20 17:06:27 +00005906 if( rc!=SQLITE_OK ){
5907 sqlite3BitvecDestroy(pPager->pInJournal);
5908 pPager->pInJournal = 0;
danad617b42022-09-02 21:19:24 +00005909 pPager->journalOff = 0;
dand0864082010-08-02 14:32:52 +00005910 }else{
dande1ae342010-08-06 12:00:27 +00005911 assert( pPager->eState==PAGER_WRITER_LOCKED );
dand0864082010-08-02 14:32:52 +00005912 pPager->eState = PAGER_WRITER_CACHEMOD;
danielk1977bea2a942009-01-20 17:06:27 +00005913 }
dand0864082010-08-02 14:32:52 +00005914
drh9c105bb2004-10-02 20:38:28 +00005915 return rc;
drhda47d772002-12-02 04:25:19 +00005916}
5917
5918/*
danielk1977bea2a942009-01-20 17:06:27 +00005919** Begin a write-transaction on the specified pager object. If a
5920** write-transaction has already been opened, this function is a no-op.
drh4b845d72002-03-05 12:41:19 +00005921**
dan3d394342015-07-27 19:31:45 +00005922** If the exFlag argument is 0, then acquire at least a RESERVED
5923** lock on the database file. If exFlag is >0, then acquire at least
danielk1977bea2a942009-01-20 17:06:27 +00005924** an EXCLUSIVE lock. If such a lock is already held, no locking
5925** functions need be called.
drh4b845d72002-03-05 12:41:19 +00005926**
dan3d394342015-07-27 19:31:45 +00005927** If (exFlag<0) and the database is in WAL mode, do not take any locks.
danbf3cf572015-08-24 19:56:04 +00005928** The transaction will run in CONCURRENT mode instead.
dan3d394342015-07-27 19:31:45 +00005929**
danielk1977d8293352009-04-30 09:10:37 +00005930** If the subjInMemory argument is non-zero, then any sub-journal opened
5931** within this transaction will be opened as an in-memory file. This
5932** has no effect if the sub-journal is already opened (as it may be when
5933** running in exclusive mode) or if the transaction does not require a
5934** sub-journal. If the subjInMemory argument is zero, then any required
5935** sub-journal is implemented in-memory if pPager is an in-memory database,
5936** or using a temporary file otherwise.
drh4b845d72002-03-05 12:41:19 +00005937*/
danielk1977d8293352009-04-30 09:10:37 +00005938int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
drh4b845d72002-03-05 12:41:19 +00005939 int rc = SQLITE_OK;
drh719e3a72010-08-17 17:25:15 +00005940
drh89bd82a2010-08-17 19:49:14 +00005941 if( pPager->errCode ) return pPager->errCode;
drh719e3a72010-08-17 17:25:15 +00005942 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
shane60a4b532009-05-06 18:57:09 +00005943 pPager->subjInMemory = (u8)subjInMemory;
dan55437592010-05-11 12:19:26 +00005944
drh55938b52021-04-08 19:56:58 +00005945 if( pPager->eState==PAGER_READER ){
drhf5e7bb52008-02-18 14:47:33 +00005946 assert( pPager->pInJournal==0 );
drh7ed91f22010-04-29 22:34:07 +00005947 if( pagerUseWal(pPager) ){
dan55437592010-05-11 12:19:26 +00005948 /* If the pager is configured to use locking_mode=exclusive, and an
5949 ** exclusive lock on the database is not already held, obtain it now.
5950 */
drh61e4ace2010-05-31 20:28:37 +00005951 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
dan4e004aa2010-08-05 15:30:22 +00005952 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
dan55437592010-05-11 12:19:26 +00005953 if( rc!=SQLITE_OK ){
5954 return rc;
5955 }
drhb4acd6a2016-01-14 01:56:43 +00005956 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
dan55437592010-05-11 12:19:26 +00005957 }
5958
dan7c246102010-04-12 19:00:29 +00005959 /* Grab the write lock on the log file. If successful, upgrade to
dan55437592010-05-11 12:19:26 +00005960 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
dan7c246102010-04-12 19:00:29 +00005961 ** The busy-handler is not invoked if another connection already
dan987f8212015-08-27 17:42:38 +00005962 ** holds the write-lock. If possible, the upper layer will call it. */
5963 if( exFlag>=0 ){
dan04085292015-08-24 16:00:08 +00005964 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
dan3d394342015-07-27 19:31:45 +00005965 }
dan64d039e2010-04-13 19:27:31 +00005966 }else{
5967 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
5968 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
5969 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
5970 ** lock, but not when obtaining the RESERVED lock.
5971 */
dan4e004aa2010-08-05 15:30:22 +00005972 rc = pagerLockDb(pPager, RESERVED_LOCK);
dan3d394342015-07-27 19:31:45 +00005973 if( rc==SQLITE_OK && exFlag>0 ){
dand0864082010-08-02 14:32:52 +00005974 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
dan7c246102010-04-12 19:00:29 +00005975 }
5976 }
5977
dand0864082010-08-02 14:32:52 +00005978 if( rc==SQLITE_OK ){
dande1ae342010-08-06 12:00:27 +00005979 /* Change to WRITER_LOCKED state.
dand0864082010-08-02 14:32:52 +00005980 **
dande1ae342010-08-06 12:00:27 +00005981 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
dand0864082010-08-02 14:32:52 +00005982 ** when it has an open transaction, but never to DBMOD or FINISHED.
5983 ** This is because in those states the code to roll back savepoint
5984 ** transactions may copy data from the sub-journal into the database
5985 ** file as well as into the page cache. Which would be incorrect in
5986 ** WAL mode.
5987 */
dande1ae342010-08-06 12:00:27 +00005988 pPager->eState = PAGER_WRITER_LOCKED;
danc8649122010-08-10 09:58:57 +00005989 pPager->dbHintSize = pPager->dbSize;
5990 pPager->dbFileSize = pPager->dbSize;
5991 pPager->dbOrigSize = pPager->dbSize;
dand0864082010-08-02 14:32:52 +00005992 pPager->journalOff = 0;
dan3ad5fd22010-06-30 04:36:03 +00005993 }
dand0864082010-08-02 14:32:52 +00005994
5995 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
dande1ae342010-08-06 12:00:27 +00005996 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
dand0864082010-08-02 14:32:52 +00005997 assert( assert_pager_state(pPager) );
drh4b845d72002-03-05 12:41:19 +00005998 }
danielk1977bea2a942009-01-20 17:06:27 +00005999
6000 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
drh4b845d72002-03-05 12:41:19 +00006001 return rc;
6002}
6003
6004/*
drh82ef8772015-06-29 14:11:50 +00006005** Write page pPg onto the end of the rollback journal.
6006*/
6007static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
6008 Pager *pPager = pPg->pPager;
6009 int rc;
6010 u32 cksum;
6011 char *pData2;
6012 i64 iOff = pPager->journalOff;
6013
6014 /* We should never write to the journal file the page that
6015 ** contains the database locks. The following assert verifies
6016 ** that we do not. */
drh584bfca2022-02-23 17:00:44 +00006017 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
drh82ef8772015-06-29 14:11:50 +00006018
6019 assert( pPager->journalHdr<=pPager->journalOff );
drhb48c0d52020-02-07 01:12:53 +00006020 pData2 = pPg->pData;
drh82ef8772015-06-29 14:11:50 +00006021 cksum = pager_cksum(pPager, (u8*)pData2);
6022
6023 /* Even if an IO or diskfull error occurs while journalling the
6024 ** page in the block above, set the need-sync flag for the page.
6025 ** Otherwise, when the transaction is rolled back, the logic in
6026 ** playback_one_page() will think that the page needs to be restored
6027 ** in the database file. And if an IO error occurs while doing so,
6028 ** then corruption may follow.
6029 */
6030 pPg->flags |= PGHDR_NEED_SYNC;
6031
6032 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
6033 if( rc!=SQLITE_OK ) return rc;
6034 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
6035 if( rc!=SQLITE_OK ) return rc;
6036 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
6037 if( rc!=SQLITE_OK ) return rc;
6038
6039 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
6040 pPager->journalOff, pPager->pageSize));
6041 PAGER_INCR(sqlite3_pager_writej_count);
6042 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
6043 PAGERID(pPager), pPg->pgno,
6044 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
6045
6046 pPager->journalOff += 8 + pPager->pageSize;
6047 pPager->nRec++;
6048 assert( pPager->pInJournal!=0 );
6049 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
6050 testcase( rc==SQLITE_NOMEM );
6051 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
6052 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
6053 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
6054 return rc;
6055}
6056
6057/*
danielk1977bea2a942009-01-20 17:06:27 +00006058** Mark a single data page as writeable. The page is written into the
6059** main journal or sub-journal as required. If the page is written into
6060** one of the journals, the corresponding bit is set in the
6061** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
6062** of any open savepoints as appropriate.
drhed7c8552001-04-11 14:29:21 +00006063*/
danielk19773b8a05f2007-03-19 17:44:26 +00006064static int pager_write(PgHdr *pPg){
drh69688d52001-04-14 16:38:23 +00006065 Pager *pPager = pPg->pPager;
drhd79caeb2001-04-15 02:27:24 +00006066 int rc = SQLITE_OK;
drh69688d52001-04-14 16:38:23 +00006067
dand0864082010-08-02 14:32:52 +00006068 /* This routine is not called unless a write-transaction has already
6069 ** been started. The journal file may or may not be open at this point.
dana42c66b2010-08-03 18:18:41 +00006070 ** It is never called in the ERROR state.
drh5e1fa032009-07-25 15:24:13 +00006071 */
dande1ae342010-08-06 12:00:27 +00006072 assert( pPager->eState==PAGER_WRITER_LOCKED
dana42c66b2010-08-03 18:18:41 +00006073 || pPager->eState==PAGER_WRITER_CACHEMOD
6074 || pPager->eState==PAGER_WRITER_DBMOD
6075 );
dand0864082010-08-02 14:32:52 +00006076 assert( assert_pager_state(pPager) );
drhc65faab2013-12-09 19:25:28 +00006077 assert( pPager->errCode==0 );
6078 assert( pPager->readOnly==0 );
danielk19773c407372005-02-15 02:54:14 +00006079 CHECK_PAGE(pPg);
6080
dan96b958a2010-10-05 17:02:47 +00006081 /* The journal file needs to be opened. Higher level routines have already
6082 ** obtained the necessary locks to begin the write-transaction, but the
6083 ** rollback journal might not yet be open. Open it now if this is the case.
6084 **
6085 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
6086 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
6087 ** an error might occur and the pager would end up in WRITER_LOCKED state
6088 ** with pages marked as dirty in the cache.
6089 */
6090 if( pPager->eState==PAGER_WRITER_LOCKED ){
6091 rc = pager_open_journal(pPager);
6092 if( rc!=SQLITE_OK ) return rc;
6093 }
6094 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
6095 assert( assert_pager_state(pPager) );
6096
drh82ef8772015-06-29 14:11:50 +00006097 /* Mark the page that is about to be modified as dirty. */
drhc047b9f2008-11-21 03:23:43 +00006098 sqlite3PcacheMakeDirty(pPg);
danielk1977dd97a492007-08-22 18:54:32 +00006099
drh82ef8772015-06-29 14:11:50 +00006100 /* If a rollback journal is in use, them make sure the page that is about
6101 ** to change is in the rollback journal, or if the page is a new page off
6102 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
6103 */
6104 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
drhe399ac22015-06-29 18:14:02 +00006105 if( pPager->pInJournal!=0
6106 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
drh82ef8772015-06-29 14:11:50 +00006107 ){
6108 assert( pagerUseWal(pPager)==0 );
6109 if( pPg->pgno<=pPager->dbOrigSize ){
6110 rc = pagerAddPageToRollbackJournal(pPg);
6111 if( rc!=SQLITE_OK ){
6112 return rc;
danielk1977a0bf2652004-11-04 14:30:04 +00006113 }
drh82ef8772015-06-29 14:11:50 +00006114 }else{
6115 if( pPager->eState!=PAGER_WRITER_DBMOD ){
6116 pPg->flags |= PGHDR_NEED_SYNC;
6117 }
6118 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
6119 PAGERID(pPager), pPg->pgno,
6120 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
drhd9b02572001-04-15 00:37:09 +00006121 }
drhfa86c412002-02-02 15:01:15 +00006122 }
drh1aacbdb2015-06-29 18:29:10 +00006123
6124 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
6125 ** and before writing the page into the rollback journal. Wait until now,
6126 ** after the page has been successfully journalled, before setting the
6127 ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
6128 */
6129 pPg->flags |= PGHDR_WRITEABLE;
drh82ef8772015-06-29 14:11:50 +00006130
6131 /* If the statement journal is open and the page is not in it,
6132 ** then write the page into the statement journal.
drhfa86c412002-02-02 15:01:15 +00006133 */
drh60e32ed2015-06-29 19:08:18 +00006134 if( pPager->nSavepoint>0 ){
6135 rc = subjournalPageIfRequired(pPg);
drh82ef8772015-06-29 14:11:50 +00006136 }
6137
6138 /* Update the database size and return. */
danielk1977d92db532008-11-17 04:56:24 +00006139 if( pPager->dbSize<pPg->pgno ){
drh306dc212001-05-21 13:45:10 +00006140 pPager->dbSize = pPg->pgno;
6141 }
drh69688d52001-04-14 16:38:23 +00006142 return rc;
drhed7c8552001-04-11 14:29:21 +00006143}
6144
6145/*
drhf063e082014-08-24 01:32:43 +00006146** This is a variant of sqlite3PagerWrite() that runs when the sector size
6147** is larger than the page size. SQLite makes the (reasonable) assumption that
6148** all bytes of a sector are written together by hardware. Hence, all bytes of
6149** a sector need to be journalled in case of a power loss in the middle of
6150** a write.
6151**
6152** Usually, the sector size is less than or equal to the page size, in which
drhe399ac22015-06-29 18:14:02 +00006153** case pages can be individually written. This routine only runs in the
6154** exceptional case where the page size is smaller than the sector size.
drhf063e082014-08-24 01:32:43 +00006155*/
6156static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
drhe399ac22015-06-29 18:14:02 +00006157 int rc = SQLITE_OK; /* Return code */
6158 Pgno nPageCount; /* Total number of pages in database file */
6159 Pgno pg1; /* First page of the sector pPg is located on. */
6160 int nPage = 0; /* Number of pages starting at pg1 to journal */
6161 int ii; /* Loop counter */
6162 int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */
6163 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
drhf063e082014-08-24 01:32:43 +00006164 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
6165
6166 /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
6167 ** a journal header to be written between the pages journaled by
6168 ** this function.
6169 */
6170 assert( !MEMDB );
6171 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
6172 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
6173
6174 /* This trick assumes that both the page-size and sector-size are
6175 ** an integer power of 2. It sets variable pg1 to the identifier
6176 ** of the first page of the sector pPg is located on.
6177 */
6178 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
6179
6180 nPageCount = pPager->dbSize;
6181 if( pPg->pgno>nPageCount ){
6182 nPage = (pPg->pgno - pg1)+1;
6183 }else if( (pg1+nPagePerSector-1)>nPageCount ){
6184 nPage = nPageCount+1-pg1;
6185 }else{
6186 nPage = nPagePerSector;
6187 }
6188 assert(nPage>0);
6189 assert(pg1<=pPg->pgno);
6190 assert((pg1+nPage)>pPg->pgno);
6191
6192 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
6193 Pgno pg = pg1+ii;
6194 PgHdr *pPage;
6195 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
drh584bfca2022-02-23 17:00:44 +00006196 if( pg!=PAGER_SJ_PGNO(pPager) ){
drh9584f582015-11-04 20:22:37 +00006197 rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
drhf063e082014-08-24 01:32:43 +00006198 if( rc==SQLITE_OK ){
6199 rc = pager_write(pPage);
6200 if( pPage->flags&PGHDR_NEED_SYNC ){
6201 needSync = 1;
6202 }
6203 sqlite3PagerUnrefNotNull(pPage);
6204 }
6205 }
drhc1378072014-08-25 11:33:41 +00006206 }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
drhf063e082014-08-24 01:32:43 +00006207 if( pPage->flags&PGHDR_NEED_SYNC ){
6208 needSync = 1;
6209 }
6210 sqlite3PagerUnrefNotNull(pPage);
6211 }
6212 }
6213
6214 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
6215 ** starting at pg1, then it needs to be set for all of them. Because
6216 ** writing to any of these nPage pages may damage the others, the
6217 ** journal file must contain sync()ed copies of all of them
6218 ** before any of them can be written out to the database file.
6219 */
6220 if( rc==SQLITE_OK && needSync ){
6221 assert( !MEMDB );
6222 for(ii=0; ii<nPage; ii++){
drhc1378072014-08-25 11:33:41 +00006223 PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
drhf063e082014-08-24 01:32:43 +00006224 if( pPage ){
6225 pPage->flags |= PGHDR_NEED_SYNC;
6226 sqlite3PagerUnrefNotNull(pPage);
6227 }
6228 }
6229 }
6230
6231 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
6232 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
6233 return rc;
6234}
6235
6236/*
danielk1977bea2a942009-01-20 17:06:27 +00006237** Mark a data page as writeable. This routine must be called before
6238** making changes to a page. The caller must check the return value
6239** of this function and be careful not to change any page data unless
6240** this routine returns SQLITE_OK.
danielk19774099f6e2007-03-19 11:25:20 +00006241**
6242** The difference between this function and pager_write() is that this
6243** function also deals with the special case where 2 or more pages
6244** fit on a single disk sector. In this case all co-resident pages
6245** must have been written to the journal file before returning.
danielk1977bea2a942009-01-20 17:06:27 +00006246**
6247** If an error occurs, SQLITE_NOMEM or an IO error code is returned
6248** as appropriate. Otherwise, SQLITE_OK.
danielk19774099f6e2007-03-19 11:25:20 +00006249*/
drhf063e082014-08-24 01:32:43 +00006250int sqlite3PagerWrite(PgHdr *pPg){
drhb3475532015-06-29 20:53:18 +00006251 Pager *pPager = pPg->pPager;
drh50642b12015-06-30 03:34:13 +00006252 assert( (pPg->flags & PGHDR_MMAP)==0 );
6253 assert( pPager->eState>=PAGER_WRITER_LOCKED );
drh50642b12015-06-30 03:34:13 +00006254 assert( assert_pager_state(pPager) );
drh66065862016-12-12 11:05:15 +00006255 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
drhb3475532015-06-29 20:53:18 +00006256 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
6257 return SQLITE_OK;
drh66065862016-12-12 11:05:15 +00006258 }else if( pPager->errCode ){
6259 return pPager->errCode;
drhb3475532015-06-29 20:53:18 +00006260 }else if( pPager->sectorSize > (u32)pPager->pageSize ){
dan41113b62016-04-05 21:07:58 +00006261 assert( pPager->tempFile==0 );
drhf063e082014-08-24 01:32:43 +00006262 return pagerWriteLargeSector(pPg);
danielk19774099f6e2007-03-19 11:25:20 +00006263 }else{
drhf063e082014-08-24 01:32:43 +00006264 return pager_write(pPg);
danielk19774099f6e2007-03-19 11:25:20 +00006265 }
danielk19774099f6e2007-03-19 11:25:20 +00006266}
6267
6268/*
drhaacc5432002-01-06 17:07:40 +00006269** Return TRUE if the page given in the argument was previously passed
danielk19773b8a05f2007-03-19 17:44:26 +00006270** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
drh6019e162001-07-02 17:51:45 +00006271** to change the content of the page.
6272*/
drh01be4632015-09-03 15:17:12 +00006273#if !defined(SQLITE_OMIT_CONCURRENT) || !defined(NDEBUG)
danielk19773b8a05f2007-03-19 17:44:26 +00006274int sqlite3PagerIswriteable(DbPage *pPg){
drh1aacbdb2015-06-29 18:29:10 +00006275 return pPg->flags & PGHDR_WRITEABLE;
drh6019e162001-07-02 17:51:45 +00006276}
dan04085292015-08-24 16:00:08 +00006277#endif
drh6019e162001-07-02 17:51:45 +00006278
drh001bbcb2003-03-19 03:14:00 +00006279/*
drh30e58752002-03-02 20:41:57 +00006280** A call to this routine tells the pager that it is not necessary to
drh538f5702007-04-13 02:14:30 +00006281** write the information on page pPg back to the disk, even though
drhdfe88ec2008-11-03 20:55:06 +00006282** that page might be marked as dirty. This happens, for example, when
6283** the page has been added as a leaf of the freelist and so its
6284** content no longer matters.
drh30e58752002-03-02 20:41:57 +00006285**
6286** The overlying software layer calls this routine when all of the data
danielk1977bea2a942009-01-20 17:06:27 +00006287** on the given page is unused. The pager marks the page as clean so
drh30e58752002-03-02 20:41:57 +00006288** that it does not get written to disk.
6289**
danielk1977bea2a942009-01-20 17:06:27 +00006290** Tests show that this optimization can quadruple the speed of large
6291** DELETE operations.
danc88ae522016-05-04 11:28:03 +00006292**
6293** This optimization cannot be used with a temp-file, as the page may
6294** have been dirty at the start of the transaction. In that case, if
6295** memory pressure forces page pPg out of the cache, the data does need
6296** to be written out to disk so that it may be read back in if the
6297** current transaction is rolled back.
drh30e58752002-03-02 20:41:57 +00006298*/
danielk1977bea2a942009-01-20 17:06:27 +00006299void sqlite3PagerDontWrite(PgHdr *pPg){
drh538f5702007-04-13 02:14:30 +00006300 Pager *pPager = pPg->pPager;
danc88ae522016-05-04 11:28:03 +00006301 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
danielk1977bea2a942009-01-20 17:06:27 +00006302 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
6303 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
6304 pPg->flags |= PGHDR_DONT_WRITE;
drhb3475532015-06-29 20:53:18 +00006305 pPg->flags &= ~PGHDR_WRITEABLE;
drha0f6b122016-05-13 15:22:06 +00006306 testcase( pPg->flags & PGHDR_NEED_SYNC );
dan5f848c32010-08-23 18:19:31 +00006307 pager_set_pagehash(pPg);
danielk197745d68822009-01-16 16:23:38 +00006308 }
drh30e58752002-03-02 20:41:57 +00006309}
6310
6311/*
danielk1977bea2a942009-01-20 17:06:27 +00006312** This routine is called to increment the value of the database file
6313** change-counter, stored as a 4-byte big-endian integer starting at
drh54a73472011-01-15 18:11:12 +00006314** byte offset 24 of the pager file. The secondary change counter at
6315** 92 is also updated, as is the SQLite version number at offset 96.
6316**
6317** But this only happens if the pPager->changeCountDone flag is false.
6318** To avoid excess churning of page 1, the update only happens once.
6319** See also the pager_write_changecounter() routine that does an
6320** unconditional update of the change counters.
danielk197745d68822009-01-16 16:23:38 +00006321**
drhb480dc22009-07-24 12:35:57 +00006322** If the isDirectMode flag is zero, then this is done by calling
danielk1977bea2a942009-01-20 17:06:27 +00006323** sqlite3PagerWrite() on page 1, then modifying the contents of the
6324** page data. In this case the file will be updated when the current
6325** transaction is committed.
6326**
drhb480dc22009-07-24 12:35:57 +00006327** The isDirectMode flag may only be non-zero if the library was compiled
danielk1977bea2a942009-01-20 17:06:27 +00006328** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
6329** if isDirect is non-zero, then the database file is updated directly
6330** by writing an updated version of page 1 using a call to the
6331** sqlite3OsWrite() function.
danielk197745d68822009-01-16 16:23:38 +00006332*/
danielk1977bea2a942009-01-20 17:06:27 +00006333static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
danielk1977c7b60172007-08-22 11:22:03 +00006334 int rc = SQLITE_OK;
drh80e35f42007-03-30 14:06:34 +00006335
dand0864082010-08-02 14:32:52 +00006336 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6337 || pPager->eState==PAGER_WRITER_DBMOD
6338 );
6339 assert( assert_pager_state(pPager) );
6340
danielk1977bea2a942009-01-20 17:06:27 +00006341 /* Declare and initialize constant integer 'isDirect'. If the
6342 ** atomic-write optimization is enabled in this build, then isDirect
6343 ** is initialized to the value passed as the isDirectMode parameter
6344 ** to this function. Otherwise, it is always set to zero.
6345 **
6346 ** The idea is that if the atomic-write optimization is not
6347 ** enabled at compile time, the compiler can omit the tests of
6348 ** 'isDirect' below, as well as the block enclosed in the
6349 ** "if( isDirect )" condition.
6350 */
drh701bb3b2008-08-02 03:50:39 +00006351#ifndef SQLITE_ENABLE_ATOMIC_WRITE
drhb480dc22009-07-24 12:35:57 +00006352# define DIRECT_MODE 0
danielk1977bea2a942009-01-20 17:06:27 +00006353 assert( isDirectMode==0 );
drhdc86e2b2009-01-24 11:30:42 +00006354 UNUSED_PARAMETER(isDirectMode);
danielk1977bea2a942009-01-20 17:06:27 +00006355#else
drhb480dc22009-07-24 12:35:57 +00006356# define DIRECT_MODE isDirectMode
drh701bb3b2008-08-02 03:50:39 +00006357#endif
danielk1977bea2a942009-01-20 17:06:27 +00006358
drh5db5c122023-02-04 20:07:52 +00006359 if( !pPager->changeCountDone && pPager->dbSize>0 ){
danielk1977bea2a942009-01-20 17:06:27 +00006360 PgHdr *pPgHdr; /* Reference to page 1 */
danielk1977bea2a942009-01-20 17:06:27 +00006361
6362 assert( !pPager->tempFile && isOpen(pPager->fd) );
6363
drh80e35f42007-03-30 14:06:34 +00006364 /* Open page 1 of the file for writing. */
drh9584f582015-11-04 20:22:37 +00006365 rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0);
danielk1977bea2a942009-01-20 17:06:27 +00006366 assert( pPgHdr==0 || rc==SQLITE_OK );
danielk1977c7b60172007-08-22 11:22:03 +00006367
danielk1977bea2a942009-01-20 17:06:27 +00006368 /* If page one was fetched successfully, and this function is not
drhad7516c2009-07-24 16:32:00 +00006369 ** operating in direct-mode, make page 1 writable. When not in
6370 ** direct mode, page 1 is always held in cache and hence the PagerGet()
6371 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
danielk1977bea2a942009-01-20 17:06:27 +00006372 */
drhc5aae5c2011-01-17 02:24:12 +00006373 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
danielk1977c7b60172007-08-22 11:22:03 +00006374 rc = sqlite3PagerWrite(pPgHdr);
danielk1977bea2a942009-01-20 17:06:27 +00006375 }
6376
6377 if( rc==SQLITE_OK ){
drh54a73472011-01-15 18:11:12 +00006378 /* Actually do the update of the change counter */
6379 pager_write_changecounter(pPgHdr);
drhf92a4e32010-03-19 16:55:47 +00006380
danielk1977bea2a942009-01-20 17:06:27 +00006381 /* If running in direct mode, write the contents of page 1 to the file. */
drhb480dc22009-07-24 12:35:57 +00006382 if( DIRECT_MODE ){
dan68928b62010-06-22 13:46:43 +00006383 const void *zBuf;
danielk1977bea2a942009-01-20 17:06:27 +00006384 assert( pPager->dbFileSize>0 );
drhb48c0d52020-02-07 01:12:53 +00006385 zBuf = pPgHdr->pData;
dan68928b62010-06-22 13:46:43 +00006386 if( rc==SQLITE_OK ){
6387 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
drh9ad3ee42012-03-24 20:06:14 +00006388 pPager->aStat[PAGER_STAT_WRITE]++;
dan68928b62010-06-22 13:46:43 +00006389 }
drhb480dc22009-07-24 12:35:57 +00006390 if( rc==SQLITE_OK ){
dan8e4714b2013-04-26 18:36:58 +00006391 /* Update the pager's copy of the change-counter. Otherwise, the
6392 ** next time a read transaction is opened the cache will be
6393 ** flushed (as the change-counter values will not match). */
6394 const void *pCopy = (const void *)&((const char *)zBuf)[24];
6395 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
drhb480dc22009-07-24 12:35:57 +00006396 pPager->changeCountDone = 1;
6397 }
6398 }else{
danielk1977bea2a942009-01-20 17:06:27 +00006399 pPager->changeCountDone = 1;
danielk1977ae72d982007-10-03 08:46:44 +00006400 }
danielk1977c7b60172007-08-22 11:22:03 +00006401 }
6402
drh80e35f42007-03-30 14:06:34 +00006403 /* Release the page reference. */
6404 sqlite3PagerUnref(pPgHdr);
drh80e35f42007-03-30 14:06:34 +00006405 }
danielk1977c7b60172007-08-22 11:22:03 +00006406 return rc;
drh80e35f42007-03-30 14:06:34 +00006407}
6408
6409/*
drhc97d8462010-11-19 18:23:35 +00006410** Sync the database file to disk. This is a no-op for in-memory databases
danielk1977bea2a942009-01-20 17:06:27 +00006411** or pages with the Pager.noSync flag set.
6412**
drhc97d8462010-11-19 18:23:35 +00006413** If successful, or if called on a pager for which it is a no-op, this
danielk1977bea2a942009-01-20 17:06:27 +00006414** function returns SQLITE_OK. Otherwise, an IO error code is returned.
danielk1977f653d782008-03-20 11:04:21 +00006415*/
drh067b92b2020-06-19 15:24:12 +00006416int sqlite3PagerSync(Pager *pPager, const char *zSuper){
drh534a58a2011-01-25 16:48:56 +00006417 int rc = SQLITE_OK;
drh067b92b2020-06-19 15:24:12 +00006418 void *pArg = (void*)zSuper;
drhafb39a42018-03-29 13:47:01 +00006419 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
6420 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
dana01abc32013-12-10 16:27:59 +00006421 if( rc==SQLITE_OK && !pPager->noSync ){
dand1cf7e22011-01-25 11:33:01 +00006422 assert( !MEMDB );
drhc97d8462010-11-19 18:23:35 +00006423 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
dan354bfe02011-01-11 17:39:37 +00006424 }
danielk1977f653d782008-03-20 11:04:21 +00006425 return rc;
6426}
6427
6428/*
dan04085292015-08-24 16:00:08 +00006429** This function is called to ensure that all locks required to commit the
6430** current write-transaction to the database file are held. If the db is
6431** in rollback mode, this means the EXCLUSIVE lock on the database file.
daneb9444a2010-07-30 10:02:24 +00006432**
danbf3cf572015-08-24 19:56:04 +00006433** Or, if this is a non-CONCURRENT transaction on a wal-mode database, this
dan04085292015-08-24 16:00:08 +00006434** function is a no-op.
6435**
danbf3cf572015-08-24 19:56:04 +00006436** If this is an CONCURRENT transaction on a wal-mode database, this function
dan04085292015-08-24 16:00:08 +00006437** attempts to obtain the WRITER lock on the wal file and also checks to
6438** see that the transaction can be safely committed (does not commit with
6439** any other transaction committed since it was opened).
6440**
6441** If the required locks are already held or successfully obtained and
6442** the transaction can be committed, SQLITE_OK is returned. If a required lock
6443** cannot be obtained, SQLITE_BUSY is returned. Or, if the current transaction
danbf3cf572015-08-24 19:56:04 +00006444** is CONCURRENT and cannot be committed due to a conflict, SQLITE_BUSY_SNAPSHOT
dan04085292015-08-24 16:00:08 +00006445** is returned. Otherwise, if some other error occurs (IO error, OOM etc.),
6446** and SQLite error code is returned.
daneb9444a2010-07-30 10:02:24 +00006447*/
dan995b2452017-05-29 19:23:56 +00006448int sqlite3PagerExclusiveLock(Pager *pPager, PgHdr *pPage1, Pgno *piConflict){
dandbf67732015-10-29 18:16:40 +00006449 int rc = pPager->errCode;
dand0864082010-08-02 14:32:52 +00006450 assert( assert_pager_state(pPager) );
dandbf67732015-10-29 18:16:40 +00006451 if( rc==SQLITE_OK ){
6452 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6453 || pPager->eState==PAGER_WRITER_DBMOD
6454 || pPager->eState==PAGER_WRITER_LOCKED
6455 );
6456 assert( assert_pager_state(pPager) );
6457 if( 0==pagerUseWal(pPager) ){
6458 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
dan3d394342015-07-27 19:31:45 +00006459 }
drhf12cc2a2015-10-30 17:17:12 +00006460#ifndef SQLITE_OMIT_CONCURRENT
6461 else{
6462 if( pPager->pAllRead ){
6463 /* This is an CONCURRENT transaction. Attempt to lock the wal database
6464 ** here. If SQLITE_BUSY (but not SQLITE_BUSY_SNAPSHOT) is returned,
6465 ** invoke the busy-handler and try again for as long as it returns
6466 ** non-zero. */
6467 do {
dan995b2452017-05-29 19:23:56 +00006468 rc = sqlite3WalLockForCommit(
6469 pPager->pWal, pPage1, pPager->pAllRead, piConflict
6470 );
drhf12cc2a2015-10-30 17:17:12 +00006471 }while( rc==SQLITE_BUSY
6472 && pPager->xBusyHandler(pPager->pBusyHandlerArg)
6473 );
6474 }
6475 }
drh01be4632015-09-03 15:17:12 +00006476#endif /* SQLITE_OMIT_CONCURRENT */
daneb9444a2010-07-30 10:02:24 +00006477 }
6478 return rc;
6479}
6480
drh01be4632015-09-03 15:17:12 +00006481#ifndef SQLITE_OMIT_CONCURRENT
dan04085292015-08-24 16:00:08 +00006482/*
danbf3cf572015-08-24 19:56:04 +00006483** This function is called as part of committing an CONCURRENT transaction.
dan04085292015-08-24 16:00:08 +00006484** At this point the wal WRITER lock is held, and all pages in the cache
6485** except for page 1 are compatible with the snapshot at the head of the
6486** wal file.
6487**
6488** This function updates the in-memory data structures and reloads the
6489** contents of page 1 so that the client is operating on the snapshot
6490** at the head of the wal file.
6491**
6492** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
6493*/
dan7b3d71e2015-08-19 20:27:05 +00006494int sqlite3PagerUpgradeSnapshot(Pager *pPager, DbPage *pPage1){
6495 int rc;
dan7b3d71e2015-08-19 20:27:05 +00006496
6497 assert( pPager->pWal && pPager->pAllRead );
dan654a9652015-08-24 06:43:25 +00006498 rc = sqlite3WalUpgradeSnapshot(pPager->pWal);
6499 if( rc==SQLITE_OK ){
drhb25057c2017-08-28 17:19:35 +00006500 rc = readDbPage(pPage1);
dan7b3d71e2015-08-19 20:27:05 +00006501 }
6502
6503 return rc;
6504}
6505
drh01be4632015-09-03 15:17:12 +00006506/* !defined(SQLITE_OMIT_CONCURRENT)
6507**
dan04085292015-08-24 16:00:08 +00006508** Set the in-memory cache of the database file size to nSz pages.
6509*/
6510void sqlite3PagerSetDbsize(Pager *pPager, Pgno nSz){
6511 pPager->dbSize = nSz;
6512}
6513
drh01be4632015-09-03 15:17:12 +00006514/* !defined(SQLITE_OMIT_CONCURRENT)
6515**
dan3d394342015-07-27 19:31:45 +00006516** If this is a WAL mode connection and the WRITER lock is currently held,
6517** relinquish it.
6518*/
6519void sqlite3PagerDropExclusiveLock(Pager *pPager){
6520 if( pagerUseWal(pPager) ){
6521 sqlite3WalEndWriteTransaction(pPager->pWal);
6522 }
6523}
drh01be4632015-09-03 15:17:12 +00006524#endif /* SQLITE_OMIT_CONCURRENT */
dan3d394342015-07-27 19:31:45 +00006525
dan7b3d71e2015-08-19 20:27:05 +00006526
dan3d394342015-07-27 19:31:45 +00006527/*
drh067b92b2020-06-19 15:24:12 +00006528** Sync the database file for the pager pPager. zSuper points to the name
6529** of a super-journal file that should be written into the individual
6530** journal file. zSuper may be NULL, which is interpreted as no
6531** super-journal (a single database transaction).
drh80e35f42007-03-30 14:06:34 +00006532**
danielk1977bea2a942009-01-20 17:06:27 +00006533** This routine ensures that:
6534**
6535** * The database file change-counter is updated,
6536** * the journal is synced (unless the atomic-write optimization is used),
6537** * all dirty pages are written to the database file,
6538** * the database file is truncated (if required), and
6539** * the database file synced.
6540**
6541** The only thing that remains to commit the transaction is to finalize
6542** (delete, truncate or zero the first part of) the journal file (or
drh067b92b2020-06-19 15:24:12 +00006543** delete the super-journal file if specified).
drh80e35f42007-03-30 14:06:34 +00006544**
drh067b92b2020-06-19 15:24:12 +00006545** Note that if zSuper==NULL, this does not overwrite a previous value
drh80e35f42007-03-30 14:06:34 +00006546** passed to an sqlite3PagerCommitPhaseOne() call.
6547**
danielk1977f653d782008-03-20 11:04:21 +00006548** If the final parameter - noSync - is true, then the database file itself
6549** is not synced. The caller must call sqlite3PagerSync() directly to
6550** sync the database file before calling CommitPhaseTwo() to delete the
6551** journal file in this case.
drh80e35f42007-03-30 14:06:34 +00006552*/
danielk1977f653d782008-03-20 11:04:21 +00006553int sqlite3PagerCommitPhaseOne(
danielk1977bea2a942009-01-20 17:06:27 +00006554 Pager *pPager, /* Pager object */
drh067b92b2020-06-19 15:24:12 +00006555 const char *zSuper, /* If not NULL, the super-journal name */
danielk1977bea2a942009-01-20 17:06:27 +00006556 int noSync /* True to omit the xSync on the db file */
danielk1977f653d782008-03-20 11:04:21 +00006557){
danielk1977bea2a942009-01-20 17:06:27 +00006558 int rc = SQLITE_OK; /* Return code */
drh80e35f42007-03-30 14:06:34 +00006559
dande1ae342010-08-06 12:00:27 +00006560 assert( pPager->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +00006561 || pPager->eState==PAGER_WRITER_CACHEMOD
6562 || pPager->eState==PAGER_WRITER_DBMOD
dan5db56402010-08-06 13:53:09 +00006563 || pPager->eState==PAGER_ERROR
dand0864082010-08-02 14:32:52 +00006564 );
6565 assert( assert_pager_state(pPager) );
6566
drhdd3cd972010-03-27 17:12:36 +00006567 /* If a prior error occurred, report that error again. */
drh719e3a72010-08-17 17:25:15 +00006568 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977dad31b52008-05-15 11:08:07 +00006569
drhead01fd2016-04-25 22:39:42 +00006570 /* Provide the ability to easily simulate an I/O error during testing */
drha7a45972016-05-12 19:05:35 +00006571 if( sqlite3FaultSim(400) ) return SQLITE_IOERR;
drhead01fd2016-04-25 22:39:42 +00006572
drh067b92b2020-06-19 15:24:12 +00006573 PAGERTRACE(("DATABASE SYNC: File=%s zSuper=%s nSize=%d\n",
6574 pPager->zFilename, zSuper, pPager->dbSize));
drh80e35f42007-03-30 14:06:34 +00006575
dand0864082010-08-02 14:32:52 +00006576 /* If no database changes have been made, return early. */
6577 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
6578
dan41113b62016-04-05 21:07:58 +00006579 assert( MEMDB==0 || pPager->tempFile );
dan199f56b2016-04-12 19:09:29 +00006580 assert( isOpen(pPager->fd) || pPager->tempFile );
drh4bf7d212016-05-13 12:12:38 +00006581 if( 0==pagerFlushOnCommit(pPager, 1) ){
drhb480dc22009-07-24 12:35:57 +00006582 /* If this is an in-memory db, or no pages have been written to, or this
6583 ** function has already been called, it is mostly a no-op. However, any
dan41113b62016-04-05 21:07:58 +00006584 ** backup in progress needs to be restarted. */
danielk197704103022009-02-03 16:51:24 +00006585 sqlite3BackupRestart(pPager->pBackup);
dand0864082010-08-02 14:32:52 +00006586 }else{
dan140a5982018-07-14 20:25:13 +00006587 PgHdr *pList;
drh7ed91f22010-04-29 22:34:07 +00006588 if( pagerUseWal(pPager) ){
drhe5a13202011-05-19 01:21:42 +00006589 PgHdr *pPageOne = 0;
dan140a5982018-07-14 20:25:13 +00006590 pList = sqlite3PcacheDirtyList(pPager->pPCache);
drhe5a13202011-05-19 01:21:42 +00006591 if( pList==0 ){
6592 /* Must have at least one page for the WAL commit flag.
6593 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
drh9584f582015-11-04 20:22:37 +00006594 rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0);
drhe5a13202011-05-19 01:21:42 +00006595 pList = pPageOne;
6596 pList->pDirty = 0;
6597 }
drh14438d12011-05-20 01:49:30 +00006598 assert( rc==SQLITE_OK );
6599 if( ALWAYS(pList) ){
drh4eb02a42011-12-16 21:26:26 +00006600 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
danielk197771aa7ff2008-05-20 07:05:09 +00006601 }
drhe5a13202011-05-19 01:21:42 +00006602 sqlite3PagerUnref(pPageOne);
dan10ec8942010-06-02 17:15:24 +00006603 if( rc==SQLITE_OK ){
6604 sqlite3PcacheCleanAll(pPager->pPCache);
6605 }
dan7c246102010-04-12 19:00:29 +00006606 }else{
drh2df94782017-07-22 16:32:33 +00006607 /* The bBatch boolean is true if the batch-atomic-write commit method
6608 ** should be used. No rollback journal is created if batch-atomic-write
6609 ** is enabled.
6610 */
drh2df94782017-07-22 16:32:33 +00006611#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
drh378a2da2018-07-18 17:37:51 +00006612 sqlite3_file *fd = pPager->fd;
drh067b92b2020-06-19 15:24:12 +00006613 int bBatch = zSuper==0 /* An SQLITE_IOCAP_BATCH_ATOMIC commit */
drh2df94782017-07-22 16:32:33 +00006614 && (sqlite3OsDeviceCharacteristics(fd) & SQLITE_IOCAP_BATCH_ATOMIC)
6615 && !pPager->noSync
6616 && sqlite3JournalIsInMemory(pPager->jfd);
6617#else
drh378a2da2018-07-18 17:37:51 +00006618# define bBatch 0
drh2df94782017-07-22 16:32:33 +00006619#endif
6620
6621#ifdef SQLITE_ENABLE_ATOMIC_WRITE
dan7c246102010-04-12 19:00:29 +00006622 /* The following block updates the change-counter. Exactly how it
6623 ** does this depends on whether or not the atomic-update optimization
6624 ** was enabled at compile time, and if this transaction meets the
6625 ** runtime criteria to use the operation:
6626 **
6627 ** * The file-system supports the atomic-write property for
6628 ** blocks of size page-size, and
6629 ** * This commit is not part of a multi-file transaction, and
6630 ** * Exactly one page has been modified and store in the journal file.
6631 **
6632 ** If the optimization was not enabled at compile time, then the
6633 ** pager_incr_changecounter() function is called to update the change
6634 ** counter in 'indirect-mode'. If the optimization is compiled in but
6635 ** is not applicable to this transaction, call sqlite3JournalCreate()
6636 ** to make sure the journal file has actually been created, then call
6637 ** pager_incr_changecounter() to update the change-counter in indirect
6638 ** mode.
6639 **
6640 ** Otherwise, if the optimization is both enabled and applicable,
6641 ** then call pager_incr_changecounter() to update the change-counter
6642 ** in 'direct' mode. In this case the journal file will never be
6643 ** created for this transaction.
6644 */
danefe16972017-07-20 19:49:14 +00006645 if( bBatch==0 ){
6646 PgHdr *pPg;
6647 assert( isOpen(pPager->jfd)
6648 || pPager->journalMode==PAGER_JOURNALMODE_OFF
6649 || pPager->journalMode==PAGER_JOURNALMODE_WAL
6650 );
drh067b92b2020-06-19 15:24:12 +00006651 if( !zSuper && isOpen(pPager->jfd)
danefe16972017-07-20 19:49:14 +00006652 && pPager->journalOff==jrnlBufferSize(pPager)
6653 && pPager->dbSize>=pPager->dbOrigSize
6654 && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
6655 ){
6656 /* Update the db file change counter via the direct-write method. The
6657 ** following call will modify the in-memory representation of page 1
6658 ** to include the updated change counter and then write page 1
6659 ** directly to the database file. Because of the atomic-write
6660 ** property of the host file-system, this is safe.
6661 */
6662 rc = pager_incr_changecounter(pPager, 1);
6663 }else{
6664 rc = sqlite3JournalCreate(pPager->jfd);
6665 if( rc==SQLITE_OK ){
6666 rc = pager_incr_changecounter(pPager, 0);
6667 }
danielk1977bea2a942009-01-20 17:06:27 +00006668 }
dan7c246102010-04-12 19:00:29 +00006669 }
dan140a5982018-07-14 20:25:13 +00006670#else /* SQLITE_ENABLE_ATOMIC_WRITE */
dand67a9772017-07-20 21:00:03 +00006671#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
drh067b92b2020-06-19 15:24:12 +00006672 if( zSuper ){
dand67a9772017-07-20 21:00:03 +00006673 rc = sqlite3JournalCreate(pPager->jfd);
6674 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
dan140a5982018-07-14 20:25:13 +00006675 assert( bBatch==0 );
dand67a9772017-07-20 21:00:03 +00006676 }
6677#endif
dan7c246102010-04-12 19:00:29 +00006678 rc = pager_incr_changecounter(pPager, 0);
dan140a5982018-07-14 20:25:13 +00006679#endif /* !SQLITE_ENABLE_ATOMIC_WRITE */
danielk1977bea2a942009-01-20 17:06:27 +00006680 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
dan7c246102010-04-12 19:00:29 +00006681
drh067b92b2020-06-19 15:24:12 +00006682 /* Write the super-journal name into the journal file. If a
6683 ** super-journal file name has already been written to the journal file,
6684 ** or if zSuper is NULL (no super-journal), then this call is a no-op.
dan7c246102010-04-12 19:00:29 +00006685 */
drh067b92b2020-06-19 15:24:12 +00006686 rc = writeSuperJournal(pPager, zSuper);
dan7c246102010-04-12 19:00:29 +00006687 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6688
dan51133ea2010-07-30 15:43:13 +00006689 /* Sync the journal file and write all dirty pages to the database.
6690 ** If the atomic-update optimization is being used, this sync will not
6691 ** create the journal file or perform any real IO.
6692 **
6693 ** Because the change-counter page was just modified, unless the
6694 ** atomic-update optimization is used it is almost certain that the
6695 ** journal requires a sync here. However, in locking_mode=exclusive
6696 ** on a system under memory pressure it is just possible that this is
6697 ** not the case. In this case it is likely enough that the redundant
6698 ** xSync() call will be changed to a no-op by the OS anyhow.
dan7c246102010-04-12 19:00:29 +00006699 */
dan937ac9d2010-08-03 12:48:45 +00006700 rc = syncJournal(pPager, 0);
dan7c246102010-04-12 19:00:29 +00006701 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
danefe16972017-07-20 19:49:14 +00006702
dan140a5982018-07-14 20:25:13 +00006703 pList = sqlite3PcacheDirtyList(pPager->pPCache);
dan4522c3e2018-07-17 13:55:08 +00006704#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
danefe16972017-07-20 19:49:14 +00006705 if( bBatch ){
danefe16972017-07-20 19:49:14 +00006706 rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, 0);
danefe16972017-07-20 19:49:14 +00006707 if( rc==SQLITE_OK ){
dan140a5982018-07-14 20:25:13 +00006708 rc = pager_write_pagelist(pPager, pList);
6709 if( rc==SQLITE_OK ){
6710 rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, 0);
6711 }
6712 if( rc!=SQLITE_OK ){
6713 sqlite3OsFileControlHint(fd, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, 0);
6714 }
danb8fff292018-01-23 14:01:51 +00006715 }
dan140a5982018-07-14 20:25:13 +00006716
6717 if( (rc&0xFF)==SQLITE_IOERR && rc!=SQLITE_IOERR_NOMEM ){
6718 rc = sqlite3JournalCreate(pPager->jfd);
6719 if( rc!=SQLITE_OK ){
6720 sqlite3OsClose(pPager->jfd);
drhb0b02302018-07-19 15:27:35 +00006721 goto commit_phase_one_exit;
dan140a5982018-07-14 20:25:13 +00006722 }
6723 bBatch = 0;
6724 }else{
6725 sqlite3OsClose(pPager->jfd);
danefe16972017-07-20 19:49:14 +00006726 }
6727 }
dan4522c3e2018-07-17 13:55:08 +00006728#endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */
danefe16972017-07-20 19:49:14 +00006729
drhb0b02302018-07-19 15:27:35 +00006730 if( bBatch==0 ){
dan140a5982018-07-14 20:25:13 +00006731 rc = pager_write_pagelist(pPager, pList);
6732 }
dan7c246102010-04-12 19:00:29 +00006733 if( rc!=SQLITE_OK ){
6734 assert( rc!=SQLITE_IOERR_BLOCKED );
6735 goto commit_phase_one_exit;
6736 }
6737 sqlite3PcacheCleanAll(pPager->pPCache);
danbc1a3c62013-02-23 16:40:46 +00006738
6739 /* If the file on disk is smaller than the database image, use
6740 ** pager_truncate to grow the file here. This can happen if the database
6741 ** image was extended as part of the current transaction and then the
6742 ** last page in the db image moved to the free-list. In this case the
6743 ** last page is never written out to disk, leaving the database file
6744 ** undersized. Fix this now if it is the case. */
6745 if( pPager->dbSize>pPager->dbFileSize ){
drh584bfca2022-02-23 17:00:44 +00006746 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
dand0864082010-08-02 14:32:52 +00006747 assert( pPager->eState==PAGER_WRITER_DBMOD );
dan7c246102010-04-12 19:00:29 +00006748 rc = pager_truncate(pPager, nNew);
6749 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6750 }
6751
6752 /* Finally, sync the database file. */
dan354bfe02011-01-11 17:39:37 +00006753 if( !noSync ){
drh067b92b2020-06-19 15:24:12 +00006754 rc = sqlite3PagerSync(pPager, zSuper);
dan7c246102010-04-12 19:00:29 +00006755 }
6756 IOTRACE(("DBSYNC %p\n", pPager))
danielk1977f90b7262009-01-07 15:18:20 +00006757 }
drh80e35f42007-03-30 14:06:34 +00006758 }
6759
danielk1977bea2a942009-01-20 17:06:27 +00006760commit_phase_one_exit:
dand0864082010-08-02 14:32:52 +00006761 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
6762 pPager->eState = PAGER_WRITER_FINISHED;
6763 }
drh80e35f42007-03-30 14:06:34 +00006764 return rc;
6765}
6766
6767
6768/*
danielk1977bea2a942009-01-20 17:06:27 +00006769** When this function is called, the database file has been completely
6770** updated to reflect the changes made by the current transaction and
6771** synced to disk. The journal file still exists in the file-system
6772** though, and if a failure occurs at this point it will eventually
6773** be used as a hot-journal and the current transaction rolled back.
drhd9b02572001-04-15 00:37:09 +00006774**
danielk1977bea2a942009-01-20 17:06:27 +00006775** This function finalizes the journal file, either by deleting,
6776** truncating or partially zeroing it, so that it cannot be used
6777** for hot-journal rollback. Once this is done the transaction is
6778** irrevocably committed.
6779**
6780** If an error occurs, an IO error code is returned and the pager
6781** moves into the error state. Otherwise, SQLITE_OK is returned.
drhed7c8552001-04-11 14:29:21 +00006782*/
drh80e35f42007-03-30 14:06:34 +00006783int sqlite3PagerCommitPhaseTwo(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00006784 int rc = SQLITE_OK; /* Return code */
drhd9b02572001-04-15 00:37:09 +00006785
drhb480dc22009-07-24 12:35:57 +00006786 /* This routine should not be called if a prior error has occurred.
6787 ** But if (due to a coding error elsewhere in the system) it does get
6788 ** called, just return the same error code without doing anything. */
6789 if( NEVER(pPager->errCode) ) return pPager->errCode;
dan7a1d7c32019-12-22 14:29:55 +00006790 pPager->iDataVersion++;
danielk1977bea2a942009-01-20 17:06:27 +00006791
dande1ae342010-08-06 12:00:27 +00006792 assert( pPager->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +00006793 || pPager->eState==PAGER_WRITER_FINISHED
6794 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
6795 );
6796 assert( assert_pager_state(pPager) );
6797
danielk1977bea2a942009-01-20 17:06:27 +00006798 /* An optimization. If the database was not actually modified during
6799 ** this transaction, the pager is running in exclusive-mode and is
6800 ** using persistent journals, then this function is a no-op.
6801 **
6802 ** The start of the journal file currently contains a single journal
6803 ** header with the nRec field set to 0. If such a journal is used as
6804 ** a hot-journal during hot-journal rollback, 0 changes will be made
6805 ** to the database file. So there is no need to zero the journal
6806 ** header. Since the pager is in exclusive mode, there is no need
6807 ** to drop any locks either.
6808 */
dande1ae342010-08-06 12:00:27 +00006809 if( pPager->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +00006810 && pPager->exclusiveMode
danielk19773cfe0702009-01-17 16:59:40 +00006811 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
6812 ){
dan6b63ab42010-06-30 10:36:18 +00006813 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
dand0864082010-08-02 14:32:52 +00006814 pPager->eState = PAGER_READER;
drhd138c012008-05-13 00:58:18 +00006815 return SQLITE_OK;
6816 }
danielk1977bea2a942009-01-20 17:06:27 +00006817
drh30d53702009-01-06 15:58:57 +00006818 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
drh067b92b2020-06-19 15:24:12 +00006819 rc = pager_end_transaction(pPager, pPager->setSuper, 1);
danielk1977bea2a942009-01-20 17:06:27 +00006820 return pager_error(pPager, rc);
drhed7c8552001-04-11 14:29:21 +00006821}
6822
6823/*
dan73d66fd2010-08-07 16:17:48 +00006824** If a write transaction is open, then all changes made within the
6825** transaction are reverted and the current write-transaction is closed.
6826** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
6827** state if an error occurs.
drhd9b02572001-04-15 00:37:09 +00006828**
dan73d66fd2010-08-07 16:17:48 +00006829** If the pager is already in PAGER_ERROR state when this function is called,
6830** it returns Pager.errCode immediately. No work is performed in this case.
6831**
6832** Otherwise, in rollback mode, this function performs two functions:
danielk1977bea2a942009-01-20 17:06:27 +00006833**
6834** 1) It rolls back the journal file, restoring all database file and
6835** in-memory cache pages to the state they were in when the transaction
6836** was opened, and
dan73d66fd2010-08-07 16:17:48 +00006837**
danielk1977bea2a942009-01-20 17:06:27 +00006838** 2) It finalizes the journal file, so that it is not used for hot
6839** rollback at any point in the future.
6840**
dan73d66fd2010-08-07 16:17:48 +00006841** Finalization of the journal file (task 2) is only performed if the
6842** rollback is successful.
danielk1977bea2a942009-01-20 17:06:27 +00006843**
dan73d66fd2010-08-07 16:17:48 +00006844** In WAL mode, all cache-entries containing data modified within the
6845** current transaction are either expelled from the cache or reverted to
6846** their pre-transaction state by re-reading data from the database or
6847** WAL files. The WAL transaction is then closed.
drhed7c8552001-04-11 14:29:21 +00006848*/
danielk19773b8a05f2007-03-19 17:44:26 +00006849int sqlite3PagerRollback(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00006850 int rc = SQLITE_OK; /* Return code */
drh30d53702009-01-06 15:58:57 +00006851 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
dand0864082010-08-02 14:32:52 +00006852
dande1ae342010-08-06 12:00:27 +00006853 /* PagerRollback() is a no-op if called in READER or OPEN state. If
dana42c66b2010-08-03 18:18:41 +00006854 ** the pager is already in the ERROR state, the rollback is not
6855 ** attempted here. Instead, the error code is returned to the caller.
6856 */
dand0864082010-08-02 14:32:52 +00006857 assert( assert_pager_state(pPager) );
dana42c66b2010-08-03 18:18:41 +00006858 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
dand0864082010-08-02 14:32:52 +00006859 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
6860
drh7ed91f22010-04-29 22:34:07 +00006861 if( pagerUseWal(pPager) ){
dan7c246102010-04-12 19:00:29 +00006862 int rc2;
6863 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
drh067b92b2020-06-19 15:24:12 +00006864 rc2 = pager_end_transaction(pPager, pPager->setSuper, 0);
dan7c246102010-04-12 19:00:29 +00006865 if( rc==SQLITE_OK ) rc = rc2;
dan73d66fd2010-08-07 16:17:48 +00006866 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
dan9f4beed2011-01-11 16:09:55 +00006867 int eState = pPager->eState;
danbc1a3c62013-02-23 16:40:46 +00006868 rc = pager_end_transaction(pPager, 0, 0);
dan9f4beed2011-01-11 16:09:55 +00006869 if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
6870 /* This can happen using journal_mode=off. Move the pager to the error
6871 ** state to indicate that the contents of the cache may not be trusted.
6872 ** Any active readers will get SQLITE_ABORT.
6873 */
6874 pPager->errCode = SQLITE_ABORT;
6875 pPager->eState = PAGER_ERROR;
drh12e6f682016-12-13 14:32:47 +00006876 setGetterMethod(pPager);
dan9f4beed2011-01-11 16:09:55 +00006877 return rc;
6878 }
drha6abd042004-06-09 17:37:22 +00006879 }else{
dana42c66b2010-08-03 18:18:41 +00006880 rc = pager_playback(pPager, 0);
danielk19778c0a7912008-08-20 14:49:23 +00006881 }
dan73d66fd2010-08-07 16:17:48 +00006882
dana42c66b2010-08-03 18:18:41 +00006883 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
dand4097922013-04-02 18:31:29 +00006884 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
dana01abc32013-12-10 16:27:59 +00006885 || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR
6886 || rc==SQLITE_CANTOPEN
6887 );
danb22aa4a2010-08-03 15:57:09 +00006888
6889 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
6890 ** cache. So call pager_error() on the way out to make any error persistent.
6891 */
6892 return pager_error(pPager, rc);
drh98808ba2001-10-18 12:34:46 +00006893}
drhd9b02572001-04-15 00:37:09 +00006894
6895/*
drh5e00f6c2001-09-13 13:46:56 +00006896** Return TRUE if the database file is opened read-only. Return FALSE
6897** if the database is (in theory) writable.
6898*/
drhf49661a2008-12-10 16:45:50 +00006899u8 sqlite3PagerIsreadonly(Pager *pPager){
drhbe0072d2001-09-13 14:46:09 +00006900 return pPager->readOnly;
drh5e00f6c2001-09-13 13:46:56 +00006901}
6902
drhe05b3f82015-07-01 17:53:49 +00006903#ifdef SQLITE_DEBUG
drh5e00f6c2001-09-13 13:46:56 +00006904/*
drh95a0b372015-09-03 20:43:55 +00006905** Return the sum of the reference counts for all pages held by pPager.
drh0f7eb612006-08-08 13:51:43 +00006906*/
danielk19773b8a05f2007-03-19 17:44:26 +00006907int sqlite3PagerRefcount(Pager *pPager){
danielk19778c0a7912008-08-20 14:49:23 +00006908 return sqlite3PcacheRefCount(pPager->pPCache);
drh0f7eb612006-08-08 13:51:43 +00006909}
drhe05b3f82015-07-01 17:53:49 +00006910#endif
drh0f7eb612006-08-08 13:51:43 +00006911
danielk197771d5d2c2008-09-29 11:49:47 +00006912/*
drh63da0892010-03-10 21:42:07 +00006913** Return the approximate number of bytes of memory currently
6914** used by the pager and its associated cache.
6915*/
6916int sqlite3PagerMemUsed(Pager *pPager){
larrybrb01f1382021-09-15 11:15:03 +00006917 int perPageSize = pPager->pageSize + pPager->nExtra
6918 + (int)(sizeof(PgHdr) + 5*sizeof(void*));
drh63da0892010-03-10 21:42:07 +00006919 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
drh233f8162010-07-28 17:36:11 +00006920 + sqlite3MallocSize(pPager)
drh0cf68a92010-07-29 10:13:25 +00006921 + pPager->pageSize;
drh63da0892010-03-10 21:42:07 +00006922}
6923
6924/*
danielk197771d5d2c2008-09-29 11:49:47 +00006925** Return the number of references to the specified page.
6926*/
6927int sqlite3PagerPageRefcount(DbPage *pPage){
6928 return sqlite3PcachePageRefcount(pPage);
6929}
6930
drh0f7eb612006-08-08 13:51:43 +00006931#ifdef SQLITE_TEST
6932/*
drhd9b02572001-04-15 00:37:09 +00006933** This routine is used for testing and analysis only.
6934*/
danielk19773b8a05f2007-03-19 17:44:26 +00006935int *sqlite3PagerStats(Pager *pPager){
danielk197742741be2005-01-08 12:42:39 +00006936 static int a[11];
danielk19778c0a7912008-08-20 14:49:23 +00006937 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
6938 a[1] = sqlite3PcachePagecount(pPager->pPCache);
6939 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
dande1ae342010-08-06 12:00:27 +00006940 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
dand0864082010-08-02 14:32:52 +00006941 a[4] = pPager->eState;
danielk1977efaaf572006-01-16 11:29:19 +00006942 a[5] = pPager->errCode;
drh9ad3ee42012-03-24 20:06:14 +00006943 a[6] = pPager->aStat[PAGER_STAT_HIT];
6944 a[7] = pPager->aStat[PAGER_STAT_MISS];
drh7c4ac0c2007-04-05 11:25:58 +00006945 a[8] = 0; /* Used to be pPager->nOvfl */
danielk197742741be2005-01-08 12:42:39 +00006946 a[9] = pPager->nRead;
drh9ad3ee42012-03-24 20:06:14 +00006947 a[10] = pPager->aStat[PAGER_STAT_WRITE];
drhd9b02572001-04-15 00:37:09 +00006948 return a;
6949}
danielk197704103022009-02-03 16:51:24 +00006950#endif
6951
6952/*
drhffc78a42018-03-14 14:53:50 +00006953** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE,
6954** or _WRITE+1. The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation
6955** of SQLITE_DBSTATUS_CACHE_SPILL. The _SPILL case is not contiguous because
6956** it was added later.
6957**
6958** Before returning, *pnVal is incremented by the
dan58ca31c2011-09-22 14:41:16 +00006959** current cache hit or miss count, according to the value of eStat. If the
6960** reset parameter is non-zero, the cache hit or miss count is zeroed before
6961** returning.
6962*/
6963void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
dan58ca31c2011-09-22 14:41:16 +00006964
6965 assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
6966 || eStat==SQLITE_DBSTATUS_CACHE_MISS
drh9ad3ee42012-03-24 20:06:14 +00006967 || eStat==SQLITE_DBSTATUS_CACHE_WRITE
drhffc78a42018-03-14 14:53:50 +00006968 || eStat==SQLITE_DBSTATUS_CACHE_WRITE+1
dan58ca31c2011-09-22 14:41:16 +00006969 );
dan58ca31c2011-09-22 14:41:16 +00006970
drh9ad3ee42012-03-24 20:06:14 +00006971 assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
6972 assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
drhffc78a42018-03-14 14:53:50 +00006973 assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1
6974 && PAGER_STAT_WRITE==2 && PAGER_STAT_SPILL==3 );
drh9ad3ee42012-03-24 20:06:14 +00006975
drhffc78a42018-03-14 14:53:50 +00006976 eStat -= SQLITE_DBSTATUS_CACHE_HIT;
6977 *pnVal += pPager->aStat[eStat];
dan58ca31c2011-09-22 14:41:16 +00006978 if( reset ){
drhffc78a42018-03-14 14:53:50 +00006979 pPager->aStat[eStat] = 0;
dan58ca31c2011-09-22 14:41:16 +00006980 }
6981}
6982
6983/*
dan9131ab92016-04-06 18:20:51 +00006984** Return true if this is an in-memory or temp-file backed pager.
danielk197704103022009-02-03 16:51:24 +00006985*/
danielk197717b90b52008-06-06 11:11:25 +00006986int sqlite3PagerIsMemdb(Pager *pPager){
drh021e2282021-10-23 20:32:27 +00006987 return pPager->tempFile || pPager->memVfs;
danielk197717b90b52008-06-06 11:11:25 +00006988}
drhdd793422001-06-28 01:54:48 +00006989
drhfa86c412002-02-02 15:01:15 +00006990/*
danielk1977bea2a942009-01-20 17:06:27 +00006991** Check that there are at least nSavepoint savepoints open. If there are
6992** currently less than nSavepoints open, then open one or more savepoints
6993** to make up the difference. If the number of savepoints is already
6994** equal to nSavepoint, then this function is a no-op.
6995**
6996** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
6997** occurs while opening the sub-journal file, then an IO error code is
6998** returned. Otherwise, SQLITE_OK.
drhfa86c412002-02-02 15:01:15 +00006999*/
drh31699062015-06-30 11:07:32 +00007000static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){
danielk1977bea2a942009-01-20 17:06:27 +00007001 int rc = SQLITE_OK; /* Return code */
7002 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
drh31699062015-06-30 11:07:32 +00007003 int ii; /* Iterator variable */
7004 PagerSavepoint *aNew; /* New Pager.aSavepoint array */
danielk1977fd7f0452008-12-17 17:30:26 +00007005
dande1ae342010-08-06 12:00:27 +00007006 assert( pPager->eState>=PAGER_WRITER_LOCKED );
dan937ac9d2010-08-03 12:48:45 +00007007 assert( assert_pager_state(pPager) );
drh31699062015-06-30 11:07:32 +00007008 assert( nSavepoint>nCurrent && pPager->useJournal );
dan937ac9d2010-08-03 12:48:45 +00007009
drh31699062015-06-30 11:07:32 +00007010 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
7011 ** if the allocation fails. Otherwise, zero the new portion in case a
7012 ** malloc failure occurs while populating it in the for(...) loop below.
7013 */
7014 aNew = (PagerSavepoint *)sqlite3Realloc(
7015 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
7016 );
7017 if( !aNew ){
mistachkinfad30392016-02-13 23:43:46 +00007018 return SQLITE_NOMEM_BKPT;
drh31699062015-06-30 11:07:32 +00007019 }
7020 memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
7021 pPager->aSavepoint = aNew;
drhdd3cd972010-03-27 17:12:36 +00007022
drh31699062015-06-30 11:07:32 +00007023 /* Populate the PagerSavepoint structures just allocated. */
7024 for(ii=nCurrent; ii<nSavepoint; ii++){
7025 aNew[ii].nOrig = pPager->dbSize;
7026 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
7027 aNew[ii].iOffset = pPager->journalOff;
7028 }else{
7029 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
7030 }
7031 aNew[ii].iSubRec = pPager->nSubRec;
7032 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
danf43fef22021-02-22 15:44:45 +00007033 aNew[ii].bTruncateOnRelease = 1;
drh31699062015-06-30 11:07:32 +00007034 if( !aNew[ii].pInSavepoint ){
mistachkinfad30392016-02-13 23:43:46 +00007035 return SQLITE_NOMEM_BKPT;
danielk1977fd7f0452008-12-17 17:30:26 +00007036 }
drh31699062015-06-30 11:07:32 +00007037 if( pagerUseWal(pPager) ){
7038 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
drh334b2992007-09-06 23:28:23 +00007039 }
drh31699062015-06-30 11:07:32 +00007040 pPager->nSavepoint = ii+1;
drh0f892532002-05-30 12:27:03 +00007041 }
drh31699062015-06-30 11:07:32 +00007042 assert( pPager->nSavepoint==nSavepoint );
7043 assertTruncateConstraint(pPager);
drh86f8c192007-08-22 00:39:19 +00007044 return rc;
7045}
drh31699062015-06-30 11:07:32 +00007046int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
7047 assert( pPager->eState>=PAGER_WRITER_LOCKED );
7048 assert( assert_pager_state(pPager) );
7049
7050 if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){
7051 return pagerOpenSavepoint(pPager, nSavepoint);
7052 }else{
7053 return SQLITE_OK;
7054 }
7055}
7056
drhfa86c412002-02-02 15:01:15 +00007057
7058/*
danielk1977bea2a942009-01-20 17:06:27 +00007059** This function is called to rollback or release (commit) a savepoint.
7060** The savepoint to release or rollback need not be the most recently
7061** created savepoint.
7062**
danielk1977fd7f0452008-12-17 17:30:26 +00007063** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
7064** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
7065** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
shanebe217792009-03-05 04:20:31 +00007066** that have occurred since the specified savepoint was created.
danielk1977fd7f0452008-12-17 17:30:26 +00007067**
danielk1977bea2a942009-01-20 17:06:27 +00007068** The savepoint to rollback or release is identified by parameter
7069** iSavepoint. A value of 0 means to operate on the outermost savepoint
7070** (the first created). A value of (Pager.nSavepoint-1) means operate
7071** on the most recently created savepoint. If iSavepoint is greater than
7072** (Pager.nSavepoint-1), then this function is a no-op.
danielk1977fd7f0452008-12-17 17:30:26 +00007073**
danielk1977bea2a942009-01-20 17:06:27 +00007074** If a negative value is passed to this function, then the current
7075** transaction is rolled back. This is different to calling
7076** sqlite3PagerRollback() because this function does not terminate
7077** the transaction or unlock the database, it just restores the
7078** contents of the database to its original state.
7079**
7080** In any case, all savepoints with an index greater than iSavepoint
7081** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
7082** then savepoint iSavepoint is also destroyed.
7083**
7084** This function may return SQLITE_NOMEM if a memory allocation fails,
7085** or an IO error code if an IO error occurs while rolling back a
7086** savepoint. If no errors occur, SQLITE_OK is returned.
danielk1977fd7f0452008-12-17 17:30:26 +00007087*/
7088int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
dand0d49b92016-09-01 09:35:20 +00007089 int rc = pPager->errCode;
7090
7091#ifdef SQLITE_ENABLE_ZIPVFS
7092 if( op==SAVEPOINT_RELEASE ) rc = SQLITE_OK;
7093#endif
danielk1977fd7f0452008-12-17 17:30:26 +00007094
7095 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
danielk1977bea2a942009-01-20 17:06:27 +00007096 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
danielk1977fd7f0452008-12-17 17:30:26 +00007097
dan4e004aa2010-08-05 15:30:22 +00007098 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
danielk1977bea2a942009-01-20 17:06:27 +00007099 int ii; /* Iterator variable */
7100 int nNew; /* Number of remaining savepoints after this op. */
7101
7102 /* Figure out how many savepoints will still be active after this
7103 ** operation. Store this value in nNew. Then free resources associated
7104 ** with any savepoints that are destroyed by this operation.
7105 */
shaneh6885de32010-02-05 16:28:00 +00007106 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
danielk1977fd7f0452008-12-17 17:30:26 +00007107 for(ii=nNew; ii<pPager->nSavepoint; ii++){
7108 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
7109 }
7110 pPager->nSavepoint = nNew;
7111
drh57dd7e62021-09-13 13:53:13 +00007112 /* Truncate the sub-journal so that it only includes the parts
7113 ** that are still in use. */
shaneh6885de32010-02-05 16:28:00 +00007114 if( op==SAVEPOINT_RELEASE ){
danf43fef22021-02-22 15:44:45 +00007115 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
7116 if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){
shaneh6885de32010-02-05 16:28:00 +00007117 /* Only truncate if it is an in-memory sub-journal. */
dan2491de22016-02-27 20:14:55 +00007118 if( sqlite3JournalIsInMemory(pPager->sjfd) ){
drh57dd7e62021-09-13 13:53:13 +00007119 i64 sz = (pPager->pageSize+4)*(i64)pRel->iSubRec;
danf43fef22021-02-22 15:44:45 +00007120 rc = sqlite3OsTruncate(pPager->sjfd, sz);
drh35173242010-03-08 21:40:13 +00007121 assert( rc==SQLITE_OK );
shaneh6885de32010-02-05 16:28:00 +00007122 }
danf43fef22021-02-22 15:44:45 +00007123 pPager->nSubRec = pRel->iSubRec;
shaneh6885de32010-02-05 16:28:00 +00007124 }
7125 }
7126 /* Else this is a rollback operation, playback the specified savepoint.
danielk1977bea2a942009-01-20 17:06:27 +00007127 ** If this is a temp-file, it is possible that the journal file has
7128 ** not yet been opened. In this case there have been no changes to
7129 ** the database file, so the playback operation can be skipped.
7130 */
drh7ed91f22010-04-29 22:34:07 +00007131 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
danielk1977f3107512008-12-22 10:58:46 +00007132 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
danielk1977fd7f0452008-12-17 17:30:26 +00007133 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
7134 assert(rc!=SQLITE_DONE);
7135 }
dand0d49b92016-09-01 09:35:20 +00007136
7137#ifdef SQLITE_ENABLE_ZIPVFS
7138 /* If the cache has been modified but the savepoint cannot be rolled
7139 ** back journal_mode=off, put the pager in the error state. This way,
7140 ** if the VFS used by this pager includes ZipVFS, the entire transaction
7141 ** can be rolled back at the ZipVFS level. */
7142 else if(
7143 pPager->journalMode==PAGER_JOURNALMODE_OFF
7144 && pPager->eState>=PAGER_WRITER_CACHEMOD
7145 ){
7146 pPager->errCode = SQLITE_ABORT;
7147 pPager->eState = PAGER_ERROR;
drhfc4111f2016-12-13 18:47:54 +00007148 setGetterMethod(pPager);
dand0d49b92016-09-01 09:35:20 +00007149 }
7150#endif
drh663fc632002-02-02 18:49:19 +00007151 }
dan4e004aa2010-08-05 15:30:22 +00007152
drhfa86c412002-02-02 15:01:15 +00007153 return rc;
7154}
7155
drh73509ee2003-04-06 20:44:45 +00007156/*
7157** Return the full pathname of the database file.
drhd4e0bb02012-05-27 01:19:04 +00007158**
7159** Except, if the pager is in-memory only, then return an empty string if
7160** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when
7161** used to report the filename to the user, for compatibility with legacy
7162** behavior. But when the Btree needs to know the filename for matching to
7163** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
7164** participate in shared-cache.
drh80804032020-01-11 16:08:31 +00007165**
7166** The return value to this routine is always safe to use with
7167** sqlite3_uri_parameter() and sqlite3_filename_database() and friends.
drh73509ee2003-04-06 20:44:45 +00007168*/
drh8875b9e2020-01-10 18:05:55 +00007169const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){
drhbe284e42020-02-27 16:21:39 +00007170 static const char zFake[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
drhcf3107c2022-11-19 00:08:35 +00007171 if( nullIfMemDb && (pPager->memDb || sqlite3IsMemdb(pPager->pVfs)) ){
7172 return &zFake[4];
7173 }else{
7174 return pPager->zFilename;
7175 }
drh73509ee2003-04-06 20:44:45 +00007176}
7177
drhb20ea9d2004-02-09 01:20:36 +00007178/*
drhd0679ed2007-08-28 22:24:34 +00007179** Return the VFS structure for the pager.
7180*/
drh790f2872015-11-28 18:06:36 +00007181sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
drhd0679ed2007-08-28 22:24:34 +00007182 return pPager->pVfs;
7183}
7184
7185/*
drhcc6bb3e2007-08-31 16:11:35 +00007186** Return the file handle for the database file associated
7187** with the pager. This might return NULL if the file has
7188** not yet been opened.
7189*/
7190sqlite3_file *sqlite3PagerFile(Pager *pPager){
7191 return pPager->fd;
7192}
7193
7194/*
drh21d61852016-01-08 02:27:01 +00007195** Return the file handle for the journal file (if it exists).
7196** This will be either the rollback journal or the WAL file.
7197*/
7198sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){
drhb4acd6a2016-01-14 01:56:43 +00007199#if SQLITE_OMIT_WAL
7200 return pPager->jfd;
7201#else
drh21d61852016-01-08 02:27:01 +00007202 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
drhb4acd6a2016-01-14 01:56:43 +00007203#endif
drh21d61852016-01-08 02:27:01 +00007204}
7205
7206/*
danielk19775865e3d2004-06-14 06:03:57 +00007207** Return the full pathname of the journal file.
7208*/
danielk19773b8a05f2007-03-19 17:44:26 +00007209const char *sqlite3PagerJournalname(Pager *pPager){
danielk19775865e3d2004-06-14 06:03:57 +00007210 return pPager->zJournal;
7211}
7212
danielk1977687566d2004-11-02 12:56:41 +00007213#ifndef SQLITE_OMIT_AUTOVACUUM
7214/*
danielk197787c29a92008-01-18 11:33:16 +00007215** Move the page pPg to location pgno in the file.
danielk1977687566d2004-11-02 12:56:41 +00007216**
drh5e385312007-06-16 04:42:12 +00007217** There must be no references to the page previously located at
7218** pgno (which we call pPgOld) though that page is allowed to be
drhb3df2e12008-09-17 20:06:26 +00007219** in cache. If the page previously located at pgno is not already
drh5e385312007-06-16 04:42:12 +00007220** in the rollback journal, it is not put there by by this routine.
danielk1977687566d2004-11-02 12:56:41 +00007221**
drh5e385312007-06-16 04:42:12 +00007222** References to the page pPg remain valid. Updating any
7223** meta-data associated with pPg (i.e. data stored in the nExtra bytes
danielk1977687566d2004-11-02 12:56:41 +00007224** allocated along with the page) is the responsibility of the caller.
7225**
danielk19775fd057a2005-03-09 13:09:43 +00007226** A transaction must be active when this routine is called. It used to be
7227** required that a statement transaction was not active, but this restriction
7228** has been removed (CREATE INDEX needs to move a page when a statement
7229** transaction is active).
danielk19774c999992008-07-16 18:17:55 +00007230**
7231** If the fourth argument, isCommit, is non-zero, then this page is being
7232** moved as part of a database reorganization just before the transaction
7233** is being committed. In this case, it is guaranteed that the database page
7234** pPg refers to will not be written to again within this transaction.
danielk1977bea2a942009-01-20 17:06:27 +00007235**
7236** This function may return SQLITE_NOMEM or an IO error code if an error
7237** occurs. Otherwise, it returns SQLITE_OK.
danielk1977687566d2004-11-02 12:56:41 +00007238*/
danielk19774c999992008-07-16 18:17:55 +00007239int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
danielk1977bea2a942009-01-20 17:06:27 +00007240 PgHdr *pPgOld; /* The page being overwritten. */
7241 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
7242 int rc; /* Return code */
drh86655a12009-03-31 02:54:40 +00007243 Pgno origPgno; /* The original page number */
danielk1977687566d2004-11-02 12:56:41 +00007244
danielk1977687566d2004-11-02 12:56:41 +00007245 assert( pPg->nRef>0 );
dand0864082010-08-02 14:32:52 +00007246 assert( pPager->eState==PAGER_WRITER_CACHEMOD
7247 || pPager->eState==PAGER_WRITER_DBMOD
7248 );
7249 assert( assert_pager_state(pPager) );
danielk1977687566d2004-11-02 12:56:41 +00007250
drh8c30f722009-11-20 18:48:35 +00007251 /* In order to be able to rollback, an in-memory database must journal
7252 ** the page we are moving from.
7253 */
drhd22f5092016-05-12 18:38:45 +00007254 assert( pPager->tempFile || !MEMDB );
dand87efd72016-04-06 15:39:03 +00007255 if( pPager->tempFile ){
drh8c30f722009-11-20 18:48:35 +00007256 rc = sqlite3PagerWrite(pPg);
7257 if( rc ) return rc;
7258 }
7259
danielk19771fab7b62009-01-07 10:35:18 +00007260 /* If the page being moved is dirty and has not been saved by the latest
7261 ** savepoint, then save the current contents of the page into the
7262 ** sub-journal now. This is required to handle the following scenario:
7263 **
7264 ** BEGIN;
7265 ** <journal page X, then modify it in memory>
7266 ** SAVEPOINT one;
7267 ** <Move page X to location Y>
7268 ** ROLLBACK TO one;
7269 **
7270 ** If page X were not written to the sub-journal here, it would not
7271 ** be possible to restore its contents when the "ROLLBACK TO one"
danielk1977bea2a942009-01-20 17:06:27 +00007272 ** statement were is processed.
7273 **
7274 ** subjournalPage() may need to allocate space to store pPg->pgno into
7275 ** one or more savepoint bitvecs. This is the reason this function
7276 ** may return SQLITE_NOMEM.
danielk19771fab7b62009-01-07 10:35:18 +00007277 */
drh60e32ed2015-06-29 19:08:18 +00007278 if( (pPg->flags & PGHDR_DIRTY)!=0
7279 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
danielk19771fab7b62009-01-07 10:35:18 +00007280 ){
7281 return rc;
7282 }
7283
drh30d53702009-01-06 15:58:57 +00007284 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
7285 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
drhb0603412007-02-28 04:47:26 +00007286 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
danielk1977ef73ee92004-11-06 12:26:07 +00007287
danielk19774c999992008-07-16 18:17:55 +00007288 /* If the journal needs to be sync()ed before page pPg->pgno can
7289 ** be written to, store pPg->pgno in local variable needSyncPgno.
7290 **
7291 ** If the isCommit flag is set, there is no need to remember that
7292 ** the journal needs to be sync()ed before database page pPg->pgno
7293 ** can be written to. The caller has already promised not to write to it.
7294 */
danielk19778c0a7912008-08-20 14:49:23 +00007295 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
danielk197794daf7f2004-11-08 09:26:09 +00007296 needSyncPgno = pPg->pgno;
drh6ffb4972013-03-01 21:01:05 +00007297 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
drh5dee6af2013-12-13 20:45:50 +00007298 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
danielk19778c0a7912008-08-20 14:49:23 +00007299 assert( pPg->flags&PGHDR_DIRTY );
danielk197794daf7f2004-11-08 09:26:09 +00007300 }
7301
danielk1977ef73ee92004-11-06 12:26:07 +00007302 /* If the cache contains a page with page-number pgno, remove it
dan51133ea2010-07-30 15:43:13 +00007303 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
danielk1977599fcba2004-11-08 07:13:13 +00007304 ** page pgno before the 'move' operation, it needs to be retained
7305 ** for the page moved there.
danielk1977f5fdda82004-11-03 08:44:05 +00007306 */
danielk1977bc2ca9e2008-11-13 14:28:28 +00007307 pPg->flags &= ~PGHDR_NEED_SYNC;
drhc1378072014-08-25 11:33:41 +00007308 pPgOld = sqlite3PagerLookup(pPager, pgno);
drhaff0fd42019-03-06 14:08:41 +00007309 assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB );
drh6e2ef432009-07-22 02:02:39 +00007310 if( pPgOld ){
drhda125362021-10-16 18:53:36 +00007311 if( NEVER(pPgOld->nRef>1) ){
drhaff0fd42019-03-06 14:08:41 +00007312 sqlite3PagerUnrefNotNull(pPgOld);
7313 return SQLITE_CORRUPT_BKPT;
7314 }
danielk19778c0a7912008-08-20 14:49:23 +00007315 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
dand87efd72016-04-06 15:39:03 +00007316 if( pPager->tempFile ){
drh98829a62009-11-20 13:18:14 +00007317 /* Do not discard pages from an in-memory database since we might
7318 ** need to rollback later. Just move the page out of the way. */
drh98829a62009-11-20 13:18:14 +00007319 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
7320 }else{
7321 sqlite3PcacheDrop(pPgOld);
7322 }
drh5e385312007-06-16 04:42:12 +00007323 }
danielk1977687566d2004-11-02 12:56:41 +00007324
drh86655a12009-03-31 02:54:40 +00007325 origPgno = pPg->pgno;
danielk19778c0a7912008-08-20 14:49:23 +00007326 sqlite3PcacheMove(pPg, pgno);
drhc047b9f2008-11-21 03:23:43 +00007327 sqlite3PcacheMakeDirty(pPg);
danielk1977687566d2004-11-02 12:56:41 +00007328
dan4e004aa2010-08-05 15:30:22 +00007329 /* For an in-memory database, make sure the original page continues
7330 ** to exist, in case the transaction needs to roll back. Use pPgOld
7331 ** as the original page since it has already been allocated.
7332 */
drhd12bc602016-05-10 20:03:08 +00007333 if( pPager->tempFile && pPgOld ){
dan4e004aa2010-08-05 15:30:22 +00007334 sqlite3PcacheMove(pPgOld, origPgno);
drhda8a3302013-12-13 19:35:21 +00007335 sqlite3PagerUnrefNotNull(pPgOld);
dan4e004aa2010-08-05 15:30:22 +00007336 }
7337
danielk197794daf7f2004-11-08 09:26:09 +00007338 if( needSyncPgno ){
7339 /* If needSyncPgno is non-zero, then the journal file needs to be
7340 ** sync()ed before any data is written to database file page needSyncPgno.
7341 ** Currently, no such page exists in the page-cache and the
danielk19774c999992008-07-16 18:17:55 +00007342 ** "is journaled" bitvec flag has been set. This needs to be remedied by
dan51133ea2010-07-30 15:43:13 +00007343 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
danielk19774c999992008-07-16 18:17:55 +00007344 ** flag.
danielk1977ae825582004-11-23 09:06:55 +00007345 **
danielk1977a98d7b42008-01-18 13:42:54 +00007346 ** If the attempt to load the page into the page-cache fails, (due
drhf5e7bb52008-02-18 14:47:33 +00007347 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
danielk1977a98d7b42008-01-18 13:42:54 +00007348 ** array. Otherwise, if the page is loaded and written again in
7349 ** this transaction, it may be written to the database file before
7350 ** it is synced into the journal file. This way, it may end up in
7351 ** the journal file twice, but that is not a problem.
danielk197794daf7f2004-11-08 09:26:09 +00007352 */
danielk19773b8a05f2007-03-19 17:44:26 +00007353 PgHdr *pPgHdr;
drh9584f582015-11-04 20:22:37 +00007354 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0);
danielk197787c29a92008-01-18 11:33:16 +00007355 if( rc!=SQLITE_OK ){
drh6aac11d2009-07-18 20:01:37 +00007356 if( needSyncPgno<=pPager->dbOrigSize ){
drhe98c9042009-06-02 21:31:38 +00007357 assert( pPager->pTmpSpace!=0 );
7358 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
danielk1977a98d7b42008-01-18 13:42:54 +00007359 }
danielk197787c29a92008-01-18 11:33:16 +00007360 return rc;
7361 }
danielk19778c0a7912008-08-20 14:49:23 +00007362 pPgHdr->flags |= PGHDR_NEED_SYNC;
drhc047b9f2008-11-21 03:23:43 +00007363 sqlite3PcacheMakeDirty(pPgHdr);
drhda8a3302013-12-13 19:35:21 +00007364 sqlite3PagerUnrefNotNull(pPgHdr);
danielk197794daf7f2004-11-08 09:26:09 +00007365 }
7366
danielk1977687566d2004-11-02 12:56:41 +00007367 return SQLITE_OK;
7368}
dane6593d82014-10-24 16:40:49 +00007369#endif
dan33ea4862014-10-09 19:35:37 +00007370
dane6593d82014-10-24 16:40:49 +00007371/*
7372** The page handle passed as the first argument refers to a dirty page
7373** with a page number other than iNew. This function changes the page's
7374** page number to iNew and sets the value of the PgHdr.flags field to
7375** the value passed as the third parameter.
7376*/
dan31f4e992014-10-24 20:57:03 +00007377void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
dane6593d82014-10-24 16:40:49 +00007378 assert( pPg->pgno!=iNew );
7379 pPg->flags = flags;
dan33ea4862014-10-09 19:35:37 +00007380 sqlite3PcacheMove(pPg, iNew);
7381}
7382
danielk19773b8a05f2007-03-19 17:44:26 +00007383/*
7384** Return a pointer to the data for the specified page.
7385*/
7386void *sqlite3PagerGetData(DbPage *pPg){
danielk197771d5d2c2008-09-29 11:49:47 +00007387 assert( pPg->nRef>0 || pPg->pPager->memDb );
danielk19778c0a7912008-08-20 14:49:23 +00007388 return pPg->pData;
danielk19773b8a05f2007-03-19 17:44:26 +00007389}
7390
7391/*
7392** Return a pointer to the Pager.nExtra bytes of "extra" space
7393** allocated along with the specified page.
7394*/
7395void *sqlite3PagerGetExtra(DbPage *pPg){
drh6aac11d2009-07-18 20:01:37 +00007396 return pPg->pExtra;
danielk19773b8a05f2007-03-19 17:44:26 +00007397}
7398
danielk197741483462007-03-24 16:45:04 +00007399/*
7400** Get/set the locking-mode for this pager. Parameter eMode must be one
7401** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
7402** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
7403** the locking-mode is set to the value specified.
7404**
7405** The returned value is either PAGER_LOCKINGMODE_NORMAL or
7406** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
7407** locking-mode.
7408*/
7409int sqlite3PagerLockingMode(Pager *pPager, int eMode){
drh369339d2007-03-30 16:01:55 +00007410 assert( eMode==PAGER_LOCKINGMODE_QUERY
7411 || eMode==PAGER_LOCKINGMODE_NORMAL
7412 || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
7413 assert( PAGER_LOCKINGMODE_QUERY<0 );
7414 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
dan8c408002010-11-01 17:38:24 +00007415 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
7416 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
drh1bd10f82008-12-10 21:19:56 +00007417 pPager->exclusiveMode = (u8)eMode;
danielk197741483462007-03-24 16:45:04 +00007418 }
7419 return (int)pPager->exclusiveMode;
7420}
7421
drh3b020132008-04-17 17:02:01 +00007422/*
drh0b9b4302010-06-11 17:01:24 +00007423** Set the journal-mode for this pager. Parameter eMode must be one of:
drh3b020132008-04-17 17:02:01 +00007424**
drh04335882008-09-26 21:08:08 +00007425** PAGER_JOURNALMODE_DELETE
7426** PAGER_JOURNALMODE_TRUNCATE
7427** PAGER_JOURNALMODE_PERSIST
7428** PAGER_JOURNALMODE_OFF
danielk1977bea2a942009-01-20 17:06:27 +00007429** PAGER_JOURNALMODE_MEMORY
dan7c246102010-04-12 19:00:29 +00007430** PAGER_JOURNALMODE_WAL
drh04335882008-09-26 21:08:08 +00007431**
drh0b9b4302010-06-11 17:01:24 +00007432** The journalmode is set to the value specified if the change is allowed.
7433** The change may be disallowed for the following reasons:
drh8a939192009-04-20 17:43:03 +00007434**
7435** * An in-memory database can only have its journal_mode set to _OFF
7436** or _MEMORY.
7437**
drh0b9b4302010-06-11 17:01:24 +00007438** * Temporary databases cannot have _WAL journalmode.
drh04335882008-09-26 21:08:08 +00007439**
danielk1977bea2a942009-01-20 17:06:27 +00007440** The returned indicate the current (possibly updated) journal-mode.
drh3b020132008-04-17 17:02:01 +00007441*/
drh0b9b4302010-06-11 17:01:24 +00007442int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
7443 u8 eOld = pPager->journalMode; /* Prior journalmode */
7444
7445 /* The eMode parameter is always valid */
drhd0fa3482022-01-02 19:10:49 +00007446 assert( eMode==PAGER_JOURNALMODE_DELETE /* 0 */
7447 || eMode==PAGER_JOURNALMODE_PERSIST /* 1 */
7448 || eMode==PAGER_JOURNALMODE_OFF /* 2 */
7449 || eMode==PAGER_JOURNALMODE_TRUNCATE /* 3 */
7450 || eMode==PAGER_JOURNALMODE_MEMORY /* 4 */
7451 || eMode==PAGER_JOURNALMODE_WAL /* 5 */ );
dane04dc882010-04-20 18:53:15 +00007452
drha485ccc2010-07-08 19:19:51 +00007453 /* This routine is only called from the OP_JournalMode opcode, and
7454 ** the logic there will never allow a temporary file to be changed
7455 ** to WAL mode.
drh0b9b4302010-06-11 17:01:24 +00007456 */
drha485ccc2010-07-08 19:19:51 +00007457 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
drh0b9b4302010-06-11 17:01:24 +00007458
7459 /* Do allow the journalmode of an in-memory database to be set to
7460 ** anything other than MEMORY or OFF
7461 */
7462 if( MEMDB ){
7463 assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
7464 if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
7465 eMode = eOld;
7466 }
7467 }
7468
7469 if( eMode!=eOld ){
drh0b9b4302010-06-11 17:01:24 +00007470
7471 /* Change the journal mode. */
dane5953cc2010-08-07 09:31:14 +00007472 assert( pPager->eState!=PAGER_ERROR );
drh0b9b4302010-06-11 17:01:24 +00007473 pPager->journalMode = (u8)eMode;
dan731bf5b2010-06-17 16:44:21 +00007474
7475 /* When transistioning from TRUNCATE or PERSIST to any other journal
dane5953cc2010-08-07 09:31:14 +00007476 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
dan731bf5b2010-06-17 16:44:21 +00007477 ** delete the journal file.
7478 */
7479 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
7480 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
7481 assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
7482 assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
7483 assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
7484 assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
7485
7486 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
7487 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
dan731bf5b2010-06-17 16:44:21 +00007488 /* In this case we would like to delete the journal file. If it is
7489 ** not possible, then that is not a problem. Deleting the journal file
7490 ** here is an optimization only.
7491 **
7492 ** Before deleting the journal file, obtain a RESERVED lock on the
7493 ** database file. This ensures that the journal file is not deleted
7494 ** while it is in use by some other client.
7495 */
dane5953cc2010-08-07 09:31:14 +00007496 sqlite3OsClose(pPager->jfd);
7497 if( pPager->eLock>=RESERVED_LOCK ){
dan731bf5b2010-06-17 16:44:21 +00007498 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
dane5953cc2010-08-07 09:31:14 +00007499 }else{
7500 int rc = SQLITE_OK;
7501 int state = pPager->eState;
dan5653e4d2010-08-12 11:25:47 +00007502 assert( state==PAGER_OPEN || state==PAGER_READER );
dane5953cc2010-08-07 09:31:14 +00007503 if( state==PAGER_OPEN ){
7504 rc = sqlite3PagerSharedLock(pPager);
7505 }
7506 if( pPager->eState==PAGER_READER ){
7507 assert( rc==SQLITE_OK );
7508 rc = pagerLockDb(pPager, RESERVED_LOCK);
7509 }
7510 if( rc==SQLITE_OK ){
7511 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
7512 }
7513 if( rc==SQLITE_OK && state==PAGER_READER ){
7514 pagerUnlockDb(pPager, SHARED_LOCK);
7515 }else if( state==PAGER_OPEN ){
7516 pager_unlock(pPager);
7517 }
7518 assert( state==pPager->eState );
dan731bf5b2010-06-17 16:44:21 +00007519 }
dan929b9232015-05-01 16:57:24 +00007520 }else if( eMode==PAGER_JOURNALMODE_OFF ){
7521 sqlite3OsClose(pPager->jfd);
dan731bf5b2010-06-17 16:44:21 +00007522 }
drh3b020132008-04-17 17:02:01 +00007523 }
drh0b9b4302010-06-11 17:01:24 +00007524
7525 /* Return the new journal mode */
drhfdc40e92008-04-17 20:59:37 +00007526 return (int)pPager->journalMode;
drh3b020132008-04-17 17:02:01 +00007527}
7528
danielk1977b53e4962008-06-04 06:45:59 +00007529/*
drh0b9b4302010-06-11 17:01:24 +00007530** Return the current journal mode.
7531*/
7532int sqlite3PagerGetJournalMode(Pager *pPager){
7533 return (int)pPager->journalMode;
7534}
7535
7536/*
7537** Return TRUE if the pager is in a state where it is OK to change the
7538** journalmode. Journalmode changes can only happen when the database
7539** is unmodified.
7540*/
7541int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
dan4e004aa2010-08-05 15:30:22 +00007542 assert( assert_pager_state(pPager) );
dand0864082010-08-02 14:32:52 +00007543 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
dan89ccf442010-07-01 15:09:47 +00007544 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
drh0b9b4302010-06-11 17:01:24 +00007545 return 1;
7546}
7547
7548/*
danielk1977b53e4962008-06-04 06:45:59 +00007549** Get/set the size-limit used for persistent journal files.
drh5d738542009-04-04 15:53:47 +00007550**
7551** Setting the size limit to -1 means no limit is enforced.
7552** An attempt to set a limit smaller than -1 is a no-op.
danielk1977b53e4962008-06-04 06:45:59 +00007553*/
7554i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
7555 if( iLimit>=-1 ){
7556 pPager->journalSizeLimit = iLimit;
drh85a83752011-05-16 21:00:27 +00007557 sqlite3WalLimit(pPager->pWal, iLimit);
danielk1977b53e4962008-06-04 06:45:59 +00007558 }
7559 return pPager->journalSizeLimit;
7560}
7561
danielk197704103022009-02-03 16:51:24 +00007562/*
7563** Return a pointer to the pPager->pBackup variable. The backup module
7564** in backup.c maintains the content of this variable. This module
7565** uses it opaquely as an argument to sqlite3BackupRestart() and
7566** sqlite3BackupUpdate() only.
7567*/
7568sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
7569 return &pPager->pBackup;
7570}
7571
danf673e092011-11-06 05:06:13 +00007572#ifndef SQLITE_OMIT_VACUUM
7573/*
7574** Unless this is an in-memory or temporary database, clear the pager cache.
7575*/
7576void sqlite3PagerClearCache(Pager *pPager){
dan7f8def22016-04-06 16:27:50 +00007577 assert( MEMDB==0 || pPager->tempFile );
7578 if( pPager->tempFile==0 ) pager_reset(pPager);
danf673e092011-11-06 05:06:13 +00007579}
7580#endif
7581
dan43c1ce32016-08-05 16:16:26 +00007582
dan5cf53532010-05-01 16:40:20 +00007583#ifndef SQLITE_OMIT_WAL
dan7c246102010-04-12 19:00:29 +00007584/*
dana58f26f2010-11-16 18:56:51 +00007585** This function is called when the user invokes "PRAGMA wal_checkpoint",
7586** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
7587** or wal_blocking_checkpoint() API functions.
7588**
dancdc1f042010-11-18 12:11:05 +00007589** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
dan7c246102010-04-12 19:00:29 +00007590*/
dan7fb89902016-08-12 16:21:15 +00007591int sqlite3PagerCheckpoint(
7592 Pager *pPager, /* Checkpoint on this pager */
7593 sqlite3 *db, /* Db handle used to check for interrupts */
7594 int eMode, /* Type of checkpoint */
7595 int *pnLog, /* OUT: Final number of frames in log */
7596 int *pnCkpt /* OUT: Final number of checkpointed frames */
7597){
dan7c246102010-04-12 19:00:29 +00007598 int rc = SQLITE_OK;
drhe2adc0e2022-02-09 18:47:09 +00007599 if( pPager->pWal==0 && pPager->journalMode==PAGER_JOURNALMODE_WAL ){
7600 /* This only happens when a database file is zero bytes in size opened and
7601 ** then "PRAGMA journal_mode=WAL" is run and then sqlite3_wal_checkpoint()
7602 ** is invoked without any intervening transactions. We need to start
7603 ** a transaction to initialize pWal. The PRAGMA table_list statement is
7604 ** used for this since it starts transactions on every database file,
7605 ** including all ATTACHed databases. This seems expensive for a single
7606 ** sqlite3_wal_checkpoint() call, but it happens very rarely.
7607 ** https://sqlite.org/forum/forumpost/fd0f19d229156939
7608 */
7609 sqlite3_exec(db, "PRAGMA table_list",0,0,0);
7610 }
drh7ed91f22010-04-29 22:34:07 +00007611 if( pPager->pWal ){
dan7fb89902016-08-12 16:21:15 +00007612 rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
drhdd90d7e2014-12-03 19:25:41 +00007613 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
7614 pPager->pBusyHandlerArg,
drhdaaae7b2017-08-25 01:14:43 +00007615 pPager->walSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
dancdc1f042010-11-18 12:11:05 +00007616 pnLog, pnCkpt
dan64d039e2010-04-13 19:27:31 +00007617 );
dan7c246102010-04-12 19:00:29 +00007618 }
7619 return rc;
7620}
7621
drh7ed91f22010-04-29 22:34:07 +00007622int sqlite3PagerWalCallback(Pager *pPager){
7623 return sqlite3WalCallback(pPager->pWal);
dan8d22a172010-04-19 18:03:51 +00007624}
7625
dane04dc882010-04-20 18:53:15 +00007626/*
drhd9e5c4f2010-05-12 18:01:39 +00007627** Return true if the underlying VFS for the given pager supports the
7628** primitives necessary for write-ahead logging.
7629*/
7630int sqlite3PagerWalSupported(Pager *pPager){
7631 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
drhffbb02a2016-03-11 23:07:30 +00007632 if( pPager->noLock ) return 0;
drhd4e0bb02012-05-27 01:19:04 +00007633 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
drhd9e5c4f2010-05-12 18:01:39 +00007634}
7635
7636/*
dan8c408002010-11-01 17:38:24 +00007637** Attempt to take an exclusive lock on the database file. If a PENDING lock
7638** is obtained instead, immediately release it.
7639*/
7640static int pagerExclusiveLock(Pager *pPager){
7641 int rc; /* Return code */
7642
7643 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
7644 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
7645 if( rc!=SQLITE_OK ){
drh7f0857c2011-02-24 21:10:00 +00007646 /* If the attempt to grab the exclusive lock failed, release the
7647 ** pending lock that may have been obtained instead. */
dan8c408002010-11-01 17:38:24 +00007648 pagerUnlockDb(pPager, SHARED_LOCK);
7649 }
7650
7651 return rc;
7652}
7653
7654/*
7655** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
7656** exclusive-locking mode when this function is called, take an EXCLUSIVE
7657** lock on the database file and use heap-memory to store the wal-index
7658** in. Otherwise, use the normal shared-memory.
7659*/
7660static int pagerOpenWal(Pager *pPager){
7661 int rc = SQLITE_OK;
7662
7663 assert( pPager->pWal==0 && pPager->tempFile==0 );
drh33f111d2012-01-17 15:29:14 +00007664 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
dan8c408002010-11-01 17:38:24 +00007665
7666 /* If the pager is already in exclusive-mode, the WAL module will use
7667 ** heap-memory for the wal-index instead of the VFS shared-memory
7668 ** implementation. Take the exclusive lock now, before opening the WAL
7669 ** file, to make sure this is safe.
7670 */
7671 if( pPager->exclusiveMode ){
7672 rc = pagerExclusiveLock(pPager);
7673 }
7674
7675 /* Open the connection to the log file. If this operation fails,
7676 ** (e.g. due to malloc() failure), return an error code.
7677 */
7678 if( rc==SQLITE_OK ){
danf23da962013-03-23 21:00:41 +00007679 rc = sqlite3WalOpen(pPager->pVfs,
drh85a83752011-05-16 21:00:27 +00007680 pPager->fd, pPager->zWal, pPager->exclusiveMode,
7681 pPager->journalSizeLimit, &pPager->pWal
dan8c408002010-11-01 17:38:24 +00007682 );
7683 }
dan5d8a1372013-03-19 19:28:06 +00007684 pagerFixMaplimit(pPager);
dan8c408002010-11-01 17:38:24 +00007685
7686 return rc;
7687}
7688
7689
7690/*
dane04dc882010-04-20 18:53:15 +00007691** The caller must be holding a SHARED lock on the database file to call
7692** this function.
drh40e459e2010-07-03 12:26:33 +00007693**
7694** If the pager passed as the first argument is open on a real database
7695** file (not a temp file or an in-memory database), and the WAL file
7696** is not already open, make an attempt to open it now. If successful,
7697** return SQLITE_OK. If an error occurs or the VFS used by the pager does
dan763afe62010-08-03 06:42:39 +00007698** not support the xShmXXX() methods, return an error code. *pbOpen is
drh40e459e2010-07-03 12:26:33 +00007699** not modified in either case.
7700**
7701** If the pager is open on a temp-file (or in-memory database), or if
dan763afe62010-08-03 06:42:39 +00007702** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
drh40e459e2010-07-03 12:26:33 +00007703** without doing anything.
dane04dc882010-04-20 18:53:15 +00007704*/
drh40e459e2010-07-03 12:26:33 +00007705int sqlite3PagerOpenWal(
7706 Pager *pPager, /* Pager object */
dan763afe62010-08-03 06:42:39 +00007707 int *pbOpen /* OUT: Set to true if call is a no-op */
drh40e459e2010-07-03 12:26:33 +00007708){
dane04dc882010-04-20 18:53:15 +00007709 int rc = SQLITE_OK; /* Return code */
7710
dan763afe62010-08-03 06:42:39 +00007711 assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +00007712 assert( pPager->eState==PAGER_OPEN || pbOpen );
dan763afe62010-08-03 06:42:39 +00007713 assert( pPager->eState==PAGER_READER || !pbOpen );
7714 assert( pbOpen==0 || *pbOpen==0 );
7715 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
drh40e459e2010-07-03 12:26:33 +00007716
7717 if( !pPager->tempFile && !pPager->pWal ){
drhd9e5c4f2010-05-12 18:01:39 +00007718 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
dane04dc882010-04-20 18:53:15 +00007719
drh919fc662010-08-16 20:02:09 +00007720 /* Close any rollback journal previously open */
7721 sqlite3OsClose(pPager->jfd);
dan4e004aa2010-08-05 15:30:22 +00007722
dan8c408002010-11-01 17:38:24 +00007723 rc = pagerOpenWal(pPager);
dane04dc882010-04-20 18:53:15 +00007724 if( rc==SQLITE_OK ){
7725 pPager->journalMode = PAGER_JOURNALMODE_WAL;
dande1ae342010-08-06 12:00:27 +00007726 pPager->eState = PAGER_OPEN;
dane04dc882010-04-20 18:53:15 +00007727 }
7728 }else{
dan763afe62010-08-03 06:42:39 +00007729 *pbOpen = 1;
dane04dc882010-04-20 18:53:15 +00007730 }
7731
7732 return rc;
7733}
7734
dane04dc882010-04-20 18:53:15 +00007735/*
7736** This function is called to close the connection to the log file prior
7737** to switching from WAL to rollback mode.
7738**
7739** Before closing the log file, this function attempts to take an
7740** EXCLUSIVE lock on the database file. If this cannot be obtained, an
7741** error (SQLITE_BUSY) is returned and the log connection is not closed.
7742** If successful, the EXCLUSIVE lock is not released before returning.
7743*/
dan7fb89902016-08-12 16:21:15 +00007744int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
dane04dc882010-04-20 18:53:15 +00007745 int rc = SQLITE_OK;
dane04dc882010-04-20 18:53:15 +00007746
danede6eb82010-04-22 06:27:04 +00007747 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
7748
7749 /* If the log file is not already open, but does exist in the file-system,
7750 ** it may need to be checkpointed before the connection can switch to
7751 ** rollback mode. Open it now so this can happen.
7752 */
drh7ed91f22010-04-29 22:34:07 +00007753 if( !pPager->pWal ){
danede6eb82010-04-22 06:27:04 +00007754 int logexists = 0;
dan4e004aa2010-08-05 15:30:22 +00007755 rc = pagerLockDb(pPager, SHARED_LOCK);
danede6eb82010-04-22 06:27:04 +00007756 if( rc==SQLITE_OK ){
dandb10f082010-07-05 19:13:26 +00007757 rc = sqlite3OsAccess(
7758 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
7759 );
danede6eb82010-04-22 06:27:04 +00007760 }
7761 if( rc==SQLITE_OK && logexists ){
dan8c408002010-11-01 17:38:24 +00007762 rc = pagerOpenWal(pPager);
danede6eb82010-04-22 06:27:04 +00007763 }
7764 }
7765
7766 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
7767 ** the database file, the log and log-summary files will be deleted.
7768 */
drh7ed91f22010-04-29 22:34:07 +00007769 if( rc==SQLITE_OK && pPager->pWal ){
dan8c408002010-11-01 17:38:24 +00007770 rc = pagerExclusiveLock(pPager);
dane04dc882010-04-20 18:53:15 +00007771 if( rc==SQLITE_OK ){
drhdaaae7b2017-08-25 01:14:43 +00007772 rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
drhc97d8462010-11-19 18:23:35 +00007773 pPager->pageSize, (u8*)pPager->pTmpSpace);
drh7ed91f22010-04-29 22:34:07 +00007774 pPager->pWal = 0;
dan5d8a1372013-03-19 19:28:06 +00007775 pagerFixMaplimit(pPager);
drhcdce61e2016-04-20 19:30:47 +00007776 if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
dane04dc882010-04-20 18:53:15 +00007777 }
dane04dc882010-04-20 18:53:15 +00007778 }
7779 return rc;
7780}
dan47ee3862010-06-22 15:18:44 +00007781
dan58021b22020-05-05 20:30:07 +00007782#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
7783/*
7784** If pager pPager is a wal-mode database not in exclusive locking mode,
7785** invoke the sqlite3WalWriteLock() function on the associated Wal object
7786** with the same db and bLock parameters as were passed to this function.
7787** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
7788*/
dan861fb1e2020-05-06 19:14:41 +00007789int sqlite3PagerWalWriteLock(Pager *pPager, int bLock){
dan58021b22020-05-05 20:30:07 +00007790 int rc = SQLITE_OK;
7791 if( pagerUseWal(pPager) && pPager->exclusiveMode==0 ){
dan861fb1e2020-05-06 19:14:41 +00007792 rc = sqlite3WalWriteLock(pPager->pWal, bLock);
dan58021b22020-05-05 20:30:07 +00007793 }
7794 return rc;
7795}
drh8875b9e2020-01-10 18:05:55 +00007796
dan861fb1e2020-05-06 19:14:41 +00007797/*
7798** Set the database handle used by the wal layer to determine if
7799** blocking locks are required.
7800*/
7801void sqlite3PagerWalDb(Pager *pPager, sqlite3 *db){
7802 if( pagerUseWal(pPager) ){
7803 sqlite3WalDb(pPager->pWal, db);
7804 }
7805}
dan58021b22020-05-05 20:30:07 +00007806#endif
drh8875b9e2020-01-10 18:05:55 +00007807
danfc1acf32015-12-05 20:51:54 +00007808#ifdef SQLITE_ENABLE_SNAPSHOT
7809/*
7810** If this is a WAL database, obtain a snapshot handle for the snapshot
7811** currently open. Otherwise, return an error.
7812*/
7813int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){
7814 int rc = SQLITE_ERROR;
7815 if( pPager->pWal ){
7816 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
7817 }
7818 return rc;
7819}
7820
7821/*
7822** If this is a WAL database, store a pointer to pSnapshot. Next time a
7823** read transaction is opened, attempt to read from the snapshot it
7824** identifies. If this is not a WAL database, return an error.
7825*/
dan8714de92020-05-04 19:42:35 +00007826int sqlite3PagerSnapshotOpen(
7827 Pager *pPager,
dan8714de92020-05-04 19:42:35 +00007828 sqlite3_snapshot *pSnapshot
7829){
danfc1acf32015-12-05 20:51:54 +00007830 int rc = SQLITE_OK;
7831 if( pPager->pWal ){
7832 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
7833 }else{
7834 rc = SQLITE_ERROR;
7835 }
7836 return rc;
7837}
dan11584982016-11-18 20:49:43 +00007838
7839/*
7840** If this is a WAL database, call sqlite3WalSnapshotRecover(). If this
7841** is not a WAL database, return an error.
7842*/
7843int sqlite3PagerSnapshotRecover(Pager *pPager){
7844 int rc;
7845 if( pPager->pWal ){
7846 rc = sqlite3WalSnapshotRecover(pPager->pWal);
7847 }else{
7848 rc = SQLITE_ERROR;
7849 }
7850 return rc;
7851}
danfa3d4c12018-08-06 17:12:36 +00007852
7853/*
7854** The caller currently has a read transaction open on the database.
7855** If this is not a WAL database, SQLITE_ERROR is returned. Otherwise,
7856** this function takes a SHARED lock on the CHECKPOINTER slot and then
7857** checks if the snapshot passed as the second argument is still
7858** available. If so, SQLITE_OK is returned.
7859**
7860** If the snapshot is not available, SQLITE_ERROR is returned. Or, if
7861** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error
7862** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
7863** lock is released before returning.
7864*/
7865int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){
7866 int rc;
7867 if( pPager->pWal ){
7868 rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot);
7869 }else{
7870 rc = SQLITE_ERROR;
7871 }
7872 return rc;
7873}
7874
7875/*
7876** Release a lock obtained by an earlier successful call to
7877** sqlite3PagerSnapshotCheck().
7878*/
7879void sqlite3PagerSnapshotUnlock(Pager *pPager){
7880 assert( pPager->pWal );
dan3fd7eaf2019-02-11 11:04:17 +00007881 sqlite3WalSnapshotUnlock(pPager->pWal);
danfa3d4c12018-08-06 17:12:36 +00007882}
7883
danfc1acf32015-12-05 20:51:54 +00007884#endif /* SQLITE_ENABLE_SNAPSHOT */
danaa595052017-05-23 19:23:45 +00007885
7886int sqlite3PagerWalInfo(Pager *pPager, u32 *pnPrior, u32 *pnFrame){
7887 return sqlite3WalInfo(pPager->pWal, pnPrior, pnFrame);
7888}
7889
drhf7c70312012-10-10 12:14:09 +00007890#endif /* !SQLITE_OMIT_WAL */
7891
drh70708602012-02-24 14:33:28 +00007892#ifdef SQLITE_ENABLE_ZIPVFS
danb3bdc722012-02-23 15:35:49 +00007893/*
7894** A read-lock must be held on the pager when this function is called. If
7895** the pager is in WAL mode and the WAL file currently contains one or more
7896** frames, return the size in bytes of the page images stored within the
7897** WAL frames. Otherwise, if this is not a WAL database or the WAL file
7898** is empty, return 0.
7899*/
7900int sqlite3PagerWalFramesize(Pager *pPager){
dan9675d5d2014-09-18 09:59:28 +00007901 assert( pPager->eState>=PAGER_READER );
danb3bdc722012-02-23 15:35:49 +00007902 return sqlite3WalFramesize(pPager->pWal);
7903}
drh70708602012-02-24 14:33:28 +00007904#endif
danb3bdc722012-02-23 15:35:49 +00007905
drh2e66f0b2005-04-28 17:18:48 +00007906#endif /* SQLITE_OMIT_DISKIO */