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