third_party/sqlite/sqlite-src-3100200/src/wal.c - Issue 2846743003: [sql] Remove SQLite 3.10.2 reference directory.

Side by Side Diff: third_party/sqlite/sqlite-src-3100200/src/wal.c

Issue 2846743003: [sql] Remove SQLite 3.10.2 reference directory. (Closed)

Patch Set: Created 3 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 ** 2010 February 1

3 **

4 ** The author disclaims copyright to this source code. In place of

5 ** a legal notice, here is a blessing:

6 **

7 ** May you do good and not evil.

8 ** May you find forgiveness for yourself and forgive others.

9 ** May you share freely, never taking more than you give.

10 **

11 *************************************************************************

12 **

13 ** This file contains the implementation of a write-ahead log (WAL) used in

14 ** "journal_mode=WAL" mode.

15 **

16 ** WRITE-AHEAD LOG (WAL) FILE FORMAT

17 **

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

25 ** "checkpoint".

26 **

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.

33 **

34 ** The WAL header is 32 bytes in size and consists of the following eight

35 ** big-endian 32-bit unsigned integer values:

36 **

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).

45 **

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:

50 **

51 ** 0: Page number.

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)

56 ** 16: Checksum-1.

57 ** 20: Checksum-2.

58 **

59 ** A frame is considered valid if and only if the following conditions are

60 ** true:

61 **

62 ** (1) The salt-1 and salt-2 values in the frame-header match

63 ** salt values in the wal-header

64 **

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.

69 **

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:

78 **

79 ** for i from 0 to n-1 step 2:

80 ** s0 += x[i] + s1;

81 ** s1 += x[i+1] + s0;

82 ** endfor

83 **

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.

88 **

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

93 ** xSync begins.

94 **

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

98 ** following a crash.

99 **

100 ** READER ALGORITHM

101 **

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.

109 **

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.

118 **

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.

126 **

127 ** WAL-INDEX FORMAT

128 **

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

133 ** share memory.

134 **

135 ** The wal-index is transient. After a crash, the wal-index can (and should

136 ** be) reconstructed from the original WAL file. In fact, the VFS is required

137 ** to either truncate or zero the header of the wal-index when the last

138 ** connection to it closes. Because the wal-index is transient, it can

139 ** use an architecture-specific format; it does not have to be cross-platform.

140 ** Hence, unlike the database and WAL file formats which store all values

141 ** as big endian, the wal-index can store multi-byte values in the native

142 ** byte order of the host computer.

143 **

144 ** The purpose of the wal-index is to answer this question quickly: Given

145 ** a page number P and a maximum frame index M, return the index of the

146 ** last frame in the wal before frame M for page P in the WAL, or return

147 ** NULL if there are no frames for page P in the WAL prior to M.

148 **

149 ** The wal-index consists of a header region, followed by an one or

150 ** more index blocks.

151 **

152 ** The wal-index header contains the total number of frames within the WAL

153 ** in the mxFrame field.

154 **

155 ** Each index block except for the first contains information on

156 ** HASHTABLE_NPAGE frames. The first index block contains information on

157 ** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and

158 ** HASHTABLE_NPAGE are selected so that together the wal-index header and

159 ** first index block are the same size as all other index blocks in the

160 ** wal-index.

161 **

162 ** Each index block contains two sections, a page-mapping that contains the

163 ** database page number associated with each wal frame, and a hash-table

164 ** that allows readers to query an index block for a specific page number.

165 ** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE

166 ** for the first index block) 32-bit page numbers. The first entry in the

167 ** first index-block contains the database page number corresponding to the

168 ** first frame in the WAL file. The first entry in the second index block

169 ** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in

170 ** the log, and so on.

171 **

172 ** The last index block in a wal-index usually contains less than the full

173 ** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers,

174 ** depending on the contents of the WAL file. This does not change the

175 ** allocated size of the page-mapping array - the page-mapping array merely

176 ** contains unused entries.

177 **

178 ** Even without using the hash table, the last frame for page P

179 ** can be found by scanning the page-mapping sections of each index block

180 ** starting with the last index block and moving toward the first, and

181 ** within each index block, starting at the end and moving toward the

182 ** beginning. The first entry that equals P corresponds to the frame

183 ** holding the content for that page.

184 **

185 ** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers.

186 ** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the

187 ** hash table for each page number in the mapping section, so the hash

188 ** table is never more than half full. The expected number of collisions

189 ** prior to finding a match is 1. Each entry of the hash table is an

190 ** 1-based index of an entry in the mapping section of the same

191 ** index block. Let K be the 1-based index of the largest entry in

192 ** the mapping section. (For index blocks other than the last, K will

193 ** always be exactly HASHTABLE_NPAGE (4096) and for the last index block

194 ** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table

195 ** contain a value of 0.

196 **

197 ** To look for page P in the hash table, first compute a hash iKey on

198 ** P as follows:

199 **

200 ** iKey = (P * 383) % HASHTABLE_NSLOT

201 **

202 ** Then start scanning entries of the hash table, starting with iKey

203 ** (wrapping around to the beginning when the end of the hash table is

204 ** reached) until an unused hash slot is found. Let the first unused slot

205 ** be at index iUnused. (iUnused might be less than iKey if there was

206 ** wrap-around.) Because the hash table is never more than half full,

207 ** the search is guaranteed to eventually hit an unused entry. Let

208 ** iMax be the value between iKey and iUnused, closest to iUnused,

209 ** where aHash[iMax]==P. If there is no iMax entry (if there exists

210 ** no hash slot such that aHash[i]==p) then page P is not in the

211 ** current index block. Otherwise the iMax-th mapping entry of the

212 ** current index block corresponds to the last entry that references

213 ** page P.

214 **

215 ** A hash search begins with the last index block and moves toward the

216 ** first index block, looking for entries corresponding to page P. On

217 ** average, only two or three slots in each index block need to be

218 ** examined in order to either find the last entry for page P, or to

219 ** establish that no such entry exists in the block. Each index block

220 ** holds over 4000 entries. So two or three index blocks are sufficient

221 ** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10

222 ** comparisons (on average) suffice to either locate a frame in the

223 ** WAL or to establish that the frame does not exist in the WAL. This

224 ** is much faster than scanning the entire 10MB WAL.

225 **

226 ** Note that entries are added in order of increasing K. Hence, one

227 ** reader might be using some value K0 and a second reader that started

228 ** at a later time (after additional transactions were added to the WAL

229 ** and to the wal-index) might be using a different value K1, where K1>K0.

230 ** Both readers can use the same hash table and mapping section to get

231 ** the correct result. There may be entries in the hash table with

232 ** K>K0 but to the first reader, those entries will appear to be unused

233 ** slots in the hash table and so the first reader will get an answer as

234 ** if no values greater than K0 had ever been inserted into the hash table

235 ** in the first place - which is what reader one wants. Meanwhile, the

236 ** second reader using K1 will see additional values that were inserted

237 ** later, which is exactly what reader two wants.

238 **

239 ** When a rollback occurs, the value of K is decreased. Hash table entries

240 ** that correspond to frames greater than the new K value are removed

241 ** from the hash table at this point.

242 */

243 #ifndef SQLITE_OMIT_WAL

244

245 #include "wal.h"

246

247 /*

248 ** Trace output macros

249 */

250 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)

251 int sqlite3WalTrace = 0;

252 # define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X

253 #else

254 # define WALTRACE(X)

255 #endif

256

257 /*

258 ** The maximum (and only) versions of the wal and wal-index formats

259 ** that may be interpreted by this version of SQLite.

260 **

261 ** If a client begins recovering a WAL file and finds that (a) the checksum

262 ** values in the wal-header are correct and (b) the version field is not

263 ** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN.

264 **

265 ** Similarly, if a client successfully reads a wal-index header (i.e. the

266 ** checksum test is successful) and finds that the version field is not

267 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite

268 ** returns SQLITE_CANTOPEN.

269 */

270 #define WAL_MAX_VERSION 3007000

271 #define WALINDEX_MAX_VERSION 3007000

272

273 /*

274 ** Indices of various locking bytes. WAL_NREADER is the number

275 ** of available reader locks and should be at least 3. The default

276 ** is SQLITE_SHM_NLOCK==8 and WAL_NREADER==5.

277 */

278 #define WAL_WRITE_LOCK 0

279 #define WAL_ALL_BUT_WRITE 1

280 #define WAL_CKPT_LOCK 1

281 #define WAL_RECOVER_LOCK 2

282 #define WAL_READ_LOCK(I) (3+(I))

283 #define WAL_NREADER (SQLITE_SHM_NLOCK-3)

284

285

286 /* Object declarations */

287 typedef struct WalIndexHdr WalIndexHdr;

288 typedef struct WalIterator WalIterator;

289 typedef struct WalCkptInfo WalCkptInfo;

290

291

292 /*

293 ** The following object holds a copy of the wal-index header content.

294 **

295 ** The actual header in the wal-index consists of two copies of this

296 ** object followed by one instance of the WalCkptInfo object.

297 ** For all versions of SQLite through 3.10.0 and probably beyond,

298 ** the locking bytes (WalCkptInfo.aLock) start at offset 120 and

299 ** the total header size is 136 bytes.

300 **

301 ** The szPage value can be any power of 2 between 512 and 32768, inclusive.

302 ** Or it can be 1 to represent a 65536-byte page. The latter case was

303 ** added in 3.7.1 when support for 64K pages was added.

304 */

305 struct WalIndexHdr {

306 u32 iVersion; /* Wal-index version */

307 u32 unused; /* Unused (padding) field */

308 u32 iChange; /* Counter incremented each transaction */

309 u8 isInit; /* 1 when initialized */

310 u8 bigEndCksum; /* True if checksums in WAL are big-endian */

311 u16 szPage; /* Database page size in bytes. 1==64K */

312 u32 mxFrame; /* Index of last valid frame in the WAL */

313 u32 nPage; /* Size of database in pages */

314 u32 aFrameCksum[2]; /* Checksum of last frame in log */

315 u32 aSalt[2]; /* Two salt values copied from WAL header */

316 u32 aCksum[2]; /* Checksum over all prior fields */

317 };

318

319 /*

320 ** A copy of the following object occurs in the wal-index immediately

321 ** following the second copy of the WalIndexHdr. This object stores

322 ** information used by checkpoint.

323 **

324 ** nBackfill is the number of frames in the WAL that have been written

325 ** back into the database. (We call the act of moving content from WAL to

326 ** database "backfilling".) The nBackfill number is never greater than

327 ** WalIndexHdr.mxFrame. nBackfill can only be increased by threads

328 ** holding the WAL_CKPT_LOCK lock (which includes a recovery thread).

329 ** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from

330 ** mxFrame back to zero when the WAL is reset.

331 **

332 ** nBackfillAttempted is the largest value of nBackfill that a checkpoint

333 ** has attempted to achieve. Normally nBackfill==nBackfillAtempted, however

334 ** the nBackfillAttempted is set before any backfilling is done and the

335 ** nBackfill is only set after all backfilling completes. So if a checkpoint

336 ** crashes, nBackfillAttempted might be larger than nBackfill. The

337 ** WalIndexHdr.mxFrame must never be less than nBackfillAttempted.

338 **

339 ** The aLock[] field is a set of bytes used for locking. These bytes should

340 ** never be read or written.

341 **

342 ** There is one entry in aReadMark[] for each reader lock. If a reader

343 ** holds read-lock K, then the value in aReadMark[K] is no greater than

344 ** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff)

345 ** for any aReadMark[] means that entry is unused. aReadMark[0] is

346 ** a special case; its value is never used and it exists as a place-holder

347 ** to avoid having to offset aReadMark[] indexs by one. Readers holding

348 ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content

349 ** directly from the database.

350 **

351 ** The value of aReadMark[K] may only be changed by a thread that

352 ** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of

353 ** aReadMark[K] cannot changed while there is a reader is using that mark

354 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).

355 **

356 ** The checkpointer may only transfer frames from WAL to database where

357 ** the frame numbers are less than or equal to every aReadMark[] that is

358 ** in use (that is, every aReadMark[j] for which there is a corresponding

359 ** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the

360 ** largest value and will increase an unused aReadMark[] to mxFrame if there

361 ** is not already an aReadMark[] equal to mxFrame. The exception to the

362 ** previous sentence is when nBackfill equals mxFrame (meaning that everything

363 ** in the WAL has been backfilled into the database) then new readers

364 ** will choose aReadMark[0] which has value 0 and hence such reader will

365 ** get all their all content directly from the database file and ignore

366 ** the WAL.

367 **

368 ** Writers normally append new frames to the end of the WAL. However,

369 ** if nBackfill equals mxFrame (meaning that all WAL content has been

370 ** written back into the database) and if no readers are using the WAL

371 ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then

372 ** the writer will first "reset" the WAL back to the beginning and start

373 ** writing new content beginning at frame 1.

374 **

375 ** We assume that 32-bit loads are atomic and so no locks are needed in

376 ** order to read from any aReadMark[] entries.

377 */

378 struct WalCkptInfo {

379 u32 nBackfill; /* Number of WAL frames backfilled into DB */

380 u32 aReadMark[WAL_NREADER]; /* Reader marks */

381 u8 aLock[SQLITE_SHM_NLOCK]; /* Reserved space for locks */

382 u32 nBackfillAttempted; /* WAL frames perhaps written, or maybe not */

383 u32 notUsed0; /* Available for future enhancements */

384 };

385 #define READMARK_NOT_USED 0xffffffff

386

387

388 /* A block of WALINDEX_LOCK_RESERVED bytes beginning at

389 ** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems

390 ** only support mandatory file-locks, we do not read or write data

391 ** from the region of the file on which locks are applied.

392 */

393 #define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock))

394 #define WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))

395

396 /* Size of header before each frame in wal */

397 #define WAL_FRAME_HDRSIZE 24

398

399 /* Size of write ahead log header, including checksum. */

400 /* #define WAL_HDRSIZE 24 */

401 #define WAL_HDRSIZE 32

402

403 /* WAL magic value. Either this value, or the same value with the least

404 ** significant bit also set (WAL_MAGIC \| 0x00000001) is stored in 32-bit

405 ** big-endian format in the first 4 bytes of a WAL file.

406 **

407 ** If the LSB is set, then the checksums for each frame within the WAL

408 ** file are calculated by treating all data as an array of 32-bit

409 ** big-endian words. Otherwise, they are calculated by interpreting

410 ** all data as 32-bit little-endian words.

411 */

412 #define WAL_MAGIC 0x377f0682

413

414 /*

415 ** Return the offset of frame iFrame in the write-ahead log file,

416 ** assuming a database page size of szPage bytes. The offset returned

417 ** is to the start of the write-ahead log frame-header.

418 */

419 #define walFrameOffset(iFrame, szPage) ( \

420 WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \

421 )

422

423 /*

424 ** An open write-ahead log file is represented by an instance of the

425 ** following object.

426 */

427 struct Wal {

428 sqlite3_vfs pVfs; / The VFS used to create pDbFd */

429 sqlite3_file pDbFd; / File handle for the database file */

430 sqlite3_file pWalFd; / File handle for WAL file */

431 u32 iCallback; /* Value to pass to log callback (or 0) */

432 i64 mxWalSize; /* Truncate WAL to this size upon reset */

433 int nWiData; /* Size of array apWiData */

434 int szFirstBlock; /* Size of first block written to WAL file */

435 volatile u32 *apWiData; / Pointer to wal-index content in memory */

436 u32 szPage; /* Database page size */

437 i16 readLock; /* Which read lock is being held. -1 for none */

438 u8 syncFlags; /* Flags to use to sync header writes */

439 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */

440 u8 writeLock; /* True if in a write transaction */

441 u8 ckptLock; /* True if holding a checkpoint lock */

442 u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */

443 u8 truncateOnCommit; /* True to truncate WAL file on commit */

444 u8 syncHeader; /* Fsync the WAL header if true */

445 u8 padToSectorBoundary; /* Pad transactions out to the next sector */

446 WalIndexHdr hdr; /* Wal-index header for current transaction */

447 u32 minFrame; /* Ignore wal frames before this one */

448 const char zWalName; / Name of WAL file */

449 u32 nCkpt; /* Checkpoint sequence counter in the wal-header */

450 #ifdef SQLITE_DEBUG

451 u8 lockError; /* True if a locking error has occurred */

452 #endif

453 #ifdef SQLITE_ENABLE_SNAPSHOT

454 WalIndexHdr pSnapshot; / Start transaction here if not NULL */

455 #endif

456 };

