Annotation of embedaddon/sqlite3/src/pager.c, revision 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