blob: 18b8960da79570c8d16aeaf2c70f73f0930efdfc [file] [log] [blame]
drhed7c8552001-04-11 14:29:21 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhed7c8552001-04-11 14:29:21 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhed7c8552001-04-11 14:29:21 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drhed7c8552001-04-11 14:29:21 +000010**
11*************************************************************************
drhb19a2bc2001-09-16 00:13:26 +000012** This is the implementation of the page cache subsystem or "pager".
drhed7c8552001-04-11 14:29:21 +000013**
drhb19a2bc2001-09-16 00:13:26 +000014** The pager is used to access a database disk file. It implements
15** atomic commit and rollback through the use of a journal file that
16** is separate from the database file. The pager also implements file
17** locking to prevent two processes from writing the same database
18** file simultaneously, or one process from reading the database while
19** another is writing.
drhed7c8552001-04-11 14:29:21 +000020*/
drh2e66f0b2005-04-28 17:18:48 +000021#ifndef SQLITE_OMIT_DISKIO
drhd9b02572001-04-15 00:37:09 +000022#include "sqliteInt.h"
dan7c246102010-04-12 19:00:29 +000023#include "log.h"
drhed7c8552001-04-11 14:29:21 +000024
25/*
drh91781bd2010-04-10 17:52:57 +000026******************** NOTES ON THE DESIGN OF THE PAGER ************************
27**
28** Within this comment block, a page is deemed to have been synced
29** automatically as soon as it is written when PRAGMA synchronous=OFF.
30** Otherwise, the page is not synced until the xSync method of the VFS
31** is called successfully on the file containing the page.
32**
33** Definition: A page of the database file is said to be "overwriteable" if
34** one or more of the following are true about the page:
35**
36** (a) The original content of the page as it was at the beginning of
37** the transaction has been written into the rollback journal and
38** synced.
39**
40** (b) The page was a freelist leaf page at the start of the transaction.
41**
42** (c) The page number is greater than the largest page that existed in
43** the database file at the start of the transaction.
44**
45** (1) A page of the database file is never overwritten unless one of the
46** following are true:
47**
48** (a) The page and all other pages on the same sector are overwriteable.
49**
50** (b) The atomic page write optimization is enabled, and the entire
51** transaction other than the update of the transaction sequence
52** number consists of a single page change.
53**
54** (2) The content of a page written into the rollback journal exactly matches
55** both the content in the database when the rollback journal was written
56** and the content in the database at the beginning of the current
57** transaction.
58**
59** (3) Writes to the database file are an integer multiple of the page size
60** in length and are aligned to a page boundary.
61**
62** (4) Reads from the database file are either aligned on a page boundary and
63** an integer multiple of the page size in length or are taken from the
64** first 100 bytes of the database file.
65**
66** (5) All writes to the database file are synced prior to the rollback journal
67** being deleted, truncated, or zeroed.
68**
69** (6) If a master journal file is used, then all writes to the database file
70** are synced prior to the master journal being deleted.
71**
72** Definition: Two databases (or the same database at two points it time)
73** are said to be "logically equivalent" if they give the same answer to
74** all queries. Note in particular the the content of freelist leaf
75** pages can be changed arbitarily without effecting the logical equivalence
76** of the database.
77**
78** (7) At any time, if any subset, including the empty set and the total set,
79** of the unsynced changes to a rollback journal are removed and the
80** journal is rolled back, the resulting database file will be logical
81** equivalent to the database file at the beginning of the transaction.
82**
83** (8) When a transaction is rolled back, the xTruncate method of the VFS
84** is called to restore the database file to the same size it was at
85** the beginning of the transaction. (In some VFSes, the xTruncate
86** method is a no-op, but that does not change the fact the SQLite will
87** invoke it.)
88**
89** (9) Whenever the database file is modified, at least one bit in the range
90** of bytes from 24 through 39 inclusive will be changed prior to releasing
91** the EXCLUSIVE lock.
92**
93** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
94** than one billion transactions.
95**
96** (11) A database file is well-formed at the beginning and at the conclusion
97** of every transaction.
98**
99** (12) An EXCLUSIVE lock is held on the database file when writing to
100** the database file.
101**
102** (13) A SHARED lock is held on the database file while reading any
103** content out of the database file.
104*/
105
106/*
drhdb48ee02003-01-16 13:42:43 +0000107** Macros for troubleshooting. Normally turned off
108*/
danielk1977466be562004-06-10 02:16:01 +0000109#if 0
danielk1977f2c31ad2009-01-06 13:40:08 +0000110int sqlite3PagerTrace=1; /* True to enable tracing */
drhd3627af2006-12-18 18:34:51 +0000111#define sqlite3DebugPrintf printf
drh30d53702009-01-06 15:58:57 +0000112#define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }
drhdb48ee02003-01-16 13:42:43 +0000113#else
drh30d53702009-01-06 15:58:57 +0000114#define PAGERTRACE(X)
drhdb48ee02003-01-16 13:42:43 +0000115#endif
116
danielk1977599fcba2004-11-08 07:13:13 +0000117/*
drh30d53702009-01-06 15:58:57 +0000118** The following two macros are used within the PAGERTRACE() macros above
drhd86959f2005-11-26 03:51:18 +0000119** to print out file-descriptors.
danielk1977599fcba2004-11-08 07:13:13 +0000120**
drh85b623f2007-12-13 21:54:09 +0000121** PAGERID() takes a pointer to a Pager struct as its argument. The
danielk197762079062007-08-15 17:08:46 +0000122** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
drh85b623f2007-12-13 21:54:09 +0000123** struct as its argument.
danielk1977599fcba2004-11-08 07:13:13 +0000124*/
drhc001c582006-03-06 18:23:16 +0000125#define PAGERID(p) ((int)(p->fd))
126#define FILEHANDLEID(fd) ((int)fd)
drhdb48ee02003-01-16 13:42:43 +0000127
128/*
drhed7c8552001-04-11 14:29:21 +0000129** The page cache as a whole is always in one of the following
130** states:
131**
drha6abd042004-06-09 17:37:22 +0000132** PAGER_UNLOCK The page cache is not currently reading or
drhed7c8552001-04-11 14:29:21 +0000133** writing the database file. There is no
134** data held in memory. This is the initial
135** state.
136**
drha6abd042004-06-09 17:37:22 +0000137** PAGER_SHARED The page cache is reading the database.
drhed7c8552001-04-11 14:29:21 +0000138** Writing is not permitted. There can be
139** multiple readers accessing the same database
drh69688d52001-04-14 16:38:23 +0000140** file at the same time.
drhed7c8552001-04-11 14:29:21 +0000141**
drh726de592004-06-10 23:35:50 +0000142** PAGER_RESERVED This process has reserved the database for writing
143** but has not yet made any changes. Only one process
144** at a time can reserve the database. The original
145** database file has not been modified so other
146** processes may still be reading the on-disk
drha6abd042004-06-09 17:37:22 +0000147** database file.
148**
149** PAGER_EXCLUSIVE The page cache is writing the database.
drhed7c8552001-04-11 14:29:21 +0000150** Access is exclusive. No other processes or
151** threads can be reading or writing while one
152** process is writing.
153**
danielk1977aa5ccdf2004-06-14 05:10:42 +0000154** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE
155** after all dirty pages have been written to the
156** database file and the file has been synced to
drh369339d2007-03-30 16:01:55 +0000157** disk. All that remains to do is to remove or
158** truncate the journal file and the transaction
159** will be committed.
danielk1977aa5ccdf2004-06-14 05:10:42 +0000160**
drha6abd042004-06-09 17:37:22 +0000161** The page cache comes up in PAGER_UNLOCK. The first time a
danielk19773b8a05f2007-03-19 17:44:26 +0000162** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED.
drhed7c8552001-04-11 14:29:21 +0000163** After all pages have been released using sqlite_page_unref(),
drha6abd042004-06-09 17:37:22 +0000164** the state transitions back to PAGER_UNLOCK. The first time
danielk19773b8a05f2007-03-19 17:44:26 +0000165** that sqlite3PagerWrite() is called, the state transitions to
drh369339d2007-03-30 16:01:55 +0000166** PAGER_RESERVED. (Note that sqlite3PagerWrite() can only be
drh306dc212001-05-21 13:45:10 +0000167** called on an outstanding page which means that the pager must
drha6abd042004-06-09 17:37:22 +0000168** be in PAGER_SHARED before it transitions to PAGER_RESERVED.)
drh369339d2007-03-30 16:01:55 +0000169** PAGER_RESERVED means that there is an open rollback journal.
170** The transition to PAGER_EXCLUSIVE occurs before any changes
171** are made to the database file, though writes to the rollback
172** journal occurs with just PAGER_RESERVED. After an sqlite3PagerRollback()
173** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED,
174** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode.
drhed7c8552001-04-11 14:29:21 +0000175*/
drha6abd042004-06-09 17:37:22 +0000176#define PAGER_UNLOCK 0
drh684917c2004-10-05 02:41:42 +0000177#define PAGER_SHARED 1 /* same as SHARED_LOCK */
178#define PAGER_RESERVED 2 /* same as RESERVED_LOCK */
179#define PAGER_EXCLUSIVE 4 /* same as EXCLUSIVE_LOCK */
180#define PAGER_SYNCED 5
drhed7c8552001-04-11 14:29:21 +0000181
drh684917c2004-10-05 02:41:42 +0000182/*
drh9eb9e262004-02-11 02:18:05 +0000183** A macro used for invoking the codec if there is one
184*/
185#ifdef SQLITE_HAS_CODEC
drh85d2bd22009-06-11 00:47:20 +0000186# define CODEC1(P,D,N,X,E) \
drhfa9601a2009-06-18 17:22:39 +0000187 if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
drh85d2bd22009-06-11 00:47:20 +0000188# define CODEC2(P,D,N,X,E,O) \
189 if( P->xCodec==0 ){ O=(char*)D; }else \
drhfa9601a2009-06-18 17:22:39 +0000190 if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
drh9eb9e262004-02-11 02:18:05 +0000191#else
drh85d2bd22009-06-11 00:47:20 +0000192# define CODEC1(P,D,N,X,E) /* NO-OP */
193# define CODEC2(P,D,N,X,E,O) O=(char*)D
drh9eb9e262004-02-11 02:18:05 +0000194#endif
195
drhed7c8552001-04-11 14:29:21 +0000196/*
drh1a5c00f2009-08-10 17:48:57 +0000197** The maximum allowed sector size. 64KiB. If the xSectorsize() method
danielk19777cbd5892009-01-10 16:15:09 +0000198** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
199** This could conceivably cause corruption following a power failure on
200** such a system. This is currently an undocumented limit.
201*/
drh1a5c00f2009-08-10 17:48:57 +0000202#define MAX_SECTOR_SIZE 0x10000
danielk19777cbd5892009-01-10 16:15:09 +0000203
204/*
danielk1977fd7f0452008-12-17 17:30:26 +0000205** An instance of the following structure is allocated for each active
206** savepoint and statement transaction in the system. All such structures
207** are stored in the Pager.aSavepoint[] array, which is allocated and
208** resized using sqlite3Realloc().
209**
210** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
211** set to 0. If a journal-header is written into the main journal while
212** the savepoint is active, then iHdrOffset is set to the byte offset
213** immediately following the last journal record written into the main
214** journal before the journal-header. This is required during savepoint
215** rollback (see pagerPlaybackSavepoint()).
216*/
217typedef struct PagerSavepoint PagerSavepoint;
218struct PagerSavepoint {
219 i64 iOffset; /* Starting offset in main journal */
220 i64 iHdrOffset; /* See above */
221 Bitvec *pInSavepoint; /* Set of pages in this savepoint */
222 Pgno nOrig; /* Original number of pages in file */
223 Pgno iSubRec; /* Index of first record in sub-journal */
224};
225
226/*
drhed7c8552001-04-11 14:29:21 +0000227** A open page cache is an instance of the following structure.
danielk1977efaaf572006-01-16 11:29:19 +0000228**
danielk1977bea2a942009-01-20 17:06:27 +0000229** errCode
danielk19773460d192008-12-27 15:23:13 +0000230**
danielk1977bea2a942009-01-20 17:06:27 +0000231** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
232** or SQLITE_FULL. Once one of the first three errors occurs, it persists
233** and is returned as the result of every major pager API call. The
234** SQLITE_FULL return code is slightly different. It persists only until the
235** next successful rollback is performed on the pager cache. Also,
236** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()
237** APIs, they may still be used successfully.
238**
239** dbSizeValid, dbSize, dbOrigSize, dbFileSize
240**
241** Managing the size of the database file in pages is a little complicated.
242** The variable Pager.dbSize contains the number of pages that the database
243** image currently contains. As the database image grows or shrinks this
244** variable is updated. The variable Pager.dbFileSize contains the number
245** of pages in the database file. This may be different from Pager.dbSize
246** if some pages have been appended to the database image but not yet written
247** out from the cache to the actual file on disk. Or if the image has been
248** truncated by an incremental-vacuum operation. The Pager.dbOrigSize variable
249** contains the number of pages in the database image when the current
250** transaction was opened. The contents of all three of these variables is
251** only guaranteed to be correct if the boolean Pager.dbSizeValid is true.
252**
253** TODO: Under what conditions is dbSizeValid set? Cleared?
254**
255** changeCountDone
256**
257** This boolean variable is used to make sure that the change-counter
258** (the 4-byte header field at byte offset 24 of the database file) is
259** not updated more often than necessary.
260**
261** It is set to true when the change-counter field is updated, which
262** can only happen if an exclusive lock is held on the database file.
263** It is cleared (set to false) whenever an exclusive lock is
264** relinquished on the database file. Each time a transaction is committed,
265** The changeCountDone flag is inspected. If it is true, the work of
266** updating the change-counter is omitted for the current transaction.
267**
268** This mechanism means that when running in exclusive mode, a connection
269** need only update the change-counter once, for the first transaction
270** committed.
271**
272** dbModified
273**
274** The dbModified flag is set whenever a database page is dirtied.
275** It is cleared at the end of each transaction.
276**
277** It is used when committing or otherwise ending a transaction. If
278** the dbModified flag is clear then less work has to be done.
279**
280** journalStarted
281**
drh91781bd2010-04-10 17:52:57 +0000282** This flag is set whenever the the main journal is opened and
283** initialized
danielk1977bea2a942009-01-20 17:06:27 +0000284**
285** The point of this flag is that it must be set after the
286** first journal header in a journal file has been synced to disk.
287** After this has happened, new pages appended to the database
288** do not need the PGHDR_NEED_SYNC flag set, as they do not need
289** to wait for a journal sync before they can be written out to
290** the database file (see function pager_write()).
291**
292** setMaster
293**
294** This variable is used to ensure that the master journal file name
295** (if any) is only written into the journal file once.
296**
297** When committing a transaction, the master journal file name (if any)
298** may be written into the journal file while the pager is still in
299** PAGER_RESERVED state (see CommitPhaseOne() for the action). It
300** then attempts to upgrade to an exclusive lock. If this attempt
301** fails, then SQLITE_BUSY may be returned to the user and the user
302** may attempt to commit the transaction again later (calling
303** CommitPhaseOne() again). This flag is used to ensure that the
304** master journal name is only written to the journal file the first
305** time CommitPhaseOne() is called.
306**
307** doNotSync
308**
drh91781bd2010-04-10 17:52:57 +0000309** When enabled, cache spills are prohibited and the journal file cannot
310** be synced. This variable is set and cleared by sqlite3PagerWrite()
311** in order to prevent a journal sync from happening in between the
312** journalling of two pages on the same sector.
danielk1977bea2a942009-01-20 17:06:27 +0000313**
314** needSync
315**
316** TODO: It might be easier to set this variable in writeJournalHdr()
317** and writeMasterJournal() only. Change its meaning to "unsynced data
318** has been written to the journal".
danielk1977d8293352009-04-30 09:10:37 +0000319**
320** subjInMemory
321**
322** This is a boolean variable. If true, then any required sub-journal
323** is opened as an in-memory journal file. If false, then in-memory
324** sub-journals are only used for in-memory pager files.
drhed7c8552001-04-11 14:29:21 +0000325*/
326struct Pager {
danielk1977b4b47412007-08-17 15:53:36 +0000327 sqlite3_vfs *pVfs; /* OS functions to use for IO */
danielk1977bea2a942009-01-20 17:06:27 +0000328 u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
329 u8 journalMode; /* On of the PAGER_JOURNALMODE_* values */
drh34e79ce2004-02-08 06:05:46 +0000330 u8 useJournal; /* Use a rollback journal on this file */
drh7bec5052005-02-06 02:45:41 +0000331 u8 noReadlock; /* Do not bother to obtain readlocks */
drh603240c2002-03-05 01:11:12 +0000332 u8 noSync; /* Do not sync the journal if true */
drh968af522003-02-11 14:55:40 +0000333 u8 fullSync; /* Do extra syncs of the journal for robustness */
danielk1977f036aef2007-08-20 05:36:51 +0000334 u8 sync_flags; /* One of SYNC_NORMAL or SYNC_FULL */
drh603240c2002-03-05 01:11:12 +0000335 u8 tempFile; /* zFilename is a temporary file */
336 u8 readOnly; /* True for a read-only database */
danielk197745d68822009-01-16 16:23:38 +0000337 u8 memDb; /* True to inhibit all file I/O */
danielk1977bea2a942009-01-20 17:06:27 +0000338
339 /* The following block contains those class members that are dynamically
340 ** modified during normal operations. The other variables in this structure
341 ** are either constant throughout the lifetime of the pager, or else
342 ** used to store configuration parameters that affect the way the pager
343 ** operates.
344 **
345 ** The 'state' variable is described in more detail along with the
346 ** descriptions of the values it may take - PAGER_UNLOCK etc. Many of the
347 ** other variables in this block are described in the comment directly
348 ** above this class definition.
349 */
350 u8 state; /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */
351 u8 dbModified; /* True if there are any changes to the Db */
352 u8 needSync; /* True if an fsync() is needed on the journal */
353 u8 journalStarted; /* True if header of journal is synced */
354 u8 changeCountDone; /* Set after incrementing the change-counter */
drh6d156e42005-05-20 20:11:20 +0000355 u8 setMaster; /* True if a m-j name has been written to jrnl */
drh80e35f42007-03-30 14:06:34 +0000356 u8 doNotSync; /* Boolean. While true, do not spill the cache */
danielk1977d92db532008-11-17 04:56:24 +0000357 u8 dbSizeValid; /* Set when dbSize is correct */
danielk1977d8293352009-04-30 09:10:37 +0000358 u8 subjInMemory; /* True to use in-memory sub-journals */
danielk19773460d192008-12-27 15:23:13 +0000359 Pgno dbSize; /* Number of pages in the database */
360 Pgno dbOrigSize; /* dbSize before the current transaction */
361 Pgno dbFileSize; /* Number of pages in the database file */
danielk197745d68822009-01-16 16:23:38 +0000362 int errCode; /* One of several kinds of errors */
danielk1977bea2a942009-01-20 17:06:27 +0000363 int nRec; /* Pages journalled since last j-header written */
danielk197745d68822009-01-16 16:23:38 +0000364 u32 cksumInit; /* Quasi-random value added to every checksum */
danielk1977bea2a942009-01-20 17:06:27 +0000365 u32 nSubRec; /* Number of records written to sub-journal */
danielk197745d68822009-01-16 16:23:38 +0000366 Bitvec *pInJournal; /* One bit for each page in the database file */
danielk1977bea2a942009-01-20 17:06:27 +0000367 sqlite3_file *fd; /* File descriptor for database */
368 sqlite3_file *jfd; /* File descriptor for main journal */
369 sqlite3_file *sjfd; /* File descriptor for sub-journal */
370 i64 journalOff; /* Current write offset in the journal file */
371 i64 journalHdr; /* Byte offset to previous journal header */
drh91781bd2010-04-10 17:52:57 +0000372 i64 journalSizeLimit; /* Size limit for persistent journal files */
danielk1977bea2a942009-01-20 17:06:27 +0000373 PagerSavepoint *aSavepoint; /* Array of active savepoints */
374 int nSavepoint; /* Number of elements in aSavepoint[] */
375 char dbFileVers[16]; /* Changes whenever database file changes */
376 u32 sectorSize; /* Assumed sector size during rollback */
377
drhfa9601a2009-06-18 17:22:39 +0000378 u16 nExtra; /* Add this many bytes to each in-memory page */
379 i16 nReserve; /* Number of unused bytes at end of each page */
danielk1977bea2a942009-01-20 17:06:27 +0000380 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
381 int pageSize; /* Number of bytes in a page */
382 Pgno mxPgno; /* Maximum allowed size of the database */
drhfcd35c72005-05-21 02:48:08 +0000383 char *zFilename; /* Name of the database file */
384 char *zJournal; /* Name of the journal file */
danielk19771ceedd32008-11-19 10:22:33 +0000385 int (*xBusyHandler)(void*); /* Function to call when busy */
386 void *pBusyHandlerArg; /* Context argument for xBusyHandler */
drhfcd35c72005-05-21 02:48:08 +0000387#ifdef SQLITE_TEST
drh7c4ac0c2007-04-05 11:25:58 +0000388 int nHit, nMiss; /* Cache hits and missing */
389 int nRead, nWrite; /* Database pages read/written */
drhfcd35c72005-05-21 02:48:08 +0000390#endif
danielk1977eaa06f62008-09-18 17:34:44 +0000391 void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
drh7c4ac0c2007-04-05 11:25:58 +0000392#ifdef SQLITE_HAS_CODEC
drhc001c582006-03-06 18:23:16 +0000393 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
drhfa9601a2009-06-18 17:22:39 +0000394 void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
395 void (*xCodecFree)(void*); /* Destructor for the codec */
396 void *pCodec; /* First argument to xCodec... methods */
drh7c4ac0c2007-04-05 11:25:58 +0000397#endif
danielk19778186df82007-03-06 13:45:59 +0000398 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
danielk19778c0a7912008-08-20 14:49:23 +0000399 PCache *pPCache; /* Pointer to page cache object */
danielk197704103022009-02-03 16:51:24 +0000400 sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
dan7c246102010-04-12 19:00:29 +0000401 Log *pLog; /* Log used by "journal_mode=wal" */
drhd9b02572001-04-15 00:37:09 +0000402};
403
404/*
drh538f5702007-04-13 02:14:30 +0000405** The following global variables hold counters used for
406** testing purposes only. These variables do not exist in
407** a non-testing build. These variables are not thread-safe.
drhfcd35c72005-05-21 02:48:08 +0000408*/
409#ifdef SQLITE_TEST
drh538f5702007-04-13 02:14:30 +0000410int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
411int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
412int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
drh538f5702007-04-13 02:14:30 +0000413# define PAGER_INCR(v) v++
drhfcd35c72005-05-21 02:48:08 +0000414#else
drh538f5702007-04-13 02:14:30 +0000415# define PAGER_INCR(v)
drhfcd35c72005-05-21 02:48:08 +0000416#endif
417
drh538f5702007-04-13 02:14:30 +0000418
419
drhfcd35c72005-05-21 02:48:08 +0000420/*
drh5e00f6c2001-09-13 13:46:56 +0000421** Journal files begin with the following magic string. The data
422** was obtained from /dev/random. It is used only as a sanity check.
drh94f33312002-08-12 12:29:56 +0000423**
drhae2b40c2004-06-09 19:03:54 +0000424** Since version 2.8.0, the journal format contains additional sanity
drh30d53702009-01-06 15:58:57 +0000425** checking information. If the power fails while the journal is being
drhae2b40c2004-06-09 19:03:54 +0000426** written, semi-random garbage data might appear in the journal
427** file after power is restored. If an attempt is then made
drh968af522003-02-11 14:55:40 +0000428** to roll the journal back, the database could be corrupted. The additional
429** sanity checking data is an attempt to discover the garbage in the
430** journal and ignore it.
431**
drhae2b40c2004-06-09 19:03:54 +0000432** The sanity checking information for the new journal format consists
drh968af522003-02-11 14:55:40 +0000433** of a 32-bit checksum on each page of data. The checksum covers both
drh90f5ecb2004-07-22 01:19:35 +0000434** the page number and the pPager->pageSize bytes of data for the page.
drh968af522003-02-11 14:55:40 +0000435** This cksum is initialized to a 32-bit random value that appears in the
436** journal file right after the header. The random initializer is important,
437** because garbage data that appears at the end of a journal is likely
438** data that was once in other files that have now been deleted. If the
439** garbage data came from an obsolete journal file, the checksums might
440** be correct. But by initializing the checksum to random value which
441** is different for every journal, we minimize that risk.
drhd9b02572001-04-15 00:37:09 +0000442*/
drhae2b40c2004-06-09 19:03:54 +0000443static const unsigned char aJournalMagic[] = {
444 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
drhed7c8552001-04-11 14:29:21 +0000445};
446
447/*
danielk1977bea2a942009-01-20 17:06:27 +0000448** The size of the of each page record in the journal is given by
449** the following macro.
drh968af522003-02-11 14:55:40 +0000450*/
drhae2b40c2004-06-09 19:03:54 +0000451#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
drh968af522003-02-11 14:55:40 +0000452
danielk197776572402004-06-25 02:38:54 +0000453/*
danielk1977bea2a942009-01-20 17:06:27 +0000454** The journal header size for this pager. This is usually the same
455** size as a single disk sector. See also setSectorSize().
danielk197776572402004-06-25 02:38:54 +0000456*/
457#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
458
drhb7f91642004-10-31 02:22:47 +0000459/*
460** The macro MEMDB is true if we are dealing with an in-memory database.
461** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
462** the value of MEMDB will be a constant and the compiler will optimize
463** out code that would never execute.
464*/
465#ifdef SQLITE_OMIT_MEMORYDB
466# define MEMDB 0
467#else
468# define MEMDB pPager->memDb
469#endif
470
471/*
danielk197726836652005-01-17 01:33:13 +0000472** The maximum legal page number is (2^31 - 1).
473*/
474#define PAGER_MAX_PGNO 2147483647
475
danielk1977bea2a942009-01-20 17:06:27 +0000476#ifndef NDEBUG
477/*
478** Usage:
479**
480** assert( assert_pager_state(pPager) );
481*/
482static int assert_pager_state(Pager *pPager){
483
484 /* A temp-file is always in PAGER_EXCLUSIVE or PAGER_SYNCED state. */
485 assert( pPager->tempFile==0 || pPager->state>=PAGER_EXCLUSIVE );
486
487 /* The changeCountDone flag is always set for temp-files */
488 assert( pPager->tempFile==0 || pPager->changeCountDone );
489
490 return 1;
491}
492#endif
493
danielk197726836652005-01-17 01:33:13 +0000494/*
danielk19773460d192008-12-27 15:23:13 +0000495** Return true if it is necessary to write page *pPg into the sub-journal.
496** A page needs to be written into the sub-journal if there exists one
497** or more open savepoints for which:
danielk1977fd7f0452008-12-17 17:30:26 +0000498**
danielk19773460d192008-12-27 15:23:13 +0000499** * The page-number is less than or equal to PagerSavepoint.nOrig, and
500** * The bit corresponding to the page-number is not set in
501** PagerSavepoint.pInSavepoint.
danielk1977f35843b2007-04-07 15:03:17 +0000502*/
danielk19773460d192008-12-27 15:23:13 +0000503static int subjRequiresPage(PgHdr *pPg){
504 Pgno pgno = pPg->pgno;
danielk1977f35843b2007-04-07 15:03:17 +0000505 Pager *pPager = pPg->pPager;
danielk19773460d192008-12-27 15:23:13 +0000506 int i;
507 for(i=0; i<pPager->nSavepoint; i++){
508 PagerSavepoint *p = &pPager->aSavepoint[i];
509 if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
510 return 1;
511 }
danielk1977fd7f0452008-12-17 17:30:26 +0000512 }
danielk19773460d192008-12-27 15:23:13 +0000513 return 0;
danielk1977f35843b2007-04-07 15:03:17 +0000514}
drh8ca0c722006-05-07 17:49:38 +0000515
danielk19773460d192008-12-27 15:23:13 +0000516/*
517** Return true if the page is already in the journal file.
518*/
danielk1977bc2ca9e2008-11-13 14:28:28 +0000519static int pageInJournal(PgHdr *pPg){
520 return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
521}
522
drh8ca0c722006-05-07 17:49:38 +0000523/*
drh34e79ce2004-02-08 06:05:46 +0000524** Read a 32-bit integer from the given file descriptor. Store the integer
525** that is read in *pRes. Return SQLITE_OK if everything worked, or an
526** error code is something goes wrong.
drh726de592004-06-10 23:35:50 +0000527**
528** All values are stored on disk as big-endian.
drh94f33312002-08-12 12:29:56 +0000529*/
danielk197762079062007-08-15 17:08:46 +0000530static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
drh3b59a5c2006-01-15 20:28:28 +0000531 unsigned char ac[4];
danielk197762079062007-08-15 17:08:46 +0000532 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
drhae2b40c2004-06-09 19:03:54 +0000533 if( rc==SQLITE_OK ){
drha3152892007-05-05 11:48:52 +0000534 *pRes = sqlite3Get4byte(ac);
drh94f33312002-08-12 12:29:56 +0000535 }
drh94f33312002-08-12 12:29:56 +0000536 return rc;
537}
538
539/*
drh97b57482006-01-10 20:32:32 +0000540** Write a 32-bit integer into a string buffer in big-endian byte order.
541*/
drha3152892007-05-05 11:48:52 +0000542#define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
drh97b57482006-01-10 20:32:32 +0000543
544/*
drh34e79ce2004-02-08 06:05:46 +0000545** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
546** on success or an error code is something goes wrong.
drh94f33312002-08-12 12:29:56 +0000547*/
danielk197762079062007-08-15 17:08:46 +0000548static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
danielk1977bab45c62006-01-16 15:14:27 +0000549 char ac[4];
drh97b57482006-01-10 20:32:32 +0000550 put32bits(ac, val);
danielk197762079062007-08-15 17:08:46 +0000551 return sqlite3OsWrite(fd, ac, 4, offset);
drh94f33312002-08-12 12:29:56 +0000552}
553
drh2554f8b2003-01-22 01:26:44 +0000554/*
danielk1977bea2a942009-01-20 17:06:27 +0000555** The argument to this macro is a file descriptor (type sqlite3_file*).
556** Return 0 if it is not open, or non-zero (but not 1) if it is.
557**
558** This is so that expressions can be written as:
559**
560** if( isOpen(pPager->jfd) ){ ...
561**
562** instead of
563**
564** if( pPager->jfd->pMethods ){ ...
565*/
566#define isOpen(pFd) ((pFd)->pMethods)
567
568/*
danielk19777a2b1ee2007-08-21 14:27:01 +0000569** If file pFd is open, call sqlite3OsUnlock() on it.
570*/
571static int osUnlock(sqlite3_file *pFd, int eLock){
danielk1977bea2a942009-01-20 17:06:27 +0000572 if( !isOpen(pFd) ){
danielk19777a2b1ee2007-08-21 14:27:01 +0000573 return SQLITE_OK;
574 }
575 return sqlite3OsUnlock(pFd, eLock);
576}
577
578/*
danielk1977c7b60172007-08-22 11:22:03 +0000579** This function determines whether or not the atomic-write optimization
580** can be used with this pager. The optimization can be used if:
581**
582** (a) the value returned by OsDeviceCharacteristics() indicates that
583** a database page may be written atomically, and
584** (b) the value returned by OsSectorSize() is less than or equal
585** to the page size.
586**
danielk1977bea2a942009-01-20 17:06:27 +0000587** The optimization is also always enabled for temporary files. It is
588** an error to call this function if pPager is opened on an in-memory
589** database.
590**
danielk1977c7b60172007-08-22 11:22:03 +0000591** If the optimization cannot be used, 0 is returned. If it can be used,
592** then the value returned is the size of the journal file when it
593** contains rollback data for exactly one page.
594*/
595#ifdef SQLITE_ENABLE_ATOMIC_WRITE
596static int jrnlBufferSize(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +0000597 assert( !MEMDB );
598 if( !pPager->tempFile ){
599 int dc; /* Device characteristics */
600 int nSector; /* Sector size */
601 int szPage; /* Page size */
danielk1977c7b60172007-08-22 11:22:03 +0000602
danielk1977bea2a942009-01-20 17:06:27 +0000603 assert( isOpen(pPager->fd) );
604 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
danielk19777cbd5892009-01-10 16:15:09 +0000605 nSector = pPager->sectorSize;
drhfacf0302008-06-17 15:12:00 +0000606 szPage = pPager->pageSize;
danielk1977c7b60172007-08-22 11:22:03 +0000607
danielk1977bea2a942009-01-20 17:06:27 +0000608 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
609 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
610 if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
611 return 0;
danielk1977ae72d982007-10-03 08:46:44 +0000612 }
danielk1977aef0bf62005-12-30 16:28:01 +0000613 }
danielk1977bea2a942009-01-20 17:06:27 +0000614
615 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
danielk1977aef0bf62005-12-30 16:28:01 +0000616}
danielk1977bea2a942009-01-20 17:06:27 +0000617#endif
danielk1977aef0bf62005-12-30 16:28:01 +0000618
drh477731b2007-06-16 03:06:27 +0000619/*
620** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
621** on the cache using a hash function. This is used for testing
622** and debugging only.
623*/
danielk19773c407372005-02-15 02:54:14 +0000624#ifdef SQLITE_CHECK_PAGES
625/*
626** Return a 32-bit hash of the page data for pPage.
627*/
drh477731b2007-06-16 03:06:27 +0000628static u32 pager_datahash(int nByte, unsigned char *pData){
danielk19773c407372005-02-15 02:54:14 +0000629 u32 hash = 0;
630 int i;
drh477731b2007-06-16 03:06:27 +0000631 for(i=0; i<nByte; i++){
632 hash = (hash*1039) + pData[i];
danielk19773c407372005-02-15 02:54:14 +0000633 }
634 return hash;
635}
drh477731b2007-06-16 03:06:27 +0000636static u32 pager_pagehash(PgHdr *pPage){
danielk19778c0a7912008-08-20 14:49:23 +0000637 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
638}
danielk1977bc2ca9e2008-11-13 14:28:28 +0000639static void pager_set_pagehash(PgHdr *pPage){
danielk19778c0a7912008-08-20 14:49:23 +0000640 pPage->pageHash = pager_pagehash(pPage);
drh477731b2007-06-16 03:06:27 +0000641}
danielk19773c407372005-02-15 02:54:14 +0000642
643/*
644** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
645** is defined, and NDEBUG is not defined, an assert() statement checks
646** that the page is either dirty or still matches the calculated page-hash.
647*/
648#define CHECK_PAGE(x) checkPage(x)
649static void checkPage(PgHdr *pPg){
650 Pager *pPager = pPg->pPager;
danielk1977b3175382008-10-17 18:51:52 +0000651 assert( !pPg->pageHash || pPager->errCode
danielk19778c0a7912008-08-20 14:49:23 +0000652 || (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
danielk19773c407372005-02-15 02:54:14 +0000653}
654
655#else
drh8ffa8172007-06-18 17:25:17 +0000656#define pager_datahash(X,Y) 0
drh477731b2007-06-16 03:06:27 +0000657#define pager_pagehash(X) 0
danielk19773c407372005-02-15 02:54:14 +0000658#define CHECK_PAGE(x)
drh41d30272008-08-20 21:47:45 +0000659#endif /* SQLITE_CHECK_PAGES */
danielk19773c407372005-02-15 02:54:14 +0000660
drhed7c8552001-04-11 14:29:21 +0000661/*
danielk197776572402004-06-25 02:38:54 +0000662** When this is called the journal file for pager pPager must be open.
danielk1977bea2a942009-01-20 17:06:27 +0000663** This function attempts to read a master journal file name from the
664** end of the file and, if successful, copies it into memory supplied
665** by the caller. See comments above writeMasterJournal() for the format
666** used to store a master journal file name at the end of a journal file.
danielk197776572402004-06-25 02:38:54 +0000667**
danielk197765839c62007-08-30 08:08:17 +0000668** zMaster must point to a buffer of at least nMaster bytes allocated by
669** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
670** enough space to write the master journal name). If the master journal
671** name in the journal is longer than nMaster bytes (including a
672** nul-terminator), then this is handled as if no master journal name
673** were present in the journal.
674**
danielk1977bea2a942009-01-20 17:06:27 +0000675** If a master journal file name is present at the end of the journal
676** file, then it is copied into the buffer pointed to by zMaster. A
677** nul-terminator byte is appended to the buffer following the master
678** journal file name.
679**
680** If it is determined that no master journal file name is present
681** zMaster[0] is set to 0 and SQLITE_OK returned.
682**
683** If an error occurs while reading from the journal file, an SQLite
684** error code is returned.
danielk197776572402004-06-25 02:38:54 +0000685*/
danielk1977d92db532008-11-17 04:56:24 +0000686static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
danielk1977bea2a942009-01-20 17:06:27 +0000687 int rc; /* Return code */
688 u32 len; /* Length in bytes of master journal name */
689 i64 szJ; /* Total size in bytes of journal file pJrnl */
690 u32 cksum; /* MJ checksum value read from journal */
691 u32 u; /* Unsigned loop counter */
692 unsigned char aMagic[8]; /* A buffer to hold the magic header */
danielk197765839c62007-08-30 08:08:17 +0000693 zMaster[0] = '\0';
danielk197776572402004-06-25 02:38:54 +0000694
danielk1977bea2a942009-01-20 17:06:27 +0000695 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
696 || szJ<16
697 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
698 || len>=nMaster
699 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
700 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
701 || memcmp(aMagic, aJournalMagic, 8)
702 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
703 ){
danielk197776572402004-06-25 02:38:54 +0000704 return rc;
705 }
danielk1977cafadba2004-06-25 11:11:54 +0000706
707 /* See if the checksum matches the master journal name */
shane0b8d2762008-07-22 05:18:00 +0000708 for(u=0; u<len; u++){
709 cksum -= zMaster[u];
danielk1977bea2a942009-01-20 17:06:27 +0000710 }
danielk19778191bff2004-06-28 04:52:30 +0000711 if( cksum ){
712 /* If the checksum doesn't add up, then one or more of the disk sectors
713 ** containing the master journal filename is corrupted. This means
714 ** definitely roll back, so just return SQLITE_OK and report a (nul)
715 ** master-journal filename.
716 */
danielk1977bea2a942009-01-20 17:06:27 +0000717 len = 0;
danielk1977cafadba2004-06-25 11:11:54 +0000718 }
danielk1977bea2a942009-01-20 17:06:27 +0000719 zMaster[len] = '\0';
danielk197776572402004-06-25 02:38:54 +0000720
721 return SQLITE_OK;
722}
723
724/*
danielk1977bea2a942009-01-20 17:06:27 +0000725** Return the offset of the sector boundary at or immediately
726** following the value in pPager->journalOff, assuming a sector
727** size of pPager->sectorSize bytes.
danielk197776572402004-06-25 02:38:54 +0000728**
729** i.e for a sector size of 512:
730**
danielk1977bea2a942009-01-20 17:06:27 +0000731** Pager.journalOff Return value
732** ---------------------------------------
733** 0 0
734** 512 512
735** 100 512
736** 2000 2048
danielk197776572402004-06-25 02:38:54 +0000737**
738*/
danielk1977112f7522009-01-08 17:50:45 +0000739static i64 journalHdrOffset(Pager *pPager){
drheb206252004-10-01 02:00:31 +0000740 i64 offset = 0;
741 i64 c = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +0000742 if( c ){
743 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
744 }
745 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
746 assert( offset>=c );
747 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
danielk1977112f7522009-01-08 17:50:45 +0000748 return offset;
749}
danielk197776572402004-06-25 02:38:54 +0000750
751/*
danielk1977bea2a942009-01-20 17:06:27 +0000752** The journal file must be open when this function is called.
753**
754** This function is a no-op if the journal file has not been written to
755** within the current transaction (i.e. if Pager.journalOff==0).
756**
757** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
758** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
759** zero the 28-byte header at the start of the journal file. In either case,
760** if the pager is not in no-sync mode, sync the journal file immediately
761** after writing or truncating it.
762**
763** If Pager.journalSizeLimit is set to a positive, non-zero value, and
764** following the truncation or zeroing described above the size of the
765** journal file in bytes is larger than this value, then truncate the
766** journal file to Pager.journalSizeLimit bytes. The journal file does
767** not need to be synced following this operation.
768**
769** If an IO error occurs, abandon processing and return the IO error code.
770** Otherwise, return SQLITE_OK.
drhf3a87622008-04-17 14:16:42 +0000771*/
danielk1977df2566a2008-05-07 19:11:03 +0000772static int zeroJournalHdr(Pager *pPager, int doTruncate){
danielk1977bea2a942009-01-20 17:06:27 +0000773 int rc = SQLITE_OK; /* Return code */
774 assert( isOpen(pPager->jfd) );
danielk1977df2566a2008-05-07 19:11:03 +0000775 if( pPager->journalOff ){
danielk1977bea2a942009-01-20 17:06:27 +0000776 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
danielk1977b53e4962008-06-04 06:45:59 +0000777
danielk1977df2566a2008-05-07 19:11:03 +0000778 IOTRACE(("JZEROHDR %p\n", pPager))
danielk1977b53e4962008-06-04 06:45:59 +0000779 if( doTruncate || iLimit==0 ){
danielk1977df2566a2008-05-07 19:11:03 +0000780 rc = sqlite3OsTruncate(pPager->jfd, 0);
781 }else{
danielk1977bea2a942009-01-20 17:06:27 +0000782 static const char zeroHdr[28] = {0};
danielk1977df2566a2008-05-07 19:11:03 +0000783 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
784 }
danielk197781620542008-06-07 05:19:37 +0000785 if( rc==SQLITE_OK && !pPager->noSync ){
danielk1977df2566a2008-05-07 19:11:03 +0000786 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->sync_flags);
787 }
danielk1977b53e4962008-06-04 06:45:59 +0000788
789 /* At this point the transaction is committed but the write lock
790 ** is still held on the file. If there is a size limit configured for
791 ** the persistent journal and the journal file currently consumes more
792 ** space than that limit allows for, truncate it now. There is no need
793 ** to sync the file following this operation.
794 */
795 if( rc==SQLITE_OK && iLimit>0 ){
796 i64 sz;
797 rc = sqlite3OsFileSize(pPager->jfd, &sz);
798 if( rc==SQLITE_OK && sz>iLimit ){
799 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
800 }
801 }
drha06ecba2008-04-22 17:15:17 +0000802 }
drhf3a87622008-04-17 14:16:42 +0000803 return rc;
804}
805
806/*
danielk197776572402004-06-25 02:38:54 +0000807** The journal file must be open when this routine is called. A journal
808** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
809** current location.
810**
811** The format for the journal header is as follows:
812** - 8 bytes: Magic identifying journal format.
813** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
814** - 4 bytes: Random number used for page hash.
815** - 4 bytes: Initial database page count.
816** - 4 bytes: Sector size used by the process that wrote this journal.
danielk197767c007b2008-03-20 04:45:49 +0000817** - 4 bytes: Database page size.
danielk197776572402004-06-25 02:38:54 +0000818**
danielk197767c007b2008-03-20 04:45:49 +0000819** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
danielk197776572402004-06-25 02:38:54 +0000820*/
821static int writeJournalHdr(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +0000822 int rc = SQLITE_OK; /* Return code */
823 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
824 u32 nHeader = pPager->pageSize; /* Size of buffer pointed to by zHeader */
825 u32 nWrite; /* Bytes of header sector written */
826 int ii; /* Loop counter */
827
828 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
danielk1977a664f8e2008-04-22 14:31:48 +0000829
830 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
831 nHeader = JOURNAL_HDR_SZ(pPager);
832 }
danielk197776572402004-06-25 02:38:54 +0000833
danielk1977bea2a942009-01-20 17:06:27 +0000834 /* If there are active savepoints and any of them were created
835 ** since the most recent journal header was written, update the
836 ** PagerSavepoint.iHdrOffset fields now.
danielk1977fd7f0452008-12-17 17:30:26 +0000837 */
838 for(ii=0; ii<pPager->nSavepoint; ii++){
839 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
840 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
841 }
danielk19774099f6e2007-03-19 11:25:20 +0000842 }
843
danielk1977bea2a942009-01-20 17:06:27 +0000844 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
danielk19774cd2cd52007-08-23 14:48:23 +0000845
846 /*
847 ** Write the nRec Field - the number of page records that follow this
848 ** journal header. Normally, zero is written to this value at this time.
849 ** After the records are added to the journal (and the journal synced,
850 ** if in full-sync mode), the zero is overwritten with the true number
851 ** of records (see syncJournal()).
852 **
853 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
854 ** reading the journal this value tells SQLite to assume that the
855 ** rest of the journal file contains valid page records. This assumption
shanebe217792009-03-05 04:20:31 +0000856 ** is dangerous, as if a failure occurred whilst writing to the journal
danielk19774cd2cd52007-08-23 14:48:23 +0000857 ** file it may contain some garbage data. There are two scenarios
858 ** where this risk can be ignored:
859 **
860 ** * When the pager is in no-sync mode. Corruption can follow a
861 ** power failure in this case anyway.
862 **
863 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
864 ** that garbage data is never appended to the journal file.
865 */
danielk1977bea2a942009-01-20 17:06:27 +0000866 assert( isOpen(pPager->fd) || pPager->noSync );
danielk1977b3175382008-10-17 18:51:52 +0000867 if( (pPager->noSync) || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
danielk19774cd2cd52007-08-23 14:48:23 +0000868 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
869 ){
danielk19776f4c73e2009-06-26 07:12:06 +0000870 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
danielk19774cd2cd52007-08-23 14:48:23 +0000871 put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
872 }else{
drh5ec53192009-08-31 16:09:58 +0000873 memset(zHeader, 0, sizeof(aJournalMagic)+4);
danielk19774cd2cd52007-08-23 14:48:23 +0000874 }
875
drh97b57482006-01-10 20:32:32 +0000876 /* The random check-hash initialiser */
drh2fa18682008-03-19 14:15:34 +0000877 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
drh97b57482006-01-10 20:32:32 +0000878 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
879 /* The initial database size */
danielk19773460d192008-12-27 15:23:13 +0000880 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
drh97b57482006-01-10 20:32:32 +0000881 /* The assumed sector size for this process */
882 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
drh08609ce2008-11-29 22:49:23 +0000883
danielk1977bea2a942009-01-20 17:06:27 +0000884 /* The page size */
885 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
886
drh08609ce2008-11-29 22:49:23 +0000887 /* Initializing the tail of the buffer is not necessary. Everything
888 ** works find if the following memset() is omitted. But initializing
889 ** the memory prevents valgrind from complaining, so we are willing to
890 ** take the performance hit.
891 */
danielk1977bea2a942009-01-20 17:06:27 +0000892 memset(&zHeader[sizeof(aJournalMagic)+20], 0,
893 nHeader-(sizeof(aJournalMagic)+20));
drh08609ce2008-11-29 22:49:23 +0000894
danielk1977bea2a942009-01-20 17:06:27 +0000895 /* In theory, it is only necessary to write the 28 bytes that the
896 ** journal header consumes to the journal file here. Then increment the
897 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
898 ** record is written to the following sector (leaving a gap in the file
899 ** that will be implicitly filled in by the OS).
900 **
901 ** However it has been discovered that on some systems this pattern can
902 ** be significantly slower than contiguously writing data to the file,
903 ** even if that means explicitly writing data to the block of
904 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
905 ** is done.
906 **
907 ** The loop is required here in case the sector-size is larger than the
908 ** database page size. Since the zHeader buffer is only Pager.pageSize
909 ** bytes in size, more than one call to sqlite3OsWrite() may be required
910 ** to populate the entire journal header sector.
911 */
danielk1977a664f8e2008-04-22 14:31:48 +0000912 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
913 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
914 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
drh91781bd2010-04-10 17:52:57 +0000915 assert( pPager->journalHdr <= pPager->journalOff );
danielk1977a664f8e2008-04-22 14:31:48 +0000916 pPager->journalOff += nHeader;
danielk197776572402004-06-25 02:38:54 +0000917 }
danielk1977a664f8e2008-04-22 14:31:48 +0000918
danielk197776572402004-06-25 02:38:54 +0000919 return rc;
920}
921
922/*
923** The journal file must be open when this is called. A journal header file
924** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
drhd6e5e092009-01-07 02:03:35 +0000925** file. The current location in the journal file is given by
danielk1977bea2a942009-01-20 17:06:27 +0000926** pPager->journalOff. See comments above function writeJournalHdr() for
drhd6e5e092009-01-07 02:03:35 +0000927** a description of the journal header format.
danielk197776572402004-06-25 02:38:54 +0000928**
danielk1977bea2a942009-01-20 17:06:27 +0000929** If the header is read successfully, *pNRec is set to the number of
930** page records following this header and *pDbSize is set to the size of the
danielk197776572402004-06-25 02:38:54 +0000931** database before the transaction began, in pages. Also, pPager->cksumInit
932** is set to the value read from the journal header. SQLITE_OK is returned
933** in this case.
934**
935** If the journal header file appears to be corrupted, SQLITE_DONE is
danielk1977bea2a942009-01-20 17:06:27 +0000936** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
danielk197776572402004-06-25 02:38:54 +0000937** cannot be read from the journal file an error code is returned.
938*/
939static int readJournalHdr(
danielk1977bea2a942009-01-20 17:06:27 +0000940 Pager *pPager, /* Pager object */
danielk19776f4c73e2009-06-26 07:12:06 +0000941 int isHot,
danielk1977bea2a942009-01-20 17:06:27 +0000942 i64 journalSize, /* Size of the open journal file in bytes */
943 u32 *pNRec, /* OUT: Value read from the nRec field */
944 u32 *pDbSize /* OUT: Value of original database size field */
danielk197776572402004-06-25 02:38:54 +0000945){
danielk1977bea2a942009-01-20 17:06:27 +0000946 int rc; /* Return code */
947 unsigned char aMagic[8]; /* A buffer to hold the magic header */
948 i64 iHdrOff; /* Offset of journal header being read */
danielk197776572402004-06-25 02:38:54 +0000949
danielk1977bea2a942009-01-20 17:06:27 +0000950 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
951
952 /* Advance Pager.journalOff to the start of the next sector. If the
953 ** journal file is too small for there to be a header stored at this
954 ** point, return SQLITE_DONE.
955 */
956 pPager->journalOff = journalHdrOffset(pPager);
danielk197776572402004-06-25 02:38:54 +0000957 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
958 return SQLITE_DONE;
959 }
danielk1977bea2a942009-01-20 17:06:27 +0000960 iHdrOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +0000961
danielk1977bea2a942009-01-20 17:06:27 +0000962 /* Read in the first 8 bytes of the journal header. If they do not match
963 ** the magic string found at the start of each journal header, return
964 ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
965 ** proceed.
966 */
danielk19776f4c73e2009-06-26 07:12:06 +0000967 if( isHot || iHdrOff!=pPager->journalHdr ){
968 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
969 if( rc ){
970 return rc;
971 }
972 if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
973 return SQLITE_DONE;
974 }
danielk197776572402004-06-25 02:38:54 +0000975 }
976
danielk1977bea2a942009-01-20 17:06:27 +0000977 /* Read the first three 32-bit fields of the journal header: The nRec
978 ** field, the checksum-initializer and the database size at the start
979 ** of the transaction. Return an error code if anything goes wrong.
980 */
981 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
982 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
983 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
984 ){
985 return rc;
986 }
danielk197776572402004-06-25 02:38:54 +0000987
danielk19777cbd5892009-01-10 16:15:09 +0000988 if( pPager->journalOff==0 ){
danielk1977bea2a942009-01-20 17:06:27 +0000989 u32 iPageSize; /* Page-size field of journal header */
990 u32 iSectorSize; /* Sector-size field of journal header */
991 u16 iPageSize16; /* Copy of iPageSize in 16-bit variable */
danielk197767c007b2008-03-20 04:45:49 +0000992
danielk1977bea2a942009-01-20 17:06:27 +0000993 /* Read the page-size and sector-size journal header fields. */
994 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
995 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
danielk19777cbd5892009-01-10 16:15:09 +0000996 ){
danielk1977bea2a942009-01-20 17:06:27 +0000997 return rc;
danielk1977443c0592009-01-16 15:21:05 +0000998 }
danielk1977bea2a942009-01-20 17:06:27 +0000999
1000 /* Check that the values read from the page-size and sector-size fields
1001 ** are within range. To be 'in range', both values need to be a power
drh3c99d682009-11-11 13:17:08 +00001002 ** of two greater than or equal to 512 or 32, and not greater than their
danielk1977bea2a942009-01-20 17:06:27 +00001003 ** respective compile time maximum limits.
1004 */
drh3c99d682009-11-11 13:17:08 +00001005 if( iPageSize<512 || iSectorSize<32
danielk1977bea2a942009-01-20 17:06:27 +00001006 || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
1007 || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
1008 ){
1009 /* If the either the page-size or sector-size in the journal-header is
1010 ** invalid, then the process that wrote the journal-header must have
1011 ** crashed before the header was synced. In this case stop reading
1012 ** the journal file here.
1013 */
1014 return SQLITE_DONE;
1015 }
1016
1017 /* Update the page-size to match the value read from the journal.
1018 ** Use a testcase() macro to make sure that malloc failure within
1019 ** PagerSetPagesize() is tested.
1020 */
1021 iPageSize16 = (u16)iPageSize;
drhfa9601a2009-06-18 17:22:39 +00001022 rc = sqlite3PagerSetPagesize(pPager, &iPageSize16, -1);
danielk1977bea2a942009-01-20 17:06:27 +00001023 testcase( rc!=SQLITE_OK );
1024 assert( rc!=SQLITE_OK || iPageSize16==(u16)iPageSize );
1025
danielk19777cbd5892009-01-10 16:15:09 +00001026 /* Update the assumed sector-size to match the value used by
1027 ** the process that created this journal. If this journal was
1028 ** created by a process other than this one, then this routine
1029 ** is being called from within pager_playback(). The local value
1030 ** of Pager.sectorSize is restored at the end of that routine.
1031 */
danielk19777cbd5892009-01-10 16:15:09 +00001032 pPager->sectorSize = iSectorSize;
drh98c58352008-11-07 00:24:53 +00001033 }
danielk197776572402004-06-25 02:38:54 +00001034
1035 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00001036 return rc;
danielk197776572402004-06-25 02:38:54 +00001037}
1038
1039
1040/*
1041** Write the supplied master journal name into the journal file for pager
danielk1977cafadba2004-06-25 11:11:54 +00001042** pPager at the current location. The master journal name must be the last
1043** thing written to a journal file. If the pager is in full-sync mode, the
1044** journal file descriptor is advanced to the next sector boundary before
1045** anything is written. The format is:
1046**
danielk1977bea2a942009-01-20 17:06:27 +00001047** + 4 bytes: PAGER_MJ_PGNO.
1048** + N bytes: Master journal filename in utf-8.
1049** + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
1050** + 4 bytes: Master journal name checksum.
1051** + 8 bytes: aJournalMagic[].
danielk1977cafadba2004-06-25 11:11:54 +00001052**
1053** The master journal page checksum is the sum of the bytes in the master
danielk1977bea2a942009-01-20 17:06:27 +00001054** journal name, where each byte is interpreted as a signed 8-bit integer.
danielk1977aef0bf62005-12-30 16:28:01 +00001055**
1056** If zMaster is a NULL pointer (occurs for a single database transaction),
1057** this call is a no-op.
danielk197776572402004-06-25 02:38:54 +00001058*/
1059static int writeMasterJournal(Pager *pPager, const char *zMaster){
danielk1977bea2a942009-01-20 17:06:27 +00001060 int rc; /* Return code */
1061 int nMaster; /* Length of string zMaster */
1062 i64 iHdrOff; /* Offset of header in journal file */
1063 i64 jrnlSize; /* Size of journal file on disk */
1064 u32 cksum = 0; /* Checksum of string zMaster */
danielk197776572402004-06-25 02:38:54 +00001065
danielk1977bea2a942009-01-20 17:06:27 +00001066 if( !zMaster || pPager->setMaster
1067 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
1068 || pPager->journalMode==PAGER_JOURNALMODE_OFF
1069 ){
1070 return SQLITE_OK;
1071 }
danielk197776572402004-06-25 02:38:54 +00001072 pPager->setMaster = 1;
danielk1977bea2a942009-01-20 17:06:27 +00001073 assert( isOpen(pPager->jfd) );
drh91781bd2010-04-10 17:52:57 +00001074 assert( pPager->journalHdr <= pPager->journalOff );
danielk197776572402004-06-25 02:38:54 +00001075
danielk1977bea2a942009-01-20 17:06:27 +00001076 /* Calculate the length in bytes and the checksum of zMaster */
1077 for(nMaster=0; zMaster[nMaster]; nMaster++){
1078 cksum += zMaster[nMaster];
danielk1977cafadba2004-06-25 11:11:54 +00001079 }
danielk197776572402004-06-25 02:38:54 +00001080
1081 /* If in full-sync mode, advance to the next disk sector before writing
1082 ** the master journal name. This is in case the previous page written to
1083 ** the journal has already been synced.
1084 */
1085 if( pPager->fullSync ){
danielk1977bea2a942009-01-20 17:06:27 +00001086 pPager->journalOff = journalHdrOffset(pPager);
danielk197776572402004-06-25 02:38:54 +00001087 }
danielk1977bea2a942009-01-20 17:06:27 +00001088 iHdrOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001089
danielk1977bea2a942009-01-20 17:06:27 +00001090 /* Write the master journal data to the end of the journal file. If
1091 ** an error occurs, return the error code to the caller.
1092 */
shane63207ab2009-02-04 01:49:30 +00001093 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
1094 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
1095 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
1096 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
1097 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, iHdrOff+4+nMaster+8)))
danielk1977bea2a942009-01-20 17:06:27 +00001098 ){
1099 return rc;
1100 }
1101 pPager->journalOff += (nMaster+20);
drh2c8997b2005-08-27 16:36:48 +00001102 pPager->needSync = !pPager->noSync;
danielk1977df2566a2008-05-07 19:11:03 +00001103
1104 /* If the pager is in peristent-journal mode, then the physical
1105 ** journal-file may extend past the end of the master-journal name
1106 ** and 8 bytes of magic data just written to the file. This is
1107 ** dangerous because the code to rollback a hot-journal file
1108 ** will not be able to find the master-journal name to determine
1109 ** whether or not the journal is hot.
1110 **
1111 ** Easiest thing to do in this scenario is to truncate the journal
1112 ** file to the required size.
1113 */
danielk1977bea2a942009-01-20 17:06:27 +00001114 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
1115 && jrnlSize>pPager->journalOff
danielk1977df2566a2008-05-07 19:11:03 +00001116 ){
danielk1977bea2a942009-01-20 17:06:27 +00001117 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
danielk1977df2566a2008-05-07 19:11:03 +00001118 }
danielk197776572402004-06-25 02:38:54 +00001119 return rc;
1120}
1121
1122/*
danielk1977bea2a942009-01-20 17:06:27 +00001123** Find a page in the hash table given its page number. Return
1124** a pointer to the page or NULL if the requested page is not
1125** already in memory.
drhed7c8552001-04-11 14:29:21 +00001126*/
drhd9b02572001-04-15 00:37:09 +00001127static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
danielk1977bea2a942009-01-20 17:06:27 +00001128 PgHdr *p; /* Return value */
1129
1130 /* It is not possible for a call to PcacheFetch() with createFlag==0 to
1131 ** fail, since no attempt to allocate dynamic memory will be made.
1132 */
1133 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
drhed7c8552001-04-11 14:29:21 +00001134 return p;
1135}
1136
1137/*
danielk1977bea2a942009-01-20 17:06:27 +00001138** Unless the pager is in error-state, discard all in-memory pages. If
1139** the pager is in error-state, then this call is a no-op.
danielk197704103022009-02-03 16:51:24 +00001140**
1141** TODO: Why can we not reset the pager while in error state?
drhed7c8552001-04-11 14:29:21 +00001142*/
drhd9b02572001-04-15 00:37:09 +00001143static void pager_reset(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00001144 if( SQLITE_OK==pPager->errCode ){
danielk197704103022009-02-03 16:51:24 +00001145 sqlite3BackupRestart(pPager->pBackup);
danielk1977bea2a942009-01-20 17:06:27 +00001146 sqlite3PcacheClear(pPager->pPCache);
drh59813952009-04-20 11:34:26 +00001147 pPager->dbSizeValid = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001148 }
danielk1977e277be02007-03-23 18:12:06 +00001149}
1150
danielk197734cf35d2008-12-18 18:31:38 +00001151/*
1152** Free all structures in the Pager.aSavepoint[] array and set both
1153** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
1154** if it is open and the pager is not in exclusive mode.
1155*/
danielk1977bea2a942009-01-20 17:06:27 +00001156static void releaseAllSavepoints(Pager *pPager){
1157 int ii; /* Iterator for looping through Pager.aSavepoint */
danielk1977fd7f0452008-12-17 17:30:26 +00001158 for(ii=0; ii<pPager->nSavepoint; ii++){
1159 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
1160 }
danielk1977f9d1a212009-04-30 16:41:00 +00001161 if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){
danielk1977fd7f0452008-12-17 17:30:26 +00001162 sqlite3OsClose(pPager->sjfd);
1163 }
1164 sqlite3_free(pPager->aSavepoint);
1165 pPager->aSavepoint = 0;
1166 pPager->nSavepoint = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001167 pPager->nSubRec = 0;
danielk1977fd7f0452008-12-17 17:30:26 +00001168}
1169
danielk197734cf35d2008-12-18 18:31:38 +00001170/*
danielk1977bea2a942009-01-20 17:06:27 +00001171** Set the bit number pgno in the PagerSavepoint.pInSavepoint
1172** bitvecs of all open savepoints. Return SQLITE_OK if successful
1173** or SQLITE_NOMEM if a malloc failure occurs.
danielk197734cf35d2008-12-18 18:31:38 +00001174*/
danielk1977fd7f0452008-12-17 17:30:26 +00001175static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
drh7539b6b2009-01-02 21:39:39 +00001176 int ii; /* Loop counter */
1177 int rc = SQLITE_OK; /* Result code */
1178
danielk1977fd7f0452008-12-17 17:30:26 +00001179 for(ii=0; ii<pPager->nSavepoint; ii++){
1180 PagerSavepoint *p = &pPager->aSavepoint[ii];
1181 if( pgno<=p->nOrig ){
drh7539b6b2009-01-02 21:39:39 +00001182 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
danielk1977bea2a942009-01-20 17:06:27 +00001183 testcase( rc==SQLITE_NOMEM );
drh7539b6b2009-01-02 21:39:39 +00001184 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
danielk1977fd7f0452008-12-17 17:30:26 +00001185 }
1186 }
drh7539b6b2009-01-02 21:39:39 +00001187 return rc;
danielk1977fd7f0452008-12-17 17:30:26 +00001188}
1189
danielk1977e277be02007-03-23 18:12:06 +00001190/*
dan7c246102010-04-12 19:00:29 +00001191** Return true if this pager uses a write-ahead log instead of the usual
1192** rollback journal. Otherwise false.
1193*/
1194static int pagerUseLog(Pager *pPager){
1195 return (pPager->pLog!=0);
1196}
1197
1198/*
danielk1977bea2a942009-01-20 17:06:27 +00001199** Unlock the database file. This function is a no-op if the pager
1200** is in exclusive mode.
danielk1977ae72d982007-10-03 08:46:44 +00001201**
1202** If the pager is currently in error state, discard the contents of
1203** the cache and reset the Pager structure internal state. If there is
1204** an open journal-file, then the next time a shared-lock is obtained
1205** on the pager file (by this or any other process), it will be
1206** treated as a hot-journal and rolled back.
1207*/
1208static void pager_unlock(Pager *pPager){
1209 if( !pPager->exclusiveMode ){
dan7c246102010-04-12 19:00:29 +00001210 int rc = SQLITE_OK; /* Return code */
danielk1977ae72d982007-10-03 08:46:44 +00001211
danielk1977b3175382008-10-17 18:51:52 +00001212 /* Always close the journal file when dropping the database lock.
1213 ** Otherwise, another connection with journal_mode=delete might
1214 ** delete the file out from under us.
1215 */
danielk1977bea2a942009-01-20 17:06:27 +00001216 sqlite3OsClose(pPager->jfd);
1217 sqlite3BitvecDestroy(pPager->pInJournal);
1218 pPager->pInJournal = 0;
1219 releaseAllSavepoints(pPager);
1220
1221 /* If the file is unlocked, somebody else might change it. The
1222 ** values stored in Pager.dbSize etc. might become invalid if
drhb1299152010-03-30 22:58:33 +00001223 ** this happens. One can argue that this doesn't need to be cleared
danielk197789bc4bc2009-07-21 19:25:24 +00001224 ** until the change-counter check fails in PagerSharedLock().
drhb1299152010-03-30 22:58:33 +00001225 ** Clearing the page size cache here is being conservative.
danielk1977bea2a942009-01-20 17:06:27 +00001226 */
1227 pPager->dbSizeValid = 0;
danielk1977ae72d982007-10-03 08:46:44 +00001228
dan7c246102010-04-12 19:00:29 +00001229 if( pagerUseLog(pPager) ){
1230 sqlite3LogCloseSnapshot(pPager->pLog);
dan3de777f2010-04-17 12:31:37 +00001231 }else{
1232 rc = osUnlock(pPager->fd, NO_LOCK);
dan7c246102010-04-12 19:00:29 +00001233 }
danielk1977bea2a942009-01-20 17:06:27 +00001234 if( rc ){
1235 pPager->errCode = rc;
1236 }
danielk19775f2d46b2009-01-13 16:03:44 +00001237 IOTRACE(("UNLOCK %p\n", pPager))
1238
danielk1977b3175382008-10-17 18:51:52 +00001239 /* If Pager.errCode is set, the contents of the pager cache cannot be
1240 ** trusted. Now that the pager file is unlocked, the contents of the
1241 ** cache can be discarded and the error code safely cleared.
1242 */
1243 if( pPager->errCode ){
danielk1977bea2a942009-01-20 17:06:27 +00001244 if( rc==SQLITE_OK ){
1245 pPager->errCode = SQLITE_OK;
1246 }
danielk1977b3175382008-10-17 18:51:52 +00001247 pager_reset(pPager);
danielk1977ae72d982007-10-03 08:46:44 +00001248 }
danielk1977b3175382008-10-17 18:51:52 +00001249
danielk197745d68822009-01-16 16:23:38 +00001250 pPager->changeCountDone = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001251 pPager->state = PAGER_UNLOCK;
danbc7c0392009-12-02 14:44:32 +00001252 pPager->dbModified = 0;
danielk1977ae72d982007-10-03 08:46:44 +00001253 }
1254}
1255
1256/*
danielk1977bea2a942009-01-20 17:06:27 +00001257** This function should be called when an IOERR, CORRUPT or FULL error
shanebe217792009-03-05 04:20:31 +00001258** may have occurred. The first argument is a pointer to the pager
danielk1977bea2a942009-01-20 17:06:27 +00001259** structure, the second the error-code about to be returned by a pager
1260** API function. The value returned is a copy of the second argument
1261** to this function.
1262**
1263** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL
1264** the error becomes persistent. Until the persisten error is cleared,
1265** subsequent API calls on this Pager will immediately return the same
1266** error code.
1267**
1268** A persistent error indicates that the contents of the pager-cache
1269** cannot be trusted. This state can be cleared by completely discarding
1270** the contents of the pager-cache. If a transaction was active when
shanebe217792009-03-05 04:20:31 +00001271** the persistent error occurred, then the rollback journal may need
danielk1977bea2a942009-01-20 17:06:27 +00001272** to be replayed to restore the contents of the database file (as if
1273** it were a hot-journal).
1274*/
1275static int pager_error(Pager *pPager, int rc){
1276 int rc2 = rc & 0xff;
danielk1977c7ca8752009-07-25 17:39:13 +00001277 assert( rc==SQLITE_OK || !MEMDB );
danielk1977bea2a942009-01-20 17:06:27 +00001278 assert(
1279 pPager->errCode==SQLITE_FULL ||
1280 pPager->errCode==SQLITE_OK ||
1281 (pPager->errCode & 0xff)==SQLITE_IOERR
1282 );
drhb75d5702009-07-25 17:08:35 +00001283 if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){
danielk1977bea2a942009-01-20 17:06:27 +00001284 pPager->errCode = rc;
danielk1977bea2a942009-01-20 17:06:27 +00001285 }
1286 return rc;
1287}
1288
1289/*
danielk1977ae72d982007-10-03 08:46:44 +00001290** Execute a rollback if a transaction is active and unlock the
danielk1977bea2a942009-01-20 17:06:27 +00001291** database file.
1292**
1293** If the pager has already entered the error state, do not attempt
1294** the rollback at this time. Instead, pager_unlock() is called. The
1295** call to pager_unlock() will discard all in-memory pages, unlock
1296** the database file and clear the error state. If this means that
1297** there is a hot-journal left in the file-system, the next connection
1298** to obtain a shared lock on the pager (which may be this one) will
1299** roll it back.
1300**
1301** If the pager has not already entered the error state, but an IO or
1302** malloc error occurs during a rollback, then this will itself cause
1303** the pager to enter the error state. Which will be cleared by the
1304** call to pager_unlock(), as described above.
danielk1977ae72d982007-10-03 08:46:44 +00001305*/
danielk1977bea2a942009-01-20 17:06:27 +00001306static void pagerUnlockAndRollback(Pager *pPager){
1307 if( pPager->errCode==SQLITE_OK && pPager->state>=PAGER_RESERVED ){
danielk19772d1d86f2008-06-20 14:59:51 +00001308 sqlite3BeginBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00001309 sqlite3PagerRollback(pPager);
danielk19772d1d86f2008-06-20 14:59:51 +00001310 sqlite3EndBenignMalloc();
danielk1977ae72d982007-10-03 08:46:44 +00001311 }
danielk1977bea2a942009-01-20 17:06:27 +00001312 pager_unlock(pPager);
danielk1977ae72d982007-10-03 08:46:44 +00001313}
1314
1315/*
danielk1977bea2a942009-01-20 17:06:27 +00001316** This routine ends a transaction. A transaction is usually ended by
1317** either a COMMIT or a ROLLBACK operation. This routine may be called
1318** after rollback of a hot-journal, or if an error occurs while opening
1319** the journal file or writing the very first journal-header of a
1320** database transaction.
1321**
1322** If the pager is in PAGER_SHARED or PAGER_UNLOCK state when this
1323** routine is called, it is a no-op (returns SQLITE_OK).
drh80e35f42007-03-30 14:06:34 +00001324**
danielk1977bea2a942009-01-20 17:06:27 +00001325** Otherwise, any active savepoints are released.
drh80e35f42007-03-30 14:06:34 +00001326**
danielk1977bea2a942009-01-20 17:06:27 +00001327** If the journal file is open, then it is "finalized". Once a journal
1328** file has been finalized it is not possible to use it to roll back a
1329** transaction. Nor will it be considered to be a hot-journal by this
1330** or any other database connection. Exactly how a journal is finalized
1331** depends on whether or not the pager is running in exclusive mode and
1332** the current journal-mode (Pager.journalMode value), as follows:
drh50457892003-09-06 01:10:47 +00001333**
danielk1977bea2a942009-01-20 17:06:27 +00001334** journalMode==MEMORY
1335** Journal file descriptor is simply closed. This destroys an
1336** in-memory journal.
1337**
1338** journalMode==TRUNCATE
1339** Journal file is truncated to zero bytes in size.
1340**
1341** journalMode==PERSIST
1342** The first 28 bytes of the journal file are zeroed. This invalidates
1343** the first journal header in the file, and hence the entire journal
1344** file. An invalid journal file cannot be rolled back.
1345**
1346** journalMode==DELETE
1347** The journal file is closed and deleted using sqlite3OsDelete().
1348**
1349** If the pager is running in exclusive mode, this method of finalizing
1350** the journal file is never used. Instead, if the journalMode is
1351** DELETE and the pager is in exclusive mode, the method described under
1352** journalMode==PERSIST is used instead.
1353**
1354** After the journal is finalized, if running in non-exclusive mode, the
1355** pager moves to PAGER_SHARED state (and downgrades the lock on the
1356** database file accordingly).
1357**
1358** If the pager is running in exclusive mode and is in PAGER_SYNCED state,
1359** it moves to PAGER_EXCLUSIVE. No locks are downgraded when running in
1360** exclusive mode.
1361**
1362** SQLITE_OK is returned if no error occurs. If an error occurs during
1363** any of the IO operations to finalize the journal file or unlock the
1364** database then the IO error code is returned to the user. If the
1365** operation to finalize the journal file fails, then the code still
1366** tries to unlock the database file if not in exclusive mode. If the
1367** unlock operation fails as well, then the first error code related
1368** to the first error encountered (the journal finalization one) is
1369** returned.
drhed7c8552001-04-11 14:29:21 +00001370*/
danielk1977df2566a2008-05-07 19:11:03 +00001371static int pager_end_transaction(Pager *pPager, int hasMaster){
danielk1977bea2a942009-01-20 17:06:27 +00001372 int rc = SQLITE_OK; /* Error code from journal finalization operation */
1373 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
1374
drha6abd042004-06-09 17:37:22 +00001375 if( pPager->state<PAGER_RESERVED ){
1376 return SQLITE_OK;
1377 }
danielk1977bea2a942009-01-20 17:06:27 +00001378 releaseAllSavepoints(pPager);
1379
1380 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
1381 if( isOpen(pPager->jfd) ){
dan7c246102010-04-12 19:00:29 +00001382 assert( !pagerUseLog(pPager) );
danielk1977bea2a942009-01-20 17:06:27 +00001383
danielk1977bea2a942009-01-20 17:06:27 +00001384 /* Finalize the journal file. */
danielk1977ded6d0f2009-07-27 14:15:44 +00001385 if( sqlite3IsMemJournal(pPager->jfd) ){
1386 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
danielk1977b3175382008-10-17 18:51:52 +00001387 sqlite3OsClose(pPager->jfd);
drh9e7ba7c2009-02-04 19:16:23 +00001388 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
drh59813952009-04-20 11:34:26 +00001389 if( pPager->journalOff==0 ){
1390 rc = SQLITE_OK;
1391 }else{
1392 rc = sqlite3OsTruncate(pPager->jfd, 0);
1393 }
drh04335882008-09-26 21:08:08 +00001394 pPager->journalOff = 0;
1395 pPager->journalStarted = 0;
1396 }else if( pPager->exclusiveMode
danielk197793f7af92008-05-09 16:57:50 +00001397 || pPager->journalMode==PAGER_JOURNALMODE_PERSIST
1398 ){
1399 rc = zeroJournalHdr(pPager, hasMaster);
1400 pager_error(pPager, rc);
danielk197741483462007-03-24 16:45:04 +00001401 pPager->journalOff = 0;
danielk1977334cdb62007-03-26 08:05:12 +00001402 pPager->journalStarted = 0;
danielk197741483462007-03-24 16:45:04 +00001403 }else{
danielk1977ded6d0f2009-07-27 14:15:44 +00001404 /* This branch may be executed with Pager.journalMode==MEMORY if
1405 ** a hot-journal was just rolled back. In this case the journal
1406 ** file should be closed and deleted. If this connection writes to
dane04dc882010-04-20 18:53:15 +00001407 ** the database file, it will do so using an in-memory journal.
1408 */
danielk1977ded6d0f2009-07-27 14:15:44 +00001409 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
1410 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
dane04dc882010-04-20 18:53:15 +00001411 || pPager->journalMode==PAGER_JOURNALMODE_WAL
danielk1977ded6d0f2009-07-27 14:15:44 +00001412 );
danielk1977b4b47412007-08-17 15:53:36 +00001413 sqlite3OsClose(pPager->jfd);
drh4775ecd2009-07-24 19:01:19 +00001414 if( !pPager->tempFile ){
danielk1977fee2d252007-08-18 10:59:19 +00001415 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
danielk19777152de82007-03-29 17:28:14 +00001416 }
danielk197741483462007-03-24 16:45:04 +00001417 }
danielk1977bea2a942009-01-20 17:06:27 +00001418
danielk19773c407372005-02-15 02:54:14 +00001419#ifdef SQLITE_CHECK_PAGES
danielk1977bc2ca9e2008-11-13 14:28:28 +00001420 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
danielk19773c407372005-02-15 02:54:14 +00001421#endif
drhd9b02572001-04-15 00:37:09 +00001422 }
drhe9c2d342010-03-19 16:52:53 +00001423 sqlite3BitvecDestroy(pPager->pInJournal);
1424 pPager->pInJournal = 0;
1425 pPager->nRec = 0;
drhba726f42010-03-19 15:48:13 +00001426 sqlite3PcacheCleanAll(pPager->pPCache);
danielk1977979f38e2007-03-27 16:19:51 +00001427
dan7c246102010-04-12 19:00:29 +00001428 if( pagerUseLog(pPager) ){
1429 rc2 = sqlite3LogWriteLock(pPager->pLog, 0);
1430 pPager->state = PAGER_SHARED;
1431 }else if( !pPager->exclusiveMode ){
danielk19777a2b1ee2007-08-21 14:27:01 +00001432 rc2 = osUnlock(pPager->fd, SHARED_LOCK);
danielk197741483462007-03-24 16:45:04 +00001433 pPager->state = PAGER_SHARED;
danielk1977104f1fe2009-01-14 17:45:57 +00001434 pPager->changeCountDone = 0;
danielk1977334cdb62007-03-26 08:05:12 +00001435 }else if( pPager->state==PAGER_SYNCED ){
1436 pPager->state = PAGER_EXCLUSIVE;
danielk197741483462007-03-24 16:45:04 +00001437 }
danielk197776572402004-06-25 02:38:54 +00001438 pPager->setMaster = 0;
danielk1977c4da5b92006-01-21 12:08:54 +00001439 pPager->needSync = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001440 pPager->dbModified = 0;
1441
1442 /* TODO: Is this optimal? Why is the db size invalidated here
1443 ** when the database file is not unlocked? */
1444 pPager->dbOrigSize = 0;
danielk1977f90b7262009-01-07 15:18:20 +00001445 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
danielk1977b3175382008-10-17 18:51:52 +00001446 if( !MEMDB ){
danielk1977d92db532008-11-17 04:56:24 +00001447 pPager->dbSizeValid = 0;
danielk1977b3175382008-10-17 18:51:52 +00001448 }
danielk1977979f38e2007-03-27 16:19:51 +00001449
1450 return (rc==SQLITE_OK?rc2:rc);
drhed7c8552001-04-11 14:29:21 +00001451}
1452
drhed7c8552001-04-11 14:29:21 +00001453/*
danielk1977bea2a942009-01-20 17:06:27 +00001454** Parameter aData must point to a buffer of pPager->pageSize bytes
1455** of data. Compute and return a checksum based ont the contents of the
1456** page of data and the current value of pPager->cksumInit.
drh34e79ce2004-02-08 06:05:46 +00001457**
danielk1977bea2a942009-01-20 17:06:27 +00001458** This is not a real checksum. It is really just the sum of the
1459** random initial value (pPager->cksumInit) and every 200th byte
1460** of the page data, starting with byte offset (pPager->pageSize%200).
1461** Each byte is interpreted as an 8-bit unsigned integer.
drh726de592004-06-10 23:35:50 +00001462**
danielk1977bea2a942009-01-20 17:06:27 +00001463** Changing the formula used to compute this checksum results in an
1464** incompatible journal file format.
1465**
1466** If journal corruption occurs due to a power failure, the most likely
1467** scenario is that one end or the other of the record will be changed.
1468** It is much less likely that the two ends of the journal record will be
drh726de592004-06-10 23:35:50 +00001469** correct and the middle be corrupt. Thus, this "checksum" scheme,
1470** though fast and simple, catches the mostly likely kind of corruption.
drh968af522003-02-11 14:55:40 +00001471*/
drh74161702006-02-24 02:53:49 +00001472static u32 pager_cksum(Pager *pPager, const u8 *aData){
danielk1977bea2a942009-01-20 17:06:27 +00001473 u32 cksum = pPager->cksumInit; /* Checksum value to return */
1474 int i = pPager->pageSize-200; /* Loop counter */
danielk1977ef317ab2004-06-23 10:43:10 +00001475 while( i>0 ){
1476 cksum += aData[i];
1477 i -= 200;
1478 }
drh968af522003-02-11 14:55:40 +00001479 return cksum;
1480}
1481
1482/*
drhd6e5e092009-01-07 02:03:35 +00001483** Read a single page from either the journal file (if isMainJrnl==1) or
1484** from the sub-journal (if isMainJrnl==0) and playback that page.
danielk1977bea2a942009-01-20 17:06:27 +00001485** The page begins at offset *pOffset into the file. The *pOffset
drhd6e5e092009-01-07 02:03:35 +00001486** value is increased to the start of the next page in the journal.
drh968af522003-02-11 14:55:40 +00001487**
drhc13148f2008-08-27 18:03:20 +00001488** The isMainJrnl flag is true if this is the main rollback journal and
1489** false for the statement journal. The main rollback journal uses
1490** checksums - the statement journal does not.
drhd6e5e092009-01-07 02:03:35 +00001491**
danielk1977bea2a942009-01-20 17:06:27 +00001492** If the page number of the page record read from the (sub-)journal file
1493** is greater than the current value of Pager.dbSize, then playback is
1494** skipped and SQLITE_OK is returned.
1495**
drhd6e5e092009-01-07 02:03:35 +00001496** If pDone is not NULL, then it is a record of pages that have already
1497** been played back. If the page at *pOffset has already been played back
1498** (if the corresponding pDone bit is set) then skip the playback.
1499** Make sure the pDone bit corresponding to the *pOffset page is set
1500** prior to returning.
danielk1977bea2a942009-01-20 17:06:27 +00001501**
1502** If the page record is successfully read from the (sub-)journal file
1503** and played back, then SQLITE_OK is returned. If an IO error occurs
1504** while reading the record from the (sub-)journal file or while writing
1505** to the database file, then the IO error code is returned. If data
1506** is successfully read from the (sub-)journal file but appears to be
1507** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
1508** two circumstances:
1509**
1510** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
1511** * If the record is being rolled back from the main journal file
1512** and the checksum field does not match the record content.
1513**
1514** Neither of these two scenarios are possible during a savepoint rollback.
1515**
1516** If this is a savepoint rollback, then memory may have to be dynamically
1517** allocated by this function. If this is the case and an allocation fails,
1518** SQLITE_NOMEM is returned.
drhfa86c412002-02-02 15:01:15 +00001519*/
danielk197762079062007-08-15 17:08:46 +00001520static int pager_playback_one_page(
danielk1977fd7f0452008-12-17 17:30:26 +00001521 Pager *pPager, /* The pager being played back */
drhd6e5e092009-01-07 02:03:35 +00001522 i64 *pOffset, /* Offset of record to playback */
drh91781bd2010-04-10 17:52:57 +00001523 Bitvec *pDone, /* Bitvec of pages already played back */
1524 int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
1525 int isSavepnt /* True for a savepoint rollback */
danielk197762079062007-08-15 17:08:46 +00001526){
drhfa86c412002-02-02 15:01:15 +00001527 int rc;
drhae2b40c2004-06-09 19:03:54 +00001528 PgHdr *pPg; /* An existing page in the cache */
1529 Pgno pgno; /* The page number of a page in journal */
1530 u32 cksum; /* Checksum used for sanity checking */
drhbfcb4ad2009-11-21 01:33:50 +00001531 char *aData; /* Temporary storage for the page */
drhd6e5e092009-01-07 02:03:35 +00001532 sqlite3_file *jfd; /* The file descriptor for the journal file */
drh91781bd2010-04-10 17:52:57 +00001533 int isSynced; /* True if journal page is synced */
drhfa86c412002-02-02 15:01:15 +00001534
drhd6e5e092009-01-07 02:03:35 +00001535 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
1536 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
1537 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
1538 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
drh96362842005-03-20 22:47:56 +00001539
drhbfcb4ad2009-11-21 01:33:50 +00001540 aData = pPager->pTmpSpace;
drhd6e5e092009-01-07 02:03:35 +00001541 assert( aData ); /* Temp storage must have already been allocated */
1542
danielk1977bea2a942009-01-20 17:06:27 +00001543 /* Read the page number and page data from the journal or sub-journal
1544 ** file. Return an error code to the caller if an IO error occurs.
1545 */
drhd6e5e092009-01-07 02:03:35 +00001546 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
drhd6e5e092009-01-07 02:03:35 +00001547 rc = read32bits(jfd, *pOffset, &pgno);
drh99ee3602003-02-16 19:13:36 +00001548 if( rc!=SQLITE_OK ) return rc;
drhbfcb4ad2009-11-21 01:33:50 +00001549 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
drh99ee3602003-02-16 19:13:36 +00001550 if( rc!=SQLITE_OK ) return rc;
drhd6e5e092009-01-07 02:03:35 +00001551 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
drhfa86c412002-02-02 15:01:15 +00001552
drh968af522003-02-11 14:55:40 +00001553 /* Sanity checking on the page. This is more important that I originally
1554 ** thought. If a power failure occurs while the journal is being written,
1555 ** it could cause invalid data to be written into the journal. We need to
1556 ** detect this invalid data (with high probability) and ignore it.
1557 */
danielk197775edc162004-06-26 01:48:18 +00001558 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
danielk1977bea2a942009-01-20 17:06:27 +00001559 assert( !isSavepnt );
drh968af522003-02-11 14:55:40 +00001560 return SQLITE_DONE;
1561 }
danielk1977fd7f0452008-12-17 17:30:26 +00001562 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
drh968af522003-02-11 14:55:40 +00001563 return SQLITE_OK;
1564 }
drhc13148f2008-08-27 18:03:20 +00001565 if( isMainJrnl ){
drhd6e5e092009-01-07 02:03:35 +00001566 rc = read32bits(jfd, (*pOffset)-4, &cksum);
drh99ee3602003-02-16 19:13:36 +00001567 if( rc ) return rc;
drhbfcb4ad2009-11-21 01:33:50 +00001568 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
drh968af522003-02-11 14:55:40 +00001569 return SQLITE_DONE;
1570 }
1571 }
danielk1977bea2a942009-01-20 17:06:27 +00001572
danielk1977859546c2009-01-22 17:12:39 +00001573 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
danielk1977fd7f0452008-12-17 17:30:26 +00001574 return rc;
1575 }
drhfa86c412002-02-02 15:01:15 +00001576
danielk1977aa5ccdf2004-06-14 05:10:42 +00001577 assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );
danielk1977a3f3a5f2004-06-10 04:32:16 +00001578
1579 /* If the pager is in RESERVED state, then there must be a copy of this
1580 ** page in the pager cache. In this case just update the pager cache,
danielk19770de0bb32004-06-10 05:59:24 +00001581 ** not the database file. The page is left marked dirty in this case.
1582 **
danielk19772df71c72007-05-24 07:22:42 +00001583 ** An exception to the above rule: If the database is in no-sync mode
1584 ** and a page is moved during an incremental vacuum then the page may
danielk1977369f3a02007-05-24 09:41:20 +00001585 ** not be in the pager cache. Later: if a malloc() or IO error occurs
1586 ** during a Movepage() call, then the page may not be in the cache
1587 ** either. So the condition described in the above paragraph is not
1588 ** assert()able.
danielk19772df71c72007-05-24 07:22:42 +00001589 **
danielk1977a3f3a5f2004-06-10 04:32:16 +00001590 ** If in EXCLUSIVE state, then we update the pager cache if it exists
1591 ** and the main file. The page is then marked not dirty.
drh96362842005-03-20 22:47:56 +00001592 **
1593 ** Ticket #1171: The statement journal might contain page content that is
1594 ** different from the page content at the start of the transaction.
1595 ** This occurs when a page is changed prior to the start of a statement
1596 ** then changed again within the statement. When rolling back such a
1597 ** statement we must not write to the original database unless we know
drh5e385312007-06-16 04:42:12 +00001598 ** for certain that original page contents are synced into the main rollback
1599 ** journal. Otherwise, a power loss might leave modified data in the
1600 ** database file without an entry in the rollback journal that can
1601 ** restore the database to its original form. Two conditions must be
1602 ** met before writing to the database files. (1) the database must be
1603 ** locked. (2) we know that the original page content is fully synced
1604 ** in the main journal either because the page is not in cache or else
1605 ** the page is marked as needSync==0.
drh4c02a232008-04-14 23:13:45 +00001606 **
1607 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
1608 ** is possible to fail a statement on a database that does not yet exist.
1609 ** Do not attempt to write if database file has never been opened.
drhfa86c412002-02-02 15:01:15 +00001610 */
drhae2b40c2004-06-09 19:03:54 +00001611 pPg = pager_lookup(pPager, pgno);
drh86655a12009-03-31 02:54:40 +00001612 assert( pPg || !MEMDB );
drh30d53702009-01-06 15:58:57 +00001613 PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
drhbfcb4ad2009-11-21 01:33:50 +00001614 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
1615 (isMainJrnl?"main-journal":"sub-journal")
drh30d53702009-01-06 15:58:57 +00001616 ));
drh91781bd2010-04-10 17:52:57 +00001617 if( isMainJrnl ){
1618 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
1619 }else{
1620 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
1621 }
danielk19778c0a7912008-08-20 14:49:23 +00001622 if( (pPager->state>=PAGER_EXCLUSIVE)
danielk1977bea2a942009-01-20 17:06:27 +00001623 && isOpen(pPager->fd)
drh91781bd2010-04-10 17:52:57 +00001624 && isSynced
danielk19778c0a7912008-08-20 14:49:23 +00001625 ){
drh281b21d2008-08-22 12:57:08 +00001626 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
drh05f69dd2010-04-09 15:34:06 +00001627 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
drhbfcb4ad2009-11-21 01:33:50 +00001628 rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
danielk19773460d192008-12-27 15:23:13 +00001629 if( pgno>pPager->dbFileSize ){
1630 pPager->dbFileSize = pgno;
1631 }
drh0719ee22009-06-18 20:52:47 +00001632 if( pPager->pBackup ){
drh0472b5a2009-06-19 02:25:48 +00001633 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
drhbfcb4ad2009-11-21 01:33:50 +00001634 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
1635 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
drh0719ee22009-06-18 20:52:47 +00001636 }
danielk1977f2c31ad2009-01-06 13:40:08 +00001637 }else if( !isMainJrnl && pPg==0 ){
1638 /* If this is a rollback of a savepoint and data was not written to
1639 ** the database and the page is not in-memory, there is a potential
1640 ** problem. When the page is next fetched by the b-tree layer, it
1641 ** will be read from the database file, which may or may not be
1642 ** current.
1643 **
1644 ** There are a couple of different ways this can happen. All are quite
danielk1977401b65e2009-01-06 14:34:34 +00001645 ** obscure. When running in synchronous mode, this can only happen
danielk1977f2c31ad2009-01-06 13:40:08 +00001646 ** if the page is on the free-list at the start of the transaction, then
1647 ** populated, then moved using sqlite3PagerMovepage().
1648 **
1649 ** The solution is to add an in-memory page to the cache containing
1650 ** the data just read from the sub-journal. Mark the page as dirty
1651 ** and if the pager requires a journal-sync, then mark the page as
1652 ** requiring a journal-sync before it is written.
1653 */
1654 assert( isSavepnt );
danielk1977859546c2009-01-22 17:12:39 +00001655 if( (rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1))!=SQLITE_OK ){
danielk1977f2c31ad2009-01-06 13:40:08 +00001656 return rc;
1657 }
1658 pPg->flags &= ~PGHDR_NEED_READ;
1659 sqlite3PcacheMakeDirty(pPg);
danielk1977a3f3a5f2004-06-10 04:32:16 +00001660 }
drhfa86c412002-02-02 15:01:15 +00001661 if( pPg ){
danielk197728129562005-01-11 10:25:06 +00001662 /* No page should ever be explicitly rolled back that is in use, except
1663 ** for page 1 which is held in use in order to keep the lock on the
1664 ** database active. However such a page may be rolled back as a result
1665 ** of an internal error resulting in an automatic call to
danielk19773b8a05f2007-03-19 17:44:26 +00001666 ** sqlite3PagerRollback().
drhacf4ac92003-12-17 23:57:34 +00001667 */
drhb6f41482004-05-14 01:58:11 +00001668 void *pData;
danielk19778c0a7912008-08-20 14:49:23 +00001669 pData = pPg->pData;
drhbfcb4ad2009-11-21 01:33:50 +00001670 memcpy(pData, (u8*)aData, pPager->pageSize);
drh4775ecd2009-07-24 19:01:19 +00001671 pPager->xReiniter(pPg);
danielk1977bea2a942009-01-20 17:06:27 +00001672 if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
danielk1977488af092008-12-19 16:31:11 +00001673 /* If the contents of this page were just restored from the main
1674 ** journal file, then its content must be as they were when the
1675 ** transaction was first opened. In this case we can mark the page
drh91781bd2010-04-10 17:52:57 +00001676 ** as clean, since there will be no need to write it out to the
1677 ** database.
danielk1977488af092008-12-19 16:31:11 +00001678 **
1679 ** There is one exception to this rule. If the page is being rolled
1680 ** back as part of a savepoint (or statement) rollback from an
1681 ** unsynced portion of the main journal file, then it is not safe
1682 ** to mark the page as clean. This is because marking the page as
1683 ** clean will clear the PGHDR_NEED_SYNC flag. Since the page is
1684 ** already in the journal file (recorded in Pager.pInJournal) and
1685 ** the PGHDR_NEED_SYNC flag is cleared, if the page is written to
1686 ** again within this transaction, it will be marked as dirty but
1687 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
1688 ** be written out into the database file before its journal file
1689 ** segment is synced. If a crash occurs during or following this,
1690 ** database corruption may ensue.
1691 */
drhc047b9f2008-11-21 03:23:43 +00001692 sqlite3PcacheMakeClean(pPg);
1693 }
danielk19773c407372005-02-15 02:54:14 +00001694#ifdef SQLITE_CHECK_PAGES
drh96362842005-03-20 22:47:56 +00001695 pPg->pageHash = pager_pagehash(pPg);
danielk19773c407372005-02-15 02:54:14 +00001696#endif
drh86a88112007-04-16 15:02:19 +00001697 /* If this was page 1, then restore the value of Pager.dbFileVers.
1698 ** Do this before any decoding. */
danielk197741483462007-03-24 16:45:04 +00001699 if( pgno==1 ){
drh86a88112007-04-16 15:02:19 +00001700 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
danielk197741483462007-03-24 16:45:04 +00001701 }
drh86a88112007-04-16 15:02:19 +00001702
1703 /* Decode the page just read from disk */
drh85d2bd22009-06-11 00:47:20 +00001704 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
danielk19778c0a7912008-08-20 14:49:23 +00001705 sqlite3PcacheRelease(pPg);
drhfa86c412002-02-02 15:01:15 +00001706 }
1707 return rc;
1708}
1709
1710/*
danielk197713adf8a2004-06-03 16:08:41 +00001711** Parameter zMaster is the name of a master journal file. A single journal
1712** file that referred to the master journal file has just been rolled back.
1713** This routine checks if it is possible to delete the master journal file,
1714** and does so if it is.
drh726de592004-06-10 23:35:50 +00001715**
danielk197765839c62007-08-30 08:08:17 +00001716** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
1717** available for use within this function.
1718**
danielk1977bea2a942009-01-20 17:06:27 +00001719** When a master journal file is created, it is populated with the names
1720** of all of its child journals, one after another, formatted as utf-8
1721** encoded text. The end of each child journal file is marked with a
1722** nul-terminator byte (0x00). i.e. the entire contents of a master journal
1723** file for a transaction involving two databases might be:
danielk197765839c62007-08-30 08:08:17 +00001724**
danielk1977bea2a942009-01-20 17:06:27 +00001725** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
1726**
1727** A master journal file may only be deleted once all of its child
1728** journals have been rolled back.
1729**
1730** This function reads the contents of the master-journal file into
1731** memory and loops through each of the child journal names. For
1732** each child journal, it checks if:
1733**
1734** * if the child journal exists, and if so
1735** * if the child journal contains a reference to master journal
1736** file zMaster
1737**
1738** If a child journal can be found that matches both of the criteria
1739** above, this function returns without doing anything. Otherwise, if
1740** no such child journal can be found, file zMaster is deleted from
1741** the file-system using sqlite3OsDelete().
1742**
1743** If an IO error within this function, an error code is returned. This
1744** function allocates memory by calling sqlite3Malloc(). If an allocation
1745** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
1746** occur, SQLITE_OK is returned.
1747**
1748** TODO: This function allocates a single block of memory to load
1749** the entire contents of the master journal file. This could be
1750** a couple of kilobytes or so - potentially larger than the page
1751** size.
danielk197713adf8a2004-06-03 16:08:41 +00001752*/
danielk1977b4b47412007-08-17 15:53:36 +00001753static int pager_delmaster(Pager *pPager, const char *zMaster){
1754 sqlite3_vfs *pVfs = pPager->pVfs;
danielk1977bea2a942009-01-20 17:06:27 +00001755 int rc; /* Return code */
1756 sqlite3_file *pMaster; /* Malloc'd master-journal file descriptor */
1757 sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
danielk197713adf8a2004-06-03 16:08:41 +00001758 char *zMasterJournal = 0; /* Contents of master journal file */
drheb206252004-10-01 02:00:31 +00001759 i64 nMasterJournal; /* Size of master journal file */
danielk197713adf8a2004-06-03 16:08:41 +00001760
danielk1977bea2a942009-01-20 17:06:27 +00001761 /* Allocate space for both the pJournal and pMaster file descriptors.
1762 ** If successful, open the master journal file for reading.
danielk197713adf8a2004-06-03 16:08:41 +00001763 */
danielk1977bea2a942009-01-20 17:06:27 +00001764 pMaster = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
danielk1977fee2d252007-08-18 10:59:19 +00001765 pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
danielk1977b4b47412007-08-17 15:53:36 +00001766 if( !pMaster ){
1767 rc = SQLITE_NOMEM;
1768 }else{
danielk1977bea2a942009-01-20 17:06:27 +00001769 const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
danielk1977fee2d252007-08-18 10:59:19 +00001770 rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
danielk1977b4b47412007-08-17 15:53:36 +00001771 }
danielk197713adf8a2004-06-03 16:08:41 +00001772 if( rc!=SQLITE_OK ) goto delmaster_out;
danielk1977b4b47412007-08-17 15:53:36 +00001773
1774 rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
danielk197713adf8a2004-06-03 16:08:41 +00001775 if( rc!=SQLITE_OK ) goto delmaster_out;
1776
1777 if( nMasterJournal>0 ){
danielk19775865e3d2004-06-14 06:03:57 +00001778 char *zJournal;
danielk197776572402004-06-25 02:38:54 +00001779 char *zMasterPtr = 0;
danielk1977bea2a942009-01-20 17:06:27 +00001780 int nMasterPtr = pVfs->mxPathname+1;
danielk19775865e3d2004-06-14 06:03:57 +00001781
1782 /* Load the entire master journal file into space obtained from
drh17435752007-08-16 04:30:38 +00001783 ** sqlite3_malloc() and pointed to by zMasterJournal.
danielk19775865e3d2004-06-14 06:03:57 +00001784 */
drh0b0abe42009-07-25 14:18:57 +00001785 zMasterJournal = sqlite3Malloc((int)nMasterJournal + nMasterPtr + 1);
danielk197713adf8a2004-06-03 16:08:41 +00001786 if( !zMasterJournal ){
1787 rc = SQLITE_NOMEM;
1788 goto delmaster_out;
1789 }
drh0b0abe42009-07-25 14:18:57 +00001790 zMasterPtr = &zMasterJournal[nMasterJournal+1];
drh4f21c4a2008-12-10 22:15:00 +00001791 rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
danielk197713adf8a2004-06-03 16:08:41 +00001792 if( rc!=SQLITE_OK ) goto delmaster_out;
drh0b0abe42009-07-25 14:18:57 +00001793 zMasterJournal[nMasterJournal] = 0;
danielk197713adf8a2004-06-03 16:08:41 +00001794
danielk19775865e3d2004-06-14 06:03:57 +00001795 zJournal = zMasterJournal;
1796 while( (zJournal-zMasterJournal)<nMasterJournal ){
danielk1977861f7452008-06-05 11:39:11 +00001797 int exists;
1798 rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
1799 if( rc!=SQLITE_OK ){
drh19db9352008-03-27 22:42:51 +00001800 goto delmaster_out;
1801 }
danielk1977861f7452008-06-05 11:39:11 +00001802 if( exists ){
danielk197713adf8a2004-06-03 16:08:41 +00001803 /* One of the journals pointed to by the master journal exists.
1804 ** Open it and check if it points at the master journal. If
1805 ** so, return without deleting the master journal file.
1806 */
drh3b7b78b2004-11-24 01:16:43 +00001807 int c;
danielk1977fee2d252007-08-18 10:59:19 +00001808 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
1809 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
danielk197713adf8a2004-06-03 16:08:41 +00001810 if( rc!=SQLITE_OK ){
danielk197713adf8a2004-06-03 16:08:41 +00001811 goto delmaster_out;
1812 }
danielk197713adf8a2004-06-03 16:08:41 +00001813
danielk197765839c62007-08-30 08:08:17 +00001814 rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
danielk1977b4b47412007-08-17 15:53:36 +00001815 sqlite3OsClose(pJournal);
danielk19779eed5052004-06-04 10:38:30 +00001816 if( rc!=SQLITE_OK ){
danielk19779eed5052004-06-04 10:38:30 +00001817 goto delmaster_out;
1818 }
danielk197776572402004-06-25 02:38:54 +00001819
danielk197765839c62007-08-30 08:08:17 +00001820 c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
drh3b7b78b2004-11-24 01:16:43 +00001821 if( c ){
danielk197776572402004-06-25 02:38:54 +00001822 /* We have a match. Do not delete the master journal file. */
1823 goto delmaster_out;
danielk197713adf8a2004-06-03 16:08:41 +00001824 }
1825 }
drhea678832008-12-10 19:26:22 +00001826 zJournal += (sqlite3Strlen30(zJournal)+1);
danielk197713adf8a2004-06-03 16:08:41 +00001827 }
1828 }
1829
danielk1977fee2d252007-08-18 10:59:19 +00001830 rc = sqlite3OsDelete(pVfs, zMaster, 0);
danielk197713adf8a2004-06-03 16:08:41 +00001831
1832delmaster_out:
1833 if( zMasterJournal ){
drh17435752007-08-16 04:30:38 +00001834 sqlite3_free(zMasterJournal);
danielk197713adf8a2004-06-03 16:08:41 +00001835 }
danielk1977bea2a942009-01-20 17:06:27 +00001836 if( pMaster ){
danielk1977b4b47412007-08-17 15:53:36 +00001837 sqlite3OsClose(pMaster);
danielk1977bea2a942009-01-20 17:06:27 +00001838 assert( !isOpen(pJournal) );
danielk197713adf8a2004-06-03 16:08:41 +00001839 }
danielk1977b4b47412007-08-17 15:53:36 +00001840 sqlite3_free(pMaster);
danielk197713adf8a2004-06-03 16:08:41 +00001841 return rc;
1842}
1843
drha6abd042004-06-09 17:37:22 +00001844
drha6abd042004-06-09 17:37:22 +00001845/*
danielk1977bea2a942009-01-20 17:06:27 +00001846** This function is used to change the actual size of the database
1847** file in the file-system. This only happens when committing a transaction,
1848** or rolling back a transaction (including rolling back a hot-journal).
drh7fe3f7e2007-11-29 18:44:27 +00001849**
danielk1977bea2a942009-01-20 17:06:27 +00001850** If the main database file is not open, or an exclusive lock is not
1851** held, this function is a no-op. Otherwise, the size of the file is
1852** changed to nPage pages (nPage*pPager->pageSize bytes). If the file
1853** on disk is currently larger than nPage pages, then use the VFS
1854** xTruncate() method to truncate it.
1855**
1856** Or, it might might be the case that the file on disk is smaller than
1857** nPage pages. Some operating system implementations can get confused if
1858** you try to truncate a file to some size that is larger than it
1859** currently is, so detect this case and write a single zero byte to
1860** the end of the new file instead.
1861**
1862** If successful, return SQLITE_OK. If an IO error occurs while modifying
1863** the database file, return the error code to the caller.
drhcb4c40b2004-08-18 19:09:43 +00001864*/
danielk1977d92db532008-11-17 04:56:24 +00001865static int pager_truncate(Pager *pPager, Pgno nPage){
danielk1977e180dd92007-04-05 17:15:52 +00001866 int rc = SQLITE_OK;
danielk1977bea2a942009-01-20 17:06:27 +00001867 if( pPager->state>=PAGER_EXCLUSIVE && isOpen(pPager->fd) ){
drh7fe3f7e2007-11-29 18:44:27 +00001868 i64 currentSize, newSize;
danielk1977bea2a942009-01-20 17:06:27 +00001869 /* TODO: Is it safe to use Pager.dbFileSize here? */
drh7fe3f7e2007-11-29 18:44:27 +00001870 rc = sqlite3OsFileSize(pPager->fd, &currentSize);
1871 newSize = pPager->pageSize*(i64)nPage;
danielk197706e11af2008-05-06 18:13:26 +00001872 if( rc==SQLITE_OK && currentSize!=newSize ){
1873 if( currentSize>newSize ){
1874 rc = sqlite3OsTruncate(pPager->fd, newSize);
1875 }else{
1876 rc = sqlite3OsWrite(pPager->fd, "", 1, newSize-1);
1877 }
danielk19773460d192008-12-27 15:23:13 +00001878 if( rc==SQLITE_OK ){
1879 pPager->dbFileSize = nPage;
1880 }
drh7fe3f7e2007-11-29 18:44:27 +00001881 }
danielk1977e180dd92007-04-05 17:15:52 +00001882 }
danielk1977e180dd92007-04-05 17:15:52 +00001883 return rc;
drhcb4c40b2004-08-18 19:09:43 +00001884}
1885
1886/*
danielk1977bea2a942009-01-20 17:06:27 +00001887** Set the value of the Pager.sectorSize variable for the given
1888** pager based on the value returned by the xSectorSize method
1889** of the open database file. The sector size will be used used
1890** to determine the size and alignment of journal header and
1891** master journal pointers within created journal files.
drhc80f0582007-05-01 16:59:48 +00001892**
danielk1977bea2a942009-01-20 17:06:27 +00001893** For temporary files the effective sector size is always 512 bytes.
1894**
1895** Otherwise, for non-temporary files, the effective sector size is
drh3c99d682009-11-11 13:17:08 +00001896** the value returned by the xSectorSize() method rounded up to 32 if
1897** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
danielk1977bea2a942009-01-20 17:06:27 +00001898** is greater than MAX_SECTOR_SIZE.
drhc80f0582007-05-01 16:59:48 +00001899*/
1900static void setSectorSize(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00001901 assert( isOpen(pPager->fd) || pPager->tempFile );
1902
danielk19777a2b1ee2007-08-21 14:27:01 +00001903 if( !pPager->tempFile ){
1904 /* Sector size doesn't matter for temporary files. Also, the file
danielk1977bea2a942009-01-20 17:06:27 +00001905 ** may not have been opened yet, in which case the OsSectorSize()
danielk19777a2b1ee2007-08-21 14:27:01 +00001906 ** call will segfault.
1907 */
1908 pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
1909 }
drh3c99d682009-11-11 13:17:08 +00001910 if( pPager->sectorSize<32 ){
drhae2a3482009-11-11 23:58:06 +00001911 pPager->sectorSize = 512;
drhc80f0582007-05-01 16:59:48 +00001912 }
danielk19777cbd5892009-01-10 16:15:09 +00001913 if( pPager->sectorSize>MAX_SECTOR_SIZE ){
danielk1977bea2a942009-01-20 17:06:27 +00001914 assert( MAX_SECTOR_SIZE>=512 );
danielk19777cbd5892009-01-10 16:15:09 +00001915 pPager->sectorSize = MAX_SECTOR_SIZE;
1916 }
drhc80f0582007-05-01 16:59:48 +00001917}
1918
1919/*
drhed7c8552001-04-11 14:29:21 +00001920** Playback the journal and thus restore the database file to
1921** the state it was in before we started making changes.
1922**
drh34e79ce2004-02-08 06:05:46 +00001923** The journal file format is as follows:
1924**
drhae2b40c2004-06-09 19:03:54 +00001925** (1) 8 byte prefix. A copy of aJournalMagic[].
1926** (2) 4 byte big-endian integer which is the number of valid page records
drh34e79ce2004-02-08 06:05:46 +00001927** in the journal. If this value is 0xffffffff, then compute the
drhae2b40c2004-06-09 19:03:54 +00001928** number of page records from the journal size.
1929** (3) 4 byte big-endian integer which is the initial value for the
1930** sanity checksum.
1931** (4) 4 byte integer which is the number of pages to truncate the
drh34e79ce2004-02-08 06:05:46 +00001932** database to during a rollback.
drh334c80d2008-03-28 17:41:13 +00001933** (5) 4 byte big-endian integer which is the sector size. The header
1934** is this many bytes in size.
drhe7ae4e22009-11-02 15:51:52 +00001935** (6) 4 byte big-endian integer which is the page size.
1936** (7) zero padding out to the next sector size.
1937** (8) Zero or more pages instances, each as follows:
drh34e79ce2004-02-08 06:05:46 +00001938** + 4 byte page number.
drhae2b40c2004-06-09 19:03:54 +00001939** + pPager->pageSize bytes of data.
1940** + 4 byte checksum
drh34e79ce2004-02-08 06:05:46 +00001941**
drhe7ae4e22009-11-02 15:51:52 +00001942** When we speak of the journal header, we mean the first 7 items above.
1943** Each entry in the journal is an instance of the 8th item.
drh34e79ce2004-02-08 06:05:46 +00001944**
1945** Call the value from the second bullet "nRec". nRec is the number of
1946** valid page entries in the journal. In most cases, you can compute the
1947** value of nRec from the size of the journal file. But if a power
1948** failure occurred while the journal was being written, it could be the
1949** case that the size of the journal file had already been increased but
1950** the extra entries had not yet made it safely to disk. In such a case,
1951** the value of nRec computed from the file size would be too large. For
1952** that reason, we always use the nRec value in the header.
1953**
1954** If the nRec value is 0xffffffff it means that nRec should be computed
1955** from the file size. This value is used when the user selects the
1956** no-sync option for the journal. A power failure could lead to corruption
1957** in this case. But for things like temporary table (which will be
1958** deleted when the power is restored) we don't care.
1959**
drhd9b02572001-04-15 00:37:09 +00001960** If the file opened as the journal file is not a well-formed
danielk1977ece80f12004-06-23 01:05:26 +00001961** journal file then all pages up to the first corrupted page are rolled
1962** back (or no pages if the journal header is corrupted). The journal file
1963** is then deleted and SQLITE_OK returned, just as if no corruption had
1964** been encountered.
1965**
1966** If an I/O or malloc() error occurs, the journal-file is not deleted
1967** and an error code is returned.
drhd3a5c502009-02-03 22:51:06 +00001968**
1969** The isHot parameter indicates that we are trying to rollback a journal
1970** that might be a hot journal. Or, it could be that the journal is
1971** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
1972** If the journal really is hot, reset the pager cache prior rolling
1973** back any content. If the journal is merely persistent, no reset is
1974** needed.
drhed7c8552001-04-11 14:29:21 +00001975*/
danielk1977e277be02007-03-23 18:12:06 +00001976static int pager_playback(Pager *pPager, int isHot){
danielk1977b4b47412007-08-17 15:53:36 +00001977 sqlite3_vfs *pVfs = pPager->pVfs;
drheb206252004-10-01 02:00:31 +00001978 i64 szJ; /* Size of the journal file in bytes */
danielk1977c3e8f5e2004-06-28 01:16:46 +00001979 u32 nRec; /* Number of Records in the journal */
shane0b8d2762008-07-22 05:18:00 +00001980 u32 u; /* Unsigned loop counter */
drhd9b02572001-04-15 00:37:09 +00001981 Pgno mxPg = 0; /* Size of the original file in pages */
drhae2b40c2004-06-09 19:03:54 +00001982 int rc; /* Result code of a subroutine */
danielk1977861f7452008-06-05 11:39:11 +00001983 int res = 1; /* Value returned by sqlite3OsAccess() */
danielk197713adf8a2004-06-03 16:08:41 +00001984 char *zMaster = 0; /* Name of master journal file if any */
drhd3a5c502009-02-03 22:51:06 +00001985 int needPagerReset; /* True to reset page prior to first page rollback */
drhed7c8552001-04-11 14:29:21 +00001986
drhc3a64ba2001-11-22 00:01:27 +00001987 /* Figure out how many records are in the journal. Abort early if
1988 ** the journal is empty.
drhed7c8552001-04-11 14:29:21 +00001989 */
danielk1977bea2a942009-01-20 17:06:27 +00001990 assert( isOpen(pPager->jfd) );
drh054889e2005-11-30 03:20:31 +00001991 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
danielk1977334cdb62007-03-26 08:05:12 +00001992 if( rc!=SQLITE_OK || szJ==0 ){
drhc3a64ba2001-11-22 00:01:27 +00001993 goto end_playback;
1994 }
drh240c5792004-02-08 00:40:52 +00001995
danielk197776572402004-06-25 02:38:54 +00001996 /* Read the master journal name from the journal, if it is present.
1997 ** If a master journal file name is specified, but the file is not
1998 ** present on disk, then the journal is not hot and does not need to be
1999 ** played back.
danielk1977bea2a942009-01-20 17:06:27 +00002000 **
2001 ** TODO: Technically the following is an error because it assumes that
2002 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
2003 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
2004 ** mxPathname is 512, which is the same as the minimum allowable value
2005 ** for pageSize.
drh240c5792004-02-08 00:40:52 +00002006 */
danielk197765839c62007-08-30 08:08:17 +00002007 zMaster = pPager->pTmpSpace;
2008 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
danielk1977861f7452008-06-05 11:39:11 +00002009 if( rc==SQLITE_OK && zMaster[0] ){
2010 rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
drhc3a64ba2001-11-22 00:01:27 +00002011 }
danielk197765839c62007-08-30 08:08:17 +00002012 zMaster = 0;
danielk1977861f7452008-06-05 11:39:11 +00002013 if( rc!=SQLITE_OK || !res ){
danielk1977ce98bba2008-04-03 10:13:01 +00002014 goto end_playback;
2015 }
2016 pPager->journalOff = 0;
drhd3a5c502009-02-03 22:51:06 +00002017 needPagerReset = isHot;
drhc3a64ba2001-11-22 00:01:27 +00002018
danielk1977bea2a942009-01-20 17:06:27 +00002019 /* This loop terminates either when a readJournalHdr() or
2020 ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
2021 ** occurs.
2022 */
danielk197776572402004-06-25 02:38:54 +00002023 while( 1 ){
danielk197776572402004-06-25 02:38:54 +00002024 /* Read the next journal header from the journal file. If there are
2025 ** not enough bytes left in the journal file for a complete header, or
2026 ** it is corrupted, then a process must of failed while writing it.
2027 ** This indicates nothing more needs to be rolled back.
2028 */
danielk19776f4c73e2009-06-26 07:12:06 +00002029 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
danielk197776572402004-06-25 02:38:54 +00002030 if( rc!=SQLITE_OK ){
drh968af522003-02-11 14:55:40 +00002031 if( rc==SQLITE_DONE ){
drh968af522003-02-11 14:55:40 +00002032 rc = SQLITE_OK;
2033 }
danielk197776572402004-06-25 02:38:54 +00002034 goto end_playback;
2035 }
2036
2037 /* If nRec is 0xffffffff, then this journal was created by a process
2038 ** working in no-sync mode. This means that the rest of the journal
2039 ** file consists of pages, there are no more journal headers. Compute
2040 ** the value of nRec based on this assumption.
2041 */
2042 if( nRec==0xffffffff ){
2043 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
drh4f21c4a2008-12-10 22:15:00 +00002044 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
danielk197776572402004-06-25 02:38:54 +00002045 }
2046
danielk1977e277be02007-03-23 18:12:06 +00002047 /* If nRec is 0 and this rollback is of a transaction created by this
drh8940f4e2007-08-11 00:26:20 +00002048 ** process and if this is the final header in the journal, then it means
2049 ** that this part of the journal was being filled but has not yet been
2050 ** synced to disk. Compute the number of pages based on the remaining
2051 ** size of the file.
2052 **
2053 ** The third term of the test was added to fix ticket #2565.
drhd6e5e092009-01-07 02:03:35 +00002054 ** When rolling back a hot journal, nRec==0 always means that the next
2055 ** chunk of the journal contains zero pages to be rolled back. But
2056 ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
2057 ** the journal, it means that the journal might contain additional
2058 ** pages that need to be rolled back and that the number of pages
drhee03d622009-01-07 15:33:45 +00002059 ** should be computed based on the journal file size.
danielk1977e277be02007-03-23 18:12:06 +00002060 */
drh8940f4e2007-08-11 00:26:20 +00002061 if( nRec==0 && !isHot &&
2062 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
drh4f21c4a2008-12-10 22:15:00 +00002063 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
danielk1977e277be02007-03-23 18:12:06 +00002064 }
2065
danielk197776572402004-06-25 02:38:54 +00002066 /* If this is the first header read from the journal, truncate the
drh85b623f2007-12-13 21:54:09 +00002067 ** database file back to its original size.
danielk197776572402004-06-25 02:38:54 +00002068 */
danielk1977e180dd92007-04-05 17:15:52 +00002069 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
drhcb4c40b2004-08-18 19:09:43 +00002070 rc = pager_truncate(pPager, mxPg);
danielk197776572402004-06-25 02:38:54 +00002071 if( rc!=SQLITE_OK ){
2072 goto end_playback;
2073 }
danielk1977f90b7262009-01-07 15:18:20 +00002074 pPager->dbSize = mxPg;
danielk197776572402004-06-25 02:38:54 +00002075 }
2076
danielk1977bea2a942009-01-20 17:06:27 +00002077 /* Copy original pages out of the journal and back into the
2078 ** database file and/or page cache.
danielk197776572402004-06-25 02:38:54 +00002079 */
shane0b8d2762008-07-22 05:18:00 +00002080 for(u=0; u<nRec; u++){
drhd3a5c502009-02-03 22:51:06 +00002081 if( needPagerReset ){
2082 pager_reset(pPager);
2083 needPagerReset = 0;
2084 }
drh91781bd2010-04-10 17:52:57 +00002085 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
danielk197776572402004-06-25 02:38:54 +00002086 if( rc!=SQLITE_OK ){
2087 if( rc==SQLITE_DONE ){
2088 rc = SQLITE_OK;
2089 pPager->journalOff = szJ;
2090 break;
drh8d83c0f2010-04-03 13:08:09 +00002091 }else if( rc==SQLITE_IOERR_SHORT_READ ){
2092 /* If the journal has been truncated, simply stop reading and
2093 ** processing the journal. This might happen if the journal was
2094 ** not completely written and synced prior to a crash. In that
2095 ** case, the database should have never been written in the
2096 ** first place so it is OK to simply abandon the rollback. */
2097 rc = SQLITE_OK;
2098 goto end_playback;
danielk197776572402004-06-25 02:38:54 +00002099 }else{
drh66fd2162009-04-11 16:27:49 +00002100 /* If we are unable to rollback, quit and return the error
2101 ** code. This will cause the pager to enter the error state
2102 ** so that no further harm will be done. Perhaps the next
2103 ** process to come along will be able to rollback the database.
drha9625ea2008-09-03 00:08:29 +00002104 */
danielk197776572402004-06-25 02:38:54 +00002105 goto end_playback;
2106 }
2107 }
drh968af522003-02-11 14:55:40 +00002108 }
drhed7c8552001-04-11 14:29:21 +00002109 }
drh580eeaf2006-02-24 03:09:37 +00002110 /*NOTREACHED*/
2111 assert( 0 );
drh4a0681e2003-02-13 01:58:20 +00002112
2113end_playback:
drh8f941bc2009-01-14 23:03:40 +00002114 /* Following a rollback, the database file should be back in its original
2115 ** state prior to the start of the transaction, so invoke the
2116 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
2117 ** assertion that the transaction counter was modified.
2118 */
2119 assert(
2120 pPager->fd->pMethods==0 ||
2121 sqlite3OsFileControl(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0)>=SQLITE_OK
2122 );
2123
danielk1977db340392009-01-16 16:40:14 +00002124 /* If this playback is happening automatically as a result of an IO or
shanebe217792009-03-05 04:20:31 +00002125 ** malloc error that occurred after the change-counter was updated but
danielk1977db340392009-01-16 16:40:14 +00002126 ** before the transaction was committed, then the change-counter
2127 ** modification may just have been reverted. If this happens in exclusive
2128 ** mode, then subsequent transactions performed by the connection will not
2129 ** update the change-counter at all. This may lead to cache inconsistency
2130 ** problems for other processes at some point in the future. So, just
2131 ** in case this has happened, clear the changeCountDone flag now.
2132 */
danielk1977bea2a942009-01-20 17:06:27 +00002133 pPager->changeCountDone = pPager->tempFile;
danielk1977db340392009-01-16 16:40:14 +00002134
danielk19778191bff2004-06-28 04:52:30 +00002135 if( rc==SQLITE_OK ){
danielk197765839c62007-08-30 08:08:17 +00002136 zMaster = pPager->pTmpSpace;
2137 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
danielk1977bea2a942009-01-20 17:06:27 +00002138 testcase( rc!=SQLITE_OK );
danielk197765839c62007-08-30 08:08:17 +00002139 }
danbb23e7f2010-03-22 17:13:53 +00002140 if( rc==SQLITE_OK && pPager->noSync==0 && pPager->state>=PAGER_EXCLUSIVE ){
2141 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
2142 }
dan7c246102010-04-12 19:00:29 +00002143 if( rc==SQLITE_OK && pPager->noSync==0 && pPager->state>=PAGER_EXCLUSIVE ){
2144 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
2145 }
danielk197765839c62007-08-30 08:08:17 +00002146 if( rc==SQLITE_OK ){
danielk1977df2566a2008-05-07 19:11:03 +00002147 rc = pager_end_transaction(pPager, zMaster[0]!='\0');
danielk1977bea2a942009-01-20 17:06:27 +00002148 testcase( rc!=SQLITE_OK );
danielk19778191bff2004-06-28 04:52:30 +00002149 }
danielk1977c56774e2008-10-07 11:51:20 +00002150 if( rc==SQLITE_OK && zMaster[0] && res ){
danielk1977979f38e2007-03-27 16:19:51 +00002151 /* If there was a master journal and this routine will return success,
danielk197732554c12005-01-22 03:39:39 +00002152 ** see if it is possible to delete the master journal.
danielk197713adf8a2004-06-03 16:08:41 +00002153 */
danielk197765839c62007-08-30 08:08:17 +00002154 rc = pager_delmaster(pPager, zMaster);
danielk1977bea2a942009-01-20 17:06:27 +00002155 testcase( rc!=SQLITE_OK );
danielk197713adf8a2004-06-03 16:08:41 +00002156 }
danielk197776572402004-06-25 02:38:54 +00002157
2158 /* The Pager.sectorSize variable may have been updated while rolling
drh3ceeb752007-03-29 18:19:52 +00002159 ** back a journal created by a process with a different sector size
danielk197776572402004-06-25 02:38:54 +00002160 ** value. Reset it to the correct value for this process.
2161 */
drhc80f0582007-05-01 16:59:48 +00002162 setSectorSize(pPager);
drhd9b02572001-04-15 00:37:09 +00002163 return rc;
drhed7c8552001-04-11 14:29:21 +00002164}
2165
dan7c246102010-04-12 19:00:29 +00002166
2167/*
2168** Read the content for page pPg out of the database file and into
2169** pPg->pData. A shared lock or greater must be held on the database
2170** file before this function is called.
2171**
2172** If page 1 is read, then the value of Pager.dbFileVers[] is set to
2173** the value read from the database file.
2174**
2175** If an IO error occurs, then the IO error is returned to the caller.
2176** Otherwise, SQLITE_OK is returned.
2177*/
2178static int readDbPage(PgHdr *pPg){
2179 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
2180 Pgno pgno = pPg->pgno; /* Page number to read */
drh622194c2010-04-13 15:30:53 +00002181 int rc = SQLITE_OK; /* Return code */
dan7c246102010-04-12 19:00:29 +00002182 i64 iOffset; /* Byte offset of file to read from */
2183 int isInLog = 0; /* True if page is in log file */
2184
2185 assert( pPager->state>=PAGER_SHARED && !MEMDB );
2186 assert( isOpen(pPager->fd) );
2187
2188 if( NEVER(!isOpen(pPager->fd)) ){
2189 assert( pPager->tempFile );
2190 memset(pPg->pData, 0, pPager->pageSize);
2191 return SQLITE_OK;
2192 }
2193
2194 if( pagerUseLog(pPager) ){
2195 /* Try to pull the page from the write-ahead log. */
2196 rc = sqlite3LogRead(pPager->pLog, pgno, &isInLog, pPg->pData);
2197 }
2198 if( rc==SQLITE_OK && !isInLog ){
2199 iOffset = (pgno-1)*(i64)pPager->pageSize;
2200 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
2201 if( rc==SQLITE_IOERR_SHORT_READ ){
2202 rc = SQLITE_OK;
2203 }
2204 }
2205
2206 if( pgno==1 ){
2207 if( rc ){
2208 /* If the read is unsuccessful, set the dbFileVers[] to something
2209 ** that will never be a valid file version. dbFileVers[] is a copy
2210 ** of bytes 24..39 of the database. Bytes 28..31 should always be
2211 ** zero. Bytes 32..35 and 35..39 should be page numbers which are
2212 ** never 0xffffffff. So filling pPager->dbFileVers[] with all 0xff
2213 ** bytes should suffice.
2214 **
2215 ** For an encrypted database, the situation is more complex: bytes
2216 ** 24..39 of the database are white noise. But the probability of
2217 ** white noising equaling 16 bytes of 0xff is vanishingly small so
2218 ** we should still be ok.
2219 */
2220 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
2221 }else{
2222 u8 *dbFileVers = &((u8*)pPg->pData)[24];
2223 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
2224 }
2225 }
2226 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
2227
2228 PAGER_INCR(sqlite3_pager_readdb_count);
2229 PAGER_INCR(pPager->nRead);
2230 IOTRACE(("PGIN %p %d\n", pPager, pgno));
2231 PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
2232 PAGERID(pPager), pgno, pager_pagehash(pPg)));
2233
2234 return rc;
2235}
2236
dan3306c4a2010-04-23 19:15:00 +00002237/*
dan74d6cd82010-04-24 18:44:05 +00002238** This function is invoked once for each page that has already been
2239** written into the log file when a WAL transaction is rolled back.
2240** Parameter iPg is the page number of said page. The pCtx argument
2241** is actually a pointer to the Pager structure.
dan3306c4a2010-04-23 19:15:00 +00002242**
dan74d6cd82010-04-24 18:44:05 +00002243** If page iPg is present in the cache, and has no outstanding references,
2244** it is discarded. Otherwise, if there are one or more outstanding
2245** references, the page content is reloaded from the database. If the
2246** attempt to reload content from the database is required and fails,
2247** return an SQLite error code. Otherwise, SQLITE_OK.
2248*/
2249static int pagerUndoCallback(void *pCtx, Pgno iPg){
2250 int rc = SQLITE_OK;
2251 Pager *pPager = (Pager *)pCtx;
2252 PgHdr *pPg;
2253
2254 pPg = sqlite3PagerLookup(pPager, iPg);
2255 if( pPg ){
2256 if( sqlite3PcachePageRefcount(pPg)==1 ){
2257 sqlite3PcacheDrop(pPg);
2258 }else{
2259 rc = readDbPage(pPg);
2260 if( rc==SQLITE_OK ){
2261 pPager->xReiniter(pPg);
2262 }
2263 sqlite3PagerUnref(pPg);
2264 }
2265 }
2266
2267 return rc;
2268}
2269
2270/*
2271** This function is called to rollback a transaction on a WAL database.
dan3306c4a2010-04-23 19:15:00 +00002272*/
dan7c246102010-04-12 19:00:29 +00002273static int pagerRollbackLog(Pager *pPager){
dan74d6cd82010-04-24 18:44:05 +00002274 int rc; /* Return Code */
2275 PgHdr *pList; /* List of dirty pages to revert */
dan3306c4a2010-04-23 19:15:00 +00002276
2277 /* Normally, if a transaction is rolled back, any backup processes are
2278 ** updated as data is copied out of the rollback journal and into the
2279 ** database. This is not generally possible with a WAL database, as
2280 ** rollback involves simply truncating the log file. Therefore, if one
2281 ** or more frames have already been written to the log (and therefore
2282 ** also copied into the backup databases) as part of this transaction,
2283 ** the backups must be restarted.
2284 */
2285 if( sqlite3LogDirty(pPager->pLog) ){
2286 sqlite3BackupRestart(pPager->pBackup);
2287 }
2288
dan74d6cd82010-04-24 18:44:05 +00002289 /* For all pages in the cache that are currently dirty or have already
2290 ** been written (but not committed) to the log file, do one of the
2291 ** following:
2292 **
2293 ** + Discard the cached page (if refcount==0), or
2294 ** + Reload page content from the database (if refcount>0).
2295 */
dan7c246102010-04-12 19:00:29 +00002296 pPager->dbSize = pPager->dbOrigSize;
dan74d6cd82010-04-24 18:44:05 +00002297 rc = sqlite3LogUndo(pPager->pLog, pagerUndoCallback, (void *)pPager);
2298 pList = sqlite3PcacheDirtyList(pPager->pPCache);
dan7c246102010-04-12 19:00:29 +00002299 while( pList && rc==SQLITE_OK ){
2300 PgHdr *pNext = pList->pDirty;
dan74d6cd82010-04-24 18:44:05 +00002301 rc = pagerUndoCallback((void *)pPager, pList->pgno);
dan7c246102010-04-12 19:00:29 +00002302 pList = pNext;
2303 }
dan74d6cd82010-04-24 18:44:05 +00002304
dan7c246102010-04-12 19:00:29 +00002305 return rc;
2306}
2307
drhed7c8552001-04-11 14:29:21 +00002308/*
danielk1977bea2a942009-01-20 17:06:27 +00002309** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
2310** the entire master journal file. The case pSavepoint==NULL occurs when
2311** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
2312** savepoint.
drhd6e5e092009-01-07 02:03:35 +00002313**
danielk1977bea2a942009-01-20 17:06:27 +00002314** When pSavepoint is not NULL (meaning a non-transaction savepoint is
2315** being rolled back), then the rollback consists of up to three stages,
2316** performed in the order specified:
2317**
2318** * Pages are played back from the main journal starting at byte
2319** offset PagerSavepoint.iOffset and continuing to
2320** PagerSavepoint.iHdrOffset, or to the end of the main journal
2321** file if PagerSavepoint.iHdrOffset is zero.
2322**
2323** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
2324** back starting from the journal header immediately following
2325** PagerSavepoint.iHdrOffset to the end of the main journal file.
2326**
2327** * Pages are then played back from the sub-journal file, starting
2328** with the PagerSavepoint.iSubRec and continuing to the end of
2329** the journal file.
2330**
2331** Throughout the rollback process, each time a page is rolled back, the
2332** corresponding bit is set in a bitvec structure (variable pDone in the
2333** implementation below). This is used to ensure that a page is only
2334** rolled back the first time it is encountered in either journal.
2335**
2336** If pSavepoint is NULL, then pages are only played back from the main
2337** journal file. There is no need for a bitvec in this case.
2338**
2339** In either case, before playback commences the Pager.dbSize variable
2340** is reset to the value that it held at the start of the savepoint
2341** (or transaction). No page with a page-number greater than this value
2342** is played back. If one is encountered it is simply skipped.
drhfa86c412002-02-02 15:01:15 +00002343*/
danielk1977fd7f0452008-12-17 17:30:26 +00002344static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
drhd6e5e092009-01-07 02:03:35 +00002345 i64 szJ; /* Effective size of the main journal */
danielk1977fd7f0452008-12-17 17:30:26 +00002346 i64 iHdrOff; /* End of first segment of main-journal records */
danielk1977f2c31ad2009-01-06 13:40:08 +00002347 int rc = SQLITE_OK; /* Return code */
danielk1977fd7f0452008-12-17 17:30:26 +00002348 Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
drhfa86c412002-02-02 15:01:15 +00002349
danielk1977bea2a942009-01-20 17:06:27 +00002350 assert( pPager->state>=PAGER_SHARED );
2351
danielk1977fd7f0452008-12-17 17:30:26 +00002352 /* Allocate a bitvec to use to store the set of pages rolled back */
2353 if( pSavepoint ){
2354 pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
2355 if( !pDone ){
2356 return SQLITE_NOMEM;
2357 }
danielk197776572402004-06-25 02:38:54 +00002358 }
danielk1977fd7f0452008-12-17 17:30:26 +00002359
danielk1977bea2a942009-01-20 17:06:27 +00002360 /* Set the database size back to the value it was before the savepoint
2361 ** being reverted was opened.
drhfa86c412002-02-02 15:01:15 +00002362 */
drhd6e5e092009-01-07 02:03:35 +00002363 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
drhfa86c412002-02-02 15:01:15 +00002364
dan7c246102010-04-12 19:00:29 +00002365 if( !pSavepoint && pagerUseLog(pPager) ){
2366 return pagerRollbackLog(pPager);
2367 }
2368
drhd6e5e092009-01-07 02:03:35 +00002369 /* Use pPager->journalOff as the effective size of the main rollback
2370 ** journal. The actual file might be larger than this in
2371 ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
2372 ** past pPager->journalOff is off-limits to us.
drhfa86c412002-02-02 15:01:15 +00002373 */
danielk1977fd7f0452008-12-17 17:30:26 +00002374 szJ = pPager->journalOff;
dan7c246102010-04-12 19:00:29 +00002375 assert( pagerUseLog(pPager)==0 || szJ==0 );
drhd6e5e092009-01-07 02:03:35 +00002376
2377 /* Begin by rolling back records from the main journal starting at
2378 ** PagerSavepoint.iOffset and continuing to the next journal header.
2379 ** There might be records in the main journal that have a page number
2380 ** greater than the current database size (pPager->dbSize) but those
2381 ** will be skipped automatically. Pages are added to pDone as they
2382 ** are played back.
2383 */
dan7c246102010-04-12 19:00:29 +00002384 if( pSavepoint && !pagerUseLog(pPager) ){
danielk1977fd7f0452008-12-17 17:30:26 +00002385 iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
2386 pPager->journalOff = pSavepoint->iOffset;
2387 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
drh91781bd2010-04-10 17:52:57 +00002388 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
danielk1977fd7f0452008-12-17 17:30:26 +00002389 }
danielk1977bea2a942009-01-20 17:06:27 +00002390 assert( rc!=SQLITE_DONE );
danielk1977fd7f0452008-12-17 17:30:26 +00002391 }else{
2392 pPager->journalOff = 0;
drhfa86c412002-02-02 15:01:15 +00002393 }
drhd6e5e092009-01-07 02:03:35 +00002394
2395 /* Continue rolling back records out of the main journal starting at
2396 ** the first journal header seen and continuing until the effective end
2397 ** of the main journal file. Continue to skip out-of-range pages and
2398 ** continue adding pages rolled back to pDone.
2399 */
danielk1977fd7f0452008-12-17 17:30:26 +00002400 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
danielk1977bea2a942009-01-20 17:06:27 +00002401 u32 ii; /* Loop counter */
danielk1977c81806f2009-01-01 15:20:37 +00002402 u32 nJRec = 0; /* Number of Journal Records */
danielk197776572402004-06-25 02:38:54 +00002403 u32 dummy;
danielk19776f4c73e2009-06-26 07:12:06 +00002404 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
danielk1977fd7f0452008-12-17 17:30:26 +00002405 assert( rc!=SQLITE_DONE );
drhd6e5e092009-01-07 02:03:35 +00002406
2407 /*
2408 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
2409 ** test is related to ticket #2565. See the discussion in the
2410 ** pager_playback() function for additional information.
2411 */
drhd6e5e092009-01-07 02:03:35 +00002412 if( nJRec==0
2413 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
2414 ){
shaned87897d2009-01-30 05:40:27 +00002415 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
danielk197775edc162004-06-26 01:48:18 +00002416 }
danielk197712dd5492008-12-18 15:45:07 +00002417 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
drh91781bd2010-04-10 17:52:57 +00002418 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
danielk1977fd7f0452008-12-17 17:30:26 +00002419 }
danielk1977bea2a942009-01-20 17:06:27 +00002420 assert( rc!=SQLITE_DONE );
danielk1977fd7f0452008-12-17 17:30:26 +00002421 }
2422 assert( rc!=SQLITE_OK || pPager->journalOff==szJ );
2423
drhd6e5e092009-01-07 02:03:35 +00002424 /* Finally, rollback pages from the sub-journal. Page that were
2425 ** previously rolled back out of the main journal (and are hence in pDone)
2426 ** will be skipped. Out-of-range pages are also skipped.
2427 */
danielk1977fd7f0452008-12-17 17:30:26 +00002428 if( pSavepoint ){
danielk1977bea2a942009-01-20 17:06:27 +00002429 u32 ii; /* Loop counter */
drhd6e5e092009-01-07 02:03:35 +00002430 i64 offset = pSavepoint->iSubRec*(4+pPager->pageSize);
danielk1977bea2a942009-01-20 17:06:27 +00002431 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
2432 assert( offset==ii*(4+pPager->pageSize) );
drh91781bd2010-04-10 17:52:57 +00002433 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
danielk197776572402004-06-25 02:38:54 +00002434 }
danielk1977bea2a942009-01-20 17:06:27 +00002435 assert( rc!=SQLITE_DONE );
drhfa86c412002-02-02 15:01:15 +00002436 }
danielk197776572402004-06-25 02:38:54 +00002437
danielk1977fd7f0452008-12-17 17:30:26 +00002438 sqlite3BitvecDestroy(pDone);
2439 if( rc==SQLITE_OK ){
danielk197775edc162004-06-26 01:48:18 +00002440 pPager->journalOff = szJ;
drhfa86c412002-02-02 15:01:15 +00002441 }
2442 return rc;
2443}
2444
2445/*
drhf57b14a2001-09-14 18:54:08 +00002446** Change the maximum number of in-memory pages that are allowed.
2447*/
danielk19773b8a05f2007-03-19 17:44:26 +00002448void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
danielk19778c0a7912008-08-20 14:49:23 +00002449 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
drhf57b14a2001-09-14 18:54:08 +00002450}
2451
2452/*
drh973b6e32003-02-12 14:09:42 +00002453** Adjust the robustness of the database to damage due to OS crashes
2454** or power failures by changing the number of syncs()s when writing
2455** the rollback journal. There are three levels:
2456**
drh054889e2005-11-30 03:20:31 +00002457** OFF sqlite3OsSync() is never called. This is the default
drh973b6e32003-02-12 14:09:42 +00002458** for temporary and transient files.
2459**
2460** NORMAL The journal is synced once before writes begin on the
2461** database. This is normally adequate protection, but
2462** it is theoretically possible, though very unlikely,
2463** that an inopertune power failure could leave the journal
2464** in a state which would cause damage to the database
2465** when it is rolled back.
2466**
2467** FULL The journal is synced twice before writes begin on the
drh34e79ce2004-02-08 06:05:46 +00002468** database (with some additional information - the nRec field
2469** of the journal header - being written in between the two
2470** syncs). If we assume that writing a
drh973b6e32003-02-12 14:09:42 +00002471** single disk sector is atomic, then this mode provides
2472** assurance that the journal will not be corrupted to the
2473** point of causing damage to the database during rollback.
2474**
2475** Numeric values associated with these states are OFF==1, NORMAL=2,
2476** and FULL=3.
2477*/
danielk197793758c82005-01-21 08:13:14 +00002478#ifndef SQLITE_OMIT_PAGER_PRAGMAS
drh281b21d2008-08-22 12:57:08 +00002479void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
drh4f21c4a2008-12-10 22:15:00 +00002480 pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
2481 pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
drh281b21d2008-08-22 12:57:08 +00002482 pPager->sync_flags = (bFullFsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);
danielk19771d850a72004-05-31 08:26:49 +00002483 if( pPager->noSync ) pPager->needSync = 0;
drh973b6e32003-02-12 14:09:42 +00002484}
danielk197793758c82005-01-21 08:13:14 +00002485#endif
drh973b6e32003-02-12 14:09:42 +00002486
2487/*
drhaf6df112005-06-07 02:12:30 +00002488** The following global variable is incremented whenever the library
2489** attempts to open a temporary file. This information is used for
2490** testing and analysis only.
2491*/
drh0f7eb612006-08-08 13:51:43 +00002492#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00002493int sqlite3_opentemp_count = 0;
drh0f7eb612006-08-08 13:51:43 +00002494#endif
drhaf6df112005-06-07 02:12:30 +00002495
2496/*
danielk1977bea2a942009-01-20 17:06:27 +00002497** Open a temporary file.
drh3f56e6e2007-03-15 01:16:47 +00002498**
danielk1977bea2a942009-01-20 17:06:27 +00002499** Write the file descriptor into *pFile. Return SQLITE_OK on success
2500** or some other error code if we fail. The OS will automatically
2501** delete the temporary file when it is closed.
2502**
2503** The flags passed to the VFS layer xOpen() call are those specified
2504** by parameter vfsFlags ORed with the following:
2505**
2506** SQLITE_OPEN_READWRITE
2507** SQLITE_OPEN_CREATE
2508** SQLITE_OPEN_EXCLUSIVE
2509** SQLITE_OPEN_DELETEONCLOSE
drhfa86c412002-02-02 15:01:15 +00002510*/
danielk1977bea2a942009-01-20 17:06:27 +00002511static int pagerOpentemp(
danielk197717b90b52008-06-06 11:11:25 +00002512 Pager *pPager, /* The pager object */
drh33f4e022007-09-03 15:19:34 +00002513 sqlite3_file *pFile, /* Write the file descriptor here */
drh33f4e022007-09-03 15:19:34 +00002514 int vfsFlags /* Flags passed through to the VFS */
danielk1977b4b47412007-08-17 15:53:36 +00002515){
danielk1977bea2a942009-01-20 17:06:27 +00002516 int rc; /* Return code */
drh3f56e6e2007-03-15 01:16:47 +00002517
drh0f7eb612006-08-08 13:51:43 +00002518#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00002519 sqlite3_opentemp_count++; /* Used for testing and analysis only */
drh0f7eb612006-08-08 13:51:43 +00002520#endif
danielk1977b4b47412007-08-17 15:53:36 +00002521
drh33f4e022007-09-03 15:19:34 +00002522 vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
2523 SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
danielk197717b90b52008-06-06 11:11:25 +00002524 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
danielk1977bea2a942009-01-20 17:06:27 +00002525 assert( rc!=SQLITE_OK || isOpen(pFile) );
drhfa86c412002-02-02 15:01:15 +00002526 return rc;
2527}
2528
drhed7c8552001-04-11 14:29:21 +00002529/*
drh90f5ecb2004-07-22 01:19:35 +00002530** Set the busy handler function.
danielk1977bea2a942009-01-20 17:06:27 +00002531**
2532** The pager invokes the busy-handler if sqlite3OsLock() returns
2533** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
2534** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
2535** lock. It does *not* invoke the busy handler when upgrading from
2536** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
2537** (which occurs during hot-journal rollback). Summary:
2538**
2539** Transition | Invokes xBusyHandler
2540** --------------------------------------------------------
2541** NO_LOCK -> SHARED_LOCK | Yes
2542** SHARED_LOCK -> RESERVED_LOCK | No
2543** SHARED_LOCK -> EXCLUSIVE_LOCK | No
2544** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
2545**
2546** If the busy-handler callback returns non-zero, the lock is
2547** retried. If it returns zero, then the SQLITE_BUSY error is
2548** returned to the caller of the pager API function.
drh90f5ecb2004-07-22 01:19:35 +00002549*/
danielk19771ceedd32008-11-19 10:22:33 +00002550void sqlite3PagerSetBusyhandler(
danielk1977bea2a942009-01-20 17:06:27 +00002551 Pager *pPager, /* Pager object */
2552 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
2553 void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
danielk19771ceedd32008-11-19 10:22:33 +00002554){
2555 pPager->xBusyHandler = xBusyHandler;
2556 pPager->pBusyHandlerArg = pBusyHandlerArg;
drh90f5ecb2004-07-22 01:19:35 +00002557}
2558
2559/*
drhfa9601a2009-06-18 17:22:39 +00002560** Report the current page size and number of reserved bytes back
2561** to the codec.
2562*/
2563#ifdef SQLITE_HAS_CODEC
2564static void pagerReportSize(Pager *pPager){
2565 if( pPager->xCodecSizeChng ){
2566 pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
2567 (int)pPager->nReserve);
2568 }
2569}
2570#else
2571# define pagerReportSize(X) /* No-op if we do not support a codec */
2572#endif
2573
2574/*
danielk1977bea2a942009-01-20 17:06:27 +00002575** Change the page size used by the Pager object. The new page size
2576** is passed in *pPageSize.
2577**
2578** If the pager is in the error state when this function is called, it
2579** is a no-op. The value returned is the error state error code (i.e.
2580** one of SQLITE_IOERR, SQLITE_CORRUPT or SQLITE_FULL).
2581**
2582** Otherwise, if all of the following are true:
2583**
2584** * the new page size (value of *pPageSize) is valid (a power
2585** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
2586**
2587** * there are no outstanding page references, and
2588**
2589** * the database is either not an in-memory database or it is
2590** an in-memory database that currently consists of zero pages.
2591**
2592** then the pager object page size is set to *pPageSize.
2593**
2594** If the page size is changed, then this function uses sqlite3PagerMalloc()
2595** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
2596** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
2597** In all other cases, SQLITE_OK is returned.
2598**
2599** If the page size is not changed, either because one of the enumerated
2600** conditions above is not true, the pager was in error state when this
2601** function was called, or because the memory allocation attempt failed,
2602** then *pPageSize is set to the old, retained page size before returning.
drh90f5ecb2004-07-22 01:19:35 +00002603*/
drhfa9601a2009-06-18 17:22:39 +00002604int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize, int nReserve){
danielk19771357d9f2008-09-16 05:12:24 +00002605 int rc = pPager->errCode;
drhd4e5cd02009-07-25 00:13:58 +00002606
danielk19771357d9f2008-09-16 05:12:24 +00002607 if( rc==SQLITE_OK ){
2608 u16 pageSize = *pPageSize;
2609 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
drh8a938f92009-07-25 04:12:02 +00002610 if( (pPager->memDb==0 || pPager->dbSize==0)
danielk19771357d9f2008-09-16 05:12:24 +00002611 && sqlite3PcacheRefCount(pPager->pPCache)==0
drh8a938f92009-07-25 04:12:02 +00002612 && pageSize && pageSize!=pPager->pageSize
danielk19771357d9f2008-09-16 05:12:24 +00002613 ){
2614 char *pNew = (char *)sqlite3PageMalloc(pageSize);
2615 if( !pNew ){
2616 rc = SQLITE_NOMEM;
2617 }else{
2618 pager_reset(pPager);
2619 pPager->pageSize = pageSize;
danielk19771357d9f2008-09-16 05:12:24 +00002620 sqlite3PageFree(pPager->pTmpSpace);
2621 pPager->pTmpSpace = pNew;
2622 sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
2623 }
danielk1977a1644fd2007-08-29 12:31:25 +00002624 }
drh4f21c4a2008-12-10 22:15:00 +00002625 *pPageSize = (u16)pPager->pageSize;
drhfa9601a2009-06-18 17:22:39 +00002626 if( nReserve<0 ) nReserve = pPager->nReserve;
2627 assert( nReserve>=0 && nReserve<1000 );
2628 pPager->nReserve = (i16)nReserve;
2629 pagerReportSize(pPager);
drh1c7880e2005-05-20 20:01:55 +00002630 }
danielk1977a1644fd2007-08-29 12:31:25 +00002631 return rc;
drh90f5ecb2004-07-22 01:19:35 +00002632}
2633
2634/*
drh26b79942007-11-28 16:19:56 +00002635** Return a pointer to the "temporary page" buffer held internally
2636** by the pager. This is a buffer that is big enough to hold the
2637** entire content of a database page. This buffer is used internally
2638** during rollback and will be overwritten whenever a rollback
2639** occurs. But other modules are free to use it too, as long as
2640** no rollbacks are happening.
2641*/
2642void *sqlite3PagerTempSpace(Pager *pPager){
2643 return pPager->pTmpSpace;
2644}
2645
2646/*
drhf8e632b2007-05-08 14:51:36 +00002647** Attempt to set the maximum database page count if mxPage is positive.
2648** Make no changes if mxPage is zero or negative. And never reduce the
2649** maximum page count below the current size of the database.
2650**
2651** Regardless of mxPage, return the current maximum page count.
2652*/
2653int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
drhb1299152010-03-30 22:58:33 +00002654 int nPage;
drhf8e632b2007-05-08 14:51:36 +00002655 if( mxPage>0 ){
2656 pPager->mxPgno = mxPage;
2657 }
drhb1299152010-03-30 22:58:33 +00002658 sqlite3PagerPagecount(pPager, &nPage);
2659 assert( pPager->mxPgno>=nPage );
drhf8e632b2007-05-08 14:51:36 +00002660 return pPager->mxPgno;
2661}
2662
2663/*
drhc9ac5ca2005-11-04 22:03:30 +00002664** The following set of routines are used to disable the simulated
2665** I/O error mechanism. These routines are used to avoid simulated
2666** errors in places where we do not care about errors.
2667**
2668** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
2669** and generate no code.
2670*/
2671#ifdef SQLITE_TEST
2672extern int sqlite3_io_error_pending;
2673extern int sqlite3_io_error_hit;
2674static int saved_cnt;
drhc9ac5ca2005-11-04 22:03:30 +00002675void disable_simulated_io_errors(void){
2676 saved_cnt = sqlite3_io_error_pending;
2677 sqlite3_io_error_pending = -1;
2678}
2679void enable_simulated_io_errors(void){
2680 sqlite3_io_error_pending = saved_cnt;
2681}
2682#else
drh152410f2005-11-05 15:11:22 +00002683# define disable_simulated_io_errors()
2684# define enable_simulated_io_errors()
drhc9ac5ca2005-11-04 22:03:30 +00002685#endif
2686
2687/*
drh90f5ecb2004-07-22 01:19:35 +00002688** Read the first N bytes from the beginning of the file into memory
danielk1977aef0bf62005-12-30 16:28:01 +00002689** that pDest points to.
2690**
danielk1977bea2a942009-01-20 17:06:27 +00002691** If the pager was opened on a transient file (zFilename==""), or
2692** opened on a file less than N bytes in size, the output buffer is
2693** zeroed and SQLITE_OK returned. The rationale for this is that this
2694** function is used to read database headers, and a new transient or
2695** zero sized database has a header than consists entirely of zeroes.
2696**
2697** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
2698** the error code is returned to the caller and the contents of the
2699** output buffer undefined.
drh90f5ecb2004-07-22 01:19:35 +00002700*/
danielk19773b8a05f2007-03-19 17:44:26 +00002701int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
drh551b7732006-11-06 21:20:25 +00002702 int rc = SQLITE_OK;
drh90f5ecb2004-07-22 01:19:35 +00002703 memset(pDest, 0, N);
danielk1977bea2a942009-01-20 17:06:27 +00002704 assert( isOpen(pPager->fd) || pPager->tempFile );
2705 if( isOpen(pPager->fd) ){
drhb0603412007-02-28 04:47:26 +00002706 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
danielk197762079062007-08-15 17:08:46 +00002707 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
drh551b7732006-11-06 21:20:25 +00002708 if( rc==SQLITE_IOERR_SHORT_READ ){
2709 rc = SQLITE_OK;
2710 }
drh90f5ecb2004-07-22 01:19:35 +00002711 }
drh551b7732006-11-06 21:20:25 +00002712 return rc;
drh90f5ecb2004-07-22 01:19:35 +00002713}
2714
2715/*
danielk1977bea2a942009-01-20 17:06:27 +00002716** Return the total number of pages in the database file associated
2717** with pPager. Normally, this is calculated as (<db file size>/<page-size>).
2718** However, if the file is between 1 and <page-size> bytes in size, then
2719** this is considered a 1 page file.
danielk197715f411d2005-09-16 10:18:45 +00002720**
danielk1977bea2a942009-01-20 17:06:27 +00002721** If the pager is in error state when this function is called, then the
2722** error state error code is returned and *pnPage left unchanged. Or,
2723** if the file system has to be queried for the size of the file and
2724** the query attempt returns an IO error, the IO error code is returned
2725** and *pnPage is left unchanged.
2726**
2727** Otherwise, if everything is successful, then SQLITE_OK is returned
2728** and *pnPage is set to the number of pages in the database.
drhed7c8552001-04-11 14:29:21 +00002729*/
danielk1977ad0132d2008-06-07 08:58:22 +00002730int sqlite3PagerPagecount(Pager *pPager, int *pnPage){
dan7c246102010-04-12 19:00:29 +00002731 Pgno nPage = 0; /* Value to return via *pnPage */
danielk1977bea2a942009-01-20 17:06:27 +00002732
danielk1977bea2a942009-01-20 17:06:27 +00002733 /* Determine the number of pages in the file. Store this in nPage. */
danielk1977d92db532008-11-17 04:56:24 +00002734 if( pPager->dbSizeValid ){
danielk1977bea2a942009-01-20 17:06:27 +00002735 nPage = pPager->dbSize;
2736 }else{
2737 int rc; /* Error returned by OsFileSize() */
2738 i64 n = 0; /* File size in bytes returned by OsFileSize() */
2739
dan7c246102010-04-12 19:00:29 +00002740 if( pagerUseLog(pPager) ){
dan8d22a172010-04-19 18:03:51 +00002741 sqlite3LogDbsize(pPager->pLog, &nPage);
danielk197715f411d2005-09-16 10:18:45 +00002742 }
dan7c246102010-04-12 19:00:29 +00002743
2744 if( nPage==0 ){
2745 assert( isOpen(pPager->fd) || pPager->tempFile );
2746 if( isOpen(pPager->fd) ){
2747 if( SQLITE_OK!=(rc = sqlite3OsFileSize(pPager->fd, &n)) ){
2748 pager_error(pPager, rc);
2749 return rc;
2750 }
2751 }
2752 if( n>0 && n<pPager->pageSize ){
2753 nPage = 1;
2754 }else{
2755 nPage = (Pgno)(n / pPager->pageSize);
2756 }
danielk197715f411d2005-09-16 10:18:45 +00002757 }
2758 if( pPager->state!=PAGER_UNLOCK ){
shaned87897d2009-01-30 05:40:27 +00002759 pPager->dbSize = nPage;
2760 pPager->dbFileSize = nPage;
danielk1977d92db532008-11-17 04:56:24 +00002761 pPager->dbSizeValid = 1;
danielk197715f411d2005-09-16 10:18:45 +00002762 }
drhed7c8552001-04-11 14:29:21 +00002763 }
danielk1977bea2a942009-01-20 17:06:27 +00002764
2765 /* If the current number of pages in the file is greater than the
2766 ** configured maximum pager number, increase the allowed limit so
2767 ** that the file can be read.
2768 */
2769 if( nPage>pPager->mxPgno ){
2770 pPager->mxPgno = (Pgno)nPage;
drh1f595712004-06-15 01:40:29 +00002771 }
danielk1977bea2a942009-01-20 17:06:27 +00002772
2773 /* Set the output variable and return SQLITE_OK */
drhb1299152010-03-30 22:58:33 +00002774 *pnPage = nPage;
danielk1977ad0132d2008-06-07 08:58:22 +00002775 return SQLITE_OK;
drhed7c8552001-04-11 14:29:21 +00002776}
2777
drhac69b052004-05-12 13:30:07 +00002778
2779/*
danielk1977bea2a942009-01-20 17:06:27 +00002780** Try to obtain a lock of type locktype on the database file. If
2781** a similar or greater lock is already held, this function is a no-op
2782** (returning SQLITE_OK immediately).
2783**
2784** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
2785** the busy callback if the lock is currently not available. Repeat
2786** until the busy callback returns false or until the attempt to
2787** obtain the lock succeeds.
danielk197717221812005-02-15 03:38:05 +00002788**
2789** Return SQLITE_OK on success and an error code if we cannot obtain
danielk1977bea2a942009-01-20 17:06:27 +00002790** the lock. If the lock is obtained successfully, set the Pager.state
2791** variable to locktype before returning.
danielk197717221812005-02-15 03:38:05 +00002792*/
2793static int pager_wait_on_lock(Pager *pPager, int locktype){
danielk1977bea2a942009-01-20 17:06:27 +00002794 int rc; /* Return code */
drh1aa2d8b2007-01-03 15:34:29 +00002795
2796 /* The OS lock values must be the same as the Pager lock values */
danielk197717221812005-02-15 03:38:05 +00002797 assert( PAGER_SHARED==SHARED_LOCK );
2798 assert( PAGER_RESERVED==RESERVED_LOCK );
2799 assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
drh1aa2d8b2007-01-03 15:34:29 +00002800
danbc7c0392009-12-02 14:44:32 +00002801 /* If the file is currently unlocked then the size must be unknown. It
2802 ** must not have been modified at this point.
2803 */
danielk1977d92db532008-11-17 04:56:24 +00002804 assert( pPager->state>=PAGER_SHARED || pPager->dbSizeValid==0 );
danbc7c0392009-12-02 14:44:32 +00002805 assert( pPager->state>=PAGER_SHARED || pPager->dbModified==0 );
drh1aa2d8b2007-01-03 15:34:29 +00002806
danielk1977bea2a942009-01-20 17:06:27 +00002807 /* Check that this is either a no-op (because the requested lock is
2808 ** already held, or one of the transistions that the busy-handler
2809 ** may be invoked during, according to the comment above
2810 ** sqlite3PagerSetBusyhandler().
2811 */
2812 assert( (pPager->state>=locktype)
2813 || (pPager->state==PAGER_UNLOCK && locktype==PAGER_SHARED)
2814 || (pPager->state==PAGER_RESERVED && locktype==PAGER_EXCLUSIVE)
2815 );
2816
danielk197717221812005-02-15 03:38:05 +00002817 if( pPager->state>=locktype ){
2818 rc = SQLITE_OK;
2819 }else{
danielk197717221812005-02-15 03:38:05 +00002820 do {
drh054889e2005-11-30 03:20:31 +00002821 rc = sqlite3OsLock(pPager->fd, locktype);
danielk19771ceedd32008-11-19 10:22:33 +00002822 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
danielk197717221812005-02-15 03:38:05 +00002823 if( rc==SQLITE_OK ){
drh4f21c4a2008-12-10 22:15:00 +00002824 pPager->state = (u8)locktype;
drhb0603412007-02-28 04:47:26 +00002825 IOTRACE(("LOCK %p %d\n", pPager, locktype))
danielk197717221812005-02-15 03:38:05 +00002826 }
2827 }
2828 return rc;
2829}
2830
danielk19773460d192008-12-27 15:23:13 +00002831/*
danielk19779f0b6be2009-07-25 11:40:07 +00002832** Function assertTruncateConstraint(pPager) checks that one of the
2833** following is true for all dirty pages currently in the page-cache:
2834**
2835** a) The page number is less than or equal to the size of the
2836** current database image, in pages, OR
2837**
2838** b) if the page content were written at this time, it would not
2839** be necessary to write the current content out to the sub-journal
2840** (as determined by function subjRequiresPage()).
2841**
2842** If the condition asserted by this function were not true, and the
2843** dirty page were to be discarded from the cache via the pagerStress()
2844** routine, pagerStress() would not write the current page content to
2845** the database file. If a savepoint transaction were rolled back after
2846** this happened, the correct behaviour would be to restore the current
2847** content of the page. However, since this content is not present in either
2848** the database file or the portion of the rollback journal and
2849** sub-journal rolled back the content could not be restored and the
2850** database image would become corrupt. It is therefore fortunate that
2851** this circumstance cannot arise.
2852*/
2853#if defined(SQLITE_DEBUG)
2854static void assertTruncateConstraintCb(PgHdr *pPg){
2855 assert( pPg->flags&PGHDR_DIRTY );
2856 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
2857}
2858static void assertTruncateConstraint(Pager *pPager){
2859 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
2860}
2861#else
2862# define assertTruncateConstraint(pPager)
2863#endif
2864
2865/*
danielk1977f90b7262009-01-07 15:18:20 +00002866** Truncate the in-memory database file image to nPage pages. This
2867** function does not actually modify the database file on disk. It
2868** just sets the internal state of the pager object so that the
2869** truncation will be done when the current transaction is committed.
danielk19773460d192008-12-27 15:23:13 +00002870*/
2871void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
2872 assert( pPager->dbSizeValid );
2873 assert( pPager->dbSize>=nPage );
danielk1977bea2a942009-01-20 17:06:27 +00002874 assert( pPager->state>=PAGER_RESERVED );
danielk19773460d192008-12-27 15:23:13 +00002875 pPager->dbSize = nPage;
danielk19779f0b6be2009-07-25 11:40:07 +00002876 assertTruncateConstraint(pPager);
danielk19773460d192008-12-27 15:23:13 +00002877}
danielk19773460d192008-12-27 15:23:13 +00002878
dan7c246102010-04-12 19:00:29 +00002879
drhf7c57532003-04-25 13:22:51 +00002880/*
daneada58a2010-04-12 17:08:44 +00002881** This function is called before attempting a hot-journal rollback. It
2882** syncs the journal file to disk, then sets pPager->journalHdr to the
2883** size of the journal file so that the pager_playback() routine knows
2884** that the entire journal file has been synced.
2885**
2886** Syncing a hot-journal to disk before attempting to roll it back ensures
2887** that if a power-failure occurs during the rollback, the process that
2888** attempts rollback following system recovery sees the same journal
2889** content as this process.
2890**
2891** If everything goes as planned, SQLITE_OK is returned. Otherwise,
2892** an SQLite error code.
2893*/
2894static int pagerSyncHotJournal(Pager *pPager){
2895 int rc = SQLITE_OK;
2896 if( !pPager->noSync ){
2897 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
2898 }
2899 if( rc==SQLITE_OK ){
2900 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
2901 }
2902 return rc;
2903}
2904
2905/*
drhed7c8552001-04-11 14:29:21 +00002906** Shutdown the page cache. Free all memory and close all files.
2907**
2908** If a transaction was in progress when this routine is called, that
2909** transaction is rolled back. All outstanding pages are invalidated
2910** and their memory is freed. Any attempt to use a page associated
2911** with this page cache after this function returns will likely
2912** result in a coredump.
danielk1977aef0bf62005-12-30 16:28:01 +00002913**
2914** This function always succeeds. If a transaction is active an attempt
2915** is made to roll it back. If an error occurs during the rollback
2916** a hot journal may be left in the filesystem but no error is returned
2917** to the caller.
drhed7c8552001-04-11 14:29:21 +00002918*/
danielk19773b8a05f2007-03-19 17:44:26 +00002919int sqlite3PagerClose(Pager *pPager){
dan7c246102010-04-12 19:00:29 +00002920 u8 *pTmp = (u8 *)pPager->pTmpSpace;
2921
drhbafda092007-01-03 23:36:22 +00002922 disable_simulated_io_errors();
danielk19772d1d86f2008-06-20 14:59:51 +00002923 sqlite3BeginBenignMalloc();
drhc2ee76c2007-01-04 14:58:14 +00002924 pPager->errCode = 0;
danielk197741483462007-03-24 16:45:04 +00002925 pPager->exclusiveMode = 0;
danc5118782010-04-17 17:34:41 +00002926 sqlite3LogClose(pPager->pLog, pPager->fd,
2927 (pPager->noSync ? 0 : pPager->sync_flags), pTmp
2928 );
dan7c246102010-04-12 19:00:29 +00002929 pPager->pLog = 0;
drhbafda092007-01-03 23:36:22 +00002930 pager_reset(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00002931 if( MEMDB ){
2932 pager_unlock(pPager);
2933 }else{
danielk1977f2c31ad2009-01-06 13:40:08 +00002934 /* Set Pager.journalHdr to -1 for the benefit of the pager_playback()
2935 ** call which may be made from within pagerUnlockAndRollback(). If it
2936 ** is not -1, then the unsynced portion of an open journal file may
2937 ** be played back into the database. If a power failure occurs while
2938 ** this is happening, the database may become corrupt.
2939 */
daneada58a2010-04-12 17:08:44 +00002940 if( isOpen(pPager->jfd) ){
2941 pPager->errCode = pagerSyncHotJournal(pPager);
2942 }
danielk1977b3175382008-10-17 18:51:52 +00002943 pagerUnlockAndRollback(pPager);
2944 }
danielk197745d68822009-01-16 16:23:38 +00002945 sqlite3EndBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00002946 enable_simulated_io_errors();
drh30d53702009-01-06 15:58:57 +00002947 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
drhb0603412007-02-28 04:47:26 +00002948 IOTRACE(("CLOSE %p\n", pPager))
danielk1977b4b47412007-08-17 15:53:36 +00002949 sqlite3OsClose(pPager->fd);
dan7c246102010-04-12 19:00:29 +00002950 sqlite3PageFree(pTmp);
danielk19778c0a7912008-08-20 14:49:23 +00002951 sqlite3PcacheClose(pPager->pPCache);
danielk1977bea2a942009-01-20 17:06:27 +00002952
drhfa9601a2009-06-18 17:22:39 +00002953#ifdef SQLITE_HAS_CODEC
2954 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
2955#endif
2956
danielk1977bea2a942009-01-20 17:06:27 +00002957 assert( !pPager->aSavepoint && !pPager->pInJournal );
2958 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
2959
drh17435752007-08-16 04:30:38 +00002960 sqlite3_free(pPager);
drhed7c8552001-04-11 14:29:21 +00002961 return SQLITE_OK;
2962}
2963
drh87cc3b32007-05-08 21:45:27 +00002964#if !defined(NDEBUG) || defined(SQLITE_TEST)
drhed7c8552001-04-11 14:29:21 +00002965/*
danielk1977bea2a942009-01-20 17:06:27 +00002966** Return the page number for page pPg.
drhed7c8552001-04-11 14:29:21 +00002967*/
danielk1977bea2a942009-01-20 17:06:27 +00002968Pgno sqlite3PagerPagenumber(DbPage *pPg){
2969 return pPg->pgno;
drhed7c8552001-04-11 14:29:21 +00002970}
drh87cc3b32007-05-08 21:45:27 +00002971#endif
drhed7c8552001-04-11 14:29:21 +00002972
2973/*
danielk1977bea2a942009-01-20 17:06:27 +00002974** Increment the reference count for page pPg.
drhdf0b3b02001-06-23 11:36:20 +00002975*/
danielk1977bea2a942009-01-20 17:06:27 +00002976void sqlite3PagerRef(DbPage *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00002977 sqlite3PcacheRef(pPg);
drh7e3b0a02001-04-28 16:52:40 +00002978}
2979
2980/*
danielk1977bea2a942009-01-20 17:06:27 +00002981** Sync the journal. In other words, make sure all the pages that have
drh34e79ce2004-02-08 06:05:46 +00002982** been written to the journal have actually reached the surface of the
danielk1977bea2a942009-01-20 17:06:27 +00002983** disk and can be restored in the event of a hot-journal rollback.
drhb19a2bc2001-09-16 00:13:26 +00002984**
danielk1977bea2a942009-01-20 17:06:27 +00002985** If the Pager.needSync flag is not set, then this function is a
2986** no-op. Otherwise, the actions required depend on the journal-mode
2987** and the device characteristics of the the file-system, as follows:
danielk19774cd2cd52007-08-23 14:48:23 +00002988**
danielk1977bea2a942009-01-20 17:06:27 +00002989** * If the journal file is an in-memory journal file, no action need
2990** be taken.
drhfa86c412002-02-02 15:01:15 +00002991**
danielk1977bea2a942009-01-20 17:06:27 +00002992** * Otherwise, if the device does not support the SAFE_APPEND property,
2993** then the nRec field of the most recently written journal header
2994** is updated to contain the number of journal records that have
2995** been written following it. If the pager is operating in full-sync
2996** mode, then the journal file is synced before this field is updated.
2997**
2998** * If the device does not support the SEQUENTIAL property, then
2999** journal file is synced.
3000**
3001** Or, in pseudo-code:
3002**
3003** if( NOT <in-memory journal> ){
3004** if( NOT SAFE_APPEND ){
3005** if( <full-sync mode> ) xSync(<journal file>);
3006** <update nRec field>
3007** }
3008** if( NOT SEQUENTIAL ) xSync(<journal file>);
3009** }
3010**
3011** The Pager.needSync flag is never be set for temporary files, or any
3012** file operating in no-sync mode (Pager.noSync set to non-zero).
3013**
3014** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
3015** page currently held in memory before returning SQLITE_OK. If an IO
3016** error is encountered, then the IO error code is returned to the caller.
drh50e5dad2001-09-15 00:57:28 +00003017*/
danielk197776572402004-06-25 02:38:54 +00003018static int syncJournal(Pager *pPager){
danielk197776572402004-06-25 02:38:54 +00003019 if( pPager->needSync ){
danielk1977b3175382008-10-17 18:51:52 +00003020 assert( !pPager->tempFile );
3021 if( pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
danielk1977bea2a942009-01-20 17:06:27 +00003022 int rc; /* Return code */
3023 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
3024 assert( isOpen(pPager->jfd) );
danielk19774cd2cd52007-08-23 14:48:23 +00003025
danielk19774cd2cd52007-08-23 14:48:23 +00003026 if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
danielk1977112f7522009-01-08 17:50:45 +00003027 /* This block deals with an obscure problem. If the last connection
3028 ** that wrote to this database was operating in persistent-journal
3029 ** mode, then the journal file may at this point actually be larger
3030 ** than Pager.journalOff bytes. If the next thing in the journal
3031 ** file happens to be a journal-header (written as part of the
drh91781bd2010-04-10 17:52:57 +00003032 ** previous connection's transaction), and a crash or power-failure
danielk1977112f7522009-01-08 17:50:45 +00003033 ** occurs after nRec is updated but before this connection writes
3034 ** anything else to the journal file (or commits/rolls back its
3035 ** transaction), then SQLite may become confused when doing the
3036 ** hot-journal rollback following recovery. It may roll back all
3037 ** of this connections data, then proceed to rolling back the old,
3038 ** out-of-date data that follows it. Database corruption.
3039 **
3040 ** To work around this, if the journal file does appear to contain
3041 ** a valid header following Pager.journalOff, then write a 0x00
3042 ** byte to the start of it to prevent it from being recognized.
danielk1977bea2a942009-01-20 17:06:27 +00003043 **
3044 ** Variable iNextHdrOffset is set to the offset at which this
3045 ** problematic header will occur, if it exists. aMagic is used
3046 ** as a temporary buffer to inspect the first couple of bytes of
3047 ** the potential journal header.
danielk1977112f7522009-01-08 17:50:45 +00003048 */
drh7b746032009-06-26 12:15:22 +00003049 i64 iNextHdrOffset;
danielk1977bea2a942009-01-20 17:06:27 +00003050 u8 aMagic[8];
danb9780022010-04-21 18:37:57 +00003051 u8 zHeader[sizeof(aJournalMagic)+4];
drh7b746032009-06-26 12:15:22 +00003052
danb9780022010-04-21 18:37:57 +00003053 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
3054 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
drh7b746032009-06-26 12:15:22 +00003055
3056 iNextHdrOffset = journalHdrOffset(pPager);
danielk1977bea2a942009-01-20 17:06:27 +00003057 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
3058 if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
danielk1977112f7522009-01-08 17:50:45 +00003059 static const u8 zerobyte = 0;
danielk1977bea2a942009-01-20 17:06:27 +00003060 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
danielk1977112f7522009-01-08 17:50:45 +00003061 }
3062 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
3063 return rc;
3064 }
3065
danielk197776572402004-06-25 02:38:54 +00003066 /* Write the nRec value into the journal file header. If in
3067 ** full-synchronous mode, sync the journal first. This ensures that
3068 ** all data has really hit the disk before nRec is updated to mark
danielk19774cd2cd52007-08-23 14:48:23 +00003069 ** it as a candidate for rollback.
3070 **
3071 ** This is not required if the persistent media supports the
3072 ** SAFE_APPEND property. Because in this case it is not possible
3073 ** for garbage data to be appended to the file, the nRec field
3074 ** is populated with 0xFFFFFFFF when the journal header is written
3075 ** and never needs to be updated.
danielk197776572402004-06-25 02:38:54 +00003076 */
danielk19774cd2cd52007-08-23 14:48:23 +00003077 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh30d53702009-01-06 15:58:57 +00003078 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
drhb0603412007-02-28 04:47:26 +00003079 IOTRACE(("JSYNC %p\n", pPager))
danielk1977f036aef2007-08-20 05:36:51 +00003080 rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags);
danielk1977bea2a942009-01-20 17:06:27 +00003081 if( rc!=SQLITE_OK ) return rc;
drhd8d66e82003-02-12 02:10:15 +00003082 }
drh7b746032009-06-26 12:15:22 +00003083 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
danielk19776f4c73e2009-06-26 07:12:06 +00003084 rc = sqlite3OsWrite(
3085 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
danb9780022010-04-21 18:37:57 +00003086 );
danielk1977bea2a942009-01-20 17:06:27 +00003087 if( rc!=SQLITE_OK ) return rc;
drh968af522003-02-11 14:55:40 +00003088 }
danielk19774cd2cd52007-08-23 14:48:23 +00003089 if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh30d53702009-01-06 15:58:57 +00003090 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
danielk19774cd2cd52007-08-23 14:48:23 +00003091 IOTRACE(("JSYNC %p\n", pPager))
3092 rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags|
3093 (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
3094 );
danielk1977bea2a942009-01-20 17:06:27 +00003095 if( rc!=SQLITE_OK ) return rc;
danielk19774cd2cd52007-08-23 14:48:23 +00003096 }
drhfa86c412002-02-02 15:01:15 +00003097 }
danielk197745d68822009-01-16 16:23:38 +00003098
danielk1977bea2a942009-01-20 17:06:27 +00003099 /* The journal file was just successfully synced. Set Pager.needSync
3100 ** to zero and clear the PGHDR_NEED_SYNC flag on all pagess.
danielk197745d68822009-01-16 16:23:38 +00003101 */
danielk1977bea2a942009-01-20 17:06:27 +00003102 pPager->needSync = 0;
3103 pPager->journalStarted = 1;
drh91781bd2010-04-10 17:52:57 +00003104 pPager->journalHdr = pPager->journalOff;
danielk1977bc2ca9e2008-11-13 14:28:28 +00003105 sqlite3PcacheClearSyncFlags(pPager->pPCache);
drh50e5dad2001-09-15 00:57:28 +00003106 }
drh03eb96a2002-11-10 23:32:56 +00003107
danielk1977bea2a942009-01-20 17:06:27 +00003108 return SQLITE_OK;
drh50e5dad2001-09-15 00:57:28 +00003109}
3110
3111/*
danielk1977bea2a942009-01-20 17:06:27 +00003112** The argument is the first in a linked list of dirty pages connected
3113** by the PgHdr.pDirty pointer. This function writes each one of the
3114** in-memory pages in the list to the database file. The argument may
3115** be NULL, representing an empty list. In this case this function is
3116** a no-op.
3117**
3118** The pager must hold at least a RESERVED lock when this function
3119** is called. Before writing anything to the database file, this lock
3120** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
3121** SQLITE_BUSY is returned and no data is written to the database file.
3122**
3123** If the pager is a temp-file pager and the actual file-system file
3124** is not yet open, it is created and opened before any data is
3125** written out.
3126**
3127** Once the lock has been upgraded and, if necessary, the file opened,
3128** the pages are written out to the database file in list order. Writing
3129** a page is skipped if it meets either of the following criteria:
3130**
3131** * The page number is greater than Pager.dbSize, or
3132** * The PGHDR_DONT_WRITE flag is set on the page.
3133**
3134** If writing out a page causes the database file to grow, Pager.dbFileSize
3135** is updated accordingly. If page 1 is written out, then the value cached
3136** in Pager.dbFileVers[] is updated to match the new value stored in
3137** the database file.
3138**
3139** If everything is successful, SQLITE_OK is returned. If an IO error
3140** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
3141** be obtained, SQLITE_BUSY is returned.
drh2554f8b2003-01-22 01:26:44 +00003142*/
3143static int pager_write_pagelist(PgHdr *pList){
danielk1977bea2a942009-01-20 17:06:27 +00003144 Pager *pPager; /* Pager object */
3145 int rc; /* Return code */
drh2554f8b2003-01-22 01:26:44 +00003146
drhfe6212d2009-07-22 13:19:20 +00003147 if( NEVER(pList==0) ) return SQLITE_OK;
drh2554f8b2003-01-22 01:26:44 +00003148 pPager = pList->pPager;
danielk19779eed5052004-06-04 10:38:30 +00003149
3150 /* At this point there may be either a RESERVED or EXCLUSIVE lock on the
3151 ** database file. If there is already an EXCLUSIVE lock, the following
danielk1977bea2a942009-01-20 17:06:27 +00003152 ** call is a no-op.
danielk19779eed5052004-06-04 10:38:30 +00003153 **
drha6abd042004-06-09 17:37:22 +00003154 ** Moving the lock from RESERVED to EXCLUSIVE actually involves going
3155 ** through an intermediate state PENDING. A PENDING lock prevents new
3156 ** readers from attaching to the database but is unsufficient for us to
3157 ** write. The idea of a PENDING lock is to prevent new readers from
3158 ** coming in while we wait for existing readers to clear.
danielk19779eed5052004-06-04 10:38:30 +00003159 **
drha6abd042004-06-09 17:37:22 +00003160 ** While the pager is in the RESERVED state, the original database file
3161 ** is unchanged and we can rollback without having to playback the
3162 ** journal into the original database file. Once we transition to
3163 ** EXCLUSIVE, it means the database file has been changed and any rollback
3164 ** will require a journal playback.
danielk19779eed5052004-06-04 10:38:30 +00003165 */
dan64d039e2010-04-13 19:27:31 +00003166 assert( !pagerUseLog(pList->pPager) );
danielk1977bea2a942009-01-20 17:06:27 +00003167 assert( pPager->state>=PAGER_RESERVED );
drh684917c2004-10-05 02:41:42 +00003168 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
danielk1977bea2a942009-01-20 17:06:27 +00003169
3170 /* If the file is a temp-file has not yet been opened, open it now. It
3171 ** is not possible for rc to be other than SQLITE_OK if this branch
3172 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
3173 */
3174 if( !isOpen(pPager->fd) ){
3175 assert( pPager->tempFile && rc==SQLITE_OK );
3176 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
danielk19779eed5052004-06-04 10:38:30 +00003177 }
3178
danielk1977bea2a942009-01-20 17:06:27 +00003179 while( rc==SQLITE_OK && pList ){
3180 Pgno pgno = pList->pgno;
danielk19777a2b1ee2007-08-21 14:27:01 +00003181
danielk1977687566d2004-11-02 12:56:41 +00003182 /* If there are dirty pages in the page cache with page numbers greater
danielk1977f90b7262009-01-07 15:18:20 +00003183 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
danielk1977687566d2004-11-02 12:56:41 +00003184 ** make the file smaller (presumably by auto-vacuum code). Do not write
3185 ** any such pages to the file.
danielk1977bea2a942009-01-20 17:06:27 +00003186 **
3187 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
drh5b47efa2010-02-12 18:18:39 +00003188 ** set (set by sqlite3PagerDontWrite()).
danielk1977687566d2004-11-02 12:56:41 +00003189 */
danielk1977bea2a942009-01-20 17:06:27 +00003190 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
drh85d2bd22009-06-11 00:47:20 +00003191 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
3192 char *pData; /* Data to write */
3193
3194 /* Encode the database */
3195 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
danielk1977443c0592009-01-16 15:21:05 +00003196
danielk1977bea2a942009-01-20 17:06:27 +00003197 /* Write out the page data. */
danielk197745d68822009-01-16 16:23:38 +00003198 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
danielk1977bea2a942009-01-20 17:06:27 +00003199
3200 /* If page 1 was just written, update Pager.dbFileVers to match
3201 ** the value now stored in the database file. If writing this
3202 ** page caused the database file to grow, update dbFileSize.
3203 */
3204 if( pgno==1 ){
danielk197745d68822009-01-16 16:23:38 +00003205 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
3206 }
danielk1977bea2a942009-01-20 17:06:27 +00003207 if( pgno>pPager->dbFileSize ){
3208 pPager->dbFileSize = pgno;
danielk197745d68822009-01-16 16:23:38 +00003209 }
danielk1977bea2a942009-01-20 17:06:27 +00003210
danielk197704103022009-02-03 16:51:24 +00003211 /* Update any backup objects copying the contents of this pager. */
drh0719ee22009-06-18 20:52:47 +00003212 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
danielk197704103022009-02-03 16:51:24 +00003213
danielk1977bea2a942009-01-20 17:06:27 +00003214 PAGERTRACE(("STORE %d page %d hash(%08x)\n",
3215 PAGERID(pPager), pgno, pager_pagehash(pList)));
3216 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
3217 PAGER_INCR(sqlite3_pager_writedb_count);
3218 PAGER_INCR(pPager->nWrite);
3219 }else{
3220 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
danielk1977687566d2004-11-02 12:56:41 +00003221 }
danielk19773c407372005-02-15 02:54:14 +00003222#ifdef SQLITE_CHECK_PAGES
3223 pList->pageHash = pager_pagehash(pList);
3224#endif
drh2554f8b2003-01-22 01:26:44 +00003225 pList = pList->pDirty;
3226 }
danielk19778c0a7912008-08-20 14:49:23 +00003227
danielk1977bea2a942009-01-20 17:06:27 +00003228 return rc;
drh2554f8b2003-01-22 01:26:44 +00003229}
3230
3231/*
danielk1977bea2a942009-01-20 17:06:27 +00003232** Append a record of the current state of page pPg to the sub-journal.
3233** It is the callers responsibility to use subjRequiresPage() to check
3234** that it is really required before calling this function.
3235**
3236** If successful, set the bit corresponding to pPg->pgno in the bitvecs
3237** for all open savepoints before returning.
3238**
3239** This function returns SQLITE_OK if everything is successful, an IO
3240** error code if the attempt to write to the sub-journal fails, or
3241** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
3242** bitvec.
danielk1977f2c31ad2009-01-06 13:40:08 +00003243*/
3244static int subjournalPage(PgHdr *pPg){
danielk1977651a52f2009-02-04 10:09:04 +00003245 int rc = SQLITE_OK;
danielk1977f2c31ad2009-01-06 13:40:08 +00003246 Pager *pPager = pPg->pPager;
danielk1977651a52f2009-02-04 10:09:04 +00003247 if( isOpen(pPager->sjfd) ){
3248 void *pData = pPg->pData;
3249 i64 offset = pPager->nSubRec*(4+pPager->pageSize);
drh85d2bd22009-06-11 00:47:20 +00003250 char *pData2;
3251
3252 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
danielk1977651a52f2009-02-04 10:09:04 +00003253 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
3254
dan7c246102010-04-12 19:00:29 +00003255 assert( pagerUseLog(pPager)
3256 || pageInJournal(pPg)
3257 || pPg->pgno>pPager->dbOrigSize
3258 );
danielk1977651a52f2009-02-04 10:09:04 +00003259 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
3260 if( rc==SQLITE_OK ){
3261 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
3262 }
danielk1977f2c31ad2009-01-06 13:40:08 +00003263 }
3264 if( rc==SQLITE_OK ){
danielk1977bea2a942009-01-20 17:06:27 +00003265 pPager->nSubRec++;
danielk1977f2c31ad2009-01-06 13:40:08 +00003266 assert( pPager->nSavepoint>0 );
3267 rc = addToSavepointBitvecs(pPager, pPg->pgno);
3268 }
3269 return rc;
3270}
3271
dan3306c4a2010-04-23 19:15:00 +00003272/*
3273** This function is a wrapper around sqlite3LogFrames(). As well as logging
3274** the contents of the list of pages headed by pList (connected by pDirty),
3275** this function notifies any active backup processes that the pages have
3276** changed.
3277*/
3278static int pagerLogFrames(
3279 Pager *pPager, /* Pager object */
3280 PgHdr *pList, /* List of frames to log */
3281 Pgno nTruncate, /* Database size after this commit */
3282 int isCommit, /* True if this is a commit */
3283 int sync_flags /* Flags to pass to OsSync() (or 0) */
3284){
3285 int rc; /* Return code */
3286
3287 assert( pPager->pLog );
3288 rc = sqlite3LogFrames(pPager->pLog,
3289 pPager->pageSize, pList, nTruncate, isCommit, sync_flags
3290 );
3291 if( rc==SQLITE_OK && pPager->pBackup ){
3292 PgHdr *p;
3293 for(p=pList; p; p=p->pDirty){
3294 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
3295 }
3296 }
3297 return rc;
3298}
danielk1977f2c31ad2009-01-06 13:40:08 +00003299
3300/*
danielk19778c0a7912008-08-20 14:49:23 +00003301** This function is called by the pcache layer when it has reached some
danielk1977bea2a942009-01-20 17:06:27 +00003302** soft memory limit. The first argument is a pointer to a Pager object
3303** (cast as a void*). The pager is always 'purgeable' (not an in-memory
3304** database). The second argument is a reference to a page that is
3305** currently dirty but has no outstanding references. The page
3306** is always associated with the Pager object passed as the first
3307** argument.
3308**
3309** The job of this function is to make pPg clean by writing its contents
3310** out to the database file, if possible. This may involve syncing the
3311** journal file.
3312**
3313** If successful, sqlite3PcacheMakeClean() is called on the page and
3314** SQLITE_OK returned. If an IO error occurs while trying to make the
3315** page clean, the IO error code is returned. If the page cannot be
3316** made clean for some other reason, but no error occurs, then SQLITE_OK
3317** is returned by sqlite3PcacheMakeClean() is not called.
drh2554f8b2003-01-22 01:26:44 +00003318*/
danielk1977a858aa22008-08-22 16:22:17 +00003319static int pagerStress(void *p, PgHdr *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00003320 Pager *pPager = (Pager *)p;
danielk19778c0a7912008-08-20 14:49:23 +00003321 int rc = SQLITE_OK;
drh8f2e9a12008-02-26 14:46:04 +00003322
danielk1977bea2a942009-01-20 17:06:27 +00003323 assert( pPg->pPager==pPager );
3324 assert( pPg->flags&PGHDR_DIRTY );
3325
dan4a4b01d2010-04-16 11:30:18 +00003326 pPg->pDirty = 0;
dan4cc6fb62010-04-15 16:45:34 +00003327 if( pagerUseLog(pPager) ){
3328 /* Write a single frame for this page to the log. */
dan3306c4a2010-04-23 19:15:00 +00003329 rc = pagerLogFrames(pPager, pPg, 0, 0, 0);
dan4cc6fb62010-04-15 16:45:34 +00003330 }else{
3331 /* The doNotSync flag is set by the sqlite3PagerWrite() function while it
3332 ** is journalling a set of two or more database pages that are stored
3333 ** on the same disk sector. Syncing the journal is not allowed while
3334 ** this is happening as it is important that all members of such a
3335 ** set of pages are synced to disk together. So, if the page this function
3336 ** is trying to make clean will require a journal sync and the doNotSync
3337 ** flag is set, return without doing anything. The pcache layer will
3338 ** just have to go ahead and allocate a new page buffer instead of
3339 ** reusing pPg.
3340 **
3341 ** Similarly, if the pager has already entered the error state, do not
3342 ** try to write the contents of pPg to disk.
3343 */
3344 if( NEVER(pPager->errCode)
3345 || (pPager->doNotSync && pPg->flags&PGHDR_NEED_SYNC)
danielk1977bea2a942009-01-20 17:06:27 +00003346 ){
dan4cc6fb62010-04-15 16:45:34 +00003347 return SQLITE_OK;
danielk1977a858aa22008-08-22 16:22:17 +00003348 }
dan4cc6fb62010-04-15 16:45:34 +00003349
3350 /* Sync the journal file if required. */
3351 if( pPg->flags&PGHDR_NEED_SYNC ){
3352 rc = syncJournal(pPager);
3353 if( rc==SQLITE_OK && pPager->fullSync &&
3354 !(pPager->journalMode==PAGER_JOURNALMODE_MEMORY) &&
3355 !(sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
3356 ){
3357 pPager->nRec = 0;
3358 rc = writeJournalHdr(pPager);
3359 }
3360 }
3361
3362 /* If the page number of this page is larger than the current size of
3363 ** the database image, it may need to be written to the sub-journal.
3364 ** This is because the call to pager_write_pagelist() below will not
3365 ** actually write data to the file in this case.
3366 **
3367 ** Consider the following sequence of events:
3368 **
3369 ** BEGIN;
3370 ** <journal page X>
3371 ** <modify page X>
3372 ** SAVEPOINT sp;
3373 ** <shrink database file to Y pages>
3374 ** pagerStress(page X)
3375 ** ROLLBACK TO sp;
3376 **
3377 ** If (X>Y), then when pagerStress is called page X will not be written
3378 ** out to the database file, but will be dropped from the cache. Then,
3379 ** following the "ROLLBACK TO sp" statement, reading page X will read
3380 ** data from the database file. This will be the copy of page X as it
3381 ** was when the transaction started, not as it was when "SAVEPOINT sp"
3382 ** was executed.
3383 **
3384 ** The solution is to write the current data for page X into the
3385 ** sub-journal file now (if it is not already there), so that it will
3386 ** be restored to its current value when the "ROLLBACK TO sp" is
3387 ** executed.
3388 */
3389 if( NEVER(
3390 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
3391 ) ){
3392 rc = subjournalPage(pPg);
3393 }
3394
3395 /* Write the contents of the page out to the database file. */
3396 if( rc==SQLITE_OK ){
dan4cc6fb62010-04-15 16:45:34 +00003397 rc = pager_write_pagelist(pPg);
3398 }
danielk1977bea2a942009-01-20 17:06:27 +00003399 }
3400
3401 /* Mark the page as clean. */
danielk1977a858aa22008-08-22 16:22:17 +00003402 if( rc==SQLITE_OK ){
drh30d53702009-01-06 15:58:57 +00003403 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
danielk1977a858aa22008-08-22 16:22:17 +00003404 sqlite3PcacheMakeClean(pPg);
danielk19778c0a7912008-08-20 14:49:23 +00003405 }
danielk1977bea2a942009-01-20 17:06:27 +00003406
3407 return pager_error(pPager, rc);
drh2554f8b2003-01-22 01:26:44 +00003408}
3409
danielk19778c0a7912008-08-20 14:49:23 +00003410
drh2554f8b2003-01-22 01:26:44 +00003411/*
danielk1977bea2a942009-01-20 17:06:27 +00003412** Allocate and initialize a new Pager object and put a pointer to it
3413** in *ppPager. The pager should eventually be freed by passing it
3414** to sqlite3PagerClose().
3415**
3416** The zFilename argument is the path to the database file to open.
3417** If zFilename is NULL then a randomly-named temporary file is created
3418** and used as the file to be cached. Temporary files are be deleted
3419** automatically when they are closed. If zFilename is ":memory:" then
3420** all information is held in cache. It is never written to disk.
3421** This can be used to implement an in-memory database.
3422**
3423** The nExtra parameter specifies the number of bytes of space allocated
3424** along with each page reference. This space is available to the user
3425** via the sqlite3PagerGetExtra() API.
3426**
3427** The flags argument is used to specify properties that affect the
3428** operation of the pager. It should be passed some bitwise combination
3429** of the PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK flags.
3430**
3431** The vfsFlags parameter is a bitmask to pass to the flags parameter
3432** of the xOpen() method of the supplied VFS when opening files.
3433**
3434** If the pager object is allocated and the specified file opened
3435** successfully, SQLITE_OK is returned and *ppPager set to point to
3436** the new pager object. If an error occurs, *ppPager is set to NULL
3437** and error code returned. This function may return SQLITE_NOMEM
3438** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
3439** various SQLITE_IO_XXX errors.
3440*/
3441int sqlite3PagerOpen(
3442 sqlite3_vfs *pVfs, /* The virtual file system to use */
3443 Pager **ppPager, /* OUT: Return the Pager structure here */
3444 const char *zFilename, /* Name of the database file to open */
3445 int nExtra, /* Extra bytes append to each in-memory page */
3446 int flags, /* flags controlling this file */
drh4775ecd2009-07-24 19:01:19 +00003447 int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */
3448 void (*xReinit)(DbPage*) /* Function to reinitialize pages */
danielk1977bea2a942009-01-20 17:06:27 +00003449){
3450 u8 *pPtr;
3451 Pager *pPager = 0; /* Pager object to allocate and return */
3452 int rc = SQLITE_OK; /* Return code */
3453 int tempFile = 0; /* True for temp files (incl. in-memory files) */
3454 int memDb = 0; /* True if this is an in-memory file */
3455 int readOnly = 0; /* True if this is a read-only file */
3456 int journalFileSize; /* Bytes to allocate for each journal fd */
3457 char *zPathname = 0; /* Full path to database file */
3458 int nPathname = 0; /* Number of bytes in zPathname */
3459 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
3460 int noReadlock = (flags & PAGER_NO_READLOCK)!=0; /* True to omit read-lock */
3461 int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */
3462 u16 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
3463
3464 /* Figure out how much space is required for each journal file-handle
3465 ** (there are two of them, the main journal and the sub-journal). This
3466 ** is the maximum space required for an in-memory journal file handle
3467 ** and a regular journal file-handle. Note that a "regular journal-handle"
3468 ** may be a wrapper capable of caching the first portion of the journal
3469 ** file in memory to implement the atomic-write optimization (see
3470 ** source file journal.c).
3471 */
3472 if( sqlite3JournalSize(pVfs)>sqlite3MemJournalSize() ){
drhea598cb2009-04-05 12:22:08 +00003473 journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
danielk1977bea2a942009-01-20 17:06:27 +00003474 }else{
drhea598cb2009-04-05 12:22:08 +00003475 journalFileSize = ROUND8(sqlite3MemJournalSize());
danielk1977bea2a942009-01-20 17:06:27 +00003476 }
3477
3478 /* Set the output variable to NULL in case an error occurs. */
3479 *ppPager = 0;
3480
3481 /* Compute and store the full pathname in an allocated buffer pointed
3482 ** to by zPathname, length nPathname. Or, if this is a temporary file,
3483 ** leave both nPathname and zPathname set to 0.
3484 */
3485 if( zFilename && zFilename[0] ){
3486 nPathname = pVfs->mxPathname+1;
3487 zPathname = sqlite3Malloc(nPathname*2);
3488 if( zPathname==0 ){
3489 return SQLITE_NOMEM;
3490 }
3491#ifndef SQLITE_OMIT_MEMORYDB
3492 if( strcmp(zFilename,":memory:")==0 ){
3493 memDb = 1;
3494 zPathname[0] = 0;
3495 }else
3496#endif
3497 {
drhe8df8002009-02-17 16:17:01 +00003498 zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
danielk1977bea2a942009-01-20 17:06:27 +00003499 rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
3500 }
3501
3502 nPathname = sqlite3Strlen30(zPathname);
3503 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
3504 /* This branch is taken when the journal path required by
3505 ** the database being opened will be more than pVfs->mxPathname
3506 ** bytes in length. This means the database cannot be opened,
3507 ** as it will not be possible to open the journal file or even
3508 ** check for a hot-journal before reading.
3509 */
drh9978c972010-02-23 17:36:32 +00003510 rc = SQLITE_CANTOPEN_BKPT;
danielk1977bea2a942009-01-20 17:06:27 +00003511 }
3512 if( rc!=SQLITE_OK ){
3513 sqlite3_free(zPathname);
3514 return rc;
3515 }
3516 }
3517
3518 /* Allocate memory for the Pager structure, PCache object, the
3519 ** three file descriptors, the database file name and the journal
3520 ** file name. The layout in memory is as follows:
3521 **
3522 ** Pager object (sizeof(Pager) bytes)
3523 ** PCache object (sqlite3PcacheSize() bytes)
3524 ** Database file handle (pVfs->szOsFile bytes)
3525 ** Sub-journal file handle (journalFileSize bytes)
3526 ** Main journal file handle (journalFileSize bytes)
3527 ** Database file name (nPathname+1 bytes)
3528 ** Journal file name (nPathname+8+1 bytes)
3529 */
3530 pPtr = (u8 *)sqlite3MallocZero(
drhea598cb2009-04-05 12:22:08 +00003531 ROUND8(sizeof(*pPager)) + /* Pager structure */
3532 ROUND8(pcacheSize) + /* PCache object */
3533 ROUND8(pVfs->szOsFile) + /* The main db file */
3534 journalFileSize * 2 + /* The two journal files */
3535 nPathname + 1 + /* zFilename */
3536 nPathname + 8 + 1 /* zJournal */
danielk1977bea2a942009-01-20 17:06:27 +00003537 );
shane60a4b532009-05-06 18:57:09 +00003538 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
danielk1977bea2a942009-01-20 17:06:27 +00003539 if( !pPtr ){
3540 sqlite3_free(zPathname);
3541 return SQLITE_NOMEM;
3542 }
3543 pPager = (Pager*)(pPtr);
drhea598cb2009-04-05 12:22:08 +00003544 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
3545 pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
3546 pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
danielk1977bea2a942009-01-20 17:06:27 +00003547 pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
3548 pPager->zFilename = (char*)(pPtr += journalFileSize);
drhea598cb2009-04-05 12:22:08 +00003549 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
danielk1977bea2a942009-01-20 17:06:27 +00003550
3551 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
3552 if( zPathname ){
3553 pPager->zJournal = (char*)(pPtr += nPathname + 1);
3554 memcpy(pPager->zFilename, zPathname, nPathname);
3555 memcpy(pPager->zJournal, zPathname, nPathname);
3556 memcpy(&pPager->zJournal[nPathname], "-journal", 8);
drhd5bc7252009-07-06 21:54:40 +00003557 if( pPager->zFilename[0]==0 ) pPager->zJournal[0] = 0;
danielk1977bea2a942009-01-20 17:06:27 +00003558 sqlite3_free(zPathname);
3559 }
3560 pPager->pVfs = pVfs;
3561 pPager->vfsFlags = vfsFlags;
3562
3563 /* Open the pager file.
3564 */
3565 if( zFilename && zFilename[0] && !memDb ){
3566 int fout = 0; /* VFS flags returned by xOpen() */
3567 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
3568 readOnly = (fout&SQLITE_OPEN_READONLY);
3569
3570 /* If the file was successfully opened for read/write access,
3571 ** choose a default page size in case we have to create the
3572 ** database file. The default page size is the maximum of:
3573 **
3574 ** + SQLITE_DEFAULT_PAGE_SIZE,
3575 ** + The value returned by sqlite3OsSectorSize()
3576 ** + The largest page size that can be written atomically.
3577 */
3578 if( rc==SQLITE_OK && !readOnly ){
3579 setSectorSize(pPager);
shaned87897d2009-01-30 05:40:27 +00003580 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
danielk1977bea2a942009-01-20 17:06:27 +00003581 if( szPageDflt<pPager->sectorSize ){
shaned87897d2009-01-30 05:40:27 +00003582 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
3583 szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
3584 }else{
3585 szPageDflt = (u16)pPager->sectorSize;
3586 }
danielk1977bea2a942009-01-20 17:06:27 +00003587 }
3588#ifdef SQLITE_ENABLE_ATOMIC_WRITE
3589 {
3590 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
3591 int ii;
3592 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
3593 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
3594 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
3595 for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
3596 if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
3597 szPageDflt = ii;
3598 }
3599 }
3600 }
3601#endif
danielk1977bea2a942009-01-20 17:06:27 +00003602 }
3603 }else{
3604 /* If a temporary file is requested, it is not opened immediately.
3605 ** In this case we accept the default page size and delay actually
3606 ** opening the file until the first call to OsWrite().
3607 **
3608 ** This branch is also run for an in-memory database. An in-memory
3609 ** database is the same as a temp-file that is never written out to
3610 ** disk and uses an in-memory rollback journal.
3611 */
3612 tempFile = 1;
3613 pPager->state = PAGER_EXCLUSIVE;
drhaed24602009-06-11 17:32:45 +00003614 readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
danielk1977bea2a942009-01-20 17:06:27 +00003615 }
3616
3617 /* The following call to PagerSetPagesize() serves to set the value of
3618 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
3619 */
3620 if( rc==SQLITE_OK ){
3621 assert( pPager->memDb==0 );
drhfa9601a2009-06-18 17:22:39 +00003622 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
danielk1977bea2a942009-01-20 17:06:27 +00003623 testcase( rc!=SQLITE_OK );
3624 }
3625
shanebe217792009-03-05 04:20:31 +00003626 /* If an error occurred in either of the blocks above, free the
danielk1977bea2a942009-01-20 17:06:27 +00003627 ** Pager structure and close the file.
3628 */
3629 if( rc!=SQLITE_OK ){
3630 assert( !pPager->pTmpSpace );
3631 sqlite3OsClose(pPager->fd);
3632 sqlite3_free(pPager);
3633 return rc;
3634 }
3635
3636 /* Initialize the PCache object. */
drhfa9601a2009-06-18 17:22:39 +00003637 assert( nExtra<1000 );
danielk1977bc739712009-03-23 04:33:32 +00003638 nExtra = ROUND8(nExtra);
danielk1977bea2a942009-01-20 17:06:27 +00003639 sqlite3PcacheOpen(szPageDflt, nExtra, !memDb,
3640 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
3641
3642 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
3643 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
3644
3645 pPager->useJournal = (u8)useJournal;
3646 pPager->noReadlock = (noReadlock && readOnly) ?1:0;
3647 /* pPager->stmtOpen = 0; */
3648 /* pPager->stmtInUse = 0; */
3649 /* pPager->nRef = 0; */
3650 pPager->dbSizeValid = (u8)memDb;
3651 /* pPager->stmtSize = 0; */
3652 /* pPager->stmtJSize = 0; */
3653 /* pPager->nPage = 0; */
3654 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
3655 /* pPager->state = PAGER_UNLOCK; */
3656 assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
3657 /* pPager->errMask = 0; */
3658 pPager->tempFile = (u8)tempFile;
3659 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
3660 || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
3661 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
3662 pPager->exclusiveMode = (u8)tempFile;
3663 pPager->changeCountDone = pPager->tempFile;
3664 pPager->memDb = (u8)memDb;
3665 pPager->readOnly = (u8)readOnly;
3666 /* pPager->needSync = 0; */
drh4775ecd2009-07-24 19:01:19 +00003667 assert( useJournal || pPager->tempFile );
3668 pPager->noSync = pPager->tempFile;
danielk1977bea2a942009-01-20 17:06:27 +00003669 pPager->fullSync = pPager->noSync ?0:1;
3670 pPager->sync_flags = SQLITE_SYNC_NORMAL;
3671 /* pPager->pFirst = 0; */
3672 /* pPager->pFirstSynced = 0; */
3673 /* pPager->pLast = 0; */
drhfa9601a2009-06-18 17:22:39 +00003674 pPager->nExtra = (u16)nExtra;
danielk1977bea2a942009-01-20 17:06:27 +00003675 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
3676 assert( isOpen(pPager->fd) || tempFile );
3677 setSectorSize(pPager);
drh4775ecd2009-07-24 19:01:19 +00003678 if( !useJournal ){
3679 pPager->journalMode = PAGER_JOURNALMODE_OFF;
3680 }else if( memDb ){
danielk1977bea2a942009-01-20 17:06:27 +00003681 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
3682 }
3683 /* pPager->xBusyHandler = 0; */
3684 /* pPager->pBusyHandlerArg = 0; */
drh4775ecd2009-07-24 19:01:19 +00003685 pPager->xReiniter = xReinit;
danielk1977bea2a942009-01-20 17:06:27 +00003686 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
drh29391c52010-03-05 20:17:45 +00003687
danielk1977bea2a942009-01-20 17:06:27 +00003688 *ppPager = pPager;
3689 return SQLITE_OK;
3690}
3691
3692
3693
3694/*
3695** This function is called after transitioning from PAGER_UNLOCK to
3696** PAGER_SHARED state. It tests if there is a hot journal present in
3697** the file-system for the given pager. A hot journal is one that
3698** needs to be played back. According to this function, a hot-journal
danielk1977ee8b7992009-03-26 17:13:06 +00003699** file exists if the following criteria are met:
danielk1977bea2a942009-01-20 17:06:27 +00003700**
3701** * The journal file exists in the file system, and
3702** * No process holds a RESERVED or greater lock on the database file, and
danielk1977ee8b7992009-03-26 17:13:06 +00003703** * The database file itself is greater than 0 bytes in size, and
3704** * The first byte of the journal file exists and is not 0x00.
drh165ffe92005-03-15 17:09:30 +00003705**
3706** If the current size of the database file is 0 but a journal file
3707** exists, that is probably an old journal left over from a prior
danielk1977bea2a942009-01-20 17:06:27 +00003708** database with the same name. In this case the journal file is
3709** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
3710** is returned.
drh82ed1e52008-04-25 12:25:42 +00003711**
danielk1977ee8b7992009-03-26 17:13:06 +00003712** This routine does not check if there is a master journal filename
3713** at the end of the file. If there is, and that master journal file
3714** does not exist, then the journal file is not really hot. In this
3715** case this routine will return a false-positive. The pager_playback()
3716** routine will discover that the journal file is not really hot and
3717** will not roll it back.
danielk1977bea2a942009-01-20 17:06:27 +00003718**
3719** If a hot-journal file is found to exist, *pExists is set to 1 and
3720** SQLITE_OK returned. If no hot-journal file is present, *pExists is
3721** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
3722** to determine whether or not a hot-journal file exists, the IO error
3723** code is returned and the value of *pExists is undefined.
drh165ffe92005-03-15 17:09:30 +00003724*/
danielk1977d300b8a2008-08-01 10:50:23 +00003725static int hasHotJournal(Pager *pPager, int *pExists){
danielk1977bea2a942009-01-20 17:06:27 +00003726 sqlite3_vfs * const pVfs = pPager->pVfs;
3727 int rc; /* Return code */
danielk1977ee8b7992009-03-26 17:13:06 +00003728 int exists; /* True if a journal file is present */
danielk1977bea2a942009-01-20 17:06:27 +00003729
drh0a846f92008-08-25 17:23:29 +00003730 assert( pPager!=0 );
drhd05c2232009-07-24 21:23:15 +00003731 assert( pPager->useJournal );
danielk1977bea2a942009-01-20 17:06:27 +00003732 assert( isOpen(pPager->fd) );
danielk1977ee8b7992009-03-26 17:13:06 +00003733 assert( !isOpen(pPager->jfd) );
drh8a938f92009-07-25 04:12:02 +00003734 assert( pPager->state <= PAGER_SHARED );
danielk1977bea2a942009-01-20 17:06:27 +00003735
danielk1977d300b8a2008-08-01 10:50:23 +00003736 *pExists = 0;
drh0a846f92008-08-25 17:23:29 +00003737 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
3738 if( rc==SQLITE_OK && exists ){
danielk1977ee8b7992009-03-26 17:13:06 +00003739 int locked; /* True if some process holds a RESERVED lock */
drhf0039ad2009-05-29 00:30:30 +00003740
3741 /* Race condition here: Another process might have been holding the
3742 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
3743 ** call above, but then delete the journal and drop the lock before
3744 ** we get to the following sqlite3OsCheckReservedLock() call. If that
3745 ** is the case, this routine might think there is a hot journal when
3746 ** in fact there is none. This results in a false-positive which will
drh9fe769f2009-05-29 11:57:38 +00003747 ** be dealt with by the playback routine. Ticket #3883.
drhf0039ad2009-05-29 00:30:30 +00003748 */
drh0a846f92008-08-25 17:23:29 +00003749 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
danielk1977bea2a942009-01-20 17:06:27 +00003750 if( rc==SQLITE_OK && !locked ){
3751 int nPage;
danielk1977ee8b7992009-03-26 17:13:06 +00003752
3753 /* Check the size of the database file. If it consists of 0 pages,
3754 ** then delete the journal file. See the header comment above for
drhf0039ad2009-05-29 00:30:30 +00003755 ** the reasoning here. Delete the obsolete journal file under
drh9fe769f2009-05-29 11:57:38 +00003756 ** a RESERVED lock to avoid race conditions and to avoid violating
3757 ** [H33020].
danielk1977ee8b7992009-03-26 17:13:06 +00003758 */
danielk1977bea2a942009-01-20 17:06:27 +00003759 rc = sqlite3PagerPagecount(pPager, &nPage);
3760 if( rc==SQLITE_OK ){
danielk1977ee8b7992009-03-26 17:13:06 +00003761 if( nPage==0 ){
drhcc0acb22009-05-29 10:55:29 +00003762 sqlite3BeginBenignMalloc();
drh8a938f92009-07-25 04:12:02 +00003763 if( sqlite3OsLock(pPager->fd, RESERVED_LOCK)==SQLITE_OK ){
drhf0039ad2009-05-29 00:30:30 +00003764 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
drh8a938f92009-07-25 04:12:02 +00003765 sqlite3OsUnlock(pPager->fd, SHARED_LOCK);
drhf0039ad2009-05-29 00:30:30 +00003766 }
drhcc0acb22009-05-29 10:55:29 +00003767 sqlite3EndBenignMalloc();
danielk1977bea2a942009-01-20 17:06:27 +00003768 }else{
danielk1977ee8b7992009-03-26 17:13:06 +00003769 /* The journal file exists and no other connection has a reserved
3770 ** or greater lock on the database file. Now check that there is
3771 ** at least one non-zero bytes at the start of the journal file.
3772 ** If there is, then we consider this journal to be hot. If not,
3773 ** it can be ignored.
3774 */
3775 int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
3776 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
3777 if( rc==SQLITE_OK ){
3778 u8 first = 0;
3779 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
3780 if( rc==SQLITE_IOERR_SHORT_READ ){
3781 rc = SQLITE_OK;
3782 }
3783 sqlite3OsClose(pPager->jfd);
3784 *pExists = (first!=0);
drhcc0acb22009-05-29 10:55:29 +00003785 }else if( rc==SQLITE_CANTOPEN ){
drhf0039ad2009-05-29 00:30:30 +00003786 /* If we cannot open the rollback journal file in order to see if
3787 ** its has a zero header, that might be due to an I/O error, or
3788 ** it might be due to the race condition described above and in
3789 ** ticket #3883. Either way, assume that the journal is hot.
3790 ** This might be a false positive. But if it is, then the
3791 ** automatic journal playback and recovery mechanism will deal
3792 ** with it under an EXCLUSIVE lock where we do not need to
3793 ** worry so much with race conditions.
3794 */
3795 *pExists = 1;
3796 rc = SQLITE_OK;
danielk1977ee8b7992009-03-26 17:13:06 +00003797 }
danielk1977bea2a942009-01-20 17:06:27 +00003798 }
danielk1977861f7452008-06-05 11:39:11 +00003799 }
3800 }
drhbb5f18d2007-04-06 18:23:17 +00003801 }
danielk1977ee8b7992009-03-26 17:13:06 +00003802
danielk1977d300b8a2008-08-01 10:50:23 +00003803 return rc;
drh165ffe92005-03-15 17:09:30 +00003804}
3805
dana470aeb2010-04-21 11:43:38 +00003806/*
3807** Check if the *-wal file that corresponds to the database opened by pPager
3808** exists. Assuming no error occurs, set *pExists to 1 if the file exists,
3809** or 0 otherwise and return SQLITE_OK. If an IO or OOM error occurs, return
3810** an SQLite error code.
3811**
3812** The caller must hold a SHARED lock on the database file to call this
danede6eb82010-04-22 06:27:04 +00003813** function. Because an EXCLUSIVE lock on the db file is required to delete
3814** a WAL, this ensures there is no race condition between the xAccess()
3815** below and an xDelete() being executed by some other connection.
dana470aeb2010-04-21 11:43:38 +00003816*/
3817static int pagerHasWAL(Pager *pPager, int *pExists){
3818 int rc; /* Return code */
3819
dana470aeb2010-04-21 11:43:38 +00003820 if( !pPager->tempFile ){
3821 char *zLog = sqlite3_mprintf("%s-wal", pPager->zFilename);
3822 if( !zLog ){
3823 rc = SQLITE_NOMEM;
3824 }else{
3825 rc = sqlite3OsAccess(pPager->pVfs, zLog, SQLITE_ACCESS_EXISTS, pExists);
3826 sqlite3_free(zLog);
3827 }
3828 }else{
3829 rc = SQLITE_OK;
3830 *pExists = 0;
3831 }
3832 return rc;
3833}
3834
3835static int pagerOpenSnapshot(Pager *pPager){
dance4f05f2010-04-22 19:14:13 +00003836 int rc; /* Return code */
3837 int changed = 0; /* True if cache must be reset */
dana470aeb2010-04-21 11:43:38 +00003838
3839 assert( pagerUseLog(pPager) );
3840
3841 rc = sqlite3LogOpenSnapshot(pPager->pLog, &changed);
3842 if( rc==SQLITE_OK ){
3843 int dummy;
3844 if( changed ){
dance4f05f2010-04-22 19:14:13 +00003845 pager_reset(pPager);
3846 assert( pPager->errCode || pPager->dbSizeValid==0 );
dana470aeb2010-04-21 11:43:38 +00003847 }
3848 rc = sqlite3PagerPagecount(pPager, &dummy);
3849 }
3850 pPager->state = PAGER_SHARED;
3851
3852 return rc;
3853}
dan3de777f2010-04-17 12:31:37 +00003854
3855/*
danielk197789bc4bc2009-07-21 19:25:24 +00003856** This function is called to obtain a shared lock on the database file.
3857** It is illegal to call sqlite3PagerAcquire() until after this function
3858** has been successfully called. If a shared-lock is already held when
3859** this function is called, it is a no-op.
3860**
3861** The following operations are also performed by this function.
danielk1977393f0682007-03-31 10:00:48 +00003862**
danielk1977bea2a942009-01-20 17:06:27 +00003863** 1) If the pager is currently in PAGER_UNLOCK state (no lock held
3864** on the database file), then an attempt is made to obtain a
3865** SHARED lock on the database file. Immediately after obtaining
3866** the SHARED lock, the file-system is checked for a hot-journal,
3867** which is played back if present. Following any hot-journal
3868** rollback, the contents of the cache are validated by checking
3869** the 'change-counter' field of the database file header and
3870** discarded if they are found to be invalid.
3871**
3872** 2) If the pager is running in exclusive-mode, and there are currently
3873** no outstanding references to any pages, and is in the error state,
3874** then an attempt is made to clear the error state by discarding
3875** the contents of the page cache and rolling back any open journal
3876** file.
3877**
3878** If the operation described by (2) above is not attempted, and if the
3879** pager is in an error state other than SQLITE_FULL when this is called,
3880** the error state error code is returned. It is permitted to read the
3881** database when in SQLITE_FULL error state.
3882**
3883** Otherwise, if everything is successful, SQLITE_OK is returned. If an
3884** IO error occurs while locking the database, checking for a hot-journal
3885** file or rolling back a journal file, the IO error code is returned.
danielk1977e277be02007-03-23 18:12:06 +00003886*/
danielk197789bc4bc2009-07-21 19:25:24 +00003887int sqlite3PagerSharedLock(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00003888 int rc = SQLITE_OK; /* Return code */
3889 int isErrorReset = 0; /* True if recovering from error state */
danielk1977e277be02007-03-23 18:12:06 +00003890
drh8a938f92009-07-25 04:12:02 +00003891 /* This routine is only called from b-tree and only when there are no
3892 ** outstanding pages */
3893 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
danielk1977c7ca8752009-07-25 17:39:13 +00003894 if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
drh8a938f92009-07-25 04:12:02 +00003895
3896 /* If this database is in an error-state, now is a chance to clear
3897 ** the error. Discard the contents of the pager-cache and rollback
3898 ** any hot journal in the file-system.
danielk1977ae72d982007-10-03 08:46:44 +00003899 */
danielk1977c7ca8752009-07-25 17:39:13 +00003900 if( pPager->errCode ){
danielk19773a1bf712009-06-20 18:52:49 +00003901 if( isOpen(pPager->jfd) || pPager->zJournal ){
3902 isErrorReset = 1;
3903 }
danielk1977ae72d982007-10-03 08:46:44 +00003904 pPager->errCode = SQLITE_OK;
danielk197793f7af92008-05-09 16:57:50 +00003905 pager_reset(pPager);
danielk1977ae72d982007-10-03 08:46:44 +00003906 }
3907
dane04dc882010-04-20 18:53:15 +00003908 if( pagerUseLog(pPager) ){
dana470aeb2010-04-21 11:43:38 +00003909 rc = pagerOpenSnapshot(pPager);
dan7c246102010-04-12 19:00:29 +00003910 }else if( pPager->state==PAGER_UNLOCK || isErrorReset ){
danielk1977bea2a942009-01-20 17:06:27 +00003911 sqlite3_vfs * const pVfs = pPager->pVfs;
drh4f21c4a2008-12-10 22:15:00 +00003912 int isHotJournal = 0;
dana470aeb2010-04-21 11:43:38 +00003913 int isWal = 0;
shane049fc212008-10-22 16:26:47 +00003914 assert( !MEMDB );
danielk1977b3175382008-10-17 18:51:52 +00003915 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
dan9281bf22010-04-13 11:18:40 +00003916 if( pPager->noReadlock ){
3917 assert( pPager->readOnly );
3918 pPager->state = PAGER_SHARED;
3919 }else{
3920 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
3921 if( rc!=SQLITE_OK ){
3922 assert( pPager->state==PAGER_UNLOCK );
3923 return pager_error(pPager, rc);
3924 }
3925 }
3926 assert( pPager->state>=SHARED_LOCK );
danielk1977b3175382008-10-17 18:51:52 +00003927
3928 /* If a journal file exists, and there is no RESERVED lock on the
3929 ** database file, then it either needs to be played back or deleted.
3930 */
3931 if( !isErrorReset ){
drh8a938f92009-07-25 04:12:02 +00003932 assert( pPager->state <= PAGER_SHARED );
danielk1977b3175382008-10-17 18:51:52 +00003933 rc = hasHotJournal(pPager, &isHotJournal);
3934 if( rc!=SQLITE_OK ){
3935 goto failed;
3936 }
3937 }
3938 if( isErrorReset || isHotJournal ){
3939 /* Get an EXCLUSIVE lock on the database file. At this point it is
3940 ** important that a RESERVED lock is not obtained on the way to the
3941 ** EXCLUSIVE lock. If it were, another process might open the
3942 ** database file, detect the RESERVED lock, and conclude that the
danielk1977bea2a942009-01-20 17:06:27 +00003943 ** database is safe to read while this process is still rolling the
3944 ** hot-journal back.
danielk1977b3175382008-10-17 18:51:52 +00003945 **
danielk1977bea2a942009-01-20 17:06:27 +00003946 ** Because the intermediate RESERVED lock is not requested, any
3947 ** other process attempting to access the database file will get to
3948 ** this point in the code and fail to obtain its own EXCLUSIVE lock
3949 ** on the database file.
danielk1977e277be02007-03-23 18:12:06 +00003950 */
danielk1977b3175382008-10-17 18:51:52 +00003951 if( pPager->state<EXCLUSIVE_LOCK ){
3952 rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
danielk1977e277be02007-03-23 18:12:06 +00003953 if( rc!=SQLITE_OK ){
danielk197752b472a2008-05-05 16:23:55 +00003954 rc = pager_error(pPager, rc);
3955 goto failed;
danielk1977e277be02007-03-23 18:12:06 +00003956 }
danielk1977b3175382008-10-17 18:51:52 +00003957 pPager->state = PAGER_EXCLUSIVE;
3958 }
3959
3960 /* Open the journal for read/write access. This is because in
3961 ** exclusive-access mode the file descriptor will be kept open and
3962 ** possibly used for a transaction later on. On some systems, the
3963 ** OsTruncate() call used in exclusive-access mode also requires
3964 ** a read/write file handle.
3965 */
danielk1977bea2a942009-01-20 17:06:27 +00003966 if( !isOpen(pPager->jfd) ){
danielk1977b3175382008-10-17 18:51:52 +00003967 int res;
3968 rc = sqlite3OsAccess(pVfs,pPager->zJournal,SQLITE_ACCESS_EXISTS,&res);
3969 if( rc==SQLITE_OK ){
3970 if( res ){
3971 int fout = 0;
3972 int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
3973 assert( !pPager->tempFile );
3974 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
danielk1977bea2a942009-01-20 17:06:27 +00003975 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
danielk1977281d8bd2008-10-29 07:01:56 +00003976 if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
drh9978c972010-02-23 17:36:32 +00003977 rc = SQLITE_CANTOPEN_BKPT;
danielk1977b3175382008-10-17 18:51:52 +00003978 sqlite3OsClose(pPager->jfd);
3979 }
3980 }else{
danielk1977641a0bd2009-06-20 11:54:39 +00003981 /* If the journal does not exist, it usually means that some
3982 ** other connection managed to get in and roll it back before
3983 ** this connection obtained the exclusive lock above. Or, it
3984 ** may mean that the pager was in the error-state when this
3985 ** function was called and the journal file does not exist. */
3986 rc = pager_end_transaction(pPager, 0);
danielk1977b3175382008-10-17 18:51:52 +00003987 }
3988 }
3989 }
3990 if( rc!=SQLITE_OK ){
danielk1977b3175382008-10-17 18:51:52 +00003991 goto failed;
3992 }
danielk1977bea2a942009-01-20 17:06:27 +00003993
drh91781bd2010-04-10 17:52:57 +00003994 /* Reset the journal status fields to indicates that we have no
3995 ** rollback journal at this time. */
danielk1977b3175382008-10-17 18:51:52 +00003996 pPager->journalStarted = 0;
3997 pPager->journalOff = 0;
3998 pPager->setMaster = 0;
3999 pPager->journalHdr = 0;
dan7c246102010-04-12 19:00:29 +00004000
drh91781bd2010-04-10 17:52:57 +00004001 /* Make sure the journal file has been synced to disk. */
danielk1977b3175382008-10-17 18:51:52 +00004002
4003 /* Playback and delete the journal. Drop the database write
danielk1977112f7522009-01-08 17:50:45 +00004004 ** lock and reacquire the read lock. Purge the cache before
4005 ** playing back the hot-journal so that we don't end up with
drh91781bd2010-04-10 17:52:57 +00004006 ** an inconsistent cache. Sync the hot journal before playing
4007 ** it back since the process that crashed and left the hot journal
4008 ** probably did not sync it and we are required to always sync
4009 ** the journal before playing it back.
danielk1977b3175382008-10-17 18:51:52 +00004010 */
danielk1977641a0bd2009-06-20 11:54:39 +00004011 if( isOpen(pPager->jfd) ){
daneada58a2010-04-12 17:08:44 +00004012 rc = pagerSyncHotJournal(pPager);
drh91781bd2010-04-10 17:52:57 +00004013 if( rc==SQLITE_OK ){
4014 rc = pager_playback(pPager, 1);
4015 }
danielk1977641a0bd2009-06-20 11:54:39 +00004016 if( rc!=SQLITE_OK ){
4017 rc = pager_error(pPager, rc);
4018 goto failed;
4019 }
danielk1977b3175382008-10-17 18:51:52 +00004020 }
danielk1977bea2a942009-01-20 17:06:27 +00004021 assert( (pPager->state==PAGER_SHARED)
4022 || (pPager->exclusiveMode && pPager->state>PAGER_SHARED)
danielk1977b3175382008-10-17 18:51:52 +00004023 );
4024 }
4025
danielk1977e70f4f62009-05-13 07:52:06 +00004026 if( pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0 ){
danielk1977b3175382008-10-17 18:51:52 +00004027 /* The shared-lock has just been acquired on the database file
4028 ** and there are already pages in the cache (from a previous
4029 ** read or write transaction). Check to see if the database
4030 ** has been modified. If the database has changed, flush the
4031 ** cache.
4032 **
4033 ** Database changes is detected by looking at 15 bytes beginning
4034 ** at offset 24 into the file. The first 4 of these 16 bytes are
4035 ** a 32-bit counter that is incremented with each change. The
4036 ** other bytes change randomly with each file change when
4037 ** a codec is in use.
4038 **
4039 ** There is a vanishingly small chance that a change will not be
4040 ** detected. The chance of an undetected change is so small that
4041 ** it can be neglected.
4042 */
drhb1299152010-03-30 22:58:33 +00004043 int nPage;
danielk1977b3175382008-10-17 18:51:52 +00004044 char dbFileVers[sizeof(pPager->dbFileVers)];
drhb1299152010-03-30 22:58:33 +00004045 sqlite3PagerPagecount(pPager, &nPage);
danielk1977b3175382008-10-17 18:51:52 +00004046
4047 if( pPager->errCode ){
4048 rc = pPager->errCode;
4049 goto failed;
danielk1977e277be02007-03-23 18:12:06 +00004050 }
4051
drhb1299152010-03-30 22:58:33 +00004052 if( nPage>0 ){
danielk1977b3175382008-10-17 18:51:52 +00004053 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
4054 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
4055 if( rc!=SQLITE_OK ){
danielk197752b472a2008-05-05 16:23:55 +00004056 goto failed;
danielk1977e277be02007-03-23 18:12:06 +00004057 }
danielk1977b3175382008-10-17 18:51:52 +00004058 }else{
4059 memset(dbFileVers, 0, sizeof(dbFileVers));
4060 }
danielk1977e277be02007-03-23 18:12:06 +00004061
danielk1977b3175382008-10-17 18:51:52 +00004062 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
4063 pager_reset(pPager);
danielk1977e277be02007-03-23 18:12:06 +00004064 }
4065 }
danielk19770371f1b2009-01-09 17:11:04 +00004066 assert( pPager->exclusiveMode || pPager->state==PAGER_SHARED );
dane04dc882010-04-20 18:53:15 +00004067
dana470aeb2010-04-21 11:43:38 +00004068 rc = pagerHasWAL(pPager, &isWal);
4069 if( rc!=SQLITE_OK ){
4070 goto failed;
4071 }
4072 if( isWal ){
4073 pager_reset(pPager);
4074 rc = sqlite3PagerOpenLog(pPager, 0);
4075 if( rc==SQLITE_OK ){
4076 rc = pagerOpenSnapshot(pPager);
4077 }
4078 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
dane04dc882010-04-20 18:53:15 +00004079 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
4080 }
danielk1977e277be02007-03-23 18:12:06 +00004081 }
4082
danielk197752b472a2008-05-05 16:23:55 +00004083 failed:
4084 if( rc!=SQLITE_OK ){
4085 /* pager_unlock() is a no-op for exclusive mode and in-memory databases. */
4086 pager_unlock(pPager);
4087 }
danielk1977e277be02007-03-23 18:12:06 +00004088 return rc;
4089}
4090
4091/*
danielk1977bea2a942009-01-20 17:06:27 +00004092** If the reference count has reached zero, rollback any active
4093** transaction and unlock the pager.
drh59813952009-04-20 11:34:26 +00004094**
4095** Except, in locking_mode=EXCLUSIVE when there is nothing to in
4096** the rollback journal, the unlock is not performed and there is
4097** nothing to rollback, so this routine is a no-op.
danielk19778c0a7912008-08-20 14:49:23 +00004098*/
4099static void pagerUnlockIfUnused(Pager *pPager){
drh59813952009-04-20 11:34:26 +00004100 if( (sqlite3PcacheRefCount(pPager->pPCache)==0)
4101 && (!pPager->exclusiveMode || pPager->journalOff>0)
4102 ){
danielk19778c0a7912008-08-20 14:49:23 +00004103 pagerUnlockAndRollback(pPager);
4104 }
4105}
4106
4107/*
danielk1977bea2a942009-01-20 17:06:27 +00004108** Acquire a reference to page number pgno in pager pPager (a page
4109** reference has type DbPage*). If the requested reference is
4110** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
drhd9b02572001-04-15 00:37:09 +00004111**
danielk1977bea2a942009-01-20 17:06:27 +00004112** If the requested page is already in the cache, it is returned.
4113** Otherwise, a new page object is allocated and populated with data
4114** read from the database file. In some cases, the pcache module may
4115** choose not to allocate a new page object and may reuse an existing
4116** object with no outstanding references.
4117**
4118** The extra data appended to a page is always initialized to zeros the
4119** first time a page is loaded into memory. If the page requested is
4120** already in the cache when this function is called, then the extra
4121** data is left as it was when the page object was last used.
4122**
4123** If the database image is smaller than the requested page or if a
4124** non-zero value is passed as the noContent parameter and the
4125** requested page is not already stored in the cache, then no
4126** actual disk read occurs. In this case the memory image of the
4127** page is initialized to all zeros.
4128**
4129** If noContent is true, it means that we do not care about the contents
4130** of the page. This occurs in two seperate scenarios:
4131**
4132** a) When reading a free-list leaf page from the database, and
4133**
4134** b) When a savepoint is being rolled back and we need to load
drh91781bd2010-04-10 17:52:57 +00004135** a new page into the cache to be filled with the data read
danielk1977bea2a942009-01-20 17:06:27 +00004136** from the savepoint journal.
4137**
4138** If noContent is true, then the data returned is zeroed instead of
4139** being read from the database. Additionally, the bits corresponding
4140** to pgno in Pager.pInJournal (bitvec of pages already written to the
4141** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
4142** savepoints are set. This means if the page is made writable at any
4143** point in the future, using a call to sqlite3PagerWrite(), its contents
4144** will not be journaled. This saves IO.
drh306dc212001-05-21 13:45:10 +00004145**
drhd9b02572001-04-15 00:37:09 +00004146** The acquisition might fail for several reasons. In all cases,
4147** an appropriate error code is returned and *ppPage is set to NULL.
drh7e3b0a02001-04-28 16:52:40 +00004148**
drhd33d5a82007-04-26 12:11:28 +00004149** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
drh7e3b0a02001-04-28 16:52:40 +00004150** to find a page in the in-memory cache first. If the page is not already
drhd33d5a82007-04-26 12:11:28 +00004151** in memory, this routine goes to disk to read it in whereas Lookup()
drh7e3b0a02001-04-28 16:52:40 +00004152** just returns 0. This routine acquires a read-lock the first time it
4153** has to go to disk, and could also playback an old journal if necessary.
drhd33d5a82007-04-26 12:11:28 +00004154** Since Lookup() never goes to disk, it never has to deal with locks
drh7e3b0a02001-04-28 16:52:40 +00004155** or journal files.
drhed7c8552001-04-11 14:29:21 +00004156*/
danielk197765e0ff32008-09-19 09:14:43 +00004157int sqlite3PagerAcquire(
drh538f5702007-04-13 02:14:30 +00004158 Pager *pPager, /* The pager open on the database file */
4159 Pgno pgno, /* Page number to fetch */
4160 DbPage **ppPage, /* Write a pointer to the page here */
4161 int noContent /* Do not bother reading content from disk if true */
4162){
drh165ffe92005-03-15 17:09:30 +00004163 int rc;
danielk197789bc4bc2009-07-21 19:25:24 +00004164 PgHdr *pPg;
drhed7c8552001-04-11 14:29:21 +00004165
danielk1977bea2a942009-01-20 17:06:27 +00004166 assert( assert_pager_state(pPager) );
danielk197789bc4bc2009-07-21 19:25:24 +00004167 assert( pPager->state>PAGER_UNLOCK );
danielk1977e277be02007-03-23 18:12:06 +00004168
danielk197789bc4bc2009-07-21 19:25:24 +00004169 if( pgno==0 ){
drh49285702005-09-17 15:20:26 +00004170 return SQLITE_CORRUPT_BKPT;
danielk197726836652005-01-17 01:33:13 +00004171 }
4172
danielk197789bc4bc2009-07-21 19:25:24 +00004173 /* If the pager is in the error state, return an error immediately.
4174 ** Otherwise, request the page from the PCache layer. */
4175 if( pPager->errCode!=SQLITE_OK && pPager->errCode!=SQLITE_FULL ){
4176 rc = pPager->errCode;
4177 }else{
4178 rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
drhed7c8552001-04-11 14:29:21 +00004179 }
danielk1977e277be02007-03-23 18:12:06 +00004180
danielk19778c0a7912008-08-20 14:49:23 +00004181 if( rc!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00004182 /* Either the call to sqlite3PcacheFetch() returned an error or the
4183 ** pager was already in the error-state when this function was called.
4184 ** Set pPg to 0 and jump to the exception handler. */
4185 pPg = 0;
4186 goto pager_acquire_err;
danielk19778c0a7912008-08-20 14:49:23 +00004187 }
danielk197789bc4bc2009-07-21 19:25:24 +00004188 assert( (*ppPage)->pgno==pgno );
4189 assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
4190
drh45b355d2010-04-01 13:41:10 +00004191 if( (*ppPage)->pPager && !noContent ){
danielk197789bc4bc2009-07-21 19:25:24 +00004192 /* In this case the pcache already contains an initialized copy of
4193 ** the page. Return without further ado. */
danielk1977e878a2f2009-07-22 16:41:15 +00004194 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
danielk197789bc4bc2009-07-21 19:25:24 +00004195 PAGER_INCR(pPager->nHit);
4196 return SQLITE_OK;
4197
4198 }else{
danielk19778c0a7912008-08-20 14:49:23 +00004199 /* The pager cache has created a new page. Its content needs to
danielk197789bc4bc2009-07-21 19:25:24 +00004200 ** be initialized. */
danielk1977979f38e2007-03-27 16:19:51 +00004201 int nMax;
danielk197789bc4bc2009-07-21 19:25:24 +00004202
drh538f5702007-04-13 02:14:30 +00004203 PAGER_INCR(pPager->nMiss);
danielk197789bc4bc2009-07-21 19:25:24 +00004204 pPg = *ppPage;
danielk19778c0a7912008-08-20 14:49:23 +00004205 pPg->pPager = pPager;
danielk197724168722007-04-02 05:07:47 +00004206
danielk197789bc4bc2009-07-21 19:25:24 +00004207 /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
4208 ** number greater than this, or the unused locking-page, is requested. */
4209 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
4210 rc = SQLITE_CORRUPT_BKPT;
4211 goto pager_acquire_err;
4212 }
4213
danielk1977ad0132d2008-06-07 08:58:22 +00004214 rc = sqlite3PagerPagecount(pPager, &nMax);
4215 if( rc!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00004216 goto pager_acquire_err;
drh2e6d11b2003-04-25 15:37:57 +00004217 }
danielk197775bab7d2006-01-23 13:09:45 +00004218
drh4ec84f32010-02-22 23:17:42 +00004219 if( MEMDB || nMax<(int)pgno || noContent || !isOpen(pPager->fd) ){
drhf8e632b2007-05-08 14:51:36 +00004220 if( pgno>pPager->mxPgno ){
dan7c246102010-04-12 19:00:29 +00004221 rc = SQLITE_FULL;
4222 goto pager_acquire_err;
drhf8e632b2007-05-08 14:51:36 +00004223 }
danielk1977a1fa00d2008-08-27 15:16:33 +00004224 if( noContent ){
danielk1977bea2a942009-01-20 17:06:27 +00004225 /* Failure to set the bits in the InJournal bit-vectors is benign.
4226 ** It merely means that we might do some extra work to journal a
4227 ** page that does not need to be journaled. Nevertheless, be sure
4228 ** to test the case where a malloc error occurs while trying to set
4229 ** a bit in a bit vector.
4230 */
4231 sqlite3BeginBenignMalloc();
drh8a938f92009-07-25 04:12:02 +00004232 if( pgno<=pPager->dbOrigSize ){
danielk1977bea2a942009-01-20 17:06:27 +00004233 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
4234 testcase( rc==SQLITE_NOMEM );
4235 }
4236 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
4237 testcase( rc==SQLITE_NOMEM );
4238 sqlite3EndBenignMalloc();
danielk19778c0a7912008-08-20 14:49:23 +00004239 }
drh39187952010-01-05 13:40:35 +00004240 memset(pPg->pData, 0, pPager->pageSize);
drh538f5702007-04-13 02:14:30 +00004241 IOTRACE(("ZERO %p %d\n", pPager, pgno));
drh306dc212001-05-21 13:45:10 +00004242 }else{
danielk1977bea2a942009-01-20 17:06:27 +00004243 assert( pPg->pPager==pPager );
4244 rc = readDbPage(pPg);
danielk1977546820e2009-03-28 06:59:41 +00004245 if( rc!=SQLITE_OK ){
danielk197789bc4bc2009-07-21 19:25:24 +00004246 goto pager_acquire_err;
drh81a20f22001-10-12 17:30:04 +00004247 }
drh306dc212001-05-21 13:45:10 +00004248 }
danielk19773c407372005-02-15 02:54:14 +00004249#ifdef SQLITE_CHECK_PAGES
4250 pPg->pageHash = pager_pagehash(pPg);
4251#endif
drhed7c8552001-04-11 14:29:21 +00004252 }
danielk19778c0a7912008-08-20 14:49:23 +00004253
drhed7c8552001-04-11 14:29:21 +00004254 return SQLITE_OK;
danielk197789bc4bc2009-07-21 19:25:24 +00004255
4256pager_acquire_err:
4257 assert( rc!=SQLITE_OK );
danielk1977e878a2f2009-07-22 16:41:15 +00004258 if( pPg ){
4259 sqlite3PcacheDrop(pPg);
4260 }
danielk197789bc4bc2009-07-21 19:25:24 +00004261 pagerUnlockIfUnused(pPager);
danielk1977e878a2f2009-07-22 16:41:15 +00004262
danielk197789bc4bc2009-07-21 19:25:24 +00004263 *ppPage = 0;
4264 return rc;
drhed7c8552001-04-11 14:29:21 +00004265}
danielk19778c0a7912008-08-20 14:49:23 +00004266
drhed7c8552001-04-11 14:29:21 +00004267/*
drh7e3b0a02001-04-28 16:52:40 +00004268** Acquire a page if it is already in the in-memory cache. Do
4269** not read the page from disk. Return a pointer to the page,
danielk1977bea2a942009-01-20 17:06:27 +00004270** or 0 if the page is not in cache. Also, return 0 if the
4271** pager is in PAGER_UNLOCK state when this function is called,
4272** or if the pager is in an error state other than SQLITE_FULL.
drh7e3b0a02001-04-28 16:52:40 +00004273**
danielk19773b8a05f2007-03-19 17:44:26 +00004274** See also sqlite3PagerGet(). The difference between this routine
4275** and sqlite3PagerGet() is that _get() will go to the disk and read
drh7e3b0a02001-04-28 16:52:40 +00004276** in the page if the page is not already in cache. This routine
drh5e00f6c2001-09-13 13:46:56 +00004277** returns NULL if the page is not in cache or if a disk I/O error
4278** has ever happened.
drh7e3b0a02001-04-28 16:52:40 +00004279*/
danielk19773b8a05f2007-03-19 17:44:26 +00004280DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
drh86f8c192007-08-22 00:39:19 +00004281 PgHdr *pPg = 0;
drh836faa42003-01-11 13:30:57 +00004282 assert( pPager!=0 );
4283 assert( pgno!=0 );
drhad7516c2009-07-24 16:32:00 +00004284 assert( pPager->pPCache!=0 );
4285 assert( pPager->state > PAGER_UNLOCK );
4286 sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
danielk19773b8a05f2007-03-19 17:44:26 +00004287 return pPg;
drh7e3b0a02001-04-28 16:52:40 +00004288}
4289
4290/*
danielk1977bea2a942009-01-20 17:06:27 +00004291** Release a page reference.
drhed7c8552001-04-11 14:29:21 +00004292**
4293** If the number of references to the page drop to zero, then the
4294** page is added to the LRU list. When all references to all pages
drhd9b02572001-04-15 00:37:09 +00004295** are released, a rollback occurs and the lock on the database is
drhed7c8552001-04-11 14:29:21 +00004296** removed.
4297*/
danielk1977bea2a942009-01-20 17:06:27 +00004298void sqlite3PagerUnref(DbPage *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004299 if( pPg ){
4300 Pager *pPager = pPg->pPager;
danielk19778c0a7912008-08-20 14:49:23 +00004301 sqlite3PcacheRelease(pPg);
4302 pagerUnlockIfUnused(pPager);
drhed7c8552001-04-11 14:29:21 +00004303 }
drhed7c8552001-04-11 14:29:21 +00004304}
4305
danielk19779153d852009-01-07 10:52:56 +00004306/*
4307** If the main journal file has already been opened, ensure that the
4308** sub-journal file is open too. If the main journal is not open,
4309** this function is a no-op.
4310**
danielk1977bea2a942009-01-20 17:06:27 +00004311** SQLITE_OK is returned if everything goes according to plan.
4312** An SQLITE_IOERR_XXX error code is returned if a call to
danielk19779153d852009-01-07 10:52:56 +00004313** sqlite3OsOpen() fails.
4314*/
danielk1977fd7f0452008-12-17 17:30:26 +00004315static int openSubJournal(Pager *pPager){
4316 int rc = SQLITE_OK;
dan7c246102010-04-12 19:00:29 +00004317 if( (pagerUseLog(pPager) || isOpen(pPager->jfd)) && !isOpen(pPager->sjfd) ){
danielk1977d8293352009-04-30 09:10:37 +00004318 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
danielk1977fd7f0452008-12-17 17:30:26 +00004319 sqlite3MemJournalOpen(pPager->sjfd);
4320 }else{
danielk1977bea2a942009-01-20 17:06:27 +00004321 rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
danielk1977fd7f0452008-12-17 17:30:26 +00004322 }
4323 }
4324 return rc;
4325}
4326
drhed7c8552001-04-11 14:29:21 +00004327/*
danielk1977bea2a942009-01-20 17:06:27 +00004328** This function is called at the start of every write transaction.
4329** There must already be a RESERVED or EXCLUSIVE lock on the database
4330** file when this routine is called.
drhda47d772002-12-02 04:25:19 +00004331**
danielk1977bea2a942009-01-20 17:06:27 +00004332** Open the journal file for pager pPager and write a journal header
4333** to the start of it. If there are active savepoints, open the sub-journal
4334** as well. This function is only used when the journal file is being
4335** opened to write a rollback log for a transaction. It is not used
4336** when opening a hot journal file to roll it back.
4337**
4338** If the journal file is already open (as it may be in exclusive mode),
4339** then this function just writes a journal header to the start of the
4340** already open file.
4341**
4342** Whether or not the journal file is opened by this function, the
4343** Pager.pInJournal bitvec structure is allocated.
4344**
4345** Return SQLITE_OK if everything is successful. Otherwise, return
4346** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
4347** an IO error code if opening or writing the journal file fails.
drhda47d772002-12-02 04:25:19 +00004348*/
4349static int pager_open_journal(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00004350 int rc = SQLITE_OK; /* Return code */
drhb1299152010-03-30 22:58:33 +00004351 int nPage; /* Size of database file */
danielk1977bea2a942009-01-20 17:06:27 +00004352 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
danielk1977b4b47412007-08-17 15:53:36 +00004353
drha6abd042004-06-09 17:37:22 +00004354 assert( pPager->state>=PAGER_RESERVED );
drhda47d772002-12-02 04:25:19 +00004355 assert( pPager->useJournal );
drh4775ecd2009-07-24 19:01:19 +00004356 assert( pPager->journalMode!=PAGER_JOURNALMODE_OFF );
drhf5e7bb52008-02-18 14:47:33 +00004357 assert( pPager->pInJournal==0 );
danielk1977bea2a942009-01-20 17:06:27 +00004358
drhad7516c2009-07-24 16:32:00 +00004359 /* If already in the error state, this function is a no-op. But on
4360 ** the other hand, this routine is never called if we are already in
4361 ** an error state. */
4362 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977b4b47412007-08-17 15:53:36 +00004363
danielk1977bea2a942009-01-20 17:06:27 +00004364 testcase( pPager->dbSizeValid==0 );
drha792dc52010-03-31 23:20:04 +00004365 rc = sqlite3PagerPagecount(pPager, &nPage);
4366 if( rc ) return rc;
drhb1299152010-03-30 22:58:33 +00004367 pPager->pInJournal = sqlite3BitvecCreate(nPage);
danielk1977bea2a942009-01-20 17:06:27 +00004368 if( pPager->pInJournal==0 ){
4369 return SQLITE_NOMEM;
4370 }
4371
4372 /* Open the journal file if it is not already open. */
4373 if( !isOpen(pPager->jfd) ){
danielk1977b3175382008-10-17 18:51:52 +00004374 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
4375 sqlite3MemJournalOpen(pPager->jfd);
danielk1977b3175382008-10-17 18:51:52 +00004376 }else{
danielk1977bea2a942009-01-20 17:06:27 +00004377 const int flags = /* VFS flags to open journal file */
danielk1977ee8b7992009-03-26 17:13:06 +00004378 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
danielk1977bea2a942009-01-20 17:06:27 +00004379 (pPager->tempFile ?
4380 (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL):
4381 (SQLITE_OPEN_MAIN_JOURNAL)
4382 );
drhfdc40e92008-04-17 20:59:37 +00004383#ifdef SQLITE_ENABLE_ATOMIC_WRITE
danielk1977b3175382008-10-17 18:51:52 +00004384 rc = sqlite3JournalOpen(
4385 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
4386 );
drhfdc40e92008-04-17 20:59:37 +00004387#else
danielk1977b3175382008-10-17 18:51:52 +00004388 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
drhfdc40e92008-04-17 20:59:37 +00004389#endif
danielk1977b3175382008-10-17 18:51:52 +00004390 }
danielk1977bea2a942009-01-20 17:06:27 +00004391 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
4392 }
4393
4394
4395 /* Write the first journal header to the journal file and open
4396 ** the sub-journal if necessary.
4397 */
4398 if( rc==SQLITE_OK ){
4399 /* TODO: Check if all of these are really required. */
4400 pPager->dbOrigSize = pPager->dbSize;
4401 pPager->journalStarted = 0;
4402 pPager->needSync = 0;
4403 pPager->nRec = 0;
drhfdc40e92008-04-17 20:59:37 +00004404 pPager->journalOff = 0;
4405 pPager->setMaster = 0;
4406 pPager->journalHdr = 0;
danielk1977bea2a942009-01-20 17:06:27 +00004407 rc = writeJournalHdr(pPager);
drhda47d772002-12-02 04:25:19 +00004408 }
danielk1977bea2a942009-01-20 17:06:27 +00004409 if( rc==SQLITE_OK && pPager->nSavepoint ){
danielk1977fd7f0452008-12-17 17:30:26 +00004410 rc = openSubJournal(pPager);
drhda47d772002-12-02 04:25:19 +00004411 }
drh9c105bb2004-10-02 20:38:28 +00004412
danielk1977bea2a942009-01-20 17:06:27 +00004413 if( rc!=SQLITE_OK ){
4414 sqlite3BitvecDestroy(pPager->pInJournal);
4415 pPager->pInJournal = 0;
4416 }
drh9c105bb2004-10-02 20:38:28 +00004417 return rc;
drhda47d772002-12-02 04:25:19 +00004418}
4419
4420/*
danielk1977bea2a942009-01-20 17:06:27 +00004421** Begin a write-transaction on the specified pager object. If a
4422** write-transaction has already been opened, this function is a no-op.
drh4b845d72002-03-05 12:41:19 +00004423**
danielk1977bea2a942009-01-20 17:06:27 +00004424** If the exFlag argument is false, then acquire at least a RESERVED
4425** lock on the database file. If exFlag is true, then acquire at least
4426** an EXCLUSIVE lock. If such a lock is already held, no locking
4427** functions need be called.
drh4b845d72002-03-05 12:41:19 +00004428**
danielk1977bea2a942009-01-20 17:06:27 +00004429** If this is not a temporary or in-memory file and, the journal file is
4430** opened if it has not been already. For a temporary file, the opening
4431** of the journal file is deferred until there is an actual need to
4432** write to the journal. TODO: Why handle temporary files differently?
drh4b845d72002-03-05 12:41:19 +00004433**
danielk1977bea2a942009-01-20 17:06:27 +00004434** If the journal file is opened (or if it is already open), then a
4435** journal-header is written to the start of it.
danielk1977d8293352009-04-30 09:10:37 +00004436**
4437** If the subjInMemory argument is non-zero, then any sub-journal opened
4438** within this transaction will be opened as an in-memory file. This
4439** has no effect if the sub-journal is already opened (as it may be when
4440** running in exclusive mode) or if the transaction does not require a
4441** sub-journal. If the subjInMemory argument is zero, then any required
4442** sub-journal is implemented in-memory if pPager is an in-memory database,
4443** or using a temporary file otherwise.
drh4b845d72002-03-05 12:41:19 +00004444*/
danielk1977d8293352009-04-30 09:10:37 +00004445int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
drh4b845d72002-03-05 12:41:19 +00004446 int rc = SQLITE_OK;
drha6abd042004-06-09 17:37:22 +00004447 assert( pPager->state!=PAGER_UNLOCK );
shane60a4b532009-05-06 18:57:09 +00004448 pPager->subjInMemory = (u8)subjInMemory;
drha6abd042004-06-09 17:37:22 +00004449 if( pPager->state==PAGER_SHARED ){
drhf5e7bb52008-02-18 14:47:33 +00004450 assert( pPager->pInJournal==0 );
danielk1977bea2a942009-01-20 17:06:27 +00004451 assert( !MEMDB && !pPager->tempFile );
4452
dan64d039e2010-04-13 19:27:31 +00004453 if( pagerUseLog(pPager) ){
dan7c246102010-04-12 19:00:29 +00004454 /* Grab the write lock on the log file. If successful, upgrade to
4455 ** PAGER_EXCLUSIVE state. Otherwise, return an error code to the caller.
4456 ** The busy-handler is not invoked if another connection already
4457 ** holds the write-lock. If possible, the upper layer will call it.
4458 */
4459 rc = sqlite3LogWriteLock(pPager->pLog, 1);
4460 if( rc==SQLITE_OK ){
4461 pPager->dbOrigSize = pPager->dbSize;
dan64d039e2010-04-13 19:27:31 +00004462 pPager->state = PAGER_RESERVED;
dane04dc882010-04-20 18:53:15 +00004463 pPager->journalOff = 0;
dan64d039e2010-04-13 19:27:31 +00004464 }
4465 }else{
4466 /* Obtain a RESERVED lock on the database file. If the exFlag parameter
4467 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
4468 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
4469 ** lock, but not when obtaining the RESERVED lock.
4470 */
4471 rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK);
4472 if( rc==SQLITE_OK ){
4473 pPager->state = PAGER_RESERVED;
4474 if( exFlag ){
4475 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
4476 }
dan7c246102010-04-12 19:00:29 +00004477 }
4478 }
4479
drhba726f42010-03-19 15:48:13 +00004480 /* No need to open the journal file at this time. It will be
4481 ** opened before it is written to. If we defer opening the journal,
4482 ** we might save the work of creating a file if the transaction
4483 ** ends up being a no-op.
danielk1977bea2a942009-01-20 17:06:27 +00004484 */
danielk1977bea2a942009-01-20 17:06:27 +00004485 }else if( isOpen(pPager->jfd) && pPager->journalOff==0 ){
drhd138c012008-05-13 00:58:18 +00004486 /* This happens when the pager was in exclusive-access mode the last
danielk1977334cdb62007-03-26 08:05:12 +00004487 ** time a (read or write) transaction was successfully concluded
4488 ** by this connection. Instead of deleting the journal file it was
drhd138c012008-05-13 00:58:18 +00004489 ** kept open and either was truncated to 0 bytes or its header was
4490 ** overwritten with zeros.
danielk1977334cdb62007-03-26 08:05:12 +00004491 */
dan7c246102010-04-12 19:00:29 +00004492 assert( pagerUseLog(pPager)==0 );
danielk1977334cdb62007-03-26 08:05:12 +00004493 assert( pPager->nRec==0 );
danielk19773460d192008-12-27 15:23:13 +00004494 assert( pPager->dbOrigSize==0 );
drhf5e7bb52008-02-18 14:47:33 +00004495 assert( pPager->pInJournal==0 );
danielk1977bea2a942009-01-20 17:06:27 +00004496 rc = pager_open_journal(pPager);
drh4b845d72002-03-05 12:41:19 +00004497 }
danielk1977bea2a942009-01-20 17:06:27 +00004498
4499 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
danielk197775a40122009-07-07 13:56:24 +00004500 if( rc!=SQLITE_OK ){
4501 assert( !pPager->dbModified );
4502 /* Ignore any IO error that occurs within pager_end_transaction(). The
4503 ** purpose of this call is to reset the internal state of the pager
4504 ** sub-system. It doesn't matter if the journal-file is not properly
4505 ** finalized at this point (since it is not a valid journal file anyway).
4506 */
4507 pager_end_transaction(pPager, 0);
4508 }
drh4b845d72002-03-05 12:41:19 +00004509 return rc;
4510}
4511
4512/*
danielk1977bea2a942009-01-20 17:06:27 +00004513** Mark a single data page as writeable. The page is written into the
4514** main journal or sub-journal as required. If the page is written into
4515** one of the journals, the corresponding bit is set in the
4516** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
4517** of any open savepoints as appropriate.
drhed7c8552001-04-11 14:29:21 +00004518*/
danielk19773b8a05f2007-03-19 17:44:26 +00004519static int pager_write(PgHdr *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004520 void *pData = pPg->pData;
drh69688d52001-04-14 16:38:23 +00004521 Pager *pPager = pPg->pPager;
drhd79caeb2001-04-15 02:27:24 +00004522 int rc = SQLITE_OK;
drh69688d52001-04-14 16:38:23 +00004523
drh5e1fa032009-07-25 15:24:13 +00004524 /* This routine is not called unless a transaction has already been
4525 ** started.
4526 */
4527 assert( pPager->state>=PAGER_RESERVED );
4528
drhdd3cd972010-03-27 17:12:36 +00004529 /* If an error has been previously detected, report the same error
4530 ** again.
drh6446c4d2001-12-15 14:22:18 +00004531 */
drhcce75d32010-04-02 03:38:59 +00004532 if( NEVER(pPager->errCode) ) return pPager->errCode;
drhad7516c2009-07-24 16:32:00 +00004533
4534 /* Higher-level routines never call this function if database is not
4535 ** writable. But check anyway, just for robustness. */
4536 if( NEVER(pPager->readOnly) ) return SQLITE_PERM;
drh6446c4d2001-12-15 14:22:18 +00004537
danielk197776572402004-06-25 02:38:54 +00004538 assert( !pPager->setMaster );
4539
danielk19773c407372005-02-15 02:54:14 +00004540 CHECK_PAGE(pPg);
4541
drh6446c4d2001-12-15 14:22:18 +00004542 /* Mark the page as dirty. If the page has already been written
4543 ** to the journal then we can return right away.
4544 */
drhc047b9f2008-11-21 03:23:43 +00004545 sqlite3PcacheMakeDirty(pPg);
danielk19773460d192008-12-27 15:23:13 +00004546 if( pageInJournal(pPg) && !subjRequiresPage(pPg) ){
dan7c246102010-04-12 19:00:29 +00004547 assert( !pagerUseLog(pPager) );
drhd138c012008-05-13 00:58:18 +00004548 pPager->dbModified = 1;
danielk1977a0bf2652004-11-04 14:30:04 +00004549 }else{
drh6446c4d2001-12-15 14:22:18 +00004550
danielk1977a0bf2652004-11-04 14:30:04 +00004551 /* If we get this far, it means that the page needs to be
4552 ** written to the transaction journal or the ckeckpoint journal
4553 ** or both.
4554 **
drh5e1fa032009-07-25 15:24:13 +00004555 ** Higher level routines should have already started a transaction,
drhba726f42010-03-19 15:48:13 +00004556 ** which means they have acquired the necessary locks but the rollback
4557 ** journal might not yet be open.
danielk1977a0bf2652004-11-04 14:30:04 +00004558 */
danielk1977d8293352009-04-30 09:10:37 +00004559 rc = sqlite3PagerBegin(pPager, 0, pPager->subjInMemory);
drhba726f42010-03-19 15:48:13 +00004560 if( rc!=SQLITE_OK ){
danielk1977a0bf2652004-11-04 14:30:04 +00004561 return rc;
4562 }
dan7c246102010-04-12 19:00:29 +00004563 if( !isOpen(pPager->jfd)
4564 && pPager->journalMode!=PAGER_JOURNALMODE_OFF
dane04dc882010-04-20 18:53:15 +00004565 && !pagerUseLog(pPager)
dan7c246102010-04-12 19:00:29 +00004566 ){
drh4775ecd2009-07-24 19:01:19 +00004567 assert( pPager->useJournal );
danielk1977a0bf2652004-11-04 14:30:04 +00004568 rc = pager_open_journal(pPager);
4569 if( rc!=SQLITE_OK ) return rc;
4570 }
drhd138c012008-05-13 00:58:18 +00004571 pPager->dbModified = 1;
danielk1977a0bf2652004-11-04 14:30:04 +00004572
4573 /* The transaction journal now exists and we have a RESERVED or an
4574 ** EXCLUSIVE lock on the main database file. Write the current page to
4575 ** the transaction journal if it is not there already.
4576 */
danielk1977bea2a942009-01-20 17:06:27 +00004577 if( !pageInJournal(pPg) && isOpen(pPager->jfd) ){
dan7c246102010-04-12 19:00:29 +00004578 assert( !pagerUseLog(pPager) );
danielk19773460d192008-12-27 15:23:13 +00004579 if( pPg->pgno<=pPager->dbOrigSize ){
danielk1977b3175382008-10-17 18:51:52 +00004580 u32 cksum;
4581 char *pData2;
danielk1977dd97a492007-08-22 18:54:32 +00004582
danielk1977b3175382008-10-17 18:51:52 +00004583 /* We should never write to the journal file the page that
4584 ** contains the database locks. The following assert verifies
4585 ** that we do not. */
4586 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
drh91781bd2010-04-10 17:52:57 +00004587
4588 assert( pPager->journalHdr <= pPager->journalOff );
drh85d2bd22009-06-11 00:47:20 +00004589 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
danielk1977b3175382008-10-17 18:51:52 +00004590 cksum = pager_cksum(pPager, (u8*)pData2);
4591 rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno);
4592 if( rc==SQLITE_OK ){
4593 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize,
4594 pPager->journalOff + 4);
4595 pPager->journalOff += pPager->pageSize+4;
4596 }
4597 if( rc==SQLITE_OK ){
4598 rc = write32bits(pPager->jfd, pPager->journalOff, cksum);
4599 pPager->journalOff += 4;
4600 }
4601 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
4602 pPager->journalOff, pPager->pageSize));
4603 PAGER_INCR(sqlite3_pager_writej_count);
drh30d53702009-01-06 15:58:57 +00004604 PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
danielk1977b3175382008-10-17 18:51:52 +00004605 PAGERID(pPager), pPg->pgno,
drh30d53702009-01-06 15:58:57 +00004606 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
danielk197707cb5602006-01-20 10:55:05 +00004607
danielk1977f3107512008-12-22 10:58:46 +00004608 /* Even if an IO or diskfull error occurred while journalling the
4609 ** page in the block above, set the need-sync flag for the page.
4610 ** Otherwise, when the transaction is rolled back, the logic in
4611 ** playback_one_page() will think that the page needs to be restored
4612 ** in the database file. And if an IO error occurs while doing so,
4613 ** then corruption may follow.
4614 */
4615 if( !pPager->noSync ){
4616 pPg->flags |= PGHDR_NEED_SYNC;
danielk1977a4124bd2008-12-23 10:37:47 +00004617 pPager->needSync = 1;
danielk1977f3107512008-12-22 10:58:46 +00004618 }
4619
shanebe217792009-03-05 04:20:31 +00004620 /* An error has occurred writing to the journal file. The
danielk1977b3175382008-10-17 18:51:52 +00004621 ** transaction will be rolled back by the layer above.
4622 */
4623 if( rc!=SQLITE_OK ){
4624 return rc;
4625 }
danielk197707cb5602006-01-20 10:55:05 +00004626
danielk1977b3175382008-10-17 18:51:52 +00004627 pPager->nRec++;
4628 assert( pPager->pInJournal!=0 );
drh7539b6b2009-01-02 21:39:39 +00004629 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
4630 testcase( rc==SQLITE_NOMEM );
4631 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
4632 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
4633 if( rc!=SQLITE_OK ){
4634 assert( rc==SQLITE_NOMEM );
4635 return rc;
4636 }
danielk197713adf8a2004-06-03 16:08:41 +00004637 }else{
danielk19778c0a7912008-08-20 14:49:23 +00004638 if( !pPager->journalStarted && !pPager->noSync ){
4639 pPg->flags |= PGHDR_NEED_SYNC;
danielk1977a4124bd2008-12-23 10:37:47 +00004640 pPager->needSync = 1;
danielk19778c0a7912008-08-20 14:49:23 +00004641 }
drh30d53702009-01-06 15:58:57 +00004642 PAGERTRACE(("APPEND %d page %d needSync=%d\n",
danielk19778c0a7912008-08-20 14:49:23 +00004643 PAGERID(pPager), pPg->pgno,
drh30d53702009-01-06 15:58:57 +00004644 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
danielk1977a0bf2652004-11-04 14:30:04 +00004645 }
danielk1977a0bf2652004-11-04 14:30:04 +00004646 }
4647
4648 /* If the statement journal is open and the page is not in it,
4649 ** then write the current page to the statement journal. Note that
4650 ** the statement journal format differs from the standard journal format
4651 ** in that it omits the checksums and the header.
4652 */
danielk19773460d192008-12-27 15:23:13 +00004653 if( subjRequiresPage(pPg) ){
danielk1977f2c31ad2009-01-06 13:40:08 +00004654 rc = subjournalPage(pPg);
drhd9b02572001-04-15 00:37:09 +00004655 }
drhfa86c412002-02-02 15:01:15 +00004656 }
4657
4658 /* Update the database size and return.
4659 */
drh1aa2d8b2007-01-03 15:34:29 +00004660 assert( pPager->state>=PAGER_SHARED );
danielk1977d92db532008-11-17 04:56:24 +00004661 if( pPager->dbSize<pPg->pgno ){
drh306dc212001-05-21 13:45:10 +00004662 pPager->dbSize = pPg->pgno;
4663 }
drh69688d52001-04-14 16:38:23 +00004664 return rc;
drhed7c8552001-04-11 14:29:21 +00004665}
4666
4667/*
danielk1977bea2a942009-01-20 17:06:27 +00004668** Mark a data page as writeable. This routine must be called before
4669** making changes to a page. The caller must check the return value
4670** of this function and be careful not to change any page data unless
4671** this routine returns SQLITE_OK.
danielk19774099f6e2007-03-19 11:25:20 +00004672**
4673** The difference between this function and pager_write() is that this
4674** function also deals with the special case where 2 or more pages
4675** fit on a single disk sector. In this case all co-resident pages
4676** must have been written to the journal file before returning.
danielk1977bea2a942009-01-20 17:06:27 +00004677**
4678** If an error occurs, SQLITE_NOMEM or an IO error code is returned
4679** as appropriate. Otherwise, SQLITE_OK.
danielk19774099f6e2007-03-19 11:25:20 +00004680*/
danielk19773b8a05f2007-03-19 17:44:26 +00004681int sqlite3PagerWrite(DbPage *pDbPage){
danielk19774099f6e2007-03-19 11:25:20 +00004682 int rc = SQLITE_OK;
4683
danielk19773b8a05f2007-03-19 17:44:26 +00004684 PgHdr *pPg = pDbPage;
danielk19774099f6e2007-03-19 11:25:20 +00004685 Pager *pPager = pPg->pPager;
4686 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
4687
danielk1977b3175382008-10-17 18:51:52 +00004688 if( nPagePerSector>1 ){
danielk19774099f6e2007-03-19 11:25:20 +00004689 Pgno nPageCount; /* Total number of pages in database file */
4690 Pgno pg1; /* First page of the sector pPg is located on. */
4691 int nPage; /* Number of pages starting at pg1 to journal */
danielk1977bea2a942009-01-20 17:06:27 +00004692 int ii; /* Loop counter */
4693 int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */
danielk19774099f6e2007-03-19 11:25:20 +00004694
4695 /* Set the doNotSync flag to 1. This is because we cannot allow a journal
4696 ** header to be written between the pages journaled by this function.
4697 */
danielk1977b3175382008-10-17 18:51:52 +00004698 assert( !MEMDB );
danielk19774099f6e2007-03-19 11:25:20 +00004699 assert( pPager->doNotSync==0 );
4700 pPager->doNotSync = 1;
4701
4702 /* This trick assumes that both the page-size and sector-size are
4703 ** an integer power of 2. It sets variable pg1 to the identifier
4704 ** of the first page of the sector pPg is located on.
4705 */
4706 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
4707
drh34e2b832010-04-02 13:25:22 +00004708 rc = sqlite3PagerPagecount(pPager, (int *)&nPageCount);
4709 if( rc ) return rc;
danielk19774099f6e2007-03-19 11:25:20 +00004710 if( pPg->pgno>nPageCount ){
4711 nPage = (pPg->pgno - pg1)+1;
4712 }else if( (pg1+nPagePerSector-1)>nPageCount ){
4713 nPage = nPageCount+1-pg1;
4714 }else{
4715 nPage = nPagePerSector;
4716 }
4717 assert(nPage>0);
4718 assert(pg1<=pPg->pgno);
4719 assert((pg1+nPage)>pPg->pgno);
4720
4721 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
4722 Pgno pg = pg1+ii;
danielk1977dd97a492007-08-22 18:54:32 +00004723 PgHdr *pPage;
drhf5e7bb52008-02-18 14:47:33 +00004724 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
danielk19774099f6e2007-03-19 11:25:20 +00004725 if( pg!=PAGER_MJ_PGNO(pPager) ){
danielk19773b8a05f2007-03-19 17:44:26 +00004726 rc = sqlite3PagerGet(pPager, pg, &pPage);
danielk19774099f6e2007-03-19 11:25:20 +00004727 if( rc==SQLITE_OK ){
4728 rc = pager_write(pPage);
danielk19778c0a7912008-08-20 14:49:23 +00004729 if( pPage->flags&PGHDR_NEED_SYNC ){
danielk1977dd97a492007-08-22 18:54:32 +00004730 needSync = 1;
danielk1977a4124bd2008-12-23 10:37:47 +00004731 assert(pPager->needSync);
danielk1977dd97a492007-08-22 18:54:32 +00004732 }
danielk19773b8a05f2007-03-19 17:44:26 +00004733 sqlite3PagerUnref(pPage);
danielk19774099f6e2007-03-19 11:25:20 +00004734 }
4735 }
drhc81945e2008-03-10 14:12:53 +00004736 }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
danielk19778c0a7912008-08-20 14:49:23 +00004737 if( pPage->flags&PGHDR_NEED_SYNC ){
danielk1977dd97a492007-08-22 18:54:32 +00004738 needSync = 1;
4739 }
danielk19778c0a7912008-08-20 14:49:23 +00004740 sqlite3PagerUnref(pPage);
danielk19774099f6e2007-03-19 11:25:20 +00004741 }
4742 }
4743
drhee03d622009-01-07 15:33:45 +00004744 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
danielk1977dd97a492007-08-22 18:54:32 +00004745 ** starting at pg1, then it needs to be set for all of them. Because
4746 ** writing to any of these nPage pages may damage the others, the
4747 ** journal file must contain sync()ed copies of all of them
4748 ** before any of them can be written out to the database file.
4749 */
danielk1977a299d612009-07-13 11:22:10 +00004750 if( rc==SQLITE_OK && needSync ){
drhb3df2e12008-09-17 20:06:26 +00004751 assert( !MEMDB && pPager->noSync==0 );
drhb480dc22009-07-24 12:35:57 +00004752 for(ii=0; ii<nPage; ii++){
danielk1977dd97a492007-08-22 18:54:32 +00004753 PgHdr *pPage = pager_lookup(pPager, pg1+ii);
drhee03d622009-01-07 15:33:45 +00004754 if( pPage ){
drhee03d622009-01-07 15:33:45 +00004755 pPage->flags |= PGHDR_NEED_SYNC;
4756 sqlite3PagerUnref(pPage);
4757 }
danielk1977dd97a492007-08-22 18:54:32 +00004758 }
4759 assert(pPager->needSync);
4760 }
4761
danielk19774099f6e2007-03-19 11:25:20 +00004762 assert( pPager->doNotSync==1 );
4763 pPager->doNotSync = 0;
4764 }else{
danielk19773b8a05f2007-03-19 17:44:26 +00004765 rc = pager_write(pDbPage);
danielk19774099f6e2007-03-19 11:25:20 +00004766 }
4767 return rc;
4768}
4769
4770/*
drhaacc5432002-01-06 17:07:40 +00004771** Return TRUE if the page given in the argument was previously passed
danielk19773b8a05f2007-03-19 17:44:26 +00004772** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
drh6019e162001-07-02 17:51:45 +00004773** to change the content of the page.
4774*/
danielk19777d3a6662006-01-23 16:21:05 +00004775#ifndef NDEBUG
danielk19773b8a05f2007-03-19 17:44:26 +00004776int sqlite3PagerIswriteable(DbPage *pPg){
danielk19778c0a7912008-08-20 14:49:23 +00004777 return pPg->flags&PGHDR_DIRTY;
drh6019e162001-07-02 17:51:45 +00004778}
danielk19777d3a6662006-01-23 16:21:05 +00004779#endif
drh6019e162001-07-02 17:51:45 +00004780
drh001bbcb2003-03-19 03:14:00 +00004781/*
drh30e58752002-03-02 20:41:57 +00004782** A call to this routine tells the pager that it is not necessary to
drh538f5702007-04-13 02:14:30 +00004783** write the information on page pPg back to the disk, even though
drhdfe88ec2008-11-03 20:55:06 +00004784** that page might be marked as dirty. This happens, for example, when
4785** the page has been added as a leaf of the freelist and so its
4786** content no longer matters.
drh30e58752002-03-02 20:41:57 +00004787**
4788** The overlying software layer calls this routine when all of the data
danielk1977bea2a942009-01-20 17:06:27 +00004789** on the given page is unused. The pager marks the page as clean so
drh30e58752002-03-02 20:41:57 +00004790** that it does not get written to disk.
4791**
danielk1977bea2a942009-01-20 17:06:27 +00004792** Tests show that this optimization can quadruple the speed of large
4793** DELETE operations.
drh30e58752002-03-02 20:41:57 +00004794*/
danielk1977bea2a942009-01-20 17:06:27 +00004795void sqlite3PagerDontWrite(PgHdr *pPg){
drh538f5702007-04-13 02:14:30 +00004796 Pager *pPager = pPg->pPager;
danielk1977bea2a942009-01-20 17:06:27 +00004797 if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
4798 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
4799 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
4800 pPg->flags |= PGHDR_DONT_WRITE;
danielk197745d68822009-01-16 16:23:38 +00004801#ifdef SQLITE_CHECK_PAGES
danielk1977bea2a942009-01-20 17:06:27 +00004802 pPg->pageHash = pager_pagehash(pPg);
danielk197745d68822009-01-16 16:23:38 +00004803#endif
danielk197745d68822009-01-16 16:23:38 +00004804 }
drh30e58752002-03-02 20:41:57 +00004805}
4806
4807/*
danielk1977bea2a942009-01-20 17:06:27 +00004808** This routine is called to increment the value of the database file
4809** change-counter, stored as a 4-byte big-endian integer starting at
4810** byte offset 24 of the pager file.
danielk197745d68822009-01-16 16:23:38 +00004811**
drhb480dc22009-07-24 12:35:57 +00004812** If the isDirectMode flag is zero, then this is done by calling
danielk1977bea2a942009-01-20 17:06:27 +00004813** sqlite3PagerWrite() on page 1, then modifying the contents of the
4814** page data. In this case the file will be updated when the current
4815** transaction is committed.
4816**
drhb480dc22009-07-24 12:35:57 +00004817** The isDirectMode flag may only be non-zero if the library was compiled
danielk1977bea2a942009-01-20 17:06:27 +00004818** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
4819** if isDirect is non-zero, then the database file is updated directly
4820** by writing an updated version of page 1 using a call to the
4821** sqlite3OsWrite() function.
danielk197745d68822009-01-16 16:23:38 +00004822*/
danielk1977bea2a942009-01-20 17:06:27 +00004823static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
danielk1977c7b60172007-08-22 11:22:03 +00004824 int rc = SQLITE_OK;
drh80e35f42007-03-30 14:06:34 +00004825
danielk1977bea2a942009-01-20 17:06:27 +00004826 /* Declare and initialize constant integer 'isDirect'. If the
4827 ** atomic-write optimization is enabled in this build, then isDirect
4828 ** is initialized to the value passed as the isDirectMode parameter
4829 ** to this function. Otherwise, it is always set to zero.
4830 **
4831 ** The idea is that if the atomic-write optimization is not
4832 ** enabled at compile time, the compiler can omit the tests of
4833 ** 'isDirect' below, as well as the block enclosed in the
4834 ** "if( isDirect )" condition.
4835 */
drh701bb3b2008-08-02 03:50:39 +00004836#ifndef SQLITE_ENABLE_ATOMIC_WRITE
drhb480dc22009-07-24 12:35:57 +00004837# define DIRECT_MODE 0
danielk1977bea2a942009-01-20 17:06:27 +00004838 assert( isDirectMode==0 );
drhdc86e2b2009-01-24 11:30:42 +00004839 UNUSED_PARAMETER(isDirectMode);
danielk1977bea2a942009-01-20 17:06:27 +00004840#else
drhb480dc22009-07-24 12:35:57 +00004841# define DIRECT_MODE isDirectMode
drh701bb3b2008-08-02 03:50:39 +00004842#endif
danielk1977bea2a942009-01-20 17:06:27 +00004843
4844 assert( pPager->state>=PAGER_RESERVED );
drh3313b142009-11-06 04:13:18 +00004845 if( !pPager->changeCountDone && pPager->dbSize>0 ){
danielk1977bea2a942009-01-20 17:06:27 +00004846 PgHdr *pPgHdr; /* Reference to page 1 */
4847 u32 change_counter; /* Initial value of change-counter field */
4848
4849 assert( !pPager->tempFile && isOpen(pPager->fd) );
4850
drh80e35f42007-03-30 14:06:34 +00004851 /* Open page 1 of the file for writing. */
4852 rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
danielk1977bea2a942009-01-20 17:06:27 +00004853 assert( pPgHdr==0 || rc==SQLITE_OK );
danielk1977c7b60172007-08-22 11:22:03 +00004854
danielk1977bea2a942009-01-20 17:06:27 +00004855 /* If page one was fetched successfully, and this function is not
drhad7516c2009-07-24 16:32:00 +00004856 ** operating in direct-mode, make page 1 writable. When not in
4857 ** direct mode, page 1 is always held in cache and hence the PagerGet()
4858 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
danielk1977bea2a942009-01-20 17:06:27 +00004859 */
drhad7516c2009-07-24 16:32:00 +00004860 if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
danielk1977c7b60172007-08-22 11:22:03 +00004861 rc = sqlite3PagerWrite(pPgHdr);
danielk1977bea2a942009-01-20 17:06:27 +00004862 }
4863
4864 if( rc==SQLITE_OK ){
4865 /* Increment the value just read and write it back to byte 24. */
4866 change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers);
4867 change_counter++;
4868 put32bits(((char*)pPgHdr->pData)+24, change_counter);
4869
drhf92a4e32010-03-19 16:55:47 +00004870 /* Also store the SQLite version number in bytes 96..99 */
drhf92a4e32010-03-19 16:55:47 +00004871 put32bits(((char*)pPgHdr->pData)+96, SQLITE_VERSION_NUMBER);
4872
danielk1977bea2a942009-01-20 17:06:27 +00004873 /* If running in direct mode, write the contents of page 1 to the file. */
drhb480dc22009-07-24 12:35:57 +00004874 if( DIRECT_MODE ){
danielk1977bea2a942009-01-20 17:06:27 +00004875 const void *zBuf = pPgHdr->pData;
4876 assert( pPager->dbFileSize>0 );
4877 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
drhb480dc22009-07-24 12:35:57 +00004878 if( rc==SQLITE_OK ){
4879 pPager->changeCountDone = 1;
4880 }
4881 }else{
danielk1977bea2a942009-01-20 17:06:27 +00004882 pPager->changeCountDone = 1;
danielk1977ae72d982007-10-03 08:46:44 +00004883 }
danielk1977c7b60172007-08-22 11:22:03 +00004884 }
4885
drh80e35f42007-03-30 14:06:34 +00004886 /* Release the page reference. */
4887 sqlite3PagerUnref(pPgHdr);
drh80e35f42007-03-30 14:06:34 +00004888 }
danielk1977c7b60172007-08-22 11:22:03 +00004889 return rc;
drh80e35f42007-03-30 14:06:34 +00004890}
4891
4892/*
danielk1977bea2a942009-01-20 17:06:27 +00004893** Sync the pager file to disk. This is a no-op for in-memory files
4894** or pages with the Pager.noSync flag set.
4895**
4896** If successful, or called on a pager for which it is a no-op, this
4897** function returns SQLITE_OK. Otherwise, an IO error code is returned.
danielk1977f653d782008-03-20 11:04:21 +00004898*/
4899int sqlite3PagerSync(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00004900 int rc; /* Return code */
drhad7516c2009-07-24 16:32:00 +00004901 assert( !MEMDB );
4902 if( pPager->noSync ){
drh7426f862008-08-26 21:07:26 +00004903 rc = SQLITE_OK;
4904 }else{
4905 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
4906 }
danielk1977f653d782008-03-20 11:04:21 +00004907 return rc;
4908}
4909
4910/*
drh80e35f42007-03-30 14:06:34 +00004911** Sync the database file for the pager pPager. zMaster points to the name
4912** of a master journal file that should be written into the individual
4913** journal file. zMaster may be NULL, which is interpreted as no master
4914** journal (a single database transaction).
4915**
danielk1977bea2a942009-01-20 17:06:27 +00004916** This routine ensures that:
4917**
4918** * The database file change-counter is updated,
4919** * the journal is synced (unless the atomic-write optimization is used),
4920** * all dirty pages are written to the database file,
4921** * the database file is truncated (if required), and
4922** * the database file synced.
4923**
4924** The only thing that remains to commit the transaction is to finalize
4925** (delete, truncate or zero the first part of) the journal file (or
4926** delete the master journal file if specified).
drh80e35f42007-03-30 14:06:34 +00004927**
4928** Note that if zMaster==NULL, this does not overwrite a previous value
4929** passed to an sqlite3PagerCommitPhaseOne() call.
4930**
danielk1977f653d782008-03-20 11:04:21 +00004931** If the final parameter - noSync - is true, then the database file itself
4932** is not synced. The caller must call sqlite3PagerSync() directly to
4933** sync the database file before calling CommitPhaseTwo() to delete the
4934** journal file in this case.
drh80e35f42007-03-30 14:06:34 +00004935*/
danielk1977f653d782008-03-20 11:04:21 +00004936int sqlite3PagerCommitPhaseOne(
danielk1977bea2a942009-01-20 17:06:27 +00004937 Pager *pPager, /* Pager object */
4938 const char *zMaster, /* If not NULL, the master journal name */
4939 int noSync /* True to omit the xSync on the db file */
danielk1977f653d782008-03-20 11:04:21 +00004940){
danielk1977bea2a942009-01-20 17:06:27 +00004941 int rc = SQLITE_OK; /* Return code */
drh80e35f42007-03-30 14:06:34 +00004942
drhad7516c2009-07-24 16:32:00 +00004943 /* The dbOrigSize is never set if journal_mode=OFF */
4944 assert( pPager->journalMode!=PAGER_JOURNALMODE_OFF || pPager->dbOrigSize==0 );
4945
drhdd3cd972010-03-27 17:12:36 +00004946 /* If a prior error occurred, report that error again. */
drhcce75d32010-04-02 03:38:59 +00004947 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977dad31b52008-05-15 11:08:07 +00004948
drh30d53702009-01-06 15:58:57 +00004949 PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
4950 pPager->zFilename, zMaster, pPager->dbSize));
drh80e35f42007-03-30 14:06:34 +00004951
danielk197704103022009-02-03 16:51:24 +00004952 if( MEMDB && pPager->dbModified ){
drhb480dc22009-07-24 12:35:57 +00004953 /* If this is an in-memory db, or no pages have been written to, or this
4954 ** function has already been called, it is mostly a no-op. However, any
4955 ** backup in progress needs to be restarted.
4956 */
danielk197704103022009-02-03 16:51:24 +00004957 sqlite3BackupRestart(pPager->pBackup);
4958 }else if( pPager->state!=PAGER_SYNCED && pPager->dbModified ){
dan7c246102010-04-12 19:00:29 +00004959 if( pagerUseLog(pPager) ){
4960 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
4961 if( pList ){
dan3306c4a2010-04-23 19:15:00 +00004962 rc = pagerLogFrames(pPager, pList, pPager->dbSize, 1,
4963 (pPager->fullSync ? pPager->sync_flags : 0)
dan7c246102010-04-12 19:00:29 +00004964 );
danielk197771aa7ff2008-05-20 07:05:09 +00004965 }
dan7c246102010-04-12 19:00:29 +00004966 sqlite3PcacheCleanAll(pPager->pPCache);
4967 }else{
4968 /* The following block updates the change-counter. Exactly how it
4969 ** does this depends on whether or not the atomic-update optimization
4970 ** was enabled at compile time, and if this transaction meets the
4971 ** runtime criteria to use the operation:
4972 **
4973 ** * The file-system supports the atomic-write property for
4974 ** blocks of size page-size, and
4975 ** * This commit is not part of a multi-file transaction, and
4976 ** * Exactly one page has been modified and store in the journal file.
4977 **
4978 ** If the optimization was not enabled at compile time, then the
4979 ** pager_incr_changecounter() function is called to update the change
4980 ** counter in 'indirect-mode'. If the optimization is compiled in but
4981 ** is not applicable to this transaction, call sqlite3JournalCreate()
4982 ** to make sure the journal file has actually been created, then call
4983 ** pager_incr_changecounter() to update the change-counter in indirect
4984 ** mode.
4985 **
4986 ** Otherwise, if the optimization is both enabled and applicable,
4987 ** then call pager_incr_changecounter() to update the change-counter
4988 ** in 'direct' mode. In this case the journal file will never be
4989 ** created for this transaction.
4990 */
4991 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
4992 PgHdr *pPg;
4993 assert( isOpen(pPager->jfd) || pPager->journalMode==PAGER_JOURNALMODE_OFF );
4994 if( !zMaster && isOpen(pPager->jfd)
4995 && pPager->journalOff==jrnlBufferSize(pPager)
4996 && pPager->dbSize>=pPager->dbFileSize
4997 && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
4998 ){
4999 /* Update the db file change counter via the direct-write method. The
5000 ** following call will modify the in-memory representation of page 1
5001 ** to include the updated change counter and then write page 1
5002 ** directly to the database file. Because of the atomic-write
5003 ** property of the host file-system, this is safe.
5004 */
5005 rc = pager_incr_changecounter(pPager, 1);
5006 }else{
5007 rc = sqlite3JournalCreate(pPager->jfd);
5008 if( rc==SQLITE_OK ){
5009 rc = pager_incr_changecounter(pPager, 0);
danielk1977bea2a942009-01-20 17:06:27 +00005010 }
dan7c246102010-04-12 19:00:29 +00005011 }
5012 #else
5013 rc = pager_incr_changecounter(pPager, 0);
5014 #endif
danielk1977bea2a942009-01-20 17:06:27 +00005015 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
dan7c246102010-04-12 19:00:29 +00005016
5017 /* If this transaction has made the database smaller, then all pages
5018 ** being discarded by the truncation must be written to the journal
5019 ** file. This can only happen in auto-vacuum mode.
5020 **
5021 ** Before reading the pages with page numbers larger than the
5022 ** current value of Pager.dbSize, set dbSize back to the value
5023 ** that it took at the start of the transaction. Otherwise, the
5024 ** calls to sqlite3PagerGet() return zeroed pages instead of
5025 ** reading data from the database file.
5026 **
5027 ** When journal_mode==OFF the dbOrigSize is always zero, so this
5028 ** block never runs if journal_mode=OFF.
5029 */
5030 #ifndef SQLITE_OMIT_AUTOVACUUM
5031 if( pPager->dbSize<pPager->dbOrigSize
5032 && ALWAYS(pPager->journalMode!=PAGER_JOURNALMODE_OFF)
5033 ){
5034 Pgno i; /* Iterator variable */
5035 const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
5036 const Pgno dbSize = pPager->dbSize; /* Database image size */
5037 pPager->dbSize = pPager->dbOrigSize;
5038 for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
5039 if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
5040 PgHdr *pPage; /* Page to journal */
5041 rc = sqlite3PagerGet(pPager, i, &pPage);
5042 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
5043 rc = sqlite3PagerWrite(pPage);
5044 sqlite3PagerUnref(pPage);
5045 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
5046 }
5047 }
5048 pPager->dbSize = dbSize;
5049 }
5050 #endif
5051
5052 /* Write the master journal name into the journal file. If a master
5053 ** journal file name has already been written to the journal file,
5054 ** or if zMaster is NULL (no master journal), then this call is a no-op.
5055 */
5056 rc = writeMasterJournal(pPager, zMaster);
5057 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
5058
5059 /* Sync the journal file. If the atomic-update optimization is being
5060 ** used, this call will not create the journal file or perform any
5061 ** real IO.
5062 */
5063 rc = syncJournal(pPager);
5064 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
5065
5066 /* Write all dirty pages to the database file. */
5067 rc = pager_write_pagelist(sqlite3PcacheDirtyList(pPager->pPCache));
5068 if( rc!=SQLITE_OK ){
5069 assert( rc!=SQLITE_IOERR_BLOCKED );
5070 goto commit_phase_one_exit;
5071 }
5072 sqlite3PcacheCleanAll(pPager->pPCache);
5073
5074 /* If the file on disk is not the same size as the database image,
5075 ** then use pager_truncate to grow or shrink the file here.
5076 */
5077 if( pPager->dbSize!=pPager->dbFileSize ){
5078 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
5079 assert( pPager->state>=PAGER_EXCLUSIVE );
5080 rc = pager_truncate(pPager, nNew);
5081 if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
5082 }
5083
5084 /* Finally, sync the database file. */
5085 if( !pPager->noSync && !noSync ){
5086 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
5087 }
5088 IOTRACE(("DBSYNC %p\n", pPager))
danielk1977f90b7262009-01-07 15:18:20 +00005089 }
5090
drh80e35f42007-03-30 14:06:34 +00005091 pPager->state = PAGER_SYNCED;
drh80e35f42007-03-30 14:06:34 +00005092 }
5093
danielk1977bea2a942009-01-20 17:06:27 +00005094commit_phase_one_exit:
drh80e35f42007-03-30 14:06:34 +00005095 return rc;
5096}
5097
5098
5099/*
danielk1977bea2a942009-01-20 17:06:27 +00005100** When this function is called, the database file has been completely
5101** updated to reflect the changes made by the current transaction and
5102** synced to disk. The journal file still exists in the file-system
5103** though, and if a failure occurs at this point it will eventually
5104** be used as a hot-journal and the current transaction rolled back.
drhd9b02572001-04-15 00:37:09 +00005105**
danielk1977bea2a942009-01-20 17:06:27 +00005106** This function finalizes the journal file, either by deleting,
5107** truncating or partially zeroing it, so that it cannot be used
5108** for hot-journal rollback. Once this is done the transaction is
5109** irrevocably committed.
5110**
5111** If an error occurs, an IO error code is returned and the pager
5112** moves into the error state. Otherwise, SQLITE_OK is returned.
drhed7c8552001-04-11 14:29:21 +00005113*/
drh80e35f42007-03-30 14:06:34 +00005114int sqlite3PagerCommitPhaseTwo(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00005115 int rc = SQLITE_OK; /* Return code */
drhd9b02572001-04-15 00:37:09 +00005116
drhb480dc22009-07-24 12:35:57 +00005117 /* This routine should not be called if a prior error has occurred.
5118 ** But if (due to a coding error elsewhere in the system) it does get
5119 ** called, just return the same error code without doing anything. */
5120 if( NEVER(pPager->errCode) ) return pPager->errCode;
danielk1977bea2a942009-01-20 17:06:27 +00005121
5122 /* This function should not be called if the pager is not in at least
5123 ** PAGER_RESERVED state. And indeed SQLite never does this. But it is
drhb480dc22009-07-24 12:35:57 +00005124 ** nice to have this defensive test here anyway.
danielk1977bea2a942009-01-20 17:06:27 +00005125 */
drhb480dc22009-07-24 12:35:57 +00005126 if( NEVER(pPager->state<PAGER_RESERVED) ) return SQLITE_ERROR;
danielk1977bea2a942009-01-20 17:06:27 +00005127
5128 /* An optimization. If the database was not actually modified during
5129 ** this transaction, the pager is running in exclusive-mode and is
5130 ** using persistent journals, then this function is a no-op.
5131 **
5132 ** The start of the journal file currently contains a single journal
5133 ** header with the nRec field set to 0. If such a journal is used as
5134 ** a hot-journal during hot-journal rollback, 0 changes will be made
5135 ** to the database file. So there is no need to zero the journal
5136 ** header. Since the pager is in exclusive mode, there is no need
5137 ** to drop any locks either.
5138 */
danielk19773cfe0702009-01-17 16:59:40 +00005139 if( pPager->dbModified==0 && pPager->exclusiveMode
5140 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
5141 ){
danielk1977bea2a942009-01-20 17:06:27 +00005142 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
drhd138c012008-05-13 00:58:18 +00005143 return SQLITE_OK;
5144 }
danielk1977bea2a942009-01-20 17:06:27 +00005145
drh30d53702009-01-06 15:58:57 +00005146 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
danielk1977bea2a942009-01-20 17:06:27 +00005147 assert( pPager->state==PAGER_SYNCED || MEMDB || !pPager->dbModified );
danielk1977b3175382008-10-17 18:51:52 +00005148 rc = pager_end_transaction(pPager, pPager->setMaster);
danielk1977bea2a942009-01-20 17:06:27 +00005149 return pager_error(pPager, rc);
drhed7c8552001-04-11 14:29:21 +00005150}
5151
5152/*
danielk1977bea2a942009-01-20 17:06:27 +00005153** Rollback all changes. The database falls back to PAGER_SHARED mode.
drhd9b02572001-04-15 00:37:09 +00005154**
danielk1977bea2a942009-01-20 17:06:27 +00005155** This function performs two tasks:
5156**
5157** 1) It rolls back the journal file, restoring all database file and
5158** in-memory cache pages to the state they were in when the transaction
5159** was opened, and
5160** 2) It finalizes the journal file, so that it is not used for hot
5161** rollback at any point in the future.
5162**
5163** subject to the following qualifications:
5164**
5165** * If the journal file is not yet open when this function is called,
5166** then only (2) is performed. In this case there is no journal file
5167** to roll back.
5168**
5169** * If in an error state other than SQLITE_FULL, then task (1) is
5170** performed. If successful, task (2). Regardless of the outcome
5171** of either, the error state error code is returned to the caller
5172** (i.e. either SQLITE_IOERR or SQLITE_CORRUPT).
5173**
5174** * If the pager is in PAGER_RESERVED state, then attempt (1). Whether
5175** or not (1) is succussful, also attempt (2). If successful, return
5176** SQLITE_OK. Otherwise, enter the error state and return the first
5177** error code encountered.
5178**
5179** In this case there is no chance that the database was written to.
5180** So is safe to finalize the journal file even if the playback
5181** (operation 1) failed. However the pager must enter the error state
5182** as the contents of the in-memory cache are now suspect.
5183**
5184** * Finally, if in PAGER_EXCLUSIVE state, then attempt (1). Only
5185** attempt (2) if (1) is successful. Return SQLITE_OK if successful,
5186** otherwise enter the error state and return the error code from the
5187** failing operation.
5188**
5189** In this case the database file may have been written to. So if the
5190** playback operation did not succeed it would not be safe to finalize
5191** the journal file. It needs to be left in the file-system so that
5192** some other process can use it to restore the database state (by
5193** hot-journal rollback).
drhed7c8552001-04-11 14:29:21 +00005194*/
danielk19773b8a05f2007-03-19 17:44:26 +00005195int sqlite3PagerRollback(Pager *pPager){
danielk1977bea2a942009-01-20 17:06:27 +00005196 int rc = SQLITE_OK; /* Return code */
drh30d53702009-01-06 15:58:57 +00005197 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
dan7c246102010-04-12 19:00:29 +00005198 if( pagerUseLog(pPager) ){
5199 int rc2;
dan3306c4a2010-04-23 19:15:00 +00005200
dan7c246102010-04-12 19:00:29 +00005201 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
5202 rc2 = pager_end_transaction(pPager, pPager->setMaster);
5203 if( rc==SQLITE_OK ) rc = rc2;
5204 }else if( !pPager->dbModified || !isOpen(pPager->jfd) ){
danielk1977df2566a2008-05-07 19:11:03 +00005205 rc = pager_end_transaction(pPager, pPager->setMaster);
danielk19778c0a7912008-08-20 14:49:23 +00005206 }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
drha6abd042004-06-09 17:37:22 +00005207 if( pPager->state>=PAGER_EXCLUSIVE ){
danielk1977e277be02007-03-23 18:12:06 +00005208 pager_playback(pPager, 0);
drh4b845d72002-03-05 12:41:19 +00005209 }
danielk19778c0a7912008-08-20 14:49:23 +00005210 rc = pPager->errCode;
drha6abd042004-06-09 17:37:22 +00005211 }else{
danielk19778c0a7912008-08-20 14:49:23 +00005212 if( pPager->state==PAGER_RESERVED ){
5213 int rc2;
5214 rc = pager_playback(pPager, 0);
5215 rc2 = pager_end_transaction(pPager, pPager->setMaster);
5216 if( rc==SQLITE_OK ){
5217 rc = rc2;
5218 }
5219 }else{
5220 rc = pager_playback(pPager, 0);
5221 }
danielk197707cb5602006-01-20 10:55:05 +00005222
danielk1977b3175382008-10-17 18:51:52 +00005223 if( !MEMDB ){
danielk1977d92db532008-11-17 04:56:24 +00005224 pPager->dbSizeValid = 0;
danielk1977b3175382008-10-17 18:51:52 +00005225 }
danielk19778c0a7912008-08-20 14:49:23 +00005226
5227 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
5228 ** cache. So call pager_error() on the way out to make any error
5229 ** persistent.
5230 */
5231 rc = pager_error(pPager, rc);
5232 }
drh86f8c192007-08-22 00:39:19 +00005233 return rc;
drh98808ba2001-10-18 12:34:46 +00005234}
drhd9b02572001-04-15 00:37:09 +00005235
5236/*
drh5e00f6c2001-09-13 13:46:56 +00005237** Return TRUE if the database file is opened read-only. Return FALSE
5238** if the database is (in theory) writable.
5239*/
drhf49661a2008-12-10 16:45:50 +00005240u8 sqlite3PagerIsreadonly(Pager *pPager){
drhbe0072d2001-09-13 14:46:09 +00005241 return pPager->readOnly;
drh5e00f6c2001-09-13 13:46:56 +00005242}
5243
5244/*
drh0f7eb612006-08-08 13:51:43 +00005245** Return the number of references to the pager.
5246*/
danielk19773b8a05f2007-03-19 17:44:26 +00005247int sqlite3PagerRefcount(Pager *pPager){
danielk19778c0a7912008-08-20 14:49:23 +00005248 return sqlite3PcacheRefCount(pPager->pPCache);
drh0f7eb612006-08-08 13:51:43 +00005249}
5250
danielk197771d5d2c2008-09-29 11:49:47 +00005251/*
drh63da0892010-03-10 21:42:07 +00005252** Return the approximate number of bytes of memory currently
5253** used by the pager and its associated cache.
5254*/
5255int sqlite3PagerMemUsed(Pager *pPager){
5256 int perPageSize = pPager->pageSize + pPager->nExtra + 20;
5257 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
5258 + sqlite3MallocSize(pPager);
5259}
5260
5261/*
danielk197771d5d2c2008-09-29 11:49:47 +00005262** Return the number of references to the specified page.
5263*/
5264int sqlite3PagerPageRefcount(DbPage *pPage){
5265 return sqlite3PcachePageRefcount(pPage);
5266}
5267
drh0f7eb612006-08-08 13:51:43 +00005268#ifdef SQLITE_TEST
5269/*
drhd9b02572001-04-15 00:37:09 +00005270** This routine is used for testing and analysis only.
5271*/
danielk19773b8a05f2007-03-19 17:44:26 +00005272int *sqlite3PagerStats(Pager *pPager){
danielk197742741be2005-01-08 12:42:39 +00005273 static int a[11];
danielk19778c0a7912008-08-20 14:49:23 +00005274 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
5275 a[1] = sqlite3PcachePagecount(pPager->pPCache);
5276 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
danielk1977d92db532008-11-17 04:56:24 +00005277 a[3] = pPager->dbSizeValid ? (int) pPager->dbSize : -1;
drhd9b02572001-04-15 00:37:09 +00005278 a[4] = pPager->state;
danielk1977efaaf572006-01-16 11:29:19 +00005279 a[5] = pPager->errCode;
drhd9b02572001-04-15 00:37:09 +00005280 a[6] = pPager->nHit;
5281 a[7] = pPager->nMiss;
drh7c4ac0c2007-04-05 11:25:58 +00005282 a[8] = 0; /* Used to be pPager->nOvfl */
danielk197742741be2005-01-08 12:42:39 +00005283 a[9] = pPager->nRead;
5284 a[10] = pPager->nWrite;
drhd9b02572001-04-15 00:37:09 +00005285 return a;
5286}
danielk197704103022009-02-03 16:51:24 +00005287#endif
5288
5289/*
5290** Return true if this is an in-memory pager.
5291*/
danielk197717b90b52008-06-06 11:11:25 +00005292int sqlite3PagerIsMemdb(Pager *pPager){
5293 return MEMDB;
5294}
drhdd793422001-06-28 01:54:48 +00005295
drhfa86c412002-02-02 15:01:15 +00005296/*
danielk1977bea2a942009-01-20 17:06:27 +00005297** Check that there are at least nSavepoint savepoints open. If there are
5298** currently less than nSavepoints open, then open one or more savepoints
5299** to make up the difference. If the number of savepoints is already
5300** equal to nSavepoint, then this function is a no-op.
5301**
5302** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
5303** occurs while opening the sub-journal file, then an IO error code is
5304** returned. Otherwise, SQLITE_OK.
drhfa86c412002-02-02 15:01:15 +00005305*/
danielk1977fd7f0452008-12-17 17:30:26 +00005306int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
danielk1977bea2a942009-01-20 17:06:27 +00005307 int rc = SQLITE_OK; /* Return code */
5308 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
danielk1977fd7f0452008-12-17 17:30:26 +00005309
danielk1977bea2a942009-01-20 17:06:27 +00005310 if( nSavepoint>nCurrent && pPager->useJournal ){
5311 int ii; /* Iterator variable */
5312 PagerSavepoint *aNew; /* New Pager.aSavepoint array */
drhb1299152010-03-30 22:58:33 +00005313 int nPage; /* Size of database file */
danielk1977fd7f0452008-12-17 17:30:26 +00005314
drhb1299152010-03-30 22:58:33 +00005315 rc = sqlite3PagerPagecount(pPager, &nPage);
drhdd3cd972010-03-27 17:12:36 +00005316 if( rc ) return rc;
5317
danielk1977fd7f0452008-12-17 17:30:26 +00005318 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
5319 ** if the allocation fails. Otherwise, zero the new portion in case a
5320 ** malloc failure occurs while populating it in the for(...) loop below.
5321 */
drh49b9d332009-01-02 18:10:42 +00005322 aNew = (PagerSavepoint *)sqlite3Realloc(
danielk1977fd7f0452008-12-17 17:30:26 +00005323 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
5324 );
5325 if( !aNew ){
5326 return SQLITE_NOMEM;
5327 }
danielk1977bea2a942009-01-20 17:06:27 +00005328 memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
danielk1977fd7f0452008-12-17 17:30:26 +00005329 pPager->aSavepoint = aNew;
danielk1977fd7f0452008-12-17 17:30:26 +00005330 pPager->nSavepoint = nSavepoint;
5331
5332 /* Populate the PagerSavepoint structures just allocated. */
danielk1977bea2a942009-01-20 17:06:27 +00005333 for(ii=nCurrent; ii<nSavepoint; ii++){
drhb1299152010-03-30 22:58:33 +00005334 aNew[ii].nOrig = nPage;
drhba726f42010-03-19 15:48:13 +00005335 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
danielk197767ddef62008-12-23 19:15:56 +00005336 aNew[ii].iOffset = pPager->journalOff;
5337 }else{
5338 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
5339 }
danielk1977bea2a942009-01-20 17:06:27 +00005340 aNew[ii].iSubRec = pPager->nSubRec;
drhb1299152010-03-30 22:58:33 +00005341 aNew[ii].pInSavepoint = sqlite3BitvecCreate(nPage);
danielk1977fd7f0452008-12-17 17:30:26 +00005342 if( !aNew[ii].pInSavepoint ){
5343 return SQLITE_NOMEM;
danielk1977b3175382008-10-17 18:51:52 +00005344 }
drh334b2992007-09-06 23:28:23 +00005345 }
danielk1977fd7f0452008-12-17 17:30:26 +00005346
5347 /* Open the sub-journal, if it is not already opened. */
5348 rc = openSubJournal(pPager);
danielk19779f0b6be2009-07-25 11:40:07 +00005349 assertTruncateConstraint(pPager);
drh0f892532002-05-30 12:27:03 +00005350 }
danielk1977fd7f0452008-12-17 17:30:26 +00005351
drh86f8c192007-08-22 00:39:19 +00005352 return rc;
5353}
drhfa86c412002-02-02 15:01:15 +00005354
5355/*
danielk1977bea2a942009-01-20 17:06:27 +00005356** This function is called to rollback or release (commit) a savepoint.
5357** The savepoint to release or rollback need not be the most recently
5358** created savepoint.
5359**
danielk1977fd7f0452008-12-17 17:30:26 +00005360** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
5361** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
5362** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
shanebe217792009-03-05 04:20:31 +00005363** that have occurred since the specified savepoint was created.
danielk1977fd7f0452008-12-17 17:30:26 +00005364**
danielk1977bea2a942009-01-20 17:06:27 +00005365** The savepoint to rollback or release is identified by parameter
5366** iSavepoint. A value of 0 means to operate on the outermost savepoint
5367** (the first created). A value of (Pager.nSavepoint-1) means operate
5368** on the most recently created savepoint. If iSavepoint is greater than
5369** (Pager.nSavepoint-1), then this function is a no-op.
danielk1977fd7f0452008-12-17 17:30:26 +00005370**
danielk1977bea2a942009-01-20 17:06:27 +00005371** If a negative value is passed to this function, then the current
5372** transaction is rolled back. This is different to calling
5373** sqlite3PagerRollback() because this function does not terminate
5374** the transaction or unlock the database, it just restores the
5375** contents of the database to its original state.
5376**
5377** In any case, all savepoints with an index greater than iSavepoint
5378** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
5379** then savepoint iSavepoint is also destroyed.
5380**
5381** This function may return SQLITE_NOMEM if a memory allocation fails,
5382** or an IO error code if an IO error occurs while rolling back a
5383** savepoint. If no errors occur, SQLITE_OK is returned.
danielk1977fd7f0452008-12-17 17:30:26 +00005384*/
5385int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
5386 int rc = SQLITE_OK;
5387
5388 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
danielk1977bea2a942009-01-20 17:06:27 +00005389 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
danielk1977fd7f0452008-12-17 17:30:26 +00005390
5391 if( iSavepoint<pPager->nSavepoint ){
danielk1977bea2a942009-01-20 17:06:27 +00005392 int ii; /* Iterator variable */
5393 int nNew; /* Number of remaining savepoints after this op. */
5394
5395 /* Figure out how many savepoints will still be active after this
5396 ** operation. Store this value in nNew. Then free resources associated
5397 ** with any savepoints that are destroyed by this operation.
5398 */
shaneh6885de32010-02-05 16:28:00 +00005399 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
danielk1977fd7f0452008-12-17 17:30:26 +00005400 for(ii=nNew; ii<pPager->nSavepoint; ii++){
5401 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
5402 }
5403 pPager->nSavepoint = nNew;
5404
shaneh6885de32010-02-05 16:28:00 +00005405 /* If this is a release of the outermost savepoint, truncate
5406 ** the sub-journal to zero bytes in size. */
5407 if( op==SAVEPOINT_RELEASE ){
5408 if( nNew==0 && isOpen(pPager->sjfd) ){
5409 /* Only truncate if it is an in-memory sub-journal. */
5410 if( sqlite3IsMemJournal(pPager->sjfd) ){
5411 rc = sqlite3OsTruncate(pPager->sjfd, 0);
drh35173242010-03-08 21:40:13 +00005412 assert( rc==SQLITE_OK );
shaneh6885de32010-02-05 16:28:00 +00005413 }
5414 pPager->nSubRec = 0;
5415 }
5416 }
5417 /* Else this is a rollback operation, playback the specified savepoint.
danielk1977bea2a942009-01-20 17:06:27 +00005418 ** If this is a temp-file, it is possible that the journal file has
5419 ** not yet been opened. In this case there have been no changes to
5420 ** the database file, so the playback operation can be skipped.
5421 */
dan7c246102010-04-12 19:00:29 +00005422 else if( pagerUseLog(pPager) || isOpen(pPager->jfd) ){
danielk1977f3107512008-12-22 10:58:46 +00005423 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
danielk1977fd7f0452008-12-17 17:30:26 +00005424 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
5425 assert(rc!=SQLITE_DONE);
5426 }
danielk1977f3107512008-12-22 10:58:46 +00005427
drh663fc632002-02-02 18:49:19 +00005428 }
drhfa86c412002-02-02 15:01:15 +00005429 return rc;
5430}
5431
drh73509ee2003-04-06 20:44:45 +00005432/*
5433** Return the full pathname of the database file.
5434*/
danielk19773b8a05f2007-03-19 17:44:26 +00005435const char *sqlite3PagerFilename(Pager *pPager){
drh73509ee2003-04-06 20:44:45 +00005436 return pPager->zFilename;
5437}
5438
drhb20ea9d2004-02-09 01:20:36 +00005439/*
drhd0679ed2007-08-28 22:24:34 +00005440** Return the VFS structure for the pager.
5441*/
5442const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
5443 return pPager->pVfs;
5444}
5445
5446/*
drhcc6bb3e2007-08-31 16:11:35 +00005447** Return the file handle for the database file associated
5448** with the pager. This might return NULL if the file has
5449** not yet been opened.
5450*/
5451sqlite3_file *sqlite3PagerFile(Pager *pPager){
5452 return pPager->fd;
5453}
5454
5455/*
danielk19775865e3d2004-06-14 06:03:57 +00005456** Return the full pathname of the journal file.
5457*/
danielk19773b8a05f2007-03-19 17:44:26 +00005458const char *sqlite3PagerJournalname(Pager *pPager){
danielk19775865e3d2004-06-14 06:03:57 +00005459 return pPager->zJournal;
5460}
5461
5462/*
drh2c8997b2005-08-27 16:36:48 +00005463** Return true if fsync() calls are disabled for this pager. Return FALSE
5464** if fsync()s are executed normally.
5465*/
danielk19773b8a05f2007-03-19 17:44:26 +00005466int sqlite3PagerNosync(Pager *pPager){
drh2c8997b2005-08-27 16:36:48 +00005467 return pPager->noSync;
5468}
5469
drh7c4ac0c2007-04-05 11:25:58 +00005470#ifdef SQLITE_HAS_CODEC
drh2c8997b2005-08-27 16:36:48 +00005471/*
drhfa9601a2009-06-18 17:22:39 +00005472** Set or retrieve the codec for this pager
drhb20ea9d2004-02-09 01:20:36 +00005473*/
drhfa9601a2009-06-18 17:22:39 +00005474static void sqlite3PagerSetCodec(
drhb20ea9d2004-02-09 01:20:36 +00005475 Pager *pPager,
drhc001c582006-03-06 18:23:16 +00005476 void *(*xCodec)(void*,void*,Pgno,int),
drhfa9601a2009-06-18 17:22:39 +00005477 void (*xCodecSizeChng)(void*,int,int),
5478 void (*xCodecFree)(void*),
5479 void *pCodec
drhb20ea9d2004-02-09 01:20:36 +00005480){
drhfa9601a2009-06-18 17:22:39 +00005481 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
drh481aa742009-11-05 18:46:02 +00005482 pPager->xCodec = pPager->memDb ? 0 : xCodec;
drhfa9601a2009-06-18 17:22:39 +00005483 pPager->xCodecSizeChng = xCodecSizeChng;
5484 pPager->xCodecFree = xCodecFree;
5485 pPager->pCodec = pCodec;
5486 pagerReportSize(pPager);
5487}
5488static void *sqlite3PagerGetCodec(Pager *pPager){
5489 return pPager->pCodec;
drhb20ea9d2004-02-09 01:20:36 +00005490}
drh7c4ac0c2007-04-05 11:25:58 +00005491#endif
drhb20ea9d2004-02-09 01:20:36 +00005492
danielk1977687566d2004-11-02 12:56:41 +00005493#ifndef SQLITE_OMIT_AUTOVACUUM
5494/*
danielk197787c29a92008-01-18 11:33:16 +00005495** Move the page pPg to location pgno in the file.
danielk1977687566d2004-11-02 12:56:41 +00005496**
drh5e385312007-06-16 04:42:12 +00005497** There must be no references to the page previously located at
5498** pgno (which we call pPgOld) though that page is allowed to be
drhb3df2e12008-09-17 20:06:26 +00005499** in cache. If the page previously located at pgno is not already
drh5e385312007-06-16 04:42:12 +00005500** in the rollback journal, it is not put there by by this routine.
danielk1977687566d2004-11-02 12:56:41 +00005501**
drh5e385312007-06-16 04:42:12 +00005502** References to the page pPg remain valid. Updating any
5503** meta-data associated with pPg (i.e. data stored in the nExtra bytes
danielk1977687566d2004-11-02 12:56:41 +00005504** allocated along with the page) is the responsibility of the caller.
5505**
danielk19775fd057a2005-03-09 13:09:43 +00005506** A transaction must be active when this routine is called. It used to be
5507** required that a statement transaction was not active, but this restriction
5508** has been removed (CREATE INDEX needs to move a page when a statement
5509** transaction is active).
danielk19774c999992008-07-16 18:17:55 +00005510**
5511** If the fourth argument, isCommit, is non-zero, then this page is being
5512** moved as part of a database reorganization just before the transaction
5513** is being committed. In this case, it is guaranteed that the database page
5514** pPg refers to will not be written to again within this transaction.
danielk1977bea2a942009-01-20 17:06:27 +00005515**
5516** This function may return SQLITE_NOMEM or an IO error code if an error
5517** occurs. Otherwise, it returns SQLITE_OK.
danielk1977687566d2004-11-02 12:56:41 +00005518*/
danielk19774c999992008-07-16 18:17:55 +00005519int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
danielk1977bea2a942009-01-20 17:06:27 +00005520 PgHdr *pPgOld; /* The page being overwritten. */
5521 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
5522 int rc; /* Return code */
drh86655a12009-03-31 02:54:40 +00005523 Pgno origPgno; /* The original page number */
danielk1977687566d2004-11-02 12:56:41 +00005524
danielk1977687566d2004-11-02 12:56:41 +00005525 assert( pPg->nRef>0 );
5526
drh8c30f722009-11-20 18:48:35 +00005527 /* In order to be able to rollback, an in-memory database must journal
5528 ** the page we are moving from.
5529 */
5530 if( MEMDB ){
5531 rc = sqlite3PagerWrite(pPg);
5532 if( rc ) return rc;
5533 }
5534
danielk19771fab7b62009-01-07 10:35:18 +00005535 /* If the page being moved is dirty and has not been saved by the latest
5536 ** savepoint, then save the current contents of the page into the
5537 ** sub-journal now. This is required to handle the following scenario:
5538 **
5539 ** BEGIN;
5540 ** <journal page X, then modify it in memory>
5541 ** SAVEPOINT one;
5542 ** <Move page X to location Y>
5543 ** ROLLBACK TO one;
5544 **
5545 ** If page X were not written to the sub-journal here, it would not
5546 ** be possible to restore its contents when the "ROLLBACK TO one"
danielk1977bea2a942009-01-20 17:06:27 +00005547 ** statement were is processed.
5548 **
5549 ** subjournalPage() may need to allocate space to store pPg->pgno into
5550 ** one or more savepoint bitvecs. This is the reason this function
5551 ** may return SQLITE_NOMEM.
danielk19771fab7b62009-01-07 10:35:18 +00005552 */
drh8c30f722009-11-20 18:48:35 +00005553 if( pPg->flags&PGHDR_DIRTY
danielk19771fab7b62009-01-07 10:35:18 +00005554 && subjRequiresPage(pPg)
5555 && SQLITE_OK!=(rc = subjournalPage(pPg))
5556 ){
5557 return rc;
5558 }
5559
drh30d53702009-01-06 15:58:57 +00005560 PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
5561 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
drhb0603412007-02-28 04:47:26 +00005562 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
danielk1977ef73ee92004-11-06 12:26:07 +00005563
danielk19774c999992008-07-16 18:17:55 +00005564 /* If the journal needs to be sync()ed before page pPg->pgno can
5565 ** be written to, store pPg->pgno in local variable needSyncPgno.
5566 **
5567 ** If the isCommit flag is set, there is no need to remember that
5568 ** the journal needs to be sync()ed before database page pPg->pgno
5569 ** can be written to. The caller has already promised not to write to it.
5570 */
danielk19778c0a7912008-08-20 14:49:23 +00005571 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
danielk197794daf7f2004-11-08 09:26:09 +00005572 needSyncPgno = pPg->pgno;
danielk19773460d192008-12-27 15:23:13 +00005573 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
danielk19778c0a7912008-08-20 14:49:23 +00005574 assert( pPg->flags&PGHDR_DIRTY );
danielk1977ae825582004-11-23 09:06:55 +00005575 assert( pPager->needSync );
danielk197794daf7f2004-11-08 09:26:09 +00005576 }
5577
danielk1977ef73ee92004-11-06 12:26:07 +00005578 /* If the cache contains a page with page-number pgno, remove it
drh85b623f2007-12-13 21:54:09 +00005579 ** from its hash chain. Also, if the PgHdr.needSync was set for
danielk1977599fcba2004-11-08 07:13:13 +00005580 ** page pgno before the 'move' operation, it needs to be retained
5581 ** for the page moved there.
danielk1977f5fdda82004-11-03 08:44:05 +00005582 */
danielk1977bc2ca9e2008-11-13 14:28:28 +00005583 pPg->flags &= ~PGHDR_NEED_SYNC;
danielk1977687566d2004-11-02 12:56:41 +00005584 pPgOld = pager_lookup(pPager, pgno);
danielk19778c0a7912008-08-20 14:49:23 +00005585 assert( !pPgOld || pPgOld->nRef==1 );
drh6e2ef432009-07-22 02:02:39 +00005586 if( pPgOld ){
danielk19778c0a7912008-08-20 14:49:23 +00005587 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
drh98829a62009-11-20 13:18:14 +00005588 if( MEMDB ){
5589 /* Do not discard pages from an in-memory database since we might
5590 ** need to rollback later. Just move the page out of the way. */
5591 assert( pPager->dbSizeValid );
5592 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
5593 }else{
5594 sqlite3PcacheDrop(pPgOld);
5595 }
drh5e385312007-06-16 04:42:12 +00005596 }
danielk1977687566d2004-11-02 12:56:41 +00005597
drh86655a12009-03-31 02:54:40 +00005598 origPgno = pPg->pgno;
danielk19778c0a7912008-08-20 14:49:23 +00005599 sqlite3PcacheMove(pPg, pgno);
drhc047b9f2008-11-21 03:23:43 +00005600 sqlite3PcacheMakeDirty(pPg);
drhd138c012008-05-13 00:58:18 +00005601 pPager->dbModified = 1;
danielk1977687566d2004-11-02 12:56:41 +00005602
danielk197794daf7f2004-11-08 09:26:09 +00005603 if( needSyncPgno ){
5604 /* If needSyncPgno is non-zero, then the journal file needs to be
5605 ** sync()ed before any data is written to database file page needSyncPgno.
5606 ** Currently, no such page exists in the page-cache and the
danielk19774c999992008-07-16 18:17:55 +00005607 ** "is journaled" bitvec flag has been set. This needs to be remedied by
5608 ** loading the page into the pager-cache and setting the PgHdr.needSync
5609 ** flag.
danielk1977ae825582004-11-23 09:06:55 +00005610 **
danielk1977a98d7b42008-01-18 13:42:54 +00005611 ** If the attempt to load the page into the page-cache fails, (due
drhf5e7bb52008-02-18 14:47:33 +00005612 ** to a malloc() or IO failure), clear the bit in the pInJournal[]
danielk1977a98d7b42008-01-18 13:42:54 +00005613 ** array. Otherwise, if the page is loaded and written again in
5614 ** this transaction, it may be written to the database file before
5615 ** it is synced into the journal file. This way, it may end up in
5616 ** the journal file twice, but that is not a problem.
5617 **
danielk19773b8a05f2007-03-19 17:44:26 +00005618 ** The sqlite3PagerGet() call may cause the journal to sync. So make
danielk1977ae825582004-11-23 09:06:55 +00005619 ** sure the Pager.needSync flag is set too.
danielk197794daf7f2004-11-08 09:26:09 +00005620 */
danielk19773b8a05f2007-03-19 17:44:26 +00005621 PgHdr *pPgHdr;
danielk1977ae825582004-11-23 09:06:55 +00005622 assert( pPager->needSync );
danielk19773b8a05f2007-03-19 17:44:26 +00005623 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
danielk197787c29a92008-01-18 11:33:16 +00005624 if( rc!=SQLITE_OK ){
drh6aac11d2009-07-18 20:01:37 +00005625 if( needSyncPgno<=pPager->dbOrigSize ){
drhe98c9042009-06-02 21:31:38 +00005626 assert( pPager->pTmpSpace!=0 );
5627 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
danielk1977a98d7b42008-01-18 13:42:54 +00005628 }
danielk197787c29a92008-01-18 11:33:16 +00005629 return rc;
5630 }
danielk1977ae825582004-11-23 09:06:55 +00005631 pPager->needSync = 1;
drhb3df2e12008-09-17 20:06:26 +00005632 assert( pPager->noSync==0 && !MEMDB );
danielk19778c0a7912008-08-20 14:49:23 +00005633 pPgHdr->flags |= PGHDR_NEED_SYNC;
drhc047b9f2008-11-21 03:23:43 +00005634 sqlite3PcacheMakeDirty(pPgHdr);
danielk19773b8a05f2007-03-19 17:44:26 +00005635 sqlite3PagerUnref(pPgHdr);
danielk197794daf7f2004-11-08 09:26:09 +00005636 }
5637
drh86655a12009-03-31 02:54:40 +00005638 /*
5639 ** For an in-memory database, make sure the original page continues
drh98829a62009-11-20 13:18:14 +00005640 ** to exist, in case the transaction needs to roll back. Use pPgOld
5641 ** as the original page since it has already been allocated.
drh86655a12009-03-31 02:54:40 +00005642 */
5643 if( MEMDB ){
drh98829a62009-11-20 13:18:14 +00005644 sqlite3PcacheMove(pPgOld, origPgno);
5645 sqlite3PagerUnref(pPgOld);
drh86655a12009-03-31 02:54:40 +00005646 }
5647
danielk1977687566d2004-11-02 12:56:41 +00005648 return SQLITE_OK;
5649}
5650#endif
5651
danielk19773b8a05f2007-03-19 17:44:26 +00005652/*
5653** Return a pointer to the data for the specified page.
5654*/
5655void *sqlite3PagerGetData(DbPage *pPg){
danielk197771d5d2c2008-09-29 11:49:47 +00005656 assert( pPg->nRef>0 || pPg->pPager->memDb );
danielk19778c0a7912008-08-20 14:49:23 +00005657 return pPg->pData;
danielk19773b8a05f2007-03-19 17:44:26 +00005658}
5659
5660/*
5661** Return a pointer to the Pager.nExtra bytes of "extra" space
5662** allocated along with the specified page.
5663*/
5664void *sqlite3PagerGetExtra(DbPage *pPg){
drh6aac11d2009-07-18 20:01:37 +00005665 return pPg->pExtra;
danielk19773b8a05f2007-03-19 17:44:26 +00005666}
5667
danielk197741483462007-03-24 16:45:04 +00005668/*
5669** Get/set the locking-mode for this pager. Parameter eMode must be one
5670** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
5671** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
5672** the locking-mode is set to the value specified.
5673**
5674** The returned value is either PAGER_LOCKINGMODE_NORMAL or
5675** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
5676** locking-mode.
5677*/
5678int sqlite3PagerLockingMode(Pager *pPager, int eMode){
drh369339d2007-03-30 16:01:55 +00005679 assert( eMode==PAGER_LOCKINGMODE_QUERY
5680 || eMode==PAGER_LOCKINGMODE_NORMAL
5681 || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
5682 assert( PAGER_LOCKINGMODE_QUERY<0 );
5683 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
5684 if( eMode>=0 && !pPager->tempFile ){
drh1bd10f82008-12-10 21:19:56 +00005685 pPager->exclusiveMode = (u8)eMode;
danielk197741483462007-03-24 16:45:04 +00005686 }
5687 return (int)pPager->exclusiveMode;
5688}
5689
drh3b020132008-04-17 17:02:01 +00005690/*
drh04335882008-09-26 21:08:08 +00005691** Get/set the journal-mode for this pager. Parameter eMode must be one of:
drh3b020132008-04-17 17:02:01 +00005692**
drh04335882008-09-26 21:08:08 +00005693** PAGER_JOURNALMODE_QUERY
5694** PAGER_JOURNALMODE_DELETE
5695** PAGER_JOURNALMODE_TRUNCATE
5696** PAGER_JOURNALMODE_PERSIST
5697** PAGER_JOURNALMODE_OFF
danielk1977bea2a942009-01-20 17:06:27 +00005698** PAGER_JOURNALMODE_MEMORY
dan7c246102010-04-12 19:00:29 +00005699** PAGER_JOURNALMODE_WAL
drh04335882008-09-26 21:08:08 +00005700**
drh8a939192009-04-20 17:43:03 +00005701** If the parameter is not _QUERY, then the journal_mode is set to the
dane04dc882010-04-20 18:53:15 +00005702** value specified if the change is allowed. The change may be disallowed
drh8a939192009-04-20 17:43:03 +00005703** for the following reasons:
5704**
5705** * An in-memory database can only have its journal_mode set to _OFF
5706** or _MEMORY.
5707**
5708** * The journal mode may not be changed while a transaction is active.
drh04335882008-09-26 21:08:08 +00005709**
danielk1977bea2a942009-01-20 17:06:27 +00005710** The returned indicate the current (possibly updated) journal-mode.
drh3b020132008-04-17 17:02:01 +00005711*/
5712int sqlite3PagerJournalMode(Pager *pPager, int eMode){
drh5d738542009-04-04 15:53:47 +00005713 assert( eMode==PAGER_JOURNALMODE_QUERY
5714 || eMode==PAGER_JOURNALMODE_DELETE
5715 || eMode==PAGER_JOURNALMODE_TRUNCATE
5716 || eMode==PAGER_JOURNALMODE_PERSIST
5717 || eMode==PAGER_JOURNALMODE_OFF
dan7c246102010-04-12 19:00:29 +00005718 || eMode==PAGER_JOURNALMODE_WAL
drh5d738542009-04-04 15:53:47 +00005719 || eMode==PAGER_JOURNALMODE_MEMORY );
5720 assert( PAGER_JOURNALMODE_QUERY<0 );
dane04dc882010-04-20 18:53:15 +00005721
5722 if( eMode==PAGER_JOURNALMODE_WAL
5723 && pPager->journalMode==PAGER_JOURNALMODE_DELETE
5724 ){
5725 pPager->journalMode = PAGER_JOURNALMODE_WAL;
5726 }else if( eMode>=0
dan7c246102010-04-12 19:00:29 +00005727 && (pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL)
5728 && (!MEMDB || eMode==PAGER_JOURNALMODE_MEMORY||eMode==PAGER_JOURNALMODE_OFF)
drh8a939192009-04-20 17:43:03 +00005729 && !pPager->dbModified
danielk1977f761f762009-04-28 05:27:20 +00005730 && (!isOpen(pPager->jfd) || 0==pPager->journalOff)
drh8a939192009-04-20 17:43:03 +00005731 ){
5732 if( isOpen(pPager->jfd) ){
5733 sqlite3OsClose(pPager->jfd);
5734 }
drhba726f42010-03-19 15:48:13 +00005735 assert( (PAGER_JOURNALMODE_TRUNCATE & 1)==1 );
5736 assert( (PAGER_JOURNALMODE_PERSIST & 1)==1 );
5737 assert( (PAGER_JOURNALMODE_DELETE & 1)==0 );
5738 assert( (PAGER_JOURNALMODE_MEMORY & 1)==0 );
5739 assert( (PAGER_JOURNALMODE_OFF & 1)==0 );
5740 if( (pPager->journalMode & 1)==1 && (eMode & 1)==0
5741 && !pPager->exclusiveMode ){
5742 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
5743 }
dan7c246102010-04-12 19:00:29 +00005744
drh5d738542009-04-04 15:53:47 +00005745 pPager->journalMode = (u8)eMode;
drh3b020132008-04-17 17:02:01 +00005746 }
drhfdc40e92008-04-17 20:59:37 +00005747 return (int)pPager->journalMode;
drh3b020132008-04-17 17:02:01 +00005748}
5749
danielk1977b53e4962008-06-04 06:45:59 +00005750/*
5751** Get/set the size-limit used for persistent journal files.
drh5d738542009-04-04 15:53:47 +00005752**
5753** Setting the size limit to -1 means no limit is enforced.
5754** An attempt to set a limit smaller than -1 is a no-op.
danielk1977b53e4962008-06-04 06:45:59 +00005755*/
5756i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
5757 if( iLimit>=-1 ){
5758 pPager->journalSizeLimit = iLimit;
5759 }
5760 return pPager->journalSizeLimit;
5761}
5762
danielk197704103022009-02-03 16:51:24 +00005763/*
5764** Return a pointer to the pPager->pBackup variable. The backup module
5765** in backup.c maintains the content of this variable. This module
5766** uses it opaquely as an argument to sqlite3BackupRestart() and
5767** sqlite3BackupUpdate() only.
5768*/
5769sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
5770 return &pPager->pBackup;
5771}
5772
dan7c246102010-04-12 19:00:29 +00005773/*
5774** This function is called when the user invokes "PRAGMA checkpoint".
5775*/
danf05c86d2010-04-13 11:56:03 +00005776int sqlite3PagerCheckpoint(Pager *pPager){
dan7c246102010-04-12 19:00:29 +00005777 int rc = SQLITE_OK;
5778 if( pPager->pLog ){
dan64d039e2010-04-13 19:27:31 +00005779 u8 *zBuf = (u8 *)pPager->pTmpSpace;
5780 rc = sqlite3LogCheckpoint(pPager->pLog, pPager->fd,
danc5118782010-04-17 17:34:41 +00005781 (pPager->noSync ? 0 : pPager->sync_flags),
dan64d039e2010-04-13 19:27:31 +00005782 zBuf, pPager->xBusyHandler, pPager->pBusyHandlerArg
5783 );
dan7c246102010-04-12 19:00:29 +00005784 }
5785 return rc;
5786}
5787
dan8d22a172010-04-19 18:03:51 +00005788int sqlite3PagerLogCallback(Pager *pPager){
5789 return sqlite3LogCallback(pPager->pLog);
5790}
5791
dane04dc882010-04-20 18:53:15 +00005792/*
5793** Open a connection to the write-ahead log file for pager pPager. If
5794** the log connection is already open, this function is a no-op.
5795**
5796** The caller must be holding a SHARED lock on the database file to call
5797** this function.
5798*/
5799int sqlite3PagerOpenLog(Pager *pPager, int *pisOpen){
5800 int rc = SQLITE_OK; /* Return code */
5801
danb9780022010-04-21 18:37:57 +00005802 assert( pPager->state>=PAGER_SHARED );
dane04dc882010-04-20 18:53:15 +00005803 if( !pPager->pLog ){
5804
5805 /* Open the connection to the log file. If this operation fails,
5806 ** (e.g. due to malloc() failure), unlock the database file and
5807 ** return an error code.
5808 */
5809 rc = sqlite3LogOpen(pPager->pVfs, pPager->zFilename, &pPager->pLog);
5810 if( rc==SQLITE_OK ){
5811 pPager->journalMode = PAGER_JOURNALMODE_WAL;
5812 }
5813 }else{
5814 *pisOpen = 1;
5815 }
5816
5817 return rc;
5818}
5819
5820
5821/*
5822** This function is called to close the connection to the log file prior
5823** to switching from WAL to rollback mode.
5824**
5825** Before closing the log file, this function attempts to take an
5826** EXCLUSIVE lock on the database file. If this cannot be obtained, an
5827** error (SQLITE_BUSY) is returned and the log connection is not closed.
5828** If successful, the EXCLUSIVE lock is not released before returning.
5829*/
5830int sqlite3PagerCloseLog(Pager *pPager){
5831 int rc = SQLITE_OK;
dane04dc882010-04-20 18:53:15 +00005832
danede6eb82010-04-22 06:27:04 +00005833 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
5834
5835 /* If the log file is not already open, but does exist in the file-system,
5836 ** it may need to be checkpointed before the connection can switch to
5837 ** rollback mode. Open it now so this can happen.
5838 */
5839 if( !pPager->pLog ){
5840 int logexists = 0;
5841 rc = sqlite3OsLock(pPager->fd, SQLITE_LOCK_SHARED);
5842 if( rc==SQLITE_OK ){
5843 rc = pagerHasWAL(pPager, &logexists);
5844 }
5845 if( rc==SQLITE_OK && logexists ){
5846 rc = sqlite3LogOpen(pPager->pVfs, pPager->zFilename, &pPager->pLog);
5847 }
5848 }
5849
5850 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
5851 ** the database file, the log and log-summary files will be deleted.
5852 */
5853 if( rc==SQLITE_OK && pPager->pLog ){
danb9780022010-04-21 18:37:57 +00005854 rc = sqlite3OsLock(pPager->fd, SQLITE_LOCK_EXCLUSIVE);
dane04dc882010-04-20 18:53:15 +00005855 if( rc==SQLITE_OK ){
5856 rc = sqlite3LogClose(pPager->pLog, pPager->fd,
5857 (pPager->noSync ? 0 : pPager->sync_flags),
5858 (u8*)pPager->pTmpSpace
5859 );
5860 pPager->pLog = 0;
5861 }
dane04dc882010-04-20 18:53:15 +00005862 }
5863 return rc;
5864}
5865
drh2e66f0b2005-04-28 17:18:48 +00005866#endif /* SQLITE_OMIT_DISKIO */