457

458 /*

459 ** Candidate values for Wal.exclusiveMode.

460 */

461 #define WAL_NORMAL_MODE 0

462 #define WAL_EXCLUSIVE_MODE 1

463 #define WAL_HEAPMEMORY_MODE 2

464

465 /*

466 ** Possible values for WAL.readOnly

467 */

468 #define WAL_RDWR 0 /* Normal read/write connection */

469 #define WAL_RDONLY 1 /* The WAL file is readonly */

470 #define WAL_SHM_RDONLY 2 /* The SHM file is readonly */

471

472 /*

473 ** Each page of the wal-index mapping contains a hash-table made up of

474 ** an array of HASHTABLE_NSLOT elements of the following type.

475 */

476 typedef u16 ht_slot;

477

478 /*

479 ** This structure is used to implement an iterator that loops through

480 ** all frames in the WAL in database page order. Where two or more frames

481 ** correspond to the same database page, the iterator visits only the

482 ** frame most recently written to the WAL (in other words, the frame with

483 ** the largest index).

484 **

485 ** The internals of this structure are only accessed by:

486 **

487 ** walIteratorInit() - Create a new iterator,

488 ** walIteratorNext() - Step an iterator,

489 ** walIteratorFree() - Free an iterator.

490 **

491 ** This functionality is used by the checkpoint code (see walCheckpoint()).

492 */

493 struct WalIterator {

494 int iPrior; /* Last result returned from the iterator */

495 int nSegment; /* Number of entries in aSegment[] */

496 struct WalSegment {

497 int iNext; /* Next slot in aIndex[] not yet returned */

498 ht_slot aIndex; / i0, i1, i2... such that aPgno[iN] ascend */

499 u32 aPgno; / Array of page numbers. */

500 int nEntry; /* Nr. of entries in aPgno[] and aIndex[] */

501 int iZero; /* Frame number associated with aPgno[0] */

502 } aSegment[1]; /* One for every 32KB page in the wal-index */

503 };

504

505 /*

506 ** Define the parameters of the hash tables in the wal-index file. There

507 ** is a hash-table following every HASHTABLE_NPAGE page numbers in the

508 ** wal-index.

509 **

510 ** Changing any of these constants will alter the wal-index format and

511 ** create incompatibilities.

512 */

513 #define HASHTABLE_NPAGE 4096 /* Must be power of 2 */

514 #define HASHTABLE_HASH_1 383 /* Should be prime */

515 #define HASHTABLE_NSLOT (HASHTABLE_NPAGE2) / Must be a power of 2 */

516

517 /*

518 ** The block of page numbers associated with the first hash-table in a

519 ** wal-index is smaller than usual. This is so that there is a complete

520 ** hash-table on each aligned 32KB page of the wal-index.

521 */

522 #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))

523

524 /* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */

525 #define WALINDEX_PGSZ ( \

526 sizeof(ht_slot)HASHTABLE_NSLOT + HASHTABLE_NPAGEsizeof(u32) \

527 )

528

529 /*

530 ** Obtain a pointer to the iPage'th page of the wal-index. The wal-index

531 ** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are

532 ** numbered from zero.

533 **

534 ** If this call is successful, *ppPage is set to point to the wal-index

535 ** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,

536 ** then an SQLite error code is returned and *ppPage is set to 0.

537 */

538 static int walIndexPage(Wal pWal, int iPage, volatile u32 *ppPage){

539 int rc = SQLITE_OK;

540

541 /* Enlarge the pWal->apWiData[] array if required */

542 if( pWal->nWiData<=iPage ){

543 int nByte = sizeof(u32)(iPage+1);

544 volatile u32 **apNew;

545 apNew = (volatile u32 *)sqlite3_realloc64((void )pWal->apWiData, nByte);

546 if( !apNew ){

547 *ppPage = 0;

548 return SQLITE_NOMEM;

549 }

550 memset((void*)&apNew[pWal->nWiData], 0,

551 sizeof(u32)(iPage+1-pWal->nWiData));

552 pWal->apWiData = apNew;

553 pWal->nWiData = iPage+1;

554 }

555

556 /* Request a pointer to the required page from the VFS */

557 if( pWal->apWiData[iPage]==0 ){

558 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){

559 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);

560 if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM;

561 }else{

562 rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,

563 pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]

564 );

565 if( rc==SQLITE_READONLY ){

566 pWal->readOnly \|= WAL_SHM_RDONLY;

567 rc = SQLITE_OK;

568 }

569 }

570 }

571

572 *ppPage = pWal->apWiData[iPage];

573 assert( iPage==0 \|\| *ppPage \|\| rc!=SQLITE_OK );

574 return rc;

575 }

576

577 /*

578 ** Return a pointer to the WalCkptInfo structure in the wal-index.

579 */

580 static volatile WalCkptInfo walCkptInfo(Wal pWal){

581 assert( pWal->nWiData>0 && pWal->apWiData[0] );

582 return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);

583 }

584

585 /*

586 ** Return a pointer to the WalIndexHdr structure in the wal-index.

587 */

588 static volatile WalIndexHdr walIndexHdr(Wal pWal){

589 assert( pWal->nWiData>0 && pWal->apWiData[0] );

590 return (volatile WalIndexHdr*)pWal->apWiData[0];

591 }

592

593 /*

594 ** The argument to this macro must be of type u32. On a little-endian

595 ** architecture, it returns the u32 value that results from interpreting

596 ** the 4 bytes as a big-endian value. On a big-endian architecture, it

597 ** returns the value that would be produced by interpreting the 4 bytes

598 ** of the input value as a little-endian integer.

599 */

600 #define BYTESWAP32(x) ( \

601 (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \

602 + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \

603 )

604

605 /*

606 ** Generate or extend an 8 byte checksum based on the data in

607 ** array aByte[] and the initial values of aIn[0] and aIn[1] (or

608 ** initial values of 0 and 0 if aIn==NULL).

609 **

610 ** The checksum is written back into aOut[] before returning.

611 **

612 ** nByte must be a positive multiple of 8.

613 */

614 static void walChecksumBytes(

615 int nativeCksum, /* True for native byte-order, false for non-native */

616 u8 a, / Content to be checksummed */

617 int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */

618 const u32 aIn, / Initial checksum value input */

619 u32 aOut / OUT: Final checksum value output */

620 ){

621 u32 s1, s2;

622 u32 aData = (u32 )a;

623 u32 aEnd = (u32 )&a[nByte];

624

625 if( aIn ){

626 s1 = aIn[0];

627 s2 = aIn[1];

628 }else{

629 s1 = s2 = 0;

630 }

631

632 assert( nByte>=8 );

633 assert( (nByte&0x00000007)==0 );

634

635 if( nativeCksum ){

636 do {

637 s1 += *aData++ + s2;

638 s2 += *aData++ + s1;

639 }while( aData<aEnd );

640 }else{

641 do {

642 s1 += BYTESWAP32(aData[0]) + s2;

643 s2 += BYTESWAP32(aData[1]) + s1;

644 aData += 2;

645 }while( aData<aEnd );

646 }

647

648 aOut[0] = s1;

649 aOut[1] = s2;

650 }

651

652 static void walShmBarrier(Wal *pWal){

653 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){

654 sqlite3OsShmBarrier(pWal->pDbFd);

655 }

656 }

657

658 /*

659 ** Write the header information in pWal->hdr into the wal-index.

660 **

661 ** The checksum on pWal->hdr is updated before it is written.

662 */

663 static void walIndexWriteHdr(Wal *pWal){

664 volatile WalIndexHdr *aHdr = walIndexHdr(pWal);

665 const int nCksum = offsetof(WalIndexHdr, aCksum);

666

667 assert( pWal->writeLock );

668 pWal->hdr.isInit = 1;

669 pWal->hdr.iVersion = WALINDEX_MAX_VERSION;

670 walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);

671 memcpy((void)&aHdr[1], (const void)&pWal->hdr, sizeof(WalIndexHdr));

672 walShmBarrier(pWal);

673 memcpy((void)&aHdr[0], (const void)&pWal->hdr, sizeof(WalIndexHdr));

674 }

675

676 /*

677 ** This function encodes a single frame header and writes it to a buffer

678 ** supplied by the caller. A frame-header is made up of a series of

679 ** 4-byte big-endian integers, as follows:

680 **

681 ** 0: Page number.

682 ** 4: For commit records, the size of the database image in pages

683 ** after the commit. For all other records, zero.

684 ** 8: Salt-1 (copied from the wal-header)

685 ** 12: Salt-2 (copied from the wal-header)

686 ** 16: Checksum-1.

687 ** 20: Checksum-2.

688 */

689 static void walEncodeFrame(

690 Wal pWal, / The write-ahead log */

691 u32 iPage, /* Database page number for frame */

692 u32 nTruncate, /* New db size (or 0 for non-commit frames) */

693 u8 aData, / Pointer to page data */

694 u8 aFrame / OUT: Write encoded frame here */

695 ){

696 int nativeCksum; /* True for native byte-order checksums */

697 u32 *aCksum = pWal->hdr.aFrameCksum;

698 assert( WAL_FRAME_HDRSIZE==24 );

699 sqlite3Put4byte(&aFrame[0], iPage);

700 sqlite3Put4byte(&aFrame[4], nTruncate);

701 memcpy(&aFrame[8], pWal->hdr.aSalt, 8);

702

703 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);

704 walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);

705 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);

706

707 sqlite3Put4byte(&aFrame[16], aCksum[0]);

708 sqlite3Put4byte(&aFrame[20], aCksum[1]);

709 }

710

711 /*

712 ** Check to see if the frame with header in aFrame[] and content

713 ** in aData[] is valid. If it is a valid frame, fill *piPage and

714 ** *pnTruncate and return true. Return if the frame is not valid.

715 */

716 static int walDecodeFrame(

717 Wal pWal, / The write-ahead log */

718 u32 piPage, / OUT: Database page number for frame */

719 u32 pnTruncate, / OUT: New db size (or 0 if not commit) */

720 u8 aData, / Pointer to page data (for checksum) */

721 u8 aFrame / Frame data */

722 ){

723 int nativeCksum; /* True for native byte-order checksums */

724 u32 *aCksum = pWal->hdr.aFrameCksum;

725 u32 pgno; /* Page number of the frame */

726 assert( WAL_FRAME_HDRSIZE==24 );

727

728 /* A frame is only valid if the salt values in the frame-header

729 ** match the salt values in the wal-header.

730 */

731 if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){

732 return 0;

733 }

734

735 /* A frame is only valid if the page number is creater than zero.

736 */

737 pgno = sqlite3Get4byte(&aFrame[0]);

738 if( pgno==0 ){

739 return 0;

740 }

741

742 /* A frame is only valid if a checksum of the WAL header,

743 ** all prior frams, the first 16 bytes of this frame-header,

744 ** and the frame-data matches the checksum in the last 8

745 ** bytes of this frame-header.

746 */

747 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);

748 walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);

749 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);

750 if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])

751 \|\| aCksum[1]!=sqlite3Get4byte(&aFrame[20])

752 ){

753 /* Checksum failed. */

754 return 0;

755 }

756

757 /* If we reach this point, the frame is valid. Return the page number

758 ** and the new database size.

759 */

760 *piPage = pgno;

761 *pnTruncate = sqlite3Get4byte(&aFrame[4]);

762 return 1;

763 }

764

765

766 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)

767 /*

768 ** Names of locks. This routine is used to provide debugging output and is not

769 ** a part of an ordinary build.

770 */

771 static const char *walLockName(int lockIdx){

772 if( lockIdx==WAL_WRITE_LOCK ){

773 return "WRITE-LOCK";

774 }else if( lockIdx==WAL_CKPT_LOCK ){

775 return "CKPT-LOCK";

776 }else if( lockIdx==WAL_RECOVER_LOCK ){

777 return "RECOVER-LOCK";

778 }else{

779 static char zName[15];

780 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",

781 lockIdx-WAL_READ_LOCK(0));

782 return zName;

783 }

784 }

785 #endif /defined(SQLITE_TEST) \|\| defined(SQLITE_DEBUG) /

786

787

788 /*

789 ** Set or release locks on the WAL. Locks are either shared or exclusive.

790 ** A lock cannot be moved directly between shared and exclusive - it must go

791 ** through the unlocked state first.

792 **

793 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.

794 */

795 static int walLockShared(Wal *pWal, int lockIdx){

796 int rc;

797 if( pWal->exclusiveMode ) return SQLITE_OK;

798 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,

799 SQLITE_SHM_LOCK \| SQLITE_SHM_SHARED);

800 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,

801 walLockName(lockIdx), rc ? "failed" : "ok"));

802 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )

803 return rc;

804 }

805 static void walUnlockShared(Wal *pWal, int lockIdx){

806 if( pWal->exclusiveMode ) return;

807 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,

808 SQLITE_SHM_UNLOCK \| SQLITE_SHM_SHARED);

809 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));

810 }

811 static int walLockExclusive(Wal *pWal, int lockIdx, int n){

812 int rc;

813 if( pWal->exclusiveMode ) return SQLITE_OK;

814 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,

815 SQLITE_SHM_LOCK \| SQLITE_SHM_EXCLUSIVE);

816 WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,

817 walLockName(lockIdx), n, rc ? "failed" : "ok"));

818 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )

819 return rc;

820 }

821 static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){

822 if( pWal->exclusiveMode ) return;

823 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,

824 SQLITE_SHM_UNLOCK \| SQLITE_SHM_EXCLUSIVE);

825 WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,

826 walLockName(lockIdx), n));

827 }

828

829 /*

830 ** Compute a hash on a page number. The resulting hash value must land

831 ** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances

832 ** the hash to the next value in the event of a collision.

833 */

834 static int walHash(u32 iPage){

835 assert( iPage>0 );

836 assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );

837 return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1);

838 }

839 static int walNextHash(int iPriorHash){

840 return (iPriorHash+1)&(HASHTABLE_NSLOT-1);

841 }

842

843 /*

844 ** Return pointers to the hash table and page number array stored on

845 ** page iHash of the wal-index. The wal-index is broken into 32KB pages

846 ** numbered starting from 0.

847 **

848 ** Set output variable *paHash to point to the start of the hash table

849 ** in the wal-index file. Set *piZero to one less than the frame

850 ** number of the first frame indexed by this hash table. If a

851 ** slot in the hash table is set to N, it refers to frame number

852 ** (*piZero+N) in the log.

853 **

854 ** Finally, set paPgno so that paPgno[1] is the page number of the

855 ** first frame indexed by the hash table, frame (*piZero+1).

856 */

857 static int walHashGet(

858 Wal pWal, / WAL handle */

859 int iHash, /* Find the iHash'th table */

860 volatile ht_slot *paHash, / OUT: Pointer to hash index */

861 volatile u32 *paPgno, / OUT: Pointer to page number array */

862 u32 piZero / OUT: Frame associated with paPgno[0] /

863 ){

864 int rc; /* Return code */

865 volatile u32 *aPgno;

866

867 rc = walIndexPage(pWal, iHash, &aPgno);

868 assert( rc==SQLITE_OK \|\| iHash>0 );

869

870 if( rc==SQLITE_OK ){

871 u32 iZero;

872 volatile ht_slot *aHash;

873

874 aHash = (volatile ht_slot *)&aPgno[HASHTABLE_NPAGE];

875 if( iHash==0 ){

876 aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];

877 iZero = 0;

878 }else{

879 iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;

880 }

881

882 *paPgno = &aPgno[-1];

883 *paHash = aHash;

884 *piZero = iZero;

885 }

886 return rc;

887 }

888

889 /*

890 ** Return the number of the wal-index page that contains the hash-table

891 ** and page-number array that contain entries corresponding to WAL frame

892 ** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages

893 ** are numbered starting from 0.

894 */

