4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
13 ** This file contains the implementation of a write-ahead log (WAL) used in
14 ** "journal_mode=WAL" mode.
16 ** WRITE-AHEAD LOG (WAL) FILE FORMAT
18 ** A WAL file consists of a header followed by zero or more "frames".
19 ** Each frame records the revised content of a single page from the
20 ** database file. All changes to the database are recorded by writing
21 ** frames into the WAL. Transactions commit when a frame is written that
22 ** contains a commit marker. A single WAL can and usually does record
23 ** multiple transactions. Periodically, the content of the WAL is
24 ** transferred back into the database file in an operation called a
27 ** A single WAL file can be used multiple times. In other words, the
28 ** WAL can fill up with frames and then be checkpointed and then new
29 ** frames can overwrite the old ones. A WAL always grows from beginning
30 ** toward the end. Checksums and counters attached to each frame are
31 ** used to determine which frames within the WAL are valid and which
32 ** are leftovers from prior checkpoints.
34 ** The WAL header is 32 bytes in size and consists of the following eight
35 ** big-endian 32-bit unsigned integer values:
37 ** 0: Magic number. 0x377f0682 or 0x377f0683
38 ** 4: File format version. Currently 3007000
39 ** 8: Database page size. Example: 1024
40 ** 12: Checkpoint sequence number
41 ** 16: Salt-1, random integer incremented with each checkpoint
42 ** 20: Salt-2, a different random integer changing with each ckpt
43 ** 24: Checksum-1 (first part of checksum for first 24 bytes of header).
44 ** 28: Checksum-2 (second part of checksum for first 24 bytes of header).
46 ** Immediately following the wal-header are zero or more frames. Each
47 ** frame consists of a 24-byte frame-header followed by a <page-size> bytes
48 ** of page data. The frame-header is six big-endian 32-bit unsigned
49 ** integer values, as follows:
52 ** 4: For commit records, the size of the database image in pages
53 ** after the commit. For all other records, zero.
54 ** 8: Salt-1 (copied from the header)
55 ** 12: Salt-2 (copied from the header)
59 ** A frame is considered valid if and only if the following conditions are
62 ** (1) The salt-1 and salt-2 values in the frame-header match
63 ** salt values in the wal-header
65 ** (2) The checksum values in the final 8 bytes of the frame-header
66 ** exactly match the checksum computed consecutively on the
67 ** WAL header and the first 8 bytes and the content of all frames
68 ** up to and including the current frame.
70 ** The checksum is computed using 32-bit big-endian integers if the
71 ** magic number in the first 4 bytes of the WAL is 0x377f0683 and it
72 ** is computed using little-endian if the magic number is 0x377f0682.
73 ** The checksum values are always stored in the frame header in a
74 ** big-endian format regardless of which byte order is used to compute
75 ** the checksum. The checksum is computed by interpreting the input as
76 ** an even number of unsigned 32-bit integers: x[0] through x[N]. The
77 ** algorithm used for the checksum is as follows:
79 ** for i from 0 to n-1 step 2:
84 ** Note that s0 and s1 are both weighted checksums using fibonacci weights
85 ** in reverse order (the largest fibonacci weight occurs on the first element
86 ** of the sequence being summed.) The s1 value spans all 32-bit
87 ** terms of the sequence whereas s0 omits the final term.
89 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
90 ** WAL is transferred into the database, then the database is VFS.xSync-ed.
91 ** The VFS.xSync operations serve as write barriers - all writes launched
92 ** before the xSync must complete before any write that launches after the
95 ** After each checkpoint, the salt-1 value is incremented and the salt-2
96 ** value is randomized. This prevents old and new frames in the WAL from
97 ** being considered valid at the same time and being checkpointing together
102 ** To read a page from the database (call it page number P), a reader
103 ** first checks the WAL to see if it contains page P. If so, then the
104 ** last valid instance of page P that is a followed by a commit frame
105 ** or is a commit frame itself becomes the value read. If the WAL
106 ** contains no copies of page P that are valid and which are a commit
107 ** frame or are followed by a commit frame, then page P is read from
108 ** the database file.
110 ** To start a read transaction, the reader records the index of the last
111 ** valid frame in the WAL. The reader uses this recorded "mxFrame" value
112 ** for all subsequent read operations. New transactions can be appended
113 ** to the WAL, but as long as the reader uses its original mxFrame value
114 ** and ignores the newly appended content, it will see a consistent snapshot
115 ** of the database from a single point in time. This technique allows
116 ** multiple concurrent readers to view different versions of the database
117 ** content simultaneously.
119 ** The reader algorithm in the previous paragraphs works correctly, but
120 ** because frames for page P can appear anywhere within the WAL, the
121 ** reader has to scan the entire WAL looking for page P frames. If the
122 ** WAL is large (multiple megabytes is typical) that scan can be slow,
123 ** and read performance suffers. To overcome this problem, a separate
124 ** data structure called the wal-index is maintained to expedite the
125 ** search for frames of a particular page.
129 ** Conceptually, the wal-index is shared memory, though VFS implementations
130 ** might choose to implement the wal-index using a mmapped file. Because
131 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
132 ** on a network filesystem. All users of the database must be able to
135 ** In the default unix and windows implementation, the wal-index is a mmapped
136 ** file whose name is the database name with a "-shm" suffix added. For that
137 ** reason, the wal-index is sometimes called the "shm" file.
139 ** The wal-index is transient. After a crash, the wal-index can (and should
140 ** be) reconstructed from the original WAL file. In fact, the VFS is required
141 ** to either truncate or zero the header of the wal-index when the last
142 ** connection to it closes. Because the wal-index is transient, it can
143 ** use an architecture-specific format; it does not have to be cross-platform.
144 ** Hence, unlike the database and WAL file formats which store all values
145 ** as big endian, the wal-index can store multi-byte values in the native
146 ** byte order of the host computer.
148 ** The purpose of the wal-index is to answer this question quickly: Given
149 ** a page number P and a maximum frame index M, return the index of the
150 ** last frame in the wal before frame M for page P in the WAL, or return
151 ** NULL if there are no frames for page P in the WAL prior to M.
153 ** The wal-index consists of a header region, followed by an one or
154 ** more index blocks.
156 ** The wal-index header contains the total number of frames within the WAL
157 ** in the mxFrame field.
159 ** Each index block except for the first contains information on
160 ** HASHTABLE_NPAGE frames. The first index block contains information on
161 ** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and
162 ** HASHTABLE_NPAGE are selected so that together the wal-index header and
163 ** first index block are the same size as all other index blocks in the
166 ** Each index block contains two sections, a page-mapping that contains the
167 ** database page number associated with each wal frame, and a hash-table
168 ** that allows readers to query an index block for a specific page number.
169 ** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE
170 ** for the first index block) 32-bit page numbers. The first entry in the
171 ** first index-block contains the database page number corresponding to the
172 ** first frame in the WAL file. The first entry in the second index block
173 ** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in
174 ** the log, and so on.
176 ** The last index block in a wal-index usually contains less than the full
177 ** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers,
178 ** depending on the contents of the WAL file. This does not change the
179 ** allocated size of the page-mapping array - the page-mapping array merely
180 ** contains unused entries.
182 ** Even without using the hash table, the last frame for page P
183 ** can be found by scanning the page-mapping sections of each index block
184 ** starting with the last index block and moving toward the first, and
185 ** within each index block, starting at the end and moving toward the
186 ** beginning. The first entry that equals P corresponds to the frame
187 ** holding the content for that page.
189 ** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers.
190 ** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the
191 ** hash table for each page number in the mapping section, so the hash
192 ** table is never more than half full. The expected number of collisions
193 ** prior to finding a match is 1. Each entry of the hash table is an
194 ** 1-based index of an entry in the mapping section of the same
195 ** index block. Let K be the 1-based index of the largest entry in
196 ** the mapping section. (For index blocks other than the last, K will
197 ** always be exactly HASHTABLE_NPAGE (4096) and for the last index block
198 ** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table
199 ** contain a value of 0.
201 ** To look for page P in the hash table, first compute a hash iKey on
204 ** iKey = (P * 383) % HASHTABLE_NSLOT
206 ** Then start scanning entries of the hash table, starting with iKey
207 ** (wrapping around to the beginning when the end of the hash table is
208 ** reached) until an unused hash slot is found. Let the first unused slot
209 ** be at index iUnused. (iUnused might be less than iKey if there was
210 ** wrap-around.) Because the hash table is never more than half full,
211 ** the search is guaranteed to eventually hit an unused entry. Let
212 ** iMax be the value between iKey and iUnused, closest to iUnused,
213 ** where aHash[iMax]==P. If there is no iMax entry (if there exists
214 ** no hash slot such that aHash[i]==p) then page P is not in the
215 ** current index block. Otherwise the iMax-th mapping entry of the
216 ** current index block corresponds to the last entry that references
219 ** A hash search begins with the last index block and moves toward the
220 ** first index block, looking for entries corresponding to page P. On
221 ** average, only two or three slots in each index block need to be
222 ** examined in order to either find the last entry for page P, or to
223 ** establish that no such entry exists in the block. Each index block
224 ** holds over 4000 entries. So two or three index blocks are sufficient
225 ** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10
226 ** comparisons (on average) suffice to either locate a frame in the
227 ** WAL or to establish that the frame does not exist in the WAL. This
228 ** is much faster than scanning the entire 10MB WAL.
230 ** Note that entries are added in order of increasing K. Hence, one
231 ** reader might be using some value K0 and a second reader that started
232 ** at a later time (after additional transactions were added to the WAL
233 ** and to the wal-index) might be using a different value K1, where K1>K0.
234 ** Both readers can use the same hash table and mapping section to get
235 ** the correct result. There may be entries in the hash table with
236 ** K>K0 but to the first reader, those entries will appear to be unused
237 ** slots in the hash table and so the first reader will get an answer as
238 ** if no values greater than K0 had ever been inserted into the hash table
239 ** in the first place - which is what reader one wants. Meanwhile, the
240 ** second reader using K1 will see additional values that were inserted
241 ** later, which is exactly what reader two wants.
243 ** When a rollback occurs, the value of K is decreased. Hash table entries
244 ** that correspond to frames greater than the new K value are removed
245 ** from the hash table at this point.
247 #ifndef SQLITE_OMIT_WAL
252 ** Trace output macros
254 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
255 int sqlite3WalTrace
= 0;
256 # define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X
262 ** The maximum (and only) versions of the wal and wal-index formats
263 ** that may be interpreted by this version of SQLite.
265 ** If a client begins recovering a WAL file and finds that (a) the checksum
266 ** values in the wal-header are correct and (b) the version field is not
267 ** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN.
269 ** Similarly, if a client successfully reads a wal-index header (i.e. the
270 ** checksum test is successful) and finds that the version field is not
271 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
272 ** returns SQLITE_CANTOPEN.
274 #define WAL_MAX_VERSION 3007000
275 #define WALINDEX_MAX_VERSION 3007000
278 ** Index numbers for various locking bytes. WAL_NREADER is the number
279 ** of available reader locks and should be at least 3. The default
280 ** is SQLITE_SHM_NLOCK==8 and WAL_NREADER==5.
282 ** Technically, the various VFSes are free to implement these locks however
283 ** they see fit. However, compatibility is encouraged so that VFSes can
284 ** interoperate. The standard implemention used on both unix and windows
285 ** is for the index number to indicate a byte offset into the
286 ** WalCkptInfo.aLock[] array in the wal-index header. In other words, all
287 ** locks are on the shm file. The WALINDEX_LOCK_OFFSET constant (which
288 ** should be 120) is the location in the shm file for the first locking
291 #define WAL_WRITE_LOCK 0
292 #define WAL_ALL_BUT_WRITE 1
293 #define WAL_CKPT_LOCK 1
294 #define WAL_RECOVER_LOCK 2
295 #define WAL_READ_LOCK(I) (3+(I))
296 #define WAL_NREADER (SQLITE_SHM_NLOCK-3)
299 /* Object declarations */
300 typedef struct WalIndexHdr WalIndexHdr
;
301 typedef struct WalIterator WalIterator
;
302 typedef struct WalCkptInfo WalCkptInfo
;
306 ** The following object holds a copy of the wal-index header content.
308 ** The actual header in the wal-index consists of two copies of this
309 ** object followed by one instance of the WalCkptInfo object.
310 ** For all versions of SQLite through 3.10.0 and probably beyond,
311 ** the locking bytes (WalCkptInfo.aLock) start at offset 120 and
312 ** the total header size is 136 bytes.
314 ** The szPage value can be any power of 2 between 512 and 32768, inclusive.
315 ** Or it can be 1 to represent a 65536-byte page. The latter case was
316 ** added in 3.7.1 when support for 64K pages was added.
319 u32 iVersion
; /* Wal-index version */
320 u32 unused
; /* Unused (padding) field */
321 u32 iChange
; /* Counter incremented each transaction */
322 u8 isInit
; /* 1 when initialized */
323 u8 bigEndCksum
; /* True if checksums in WAL are big-endian */
324 u16 szPage
; /* Database page size in bytes. 1==64K */
325 u32 mxFrame
; /* Index of last valid frame in the WAL */
326 u32 nPage
; /* Size of database in pages */
327 u32 aFrameCksum
[2]; /* Checksum of last frame in log */
328 u32 aSalt
[2]; /* Two salt values copied from WAL header */
329 u32 aCksum
[2]; /* Checksum over all prior fields */
333 ** A copy of the following object occurs in the wal-index immediately
334 ** following the second copy of the WalIndexHdr. This object stores
335 ** information used by checkpoint.
337 ** nBackfill is the number of frames in the WAL that have been written
338 ** back into the database. (We call the act of moving content from WAL to
339 ** database "backfilling".) The nBackfill number is never greater than
340 ** WalIndexHdr.mxFrame. nBackfill can only be increased by threads
341 ** holding the WAL_CKPT_LOCK lock (which includes a recovery thread).
342 ** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from
343 ** mxFrame back to zero when the WAL is reset.
345 ** nBackfillAttempted is the largest value of nBackfill that a checkpoint
346 ** has attempted to achieve. Normally nBackfill==nBackfillAtempted, however
347 ** the nBackfillAttempted is set before any backfilling is done and the
348 ** nBackfill is only set after all backfilling completes. So if a checkpoint
349 ** crashes, nBackfillAttempted might be larger than nBackfill. The
350 ** WalIndexHdr.mxFrame must never be less than nBackfillAttempted.
352 ** The aLock[] field is a set of bytes used for locking. These bytes should
353 ** never be read or written.
355 ** There is one entry in aReadMark[] for each reader lock. If a reader
356 ** holds read-lock K, then the value in aReadMark[K] is no greater than
357 ** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff)
358 ** for any aReadMark[] means that entry is unused. aReadMark[0] is
359 ** a special case; its value is never used and it exists as a place-holder
360 ** to avoid having to offset aReadMark[] indexs by one. Readers holding
361 ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content
362 ** directly from the database.
364 ** The value of aReadMark[K] may only be changed by a thread that
365 ** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of
366 ** aReadMark[K] cannot changed while there is a reader is using that mark
367 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
369 ** The checkpointer may only transfer frames from WAL to database where
370 ** the frame numbers are less than or equal to every aReadMark[] that is
371 ** in use (that is, every aReadMark[j] for which there is a corresponding
372 ** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the
373 ** largest value and will increase an unused aReadMark[] to mxFrame if there
374 ** is not already an aReadMark[] equal to mxFrame. The exception to the
375 ** previous sentence is when nBackfill equals mxFrame (meaning that everything
376 ** in the WAL has been backfilled into the database) then new readers
377 ** will choose aReadMark[0] which has value 0 and hence such reader will
378 ** get all their all content directly from the database file and ignore
381 ** Writers normally append new frames to the end of the WAL. However,
382 ** if nBackfill equals mxFrame (meaning that all WAL content has been
383 ** written back into the database) and if no readers are using the WAL
384 ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then
385 ** the writer will first "reset" the WAL back to the beginning and start
386 ** writing new content beginning at frame 1.
388 ** We assume that 32-bit loads are atomic and so no locks are needed in
389 ** order to read from any aReadMark[] entries.
392 u32 nBackfill
; /* Number of WAL frames backfilled into DB */
393 u32 aReadMark
[WAL_NREADER
]; /* Reader marks */
394 u8 aLock
[SQLITE_SHM_NLOCK
]; /* Reserved space for locks */
395 u32 nBackfillAttempted
; /* WAL frames perhaps written, or maybe not */
396 u32 notUsed0
; /* Available for future enhancements */
398 #define READMARK_NOT_USED 0xffffffff
401 /* A block of WALINDEX_LOCK_RESERVED bytes beginning at
402 ** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems
403 ** only support mandatory file-locks, we do not read or write data
404 ** from the region of the file on which locks are applied.
406 #define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock))
407 #define WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))
409 /* Size of header before each frame in wal */
410 #define WAL_FRAME_HDRSIZE 24
412 /* Size of write ahead log header, including checksum. */
413 #define WAL_HDRSIZE 32
415 /* WAL magic value. Either this value, or the same value with the least
416 ** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit
417 ** big-endian format in the first 4 bytes of a WAL file.
419 ** If the LSB is set, then the checksums for each frame within the WAL
420 ** file are calculated by treating all data as an array of 32-bit
421 ** big-endian words. Otherwise, they are calculated by interpreting
422 ** all data as 32-bit little-endian words.
424 #define WAL_MAGIC 0x377f0682
427 ** Return the offset of frame iFrame in the write-ahead log file,
428 ** assuming a database page size of szPage bytes. The offset returned
429 ** is to the start of the write-ahead log frame-header.
431 #define walFrameOffset(iFrame, szPage) ( \
432 WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \
436 ** An open write-ahead log file is represented by an instance of the
440 sqlite3_vfs
*pVfs
; /* The VFS used to create pDbFd */
441 sqlite3_file
*pDbFd
; /* File handle for the database file */
442 sqlite3_file
*pWalFd
; /* File handle for WAL file */
443 u32 iCallback
; /* Value to pass to log callback (or 0) */
444 i64 mxWalSize
; /* Truncate WAL to this size upon reset */
445 int nWiData
; /* Size of array apWiData */
446 int szFirstBlock
; /* Size of first block written to WAL file */
447 volatile u32
**apWiData
; /* Pointer to wal-index content in memory */
448 u32 szPage
; /* Database page size */
449 i16 readLock
; /* Which read lock is being held. -1 for none */
450 u8 syncFlags
; /* Flags to use to sync header writes */
451 u8 exclusiveMode
; /* Non-zero if connection is in exclusive mode */
452 u8 writeLock
; /* True if in a write transaction */
453 u8 ckptLock
; /* True if holding a checkpoint lock */
454 u8 readOnly
; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */
455 u8 truncateOnCommit
; /* True to truncate WAL file on commit */
456 u8 syncHeader
; /* Fsync the WAL header if true */
457 u8 padToSectorBoundary
; /* Pad transactions out to the next sector */
458 u8 bShmUnreliable
; /* SHM content is read-only and unreliable */
459 WalIndexHdr hdr
; /* Wal-index header for current transaction */
460 u32 minFrame
; /* Ignore wal frames before this one */
461 u32 iReCksum
; /* On commit, recalculate checksums from here */
462 const char *zWalName
; /* Name of WAL file */
463 u32 nCkpt
; /* Checkpoint sequence counter in the wal-header */
465 u8 lockError
; /* True if a locking error has occurred */
467 #ifdef SQLITE_ENABLE_SNAPSHOT
468 WalIndexHdr
*pSnapshot
; /* Start transaction here if not NULL */
470 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
476 ** Candidate values for Wal.exclusiveMode.
478 #define WAL_NORMAL_MODE 0
479 #define WAL_EXCLUSIVE_MODE 1
480 #define WAL_HEAPMEMORY_MODE 2
483 ** Possible values for WAL.readOnly
485 #define WAL_RDWR 0 /* Normal read/write connection */
486 #define WAL_RDONLY 1 /* The WAL file is readonly */
487 #define WAL_SHM_RDONLY 2 /* The SHM file is readonly */
490 ** Each page of the wal-index mapping contains a hash-table made up of
491 ** an array of HASHTABLE_NSLOT elements of the following type.
496 ** This structure is used to implement an iterator that loops through
497 ** all frames in the WAL in database page order. Where two or more frames
498 ** correspond to the same database page, the iterator visits only the
499 ** frame most recently written to the WAL (in other words, the frame with
500 ** the largest index).
502 ** The internals of this structure are only accessed by:
504 ** walIteratorInit() - Create a new iterator,
505 ** walIteratorNext() - Step an iterator,
506 ** walIteratorFree() - Free an iterator.
508 ** This functionality is used by the checkpoint code (see walCheckpoint()).
511 int iPrior
; /* Last result returned from the iterator */
512 int nSegment
; /* Number of entries in aSegment[] */
514 int iNext
; /* Next slot in aIndex[] not yet returned */
515 ht_slot
*aIndex
; /* i0, i1, i2... such that aPgno[iN] ascend */
516 u32
*aPgno
; /* Array of page numbers. */
517 int nEntry
; /* Nr. of entries in aPgno[] and aIndex[] */
518 int iZero
; /* Frame number associated with aPgno[0] */
519 } aSegment
[1]; /* One for every 32KB page in the wal-index */
523 ** Define the parameters of the hash tables in the wal-index file. There
524 ** is a hash-table following every HASHTABLE_NPAGE page numbers in the
527 ** Changing any of these constants will alter the wal-index format and
528 ** create incompatibilities.
530 #define HASHTABLE_NPAGE 4096 /* Must be power of 2 */
531 #define HASHTABLE_HASH_1 383 /* Should be prime */
532 #define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */
535 ** The block of page numbers associated with the first hash-table in a
536 ** wal-index is smaller than usual. This is so that there is a complete
537 ** hash-table on each aligned 32KB page of the wal-index.
539 #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
541 /* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */
542 #define WALINDEX_PGSZ ( \
543 sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
547 ** Obtain a pointer to the iPage'th page of the wal-index. The wal-index
548 ** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are
549 ** numbered from zero.
551 ** If the wal-index is currently smaller the iPage pages then the size
552 ** of the wal-index might be increased, but only if it is safe to do
553 ** so. It is safe to enlarge the wal-index if pWal->writeLock is true
554 ** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE.
556 ** If this call is successful, *ppPage is set to point to the wal-index
557 ** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,
558 ** then an SQLite error code is returned and *ppPage is set to 0.
560 static SQLITE_NOINLINE
int walIndexPageRealloc(
561 Wal
*pWal
, /* The WAL context */
562 int iPage
, /* The page we seek */
563 volatile u32
**ppPage
/* Write the page pointer here */
567 /* Enlarge the pWal->apWiData[] array if required */
568 if( pWal
->nWiData
<=iPage
){
569 sqlite3_int64 nByte
= sizeof(u32
*)*(iPage
+1);
570 volatile u32
**apNew
;
571 apNew
= (volatile u32
**)sqlite3Realloc((void *)pWal
->apWiData
, nByte
);
574 return SQLITE_NOMEM_BKPT
;
576 memset((void*)&apNew
[pWal
->nWiData
], 0,
577 sizeof(u32
*)*(iPage
+1-pWal
->nWiData
));
578 pWal
->apWiData
= apNew
;
579 pWal
->nWiData
= iPage
+1;
582 /* Request a pointer to the required page from the VFS */
583 assert( pWal
->apWiData
[iPage
]==0 );
584 if( pWal
->exclusiveMode
==WAL_HEAPMEMORY_MODE
){
585 pWal
->apWiData
[iPage
] = (u32
volatile *)sqlite3MallocZero(WALINDEX_PGSZ
);
586 if( !pWal
->apWiData
[iPage
] ) rc
= SQLITE_NOMEM_BKPT
;
588 rc
= sqlite3OsShmMap(pWal
->pDbFd
, iPage
, WALINDEX_PGSZ
,
589 pWal
->writeLock
, (void volatile **)&pWal
->apWiData
[iPage
]
591 assert( pWal
->apWiData
[iPage
]!=0 || rc
!=SQLITE_OK
|| pWal
->writeLock
==0 );
592 testcase( pWal
->apWiData
[iPage
]==0 && rc
==SQLITE_OK
);
593 if( (rc
&0xff)==SQLITE_READONLY
){
594 pWal
->readOnly
|= WAL_SHM_RDONLY
;
595 if( rc
==SQLITE_READONLY
){
601 *ppPage
= pWal
->apWiData
[iPage
];
602 assert( iPage
==0 || *ppPage
|| rc
!=SQLITE_OK
);
605 static int walIndexPage(
606 Wal
*pWal
, /* The WAL context */
607 int iPage
, /* The page we seek */
608 volatile u32
**ppPage
/* Write the page pointer here */
610 if( pWal
->nWiData
<=iPage
|| (*ppPage
= pWal
->apWiData
[iPage
])==0 ){
611 return walIndexPageRealloc(pWal
, iPage
, ppPage
);
617 ** Return a pointer to the WalCkptInfo structure in the wal-index.
619 static volatile WalCkptInfo
*walCkptInfo(Wal
*pWal
){
620 assert( pWal
->nWiData
>0 && pWal
->apWiData
[0] );
621 return (volatile WalCkptInfo
*)&(pWal
->apWiData
[0][sizeof(WalIndexHdr
)/2]);
625 ** Return a pointer to the WalIndexHdr structure in the wal-index.
627 static volatile WalIndexHdr
*walIndexHdr(Wal
*pWal
){
628 assert( pWal
->nWiData
>0 && pWal
->apWiData
[0] );
629 return (volatile WalIndexHdr
*)pWal
->apWiData
[0];
633 ** The argument to this macro must be of type u32. On a little-endian
634 ** architecture, it returns the u32 value that results from interpreting
635 ** the 4 bytes as a big-endian value. On a big-endian architecture, it
636 ** returns the value that would be produced by interpreting the 4 bytes
637 ** of the input value as a little-endian integer.
639 #define BYTESWAP32(x) ( \
640 (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \
641 + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \
645 ** Generate or extend an 8 byte checksum based on the data in
646 ** array aByte[] and the initial values of aIn[0] and aIn[1] (or
647 ** initial values of 0 and 0 if aIn==NULL).
649 ** The checksum is written back into aOut[] before returning.
651 ** nByte must be a positive multiple of 8.
653 static void walChecksumBytes(
654 int nativeCksum
, /* True for native byte-order, false for non-native */
655 u8
*a
, /* Content to be checksummed */
656 int nByte
, /* Bytes of content in a[]. Must be a multiple of 8. */
657 const u32
*aIn
, /* Initial checksum value input */
658 u32
*aOut
/* OUT: Final checksum value output */
661 u32
*aData
= (u32
*)a
;
662 u32
*aEnd
= (u32
*)&a
[nByte
];
672 assert( (nByte
&0x00000007)==0 );
673 assert( nByte
<=65536 );
679 }while( aData
<aEnd
);
682 s1
+= BYTESWAP32(aData
[0]) + s2
;
683 s2
+= BYTESWAP32(aData
[1]) + s1
;
685 }while( aData
<aEnd
);
693 ** If there is the possibility of concurrent access to the SHM file
694 ** from multiple threads and/or processes, then do a memory barrier.
696 static void walShmBarrier(Wal
*pWal
){
697 if( pWal
->exclusiveMode
!=WAL_HEAPMEMORY_MODE
){
698 sqlite3OsShmBarrier(pWal
->pDbFd
);
703 ** Add the SQLITE_NO_TSAN as part of the return-type of a function
704 ** definition as a hint that the function contains constructs that
705 ** might give false-positive TSAN warnings.
707 ** See tag-20200519-1.
709 #if defined(__clang__) && !defined(SQLITE_NO_TSAN)
710 # define SQLITE_NO_TSAN __attribute__((no_sanitize_thread))
712 # define SQLITE_NO_TSAN
716 ** Write the header information in pWal->hdr into the wal-index.
718 ** The checksum on pWal->hdr is updated before it is written.
720 static SQLITE_NO_TSAN
void walIndexWriteHdr(Wal
*pWal
){
721 volatile WalIndexHdr
*aHdr
= walIndexHdr(pWal
);
722 const int nCksum
= offsetof(WalIndexHdr
, aCksum
);
724 assert( pWal
->writeLock
);
725 pWal
->hdr
.isInit
= 1;
726 pWal
->hdr
.iVersion
= WALINDEX_MAX_VERSION
;
727 walChecksumBytes(1, (u8
*)&pWal
->hdr
, nCksum
, 0, pWal
->hdr
.aCksum
);
728 /* Possible TSAN false-positive. See tag-20200519-1 */
729 memcpy((void*)&aHdr
[1], (const void*)&pWal
->hdr
, sizeof(WalIndexHdr
));
731 memcpy((void*)&aHdr
[0], (const void*)&pWal
->hdr
, sizeof(WalIndexHdr
));
735 ** This function encodes a single frame header and writes it to a buffer
736 ** supplied by the caller. A frame-header is made up of a series of
737 ** 4-byte big-endian integers, as follows:
740 ** 4: For commit records, the size of the database image in pages
741 ** after the commit. For all other records, zero.
742 ** 8: Salt-1 (copied from the wal-header)
743 ** 12: Salt-2 (copied from the wal-header)
747 static void walEncodeFrame(
748 Wal
*pWal
, /* The write-ahead log */
749 u32 iPage
, /* Database page number for frame */
750 u32 nTruncate
, /* New db size (or 0 for non-commit frames) */
751 u8
*aData
, /* Pointer to page data */
752 u8
*aFrame
/* OUT: Write encoded frame here */
754 int nativeCksum
; /* True for native byte-order checksums */
755 u32
*aCksum
= pWal
->hdr
.aFrameCksum
;
756 assert( WAL_FRAME_HDRSIZE
==24 );
757 sqlite3Put4byte(&aFrame
[0], iPage
);
758 sqlite3Put4byte(&aFrame
[4], nTruncate
);
759 if( pWal
->iReCksum
==0 ){
760 memcpy(&aFrame
[8], pWal
->hdr
.aSalt
, 8);
762 nativeCksum
= (pWal
->hdr
.bigEndCksum
==SQLITE_BIGENDIAN
);
763 walChecksumBytes(nativeCksum
, aFrame
, 8, aCksum
, aCksum
);
764 walChecksumBytes(nativeCksum
, aData
, pWal
->szPage
, aCksum
, aCksum
);
766 sqlite3Put4byte(&aFrame
[16], aCksum
[0]);
767 sqlite3Put4byte(&aFrame
[20], aCksum
[1]);
769 memset(&aFrame
[8], 0, 16);
774 ** Check to see if the frame with header in aFrame[] and content
775 ** in aData[] is valid. If it is a valid frame, fill *piPage and
776 ** *pnTruncate and return true. Return if the frame is not valid.
778 static int walDecodeFrame(
779 Wal
*pWal
, /* The write-ahead log */
780 u32
*piPage
, /* OUT: Database page number for frame */
781 u32
*pnTruncate
, /* OUT: New db size (or 0 if not commit) */
782 u8
*aData
, /* Pointer to page data (for checksum) */
783 u8
*aFrame
/* Frame data */
785 int nativeCksum
; /* True for native byte-order checksums */
786 u32
*aCksum
= pWal
->hdr
.aFrameCksum
;
787 u32 pgno
; /* Page number of the frame */
788 assert( WAL_FRAME_HDRSIZE
==24 );
790 /* A frame is only valid if the salt values in the frame-header
791 ** match the salt values in the wal-header.
793 if( memcmp(&pWal
->hdr
.aSalt
, &aFrame
[8], 8)!=0 ){
797 /* A frame is only valid if the page number is creater than zero.
799 pgno
= sqlite3Get4byte(&aFrame
[0]);
804 /* A frame is only valid if a checksum of the WAL header,
805 ** all prior frams, the first 16 bytes of this frame-header,
806 ** and the frame-data matches the checksum in the last 8
807 ** bytes of this frame-header.
809 nativeCksum
= (pWal
->hdr
.bigEndCksum
==SQLITE_BIGENDIAN
);
810 walChecksumBytes(nativeCksum
, aFrame
, 8, aCksum
, aCksum
);
811 walChecksumBytes(nativeCksum
, aData
, pWal
->szPage
, aCksum
, aCksum
);
812 if( aCksum
[0]!=sqlite3Get4byte(&aFrame
[16])
813 || aCksum
[1]!=sqlite3Get4byte(&aFrame
[20])
815 /* Checksum failed. */
819 /* If we reach this point, the frame is valid. Return the page number
820 ** and the new database size.
823 *pnTruncate
= sqlite3Get4byte(&aFrame
[4]);
828 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
830 ** Names of locks. This routine is used to provide debugging output and is not
831 ** a part of an ordinary build.
833 static const char *walLockName(int lockIdx
){
834 if( lockIdx
==WAL_WRITE_LOCK
){
836 }else if( lockIdx
==WAL_CKPT_LOCK
){
838 }else if( lockIdx
==WAL_RECOVER_LOCK
){
839 return "RECOVER-LOCK";
841 static char zName
[15];
842 sqlite3_snprintf(sizeof(zName
), zName
, "READ-LOCK[%d]",
843 lockIdx
-WAL_READ_LOCK(0));
847 #endif /*defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */
851 ** Set or release locks on the WAL. Locks are either shared or exclusive.
852 ** A lock cannot be moved directly between shared and exclusive - it must go
853 ** through the unlocked state first.
855 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
857 static int walLockShared(Wal
*pWal
, int lockIdx
){
859 if( pWal
->exclusiveMode
) return SQLITE_OK
;
860 rc
= sqlite3OsShmLock(pWal
->pDbFd
, lockIdx
, 1,
861 SQLITE_SHM_LOCK
| SQLITE_SHM_SHARED
);
862 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal
,
863 walLockName(lockIdx
), rc
? "failed" : "ok"));
864 VVA_ONLY( pWal
->lockError
= (u8
)(rc
!=SQLITE_OK
&& (rc
&0xFF)!=SQLITE_BUSY
); )
867 static void walUnlockShared(Wal
*pWal
, int lockIdx
){
868 if( pWal
->exclusiveMode
) return;
869 (void)sqlite3OsShmLock(pWal
->pDbFd
, lockIdx
, 1,
870 SQLITE_SHM_UNLOCK
| SQLITE_SHM_SHARED
);
871 WALTRACE(("WAL%p: release SHARED-%s\n", pWal
, walLockName(lockIdx
)));
873 static int walLockExclusive(Wal
*pWal
, int lockIdx
, int n
){
875 if( pWal
->exclusiveMode
) return SQLITE_OK
;
876 rc
= sqlite3OsShmLock(pWal
->pDbFd
, lockIdx
, n
,
877 SQLITE_SHM_LOCK
| SQLITE_SHM_EXCLUSIVE
);
878 WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal
,
879 walLockName(lockIdx
), n
, rc
? "failed" : "ok"));
880 VVA_ONLY( pWal
->lockError
= (u8
)(rc
!=SQLITE_OK
&& (rc
&0xFF)!=SQLITE_BUSY
); )
883 static void walUnlockExclusive(Wal
*pWal
, int lockIdx
, int n
){
884 if( pWal
->exclusiveMode
) return;
885 (void)sqlite3OsShmLock(pWal
->pDbFd
, lockIdx
, n
,
886 SQLITE_SHM_UNLOCK
| SQLITE_SHM_EXCLUSIVE
);
887 WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal
,
888 walLockName(lockIdx
), n
));
892 ** Compute a hash on a page number. The resulting hash value must land
893 ** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances
894 ** the hash to the next value in the event of a collision.
896 static int walHash(u32 iPage
){
898 assert( (HASHTABLE_NSLOT
& (HASHTABLE_NSLOT
-1))==0 );
899 return (iPage
*HASHTABLE_HASH_1
) & (HASHTABLE_NSLOT
-1);
901 static int walNextHash(int iPriorHash
){
902 return (iPriorHash
+1)&(HASHTABLE_NSLOT
-1);
906 ** An instance of the WalHashLoc object is used to describe the location
907 ** of a page hash table in the wal-index. This becomes the return value
908 ** from walHashGet().
910 typedef struct WalHashLoc WalHashLoc
;
912 volatile ht_slot
*aHash
; /* Start of the wal-index hash table */
913 volatile u32
*aPgno
; /* aPgno[1] is the page of first frame indexed */
914 u32 iZero
; /* One less than the frame number of first indexed*/
918 ** Return pointers to the hash table and page number array stored on
919 ** page iHash of the wal-index. The wal-index is broken into 32KB pages
920 ** numbered starting from 0.
922 ** Set output variable pLoc->aHash to point to the start of the hash table
923 ** in the wal-index file. Set pLoc->iZero to one less than the frame
924 ** number of the first frame indexed by this hash table. If a
925 ** slot in the hash table is set to N, it refers to frame number
926 ** (pLoc->iZero+N) in the log.
928 ** Finally, set pLoc->aPgno so that pLoc->aPgno[1] is the page number of the
929 ** first frame indexed by the hash table, frame (pLoc->iZero+1).
931 static int walHashGet(
932 Wal
*pWal
, /* WAL handle */
933 int iHash
, /* Find the iHash'th table */
934 WalHashLoc
*pLoc
/* OUT: Hash table location */
936 int rc
; /* Return code */
938 rc
= walIndexPage(pWal
, iHash
, &pLoc
->aPgno
);
939 assert( rc
==SQLITE_OK
|| iHash
>0 );
942 pLoc
->aHash
= (volatile ht_slot
*)&pLoc
->aPgno
[HASHTABLE_NPAGE
];
944 pLoc
->aPgno
= &pLoc
->aPgno
[WALINDEX_HDR_SIZE
/sizeof(u32
)];
947 pLoc
->iZero
= HASHTABLE_NPAGE_ONE
+ (iHash
-1)*HASHTABLE_NPAGE
;
949 pLoc
->aPgno
= &pLoc
->aPgno
[-1];
955 ** Return the number of the wal-index page that contains the hash-table
956 ** and page-number array that contain entries corresponding to WAL frame
957 ** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages
958 ** are numbered starting from 0.
960 static int walFramePage(u32 iFrame
){
961 int iHash
= (iFrame
+HASHTABLE_NPAGE
-HASHTABLE_NPAGE_ONE
-1) / HASHTABLE_NPAGE
;
962 assert( (iHash
==0 || iFrame
>HASHTABLE_NPAGE_ONE
)
963 && (iHash
>=1 || iFrame
<=HASHTABLE_NPAGE_ONE
)
964 && (iHash
<=1 || iFrame
>(HASHTABLE_NPAGE_ONE
+HASHTABLE_NPAGE
))
965 && (iHash
>=2 || iFrame
<=HASHTABLE_NPAGE_ONE
+HASHTABLE_NPAGE
)
966 && (iHash
<=2 || iFrame
>(HASHTABLE_NPAGE_ONE
+2*HASHTABLE_NPAGE
))
972 ** Return the page number associated with frame iFrame in this WAL.
974 static u32
walFramePgno(Wal
*pWal
, u32 iFrame
){
975 int iHash
= walFramePage(iFrame
);
977 return pWal
->apWiData
[0][WALINDEX_HDR_SIZE
/sizeof(u32
) + iFrame
- 1];
979 return pWal
->apWiData
[iHash
][(iFrame
-1-HASHTABLE_NPAGE_ONE
)%HASHTABLE_NPAGE
];
983 ** Remove entries from the hash table that point to WAL slots greater
984 ** than pWal->hdr.mxFrame.
986 ** This function is called whenever pWal->hdr.mxFrame is decreased due
987 ** to a rollback or savepoint.
989 ** At most only the hash table containing pWal->hdr.mxFrame needs to be
990 ** updated. Any later hash tables will be automatically cleared when
991 ** pWal->hdr.mxFrame advances to the point where those hash tables are
994 static void walCleanupHash(Wal
*pWal
){
995 WalHashLoc sLoc
; /* Hash table location */
996 int iLimit
= 0; /* Zero values greater than this */
997 int nByte
; /* Number of bytes to zero in aPgno[] */
998 int i
; /* Used to iterate through aHash[] */
999 int rc
; /* Return code form walHashGet() */
1001 assert( pWal
->writeLock
);
1002 testcase( pWal
->hdr
.mxFrame
==HASHTABLE_NPAGE_ONE
-1 );
1003 testcase( pWal
->hdr
.mxFrame
==HASHTABLE_NPAGE_ONE
);
1004 testcase( pWal
->hdr
.mxFrame
==HASHTABLE_NPAGE_ONE
+1 );
1006 if( pWal
->hdr
.mxFrame
==0 ) return;
1008 /* Obtain pointers to the hash-table and page-number array containing
1009 ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
1010 ** that the page said hash-table and array reside on is already mapped.(1)
1012 assert( pWal
->nWiData
>walFramePage(pWal
->hdr
.mxFrame
) );
1013 assert( pWal
->apWiData
[walFramePage(pWal
->hdr
.mxFrame
)] );
1014 rc
= walHashGet(pWal
, walFramePage(pWal
->hdr
.mxFrame
), &sLoc
);
1015 if( NEVER(rc
) ) return; /* Defense-in-depth, in case (1) above is wrong */
1017 /* Zero all hash-table entries that correspond to frame numbers greater
1018 ** than pWal->hdr.mxFrame.
1020 iLimit
= pWal
->hdr
.mxFrame
- sLoc
.iZero
;
1022 for(i
=0; i
<HASHTABLE_NSLOT
; i
++){
1023 if( sLoc
.aHash
[i
]>iLimit
){
1028 /* Zero the entries in the aPgno array that correspond to frames with
1029 ** frame numbers greater than pWal->hdr.mxFrame.
1031 nByte
= (int)((char *)sLoc
.aHash
- (char *)&sLoc
.aPgno
[iLimit
+1]);
1032 memset((void *)&sLoc
.aPgno
[iLimit
+1], 0, nByte
);
1034 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
1035 /* Verify that the every entry in the mapping region is still reachable
1036 ** via the hash table even after the cleanup.
1039 int j
; /* Loop counter */
1040 int iKey
; /* Hash key */
1041 for(j
=1; j
<=iLimit
; j
++){
1042 for(iKey
=walHash(sLoc
.aPgno
[j
]);sLoc
.aHash
[iKey
];iKey
=walNextHash(iKey
)){
1043 if( sLoc
.aHash
[iKey
]==j
) break;
1045 assert( sLoc
.aHash
[iKey
]==j
);
1048 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
1053 ** Set an entry in the wal-index that will map database page number
1054 ** pPage into WAL frame iFrame.
1056 static int walIndexAppend(Wal
*pWal
, u32 iFrame
, u32 iPage
){
1057 int rc
; /* Return code */
1058 WalHashLoc sLoc
; /* Wal-index hash table location */
1060 rc
= walHashGet(pWal
, walFramePage(iFrame
), &sLoc
);
1062 /* Assuming the wal-index file was successfully mapped, populate the
1063 ** page number array and hash table entry.
1065 if( rc
==SQLITE_OK
){
1066 int iKey
; /* Hash table key */
1067 int idx
; /* Value to write to hash-table slot */
1068 int nCollide
; /* Number of hash collisions */
1070 idx
= iFrame
- sLoc
.iZero
;
1071 assert( idx
<= HASHTABLE_NSLOT
/2 + 1 );
1073 /* If this is the first entry to be added to this hash-table, zero the
1074 ** entire hash table and aPgno[] array before proceeding.
1077 int nByte
= (int)((u8
*)&sLoc
.aHash
[HASHTABLE_NSLOT
]
1078 - (u8
*)&sLoc
.aPgno
[1]);
1079 memset((void*)&sLoc
.aPgno
[1], 0, nByte
);
1082 /* If the entry in aPgno[] is already set, then the previous writer
1083 ** must have exited unexpectedly in the middle of a transaction (after
1084 ** writing one or more dirty pages to the WAL to free up memory).
1085 ** Remove the remnants of that writers uncommitted transaction from
1086 ** the hash-table before writing any new entries.
1088 if( sLoc
.aPgno
[idx
] ){
1089 walCleanupHash(pWal
);
1090 assert( !sLoc
.aPgno
[idx
] );
1093 /* Write the aPgno[] array entry and the hash-table slot. */
1095 for(iKey
=walHash(iPage
); sLoc
.aHash
[iKey
]; iKey
=walNextHash(iKey
)){
1096 if( (nCollide
--)==0 ) return SQLITE_CORRUPT_BKPT
;
1098 sLoc
.aPgno
[idx
] = iPage
;
1099 sLoc
.aHash
[iKey
] = (ht_slot
)idx
;
1101 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
1102 /* Verify that the number of entries in the hash table exactly equals
1103 ** the number of entries in the mapping region.
1106 int i
; /* Loop counter */
1107 int nEntry
= 0; /* Number of entries in the hash table */
1108 for(i
=0; i
<HASHTABLE_NSLOT
; i
++){ if( sLoc
.aHash
[i
] ) nEntry
++; }
1109 assert( nEntry
==idx
);
1112 /* Verify that the every entry in the mapping region is reachable
1113 ** via the hash table. This turns out to be a really, really expensive
1114 ** thing to check, so only do this occasionally - not on every
1117 if( (idx
&0x3ff)==0 ){
1118 int i
; /* Loop counter */
1119 for(i
=1; i
<=idx
; i
++){
1120 for(iKey
=walHash(sLoc
.aPgno
[i
]);
1122 iKey
=walNextHash(iKey
)){
1123 if( sLoc
.aHash
[iKey
]==i
) break;
1125 assert( sLoc
.aHash
[iKey
]==i
);
1128 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
1137 ** Recover the wal-index by reading the write-ahead log file.
1139 ** This routine first tries to establish an exclusive lock on the
1140 ** wal-index to prevent other threads/processes from doing anything
1141 ** with the WAL or wal-index while recovery is running. The
1142 ** WAL_RECOVER_LOCK is also held so that other threads will know
1143 ** that this thread is running recovery. If unable to establish
1144 ** the necessary locks, this routine returns SQLITE_BUSY.
1146 static int walIndexRecover(Wal
*pWal
){
1147 int rc
; /* Return Code */
1148 i64 nSize
; /* Size of log file */
1149 u32 aFrameCksum
[2] = {0, 0};
1150 int iLock
; /* Lock offset to lock for checkpoint */
1152 /* Obtain an exclusive lock on all byte in the locking range not already
1153 ** locked by the caller. The caller is guaranteed to have locked the
1154 ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.
1155 ** If successful, the same bytes that are locked here are unlocked before
1156 ** this function returns.
1158 assert( pWal
->ckptLock
==1 || pWal
->ckptLock
==0 );
1159 assert( WAL_ALL_BUT_WRITE
==WAL_WRITE_LOCK
+1 );
1160 assert( WAL_CKPT_LOCK
==WAL_ALL_BUT_WRITE
);
1161 assert( pWal
->writeLock
);
1162 iLock
= WAL_ALL_BUT_WRITE
+ pWal
->ckptLock
;
1163 rc
= walLockExclusive(pWal
, iLock
, WAL_READ_LOCK(0)-iLock
);
1164 if( rc
==SQLITE_OK
){
1165 rc
= walLockExclusive(pWal
, WAL_READ_LOCK(1), WAL_NREADER
-1);
1166 if( rc
!=SQLITE_OK
){
1167 walUnlockExclusive(pWal
, iLock
, WAL_READ_LOCK(0)-iLock
);
1174 WALTRACE(("WAL%p: recovery begin...\n", pWal
));
1176 memset(&pWal
->hdr
, 0, sizeof(WalIndexHdr
));
1178 rc
= sqlite3OsFileSize(pWal
->pWalFd
, &nSize
);
1179 if( rc
!=SQLITE_OK
){
1180 goto recovery_error
;
1183 if( nSize
>WAL_HDRSIZE
){
1184 u8 aBuf
[WAL_HDRSIZE
]; /* Buffer to load WAL header into */
1185 u8
*aFrame
= 0; /* Malloc'd buffer to load entire frame */
1186 int szFrame
; /* Number of bytes in buffer aFrame[] */
1187 u8
*aData
; /* Pointer to data part of aFrame buffer */
1188 int iFrame
; /* Index of last frame read */
1189 i64 iOffset
; /* Next offset to read from log file */
1190 int szPage
; /* Page size according to the log */
1191 u32 magic
; /* Magic value read from WAL header */
1192 u32 version
; /* Magic value read from WAL header */
1193 int isValid
; /* True if this frame is valid */
1195 /* Read in the WAL header. */
1196 rc
= sqlite3OsRead(pWal
->pWalFd
, aBuf
, WAL_HDRSIZE
, 0);
1197 if( rc
!=SQLITE_OK
){
1198 goto recovery_error
;
1201 /* If the database page size is not a power of two, or is greater than
1202 ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid
1203 ** data. Similarly, if the 'magic' value is invalid, ignore the whole
1206 magic
= sqlite3Get4byte(&aBuf
[0]);
1207 szPage
= sqlite3Get4byte(&aBuf
[8]);
1208 if( (magic
&0xFFFFFFFE)!=WAL_MAGIC
1209 || szPage
&(szPage
-1)
1210 || szPage
>SQLITE_MAX_PAGE_SIZE
1215 pWal
->hdr
.bigEndCksum
= (u8
)(magic
&0x00000001);
1216 pWal
->szPage
= szPage
;
1217 pWal
->nCkpt
= sqlite3Get4byte(&aBuf
[12]);
1218 memcpy(&pWal
->hdr
.aSalt
, &aBuf
[16], 8);
1220 /* Verify that the WAL header checksum is correct */
1221 walChecksumBytes(pWal
->hdr
.bigEndCksum
==SQLITE_BIGENDIAN
,
1222 aBuf
, WAL_HDRSIZE
-2*4, 0, pWal
->hdr
.aFrameCksum
1224 if( pWal
->hdr
.aFrameCksum
[0]!=sqlite3Get4byte(&aBuf
[24])
1225 || pWal
->hdr
.aFrameCksum
[1]!=sqlite3Get4byte(&aBuf
[28])
1230 /* Verify that the version number on the WAL format is one that
1231 ** are able to understand */
1232 version
= sqlite3Get4byte(&aBuf
[4]);
1233 if( version
!=WAL_MAX_VERSION
){
1234 rc
= SQLITE_CANTOPEN_BKPT
;
1238 /* Malloc a buffer to read frames into. */
1239 szFrame
= szPage
+ WAL_FRAME_HDRSIZE
;
1240 aFrame
= (u8
*)sqlite3_malloc64(szFrame
);
1242 rc
= SQLITE_NOMEM_BKPT
;
1243 goto recovery_error
;
1245 aData
= &aFrame
[WAL_FRAME_HDRSIZE
];
1247 /* Read all frames from the log file. */
1249 for(iOffset
=WAL_HDRSIZE
; (iOffset
+szFrame
)<=nSize
; iOffset
+=szFrame
){
1250 u32 pgno
; /* Database page number for frame */
1251 u32 nTruncate
; /* dbsize field from frame header */
1253 /* Read and decode the next log frame. */
1255 rc
= sqlite3OsRead(pWal
->pWalFd
, aFrame
, szFrame
, iOffset
);
1256 if( rc
!=SQLITE_OK
) break;
1257 isValid
= walDecodeFrame(pWal
, &pgno
, &nTruncate
, aData
, aFrame
);
1258 if( !isValid
) break;
1259 rc
= walIndexAppend(pWal
, iFrame
, pgno
);
1260 if( rc
!=SQLITE_OK
) break;
1262 /* If nTruncate is non-zero, this is a commit record. */
1264 pWal
->hdr
.mxFrame
= iFrame
;
1265 pWal
->hdr
.nPage
= nTruncate
;
1266 pWal
->hdr
.szPage
= (u16
)((szPage
&0xff00) | (szPage
>>16));
1267 testcase( szPage
<=32768 );
1268 testcase( szPage
>=65536 );
1269 aFrameCksum
[0] = pWal
->hdr
.aFrameCksum
[0];
1270 aFrameCksum
[1] = pWal
->hdr
.aFrameCksum
[1];
1274 sqlite3_free(aFrame
);
1278 if( rc
==SQLITE_OK
){
1279 volatile WalCkptInfo
*pInfo
;
1281 pWal
->hdr
.aFrameCksum
[0] = aFrameCksum
[0];
1282 pWal
->hdr
.aFrameCksum
[1] = aFrameCksum
[1];
1283 walIndexWriteHdr(pWal
);
1285 /* Reset the checkpoint-header. This is safe because this thread is
1286 ** currently holding locks that exclude all other readers, writers and
1289 pInfo
= walCkptInfo(pWal
);
1290 pInfo
->nBackfill
= 0;
1291 pInfo
->nBackfillAttempted
= pWal
->hdr
.mxFrame
;
1292 pInfo
->aReadMark
[0] = 0;
1293 for(i
=1; i
<WAL_NREADER
; i
++) pInfo
->aReadMark
[i
] = READMARK_NOT_USED
;
1294 if( pWal
->hdr
.mxFrame
) pInfo
->aReadMark
[1] = pWal
->hdr
.mxFrame
;
1296 /* If more than one frame was recovered from the log file, report an
1297 ** event via sqlite3_log(). This is to help with identifying performance
1298 ** problems caused by applications routinely shutting down without
1299 ** checkpointing the log file.
1301 if( pWal
->hdr
.nPage
){
1302 sqlite3_log(SQLITE_NOTICE_RECOVER_WAL
,
1303 "recovered %d frames from WAL file %s",
1304 pWal
->hdr
.mxFrame
, pWal
->zWalName
1310 WALTRACE(("WAL%p: recovery %s\n", pWal
, rc
? "failed" : "ok"));
1311 walUnlockExclusive(pWal
, iLock
, WAL_READ_LOCK(0)-iLock
);
1312 walUnlockExclusive(pWal
, WAL_READ_LOCK(1), WAL_NREADER
-1);
1317 ** Close an open wal-index.
1319 static void walIndexClose(Wal
*pWal
, int isDelete
){
1320 if( pWal
->exclusiveMode
==WAL_HEAPMEMORY_MODE
|| pWal
->bShmUnreliable
){
1322 for(i
=0; i
<pWal
->nWiData
; i
++){
1323 sqlite3_free((void *)pWal
->apWiData
[i
]);
1324 pWal
->apWiData
[i
] = 0;
1327 if( pWal
->exclusiveMode
!=WAL_HEAPMEMORY_MODE
){
1328 sqlite3OsShmUnmap(pWal
->pDbFd
, isDelete
);
1333 ** Open a connection to the WAL file zWalName. The database file must
1334 ** already be opened on connection pDbFd. The buffer that zWalName points
1335 ** to must remain valid for the lifetime of the returned Wal* handle.
1337 ** A SHARED lock should be held on the database file when this function
1338 ** is called. The purpose of this SHARED lock is to prevent any other
1339 ** client from unlinking the WAL or wal-index file. If another process
1340 ** were to do this just after this client opened one of these files, the
1341 ** system would be badly broken.
1343 ** If the log file is successfully opened, SQLITE_OK is returned and
1344 ** *ppWal is set to point to a new WAL handle. If an error occurs,
1345 ** an SQLite error code is returned and *ppWal is left unmodified.
1348 sqlite3_vfs
*pVfs
, /* vfs module to open wal and wal-index */
1349 sqlite3_file
*pDbFd
, /* The open database file */
1350 const char *zWalName
, /* Name of the WAL file */
1351 int bNoShm
, /* True to run in heap-memory mode */
1352 i64 mxWalSize
, /* Truncate WAL to this size on reset */
1353 Wal
**ppWal
/* OUT: Allocated Wal handle */
1355 int rc
; /* Return Code */
1356 Wal
*pRet
; /* Object to allocate and return */
1357 int flags
; /* Flags passed to OsOpen() */
1359 assert( zWalName
&& zWalName
[0] );
1362 /* In the amalgamation, the os_unix.c and os_win.c source files come before
1363 ** this source file. Verify that the #defines of the locking byte offsets
1364 ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.
1365 ** For that matter, if the lock offset ever changes from its initial design
1366 ** value of 120, we need to know that so there is an assert() to check it.
1368 assert( 120==WALINDEX_LOCK_OFFSET
);
1369 assert( 136==WALINDEX_HDR_SIZE
);
1371 assert( WIN_SHM_BASE
==WALINDEX_LOCK_OFFSET
);
1373 #ifdef UNIX_SHM_BASE
1374 assert( UNIX_SHM_BASE
==WALINDEX_LOCK_OFFSET
);
1378 /* Allocate an instance of struct Wal to return. */
1380 pRet
= (Wal
*)sqlite3MallocZero(sizeof(Wal
) + pVfs
->szOsFile
);
1382 return SQLITE_NOMEM_BKPT
;
1386 pRet
->pWalFd
= (sqlite3_file
*)&pRet
[1];
1387 pRet
->pDbFd
= pDbFd
;
1388 pRet
->readLock
= -1;
1389 pRet
->mxWalSize
= mxWalSize
;
1390 pRet
->zWalName
= zWalName
;
1391 pRet
->syncHeader
= 1;
1392 pRet
->padToSectorBoundary
= 1;
1393 pRet
->exclusiveMode
= (bNoShm
? WAL_HEAPMEMORY_MODE
: WAL_NORMAL_MODE
);
1395 /* Open file handle on the write-ahead log file. */
1396 flags
= (SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
|SQLITE_OPEN_WAL
);
1397 rc
= sqlite3OsOpen(pVfs
, zWalName
, pRet
->pWalFd
, flags
, &flags
);
1398 if( rc
==SQLITE_OK
&& flags
&SQLITE_OPEN_READONLY
){
1399 pRet
->readOnly
= WAL_RDONLY
;
1402 if( rc
!=SQLITE_OK
){
1403 walIndexClose(pRet
, 0);
1404 sqlite3OsClose(pRet
->pWalFd
);
1407 int iDC
= sqlite3OsDeviceCharacteristics(pDbFd
);
1408 if( iDC
& SQLITE_IOCAP_SEQUENTIAL
){ pRet
->syncHeader
= 0; }
1409 if( iDC
& SQLITE_IOCAP_POWERSAFE_OVERWRITE
){
1410 pRet
->padToSectorBoundary
= 0;
1413 WALTRACE(("WAL%d: opened\n", pRet
));
1419 ** Change the size to which the WAL file is trucated on each reset.
1421 void sqlite3WalLimit(Wal
*pWal
, i64 iLimit
){
1422 if( pWal
) pWal
->mxWalSize
= iLimit
;
1426 ** Find the smallest page number out of all pages held in the WAL that
1427 ** has not been returned by any prior invocation of this method on the
1428 ** same WalIterator object. Write into *piFrame the frame index where
1429 ** that page was last written into the WAL. Write into *piPage the page
1432 ** Return 0 on success. If there are no pages in the WAL with a page
1433 ** number larger than *piPage, then return 1.
1435 static int walIteratorNext(
1436 WalIterator
*p
, /* Iterator */
1437 u32
*piPage
, /* OUT: The page number of the next page */
1438 u32
*piFrame
/* OUT: Wal frame index of next page */
1440 u32 iMin
; /* Result pgno must be greater than iMin */
1441 u32 iRet
= 0xFFFFFFFF; /* 0xffffffff is never a valid page number */
1442 int i
; /* For looping through segments */
1445 assert( iMin
<0xffffffff );
1446 for(i
=p
->nSegment
-1; i
>=0; i
--){
1447 struct WalSegment
*pSegment
= &p
->aSegment
[i
];
1448 while( pSegment
->iNext
<pSegment
->nEntry
){
1449 u32 iPg
= pSegment
->aPgno
[pSegment
->aIndex
[pSegment
->iNext
]];
1453 *piFrame
= pSegment
->iZero
+ pSegment
->aIndex
[pSegment
->iNext
];
1461 *piPage
= p
->iPrior
= iRet
;
1462 return (iRet
==0xFFFFFFFF);
1466 ** This function merges two sorted lists into a single sorted list.
1468 ** aLeft[] and aRight[] are arrays of indices. The sort key is
1469 ** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following
1470 ** is guaranteed for all J<K:
1472 ** aContent[aLeft[J]] < aContent[aLeft[K]]
1473 ** aContent[aRight[J]] < aContent[aRight[K]]
1475 ** This routine overwrites aRight[] with a new (probably longer) sequence
1476 ** of indices such that the aRight[] contains every index that appears in
1477 ** either aLeft[] or the old aRight[] and such that the second condition
1478 ** above is still met.
1480 ** The aContent[aLeft[X]] values will be unique for all X. And the
1481 ** aContent[aRight[X]] values will be unique too. But there might be
1482 ** one or more combinations of X and Y such that
1484 ** aLeft[X]!=aRight[Y] && aContent[aLeft[X]] == aContent[aRight[Y]]
1486 ** When that happens, omit the aLeft[X] and use the aRight[Y] index.
1488 static void walMerge(
1489 const u32
*aContent
, /* Pages in wal - keys for the sort */
1490 ht_slot
*aLeft
, /* IN: Left hand input list */
1491 int nLeft
, /* IN: Elements in array *paLeft */
1492 ht_slot
**paRight
, /* IN/OUT: Right hand input list */
1493 int *pnRight
, /* IN/OUT: Elements in *paRight */
1494 ht_slot
*aTmp
/* Temporary buffer */
1496 int iLeft
= 0; /* Current index in aLeft */
1497 int iRight
= 0; /* Current index in aRight */
1498 int iOut
= 0; /* Current index in output buffer */
1499 int nRight
= *pnRight
;
1500 ht_slot
*aRight
= *paRight
;
1502 assert( nLeft
>0 && nRight
>0 );
1503 while( iRight
<nRight
|| iLeft
<nLeft
){
1508 && (iRight
>=nRight
|| aContent
[aLeft
[iLeft
]]<aContent
[aRight
[iRight
]])
1510 logpage
= aLeft
[iLeft
++];
1512 logpage
= aRight
[iRight
++];
1514 dbpage
= aContent
[logpage
];
1516 aTmp
[iOut
++] = logpage
;
1517 if( iLeft
<nLeft
&& aContent
[aLeft
[iLeft
]]==dbpage
) iLeft
++;
1519 assert( iLeft
>=nLeft
|| aContent
[aLeft
[iLeft
]]>dbpage
);
1520 assert( iRight
>=nRight
|| aContent
[aRight
[iRight
]]>dbpage
);
1525 memcpy(aLeft
, aTmp
, sizeof(aTmp
[0])*iOut
);
1529 ** Sort the elements in list aList using aContent[] as the sort key.
1530 ** Remove elements with duplicate keys, preferring to keep the
1531 ** larger aList[] values.
1533 ** The aList[] entries are indices into aContent[]. The values in
1534 ** aList[] are to be sorted so that for all J<K:
1536 ** aContent[aList[J]] < aContent[aList[K]]
1538 ** For any X and Y such that
1540 ** aContent[aList[X]] == aContent[aList[Y]]
1542 ** Keep the larger of the two values aList[X] and aList[Y] and discard
1545 static void walMergesort(
1546 const u32
*aContent
, /* Pages in wal */
1547 ht_slot
*aBuffer
, /* Buffer of at least *pnList items to use */
1548 ht_slot
*aList
, /* IN/OUT: List to sort */
1549 int *pnList
/* IN/OUT: Number of elements in aList[] */
1552 int nList
; /* Number of elements in aList */
1553 ht_slot
*aList
; /* Pointer to sub-list content */
1556 const int nList
= *pnList
; /* Size of input list */
1557 int nMerge
= 0; /* Number of elements in list aMerge */
1558 ht_slot
*aMerge
= 0; /* List to be merged */
1559 int iList
; /* Index into input list */
1560 u32 iSub
= 0; /* Index into aSub array */
1561 struct Sublist aSub
[13]; /* Array of sub-lists */
1563 memset(aSub
, 0, sizeof(aSub
));
1564 assert( nList
<=HASHTABLE_NPAGE
&& nList
>0 );
1565 assert( HASHTABLE_NPAGE
==(1<<(ArraySize(aSub
)-1)) );
1567 for(iList
=0; iList
<nList
; iList
++){
1569 aMerge
= &aList
[iList
];
1570 for(iSub
=0; iList
& (1<<iSub
); iSub
++){
1572 assert( iSub
<ArraySize(aSub
) );
1574 assert( p
->aList
&& p
->nList
<=(1<<iSub
) );
1575 assert( p
->aList
==&aList
[iList
&~((2<<iSub
)-1)] );
1576 walMerge(aContent
, p
->aList
, p
->nList
, &aMerge
, &nMerge
, aBuffer
);
1578 aSub
[iSub
].aList
= aMerge
;
1579 aSub
[iSub
].nList
= nMerge
;
1582 for(iSub
++; iSub
<ArraySize(aSub
); iSub
++){
1583 if( nList
& (1<<iSub
) ){
1585 assert( iSub
<ArraySize(aSub
) );
1587 assert( p
->nList
<=(1<<iSub
) );
1588 assert( p
->aList
==&aList
[nList
&~((2<<iSub
)-1)] );
1589 walMerge(aContent
, p
->aList
, p
->nList
, &aMerge
, &nMerge
, aBuffer
);
1592 assert( aMerge
==aList
);
1598 for(i
=1; i
<*pnList
; i
++){
1599 assert( aContent
[aList
[i
]] > aContent
[aList
[i
-1]] );
1606 ** Free an iterator allocated by walIteratorInit().
1608 static void walIteratorFree(WalIterator
*p
){
1613 ** Construct a WalInterator object that can be used to loop over all
1614 ** pages in the WAL following frame nBackfill in ascending order. Frames
1615 ** nBackfill or earlier may be included - excluding them is an optimization
1616 ** only. The caller must hold the checkpoint lock.
1618 ** On success, make *pp point to the newly allocated WalInterator object
1619 ** return SQLITE_OK. Otherwise, return an error code. If this routine
1620 ** returns an error, the value of *pp is undefined.
1622 ** The calling routine should invoke walIteratorFree() to destroy the
1623 ** WalIterator object when it has finished with it.
1625 static int walIteratorInit(Wal
*pWal
, u32 nBackfill
, WalIterator
**pp
){
1626 WalIterator
*p
; /* Return value */
1627 int nSegment
; /* Number of segments to merge */
1628 u32 iLast
; /* Last frame in log */
1629 sqlite3_int64 nByte
; /* Number of bytes to allocate */
1630 int i
; /* Iterator variable */
1631 ht_slot
*aTmp
; /* Temp space used by merge-sort */
1632 int rc
= SQLITE_OK
; /* Return Code */
1634 /* This routine only runs while holding the checkpoint lock. And
1635 ** it only runs if there is actually content in the log (mxFrame>0).
1637 assert( pWal
->ckptLock
&& pWal
->hdr
.mxFrame
>0 );
1638 iLast
= pWal
->hdr
.mxFrame
;
1640 /* Allocate space for the WalIterator object. */
1641 nSegment
= walFramePage(iLast
) + 1;
1642 nByte
= sizeof(WalIterator
)
1643 + (nSegment
-1)*sizeof(struct WalSegment
)
1644 + iLast
*sizeof(ht_slot
);
1645 p
= (WalIterator
*)sqlite3_malloc64(nByte
);
1647 return SQLITE_NOMEM_BKPT
;
1649 memset(p
, 0, nByte
);
1650 p
->nSegment
= nSegment
;
1652 /* Allocate temporary space used by the merge-sort routine. This block
1653 ** of memory will be freed before this function returns.
1655 aTmp
= (ht_slot
*)sqlite3_malloc64(
1656 sizeof(ht_slot
) * (iLast
>HASHTABLE_NPAGE
?HASHTABLE_NPAGE
:iLast
)
1659 rc
= SQLITE_NOMEM_BKPT
;
1662 for(i
=walFramePage(nBackfill
+1); rc
==SQLITE_OK
&& i
<nSegment
; i
++){
1665 rc
= walHashGet(pWal
, i
, &sLoc
);
1666 if( rc
==SQLITE_OK
){
1667 int j
; /* Counter variable */
1668 int nEntry
; /* Number of entries in this segment */
1669 ht_slot
*aIndex
; /* Sorted index for this segment */
1672 if( (i
+1)==nSegment
){
1673 nEntry
= (int)(iLast
- sLoc
.iZero
);
1675 nEntry
= (int)((u32
*)sLoc
.aHash
- (u32
*)sLoc
.aPgno
);
1677 aIndex
= &((ht_slot
*)&p
->aSegment
[p
->nSegment
])[sLoc
.iZero
];
1680 for(j
=0; j
<nEntry
; j
++){
1681 aIndex
[j
] = (ht_slot
)j
;
1683 walMergesort((u32
*)sLoc
.aPgno
, aTmp
, aIndex
, &nEntry
);
1684 p
->aSegment
[i
].iZero
= sLoc
.iZero
;
1685 p
->aSegment
[i
].nEntry
= nEntry
;
1686 p
->aSegment
[i
].aIndex
= aIndex
;
1687 p
->aSegment
[i
].aPgno
= (u32
*)sLoc
.aPgno
;
1692 if( rc
!=SQLITE_OK
){
1700 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
1702 ** Attempt to enable blocking locks. Blocking locks are enabled only if (a)
1703 ** they are supported by the VFS, and (b) the database handle is configured
1704 ** with a busy-timeout. Return 1 if blocking locks are successfully enabled,
1707 static int walEnableBlocking(Wal
*pWal
){
1710 int tmout
= pWal
->db
->busyTimeout
;
1713 rc
= sqlite3OsFileControl(
1714 pWal
->pDbFd
, SQLITE_FCNTL_LOCK_TIMEOUT
, (void*)&tmout
1716 res
= (rc
==SQLITE_OK
);
1723 ** Disable blocking locks.
1725 static void walDisableBlocking(Wal
*pWal
){
1727 sqlite3OsFileControl(pWal
->pDbFd
, SQLITE_FCNTL_LOCK_TIMEOUT
, (void*)&tmout
);
1731 ** If parameter bLock is true, attempt to enable blocking locks, take
1732 ** the WRITER lock, and then disable blocking locks. If blocking locks
1733 ** cannot be enabled, no attempt to obtain the WRITER lock is made. Return
1734 ** an SQLite error code if an error occurs, or SQLITE_OK otherwise. It is not
1735 ** an error if blocking locks can not be enabled.
1737 ** If the bLock parameter is false and the WRITER lock is held, release it.
1739 int sqlite3WalWriteLock(Wal
*pWal
, int bLock
){
1741 assert( pWal
->readLock
<0 || bLock
==0 );
1744 if( walEnableBlocking(pWal
) ){
1745 rc
= walLockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
1746 if( rc
==SQLITE_OK
){
1747 pWal
->writeLock
= 1;
1749 walDisableBlocking(pWal
);
1751 }else if( pWal
->writeLock
){
1752 walUnlockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
1753 pWal
->writeLock
= 0;
1759 ** Set the database handle used to determine if blocking locks are required.
1761 void sqlite3WalDb(Wal
*pWal
, sqlite3
*db
){
1766 ** Take an exclusive WRITE lock. Blocking if so configured.
1768 static int walLockWriter(Wal
*pWal
){
1770 walEnableBlocking(pWal
);
1771 rc
= walLockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
1772 walDisableBlocking(pWal
);
1776 # define walEnableBlocking(x) 0
1777 # define walDisableBlocking(x)
1778 # define walLockWriter(pWal) walLockExclusive((pWal), WAL_WRITE_LOCK, 1)
1779 # define sqlite3WalDb(pWal, db)
1780 #endif /* ifdef SQLITE_ENABLE_SETLK_TIMEOUT */
1784 ** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and
1785 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
1786 ** busy-handler function. Invoke it and retry the lock until either the
1787 ** lock is successfully obtained or the busy-handler returns 0.
1789 static int walBusyLock(
1790 Wal
*pWal
, /* WAL connection */
1791 int (*xBusy
)(void*), /* Function to call when busy */
1792 void *pBusyArg
, /* Context argument for xBusyHandler */
1793 int lockIdx
, /* Offset of first byte to lock */
1794 int n
/* Number of bytes to lock */
1798 rc
= walLockExclusive(pWal
, lockIdx
, n
);
1799 }while( xBusy
&& rc
==SQLITE_BUSY
&& xBusy(pBusyArg
) );
1800 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
1801 if( rc
==SQLITE_BUSY_TIMEOUT
){
1802 walDisableBlocking(pWal
);
1810 ** The cache of the wal-index header must be valid to call this function.
1811 ** Return the page-size in bytes used by the database.
1813 static int walPagesize(Wal
*pWal
){
1814 return (pWal
->hdr
.szPage
&0xfe00) + ((pWal
->hdr
.szPage
&0x0001)<<16);
1818 ** The following is guaranteed when this function is called:
1820 ** a) the WRITER lock is held,
1821 ** b) the entire log file has been checkpointed, and
1822 ** c) any existing readers are reading exclusively from the database
1823 ** file - there are no readers that may attempt to read a frame from
1826 ** This function updates the shared-memory structures so that the next
1827 ** client to write to the database (which may be this one) does so by
1828 ** writing frames into the start of the log file.
1830 ** The value of parameter salt1 is used as the aSalt[1] value in the
1831 ** new wal-index header. It should be passed a pseudo-random value (i.e.
1832 ** one obtained from sqlite3_randomness()).
1834 static void walRestartHdr(Wal
*pWal
, u32 salt1
){
1835 volatile WalCkptInfo
*pInfo
= walCkptInfo(pWal
);
1836 int i
; /* Loop counter */
1837 u32
*aSalt
= pWal
->hdr
.aSalt
; /* Big-endian salt values */
1839 pWal
->hdr
.mxFrame
= 0;
1840 sqlite3Put4byte((u8
*)&aSalt
[0], 1 + sqlite3Get4byte((u8
*)&aSalt
[0]));
1841 memcpy(&pWal
->hdr
.aSalt
[1], &salt1
, 4);
1842 walIndexWriteHdr(pWal
);
1843 AtomicStore(&pInfo
->nBackfill
, 0);
1844 pInfo
->nBackfillAttempted
= 0;
1845 pInfo
->aReadMark
[1] = 0;
1846 for(i
=2; i
<WAL_NREADER
; i
++) pInfo
->aReadMark
[i
] = READMARK_NOT_USED
;
1847 assert( pInfo
->aReadMark
[0]==0 );
1851 ** Copy as much content as we can from the WAL back into the database file
1852 ** in response to an sqlite3_wal_checkpoint() request or the equivalent.
1854 ** The amount of information copies from WAL to database might be limited
1855 ** by active readers. This routine will never overwrite a database page
1856 ** that a concurrent reader might be using.
1858 ** All I/O barrier operations (a.k.a fsyncs) occur in this routine when
1859 ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if
1860 ** checkpoints are always run by a background thread or background
1861 ** process, foreground threads will never block on a lengthy fsync call.
1863 ** Fsync is called on the WAL before writing content out of the WAL and
1864 ** into the database. This ensures that if the new content is persistent
1865 ** in the WAL and can be recovered following a power-loss or hard reset.
1867 ** Fsync is also called on the database file if (and only if) the entire
1868 ** WAL content is copied into the database file. This second fsync makes
1869 ** it safe to delete the WAL since the new content will persist in the
1872 ** This routine uses and updates the nBackfill field of the wal-index header.
1873 ** This is the only routine that will increase the value of nBackfill.
1874 ** (A WAL reset or recovery will revert nBackfill to zero, but not increase
1877 ** The caller must be holding sufficient locks to ensure that no other
1878 ** checkpoint is running (in any other thread or process) at the same
1881 static int walCheckpoint(
1882 Wal
*pWal
, /* Wal connection */
1883 sqlite3
*db
, /* Check for interrupts on this handle */
1884 int eMode
, /* One of PASSIVE, FULL or RESTART */
1885 int (*xBusy
)(void*), /* Function to call when busy */
1886 void *pBusyArg
, /* Context argument for xBusyHandler */
1887 int sync_flags
, /* Flags for OsSync() (or 0) */
1888 u8
*zBuf
/* Temporary buffer to use */
1890 int rc
= SQLITE_OK
; /* Return code */
1891 int szPage
; /* Database page-size */
1892 WalIterator
*pIter
= 0; /* Wal iterator context */
1893 u32 iDbpage
= 0; /* Next database page to write */
1894 u32 iFrame
= 0; /* Wal frame containing data for iDbpage */
1895 u32 mxSafeFrame
; /* Max frame that can be backfilled */
1896 u32 mxPage
; /* Max database page to write */
1897 int i
; /* Loop counter */
1898 volatile WalCkptInfo
*pInfo
; /* The checkpoint status information */
1900 szPage
= walPagesize(pWal
);
1901 testcase( szPage
<=32768 );
1902 testcase( szPage
>=65536 );
1903 pInfo
= walCkptInfo(pWal
);
1904 if( pInfo
->nBackfill
<pWal
->hdr
.mxFrame
){
1906 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
1907 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
1908 assert( eMode
!=SQLITE_CHECKPOINT_PASSIVE
|| xBusy
==0 );
1910 /* Compute in mxSafeFrame the index of the last frame of the WAL that is
1911 ** safe to write into the database. Frames beyond mxSafeFrame might
1912 ** overwrite database pages that are in use by active readers and thus
1913 ** cannot be backfilled from the WAL.
1915 mxSafeFrame
= pWal
->hdr
.mxFrame
;
1916 mxPage
= pWal
->hdr
.nPage
;
1917 for(i
=1; i
<WAL_NREADER
; i
++){
1918 u32 y
= AtomicLoad(pInfo
->aReadMark
+i
);
1919 if( mxSafeFrame
>y
){
1920 assert( y
<=pWal
->hdr
.mxFrame
);
1921 rc
= walBusyLock(pWal
, xBusy
, pBusyArg
, WAL_READ_LOCK(i
), 1);
1922 if( rc
==SQLITE_OK
){
1923 u32 iMark
= (i
==1 ? mxSafeFrame
: READMARK_NOT_USED
);
1924 AtomicStore(pInfo
->aReadMark
+i
, iMark
);
1925 walUnlockExclusive(pWal
, WAL_READ_LOCK(i
), 1);
1926 }else if( rc
==SQLITE_BUSY
){
1930 goto walcheckpoint_out
;
1935 /* Allocate the iterator */
1936 if( pInfo
->nBackfill
<mxSafeFrame
){
1937 rc
= walIteratorInit(pWal
, pInfo
->nBackfill
, &pIter
);
1938 assert( rc
==SQLITE_OK
|| pIter
==0 );
1942 && (rc
= walBusyLock(pWal
,xBusy
,pBusyArg
,WAL_READ_LOCK(0),1))==SQLITE_OK
1944 u32 nBackfill
= pInfo
->nBackfill
;
1946 pInfo
->nBackfillAttempted
= mxSafeFrame
;
1948 /* Sync the WAL to disk */
1949 rc
= sqlite3OsSync(pWal
->pWalFd
, CKPT_SYNC_FLAGS(sync_flags
));
1951 /* If the database may grow as a result of this checkpoint, hint
1952 ** about the eventual size of the db file to the VFS layer.
1954 if( rc
==SQLITE_OK
){
1955 i64 nReq
= ((i64
)mxPage
* szPage
);
1956 i64 nSize
; /* Current size of database file */
1957 sqlite3OsFileControl(pWal
->pDbFd
, SQLITE_FCNTL_CKPT_START
, 0);
1958 rc
= sqlite3OsFileSize(pWal
->pDbFd
, &nSize
);
1959 if( rc
==SQLITE_OK
&& nSize
<nReq
){
1960 sqlite3OsFileControlHint(pWal
->pDbFd
, SQLITE_FCNTL_SIZE_HINT
, &nReq
);
1965 /* Iterate through the contents of the WAL, copying data to the db file */
1966 while( rc
==SQLITE_OK
&& 0==walIteratorNext(pIter
, &iDbpage
, &iFrame
) ){
1968 assert( walFramePgno(pWal
, iFrame
)==iDbpage
);
1969 if( AtomicLoad(&db
->u1
.isInterrupted
) ){
1970 rc
= db
->mallocFailed
? SQLITE_NOMEM_BKPT
: SQLITE_INTERRUPT
;
1973 if( iFrame
<=nBackfill
|| iFrame
>mxSafeFrame
|| iDbpage
>mxPage
){
1976 iOffset
= walFrameOffset(iFrame
, szPage
) + WAL_FRAME_HDRSIZE
;
1977 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
1978 rc
= sqlite3OsRead(pWal
->pWalFd
, zBuf
, szPage
, iOffset
);
1979 if( rc
!=SQLITE_OK
) break;
1980 iOffset
= (iDbpage
-1)*(i64
)szPage
;
1981 testcase( IS_BIG_INT(iOffset
) );
1982 rc
= sqlite3OsWrite(pWal
->pDbFd
, zBuf
, szPage
, iOffset
);
1983 if( rc
!=SQLITE_OK
) break;
1985 sqlite3OsFileControl(pWal
->pDbFd
, SQLITE_FCNTL_CKPT_DONE
, 0);
1987 /* If work was actually accomplished... */
1988 if( rc
==SQLITE_OK
){
1989 if( mxSafeFrame
==walIndexHdr(pWal
)->mxFrame
){
1990 i64 szDb
= pWal
->hdr
.nPage
*(i64
)szPage
;
1991 testcase( IS_BIG_INT(szDb
) );
1992 rc
= sqlite3OsTruncate(pWal
->pDbFd
, szDb
);
1993 if( rc
==SQLITE_OK
){
1994 rc
= sqlite3OsSync(pWal
->pDbFd
, CKPT_SYNC_FLAGS(sync_flags
));
1997 if( rc
==SQLITE_OK
){
1998 AtomicStore(&pInfo
->nBackfill
, mxSafeFrame
);
2002 /* Release the reader lock held while backfilling */
2003 walUnlockExclusive(pWal
, WAL_READ_LOCK(0), 1);
2006 if( rc
==SQLITE_BUSY
){
2007 /* Reset the return code so as not to report a checkpoint failure
2008 ** just because there are active readers. */
2013 /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the
2014 ** entire wal file has been copied into the database file, then block
2015 ** until all readers have finished using the wal file. This ensures that
2016 ** the next process to write to the database restarts the wal file.
2018 if( rc
==SQLITE_OK
&& eMode
!=SQLITE_CHECKPOINT_PASSIVE
){
2019 assert( pWal
->writeLock
);
2020 if( pInfo
->nBackfill
<pWal
->hdr
.mxFrame
){
2022 }else if( eMode
>=SQLITE_CHECKPOINT_RESTART
){
2024 sqlite3_randomness(4, &salt1
);
2025 assert( pInfo
->nBackfill
==pWal
->hdr
.mxFrame
);
2026 rc
= walBusyLock(pWal
, xBusy
, pBusyArg
, WAL_READ_LOCK(1), WAL_NREADER
-1);
2027 if( rc
==SQLITE_OK
){
2028 if( eMode
==SQLITE_CHECKPOINT_TRUNCATE
){
2029 /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as
2030 ** SQLITE_CHECKPOINT_RESTART with the addition that it also
2031 ** truncates the log file to zero bytes just prior to a
2032 ** successful return.
2034 ** In theory, it might be safe to do this without updating the
2035 ** wal-index header in shared memory, as all subsequent reader or
2036 ** writer clients should see that the entire log file has been
2037 ** checkpointed and behave accordingly. This seems unsafe though,
2038 ** as it would leave the system in a state where the contents of
2039 ** the wal-index header do not match the contents of the
2040 ** file-system. To avoid this, update the wal-index header to
2041 ** indicate that the log file contains zero valid frames. */
2042 walRestartHdr(pWal
, salt1
);
2043 rc
= sqlite3OsTruncate(pWal
->pWalFd
, 0);
2045 walUnlockExclusive(pWal
, WAL_READ_LOCK(1), WAL_NREADER
-1);
2051 walIteratorFree(pIter
);
2056 ** If the WAL file is currently larger than nMax bytes in size, truncate
2057 ** it to exactly nMax bytes. If an error occurs while doing so, ignore it.
2059 static void walLimitSize(Wal
*pWal
, i64 nMax
){
2062 sqlite3BeginBenignMalloc();
2063 rx
= sqlite3OsFileSize(pWal
->pWalFd
, &sz
);
2064 if( rx
==SQLITE_OK
&& (sz
> nMax
) ){
2065 rx
= sqlite3OsTruncate(pWal
->pWalFd
, nMax
);
2067 sqlite3EndBenignMalloc();
2069 sqlite3_log(rx
, "cannot limit WAL size: %s", pWal
->zWalName
);
2074 ** Close a connection to a log file.
2076 int sqlite3WalClose(
2077 Wal
*pWal
, /* Wal to close */
2078 sqlite3
*db
, /* For interrupt flag */
2079 int sync_flags
, /* Flags to pass to OsSync() (or 0) */
2081 u8
*zBuf
/* Buffer of at least nBuf bytes */
2085 int isDelete
= 0; /* True to unlink wal and wal-index files */
2087 /* If an EXCLUSIVE lock can be obtained on the database file (using the
2088 ** ordinary, rollback-mode locking methods, this guarantees that the
2089 ** connection associated with this log file is the only connection to
2090 ** the database. In this case checkpoint the database and unlink both
2091 ** the wal and wal-index files.
2093 ** The EXCLUSIVE lock is not released before returning.
2096 && SQLITE_OK
==(rc
= sqlite3OsLock(pWal
->pDbFd
, SQLITE_LOCK_EXCLUSIVE
))
2098 if( pWal
->exclusiveMode
==WAL_NORMAL_MODE
){
2099 pWal
->exclusiveMode
= WAL_EXCLUSIVE_MODE
;
2101 rc
= sqlite3WalCheckpoint(pWal
, db
,
2102 SQLITE_CHECKPOINT_PASSIVE
, 0, 0, sync_flags
, nBuf
, zBuf
, 0, 0
2104 if( rc
==SQLITE_OK
){
2106 sqlite3OsFileControlHint(
2107 pWal
->pDbFd
, SQLITE_FCNTL_PERSIST_WAL
, &bPersist
2110 /* Try to delete the WAL file if the checkpoint completed and
2111 ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
2112 ** mode (!bPersist) */
2114 }else if( pWal
->mxWalSize
>=0 ){
2115 /* Try to truncate the WAL file to zero bytes if the checkpoint
2116 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
2117 ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
2118 ** non-negative value (pWal->mxWalSize>=0). Note that we truncate
2119 ** to zero bytes as truncating to the journal_size_limit might
2120 ** leave a corrupt WAL file on disk. */
2121 walLimitSize(pWal
, 0);
2126 walIndexClose(pWal
, isDelete
);
2127 sqlite3OsClose(pWal
->pWalFd
);
2129 sqlite3BeginBenignMalloc();
2130 sqlite3OsDelete(pWal
->pVfs
, pWal
->zWalName
, 0);
2131 sqlite3EndBenignMalloc();
2133 WALTRACE(("WAL%p: closed\n", pWal
));
2134 sqlite3_free((void *)pWal
->apWiData
);
2141 ** Try to read the wal-index header. Return 0 on success and 1 if
2142 ** there is a problem.
2144 ** The wal-index is in shared memory. Another thread or process might
2145 ** be writing the header at the same time this procedure is trying to
2146 ** read it, which might result in inconsistency. A dirty read is detected
2147 ** by verifying that both copies of the header are the same and also by
2148 ** a checksum on the header.
2150 ** If and only if the read is consistent and the header is different from
2151 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
2152 ** and *pChanged is set to 1.
2154 ** If the checksum cannot be verified return non-zero. If the header
2155 ** is read successfully and the checksum verified, return zero.
2157 static SQLITE_NO_TSAN
int walIndexTryHdr(Wal
*pWal
, int *pChanged
){
2158 u32 aCksum
[2]; /* Checksum on the header content */
2159 WalIndexHdr h1
, h2
; /* Two copies of the header content */
2160 WalIndexHdr
volatile *aHdr
; /* Header in shared memory */
2162 /* The first page of the wal-index must be mapped at this point. */
2163 assert( pWal
->nWiData
>0 && pWal
->apWiData
[0] );
2165 /* Read the header. This might happen concurrently with a write to the
2166 ** same area of shared memory on a different CPU in a SMP,
2167 ** meaning it is possible that an inconsistent snapshot is read
2168 ** from the file. If this happens, return non-zero.
2171 ** There are two copies of the header at the beginning of the wal-index.
2172 ** When reading, read [0] first then [1]. Writes are in the reverse order.
2173 ** Memory barriers are used to prevent the compiler or the hardware from
2174 ** reordering the reads and writes. TSAN and similar tools can sometimes
2175 ** give false-positive warnings about these accesses because the tools do not
2176 ** account for the double-read and the memory barrier. The use of mutexes
2177 ** here would be problematic as the memory being accessed is potentially
2178 ** shared among multiple processes and not all mutex implementions work
2179 ** reliably in that environment.
2181 aHdr
= walIndexHdr(pWal
);
2182 memcpy(&h1
, (void *)&aHdr
[0], sizeof(h1
)); /* Possible TSAN false-positive */
2183 walShmBarrier(pWal
);
2184 memcpy(&h2
, (void *)&aHdr
[1], sizeof(h2
));
2186 if( memcmp(&h1
, &h2
, sizeof(h1
))!=0 ){
2187 return 1; /* Dirty read */
2190 return 1; /* Malformed header - probably all zeros */
2192 walChecksumBytes(1, (u8
*)&h1
, sizeof(h1
)-sizeof(h1
.aCksum
), 0, aCksum
);
2193 if( aCksum
[0]!=h1
.aCksum
[0] || aCksum
[1]!=h1
.aCksum
[1] ){
2194 return 1; /* Checksum does not match */
2197 if( memcmp(&pWal
->hdr
, &h1
, sizeof(WalIndexHdr
)) ){
2199 memcpy(&pWal
->hdr
, &h1
, sizeof(WalIndexHdr
));
2200 pWal
->szPage
= (pWal
->hdr
.szPage
&0xfe00) + ((pWal
->hdr
.szPage
&0x0001)<<16);
2201 testcase( pWal
->szPage
<=32768 );
2202 testcase( pWal
->szPage
>=65536 );
2205 /* The header was successfully read. Return zero. */
2210 ** This is the value that walTryBeginRead returns when it needs to
2213 #define WAL_RETRY (-1)
2216 ** Read the wal-index header from the wal-index and into pWal->hdr.
2217 ** If the wal-header appears to be corrupt, try to reconstruct the
2218 ** wal-index from the WAL before returning.
2220 ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is
2221 ** changed by this operation. If pWal->hdr is unchanged, set *pChanged
2224 ** If the wal-index header is successfully read, return SQLITE_OK.
2225 ** Otherwise an SQLite error code.
2227 static int walIndexReadHdr(Wal
*pWal
, int *pChanged
){
2228 int rc
; /* Return code */
2229 int badHdr
; /* True if a header read failed */
2230 volatile u32
*page0
; /* Chunk of wal-index containing header */
2232 /* Ensure that page 0 of the wal-index (the page that contains the
2233 ** wal-index header) is mapped. Return early if an error occurs here.
2236 rc
= walIndexPage(pWal
, 0, &page0
);
2237 if( rc
!=SQLITE_OK
){
2238 assert( rc
!=SQLITE_READONLY
); /* READONLY changed to OK in walIndexPage */
2239 if( rc
==SQLITE_READONLY_CANTINIT
){
2240 /* The SQLITE_READONLY_CANTINIT return means that the shared-memory
2241 ** was openable but is not writable, and this thread is unable to
2242 ** confirm that another write-capable connection has the shared-memory
2243 ** open, and hence the content of the shared-memory is unreliable,
2244 ** since the shared-memory might be inconsistent with the WAL file
2245 ** and there is no writer on hand to fix it. */
2247 assert( pWal
->writeLock
==0 );
2248 assert( pWal
->readOnly
& WAL_SHM_RDONLY
);
2249 pWal
->bShmUnreliable
= 1;
2250 pWal
->exclusiveMode
= WAL_HEAPMEMORY_MODE
;
2253 return rc
; /* Any other non-OK return is just an error */
2256 /* page0 can be NULL if the SHM is zero bytes in size and pWal->writeLock
2257 ** is zero, which prevents the SHM from growing */
2258 testcase( page0
!=0 );
2260 assert( page0
!=0 || pWal
->writeLock
==0 );
2262 /* If the first page of the wal-index has been mapped, try to read the
2263 ** wal-index header immediately, without holding any lock. This usually
2264 ** works, but may fail if the wal-index header is corrupt or currently
2265 ** being modified by another thread or process.
2267 badHdr
= (page0
? walIndexTryHdr(pWal
, pChanged
) : 1);
2269 /* If the first attempt failed, it might have been due to a race
2270 ** with a writer. So get a WRITE lock and try again.
2273 if( pWal
->bShmUnreliable
==0 && (pWal
->readOnly
& WAL_SHM_RDONLY
) ){
2274 if( SQLITE_OK
==(rc
= walLockShared(pWal
, WAL_WRITE_LOCK
)) ){
2275 walUnlockShared(pWal
, WAL_WRITE_LOCK
);
2276 rc
= SQLITE_READONLY_RECOVERY
;
2279 int bWriteLock
= pWal
->writeLock
;
2280 if( bWriteLock
|| SQLITE_OK
==(rc
= walLockWriter(pWal
)) ){
2281 pWal
->writeLock
= 1;
2282 if( SQLITE_OK
==(rc
= walIndexPage(pWal
, 0, &page0
)) ){
2283 badHdr
= walIndexTryHdr(pWal
, pChanged
);
2285 /* If the wal-index header is still malformed even while holding
2286 ** a WRITE lock, it can only mean that the header is corrupted and
2287 ** needs to be reconstructed. So run recovery to do exactly that.
2289 rc
= walIndexRecover(pWal
);
2293 if( bWriteLock
==0 ){
2294 pWal
->writeLock
= 0;
2295 walUnlockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
2301 /* If the header is read successfully, check the version number to make
2302 ** sure the wal-index was not constructed with some future format that
2303 ** this version of SQLite cannot understand.
2305 if( badHdr
==0 && pWal
->hdr
.iVersion
!=WALINDEX_MAX_VERSION
){
2306 rc
= SQLITE_CANTOPEN_BKPT
;
2308 if( pWal
->bShmUnreliable
){
2309 if( rc
!=SQLITE_OK
){
2310 walIndexClose(pWal
, 0);
2311 pWal
->bShmUnreliable
= 0;
2312 assert( pWal
->nWiData
>0 && pWal
->apWiData
[0]==0 );
2313 /* walIndexRecover() might have returned SHORT_READ if a concurrent
2314 ** writer truncated the WAL out from under it. If that happens, it
2315 ** indicates that a writer has fixed the SHM file for us, so retry */
2316 if( rc
==SQLITE_IOERR_SHORT_READ
) rc
= WAL_RETRY
;
2318 pWal
->exclusiveMode
= WAL_NORMAL_MODE
;
2325 ** Open a transaction in a connection where the shared-memory is read-only
2326 ** and where we cannot verify that there is a separate write-capable connection
2327 ** on hand to keep the shared-memory up-to-date with the WAL file.
2329 ** This can happen, for example, when the shared-memory is implemented by
2330 ** memory-mapping a *-shm file, where a prior writer has shut down and
2331 ** left the *-shm file on disk, and now the present connection is trying
2332 ** to use that database but lacks write permission on the *-shm file.
2333 ** Other scenarios are also possible, depending on the VFS implementation.
2337 ** The *-wal file has been read and an appropriate wal-index has been
2338 ** constructed in pWal->apWiData[] using heap memory instead of shared
2341 ** If this function returns SQLITE_OK, then the read transaction has
2342 ** been successfully opened. In this case output variable (*pChanged)
2343 ** is set to true before returning if the caller should discard the
2344 ** contents of the page cache before proceeding. Or, if it returns
2345 ** WAL_RETRY, then the heap memory wal-index has been discarded and
2346 ** the caller should retry opening the read transaction from the
2347 ** beginning (including attempting to map the *-shm file).
2349 ** If an error occurs, an SQLite error code is returned.
2351 static int walBeginShmUnreliable(Wal
*pWal
, int *pChanged
){
2352 i64 szWal
; /* Size of wal file on disk in bytes */
2353 i64 iOffset
; /* Current offset when reading wal file */
2354 u8 aBuf
[WAL_HDRSIZE
]; /* Buffer to load WAL header into */
2355 u8
*aFrame
= 0; /* Malloc'd buffer to load entire frame */
2356 int szFrame
; /* Number of bytes in buffer aFrame[] */
2357 u8
*aData
; /* Pointer to data part of aFrame buffer */
2358 volatile void *pDummy
; /* Dummy argument for xShmMap */
2359 int rc
; /* Return code */
2360 u32 aSaveCksum
[2]; /* Saved copy of pWal->hdr.aFrameCksum */
2362 assert( pWal
->bShmUnreliable
);
2363 assert( pWal
->readOnly
& WAL_SHM_RDONLY
);
2364 assert( pWal
->nWiData
>0 && pWal
->apWiData
[0] );
2366 /* Take WAL_READ_LOCK(0). This has the effect of preventing any
2367 ** writers from running a checkpoint, but does not stop them
2368 ** from running recovery. */
2369 rc
= walLockShared(pWal
, WAL_READ_LOCK(0));
2370 if( rc
!=SQLITE_OK
){
2371 if( rc
==SQLITE_BUSY
) rc
= WAL_RETRY
;
2372 goto begin_unreliable_shm_out
;
2376 /* Check to see if a separate writer has attached to the shared-memory area,
2377 ** thus making the shared-memory "reliable" again. Do this by invoking
2378 ** the xShmMap() routine of the VFS and looking to see if the return
2379 ** is SQLITE_READONLY instead of SQLITE_READONLY_CANTINIT.
2381 ** If the shared-memory is now "reliable" return WAL_RETRY, which will
2382 ** cause the heap-memory WAL-index to be discarded and the actual
2383 ** shared memory to be used in its place.
2385 ** This step is important because, even though this connection is holding
2386 ** the WAL_READ_LOCK(0) which prevents a checkpoint, a writer might
2387 ** have already checkpointed the WAL file and, while the current
2388 ** is active, wrap the WAL and start overwriting frames that this
2389 ** process wants to use.
2391 ** Once sqlite3OsShmMap() has been called for an sqlite3_file and has
2392 ** returned any SQLITE_READONLY value, it must return only SQLITE_READONLY
2393 ** or SQLITE_READONLY_CANTINIT or some error for all subsequent invocations,
2394 ** even if some external agent does a "chmod" to make the shared-memory
2395 ** writable by us, until sqlite3OsShmUnmap() has been called.
2396 ** This is a requirement on the VFS implementation.
2398 rc
= sqlite3OsShmMap(pWal
->pDbFd
, 0, WALINDEX_PGSZ
, 0, &pDummy
);
2399 assert( rc
!=SQLITE_OK
); /* SQLITE_OK not possible for read-only connection */
2400 if( rc
!=SQLITE_READONLY_CANTINIT
){
2401 rc
= (rc
==SQLITE_READONLY
? WAL_RETRY
: rc
);
2402 goto begin_unreliable_shm_out
;
2405 /* We reach this point only if the real shared-memory is still unreliable.
2406 ** Assume the in-memory WAL-index substitute is correct and load it
2409 memcpy(&pWal
->hdr
, (void*)walIndexHdr(pWal
), sizeof(WalIndexHdr
));
2411 /* Make sure some writer hasn't come in and changed the WAL file out
2412 ** from under us, then disconnected, while we were not looking.
2414 rc
= sqlite3OsFileSize(pWal
->pWalFd
, &szWal
);
2415 if( rc
!=SQLITE_OK
){
2416 goto begin_unreliable_shm_out
;
2418 if( szWal
<WAL_HDRSIZE
){
2419 /* If the wal file is too small to contain a wal-header and the
2420 ** wal-index header has mxFrame==0, then it must be safe to proceed
2421 ** reading the database file only. However, the page cache cannot
2422 ** be trusted, as a read/write connection may have connected, written
2423 ** the db, run a checkpoint, truncated the wal file and disconnected
2424 ** since this client's last read transaction. */
2426 rc
= (pWal
->hdr
.mxFrame
==0 ? SQLITE_OK
: WAL_RETRY
);
2427 goto begin_unreliable_shm_out
;
2430 /* Check the salt keys at the start of the wal file still match. */
2431 rc
= sqlite3OsRead(pWal
->pWalFd
, aBuf
, WAL_HDRSIZE
, 0);
2432 if( rc
!=SQLITE_OK
){
2433 goto begin_unreliable_shm_out
;
2435 if( memcmp(&pWal
->hdr
.aSalt
, &aBuf
[16], 8) ){
2436 /* Some writer has wrapped the WAL file while we were not looking.
2437 ** Return WAL_RETRY which will cause the in-memory WAL-index to be
2440 goto begin_unreliable_shm_out
;
2443 /* Allocate a buffer to read frames into */
2444 szFrame
= pWal
->hdr
.szPage
+ WAL_FRAME_HDRSIZE
;
2445 aFrame
= (u8
*)sqlite3_malloc64(szFrame
);
2447 rc
= SQLITE_NOMEM_BKPT
;
2448 goto begin_unreliable_shm_out
;
2450 aData
= &aFrame
[WAL_FRAME_HDRSIZE
];
2452 /* Check to see if a complete transaction has been appended to the
2453 ** wal file since the heap-memory wal-index was created. If so, the
2454 ** heap-memory wal-index is discarded and WAL_RETRY returned to
2456 aSaveCksum
[0] = pWal
->hdr
.aFrameCksum
[0];
2457 aSaveCksum
[1] = pWal
->hdr
.aFrameCksum
[1];
2458 for(iOffset
=walFrameOffset(pWal
->hdr
.mxFrame
+1, pWal
->hdr
.szPage
);
2459 iOffset
+szFrame
<=szWal
;
2462 u32 pgno
; /* Database page number for frame */
2463 u32 nTruncate
; /* dbsize field from frame header */
2465 /* Read and decode the next log frame. */
2466 rc
= sqlite3OsRead(pWal
->pWalFd
, aFrame
, szFrame
, iOffset
);
2467 if( rc
!=SQLITE_OK
) break;
2468 if( !walDecodeFrame(pWal
, &pgno
, &nTruncate
, aData
, aFrame
) ) break;
2470 /* If nTruncate is non-zero, then a complete transaction has been
2471 ** appended to this wal file. Set rc to WAL_RETRY and break out of
2478 pWal
->hdr
.aFrameCksum
[0] = aSaveCksum
[0];
2479 pWal
->hdr
.aFrameCksum
[1] = aSaveCksum
[1];
2481 begin_unreliable_shm_out
:
2482 sqlite3_free(aFrame
);
2483 if( rc
!=SQLITE_OK
){
2485 for(i
=0; i
<pWal
->nWiData
; i
++){
2486 sqlite3_free((void*)pWal
->apWiData
[i
]);
2487 pWal
->apWiData
[i
] = 0;
2489 pWal
->bShmUnreliable
= 0;
2490 sqlite3WalEndReadTransaction(pWal
);
2497 ** Attempt to start a read transaction. This might fail due to a race or
2498 ** other transient condition. When that happens, it returns WAL_RETRY to
2499 ** indicate to the caller that it is safe to retry immediately.
2501 ** On success return SQLITE_OK. On a permanent failure (such an
2502 ** I/O error or an SQLITE_BUSY because another process is running
2503 ** recovery) return a positive error code.
2505 ** The useWal parameter is true to force the use of the WAL and disable
2506 ** the case where the WAL is bypassed because it has been completely
2507 ** checkpointed. If useWal==0 then this routine calls walIndexReadHdr()
2508 ** to make a copy of the wal-index header into pWal->hdr. If the
2509 ** wal-index header has changed, *pChanged is set to 1 (as an indication
2510 ** to the caller that the local page cache is obsolete and needs to be
2511 ** flushed.) When useWal==1, the wal-index header is assumed to already
2512 ** be loaded and the pChanged parameter is unused.
2514 ** The caller must set the cnt parameter to the number of prior calls to
2515 ** this routine during the current read attempt that returned WAL_RETRY.
2516 ** This routine will start taking more aggressive measures to clear the
2517 ** race conditions after multiple WAL_RETRY returns, and after an excessive
2518 ** number of errors will ultimately return SQLITE_PROTOCOL. The
2519 ** SQLITE_PROTOCOL return indicates that some other process has gone rogue
2520 ** and is not honoring the locking protocol. There is a vanishingly small
2521 ** chance that SQLITE_PROTOCOL could be returned because of a run of really
2522 ** bad luck when there is lots of contention for the wal-index, but that
2523 ** possibility is so small that it can be safely neglected, we believe.
2525 ** On success, this routine obtains a read lock on
2526 ** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is
2527 ** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1)
2528 ** that means the Wal does not hold any read lock. The reader must not
2529 ** access any database page that is modified by a WAL frame up to and
2530 ** including frame number aReadMark[pWal->readLock]. The reader will
2531 ** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0
2532 ** Or if pWal->readLock==0, then the reader will ignore the WAL
2533 ** completely and get all content directly from the database file.
2534 ** If the useWal parameter is 1 then the WAL will never be ignored and
2535 ** this routine will always set pWal->readLock>0 on success.
2536 ** When the read transaction is completed, the caller must release the
2537 ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.
2539 ** This routine uses the nBackfill and aReadMark[] fields of the header
2540 ** to select a particular WAL_READ_LOCK() that strives to let the
2541 ** checkpoint process do as much work as possible. This routine might
2542 ** update values of the aReadMark[] array in the header, but if it does
2543 ** so it takes care to hold an exclusive lock on the corresponding
2544 ** WAL_READ_LOCK() while changing values.
2546 static int walTryBeginRead(Wal
*pWal
, int *pChanged
, int useWal
, int cnt
){
2547 volatile WalCkptInfo
*pInfo
; /* Checkpoint information in wal-index */
2548 u32 mxReadMark
; /* Largest aReadMark[] value */
2549 int mxI
; /* Index of largest aReadMark[] value */
2550 int i
; /* Loop counter */
2551 int rc
= SQLITE_OK
; /* Return code */
2552 u32 mxFrame
; /* Wal frame to lock to */
2554 assert( pWal
->readLock
<0 ); /* Not currently locked */
2556 /* useWal may only be set for read/write connections */
2557 assert( (pWal
->readOnly
& WAL_SHM_RDONLY
)==0 || useWal
==0 );
2559 /* Take steps to avoid spinning forever if there is a protocol error.
2561 ** Circumstances that cause a RETRY should only last for the briefest
2562 ** instances of time. No I/O or other system calls are done while the
2563 ** locks are held, so the locks should not be held for very long. But
2564 ** if we are unlucky, another process that is holding a lock might get
2565 ** paged out or take a page-fault that is time-consuming to resolve,
2566 ** during the few nanoseconds that it is holding the lock. In that case,
2567 ** it might take longer than normal for the lock to free.
2569 ** After 5 RETRYs, we begin calling sqlite3OsSleep(). The first few
2570 ** calls to sqlite3OsSleep() have a delay of 1 microsecond. Really this
2571 ** is more of a scheduler yield than an actual delay. But on the 10th
2572 ** an subsequent retries, the delays start becoming longer and longer,
2573 ** so that on the 100th (and last) RETRY we delay for 323 milliseconds.
2574 ** The total delay time before giving up is less than 10 seconds.
2577 int nDelay
= 1; /* Pause time in microseconds */
2579 VVA_ONLY( pWal
->lockError
= 1; )
2580 return SQLITE_PROTOCOL
;
2582 if( cnt
>=10 ) nDelay
= (cnt
-9)*(cnt
-9)*39;
2583 sqlite3OsSleep(pWal
->pVfs
, nDelay
);
2587 assert( rc
==SQLITE_OK
);
2588 if( pWal
->bShmUnreliable
==0 ){
2589 rc
= walIndexReadHdr(pWal
, pChanged
);
2591 if( rc
==SQLITE_BUSY
){
2592 /* If there is not a recovery running in another thread or process
2593 ** then convert BUSY errors to WAL_RETRY. If recovery is known to
2594 ** be running, convert BUSY to BUSY_RECOVERY. There is a race here
2595 ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
2596 ** would be technically correct. But the race is benign since with
2597 ** WAL_RETRY this routine will be called again and will probably be
2598 ** right on the second iteration.
2600 if( pWal
->apWiData
[0]==0 ){
2601 /* This branch is taken when the xShmMap() method returns SQLITE_BUSY.
2602 ** We assume this is a transient condition, so return WAL_RETRY. The
2603 ** xShmMap() implementation used by the default unix and win32 VFS
2604 ** modules may return SQLITE_BUSY due to a race condition in the
2605 ** code that determines whether or not the shared-memory region
2606 ** must be zeroed before the requested page is returned.
2609 }else if( SQLITE_OK
==(rc
= walLockShared(pWal
, WAL_RECOVER_LOCK
)) ){
2610 walUnlockShared(pWal
, WAL_RECOVER_LOCK
);
2612 }else if( rc
==SQLITE_BUSY
){
2613 rc
= SQLITE_BUSY_RECOVERY
;
2616 if( rc
!=SQLITE_OK
){
2619 else if( pWal
->bShmUnreliable
){
2620 return walBeginShmUnreliable(pWal
, pChanged
);
2624 assert( pWal
->nWiData
>0 );
2625 assert( pWal
->apWiData
[0]!=0 );
2626 pInfo
= walCkptInfo(pWal
);
2627 if( !useWal
&& AtomicLoad(&pInfo
->nBackfill
)==pWal
->hdr
.mxFrame
2628 #ifdef SQLITE_ENABLE_SNAPSHOT
2629 && (pWal
->pSnapshot
==0 || pWal
->hdr
.mxFrame
==0)
2632 /* The WAL has been completely backfilled (or it is empty).
2633 ** and can be safely ignored.
2635 rc
= walLockShared(pWal
, WAL_READ_LOCK(0));
2636 walShmBarrier(pWal
);
2637 if( rc
==SQLITE_OK
){
2638 if( memcmp((void *)walIndexHdr(pWal
), &pWal
->hdr
, sizeof(WalIndexHdr
)) ){
2639 /* It is not safe to allow the reader to continue here if frames
2640 ** may have been appended to the log before READ_LOCK(0) was obtained.
2641 ** When holding READ_LOCK(0), the reader ignores the entire log file,
2642 ** which implies that the database file contains a trustworthy
2643 ** snapshot. Since holding READ_LOCK(0) prevents a checkpoint from
2644 ** happening, this is usually correct.
2646 ** However, if frames have been appended to the log (or if the log
2647 ** is wrapped and written for that matter) before the READ_LOCK(0)
2648 ** is obtained, that is not necessarily true. A checkpointer may
2649 ** have started to backfill the appended frames but crashed before
2650 ** it finished. Leaving a corrupt image in the database file.
2652 walUnlockShared(pWal
, WAL_READ_LOCK(0));
2657 }else if( rc
!=SQLITE_BUSY
){
2662 /* If we get this far, it means that the reader will want to use
2663 ** the WAL to get at content from recent commits. The job now is
2664 ** to select one of the aReadMark[] entries that is closest to
2665 ** but not exceeding pWal->hdr.mxFrame and lock that entry.
2669 mxFrame
= pWal
->hdr
.mxFrame
;
2670 #ifdef SQLITE_ENABLE_SNAPSHOT
2671 if( pWal
->pSnapshot
&& pWal
->pSnapshot
->mxFrame
<mxFrame
){
2672 mxFrame
= pWal
->pSnapshot
->mxFrame
;
2675 for(i
=1; i
<WAL_NREADER
; i
++){
2676 u32 thisMark
= AtomicLoad(pInfo
->aReadMark
+i
);
2677 if( mxReadMark
<=thisMark
&& thisMark
<=mxFrame
){
2678 assert( thisMark
!=READMARK_NOT_USED
);
2679 mxReadMark
= thisMark
;
2683 if( (pWal
->readOnly
& WAL_SHM_RDONLY
)==0
2684 && (mxReadMark
<mxFrame
|| mxI
==0)
2686 for(i
=1; i
<WAL_NREADER
; i
++){
2687 rc
= walLockExclusive(pWal
, WAL_READ_LOCK(i
), 1);
2688 if( rc
==SQLITE_OK
){
2689 AtomicStore(pInfo
->aReadMark
+i
,mxFrame
);
2690 mxReadMark
= mxFrame
;
2692 walUnlockExclusive(pWal
, WAL_READ_LOCK(i
), 1);
2694 }else if( rc
!=SQLITE_BUSY
){
2700 assert( rc
==SQLITE_BUSY
|| (pWal
->readOnly
& WAL_SHM_RDONLY
)!=0 );
2701 return rc
==SQLITE_BUSY
? WAL_RETRY
: SQLITE_READONLY_CANTINIT
;
2704 rc
= walLockShared(pWal
, WAL_READ_LOCK(mxI
));
2706 return rc
==SQLITE_BUSY
? WAL_RETRY
: rc
;
2708 /* Now that the read-lock has been obtained, check that neither the
2709 ** value in the aReadMark[] array or the contents of the wal-index
2710 ** header have changed.
2712 ** It is necessary to check that the wal-index header did not change
2713 ** between the time it was read and when the shared-lock was obtained
2714 ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility
2715 ** that the log file may have been wrapped by a writer, or that frames
2716 ** that occur later in the log than pWal->hdr.mxFrame may have been
2717 ** copied into the database by a checkpointer. If either of these things
2718 ** happened, then reading the database with the current value of
2719 ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry
2722 ** Before checking that the live wal-index header has not changed
2723 ** since it was read, set Wal.minFrame to the first frame in the wal
2724 ** file that has not yet been checkpointed. This client will not need
2725 ** to read any frames earlier than minFrame from the wal file - they
2726 ** can be safely read directly from the database file.
2728 ** Because a ShmBarrier() call is made between taking the copy of
2729 ** nBackfill and checking that the wal-header in shared-memory still
2730 ** matches the one cached in pWal->hdr, it is guaranteed that the
2731 ** checkpointer that set nBackfill was not working with a wal-index
2732 ** header newer than that cached in pWal->hdr. If it were, that could
2733 ** cause a problem. The checkpointer could omit to checkpoint
2734 ** a version of page X that lies before pWal->minFrame (call that version
2735 ** A) on the basis that there is a newer version (version B) of the same
2736 ** page later in the wal file. But if version B happens to like past
2737 ** frame pWal->hdr.mxFrame - then the client would incorrectly assume
2738 ** that it can read version A from the database file. However, since
2739 ** we can guarantee that the checkpointer that set nBackfill could not
2740 ** see any pages past pWal->hdr.mxFrame, this problem does not come up.
2742 pWal
->minFrame
= AtomicLoad(&pInfo
->nBackfill
)+1;
2743 walShmBarrier(pWal
);
2744 if( AtomicLoad(pInfo
->aReadMark
+mxI
)!=mxReadMark
2745 || memcmp((void *)walIndexHdr(pWal
), &pWal
->hdr
, sizeof(WalIndexHdr
))
2747 walUnlockShared(pWal
, WAL_READ_LOCK(mxI
));
2750 assert( mxReadMark
<=pWal
->hdr
.mxFrame
);
2751 pWal
->readLock
= (i16
)mxI
;
2756 #ifdef SQLITE_ENABLE_SNAPSHOT
2758 ** Attempt to reduce the value of the WalCkptInfo.nBackfillAttempted
2759 ** variable so that older snapshots can be accessed. To do this, loop
2760 ** through all wal frames from nBackfillAttempted to (nBackfill+1),
2761 ** comparing their content to the corresponding page with the database
2762 ** file, if any. Set nBackfillAttempted to the frame number of the
2763 ** first frame for which the wal file content matches the db file.
2765 ** This is only really safe if the file-system is such that any page
2766 ** writes made by earlier checkpointers were atomic operations, which
2767 ** is not always true. It is also possible that nBackfillAttempted
2768 ** may be left set to a value larger than expected, if a wal frame
2769 ** contains content that duplicate of an earlier version of the same
2772 ** SQLITE_OK is returned if successful, or an SQLite error code if an
2773 ** error occurs. It is not an error if nBackfillAttempted cannot be
2774 ** decreased at all.
2776 int sqlite3WalSnapshotRecover(Wal
*pWal
){
2779 assert( pWal
->readLock
>=0 );
2780 rc
= walLockExclusive(pWal
, WAL_CKPT_LOCK
, 1);
2781 if( rc
==SQLITE_OK
){
2782 volatile WalCkptInfo
*pInfo
= walCkptInfo(pWal
);
2783 int szPage
= (int)pWal
->szPage
;
2784 i64 szDb
; /* Size of db file in bytes */
2786 rc
= sqlite3OsFileSize(pWal
->pDbFd
, &szDb
);
2787 if( rc
==SQLITE_OK
){
2788 void *pBuf1
= sqlite3_malloc(szPage
);
2789 void *pBuf2
= sqlite3_malloc(szPage
);
2790 if( pBuf1
==0 || pBuf2
==0 ){
2793 u32 i
= pInfo
->nBackfillAttempted
;
2794 for(i
=pInfo
->nBackfillAttempted
; i
>AtomicLoad(&pInfo
->nBackfill
); i
--){
2795 WalHashLoc sLoc
; /* Hash table location */
2796 u32 pgno
; /* Page number in db file */
2797 i64 iDbOff
; /* Offset of db file entry */
2798 i64 iWalOff
; /* Offset of wal file entry */
2800 rc
= walHashGet(pWal
, walFramePage(i
), &sLoc
);
2801 if( rc
!=SQLITE_OK
) break;
2802 pgno
= sLoc
.aPgno
[i
-sLoc
.iZero
];
2803 iDbOff
= (i64
)(pgno
-1) * szPage
;
2805 if( iDbOff
+szPage
<=szDb
){
2806 iWalOff
= walFrameOffset(i
, szPage
) + WAL_FRAME_HDRSIZE
;
2807 rc
= sqlite3OsRead(pWal
->pWalFd
, pBuf1
, szPage
, iWalOff
);
2809 if( rc
==SQLITE_OK
){
2810 rc
= sqlite3OsRead(pWal
->pDbFd
, pBuf2
, szPage
, iDbOff
);
2813 if( rc
!=SQLITE_OK
|| 0==memcmp(pBuf1
, pBuf2
, szPage
) ){
2818 pInfo
->nBackfillAttempted
= i
-1;
2822 sqlite3_free(pBuf1
);
2823 sqlite3_free(pBuf2
);
2825 walUnlockExclusive(pWal
, WAL_CKPT_LOCK
, 1);
2830 #endif /* SQLITE_ENABLE_SNAPSHOT */
2833 ** Begin a read transaction on the database.
2835 ** This routine used to be called sqlite3OpenSnapshot() and with good reason:
2836 ** it takes a snapshot of the state of the WAL and wal-index for the current
2837 ** instant in time. The current thread will continue to use this snapshot.
2838 ** Other threads might append new content to the WAL and wal-index but
2839 ** that extra content is ignored by the current thread.
2841 ** If the database contents have changes since the previous read
2842 ** transaction, then *pChanged is set to 1 before returning. The
2843 ** Pager layer will use this to know that its cache is stale and
2844 ** needs to be flushed.
2846 int sqlite3WalBeginReadTransaction(Wal
*pWal
, int *pChanged
){
2847 int rc
; /* Return code */
2848 int cnt
= 0; /* Number of TryBeginRead attempts */
2850 assert( pWal
->ckptLock
==0 );
2852 #ifdef SQLITE_ENABLE_SNAPSHOT
2854 WalIndexHdr
*pSnapshot
= pWal
->pSnapshot
;
2856 if( memcmp(pSnapshot
, &pWal
->hdr
, sizeof(WalIndexHdr
))!=0 ){
2860 /* It is possible that there is a checkpointer thread running
2861 ** concurrent with this code. If this is the case, it may be that the
2862 ** checkpointer has already determined that it will checkpoint
2863 ** snapshot X, where X is later in the wal file than pSnapshot, but
2864 ** has not yet set the pInfo->nBackfillAttempted variable to indicate
2865 ** its intent. To avoid the race condition this leads to, ensure that
2866 ** there is no checkpointer process by taking a shared CKPT lock
2867 ** before checking pInfo->nBackfillAttempted. */
2868 (void)walEnableBlocking(pWal
);
2869 rc
= walLockShared(pWal
, WAL_CKPT_LOCK
);
2870 walDisableBlocking(pWal
);
2872 if( rc
!=SQLITE_OK
){
2880 rc
= walTryBeginRead(pWal
, pChanged
, 0, ++cnt
);
2881 }while( rc
==WAL_RETRY
);
2882 testcase( (rc
&0xff)==SQLITE_BUSY
);
2883 testcase( (rc
&0xff)==SQLITE_IOERR
);
2884 testcase( rc
==SQLITE_PROTOCOL
);
2885 testcase( rc
==SQLITE_OK
);
2887 #ifdef SQLITE_ENABLE_SNAPSHOT
2888 if( rc
==SQLITE_OK
){
2889 if( pSnapshot
&& memcmp(pSnapshot
, &pWal
->hdr
, sizeof(WalIndexHdr
))!=0 ){
2890 /* At this point the client has a lock on an aReadMark[] slot holding
2891 ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr
2892 ** is populated with the wal-index header corresponding to the head
2893 ** of the wal file. Verify that pSnapshot is still valid before
2894 ** continuing. Reasons why pSnapshot might no longer be valid:
2896 ** (1) The WAL file has been reset since the snapshot was taken.
2897 ** In this case, the salt will have changed.
2899 ** (2) A checkpoint as been attempted that wrote frames past
2900 ** pSnapshot->mxFrame into the database file. Note that the
2901 ** checkpoint need not have completed for this to cause problems.
2903 volatile WalCkptInfo
*pInfo
= walCkptInfo(pWal
);
2905 assert( pWal
->readLock
>0 || pWal
->hdr
.mxFrame
==0 );
2906 assert( pInfo
->aReadMark
[pWal
->readLock
]<=pSnapshot
->mxFrame
);
2908 /* Check that the wal file has not been wrapped. Assuming that it has
2909 ** not, also check that no checkpointer has attempted to checkpoint any
2910 ** frames beyond pSnapshot->mxFrame. If either of these conditions are
2911 ** true, return SQLITE_ERROR_SNAPSHOT. Otherwise, overwrite pWal->hdr
2912 ** with *pSnapshot and set *pChanged as appropriate for opening the
2914 if( !memcmp(pSnapshot
->aSalt
, pWal
->hdr
.aSalt
, sizeof(pWal
->hdr
.aSalt
))
2915 && pSnapshot
->mxFrame
>=pInfo
->nBackfillAttempted
2917 assert( pWal
->readLock
>0 );
2918 memcpy(&pWal
->hdr
, pSnapshot
, sizeof(WalIndexHdr
));
2919 *pChanged
= bChanged
;
2921 rc
= SQLITE_ERROR_SNAPSHOT
;
2924 /* A client using a non-current snapshot may not ignore any frames
2925 ** from the start of the wal file. This is because, for a system
2926 ** where (minFrame < iSnapshot < maxFrame), a checkpointer may
2927 ** have omitted to checkpoint a frame earlier than minFrame in
2928 ** the file because there exists a frame after iSnapshot that
2929 ** is the same database page. */
2932 if( rc
!=SQLITE_OK
){
2933 sqlite3WalEndReadTransaction(pWal
);
2938 /* Release the shared CKPT lock obtained above. */
2939 if( pWal
->ckptLock
){
2940 assert( pSnapshot
);
2941 walUnlockShared(pWal
, WAL_CKPT_LOCK
);
2949 ** Finish with a read transaction. All this does is release the
2952 void sqlite3WalEndReadTransaction(Wal
*pWal
){
2953 sqlite3WalEndWriteTransaction(pWal
);
2954 if( pWal
->readLock
>=0 ){
2955 walUnlockShared(pWal
, WAL_READ_LOCK(pWal
->readLock
));
2956 pWal
->readLock
= -1;
2961 ** Search the wal file for page pgno. If found, set *piRead to the frame that
2962 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
2965 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an
2966 ** error does occur, the final value of *piRead is undefined.
2968 int sqlite3WalFindFrame(
2969 Wal
*pWal
, /* WAL handle */
2970 Pgno pgno
, /* Database page number to read data for */
2971 u32
*piRead
/* OUT: Frame number (or zero) */
2973 u32 iRead
= 0; /* If !=0, WAL frame to return data from */
2974 u32 iLast
= pWal
->hdr
.mxFrame
; /* Last page in WAL for this reader */
2975 int iHash
; /* Used to loop through N hash tables */
2978 /* This routine is only be called from within a read transaction. */
2979 assert( pWal
->readLock
>=0 || pWal
->lockError
);
2981 /* If the "last page" field of the wal-index header snapshot is 0, then
2982 ** no data will be read from the wal under any circumstances. Return early
2983 ** in this case as an optimization. Likewise, if pWal->readLock==0,
2984 ** then the WAL is ignored by the reader so return early, as if the
2987 if( iLast
==0 || (pWal
->readLock
==0 && pWal
->bShmUnreliable
==0) ){
2992 /* Search the hash table or tables for an entry matching page number
2993 ** pgno. Each iteration of the following for() loop searches one
2994 ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames).
2996 ** This code might run concurrently to the code in walIndexAppend()
2997 ** that adds entries to the wal-index (and possibly to this hash
2998 ** table). This means the value just read from the hash
2999 ** slot (aHash[iKey]) may have been added before or after the
3000 ** current read transaction was opened. Values added after the
3001 ** read transaction was opened may have been written incorrectly -
3002 ** i.e. these slots may contain garbage data. However, we assume
3003 ** that any slots written before the current read transaction was
3004 ** opened remain unmodified.
3006 ** For the reasons above, the if(...) condition featured in the inner
3007 ** loop of the following block is more stringent that would be required
3008 ** if we had exclusive access to the hash-table:
3010 ** (aPgno[iFrame]==pgno):
3011 ** This condition filters out normal hash-table collisions.
3014 ** This condition filters out entries that were added to the hash
3015 ** table after the current read-transaction had started.
3017 iMinHash
= walFramePage(pWal
->minFrame
);
3018 for(iHash
=walFramePage(iLast
); iHash
>=iMinHash
; iHash
--){
3019 WalHashLoc sLoc
; /* Hash table location */
3020 int iKey
; /* Hash slot index */
3021 int nCollide
; /* Number of hash collisions remaining */
3022 int rc
; /* Error code */
3025 rc
= walHashGet(pWal
, iHash
, &sLoc
);
3026 if( rc
!=SQLITE_OK
){
3029 nCollide
= HASHTABLE_NSLOT
;
3030 iKey
= walHash(pgno
);
3031 while( (iH
= AtomicLoad(&sLoc
.aHash
[iKey
]))!=0 ){
3032 u32 iFrame
= iH
+ sLoc
.iZero
;
3033 if( iFrame
<=iLast
&& iFrame
>=pWal
->minFrame
&& sLoc
.aPgno
[iH
]==pgno
){
3034 assert( iFrame
>iRead
|| CORRUPT_DB
);
3037 if( (nCollide
--)==0 ){
3038 return SQLITE_CORRUPT_BKPT
;
3040 iKey
= walNextHash(iKey
);
3045 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
3046 /* If expensive assert() statements are available, do a linear search
3047 ** of the wal-index file content. Make sure the results agree with the
3048 ** result obtained using the hash indexes above. */
3052 assert( pWal
->bShmUnreliable
|| pWal
->minFrame
>0 );
3053 for(iTest
=iLast
; iTest
>=pWal
->minFrame
&& iTest
>0; iTest
--){
3054 if( walFramePgno(pWal
, iTest
)==pgno
){
3059 assert( iRead
==iRead2
);
3068 ** Read the contents of frame iRead from the wal file into buffer pOut
3069 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
3070 ** error code otherwise.
3072 int sqlite3WalReadFrame(
3073 Wal
*pWal
, /* WAL handle */
3074 u32 iRead
, /* Frame to read */
3075 int nOut
, /* Size of buffer pOut in bytes */
3076 u8
*pOut
/* Buffer to write page data to */
3080 sz
= pWal
->hdr
.szPage
;
3081 sz
= (sz
&0xfe00) + ((sz
&0x0001)<<16);
3082 testcase( sz
<=32768 );
3083 testcase( sz
>=65536 );
3084 iOffset
= walFrameOffset(iRead
, sz
) + WAL_FRAME_HDRSIZE
;
3085 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
3086 return sqlite3OsRead(pWal
->pWalFd
, pOut
, (nOut
>sz
? sz
: nOut
), iOffset
);
3090 ** Return the size of the database in pages (or zero, if unknown).
3092 Pgno
sqlite3WalDbsize(Wal
*pWal
){
3093 if( pWal
&& ALWAYS(pWal
->readLock
>=0) ){
3094 return pWal
->hdr
.nPage
;
3101 ** This function starts a write transaction on the WAL.
3103 ** A read transaction must have already been started by a prior call
3104 ** to sqlite3WalBeginReadTransaction().
3106 ** If another thread or process has written into the database since
3107 ** the read transaction was started, then it is not possible for this
3108 ** thread to write as doing so would cause a fork. So this routine
3109 ** returns SQLITE_BUSY in that case and no write transaction is started.
3111 ** There can only be a single writer active at a time.
3113 int sqlite3WalBeginWriteTransaction(Wal
*pWal
){
3116 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
3117 /* If the write-lock is already held, then it was obtained before the
3118 ** read-transaction was even opened, making this call a no-op.
3120 if( pWal
->writeLock
){
3121 assert( !memcmp(&pWal
->hdr
,(void *)walIndexHdr(pWal
),sizeof(WalIndexHdr
)) );
3126 /* Cannot start a write transaction without first holding a read
3128 assert( pWal
->readLock
>=0 );
3129 assert( pWal
->writeLock
==0 && pWal
->iReCksum
==0 );
3131 if( pWal
->readOnly
){
3132 return SQLITE_READONLY
;
3135 /* Only one writer allowed at a time. Get the write lock. Return
3136 ** SQLITE_BUSY if unable.
3138 rc
= walLockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
3142 pWal
->writeLock
= 1;
3144 /* If another connection has written to the database file since the
3145 ** time the read transaction on this connection was started, then
3146 ** the write is disallowed.
3148 if( memcmp(&pWal
->hdr
, (void *)walIndexHdr(pWal
), sizeof(WalIndexHdr
))!=0 ){
3149 walUnlockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
3150 pWal
->writeLock
= 0;
3151 rc
= SQLITE_BUSY_SNAPSHOT
;
3158 ** End a write transaction. The commit has already been done. This
3159 ** routine merely releases the lock.
3161 int sqlite3WalEndWriteTransaction(Wal
*pWal
){
3162 if( pWal
->writeLock
){
3163 walUnlockExclusive(pWal
, WAL_WRITE_LOCK
, 1);
3164 pWal
->writeLock
= 0;
3166 pWal
->truncateOnCommit
= 0;
3172 ** If any data has been written (but not committed) to the log file, this
3173 ** function moves the write-pointer back to the start of the transaction.
3175 ** Additionally, the callback function is invoked for each frame written
3176 ** to the WAL since the start of the transaction. If the callback returns
3177 ** other than SQLITE_OK, it is not invoked again and the error code is
3178 ** returned to the caller.
3180 ** Otherwise, if the callback function does not return an error, this
3181 ** function returns SQLITE_OK.
3183 int sqlite3WalUndo(Wal
*pWal
, int (*xUndo
)(void *, Pgno
), void *pUndoCtx
){
3185 if( ALWAYS(pWal
->writeLock
) ){
3186 Pgno iMax
= pWal
->hdr
.mxFrame
;
3189 /* Restore the clients cache of the wal-index header to the state it
3190 ** was in before the client began writing to the database.
3192 memcpy(&pWal
->hdr
, (void *)walIndexHdr(pWal
), sizeof(WalIndexHdr
));
3194 for(iFrame
=pWal
->hdr
.mxFrame
+1;
3195 ALWAYS(rc
==SQLITE_OK
) && iFrame
<=iMax
;
3198 /* This call cannot fail. Unless the page for which the page number
3199 ** is passed as the second argument is (a) in the cache and
3200 ** (b) has an outstanding reference, then xUndo is either a no-op
3201 ** (if (a) is false) or simply expels the page from the cache (if (b)
3204 ** If the upper layer is doing a rollback, it is guaranteed that there
3205 ** are no outstanding references to any page other than page 1. And
3206 ** page 1 is never written to the log until the transaction is
3207 ** committed. As a result, the call to xUndo may not fail.
3209 assert( walFramePgno(pWal
, iFrame
)!=1 );
3210 rc
= xUndo(pUndoCtx
, walFramePgno(pWal
, iFrame
));
3212 if( iMax
!=pWal
->hdr
.mxFrame
) walCleanupHash(pWal
);
3218 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
3219 ** values. This function populates the array with values required to
3220 ** "rollback" the write position of the WAL handle back to the current
3221 ** point in the event of a savepoint rollback (via WalSavepointUndo()).
3223 void sqlite3WalSavepoint(Wal
*pWal
, u32
*aWalData
){
3224 assert( pWal
->writeLock
);
3225 aWalData
[0] = pWal
->hdr
.mxFrame
;
3226 aWalData
[1] = pWal
->hdr
.aFrameCksum
[0];
3227 aWalData
[2] = pWal
->hdr
.aFrameCksum
[1];
3228 aWalData
[3] = pWal
->nCkpt
;
3232 ** Move the write position of the WAL back to the point identified by
3233 ** the values in the aWalData[] array. aWalData must point to an array
3234 ** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated
3235 ** by a call to WalSavepoint().
3237 int sqlite3WalSavepointUndo(Wal
*pWal
, u32
*aWalData
){
3240 assert( pWal
->writeLock
);
3241 assert( aWalData
[3]!=pWal
->nCkpt
|| aWalData
[0]<=pWal
->hdr
.mxFrame
);
3243 if( aWalData
[3]!=pWal
->nCkpt
){
3244 /* This savepoint was opened immediately after the write-transaction
3245 ** was started. Right after that, the writer decided to wrap around
3246 ** to the start of the log. Update the savepoint values to match.
3249 aWalData
[3] = pWal
->nCkpt
;
3252 if( aWalData
[0]<pWal
->hdr
.mxFrame
){
3253 pWal
->hdr
.mxFrame
= aWalData
[0];
3254 pWal
->hdr
.aFrameCksum
[0] = aWalData
[1];
3255 pWal
->hdr
.aFrameCksum
[1] = aWalData
[2];
3256 walCleanupHash(pWal
);
3263 ** This function is called just before writing a set of frames to the log
3264 ** file (see sqlite3WalFrames()). It checks to see if, instead of appending
3265 ** to the current log file, it is possible to overwrite the start of the
3266 ** existing log file with the new frames (i.e. "reset" the log). If so,
3267 ** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left
3270 ** SQLITE_OK is returned if no error is encountered (regardless of whether
3271 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
3272 ** if an error occurs.
3274 static int walRestartLog(Wal
*pWal
){
3278 if( pWal
->readLock
==0 ){
3279 volatile WalCkptInfo
*pInfo
= walCkptInfo(pWal
);
3280 assert( pInfo
->nBackfill
==pWal
->hdr
.mxFrame
);
3281 if( pInfo
->nBackfill
>0 ){
3283 sqlite3_randomness(4, &salt1
);
3284 rc
= walLockExclusive(pWal
, WAL_READ_LOCK(1), WAL_NREADER
-1);
3285 if( rc
==SQLITE_OK
){
3286 /* If all readers are using WAL_READ_LOCK(0) (in other words if no
3287 ** readers are currently using the WAL), then the transactions
3288 ** frames will overwrite the start of the existing log. Update the
3289 ** wal-index header to reflect this.
3291 ** In theory it would be Ok to update the cache of the header only
3292 ** at this point. But updating the actual wal-index header is also
3293 ** safe and means there is no special case for sqlite3WalUndo()
3294 ** to handle if this transaction is rolled back. */
3295 walRestartHdr(pWal
, salt1
);
3296 walUnlockExclusive(pWal
, WAL_READ_LOCK(1), WAL_NREADER
-1);
3297 }else if( rc
!=SQLITE_BUSY
){
3301 walUnlockShared(pWal
, WAL_READ_LOCK(0));
3302 pWal
->readLock
= -1;
3306 rc
= walTryBeginRead(pWal
, ¬Used
, 1, ++cnt
);
3307 }while( rc
==WAL_RETRY
);
3308 assert( (rc
&0xff)!=SQLITE_BUSY
); /* BUSY not possible when useWal==1 */
3309 testcase( (rc
&0xff)==SQLITE_IOERR
);
3310 testcase( rc
==SQLITE_PROTOCOL
);
3311 testcase( rc
==SQLITE_OK
);
3317 ** Information about the current state of the WAL file and where
3318 ** the next fsync should occur - passed from sqlite3WalFrames() into
3321 typedef struct WalWriter
{
3322 Wal
*pWal
; /* The complete WAL information */
3323 sqlite3_file
*pFd
; /* The WAL file to which we write */
3324 sqlite3_int64 iSyncPoint
; /* Fsync at this offset */
3325 int syncFlags
; /* Flags for the fsync */
3326 int szPage
; /* Size of one page */
3330 ** Write iAmt bytes of content into the WAL file beginning at iOffset.
3331 ** Do a sync when crossing the p->iSyncPoint boundary.
3333 ** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt,
3334 ** first write the part before iSyncPoint, then sync, then write the
3337 static int walWriteToLog(
3338 WalWriter
*p
, /* WAL to write to */
3339 void *pContent
, /* Content to be written */
3340 int iAmt
, /* Number of bytes to write */
3341 sqlite3_int64 iOffset
/* Start writing at this offset */
3344 if( iOffset
<p
->iSyncPoint
&& iOffset
+iAmt
>=p
->iSyncPoint
){
3345 int iFirstAmt
= (int)(p
->iSyncPoint
- iOffset
);
3346 rc
= sqlite3OsWrite(p
->pFd
, pContent
, iFirstAmt
, iOffset
);
3348 iOffset
+= iFirstAmt
;
3350 pContent
= (void*)(iFirstAmt
+ (char*)pContent
);
3351 assert( WAL_SYNC_FLAGS(p
->syncFlags
)!=0 );
3352 rc
= sqlite3OsSync(p
->pFd
, WAL_SYNC_FLAGS(p
->syncFlags
));
3353 if( iAmt
==0 || rc
) return rc
;
3355 rc
= sqlite3OsWrite(p
->pFd
, pContent
, iAmt
, iOffset
);
3360 ** Write out a single frame of the WAL
3362 static int walWriteOneFrame(
3363 WalWriter
*p
, /* Where to write the frame */
3364 PgHdr
*pPage
, /* The page of the frame to be written */
3365 int nTruncate
, /* The commit flag. Usually 0. >0 for commit */
3366 sqlite3_int64 iOffset
/* Byte offset at which to write */
3368 int rc
; /* Result code from subfunctions */
3369 void *pData
; /* Data actually written */
3370 u8 aFrame
[WAL_FRAME_HDRSIZE
]; /* Buffer to assemble frame-header in */
3371 pData
= pPage
->pData
;
3372 walEncodeFrame(p
->pWal
, pPage
->pgno
, nTruncate
, pData
, aFrame
);
3373 rc
= walWriteToLog(p
, aFrame
, sizeof(aFrame
), iOffset
);
3375 /* Write the page data */
3376 rc
= walWriteToLog(p
, pData
, p
->szPage
, iOffset
+sizeof(aFrame
));
3381 ** This function is called as part of committing a transaction within which
3382 ** one or more frames have been overwritten. It updates the checksums for
3383 ** all frames written to the wal file by the current transaction starting
3384 ** with the earliest to have been overwritten.
3386 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
3388 static int walRewriteChecksums(Wal
*pWal
, u32 iLast
){
3389 const int szPage
= pWal
->szPage
;/* Database page size */
3390 int rc
= SQLITE_OK
; /* Return code */
3391 u8
*aBuf
; /* Buffer to load data from wal file into */
3392 u8 aFrame
[WAL_FRAME_HDRSIZE
]; /* Buffer to assemble frame-headers in */
3393 u32 iRead
; /* Next frame to read from wal file */
3396 aBuf
= sqlite3_malloc(szPage
+ WAL_FRAME_HDRSIZE
);
3397 if( aBuf
==0 ) return SQLITE_NOMEM_BKPT
;
3399 /* Find the checksum values to use as input for the recalculating the
3400 ** first checksum. If the first frame is frame 1 (implying that the current
3401 ** transaction restarted the wal file), these values must be read from the
3402 ** wal-file header. Otherwise, read them from the frame header of the
3403 ** previous frame. */
3404 assert( pWal
->iReCksum
>0 );
3405 if( pWal
->iReCksum
==1 ){
3408 iCksumOff
= walFrameOffset(pWal
->iReCksum
-1, szPage
) + 16;
3410 rc
= sqlite3OsRead(pWal
->pWalFd
, aBuf
, sizeof(u32
)*2, iCksumOff
);
3411 pWal
->hdr
.aFrameCksum
[0] = sqlite3Get4byte(aBuf
);
3412 pWal
->hdr
.aFrameCksum
[1] = sqlite3Get4byte(&aBuf
[sizeof(u32
)]);
3414 iRead
= pWal
->iReCksum
;
3416 for(; rc
==SQLITE_OK
&& iRead
<=iLast
; iRead
++){
3417 i64 iOff
= walFrameOffset(iRead
, szPage
);
3418 rc
= sqlite3OsRead(pWal
->pWalFd
, aBuf
, szPage
+WAL_FRAME_HDRSIZE
, iOff
);
3419 if( rc
==SQLITE_OK
){
3421 iPgno
= sqlite3Get4byte(aBuf
);
3422 nDbSize
= sqlite3Get4byte(&aBuf
[4]);
3424 walEncodeFrame(pWal
, iPgno
, nDbSize
, &aBuf
[WAL_FRAME_HDRSIZE
], aFrame
);
3425 rc
= sqlite3OsWrite(pWal
->pWalFd
, aFrame
, sizeof(aFrame
), iOff
);
3434 ** Write a set of frames to the log. The caller must hold the write-lock
3435 ** on the log file (obtained using sqlite3WalBeginWriteTransaction()).
3437 int sqlite3WalFrames(
3438 Wal
*pWal
, /* Wal handle to write to */
3439 int szPage
, /* Database page-size in bytes */
3440 PgHdr
*pList
, /* List of dirty pages to write */
3441 Pgno nTruncate
, /* Database size after this commit */
3442 int isCommit
, /* True if this is a commit */
3443 int sync_flags
/* Flags to pass to OsSync() (or 0) */
3445 int rc
; /* Used to catch return codes */
3446 u32 iFrame
; /* Next frame address */
3447 PgHdr
*p
; /* Iterator to run through pList with. */
3448 PgHdr
*pLast
= 0; /* Last frame in list */
3449 int nExtra
= 0; /* Number of extra copies of last page */
3450 int szFrame
; /* The size of a single frame */
3451 i64 iOffset
; /* Next byte to write in WAL file */
3452 WalWriter w
; /* The writer */
3453 u32 iFirst
= 0; /* First frame that may be overwritten */
3454 WalIndexHdr
*pLive
; /* Pointer to shared header */
3457 assert( pWal
->writeLock
);
3459 /* If this frame set completes a transaction, then nTruncate>0. If
3460 ** nTruncate==0 then this frame set does not complete the transaction. */
3461 assert( (isCommit
!=0)==(nTruncate
!=0) );
3463 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
3464 { int cnt
; for(cnt
=0, p
=pList
; p
; p
=p
->pDirty
, cnt
++){}
3465 WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n",
3466 pWal
, cnt
, pWal
->hdr
.mxFrame
, isCommit
? "Commit" : "Spill"));
3470 pLive
= (WalIndexHdr
*)walIndexHdr(pWal
);
3471 if( memcmp(&pWal
->hdr
, (void *)pLive
, sizeof(WalIndexHdr
))!=0 ){
3472 iFirst
= pLive
->mxFrame
+1;
3475 /* See if it is possible to write these frames into the start of the
3476 ** log file, instead of appending to it at pWal->hdr.mxFrame.
3478 if( SQLITE_OK
!=(rc
= walRestartLog(pWal
)) ){
3482 /* If this is the first frame written into the log, write the WAL
3483 ** header to the start of the WAL file. See comments at the top of
3484 ** this source file for a description of the WAL header format.
3486 iFrame
= pWal
->hdr
.mxFrame
;
3488 u8 aWalHdr
[WAL_HDRSIZE
]; /* Buffer to assemble wal-header in */
3489 u32 aCksum
[2]; /* Checksum for wal-header */
3491 sqlite3Put4byte(&aWalHdr
[0], (WAL_MAGIC
| SQLITE_BIGENDIAN
));
3492 sqlite3Put4byte(&aWalHdr
[4], WAL_MAX_VERSION
);
3493 sqlite3Put4byte(&aWalHdr
[8], szPage
);
3494 sqlite3Put4byte(&aWalHdr
[12], pWal
->nCkpt
);
3495 if( pWal
->nCkpt
==0 ) sqlite3_randomness(8, pWal
->hdr
.aSalt
);
3496 memcpy(&aWalHdr
[16], pWal
->hdr
.aSalt
, 8);
3497 walChecksumBytes(1, aWalHdr
, WAL_HDRSIZE
-2*4, 0, aCksum
);
3498 sqlite3Put4byte(&aWalHdr
[24], aCksum
[0]);
3499 sqlite3Put4byte(&aWalHdr
[28], aCksum
[1]);
3501 pWal
->szPage
= szPage
;
3502 pWal
->hdr
.bigEndCksum
= SQLITE_BIGENDIAN
;
3503 pWal
->hdr
.aFrameCksum
[0] = aCksum
[0];
3504 pWal
->hdr
.aFrameCksum
[1] = aCksum
[1];
3505 pWal
->truncateOnCommit
= 1;
3507 rc
= sqlite3OsWrite(pWal
->pWalFd
, aWalHdr
, sizeof(aWalHdr
), 0);
3508 WALTRACE(("WAL%p: wal-header write %s\n", pWal
, rc
? "failed" : "ok"));
3509 if( rc
!=SQLITE_OK
){
3513 /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless
3514 ** all syncing is turned off by PRAGMA synchronous=OFF). Otherwise
3515 ** an out-of-order write following a WAL restart could result in
3516 ** database corruption. See the ticket:
3518 ** https://sqlite.org/src/info/ff5be73dee
3520 if( pWal
->syncHeader
){
3521 rc
= sqlite3OsSync(pWal
->pWalFd
, CKPT_SYNC_FLAGS(sync_flags
));
3525 assert( (int)pWal
->szPage
==szPage
);
3527 /* Setup information needed to write frames into the WAL */
3529 w
.pFd
= pWal
->pWalFd
;
3531 w
.syncFlags
= sync_flags
;
3533 iOffset
= walFrameOffset(iFrame
+1, szPage
);
3534 szFrame
= szPage
+ WAL_FRAME_HDRSIZE
;
3536 /* Write all frames into the log file exactly once */
3537 for(p
=pList
; p
; p
=p
->pDirty
){
3538 int nDbSize
; /* 0 normally. Positive == commit flag */
3540 /* Check if this page has already been written into the wal file by
3541 ** the current transaction. If so, overwrite the existing frame and
3542 ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that
3543 ** checksums must be recomputed when the transaction is committed. */
3544 if( iFirst
&& (p
->pDirty
|| isCommit
==0) ){
3546 VVA_ONLY(rc
=) sqlite3WalFindFrame(pWal
, p
->pgno
, &iWrite
);
3547 assert( rc
==SQLITE_OK
|| iWrite
==0 );
3548 if( iWrite
>=iFirst
){
3549 i64 iOff
= walFrameOffset(iWrite
, szPage
) + WAL_FRAME_HDRSIZE
;
3551 if( pWal
->iReCksum
==0 || iWrite
<pWal
->iReCksum
){
3552 pWal
->iReCksum
= iWrite
;
3555 rc
= sqlite3OsWrite(pWal
->pWalFd
, pData
, szPage
, iOff
);
3557 p
->flags
&= ~PGHDR_WAL_APPEND
;
3563 assert( iOffset
==walFrameOffset(iFrame
, szPage
) );
3564 nDbSize
= (isCommit
&& p
->pDirty
==0) ? nTruncate
: 0;
3565 rc
= walWriteOneFrame(&w
, p
, nDbSize
, iOffset
);
3569 p
->flags
|= PGHDR_WAL_APPEND
;
3572 /* Recalculate checksums within the wal file if required. */
3573 if( isCommit
&& pWal
->iReCksum
){
3574 rc
= walRewriteChecksums(pWal
, iFrame
);
3578 /* If this is the end of a transaction, then we might need to pad
3579 ** the transaction and/or sync the WAL file.
3581 ** Padding and syncing only occur if this set of frames complete a
3582 ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL
3583 ** or synchronous==OFF, then no padding or syncing are needed.
3585 ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not
3586 ** needed and only the sync is done. If padding is needed, then the
3587 ** final frame is repeated (with its commit mark) until the next sector
3588 ** boundary is crossed. Only the part of the WAL prior to the last
3589 ** sector boundary is synced; the part of the last frame that extends
3590 ** past the sector boundary is written after the sync.
3592 if( isCommit
&& WAL_SYNC_FLAGS(sync_flags
)!=0 ){
3594 if( pWal
->padToSectorBoundary
){
3595 int sectorSize
= sqlite3SectorSize(pWal
->pWalFd
);
3596 w
.iSyncPoint
= ((iOffset
+sectorSize
-1)/sectorSize
)*sectorSize
;
3597 bSync
= (w
.iSyncPoint
==iOffset
);
3599 while( iOffset
<w
.iSyncPoint
){
3600 rc
= walWriteOneFrame(&w
, pLast
, nTruncate
, iOffset
);
3608 assert( rc
==SQLITE_OK
);
3609 rc
= sqlite3OsSync(w
.pFd
, WAL_SYNC_FLAGS(sync_flags
));
3613 /* If this frame set completes the first transaction in the WAL and
3614 ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
3615 ** journal size limit, if possible.
3617 if( isCommit
&& pWal
->truncateOnCommit
&& pWal
->mxWalSize
>=0 ){
3618 i64 sz
= pWal
->mxWalSize
;
3619 if( walFrameOffset(iFrame
+nExtra
+1, szPage
)>pWal
->mxWalSize
){
3620 sz
= walFrameOffset(iFrame
+nExtra
+1, szPage
);
3622 walLimitSize(pWal
, sz
);
3623 pWal
->truncateOnCommit
= 0;
3626 /* Append data to the wal-index. It is not necessary to lock the
3627 ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index
3628 ** guarantees that there are no other writers, and no data that may
3629 ** be in use by existing readers is being overwritten.
3631 iFrame
= pWal
->hdr
.mxFrame
;
3632 for(p
=pList
; p
&& rc
==SQLITE_OK
; p
=p
->pDirty
){
3633 if( (p
->flags
& PGHDR_WAL_APPEND
)==0 ) continue;
3635 rc
= walIndexAppend(pWal
, iFrame
, p
->pgno
);
3637 assert( pLast
!=0 || nExtra
==0 );
3638 while( rc
==SQLITE_OK
&& nExtra
>0 ){
3641 rc
= walIndexAppend(pWal
, iFrame
, pLast
->pgno
);
3644 if( rc
==SQLITE_OK
){
3645 /* Update the private copy of the header. */
3646 pWal
->hdr
.szPage
= (u16
)((szPage
&0xff00) | (szPage
>>16));
3647 testcase( szPage
<=32768 );
3648 testcase( szPage
>=65536 );
3649 pWal
->hdr
.mxFrame
= iFrame
;
3651 pWal
->hdr
.iChange
++;
3652 pWal
->hdr
.nPage
= nTruncate
;
3654 /* If this is a commit, update the wal-index header too. */
3656 walIndexWriteHdr(pWal
);
3657 pWal
->iCallback
= iFrame
;
3661 WALTRACE(("WAL%p: frame write %s\n", pWal
, rc
? "failed" : "ok"));
3666 ** This routine is called to implement sqlite3_wal_checkpoint() and
3667 ** related interfaces.
3669 ** Obtain a CHECKPOINT lock and then backfill as much information as
3670 ** we can from WAL into the database.
3672 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
3673 ** callback. In this case this function runs a blocking checkpoint.
3675 int sqlite3WalCheckpoint(
3676 Wal
*pWal
, /* Wal connection */
3677 sqlite3
*db
, /* Check this handle's interrupt flag */
3678 int eMode
, /* PASSIVE, FULL, RESTART, or TRUNCATE */
3679 int (*xBusy
)(void*), /* Function to call when busy */
3680 void *pBusyArg
, /* Context argument for xBusyHandler */
3681 int sync_flags
, /* Flags to sync db file with (or 0) */
3682 int nBuf
, /* Size of temporary buffer */
3683 u8
*zBuf
, /* Temporary buffer to use */
3684 int *pnLog
, /* OUT: Number of frames in WAL */
3685 int *pnCkpt
/* OUT: Number of backfilled frames in WAL */
3687 int rc
; /* Return code */
3688 int isChanged
= 0; /* True if a new wal-index header is loaded */
3689 int eMode2
= eMode
; /* Mode to pass to walCheckpoint() */
3690 int (*xBusy2
)(void*) = xBusy
; /* Busy handler for eMode2 */
3692 assert( pWal
->ckptLock
==0 );
3693 assert( pWal
->writeLock
==0 );
3695 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
3696 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
3697 assert( eMode
!=SQLITE_CHECKPOINT_PASSIVE
|| xBusy
==0 );
3699 if( pWal
->readOnly
) return SQLITE_READONLY
;
3700 WALTRACE(("WAL%p: checkpoint begins\n", pWal
));
3702 /* Enable blocking locks, if possible. If blocking locks are successfully
3703 ** enabled, set xBusy2=0 so that the busy-handler is never invoked. */
3704 sqlite3WalDb(pWal
, db
);
3705 (void)walEnableBlocking(pWal
);
3707 /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive
3708 ** "checkpoint" lock on the database file.
3709 ** EVIDENCE-OF: R-10421-19736 If any other process is running a
3710 ** checkpoint operation at the same time, the lock cannot be obtained and
3711 ** SQLITE_BUSY is returned.
3712 ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured,
3713 ** it will not be invoked in this case.
3715 rc
= walLockExclusive(pWal
, WAL_CKPT_LOCK
, 1);
3716 testcase( rc
==SQLITE_BUSY
);
3717 testcase( rc
!=SQLITE_OK
&& xBusy2
!=0 );
3718 if( rc
==SQLITE_OK
){
3721 /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and
3722 ** TRUNCATE modes also obtain the exclusive "writer" lock on the database
3725 ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained
3726 ** immediately, and a busy-handler is configured, it is invoked and the
3727 ** writer lock retried until either the busy-handler returns 0 or the
3728 ** lock is successfully obtained.
3730 if( eMode
!=SQLITE_CHECKPOINT_PASSIVE
){
3731 rc
= walBusyLock(pWal
, xBusy2
, pBusyArg
, WAL_WRITE_LOCK
, 1);
3732 if( rc
==SQLITE_OK
){
3733 pWal
->writeLock
= 1;
3734 }else if( rc
==SQLITE_BUSY
){
3735 eMode2
= SQLITE_CHECKPOINT_PASSIVE
;
3743 /* Read the wal-index header. */
3744 if( rc
==SQLITE_OK
){
3745 walDisableBlocking(pWal
);
3746 rc
= walIndexReadHdr(pWal
, &isChanged
);
3747 (void)walEnableBlocking(pWal
);
3748 if( isChanged
&& pWal
->pDbFd
->pMethods
->iVersion
>=3 ){
3749 sqlite3OsUnfetch(pWal
->pDbFd
, 0, 0);
3753 /* Copy data from the log to the database file. */
3754 if( rc
==SQLITE_OK
){
3756 if( pWal
->hdr
.mxFrame
&& walPagesize(pWal
)!=nBuf
){
3757 rc
= SQLITE_CORRUPT_BKPT
;
3759 rc
= walCheckpoint(pWal
, db
, eMode2
, xBusy2
, pBusyArg
, sync_flags
, zBuf
);
3762 /* If no error occurred, set the output variables. */
3763 if( rc
==SQLITE_OK
|| rc
==SQLITE_BUSY
){
3764 if( pnLog
) *pnLog
= (int)pWal
->hdr
.mxFrame
;
3765 if( pnCkpt
) *pnCkpt
= (int)(walCkptInfo(pWal
)->nBackfill
);
3770 /* If a new wal-index header was loaded before the checkpoint was
3771 ** performed, then the pager-cache associated with pWal is now
3772 ** out of date. So zero the cached wal-index header to ensure that
3773 ** next time the pager opens a snapshot on this database it knows that
3774 ** the cache needs to be reset.
3776 memset(&pWal
->hdr
, 0, sizeof(WalIndexHdr
));
3779 walDisableBlocking(pWal
);
3780 sqlite3WalDb(pWal
, 0);
3782 /* Release the locks. */
3783 sqlite3WalEndWriteTransaction(pWal
);
3784 if( pWal
->ckptLock
){
3785 walUnlockExclusive(pWal
, WAL_CKPT_LOCK
, 1);
3788 WALTRACE(("WAL%p: checkpoint %s\n", pWal
, rc
? "failed" : "ok"));
3789 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
3790 if( rc
==SQLITE_BUSY_TIMEOUT
) rc
= SQLITE_BUSY
;
3792 return (rc
==SQLITE_OK
&& eMode
!=eMode2
? SQLITE_BUSY
: rc
);
3795 /* Return the value to pass to a sqlite3_wal_hook callback, the
3796 ** number of frames in the WAL at the point of the last commit since
3797 ** sqlite3WalCallback() was called. If no commits have occurred since
3798 ** the last call, then return 0.
3800 int sqlite3WalCallback(Wal
*pWal
){
3803 ret
= pWal
->iCallback
;
3804 pWal
->iCallback
= 0;
3810 ** This function is called to change the WAL subsystem into or out
3811 ** of locking_mode=EXCLUSIVE.
3813 ** If op is zero, then attempt to change from locking_mode=EXCLUSIVE
3814 ** into locking_mode=NORMAL. This means that we must acquire a lock
3815 ** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL
3816 ** or if the acquisition of the lock fails, then return 0. If the
3817 ** transition out of exclusive-mode is successful, return 1. This
3818 ** operation must occur while the pager is still holding the exclusive
3819 ** lock on the main database file.
3821 ** If op is one, then change from locking_mode=NORMAL into
3822 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
3823 ** be released. Return 1 if the transition is made and 0 if the
3824 ** WAL is already in exclusive-locking mode - meaning that this
3825 ** routine is a no-op. The pager must already hold the exclusive lock
3826 ** on the main database file before invoking this operation.
3828 ** If op is negative, then do a dry-run of the op==1 case but do
3829 ** not actually change anything. The pager uses this to see if it
3830 ** should acquire the database exclusive lock prior to invoking
3833 int sqlite3WalExclusiveMode(Wal
*pWal
, int op
){
3835 assert( pWal
->writeLock
==0 );
3836 assert( pWal
->exclusiveMode
!=WAL_HEAPMEMORY_MODE
|| op
==-1 );
3838 /* pWal->readLock is usually set, but might be -1 if there was a
3839 ** prior error while attempting to acquire are read-lock. This cannot
3840 ** happen if the connection is actually in exclusive mode (as no xShmLock
3841 ** locks are taken in this case). Nor should the pager attempt to
3842 ** upgrade to exclusive-mode following such an error.
3844 assert( pWal
->readLock
>=0 || pWal
->lockError
);
3845 assert( pWal
->readLock
>=0 || (op
<=0 && pWal
->exclusiveMode
==0) );
3848 if( pWal
->exclusiveMode
!=WAL_NORMAL_MODE
){
3849 pWal
->exclusiveMode
= WAL_NORMAL_MODE
;
3850 if( walLockShared(pWal
, WAL_READ_LOCK(pWal
->readLock
))!=SQLITE_OK
){
3851 pWal
->exclusiveMode
= WAL_EXCLUSIVE_MODE
;
3853 rc
= pWal
->exclusiveMode
==WAL_NORMAL_MODE
;
3855 /* Already in locking_mode=NORMAL */
3859 assert( pWal
->exclusiveMode
==WAL_NORMAL_MODE
);
3860 assert( pWal
->readLock
>=0 );
3861 walUnlockShared(pWal
, WAL_READ_LOCK(pWal
->readLock
));
3862 pWal
->exclusiveMode
= WAL_EXCLUSIVE_MODE
;
3865 rc
= pWal
->exclusiveMode
==WAL_NORMAL_MODE
;
3871 ** Return true if the argument is non-NULL and the WAL module is using
3872 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
3873 ** WAL module is using shared-memory, return false.
3875 int sqlite3WalHeapMemory(Wal
*pWal
){
3876 return (pWal
&& pWal
->exclusiveMode
==WAL_HEAPMEMORY_MODE
);
3879 #ifdef SQLITE_ENABLE_SNAPSHOT
3880 /* Create a snapshot object. The content of a snapshot is opaque to
3881 ** every other subsystem, so the WAL module can put whatever it needs
3884 int sqlite3WalSnapshotGet(Wal
*pWal
, sqlite3_snapshot
**ppSnapshot
){
3887 static const u32 aZero
[4] = { 0, 0, 0, 0 };
3889 assert( pWal
->readLock
>=0 && pWal
->writeLock
==0 );
3891 if( memcmp(&pWal
->hdr
.aFrameCksum
[0],aZero
,16)==0 ){
3893 return SQLITE_ERROR
;
3895 pRet
= (WalIndexHdr
*)sqlite3_malloc(sizeof(WalIndexHdr
));
3897 rc
= SQLITE_NOMEM_BKPT
;
3899 memcpy(pRet
, &pWal
->hdr
, sizeof(WalIndexHdr
));
3900 *ppSnapshot
= (sqlite3_snapshot
*)pRet
;
3906 /* Try to open on pSnapshot when the next read-transaction starts
3908 void sqlite3WalSnapshotOpen(
3910 sqlite3_snapshot
*pSnapshot
3912 pWal
->pSnapshot
= (WalIndexHdr
*)pSnapshot
;
3916 ** Return a +ve value if snapshot p1 is newer than p2. A -ve value if
3917 ** p1 is older than p2 and zero if p1 and p2 are the same snapshot.
3919 int sqlite3_snapshot_cmp(sqlite3_snapshot
*p1
, sqlite3_snapshot
*p2
){
3920 WalIndexHdr
*pHdr1
= (WalIndexHdr
*)p1
;
3921 WalIndexHdr
*pHdr2
= (WalIndexHdr
*)p2
;
3923 /* aSalt[0] is a copy of the value stored in the wal file header. It
3924 ** is incremented each time the wal file is restarted. */
3925 if( pHdr1
->aSalt
[0]<pHdr2
->aSalt
[0] ) return -1;
3926 if( pHdr1
->aSalt
[0]>pHdr2
->aSalt
[0] ) return +1;
3927 if( pHdr1
->mxFrame
<pHdr2
->mxFrame
) return -1;
3928 if( pHdr1
->mxFrame
>pHdr2
->mxFrame
) return +1;
3933 ** The caller currently has a read transaction open on the database.
3934 ** This function takes a SHARED lock on the CHECKPOINTER slot and then
3935 ** checks if the snapshot passed as the second argument is still
3936 ** available. If so, SQLITE_OK is returned.
3938 ** If the snapshot is not available, SQLITE_ERROR is returned. Or, if
3939 ** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error
3940 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
3941 ** lock is released before returning.
3943 int sqlite3WalSnapshotCheck(Wal
*pWal
, sqlite3_snapshot
*pSnapshot
){
3945 rc
= walLockShared(pWal
, WAL_CKPT_LOCK
);
3946 if( rc
==SQLITE_OK
){
3947 WalIndexHdr
*pNew
= (WalIndexHdr
*)pSnapshot
;
3948 if( memcmp(pNew
->aSalt
, pWal
->hdr
.aSalt
, sizeof(pWal
->hdr
.aSalt
))
3949 || pNew
->mxFrame
<walCkptInfo(pWal
)->nBackfillAttempted
3951 rc
= SQLITE_ERROR_SNAPSHOT
;
3952 walUnlockShared(pWal
, WAL_CKPT_LOCK
);
3959 ** Release a lock obtained by an earlier successful call to
3960 ** sqlite3WalSnapshotCheck().
3962 void sqlite3WalSnapshotUnlock(Wal
*pWal
){
3964 walUnlockShared(pWal
, WAL_CKPT_LOCK
);
3968 #endif /* SQLITE_ENABLE_SNAPSHOT */
3970 #ifdef SQLITE_ENABLE_ZIPVFS
3972 ** If the argument is not NULL, it points to a Wal object that holds a
3973 ** read-lock. This function returns the database page-size if it is known,
3974 ** or zero if it is not (or if pWal is NULL).
3976 int sqlite3WalFramesize(Wal
*pWal
){
3977 assert( pWal
==0 || pWal
->readLock
>=0 );
3978 return (pWal
? pWal
->szPage
: 0);
3982 /* Return the sqlite3_file object for the WAL file
3984 sqlite3_file
*sqlite3WalFile(Wal
*pWal
){
3985 return pWal
->pWalFd
;
3988 #endif /* #ifndef SQLITE_OMIT_WAL */