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