895 static int walFramePage(u32 iFrame){

896 int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE;

897 assert( (iHash==0 \|\| iFrame>HASHTABLE_NPAGE_ONE)

898 && (iHash>=1 \|\| iFrame<=HASHTABLE_NPAGE_ONE)

899 && (iHash<=1 \|\| iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE))

900 && (iHash>=2 \|\| iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)

901 && (iHash<=2 \|\| iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE))

902 );

903 return iHash;

904 }

905

906 /*

907 ** Return the page number associated with frame iFrame in this WAL.

908 */

909 static u32 walFramePgno(Wal *pWal, u32 iFrame){

910 int iHash = walFramePage(iFrame);

911 if( iHash==0 ){

912 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];

913 }

914 return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];

915 }

916

917 /*

918 ** Remove entries from the hash table that point to WAL slots greater

919 ** than pWal->hdr.mxFrame.

920 **

921 ** This function is called whenever pWal->hdr.mxFrame is decreased due

922 ** to a rollback or savepoint.

923 **

924 ** At most only the hash table containing pWal->hdr.mxFrame needs to be

925 ** updated. Any later hash tables will be automatically cleared when

926 ** pWal->hdr.mxFrame advances to the point where those hash tables are

927 ** actually needed.

928 */

929 static void walCleanupHash(Wal *pWal){

930 volatile ht_slot aHash = 0; / Pointer to hash table to clear */

931 volatile u32 aPgno = 0; / Page number array for hash table */

932 u32 iZero = 0; /* frame == (aHash[x]+iZero) */

933 int iLimit = 0; /* Zero values greater than this */

934 int nByte; /* Number of bytes to zero in aPgno[] */

935 int i; /* Used to iterate through aHash[] */

936

937 assert( pWal->writeLock );

938 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );

939 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );

940 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );

941

942 if( pWal->hdr.mxFrame==0 ) return;

943

944 /* Obtain pointers to the hash-table and page-number array containing

945 ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed

946 ** that the page said hash-table and array reside on is already mapped.

947 */

948 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );

949 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );

950 walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &aHash, &aPgno, &iZero);

951

952 /* Zero all hash-table entries that correspond to frame numbers greater

953 ** than pWal->hdr.mxFrame.

954 */

955 iLimit = pWal->hdr.mxFrame - iZero;

956 assert( iLimit>0 );

957 for(i=0; i<HASHTABLE_NSLOT; i++){

958 if( aHash[i]>iLimit ){

959 aHash[i] = 0;

960 }

961 }

962

963 /* Zero the entries in the aPgno array that correspond to frames with

964 ** frame numbers greater than pWal->hdr.mxFrame.

965 */

966 nByte = (int)((char )aHash - (char )&aPgno[iLimit+1]);

967 memset((void *)&aPgno[iLimit+1], 0, nByte);

968

969 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT

970 /* Verify that the every entry in the mapping region is still reachable

971 ** via the hash table even after the cleanup.

972 */

973 if( iLimit ){

974 int j; /* Loop counter */

975 int iKey; /* Hash key */

976 for(j=1; j<=iLimit; j++){

977 for(iKey=walHash(aPgno[j]); aHash[iKey]; iKey=walNextHash(iKey)){

978 if( aHash[iKey]==j ) break;

979 }

980 assert( aHash[iKey]==j );

981 }

982 }

983 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */

984 }

985

986

987 /*

988 ** Set an entry in the wal-index that will map database page number

989 ** pPage into WAL frame iFrame.

990 */

991 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){

992 int rc; /* Return code */

993 u32 iZero = 0; /* One less than frame number of aPgno[1] */

994 volatile u32 aPgno = 0; / Page number array */

995 volatile ht_slot aHash = 0; / Hash table */

996

997 rc = walHashGet(pWal, walFramePage(iFrame), &aHash, &aPgno, &iZero);

998

999 /* Assuming the wal-index file was successfully mapped, populate the

1000 ** page number array and hash table entry.

1001 */

1002 if( rc==SQLITE_OK ){

1003 int iKey; /* Hash table key */

1004 int idx; /* Value to write to hash-table slot */

1005 int nCollide; /* Number of hash collisions */

1006

1007 idx = iFrame - iZero;

1008 assert( idx <= HASHTABLE_NSLOT/2 + 1 );

1009

1010 /* If this is the first entry to be added to this hash-table, zero the

1011 ** entire hash table and aPgno[] array before proceeding.

1012 */

1013 if( idx==1 ){

1014 int nByte = (int)((u8 )&aHash[HASHTABLE_NSLOT] - (u8 )&aPgno[1]);

1015 memset((void*)&aPgno[1], 0, nByte);

1016 }

1017

1018 /* If the entry in aPgno[] is already set, then the previous writer

1019 ** must have exited unexpectedly in the middle of a transaction (after

1020 ** writing one or more dirty pages to the WAL to free up memory).

1021 ** Remove the remnants of that writers uncommitted transaction from

1022 ** the hash-table before writing any new entries.

1023 */

1024 if( aPgno[idx] ){

1025 walCleanupHash(pWal);

1026 assert( !aPgno[idx] );

1027 }

1028

1029 /* Write the aPgno[] array entry and the hash-table slot. */

1030 nCollide = idx;

1031 for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){

1032 if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;

1033 }

1034 aPgno[idx] = iPage;

1035 aHash[iKey] = (ht_slot)idx;

1036

1037 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT

1038 /* Verify that the number of entries in the hash table exactly equals

1039 ** the number of entries in the mapping region.

1040 */

1041 {

1042 int i; /* Loop counter */

1043 int nEntry = 0; /* Number of entries in the hash table */

1044 for(i=0; i<HASHTABLE_NSLOT; i++){ if( aHash[i] ) nEntry++; }

1045 assert( nEntry==idx );

1046 }

1047

1048 /* Verify that the every entry in the mapping region is reachable

1049 ** via the hash table. This turns out to be a really, really expensive

1050 ** thing to check, so only do this occasionally - not on every

1051 ** iteration.

1052 */

1053 if( (idx&0x3ff)==0 ){

1054 int i; /* Loop counter */

1055 for(i=1; i<=idx; i++){

1056 for(iKey=walHash(aPgno[i]); aHash[iKey]; iKey=walNextHash(iKey)){

1057 if( aHash[iKey]==i ) break;

1058 }

1059 assert( aHash[iKey]==i );

1060 }

1061 }

1062 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */

1063 }

1064

1065

1066 return rc;

1067 }

1068

1069

1070 /*

1071 ** Recover the wal-index by reading the write-ahead log file.

1072 **

1073 ** This routine first tries to establish an exclusive lock on the

1074 ** wal-index to prevent other threads/processes from doing anything

1075 ** with the WAL or wal-index while recovery is running. The

1076 ** WAL_RECOVER_LOCK is also held so that other threads will know

1077 ** that this thread is running recovery. If unable to establish

1078 ** the necessary locks, this routine returns SQLITE_BUSY.

1079 */

1080 static int walIndexRecover(Wal *pWal){

1081 int rc; /* Return Code */

1082 i64 nSize; /* Size of log file */

1083 u32 aFrameCksum[2] = {0, 0};

1084 int iLock; /* Lock offset to lock for checkpoint */

1085 int nLock; /* Number of locks to hold */

1086

1087 /* Obtain an exclusive lock on all byte in the locking range not already

1088 ** locked by the caller. The caller is guaranteed to have locked the

1089 ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.

1090 ** If successful, the same bytes that are locked here are unlocked before

1091 ** this function returns.

1092 */

1093 assert( pWal->ckptLock==1 \|\| pWal->ckptLock==0 );

1094 assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );

1095 assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );

1096 assert( pWal->writeLock );

1097 iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;

1098 nLock = SQLITE_SHM_NLOCK - iLock;

1099 rc = walLockExclusive(pWal, iLock, nLock);

1100 if( rc ){

1101 return rc;

1102 }

1103 WALTRACE(("WAL%p: recovery begin...\n", pWal));

1104

1105 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));

1106

1107 rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);

1108 if( rc!=SQLITE_OK ){

1109 goto recovery_error;

1110 }

1111

1112 if( nSize>WAL_HDRSIZE ){

1113 u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */

1114 u8 aFrame = 0; / Malloc'd buffer to load entire frame */

1115 int szFrame; /* Number of bytes in buffer aFrame[] */

1116 u8 aData; / Pointer to data part of aFrame buffer */

1117 int iFrame; /* Index of last frame read */

1118 i64 iOffset; /* Next offset to read from log file */

1119 int szPage; /* Page size according to the log */

1120 u32 magic; /* Magic value read from WAL header */

1121 u32 version; /* Magic value read from WAL header */

1122 int isValid; /* True if this frame is valid */

1123

1124 /* Read in the WAL header. */

1125 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);

1126 if( rc!=SQLITE_OK ){

1127 goto recovery_error;

1128 }

1129

1130 /* If the database page size is not a power of two, or is greater than

1131 ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid

1132 ** data. Similarly, if the 'magic' value is invalid, ignore the whole

1133 ** WAL file.

1134 */

1135 magic = sqlite3Get4byte(&aBuf[0]);

1136 szPage = sqlite3Get4byte(&aBuf[8]);

1137 if( (magic&0xFFFFFFFE)!=WAL_MAGIC

1138 \|\| szPage&(szPage-1)

1139 \|\| szPage>SQLITE_MAX_PAGE_SIZE

1140 \|\| szPage<512

1141 ){

1142 goto finished;

1143 }

1144 pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);

1145 pWal->szPage = szPage;

1146 pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);

1147 memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);

1148

1149 /* Verify that the WAL header checksum is correct */

1150 walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,

1151 aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum

1152 );

1153 if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])

1154 \|\| pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])

1155 ){

1156 goto finished;

1157 }

1158

1159 /* Verify that the version number on the WAL format is one that

1160 ** are able to understand */

1161 version = sqlite3Get4byte(&aBuf[4]);

1162 if( version!=WAL_MAX_VERSION ){

1163 rc = SQLITE_CANTOPEN_BKPT;

1164 goto finished;

1165 }

1166

1167 /* Malloc a buffer to read frames into. */

1168 szFrame = szPage + WAL_FRAME_HDRSIZE;

1169 aFrame = (u8 *)sqlite3_malloc64(szFrame);

1170 if( !aFrame ){

1171 rc = SQLITE_NOMEM;

1172 goto recovery_error;

1173 }

1174 aData = &aFrame[WAL_FRAME_HDRSIZE];

1175

1176 /* Read all frames from the log file. */

1177 iFrame = 0;

1178 for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){

1179 u32 pgno; /* Database page number for frame */

1180 u32 nTruncate; /* dbsize field from frame header */

1181

1182 /* Read and decode the next log frame. */

1183 iFrame++;

1184 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);

1185 if( rc!=SQLITE_OK ) break;

1186 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);

1187 if( !isValid ) break;

1188 rc = walIndexAppend(pWal, iFrame, pgno);

1189 if( rc!=SQLITE_OK ) break;

1190

1191 /* If nTruncate is non-zero, this is a commit record. */

1192 if( nTruncate ){

1193 pWal->hdr.mxFrame = iFrame;

1194 pWal->hdr.nPage = nTruncate;

1195 pWal->hdr.szPage = (u16)((szPage&0xff00) \| (szPage>>16));

1196 testcase( szPage<=32768 );

1197 testcase( szPage>=65536 );

1198 aFrameCksum[0] = pWal->hdr.aFrameCksum[0];

1199 aFrameCksum[1] = pWal->hdr.aFrameCksum[1];

1200 }

1201 }

1202

1203 sqlite3_free(aFrame);

1204 }

1205

1206 finished:

1207 if( rc==SQLITE_OK ){

1208 volatile WalCkptInfo *pInfo;

1209 int i;

1210 pWal->hdr.aFrameCksum[0] = aFrameCksum[0];

1211 pWal->hdr.aFrameCksum[1] = aFrameCksum[1];

1212 walIndexWriteHdr(pWal);

1213

1214 /* Reset the checkpoint-header. This is safe because this thread is

1215 ** currently holding locks that exclude all other readers, writers and

1216 ** checkpointers.

1217 */

1218 pInfo = walCkptInfo(pWal);

1219 pInfo->nBackfill = 0;

1220 pInfo->nBackfillAttempted = pWal->hdr.mxFrame;

1221 pInfo->aReadMark[0] = 0;

1222 for(i=1; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;

1223 if( pWal->hdr.mxFrame ) pInfo->aReadMark[1] = pWal->hdr.mxFrame;

1224

1225 /* If more than one frame was recovered from the log file, report an

1226 ** event via sqlite3_log(). This is to help with identifying performance

1227 ** problems caused by applications routinely shutting down without

1228 ** checkpointing the log file.

1229 */

1230 if( pWal->hdr.nPage ){

1231 sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,

1232 "recovered %d frames from WAL file %s",

1233 pWal->hdr.mxFrame, pWal->zWalName

1234 );

1235 }

1236 }

1237

1238 recovery_error:

1239 WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));

1240 walUnlockExclusive(pWal, iLock, nLock);

1241 return rc;

1242 }

1243

1244 /*

1245 ** Close an open wal-index.

1246 */

1247 static void walIndexClose(Wal *pWal, int isDelete){

1248 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){

1249 int i;

1250 for(i=0; i<pWal->nWiData; i++){

1251 sqlite3_free((void *)pWal->apWiData[i]);

1252 pWal->apWiData[i] = 0;

1253 }

1254 }else{

1255 sqlite3OsShmUnmap(pWal->pDbFd, isDelete);

1256 }

1257 }

1258

1259 /*

1260 ** Open a connection to the WAL file zWalName. The database file must

1261 ** already be opened on connection pDbFd. The buffer that zWalName points

1262 ** to must remain valid for the lifetime of the returned Wal* handle.

1263 **

1264 ** A SHARED lock should be held on the database file when this function

1265 ** is called. The purpose of this SHARED lock is to prevent any other

1266 ** client from unlinking the WAL or wal-index file. If another process

1267 ** were to do this just after this client opened one of these files, the

1268 ** system would be badly broken.

1269 **

1270 ** If the log file is successfully opened, SQLITE_OK is returned and

1271 ** *ppWal is set to point to a new WAL handle. If an error occurs,

1272 ** an SQLite error code is returned and *ppWal is left unmodified.

1273 */

1274 int sqlite3WalOpen(

1275 sqlite3_vfs pVfs, / vfs module to open wal and wal-index */

1276 sqlite3_file pDbFd, / The open database file */

1277 const char zWalName, / Name of the WAL file */

1278 int bNoShm, /* True to run in heap-memory mode */

1279 i64 mxWalSize, /* Truncate WAL to this size on reset */

1280 Wal *ppWal / OUT: Allocated Wal handle */

1281 ){

1282 int rc; /* Return Code */

1283 Wal pRet; / Object to allocate and return */

1284 int flags; /* Flags passed to OsOpen() */

1285

1286 assert( zWalName && zWalName[0] );

1287 assert( pDbFd );

1288

1289 /* In the amalgamation, the os_unix.c and os_win.c source files come before

1290 ** this source file. Verify that the #defines of the locking byte offsets

1291 ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.

1292 ** For that matter, if the lock offset ever changes from its initial design

1293 ** value of 120, we need to know that so there is an assert() to check it.

1294 */

1295 assert( 120==WALINDEX_LOCK_OFFSET );

1296 assert( 136==WALINDEX_HDR_SIZE );

1297 #ifdef WIN_SHM_BASE

1298 assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );

1299 #endif

1300 #ifdef UNIX_SHM_BASE

1301 assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );

1302 #endif

1303

1304

1305 /* Allocate an instance of struct Wal to return. */

1306 *ppWal = 0;

1307 pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);

1308 if( !pRet ){

1309 return SQLITE_NOMEM;

1310 }

1311

1312 pRet->pVfs = pVfs;

1313 pRet->pWalFd = (sqlite3_file *)&pRet[1];

1314 pRet->pDbFd = pDbFd;

1315 pRet->readLock = -1;

1316 pRet->mxWalSize = mxWalSize;

1317 pRet->zWalName = zWalName;

1318 pRet->syncHeader = 1;

1319 pRet->padToSectorBoundary = 1;

1320 pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);

1321

1322 /* Open file handle on the write-ahead log file. */

