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