blob: 796ca44c32f885ebc2fb18ee9cc69aed0d1cf2a6 [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**
73** (6) If a master journal file is used, then all writes to the database file
74** are synced prior to the master journal being deleted.
75**
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*/
drhc001c582006-03-06 18:23:16 +0000131#define PAGERID(p) ((int)(p->fd))
132#define FILEHANDLEID(fd) ((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/*
drh9eb9e262004-02-11 02:18:05 +0000410** A macro used for invoking the codec if there is one
411*/
412#ifdef SQLITE_HAS_CODEC
drh85d2bd22009-06-11 00:47:20 +0000413# define CODEC1(P,D,N,X,E) \
drhfa9601a2009-06-18 17:22:39 +0000414 if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
drh85d2bd22009-06-11 00:47:20 +0000415# define CODEC2(P,D,N,X,E,O) \
416 if( P->xCodec==0 ){ O=(char*)D; }else \
drhfa9601a2009-06-18 17:22:39 +0000417 if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
drh9eb9e262004-02-11 02:18:05 +0000418#else
drh85d2bd22009-06-11 00:47:20 +0000419# define CODEC1(P,D,N,X,E) /* NO-OP */
420# define CODEC2(P,D,N,X,E,O) O=(char*)D
drh9eb9e262004-02-11 02:18:05 +0000421#endif
422
drhed7c8552001-04-11 14:29:21 +0000423/*
drh1a5c00f2009-08-10 17:48:57 +0000424** The maximum allowed sector size. 64KiB. If the xSectorsize() method
danielk19777cbd5892009-01-10 16:15:09 +0000425** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
426** This could conceivably cause corruption following a power failure on
427** such a system. This is currently an undocumented limit.
428*/
drh1a5c00f2009-08-10 17:48:57 +0000429#define MAX_SECTOR_SIZE 0x10000
danielk19777cbd5892009-01-10 16:15:09 +0000430
drh164c9572016-01-25 13:55:47 +0000431
432/*
danielk1977fd7f0452008-12-17 17:30:26 +0000433** An instance of the following structure is allocated for each active
434** savepoint and statement transaction in the system. All such structures
435** are stored in the Pager.aSavepoint[] array, which is allocated and
436** resized using sqlite3Realloc().
437**
438** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
439** set to 0. If a journal-header is written into the main journal while
440** the savepoint is active, then iHdrOffset is set to the byte offset
441** immediately following the last journal record written into the main
442** journal before the journal-header. This is required during savepoint
443** rollback (see pagerPlaybackSavepoint()).
444*/
445typedef struct PagerSavepoint PagerSavepoint;
446struct PagerSavepoint {
447 i64 iOffset; /* Starting offset in main journal */
448 i64 iHdrOffset; /* See above */
449 Bitvec *pInSavepoint; /* Set of pages in this savepoint */
450 Pgno nOrig; /* Original number of pages in file */
451 Pgno iSubRec; /* Index of first record in sub-journal */
dan38e1a272010-06-28 11:23:09 +0000452#ifndef SQLITE_OMIT_WAL
dan71d89912010-05-24 13:57:42 +0000453 u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
dan38e1a272010-06-28 11:23:09 +0000454#endif
danielk1977fd7f0452008-12-17 17:30:26 +0000455};
456
457/*
drh40c39412013-08-16 20:42:20 +0000458** Bits of the Pager.doNotSpill flag. See further description below.
459*/
drhe399ac22015-06-29 18:14:02 +0000460#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */
461#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */
462#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */
drh40c39412013-08-16 20:42:20 +0000463
464/*
peter.d.reid60ec9142014-09-06 16:39:46 +0000465** An open page cache is an instance of struct Pager. A description of
dande1ae342010-08-06 12:00:27 +0000466** some of the more important member variables follows:
danielk1977efaaf572006-01-16 11:29:19 +0000467**
dande1ae342010-08-06 12:00:27 +0000468** eState
danielk19773460d192008-12-27 15:23:13 +0000469**
dande1ae342010-08-06 12:00:27 +0000470** The current 'state' of the pager object. See the comment and state
471** diagram above for a description of the pager state.
danielk1977bea2a942009-01-20 17:06:27 +0000472**
dande1ae342010-08-06 12:00:27 +0000473** eLock
danielk1977bea2a942009-01-20 17:06:27 +0000474**
dande1ae342010-08-06 12:00:27 +0000475** For a real on-disk database, the current lock held on the database file -
476** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
477**
478** For a temporary or in-memory database (neither of which require any
479** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
480** databases always have Pager.exclusiveMode==1, this tricks the pager
481** logic into thinking that it already has all the locks it will ever
482** need (and no reason to release them).
483**
484** In some (obscure) circumstances, this variable may also be set to
485** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
486** details.
danielk1977bea2a942009-01-20 17:06:27 +0000487**
488** changeCountDone
489**
490** This boolean variable is used to make sure that the change-counter
491** (the 4-byte header field at byte offset 24 of the database file) is
492** not updated more often than necessary.
493**
494** It is set to true when the change-counter field is updated, which
495** can only happen if an exclusive lock is held on the database file.
496** It is cleared (set to false) whenever an exclusive lock is
497** relinquished on the database file. Each time a transaction is committed,
498** The changeCountDone flag is inspected. If it is true, the work of
499** updating the change-counter is omitted for the current transaction.
500**
501** This mechanism means that when running in exclusive mode, a connection
502** need only update the change-counter once, for the first transaction
503** committed.
504**
danielk1977bea2a942009-01-20 17:06:27 +0000505** setMaster
506**
dan1e01cf12010-07-30 11:31:12 +0000507** When PagerCommitPhaseOne() is called to commit a transaction, it may
508** (or may not) specify a master-journal name to be written into the
509** journal file before it is synced to disk.
danielk1977bea2a942009-01-20 17:06:27 +0000510**
dan1e01cf12010-07-30 11:31:12 +0000511** Whether or not a journal file contains a master-journal pointer affects
512** the way in which the journal file is finalized after the transaction is
513** committed or rolled back when running in "journal_mode=PERSIST" mode.
514** If a journal file does not contain a master-journal pointer, it is
dande1ae342010-08-06 12:00:27 +0000515** finalized by overwriting the first journal header with zeroes. If
516** it does contain a master-journal pointer the journal file is finalized
517** by truncating it to zero bytes, just as if the connection were
518** running in "journal_mode=truncate" mode.
dan1e01cf12010-07-30 11:31:12 +0000519**
520** Journal files that contain master journal pointers cannot be finalized
521** simply by overwriting the first journal-header with zeroes, as the
522** master journal pointer could interfere with hot-journal rollback of any
523** subsequently interrupted transaction that reuses the journal file.
524**
525** The flag is cleared as soon as the journal file is finalized (either
526** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
527** journal file from being successfully finalized, the setMaster flag
dande1ae342010-08-06 12:00:27 +0000528** is cleared anyway (and the pager will move to ERROR state).
danielk1977bea2a942009-01-20 17:06:27 +0000529**
drh40c39412013-08-16 20:42:20 +0000530** doNotSpill
danielk1977bea2a942009-01-20 17:06:27 +0000531**
drh40c39412013-08-16 20:42:20 +0000532** This variables control the behavior of cache-spills (calls made by
533** the pcache module to the pagerStress() routine to write cached data
534** to the file-system in order to free up memory).
dan85d14ed2010-08-06 17:18:00 +0000535**
drh40c39412013-08-16 20:42:20 +0000536** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
537** writing to the database from pagerStress() is disabled altogether.
538** The SPILLFLAG_ROLLBACK case is done in a very obscure case that
dan85d14ed2010-08-06 17:18:00 +0000539** comes up during savepoint rollback that requires the pcache module
540** to allocate a new page to prevent the journal file from being written
drh40c39412013-08-16 20:42:20 +0000541** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
542** case is a user preference.
dan85d14ed2010-08-06 17:18:00 +0000543**
drhe399ac22015-06-29 18:14:02 +0000544** If the SPILLFLAG_NOSYNC bit is set, writing to the database from
545** pagerStress() is permitted, but syncing the journal file is not.
546** This flag is set by sqlite3PagerWrite() when the file-system sector-size
547** is larger than the database page-size in order to prevent a journal sync
548** from happening in between the journalling of two pages on the same sector.
danielk1977bea2a942009-01-20 17:06:27 +0000549**
danielk1977d8293352009-04-30 09:10:37 +0000550** subjInMemory
551**
552** This is a boolean variable. If true, then any required sub-journal
553** is opened as an in-memory journal file. If false, then in-memory
554** sub-journals are only used for in-memory pager files.
dande1ae342010-08-06 12:00:27 +0000555**
556** This variable is updated by the upper layer each time a new
557** write-transaction is opened.
558**
559** dbSize, dbOrigSize, dbFileSize
560**
561** Variable dbSize is set to the number of pages in the database file.
562** It is valid in PAGER_READER and higher states (all states except for
563** OPEN and ERROR).
564**
565** dbSize is set based on the size of the database file, which may be
566** larger than the size of the database (the value stored at offset
567** 28 of the database header by the btree). If the size of the file
568** is not an integer multiple of the page-size, the value stored in
569** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
570** Except, any file that is greater than 0 bytes in size is considered
571** to have at least one page. (i.e. a 1KB file with 2K page-size leads
572** to dbSize==1).
573**
574** During a write-transaction, if pages with page-numbers greater than
575** dbSize are modified in the cache, dbSize is updated accordingly.
576** Similarly, if the database is truncated using PagerTruncateImage(),
577** dbSize is updated.
578**
579** Variables dbOrigSize and dbFileSize are valid in states
580** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
581** variable at the start of the transaction. It is used during rollback,
582** and to determine whether or not pages need to be journalled before
583** being modified.
584**
585** Throughout a write-transaction, dbFileSize contains the size of
586** the file on disk in pages. It is set to a copy of dbSize when the
587** write-transaction is first opened, and updated when VFS calls are made
danc8649122010-08-10 09:58:57 +0000588** to write or truncate the database file on disk.
589**
590** The only reason the dbFileSize variable is required is to suppress
591** unnecessary calls to xTruncate() after committing a transaction. If,
592** when a transaction is committed, the dbFileSize variable indicates
593** that the database file is larger than the database image (Pager.dbSize),
594** pager_truncate() is called. The pager_truncate() call uses xFilesize()
595** to measure the database file on disk, and then truncates it if required.
596** dbFileSize is not used when rolling back a transaction. In this case
597** pager_truncate() is called unconditionally (which means there may be
598** a call to xFilesize() that is not strictly required). In either case,
599** pager_truncate() may cause the file to become smaller or larger.
600**
601** dbHintSize
602**
603** The dbHintSize variable is used to limit the number of calls made to
604** the VFS xFileControl(FCNTL_SIZE_HINT) method.
605**
606** dbHintSize is set to a copy of the dbSize variable when a
607** write-transaction is opened (at the same time as dbFileSize and
608** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
609** dbHintSize is increased to the number of pages that correspond to the
610** size-hint passed to the method call. See pager_write_pagelist() for
611** details.
dande1ae342010-08-06 12:00:27 +0000612**
613** errCode
614**
615** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
616** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
617** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
618** sub-codes.
drhed7c8552001-04-11 14:29:21 +0000619*/
620struct Pager {
danielk1977b4b47412007-08-17 15:53:36 +0000621 sqlite3_vfs *pVfs; /* OS functions to use for IO */
danielk1977bea2a942009-01-20 17:06:27 +0000622 u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
dan4d9c1b72010-07-30 07:26:51 +0000623 u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */
drh34e79ce2004-02-08 06:05:46 +0000624 u8 useJournal; /* Use a rollback journal on this file */
drh603240c2002-03-05 01:11:12 +0000625 u8 noSync; /* Do not sync the journal if true */
drh968af522003-02-11 14:55:40 +0000626 u8 fullSync; /* Do extra syncs of the journal for robustness */
drh6841b1c2016-02-03 19:20:15 +0000627 u8 extraSync; /* sync directory after journal delete */
drhc97d8462010-11-19 18:23:35 +0000628 u8 ckptSyncFlags; /* SYNC_NORMAL or SYNC_FULL for checkpoint */
drh4eb02a42011-12-16 21:26:26 +0000629 u8 walSyncFlags; /* SYNC_NORMAL or SYNC_FULL for wal writes */
drhc97d8462010-11-19 18:23:35 +0000630 u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */
drh57fe1362014-05-01 01:49:22 +0000631 u8 tempFile; /* zFilename is a temporary or immutable file */
632 u8 noLock; /* Do not lock (except in WAL mode) */
drh603240c2002-03-05 01:11:12 +0000633 u8 readOnly; /* True for a read-only database */
danielk197745d68822009-01-16 16:23:38 +0000634 u8 memDb; /* True to inhibit all file I/O */
danielk1977bea2a942009-01-20 17:06:27 +0000635
drhe5918c62010-08-14 12:42:45 +0000636 /**************************************************************************
637 ** The following block contains those class members that change during
peter.d.reid60ec9142014-09-06 16:39:46 +0000638 ** routine operation. Class members not in this block are either fixed
drhe5918c62010-08-14 12:42:45 +0000639 ** when the pager is first created or else only change when there is a
640 ** significant mode change (such as changing the page_size, locking_mode,
641 ** or the journal_mode). From another view, these class members describe
642 ** the "state" of the pager, while other class members describe the
643 ** "configuration" of the pager.
danielk1977bea2a942009-01-20 17:06:27 +0000644 */
dande1ae342010-08-06 12:00:27 +0000645 u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
dand0864082010-08-02 14:32:52 +0000646 u8 eLock; /* Current lock held on database file */
danielk1977bea2a942009-01-20 17:06:27 +0000647 u8 changeCountDone; /* Set after incrementing the change-counter */
drh6d156e42005-05-20 20:11:20 +0000648 u8 setMaster; /* True if a m-j name has been written to jrnl */
drh7cf4c7a2010-06-24 14:52:25 +0000649 u8 doNotSpill; /* Do not spill the cache when non-zero */
danielk1977d8293352009-04-30 09:10:37 +0000650 u8 subjInMemory; /* True to use in-memory sub-journals */
drh91618562014-12-19 19:28:02 +0000651 u8 bUseFetch; /* True to use xFetch() */
drhc98a4cc2015-09-03 17:54:32 +0000652 u8 hasHeldSharedLock; /* True if a shared lock has ever been held */
danielk19773460d192008-12-27 15:23:13 +0000653 Pgno dbSize; /* Number of pages in the database */
654 Pgno dbOrigSize; /* dbSize before the current transaction */
655 Pgno dbFileSize; /* Number of pages in the database file */
danc8649122010-08-10 09:58:57 +0000656 Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
danielk197745d68822009-01-16 16:23:38 +0000657 int errCode; /* One of several kinds of errors */
danielk1977bea2a942009-01-20 17:06:27 +0000658 int nRec; /* Pages journalled since last j-header written */
danielk197745d68822009-01-16 16:23:38 +0000659 u32 cksumInit; /* Quasi-random value added to every checksum */
danielk1977bea2a942009-01-20 17:06:27 +0000660 u32 nSubRec; /* Number of records written to sub-journal */
danielk197745d68822009-01-16 16:23:38 +0000661 Bitvec *pInJournal; /* One bit for each page in the database file */
danielk1977bea2a942009-01-20 17:06:27 +0000662 sqlite3_file *fd; /* File descriptor for database */
663 sqlite3_file *jfd; /* File descriptor for main journal */
664 sqlite3_file *sjfd; /* File descriptor for sub-journal */
665 i64 journalOff; /* Current write offset in the journal file */
666 i64 journalHdr; /* Byte offset to previous journal header */
drhe5918c62010-08-14 12:42:45 +0000667 sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
danielk1977bea2a942009-01-20 17:06:27 +0000668 PagerSavepoint *aSavepoint; /* Array of active savepoints */
669 int nSavepoint; /* Number of elements in aSavepoint[] */
drhd7107b32014-12-20 14:34:02 +0000670 u32 iDataVersion; /* Changes whenever database content changes */
danielk1977bea2a942009-01-20 17:06:27 +0000671 char dbFileVers[16]; /* Changes whenever database file changes */
danb2d3de32013-03-14 18:34:37 +0000672
danb2d3de32013-03-14 18:34:37 +0000673 int nMmapOut; /* Number of mmap pages currently outstanding */
drh9b4c59f2013-04-15 17:03:42 +0000674 sqlite3_int64 szMmap; /* Desired maximum mmap size */
drhc86e5132013-03-26 14:36:11 +0000675 PgHdr *pMmapFreelist; /* List of free mmap page headers (pDirty) */
drhe5918c62010-08-14 12:42:45 +0000676 /*
677 ** End of the routinely-changing class members
678 ***************************************************************************/
danielk1977bea2a942009-01-20 17:06:27 +0000679
drhfa9601a2009-06-18 17:22:39 +0000680 u16 nExtra; /* Add this many bytes to each in-memory page */
681 i16 nReserve; /* Number of unused bytes at end of each page */
danielk1977bea2a942009-01-20 17:06:27 +0000682 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
drhe5918c62010-08-14 12:42:45 +0000683 u32 sectorSize; /* Assumed sector size during rollback */
danielk1977bea2a942009-01-20 17:06:27 +0000684 int pageSize; /* Number of bytes in a page */
685 Pgno mxPgno; /* Maximum allowed size of the database */
drhe5918c62010-08-14 12:42:45 +0000686 i64 journalSizeLimit; /* Size limit for persistent journal files */
drhfcd35c72005-05-21 02:48:08 +0000687 char *zFilename; /* Name of the database file */
688 char *zJournal; /* Name of the journal file */
danielk19771ceedd32008-11-19 10:22:33 +0000689 int (*xBusyHandler)(void*); /* Function to call when busy */
690 void *pBusyHandlerArg; /* Context argument for xBusyHandler */
drh9ad3ee42012-03-24 20:06:14 +0000691 int aStat[3]; /* Total cache hits, misses and writes */
drhfcd35c72005-05-21 02:48:08 +0000692#ifdef SQLITE_TEST
drh9ad3ee42012-03-24 20:06:14 +0000693 int nRead; /* Database pages read */
drhfcd35c72005-05-21 02:48:08 +0000694#endif
danielk1977eaa06f62008-09-18 17:34:44 +0000695 void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
drh7c4ac0c2007-04-05 11:25:58 +0000696#ifdef SQLITE_HAS_CODEC
drhc001c582006-03-06 18:23:16 +0000697 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
drhfa9601a2009-06-18 17:22:39 +0000698 void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
699 void (*xCodecFree)(void*); /* Destructor for the codec */
700 void *pCodec; /* First argument to xCodec... methods */
drh7c4ac0c2007-04-05 11:25:58 +0000701#endif
danielk19778186df82007-03-06 13:45:59 +0000702 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
danielk19778c0a7912008-08-20 14:49:23 +0000703 PCache *pPCache; /* Pointer to page cache object */
dan5cf53532010-05-01 16:40:20 +0000704#ifndef SQLITE_OMIT_WAL
drh7ed91f22010-04-29 22:34:07 +0000705 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
dan3e875ef2010-07-05 19:03:35 +0000706 char *zWal; /* File name for write-ahead log */
dan5cf53532010-05-01 16:40:20 +0000707#endif
drhd9b02572001-04-15 00:37:09 +0000708};
709
710/*
drh9ad3ee42012-03-24 20:06:14 +0000711** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains
712** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS
713** or CACHE_WRITE to sqlite3_db_status().
714*/
715#define PAGER_STAT_HIT 0
716#define PAGER_STAT_MISS 1
717#define PAGER_STAT_WRITE 2
718
719/*
drh538f5702007-04-13 02:14:30 +0000720** The following global variables hold counters used for
721** testing purposes only. These variables do not exist in
722** a non-testing build. These variables are not thread-safe.
drhfcd35c72005-05-21 02:48:08 +0000723*/
724#ifdef SQLITE_TEST
drh538f5702007-04-13 02:14:30 +0000725int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
726int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
727int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
drh538f5702007-04-13 02:14:30 +0000728# define PAGER_INCR(v) v++
drhfcd35c72005-05-21 02:48:08 +0000729#else
drh538f5702007-04-13 02:14:30 +0000730# define PAGER_INCR(v)
drhfcd35c72005-05-21 02:48:08 +0000731#endif
732
drh538f5702007-04-13 02:14:30 +0000733
734
drhfcd35c72005-05-21 02:48:08 +0000735/*
drh5e00f6c2001-09-13 13:46:56 +0000736** Journal files begin with the following magic string. The data
737** was obtained from /dev/random. It is used only as a sanity check.
drh94f33312002-08-12 12:29:56 +0000738**
drhae2b40c2004-06-09 19:03:54 +0000739** Since version 2.8.0, the journal format contains additional sanity
drh30d53702009-01-06 15:58:57 +0000740** checking information. If the power fails while the journal is being
drhae2b40c2004-06-09 19:03:54 +0000741** written, semi-random garbage data might appear in the journal
742** file after power is restored. If an attempt is then made
drh968af522003-02-11 14:55:40 +0000743** to roll the journal back, the database could be corrupted. The additional
744** sanity checking data is an attempt to discover the garbage in the
745** journal and ignore it.
746**
drhae2b40c2004-06-09 19:03:54 +0000747** The sanity checking information for the new journal format consists
drh968af522003-02-11 14:55:40 +0000748** of a 32-bit checksum on each page of data. The checksum covers both
drh90f5ecb2004-07-22 01:19:35 +0000749** the page number and the pPager->pageSize bytes of data for the page.
drh968af522003-02-11 14:55:40 +0000750** This cksum is initialized to a 32-bit random value that appears in the
751** journal file right after the header. The random initializer is important,
752** because garbage data that appears at the end of a journal is likely
753** data that was once in other files that have now been deleted. If the
754** garbage data came from an obsolete journal file, the checksums might
755** be correct. But by initializing the checksum to random value which
756** is different for every journal, we minimize that risk.
drhd9b02572001-04-15 00:37:09 +0000757*/
drhae2b40c2004-06-09 19:03:54 +0000758static const unsigned char aJournalMagic[] = {
759 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
drhed7c8552001-04-11 14:29:21 +0000760};
761
762/*
danielk1977bea2a942009-01-20 17:06:27 +0000763** The size of the of each page record in the journal is given by
764** the following macro.
drh968af522003-02-11 14:55:40 +0000765*/
drhae2b40c2004-06-09 19:03:54 +0000766#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
drh968af522003-02-11 14:55:40 +0000767
danielk197776572402004-06-25 02:38:54 +0000768/*
danielk1977bea2a942009-01-20 17:06:27 +0000769** The journal header size for this pager. This is usually the same
770** size as a single disk sector. See also setSectorSize().
danielk197776572402004-06-25 02:38:54 +0000771*/
772#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
773
drhb7f91642004-10-31 02:22:47 +0000774/*
775** The macro MEMDB is true if we are dealing with an in-memory database.
776** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
777** the value of MEMDB will be a constant and the compiler will optimize
778** out code that would never execute.
779*/
780#ifdef SQLITE_OMIT_MEMORYDB
781# define MEMDB 0
782#else
783# define MEMDB pPager->memDb
784#endif
785
786/*
drh188d4882013-04-08 20:47:49 +0000787** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
788** interfaces to access the database using memory-mapped I/O.
789*/
drh9b4c59f2013-04-15 17:03:42 +0000790#if SQLITE_MAX_MMAP_SIZE>0
drh188d4882013-04-08 20:47:49 +0000791# define USEFETCH(x) ((x)->bUseFetch)
drh9b4c59f2013-04-15 17:03:42 +0000792#else
793# define USEFETCH(x) 0
drh188d4882013-04-08 20:47:49 +0000794#endif
795
796/*
danielk197726836652005-01-17 01:33:13 +0000797** The maximum legal page number is (2^31 - 1).
798*/
799#define PAGER_MAX_PGNO 2147483647
800
dand0864082010-08-02 14:32:52 +0000801/*
802** The argument to this macro is a file descriptor (type sqlite3_file*).
803** Return 0 if it is not open, or non-zero (but not 1) if it is.
804**
805** This is so that expressions can be written as:
806**
807** if( isOpen(pPager->jfd) ){ ...
808**
809** instead of
810**
811** if( pPager->jfd->pMethods ){ ...
812*/
drh82ef8772015-06-29 14:11:50 +0000813#define isOpen(pFd) ((pFd)->pMethods!=0)
dand0864082010-08-02 14:32:52 +0000814
815/*
816** Return true if this pager uses a write-ahead log instead of the usual
817** rollback journal. Otherwise false.
818*/
819#ifndef SQLITE_OMIT_WAL
820static int pagerUseWal(Pager *pPager){
821 return (pPager->pWal!=0);
822}
823#else
824# define pagerUseWal(x) 0
825# define pagerRollbackWal(x) 0
drh4eb02a42011-12-16 21:26:26 +0000826# define pagerWalFrames(v,w,x,y) 0
dand0864082010-08-02 14:32:52 +0000827# define pagerOpenWalIfPresent(z) SQLITE_OK
828# define pagerBeginReadTransaction(z) SQLITE_OK
829#endif
830
danielk1977bea2a942009-01-20 17:06:27 +0000831#ifndef NDEBUG
832/*
833** Usage:
834**
835** assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +0000836**
837** This function runs many asserts to try to find inconsistencies in
838** the internal state of the Pager object.
danielk1977bea2a942009-01-20 17:06:27 +0000839*/
dand0864082010-08-02 14:32:52 +0000840static int assert_pager_state(Pager *p){
841 Pager *pPager = p;
danielk1977bea2a942009-01-20 17:06:27 +0000842
dand0864082010-08-02 14:32:52 +0000843 /* State must be valid. */
dande1ae342010-08-06 12:00:27 +0000844 assert( p->eState==PAGER_OPEN
dand0864082010-08-02 14:32:52 +0000845 || p->eState==PAGER_READER
dande1ae342010-08-06 12:00:27 +0000846 || p->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +0000847 || p->eState==PAGER_WRITER_CACHEMOD
848 || p->eState==PAGER_WRITER_DBMOD
849 || p->eState==PAGER_WRITER_FINISHED
dana42c66b2010-08-03 18:18:41 +0000850 || p->eState==PAGER_ERROR
dand0864082010-08-02 14:32:52 +0000851 );
danielk1977bea2a942009-01-20 17:06:27 +0000852
dand0864082010-08-02 14:32:52 +0000853 /* Regardless of the current state, a temp-file connection always behaves
854 ** as if it has an exclusive lock on the database file. It never updates
855 ** the change-counter field, so the changeCountDone flag is always set.
856 */
857 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
858 assert( p->tempFile==0 || pPager->changeCountDone );
859
860 /* If the useJournal flag is clear, the journal-mode must be "OFF".
861 ** And if the journal-mode is "OFF", the journal file must not be open.
862 */
863 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
864 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
865
dan22b328b2010-08-11 18:56:45 +0000866 /* Check that MEMDB implies noSync. And an in-memory journal. Since
867 ** this means an in-memory pager performs no IO at all, it cannot encounter
868 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
869 ** a journal file. (although the in-memory journal implementation may
870 ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
871 ** is therefore not possible for an in-memory pager to enter the ERROR
872 ** state.
873 */
874 if( MEMDB ){
drh835f22d2016-04-25 19:20:56 +0000875 assert( !isOpen(p->fd) );
dan22b328b2010-08-11 18:56:45 +0000876 assert( p->noSync );
877 assert( p->journalMode==PAGER_JOURNALMODE_OFF
878 || p->journalMode==PAGER_JOURNALMODE_MEMORY
879 );
880 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
881 assert( pagerUseWal(p)==0 );
882 }
dand0864082010-08-02 14:32:52 +0000883
dan431b0b42010-08-04 19:14:22 +0000884 /* If changeCountDone is set, a RESERVED lock or greater must be held
885 ** on the file.
886 */
887 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
dan54919f82010-08-05 18:53:26 +0000888 assert( p->eLock!=PENDING_LOCK );
dan431b0b42010-08-04 19:14:22 +0000889
dand0864082010-08-02 14:32:52 +0000890 switch( p->eState ){
dande1ae342010-08-06 12:00:27 +0000891 case PAGER_OPEN:
dand0864082010-08-02 14:32:52 +0000892 assert( !MEMDB );
dana42c66b2010-08-03 18:18:41 +0000893 assert( pPager->errCode==SQLITE_OK );
dan4e004aa2010-08-05 15:30:22 +0000894 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
dand0864082010-08-02 14:32:52 +0000895 break;
896
897 case PAGER_READER:
dana42c66b2010-08-03 18:18:41 +0000898 assert( pPager->errCode==SQLITE_OK );
dan4e004aa2010-08-05 15:30:22 +0000899 assert( p->eLock!=UNKNOWN_LOCK );
drh33f111d2012-01-17 15:29:14 +0000900 assert( p->eLock>=SHARED_LOCK );
dand0864082010-08-02 14:32:52 +0000901 break;
902
dande1ae342010-08-06 12:00:27 +0000903 case PAGER_WRITER_LOCKED:
dan4e004aa2010-08-05 15:30:22 +0000904 assert( p->eLock!=UNKNOWN_LOCK );
dana42c66b2010-08-03 18:18:41 +0000905 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000906 if( !pagerUseWal(pPager) ){
907 assert( p->eLock>=RESERVED_LOCK );
908 }
dan937ac9d2010-08-03 12:48:45 +0000909 assert( pPager->dbSize==pPager->dbOrigSize );
910 assert( pPager->dbOrigSize==pPager->dbFileSize );
danc8649122010-08-10 09:58:57 +0000911 assert( pPager->dbOrigSize==pPager->dbHintSize );
dana42c66b2010-08-03 18:18:41 +0000912 assert( pPager->setMaster==0 );
dand0864082010-08-02 14:32:52 +0000913 break;
914
915 case PAGER_WRITER_CACHEMOD:
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 /* It is possible that if journal_mode=wal here that neither the
920 ** journal file nor the WAL file are open. This happens during
921 ** a rollback transaction that switches from journal_mode=off
922 ** to journal_mode=wal.
923 */
924 assert( p->eLock>=RESERVED_LOCK );
925 assert( isOpen(p->jfd)
926 || p->journalMode==PAGER_JOURNALMODE_OFF
927 || p->journalMode==PAGER_JOURNALMODE_WAL
928 );
929 }
dan937ac9d2010-08-03 12:48:45 +0000930 assert( pPager->dbOrigSize==pPager->dbFileSize );
danc8649122010-08-10 09:58:57 +0000931 assert( pPager->dbOrigSize==pPager->dbHintSize );
dand0864082010-08-02 14:32:52 +0000932 break;
933
934 case PAGER_WRITER_DBMOD:
dan4e004aa2010-08-05 15:30:22 +0000935 assert( p->eLock==EXCLUSIVE_LOCK );
dana42c66b2010-08-03 18:18:41 +0000936 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000937 assert( !pagerUseWal(pPager) );
dan4e004aa2010-08-05 15:30:22 +0000938 assert( p->eLock>=EXCLUSIVE_LOCK );
dand0864082010-08-02 14:32:52 +0000939 assert( isOpen(p->jfd)
940 || p->journalMode==PAGER_JOURNALMODE_OFF
941 || p->journalMode==PAGER_JOURNALMODE_WAL
942 );
danc8649122010-08-10 09:58:57 +0000943 assert( pPager->dbOrigSize<=pPager->dbHintSize );
dand0864082010-08-02 14:32:52 +0000944 break;
945
946 case PAGER_WRITER_FINISHED:
dan4e004aa2010-08-05 15:30:22 +0000947 assert( p->eLock==EXCLUSIVE_LOCK );
dana42c66b2010-08-03 18:18:41 +0000948 assert( pPager->errCode==SQLITE_OK );
dand0864082010-08-02 14:32:52 +0000949 assert( !pagerUseWal(pPager) );
dand0864082010-08-02 14:32:52 +0000950 assert( isOpen(p->jfd)
951 || p->journalMode==PAGER_JOURNALMODE_OFF
952 || p->journalMode==PAGER_JOURNALMODE_WAL
953 );
954 break;
dana42c66b2010-08-03 18:18:41 +0000955
956 case PAGER_ERROR:
957 /* There must be at least one outstanding reference to the pager if
958 ** in ERROR state. Otherwise the pager should have already dropped
dande1ae342010-08-06 12:00:27 +0000959 ** back to OPEN state.
dana42c66b2010-08-03 18:18:41 +0000960 */
961 assert( pPager->errCode!=SQLITE_OK );
dan67330a12016-04-11 18:07:47 +0000962 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );
dana42c66b2010-08-03 18:18:41 +0000963 break;
dand0864082010-08-02 14:32:52 +0000964 }
danielk1977bea2a942009-01-20 17:06:27 +0000965
966 return 1;
967}
dan6a88adc2010-11-04 04:47:42 +0000968#endif /* ifndef NDEBUG */
dand0864082010-08-02 14:32:52 +0000969
dan6a88adc2010-11-04 04:47:42 +0000970#ifdef SQLITE_DEBUG
dand0864082010-08-02 14:32:52 +0000971/*
dande1ae342010-08-06 12:00:27 +0000972** Return a pointer to a human readable string in a static buffer
973** containing the state of the Pager object passed as an argument. This
974** is intended to be used within debuggers. For example, as an alternative
975** to "print *pPager" in gdb:
976**
dand0864082010-08-02 14:32:52 +0000977** (gdb) printf "%s", print_pager_state(pPager)
978*/
979static char *print_pager_state(Pager *p){
980 static char zRet[1024];
981
982 sqlite3_snprintf(1024, zRet,
dan11f47a92010-08-06 06:54:47 +0000983 "Filename: %s\n"
dan4e004aa2010-08-05 15:30:22 +0000984 "State: %s errCode=%d\n"
dan937ac9d2010-08-03 12:48:45 +0000985 "Lock: %s\n"
dand0864082010-08-02 14:32:52 +0000986 "Locking mode: locking_mode=%s\n"
dan937ac9d2010-08-03 12:48:45 +0000987 "Journal mode: journal_mode=%s\n"
988 "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
dan4e004aa2010-08-05 15:30:22 +0000989 "Journal: journalOff=%lld journalHdr=%lld\n"
dan73d66fd2010-08-07 16:17:48 +0000990 "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
dan11f47a92010-08-06 06:54:47 +0000991 , p->zFilename
dande1ae342010-08-06 12:00:27 +0000992 , p->eState==PAGER_OPEN ? "OPEN" :
dand0864082010-08-02 14:32:52 +0000993 p->eState==PAGER_READER ? "READER" :
dande1ae342010-08-06 12:00:27 +0000994 p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
dand0864082010-08-02 14:32:52 +0000995 p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
996 p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
dana42c66b2010-08-03 18:18:41 +0000997 p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
998 p->eState==PAGER_ERROR ? "ERROR" : "?error?"
dan4e004aa2010-08-05 15:30:22 +0000999 , (int)p->errCode
dan5198bea2010-08-09 16:12:51 +00001000 , p->eLock==NO_LOCK ? "NO_LOCK" :
dand0864082010-08-02 14:32:52 +00001001 p->eLock==RESERVED_LOCK ? "RESERVED" :
1002 p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
dan4e004aa2010-08-05 15:30:22 +00001003 p->eLock==SHARED_LOCK ? "SHARED" :
1004 p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
dand0864082010-08-02 14:32:52 +00001005 , p->exclusiveMode ? "exclusive" : "normal"
dan937ac9d2010-08-03 12:48:45 +00001006 , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
1007 p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
1008 p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
1009 p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
1010 p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
1011 p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
1012 , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
dan4e004aa2010-08-05 15:30:22 +00001013 , p->journalOff, p->journalHdr
dan73d66fd2010-08-07 16:17:48 +00001014 , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
dand0864082010-08-02 14:32:52 +00001015 );
1016
1017 return zRet;
1018}
danielk1977bea2a942009-01-20 17:06:27 +00001019#endif
1020
danielk197726836652005-01-17 01:33:13 +00001021/*
danielk19773460d192008-12-27 15:23:13 +00001022** Return true if it is necessary to write page *pPg into the sub-journal.
1023** A page needs to be written into the sub-journal if there exists one
1024** or more open savepoints for which:
danielk1977fd7f0452008-12-17 17:30:26 +00001025**
danielk19773460d192008-12-27 15:23:13 +00001026** * The page-number is less than or equal to PagerSavepoint.nOrig, and
1027** * The bit corresponding to the page-number is not set in
1028** PagerSavepoint.pInSavepoint.
danielk1977f35843b2007-04-07 15:03:17 +00001029*/
danielk19773460d192008-12-27 15:23:13 +00001030static int subjRequiresPage(PgHdr *pPg){
danielk1977f35843b2007-04-07 15:03:17 +00001031 Pager *pPager = pPg->pPager;
drh9d1ab072013-08-21 22:54:55 +00001032 PagerSavepoint *p;
drh16f9a812013-12-13 19:48:04 +00001033 Pgno pgno = pPg->pgno;
danielk19773460d192008-12-27 15:23:13 +00001034 int i;
1035 for(i=0; i<pPager->nSavepoint; i++){
drh16f9a812013-12-13 19:48:04 +00001036 p = &pPager->aSavepoint[i];
drh82ef8772015-06-29 14:11:50 +00001037 if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
danielk19773460d192008-12-27 15:23:13 +00001038 return 1;
1039 }
danielk1977fd7f0452008-12-17 17:30:26 +00001040 }
danielk19773460d192008-12-27 15:23:13 +00001041 return 0;
danielk1977f35843b2007-04-07 15:03:17 +00001042}
drh8ca0c722006-05-07 17:49:38 +00001043
drh82ef8772015-06-29 14:11:50 +00001044#ifdef SQLITE_DEBUG
danielk19773460d192008-12-27 15:23:13 +00001045/*
1046** Return true if the page is already in the journal file.
1047*/
drh5dee6af2013-12-13 20:45:50 +00001048static int pageInJournal(Pager *pPager, PgHdr *pPg){
1049 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
danielk1977bc2ca9e2008-11-13 14:28:28 +00001050}
drh82ef8772015-06-29 14:11:50 +00001051#endif
danielk1977bc2ca9e2008-11-13 14:28:28 +00001052
drh8ca0c722006-05-07 17:49:38 +00001053/*
drh34e79ce2004-02-08 06:05:46 +00001054** Read a 32-bit integer from the given file descriptor. Store the integer
1055** that is read in *pRes. Return SQLITE_OK if everything worked, or an
1056** error code is something goes wrong.
drh726de592004-06-10 23:35:50 +00001057**
1058** All values are stored on disk as big-endian.
drh94f33312002-08-12 12:29:56 +00001059*/
danielk197762079062007-08-15 17:08:46 +00001060static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
drh3b59a5c2006-01-15 20:28:28 +00001061 unsigned char ac[4];
danielk197762079062007-08-15 17:08:46 +00001062 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
drhae2b40c2004-06-09 19:03:54 +00001063 if( rc==SQLITE_OK ){
drha3152892007-05-05 11:48:52 +00001064 *pRes = sqlite3Get4byte(ac);
drh94f33312002-08-12 12:29:56 +00001065 }
drh94f33312002-08-12 12:29:56 +00001066 return rc;
1067}
1068
1069/*
drh97b57482006-01-10 20:32:32 +00001070** Write a 32-bit integer into a string buffer in big-endian byte order.
1071*/
drha3152892007-05-05 11:48:52 +00001072#define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
drh97b57482006-01-10 20:32:32 +00001073
dand0864082010-08-02 14:32:52 +00001074
drh97b57482006-01-10 20:32:32 +00001075/*
drh34e79ce2004-02-08 06:05:46 +00001076** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
1077** on success or an error code is something goes wrong.
drh94f33312002-08-12 12:29:56 +00001078*/
danielk197762079062007-08-15 17:08:46 +00001079static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
danielk1977bab45c62006-01-16 15:14:27 +00001080 char ac[4];
drh97b57482006-01-10 20:32:32 +00001081 put32bits(ac, val);
danielk197762079062007-08-15 17:08:46 +00001082 return sqlite3OsWrite(fd, ac, 4, offset);
drh94f33312002-08-12 12:29:56 +00001083}
1084
drh2554f8b2003-01-22 01:26:44 +00001085/*
dan54919f82010-08-05 18:53:26 +00001086** Unlock the database file to level eLock, which must be either NO_LOCK
1087** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
1088** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
1089**
1090** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1091** called, do not modify it. See the comment above the #define of
1092** UNKNOWN_LOCK for an explanation of this.
danielk19777a2b1ee2007-08-21 14:27:01 +00001093*/
dan4e004aa2010-08-05 15:30:22 +00001094static int pagerUnlockDb(Pager *pPager, int eLock){
dan431b0b42010-08-04 19:14:22 +00001095 int rc = SQLITE_OK;
dan54919f82010-08-05 18:53:26 +00001096
dan8c408002010-11-01 17:38:24 +00001097 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
dan54919f82010-08-05 18:53:26 +00001098 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
1099 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
dan431b0b42010-08-04 19:14:22 +00001100 if( isOpen(pPager->fd) ){
1101 assert( pPager->eLock>=eLock );
drh57fe1362014-05-01 01:49:22 +00001102 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
dan4e004aa2010-08-05 15:30:22 +00001103 if( pPager->eLock!=UNKNOWN_LOCK ){
shaneh1df2db72010-08-18 02:28:48 +00001104 pPager->eLock = (u8)eLock;
dan431b0b42010-08-04 19:14:22 +00001105 }
dan4e004aa2010-08-05 15:30:22 +00001106 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
danielk19777a2b1ee2007-08-21 14:27:01 +00001107 }
dan431b0b42010-08-04 19:14:22 +00001108 return rc;
1109}
1110
dan54919f82010-08-05 18:53:26 +00001111/*
1112** Lock the database file to level eLock, which must be either SHARED_LOCK,
1113** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
1114** Pager.eLock variable to the new locking state.
1115**
1116** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1117** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
1118** See the comment above the #define of UNKNOWN_LOCK for an explanation
1119** of this.
1120*/
dan4e004aa2010-08-05 15:30:22 +00001121static int pagerLockDb(Pager *pPager, int eLock){
dan54919f82010-08-05 18:53:26 +00001122 int rc = SQLITE_OK;
1123
dan431b0b42010-08-04 19:14:22 +00001124 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
dan54919f82010-08-05 18:53:26 +00001125 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
drh57fe1362014-05-01 01:49:22 +00001126 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
dan4e004aa2010-08-05 15:30:22 +00001127 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
shaneh1df2db72010-08-18 02:28:48 +00001128 pPager->eLock = (u8)eLock;
dan4e004aa2010-08-05 15:30:22 +00001129 IOTRACE(("LOCK %p %d\n", pPager, eLock))
dan431b0b42010-08-04 19:14:22 +00001130 }
1131 }
1132 return rc;
danielk19777a2b1ee2007-08-21 14:27:01 +00001133}
1134
1135/*
danielk1977c7b60172007-08-22 11:22:03 +00001136** This function determines whether or not the atomic-write optimization
1137** can be used with this pager. The optimization can be used if:
1138**
1139** (a) the value returned by OsDeviceCharacteristics() indicates that
1140** a database page may be written atomically, and
1141** (b) the value returned by OsSectorSize() is less than or equal
1142** to the page size.
1143**
danielk1977bea2a942009-01-20 17:06:27 +00001144** The optimization is also always enabled for temporary files. It is
1145** an error to call this function if pPager is opened on an in-memory
1146** database.
1147**
danielk1977c7b60172007-08-22 11:22:03 +00001148** If the optimization cannot be used, 0 is returned. If it can be used,
1149** then the value returned is the size of the journal file when it
1150** contains rollback data for exactly one page.
1151*/
1152#ifdef SQLITE_ENABLE_ATOMIC_WRITE
1153static int jrnlBufferSize(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00001154 assert( !MEMDB );
1155 if( !pPager->tempFile ){
1156 int dc; /* Device characteristics */
1157 int nSector; /* Sector size */
1158 int szPage; /* Page size */
danielk1977c7b60172007-08-22 11:22:03 +00001159
danielk1977bea2a942009-01-20 17:06:27 +00001160 assert( isOpen(pPager->fd) );
1161 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
danielk19777cbd5892009-01-10 16:15:09 +00001162 nSector = pPager->sectorSize;
drhfacf0302008-06-17 15:12:00 +00001163 szPage = pPager->pageSize;
danielk1977c7b60172007-08-22 11:22:03 +00001164
danielk1977bea2a942009-01-20 17:06:27 +00001165 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
1166 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
1167 if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
1168 return 0;
danielk1977ae72d982007-10-03 08:46:44 +00001169 }
danielk1977aef0bf62005-12-30 16:28:01 +00001170 }
danielk1977bea2a942009-01-20 17:06:27 +00001171
1172 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
danielk1977aef0bf62005-12-30 16:28:01 +00001173}
dan9131ab92016-04-06 18:20:51 +00001174#else
1175# define jrnlBufferSize(x) 0
danielk1977bea2a942009-01-20 17:06:27 +00001176#endif
danielk1977aef0bf62005-12-30 16:28:01 +00001177
drh477731b2007-06-16 03:06:27 +00001178/*
1179** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
1180** on the cache using a hash function. This is used for testing
1181** and debugging only.
1182*/
danielk19773c407372005-02-15 02:54:14 +00001183#ifdef SQLITE_CHECK_PAGES
1184/*
1185** Return a 32-bit hash of the page data for pPage.
1186*/
drh477731b2007-06-16 03:06:27 +00001187static u32 pager_datahash(int nByte, unsigned char *pData){
danielk19773c407372005-02-15 02:54:14 +00001188 u32 hash = 0;
1189 int i;
drh477731b2007-06-16 03:06:27 +00001190 for(i=0; i<nByte; i++){
1191 hash = (hash*1039) + pData[i];
danielk19773c407372005-02-15 02:54:14 +00001192 }
1193 return hash;
1194}
drh477731b2007-06-16 03:06:27 +00001195static u32 pager_pagehash(PgHdr *pPage){
danielk19778c0a7912008-08-20 14:49:23 +00001196 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
1197}
danielk1977bc2ca9e2008-11-13 14:28:28 +00001198static void pager_set_pagehash(PgHdr *pPage){
danielk19778c0a7912008-08-20 14:49:23 +00001199 pPage->pageHash = pager_pagehash(pPage);
drh477731b2007-06-16 03:06:27 +00001200}
danielk19773c407372005-02-15 02:54:14 +00001201
1202/*
1203** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
1204** is defined, and NDEBUG is not defined, an assert() statement checks
1205** that the page is either dirty or still matches the calculated page-hash.
1206*/
1207#define CHECK_PAGE(x) checkPage(x)
1208static void checkPage(PgHdr *pPg){
1209 Pager *pPager = pPg->pPager;
dan5f848c32010-08-23 18:19:31 +00001210 assert( pPager->eState!=PAGER_ERROR );
1211 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
danielk19773c407372005-02-15 02:54:14 +00001212}
1213
1214#else
drh8ffa8172007-06-18 17:25:17 +00001215#define pager_datahash(X,Y) 0
drh477731b2007-06-16 03:06:27 +00001216#define pager_pagehash(X) 0
dan5f848c32010-08-23 18:19:31 +00001217#define pager_set_pagehash(X)
danielk19773c407372005-02-15 02:54:14 +00001218#define CHECK_PAGE(x)
drh41d30272008-08-20 21:47:45 +00001219#endif /* SQLITE_CHECK_PAGES */
danielk19773c407372005-02-15 02:54:14 +00001220
drhed7c8552001-04-11 14:29:21 +00001221/*
danielk197776572402004-06-25 02:38:54 +00001222** When this is called the journal file for pager pPager must be open.
danielk1977bea2a942009-01-20 17:06:27 +00001223** This function attempts to read a master journal file name from the
1224** end of the file and, if successful, copies it into memory supplied
1225** by the caller. See comments above writeMasterJournal() for the format
1226** used to store a master journal file name at the end of a journal file.
danielk197776572402004-06-25 02:38:54 +00001227**
danielk197765839c62007-08-30 08:08:17 +00001228** zMaster must point to a buffer of at least nMaster bytes allocated by
1229** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
1230** enough space to write the master journal name). If the master journal
1231** name in the journal is longer than nMaster bytes (including a
1232** nul-terminator), then this is handled as if no master journal name
1233** were present in the journal.
1234**
danielk1977bea2a942009-01-20 17:06:27 +00001235** If a master journal file name is present at the end of the journal
1236** file, then it is copied into the buffer pointed to by zMaster. A
1237** nul-terminator byte is appended to the buffer following the master
1238** journal file name.
1239**
1240** If it is determined that no master journal file name is present
1241** zMaster[0] is set to 0 and SQLITE_OK returned.
1242**
1243** If an error occurs while reading from the journal file, an SQLite
1244** error code is returned.
danielk197776572402004-06-25 02:38:54 +00001245*/
danielk1977d92db532008-11-17 04:56:24 +00001246static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
danielk1977bea2a942009-01-20 17:06:27 +00001247 int rc; /* Return code */
1248 u32 len; /* Length in bytes of master journal name */
1249 i64 szJ; /* Total size in bytes of journal file pJrnl */
1250 u32 cksum; /* MJ checksum value read from journal */
1251 u32 u; /* Unsigned loop counter */
1252 unsigned char aMagic[8]; /* A buffer to hold the magic header */
danielk197765839c62007-08-30 08:08:17 +00001253 zMaster[0] = '\0';
danielk197776572402004-06-25 02:38:54 +00001254
danielk1977bea2a942009-01-20 17:06:27 +00001255 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
1256 || szJ<16
1257 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
1258 || len>=nMaster
dan999cd082013-12-09 20:42:03 +00001259 || len==0
danielk1977bea2a942009-01-20 17:06:27 +00001260 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
1261 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
1262 || memcmp(aMagic, aJournalMagic, 8)
1263 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
1264 ){
danielk197776572402004-06-25 02:38:54 +00001265 return rc;
1266 }
danielk1977cafadba2004-06-25 11:11:54 +00001267
1268 /* See if the checksum matches the master journal name */
shane0b8d2762008-07-22 05:18:00 +00001269 for(u=0; u<len; u++){
1270 cksum -= zMaster[u];
danielk1977bea2a942009-01-20 17:06:27 +00001271 }
danielk19778191bff2004-06-28 04:52:30 +00001272 if( cksum ){
1273 /* If the checksum doesn't add up, then one or more of the disk sectors
1274 ** containing the master journal filename is corrupted. This means
1275 ** definitely roll back, so just return SQLITE_OK and report a (nul)
1276 ** master-journal filename.
1277 */
danielk1977bea2a942009-01-20 17:06:27 +00001278 len = 0;
danielk1977cafadba2004-06-25 11:11:54 +00001279 }
danielk1977bea2a942009-01-20 17:06:27 +00001280 zMaster[len] = '\0';
danielk197776572402004-06-25 02:38:54 +00001281
1282 return SQLITE_OK;
1283}
1284
1285/*
danielk1977bea2a942009-01-20 17:06:27 +00001286** Return the offset of the sector boundary at or immediately
1287** following the value in pPager->journalOff, assuming a sector
1288** size of pPager->sectorSize bytes.
danielk197776572402004-06-25 02:38:54 +00001289**
1290** i.e for a sector size of 512:
1291**
danielk1977bea2a942009-01-20 17:06:27 +00001292** Pager.journalOff Return value
1293** ---------------------------------------
1294** 0 0
1295** 512 512
1296** 100 512
1297** 2000 2048
danielk197776572402004-06-25 02:38:54 +00001298**
1299*/
danielk1977112f7522009-01-08 17:50:45 +00001300static i64 journalHdrOffset(Pager *pPager){
drheb206252004-10-01 02:00:31 +00001301 i64 offset = 0;
1302 i64 c = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001303 if( c ){
1304 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
1305 }
1306 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
1307 assert( offset>=c );
1308 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
danielk1977112f7522009-01-08 17:50:45 +00001309 return offset;
1310}
danielk197776572402004-06-25 02:38:54 +00001311
1312/*
danielk1977bea2a942009-01-20 17:06:27 +00001313** The journal file must be open when this function is called.
1314**
1315** This function is a no-op if the journal file has not been written to
1316** within the current transaction (i.e. if Pager.journalOff==0).
1317**
1318** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
1319** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
1320** zero the 28-byte header at the start of the journal file. In either case,
1321** if the pager is not in no-sync mode, sync the journal file immediately
1322** after writing or truncating it.
1323**
1324** If Pager.journalSizeLimit is set to a positive, non-zero value, and
1325** following the truncation or zeroing described above the size of the
1326** journal file in bytes is larger than this value, then truncate the
1327** journal file to Pager.journalSizeLimit bytes. The journal file does
1328** not need to be synced following this operation.
1329**
1330** If an IO error occurs, abandon processing and return the IO error code.
1331** Otherwise, return SQLITE_OK.
drhf3a87622008-04-17 14:16:42 +00001332*/
danielk1977df2566a2008-05-07 19:11:03 +00001333static int zeroJournalHdr(Pager *pPager, int doTruncate){
danielk1977bea2a942009-01-20 17:06:27 +00001334 int rc = SQLITE_OK; /* Return code */
1335 assert( isOpen(pPager->jfd) );
dan5f37ed52016-02-29 20:00:13 +00001336 assert( !sqlite3JournalIsInMemory(pPager->jfd) );
danielk1977df2566a2008-05-07 19:11:03 +00001337 if( pPager->journalOff ){
danielk1977bea2a942009-01-20 17:06:27 +00001338 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
danielk1977b53e4962008-06-04 06:45:59 +00001339
danielk1977df2566a2008-05-07 19:11:03 +00001340 IOTRACE(("JZEROHDR %p\n", pPager))
danielk1977b53e4962008-06-04 06:45:59 +00001341 if( doTruncate || iLimit==0 ){
danielk1977df2566a2008-05-07 19:11:03 +00001342 rc = sqlite3OsTruncate(pPager->jfd, 0);
1343 }else{
danielk1977bea2a942009-01-20 17:06:27 +00001344 static const char zeroHdr[28] = {0};
danielk1977df2566a2008-05-07 19:11:03 +00001345 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
1346 }
danielk197781620542008-06-07 05:19:37 +00001347 if( rc==SQLITE_OK && !pPager->noSync ){
drhc97d8462010-11-19 18:23:35 +00001348 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
danielk1977df2566a2008-05-07 19:11:03 +00001349 }
danielk1977b53e4962008-06-04 06:45:59 +00001350
1351 /* At this point the transaction is committed but the write lock
1352 ** is still held on the file. If there is a size limit configured for
1353 ** the persistent journal and the journal file currently consumes more
1354 ** space than that limit allows for, truncate it now. There is no need
1355 ** to sync the file following this operation.
1356 */
1357 if( rc==SQLITE_OK && iLimit>0 ){
1358 i64 sz;
1359 rc = sqlite3OsFileSize(pPager->jfd, &sz);
1360 if( rc==SQLITE_OK && sz>iLimit ){
1361 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
1362 }
1363 }
drha06ecba2008-04-22 17:15:17 +00001364 }
drhf3a87622008-04-17 14:16:42 +00001365 return rc;
1366}
1367
1368/*
danielk197776572402004-06-25 02:38:54 +00001369** The journal file must be open when this routine is called. A journal
1370** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
1371** current location.
1372**
1373** The format for the journal header is as follows:
1374** - 8 bytes: Magic identifying journal format.
1375** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
1376** - 4 bytes: Random number used for page hash.
1377** - 4 bytes: Initial database page count.
1378** - 4 bytes: Sector size used by the process that wrote this journal.
danielk197767c007b2008-03-20 04:45:49 +00001379** - 4 bytes: Database page size.
danielk197776572402004-06-25 02:38:54 +00001380**
danielk197767c007b2008-03-20 04:45:49 +00001381** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
danielk197776572402004-06-25 02:38:54 +00001382*/
1383static int writeJournalHdr(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00001384 int rc = SQLITE_OK; /* Return code */
1385 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
drh43b18e12010-08-17 19:40:08 +00001386 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
danielk1977bea2a942009-01-20 17:06:27 +00001387 u32 nWrite; /* Bytes of header sector written */
1388 int ii; /* Loop counter */
1389
1390 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
danielk1977a664f8e2008-04-22 14:31:48 +00001391
1392 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
1393 nHeader = JOURNAL_HDR_SZ(pPager);
1394 }
danielk197776572402004-06-25 02:38:54 +00001395
danielk1977bea2a942009-01-20 17:06:27 +00001396 /* If there are active savepoints and any of them were created
1397 ** since the most recent journal header was written, update the
1398 ** PagerSavepoint.iHdrOffset fields now.
danielk1977fd7f0452008-12-17 17:30:26 +00001399 */
1400 for(ii=0; ii<pPager->nSavepoint; ii++){
1401 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
1402 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
1403 }
danielk19774099f6e2007-03-19 11:25:20 +00001404 }
1405
danielk1977bea2a942009-01-20 17:06:27 +00001406 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
danielk19774cd2cd52007-08-23 14:48:23 +00001407
1408 /*
1409 ** Write the nRec Field - the number of page records that follow this
1410 ** journal header. Normally, zero is written to this value at this time.
1411 ** After the records are added to the journal (and the journal synced,
1412 ** if in full-sync mode), the zero is overwritten with the true number
1413 ** of records (see syncJournal()).
1414 **
1415 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
1416 ** reading the journal this value tells SQLite to assume that the
1417 ** rest of the journal file contains valid page records. This assumption
shanebe217792009-03-05 04:20:31 +00001418 ** is dangerous, as if a failure occurred whilst writing to the journal
danielk19774cd2cd52007-08-23 14:48:23 +00001419 ** file it may contain some garbage data. There are two scenarios
1420 ** where this risk can be ignored:
1421 **
1422 ** * When the pager is in no-sync mode. Corruption can follow a
1423 ** power failure in this case anyway.
1424 **
1425 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1426 ** that garbage data is never appended to the journal file.
1427 */
danielk1977bea2a942009-01-20 17:06:27 +00001428 assert( isOpen(pPager->fd) || pPager->noSync );
dand0864082010-08-02 14:32:52 +00001429 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
danielk19774cd2cd52007-08-23 14:48:23 +00001430 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
1431 ){
danielk19776f4c73e2009-06-26 07:12:06 +00001432 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
danielk19774cd2cd52007-08-23 14:48:23 +00001433 put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
1434 }else{
drh5ec53192009-08-31 16:09:58 +00001435 memset(zHeader, 0, sizeof(aJournalMagic)+4);
danielk19774cd2cd52007-08-23 14:48:23 +00001436 }
1437
mistachkin48864df2013-03-21 21:20:32 +00001438 /* The random check-hash initializer */
drh2fa18682008-03-19 14:15:34 +00001439 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
drh97b57482006-01-10 20:32:32 +00001440 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
1441 /* The initial database size */
danielk19773460d192008-12-27 15:23:13 +00001442 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
drh97b57482006-01-10 20:32:32 +00001443 /* The assumed sector size for this process */
1444 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
drh08609ce2008-11-29 22:49:23 +00001445
danielk1977bea2a942009-01-20 17:06:27 +00001446 /* The page size */
1447 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
1448
drh08609ce2008-11-29 22:49:23 +00001449 /* Initializing the tail of the buffer is not necessary. Everything
1450 ** works find if the following memset() is omitted. But initializing
1451 ** the memory prevents valgrind from complaining, so we are willing to
1452 ** take the performance hit.
1453 */
danielk1977bea2a942009-01-20 17:06:27 +00001454 memset(&zHeader[sizeof(aJournalMagic)+20], 0,
1455 nHeader-(sizeof(aJournalMagic)+20));
drh08609ce2008-11-29 22:49:23 +00001456
danielk1977bea2a942009-01-20 17:06:27 +00001457 /* In theory, it is only necessary to write the 28 bytes that the
1458 ** journal header consumes to the journal file here. Then increment the
1459 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
1460 ** record is written to the following sector (leaving a gap in the file
1461 ** that will be implicitly filled in by the OS).
1462 **
1463 ** However it has been discovered that on some systems this pattern can
1464 ** be significantly slower than contiguously writing data to the file,
1465 ** even if that means explicitly writing data to the block of
1466 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
1467 ** is done.
1468 **
1469 ** The loop is required here in case the sector-size is larger than the
1470 ** database page size. Since the zHeader buffer is only Pager.pageSize
1471 ** bytes in size, more than one call to sqlite3OsWrite() may be required
1472 ** to populate the entire journal header sector.
1473 */
danielk1977a664f8e2008-04-22 14:31:48 +00001474 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
1475 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
1476 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
drh91781bd2010-04-10 17:52:57 +00001477 assert( pPager->journalHdr <= pPager->journalOff );
danielk1977a664f8e2008-04-22 14:31:48 +00001478 pPager->journalOff += nHeader;
danielk197776572402004-06-25 02:38:54 +00001479 }
danielk1977a664f8e2008-04-22 14:31:48 +00001480
danielk197776572402004-06-25 02:38:54 +00001481 return rc;
1482}
1483
1484/*
1485** The journal file must be open when this is called. A journal header file
1486** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
drhd6e5e092009-01-07 02:03:35 +00001487** file. The current location in the journal file is given by
danielk1977bea2a942009-01-20 17:06:27 +00001488** pPager->journalOff. See comments above function writeJournalHdr() for
drhd6e5e092009-01-07 02:03:35 +00001489** a description of the journal header format.
danielk197776572402004-06-25 02:38:54 +00001490**
danielk1977bea2a942009-01-20 17:06:27 +00001491** If the header is read successfully, *pNRec is set to the number of
1492** page records following this header and *pDbSize is set to the size of the
danielk197776572402004-06-25 02:38:54 +00001493** database before the transaction began, in pages. Also, pPager->cksumInit
1494** is set to the value read from the journal header. SQLITE_OK is returned
1495** in this case.
1496**
1497** If the journal header file appears to be corrupted, SQLITE_DONE is
danielk1977bea2a942009-01-20 17:06:27 +00001498** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
danielk197776572402004-06-25 02:38:54 +00001499** cannot be read from the journal file an error code is returned.
1500*/
1501static int readJournalHdr(
danielk1977bea2a942009-01-20 17:06:27 +00001502 Pager *pPager, /* Pager object */
danielk19776f4c73e2009-06-26 07:12:06 +00001503 int isHot,
danielk1977bea2a942009-01-20 17:06:27 +00001504 i64 journalSize, /* Size of the open journal file in bytes */
1505 u32 *pNRec, /* OUT: Value read from the nRec field */
1506 u32 *pDbSize /* OUT: Value of original database size field */
danielk197776572402004-06-25 02:38:54 +00001507){
danielk1977bea2a942009-01-20 17:06:27 +00001508 int rc; /* Return code */
1509 unsigned char aMagic[8]; /* A buffer to hold the magic header */
1510 i64 iHdrOff; /* Offset of journal header being read */
danielk197776572402004-06-25 02:38:54 +00001511
danielk1977bea2a942009-01-20 17:06:27 +00001512 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
1513
1514 /* Advance Pager.journalOff to the start of the next sector. If the
1515 ** journal file is too small for there to be a header stored at this
1516 ** point, return SQLITE_DONE.
1517 */
1518 pPager->journalOff = journalHdrOffset(pPager);
danielk197776572402004-06-25 02:38:54 +00001519 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
1520 return SQLITE_DONE;
1521 }
danielk1977bea2a942009-01-20 17:06:27 +00001522 iHdrOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001523
danielk1977bea2a942009-01-20 17:06:27 +00001524 /* Read in the first 8 bytes of the journal header. If they do not match
1525 ** the magic string found at the start of each journal header, return
1526 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
1527 ** proceed.
1528 */
danielk19776f4c73e2009-06-26 07:12:06 +00001529 if( isHot || iHdrOff!=pPager->journalHdr ){
1530 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
1531 if( rc ){
1532 return rc;
1533 }
1534 if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
1535 return SQLITE_DONE;
1536 }
danielk197776572402004-06-25 02:38:54 +00001537 }
1538
danielk1977bea2a942009-01-20 17:06:27 +00001539 /* Read the first three 32-bit fields of the journal header: The nRec
1540 ** field, the checksum-initializer and the database size at the start
1541 ** of the transaction. Return an error code if anything goes wrong.
1542 */
1543 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
1544 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
1545 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
1546 ){
1547 return rc;
1548 }
danielk197776572402004-06-25 02:38:54 +00001549
danielk19777cbd5892009-01-10 16:15:09 +00001550 if( pPager->journalOff==0 ){
danielk1977bea2a942009-01-20 17:06:27 +00001551 u32 iPageSize; /* Page-size field of journal header */
1552 u32 iSectorSize; /* Sector-size field of journal header */
danielk197767c007b2008-03-20 04:45:49 +00001553
danielk1977bea2a942009-01-20 17:06:27 +00001554 /* Read the page-size and sector-size journal header fields. */
1555 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
1556 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
danielk19777cbd5892009-01-10 16:15:09 +00001557 ){
danielk1977bea2a942009-01-20 17:06:27 +00001558 return rc;
danielk1977443c0592009-01-16 15:21:05 +00001559 }
danielk1977bea2a942009-01-20 17:06:27 +00001560
dana35dafc2010-08-19 15:11:34 +00001561 /* Versions of SQLite prior to 3.5.8 set the page-size field of the
1562 ** journal header to zero. In this case, assume that the Pager.pageSize
1563 ** variable is already set to the correct page size.
1564 */
1565 if( iPageSize==0 ){
1566 iPageSize = pPager->pageSize;
1567 }
1568
danielk1977bea2a942009-01-20 17:06:27 +00001569 /* Check that the values read from the page-size and sector-size fields
1570 ** are within range. To be 'in range', both values need to be a power
drh3c99d682009-11-11 13:17:08 +00001571 ** of two greater than or equal to 512 or 32, and not greater than their
danielk1977bea2a942009-01-20 17:06:27 +00001572 ** respective compile time maximum limits.
1573 */
drh3c99d682009-11-11 13:17:08 +00001574 if( iPageSize<512 || iSectorSize<32
danielk1977bea2a942009-01-20 17:06:27 +00001575 || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
1576 || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
1577 ){
1578 /* If the either the page-size or sector-size in the journal-header is
1579 ** invalid, then the process that wrote the journal-header must have
1580 ** crashed before the header was synced. In this case stop reading
1581 ** the journal file here.
1582 */
1583 return SQLITE_DONE;
1584 }
1585
1586 /* Update the page-size to match the value read from the journal.
1587 ** Use a testcase() macro to make sure that malloc failure within
1588 ** PagerSetPagesize() is tested.
1589 */
drhb2eced52010-08-12 02:41:12 +00001590 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
danielk1977bea2a942009-01-20 17:06:27 +00001591 testcase( rc!=SQLITE_OK );
danielk1977bea2a942009-01-20 17:06:27 +00001592
danielk19777cbd5892009-01-10 16:15:09 +00001593 /* Update the assumed sector-size to match the value used by
1594 ** the process that created this journal. If this journal was
1595 ** created by a process other than this one, then this routine
1596 ** is being called from within pager_playback(). The local value
1597 ** of Pager.sectorSize is restored at the end of that routine.
1598 */
danielk19777cbd5892009-01-10 16:15:09 +00001599 pPager->sectorSize = iSectorSize;
drh98c58352008-11-07 00:24:53 +00001600 }
danielk197776572402004-06-25 02:38:54 +00001601
1602 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00001603 return rc;
danielk197776572402004-06-25 02:38:54 +00001604}
1605
1606
1607/*
1608** Write the supplied master journal name into the journal file for pager
danielk1977cafadba2004-06-25 11:11:54 +00001609** pPager at the current location. The master journal name must be the last
1610** thing written to a journal file. If the pager is in full-sync mode, the
1611** journal file descriptor is advanced to the next sector boundary before
1612** anything is written. The format is:
1613**
danielk1977bea2a942009-01-20 17:06:27 +00001614** + 4 bytes: PAGER_MJ_PGNO.
1615** + N bytes: Master journal filename in utf-8.
1616** + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
1617** + 4 bytes: Master journal name checksum.
1618** + 8 bytes: aJournalMagic[].
danielk1977cafadba2004-06-25 11:11:54 +00001619**
1620** The master journal page checksum is the sum of the bytes in the master
danielk1977bea2a942009-01-20 17:06:27 +00001621** journal name, where each byte is interpreted as a signed 8-bit integer.
danielk1977aef0bf62005-12-30 16:28:01 +00001622**
1623** If zMaster is a NULL pointer (occurs for a single database transaction),
1624** this call is a no-op.
danielk197776572402004-06-25 02:38:54 +00001625*/
1626static int writeMasterJournal(Pager *pPager, const char *zMaster){
danielk1977bea2a942009-01-20 17:06:27 +00001627 int rc; /* Return code */
1628 int nMaster; /* Length of string zMaster */
1629 i64 iHdrOff; /* Offset of header in journal file */
1630 i64 jrnlSize; /* Size of journal file on disk */
1631 u32 cksum = 0; /* Checksum of string zMaster */
danielk197776572402004-06-25 02:38:54 +00001632
dan1e01cf12010-07-30 11:31:12 +00001633 assert( pPager->setMaster==0 );
dand0864082010-08-02 14:32:52 +00001634 assert( !pagerUseWal(pPager) );
dan1e01cf12010-07-30 11:31:12 +00001635
1636 if( !zMaster
danielk1977bea2a942009-01-20 17:06:27 +00001637 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
drh1fb6a112014-04-04 14:12:52 +00001638 || !isOpen(pPager->jfd)
danielk1977bea2a942009-01-20 17:06:27 +00001639 ){
1640 return SQLITE_OK;
1641 }
danielk197776572402004-06-25 02:38:54 +00001642 pPager->setMaster = 1;
drh91781bd2010-04-10 17:52:57 +00001643 assert( pPager->journalHdr <= pPager->journalOff );
danielk197776572402004-06-25 02:38:54 +00001644
danielk1977bea2a942009-01-20 17:06:27 +00001645 /* Calculate the length in bytes and the checksum of zMaster */
1646 for(nMaster=0; zMaster[nMaster]; nMaster++){
1647 cksum += zMaster[nMaster];
danielk1977cafadba2004-06-25 11:11:54 +00001648 }
danielk197776572402004-06-25 02:38:54 +00001649
1650 /* If in full-sync mode, advance to the next disk sector before writing
1651 ** the master journal name. This is in case the previous page written to
1652 ** the journal has already been synced.
1653 */
1654 if( pPager->fullSync ){
danielk1977bea2a942009-01-20 17:06:27 +00001655 pPager->journalOff = journalHdrOffset(pPager);
danielk197776572402004-06-25 02:38:54 +00001656 }
danielk1977bea2a942009-01-20 17:06:27 +00001657 iHdrOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001658
danielk1977bea2a942009-01-20 17:06:27 +00001659 /* Write the master journal data to the end of the journal file. If
1660 ** an error occurs, return the error code to the caller.
1661 */
shane63207ab2009-02-04 01:49:30 +00001662 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
1663 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
1664 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
1665 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
drhe399ac22015-06-29 18:14:02 +00001666 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
1667 iHdrOff+4+nMaster+8)))
danielk1977bea2a942009-01-20 17:06:27 +00001668 ){
1669 return rc;
1670 }
1671 pPager->journalOff += (nMaster+20);
danielk1977df2566a2008-05-07 19:11:03 +00001672
1673 /* If the pager is in peristent-journal mode, then the physical
1674 ** journal-file may extend past the end of the master-journal name
1675 ** and 8 bytes of magic data just written to the file. This is
1676 ** dangerous because the code to rollback a hot-journal file
1677 ** will not be able to find the master-journal name to determine
1678 ** whether or not the journal is hot.
1679 **
1680 ** Easiest thing to do in this scenario is to truncate the journal
1681 ** file to the required size.
1682 */
danielk1977bea2a942009-01-20 17:06:27 +00001683 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
1684 && jrnlSize>pPager->journalOff
danielk1977df2566a2008-05-07 19:11:03 +00001685 ){
danielk1977bea2a942009-01-20 17:06:27 +00001686 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
danielk1977df2566a2008-05-07 19:11:03 +00001687 }
danielk197776572402004-06-25 02:38:54 +00001688 return rc;
1689}
1690
1691/*
dana42c66b2010-08-03 18:18:41 +00001692** Discard the entire contents of the in-memory page-cache.
drhed7c8552001-04-11 14:29:21 +00001693*/
drhd9b02572001-04-15 00:37:09 +00001694static void pager_reset(Pager *pPager){
drhd7107b32014-12-20 14:34:02 +00001695 pPager->iDataVersion++;
dana42c66b2010-08-03 18:18:41 +00001696 sqlite3BackupRestart(pPager->pBackup);
1697 sqlite3PcacheClear(pPager->pPCache);
danielk1977e277be02007-03-23 18:12:06 +00001698}
1699
danielk197734cf35d2008-12-18 18:31:38 +00001700/*
drhd7107b32014-12-20 14:34:02 +00001701** Return the pPager->iDataVersion value
drh91618562014-12-19 19:28:02 +00001702*/
1703u32 sqlite3PagerDataVersion(Pager *pPager){
1704 assert( pPager->eState>PAGER_OPEN );
drhd7107b32014-12-20 14:34:02 +00001705 return pPager->iDataVersion;
drh91618562014-12-19 19:28:02 +00001706}
1707
1708/*
danielk197734cf35d2008-12-18 18:31:38 +00001709** Free all structures in the Pager.aSavepoint[] array and set both
1710** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1711** if it is open and the pager is not in exclusive mode.
1712*/
danielk1977bea2a942009-01-20 17:06:27 +00001713static void releaseAllSavepoints(Pager *pPager){
1714 int ii; /* Iterator for looping through Pager.aSavepoint */
danielk1977fd7f0452008-12-17 17:30:26 +00001715 for(ii=0; ii<pPager->nSavepoint; ii++){
1716 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
1717 }
dan2491de22016-02-27 20:14:55 +00001718 if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){
danielk1977fd7f0452008-12-17 17:30:26 +00001719 sqlite3OsClose(pPager->sjfd);
1720 }
1721 sqlite3_free(pPager->aSavepoint);
1722 pPager->aSavepoint = 0;
1723 pPager->nSavepoint = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001724 pPager->nSubRec = 0;
danielk1977fd7f0452008-12-17 17:30:26 +00001725}
1726
danielk197734cf35d2008-12-18 18:31:38 +00001727/*
danielk1977bea2a942009-01-20 17:06:27 +00001728** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1729** bitvecs of all open savepoints. Return SQLITE_OK if successful
1730** or SQLITE_NOMEM if a malloc failure occurs.
danielk197734cf35d2008-12-18 18:31:38 +00001731*/
danielk1977fd7f0452008-12-17 17:30:26 +00001732static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
drh7539b6b2009-01-02 21:39:39 +00001733 int ii; /* Loop counter */
1734 int rc = SQLITE_OK; /* Result code */
1735
danielk1977fd7f0452008-12-17 17:30:26 +00001736 for(ii=0; ii<pPager->nSavepoint; ii++){
1737 PagerSavepoint *p = &pPager->aSavepoint[ii];
1738 if( pgno<=p->nOrig ){
drh7539b6b2009-01-02 21:39:39 +00001739 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
danielk1977bea2a942009-01-20 17:06:27 +00001740 testcase( rc==SQLITE_NOMEM );
drh7539b6b2009-01-02 21:39:39 +00001741 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
danielk1977fd7f0452008-12-17 17:30:26 +00001742 }
1743 }
drh7539b6b2009-01-02 21:39:39 +00001744 return rc;
danielk1977fd7f0452008-12-17 17:30:26 +00001745}
1746
danielk1977e277be02007-03-23 18:12:06 +00001747/*
dande5fd222010-08-09 19:17:29 +00001748** This function is a no-op if the pager is in exclusive mode and not
1749** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
1750** state.
danielk1977ae72d982007-10-03 08:46:44 +00001751**
dande5fd222010-08-09 19:17:29 +00001752** If the pager is not in exclusive-access mode, the database file is
1753** completely unlocked. If the file is unlocked and the file-system does
1754** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
1755** closed (if it is open).
1756**
1757** If the pager is in ERROR state when this function is called, the
1758** contents of the pager cache are discarded before switching back to
1759** the OPEN state. Regardless of whether the pager is in exclusive-mode
1760** or not, any journal file left in the file-system will be treated
1761** as a hot-journal and rolled back the next time a read-transaction
1762** is opened (by this or by any other connection).
danielk1977ae72d982007-10-03 08:46:44 +00001763*/
1764static void pager_unlock(Pager *pPager){
dana42c66b2010-08-03 18:18:41 +00001765
dande5fd222010-08-09 19:17:29 +00001766 assert( pPager->eState==PAGER_READER
1767 || pPager->eState==PAGER_OPEN
1768 || pPager->eState==PAGER_ERROR
1769 );
1770
dana42c66b2010-08-03 18:18:41 +00001771 sqlite3BitvecDestroy(pPager->pInJournal);
1772 pPager->pInJournal = 0;
1773 releaseAllSavepoints(pPager);
1774
1775 if( pagerUseWal(pPager) ){
1776 assert( !isOpen(pPager->jfd) );
1777 sqlite3WalEndReadTransaction(pPager->pWal);
dande1ae342010-08-06 12:00:27 +00001778 pPager->eState = PAGER_OPEN;
dana42c66b2010-08-03 18:18:41 +00001779 }else if( !pPager->exclusiveMode ){
dan4e004aa2010-08-05 15:30:22 +00001780 int rc; /* Error code returned by pagerUnlockDb() */
dane08341c2010-06-21 12:34:29 +00001781 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
danielk1977ae72d982007-10-03 08:46:44 +00001782
drhde3c3012010-06-21 20:19:25 +00001783 /* If the operating system support deletion of open files, then
1784 ** close the journal file when dropping the database lock. Otherwise
1785 ** another connection with journal_mode=delete might delete the file
1786 ** out from under us.
danielk1977b3175382008-10-17 18:51:52 +00001787 */
dane08341c2010-06-21 12:34:29 +00001788 assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
1789 assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
1790 assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
1791 assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
1792 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
1793 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
1794 if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
1795 || 1!=(pPager->journalMode & 5)
dan2a321c72010-06-16 19:04:23 +00001796 ){
1797 sqlite3OsClose(pPager->jfd);
1798 }
dan4e004aa2010-08-05 15:30:22 +00001799
dan54919f82010-08-05 18:53:26 +00001800 /* If the pager is in the ERROR state and the call to unlock the database
1801 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
1802 ** above the #define for UNKNOWN_LOCK for an explanation of why this
1803 ** is necessary.
1804 */
dan4e004aa2010-08-05 15:30:22 +00001805 rc = pagerUnlockDb(pPager, NO_LOCK);
1806 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
1807 pPager->eLock = UNKNOWN_LOCK;
1808 }
dan2a321c72010-06-16 19:04:23 +00001809
dande1ae342010-08-06 12:00:27 +00001810 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
dana42c66b2010-08-03 18:18:41 +00001811 ** without clearing the error code. This is intentional - the error
1812 ** code is cleared and the cache reset in the block below.
danielk1977b3175382008-10-17 18:51:52 +00001813 */
dana42c66b2010-08-03 18:18:41 +00001814 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
danielk197745d68822009-01-16 16:23:38 +00001815 pPager->changeCountDone = 0;
dande1ae342010-08-06 12:00:27 +00001816 pPager->eState = PAGER_OPEN;
dana42c66b2010-08-03 18:18:41 +00001817 }
1818
1819 /* If Pager.errCode is set, the contents of the pager cache cannot be
1820 ** trusted. Now that there are no outstanding references to the pager,
dande1ae342010-08-06 12:00:27 +00001821 ** it can safely move back to PAGER_OPEN state. This happens in both
dana42c66b2010-08-03 18:18:41 +00001822 ** normal and exclusive-locking mode.
1823 */
dan67330a12016-04-11 18:07:47 +00001824 assert( pPager->errCode==SQLITE_OK || !MEMDB );
dan22b328b2010-08-11 18:56:45 +00001825 if( pPager->errCode ){
dan6572c162016-04-23 14:55:28 +00001826 if( pPager->tempFile==0 ){
1827 pager_reset(pPager);
1828 pPager->changeCountDone = 0;
1829 pPager->eState = PAGER_OPEN;
1830 }else{
1831 pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
1832 }
dan789efdb2013-07-06 17:57:39 +00001833 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
dan6572c162016-04-23 14:55:28 +00001834 pPager->errCode = SQLITE_OK;
danielk1977ae72d982007-10-03 08:46:44 +00001835 }
dan4e004aa2010-08-05 15:30:22 +00001836
1837 pPager->journalOff = 0;
1838 pPager->journalHdr = 0;
1839 pPager->setMaster = 0;
danielk1977ae72d982007-10-03 08:46:44 +00001840}
1841
1842/*
dande5fd222010-08-09 19:17:29 +00001843** This function is called whenever an IOERR or FULL error that requires
1844** the pager to transition into the ERROR state may ahve occurred.
1845** The first argument is a pointer to the pager structure, the second
1846** the error-code about to be returned by a pager API function. The
1847** value returned is a copy of the second argument to this function.
danielk1977bea2a942009-01-20 17:06:27 +00001848**
dande5fd222010-08-09 19:17:29 +00001849** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
1850** IOERR sub-codes, the pager enters the ERROR state and the error code
1851** is stored in Pager.errCode. While the pager remains in the ERROR state,
1852** all major API calls on the Pager will immediately return Pager.errCode.
danielk1977bea2a942009-01-20 17:06:27 +00001853**
dande5fd222010-08-09 19:17:29 +00001854** The ERROR state indicates that the contents of the pager-cache
danielk1977bea2a942009-01-20 17:06:27 +00001855** cannot be trusted. This state can be cleared by completely discarding
1856** the contents of the pager-cache. If a transaction was active when
shanebe217792009-03-05 04:20:31 +00001857** the persistent error occurred, then the rollback journal may need
danielk1977bea2a942009-01-20 17:06:27 +00001858** to be replayed to restore the contents of the database file (as if
1859** it were a hot-journal).
1860*/
1861static int pager_error(Pager *pPager, int rc){
1862 int rc2 = rc & 0xff;
danielk1977c7ca8752009-07-25 17:39:13 +00001863 assert( rc==SQLITE_OK || !MEMDB );
danielk1977bea2a942009-01-20 17:06:27 +00001864 assert(
1865 pPager->errCode==SQLITE_FULL ||
1866 pPager->errCode==SQLITE_OK ||
1867 (pPager->errCode & 0xff)==SQLITE_IOERR
1868 );
drhb75d5702009-07-25 17:08:35 +00001869 if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){
danielk1977bea2a942009-01-20 17:06:27 +00001870 pPager->errCode = rc;
dana42c66b2010-08-03 18:18:41 +00001871 pPager->eState = PAGER_ERROR;
danielk1977bea2a942009-01-20 17:06:27 +00001872 }
1873 return rc;
1874}
1875
danbc1a3c62013-02-23 16:40:46 +00001876static int pager_truncate(Pager *pPager, Pgno nPage);
1877
danielk1977bea2a942009-01-20 17:06:27 +00001878/*
drh4bf7d212016-05-13 12:12:38 +00001879** The write transaction open on pPager is being committed (bCommit==1)
1880** or rolled back (bCommit==0).
dan0f524552016-04-13 16:52:11 +00001881**
drh4bf7d212016-05-13 12:12:38 +00001882** Return TRUE if and only if all dirty pages should be flushed to disk.
dan0f524552016-04-13 16:52:11 +00001883**
drh4bf7d212016-05-13 12:12:38 +00001884** Rules:
dan0f524552016-04-13 16:52:11 +00001885**
drh4bf7d212016-05-13 12:12:38 +00001886** * For non-TEMP databases, always sync to disk. This is necessary
1887** for transactions to be durable.
1888**
1889** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing
1890** file has been created already (via a spill on pagerStress()) and
1891** when the number of dirty pages in memory exceeds 25% of the total
1892** cache size.
dan0f524552016-04-13 16:52:11 +00001893*/
drh4bf7d212016-05-13 12:12:38 +00001894static int pagerFlushOnCommit(Pager *pPager, int bCommit){
dan0f524552016-04-13 16:52:11 +00001895 if( pPager->tempFile==0 ) return 1;
drh4bf7d212016-05-13 12:12:38 +00001896 if( !bCommit ) return 0;
dan0f524552016-04-13 16:52:11 +00001897 if( !isOpen(pPager->fd) ) return 0;
1898 return (sqlite3PCachePercentDirty(pPager->pPCache)>=25);
1899}
1900
1901/*
danielk1977bea2a942009-01-20 17:06:27 +00001902** This routine ends a transaction. A transaction is usually ended by
1903** either a COMMIT or a ROLLBACK operation. This routine may be called
1904** after rollback of a hot-journal, or if an error occurs while opening
1905** the journal file or writing the very first journal-header of a
1906** database transaction.
1907**
dan85d14ed2010-08-06 17:18:00 +00001908** This routine is never called in PAGER_ERROR state. If it is called
1909** in PAGER_NONE or PAGER_SHARED state and the lock held is less
1910** exclusive than a RESERVED lock, it is a no-op.
drh80e35f42007-03-30 14:06:34 +00001911**
danielk1977bea2a942009-01-20 17:06:27 +00001912** Otherwise, any active savepoints are released.
drh80e35f42007-03-30 14:06:34 +00001913**
danielk1977bea2a942009-01-20 17:06:27 +00001914** If the journal file is open, then it is "finalized". Once a journal
1915** file has been finalized it is not possible to use it to roll back a
1916** transaction. Nor will it be considered to be a hot-journal by this
1917** or any other database connection. Exactly how a journal is finalized
1918** depends on whether or not the pager is running in exclusive mode and
1919** the current journal-mode (Pager.journalMode value), as follows:
drh50457892003-09-06 01:10:47 +00001920**
danielk1977bea2a942009-01-20 17:06:27 +00001921** journalMode==MEMORY
1922** Journal file descriptor is simply closed. This destroys an
1923** in-memory journal.
1924**
1925** journalMode==TRUNCATE
1926** Journal file is truncated to zero bytes in size.
1927**
1928** journalMode==PERSIST
1929** The first 28 bytes of the journal file are zeroed. This invalidates
1930** the first journal header in the file, and hence the entire journal
1931** file. An invalid journal file cannot be rolled back.
1932**
1933** journalMode==DELETE
1934** The journal file is closed and deleted using sqlite3OsDelete().
1935**
1936** If the pager is running in exclusive mode, this method of finalizing
1937** the journal file is never used. Instead, if the journalMode is
1938** DELETE and the pager is in exclusive mode, the method described under
1939** journalMode==PERSIST is used instead.
1940**
dan85d14ed2010-08-06 17:18:00 +00001941** After the journal is finalized, the pager moves to PAGER_READER state.
1942** If running in non-exclusive rollback mode, the lock on the file is
1943** downgraded to a SHARED_LOCK.
danielk1977bea2a942009-01-20 17:06:27 +00001944**
1945** SQLITE_OK is returned if no error occurs. If an error occurs during
1946** any of the IO operations to finalize the journal file or unlock the
1947** database then the IO error code is returned to the user. If the
1948** operation to finalize the journal file fails, then the code still
1949** tries to unlock the database file if not in exclusive mode. If the
1950** unlock operation fails as well, then the first error code related
1951** to the first error encountered (the journal finalization one) is
1952** returned.
drhed7c8552001-04-11 14:29:21 +00001953*/
danbc1a3c62013-02-23 16:40:46 +00001954static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){
danielk1977bea2a942009-01-20 17:06:27 +00001955 int rc = SQLITE_OK; /* Error code from journal finalization operation */
1956 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
1957
dan85d14ed2010-08-06 17:18:00 +00001958 /* Do nothing if the pager does not have an open write transaction
1959 ** or at least a RESERVED lock. This function may be called when there
1960 ** is no write-transaction active but a RESERVED or greater lock is
1961 ** held under two circumstances:
1962 **
1963 ** 1. After a successful hot-journal rollback, it is called with
1964 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
1965 **
1966 ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
1967 ** lock switches back to locking_mode=normal and then executes a
1968 ** read-transaction, this function is called with eState==PAGER_READER
1969 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
1970 */
dand0864082010-08-02 14:32:52 +00001971 assert( assert_pager_state(pPager) );
dana42c66b2010-08-03 18:18:41 +00001972 assert( pPager->eState!=PAGER_ERROR );
dande1ae342010-08-06 12:00:27 +00001973 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
drha6abd042004-06-09 17:37:22 +00001974 return SQLITE_OK;
1975 }
danielk1977bea2a942009-01-20 17:06:27 +00001976
dand0864082010-08-02 14:32:52 +00001977 releaseAllSavepoints(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00001978 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
1979 if( isOpen(pPager->jfd) ){
drh7ed91f22010-04-29 22:34:07 +00001980 assert( !pagerUseWal(pPager) );
danielk1977bea2a942009-01-20 17:06:27 +00001981
danielk1977bea2a942009-01-20 17:06:27 +00001982 /* Finalize the journal file. */
dan2491de22016-02-27 20:14:55 +00001983 if( sqlite3JournalIsInMemory(pPager->jfd) ){
1984 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
danielk1977b3175382008-10-17 18:51:52 +00001985 sqlite3OsClose(pPager->jfd);
drh9e7ba7c2009-02-04 19:16:23 +00001986 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
drh59813952009-04-20 11:34:26 +00001987 if( pPager->journalOff==0 ){
1988 rc = SQLITE_OK;
1989 }else{
1990 rc = sqlite3OsTruncate(pPager->jfd, 0);
drh442c5cd2014-10-21 21:56:06 +00001991 if( rc==SQLITE_OK && pPager->fullSync ){
1992 /* Make sure the new file size is written into the inode right away.
1993 ** Otherwise the journal might resurrect following a power loss and
1994 ** cause the last transaction to roll back. See
1995 ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
1996 */
1997 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
1998 }
drh59813952009-04-20 11:34:26 +00001999 }
drh04335882008-09-26 21:08:08 +00002000 pPager->journalOff = 0;
dan55437592010-05-11 12:19:26 +00002001 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
2002 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
danielk197793f7af92008-05-09 16:57:50 +00002003 ){
drh65c64202016-05-11 11:04:17 +00002004 rc = zeroJournalHdr(pPager, hasMaster||pPager->tempFile);
danielk197741483462007-03-24 16:45:04 +00002005 pPager->journalOff = 0;
2006 }else{
danielk1977ded6d0f2009-07-27 14:15:44 +00002007 /* This branch may be executed with Pager.journalMode==MEMORY if
2008 ** a hot-journal was just rolled back. In this case the journal
2009 ** file should be closed and deleted. If this connection writes to
dan5f37ed52016-02-29 20:00:13 +00002010 ** the database file, it will do so using an in-memory journal.
dane04dc882010-04-20 18:53:15 +00002011 */
dan5f37ed52016-02-29 20:00:13 +00002012 int bDelete = !pPager->tempFile;
2013 assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
danielk1977ded6d0f2009-07-27 14:15:44 +00002014 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
2015 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
dane04dc882010-04-20 18:53:15 +00002016 || pPager->journalMode==PAGER_JOURNALMODE_WAL
danielk1977ded6d0f2009-07-27 14:15:44 +00002017 );
danielk1977b4b47412007-08-17 15:53:36 +00002018 sqlite3OsClose(pPager->jfd);
dan3de0f182012-12-05 10:01:35 +00002019 if( bDelete ){
drh6841b1c2016-02-03 19:20:15 +00002020 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
danielk19777152de82007-03-29 17:28:14 +00002021 }
danielk197741483462007-03-24 16:45:04 +00002022 }
dan5f848c32010-08-23 18:19:31 +00002023 }
danielk1977bea2a942009-01-20 17:06:27 +00002024
danielk19773c407372005-02-15 02:54:14 +00002025#ifdef SQLITE_CHECK_PAGES
dan5f848c32010-08-23 18:19:31 +00002026 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
2027 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
drhc1378072014-08-25 11:33:41 +00002028 PgHdr *p = sqlite3PagerLookup(pPager, 1);
dan5f848c32010-08-23 18:19:31 +00002029 if( p ){
2030 p->pageHash = 0;
drhda8a3302013-12-13 19:35:21 +00002031 sqlite3PagerUnrefNotNull(p);
dan5f848c32010-08-23 18:19:31 +00002032 }
drhd9b02572001-04-15 00:37:09 +00002033 }
dan5f848c32010-08-23 18:19:31 +00002034#endif
2035
drhe9c2d342010-03-19 16:52:53 +00002036 sqlite3BitvecDestroy(pPager->pInJournal);
2037 pPager->pInJournal = 0;
2038 pPager->nRec = 0;
drha37e0cf2016-05-11 12:47:46 +00002039 if( rc==SQLITE_OK ){
drh4bf7d212016-05-13 12:12:38 +00002040 if( pagerFlushOnCommit(pPager, bCommit) ){
drha37e0cf2016-05-11 12:47:46 +00002041 sqlite3PcacheCleanAll(pPager->pPCache);
2042 }else{
2043 sqlite3PcacheClearWritable(pPager->pPCache);
2044 }
2045 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
dan41113b62016-04-05 21:07:58 +00002046 }
danielk1977979f38e2007-03-27 16:19:51 +00002047
drh7ed91f22010-04-29 22:34:07 +00002048 if( pagerUseWal(pPager) ){
dand0864082010-08-02 14:32:52 +00002049 /* Drop the WAL write-lock, if any. Also, if the connection was in
2050 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
2051 ** lock held on the database file.
2052 */
drh73b64e42010-05-30 19:55:15 +00002053 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
drh0350c7f2010-06-10 01:07:42 +00002054 assert( rc2==SQLITE_OK );
danbc1a3c62013-02-23 16:40:46 +00002055 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
2056 /* This branch is taken when committing a transaction in rollback-journal
2057 ** mode if the database file on disk is larger than the database image.
2058 ** At this point the journal has been finalized and the transaction
2059 ** successfully committed, but the EXCLUSIVE lock is still held on the
2060 ** file. So it is safe to truncate the database file to its minimum
2061 ** required size. */
2062 assert( pPager->eLock==EXCLUSIVE_LOCK );
2063 rc = pager_truncate(pPager, pPager->dbSize);
dan431b0b42010-08-04 19:14:22 +00002064 }
danbc1a3c62013-02-23 16:40:46 +00002065
dan999cd082013-12-09 20:42:03 +00002066 if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){
2067 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
2068 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
2069 }
2070
dan431b0b42010-08-04 19:14:22 +00002071 if( !pPager->exclusiveMode
2072 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
2073 ){
dan4e004aa2010-08-05 15:30:22 +00002074 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
danielk1977104f1fe2009-01-14 17:45:57 +00002075 pPager->changeCountDone = 0;
danielk197741483462007-03-24 16:45:04 +00002076 }
dand0864082010-08-02 14:32:52 +00002077 pPager->eState = PAGER_READER;
danielk197776572402004-06-25 02:38:54 +00002078 pPager->setMaster = 0;
danielk1977979f38e2007-03-27 16:19:51 +00002079
2080 return (rc==SQLITE_OK?rc2:rc);
drhed7c8552001-04-11 14:29:21 +00002081}
2082
drhed7c8552001-04-11 14:29:21 +00002083/*
dand0864082010-08-02 14:32:52 +00002084** Execute a rollback if a transaction is active and unlock the
2085** database file.
2086**
dan85d14ed2010-08-06 17:18:00 +00002087** If the pager has already entered the ERROR state, do not attempt
dand0864082010-08-02 14:32:52 +00002088** the rollback at this time. Instead, pager_unlock() is called. The
2089** call to pager_unlock() will discard all in-memory pages, unlock
dan85d14ed2010-08-06 17:18:00 +00002090** the database file and move the pager back to OPEN state. If this
2091** means that there is a hot-journal left in the file-system, the next
2092** connection to obtain a shared lock on the pager (which may be this one)
2093** will roll it back.
dand0864082010-08-02 14:32:52 +00002094**
dan85d14ed2010-08-06 17:18:00 +00002095** If the pager has not already entered the ERROR state, but an IO or
dand0864082010-08-02 14:32:52 +00002096** malloc error occurs during a rollback, then this will itself cause
dan85d14ed2010-08-06 17:18:00 +00002097** the pager to enter the ERROR state. Which will be cleared by the
dand0864082010-08-02 14:32:52 +00002098** call to pager_unlock(), as described above.
2099*/
2100static void pagerUnlockAndRollback(Pager *pPager){
dande1ae342010-08-06 12:00:27 +00002101 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
dana42c66b2010-08-03 18:18:41 +00002102 assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +00002103 if( pPager->eState>=PAGER_WRITER_LOCKED ){
dand0864082010-08-02 14:32:52 +00002104 sqlite3BeginBenignMalloc();
2105 sqlite3PagerRollback(pPager);
2106 sqlite3EndBenignMalloc();
dan85d14ed2010-08-06 17:18:00 +00002107 }else if( !pPager->exclusiveMode ){
dan11f47a92010-08-06 06:54:47 +00002108 assert( pPager->eState==PAGER_READER );
danbc1a3c62013-02-23 16:40:46 +00002109 pager_end_transaction(pPager, 0, 0);
dand0864082010-08-02 14:32:52 +00002110 }
2111 }
2112 pager_unlock(pPager);
2113}
2114
2115/*
danielk1977bea2a942009-01-20 17:06:27 +00002116** Parameter aData must point to a buffer of pPager->pageSize bytes
2117** of data. Compute and return a checksum based ont the contents of the
2118** page of data and the current value of pPager->cksumInit.
drh34e79ce2004-02-08 06:05:46 +00002119**
danielk1977bea2a942009-01-20 17:06:27 +00002120** This is not a real checksum. It is really just the sum of the
2121** random initial value (pPager->cksumInit) and every 200th byte
2122** of the page data, starting with byte offset (pPager->pageSize%200).
2123** Each byte is interpreted as an 8-bit unsigned integer.
drh726de592004-06-10 23:35:50 +00002124**
danielk1977bea2a942009-01-20 17:06:27 +00002125** Changing the formula used to compute this checksum results in an
2126** incompatible journal file format.
2127**
2128** If journal corruption occurs due to a power failure, the most likely
2129** scenario is that one end or the other of the record will be changed.
2130** It is much less likely that the two ends of the journal record will be
drh726de592004-06-10 23:35:50 +00002131** correct and the middle be corrupt. Thus, this "checksum" scheme,
2132** though fast and simple, catches the mostly likely kind of corruption.
drh968af522003-02-11 14:55:40 +00002133*/
drh74161702006-02-24 02:53:49 +00002134static u32 pager_cksum(Pager *pPager, const u8 *aData){
danielk1977bea2a942009-01-20 17:06:27 +00002135 u32 cksum = pPager->cksumInit; /* Checksum value to return */
2136 int i = pPager->pageSize-200; /* Loop counter */
danielk1977ef317ab2004-06-23 10:43:10 +00002137 while( i>0 ){
2138 cksum += aData[i];
2139 i -= 200;
2140 }
drh968af522003-02-11 14:55:40 +00002141 return cksum;
2142}
2143
2144/*
drh8220da72010-07-05 17:43:32 +00002145** Report the current page size and number of reserved bytes back
2146** to the codec.
2147*/
2148#ifdef SQLITE_HAS_CODEC
2149static void pagerReportSize(Pager *pPager){
2150 if( pPager->xCodecSizeChng ){
2151 pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
2152 (int)pPager->nReserve);
2153 }
2154}
2155#else
2156# define pagerReportSize(X) /* No-op if we do not support a codec */
2157#endif
2158
drh58cb6db2015-09-23 19:17:23 +00002159#ifdef SQLITE_HAS_CODEC
2160/*
2161** Make sure the number of reserved bits is the same in the destination
2162** pager as it is in the source. This comes up when a VACUUM changes the
2163** number of reserved bits to the "optimal" amount.
2164*/
2165void sqlite3PagerAlignReserve(Pager *pDest, Pager *pSrc){
2166 if( pDest->nReserve!=pSrc->nReserve ){
2167 pDest->nReserve = pSrc->nReserve;
2168 pagerReportSize(pDest);
2169 }
2170}
2171#endif
2172
drh8220da72010-07-05 17:43:32 +00002173/*
drhd6e5e092009-01-07 02:03:35 +00002174** Read a single page from either the journal file (if isMainJrnl==1) or
2175** from the sub-journal (if isMainJrnl==0) and playback that page.
danielk1977bea2a942009-01-20 17:06:27 +00002176** The page begins at offset *pOffset into the file. The *pOffset
drhd6e5e092009-01-07 02:03:35 +00002177** value is increased to the start of the next page in the journal.
drh968af522003-02-11 14:55:40 +00002178**
dan85d14ed2010-08-06 17:18:00 +00002179** The main rollback journal uses checksums - the statement journal does
2180** not.
drhd6e5e092009-01-07 02:03:35 +00002181**
danielk1977bea2a942009-01-20 17:06:27 +00002182** If the page number of the page record read from the (sub-)journal file
2183** is greater than the current value of Pager.dbSize, then playback is
2184** skipped and SQLITE_OK is returned.
2185**
drhd6e5e092009-01-07 02:03:35 +00002186** If pDone is not NULL, then it is a record of pages that have already
2187** been played back. If the page at *pOffset has already been played back
2188** (if the corresponding pDone bit is set) then skip the playback.
2189** Make sure the pDone bit corresponding to the *pOffset page is set
2190** prior to returning.
danielk1977bea2a942009-01-20 17:06:27 +00002191**
2192** If the page record is successfully read from the (sub-)journal file
2193** and played back, then SQLITE_OK is returned. If an IO error occurs
2194** while reading the record from the (sub-)journal file or while writing
2195** to the database file, then the IO error code is returned. If data
2196** is successfully read from the (sub-)journal file but appears to be
2197** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
2198** two circumstances:
2199**
2200** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
2201** * If the record is being rolled back from the main journal file
2202** and the checksum field does not match the record content.
2203**
2204** Neither of these two scenarios are possible during a savepoint rollback.
2205**
2206** If this is a savepoint rollback, then memory may have to be dynamically
2207** allocated by this function. If this is the case and an allocation fails,
2208** SQLITE_NOMEM is returned.
drhfa86c412002-02-02 15:01:15 +00002209*/
danielk197762079062007-08-15 17:08:46 +00002210static int pager_playback_one_page(
danielk1977fd7f0452008-12-17 17:30:26 +00002211 Pager *pPager, /* The pager being played back */
drhd6e5e092009-01-07 02:03:35 +00002212 i64 *pOffset, /* Offset of record to playback */
drh91781bd2010-04-10 17:52:57 +00002213 Bitvec *pDone, /* Bitvec of pages already played back */
2214 int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
2215 int isSavepnt /* True for a savepoint rollback */
danielk197762079062007-08-15 17:08:46 +00002216){
drhfa86c412002-02-02 15:01:15 +00002217 int rc;
drhae2b40c2004-06-09 19:03:54 +00002218 PgHdr *pPg; /* An existing page in the cache */
2219 Pgno pgno; /* The page number of a page in journal */
2220 u32 cksum; /* Checksum used for sanity checking */
drhbfcb4ad2009-11-21 01:33:50 +00002221 char *aData; /* Temporary storage for the page */
drhd6e5e092009-01-07 02:03:35 +00002222 sqlite3_file *jfd; /* The file descriptor for the journal file */
drh91781bd2010-04-10 17:52:57 +00002223 int isSynced; /* True if journal page is synced */
drhfa86c412002-02-02 15:01:15 +00002224
drhd6e5e092009-01-07 02:03:35 +00002225 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
2226 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
2227 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
2228 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
drh96362842005-03-20 22:47:56 +00002229
drhbfcb4ad2009-11-21 01:33:50 +00002230 aData = pPager->pTmpSpace;
drhd6e5e092009-01-07 02:03:35 +00002231 assert( aData ); /* Temp storage must have already been allocated */
drh7ed91f22010-04-29 22:34:07 +00002232 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
drhd6e5e092009-01-07 02:03:35 +00002233
dan85d14ed2010-08-06 17:18:00 +00002234 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
2235 ** or savepoint rollback done at the request of the caller) or this is
2236 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
2237 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
2238 ** only reads from the main journal, not the sub-journal.
2239 */
2240 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
2241 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
2242 );
2243 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
2244
danielk1977bea2a942009-01-20 17:06:27 +00002245 /* Read the page number and page data from the journal or sub-journal
2246 ** file. Return an error code to the caller if an IO error occurs.
2247 */
drhd6e5e092009-01-07 02:03:35 +00002248 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
drhd6e5e092009-01-07 02:03:35 +00002249 rc = read32bits(jfd, *pOffset, &pgno);
drh99ee3602003-02-16 19:13:36 +00002250 if( rc!=SQLITE_OK ) return rc;
drhbfcb4ad2009-11-21 01:33:50 +00002251 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
drh99ee3602003-02-16 19:13:36 +00002252 if( rc!=SQLITE_OK ) return rc;
drhd6e5e092009-01-07 02:03:35 +00002253 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
drhfa86c412002-02-02 15:01:15 +00002254
drh968af522003-02-11 14:55:40 +00002255 /* Sanity checking on the page. This is more important that I originally
2256 ** thought. If a power failure occurs while the journal is being written,
2257 ** it could cause invalid data to be written into the journal. We need to
2258 ** detect this invalid data (with high probability) and ignore it.
2259 */
danielk197775edc162004-06-26 01:48:18 +00002260 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
danielk1977bea2a942009-01-20 17:06:27 +00002261 assert( !isSavepnt );
drh968af522003-02-11 14:55:40 +00002262 return SQLITE_DONE;
2263 }
danielk1977fd7f0452008-12-17 17:30:26 +00002264 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
drh968af522003-02-11 14:55:40 +00002265 return SQLITE_OK;
2266 }
drhc13148f2008-08-27 18:03:20 +00002267 if( isMainJrnl ){
drhd6e5e092009-01-07 02:03:35 +00002268 rc = read32bits(jfd, (*pOffset)-4, &cksum);
drh99ee3602003-02-16 19:13:36 +00002269 if( rc ) return rc;
drhbfcb4ad2009-11-21 01:33:50 +00002270 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
drh968af522003-02-11 14:55:40 +00002271 return SQLITE_DONE;
2272 }
2273 }
danielk1977bea2a942009-01-20 17:06:27 +00002274
drhb3475532015-06-29 20:53:18 +00002275 /* If this page has already been played back before during the current
drh8220da72010-07-05 17:43:32 +00002276 ** rollback, then don't bother to play it back again.
2277 */
danielk1977859546c2009-01-22 17:12:39 +00002278 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
danielk1977fd7f0452008-12-17 17:30:26 +00002279 return rc;
2280 }
danielk1977a3f3a5f2004-06-10 04:32:16 +00002281
drh8220da72010-07-05 17:43:32 +00002282 /* When playing back page 1, restore the nReserve setting
2283 */
2284 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
2285 pPager->nReserve = ((u8*)aData)[20];
2286 pagerReportSize(pPager);
2287 }
2288
dande5fd222010-08-09 19:17:29 +00002289 /* If the pager is in CACHEMOD state, then there must be a copy of this
danielk1977a3f3a5f2004-06-10 04:32:16 +00002290 ** page in the pager cache. In this case just update the pager cache,
danielk19770de0bb32004-06-10 05:59:24 +00002291 ** not the database file. The page is left marked dirty in this case.
2292 **
danielk19772df71c72007-05-24 07:22:42 +00002293 ** An exception to the above rule: If the database is in no-sync mode
2294 ** and a page is moved during an incremental vacuum then the page may
danielk1977369f3a02007-05-24 09:41:20 +00002295 ** not be in the pager cache. Later: if a malloc() or IO error occurs
2296 ** during a Movepage() call, then the page may not be in the cache
2297 ** either. So the condition described in the above paragraph is not
2298 ** assert()able.
danielk19772df71c72007-05-24 07:22:42 +00002299 **
dande5fd222010-08-09 19:17:29 +00002300 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
2301 ** pager cache if it exists and the main file. The page is then marked
2302 ** not dirty. Since this code is only executed in PAGER_OPEN state for
2303 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
2304 ** if the pager is in OPEN state.
drh96362842005-03-20 22:47:56 +00002305 **
2306 ** Ticket #1171: The statement journal might contain page content that is
2307 ** different from the page content at the start of the transaction.
2308 ** This occurs when a page is changed prior to the start of a statement
2309 ** then changed again within the statement. When rolling back such a
2310 ** statement we must not write to the original database unless we know
drh5e385312007-06-16 04:42:12 +00002311 ** for certain that original page contents are synced into the main rollback
2312 ** journal. Otherwise, a power loss might leave modified data in the
2313 ** database file without an entry in the rollback journal that can
2314 ** restore the database to its original form. Two conditions must be
2315 ** met before writing to the database files. (1) the database must be
2316 ** locked. (2) we know that the original page content is fully synced
2317 ** in the main journal either because the page is not in cache or else
2318 ** the page is marked as needSync==0.
drh4c02a232008-04-14 23:13:45 +00002319 **
2320 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
2321 ** is possible to fail a statement on a database that does not yet exist.
2322 ** Do not attempt to write if database file has never been opened.
drhfa86c412002-02-02 15:01:15 +00002323 */
drh7ed91f22010-04-29 22:34:07 +00002324 if( pagerUseWal(pPager) ){
dan4cd78b42010-04-26 16:57:10 +00002325 pPg = 0;
2326 }else{
drhc1378072014-08-25 11:33:41 +00002327 pPg = sqlite3PagerLookup(pPager, pgno);
dan4cd78b42010-04-26 16:57:10 +00002328 }
drh86655a12009-03-31 02:54:40 +00002329 assert( pPg || !MEMDB );
dan6572c162016-04-23 14:55:28 +00002330 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
drh30d53702009-01-06 15:58:57 +00002331 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
drhbfcb4ad2009-11-21 01:33:50 +00002332 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
2333 (isMainJrnl?"main-journal":"sub-journal")
drh30d53702009-01-06 15:58:57 +00002334 ));
drh91781bd2010-04-10 17:52:57 +00002335 if( isMainJrnl ){
2336 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
2337 }else{
2338 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
2339 }
drh719e3a72010-08-17 17:25:15 +00002340 if( isOpen(pPager->fd)
2341 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
drh91781bd2010-04-10 17:52:57 +00002342 && isSynced
danielk19778c0a7912008-08-20 14:49:23 +00002343 ){
drh281b21d2008-08-22 12:57:08 +00002344 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
drh05f69dd2010-04-09 15:34:06 +00002345 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
drh7ed91f22010-04-29 22:34:07 +00002346 assert( !pagerUseWal(pPager) );
danf23da962013-03-23 21:00:41 +00002347 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
danielk19773460d192008-12-27 15:23:13 +00002348 if( pgno>pPager->dbFileSize ){
2349 pPager->dbFileSize = pgno;
2350 }
drh0719ee22009-06-18 20:52:47 +00002351 if( pPager->pBackup ){
mistachkinfad30392016-02-13 23:43:46 +00002352 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT);
drhbfcb4ad2009-11-21 01:33:50 +00002353 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
mistachkinfad30392016-02-13 23:43:46 +00002354 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT, aData);
drh0719ee22009-06-18 20:52:47 +00002355 }
danielk1977f2c31ad2009-01-06 13:40:08 +00002356 }else if( !isMainJrnl && pPg==0 ){
2357 /* If this is a rollback of a savepoint and data was not written to
2358 ** the database and the page is not in-memory, there is a potential
2359 ** problem. When the page is next fetched by the b-tree layer, it
2360 ** will be read from the database file, which may or may not be
2361 ** current.
2362 **
2363 ** There are a couple of different ways this can happen. All are quite
danielk1977401b65e2009-01-06 14:34:34 +00002364 ** obscure. When running in synchronous mode, this can only happen
danielk1977f2c31ad2009-01-06 13:40:08 +00002365 ** if the page is on the free-list at the start of the transaction, then
2366 ** populated, then moved using sqlite3PagerMovepage().
2367 **
2368 ** The solution is to add an in-memory page to the cache containing
2369 ** the data just read from the sub-journal. Mark the page as dirty
2370 ** and if the pager requires a journal-sync, then mark the page as
2371 ** requiring a journal-sync before it is written.
2372 */
2373 assert( isSavepnt );
drh40c39412013-08-16 20:42:20 +00002374 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
2375 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
drh9584f582015-11-04 20:22:37 +00002376 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
drh40c39412013-08-16 20:42:20 +00002377 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
2378 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
drh7cf4c7a2010-06-24 14:52:25 +00002379 if( rc!=SQLITE_OK ) return rc;
danielk1977f2c31ad2009-01-06 13:40:08 +00002380 sqlite3PcacheMakeDirty(pPg);
danielk1977a3f3a5f2004-06-10 04:32:16 +00002381 }
drhfa86c412002-02-02 15:01:15 +00002382 if( pPg ){
danielk197728129562005-01-11 10:25:06 +00002383 /* No page should ever be explicitly rolled back that is in use, except
2384 ** for page 1 which is held in use in order to keep the lock on the
2385 ** database active. However such a page may be rolled back as a result
2386 ** of an internal error resulting in an automatic call to
danielk19773b8a05f2007-03-19 17:44:26 +00002387 ** sqlite3PagerRollback().
drhacf4ac92003-12-17 23:57:34 +00002388 */
drhb6f41482004-05-14 01:58:11 +00002389 void *pData;
danielk19778c0a7912008-08-20 14:49:23 +00002390 pData = pPg->pData;
drhbfcb4ad2009-11-21 01:33:50 +00002391 memcpy(pData, (u8*)aData, pPager->pageSize);
drh4775ecd2009-07-24 19:01:19 +00002392 pPager->xReiniter(pPg);
drh42bee5f2016-05-12 12:01:20 +00002393 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
2394 ** that call was dangerous and had no detectable benefit since the cache
2395 ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so
2396 ** has been removed. */
dan5f848c32010-08-23 18:19:31 +00002397 pager_set_pagehash(pPg);
2398
drh86a88112007-04-16 15:02:19 +00002399 /* If this was page 1, then restore the value of Pager.dbFileVers.
2400 ** Do this before any decoding. */
danielk197741483462007-03-24 16:45:04 +00002401 if( pgno==1 ){
drh86a88112007-04-16 15:02:19 +00002402 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
danielk197741483462007-03-24 16:45:04 +00002403 }
drh86a88112007-04-16 15:02:19 +00002404
2405 /* Decode the page just read from disk */
mistachkinfad30392016-02-13 23:43:46 +00002406 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM_BKPT);
danielk19778c0a7912008-08-20 14:49:23 +00002407 sqlite3PcacheRelease(pPg);
drhfa86c412002-02-02 15:01:15 +00002408 }
2409 return rc;
2410}
2411
2412/*
danielk197713adf8a2004-06-03 16:08:41 +00002413** Parameter zMaster is the name of a master journal file. A single journal
2414** file that referred to the master journal file has just been rolled back.
2415** This routine checks if it is possible to delete the master journal file,
2416** and does so if it is.
drh726de592004-06-10 23:35:50 +00002417**
danielk197765839c62007-08-30 08:08:17 +00002418** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
2419** available for use within this function.
2420**
danielk1977bea2a942009-01-20 17:06:27 +00002421** When a master journal file is created, it is populated with the names
2422** of all of its child journals, one after another, formatted as utf-8
2423** encoded text. The end of each child journal file is marked with a
2424** nul-terminator byte (0x00). i.e. the entire contents of a master journal
2425** file for a transaction involving two databases might be:
danielk197765839c62007-08-30 08:08:17 +00002426**
danielk1977bea2a942009-01-20 17:06:27 +00002427** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
2428**
2429** A master journal file may only be deleted once all of its child
2430** journals have been rolled back.
2431**
2432** This function reads the contents of the master-journal file into
2433** memory and loops through each of the child journal names. For
2434** each child journal, it checks if:
2435**
2436** * if the child journal exists, and if so
2437** * if the child journal contains a reference to master journal
2438** file zMaster
2439**
2440** If a child journal can be found that matches both of the criteria
2441** above, this function returns without doing anything. Otherwise, if
2442** no such child journal can be found, file zMaster is deleted from
2443** the file-system using sqlite3OsDelete().
2444**
2445** If an IO error within this function, an error code is returned. This
2446** function allocates memory by calling sqlite3Malloc(). If an allocation
2447** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
2448** occur, SQLITE_OK is returned.
2449**
2450** TODO: This function allocates a single block of memory to load
2451** the entire contents of the master journal file. This could be
2452** a couple of kilobytes or so - potentially larger than the page
2453** size.
danielk197713adf8a2004-06-03 16:08:41 +00002454*/
danielk1977b4b47412007-08-17 15:53:36 +00002455static int pager_delmaster(Pager *pPager, const char *zMaster){
2456 sqlite3_vfs *pVfs = pPager->pVfs;
danielk1977bea2a942009-01-20 17:06:27 +00002457 int rc; /* Return code */
2458 sqlite3_file *pMaster; /* Malloc'd master-journal file descriptor */
2459 sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
danielk197713adf8a2004-06-03 16:08:41 +00002460 char *zMasterJournal = 0; /* Contents of master journal file */
drheb206252004-10-01 02:00:31 +00002461 i64 nMasterJournal; /* Size of master journal file */
drha64febe2010-06-23 15:04:27 +00002462 char *zJournal; /* Pointer to one journal within MJ file */
2463 char *zMasterPtr; /* Space to hold MJ filename from a journal file */
2464 int nMasterPtr; /* Amount of space allocated to zMasterPtr[] */
danielk197713adf8a2004-06-03 16:08:41 +00002465
danielk1977bea2a942009-01-20 17:06:27 +00002466 /* Allocate space for both the pJournal and pMaster file descriptors.
2467 ** If successful, open the master journal file for reading.
danielk197713adf8a2004-06-03 16:08:41 +00002468 */
danielk1977bea2a942009-01-20 17:06:27 +00002469 pMaster = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
danielk1977fee2d252007-08-18 10:59:19 +00002470 pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
danielk1977b4b47412007-08-17 15:53:36 +00002471 if( !pMaster ){
mistachkinfad30392016-02-13 23:43:46 +00002472 rc = SQLITE_NOMEM_BKPT;
danielk1977b4b47412007-08-17 15:53:36 +00002473 }else{
adam2e4491d2011-06-24 20:47:06 +00002474 const int flags =
2475#if SQLITE_ENABLE_DATA_PROTECTION
2476 (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
2477#endif
2478 (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
danielk1977fee2d252007-08-18 10:59:19 +00002479 rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
danielk1977b4b47412007-08-17 15:53:36 +00002480 }
danielk197713adf8a2004-06-03 16:08:41 +00002481 if( rc!=SQLITE_OK ) goto delmaster_out;
danielk1977b4b47412007-08-17 15:53:36 +00002482
drha64febe2010-06-23 15:04:27 +00002483 /* Load the entire master journal file into space obtained from
2484 ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain
2485 ** sufficient space (in zMasterPtr) to hold the names of master
2486 ** journal files extracted from regular rollback-journals.
2487 */
danielk1977b4b47412007-08-17 15:53:36 +00002488 rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
danielk197713adf8a2004-06-03 16:08:41 +00002489 if( rc!=SQLITE_OK ) goto delmaster_out;
drha64febe2010-06-23 15:04:27 +00002490 nMasterPtr = pVfs->mxPathname+1;
drhda4ca9d2014-09-09 17:27:35 +00002491 zMasterJournal = sqlite3Malloc(nMasterJournal + nMasterPtr + 1);
drha64febe2010-06-23 15:04:27 +00002492 if( !zMasterJournal ){
mistachkinfad30392016-02-13 23:43:46 +00002493 rc = SQLITE_NOMEM_BKPT;
drha64febe2010-06-23 15:04:27 +00002494 goto delmaster_out;
2495 }
2496 zMasterPtr = &zMasterJournal[nMasterJournal+1];
2497 rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
2498 if( rc!=SQLITE_OK ) goto delmaster_out;
2499 zMasterJournal[nMasterJournal] = 0;
danielk197713adf8a2004-06-03 16:08:41 +00002500
drha64febe2010-06-23 15:04:27 +00002501 zJournal = zMasterJournal;
2502 while( (zJournal-zMasterJournal)<nMasterJournal ){
2503 int exists;
2504 rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
2505 if( rc!=SQLITE_OK ){
danielk197713adf8a2004-06-03 16:08:41 +00002506 goto delmaster_out;
2507 }
drha64febe2010-06-23 15:04:27 +00002508 if( exists ){
2509 /* One of the journals pointed to by the master journal exists.
2510 ** Open it and check if it points at the master journal. If
2511 ** so, return without deleting the master journal file.
2512 */
2513 int c;
adam2e4491d2011-06-24 20:47:06 +00002514 int flags =
2515#if SQLITE_ENABLE_DATA_PROTECTION
2516 (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
2517#endif
2518 (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
drha64febe2010-06-23 15:04:27 +00002519 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
danielk1977861f7452008-06-05 11:39:11 +00002520 if( rc!=SQLITE_OK ){
drh19db9352008-03-27 22:42:51 +00002521 goto delmaster_out;
2522 }
danielk197713adf8a2004-06-03 16:08:41 +00002523
drha64febe2010-06-23 15:04:27 +00002524 rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
2525 sqlite3OsClose(pJournal);
2526 if( rc!=SQLITE_OK ){
2527 goto delmaster_out;
danielk197713adf8a2004-06-03 16:08:41 +00002528 }
drha64febe2010-06-23 15:04:27 +00002529
2530 c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
2531 if( c ){
2532 /* We have a match. Do not delete the master journal file. */
2533 goto delmaster_out;
2534 }
danielk197713adf8a2004-06-03 16:08:41 +00002535 }
drha64febe2010-06-23 15:04:27 +00002536 zJournal += (sqlite3Strlen30(zJournal)+1);
danielk197713adf8a2004-06-03 16:08:41 +00002537 }
drhde3c3012010-06-21 20:19:25 +00002538
2539 sqlite3OsClose(pMaster);
danielk1977fee2d252007-08-18 10:59:19 +00002540 rc = sqlite3OsDelete(pVfs, zMaster, 0);
danielk197713adf8a2004-06-03 16:08:41 +00002541
2542delmaster_out:
drha64febe2010-06-23 15:04:27 +00002543 sqlite3_free(zMasterJournal);
danielk1977bea2a942009-01-20 17:06:27 +00002544 if( pMaster ){
danielk1977b4b47412007-08-17 15:53:36 +00002545 sqlite3OsClose(pMaster);
danielk1977bea2a942009-01-20 17:06:27 +00002546 assert( !isOpen(pJournal) );
drhde3c3012010-06-21 20:19:25 +00002547 sqlite3_free(pMaster);
danielk197713adf8a2004-06-03 16:08:41 +00002548 }
2549 return rc;
2550}
2551
drha6abd042004-06-09 17:37:22 +00002552
drha6abd042004-06-09 17:37:22 +00002553/*
danielk1977bea2a942009-01-20 17:06:27 +00002554** This function is used to change the actual size of the database
2555** file in the file-system. This only happens when committing a transaction,
2556** or rolling back a transaction (including rolling back a hot-journal).
drh7fe3f7e2007-11-29 18:44:27 +00002557**
dande5fd222010-08-09 19:17:29 +00002558** If the main database file is not open, or the pager is not in either
2559** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
2560** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
2561** If the file on disk is currently larger than nPage pages, then use the VFS
danielk1977bea2a942009-01-20 17:06:27 +00002562** xTruncate() method to truncate it.
2563**
peter.d.reid60ec9142014-09-06 16:39:46 +00002564** Or, it might be the case that the file on disk is smaller than
danielk1977bea2a942009-01-20 17:06:27 +00002565** nPage pages. Some operating system implementations can get confused if
2566** you try to truncate a file to some size that is larger than it
2567** currently is, so detect this case and write a single zero byte to
2568** the end of the new file instead.
2569**
2570** If successful, return SQLITE_OK. If an IO error occurs while modifying
2571** the database file, return the error code to the caller.
drhcb4c40b2004-08-18 19:09:43 +00002572*/
danielk1977d92db532008-11-17 04:56:24 +00002573static int pager_truncate(Pager *pPager, Pgno nPage){
danielk1977e180dd92007-04-05 17:15:52 +00002574 int rc = SQLITE_OK;
dana42c66b2010-08-03 18:18:41 +00002575 assert( pPager->eState!=PAGER_ERROR );
dan4e004aa2010-08-05 15:30:22 +00002576 assert( pPager->eState!=PAGER_READER );
2577
2578 if( isOpen(pPager->fd)
dande1ae342010-08-06 12:00:27 +00002579 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
dan4e004aa2010-08-05 15:30:22 +00002580 ){
drh7fe3f7e2007-11-29 18:44:27 +00002581 i64 currentSize, newSize;
drhbd1334d2011-01-28 15:46:14 +00002582 int szPage = pPager->pageSize;
dande5fd222010-08-09 19:17:29 +00002583 assert( pPager->eLock==EXCLUSIVE_LOCK );
danielk1977bea2a942009-01-20 17:06:27 +00002584 /* TODO: Is it safe to use Pager.dbFileSize here? */
drh7fe3f7e2007-11-29 18:44:27 +00002585 rc = sqlite3OsFileSize(pPager->fd, &currentSize);
drhbd1334d2011-01-28 15:46:14 +00002586 newSize = szPage*(i64)nPage;
danielk197706e11af2008-05-06 18:13:26 +00002587 if( rc==SQLITE_OK && currentSize!=newSize ){
2588 if( currentSize>newSize ){
2589 rc = sqlite3OsTruncate(pPager->fd, newSize);
drh935de7e2012-01-11 15:47:42 +00002590 }else if( (currentSize+szPage)<=newSize ){
danfb3828c2011-01-28 15:07:55 +00002591 char *pTmp = pPager->pTmpSpace;
drhbd1334d2011-01-28 15:46:14 +00002592 memset(pTmp, 0, szPage);
drhbd1334d2011-01-28 15:46:14 +00002593 testcase( (newSize-szPage) == currentSize );
2594 testcase( (newSize-szPage) > currentSize );
2595 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
danielk197706e11af2008-05-06 18:13:26 +00002596 }
danielk19773460d192008-12-27 15:23:13 +00002597 if( rc==SQLITE_OK ){
2598 pPager->dbFileSize = nPage;
2599 }
drh7fe3f7e2007-11-29 18:44:27 +00002600 }
danielk1977e180dd92007-04-05 17:15:52 +00002601 }
danielk1977e180dd92007-04-05 17:15:52 +00002602 return rc;
drhcb4c40b2004-08-18 19:09:43 +00002603}
2604
2605/*
danc9a53262012-10-01 06:50:55 +00002606** Return a sanitized version of the sector-size of OS file pFile. The
2607** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
2608*/
2609int sqlite3SectorSize(sqlite3_file *pFile){
2610 int iRet = sqlite3OsSectorSize(pFile);
2611 if( iRet<32 ){
2612 iRet = 512;
2613 }else if( iRet>MAX_SECTOR_SIZE ){
2614 assert( MAX_SECTOR_SIZE>=512 );
2615 iRet = MAX_SECTOR_SIZE;
2616 }
2617 return iRet;
2618}
2619
2620/*
danielk1977bea2a942009-01-20 17:06:27 +00002621** Set the value of the Pager.sectorSize variable for the given
2622** pager based on the value returned by the xSectorSize method
peter.d.reid60ec9142014-09-06 16:39:46 +00002623** of the open database file. The sector size will be used
danielk1977bea2a942009-01-20 17:06:27 +00002624** to determine the size and alignment of journal header and
2625** master journal pointers within created journal files.
drhc80f0582007-05-01 16:59:48 +00002626**
danielk1977bea2a942009-01-20 17:06:27 +00002627** For temporary files the effective sector size is always 512 bytes.
2628**
2629** Otherwise, for non-temporary files, the effective sector size is
drh3c99d682009-11-11 13:17:08 +00002630** the value returned by the xSectorSize() method rounded up to 32 if
2631** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
danielk1977bea2a942009-01-20 17:06:27 +00002632** is greater than MAX_SECTOR_SIZE.
drh8bbaa892011-12-17 19:49:02 +00002633**
drhcb15f352011-12-23 01:04:17 +00002634** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
2635** the effective sector size to its minimum value (512). The purpose of
drh8bbaa892011-12-17 19:49:02 +00002636** pPager->sectorSize is to define the "blast radius" of bytes that
2637** might change if a crash occurs while writing to a single byte in
drhcb15f352011-12-23 01:04:17 +00002638** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
2639** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
2640** size. For backwards compatibility of the rollback journal file format,
2641** we cannot reduce the effective sector size below 512.
drhc80f0582007-05-01 16:59:48 +00002642*/
2643static void setSectorSize(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00002644 assert( isOpen(pPager->fd) || pPager->tempFile );
2645
drh374f4a02011-12-17 20:02:11 +00002646 if( pPager->tempFile
drhcb15f352011-12-23 01:04:17 +00002647 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
2648 SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0
drh8bbaa892011-12-17 19:49:02 +00002649 ){
danielk19777a2b1ee2007-08-21 14:27:01 +00002650 /* Sector size doesn't matter for temporary files. Also, the file
danielk1977bea2a942009-01-20 17:06:27 +00002651 ** may not have been opened yet, in which case the OsSectorSize()
drh374f4a02011-12-17 20:02:11 +00002652 ** call will segfault. */
drhae2a3482009-11-11 23:58:06 +00002653 pPager->sectorSize = 512;
drh374f4a02011-12-17 20:02:11 +00002654 }else{
danc9a53262012-10-01 06:50:55 +00002655 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
danielk19777cbd5892009-01-10 16:15:09 +00002656 }
drhc80f0582007-05-01 16:59:48 +00002657}
2658
2659/*
drhed7c8552001-04-11 14:29:21 +00002660** Playback the journal and thus restore the database file to
2661** the state it was in before we started making changes.
2662**
drh34e79ce2004-02-08 06:05:46 +00002663** The journal file format is as follows:
2664**
drhae2b40c2004-06-09 19:03:54 +00002665** (1) 8 byte prefix. A copy of aJournalMagic[].
2666** (2) 4 byte big-endian integer which is the number of valid page records
drh34e79ce2004-02-08 06:05:46 +00002667** in the journal. If this value is 0xffffffff, then compute the
drhae2b40c2004-06-09 19:03:54 +00002668** number of page records from the journal size.
2669** (3) 4 byte big-endian integer which is the initial value for the
2670** sanity checksum.
2671** (4) 4 byte integer which is the number of pages to truncate the
drh34e79ce2004-02-08 06:05:46 +00002672** database to during a rollback.
drh334c80d2008-03-28 17:41:13 +00002673** (5) 4 byte big-endian integer which is the sector size. The header
2674** is this many bytes in size.
drhe7ae4e22009-11-02 15:51:52 +00002675** (6) 4 byte big-endian integer which is the page size.
2676** (7) zero padding out to the next sector size.
2677** (8) Zero or more pages instances, each as follows:
drh34e79ce2004-02-08 06:05:46 +00002678** + 4 byte page number.
drhae2b40c2004-06-09 19:03:54 +00002679** + pPager->pageSize bytes of data.
2680** + 4 byte checksum
drh34e79ce2004-02-08 06:05:46 +00002681**
drhe7ae4e22009-11-02 15:51:52 +00002682** When we speak of the journal header, we mean the first 7 items above.
2683** Each entry in the journal is an instance of the 8th item.
drh34e79ce2004-02-08 06:05:46 +00002684**
2685** Call the value from the second bullet "nRec". nRec is the number of
2686** valid page entries in the journal. In most cases, you can compute the
2687** value of nRec from the size of the journal file. But if a power
2688** failure occurred while the journal was being written, it could be the
2689** case that the size of the journal file had already been increased but
2690** the extra entries had not yet made it safely to disk. In such a case,
2691** the value of nRec computed from the file size would be too large. For
2692** that reason, we always use the nRec value in the header.
2693**
2694** If the nRec value is 0xffffffff it means that nRec should be computed
2695** from the file size. This value is used when the user selects the
2696** no-sync option for the journal. A power failure could lead to corruption
2697** in this case. But for things like temporary table (which will be
2698** deleted when the power is restored) we don't care.
2699**
drhd9b02572001-04-15 00:37:09 +00002700** If the file opened as the journal file is not a well-formed
danielk1977ece80f12004-06-23 01:05:26 +00002701** journal file then all pages up to the first corrupted page are rolled
2702** back (or no pages if the journal header is corrupted). The journal file
2703** is then deleted and SQLITE_OK returned, just as if no corruption had
2704** been encountered.
2705**
2706** If an I/O or malloc() error occurs, the journal-file is not deleted
2707** and an error code is returned.
drhd3a5c502009-02-03 22:51:06 +00002708**
2709** The isHot parameter indicates that we are trying to rollback a journal
2710** that might be a hot journal. Or, it could be that the journal is
2711** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
2712** If the journal really is hot, reset the pager cache prior rolling
2713** back any content. If the journal is merely persistent, no reset is
2714** needed.
drhed7c8552001-04-11 14:29:21 +00002715*/
danielk1977e277be02007-03-23 18:12:06 +00002716static int pager_playback(Pager *pPager, int isHot){
danielk1977b4b47412007-08-17 15:53:36 +00002717 sqlite3_vfs *pVfs = pPager->pVfs;
drheb206252004-10-01 02:00:31 +00002718 i64 szJ; /* Size of the journal file in bytes */
danielk1977c3e8f5e2004-06-28 01:16:46 +00002719 u32 nRec; /* Number of Records in the journal */
shane0b8d2762008-07-22 05:18:00 +00002720 u32 u; /* Unsigned loop counter */
drhd9b02572001-04-15 00:37:09 +00002721 Pgno mxPg = 0; /* Size of the original file in pages */
drhae2b40c2004-06-09 19:03:54 +00002722 int rc; /* Result code of a subroutine */
danielk1977861f7452008-06-05 11:39:11 +00002723 int res = 1; /* Value returned by sqlite3OsAccess() */
danielk197713adf8a2004-06-03 16:08:41 +00002724 char *zMaster = 0; /* Name of master journal file if any */
drhd3a5c502009-02-03 22:51:06 +00002725 int needPagerReset; /* True to reset page prior to first page rollback */
drhab755ac2013-04-09 18:36:36 +00002726 int nPlayback = 0; /* Total number of pages restored from journal */
drhed7c8552001-04-11 14:29:21 +00002727
drhc3a64ba2001-11-22 00:01:27 +00002728 /* Figure out how many records are in the journal. Abort early if
2729 ** the journal is empty.
drhed7c8552001-04-11 14:29:21 +00002730 */
dan22b328b2010-08-11 18:56:45 +00002731 assert( isOpen(pPager->jfd) );
drh054889e2005-11-30 03:20:31 +00002732 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
drh719e3a72010-08-17 17:25:15 +00002733 if( rc!=SQLITE_OK ){
drhc3a64ba2001-11-22 00:01:27 +00002734 goto end_playback;
2735 }
drh240c5792004-02-08 00:40:52 +00002736
danielk197776572402004-06-25 02:38:54 +00002737 /* Read the master journal name from the journal, if it is present.
2738 ** If a master journal file name is specified, but the file is not
2739 ** present on disk, then the journal is not hot and does not need to be
2740 ** played back.
danielk1977bea2a942009-01-20 17:06:27 +00002741 **
2742 ** TODO: Technically the following is an error because it assumes that
2743 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2744 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
dan5f37ed52016-02-29 20:00:13 +00002745 ** mxPathname is 512, which is the same as the minimum allowable value
danielk1977bea2a942009-01-20 17:06:27 +00002746 ** for pageSize.
drh240c5792004-02-08 00:40:52 +00002747 */
danielk197765839c62007-08-30 08:08:17 +00002748 zMaster = pPager->pTmpSpace;
2749 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
danielk1977861f7452008-06-05 11:39:11 +00002750 if( rc==SQLITE_OK && zMaster[0] ){
2751 rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
drhc3a64ba2001-11-22 00:01:27 +00002752 }
danielk197765839c62007-08-30 08:08:17 +00002753 zMaster = 0;
danielk1977861f7452008-06-05 11:39:11 +00002754 if( rc!=SQLITE_OK || !res ){
danielk1977ce98bba2008-04-03 10:13:01 +00002755 goto end_playback;
2756 }
2757 pPager->journalOff = 0;
drhd3a5c502009-02-03 22:51:06 +00002758 needPagerReset = isHot;
drhc3a64ba2001-11-22 00:01:27 +00002759
danielk1977bea2a942009-01-20 17:06:27 +00002760 /* This loop terminates either when a readJournalHdr() or
2761 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2762 ** occurs.
2763 */
danielk197776572402004-06-25 02:38:54 +00002764 while( 1 ){
danielk197776572402004-06-25 02:38:54 +00002765 /* Read the next journal header from the journal file. If there are
2766 ** not enough bytes left in the journal file for a complete header, or
drh719e3a72010-08-17 17:25:15 +00002767 ** it is corrupted, then a process must have failed while writing it.
danielk197776572402004-06-25 02:38:54 +00002768 ** This indicates nothing more needs to be rolled back.
2769 */
danielk19776f4c73e2009-06-26 07:12:06 +00002770 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
danielk197776572402004-06-25 02:38:54 +00002771 if( rc!=SQLITE_OK ){
drh968af522003-02-11 14:55:40 +00002772 if( rc==SQLITE_DONE ){
drh968af522003-02-11 14:55:40 +00002773 rc = SQLITE_OK;
2774 }
danielk197776572402004-06-25 02:38:54 +00002775 goto end_playback;
2776 }
2777
2778 /* If nRec is 0xffffffff, then this journal was created by a process
2779 ** working in no-sync mode. This means that the rest of the journal
2780 ** file consists of pages, there are no more journal headers. Compute
2781 ** the value of nRec based on this assumption.
2782 */
2783 if( nRec==0xffffffff ){
2784 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
drh4f21c4a2008-12-10 22:15:00 +00002785 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
danielk197776572402004-06-25 02:38:54 +00002786 }
2787
danielk1977e277be02007-03-23 18:12:06 +00002788 /* If nRec is 0 and this rollback is of a transaction created by this
drh8940f4e2007-08-11 00:26:20 +00002789 ** process and if this is the final header in the journal, then it means
2790 ** that this part of the journal was being filled but has not yet been
2791 ** synced to disk. Compute the number of pages based on the remaining
2792 ** size of the file.
2793 **
2794 ** The third term of the test was added to fix ticket #2565.
drhd6e5e092009-01-07 02:03:35 +00002795 ** When rolling back a hot journal, nRec==0 always means that the next
2796 ** chunk of the journal contains zero pages to be rolled back. But
2797 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2798 ** the journal, it means that the journal might contain additional
2799 ** pages that need to be rolled back and that the number of pages
drhee03d622009-01-07 15:33:45 +00002800 ** should be computed based on the journal file size.
danielk1977e277be02007-03-23 18:12:06 +00002801 */
drh8940f4e2007-08-11 00:26:20 +00002802 if( nRec==0 && !isHot &&
2803 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
drh4f21c4a2008-12-10 22:15:00 +00002804 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
danielk1977e277be02007-03-23 18:12:06 +00002805 }
2806
danielk197776572402004-06-25 02:38:54 +00002807 /* If this is the first header read from the journal, truncate the
drh85b623f2007-12-13 21:54:09 +00002808 ** database file back to its original size.
danielk197776572402004-06-25 02:38:54 +00002809 */
danielk1977e180dd92007-04-05 17:15:52 +00002810 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
drhcb4c40b2004-08-18 19:09:43 +00002811 rc = pager_truncate(pPager, mxPg);
danielk197776572402004-06-25 02:38:54 +00002812 if( rc!=SQLITE_OK ){
2813 goto end_playback;
2814 }
danielk1977f90b7262009-01-07 15:18:20 +00002815 pPager->dbSize = mxPg;
danielk197776572402004-06-25 02:38:54 +00002816 }
2817
danielk1977bea2a942009-01-20 17:06:27 +00002818 /* Copy original pages out of the journal and back into the
2819 ** database file and/or page cache.
danielk197776572402004-06-25 02:38:54 +00002820 */
shane0b8d2762008-07-22 05:18:00 +00002821 for(u=0; u<nRec; u++){
drhd3a5c502009-02-03 22:51:06 +00002822 if( needPagerReset ){
2823 pager_reset(pPager);
2824 needPagerReset = 0;
2825 }
drh91781bd2010-04-10 17:52:57 +00002826 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
drhab755ac2013-04-09 18:36:36 +00002827 if( rc==SQLITE_OK ){
2828 nPlayback++;
2829 }else{
danielk197776572402004-06-25 02:38:54 +00002830 if( rc==SQLITE_DONE ){
danielk197776572402004-06-25 02:38:54 +00002831 pPager->journalOff = szJ;
2832 break;
drh8d83c0f2010-04-03 13:08:09 +00002833 }else if( rc==SQLITE_IOERR_SHORT_READ ){
2834 /* If the journal has been truncated, simply stop reading and
2835 ** processing the journal. This might happen if the journal was
2836 ** not completely written and synced prior to a crash. In that
2837 ** case, the database should have never been written in the
2838 ** first place so it is OK to simply abandon the rollback. */
2839 rc = SQLITE_OK;
2840 goto end_playback;
danielk197776572402004-06-25 02:38:54 +00002841 }else{
drh66fd2162009-04-11 16:27:49 +00002842 /* If we are unable to rollback, quit and return the error
2843 ** code. This will cause the pager to enter the error state
2844 ** so that no further harm will be done. Perhaps the next
2845 ** process to come along will be able to rollback the database.
drha9625ea2008-09-03 00:08:29 +00002846 */
danielk197776572402004-06-25 02:38:54 +00002847 goto end_playback;
2848 }
2849 }
drh968af522003-02-11 14:55:40 +00002850 }
drhed7c8552001-04-11 14:29:21 +00002851 }
drh580eeaf2006-02-24 03:09:37 +00002852 /*NOTREACHED*/
2853 assert( 0 );
drh4a0681e2003-02-13 01:58:20 +00002854
2855end_playback:
drh8f941bc2009-01-14 23:03:40 +00002856 /* Following a rollback, the database file should be back in its original
2857 ** state prior to the start of the transaction, so invoke the
2858 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
2859 ** assertion that the transaction counter was modified.
2860 */
drhc02372c2012-01-10 17:59:59 +00002861#ifdef SQLITE_DEBUG
2862 if( pPager->fd->pMethods ){
2863 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
2864 }
2865#endif
drh8f941bc2009-01-14 23:03:40 +00002866
danielk1977db340392009-01-16 16:40:14 +00002867 /* If this playback is happening automatically as a result of an IO or
shanebe217792009-03-05 04:20:31 +00002868 ** malloc error that occurred after the change-counter was updated but
danielk1977db340392009-01-16 16:40:14 +00002869 ** before the transaction was committed, then the change-counter
2870 ** modification may just have been reverted. If this happens in exclusive
2871 ** mode, then subsequent transactions performed by the connection will not
2872 ** update the change-counter at all. This may lead to cache inconsistency
2873 ** problems for other processes at some point in the future. So, just
2874 ** in case this has happened, clear the changeCountDone flag now.
2875 */
danielk1977bea2a942009-01-20 17:06:27 +00002876 pPager->changeCountDone = pPager->tempFile;
danielk1977db340392009-01-16 16:40:14 +00002877
danielk19778191bff2004-06-28 04:52:30 +00002878 if( rc==SQLITE_OK ){
danielk197765839c62007-08-30 08:08:17 +00002879 zMaster = pPager->pTmpSpace;
2880 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
danielk1977bea2a942009-01-20 17:06:27 +00002881 testcase( rc!=SQLITE_OK );
danielk197765839c62007-08-30 08:08:17 +00002882 }
dan354bfe02011-01-11 17:39:37 +00002883 if( rc==SQLITE_OK
dan7e684232010-08-10 15:46:06 +00002884 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
2885 ){
dan999cd082013-12-09 20:42:03 +00002886 rc = sqlite3PagerSync(pPager, 0);
dan7c246102010-04-12 19:00:29 +00002887 }
danielk197765839c62007-08-30 08:08:17 +00002888 if( rc==SQLITE_OK ){
danbc1a3c62013-02-23 16:40:46 +00002889 rc = pager_end_transaction(pPager, zMaster[0]!='\0', 0);
danielk1977bea2a942009-01-20 17:06:27 +00002890 testcase( rc!=SQLITE_OK );
danielk19778191bff2004-06-28 04:52:30 +00002891 }
danielk1977c56774e2008-10-07 11:51:20 +00002892 if( rc==SQLITE_OK && zMaster[0] && res ){
danielk1977979f38e2007-03-27 16:19:51 +00002893 /* If there was a master journal and this routine will return success,
danielk197732554c12005-01-22 03:39:39 +00002894 ** see if it is possible to delete the master journal.
danielk197713adf8a2004-06-03 16:08:41 +00002895 */
danielk197765839c62007-08-30 08:08:17 +00002896 rc = pager_delmaster(pPager, zMaster);
danielk1977bea2a942009-01-20 17:06:27 +00002897 testcase( rc!=SQLITE_OK );
danielk197713adf8a2004-06-03 16:08:41 +00002898 }
drhab755ac2013-04-09 18:36:36 +00002899 if( isHot && nPlayback ){
drhd040e762013-04-10 23:48:37 +00002900 sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s",
drhab755ac2013-04-09 18:36:36 +00002901 nPlayback, pPager->zJournal);
2902 }
danielk197776572402004-06-25 02:38:54 +00002903
2904 /* The Pager.sectorSize variable may have been updated while rolling
drh3ceeb752007-03-29 18:19:52 +00002905 ** back a journal created by a process with a different sector size
danielk197776572402004-06-25 02:38:54 +00002906 ** value. Reset it to the correct value for this process.
2907 */
drhc80f0582007-05-01 16:59:48 +00002908 setSectorSize(pPager);
drhd9b02572001-04-15 00:37:09 +00002909 return rc;
drhed7c8552001-04-11 14:29:21 +00002910}
2911
dan7c246102010-04-12 19:00:29 +00002912
2913/*
2914** Read the content for page pPg out of the database file and into
2915** pPg->pData. A shared lock or greater must be held on the database
2916** file before this function is called.
2917**
2918** If page 1 is read, then the value of Pager.dbFileVers[] is set to
2919** the value read from the database file.
2920**
2921** If an IO error occurs, then the IO error is returned to the caller.
2922** Otherwise, SQLITE_OK is returned.
2923*/
dan99bd1092013-03-22 18:20:14 +00002924static int readDbPage(PgHdr *pPg, u32 iFrame){
dan7c246102010-04-12 19:00:29 +00002925 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
2926 Pgno pgno = pPg->pgno; /* Page number to read */
drh622194c2010-04-13 15:30:53 +00002927 int rc = SQLITE_OK; /* Return code */
danb6e099a2010-05-04 14:47:39 +00002928 int pgsz = pPager->pageSize; /* Number of bytes to read */
dan7c246102010-04-12 19:00:29 +00002929
dand0864082010-08-02 14:32:52 +00002930 assert( pPager->eState>=PAGER_READER && !MEMDB );
dan7c246102010-04-12 19:00:29 +00002931 assert( isOpen(pPager->fd) );
2932
dan32c12fe2013-05-02 17:37:31 +00002933#ifndef SQLITE_OMIT_WAL
dan99bd1092013-03-22 18:20:14 +00002934 if( iFrame ){
dan7c246102010-04-12 19:00:29 +00002935 /* Try to pull the page from the write-ahead log. */
dan99bd1092013-03-22 18:20:14 +00002936 rc = sqlite3WalReadFrame(pPager->pWal, iFrame, pgsz, pPg->pData);
dan32c12fe2013-05-02 17:37:31 +00002937 }else
2938#endif
2939 {
danb6e099a2010-05-04 14:47:39 +00002940 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
2941 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
dan7c246102010-04-12 19:00:29 +00002942 if( rc==SQLITE_IOERR_SHORT_READ ){
2943 rc = SQLITE_OK;
2944 }
2945 }
2946
2947 if( pgno==1 ){
2948 if( rc ){
2949 /* If the read is unsuccessful, set the dbFileVers[] to something
2950 ** that will never be a valid file version. dbFileVers[] is a copy
2951 ** of bytes 24..39 of the database. Bytes 28..31 should always be
drhb28e59b2010-06-17 02:13:39 +00002952 ** zero or the size of the database in page. Bytes 32..35 and 35..39
2953 ** should be page numbers which are never 0xffffffff. So filling
2954 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
dan7c246102010-04-12 19:00:29 +00002955 **
2956 ** For an encrypted database, the situation is more complex: bytes
2957 ** 24..39 of the database are white noise. But the probability of
drh113762a2014-11-19 16:36:25 +00002958 ** white noise equaling 16 bytes of 0xff is vanishingly small so
dan7c246102010-04-12 19:00:29 +00002959 ** we should still be ok.
2960 */
2961 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
2962 }else{
2963 u8 *dbFileVers = &((u8*)pPg->pData)[24];
2964 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
2965 }
2966 }
mistachkinfad30392016-02-13 23:43:46 +00002967 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM_BKPT);
dan7c246102010-04-12 19:00:29 +00002968
2969 PAGER_INCR(sqlite3_pager_readdb_count);
2970 PAGER_INCR(pPager->nRead);
2971 IOTRACE(("PGIN %p %d\n", pPager, pgno));
2972 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
2973 PAGERID(pPager), pgno, pager_pagehash(pPg)));
2974
2975 return rc;
2976}
2977
dan6d311fb2011-02-01 18:00:43 +00002978/*
2979** Update the value of the change-counter at offsets 24 and 92 in
2980** the header and the sqlite version number at offset 96.
2981**
2982** This is an unconditional update. See also the pager_incr_changecounter()
2983** routine which only updates the change-counter if the update is actually
2984** needed, as determined by the pPager->changeCountDone state variable.
2985*/
2986static void pager_write_changecounter(PgHdr *pPg){
2987 u32 change_counter;
2988
2989 /* Increment the value just read and write it back to byte 24. */
2990 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
2991 put32bits(((char*)pPg->pData)+24, change_counter);
2992
2993 /* Also store the SQLite version number in bytes 96..99 and in
2994 ** bytes 92..95 store the change counter for which the version number
2995 ** is valid. */
2996 put32bits(((char*)pPg->pData)+92, change_counter);
2997 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
2998}
2999
dan5cf53532010-05-01 16:40:20 +00003000#ifndef SQLITE_OMIT_WAL
dan3306c4a2010-04-23 19:15:00 +00003001/*
dan74d6cd82010-04-24 18:44:05 +00003002** This function is invoked once for each page that has already been
3003** written into the log file when a WAL transaction is rolled back.
3004** Parameter iPg is the page number of said page. The pCtx argument
3005** is actually a pointer to the Pager structure.
dan3306c4a2010-04-23 19:15:00 +00003006**
dan74d6cd82010-04-24 18:44:05 +00003007** If page iPg is present in the cache, and has no outstanding references,
3008** it is discarded. Otherwise, if there are one or more outstanding
3009** references, the page content is reloaded from the database. If the
3010** attempt to reload content from the database is required and fails,
3011** return an SQLite error code. Otherwise, SQLITE_OK.
3012*/
3013static int pagerUndoCallback(void *pCtx, Pgno iPg){
3014 int rc = SQLITE_OK;
3015 Pager *pPager = (Pager *)pCtx;
3016 PgHdr *pPg;
3017
drh092d9932013-04-02 00:41:18 +00003018 assert( pagerUseWal(pPager) );
dan74d6cd82010-04-24 18:44:05 +00003019 pPg = sqlite3PagerLookup(pPager, iPg);
3020 if( pPg ){
3021 if( sqlite3PcachePageRefcount(pPg)==1 ){
3022 sqlite3PcacheDrop(pPg);
3023 }else{
dan99bd1092013-03-22 18:20:14 +00003024 u32 iFrame = 0;
drh092d9932013-04-02 00:41:18 +00003025 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
dan99bd1092013-03-22 18:20:14 +00003026 if( rc==SQLITE_OK ){
3027 rc = readDbPage(pPg, iFrame);
3028 }
dan74d6cd82010-04-24 18:44:05 +00003029 if( rc==SQLITE_OK ){
3030 pPager->xReiniter(pPg);
3031 }
drhda8a3302013-12-13 19:35:21 +00003032 sqlite3PagerUnrefNotNull(pPg);
dan74d6cd82010-04-24 18:44:05 +00003033 }
3034 }
3035
dan4c97b532010-04-30 09:52:17 +00003036 /* Normally, if a transaction is rolled back, any backup processes are
3037 ** updated as data is copied out of the rollback journal and into the
3038 ** database. This is not generally possible with a WAL database, as
3039 ** rollback involves simply truncating the log file. Therefore, if one
3040 ** or more frames have already been written to the log (and therefore
3041 ** also copied into the backup databases) as part of this transaction,
3042 ** the backups must be restarted.
3043 */
3044 sqlite3BackupRestart(pPager->pBackup);
3045
dan74d6cd82010-04-24 18:44:05 +00003046 return rc;
3047}
3048
3049/*
3050** This function is called to rollback a transaction on a WAL database.
dan3306c4a2010-04-23 19:15:00 +00003051*/
drh7ed91f22010-04-29 22:34:07 +00003052static int pagerRollbackWal(Pager *pPager){
dan74d6cd82010-04-24 18:44:05 +00003053 int rc; /* Return Code */
3054 PgHdr *pList; /* List of dirty pages to revert */
dan3306c4a2010-04-23 19:15:00 +00003055
dan74d6cd82010-04-24 18:44:05 +00003056 /* For all pages in the cache that are currently dirty or have already
3057 ** been written (but not committed) to the log file, do one of the
3058 ** following:
3059 **
3060 ** + Discard the cached page (if refcount==0), or
3061 ** + Reload page content from the database (if refcount>0).
3062 */
dan7c246102010-04-12 19:00:29 +00003063 pPager->dbSize = pPager->dbOrigSize;
drh7ed91f22010-04-29 22:34:07 +00003064 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
dan74d6cd82010-04-24 18:44:05 +00003065 pList = sqlite3PcacheDirtyList(pPager->pPCache);
dan7c246102010-04-12 19:00:29 +00003066 while( pList && rc==SQLITE_OK ){
3067 PgHdr *pNext = pList->pDirty;
dan74d6cd82010-04-24 18:44:05 +00003068 rc = pagerUndoCallback((void *)pPager, pList->pgno);
dan7c246102010-04-12 19:00:29 +00003069 pList = pNext;
3070 }
dan74d6cd82010-04-24 18:44:05 +00003071
dan7c246102010-04-12 19:00:29 +00003072 return rc;
3073}
3074
drhed7c8552001-04-11 14:29:21 +00003075/*
dan5cf53532010-05-01 16:40:20 +00003076** This function is a wrapper around sqlite3WalFrames(). As well as logging
3077** the contents of the list of pages headed by pList (connected by pDirty),
3078** this function notifies any active backup processes that the pages have
3079** changed.
drh104a7bb2011-01-15 17:12:59 +00003080**
3081** The list of pages passed into this routine is always sorted by page number.
3082** Hence, if page 1 appears anywhere on the list, it will be the first page.
dan5cf53532010-05-01 16:40:20 +00003083*/
3084static int pagerWalFrames(
3085 Pager *pPager, /* Pager object */
3086 PgHdr *pList, /* List of frames to log */
3087 Pgno nTruncate, /* Database size after this commit */
drh4eb02a42011-12-16 21:26:26 +00003088 int isCommit /* True if this is a commit */
dan5cf53532010-05-01 16:40:20 +00003089){
3090 int rc; /* Return code */
drh9ad3ee42012-03-24 20:06:14 +00003091 int nList; /* Number of pages in pList */
drh104a7bb2011-01-15 17:12:59 +00003092 PgHdr *p; /* For looping over pages */
dan5cf53532010-05-01 16:40:20 +00003093
3094 assert( pPager->pWal );
drhb07028f2011-10-14 21:49:18 +00003095 assert( pList );
drh104a7bb2011-01-15 17:12:59 +00003096#ifdef SQLITE_DEBUG
3097 /* Verify that the page list is in accending order */
3098 for(p=pList; p && p->pDirty; p=p->pDirty){
3099 assert( p->pgno < p->pDirty->pgno );
3100 }
3101#endif
3102
drh9ad3ee42012-03-24 20:06:14 +00003103 assert( pList->pDirty==0 || isCommit );
dance8e5ff2011-04-05 16:09:08 +00003104 if( isCommit ){
3105 /* If a WAL transaction is being committed, there is no point in writing
3106 ** any pages with page numbers greater than nTruncate into the WAL file.
3107 ** They will never be read by any client. So remove them from the pDirty
3108 ** list here. */
dance8e5ff2011-04-05 16:09:08 +00003109 PgHdr **ppNext = &pList;
drh9ad3ee42012-03-24 20:06:14 +00003110 nList = 0;
drha4c58602012-04-27 16:38:11 +00003111 for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
drh9ad3ee42012-03-24 20:06:14 +00003112 if( p->pgno<=nTruncate ){
3113 ppNext = &p->pDirty;
3114 nList++;
3115 }
dance8e5ff2011-04-05 16:09:08 +00003116 }
3117 assert( pList );
drh9ad3ee42012-03-24 20:06:14 +00003118 }else{
3119 nList = 1;
dance8e5ff2011-04-05 16:09:08 +00003120 }
drh9ad3ee42012-03-24 20:06:14 +00003121 pPager->aStat[PAGER_STAT_WRITE] += nList;
dance8e5ff2011-04-05 16:09:08 +00003122
drh54a73472011-01-15 18:11:12 +00003123 if( pList->pgno==1 ) pager_write_changecounter(pList);
dan5cf53532010-05-01 16:40:20 +00003124 rc = sqlite3WalFrames(pPager->pWal,
drh4eb02a42011-12-16 21:26:26 +00003125 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
dan5cf53532010-05-01 16:40:20 +00003126 );
3127 if( rc==SQLITE_OK && pPager->pBackup ){
dan5cf53532010-05-01 16:40:20 +00003128 for(p=pList; p; p=p->pDirty){
3129 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
3130 }
3131 }
dan5f848c32010-08-23 18:19:31 +00003132
3133#ifdef SQLITE_CHECK_PAGES
dance8e5ff2011-04-05 16:09:08 +00003134 pList = sqlite3PcacheDirtyList(pPager->pPCache);
drh104a7bb2011-01-15 17:12:59 +00003135 for(p=pList; p; p=p->pDirty){
3136 pager_set_pagehash(p);
dan5f848c32010-08-23 18:19:31 +00003137 }
3138#endif
3139
dan5cf53532010-05-01 16:40:20 +00003140 return rc;
3141}
3142
3143/*
drh73b64e42010-05-30 19:55:15 +00003144** Begin a read transaction on the WAL.
3145**
3146** This routine used to be called "pagerOpenSnapshot()" because it essentially
3147** makes a snapshot of the database at the current point in time and preserves
3148** that snapshot for use by the reader in spite of concurrently changes by
3149** other writers or checkpointers.
dan5cf53532010-05-01 16:40:20 +00003150*/
drh73b64e42010-05-30 19:55:15 +00003151static int pagerBeginReadTransaction(Pager *pPager){
dan5cf53532010-05-01 16:40:20 +00003152 int rc; /* Return code */
3153 int changed = 0; /* True if cache must be reset */
3154
3155 assert( pagerUseWal(pPager) );
dande1ae342010-08-06 12:00:27 +00003156 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
dan5cf53532010-05-01 16:40:20 +00003157
drh61e4ace2010-05-31 20:28:37 +00003158 /* sqlite3WalEndReadTransaction() was not called for the previous
3159 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
3160 ** are in locking_mode=NORMAL and EndRead() was previously called,
3161 ** the duplicate call is harmless.
3162 */
3163 sqlite3WalEndReadTransaction(pPager->pWal);
3164
drh73b64e42010-05-30 19:55:15 +00003165 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
drh92683f52010-09-18 19:36:40 +00003166 if( rc!=SQLITE_OK || changed ){
dan763afe62010-08-03 06:42:39 +00003167 pager_reset(pPager);
drh188d4882013-04-08 20:47:49 +00003168 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
dan5cf53532010-05-01 16:40:20 +00003169 }
dan5cf53532010-05-01 16:40:20 +00003170
3171 return rc;
3172}
shaneh9091f772010-08-24 18:35:12 +00003173#endif
dan5cf53532010-05-01 16:40:20 +00003174
dan763afe62010-08-03 06:42:39 +00003175/*
dan85d14ed2010-08-06 17:18:00 +00003176** This function is called as part of the transition from PAGER_OPEN
3177** to PAGER_READER state to determine the size of the database file
3178** in pages (assuming the page size currently stored in Pager.pageSize).
3179**
3180** If no error occurs, SQLITE_OK is returned and the size of the database
3181** in pages is stored in *pnPage. Otherwise, an error code (perhaps
3182** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
dan763afe62010-08-03 06:42:39 +00003183*/
3184static int pagerPagecount(Pager *pPager, Pgno *pnPage){
3185 Pgno nPage; /* Value to return via *pnPage */
3186
dan85d14ed2010-08-06 17:18:00 +00003187 /* Query the WAL sub-system for the database size. The WalDbsize()
3188 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
3189 ** if the database size is not available. The database size is not
3190 ** available from the WAL sub-system if the log file is empty or
3191 ** contains no valid committed transactions.
3192 */
dande1ae342010-08-06 12:00:27 +00003193 assert( pPager->eState==PAGER_OPEN );
drh33f111d2012-01-17 15:29:14 +00003194 assert( pPager->eLock>=SHARED_LOCK );
drh835f22d2016-04-25 19:20:56 +00003195 assert( isOpen(pPager->fd) );
3196 assert( pPager->tempFile==0 );
dan763afe62010-08-03 06:42:39 +00003197 nPage = sqlite3WalDbsize(pPager->pWal);
dan85d14ed2010-08-06 17:18:00 +00003198
drhaf80a1c2015-05-25 10:29:52 +00003199 /* If the number of pages in the database is not available from the
3200 ** WAL sub-system, determine the page counte based on the size of
3201 ** the database file. If the size of the database file is not an
3202 ** integer multiple of the page-size, round up the result.
dan85d14ed2010-08-06 17:18:00 +00003203 */
drh835f22d2016-04-25 19:20:56 +00003204 if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
dan763afe62010-08-03 06:42:39 +00003205 i64 n = 0; /* Size of db file in bytes */
drh835f22d2016-04-25 19:20:56 +00003206 int rc = sqlite3OsFileSize(pPager->fd, &n);
3207 if( rc!=SQLITE_OK ){
3208 return rc;
dan763afe62010-08-03 06:42:39 +00003209 }
drh935de7e2012-01-11 15:47:42 +00003210 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
dan763afe62010-08-03 06:42:39 +00003211 }
dan937ac9d2010-08-03 12:48:45 +00003212
dan85d14ed2010-08-06 17:18:00 +00003213 /* If the current number of pages in the file is greater than the
dan937ac9d2010-08-03 12:48:45 +00003214 ** configured maximum pager number, increase the allowed limit so
3215 ** that the file can be read.
3216 */
3217 if( nPage>pPager->mxPgno ){
3218 pPager->mxPgno = (Pgno)nPage;
3219 }
3220
dan763afe62010-08-03 06:42:39 +00003221 *pnPage = nPage;
3222 return SQLITE_OK;
3223}
3224
shaneh9091f772010-08-24 18:35:12 +00003225#ifndef SQLITE_OMIT_WAL
dan5cf53532010-05-01 16:40:20 +00003226/*
dan5cf53532010-05-01 16:40:20 +00003227** Check if the *-wal file that corresponds to the database opened by pPager
drh32f29642010-07-01 19:45:34 +00003228** exists if the database is not empy, or verify that the *-wal file does
3229** not exist (by deleting it) if the database file is empty.
3230**
3231** If the database is not empty and the *-wal file exists, open the pager
3232** in WAL mode. If the database is empty or if no *-wal file exists and
3233** if no error occurs, make sure Pager.journalMode is not set to
3234** PAGER_JOURNALMODE_WAL.
3235**
3236** Return SQLITE_OK or an error code.
dan5cf53532010-05-01 16:40:20 +00003237**
dan5cf53532010-05-01 16:40:20 +00003238** The caller must hold a SHARED lock on the database file to call this
3239** function. Because an EXCLUSIVE lock on the db file is required to delete
drh32f29642010-07-01 19:45:34 +00003240** a WAL on a none-empty database, this ensures there is no race condition
3241** between the xAccess() below and an xDelete() being executed by some
3242** other connection.
dan5cf53532010-05-01 16:40:20 +00003243*/
3244static int pagerOpenWalIfPresent(Pager *pPager){
3245 int rc = SQLITE_OK;
dan85d14ed2010-08-06 17:18:00 +00003246 assert( pPager->eState==PAGER_OPEN );
drh33f111d2012-01-17 15:29:14 +00003247 assert( pPager->eLock>=SHARED_LOCK );
dan85d14ed2010-08-06 17:18:00 +00003248
dan5cf53532010-05-01 16:40:20 +00003249 if( !pPager->tempFile ){
3250 int isWal; /* True if WAL file exists */
dan763afe62010-08-03 06:42:39 +00003251 Pgno nPage; /* Size of the database file */
dand0864082010-08-02 14:32:52 +00003252
dan763afe62010-08-03 06:42:39 +00003253 rc = pagerPagecount(pPager, &nPage);
drh32f29642010-07-01 19:45:34 +00003254 if( rc ) return rc;
3255 if( nPage==0 ){
dandb10f082010-07-05 19:13:26 +00003256 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
dan9fc5b4a2012-11-09 20:17:26 +00003257 if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
drh32f29642010-07-01 19:45:34 +00003258 isWal = 0;
3259 }else{
dandb10f082010-07-05 19:13:26 +00003260 rc = sqlite3OsAccess(
3261 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
3262 );
drh32f29642010-07-01 19:45:34 +00003263 }
dan5cf53532010-05-01 16:40:20 +00003264 if( rc==SQLITE_OK ){
3265 if( isWal ){
dan4e004aa2010-08-05 15:30:22 +00003266 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
dan5cf53532010-05-01 16:40:20 +00003267 rc = sqlite3PagerOpenWal(pPager, 0);
dan5cf53532010-05-01 16:40:20 +00003268 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
3269 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
3270 }
3271 }
3272 }
3273 return rc;
3274}
3275#endif
3276
3277/*
danielk1977bea2a942009-01-20 17:06:27 +00003278** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
3279** the entire master journal file. The case pSavepoint==NULL occurs when
3280** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
3281** savepoint.
drhd6e5e092009-01-07 02:03:35 +00003282**
danielk1977bea2a942009-01-20 17:06:27 +00003283** When pSavepoint is not NULL (meaning a non-transaction savepoint is
3284** being rolled back), then the rollback consists of up to three stages,
3285** performed in the order specified:
3286**
3287** * Pages are played back from the main journal starting at byte
3288** offset PagerSavepoint.iOffset and continuing to
3289** PagerSavepoint.iHdrOffset, or to the end of the main journal
3290** file if PagerSavepoint.iHdrOffset is zero.
3291**
3292** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
3293** back starting from the journal header immediately following
3294** PagerSavepoint.iHdrOffset to the end of the main journal file.
3295**
3296** * Pages are then played back from the sub-journal file, starting
3297** with the PagerSavepoint.iSubRec and continuing to the end of
3298** the journal file.
3299**
3300** Throughout the rollback process, each time a page is rolled back, the
3301** corresponding bit is set in a bitvec structure (variable pDone in the
3302** implementation below). This is used to ensure that a page is only
3303** rolled back the first time it is encountered in either journal.
3304**
3305** If pSavepoint is NULL, then pages are only played back from the main
3306** journal file. There is no need for a bitvec in this case.
3307**
3308** In either case, before playback commences the Pager.dbSize variable
3309** is reset to the value that it held at the start of the savepoint
3310** (or transaction). No page with a page-number greater than this value
3311** is played back. If one is encountered it is simply skipped.
drhfa86c412002-02-02 15:01:15 +00003312*/
danielk1977fd7f0452008-12-17 17:30:26 +00003313static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
drhd6e5e092009-01-07 02:03:35 +00003314 i64 szJ; /* Effective size of the main journal */
danielk1977fd7f0452008-12-17 17:30:26 +00003315 i64 iHdrOff; /* End of first segment of main-journal records */
danielk1977f2c31ad2009-01-06 13:40:08 +00003316 int rc = SQLITE_OK; /* Return code */
danielk1977fd7f0452008-12-17 17:30:26 +00003317 Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
drhfa86c412002-02-02 15:01:15 +00003318
dana42c66b2010-08-03 18:18:41 +00003319 assert( pPager->eState!=PAGER_ERROR );
dande1ae342010-08-06 12:00:27 +00003320 assert( pPager->eState>=PAGER_WRITER_LOCKED );
danielk1977bea2a942009-01-20 17:06:27 +00003321
danielk1977fd7f0452008-12-17 17:30:26 +00003322 /* Allocate a bitvec to use to store the set of pages rolled back */
3323 if( pSavepoint ){
3324 pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
3325 if( !pDone ){
mistachkinfad30392016-02-13 23:43:46 +00003326 return SQLITE_NOMEM_BKPT;
danielk1977fd7f0452008-12-17 17:30:26 +00003327 }
danielk197776572402004-06-25 02:38:54 +00003328 }
danielk1977fd7f0452008-12-17 17:30:26 +00003329
danielk1977bea2a942009-01-20 17:06:27 +00003330 /* Set the database size back to the value it was before the savepoint
3331 ** being reverted was opened.
drhfa86c412002-02-02 15:01:15 +00003332 */
drhd6e5e092009-01-07 02:03:35 +00003333 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
danab7e8d82010-07-07 17:53:51 +00003334 pPager->changeCountDone = pPager->tempFile;
drhfa86c412002-02-02 15:01:15 +00003335
drh7ed91f22010-04-29 22:34:07 +00003336 if( !pSavepoint && pagerUseWal(pPager) ){
3337 return pagerRollbackWal(pPager);
dan7c246102010-04-12 19:00:29 +00003338 }
3339
drhd6e5e092009-01-07 02:03:35 +00003340 /* Use pPager->journalOff as the effective size of the main rollback
3341 ** journal. The actual file might be larger than this in
3342 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
3343 ** past pPager->journalOff is off-limits to us.
drhfa86c412002-02-02 15:01:15 +00003344 */
danielk1977fd7f0452008-12-17 17:30:26 +00003345 szJ = pPager->journalOff;
drh7ed91f22010-04-29 22:34:07 +00003346 assert( pagerUseWal(pPager)==0 || szJ==0 );
drhd6e5e092009-01-07 02:03:35 +00003347
3348 /* Begin by rolling back records from the main journal starting at
3349 ** PagerSavepoint.iOffset and continuing to the next journal header.
3350 ** There might be records in the main journal that have a page number
3351 ** greater than the current database size (pPager->dbSize) but those
3352 ** will be skipped automatically. Pages are added to pDone as they
3353 ** are played back.
3354 */
drh7ed91f22010-04-29 22:34:07 +00003355 if( pSavepoint && !pagerUseWal(pPager) ){
danielk1977fd7f0452008-12-17 17:30:26 +00003356 iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
3357 pPager->journalOff = pSavepoint->iOffset;
3358 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
drh91781bd2010-04-10 17:52:57 +00003359 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
danielk1977fd7f0452008-12-17 17:30:26 +00003360 }
danielk1977bea2a942009-01-20 17:06:27 +00003361 assert( rc!=SQLITE_DONE );
danielk1977fd7f0452008-12-17 17:30:26 +00003362 }else{
3363 pPager->journalOff = 0;
drhfa86c412002-02-02 15:01:15 +00003364 }
drhd6e5e092009-01-07 02:03:35 +00003365
3366 /* Continue rolling back records out of the main journal starting at
3367 ** the first journal header seen and continuing until the effective end
3368 ** of the main journal file. Continue to skip out-of-range pages and
3369 ** continue adding pages rolled back to pDone.
3370 */
danielk1977fd7f0452008-12-17 17:30:26 +00003371 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
danielk1977bea2a942009-01-20 17:06:27 +00003372 u32 ii; /* Loop counter */
danielk1977c81806f2009-01-01 15:20:37 +00003373 u32 nJRec = 0; /* Number of Journal Records */
danielk197776572402004-06-25 02:38:54 +00003374 u32 dummy;
danielk19776f4c73e2009-06-26 07:12:06 +00003375 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
danielk1977fd7f0452008-12-17 17:30:26 +00003376 assert( rc!=SQLITE_DONE );
drhd6e5e092009-01-07 02:03:35 +00003377
3378 /*
3379 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
3380 ** test is related to ticket #2565. See the discussion in the
3381 ** pager_playback() function for additional information.
3382 */
drhd6e5e092009-01-07 02:03:35 +00003383 if( nJRec==0
3384 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
3385 ){
shaned87897d2009-01-30 05:40:27 +00003386 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
danielk197775edc162004-06-26 01:48:18 +00003387 }
danielk197712dd5492008-12-18 15:45:07 +00003388 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
drh91781bd2010-04-10 17:52:57 +00003389 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
danielk1977fd7f0452008-12-17 17:30:26 +00003390 }
danielk1977bea2a942009-01-20 17:06:27 +00003391 assert( rc!=SQLITE_DONE );
danielk1977fd7f0452008-12-17 17:30:26 +00003392 }
drh39cf5102010-06-21 21:45:37 +00003393 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
danielk1977fd7f0452008-12-17 17:30:26 +00003394
drhd6e5e092009-01-07 02:03:35 +00003395 /* Finally, rollback pages from the sub-journal. Page that were
3396 ** previously rolled back out of the main journal (and are hence in pDone)
3397 ** will be skipped. Out-of-range pages are also skipped.
3398 */
danielk1977fd7f0452008-12-17 17:30:26 +00003399 if( pSavepoint ){
danielk1977bea2a942009-01-20 17:06:27 +00003400 u32 ii; /* Loop counter */
dan7c3210e2011-12-21 18:04:41 +00003401 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
dan4cd78b42010-04-26 16:57:10 +00003402
drh7ed91f22010-04-29 22:34:07 +00003403 if( pagerUseWal(pPager) ){
dan71d89912010-05-24 13:57:42 +00003404 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
dan4cd78b42010-04-26 16:57:10 +00003405 }
danielk1977bea2a942009-01-20 17:06:27 +00003406 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
dan7c3210e2011-12-21 18:04:41 +00003407 assert( offset==(i64)ii*(4+pPager->pageSize) );
drh91781bd2010-04-10 17:52:57 +00003408 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
danielk197776572402004-06-25 02:38:54 +00003409 }
danielk1977bea2a942009-01-20 17:06:27 +00003410 assert( rc!=SQLITE_DONE );
drhfa86c412002-02-02 15:01:15 +00003411 }
danielk197776572402004-06-25 02:38:54 +00003412
danielk1977fd7f0452008-12-17 17:30:26 +00003413 sqlite3BitvecDestroy(pDone);
3414 if( rc==SQLITE_OK ){
danielk197775edc162004-06-26 01:48:18 +00003415 pPager->journalOff = szJ;
drhfa86c412002-02-02 15:01:15 +00003416 }
dan4cd78b42010-04-26 16:57:10 +00003417
drhfa86c412002-02-02 15:01:15 +00003418 return rc;
3419}
3420
3421/*
drh9b0cf342015-11-12 14:57:19 +00003422** Change the maximum number of in-memory pages that are allowed
3423** before attempting to recycle clean and unused pages.
drhf57b14a2001-09-14 18:54:08 +00003424*/
danielk19773b8a05f2007-03-19 17:44:26 +00003425void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
danielk19778c0a7912008-08-20 14:49:23 +00003426 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
drhf57b14a2001-09-14 18:54:08 +00003427}
3428
3429/*
drh9b0cf342015-11-12 14:57:19 +00003430** Change the maximum number of in-memory pages that are allowed
3431** before attempting to spill pages to journal.
3432*/
3433int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){
3434 return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage);
3435}
3436
3437/*
drh9b4c59f2013-04-15 17:03:42 +00003438** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
dan5d8a1372013-03-19 19:28:06 +00003439*/
3440static void pagerFixMaplimit(Pager *pPager){
drh9b4c59f2013-04-15 17:03:42 +00003441#if SQLITE_MAX_MMAP_SIZE>0
danf23da962013-03-23 21:00:41 +00003442 sqlite3_file *fd = pPager->fd;
dan789efdb2013-07-06 17:57:39 +00003443 if( isOpen(fd) && fd->pMethods->iVersion>=3 ){
drh9b4c59f2013-04-15 17:03:42 +00003444 sqlite3_int64 sz;
drh9b4c59f2013-04-15 17:03:42 +00003445 sz = pPager->szMmap;
dan789efdb2013-07-06 17:57:39 +00003446 pPager->bUseFetch = (sz>0);
drh9b4c59f2013-04-15 17:03:42 +00003447 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
dan5d8a1372013-03-19 19:28:06 +00003448 }
drh188d4882013-04-08 20:47:49 +00003449#endif
dan5d8a1372013-03-19 19:28:06 +00003450}
3451
3452/*
3453** Change the maximum size of any memory mapping made of the database file.
3454*/
drh9b4c59f2013-04-15 17:03:42 +00003455void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
3456 pPager->szMmap = szMmap;
dan5d8a1372013-03-19 19:28:06 +00003457 pagerFixMaplimit(pPager);
3458}
3459
3460/*
drh09419b42011-11-16 19:29:17 +00003461** Free as much memory as possible from the pager.
3462*/
3463void sqlite3PagerShrink(Pager *pPager){
3464 sqlite3PcacheShrink(pPager->pPCache);
3465}
3466
3467/*
drh40c39412013-08-16 20:42:20 +00003468** Adjust settings of the pager to those specified in the pgFlags parameter.
3469**
3470** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness
3471** of the database to damage due to OS crashes or power failures by
3472** changing the number of syncs()s when writing the journals.
drh0dba3302016-03-08 13:56:02 +00003473** There are four levels:
drh973b6e32003-02-12 14:09:42 +00003474**
drh054889e2005-11-30 03:20:31 +00003475** OFF sqlite3OsSync() is never called. This is the default
drh973b6e32003-02-12 14:09:42 +00003476** for temporary and transient files.
3477**
3478** NORMAL The journal is synced once before writes begin on the
3479** database. This is normally adequate protection, but
3480** it is theoretically possible, though very unlikely,
3481** that an inopertune power failure could leave the journal
3482** in a state which would cause damage to the database
3483** when it is rolled back.
3484**
3485** FULL The journal is synced twice before writes begin on the
drh34e79ce2004-02-08 06:05:46 +00003486** database (with some additional information - the nRec field
3487** of the journal header - being written in between the two
3488** syncs). If we assume that writing a
drh973b6e32003-02-12 14:09:42 +00003489** single disk sector is atomic, then this mode provides
3490** assurance that the journal will not be corrupted to the
3491** point of causing damage to the database during rollback.
3492**
drh0dba3302016-03-08 13:56:02 +00003493** EXTRA This is like FULL except that is also syncs the directory
3494** that contains the rollback journal after the rollback
3495** journal is unlinked.
3496**
drhc97d8462010-11-19 18:23:35 +00003497** The above is for a rollback-journal mode. For WAL mode, OFF continues
3498** to mean that no syncs ever occur. NORMAL means that the WAL is synced
3499** prior to the start of checkpoint and that the database file is synced
3500** at the conclusion of the checkpoint if the entire content of the WAL
3501** was written back into the database. But no sync operations occur for
3502** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
3503** file is synced following each commit operation, in addition to the
drh0dba3302016-03-08 13:56:02 +00003504** syncs associated with NORMAL. There is no difference between FULL
3505** and EXTRA for WAL mode.
drhc97d8462010-11-19 18:23:35 +00003506**
3507** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
3508** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
3509** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
3510** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
3511** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
3512** synchronous=FULL versus synchronous=NORMAL setting determines when
3513** the xSync primitive is called and is relevant to all platforms.
3514**
drh973b6e32003-02-12 14:09:42 +00003515** Numeric values associated with these states are OFF==1, NORMAL=2,
3516** and FULL=3.
3517*/
danielk197793758c82005-01-21 08:13:14 +00003518#ifndef SQLITE_OMIT_PAGER_PRAGMAS
drh40c39412013-08-16 20:42:20 +00003519void sqlite3PagerSetFlags(
drhc97d8462010-11-19 18:23:35 +00003520 Pager *pPager, /* The pager to set safety level for */
drh40c39412013-08-16 20:42:20 +00003521 unsigned pgFlags /* Various flags */
drhc97d8462010-11-19 18:23:35 +00003522){
drh40c39412013-08-16 20:42:20 +00003523 unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK;
drh6841b1c2016-02-03 19:20:15 +00003524 if( pPager->tempFile ){
3525 pPager->noSync = 1;
3526 pPager->fullSync = 0;
3527 pPager->extraSync = 0;
3528 }else{
3529 pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0;
3530 pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
3531 pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
3532 }
drhc97d8462010-11-19 18:23:35 +00003533 if( pPager->noSync ){
3534 pPager->syncFlags = 0;
3535 pPager->ckptSyncFlags = 0;
drh40c39412013-08-16 20:42:20 +00003536 }else if( pgFlags & PAGER_FULLFSYNC ){
drhc97d8462010-11-19 18:23:35 +00003537 pPager->syncFlags = SQLITE_SYNC_FULL;
3538 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
drh40c39412013-08-16 20:42:20 +00003539 }else if( pgFlags & PAGER_CKPT_FULLFSYNC ){
drhc97d8462010-11-19 18:23:35 +00003540 pPager->syncFlags = SQLITE_SYNC_NORMAL;
3541 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
3542 }else{
3543 pPager->syncFlags = SQLITE_SYNC_NORMAL;
3544 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
3545 }
drh4eb02a42011-12-16 21:26:26 +00003546 pPager->walSyncFlags = pPager->syncFlags;
3547 if( pPager->fullSync ){
3548 pPager->walSyncFlags |= WAL_SYNC_TRANSACTIONS;
3549 }
drh40c39412013-08-16 20:42:20 +00003550 if( pgFlags & PAGER_CACHESPILL ){
3551 pPager->doNotSpill &= ~SPILLFLAG_OFF;
3552 }else{
3553 pPager->doNotSpill |= SPILLFLAG_OFF;
3554 }
drh973b6e32003-02-12 14:09:42 +00003555}
danielk197793758c82005-01-21 08:13:14 +00003556#endif
drh973b6e32003-02-12 14:09:42 +00003557
3558/*
drhaf6df112005-06-07 02:12:30 +00003559** The following global variable is incremented whenever the library
3560** attempts to open a temporary file. This information is used for
3561** testing and analysis only.
3562*/
drh0f7eb612006-08-08 13:51:43 +00003563#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00003564int sqlite3_opentemp_count = 0;
drh0f7eb612006-08-08 13:51:43 +00003565#endif
drhaf6df112005-06-07 02:12:30 +00003566
3567/*
danielk1977bea2a942009-01-20 17:06:27 +00003568** Open a temporary file.
drh3f56e6e2007-03-15 01:16:47 +00003569**
danielk1977bea2a942009-01-20 17:06:27 +00003570** Write the file descriptor into *pFile. Return SQLITE_OK on success
3571** or some other error code if we fail. The OS will automatically
3572** delete the temporary file when it is closed.
3573**
3574** The flags passed to the VFS layer xOpen() call are those specified
3575** by parameter vfsFlags ORed with the following:
3576**
3577** SQLITE_OPEN_READWRITE
3578** SQLITE_OPEN_CREATE
3579** SQLITE_OPEN_EXCLUSIVE
3580** SQLITE_OPEN_DELETEONCLOSE
drhfa86c412002-02-02 15:01:15 +00003581*/
danielk1977bea2a942009-01-20 17:06:27 +00003582static int pagerOpentemp(
danielk197717b90b52008-06-06 11:11:25 +00003583 Pager *pPager, /* The pager object */
drh33f4e022007-09-03 15:19:34 +00003584 sqlite3_file *pFile, /* Write the file descriptor here */
drh33f4e022007-09-03 15:19:34 +00003585 int vfsFlags /* Flags passed through to the VFS */
danielk1977b4b47412007-08-17 15:53:36 +00003586){
danielk1977bea2a942009-01-20 17:06:27 +00003587 int rc; /* Return code */
drh3f56e6e2007-03-15 01:16:47 +00003588
drh0f7eb612006-08-08 13:51:43 +00003589#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00003590 sqlite3_opentemp_count++; /* Used for testing and analysis only */
drh0f7eb612006-08-08 13:51:43 +00003591#endif
danielk1977b4b47412007-08-17 15:53:36 +00003592
adam2e4491d2011-06-24 20:47:06 +00003593 vfsFlags |=
3594#if SQLITE_ENABLE_DATA_PROTECTION
3595 (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
3596#endif
3597 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
drh33f4e022007-09-03 15:19:34 +00003598 SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
danielk197717b90b52008-06-06 11:11:25 +00003599 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
danielk1977bea2a942009-01-20 17:06:27 +00003600 assert( rc!=SQLITE_OK || isOpen(pFile) );
drhfa86c412002-02-02 15:01:15 +00003601 return rc;
3602}
3603
drhed7c8552001-04-11 14:29:21 +00003604/*
drh90f5ecb2004-07-22 01:19:35 +00003605** Set the busy handler function.
danielk1977bea2a942009-01-20 17:06:27 +00003606**
3607** The pager invokes the busy-handler if sqlite3OsLock() returns
3608** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
3609** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
3610** lock. It does *not* invoke the busy handler when upgrading from
3611** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
3612** (which occurs during hot-journal rollback). Summary:
3613**
3614** Transition | Invokes xBusyHandler
3615** --------------------------------------------------------
3616** NO_LOCK -> SHARED_LOCK | Yes
3617** SHARED_LOCK -> RESERVED_LOCK | No
3618** SHARED_LOCK -> EXCLUSIVE_LOCK | No
3619** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
3620**
3621** If the busy-handler callback returns non-zero, the lock is
3622** retried. If it returns zero, then the SQLITE_BUSY error is
3623** returned to the caller of the pager API function.
drh90f5ecb2004-07-22 01:19:35 +00003624*/
danielk19771ceedd32008-11-19 10:22:33 +00003625void sqlite3PagerSetBusyhandler(
danielk1977bea2a942009-01-20 17:06:27 +00003626 Pager *pPager, /* Pager object */
3627 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
3628 void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
dan80bb6f82012-10-01 18:44:33 +00003629){
danielk19771ceedd32008-11-19 10:22:33 +00003630 pPager->xBusyHandler = xBusyHandler;
3631 pPager->pBusyHandlerArg = pBusyHandlerArg;
dan80bb6f82012-10-01 18:44:33 +00003632
3633 if( isOpen(pPager->fd) ){
mistachkinc197eed2012-10-01 20:12:30 +00003634 void **ap = (void **)&pPager->xBusyHandler;
dan80bb6f82012-10-01 18:44:33 +00003635 assert( ((int(*)(void *))(ap[0]))==xBusyHandler );
3636 assert( ap[1]==pBusyHandlerArg );
dan44c4fcb2012-12-05 11:30:28 +00003637 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
dan80bb6f82012-10-01 18:44:33 +00003638 }
drh90f5ecb2004-07-22 01:19:35 +00003639}
3640
3641/*
danielk1977bea2a942009-01-20 17:06:27 +00003642** Change the page size used by the Pager object. The new page size
3643** is passed in *pPageSize.
3644**
3645** If the pager is in the error state when this function is called, it
3646** is a no-op. The value returned is the error state error code (i.e.
dana81a2202010-08-17 18:15:48 +00003647** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
danielk1977bea2a942009-01-20 17:06:27 +00003648**
3649** Otherwise, if all of the following are true:
3650**
3651** * the new page size (value of *pPageSize) is valid (a power
3652** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
3653**
3654** * there are no outstanding page references, and
3655**
3656** * the database is either not an in-memory database or it is
3657** an in-memory database that currently consists of zero pages.
3658**
3659** then the pager object page size is set to *pPageSize.
3660**
3661** If the page size is changed, then this function uses sqlite3PagerMalloc()
3662** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
3663** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
3664** In all other cases, SQLITE_OK is returned.
3665**
3666** If the page size is not changed, either because one of the enumerated
3667** conditions above is not true, the pager was in error state when this
3668** function was called, or because the memory allocation attempt failed,
3669** then *pPageSize is set to the old, retained page size before returning.
drh90f5ecb2004-07-22 01:19:35 +00003670*/
drhb2eced52010-08-12 02:41:12 +00003671int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
dan1879b082010-08-12 16:36:34 +00003672 int rc = SQLITE_OK;
3673
dana42c66b2010-08-03 18:18:41 +00003674 /* It is not possible to do a full assert_pager_state() here, as this
3675 ** function may be called from within PagerOpen(), before the state
3676 ** of the Pager object is internally consistent.
dan22b328b2010-08-11 18:56:45 +00003677 **
3678 ** At one point this function returned an error if the pager was in
3679 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
3680 ** there is at least one outstanding page reference, this function
3681 ** is a no-op for that case anyhow.
dana42c66b2010-08-03 18:18:41 +00003682 */
dana42c66b2010-08-03 18:18:41 +00003683
drhb2eced52010-08-12 02:41:12 +00003684 u32 pageSize = *pPageSize;
dan22b328b2010-08-11 18:56:45 +00003685 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
3686 if( (pPager->memDb==0 || pPager->dbSize==0)
3687 && sqlite3PcacheRefCount(pPager->pPCache)==0
drh43b18e12010-08-17 19:40:08 +00003688 && pageSize && pageSize!=(u32)pPager->pageSize
dan22b328b2010-08-11 18:56:45 +00003689 ){
shaneh1df2db72010-08-18 02:28:48 +00003690 char *pNew = NULL; /* New temp space */
dan22b328b2010-08-11 18:56:45 +00003691 i64 nByte = 0;
dan1879b082010-08-12 16:36:34 +00003692
dan22b328b2010-08-11 18:56:45 +00003693 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
dan1879b082010-08-12 16:36:34 +00003694 rc = sqlite3OsFileSize(pPager->fd, &nByte);
danielk1977a1644fd2007-08-29 12:31:25 +00003695 }
dan1879b082010-08-12 16:36:34 +00003696 if( rc==SQLITE_OK ){
3697 pNew = (char *)sqlite3PageMalloc(pageSize);
mistachkinfad30392016-02-13 23:43:46 +00003698 if( !pNew ) rc = SQLITE_NOMEM_BKPT;
dan1879b082010-08-12 16:36:34 +00003699 }
3700
3701 if( rc==SQLITE_OK ){
dan22b328b2010-08-11 18:56:45 +00003702 pager_reset(pPager);
drhc3031c62014-08-26 15:06:49 +00003703 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
dan22b328b2010-08-11 18:56:45 +00003704 }
drh60da7272014-09-06 03:38:51 +00003705 if( rc==SQLITE_OK ){
drh6a154402014-10-08 13:34:21 +00003706 sqlite3PageFree(pPager->pTmpSpace);
3707 pPager->pTmpSpace = pNew;
drh60da7272014-09-06 03:38:51 +00003708 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
3709 pPager->pageSize = pageSize;
drh6a154402014-10-08 13:34:21 +00003710 }else{
3711 sqlite3PageFree(pNew);
drh60da7272014-09-06 03:38:51 +00003712 }
drh1c7880e2005-05-20 20:01:55 +00003713 }
dan22b328b2010-08-11 18:56:45 +00003714
drhb2eced52010-08-12 02:41:12 +00003715 *pPageSize = pPager->pageSize;
dan1879b082010-08-12 16:36:34 +00003716 if( rc==SQLITE_OK ){
3717 if( nReserve<0 ) nReserve = pPager->nReserve;
3718 assert( nReserve>=0 && nReserve<1000 );
3719 pPager->nReserve = (i16)nReserve;
3720 pagerReportSize(pPager);
dan5d8a1372013-03-19 19:28:06 +00003721 pagerFixMaplimit(pPager);
dan1879b082010-08-12 16:36:34 +00003722 }
3723 return rc;
drh90f5ecb2004-07-22 01:19:35 +00003724}
3725
3726/*
drh26b79942007-11-28 16:19:56 +00003727** Return a pointer to the "temporary page" buffer held internally
3728** by the pager. This is a buffer that is big enough to hold the
3729** entire content of a database page. This buffer is used internally
3730** during rollback and will be overwritten whenever a rollback
3731** occurs. But other modules are free to use it too, as long as
3732** no rollbacks are happening.
3733*/
3734void *sqlite3PagerTempSpace(Pager *pPager){
3735 return pPager->pTmpSpace;
3736}
3737
3738/*
drhf8e632b2007-05-08 14:51:36 +00003739** Attempt to set the maximum database page count if mxPage is positive.
3740** Make no changes if mxPage is zero or negative. And never reduce the
3741** maximum page count below the current size of the database.
3742**
3743** Regardless of mxPage, return the current maximum page count.
3744*/
3745int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
3746 if( mxPage>0 ){
3747 pPager->mxPgno = mxPage;
3748 }
drhc84e0332010-11-23 20:25:08 +00003749 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
3750 assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
drhf8e632b2007-05-08 14:51:36 +00003751 return pPager->mxPgno;
3752}
3753
3754/*
drhc9ac5ca2005-11-04 22:03:30 +00003755** The following set of routines are used to disable the simulated
3756** I/O error mechanism. These routines are used to avoid simulated
3757** errors in places where we do not care about errors.
3758**
3759** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
3760** and generate no code.
3761*/
3762#ifdef SQLITE_TEST
3763extern int sqlite3_io_error_pending;
3764extern int sqlite3_io_error_hit;
3765static int saved_cnt;
drhc9ac5ca2005-11-04 22:03:30 +00003766void disable_simulated_io_errors(void){
3767 saved_cnt = sqlite3_io_error_pending;
3768 sqlite3_io_error_pending = -1;
3769}
3770void enable_simulated_io_errors(void){
3771 sqlite3_io_error_pending = saved_cnt;
3772}
3773#else
drh152410f2005-11-05 15:11:22 +00003774# define disable_simulated_io_errors()
3775# define enable_simulated_io_errors()
drhc9ac5ca2005-11-04 22:03:30 +00003776#endif
3777
3778/*
drh90f5ecb2004-07-22 01:19:35 +00003779** Read the first N bytes from the beginning of the file into memory
danielk1977aef0bf62005-12-30 16:28:01 +00003780** that pDest points to.
3781**
danielk1977bea2a942009-01-20 17:06:27 +00003782** If the pager was opened on a transient file (zFilename==""), or
3783** opened on a file less than N bytes in size, the output buffer is
3784** zeroed and SQLITE_OK returned. The rationale for this is that this
3785** function is used to read database headers, and a new transient or
3786** zero sized database has a header than consists entirely of zeroes.
3787**
3788** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
3789** the error code is returned to the caller and the contents of the
3790** output buffer undefined.
drh90f5ecb2004-07-22 01:19:35 +00003791*/
danielk19773b8a05f2007-03-19 17:44:26 +00003792int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
drh551b7732006-11-06 21:20:25 +00003793 int rc = SQLITE_OK;
drh90f5ecb2004-07-22 01:19:35 +00003794 memset(pDest, 0, N);
danielk1977bea2a942009-01-20 17:06:27 +00003795 assert( isOpen(pPager->fd) || pPager->tempFile );
danb6e099a2010-05-04 14:47:39 +00003796
drh82043b32010-05-25 02:24:01 +00003797 /* This routine is only called by btree immediately after creating
3798 ** the Pager object. There has not been an opportunity to transition
3799 ** to WAL mode yet.
3800 */
3801 assert( !pagerUseWal(pPager) );
danb6e099a2010-05-04 14:47:39 +00003802
danielk1977bea2a942009-01-20 17:06:27 +00003803 if( isOpen(pPager->fd) ){
drhb0603412007-02-28 04:47:26 +00003804 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
danielk197762079062007-08-15 17:08:46 +00003805 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
drh551b7732006-11-06 21:20:25 +00003806 if( rc==SQLITE_IOERR_SHORT_READ ){
3807 rc = SQLITE_OK;
3808 }
drh90f5ecb2004-07-22 01:19:35 +00003809 }
drh551b7732006-11-06 21:20:25 +00003810 return rc;
drh90f5ecb2004-07-22 01:19:35 +00003811}
3812
3813/*
dan937ac9d2010-08-03 12:48:45 +00003814** This function may only be called when a read-transaction is open on
3815** the pager. It returns the total number of pages in the database.
3816**
danielk1977bea2a942009-01-20 17:06:27 +00003817** However, if the file is between 1 and <page-size> bytes in size, then
3818** this is considered a 1 page file.
drhed7c8552001-04-11 14:29:21 +00003819*/
drh8fb8b532010-08-14 17:12:04 +00003820void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
dan54919f82010-08-05 18:53:26 +00003821 assert( pPager->eState>=PAGER_READER );
dan763afe62010-08-03 06:42:39 +00003822 assert( pPager->eState!=PAGER_WRITER_FINISHED );
dan937ac9d2010-08-03 12:48:45 +00003823 *pnPage = (int)pPager->dbSize;
drhed7c8552001-04-11 14:29:21 +00003824}
3825
drhac69b052004-05-12 13:30:07 +00003826
3827/*
danielk1977bea2a942009-01-20 17:06:27 +00003828** Try to obtain a lock of type locktype on the database file. If
3829** a similar or greater lock is already held, this function is a no-op
3830** (returning SQLITE_OK immediately).
3831**
3832** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
3833** the busy callback if the lock is currently not available. Repeat
3834** until the busy callback returns false or until the attempt to
3835** obtain the lock succeeds.
danielk197717221812005-02-15 03:38:05 +00003836**
3837** Return SQLITE_OK on success and an error code if we cannot obtain
danielk1977bea2a942009-01-20 17:06:27 +00003838** the lock. If the lock is obtained successfully, set the Pager.state
3839** variable to locktype before returning.
danielk197717221812005-02-15 03:38:05 +00003840*/
3841static int pager_wait_on_lock(Pager *pPager, int locktype){
danielk1977bea2a942009-01-20 17:06:27 +00003842 int rc; /* Return code */
drh1aa2d8b2007-01-03 15:34:29 +00003843
danielk1977bea2a942009-01-20 17:06:27 +00003844 /* Check that this is either a no-op (because the requested lock is
peter.d.reid60ec9142014-09-06 16:39:46 +00003845 ** already held), or one of the transitions that the busy-handler
danielk1977bea2a942009-01-20 17:06:27 +00003846 ** may be invoked during, according to the comment above
3847 ** sqlite3PagerSetBusyhandler().
3848 */
dand0864082010-08-02 14:32:52 +00003849 assert( (pPager->eLock>=locktype)
3850 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
3851 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
danielk1977bea2a942009-01-20 17:06:27 +00003852 );
3853
dan4e004aa2010-08-05 15:30:22 +00003854 do {
3855 rc = pagerLockDb(pPager, locktype);
3856 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
danielk197717221812005-02-15 03:38:05 +00003857 return rc;
3858}
3859
danielk19773460d192008-12-27 15:23:13 +00003860/*
danielk19779f0b6be2009-07-25 11:40:07 +00003861** Function assertTruncateConstraint(pPager) checks that one of the
3862** following is true for all dirty pages currently in the page-cache:
3863**
3864** a) The page number is less than or equal to the size of the
3865** current database image, in pages, OR
3866**
3867** b) if the page content were written at this time, it would not
3868** be necessary to write the current content out to the sub-journal
3869** (as determined by function subjRequiresPage()).
3870**
3871** If the condition asserted by this function were not true, and the
3872** dirty page were to be discarded from the cache via the pagerStress()
3873** routine, pagerStress() would not write the current page content to
3874** the database file. If a savepoint transaction were rolled back after
mistachkin48864df2013-03-21 21:20:32 +00003875** this happened, the correct behavior would be to restore the current
danielk19779f0b6be2009-07-25 11:40:07 +00003876** content of the page. However, since this content is not present in either
3877** the database file or the portion of the rollback journal and
3878** sub-journal rolled back the content could not be restored and the
3879** database image would become corrupt. It is therefore fortunate that
3880** this circumstance cannot arise.
3881*/
3882#if defined(SQLITE_DEBUG)
3883static void assertTruncateConstraintCb(PgHdr *pPg){
3884 assert( pPg->flags&PGHDR_DIRTY );
3885 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
3886}
3887static void assertTruncateConstraint(Pager *pPager){
3888 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
3889}
3890#else
3891# define assertTruncateConstraint(pPager)
3892#endif
3893
3894/*
danielk1977f90b7262009-01-07 15:18:20 +00003895** Truncate the in-memory database file image to nPage pages. This
3896** function does not actually modify the database file on disk. It
3897** just sets the internal state of the pager object so that the
3898** truncation will be done when the current transaction is committed.
dane0ac3632013-03-04 16:35:06 +00003899**
3900** This function is only called right before committing a transaction.
3901** Once this function has been called, the transaction must either be
3902** rolled back or committed. It is not safe to call this function and
3903** then continue writing to the database.
danielk19773460d192008-12-27 15:23:13 +00003904*/
3905void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
danielk19773460d192008-12-27 15:23:13 +00003906 assert( pPager->dbSize>=nPage );
dand0864082010-08-02 14:32:52 +00003907 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
danielk19773460d192008-12-27 15:23:13 +00003908 pPager->dbSize = nPage;
dane0ac3632013-03-04 16:35:06 +00003909
3910 /* At one point the code here called assertTruncateConstraint() to
3911 ** ensure that all pages being truncated away by this operation are,
3912 ** if one or more savepoints are open, present in the savepoint
3913 ** journal so that they can be restored if the savepoint is rolled
3914 ** back. This is no longer necessary as this function is now only
3915 ** called right before committing a transaction. So although the
3916 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
3917 ** they cannot be rolled back. So the assertTruncateConstraint() call
3918 ** is no longer correct. */
danielk19773460d192008-12-27 15:23:13 +00003919}
danielk19773460d192008-12-27 15:23:13 +00003920
dan7c246102010-04-12 19:00:29 +00003921
drhf7c57532003-04-25 13:22:51 +00003922/*
daneada58a2010-04-12 17:08:44 +00003923** This function is called before attempting a hot-journal rollback. It
3924** syncs the journal file to disk, then sets pPager->journalHdr to the
3925** size of the journal file so that the pager_playback() routine knows
3926** that the entire journal file has been synced.
3927**
3928** Syncing a hot-journal to disk before attempting to roll it back ensures
3929** that if a power-failure occurs during the rollback, the process that
3930** attempts rollback following system recovery sees the same journal
3931** content as this process.
3932**
3933** If everything goes as planned, SQLITE_OK is returned. Otherwise,
3934** an SQLite error code.
3935*/
3936static int pagerSyncHotJournal(Pager *pPager){
3937 int rc = SQLITE_OK;
3938 if( !pPager->noSync ){
3939 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
3940 }
3941 if( rc==SQLITE_OK ){
3942 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
3943 }
3944 return rc;
3945}
3946
3947/*
dan5d8a1372013-03-19 19:28:06 +00003948** Obtain a reference to a memory mapped page object for page number pgno.
danf23da962013-03-23 21:00:41 +00003949** The new object will use the pointer pData, obtained from xFetch().
3950** If successful, set *ppPage to point to the new page reference
dan5d8a1372013-03-19 19:28:06 +00003951** and return SQLITE_OK. Otherwise, return an SQLite error code and set
3952** *ppPage to zero.
3953**
3954** Page references obtained by calling this function should be released
3955** by calling pagerReleaseMapPage().
3956*/
danf23da962013-03-23 21:00:41 +00003957static int pagerAcquireMapPage(
3958 Pager *pPager, /* Pager object */
3959 Pgno pgno, /* Page number */
3960 void *pData, /* xFetch()'d data for this page */
3961 PgHdr **ppPage /* OUT: Acquired page object */
3962){
dan5d8a1372013-03-19 19:28:06 +00003963 PgHdr *p; /* Memory mapped page to return */
drh542d5582014-12-31 14:18:48 +00003964
drhc86e5132013-03-26 14:36:11 +00003965 if( pPager->pMmapFreelist ){
3966 *ppPage = p = pPager->pMmapFreelist;
3967 pPager->pMmapFreelist = p->pDirty;
dan5d8a1372013-03-19 19:28:06 +00003968 p->pDirty = 0;
3969 memset(p->pExtra, 0, pPager->nExtra);
3970 }else{
3971 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
3972 if( p==0 ){
dandf737fe2013-03-25 17:00:24 +00003973 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
mistachkinfad30392016-02-13 23:43:46 +00003974 return SQLITE_NOMEM_BKPT;
danb2d3de32013-03-14 18:34:37 +00003975 }
dan5d8a1372013-03-19 19:28:06 +00003976 p->pExtra = (void *)&p[1];
3977 p->flags = PGHDR_MMAP;
3978 p->nRef = 1;
3979 p->pPager = pPager;
danb2d3de32013-03-14 18:34:37 +00003980 }
3981
dan5d8a1372013-03-19 19:28:06 +00003982 assert( p->pExtra==(void *)&p[1] );
3983 assert( p->pPage==0 );
3984 assert( p->flags==PGHDR_MMAP );
3985 assert( p->pPager==pPager );
3986 assert( p->nRef==1 );
3987
dan5d8a1372013-03-19 19:28:06 +00003988 p->pgno = pgno;
danf23da962013-03-23 21:00:41 +00003989 p->pData = pData;
dan5d8a1372013-03-19 19:28:06 +00003990 pPager->nMmapOut++;
3991
danb2d3de32013-03-14 18:34:37 +00003992 return SQLITE_OK;
3993}
3994
dan5d8a1372013-03-19 19:28:06 +00003995/*
3996** Release a reference to page pPg. pPg must have been returned by an
3997** earlier call to pagerAcquireMapPage().
3998*/
danb2d3de32013-03-14 18:34:37 +00003999static void pagerReleaseMapPage(PgHdr *pPg){
4000 Pager *pPager = pPg->pPager;
4001 pPager->nMmapOut--;
drhc86e5132013-03-26 14:36:11 +00004002 pPg->pDirty = pPager->pMmapFreelist;
4003 pPager->pMmapFreelist = pPg;
danf23da962013-03-23 21:00:41 +00004004
4005 assert( pPager->fd->pMethods->iVersion>=3 );
dandf737fe2013-03-25 17:00:24 +00004006 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
danb2d3de32013-03-14 18:34:37 +00004007}
4008
dan5d8a1372013-03-19 19:28:06 +00004009/*
drhc86e5132013-03-26 14:36:11 +00004010** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
dan5d8a1372013-03-19 19:28:06 +00004011*/
danb2d3de32013-03-14 18:34:37 +00004012static void pagerFreeMapHdrs(Pager *pPager){
4013 PgHdr *p;
4014 PgHdr *pNext;
drhc86e5132013-03-26 14:36:11 +00004015 for(p=pPager->pMmapFreelist; p; p=pNext){
danb2d3de32013-03-14 18:34:37 +00004016 pNext = p->pDirty;
4017 sqlite3_free(p);
4018 }
4019}
4020
4021
drhed7c8552001-04-11 14:29:21 +00004022/*
4023** Shutdown the page cache. Free all memory and close all files.
4024**
4025** If a transaction was in progress when this routine is called, that
4026** transaction is rolled back. All outstanding pages are invalidated
4027** and their memory is freed. Any attempt to use a page associated
4028** with this page cache after this function returns will likely
4029** result in a coredump.
danielk1977aef0bf62005-12-30 16:28:01 +00004030**
4031** This function always succeeds. If a transaction is active an attempt
4032** is made to roll it back. If an error occurs during the rollback
4033** a hot journal may be left in the filesystem but no error is returned
4034** to the caller.
drhed7c8552001-04-11 14:29:21 +00004035*/
danielk19773b8a05f2007-03-19 17:44:26 +00004036int sqlite3PagerClose(Pager *pPager){
dan7c246102010-04-12 19:00:29 +00004037 u8 *pTmp = (u8 *)pPager->pTmpSpace;
4038
drh2a5d9902011-08-26 00:34:45 +00004039 assert( assert_pager_state(pPager) );
drhbafda092007-01-03 23:36:22 +00004040 disable_simulated_io_errors();
danielk19772d1d86f2008-06-20 14:59:51 +00004041 sqlite3BeginBenignMalloc();
danb2d3de32013-03-14 18:34:37 +00004042 pagerFreeMapHdrs(pPager);
dana42c66b2010-08-03 18:18:41 +00004043 /* pPager->errCode = 0; */
danielk197741483462007-03-24 16:45:04 +00004044 pPager->exclusiveMode = 0;
dan5cf53532010-05-01 16:40:20 +00004045#ifndef SQLITE_OMIT_WAL
drhc97d8462010-11-19 18:23:35 +00004046 sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
drh7ed91f22010-04-29 22:34:07 +00004047 pPager->pWal = 0;
dan5cf53532010-05-01 16:40:20 +00004048#endif
drhbafda092007-01-03 23:36:22 +00004049 pager_reset(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00004050 if( MEMDB ){
4051 pager_unlock(pPager);
4052 }else{
dana42c66b2010-08-03 18:18:41 +00004053 /* If it is open, sync the journal file before calling UnlockAndRollback.
4054 ** If this is not done, then an unsynced portion of the open journal
4055 ** file may be played back into the database. If a power failure occurs
4056 ** while this is happening, the database could become corrupt.
4057 **
4058 ** If an error occurs while trying to sync the journal, shift the pager
4059 ** into the ERROR state. This causes UnlockAndRollback to unlock the
4060 ** database and close the journal file without attempting to roll it
4061 ** back or finalize it. The next database user will have to do hot-journal
4062 ** rollback before accessing the database file.
danielk1977f2c31ad2009-01-06 13:40:08 +00004063 */
daneada58a2010-04-12 17:08:44 +00004064 if( isOpen(pPager->jfd) ){
dana42c66b2010-08-03 18:18:41 +00004065 pager_error(pPager, pagerSyncHotJournal(pPager));
daneada58a2010-04-12 17:08:44 +00004066 }
danielk1977b3175382008-10-17 18:51:52 +00004067 pagerUnlockAndRollback(pPager);
4068 }
danielk197745d68822009-01-16 16:23:38 +00004069 sqlite3EndBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00004070 enable_simulated_io_errors();
drh30d53702009-01-06 15:58:57 +00004071 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
drhb0603412007-02-28 04:47:26 +00004072 IOTRACE(("CLOSE %p\n", pPager))
dane08341c2010-06-21 12:34:29 +00004073 sqlite3OsClose(pPager->jfd);
danielk1977b4b47412007-08-17 15:53:36 +00004074 sqlite3OsClose(pPager->fd);
dan7c246102010-04-12 19:00:29 +00004075 sqlite3PageFree(pTmp);
danielk19778c0a7912008-08-20 14:49:23 +00004076 sqlite3PcacheClose(pPager->pPCache);
danielk1977bea2a942009-01-20 17:06:27 +00004077
drhfa9601a2009-06-18 17:22:39 +00004078#ifdef SQLITE_HAS_CODEC
4079 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
4080#endif
4081
danielk1977bea2a942009-01-20 17:06:27 +00004082 assert( !pPager->aSavepoint && !pPager->pInJournal );
4083 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
4084
drh17435752007-08-16 04:30:38 +00004085 sqlite3_free(pPager);
drhed7c8552001-04-11 14:29:21 +00004086 return SQLITE_OK;
4087}
4088
drh87cc3b32007-05-08 21:45:27 +00004089#if !defined(NDEBUG) || defined(SQLITE_TEST)
drhed7c8552001-04-11 14:29:21 +00004090/*
danielk1977bea2a942009-01-20 17:06:27 +00004091** Return the page number for page pPg.
drhed7c8552001-04-11 14:29:21 +00004092*/
danielk1977bea2a942009-01-20 17:06:27 +00004093Pgno sqlite3PagerPagenumber(DbPage *pPg){
4094 return pPg->pgno;
drhed7c8552001-04-11 14:29:21 +00004095}
drh87cc3b32007-05-08 21:45:27 +00004096#endif
drhed7c8552001-04-11 14:29:21 +00004097
4098/*
danielk1977bea2a942009-01-20 17:06:27 +00004099** Increment the reference count for page pPg.
drhdf0b3b02001-06-23 11:36:20 +00004100*/
danielk1977bea2a942009-01-20 17:06:27 +00004101void sqlite3PagerRef(DbPage *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004102 sqlite3PcacheRef(pPg);
drh7e3b0a02001-04-28 16:52:40 +00004103}
4104
4105/*
danielk1977bea2a942009-01-20 17:06:27 +00004106** Sync the journal. In other words, make sure all the pages that have
drh34e79ce2004-02-08 06:05:46 +00004107** been written to the journal have actually reached the surface of the
danielk1977bea2a942009-01-20 17:06:27 +00004108** disk and can be restored in the event of a hot-journal rollback.
drhb19a2bc2001-09-16 00:13:26 +00004109**
dan937ac9d2010-08-03 12:48:45 +00004110** If the Pager.noSync flag is set, then this function is a no-op.
dan51133ea2010-07-30 15:43:13 +00004111** Otherwise, the actions required depend on the journal-mode and the
mistachkind5578432012-08-25 10:01:29 +00004112** device characteristics of the file-system, as follows:
danielk19774cd2cd52007-08-23 14:48:23 +00004113**
danielk1977bea2a942009-01-20 17:06:27 +00004114** * If the journal file is an in-memory journal file, no action need
4115** be taken.
drhfa86c412002-02-02 15:01:15 +00004116**
danielk1977bea2a942009-01-20 17:06:27 +00004117** * Otherwise, if the device does not support the SAFE_APPEND property,
4118** then the nRec field of the most recently written journal header
4119** is updated to contain the number of journal records that have
4120** been written following it. If the pager is operating in full-sync
4121** mode, then the journal file is synced before this field is updated.
4122**
4123** * If the device does not support the SEQUENTIAL property, then
4124** journal file is synced.
4125**
4126** Or, in pseudo-code:
4127**
4128** if( NOT <in-memory journal> ){
4129** if( NOT SAFE_APPEND ){
4130** if( <full-sync mode> ) xSync(<journal file>);
4131** <update nRec field>
4132** }
4133** if( NOT SEQUENTIAL ) xSync(<journal file>);
4134** }
4135**
danielk1977bea2a942009-01-20 17:06:27 +00004136** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
4137** page currently held in memory before returning SQLITE_OK. If an IO
4138** error is encountered, then the IO error code is returned to the caller.
drh50e5dad2001-09-15 00:57:28 +00004139*/
dan937ac9d2010-08-03 12:48:45 +00004140static int syncJournal(Pager *pPager, int newHdr){
dand0864082010-08-02 14:32:52 +00004141 int rc; /* Return code */
4142
4143 assert( pPager->eState==PAGER_WRITER_CACHEMOD
4144 || pPager->eState==PAGER_WRITER_DBMOD
4145 );
4146 assert( assert_pager_state(pPager) );
dan937ac9d2010-08-03 12:48:45 +00004147 assert( !pagerUseWal(pPager) );
dand0864082010-08-02 14:32:52 +00004148
4149 rc = sqlite3PagerExclusiveLock(pPager);
4150 if( rc!=SQLITE_OK ) return rc;
4151
dan51133ea2010-07-30 15:43:13 +00004152 if( !pPager->noSync ){
danielk1977b3175382008-10-17 18:51:52 +00004153 assert( !pPager->tempFile );
dand0864082010-08-02 14:32:52 +00004154 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
danielk1977bea2a942009-01-20 17:06:27 +00004155 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
4156 assert( isOpen(pPager->jfd) );
danielk19774cd2cd52007-08-23 14:48:23 +00004157
danielk19774cd2cd52007-08-23 14:48:23 +00004158 if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
danielk1977112f7522009-01-08 17:50:45 +00004159 /* This block deals with an obscure problem. If the last connection
4160 ** that wrote to this database was operating in persistent-journal
4161 ** mode, then the journal file may at this point actually be larger
4162 ** than Pager.journalOff bytes. If the next thing in the journal
4163 ** file happens to be a journal-header (written as part of the
drh91781bd2010-04-10 17:52:57 +00004164 ** previous connection's transaction), and a crash or power-failure
danielk1977112f7522009-01-08 17:50:45 +00004165 ** occurs after nRec is updated but before this connection writes
4166 ** anything else to the journal file (or commits/rolls back its
4167 ** transaction), then SQLite may become confused when doing the
4168 ** hot-journal rollback following recovery. It may roll back all
4169 ** of this connections data, then proceed to rolling back the old,
4170 ** out-of-date data that follows it. Database corruption.
4171 **
4172 ** To work around this, if the journal file does appear to contain
4173 ** a valid header following Pager.journalOff, then write a 0x00
4174 ** byte to the start of it to prevent it from being recognized.
danielk1977bea2a942009-01-20 17:06:27 +00004175 **
4176 ** Variable iNextHdrOffset is set to the offset at which this
4177 ** problematic header will occur, if it exists. aMagic is used
4178 ** as a temporary buffer to inspect the first couple of bytes of
4179 ** the potential journal header.
danielk1977112f7522009-01-08 17:50:45 +00004180 */
drh7b746032009-06-26 12:15:22 +00004181 i64 iNextHdrOffset;
danielk1977bea2a942009-01-20 17:06:27 +00004182 u8 aMagic[8];
danb9780022010-04-21 18:37:57 +00004183 u8 zHeader[sizeof(aJournalMagic)+4];
drh7b746032009-06-26 12:15:22 +00004184
danb9780022010-04-21 18:37:57 +00004185 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
4186 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
drh7b746032009-06-26 12:15:22 +00004187
4188 iNextHdrOffset = journalHdrOffset(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00004189 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
4190 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
danielk1977112f7522009-01-08 17:50:45 +00004191 static const u8 zerobyte = 0;
danielk1977bea2a942009-01-20 17:06:27 +00004192 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
danielk1977112f7522009-01-08 17:50:45 +00004193 }
4194 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
4195 return rc;
4196 }
4197
danielk197776572402004-06-25 02:38:54 +00004198 /* Write the nRec value into the journal file header. If in
4199 ** full-synchronous mode, sync the journal first. This ensures that
4200 ** all data has really hit the disk before nRec is updated to mark
danielk19774cd2cd52007-08-23 14:48:23 +00004201 ** it as a candidate for rollback.
4202 **
4203 ** This is not required if the persistent media supports the
4204 ** SAFE_APPEND property. Because in this case it is not possible
4205 ** for garbage data to be appended to the file, the nRec field
4206 ** is populated with 0xFFFFFFFF when the journal header is written
4207 ** and never needs to be updated.
danielk197776572402004-06-25 02:38:54 +00004208 */
danielk19774cd2cd52007-08-23 14:48:23 +00004209 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh30d53702009-01-06 15:58:57 +00004210 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
drhb0603412007-02-28 04:47:26 +00004211 IOTRACE(("JSYNC %p\n", pPager))
drhc97d8462010-11-19 18:23:35 +00004212 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
danielk1977bea2a942009-01-20 17:06:27 +00004213 if( rc!=SQLITE_OK ) return rc;
drhd8d66e82003-02-12 02:10:15 +00004214 }
drh7b746032009-06-26 12:15:22 +00004215 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
danielk19776f4c73e2009-06-26 07:12:06 +00004216 rc = sqlite3OsWrite(
4217 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
danb9780022010-04-21 18:37:57 +00004218 );
danielk1977bea2a942009-01-20 17:06:27 +00004219 if( rc!=SQLITE_OK ) return rc;
drh968af522003-02-11 14:55:40 +00004220 }
danielk19774cd2cd52007-08-23 14:48:23 +00004221 if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh30d53702009-01-06 15:58:57 +00004222 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
danielk19774cd2cd52007-08-23 14:48:23 +00004223 IOTRACE(("JSYNC %p\n", pPager))
drhc97d8462010-11-19 18:23:35 +00004224 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
4225 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
danielk19774cd2cd52007-08-23 14:48:23 +00004226 );
danielk1977bea2a942009-01-20 17:06:27 +00004227 if( rc!=SQLITE_OK ) return rc;
danielk19774cd2cd52007-08-23 14:48:23 +00004228 }
danielk197745d68822009-01-16 16:23:38 +00004229
dan937ac9d2010-08-03 12:48:45 +00004230 pPager->journalHdr = pPager->journalOff;
4231 if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
4232 pPager->nRec = 0;
4233 rc = writeJournalHdr(pPager);
dan5761dbe2010-08-05 16:08:26 +00004234 if( rc!=SQLITE_OK ) return rc;
dan937ac9d2010-08-03 12:48:45 +00004235 }
4236 }else{
4237 pPager->journalHdr = pPager->journalOff;
4238 }
drh50e5dad2001-09-15 00:57:28 +00004239 }
drh03eb96a2002-11-10 23:32:56 +00004240
dand0864082010-08-02 14:32:52 +00004241 /* Unless the pager is in noSync mode, the journal file was just
4242 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
4243 ** all pages.
4244 */
4245 sqlite3PcacheClearSyncFlags(pPager->pPCache);
4246 pPager->eState = PAGER_WRITER_DBMOD;
4247 assert( assert_pager_state(pPager) );
danielk1977bea2a942009-01-20 17:06:27 +00004248 return SQLITE_OK;
drh50e5dad2001-09-15 00:57:28 +00004249}
4250
4251/*
danielk1977bea2a942009-01-20 17:06:27 +00004252** The argument is the first in a linked list of dirty pages connected
4253** by the PgHdr.pDirty pointer. This function writes each one of the
4254** in-memory pages in the list to the database file. The argument may
4255** be NULL, representing an empty list. In this case this function is
4256** a no-op.
4257**
4258** The pager must hold at least a RESERVED lock when this function
4259** is called. Before writing anything to the database file, this lock
4260** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
4261** SQLITE_BUSY is returned and no data is written to the database file.
4262**
4263** If the pager is a temp-file pager and the actual file-system file
4264** is not yet open, it is created and opened before any data is
4265** written out.
4266**
4267** Once the lock has been upgraded and, if necessary, the file opened,
4268** the pages are written out to the database file in list order. Writing
4269** a page is skipped if it meets either of the following criteria:
4270**
4271** * The page number is greater than Pager.dbSize, or
4272** * The PGHDR_DONT_WRITE flag is set on the page.
4273**
4274** If writing out a page causes the database file to grow, Pager.dbFileSize
4275** is updated accordingly. If page 1 is written out, then the value cached
4276** in Pager.dbFileVers[] is updated to match the new value stored in
4277** the database file.
4278**
4279** If everything is successful, SQLITE_OK is returned. If an IO error
4280** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
4281** be obtained, SQLITE_BUSY is returned.
drh2554f8b2003-01-22 01:26:44 +00004282*/
drh146151c2010-07-07 14:19:13 +00004283static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
danc8649122010-08-10 09:58:57 +00004284 int rc = SQLITE_OK; /* Return code */
drh2554f8b2003-01-22 01:26:44 +00004285
danc8649122010-08-10 09:58:57 +00004286 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
drh146151c2010-07-07 14:19:13 +00004287 assert( !pagerUseWal(pPager) );
dan41113b62016-04-05 21:07:58 +00004288 assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
danc8649122010-08-10 09:58:57 +00004289 assert( pPager->eLock==EXCLUSIVE_LOCK );
dan199f56b2016-04-12 19:09:29 +00004290 assert( isOpen(pPager->fd) || pList->pDirty==0 );
danielk1977bea2a942009-01-20 17:06:27 +00004291
4292 /* If the file is a temp-file has not yet been opened, open it now. It
4293 ** is not possible for rc to be other than SQLITE_OK if this branch
4294 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
4295 */
4296 if( !isOpen(pPager->fd) ){
4297 assert( pPager->tempFile && rc==SQLITE_OK );
4298 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
danielk19779eed5052004-06-04 10:38:30 +00004299 }
4300
drh9ff27ec2010-05-19 19:26:05 +00004301 /* Before the first write, give the VFS a hint of what the final
4302 ** file size will be.
4303 */
dan7fb574e2010-07-07 16:18:45 +00004304 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
daneb97b292013-03-20 14:26:59 +00004305 if( rc==SQLITE_OK
dan3719f5f2013-05-23 10:13:18 +00004306 && pPager->dbHintSize<pPager->dbSize
4307 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
daneb97b292013-03-20 14:26:59 +00004308 ){
drh9ff27ec2010-05-19 19:26:05 +00004309 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
drhc02372c2012-01-10 17:59:59 +00004310 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
danc8649122010-08-10 09:58:57 +00004311 pPager->dbHintSize = pPager->dbSize;
drh9ff27ec2010-05-19 19:26:05 +00004312 }
4313
danielk1977bea2a942009-01-20 17:06:27 +00004314 while( rc==SQLITE_OK && pList ){
4315 Pgno pgno = pList->pgno;
danielk19777a2b1ee2007-08-21 14:27:01 +00004316
danielk1977687566d2004-11-02 12:56:41 +00004317 /* If there are dirty pages in the page cache with page numbers greater
danielk1977f90b7262009-01-07 15:18:20 +00004318 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
danielk1977687566d2004-11-02 12:56:41 +00004319 ** make the file smaller (presumably by auto-vacuum code). Do not write
4320 ** any such pages to the file.
danielk1977bea2a942009-01-20 17:06:27 +00004321 **
4322 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
drh5b47efa2010-02-12 18:18:39 +00004323 ** set (set by sqlite3PagerDontWrite()).
danielk1977687566d2004-11-02 12:56:41 +00004324 */
danielk1977bea2a942009-01-20 17:06:27 +00004325 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
drh85d2bd22009-06-11 00:47:20 +00004326 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
4327 char *pData; /* Data to write */
4328
dan51133ea2010-07-30 15:43:13 +00004329 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
drhd40d7ec2011-01-16 00:56:19 +00004330 if( pList->pgno==1 ) pager_write_changecounter(pList);
dan51133ea2010-07-30 15:43:13 +00004331
drh85d2bd22009-06-11 00:47:20 +00004332 /* Encode the database */
mistachkinfad30392016-02-13 23:43:46 +00004333 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM_BKPT, pData);
danielk1977443c0592009-01-16 15:21:05 +00004334
danielk1977bea2a942009-01-20 17:06:27 +00004335 /* Write out the page data. */
danielk197745d68822009-01-16 16:23:38 +00004336 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
danielk1977bea2a942009-01-20 17:06:27 +00004337
4338 /* If page 1 was just written, update Pager.dbFileVers to match
4339 ** the value now stored in the database file. If writing this
4340 ** page caused the database file to grow, update dbFileSize.
4341 */
4342 if( pgno==1 ){
danielk197745d68822009-01-16 16:23:38 +00004343 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
4344 }
danielk1977bea2a942009-01-20 17:06:27 +00004345 if( pgno>pPager->dbFileSize ){
4346 pPager->dbFileSize = pgno;
danielk197745d68822009-01-16 16:23:38 +00004347 }
drh9ad3ee42012-03-24 20:06:14 +00004348 pPager->aStat[PAGER_STAT_WRITE]++;
danielk1977bea2a942009-01-20 17:06:27 +00004349
danielk197704103022009-02-03 16:51:24 +00004350 /* Update any backup objects copying the contents of this pager. */
drh0719ee22009-06-18 20:52:47 +00004351 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
danielk197704103022009-02-03 16:51:24 +00004352
danielk1977bea2a942009-01-20 17:06:27 +00004353 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
4354 PAGERID(pPager), pgno, pager_pagehash(pList)));
4355 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
4356 PAGER_INCR(sqlite3_pager_writedb_count);
danielk1977bea2a942009-01-20 17:06:27 +00004357 }else{
4358 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
danielk1977687566d2004-11-02 12:56:41 +00004359 }
dan5f848c32010-08-23 18:19:31 +00004360 pager_set_pagehash(pList);
drh2554f8b2003-01-22 01:26:44 +00004361 pList = pList->pDirty;
4362 }
danielk19778c0a7912008-08-20 14:49:23 +00004363
danielk1977bea2a942009-01-20 17:06:27 +00004364 return rc;
drh2554f8b2003-01-22 01:26:44 +00004365}
4366
4367/*
dan459564f2010-06-03 12:35:28 +00004368** Ensure that the sub-journal file is open. If it is already open, this
4369** function is a no-op.
4370**
4371** SQLITE_OK is returned if everything goes according to plan. An
4372** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
4373** fails.
4374*/
4375static int openSubJournal(Pager *pPager){
4376 int rc = SQLITE_OK;
4377 if( !isOpen(pPager->sjfd) ){
dan6e763262016-02-29 20:18:21 +00004378 const int flags = SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_READWRITE
4379 | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE
4380 | SQLITE_OPEN_DELETEONCLOSE;
drh8c71a982016-03-07 17:37:37 +00004381 int nStmtSpill = sqlite3Config.nStmtSpill;
dan459564f2010-06-03 12:35:28 +00004382 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
drh8c71a982016-03-07 17:37:37 +00004383 nStmtSpill = -1;
dan459564f2010-06-03 12:35:28 +00004384 }
drh8c71a982016-03-07 17:37:37 +00004385 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
dan459564f2010-06-03 12:35:28 +00004386 }
4387 return rc;
4388}
4389
4390/*
danielk1977bea2a942009-01-20 17:06:27 +00004391** Append a record of the current state of page pPg to the sub-journal.
danielk1977bea2a942009-01-20 17:06:27 +00004392**
4393** If successful, set the bit corresponding to pPg->pgno in the bitvecs
4394** for all open savepoints before returning.
4395**
4396** This function returns SQLITE_OK if everything is successful, an IO
4397** error code if the attempt to write to the sub-journal fails, or
4398** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
4399** bitvec.
danielk1977f2c31ad2009-01-06 13:40:08 +00004400*/
4401static int subjournalPage(PgHdr *pPg){
danielk1977651a52f2009-02-04 10:09:04 +00004402 int rc = SQLITE_OK;
danielk1977f2c31ad2009-01-06 13:40:08 +00004403 Pager *pPager = pPg->pPager;
dan459564f2010-06-03 12:35:28 +00004404 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
drh85d2bd22009-06-11 00:47:20 +00004405
dan459564f2010-06-03 12:35:28 +00004406 /* Open the sub-journal, if it has not already been opened */
4407 assert( pPager->useJournal );
4408 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
4409 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
drh7ed91f22010-04-29 22:34:07 +00004410 assert( pagerUseWal(pPager)
drh5dee6af2013-12-13 20:45:50 +00004411 || pageInJournal(pPager, pPg)
dan7c246102010-04-12 19:00:29 +00004412 || pPg->pgno>pPager->dbOrigSize
4413 );
dan459564f2010-06-03 12:35:28 +00004414 rc = openSubJournal(pPager);
4415
4416 /* If the sub-journal was opened successfully (or was already open),
4417 ** write the journal record into the file. */
danielk1977651a52f2009-02-04 10:09:04 +00004418 if( rc==SQLITE_OK ){
dan459564f2010-06-03 12:35:28 +00004419 void *pData = pPg->pData;
dan7c3210e2011-12-21 18:04:41 +00004420 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
dan459564f2010-06-03 12:35:28 +00004421 char *pData2;
4422
mistachkinfad30392016-02-13 23:43:46 +00004423 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
dan459564f2010-06-03 12:35:28 +00004424 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
4425 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
4426 if( rc==SQLITE_OK ){
4427 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
4428 }
danielk1977651a52f2009-02-04 10:09:04 +00004429 }
danielk1977f2c31ad2009-01-06 13:40:08 +00004430 }
4431 if( rc==SQLITE_OK ){
danielk1977bea2a942009-01-20 17:06:27 +00004432 pPager->nSubRec++;
danielk1977f2c31ad2009-01-06 13:40:08 +00004433 assert( pPager->nSavepoint>0 );
4434 rc = addToSavepointBitvecs(pPager, pPg->pgno);
4435 }
4436 return rc;
4437}
drh60e32ed2015-06-29 19:08:18 +00004438static int subjournalPageIfRequired(PgHdr *pPg){
4439 if( subjRequiresPage(pPg) ){
4440 return subjournalPage(pPg);
4441 }else{
4442 return SQLITE_OK;
4443 }
4444}
danielk1977f2c31ad2009-01-06 13:40:08 +00004445
dan3306c4a2010-04-23 19:15:00 +00004446/*
danielk19778c0a7912008-08-20 14:49:23 +00004447** This function is called by the pcache layer when it has reached some
danielk1977bea2a942009-01-20 17:06:27 +00004448** soft memory limit. The first argument is a pointer to a Pager object
4449** (cast as a void*). The pager is always 'purgeable' (not an in-memory
4450** database). The second argument is a reference to a page that is
4451** currently dirty but has no outstanding references. The page
4452** is always associated with the Pager object passed as the first
4453** argument.
4454**
4455** The job of this function is to make pPg clean by writing its contents
4456** out to the database file, if possible. This may involve syncing the
4457** journal file.
4458**
4459** If successful, sqlite3PcacheMakeClean() is called on the page and
4460** SQLITE_OK returned. If an IO error occurs while trying to make the
4461** page clean, the IO error code is returned. If the page cannot be
4462** made clean for some other reason, but no error occurs, then SQLITE_OK
4463** is returned by sqlite3PcacheMakeClean() is not called.
drh2554f8b2003-01-22 01:26:44 +00004464*/
danielk1977a858aa22008-08-22 16:22:17 +00004465static int pagerStress(void *p, PgHdr *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004466 Pager *pPager = (Pager *)p;
danielk19778c0a7912008-08-20 14:49:23 +00004467 int rc = SQLITE_OK;
drh8f2e9a12008-02-26 14:46:04 +00004468
danielk1977bea2a942009-01-20 17:06:27 +00004469 assert( pPg->pPager==pPager );
4470 assert( pPg->flags&PGHDR_DIRTY );
4471
drh40c39412013-08-16 20:42:20 +00004472 /* The doNotSpill NOSYNC bit is set during times when doing a sync of
drh314f30d2010-06-24 18:36:33 +00004473 ** journal (and adding a new header) is not allowed. This occurs
4474 ** during calls to sqlite3PagerWrite() while trying to journal multiple
4475 ** pages belonging to the same sector.
drh7cf4c7a2010-06-24 14:52:25 +00004476 **
drh40c39412013-08-16 20:42:20 +00004477 ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
4478 ** regardless of whether or not a sync is required. This is set during
4479 ** a rollback or by user request, respectively.
drh314f30d2010-06-24 18:36:33 +00004480 **
drh00284862010-08-17 18:37:12 +00004481 ** Spilling is also prohibited when in an error state since that could
peter.d.reid60ec9142014-09-06 16:39:46 +00004482 ** lead to database corruption. In the current implementation it
drhc3031c62014-08-26 15:06:49 +00004483 ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
drh00284862010-08-17 18:37:12 +00004484 ** while in the error state, hence it is impossible for this routine to
4485 ** be called in the error state. Nevertheless, we include a NEVER()
4486 ** test for the error state as a safeguard against future changes.
drh7cf4c7a2010-06-24 14:52:25 +00004487 */
drh00284862010-08-17 18:37:12 +00004488 if( NEVER(pPager->errCode) ) return SQLITE_OK;
drh40c39412013-08-16 20:42:20 +00004489 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
4490 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
4491 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
4492 if( pPager->doNotSpill
4493 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
4494 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
4495 ){
drh7cf4c7a2010-06-24 14:52:25 +00004496 return SQLITE_OK;
4497 }
4498
dan4a4b01d2010-04-16 11:30:18 +00004499 pPg->pDirty = 0;
drh7ed91f22010-04-29 22:34:07 +00004500 if( pagerUseWal(pPager) ){
dan4cc6fb62010-04-15 16:45:34 +00004501 /* Write a single frame for this page to the log. */
drh60e32ed2015-06-29 19:08:18 +00004502 rc = subjournalPageIfRequired(pPg);
dan4cd78b42010-04-26 16:57:10 +00004503 if( rc==SQLITE_OK ){
drh4eb02a42011-12-16 21:26:26 +00004504 rc = pagerWalFrames(pPager, pPg, 0, 0);
dan4cd78b42010-04-26 16:57:10 +00004505 }
dan4cc6fb62010-04-15 16:45:34 +00004506 }else{
dan4cc6fb62010-04-15 16:45:34 +00004507
4508 /* Sync the journal file if required. */
danc8649122010-08-10 09:58:57 +00004509 if( pPg->flags&PGHDR_NEED_SYNC
4510 || pPager->eState==PAGER_WRITER_CACHEMOD
4511 ){
dan937ac9d2010-08-03 12:48:45 +00004512 rc = syncJournal(pPager, 1);
dan4cc6fb62010-04-15 16:45:34 +00004513 }
4514
dan4cc6fb62010-04-15 16:45:34 +00004515 /* Write the contents of the page out to the database file. */
4516 if( rc==SQLITE_OK ){
dan51133ea2010-07-30 15:43:13 +00004517 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
drh146151c2010-07-07 14:19:13 +00004518 rc = pager_write_pagelist(pPager, pPg);
dan4cc6fb62010-04-15 16:45:34 +00004519 }
danielk1977bea2a942009-01-20 17:06:27 +00004520 }
4521
4522 /* Mark the page as clean. */
danielk1977a858aa22008-08-22 16:22:17 +00004523 if( rc==SQLITE_OK ){
drh30d53702009-01-06 15:58:57 +00004524 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
danielk1977a858aa22008-08-22 16:22:17 +00004525 sqlite3PcacheMakeClean(pPg);
danielk19778c0a7912008-08-20 14:49:23 +00004526 }
danielk1977bea2a942009-01-20 17:06:27 +00004527
dan5653e4d2010-08-12 11:25:47 +00004528 return pager_error(pPager, rc);
drh2554f8b2003-01-22 01:26:44 +00004529}
4530
dan6fa255f2015-10-28 19:46:57 +00004531/*
4532** Flush all unreferenced dirty pages to disk.
4533*/
4534int sqlite3PagerFlush(Pager *pPager){
dandbf67732015-10-29 18:16:40 +00004535 int rc = pPager->errCode;
dan9fb13ab2015-10-29 21:11:22 +00004536 if( !MEMDB ){
4537 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
4538 assert( assert_pager_state(pPager) );
4539 while( rc==SQLITE_OK && pList ){
4540 PgHdr *pNext = pList->pDirty;
4541 if( pList->nRef==0 ){
4542 rc = pagerStress((void*)pPager, pList);
4543 }
4544 pList = pNext;
dan6fa255f2015-10-28 19:46:57 +00004545 }
dan6fa255f2015-10-28 19:46:57 +00004546 }
4547
4548 return rc;
4549}
danielk19778c0a7912008-08-20 14:49:23 +00004550
drh2554f8b2003-01-22 01:26:44 +00004551/*
danielk1977bea2a942009-01-20 17:06:27 +00004552** Allocate and initialize a new Pager object and put a pointer to it
4553** in *ppPager. The pager should eventually be freed by passing it
4554** to sqlite3PagerClose().
4555**
4556** The zFilename argument is the path to the database file to open.
4557** If zFilename is NULL then a randomly-named temporary file is created
4558** and used as the file to be cached. Temporary files are be deleted
4559** automatically when they are closed. If zFilename is ":memory:" then
4560** all information is held in cache. It is never written to disk.
4561** This can be used to implement an in-memory database.
4562**
4563** The nExtra parameter specifies the number of bytes of space allocated
4564** along with each page reference. This space is available to the user
4565** via the sqlite3PagerGetExtra() API.
4566**
4567** The flags argument is used to specify properties that affect the
4568** operation of the pager. It should be passed some bitwise combination
drh33f111d2012-01-17 15:29:14 +00004569** of the PAGER_* flags.
danielk1977bea2a942009-01-20 17:06:27 +00004570**
4571** The vfsFlags parameter is a bitmask to pass to the flags parameter
4572** of the xOpen() method of the supplied VFS when opening files.
4573**
4574** If the pager object is allocated and the specified file opened
4575** successfully, SQLITE_OK is returned and *ppPager set to point to
4576** the new pager object. If an error occurs, *ppPager is set to NULL
4577** and error code returned. This function may return SQLITE_NOMEM
4578** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
4579** various SQLITE_IO_XXX errors.
4580*/
4581int sqlite3PagerOpen(
4582 sqlite3_vfs *pVfs, /* The virtual file system to use */
4583 Pager **ppPager, /* OUT: Return the Pager structure here */
4584 const char *zFilename, /* Name of the database file to open */
4585 int nExtra, /* Extra bytes append to each in-memory page */
4586 int flags, /* flags controlling this file */
drh4775ecd2009-07-24 19:01:19 +00004587 int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */
4588 void (*xReinit)(DbPage*) /* Function to reinitialize pages */
danielk1977bea2a942009-01-20 17:06:27 +00004589){
4590 u8 *pPtr;
4591 Pager *pPager = 0; /* Pager object to allocate and return */
4592 int rc = SQLITE_OK; /* Return code */
4593 int tempFile = 0; /* True for temp files (incl. in-memory files) */
4594 int memDb = 0; /* True if this is an in-memory file */
4595 int readOnly = 0; /* True if this is a read-only file */
4596 int journalFileSize; /* Bytes to allocate for each journal fd */
4597 char *zPathname = 0; /* Full path to database file */
4598 int nPathname = 0; /* Number of bytes in zPathname */
4599 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
danielk1977bea2a942009-01-20 17:06:27 +00004600 int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */
drhb2eced52010-08-12 02:41:12 +00004601 u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
dancd74b612011-04-22 19:37:32 +00004602 const char *zUri = 0; /* URI args to copy */
4603 int nUri = 0; /* Number of bytes of URI args at *zUri */
danielk1977bea2a942009-01-20 17:06:27 +00004604
4605 /* Figure out how much space is required for each journal file-handle
dan2491de22016-02-27 20:14:55 +00004606 ** (there are two of them, the main journal and the sub-journal). */
4607 journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
danielk1977bea2a942009-01-20 17:06:27 +00004608
4609 /* Set the output variable to NULL in case an error occurs. */
4610 *ppPager = 0;
4611
drh75c014c2010-08-30 15:02:28 +00004612#ifndef SQLITE_OMIT_MEMORYDB
4613 if( flags & PAGER_MEMORY ){
4614 memDb = 1;
drhd4e0bb02012-05-27 01:19:04 +00004615 if( zFilename && zFilename[0] ){
drh4ab9d252012-05-26 20:08:49 +00004616 zPathname = sqlite3DbStrDup(0, zFilename);
mistachkinfad30392016-02-13 23:43:46 +00004617 if( zPathname==0 ) return SQLITE_NOMEM_BKPT;
drh4ab9d252012-05-26 20:08:49 +00004618 nPathname = sqlite3Strlen30(zPathname);
4619 zFilename = 0;
4620 }
drh75c014c2010-08-30 15:02:28 +00004621 }
4622#endif
4623
danielk1977bea2a942009-01-20 17:06:27 +00004624 /* Compute and store the full pathname in an allocated buffer pointed
4625 ** to by zPathname, length nPathname. Or, if this is a temporary file,
4626 ** leave both nPathname and zPathname set to 0.
4627 */
4628 if( zFilename && zFilename[0] ){
dancd74b612011-04-22 19:37:32 +00004629 const char *z;
danielk1977bea2a942009-01-20 17:06:27 +00004630 nPathname = pVfs->mxPathname+1;
dana8793422012-06-07 07:24:04 +00004631 zPathname = sqlite3DbMallocRaw(0, nPathname*2);
danielk1977bea2a942009-01-20 17:06:27 +00004632 if( zPathname==0 ){
mistachkinfad30392016-02-13 23:43:46 +00004633 return SQLITE_NOMEM_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00004634 }
drh75c014c2010-08-30 15:02:28 +00004635 zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
4636 rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
danielk1977bea2a942009-01-20 17:06:27 +00004637 nPathname = sqlite3Strlen30(zPathname);
dancd74b612011-04-22 19:37:32 +00004638 z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
4639 while( *z ){
4640 z += sqlite3Strlen30(z)+1;
4641 z += sqlite3Strlen30(z)+1;
4642 }
dan0e208252011-12-30 09:00:19 +00004643 nUri = (int)(&z[1] - zUri);
4644 assert( nUri>=0 );
danielk1977bea2a942009-01-20 17:06:27 +00004645 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
4646 /* This branch is taken when the journal path required by
4647 ** the database being opened will be more than pVfs->mxPathname
4648 ** bytes in length. This means the database cannot be opened,
4649 ** as it will not be possible to open the journal file or even
4650 ** check for a hot-journal before reading.
4651 */
drh9978c972010-02-23 17:36:32 +00004652 rc = SQLITE_CANTOPEN_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00004653 }
4654 if( rc!=SQLITE_OK ){
dana8793422012-06-07 07:24:04 +00004655 sqlite3DbFree(0, zPathname);
danielk1977bea2a942009-01-20 17:06:27 +00004656 return rc;
4657 }
4658 }
4659
4660 /* Allocate memory for the Pager structure, PCache object, the
4661 ** three file descriptors, the database file name and the journal
4662 ** file name. The layout in memory is as follows:
4663 **
4664 ** Pager object (sizeof(Pager) bytes)
4665 ** PCache object (sqlite3PcacheSize() bytes)
4666 ** Database file handle (pVfs->szOsFile bytes)
4667 ** Sub-journal file handle (journalFileSize bytes)
4668 ** Main journal file handle (journalFileSize bytes)
4669 ** Database file name (nPathname+1 bytes)
4670 ** Journal file name (nPathname+8+1 bytes)
4671 */
4672 pPtr = (u8 *)sqlite3MallocZero(
drhea598cb2009-04-05 12:22:08 +00004673 ROUND8(sizeof(*pPager)) + /* Pager structure */
4674 ROUND8(pcacheSize) + /* PCache object */
4675 ROUND8(pVfs->szOsFile) + /* The main db file */
4676 journalFileSize * 2 + /* The two journal files */
dancd74b612011-04-22 19:37:32 +00004677 nPathname + 1 + nUri + /* zFilename */
drh52bcde02012-01-03 14:50:45 +00004678 nPathname + 8 + 2 /* zJournal */
dan3e875ef2010-07-05 19:03:35 +00004679#ifndef SQLITE_OMIT_WAL
drh52bcde02012-01-03 14:50:45 +00004680 + nPathname + 4 + 2 /* zWal */
dan3e875ef2010-07-05 19:03:35 +00004681#endif
danielk1977bea2a942009-01-20 17:06:27 +00004682 );
shane60a4b532009-05-06 18:57:09 +00004683 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
danielk1977bea2a942009-01-20 17:06:27 +00004684 if( !pPtr ){
dana8793422012-06-07 07:24:04 +00004685 sqlite3DbFree(0, zPathname);
mistachkinfad30392016-02-13 23:43:46 +00004686 return SQLITE_NOMEM_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00004687 }
4688 pPager = (Pager*)(pPtr);
drhea598cb2009-04-05 12:22:08 +00004689 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
4690 pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
4691 pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
danielk1977bea2a942009-01-20 17:06:27 +00004692 pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
4693 pPager->zFilename = (char*)(pPtr += journalFileSize);
drhea598cb2009-04-05 12:22:08 +00004694 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
danielk1977bea2a942009-01-20 17:06:27 +00004695
4696 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
4697 if( zPathname ){
drh8c96a6e2010-08-31 01:09:15 +00004698 assert( nPathname>0 );
dancd74b612011-04-22 19:37:32 +00004699 pPager->zJournal = (char*)(pPtr += nPathname + 1 + nUri);
danielk1977bea2a942009-01-20 17:06:27 +00004700 memcpy(pPager->zFilename, zPathname, nPathname);
drh5e0c4932012-06-06 23:59:36 +00004701 if( nUri ) memcpy(&pPager->zFilename[nPathname+1], zUri, nUri);
danielk1977bea2a942009-01-20 17:06:27 +00004702 memcpy(pPager->zJournal, zPathname, nPathname);
drh55b4c222012-09-15 13:39:24 +00004703 memcpy(&pPager->zJournal[nPathname], "-journal\000", 8+2);
drh81cc5162011-05-17 20:36:21 +00004704 sqlite3FileSuffix3(pPager->zFilename, pPager->zJournal);
dan3e875ef2010-07-05 19:03:35 +00004705#ifndef SQLITE_OMIT_WAL
drh8c96a6e2010-08-31 01:09:15 +00004706 pPager->zWal = &pPager->zJournal[nPathname+8+1];
4707 memcpy(pPager->zWal, zPathname, nPathname);
drh52bcde02012-01-03 14:50:45 +00004708 memcpy(&pPager->zWal[nPathname], "-wal\000", 4+1);
drh81cc5162011-05-17 20:36:21 +00004709 sqlite3FileSuffix3(pPager->zFilename, pPager->zWal);
dan3e875ef2010-07-05 19:03:35 +00004710#endif
dana8793422012-06-07 07:24:04 +00004711 sqlite3DbFree(0, zPathname);
danielk1977bea2a942009-01-20 17:06:27 +00004712 }
4713 pPager->pVfs = pVfs;
4714 pPager->vfsFlags = vfsFlags;
4715
4716 /* Open the pager file.
4717 */
drh8c96a6e2010-08-31 01:09:15 +00004718 if( zFilename && zFilename[0] ){
danielk1977bea2a942009-01-20 17:06:27 +00004719 int fout = 0; /* VFS flags returned by xOpen() */
4720 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
drh8c96a6e2010-08-31 01:09:15 +00004721 assert( !memDb );
danielk1977bea2a942009-01-20 17:06:27 +00004722 readOnly = (fout&SQLITE_OPEN_READONLY);
4723
4724 /* If the file was successfully opened for read/write access,
4725 ** choose a default page size in case we have to create the
4726 ** database file. The default page size is the maximum of:
4727 **
4728 ** + SQLITE_DEFAULT_PAGE_SIZE,
4729 ** + The value returned by sqlite3OsSectorSize()
4730 ** + The largest page size that can be written atomically.
4731 */
drhd1ae96d2014-05-01 01:13:08 +00004732 if( rc==SQLITE_OK ){
drh6451c2b2014-05-07 15:32:03 +00004733 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
drhd1ae96d2014-05-01 01:13:08 +00004734 if( !readOnly ){
drhd1ae96d2014-05-01 01:13:08 +00004735 setSectorSize(pPager);
4736 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
4737 if( szPageDflt<pPager->sectorSize ){
4738 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
4739 szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
4740 }else{
4741 szPageDflt = (u32)pPager->sectorSize;
danielk1977bea2a942009-01-20 17:06:27 +00004742 }
4743 }
drhd1ae96d2014-05-01 01:13:08 +00004744#ifdef SQLITE_ENABLE_ATOMIC_WRITE
4745 {
4746 int ii;
4747 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
4748 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
4749 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
4750 for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
4751 if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
4752 szPageDflt = ii;
4753 }
4754 }
4755 }
danielk1977bea2a942009-01-20 17:06:27 +00004756#endif
drh6451c2b2014-05-07 15:32:03 +00004757 }
4758 pPager->noLock = sqlite3_uri_boolean(zFilename, "nolock", 0);
4759 if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0
4760 || sqlite3_uri_boolean(zFilename, "immutable", 0) ){
4761 vfsFlags |= SQLITE_OPEN_READONLY;
4762 goto act_like_temp_file;
drhd1ae96d2014-05-01 01:13:08 +00004763 }
danielk1977bea2a942009-01-20 17:06:27 +00004764 }
4765 }else{
4766 /* If a temporary file is requested, it is not opened immediately.
4767 ** In this case we accept the default page size and delay actually
4768 ** opening the file until the first call to OsWrite().
4769 **
4770 ** This branch is also run for an in-memory database. An in-memory
4771 ** database is the same as a temp-file that is never written out to
4772 ** disk and uses an in-memory rollback journal.
drh57fe1362014-05-01 01:49:22 +00004773 **
4774 ** This branch also runs for files marked as immutable.
danielk1977bea2a942009-01-20 17:06:27 +00004775 */
drhd1ae96d2014-05-01 01:13:08 +00004776act_like_temp_file:
danielk1977bea2a942009-01-20 17:06:27 +00004777 tempFile = 1;
drh57fe1362014-05-01 01:49:22 +00004778 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
drhe399ac22015-06-29 18:14:02 +00004779 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
drh57fe1362014-05-01 01:49:22 +00004780 pPager->noLock = 1; /* Do no locking */
drhaed24602009-06-11 17:32:45 +00004781 readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
danielk1977bea2a942009-01-20 17:06:27 +00004782 }
4783
4784 /* The following call to PagerSetPagesize() serves to set the value of
4785 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
4786 */
4787 if( rc==SQLITE_OK ){
4788 assert( pPager->memDb==0 );
drhfa9601a2009-06-18 17:22:39 +00004789 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
danielk1977bea2a942009-01-20 17:06:27 +00004790 testcase( rc!=SQLITE_OK );
4791 }
4792
drhc3031c62014-08-26 15:06:49 +00004793 /* Initialize the PCache object. */
4794 if( rc==SQLITE_OK ){
4795 assert( nExtra<1000 );
4796 nExtra = ROUND8(nExtra);
4797 rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb,
drhe399ac22015-06-29 18:14:02 +00004798 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
drhc3031c62014-08-26 15:06:49 +00004799 }
4800
4801 /* If an error occurred above, free the Pager structure and close the file.
danielk1977bea2a942009-01-20 17:06:27 +00004802 */
4803 if( rc!=SQLITE_OK ){
danielk1977bea2a942009-01-20 17:06:27 +00004804 sqlite3OsClose(pPager->fd);
drhc3031c62014-08-26 15:06:49 +00004805 sqlite3PageFree(pPager->pTmpSpace);
danielk1977bea2a942009-01-20 17:06:27 +00004806 sqlite3_free(pPager);
4807 return rc;
4808 }
4809
danielk1977bea2a942009-01-20 17:06:27 +00004810 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
4811 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
4812
4813 pPager->useJournal = (u8)useJournal;
danielk1977bea2a942009-01-20 17:06:27 +00004814 /* pPager->stmtOpen = 0; */
4815 /* pPager->stmtInUse = 0; */
4816 /* pPager->nRef = 0; */
danielk1977bea2a942009-01-20 17:06:27 +00004817 /* pPager->stmtSize = 0; */
4818 /* pPager->stmtJSize = 0; */
4819 /* pPager->nPage = 0; */
4820 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
4821 /* pPager->state = PAGER_UNLOCK; */
danielk1977bea2a942009-01-20 17:06:27 +00004822 /* pPager->errMask = 0; */
4823 pPager->tempFile = (u8)tempFile;
4824 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
4825 || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
4826 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
4827 pPager->exclusiveMode = (u8)tempFile;
4828 pPager->changeCountDone = pPager->tempFile;
4829 pPager->memDb = (u8)memDb;
4830 pPager->readOnly = (u8)readOnly;
drh4775ecd2009-07-24 19:01:19 +00004831 assert( useJournal || pPager->tempFile );
4832 pPager->noSync = pPager->tempFile;
danielk1977bea2a942009-01-20 17:06:27 +00004833 pPager->fullSync = pPager->noSync ?0:1;
drhc97d8462010-11-19 18:23:35 +00004834 pPager->syncFlags = pPager->noSync ? 0 : SQLITE_SYNC_NORMAL;
4835 pPager->ckptSyncFlags = pPager->syncFlags;
drh4eb02a42011-12-16 21:26:26 +00004836 if( pPager->noSync ){
4837 assert( pPager->fullSync==0 );
drh6841b1c2016-02-03 19:20:15 +00004838 assert( pPager->extraSync==0 );
drh4eb02a42011-12-16 21:26:26 +00004839 assert( pPager->syncFlags==0 );
4840 assert( pPager->walSyncFlags==0 );
4841 assert( pPager->ckptSyncFlags==0 );
4842 }else{
4843 pPager->fullSync = 1;
drh6841b1c2016-02-03 19:20:15 +00004844 pPager->extraSync = 0;
drh4eb02a42011-12-16 21:26:26 +00004845 pPager->syncFlags = SQLITE_SYNC_NORMAL;
4846 pPager->walSyncFlags = SQLITE_SYNC_NORMAL | WAL_SYNC_TRANSACTIONS;
4847 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
4848 }
danielk1977bea2a942009-01-20 17:06:27 +00004849 /* pPager->pFirst = 0; */
4850 /* pPager->pFirstSynced = 0; */
4851 /* pPager->pLast = 0; */
drhfa9601a2009-06-18 17:22:39 +00004852 pPager->nExtra = (u16)nExtra;
danielk1977bea2a942009-01-20 17:06:27 +00004853 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
4854 assert( isOpen(pPager->fd) || tempFile );
4855 setSectorSize(pPager);
drh4775ecd2009-07-24 19:01:19 +00004856 if( !useJournal ){
4857 pPager->journalMode = PAGER_JOURNALMODE_OFF;
4858 }else if( memDb ){
danielk1977bea2a942009-01-20 17:06:27 +00004859 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
4860 }
4861 /* pPager->xBusyHandler = 0; */
4862 /* pPager->pBusyHandlerArg = 0; */
drh4775ecd2009-07-24 19:01:19 +00004863 pPager->xReiniter = xReinit;
danielk1977bea2a942009-01-20 17:06:27 +00004864 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
drh9b4c59f2013-04-15 17:03:42 +00004865 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
drh29391c52010-03-05 20:17:45 +00004866
danielk1977bea2a942009-01-20 17:06:27 +00004867 *ppPager = pPager;
4868 return SQLITE_OK;
4869}
4870
4871
drh1b1f30b2013-12-06 15:37:35 +00004872/* Verify that the database file has not be deleted or renamed out from
4873** under the pager. Return SQLITE_OK if the database is still were it ought
drh3fee8a62013-12-06 17:23:38 +00004874** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
drh1b1f30b2013-12-06 15:37:35 +00004875** code from sqlite3OsAccess()) if the database has gone missing.
4876*/
4877static int databaseIsUnmoved(Pager *pPager){
drhb959a012013-12-07 12:29:22 +00004878 int bHasMoved = 0;
4879 int rc;
drh1b1f30b2013-12-06 15:37:35 +00004880
4881 if( pPager->tempFile ) return SQLITE_OK;
4882 if( pPager->dbSize==0 ) return SQLITE_OK;
4883 assert( pPager->zFilename && pPager->zFilename[0] );
drhb959a012013-12-07 12:29:22 +00004884 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
drha9c19f92013-12-07 16:45:05 +00004885 if( rc==SQLITE_NOTFOUND ){
4886 /* If the HAS_MOVED file-control is unimplemented, assume that the file
4887 ** has not been moved. That is the historical behavior of SQLite: prior to
4888 ** version 3.8.3, it never checked */
4889 rc = SQLITE_OK;
4890 }else if( rc==SQLITE_OK && bHasMoved ){
4891 rc = SQLITE_READONLY_DBMOVED;
4892 }
drh1b1f30b2013-12-06 15:37:35 +00004893 return rc;
4894}
4895
danielk1977bea2a942009-01-20 17:06:27 +00004896
4897/*
4898** This function is called after transitioning from PAGER_UNLOCK to
4899** PAGER_SHARED state. It tests if there is a hot journal present in
4900** the file-system for the given pager. A hot journal is one that
4901** needs to be played back. According to this function, a hot-journal
danielk1977ee8b7992009-03-26 17:13:06 +00004902** file exists if the following criteria are met:
danielk1977bea2a942009-01-20 17:06:27 +00004903**
4904** * The journal file exists in the file system, and
4905** * No process holds a RESERVED or greater lock on the database file, and
danielk1977ee8b7992009-03-26 17:13:06 +00004906** * The database file itself is greater than 0 bytes in size, and
4907** * The first byte of the journal file exists and is not 0x00.
drh165ffe92005-03-15 17:09:30 +00004908**
4909** If the current size of the database file is 0 but a journal file
4910** exists, that is probably an old journal left over from a prior
danielk1977bea2a942009-01-20 17:06:27 +00004911** database with the same name. In this case the journal file is
4912** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
4913** is returned.
drh82ed1e52008-04-25 12:25:42 +00004914**
danielk1977ee8b7992009-03-26 17:13:06 +00004915** This routine does not check if there is a master journal filename
4916** at the end of the file. If there is, and that master journal file
4917** does not exist, then the journal file is not really hot. In this
4918** case this routine will return a false-positive. The pager_playback()
4919** routine will discover that the journal file is not really hot and
4920** will not roll it back.
danielk1977bea2a942009-01-20 17:06:27 +00004921**
4922** If a hot-journal file is found to exist, *pExists is set to 1 and
4923** SQLITE_OK returned. If no hot-journal file is present, *pExists is
4924** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
4925** to determine whether or not a hot-journal file exists, the IO error
4926** code is returned and the value of *pExists is undefined.
drh165ffe92005-03-15 17:09:30 +00004927*/
danielk1977d300b8a2008-08-01 10:50:23 +00004928static int hasHotJournal(Pager *pPager, int *pExists){
danielk1977bea2a942009-01-20 17:06:27 +00004929 sqlite3_vfs * const pVfs = pPager->pVfs;
dan2a321c72010-06-16 19:04:23 +00004930 int rc = SQLITE_OK; /* Return code */
4931 int exists = 1; /* True if a journal file is present */
4932 int jrnlOpen = !!isOpen(pPager->jfd);
danielk1977bea2a942009-01-20 17:06:27 +00004933
drhd05c2232009-07-24 21:23:15 +00004934 assert( pPager->useJournal );
danielk1977bea2a942009-01-20 17:06:27 +00004935 assert( isOpen(pPager->fd) );
dande1ae342010-08-06 12:00:27 +00004936 assert( pPager->eState==PAGER_OPEN );
dand0864082010-08-02 14:32:52 +00004937
dan8ce49d62010-06-19 18:12:02 +00004938 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
4939 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
4940 ));
danielk1977bea2a942009-01-20 17:06:27 +00004941
danielk1977d300b8a2008-08-01 10:50:23 +00004942 *pExists = 0;
dan2a321c72010-06-16 19:04:23 +00004943 if( !jrnlOpen ){
4944 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
4945 }
drh0a846f92008-08-25 17:23:29 +00004946 if( rc==SQLITE_OK && exists ){
dan431b0b42010-08-04 19:14:22 +00004947 int locked = 0; /* True if some process holds a RESERVED lock */
drhf0039ad2009-05-29 00:30:30 +00004948
4949 /* Race condition here: Another process might have been holding the
4950 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
4951 ** call above, but then delete the journal and drop the lock before
4952 ** we get to the following sqlite3OsCheckReservedLock() call. If that
4953 ** is the case, this routine might think there is a hot journal when
4954 ** in fact there is none. This results in a false-positive which will
drh9fe769f2009-05-29 11:57:38 +00004955 ** be dealt with by the playback routine. Ticket #3883.
drhf0039ad2009-05-29 00:30:30 +00004956 */
drh0a846f92008-08-25 17:23:29 +00004957 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
danielk1977bea2a942009-01-20 17:06:27 +00004958 if( rc==SQLITE_OK && !locked ){
dan763afe62010-08-03 06:42:39 +00004959 Pgno nPage; /* Number of pages in database file */
danielk1977ee8b7992009-03-26 17:13:06 +00004960
drh835f22d2016-04-25 19:20:56 +00004961 assert( pPager->tempFile==0 );
dan763afe62010-08-03 06:42:39 +00004962 rc = pagerPagecount(pPager, &nPage);
danielk1977bea2a942009-01-20 17:06:27 +00004963 if( rc==SQLITE_OK ){
drhf3ccc382014-03-07 14:57:07 +00004964 /* If the database is zero pages in size, that means that either (1) the
4965 ** journal is a remnant from a prior database with the same name where
4966 ** the database file but not the journal was deleted, or (2) the initial
4967 ** transaction that populates a new database is being rolled back.
4968 ** In either case, the journal file can be deleted. However, take care
4969 ** not to delete the journal file if it is already open due to
4970 ** journal_mode=PERSIST.
4971 */
mistachkineb443922014-03-07 03:31:35 +00004972 if( nPage==0 && !jrnlOpen ){
drhcc0acb22009-05-29 10:55:29 +00004973 sqlite3BeginBenignMalloc();
dan4e004aa2010-08-05 15:30:22 +00004974 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
drhf0039ad2009-05-29 00:30:30 +00004975 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
dan76de8a72010-10-22 13:55:50 +00004976 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
drhf0039ad2009-05-29 00:30:30 +00004977 }
drhcc0acb22009-05-29 10:55:29 +00004978 sqlite3EndBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00004979 }else{
danielk1977ee8b7992009-03-26 17:13:06 +00004980 /* The journal file exists and no other connection has a reserved
4981 ** or greater lock on the database file. Now check that there is
4982 ** at least one non-zero bytes at the start of the journal file.
4983 ** If there is, then we consider this journal to be hot. If not,
4984 ** it can be ignored.
4985 */
dan2a321c72010-06-16 19:04:23 +00004986 if( !jrnlOpen ){
adam2e4491d2011-06-24 20:47:06 +00004987 int f =
4988#if SQLITE_ENABLE_DATA_PROTECTION
4989 (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
4990#endif
4991 SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
dan2a321c72010-06-16 19:04:23 +00004992 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
4993 }
danielk1977ee8b7992009-03-26 17:13:06 +00004994 if( rc==SQLITE_OK ){
4995 u8 first = 0;
4996 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
4997 if( rc==SQLITE_IOERR_SHORT_READ ){
4998 rc = SQLITE_OK;
4999 }
dan2a321c72010-06-16 19:04:23 +00005000 if( !jrnlOpen ){
5001 sqlite3OsClose(pPager->jfd);
5002 }
danielk1977ee8b7992009-03-26 17:13:06 +00005003 *pExists = (first!=0);
drhcc0acb22009-05-29 10:55:29 +00005004 }else if( rc==SQLITE_CANTOPEN ){
drhf0039ad2009-05-29 00:30:30 +00005005 /* If we cannot open the rollback journal file in order to see if
peter.d.reid60ec9142014-09-06 16:39:46 +00005006 ** it has a zero header, that might be due to an I/O error, or
drhf0039ad2009-05-29 00:30:30 +00005007 ** it might be due to the race condition described above and in
5008 ** ticket #3883. Either way, assume that the journal is hot.
5009 ** This might be a false positive. But if it is, then the
5010 ** automatic journal playback and recovery mechanism will deal
5011 ** with it under an EXCLUSIVE lock where we do not need to
5012 ** worry so much with race conditions.
5013 */
5014 *pExists = 1;
5015 rc = SQLITE_OK;
danielk1977ee8b7992009-03-26 17:13:06 +00005016 }
danielk1977bea2a942009-01-20 17:06:27 +00005017 }
danielk1977861f7452008-06-05 11:39:11 +00005018 }
5019 }
drhbb5f18d2007-04-06 18:23:17 +00005020 }
danielk1977ee8b7992009-03-26 17:13:06 +00005021
danielk1977d300b8a2008-08-01 10:50:23 +00005022 return rc;
drh165ffe92005-03-15 17:09:30 +00005023}
5024
dana470aeb2010-04-21 11:43:38 +00005025/*
danielk197789bc4bc2009-07-21 19:25:24 +00005026** This function is called to obtain a shared lock on the database file.
drh9584f582015-11-04 20:22:37 +00005027** It is illegal to call sqlite3PagerGet() until after this function
danielk197789bc4bc2009-07-21 19:25:24 +00005028** has been successfully called. If a shared-lock is already held when
5029** this function is called, it is a no-op.
5030**
5031** The following operations are also performed by this function.
danielk1977393f0682007-03-31 10:00:48 +00005032**
dana81a2202010-08-17 18:15:48 +00005033** 1) If the pager is currently in PAGER_OPEN state (no lock held
danielk1977bea2a942009-01-20 17:06:27 +00005034** on the database file), then an attempt is made to obtain a
5035** SHARED lock on the database file. Immediately after obtaining
5036** the SHARED lock, the file-system is checked for a hot-journal,
5037** which is played back if present. Following any hot-journal
5038** rollback, the contents of the cache are validated by checking
5039** the 'change-counter' field of the database file header and
5040** discarded if they are found to be invalid.
5041**
5042** 2) If the pager is running in exclusive-mode, and there are currently
5043** no outstanding references to any pages, and is in the error state,
5044** then an attempt is made to clear the error state by discarding
5045** the contents of the page cache and rolling back any open journal
5046** file.
5047**
dana81a2202010-08-17 18:15:48 +00005048** If everything is successful, SQLITE_OK is returned. If an IO error
5049** occurs while locking the database, checking for a hot-journal file or
5050** rolling back a journal file, the IO error code is returned.
danielk1977e277be02007-03-23 18:12:06 +00005051*/
danielk197789bc4bc2009-07-21 19:25:24 +00005052int sqlite3PagerSharedLock(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00005053 int rc = SQLITE_OK; /* Return code */
danielk1977e277be02007-03-23 18:12:06 +00005054
drh8a938f92009-07-25 04:12:02 +00005055 /* This routine is only called from b-tree and only when there are no
dan763afe62010-08-03 06:42:39 +00005056 ** outstanding pages. This implies that the pager state should either
dande1ae342010-08-06 12:00:27 +00005057 ** be OPEN or READER. READER is only possible if the pager is or was in
dan6572c162016-04-23 14:55:28 +00005058 ** exclusive access mode. */
drh8a938f92009-07-25 04:12:02 +00005059 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
dan763afe62010-08-03 06:42:39 +00005060 assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +00005061 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
dan6572c162016-04-23 14:55:28 +00005062 assert( pPager->errCode==SQLITE_OK );
drh8a938f92009-07-25 04:12:02 +00005063
dande1ae342010-08-06 12:00:27 +00005064 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
dan431b0b42010-08-04 19:14:22 +00005065 int bHotJournal = 1; /* True if there exists a hot journal-file */
dand0864082010-08-02 14:32:52 +00005066
dan4e004aa2010-08-05 15:30:22 +00005067 assert( !MEMDB );
dan6572c162016-04-23 14:55:28 +00005068 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
dand0864082010-08-02 14:32:52 +00005069
drh33f111d2012-01-17 15:29:14 +00005070 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
5071 if( rc!=SQLITE_OK ){
5072 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
5073 goto failed;
dan9281bf22010-04-13 11:18:40 +00005074 }
danielk1977b3175382008-10-17 18:51:52 +00005075
5076 /* If a journal file exists, and there is no RESERVED lock on the
5077 ** database file, then it either needs to be played back or deleted.
5078 */
dan431b0b42010-08-04 19:14:22 +00005079 if( pPager->eLock<=SHARED_LOCK ){
5080 rc = hasHotJournal(pPager, &bHotJournal);
danielk1977b3175382008-10-17 18:51:52 +00005081 }
dan431b0b42010-08-04 19:14:22 +00005082 if( rc!=SQLITE_OK ){
5083 goto failed;
5084 }
5085 if( bHotJournal ){
dane3664fb2013-03-05 15:09:25 +00005086 if( pPager->readOnly ){
5087 rc = SQLITE_READONLY_ROLLBACK;
5088 goto failed;
5089 }
5090
danielk1977b3175382008-10-17 18:51:52 +00005091 /* Get an EXCLUSIVE lock on the database file. At this point it is
5092 ** important that a RESERVED lock is not obtained on the way to the
5093 ** EXCLUSIVE lock. If it were, another process might open the
5094 ** database file, detect the RESERVED lock, and conclude that the
danielk1977bea2a942009-01-20 17:06:27 +00005095 ** database is safe to read while this process is still rolling the
5096 ** hot-journal back.
danielk1977b3175382008-10-17 18:51:52 +00005097 **
danielk1977bea2a942009-01-20 17:06:27 +00005098 ** Because the intermediate RESERVED lock is not requested, any
5099 ** other process attempting to access the database file will get to
5100 ** this point in the code and fail to obtain its own EXCLUSIVE lock
5101 ** on the database file.
dand0864082010-08-02 14:32:52 +00005102 **
5103 ** Unless the pager is in locking_mode=exclusive mode, the lock is
5104 ** downgraded to SHARED_LOCK before this function returns.
danielk1977e277be02007-03-23 18:12:06 +00005105 */
dan4e004aa2010-08-05 15:30:22 +00005106 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
dand0864082010-08-02 14:32:52 +00005107 if( rc!=SQLITE_OK ){
dand0864082010-08-02 14:32:52 +00005108 goto failed;
danielk1977b3175382008-10-17 18:51:52 +00005109 }
5110
dand0864082010-08-02 14:32:52 +00005111 /* If it is not already open and the file exists on disk, open the
5112 ** journal for read/write access. Write access is required because
5113 ** in exclusive-access mode the file descriptor will be kept open
5114 ** and possibly used for a transaction later on. Also, write-access
5115 ** is usually required to finalize the journal in journal_mode=persist
5116 ** mode (and also for journal_mode=truncate on some systems).
5117 **
5118 ** If the journal does not exist, it usually means that some
5119 ** other connection managed to get in and roll it back before
5120 ** this connection obtained the exclusive lock above. Or, it
5121 ** may mean that the pager was in the error-state when this
5122 ** function was called and the journal file does not exist.
danielk1977b3175382008-10-17 18:51:52 +00005123 */
danielk1977bea2a942009-01-20 17:06:27 +00005124 if( !isOpen(pPager->jfd) ){
dan431b0b42010-08-04 19:14:22 +00005125 sqlite3_vfs * const pVfs = pPager->pVfs;
5126 int bExists; /* True if journal file exists */
5127 rc = sqlite3OsAccess(
5128 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
5129 if( rc==SQLITE_OK && bExists ){
5130 int fout = 0;
adam2e4491d2011-06-24 20:47:06 +00005131 int f =
5132#if SQLITE_ENABLE_DATA_PROTECTION
5133 (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
5134#endif
5135 SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
dan431b0b42010-08-04 19:14:22 +00005136 assert( !pPager->tempFile );
5137 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
5138 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
5139 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
5140 rc = SQLITE_CANTOPEN_BKPT;
5141 sqlite3OsClose(pPager->jfd);
danielk1977b3175382008-10-17 18:51:52 +00005142 }
5143 }
5144 }
danielk1977b3175382008-10-17 18:51:52 +00005145
5146 /* Playback and delete the journal. Drop the database write
danielk1977112f7522009-01-08 17:50:45 +00005147 ** lock and reacquire the read lock. Purge the cache before
5148 ** playing back the hot-journal so that we don't end up with
drh91781bd2010-04-10 17:52:57 +00005149 ** an inconsistent cache. Sync the hot journal before playing
5150 ** it back since the process that crashed and left the hot journal
5151 ** probably did not sync it and we are required to always sync
5152 ** the journal before playing it back.
danielk1977b3175382008-10-17 18:51:52 +00005153 */
danielk1977641a0bd2009-06-20 11:54:39 +00005154 if( isOpen(pPager->jfd) ){
dan4e004aa2010-08-05 15:30:22 +00005155 assert( rc==SQLITE_OK );
daneada58a2010-04-12 17:08:44 +00005156 rc = pagerSyncHotJournal(pPager);
drh91781bd2010-04-10 17:52:57 +00005157 if( rc==SQLITE_OK ){
dan6572c162016-04-23 14:55:28 +00005158 rc = pager_playback(pPager, !pPager->tempFile);
dande1ae342010-08-06 12:00:27 +00005159 pPager->eState = PAGER_OPEN;
drh91781bd2010-04-10 17:52:57 +00005160 }
dan4e004aa2010-08-05 15:30:22 +00005161 }else if( !pPager->exclusiveMode ){
5162 pagerUnlockDb(pPager, SHARED_LOCK);
5163 }
5164
5165 if( rc!=SQLITE_OK ){
dande1ae342010-08-06 12:00:27 +00005166 /* This branch is taken if an error occurs while trying to open
5167 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
5168 ** pager_unlock() routine will be called before returning to unlock
5169 ** the file. If the unlock attempt fails, then Pager.eLock must be
5170 ** set to UNKNOWN_LOCK (see the comment above the #define for
5171 ** UNKNOWN_LOCK above for an explanation).
5172 **
5173 ** In order to get pager_unlock() to do this, set Pager.eState to
5174 ** PAGER_ERROR now. This is not actually counted as a transition
5175 ** to ERROR state in the state diagram at the top of this file,
5176 ** since we know that the same call to pager_unlock() will very
5177 ** shortly transition the pager object to the OPEN state. Calling
5178 ** assert_pager_state() would fail now, as it should not be possible
5179 ** to be in ERROR state when there are zero outstanding page
5180 ** references.
5181 */
dan4e004aa2010-08-05 15:30:22 +00005182 pager_error(pPager, rc);
5183 goto failed;
danielk1977b3175382008-10-17 18:51:52 +00005184 }
dand0864082010-08-02 14:32:52 +00005185
dande1ae342010-08-06 12:00:27 +00005186 assert( pPager->eState==PAGER_OPEN );
dand0864082010-08-02 14:32:52 +00005187 assert( (pPager->eLock==SHARED_LOCK)
5188 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
danielk1977b3175382008-10-17 18:51:52 +00005189 );
5190 }
5191
drhc98a4cc2015-09-03 17:54:32 +00005192 if( !pPager->tempFile && pPager->hasHeldSharedLock ){
drh542d5582014-12-31 14:18:48 +00005193 /* The shared-lock has just been acquired then check to
5194 ** see if the database has been modified. If the database has changed,
drhc98a4cc2015-09-03 17:54:32 +00005195 ** flush the cache. The hasHeldSharedLock flag prevents this from
drh542d5582014-12-31 14:18:48 +00005196 ** occurring on the very first access to a file, in order to save a
5197 ** single unnecessary sqlite3OsRead() call at the start-up.
danielk1977b3175382008-10-17 18:51:52 +00005198 **
drhb84c14d2015-06-28 17:33:11 +00005199 ** Database changes are detected by looking at 15 bytes beginning
danielk1977b3175382008-10-17 18:51:52 +00005200 ** at offset 24 into the file. The first 4 of these 16 bytes are
5201 ** a 32-bit counter that is incremented with each change. The
5202 ** other bytes change randomly with each file change when
5203 ** a codec is in use.
5204 **
5205 ** There is a vanishingly small chance that a change will not be
5206 ** detected. The chance of an undetected change is so small that
5207 ** it can be neglected.
5208 */
dan763afe62010-08-03 06:42:39 +00005209 Pgno nPage = 0;
danielk1977b3175382008-10-17 18:51:52 +00005210 char dbFileVers[sizeof(pPager->dbFileVers)];
danielk1977b3175382008-10-17 18:51:52 +00005211
dan763afe62010-08-03 06:42:39 +00005212 rc = pagerPagecount(pPager, &nPage);
5213 if( rc ) goto failed;
danielk1977e277be02007-03-23 18:12:06 +00005214
drhb1299152010-03-30 22:58:33 +00005215 if( nPage>0 ){
danielk1977b3175382008-10-17 18:51:52 +00005216 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
5217 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
dan11ac8462013-03-25 14:31:39 +00005218 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
danielk197752b472a2008-05-05 16:23:55 +00005219 goto failed;
danielk1977e277be02007-03-23 18:12:06 +00005220 }
danielk1977b3175382008-10-17 18:51:52 +00005221 }else{
5222 memset(dbFileVers, 0, sizeof(dbFileVers));
5223 }
danielk1977e277be02007-03-23 18:12:06 +00005224
danielk1977b3175382008-10-17 18:51:52 +00005225 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
5226 pager_reset(pPager);
dan11dcd112013-03-15 18:29:18 +00005227
5228 /* Unmap the database file. It is possible that external processes
5229 ** may have truncated the database file and then extended it back
5230 ** to its original size while this process was not holding a lock.
5231 ** In this case there may exist a Pager.pMap mapping that appears
5232 ** to be the right size but is not actually valid. Avoid this
5233 ** possibility by unmapping the db here. */
drh188d4882013-04-08 20:47:49 +00005234 if( USEFETCH(pPager) ){
dandf737fe2013-03-25 17:00:24 +00005235 sqlite3OsUnfetch(pPager->fd, 0, 0);
danf23da962013-03-23 21:00:41 +00005236 }
danielk1977e277be02007-03-23 18:12:06 +00005237 }
5238 }
dane04dc882010-04-20 18:53:15 +00005239
dan5cf53532010-05-01 16:40:20 +00005240 /* If there is a WAL file in the file-system, open this database in WAL
5241 ** mode. Otherwise, the following function call is a no-op.
5242 */
5243 rc = pagerOpenWalIfPresent(pPager);
shaneh9091f772010-08-24 18:35:12 +00005244#ifndef SQLITE_OMIT_WAL
dan22b328b2010-08-11 18:56:45 +00005245 assert( pPager->pWal==0 || rc==SQLITE_OK );
shaneh9091f772010-08-24 18:35:12 +00005246#endif
danielk1977e277be02007-03-23 18:12:06 +00005247 }
5248
dan22b328b2010-08-11 18:56:45 +00005249 if( pagerUseWal(pPager) ){
5250 assert( rc==SQLITE_OK );
dan763afe62010-08-03 06:42:39 +00005251 rc = pagerBeginReadTransaction(pPager);
5252 }
5253
dan6572c162016-04-23 14:55:28 +00005254 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
dan763afe62010-08-03 06:42:39 +00005255 rc = pagerPagecount(pPager, &pPager->dbSize);
5256 }
5257
danielk197752b472a2008-05-05 16:23:55 +00005258 failed:
5259 if( rc!=SQLITE_OK ){
dan22b328b2010-08-11 18:56:45 +00005260 assert( !MEMDB );
danielk197752b472a2008-05-05 16:23:55 +00005261 pager_unlock(pPager);
dande1ae342010-08-06 12:00:27 +00005262 assert( pPager->eState==PAGER_OPEN );
dan763afe62010-08-03 06:42:39 +00005263 }else{
5264 pPager->eState = PAGER_READER;
drhc98a4cc2015-09-03 17:54:32 +00005265 pPager->hasHeldSharedLock = 1;
danielk197752b472a2008-05-05 16:23:55 +00005266 }
danielk1977e277be02007-03-23 18:12:06 +00005267 return rc;
5268}
5269
5270/*
danielk1977bea2a942009-01-20 17:06:27 +00005271** If the reference count has reached zero, rollback any active
5272** transaction and unlock the pager.
drh59813952009-04-20 11:34:26 +00005273**
5274** Except, in locking_mode=EXCLUSIVE when there is nothing to in
5275** the rollback journal, the unlock is not performed and there is
5276** nothing to rollback, so this routine is a no-op.
danielk19778c0a7912008-08-20 14:49:23 +00005277*/
5278static void pagerUnlockIfUnused(Pager *pPager){
drh6d814492013-04-02 01:45:10 +00005279 if( pPager->nMmapOut==0 && (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
danielk19778c0a7912008-08-20 14:49:23 +00005280 pagerUnlockAndRollback(pPager);
5281 }
5282}
5283
5284/*
danielk1977bea2a942009-01-20 17:06:27 +00005285** Acquire a reference to page number pgno in pager pPager (a page
5286** reference has type DbPage*). If the requested reference is
5287** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
drhd9b02572001-04-15 00:37:09 +00005288**
danielk1977bea2a942009-01-20 17:06:27 +00005289** If the requested page is already in the cache, it is returned.
5290** Otherwise, a new page object is allocated and populated with data
5291** read from the database file. In some cases, the pcache module may
5292** choose not to allocate a new page object and may reuse an existing
5293** object with no outstanding references.
5294**
5295** The extra data appended to a page is always initialized to zeros the
5296** first time a page is loaded into memory. If the page requested is
5297** already in the cache when this function is called, then the extra
5298** data is left as it was when the page object was last used.
5299**
5300** If the database image is smaller than the requested page or if a
5301** non-zero value is passed as the noContent parameter and the
5302** requested page is not already stored in the cache, then no
5303** actual disk read occurs. In this case the memory image of the
5304** page is initialized to all zeros.
5305**
5306** If noContent is true, it means that we do not care about the contents
drhf7b54962013-05-28 12:11:54 +00005307** of the page. This occurs in two scenarios:
danielk1977bea2a942009-01-20 17:06:27 +00005308**
5309** a) When reading a free-list leaf page from the database, and
5310**
5311** b) When a savepoint is being rolled back and we need to load
drh91781bd2010-04-10 17:52:57 +00005312** a new page into the cache to be filled with the data read
danielk1977bea2a942009-01-20 17:06:27 +00005313** from the savepoint journal.
5314**
5315** If noContent is true, then the data returned is zeroed instead of
5316** being read from the database. Additionally, the bits corresponding
5317** to pgno in Pager.pInJournal (bitvec of pages already written to the
5318** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
5319** savepoints are set. This means if the page is made writable at any
5320** point in the future, using a call to sqlite3PagerWrite(), its contents
5321** will not be journaled. This saves IO.
drh306dc212001-05-21 13:45:10 +00005322**
drhd9b02572001-04-15 00:37:09 +00005323** The acquisition might fail for several reasons. In all cases,
5324** an appropriate error code is returned and *ppPage is set to NULL.
drh7e3b0a02001-04-28 16:52:40 +00005325**
drhd33d5a82007-04-26 12:11:28 +00005326** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
drh7e3b0a02001-04-28 16:52:40 +00005327** to find a page in the in-memory cache first. If the page is not already
drhd33d5a82007-04-26 12:11:28 +00005328** in memory, this routine goes to disk to read it in whereas Lookup()
drh7e3b0a02001-04-28 16:52:40 +00005329** just returns 0. This routine acquires a read-lock the first time it
5330** has to go to disk, and could also playback an old journal if necessary.
drhd33d5a82007-04-26 12:11:28 +00005331** Since Lookup() never goes to disk, it never has to deal with locks
drh7e3b0a02001-04-28 16:52:40 +00005332** or journal files.
drhed7c8552001-04-11 14:29:21 +00005333*/
drh9584f582015-11-04 20:22:37 +00005334int sqlite3PagerGet(
drh538f5702007-04-13 02:14:30 +00005335 Pager *pPager, /* The pager open on the database file */
5336 Pgno pgno, /* Page number to fetch */
5337 DbPage **ppPage, /* Write a pointer to the page here */
drhb00fc3b2013-08-21 23:42:32 +00005338 int flags /* PAGER_GET_XXX flags */
drh538f5702007-04-13 02:14:30 +00005339){
dan11dcd112013-03-15 18:29:18 +00005340 int rc = SQLITE_OK;
5341 PgHdr *pPg = 0;
dan99bd1092013-03-22 18:20:14 +00005342 u32 iFrame = 0; /* Frame to read from WAL file */
drhb00fc3b2013-08-21 23:42:32 +00005343 const int noContent = (flags & PAGER_GET_NOCONTENT);
dan11dcd112013-03-15 18:29:18 +00005344
5345 /* It is acceptable to use a read-only (mmap) page for any page except
5346 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
5347 ** flag was specified by the caller. And so long as the db is not a
5348 ** temporary or in-memory database. */
drh98c5f872015-09-03 18:20:10 +00005349 const int bMmapOk = (pgno>1 && USEFETCH(pPager)
drhb00fc3b2013-08-21 23:42:32 +00005350 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
drh0f234012013-04-16 14:52:47 +00005351#ifdef SQLITE_HAS_CODEC
5352 && pPager->xCodec==0
5353#endif
dan11dcd112013-03-15 18:29:18 +00005354 );
drhed7c8552001-04-11 14:29:21 +00005355
drh95a0b372015-09-03 20:43:55 +00005356 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
5357 ** allows the compiler optimizer to reuse the results of the "pgno>1"
5358 ** test in the previous statement, and avoid testing pgno==0 in the
5359 ** common case where pgno is large. */
drh98c5f872015-09-03 18:20:10 +00005360 if( pgno<=1 && pgno==0 ){
5361 return SQLITE_CORRUPT_BKPT;
5362 }
dand0864082010-08-02 14:32:52 +00005363 assert( pPager->eState>=PAGER_READER );
danielk1977bea2a942009-01-20 17:06:27 +00005364 assert( assert_pager_state(pPager) );
dan99bd1092013-03-22 18:20:14 +00005365 assert( noContent==0 || bMmapOk==0 );
danielk1977e277be02007-03-23 18:12:06 +00005366
drhc98a4cc2015-09-03 17:54:32 +00005367 assert( pPager->hasHeldSharedLock==1 );
danielk197726836652005-01-17 01:33:13 +00005368
danielk197789bc4bc2009-07-21 19:25:24 +00005369 /* If the pager is in the error state, return an error immediately.
5370 ** Otherwise, request the page from the PCache layer. */
dana81a2202010-08-17 18:15:48 +00005371 if( pPager->errCode!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00005372 rc = pPager->errCode;
5373 }else{
dan99bd1092013-03-22 18:20:14 +00005374 if( bMmapOk && pagerUseWal(pPager) ){
5375 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
5376 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5377 }
5378
drh1e983102013-12-08 19:54:52 +00005379 if( bMmapOk && iFrame==0 ){
danf23da962013-03-23 21:00:41 +00005380 void *pData = 0;
5381
5382 rc = sqlite3OsFetch(pPager->fd,
5383 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
5384 );
5385
5386 if( rc==SQLITE_OK && pData ){
dan2d36f062016-04-23 17:24:16 +00005387 if( pPager->eState>PAGER_READER || pPager->tempFile ){
drhbc59ac02014-08-27 23:18:01 +00005388 pPg = sqlite3PagerLookup(pPager, pgno);
dan11dcd112013-03-15 18:29:18 +00005389 }
5390 if( pPg==0 ){
danf23da962013-03-23 21:00:41 +00005391 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
5392 }else{
dandf737fe2013-03-25 17:00:24 +00005393 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
dan11dcd112013-03-15 18:29:18 +00005394 }
5395 if( pPg ){
5396 assert( rc==SQLITE_OK );
5397 *ppPage = pPg;
5398 return SQLITE_OK;
dan11dcd112013-03-15 18:29:18 +00005399 }
danb2d3de32013-03-14 18:34:37 +00005400 }
dan7af65472013-03-15 19:13:42 +00005401 if( rc!=SQLITE_OK ){
5402 goto pager_acquire_err;
5403 }
danb2d3de32013-03-14 18:34:37 +00005404 }
5405
drhbc59ac02014-08-27 23:18:01 +00005406 {
5407 sqlite3_pcache_page *pBase;
5408 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
5409 if( pBase==0 ){
5410 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
5411 if( rc!=SQLITE_OK ) goto pager_acquire_err;
drhd8c0ba32015-06-30 03:57:59 +00005412 if( pBase==0 ){
5413 pPg = *ppPage = 0;
mistachkinfad30392016-02-13 23:43:46 +00005414 rc = SQLITE_NOMEM_BKPT;
drhd8c0ba32015-06-30 03:57:59 +00005415 goto pager_acquire_err;
5416 }
drhbc59ac02014-08-27 23:18:01 +00005417 }
5418 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
drh31699062015-06-30 11:07:32 +00005419 assert( pPg!=0 );
drhbc59ac02014-08-27 23:18:01 +00005420 }
drhed7c8552001-04-11 14:29:21 +00005421 }
danielk1977e277be02007-03-23 18:12:06 +00005422
danielk19778c0a7912008-08-20 14:49:23 +00005423 if( rc!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00005424 /* Either the call to sqlite3PcacheFetch() returned an error or the
5425 ** pager was already in the error-state when this function was called.
5426 ** Set pPg to 0 and jump to the exception handler. */
5427 pPg = 0;
5428 goto pager_acquire_err;
danielk19778c0a7912008-08-20 14:49:23 +00005429 }
drhb84c14d2015-06-28 17:33:11 +00005430 assert( pPg==(*ppPage) );
5431 assert( pPg->pgno==pgno );
5432 assert( pPg->pPager==pPager || pPg->pPager==0 );
danielk197789bc4bc2009-07-21 19:25:24 +00005433
drhb84c14d2015-06-28 17:33:11 +00005434 if( pPg->pPager && !noContent ){
danielk197789bc4bc2009-07-21 19:25:24 +00005435 /* In this case the pcache already contains an initialized copy of
5436 ** the page. Return without further ado. */
danielk1977e878a2f2009-07-22 16:41:15 +00005437 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
drh9ad3ee42012-03-24 20:06:14 +00005438 pPager->aStat[PAGER_STAT_HIT]++;
danielk197789bc4bc2009-07-21 19:25:24 +00005439 return SQLITE_OK;
5440
5441 }else{
danielk19778c0a7912008-08-20 14:49:23 +00005442 /* The pager cache has created a new page. Its content needs to
danielk197789bc4bc2009-07-21 19:25:24 +00005443 ** be initialized. */
danielk197789bc4bc2009-07-21 19:25:24 +00005444
danielk19778c0a7912008-08-20 14:49:23 +00005445 pPg->pPager = pPager;
danielk197724168722007-04-02 05:07:47 +00005446
danielk197789bc4bc2009-07-21 19:25:24 +00005447 /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
5448 ** number greater than this, or the unused locking-page, is requested. */
5449 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
5450 rc = SQLITE_CORRUPT_BKPT;
5451 goto pager_acquire_err;
5452 }
5453
drh835f22d2016-04-25 19:20:56 +00005454 assert( !isOpen(pPager->fd) || !MEMDB );
5455 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
drhf8e632b2007-05-08 14:51:36 +00005456 if( pgno>pPager->mxPgno ){
dan7c246102010-04-12 19:00:29 +00005457 rc = SQLITE_FULL;
5458 goto pager_acquire_err;
drhf8e632b2007-05-08 14:51:36 +00005459 }
danielk1977a1fa00d2008-08-27 15:16:33 +00005460 if( noContent ){
danielk1977bea2a942009-01-20 17:06:27 +00005461 /* Failure to set the bits in the InJournal bit-vectors is benign.
5462 ** It merely means that we might do some extra work to journal a
5463 ** page that does not need to be journaled. Nevertheless, be sure
5464 ** to test the case where a malloc error occurs while trying to set
5465 ** a bit in a bit vector.
5466 */
5467 sqlite3BeginBenignMalloc();
drh8a938f92009-07-25 04:12:02 +00005468 if( pgno<=pPager->dbOrigSize ){
danielk1977bea2a942009-01-20 17:06:27 +00005469 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
5470 testcase( rc==SQLITE_NOMEM );
5471 }
5472 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
5473 testcase( rc==SQLITE_NOMEM );
5474 sqlite3EndBenignMalloc();
danielk19778c0a7912008-08-20 14:49:23 +00005475 }
drh39187952010-01-05 13:40:35 +00005476 memset(pPg->pData, 0, pPager->pageSize);
drh538f5702007-04-13 02:14:30 +00005477 IOTRACE(("ZERO %p %d\n", pPager, pgno));
drh306dc212001-05-21 13:45:10 +00005478 }else{
dan99bd1092013-03-22 18:20:14 +00005479 if( pagerUseWal(pPager) && bMmapOk==0 ){
5480 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
5481 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5482 }
danielk1977bea2a942009-01-20 17:06:27 +00005483 assert( pPg->pPager==pPager );
drh9ad3ee42012-03-24 20:06:14 +00005484 pPager->aStat[PAGER_STAT_MISS]++;
dan99bd1092013-03-22 18:20:14 +00005485 rc = readDbPage(pPg, iFrame);
danielk1977546820e2009-03-28 06:59:41 +00005486 if( rc!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00005487 goto pager_acquire_err;
drh81a20f22001-10-12 17:30:04 +00005488 }
drh306dc212001-05-21 13:45:10 +00005489 }
dan5f848c32010-08-23 18:19:31 +00005490 pager_set_pagehash(pPg);
drhed7c8552001-04-11 14:29:21 +00005491 }
danielk19778c0a7912008-08-20 14:49:23 +00005492
drhed7c8552001-04-11 14:29:21 +00005493 return SQLITE_OK;
danielk197789bc4bc2009-07-21 19:25:24 +00005494
5495pager_acquire_err:
5496 assert( rc!=SQLITE_OK );
danielk1977e878a2f2009-07-22 16:41:15 +00005497 if( pPg ){
5498 sqlite3PcacheDrop(pPg);
5499 }
danielk197789bc4bc2009-07-21 19:25:24 +00005500 pagerUnlockIfUnused(pPager);
danielk1977e878a2f2009-07-22 16:41:15 +00005501
danielk197789bc4bc2009-07-21 19:25:24 +00005502 *ppPage = 0;
5503 return rc;
drhed7c8552001-04-11 14:29:21 +00005504}
danielk19778c0a7912008-08-20 14:49:23 +00005505
drhed7c8552001-04-11 14:29:21 +00005506/*
drh7e3b0a02001-04-28 16:52:40 +00005507** Acquire a page if it is already in the in-memory cache. Do
5508** not read the page from disk. Return a pointer to the page,
dana81a2202010-08-17 18:15:48 +00005509** or 0 if the page is not in cache.
drh7e3b0a02001-04-28 16:52:40 +00005510**
danielk19773b8a05f2007-03-19 17:44:26 +00005511** See also sqlite3PagerGet(). The difference between this routine
5512** and sqlite3PagerGet() is that _get() will go to the disk and read
drh7e3b0a02001-04-28 16:52:40 +00005513** in the page if the page is not already in cache. This routine
drh5e00f6c2001-09-13 13:46:56 +00005514** returns NULL if the page is not in cache or if a disk I/O error
5515** has ever happened.
drh7e3b0a02001-04-28 16:52:40 +00005516*/
danielk19773b8a05f2007-03-19 17:44:26 +00005517DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
drhbc59ac02014-08-27 23:18:01 +00005518 sqlite3_pcache_page *pPage;
drh836faa42003-01-11 13:30:57 +00005519 assert( pPager!=0 );
5520 assert( pgno!=0 );
drhad7516c2009-07-24 16:32:00 +00005521 assert( pPager->pPCache!=0 );
drhbc59ac02014-08-27 23:18:01 +00005522 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
drhc98a4cc2015-09-03 17:54:32 +00005523 assert( pPage==0 || pPager->hasHeldSharedLock );
drhd8c0ba32015-06-30 03:57:59 +00005524 if( pPage==0 ) return 0;
drhbc59ac02014-08-27 23:18:01 +00005525 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
drh7e3b0a02001-04-28 16:52:40 +00005526}
5527
5528/*
danielk1977bea2a942009-01-20 17:06:27 +00005529** Release a page reference.
drhed7c8552001-04-11 14:29:21 +00005530**
5531** If the number of references to the page drop to zero, then the
5532** page is added to the LRU list. When all references to all pages
drhd9b02572001-04-15 00:37:09 +00005533** are released, a rollback occurs and the lock on the database is
drhed7c8552001-04-11 14:29:21 +00005534** removed.
5535*/
drhda8a3302013-12-13 19:35:21 +00005536void sqlite3PagerUnrefNotNull(DbPage *pPg){
5537 Pager *pPager;
5538 assert( pPg!=0 );
5539 pPager = pPg->pPager;
5540 if( pPg->flags & PGHDR_MMAP ){
5541 pagerReleaseMapPage(pPg);
5542 }else{
danielk19778c0a7912008-08-20 14:49:23 +00005543 sqlite3PcacheRelease(pPg);
drhed7c8552001-04-11 14:29:21 +00005544 }
drhda8a3302013-12-13 19:35:21 +00005545 pagerUnlockIfUnused(pPager);
5546}
5547void sqlite3PagerUnref(DbPage *pPg){
5548 if( pPg ) sqlite3PagerUnrefNotNull(pPg);
drhed7c8552001-04-11 14:29:21 +00005549}
5550
danielk19779153d852009-01-07 10:52:56 +00005551/*
danielk1977bea2a942009-01-20 17:06:27 +00005552** This function is called at the start of every write transaction.
5553** There must already be a RESERVED or EXCLUSIVE lock on the database
5554** file when this routine is called.
drhda47d772002-12-02 04:25:19 +00005555**
danielk1977bea2a942009-01-20 17:06:27 +00005556** Open the journal file for pager pPager and write a journal header
5557** to the start of it. If there are active savepoints, open the sub-journal
5558** as well. This function is only used when the journal file is being
5559** opened to write a rollback log for a transaction. It is not used
5560** when opening a hot journal file to roll it back.
5561**
5562** If the journal file is already open (as it may be in exclusive mode),
5563** then this function just writes a journal header to the start of the
5564** already open file.
5565**
5566** Whether or not the journal file is opened by this function, the
5567** Pager.pInJournal bitvec structure is allocated.
5568**
5569** Return SQLITE_OK if everything is successful. Otherwise, return
5570** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
5571** an IO error code if opening or writing the journal file fails.
drhda47d772002-12-02 04:25:19 +00005572*/
5573static int pager_open_journal(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00005574 int rc = SQLITE_OK; /* Return code */
5575 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
danielk1977b4b47412007-08-17 15:53:36 +00005576
dande1ae342010-08-06 12:00:27 +00005577 assert( pPager->eState==PAGER_WRITER_LOCKED );
dand0864082010-08-02 14:32:52 +00005578 assert( assert_pager_state(pPager) );
drhf5e7bb52008-02-18 14:47:33 +00005579 assert( pPager->pInJournal==0 );
danielk1977bea2a942009-01-20 17:06:27 +00005580
drhad7516c2009-07-24 16:32:00 +00005581 /* If already in the error state, this function is a no-op. But on
5582 ** the other hand, this routine is never called if we are already in
5583 ** an error state. */
5584 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977b4b47412007-08-17 15:53:36 +00005585
dand0864082010-08-02 14:32:52 +00005586 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
dan937ac9d2010-08-03 12:48:45 +00005587 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
dand0864082010-08-02 14:32:52 +00005588 if( pPager->pInJournal==0 ){
mistachkinfad30392016-02-13 23:43:46 +00005589 return SQLITE_NOMEM_BKPT;
danielk1977b3175382008-10-17 18:51:52 +00005590 }
dand0864082010-08-02 14:32:52 +00005591
5592 /* Open the journal file if it is not already open. */
5593 if( !isOpen(pPager->jfd) ){
5594 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
5595 sqlite3MemJournalOpen(pPager->jfd);
5596 }else{
dan9131ab92016-04-06 18:20:51 +00005597 int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
5598 int nSpill;
drh3fee8a62013-12-06 17:23:38 +00005599
drh2b78c0d2016-04-29 15:52:58 +00005600#if SQLITE_ENABLE_DATA_PROTECTION
drh04600b22016-05-03 02:43:50 +00005601 flags |= (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK);
drh2b78c0d2016-04-29 15:52:58 +00005602#endif
dan9131ab92016-04-06 18:20:51 +00005603 if( pPager->tempFile ){
5604 flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
5605 nSpill = sqlite3Config.nStmtSpill;
5606 }else{
5607 flags |= SQLITE_OPEN_MAIN_JOURNAL;
5608 nSpill = jrnlBufferSize(pPager);
5609 }
5610
drh3fee8a62013-12-06 17:23:38 +00005611 /* Verify that the database still has the same name as it did when
5612 ** it was originally opened. */
5613 rc = databaseIsUnmoved(pPager);
5614 if( rc==SQLITE_OK ){
dan9131ab92016-04-06 18:20:51 +00005615 rc = sqlite3JournalOpen (
5616 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
drh3fee8a62013-12-06 17:23:38 +00005617 );
drh3fee8a62013-12-06 17:23:38 +00005618 }
dand0864082010-08-02 14:32:52 +00005619 }
5620 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
5621 }
5622
5623
5624 /* Write the first journal header to the journal file and open
5625 ** the sub-journal if necessary.
5626 */
5627 if( rc==SQLITE_OK ){
5628 /* TODO: Check if all of these are really required. */
dand0864082010-08-02 14:32:52 +00005629 pPager->nRec = 0;
5630 pPager->journalOff = 0;
5631 pPager->setMaster = 0;
5632 pPager->journalHdr = 0;
5633 rc = writeJournalHdr(pPager);
5634 }
drhda47d772002-12-02 04:25:19 +00005635 }
drh9c105bb2004-10-02 20:38:28 +00005636
danielk1977bea2a942009-01-20 17:06:27 +00005637 if( rc!=SQLITE_OK ){
5638 sqlite3BitvecDestroy(pPager->pInJournal);
5639 pPager->pInJournal = 0;
dand0864082010-08-02 14:32:52 +00005640 }else{
dande1ae342010-08-06 12:00:27 +00005641 assert( pPager->eState==PAGER_WRITER_LOCKED );
dand0864082010-08-02 14:32:52 +00005642 pPager->eState = PAGER_WRITER_CACHEMOD;
danielk1977bea2a942009-01-20 17:06:27 +00005643 }
dand0864082010-08-02 14:32:52 +00005644
drh9c105bb2004-10-02 20:38:28 +00005645 return rc;
drhda47d772002-12-02 04:25:19 +00005646}
5647
5648/*
danielk1977bea2a942009-01-20 17:06:27 +00005649** Begin a write-transaction on the specified pager object. If a
5650** write-transaction has already been opened, this function is a no-op.
drh4b845d72002-03-05 12:41:19 +00005651**
danielk1977bea2a942009-01-20 17:06:27 +00005652** If the exFlag argument is false, then acquire at least a RESERVED
5653** lock on the database file. If exFlag is true, then acquire at least
5654** an EXCLUSIVE lock. If such a lock is already held, no locking
5655** functions need be called.
drh4b845d72002-03-05 12:41:19 +00005656**
danielk1977d8293352009-04-30 09:10:37 +00005657** If the subjInMemory argument is non-zero, then any sub-journal opened
5658** within this transaction will be opened as an in-memory file. This
5659** has no effect if the sub-journal is already opened (as it may be when
5660** running in exclusive mode) or if the transaction does not require a
5661** sub-journal. If the subjInMemory argument is zero, then any required
5662** sub-journal is implemented in-memory if pPager is an in-memory database,
5663** or using a temporary file otherwise.
drh4b845d72002-03-05 12:41:19 +00005664*/
danielk1977d8293352009-04-30 09:10:37 +00005665int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
drh4b845d72002-03-05 12:41:19 +00005666 int rc = SQLITE_OK;
drh719e3a72010-08-17 17:25:15 +00005667
drh89bd82a2010-08-17 19:49:14 +00005668 if( pPager->errCode ) return pPager->errCode;
drh719e3a72010-08-17 17:25:15 +00005669 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
shane60a4b532009-05-06 18:57:09 +00005670 pPager->subjInMemory = (u8)subjInMemory;
dan55437592010-05-11 12:19:26 +00005671
dan22b328b2010-08-11 18:56:45 +00005672 if( ALWAYS(pPager->eState==PAGER_READER) ){
drhf5e7bb52008-02-18 14:47:33 +00005673 assert( pPager->pInJournal==0 );
danielk1977bea2a942009-01-20 17:06:27 +00005674
drh7ed91f22010-04-29 22:34:07 +00005675 if( pagerUseWal(pPager) ){
dan55437592010-05-11 12:19:26 +00005676 /* If the pager is configured to use locking_mode=exclusive, and an
5677 ** exclusive lock on the database is not already held, obtain it now.
5678 */
drh61e4ace2010-05-31 20:28:37 +00005679 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
dan4e004aa2010-08-05 15:30:22 +00005680 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
dan55437592010-05-11 12:19:26 +00005681 if( rc!=SQLITE_OK ){
5682 return rc;
5683 }
drhb4acd6a2016-01-14 01:56:43 +00005684 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
dan55437592010-05-11 12:19:26 +00005685 }
5686
dan7c246102010-04-12 19:00:29 +00005687 /* Grab the write lock on the log file. If successful, upgrade to
dan55437592010-05-11 12:19:26 +00005688 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
dan7c246102010-04-12 19:00:29 +00005689 ** The busy-handler is not invoked if another connection already
5690 ** holds the write-lock. If possible, the upper layer will call it.
5691 */
drh73b64e42010-05-30 19:55:15 +00005692 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
dan64d039e2010-04-13 19:27:31 +00005693 }else{
5694 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
5695 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
5696 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
5697 ** lock, but not when obtaining the RESERVED lock.
5698 */
dan4e004aa2010-08-05 15:30:22 +00005699 rc = pagerLockDb(pPager, RESERVED_LOCK);
dand0864082010-08-02 14:32:52 +00005700 if( rc==SQLITE_OK && exFlag ){
5701 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
dan7c246102010-04-12 19:00:29 +00005702 }
5703 }
5704
dand0864082010-08-02 14:32:52 +00005705 if( rc==SQLITE_OK ){
dande1ae342010-08-06 12:00:27 +00005706 /* Change to WRITER_LOCKED state.
dand0864082010-08-02 14:32:52 +00005707 **
dande1ae342010-08-06 12:00:27 +00005708 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
dand0864082010-08-02 14:32:52 +00005709 ** when it has an open transaction, but never to DBMOD or FINISHED.
5710 ** This is because in those states the code to roll back savepoint
5711 ** transactions may copy data from the sub-journal into the database
5712 ** file as well as into the page cache. Which would be incorrect in
5713 ** WAL mode.
5714 */
dande1ae342010-08-06 12:00:27 +00005715 pPager->eState = PAGER_WRITER_LOCKED;
danc8649122010-08-10 09:58:57 +00005716 pPager->dbHintSize = pPager->dbSize;
5717 pPager->dbFileSize = pPager->dbSize;
5718 pPager->dbOrigSize = pPager->dbSize;
dand0864082010-08-02 14:32:52 +00005719 pPager->journalOff = 0;
dan3ad5fd22010-06-30 04:36:03 +00005720 }
dand0864082010-08-02 14:32:52 +00005721
5722 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
dande1ae342010-08-06 12:00:27 +00005723 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
dand0864082010-08-02 14:32:52 +00005724 assert( assert_pager_state(pPager) );
drh4b845d72002-03-05 12:41:19 +00005725 }
danielk1977bea2a942009-01-20 17:06:27 +00005726
5727 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
drh4b845d72002-03-05 12:41:19 +00005728 return rc;
5729}
5730
5731/*
drh82ef8772015-06-29 14:11:50 +00005732** Write page pPg onto the end of the rollback journal.
5733*/
5734static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
5735 Pager *pPager = pPg->pPager;
5736 int rc;
5737 u32 cksum;
5738 char *pData2;
5739 i64 iOff = pPager->journalOff;
5740
5741 /* We should never write to the journal file the page that
5742 ** contains the database locks. The following assert verifies
5743 ** that we do not. */
5744 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
5745
5746 assert( pPager->journalHdr<=pPager->journalOff );
mistachkinfad30392016-02-13 23:43:46 +00005747 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
drh82ef8772015-06-29 14:11:50 +00005748 cksum = pager_cksum(pPager, (u8*)pData2);
5749
5750 /* Even if an IO or diskfull error occurs while journalling the
5751 ** page in the block above, set the need-sync flag for the page.
5752 ** Otherwise, when the transaction is rolled back, the logic in
5753 ** playback_one_page() will think that the page needs to be restored
5754 ** in the database file. And if an IO error occurs while doing so,
5755 ** then corruption may follow.
5756 */
5757 pPg->flags |= PGHDR_NEED_SYNC;
5758
5759 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
5760 if( rc!=SQLITE_OK ) return rc;
5761 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
5762 if( rc!=SQLITE_OK ) return rc;
5763 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
5764 if( rc!=SQLITE_OK ) return rc;
5765
5766 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
5767 pPager->journalOff, pPager->pageSize));
5768 PAGER_INCR(sqlite3_pager_writej_count);
5769 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
5770 PAGERID(pPager), pPg->pgno,
5771 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
5772
5773 pPager->journalOff += 8 + pPager->pageSize;
5774 pPager->nRec++;
5775 assert( pPager->pInJournal!=0 );
5776 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
5777 testcase( rc==SQLITE_NOMEM );
5778 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
5779 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
5780 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
5781 return rc;
5782}
5783
5784/*
danielk1977bea2a942009-01-20 17:06:27 +00005785** Mark a single data page as writeable. The page is written into the
5786** main journal or sub-journal as required. If the page is written into
5787** one of the journals, the corresponding bit is set in the
5788** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
5789** of any open savepoints as appropriate.
drhed7c8552001-04-11 14:29:21 +00005790*/
danielk19773b8a05f2007-03-19 17:44:26 +00005791static int pager_write(PgHdr *pPg){
drh69688d52001-04-14 16:38:23 +00005792 Pager *pPager = pPg->pPager;
drhd79caeb2001-04-15 02:27:24 +00005793 int rc = SQLITE_OK;
drh69688d52001-04-14 16:38:23 +00005794
dand0864082010-08-02 14:32:52 +00005795 /* This routine is not called unless a write-transaction has already
5796 ** been started. The journal file may or may not be open at this point.
dana42c66b2010-08-03 18:18:41 +00005797 ** It is never called in the ERROR state.
drh5e1fa032009-07-25 15:24:13 +00005798 */
dande1ae342010-08-06 12:00:27 +00005799 assert( pPager->eState==PAGER_WRITER_LOCKED
dana42c66b2010-08-03 18:18:41 +00005800 || pPager->eState==PAGER_WRITER_CACHEMOD
5801 || pPager->eState==PAGER_WRITER_DBMOD
5802 );
dand0864082010-08-02 14:32:52 +00005803 assert( assert_pager_state(pPager) );
drhc65faab2013-12-09 19:25:28 +00005804 assert( pPager->errCode==0 );
5805 assert( pPager->readOnly==0 );
danielk19773c407372005-02-15 02:54:14 +00005806 CHECK_PAGE(pPg);
5807
dan96b958a2010-10-05 17:02:47 +00005808 /* The journal file needs to be opened. Higher level routines have already
5809 ** obtained the necessary locks to begin the write-transaction, but the
5810 ** rollback journal might not yet be open. Open it now if this is the case.
5811 **
5812 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
5813 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
5814 ** an error might occur and the pager would end up in WRITER_LOCKED state
5815 ** with pages marked as dirty in the cache.
5816 */
5817 if( pPager->eState==PAGER_WRITER_LOCKED ){
5818 rc = pager_open_journal(pPager);
5819 if( rc!=SQLITE_OK ) return rc;
5820 }
5821 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
5822 assert( assert_pager_state(pPager) );
5823
drh82ef8772015-06-29 14:11:50 +00005824 /* Mark the page that is about to be modified as dirty. */
drhc047b9f2008-11-21 03:23:43 +00005825 sqlite3PcacheMakeDirty(pPg);
danielk1977dd97a492007-08-22 18:54:32 +00005826
drh82ef8772015-06-29 14:11:50 +00005827 /* If a rollback journal is in use, them make sure the page that is about
5828 ** to change is in the rollback journal, or if the page is a new page off
5829 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
5830 */
5831 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
drhe399ac22015-06-29 18:14:02 +00005832 if( pPager->pInJournal!=0
5833 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
drh82ef8772015-06-29 14:11:50 +00005834 ){
5835 assert( pagerUseWal(pPager)==0 );
5836 if( pPg->pgno<=pPager->dbOrigSize ){
5837 rc = pagerAddPageToRollbackJournal(pPg);
5838 if( rc!=SQLITE_OK ){
5839 return rc;
danielk1977a0bf2652004-11-04 14:30:04 +00005840 }
drh82ef8772015-06-29 14:11:50 +00005841 }else{
5842 if( pPager->eState!=PAGER_WRITER_DBMOD ){
5843 pPg->flags |= PGHDR_NEED_SYNC;
5844 }
5845 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
5846 PAGERID(pPager), pPg->pgno,
5847 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
drhd9b02572001-04-15 00:37:09 +00005848 }
drhfa86c412002-02-02 15:01:15 +00005849 }
5850
drh1aacbdb2015-06-29 18:29:10 +00005851 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
5852 ** and before writing the page into the rollback journal. Wait until now,
5853 ** after the page has been successfully journalled, before setting the
5854 ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
drhfa86c412002-02-02 15:01:15 +00005855 */
drh1aacbdb2015-06-29 18:29:10 +00005856 pPg->flags |= PGHDR_WRITEABLE;
drh82ef8772015-06-29 14:11:50 +00005857
5858 /* If the statement journal is open and the page is not in it,
5859 ** then write the page into the statement journal.
drh69688d52001-04-14 16:38:23 +00005860 */
drh60e32ed2015-06-29 19:08:18 +00005861 if( pPager->nSavepoint>0 ){
5862 rc = subjournalPageIfRequired(pPg);
drh82ef8772015-06-29 14:11:50 +00005863 }
5864
5865 /* Update the database size and return. */
danielk1977d92db532008-11-17 04:56:24 +00005866 if( pPager->dbSize<pPg->pgno ){
drh306dc212001-05-21 13:45:10 +00005867 pPager->dbSize = pPg->pgno;
5868 }
drh69688d52001-04-14 16:38:23 +00005869 return rc;
drhed7c8552001-04-11 14:29:21 +00005870}
5871
5872/*
drhf063e082014-08-24 01:32:43 +00005873** This is a variant of sqlite3PagerWrite() that runs when the sector size
5874** is larger than the page size. SQLite makes the (reasonable) assumption that
5875** all bytes of a sector are written together by hardware. Hence, all bytes of
5876** a sector need to be journalled in case of a power loss in the middle of
5877** a write.
5878**
5879** Usually, the sector size is less than or equal to the page size, in which
drhe399ac22015-06-29 18:14:02 +00005880** case pages can be individually written. This routine only runs in the
5881** exceptional case where the page size is smaller than the sector size.
drhf063e082014-08-24 01:32:43 +00005882*/
5883static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
drhe399ac22015-06-29 18:14:02 +00005884 int rc = SQLITE_OK; /* Return code */
5885 Pgno nPageCount; /* Total number of pages in database file */
5886 Pgno pg1; /* First page of the sector pPg is located on. */
5887 int nPage = 0; /* Number of pages starting at pg1 to journal */
5888 int ii; /* Loop counter */
5889 int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */
5890 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
drhf063e082014-08-24 01:32:43 +00005891 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
5892
5893 /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
5894 ** a journal header to be written between the pages journaled by
5895 ** this function.
5896 */
5897 assert( !MEMDB );
5898 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
5899 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
5900
5901 /* This trick assumes that both the page-size and sector-size are
5902 ** an integer power of 2. It sets variable pg1 to the identifier
5903 ** of the first page of the sector pPg is located on.
5904 */
5905 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
5906
5907 nPageCount = pPager->dbSize;
5908 if( pPg->pgno>nPageCount ){
5909 nPage = (pPg->pgno - pg1)+1;
5910 }else if( (pg1+nPagePerSector-1)>nPageCount ){
5911 nPage = nPageCount+1-pg1;
5912 }else{
5913 nPage = nPagePerSector;
5914 }
5915 assert(nPage>0);
5916 assert(pg1<=pPg->pgno);
5917 assert((pg1+nPage)>pPg->pgno);
5918
5919 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
5920 Pgno pg = pg1+ii;
5921 PgHdr *pPage;
5922 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
5923 if( pg!=PAGER_MJ_PGNO(pPager) ){
drh9584f582015-11-04 20:22:37 +00005924 rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
drhf063e082014-08-24 01:32:43 +00005925 if( rc==SQLITE_OK ){
5926 rc = pager_write(pPage);
5927 if( pPage->flags&PGHDR_NEED_SYNC ){
5928 needSync = 1;
5929 }
5930 sqlite3PagerUnrefNotNull(pPage);
5931 }
5932 }
drhc1378072014-08-25 11:33:41 +00005933 }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
drhf063e082014-08-24 01:32:43 +00005934 if( pPage->flags&PGHDR_NEED_SYNC ){
5935 needSync = 1;
5936 }
5937 sqlite3PagerUnrefNotNull(pPage);
5938 }
5939 }
5940
5941 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
5942 ** starting at pg1, then it needs to be set for all of them. Because
5943 ** writing to any of these nPage pages may damage the others, the
5944 ** journal file must contain sync()ed copies of all of them
5945 ** before any of them can be written out to the database file.
5946 */
5947 if( rc==SQLITE_OK && needSync ){
5948 assert( !MEMDB );
5949 for(ii=0; ii<nPage; ii++){
drhc1378072014-08-25 11:33:41 +00005950 PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
drhf063e082014-08-24 01:32:43 +00005951 if( pPage ){
5952 pPage->flags |= PGHDR_NEED_SYNC;
5953 sqlite3PagerUnrefNotNull(pPage);
5954 }
5955 }
5956 }
5957
5958 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
5959 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
5960 return rc;
5961}
5962
5963/*
danielk1977bea2a942009-01-20 17:06:27 +00005964** Mark a data page as writeable. This routine must be called before
5965** making changes to a page. The caller must check the return value
5966** of this function and be careful not to change any page data unless
5967** this routine returns SQLITE_OK.
danielk19774099f6e2007-03-19 11:25:20 +00005968**
5969** The difference between this function and pager_write() is that this
5970** function also deals with the special case where 2 or more pages
5971** fit on a single disk sector. In this case all co-resident pages
5972** must have been written to the journal file before returning.
danielk1977bea2a942009-01-20 17:06:27 +00005973**
5974** If an error occurs, SQLITE_NOMEM or an IO error code is returned
5975** as appropriate. Otherwise, SQLITE_OK.
danielk19774099f6e2007-03-19 11:25:20 +00005976*/
drhf063e082014-08-24 01:32:43 +00005977int sqlite3PagerWrite(PgHdr *pPg){
drhb3475532015-06-29 20:53:18 +00005978 Pager *pPager = pPg->pPager;
dan11dcd112013-03-15 18:29:18 +00005979 assert( (pPg->flags & PGHDR_MMAP)==0 );
drh50642b12015-06-30 03:34:13 +00005980 assert( pPager->eState>=PAGER_WRITER_LOCKED );
drh50642b12015-06-30 03:34:13 +00005981 assert( assert_pager_state(pPager) );
dan5596eb32015-10-30 14:28:16 +00005982 if( pPager->errCode ){
5983 return pPager->errCode;
5984 }else if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
drhb3475532015-06-29 20:53:18 +00005985 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
5986 return SQLITE_OK;
5987 }else if( pPager->sectorSize > (u32)pPager->pageSize ){
dan41113b62016-04-05 21:07:58 +00005988 assert( pPager->tempFile==0 );
drhf063e082014-08-24 01:32:43 +00005989 return pagerWriteLargeSector(pPg);
danielk19774099f6e2007-03-19 11:25:20 +00005990 }else{
drhf063e082014-08-24 01:32:43 +00005991 return pager_write(pPg);
danielk19774099f6e2007-03-19 11:25:20 +00005992 }
danielk19774099f6e2007-03-19 11:25:20 +00005993}
5994
5995/*
drhaacc5432002-01-06 17:07:40 +00005996** Return TRUE if the page given in the argument was previously passed
danielk19773b8a05f2007-03-19 17:44:26 +00005997** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
drh6019e162001-07-02 17:51:45 +00005998** to change the content of the page.
5999*/
danielk19777d3a6662006-01-23 16:21:05 +00006000#ifndef NDEBUG
danielk19773b8a05f2007-03-19 17:44:26 +00006001int sqlite3PagerIswriteable(DbPage *pPg){
drh1aacbdb2015-06-29 18:29:10 +00006002 return pPg->flags & PGHDR_WRITEABLE;
drh6019e162001-07-02 17:51:45 +00006003}
danielk19777d3a6662006-01-23 16:21:05 +00006004#endif
drh6019e162001-07-02 17:51:45 +00006005
drh001bbcb2003-03-19 03:14:00 +00006006/*
drh30e58752002-03-02 20:41:57 +00006007** A call to this routine tells the pager that it is not necessary to
drh538f5702007-04-13 02:14:30 +00006008** write the information on page pPg back to the disk, even though
drhdfe88ec2008-11-03 20:55:06 +00006009** that page might be marked as dirty. This happens, for example, when
6010** the page has been added as a leaf of the freelist and so its
6011** content no longer matters.
drh30e58752002-03-02 20:41:57 +00006012**
6013** The overlying software layer calls this routine when all of the data
danielk1977bea2a942009-01-20 17:06:27 +00006014** on the given page is unused. The pager marks the page as clean so
drh30e58752002-03-02 20:41:57 +00006015** that it does not get written to disk.
6016**
danielk1977bea2a942009-01-20 17:06:27 +00006017** Tests show that this optimization can quadruple the speed of large
6018** DELETE operations.
danc88ae522016-05-04 11:28:03 +00006019**
6020** This optimization cannot be used with a temp-file, as the page may
6021** have been dirty at the start of the transaction. In that case, if
6022** memory pressure forces page pPg out of the cache, the data does need
6023** to be written out to disk so that it may be read back in if the
6024** current transaction is rolled back.
drh30e58752002-03-02 20:41:57 +00006025*/
danielk1977bea2a942009-01-20 17:06:27 +00006026void sqlite3PagerDontWrite(PgHdr *pPg){
drh538f5702007-04-13 02:14:30 +00006027 Pager *pPager = pPg->pPager;
danc88ae522016-05-04 11:28:03 +00006028 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
danielk1977bea2a942009-01-20 17:06:27 +00006029 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
6030 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
6031 pPg->flags |= PGHDR_DONT_WRITE;
drhb3475532015-06-29 20:53:18 +00006032 pPg->flags &= ~PGHDR_WRITEABLE;
drha0f6b122016-05-13 15:22:06 +00006033 testcase( pPg->flags & PGHDR_NEED_SYNC );
dan5f848c32010-08-23 18:19:31 +00006034 pager_set_pagehash(pPg);
danielk197745d68822009-01-16 16:23:38 +00006035 }
drh30e58752002-03-02 20:41:57 +00006036}
6037
6038/*
danielk1977bea2a942009-01-20 17:06:27 +00006039** This routine is called to increment the value of the database file
6040** change-counter, stored as a 4-byte big-endian integer starting at
drh54a73472011-01-15 18:11:12 +00006041** byte offset 24 of the pager file. The secondary change counter at
6042** 92 is also updated, as is the SQLite version number at offset 96.
6043**
6044** But this only happens if the pPager->changeCountDone flag is false.
6045** To avoid excess churning of page 1, the update only happens once.
6046** See also the pager_write_changecounter() routine that does an
6047** unconditional update of the change counters.
danielk197745d68822009-01-16 16:23:38 +00006048**
drhb480dc22009-07-24 12:35:57 +00006049** If the isDirectMode flag is zero, then this is done by calling
danielk1977bea2a942009-01-20 17:06:27 +00006050** sqlite3PagerWrite() on page 1, then modifying the contents of the
6051** page data. In this case the file will be updated when the current
6052** transaction is committed.
6053**
drhb480dc22009-07-24 12:35:57 +00006054** The isDirectMode flag may only be non-zero if the library was compiled
danielk1977bea2a942009-01-20 17:06:27 +00006055** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
6056** if isDirect is non-zero, then the database file is updated directly
6057** by writing an updated version of page 1 using a call to the
6058** sqlite3OsWrite() function.
danielk197745d68822009-01-16 16:23:38 +00006059*/
danielk1977bea2a942009-01-20 17:06:27 +00006060static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
danielk1977c7b60172007-08-22 11:22:03 +00006061 int rc = SQLITE_OK;
drh80e35f42007-03-30 14:06:34 +00006062
dand0864082010-08-02 14:32:52 +00006063 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6064 || pPager->eState==PAGER_WRITER_DBMOD
6065 );
6066 assert( assert_pager_state(pPager) );
6067
danielk1977bea2a942009-01-20 17:06:27 +00006068 /* Declare and initialize constant integer 'isDirect'. If the
6069 ** atomic-write optimization is enabled in this build, then isDirect
6070 ** is initialized to the value passed as the isDirectMode parameter
6071 ** to this function. Otherwise, it is always set to zero.
6072 **
6073 ** The idea is that if the atomic-write optimization is not
6074 ** enabled at compile time, the compiler can omit the tests of
6075 ** 'isDirect' below, as well as the block enclosed in the
6076 ** "if( isDirect )" condition.
6077 */
drh701bb3b2008-08-02 03:50:39 +00006078#ifndef SQLITE_ENABLE_ATOMIC_WRITE
drhb480dc22009-07-24 12:35:57 +00006079# define DIRECT_MODE 0
danielk1977bea2a942009-01-20 17:06:27 +00006080 assert( isDirectMode==0 );
drhdc86e2b2009-01-24 11:30:42 +00006081 UNUSED_PARAMETER(isDirectMode);
danielk1977bea2a942009-01-20 17:06:27 +00006082#else
drhb480dc22009-07-24 12:35:57 +00006083# define DIRECT_MODE isDirectMode
drh701bb3b2008-08-02 03:50:39 +00006084#endif
danielk1977bea2a942009-01-20 17:06:27 +00006085
drhaa2db792012-10-13 20:55:12 +00006086 if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
danielk1977bea2a942009-01-20 17:06:27 +00006087 PgHdr *pPgHdr; /* Reference to page 1 */
danielk1977bea2a942009-01-20 17:06:27 +00006088
6089 assert( !pPager->tempFile && isOpen(pPager->fd) );
6090
drh80e35f42007-03-30 14:06:34 +00006091 /* Open page 1 of the file for writing. */
drh9584f582015-11-04 20:22:37 +00006092 rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0);
danielk1977bea2a942009-01-20 17:06:27 +00006093 assert( pPgHdr==0 || rc==SQLITE_OK );
danielk1977c7b60172007-08-22 11:22:03 +00006094
danielk1977bea2a942009-01-20 17:06:27 +00006095 /* If page one was fetched successfully, and this function is not
drhad7516c2009-07-24 16:32:00 +00006096 ** operating in direct-mode, make page 1 writable. When not in
6097 ** direct mode, page 1 is always held in cache and hence the PagerGet()
6098 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
danielk1977bea2a942009-01-20 17:06:27 +00006099 */
drhc5aae5c2011-01-17 02:24:12 +00006100 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
danielk1977c7b60172007-08-22 11:22:03 +00006101 rc = sqlite3PagerWrite(pPgHdr);
danielk1977bea2a942009-01-20 17:06:27 +00006102 }
6103
6104 if( rc==SQLITE_OK ){
drh54a73472011-01-15 18:11:12 +00006105 /* Actually do the update of the change counter */
6106 pager_write_changecounter(pPgHdr);
drhf92a4e32010-03-19 16:55:47 +00006107
danielk1977bea2a942009-01-20 17:06:27 +00006108 /* If running in direct mode, write the contents of page 1 to the file. */
drhb480dc22009-07-24 12:35:57 +00006109 if( DIRECT_MODE ){
dan68928b62010-06-22 13:46:43 +00006110 const void *zBuf;
danielk1977bea2a942009-01-20 17:06:27 +00006111 assert( pPager->dbFileSize>0 );
mistachkinfad30392016-02-13 23:43:46 +00006112 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM_BKPT, zBuf);
dan68928b62010-06-22 13:46:43 +00006113 if( rc==SQLITE_OK ){
6114 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
drh9ad3ee42012-03-24 20:06:14 +00006115 pPager->aStat[PAGER_STAT_WRITE]++;
dan68928b62010-06-22 13:46:43 +00006116 }
drhb480dc22009-07-24 12:35:57 +00006117 if( rc==SQLITE_OK ){
dan8e4714b2013-04-26 18:36:58 +00006118 /* Update the pager's copy of the change-counter. Otherwise, the
6119 ** next time a read transaction is opened the cache will be
6120 ** flushed (as the change-counter values will not match). */
6121 const void *pCopy = (const void *)&((const char *)zBuf)[24];
6122 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
drhb480dc22009-07-24 12:35:57 +00006123 pPager->changeCountDone = 1;
6124 }
6125 }else{
danielk1977bea2a942009-01-20 17:06:27 +00006126 pPager->changeCountDone = 1;
danielk1977ae72d982007-10-03 08:46:44 +00006127 }
danielk1977c7b60172007-08-22 11:22:03 +00006128 }
6129
drh80e35f42007-03-30 14:06:34 +00006130 /* Release the page reference. */
6131 sqlite3PagerUnref(pPgHdr);
drh80e35f42007-03-30 14:06:34 +00006132 }
danielk1977c7b60172007-08-22 11:22:03 +00006133 return rc;
drh80e35f42007-03-30 14:06:34 +00006134}
6135
6136/*
drhc97d8462010-11-19 18:23:35 +00006137** Sync the database file to disk. This is a no-op for in-memory databases
danielk1977bea2a942009-01-20 17:06:27 +00006138** or pages with the Pager.noSync flag set.
6139**
drhc97d8462010-11-19 18:23:35 +00006140** If successful, or if called on a pager for which it is a no-op, this
danielk1977bea2a942009-01-20 17:06:27 +00006141** function returns SQLITE_OK. Otherwise, an IO error code is returned.
danielk1977f653d782008-03-20 11:04:21 +00006142*/
dan999cd082013-12-09 20:42:03 +00006143int sqlite3PagerSync(Pager *pPager, const char *zMaster){
drh534a58a2011-01-25 16:48:56 +00006144 int rc = SQLITE_OK;
dan999cd082013-12-09 20:42:03 +00006145
6146 if( isOpen(pPager->fd) ){
6147 void *pArg = (void*)zMaster;
dan6f68f162013-12-10 17:34:53 +00006148 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
dan999cd082013-12-09 20:42:03 +00006149 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
6150 }
dana01abc32013-12-10 16:27:59 +00006151 if( rc==SQLITE_OK && !pPager->noSync ){
dand1cf7e22011-01-25 11:33:01 +00006152 assert( !MEMDB );
drhc97d8462010-11-19 18:23:35 +00006153 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
dan354bfe02011-01-11 17:39:37 +00006154 }
danielk1977f653d782008-03-20 11:04:21 +00006155 return rc;
6156}
6157
6158/*
daneb9444a2010-07-30 10:02:24 +00006159** This function may only be called while a write-transaction is active in
6160** rollback. If the connection is in WAL mode, this call is a no-op.
6161** Otherwise, if the connection does not already have an EXCLUSIVE lock on
6162** the database file, an attempt is made to obtain one.
6163**
6164** If the EXCLUSIVE lock is already held or the attempt to obtain it is
6165** successful, or the connection is in WAL mode, SQLITE_OK is returned.
6166** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
6167** returned.
6168*/
6169int sqlite3PagerExclusiveLock(Pager *pPager){
dandbf67732015-10-29 18:16:40 +00006170 int rc = pPager->errCode;
dand0864082010-08-02 14:32:52 +00006171 assert( assert_pager_state(pPager) );
dandbf67732015-10-29 18:16:40 +00006172 if( rc==SQLITE_OK ){
6173 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6174 || pPager->eState==PAGER_WRITER_DBMOD
6175 || pPager->eState==PAGER_WRITER_LOCKED
6176 );
6177 assert( assert_pager_state(pPager) );
6178 if( 0==pagerUseWal(pPager) ){
6179 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
6180 }
daneb9444a2010-07-30 10:02:24 +00006181 }
6182 return rc;
6183}
6184
6185/*
drh80e35f42007-03-30 14:06:34 +00006186** Sync the database file for the pager pPager. zMaster points to the name
6187** of a master journal file that should be written into the individual
6188** journal file. zMaster may be NULL, which is interpreted as no master
6189** journal (a single database transaction).
6190**
danielk1977bea2a942009-01-20 17:06:27 +00006191** This routine ensures that:
6192**
6193** * The database file change-counter is updated,
6194** * the journal is synced (unless the atomic-write optimization is used),
6195** * all dirty pages are written to the database file,
6196** * the database file is truncated (if required), and
6197** * the database file synced.
6198**
6199** The only thing that remains to commit the transaction is to finalize
6200** (delete, truncate or zero the first part of) the journal file (or
6201** delete the master journal file if specified).
drh80e35f42007-03-30 14:06:34 +00006202**
6203** Note that if zMaster==NULL, this does not overwrite a previous value
6204** passed to an sqlite3PagerCommitPhaseOne() call.
6205**
danielk1977f653d782008-03-20 11:04:21 +00006206** If the final parameter - noSync - is true, then the database file itself
6207** is not synced. The caller must call sqlite3PagerSync() directly to
6208** sync the database file before calling CommitPhaseTwo() to delete the
6209** journal file in this case.
drh80e35f42007-03-30 14:06:34 +00006210*/
danielk1977f653d782008-03-20 11:04:21 +00006211int sqlite3PagerCommitPhaseOne(
danielk1977bea2a942009-01-20 17:06:27 +00006212 Pager *pPager, /* Pager object */
6213 const char *zMaster, /* If not NULL, the master journal name */
6214 int noSync /* True to omit the xSync on the db file */
danielk1977f653d782008-03-20 11:04:21 +00006215){
danielk1977bea2a942009-01-20 17:06:27 +00006216 int rc = SQLITE_OK; /* Return code */
drh80e35f42007-03-30 14:06:34 +00006217
dande1ae342010-08-06 12:00:27 +00006218 assert( pPager->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +00006219 || pPager->eState==PAGER_WRITER_CACHEMOD
6220 || pPager->eState==PAGER_WRITER_DBMOD
dan5db56402010-08-06 13:53:09 +00006221 || pPager->eState==PAGER_ERROR
dand0864082010-08-02 14:32:52 +00006222 );
6223 assert( assert_pager_state(pPager) );
6224
drhdd3cd972010-03-27 17:12:36 +00006225 /* If a prior error occurred, report that error again. */
drh719e3a72010-08-17 17:25:15 +00006226 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977dad31b52008-05-15 11:08:07 +00006227
drhead01fd2016-04-25 22:39:42 +00006228 /* Provide the ability to easily simulate an I/O error during testing */
drha7a45972016-05-12 19:05:35 +00006229 if( sqlite3FaultSim(400) ) return SQLITE_IOERR;
drhead01fd2016-04-25 22:39:42 +00006230
drh30d53702009-01-06 15:58:57 +00006231 PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
6232 pPager->zFilename, zMaster, pPager->dbSize));
drh80e35f42007-03-30 14:06:34 +00006233
dand0864082010-08-02 14:32:52 +00006234 /* If no database changes have been made, return early. */
6235 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
6236
dan41113b62016-04-05 21:07:58 +00006237 assert( MEMDB==0 || pPager->tempFile );
dan199f56b2016-04-12 19:09:29 +00006238 assert( isOpen(pPager->fd) || pPager->tempFile );
drh4bf7d212016-05-13 12:12:38 +00006239 if( 0==pagerFlushOnCommit(pPager, 1) ){
drhb480dc22009-07-24 12:35:57 +00006240 /* If this is an in-memory db, or no pages have been written to, or this
6241 ** function has already been called, it is mostly a no-op. However, any
dan41113b62016-04-05 21:07:58 +00006242 ** backup in progress needs to be restarted. */
danielk197704103022009-02-03 16:51:24 +00006243 sqlite3BackupRestart(pPager->pBackup);
dand0864082010-08-02 14:32:52 +00006244 }else{
drh7ed91f22010-04-29 22:34:07 +00006245 if( pagerUseWal(pPager) ){
dan7c246102010-04-12 19:00:29 +00006246 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
drhe5a13202011-05-19 01:21:42 +00006247 PgHdr *pPageOne = 0;
6248 if( pList==0 ){
6249 /* Must have at least one page for the WAL commit flag.
6250 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
drh9584f582015-11-04 20:22:37 +00006251 rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0);
drhe5a13202011-05-19 01:21:42 +00006252 pList = pPageOne;
6253 pList->pDirty = 0;
6254 }
drh14438d12011-05-20 01:49:30 +00006255 assert( rc==SQLITE_OK );
6256 if( ALWAYS(pList) ){
drh4eb02a42011-12-16 21:26:26 +00006257 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
danielk197771aa7ff2008-05-20 07:05:09 +00006258 }
drhe5a13202011-05-19 01:21:42 +00006259 sqlite3PagerUnref(pPageOne);
dan10ec8942010-06-02 17:15:24 +00006260 if( rc==SQLITE_OK ){
6261 sqlite3PcacheCleanAll(pPager->pPCache);
6262 }
dan7c246102010-04-12 19:00:29 +00006263 }else{
6264 /* The following block updates the change-counter. Exactly how it
6265 ** does this depends on whether or not the atomic-update optimization
6266 ** was enabled at compile time, and if this transaction meets the
6267 ** runtime criteria to use the operation:
6268 **
6269 ** * The file-system supports the atomic-write property for
6270 ** blocks of size page-size, and
6271 ** * This commit is not part of a multi-file transaction, and
6272 ** * Exactly one page has been modified and store in the journal file.
6273 **
6274 ** If the optimization was not enabled at compile time, then the
6275 ** pager_incr_changecounter() function is called to update the change
6276 ** counter in 'indirect-mode'. If the optimization is compiled in but
6277 ** is not applicable to this transaction, call sqlite3JournalCreate()
6278 ** to make sure the journal file has actually been created, then call
6279 ** pager_incr_changecounter() to update the change-counter in indirect
6280 ** mode.
6281 **
6282 ** Otherwise, if the optimization is both enabled and applicable,
6283 ** then call pager_incr_changecounter() to update the change-counter
6284 ** in 'direct' mode. In this case the journal file will never be
6285 ** created for this transaction.
6286 */
6287 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
6288 PgHdr *pPg;
dan3f94b602010-07-03 13:45:52 +00006289 assert( isOpen(pPager->jfd)
6290 || pPager->journalMode==PAGER_JOURNALMODE_OFF
6291 || pPager->journalMode==PAGER_JOURNALMODE_WAL
6292 );
dan7c246102010-04-12 19:00:29 +00006293 if( !zMaster && isOpen(pPager->jfd)
6294 && pPager->journalOff==jrnlBufferSize(pPager)
dan4d9c1b72010-07-30 07:26:51 +00006295 && pPager->dbSize>=pPager->dbOrigSize
dan7c246102010-04-12 19:00:29 +00006296 && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
6297 ){
6298 /* Update the db file change counter via the direct-write method. The
6299 ** following call will modify the in-memory representation of page 1
6300 ** to include the updated change counter and then write page 1
6301 ** directly to the database file. Because of the atomic-write
6302 ** property of the host file-system, this is safe.
6303 */
6304 rc = pager_incr_changecounter(pPager, 1);
6305 }else{
6306 rc = sqlite3JournalCreate(pPager->jfd);
6307 if( rc==SQLITE_OK ){
6308 rc = pager_incr_changecounter(pPager, 0);
danielk1977bea2a942009-01-20 17:06:27 +00006309 }
dan7c246102010-04-12 19:00:29 +00006310 }
6311 #else
6312 rc = pager_incr_changecounter(pPager, 0);
6313 #endif
danielk1977bea2a942009-01-20 17:06:27 +00006314 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
dan7c246102010-04-12 19:00:29 +00006315
dan7c246102010-04-12 19:00:29 +00006316 /* Write the master journal name into the journal file. If a master
6317 ** journal file name has already been written to the journal file,
6318 ** or if zMaster is NULL (no master journal), then this call is a no-op.
6319 */
6320 rc = writeMasterJournal(pPager, zMaster);
6321 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6322
dan51133ea2010-07-30 15:43:13 +00006323 /* Sync the journal file and write all dirty pages to the database.
6324 ** If the atomic-update optimization is being used, this sync will not
6325 ** create the journal file or perform any real IO.
6326 **
6327 ** Because the change-counter page was just modified, unless the
6328 ** atomic-update optimization is used it is almost certain that the
6329 ** journal requires a sync here. However, in locking_mode=exclusive
6330 ** on a system under memory pressure it is just possible that this is
6331 ** not the case. In this case it is likely enough that the redundant
6332 ** xSync() call will be changed to a no-op by the OS anyhow.
dan7c246102010-04-12 19:00:29 +00006333 */
dan937ac9d2010-08-03 12:48:45 +00006334 rc = syncJournal(pPager, 0);
dan7c246102010-04-12 19:00:29 +00006335 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6336
drh146151c2010-07-07 14:19:13 +00006337 rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
dan7c246102010-04-12 19:00:29 +00006338 if( rc!=SQLITE_OK ){
6339 assert( rc!=SQLITE_IOERR_BLOCKED );
6340 goto commit_phase_one_exit;
6341 }
6342 sqlite3PcacheCleanAll(pPager->pPCache);
danbc1a3c62013-02-23 16:40:46 +00006343
6344 /* If the file on disk is smaller than the database image, use
6345 ** pager_truncate to grow the file here. This can happen if the database
6346 ** image was extended as part of the current transaction and then the
6347 ** last page in the db image moved to the free-list. In this case the
6348 ** last page is never written out to disk, leaving the database file
6349 ** undersized. Fix this now if it is the case. */
6350 if( pPager->dbSize>pPager->dbFileSize ){
dan7c246102010-04-12 19:00:29 +00006351 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
dand0864082010-08-02 14:32:52 +00006352 assert( pPager->eState==PAGER_WRITER_DBMOD );
dan7c246102010-04-12 19:00:29 +00006353 rc = pager_truncate(pPager, nNew);
6354 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6355 }
6356
6357 /* Finally, sync the database file. */
dan354bfe02011-01-11 17:39:37 +00006358 if( !noSync ){
dan999cd082013-12-09 20:42:03 +00006359 rc = sqlite3PagerSync(pPager, zMaster);
dan7c246102010-04-12 19:00:29 +00006360 }
6361 IOTRACE(("DBSYNC %p\n", pPager))
danielk1977f90b7262009-01-07 15:18:20 +00006362 }
drh80e35f42007-03-30 14:06:34 +00006363 }
6364
danielk1977bea2a942009-01-20 17:06:27 +00006365commit_phase_one_exit:
dand0864082010-08-02 14:32:52 +00006366 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
6367 pPager->eState = PAGER_WRITER_FINISHED;
6368 }
drh80e35f42007-03-30 14:06:34 +00006369 return rc;
6370}
6371
6372
6373/*
danielk1977bea2a942009-01-20 17:06:27 +00006374** When this function is called, the database file has been completely
6375** updated to reflect the changes made by the current transaction and
6376** synced to disk. The journal file still exists in the file-system
6377** though, and if a failure occurs at this point it will eventually
6378** be used as a hot-journal and the current transaction rolled back.
drhd9b02572001-04-15 00:37:09 +00006379**
danielk1977bea2a942009-01-20 17:06:27 +00006380** This function finalizes the journal file, either by deleting,
6381** truncating or partially zeroing it, so that it cannot be used
6382** for hot-journal rollback. Once this is done the transaction is
6383** irrevocably committed.
6384**
6385** If an error occurs, an IO error code is returned and the pager
6386** moves into the error state. Otherwise, SQLITE_OK is returned.
drhed7c8552001-04-11 14:29:21 +00006387*/
drh80e35f42007-03-30 14:06:34 +00006388int sqlite3PagerCommitPhaseTwo(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00006389 int rc = SQLITE_OK; /* Return code */
drhd9b02572001-04-15 00:37:09 +00006390
drhb480dc22009-07-24 12:35:57 +00006391 /* This routine should not be called if a prior error has occurred.
6392 ** But if (due to a coding error elsewhere in the system) it does get
6393 ** called, just return the same error code without doing anything. */
6394 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977bea2a942009-01-20 17:06:27 +00006395
dande1ae342010-08-06 12:00:27 +00006396 assert( pPager->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +00006397 || pPager->eState==PAGER_WRITER_FINISHED
6398 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
6399 );
6400 assert( assert_pager_state(pPager) );
6401
danielk1977bea2a942009-01-20 17:06:27 +00006402 /* An optimization. If the database was not actually modified during
6403 ** this transaction, the pager is running in exclusive-mode and is
6404 ** using persistent journals, then this function is a no-op.
6405 **
6406 ** The start of the journal file currently contains a single journal
6407 ** header with the nRec field set to 0. If such a journal is used as
6408 ** a hot-journal during hot-journal rollback, 0 changes will be made
6409 ** to the database file. So there is no need to zero the journal
6410 ** header. Since the pager is in exclusive mode, there is no need
6411 ** to drop any locks either.
6412 */
dande1ae342010-08-06 12:00:27 +00006413 if( pPager->eState==PAGER_WRITER_LOCKED
dand0864082010-08-02 14:32:52 +00006414 && pPager->exclusiveMode
danielk19773cfe0702009-01-17 16:59:40 +00006415 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
6416 ){
dan6b63ab42010-06-30 10:36:18 +00006417 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
dand0864082010-08-02 14:32:52 +00006418 pPager->eState = PAGER_READER;
drhd138c012008-05-13 00:58:18 +00006419 return SQLITE_OK;
6420 }
danielk1977bea2a942009-01-20 17:06:27 +00006421
drh30d53702009-01-06 15:58:57 +00006422 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
drhd7107b32014-12-20 14:34:02 +00006423 pPager->iDataVersion++;
danbc1a3c62013-02-23 16:40:46 +00006424 rc = pager_end_transaction(pPager, pPager->setMaster, 1);
danielk1977bea2a942009-01-20 17:06:27 +00006425 return pager_error(pPager, rc);
drhed7c8552001-04-11 14:29:21 +00006426}
6427
6428/*
dan73d66fd2010-08-07 16:17:48 +00006429** If a write transaction is open, then all changes made within the
6430** transaction are reverted and the current write-transaction is closed.
6431** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
6432** state if an error occurs.
drhd9b02572001-04-15 00:37:09 +00006433**
dan73d66fd2010-08-07 16:17:48 +00006434** If the pager is already in PAGER_ERROR state when this function is called,
6435** it returns Pager.errCode immediately. No work is performed in this case.
6436**
6437** Otherwise, in rollback mode, this function performs two functions:
danielk1977bea2a942009-01-20 17:06:27 +00006438**
6439** 1) It rolls back the journal file, restoring all database file and
6440** in-memory cache pages to the state they were in when the transaction
6441** was opened, and
dan73d66fd2010-08-07 16:17:48 +00006442**
danielk1977bea2a942009-01-20 17:06:27 +00006443** 2) It finalizes the journal file, so that it is not used for hot
6444** rollback at any point in the future.
6445**
dan73d66fd2010-08-07 16:17:48 +00006446** Finalization of the journal file (task 2) is only performed if the
6447** rollback is successful.
danielk1977bea2a942009-01-20 17:06:27 +00006448**
dan73d66fd2010-08-07 16:17:48 +00006449** In WAL mode, all cache-entries containing data modified within the
6450** current transaction are either expelled from the cache or reverted to
6451** their pre-transaction state by re-reading data from the database or
6452** WAL files. The WAL transaction is then closed.
drhed7c8552001-04-11 14:29:21 +00006453*/
danielk19773b8a05f2007-03-19 17:44:26 +00006454int sqlite3PagerRollback(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00006455 int rc = SQLITE_OK; /* Return code */
drh30d53702009-01-06 15:58:57 +00006456 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
dand0864082010-08-02 14:32:52 +00006457
dande1ae342010-08-06 12:00:27 +00006458 /* PagerRollback() is a no-op if called in READER or OPEN state. If
dana42c66b2010-08-03 18:18:41 +00006459 ** the pager is already in the ERROR state, the rollback is not
6460 ** attempted here. Instead, the error code is returned to the caller.
6461 */
dand0864082010-08-02 14:32:52 +00006462 assert( assert_pager_state(pPager) );
dana42c66b2010-08-03 18:18:41 +00006463 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
dand0864082010-08-02 14:32:52 +00006464 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
6465
drh7ed91f22010-04-29 22:34:07 +00006466 if( pagerUseWal(pPager) ){
dan7c246102010-04-12 19:00:29 +00006467 int rc2;
6468 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
danbc1a3c62013-02-23 16:40:46 +00006469 rc2 = pager_end_transaction(pPager, pPager->setMaster, 0);
dan7c246102010-04-12 19:00:29 +00006470 if( rc==SQLITE_OK ) rc = rc2;
dan73d66fd2010-08-07 16:17:48 +00006471 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
dan9f4beed2011-01-11 16:09:55 +00006472 int eState = pPager->eState;
danbc1a3c62013-02-23 16:40:46 +00006473 rc = pager_end_transaction(pPager, 0, 0);
dan9f4beed2011-01-11 16:09:55 +00006474 if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
6475 /* This can happen using journal_mode=off. Move the pager to the error
6476 ** state to indicate that the contents of the cache may not be trusted.
6477 ** Any active readers will get SQLITE_ABORT.
6478 */
6479 pPager->errCode = SQLITE_ABORT;
6480 pPager->eState = PAGER_ERROR;
6481 return rc;
6482 }
drha6abd042004-06-09 17:37:22 +00006483 }else{
dana42c66b2010-08-03 18:18:41 +00006484 rc = pager_playback(pPager, 0);
danielk19778c0a7912008-08-20 14:49:23 +00006485 }
dan73d66fd2010-08-07 16:17:48 +00006486
dana42c66b2010-08-03 18:18:41 +00006487 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
dand4097922013-04-02 18:31:29 +00006488 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
dana01abc32013-12-10 16:27:59 +00006489 || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR
6490 || rc==SQLITE_CANTOPEN
6491 );
danb22aa4a2010-08-03 15:57:09 +00006492
6493 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
6494 ** cache. So call pager_error() on the way out to make any error persistent.
6495 */
6496 return pager_error(pPager, rc);
drh98808ba2001-10-18 12:34:46 +00006497}
drhd9b02572001-04-15 00:37:09 +00006498
6499/*
drh5e00f6c2001-09-13 13:46:56 +00006500** Return TRUE if the database file is opened read-only. Return FALSE
6501** if the database is (in theory) writable.
6502*/
drhf49661a2008-12-10 16:45:50 +00006503u8 sqlite3PagerIsreadonly(Pager *pPager){
drhbe0072d2001-09-13 14:46:09 +00006504 return pPager->readOnly;
drh5e00f6c2001-09-13 13:46:56 +00006505}
6506
drhe05b3f82015-07-01 17:53:49 +00006507#ifdef SQLITE_DEBUG
drh5e00f6c2001-09-13 13:46:56 +00006508/*
drh95a0b372015-09-03 20:43:55 +00006509** Return the sum of the reference counts for all pages held by pPager.
drh0f7eb612006-08-08 13:51:43 +00006510*/
danielk19773b8a05f2007-03-19 17:44:26 +00006511int sqlite3PagerRefcount(Pager *pPager){
danielk19778c0a7912008-08-20 14:49:23 +00006512 return sqlite3PcacheRefCount(pPager->pPCache);
drh0f7eb612006-08-08 13:51:43 +00006513}
drhe05b3f82015-07-01 17:53:49 +00006514#endif
drh0f7eb612006-08-08 13:51:43 +00006515
danielk197771d5d2c2008-09-29 11:49:47 +00006516/*
drh63da0892010-03-10 21:42:07 +00006517** Return the approximate number of bytes of memory currently
6518** used by the pager and its associated cache.
6519*/
6520int sqlite3PagerMemUsed(Pager *pPager){
drh233f8162010-07-28 17:36:11 +00006521 int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
6522 + 5*sizeof(void*);
drh63da0892010-03-10 21:42:07 +00006523 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
drh233f8162010-07-28 17:36:11 +00006524 + sqlite3MallocSize(pPager)
drh0cf68a92010-07-29 10:13:25 +00006525 + pPager->pageSize;
drh63da0892010-03-10 21:42:07 +00006526}
6527
6528/*
danielk197771d5d2c2008-09-29 11:49:47 +00006529** Return the number of references to the specified page.
6530*/
6531int sqlite3PagerPageRefcount(DbPage *pPage){
6532 return sqlite3PcachePageRefcount(pPage);
6533}
6534
drh0f7eb612006-08-08 13:51:43 +00006535#ifdef SQLITE_TEST
6536/*
drhd9b02572001-04-15 00:37:09 +00006537** This routine is used for testing and analysis only.
6538*/
danielk19773b8a05f2007-03-19 17:44:26 +00006539int *sqlite3PagerStats(Pager *pPager){
danielk197742741be2005-01-08 12:42:39 +00006540 static int a[11];
danielk19778c0a7912008-08-20 14:49:23 +00006541 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
6542 a[1] = sqlite3PcachePagecount(pPager->pPCache);
6543 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
dande1ae342010-08-06 12:00:27 +00006544 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
dand0864082010-08-02 14:32:52 +00006545 a[4] = pPager->eState;
danielk1977efaaf572006-01-16 11:29:19 +00006546 a[5] = pPager->errCode;
drh9ad3ee42012-03-24 20:06:14 +00006547 a[6] = pPager->aStat[PAGER_STAT_HIT];
6548 a[7] = pPager->aStat[PAGER_STAT_MISS];
drh7c4ac0c2007-04-05 11:25:58 +00006549 a[8] = 0; /* Used to be pPager->nOvfl */
danielk197742741be2005-01-08 12:42:39 +00006550 a[9] = pPager->nRead;
drh9ad3ee42012-03-24 20:06:14 +00006551 a[10] = pPager->aStat[PAGER_STAT_WRITE];
drhd9b02572001-04-15 00:37:09 +00006552 return a;
6553}
danielk197704103022009-02-03 16:51:24 +00006554#endif
6555
6556/*
dan58ca31c2011-09-22 14:41:16 +00006557** Parameter eStat must be either SQLITE_DBSTATUS_CACHE_HIT or
6558** SQLITE_DBSTATUS_CACHE_MISS. Before returning, *pnVal is incremented by the
6559** current cache hit or miss count, according to the value of eStat. If the
6560** reset parameter is non-zero, the cache hit or miss count is zeroed before
6561** returning.
6562*/
6563void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
dan58ca31c2011-09-22 14:41:16 +00006564
6565 assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
6566 || eStat==SQLITE_DBSTATUS_CACHE_MISS
drh9ad3ee42012-03-24 20:06:14 +00006567 || eStat==SQLITE_DBSTATUS_CACHE_WRITE
dan58ca31c2011-09-22 14:41:16 +00006568 );
dan58ca31c2011-09-22 14:41:16 +00006569
drh9ad3ee42012-03-24 20:06:14 +00006570 assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
6571 assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
6572 assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 && PAGER_STAT_WRITE==2 );
6573
6574 *pnVal += pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT];
dan58ca31c2011-09-22 14:41:16 +00006575 if( reset ){
drh9ad3ee42012-03-24 20:06:14 +00006576 pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT] = 0;
dan58ca31c2011-09-22 14:41:16 +00006577 }
6578}
6579
6580/*
dan9131ab92016-04-06 18:20:51 +00006581** Return true if this is an in-memory or temp-file backed pager.
danielk197704103022009-02-03 16:51:24 +00006582*/
danielk197717b90b52008-06-06 11:11:25 +00006583int sqlite3PagerIsMemdb(Pager *pPager){
dan9131ab92016-04-06 18:20:51 +00006584 return pPager->tempFile;
danielk197717b90b52008-06-06 11:11:25 +00006585}
drhdd793422001-06-28 01:54:48 +00006586
drhfa86c412002-02-02 15:01:15 +00006587/*
danielk1977bea2a942009-01-20 17:06:27 +00006588** Check that there are at least nSavepoint savepoints open. If there are
6589** currently less than nSavepoints open, then open one or more savepoints
6590** to make up the difference. If the number of savepoints is already
6591** equal to nSavepoint, then this function is a no-op.
6592**
6593** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
6594** occurs while opening the sub-journal file, then an IO error code is
6595** returned. Otherwise, SQLITE_OK.
drhfa86c412002-02-02 15:01:15 +00006596*/
drh31699062015-06-30 11:07:32 +00006597static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){
danielk1977bea2a942009-01-20 17:06:27 +00006598 int rc = SQLITE_OK; /* Return code */
6599 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
drh31699062015-06-30 11:07:32 +00006600 int ii; /* Iterator variable */
6601 PagerSavepoint *aNew; /* New Pager.aSavepoint array */
danielk1977fd7f0452008-12-17 17:30:26 +00006602
dande1ae342010-08-06 12:00:27 +00006603 assert( pPager->eState>=PAGER_WRITER_LOCKED );
dan937ac9d2010-08-03 12:48:45 +00006604 assert( assert_pager_state(pPager) );
drh31699062015-06-30 11:07:32 +00006605 assert( nSavepoint>nCurrent && pPager->useJournal );
dan937ac9d2010-08-03 12:48:45 +00006606
drh31699062015-06-30 11:07:32 +00006607 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
6608 ** if the allocation fails. Otherwise, zero the new portion in case a
6609 ** malloc failure occurs while populating it in the for(...) loop below.
6610 */
6611 aNew = (PagerSavepoint *)sqlite3Realloc(
6612 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
6613 );
6614 if( !aNew ){
mistachkinfad30392016-02-13 23:43:46 +00006615 return SQLITE_NOMEM_BKPT;
drh31699062015-06-30 11:07:32 +00006616 }
6617 memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
6618 pPager->aSavepoint = aNew;
drhdd3cd972010-03-27 17:12:36 +00006619
drh31699062015-06-30 11:07:32 +00006620 /* Populate the PagerSavepoint structures just allocated. */
6621 for(ii=nCurrent; ii<nSavepoint; ii++){
6622 aNew[ii].nOrig = pPager->dbSize;
6623 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
6624 aNew[ii].iOffset = pPager->journalOff;
6625 }else{
6626 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
6627 }
6628 aNew[ii].iSubRec = pPager->nSubRec;
6629 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
6630 if( !aNew[ii].pInSavepoint ){
mistachkinfad30392016-02-13 23:43:46 +00006631 return SQLITE_NOMEM_BKPT;
danielk1977fd7f0452008-12-17 17:30:26 +00006632 }
drh31699062015-06-30 11:07:32 +00006633 if( pagerUseWal(pPager) ){
6634 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
drh334b2992007-09-06 23:28:23 +00006635 }
drh31699062015-06-30 11:07:32 +00006636 pPager->nSavepoint = ii+1;
drh0f892532002-05-30 12:27:03 +00006637 }
drh31699062015-06-30 11:07:32 +00006638 assert( pPager->nSavepoint==nSavepoint );
6639 assertTruncateConstraint(pPager);
drh86f8c192007-08-22 00:39:19 +00006640 return rc;
6641}
drh31699062015-06-30 11:07:32 +00006642int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
6643 assert( pPager->eState>=PAGER_WRITER_LOCKED );
6644 assert( assert_pager_state(pPager) );
6645
6646 if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){
6647 return pagerOpenSavepoint(pPager, nSavepoint);
6648 }else{
6649 return SQLITE_OK;
6650 }
6651}
6652
drhfa86c412002-02-02 15:01:15 +00006653
6654/*
danielk1977bea2a942009-01-20 17:06:27 +00006655** This function is called to rollback or release (commit) a savepoint.
6656** The savepoint to release or rollback need not be the most recently
6657** created savepoint.
6658**
danielk1977fd7f0452008-12-17 17:30:26 +00006659** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
6660** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
6661** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
shanebe217792009-03-05 04:20:31 +00006662** that have occurred since the specified savepoint was created.
danielk1977fd7f0452008-12-17 17:30:26 +00006663**
danielk1977bea2a942009-01-20 17:06:27 +00006664** The savepoint to rollback or release is identified by parameter
6665** iSavepoint. A value of 0 means to operate on the outermost savepoint
6666** (the first created). A value of (Pager.nSavepoint-1) means operate
6667** on the most recently created savepoint. If iSavepoint is greater than
6668** (Pager.nSavepoint-1), then this function is a no-op.
danielk1977fd7f0452008-12-17 17:30:26 +00006669**
danielk1977bea2a942009-01-20 17:06:27 +00006670** If a negative value is passed to this function, then the current
6671** transaction is rolled back. This is different to calling
6672** sqlite3PagerRollback() because this function does not terminate
6673** the transaction or unlock the database, it just restores the
6674** contents of the database to its original state.
6675**
6676** In any case, all savepoints with an index greater than iSavepoint
6677** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
6678** then savepoint iSavepoint is also destroyed.
6679**
6680** This function may return SQLITE_NOMEM if a memory allocation fails,
6681** or an IO error code if an IO error occurs while rolling back a
6682** savepoint. If no errors occur, SQLITE_OK is returned.
danielk1977fd7f0452008-12-17 17:30:26 +00006683*/
6684int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
dan4e004aa2010-08-05 15:30:22 +00006685 int rc = pPager->errCode; /* Return code */
danielk1977fd7f0452008-12-17 17:30:26 +00006686
6687 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
danielk1977bea2a942009-01-20 17:06:27 +00006688 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
danielk1977fd7f0452008-12-17 17:30:26 +00006689
dan4e004aa2010-08-05 15:30:22 +00006690 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
danielk1977bea2a942009-01-20 17:06:27 +00006691 int ii; /* Iterator variable */
6692 int nNew; /* Number of remaining savepoints after this op. */
6693
6694 /* Figure out how many savepoints will still be active after this
6695 ** operation. Store this value in nNew. Then free resources associated
6696 ** with any savepoints that are destroyed by this operation.
6697 */
shaneh6885de32010-02-05 16:28:00 +00006698 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
danielk1977fd7f0452008-12-17 17:30:26 +00006699 for(ii=nNew; ii<pPager->nSavepoint; ii++){
6700 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
6701 }
6702 pPager->nSavepoint = nNew;
6703
shaneh6885de32010-02-05 16:28:00 +00006704 /* If this is a release of the outermost savepoint, truncate
6705 ** the sub-journal to zero bytes in size. */
6706 if( op==SAVEPOINT_RELEASE ){
6707 if( nNew==0 && isOpen(pPager->sjfd) ){
6708 /* Only truncate if it is an in-memory sub-journal. */
dan2491de22016-02-27 20:14:55 +00006709 if( sqlite3JournalIsInMemory(pPager->sjfd) ){
shaneh6885de32010-02-05 16:28:00 +00006710 rc = sqlite3OsTruncate(pPager->sjfd, 0);
drh35173242010-03-08 21:40:13 +00006711 assert( rc==SQLITE_OK );
shaneh6885de32010-02-05 16:28:00 +00006712 }
6713 pPager->nSubRec = 0;
6714 }
6715 }
6716 /* Else this is a rollback operation, playback the specified savepoint.
danielk1977bea2a942009-01-20 17:06:27 +00006717 ** If this is a temp-file, it is possible that the journal file has
6718 ** not yet been opened. In this case there have been no changes to
6719 ** the database file, so the playback operation can be skipped.
6720 */
drh7ed91f22010-04-29 22:34:07 +00006721 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
danielk1977f3107512008-12-22 10:58:46 +00006722 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
danielk1977fd7f0452008-12-17 17:30:26 +00006723 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
6724 assert(rc!=SQLITE_DONE);
6725 }
drh663fc632002-02-02 18:49:19 +00006726 }
dan4e004aa2010-08-05 15:30:22 +00006727
drhfa86c412002-02-02 15:01:15 +00006728 return rc;
6729}
6730
drh73509ee2003-04-06 20:44:45 +00006731/*
6732** Return the full pathname of the database file.
drhd4e0bb02012-05-27 01:19:04 +00006733**
6734** Except, if the pager is in-memory only, then return an empty string if
6735** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when
6736** used to report the filename to the user, for compatibility with legacy
6737** behavior. But when the Btree needs to know the filename for matching to
6738** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
6739** participate in shared-cache.
drh73509ee2003-04-06 20:44:45 +00006740*/
drhd4e0bb02012-05-27 01:19:04 +00006741const char *sqlite3PagerFilename(Pager *pPager, int nullIfMemDb){
6742 return (nullIfMemDb && pPager->memDb) ? "" : pPager->zFilename;
drh73509ee2003-04-06 20:44:45 +00006743}
6744
drhb20ea9d2004-02-09 01:20:36 +00006745/*
drhd0679ed2007-08-28 22:24:34 +00006746** Return the VFS structure for the pager.
6747*/
drh790f2872015-11-28 18:06:36 +00006748sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
drhd0679ed2007-08-28 22:24:34 +00006749 return pPager->pVfs;
6750}
6751
6752/*
drhcc6bb3e2007-08-31 16:11:35 +00006753** Return the file handle for the database file associated
6754** with the pager. This might return NULL if the file has
6755** not yet been opened.
6756*/
6757sqlite3_file *sqlite3PagerFile(Pager *pPager){
6758 return pPager->fd;
6759}
6760
drhafd6cf12016-01-14 15:03:12 +00006761#if !defined(SQLITE_OMIT_WAL)
drhcc6bb3e2007-08-31 16:11:35 +00006762/*
adam02d24932012-05-09 22:36:25 +00006763 ** Return the file handle for the WAL journal file associated
6764 ** with the pager. This might return NULL if the file has
6765 ** not yet been opened.
6766 */
6767sqlite3_file *sqlite3PagerWalFile(Pager *pPager){
6768 return ((pPager->pWal) ? sqlite3WalFile(pPager->pWal) : (NULL));
6769}
drhafd6cf12016-01-14 15:03:12 +00006770#endif
6771
6772
danielk19775865e3d2004-06-14 06:03:57 +00006773/*
drh21d61852016-01-08 02:27:01 +00006774** Return the file handle for the journal file (if it exists).
6775** This will be either the rollback journal or the WAL file.
6776*/
6777sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){
drhb4acd6a2016-01-14 01:56:43 +00006778#if SQLITE_OMIT_WAL
6779 return pPager->jfd;
6780#else
drh21d61852016-01-08 02:27:01 +00006781 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
drhb4acd6a2016-01-14 01:56:43 +00006782#endif
drh21d61852016-01-08 02:27:01 +00006783}
adam02d24932012-05-09 22:36:25 +00006784
6785/*
danielk19775865e3d2004-06-14 06:03:57 +00006786** Return the full pathname of the journal file.
6787*/
danielk19773b8a05f2007-03-19 17:44:26 +00006788const char *sqlite3PagerJournalname(Pager *pPager){
danielk19775865e3d2004-06-14 06:03:57 +00006789 return pPager->zJournal;
6790}
6791
drh7c4ac0c2007-04-05 11:25:58 +00006792#ifdef SQLITE_HAS_CODEC
drh2c8997b2005-08-27 16:36:48 +00006793/*
drhfa9601a2009-06-18 17:22:39 +00006794** Set or retrieve the codec for this pager
drhb20ea9d2004-02-09 01:20:36 +00006795*/
drh40e459e2010-07-03 12:26:33 +00006796void sqlite3PagerSetCodec(
drhb20ea9d2004-02-09 01:20:36 +00006797 Pager *pPager,
drhc001c582006-03-06 18:23:16 +00006798 void *(*xCodec)(void*,void*,Pgno,int),
drhfa9601a2009-06-18 17:22:39 +00006799 void (*xCodecSizeChng)(void*,int,int),
6800 void (*xCodecFree)(void*),
6801 void *pCodec
drhb20ea9d2004-02-09 01:20:36 +00006802){
drhfa9601a2009-06-18 17:22:39 +00006803 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
drh481aa742009-11-05 18:46:02 +00006804 pPager->xCodec = pPager->memDb ? 0 : xCodec;
drhfa9601a2009-06-18 17:22:39 +00006805 pPager->xCodecSizeChng = xCodecSizeChng;
6806 pPager->xCodecFree = xCodecFree;
6807 pPager->pCodec = pCodec;
6808 pagerReportSize(pPager);
6809}
drh40e459e2010-07-03 12:26:33 +00006810void *sqlite3PagerGetCodec(Pager *pPager){
drhfa9601a2009-06-18 17:22:39 +00006811 return pPager->pCodec;
drhb20ea9d2004-02-09 01:20:36 +00006812}
drhee0231e2013-05-29 17:48:28 +00006813
6814/*
6815** This function is called by the wal module when writing page content
6816** into the log file.
6817**
6818** This function returns a pointer to a buffer containing the encrypted
6819** page content. If a malloc fails, this function may return NULL.
6820*/
6821void *sqlite3PagerCodec(PgHdr *pPg){
6822 void *aData = 0;
6823 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
6824 return aData;
6825}
6826
6827/*
6828** Return the current pager state
6829*/
6830int sqlite3PagerState(Pager *pPager){
6831 return pPager->eState;
6832}
6833#endif /* SQLITE_HAS_CODEC */
drhb20ea9d2004-02-09 01:20:36 +00006834
danielk1977687566d2004-11-02 12:56:41 +00006835#ifndef SQLITE_OMIT_AUTOVACUUM
6836/*
danielk197787c29a92008-01-18 11:33:16 +00006837** Move the page pPg to location pgno in the file.
danielk1977687566d2004-11-02 12:56:41 +00006838**
drh5e385312007-06-16 04:42:12 +00006839** There must be no references to the page previously located at
6840** pgno (which we call pPgOld) though that page is allowed to be
drhb3df2e12008-09-17 20:06:26 +00006841** in cache. If the page previously located at pgno is not already
drh5e385312007-06-16 04:42:12 +00006842** in the rollback journal, it is not put there by by this routine.
danielk1977687566d2004-11-02 12:56:41 +00006843**
drh5e385312007-06-16 04:42:12 +00006844** References to the page pPg remain valid. Updating any
6845** meta-data associated with pPg (i.e. data stored in the nExtra bytes
danielk1977687566d2004-11-02 12:56:41 +00006846** allocated along with the page) is the responsibility of the caller.
6847**
danielk19775fd057a2005-03-09 13:09:43 +00006848** A transaction must be active when this routine is called. It used to be
6849** required that a statement transaction was not active, but this restriction
6850** has been removed (CREATE INDEX needs to move a page when a statement
6851** transaction is active).
danielk19774c999992008-07-16 18:17:55 +00006852**
6853** If the fourth argument, isCommit, is non-zero, then this page is being
6854** moved as part of a database reorganization just before the transaction
6855** is being committed. In this case, it is guaranteed that the database page
6856** pPg refers to will not be written to again within this transaction.
danielk1977bea2a942009-01-20 17:06:27 +00006857**
6858** This function may return SQLITE_NOMEM or an IO error code if an error
6859** occurs. Otherwise, it returns SQLITE_OK.
danielk1977687566d2004-11-02 12:56:41 +00006860*/
danielk19774c999992008-07-16 18:17:55 +00006861int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
danielk1977bea2a942009-01-20 17:06:27 +00006862 PgHdr *pPgOld; /* The page being overwritten. */
6863 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
6864 int rc; /* Return code */
drh86655a12009-03-31 02:54:40 +00006865 Pgno origPgno; /* The original page number */
danielk1977687566d2004-11-02 12:56:41 +00006866
danielk1977687566d2004-11-02 12:56:41 +00006867 assert( pPg->nRef>0 );
dand0864082010-08-02 14:32:52 +00006868 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6869 || pPager->eState==PAGER_WRITER_DBMOD
6870 );
6871 assert( assert_pager_state(pPager) );
danielk1977687566d2004-11-02 12:56:41 +00006872
drh8c30f722009-11-20 18:48:35 +00006873 /* In order to be able to rollback, an in-memory database must journal
6874 ** the page we are moving from.
6875 */
drhd22f5092016-05-12 18:38:45 +00006876 assert( pPager->tempFile || !MEMDB );
dand87efd72016-04-06 15:39:03 +00006877 if( pPager->tempFile ){
drh8c30f722009-11-20 18:48:35 +00006878 rc = sqlite3PagerWrite(pPg);
6879 if( rc ) return rc;
6880 }
6881
danielk19771fab7b62009-01-07 10:35:18 +00006882 /* If the page being moved is dirty and has not been saved by the latest
6883 ** savepoint, then save the current contents of the page into the
6884 ** sub-journal now. This is required to handle the following scenario:
6885 **
6886 ** BEGIN;
6887 ** <journal page X, then modify it in memory>
6888 ** SAVEPOINT one;
6889 ** <Move page X to location Y>
6890 ** ROLLBACK TO one;
6891 **
6892 ** If page X were not written to the sub-journal here, it would not
6893 ** be possible to restore its contents when the "ROLLBACK TO one"
danielk1977bea2a942009-01-20 17:06:27 +00006894 ** statement were is processed.
6895 **
6896 ** subjournalPage() may need to allocate space to store pPg->pgno into
6897 ** one or more savepoint bitvecs. This is the reason this function
6898 ** may return SQLITE_NOMEM.
danielk19771fab7b62009-01-07 10:35:18 +00006899 */
drh60e32ed2015-06-29 19:08:18 +00006900 if( (pPg->flags & PGHDR_DIRTY)!=0
6901 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
danielk19771fab7b62009-01-07 10:35:18 +00006902 ){
6903 return rc;
6904 }
6905
drh30d53702009-01-06 15:58:57 +00006906 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
6907 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
drhb0603412007-02-28 04:47:26 +00006908 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
danielk1977ef73ee92004-11-06 12:26:07 +00006909
danielk19774c999992008-07-16 18:17:55 +00006910 /* If the journal needs to be sync()ed before page pPg->pgno can
6911 ** be written to, store pPg->pgno in local variable needSyncPgno.
6912 **
6913 ** If the isCommit flag is set, there is no need to remember that
6914 ** the journal needs to be sync()ed before database page pPg->pgno
6915 ** can be written to. The caller has already promised not to write to it.
6916 */
danielk19778c0a7912008-08-20 14:49:23 +00006917 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
danielk197794daf7f2004-11-08 09:26:09 +00006918 needSyncPgno = pPg->pgno;
drh6ffb4972013-03-01 21:01:05 +00006919 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
drh5dee6af2013-12-13 20:45:50 +00006920 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
danielk19778c0a7912008-08-20 14:49:23 +00006921 assert( pPg->flags&PGHDR_DIRTY );
danielk197794daf7f2004-11-08 09:26:09 +00006922 }
6923
danielk1977ef73ee92004-11-06 12:26:07 +00006924 /* If the cache contains a page with page-number pgno, remove it
dan51133ea2010-07-30 15:43:13 +00006925 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
danielk1977599fcba2004-11-08 07:13:13 +00006926 ** page pgno before the 'move' operation, it needs to be retained
6927 ** for the page moved there.
danielk1977f5fdda82004-11-03 08:44:05 +00006928 */
danielk1977bc2ca9e2008-11-13 14:28:28 +00006929 pPg->flags &= ~PGHDR_NEED_SYNC;
drhc1378072014-08-25 11:33:41 +00006930 pPgOld = sqlite3PagerLookup(pPager, pgno);
danielk19778c0a7912008-08-20 14:49:23 +00006931 assert( !pPgOld || pPgOld->nRef==1 );
drh6e2ef432009-07-22 02:02:39 +00006932 if( pPgOld ){
danielk19778c0a7912008-08-20 14:49:23 +00006933 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
dand87efd72016-04-06 15:39:03 +00006934 if( pPager->tempFile ){
drh98829a62009-11-20 13:18:14 +00006935 /* Do not discard pages from an in-memory database since we might
6936 ** need to rollback later. Just move the page out of the way. */
drh98829a62009-11-20 13:18:14 +00006937 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
6938 }else{
6939 sqlite3PcacheDrop(pPgOld);
6940 }
drh5e385312007-06-16 04:42:12 +00006941 }
danielk1977687566d2004-11-02 12:56:41 +00006942
drh86655a12009-03-31 02:54:40 +00006943 origPgno = pPg->pgno;
danielk19778c0a7912008-08-20 14:49:23 +00006944 sqlite3PcacheMove(pPg, pgno);
drhc047b9f2008-11-21 03:23:43 +00006945 sqlite3PcacheMakeDirty(pPg);
danielk1977687566d2004-11-02 12:56:41 +00006946
dan4e004aa2010-08-05 15:30:22 +00006947 /* For an in-memory database, make sure the original page continues
6948 ** to exist, in case the transaction needs to roll back. Use pPgOld
6949 ** as the original page since it has already been allocated.
6950 */
drhd12bc602016-05-10 20:03:08 +00006951 if( pPager->tempFile && pPgOld ){
dan4e004aa2010-08-05 15:30:22 +00006952 sqlite3PcacheMove(pPgOld, origPgno);
drhda8a3302013-12-13 19:35:21 +00006953 sqlite3PagerUnrefNotNull(pPgOld);
dan4e004aa2010-08-05 15:30:22 +00006954 }
6955
danielk197794daf7f2004-11-08 09:26:09 +00006956 if( needSyncPgno ){
6957 /* If needSyncPgno is non-zero, then the journal file needs to be
6958 ** sync()ed before any data is written to database file page needSyncPgno.
6959 ** Currently, no such page exists in the page-cache and the
danielk19774c999992008-07-16 18:17:55 +00006960 ** "is journaled" bitvec flag has been set. This needs to be remedied by
dan51133ea2010-07-30 15:43:13 +00006961 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
danielk19774c999992008-07-16 18:17:55 +00006962 ** flag.
danielk1977ae825582004-11-23 09:06:55 +00006963 **
danielk1977a98d7b42008-01-18 13:42:54 +00006964 ** If the attempt to load the page into the page-cache fails, (due
drhf5e7bb52008-02-18 14:47:33 +00006965 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
danielk1977a98d7b42008-01-18 13:42:54 +00006966 ** array. Otherwise, if the page is loaded and written again in
6967 ** this transaction, it may be written to the database file before
6968 ** it is synced into the journal file. This way, it may end up in
6969 ** the journal file twice, but that is not a problem.
danielk197794daf7f2004-11-08 09:26:09 +00006970 */
danielk19773b8a05f2007-03-19 17:44:26 +00006971 PgHdr *pPgHdr;
drh9584f582015-11-04 20:22:37 +00006972 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0);
danielk197787c29a92008-01-18 11:33:16 +00006973 if( rc!=SQLITE_OK ){
drh6aac11d2009-07-18 20:01:37 +00006974 if( needSyncPgno<=pPager->dbOrigSize ){
drhe98c9042009-06-02 21:31:38 +00006975 assert( pPager->pTmpSpace!=0 );
6976 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
danielk1977a98d7b42008-01-18 13:42:54 +00006977 }
danielk197787c29a92008-01-18 11:33:16 +00006978 return rc;
6979 }
danielk19778c0a7912008-08-20 14:49:23 +00006980 pPgHdr->flags |= PGHDR_NEED_SYNC;
drhc047b9f2008-11-21 03:23:43 +00006981 sqlite3PcacheMakeDirty(pPgHdr);
drhda8a3302013-12-13 19:35:21 +00006982 sqlite3PagerUnrefNotNull(pPgHdr);
danielk197794daf7f2004-11-08 09:26:09 +00006983 }
6984
danielk1977687566d2004-11-02 12:56:41 +00006985 return SQLITE_OK;
6986}
6987#endif
6988
danielk19773b8a05f2007-03-19 17:44:26 +00006989/*
dane6593d82014-10-24 16:40:49 +00006990** The page handle passed as the first argument refers to a dirty page
6991** with a page number other than iNew. This function changes the page's
6992** page number to iNew and sets the value of the PgHdr.flags field to
6993** the value passed as the third parameter.
6994*/
dan31f4e992014-10-24 20:57:03 +00006995void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
dane6593d82014-10-24 16:40:49 +00006996 assert( pPg->pgno!=iNew );
6997 pPg->flags = flags;
dan33ea4862014-10-09 19:35:37 +00006998 sqlite3PcacheMove(pPg, iNew);
6999}
7000
danielk19773b8a05f2007-03-19 17:44:26 +00007001/*
7002** Return a pointer to the data for the specified page.
7003*/
7004void *sqlite3PagerGetData(DbPage *pPg){
danielk197771d5d2c2008-09-29 11:49:47 +00007005 assert( pPg->nRef>0 || pPg->pPager->memDb );
danielk19778c0a7912008-08-20 14:49:23 +00007006 return pPg->pData;
danielk19773b8a05f2007-03-19 17:44:26 +00007007}
7008
7009/*
7010** Return a pointer to the Pager.nExtra bytes of "extra" space
7011** allocated along with the specified page.
7012*/
7013void *sqlite3PagerGetExtra(DbPage *pPg){
drh6aac11d2009-07-18 20:01:37 +00007014 return pPg->pExtra;
danielk19773b8a05f2007-03-19 17:44:26 +00007015}
7016
danielk197741483462007-03-24 16:45:04 +00007017/*
7018** Get/set the locking-mode for this pager. Parameter eMode must be one
7019** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
7020** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
7021** the locking-mode is set to the value specified.
7022**
7023** The returned value is either PAGER_LOCKINGMODE_NORMAL or
7024** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
7025** locking-mode.
7026*/
7027int sqlite3PagerLockingMode(Pager *pPager, int eMode){
drh369339d2007-03-30 16:01:55 +00007028 assert( eMode==PAGER_LOCKINGMODE_QUERY
7029 || eMode==PAGER_LOCKINGMODE_NORMAL
7030 || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
7031 assert( PAGER_LOCKINGMODE_QUERY<0 );
7032 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
dan8c408002010-11-01 17:38:24 +00007033 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
7034 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
drh1bd10f82008-12-10 21:19:56 +00007035 pPager->exclusiveMode = (u8)eMode;
danielk197741483462007-03-24 16:45:04 +00007036 }
7037 return (int)pPager->exclusiveMode;
7038}
7039
drh3b020132008-04-17 17:02:01 +00007040/*
drh0b9b4302010-06-11 17:01:24 +00007041** Set the journal-mode for this pager. Parameter eMode must be one of:
drh3b020132008-04-17 17:02:01 +00007042**
drh04335882008-09-26 21:08:08 +00007043** PAGER_JOURNALMODE_DELETE
7044** PAGER_JOURNALMODE_TRUNCATE
7045** PAGER_JOURNALMODE_PERSIST
7046** PAGER_JOURNALMODE_OFF
danielk1977bea2a942009-01-20 17:06:27 +00007047** PAGER_JOURNALMODE_MEMORY
dan7c246102010-04-12 19:00:29 +00007048** PAGER_JOURNALMODE_WAL
drh04335882008-09-26 21:08:08 +00007049**
drh0b9b4302010-06-11 17:01:24 +00007050** The journalmode is set to the value specified if the change is allowed.
7051** The change may be disallowed for the following reasons:
drh8a939192009-04-20 17:43:03 +00007052**
7053** * An in-memory database can only have its journal_mode set to _OFF
7054** or _MEMORY.
7055**
drh0b9b4302010-06-11 17:01:24 +00007056** * Temporary databases cannot have _WAL journalmode.
drh04335882008-09-26 21:08:08 +00007057**
danielk1977bea2a942009-01-20 17:06:27 +00007058** The returned indicate the current (possibly updated) journal-mode.
drh3b020132008-04-17 17:02:01 +00007059*/
drh0b9b4302010-06-11 17:01:24 +00007060int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
7061 u8 eOld = pPager->journalMode; /* Prior journalmode */
7062
drhe5918c62010-08-14 12:42:45 +00007063#ifdef SQLITE_DEBUG
7064 /* The print_pager_state() routine is intended to be used by the debugger
7065 ** only. We invoke it once here to suppress a compiler warning. */
7066 print_pager_state(pPager);
7067#endif
7068
7069
drh0b9b4302010-06-11 17:01:24 +00007070 /* The eMode parameter is always valid */
7071 assert( eMode==PAGER_JOURNALMODE_DELETE
drh5d738542009-04-04 15:53:47 +00007072 || eMode==PAGER_JOURNALMODE_TRUNCATE
7073 || eMode==PAGER_JOURNALMODE_PERSIST
7074 || eMode==PAGER_JOURNALMODE_OFF
dan7c246102010-04-12 19:00:29 +00007075 || eMode==PAGER_JOURNALMODE_WAL
drh5d738542009-04-04 15:53:47 +00007076 || eMode==PAGER_JOURNALMODE_MEMORY );
dane04dc882010-04-20 18:53:15 +00007077
drha485ccc2010-07-08 19:19:51 +00007078 /* This routine is only called from the OP_JournalMode opcode, and
7079 ** the logic there will never allow a temporary file to be changed
7080 ** to WAL mode.
drh0b9b4302010-06-11 17:01:24 +00007081 */
drha485ccc2010-07-08 19:19:51 +00007082 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
drh0b9b4302010-06-11 17:01:24 +00007083
7084 /* Do allow the journalmode of an in-memory database to be set to
7085 ** anything other than MEMORY or OFF
7086 */
7087 if( MEMDB ){
7088 assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
7089 if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
7090 eMode = eOld;
7091 }
7092 }
7093
7094 if( eMode!=eOld ){
drh0b9b4302010-06-11 17:01:24 +00007095
7096 /* Change the journal mode. */
dane5953cc2010-08-07 09:31:14 +00007097 assert( pPager->eState!=PAGER_ERROR );
drh0b9b4302010-06-11 17:01:24 +00007098 pPager->journalMode = (u8)eMode;
dan731bf5b2010-06-17 16:44:21 +00007099
7100 /* When transistioning from TRUNCATE or PERSIST to any other journal
dane5953cc2010-08-07 09:31:14 +00007101 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
dan731bf5b2010-06-17 16:44:21 +00007102 ** delete the journal file.
7103 */
7104 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
7105 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
7106 assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
7107 assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
7108 assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
7109 assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
7110
7111 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
7112 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
7113
7114 /* In this case we would like to delete the journal file. If it is
7115 ** not possible, then that is not a problem. Deleting the journal file
7116 ** here is an optimization only.
7117 **
7118 ** Before deleting the journal file, obtain a RESERVED lock on the
7119 ** database file. This ensures that the journal file is not deleted
7120 ** while it is in use by some other client.
7121 */
dane5953cc2010-08-07 09:31:14 +00007122 sqlite3OsClose(pPager->jfd);
7123 if( pPager->eLock>=RESERVED_LOCK ){
dan731bf5b2010-06-17 16:44:21 +00007124 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
dane5953cc2010-08-07 09:31:14 +00007125 }else{
7126 int rc = SQLITE_OK;
7127 int state = pPager->eState;
dan5653e4d2010-08-12 11:25:47 +00007128 assert( state==PAGER_OPEN || state==PAGER_READER );
dane5953cc2010-08-07 09:31:14 +00007129 if( state==PAGER_OPEN ){
7130 rc = sqlite3PagerSharedLock(pPager);
7131 }
7132 if( pPager->eState==PAGER_READER ){
7133 assert( rc==SQLITE_OK );
7134 rc = pagerLockDb(pPager, RESERVED_LOCK);
7135 }
7136 if( rc==SQLITE_OK ){
7137 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
7138 }
7139 if( rc==SQLITE_OK && state==PAGER_READER ){
7140 pagerUnlockDb(pPager, SHARED_LOCK);
7141 }else if( state==PAGER_OPEN ){
7142 pager_unlock(pPager);
7143 }
7144 assert( state==pPager->eState );
dan731bf5b2010-06-17 16:44:21 +00007145 }
dan929b9232015-05-01 16:57:24 +00007146 }else if( eMode==PAGER_JOURNALMODE_OFF ){
7147 sqlite3OsClose(pPager->jfd);
dan731bf5b2010-06-17 16:44:21 +00007148 }
drh3b020132008-04-17 17:02:01 +00007149 }
drh0b9b4302010-06-11 17:01:24 +00007150
7151 /* Return the new journal mode */
drhfdc40e92008-04-17 20:59:37 +00007152 return (int)pPager->journalMode;
drh3b020132008-04-17 17:02:01 +00007153}
7154
danielk1977b53e4962008-06-04 06:45:59 +00007155/*
drh0b9b4302010-06-11 17:01:24 +00007156** Return the current journal mode.
7157*/
7158int sqlite3PagerGetJournalMode(Pager *pPager){
7159 return (int)pPager->journalMode;
7160}
7161
7162/*
7163** Return TRUE if the pager is in a state where it is OK to change the
7164** journalmode. Journalmode changes can only happen when the database
7165** is unmodified.
7166*/
7167int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
dan4e004aa2010-08-05 15:30:22 +00007168 assert( assert_pager_state(pPager) );
dand0864082010-08-02 14:32:52 +00007169 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
dan89ccf442010-07-01 15:09:47 +00007170 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
drh0b9b4302010-06-11 17:01:24 +00007171 return 1;
7172}
7173
7174/*
danielk1977b53e4962008-06-04 06:45:59 +00007175** Get/set the size-limit used for persistent journal files.
drh5d738542009-04-04 15:53:47 +00007176**
7177** Setting the size limit to -1 means no limit is enforced.
7178** An attempt to set a limit smaller than -1 is a no-op.
danielk1977b53e4962008-06-04 06:45:59 +00007179*/
7180i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
7181 if( iLimit>=-1 ){
7182 pPager->journalSizeLimit = iLimit;
drh85a83752011-05-16 21:00:27 +00007183 sqlite3WalLimit(pPager->pWal, iLimit);
danielk1977b53e4962008-06-04 06:45:59 +00007184 }
7185 return pPager->journalSizeLimit;
7186}
7187
danielk197704103022009-02-03 16:51:24 +00007188/*
7189** Return a pointer to the pPager->pBackup variable. The backup module
7190** in backup.c maintains the content of this variable. This module
7191** uses it opaquely as an argument to sqlite3BackupRestart() and
7192** sqlite3BackupUpdate() only.
7193*/
7194sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
7195 return &pPager->pBackup;
7196}
7197
dan5cf53532010-05-01 16:40:20 +00007198#ifndef SQLITE_OMIT_WAL
dan7c246102010-04-12 19:00:29 +00007199/*
dana58f26f2010-11-16 18:56:51 +00007200** This function is called when the user invokes "PRAGMA wal_checkpoint",
7201** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
7202** or wal_blocking_checkpoint() API functions.
7203**
dancdc1f042010-11-18 12:11:05 +00007204** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
dan7c246102010-04-12 19:00:29 +00007205*/
dancdc1f042010-11-18 12:11:05 +00007206int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
dan7c246102010-04-12 19:00:29 +00007207 int rc = SQLITE_OK;
drh7ed91f22010-04-29 22:34:07 +00007208 if( pPager->pWal ){
dancdc1f042010-11-18 12:11:05 +00007209 rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
drhdd90d7e2014-12-03 19:25:41 +00007210 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
7211 pPager->pBusyHandlerArg,
drh27f9aba2010-11-19 18:51:31 +00007212 pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
dancdc1f042010-11-18 12:11:05 +00007213 pnLog, pnCkpt
dan64d039e2010-04-13 19:27:31 +00007214 );
dan7c246102010-04-12 19:00:29 +00007215 }
7216 return rc;
7217}
7218
drh7ed91f22010-04-29 22:34:07 +00007219int sqlite3PagerWalCallback(Pager *pPager){
7220 return sqlite3WalCallback(pPager->pWal);
dan8d22a172010-04-19 18:03:51 +00007221}
7222
dane04dc882010-04-20 18:53:15 +00007223/*
drhd9e5c4f2010-05-12 18:01:39 +00007224** Return true if the underlying VFS for the given pager supports the
7225** primitives necessary for write-ahead logging.
7226*/
7227int sqlite3PagerWalSupported(Pager *pPager){
7228 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
drhffbb02a2016-03-11 23:07:30 +00007229 if( pPager->noLock ) return 0;
dan8c408002010-11-01 17:38:24 +00007230 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
drhd9e5c4f2010-05-12 18:01:39 +00007231}
7232
7233/*
dan8c408002010-11-01 17:38:24 +00007234** Attempt to take an exclusive lock on the database file. If a PENDING lock
7235** is obtained instead, immediately release it.
7236*/
7237static int pagerExclusiveLock(Pager *pPager){
7238 int rc; /* Return code */
7239
7240 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
7241 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
7242 if( rc!=SQLITE_OK ){
drh7f0857c2011-02-24 21:10:00 +00007243 /* If the attempt to grab the exclusive lock failed, release the
7244 ** pending lock that may have been obtained instead. */
dan8c408002010-11-01 17:38:24 +00007245 pagerUnlockDb(pPager, SHARED_LOCK);
7246 }
7247
7248 return rc;
7249}
7250
7251/*
7252** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
7253** exclusive-locking mode when this function is called, take an EXCLUSIVE
7254** lock on the database file and use heap-memory to store the wal-index
7255** in. Otherwise, use the normal shared-memory.
7256*/
7257static int pagerOpenWal(Pager *pPager){
7258 int rc = SQLITE_OK;
7259
7260 assert( pPager->pWal==0 && pPager->tempFile==0 );
drh33f111d2012-01-17 15:29:14 +00007261 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
dan8c408002010-11-01 17:38:24 +00007262
7263 /* If the pager is already in exclusive-mode, the WAL module will use
7264 ** heap-memory for the wal-index instead of the VFS shared-memory
7265 ** implementation. Take the exclusive lock now, before opening the WAL
7266 ** file, to make sure this is safe.
7267 */
7268 if( pPager->exclusiveMode ){
7269 rc = pagerExclusiveLock(pPager);
7270 }
7271
7272 /* Open the connection to the log file. If this operation fails,
7273 ** (e.g. due to malloc() failure), return an error code.
7274 */
7275 if( rc==SQLITE_OK ){
adam2e4491d2011-06-24 20:47:06 +00007276#if SQLITE_ENABLE_DATA_PROTECTION
7277 rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, pPager->exclusiveMode,
adamaec336a2011-10-10 22:11:44 +00007278 pPager->journalSizeLimit, (pPager->vfsFlags & (SQLITE_OPEN_FILEPROTECTION_MASK | SQLITE_OPEN_READONLY)),
adam2e4491d2011-06-24 20:47:06 +00007279 &pPager->pWal);
7280#else
7281 rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, pPager->exclusiveMode,
adamaec336a2011-10-10 22:11:44 +00007282 pPager->journalSizeLimit, (pPager->vfsFlags & SQLITE_OPEN_READONLY), &pPager->pWal);
adam2e4491d2011-06-24 20:47:06 +00007283#endif
dan8c408002010-11-01 17:38:24 +00007284 }
dan5d8a1372013-03-19 19:28:06 +00007285 pagerFixMaplimit(pPager);
dan8c408002010-11-01 17:38:24 +00007286
7287 return rc;
7288}
7289
7290
7291/*
dane04dc882010-04-20 18:53:15 +00007292** The caller must be holding a SHARED lock on the database file to call
7293** this function.
drh40e459e2010-07-03 12:26:33 +00007294**
7295** If the pager passed as the first argument is open on a real database
7296** file (not a temp file or an in-memory database), and the WAL file
7297** is not already open, make an attempt to open it now. If successful,
7298** return SQLITE_OK. If an error occurs or the VFS used by the pager does
dan763afe62010-08-03 06:42:39 +00007299** not support the xShmXXX() methods, return an error code. *pbOpen is
drh40e459e2010-07-03 12:26:33 +00007300** not modified in either case.
7301**
7302** If the pager is open on a temp-file (or in-memory database), or if
dan763afe62010-08-03 06:42:39 +00007303** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
drh40e459e2010-07-03 12:26:33 +00007304** without doing anything.
dane04dc882010-04-20 18:53:15 +00007305*/
drh40e459e2010-07-03 12:26:33 +00007306int sqlite3PagerOpenWal(
7307 Pager *pPager, /* Pager object */
dan763afe62010-08-03 06:42:39 +00007308 int *pbOpen /* OUT: Set to true if call is a no-op */
drh40e459e2010-07-03 12:26:33 +00007309){
dane04dc882010-04-20 18:53:15 +00007310 int rc = SQLITE_OK; /* Return code */
7311
dan763afe62010-08-03 06:42:39 +00007312 assert( assert_pager_state(pPager) );
dande1ae342010-08-06 12:00:27 +00007313 assert( pPager->eState==PAGER_OPEN || pbOpen );
dan763afe62010-08-03 06:42:39 +00007314 assert( pPager->eState==PAGER_READER || !pbOpen );
7315 assert( pbOpen==0 || *pbOpen==0 );
7316 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
drh40e459e2010-07-03 12:26:33 +00007317
7318 if( !pPager->tempFile && !pPager->pWal ){
drhd9e5c4f2010-05-12 18:01:39 +00007319 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
dane04dc882010-04-20 18:53:15 +00007320
drh919fc662010-08-16 20:02:09 +00007321 /* Close any rollback journal previously open */
7322 sqlite3OsClose(pPager->jfd);
dan4e004aa2010-08-05 15:30:22 +00007323
dan8c408002010-11-01 17:38:24 +00007324 rc = pagerOpenWal(pPager);
dane04dc882010-04-20 18:53:15 +00007325 if( rc==SQLITE_OK ){
7326 pPager->journalMode = PAGER_JOURNALMODE_WAL;
dande1ae342010-08-06 12:00:27 +00007327 pPager->eState = PAGER_OPEN;
dane04dc882010-04-20 18:53:15 +00007328 }
7329 }else{
dan763afe62010-08-03 06:42:39 +00007330 *pbOpen = 1;
dane04dc882010-04-20 18:53:15 +00007331 }
7332
7333 return rc;
7334}
7335
dane04dc882010-04-20 18:53:15 +00007336/*
7337** This function is called to close the connection to the log file prior
7338** to switching from WAL to rollback mode.
7339**
7340** Before closing the log file, this function attempts to take an
7341** EXCLUSIVE lock on the database file. If this cannot be obtained, an
7342** error (SQLITE_BUSY) is returned and the log connection is not closed.
7343** If successful, the EXCLUSIVE lock is not released before returning.
7344*/
drh7ed91f22010-04-29 22:34:07 +00007345int sqlite3PagerCloseWal(Pager *pPager){
dane04dc882010-04-20 18:53:15 +00007346 int rc = SQLITE_OK;
dane04dc882010-04-20 18:53:15 +00007347
danede6eb82010-04-22 06:27:04 +00007348 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
7349
7350 /* If the log file is not already open, but does exist in the file-system,
7351 ** it may need to be checkpointed before the connection can switch to
7352 ** rollback mode. Open it now so this can happen.
7353 */
drh7ed91f22010-04-29 22:34:07 +00007354 if( !pPager->pWal ){
danede6eb82010-04-22 06:27:04 +00007355 int logexists = 0;
dan4e004aa2010-08-05 15:30:22 +00007356 rc = pagerLockDb(pPager, SHARED_LOCK);
danede6eb82010-04-22 06:27:04 +00007357 if( rc==SQLITE_OK ){
dandb10f082010-07-05 19:13:26 +00007358 rc = sqlite3OsAccess(
7359 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
7360 );
danede6eb82010-04-22 06:27:04 +00007361 }
7362 if( rc==SQLITE_OK && logexists ){
dan8c408002010-11-01 17:38:24 +00007363 rc = pagerOpenWal(pPager);
danede6eb82010-04-22 06:27:04 +00007364 }
7365 }
7366
7367 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
7368 ** the database file, the log and log-summary files will be deleted.
7369 */
drh7ed91f22010-04-29 22:34:07 +00007370 if( rc==SQLITE_OK && pPager->pWal ){
dan8c408002010-11-01 17:38:24 +00007371 rc = pagerExclusiveLock(pPager);
dane04dc882010-04-20 18:53:15 +00007372 if( rc==SQLITE_OK ){
drhc97d8462010-11-19 18:23:35 +00007373 rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
7374 pPager->pageSize, (u8*)pPager->pTmpSpace);
drh7ed91f22010-04-29 22:34:07 +00007375 pPager->pWal = 0;
dan5d8a1372013-03-19 19:28:06 +00007376 pagerFixMaplimit(pPager);
drhfc73c502012-05-11 00:56:28 +00007377
7378 /* Ensure that the WAL file is deleted even if the PERSIST_WAL
7379 ** hint is enabled. */
7380 if( rc==SQLITE_OK ){
7381 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
drh8a9a68e2014-05-09 13:27:38 +00007382 if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
drhfc73c502012-05-11 00:56:28 +00007383 }
drhcdce61e2016-04-20 19:30:47 +00007384 if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
dane04dc882010-04-20 18:53:15 +00007385 }
dane04dc882010-04-20 18:53:15 +00007386 }
7387 return rc;
7388}
dan47ee3862010-06-22 15:18:44 +00007389
danfc1acf32015-12-05 20:51:54 +00007390#ifdef SQLITE_ENABLE_SNAPSHOT
7391/*
7392** If this is a WAL database, obtain a snapshot handle for the snapshot
7393** currently open. Otherwise, return an error.
7394*/
7395int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){
7396 int rc = SQLITE_ERROR;
7397 if( pPager->pWal ){
7398 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
7399 }
7400 return rc;
7401}
7402
7403/*
7404** If this is a WAL database, store a pointer to pSnapshot. Next time a
7405** read transaction is opened, attempt to read from the snapshot it
7406** identifies. If this is not a WAL database, return an error.
7407*/
7408int sqlite3PagerSnapshotOpen(Pager *pPager, sqlite3_snapshot *pSnapshot){
7409 int rc = SQLITE_OK;
7410 if( pPager->pWal ){
7411 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
7412 }else{
7413 rc = SQLITE_ERROR;
7414 }
7415 return rc;
7416}
7417#endif /* SQLITE_ENABLE_SNAPSHOT */
drhf7c70312012-10-10 12:14:09 +00007418#endif /* !SQLITE_OMIT_WAL */
7419
drh70708602012-02-24 14:33:28 +00007420#ifdef SQLITE_ENABLE_ZIPVFS
danb3bdc722012-02-23 15:35:49 +00007421/*
7422** A read-lock must be held on the pager when this function is called. If
7423** the pager is in WAL mode and the WAL file currently contains one or more
7424** frames, return the size in bytes of the page images stored within the
7425** WAL frames. Otherwise, if this is not a WAL database or the WAL file
7426** is empty, return 0.
7427*/
7428int sqlite3PagerWalFramesize(Pager *pPager){
dan9675d5d2014-09-18 09:59:28 +00007429 assert( pPager->eState>=PAGER_READER );
danb3bdc722012-02-23 15:35:49 +00007430 return sqlite3WalFramesize(pPager->pWal);
7431}
drh70708602012-02-24 14:33:28 +00007432#endif
danb3bdc722012-02-23 15:35:49 +00007433
dan33ea4862014-10-09 19:35:37 +00007434
drh2e66f0b2005-04-28 17:18:48 +00007435#endif /* SQLITE_OMIT_DISKIO */