1323 flags = (SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE\|SQLITE_OPEN_WAL);

1324 rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);

1325 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){

1326 pRet->readOnly = WAL_RDONLY;

1327 }

1328

1329 if( rc!=SQLITE_OK ){

1330 walIndexClose(pRet, 0);

1331 sqlite3OsClose(pRet->pWalFd);

1332 sqlite3_free(pRet);

1333 }else{

1334 int iDC = sqlite3OsDeviceCharacteristics(pDbFd);

1335 if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; }

1336 if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){

1337 pRet->padToSectorBoundary = 0;

1338 }

1339 *ppWal = pRet;

1340 WALTRACE(("WAL%d: opened\n", pRet));

1341 }

1342 return rc;

1343 }

1344

1345 /*

1346 ** Change the size to which the WAL file is trucated on each reset.

1347 */

1348 void sqlite3WalLimit(Wal *pWal, i64 iLimit){

1349 if( pWal ) pWal->mxWalSize = iLimit;

1350 }

1351

1352 /*

1353 ** Find the smallest page number out of all pages held in the WAL that

1354 ** has not been returned by any prior invocation of this method on the

1355 ** same WalIterator object. Write into *piFrame the frame index where

1356 ** that page was last written into the WAL. Write into *piPage the page

1357 ** number.

1358 **

1359 ** Return 0 on success. If there are no pages in the WAL with a page

1360 ** number larger than *piPage, then return 1.

1361 */

1362 static int walIteratorNext(

1363 WalIterator p, / Iterator */

1364 u32 piPage, / OUT: The page number of the next page */

1365 u32 piFrame / OUT: Wal frame index of next page */

1366 ){

1367 u32 iMin; /* Result pgno must be greater than iMin */

1368 u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */

1369 int i; /* For looping through segments */

1370

1371 iMin = p->iPrior;

1372 assert( iMin<0xffffffff );

1373 for(i=p->nSegment-1; i>=0; i--){

1374 struct WalSegment *pSegment = &p->aSegment[i];

1375 while( pSegment->iNext<pSegment->nEntry ){

1376 u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];

1377 if( iPg>iMin ){

1378 if( iPg<iRet ){

1379 iRet = iPg;

1380 *piFrame = pSegment->iZero + pSegment->aIndex[pSegment->iNext];

1381 }

1382 break;

1383 }

1384 pSegment->iNext++;

1385 }

1386 }

1387

1388 *piPage = p->iPrior = iRet;

1389 return (iRet==0xFFFFFFFF);

1390 }

1391

1392 /*

1393 ** This function merges two sorted lists into a single sorted list.

1394 **

1395 ** aLeft[] and aRight[] are arrays of indices. The sort key is

1396 ** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following

1397 ** is guaranteed for all J<K:

1398 **

1399 ** aContent[aLeft[J]] < aContent[aLeft[K]]

1400 ** aContent[aRight[J]] < aContent[aRight[K]]

1401 **

1402 ** This routine overwrites aRight[] with a new (probably longer) sequence

1403 ** of indices such that the aRight[] contains every index that appears in

1404 ** either aLeft[] or the old aRight[] and such that the second condition

1405 ** above is still met.

1406 **

1407 ** The aContent[aLeft[X]] values will be unique for all X. And the

1408 ** aContent[aRight[X]] values will be unique too. But there might be

1409 ** one or more combinations of X and Y such that

1410 **

1411 ** aLeft[X]!=aRight[Y] && aContent[aLeft[X]] == aContent[aRight[Y]]

1412 **

1413 ** When that happens, omit the aLeft[X] and use the aRight[Y] index.

1414 */

1415 static void walMerge(

1416 const u32 aContent, / Pages in wal - keys for the sort */

1417 ht_slot aLeft, / IN: Left hand input list */

1418 int nLeft, /* IN: Elements in array paLeft /

1419 ht_slot *paRight, / IN/OUT: Right hand input list */

1420 int pnRight, / IN/OUT: Elements in paRight /

1421 ht_slot aTmp / Temporary buffer */

1422 ){

1423 int iLeft = 0; /* Current index in aLeft */

1424 int iRight = 0; /* Current index in aRight */

1425 int iOut = 0; /* Current index in output buffer */

1426 int nRight = *pnRight;

1427 ht_slot aRight = paRight;

1428

1429 assert( nLeft>0 && nRight>0 );

1430 while( iRight<nRight \|\| iLeft<nLeft ){

1431 ht_slot logpage;

1432 Pgno dbpage;

1433

1434 if( (iLeft<nLeft)

1435 && (iRight>=nRight \|\| aContent[aLeft[iLeft]]<aContent[aRight[iRight]])

1436 ){

1437 logpage = aLeft[iLeft++];

1438 }else{

1439 logpage = aRight[iRight++];

1440 }

1441 dbpage = aContent[logpage];

1442

1443 aTmp[iOut++] = logpage;

1444 if( iLeft<nLeft && aContent[aLeft[iLeft]]==dbpage ) iLeft++;

1445

1446 assert( iLeft>=nLeft \|\| aContent[aLeft[iLeft]]>dbpage );

1447 assert( iRight>=nRight \|\| aContent[aRight[iRight]]>dbpage );

1448 }

1449

1450 *paRight = aLeft;

1451 *pnRight = iOut;

1452 memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut);

1453 }

1454

1455 /*

1456 ** Sort the elements in list aList using aContent[] as the sort key.

1457 ** Remove elements with duplicate keys, preferring to keep the

1458 ** larger aList[] values.

1459 **

1460 ** The aList[] entries are indices into aContent[]. The values in

1461 ** aList[] are to be sorted so that for all J<K:

1462 **

1463 ** aContent[aList[J]] < aContent[aList[K]]

1464 **

1465 ** For any X and Y such that

1466 **

1467 ** aContent[aList[X]] == aContent[aList[Y]]

1468 **

1469 ** Keep the larger of the two values aList[X] and aList[Y] and discard

1470 ** the smaller.

1471 */

1472 static void walMergesort(

1473 const u32 aContent, / Pages in wal */

1474 ht_slot aBuffer, / Buffer of at least pnList items to use /

1475 ht_slot aList, / IN/OUT: List to sort */

1476 int pnList / IN/OUT: Number of elements in aList[] */

1477 ){

1478 struct Sublist {

1479 int nList; /* Number of elements in aList */

1480 ht_slot aList; / Pointer to sub-list content */

1481 };

1482

1483 const int nList = pnList; / Size of input list */

1484 int nMerge = 0; /* Number of elements in list aMerge */

1485 ht_slot aMerge = 0; / List to be merged */

1486 int iList; /* Index into input list */

1487 u32 iSub = 0; /* Index into aSub array */

1488 struct Sublist aSub[13]; /* Array of sub-lists */

1489

1490 memset(aSub, 0, sizeof(aSub));

1491 assert( nList<=HASHTABLE_NPAGE && nList>0 );

1492 assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );

1493

1494 for(iList=0; iList<nList; iList++){

1495 nMerge = 1;

1496 aMerge = &aList[iList];

1497 for(iSub=0; iList & (1<<iSub); iSub++){

1498 struct Sublist *p;

1499 assert( iSub<ArraySize(aSub) );

1500 p = &aSub[iSub];

1501 assert( p->aList && p->nList<=(1<<iSub) );

1502 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );

1503 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);

1504 }

1505 aSub[iSub].aList = aMerge;

1506 aSub[iSub].nList = nMerge;

1507 }

1508

1509 for(iSub++; iSub<ArraySize(aSub); iSub++){

1510 if( nList & (1<<iSub) ){

1511 struct Sublist *p;

1512 assert( iSub<ArraySize(aSub) );

1513 p = &aSub[iSub];

1514 assert( p->nList<=(1<<iSub) );

1515 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );

1516 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);

1517 }

1518 }

1519 assert( aMerge==aList );

1520 *pnList = nMerge;

1521

1522 #ifdef SQLITE_DEBUG

1523 {

1524 int i;

1525 for(i=1; i<*pnList; i++){

1526 assert( aContent[aList[i]] > aContent[aList[i-1]] );

1527 }

1528 }

1529 #endif

1530 }

1531

1532 /*

1533 ** Free an iterator allocated by walIteratorInit().

1534 */

1535 static void walIteratorFree(WalIterator *p){

1536 sqlite3_free(p);

1537 }

1538

1539 /*

1540 ** Construct a WalInterator object that can be used to loop over all

1541 ** pages in the WAL in ascending order. The caller must hold the checkpoint

1542 ** lock.

1543 **

1544 ** On success, make *pp point to the newly allocated WalInterator object

1545 ** return SQLITE_OK. Otherwise, return an error code. If this routine

1546 ** returns an error, the value of *pp is undefined.

1547 **

1548 ** The calling routine should invoke walIteratorFree() to destroy the

1549 ** WalIterator object when it has finished with it.

1550 */

1551 static int walIteratorInit(Wal pWal, WalIterator *pp){

1552 WalIterator p; / Return value */

1553 int nSegment; /* Number of segments to merge */

1554 u32 iLast; /* Last frame in log */

1555 int nByte; /* Number of bytes to allocate */

1556 int i; /* Iterator variable */

1557 ht_slot aTmp; / Temp space used by merge-sort */

1558 int rc = SQLITE_OK; /* Return Code */

1559

1560 /* This routine only runs while holding the checkpoint lock. And

1561 ** it only runs if there is actually content in the log (mxFrame>0).

1562 */

1563 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );

1564 iLast = pWal->hdr.mxFrame;

1565

1566 /* Allocate space for the WalIterator object. */

1567 nSegment = walFramePage(iLast) + 1;

1568 nByte = sizeof(WalIterator)

1569 + (nSegment-1)*sizeof(struct WalSegment)

1570 + iLast*sizeof(ht_slot);

1571 p = (WalIterator *)sqlite3_malloc64(nByte);

1572 if( !p ){

1573 return SQLITE_NOMEM;

1574 }

1575 memset(p, 0, nByte);

1576 p->nSegment = nSegment;

1577

1578 /* Allocate temporary space used by the merge-sort routine. This block

1579 ** of memory will be freed before this function returns.

1580 */

1581 aTmp = (ht_slot *)sqlite3_malloc64(

1582 sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast)

1583 );

1584 if( !aTmp ){

1585 rc = SQLITE_NOMEM;

1586 }

1587

1588 for(i=0; rc==SQLITE_OK && i<nSegment; i++){

1589 volatile ht_slot *aHash;

1590 u32 iZero;

1591 volatile u32 *aPgno;

1592

1593 rc = walHashGet(pWal, i, &aHash, &aPgno, &iZero);

1594 if( rc==SQLITE_OK ){

1595 int j; /* Counter variable */

1596 int nEntry; /* Number of entries in this segment */

1597 ht_slot aIndex; / Sorted index for this segment */

1598

1599 aPgno++;

1600 if( (i+1)==nSegment ){

1601 nEntry = (int)(iLast - iZero);

1602 }else{

1603 nEntry = (int)((u32)aHash - (u32)aPgno);

1604 }

1605 aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];

1606 iZero++;

1607

1608 for(j=0; j<nEntry; j++){

1609 aIndex[j] = (ht_slot)j;

1610 }

1611 walMergesort((u32 *)aPgno, aTmp, aIndex, &nEntry);

1612 p->aSegment[i].iZero = iZero;

1613 p->aSegment[i].nEntry = nEntry;

1614 p->aSegment[i].aIndex = aIndex;

1615 p->aSegment[i].aPgno = (u32 *)aPgno;

1616 }

1617 }

1618 sqlite3_free(aTmp);

1619

1620 if( rc!=SQLITE_OK ){

1621 walIteratorFree(p);

1622 }

1623 *pp = p;

1624 return rc;

1625 }

1626

1627 /*

1628 ** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and

1629 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a

1630 ** busy-handler function. Invoke it and retry the lock until either the

1631 ** lock is successfully obtained or the busy-handler returns 0.

1632 */

1633 static int walBusyLock(

1634 Wal pWal, / WAL connection */

1635 int (xBusy)(void), /* Function to call when busy */

1636 void pBusyArg, / Context argument for xBusyHandler */

1637 int lockIdx, /* Offset of first byte to lock */

1638 int n /* Number of bytes to lock */

1639 ){

1640 int rc;

1641 do {

1642 rc = walLockExclusive(pWal, lockIdx, n);

1643 }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) );

1644 return rc;

1645 }

1646

1647 /*

1648 ** The cache of the wal-index header must be valid to call this function.

1649 ** Return the page-size in bytes used by the database.

1650 */

1651 static int walPagesize(Wal *pWal){

1652 return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);

1653 }

1654

1655 /*

1656 ** The following is guaranteed when this function is called:

1657 **

1658 ** a) the WRITER lock is held,

1659 ** b) the entire log file has been checkpointed, and

1660 ** c) any existing readers are reading exclusively from the database

1661 ** file - there are no readers that may attempt to read a frame from

1662 ** the log file.

1663 **

1664 ** This function updates the shared-memory structures so that the next

1665 ** client to write to the database (which may be this one) does so by

1666 ** writing frames into the start of the log file.

1667 **

1668 ** The value of parameter salt1 is used as the aSalt[1] value in the

1669 ** new wal-index header. It should be passed a pseudo-random value (i.e.

1670 ** one obtained from sqlite3_randomness()).

1671 */

1672 static void walRestartHdr(Wal *pWal, u32 salt1){

1673 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);

1674 int i; /* Loop counter */

1675 u32 aSalt = pWal->hdr.aSalt; / Big-endian salt values */

1676 pWal->nCkpt++;

1677 pWal->hdr.mxFrame = 0;

1678 sqlite3Put4byte((u8)&aSalt[0], 1 + sqlite3Get4byte((u8)&aSalt[0]));

1679 memcpy(&pWal->hdr.aSalt[1], &salt1, 4);

1680 walIndexWriteHdr(pWal);

1681 pInfo->nBackfill = 0;

1682 pInfo->nBackfillAttempted = 0;

1683 pInfo->aReadMark[1] = 0;

1684 for(i=2; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;

1685 assert( pInfo->aReadMark[0]==0 );

1686 }

1687

1688 /*

1689 ** Copy as much content as we can from the WAL back into the database file

1690 ** in response to an sqlite3_wal_checkpoint() request or the equivalent.

1691 **

1692 ** The amount of information copies from WAL to database might be limited

1693 ** by active readers. This routine will never overwrite a database page

1694 ** that a concurrent reader might be using.

1695 **

1696 ** All I/O barrier operations (a.k.a fsyncs) occur in this routine when

1697 ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if

1698 ** checkpoints are always run by a background thread or background

1699 ** process, foreground threads will never block on a lengthy fsync call.

1700 **

1701 ** Fsync is called on the WAL before writing content out of the WAL and

1702 ** into the database. This ensures that if the new content is persistent

1703 ** in the WAL and can be recovered following a power-loss or hard reset.

1704 **

1705 ** Fsync is also called on the database file if (and only if) the entire

1706 ** WAL content is copied into the database file. This second fsync makes

1707 ** it safe to delete the WAL since the new content will persist in the

1708 ** database file.

1709 **

1710 ** This routine uses and updates the nBackfill field of the wal-index header.

1711 ** This is the only routine that will increase the value of nBackfill.

1712 ** (A WAL reset or recovery will revert nBackfill to zero, but not increase

1713 ** its value.)

1714 **

1715 ** The caller must be holding sufficient locks to ensure that no other

1716 ** checkpoint is running (in any other thread or process) at the same

1717 ** time.

1718 */

