The 5 states of an historical rollback lock as implemented by the

xLock, xUnlock, and xCheckReservedLock methods of the sqlite3_io_methods

objec are:

UNLOCKED

SHARED

RESERVED

PENDING

EXCLUSIVE

The wal-index file has a similar locking hierarchy implemented using

the xShmLock method of the sqlite3_vfs object, but with 7

states. Each connection to a wal-index file must be in one of

the following 7 states:

UNLOCKED

READ

READ_FULL

WRITE

PENDING

CHECKPOINT

RECOVER

These roughly correspond to the 5 states of a rollback lock except

that SHARED is split out into 2 states: READ and READ_FULL and

there is an extra RECOVER state used for wal-index reconstruction.

The meanings of the various wal-index locking states is as follows:

UNLOCKED - The wal-index is not in use.

READ - Some prefix of the wal-index is being read. Additional

wal-index information can be appended at any time. The

newly appended content will be ignored by the holder of

the READ lock.

READ_FULL - The entire wal-index is being read. No new information

can be added to the wal-index. The holder of a READ_FULL

lock promises never to read pages from the database file

that are available anywhere in the wal-index.

WRITE - It is OK to append to the wal-index file and to adjust

the header to indicate the new "last valid frame".

PENDING - Waiting on all READ locks to clear so that a

CHECKPOINT lock can be acquired.

CHECKPOINT - It is OK to write any WAL data into the database file

and zero the last valid frame field of the wal-index

header. The wal-index file itself may not be changed

other than to zero the last valid frame field in the

header.

RECOVER - Held during wal-index recovery. Used to prevent a

race if multiple clients try to recover a wal-index at

the same time.

A particular lock manager implementation may coalesce one or more of

the wal-index locking states, though with a reduction in concurrency.

For example, an implemention might implement only exclusive locking,

in which case all states would be equivalent to CHECKPOINT, meaning that

only one reader or one writer or one checkpointer could be active at a

time. Or, an implementation might combine READ and READ_FULL into

a single state equivalent to READ, meaning that a writer could

coexist with a reader, but no reader or writers could coexist with a

checkpointer.

The lock manager must obey the following rules:

(1) A READ cannot coexist with CHECKPOINT.

(2) A READ_FULL cannot coexist with WRITE.

(3) None of WRITE, PENDING, CHECKPOINT, or RECOVER can coexist.

The SQLite core will obey the next set of rules. These rules are

assertions on the behavior of the SQLite core which might be verified

during testing using an instrumented lock manager.

(5) No part of the wal-index will be read without holding either some

kind of SHM lock or an EXCLUSIVE lock on the original database.

The original database is the file named in the 2nd parameter to

the xShmOpen method.

(6) A holder of a READ_FULL will never read any page of the database

file that is contained anywhere in the wal-index.

(7) No part of the wal-index other than the header will be written nor

will the size of the wal-index grow without holding a WRITE or

an EXCLUSIVE on the original database file.

(8) The wal-index header will not be written without holding one of

WRITE, CHECKPOINT, or RECOVER on the wal-index or an EXCLUSIVE on

the original database files.

(9) A CHECKPOINT or RECOVER must be held on the wal-index, or an

EXCLUSIVE on the original database file, in order to reset the

last valid frame counter in the header of the wal-index back to zero.

(10) A WRITE can only increase the last valid frame pointer in the header.

The SQLite core will only ever send requests for UNLOCK, READ, WRITE,

CHECKPOINT, or RECOVER to the lock manager. The SQLite core will never

request a READ_FULL or PENDING lock though the lock manager may deliver

those locking states in response to READ and CHECKPOINT requests,

respectively, if and only if the requested READ or CHECKPOINT cannot

be delivered.

The following are the allowed lock transitions:

Original-State Request New-State

-------------- ---------- ----------

(11a) UNLOCK READ READ

(11b) UNLOCK READ READ_FULL

(11c) UNLOCK CHECKPOINT PENDING

(11d) UNLOCK CHECKPOINT CHECKPOINT

(11e) READ UNLOCK UNLOCK

(11f) READ WRITE WRITE

(11g) READ RECOVER RECOVER

(11h) READ_FULL UNLOCK UNLOCK

(11i) READ_FULL WRITE WRITE

(11j) READ_FULL RECOVER RECOVER

(11k) WRITE READ READ

(11l) PENDING UNLOCK UNLOCK

(11m) PENDING CHECKPOINT CHECKPOINT

(11n) CHECKPOINT UNLOCK UNLOCK

(11o) RECOVER READ READ

These 15 transitions are all that needs to be supported. The lock

manager implementation can assert that fact. The other 27 possible

transitions among the 7 locking states will never occur.