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