1719 static int walCheckpoint(

1720 Wal pWal, / Wal connection */

1721 int eMode, /* One of PASSIVE, FULL or RESTART */

1722 int (xBusy)(void), /* Function to call when busy */

1723 void pBusyArg, / Context argument for xBusyHandler */

1724 int sync_flags, /* Flags for OsSync() (or 0) */

1725 u8 zBuf / Temporary buffer to use */

1726 ){

1727 int rc = SQLITE_OK; /* Return code */

1728 int szPage; /* Database page-size */

1729 WalIterator pIter = 0; / Wal iterator context */

1730 u32 iDbpage = 0; /* Next database page to write */

1731 u32 iFrame = 0; /* Wal frame containing data for iDbpage */

1732 u32 mxSafeFrame; /* Max frame that can be backfilled */

1733 u32 mxPage; /* Max database page to write */

1734 int i; /* Loop counter */

1735 volatile WalCkptInfo pInfo; / The checkpoint status information */

1736

1737 szPage = walPagesize(pWal);

1738 testcase( szPage<=32768 );

1739 testcase( szPage>=65536 );

1740 pInfo = walCkptInfo(pWal);

1741 if( pInfo->nBackfill<pWal->hdr.mxFrame ){

1742

1743 /* Allocate the iterator */

1744 rc = walIteratorInit(pWal, &pIter);

1745 if( rc!=SQLITE_OK ){

1746 return rc;

1747 }

1748 assert( pIter );

1749

1750 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked

1751 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */

1752 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE \|\| xBusy==0 );

1753

1754 /* Compute in mxSafeFrame the index of the last frame of the WAL that is

1755 ** safe to write into the database. Frames beyond mxSafeFrame might

1756 ** overwrite database pages that are in use by active readers and thus

1757 ** cannot be backfilled from the WAL.

1758 */

1759 mxSafeFrame = pWal->hdr.mxFrame;

1760 mxPage = pWal->hdr.nPage;

1761 for(i=1; i<WAL_NREADER; i++){

1762 /* Thread-sanitizer reports that the following is an unsafe read,

1763 ** as some other thread may be in the process of updating the value

1764 ** of the aReadMark[] slot. The assumption here is that if that is

1765 ** happening, the other client may only be increasing the value,

1766 ** not decreasing it. So assuming either that either the "old" or

1767 ** "new" version of the value is read, and not some arbitrary value

1768 ** that would never be written by a real client, things are still

1769 ** safe. */

1770 u32 y = pInfo->aReadMark[i];

1771 if( mxSafeFrame>y ){

1772 assert( y<=pWal->hdr.mxFrame );

1773 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);

1774 if( rc==SQLITE_OK ){

1775 pInfo->aReadMark[i] = (i==1 ? mxSafeFrame : READMARK_NOT_USED);

1776 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);

1777 }else if( rc==SQLITE_BUSY ){

1778 mxSafeFrame = y;

1779 xBusy = 0;

1780 }else{

1781 goto walcheckpoint_out;

1782 }

1783 }

1784 }

1785

1786 if( pInfo->nBackfill<mxSafeFrame

1787 && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0),1))==SQLITE_OK

1788 ){

1789 i64 nSize; /* Current size of database file */

1790 u32 nBackfill = pInfo->nBackfill;

1791

1792 pInfo->nBackfillAttempted = mxSafeFrame;

1793

1794 /* Sync the WAL to disk */

1795 if( sync_flags ){

1796 rc = sqlite3OsSync(pWal->pWalFd, sync_flags);

1797 }

1798

1799 /* If the database may grow as a result of this checkpoint, hint

1800 ** about the eventual size of the db file to the VFS layer.

1801 */

1802 if( rc==SQLITE_OK ){

1803 i64 nReq = ((i64)mxPage * szPage);

1804 rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);

1805 if( rc==SQLITE_OK && nSize<nReq ){

1806 sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT, &nReq);

1807 }

1808 }

1809

1810

1811 /* Iterate through the contents of the WAL, copying data to the db file */

1812 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){

1813 i64 iOffset;

1814 assert( walFramePgno(pWal, iFrame)==iDbpage );

1815 if( iFrame<=nBackfill \|\| iFrame>mxSafeFrame \|\| iDbpage>mxPage ){

1816 continue;

1817 }

1818 iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;

1819 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */

1820 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);

1821 if( rc!=SQLITE_OK ) break;

1822 iOffset = (iDbpage-1)*(i64)szPage;

1823 testcase( IS_BIG_INT(iOffset) );

1824 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);

1825 if( rc!=SQLITE_OK ) break;

1826 }

1827

1828 /* If work was actually accomplished... */

1829 if( rc==SQLITE_OK ){

1830 if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){

1831 i64 szDb = pWal->hdr.nPage*(i64)szPage;

1832 testcase( IS_BIG_INT(szDb) );

1833 rc = sqlite3OsTruncate(pWal->pDbFd, szDb);

1834 if( rc==SQLITE_OK && sync_flags ){

1835 rc = sqlite3OsSync(pWal->pDbFd, sync_flags);

1836 }

1837 }

1838 if( rc==SQLITE_OK ){

1839 pInfo->nBackfill = mxSafeFrame;

1840 }

1841 }

1842

1843 /* Release the reader lock held while backfilling */

1844 walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);

1845 }

1846

1847 if( rc==SQLITE_BUSY ){

1848 /* Reset the return code so as not to report a checkpoint failure

1849 ** just because there are active readers. */

1850 rc = SQLITE_OK;

1851 }

1852 }

1853

1854 /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the

1855 ** entire wal file has been copied into the database file, then block

1856 ** until all readers have finished using the wal file. This ensures that

1857 ** the next process to write to the database restarts the wal file.

1858 */

1859 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){

1860 assert( pWal->writeLock );

1861 if( pInfo->nBackfill<pWal->hdr.mxFrame ){

1862 rc = SQLITE_BUSY;

1863 }else if( eMode>=SQLITE_CHECKPOINT_RESTART ){

1864 u32 salt1;

1865 sqlite3_randomness(4, &salt1);

1866 assert( pInfo->nBackfill==pWal->hdr.mxFrame );

1867 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);

1868 if( rc==SQLITE_OK ){

1869 if( eMode==SQLITE_CHECKPOINT_TRUNCATE ){

1870 /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as

1871 ** SQLITE_CHECKPOINT_RESTART with the addition that it also

1872 ** truncates the log file to zero bytes just prior to a

1873 ** successful return.

1874 **

1875 ** In theory, it might be safe to do this without updating the

1876 ** wal-index header in shared memory, as all subsequent reader or

1877 ** writer clients should see that the entire log file has been

1878 ** checkpointed and behave accordingly. This seems unsafe though,

1879 ** as it would leave the system in a state where the contents of

1880 ** the wal-index header do not match the contents of the

1881 ** file-system. To avoid this, update the wal-index header to

1882 ** indicate that the log file contains zero valid frames. */

1883 walRestartHdr(pWal, salt1);

1884 rc = sqlite3OsTruncate(pWal->pWalFd, 0);

1885 }

1886 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);

1887 }

1888 }

1889 }

1890

1891 walcheckpoint_out:

1892 walIteratorFree(pIter);

1893 return rc;

1894 }

1895

1896 /*

1897 ** If the WAL file is currently larger than nMax bytes in size, truncate

1898 ** it to exactly nMax bytes. If an error occurs while doing so, ignore it.

1899 */

1900 static void walLimitSize(Wal *pWal, i64 nMax){

1901 i64 sz;

1902 int rx;

1903 sqlite3BeginBenignMalloc();

1904 rx = sqlite3OsFileSize(pWal->pWalFd, &sz);

1905 if( rx==SQLITE_OK && (sz > nMax ) ){

1906 rx = sqlite3OsTruncate(pWal->pWalFd, nMax);

1907 }

1908 sqlite3EndBenignMalloc();

1909 if( rx ){

1910 sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);

1911 }

1912 }

1913

1914 /*

1915 ** Close a connection to a log file.

1916 */

1917 int sqlite3WalClose(

1918 Wal pWal, / Wal to close */

1919 int sync_flags, /* Flags to pass to OsSync() (or 0) */

1920 int nBuf,

1921 u8 zBuf / Buffer of at least nBuf bytes */

1922 ){

1923 int rc = SQLITE_OK;

1924 if( pWal ){

1925 int isDelete = 0; /* True to unlink wal and wal-index files */

1926

1927 /* If an EXCLUSIVE lock can be obtained on the database file (using the

1928 ** ordinary, rollback-mode locking methods, this guarantees that the

1929 ** connection associated with this log file is the only connection to

1930 ** the database. In this case checkpoint the database and unlink both

1931 ** the wal and wal-index files.

1932 **

1933 ** The EXCLUSIVE lock is not released before returning.

1934 */

1935 rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE);

1936 if( rc==SQLITE_OK ){

1937 if( pWal->exclusiveMode==WAL_NORMAL_MODE ){

1938 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;

1939 }

1940 rc = sqlite3WalCheckpoint(

1941 pWal, SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0

1942 );

1943 if( rc==SQLITE_OK ){

1944 int bPersist = -1;

1945 sqlite3OsFileControlHint(

1946 pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist

1947 );

1948 if( bPersist!=1 ){

1949 /* Try to delete the WAL file if the checkpoint completed and

1950 ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal

1951 ** mode (!bPersist) */

1952 isDelete = 1;

1953 }else if( pWal->mxWalSize>=0 ){

1954 /* Try to truncate the WAL file to zero bytes if the checkpoint

1955 ** completed and fsynced (rc==SQLITE_OK) and we are in persistent

1956 ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a

1957 ** non-negative value (pWal->mxWalSize>=0). Note that we truncate

1958 ** to zero bytes as truncating to the journal_size_limit might

1959 ** leave a corrupt WAL file on disk. */

1960 walLimitSize(pWal, 0);

1961 }

1962 }

1963 }

1964

1965 walIndexClose(pWal, isDelete);

1966 sqlite3OsClose(pWal->pWalFd);

1967 if( isDelete ){

1968 sqlite3BeginBenignMalloc();

1969 sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);

1970 sqlite3EndBenignMalloc();

1971 }

1972 WALTRACE(("WAL%p: closed\n", pWal));

1973 sqlite3_free((void *)pWal->apWiData);

1974 sqlite3_free(pWal);

1975 }

1976 return rc;

1977 }

1978

1979 /*

1980 ** Try to read the wal-index header. Return 0 on success and 1 if

1981 ** there is a problem.

1982 **

1983 ** The wal-index is in shared memory. Another thread or process might

1984 ** be writing the header at the same time this procedure is trying to

1985 ** read it, which might result in inconsistency. A dirty read is detected

1986 ** by verifying that both copies of the header are the same and also by

1987 ** a checksum on the header.

1988 **

1989 ** If and only if the read is consistent and the header is different from

1990 ** pWal->hdr, then pWal->hdr is updated to the content of the new header

1991 ** and *pChanged is set to 1.

1992 **

1993 ** If the checksum cannot be verified return non-zero. If the header

1994 ** is read successfully and the checksum verified, return zero.

1995 */

1996 static int walIndexTryHdr(Wal pWal, int pChanged){

1997 u32 aCksum[2]; /* Checksum on the header content */

1998 WalIndexHdr h1, h2; /* Two copies of the header content */

1999 WalIndexHdr volatile aHdr; / Header in shared memory */

2000

2001 /* The first page of the wal-index must be mapped at this point. */

2002 assert( pWal->nWiData>0 && pWal->apWiData[0] );

2003

2004 /* Read the header. This might happen concurrently with a write to the

2005 ** same area of shared memory on a different CPU in a SMP,

2006 ** meaning it is possible that an inconsistent snapshot is read

2007 ** from the file. If this happens, return non-zero.

2008 **

2009 ** There are two copies of the header at the beginning of the wal-index.

2010 ** When reading, read [0] first then [1]. Writes are in the reverse order.

2011 ** Memory barriers are used to prevent the compiler or the hardware from

2012 ** reordering the reads and writes.

2013 */

2014 aHdr = walIndexHdr(pWal);

2015 memcpy(&h1, (void *)&aHdr[0], sizeof(h1));

2016 walShmBarrier(pWal);

2017 memcpy(&h2, (void *)&aHdr[1], sizeof(h2));

2018

2019 if( memcmp(&h1, &h2, sizeof(h1))!=0 ){

2020 return 1; /* Dirty read */

2021 }

2022 if( h1.isInit==0 ){

2023 return 1; /* Malformed header - probably all zeros */

2024 }

2025 walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum);

2026 if( aCksum[0]!=h1.aCksum[0] \|\| aCksum[1]!=h1.aCksum[1] ){

2027 return 1; /* Checksum does not match */

2028 }

2029

2030 if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){

2031 *pChanged = 1;

2032 memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));

2033 pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);

2034 testcase( pWal->szPage<=32768 );

2035 testcase( pWal->szPage>=65536 );

2036 }

2037

2038 /* The header was successfully read. Return zero. */

2039 return 0;

2040 }

2041

2042 /*

2043 ** Read the wal-index header from the wal-index and into pWal->hdr.

2044 ** If the wal-header appears to be corrupt, try to reconstruct the

2045 ** wal-index from the WAL before returning.

2046 **

2047 ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is

2048 ** changed by this operation. If pWal->hdr is unchanged, set *pChanged

2049 ** to 0.

2050 **

2051 ** If the wal-index header is successfully read, return SQLITE_OK.

2052 ** Otherwise an SQLite error code.

2053 */

2054 static int walIndexReadHdr(Wal pWal, int pChanged){

2055 int rc; /* Return code */

2056 int badHdr; /* True if a header read failed */

2057 volatile u32 page0; / Chunk of wal-index containing header */

2058

2059 /* Ensure that page 0 of the wal-index (the page that contains the

2060 ** wal-index header) is mapped. Return early if an error occurs here.

2061 */

2062 assert( pChanged );

2063 rc = walIndexPage(pWal, 0, &page0);

2064 if( rc!=SQLITE_OK ){

2065 return rc;

2066 };

2067 assert( page0 \|\| pWal->writeLock==0 );

2068

2069 /* If the first page of the wal-index has been mapped, try to read the

2070 ** wal-index header immediately, without holding any lock. This usually

2071 ** works, but may fail if the wal-index header is corrupt or currently

2072 ** being modified by another thread or process.

2073 */

2074 badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1);

2075

2076 /* If the first attempt failed, it might have been due to a race

2077 ** with a writer. So get a WRITE lock and try again.

2078 */

2079 assert( badHdr==0 \|\| pWal->writeLock==0 );

2080 if( badHdr ){

2081 if( pWal->readOnly & WAL_SHM_RDONLY ){

2082 if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){

2083 walUnlockShared(pWal, WAL_WRITE_LOCK);

2084 rc = SQLITE_READONLY_RECOVERY;

2085 }

2086 }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){

2087 pWal->writeLock = 1;

2088 if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){

2089 badHdr = walIndexTryHdr(pWal, pChanged);

2090 if( badHdr ){

2091 /* If the wal-index header is still malformed even while holding

2092 ** a WRITE lock, it can only mean that the header is corrupted and

2093 ** needs to be reconstructed. So run recovery to do exactly that.

2094 */

2095 rc = walIndexRecover(pWal);

2096 *pChanged = 1;

2097 }

2098 }

2099 pWal->writeLock = 0;

2100 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);

2101 }

2102 }

2103

2104 /* If the header is read successfully, check the version number to make

2105 ** sure the wal-index was not constructed with some future format that

2106 ** this version of SQLite cannot understand.

2107 */

2108 if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){

2109 rc = SQLITE_CANTOPEN_BKPT;

2110 }

2111

2112 return rc;

2113 }

2114

2115 /*

2116 ** This is the value that walTryBeginRead returns when it needs to

2117 ** be retried.

2118 */

2119 #define WAL_RETRY (-1)

2120

