Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(114)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/sqlite/sqlite-src-3100200/src/pager.c

Issue 2846743003: [sql] Remove SQLite 3.10.2 reference directory. (Closed)
Patch Set: Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/sqlite/sqlite-src-3100200/src/pager.h ('k') | third_party/sqlite/sqlite-src-3100200/src/parse.y » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This is the implementation of the page cache subsystem or "pager".
13 **
14 ** The pager is used to access a database disk file. It implements
15 ** atomic commit and rollback through the use of a journal file that
16 ** is separate from the database file. The pager also implements file
17 ** locking to prevent two processes from writing the same database
18 ** file simultaneously, or one process from reading the database while
19 ** another is writing.
20 */
21 #ifndef SQLITE_OMIT_DISKIO
22 #include "sqliteInt.h"
23 #include "wal.h"
24
25
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.
31 **
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
64 ** in length and are aligned on a page boundary.
65 **
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
78 ** all queries. Note in particular the content of freelist leaf
79 ** pages can be changed arbitrarily without affecting the logical equivalence
80 ** 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
84 ** journal is rolled back, the resulting database file will be logically
85 ** 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
95 ** the EXCLUSIVE lock, thus signaling other connections on the same
96 ** database to flush their caches.
97 **
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.
109 **
110 ******************************************************************************/
111
112 /*
113 ** Macros for troubleshooting. Normally turned off
114 */
115 #if 0
116 int sqlite3PagerTrace=1; /* True to enable tracing */
117 #define sqlite3DebugPrintf printf
118 #define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }
119 #else
120 #define PAGERTRACE(X)
121 #endif
122
123 /*
124 ** The following two macros are used within the PAGERTRACE() macros above
125 ** to print out file-descriptors.
126 **
127 ** PAGERID() takes a pointer to a Pager struct as its argument. The
128 ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
129 ** struct as its argument.
130 */
131 #define PAGERID(p) ((int)(p->fd))
132 #define FILEHANDLEID(fd) ((int)fd)
133
134 /*
135 ** The Pager.eState variable stores the current 'state' of a pager. A
136 ** pager may be in any one of the seven states shown in the following
137 ** state diagram.
138 **
139 ** OPEN <------+------+
140 ** | | |
141 ** V | |
142 ** +---------> READER-------+ |
143 ** | | |
144 ** | V |
145 ** |<-------WRITER_LOCKED------> ERROR
146 ** | | ^
147 ** | V |
148 ** |<------WRITER_CACHEMOD-------->|
149 ** | | |
150 ** | V |
151 ** |<-------WRITER_DBMOD---------->|
152 ** | | |
153 ** | V |
154 ** +<------WRITER_FINISHED-------->+
155 **
156 **
157 ** List of state transitions and the C [function] that performs each:
158 **
159 ** OPEN -> READER [sqlite3PagerSharedLock]
160 ** READER -> OPEN [pager_unlock]
161 **
162 ** READER -> WRITER_LOCKED [sqlite3PagerBegin]
163 ** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
164 ** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
165 ** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
166 ** WRITER_*** -> READER [pager_end_transaction]
167 **
168 ** WRITER_*** -> ERROR [pager_error]
169 ** ERROR -> OPEN [pager_unlock]
170 **
171 **
172 ** OPEN:
173 **
174 ** The pager starts up in this state. Nothing is guaranteed in this
175 ** state - the file may or may not be locked and the database size is
176 ** unknown. The database may not be read or written.
177 **
178 ** * No read or write transaction is active.
179 ** * Any lock, or no lock at all, may be held on the database file.
180 ** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
181 **
182 ** READER:
183 **
184 ** In this state all the requirements for reading the database in
185 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
186 ** was) in exclusive-locking mode, a user-level read transaction is
187 ** open. The database size is known in this state.
188 **
189 ** A connection running with locking_mode=normal enters this state when
190 ** it opens a read-transaction on the database and returns to state
191 ** OPEN after the read-transaction is completed. However a connection
192 ** running in locking_mode=exclusive (including temp databases) remains in
193 ** this state even after the read-transaction is closed. The only way
194 ** a locking_mode=exclusive connection can transition from READER to OPEN
195 ** is via the ERROR state (see below).
196 **
197 ** * A read transaction may be active (but a write-transaction cannot).
198 ** * A SHARED or greater lock is held on the database file.
199 ** * The dbSize variable may be trusted (even if a user-level read
200 ** transaction is not active). The dbOrigSize and dbFileSize variables
201 ** may not be trusted at this point.
202 ** * If the database is a WAL database, then the WAL connection is open.
203 ** * Even if a read-transaction is not open, it is guaranteed that
204 ** there is no hot-journal in the file-system.
205 **
206 ** WRITER_LOCKED:
207 **
208 ** The pager moves to this state from READER when a write-transaction
209 ** is first opened on the database. In WRITER_LOCKED state, all locks
210 ** required to start a write-transaction are held, but no actual
211 ** modifications to the cache or database have taken place.
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.
223 **
224 ** * A write transaction is active.
225 ** * If the connection is open in rollback-mode, a RESERVED or greater
226 ** lock is held on the database file.
227 ** * If the connection is open in WAL-mode, a WAL write transaction
228 ** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully
229 ** called).
230 ** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
231 ** * The contents of the pager cache have not been modified.
232 ** * The journal file may or may not be open.
233 ** * Nothing (not even the first header) has been written to the journal.
234 **
235 ** WRITER_CACHEMOD:
236 **
237 ** A pager moves from WRITER_LOCKED state to this state when a page is
238 ** first modified by the upper layer. In rollback mode the journal file
239 ** is opened (if it is not already open) and a header written to the
240 ** start of it. The database file on disk has not been modified.
241 **
242 ** * A write transaction is active.
243 ** * A RESERVED or greater lock is held on the database file.
244 ** * The journal file is open and the first header has been written
245 ** to it, but the header has not been synced to disk.
246 ** * The contents of the page cache have been modified.
247 **
248 ** WRITER_DBMOD:
249 **
250 ** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
251 ** when it modifies the contents of the database file. WAL connections
252 ** never enter this state (since they do not modify the database file,
253 ** just the log file).
254 **
255 ** * A write transaction is active.
256 ** * An EXCLUSIVE or greater lock is held on the database file.
257 ** * The journal file is open and the first header has been written
258 ** and synced to disk.
259 ** * The contents of the page cache have been modified (and possibly
260 ** written to disk).
261 **
262 ** WRITER_FINISHED:
263 **
264 ** 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 **
273 ** * A write transaction is active.
274 ** * An EXCLUSIVE or greater lock is held on the database file.
275 ** * All writing and syncing of journal and database data has finished.
276 ** If no error occurred, all that remains is to finalize the journal to
277 ** commit the transaction. If an error did occur, the caller will need
278 ** to rollback the transaction.
279 **
280 ** ERROR:
281 **
282 ** The ERROR state is entered when an IO or disk-full error (including
283 ** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it
284 ** difficult to be sure that the in-memory pager state (cache contents,
285 ** db size etc.) are consistent with the contents of the file-system.
286 **
287 ** Temporary pager files may enter the ERROR state, but in-memory pagers
288 ** cannot.
289 **
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
302 ** transition back to OPEN state, discarding the contents of the
303 ** page-cache and any other in-memory state at the same time. Everything
304 ** is reloaded from disk (and, if necessary, hot-journal rollback peformed)
305 ** when a read-transaction is next opened on the pager (transitioning
306 ** the pager into READER state). At that point the system has recovered
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.
331 **
332 ** * The Pager.errCode variable is set to something other than SQLITE_OK.
333 ** * There are one or more outstanding references to pages (after the
334 ** last reference is dropped the pager should move back to OPEN state).
335 ** * The pager is not an in-memory pager.
336 **
337 **
338 ** 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 **
344 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
345 ** state. There are two exceptions: immediately after exclusive-mode has
346 ** been turned on (and before any read or write transactions are
347 ** executed), and when the pager is leaving the "error state".
348 **
349 ** * See also: assert_pager_state().
350 */
351 #define PAGER_OPEN 0
352 #define PAGER_READER 1
353 #define PAGER_WRITER_LOCKED 2
354 #define PAGER_WRITER_CACHEMOD 3
355 #define PAGER_WRITER_DBMOD 4
356 #define PAGER_WRITER_FINISHED 5
357 #define PAGER_ERROR 6
358
359 /*
360 ** The Pager.eLock variable is almost always set to one of the
361 ** following locking-states, according to the lock currently held on
362 ** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
363 ** This variable is kept up to date as locks are taken and released by
364 ** the pagerLockDb() and pagerUnlockDb() wrappers.
365 **
366 ** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY
367 ** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
368 ** the operation was successful. In these circumstances pagerLockDb() and
369 ** pagerUnlockDb() take a conservative approach - eLock is always updated
370 ** when unlocking the file, and only updated when locking the file if the
371 ** VFS call is successful. This way, the Pager.eLock variable may be set
372 ** to a less exclusive (lower) value than the lock that is actually held
373 ** at the system level, but it is never set to a more exclusive value.
374 **
375 ** This is usually safe. If an xUnlock fails or appears to fail, there may
376 ** be a few redundant xLock() calls or a lock may be held for longer than
377 ** required, but nothing really goes wrong.
378 **
379 ** The exception is when the database file is unlocked as the pager moves
380 ** from ERROR to OPEN state. At this point there may be a hot-journal file
381 ** in the file-system that needs to be rolled back (as part of an OPEN->SHARED
382 ** transition, by the same pager or any other). If the call to xUnlock()
383 ** fails at this point and the pager is left holding an EXCLUSIVE lock, this
384 ** can confuse the call to xCheckReservedLock() call made later as part
385 ** of hot-journal detection.
386 **
387 ** xCheckReservedLock() is defined as returning true "if there is a RESERVED
388 ** lock held by this process or any others". So xCheckReservedLock may
389 ** return true because the caller itself is holding an EXCLUSIVE lock (but
390 ** doesn't know it because of a previous error in xUnlock). If this happens
391 ** a hot-journal may be mistaken for a journal being created by an active
392 ** transaction in another process, causing SQLite to read from the database
393 ** without rolling it back.
394 **
395 ** To work around this, if a call to xUnlock() fails when unlocking the
396 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
397 ** is only changed back to a real locking state after a successful call
398 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
399 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
400 ** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
401 ** lock on the database file before attempting to roll it back. See function
402 ** PagerSharedLock() for more detail.
403 **
404 ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
405 ** PAGER_OPEN state.
406 */
407 #define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)
408
409 /*
410 ** A macro used for invoking the codec if there is one
411 */
412 #ifdef SQLITE_HAS_CODEC
413 # define CODEC1(P,D,N,X,E) \
414 if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
415 # define CODEC2(P,D,N,X,E,O) \
416 if( P->xCodec==0 ){ O=(char*)D; }else \
417 if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
418 #else
419 # define CODEC1(P,D,N,X,E) /* NO-OP */
420 # define CODEC2(P,D,N,X,E,O) O=(char*)D
421 #endif
422
423 /*
424 ** The maximum allowed sector size. 64KiB. If the xSectorsize() method
425 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
426 ** This could conceivably cause corruption following a power failure on
427 ** such a system. This is currently an undocumented limit.
428 */
429 #define MAX_SECTOR_SIZE 0x10000
430
431 /*
432 ** An instance of the following structure is allocated for each active
433 ** savepoint and statement transaction in the system. All such structures
434 ** are stored in the Pager.aSavepoint[] array, which is allocated and
435 ** resized using sqlite3Realloc().
436 **
437 ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
438 ** set to 0. If a journal-header is written into the main journal while
439 ** the savepoint is active, then iHdrOffset is set to the byte offset
440 ** immediately following the last journal record written into the main
441 ** journal before the journal-header. This is required during savepoint
442 ** rollback (see pagerPlaybackSavepoint()).
443 */
444 typedef struct PagerSavepoint PagerSavepoint;
445 struct PagerSavepoint {
446 i64 iOffset; /* Starting offset in main journal */
447 i64 iHdrOffset; /* See above */
448 Bitvec *pInSavepoint; /* Set of pages in this savepoint */
449 Pgno nOrig; /* Original number of pages in file */
450 Pgno iSubRec; /* Index of first record in sub-journal */
451 #ifndef SQLITE_OMIT_WAL
452 u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
453 #endif
454 };
455
456 /*
457 ** Bits of the Pager.doNotSpill flag. See further description below.
458 */
459 #define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */
460 #define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */
461 #define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */
462
463 /*
464 ** An open page cache is an instance of struct Pager. A description of
465 ** some of the more important member variables follows:
466 **
467 ** eState
468 **
469 ** The current 'state' of the pager object. See the comment and state
470 ** diagram above for a description of the pager state.
471 **
472 ** eLock
473 **
474 ** For a real on-disk database, the current lock held on the database file -
475 ** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
476 **
477 ** For a temporary or in-memory database (neither of which require any
478 ** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
479 ** databases always have Pager.exclusiveMode==1, this tricks the pager
480 ** logic into thinking that it already has all the locks it will ever
481 ** need (and no reason to release them).
482 **
483 ** In some (obscure) circumstances, this variable may also be set to
484 ** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
485 ** details.
486 **
487 ** changeCountDone
488 **
489 ** This boolean variable is used to make sure that the change-counter
490 ** (the 4-byte header field at byte offset 24 of the database file) is
491 ** not updated more often than necessary.
492 **
493 ** It is set to true when the change-counter field is updated, which
494 ** can only happen if an exclusive lock is held on the database file.
495 ** It is cleared (set to false) whenever an exclusive lock is
496 ** relinquished on the database file. Each time a transaction is committed,
497 ** The changeCountDone flag is inspected. If it is true, the work of
498 ** updating the change-counter is omitted for the current transaction.
499 **
500 ** This mechanism means that when running in exclusive mode, a connection
501 ** need only update the change-counter once, for the first transaction
502 ** committed.
503 **
504 ** setMaster
505 **
506 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
507 ** (or may not) specify a master-journal name to be written into the
508 ** journal file before it is synced to disk.
509 **
510 ** Whether or not a journal file contains a master-journal pointer affects
511 ** the way in which the journal file is finalized after the transaction is
512 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
513 ** If a journal file does not contain a master-journal pointer, it is
514 ** finalized by overwriting the first journal header with zeroes. If
515 ** it does contain a master-journal pointer the journal file is finalized
516 ** by truncating it to zero bytes, just as if the connection were
517 ** running in "journal_mode=truncate" mode.
518 **
519 ** Journal files that contain master journal pointers cannot be finalized
520 ** simply by overwriting the first journal-header with zeroes, as the
521 ** master journal pointer could interfere with hot-journal rollback of any
522 ** subsequently interrupted transaction that reuses the journal file.
523 **
524 ** The flag is cleared as soon as the journal file is finalized (either
525 ** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
526 ** journal file from being successfully finalized, the setMaster flag
527 ** is cleared anyway (and the pager will move to ERROR state).
528 **
529 ** doNotSpill
530 **
531 ** This variables control the behavior of cache-spills (calls made by
532 ** the pcache module to the pagerStress() routine to write cached data
533 ** to the file-system in order to free up memory).
534 **
535 ** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
536 ** writing to the database from pagerStress() is disabled altogether.
537 ** The SPILLFLAG_ROLLBACK case is done in a very obscure case that
538 ** comes up during savepoint rollback that requires the pcache module
539 ** to allocate a new page to prevent the journal file from being written
540 ** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF
541 ** case is a user preference.
542 **
543 ** If the SPILLFLAG_NOSYNC bit is set, writing to the database from
544 ** pagerStress() is permitted, but syncing the journal file is not.
545 ** This flag is set by sqlite3PagerWrite() when the file-system sector-size
546 ** is larger than the database page-size in order to prevent a journal sync
547 ** from happening in between the journalling of two pages on the same sector.
548 **
549 ** subjInMemory
550 **
551 ** This is a boolean variable. If true, then any required sub-journal
552 ** is opened as an in-memory journal file. If false, then in-memory
553 ** sub-journals are only used for in-memory pager files.
554 **
555 ** This variable is updated by the upper layer each time a new
556 ** write-transaction is opened.
557 **
558 ** dbSize, dbOrigSize, dbFileSize
559 **
560 ** Variable dbSize is set to the number of pages in the database file.
561 ** It is valid in PAGER_READER and higher states (all states except for
562 ** OPEN and ERROR).
563 **
564 ** dbSize is set based on the size of the database file, which may be
565 ** larger than the size of the database (the value stored at offset
566 ** 28 of the database header by the btree). If the size of the file
567 ** is not an integer multiple of the page-size, the value stored in
568 ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
569 ** Except, any file that is greater than 0 bytes in size is considered
570 ** to have at least one page. (i.e. a 1KB file with 2K page-size leads
571 ** to dbSize==1).
572 **
573 ** During a write-transaction, if pages with page-numbers greater than
574 ** dbSize are modified in the cache, dbSize is updated accordingly.
575 ** Similarly, if the database is truncated using PagerTruncateImage(),
576 ** dbSize is updated.
577 **
578 ** Variables dbOrigSize and dbFileSize are valid in states
579 ** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
580 ** variable at the start of the transaction. It is used during rollback,
581 ** and to determine whether or not pages need to be journalled before
582 ** being modified.
583 **
584 ** Throughout a write-transaction, dbFileSize contains the size of
585 ** the file on disk in pages. It is set to a copy of dbSize when the
586 ** write-transaction is first opened, and updated when VFS calls are made
587 ** to write or truncate the database file on disk.
588 **
589 ** The only reason the dbFileSize variable is required is to suppress
590 ** unnecessary calls to xTruncate() after committing a transaction. If,
591 ** when a transaction is committed, the dbFileSize variable indicates
592 ** that the database file is larger than the database image (Pager.dbSize),
593 ** pager_truncate() is called. The pager_truncate() call uses xFilesize()
594 ** to measure the database file on disk, and then truncates it if required.
595 ** dbFileSize is not used when rolling back a transaction. In this case
596 ** pager_truncate() is called unconditionally (which means there may be
597 ** a call to xFilesize() that is not strictly required). In either case,
598 ** pager_truncate() may cause the file to become smaller or larger.
599 **
600 ** dbHintSize
601 **
602 ** The dbHintSize variable is used to limit the number of calls made to
603 ** the VFS xFileControl(FCNTL_SIZE_HINT) method.
604 **
605 ** dbHintSize is set to a copy of the dbSize variable when a
606 ** write-transaction is opened (at the same time as dbFileSize and
607 ** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
608 ** dbHintSize is increased to the number of pages that correspond to the
609 ** size-hint passed to the method call. See pager_write_pagelist() for
610 ** details.
611 **
612 ** errCode
613 **
614 ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
615 ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
616 ** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
617 ** sub-codes.
618 */
619 struct Pager {
620 sqlite3_vfs *pVfs; /* OS functions to use for IO */
621 u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
622 u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */
623 u8 useJournal; /* Use a rollback journal on this file */
624 u8 noSync; /* Do not sync the journal if true */
625 u8 fullSync; /* Do extra syncs of the journal for robustness */
626 u8 ckptSyncFlags; /* SYNC_NORMAL or SYNC_FULL for checkpoint */
627 u8 walSyncFlags; /* SYNC_NORMAL or SYNC_FULL for wal writes */
628 u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */
629 u8 tempFile; /* zFilename is a temporary or immutable file */
630 u8 noLock; /* Do not lock (except in WAL mode) */
631 u8 readOnly; /* True for a read-only database */
632 u8 memDb; /* True to inhibit all file I/O */
633
634 /**************************************************************************
635 ** The following block contains those class members that change during
636 ** routine operation. Class members not in this block are either fixed
637 ** when the pager is first created or else only change when there is a
638 ** significant mode change (such as changing the page_size, locking_mode,
639 ** or the journal_mode). From another view, these class members describe
640 ** the "state" of the pager, while other class members describe the
641 ** "configuration" of the pager.
642 */
643 u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
644 u8 eLock; /* Current lock held on database file */
645 u8 changeCountDone; /* Set after incrementing the change-counter */
646 u8 setMaster; /* True if a m-j name has been written to jrnl */
647 u8 doNotSpill; /* Do not spill the cache when non-zero */
648 u8 subjInMemory; /* True to use in-memory sub-journals */
649 u8 bUseFetch; /* True to use xFetch() */
650 u8 hasHeldSharedLock; /* True if a shared lock has ever been held */
651 Pgno dbSize; /* Number of pages in the database */
652 Pgno dbOrigSize; /* dbSize before the current transaction */
653 Pgno dbFileSize; /* Number of pages in the database file */
654 Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
655 int errCode; /* One of several kinds of errors */
656 int nRec; /* Pages journalled since last j-header written */
657 u32 cksumInit; /* Quasi-random value added to every checksum */
658 u32 nSubRec; /* Number of records written to sub-journal */
659 Bitvec *pInJournal; /* One bit for each page in the database file */
660 sqlite3_file *fd; /* File descriptor for database */
661 sqlite3_file *jfd; /* File descriptor for main journal */
662 sqlite3_file *sjfd; /* File descriptor for sub-journal */
663 i64 journalOff; /* Current write offset in the journal file */
664 i64 journalHdr; /* Byte offset to previous journal header */
665 sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
666 PagerSavepoint *aSavepoint; /* Array of active savepoints */
667 int nSavepoint; /* Number of elements in aSavepoint[] */
668 u32 iDataVersion; /* Changes whenever database content changes */
669 char dbFileVers[16]; /* Changes whenever database file changes */
670
671 int nMmapOut; /* Number of mmap pages currently outstanding */
672 sqlite3_int64 szMmap; /* Desired maximum mmap size */
673 PgHdr *pMmapFreelist; /* List of free mmap page headers (pDirty) */
674 /*
675 ** End of the routinely-changing class members
676 ***************************************************************************/
677
678 u16 nExtra; /* Add this many bytes to each in-memory page */
679 i16 nReserve; /* Number of unused bytes at end of each page */
680 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
681 u32 sectorSize; /* Assumed sector size during rollback */
682 int pageSize; /* Number of bytes in a page */
683 Pgno mxPgno; /* Maximum allowed size of the database */
684 i64 journalSizeLimit; /* Size limit for persistent journal files */
685 char *zFilename; /* Name of the database file */
686 char *zJournal; /* Name of the journal file */
687 int (*xBusyHandler)(void*); /* Function to call when busy */
688 void *pBusyHandlerArg; /* Context argument for xBusyHandler */
689 int aStat[3]; /* Total cache hits, misses and writes */
690 #ifdef SQLITE_TEST
691 int nRead; /* Database pages read */
692 #endif
693 void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
694 #ifdef SQLITE_HAS_CODEC
695 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
696 void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
697 void (*xCodecFree)(void*); /* Destructor for the codec */
698 void *pCodec; /* First argument to xCodec... methods */
699 #endif
700 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
701 PCache *pPCache; /* Pointer to page cache object */
702 #ifndef SQLITE_OMIT_WAL
703 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
704 char *zWal; /* File name for write-ahead log */
705 #endif
706 };
707
708 /*
709 ** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains
710 ** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS
711 ** or CACHE_WRITE to sqlite3_db_status().
712 */
713 #define PAGER_STAT_HIT 0
714 #define PAGER_STAT_MISS 1
715 #define PAGER_STAT_WRITE 2
716
717 /*
718 ** The following global variables hold counters used for
719 ** testing purposes only. These variables do not exist in
720 ** a non-testing build. These variables are not thread-safe.
721 */
722 #ifdef SQLITE_TEST
723 int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
724 int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
725 int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
726 # define PAGER_INCR(v) v++
727 #else
728 # define PAGER_INCR(v)
729 #endif
730
731
732
733 /*
734 ** Journal files begin with the following magic string. The data
735 ** was obtained from /dev/random. It is used only as a sanity check.
736 **
737 ** Since version 2.8.0, the journal format contains additional sanity
738 ** checking information. If the power fails while the journal is being
739 ** written, semi-random garbage data might appear in the journal
740 ** file after power is restored. If an attempt is then made
741 ** to roll the journal back, the database could be corrupted. The additional
742 ** sanity checking data is an attempt to discover the garbage in the
743 ** journal and ignore it.
744 **
745 ** The sanity checking information for the new journal format consists
746 ** of a 32-bit checksum on each page of data. The checksum covers both
747 ** the page number and the pPager->pageSize bytes of data for the page.
748 ** This cksum is initialized to a 32-bit random value that appears in the
749 ** journal file right after the header. The random initializer is important,
750 ** because garbage data that appears at the end of a journal is likely
751 ** data that was once in other files that have now been deleted. If the
752 ** garbage data came from an obsolete journal file, the checksums might
753 ** be correct. But by initializing the checksum to random value which
754 ** is different for every journal, we minimize that risk.
755 */
756 static const unsigned char aJournalMagic[] = {
757 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
758 };
759
760 /*
761 ** The size of the of each page record in the journal is given by
762 ** the following macro.
763 */
764 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
765
766 /*
767 ** The journal header size for this pager. This is usually the same
768 ** size as a single disk sector. See also setSectorSize().
769 */
770 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
771
772 /*
773 ** The macro MEMDB is true if we are dealing with an in-memory database.
774 ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
775 ** the value of MEMDB will be a constant and the compiler will optimize
776 ** out code that would never execute.
777 */
778 #ifdef SQLITE_OMIT_MEMORYDB
779 # define MEMDB 0
780 #else
781 # define MEMDB pPager->memDb
782 #endif
783
784 /*
785 ** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
786 ** interfaces to access the database using memory-mapped I/O.
787 */
788 #if SQLITE_MAX_MMAP_SIZE>0
789 # define USEFETCH(x) ((x)->bUseFetch)
790 #else
791 # define USEFETCH(x) 0
792 #endif
793
794 /*
795 ** The maximum legal page number is (2^31 - 1).
796 */
797 #define PAGER_MAX_PGNO 2147483647
798
799 /*
800 ** The argument to this macro is a file descriptor (type sqlite3_file*).
801 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
802 **
803 ** This is so that expressions can be written as:
804 **
805 ** if( isOpen(pPager->jfd) ){ ...
806 **
807 ** instead of
808 **
809 ** if( pPager->jfd->pMethods ){ ...
810 */
811 #define isOpen(pFd) ((pFd)->pMethods!=0)
812
813 /*
814 ** Return true if this pager uses a write-ahead log instead of the usual
815 ** rollback journal. Otherwise false.
816 */
817 #ifndef SQLITE_OMIT_WAL
818 static int pagerUseWal(Pager *pPager){
819 return (pPager->pWal!=0);
820 }
821 #else
822 # define pagerUseWal(x) 0
823 # define pagerRollbackWal(x) 0
824 # define pagerWalFrames(v,w,x,y) 0
825 # define pagerOpenWalIfPresent(z) SQLITE_OK
826 # define pagerBeginReadTransaction(z) SQLITE_OK
827 #endif
828
829 #ifndef NDEBUG
830 /*
831 ** Usage:
832 **
833 ** assert( assert_pager_state(pPager) );
834 **
835 ** This function runs many asserts to try to find inconsistencies in
836 ** the internal state of the Pager object.
837 */
838 static int assert_pager_state(Pager *p){
839 Pager *pPager = p;
840
841 /* State must be valid. */
842 assert( p->eState==PAGER_OPEN
843 || p->eState==PAGER_READER
844 || p->eState==PAGER_WRITER_LOCKED
845 || p->eState==PAGER_WRITER_CACHEMOD
846 || p->eState==PAGER_WRITER_DBMOD
847 || p->eState==PAGER_WRITER_FINISHED
848 || p->eState==PAGER_ERROR
849 );
850
851 /* Regardless of the current state, a temp-file connection always behaves
852 ** as if it has an exclusive lock on the database file. It never updates
853 ** the change-counter field, so the changeCountDone flag is always set.
854 */
855 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
856 assert( p->tempFile==0 || pPager->changeCountDone );
857
858 /* If the useJournal flag is clear, the journal-mode must be "OFF".
859 ** And if the journal-mode is "OFF", the journal file must not be open.
860 */
861 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
862 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
863
864 /* Check that MEMDB implies noSync. And an in-memory journal. Since
865 ** this means an in-memory pager performs no IO at all, it cannot encounter
866 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
867 ** a journal file. (although the in-memory journal implementation may
868 ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
869 ** is therefore not possible for an in-memory pager to enter the ERROR
870 ** state.
871 */
872 if( MEMDB ){
873 assert( p->noSync );
874 assert( p->journalMode==PAGER_JOURNALMODE_OFF
875 || p->journalMode==PAGER_JOURNALMODE_MEMORY
876 );
877 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
878 assert( pagerUseWal(p)==0 );
879 }
880
881 /* If changeCountDone is set, a RESERVED lock or greater must be held
882 ** on the file.
883 */
884 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
885 assert( p->eLock!=PENDING_LOCK );
886
887 switch( p->eState ){
888 case PAGER_OPEN:
889 assert( !MEMDB );
890 assert( pPager->errCode==SQLITE_OK );
891 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
892 break;
893
894 case PAGER_READER:
895 assert( pPager->errCode==SQLITE_OK );
896 assert( p->eLock!=UNKNOWN_LOCK );
897 assert( p->eLock>=SHARED_LOCK );
898 break;
899
900 case PAGER_WRITER_LOCKED:
901 assert( p->eLock!=UNKNOWN_LOCK );
902 assert( pPager->errCode==SQLITE_OK );
903 if( !pagerUseWal(pPager) ){
904 assert( p->eLock>=RESERVED_LOCK );
905 }
906 assert( pPager->dbSize==pPager->dbOrigSize );
907 assert( pPager->dbOrigSize==pPager->dbFileSize );
908 assert( pPager->dbOrigSize==pPager->dbHintSize );
909 assert( pPager->setMaster==0 );
910 break;
911
912 case PAGER_WRITER_CACHEMOD:
913 assert( p->eLock!=UNKNOWN_LOCK );
914 assert( pPager->errCode==SQLITE_OK );
915 if( !pagerUseWal(pPager) ){
916 /* It is possible that if journal_mode=wal here that neither the
917 ** journal file nor the WAL file are open. This happens during
918 ** a rollback transaction that switches from journal_mode=off
919 ** to journal_mode=wal.
920 */
921 assert( p->eLock>=RESERVED_LOCK );
922 assert( isOpen(p->jfd)
923 || p->journalMode==PAGER_JOURNALMODE_OFF
924 || p->journalMode==PAGER_JOURNALMODE_WAL
925 );
926 }
927 assert( pPager->dbOrigSize==pPager->dbFileSize );
928 assert( pPager->dbOrigSize==pPager->dbHintSize );
929 break;
930
931 case PAGER_WRITER_DBMOD:
932 assert( p->eLock==EXCLUSIVE_LOCK );
933 assert( pPager->errCode==SQLITE_OK );
934 assert( !pagerUseWal(pPager) );
935 assert( p->eLock>=EXCLUSIVE_LOCK );
936 assert( isOpen(p->jfd)
937 || p->journalMode==PAGER_JOURNALMODE_OFF
938 || p->journalMode==PAGER_JOURNALMODE_WAL
939 );
940 assert( pPager->dbOrigSize<=pPager->dbHintSize );
941 break;
942
943 case PAGER_WRITER_FINISHED:
944 assert( p->eLock==EXCLUSIVE_LOCK );
945 assert( pPager->errCode==SQLITE_OK );
946 assert( !pagerUseWal(pPager) );
947 assert( isOpen(p->jfd)
948 || p->journalMode==PAGER_JOURNALMODE_OFF
949 || p->journalMode==PAGER_JOURNALMODE_WAL
950 );
951 break;
952
953 case PAGER_ERROR:
954 /* There must be at least one outstanding reference to the pager if
955 ** in ERROR state. Otherwise the pager should have already dropped
956 ** back to OPEN state.
957 */
958 assert( pPager->errCode!=SQLITE_OK );
959 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
960 break;
961 }
962
963 return 1;
964 }
965 #endif /* ifndef NDEBUG */
966
967 #ifdef SQLITE_DEBUG
968 /*
969 ** Return a pointer to a human readable string in a static buffer
970 ** containing the state of the Pager object passed as an argument. This
971 ** is intended to be used within debuggers. For example, as an alternative
972 ** to "print *pPager" in gdb:
973 **
974 ** (gdb) printf "%s", print_pager_state(pPager)
975 */
976 static char *print_pager_state(Pager *p){
977 static char zRet[1024];
978
979 sqlite3_snprintf(1024, zRet,
980 "Filename: %s\n"
981 "State: %s errCode=%d\n"
982 "Lock: %s\n"
983 "Locking mode: locking_mode=%s\n"
984 "Journal mode: journal_mode=%s\n"
985 "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
986 "Journal: journalOff=%lld journalHdr=%lld\n"
987 "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
988 , p->zFilename
989 , p->eState==PAGER_OPEN ? "OPEN" :
990 p->eState==PAGER_READER ? "READER" :
991 p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
992 p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
993 p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
994 p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
995 p->eState==PAGER_ERROR ? "ERROR" : "?error?"
996 , (int)p->errCode
997 , p->eLock==NO_LOCK ? "NO_LOCK" :
998 p->eLock==RESERVED_LOCK ? "RESERVED" :
999 p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
1000 p->eLock==SHARED_LOCK ? "SHARED" :
1001 p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
1002 , p->exclusiveMode ? "exclusive" : "normal"
1003 , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
1004 p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
1005 p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
1006 p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
1007 p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
1008 p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
1009 , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
1010 , p->journalOff, p->journalHdr
1011 , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
1012 );
1013
1014 return zRet;
1015 }
1016 #endif
1017
1018 /*
1019 ** Return true if it is necessary to write page *pPg into the sub-journal.
1020 ** A page needs to be written into the sub-journal if there exists one
1021 ** or more open savepoints for which:
1022 **
1023 ** * The page-number is less than or equal to PagerSavepoint.nOrig, and
1024 ** * The bit corresponding to the page-number is not set in
1025 ** PagerSavepoint.pInSavepoint.
1026 */
1027 static int subjRequiresPage(PgHdr *pPg){
1028 Pager *pPager = pPg->pPager;
1029 PagerSavepoint *p;
1030 Pgno pgno = pPg->pgno;
1031 int i;
1032 for(i=0; i<pPager->nSavepoint; i++){
1033 p = &pPager->aSavepoint[i];
1034 if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
1035 return 1;
1036 }
1037 }
1038 return 0;
1039 }
1040
1041 #ifdef SQLITE_DEBUG
1042 /*
1043 ** Return true if the page is already in the journal file.
1044 */
1045 static int pageInJournal(Pager *pPager, PgHdr *pPg){
1046 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
1047 }
1048 #endif
1049
1050 /*
1051 ** Read a 32-bit integer from the given file descriptor. Store the integer
1052 ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
1053 ** error code is something goes wrong.
1054 **
1055 ** All values are stored on disk as big-endian.
1056 */
1057 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
1058 unsigned char ac[4];
1059 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
1060 if( rc==SQLITE_OK ){
1061 *pRes = sqlite3Get4byte(ac);
1062 }
1063 return rc;
1064 }
1065
1066 /*
1067 ** Write a 32-bit integer into a string buffer in big-endian byte order.
1068 */
1069 #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
1070
1071
1072 /*
1073 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
1074 ** on success or an error code is something goes wrong.
1075 */
1076 static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
1077 char ac[4];
1078 put32bits(ac, val);
1079 return sqlite3OsWrite(fd, ac, 4, offset);
1080 }
1081
1082 /*
1083 ** Unlock the database file to level eLock, which must be either NO_LOCK
1084 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
1085 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
1086 **
1087 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1088 ** called, do not modify it. See the comment above the #define of
1089 ** UNKNOWN_LOCK for an explanation of this.
1090 */
1091 static int pagerUnlockDb(Pager *pPager, int eLock){
1092 int rc = SQLITE_OK;
1093
1094 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
1095 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
1096 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
1097 if( isOpen(pPager->fd) ){
1098 assert( pPager->eLock>=eLock );
1099 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
1100 if( pPager->eLock!=UNKNOWN_LOCK ){
1101 pPager->eLock = (u8)eLock;
1102 }
1103 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
1104 }
1105 return rc;
1106 }
1107
1108 /*
1109 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
1110 ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
1111 ** Pager.eLock variable to the new locking state.
1112 **
1113 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
1114 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
1115 ** See the comment above the #define of UNKNOWN_LOCK for an explanation
1116 ** of this.
1117 */
1118 static int pagerLockDb(Pager *pPager, int eLock){
1119 int rc = SQLITE_OK;
1120
1121 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
1122 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
1123 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
1124 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
1125 pPager->eLock = (u8)eLock;
1126 IOTRACE(("LOCK %p %d\n", pPager, eLock))
1127 }
1128 }
1129 return rc;
1130 }
1131
1132 /*
1133 ** This function determines whether or not the atomic-write optimization
1134 ** can be used with this pager. The optimization can be used if:
1135 **
1136 ** (a) the value returned by OsDeviceCharacteristics() indicates that
1137 ** a database page may be written atomically, and
1138 ** (b) the value returned by OsSectorSize() is less than or equal
1139 ** to the page size.
1140 **
1141 ** The optimization is also always enabled for temporary files. It is
1142 ** an error to call this function if pPager is opened on an in-memory
1143 ** database.
1144 **
1145 ** If the optimization cannot be used, 0 is returned. If it can be used,
1146 ** then the value returned is the size of the journal file when it
1147 ** contains rollback data for exactly one page.
1148 */
1149 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
1150 static int jrnlBufferSize(Pager *pPager){
1151 assert( !MEMDB );
1152 if( !pPager->tempFile ){
1153 int dc; /* Device characteristics */
1154 int nSector; /* Sector size */
1155 int szPage; /* Page size */
1156
1157 assert( isOpen(pPager->fd) );
1158 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
1159 nSector = pPager->sectorSize;
1160 szPage = pPager->pageSize;
1161
1162 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
1163 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
1164 if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
1165 return 0;
1166 }
1167 }
1168
1169 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
1170 }
1171 #endif
1172
1173 /*
1174 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
1175 ** on the cache using a hash function. This is used for testing
1176 ** and debugging only.
1177 */
1178 #ifdef SQLITE_CHECK_PAGES
1179 /*
1180 ** Return a 32-bit hash of the page data for pPage.
1181 */
1182 static u32 pager_datahash(int nByte, unsigned char *pData){
1183 u32 hash = 0;
1184 int i;
1185 for(i=0; i<nByte; i++){
1186 hash = (hash*1039) + pData[i];
1187 }
1188 return hash;
1189 }
1190 static u32 pager_pagehash(PgHdr *pPage){
1191 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
1192 }
1193 static void pager_set_pagehash(PgHdr *pPage){
1194 pPage->pageHash = pager_pagehash(pPage);
1195 }
1196
1197 /*
1198 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
1199 ** is defined, and NDEBUG is not defined, an assert() statement checks
1200 ** that the page is either dirty or still matches the calculated page-hash.
1201 */
1202 #define CHECK_PAGE(x) checkPage(x)
1203 static void checkPage(PgHdr *pPg){
1204 Pager *pPager = pPg->pPager;
1205 assert( pPager->eState!=PAGER_ERROR );
1206 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
1207 }
1208
1209 #else
1210 #define pager_datahash(X,Y) 0
1211 #define pager_pagehash(X) 0
1212 #define pager_set_pagehash(X)
1213 #define CHECK_PAGE(x)
1214 #endif /* SQLITE_CHECK_PAGES */
1215
1216 /*
1217 ** When this is called the journal file for pager pPager must be open.
1218 ** This function attempts to read a master journal file name from the
1219 ** end of the file and, if successful, copies it into memory supplied
1220 ** by the caller. See comments above writeMasterJournal() for the format
1221 ** used to store a master journal file name at the end of a journal file.
1222 **
1223 ** zMaster must point to a buffer of at least nMaster bytes allocated by
1224 ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
1225 ** enough space to write the master journal name). If the master journal
1226 ** name in the journal is longer than nMaster bytes (including a
1227 ** nul-terminator), then this is handled as if no master journal name
1228 ** were present in the journal.
1229 **
1230 ** If a master journal file name is present at the end of the journal
1231 ** file, then it is copied into the buffer pointed to by zMaster. A
1232 ** nul-terminator byte is appended to the buffer following the master
1233 ** journal file name.
1234 **
1235 ** If it is determined that no master journal file name is present
1236 ** zMaster[0] is set to 0 and SQLITE_OK returned.
1237 **
1238 ** If an error occurs while reading from the journal file, an SQLite
1239 ** error code is returned.
1240 */
1241 static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
1242 int rc; /* Return code */
1243 u32 len; /* Length in bytes of master journal name */
1244 i64 szJ; /* Total size in bytes of journal file pJrnl */
1245 u32 cksum; /* MJ checksum value read from journal */
1246 u32 u; /* Unsigned loop counter */
1247 unsigned char aMagic[8]; /* A buffer to hold the magic header */
1248 zMaster[0] = '\0';
1249
1250 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
1251 || szJ<16
1252 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
1253 || len>=nMaster
1254 || len==0
1255 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
1256 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
1257 || memcmp(aMagic, aJournalMagic, 8)
1258 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
1259 ){
1260 return rc;
1261 }
1262
1263 /* See if the checksum matches the master journal name */
1264 for(u=0; u<len; u++){
1265 cksum -= zMaster[u];
1266 }
1267 if( cksum ){
1268 /* If the checksum doesn't add up, then one or more of the disk sectors
1269 ** containing the master journal filename is corrupted. This means
1270 ** definitely roll back, so just return SQLITE_OK and report a (nul)
1271 ** master-journal filename.
1272 */
1273 len = 0;
1274 }
1275 zMaster[len] = '\0';
1276
1277 return SQLITE_OK;
1278 }
1279
1280 /*
1281 ** Return the offset of the sector boundary at or immediately
1282 ** following the value in pPager->journalOff, assuming a sector
1283 ** size of pPager->sectorSize bytes.
1284 **
1285 ** i.e for a sector size of 512:
1286 **
1287 ** Pager.journalOff Return value
1288 ** ---------------------------------------
1289 ** 0 0
1290 ** 512 512
1291 ** 100 512
1292 ** 2000 2048
1293 **
1294 */
1295 static i64 journalHdrOffset(Pager *pPager){
1296 i64 offset = 0;
1297 i64 c = pPager->journalOff;
1298 if( c ){
1299 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
1300 }
1301 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
1302 assert( offset>=c );
1303 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
1304 return offset;
1305 }
1306
1307 /*
1308 ** The journal file must be open when this function is called.
1309 **
1310 ** This function is a no-op if the journal file has not been written to
1311 ** within the current transaction (i.e. if Pager.journalOff==0).
1312 **
1313 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
1314 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
1315 ** zero the 28-byte header at the start of the journal file. In either case,
1316 ** if the pager is not in no-sync mode, sync the journal file immediately
1317 ** after writing or truncating it.
1318 **
1319 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
1320 ** following the truncation or zeroing described above the size of the
1321 ** journal file in bytes is larger than this value, then truncate the
1322 ** journal file to Pager.journalSizeLimit bytes. The journal file does
1323 ** not need to be synced following this operation.
1324 **
1325 ** If an IO error occurs, abandon processing and return the IO error code.
1326 ** Otherwise, return SQLITE_OK.
1327 */
1328 static int zeroJournalHdr(Pager *pPager, int doTruncate){
1329 int rc = SQLITE_OK; /* Return code */
1330 assert( isOpen(pPager->jfd) );
1331 if( pPager->journalOff ){
1332 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
1333
1334 IOTRACE(("JZEROHDR %p\n", pPager))
1335 if( doTruncate || iLimit==0 ){
1336 rc = sqlite3OsTruncate(pPager->jfd, 0);
1337 }else{
1338 static const char zeroHdr[28] = {0};
1339 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
1340 }
1341 if( rc==SQLITE_OK && !pPager->noSync ){
1342 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
1343 }
1344
1345 /* At this point the transaction is committed but the write lock
1346 ** is still held on the file. If there is a size limit configured for
1347 ** the persistent journal and the journal file currently consumes more
1348 ** space than that limit allows for, truncate it now. There is no need
1349 ** to sync the file following this operation.
1350 */
1351 if( rc==SQLITE_OK && iLimit>0 ){
1352 i64 sz;
1353 rc = sqlite3OsFileSize(pPager->jfd, &sz);
1354 if( rc==SQLITE_OK && sz>iLimit ){
1355 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
1356 }
1357 }
1358 }
1359 return rc;
1360 }
1361
1362 /*
1363 ** The journal file must be open when this routine is called. A journal
1364 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
1365 ** current location.
1366 **
1367 ** The format for the journal header is as follows:
1368 ** - 8 bytes: Magic identifying journal format.
1369 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
1370 ** - 4 bytes: Random number used for page hash.
1371 ** - 4 bytes: Initial database page count.
1372 ** - 4 bytes: Sector size used by the process that wrote this journal.
1373 ** - 4 bytes: Database page size.
1374 **
1375 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
1376 */
1377 static int writeJournalHdr(Pager *pPager){
1378 int rc = SQLITE_OK; /* Return code */
1379 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
1380 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
1381 u32 nWrite; /* Bytes of header sector written */
1382 int ii; /* Loop counter */
1383
1384 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
1385
1386 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
1387 nHeader = JOURNAL_HDR_SZ(pPager);
1388 }
1389
1390 /* If there are active savepoints and any of them were created
1391 ** since the most recent journal header was written, update the
1392 ** PagerSavepoint.iHdrOffset fields now.
1393 */
1394 for(ii=0; ii<pPager->nSavepoint; ii++){
1395 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
1396 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
1397 }
1398 }
1399
1400 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
1401
1402 /*
1403 ** Write the nRec Field - the number of page records that follow this
1404 ** journal header. Normally, zero is written to this value at this time.
1405 ** After the records are added to the journal (and the journal synced,
1406 ** if in full-sync mode), the zero is overwritten with the true number
1407 ** of records (see syncJournal()).
1408 **
1409 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
1410 ** reading the journal this value tells SQLite to assume that the
1411 ** rest of the journal file contains valid page records. This assumption
1412 ** is dangerous, as if a failure occurred whilst writing to the journal
1413 ** file it may contain some garbage data. There are two scenarios
1414 ** where this risk can be ignored:
1415 **
1416 ** * When the pager is in no-sync mode. Corruption can follow a
1417 ** power failure in this case anyway.
1418 **
1419 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1420 ** that garbage data is never appended to the journal file.
1421 */
1422 assert( isOpen(pPager->fd) || pPager->noSync );
1423 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
1424 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
1425 ){
1426 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
1427 put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
1428 }else{
1429 memset(zHeader, 0, sizeof(aJournalMagic)+4);
1430 }
1431
1432 /* The random check-hash initializer */
1433 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
1434 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
1435 /* The initial database size */
1436 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
1437 /* The assumed sector size for this process */
1438 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
1439
1440 /* The page size */
1441 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
1442
1443 /* Initializing the tail of the buffer is not necessary. Everything
1444 ** works find if the following memset() is omitted. But initializing
1445 ** the memory prevents valgrind from complaining, so we are willing to
1446 ** take the performance hit.
1447 */
1448 memset(&zHeader[sizeof(aJournalMagic)+20], 0,
1449 nHeader-(sizeof(aJournalMagic)+20));
1450
1451 /* In theory, it is only necessary to write the 28 bytes that the
1452 ** journal header consumes to the journal file here. Then increment the
1453 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
1454 ** record is written to the following sector (leaving a gap in the file
1455 ** that will be implicitly filled in by the OS).
1456 **
1457 ** However it has been discovered that on some systems this pattern can
1458 ** be significantly slower than contiguously writing data to the file,
1459 ** even if that means explicitly writing data to the block of
1460 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
1461 ** is done.
1462 **
1463 ** The loop is required here in case the sector-size is larger than the
1464 ** database page size. Since the zHeader buffer is only Pager.pageSize
1465 ** bytes in size, more than one call to sqlite3OsWrite() may be required
1466 ** to populate the entire journal header sector.
1467 */
1468 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
1469 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
1470 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
1471 assert( pPager->journalHdr <= pPager->journalOff );
1472 pPager->journalOff += nHeader;
1473 }
1474
1475 return rc;
1476 }
1477
1478 /*
1479 ** The journal file must be open when this is called. A journal header file
1480 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
1481 ** file. The current location in the journal file is given by
1482 ** pPager->journalOff. See comments above function writeJournalHdr() for
1483 ** a description of the journal header format.
1484 **
1485 ** If the header is read successfully, *pNRec is set to the number of
1486 ** page records following this header and *pDbSize is set to the size of the
1487 ** database before the transaction began, in pages. Also, pPager->cksumInit
1488 ** is set to the value read from the journal header. SQLITE_OK is returned
1489 ** in this case.
1490 **
1491 ** If the journal header file appears to be corrupted, SQLITE_DONE is
1492 ** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
1493 ** cannot be read from the journal file an error code is returned.
1494 */
1495 static int readJournalHdr(
1496 Pager *pPager, /* Pager object */
1497 int isHot,
1498 i64 journalSize, /* Size of the open journal file in bytes */
1499 u32 *pNRec, /* OUT: Value read from the nRec field */
1500 u32 *pDbSize /* OUT: Value of original database size field */
1501 ){
1502 int rc; /* Return code */
1503 unsigned char aMagic[8]; /* A buffer to hold the magic header */
1504 i64 iHdrOff; /* Offset of journal header being read */
1505
1506 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
1507
1508 /* Advance Pager.journalOff to the start of the next sector. If the
1509 ** journal file is too small for there to be a header stored at this
1510 ** point, return SQLITE_DONE.
1511 */
1512 pPager->journalOff = journalHdrOffset(pPager);
1513 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
1514 return SQLITE_DONE;
1515 }
1516 iHdrOff = pPager->journalOff;
1517
1518 /* Read in the first 8 bytes of the journal header. If they do not match
1519 ** the magic string found at the start of each journal header, return
1520 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
1521 ** proceed.
1522 */
1523 if( isHot || iHdrOff!=pPager->journalHdr ){
1524 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
1525 if( rc ){
1526 return rc;
1527 }
1528 if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
1529 return SQLITE_DONE;
1530 }
1531 }
1532
1533 /* Read the first three 32-bit fields of the journal header: The nRec
1534 ** field, the checksum-initializer and the database size at the start
1535 ** of the transaction. Return an error code if anything goes wrong.
1536 */
1537 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
1538 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
1539 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
1540 ){
1541 return rc;
1542 }
1543
1544 if( pPager->journalOff==0 ){
1545 u32 iPageSize; /* Page-size field of journal header */
1546 u32 iSectorSize; /* Sector-size field of journal header */
1547
1548 /* Read the page-size and sector-size journal header fields. */
1549 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
1550 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
1551 ){
1552 return rc;
1553 }
1554
1555 /* Versions of SQLite prior to 3.5.8 set the page-size field of the
1556 ** journal header to zero. In this case, assume that the Pager.pageSize
1557 ** variable is already set to the correct page size.
1558 */
1559 if( iPageSize==0 ){
1560 iPageSize = pPager->pageSize;
1561 }
1562
1563 /* Check that the values read from the page-size and sector-size fields
1564 ** are within range. To be 'in range', both values need to be a power
1565 ** of two greater than or equal to 512 or 32, and not greater than their
1566 ** respective compile time maximum limits.
1567 */
1568 if( iPageSize<512 || iSectorSize<32
1569 || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
1570 || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
1571 ){
1572 /* If the either the page-size or sector-size in the journal-header is
1573 ** invalid, then the process that wrote the journal-header must have
1574 ** crashed before the header was synced. In this case stop reading
1575 ** the journal file here.
1576 */
1577 return SQLITE_DONE;
1578 }
1579
1580 /* Update the page-size to match the value read from the journal.
1581 ** Use a testcase() macro to make sure that malloc failure within
1582 ** PagerSetPagesize() is tested.
1583 */
1584 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
1585 testcase( rc!=SQLITE_OK );
1586
1587 /* Update the assumed sector-size to match the value used by
1588 ** the process that created this journal. If this journal was
1589 ** created by a process other than this one, then this routine
1590 ** is being called from within pager_playback(). The local value
1591 ** of Pager.sectorSize is restored at the end of that routine.
1592 */
1593 pPager->sectorSize = iSectorSize;
1594 }
1595
1596 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
1597 return rc;
1598 }
1599
1600
1601 /*
1602 ** Write the supplied master journal name into the journal file for pager
1603 ** pPager at the current location. The master journal name must be the last
1604 ** thing written to a journal file. If the pager is in full-sync mode, the
1605 ** journal file descriptor is advanced to the next sector boundary before
1606 ** anything is written. The format is:
1607 **
1608 ** + 4 bytes: PAGER_MJ_PGNO.
1609 ** + N bytes: Master journal filename in utf-8.
1610 ** + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
1611 ** + 4 bytes: Master journal name checksum.
1612 ** + 8 bytes: aJournalMagic[].
1613 **
1614 ** The master journal page checksum is the sum of the bytes in the master
1615 ** journal name, where each byte is interpreted as a signed 8-bit integer.
1616 **
1617 ** If zMaster is a NULL pointer (occurs for a single database transaction),
1618 ** this call is a no-op.
1619 */
1620 static int writeMasterJournal(Pager *pPager, const char *zMaster){
1621 int rc; /* Return code */
1622 int nMaster; /* Length of string zMaster */
1623 i64 iHdrOff; /* Offset of header in journal file */
1624 i64 jrnlSize; /* Size of journal file on disk */
1625 u32 cksum = 0; /* Checksum of string zMaster */
1626
1627 assert( pPager->setMaster==0 );
1628 assert( !pagerUseWal(pPager) );
1629
1630 if( !zMaster
1631 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
1632 || !isOpen(pPager->jfd)
1633 ){
1634 return SQLITE_OK;
1635 }
1636 pPager->setMaster = 1;
1637 assert( pPager->journalHdr <= pPager->journalOff );
1638
1639 /* Calculate the length in bytes and the checksum of zMaster */
1640 for(nMaster=0; zMaster[nMaster]; nMaster++){
1641 cksum += zMaster[nMaster];
1642 }
1643
1644 /* If in full-sync mode, advance to the next disk sector before writing
1645 ** the master journal name. This is in case the previous page written to
1646 ** the journal has already been synced.
1647 */
1648 if( pPager->fullSync ){
1649 pPager->journalOff = journalHdrOffset(pPager);
1650 }
1651 iHdrOff = pPager->journalOff;
1652
1653 /* Write the master journal data to the end of the journal file. If
1654 ** an error occurs, return the error code to the caller.
1655 */
1656 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
1657 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
1658 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
1659 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
1660 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
1661 iHdrOff+4+nMaster+8)))
1662 ){
1663 return rc;
1664 }
1665 pPager->journalOff += (nMaster+20);
1666
1667 /* If the pager is in peristent-journal mode, then the physical
1668 ** journal-file may extend past the end of the master-journal name
1669 ** and 8 bytes of magic data just written to the file. This is
1670 ** dangerous because the code to rollback a hot-journal file
1671 ** will not be able to find the master-journal name to determine
1672 ** whether or not the journal is hot.
1673 **
1674 ** Easiest thing to do in this scenario is to truncate the journal
1675 ** file to the required size.
1676 */
1677 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
1678 && jrnlSize>pPager->journalOff
1679 ){
1680 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
1681 }
1682 return rc;
1683 }
1684
1685 /*
1686 ** Discard the entire contents of the in-memory page-cache.
1687 */
1688 static void pager_reset(Pager *pPager){
1689 pPager->iDataVersion++;
1690 sqlite3BackupRestart(pPager->pBackup);
1691 sqlite3PcacheClear(pPager->pPCache);
1692 }
1693
1694 /*
1695 ** Return the pPager->iDataVersion value
1696 */
1697 u32 sqlite3PagerDataVersion(Pager *pPager){
1698 assert( pPager->eState>PAGER_OPEN );
1699 return pPager->iDataVersion;
1700 }
1701
1702 /*
1703 ** Free all structures in the Pager.aSavepoint[] array and set both
1704 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1705 ** if it is open and the pager is not in exclusive mode.
1706 */
1707 static void releaseAllSavepoints(Pager *pPager){
1708 int ii; /* Iterator for looping through Pager.aSavepoint */
1709 for(ii=0; ii<pPager->nSavepoint; ii++){
1710 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
1711 }
1712 if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){
1713 sqlite3OsClose(pPager->sjfd);
1714 }
1715 sqlite3_free(pPager->aSavepoint);
1716 pPager->aSavepoint = 0;
1717 pPager->nSavepoint = 0;
1718 pPager->nSubRec = 0;
1719 }
1720
1721 /*
1722 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1723 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
1724 ** or SQLITE_NOMEM if a malloc failure occurs.
1725 */
1726 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
1727 int ii; /* Loop counter */
1728 int rc = SQLITE_OK; /* Result code */
1729
1730 for(ii=0; ii<pPager->nSavepoint; ii++){
1731 PagerSavepoint *p = &pPager->aSavepoint[ii];
1732 if( pgno<=p->nOrig ){
1733 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
1734 testcase( rc==SQLITE_NOMEM );
1735 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
1736 }
1737 }
1738 return rc;
1739 }
1740
1741 /*
1742 ** This function is a no-op if the pager is in exclusive mode and not
1743 ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
1744 ** state.
1745 **
1746 ** If the pager is not in exclusive-access mode, the database file is
1747 ** completely unlocked. If the file is unlocked and the file-system does
1748 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
1749 ** closed (if it is open).
1750 **
1751 ** If the pager is in ERROR state when this function is called, the
1752 ** contents of the pager cache are discarded before switching back to
1753 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
1754 ** or not, any journal file left in the file-system will be treated
1755 ** as a hot-journal and rolled back the next time a read-transaction
1756 ** is opened (by this or by any other connection).
1757 */
1758 static void pager_unlock(Pager *pPager){
1759
1760 assert( pPager->eState==PAGER_READER
1761 || pPager->eState==PAGER_OPEN
1762 || pPager->eState==PAGER_ERROR
1763 );
1764
1765 sqlite3BitvecDestroy(pPager->pInJournal);
1766 pPager->pInJournal = 0;
1767 releaseAllSavepoints(pPager);
1768
1769 if( pagerUseWal(pPager) ){
1770 assert( !isOpen(pPager->jfd) );
1771 sqlite3WalEndReadTransaction(pPager->pWal);
1772 pPager->eState = PAGER_OPEN;
1773 }else if( !pPager->exclusiveMode ){
1774 int rc; /* Error code returned by pagerUnlockDb() */
1775 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
1776
1777 /* If the operating system support deletion of open files, then
1778 ** close the journal file when dropping the database lock. Otherwise
1779 ** another connection with journal_mode=delete might delete the file
1780 ** out from under us.
1781 */
1782 assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
1783 assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
1784 assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
1785 assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
1786 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
1787 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
1788 if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
1789 || 1!=(pPager->journalMode & 5)
1790 ){
1791 sqlite3OsClose(pPager->jfd);
1792 }
1793
1794 /* If the pager is in the ERROR state and the call to unlock the database
1795 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
1796 ** above the #define for UNKNOWN_LOCK for an explanation of why this
1797 ** is necessary.
1798 */
1799 rc = pagerUnlockDb(pPager, NO_LOCK);
1800 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
1801 pPager->eLock = UNKNOWN_LOCK;
1802 }
1803
1804 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
1805 ** without clearing the error code. This is intentional - the error
1806 ** code is cleared and the cache reset in the block below.
1807 */
1808 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
1809 pPager->changeCountDone = 0;
1810 pPager->eState = PAGER_OPEN;
1811 }
1812
1813 /* If Pager.errCode is set, the contents of the pager cache cannot be
1814 ** trusted. Now that there are no outstanding references to the pager,
1815 ** it can safely move back to PAGER_OPEN state. This happens in both
1816 ** normal and exclusive-locking mode.
1817 */
1818 if( pPager->errCode ){
1819 assert( !MEMDB );
1820 pager_reset(pPager);
1821 pPager->changeCountDone = pPager->tempFile;
1822 pPager->eState = PAGER_OPEN;
1823 pPager->errCode = SQLITE_OK;
1824 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
1825 }
1826
1827 pPager->journalOff = 0;
1828 pPager->journalHdr = 0;
1829 pPager->setMaster = 0;
1830 }
1831
1832 /*
1833 ** This function is called whenever an IOERR or FULL error that requires
1834 ** the pager to transition into the ERROR state may ahve occurred.
1835 ** The first argument is a pointer to the pager structure, the second
1836 ** the error-code about to be returned by a pager API function. The
1837 ** value returned is a copy of the second argument to this function.
1838 **
1839 ** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
1840 ** IOERR sub-codes, the pager enters the ERROR state and the error code
1841 ** is stored in Pager.errCode. While the pager remains in the ERROR state,
1842 ** all major API calls on the Pager will immediately return Pager.errCode.
1843 **
1844 ** The ERROR state indicates that the contents of the pager-cache
1845 ** cannot be trusted. This state can be cleared by completely discarding
1846 ** the contents of the pager-cache. If a transaction was active when
1847 ** the persistent error occurred, then the rollback journal may need
1848 ** to be replayed to restore the contents of the database file (as if
1849 ** it were a hot-journal).
1850 */
1851 static int pager_error(Pager *pPager, int rc){
1852 int rc2 = rc & 0xff;
1853 assert( rc==SQLITE_OK || !MEMDB );
1854 assert(
1855 pPager->errCode==SQLITE_FULL ||
1856 pPager->errCode==SQLITE_OK ||
1857 (pPager->errCode & 0xff)==SQLITE_IOERR
1858 );
1859 if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){
1860 pPager->errCode = rc;
1861 pPager->eState = PAGER_ERROR;
1862 }
1863 return rc;
1864 }
1865
1866 static int pager_truncate(Pager *pPager, Pgno nPage);
1867
1868 /*
1869 ** This routine ends a transaction. A transaction is usually ended by
1870 ** either a COMMIT or a ROLLBACK operation. This routine may be called
1871 ** after rollback of a hot-journal, or if an error occurs while opening
1872 ** the journal file or writing the very first journal-header of a
1873 ** database transaction.
1874 **
1875 ** This routine is never called in PAGER_ERROR state. If it is called
1876 ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
1877 ** exclusive than a RESERVED lock, it is a no-op.
1878 **
1879 ** Otherwise, any active savepoints are released.
1880 **
1881 ** If the journal file is open, then it is "finalized". Once a journal
1882 ** file has been finalized it is not possible to use it to roll back a
1883 ** transaction. Nor will it be considered to be a hot-journal by this
1884 ** or any other database connection. Exactly how a journal is finalized
1885 ** depends on whether or not the pager is running in exclusive mode and
1886 ** the current journal-mode (Pager.journalMode value), as follows:
1887 **
1888 ** journalMode==MEMORY
1889 ** Journal file descriptor is simply closed. This destroys an
1890 ** in-memory journal.
1891 **
1892 ** journalMode==TRUNCATE
1893 ** Journal file is truncated to zero bytes in size.
1894 **
1895 ** journalMode==PERSIST
1896 ** The first 28 bytes of the journal file are zeroed. This invalidates
1897 ** the first journal header in the file, and hence the entire journal
1898 ** file. An invalid journal file cannot be rolled back.
1899 **
1900 ** journalMode==DELETE
1901 ** The journal file is closed and deleted using sqlite3OsDelete().
1902 **
1903 ** If the pager is running in exclusive mode, this method of finalizing
1904 ** the journal file is never used. Instead, if the journalMode is
1905 ** DELETE and the pager is in exclusive mode, the method described under
1906 ** journalMode==PERSIST is used instead.
1907 **
1908 ** After the journal is finalized, the pager moves to PAGER_READER state.
1909 ** If running in non-exclusive rollback mode, the lock on the file is
1910 ** downgraded to a SHARED_LOCK.
1911 **
1912 ** SQLITE_OK is returned if no error occurs. If an error occurs during
1913 ** any of the IO operations to finalize the journal file or unlock the
1914 ** database then the IO error code is returned to the user. If the
1915 ** operation to finalize the journal file fails, then the code still
1916 ** tries to unlock the database file if not in exclusive mode. If the
1917 ** unlock operation fails as well, then the first error code related
1918 ** to the first error encountered (the journal finalization one) is
1919 ** returned.
1920 */
1921 static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){
1922 int rc = SQLITE_OK; /* Error code from journal finalization operation */
1923 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
1924
1925 /* Do nothing if the pager does not have an open write transaction
1926 ** or at least a RESERVED lock. This function may be called when there
1927 ** is no write-transaction active but a RESERVED or greater lock is
1928 ** held under two circumstances:
1929 **
1930 ** 1. After a successful hot-journal rollback, it is called with
1931 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
1932 **
1933 ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
1934 ** lock switches back to locking_mode=normal and then executes a
1935 ** read-transaction, this function is called with eState==PAGER_READER
1936 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
1937 */
1938 assert( assert_pager_state(pPager) );
1939 assert( pPager->eState!=PAGER_ERROR );
1940 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
1941 return SQLITE_OK;
1942 }
1943
1944 releaseAllSavepoints(pPager);
1945 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
1946 if( isOpen(pPager->jfd) ){
1947 assert( !pagerUseWal(pPager) );
1948
1949 /* Finalize the journal file. */
1950 if( sqlite3IsMemJournal(pPager->jfd) ){
1951 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
1952 sqlite3OsClose(pPager->jfd);
1953 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
1954 if( pPager->journalOff==0 ){
1955 rc = SQLITE_OK;
1956 }else{
1957 rc = sqlite3OsTruncate(pPager->jfd, 0);
1958 if( rc==SQLITE_OK && pPager->fullSync ){
1959 /* Make sure the new file size is written into the inode right away.
1960 ** Otherwise the journal might resurrect following a power loss and
1961 ** cause the last transaction to roll back. See
1962 ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
1963 */
1964 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
1965 }
1966 }
1967 pPager->journalOff = 0;
1968 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
1969 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
1970 ){
1971 rc = zeroJournalHdr(pPager, hasMaster);
1972 pPager->journalOff = 0;
1973 }else{
1974 /* This branch may be executed with Pager.journalMode==MEMORY if
1975 ** a hot-journal was just rolled back. In this case the journal
1976 ** file should be closed and deleted. If this connection writes to
1977 ** the database file, it will do so using an in-memory journal.
1978 */
1979 int bDelete = (!pPager->tempFile && sqlite3JournalExists(pPager->jfd));
1980 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
1981 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
1982 || pPager->journalMode==PAGER_JOURNALMODE_WAL
1983 );
1984 sqlite3OsClose(pPager->jfd);
1985 if( bDelete ){
1986 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
1987 }
1988 }
1989 }
1990
1991 #ifdef SQLITE_CHECK_PAGES
1992 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
1993 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
1994 PgHdr *p = sqlite3PagerLookup(pPager, 1);
1995 if( p ){
1996 p->pageHash = 0;
1997 sqlite3PagerUnrefNotNull(p);
1998 }
1999 }
2000 #endif
2001
2002 sqlite3BitvecDestroy(pPager->pInJournal);
2003 pPager->pInJournal = 0;
2004 pPager->nRec = 0;
2005 sqlite3PcacheCleanAll(pPager->pPCache);
2006 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
2007
2008 if( pagerUseWal(pPager) ){
2009 /* Drop the WAL write-lock, if any. Also, if the connection was in
2010 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
2011 ** lock held on the database file.
2012 */
2013 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
2014 assert( rc2==SQLITE_OK );
2015 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
2016 /* This branch is taken when committing a transaction in rollback-journal
2017 ** mode if the database file on disk is larger than the database image.
2018 ** At this point the journal has been finalized and the transaction
2019 ** successfully committed, but the EXCLUSIVE lock is still held on the
2020 ** file. So it is safe to truncate the database file to its minimum
2021 ** required size. */
2022 assert( pPager->eLock==EXCLUSIVE_LOCK );
2023 rc = pager_truncate(pPager, pPager->dbSize);
2024 }
2025
2026 if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){
2027 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
2028 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
2029 }
2030
2031 if( !pPager->exclusiveMode
2032 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
2033 ){
2034 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
2035 pPager->changeCountDone = 0;
2036 }
2037 pPager->eState = PAGER_READER;
2038 pPager->setMaster = 0;
2039
2040 return (rc==SQLITE_OK?rc2:rc);
2041 }
2042
2043 /*
2044 ** Execute a rollback if a transaction is active and unlock the
2045 ** database file.
2046 **
2047 ** If the pager has already entered the ERROR state, do not attempt
2048 ** the rollback at this time. Instead, pager_unlock() is called. The
2049 ** call to pager_unlock() will discard all in-memory pages, unlock
2050 ** the database file and move the pager back to OPEN state. If this
2051 ** means that there is a hot-journal left in the file-system, the next
2052 ** connection to obtain a shared lock on the pager (which may be this one)
2053 ** will roll it back.
2054 **
2055 ** If the pager has not already entered the ERROR state, but an IO or
2056 ** malloc error occurs during a rollback, then this will itself cause
2057 ** the pager to enter the ERROR state. Which will be cleared by the
2058 ** call to pager_unlock(), as described above.
2059 */
2060 static void pagerUnlockAndRollback(Pager *pPager){
2061 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
2062 assert( assert_pager_state(pPager) );
2063 if( pPager->eState>=PAGER_WRITER_LOCKED ){
2064 sqlite3BeginBenignMalloc();
2065 sqlite3PagerRollback(pPager);
2066 sqlite3EndBenignMalloc();
2067 }else if( !pPager->exclusiveMode ){
2068 assert( pPager->eState==PAGER_READER );
2069 pager_end_transaction(pPager, 0, 0);
2070 }
2071 }
2072 pager_unlock(pPager);
2073 }
2074
2075 /*
2076 ** Parameter aData must point to a buffer of pPager->pageSize bytes
2077 ** of data. Compute and return a checksum based ont the contents of the
2078 ** page of data and the current value of pPager->cksumInit.
2079 **
2080 ** This is not a real checksum. It is really just the sum of the
2081 ** random initial value (pPager->cksumInit) and every 200th byte
2082 ** of the page data, starting with byte offset (pPager->pageSize%200).
2083 ** Each byte is interpreted as an 8-bit unsigned integer.
2084 **
2085 ** Changing the formula used to compute this checksum results in an
2086 ** incompatible journal file format.
2087 **
2088 ** If journal corruption occurs due to a power failure, the most likely
2089 ** scenario is that one end or the other of the record will be changed.
2090 ** It is much less likely that the two ends of the journal record will be
2091 ** correct and the middle be corrupt. Thus, this "checksum" scheme,
2092 ** though fast and simple, catches the mostly likely kind of corruption.
2093 */
2094 static u32 pager_cksum(Pager *pPager, const u8 *aData){
2095 u32 cksum = pPager->cksumInit; /* Checksum value to return */
2096 int i = pPager->pageSize-200; /* Loop counter */
2097 while( i>0 ){
2098 cksum += aData[i];
2099 i -= 200;
2100 }
2101 return cksum;
2102 }
2103
2104 /*
2105 ** Report the current page size and number of reserved bytes back
2106 ** to the codec.
2107 */
2108 #ifdef SQLITE_HAS_CODEC
2109 static void pagerReportSize(Pager *pPager){
2110 if( pPager->xCodecSizeChng ){
2111 pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
2112 (int)pPager->nReserve);
2113 }
2114 }
2115 #else
2116 # define pagerReportSize(X) /* No-op if we do not support a codec */
2117 #endif
2118
2119 #ifdef SQLITE_HAS_CODEC
2120 /*
2121 ** Make sure the number of reserved bits is the same in the destination
2122 ** pager as it is in the source. This comes up when a VACUUM changes the
2123 ** number of reserved bits to the "optimal" amount.
2124 */
2125 void sqlite3PagerAlignReserve(Pager *pDest, Pager *pSrc){
2126 if( pDest->nReserve!=pSrc->nReserve ){
2127 pDest->nReserve = pSrc->nReserve;
2128 pagerReportSize(pDest);
2129 }
2130 }
2131 #endif
2132
2133 /*
2134 ** Read a single page from either the journal file (if isMainJrnl==1) or
2135 ** from the sub-journal (if isMainJrnl==0) and playback that page.
2136 ** The page begins at offset *pOffset into the file. The *pOffset
2137 ** value is increased to the start of the next page in the journal.
2138 **
2139 ** The main rollback journal uses checksums - the statement journal does
2140 ** not.
2141 **
2142 ** If the page number of the page record read from the (sub-)journal file
2143 ** is greater than the current value of Pager.dbSize, then playback is
2144 ** skipped and SQLITE_OK is returned.
2145 **
2146 ** If pDone is not NULL, then it is a record of pages that have already
2147 ** been played back. If the page at *pOffset has already been played back
2148 ** (if the corresponding pDone bit is set) then skip the playback.
2149 ** Make sure the pDone bit corresponding to the *pOffset page is set
2150 ** prior to returning.
2151 **
2152 ** If the page record is successfully read from the (sub-)journal file
2153 ** and played back, then SQLITE_OK is returned. If an IO error occurs
2154 ** while reading the record from the (sub-)journal file or while writing
2155 ** to the database file, then the IO error code is returned. If data
2156 ** is successfully read from the (sub-)journal file but appears to be
2157 ** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
2158 ** two circumstances:
2159 **
2160 ** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
2161 ** * If the record is being rolled back from the main journal file
2162 ** and the checksum field does not match the record content.
2163 **
2164 ** Neither of these two scenarios are possible during a savepoint rollback.
2165 **
2166 ** If this is a savepoint rollback, then memory may have to be dynamically
2167 ** allocated by this function. If this is the case and an allocation fails,
2168 ** SQLITE_NOMEM is returned.
2169 */
2170 static int pager_playback_one_page(
2171 Pager *pPager, /* The pager being played back */
2172 i64 *pOffset, /* Offset of record to playback */
2173 Bitvec *pDone, /* Bitvec of pages already played back */
2174 int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
2175 int isSavepnt /* True for a savepoint rollback */
2176 ){
2177 int rc;
2178 PgHdr *pPg; /* An existing page in the cache */
2179 Pgno pgno; /* The page number of a page in journal */
2180 u32 cksum; /* Checksum used for sanity checking */
2181 char *aData; /* Temporary storage for the page */
2182 sqlite3_file *jfd; /* The file descriptor for the journal file */
2183 int isSynced; /* True if journal page is synced */
2184
2185 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
2186 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
2187 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
2188 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
2189
2190 aData = pPager->pTmpSpace;
2191 assert( aData ); /* Temp storage must have already been allocated */
2192 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
2193
2194 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
2195 ** or savepoint rollback done at the request of the caller) or this is
2196 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
2197 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
2198 ** only reads from the main journal, not the sub-journal.
2199 */
2200 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
2201 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
2202 );
2203 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
2204
2205 /* Read the page number and page data from the journal or sub-journal
2206 ** file. Return an error code to the caller if an IO error occurs.
2207 */
2208 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
2209 rc = read32bits(jfd, *pOffset, &pgno);
2210 if( rc!=SQLITE_OK ) return rc;
2211 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
2212 if( rc!=SQLITE_OK ) return rc;
2213 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
2214
2215 /* Sanity checking on the page. This is more important that I originally
2216 ** thought. If a power failure occurs while the journal is being written,
2217 ** it could cause invalid data to be written into the journal. We need to
2218 ** detect this invalid data (with high probability) and ignore it.
2219 */
2220 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
2221 assert( !isSavepnt );
2222 return SQLITE_DONE;
2223 }
2224 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
2225 return SQLITE_OK;
2226 }
2227 if( isMainJrnl ){
2228 rc = read32bits(jfd, (*pOffset)-4, &cksum);
2229 if( rc ) return rc;
2230 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
2231 return SQLITE_DONE;
2232 }
2233 }
2234
2235 /* If this page has already been played back before during the current
2236 ** rollback, then don't bother to play it back again.
2237 */
2238 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
2239 return rc;
2240 }
2241
2242 /* When playing back page 1, restore the nReserve setting
2243 */
2244 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
2245 pPager->nReserve = ((u8*)aData)[20];
2246 pagerReportSize(pPager);
2247 }
2248
2249 /* If the pager is in CACHEMOD state, then there must be a copy of this
2250 ** page in the pager cache. In this case just update the pager cache,
2251 ** not the database file. The page is left marked dirty in this case.
2252 **
2253 ** An exception to the above rule: If the database is in no-sync mode
2254 ** and a page is moved during an incremental vacuum then the page may
2255 ** not be in the pager cache. Later: if a malloc() or IO error occurs
2256 ** during a Movepage() call, then the page may not be in the cache
2257 ** either. So the condition described in the above paragraph is not
2258 ** assert()able.
2259 **
2260 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
2261 ** pager cache if it exists and the main file. The page is then marked
2262 ** not dirty. Since this code is only executed in PAGER_OPEN state for
2263 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
2264 ** if the pager is in OPEN state.
2265 **
2266 ** Ticket #1171: The statement journal might contain page content that is
2267 ** different from the page content at the start of the transaction.
2268 ** This occurs when a page is changed prior to the start of a statement
2269 ** then changed again within the statement. When rolling back such a
2270 ** statement we must not write to the original database unless we know
2271 ** for certain that original page contents are synced into the main rollback
2272 ** journal. Otherwise, a power loss might leave modified data in the
2273 ** database file without an entry in the rollback journal that can
2274 ** restore the database to its original form. Two conditions must be
2275 ** met before writing to the database files. (1) the database must be
2276 ** locked. (2) we know that the original page content is fully synced
2277 ** in the main journal either because the page is not in cache or else
2278 ** the page is marked as needSync==0.
2279 **
2280 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
2281 ** is possible to fail a statement on a database that does not yet exist.
2282 ** Do not attempt to write if database file has never been opened.
2283 */
2284 if( pagerUseWal(pPager) ){
2285 pPg = 0;
2286 }else{
2287 pPg = sqlite3PagerLookup(pPager, pgno);
2288 }
2289 assert( pPg || !MEMDB );
2290 assert( pPager->eState!=PAGER_OPEN || pPg==0 );
2291 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
2292 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
2293 (isMainJrnl?"main-journal":"sub-journal")
2294 ));
2295 if( isMainJrnl ){
2296 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
2297 }else{
2298 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
2299 }
2300 if( isOpen(pPager->fd)
2301 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
2302 && isSynced
2303 ){
2304 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
2305 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
2306 assert( !pagerUseWal(pPager) );
2307 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
2308 if( pgno>pPager->dbFileSize ){
2309 pPager->dbFileSize = pgno;
2310 }
2311 if( pPager->pBackup ){
2312 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
2313 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
2314 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
2315 }
2316 }else if( !isMainJrnl && pPg==0 ){
2317 /* If this is a rollback of a savepoint and data was not written to
2318 ** the database and the page is not in-memory, there is a potential
2319 ** problem. When the page is next fetched by the b-tree layer, it
2320 ** will be read from the database file, which may or may not be
2321 ** current.
2322 **
2323 ** There are a couple of different ways this can happen. All are quite
2324 ** obscure. When running in synchronous mode, this can only happen
2325 ** if the page is on the free-list at the start of the transaction, then
2326 ** populated, then moved using sqlite3PagerMovepage().
2327 **
2328 ** The solution is to add an in-memory page to the cache containing
2329 ** the data just read from the sub-journal. Mark the page as dirty
2330 ** and if the pager requires a journal-sync, then mark the page as
2331 ** requiring a journal-sync before it is written.
2332 */
2333 assert( isSavepnt );
2334 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
2335 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
2336 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
2337 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
2338 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
2339 if( rc!=SQLITE_OK ) return rc;
2340 pPg->flags &= ~PGHDR_NEED_READ;
2341 sqlite3PcacheMakeDirty(pPg);
2342 }
2343 if( pPg ){
2344 /* No page should ever be explicitly rolled back that is in use, except
2345 ** for page 1 which is held in use in order to keep the lock on the
2346 ** database active. However such a page may be rolled back as a result
2347 ** of an internal error resulting in an automatic call to
2348 ** sqlite3PagerRollback().
2349 */
2350 void *pData;
2351 pData = pPg->pData;
2352 memcpy(pData, (u8*)aData, pPager->pageSize);
2353 pPager->xReiniter(pPg);
2354 if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
2355 /* If the contents of this page were just restored from the main
2356 ** journal file, then its content must be as they were when the
2357 ** transaction was first opened. In this case we can mark the page
2358 ** as clean, since there will be no need to write it out to the
2359 ** database.
2360 **
2361 ** There is one exception to this rule. If the page is being rolled
2362 ** back as part of a savepoint (or statement) rollback from an
2363 ** unsynced portion of the main journal file, then it is not safe
2364 ** to mark the page as clean. This is because marking the page as
2365 ** clean will clear the PGHDR_NEED_SYNC flag. Since the page is
2366 ** already in the journal file (recorded in Pager.pInJournal) and
2367 ** the PGHDR_NEED_SYNC flag is cleared, if the page is written to
2368 ** again within this transaction, it will be marked as dirty but
2369 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
2370 ** be written out into the database file before its journal file
2371 ** segment is synced. If a crash occurs during or following this,
2372 ** database corruption may ensue.
2373 */
2374 assert( !pagerUseWal(pPager) );
2375 sqlite3PcacheMakeClean(pPg);
2376 }
2377 pager_set_pagehash(pPg);
2378
2379 /* If this was page 1, then restore the value of Pager.dbFileVers.
2380 ** Do this before any decoding. */
2381 if( pgno==1 ){
2382 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
2383 }
2384
2385 /* Decode the page just read from disk */
2386 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
2387 sqlite3PcacheRelease(pPg);
2388 }
2389 return rc;
2390 }
2391
2392 /*
2393 ** Parameter zMaster is the name of a master journal file. A single journal
2394 ** file that referred to the master journal file has just been rolled back.
2395 ** This routine checks if it is possible to delete the master journal file,
2396 ** and does so if it is.
2397 **
2398 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
2399 ** available for use within this function.
2400 **
2401 ** When a master journal file is created, it is populated with the names
2402 ** of all of its child journals, one after another, formatted as utf-8
2403 ** encoded text. The end of each child journal file is marked with a
2404 ** nul-terminator byte (0x00). i.e. the entire contents of a master journal
2405 ** file for a transaction involving two databases might be:
2406 **
2407 ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
2408 **
2409 ** A master journal file may only be deleted once all of its child
2410 ** journals have been rolled back.
2411 **
2412 ** This function reads the contents of the master-journal file into
2413 ** memory and loops through each of the child journal names. For
2414 ** each child journal, it checks if:
2415 **
2416 ** * if the child journal exists, and if so
2417 ** * if the child journal contains a reference to master journal
2418 ** file zMaster
2419 **
2420 ** If a child journal can be found that matches both of the criteria
2421 ** above, this function returns without doing anything. Otherwise, if
2422 ** no such child journal can be found, file zMaster is deleted from
2423 ** the file-system using sqlite3OsDelete().
2424 **
2425 ** If an IO error within this function, an error code is returned. This
2426 ** function allocates memory by calling sqlite3Malloc(). If an allocation
2427 ** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
2428 ** occur, SQLITE_OK is returned.
2429 **
2430 ** TODO: This function allocates a single block of memory to load
2431 ** the entire contents of the master journal file. This could be
2432 ** a couple of kilobytes or so - potentially larger than the page
2433 ** size.
2434 */
2435 static int pager_delmaster(Pager *pPager, const char *zMaster){
2436 sqlite3_vfs *pVfs = pPager->pVfs;
2437 int rc; /* Return code */
2438 sqlite3_file *pMaster; /* Malloc'd master-journal file descriptor */
2439 sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
2440 char *zMasterJournal = 0; /* Contents of master journal file */
2441 i64 nMasterJournal; /* Size of master journal file */
2442 char *zJournal; /* Pointer to one journal within MJ file */
2443 char *zMasterPtr; /* Space to hold MJ filename from a journal file */
2444 int nMasterPtr; /* Amount of space allocated to zMasterPtr[] */
2445
2446 /* Allocate space for both the pJournal and pMaster file descriptors.
2447 ** If successful, open the master journal file for reading.
2448 */
2449 pMaster = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
2450 pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
2451 if( !pMaster ){
2452 rc = SQLITE_NOMEM;
2453 }else{
2454 const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
2455 rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
2456 }
2457 if( rc!=SQLITE_OK ) goto delmaster_out;
2458
2459 /* Load the entire master journal file into space obtained from
2460 ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain
2461 ** sufficient space (in zMasterPtr) to hold the names of master
2462 ** journal files extracted from regular rollback-journals.
2463 */
2464 rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
2465 if( rc!=SQLITE_OK ) goto delmaster_out;
2466 nMasterPtr = pVfs->mxPathname+1;
2467 zMasterJournal = sqlite3Malloc(nMasterJournal + nMasterPtr + 1);
2468 if( !zMasterJournal ){
2469 rc = SQLITE_NOMEM;
2470 goto delmaster_out;
2471 }
2472 zMasterPtr = &zMasterJournal[nMasterJournal+1];
2473 rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
2474 if( rc!=SQLITE_OK ) goto delmaster_out;
2475 zMasterJournal[nMasterJournal] = 0;
2476
2477 zJournal = zMasterJournal;
2478 while( (zJournal-zMasterJournal)<nMasterJournal ){
2479 int exists;
2480 rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
2481 if( rc!=SQLITE_OK ){
2482 goto delmaster_out;
2483 }
2484 if( exists ){
2485 /* One of the journals pointed to by the master journal exists.
2486 ** Open it and check if it points at the master journal. If
2487 ** so, return without deleting the master journal file.
2488 */
2489 int c;
2490 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
2491 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
2492 if( rc!=SQLITE_OK ){
2493 goto delmaster_out;
2494 }
2495
2496 rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
2497 sqlite3OsClose(pJournal);
2498 if( rc!=SQLITE_OK ){
2499 goto delmaster_out;
2500 }
2501
2502 c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
2503 if( c ){
2504 /* We have a match. Do not delete the master journal file. */
2505 goto delmaster_out;
2506 }
2507 }
2508 zJournal += (sqlite3Strlen30(zJournal)+1);
2509 }
2510
2511 sqlite3OsClose(pMaster);
2512 rc = sqlite3OsDelete(pVfs, zMaster, 0);
2513
2514 delmaster_out:
2515 sqlite3_free(zMasterJournal);
2516 if( pMaster ){
2517 sqlite3OsClose(pMaster);
2518 assert( !isOpen(pJournal) );
2519 sqlite3_free(pMaster);
2520 }
2521 return rc;
2522 }
2523
2524
2525 /*
2526 ** This function is used to change the actual size of the database
2527 ** file in the file-system. This only happens when committing a transaction,
2528 ** or rolling back a transaction (including rolling back a hot-journal).
2529 **
2530 ** If the main database file is not open, or the pager is not in either
2531 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
2532 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
2533 ** If the file on disk is currently larger than nPage pages, then use the VFS
2534 ** xTruncate() method to truncate it.
2535 **
2536 ** Or, it might be the case that the file on disk is smaller than
2537 ** nPage pages. Some operating system implementations can get confused if
2538 ** you try to truncate a file to some size that is larger than it
2539 ** currently is, so detect this case and write a single zero byte to
2540 ** the end of the new file instead.
2541 **
2542 ** If successful, return SQLITE_OK. If an IO error occurs while modifying
2543 ** the database file, return the error code to the caller.
2544 */
2545 static int pager_truncate(Pager *pPager, Pgno nPage){
2546 int rc = SQLITE_OK;
2547 assert( pPager->eState!=PAGER_ERROR );
2548 assert( pPager->eState!=PAGER_READER );
2549
2550 if( isOpen(pPager->fd)
2551 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
2552 ){
2553 i64 currentSize, newSize;
2554 int szPage = pPager->pageSize;
2555 assert( pPager->eLock==EXCLUSIVE_LOCK );
2556 /* TODO: Is it safe to use Pager.dbFileSize here? */
2557 rc = sqlite3OsFileSize(pPager->fd, &currentSize);
2558 newSize = szPage*(i64)nPage;
2559 if( rc==SQLITE_OK && currentSize!=newSize ){
2560 if( currentSize>newSize ){
2561 rc = sqlite3OsTruncate(pPager->fd, newSize);
2562 }else if( (currentSize+szPage)<=newSize ){
2563 char *pTmp = pPager->pTmpSpace;
2564 memset(pTmp, 0, szPage);
2565 testcase( (newSize-szPage) == currentSize );
2566 testcase( (newSize-szPage) > currentSize );
2567 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
2568 }
2569 if( rc==SQLITE_OK ){
2570 pPager->dbFileSize = nPage;
2571 }
2572 }
2573 }
2574 return rc;
2575 }
2576
2577 /*
2578 ** Return a sanitized version of the sector-size of OS file pFile. The
2579 ** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
2580 */
2581 int sqlite3SectorSize(sqlite3_file *pFile){
2582 int iRet = sqlite3OsSectorSize(pFile);
2583 if( iRet<32 ){
2584 iRet = 512;
2585 }else if( iRet>MAX_SECTOR_SIZE ){
2586 assert( MAX_SECTOR_SIZE>=512 );
2587 iRet = MAX_SECTOR_SIZE;
2588 }
2589 return iRet;
2590 }
2591
2592 /*
2593 ** Set the value of the Pager.sectorSize variable for the given
2594 ** pager based on the value returned by the xSectorSize method
2595 ** of the open database file. The sector size will be used
2596 ** to determine the size and alignment of journal header and
2597 ** master journal pointers within created journal files.
2598 **
2599 ** For temporary files the effective sector size is always 512 bytes.
2600 **
2601 ** Otherwise, for non-temporary files, the effective sector size is
2602 ** the value returned by the xSectorSize() method rounded up to 32 if
2603 ** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
2604 ** is greater than MAX_SECTOR_SIZE.
2605 **
2606 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
2607 ** the effective sector size to its minimum value (512). The purpose of
2608 ** pPager->sectorSize is to define the "blast radius" of bytes that
2609 ** might change if a crash occurs while writing to a single byte in
2610 ** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
2611 ** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
2612 ** size. For backwards compatibility of the rollback journal file format,
2613 ** we cannot reduce the effective sector size below 512.
2614 */
2615 static void setSectorSize(Pager *pPager){
2616 assert( isOpen(pPager->fd) || pPager->tempFile );
2617
2618 if( pPager->tempFile
2619 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
2620 SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0
2621 ){
2622 /* Sector size doesn't matter for temporary files. Also, the file
2623 ** may not have been opened yet, in which case the OsSectorSize()
2624 ** call will segfault. */
2625 pPager->sectorSize = 512;
2626 }else{
2627 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
2628 }
2629 }
2630
2631 /*
2632 ** Playback the journal and thus restore the database file to
2633 ** the state it was in before we started making changes.
2634 **
2635 ** The journal file format is as follows:
2636 **
2637 ** (1) 8 byte prefix. A copy of aJournalMagic[].
2638 ** (2) 4 byte big-endian integer which is the number of valid page records
2639 ** in the journal. If this value is 0xffffffff, then compute the
2640 ** number of page records from the journal size.
2641 ** (3) 4 byte big-endian integer which is the initial value for the
2642 ** sanity checksum.
2643 ** (4) 4 byte integer which is the number of pages to truncate the
2644 ** database to during a rollback.
2645 ** (5) 4 byte big-endian integer which is the sector size. The header
2646 ** is this many bytes in size.
2647 ** (6) 4 byte big-endian integer which is the page size.
2648 ** (7) zero padding out to the next sector size.
2649 ** (8) Zero or more pages instances, each as follows:
2650 ** + 4 byte page number.
2651 ** + pPager->pageSize bytes of data.
2652 ** + 4 byte checksum
2653 **
2654 ** When we speak of the journal header, we mean the first 7 items above.
2655 ** Each entry in the journal is an instance of the 8th item.
2656 **
2657 ** Call the value from the second bullet "nRec". nRec is the number of
2658 ** valid page entries in the journal. In most cases, you can compute the
2659 ** value of nRec from the size of the journal file. But if a power
2660 ** failure occurred while the journal was being written, it could be the
2661 ** case that the size of the journal file had already been increased but
2662 ** the extra entries had not yet made it safely to disk. In such a case,
2663 ** the value of nRec computed from the file size would be too large. For
2664 ** that reason, we always use the nRec value in the header.
2665 **
2666 ** If the nRec value is 0xffffffff it means that nRec should be computed
2667 ** from the file size. This value is used when the user selects the
2668 ** no-sync option for the journal. A power failure could lead to corruption
2669 ** in this case. But for things like temporary table (which will be
2670 ** deleted when the power is restored) we don't care.
2671 **
2672 ** If the file opened as the journal file is not a well-formed
2673 ** journal file then all pages up to the first corrupted page are rolled
2674 ** back (or no pages if the journal header is corrupted). The journal file
2675 ** is then deleted and SQLITE_OK returned, just as if no corruption had
2676 ** been encountered.
2677 **
2678 ** If an I/O or malloc() error occurs, the journal-file is not deleted
2679 ** and an error code is returned.
2680 **
2681 ** The isHot parameter indicates that we are trying to rollback a journal
2682 ** that might be a hot journal. Or, it could be that the journal is
2683 ** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
2684 ** If the journal really is hot, reset the pager cache prior rolling
2685 ** back any content. If the journal is merely persistent, no reset is
2686 ** needed.
2687 */
2688 static int pager_playback(Pager *pPager, int isHot){
2689 sqlite3_vfs *pVfs = pPager->pVfs;
2690 i64 szJ; /* Size of the journal file in bytes */
2691 u32 nRec; /* Number of Records in the journal */
2692 u32 u; /* Unsigned loop counter */
2693 Pgno mxPg = 0; /* Size of the original file in pages */
2694 int rc; /* Result code of a subroutine */
2695 int res = 1; /* Value returned by sqlite3OsAccess() */
2696 char *zMaster = 0; /* Name of master journal file if any */
2697 int needPagerReset; /* True to reset page prior to first page rollback */
2698 int nPlayback = 0; /* Total number of pages restored from journal */
2699
2700 /* Figure out how many records are in the journal. Abort early if
2701 ** the journal is empty.
2702 */
2703 assert( isOpen(pPager->jfd) );
2704 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
2705 if( rc!=SQLITE_OK ){
2706 goto end_playback;
2707 }
2708
2709 /* Read the master journal name from the journal, if it is present.
2710 ** If a master journal file name is specified, but the file is not
2711 ** present on disk, then the journal is not hot and does not need to be
2712 ** played back.
2713 **
2714 ** TODO: Technically the following is an error because it assumes that
2715 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2716 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
2717 ** mxPathname is 512, which is the same as the minimum allowable value
2718 ** for pageSize.
2719 */
2720 zMaster = pPager->pTmpSpace;
2721 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
2722 if( rc==SQLITE_OK && zMaster[0] ){
2723 rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
2724 }
2725 zMaster = 0;
2726 if( rc!=SQLITE_OK || !res ){
2727 goto end_playback;
2728 }
2729 pPager->journalOff = 0;
2730 needPagerReset = isHot;
2731
2732 /* This loop terminates either when a readJournalHdr() or
2733 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2734 ** occurs.
2735 */
2736 while( 1 ){
2737 /* Read the next journal header from the journal file. If there are
2738 ** not enough bytes left in the journal file for a complete header, or
2739 ** it is corrupted, then a process must have failed while writing it.
2740 ** This indicates nothing more needs to be rolled back.
2741 */
2742 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
2743 if( rc!=SQLITE_OK ){
2744 if( rc==SQLITE_DONE ){
2745 rc = SQLITE_OK;
2746 }
2747 goto end_playback;
2748 }
2749
2750 /* If nRec is 0xffffffff, then this journal was created by a process
2751 ** working in no-sync mode. This means that the rest of the journal
2752 ** file consists of pages, there are no more journal headers. Compute
2753 ** the value of nRec based on this assumption.
2754 */
2755 if( nRec==0xffffffff ){
2756 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
2757 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
2758 }
2759
2760 /* If nRec is 0 and this rollback is of a transaction created by this
2761 ** process and if this is the final header in the journal, then it means
2762 ** that this part of the journal was being filled but has not yet been
2763 ** synced to disk. Compute the number of pages based on the remaining
2764 ** size of the file.
2765 **
2766 ** The third term of the test was added to fix ticket #2565.
2767 ** When rolling back a hot journal, nRec==0 always means that the next
2768 ** chunk of the journal contains zero pages to be rolled back. But
2769 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2770 ** the journal, it means that the journal might contain additional
2771 ** pages that need to be rolled back and that the number of pages
2772 ** should be computed based on the journal file size.
2773 */
2774 if( nRec==0 && !isHot &&
2775 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
2776 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
2777 }
2778
2779 /* If this is the first header read from the journal, truncate the
2780 ** database file back to its original size.
2781 */
2782 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
2783 rc = pager_truncate(pPager, mxPg);
2784 if( rc!=SQLITE_OK ){
2785 goto end_playback;
2786 }
2787 pPager->dbSize = mxPg;
2788 }
2789
2790 /* Copy original pages out of the journal and back into the
2791 ** database file and/or page cache.
2792 */
2793 for(u=0; u<nRec; u++){
2794 if( needPagerReset ){
2795 pager_reset(pPager);
2796 needPagerReset = 0;
2797 }
2798 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
2799 if( rc==SQLITE_OK ){
2800 nPlayback++;
2801 }else{
2802 if( rc==SQLITE_DONE ){
2803 pPager->journalOff = szJ;
2804 break;
2805 }else if( rc==SQLITE_IOERR_SHORT_READ ){
2806 /* If the journal has been truncated, simply stop reading and
2807 ** processing the journal. This might happen if the journal was
2808 ** not completely written and synced prior to a crash. In that
2809 ** case, the database should have never been written in the
2810 ** first place so it is OK to simply abandon the rollback. */
2811 rc = SQLITE_OK;
2812 goto end_playback;
2813 }else{
2814 /* If we are unable to rollback, quit and return the error
2815 ** code. This will cause the pager to enter the error state
2816 ** so that no further harm will be done. Perhaps the next
2817 ** process to come along will be able to rollback the database.
2818 */
2819 goto end_playback;
2820 }
2821 }
2822 }
2823 }
2824 /*NOTREACHED*/
2825 assert( 0 );
2826
2827 end_playback:
2828 /* Following a rollback, the database file should be back in its original
2829 ** state prior to the start of the transaction, so invoke the
2830 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
2831 ** assertion that the transaction counter was modified.
2832 */
2833 #ifdef SQLITE_DEBUG
2834 if( pPager->fd->pMethods ){
2835 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
2836 }
2837 #endif
2838
2839 /* If this playback is happening automatically as a result of an IO or
2840 ** malloc error that occurred after the change-counter was updated but
2841 ** before the transaction was committed, then the change-counter
2842 ** modification may just have been reverted. If this happens in exclusive
2843 ** mode, then subsequent transactions performed by the connection will not
2844 ** update the change-counter at all. This may lead to cache inconsistency
2845 ** problems for other processes at some point in the future. So, just
2846 ** in case this has happened, clear the changeCountDone flag now.
2847 */
2848 pPager->changeCountDone = pPager->tempFile;
2849
2850 if( rc==SQLITE_OK ){
2851 zMaster = pPager->pTmpSpace;
2852 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
2853 testcase( rc!=SQLITE_OK );
2854 }
2855 if( rc==SQLITE_OK
2856 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
2857 ){
2858 rc = sqlite3PagerSync(pPager, 0);
2859 }
2860 if( rc==SQLITE_OK ){
2861 rc = pager_end_transaction(pPager, zMaster[0]!='\0', 0);
2862 testcase( rc!=SQLITE_OK );
2863 }
2864 if( rc==SQLITE_OK && zMaster[0] && res ){
2865 /* If there was a master journal and this routine will return success,
2866 ** see if it is possible to delete the master journal.
2867 */
2868 rc = pager_delmaster(pPager, zMaster);
2869 testcase( rc!=SQLITE_OK );
2870 }
2871 if( isHot && nPlayback ){
2872 sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s",
2873 nPlayback, pPager->zJournal);
2874 }
2875
2876 /* The Pager.sectorSize variable may have been updated while rolling
2877 ** back a journal created by a process with a different sector size
2878 ** value. Reset it to the correct value for this process.
2879 */
2880 setSectorSize(pPager);
2881 return rc;
2882 }
2883
2884
2885 /*
2886 ** Read the content for page pPg out of the database file and into
2887 ** pPg->pData. A shared lock or greater must be held on the database
2888 ** file before this function is called.
2889 **
2890 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
2891 ** the value read from the database file.
2892 **
2893 ** If an IO error occurs, then the IO error is returned to the caller.
2894 ** Otherwise, SQLITE_OK is returned.
2895 */
2896 static int readDbPage(PgHdr *pPg, u32 iFrame){
2897 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
2898 Pgno pgno = pPg->pgno; /* Page number to read */
2899 int rc = SQLITE_OK; /* Return code */
2900 int pgsz = pPager->pageSize; /* Number of bytes to read */
2901
2902 assert( pPager->eState>=PAGER_READER && !MEMDB );
2903 assert( isOpen(pPager->fd) );
2904
2905 #ifndef SQLITE_OMIT_WAL
2906 if( iFrame ){
2907 /* Try to pull the page from the write-ahead log. */
2908 rc = sqlite3WalReadFrame(pPager->pWal, iFrame, pgsz, pPg->pData);
2909 }else
2910 #endif
2911 {
2912 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
2913 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
2914 if( rc==SQLITE_IOERR_SHORT_READ ){
2915 rc = SQLITE_OK;
2916 }
2917 }
2918
2919 if( pgno==1 ){
2920 if( rc ){
2921 /* If the read is unsuccessful, set the dbFileVers[] to something
2922 ** that will never be a valid file version. dbFileVers[] is a copy
2923 ** of bytes 24..39 of the database. Bytes 28..31 should always be
2924 ** zero or the size of the database in page. Bytes 32..35 and 35..39
2925 ** should be page numbers which are never 0xffffffff. So filling
2926 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
2927 **
2928 ** For an encrypted database, the situation is more complex: bytes
2929 ** 24..39 of the database are white noise. But the probability of
2930 ** white noise equaling 16 bytes of 0xff is vanishingly small so
2931 ** we should still be ok.
2932 */
2933 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
2934 }else{
2935 u8 *dbFileVers = &((u8*)pPg->pData)[24];
2936 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
2937 }
2938 }
2939 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
2940
2941 PAGER_INCR(sqlite3_pager_readdb_count);
2942 PAGER_INCR(pPager->nRead);
2943 IOTRACE(("PGIN %p %d\n", pPager, pgno));
2944 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
2945 PAGERID(pPager), pgno, pager_pagehash(pPg)));
2946
2947 return rc;
2948 }
2949
2950 /*
2951 ** Update the value of the change-counter at offsets 24 and 92 in
2952 ** the header and the sqlite version number at offset 96.
2953 **
2954 ** This is an unconditional update. See also the pager_incr_changecounter()
2955 ** routine which only updates the change-counter if the update is actually
2956 ** needed, as determined by the pPager->changeCountDone state variable.
2957 */
2958 static void pager_write_changecounter(PgHdr *pPg){
2959 u32 change_counter;
2960
2961 /* Increment the value just read and write it back to byte 24. */
2962 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
2963 put32bits(((char*)pPg->pData)+24, change_counter);
2964
2965 /* Also store the SQLite version number in bytes 96..99 and in
2966 ** bytes 92..95 store the change counter for which the version number
2967 ** is valid. */
2968 put32bits(((char*)pPg->pData)+92, change_counter);
2969 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
2970 }
2971
2972 #ifndef SQLITE_OMIT_WAL
2973 /*
2974 ** This function is invoked once for each page that has already been
2975 ** written into the log file when a WAL transaction is rolled back.
2976 ** Parameter iPg is the page number of said page. The pCtx argument
2977 ** is actually a pointer to the Pager structure.
2978 **
2979 ** If page iPg is present in the cache, and has no outstanding references,
2980 ** it is discarded. Otherwise, if there are one or more outstanding
2981 ** references, the page content is reloaded from the database. If the
2982 ** attempt to reload content from the database is required and fails,
2983 ** return an SQLite error code. Otherwise, SQLITE_OK.
2984 */
2985 static int pagerUndoCallback(void *pCtx, Pgno iPg){
2986 int rc = SQLITE_OK;
2987 Pager *pPager = (Pager *)pCtx;
2988 PgHdr *pPg;
2989
2990 assert( pagerUseWal(pPager) );
2991 pPg = sqlite3PagerLookup(pPager, iPg);
2992 if( pPg ){
2993 if( sqlite3PcachePageRefcount(pPg)==1 ){
2994 sqlite3PcacheDrop(pPg);
2995 }else{
2996 u32 iFrame = 0;
2997 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
2998 if( rc==SQLITE_OK ){
2999 rc = readDbPage(pPg, iFrame);
3000 }
3001 if( rc==SQLITE_OK ){
3002 pPager->xReiniter(pPg);
3003 }
3004 sqlite3PagerUnrefNotNull(pPg);
3005 }
3006 }
3007
3008 /* Normally, if a transaction is rolled back, any backup processes are
3009 ** updated as data is copied out of the rollback journal and into the
3010 ** database. This is not generally possible with a WAL database, as
3011 ** rollback involves simply truncating the log file. Therefore, if one
3012 ** or more frames have already been written to the log (and therefore
3013 ** also copied into the backup databases) as part of this transaction,
3014 ** the backups must be restarted.
3015 */
3016 sqlite3BackupRestart(pPager->pBackup);
3017
3018 return rc;
3019 }
3020
3021 /*
3022 ** This function is called to rollback a transaction on a WAL database.
3023 */
3024 static int pagerRollbackWal(Pager *pPager){
3025 int rc; /* Return Code */
3026 PgHdr *pList; /* List of dirty pages to revert */
3027
3028 /* For all pages in the cache that are currently dirty or have already
3029 ** been written (but not committed) to the log file, do one of the
3030 ** following:
3031 **
3032 ** + Discard the cached page (if refcount==0), or
3033 ** + Reload page content from the database (if refcount>0).
3034 */
3035 pPager->dbSize = pPager->dbOrigSize;
3036 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
3037 pList = sqlite3PcacheDirtyList(pPager->pPCache);
3038 while( pList && rc==SQLITE_OK ){
3039 PgHdr *pNext = pList->pDirty;
3040 rc = pagerUndoCallback((void *)pPager, pList->pgno);
3041 pList = pNext;
3042 }
3043
3044 return rc;
3045 }
3046
3047 /*
3048 ** This function is a wrapper around sqlite3WalFrames(). As well as logging
3049 ** the contents of the list of pages headed by pList (connected by pDirty),
3050 ** this function notifies any active backup processes that the pages have
3051 ** changed.
3052 **
3053 ** The list of pages passed into this routine is always sorted by page number.
3054 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
3055 */
3056 static int pagerWalFrames(
3057 Pager *pPager, /* Pager object */
3058 PgHdr *pList, /* List of frames to log */
3059 Pgno nTruncate, /* Database size after this commit */
3060 int isCommit /* True if this is a commit */
3061 ){
3062 int rc; /* Return code */
3063 int nList; /* Number of pages in pList */
3064 PgHdr *p; /* For looping over pages */
3065
3066 assert( pPager->pWal );
3067 assert( pList );
3068 #ifdef SQLITE_DEBUG
3069 /* Verify that the page list is in accending order */
3070 for(p=pList; p && p->pDirty; p=p->pDirty){
3071 assert( p->pgno < p->pDirty->pgno );
3072 }
3073 #endif
3074
3075 assert( pList->pDirty==0 || isCommit );
3076 if( isCommit ){
3077 /* If a WAL transaction is being committed, there is no point in writing
3078 ** any pages with page numbers greater than nTruncate into the WAL file.
3079 ** They will never be read by any client. So remove them from the pDirty
3080 ** list here. */
3081 PgHdr **ppNext = &pList;
3082 nList = 0;
3083 for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
3084 if( p->pgno<=nTruncate ){
3085 ppNext = &p->pDirty;
3086 nList++;
3087 }
3088 }
3089 assert( pList );
3090 }else{
3091 nList = 1;
3092 }
3093 pPager->aStat[PAGER_STAT_WRITE] += nList;
3094
3095 if( pList->pgno==1 ) pager_write_changecounter(pList);
3096 rc = sqlite3WalFrames(pPager->pWal,
3097 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
3098 );
3099 if( rc==SQLITE_OK && pPager->pBackup ){
3100 for(p=pList; p; p=p->pDirty){
3101 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
3102 }
3103 }
3104
3105 #ifdef SQLITE_CHECK_PAGES
3106 pList = sqlite3PcacheDirtyList(pPager->pPCache);
3107 for(p=pList; p; p=p->pDirty){
3108 pager_set_pagehash(p);
3109 }
3110 #endif
3111
3112 return rc;
3113 }
3114
3115 /*
3116 ** Begin a read transaction on the WAL.
3117 **
3118 ** This routine used to be called "pagerOpenSnapshot()" because it essentially
3119 ** makes a snapshot of the database at the current point in time and preserves
3120 ** that snapshot for use by the reader in spite of concurrently changes by
3121 ** other writers or checkpointers.
3122 */
3123 static int pagerBeginReadTransaction(Pager *pPager){
3124 int rc; /* Return code */
3125 int changed = 0; /* True if cache must be reset */
3126
3127 assert( pagerUseWal(pPager) );
3128 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
3129
3130 /* sqlite3WalEndReadTransaction() was not called for the previous
3131 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
3132 ** are in locking_mode=NORMAL and EndRead() was previously called,
3133 ** the duplicate call is harmless.
3134 */
3135 sqlite3WalEndReadTransaction(pPager->pWal);
3136
3137 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
3138 if( rc!=SQLITE_OK || changed ){
3139 pager_reset(pPager);
3140 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
3141 }
3142
3143 return rc;
3144 }
3145 #endif
3146
3147 /*
3148 ** This function is called as part of the transition from PAGER_OPEN
3149 ** to PAGER_READER state to determine the size of the database file
3150 ** in pages (assuming the page size currently stored in Pager.pageSize).
3151 **
3152 ** If no error occurs, SQLITE_OK is returned and the size of the database
3153 ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
3154 ** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
3155 */
3156 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
3157 Pgno nPage; /* Value to return via *pnPage */
3158
3159 /* Query the WAL sub-system for the database size. The WalDbsize()
3160 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
3161 ** if the database size is not available. The database size is not
3162 ** available from the WAL sub-system if the log file is empty or
3163 ** contains no valid committed transactions.
3164 */
3165 assert( pPager->eState==PAGER_OPEN );
3166 assert( pPager->eLock>=SHARED_LOCK );
3167 nPage = sqlite3WalDbsize(pPager->pWal);
3168
3169 /* If the number of pages in the database is not available from the
3170 ** WAL sub-system, determine the page counte based on the size of
3171 ** the database file. If the size of the database file is not an
3172 ** integer multiple of the page-size, round up the result.
3173 */
3174 if( nPage==0 ){
3175 i64 n = 0; /* Size of db file in bytes */
3176 assert( isOpen(pPager->fd) || pPager->tempFile );
3177 if( isOpen(pPager->fd) ){
3178 int rc = sqlite3OsFileSize(pPager->fd, &n);
3179 if( rc!=SQLITE_OK ){
3180 return rc;
3181 }
3182 }
3183 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
3184 }
3185
3186 /* If the current number of pages in the file is greater than the
3187 ** configured maximum pager number, increase the allowed limit so
3188 ** that the file can be read.
3189 */
3190 if( nPage>pPager->mxPgno ){
3191 pPager->mxPgno = (Pgno)nPage;
3192 }
3193
3194 *pnPage = nPage;
3195 return SQLITE_OK;
3196 }
3197
3198 #ifndef SQLITE_OMIT_WAL
3199 /*
3200 ** Check if the *-wal file that corresponds to the database opened by pPager
3201 ** exists if the database is not empy, or verify that the *-wal file does
3202 ** not exist (by deleting it) if the database file is empty.
3203 **
3204 ** If the database is not empty and the *-wal file exists, open the pager
3205 ** in WAL mode. If the database is empty or if no *-wal file exists and
3206 ** if no error occurs, make sure Pager.journalMode is not set to
3207 ** PAGER_JOURNALMODE_WAL.
3208 **
3209 ** Return SQLITE_OK or an error code.
3210 **
3211 ** The caller must hold a SHARED lock on the database file to call this
3212 ** function. Because an EXCLUSIVE lock on the db file is required to delete
3213 ** a WAL on a none-empty database, this ensures there is no race condition
3214 ** between the xAccess() below and an xDelete() being executed by some
3215 ** other connection.
3216 */
3217 static int pagerOpenWalIfPresent(Pager *pPager){
3218 int rc = SQLITE_OK;
3219 assert( pPager->eState==PAGER_OPEN );
3220 assert( pPager->eLock>=SHARED_LOCK );
3221
3222 if( !pPager->tempFile ){
3223 int isWal; /* True if WAL file exists */
3224 Pgno nPage; /* Size of the database file */
3225
3226 rc = pagerPagecount(pPager, &nPage);
3227 if( rc ) return rc;
3228 if( nPage==0 ){
3229 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
3230 if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
3231 isWal = 0;
3232 }else{
3233 rc = sqlite3OsAccess(
3234 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
3235 );
3236 }
3237 if( rc==SQLITE_OK ){
3238 if( isWal ){
3239 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
3240 rc = sqlite3PagerOpenWal(pPager, 0);
3241 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
3242 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
3243 }
3244 }
3245 }
3246 return rc;
3247 }
3248 #endif
3249
3250 /*
3251 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
3252 ** the entire master journal file. The case pSavepoint==NULL occurs when
3253 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
3254 ** savepoint.
3255 **
3256 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
3257 ** being rolled back), then the rollback consists of up to three stages,
3258 ** performed in the order specified:
3259 **
3260 ** * Pages are played back from the main journal starting at byte
3261 ** offset PagerSavepoint.iOffset and continuing to
3262 ** PagerSavepoint.iHdrOffset, or to the end of the main journal
3263 ** file if PagerSavepoint.iHdrOffset is zero.
3264 **
3265 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
3266 ** back starting from the journal header immediately following
3267 ** PagerSavepoint.iHdrOffset to the end of the main journal file.
3268 **
3269 ** * Pages are then played back from the sub-journal file, starting
3270 ** with the PagerSavepoint.iSubRec and continuing to the end of
3271 ** the journal file.
3272 **
3273 ** Throughout the rollback process, each time a page is rolled back, the
3274 ** corresponding bit is set in a bitvec structure (variable pDone in the
3275 ** implementation below). This is used to ensure that a page is only
3276 ** rolled back the first time it is encountered in either journal.
3277 **
3278 ** If pSavepoint is NULL, then pages are only played back from the main
3279 ** journal file. There is no need for a bitvec in this case.
3280 **
3281 ** In either case, before playback commences the Pager.dbSize variable
3282 ** is reset to the value that it held at the start of the savepoint
3283 ** (or transaction). No page with a page-number greater than this value
3284 ** is played back. If one is encountered it is simply skipped.
3285 */
3286 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
3287 i64 szJ; /* Effective size of the main journal */
3288 i64 iHdrOff; /* End of first segment of main-journal records */
3289 int rc = SQLITE_OK; /* Return code */
3290 Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
3291
3292 assert( pPager->eState!=PAGER_ERROR );
3293 assert( pPager->eState>=PAGER_WRITER_LOCKED );
3294
3295 /* Allocate a bitvec to use to store the set of pages rolled back */
3296 if( pSavepoint ){
3297 pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
3298 if( !pDone ){
3299 return SQLITE_NOMEM;
3300 }
3301 }
3302
3303 /* Set the database size back to the value it was before the savepoint
3304 ** being reverted was opened.
3305 */
3306 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
3307 pPager->changeCountDone = pPager->tempFile;
3308
3309 if( !pSavepoint && pagerUseWal(pPager) ){
3310 return pagerRollbackWal(pPager);
3311 }
3312
3313 /* Use pPager->journalOff as the effective size of the main rollback
3314 ** journal. The actual file might be larger than this in
3315 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
3316 ** past pPager->journalOff is off-limits to us.
3317 */
3318 szJ = pPager->journalOff;
3319 assert( pagerUseWal(pPager)==0 || szJ==0 );
3320
3321 /* Begin by rolling back records from the main journal starting at
3322 ** PagerSavepoint.iOffset and continuing to the next journal header.
3323 ** There might be records in the main journal that have a page number
3324 ** greater than the current database size (pPager->dbSize) but those
3325 ** will be skipped automatically. Pages are added to pDone as they
3326 ** are played back.
3327 */
3328 if( pSavepoint && !pagerUseWal(pPager) ){
3329 iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
3330 pPager->journalOff = pSavepoint->iOffset;
3331 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
3332 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
3333 }
3334 assert( rc!=SQLITE_DONE );
3335 }else{
3336 pPager->journalOff = 0;
3337 }
3338
3339 /* Continue rolling back records out of the main journal starting at
3340 ** the first journal header seen and continuing until the effective end
3341 ** of the main journal file. Continue to skip out-of-range pages and
3342 ** continue adding pages rolled back to pDone.
3343 */
3344 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
3345 u32 ii; /* Loop counter */
3346 u32 nJRec = 0; /* Number of Journal Records */
3347 u32 dummy;
3348 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
3349 assert( rc!=SQLITE_DONE );
3350
3351 /*
3352 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
3353 ** test is related to ticket #2565. See the discussion in the
3354 ** pager_playback() function for additional information.
3355 */
3356 if( nJRec==0
3357 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
3358 ){
3359 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
3360 }
3361 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
3362 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
3363 }
3364 assert( rc!=SQLITE_DONE );
3365 }
3366 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
3367
3368 /* Finally, rollback pages from the sub-journal. Page that were
3369 ** previously rolled back out of the main journal (and are hence in pDone)
3370 ** will be skipped. Out-of-range pages are also skipped.
3371 */
3372 if( pSavepoint ){
3373 u32 ii; /* Loop counter */
3374 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
3375
3376 if( pagerUseWal(pPager) ){
3377 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
3378 }
3379 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
3380 assert( offset==(i64)ii*(4+pPager->pageSize) );
3381 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
3382 }
3383 assert( rc!=SQLITE_DONE );
3384 }
3385
3386 sqlite3BitvecDestroy(pDone);
3387 if( rc==SQLITE_OK ){
3388 pPager->journalOff = szJ;
3389 }
3390
3391 return rc;
3392 }
3393
3394 /*
3395 ** Change the maximum number of in-memory pages that are allowed
3396 ** before attempting to recycle clean and unused pages.
3397 */
3398 void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
3399 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
3400 }
3401
3402 /*
3403 ** Change the maximum number of in-memory pages that are allowed
3404 ** before attempting to spill pages to journal.
3405 */
3406 int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){
3407 return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage);
3408 }
3409
3410 /*
3411 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
3412 */
3413 static void pagerFixMaplimit(Pager *pPager){
3414 #if SQLITE_MAX_MMAP_SIZE>0
3415 sqlite3_file *fd = pPager->fd;
3416 if( isOpen(fd) && fd->pMethods->iVersion>=3 ){
3417 sqlite3_int64 sz;
3418 sz = pPager->szMmap;
3419 pPager->bUseFetch = (sz>0);
3420 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
3421 }
3422 #endif
3423 }
3424
3425 /*
3426 ** Change the maximum size of any memory mapping made of the database file.
3427 */
3428 void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
3429 pPager->szMmap = szMmap;
3430 pagerFixMaplimit(pPager);
3431 }
3432
3433 /*
3434 ** Free as much memory as possible from the pager.
3435 */
3436 void sqlite3PagerShrink(Pager *pPager){
3437 sqlite3PcacheShrink(pPager->pPCache);
3438 }
3439
3440 /*
3441 ** Adjust settings of the pager to those specified in the pgFlags parameter.
3442 **
3443 ** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness
3444 ** of the database to damage due to OS crashes or power failures by
3445 ** changing the number of syncs()s when writing the journals.
3446 ** There are three levels:
3447 **
3448 ** OFF sqlite3OsSync() is never called. This is the default
3449 ** for temporary and transient files.
3450 **
3451 ** NORMAL The journal is synced once before writes begin on the
3452 ** database. This is normally adequate protection, but
3453 ** it is theoretically possible, though very unlikely,
3454 ** that an inopertune power failure could leave the journal
3455 ** in a state which would cause damage to the database
3456 ** when it is rolled back.
3457 **
3458 ** FULL The journal is synced twice before writes begin on the
3459 ** database (with some additional information - the nRec field
3460 ** of the journal header - being written in between the two
3461 ** syncs). If we assume that writing a
3462 ** single disk sector is atomic, then this mode provides
3463 ** assurance that the journal will not be corrupted to the
3464 ** point of causing damage to the database during rollback.
3465 **
3466 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
3467 ** to mean that no syncs ever occur. NORMAL means that the WAL is synced
3468 ** prior to the start of checkpoint and that the database file is synced
3469 ** at the conclusion of the checkpoint if the entire content of the WAL
3470 ** was written back into the database. But no sync operations occur for
3471 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
3472 ** file is synced following each commit operation, in addition to the
3473 ** syncs associated with NORMAL.
3474 **
3475 ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
3476 ** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
3477 ** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
3478 ** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
3479 ** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
3480 ** synchronous=FULL versus synchronous=NORMAL setting determines when
3481 ** the xSync primitive is called and is relevant to all platforms.
3482 **
3483 ** Numeric values associated with these states are OFF==1, NORMAL=2,
3484 ** and FULL=3.
3485 */
3486 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
3487 void sqlite3PagerSetFlags(
3488 Pager *pPager, /* The pager to set safety level for */
3489 unsigned pgFlags /* Various flags */
3490 ){
3491 unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK;
3492 assert( level>=1 && level<=3 );
3493 pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
3494 pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
3495 if( pPager->noSync ){
3496 pPager->syncFlags = 0;
3497 pPager->ckptSyncFlags = 0;
3498 }else if( pgFlags & PAGER_FULLFSYNC ){
3499 pPager->syncFlags = SQLITE_SYNC_FULL;
3500 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
3501 }else if( pgFlags & PAGER_CKPT_FULLFSYNC ){
3502 pPager->syncFlags = SQLITE_SYNC_NORMAL;
3503 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
3504 }else{
3505 pPager->syncFlags = SQLITE_SYNC_NORMAL;
3506 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
3507 }
3508 pPager->walSyncFlags = pPager->syncFlags;
3509 if( pPager->fullSync ){
3510 pPager->walSyncFlags |= WAL_SYNC_TRANSACTIONS;
3511 }
3512 if( pgFlags & PAGER_CACHESPILL ){
3513 pPager->doNotSpill &= ~SPILLFLAG_OFF;
3514 }else{
3515 pPager->doNotSpill |= SPILLFLAG_OFF;
3516 }
3517 }
3518 #endif
3519
3520 /*
3521 ** The following global variable is incremented whenever the library
3522 ** attempts to open a temporary file. This information is used for
3523 ** testing and analysis only.
3524 */
3525 #ifdef SQLITE_TEST
3526 int sqlite3_opentemp_count = 0;
3527 #endif
3528
3529 /*
3530 ** Open a temporary file.
3531 **
3532 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
3533 ** or some other error code if we fail. The OS will automatically
3534 ** delete the temporary file when it is closed.
3535 **
3536 ** The flags passed to the VFS layer xOpen() call are those specified
3537 ** by parameter vfsFlags ORed with the following:
3538 **
3539 ** SQLITE_OPEN_READWRITE
3540 ** SQLITE_OPEN_CREATE
3541 ** SQLITE_OPEN_EXCLUSIVE
3542 ** SQLITE_OPEN_DELETEONCLOSE
3543 */
3544 static int pagerOpentemp(
3545 Pager *pPager, /* The pager object */
3546 sqlite3_file *pFile, /* Write the file descriptor here */
3547 int vfsFlags /* Flags passed through to the VFS */
3548 ){
3549 int rc; /* Return code */
3550
3551 #ifdef SQLITE_TEST
3552 sqlite3_opentemp_count++; /* Used for testing and analysis only */
3553 #endif
3554
3555 vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
3556 SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
3557 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
3558 assert( rc!=SQLITE_OK || isOpen(pFile) );
3559 return rc;
3560 }
3561
3562 /*
3563 ** Set the busy handler function.
3564 **
3565 ** The pager invokes the busy-handler if sqlite3OsLock() returns
3566 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
3567 ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
3568 ** lock. It does *not* invoke the busy handler when upgrading from
3569 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
3570 ** (which occurs during hot-journal rollback). Summary:
3571 **
3572 ** Transition | Invokes xBusyHandler
3573 ** --------------------------------------------------------
3574 ** NO_LOCK -> SHARED_LOCK | Yes
3575 ** SHARED_LOCK -> RESERVED_LOCK | No
3576 ** SHARED_LOCK -> EXCLUSIVE_LOCK | No
3577 ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
3578 **
3579 ** If the busy-handler callback returns non-zero, the lock is
3580 ** retried. If it returns zero, then the SQLITE_BUSY error is
3581 ** returned to the caller of the pager API function.
3582 */
3583 void sqlite3PagerSetBusyhandler(
3584 Pager *pPager, /* Pager object */
3585 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
3586 void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
3587 ){
3588 pPager->xBusyHandler = xBusyHandler;
3589 pPager->pBusyHandlerArg = pBusyHandlerArg;
3590
3591 if( isOpen(pPager->fd) ){
3592 void **ap = (void **)&pPager->xBusyHandler;
3593 assert( ((int(*)(void *))(ap[0]))==xBusyHandler );
3594 assert( ap[1]==pBusyHandlerArg );
3595 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
3596 }
3597 }
3598
3599 /*
3600 ** Change the page size used by the Pager object. The new page size
3601 ** is passed in *pPageSize.
3602 **
3603 ** If the pager is in the error state when this function is called, it
3604 ** is a no-op. The value returned is the error state error code (i.e.
3605 ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
3606 **
3607 ** Otherwise, if all of the following are true:
3608 **
3609 ** * the new page size (value of *pPageSize) is valid (a power
3610 ** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
3611 **
3612 ** * there are no outstanding page references, and
3613 **
3614 ** * the database is either not an in-memory database or it is
3615 ** an in-memory database that currently consists of zero pages.
3616 **
3617 ** then the pager object page size is set to *pPageSize.
3618 **
3619 ** If the page size is changed, then this function uses sqlite3PagerMalloc()
3620 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
3621 ** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
3622 ** In all other cases, SQLITE_OK is returned.
3623 **
3624 ** If the page size is not changed, either because one of the enumerated
3625 ** conditions above is not true, the pager was in error state when this
3626 ** function was called, or because the memory allocation attempt failed,
3627 ** then *pPageSize is set to the old, retained page size before returning.
3628 */
3629 int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
3630 int rc = SQLITE_OK;
3631
3632 /* It is not possible to do a full assert_pager_state() here, as this
3633 ** function may be called from within PagerOpen(), before the state
3634 ** of the Pager object is internally consistent.
3635 **
3636 ** At one point this function returned an error if the pager was in
3637 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
3638 ** there is at least one outstanding page reference, this function
3639 ** is a no-op for that case anyhow.
3640 */
3641
3642 u32 pageSize = *pPageSize;
3643 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
3644 if( (pPager->memDb==0 || pPager->dbSize==0)
3645 && sqlite3PcacheRefCount(pPager->pPCache)==0
3646 && pageSize && pageSize!=(u32)pPager->pageSize
3647 ){
3648 char *pNew = NULL; /* New temp space */
3649 i64 nByte = 0;
3650
3651 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
3652 rc = sqlite3OsFileSize(pPager->fd, &nByte);
3653 }
3654 if( rc==SQLITE_OK ){
3655 pNew = (char *)sqlite3PageMalloc(pageSize);
3656 if( !pNew ) rc = SQLITE_NOMEM;
3657 }
3658
3659 if( rc==SQLITE_OK ){
3660 pager_reset(pPager);
3661 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
3662 }
3663 if( rc==SQLITE_OK ){
3664 sqlite3PageFree(pPager->pTmpSpace);
3665 pPager->pTmpSpace = pNew;
3666 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
3667 pPager->pageSize = pageSize;
3668 }else{
3669 sqlite3PageFree(pNew);
3670 }
3671 }
3672
3673 *pPageSize = pPager->pageSize;
3674 if( rc==SQLITE_OK ){
3675 if( nReserve<0 ) nReserve = pPager->nReserve;
3676 assert( nReserve>=0 && nReserve<1000 );
3677 pPager->nReserve = (i16)nReserve;
3678 pagerReportSize(pPager);
3679 pagerFixMaplimit(pPager);
3680 }
3681 return rc;
3682 }
3683
3684 /*
3685 ** Return a pointer to the "temporary page" buffer held internally
3686 ** by the pager. This is a buffer that is big enough to hold the
3687 ** entire content of a database page. This buffer is used internally
3688 ** during rollback and will be overwritten whenever a rollback
3689 ** occurs. But other modules are free to use it too, as long as
3690 ** no rollbacks are happening.
3691 */
3692 void *sqlite3PagerTempSpace(Pager *pPager){
3693 return pPager->pTmpSpace;
3694 }
3695
3696 /*
3697 ** Attempt to set the maximum database page count if mxPage is positive.
3698 ** Make no changes if mxPage is zero or negative. And never reduce the
3699 ** maximum page count below the current size of the database.
3700 **
3701 ** Regardless of mxPage, return the current maximum page count.
3702 */
3703 int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
3704 if( mxPage>0 ){
3705 pPager->mxPgno = mxPage;
3706 }
3707 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
3708 assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
3709 return pPager->mxPgno;
3710 }
3711
3712 /*
3713 ** The following set of routines are used to disable the simulated
3714 ** I/O error mechanism. These routines are used to avoid simulated
3715 ** errors in places where we do not care about errors.
3716 **
3717 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
3718 ** and generate no code.
3719 */
3720 #ifdef SQLITE_TEST
3721 extern int sqlite3_io_error_pending;
3722 extern int sqlite3_io_error_hit;
3723 static int saved_cnt;
3724 void disable_simulated_io_errors(void){
3725 saved_cnt = sqlite3_io_error_pending;
3726 sqlite3_io_error_pending = -1;
3727 }
3728 void enable_simulated_io_errors(void){
3729 sqlite3_io_error_pending = saved_cnt;
3730 }
3731 #else
3732 # define disable_simulated_io_errors()
3733 # define enable_simulated_io_errors()
3734 #endif
3735
3736 /*
3737 ** Read the first N bytes from the beginning of the file into memory
3738 ** that pDest points to.
3739 **
3740 ** If the pager was opened on a transient file (zFilename==""), or
3741 ** opened on a file less than N bytes in size, the output buffer is
3742 ** zeroed and SQLITE_OK returned. The rationale for this is that this
3743 ** function is used to read database headers, and a new transient or
3744 ** zero sized database has a header than consists entirely of zeroes.
3745 **
3746 ** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
3747 ** the error code is returned to the caller and the contents of the
3748 ** output buffer undefined.
3749 */
3750 int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
3751 int rc = SQLITE_OK;
3752 memset(pDest, 0, N);
3753 assert( isOpen(pPager->fd) || pPager->tempFile );
3754
3755 /* This routine is only called by btree immediately after creating
3756 ** the Pager object. There has not been an opportunity to transition
3757 ** to WAL mode yet.
3758 */
3759 assert( !pagerUseWal(pPager) );
3760
3761 if( isOpen(pPager->fd) ){
3762 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
3763 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
3764 if( rc==SQLITE_IOERR_SHORT_READ ){
3765 rc = SQLITE_OK;
3766 }
3767 }
3768 return rc;
3769 }
3770
3771 /*
3772 ** This function may only be called when a read-transaction is open on
3773 ** the pager. It returns the total number of pages in the database.
3774 **
3775 ** However, if the file is between 1 and <page-size> bytes in size, then
3776 ** this is considered a 1 page file.
3777 */
3778 void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
3779 assert( pPager->eState>=PAGER_READER );
3780 assert( pPager->eState!=PAGER_WRITER_FINISHED );
3781 *pnPage = (int)pPager->dbSize;
3782 }
3783
3784
3785 /*
3786 ** Try to obtain a lock of type locktype on the database file. If
3787 ** a similar or greater lock is already held, this function is a no-op
3788 ** (returning SQLITE_OK immediately).
3789 **
3790 ** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
3791 ** the busy callback if the lock is currently not available. Repeat
3792 ** until the busy callback returns false or until the attempt to
3793 ** obtain the lock succeeds.
3794 **
3795 ** Return SQLITE_OK on success and an error code if we cannot obtain
3796 ** the lock. If the lock is obtained successfully, set the Pager.state
3797 ** variable to locktype before returning.
3798 */
3799 static int pager_wait_on_lock(Pager *pPager, int locktype){
3800 int rc; /* Return code */
3801
3802 /* Check that this is either a no-op (because the requested lock is
3803 ** already held), or one of the transitions that the busy-handler
3804 ** may be invoked during, according to the comment above
3805 ** sqlite3PagerSetBusyhandler().
3806 */
3807 assert( (pPager->eLock>=locktype)
3808 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
3809 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
3810 );
3811
3812 do {
3813 rc = pagerLockDb(pPager, locktype);
3814 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
3815 return rc;
3816 }
3817
3818 /*
3819 ** Function assertTruncateConstraint(pPager) checks that one of the
3820 ** following is true for all dirty pages currently in the page-cache:
3821 **
3822 ** a) The page number is less than or equal to the size of the
3823 ** current database image, in pages, OR
3824 **
3825 ** b) if the page content were written at this time, it would not
3826 ** be necessary to write the current content out to the sub-journal
3827 ** (as determined by function subjRequiresPage()).
3828 **
3829 ** If the condition asserted by this function were not true, and the
3830 ** dirty page were to be discarded from the cache via the pagerStress()
3831 ** routine, pagerStress() would not write the current page content to
3832 ** the database file. If a savepoint transaction were rolled back after
3833 ** this happened, the correct behavior would be to restore the current
3834 ** content of the page. However, since this content is not present in either
3835 ** the database file or the portion of the rollback journal and
3836 ** sub-journal rolled back the content could not be restored and the
3837 ** database image would become corrupt. It is therefore fortunate that
3838 ** this circumstance cannot arise.
3839 */
3840 #if defined(SQLITE_DEBUG)
3841 static void assertTruncateConstraintCb(PgHdr *pPg){
3842 assert( pPg->flags&PGHDR_DIRTY );
3843 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
3844 }
3845 static void assertTruncateConstraint(Pager *pPager){
3846 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
3847 }
3848 #else
3849 # define assertTruncateConstraint(pPager)
3850 #endif
3851
3852 /*
3853 ** Truncate the in-memory database file image to nPage pages. This
3854 ** function does not actually modify the database file on disk. It
3855 ** just sets the internal state of the pager object so that the
3856 ** truncation will be done when the current transaction is committed.
3857 **
3858 ** This function is only called right before committing a transaction.
3859 ** Once this function has been called, the transaction must either be
3860 ** rolled back or committed. It is not safe to call this function and
3861 ** then continue writing to the database.
3862 */
3863 void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
3864 assert( pPager->dbSize>=nPage );
3865 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
3866 pPager->dbSize = nPage;
3867
3868 /* At one point the code here called assertTruncateConstraint() to
3869 ** ensure that all pages being truncated away by this operation are,
3870 ** if one or more savepoints are open, present in the savepoint
3871 ** journal so that they can be restored if the savepoint is rolled
3872 ** back. This is no longer necessary as this function is now only
3873 ** called right before committing a transaction. So although the
3874 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
3875 ** they cannot be rolled back. So the assertTruncateConstraint() call
3876 ** is no longer correct. */
3877 }
3878
3879
3880 /*
3881 ** This function is called before attempting a hot-journal rollback. It
3882 ** syncs the journal file to disk, then sets pPager->journalHdr to the
3883 ** size of the journal file so that the pager_playback() routine knows
3884 ** that the entire journal file has been synced.
3885 **
3886 ** Syncing a hot-journal to disk before attempting to roll it back ensures
3887 ** that if a power-failure occurs during the rollback, the process that
3888 ** attempts rollback following system recovery sees the same journal
3889 ** content as this process.
3890 **
3891 ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
3892 ** an SQLite error code.
3893 */
3894 static int pagerSyncHotJournal(Pager *pPager){
3895 int rc = SQLITE_OK;
3896 if( !pPager->noSync ){
3897 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
3898 }
3899 if( rc==SQLITE_OK ){
3900 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
3901 }
3902 return rc;
3903 }
3904
3905 /*
3906 ** Obtain a reference to a memory mapped page object for page number pgno.
3907 ** The new object will use the pointer pData, obtained from xFetch().
3908 ** If successful, set *ppPage to point to the new page reference
3909 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
3910 ** *ppPage to zero.
3911 **
3912 ** Page references obtained by calling this function should be released
3913 ** by calling pagerReleaseMapPage().
3914 */
3915 static int pagerAcquireMapPage(
3916 Pager *pPager, /* Pager object */
3917 Pgno pgno, /* Page number */
3918 void *pData, /* xFetch()'d data for this page */
3919 PgHdr **ppPage /* OUT: Acquired page object */
3920 ){
3921 PgHdr *p; /* Memory mapped page to return */
3922
3923 if( pPager->pMmapFreelist ){
3924 *ppPage = p = pPager->pMmapFreelist;
3925 pPager->pMmapFreelist = p->pDirty;
3926 p->pDirty = 0;
3927 memset(p->pExtra, 0, pPager->nExtra);
3928 }else{
3929 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
3930 if( p==0 ){
3931 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
3932 return SQLITE_NOMEM;
3933 }
3934 p->pExtra = (void *)&p[1];
3935 p->flags = PGHDR_MMAP;
3936 p->nRef = 1;
3937 p->pPager = pPager;
3938 }
3939
3940 assert( p->pExtra==(void *)&p[1] );
3941 assert( p->pPage==0 );
3942 assert( p->flags==PGHDR_MMAP );
3943 assert( p->pPager==pPager );
3944 assert( p->nRef==1 );
3945
3946 p->pgno = pgno;
3947 p->pData = pData;
3948 pPager->nMmapOut++;
3949
3950 return SQLITE_OK;
3951 }
3952
3953 /*
3954 ** Release a reference to page pPg. pPg must have been returned by an
3955 ** earlier call to pagerAcquireMapPage().
3956 */
3957 static void pagerReleaseMapPage(PgHdr *pPg){
3958 Pager *pPager = pPg->pPager;
3959 pPager->nMmapOut--;
3960 pPg->pDirty = pPager->pMmapFreelist;
3961 pPager->pMmapFreelist = pPg;
3962
3963 assert( pPager->fd->pMethods->iVersion>=3 );
3964 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
3965 }
3966
3967 /*
3968 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
3969 */
3970 static void pagerFreeMapHdrs(Pager *pPager){
3971 PgHdr *p;
3972 PgHdr *pNext;
3973 for(p=pPager->pMmapFreelist; p; p=pNext){
3974 pNext = p->pDirty;
3975 sqlite3_free(p);
3976 }
3977 }
3978
3979
3980 /*
3981 ** Shutdown the page cache. Free all memory and close all files.
3982 **
3983 ** If a transaction was in progress when this routine is called, that
3984 ** transaction is rolled back. All outstanding pages are invalidated
3985 ** and their memory is freed. Any attempt to use a page associated
3986 ** with this page cache after this function returns will likely
3987 ** result in a coredump.
3988 **
3989 ** This function always succeeds. If a transaction is active an attempt
3990 ** is made to roll it back. If an error occurs during the rollback
3991 ** a hot journal may be left in the filesystem but no error is returned
3992 ** to the caller.
3993 */
3994 int sqlite3PagerClose(Pager *pPager){
3995 u8 *pTmp = (u8 *)pPager->pTmpSpace;
3996
3997 assert( assert_pager_state(pPager) );
3998 disable_simulated_io_errors();
3999 sqlite3BeginBenignMalloc();
4000 pagerFreeMapHdrs(pPager);
4001 /* pPager->errCode = 0; */
4002 pPager->exclusiveMode = 0;
4003 #ifndef SQLITE_OMIT_WAL
4004 sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
4005 pPager->pWal = 0;
4006 #endif
4007 pager_reset(pPager);
4008 if( MEMDB ){
4009 pager_unlock(pPager);
4010 }else{
4011 /* If it is open, sync the journal file before calling UnlockAndRollback.
4012 ** If this is not done, then an unsynced portion of the open journal
4013 ** file may be played back into the database. If a power failure occurs
4014 ** while this is happening, the database could become corrupt.
4015 **
4016 ** If an error occurs while trying to sync the journal, shift the pager
4017 ** into the ERROR state. This causes UnlockAndRollback to unlock the
4018 ** database and close the journal file without attempting to roll it
4019 ** back or finalize it. The next database user will have to do hot-journal
4020 ** rollback before accessing the database file.
4021 */
4022 if( isOpen(pPager->jfd) ){
4023 pager_error(pPager, pagerSyncHotJournal(pPager));
4024 }
4025 pagerUnlockAndRollback(pPager);
4026 }
4027 sqlite3EndBenignMalloc();
4028 enable_simulated_io_errors();
4029 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
4030 IOTRACE(("CLOSE %p\n", pPager))
4031 sqlite3OsClose(pPager->jfd);
4032 sqlite3OsClose(pPager->fd);
4033 sqlite3PageFree(pTmp);
4034 sqlite3PcacheClose(pPager->pPCache);
4035
4036 #ifdef SQLITE_HAS_CODEC
4037 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
4038 #endif
4039
4040 assert( !pPager->aSavepoint && !pPager->pInJournal );
4041 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
4042
4043 sqlite3_free(pPager);
4044 return SQLITE_OK;
4045 }
4046
4047 #if !defined(NDEBUG) || defined(SQLITE_TEST)
4048 /*
4049 ** Return the page number for page pPg.
4050 */
4051 Pgno sqlite3PagerPagenumber(DbPage *pPg){
4052 return pPg->pgno;
4053 }
4054 #endif
4055
4056 /*
4057 ** Increment the reference count for page pPg.
4058 */
4059 void sqlite3PagerRef(DbPage *pPg){
4060 sqlite3PcacheRef(pPg);
4061 }
4062
4063 /*
4064 ** Sync the journal. In other words, make sure all the pages that have
4065 ** been written to the journal have actually reached the surface of the
4066 ** disk and can be restored in the event of a hot-journal rollback.
4067 **
4068 ** If the Pager.noSync flag is set, then this function is a no-op.
4069 ** Otherwise, the actions required depend on the journal-mode and the
4070 ** device characteristics of the file-system, as follows:
4071 **
4072 ** * If the journal file is an in-memory journal file, no action need
4073 ** be taken.
4074 **
4075 ** * Otherwise, if the device does not support the SAFE_APPEND property,
4076 ** then the nRec field of the most recently written journal header
4077 ** is updated to contain the number of journal records that have
4078 ** been written following it. If the pager is operating in full-sync
4079 ** mode, then the journal file is synced before this field is updated.
4080 **
4081 ** * If the device does not support the SEQUENTIAL property, then
4082 ** journal file is synced.
4083 **
4084 ** Or, in pseudo-code:
4085 **
4086 ** if( NOT <in-memory journal> ){
4087 ** if( NOT SAFE_APPEND ){
4088 ** if( <full-sync mode> ) xSync(<journal file>);
4089 ** <update nRec field>
4090 ** }
4091 ** if( NOT SEQUENTIAL ) xSync(<journal file>);
4092 ** }
4093 **
4094 ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
4095 ** page currently held in memory before returning SQLITE_OK. If an IO
4096 ** error is encountered, then the IO error code is returned to the caller.
4097 */
4098 static int syncJournal(Pager *pPager, int newHdr){
4099 int rc; /* Return code */
4100
4101 assert( pPager->eState==PAGER_WRITER_CACHEMOD
4102 || pPager->eState==PAGER_WRITER_DBMOD
4103 );
4104 assert( assert_pager_state(pPager) );
4105 assert( !pagerUseWal(pPager) );
4106
4107 rc = sqlite3PagerExclusiveLock(pPager);
4108 if( rc!=SQLITE_OK ) return rc;
4109
4110 if( !pPager->noSync ){
4111 assert( !pPager->tempFile );
4112 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
4113 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
4114 assert( isOpen(pPager->jfd) );
4115
4116 if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
4117 /* This block deals with an obscure problem. If the last connection
4118 ** that wrote to this database was operating in persistent-journal
4119 ** mode, then the journal file may at this point actually be larger
4120 ** than Pager.journalOff bytes. If the next thing in the journal
4121 ** file happens to be a journal-header (written as part of the
4122 ** previous connection's transaction), and a crash or power-failure
4123 ** occurs after nRec is updated but before this connection writes
4124 ** anything else to the journal file (or commits/rolls back its
4125 ** transaction), then SQLite may become confused when doing the
4126 ** hot-journal rollback following recovery. It may roll back all
4127 ** of this connections data, then proceed to rolling back the old,
4128 ** out-of-date data that follows it. Database corruption.
4129 **
4130 ** To work around this, if the journal file does appear to contain
4131 ** a valid header following Pager.journalOff, then write a 0x00
4132 ** byte to the start of it to prevent it from being recognized.
4133 **
4134 ** Variable iNextHdrOffset is set to the offset at which this
4135 ** problematic header will occur, if it exists. aMagic is used
4136 ** as a temporary buffer to inspect the first couple of bytes of
4137 ** the potential journal header.
4138 */
4139 i64 iNextHdrOffset;
4140 u8 aMagic[8];
4141 u8 zHeader[sizeof(aJournalMagic)+4];
4142
4143 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
4144 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
4145
4146 iNextHdrOffset = journalHdrOffset(pPager);
4147 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
4148 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
4149 static const u8 zerobyte = 0;
4150 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
4151 }
4152 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
4153 return rc;
4154 }
4155
4156 /* Write the nRec value into the journal file header. If in
4157 ** full-synchronous mode, sync the journal first. This ensures that
4158 ** all data has really hit the disk before nRec is updated to mark
4159 ** it as a candidate for rollback.
4160 **
4161 ** This is not required if the persistent media supports the
4162 ** SAFE_APPEND property. Because in this case it is not possible
4163 ** for garbage data to be appended to the file, the nRec field
4164 ** is populated with 0xFFFFFFFF when the journal header is written
4165 ** and never needs to be updated.
4166 */
4167 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
4168 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
4169 IOTRACE(("JSYNC %p\n", pPager))
4170 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
4171 if( rc!=SQLITE_OK ) return rc;
4172 }
4173 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
4174 rc = sqlite3OsWrite(
4175 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
4176 );
4177 if( rc!=SQLITE_OK ) return rc;
4178 }
4179 if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
4180 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
4181 IOTRACE(("JSYNC %p\n", pPager))
4182 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
4183 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
4184 );
4185 if( rc!=SQLITE_OK ) return rc;
4186 }
4187
4188 pPager->journalHdr = pPager->journalOff;
4189 if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
4190 pPager->nRec = 0;
4191 rc = writeJournalHdr(pPager);
4192 if( rc!=SQLITE_OK ) return rc;
4193 }
4194 }else{
4195 pPager->journalHdr = pPager->journalOff;
4196 }
4197 }
4198
4199 /* Unless the pager is in noSync mode, the journal file was just
4200 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
4201 ** all pages.
4202 */
4203 sqlite3PcacheClearSyncFlags(pPager->pPCache);
4204 pPager->eState = PAGER_WRITER_DBMOD;
4205 assert( assert_pager_state(pPager) );
4206 return SQLITE_OK;
4207 }
4208
4209 /*
4210 ** The argument is the first in a linked list of dirty pages connected
4211 ** by the PgHdr.pDirty pointer. This function writes each one of the
4212 ** in-memory pages in the list to the database file. The argument may
4213 ** be NULL, representing an empty list. In this case this function is
4214 ** a no-op.
4215 **
4216 ** The pager must hold at least a RESERVED lock when this function
4217 ** is called. Before writing anything to the database file, this lock
4218 ** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
4219 ** SQLITE_BUSY is returned and no data is written to the database file.
4220 **
4221 ** If the pager is a temp-file pager and the actual file-system file
4222 ** is not yet open, it is created and opened before any data is
4223 ** written out.
4224 **
4225 ** Once the lock has been upgraded and, if necessary, the file opened,
4226 ** the pages are written out to the database file in list order. Writing
4227 ** a page is skipped if it meets either of the following criteria:
4228 **
4229 ** * The page number is greater than Pager.dbSize, or
4230 ** * The PGHDR_DONT_WRITE flag is set on the page.
4231 **
4232 ** If writing out a page causes the database file to grow, Pager.dbFileSize
4233 ** is updated accordingly. If page 1 is written out, then the value cached
4234 ** in Pager.dbFileVers[] is updated to match the new value stored in
4235 ** the database file.
4236 **
4237 ** If everything is successful, SQLITE_OK is returned. If an IO error
4238 ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
4239 ** be obtained, SQLITE_BUSY is returned.
4240 */
4241 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
4242 int rc = SQLITE_OK; /* Return code */
4243
4244 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
4245 assert( !pagerUseWal(pPager) );
4246 assert( pPager->eState==PAGER_WRITER_DBMOD );
4247 assert( pPager->eLock==EXCLUSIVE_LOCK );
4248
4249 /* If the file is a temp-file has not yet been opened, open it now. It
4250 ** is not possible for rc to be other than SQLITE_OK if this branch
4251 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
4252 */
4253 if( !isOpen(pPager->fd) ){
4254 assert( pPager->tempFile && rc==SQLITE_OK );
4255 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
4256 }
4257
4258 /* Before the first write, give the VFS a hint of what the final
4259 ** file size will be.
4260 */
4261 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
4262 if( rc==SQLITE_OK
4263 && pPager->dbHintSize<pPager->dbSize
4264 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
4265 ){
4266 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
4267 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
4268 pPager->dbHintSize = pPager->dbSize;
4269 }
4270
4271 while( rc==SQLITE_OK && pList ){
4272 Pgno pgno = pList->pgno;
4273
4274 /* If there are dirty pages in the page cache with page numbers greater
4275 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
4276 ** make the file smaller (presumably by auto-vacuum code). Do not write
4277 ** any such pages to the file.
4278 **
4279 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
4280 ** set (set by sqlite3PagerDontWrite()).
4281 */
4282 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
4283 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
4284 char *pData; /* Data to write */
4285
4286 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
4287 if( pList->pgno==1 ) pager_write_changecounter(pList);
4288
4289 /* Encode the database */
4290 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
4291
4292 /* Write out the page data. */
4293 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
4294
4295 /* If page 1 was just written, update Pager.dbFileVers to match
4296 ** the value now stored in the database file. If writing this
4297 ** page caused the database file to grow, update dbFileSize.
4298 */
4299 if( pgno==1 ){
4300 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
4301 }
4302 if( pgno>pPager->dbFileSize ){
4303 pPager->dbFileSize = pgno;
4304 }
4305 pPager->aStat[PAGER_STAT_WRITE]++;
4306
4307 /* Update any backup objects copying the contents of this pager. */
4308 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
4309
4310 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
4311 PAGERID(pPager), pgno, pager_pagehash(pList)));
4312 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
4313 PAGER_INCR(sqlite3_pager_writedb_count);
4314 }else{
4315 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
4316 }
4317 pager_set_pagehash(pList);
4318 pList = pList->pDirty;
4319 }
4320
4321 return rc;
4322 }
4323
4324 /*
4325 ** Ensure that the sub-journal file is open. If it is already open, this
4326 ** function is a no-op.
4327 **
4328 ** SQLITE_OK is returned if everything goes according to plan. An
4329 ** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
4330 ** fails.
4331 */
4332 static int openSubJournal(Pager *pPager){
4333 int rc = SQLITE_OK;
4334 if( !isOpen(pPager->sjfd) ){
4335 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
4336 sqlite3MemJournalOpen(pPager->sjfd);
4337 }else{
4338 rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
4339 }
4340 }
4341 return rc;
4342 }
4343
4344 /*
4345 ** Append a record of the current state of page pPg to the sub-journal.
4346 **
4347 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
4348 ** for all open savepoints before returning.
4349 **
4350 ** This function returns SQLITE_OK if everything is successful, an IO
4351 ** error code if the attempt to write to the sub-journal fails, or
4352 ** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
4353 ** bitvec.
4354 */
4355 static int subjournalPage(PgHdr *pPg){
4356 int rc = SQLITE_OK;
4357 Pager *pPager = pPg->pPager;
4358 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
4359
4360 /* Open the sub-journal, if it has not already been opened */
4361 assert( pPager->useJournal );
4362 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
4363 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
4364 assert( pagerUseWal(pPager)
4365 || pageInJournal(pPager, pPg)
4366 || pPg->pgno>pPager->dbOrigSize
4367 );
4368 rc = openSubJournal(pPager);
4369
4370 /* If the sub-journal was opened successfully (or was already open),
4371 ** write the journal record into the file. */
4372 if( rc==SQLITE_OK ){
4373 void *pData = pPg->pData;
4374 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
4375 char *pData2;
4376
4377 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
4378 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
4379 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
4380 if( rc==SQLITE_OK ){
4381 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
4382 }
4383 }
4384 }
4385 if( rc==SQLITE_OK ){
4386 pPager->nSubRec++;
4387 assert( pPager->nSavepoint>0 );
4388 rc = addToSavepointBitvecs(pPager, pPg->pgno);
4389 }
4390 return rc;
4391 }
4392 static int subjournalPageIfRequired(PgHdr *pPg){
4393 if( subjRequiresPage(pPg) ){
4394 return subjournalPage(pPg);
4395 }else{
4396 return SQLITE_OK;
4397 }
4398 }
4399
4400 /*
4401 ** This function is called by the pcache layer when it has reached some
4402 ** soft memory limit. The first argument is a pointer to a Pager object
4403 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
4404 ** database). The second argument is a reference to a page that is
4405 ** currently dirty but has no outstanding references. The page
4406 ** is always associated with the Pager object passed as the first
4407 ** argument.
4408 **
4409 ** The job of this function is to make pPg clean by writing its contents
4410 ** out to the database file, if possible. This may involve syncing the
4411 ** journal file.
4412 **
4413 ** If successful, sqlite3PcacheMakeClean() is called on the page and
4414 ** SQLITE_OK returned. If an IO error occurs while trying to make the
4415 ** page clean, the IO error code is returned. If the page cannot be
4416 ** made clean for some other reason, but no error occurs, then SQLITE_OK
4417 ** is returned by sqlite3PcacheMakeClean() is not called.
4418 */
4419 static int pagerStress(void *p, PgHdr *pPg){
4420 Pager *pPager = (Pager *)p;
4421 int rc = SQLITE_OK;
4422
4423 assert( pPg->pPager==pPager );
4424 assert( pPg->flags&PGHDR_DIRTY );
4425
4426 /* The doNotSpill NOSYNC bit is set during times when doing a sync of
4427 ** journal (and adding a new header) is not allowed. This occurs
4428 ** during calls to sqlite3PagerWrite() while trying to journal multiple
4429 ** pages belonging to the same sector.
4430 **
4431 ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
4432 ** regardless of whether or not a sync is required. This is set during
4433 ** a rollback or by user request, respectively.
4434 **
4435 ** Spilling is also prohibited when in an error state since that could
4436 ** lead to database corruption. In the current implementation it
4437 ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
4438 ** while in the error state, hence it is impossible for this routine to
4439 ** be called in the error state. Nevertheless, we include a NEVER()
4440 ** test for the error state as a safeguard against future changes.
4441 */
4442 if( NEVER(pPager->errCode) ) return SQLITE_OK;
4443 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
4444 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
4445 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
4446 if( pPager->doNotSpill
4447 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
4448 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
4449 ){
4450 return SQLITE_OK;
4451 }
4452
4453 pPg->pDirty = 0;
4454 if( pagerUseWal(pPager) ){
4455 /* Write a single frame for this page to the log. */
4456 rc = subjournalPageIfRequired(pPg);
4457 if( rc==SQLITE_OK ){
4458 rc = pagerWalFrames(pPager, pPg, 0, 0);
4459 }
4460 }else{
4461
4462 /* Sync the journal file if required. */
4463 if( pPg->flags&PGHDR_NEED_SYNC
4464 || pPager->eState==PAGER_WRITER_CACHEMOD
4465 ){
4466 rc = syncJournal(pPager, 1);
4467 }
4468
4469 /* Write the contents of the page out to the database file. */
4470 if( rc==SQLITE_OK ){
4471 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
4472 rc = pager_write_pagelist(pPager, pPg);
4473 }
4474 }
4475
4476 /* Mark the page as clean. */
4477 if( rc==SQLITE_OK ){
4478 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
4479 sqlite3PcacheMakeClean(pPg);
4480 }
4481
4482 return pager_error(pPager, rc);
4483 }
4484
4485 /*
4486 ** Flush all unreferenced dirty pages to disk.
4487 */
4488 int sqlite3PagerFlush(Pager *pPager){
4489 int rc = pPager->errCode;
4490 if( !MEMDB ){
4491 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
4492 assert( assert_pager_state(pPager) );
4493 while( rc==SQLITE_OK && pList ){
4494 PgHdr *pNext = pList->pDirty;
4495 if( pList->nRef==0 ){
4496 rc = pagerStress((void*)pPager, pList);
4497 }
4498 pList = pNext;
4499 }
4500 }
4501
4502 return rc;
4503 }
4504
4505 /*
4506 ** Allocate and initialize a new Pager object and put a pointer to it
4507 ** in *ppPager. The pager should eventually be freed by passing it
4508 ** to sqlite3PagerClose().
4509 **
4510 ** The zFilename argument is the path to the database file to open.
4511 ** If zFilename is NULL then a randomly-named temporary file is created
4512 ** and used as the file to be cached. Temporary files are be deleted
4513 ** automatically when they are closed. If zFilename is ":memory:" then
4514 ** all information is held in cache. It is never written to disk.
4515 ** This can be used to implement an in-memory database.
4516 **
4517 ** The nExtra parameter specifies the number of bytes of space allocated
4518 ** along with each page reference. This space is available to the user
4519 ** via the sqlite3PagerGetExtra() API.
4520 **
4521 ** The flags argument is used to specify properties that affect the
4522 ** operation of the pager. It should be passed some bitwise combination
4523 ** of the PAGER_* flags.
4524 **
4525 ** The vfsFlags parameter is a bitmask to pass to the flags parameter
4526 ** of the xOpen() method of the supplied VFS when opening files.
4527 **
4528 ** If the pager object is allocated and the specified file opened
4529 ** successfully, SQLITE_OK is returned and *ppPager set to point to
4530 ** the new pager object. If an error occurs, *ppPager is set to NULL
4531 ** and error code returned. This function may return SQLITE_NOMEM
4532 ** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
4533 ** various SQLITE_IO_XXX errors.
4534 */
4535 int sqlite3PagerOpen(
4536 sqlite3_vfs *pVfs, /* The virtual file system to use */
4537 Pager **ppPager, /* OUT: Return the Pager structure here */
4538 const char *zFilename, /* Name of the database file to open */
4539 int nExtra, /* Extra bytes append to each in-memory page */
4540 int flags, /* flags controlling this file */
4541 int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */
4542 void (*xReinit)(DbPage*) /* Function to reinitialize pages */
4543 ){
4544 u8 *pPtr;
4545 Pager *pPager = 0; /* Pager object to allocate and return */
4546 int rc = SQLITE_OK; /* Return code */
4547 int tempFile = 0; /* True for temp files (incl. in-memory files) */
4548 int memDb = 0; /* True if this is an in-memory file */
4549 int readOnly = 0; /* True if this is a read-only file */
4550 int journalFileSize; /* Bytes to allocate for each journal fd */
4551 char *zPathname = 0; /* Full path to database file */
4552 int nPathname = 0; /* Number of bytes in zPathname */
4553 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
4554 int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */
4555 u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
4556 const char *zUri = 0; /* URI args to copy */
4557 int nUri = 0; /* Number of bytes of URI args at *zUri */
4558
4559 /* Figure out how much space is required for each journal file-handle
4560 ** (there are two of them, the main journal and the sub-journal). This
4561 ** is the maximum space required for an in-memory journal file handle
4562 ** and a regular journal file-handle. Note that a "regular journal-handle"
4563 ** may be a wrapper capable of caching the first portion of the journal
4564 ** file in memory to implement the atomic-write optimization (see
4565 ** source file journal.c).
4566 */
4567 if( sqlite3JournalSize(pVfs)>sqlite3MemJournalSize() ){
4568 journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
4569 }else{
4570 journalFileSize = ROUND8(sqlite3MemJournalSize());
4571 }
4572
4573 /* Set the output variable to NULL in case an error occurs. */
4574 *ppPager = 0;
4575
4576 #ifndef SQLITE_OMIT_MEMORYDB
4577 if( flags & PAGER_MEMORY ){
4578 memDb = 1;
4579 if( zFilename && zFilename[0] ){
4580 zPathname = sqlite3DbStrDup(0, zFilename);
4581 if( zPathname==0 ) return SQLITE_NOMEM;
4582 nPathname = sqlite3Strlen30(zPathname);
4583 zFilename = 0;
4584 }
4585 }
4586 #endif
4587
4588 /* Compute and store the full pathname in an allocated buffer pointed
4589 ** to by zPathname, length nPathname. Or, if this is a temporary file,
4590 ** leave both nPathname and zPathname set to 0.
4591 */
4592 if( zFilename && zFilename[0] ){
4593 const char *z;
4594 nPathname = pVfs->mxPathname+1;
4595 zPathname = sqlite3DbMallocRaw(0, nPathname*2);
4596 if( zPathname==0 ){
4597 return SQLITE_NOMEM;
4598 }
4599 zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
4600 rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
4601 nPathname = sqlite3Strlen30(zPathname);
4602 z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
4603 while( *z ){
4604 z += sqlite3Strlen30(z)+1;
4605 z += sqlite3Strlen30(z)+1;
4606 }
4607 nUri = (int)(&z[1] - zUri);
4608 assert( nUri>=0 );
4609 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
4610 /* This branch is taken when the journal path required by
4611 ** the database being opened will be more than pVfs->mxPathname
4612 ** bytes in length. This means the database cannot be opened,
4613 ** as it will not be possible to open the journal file or even
4614 ** check for a hot-journal before reading.
4615 */
4616 rc = SQLITE_CANTOPEN_BKPT;
4617 }
4618 if( rc!=SQLITE_OK ){
4619 sqlite3DbFree(0, zPathname);
4620 return rc;
4621 }
4622 }
4623
4624 /* Allocate memory for the Pager structure, PCache object, the
4625 ** three file descriptors, the database file name and the journal
4626 ** file name. The layout in memory is as follows:
4627 **
4628 ** Pager object (sizeof(Pager) bytes)
4629 ** PCache object (sqlite3PcacheSize() bytes)
4630 ** Database file handle (pVfs->szOsFile bytes)
4631 ** Sub-journal file handle (journalFileSize bytes)
4632 ** Main journal file handle (journalFileSize bytes)
4633 ** Database file name (nPathname+1 bytes)
4634 ** Journal file name (nPathname+8+1 bytes)
4635 */
4636 pPtr = (u8 *)sqlite3MallocZero(
4637 ROUND8(sizeof(*pPager)) + /* Pager structure */
4638 ROUND8(pcacheSize) + /* PCache object */
4639 ROUND8(pVfs->szOsFile) + /* The main db file */
4640 journalFileSize * 2 + /* The two journal files */
4641 nPathname + 1 + nUri + /* zFilename */
4642 nPathname + 8 + 2 /* zJournal */
4643 #ifndef SQLITE_OMIT_WAL
4644 + nPathname + 4 + 2 /* zWal */
4645 #endif
4646 );
4647 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
4648 if( !pPtr ){
4649 sqlite3DbFree(0, zPathname);
4650 return SQLITE_NOMEM;
4651 }
4652 pPager = (Pager*)(pPtr);
4653 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
4654 pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
4655 pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
4656 pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
4657 pPager->zFilename = (char*)(pPtr += journalFileSize);
4658 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
4659
4660 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
4661 if( zPathname ){
4662 assert( nPathname>0 );
4663 pPager->zJournal = (char*)(pPtr += nPathname + 1 + nUri);
4664 memcpy(pPager->zFilename, zPathname, nPathname);
4665 if( nUri ) memcpy(&pPager->zFilename[nPathname+1], zUri, nUri);
4666 memcpy(pPager->zJournal, zPathname, nPathname);
4667 memcpy(&pPager->zJournal[nPathname], "-journal\000", 8+2);
4668 sqlite3FileSuffix3(pPager->zFilename, pPager->zJournal);
4669 #ifndef SQLITE_OMIT_WAL
4670 pPager->zWal = &pPager->zJournal[nPathname+8+1];
4671 memcpy(pPager->zWal, zPathname, nPathname);
4672 memcpy(&pPager->zWal[nPathname], "-wal\000", 4+1);
4673 sqlite3FileSuffix3(pPager->zFilename, pPager->zWal);
4674 #endif
4675 sqlite3DbFree(0, zPathname);
4676 }
4677 pPager->pVfs = pVfs;
4678 pPager->vfsFlags = vfsFlags;
4679
4680 /* Open the pager file.
4681 */
4682 if( zFilename && zFilename[0] ){
4683 int fout = 0; /* VFS flags returned by xOpen() */
4684 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
4685 assert( !memDb );
4686 readOnly = (fout&SQLITE_OPEN_READONLY);
4687
4688 /* If the file was successfully opened for read/write access,
4689 ** choose a default page size in case we have to create the
4690 ** database file. The default page size is the maximum of:
4691 **
4692 ** + SQLITE_DEFAULT_PAGE_SIZE,
4693 ** + The value returned by sqlite3OsSectorSize()
4694 ** + The largest page size that can be written atomically.
4695 */
4696 if( rc==SQLITE_OK ){
4697 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
4698 if( !readOnly ){
4699 setSectorSize(pPager);
4700 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
4701 if( szPageDflt<pPager->sectorSize ){
4702 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
4703 szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
4704 }else{
4705 szPageDflt = (u32)pPager->sectorSize;
4706 }
4707 }
4708 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
4709 {
4710 int ii;
4711 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
4712 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
4713 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
4714 for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
4715 if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
4716 szPageDflt = ii;
4717 }
4718 }
4719 }
4720 #endif
4721 }
4722 pPager->noLock = sqlite3_uri_boolean(zFilename, "nolock", 0);
4723 if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0
4724 || sqlite3_uri_boolean(zFilename, "immutable", 0) ){
4725 vfsFlags |= SQLITE_OPEN_READONLY;
4726 goto act_like_temp_file;
4727 }
4728 }
4729 }else{
4730 /* If a temporary file is requested, it is not opened immediately.
4731 ** In this case we accept the default page size and delay actually
4732 ** opening the file until the first call to OsWrite().
4733 **
4734 ** This branch is also run for an in-memory database. An in-memory
4735 ** database is the same as a temp-file that is never written out to
4736 ** disk and uses an in-memory rollback journal.
4737 **
4738 ** This branch also runs for files marked as immutable.
4739 */
4740 act_like_temp_file:
4741 tempFile = 1;
4742 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
4743 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
4744 pPager->noLock = 1; /* Do no locking */
4745 readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
4746 }
4747
4748 /* The following call to PagerSetPagesize() serves to set the value of
4749 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
4750 */
4751 if( rc==SQLITE_OK ){
4752 assert( pPager->memDb==0 );
4753 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
4754 testcase( rc!=SQLITE_OK );
4755 }
4756
4757 /* Initialize the PCache object. */
4758 if( rc==SQLITE_OK ){
4759 assert( nExtra<1000 );
4760 nExtra = ROUND8(nExtra);
4761 rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb,
4762 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
4763 }
4764
4765 /* If an error occurred above, free the Pager structure and close the file.
4766 */
4767 if( rc!=SQLITE_OK ){
4768 sqlite3OsClose(pPager->fd);
4769 sqlite3PageFree(pPager->pTmpSpace);
4770 sqlite3_free(pPager);
4771 return rc;
4772 }
4773
4774 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
4775 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
4776
4777 pPager->useJournal = (u8)useJournal;
4778 /* pPager->stmtOpen = 0; */
4779 /* pPager->stmtInUse = 0; */
4780 /* pPager->nRef = 0; */
4781 /* pPager->stmtSize = 0; */
4782 /* pPager->stmtJSize = 0; */
4783 /* pPager->nPage = 0; */
4784 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
4785 /* pPager->state = PAGER_UNLOCK; */
4786 /* pPager->errMask = 0; */
4787 pPager->tempFile = (u8)tempFile;
4788 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
4789 || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
4790 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
4791 pPager->exclusiveMode = (u8)tempFile;
4792 pPager->changeCountDone = pPager->tempFile;
4793 pPager->memDb = (u8)memDb;
4794 pPager->readOnly = (u8)readOnly;
4795 assert( useJournal || pPager->tempFile );
4796 pPager->noSync = pPager->tempFile;
4797 if( pPager->noSync ){
4798 assert( pPager->fullSync==0 );
4799 assert( pPager->syncFlags==0 );
4800 assert( pPager->walSyncFlags==0 );
4801 assert( pPager->ckptSyncFlags==0 );
4802 }else{
4803 pPager->fullSync = 1;
4804 pPager->syncFlags = SQLITE_SYNC_NORMAL;
4805 pPager->walSyncFlags = SQLITE_SYNC_NORMAL | WAL_SYNC_TRANSACTIONS;
4806 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
4807 }
4808 /* pPager->pFirst = 0; */
4809 /* pPager->pFirstSynced = 0; */
4810 /* pPager->pLast = 0; */
4811 pPager->nExtra = (u16)nExtra;
4812 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
4813 assert( isOpen(pPager->fd) || tempFile );
4814 setSectorSize(pPager);
4815 if( !useJournal ){
4816 pPager->journalMode = PAGER_JOURNALMODE_OFF;
4817 }else if( memDb ){
4818 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
4819 }
4820 /* pPager->xBusyHandler = 0; */
4821 /* pPager->pBusyHandlerArg = 0; */
4822 pPager->xReiniter = xReinit;
4823 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
4824 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
4825
4826 *ppPager = pPager;
4827 return SQLITE_OK;
4828 }
4829
4830
4831 /* Verify that the database file has not be deleted or renamed out from
4832 ** under the pager. Return SQLITE_OK if the database is still were it ought
4833 ** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
4834 ** code from sqlite3OsAccess()) if the database has gone missing.
4835 */
4836 static int databaseIsUnmoved(Pager *pPager){
4837 int bHasMoved = 0;
4838 int rc;
4839
4840 if( pPager->tempFile ) return SQLITE_OK;
4841 if( pPager->dbSize==0 ) return SQLITE_OK;
4842 assert( pPager->zFilename && pPager->zFilename[0] );
4843 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
4844 if( rc==SQLITE_NOTFOUND ){
4845 /* If the HAS_MOVED file-control is unimplemented, assume that the file
4846 ** has not been moved. That is the historical behavior of SQLite: prior to
4847 ** version 3.8.3, it never checked */
4848 rc = SQLITE_OK;
4849 }else if( rc==SQLITE_OK && bHasMoved ){
4850 rc = SQLITE_READONLY_DBMOVED;
4851 }
4852 return rc;
4853 }
4854
4855
4856 /*
4857 ** This function is called after transitioning from PAGER_UNLOCK to
4858 ** PAGER_SHARED state. It tests if there is a hot journal present in
4859 ** the file-system for the given pager. A hot journal is one that
4860 ** needs to be played back. According to this function, a hot-journal
4861 ** file exists if the following criteria are met:
4862 **
4863 ** * The journal file exists in the file system, and
4864 ** * No process holds a RESERVED or greater lock on the database file, and
4865 ** * The database file itself is greater than 0 bytes in size, and
4866 ** * The first byte of the journal file exists and is not 0x00.
4867 **
4868 ** If the current size of the database file is 0 but a journal file
4869 ** exists, that is probably an old journal left over from a prior
4870 ** database with the same name. In this case the journal file is
4871 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
4872 ** is returned.
4873 **
4874 ** This routine does not check if there is a master journal filename
4875 ** at the end of the file. If there is, and that master journal file
4876 ** does not exist, then the journal file is not really hot. In this
4877 ** case this routine will return a false-positive. The pager_playback()
4878 ** routine will discover that the journal file is not really hot and
4879 ** will not roll it back.
4880 **
4881 ** If a hot-journal file is found to exist, *pExists is set to 1 and
4882 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
4883 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
4884 ** to determine whether or not a hot-journal file exists, the IO error
4885 ** code is returned and the value of *pExists is undefined.
4886 */
4887 static int hasHotJournal(Pager *pPager, int *pExists){
4888 sqlite3_vfs * const pVfs = pPager->pVfs;
4889 int rc = SQLITE_OK; /* Return code */
4890 int exists = 1; /* True if a journal file is present */
4891 int jrnlOpen = !!isOpen(pPager->jfd);
4892
4893 assert( pPager->useJournal );
4894 assert( isOpen(pPager->fd) );
4895 assert( pPager->eState==PAGER_OPEN );
4896
4897 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
4898 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
4899 ));
4900
4901 *pExists = 0;
4902 if( !jrnlOpen ){
4903 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
4904 }
4905 if( rc==SQLITE_OK && exists ){
4906 int locked = 0; /* True if some process holds a RESERVED lock */
4907
4908 /* Race condition here: Another process might have been holding the
4909 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
4910 ** call above, but then delete the journal and drop the lock before
4911 ** we get to the following sqlite3OsCheckReservedLock() call. If that
4912 ** is the case, this routine might think there is a hot journal when
4913 ** in fact there is none. This results in a false-positive which will
4914 ** be dealt with by the playback routine. Ticket #3883.
4915 */
4916 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
4917 if( rc==SQLITE_OK && !locked ){
4918 Pgno nPage; /* Number of pages in database file */
4919
4920 rc = pagerPagecount(pPager, &nPage);
4921 if( rc==SQLITE_OK ){
4922 /* If the database is zero pages in size, that means that either (1) the
4923 ** journal is a remnant from a prior database with the same name where
4924 ** the database file but not the journal was deleted, or (2) the initial
4925 ** transaction that populates a new database is being rolled back.
4926 ** In either case, the journal file can be deleted. However, take care
4927 ** not to delete the journal file if it is already open due to
4928 ** journal_mode=PERSIST.
4929 */
4930 if( nPage==0 && !jrnlOpen ){
4931 sqlite3BeginBenignMalloc();
4932 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
4933 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
4934 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
4935 }
4936 sqlite3EndBenignMalloc();
4937 }else{
4938 /* The journal file exists and no other connection has a reserved
4939 ** or greater lock on the database file. Now check that there is
4940 ** at least one non-zero bytes at the start of the journal file.
4941 ** If there is, then we consider this journal to be hot. If not,
4942 ** it can be ignored.
4943 */
4944 if( !jrnlOpen ){
4945 int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
4946 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
4947 }
4948 if( rc==SQLITE_OK ){
4949 u8 first = 0;
4950 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
4951 if( rc==SQLITE_IOERR_SHORT_READ ){
4952 rc = SQLITE_OK;
4953 }
4954 if( !jrnlOpen ){
4955 sqlite3OsClose(pPager->jfd);
4956 }
4957 *pExists = (first!=0);
4958 }else if( rc==SQLITE_CANTOPEN ){
4959 /* If we cannot open the rollback journal file in order to see if
4960 ** it has a zero header, that might be due to an I/O error, or
4961 ** it might be due to the race condition described above and in
4962 ** ticket #3883. Either way, assume that the journal is hot.
4963 ** This might be a false positive. But if it is, then the
4964 ** automatic journal playback and recovery mechanism will deal
4965 ** with it under an EXCLUSIVE lock where we do not need to
4966 ** worry so much with race conditions.
4967 */
4968 *pExists = 1;
4969 rc = SQLITE_OK;
4970 }
4971 }
4972 }
4973 }
4974 }
4975
4976 return rc;
4977 }
4978
4979 /*
4980 ** This function is called to obtain a shared lock on the database file.
4981 ** It is illegal to call sqlite3PagerGet() until after this function
4982 ** has been successfully called. If a shared-lock is already held when
4983 ** this function is called, it is a no-op.
4984 **
4985 ** The following operations are also performed by this function.
4986 **
4987 ** 1) If the pager is currently in PAGER_OPEN state (no lock held
4988 ** on the database file), then an attempt is made to obtain a
4989 ** SHARED lock on the database file. Immediately after obtaining
4990 ** the SHARED lock, the file-system is checked for a hot-journal,
4991 ** which is played back if present. Following any hot-journal
4992 ** rollback, the contents of the cache are validated by checking
4993 ** the 'change-counter' field of the database file header and
4994 ** discarded if they are found to be invalid.
4995 **
4996 ** 2) If the pager is running in exclusive-mode, and there are currently
4997 ** no outstanding references to any pages, and is in the error state,
4998 ** then an attempt is made to clear the error state by discarding
4999 ** the contents of the page cache and rolling back any open journal
5000 ** file.
5001 **
5002 ** If everything is successful, SQLITE_OK is returned. If an IO error
5003 ** occurs while locking the database, checking for a hot-journal file or
5004 ** rolling back a journal file, the IO error code is returned.
5005 */
5006 int sqlite3PagerSharedLock(Pager *pPager){
5007 int rc = SQLITE_OK; /* Return code */
5008
5009 /* This routine is only called from b-tree and only when there are no
5010 ** outstanding pages. This implies that the pager state should either
5011 ** be OPEN or READER. READER is only possible if the pager is or was in
5012 ** exclusive access mode.
5013 */
5014 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
5015 assert( assert_pager_state(pPager) );
5016 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
5017 if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
5018
5019 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
5020 int bHotJournal = 1; /* True if there exists a hot journal-file */
5021
5022 assert( !MEMDB );
5023
5024 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
5025 if( rc!=SQLITE_OK ){
5026 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
5027 goto failed;
5028 }
5029
5030 /* If a journal file exists, and there is no RESERVED lock on the
5031 ** database file, then it either needs to be played back or deleted.
5032 */
5033 if( pPager->eLock<=SHARED_LOCK ){
5034 rc = hasHotJournal(pPager, &bHotJournal);
5035 }
5036 if( rc!=SQLITE_OK ){
5037 goto failed;
5038 }
5039 if( bHotJournal ){
5040 if( pPager->readOnly ){
5041 rc = SQLITE_READONLY_ROLLBACK;
5042 goto failed;
5043 }
5044
5045 /* Get an EXCLUSIVE lock on the database file. At this point it is
5046 ** important that a RESERVED lock is not obtained on the way to the
5047 ** EXCLUSIVE lock. If it were, another process might open the
5048 ** database file, detect the RESERVED lock, and conclude that the
5049 ** database is safe to read while this process is still rolling the
5050 ** hot-journal back.
5051 **
5052 ** Because the intermediate RESERVED lock is not requested, any
5053 ** other process attempting to access the database file will get to
5054 ** this point in the code and fail to obtain its own EXCLUSIVE lock
5055 ** on the database file.
5056 **
5057 ** Unless the pager is in locking_mode=exclusive mode, the lock is
5058 ** downgraded to SHARED_LOCK before this function returns.
5059 */
5060 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
5061 if( rc!=SQLITE_OK ){
5062 goto failed;
5063 }
5064
5065 /* If it is not already open and the file exists on disk, open the
5066 ** journal for read/write access. Write access is required because
5067 ** in exclusive-access mode the file descriptor will be kept open
5068 ** and possibly used for a transaction later on. Also, write-access
5069 ** is usually required to finalize the journal in journal_mode=persist
5070 ** mode (and also for journal_mode=truncate on some systems).
5071 **
5072 ** If the journal does not exist, it usually means that some
5073 ** other connection managed to get in and roll it back before
5074 ** this connection obtained the exclusive lock above. Or, it
5075 ** may mean that the pager was in the error-state when this
5076 ** function was called and the journal file does not exist.
5077 */
5078 if( !isOpen(pPager->jfd) ){
5079 sqlite3_vfs * const pVfs = pPager->pVfs;
5080 int bExists; /* True if journal file exists */
5081 rc = sqlite3OsAccess(
5082 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
5083 if( rc==SQLITE_OK && bExists ){
5084 int fout = 0;
5085 int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
5086 assert( !pPager->tempFile );
5087 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
5088 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
5089 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
5090 rc = SQLITE_CANTOPEN_BKPT;
5091 sqlite3OsClose(pPager->jfd);
5092 }
5093 }
5094 }
5095
5096 /* Playback and delete the journal. Drop the database write
5097 ** lock and reacquire the read lock. Purge the cache before
5098 ** playing back the hot-journal so that we don't end up with
5099 ** an inconsistent cache. Sync the hot journal before playing
5100 ** it back since the process that crashed and left the hot journal
5101 ** probably did not sync it and we are required to always sync
5102 ** the journal before playing it back.
5103 */
5104 if( isOpen(pPager->jfd) ){
5105 assert( rc==SQLITE_OK );
5106 rc = pagerSyncHotJournal(pPager);
5107 if( rc==SQLITE_OK ){
5108 rc = pager_playback(pPager, 1);
5109 pPager->eState = PAGER_OPEN;
5110 }
5111 }else if( !pPager->exclusiveMode ){
5112 pagerUnlockDb(pPager, SHARED_LOCK);
5113 }
5114
5115 if( rc!=SQLITE_OK ){
5116 /* This branch is taken if an error occurs while trying to open
5117 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
5118 ** pager_unlock() routine will be called before returning to unlock
5119 ** the file. If the unlock attempt fails, then Pager.eLock must be
5120 ** set to UNKNOWN_LOCK (see the comment above the #define for
5121 ** UNKNOWN_LOCK above for an explanation).
5122 **
5123 ** In order to get pager_unlock() to do this, set Pager.eState to
5124 ** PAGER_ERROR now. This is not actually counted as a transition
5125 ** to ERROR state in the state diagram at the top of this file,
5126 ** since we know that the same call to pager_unlock() will very
5127 ** shortly transition the pager object to the OPEN state. Calling
5128 ** assert_pager_state() would fail now, as it should not be possible
5129 ** to be in ERROR state when there are zero outstanding page
5130 ** references.
5131 */
5132 pager_error(pPager, rc);
5133 goto failed;
5134 }
5135
5136 assert( pPager->eState==PAGER_OPEN );
5137 assert( (pPager->eLock==SHARED_LOCK)
5138 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
5139 );
5140 }
5141
5142 if( !pPager->tempFile && pPager->hasHeldSharedLock ){
5143 /* The shared-lock has just been acquired then check to
5144 ** see if the database has been modified. If the database has changed,
5145 ** flush the cache. The hasHeldSharedLock flag prevents this from
5146 ** occurring on the very first access to a file, in order to save a
5147 ** single unnecessary sqlite3OsRead() call at the start-up.
5148 **
5149 ** Database changes are detected by looking at 15 bytes beginning
5150 ** at offset 24 into the file. The first 4 of these 16 bytes are
5151 ** a 32-bit counter that is incremented with each change. The
5152 ** other bytes change randomly with each file change when
5153 ** a codec is in use.
5154 **
5155 ** There is a vanishingly small chance that a change will not be
5156 ** detected. The chance of an undetected change is so small that
5157 ** it can be neglected.
5158 */
5159 Pgno nPage = 0;
5160 char dbFileVers[sizeof(pPager->dbFileVers)];
5161
5162 rc = pagerPagecount(pPager, &nPage);
5163 if( rc ) goto failed;
5164
5165 if( nPage>0 ){
5166 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
5167 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
5168 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
5169 goto failed;
5170 }
5171 }else{
5172 memset(dbFileVers, 0, sizeof(dbFileVers));
5173 }
5174
5175 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
5176 pager_reset(pPager);
5177
5178 /* Unmap the database file. It is possible that external processes
5179 ** may have truncated the database file and then extended it back
5180 ** to its original size while this process was not holding a lock.
5181 ** In this case there may exist a Pager.pMap mapping that appears
5182 ** to be the right size but is not actually valid. Avoid this
5183 ** possibility by unmapping the db here. */
5184 if( USEFETCH(pPager) ){
5185 sqlite3OsUnfetch(pPager->fd, 0, 0);
5186 }
5187 }
5188 }
5189
5190 /* If there is a WAL file in the file-system, open this database in WAL
5191 ** mode. Otherwise, the following function call is a no-op.
5192 */
5193 rc = pagerOpenWalIfPresent(pPager);
5194 #ifndef SQLITE_OMIT_WAL
5195 assert( pPager->pWal==0 || rc==SQLITE_OK );
5196 #endif
5197 }
5198
5199 if( pagerUseWal(pPager) ){
5200 assert( rc==SQLITE_OK );
5201 rc = pagerBeginReadTransaction(pPager);
5202 }
5203
5204 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
5205 rc = pagerPagecount(pPager, &pPager->dbSize);
5206 }
5207
5208 failed:
5209 if( rc!=SQLITE_OK ){
5210 assert( !MEMDB );
5211 pager_unlock(pPager);
5212 assert( pPager->eState==PAGER_OPEN );
5213 }else{
5214 pPager->eState = PAGER_READER;
5215 pPager->hasHeldSharedLock = 1;
5216 }
5217 return rc;
5218 }
5219
5220 /*
5221 ** If the reference count has reached zero, rollback any active
5222 ** transaction and unlock the pager.
5223 **
5224 ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
5225 ** the rollback journal, the unlock is not performed and there is
5226 ** nothing to rollback, so this routine is a no-op.
5227 */
5228 static void pagerUnlockIfUnused(Pager *pPager){
5229 if( pPager->nMmapOut==0 && (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
5230 pagerUnlockAndRollback(pPager);
5231 }
5232 }
5233
5234 /*
5235 ** Acquire a reference to page number pgno in pager pPager (a page
5236 ** reference has type DbPage*). If the requested reference is
5237 ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
5238 **
5239 ** If the requested page is already in the cache, it is returned.
5240 ** Otherwise, a new page object is allocated and populated with data
5241 ** read from the database file. In some cases, the pcache module may
5242 ** choose not to allocate a new page object and may reuse an existing
5243 ** object with no outstanding references.
5244 **
5245 ** The extra data appended to a page is always initialized to zeros the
5246 ** first time a page is loaded into memory. If the page requested is
5247 ** already in the cache when this function is called, then the extra
5248 ** data is left as it was when the page object was last used.
5249 **
5250 ** If the database image is smaller than the requested page or if a
5251 ** non-zero value is passed as the noContent parameter and the
5252 ** requested page is not already stored in the cache, then no
5253 ** actual disk read occurs. In this case the memory image of the
5254 ** page is initialized to all zeros.
5255 **
5256 ** If noContent is true, it means that we do not care about the contents
5257 ** of the page. This occurs in two scenarios:
5258 **
5259 ** a) When reading a free-list leaf page from the database, and
5260 **
5261 ** b) When a savepoint is being rolled back and we need to load
5262 ** a new page into the cache to be filled with the data read
5263 ** from the savepoint journal.
5264 **
5265 ** If noContent is true, then the data returned is zeroed instead of
5266 ** being read from the database. Additionally, the bits corresponding
5267 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
5268 ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
5269 ** savepoints are set. This means if the page is made writable at any
5270 ** point in the future, using a call to sqlite3PagerWrite(), its contents
5271 ** will not be journaled. This saves IO.
5272 **
5273 ** The acquisition might fail for several reasons. In all cases,
5274 ** an appropriate error code is returned and *ppPage is set to NULL.
5275 **
5276 ** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
5277 ** to find a page in the in-memory cache first. If the page is not already
5278 ** in memory, this routine goes to disk to read it in whereas Lookup()
5279 ** just returns 0. This routine acquires a read-lock the first time it
5280 ** has to go to disk, and could also playback an old journal if necessary.
5281 ** Since Lookup() never goes to disk, it never has to deal with locks
5282 ** or journal files.
5283 */
5284 int sqlite3PagerGet(
5285 Pager *pPager, /* The pager open on the database file */
5286 Pgno pgno, /* Page number to fetch */
5287 DbPage **ppPage, /* Write a pointer to the page here */
5288 int flags /* PAGER_GET_XXX flags */
5289 ){
5290 int rc = SQLITE_OK;
5291 PgHdr *pPg = 0;
5292 u32 iFrame = 0; /* Frame to read from WAL file */
5293 const int noContent = (flags & PAGER_GET_NOCONTENT);
5294
5295 /* It is acceptable to use a read-only (mmap) page for any page except
5296 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
5297 ** flag was specified by the caller. And so long as the db is not a
5298 ** temporary or in-memory database. */
5299 const int bMmapOk = (pgno>1 && USEFETCH(pPager)
5300 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
5301 #ifdef SQLITE_HAS_CODEC
5302 && pPager->xCodec==0
5303 #endif
5304 );
5305
5306 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
5307 ** allows the compiler optimizer to reuse the results of the "pgno>1"
5308 ** test in the previous statement, and avoid testing pgno==0 in the
5309 ** common case where pgno is large. */
5310 if( pgno<=1 && pgno==0 ){
5311 return SQLITE_CORRUPT_BKPT;
5312 }
5313 assert( pPager->eState>=PAGER_READER );
5314 assert( assert_pager_state(pPager) );
5315 assert( noContent==0 || bMmapOk==0 );
5316
5317 assert( pPager->hasHeldSharedLock==1 );
5318
5319 /* If the pager is in the error state, return an error immediately.
5320 ** Otherwise, request the page from the PCache layer. */
5321 if( pPager->errCode!=SQLITE_OK ){
5322 rc = pPager->errCode;
5323 }else{
5324 if( bMmapOk && pagerUseWal(pPager) ){
5325 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
5326 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5327 }
5328
5329 if( bMmapOk && iFrame==0 ){
5330 void *pData = 0;
5331
5332 rc = sqlite3OsFetch(pPager->fd,
5333 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
5334 );
5335
5336 if( rc==SQLITE_OK && pData ){
5337 if( pPager->eState>PAGER_READER ){
5338 pPg = sqlite3PagerLookup(pPager, pgno);
5339 }
5340 if( pPg==0 ){
5341 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
5342 }else{
5343 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
5344 }
5345 if( pPg ){
5346 assert( rc==SQLITE_OK );
5347 *ppPage = pPg;
5348 return SQLITE_OK;
5349 }
5350 }
5351 if( rc!=SQLITE_OK ){
5352 goto pager_acquire_err;
5353 }
5354 }
5355
5356 {
5357 sqlite3_pcache_page *pBase;
5358 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
5359 if( pBase==0 ){
5360 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
5361 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5362 if( pBase==0 ){
5363 pPg = *ppPage = 0;
5364 rc = SQLITE_NOMEM;
5365 goto pager_acquire_err;
5366 }
5367 }
5368 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
5369 assert( pPg!=0 );
5370 }
5371 }
5372
5373 if( rc!=SQLITE_OK ){
5374 /* Either the call to sqlite3PcacheFetch() returned an error or the
5375 ** pager was already in the error-state when this function was called.
5376 ** Set pPg to 0 and jump to the exception handler. */
5377 pPg = 0;
5378 goto pager_acquire_err;
5379 }
5380 assert( pPg==(*ppPage) );
5381 assert( pPg->pgno==pgno );
5382 assert( pPg->pPager==pPager || pPg->pPager==0 );
5383
5384 if( pPg->pPager && !noContent ){
5385 /* In this case the pcache already contains an initialized copy of
5386 ** the page. Return without further ado. */
5387 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
5388 pPager->aStat[PAGER_STAT_HIT]++;
5389 return SQLITE_OK;
5390
5391 }else{
5392 /* The pager cache has created a new page. Its content needs to
5393 ** be initialized. */
5394
5395 pPg->pPager = pPager;
5396
5397 /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
5398 ** number greater than this, or the unused locking-page, is requested. */
5399 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
5400 rc = SQLITE_CORRUPT_BKPT;
5401 goto pager_acquire_err;
5402 }
5403
5404 if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
5405 if( pgno>pPager->mxPgno ){
5406 rc = SQLITE_FULL;
5407 goto pager_acquire_err;
5408 }
5409 if( noContent ){
5410 /* Failure to set the bits in the InJournal bit-vectors is benign.
5411 ** It merely means that we might do some extra work to journal a
5412 ** page that does not need to be journaled. Nevertheless, be sure
5413 ** to test the case where a malloc error occurs while trying to set
5414 ** a bit in a bit vector.
5415 */
5416 sqlite3BeginBenignMalloc();
5417 if( pgno<=pPager->dbOrigSize ){
5418 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
5419 testcase( rc==SQLITE_NOMEM );
5420 }
5421 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
5422 testcase( rc==SQLITE_NOMEM );
5423 sqlite3EndBenignMalloc();
5424 }
5425 memset(pPg->pData, 0, pPager->pageSize);
5426 IOTRACE(("ZERO %p %d\n", pPager, pgno));
5427 }else{
5428 if( pagerUseWal(pPager) && bMmapOk==0 ){
5429 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
5430 if( rc!=SQLITE_OK ) goto pager_acquire_err;
5431 }
5432 assert( pPg->pPager==pPager );
5433 pPager->aStat[PAGER_STAT_MISS]++;
5434 rc = readDbPage(pPg, iFrame);
5435 if( rc!=SQLITE_OK ){
5436 goto pager_acquire_err;
5437 }
5438 }
5439 pager_set_pagehash(pPg);
5440 }
5441
5442 return SQLITE_OK;
5443
5444 pager_acquire_err:
5445 assert( rc!=SQLITE_OK );
5446 if( pPg ){
5447 sqlite3PcacheDrop(pPg);
5448 }
5449 pagerUnlockIfUnused(pPager);
5450
5451 *ppPage = 0;
5452 return rc;
5453 }
5454
5455 /*
5456 ** Acquire a page if it is already in the in-memory cache. Do
5457 ** not read the page from disk. Return a pointer to the page,
5458 ** or 0 if the page is not in cache.
5459 **
5460 ** See also sqlite3PagerGet(). The difference between this routine
5461 ** and sqlite3PagerGet() is that _get() will go to the disk and read
5462 ** in the page if the page is not already in cache. This routine
5463 ** returns NULL if the page is not in cache or if a disk I/O error
5464 ** has ever happened.
5465 */
5466 DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
5467 sqlite3_pcache_page *pPage;
5468 assert( pPager!=0 );
5469 assert( pgno!=0 );
5470 assert( pPager->pPCache!=0 );
5471 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
5472 assert( pPage==0 || pPager->hasHeldSharedLock );
5473 if( pPage==0 ) return 0;
5474 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
5475 }
5476
5477 /*
5478 ** Release a page reference.
5479 **
5480 ** If the number of references to the page drop to zero, then the
5481 ** page is added to the LRU list. When all references to all pages
5482 ** are released, a rollback occurs and the lock on the database is
5483 ** removed.
5484 */
5485 void sqlite3PagerUnrefNotNull(DbPage *pPg){
5486 Pager *pPager;
5487 assert( pPg!=0 );
5488 pPager = pPg->pPager;
5489 if( pPg->flags & PGHDR_MMAP ){
5490 pagerReleaseMapPage(pPg);
5491 }else{
5492 sqlite3PcacheRelease(pPg);
5493 }
5494 pagerUnlockIfUnused(pPager);
5495 }
5496 void sqlite3PagerUnref(DbPage *pPg){
5497 if( pPg ) sqlite3PagerUnrefNotNull(pPg);
5498 }
5499
5500 /*
5501 ** This function is called at the start of every write transaction.
5502 ** There must already be a RESERVED or EXCLUSIVE lock on the database
5503 ** file when this routine is called.
5504 **
5505 ** Open the journal file for pager pPager and write a journal header
5506 ** to the start of it. If there are active savepoints, open the sub-journal
5507 ** as well. This function is only used when the journal file is being
5508 ** opened to write a rollback log for a transaction. It is not used
5509 ** when opening a hot journal file to roll it back.
5510 **
5511 ** If the journal file is already open (as it may be in exclusive mode),
5512 ** then this function just writes a journal header to the start of the
5513 ** already open file.
5514 **
5515 ** Whether or not the journal file is opened by this function, the
5516 ** Pager.pInJournal bitvec structure is allocated.
5517 **
5518 ** Return SQLITE_OK if everything is successful. Otherwise, return
5519 ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
5520 ** an IO error code if opening or writing the journal file fails.
5521 */
5522 static int pager_open_journal(Pager *pPager){
5523 int rc = SQLITE_OK; /* Return code */
5524 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
5525
5526 assert( pPager->eState==PAGER_WRITER_LOCKED );
5527 assert( assert_pager_state(pPager) );
5528 assert( pPager->pInJournal==0 );
5529
5530 /* If already in the error state, this function is a no-op. But on
5531 ** the other hand, this routine is never called if we are already in
5532 ** an error state. */
5533 if( NEVER(pPager->errCode) ) return pPager->errCode;
5534
5535 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
5536 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
5537 if( pPager->pInJournal==0 ){
5538 return SQLITE_NOMEM;
5539 }
5540
5541 /* Open the journal file if it is not already open. */
5542 if( !isOpen(pPager->jfd) ){
5543 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
5544 sqlite3MemJournalOpen(pPager->jfd);
5545 }else{
5546 const int flags = /* VFS flags to open journal file */
5547 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
5548 (pPager->tempFile ?
5549 (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL):
5550 (SQLITE_OPEN_MAIN_JOURNAL)
5551 );
5552
5553 /* Verify that the database still has the same name as it did when
5554 ** it was originally opened. */
5555 rc = databaseIsUnmoved(pPager);
5556 if( rc==SQLITE_OK ){
5557 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
5558 rc = sqlite3JournalOpen(
5559 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
5560 );
5561 #else
5562 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
5563 #endif
5564 }
5565 }
5566 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
5567 }
5568
5569
5570 /* Write the first journal header to the journal file and open
5571 ** the sub-journal if necessary.
5572 */
5573 if( rc==SQLITE_OK ){
5574 /* TODO: Check if all of these are really required. */
5575 pPager->nRec = 0;
5576 pPager->journalOff = 0;
5577 pPager->setMaster = 0;
5578 pPager->journalHdr = 0;
5579 rc = writeJournalHdr(pPager);
5580 }
5581 }
5582
5583 if( rc!=SQLITE_OK ){
5584 sqlite3BitvecDestroy(pPager->pInJournal);
5585 pPager->pInJournal = 0;
5586 }else{
5587 assert( pPager->eState==PAGER_WRITER_LOCKED );
5588 pPager->eState = PAGER_WRITER_CACHEMOD;
5589 }
5590
5591 return rc;
5592 }
5593
5594 /*
5595 ** Begin a write-transaction on the specified pager object. If a
5596 ** write-transaction has already been opened, this function is a no-op.
5597 **
5598 ** If the exFlag argument is false, then acquire at least a RESERVED
5599 ** lock on the database file. If exFlag is true, then acquire at least
5600 ** an EXCLUSIVE lock. If such a lock is already held, no locking
5601 ** functions need be called.
5602 **
5603 ** If the subjInMemory argument is non-zero, then any sub-journal opened
5604 ** within this transaction will be opened as an in-memory file. This
5605 ** has no effect if the sub-journal is already opened (as it may be when
5606 ** running in exclusive mode) or if the transaction does not require a
5607 ** sub-journal. If the subjInMemory argument is zero, then any required
5608 ** sub-journal is implemented in-memory if pPager is an in-memory database,
5609 ** or using a temporary file otherwise.
5610 */
5611 int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
5612 int rc = SQLITE_OK;
5613
5614 if( pPager->errCode ) return pPager->errCode;
5615 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
5616 pPager->subjInMemory = (u8)subjInMemory;
5617
5618 if( ALWAYS(pPager->eState==PAGER_READER) ){
5619 assert( pPager->pInJournal==0 );
5620
5621 if( pagerUseWal(pPager) ){
5622 /* If the pager is configured to use locking_mode=exclusive, and an
5623 ** exclusive lock on the database is not already held, obtain it now.
5624 */
5625 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
5626 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
5627 if( rc!=SQLITE_OK ){
5628 return rc;
5629 }
5630 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
5631 }
5632
5633 /* Grab the write lock on the log file. If successful, upgrade to
5634 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
5635 ** The busy-handler is not invoked if another connection already
5636 ** holds the write-lock. If possible, the upper layer will call it.
5637 */
5638 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
5639 }else{
5640 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
5641 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
5642 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
5643 ** lock, but not when obtaining the RESERVED lock.
5644 */
5645 rc = pagerLockDb(pPager, RESERVED_LOCK);
5646 if( rc==SQLITE_OK && exFlag ){
5647 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
5648 }
5649 }
5650
5651 if( rc==SQLITE_OK ){
5652 /* Change to WRITER_LOCKED state.
5653 **
5654 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
5655 ** when it has an open transaction, but never to DBMOD or FINISHED.
5656 ** This is because in those states the code to roll back savepoint
5657 ** transactions may copy data from the sub-journal into the database
5658 ** file as well as into the page cache. Which would be incorrect in
5659 ** WAL mode.
5660 */
5661 pPager->eState = PAGER_WRITER_LOCKED;
5662 pPager->dbHintSize = pPager->dbSize;
5663 pPager->dbFileSize = pPager->dbSize;
5664 pPager->dbOrigSize = pPager->dbSize;
5665 pPager->journalOff = 0;
5666 }
5667
5668 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
5669 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
5670 assert( assert_pager_state(pPager) );
5671 }
5672
5673 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
5674 return rc;
5675 }
5676
5677 /*
5678 ** Write page pPg onto the end of the rollback journal.
5679 */
5680 static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
5681 Pager *pPager = pPg->pPager;
5682 int rc;
5683 u32 cksum;
5684 char *pData2;
5685 i64 iOff = pPager->journalOff;
5686
5687 /* We should never write to the journal file the page that
5688 ** contains the database locks. The following assert verifies
5689 ** that we do not. */
5690 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
5691
5692 assert( pPager->journalHdr<=pPager->journalOff );
5693 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
5694 cksum = pager_cksum(pPager, (u8*)pData2);
5695
5696 /* Even if an IO or diskfull error occurs while journalling the
5697 ** page in the block above, set the need-sync flag for the page.
5698 ** Otherwise, when the transaction is rolled back, the logic in
5699 ** playback_one_page() will think that the page needs to be restored
5700 ** in the database file. And if an IO error occurs while doing so,
5701 ** then corruption may follow.
5702 */
5703 pPg->flags |= PGHDR_NEED_SYNC;
5704
5705 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
5706 if( rc!=SQLITE_OK ) return rc;
5707 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
5708 if( rc!=SQLITE_OK ) return rc;
5709 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
5710 if( rc!=SQLITE_OK ) return rc;
5711
5712 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
5713 pPager->journalOff, pPager->pageSize));
5714 PAGER_INCR(sqlite3_pager_writej_count);
5715 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
5716 PAGERID(pPager), pPg->pgno,
5717 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
5718
5719 pPager->journalOff += 8 + pPager->pageSize;
5720 pPager->nRec++;
5721 assert( pPager->pInJournal!=0 );
5722 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
5723 testcase( rc==SQLITE_NOMEM );
5724 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
5725 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
5726 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
5727 return rc;
5728 }
5729
5730 /*
5731 ** Mark a single data page as writeable. The page is written into the
5732 ** main journal or sub-journal as required. If the page is written into
5733 ** one of the journals, the corresponding bit is set in the
5734 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
5735 ** of any open savepoints as appropriate.
5736 */
5737 static int pager_write(PgHdr *pPg){
5738 Pager *pPager = pPg->pPager;
5739 int rc = SQLITE_OK;
5740
5741 /* This routine is not called unless a write-transaction has already
5742 ** been started. The journal file may or may not be open at this point.
5743 ** It is never called in the ERROR state.
5744 */
5745 assert( pPager->eState==PAGER_WRITER_LOCKED
5746 || pPager->eState==PAGER_WRITER_CACHEMOD
5747 || pPager->eState==PAGER_WRITER_DBMOD
5748 );
5749 assert( assert_pager_state(pPager) );
5750 assert( pPager->errCode==0 );
5751 assert( pPager->readOnly==0 );
5752 CHECK_PAGE(pPg);
5753
5754 /* The journal file needs to be opened. Higher level routines have already
5755 ** obtained the necessary locks to begin the write-transaction, but the
5756 ** rollback journal might not yet be open. Open it now if this is the case.
5757 **
5758 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
5759 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
5760 ** an error might occur and the pager would end up in WRITER_LOCKED state
5761 ** with pages marked as dirty in the cache.
5762 */
5763 if( pPager->eState==PAGER_WRITER_LOCKED ){
5764 rc = pager_open_journal(pPager);
5765 if( rc!=SQLITE_OK ) return rc;
5766 }
5767 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
5768 assert( assert_pager_state(pPager) );
5769
5770 /* Mark the page that is about to be modified as dirty. */
5771 sqlite3PcacheMakeDirty(pPg);
5772
5773 /* If a rollback journal is in use, them make sure the page that is about
5774 ** to change is in the rollback journal, or if the page is a new page off
5775 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
5776 */
5777 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
5778 if( pPager->pInJournal!=0
5779 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
5780 ){
5781 assert( pagerUseWal(pPager)==0 );
5782 if( pPg->pgno<=pPager->dbOrigSize ){
5783 rc = pagerAddPageToRollbackJournal(pPg);
5784 if( rc!=SQLITE_OK ){
5785 return rc;
5786 }
5787 }else{
5788 if( pPager->eState!=PAGER_WRITER_DBMOD ){
5789 pPg->flags |= PGHDR_NEED_SYNC;
5790 }
5791 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
5792 PAGERID(pPager), pPg->pgno,
5793 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
5794 }
5795 }
5796
5797 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
5798 ** and before writing the page into the rollback journal. Wait until now,
5799 ** after the page has been successfully journalled, before setting the
5800 ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
5801 */
5802 pPg->flags |= PGHDR_WRITEABLE;
5803
5804 /* If the statement journal is open and the page is not in it,
5805 ** then write the page into the statement journal.
5806 */
5807 if( pPager->nSavepoint>0 ){
5808 rc = subjournalPageIfRequired(pPg);
5809 }
5810
5811 /* Update the database size and return. */
5812 if( pPager->dbSize<pPg->pgno ){
5813 pPager->dbSize = pPg->pgno;
5814 }
5815 return rc;
5816 }
5817
5818 /*
5819 ** This is a variant of sqlite3PagerWrite() that runs when the sector size
5820 ** is larger than the page size. SQLite makes the (reasonable) assumption that
5821 ** all bytes of a sector are written together by hardware. Hence, all bytes of
5822 ** a sector need to be journalled in case of a power loss in the middle of
5823 ** a write.
5824 **
5825 ** Usually, the sector size is less than or equal to the page size, in which
5826 ** case pages can be individually written. This routine only runs in the
5827 ** exceptional case where the page size is smaller than the sector size.
5828 */
5829 static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
5830 int rc = SQLITE_OK; /* Return code */
5831 Pgno nPageCount; /* Total number of pages in database file */
5832 Pgno pg1; /* First page of the sector pPg is located on. */
5833 int nPage = 0; /* Number of pages starting at pg1 to journal */
5834 int ii; /* Loop counter */
5835 int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */
5836 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
5837 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
5838
5839 /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
5840 ** a journal header to be written between the pages journaled by
5841 ** this function.
5842 */
5843 assert( !MEMDB );
5844 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
5845 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
5846
5847 /* This trick assumes that both the page-size and sector-size are
5848 ** an integer power of 2. It sets variable pg1 to the identifier
5849 ** of the first page of the sector pPg is located on.
5850 */
5851 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
5852
5853 nPageCount = pPager->dbSize;
5854 if( pPg->pgno>nPageCount ){
5855 nPage = (pPg->pgno - pg1)+1;
5856 }else if( (pg1+nPagePerSector-1)>nPageCount ){
5857 nPage = nPageCount+1-pg1;
5858 }else{
5859 nPage = nPagePerSector;
5860 }
5861 assert(nPage>0);
5862 assert(pg1<=pPg->pgno);
5863 assert((pg1+nPage)>pPg->pgno);
5864
5865 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
5866 Pgno pg = pg1+ii;
5867 PgHdr *pPage;
5868 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
5869 if( pg!=PAGER_MJ_PGNO(pPager) ){
5870 rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
5871 if( rc==SQLITE_OK ){
5872 rc = pager_write(pPage);
5873 if( pPage->flags&PGHDR_NEED_SYNC ){
5874 needSync = 1;
5875 }
5876 sqlite3PagerUnrefNotNull(pPage);
5877 }
5878 }
5879 }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
5880 if( pPage->flags&PGHDR_NEED_SYNC ){
5881 needSync = 1;
5882 }
5883 sqlite3PagerUnrefNotNull(pPage);
5884 }
5885 }
5886
5887 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
5888 ** starting at pg1, then it needs to be set for all of them. Because
5889 ** writing to any of these nPage pages may damage the others, the
5890 ** journal file must contain sync()ed copies of all of them
5891 ** before any of them can be written out to the database file.
5892 */
5893 if( rc==SQLITE_OK && needSync ){
5894 assert( !MEMDB );
5895 for(ii=0; ii<nPage; ii++){
5896 PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
5897 if( pPage ){
5898 pPage->flags |= PGHDR_NEED_SYNC;
5899 sqlite3PagerUnrefNotNull(pPage);
5900 }
5901 }
5902 }
5903
5904 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
5905 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
5906 return rc;
5907 }
5908
5909 /*
5910 ** Mark a data page as writeable. This routine must be called before
5911 ** making changes to a page. The caller must check the return value
5912 ** of this function and be careful not to change any page data unless
5913 ** this routine returns SQLITE_OK.
5914 **
5915 ** The difference between this function and pager_write() is that this
5916 ** function also deals with the special case where 2 or more pages
5917 ** fit on a single disk sector. In this case all co-resident pages
5918 ** must have been written to the journal file before returning.
5919 **
5920 ** If an error occurs, SQLITE_NOMEM or an IO error code is returned
5921 ** as appropriate. Otherwise, SQLITE_OK.
5922 */
5923 int sqlite3PagerWrite(PgHdr *pPg){
5924 Pager *pPager = pPg->pPager;
5925 assert( (pPg->flags & PGHDR_MMAP)==0 );
5926 assert( pPager->eState>=PAGER_WRITER_LOCKED );
5927 assert( assert_pager_state(pPager) );
5928 if( pPager->errCode ){
5929 return pPager->errCode;
5930 }else if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
5931 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
5932 return SQLITE_OK;
5933 }else if( pPager->sectorSize > (u32)pPager->pageSize ){
5934 return pagerWriteLargeSector(pPg);
5935 }else{
5936 return pager_write(pPg);
5937 }
5938 }
5939
5940 /*
5941 ** Return TRUE if the page given in the argument was previously passed
5942 ** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
5943 ** to change the content of the page.
5944 */
5945 #ifndef NDEBUG
5946 int sqlite3PagerIswriteable(DbPage *pPg){
5947 return pPg->flags & PGHDR_WRITEABLE;
5948 }
5949 #endif
5950
5951 /*
5952 ** A call to this routine tells the pager that it is not necessary to
5953 ** write the information on page pPg back to the disk, even though
5954 ** that page might be marked as dirty. This happens, for example, when
5955 ** the page has been added as a leaf of the freelist and so its
5956 ** content no longer matters.
5957 **
5958 ** The overlying software layer calls this routine when all of the data
5959 ** on the given page is unused. The pager marks the page as clean so
5960 ** that it does not get written to disk.
5961 **
5962 ** Tests show that this optimization can quadruple the speed of large
5963 ** DELETE operations.
5964 */
5965 void sqlite3PagerDontWrite(PgHdr *pPg){
5966 Pager *pPager = pPg->pPager;
5967 if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
5968 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
5969 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
5970 pPg->flags |= PGHDR_DONT_WRITE;
5971 pPg->flags &= ~PGHDR_WRITEABLE;
5972 pager_set_pagehash(pPg);
5973 }
5974 }
5975
5976 /*
5977 ** This routine is called to increment the value of the database file
5978 ** change-counter, stored as a 4-byte big-endian integer starting at
5979 ** byte offset 24 of the pager file. The secondary change counter at
5980 ** 92 is also updated, as is the SQLite version number at offset 96.
5981 **
5982 ** But this only happens if the pPager->changeCountDone flag is false.
5983 ** To avoid excess churning of page 1, the update only happens once.
5984 ** See also the pager_write_changecounter() routine that does an
5985 ** unconditional update of the change counters.
5986 **
5987 ** If the isDirectMode flag is zero, then this is done by calling
5988 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
5989 ** page data. In this case the file will be updated when the current
5990 ** transaction is committed.
5991 **
5992 ** The isDirectMode flag may only be non-zero if the library was compiled
5993 ** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
5994 ** if isDirect is non-zero, then the database file is updated directly
5995 ** by writing an updated version of page 1 using a call to the
5996 ** sqlite3OsWrite() function.
5997 */
5998 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
5999 int rc = SQLITE_OK;
6000
6001 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6002 || pPager->eState==PAGER_WRITER_DBMOD
6003 );
6004 assert( assert_pager_state(pPager) );
6005
6006 /* Declare and initialize constant integer 'isDirect'. If the
6007 ** atomic-write optimization is enabled in this build, then isDirect
6008 ** is initialized to the value passed as the isDirectMode parameter
6009 ** to this function. Otherwise, it is always set to zero.
6010 **
6011 ** The idea is that if the atomic-write optimization is not
6012 ** enabled at compile time, the compiler can omit the tests of
6013 ** 'isDirect' below, as well as the block enclosed in the
6014 ** "if( isDirect )" condition.
6015 */
6016 #ifndef SQLITE_ENABLE_ATOMIC_WRITE
6017 # define DIRECT_MODE 0
6018 assert( isDirectMode==0 );
6019 UNUSED_PARAMETER(isDirectMode);
6020 #else
6021 # define DIRECT_MODE isDirectMode
6022 #endif
6023
6024 if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
6025 PgHdr *pPgHdr; /* Reference to page 1 */
6026
6027 assert( !pPager->tempFile && isOpen(pPager->fd) );
6028
6029 /* Open page 1 of the file for writing. */
6030 rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0);
6031 assert( pPgHdr==0 || rc==SQLITE_OK );
6032
6033 /* If page one was fetched successfully, and this function is not
6034 ** operating in direct-mode, make page 1 writable. When not in
6035 ** direct mode, page 1 is always held in cache and hence the PagerGet()
6036 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
6037 */
6038 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
6039 rc = sqlite3PagerWrite(pPgHdr);
6040 }
6041
6042 if( rc==SQLITE_OK ){
6043 /* Actually do the update of the change counter */
6044 pager_write_changecounter(pPgHdr);
6045
6046 /* If running in direct mode, write the contents of page 1 to the file. */
6047 if( DIRECT_MODE ){
6048 const void *zBuf;
6049 assert( pPager->dbFileSize>0 );
6050 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
6051 if( rc==SQLITE_OK ){
6052 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
6053 pPager->aStat[PAGER_STAT_WRITE]++;
6054 }
6055 if( rc==SQLITE_OK ){
6056 /* Update the pager's copy of the change-counter. Otherwise, the
6057 ** next time a read transaction is opened the cache will be
6058 ** flushed (as the change-counter values will not match). */
6059 const void *pCopy = (const void *)&((const char *)zBuf)[24];
6060 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
6061 pPager->changeCountDone = 1;
6062 }
6063 }else{
6064 pPager->changeCountDone = 1;
6065 }
6066 }
6067
6068 /* Release the page reference. */
6069 sqlite3PagerUnref(pPgHdr);
6070 }
6071 return rc;
6072 }
6073
6074 /*
6075 ** Sync the database file to disk. This is a no-op for in-memory databases
6076 ** or pages with the Pager.noSync flag set.
6077 **
6078 ** If successful, or if called on a pager for which it is a no-op, this
6079 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
6080 */
6081 int sqlite3PagerSync(Pager *pPager, const char *zMaster){
6082 int rc = SQLITE_OK;
6083
6084 if( isOpen(pPager->fd) ){
6085 void *pArg = (void*)zMaster;
6086 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
6087 if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
6088 }
6089 if( rc==SQLITE_OK && !pPager->noSync ){
6090 assert( !MEMDB );
6091 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
6092 }
6093 return rc;
6094 }
6095
6096 /*
6097 ** This function may only be called while a write-transaction is active in
6098 ** rollback. If the connection is in WAL mode, this call is a no-op.
6099 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
6100 ** the database file, an attempt is made to obtain one.
6101 **
6102 ** If the EXCLUSIVE lock is already held or the attempt to obtain it is
6103 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
6104 ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
6105 ** returned.
6106 */
6107 int sqlite3PagerExclusiveLock(Pager *pPager){
6108 int rc = pPager->errCode;
6109 assert( assert_pager_state(pPager) );
6110 if( rc==SQLITE_OK ){
6111 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6112 || pPager->eState==PAGER_WRITER_DBMOD
6113 || pPager->eState==PAGER_WRITER_LOCKED
6114 );
6115 assert( assert_pager_state(pPager) );
6116 if( 0==pagerUseWal(pPager) ){
6117 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
6118 }
6119 }
6120 return rc;
6121 }
6122
6123 /*
6124 ** Sync the database file for the pager pPager. zMaster points to the name
6125 ** of a master journal file that should be written into the individual
6126 ** journal file. zMaster may be NULL, which is interpreted as no master
6127 ** journal (a single database transaction).
6128 **
6129 ** This routine ensures that:
6130 **
6131 ** * The database file change-counter is updated,
6132 ** * the journal is synced (unless the atomic-write optimization is used),
6133 ** * all dirty pages are written to the database file,
6134 ** * the database file is truncated (if required), and
6135 ** * the database file synced.
6136 **
6137 ** The only thing that remains to commit the transaction is to finalize
6138 ** (delete, truncate or zero the first part of) the journal file (or
6139 ** delete the master journal file if specified).
6140 **
6141 ** Note that if zMaster==NULL, this does not overwrite a previous value
6142 ** passed to an sqlite3PagerCommitPhaseOne() call.
6143 **
6144 ** If the final parameter - noSync - is true, then the database file itself
6145 ** is not synced. The caller must call sqlite3PagerSync() directly to
6146 ** sync the database file before calling CommitPhaseTwo() to delete the
6147 ** journal file in this case.
6148 */
6149 int sqlite3PagerCommitPhaseOne(
6150 Pager *pPager, /* Pager object */
6151 const char *zMaster, /* If not NULL, the master journal name */
6152 int noSync /* True to omit the xSync on the db file */
6153 ){
6154 int rc = SQLITE_OK; /* Return code */
6155
6156 assert( pPager->eState==PAGER_WRITER_LOCKED
6157 || pPager->eState==PAGER_WRITER_CACHEMOD
6158 || pPager->eState==PAGER_WRITER_DBMOD
6159 || pPager->eState==PAGER_ERROR
6160 );
6161 assert( assert_pager_state(pPager) );
6162
6163 /* If a prior error occurred, report that error again. */
6164 if( NEVER(pPager->errCode) ) return pPager->errCode;
6165
6166 PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
6167 pPager->zFilename, zMaster, pPager->dbSize));
6168
6169 /* If no database changes have been made, return early. */
6170 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
6171
6172 if( MEMDB ){
6173 /* If this is an in-memory db, or no pages have been written to, or this
6174 ** function has already been called, it is mostly a no-op. However, any
6175 ** backup in progress needs to be restarted.
6176 */
6177 sqlite3BackupRestart(pPager->pBackup);
6178 }else{
6179 if( pagerUseWal(pPager) ){
6180 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
6181 PgHdr *pPageOne = 0;
6182 if( pList==0 ){
6183 /* Must have at least one page for the WAL commit flag.
6184 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
6185 rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0);
6186 pList = pPageOne;
6187 pList->pDirty = 0;
6188 }
6189 assert( rc==SQLITE_OK );
6190 if( ALWAYS(pList) ){
6191 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
6192 }
6193 sqlite3PagerUnref(pPageOne);
6194 if( rc==SQLITE_OK ){
6195 sqlite3PcacheCleanAll(pPager->pPCache);
6196 }
6197 }else{
6198 /* The following block updates the change-counter. Exactly how it
6199 ** does this depends on whether or not the atomic-update optimization
6200 ** was enabled at compile time, and if this transaction meets the
6201 ** runtime criteria to use the operation:
6202 **
6203 ** * The file-system supports the atomic-write property for
6204 ** blocks of size page-size, and
6205 ** * This commit is not part of a multi-file transaction, and
6206 ** * Exactly one page has been modified and store in the journal file.
6207 **
6208 ** If the optimization was not enabled at compile time, then the
6209 ** pager_incr_changecounter() function is called to update the change
6210 ** counter in 'indirect-mode'. If the optimization is compiled in but
6211 ** is not applicable to this transaction, call sqlite3JournalCreate()
6212 ** to make sure the journal file has actually been created, then call
6213 ** pager_incr_changecounter() to update the change-counter in indirect
6214 ** mode.
6215 **
6216 ** Otherwise, if the optimization is both enabled and applicable,
6217 ** then call pager_incr_changecounter() to update the change-counter
6218 ** in 'direct' mode. In this case the journal file will never be
6219 ** created for this transaction.
6220 */
6221 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
6222 PgHdr *pPg;
6223 assert( isOpen(pPager->jfd)
6224 || pPager->journalMode==PAGER_JOURNALMODE_OFF
6225 || pPager->journalMode==PAGER_JOURNALMODE_WAL
6226 );
6227 if( !zMaster && isOpen(pPager->jfd)
6228 && pPager->journalOff==jrnlBufferSize(pPager)
6229 && pPager->dbSize>=pPager->dbOrigSize
6230 && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
6231 ){
6232 /* Update the db file change counter via the direct-write method. The
6233 ** following call will modify the in-memory representation of page 1
6234 ** to include the updated change counter and then write page 1
6235 ** directly to the database file. Because of the atomic-write
6236 ** property of the host file-system, this is safe.
6237 */
6238 rc = pager_incr_changecounter(pPager, 1);
6239 }else{
6240 rc = sqlite3JournalCreate(pPager->jfd);
6241 if( rc==SQLITE_OK ){
6242 rc = pager_incr_changecounter(pPager, 0);
6243 }
6244 }
6245 #else
6246 rc = pager_incr_changecounter(pPager, 0);
6247 #endif
6248 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6249
6250 /* Write the master journal name into the journal file. If a master
6251 ** journal file name has already been written to the journal file,
6252 ** or if zMaster is NULL (no master journal), then this call is a no-op.
6253 */
6254 rc = writeMasterJournal(pPager, zMaster);
6255 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6256
6257 /* Sync the journal file and write all dirty pages to the database.
6258 ** If the atomic-update optimization is being used, this sync will not
6259 ** create the journal file or perform any real IO.
6260 **
6261 ** Because the change-counter page was just modified, unless the
6262 ** atomic-update optimization is used it is almost certain that the
6263 ** journal requires a sync here. However, in locking_mode=exclusive
6264 ** on a system under memory pressure it is just possible that this is
6265 ** not the case. In this case it is likely enough that the redundant
6266 ** xSync() call will be changed to a no-op by the OS anyhow.
6267 */
6268 rc = syncJournal(pPager, 0);
6269 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6270
6271 rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
6272 if( rc!=SQLITE_OK ){
6273 assert( rc!=SQLITE_IOERR_BLOCKED );
6274 goto commit_phase_one_exit;
6275 }
6276 sqlite3PcacheCleanAll(pPager->pPCache);
6277
6278 /* If the file on disk is smaller than the database image, use
6279 ** pager_truncate to grow the file here. This can happen if the database
6280 ** image was extended as part of the current transaction and then the
6281 ** last page in the db image moved to the free-list. In this case the
6282 ** last page is never written out to disk, leaving the database file
6283 ** undersized. Fix this now if it is the case. */
6284 if( pPager->dbSize>pPager->dbFileSize ){
6285 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
6286 assert( pPager->eState==PAGER_WRITER_DBMOD );
6287 rc = pager_truncate(pPager, nNew);
6288 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
6289 }
6290
6291 /* Finally, sync the database file. */
6292 if( !noSync ){
6293 rc = sqlite3PagerSync(pPager, zMaster);
6294 }
6295 IOTRACE(("DBSYNC %p\n", pPager))
6296 }
6297 }
6298
6299 commit_phase_one_exit:
6300 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
6301 pPager->eState = PAGER_WRITER_FINISHED;
6302 }
6303 return rc;
6304 }
6305
6306
6307 /*
6308 ** When this function is called, the database file has been completely
6309 ** updated to reflect the changes made by the current transaction and
6310 ** synced to disk. The journal file still exists in the file-system
6311 ** though, and if a failure occurs at this point it will eventually
6312 ** be used as a hot-journal and the current transaction rolled back.
6313 **
6314 ** This function finalizes the journal file, either by deleting,
6315 ** truncating or partially zeroing it, so that it cannot be used
6316 ** for hot-journal rollback. Once this is done the transaction is
6317 ** irrevocably committed.
6318 **
6319 ** If an error occurs, an IO error code is returned and the pager
6320 ** moves into the error state. Otherwise, SQLITE_OK is returned.
6321 */
6322 int sqlite3PagerCommitPhaseTwo(Pager *pPager){
6323 int rc = SQLITE_OK; /* Return code */
6324
6325 /* This routine should not be called if a prior error has occurred.
6326 ** But if (due to a coding error elsewhere in the system) it does get
6327 ** called, just return the same error code without doing anything. */
6328 if( NEVER(pPager->errCode) ) return pPager->errCode;
6329
6330 assert( pPager->eState==PAGER_WRITER_LOCKED
6331 || pPager->eState==PAGER_WRITER_FINISHED
6332 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
6333 );
6334 assert( assert_pager_state(pPager) );
6335
6336 /* An optimization. If the database was not actually modified during
6337 ** this transaction, the pager is running in exclusive-mode and is
6338 ** using persistent journals, then this function is a no-op.
6339 **
6340 ** The start of the journal file currently contains a single journal
6341 ** header with the nRec field set to 0. If such a journal is used as
6342 ** a hot-journal during hot-journal rollback, 0 changes will be made
6343 ** to the database file. So there is no need to zero the journal
6344 ** header. Since the pager is in exclusive mode, there is no need
6345 ** to drop any locks either.
6346 */
6347 if( pPager->eState==PAGER_WRITER_LOCKED
6348 && pPager->exclusiveMode
6349 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
6350 ){
6351 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
6352 pPager->eState = PAGER_READER;
6353 return SQLITE_OK;
6354 }
6355
6356 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
6357 pPager->iDataVersion++;
6358 rc = pager_end_transaction(pPager, pPager->setMaster, 1);
6359 return pager_error(pPager, rc);
6360 }
6361
6362 /*
6363 ** If a write transaction is open, then all changes made within the
6364 ** transaction are reverted and the current write-transaction is closed.
6365 ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
6366 ** state if an error occurs.
6367 **
6368 ** If the pager is already in PAGER_ERROR state when this function is called,
6369 ** it returns Pager.errCode immediately. No work is performed in this case.
6370 **
6371 ** Otherwise, in rollback mode, this function performs two functions:
6372 **
6373 ** 1) It rolls back the journal file, restoring all database file and
6374 ** in-memory cache pages to the state they were in when the transaction
6375 ** was opened, and
6376 **
6377 ** 2) It finalizes the journal file, so that it is not used for hot
6378 ** rollback at any point in the future.
6379 **
6380 ** Finalization of the journal file (task 2) is only performed if the
6381 ** rollback is successful.
6382 **
6383 ** In WAL mode, all cache-entries containing data modified within the
6384 ** current transaction are either expelled from the cache or reverted to
6385 ** their pre-transaction state by re-reading data from the database or
6386 ** WAL files. The WAL transaction is then closed.
6387 */
6388 int sqlite3PagerRollback(Pager *pPager){
6389 int rc = SQLITE_OK; /* Return code */
6390 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
6391
6392 /* PagerRollback() is a no-op if called in READER or OPEN state. If
6393 ** the pager is already in the ERROR state, the rollback is not
6394 ** attempted here. Instead, the error code is returned to the caller.
6395 */
6396 assert( assert_pager_state(pPager) );
6397 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
6398 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
6399
6400 if( pagerUseWal(pPager) ){
6401 int rc2;
6402 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
6403 rc2 = pager_end_transaction(pPager, pPager->setMaster, 0);
6404 if( rc==SQLITE_OK ) rc = rc2;
6405 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
6406 int eState = pPager->eState;
6407 rc = pager_end_transaction(pPager, 0, 0);
6408 if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
6409 /* This can happen using journal_mode=off. Move the pager to the error
6410 ** state to indicate that the contents of the cache may not be trusted.
6411 ** Any active readers will get SQLITE_ABORT.
6412 */
6413 pPager->errCode = SQLITE_ABORT;
6414 pPager->eState = PAGER_ERROR;
6415 return rc;
6416 }
6417 }else{
6418 rc = pager_playback(pPager, 0);
6419 }
6420
6421 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
6422 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
6423 || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR
6424 || rc==SQLITE_CANTOPEN
6425 );
6426
6427 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
6428 ** cache. So call pager_error() on the way out to make any error persistent.
6429 */
6430 return pager_error(pPager, rc);
6431 }
6432
6433 /*
6434 ** Return TRUE if the database file is opened read-only. Return FALSE
6435 ** if the database is (in theory) writable.
6436 */
6437 u8 sqlite3PagerIsreadonly(Pager *pPager){
6438 return pPager->readOnly;
6439 }
6440
6441 #ifdef SQLITE_DEBUG
6442 /*
6443 ** Return the sum of the reference counts for all pages held by pPager.
6444 */
6445 int sqlite3PagerRefcount(Pager *pPager){
6446 return sqlite3PcacheRefCount(pPager->pPCache);
6447 }
6448 #endif
6449
6450 /*
6451 ** Return the approximate number of bytes of memory currently
6452 ** used by the pager and its associated cache.
6453 */
6454 int sqlite3PagerMemUsed(Pager *pPager){
6455 int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
6456 + 5*sizeof(void*);
6457 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
6458 + sqlite3MallocSize(pPager)
6459 + pPager->pageSize;
6460 }
6461
6462 /*
6463 ** Return the number of references to the specified page.
6464 */
6465 int sqlite3PagerPageRefcount(DbPage *pPage){
6466 return sqlite3PcachePageRefcount(pPage);
6467 }
6468
6469 #ifdef SQLITE_TEST
6470 /*
6471 ** This routine is used for testing and analysis only.
6472 */
6473 int *sqlite3PagerStats(Pager *pPager){
6474 static int a[11];
6475 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
6476 a[1] = sqlite3PcachePagecount(pPager->pPCache);
6477 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
6478 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
6479 a[4] = pPager->eState;
6480 a[5] = pPager->errCode;
6481 a[6] = pPager->aStat[PAGER_STAT_HIT];
6482 a[7] = pPager->aStat[PAGER_STAT_MISS];
6483 a[8] = 0; /* Used to be pPager->nOvfl */
6484 a[9] = pPager->nRead;
6485 a[10] = pPager->aStat[PAGER_STAT_WRITE];
6486 return a;
6487 }
6488 #endif
6489
6490 /*
6491 ** Parameter eStat must be either SQLITE_DBSTATUS_CACHE_HIT or
6492 ** SQLITE_DBSTATUS_CACHE_MISS. Before returning, *pnVal is incremented by the
6493 ** current cache hit or miss count, according to the value of eStat. If the
6494 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
6495 ** returning.
6496 */
6497 void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
6498
6499 assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
6500 || eStat==SQLITE_DBSTATUS_CACHE_MISS
6501 || eStat==SQLITE_DBSTATUS_CACHE_WRITE
6502 );
6503
6504 assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
6505 assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
6506 assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 && PAGER_STAT_WRITE==2 );
6507
6508 *pnVal += pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT];
6509 if( reset ){
6510 pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT] = 0;
6511 }
6512 }
6513
6514 /*
6515 ** Return true if this is an in-memory pager.
6516 */
6517 int sqlite3PagerIsMemdb(Pager *pPager){
6518 return MEMDB;
6519 }
6520
6521 /*
6522 ** Check that there are at least nSavepoint savepoints open. If there are
6523 ** currently less than nSavepoints open, then open one or more savepoints
6524 ** to make up the difference. If the number of savepoints is already
6525 ** equal to nSavepoint, then this function is a no-op.
6526 **
6527 ** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
6528 ** occurs while opening the sub-journal file, then an IO error code is
6529 ** returned. Otherwise, SQLITE_OK.
6530 */
6531 static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){
6532 int rc = SQLITE_OK; /* Return code */
6533 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
6534 int ii; /* Iterator variable */
6535 PagerSavepoint *aNew; /* New Pager.aSavepoint array */
6536
6537 assert( pPager->eState>=PAGER_WRITER_LOCKED );
6538 assert( assert_pager_state(pPager) );
6539 assert( nSavepoint>nCurrent && pPager->useJournal );
6540
6541 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
6542 ** if the allocation fails. Otherwise, zero the new portion in case a
6543 ** malloc failure occurs while populating it in the for(...) loop below.
6544 */
6545 aNew = (PagerSavepoint *)sqlite3Realloc(
6546 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
6547 );
6548 if( !aNew ){
6549 return SQLITE_NOMEM;
6550 }
6551 memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
6552 pPager->aSavepoint = aNew;
6553
6554 /* Populate the PagerSavepoint structures just allocated. */
6555 for(ii=nCurrent; ii<nSavepoint; ii++){
6556 aNew[ii].nOrig = pPager->dbSize;
6557 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
6558 aNew[ii].iOffset = pPager->journalOff;
6559 }else{
6560 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
6561 }
6562 aNew[ii].iSubRec = pPager->nSubRec;
6563 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
6564 if( !aNew[ii].pInSavepoint ){
6565 return SQLITE_NOMEM;
6566 }
6567 if( pagerUseWal(pPager) ){
6568 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
6569 }
6570 pPager->nSavepoint = ii+1;
6571 }
6572 assert( pPager->nSavepoint==nSavepoint );
6573 assertTruncateConstraint(pPager);
6574 return rc;
6575 }
6576 int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
6577 assert( pPager->eState>=PAGER_WRITER_LOCKED );
6578 assert( assert_pager_state(pPager) );
6579
6580 if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){
6581 return pagerOpenSavepoint(pPager, nSavepoint);
6582 }else{
6583 return SQLITE_OK;
6584 }
6585 }
6586
6587
6588 /*
6589 ** This function is called to rollback or release (commit) a savepoint.
6590 ** The savepoint to release or rollback need not be the most recently
6591 ** created savepoint.
6592 **
6593 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
6594 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
6595 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
6596 ** that have occurred since the specified savepoint was created.
6597 **
6598 ** The savepoint to rollback or release is identified by parameter
6599 ** iSavepoint. A value of 0 means to operate on the outermost savepoint
6600 ** (the first created). A value of (Pager.nSavepoint-1) means operate
6601 ** on the most recently created savepoint. If iSavepoint is greater than
6602 ** (Pager.nSavepoint-1), then this function is a no-op.
6603 **
6604 ** If a negative value is passed to this function, then the current
6605 ** transaction is rolled back. This is different to calling
6606 ** sqlite3PagerRollback() because this function does not terminate
6607 ** the transaction or unlock the database, it just restores the
6608 ** contents of the database to its original state.
6609 **
6610 ** In any case, all savepoints with an index greater than iSavepoint
6611 ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
6612 ** then savepoint iSavepoint is also destroyed.
6613 **
6614 ** This function may return SQLITE_NOMEM if a memory allocation fails,
6615 ** or an IO error code if an IO error occurs while rolling back a
6616 ** savepoint. If no errors occur, SQLITE_OK is returned.
6617 */
6618 int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
6619 int rc = pPager->errCode; /* Return code */
6620
6621 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
6622 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
6623
6624 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
6625 int ii; /* Iterator variable */
6626 int nNew; /* Number of remaining savepoints after this op. */
6627
6628 /* Figure out how many savepoints will still be active after this
6629 ** operation. Store this value in nNew. Then free resources associated
6630 ** with any savepoints that are destroyed by this operation.
6631 */
6632 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
6633 for(ii=nNew; ii<pPager->nSavepoint; ii++){
6634 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
6635 }
6636 pPager->nSavepoint = nNew;
6637
6638 /* If this is a release of the outermost savepoint, truncate
6639 ** the sub-journal to zero bytes in size. */
6640 if( op==SAVEPOINT_RELEASE ){
6641 if( nNew==0 && isOpen(pPager->sjfd) ){
6642 /* Only truncate if it is an in-memory sub-journal. */
6643 if( sqlite3IsMemJournal(pPager->sjfd) ){
6644 rc = sqlite3OsTruncate(pPager->sjfd, 0);
6645 assert( rc==SQLITE_OK );
6646 }
6647 pPager->nSubRec = 0;
6648 }
6649 }
6650 /* Else this is a rollback operation, playback the specified savepoint.
6651 ** If this is a temp-file, it is possible that the journal file has
6652 ** not yet been opened. In this case there have been no changes to
6653 ** the database file, so the playback operation can be skipped.
6654 */
6655 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
6656 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
6657 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
6658 assert(rc!=SQLITE_DONE);
6659 }
6660 }
6661
6662 return rc;
6663 }
6664
6665 /*
6666 ** Return the full pathname of the database file.
6667 **
6668 ** Except, if the pager is in-memory only, then return an empty string if
6669 ** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when
6670 ** used to report the filename to the user, for compatibility with legacy
6671 ** behavior. But when the Btree needs to know the filename for matching to
6672 ** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
6673 ** participate in shared-cache.
6674 */
6675 const char *sqlite3PagerFilename(Pager *pPager, int nullIfMemDb){
6676 return (nullIfMemDb && pPager->memDb) ? "" : pPager->zFilename;
6677 }
6678
6679 /*
6680 ** Return the VFS structure for the pager.
6681 */
6682 sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
6683 return pPager->pVfs;
6684 }
6685
6686 /*
6687 ** Return the file handle for the database file associated
6688 ** with the pager. This might return NULL if the file has
6689 ** not yet been opened.
6690 */
6691 sqlite3_file *sqlite3PagerFile(Pager *pPager){
6692 return pPager->fd;
6693 }
6694
6695 /*
6696 ** Return the file handle for the journal file (if it exists).
6697 ** This will be either the rollback journal or the WAL file.
6698 */
6699 sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){
6700 #if SQLITE_OMIT_WAL
6701 return pPager->jfd;
6702 #else
6703 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
6704 #endif
6705 }
6706
6707 /*
6708 ** Return the full pathname of the journal file.
6709 */
6710 const char *sqlite3PagerJournalname(Pager *pPager){
6711 return pPager->zJournal;
6712 }
6713
6714 /*
6715 ** Return true if fsync() calls are disabled for this pager. Return FALSE
6716 ** if fsync()s are executed normally.
6717 */
6718 int sqlite3PagerNosync(Pager *pPager){
6719 return pPager->noSync;
6720 }
6721
6722 #ifdef SQLITE_HAS_CODEC
6723 /*
6724 ** Set or retrieve the codec for this pager
6725 */
6726 void sqlite3PagerSetCodec(
6727 Pager *pPager,
6728 void *(*xCodec)(void*,void*,Pgno,int),
6729 void (*xCodecSizeChng)(void*,int,int),
6730 void (*xCodecFree)(void*),
6731 void *pCodec
6732 ){
6733 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
6734 pPager->xCodec = pPager->memDb ? 0 : xCodec;
6735 pPager->xCodecSizeChng = xCodecSizeChng;
6736 pPager->xCodecFree = xCodecFree;
6737 pPager->pCodec = pCodec;
6738 pagerReportSize(pPager);
6739 }
6740 void *sqlite3PagerGetCodec(Pager *pPager){
6741 return pPager->pCodec;
6742 }
6743
6744 /*
6745 ** This function is called by the wal module when writing page content
6746 ** into the log file.
6747 **
6748 ** This function returns a pointer to a buffer containing the encrypted
6749 ** page content. If a malloc fails, this function may return NULL.
6750 */
6751 void *sqlite3PagerCodec(PgHdr *pPg){
6752 void *aData = 0;
6753 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
6754 return aData;
6755 }
6756
6757 /*
6758 ** Return the current pager state
6759 */
6760 int sqlite3PagerState(Pager *pPager){
6761 return pPager->eState;
6762 }
6763 #endif /* SQLITE_HAS_CODEC */
6764
6765 #ifndef SQLITE_OMIT_AUTOVACUUM
6766 /*
6767 ** Move the page pPg to location pgno in the file.
6768 **
6769 ** There must be no references to the page previously located at
6770 ** pgno (which we call pPgOld) though that page is allowed to be
6771 ** in cache. If the page previously located at pgno is not already
6772 ** in the rollback journal, it is not put there by by this routine.
6773 **
6774 ** References to the page pPg remain valid. Updating any
6775 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
6776 ** allocated along with the page) is the responsibility of the caller.
6777 **
6778 ** A transaction must be active when this routine is called. It used to be
6779 ** required that a statement transaction was not active, but this restriction
6780 ** has been removed (CREATE INDEX needs to move a page when a statement
6781 ** transaction is active).
6782 **
6783 ** If the fourth argument, isCommit, is non-zero, then this page is being
6784 ** moved as part of a database reorganization just before the transaction
6785 ** is being committed. In this case, it is guaranteed that the database page
6786 ** pPg refers to will not be written to again within this transaction.
6787 **
6788 ** This function may return SQLITE_NOMEM or an IO error code if an error
6789 ** occurs. Otherwise, it returns SQLITE_OK.
6790 */
6791 int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
6792 PgHdr *pPgOld; /* The page being overwritten. */
6793 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
6794 int rc; /* Return code */
6795 Pgno origPgno; /* The original page number */
6796
6797 assert( pPg->nRef>0 );
6798 assert( pPager->eState==PAGER_WRITER_CACHEMOD
6799 || pPager->eState==PAGER_WRITER_DBMOD
6800 );
6801 assert( assert_pager_state(pPager) );
6802
6803 /* In order to be able to rollback, an in-memory database must journal
6804 ** the page we are moving from.
6805 */
6806 if( MEMDB ){
6807 rc = sqlite3PagerWrite(pPg);
6808 if( rc ) return rc;
6809 }
6810
6811 /* If the page being moved is dirty and has not been saved by the latest
6812 ** savepoint, then save the current contents of the page into the
6813 ** sub-journal now. This is required to handle the following scenario:
6814 **
6815 ** BEGIN;
6816 ** <journal page X, then modify it in memory>
6817 ** SAVEPOINT one;
6818 ** <Move page X to location Y>
6819 ** ROLLBACK TO one;
6820 **
6821 ** If page X were not written to the sub-journal here, it would not
6822 ** be possible to restore its contents when the "ROLLBACK TO one"
6823 ** statement were is processed.
6824 **
6825 ** subjournalPage() may need to allocate space to store pPg->pgno into
6826 ** one or more savepoint bitvecs. This is the reason this function
6827 ** may return SQLITE_NOMEM.
6828 */
6829 if( (pPg->flags & PGHDR_DIRTY)!=0
6830 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
6831 ){
6832 return rc;
6833 }
6834
6835 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
6836 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
6837 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
6838
6839 /* If the journal needs to be sync()ed before page pPg->pgno can
6840 ** be written to, store pPg->pgno in local variable needSyncPgno.
6841 **
6842 ** If the isCommit flag is set, there is no need to remember that
6843 ** the journal needs to be sync()ed before database page pPg->pgno
6844 ** can be written to. The caller has already promised not to write to it.
6845 */
6846 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
6847 needSyncPgno = pPg->pgno;
6848 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
6849 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
6850 assert( pPg->flags&PGHDR_DIRTY );
6851 }
6852
6853 /* If the cache contains a page with page-number pgno, remove it
6854 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
6855 ** page pgno before the 'move' operation, it needs to be retained
6856 ** for the page moved there.
6857 */
6858 pPg->flags &= ~PGHDR_NEED_SYNC;
6859 pPgOld = sqlite3PagerLookup(pPager, pgno);
6860 assert( !pPgOld || pPgOld->nRef==1 );
6861 if( pPgOld ){
6862 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
6863 if( MEMDB ){
6864 /* Do not discard pages from an in-memory database since we might
6865 ** need to rollback later. Just move the page out of the way. */
6866 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
6867 }else{
6868 sqlite3PcacheDrop(pPgOld);
6869 }
6870 }
6871
6872 origPgno = pPg->pgno;
6873 sqlite3PcacheMove(pPg, pgno);
6874 sqlite3PcacheMakeDirty(pPg);
6875
6876 /* For an in-memory database, make sure the original page continues
6877 ** to exist, in case the transaction needs to roll back. Use pPgOld
6878 ** as the original page since it has already been allocated.
6879 */
6880 if( MEMDB ){
6881 assert( pPgOld );
6882 sqlite3PcacheMove(pPgOld, origPgno);
6883 sqlite3PagerUnrefNotNull(pPgOld);
6884 }
6885
6886 if( needSyncPgno ){
6887 /* If needSyncPgno is non-zero, then the journal file needs to be
6888 ** sync()ed before any data is written to database file page needSyncPgno.
6889 ** Currently, no such page exists in the page-cache and the
6890 ** "is journaled" bitvec flag has been set. This needs to be remedied by
6891 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
6892 ** flag.
6893 **
6894 ** If the attempt to load the page into the page-cache fails, (due
6895 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
6896 ** array. Otherwise, if the page is loaded and written again in
6897 ** this transaction, it may be written to the database file before
6898 ** it is synced into the journal file. This way, it may end up in
6899 ** the journal file twice, but that is not a problem.
6900 */
6901 PgHdr *pPgHdr;
6902 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0);
6903 if( rc!=SQLITE_OK ){
6904 if( needSyncPgno<=pPager->dbOrigSize ){
6905 assert( pPager->pTmpSpace!=0 );
6906 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
6907 }
6908 return rc;
6909 }
6910 pPgHdr->flags |= PGHDR_NEED_SYNC;
6911 sqlite3PcacheMakeDirty(pPgHdr);
6912 sqlite3PagerUnrefNotNull(pPgHdr);
6913 }
6914
6915 return SQLITE_OK;
6916 }
6917 #endif
6918
6919 /*
6920 ** The page handle passed as the first argument refers to a dirty page
6921 ** with a page number other than iNew. This function changes the page's
6922 ** page number to iNew and sets the value of the PgHdr.flags field to
6923 ** the value passed as the third parameter.
6924 */
6925 void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
6926 assert( pPg->pgno!=iNew );
6927 pPg->flags = flags;
6928 sqlite3PcacheMove(pPg, iNew);
6929 }
6930
6931 /*
6932 ** Return a pointer to the data for the specified page.
6933 */
6934 void *sqlite3PagerGetData(DbPage *pPg){
6935 assert( pPg->nRef>0 || pPg->pPager->memDb );
6936 return pPg->pData;
6937 }
6938
6939 /*
6940 ** Return a pointer to the Pager.nExtra bytes of "extra" space
6941 ** allocated along with the specified page.
6942 */
6943 void *sqlite3PagerGetExtra(DbPage *pPg){
6944 return pPg->pExtra;
6945 }
6946
6947 /*
6948 ** Get/set the locking-mode for this pager. Parameter eMode must be one
6949 ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
6950 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
6951 ** the locking-mode is set to the value specified.
6952 **
6953 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
6954 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
6955 ** locking-mode.
6956 */
6957 int sqlite3PagerLockingMode(Pager *pPager, int eMode){
6958 assert( eMode==PAGER_LOCKINGMODE_QUERY
6959 || eMode==PAGER_LOCKINGMODE_NORMAL
6960 || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
6961 assert( PAGER_LOCKINGMODE_QUERY<0 );
6962 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
6963 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
6964 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
6965 pPager->exclusiveMode = (u8)eMode;
6966 }
6967 return (int)pPager->exclusiveMode;
6968 }
6969
6970 /*
6971 ** Set the journal-mode for this pager. Parameter eMode must be one of:
6972 **
6973 ** PAGER_JOURNALMODE_DELETE
6974 ** PAGER_JOURNALMODE_TRUNCATE
6975 ** PAGER_JOURNALMODE_PERSIST
6976 ** PAGER_JOURNALMODE_OFF
6977 ** PAGER_JOURNALMODE_MEMORY
6978 ** PAGER_JOURNALMODE_WAL
6979 **
6980 ** The journalmode is set to the value specified if the change is allowed.
6981 ** The change may be disallowed for the following reasons:
6982 **
6983 ** * An in-memory database can only have its journal_mode set to _OFF
6984 ** or _MEMORY.
6985 **
6986 ** * Temporary databases cannot have _WAL journalmode.
6987 **
6988 ** The returned indicate the current (possibly updated) journal-mode.
6989 */
6990 int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
6991 u8 eOld = pPager->journalMode; /* Prior journalmode */
6992
6993 #ifdef SQLITE_DEBUG
6994 /* The print_pager_state() routine is intended to be used by the debugger
6995 ** only. We invoke it once here to suppress a compiler warning. */
6996 print_pager_state(pPager);
6997 #endif
6998
6999
7000 /* The eMode parameter is always valid */
7001 assert( eMode==PAGER_JOURNALMODE_DELETE
7002 || eMode==PAGER_JOURNALMODE_TRUNCATE
7003 || eMode==PAGER_JOURNALMODE_PERSIST
7004 || eMode==PAGER_JOURNALMODE_OFF
7005 || eMode==PAGER_JOURNALMODE_WAL
7006 || eMode==PAGER_JOURNALMODE_MEMORY );
7007
7008 /* This routine is only called from the OP_JournalMode opcode, and
7009 ** the logic there will never allow a temporary file to be changed
7010 ** to WAL mode.
7011 */
7012 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
7013
7014 /* Do allow the journalmode of an in-memory database to be set to
7015 ** anything other than MEMORY or OFF
7016 */
7017 if( MEMDB ){
7018 assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
7019 if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
7020 eMode = eOld;
7021 }
7022 }
7023
7024 if( eMode!=eOld ){
7025
7026 /* Change the journal mode. */
7027 assert( pPager->eState!=PAGER_ERROR );
7028 pPager->journalMode = (u8)eMode;
7029
7030 /* When transistioning from TRUNCATE or PERSIST to any other journal
7031 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
7032 ** delete the journal file.
7033 */
7034 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
7035 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
7036 assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
7037 assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
7038 assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
7039 assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
7040
7041 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
7042 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
7043
7044 /* In this case we would like to delete the journal file. If it is
7045 ** not possible, then that is not a problem. Deleting the journal file
7046 ** here is an optimization only.
7047 **
7048 ** Before deleting the journal file, obtain a RESERVED lock on the
7049 ** database file. This ensures that the journal file is not deleted
7050 ** while it is in use by some other client.
7051 */
7052 sqlite3OsClose(pPager->jfd);
7053 if( pPager->eLock>=RESERVED_LOCK ){
7054 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
7055 }else{
7056 int rc = SQLITE_OK;
7057 int state = pPager->eState;
7058 assert( state==PAGER_OPEN || state==PAGER_READER );
7059 if( state==PAGER_OPEN ){
7060 rc = sqlite3PagerSharedLock(pPager);
7061 }
7062 if( pPager->eState==PAGER_READER ){
7063 assert( rc==SQLITE_OK );
7064 rc = pagerLockDb(pPager, RESERVED_LOCK);
7065 }
7066 if( rc==SQLITE_OK ){
7067 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
7068 }
7069 if( rc==SQLITE_OK && state==PAGER_READER ){
7070 pagerUnlockDb(pPager, SHARED_LOCK);
7071 }else if( state==PAGER_OPEN ){
7072 pager_unlock(pPager);
7073 }
7074 assert( state==pPager->eState );
7075 }
7076 }else if( eMode==PAGER_JOURNALMODE_OFF ){
7077 sqlite3OsClose(pPager->jfd);
7078 }
7079 }
7080
7081 /* Return the new journal mode */
7082 return (int)pPager->journalMode;
7083 }
7084
7085 /*
7086 ** Return the current journal mode.
7087 */
7088 int sqlite3PagerGetJournalMode(Pager *pPager){
7089 return (int)pPager->journalMode;
7090 }
7091
7092 /*
7093 ** Return TRUE if the pager is in a state where it is OK to change the
7094 ** journalmode. Journalmode changes can only happen when the database
7095 ** is unmodified.
7096 */
7097 int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
7098 assert( assert_pager_state(pPager) );
7099 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
7100 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
7101 return 1;
7102 }
7103
7104 /*
7105 ** Get/set the size-limit used for persistent journal files.
7106 **
7107 ** Setting the size limit to -1 means no limit is enforced.
7108 ** An attempt to set a limit smaller than -1 is a no-op.
7109 */
7110 i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
7111 if( iLimit>=-1 ){
7112 pPager->journalSizeLimit = iLimit;
7113 sqlite3WalLimit(pPager->pWal, iLimit);
7114 }
7115 return pPager->journalSizeLimit;
7116 }
7117
7118 /*
7119 ** Return a pointer to the pPager->pBackup variable. The backup module
7120 ** in backup.c maintains the content of this variable. This module
7121 ** uses it opaquely as an argument to sqlite3BackupRestart() and
7122 ** sqlite3BackupUpdate() only.
7123 */
7124 sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
7125 return &pPager->pBackup;
7126 }
7127
7128 #ifndef SQLITE_OMIT_VACUUM
7129 /*
7130 ** Unless this is an in-memory or temporary database, clear the pager cache.
7131 */
7132 void sqlite3PagerClearCache(Pager *pPager){
7133 if( !MEMDB && pPager->tempFile==0 ) pager_reset(pPager);
7134 }
7135 #endif
7136
7137 #ifndef SQLITE_OMIT_WAL
7138 /*
7139 ** This function is called when the user invokes "PRAGMA wal_checkpoint",
7140 ** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
7141 ** or wal_blocking_checkpoint() API functions.
7142 **
7143 ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
7144 */
7145 int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
7146 int rc = SQLITE_OK;
7147 if( pPager->pWal ){
7148 rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
7149 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
7150 pPager->pBusyHandlerArg,
7151 pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
7152 pnLog, pnCkpt
7153 );
7154 }
7155 return rc;
7156 }
7157
7158 int sqlite3PagerWalCallback(Pager *pPager){
7159 return sqlite3WalCallback(pPager->pWal);
7160 }
7161
7162 /*
7163 ** Return true if the underlying VFS for the given pager supports the
7164 ** primitives necessary for write-ahead logging.
7165 */
7166 int sqlite3PagerWalSupported(Pager *pPager){
7167 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
7168 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
7169 }
7170
7171 /*
7172 ** Attempt to take an exclusive lock on the database file. If a PENDING lock
7173 ** is obtained instead, immediately release it.
7174 */
7175 static int pagerExclusiveLock(Pager *pPager){
7176 int rc; /* Return code */
7177
7178 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
7179 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
7180 if( rc!=SQLITE_OK ){
7181 /* If the attempt to grab the exclusive lock failed, release the
7182 ** pending lock that may have been obtained instead. */
7183 pagerUnlockDb(pPager, SHARED_LOCK);
7184 }
7185
7186 return rc;
7187 }
7188
7189 /*
7190 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
7191 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
7192 ** lock on the database file and use heap-memory to store the wal-index
7193 ** in. Otherwise, use the normal shared-memory.
7194 */
7195 static int pagerOpenWal(Pager *pPager){
7196 int rc = SQLITE_OK;
7197
7198 assert( pPager->pWal==0 && pPager->tempFile==0 );
7199 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
7200
7201 /* If the pager is already in exclusive-mode, the WAL module will use
7202 ** heap-memory for the wal-index instead of the VFS shared-memory
7203 ** implementation. Take the exclusive lock now, before opening the WAL
7204 ** file, to make sure this is safe.
7205 */
7206 if( pPager->exclusiveMode ){
7207 rc = pagerExclusiveLock(pPager);
7208 }
7209
7210 /* Open the connection to the log file. If this operation fails,
7211 ** (e.g. due to malloc() failure), return an error code.
7212 */
7213 if( rc==SQLITE_OK ){
7214 rc = sqlite3WalOpen(pPager->pVfs,
7215 pPager->fd, pPager->zWal, pPager->exclusiveMode,
7216 pPager->journalSizeLimit, &pPager->pWal
7217 );
7218 }
7219 pagerFixMaplimit(pPager);
7220
7221 return rc;
7222 }
7223
7224
7225 /*
7226 ** The caller must be holding a SHARED lock on the database file to call
7227 ** this function.
7228 **
7229 ** If the pager passed as the first argument is open on a real database
7230 ** file (not a temp file or an in-memory database), and the WAL file
7231 ** is not already open, make an attempt to open it now. If successful,
7232 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
7233 ** not support the xShmXXX() methods, return an error code. *pbOpen is
7234 ** not modified in either case.
7235 **
7236 ** If the pager is open on a temp-file (or in-memory database), or if
7237 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
7238 ** without doing anything.
7239 */
7240 int sqlite3PagerOpenWal(
7241 Pager *pPager, /* Pager object */
7242 int *pbOpen /* OUT: Set to true if call is a no-op */
7243 ){
7244 int rc = SQLITE_OK; /* Return code */
7245
7246 assert( assert_pager_state(pPager) );
7247 assert( pPager->eState==PAGER_OPEN || pbOpen );
7248 assert( pPager->eState==PAGER_READER || !pbOpen );
7249 assert( pbOpen==0 || *pbOpen==0 );
7250 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
7251
7252 if( !pPager->tempFile && !pPager->pWal ){
7253 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
7254
7255 /* Close any rollback journal previously open */
7256 sqlite3OsClose(pPager->jfd);
7257
7258 rc = pagerOpenWal(pPager);
7259 if( rc==SQLITE_OK ){
7260 pPager->journalMode = PAGER_JOURNALMODE_WAL;
7261 pPager->eState = PAGER_OPEN;
7262 }
7263 }else{
7264 *pbOpen = 1;
7265 }
7266
7267 return rc;
7268 }
7269
7270 /*
7271 ** This function is called to close the connection to the log file prior
7272 ** to switching from WAL to rollback mode.
7273 **
7274 ** Before closing the log file, this function attempts to take an
7275 ** EXCLUSIVE lock on the database file. If this cannot be obtained, an
7276 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
7277 ** If successful, the EXCLUSIVE lock is not released before returning.
7278 */
7279 int sqlite3PagerCloseWal(Pager *pPager){
7280 int rc = SQLITE_OK;
7281
7282 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
7283
7284 /* If the log file is not already open, but does exist in the file-system,
7285 ** it may need to be checkpointed before the connection can switch to
7286 ** rollback mode. Open it now so this can happen.
7287 */
7288 if( !pPager->pWal ){
7289 int logexists = 0;
7290 rc = pagerLockDb(pPager, SHARED_LOCK);
7291 if( rc==SQLITE_OK ){
7292 rc = sqlite3OsAccess(
7293 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
7294 );
7295 }
7296 if( rc==SQLITE_OK && logexists ){
7297 rc = pagerOpenWal(pPager);
7298 }
7299 }
7300
7301 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
7302 ** the database file, the log and log-summary files will be deleted.
7303 */
7304 if( rc==SQLITE_OK && pPager->pWal ){
7305 rc = pagerExclusiveLock(pPager);
7306 if( rc==SQLITE_OK ){
7307 rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
7308 pPager->pageSize, (u8*)pPager->pTmpSpace);
7309 pPager->pWal = 0;
7310 pagerFixMaplimit(pPager);
7311 }
7312 }
7313 return rc;
7314 }
7315
7316 #ifdef SQLITE_ENABLE_SNAPSHOT
7317 /*
7318 ** If this is a WAL database, obtain a snapshot handle for the snapshot
7319 ** currently open. Otherwise, return an error.
7320 */
7321 int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){
7322 int rc = SQLITE_ERROR;
7323 if( pPager->pWal ){
7324 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
7325 }
7326 return rc;
7327 }
7328
7329 /*
7330 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
7331 ** read transaction is opened, attempt to read from the snapshot it
7332 ** identifies. If this is not a WAL database, return an error.
7333 */
7334 int sqlite3PagerSnapshotOpen(Pager *pPager, sqlite3_snapshot *pSnapshot){
7335 int rc = SQLITE_OK;
7336 if( pPager->pWal ){
7337 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
7338 }else{
7339 rc = SQLITE_ERROR;
7340 }
7341 return rc;
7342 }
7343 #endif /* SQLITE_ENABLE_SNAPSHOT */
7344 #endif /* !SQLITE_OMIT_WAL */
7345
7346 #ifdef SQLITE_ENABLE_ZIPVFS
7347 /*
7348 ** A read-lock must be held on the pager when this function is called. If
7349 ** the pager is in WAL mode and the WAL file currently contains one or more
7350 ** frames, return the size in bytes of the page images stored within the
7351 ** WAL frames. Otherwise, if this is not a WAL database or the WAL file
7352 ** is empty, return 0.
7353 */
7354 int sqlite3PagerWalFramesize(Pager *pPager){
7355 assert( pPager->eState>=PAGER_READER );
7356 return sqlite3WalFramesize(pPager->pWal);
7357 }
7358 #endif
7359
7360
7361 #endif /* SQLITE_OMIT_DISKIO */
OLDNEW
« no previous file with comments | « third_party/sqlite/sqlite-src-3100200/src/pager.h ('k') | third_party/sqlite/sqlite-src-3100200/src/parse.y » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698