2121 /*

2122 ** Attempt to start a read transaction. This might fail due to a race or

2123 ** other transient condition. When that happens, it returns WAL_RETRY to

2124 ** indicate to the caller that it is safe to retry immediately.

2125 **

2126 ** On success return SQLITE_OK. On a permanent failure (such an

2127 ** I/O error or an SQLITE_BUSY because another process is running

2128 ** recovery) return a positive error code.

2129 **

2130 ** The useWal parameter is true to force the use of the WAL and disable

2131 ** the case where the WAL is bypassed because it has been completely

2132 ** checkpointed. If useWal==0 then this routine calls walIndexReadHdr()

2133 ** to make a copy of the wal-index header into pWal->hdr. If the

2134 ** wal-index header has changed, *pChanged is set to 1 (as an indication

2135 ** to the caller that the local paget cache is obsolete and needs to be

2136 ** flushed.) When useWal==1, the wal-index header is assumed to already

2137 ** be loaded and the pChanged parameter is unused.

2138 **

2139 ** The caller must set the cnt parameter to the number of prior calls to

2140 ** this routine during the current read attempt that returned WAL_RETRY.

2141 ** This routine will start taking more aggressive measures to clear the

2142 ** race conditions after multiple WAL_RETRY returns, and after an excessive

2143 ** number of errors will ultimately return SQLITE_PROTOCOL. The

2144 ** SQLITE_PROTOCOL return indicates that some other process has gone rogue

2145 ** and is not honoring the locking protocol. There is a vanishingly small

2146 ** chance that SQLITE_PROTOCOL could be returned because of a run of really

2147 ** bad luck when there is lots of contention for the wal-index, but that

2148 ** possibility is so small that it can be safely neglected, we believe.

2149 **

2150 ** On success, this routine obtains a read lock on

2151 ** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is

2152 ** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1)

2153 ** that means the Wal does not hold any read lock. The reader must not

2154 ** access any database page that is modified by a WAL frame up to and

2155 ** including frame number aReadMark[pWal->readLock]. The reader will

2156 ** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0

2157 ** Or if pWal->readLock==0, then the reader will ignore the WAL

2158 ** completely and get all content directly from the database file.

2159 ** If the useWal parameter is 1 then the WAL will never be ignored and

2160 ** this routine will always set pWal->readLock>0 on success.

2161 ** When the read transaction is completed, the caller must release the

2162 ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.

2163 **

2164 ** This routine uses the nBackfill and aReadMark[] fields of the header

2165 ** to select a particular WAL_READ_LOCK() that strives to let the

2166 ** checkpoint process do as much work as possible. This routine might

2167 ** update values of the aReadMark[] array in the header, but if it does

2168 ** so it takes care to hold an exclusive lock on the corresponding

2169 ** WAL_READ_LOCK() while changing values.

2170 */

2171 static int walTryBeginRead(Wal pWal, int pChanged, int useWal, int cnt){

2172 volatile WalCkptInfo pInfo; / Checkpoint information in wal-index */

2173 u32 mxReadMark; /* Largest aReadMark[] value */

2174 int mxI; /* Index of largest aReadMark[] value */

2175 int i; /* Loop counter */

2176 int rc = SQLITE_OK; /* Return code */

2177 u32 mxFrame; /* Wal frame to lock to */

2178

2179 assert( pWal->readLock<0 ); /* Not currently locked */

2180

2181 /* Take steps to avoid spinning forever if there is a protocol error.

2182 **

2183 ** Circumstances that cause a RETRY should only last for the briefest

2184 ** instances of time. No I/O or other system calls are done while the

2185 ** locks are held, so the locks should not be held for very long. But

2186 ** if we are unlucky, another process that is holding a lock might get

2187 ** paged out or take a page-fault that is time-consuming to resolve,

2188 ** during the few nanoseconds that it is holding the lock. In that case,

2189 ** it might take longer than normal for the lock to free.

2190 **

2191 ** After 5 RETRYs, we begin calling sqlite3OsSleep(). The first few

2192 ** calls to sqlite3OsSleep() have a delay of 1 microsecond. Really this

2193 ** is more of a scheduler yield than an actual delay. But on the 10th

2194 ** an subsequent retries, the delays start becoming longer and longer,

2195 ** so that on the 100th (and last) RETRY we delay for 323 milliseconds.

2196 ** The total delay time before giving up is less than 10 seconds.

2197 */

2198 if( cnt>5 ){

2199 int nDelay = 1; /* Pause time in microseconds */

2200 if( cnt>100 ){

2201 VVA_ONLY( pWal->lockError = 1; )

2202 return SQLITE_PROTOCOL;

2203 }

2204 if( cnt>=10 ) nDelay = (cnt-9)(cnt-9)39;

2205 sqlite3OsSleep(pWal->pVfs, nDelay);

2206 }

2207

2208 if( !useWal ){

2209 rc = walIndexReadHdr(pWal, pChanged);

2210 if( rc==SQLITE_BUSY ){

2211 /* If there is not a recovery running in another thread or process

2212 ** then convert BUSY errors to WAL_RETRY. If recovery is known to

2213 ** be running, convert BUSY to BUSY_RECOVERY. There is a race here

2214 ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY

2215 ** would be technically correct. But the race is benign since with

2216 ** WAL_RETRY this routine will be called again and will probably be

2217 ** right on the second iteration.

2218 */

2219 if( pWal->apWiData[0]==0 ){

2220 /* This branch is taken when the xShmMap() method returns SQLITE_BUSY.

2221 ** We assume this is a transient condition, so return WAL_RETRY. The

2222 ** xShmMap() implementation used by the default unix and win32 VFS

2223 ** modules may return SQLITE_BUSY due to a race condition in the

2224 ** code that determines whether or not the shared-memory region

2225 ** must be zeroed before the requested page is returned.

2226 */

2227 rc = WAL_RETRY;

2228 }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){

2229 walUnlockShared(pWal, WAL_RECOVER_LOCK);

2230 rc = WAL_RETRY;

2231 }else if( rc==SQLITE_BUSY ){

2232 rc = SQLITE_BUSY_RECOVERY;

2233 }

2234 }

2235 if( rc!=SQLITE_OK ){

2236 return rc;

2237 }

2238 }

2239

2240 pInfo = walCkptInfo(pWal);

2241 if( !useWal && pInfo->nBackfill==pWal->hdr.mxFrame

2242 #ifdef SQLITE_ENABLE_SNAPSHOT

2243 && (pWal->pSnapshot==0 \|\| pWal->hdr.mxFrame==0

2244 \|\| 0==memcmp(&pWal->hdr, pWal->pSnapshot, sizeof(WalIndexHdr)))

2245 #endif

2246 ){

2247 /* The WAL has been completely backfilled (or it is empty).

2248 ** and can be safely ignored.

2249 */

2250 rc = walLockShared(pWal, WAL_READ_LOCK(0));

2251 walShmBarrier(pWal);

2252 if( rc==SQLITE_OK ){

2253 if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){

2254 /* It is not safe to allow the reader to continue here if frames

2255 ** may have been appended to the log before READ_LOCK(0) was obtained.

2256 ** When holding READ_LOCK(0), the reader ignores the entire log file,

2257 ** which implies that the database file contains a trustworthy

2258 ** snapshot. Since holding READ_LOCK(0) prevents a checkpoint from

2259 ** happening, this is usually correct.

2260 **

2261 ** However, if frames have been appended to the log (or if the log

2262 ** is wrapped and written for that matter) before the READ_LOCK(0)

2263 ** is obtained, that is not necessarily true. A checkpointer may

2264 ** have started to backfill the appended frames but crashed before

2265 ** it finished. Leaving a corrupt image in the database file.

2266 */

2267 walUnlockShared(pWal, WAL_READ_LOCK(0));

2268 return WAL_RETRY;

2269 }

2270 pWal->readLock = 0;

2271 return SQLITE_OK;

2272 }else if( rc!=SQLITE_BUSY ){

2273 return rc;

2274 }

2275 }

2276

2277 /* If we get this far, it means that the reader will want to use

2278 ** the WAL to get at content from recent commits. The job now is

2279 ** to select one of the aReadMark[] entries that is closest to

2280 ** but not exceeding pWal->hdr.mxFrame and lock that entry.

2281 */

2282 mxReadMark = 0;

2283 mxI = 0;

2284 mxFrame = pWal->hdr.mxFrame;

2285 #ifdef SQLITE_ENABLE_SNAPSHOT

2286 if( pWal->pSnapshot && pWal->pSnapshot->mxFrame<mxFrame ){

2287 mxFrame = pWal->pSnapshot->mxFrame;

2288 }

2289 #endif

2290 for(i=1; i<WAL_NREADER; i++){

2291 u32 thisMark = pInfo->aReadMark[i];

2292 if( mxReadMark<=thisMark && thisMark<=mxFrame ){

2293 assert( thisMark!=READMARK_NOT_USED );

2294 mxReadMark = thisMark;

2295 mxI = i;

2296 }

2297 }

2298 if( (pWal->readOnly & WAL_SHM_RDONLY)==0

2299 && (mxReadMark<mxFrame \|\| mxI==0)

2300 ){

2301 for(i=1; i<WAL_NREADER; i++){

2302 rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);

2303 if( rc==SQLITE_OK ){

2304 mxReadMark = pInfo->aReadMark[i] = mxFrame;

2305 mxI = i;

2306 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);

2307 break;

2308 }else if( rc!=SQLITE_BUSY ){

2309 return rc;

2310 }

2311 }

2312 }

2313 if( mxI==0 ){

2314 assert( rc==SQLITE_BUSY \|\| (pWal->readOnly & WAL_SHM_RDONLY)!=0 );

2315 return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTLOCK;

2316 }

2317

2318 rc = walLockShared(pWal, WAL_READ_LOCK(mxI));

2319 if( rc ){

2320 return rc==SQLITE_BUSY ? WAL_RETRY : rc;

2321 }

2322 /* Now that the read-lock has been obtained, check that neither the

2323 ** value in the aReadMark[] array or the contents of the wal-index

2324 ** header have changed.

2325 **

2326 ** It is necessary to check that the wal-index header did not change

2327 ** between the time it was read and when the shared-lock was obtained

2328 ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility

2329 ** that the log file may have been wrapped by a writer, or that frames

2330 ** that occur later in the log than pWal->hdr.mxFrame may have been

2331 ** copied into the database by a checkpointer. If either of these things

2332 ** happened, then reading the database with the current value of

2333 ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry

2334 ** instead.

2335 **

2336 ** Before checking that the live wal-index header has not changed

2337 ** since it was read, set Wal.minFrame to the first frame in the wal

2338 ** file that has not yet been checkpointed. This client will not need

2339 ** to read any frames earlier than minFrame from the wal file - they

2340 ** can be safely read directly from the database file.

2341 **

2342 ** Because a ShmBarrier() call is made between taking the copy of

2343 ** nBackfill and checking that the wal-header in shared-memory still

2344 ** matches the one cached in pWal->hdr, it is guaranteed that the

2345 ** checkpointer that set nBackfill was not working with a wal-index

2346 ** header newer than that cached in pWal->hdr. If it were, that could

2347 ** cause a problem. The checkpointer could omit to checkpoint

2348 ** a version of page X that lies before pWal->minFrame (call that version

2349 ** A) on the basis that there is a newer version (version B) of the same

2350 ** page later in the wal file. But if version B happens to like past

2351 ** frame pWal->hdr.mxFrame - then the client would incorrectly assume

2352 ** that it can read version A from the database file. However, since

2353 ** we can guarantee that the checkpointer that set nBackfill could not

2354 ** see any pages past pWal->hdr.mxFrame, this problem does not come up.

2355 */

2356 pWal->minFrame = pInfo->nBackfill+1;

2357 walShmBarrier(pWal);

2358 if( pInfo->aReadMark[mxI]!=mxReadMark

2359 \|\| memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))

2360 ){

2361 walUnlockShared(pWal, WAL_READ_LOCK(mxI));

2362 return WAL_RETRY;

2363 }else{

2364 assert( mxReadMark<=pWal->hdr.mxFrame );

2365 pWal->readLock = (i16)mxI;

2366 }

2367 return rc;

2368 }

2369

2370 /*

2371 ** Begin a read transaction on the database.

2372 **

2373 ** This routine used to be called sqlite3OpenSnapshot() and with good reason:

2374 ** it takes a snapshot of the state of the WAL and wal-index for the current

2375 ** instant in time. The current thread will continue to use this snapshot.

2376 ** Other threads might append new content to the WAL and wal-index but

2377 ** that extra content is ignored by the current thread.

2378 **

2379 ** If the database contents have changes since the previous read

2380 ** transaction, then *pChanged is set to 1 before returning. The

2381 ** Pager layer will use this to know that is cache is stale and

2382 ** needs to be flushed.

2383 */

2384 int sqlite3WalBeginReadTransaction(Wal pWal, int pChanged){

2385 int rc; /* Return code */

2386 int cnt = 0; /* Number of TryBeginRead attempts */

2387

2388 #ifdef SQLITE_ENABLE_SNAPSHOT

2389 int bChanged = 0;

2390 WalIndexHdr *pSnapshot = pWal->pSnapshot;

2391 if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){

2392 bChanged = 1;

2393 }

2394 #endif

2395

2396 do{

2397 rc = walTryBeginRead(pWal, pChanged, 0, ++cnt);

2398 }while( rc==WAL_RETRY );

2399 testcase( (rc&0xff)==SQLITE_BUSY );

2400 testcase( (rc&0xff)==SQLITE_IOERR );

2401 testcase( rc==SQLITE_PROTOCOL );

2402 testcase( rc==SQLITE_OK );

2403

2404 #ifdef SQLITE_ENABLE_SNAPSHOT

2405 if( rc==SQLITE_OK ){

2406 if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){

2407 /* At this point the client has a lock on an aReadMark[] slot holding

2408 ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr

2409 ** is populated with the wal-index header corresponding to the head

2410 ** of the wal file. Verify that pSnapshot is still valid before

2411 ** continuing. Reasons why pSnapshot might no longer be valid:

2412 **

2413 ** (1) The WAL file has been reset since the snapshot was taken.

2414 ** In this case, the salt will have changed.

2415 **

2416 ** (2) A checkpoint as been attempted that wrote frames past

2417 ** pSnapshot->mxFrame into the database file. Note that the

2418 ** checkpoint need not have completed for this to cause problems.

2419 */

2420 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);

2421

2422 assert( pWal->readLock>0 \|\| pWal->hdr.mxFrame==0 );

2423 assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame );

2424

2425 /* It is possible that there is a checkpointer thread running

2426 ** concurrent with this code. If this is the case, it may be that the

2427 ** checkpointer has already determined that it will checkpoint

2428 ** snapshot X, where X is later in the wal file than pSnapshot, but

2429 ** has not yet set the pInfo->nBackfillAttempted variable to indicate

2430 ** its intent. To avoid the race condition this leads to, ensure that

2431 ** there is no checkpointer process by taking a shared CKPT lock

2432 ** before checking pInfo->nBackfillAttempted. */

2433 rc = walLockShared(pWal, WAL_CKPT_LOCK);

2434

2435 if( rc==SQLITE_OK ){

2436 /* Check that the wal file has not been wrapped. Assuming that it has

2437 ** not, also check that no checkpointer has attempted to checkpoint any

2438 ** frames beyond pSnapshot->mxFrame. If either of these conditions are

2439 ** true, return SQLITE_BUSY_SNAPSHOT. Otherwise, overwrite pWal->hdr

2440 ** with pSnapshot and set pChanged as appropriate for opening the

2441 ** snapshot. */

2442 if( !memcmp(pSnapshot->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))

2443 && pSnapshot->mxFrame>=pInfo->nBackfillAttempted

2444 ){

2445 assert( pWal->readLock>0 );

2446 memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr));

2447 *pChanged = bChanged;

2448 }else{

2449 rc = SQLITE_BUSY_SNAPSHOT;

2450 }

2451

2452 /* Release the shared CKPT lock obtained above. */

2453 walUnlockShared(pWal, WAL_CKPT_LOCK);

2454 }

2455

2456

2457 if( rc!=SQLITE_OK ){

2458 sqlite3WalEndReadTransaction(pWal);

2459 }

2460 }

2461 }

2462 #endif

2463 return rc;

2464 }

2465

2466 /*

2467 ** Finish with a read transaction. All this does is release the

2468 ** read-lock.

2469 */

2470 void sqlite3WalEndReadTransaction(Wal *pWal){

2471 sqlite3WalEndWriteTransaction(pWal);

2472 if( pWal->readLock>=0 ){

2473 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));

2474 pWal->readLock = -1;

2475 }

2476 }

2477

2478 /*

2479 ** Search the wal file for page pgno. If found, set *piRead to the frame that

2480 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead

2481 ** to zero.

2482 **

2483 ** Return SQLITE_OK if successful, or an error code if an error occurs. If an

2484 ** error does occur, the final value of *piRead is undefined.

2485 */

2486 int sqlite3WalFindFrame(

2487 Wal pWal, / WAL handle */

2488 Pgno pgno, /* Database page number to read data for */

2489 u32 piRead / OUT: Frame number (or zero) */

2490 ){

2491 u32 iRead = 0; /* If !=0, WAL frame to return data from */

2492 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */

2493 int iHash; /* Used to loop through N hash tables */

2494 int iMinHash;

2495

2496 /* This routine is only be called from within a read transaction. */

2497 assert( pWal->readLock>=0 \|\| pWal->lockError );

2498

2499 /* If the "last page" field of the wal-index header snapshot is 0, then

2500 ** no data will be read from the wal under any circumstances. Return early

2501 ** in this case as an optimization. Likewise, if pWal->readLock==0,

2502 ** then the WAL is ignored by the reader so return early, as if the

2503 ** WAL were empty.

2504 */

2505 if( iLast==0 \|\| pWal->readLock==0 ){

2506 *piRead = 0;

2507 return SQLITE_OK;

2508 }

2509

2510 /* Search the hash table or tables for an entry matching page number

2511 ** pgno. Each iteration of the following for() loop searches one

2512 ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames).

2513 **

2514 ** This code might run concurrently to the code in walIndexAppend()

2515 ** that adds entries to the wal-index (and possibly to this hash

2516 ** table). This means the value just read from the hash

2517 ** slot (aHash[iKey]) may have been added before or after the

2518 ** current read transaction was opened. Values added after the

2519 ** read transaction was opened may have been written incorrectly -

2520 ** i.e. these slots may contain garbage data. However, we assume

2521 ** that any slots written before the current read transaction was

2522 ** opened remain unmodified.

2523 **

2524 ** For the reasons above, the if(...) condition featured in the inner

2525 ** loop of the following block is more stringent that would be required

2526 ** if we had exclusive access to the hash-table:

2527 **

2528 ** (aPgno[iFrame]==pgno):

2529 ** This condition filters out normal hash-table collisions.

2530 **

2531 ** (iFrame<=iLast):

2532 ** This condition filters out entries that were added to the hash

2533 ** table after the current read-transaction had started.

2534 */

2535 iMinHash = walFramePage(pWal->minFrame);

2536 for(iHash=walFramePage(iLast); iHash>=iMinHash && iRead==0; iHash--){

2537 volatile ht_slot aHash; / Pointer to hash table */

2538 volatile u32 aPgno; / Pointer to array of page numbers */

2539 u32 iZero; /* Frame number corresponding to aPgno[0] */

2540 int iKey; /* Hash slot index */

2541 int nCollide; /* Number of hash collisions remaining */

2542 int rc; /* Error code */

2543

2544 rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);

2545 if( rc!=SQLITE_OK ){

2546 return rc;

2547 }

2548 nCollide = HASHTABLE_NSLOT;

2549 for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){

2550 u32 iFrame = aHash[iKey] + iZero;

2551 if( iFrame<=iLast && iFrame>=pWal->minFrame && aPgno[aHash[iKey]]==pgno ){

2552 assert( iFrame>iRead \|\| CORRUPT_DB );

2553 iRead = iFrame;

2554 }

2555 if( (nCollide--)==0 ){

2556 return SQLITE_CORRUPT_BKPT;

2557 }

2558 }

2559 }

2560

2561 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT

2562 /* If expensive assert() statements are available, do a linear search

2563 ** of the wal-index file content. Make sure the results agree with the

2564 ** result obtained using the hash indexes above. */

2565 {

2566 u32 iRead2 = 0;

2567 u32 iTest;

2568 assert( pWal->minFrame>0 );

2569 for(iTest=iLast; iTest>=pWal->minFrame; iTest--){

2570 if( walFramePgno(pWal, iTest)==pgno ){

2571 iRead2 = iTest;

2572 break;

2573 }

2574 }

2575 assert( iRead==iRead2 );

2576 }

2577 #endif

2578

2579 *piRead = iRead;

2580 return SQLITE_OK;

2581 }

2582

2583 /*

2584 ** Read the contents of frame iRead from the wal file into buffer pOut

2585 ** (which is nOut bytes in size). Return SQLITE_OK if successful, or an

2586 ** error code otherwise.

2587 */

2588 int sqlite3WalReadFrame(

2589 Wal pWal, / WAL handle */

2590 u32 iRead, /* Frame to read */

2591 int nOut, /* Size of buffer pOut in bytes */

2592 u8 pOut / Buffer to write page data to */

2593 ){

2594 int sz;

2595 i64 iOffset;

2596 sz = pWal->hdr.szPage;

2597 sz = (sz&0xfe00) + ((sz&0x0001)<<16);

2598 testcase( sz<=32768 );

2599 testcase( sz>=65536 );

2600 iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;

2601 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */

2602 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);

2603 }

2604

2605 /*

2606 ** Return the size of the database in pages (or zero, if unknown).

2607 */

2608 Pgno sqlite3WalDbsize(Wal *pWal){

2609 if( pWal && ALWAYS(pWal->readLock>=0) ){

2610 return pWal->hdr.nPage;

2611 }

2612 return 0;

2613 }

2614

2615

2616 /*

2617 ** This function starts a write transaction on the WAL.

2618 **

2619 ** A read transaction must have already been started by a prior call

2620 ** to sqlite3WalBeginReadTransaction().

2621 **

2622 ** If another thread or process has written into the database since

2623 ** the read transaction was started, then it is not possible for this

2624 ** thread to write as doing so would cause a fork. So this routine

2625 ** returns SQLITE_BUSY in that case and no write transaction is started.

2626 **

2627 ** There can only be a single writer active at a time.

2628 */

2629 int sqlite3WalBeginWriteTransaction(Wal *pWal){

2630 int rc;

2631

2632 /* Cannot start a write transaction without first holding a read

2633 ** transaction. */

2634 assert( pWal->readLock>=0 );

2635

2636 if( pWal->readOnly ){

2637 return SQLITE_READONLY;

2638 }

2639

2640 /* Only one writer allowed at a time. Get the write lock. Return

2641 ** SQLITE_BUSY if unable.

2642 */

2643 rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);

2644 if( rc ){

2645 return rc;

2646 }

2647 pWal->writeLock = 1;

2648

2649 /* If another connection has written to the database file since the

2650 ** time the read transaction on this connection was started, then

2651 ** the write is disallowed.

2652 */

2653 if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){

2654 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);

2655 pWal->writeLock = 0;

2656 rc = SQLITE_BUSY_SNAPSHOT;

2657 }

2658

2659 return rc;

2660 }

2661

2662 /*

2663 ** End a write transaction. The commit has already been done. This

2664 ** routine merely releases the lock.

2665 */

2666 int sqlite3WalEndWriteTransaction(Wal *pWal){

2667 if( pWal->writeLock ){

2668 walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);

2669 pWal->writeLock = 0;

2670 pWal->truncateOnCommit = 0;

2671 }

2672 return SQLITE_OK;

2673 }

2674

2675 /*

2676 ** If any data has been written (but not committed) to the log file, this

2677 ** function moves the write-pointer back to the start of the transaction.

2678 **

2679 ** Additionally, the callback function is invoked for each frame written

2680 ** to the WAL since the start of the transaction. If the callback returns

2681 ** other than SQLITE_OK, it is not invoked again and the error code is

2682 ** returned to the caller.

2683 **

2684 ** Otherwise, if the callback function does not return an error, this

2685 ** function returns SQLITE_OK.

2686 */

2687 int sqlite3WalUndo(Wal pWal, int (xUndo)(void , Pgno), void pUndoCtx){

2688 int rc = SQLITE_OK;

2689 if( ALWAYS(pWal->writeLock) ){

2690 Pgno iMax = pWal->hdr.mxFrame;

2691 Pgno iFrame;

2692

2693 /* Restore the clients cache of the wal-index header to the state it

2694 ** was in before the client began writing to the database.

2695 */

2696 memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));

2697

2698 for(iFrame=pWal->hdr.mxFrame+1;

2699 ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;

2700 iFrame++

2701 ){

2702 /* This call cannot fail. Unless the page for which the page number

2703 ** is passed as the second argument is (a) in the cache and

2704 ** (b) has an outstanding reference, then xUndo is either a no-op

2705 ** (if (a) is false) or simply expels the page from the cache (if (b)

2706 ** is false).

2707 **

2708 ** If the upper layer is doing a rollback, it is guaranteed that there

2709 ** are no outstanding references to any page other than page 1. And

2710 ** page 1 is never written to the log until the transaction is

2711 ** committed. As a result, the call to xUndo may not fail.

2712 */

2713 assert( walFramePgno(pWal, iFrame)!=1 );

2714 rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));

2715 }

2716 if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal);

2717 }

2718 return rc;

2719 }

2720

2721 /*

2722 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32

2723 ** values. This function populates the array with values required to

2724 ** "rollback" the write position of the WAL handle back to the current

2725 ** point in the event of a savepoint rollback (via WalSavepointUndo()).

2726 */

2727 void sqlite3WalSavepoint(Wal pWal, u32 aWalData){

2728 assert( pWal->writeLock );

2729 aWalData[0] = pWal->hdr.mxFrame;

2730 aWalData[1] = pWal->hdr.aFrameCksum[0];

2731 aWalData[2] = pWal->hdr.aFrameCksum[1];

2732 aWalData[3] = pWal->nCkpt;

2733 }

2734

2735 /*

2736 ** Move the write position of the WAL back to the point identified by

2737 ** the values in the aWalData[] array. aWalData must point to an array

2738 ** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated

2739 ** by a call to WalSavepoint().

2740 */

2741 int sqlite3WalSavepointUndo(Wal pWal, u32 aWalData){

2742 int rc = SQLITE_OK;

2743

2744 assert( pWal->writeLock );

2745 assert( aWalData[3]!=pWal->nCkpt \|\| aWalData[0]<=pWal->hdr.mxFrame );

2746

2747 if( aWalData[3]!=pWal->nCkpt ){

2748 /* This savepoint was opened immediately after the write-transaction

2749 ** was started. Right after that, the writer decided to wrap around

2750 ** to the start of the log. Update the savepoint values to match.

2751 */

2752 aWalData[0] = 0;

2753 aWalData[3] = pWal->nCkpt;

2754 }

2755

2756 if( aWalData[0]<pWal->hdr.mxFrame ){

2757 pWal->hdr.mxFrame = aWalData[0];

2758 pWal->hdr.aFrameCksum[0] = aWalData[1];

2759 pWal->hdr.aFrameCksum[1] = aWalData[2];

2760 walCleanupHash(pWal);

2761 }

2762

2763 return rc;

2764 }

2765

2766 /*

2767 ** This function is called just before writing a set of frames to the log

2768 ** file (see sqlite3WalFrames()). It checks to see if, instead of appending

2769 ** to the current log file, it is possible to overwrite the start of the

2770 ** existing log file with the new frames (i.e. "reset" the log). If so,

2771 ** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left

2772 ** unchanged.

2773 **

2774 ** SQLITE_OK is returned if no error is encountered (regardless of whether

2775 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned

2776 ** if an error occurs.

2777 */

2778 static int walRestartLog(Wal *pWal){

2779 int rc = SQLITE_OK;

2780 int cnt;

2781

2782 if( pWal->readLock==0 ){

2783 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);

2784 assert( pInfo->nBackfill==pWal->hdr.mxFrame );

2785 if( pInfo->nBackfill>0 ){

2786 u32 salt1;

2787 sqlite3_randomness(4, &salt1);

2788 rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);

2789 if( rc==SQLITE_OK ){

2790 /* If all readers are using WAL_READ_LOCK(0) (in other words if no

2791 ** readers are currently using the WAL), then the transactions

2792 ** frames will overwrite the start of the existing log. Update the

2793 ** wal-index header to reflect this.

2794 **

2795 ** In theory it would be Ok to update the cache of the header only

2796 ** at this point. But updating the actual wal-index header is also

2797 ** safe and means there is no special case for sqlite3WalUndo()

2798 ** to handle if this transaction is rolled back. */

2799 walRestartHdr(pWal, salt1);

2800 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);

2801 }else if( rc!=SQLITE_BUSY ){

2802 return rc;

2803 }

2804 }

2805 walUnlockShared(pWal, WAL_READ_LOCK(0));

2806 pWal->readLock = -1;

2807 cnt = 0;

2808 do{

2809 int notUsed;

2810 rc = walTryBeginRead(pWal, &notUsed, 1, ++cnt);

2811 }while( rc==WAL_RETRY );

2812 assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */

2813 testcase( (rc&0xff)==SQLITE_IOERR );

2814 testcase( rc==SQLITE_PROTOCOL );

2815 testcase( rc==SQLITE_OK );

2816 }

2817 return rc;

2818 }

2819

2820 /*

2821 ** Information about the current state of the WAL file and where

2822 ** the next fsync should occur - passed from sqlite3WalFrames() into

2823 ** walWriteToLog().

2824 */

2825 typedef struct WalWriter {

2826 Wal pWal; / The complete WAL information */

2827 sqlite3_file pFd; / The WAL file to which we write */

2828 sqlite3_int64 iSyncPoint; /* Fsync at this offset */

2829 int syncFlags; /* Flags for the fsync */

2830 int szPage; /* Size of one page */

2831 } WalWriter;

2832

2833 /*

2834 ** Write iAmt bytes of content into the WAL file beginning at iOffset.

2835 ** Do a sync when crossing the p->iSyncPoint boundary.

2836 **

2837 ** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt,

2838 ** first write the part before iSyncPoint, then sync, then write the

2839 ** rest.

2840 */

2841 static int walWriteToLog(

2842 WalWriter p, / WAL to write to */

2843 void pContent, / Content to be written */

2844 int iAmt, /* Number of bytes to write */

2845 sqlite3_int64 iOffset /* Start writing at this offset */

2846 ){

2847 int rc;

2848 if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){

2849 int iFirstAmt = (int)(p->iSyncPoint - iOffset);

2850 rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);

2851 if( rc ) return rc;

2852 iOffset += iFirstAmt;

2853 iAmt -= iFirstAmt;

2854 pContent = (void)(iFirstAmt + (char)pContent);

2855 assert( p->syncFlags & (SQLITE_SYNC_NORMAL\|SQLITE_SYNC_FULL) );

2856 rc = sqlite3OsSync(p->pFd, p->syncFlags & SQLITE_SYNC_MASK);

2857 if( iAmt==0 \|\| rc ) return rc;

2858 }

2859 rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);

2860 return rc;

2861 }

2862

2863 /*

2864 ** Write out a single frame of the WAL

2865 */

2866 static int walWriteOneFrame(

2867 WalWriter p, / Where to write the frame */

2868 PgHdr pPage, / The page of the frame to be written */

2869 int nTruncate, /* The commit flag. Usually 0. >0 for commit */

2870 sqlite3_int64 iOffset /* Byte offset at which to write */

2871 ){

2872 int rc; /* Result code from subfunctions */

2873 void pData; / Data actually written */

2874 u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */

2875 #if defined(SQLITE_HAS_CODEC)

2876 if( (pData = sqlite3PagerCodec(pPage))==0 ) return SQLITE_NOMEM;

2877 #else

2878 pData = pPage->pData;

2879 #endif

2880 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);

2881 rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);

2882 if( rc ) return rc;

2883 /* Write the page data */

2884 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));

2885 return rc;

2886 }

2887

2888 /*

2889 ** Write a set of frames to the log. The caller must hold the write-lock

2890 ** on the log file (obtained using sqlite3WalBeginWriteTransaction()).

2891 */

2892 int sqlite3WalFrames(

2893 Wal pWal, / Wal handle to write to */

2894 int szPage, /* Database page-size in bytes */

2895 PgHdr pList, / List of dirty pages to write */

2896 Pgno nTruncate, /* Database size after this commit */

2897 int isCommit, /* True if this is a commit */

2898 int sync_flags /* Flags to pass to OsSync() (or 0) */

2899 ){

2900 int rc; /* Used to catch return codes */

2901 u32 iFrame; /* Next frame address */

2902 PgHdr p; / Iterator to run through pList with. */

2903 PgHdr pLast = 0; / Last frame in list */

2904 int nExtra = 0; /* Number of extra copies of last page */

2905 int szFrame; /* The size of a single frame */

2906 i64 iOffset; /* Next byte to write in WAL file */

2907 WalWriter w; /* The writer */

2908

2909 assert( pList );

2910 assert( pWal->writeLock );

2911

2912 /* If this frame set completes a transaction, then nTruncate>0. If

2913 ** nTruncate==0 then this frame set does not complete the transaction. */

2914 assert( (isCommit!=0)==(nTruncate!=0) );

2915

2916 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)

2917 { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}

2918 WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n",

2919 pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));

2920 }

2921 #endif

2922

2923 /* See if it is possible to write these frames into the start of the

2924 ** log file, instead of appending to it at pWal->hdr.mxFrame.

2925 */

2926 if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){

2927 return rc;

2928 }

2929

2930 /* If this is the first frame written into the log, write the WAL

2931 ** header to the start of the WAL file. See comments at the top of

2932 ** this source file for a description of the WAL header format.

2933 */

2934 iFrame = pWal->hdr.mxFrame;

2935 if( iFrame==0 ){

2936 u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */

2937 u32 aCksum[2]; /* Checksum for wal-header */

2938

2939 sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC \| SQLITE_BIGENDIAN));

2940 sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION);

2941 sqlite3Put4byte(&aWalHdr[8], szPage);

2942 sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);

2943 if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt);

2944 memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);

2945 walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum);

2946 sqlite3Put4byte(&aWalHdr[24], aCksum[0]);

2947 sqlite3Put4byte(&aWalHdr[28], aCksum[1]);

2948

2949 pWal->szPage = szPage;

2950 pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN;

2951 pWal->hdr.aFrameCksum[0] = aCksum[0];

2952 pWal->hdr.aFrameCksum[1] = aCksum[1];

2953 pWal->truncateOnCommit = 1;

2954

2955 rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);

2956 WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));

2957 if( rc!=SQLITE_OK ){

2958 return rc;

2959 }

2960

2961 /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless

2962 ** all syncing is turned off by PRAGMA synchronous=OFF). Otherwise

2963 ** an out-of-order write following a WAL restart could result in

2964 ** database corruption. See the ticket:

2965 **

2966 ** http://localhost:591/sqlite/info/ff5be73dee

2967 */

2968 if( pWal->syncHeader && sync_flags ){

2969 rc = sqlite3OsSync(pWal->pWalFd, sync_flags & SQLITE_SYNC_MASK);

2970 if( rc ) return rc;

2971 }

2972 }

2973 assert( (int)pWal->szPage==szPage );

2974

2975 /* Setup information needed to write frames into the WAL */

2976 w.pWal = pWal;

2977 w.pFd = pWal->pWalFd;

2978 w.iSyncPoint = 0;

2979 w.syncFlags = sync_flags;

2980 w.szPage = szPage;

2981 iOffset = walFrameOffset(iFrame+1, szPage);

2982 szFrame = szPage + WAL_FRAME_HDRSIZE;

2983

2984 /* Write all frames into the log file exactly once */

2985 for(p=pList; p; p=p->pDirty){

2986 int nDbSize; /* 0 normally. Positive == commit flag */

2987 iFrame++;

2988 assert( iOffset==walFrameOffset(iFrame, szPage) );

2989 nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;

2990 rc = walWriteOneFrame(&w, p, nDbSize, iOffset);

2991 if( rc ) return rc;

2992 pLast = p;

2993 iOffset += szFrame;

2994 }

2995

2996 /* If this is the end of a transaction, then we might need to pad

2997 ** the transaction and/or sync the WAL file.

2998 **

2999 ** Padding and syncing only occur if this set of frames complete a

3000 ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL

3001 ** or synchronous==OFF, then no padding or syncing are needed.

3002 **

3003 ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not

3004 ** needed and only the sync is done. If padding is needed, then the

3005 ** final frame is repeated (with its commit mark) until the next sector

3006 ** boundary is crossed. Only the part of the WAL prior to the last

3007 ** sector boundary is synced; the part of the last frame that extends

3008 ** past the sector boundary is written after the sync.

3009 */

3010 if( isCommit && (sync_flags & WAL_SYNC_TRANSACTIONS)!=0 ){

3011 if( pWal->padToSectorBoundary ){

3012 int sectorSize = sqlite3SectorSize(pWal->pWalFd);

3013 w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;

3014 while( iOffset<w.iSyncPoint ){

3015 rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);

3016 if( rc ) return rc;

3017 iOffset += szFrame;

3018 nExtra++;

3019 }

3020 }else{

3021 rc = sqlite3OsSync(w.pFd, sync_flags & SQLITE_SYNC_MASK);

3022 }

3023 }

3024

3025 /* If this frame set completes the first transaction in the WAL and

3026 ** if PRAGMA journal_size_limit is set, then truncate the WAL to the

3027 ** journal size limit, if possible.

3028 */

3029 if( isCommit && pWal->truncateOnCommit && pWal->mxWalSize>=0 ){

3030 i64 sz = pWal->mxWalSize;

3031 if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){

3032 sz = walFrameOffset(iFrame+nExtra+1, szPage);

3033 }

3034 walLimitSize(pWal, sz);

3035 pWal->truncateOnCommit = 0;

3036 }

3037

3038 /* Append data to the wal-index. It is not necessary to lock the

3039 ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index

3040 ** guarantees that there are no other writers, and no data that may

3041 ** be in use by existing readers is being overwritten.

3042 */

3043 iFrame = pWal->hdr.mxFrame;

3044 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){

3045 iFrame++;

3046 rc = walIndexAppend(pWal, iFrame, p->pgno);

3047 }

3048 while( rc==SQLITE_OK && nExtra>0 ){

3049 iFrame++;

3050 nExtra--;

3051 rc = walIndexAppend(pWal, iFrame, pLast->pgno);

3052 }

3053

3054 if( rc==SQLITE_OK ){

3055 /* Update the private copy of the header. */

3056 pWal->hdr.szPage = (u16)((szPage&0xff00) \| (szPage>>16));

3057 testcase( szPage<=32768 );

3058 testcase( szPage>=65536 );

3059 pWal->hdr.mxFrame = iFrame;

3060 if( isCommit ){

3061 pWal->hdr.iChange++;

3062 pWal->hdr.nPage = nTruncate;

3063 }

3064 /* If this is a commit, update the wal-index header too. */

3065 if( isCommit ){

3066 walIndexWriteHdr(pWal);

3067 pWal->iCallback = iFrame;

3068 }

3069 }

3070

3071 WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok"));

3072 return rc;

3073 }

3074

3075 /*

3076 ** This routine is called to implement sqlite3_wal_checkpoint() and

3077 ** related interfaces.

3078 **

3079 ** Obtain a CHECKPOINT lock and then backfill as much information as

3080 ** we can from WAL into the database.

3081 **

3082 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler

3083 ** callback. In this case this function runs a blocking checkpoint.

3084 */

3085 int sqlite3WalCheckpoint(

3086 Wal pWal, / Wal connection */

3087 int eMode, /* PASSIVE, FULL, RESTART, or TRUNCATE */

3088 int (xBusy)(void), /* Function to call when busy */

3089 void pBusyArg, / Context argument for xBusyHandler */

3090 int sync_flags, /* Flags to sync db file with (or 0) */

3091 int nBuf, /* Size of temporary buffer */

3092 u8 zBuf, / Temporary buffer to use */

3093 int pnLog, / OUT: Number of frames in WAL */

3094 int pnCkpt / OUT: Number of backfilled frames in WAL */

3095 ){

3096 int rc; /* Return code */

3097 int isChanged = 0; /* True if a new wal-index header is loaded */

3098 int eMode2 = eMode; /* Mode to pass to walCheckpoint() */

3099 int (xBusy2)(void) = xBusy; /* Busy handler for eMode2 */

3100

3101 assert( pWal->ckptLock==0 );

3102 assert( pWal->writeLock==0 );

3103

3104 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked

3105 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */

3106 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE \|\| xBusy==0 );

3107

3108 if( pWal->readOnly ) return SQLITE_READONLY;

3109 WALTRACE(("WAL%p: checkpoint begins\n", pWal));

3110

3111 /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive

3112 ** "checkpoint" lock on the database file. */

3113 rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);

3114 if( rc ){

3115 /* EVIDENCE-OF: R-10421-19736 If any other process is running a

3116 ** checkpoint operation at the same time, the lock cannot be obtained and

3117 ** SQLITE_BUSY is returned.

3118 ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured,

3119 ** it will not be invoked in this case.

3120 */

3121 testcase( rc==SQLITE_BUSY );

3122 testcase( xBusy!=0 );

3123 return rc;

3124 }

3125 pWal->ckptLock = 1;

3126

3127 /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and

3128 ** TRUNCATE modes also obtain the exclusive "writer" lock on the database

3129 ** file.

3130 **

3131 ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained

3132 ** immediately, and a busy-handler is configured, it is invoked and the

3133 ** writer lock retried until either the busy-handler returns 0 or the

3134 ** lock is successfully obtained.

3135 */

3136 if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){

3137 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_WRITE_LOCK, 1);

3138 if( rc==SQLITE_OK ){

3139 pWal->writeLock = 1;

3140 }else if( rc==SQLITE_BUSY ){

3141 eMode2 = SQLITE_CHECKPOINT_PASSIVE;

3142 xBusy2 = 0;

3143 rc = SQLITE_OK;

3144 }

3145 }

3146

3147 /* Read the wal-index header. */

3148 if( rc==SQLITE_OK ){

3149 rc = walIndexReadHdr(pWal, &isChanged);

3150 if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){

3151 sqlite3OsUnfetch(pWal->pDbFd, 0, 0);

3152 }

3153 }

3154

3155 /* Copy data from the log to the database file. */

3156 if( rc==SQLITE_OK ){

3157 if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){

3158 rc = SQLITE_CORRUPT_BKPT;

3159 }else{

3160 rc = walCheckpoint(pWal, eMode2, xBusy2, pBusyArg, sync_flags, zBuf);

3161 }

3162

3163 /* If no error occurred, set the output variables. */

3164 if( rc==SQLITE_OK \|\| rc==SQLITE_BUSY ){

3165 if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;

3166 if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);

3167 }

3168 }

3169

3170 if( isChanged ){

3171 /* If a new wal-index header was loaded before the checkpoint was

3172 ** performed, then the pager-cache associated with pWal is now

3173 ** out of date. So zero the cached wal-index header to ensure that

3174 ** next time the pager opens a snapshot on this database it knows that

3175 ** the cache needs to be reset.

3176 */

3177 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));

3178 }

3179

3180 /* Release the locks. */

3181 sqlite3WalEndWriteTransaction(pWal);

3182 walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);

3183 pWal->ckptLock = 0;

3184 WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok"));

3185 return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);

3186 }

3187

3188 /* Return the value to pass to a sqlite3_wal_hook callback, the

3189 ** number of frames in the WAL at the point of the last commit since

3190 ** sqlite3WalCallback() was called. If no commits have occurred since

3191 ** the last call, then return 0.

3192 */

3193 int sqlite3WalCallback(Wal *pWal){

3194 u32 ret = 0;

3195 if( pWal ){

3196 ret = pWal->iCallback;

3197 pWal->iCallback = 0;

3198 }

3199 return (int)ret;

3200 }

3201

3202 /*

3203 ** This function is called to change the WAL subsystem into or out

3204 ** of locking_mode=EXCLUSIVE.

3205 **

3206 ** If op is zero, then attempt to change from locking_mode=EXCLUSIVE

3207 ** into locking_mode=NORMAL. This means that we must acquire a lock

3208 ** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL

3209 ** or if the acquisition of the lock fails, then return 0. If the

3210 ** transition out of exclusive-mode is successful, return 1. This

3211 ** operation must occur while the pager is still holding the exclusive

3212 ** lock on the main database file.

3213 **

3214 ** If op is one, then change from locking_mode=NORMAL into

3215 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must

3216 ** be released. Return 1 if the transition is made and 0 if the

3217 ** WAL is already in exclusive-locking mode - meaning that this

3218 ** routine is a no-op. The pager must already hold the exclusive lock

3219 ** on the main database file before invoking this operation.

3220 **

3221 ** If op is negative, then do a dry-run of the op==1 case but do

3222 ** not actually change anything. The pager uses this to see if it

3223 ** should acquire the database exclusive lock prior to invoking

3224 ** the op==1 case.

3225 */

3226 int sqlite3WalExclusiveMode(Wal *pWal, int op){

3227 int rc;

3228 assert( pWal->writeLock==0 );

3229 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE \|\| op==-1 );

3230

3231 /* pWal->readLock is usually set, but might be -1 if there was a

3232 ** prior error while attempting to acquire are read-lock. This cannot

3233 ** happen if the connection is actually in exclusive mode (as no xShmLock

3234 ** locks are taken in this case). Nor should the pager attempt to

3235 ** upgrade to exclusive-mode following such an error.

3236 */

3237 assert( pWal->readLock>=0 \|\| pWal->lockError );

3238 assert( pWal->readLock>=0 \|\| (op<=0 && pWal->exclusiveMode==0) );

3239

3240 if( op==0 ){

3241 if( pWal->exclusiveMode ){

3242 pWal->exclusiveMode = 0;

3243 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){

3244 pWal->exclusiveMode = 1;

3245 }

3246 rc = pWal->exclusiveMode==0;

3247 }else{

3248 /* Already in locking_mode=NORMAL */

3249 rc = 0;

3250 }

3251 }else if( op>0 ){

3252 assert( pWal->exclusiveMode==0 );

3253 assert( pWal->readLock>=0 );

3254 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));

3255 pWal->exclusiveMode = 1;

3256 rc = 1;

3257 }else{

3258 rc = pWal->exclusiveMode==0;

3259 }

3260 return rc;

3261 }

3262

3263 /*

3264 ** Return true if the argument is non-NULL and the WAL module is using

3265 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the

3266 ** WAL module is using shared-memory, return false.

3267 */

3268 int sqlite3WalHeapMemory(Wal *pWal){

3269 return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );

3270 }

3271

3272 #ifdef SQLITE_ENABLE_SNAPSHOT

3273 /* Create a snapshot object. The content of a snapshot is opaque to

3274 ** every other subsystem, so the WAL module can put whatever it needs

3275 ** in the object.

3276 */

3277 int sqlite3WalSnapshotGet(Wal pWal, sqlite3_snapshot *ppSnapshot){

3278 int rc = SQLITE_OK;

3279 WalIndexHdr *pRet;

3280

3281 assert( pWal->readLock>=0 && pWal->writeLock==0 );

3282

3283 pRet = (WalIndexHdr*)sqlite3_malloc(sizeof(WalIndexHdr));

3284 if( pRet==0 ){

3285 rc = SQLITE_NOMEM;

3286 }else{

3287 memcpy(pRet, &pWal->hdr, sizeof(WalIndexHdr));

3288 ppSnapshot = (sqlite3_snapshot)pRet;

3289 }

3290

3291 return rc;

3292 }

3293

3294 /* Try to open on pSnapshot when the next read-transaction starts

3295 */

3296 void sqlite3WalSnapshotOpen(Wal pWal, sqlite3_snapshot pSnapshot){

3297 pWal->pSnapshot = (WalIndexHdr*)pSnapshot;

3298 }

3299 #endif /* SQLITE_ENABLE_SNAPSHOT */

3300

3301 #ifdef SQLITE_ENABLE_ZIPVFS

3302 /*

3303 ** If the argument is not NULL, it points to a Wal object that holds a

3304 ** read-lock. This function returns the database page-size if it is known,

3305 ** or zero if it is not (or if pWal is NULL).

3306 */

3307 int sqlite3WalFramesize(Wal *pWal){

3308 assert( pWal==0 \|\| pWal->readLock>=0 );

3309 return (pWal ? pWal->szPage : 0);

3310 }

3311 #endif

3312

3313 /* Return the sqlite3_file object for the WAL file

3314 */

3315 sqlite3_file sqlite3WalFile(Wal pWal){

3316 return pWal->pWalFd;

3317 }

3318

3319 #endif /* #ifndef SQLITE_OMIT_WAL */

OLD	NEW

« no previous file with comments | « third_party/sqlite/sqlite-src-3100200/src/wal.h ('k') | third_party/sqlite/sqlite-src-3100200/src/walker.c » ('j') | no next file with comments »