blob: fd364ae51bbc6d6934ed0750cc0a060e7cd10ca9 [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**
danielk197765839c62007-08-30 08:08:17 +000021** @(#) $Id: pager.c,v 1.381 2007/08/30 08:08:17 danielk1977 Exp $
drhed7c8552001-04-11 14:29:21 +000022*/
drh2e66f0b2005-04-28 17:18:48 +000023#ifndef SQLITE_OMIT_DISKIO
drhd9b02572001-04-15 00:37:09 +000024#include "sqliteInt.h"
drhed7c8552001-04-11 14:29:21 +000025#include <assert.h>
drhd9b02572001-04-15 00:37:09 +000026#include <string.h>
drhed7c8552001-04-11 14:29:21 +000027
28/*
drhdb48ee02003-01-16 13:42:43 +000029** Macros for troubleshooting. Normally turned off
30*/
danielk1977466be562004-06-10 02:16:01 +000031#if 0
drhd3627af2006-12-18 18:34:51 +000032#define sqlite3DebugPrintf printf
drh4f0c5872007-03-26 22:05:01 +000033#define PAGERTRACE1(X) sqlite3DebugPrintf(X)
34#define PAGERTRACE2(X,Y) sqlite3DebugPrintf(X,Y)
35#define PAGERTRACE3(X,Y,Z) sqlite3DebugPrintf(X,Y,Z)
36#define PAGERTRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W)
37#define PAGERTRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V)
drhdb48ee02003-01-16 13:42:43 +000038#else
drh4f0c5872007-03-26 22:05:01 +000039#define PAGERTRACE1(X)
40#define PAGERTRACE2(X,Y)
41#define PAGERTRACE3(X,Y,Z)
42#define PAGERTRACE4(X,Y,Z,W)
43#define PAGERTRACE5(X,Y,Z,W,V)
drhdb48ee02003-01-16 13:42:43 +000044#endif
45
danielk1977599fcba2004-11-08 07:13:13 +000046/*
drh4f0c5872007-03-26 22:05:01 +000047** The following two macros are used within the PAGERTRACEX() macros above
drhd86959f2005-11-26 03:51:18 +000048** to print out file-descriptors.
danielk1977599fcba2004-11-08 07:13:13 +000049**
50** PAGERID() takes a pointer to a Pager struct as it's argument. The
danielk197762079062007-08-15 17:08:46 +000051** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
danielk1977599fcba2004-11-08 07:13:13 +000052** struct as it's argument.
53*/
drhc001c582006-03-06 18:23:16 +000054#define PAGERID(p) ((int)(p->fd))
55#define FILEHANDLEID(fd) ((int)fd)
drhdb48ee02003-01-16 13:42:43 +000056
57/*
drhed7c8552001-04-11 14:29:21 +000058** The page cache as a whole is always in one of the following
59** states:
60**
drha6abd042004-06-09 17:37:22 +000061** PAGER_UNLOCK The page cache is not currently reading or
drhed7c8552001-04-11 14:29:21 +000062** writing the database file. There is no
63** data held in memory. This is the initial
64** state.
65**
drha6abd042004-06-09 17:37:22 +000066** PAGER_SHARED The page cache is reading the database.
drhed7c8552001-04-11 14:29:21 +000067** Writing is not permitted. There can be
68** multiple readers accessing the same database
drh69688d52001-04-14 16:38:23 +000069** file at the same time.
drhed7c8552001-04-11 14:29:21 +000070**
drh726de592004-06-10 23:35:50 +000071** PAGER_RESERVED This process has reserved the database for writing
72** but has not yet made any changes. Only one process
73** at a time can reserve the database. The original
74** database file has not been modified so other
75** processes may still be reading the on-disk
drha6abd042004-06-09 17:37:22 +000076** database file.
77**
78** PAGER_EXCLUSIVE The page cache is writing the database.
drhed7c8552001-04-11 14:29:21 +000079** Access is exclusive. No other processes or
80** threads can be reading or writing while one
81** process is writing.
82**
danielk1977aa5ccdf2004-06-14 05:10:42 +000083** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE
84** after all dirty pages have been written to the
85** database file and the file has been synced to
drh369339d2007-03-30 16:01:55 +000086** disk. All that remains to do is to remove or
87** truncate the journal file and the transaction
88** will be committed.
danielk1977aa5ccdf2004-06-14 05:10:42 +000089**
drha6abd042004-06-09 17:37:22 +000090** The page cache comes up in PAGER_UNLOCK. The first time a
danielk19773b8a05f2007-03-19 17:44:26 +000091** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED.
drhed7c8552001-04-11 14:29:21 +000092** After all pages have been released using sqlite_page_unref(),
drha6abd042004-06-09 17:37:22 +000093** the state transitions back to PAGER_UNLOCK. The first time
danielk19773b8a05f2007-03-19 17:44:26 +000094** that sqlite3PagerWrite() is called, the state transitions to
drh369339d2007-03-30 16:01:55 +000095** PAGER_RESERVED. (Note that sqlite3PagerWrite() can only be
drh306dc212001-05-21 13:45:10 +000096** called on an outstanding page which means that the pager must
drha6abd042004-06-09 17:37:22 +000097** be in PAGER_SHARED before it transitions to PAGER_RESERVED.)
drh369339d2007-03-30 16:01:55 +000098** PAGER_RESERVED means that there is an open rollback journal.
99** The transition to PAGER_EXCLUSIVE occurs before any changes
100** are made to the database file, though writes to the rollback
101** journal occurs with just PAGER_RESERVED. After an sqlite3PagerRollback()
102** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED,
103** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode.
drhed7c8552001-04-11 14:29:21 +0000104*/
drha6abd042004-06-09 17:37:22 +0000105#define PAGER_UNLOCK 0
drh684917c2004-10-05 02:41:42 +0000106#define PAGER_SHARED 1 /* same as SHARED_LOCK */
107#define PAGER_RESERVED 2 /* same as RESERVED_LOCK */
108#define PAGER_EXCLUSIVE 4 /* same as EXCLUSIVE_LOCK */
109#define PAGER_SYNCED 5
drhed7c8552001-04-11 14:29:21 +0000110
drh684917c2004-10-05 02:41:42 +0000111/*
112** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time,
113** then failed attempts to get a reserved lock will invoke the busy callback.
114** This is off by default. To see why, consider the following scenario:
115**
116** Suppose thread A already has a shared lock and wants a reserved lock.
117** Thread B already has a reserved lock and wants an exclusive lock. If
118** both threads are using their busy callbacks, it might be a long time
119** be for one of the threads give up and allows the other to proceed.
120** But if the thread trying to get the reserved lock gives up quickly
121** (if it never invokes its busy callback) then the contention will be
122** resolved quickly.
123*/
124#ifndef SQLITE_BUSY_RESERVED_LOCK
125# define SQLITE_BUSY_RESERVED_LOCK 0
126#endif
drhd9b02572001-04-15 00:37:09 +0000127
drhed7c8552001-04-11 14:29:21 +0000128/*
drh887dc4c2004-10-22 16:22:57 +0000129** This macro rounds values up so that if the value is an address it
130** is guaranteed to be an address that is aligned to an 8-byte boundary.
131*/
132#define FORCE_ALIGNMENT(X) (((X)+7)&~7)
133
danielk19779f61c2f2007-08-27 17:27:49 +0000134typedef struct PgHdr PgHdr;
danielk197784f786f2007-08-28 08:00:17 +0000135
136/*
137** Each pager stores all currently unreferenced pages in a list sorted
138** in least-recently-used (LRU) order (i.e. the first item on the list has
139** not been referenced in a long time, the last item has been recently
140** used). An instance of this structure is included as part of each
141** pager structure for this purpose (variable Pager.lru).
142**
143** Additionally, if memory-management is enabled, all unreferenced pages
144** are stored in a global LRU list (global variable sqlite3LruPageList).
145**
146** In both cases, the PagerLruList.pFirstSynced variable points to
147** the first page in the corresponding list that does not require an
148** fsync() operation before it's memory can be reclaimed. If no such
149** page exists, PagerLruList.pFirstSynced is set to NULL.
150*/
151typedef struct PagerLruList PagerLruList;
152struct PagerLruList {
153 PgHdr *pFirst; /* First page in LRU list */
154 PgHdr *pLast; /* Last page in LRU list (the most recently used) */
155 PgHdr *pFirstSynced; /* First page in list with PgHdr.needSync==0 */
156};
157
158/*
159** The following structure contains the next and previous pointers used
160** to link a PgHdr structure into a PagerLruList linked list.
161*/
danielk19779f61c2f2007-08-27 17:27:49 +0000162typedef struct PagerLruLink PagerLruLink;
163struct PagerLruLink {
164 PgHdr *pNext;
165 PgHdr *pPrev;
166};
167
drh887dc4c2004-10-22 16:22:57 +0000168/*
drhed7c8552001-04-11 14:29:21 +0000169** Each in-memory image of a page begins with the following header.
drhbd03cae2001-06-02 02:40:57 +0000170** This header is only visible to this pager module. The client
171** code that calls pager sees only the data that follows the header.
drhf6038712004-02-08 18:07:34 +0000172**
danielk19773b8a05f2007-03-19 17:44:26 +0000173** Client code should call sqlite3PagerWrite() on a page prior to making
174** any modifications to that page. The first time sqlite3PagerWrite()
drhf6038712004-02-08 18:07:34 +0000175** is called, the original page contents are written into the rollback
176** journal and PgHdr.inJournal and PgHdr.needSync are set. Later, once
177** the journal page has made it onto the disk surface, PgHdr.needSync
178** is cleared. The modified page cannot be written back into the original
179** database file until the journal pages has been synced to disk and the
180** PgHdr.needSync has been cleared.
181**
danielk19773b8a05f2007-03-19 17:44:26 +0000182** The PgHdr.dirty flag is set when sqlite3PagerWrite() is called and
drhf6038712004-02-08 18:07:34 +0000183** is cleared again when the page content is written back to the original
184** database file.
drh732c8172007-06-16 11:17:45 +0000185**
186** Details of important structure elements:
187**
188** needSync
189**
190** If this is true, this means that it is not safe to write the page
191** content to the database because the original content needed
192** for rollback has not by synced to the main rollback journal.
193** The original content may have been written to the rollback journal
194** but it has not yet been synced. So we cannot write to the database
195** file because power failure might cause the page in the journal file
196** to never reach the disk. It is as if the write to the journal file
197** does not occur until the journal file is synced.
198**
199** This flag is false if the page content exactly matches what
200** currently exists in the database file. The needSync flag is also
201** false if the original content has been written to the main rollback
202** journal and synced. If the page represents a new page that has
203** been added onto the end of the database during the current
204** transaction, the needSync flag is true until the original database
205** size in the journal header has been synced to disk.
206**
207** inJournal
208**
209** This is true if the original page has been written into the main
210** rollback journal. This is always false for new pages added to
211** the end of the database file during the current transaction.
212** And this flag says nothing about whether or not the journal
213** has been synced to disk. For pages that are in the original
214** database file, the following expression should always be true:
215**
216** inJournal = (pPager->aInJournal[(pgno-1)/8] & (1<<((pgno-1)%8))!=0
217**
218** The pPager->aInJournal[] array is only valid for the original
219** pages of the database, not new pages that are added to the end
220** of the database, so obviously the above expression cannot be
221** valid for new pages. For new pages inJournal is always 0.
222**
223** dirty
224**
225** When true, this means that the content of the page has been
226** modified and needs to be written back to the database file.
227** If false, it means that either the content of the page is
228** unchanged or else the content is unimportant and we do not
229** care whether or not it is preserved.
230**
231** alwaysRollback
232**
233** This means that the sqlite3PagerDontRollback() API should be
234** ignored for this page. The DontRollback() API attempts to say
235** that the content of the page on disk is unimportant (it is an
236** unused page on the freelist) so that it is unnecessary to
237** rollback changes to this page because the content of the page
238** can change without changing the meaning of the database. This
239** flag overrides any DontRollback() attempt. This flag is set
240** when a page that originally contained valid data is added to
241** the freelist. Later in the same transaction, this page might
242** be pulled from the freelist and reused for something different
243** and at that point the DontRollback() API will be called because
244** pages taken from the freelist do not need to be protected by
245** the rollback journal. But this flag says that the page was
246** not originally part of the freelist so that it still needs to
247** be rolled back in spite of any subsequent DontRollback() calls.
248**
249** needRead
250**
251** This flag means (when true) that the content of the page has
252** not yet been loaded from disk. The in-memory content is just
253** garbage. (Actually, we zero the content, but you should not
254** make any assumptions about the content nevertheless.) If the
255** content is needed in the future, it should be read from the
256** original database file.
drhed7c8552001-04-11 14:29:21 +0000257*/
258struct PgHdr {
259 Pager *pPager; /* The pager to which this page belongs */
260 Pgno pgno; /* The page number for this page */
drh69688d52001-04-14 16:38:23 +0000261 PgHdr *pNextHash, *pPrevHash; /* Hash collision chain for PgHdr.pgno */
danielk19779f61c2f2007-08-27 17:27:49 +0000262 PagerLruLink free; /* Next and previous free pages */
drhac69b052004-05-12 13:30:07 +0000263 PgHdr *pNextAll; /* A list of all pages */
drh193a6b42002-07-07 16:52:46 +0000264 u8 inJournal; /* TRUE if has been written to journal */
drh193a6b42002-07-07 16:52:46 +0000265 u8 dirty; /* TRUE if we need to write back changes */
drhdb48ee02003-01-16 13:42:43 +0000266 u8 needSync; /* Sync journal before writing this page */
drh80e35f42007-03-30 14:06:34 +0000267 u8 alwaysRollback; /* Disable DontRollback() for this page */
drh538f5702007-04-13 02:14:30 +0000268 u8 needRead; /* Read content if PagerWrite() is called */
drhac69b052004-05-12 13:30:07 +0000269 short int nRef; /* Number of users of this page */
drhdc3e10b2006-06-15 14:31:06 +0000270 PgHdr *pDirty, *pPrevDirty; /* Dirty pages */
danielk19779f61c2f2007-08-27 17:27:49 +0000271#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
272 PagerLruLink gfree; /* Global list of nRef==0 pages */
273#endif
drh605ad8f2006-05-03 23:34:05 +0000274 u32 notUsed; /* Buffer space */
danielk19773c407372005-02-15 02:54:14 +0000275#ifdef SQLITE_CHECK_PAGES
276 u32 pageHash;
277#endif
drh1c7880e2005-05-20 20:01:55 +0000278 /* pPager->pageSize bytes of page data follow this header */
drh973b6e32003-02-12 14:09:42 +0000279 /* Pager.nExtra bytes of local data follow the page data */
drhed7c8552001-04-11 14:29:21 +0000280};
281
drhac69b052004-05-12 13:30:07 +0000282/*
283** For an in-memory only database, some extra information is recorded about
284** each page so that changes can be rolled back. (Journal files are not
285** used for in-memory databases.) The following information is added to
286** the end of every EXTRA block for in-memory databases.
287**
288** This information could have been added directly to the PgHdr structure.
289** But then it would take up an extra 8 bytes of storage on every PgHdr
290** even for disk-based databases. Splitting it out saves 8 bytes. This
291** is only a savings of 0.8% but those percentages add up.
292*/
293typedef struct PgHistory PgHistory;
294struct PgHistory {
295 u8 *pOrig; /* Original page text. Restore to this on a full rollback */
296 u8 *pStmt; /* Text as it was at the beginning of the current statement */
danielk1977f35843b2007-04-07 15:03:17 +0000297 PgHdr *pNextStmt, *pPrevStmt; /* List of pages in the statement journal */
298 u8 inStmt; /* TRUE if in the statement subjournal */
drhac69b052004-05-12 13:30:07 +0000299};
drh9eb9e262004-02-11 02:18:05 +0000300
301/*
302** A macro used for invoking the codec if there is one
303*/
304#ifdef SQLITE_HAS_CODEC
drhc001c582006-03-06 18:23:16 +0000305# define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); }
306# define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D))
drh9eb9e262004-02-11 02:18:05 +0000307#else
drhc001c582006-03-06 18:23:16 +0000308# define CODEC1(P,D,N,X) /* NO-OP */
309# define CODEC2(P,D,N,X) ((char*)D)
drh9eb9e262004-02-11 02:18:05 +0000310#endif
311
drhed7c8552001-04-11 14:29:21 +0000312/*
drh69688d52001-04-14 16:38:23 +0000313** Convert a pointer to a PgHdr into a pointer to its data
314** and back again.
drhed7c8552001-04-11 14:29:21 +0000315*/
316#define PGHDR_TO_DATA(P) ((void*)(&(P)[1]))
317#define DATA_TO_PGHDR(D) (&((PgHdr*)(D))[-1])
drh1c7880e2005-05-20 20:01:55 +0000318#define PGHDR_TO_EXTRA(G,P) ((void*)&((char*)(&(G)[1]))[(P)->pageSize])
drhac69b052004-05-12 13:30:07 +0000319#define PGHDR_TO_HIST(P,PGR) \
drh1c7880e2005-05-20 20:01:55 +0000320 ((PgHistory*)&((char*)(&(P)[1]))[(PGR)->pageSize+(PGR)->nExtra])
drhed7c8552001-04-11 14:29:21 +0000321
322/*
drhed7c8552001-04-11 14:29:21 +0000323** A open page cache is an instance of the following structure.
danielk1977efaaf572006-01-16 11:29:19 +0000324**
drh4f0ee682007-03-30 20:43:40 +0000325** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
danielk1977efaaf572006-01-16 11:29:19 +0000326** or SQLITE_FULL. Once one of the first three errors occurs, it persists
327** and is returned as the result of every major pager API call. The
328** SQLITE_FULL return code is slightly different. It persists only until the
329** next successful rollback is performed on the pager cache. Also,
danielk19773b8a05f2007-03-19 17:44:26 +0000330** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()
danielk1977efaaf572006-01-16 11:29:19 +0000331** APIs, they may still be used successfully.
drhed7c8552001-04-11 14:29:21 +0000332*/
333struct Pager {
danielk1977b4b47412007-08-17 15:53:36 +0000334 sqlite3_vfs *pVfs; /* OS functions to use for IO */
drh603240c2002-03-05 01:11:12 +0000335 u8 journalOpen; /* True if journal file descriptors is valid */
drh34e79ce2004-02-08 06:05:46 +0000336 u8 journalStarted; /* True if header of journal is synced */
337 u8 useJournal; /* Use a rollback journal on this file */
drh7bec5052005-02-06 02:45:41 +0000338 u8 noReadlock; /* Do not bother to obtain readlocks */
drhac69b052004-05-12 13:30:07 +0000339 u8 stmtOpen; /* True if the statement subjournal is open */
340 u8 stmtInUse; /* True we are in a statement subtransaction */
341 u8 stmtAutoopen; /* Open stmt journal when main journal is opened*/
drh603240c2002-03-05 01:11:12 +0000342 u8 noSync; /* Do not sync the journal if true */
drh968af522003-02-11 14:55:40 +0000343 u8 fullSync; /* Do extra syncs of the journal for robustness */
danielk1977f036aef2007-08-20 05:36:51 +0000344 u8 sync_flags; /* One of SYNC_NORMAL or SYNC_FULL */
drha6abd042004-06-09 17:37:22 +0000345 u8 state; /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */
drh603240c2002-03-05 01:11:12 +0000346 u8 tempFile; /* zFilename is a temporary file */
347 u8 readOnly; /* True for a read-only database */
348 u8 needSync; /* True if an fsync() is needed on the journal */
drha6abd042004-06-09 17:37:22 +0000349 u8 dirtyCache; /* True if cached pages have changed */
drh80e35f42007-03-30 14:06:34 +0000350 u8 alwaysRollback; /* Disable DontRollback() for all pages */
drhac69b052004-05-12 13:30:07 +0000351 u8 memDb; /* True to inhibit all file I/O */
drh6d156e42005-05-20 20:11:20 +0000352 u8 setMaster; /* True if a m-j name has been written to jrnl */
drh80e35f42007-03-30 14:06:34 +0000353 u8 doNotSync; /* Boolean. While true, do not spill the cache */
354 u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
355 u8 changeCountDone; /* Set after incrementing the change-counter */
drhe49f9822006-09-15 12:29:16 +0000356 int errCode; /* One of several kinds of errors */
drhfcd35c72005-05-21 02:48:08 +0000357 int dbSize; /* Number of pages in the file */
358 int origDbSize; /* dbSize before the current change */
359 int stmtSize; /* Size of database (in pages) at stmt_begin() */
360 int nRec; /* Number of pages written to the journal */
361 u32 cksumInit; /* Quasi-random value added to every checksum */
362 int stmtNRec; /* Number of records in stmt subjournal */
363 int nExtra; /* Add this many bytes to each in-memory page */
364 int pageSize; /* Number of bytes in a page */
365 int nPage; /* Total number of in-memory pages */
drhfcd35c72005-05-21 02:48:08 +0000366 int nRef; /* Number of in-memory pages with PgHdr.nRef>0 */
367 int mxPage; /* Maximum number of pages to hold in cache */
drhf8e632b2007-05-08 14:51:36 +0000368 Pgno mxPgno; /* Maximum allowed size of the database */
drh603240c2002-03-05 01:11:12 +0000369 u8 *aInJournal; /* One bit for each page in the database file */
drhac69b052004-05-12 13:30:07 +0000370 u8 *aInStmt; /* One bit for each page in the database */
drhfcd35c72005-05-21 02:48:08 +0000371 char *zFilename; /* Name of the database file */
372 char *zJournal; /* Name of the journal file */
373 char *zDirectory; /* Directory hold database and journal files */
danielk197762079062007-08-15 17:08:46 +0000374 sqlite3_file *fd, *jfd; /* File descriptors for database and journal */
375 sqlite3_file *stfd; /* File descriptor for the statement subjournal*/
drh726de592004-06-10 23:35:50 +0000376 BusyHandler *pBusyHandler; /* Pointer to sqlite.busyHandler */
danielk19779f61c2f2007-08-27 17:27:49 +0000377 PagerLruList lru; /* LRU list of free pages */
drhd9b02572001-04-15 00:37:09 +0000378 PgHdr *pAll; /* List of all pages */
drhac69b052004-05-12 13:30:07 +0000379 PgHdr *pStmt; /* List of pages in the statement subjournal */
drh605ad8f2006-05-03 23:34:05 +0000380 PgHdr *pDirty; /* List of all dirty pages */
drheb206252004-10-01 02:00:31 +0000381 i64 journalOff; /* Current byte offset in the journal file */
382 i64 journalHdr; /* Byte offset to previous journal header */
383 i64 stmtHdrOff; /* First journal header written this statement */
384 i64 stmtCksum; /* cksumInit when statement was started */
drh6d156e42005-05-20 20:11:20 +0000385 i64 stmtJSize; /* Size of journal at stmt_begin() */
danielk197776572402004-06-25 02:38:54 +0000386 int sectorSize; /* Assumed sector size during rollback */
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
danielk19773b8a05f2007-03-19 17:44:26 +0000391 void (*xDestructor)(DbPage*,int); /* Call this routine when freeing pages */
392 void (*xReiniter)(DbPage*,int); /* Call this routine when reloading pages */
drh7c4ac0c2007-04-05 11:25:58 +0000393#ifdef SQLITE_HAS_CODEC
drhc001c582006-03-06 18:23:16 +0000394 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
drh6d156e42005-05-20 20:11:20 +0000395 void *pCodecArg; /* First argument to xCodec() */
drh7c4ac0c2007-04-05 11:25:58 +0000396#endif
drh8ca0c722006-05-07 17:49:38 +0000397 int nHash; /* Size of the pager hash table */
398 PgHdr **aHash; /* Hash table to map page number to PgHdr */
drh6f7adc82006-01-11 21:41:20 +0000399#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
drh86f8c192007-08-22 00:39:19 +0000400 Pager *pNext; /* Doubly linked list of pagers on which */
401 Pager *pPrev; /* sqlite3_release_memory() will work */
402 int iInUseMM; /* Non-zero if unavailable to MM */
403 int iInUseDB; /* Non-zero if in sqlite3_release_memory() */
danielk197713f72992005-12-18 08:51:22 +0000404#endif
danielk19778186df82007-03-06 13:45:59 +0000405 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
drh86a88112007-04-16 15:02:19 +0000406 char dbFileVers[16]; /* Changes whenever database file changes */
drhd9b02572001-04-15 00:37:09 +0000407};
408
409/*
drh538f5702007-04-13 02:14:30 +0000410** The following global variables hold counters used for
411** testing purposes only. These variables do not exist in
412** a non-testing build. These variables are not thread-safe.
drhfcd35c72005-05-21 02:48:08 +0000413*/
414#ifdef SQLITE_TEST
drh538f5702007-04-13 02:14:30 +0000415int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
416int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
417int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
418int sqlite3_pager_pgfree_count = 0; /* Number of cache pages freed */
419# define PAGER_INCR(v) v++
drhfcd35c72005-05-21 02:48:08 +0000420#else
drh538f5702007-04-13 02:14:30 +0000421# define PAGER_INCR(v)
drhfcd35c72005-05-21 02:48:08 +0000422#endif
423
drh86f8c192007-08-22 00:39:19 +0000424/*
425** The following variable points to the head of a double-linked list
426** of all pagers that are eligible for page stealing by the
427** sqlite3_release_memory() interface. Access to this list is
428** protected by the SQLITE_MUTEX_STATIC_MEM2 mutex.
429*/
430#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
431static Pager *sqlite3PagerList = 0;
danielk19779f61c2f2007-08-27 17:27:49 +0000432static PagerLruList sqlite3LruPageList = {0, 0, 0};
drh86f8c192007-08-22 00:39:19 +0000433#endif
drh538f5702007-04-13 02:14:30 +0000434
435
drhfcd35c72005-05-21 02:48:08 +0000436/*
drh5e00f6c2001-09-13 13:46:56 +0000437** Journal files begin with the following magic string. The data
438** was obtained from /dev/random. It is used only as a sanity check.
drh94f33312002-08-12 12:29:56 +0000439**
drhae2b40c2004-06-09 19:03:54 +0000440** Since version 2.8.0, the journal format contains additional sanity
441** checking information. If the power fails while the journal is begin
442** written, semi-random garbage data might appear in the journal
443** file after power is restored. If an attempt is then made
drh968af522003-02-11 14:55:40 +0000444** to roll the journal back, the database could be corrupted. The additional
445** sanity checking data is an attempt to discover the garbage in the
446** journal and ignore it.
447**
drhae2b40c2004-06-09 19:03:54 +0000448** The sanity checking information for the new journal format consists
drh968af522003-02-11 14:55:40 +0000449** of a 32-bit checksum on each page of data. The checksum covers both
drh90f5ecb2004-07-22 01:19:35 +0000450** the page number and the pPager->pageSize bytes of data for the page.
drh968af522003-02-11 14:55:40 +0000451** This cksum is initialized to a 32-bit random value that appears in the
452** journal file right after the header. The random initializer is important,
453** because garbage data that appears at the end of a journal is likely
454** data that was once in other files that have now been deleted. If the
455** garbage data came from an obsolete journal file, the checksums might
456** be correct. But by initializing the checksum to random value which
457** is different for every journal, we minimize that risk.
drhd9b02572001-04-15 00:37:09 +0000458*/
drhae2b40c2004-06-09 19:03:54 +0000459static const unsigned char aJournalMagic[] = {
460 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
drhed7c8552001-04-11 14:29:21 +0000461};
462
463/*
drh726de592004-06-10 23:35:50 +0000464** The size of the header and of each page in the journal is determined
465** by the following macros.
drh968af522003-02-11 14:55:40 +0000466*/
drhae2b40c2004-06-09 19:03:54 +0000467#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
drh968af522003-02-11 14:55:40 +0000468
danielk197776572402004-06-25 02:38:54 +0000469/*
470** The journal header size for this pager. In the future, this could be
471** set to some value read from the disk controller. The important
472** characteristic is that it is the same size as a disk sector.
473*/
474#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
475
drhb7f91642004-10-31 02:22:47 +0000476/*
477** The macro MEMDB is true if we are dealing with an in-memory database.
478** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
479** the value of MEMDB will be a constant and the compiler will optimize
480** out code that would never execute.
481*/
482#ifdef SQLITE_OMIT_MEMORYDB
483# define MEMDB 0
484#else
485# define MEMDB pPager->memDb
486#endif
487
488/*
danielk197776572402004-06-25 02:38:54 +0000489** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
490** reserved for working around a windows/posix incompatibility). It is
491** used in the journal to signify that the remainder of the journal file
492** is devoted to storing a master journal name - there are no more pages to
493** roll back. See comments for function writeMasterJournal() for details.
494*/
danielk1977599fcba2004-11-08 07:13:13 +0000495/* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */
496#define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1)
danielk197713adf8a2004-06-03 16:08:41 +0000497
drh968af522003-02-11 14:55:40 +0000498/*
danielk197726836652005-01-17 01:33:13 +0000499** The maximum legal page number is (2^31 - 1).
500*/
501#define PAGER_MAX_PGNO 2147483647
502
503/*
drh86f8c192007-08-22 00:39:19 +0000504** The pagerEnter() and pagerLeave() routines acquire and release
505** a mutex on each pager. The mutex is recursive.
506**
507** This is a special-purpose mutex. It only provides mutual exclusion
508** between the Btree and the Memory Management sqlite3_release_memory()
509** function. It does not prevent, for example, two Btrees from accessing
510** the same pager at the same time. Other general-purpose mutexes in
511** the btree layer handle that chore.
512*/
513#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
514 static void pagerEnter(Pager *p){
515 p->iInUseDB++;
516 if( p->iInUseMM && p->iInUseDB==1 ){
517 sqlite3_mutex *mutex;
518 mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
519 p->iInUseDB = 0;
520 sqlite3_mutex_enter(mutex);
521 p->iInUseDB = 1;
522 sqlite3_mutex_leave(mutex);
523 }
524 assert( p->iInUseMM==0 );
525 }
526 static void pagerLeave(Pager *p){
527 p->iInUseDB--;
528 assert( p->iInUseDB>=0 );
529 }
530#else
531# define pagerEnter(X)
532# define pagerLeave(X)
533#endif
534
535/*
drh726de592004-06-10 23:35:50 +0000536** Enable reference count tracking (for debugging) here:
drhdd793422001-06-28 01:54:48 +0000537*/
drh7c4ac0c2007-04-05 11:25:58 +0000538#ifdef SQLITE_DEBUG
drh3aac2dd2004-04-26 14:10:20 +0000539 int pager3_refinfo_enable = 0;
drhdd793422001-06-28 01:54:48 +0000540 static void pager_refinfo(PgHdr *p){
541 static int cnt = 0;
drh3aac2dd2004-04-26 14:10:20 +0000542 if( !pager3_refinfo_enable ) return;
drhfe63d1c2004-09-08 20:13:04 +0000543 sqlite3DebugPrintf(
drh24c9a2e2007-01-05 02:00:47 +0000544 "REFCNT: %4d addr=%p nRef=%-3d total=%d\n",
545 p->pgno, PGHDR_TO_DATA(p), p->nRef, p->pPager->nRef
drhdd793422001-06-28 01:54:48 +0000546 );
547 cnt++; /* Something to set a breakpoint on */
548 }
549# define REFINFO(X) pager_refinfo(X)
550#else
551# define REFINFO(X)
552#endif
553
danielk197784f786f2007-08-28 08:00:17 +0000554/*
555** Add page pPg to the end of the linked list managed by structure
556** pList (pPg becomes the last entry in the list - the most recently
557** used). Argument pLink should point to either pPg->free or pPg->gfree,
558** depending on whether pPg is being added to the pager-specific or
559** global LRU list.
560*/
danielk19779f61c2f2007-08-27 17:27:49 +0000561static void listAdd(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){
562 pLink->pNext = 0;
563 pLink->pPrev = pList->pLast;
564
danielk197784f786f2007-08-28 08:00:17 +0000565#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
566 assert(pLink==&pPg->free || pLink==&pPg->gfree);
567 assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);
568#endif
569
danielk19779f61c2f2007-08-27 17:27:49 +0000570 if( pList->pLast ){
571 int iOff = (char *)pLink - (char *)pPg;
572 PagerLruLink *pLastLink = (PagerLruLink *)(&((u8 *)pList->pLast)[iOff]);
573 pLastLink->pNext = pPg;
574 }else{
575 assert(!pList->pFirst);
576 pList->pFirst = pPg;
577 }
578
579 pList->pLast = pPg;
580 if( !pList->pFirstSynced && pPg->needSync==0 ){
581 pList->pFirstSynced = pPg;
582 }
583}
584
danielk197784f786f2007-08-28 08:00:17 +0000585/*
586** Remove pPg from the list managed by the structure pointed to by pList.
587**
588** Argument pLink should point to either pPg->free or pPg->gfree, depending
589** on whether pPg is being added to the pager-specific or global LRU list.
590*/
danielk19779f61c2f2007-08-27 17:27:49 +0000591static void listRemove(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){
592 int iOff = (char *)pLink - (char *)pPg;
593
danielk197784f786f2007-08-28 08:00:17 +0000594#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
595 assert(pLink==&pPg->free || pLink==&pPg->gfree);
596 assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);
597#endif
598
danielk19779f61c2f2007-08-27 17:27:49 +0000599 if( pPg==pList->pFirst ){
600 pList->pFirst = pLink->pNext;
601 }
602 if( pPg==pList->pLast ){
603 pList->pLast = pLink->pPrev;
604 }
605 if( pLink->pPrev ){
606 PagerLruLink *pPrevLink = (PagerLruLink *)(&((u8 *)pLink->pPrev)[iOff]);
607 pPrevLink->pNext = pLink->pNext;
608 }
609 if( pLink->pNext ){
610 PagerLruLink *pNextLink = (PagerLruLink *)(&((u8 *)pLink->pNext)[iOff]);
611 pNextLink->pPrev = pLink->pPrev;
612 }
613 if( pPg==pList->pFirstSynced ){
614 PgHdr *p = pLink->pNext;
615 while( p && p->needSync ){
616 PagerLruLink *pL = (PagerLruLink *)(&((u8 *)p)[iOff]);
617 p = pL->pNext;
618 }
619 pList->pFirstSynced = p;
620 }
621
622 pLink->pNext = pLink->pPrev = 0;
623}
624
625/*
danielk197784f786f2007-08-28 08:00:17 +0000626** Add page pPg to the list of free pages for the pager. If
627** memory-management is enabled, also add the page to the global
628** list of free pages.
danielk19779f61c2f2007-08-27 17:27:49 +0000629*/
630static void lruListAdd(PgHdr *pPg){
631 listAdd(&pPg->pPager->lru, &pPg->free, pPg);
632#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
633 if( !pPg->pPager->memDb ){
634 sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
635 listAdd(&sqlite3LruPageList, &pPg->gfree, pPg);
636 sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
637 }
638#endif
639}
640
641/*
danielk197784f786f2007-08-28 08:00:17 +0000642** Remove page pPg from the list of free pages for the associated pager.
643** If memory-management is enabled, also remove pPg from the global list
644** of free pages.
danielk19779f61c2f2007-08-27 17:27:49 +0000645*/
646static void lruListRemove(PgHdr *pPg){
647 listRemove(&pPg->pPager->lru, &pPg->free, pPg);
648#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
649 if( !pPg->pPager->memDb ){
650 sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
651 listRemove(&sqlite3LruPageList, &pPg->gfree, pPg);
652 sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
653 }
654#endif
655}
656
657/*
danielk197784f786f2007-08-28 08:00:17 +0000658** This function is called just after the needSync flag has been cleared
659** from all pages managed by pPager (usually because the journal file
660** has just been synced). It updates the pPager->lru.pFirstSynced variable
661** and, if memory-management is enabled, the sqlite3LruPageList.pFirstSynced
662** variable also.
danielk19779f61c2f2007-08-27 17:27:49 +0000663*/
664static void lruListSetFirstSynced(Pager *pPager){
665 pPager->lru.pFirstSynced = pPager->lru.pFirst;
666#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
667 if( !pPager->memDb ){
668 PgHdr *p;
669 sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
670 for(p=sqlite3LruPageList.pFirst; p && p->needSync; p=p->gfree.pNext);
671 assert(p==pPager->lru.pFirstSynced || p==sqlite3LruPageList.pFirstSynced);
672 sqlite3LruPageList.pFirstSynced = p;
673 sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
674 }
675#endif
676}
677
danielk1977f35843b2007-04-07 15:03:17 +0000678/*
679** Return true if page *pPg has already been written to the statement
680** journal (or statement snapshot has been created, if *pPg is part
681** of an in-memory database).
682*/
683static int pageInStatement(PgHdr *pPg){
684 Pager *pPager = pPg->pPager;
685 if( MEMDB ){
686 return PGHDR_TO_HIST(pPg, pPager)->inStmt;
687 }else{
688 Pgno pgno = pPg->pgno;
689 u8 *a = pPager->aInStmt;
690 return (a && (int)pgno<=pPager->stmtSize && (a[pgno/8] & (1<<(pgno&7))));
691 }
692}
drh8ca0c722006-05-07 17:49:38 +0000693
694/*
695** Change the size of the pager hash table to N. N must be a power
696** of two.
697*/
698static void pager_resize_hash_table(Pager *pPager, int N){
699 PgHdr **aHash, *pPg;
700 assert( N>0 && (N&(N-1))==0 );
drhed138fb2007-08-22 22:04:37 +0000701 pagerLeave(pPager);
danielk1977a1644fd2007-08-29 12:31:25 +0000702 sqlite3MallocBenignFailure((int)pPager->aHash);
drh17435752007-08-16 04:30:38 +0000703 aHash = sqlite3MallocZero( sizeof(aHash[0])*N );
drhed138fb2007-08-22 22:04:37 +0000704 pagerEnter(pPager);
drh8ca0c722006-05-07 17:49:38 +0000705 if( aHash==0 ){
706 /* Failure to rehash is not an error. It is only a performance hit. */
707 return;
708 }
drh17435752007-08-16 04:30:38 +0000709 sqlite3_free(pPager->aHash);
drh8ca0c722006-05-07 17:49:38 +0000710 pPager->nHash = N;
711 pPager->aHash = aHash;
712 for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
drh3765df42006-06-28 18:18:09 +0000713 int h;
714 if( pPg->pgno==0 ){
715 assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );
716 continue;
717 }
718 h = pPg->pgno & (N-1);
drh8ca0c722006-05-07 17:49:38 +0000719 pPg->pNextHash = aHash[h];
720 if( aHash[h] ){
721 aHash[h]->pPrevHash = pPg;
722 }
723 aHash[h] = pPg;
724 pPg->pPrevHash = 0;
725 }
726}
727
drhdd793422001-06-28 01:54:48 +0000728/*
drh34e79ce2004-02-08 06:05:46 +0000729** Read a 32-bit integer from the given file descriptor. Store the integer
730** that is read in *pRes. Return SQLITE_OK if everything worked, or an
731** error code is something goes wrong.
drh726de592004-06-10 23:35:50 +0000732**
733** All values are stored on disk as big-endian.
drh94f33312002-08-12 12:29:56 +0000734*/
danielk197762079062007-08-15 17:08:46 +0000735static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
drh3b59a5c2006-01-15 20:28:28 +0000736 unsigned char ac[4];
danielk197762079062007-08-15 17:08:46 +0000737 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
drhae2b40c2004-06-09 19:03:54 +0000738 if( rc==SQLITE_OK ){
drha3152892007-05-05 11:48:52 +0000739 *pRes = sqlite3Get4byte(ac);
drh94f33312002-08-12 12:29:56 +0000740 }
drh94f33312002-08-12 12:29:56 +0000741 return rc;
742}
743
744/*
drh97b57482006-01-10 20:32:32 +0000745** Write a 32-bit integer into a string buffer in big-endian byte order.
746*/
drha3152892007-05-05 11:48:52 +0000747#define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
drh97b57482006-01-10 20:32:32 +0000748
749/*
drh34e79ce2004-02-08 06:05:46 +0000750** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
751** on success or an error code is something goes wrong.
drh94f33312002-08-12 12:29:56 +0000752*/
danielk197762079062007-08-15 17:08:46 +0000753static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
danielk1977bab45c62006-01-16 15:14:27 +0000754 char ac[4];
drh97b57482006-01-10 20:32:32 +0000755 put32bits(ac, val);
danielk197762079062007-08-15 17:08:46 +0000756 return sqlite3OsWrite(fd, ac, 4, offset);
drh94f33312002-08-12 12:29:56 +0000757}
758
drh2554f8b2003-01-22 01:26:44 +0000759/*
danielk19777a2b1ee2007-08-21 14:27:01 +0000760** If file pFd is open, call sqlite3OsUnlock() on it.
761*/
762static int osUnlock(sqlite3_file *pFd, int eLock){
763 if( !pFd->pMethods ){
764 return SQLITE_OK;
765 }
766 return sqlite3OsUnlock(pFd, eLock);
767}
768
769/*
danielk1977c7b60172007-08-22 11:22:03 +0000770** This function determines whether or not the atomic-write optimization
771** can be used with this pager. The optimization can be used if:
772**
773** (a) the value returned by OsDeviceCharacteristics() indicates that
774** a database page may be written atomically, and
775** (b) the value returned by OsSectorSize() is less than or equal
776** to the page size.
777**
778** If the optimization cannot be used, 0 is returned. If it can be used,
779** then the value returned is the size of the journal file when it
780** contains rollback data for exactly one page.
781*/
782#ifdef SQLITE_ENABLE_ATOMIC_WRITE
783static int jrnlBufferSize(Pager *pPager){
784 int dc; /* Device characteristics */
785 int nSector; /* Sector size */
786 int nPage; /* Page size */
787 sqlite3_file *fd = pPager->fd;
788
789 if( fd->pMethods ){
790 dc = sqlite3OsDeviceCharacteristics(fd);
791 nSector = sqlite3OsSectorSize(fd);
792 nPage = pPager->pageSize;
793 }
794
795 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
796 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
797
danielk1977f8940ae2007-08-23 11:07:10 +0000798 if( !fd->pMethods || (dc&(SQLITE_IOCAP_ATOMIC|(nPage>>8))&&nSector<=nPage) ){
danielk1977c7b60172007-08-22 11:22:03 +0000799 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
800 }
801 return 0;
802}
803#endif
804
805/*
danielk1977aef0bf62005-12-30 16:28:01 +0000806** This function should be called when an error occurs within the pager
danielk1977a96a7102006-01-16 12:46:41 +0000807** code. The first argument is a pointer to the pager structure, the
808** second the error-code about to be returned by a pager API function.
809** The value returned is a copy of the second argument to this function.
810**
drh4f0ee682007-03-30 20:43:40 +0000811** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL
danielk1977a96a7102006-01-16 12:46:41 +0000812** the error becomes persistent. All subsequent API calls on this Pager
813** will immediately return the same error code.
danielk1977aef0bf62005-12-30 16:28:01 +0000814*/
815static int pager_error(Pager *pPager, int rc){
drh4ac285a2006-09-15 07:28:50 +0000816 int rc2 = rc & 0xff;
drh34f56212007-08-10 23:56:35 +0000817 assert(
818 pPager->errCode==SQLITE_FULL ||
819 pPager->errCode==SQLITE_OK ||
820 (pPager->errCode & 0xff)==SQLITE_IOERR
821 );
danielk1977979f38e2007-03-27 16:19:51 +0000822 if(
drh4ac285a2006-09-15 07:28:50 +0000823 rc2==SQLITE_FULL ||
824 rc2==SQLITE_IOERR ||
drh4f0ee682007-03-30 20:43:40 +0000825 rc2==SQLITE_CORRUPT
danielk1977efaaf572006-01-16 11:29:19 +0000826 ){
827 pPager->errCode = rc;
danielk1977aef0bf62005-12-30 16:28:01 +0000828 }
829 return rc;
830}
831
drh477731b2007-06-16 03:06:27 +0000832/*
833** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
834** on the cache using a hash function. This is used for testing
835** and debugging only.
836*/
danielk19773c407372005-02-15 02:54:14 +0000837#ifdef SQLITE_CHECK_PAGES
838/*
839** Return a 32-bit hash of the page data for pPage.
840*/
drh477731b2007-06-16 03:06:27 +0000841static u32 pager_datahash(int nByte, unsigned char *pData){
danielk19773c407372005-02-15 02:54:14 +0000842 u32 hash = 0;
843 int i;
drh477731b2007-06-16 03:06:27 +0000844 for(i=0; i<nByte; i++){
845 hash = (hash*1039) + pData[i];
danielk19773c407372005-02-15 02:54:14 +0000846 }
847 return hash;
848}
drh477731b2007-06-16 03:06:27 +0000849static u32 pager_pagehash(PgHdr *pPage){
850 return pager_datahash(pPage->pPager->pageSize,
851 (unsigned char *)PGHDR_TO_DATA(pPage));
852}
danielk19773c407372005-02-15 02:54:14 +0000853
854/*
855** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
856** is defined, and NDEBUG is not defined, an assert() statement checks
857** that the page is either dirty or still matches the calculated page-hash.
858*/
859#define CHECK_PAGE(x) checkPage(x)
860static void checkPage(PgHdr *pPg){
861 Pager *pPager = pPg->pPager;
danielk1977efaaf572006-01-16 11:29:19 +0000862 assert( !pPg->pageHash || pPager->errCode || MEMDB || pPg->dirty ||
danielk19773c407372005-02-15 02:54:14 +0000863 pPg->pageHash==pager_pagehash(pPg) );
864}
865
866#else
drh8ffa8172007-06-18 17:25:17 +0000867#define pager_datahash(X,Y) 0
drh477731b2007-06-16 03:06:27 +0000868#define pager_pagehash(X) 0
danielk19773c407372005-02-15 02:54:14 +0000869#define CHECK_PAGE(x)
870#endif
871
drhed7c8552001-04-11 14:29:21 +0000872/*
danielk197776572402004-06-25 02:38:54 +0000873** When this is called the journal file for pager pPager must be open.
874** The master journal file name is read from the end of the file and
danielk197765839c62007-08-30 08:08:17 +0000875** written into memory supplied by the caller.
danielk197776572402004-06-25 02:38:54 +0000876**
danielk197765839c62007-08-30 08:08:17 +0000877** zMaster must point to a buffer of at least nMaster bytes allocated by
878** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
879** enough space to write the master journal name). If the master journal
880** name in the journal is longer than nMaster bytes (including a
881** nul-terminator), then this is handled as if no master journal name
882** were present in the journal.
883**
884** If no master journal file name is present zMaster[0] is set to 0 and
danielk197776572402004-06-25 02:38:54 +0000885** SQLITE_OK returned.
886*/
danielk197765839c62007-08-30 08:08:17 +0000887static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, int nMaster){
danielk197776572402004-06-25 02:38:54 +0000888 int rc;
889 u32 len;
drheb206252004-10-01 02:00:31 +0000890 i64 szJ;
danielk1977c3e8f5e2004-06-28 01:16:46 +0000891 u32 cksum;
danielk1977cafadba2004-06-25 11:11:54 +0000892 int i;
danielk197776572402004-06-25 02:38:54 +0000893 unsigned char aMagic[8]; /* A buffer to hold the magic header */
894
danielk197765839c62007-08-30 08:08:17 +0000895 zMaster[0] = '\0';
danielk197776572402004-06-25 02:38:54 +0000896
drh054889e2005-11-30 03:20:31 +0000897 rc = sqlite3OsFileSize(pJrnl, &szJ);
danielk1977cafadba2004-06-25 11:11:54 +0000898 if( rc!=SQLITE_OK || szJ<16 ) return rc;
danielk197776572402004-06-25 02:38:54 +0000899
danielk197762079062007-08-15 17:08:46 +0000900 rc = read32bits(pJrnl, szJ-16, &len);
danielk197776572402004-06-25 02:38:54 +0000901 if( rc!=SQLITE_OK ) return rc;
902
danielk197765839c62007-08-30 08:08:17 +0000903 if( len>=nMaster ){
904 return SQLITE_OK;
905 }
906
danielk197762079062007-08-15 17:08:46 +0000907 rc = read32bits(pJrnl, szJ-12, &cksum);
danielk1977cafadba2004-06-25 11:11:54 +0000908 if( rc!=SQLITE_OK ) return rc;
909
danielk197762079062007-08-15 17:08:46 +0000910 rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8);
danielk197776572402004-06-25 02:38:54 +0000911 if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc;
912
danielk197765839c62007-08-30 08:08:17 +0000913 rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len);
danielk197776572402004-06-25 02:38:54 +0000914 if( rc!=SQLITE_OK ){
danielk197776572402004-06-25 02:38:54 +0000915 return rc;
916 }
danielk197765839c62007-08-30 08:08:17 +0000917 zMaster[len] = '\0';
danielk1977cafadba2004-06-25 11:11:54 +0000918
919 /* See if the checksum matches the master journal name */
920 for(i=0; i<len; i++){
danielk197765839c62007-08-30 08:08:17 +0000921 cksum -= zMaster[i];
922 }
danielk19778191bff2004-06-28 04:52:30 +0000923 if( cksum ){
924 /* If the checksum doesn't add up, then one or more of the disk sectors
925 ** containing the master journal filename is corrupted. This means
926 ** definitely roll back, so just return SQLITE_OK and report a (nul)
927 ** master-journal filename.
928 */
danielk197765839c62007-08-30 08:08:17 +0000929 zMaster[0] = '\0';
danielk1977cafadba2004-06-25 11:11:54 +0000930 }
danielk197776572402004-06-25 02:38:54 +0000931
932 return SQLITE_OK;
933}
934
935/*
936** Seek the journal file descriptor to the next sector boundary where a
937** journal header may be read or written. Pager.journalOff is updated with
938** the new seek offset.
939**
940** i.e for a sector size of 512:
941**
942** Input Offset Output Offset
943** ---------------------------------------
944** 0 0
945** 512 512
946** 100 512
947** 2000 2048
948**
949*/
danielk197762079062007-08-15 17:08:46 +0000950static void seekJournalHdr(Pager *pPager){
drheb206252004-10-01 02:00:31 +0000951 i64 offset = 0;
952 i64 c = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +0000953 if( c ){
954 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
955 }
956 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
957 assert( offset>=c );
958 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
959 pPager->journalOff = offset;
danielk197776572402004-06-25 02:38:54 +0000960}
961
962/*
963** The journal file must be open when this routine is called. A journal
964** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
965** current location.
966**
967** The format for the journal header is as follows:
968** - 8 bytes: Magic identifying journal format.
969** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
970** - 4 bytes: Random number used for page hash.
971** - 4 bytes: Initial database page count.
972** - 4 bytes: Sector size used by the process that wrote this journal.
973**
danielk1977f42f25c2004-06-25 07:21:28 +0000974** Followed by (JOURNAL_HDR_SZ - 24) bytes of unused space.
danielk197776572402004-06-25 02:38:54 +0000975*/
976static int writeJournalHdr(Pager *pPager){
drh97b57482006-01-10 20:32:32 +0000977 char zHeader[sizeof(aJournalMagic)+16];
danielk19774099f6e2007-03-19 11:25:20 +0000978 int rc;
danielk197776572402004-06-25 02:38:54 +0000979
danielk19774099f6e2007-03-19 11:25:20 +0000980 if( pPager->stmtHdrOff==0 ){
981 pPager->stmtHdrOff = pPager->journalOff;
982 }
983
danielk197762079062007-08-15 17:08:46 +0000984 seekJournalHdr(pPager);
danielk197776572402004-06-25 02:38:54 +0000985 pPager->journalHdr = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +0000986
drh97b57482006-01-10 20:32:32 +0000987 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
danielk19774cd2cd52007-08-23 14:48:23 +0000988
989 /*
990 ** Write the nRec Field - the number of page records that follow this
991 ** journal header. Normally, zero is written to this value at this time.
992 ** After the records are added to the journal (and the journal synced,
993 ** if in full-sync mode), the zero is overwritten with the true number
994 ** of records (see syncJournal()).
995 **
996 ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
997 ** reading the journal this value tells SQLite to assume that the
998 ** rest of the journal file contains valid page records. This assumption
999 ** is dangerous, as if a failure occured whilst writing to the journal
1000 ** file it may contain some garbage data. There are two scenarios
1001 ** where this risk can be ignored:
1002 **
1003 ** * When the pager is in no-sync mode. Corruption can follow a
1004 ** power failure in this case anyway.
1005 **
1006 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
1007 ** that garbage data is never appended to the journal file.
1008 */
1009 assert(pPager->fd->pMethods||pPager->noSync);
1010 if( (pPager->noSync)
1011 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
1012 ){
1013 put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
1014 }else{
1015 put32bits(&zHeader[sizeof(aJournalMagic)], 0);
1016 }
1017
drh97b57482006-01-10 20:32:32 +00001018 /* The random check-hash initialiser */
1019 sqlite3Randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
1020 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
1021 /* The initial database size */
1022 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize);
1023 /* The assumed sector size for this process */
1024 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
drhb0603412007-02-28 04:47:26 +00001025 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, sizeof(zHeader)))
danielk197762079062007-08-15 17:08:46 +00001026 rc = sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader),pPager->journalOff);
1027 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
danielk197776572402004-06-25 02:38:54 +00001028
1029 /* The journal header has been written successfully. Seek the journal
1030 ** file descriptor to the end of the journal header sector.
1031 */
1032 if( rc==SQLITE_OK ){
drhb0603412007-02-28 04:47:26 +00001033 IOTRACE(("JTAIL %p %lld\n", pPager, pPager->journalOff-1))
danielk197762079062007-08-15 17:08:46 +00001034 rc = sqlite3OsWrite(pPager->jfd, "\000", 1, pPager->journalOff-1);
danielk197776572402004-06-25 02:38:54 +00001035 }
1036 return rc;
1037}
1038
1039/*
1040** The journal file must be open when this is called. A journal header file
1041** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
1042** file. See comments above function writeJournalHdr() for a description of
1043** the journal header format.
1044**
1045** If the header is read successfully, *nRec is set to the number of
1046** page records following this header and *dbSize is set to the size of the
1047** database before the transaction began, in pages. Also, pPager->cksumInit
1048** is set to the value read from the journal header. SQLITE_OK is returned
1049** in this case.
1050**
1051** If the journal header file appears to be corrupted, SQLITE_DONE is
1052** returned and *nRec and *dbSize are not set. If JOURNAL_HDR_SZ bytes
1053** cannot be read from the journal file an error code is returned.
1054*/
1055static int readJournalHdr(
1056 Pager *pPager,
drheb206252004-10-01 02:00:31 +00001057 i64 journalSize,
danielk197776572402004-06-25 02:38:54 +00001058 u32 *pNRec,
1059 u32 *pDbSize
1060){
1061 int rc;
1062 unsigned char aMagic[8]; /* A buffer to hold the magic header */
danielk197762079062007-08-15 17:08:46 +00001063 i64 jrnlOff;
danielk197776572402004-06-25 02:38:54 +00001064
danielk197762079062007-08-15 17:08:46 +00001065 seekJournalHdr(pPager);
danielk197776572402004-06-25 02:38:54 +00001066 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
1067 return SQLITE_DONE;
1068 }
danielk197762079062007-08-15 17:08:46 +00001069 jrnlOff = pPager->journalOff;
danielk197776572402004-06-25 02:38:54 +00001070
danielk197762079062007-08-15 17:08:46 +00001071 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), jrnlOff);
danielk197776572402004-06-25 02:38:54 +00001072 if( rc ) return rc;
danielk197762079062007-08-15 17:08:46 +00001073 jrnlOff += sizeof(aMagic);
danielk197776572402004-06-25 02:38:54 +00001074
1075 if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
1076 return SQLITE_DONE;
1077 }
1078
danielk197762079062007-08-15 17:08:46 +00001079 rc = read32bits(pPager->jfd, jrnlOff, pNRec);
danielk197776572402004-06-25 02:38:54 +00001080 if( rc ) return rc;
1081
danielk197762079062007-08-15 17:08:46 +00001082 rc = read32bits(pPager->jfd, jrnlOff+4, &pPager->cksumInit);
danielk197776572402004-06-25 02:38:54 +00001083 if( rc ) return rc;
1084
danielk197762079062007-08-15 17:08:46 +00001085 rc = read32bits(pPager->jfd, jrnlOff+8, pDbSize);
danielk197776572402004-06-25 02:38:54 +00001086 if( rc ) return rc;
1087
1088 /* Update the assumed sector-size to match the value used by
1089 ** the process that created this journal. If this journal was
1090 ** created by a process other than this one, then this routine
1091 ** is being called from within pager_playback(). The local value
1092 ** of Pager.sectorSize is restored at the end of that routine.
1093 */
danielk197762079062007-08-15 17:08:46 +00001094 rc = read32bits(pPager->jfd, jrnlOff+12, (u32 *)&pPager->sectorSize);
danielk197776572402004-06-25 02:38:54 +00001095 if( rc ) return rc;
1096
1097 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
danielk197762079062007-08-15 17:08:46 +00001098 return SQLITE_OK;
danielk197776572402004-06-25 02:38:54 +00001099}
1100
1101
1102/*
1103** Write the supplied master journal name into the journal file for pager
danielk1977cafadba2004-06-25 11:11:54 +00001104** pPager at the current location. The master journal name must be the last
1105** thing written to a journal file. If the pager is in full-sync mode, the
1106** journal file descriptor is advanced to the next sector boundary before
1107** anything is written. The format is:
1108**
1109** + 4 bytes: PAGER_MJ_PGNO.
1110** + N bytes: length of master journal name.
1111** + 4 bytes: N
1112** + 4 bytes: Master journal name checksum.
1113** + 8 bytes: aJournalMagic[].
1114**
1115** The master journal page checksum is the sum of the bytes in the master
1116** journal name.
danielk1977aef0bf62005-12-30 16:28:01 +00001117**
1118** If zMaster is a NULL pointer (occurs for a single database transaction),
1119** this call is a no-op.
danielk197776572402004-06-25 02:38:54 +00001120*/
1121static int writeMasterJournal(Pager *pPager, const char *zMaster){
1122 int rc;
1123 int len;
danielk1977cafadba2004-06-25 11:11:54 +00001124 int i;
danielk197762079062007-08-15 17:08:46 +00001125 i64 jrnlOff;
drh97b57482006-01-10 20:32:32 +00001126 u32 cksum = 0;
1127 char zBuf[sizeof(aJournalMagic)+2*4];
danielk197776572402004-06-25 02:38:54 +00001128
1129 if( !zMaster || pPager->setMaster) return SQLITE_OK;
1130 pPager->setMaster = 1;
1131
1132 len = strlen(zMaster);
danielk1977cafadba2004-06-25 11:11:54 +00001133 for(i=0; i<len; i++){
1134 cksum += zMaster[i];
1135 }
danielk197776572402004-06-25 02:38:54 +00001136
1137 /* If in full-sync mode, advance to the next disk sector before writing
1138 ** the master journal name. This is in case the previous page written to
1139 ** the journal has already been synced.
1140 */
1141 if( pPager->fullSync ){
danielk197762079062007-08-15 17:08:46 +00001142 seekJournalHdr(pPager);
danielk197776572402004-06-25 02:38:54 +00001143 }
danielk197762079062007-08-15 17:08:46 +00001144 jrnlOff = pPager->journalOff;
danielk1977cafadba2004-06-25 11:11:54 +00001145 pPager->journalOff += (len+20);
danielk197776572402004-06-25 02:38:54 +00001146
danielk197762079062007-08-15 17:08:46 +00001147 rc = write32bits(pPager->jfd, jrnlOff, PAGER_MJ_PGNO(pPager));
danielk197776572402004-06-25 02:38:54 +00001148 if( rc!=SQLITE_OK ) return rc;
danielk197762079062007-08-15 17:08:46 +00001149 jrnlOff += 4;
danielk197776572402004-06-25 02:38:54 +00001150
danielk197762079062007-08-15 17:08:46 +00001151 rc = sqlite3OsWrite(pPager->jfd, zMaster, len, jrnlOff);
danielk197776572402004-06-25 02:38:54 +00001152 if( rc!=SQLITE_OK ) return rc;
danielk197762079062007-08-15 17:08:46 +00001153 jrnlOff += len;
danielk197776572402004-06-25 02:38:54 +00001154
drh97b57482006-01-10 20:32:32 +00001155 put32bits(zBuf, len);
1156 put32bits(&zBuf[4], cksum);
1157 memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic));
danielk197762079062007-08-15 17:08:46 +00001158 rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic), jrnlOff);
drh2c8997b2005-08-27 16:36:48 +00001159 pPager->needSync = !pPager->noSync;
danielk197776572402004-06-25 02:38:54 +00001160 return rc;
1161}
1162
1163/*
drh03eb96a2002-11-10 23:32:56 +00001164** Add or remove a page from the list of all pages that are in the
drhac69b052004-05-12 13:30:07 +00001165** statement journal.
drh03eb96a2002-11-10 23:32:56 +00001166**
1167** The Pager keeps a separate list of pages that are currently in
danielk19773b8a05f2007-03-19 17:44:26 +00001168** the statement journal. This helps the sqlite3PagerStmtCommit()
drh03eb96a2002-11-10 23:32:56 +00001169** routine run MUCH faster for the common case where there are many
drhac69b052004-05-12 13:30:07 +00001170** pages in memory but only a few are in the statement journal.
drh03eb96a2002-11-10 23:32:56 +00001171*/
drh3aac2dd2004-04-26 14:10:20 +00001172static void page_add_to_stmt_list(PgHdr *pPg){
drh03eb96a2002-11-10 23:32:56 +00001173 Pager *pPager = pPg->pPager;
danielk1977f35843b2007-04-07 15:03:17 +00001174 PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
1175 assert( MEMDB );
1176 if( !pHist->inStmt ){
1177 assert( pHist->pPrevStmt==0 && pHist->pNextStmt==0 );
1178 if( pPager->pStmt ){
1179 PGHDR_TO_HIST(pPager->pStmt, pPager)->pPrevStmt = pPg;
1180 }
1181 pHist->pNextStmt = pPager->pStmt;
1182 pPager->pStmt = pPg;
1183 pHist->inStmt = 1;
drh03eb96a2002-11-10 23:32:56 +00001184 }
drh03eb96a2002-11-10 23:32:56 +00001185}
1186
1187/*
drhed7c8552001-04-11 14:29:21 +00001188** Find a page in the hash table given its page number. Return
1189** a pointer to the page or NULL if not found.
1190*/
drhd9b02572001-04-15 00:37:09 +00001191static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
drh8ca0c722006-05-07 17:49:38 +00001192 PgHdr *p;
1193 if( pPager->aHash==0 ) return 0;
1194 p = pPager->aHash[pgno & (pPager->nHash-1)];
drhed7c8552001-04-11 14:29:21 +00001195 while( p && p->pgno!=pgno ){
1196 p = p->pNextHash;
1197 }
1198 return p;
1199}
1200
1201/*
drh1aa2d8b2007-01-03 15:34:29 +00001202** Unlock the database file.
drh1aa2d8b2007-01-03 15:34:29 +00001203*/
1204static void pager_unlock(Pager *pPager){
danielk197741483462007-03-24 16:45:04 +00001205 if( !pPager->exclusiveMode ){
1206 if( !MEMDB ){
danielk19777a2b1ee2007-08-21 14:27:01 +00001207 osUnlock(pPager->fd, NO_LOCK);
danielk197741483462007-03-24 16:45:04 +00001208 pPager->dbSize = -1;
1209 IOTRACE(("UNLOCK %p\n", pPager))
1210 }
1211 pPager->state = PAGER_UNLOCK;
1212 pPager->changeCountDone = 0;
drh1aa2d8b2007-01-03 15:34:29 +00001213 }
danielk1977e277be02007-03-23 18:12:06 +00001214}
1215
1216/*
1217** Execute a rollback if a transaction is active and unlock the
1218** database file. This is a no-op if the pager has already entered
1219** the error-state.
1220*/
danielk1977334cdb62007-03-26 08:05:12 +00001221static void pagerUnlockAndRollback(Pager *p){
1222 if( p->errCode ) return;
danielk1977c5859712007-03-26 12:26:27 +00001223 assert( p->state>=PAGER_RESERVED || p->journalOpen==0 );
danielk1977334cdb62007-03-26 08:05:12 +00001224 if( p->state>=PAGER_RESERVED ){
1225 sqlite3PagerRollback(p);
danielk1977e277be02007-03-23 18:12:06 +00001226 }
danielk1977334cdb62007-03-26 08:05:12 +00001227 pager_unlock(p);
1228 assert( p->errCode || !p->journalOpen || (p->exclusiveMode&&!p->journalOff) );
1229 assert( p->errCode || !p->stmtOpen || p->exclusiveMode );
drh1aa2d8b2007-01-03 15:34:29 +00001230}
1231
1232
1233/*
danielk1977e180dd92007-04-05 17:15:52 +00001234** Clear the in-memory cache. This routine
drhed7c8552001-04-11 14:29:21 +00001235** sets the state of the pager back to what it was when it was first
1236** opened. Any outstanding pages are invalidated and subsequent attempts
1237** to access those pages will likely result in a coredump.
1238*/
drhd9b02572001-04-15 00:37:09 +00001239static void pager_reset(Pager *pPager){
drhed7c8552001-04-11 14:29:21 +00001240 PgHdr *pPg, *pNext;
danielk1977efaaf572006-01-16 11:29:19 +00001241 if( pPager->errCode ) return;
drhd9b02572001-04-15 00:37:09 +00001242 for(pPg=pPager->pAll; pPg; pPg=pNext){
drh538f5702007-04-13 02:14:30 +00001243 IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno));
1244 PAGER_INCR(sqlite3_pager_pgfree_count);
drhd9b02572001-04-15 00:37:09 +00001245 pNext = pPg->pNextAll;
danielk19779f61c2f2007-08-27 17:27:49 +00001246 lruListRemove(pPg);
drh17435752007-08-16 04:30:38 +00001247 sqlite3_free(pPg);
drhed7c8552001-04-11 14:29:21 +00001248 }
danielk19779f61c2f2007-08-27 17:27:49 +00001249 assert(pPager->lru.pFirst==0);
1250 assert(pPager->lru.pFirstSynced==0);
1251 assert(pPager->lru.pLast==0);
danielk1977b94bf852007-03-19 13:53:37 +00001252 pPager->pStmt = 0;
drhd9b02572001-04-15 00:37:09 +00001253 pPager->pAll = 0;
drh8ca0c722006-05-07 17:49:38 +00001254 pPager->nHash = 0;
drh17435752007-08-16 04:30:38 +00001255 sqlite3_free(pPager->aHash);
drhed7c8552001-04-11 14:29:21 +00001256 pPager->nPage = 0;
drh8ca0c722006-05-07 17:49:38 +00001257 pPager->aHash = 0;
drhed7c8552001-04-11 14:29:21 +00001258 pPager->nRef = 0;
danielk1977e277be02007-03-23 18:12:06 +00001259}
1260
1261/*
drh80e35f42007-03-30 14:06:34 +00001262** This routine ends a transaction. A transaction is ended by either
1263** a COMMIT or a ROLLBACK.
1264**
drhed7c8552001-04-11 14:29:21 +00001265** When this routine is called, the pager has the journal file open and
drh80e35f42007-03-30 14:06:34 +00001266** a RESERVED or EXCLUSIVE lock on the database. This routine will release
1267** the database lock and acquires a SHARED lock in its place if that is
1268** the appropriate thing to do. Release locks usually is appropriate,
1269** unless we are in exclusive access mode or unless this is a
1270** COMMIT AND BEGIN or ROLLBACK AND BEGIN operation.
1271**
1272** The journal file is either deleted or truncated.
drh50457892003-09-06 01:10:47 +00001273**
1274** TODO: Consider keeping the journal file open for temporary databases.
1275** This might give a performance improvement on windows where opening
1276** a file is an expensive operation.
drhed7c8552001-04-11 14:29:21 +00001277*/
drh80e35f42007-03-30 14:06:34 +00001278static int pager_end_transaction(Pager *pPager){
drhd9b02572001-04-15 00:37:09 +00001279 PgHdr *pPg;
danielk197741483462007-03-24 16:45:04 +00001280 int rc = SQLITE_OK;
danielk1977979f38e2007-03-27 16:19:51 +00001281 int rc2 = SQLITE_OK;
drhb7f91642004-10-31 02:22:47 +00001282 assert( !MEMDB );
drha6abd042004-06-09 17:37:22 +00001283 if( pPager->state<PAGER_RESERVED ){
1284 return SQLITE_OK;
1285 }
danielk19773b8a05f2007-03-19 17:44:26 +00001286 sqlite3PagerStmtCommit(pPager);
danielk1977334cdb62007-03-26 08:05:12 +00001287 if( pPager->stmtOpen && !pPager->exclusiveMode ){
danielk1977b4b47412007-08-17 15:53:36 +00001288 sqlite3OsClose(pPager->stfd);
danielk1977979f38e2007-03-27 16:19:51 +00001289 pPager->stmtOpen = 0;
drh0f892532002-05-30 12:27:03 +00001290 }
drhda47d772002-12-02 04:25:19 +00001291 if( pPager->journalOpen ){
drh01fa4c32007-04-02 11:22:22 +00001292 if( pPager->exclusiveMode
1293 && (rc = sqlite3OsTruncate(pPager->jfd, 0))==SQLITE_OK ){;
danielk197741483462007-03-24 16:45:04 +00001294 pPager->journalOff = 0;
danielk1977334cdb62007-03-26 08:05:12 +00001295 pPager->journalStarted = 0;
danielk197741483462007-03-24 16:45:04 +00001296 }else{
danielk1977b4b47412007-08-17 15:53:36 +00001297 sqlite3OsClose(pPager->jfd);
danielk197741483462007-03-24 16:45:04 +00001298 pPager->journalOpen = 0;
drh01fa4c32007-04-02 11:22:22 +00001299 if( rc==SQLITE_OK ){
danielk1977fee2d252007-08-18 10:59:19 +00001300 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
danielk19777152de82007-03-29 17:28:14 +00001301 }
danielk197741483462007-03-24 16:45:04 +00001302 }
drh17435752007-08-16 04:30:38 +00001303 sqlite3_free( pPager->aInJournal );
drhda47d772002-12-02 04:25:19 +00001304 pPager->aInJournal = 0;
1305 for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
1306 pPg->inJournal = 0;
1307 pPg->dirty = 0;
drhdb48ee02003-01-16 13:42:43 +00001308 pPg->needSync = 0;
danielk197741483462007-03-24 16:45:04 +00001309 pPg->alwaysRollback = 0;
danielk19773c407372005-02-15 02:54:14 +00001310#ifdef SQLITE_CHECK_PAGES
1311 pPg->pageHash = pager_pagehash(pPg);
1312#endif
drhda47d772002-12-02 04:25:19 +00001313 }
drh605ad8f2006-05-03 23:34:05 +00001314 pPager->pDirty = 0;
danielk1977ef317ab2004-06-23 10:43:10 +00001315 pPager->dirtyCache = 0;
danielk1977ef317ab2004-06-23 10:43:10 +00001316 pPager->nRec = 0;
drhda47d772002-12-02 04:25:19 +00001317 }else{
drh88b01a12005-03-28 18:04:27 +00001318 assert( pPager->aInJournal==0 );
drha6abd042004-06-09 17:37:22 +00001319 assert( pPager->dirtyCache==0 || pPager->useJournal==0 );
drhd9b02572001-04-15 00:37:09 +00001320 }
danielk1977979f38e2007-03-27 16:19:51 +00001321
danielk197741483462007-03-24 16:45:04 +00001322 if( !pPager->exclusiveMode ){
danielk19777a2b1ee2007-08-21 14:27:01 +00001323 rc2 = osUnlock(pPager->fd, SHARED_LOCK);
danielk197741483462007-03-24 16:45:04 +00001324 pPager->state = PAGER_SHARED;
danielk1977334cdb62007-03-26 08:05:12 +00001325 }else if( pPager->state==PAGER_SYNCED ){
1326 pPager->state = PAGER_EXCLUSIVE;
danielk197741483462007-03-24 16:45:04 +00001327 }
danielk1977334cdb62007-03-26 08:05:12 +00001328 pPager->origDbSize = 0;
danielk197776572402004-06-25 02:38:54 +00001329 pPager->setMaster = 0;
danielk1977c4da5b92006-01-21 12:08:54 +00001330 pPager->needSync = 0;
danielk19779f61c2f2007-08-27 17:27:49 +00001331 lruListSetFirstSynced(pPager);
drh588f5bc2007-01-02 18:41:54 +00001332 pPager->dbSize = -1;
danielk1977979f38e2007-03-27 16:19:51 +00001333
1334 return (rc==SQLITE_OK?rc2:rc);
drhed7c8552001-04-11 14:29:21 +00001335}
1336
drhed7c8552001-04-11 14:29:21 +00001337/*
drh968af522003-02-11 14:55:40 +00001338** Compute and return a checksum for the page of data.
drh34e79ce2004-02-08 06:05:46 +00001339**
1340** This is not a real checksum. It is really just the sum of the
drh726de592004-06-10 23:35:50 +00001341** random initial value and the page number. We experimented with
1342** a checksum of the entire data, but that was found to be too slow.
1343**
1344** Note that the page number is stored at the beginning of data and
1345** the checksum is stored at the end. This is important. If journal
1346** corruption occurs due to a power failure, the most likely scenario
1347** is that one end or the other of the record will be changed. It is
1348** much less likely that the two ends of the journal record will be
1349** correct and the middle be corrupt. Thus, this "checksum" scheme,
1350** though fast and simple, catches the mostly likely kind of corruption.
1351**
1352** FIX ME: Consider adding every 200th (or so) byte of the data to the
1353** checksum. That way if a single page spans 3 or more disk sectors and
1354** only the middle sector is corrupt, we will still have a reasonable
1355** chance of failing the checksum and thus detecting the problem.
drh968af522003-02-11 14:55:40 +00001356*/
drh74161702006-02-24 02:53:49 +00001357static u32 pager_cksum(Pager *pPager, const u8 *aData){
danielk1977ef317ab2004-06-23 10:43:10 +00001358 u32 cksum = pPager->cksumInit;
1359 int i = pPager->pageSize-200;
1360 while( i>0 ){
1361 cksum += aData[i];
1362 i -= 200;
1363 }
drh968af522003-02-11 14:55:40 +00001364 return cksum;
1365}
1366
drh605ad8f2006-05-03 23:34:05 +00001367/* Forward declaration */
1368static void makeClean(PgHdr*);
1369
drh968af522003-02-11 14:55:40 +00001370/*
drhfa86c412002-02-02 15:01:15 +00001371** Read a single page from the journal file opened on file descriptor
1372** jfd. Playback this one page.
drh968af522003-02-11 14:55:40 +00001373**
drh726de592004-06-10 23:35:50 +00001374** If useCksum==0 it means this journal does not use checksums. Checksums
1375** are not used in statement journals because statement journals do not
1376** need to survive power failures.
drhfa86c412002-02-02 15:01:15 +00001377*/
danielk197762079062007-08-15 17:08:46 +00001378static int pager_playback_one_page(
1379 Pager *pPager,
1380 sqlite3_file *jfd,
1381 i64 offset,
1382 int useCksum
1383){
drhfa86c412002-02-02 15:01:15 +00001384 int rc;
drhae2b40c2004-06-09 19:03:54 +00001385 PgHdr *pPg; /* An existing page in the cache */
1386 Pgno pgno; /* The page number of a page in journal */
1387 u32 cksum; /* Checksum used for sanity checking */
danielk19778186df82007-03-06 13:45:59 +00001388 u8 *aData = (u8 *)pPager->pTmpSpace; /* Temp storage for a page */
drhfa86c412002-02-02 15:01:15 +00001389
drh96362842005-03-20 22:47:56 +00001390 /* useCksum should be true for the main journal and false for
1391 ** statement journals. Verify that this is always the case
1392 */
drh9cbe6352005-11-29 03:13:21 +00001393 assert( jfd == (useCksum ? pPager->jfd : pPager->stfd) );
danielk19778186df82007-03-06 13:45:59 +00001394 assert( aData );
drh96362842005-03-20 22:47:56 +00001395
danielk197762079062007-08-15 17:08:46 +00001396 rc = read32bits(jfd, offset, &pgno);
drh99ee3602003-02-16 19:13:36 +00001397 if( rc!=SQLITE_OK ) return rc;
danielk197762079062007-08-15 17:08:46 +00001398 rc = sqlite3OsRead(jfd, aData, pPager->pageSize, offset+4);
drh99ee3602003-02-16 19:13:36 +00001399 if( rc!=SQLITE_OK ) return rc;
danielk197776572402004-06-25 02:38:54 +00001400 pPager->journalOff += pPager->pageSize + 4;
drhfa86c412002-02-02 15:01:15 +00001401
drh968af522003-02-11 14:55:40 +00001402 /* Sanity checking on the page. This is more important that I originally
1403 ** thought. If a power failure occurs while the journal is being written,
1404 ** it could cause invalid data to be written into the journal. We need to
1405 ** detect this invalid data (with high probability) and ignore it.
1406 */
danielk197775edc162004-06-26 01:48:18 +00001407 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
drh968af522003-02-11 14:55:40 +00001408 return SQLITE_DONE;
1409 }
drhae2b40c2004-06-09 19:03:54 +00001410 if( pgno>(unsigned)pPager->dbSize ){
drh968af522003-02-11 14:55:40 +00001411 return SQLITE_OK;
1412 }
drhae2b40c2004-06-09 19:03:54 +00001413 if( useCksum ){
danielk197762079062007-08-15 17:08:46 +00001414 rc = read32bits(jfd, offset+pPager->pageSize+4, &cksum);
drh99ee3602003-02-16 19:13:36 +00001415 if( rc ) return rc;
danielk197776572402004-06-25 02:38:54 +00001416 pPager->journalOff += 4;
drh74161702006-02-24 02:53:49 +00001417 if( pager_cksum(pPager, aData)!=cksum ){
drh968af522003-02-11 14:55:40 +00001418 return SQLITE_DONE;
1419 }
1420 }
drhfa86c412002-02-02 15:01:15 +00001421
danielk1977aa5ccdf2004-06-14 05:10:42 +00001422 assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );
danielk1977a3f3a5f2004-06-10 04:32:16 +00001423
1424 /* If the pager is in RESERVED state, then there must be a copy of this
1425 ** page in the pager cache. In this case just update the pager cache,
danielk19770de0bb32004-06-10 05:59:24 +00001426 ** not the database file. The page is left marked dirty in this case.
1427 **
danielk19772df71c72007-05-24 07:22:42 +00001428 ** An exception to the above rule: If the database is in no-sync mode
1429 ** and a page is moved during an incremental vacuum then the page may
danielk1977369f3a02007-05-24 09:41:20 +00001430 ** not be in the pager cache. Later: if a malloc() or IO error occurs
1431 ** during a Movepage() call, then the page may not be in the cache
1432 ** either. So the condition described in the above paragraph is not
1433 ** assert()able.
danielk19772df71c72007-05-24 07:22:42 +00001434 **
danielk1977a3f3a5f2004-06-10 04:32:16 +00001435 ** If in EXCLUSIVE state, then we update the pager cache if it exists
1436 ** and the main file. The page is then marked not dirty.
drh96362842005-03-20 22:47:56 +00001437 **
1438 ** Ticket #1171: The statement journal might contain page content that is
1439 ** different from the page content at the start of the transaction.
1440 ** This occurs when a page is changed prior to the start of a statement
1441 ** then changed again within the statement. When rolling back such a
1442 ** statement we must not write to the original database unless we know
drh5e385312007-06-16 04:42:12 +00001443 ** for certain that original page contents are synced into the main rollback
1444 ** journal. Otherwise, a power loss might leave modified data in the
1445 ** database file without an entry in the rollback journal that can
1446 ** restore the database to its original form. Two conditions must be
1447 ** met before writing to the database files. (1) the database must be
1448 ** locked. (2) we know that the original page content is fully synced
1449 ** in the main journal either because the page is not in cache or else
1450 ** the page is marked as needSync==0.
drhfa86c412002-02-02 15:01:15 +00001451 */
drhae2b40c2004-06-09 19:03:54 +00001452 pPg = pager_lookup(pPager, pgno);
drh477731b2007-06-16 03:06:27 +00001453 PAGERTRACE4("PLAYBACK %d page %d hash(%08x)\n",
1454 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData));
drh96362842005-03-20 22:47:56 +00001455 if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0) ){
danielk197762079062007-08-15 17:08:46 +00001456 i64 offset = (pgno-1)*(i64)pPager->pageSize;
1457 rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, offset);
drh605ad8f2006-05-03 23:34:05 +00001458 if( pPg ){
1459 makeClean(pPg);
1460 }
danielk1977a3f3a5f2004-06-10 04:32:16 +00001461 }
drhfa86c412002-02-02 15:01:15 +00001462 if( pPg ){
danielk197728129562005-01-11 10:25:06 +00001463 /* No page should ever be explicitly rolled back that is in use, except
1464 ** for page 1 which is held in use in order to keep the lock on the
1465 ** database active. However such a page may be rolled back as a result
1466 ** of an internal error resulting in an automatic call to
danielk19773b8a05f2007-03-19 17:44:26 +00001467 ** sqlite3PagerRollback().
drhacf4ac92003-12-17 23:57:34 +00001468 */
drhb6f41482004-05-14 01:58:11 +00001469 void *pData;
danielk197728129562005-01-11 10:25:06 +00001470 /* assert( pPg->nRef==0 || pPg->pgno==1 ); */
drhb6f41482004-05-14 01:58:11 +00001471 pData = PGHDR_TO_DATA(pPg);
drhae2b40c2004-06-09 19:03:54 +00001472 memcpy(pData, aData, pPager->pageSize);
danielk19779038bb62007-04-09 11:20:54 +00001473 if( pPager->xReiniter ){
1474 pPager->xReiniter(pPg, pPager->pageSize);
drhde647132004-05-07 17:57:49 +00001475 }
danielk19773c407372005-02-15 02:54:14 +00001476#ifdef SQLITE_CHECK_PAGES
drh96362842005-03-20 22:47:56 +00001477 pPg->pageHash = pager_pagehash(pPg);
danielk19773c407372005-02-15 02:54:14 +00001478#endif
drh86a88112007-04-16 15:02:19 +00001479 /* If this was page 1, then restore the value of Pager.dbFileVers.
1480 ** Do this before any decoding. */
danielk197741483462007-03-24 16:45:04 +00001481 if( pgno==1 ){
drh86a88112007-04-16 15:02:19 +00001482 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
danielk197741483462007-03-24 16:45:04 +00001483 }
drh86a88112007-04-16 15:02:19 +00001484
1485 /* Decode the page just read from disk */
1486 CODEC1(pPager, pData, pPg->pgno, 3);
drhfa86c412002-02-02 15:01:15 +00001487 }
1488 return rc;
1489}
1490
1491/*
danielk197713adf8a2004-06-03 16:08:41 +00001492** Parameter zMaster is the name of a master journal file. A single journal
1493** file that referred to the master journal file has just been rolled back.
1494** This routine checks if it is possible to delete the master journal file,
1495** and does so if it is.
drh726de592004-06-10 23:35:50 +00001496**
danielk197765839c62007-08-30 08:08:17 +00001497** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
1498** available for use within this function.
1499**
1500**
drh726de592004-06-10 23:35:50 +00001501** The master journal file contains the names of all child journals.
1502** To tell if a master journal can be deleted, check to each of the
1503** children. If all children are either missing or do not refer to
1504** a different master journal, then this master journal can be deleted.
danielk197713adf8a2004-06-03 16:08:41 +00001505*/
danielk1977b4b47412007-08-17 15:53:36 +00001506static int pager_delmaster(Pager *pPager, const char *zMaster){
1507 sqlite3_vfs *pVfs = pPager->pVfs;
danielk197713adf8a2004-06-03 16:08:41 +00001508 int rc;
1509 int master_open = 0;
danielk1977b4b47412007-08-17 15:53:36 +00001510 sqlite3_file *pMaster;
1511 sqlite3_file *pJournal;
danielk197713adf8a2004-06-03 16:08:41 +00001512 char *zMasterJournal = 0; /* Contents of master journal file */
drheb206252004-10-01 02:00:31 +00001513 i64 nMasterJournal; /* Size of master journal file */
danielk197713adf8a2004-06-03 16:08:41 +00001514
1515 /* Open the master journal file exclusively in case some other process
1516 ** is running this routine also. Not that it makes too much difference.
1517 */
danielk1977b4b47412007-08-17 15:53:36 +00001518 pMaster = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile * 2);
danielk1977fee2d252007-08-18 10:59:19 +00001519 pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
danielk1977b4b47412007-08-17 15:53:36 +00001520 if( !pMaster ){
1521 rc = SQLITE_NOMEM;
1522 }else{
danielk1977fee2d252007-08-18 10:59:19 +00001523 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
1524 rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
danielk1977b4b47412007-08-17 15:53:36 +00001525 }
danielk197713adf8a2004-06-03 16:08:41 +00001526 if( rc!=SQLITE_OK ) goto delmaster_out;
1527 master_open = 1;
danielk1977b4b47412007-08-17 15:53:36 +00001528
1529 rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
danielk197713adf8a2004-06-03 16:08:41 +00001530 if( rc!=SQLITE_OK ) goto delmaster_out;
1531
1532 if( nMasterJournal>0 ){
danielk19775865e3d2004-06-14 06:03:57 +00001533 char *zJournal;
danielk197776572402004-06-25 02:38:54 +00001534 char *zMasterPtr = 0;
danielk197765839c62007-08-30 08:08:17 +00001535 int nMasterPtr = pPager->pVfs->mxPathname+1;
danielk19775865e3d2004-06-14 06:03:57 +00001536
1537 /* Load the entire master journal file into space obtained from
drh17435752007-08-16 04:30:38 +00001538 ** sqlite3_malloc() and pointed to by zMasterJournal.
danielk19775865e3d2004-06-14 06:03:57 +00001539 */
danielk197765839c62007-08-30 08:08:17 +00001540 zMasterJournal = (char *)sqlite3_malloc(nMasterJournal + nMasterPtr);
danielk197713adf8a2004-06-03 16:08:41 +00001541 if( !zMasterJournal ){
1542 rc = SQLITE_NOMEM;
1543 goto delmaster_out;
1544 }
danielk197765839c62007-08-30 08:08:17 +00001545 zMasterPtr = &zMasterJournal[nMasterJournal];
danielk1977b4b47412007-08-17 15:53:36 +00001546 rc = sqlite3OsRead(pMaster, zMasterJournal, nMasterJournal, 0);
danielk197713adf8a2004-06-03 16:08:41 +00001547 if( rc!=SQLITE_OK ) goto delmaster_out;
1548
danielk19775865e3d2004-06-14 06:03:57 +00001549 zJournal = zMasterJournal;
1550 while( (zJournal-zMasterJournal)<nMasterJournal ){
danielk1977b4b47412007-08-17 15:53:36 +00001551 if( sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS) ){
danielk197713adf8a2004-06-03 16:08:41 +00001552 /* One of the journals pointed to by the master journal exists.
1553 ** Open it and check if it points at the master journal. If
1554 ** so, return without deleting the master journal file.
1555 */
drh3b7b78b2004-11-24 01:16:43 +00001556 int c;
danielk1977fee2d252007-08-18 10:59:19 +00001557 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
1558 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
danielk197713adf8a2004-06-03 16:08:41 +00001559 if( rc!=SQLITE_OK ){
danielk197713adf8a2004-06-03 16:08:41 +00001560 goto delmaster_out;
1561 }
danielk197713adf8a2004-06-03 16:08:41 +00001562
danielk197765839c62007-08-30 08:08:17 +00001563 rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
danielk1977b4b47412007-08-17 15:53:36 +00001564 sqlite3OsClose(pJournal);
danielk19779eed5052004-06-04 10:38:30 +00001565 if( rc!=SQLITE_OK ){
danielk19779eed5052004-06-04 10:38:30 +00001566 goto delmaster_out;
1567 }
danielk197776572402004-06-25 02:38:54 +00001568
danielk197765839c62007-08-30 08:08:17 +00001569 c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
drh3b7b78b2004-11-24 01:16:43 +00001570 if( c ){
danielk197776572402004-06-25 02:38:54 +00001571 /* We have a match. Do not delete the master journal file. */
1572 goto delmaster_out;
danielk197713adf8a2004-06-03 16:08:41 +00001573 }
1574 }
danielk19775865e3d2004-06-14 06:03:57 +00001575 zJournal += (strlen(zJournal)+1);
danielk197713adf8a2004-06-03 16:08:41 +00001576 }
1577 }
1578
danielk1977fee2d252007-08-18 10:59:19 +00001579 rc = sqlite3OsDelete(pVfs, zMaster, 0);
danielk197713adf8a2004-06-03 16:08:41 +00001580
1581delmaster_out:
1582 if( zMasterJournal ){
drh17435752007-08-16 04:30:38 +00001583 sqlite3_free(zMasterJournal);
danielk197713adf8a2004-06-03 16:08:41 +00001584 }
1585 if( master_open ){
danielk1977b4b47412007-08-17 15:53:36 +00001586 sqlite3OsClose(pMaster);
danielk197713adf8a2004-06-03 16:08:41 +00001587 }
danielk1977b4b47412007-08-17 15:53:36 +00001588 sqlite3_free(pMaster);
danielk197713adf8a2004-06-03 16:08:41 +00001589 return rc;
1590}
1591
drha6abd042004-06-09 17:37:22 +00001592
danielk1977e180dd92007-04-05 17:15:52 +00001593static void pager_truncate_cache(Pager *pPager);
1594
drha6abd042004-06-09 17:37:22 +00001595/*
drhcb4c40b2004-08-18 19:09:43 +00001596** Truncate the main file of the given pager to the number of pages
danielk1977e180dd92007-04-05 17:15:52 +00001597** indicated. Also truncate the cached representation of the file.
drhcb4c40b2004-08-18 19:09:43 +00001598*/
1599static int pager_truncate(Pager *pPager, int nPage){
danielk1977e180dd92007-04-05 17:15:52 +00001600 int rc = SQLITE_OK;
danielk19777a2b1ee2007-08-21 14:27:01 +00001601 if( pPager->state>=PAGER_EXCLUSIVE && pPager->fd->pMethods ){
danielk1977e180dd92007-04-05 17:15:52 +00001602 rc = sqlite3OsTruncate(pPager->fd, pPager->pageSize*(i64)nPage);
1603 }
1604 if( rc==SQLITE_OK ){
1605 pPager->dbSize = nPage;
1606 pager_truncate_cache(pPager);
1607 }
1608 return rc;
drhcb4c40b2004-08-18 19:09:43 +00001609}
1610
1611/*
drhc80f0582007-05-01 16:59:48 +00001612** Set the sectorSize for the given pager.
1613**
1614** The sector size is the larger of the sector size reported
1615** by sqlite3OsSectorSize() and the pageSize.
1616*/
1617static void setSectorSize(Pager *pPager){
danielk19777a2b1ee2007-08-21 14:27:01 +00001618 assert(pPager->fd->pMethods||pPager->tempFile);
1619 if( !pPager->tempFile ){
1620 /* Sector size doesn't matter for temporary files. Also, the file
1621 ** may not have been opened yet, in whcih case the OsSectorSize()
1622 ** call will segfault.
1623 */
1624 pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
1625 }
drhc80f0582007-05-01 16:59:48 +00001626 if( pPager->sectorSize<pPager->pageSize ){
1627 pPager->sectorSize = pPager->pageSize;
1628 }
1629}
1630
1631/*
drhed7c8552001-04-11 14:29:21 +00001632** Playback the journal and thus restore the database file to
1633** the state it was in before we started making changes.
1634**
drh34e79ce2004-02-08 06:05:46 +00001635** The journal file format is as follows:
1636**
drhae2b40c2004-06-09 19:03:54 +00001637** (1) 8 byte prefix. A copy of aJournalMagic[].
1638** (2) 4 byte big-endian integer which is the number of valid page records
drh34e79ce2004-02-08 06:05:46 +00001639** in the journal. If this value is 0xffffffff, then compute the
drhae2b40c2004-06-09 19:03:54 +00001640** number of page records from the journal size.
1641** (3) 4 byte big-endian integer which is the initial value for the
1642** sanity checksum.
1643** (4) 4 byte integer which is the number of pages to truncate the
drh34e79ce2004-02-08 06:05:46 +00001644** database to during a rollback.
drhae2b40c2004-06-09 19:03:54 +00001645** (5) 4 byte integer which is the number of bytes in the master journal
1646** name. The value may be zero (indicate that there is no master
1647** journal.)
1648** (6) N bytes of the master journal name. The name will be nul-terminated
1649** and might be shorter than the value read from (5). If the first byte
1650** of the name is \000 then there is no master journal. The master
1651** journal name is stored in UTF-8.
1652** (7) Zero or more pages instances, each as follows:
drh34e79ce2004-02-08 06:05:46 +00001653** + 4 byte page number.
drhae2b40c2004-06-09 19:03:54 +00001654** + pPager->pageSize bytes of data.
1655** + 4 byte checksum
drh34e79ce2004-02-08 06:05:46 +00001656**
drhae2b40c2004-06-09 19:03:54 +00001657** When we speak of the journal header, we mean the first 6 items above.
1658** Each entry in the journal is an instance of the 7th item.
drh34e79ce2004-02-08 06:05:46 +00001659**
1660** Call the value from the second bullet "nRec". nRec is the number of
1661** valid page entries in the journal. In most cases, you can compute the
1662** value of nRec from the size of the journal file. But if a power
1663** failure occurred while the journal was being written, it could be the
1664** case that the size of the journal file had already been increased but
1665** the extra entries had not yet made it safely to disk. In such a case,
1666** the value of nRec computed from the file size would be too large. For
1667** that reason, we always use the nRec value in the header.
1668**
1669** If the nRec value is 0xffffffff it means that nRec should be computed
1670** from the file size. This value is used when the user selects the
1671** no-sync option for the journal. A power failure could lead to corruption
1672** in this case. But for things like temporary table (which will be
1673** deleted when the power is restored) we don't care.
1674**
drhd9b02572001-04-15 00:37:09 +00001675** If the file opened as the journal file is not a well-formed
danielk1977ece80f12004-06-23 01:05:26 +00001676** journal file then all pages up to the first corrupted page are rolled
1677** back (or no pages if the journal header is corrupted). The journal file
1678** is then deleted and SQLITE_OK returned, just as if no corruption had
1679** been encountered.
1680**
1681** If an I/O or malloc() error occurs, the journal-file is not deleted
1682** and an error code is returned.
drhed7c8552001-04-11 14:29:21 +00001683*/
danielk1977e277be02007-03-23 18:12:06 +00001684static int pager_playback(Pager *pPager, int isHot){
danielk1977b4b47412007-08-17 15:53:36 +00001685 sqlite3_vfs *pVfs = pPager->pVfs;
drheb206252004-10-01 02:00:31 +00001686 i64 szJ; /* Size of the journal file in bytes */
danielk1977c3e8f5e2004-06-28 01:16:46 +00001687 u32 nRec; /* Number of Records in the journal */
drhd9b02572001-04-15 00:37:09 +00001688 int i; /* Loop counter */
1689 Pgno mxPg = 0; /* Size of the original file in pages */
drhae2b40c2004-06-09 19:03:54 +00001690 int rc; /* Result code of a subroutine */
danielk197713adf8a2004-06-03 16:08:41 +00001691 char *zMaster = 0; /* Name of master journal file if any */
drhed7c8552001-04-11 14:29:21 +00001692
drhc3a64ba2001-11-22 00:01:27 +00001693 /* Figure out how many records are in the journal. Abort early if
1694 ** the journal is empty.
drhed7c8552001-04-11 14:29:21 +00001695 */
drh8cfbf082001-09-19 13:22:39 +00001696 assert( pPager->journalOpen );
drh054889e2005-11-30 03:20:31 +00001697 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
danielk1977334cdb62007-03-26 08:05:12 +00001698 if( rc!=SQLITE_OK || szJ==0 ){
drhc3a64ba2001-11-22 00:01:27 +00001699 goto end_playback;
1700 }
drh240c5792004-02-08 00:40:52 +00001701
danielk197776572402004-06-25 02:38:54 +00001702 /* Read the master journal name from the journal, if it is present.
1703 ** If a master journal file name is specified, but the file is not
1704 ** present on disk, then the journal is not hot and does not need to be
1705 ** played back.
drh240c5792004-02-08 00:40:52 +00001706 */
danielk197765839c62007-08-30 08:08:17 +00001707 zMaster = pPager->pTmpSpace;
1708 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
danielk197776572402004-06-25 02:38:54 +00001709 assert( rc!=SQLITE_DONE );
danielk1977b4b47412007-08-17 15:53:36 +00001710 if( rc!=SQLITE_OK
danielk197765839c62007-08-30 08:08:17 +00001711 || (zMaster[0] && !sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS))
danielk1977b4b47412007-08-17 15:53:36 +00001712 ){
danielk197776572402004-06-25 02:38:54 +00001713 zMaster = 0;
1714 if( rc==SQLITE_DONE ) rc = SQLITE_OK;
drhc3a64ba2001-11-22 00:01:27 +00001715 goto end_playback;
1716 }
danielk197776572402004-06-25 02:38:54 +00001717 pPager->journalOff = 0;
danielk197765839c62007-08-30 08:08:17 +00001718 zMaster = 0;
drhc3a64ba2001-11-22 00:01:27 +00001719
danielk197776572402004-06-25 02:38:54 +00001720 /* This loop terminates either when the readJournalHdr() call returns
1721 ** SQLITE_DONE or an IO error occurs. */
1722 while( 1 ){
drhae2b40c2004-06-09 19:03:54 +00001723
danielk197776572402004-06-25 02:38:54 +00001724 /* Read the next journal header from the journal file. If there are
1725 ** not enough bytes left in the journal file for a complete header, or
1726 ** it is corrupted, then a process must of failed while writing it.
1727 ** This indicates nothing more needs to be rolled back.
1728 */
1729 rc = readJournalHdr(pPager, szJ, &nRec, &mxPg);
1730 if( rc!=SQLITE_OK ){
drh968af522003-02-11 14:55:40 +00001731 if( rc==SQLITE_DONE ){
drh968af522003-02-11 14:55:40 +00001732 rc = SQLITE_OK;
1733 }
danielk197776572402004-06-25 02:38:54 +00001734 goto end_playback;
1735 }
1736
1737 /* If nRec is 0xffffffff, then this journal was created by a process
1738 ** working in no-sync mode. This means that the rest of the journal
1739 ** file consists of pages, there are no more journal headers. Compute
1740 ** the value of nRec based on this assumption.
1741 */
1742 if( nRec==0xffffffff ){
1743 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
1744 nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager);
1745 }
1746
danielk1977e277be02007-03-23 18:12:06 +00001747 /* If nRec is 0 and this rollback is of a transaction created by this
drh8940f4e2007-08-11 00:26:20 +00001748 ** process and if this is the final header in the journal, then it means
1749 ** that this part of the journal was being filled but has not yet been
1750 ** synced to disk. Compute the number of pages based on the remaining
1751 ** size of the file.
1752 **
1753 ** The third term of the test was added to fix ticket #2565.
danielk1977e277be02007-03-23 18:12:06 +00001754 */
drh8940f4e2007-08-11 00:26:20 +00001755 if( nRec==0 && !isHot &&
1756 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
danielk1977e277be02007-03-23 18:12:06 +00001757 nRec = (szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager);
1758 }
1759
danielk197776572402004-06-25 02:38:54 +00001760 /* If this is the first header read from the journal, truncate the
1761 ** database file back to it's original size.
1762 */
danielk1977e180dd92007-04-05 17:15:52 +00001763 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
drhcb4c40b2004-08-18 19:09:43 +00001764 rc = pager_truncate(pPager, mxPg);
danielk197776572402004-06-25 02:38:54 +00001765 if( rc!=SQLITE_OK ){
1766 goto end_playback;
1767 }
danielk197776572402004-06-25 02:38:54 +00001768 }
1769
danielk197776572402004-06-25 02:38:54 +00001770 /* Copy original pages out of the journal and back into the database file.
1771 */
1772 for(i=0; i<nRec; i++){
danielk197762079062007-08-15 17:08:46 +00001773 rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
danielk197776572402004-06-25 02:38:54 +00001774 if( rc!=SQLITE_OK ){
1775 if( rc==SQLITE_DONE ){
1776 rc = SQLITE_OK;
1777 pPager->journalOff = szJ;
1778 break;
1779 }else{
1780 goto end_playback;
1781 }
1782 }
drh968af522003-02-11 14:55:40 +00001783 }
drhed7c8552001-04-11 14:29:21 +00001784 }
drh580eeaf2006-02-24 03:09:37 +00001785 /*NOTREACHED*/
1786 assert( 0 );
drh4a0681e2003-02-13 01:58:20 +00001787
1788end_playback:
danielk19778191bff2004-06-28 04:52:30 +00001789 if( rc==SQLITE_OK ){
danielk197765839c62007-08-30 08:08:17 +00001790 zMaster = pPager->pTmpSpace;
1791 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
1792 }
1793 if( rc==SQLITE_OK ){
drh80e35f42007-03-30 14:06:34 +00001794 rc = pager_end_transaction(pPager);
danielk19778191bff2004-06-28 04:52:30 +00001795 }
danielk197765839c62007-08-30 08:08:17 +00001796 if( rc==SQLITE_OK && zMaster[0] ){
danielk1977979f38e2007-03-27 16:19:51 +00001797 /* If there was a master journal and this routine will return success,
danielk197732554c12005-01-22 03:39:39 +00001798 ** see if it is possible to delete the master journal.
danielk197713adf8a2004-06-03 16:08:41 +00001799 */
danielk197765839c62007-08-30 08:08:17 +00001800 rc = pager_delmaster(pPager, zMaster);
danielk197713adf8a2004-06-03 16:08:41 +00001801 }
danielk197776572402004-06-25 02:38:54 +00001802
1803 /* The Pager.sectorSize variable may have been updated while rolling
drh3ceeb752007-03-29 18:19:52 +00001804 ** back a journal created by a process with a different sector size
danielk197776572402004-06-25 02:38:54 +00001805 ** value. Reset it to the correct value for this process.
1806 */
drhc80f0582007-05-01 16:59:48 +00001807 setSectorSize(pPager);
drhd9b02572001-04-15 00:37:09 +00001808 return rc;
drhed7c8552001-04-11 14:29:21 +00001809}
1810
1811/*
drhac69b052004-05-12 13:30:07 +00001812** Playback the statement journal.
drhfa86c412002-02-02 15:01:15 +00001813**
1814** This is similar to playing back the transaction journal but with
1815** a few extra twists.
1816**
drh663fc632002-02-02 18:49:19 +00001817** (1) The number of pages in the database file at the start of
drhac69b052004-05-12 13:30:07 +00001818** the statement is stored in pPager->stmtSize, not in the
drh663fc632002-02-02 18:49:19 +00001819** journal file itself.
drhfa86c412002-02-02 15:01:15 +00001820**
drhac69b052004-05-12 13:30:07 +00001821** (2) In addition to playing back the statement journal, also
drhfa86c412002-02-02 15:01:15 +00001822** playback all pages of the transaction journal beginning
drhac69b052004-05-12 13:30:07 +00001823** at offset pPager->stmtJSize.
drhfa86c412002-02-02 15:01:15 +00001824*/
drh3aac2dd2004-04-26 14:10:20 +00001825static int pager_stmt_playback(Pager *pPager){
drheb206252004-10-01 02:00:31 +00001826 i64 szJ; /* Size of the full journal */
1827 i64 hdrOff;
drh968af522003-02-11 14:55:40 +00001828 int nRec; /* Number of Records */
drhfa86c412002-02-02 15:01:15 +00001829 int i; /* Loop counter */
1830 int rc;
1831
danielk197776572402004-06-25 02:38:54 +00001832 szJ = pPager->journalOff;
1833#ifndef NDEBUG
1834 {
drheb206252004-10-01 02:00:31 +00001835 i64 os_szJ;
drh054889e2005-11-30 03:20:31 +00001836 rc = sqlite3OsFileSize(pPager->jfd, &os_szJ);
danielk197776572402004-06-25 02:38:54 +00001837 if( rc!=SQLITE_OK ) return rc;
1838 assert( szJ==os_szJ );
1839 }
1840#endif
1841
danielk19774099f6e2007-03-19 11:25:20 +00001842 /* Set hdrOff to be the offset just after the end of the last journal
1843 ** page written before the first journal-header for this statement
1844 ** transaction was written, or the end of the file if no journal
danielk197776572402004-06-25 02:38:54 +00001845 ** header was written.
1846 */
1847 hdrOff = pPager->stmtHdrOff;
1848 assert( pPager->fullSync || !hdrOff );
1849 if( !hdrOff ){
1850 hdrOff = szJ;
1851 }
1852
drhfa86c412002-02-02 15:01:15 +00001853 /* Truncate the database back to its original size.
1854 */
danielk1977e180dd92007-04-05 17:15:52 +00001855 rc = pager_truncate(pPager, pPager->stmtSize);
drh1aa2d8b2007-01-03 15:34:29 +00001856 assert( pPager->state>=PAGER_SHARED );
drhfa86c412002-02-02 15:01:15 +00001857
drhac69b052004-05-12 13:30:07 +00001858 /* Figure out how many records are in the statement journal.
drhfa86c412002-02-02 15:01:15 +00001859 */
drhac69b052004-05-12 13:30:07 +00001860 assert( pPager->stmtInUse && pPager->journalOpen );
drhac69b052004-05-12 13:30:07 +00001861 nRec = pPager->stmtNRec;
drhfa86c412002-02-02 15:01:15 +00001862
drhac69b052004-05-12 13:30:07 +00001863 /* Copy original pages out of the statement journal and back into the
drhae2b40c2004-06-09 19:03:54 +00001864 ** database file. Note that the statement journal omits checksums from
1865 ** each record since power-failure recovery is not important to statement
1866 ** journals.
drhfa86c412002-02-02 15:01:15 +00001867 */
danielk197762079062007-08-15 17:08:46 +00001868 for(i=0; i<nRec; i++){
1869 i64 offset = i*(4+pPager->pageSize);
1870 rc = pager_playback_one_page(pPager, pPager->stfd, offset, 0);
drh968af522003-02-11 14:55:40 +00001871 assert( rc!=SQLITE_DONE );
drh3aac2dd2004-04-26 14:10:20 +00001872 if( rc!=SQLITE_OK ) goto end_stmt_playback;
drhfa86c412002-02-02 15:01:15 +00001873 }
1874
danielk197776572402004-06-25 02:38:54 +00001875 /* Now roll some pages back from the transaction journal. Pager.stmtJSize
1876 ** was the size of the journal file when this statement was started, so
1877 ** everything after that needs to be rolled back, either into the
1878 ** database, the memory cache, or both.
1879 **
1880 ** If it is not zero, then Pager.stmtHdrOff is the offset to the start
1881 ** of the first journal header written during this statement transaction.
drhfa86c412002-02-02 15:01:15 +00001882 */
danielk197776572402004-06-25 02:38:54 +00001883 pPager->journalOff = pPager->stmtJSize;
danielk197775edc162004-06-26 01:48:18 +00001884 pPager->cksumInit = pPager->stmtCksum;
danielk19774099f6e2007-03-19 11:25:20 +00001885 while( pPager->journalOff < hdrOff ){
danielk197762079062007-08-15 17:08:46 +00001886 rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
danielk197776572402004-06-25 02:38:54 +00001887 assert( rc!=SQLITE_DONE );
1888 if( rc!=SQLITE_OK ) goto end_stmt_playback;
1889 }
1890
1891 while( pPager->journalOff < szJ ){
danielk1977f0113002006-01-24 12:09:17 +00001892 u32 nJRec; /* Number of Journal Records */
danielk197776572402004-06-25 02:38:54 +00001893 u32 dummy;
danielk1977f0113002006-01-24 12:09:17 +00001894 rc = readJournalHdr(pPager, szJ, &nJRec, &dummy);
drh968af522003-02-11 14:55:40 +00001895 if( rc!=SQLITE_OK ){
1896 assert( rc!=SQLITE_DONE );
drh3aac2dd2004-04-26 14:10:20 +00001897 goto end_stmt_playback;
drh968af522003-02-11 14:55:40 +00001898 }
danielk1977f0113002006-01-24 12:09:17 +00001899 if( nJRec==0 ){
1900 nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8);
danielk197775edc162004-06-26 01:48:18 +00001901 }
danielk1977f0113002006-01-24 12:09:17 +00001902 for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){
danielk197762079062007-08-15 17:08:46 +00001903 rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
danielk197776572402004-06-25 02:38:54 +00001904 assert( rc!=SQLITE_DONE );
1905 if( rc!=SQLITE_OK ) goto end_stmt_playback;
1906 }
drhfa86c412002-02-02 15:01:15 +00001907 }
danielk197776572402004-06-25 02:38:54 +00001908
1909 pPager->journalOff = szJ;
drhfa86c412002-02-02 15:01:15 +00001910
drh3aac2dd2004-04-26 14:10:20 +00001911end_stmt_playback:
danielk19778a7aea32006-01-23 15:25:48 +00001912 if( rc==SQLITE_OK) {
danielk197775edc162004-06-26 01:48:18 +00001913 pPager->journalOff = szJ;
1914 /* pager_reload_cache(pPager); */
drhfa86c412002-02-02 15:01:15 +00001915 }
1916 return rc;
1917}
1918
1919/*
drhf57b14a2001-09-14 18:54:08 +00001920** Change the maximum number of in-memory pages that are allowed.
1921*/
danielk19773b8a05f2007-03-19 17:44:26 +00001922void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
drhf57b14a2001-09-14 18:54:08 +00001923 if( mxPage>10 ){
1924 pPager->mxPage = mxPage;
danielk1977ef317ab2004-06-23 10:43:10 +00001925 }else{
1926 pPager->mxPage = 10;
drhf57b14a2001-09-14 18:54:08 +00001927 }
1928}
1929
1930/*
drh973b6e32003-02-12 14:09:42 +00001931** Adjust the robustness of the database to damage due to OS crashes
1932** or power failures by changing the number of syncs()s when writing
1933** the rollback journal. There are three levels:
1934**
drh054889e2005-11-30 03:20:31 +00001935** OFF sqlite3OsSync() is never called. This is the default
drh973b6e32003-02-12 14:09:42 +00001936** for temporary and transient files.
1937**
1938** NORMAL The journal is synced once before writes begin on the
1939** database. This is normally adequate protection, but
1940** it is theoretically possible, though very unlikely,
1941** that an inopertune power failure could leave the journal
1942** in a state which would cause damage to the database
1943** when it is rolled back.
1944**
1945** FULL The journal is synced twice before writes begin on the
drh34e79ce2004-02-08 06:05:46 +00001946** database (with some additional information - the nRec field
1947** of the journal header - being written in between the two
1948** syncs). If we assume that writing a
drh973b6e32003-02-12 14:09:42 +00001949** single disk sector is atomic, then this mode provides
1950** assurance that the journal will not be corrupted to the
1951** point of causing damage to the database during rollback.
1952**
1953** Numeric values associated with these states are OFF==1, NORMAL=2,
1954** and FULL=3.
1955*/
danielk197793758c82005-01-21 08:13:14 +00001956#ifndef SQLITE_OMIT_PAGER_PRAGMAS
danielk19773b8a05f2007-03-19 17:44:26 +00001957void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int full_fsync){
drh973b6e32003-02-12 14:09:42 +00001958 pPager->noSync = level==1 || pPager->tempFile;
1959 pPager->fullSync = level==3 && !pPager->tempFile;
danielk1977f036aef2007-08-20 05:36:51 +00001960 pPager->sync_flags = (full_fsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);
danielk19771d850a72004-05-31 08:26:49 +00001961 if( pPager->noSync ) pPager->needSync = 0;
drh973b6e32003-02-12 14:09:42 +00001962}
danielk197793758c82005-01-21 08:13:14 +00001963#endif
drh973b6e32003-02-12 14:09:42 +00001964
1965/*
drhaf6df112005-06-07 02:12:30 +00001966** The following global variable is incremented whenever the library
1967** attempts to open a temporary file. This information is used for
1968** testing and analysis only.
1969*/
drh0f7eb612006-08-08 13:51:43 +00001970#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00001971int sqlite3_opentemp_count = 0;
drh0f7eb612006-08-08 13:51:43 +00001972#endif
drhaf6df112005-06-07 02:12:30 +00001973
1974/*
drh3f56e6e2007-03-15 01:16:47 +00001975** Open a temporary file.
1976**
1977** Write the file descriptor into *fd. Return SQLITE_OK on success or some
danielk1977fee2d252007-08-18 10:59:19 +00001978** other error code if we fail. The OS will automatically delete the temporary
1979** file when it is closed.
drhfa86c412002-02-02 15:01:15 +00001980**
drhae28c012007-08-24 16:29:23 +00001981** If zFilename is 0, then an appropriate temporary filename is
1982** generated automatically and SQLITE_OPEN_SUBJOURNAL is passed to
1983** the OS layer as the file type.
1984**
1985** If zFilename is not 0, SQLITE_OPEN_TEMP_DB is passed as the file type.
drhfa86c412002-02-02 15:01:15 +00001986*/
danielk1977b4b47412007-08-17 15:53:36 +00001987static int sqlite3PagerOpentemp(
1988 sqlite3_vfs *pVfs,
1989 sqlite3_file *pFile,
drhae28c012007-08-24 16:29:23 +00001990 char *zFilename
danielk1977b4b47412007-08-17 15:53:36 +00001991){
drhfa86c412002-02-02 15:01:15 +00001992 int rc;
danielk1977863c0f92007-08-23 11:47:59 +00001993 int flags = (
1994 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
1995 SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_DELETEONCLOSE
1996 );
danielk1977b4b47412007-08-17 15:53:36 +00001997
1998 char *zFree = 0;
drhae28c012007-08-24 16:29:23 +00001999 if( zFilename==0 ){
danielk1977b4b47412007-08-17 15:53:36 +00002000 zFree = (char *)sqlite3_malloc(pVfs->mxPathname);
2001 if( !zFree ){
2002 return SQLITE_NOMEM;
2003 }
drhae28c012007-08-24 16:29:23 +00002004 zFilename = zFree;
danielk1977fee2d252007-08-18 10:59:19 +00002005 flags |= SQLITE_OPEN_SUBJOURNAL;
drhae28c012007-08-24 16:29:23 +00002006 rc = sqlite3OsGetTempName(pVfs, zFilename);
2007 if( rc!=SQLITE_OK ){
2008 sqlite3_free(zFree);
2009 return rc;
2010 }
danielk1977fee2d252007-08-18 10:59:19 +00002011 }else{
2012 flags |= SQLITE_OPEN_TEMP_DB;
danielk1977b4b47412007-08-17 15:53:36 +00002013 }
drh3f56e6e2007-03-15 01:16:47 +00002014
drh0f7eb612006-08-08 13:51:43 +00002015#ifdef SQLITE_TEST
drhaf6df112005-06-07 02:12:30 +00002016 sqlite3_opentemp_count++; /* Used for testing and analysis only */
drh0f7eb612006-08-08 13:51:43 +00002017#endif
danielk1977b4b47412007-08-17 15:53:36 +00002018
drhae28c012007-08-24 16:29:23 +00002019 rc = sqlite3OsOpen(pVfs, zFilename, pFile, flags, 0);
2020 assert( rc!=SQLITE_OK || pFile->pMethods );
danielk1977b4b47412007-08-17 15:53:36 +00002021 sqlite3_free(zFree);
drhfa86c412002-02-02 15:01:15 +00002022 return rc;
2023}
2024
2025/*
drhed7c8552001-04-11 14:29:21 +00002026** Create a new page cache and put a pointer to the page cache in *ppPager.
drh5e00f6c2001-09-13 13:46:56 +00002027** The file to be cached need not exist. The file is not locked until
danielk19773b8a05f2007-03-19 17:44:26 +00002028** the first call to sqlite3PagerGet() and is only held open until the
2029** last page is released using sqlite3PagerUnref().
drh382c0242001-10-06 16:33:02 +00002030**
drh6446c4d2001-12-15 14:22:18 +00002031** If zFilename is NULL then a randomly-named temporary file is created
drh1cc8c442007-08-24 16:08:29 +00002032** and used as the file to be cached. The file will be deleted
drh6446c4d2001-12-15 14:22:18 +00002033** automatically when it is closed.
drh90f5ecb2004-07-22 01:19:35 +00002034**
2035** If zFilename is ":memory:" then all information is held in cache.
2036** It is never written to disk. This can be used to implement an
2037** in-memory database.
drhed7c8552001-04-11 14:29:21 +00002038*/
danielk19773b8a05f2007-03-19 17:44:26 +00002039int sqlite3PagerOpen(
drh86f8c192007-08-22 00:39:19 +00002040 sqlite3_vfs *pVfs, /* The virtual file system to use */
drh7e3b0a02001-04-28 16:52:40 +00002041 Pager **ppPager, /* Return the Pager structure here */
2042 const char *zFilename, /* Name of the database file to open */
drhda47d772002-12-02 04:25:19 +00002043 int nExtra, /* Extra bytes append to each in-memory page */
drh7bec5052005-02-06 02:45:41 +00002044 int flags /* flags controlling this file */
drh7e3b0a02001-04-28 16:52:40 +00002045){
danielk1977b4b47412007-08-17 15:53:36 +00002046 u8 *pPtr;
danielk1977aef0bf62005-12-30 16:28:01 +00002047 Pager *pPager = 0;
danielk1977cfe9a692004-06-16 12:00:29 +00002048 int rc = SQLITE_OK;
2049 int i;
danielk19778def5ea2004-06-16 10:39:52 +00002050 int tempFile = 0;
drhac69b052004-05-12 13:30:07 +00002051 int memDb = 0;
drh5e00f6c2001-09-13 13:46:56 +00002052 int readOnly = 0;
drh7bec5052005-02-06 02:45:41 +00002053 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0;
2054 int noReadlock = (flags & PAGER_NO_READLOCK)!=0;
danielk1977c7b60172007-08-22 11:22:03 +00002055 int journalFileSize = sqlite3JournalSize(pVfs);
drh1cc8c442007-08-24 16:08:29 +00002056 int nDefaultPage = SQLITE_DEFAULT_PAGE_SIZE;
2057 char *zPathname;
2058 int nPathname;
danielk1977b4b47412007-08-17 15:53:36 +00002059
drh86f8c192007-08-22 00:39:19 +00002060 /* The default return is a NULL pointer */
drhd9b02572001-04-15 00:37:09 +00002061 *ppPager = 0;
danielk1977aef0bf62005-12-30 16:28:01 +00002062
drh1cc8c442007-08-24 16:08:29 +00002063 /* Compute the full pathname */
2064 zPathname = sqlite3_malloc(pVfs->mxPathname+1);
2065 if( zPathname==0 ){
2066 return SQLITE_NOMEM;
2067 }
2068 if( zFilename && zFilename[0] ){
2069#ifndef SQLITE_OMIT_MEMORYDB
2070 if( strcmp(zFilename,":memory:")==0 ){
2071 memDb = 1;
2072 zPathname[0] = 0;
2073 }else
2074#endif
2075 {
2076 rc = sqlite3OsFullPathname(pVfs, zFilename, zPathname);
drh1cc8c442007-08-24 16:08:29 +00002077 }
2078 }else{
drhae28c012007-08-24 16:29:23 +00002079 rc = sqlite3OsGetTempName(pVfs, zPathname);
2080 }
2081 if( rc!=SQLITE_OK ){
2082 sqlite3_free(zPathname);
2083 return rc;
drh1cc8c442007-08-24 16:08:29 +00002084 }
2085 nPathname = strlen(zPathname);
2086
danielk1977b4b47412007-08-17 15:53:36 +00002087 /* Allocate memory for the pager structure */
2088 pPager = sqlite3MallocZero(
2089 sizeof(*pPager) + /* Pager structure */
danielk1977c7b60172007-08-22 11:22:03 +00002090 journalFileSize + /* The journal file structure */
2091 pVfs->szOsFile * 2 + /* The db and stmt journal files */
drh1cc8c442007-08-24 16:08:29 +00002092 nPathname * 3 + 30 /* zFilename, zDirectory, zJournal */
danielk1977b4b47412007-08-17 15:53:36 +00002093 );
2094 if( !pPager ){
drh1cc8c442007-08-24 16:08:29 +00002095 sqlite3_free(zPathname);
danielk1977b4b47412007-08-17 15:53:36 +00002096 return SQLITE_NOMEM;
2097 }
2098 pPtr = (u8 *)&pPager[1];
2099 pPager->fd = (sqlite3_file*)&pPtr[pVfs->szOsFile*0];
danielk1977c7b60172007-08-22 11:22:03 +00002100 pPager->stfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*1];
2101 pPager->jfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*2];
2102 pPager->zFilename = (char*)&pPtr[pVfs->szOsFile*2+journalFileSize];
drh1cc8c442007-08-24 16:08:29 +00002103 pPager->zDirectory = &pPager->zFilename[nPathname+1];
2104 pPager->zJournal = &pPager->zDirectory[nPathname+1];
danielk1977b4b47412007-08-17 15:53:36 +00002105 pPager->pVfs = pVfs;
drh1cc8c442007-08-24 16:08:29 +00002106 memcpy(pPager->zFilename, zPathname, nPathname+1);
2107 sqlite3_free(zPathname);
danielk1977b4b47412007-08-17 15:53:36 +00002108
drh153c62c2007-08-24 03:51:33 +00002109 /* Open the pager file.
danielk1977aef0bf62005-12-30 16:28:01 +00002110 */
drhae28c012007-08-24 16:29:23 +00002111 if( zFilename && zFilename[0] && !memDb ){
drh1cc8c442007-08-24 16:08:29 +00002112 if( nPathname>(pVfs->mxPathname - sizeof("-journal")) ){
2113 rc = SQLITE_CANTOPEN;
2114 }else{
2115/*** FIXME: Might need to be SQLITE_OPEN_TEMP_DB. Need to pass in
2116**** a flag from higher up.
2117****/
2118 int oflag =
2119 (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MAIN_DB);
2120 int fout = 0;
2121 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, oflag, &fout);
2122 readOnly = (fout&SQLITE_OPEN_READONLY);
2123
2124 /* If the file was successfully opened for read/write access,
2125 ** choose a default page size in case we have to create the
2126 ** database file. The default page size is the maximum of:
2127 **
2128 ** + SQLITE_DEFAULT_PAGE_SIZE,
2129 ** + The value returned by sqlite3OsSectorSize()
2130 ** + The largest page size that can be written atomically.
2131 */
2132 if( rc==SQLITE_OK && !readOnly ){
2133 int iSectorSize = sqlite3OsSectorSize(pPager->fd);
2134 if( nDefaultPage<iSectorSize ){
2135 nDefaultPage = iSectorSize;
2136 }
danielk19779663b8f2007-08-24 11:52:28 +00002137#ifdef SQLITE_ENABLE_ATOMIC_WRITE
drh1cc8c442007-08-24 16:08:29 +00002138 {
2139 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
2140 int ii;
2141 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
2142 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
2143 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
2144 for(ii=nDefaultPage; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
2145 if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ) nDefaultPage = ii;
danielk19779663b8f2007-08-24 11:52:28 +00002146 }
danielk1977b4b47412007-08-17 15:53:36 +00002147 }
drh1cc8c442007-08-24 16:08:29 +00002148#endif
2149 if( nDefaultPage>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
2150 nDefaultPage = SQLITE_MAX_DEFAULT_PAGE_SIZE;
2151 }
danielk19778def5ea2004-06-16 10:39:52 +00002152 }
drhac69b052004-05-12 13:30:07 +00002153 }
drh1cc8c442007-08-24 16:08:29 +00002154 }else if( !memDb ){
danielk19777a2b1ee2007-08-21 14:27:01 +00002155 /* If a temporary file is requested, it is not opened immediately.
2156 ** In this case we accept the default page size and delay actually
2157 ** opening the file until the first call to OsWrite().
2158 */
danielk19777a2b1ee2007-08-21 14:27:01 +00002159 tempFile = 1;
2160 pPager->state = PAGER_EXCLUSIVE;
drh5e00f6c2001-09-13 13:46:56 +00002161 }
danielk1977aef0bf62005-12-30 16:28:01 +00002162
danielk1977b4b47412007-08-17 15:53:36 +00002163 if( pPager && rc==SQLITE_OK ){
danielk19779663b8f2007-08-24 11:52:28 +00002164 pPager->pTmpSpace = (char *)sqlite3_malloc(nDefaultPage);
drh3e7a6092002-12-07 21:45:14 +00002165 }
danielk1977aef0bf62005-12-30 16:28:01 +00002166
drh153c62c2007-08-24 03:51:33 +00002167 /* If an error occured in either of the blocks above.
2168 ** Free the Pager structure and close the file.
2169 ** Since the pager is not allocated there is no need to set
danielk1977aef0bf62005-12-30 16:28:01 +00002170 ** any Pager.errMask variables.
2171 */
danielk1977b4b47412007-08-17 15:53:36 +00002172 if( !pPager || !pPager->pTmpSpace ){
2173 sqlite3OsClose(pPager->fd);
drh17435752007-08-16 04:30:38 +00002174 sqlite3_free(pPager);
danielk1977aef0bf62005-12-30 16:28:01 +00002175 return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc);
drhed7c8552001-04-11 14:29:21 +00002176 }
danielk1977aef0bf62005-12-30 16:28:01 +00002177
drh153c62c2007-08-24 03:51:33 +00002178 PAGERTRACE3("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename);
2179 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
danielk1977aef0bf62005-12-30 16:28:01 +00002180
danielk1977b4b47412007-08-17 15:53:36 +00002181 /* Fill in Pager.zDirectory[] */
drh1cc8c442007-08-24 16:08:29 +00002182 memcpy(pPager->zDirectory, pPager->zFilename, nPathname+1);
danielk1977b4b47412007-08-17 15:53:36 +00002183 for(i=strlen(pPager->zDirectory); i>0 && pPager->zDirectory[i-1]!='/'; i--){}
drha76c82e2003-07-27 18:59:42 +00002184 if( i>0 ) pPager->zDirectory[i-1] = 0;
danielk1977b4b47412007-08-17 15:53:36 +00002185
2186 /* Fill in Pager.zJournal[] */
drh1cc8c442007-08-24 16:08:29 +00002187 memcpy(pPager->zJournal, pPager->zFilename, nPathname);
2188 memcpy(&pPager->zJournal[nPathname], "-journal", 9);
danielk1977b4b47412007-08-17 15:53:36 +00002189
drh3b59a5c2006-01-15 20:28:28 +00002190 /* pPager->journalOpen = 0; */
drhac69b052004-05-12 13:30:07 +00002191 pPager->useJournal = useJournal && !memDb;
drh7bec5052005-02-06 02:45:41 +00002192 pPager->noReadlock = noReadlock && readOnly;
drh3b59a5c2006-01-15 20:28:28 +00002193 /* pPager->stmtOpen = 0; */
2194 /* pPager->stmtInUse = 0; */
2195 /* pPager->nRef = 0; */
drhac69b052004-05-12 13:30:07 +00002196 pPager->dbSize = memDb-1;
danielk19779663b8f2007-08-24 11:52:28 +00002197 pPager->pageSize = nDefaultPage;
drh3b59a5c2006-01-15 20:28:28 +00002198 /* pPager->stmtSize = 0; */
2199 /* pPager->stmtJSize = 0; */
2200 /* pPager->nPage = 0; */
drh90f5ecb2004-07-22 01:19:35 +00002201 pPager->mxPage = 100;
drhf8e632b2007-05-08 14:51:36 +00002202 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
drh3b59a5c2006-01-15 20:28:28 +00002203 /* pPager->state = PAGER_UNLOCK; */
drh1cc8c442007-08-24 16:08:29 +00002204 assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
drh3b59a5c2006-01-15 20:28:28 +00002205 /* pPager->errMask = 0; */
drh5e00f6c2001-09-13 13:46:56 +00002206 pPager->tempFile = tempFile;
drh369339d2007-03-30 16:01:55 +00002207 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
2208 || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
2209 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
2210 pPager->exclusiveMode = tempFile;
drhac69b052004-05-12 13:30:07 +00002211 pPager->memDb = memDb;
drh5e00f6c2001-09-13 13:46:56 +00002212 pPager->readOnly = readOnly;
drh3b59a5c2006-01-15 20:28:28 +00002213 /* pPager->needSync = 0; */
drhda47d772002-12-02 04:25:19 +00002214 pPager->noSync = pPager->tempFile || !useJournal;
danielk197775edc162004-06-26 01:48:18 +00002215 pPager->fullSync = (pPager->noSync?0:1);
danielk1977f036aef2007-08-20 05:36:51 +00002216 pPager->sync_flags = SQLITE_SYNC_NORMAL;
drh3b59a5c2006-01-15 20:28:28 +00002217 /* pPager->pFirst = 0; */
2218 /* pPager->pFirstSynced = 0; */
2219 /* pPager->pLast = 0; */
drh887dc4c2004-10-22 16:22:57 +00002220 pPager->nExtra = FORCE_ALIGNMENT(nExtra);
danielk19777a2b1ee2007-08-21 14:27:01 +00002221 assert(pPager->fd->pMethods||memDb||tempFile);
danielk1977b4721172007-03-19 05:54:48 +00002222 if( !memDb ){
drhc80f0582007-05-01 16:59:48 +00002223 setSectorSize(pPager);
danielk1977b4721172007-03-19 05:54:48 +00002224 }
drh3b59a5c2006-01-15 20:28:28 +00002225 /* pPager->pBusyHandler = 0; */
2226 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
drhed7c8552001-04-11 14:29:21 +00002227 *ppPager = pPager;
drh6f7adc82006-01-11 21:41:20 +00002228#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
drh86f8c192007-08-22 00:39:19 +00002229 pPager->iInUseMM = 0;
2230 pPager->iInUseDB = 0;
2231 if( !memDb ){
2232 sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
2233 sqlite3_mutex_enter(mutex);
2234 pPager->pNext = sqlite3PagerList;
2235 if( sqlite3PagerList ){
2236 assert( sqlite3PagerList->pPrev==0 );
2237 sqlite3PagerList->pPrev = pPager;
2238 }
2239 pPager->pPrev = 0;
2240 sqlite3PagerList = pPager;
2241 sqlite3_mutex_leave(mutex);
2242 }
danielk197752622822006-01-09 09:59:49 +00002243#endif
drhed7c8552001-04-11 14:29:21 +00002244 return SQLITE_OK;
2245}
2246
2247/*
drh90f5ecb2004-07-22 01:19:35 +00002248** Set the busy handler function.
2249*/
danielk19773b8a05f2007-03-19 17:44:26 +00002250void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){
drh90f5ecb2004-07-22 01:19:35 +00002251 pPager->pBusyHandler = pBusyHandler;
2252}
2253
2254/*
drh72f82862001-05-24 21:06:34 +00002255** Set the destructor for this pager. If not NULL, the destructor is called
drh5e00f6c2001-09-13 13:46:56 +00002256** when the reference count on each page reaches zero. The destructor can
2257** be used to clean up information in the extra segment appended to each page.
drh72f82862001-05-24 21:06:34 +00002258**
danielk19773b8a05f2007-03-19 17:44:26 +00002259** The destructor is not called as a result sqlite3PagerClose().
2260** Destructors are only called by sqlite3PagerUnref().
drh72f82862001-05-24 21:06:34 +00002261*/
danielk19773b8a05f2007-03-19 17:44:26 +00002262void sqlite3PagerSetDestructor(Pager *pPager, void (*xDesc)(DbPage*,int)){
drh72f82862001-05-24 21:06:34 +00002263 pPager->xDestructor = xDesc;
2264}
2265
2266/*
drha6abd042004-06-09 17:37:22 +00002267** Set the reinitializer for this pager. If not NULL, the reinitializer
2268** is called when the content of a page in cache is restored to its original
2269** value as a result of a rollback. The callback gives higher-level code
2270** an opportunity to restore the EXTRA section to agree with the restored
2271** page data.
2272*/
danielk19773b8a05f2007-03-19 17:44:26 +00002273void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*,int)){
drha6abd042004-06-09 17:37:22 +00002274 pPager->xReiniter = xReinit;
2275}
2276
2277/*
danielk1977a1644fd2007-08-29 12:31:25 +00002278** Set the page size to *pPageSize. If the suggest new page size is
2279** inappropriate, then an alternative page size is set to that
2280** value before returning.
drh90f5ecb2004-07-22 01:19:35 +00002281*/
danielk1977a1644fd2007-08-29 12:31:25 +00002282int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize){
2283 int rc = SQLITE_OK;
2284 u16 pageSize = *pPageSize;
danielk19779663b8f2007-08-24 11:52:28 +00002285 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
danielk1977a1644fd2007-08-29 12:31:25 +00002286 if( pageSize && pageSize!=pPager->pageSize
2287 && !pPager->memDb && pPager->nRef==0
2288 ){
2289 char *pNew = (char *)sqlite3_malloc(pageSize);
2290 if( !pNew ){
2291 rc = SQLITE_NOMEM;
2292 }else{
2293 pagerEnter(pPager);
2294 pager_reset(pPager);
2295 pPager->pageSize = pageSize;
2296 setSectorSize(pPager);
2297 sqlite3_free(pPager->pTmpSpace);
2298 pPager->pTmpSpace = pNew;
2299 pagerLeave(pPager);
2300 }
drh1c7880e2005-05-20 20:01:55 +00002301 }
danielk1977a1644fd2007-08-29 12:31:25 +00002302 *pPageSize = pPager->pageSize;
2303 return rc;
drh90f5ecb2004-07-22 01:19:35 +00002304}
2305
2306/*
drhf8e632b2007-05-08 14:51:36 +00002307** Attempt to set the maximum database page count if mxPage is positive.
2308** Make no changes if mxPage is zero or negative. And never reduce the
2309** maximum page count below the current size of the database.
2310**
2311** Regardless of mxPage, return the current maximum page count.
2312*/
2313int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
2314 if( mxPage>0 ){
2315 pPager->mxPgno = mxPage;
2316 }
2317 sqlite3PagerPagecount(pPager);
2318 return pPager->mxPgno;
2319}
2320
2321/*
drhc9ac5ca2005-11-04 22:03:30 +00002322** The following set of routines are used to disable the simulated
2323** I/O error mechanism. These routines are used to avoid simulated
2324** errors in places where we do not care about errors.
2325**
2326** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
2327** and generate no code.
2328*/
2329#ifdef SQLITE_TEST
2330extern int sqlite3_io_error_pending;
2331extern int sqlite3_io_error_hit;
2332static int saved_cnt;
drhc9ac5ca2005-11-04 22:03:30 +00002333void disable_simulated_io_errors(void){
2334 saved_cnt = sqlite3_io_error_pending;
2335 sqlite3_io_error_pending = -1;
2336}
2337void enable_simulated_io_errors(void){
2338 sqlite3_io_error_pending = saved_cnt;
2339}
2340#else
drh152410f2005-11-05 15:11:22 +00002341# define disable_simulated_io_errors()
2342# define enable_simulated_io_errors()
drhc9ac5ca2005-11-04 22:03:30 +00002343#endif
2344
2345/*
drh90f5ecb2004-07-22 01:19:35 +00002346** Read the first N bytes from the beginning of the file into memory
danielk1977aef0bf62005-12-30 16:28:01 +00002347** that pDest points to.
2348**
2349** No error checking is done. The rational for this is that this function
2350** may be called even if the file does not exist or contain a header. In
2351** these cases sqlite3OsRead() will return an error, to which the correct
2352** response is to zero the memory at pDest and continue. A real IO error
2353** will presumably recur and be picked up later (Todo: Think about this).
drh90f5ecb2004-07-22 01:19:35 +00002354*/
danielk19773b8a05f2007-03-19 17:44:26 +00002355int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
drh551b7732006-11-06 21:20:25 +00002356 int rc = SQLITE_OK;
drh90f5ecb2004-07-22 01:19:35 +00002357 memset(pDest, 0, N);
danielk19777a2b1ee2007-08-21 14:27:01 +00002358 assert(MEMDB||pPager->fd->pMethods||pPager->tempFile);
2359 if( pPager->fd->pMethods ){
drhb0603412007-02-28 04:47:26 +00002360 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
danielk197762079062007-08-15 17:08:46 +00002361 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
drh551b7732006-11-06 21:20:25 +00002362 if( rc==SQLITE_IOERR_SHORT_READ ){
2363 rc = SQLITE_OK;
2364 }
drh90f5ecb2004-07-22 01:19:35 +00002365 }
drh551b7732006-11-06 21:20:25 +00002366 return rc;
drh90f5ecb2004-07-22 01:19:35 +00002367}
2368
2369/*
drh5e00f6c2001-09-13 13:46:56 +00002370** Return the total number of pages in the disk file associated with
danielk197715f411d2005-09-16 10:18:45 +00002371** pPager.
2372**
2373** If the PENDING_BYTE lies on the page directly after the end of the
2374** file, then consider this page part of the file too. For example, if
2375** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the
2376** file is 4096 bytes, 5 is returned instead of 4.
drhed7c8552001-04-11 14:29:21 +00002377*/
danielk19773b8a05f2007-03-19 17:44:26 +00002378int sqlite3PagerPagecount(Pager *pPager){
danielk19777a2b1ee2007-08-21 14:27:01 +00002379 i64 n = 0;
drhe49f9822006-09-15 12:29:16 +00002380 int rc;
drhd9b02572001-04-15 00:37:09 +00002381 assert( pPager!=0 );
drha7aea3d2007-03-15 12:51:16 +00002382 if( pPager->errCode ){
2383 return 0;
2384 }
drhed7c8552001-04-11 14:29:21 +00002385 if( pPager->dbSize>=0 ){
danielk197715f411d2005-09-16 10:18:45 +00002386 n = pPager->dbSize;
2387 } else {
danielk19777a2b1ee2007-08-21 14:27:01 +00002388 assert(pPager->fd->pMethods||pPager->tempFile);
2389 if( (pPager->fd->pMethods)
2390 && (rc = sqlite3OsFileSize(pPager->fd, &n))!=SQLITE_OK ){
drhe49f9822006-09-15 12:29:16 +00002391 pager_error(pPager, rc);
danielk197715f411d2005-09-16 10:18:45 +00002392 return 0;
2393 }
2394 if( n>0 && n<pPager->pageSize ){
2395 n = 1;
2396 }else{
2397 n /= pPager->pageSize;
2398 }
2399 if( pPager->state!=PAGER_UNLOCK ){
2400 pPager->dbSize = n;
2401 }
drhed7c8552001-04-11 14:29:21 +00002402 }
danielk197715f411d2005-09-16 10:18:45 +00002403 if( n==(PENDING_BYTE/pPager->pageSize) ){
drh1f595712004-06-15 01:40:29 +00002404 n++;
2405 }
drhf8e632b2007-05-08 14:51:36 +00002406 if( n>pPager->mxPgno ){
2407 pPager->mxPgno = n;
2408 }
drhed7c8552001-04-11 14:29:21 +00002409 return n;
2410}
2411
drhf07e7d52006-04-07 13:54:46 +00002412
2413#ifndef SQLITE_OMIT_MEMORYDB
2414/*
2415** Clear a PgHistory block
2416*/
2417static void clearHistory(PgHistory *pHist){
drh17435752007-08-16 04:30:38 +00002418 sqlite3_free(pHist->pOrig);
2419 sqlite3_free(pHist->pStmt);
drhf07e7d52006-04-07 13:54:46 +00002420 pHist->pOrig = 0;
2421 pHist->pStmt = 0;
2422}
2423#else
2424#define clearHistory(x)
2425#endif
2426
drhed7c8552001-04-11 14:29:21 +00002427/*
drhf7c57532003-04-25 13:22:51 +00002428** Forward declaration
2429*/
danielk197776572402004-06-25 02:38:54 +00002430static int syncJournal(Pager*);
drhac69b052004-05-12 13:30:07 +00002431
2432/*
danielk1977f5fdda82004-11-03 08:44:05 +00002433** Unlink pPg from it's hash chain. Also set the page number to 0 to indicate
2434** that the page is not part of any hash chain. This is required because the
danielk19773b8a05f2007-03-19 17:44:26 +00002435** sqlite3PagerMovepage() routine can leave a page in the
danielk1977f5fdda82004-11-03 08:44:05 +00002436** pNextFree/pPrevFree list that is not a part of any hash-chain.
2437*/
2438static void unlinkHashChain(Pager *pPager, PgHdr *pPg){
2439 if( pPg->pgno==0 ){
drh3765df42006-06-28 18:18:09 +00002440 assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );
danielk1977f5fdda82004-11-03 08:44:05 +00002441 return;
2442 }
2443 if( pPg->pNextHash ){
2444 pPg->pNextHash->pPrevHash = pPg->pPrevHash;
2445 }
2446 if( pPg->pPrevHash ){
drh8ca0c722006-05-07 17:49:38 +00002447 assert( pPager->aHash[pPg->pgno & (pPager->nHash-1)]!=pPg );
danielk1977f5fdda82004-11-03 08:44:05 +00002448 pPg->pPrevHash->pNextHash = pPg->pNextHash;
2449 }else{
drh8ca0c722006-05-07 17:49:38 +00002450 int h = pPg->pgno & (pPager->nHash-1);
danielk1977f5fdda82004-11-03 08:44:05 +00002451 pPager->aHash[h] = pPg->pNextHash;
2452 }
drh5229ae42006-03-23 23:29:04 +00002453 if( MEMDB ){
drh5229ae42006-03-23 23:29:04 +00002454 clearHistory(PGHDR_TO_HIST(pPg, pPager));
2455 }
danielk1977f5fdda82004-11-03 08:44:05 +00002456 pPg->pgno = 0;
2457 pPg->pNextHash = pPg->pPrevHash = 0;
2458}
2459
2460/*
drhac69b052004-05-12 13:30:07 +00002461** Unlink a page from the free list (the list of all pages where nRef==0)
2462** and from its hash collision chain.
2463*/
2464static void unlinkPage(PgHdr *pPg){
2465 Pager *pPager = pPg->pPager;
2466
danielk19779f61c2f2007-08-27 17:27:49 +00002467 /* Unlink from free page list */
2468 lruListRemove(pPg);
drhac69b052004-05-12 13:30:07 +00002469
2470 /* Unlink from the pgno hash table */
danielk1977f5fdda82004-11-03 08:44:05 +00002471 unlinkHashChain(pPager, pPg);
drhac69b052004-05-12 13:30:07 +00002472}
2473
2474/*
danielk1977e180dd92007-04-05 17:15:52 +00002475** This routine is used to truncate the cache when a database
2476** is truncated. Drop from the cache all pages whose pgno is
2477** larger than pPager->dbSize and is unreferenced.
2478**
drhac69b052004-05-12 13:30:07 +00002479** Referenced pages larger than pPager->dbSize are zeroed.
danielk1977e180dd92007-04-05 17:15:52 +00002480**
2481** Actually, at the point this routine is called, it would be
2482** an error to have a referenced page. But rather than delete
2483** that page and guarantee a subsequent segfault, it seems better
2484** to zero it and hope that we error out sanely.
drhac69b052004-05-12 13:30:07 +00002485*/
danielk1977e180dd92007-04-05 17:15:52 +00002486static void pager_truncate_cache(Pager *pPager){
drhac69b052004-05-12 13:30:07 +00002487 PgHdr *pPg;
2488 PgHdr **ppPg;
2489 int dbSize = pPager->dbSize;
2490
2491 ppPg = &pPager->pAll;
2492 while( (pPg = *ppPg)!=0 ){
2493 if( pPg->pgno<=dbSize ){
2494 ppPg = &pPg->pNextAll;
2495 }else if( pPg->nRef>0 ){
2496 memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
2497 ppPg = &pPg->pNextAll;
2498 }else{
2499 *ppPg = pPg->pNextAll;
drh538f5702007-04-13 02:14:30 +00002500 IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno));
2501 PAGER_INCR(sqlite3_pager_pgfree_count);
drhac69b052004-05-12 13:30:07 +00002502 unlinkPage(pPg);
drh605ad8f2006-05-03 23:34:05 +00002503 makeClean(pPg);
drh17435752007-08-16 04:30:38 +00002504 sqlite3_free(pPg);
drhac69b052004-05-12 13:30:07 +00002505 pPager->nPage--;
2506 }
2507 }
2508}
2509
drhf7c57532003-04-25 13:22:51 +00002510/*
danielk197717221812005-02-15 03:38:05 +00002511** Try to obtain a lock on a file. Invoke the busy callback if the lock
drha4afb652005-07-09 02:16:02 +00002512** is currently not available. Repeat until the busy callback returns
danielk197717221812005-02-15 03:38:05 +00002513** false or until the lock succeeds.
2514**
2515** Return SQLITE_OK on success and an error code if we cannot obtain
2516** the lock.
2517*/
2518static int pager_wait_on_lock(Pager *pPager, int locktype){
2519 int rc;
drh1aa2d8b2007-01-03 15:34:29 +00002520
2521 /* The OS lock values must be the same as the Pager lock values */
danielk197717221812005-02-15 03:38:05 +00002522 assert( PAGER_SHARED==SHARED_LOCK );
2523 assert( PAGER_RESERVED==RESERVED_LOCK );
2524 assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
drh1aa2d8b2007-01-03 15:34:29 +00002525
2526 /* If the file is currently unlocked then the size must be unknown */
2527 assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB );
2528
danielk197717221812005-02-15 03:38:05 +00002529 if( pPager->state>=locktype ){
2530 rc = SQLITE_OK;
2531 }else{
danielk197717221812005-02-15 03:38:05 +00002532 do {
drh054889e2005-11-30 03:20:31 +00002533 rc = sqlite3OsLock(pPager->fd, locktype);
drha4afb652005-07-09 02:16:02 +00002534 }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) );
danielk197717221812005-02-15 03:38:05 +00002535 if( rc==SQLITE_OK ){
2536 pPager->state = locktype;
drhb0603412007-02-28 04:47:26 +00002537 IOTRACE(("LOCK %p %d\n", pPager, locktype))
danielk197717221812005-02-15 03:38:05 +00002538 }
2539 }
2540 return rc;
2541}
2542
2543/*
drhf7c57532003-04-25 13:22:51 +00002544** Truncate the file to the number of pages specified.
2545*/
danielk19773b8a05f2007-03-19 17:44:26 +00002546int sqlite3PagerTruncate(Pager *pPager, Pgno nPage){
drhf7c57532003-04-25 13:22:51 +00002547 int rc;
drh1aa2d8b2007-01-03 15:34:29 +00002548 assert( pPager->state>=PAGER_SHARED || MEMDB );
danielk19773b8a05f2007-03-19 17:44:26 +00002549 sqlite3PagerPagecount(pPager);
danielk1977efaaf572006-01-16 11:29:19 +00002550 if( pPager->errCode ){
2551 rc = pPager->errCode;
drh2e6d11b2003-04-25 15:37:57 +00002552 return rc;
2553 }
drh7d02cb72003-06-04 16:24:39 +00002554 if( nPage>=(unsigned)pPager->dbSize ){
drhf7c57532003-04-25 13:22:51 +00002555 return SQLITE_OK;
2556 }
drhb7f91642004-10-31 02:22:47 +00002557 if( MEMDB ){
drhac69b052004-05-12 13:30:07 +00002558 pPager->dbSize = nPage;
danielk1977e180dd92007-04-05 17:15:52 +00002559 pager_truncate_cache(pPager);
drhac69b052004-05-12 13:30:07 +00002560 return SQLITE_OK;
2561 }
drh86f8c192007-08-22 00:39:19 +00002562 pagerEnter(pPager);
danielk197776572402004-06-25 02:38:54 +00002563 rc = syncJournal(pPager);
drh86f8c192007-08-22 00:39:19 +00002564 pagerLeave(pPager);
danielk1977369f27e2004-06-15 11:40:04 +00002565 if( rc!=SQLITE_OK ){
2566 return rc;
2567 }
danielk197717221812005-02-15 03:38:05 +00002568
2569 /* Get an exclusive lock on the database before truncating. */
drh86f8c192007-08-22 00:39:19 +00002570 pagerEnter(pPager);
danielk197717221812005-02-15 03:38:05 +00002571 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
drh86f8c192007-08-22 00:39:19 +00002572 pagerLeave(pPager);
danielk197717221812005-02-15 03:38:05 +00002573 if( rc!=SQLITE_OK ){
2574 return rc;
2575 }
2576
drhcb4c40b2004-08-18 19:09:43 +00002577 rc = pager_truncate(pPager, nPage);
drhf7c57532003-04-25 13:22:51 +00002578 return rc;
2579}
2580
2581/*
drhed7c8552001-04-11 14:29:21 +00002582** Shutdown the page cache. Free all memory and close all files.
2583**
2584** If a transaction was in progress when this routine is called, that
2585** transaction is rolled back. All outstanding pages are invalidated
2586** and their memory is freed. Any attempt to use a page associated
2587** with this page cache after this function returns will likely
2588** result in a coredump.
danielk1977aef0bf62005-12-30 16:28:01 +00002589**
2590** This function always succeeds. If a transaction is active an attempt
2591** is made to roll it back. If an error occurs during the rollback
2592** a hot journal may be left in the filesystem but no error is returned
2593** to the caller.
drhed7c8552001-04-11 14:29:21 +00002594*/
danielk19773b8a05f2007-03-19 17:44:26 +00002595int sqlite3PagerClose(Pager *pPager){
drh6f7adc82006-01-11 21:41:20 +00002596#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
drh86f8c192007-08-22 00:39:19 +00002597 if( !MEMDB ){
2598 sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
2599 sqlite3_mutex_enter(mutex);
2600 if( pPager->pPrev ){
2601 pPager->pPrev->pNext = pPager->pNext;
2602 }else{
2603 sqlite3PagerList = pPager->pNext;
2604 }
2605 if( pPager->pNext ){
2606 pPager->pNext->pPrev = pPager->pPrev;
2607 }
2608 sqlite3_mutex_leave(mutex);
2609 }
danielk197713f72992005-12-18 08:51:22 +00002610#endif
2611
drhbafda092007-01-03 23:36:22 +00002612 disable_simulated_io_errors();
drhc2ee76c2007-01-04 14:58:14 +00002613 pPager->errCode = 0;
danielk197741483462007-03-24 16:45:04 +00002614 pPager->exclusiveMode = 0;
drhbafda092007-01-03 23:36:22 +00002615 pager_reset(pPager);
danielk1977e277be02007-03-23 18:12:06 +00002616 pagerUnlockAndRollback(pPager);
drhbafda092007-01-03 23:36:22 +00002617 enable_simulated_io_errors();
drh4f0c5872007-03-26 22:05:01 +00002618 PAGERTRACE2("CLOSE %d\n", PAGERID(pPager));
drhb0603412007-02-28 04:47:26 +00002619 IOTRACE(("CLOSE %p\n", pPager))
danielk1977efaaf572006-01-16 11:29:19 +00002620 assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) );
danielk1977e94ddc92005-03-21 03:53:38 +00002621 if( pPager->journalOpen ){
danielk1977b4b47412007-08-17 15:53:36 +00002622 sqlite3OsClose(pPager->jfd);
danielk1977e94ddc92005-03-21 03:53:38 +00002623 }
drh17435752007-08-16 04:30:38 +00002624 sqlite3_free(pPager->aInJournal);
danielk1977e94ddc92005-03-21 03:53:38 +00002625 if( pPager->stmtOpen ){
danielk1977b4b47412007-08-17 15:53:36 +00002626 sqlite3OsClose(pPager->stfd);
danielk1977e94ddc92005-03-21 03:53:38 +00002627 }
danielk1977b4b47412007-08-17 15:53:36 +00002628 sqlite3OsClose(pPager->fd);
drh0f892532002-05-30 12:27:03 +00002629 /* Temp files are automatically deleted by the OS
2630 ** if( pPager->tempFile ){
drh66560ad2006-01-06 14:32:19 +00002631 ** sqlite3OsDelete(pPager->zFilename);
drh0f892532002-05-30 12:27:03 +00002632 ** }
2633 */
danielk1977aca790a2005-01-13 11:07:52 +00002634
drh17435752007-08-16 04:30:38 +00002635 sqlite3_free(pPager->aHash);
2636 sqlite3_free(pPager->pTmpSpace);
2637 sqlite3_free(pPager);
drhed7c8552001-04-11 14:29:21 +00002638 return SQLITE_OK;
2639}
2640
drh87cc3b32007-05-08 21:45:27 +00002641#if !defined(NDEBUG) || defined(SQLITE_TEST)
drhed7c8552001-04-11 14:29:21 +00002642/*
drh5e00f6c2001-09-13 13:46:56 +00002643** Return the page number for the given page data.
drhed7c8552001-04-11 14:29:21 +00002644*/
danielk19773b8a05f2007-03-19 17:44:26 +00002645Pgno sqlite3PagerPagenumber(DbPage *p){
drhed7c8552001-04-11 14:29:21 +00002646 return p->pgno;
2647}
drh87cc3b32007-05-08 21:45:27 +00002648#endif
drhed7c8552001-04-11 14:29:21 +00002649
2650/*
drhc8629a12004-05-08 20:07:40 +00002651** The page_ref() function increments the reference count for a page.
2652** If the page is currently on the freelist (the reference count is zero) then
drh7e3b0a02001-04-28 16:52:40 +00002653** remove it from the freelist.
drhc8629a12004-05-08 20:07:40 +00002654**
2655** For non-test systems, page_ref() is a macro that calls _page_ref()
2656** online of the reference count is zero. For test systems, page_ref()
2657** is a real function so that we can set breakpoints and trace it.
drh7e3b0a02001-04-28 16:52:40 +00002658*/
drh836faa42003-01-11 13:30:57 +00002659static void _page_ref(PgHdr *pPg){
drh7e3b0a02001-04-28 16:52:40 +00002660 if( pPg->nRef==0 ){
2661 /* The page is currently on the freelist. Remove it. */
danielk19779f61c2f2007-08-27 17:27:49 +00002662 lruListRemove(pPg);
drh7e3b0a02001-04-28 16:52:40 +00002663 pPg->pPager->nRef++;
2664 }
2665 pPg->nRef++;
drhdd793422001-06-28 01:54:48 +00002666 REFINFO(pPg);
drhdf0b3b02001-06-23 11:36:20 +00002667}
danielk1977aca790a2005-01-13 11:07:52 +00002668#ifdef SQLITE_DEBUG
drhc8629a12004-05-08 20:07:40 +00002669 static void page_ref(PgHdr *pPg){
2670 if( pPg->nRef==0 ){
2671 _page_ref(pPg);
2672 }else{
2673 pPg->nRef++;
2674 REFINFO(pPg);
2675 }
2676 }
2677#else
2678# define page_ref(P) ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++)
2679#endif
drhdf0b3b02001-06-23 11:36:20 +00002680
2681/*
2682** Increment the reference count for a page. The input pointer is
2683** a reference to the page data.
2684*/
danielk19773b8a05f2007-03-19 17:44:26 +00002685int sqlite3PagerRef(DbPage *pPg){
drh86f8c192007-08-22 00:39:19 +00002686 pagerEnter(pPg->pPager);
drhdf0b3b02001-06-23 11:36:20 +00002687 page_ref(pPg);
drh86f8c192007-08-22 00:39:19 +00002688 pagerLeave(pPg->pPager);
drh8c42ca92001-06-22 19:15:00 +00002689 return SQLITE_OK;
drh7e3b0a02001-04-28 16:52:40 +00002690}
2691
2692/*
drh34e79ce2004-02-08 06:05:46 +00002693** Sync the journal. In other words, make sure all the pages that have
2694** been written to the journal have actually reached the surface of the
2695** disk. It is not safe to modify the original database file until after
2696** the journal has been synced. If the original database is modified before
2697** the journal is synced and a power failure occurs, the unsynced journal
2698** data would be lost and we would be unable to completely rollback the
2699** database changes. Database corruption would occur.
2700**
2701** This routine also updates the nRec field in the header of the journal.
2702** (See comments on the pager_playback() routine for additional information.)
2703** If the sync mode is FULL, two syncs will occur. First the whole journal
2704** is synced, then the nRec field is updated, then a second sync occurs.
drhb19a2bc2001-09-16 00:13:26 +00002705**
drh34e79ce2004-02-08 06:05:46 +00002706** For temporary databases, we do not care if we are able to rollback
danielk19774cd2cd52007-08-23 14:48:23 +00002707** after a power failure, so no sync occurs.
2708**
2709** If the IOCAP_SEQUENTIAL flag is set for the persistent media on which
2710** the database is stored, then OsSync() is never called on the journal
2711** file. In this case all that is required is to update the nRec field in
2712** the journal header.
drhfa86c412002-02-02 15:01:15 +00002713**
drh34e79ce2004-02-08 06:05:46 +00002714** This routine clears the needSync field of every page current held in
2715** memory.
drh50e5dad2001-09-15 00:57:28 +00002716*/
danielk197776572402004-06-25 02:38:54 +00002717static int syncJournal(Pager *pPager){
drh50e5dad2001-09-15 00:57:28 +00002718 PgHdr *pPg;
2719 int rc = SQLITE_OK;
drh03eb96a2002-11-10 23:32:56 +00002720
danielk19774cd2cd52007-08-23 14:48:23 +00002721
drh03eb96a2002-11-10 23:32:56 +00002722 /* Sync the journal before modifying the main database
2723 ** (assuming there is a journal and it needs to be synced.)
2724 */
danielk197776572402004-06-25 02:38:54 +00002725 if( pPager->needSync ){
drhfa86c412002-02-02 15:01:15 +00002726 if( !pPager->tempFile ){
danielk19774cd2cd52007-08-23 14:48:23 +00002727 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
drhdb48ee02003-01-16 13:42:43 +00002728 assert( pPager->journalOpen );
danielk19774cd2cd52007-08-23 14:48:23 +00002729
drh946966f2004-02-25 02:20:41 +00002730 /* assert( !pPager->noSync ); // noSync might be set if synchronous
2731 ** was turned off after the transaction was started. Ticket #615 */
drh968af522003-02-11 14:55:40 +00002732#ifndef NDEBUG
2733 {
drh34e79ce2004-02-08 06:05:46 +00002734 /* Make sure the pPager->nRec counter we are keeping agrees
2735 ** with the nRec computed from the size of the journal file.
2736 */
drheb206252004-10-01 02:00:31 +00002737 i64 jSz;
drh054889e2005-11-30 03:20:31 +00002738 rc = sqlite3OsFileSize(pPager->jfd, &jSz);
drh968af522003-02-11 14:55:40 +00002739 if( rc!=0 ) return rc;
danielk197776572402004-06-25 02:38:54 +00002740 assert( pPager->journalOff==jSz );
drh968af522003-02-11 14:55:40 +00002741 }
2742#endif
danielk19774cd2cd52007-08-23 14:48:23 +00002743 if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
danielk197776572402004-06-25 02:38:54 +00002744 /* Write the nRec value into the journal file header. If in
2745 ** full-synchronous mode, sync the journal first. This ensures that
2746 ** all data has really hit the disk before nRec is updated to mark
danielk19774cd2cd52007-08-23 14:48:23 +00002747 ** it as a candidate for rollback.
2748 **
2749 ** This is not required if the persistent media supports the
2750 ** SAFE_APPEND property. Because in this case it is not possible
2751 ** for garbage data to be appended to the file, the nRec field
2752 ** is populated with 0xFFFFFFFF when the journal header is written
2753 ** and never needs to be updated.
danielk197776572402004-06-25 02:38:54 +00002754 */
danielk19774cd2cd52007-08-23 14:48:23 +00002755 i64 jrnlOff;
2756 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
drh4f0c5872007-03-26 22:05:01 +00002757 PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager));
drhb0603412007-02-28 04:47:26 +00002758 IOTRACE(("JSYNC %p\n", pPager))
danielk1977f036aef2007-08-20 05:36:51 +00002759 rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags);
drhd8d66e82003-02-12 02:10:15 +00002760 if( rc!=0 ) return rc;
2761 }
danielk197713adf8a2004-06-03 16:08:41 +00002762
danielk197762079062007-08-15 17:08:46 +00002763 jrnlOff = pPager->journalHdr + sizeof(aJournalMagic);
2764 IOTRACE(("JHDR %p %lld %d\n", pPager, jrnlOff, 4));
2765 rc = write32bits(pPager->jfd, jrnlOff, pPager->nRec);
drhb4746b92005-09-09 01:32:06 +00002766 if( rc ) return rc;
drh968af522003-02-11 14:55:40 +00002767 }
danielk19774cd2cd52007-08-23 14:48:23 +00002768 if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
2769 PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager));
2770 IOTRACE(("JSYNC %p\n", pPager))
2771 rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags|
2772 (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
2773 );
2774 if( rc!=0 ) return rc;
2775 }
drhdb48ee02003-01-16 13:42:43 +00002776 pPager->journalStarted = 1;
drhfa86c412002-02-02 15:01:15 +00002777 }
drh50e5dad2001-09-15 00:57:28 +00002778 pPager->needSync = 0;
drh341eae82003-01-21 02:39:36 +00002779
2780 /* Erase the needSync flag from every page.
2781 */
2782 for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
2783 pPg->needSync = 0;
2784 }
danielk19779f61c2f2007-08-27 17:27:49 +00002785 lruListSetFirstSynced(pPager);
drh50e5dad2001-09-15 00:57:28 +00002786 }
drh03eb96a2002-11-10 23:32:56 +00002787
drh341eae82003-01-21 02:39:36 +00002788#ifndef NDEBUG
2789 /* If the Pager.needSync flag is clear then the PgHdr.needSync
2790 ** flag must also be clear for all pages. Verify that this
2791 ** invariant is true.
drh03eb96a2002-11-10 23:32:56 +00002792 */
drh341eae82003-01-21 02:39:36 +00002793 else{
2794 for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
2795 assert( pPg->needSync==0 );
2796 }
danielk19779f61c2f2007-08-27 17:27:49 +00002797 assert( pPager->lru.pFirstSynced==pPager->lru.pFirst );
drh03eb96a2002-11-10 23:32:56 +00002798 }
drh341eae82003-01-21 02:39:36 +00002799#endif
drhdb48ee02003-01-16 13:42:43 +00002800
drh81a20f22001-10-12 17:30:04 +00002801 return rc;
drh50e5dad2001-09-15 00:57:28 +00002802}
2803
2804/*
drhdc3e10b2006-06-15 14:31:06 +00002805** Merge two lists of pages connected by pDirty and in pgno order.
2806** Do not both fixing the pPrevDirty pointers.
2807*/
2808static PgHdr *merge_pagelist(PgHdr *pA, PgHdr *pB){
2809 PgHdr result, *pTail;
2810 pTail = &result;
2811 while( pA && pB ){
2812 if( pA->pgno<pB->pgno ){
2813 pTail->pDirty = pA;
2814 pTail = pA;
2815 pA = pA->pDirty;
2816 }else{
2817 pTail->pDirty = pB;
2818 pTail = pB;
2819 pB = pB->pDirty;
2820 }
2821 }
2822 if( pA ){
2823 pTail->pDirty = pA;
2824 }else if( pB ){
2825 pTail->pDirty = pB;
2826 }else{
2827 pTail->pDirty = 0;
2828 }
2829 return result.pDirty;
2830}
2831
2832/*
2833** Sort the list of pages in accending order by pgno. Pages are
2834** connected by pDirty pointers. The pPrevDirty pointers are
2835** corrupted by this sort.
2836*/
danielk197724168722007-04-02 05:07:47 +00002837#define N_SORT_BUCKET_ALLOC 25
2838#define N_SORT_BUCKET 25
2839#ifdef SQLITE_TEST
2840 int sqlite3_pager_n_sort_bucket = 0;
2841 #undef N_SORT_BUCKET
2842 #define N_SORT_BUCKET \
2843 (sqlite3_pager_n_sort_bucket?sqlite3_pager_n_sort_bucket:N_SORT_BUCKET_ALLOC)
2844#endif
drhdc3e10b2006-06-15 14:31:06 +00002845static PgHdr *sort_pagelist(PgHdr *pIn){
danielk197724168722007-04-02 05:07:47 +00002846 PgHdr *a[N_SORT_BUCKET_ALLOC], *p;
drhdc3e10b2006-06-15 14:31:06 +00002847 int i;
2848 memset(a, 0, sizeof(a));
2849 while( pIn ){
2850 p = pIn;
2851 pIn = p->pDirty;
2852 p->pDirty = 0;
2853 for(i=0; i<N_SORT_BUCKET-1; i++){
2854 if( a[i]==0 ){
2855 a[i] = p;
2856 break;
2857 }else{
2858 p = merge_pagelist(a[i], p);
2859 a[i] = 0;
2860 }
2861 }
2862 if( i==N_SORT_BUCKET-1 ){
danielk197724168722007-04-02 05:07:47 +00002863 /* Coverage: To get here, there need to be 2^(N_SORT_BUCKET)
2864 ** elements in the input list. This is possible, but impractical.
2865 ** Testing this line is the point of global variable
2866 ** sqlite3_pager_n_sort_bucket.
2867 */
drhdc3e10b2006-06-15 14:31:06 +00002868 a[i] = merge_pagelist(a[i], p);
2869 }
2870 }
2871 p = a[0];
2872 for(i=1; i<N_SORT_BUCKET; i++){
2873 p = merge_pagelist(p, a[i]);
2874 }
2875 return p;
2876}
2877
2878/*
drh2554f8b2003-01-22 01:26:44 +00002879** Given a list of pages (connected by the PgHdr.pDirty pointer) write
2880** every one of those pages out to the database file and mark them all
2881** as clean.
2882*/
2883static int pager_write_pagelist(PgHdr *pList){
2884 Pager *pPager;
drh153c62c2007-08-24 03:51:33 +00002885 PgHdr *p;
drh2554f8b2003-01-22 01:26:44 +00002886 int rc;
2887
2888 if( pList==0 ) return SQLITE_OK;
2889 pPager = pList->pPager;
danielk19779eed5052004-06-04 10:38:30 +00002890
2891 /* At this point there may be either a RESERVED or EXCLUSIVE lock on the
2892 ** database file. If there is already an EXCLUSIVE lock, the following
drh054889e2005-11-30 03:20:31 +00002893 ** calls to sqlite3OsLock() are no-ops.
danielk19779eed5052004-06-04 10:38:30 +00002894 **
drha6abd042004-06-09 17:37:22 +00002895 ** Moving the lock from RESERVED to EXCLUSIVE actually involves going
2896 ** through an intermediate state PENDING. A PENDING lock prevents new
2897 ** readers from attaching to the database but is unsufficient for us to
2898 ** write. The idea of a PENDING lock is to prevent new readers from
2899 ** coming in while we wait for existing readers to clear.
danielk19779eed5052004-06-04 10:38:30 +00002900 **
drha6abd042004-06-09 17:37:22 +00002901 ** While the pager is in the RESERVED state, the original database file
2902 ** is unchanged and we can rollback without having to playback the
2903 ** journal into the original database file. Once we transition to
2904 ** EXCLUSIVE, it means the database file has been changed and any rollback
2905 ** will require a journal playback.
danielk19779eed5052004-06-04 10:38:30 +00002906 */
drh684917c2004-10-05 02:41:42 +00002907 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
danielk19779eed5052004-06-04 10:38:30 +00002908 if( rc!=SQLITE_OK ){
2909 return rc;
2910 }
2911
drhdc3e10b2006-06-15 14:31:06 +00002912 pList = sort_pagelist(pList);
drh153c62c2007-08-24 03:51:33 +00002913 for(p=pList; p; p=p->pDirty){
2914 assert( p->dirty );
2915 p->dirty = 0;
2916 }
drh2554f8b2003-01-22 01:26:44 +00002917 while( pList ){
danielk19777a2b1ee2007-08-21 14:27:01 +00002918
2919 /* If the file has not yet been opened, open it now. */
2920 if( !pPager->fd->pMethods ){
2921 assert(pPager->tempFile);
2922 rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->fd, pPager->zFilename);
2923 if( rc ) return rc;
2924 }
2925
danielk1977687566d2004-11-02 12:56:41 +00002926 /* If there are dirty pages in the page cache with page numbers greater
danielk19773b8a05f2007-03-19 17:44:26 +00002927 ** than Pager.dbSize, this means sqlite3PagerTruncate() was called to
danielk1977687566d2004-11-02 12:56:41 +00002928 ** make the file smaller (presumably by auto-vacuum code). Do not write
2929 ** any such pages to the file.
2930 */
2931 if( pList->pgno<=pPager->dbSize ){
danielk197762079062007-08-15 17:08:46 +00002932 i64 offset = (pList->pgno-1)*(i64)pPager->pageSize;
drhc001c582006-03-06 18:23:16 +00002933 char *pData = CODEC2(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);
drh477731b2007-06-16 03:06:27 +00002934 PAGERTRACE4("STORE %d page %d hash(%08x)\n",
2935 PAGERID(pPager), pList->pgno, pager_pagehash(pList));
drh538f5702007-04-13 02:14:30 +00002936 IOTRACE(("PGOUT %p %d\n", pPager, pList->pgno));
danielk197762079062007-08-15 17:08:46 +00002937 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
drh538f5702007-04-13 02:14:30 +00002938 PAGER_INCR(sqlite3_pager_writedb_count);
2939 PAGER_INCR(pPager->nWrite);
drh86a88112007-04-16 15:02:19 +00002940 if( pList->pgno==1 ){
2941 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
2942 }
danielk1977687566d2004-11-02 12:56:41 +00002943 }
2944#ifndef NDEBUG
2945 else{
drh4f0c5872007-03-26 22:05:01 +00002946 PAGERTRACE3("NOSTORE %d page %d\n", PAGERID(pPager), pList->pgno);
danielk1977687566d2004-11-02 12:56:41 +00002947 }
2948#endif
drh2554f8b2003-01-22 01:26:44 +00002949 if( rc ) return rc;
danielk19773c407372005-02-15 02:54:14 +00002950#ifdef SQLITE_CHECK_PAGES
2951 pList->pageHash = pager_pagehash(pList);
2952#endif
drh2554f8b2003-01-22 01:26:44 +00002953 pList = pList->pDirty;
2954 }
2955 return SQLITE_OK;
2956}
2957
2958/*
2959** Collect every dirty page into a dirty list and
2960** return a pointer to the head of that list. All pages are
2961** collected even if they are still in use.
2962*/
2963static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
drh605ad8f2006-05-03 23:34:05 +00002964 return pPager->pDirty;
drh2554f8b2003-01-22 01:26:44 +00002965}
2966
2967/*
drh165ffe92005-03-15 17:09:30 +00002968** Return TRUE if there is a hot journal on the given pager.
2969** A hot journal is one that needs to be played back.
2970**
2971** If the current size of the database file is 0 but a journal file
2972** exists, that is probably an old journal left over from a prior
2973** database with the same name. Just delete the journal.
2974*/
2975static int hasHotJournal(Pager *pPager){
danielk1977b4b47412007-08-17 15:53:36 +00002976 sqlite3_vfs *pVfs = pPager->pVfs;
drh165ffe92005-03-15 17:09:30 +00002977 if( !pPager->useJournal ) return 0;
danielk1977b4b47412007-08-17 15:53:36 +00002978 if( !sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS) ){
drhbb5f18d2007-04-06 18:23:17 +00002979 return 0;
2980 }
2981 if( sqlite3OsCheckReservedLock(pPager->fd) ){
2982 return 0;
2983 }
danielk19773b8a05f2007-03-19 17:44:26 +00002984 if( sqlite3PagerPagecount(pPager)==0 ){
danielk1977fee2d252007-08-18 10:59:19 +00002985 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
drh165ffe92005-03-15 17:09:30 +00002986 return 0;
2987 }else{
2988 return 1;
2989 }
2990}
2991
danielk19775591df52005-12-20 09:19:37 +00002992/*
danielk1977aef0bf62005-12-30 16:28:01 +00002993** Try to find a page in the cache that can be recycled.
2994**
2995** This routine may return SQLITE_IOERR, SQLITE_FULL or SQLITE_OK. It
danielk1977efaaf572006-01-16 11:29:19 +00002996** does not set the pPager->errCode variable.
danielk19775591df52005-12-20 09:19:37 +00002997*/
danielk197713f72992005-12-18 08:51:22 +00002998static int pager_recycle(Pager *pPager, int syncOk, PgHdr **ppPg){
2999 PgHdr *pPg;
3000 *ppPg = 0;
3001
danielk1977c551edc2007-04-05 13:12:13 +00003002 assert(!MEMDB);
3003
danielk197713f72992005-12-18 08:51:22 +00003004 /* Find a page to recycle. Try to locate a page that does not
3005 ** require us to do an fsync() on the journal.
3006 */
danielk19779f61c2f2007-08-27 17:27:49 +00003007 pPg = pPager->lru.pFirstSynced;
danielk197713f72992005-12-18 08:51:22 +00003008
3009 /* If we could not find a page that does not require an fsync()
3010 ** on the journal file then fsync the journal file. This is a
3011 ** very slow operation, so we work hard to avoid it. But sometimes
3012 ** it can't be helped.
3013 */
danielk19779f61c2f2007-08-27 17:27:49 +00003014 if( pPg==0 && pPager->lru.pFirst && syncOk && !MEMDB){
danielk19774cd2cd52007-08-23 14:48:23 +00003015 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
danielk197713f72992005-12-18 08:51:22 +00003016 int rc = syncJournal(pPager);
3017 if( rc!=0 ){
danielk1977aef0bf62005-12-30 16:28:01 +00003018 return rc;
danielk197713f72992005-12-18 08:51:22 +00003019 }
danielk19774cd2cd52007-08-23 14:48:23 +00003020 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
danielk197713f72992005-12-18 08:51:22 +00003021 /* If in full-sync mode, write a new journal header into the
3022 ** journal file. This is done to avoid ever modifying a journal
3023 ** header that is involved in the rollback of pages that have
3024 ** already been written to the database (in case the header is
3025 ** trashed when the nRec field is updated).
3026 */
3027 pPager->nRec = 0;
3028 assert( pPager->journalOff > 0 );
danielk19774099f6e2007-03-19 11:25:20 +00003029 assert( pPager->doNotSync==0 );
danielk197713f72992005-12-18 08:51:22 +00003030 rc = writeJournalHdr(pPager);
3031 if( rc!=0 ){
danielk1977aef0bf62005-12-30 16:28:01 +00003032 return rc;
danielk197713f72992005-12-18 08:51:22 +00003033 }
3034 }
danielk19779f61c2f2007-08-27 17:27:49 +00003035 pPg = pPager->lru.pFirst;
danielk197713f72992005-12-18 08:51:22 +00003036 }
3037 if( pPg==0 ){
3038 return SQLITE_OK;
3039 }
3040
3041 assert( pPg->nRef==0 );
3042
3043 /* Write the page to the database file if it is dirty.
3044 */
3045 if( pPg->dirty ){
3046 int rc;
3047 assert( pPg->needSync==0 );
drh605ad8f2006-05-03 23:34:05 +00003048 makeClean(pPg);
3049 pPg->dirty = 1;
danielk197713f72992005-12-18 08:51:22 +00003050 pPg->pDirty = 0;
3051 rc = pager_write_pagelist( pPg );
drh153c62c2007-08-24 03:51:33 +00003052 pPg->dirty = 0;
danielk197713f72992005-12-18 08:51:22 +00003053 if( rc!=SQLITE_OK ){
danielk1977aef0bf62005-12-30 16:28:01 +00003054 return rc;
danielk197713f72992005-12-18 08:51:22 +00003055 }
3056 }
3057 assert( pPg->dirty==0 );
3058
3059 /* If the page we are recycling is marked as alwaysRollback, then
3060 ** set the global alwaysRollback flag, thus disabling the
drh80e35f42007-03-30 14:06:34 +00003061 ** sqlite3PagerDontRollback() optimization for the rest of this transaction.
danielk197713f72992005-12-18 08:51:22 +00003062 ** It is necessary to do this because the page marked alwaysRollback
3063 ** might be reloaded at a later time but at that point we won't remember
3064 ** that is was marked alwaysRollback. This means that all pages must
3065 ** be marked as alwaysRollback from here on out.
3066 */
3067 if( pPg->alwaysRollback ){
drh602c2372007-03-01 00:29:13 +00003068 IOTRACE(("ALWAYS_ROLLBACK %p\n", pPager))
danielk197713f72992005-12-18 08:51:22 +00003069 pPager->alwaysRollback = 1;
3070 }
3071
3072 /* Unlink the old page from the free list and the hash table
3073 */
3074 unlinkPage(pPg);
drh7c4ac0c2007-04-05 11:25:58 +00003075 assert( pPg->pgno==0 );
danielk197713f72992005-12-18 08:51:22 +00003076
3077 *ppPg = pPg;
3078 return SQLITE_OK;
3079}
3080
drh86f8c192007-08-22 00:39:19 +00003081#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
danielk197713f72992005-12-18 08:51:22 +00003082/*
3083** This function is called to free superfluous dynamically allocated memory
3084** held by the pager system. Memory in use by any SQLite pager allocated
drh17435752007-08-16 04:30:38 +00003085** by the current thread may be sqlite3_free()ed.
danielk197713f72992005-12-18 08:51:22 +00003086**
3087** nReq is the number of bytes of memory required. Once this much has
drh86f8c192007-08-22 00:39:19 +00003088** been released, the function returns. The return value is the total number
danielk197713f72992005-12-18 08:51:22 +00003089** of bytes of memory released.
3090*/
danielk19773b8a05f2007-03-19 17:44:26 +00003091int sqlite3PagerReleaseMemory(int nReq){
drh86f8c192007-08-22 00:39:19 +00003092 int nReleased = 0; /* Bytes of memory released so far */
3093 sqlite3_mutex *mutex; /* The MEM2 mutex */
3094 Pager *pPager; /* For looping over pagers */
danielk19779f61c2f2007-08-27 17:27:49 +00003095 int rc = SQLITE_OK;
danielk197713f72992005-12-18 08:51:22 +00003096
drh86f8c192007-08-22 00:39:19 +00003097 /* Acquire the memory-management mutex
danielk1977441b09a2006-01-05 13:48:29 +00003098 */
drh86f8c192007-08-22 00:39:19 +00003099 mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
3100 sqlite3_mutex_enter(mutex);
3101
3102 /* Signal all database connections that memory management wants
3103 ** to have access to the pagers.
3104 */
3105 for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){
3106 pPager->iInUseMM = 1;
danielk1977441b09a2006-01-05 13:48:29 +00003107 }
3108
danielk19779f61c2f2007-08-27 17:27:49 +00003109 while( rc==SQLITE_OK && (nReq<0 || nReleased<nReq) ){
3110 PgHdr *pPg;
3111 PgHdr *pRecycled;
3112
3113 /* Try to find a page to recycle that does not require a sync(). If
3114 ** this is not possible, find one that does require a sync().
3115 */
3116 sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
3117 pPg = sqlite3LruPageList.pFirstSynced;
3118 while( pPg && (pPg->needSync || pPg->pPager->iInUseDB) ){
3119 pPg = pPg->gfree.pNext;
3120 }
3121 if( !pPg ){
3122 pPg = sqlite3LruPageList.pFirst;
3123 while( pPg && pPg->pPager->iInUseDB ){
3124 pPg = pPg->gfree.pNext;
3125 }
3126 }
3127 sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
danielk197713f72992005-12-18 08:51:22 +00003128
danielk197784f786f2007-08-28 08:00:17 +00003129 /* If pPg==0, then the block above has failed to find a page to
3130 ** recycle. In this case return early - no further memory will
3131 ** be released.
3132 */
danielk19779f61c2f2007-08-27 17:27:49 +00003133 if( !pPg ) break;
danielk197713f72992005-12-18 08:51:22 +00003134
danielk19779f61c2f2007-08-27 17:27:49 +00003135 pPager = pPg->pPager;
3136 assert(!pPg->needSync || pPg==pPager->lru.pFirst);
3137 assert(pPg->needSync || pPg==pPager->lru.pFirstSynced);
3138
3139 rc = pager_recycle(pPager, 1, &pRecycled);
3140 assert(pRecycled==pPg || rc!=SQLITE_OK);
3141 if( rc==SQLITE_OK ){
3142 /* We've found a page to free. At this point the page has been
3143 ** removed from the page hash-table, free-list and synced-list
3144 ** (pFirstSynced). It is still in the all pages (pAll) list.
3145 ** Remove it from this list before freeing.
3146 **
3147 ** Todo: Check the Pager.pStmt list to make sure this is Ok. It
3148 ** probably is though.
danielk197713f72992005-12-18 08:51:22 +00003149 */
danielk19779f61c2f2007-08-27 17:27:49 +00003150 PgHdr *pTmp;
3151 assert( pPg );
3152 if( pPg==pPager->pAll ){
3153 pPager->pAll = pPg->pNextAll;
3154 }else{
3155 for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){}
3156 pTmp->pNextAll = pPg->pNextAll;
danielk197713f72992005-12-18 08:51:22 +00003157 }
danielk19779f61c2f2007-08-27 17:27:49 +00003158 nReleased += (
3159 sizeof(*pPg) + pPager->pageSize
3160 + sizeof(u32) + pPager->nExtra
3161 + MEMDB*sizeof(PgHistory)
3162 );
3163 IOTRACE(("PGFREE %p %d *\n", pPager, pPg->pgno));
3164 PAGER_INCR(sqlite3_pager_pgfree_count);
3165 sqlite3_free(pPg);
danielk197784f786f2007-08-28 08:00:17 +00003166 pPager->nPage--;
danielk19779f61c2f2007-08-27 17:27:49 +00003167 }else{
3168 /* An error occured whilst writing to the database file or
3169 ** journal in pager_recycle(). The error is not returned to the
3170 ** caller of this function. Instead, set the Pager.errCode variable.
3171 ** The error will be returned to the user (or users, in the case
3172 ** of a shared pager cache) of the pager for which the error occured.
3173 */
3174 assert(
3175 (rc&0xff)==SQLITE_IOERR ||
3176 rc==SQLITE_FULL ||
3177 rc==SQLITE_BUSY
3178 );
3179 assert( pPager->state>=PAGER_RESERVED );
3180 pager_error(pPager, rc);
danielk197713f72992005-12-18 08:51:22 +00003181 }
3182 }
danielk1977aef0bf62005-12-30 16:28:01 +00003183
drh86f8c192007-08-22 00:39:19 +00003184 /* Clear the memory management flags and release the mutex
3185 */
3186 for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){
3187 pPager->iInUseMM = 0;
3188 }
3189 sqlite3_mutex_leave(mutex);
3190
3191 /* Return the number of bytes released
3192 */
danielk197713f72992005-12-18 08:51:22 +00003193 return nReleased;
3194}
drh86f8c192007-08-22 00:39:19 +00003195#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
danielk197713f72992005-12-18 08:51:22 +00003196
drh165ffe92005-03-15 17:09:30 +00003197/*
danielk1977e180dd92007-04-05 17:15:52 +00003198** Read the content of page pPg out of the database file.
3199*/
3200static int readDbPage(Pager *pPager, PgHdr *pPg, Pgno pgno){
3201 int rc;
danielk197762079062007-08-15 17:08:46 +00003202 i64 offset;
danielk1977e180dd92007-04-05 17:15:52 +00003203 assert( MEMDB==0 );
danielk19777a2b1ee2007-08-21 14:27:01 +00003204 assert(pPager->fd->pMethods||pPager->tempFile);
3205 if( !pPager->fd->pMethods ){
3206 return SQLITE_IOERR_SHORT_READ;
3207 }
danielk197762079062007-08-15 17:08:46 +00003208 offset = (pgno-1)*(i64)pPager->pageSize;
3209 rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg), pPager->pageSize, offset);
drh538f5702007-04-13 02:14:30 +00003210 PAGER_INCR(sqlite3_pager_readdb_count);
3211 PAGER_INCR(pPager->nRead);
3212 IOTRACE(("PGIN %p %d\n", pPager, pgno));
drh86a88112007-04-16 15:02:19 +00003213 if( pgno==1 ){
3214 memcpy(&pPager->dbFileVers, &((u8*)PGHDR_TO_DATA(pPg))[24],
3215 sizeof(pPager->dbFileVers));
3216 }
danielk1977e180dd92007-04-05 17:15:52 +00003217 CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
drh477731b2007-06-16 03:06:27 +00003218 PAGERTRACE4("FETCH %d page %d hash(%08x)\n",
3219 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg));
danielk1977e180dd92007-04-05 17:15:52 +00003220 return rc;
3221}
3222
3223
3224/*
danielk1977e277be02007-03-23 18:12:06 +00003225** This function is called to obtain the shared lock required before
3226** data may be read from the pager cache. If the shared lock has already
3227** been obtained, this function is a no-op.
danielk1977393f0682007-03-31 10:00:48 +00003228**
3229** Immediately after obtaining the shared lock (if required), this function
3230** checks for a hot-journal file. If one is found, an emergency rollback
3231** is performed immediately.
danielk1977e277be02007-03-23 18:12:06 +00003232*/
3233static int pagerSharedLock(Pager *pPager){
3234 int rc = SQLITE_OK;
3235
3236 if( pPager->state==PAGER_UNLOCK ){
danielk1977b4b47412007-08-17 15:53:36 +00003237 sqlite3_vfs *pVfs = pPager->pVfs;
danielk1977e277be02007-03-23 18:12:06 +00003238 if( !MEMDB ){
3239 assert( pPager->nRef==0 );
3240 if( !pPager->noReadlock ){
3241 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
3242 if( rc!=SQLITE_OK ){
3243 return pager_error(pPager, rc);
3244 }
3245 assert( pPager->state>=SHARED_LOCK );
3246 }
3247
3248 /* If a journal file exists, and there is no RESERVED lock on the
3249 ** database file, then it either needs to be played back or deleted.
3250 */
3251 if( hasHotJournal(pPager) ){
3252 /* Get an EXCLUSIVE lock on the database file. At this point it is
3253 ** important that a RESERVED lock is not obtained on the way to the
3254 ** EXCLUSIVE lock. If it were, another process might open the
3255 ** database file, detect the RESERVED lock, and conclude that the
3256 ** database is safe to read while this process is still rolling it
3257 ** back.
3258 **
3259 ** Because the intermediate RESERVED lock is not requested, the
3260 ** second process will get to this point in the code and fail to
3261 ** obtain it's own EXCLUSIVE lock on the database file.
3262 */
3263 rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
3264 if( rc!=SQLITE_OK ){
3265 pager_unlock(pPager);
3266 return pager_error(pPager, rc);
3267 }
3268 pPager->state = PAGER_EXCLUSIVE;
3269
3270 /* Open the journal for reading only. Return SQLITE_BUSY if
3271 ** we are unable to open the journal file.
3272 **
3273 ** The journal file does not need to be locked itself. The
3274 ** journal file is never open unless the main database file holds
3275 ** a write lock, so there is never any chance of two or more
3276 ** processes opening the journal at the same time.
danielk1977979f38e2007-03-27 16:19:51 +00003277 **
drhfd131da2007-08-07 17:13:03 +00003278 ** Open the journal for read/write access. This is because in
3279 ** exclusive-access mode the file descriptor will be kept open and
danielk1977979f38e2007-03-27 16:19:51 +00003280 ** possibly used for a transaction later on. On some systems, the
3281 ** OsTruncate() call used in exclusive-access mode also requires
3282 ** a read/write file handle.
danielk1977e277be02007-03-23 18:12:06 +00003283 */
danielk1977979f38e2007-03-27 16:19:51 +00003284 rc = SQLITE_BUSY;
danielk1977b4b47412007-08-17 15:53:36 +00003285 if( sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS) ){
3286 int fout = 0;
danielk1977fee2d252007-08-18 10:59:19 +00003287 int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
danielk19777152de82007-03-29 17:28:14 +00003288 assert( !pPager->tempFile );
danielk1977a1644fd2007-08-29 12:31:25 +00003289 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, &fout);
danielk1977b4b47412007-08-17 15:53:36 +00003290 assert( rc!=SQLITE_OK || pPager->jfd->pMethods );
3291 if( fout&SQLITE_OPEN_READONLY ){
danielk1977979f38e2007-03-27 16:19:51 +00003292 rc = SQLITE_BUSY;
danielk1977b4b47412007-08-17 15:53:36 +00003293 sqlite3OsClose(pPager->jfd);
danielk1977979f38e2007-03-27 16:19:51 +00003294 }
3295 }
danielk1977e277be02007-03-23 18:12:06 +00003296 if( rc!=SQLITE_OK ){
3297 pager_unlock(pPager);
danielk1977a1644fd2007-08-29 12:31:25 +00003298 return (rc==SQLITE_NOMEM?rc:SQLITE_BUSY);
danielk1977e277be02007-03-23 18:12:06 +00003299 }
3300 pPager->journalOpen = 1;
3301 pPager->journalStarted = 0;
3302 pPager->journalOff = 0;
3303 pPager->setMaster = 0;
3304 pPager->journalHdr = 0;
3305
3306 /* Playback and delete the journal. Drop the database write
3307 ** lock and reacquire the read lock.
3308 */
3309 rc = pager_playback(pPager, 1);
3310 if( rc!=SQLITE_OK ){
3311 return pager_error(pPager, rc);
3312 }
danielk1977c5859712007-03-26 12:26:27 +00003313 assert(pPager->state==PAGER_SHARED ||
3314 (pPager->exclusiveMode && pPager->state>PAGER_SHARED)
3315 );
danielk1977e277be02007-03-23 18:12:06 +00003316 }
3317
3318 if( pPager->pAll ){
danielk197724168722007-04-02 05:07:47 +00003319 /* The shared-lock has just been acquired on the database file
3320 ** and there are already pages in the cache (from a previous
drh86a88112007-04-16 15:02:19 +00003321 ** read or write transaction). Check to see if the database
3322 ** has been modified. If the database has changed, flush the
3323 ** cache.
3324 **
3325 ** Database changes is detected by looking at 15 bytes beginning
3326 ** at offset 24 into the file. The first 4 of these 16 bytes are
3327 ** a 32-bit counter that is incremented with each change. The
3328 ** other bytes change randomly with each file change when
3329 ** a codec is in use.
3330 **
3331 ** There is a vanishingly small chance that a change will not be
drh6fa51032007-05-09 20:35:31 +00003332 ** detected. The chance of an undetected change is so small that
drh86a88112007-04-16 15:02:19 +00003333 ** it can be neglected.
danielk197724168722007-04-02 05:07:47 +00003334 */
drh86a88112007-04-16 15:02:19 +00003335 char dbFileVers[sizeof(pPager->dbFileVers)];
danielk1977e180dd92007-04-05 17:15:52 +00003336 sqlite3PagerPagecount(pPager);
danielk197724168722007-04-02 05:07:47 +00003337
danielk1977e180dd92007-04-05 17:15:52 +00003338 if( pPager->errCode ){
3339 return pPager->errCode;
danielk1977e277be02007-03-23 18:12:06 +00003340 }
3341
danielk1977e180dd92007-04-05 17:15:52 +00003342 if( pPager->dbSize>0 ){
drhae5e4452007-05-03 17:18:36 +00003343 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
danielk197762079062007-08-15 17:08:46 +00003344 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
danielk1977e180dd92007-04-05 17:15:52 +00003345 if( rc!=SQLITE_OK ){
3346 return rc;
3347 }
drh86a88112007-04-16 15:02:19 +00003348 }else{
3349 memset(dbFileVers, 0, sizeof(dbFileVers));
danielk1977e180dd92007-04-05 17:15:52 +00003350 }
3351
drh86a88112007-04-16 15:02:19 +00003352 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
danielk1977e180dd92007-04-05 17:15:52 +00003353 pager_reset(pPager);
danielk1977e277be02007-03-23 18:12:06 +00003354 }
3355 }
3356 }
danielk1977c5859712007-03-26 12:26:27 +00003357 assert( pPager->exclusiveMode || pPager->state<=PAGER_SHARED );
3358 if( pPager->state==PAGER_UNLOCK ){
3359 pPager->state = PAGER_SHARED;
3360 }
danielk1977e277be02007-03-23 18:12:06 +00003361 }
3362
3363 return rc;
3364}
3365
3366/*
danielk1977e180dd92007-04-05 17:15:52 +00003367** Allocate a PgHdr object. Either create a new one or reuse
3368** an existing one that is not otherwise in use.
3369**
3370** A new PgHdr structure is created if any of the following are
3371** true:
3372**
3373** (1) We have not exceeded our maximum allocated cache size
3374** as set by the "PRAGMA cache_size" command.
3375**
3376** (2) There are no unused PgHdr objects available at this time.
3377**
3378** (3) This is an in-memory database.
3379**
3380** (4) There are no PgHdr objects that do not require a journal
3381** file sync and a sync of the journal file is currently
3382** prohibited.
3383**
3384** Otherwise, reuse an existing PgHdr. In other words, reuse an
3385** existing PgHdr if all of the following are true:
3386**
3387** (1) We have reached or exceeded the maximum cache size
3388** allowed by "PRAGMA cache_size".
3389**
3390** (2) There is a PgHdr available with PgHdr->nRef==0
3391**
3392** (3) We are not in an in-memory database
3393**
3394** (4) Either there is an available PgHdr that does not need
3395** to be synced to disk or else disk syncing is currently
3396** allowed.
danielk197724168722007-04-02 05:07:47 +00003397*/
3398static int pagerAllocatePage(Pager *pPager, PgHdr **ppPg){
3399 int rc = SQLITE_OK;
3400 PgHdr *pPg;
3401
danielk1977e180dd92007-04-05 17:15:52 +00003402 /* Create a new PgHdr if any of the four conditions defined
danielk19772a6bdf62007-08-20 16:07:00 +00003403 ** above are met: */
danielk1977e180dd92007-04-05 17:15:52 +00003404 if( pPager->nPage<pPager->mxPage
danielk19779f61c2f2007-08-27 17:27:49 +00003405 || pPager->lru.pFirst==0
danielk1977e180dd92007-04-05 17:15:52 +00003406 || MEMDB
danielk19779f61c2f2007-08-27 17:27:49 +00003407 || (pPager->lru.pFirstSynced==0 && pPager->doNotSync)
danielk1977e180dd92007-04-05 17:15:52 +00003408 ){
danielk197724168722007-04-02 05:07:47 +00003409 if( pPager->nPage>=pPager->nHash ){
3410 pager_resize_hash_table(pPager,
3411 pPager->nHash<256 ? 256 : pPager->nHash*2);
3412 if( pPager->nHash==0 ){
3413 rc = SQLITE_NOMEM;
3414 goto pager_allocate_out;
3415 }
3416 }
drhed138fb2007-08-22 22:04:37 +00003417 pagerLeave(pPager);
drh17435752007-08-16 04:30:38 +00003418 pPg = sqlite3_malloc( sizeof(*pPg) + pPager->pageSize
danielk197724168722007-04-02 05:07:47 +00003419 + sizeof(u32) + pPager->nExtra
3420 + MEMDB*sizeof(PgHistory) );
drhed138fb2007-08-22 22:04:37 +00003421 pagerEnter(pPager);
danielk197724168722007-04-02 05:07:47 +00003422 if( pPg==0 ){
3423 rc = SQLITE_NOMEM;
3424 goto pager_allocate_out;
3425 }
3426 memset(pPg, 0, sizeof(*pPg));
3427 if( MEMDB ){
3428 memset(PGHDR_TO_HIST(pPg, pPager), 0, sizeof(PgHistory));
3429 }
3430 pPg->pPager = pPager;
3431 pPg->pNextAll = pPager->pAll;
3432 pPager->pAll = pPg;
3433 pPager->nPage++;
danielk197724168722007-04-02 05:07:47 +00003434 }else{
3435 /* Recycle an existing page with a zero ref-count. */
3436 rc = pager_recycle(pPager, 1, &pPg);
danielk1977e965ac72007-06-13 15:22:28 +00003437 if( rc==SQLITE_BUSY ){
3438 rc = SQLITE_IOERR_BLOCKED;
3439 }
danielk197724168722007-04-02 05:07:47 +00003440 if( rc!=SQLITE_OK ){
3441 goto pager_allocate_out;
3442 }
3443 assert( pPager->state>=SHARED_LOCK );
3444 assert(pPg);
3445 }
3446 *ppPg = pPg;
3447
3448pager_allocate_out:
3449 return rc;
3450}
3451
3452/*
drhd33d5a82007-04-26 12:11:28 +00003453** Make sure we have the content for a page. If the page was
3454** previously acquired with noContent==1, then the content was
3455** just initialized to zeros instead of being read from disk.
3456** But now we need the real data off of disk. So make sure we
3457** have it. Read it in if we do not have it already.
3458*/
3459static int pager_get_content(PgHdr *pPg){
3460 if( pPg->needRead ){
3461 int rc = readDbPage(pPg->pPager, pPg, pPg->pgno);
3462 if( rc==SQLITE_OK ){
3463 pPg->needRead = 0;
3464 }else{
3465 return rc;
3466 }
3467 }
3468 return SQLITE_OK;
3469}
3470
3471/*
drhd9b02572001-04-15 00:37:09 +00003472** Acquire a page.
3473**
drh58a11682001-11-10 13:51:08 +00003474** A read lock on the disk file is obtained when the first page is acquired.
drh5e00f6c2001-09-13 13:46:56 +00003475** This read lock is dropped when the last page is released.
drhd9b02572001-04-15 00:37:09 +00003476**
drhd33d5a82007-04-26 12:11:28 +00003477** This routine works for any page number greater than 0. If the database
drh306dc212001-05-21 13:45:10 +00003478** file is smaller than the requested page, then no actual disk
3479** read occurs and the memory image of the page is initialized to
3480** all zeros. The extra data appended to a page is always initialized
3481** to zeros the first time a page is loaded into memory.
3482**
drhd9b02572001-04-15 00:37:09 +00003483** The acquisition might fail for several reasons. In all cases,
3484** an appropriate error code is returned and *ppPage is set to NULL.
drh7e3b0a02001-04-28 16:52:40 +00003485**
drhd33d5a82007-04-26 12:11:28 +00003486** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
drh7e3b0a02001-04-28 16:52:40 +00003487** to find a page in the in-memory cache first. If the page is not already
drhd33d5a82007-04-26 12:11:28 +00003488** in memory, this routine goes to disk to read it in whereas Lookup()
drh7e3b0a02001-04-28 16:52:40 +00003489** just returns 0. This routine acquires a read-lock the first time it
3490** has to go to disk, and could also playback an old journal if necessary.
drhd33d5a82007-04-26 12:11:28 +00003491** Since Lookup() never goes to disk, it never has to deal with locks
drh7e3b0a02001-04-28 16:52:40 +00003492** or journal files.
drh0787db62007-03-04 13:15:27 +00003493**
drh538f5702007-04-13 02:14:30 +00003494** If noContent is false, the page contents are actually read from disk.
3495** If noContent is true, it means that we do not care about the contents
3496** of the page at this time, so do not do a disk read. Just fill in the
3497** page content with zeros. But mark the fact that we have not read the
3498** content by setting the PgHdr.needRead flag. Later on, if
drhd33d5a82007-04-26 12:11:28 +00003499** sqlite3PagerWrite() is called on this page or if this routine is
3500** called again with noContent==0, that means that the content is needed
3501** and the disk read should occur at that point.
drhed7c8552001-04-11 14:29:21 +00003502*/
drh86f8c192007-08-22 00:39:19 +00003503static int pagerAcquire(
drh538f5702007-04-13 02:14:30 +00003504 Pager *pPager, /* The pager open on the database file */
3505 Pgno pgno, /* Page number to fetch */
3506 DbPage **ppPage, /* Write a pointer to the page here */
3507 int noContent /* Do not bother reading content from disk if true */
3508){
drhed7c8552001-04-11 14:29:21 +00003509 PgHdr *pPg;
drh165ffe92005-03-15 17:09:30 +00003510 int rc;
drhed7c8552001-04-11 14:29:21 +00003511
danielk1977e277be02007-03-23 18:12:06 +00003512 assert( pPager->state==PAGER_UNLOCK || pPager->nRef>0 || pgno==1 );
3513
danielk197726836652005-01-17 01:33:13 +00003514 /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
3515 ** number greater than this, or zero, is requested.
3516 */
drh267cb322005-09-16 17:16:52 +00003517 if( pgno>PAGER_MAX_PGNO || pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
drh49285702005-09-17 15:20:26 +00003518 return SQLITE_CORRUPT_BKPT;
danielk197726836652005-01-17 01:33:13 +00003519 }
3520
drhd9b02572001-04-15 00:37:09 +00003521 /* Make sure we have not hit any critical errors.
3522 */
drh836faa42003-01-11 13:30:57 +00003523 assert( pPager!=0 );
drh2e6d11b2003-04-25 15:37:57 +00003524 *ppPage = 0;
danielk1977efaaf572006-01-16 11:29:19 +00003525 if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
3526 return pPager->errCode;
drhd9b02572001-04-15 00:37:09 +00003527 }
3528
danielk197713adf8a2004-06-03 16:08:41 +00003529 /* If this is the first page accessed, then get a SHARED lock
danielk1977334cdb62007-03-26 08:05:12 +00003530 ** on the database file. pagerSharedLock() is a no-op if
3531 ** a database lock is already held.
drhed7c8552001-04-11 14:29:21 +00003532 */
danielk1977e277be02007-03-23 18:12:06 +00003533 rc = pagerSharedLock(pPager);
3534 if( rc!=SQLITE_OK ){
3535 return rc;
drhed7c8552001-04-11 14:29:21 +00003536 }
danielk1977e277be02007-03-23 18:12:06 +00003537 assert( pPager->state!=PAGER_UNLOCK );
3538
3539 pPg = pager_lookup(pPager, pgno);
drhed7c8552001-04-11 14:29:21 +00003540 if( pPg==0 ){
drhd9b02572001-04-15 00:37:09 +00003541 /* The requested page is not in the page cache. */
danielk1977979f38e2007-03-27 16:19:51 +00003542 int nMax;
drhed7c8552001-04-11 14:29:21 +00003543 int h;
drh538f5702007-04-13 02:14:30 +00003544 PAGER_INCR(pPager->nMiss);
danielk197724168722007-04-02 05:07:47 +00003545 rc = pagerAllocatePage(pPager, &pPg);
3546 if( rc!=SQLITE_OK ){
3547 return rc;
drhed7c8552001-04-11 14:29:21 +00003548 }
danielk197724168722007-04-02 05:07:47 +00003549
drhed7c8552001-04-11 14:29:21 +00003550 pPg->pgno = pgno;
danielk1977f35843b2007-04-07 15:03:17 +00003551 assert( !MEMDB || pgno>pPager->stmtSize );
drh1ab43002002-01-14 09:28:19 +00003552 if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
danielk19771e536952007-08-16 10:09:01 +00003553#if 0
danielk19774adee202004-05-08 08:23:19 +00003554 sqlite3CheckMemory(pPager->aInJournal, pgno/8);
danielk19771e536952007-08-16 10:09:01 +00003555#endif
drhdb48ee02003-01-16 13:42:43 +00003556 assert( pPager->journalOpen );
drh6019e162001-07-02 17:51:45 +00003557 pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
drhdb48ee02003-01-16 13:42:43 +00003558 pPg->needSync = 0;
drh6019e162001-07-02 17:51:45 +00003559 }else{
3560 pPg->inJournal = 0;
drhdb48ee02003-01-16 13:42:43 +00003561 pPg->needSync = 0;
drh6019e162001-07-02 17:51:45 +00003562 }
danielk1977f35843b2007-04-07 15:03:17 +00003563
drh605ad8f2006-05-03 23:34:05 +00003564 makeClean(pPg);
drhed7c8552001-04-11 14:29:21 +00003565 pPg->nRef = 1;
drhdd793422001-06-28 01:54:48 +00003566 REFINFO(pPg);
danielk197775bab7d2006-01-23 13:09:45 +00003567
drhd9b02572001-04-15 00:37:09 +00003568 pPager->nRef++;
drh2e6d11b2003-04-25 15:37:57 +00003569 if( pPager->nExtra>0 ){
drh90f5ecb2004-07-22 01:19:35 +00003570 memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra);
drh2e6d11b2003-04-25 15:37:57 +00003571 }
danielk1977979f38e2007-03-27 16:19:51 +00003572 nMax = sqlite3PagerPagecount(pPager);
danielk1977efaaf572006-01-16 11:29:19 +00003573 if( pPager->errCode ){
danielk19773b8a05f2007-03-19 17:44:26 +00003574 sqlite3PagerUnref(pPg);
danielk1977efaaf572006-01-16 11:29:19 +00003575 rc = pPager->errCode;
drh2e6d11b2003-04-25 15:37:57 +00003576 return rc;
3577 }
danielk197775bab7d2006-01-23 13:09:45 +00003578
3579 /* Populate the page with data, either by reading from the database
3580 ** file, or by setting the entire page to zero.
3581 */
drhd215acf2007-04-13 04:01:58 +00003582 if( nMax<(int)pgno || MEMDB || (noContent && !pPager->alwaysRollback) ){
drhf8e632b2007-05-08 14:51:36 +00003583 if( pgno>pPager->mxPgno ){
danielk1977de3bea72007-05-09 15:56:39 +00003584 sqlite3PagerUnref(pPg);
drhf8e632b2007-05-08 14:51:36 +00003585 return SQLITE_FULL;
3586 }
drh90f5ecb2004-07-22 01:19:35 +00003587 memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
drhd215acf2007-04-13 04:01:58 +00003588 pPg->needRead = noContent && !pPager->alwaysRollback;
drh538f5702007-04-13 02:14:30 +00003589 IOTRACE(("ZERO %p %d\n", pPager, pgno));
drh306dc212001-05-21 13:45:10 +00003590 }else{
danielk1977e180dd92007-04-05 17:15:52 +00003591 rc = readDbPage(pPager, pPg, pgno);
drh551b7732006-11-06 21:20:25 +00003592 if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
3593 pPg->pgno = 0;
danielk19773b8a05f2007-03-19 17:44:26 +00003594 sqlite3PagerUnref(pPg);
drh551b7732006-11-06 21:20:25 +00003595 return rc;
drh81a20f22001-10-12 17:30:04 +00003596 }
danielk1977b4626a32007-04-28 15:47:43 +00003597 pPg->needRead = 0;
drh306dc212001-05-21 13:45:10 +00003598 }
danielk197775bab7d2006-01-23 13:09:45 +00003599
3600 /* Link the page into the page hash table */
drh8ca0c722006-05-07 17:49:38 +00003601 h = pgno & (pPager->nHash-1);
drh3765df42006-06-28 18:18:09 +00003602 assert( pgno!=0 );
danielk197775bab7d2006-01-23 13:09:45 +00003603 pPg->pNextHash = pPager->aHash[h];
3604 pPager->aHash[h] = pPg;
3605 if( pPg->pNextHash ){
3606 assert( pPg->pNextHash->pPrevHash==0 );
3607 pPg->pNextHash->pPrevHash = pPg;
3608 }
3609
danielk19773c407372005-02-15 02:54:14 +00003610#ifdef SQLITE_CHECK_PAGES
3611 pPg->pageHash = pager_pagehash(pPg);
3612#endif
drhed7c8552001-04-11 14:29:21 +00003613 }else{
drhd9b02572001-04-15 00:37:09 +00003614 /* The requested page is in the page cache. */
danielk1977e277be02007-03-23 18:12:06 +00003615 assert(pPager->nRef>0 || pgno==1);
drh538f5702007-04-13 02:14:30 +00003616 PAGER_INCR(pPager->nHit);
drhd33d5a82007-04-26 12:11:28 +00003617 if( !noContent ){
3618 rc = pager_get_content(pPg);
3619 if( rc ){
3620 return rc;
3621 }
3622 }
drhdf0b3b02001-06-23 11:36:20 +00003623 page_ref(pPg);
drhed7c8552001-04-11 14:29:21 +00003624 }
danielk19773b8a05f2007-03-19 17:44:26 +00003625 *ppPage = pPg;
drhed7c8552001-04-11 14:29:21 +00003626 return SQLITE_OK;
3627}
drh86f8c192007-08-22 00:39:19 +00003628int sqlite3PagerAcquire(
3629 Pager *pPager, /* The pager open on the database file */
3630 Pgno pgno, /* Page number to fetch */
3631 DbPage **ppPage, /* Write a pointer to the page here */
3632 int noContent /* Do not bother reading content from disk if true */
3633){
3634 int rc;
3635 pagerEnter(pPager);
3636 rc = pagerAcquire(pPager, pgno, ppPage, noContent);
3637 pagerLeave(pPager);
3638 return rc;
3639}
3640
drhed7c8552001-04-11 14:29:21 +00003641
3642/*
drh7e3b0a02001-04-28 16:52:40 +00003643** Acquire a page if it is already in the in-memory cache. Do
3644** not read the page from disk. Return a pointer to the page,
3645** or 0 if the page is not in cache.
3646**
danielk19773b8a05f2007-03-19 17:44:26 +00003647** See also sqlite3PagerGet(). The difference between this routine
3648** and sqlite3PagerGet() is that _get() will go to the disk and read
drh7e3b0a02001-04-28 16:52:40 +00003649** in the page if the page is not already in cache. This routine
drh5e00f6c2001-09-13 13:46:56 +00003650** returns NULL if the page is not in cache or if a disk I/O error
3651** has ever happened.
drh7e3b0a02001-04-28 16:52:40 +00003652*/
danielk19773b8a05f2007-03-19 17:44:26 +00003653DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
drh86f8c192007-08-22 00:39:19 +00003654 PgHdr *pPg = 0;
drh7e3b0a02001-04-28 16:52:40 +00003655
drh836faa42003-01-11 13:30:57 +00003656 assert( pPager!=0 );
3657 assert( pgno!=0 );
danielk1977e277be02007-03-23 18:12:06 +00003658
drh86f8c192007-08-22 00:39:19 +00003659 pagerEnter(pPager);
danielk1977e277be02007-03-23 18:12:06 +00003660 if( pPager->state==PAGER_UNLOCK ){
danielk1977334cdb62007-03-26 08:05:12 +00003661 assert( !pPager->pAll || pPager->exclusiveMode );
drh86f8c192007-08-22 00:39:19 +00003662 }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
3663 /* Do nothing */
3664 }else if( (pPg = pager_lookup(pPager, pgno))!=0 ){
3665 page_ref(pPg);
danielk1977e277be02007-03-23 18:12:06 +00003666 }
drh86f8c192007-08-22 00:39:19 +00003667 pagerLeave(pPager);
danielk19773b8a05f2007-03-19 17:44:26 +00003668 return pPg;
drh7e3b0a02001-04-28 16:52:40 +00003669}
3670
3671/*
drhed7c8552001-04-11 14:29:21 +00003672** Release a page.
3673**
3674** If the number of references to the page drop to zero, then the
3675** page is added to the LRU list. When all references to all pages
drhd9b02572001-04-15 00:37:09 +00003676** are released, a rollback occurs and the lock on the database is
drhed7c8552001-04-11 14:29:21 +00003677** removed.
3678*/
danielk19773b8a05f2007-03-19 17:44:26 +00003679int sqlite3PagerUnref(DbPage *pPg){
drhd9b02572001-04-15 00:37:09 +00003680
3681 /* Decrement the reference count for this page
3682 */
drhed7c8552001-04-11 14:29:21 +00003683 assert( pPg->nRef>0 );
drh86f8c192007-08-22 00:39:19 +00003684 pagerEnter(pPg->pPager);
drhed7c8552001-04-11 14:29:21 +00003685 pPg->nRef--;
drhdd793422001-06-28 01:54:48 +00003686 REFINFO(pPg);
drhd9b02572001-04-15 00:37:09 +00003687
danielk19773c407372005-02-15 02:54:14 +00003688 CHECK_PAGE(pPg);
3689
drh72f82862001-05-24 21:06:34 +00003690 /* When the number of references to a page reach 0, call the
3691 ** destructor and add the page to the freelist.
drhd9b02572001-04-15 00:37:09 +00003692 */
drhed7c8552001-04-11 14:29:21 +00003693 if( pPg->nRef==0 ){
danielk19779f61c2f2007-08-27 17:27:49 +00003694 Pager *pPager = pPg->pPager;
3695
3696 lruListAdd(pPg);
drh72f82862001-05-24 21:06:34 +00003697 if( pPager->xDestructor ){
danielk19773b8a05f2007-03-19 17:44:26 +00003698 pPager->xDestructor(pPg, pPager->pageSize);
drh72f82862001-05-24 21:06:34 +00003699 }
drhd9b02572001-04-15 00:37:09 +00003700
3701 /* When all pages reach the freelist, drop the read lock from
3702 ** the database file.
3703 */
3704 pPager->nRef--;
3705 assert( pPager->nRef>=0 );
danielk19773dedc192007-03-27 17:37:31 +00003706 if( pPager->nRef==0 && (!pPager->exclusiveMode || pPager->journalOff>0) ){
danielk1977e277be02007-03-23 18:12:06 +00003707 pagerUnlockAndRollback(pPager);
drhd9b02572001-04-15 00:37:09 +00003708 }
drhed7c8552001-04-11 14:29:21 +00003709 }
drh86f8c192007-08-22 00:39:19 +00003710 pagerLeave(pPg->pPager);
drhd9b02572001-04-15 00:37:09 +00003711 return SQLITE_OK;
drhed7c8552001-04-11 14:29:21 +00003712}
3713
3714/*
drha6abd042004-06-09 17:37:22 +00003715** Create a journal file for pPager. There should already be a RESERVED
3716** or EXCLUSIVE lock on the database file when this routine is called.
drhda47d772002-12-02 04:25:19 +00003717**
3718** Return SQLITE_OK if everything. Return an error code and release the
3719** write lock if anything goes wrong.
3720*/
3721static int pager_open_journal(Pager *pPager){
danielk1977b4b47412007-08-17 15:53:36 +00003722 sqlite3_vfs *pVfs = pPager->pVfs;
3723 int flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_CREATE);
3724
drhda47d772002-12-02 04:25:19 +00003725 int rc;
drhb7f91642004-10-31 02:22:47 +00003726 assert( !MEMDB );
drha6abd042004-06-09 17:37:22 +00003727 assert( pPager->state>=PAGER_RESERVED );
drhda47d772002-12-02 04:25:19 +00003728 assert( pPager->journalOpen==0 );
3729 assert( pPager->useJournal );
drh88b01a12005-03-28 18:04:27 +00003730 assert( pPager->aInJournal==0 );
danielk19773b8a05f2007-03-19 17:44:26 +00003731 sqlite3PagerPagecount(pPager);
drhed138fb2007-08-22 22:04:37 +00003732 pagerLeave(pPager);
drh17435752007-08-16 04:30:38 +00003733 pPager->aInJournal = sqlite3MallocZero( pPager->dbSize/8 + 1 );
drhed138fb2007-08-22 22:04:37 +00003734 pagerEnter(pPager);
drhda47d772002-12-02 04:25:19 +00003735 if( pPager->aInJournal==0 ){
drh9c105bb2004-10-02 20:38:28 +00003736 rc = SQLITE_NOMEM;
3737 goto failed_to_open_journal;
drhda47d772002-12-02 04:25:19 +00003738 }
danielk1977b4b47412007-08-17 15:53:36 +00003739
3740 if( pPager->tempFile ){
danielk1977fee2d252007-08-18 10:59:19 +00003741 flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
3742 }else{
3743 flags |= (SQLITE_OPEN_MAIN_JOURNAL);
danielk1977b4b47412007-08-17 15:53:36 +00003744 }
danielk1977c7b60172007-08-22 11:22:03 +00003745#ifdef SQLITE_ENABLE_ATOMIC_WRITE
3746 rc = sqlite3JournalOpen(
3747 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
3748 );
3749#else
danielk1977b4b47412007-08-17 15:53:36 +00003750 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
danielk1977c7b60172007-08-22 11:22:03 +00003751#endif
danielk1977b4b47412007-08-17 15:53:36 +00003752 assert( rc!=SQLITE_OK || pPager->jfd->pMethods );
danielk197776572402004-06-25 02:38:54 +00003753 pPager->journalOff = 0;
3754 pPager->setMaster = 0;
3755 pPager->journalHdr = 0;
drhda47d772002-12-02 04:25:19 +00003756 if( rc!=SQLITE_OK ){
drh600e46a2007-03-28 01:59:33 +00003757 if( rc==SQLITE_NOMEM ){
danielk1977fee2d252007-08-18 10:59:19 +00003758 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
drh600e46a2007-03-28 01:59:33 +00003759 }
drh9c105bb2004-10-02 20:38:28 +00003760 goto failed_to_open_journal;
drhda47d772002-12-02 04:25:19 +00003761 }
3762 pPager->journalOpen = 1;
drhdb48ee02003-01-16 13:42:43 +00003763 pPager->journalStarted = 0;
drhda47d772002-12-02 04:25:19 +00003764 pPager->needSync = 0;
3765 pPager->alwaysRollback = 0;
drh968af522003-02-11 14:55:40 +00003766 pPager->nRec = 0;
danielk1977efaaf572006-01-16 11:29:19 +00003767 if( pPager->errCode ){
3768 rc = pPager->errCode;
drhdd5b2fa2005-03-28 03:39:55 +00003769 goto failed_to_open_journal;
drh2e6d11b2003-04-25 15:37:57 +00003770 }
drhda47d772002-12-02 04:25:19 +00003771 pPager->origDbSize = pPager->dbSize;
drhae2b40c2004-06-09 19:03:54 +00003772
danielk197776572402004-06-25 02:38:54 +00003773 rc = writeJournalHdr(pPager);
3774
drhac69b052004-05-12 13:30:07 +00003775 if( pPager->stmtAutoopen && rc==SQLITE_OK ){
danielk19773b8a05f2007-03-19 17:44:26 +00003776 rc = sqlite3PagerStmtBegin(pPager);
drhda47d772002-12-02 04:25:19 +00003777 }
danielk1977261919c2005-12-06 12:52:59 +00003778 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
drh80e35f42007-03-30 14:06:34 +00003779 rc = pager_end_transaction(pPager);
drhda47d772002-12-02 04:25:19 +00003780 if( rc==SQLITE_OK ){
3781 rc = SQLITE_FULL;
3782 }
3783 }
drh9c105bb2004-10-02 20:38:28 +00003784 return rc;
3785
3786failed_to_open_journal:
drh17435752007-08-16 04:30:38 +00003787 sqlite3_free(pPager->aInJournal);
drh9c105bb2004-10-02 20:38:28 +00003788 pPager->aInJournal = 0;
drh9c105bb2004-10-02 20:38:28 +00003789 return rc;
drhda47d772002-12-02 04:25:19 +00003790}
3791
3792/*
drh4b845d72002-03-05 12:41:19 +00003793** Acquire a write-lock on the database. The lock is removed when
3794** the any of the following happen:
3795**
drh80e35f42007-03-30 14:06:34 +00003796** * sqlite3PagerCommitPhaseTwo() is called.
danielk19773b8a05f2007-03-19 17:44:26 +00003797** * sqlite3PagerRollback() is called.
3798** * sqlite3PagerClose() is called.
3799** * sqlite3PagerUnref() is called to on every outstanding page.
drh4b845d72002-03-05 12:41:19 +00003800**
danielk197713adf8a2004-06-03 16:08:41 +00003801** The first parameter to this routine is a pointer to any open page of the
3802** database file. Nothing changes about the page - it is used merely to
3803** acquire a pointer to the Pager structure and as proof that there is
3804** already a read-lock on the database.
drh4b845d72002-03-05 12:41:19 +00003805**
danielk197713adf8a2004-06-03 16:08:41 +00003806** The second parameter indicates how much space in bytes to reserve for a
3807** master journal file-name at the start of the journal when it is created.
3808**
3809** A journal file is opened if this is not a temporary file. For temporary
3810** files, the opening of the journal file is deferred until there is an
3811** actual need to write to the journal.
drhda47d772002-12-02 04:25:19 +00003812**
drha6abd042004-06-09 17:37:22 +00003813** If the database is already reserved for writing, this routine is a no-op.
drh684917c2004-10-05 02:41:42 +00003814**
3815** If exFlag is true, go ahead and get an EXCLUSIVE lock on the file
3816** immediately instead of waiting until we try to flush the cache. The
3817** exFlag is ignored if a transaction is already active.
drh4b845d72002-03-05 12:41:19 +00003818*/
danielk19773b8a05f2007-03-19 17:44:26 +00003819int sqlite3PagerBegin(DbPage *pPg, int exFlag){
drh4b845d72002-03-05 12:41:19 +00003820 Pager *pPager = pPg->pPager;
3821 int rc = SQLITE_OK;
drh86f8c192007-08-22 00:39:19 +00003822 pagerEnter(pPager);
drh4b845d72002-03-05 12:41:19 +00003823 assert( pPg->nRef>0 );
drha6abd042004-06-09 17:37:22 +00003824 assert( pPager->state!=PAGER_UNLOCK );
3825 if( pPager->state==PAGER_SHARED ){
drh4b845d72002-03-05 12:41:19 +00003826 assert( pPager->aInJournal==0 );
drhb7f91642004-10-31 02:22:47 +00003827 if( MEMDB ){
drha6abd042004-06-09 17:37:22 +00003828 pPager->state = PAGER_EXCLUSIVE;
drhac69b052004-05-12 13:30:07 +00003829 pPager->origDbSize = pPager->dbSize;
3830 }else{
drh054889e2005-11-30 03:20:31 +00003831 rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK);
drh684917c2004-10-05 02:41:42 +00003832 if( rc==SQLITE_OK ){
3833 pPager->state = PAGER_RESERVED;
3834 if( exFlag ){
3835 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
3836 }
3837 }
danielk19779eed5052004-06-04 10:38:30 +00003838 if( rc!=SQLITE_OK ){
drh86f8c192007-08-22 00:39:19 +00003839 pagerLeave(pPager);
danielk19779eed5052004-06-04 10:38:30 +00003840 return rc;
drhac69b052004-05-12 13:30:07 +00003841 }
drha6abd042004-06-09 17:37:22 +00003842 pPager->dirtyCache = 0;
drh4f0c5872007-03-26 22:05:01 +00003843 PAGERTRACE2("TRANSACTION %d\n", PAGERID(pPager));
drhac69b052004-05-12 13:30:07 +00003844 if( pPager->useJournal && !pPager->tempFile ){
3845 rc = pager_open_journal(pPager);
3846 }
drh4b845d72002-03-05 12:41:19 +00003847 }
danielk1977334cdb62007-03-26 08:05:12 +00003848 }else if( pPager->journalOpen && pPager->journalOff==0 ){
3849 /* This happens when the pager was in exclusive-access mode last
3850 ** time a (read or write) transaction was successfully concluded
3851 ** by this connection. Instead of deleting the journal file it was
3852 ** kept open and truncated to 0 bytes.
3853 */
3854 assert( pPager->nRec==0 );
3855 assert( pPager->origDbSize==0 );
drh369339d2007-03-30 16:01:55 +00003856 assert( pPager->aInJournal==0 );
danielk1977334cdb62007-03-26 08:05:12 +00003857 sqlite3PagerPagecount(pPager);
drhed138fb2007-08-22 22:04:37 +00003858 pagerLeave(pPager);
drh17435752007-08-16 04:30:38 +00003859 pPager->aInJournal = sqlite3MallocZero( pPager->dbSize/8 + 1 );
drhed138fb2007-08-22 22:04:37 +00003860 pagerEnter(pPager);
danielk1977334cdb62007-03-26 08:05:12 +00003861 if( !pPager->aInJournal ){
3862 rc = SQLITE_NOMEM;
3863 }else{
drh369339d2007-03-30 16:01:55 +00003864 pPager->origDbSize = pPager->dbSize;
danielk1977334cdb62007-03-26 08:05:12 +00003865 rc = writeJournalHdr(pPager);
3866 }
drh4b845d72002-03-05 12:41:19 +00003867 }
danielk1977334cdb62007-03-26 08:05:12 +00003868 assert( !pPager->journalOpen || pPager->journalOff>0 || rc!=SQLITE_OK );
drh86f8c192007-08-22 00:39:19 +00003869 pagerLeave(pPager);
drh4b845d72002-03-05 12:41:19 +00003870 return rc;
3871}
3872
3873/*
drh605ad8f2006-05-03 23:34:05 +00003874** Make a page dirty. Set its dirty flag and add it to the dirty
3875** page list.
3876*/
3877static void makeDirty(PgHdr *pPg){
3878 if( pPg->dirty==0 ){
3879 Pager *pPager = pPg->pPager;
3880 pPg->dirty = 1;
3881 pPg->pDirty = pPager->pDirty;
3882 if( pPager->pDirty ){
3883 pPager->pDirty->pPrevDirty = pPg;
3884 }
3885 pPg->pPrevDirty = 0;
3886 pPager->pDirty = pPg;
3887 }
3888}
3889
3890/*
3891** Make a page clean. Clear its dirty bit and remove it from the
3892** dirty page list.
3893*/
3894static void makeClean(PgHdr *pPg){
3895 if( pPg->dirty ){
3896 pPg->dirty = 0;
3897 if( pPg->pDirty ){
drh153c62c2007-08-24 03:51:33 +00003898 assert( pPg->pDirty->pPrevDirty==pPg );
drh605ad8f2006-05-03 23:34:05 +00003899 pPg->pDirty->pPrevDirty = pPg->pPrevDirty;
3900 }
3901 if( pPg->pPrevDirty ){
drh153c62c2007-08-24 03:51:33 +00003902 assert( pPg->pPrevDirty->pDirty==pPg );
drh605ad8f2006-05-03 23:34:05 +00003903 pPg->pPrevDirty->pDirty = pPg->pDirty;
3904 }else{
drh153c62c2007-08-24 03:51:33 +00003905 assert( pPg->pPager->pDirty==pPg );
drh605ad8f2006-05-03 23:34:05 +00003906 pPg->pPager->pDirty = pPg->pDirty;
3907 }
3908 }
3909}
3910
3911
3912/*
drhed7c8552001-04-11 14:29:21 +00003913** Mark a data page as writeable. The page is written into the journal
3914** if it is not there already. This routine must be called before making
3915** changes to a page.
3916**
3917** The first time this routine is called, the pager creates a new
drha6abd042004-06-09 17:37:22 +00003918** journal and acquires a RESERVED lock on the database. If the RESERVED
drhed7c8552001-04-11 14:29:21 +00003919** lock could not be acquired, this routine returns SQLITE_BUSY. The
drh306dc212001-05-21 13:45:10 +00003920** calling routine must check for that return value and be careful not to
drhed7c8552001-04-11 14:29:21 +00003921** change any page data until this routine returns SQLITE_OK.
drhd9b02572001-04-15 00:37:09 +00003922**
3923** If the journal file could not be written because the disk is full,
3924** then this routine returns SQLITE_FULL and does an immediate rollback.
3925** All subsequent write attempts also return SQLITE_FULL until there
danielk19773b8a05f2007-03-19 17:44:26 +00003926** is a call to sqlite3PagerCommit() or sqlite3PagerRollback() to
drhd9b02572001-04-15 00:37:09 +00003927** reset.
drhed7c8552001-04-11 14:29:21 +00003928*/
danielk19773b8a05f2007-03-19 17:44:26 +00003929static int pager_write(PgHdr *pPg){
3930 void *pData = PGHDR_TO_DATA(pPg);
drh69688d52001-04-14 16:38:23 +00003931 Pager *pPager = pPg->pPager;
drhd79caeb2001-04-15 02:27:24 +00003932 int rc = SQLITE_OK;
drh69688d52001-04-14 16:38:23 +00003933
drh6446c4d2001-12-15 14:22:18 +00003934 /* Check for errors
3935 */
danielk1977efaaf572006-01-16 11:29:19 +00003936 if( pPager->errCode ){
3937 return pPager->errCode;
drhd9b02572001-04-15 00:37:09 +00003938 }
drh5e00f6c2001-09-13 13:46:56 +00003939 if( pPager->readOnly ){
3940 return SQLITE_PERM;
3941 }
drh6446c4d2001-12-15 14:22:18 +00003942
danielk197776572402004-06-25 02:38:54 +00003943 assert( !pPager->setMaster );
3944
danielk19773c407372005-02-15 02:54:14 +00003945 CHECK_PAGE(pPg);
3946
drh538f5702007-04-13 02:14:30 +00003947 /* If this page was previously acquired with noContent==1, that means
3948 ** we didn't really read in the content of the page. This can happen
3949 ** (for example) when the page is being moved to the freelist. But
3950 ** now we are (perhaps) moving the page off of the freelist for
3951 ** reuse and we need to know its original content so that content
3952 ** can be stored in the rollback journal. So do the read at this
3953 ** time.
3954 */
drhd33d5a82007-04-26 12:11:28 +00003955 rc = pager_get_content(pPg);
3956 if( rc ){
3957 return rc;
drh538f5702007-04-13 02:14:30 +00003958 }
3959
drh6446c4d2001-12-15 14:22:18 +00003960 /* Mark the page as dirty. If the page has already been written
3961 ** to the journal then we can return right away.
3962 */
drh605ad8f2006-05-03 23:34:05 +00003963 makeDirty(pPg);
danielk1977f35843b2007-04-07 15:03:17 +00003964 if( pPg->inJournal && (pageInStatement(pPg) || pPager->stmtInUse==0) ){
drha6abd042004-06-09 17:37:22 +00003965 pPager->dirtyCache = 1;
danielk1977a0bf2652004-11-04 14:30:04 +00003966 }else{
drh6446c4d2001-12-15 14:22:18 +00003967
danielk1977a0bf2652004-11-04 14:30:04 +00003968 /* If we get this far, it means that the page needs to be
3969 ** written to the transaction journal or the ckeckpoint journal
3970 ** or both.
3971 **
3972 ** First check to see that the transaction journal exists and
3973 ** create it if it does not.
3974 */
3975 assert( pPager->state!=PAGER_UNLOCK );
danielk19773b8a05f2007-03-19 17:44:26 +00003976 rc = sqlite3PagerBegin(pPg, 0);
danielk1977a0bf2652004-11-04 14:30:04 +00003977 if( rc!=SQLITE_OK ){
3978 return rc;
3979 }
3980 assert( pPager->state>=PAGER_RESERVED );
3981 if( !pPager->journalOpen && pPager->useJournal ){
3982 rc = pager_open_journal(pPager);
3983 if( rc!=SQLITE_OK ) return rc;
3984 }
3985 assert( pPager->journalOpen || !pPager->useJournal );
3986 pPager->dirtyCache = 1;
3987
3988 /* The transaction journal now exists and we have a RESERVED or an
3989 ** EXCLUSIVE lock on the main database file. Write the current page to
3990 ** the transaction journal if it is not there already.
3991 */
3992 if( !pPg->inJournal && (pPager->useJournal || MEMDB) ){
3993 if( (int)pPg->pgno <= pPager->origDbSize ){
3994 int szPg;
danielk1977a0bf2652004-11-04 14:30:04 +00003995 if( MEMDB ){
3996 PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
drh4f0c5872007-03-26 22:05:01 +00003997 PAGERTRACE3("JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
danielk1977a0bf2652004-11-04 14:30:04 +00003998 assert( pHist->pOrig==0 );
drh17435752007-08-16 04:30:38 +00003999 pHist->pOrig = sqlite3_malloc( pPager->pageSize );
danielk1977a0bf2652004-11-04 14:30:04 +00004000 if( pHist->pOrig ){
4001 memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize);
4002 }
4003 }else{
drhc001c582006-03-06 18:23:16 +00004004 u32 cksum, saved;
4005 char *pData2, *pEnd;
danielk1977dd97a492007-08-22 18:54:32 +00004006
drh267cb322005-09-16 17:16:52 +00004007 /* We should never write to the journal file the page that
4008 ** contains the database locks. The following assert verifies
4009 ** that we do not. */
4010 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
drhc001c582006-03-06 18:23:16 +00004011 pData2 = CODEC2(pPager, pData, pPg->pgno, 7);
drh37527852006-03-16 16:19:56 +00004012 cksum = pager_cksum(pPager, (u8*)pData2);
drhc001c582006-03-06 18:23:16 +00004013 pEnd = pData2 + pPager->pageSize;
4014 pData2 -= 4;
4015 saved = *(u32*)pEnd;
4016 put32bits(pEnd, cksum);
danielk1977a0bf2652004-11-04 14:30:04 +00004017 szPg = pPager->pageSize+8;
drhc001c582006-03-06 18:23:16 +00004018 put32bits(pData2, pPg->pgno);
danielk197762079062007-08-15 17:08:46 +00004019 rc = sqlite3OsWrite(pPager->jfd, pData2, szPg, pPager->journalOff);
drhb0603412007-02-28 04:47:26 +00004020 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
drh538f5702007-04-13 02:14:30 +00004021 pPager->journalOff, szPg));
4022 PAGER_INCR(sqlite3_pager_writej_count);
danielk1977a0bf2652004-11-04 14:30:04 +00004023 pPager->journalOff += szPg;
drh477731b2007-06-16 03:06:27 +00004024 PAGERTRACE5("JOURNAL %d page %d needSync=%d hash(%08x)\n",
4025 PAGERID(pPager), pPg->pgno, pPg->needSync, pager_pagehash(pPg));
drhc001c582006-03-06 18:23:16 +00004026 *(u32*)pEnd = saved;
danielk197707cb5602006-01-20 10:55:05 +00004027
drhfd131da2007-08-07 17:13:03 +00004028 /* An error has occured writing to the journal file. The
danielk197707cb5602006-01-20 10:55:05 +00004029 ** transaction will be rolled back by the layer above.
4030 */
danielk1977a0bf2652004-11-04 14:30:04 +00004031 if( rc!=SQLITE_OK ){
danielk1977a0bf2652004-11-04 14:30:04 +00004032 return rc;
4033 }
danielk197707cb5602006-01-20 10:55:05 +00004034
danielk1977a0bf2652004-11-04 14:30:04 +00004035 pPager->nRec++;
4036 assert( pPager->aInJournal!=0 );
4037 pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
4038 pPg->needSync = !pPager->noSync;
4039 if( pPager->stmtInUse ){
4040 pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
danielk1977a0bf2652004-11-04 14:30:04 +00004041 }
drhac69b052004-05-12 13:30:07 +00004042 }
danielk197713adf8a2004-06-03 16:08:41 +00004043 }else{
danielk1977a0bf2652004-11-04 14:30:04 +00004044 pPg->needSync = !pPager->journalStarted && !pPager->noSync;
drh4f0c5872007-03-26 22:05:01 +00004045 PAGERTRACE4("APPEND %d page %d needSync=%d\n",
danielk1977ef73ee92004-11-06 12:26:07 +00004046 PAGERID(pPager), pPg->pgno, pPg->needSync);
danielk1977a0bf2652004-11-04 14:30:04 +00004047 }
4048 if( pPg->needSync ){
4049 pPager->needSync = 1;
4050 }
4051 pPg->inJournal = 1;
4052 }
4053
4054 /* If the statement journal is open and the page is not in it,
4055 ** then write the current page to the statement journal. Note that
4056 ** the statement journal format differs from the standard journal format
4057 ** in that it omits the checksums and the header.
4058 */
danielk1977f35843b2007-04-07 15:03:17 +00004059 if( pPager->stmtInUse
4060 && !pageInStatement(pPg)
4061 && (int)pPg->pgno<=pPager->stmtSize
4062 ){
danielk1977a0bf2652004-11-04 14:30:04 +00004063 assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
4064 if( MEMDB ){
4065 PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
4066 assert( pHist->pStmt==0 );
drh17435752007-08-16 04:30:38 +00004067 pHist->pStmt = sqlite3_malloc( pPager->pageSize );
danielk1977a0bf2652004-11-04 14:30:04 +00004068 if( pHist->pStmt ){
4069 memcpy(pHist->pStmt, PGHDR_TO_DATA(pPg), pPager->pageSize);
4070 }
drh4f0c5872007-03-26 22:05:01 +00004071 PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
danielk1977f35843b2007-04-07 15:03:17 +00004072 page_add_to_stmt_list(pPg);
danielk1977a0bf2652004-11-04 14:30:04 +00004073 }else{
danielk197762079062007-08-15 17:08:46 +00004074 i64 offset = pPager->stmtNRec*(4+pPager->pageSize);
drhc001c582006-03-06 18:23:16 +00004075 char *pData2 = CODEC2(pPager, pData, pPg->pgno, 7)-4;
4076 put32bits(pData2, pPg->pgno);
danielk197762079062007-08-15 17:08:46 +00004077 rc = sqlite3OsWrite(pPager->stfd, pData2, pPager->pageSize+4, offset);
drh4f0c5872007-03-26 22:05:01 +00004078 PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
drhac69b052004-05-12 13:30:07 +00004079 if( rc!=SQLITE_OK ){
drhac69b052004-05-12 13:30:07 +00004080 return rc;
4081 }
danielk1977a0bf2652004-11-04 14:30:04 +00004082 pPager->stmtNRec++;
4083 assert( pPager->aInStmt!=0 );
4084 pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
drhdb48ee02003-01-16 13:42:43 +00004085 }
drhd9b02572001-04-15 00:37:09 +00004086 }
drhfa86c412002-02-02 15:01:15 +00004087 }
4088
4089 /* Update the database size and return.
4090 */
drh1aa2d8b2007-01-03 15:34:29 +00004091 assert( pPager->state>=PAGER_SHARED );
drh1ab43002002-01-14 09:28:19 +00004092 if( pPager->dbSize<(int)pPg->pgno ){
drh306dc212001-05-21 13:45:10 +00004093 pPager->dbSize = pPg->pgno;
drhb7f91642004-10-31 02:22:47 +00004094 if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){
drh1f595712004-06-15 01:40:29 +00004095 pPager->dbSize++;
4096 }
drh306dc212001-05-21 13:45:10 +00004097 }
drh69688d52001-04-14 16:38:23 +00004098 return rc;
drhed7c8552001-04-11 14:29:21 +00004099}
4100
4101/*
danielk19774099f6e2007-03-19 11:25:20 +00004102** This function is used to mark a data-page as writable. It uses
4103** pager_write() to open a journal file (if it is not already open)
4104** and write the page *pData to the journal.
4105**
4106** The difference between this function and pager_write() is that this
4107** function also deals with the special case where 2 or more pages
4108** fit on a single disk sector. In this case all co-resident pages
4109** must have been written to the journal file before returning.
4110*/
danielk19773b8a05f2007-03-19 17:44:26 +00004111int sqlite3PagerWrite(DbPage *pDbPage){
danielk19774099f6e2007-03-19 11:25:20 +00004112 int rc = SQLITE_OK;
4113
danielk19773b8a05f2007-03-19 17:44:26 +00004114 PgHdr *pPg = pDbPage;
danielk19774099f6e2007-03-19 11:25:20 +00004115 Pager *pPager = pPg->pPager;
4116 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
4117
drh86f8c192007-08-22 00:39:19 +00004118 pagerEnter(pPager);
danielk19774099f6e2007-03-19 11:25:20 +00004119 if( !MEMDB && nPagePerSector>1 ){
4120 Pgno nPageCount; /* Total number of pages in database file */
4121 Pgno pg1; /* First page of the sector pPg is located on. */
4122 int nPage; /* Number of pages starting at pg1 to journal */
4123 int ii;
danielk1977dd97a492007-08-22 18:54:32 +00004124 int needSync = 0;
danielk19774099f6e2007-03-19 11:25:20 +00004125
4126 /* Set the doNotSync flag to 1. This is because we cannot allow a journal
4127 ** header to be written between the pages journaled by this function.
4128 */
4129 assert( pPager->doNotSync==0 );
4130 pPager->doNotSync = 1;
4131
4132 /* This trick assumes that both the page-size and sector-size are
4133 ** an integer power of 2. It sets variable pg1 to the identifier
4134 ** of the first page of the sector pPg is located on.
4135 */
4136 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
4137
danielk19773b8a05f2007-03-19 17:44:26 +00004138 nPageCount = sqlite3PagerPagecount(pPager);
danielk19774099f6e2007-03-19 11:25:20 +00004139 if( pPg->pgno>nPageCount ){
4140 nPage = (pPg->pgno - pg1)+1;
4141 }else if( (pg1+nPagePerSector-1)>nPageCount ){
4142 nPage = nPageCount+1-pg1;
4143 }else{
4144 nPage = nPagePerSector;
4145 }
4146 assert(nPage>0);
4147 assert(pg1<=pPg->pgno);
4148 assert((pg1+nPage)>pPg->pgno);
4149
4150 for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
4151 Pgno pg = pg1+ii;
danielk1977dd97a492007-08-22 18:54:32 +00004152 PgHdr *pPage;
danielk19774099f6e2007-03-19 11:25:20 +00004153 if( !pPager->aInJournal || pg==pPg->pgno ||
4154 pg>pPager->origDbSize || !(pPager->aInJournal[pg/8]&(1<<(pg&7)))
4155 ) {
4156 if( pg!=PAGER_MJ_PGNO(pPager) ){
danielk19773b8a05f2007-03-19 17:44:26 +00004157 rc = sqlite3PagerGet(pPager, pg, &pPage);
danielk19774099f6e2007-03-19 11:25:20 +00004158 if( rc==SQLITE_OK ){
4159 rc = pager_write(pPage);
danielk1977dd97a492007-08-22 18:54:32 +00004160 if( pPage->needSync ){
4161 needSync = 1;
4162 }
danielk19773b8a05f2007-03-19 17:44:26 +00004163 sqlite3PagerUnref(pPage);
danielk19774099f6e2007-03-19 11:25:20 +00004164 }
4165 }
danielk1977dd97a492007-08-22 18:54:32 +00004166 }else if( (pPage = pager_lookup(pPager, pg)) ){
4167 if( pPage->needSync ){
4168 needSync = 1;
4169 }
danielk19774099f6e2007-03-19 11:25:20 +00004170 }
4171 }
4172
danielk1977dd97a492007-08-22 18:54:32 +00004173 /* If the PgHdr.needSync flag is set for any of the nPage pages
4174 ** starting at pg1, then it needs to be set for all of them. Because
4175 ** writing to any of these nPage pages may damage the others, the
4176 ** journal file must contain sync()ed copies of all of them
4177 ** before any of them can be written out to the database file.
4178 */
4179 if( needSync ){
4180 for(ii=0; ii<nPage && needSync; ii++){
4181 PgHdr *pPage = pager_lookup(pPager, pg1+ii);
4182 if( pPage ) pPage->needSync = 1;
4183 }
4184 assert(pPager->needSync);
4185 }
4186
danielk19774099f6e2007-03-19 11:25:20 +00004187 assert( pPager->doNotSync==1 );
4188 pPager->doNotSync = 0;
4189 }else{
danielk19773b8a05f2007-03-19 17:44:26 +00004190 rc = pager_write(pDbPage);
danielk19774099f6e2007-03-19 11:25:20 +00004191 }
drh86f8c192007-08-22 00:39:19 +00004192 pagerLeave(pPager);
danielk19774099f6e2007-03-19 11:25:20 +00004193 return rc;
4194}
4195
4196/*
drhaacc5432002-01-06 17:07:40 +00004197** Return TRUE if the page given in the argument was previously passed
danielk19773b8a05f2007-03-19 17:44:26 +00004198** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
drh6019e162001-07-02 17:51:45 +00004199** to change the content of the page.
4200*/
danielk19777d3a6662006-01-23 16:21:05 +00004201#ifndef NDEBUG
danielk19773b8a05f2007-03-19 17:44:26 +00004202int sqlite3PagerIswriteable(DbPage *pPg){
drh6019e162001-07-02 17:51:45 +00004203 return pPg->dirty;
4204}
danielk19777d3a6662006-01-23 16:21:05 +00004205#endif
drh6019e162001-07-02 17:51:45 +00004206
danielk1977b84f96f2005-01-20 11:32:23 +00004207#ifndef SQLITE_OMIT_VACUUM
drh6019e162001-07-02 17:51:45 +00004208/*
drh001bbcb2003-03-19 03:14:00 +00004209** Replace the content of a single page with the information in the third
4210** argument.
4211*/
danielk19773b8a05f2007-03-19 17:44:26 +00004212int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void *pData){
4213 PgHdr *pPg;
drh001bbcb2003-03-19 03:14:00 +00004214 int rc;
4215
drh86f8c192007-08-22 00:39:19 +00004216 pagerEnter(pPager);
danielk19773b8a05f2007-03-19 17:44:26 +00004217 rc = sqlite3PagerGet(pPager, pgno, &pPg);
drh001bbcb2003-03-19 03:14:00 +00004218 if( rc==SQLITE_OK ){
danielk19773b8a05f2007-03-19 17:44:26 +00004219 rc = sqlite3PagerWrite(pPg);
drh001bbcb2003-03-19 03:14:00 +00004220 if( rc==SQLITE_OK ){
danielk19773b8a05f2007-03-19 17:44:26 +00004221 memcpy(sqlite3PagerGetData(pPg), pData, pPager->pageSize);
drh001bbcb2003-03-19 03:14:00 +00004222 }
danielk19773b8a05f2007-03-19 17:44:26 +00004223 sqlite3PagerUnref(pPg);
drh001bbcb2003-03-19 03:14:00 +00004224 }
drh86f8c192007-08-22 00:39:19 +00004225 pagerLeave(pPager);
drh001bbcb2003-03-19 03:14:00 +00004226 return rc;
4227}
danielk1977b84f96f2005-01-20 11:32:23 +00004228#endif
drh001bbcb2003-03-19 03:14:00 +00004229
4230/*
drh30e58752002-03-02 20:41:57 +00004231** A call to this routine tells the pager that it is not necessary to
drh538f5702007-04-13 02:14:30 +00004232** write the information on page pPg back to the disk, even though
drh30e58752002-03-02 20:41:57 +00004233** that page might be marked as dirty.
4234**
4235** The overlying software layer calls this routine when all of the data
4236** on the given page is unused. The pager marks the page as clean so
4237** that it does not get written to disk.
4238**
4239** Tests show that this optimization, together with the
danielk19773b8a05f2007-03-19 17:44:26 +00004240** sqlite3PagerDontRollback() below, more than double the speed
drh30e58752002-03-02 20:41:57 +00004241** of large INSERT operations and quadruple the speed of large DELETEs.
drh8e298f92002-07-06 16:28:47 +00004242**
4243** When this routine is called, set the alwaysRollback flag to true.
danielk19773b8a05f2007-03-19 17:44:26 +00004244** Subsequent calls to sqlite3PagerDontRollback() for the same page
drh8e298f92002-07-06 16:28:47 +00004245** will thereafter be ignored. This is necessary to avoid a problem
4246** where a page with data is added to the freelist during one part of
4247** a transaction then removed from the freelist during a later part
4248** of the same transaction and reused for some other purpose. When it
4249** is first added to the freelist, this routine is called. When reused,
drh80e35f42007-03-30 14:06:34 +00004250** the sqlite3PagerDontRollback() routine is called. But because the
4251** page contains critical data, we still need to be sure it gets
4252** rolled back in spite of the sqlite3PagerDontRollback() call.
drh30e58752002-03-02 20:41:57 +00004253*/
drh538f5702007-04-13 02:14:30 +00004254void sqlite3PagerDontWrite(DbPage *pDbPage){
4255 PgHdr *pPg = pDbPage;
4256 Pager *pPager = pPg->pPager;
drh8e298f92002-07-06 16:28:47 +00004257
drhb7f91642004-10-31 02:22:47 +00004258 if( MEMDB ) return;
drh86f8c192007-08-22 00:39:19 +00004259 pagerEnter(pPager);
drh8e298f92002-07-06 16:28:47 +00004260 pPg->alwaysRollback = 1;
drh43617e92006-03-06 20:55:46 +00004261 if( pPg->dirty && !pPager->stmtInUse ){
drh1aa2d8b2007-01-03 15:34:29 +00004262 assert( pPager->state>=PAGER_SHARED );
drh8124a302002-06-25 14:43:57 +00004263 if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){
4264 /* If this pages is the last page in the file and the file has grown
4265 ** during the current transaction, then do NOT mark the page as clean.
4266 ** When the database file grows, we must make sure that the last page
4267 ** gets written at least once so that the disk file will be the correct
4268 ** size. If you do not write this page and the size of the file
4269 ** on the disk ends up being too small, that can lead to database
4270 ** corruption during the next transaction.
4271 */
4272 }else{
drh538f5702007-04-13 02:14:30 +00004273 PAGERTRACE3("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager));
4274 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
drh605ad8f2006-05-03 23:34:05 +00004275 makeClean(pPg);
danielk19773c407372005-02-15 02:54:14 +00004276#ifdef SQLITE_CHECK_PAGES
4277 pPg->pageHash = pager_pagehash(pPg);
4278#endif
drh8124a302002-06-25 14:43:57 +00004279 }
drh30e58752002-03-02 20:41:57 +00004280 }
drh86f8c192007-08-22 00:39:19 +00004281 pagerLeave(pPager);
drh30e58752002-03-02 20:41:57 +00004282}
4283
4284/*
4285** A call to this routine tells the pager that if a rollback occurs,
4286** it is not necessary to restore the data on the given page. This
4287** means that the pager does not have to record the given page in the
4288** rollback journal.
drh538f5702007-04-13 02:14:30 +00004289**
4290** If we have not yet actually read the content of this page (if
4291** the PgHdr.needRead flag is set) then this routine acts as a promise
4292** that we will never need to read the page content in the future.
4293** so the needRead flag can be cleared at this point.
drh30e58752002-03-02 20:41:57 +00004294*/
danielk19773b8a05f2007-03-19 17:44:26 +00004295void sqlite3PagerDontRollback(DbPage *pPg){
drh30e58752002-03-02 20:41:57 +00004296 Pager *pPager = pPg->pPager;
4297
drh86f8c192007-08-22 00:39:19 +00004298 pagerEnter(pPager);
drhd3627af2006-12-18 18:34:51 +00004299 assert( pPager->state>=PAGER_RESERVED );
4300 if( pPager->journalOpen==0 ) return;
drhb7f91642004-10-31 02:22:47 +00004301 if( pPg->alwaysRollback || pPager->alwaysRollback || MEMDB ) return;
drh30e58752002-03-02 20:41:57 +00004302 if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){
4303 assert( pPager->aInJournal!=0 );
4304 pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
4305 pPg->inJournal = 1;
drh538f5702007-04-13 02:14:30 +00004306 pPg->needRead = 0;
drhac69b052004-05-12 13:30:07 +00004307 if( pPager->stmtInUse ){
4308 pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
drh30e58752002-03-02 20:41:57 +00004309 }
drh4f0c5872007-03-26 22:05:01 +00004310 PAGERTRACE3("DONT_ROLLBACK page %d of %d\n", pPg->pgno, PAGERID(pPager));
drhb0603412007-02-28 04:47:26 +00004311 IOTRACE(("GARBAGE %p %d\n", pPager, pPg->pgno))
drh30e58752002-03-02 20:41:57 +00004312 }
danielk1977f35843b2007-04-07 15:03:17 +00004313 if( pPager->stmtInUse
4314 && !pageInStatement(pPg)
4315 && (int)pPg->pgno<=pPager->stmtSize
4316 ){
drh30e58752002-03-02 20:41:57 +00004317 assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
drhac69b052004-05-12 13:30:07 +00004318 assert( pPager->aInStmt!=0 );
4319 pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
drh30e58752002-03-02 20:41:57 +00004320 }
drh86f8c192007-08-22 00:39:19 +00004321 pagerLeave(pPager);
drh30e58752002-03-02 20:41:57 +00004322}
4323
drhac69b052004-05-12 13:30:07 +00004324
drh30e58752002-03-02 20:41:57 +00004325/*
drh80e35f42007-03-30 14:06:34 +00004326** This routine is called to increment the database file change-counter,
4327** stored at byte 24 of the pager file.
4328*/
danielk1977c7b60172007-08-22 11:22:03 +00004329static int pager_incr_changecounter(Pager *pPager, int isDirect){
drh80e35f42007-03-30 14:06:34 +00004330 PgHdr *pPgHdr;
4331 u32 change_counter;
danielk1977c7b60172007-08-22 11:22:03 +00004332 int rc = SQLITE_OK;
drh80e35f42007-03-30 14:06:34 +00004333
4334 if( !pPager->changeCountDone ){
4335 /* Open page 1 of the file for writing. */
4336 rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
4337 if( rc!=SQLITE_OK ) return rc;
danielk1977c7b60172007-08-22 11:22:03 +00004338
4339 if( !isDirect ){
4340 rc = sqlite3PagerWrite(pPgHdr);
4341 if( rc!=SQLITE_OK ) return rc;
4342 }
4343
drh80e35f42007-03-30 14:06:34 +00004344 /* Increment the value just read and write it back to byte 24. */
drhb1003912007-07-20 00:33:36 +00004345 change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers);
drh80e35f42007-03-30 14:06:34 +00004346 change_counter++;
4347 put32bits(((char*)PGHDR_TO_DATA(pPgHdr))+24, change_counter);
danielk1977c7b60172007-08-22 11:22:03 +00004348
4349 if( isDirect && pPager->fd->pMethods ){
4350 const void *zBuf = PGHDR_TO_DATA(pPgHdr);
4351 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
4352 }
4353
drh80e35f42007-03-30 14:06:34 +00004354 /* Release the page reference. */
4355 sqlite3PagerUnref(pPgHdr);
4356 pPager->changeCountDone = 1;
4357 }
danielk1977c7b60172007-08-22 11:22:03 +00004358 return rc;
drh80e35f42007-03-30 14:06:34 +00004359}
4360
4361/*
4362** Sync the database file for the pager pPager. zMaster points to the name
4363** of a master journal file that should be written into the individual
4364** journal file. zMaster may be NULL, which is interpreted as no master
4365** journal (a single database transaction).
4366**
4367** This routine ensures that the journal is synced, all dirty pages written
4368** to the database file and the database file synced. The only thing that
4369** remains to commit the transaction is to delete the journal file (or
4370** master journal file if specified).
4371**
4372** Note that if zMaster==NULL, this does not overwrite a previous value
4373** passed to an sqlite3PagerCommitPhaseOne() call.
4374**
4375** If parameter nTrunc is non-zero, then the pager file is truncated to
4376** nTrunc pages (this is used by auto-vacuum databases).
4377*/
4378int sqlite3PagerCommitPhaseOne(Pager *pPager, const char *zMaster, Pgno nTrunc){
4379 int rc = SQLITE_OK;
4380
4381 PAGERTRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%d\n",
4382 pPager->zFilename, zMaster, nTrunc);
drh86f8c192007-08-22 00:39:19 +00004383 pagerEnter(pPager);
drh80e35f42007-03-30 14:06:34 +00004384
4385 /* If this is an in-memory db, or no pages have been written to, or this
4386 ** function has already been called, it is a no-op.
4387 */
4388 if( pPager->state!=PAGER_SYNCED && !MEMDB && pPager->dirtyCache ){
4389 PgHdr *pPg;
drh80e35f42007-03-30 14:06:34 +00004390
danielk1977c7b60172007-08-22 11:22:03 +00004391#ifdef SQLITE_ENABLE_ATOMIC_WRITE
4392 /* The atomic-write optimization can be used if all of the
4393 ** following are true:
4394 **
4395 ** + The file-system supports the atomic-write property for
4396 ** blocks of size page-size, and
4397 ** + This commit is not part of a multi-file transaction, and
4398 ** + Exactly one page has been modified and store in the journal file.
4399 **
4400 ** If the optimization can be used, then the journal file will never
4401 ** be created for this transaction.
4402 */
danielk1977f55b8992007-08-24 08:15:53 +00004403 int useAtomicWrite = (
4404 !zMaster &&
4405 pPager->journalOff==jrnlBufferSize(pPager) &&
4406 nTrunc==0 &&
4407 (0==pPager->pDirty || 0==pPager->pDirty->pDirty)
4408 );
4409 if( useAtomicWrite ){
danielk1977c7b60172007-08-22 11:22:03 +00004410 /* Update the nRec field in the journal file. */
4411 int offset = pPager->journalHdr + sizeof(aJournalMagic);
4412 assert(pPager->nRec==1);
4413 rc = write32bits(pPager->jfd, offset, pPager->nRec);
4414
4415 /* Update the db file change counter. The following call will modify
4416 ** the in-memory representation of page 1 to include the updated
4417 ** change counter and then write page 1 directly to the database
4418 ** file. Because of the atomic-write property of the host file-system,
4419 ** this is safe.
4420 */
4421 rc = pager_incr_changecounter(pPager, 1);
danielk1977f55b8992007-08-24 08:15:53 +00004422 }else{
4423 rc = sqlite3JournalCreate(pPager->jfd);
4424 if( rc!=SQLITE_OK ) goto sync_exit;
4425 }
4426
4427 if( !useAtomicWrite )
danielk1977c7b60172007-08-22 11:22:03 +00004428#endif
4429
drh80e35f42007-03-30 14:06:34 +00004430 /* If a master journal file name has already been written to the
4431 ** journal file, then no sync is required. This happens when it is
4432 ** written, then the process fails to upgrade from a RESERVED to an
4433 ** EXCLUSIVE lock. The next time the process tries to commit the
4434 ** transaction the m-j name will have already been written.
4435 */
4436 if( !pPager->setMaster ){
danielk1977f55b8992007-08-24 08:15:53 +00004437 assert( pPager->journalOpen );
danielk1977c7b60172007-08-22 11:22:03 +00004438 rc = pager_incr_changecounter(pPager, 0);
drh80e35f42007-03-30 14:06:34 +00004439 if( rc!=SQLITE_OK ) goto sync_exit;
4440#ifndef SQLITE_OMIT_AUTOVACUUM
4441 if( nTrunc!=0 ){
4442 /* If this transaction has made the database smaller, then all pages
4443 ** being discarded by the truncation must be written to the journal
4444 ** file.
4445 */
4446 Pgno i;
4447 int iSkip = PAGER_MJ_PGNO(pPager);
4448 for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){
4449 if( !(pPager->aInJournal[i/8] & (1<<(i&7))) && i!=iSkip ){
4450 rc = sqlite3PagerGet(pPager, i, &pPg);
4451 if( rc!=SQLITE_OK ) goto sync_exit;
4452 rc = sqlite3PagerWrite(pPg);
4453 sqlite3PagerUnref(pPg);
4454 if( rc!=SQLITE_OK ) goto sync_exit;
4455 }
4456 }
4457 }
4458#endif
4459 rc = writeMasterJournal(pPager, zMaster);
4460 if( rc!=SQLITE_OK ) goto sync_exit;
4461 rc = syncJournal(pPager);
drh80e35f42007-03-30 14:06:34 +00004462 }
danielk1977c7b60172007-08-22 11:22:03 +00004463 if( rc!=SQLITE_OK ) goto sync_exit;
drh80e35f42007-03-30 14:06:34 +00004464
4465#ifndef SQLITE_OMIT_AUTOVACUUM
4466 if( nTrunc!=0 ){
4467 rc = sqlite3PagerTruncate(pPager, nTrunc);
4468 if( rc!=SQLITE_OK ) goto sync_exit;
4469 }
4470#endif
4471
4472 /* Write all dirty pages to the database file */
4473 pPg = pager_get_all_dirty_pages(pPager);
4474 rc = pager_write_pagelist(pPg);
drh153c62c2007-08-24 03:51:33 +00004475 if( rc!=SQLITE_OK ){
4476 while( pPg && !pPg->dirty ){ pPg = pPg->pDirty; }
4477 pPager->pDirty = pPg;
4478 goto sync_exit;
4479 }
drh3cdd7d32007-03-30 14:46:01 +00004480 pPager->pDirty = 0;
drh80e35f42007-03-30 14:06:34 +00004481
4482 /* Sync the database file. */
drh1cc8c442007-08-24 16:08:29 +00004483 if( !pPager->noSync ){
danielk1977f036aef2007-08-20 05:36:51 +00004484 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
drh80e35f42007-03-30 14:06:34 +00004485 }
4486 IOTRACE(("DBSYNC %p\n", pPager))
4487
4488 pPager->state = PAGER_SYNCED;
4489 }else if( MEMDB && nTrunc!=0 ){
4490 rc = sqlite3PagerTruncate(pPager, nTrunc);
4491 }
4492
4493sync_exit:
danielk1977e965ac72007-06-13 15:22:28 +00004494 if( rc==SQLITE_IOERR_BLOCKED ){
4495 /* pager_incr_changecounter() may attempt to obtain an exclusive
4496 * lock to spill the cache and return IOERR_BLOCKED. But since
4497 * there is no chance the cache is inconsistent, it's
4498 * better to return SQLITE_BUSY.
4499 */
4500 rc = SQLITE_BUSY;
4501 }
drh86f8c192007-08-22 00:39:19 +00004502 pagerLeave(pPager);
drh80e35f42007-03-30 14:06:34 +00004503 return rc;
4504}
4505
4506
4507/*
drhed7c8552001-04-11 14:29:21 +00004508** Commit all changes to the database and release the write lock.
drhd9b02572001-04-15 00:37:09 +00004509**
4510** If the commit fails for any reason, a rollback attempt is made
4511** and an error code is returned. If the commit worked, SQLITE_OK
4512** is returned.
drhed7c8552001-04-11 14:29:21 +00004513*/
drh80e35f42007-03-30 14:06:34 +00004514int sqlite3PagerCommitPhaseTwo(Pager *pPager){
drha1b351a2001-09-14 16:42:12 +00004515 int rc;
drhed7c8552001-04-11 14:29:21 +00004516 PgHdr *pPg;
drhd9b02572001-04-15 00:37:09 +00004517
danielk1977efaaf572006-01-16 11:29:19 +00004518 if( pPager->errCode ){
danielk19777f7bc662006-01-23 13:47:47 +00004519 return pPager->errCode;
drhd9b02572001-04-15 00:37:09 +00004520 }
drha6abd042004-06-09 17:37:22 +00004521 if( pPager->state<PAGER_RESERVED ){
drhd9b02572001-04-15 00:37:09 +00004522 return SQLITE_ERROR;
4523 }
drh86f8c192007-08-22 00:39:19 +00004524 pagerEnter(pPager);
drh4f0c5872007-03-26 22:05:01 +00004525 PAGERTRACE2("COMMIT %d\n", PAGERID(pPager));
drhb7f91642004-10-31 02:22:47 +00004526 if( MEMDB ){
drhac69b052004-05-12 13:30:07 +00004527 pPg = pager_get_all_dirty_pages(pPager);
4528 while( pPg ){
danielk1977f35843b2007-04-07 15:03:17 +00004529 PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
4530 clearHistory(pHist);
drhac69b052004-05-12 13:30:07 +00004531 pPg->dirty = 0;
4532 pPg->inJournal = 0;
danielk1977f35843b2007-04-07 15:03:17 +00004533 pHist->inStmt = 0;
drh5229ae42006-03-23 23:29:04 +00004534 pPg->needSync = 0;
danielk1977f35843b2007-04-07 15:03:17 +00004535 pHist->pPrevStmt = pHist->pNextStmt = 0;
drhac69b052004-05-12 13:30:07 +00004536 pPg = pPg->pDirty;
4537 }
drh605ad8f2006-05-03 23:34:05 +00004538 pPager->pDirty = 0;
danielk1977eac7a362004-06-16 07:45:24 +00004539#ifndef NDEBUG
4540 for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
4541 PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
4542 assert( !pPg->alwaysRollback );
4543 assert( !pHist->pOrig );
4544 assert( !pHist->pStmt );
4545 }
4546#endif
drhac69b052004-05-12 13:30:07 +00004547 pPager->pStmt = 0;
drha6abd042004-06-09 17:37:22 +00004548 pPager->state = PAGER_SHARED;
drhac69b052004-05-12 13:30:07 +00004549 return SQLITE_OK;
4550 }
drh3cdd7d32007-03-30 14:46:01 +00004551 assert( pPager->journalOpen || !pPager->dirtyCache );
4552 assert( pPager->state==PAGER_SYNCED || !pPager->dirtyCache );
4553 rc = pager_end_transaction(pPager);
drh86f8c192007-08-22 00:39:19 +00004554 rc = pager_error(pPager, rc);
4555 pagerLeave(pPager);
4556 return rc;
drhed7c8552001-04-11 14:29:21 +00004557}
4558
4559/*
drha6abd042004-06-09 17:37:22 +00004560** Rollback all changes. The database falls back to PAGER_SHARED mode.
drhed7c8552001-04-11 14:29:21 +00004561** All in-memory cache pages revert to their original data contents.
4562** The journal is deleted.
drhd9b02572001-04-15 00:37:09 +00004563**
4564** This routine cannot fail unless some other process is not following
drh4f0ee682007-03-30 20:43:40 +00004565** the correct locking protocol or unless some other
drhd9b02572001-04-15 00:37:09 +00004566** process is writing trash into the journal file (SQLITE_CORRUPT) or
4567** unless a prior malloc() failed (SQLITE_NOMEM). Appropriate error
4568** codes are returned for all these occasions. Otherwise,
4569** SQLITE_OK is returned.
drhed7c8552001-04-11 14:29:21 +00004570*/
danielk19773b8a05f2007-03-19 17:44:26 +00004571int sqlite3PagerRollback(Pager *pPager){
drhed7c8552001-04-11 14:29:21 +00004572 int rc;
drh4f0c5872007-03-26 22:05:01 +00004573 PAGERTRACE2("ROLLBACK %d\n", PAGERID(pPager));
drhb7f91642004-10-31 02:22:47 +00004574 if( MEMDB ){
drhac69b052004-05-12 13:30:07 +00004575 PgHdr *p;
4576 for(p=pPager->pAll; p; p=p->pNextAll){
4577 PgHistory *pHist;
danielk1977eac7a362004-06-16 07:45:24 +00004578 assert( !p->alwaysRollback );
4579 if( !p->dirty ){
4580 assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pOrig );
4581 assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pStmt );
4582 continue;
4583 }
4584
drhac69b052004-05-12 13:30:07 +00004585 pHist = PGHDR_TO_HIST(p, pPager);
4586 if( pHist->pOrig ){
4587 memcpy(PGHDR_TO_DATA(p), pHist->pOrig, pPager->pageSize);
drh4f0c5872007-03-26 22:05:01 +00004588 PAGERTRACE3("ROLLBACK-PAGE %d of %d\n", p->pgno, PAGERID(pPager));
drhac69b052004-05-12 13:30:07 +00004589 }else{
drh4f0c5872007-03-26 22:05:01 +00004590 PAGERTRACE3("PAGE %d is clean on %d\n", p->pgno, PAGERID(pPager));
drhac69b052004-05-12 13:30:07 +00004591 }
4592 clearHistory(pHist);
4593 p->dirty = 0;
4594 p->inJournal = 0;
danielk1977f35843b2007-04-07 15:03:17 +00004595 pHist->inStmt = 0;
4596 pHist->pPrevStmt = pHist->pNextStmt = 0;
danielk1977369f27e2004-06-15 11:40:04 +00004597 if( pPager->xReiniter ){
danielk19773b8a05f2007-03-19 17:44:26 +00004598 pPager->xReiniter(p, pPager->pageSize);
danielk1977369f27e2004-06-15 11:40:04 +00004599 }
drhac69b052004-05-12 13:30:07 +00004600 }
drh605ad8f2006-05-03 23:34:05 +00004601 pPager->pDirty = 0;
drhac69b052004-05-12 13:30:07 +00004602 pPager->pStmt = 0;
4603 pPager->dbSize = pPager->origDbSize;
danielk1977e180dd92007-04-05 17:15:52 +00004604 pager_truncate_cache(pPager);
drhac69b052004-05-12 13:30:07 +00004605 pPager->stmtInUse = 0;
drha6abd042004-06-09 17:37:22 +00004606 pPager->state = PAGER_SHARED;
drhac69b052004-05-12 13:30:07 +00004607 return SQLITE_OK;
4608 }
4609
drh86f8c192007-08-22 00:39:19 +00004610 pagerEnter(pPager);
drha6abd042004-06-09 17:37:22 +00004611 if( !pPager->dirtyCache || !pPager->journalOpen ){
drh80e35f42007-03-30 14:06:34 +00004612 rc = pager_end_transaction(pPager);
drh86f8c192007-08-22 00:39:19 +00004613 pagerLeave(pPager);
drhda47d772002-12-02 04:25:19 +00004614 return rc;
4615 }
drhdb48ee02003-01-16 13:42:43 +00004616
danielk1977efaaf572006-01-16 11:29:19 +00004617 if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
drha6abd042004-06-09 17:37:22 +00004618 if( pPager->state>=PAGER_EXCLUSIVE ){
danielk1977e277be02007-03-23 18:12:06 +00004619 pager_playback(pPager, 0);
drh4b845d72002-03-05 12:41:19 +00004620 }
drh86f8c192007-08-22 00:39:19 +00004621 pagerLeave(pPager);
danielk1977efaaf572006-01-16 11:29:19 +00004622 return pPager->errCode;
drhed7c8552001-04-11 14:29:21 +00004623 }
drha6abd042004-06-09 17:37:22 +00004624 if( pPager->state==PAGER_RESERVED ){
danielk197717221812005-02-15 03:38:05 +00004625 int rc2;
danielk1977e277be02007-03-23 18:12:06 +00004626 rc = pager_playback(pPager, 0);
drh80e35f42007-03-30 14:06:34 +00004627 rc2 = pager_end_transaction(pPager);
drha6abd042004-06-09 17:37:22 +00004628 if( rc==SQLITE_OK ){
4629 rc = rc2;
4630 }
4631 }else{
danielk1977e277be02007-03-23 18:12:06 +00004632 rc = pager_playback(pPager, 0);
drhd9b02572001-04-15 00:37:09 +00004633 }
danielk1977e180dd92007-04-05 17:15:52 +00004634 /* pager_reset(pPager); */
drhd9b02572001-04-15 00:37:09 +00004635 pPager->dbSize = -1;
danielk197707cb5602006-01-20 10:55:05 +00004636
4637 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
4638 ** cache. So call pager_error() on the way out to make any error
4639 ** persistent.
4640 */
drh86f8c192007-08-22 00:39:19 +00004641 rc = pager_error(pPager, rc);
4642 pagerLeave(pPager);
4643 return rc;
drh98808ba2001-10-18 12:34:46 +00004644}
drhd9b02572001-04-15 00:37:09 +00004645
4646/*
drh5e00f6c2001-09-13 13:46:56 +00004647** Return TRUE if the database file is opened read-only. Return FALSE
4648** if the database is (in theory) writable.
4649*/
danielk19773b8a05f2007-03-19 17:44:26 +00004650int sqlite3PagerIsreadonly(Pager *pPager){
drhbe0072d2001-09-13 14:46:09 +00004651 return pPager->readOnly;
drh5e00f6c2001-09-13 13:46:56 +00004652}
4653
4654/*
drh0f7eb612006-08-08 13:51:43 +00004655** Return the number of references to the pager.
4656*/
danielk19773b8a05f2007-03-19 17:44:26 +00004657int sqlite3PagerRefcount(Pager *pPager){
drh0f7eb612006-08-08 13:51:43 +00004658 return pPager->nRef;
4659}
4660
4661#ifdef SQLITE_TEST
4662/*
drhd9b02572001-04-15 00:37:09 +00004663** This routine is used for testing and analysis only.
4664*/
danielk19773b8a05f2007-03-19 17:44:26 +00004665int *sqlite3PagerStats(Pager *pPager){
danielk197742741be2005-01-08 12:42:39 +00004666 static int a[11];
drhd9b02572001-04-15 00:37:09 +00004667 a[0] = pPager->nRef;
4668 a[1] = pPager->nPage;
4669 a[2] = pPager->mxPage;
4670 a[3] = pPager->dbSize;
4671 a[4] = pPager->state;
danielk1977efaaf572006-01-16 11:29:19 +00004672 a[5] = pPager->errCode;
drhd9b02572001-04-15 00:37:09 +00004673 a[6] = pPager->nHit;
4674 a[7] = pPager->nMiss;
drh7c4ac0c2007-04-05 11:25:58 +00004675 a[8] = 0; /* Used to be pPager->nOvfl */
danielk197742741be2005-01-08 12:42:39 +00004676 a[9] = pPager->nRead;
4677 a[10] = pPager->nWrite;
drhd9b02572001-04-15 00:37:09 +00004678 return a;
4679}
drh0f7eb612006-08-08 13:51:43 +00004680#endif
drhdd793422001-06-28 01:54:48 +00004681
drhfa86c412002-02-02 15:01:15 +00004682/*
drhac69b052004-05-12 13:30:07 +00004683** Set the statement rollback point.
drhfa86c412002-02-02 15:01:15 +00004684**
4685** This routine should be called with the transaction journal already
drhac69b052004-05-12 13:30:07 +00004686** open. A new statement journal is created that can be used to rollback
drhaaab5722002-02-19 13:39:21 +00004687** changes of a single SQL command within a larger transaction.
drhfa86c412002-02-02 15:01:15 +00004688*/
drh86f8c192007-08-22 00:39:19 +00004689static int pagerStmtBegin(Pager *pPager){
drhfa86c412002-02-02 15:01:15 +00004690 int rc;
drhac69b052004-05-12 13:30:07 +00004691 assert( !pPager->stmtInUse );
drh1aa2d8b2007-01-03 15:34:29 +00004692 assert( pPager->state>=PAGER_SHARED );
drhdc3ff9c2004-08-18 02:10:15 +00004693 assert( pPager->dbSize>=0 );
drh4f0c5872007-03-26 22:05:01 +00004694 PAGERTRACE2("STMT-BEGIN %d\n", PAGERID(pPager));
drhb7f91642004-10-31 02:22:47 +00004695 if( MEMDB ){
drhac69b052004-05-12 13:30:07 +00004696 pPager->stmtInUse = 1;
4697 pPager->stmtSize = pPager->dbSize;
4698 return SQLITE_OK;
4699 }
drhda47d772002-12-02 04:25:19 +00004700 if( !pPager->journalOpen ){
drhac69b052004-05-12 13:30:07 +00004701 pPager->stmtAutoopen = 1;
drhda47d772002-12-02 04:25:19 +00004702 return SQLITE_OK;
4703 }
drhfa86c412002-02-02 15:01:15 +00004704 assert( pPager->journalOpen );
drhed138fb2007-08-22 22:04:37 +00004705 pagerLeave(pPager);
drh17435752007-08-16 04:30:38 +00004706 pPager->aInStmt = sqlite3MallocZero( pPager->dbSize/8 + 1 );
drhed138fb2007-08-22 22:04:37 +00004707 pagerEnter(pPager);
drhac69b052004-05-12 13:30:07 +00004708 if( pPager->aInStmt==0 ){
danielk1977261919c2005-12-06 12:52:59 +00004709 /* sqlite3OsLock(pPager->fd, SHARED_LOCK); */
drhfa86c412002-02-02 15:01:15 +00004710 return SQLITE_NOMEM;
4711 }
drh968af522003-02-11 14:55:40 +00004712#ifndef NDEBUG
drh054889e2005-11-30 03:20:31 +00004713 rc = sqlite3OsFileSize(pPager->jfd, &pPager->stmtJSize);
drhac69b052004-05-12 13:30:07 +00004714 if( rc ) goto stmt_begin_failed;
danielk197776572402004-06-25 02:38:54 +00004715 assert( pPager->stmtJSize == pPager->journalOff );
drh968af522003-02-11 14:55:40 +00004716#endif
danielk197776572402004-06-25 02:38:54 +00004717 pPager->stmtJSize = pPager->journalOff;
drhac69b052004-05-12 13:30:07 +00004718 pPager->stmtSize = pPager->dbSize;
danielk197776572402004-06-25 02:38:54 +00004719 pPager->stmtHdrOff = 0;
danielk197775edc162004-06-26 01:48:18 +00004720 pPager->stmtCksum = pPager->cksumInit;
drhac69b052004-05-12 13:30:07 +00004721 if( !pPager->stmtOpen ){
danielk1977b4b47412007-08-17 15:53:36 +00004722 rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->stfd, 0);
drhac69b052004-05-12 13:30:07 +00004723 if( rc ) goto stmt_begin_failed;
4724 pPager->stmtOpen = 1;
4725 pPager->stmtNRec = 0;
drh0f892532002-05-30 12:27:03 +00004726 }
drhac69b052004-05-12 13:30:07 +00004727 pPager->stmtInUse = 1;
drhfa86c412002-02-02 15:01:15 +00004728 return SQLITE_OK;
4729
drhac69b052004-05-12 13:30:07 +00004730stmt_begin_failed:
4731 if( pPager->aInStmt ){
drh17435752007-08-16 04:30:38 +00004732 sqlite3_free(pPager->aInStmt);
drhac69b052004-05-12 13:30:07 +00004733 pPager->aInStmt = 0;
drhfa86c412002-02-02 15:01:15 +00004734 }
4735 return rc;
4736}
drh86f8c192007-08-22 00:39:19 +00004737int sqlite3PagerStmtBegin(Pager *pPager){
4738 int rc;
4739 pagerEnter(pPager);
4740 rc = pagerStmtBegin(pPager);
4741 pagerLeave(pPager);
4742 return rc;
4743}
drhfa86c412002-02-02 15:01:15 +00004744
4745/*
drhac69b052004-05-12 13:30:07 +00004746** Commit a statement.
drhfa86c412002-02-02 15:01:15 +00004747*/
danielk19773b8a05f2007-03-19 17:44:26 +00004748int sqlite3PagerStmtCommit(Pager *pPager){
drh86f8c192007-08-22 00:39:19 +00004749 pagerEnter(pPager);
drhac69b052004-05-12 13:30:07 +00004750 if( pPager->stmtInUse ){
drh03eb96a2002-11-10 23:32:56 +00004751 PgHdr *pPg, *pNext;
drh4f0c5872007-03-26 22:05:01 +00004752 PAGERTRACE2("STMT-COMMIT %d\n", PAGERID(pPager));
drhb7f91642004-10-31 02:22:47 +00004753 if( !MEMDB ){
drh054889e2005-11-30 03:20:31 +00004754 /* sqlite3OsTruncate(pPager->stfd, 0); */
drh17435752007-08-16 04:30:38 +00004755 sqlite3_free( pPager->aInStmt );
drhac69b052004-05-12 13:30:07 +00004756 pPager->aInStmt = 0;
danielk1977f35843b2007-04-07 15:03:17 +00004757 }else{
4758 for(pPg=pPager->pStmt; pPg; pPg=pNext){
drhac69b052004-05-12 13:30:07 +00004759 PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
danielk1977f35843b2007-04-07 15:03:17 +00004760 pNext = pHist->pNextStmt;
4761 assert( pHist->inStmt );
4762 pHist->inStmt = 0;
4763 pHist->pPrevStmt = pHist->pNextStmt = 0;
drh17435752007-08-16 04:30:38 +00004764 sqlite3_free(pHist->pStmt);
drhac69b052004-05-12 13:30:07 +00004765 pHist->pStmt = 0;
4766 }
4767 }
4768 pPager->stmtNRec = 0;
4769 pPager->stmtInUse = 0;
4770 pPager->pStmt = 0;
drh663fc632002-02-02 18:49:19 +00004771 }
drhac69b052004-05-12 13:30:07 +00004772 pPager->stmtAutoopen = 0;
drh86f8c192007-08-22 00:39:19 +00004773 pagerLeave(pPager);
drhfa86c412002-02-02 15:01:15 +00004774 return SQLITE_OK;
4775}
4776
4777/*
drhac69b052004-05-12 13:30:07 +00004778** Rollback a statement.
drhfa86c412002-02-02 15:01:15 +00004779*/
danielk19773b8a05f2007-03-19 17:44:26 +00004780int sqlite3PagerStmtRollback(Pager *pPager){
drhfa86c412002-02-02 15:01:15 +00004781 int rc;
drh86f8c192007-08-22 00:39:19 +00004782 pagerEnter(pPager);
drhac69b052004-05-12 13:30:07 +00004783 if( pPager->stmtInUse ){
drh4f0c5872007-03-26 22:05:01 +00004784 PAGERTRACE2("STMT-ROLLBACK %d\n", PAGERID(pPager));
drhb7f91642004-10-31 02:22:47 +00004785 if( MEMDB ){
drhac69b052004-05-12 13:30:07 +00004786 PgHdr *pPg;
danielk1977f35843b2007-04-07 15:03:17 +00004787 PgHistory *pHist;
4788 for(pPg=pPager->pStmt; pPg; pPg=pHist->pNextStmt){
4789 pHist = PGHDR_TO_HIST(pPg, pPager);
drhac69b052004-05-12 13:30:07 +00004790 if( pHist->pStmt ){
4791 memcpy(PGHDR_TO_DATA(pPg), pHist->pStmt, pPager->pageSize);
drh17435752007-08-16 04:30:38 +00004792 sqlite3_free(pHist->pStmt);
drhac69b052004-05-12 13:30:07 +00004793 pHist->pStmt = 0;
4794 }
4795 }
4796 pPager->dbSize = pPager->stmtSize;
danielk1977e180dd92007-04-05 17:15:52 +00004797 pager_truncate_cache(pPager);
drhac69b052004-05-12 13:30:07 +00004798 rc = SQLITE_OK;
4799 }else{
4800 rc = pager_stmt_playback(pPager);
4801 }
danielk19773b8a05f2007-03-19 17:44:26 +00004802 sqlite3PagerStmtCommit(pPager);
drh663fc632002-02-02 18:49:19 +00004803 }else{
4804 rc = SQLITE_OK;
4805 }
drhac69b052004-05-12 13:30:07 +00004806 pPager->stmtAutoopen = 0;
drh86f8c192007-08-22 00:39:19 +00004807 pagerLeave(pPager);
drhfa86c412002-02-02 15:01:15 +00004808 return rc;
4809}
4810
drh73509ee2003-04-06 20:44:45 +00004811/*
4812** Return the full pathname of the database file.
4813*/
danielk19773b8a05f2007-03-19 17:44:26 +00004814const char *sqlite3PagerFilename(Pager *pPager){
drh73509ee2003-04-06 20:44:45 +00004815 return pPager->zFilename;
4816}
4817
drhb20ea9d2004-02-09 01:20:36 +00004818/*
drhd0679ed2007-08-28 22:24:34 +00004819** Return the VFS structure for the pager.
4820*/
4821const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
4822 return pPager->pVfs;
4823}
4824
4825/*
danielk19775865e3d2004-06-14 06:03:57 +00004826** Return the directory of the database file.
4827*/
danielk19773b8a05f2007-03-19 17:44:26 +00004828const char *sqlite3PagerDirname(Pager *pPager){
danielk19775865e3d2004-06-14 06:03:57 +00004829 return pPager->zDirectory;
4830}
4831
4832/*
4833** Return the full pathname of the journal file.
4834*/
danielk19773b8a05f2007-03-19 17:44:26 +00004835const char *sqlite3PagerJournalname(Pager *pPager){
danielk19775865e3d2004-06-14 06:03:57 +00004836 return pPager->zJournal;
4837}
4838
4839/*
drh2c8997b2005-08-27 16:36:48 +00004840** Return true if fsync() calls are disabled for this pager. Return FALSE
4841** if fsync()s are executed normally.
4842*/
danielk19773b8a05f2007-03-19 17:44:26 +00004843int sqlite3PagerNosync(Pager *pPager){
drh2c8997b2005-08-27 16:36:48 +00004844 return pPager->noSync;
4845}
4846
drh7c4ac0c2007-04-05 11:25:58 +00004847#ifdef SQLITE_HAS_CODEC
drh2c8997b2005-08-27 16:36:48 +00004848/*
drhb20ea9d2004-02-09 01:20:36 +00004849** Set the codec for this pager
4850*/
danielk19773b8a05f2007-03-19 17:44:26 +00004851void sqlite3PagerSetCodec(
drhb20ea9d2004-02-09 01:20:36 +00004852 Pager *pPager,
drhc001c582006-03-06 18:23:16 +00004853 void *(*xCodec)(void*,void*,Pgno,int),
drhb20ea9d2004-02-09 01:20:36 +00004854 void *pCodecArg
4855){
4856 pPager->xCodec = xCodec;
4857 pPager->pCodecArg = pCodecArg;
4858}
drh7c4ac0c2007-04-05 11:25:58 +00004859#endif
drhb20ea9d2004-02-09 01:20:36 +00004860
danielk1977687566d2004-11-02 12:56:41 +00004861#ifndef SQLITE_OMIT_AUTOVACUUM
4862/*
drh5e385312007-06-16 04:42:12 +00004863** Move the page pPg to location pgno in the file.
danielk1977687566d2004-11-02 12:56:41 +00004864**
drh5e385312007-06-16 04:42:12 +00004865** There must be no references to the page previously located at
4866** pgno (which we call pPgOld) though that page is allowed to be
4867** in cache. If the page previous located at pgno is not already
4868** in the rollback journal, it is not put there by by this routine.
danielk1977687566d2004-11-02 12:56:41 +00004869**
drh5e385312007-06-16 04:42:12 +00004870** References to the page pPg remain valid. Updating any
4871** meta-data associated with pPg (i.e. data stored in the nExtra bytes
danielk1977687566d2004-11-02 12:56:41 +00004872** allocated along with the page) is the responsibility of the caller.
4873**
danielk19775fd057a2005-03-09 13:09:43 +00004874** A transaction must be active when this routine is called. It used to be
4875** required that a statement transaction was not active, but this restriction
4876** has been removed (CREATE INDEX needs to move a page when a statement
4877** transaction is active).
danielk1977687566d2004-11-02 12:56:41 +00004878*/
danielk19773b8a05f2007-03-19 17:44:26 +00004879int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno){
drh5e385312007-06-16 04:42:12 +00004880 PgHdr *pPgOld; /* The page being overwritten. */
danielk1977f5fdda82004-11-03 08:44:05 +00004881 int h;
danielk197794daf7f2004-11-08 09:26:09 +00004882 Pgno needSyncPgno = 0;
danielk1977687566d2004-11-02 12:56:41 +00004883
drh86f8c192007-08-22 00:39:19 +00004884 pagerEnter(pPager);
danielk1977687566d2004-11-02 12:56:41 +00004885 assert( pPg->nRef>0 );
4886
drh4f0c5872007-03-26 22:05:01 +00004887 PAGERTRACE5("MOVE %d page %d (needSync=%d) moves to %d\n",
danielk1977599fcba2004-11-08 07:13:13 +00004888 PAGERID(pPager), pPg->pgno, pPg->needSync, pgno);
drhb0603412007-02-28 04:47:26 +00004889 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
danielk1977ef73ee92004-11-06 12:26:07 +00004890
danielk1977b4626a32007-04-28 15:47:43 +00004891 pager_get_content(pPg);
danielk197794daf7f2004-11-08 09:26:09 +00004892 if( pPg->needSync ){
4893 needSyncPgno = pPg->pgno;
drh4f0aee42007-06-16 18:39:41 +00004894 assert( pPg->inJournal || (int)pgno>pPager->origDbSize );
danielk197794daf7f2004-11-08 09:26:09 +00004895 assert( pPg->dirty );
danielk1977ae825582004-11-23 09:06:55 +00004896 assert( pPager->needSync );
danielk197794daf7f2004-11-08 09:26:09 +00004897 }
4898
danielk1977687566d2004-11-02 12:56:41 +00004899 /* Unlink pPg from it's hash-chain */
danielk1977f5fdda82004-11-03 08:44:05 +00004900 unlinkHashChain(pPager, pPg);
danielk1977687566d2004-11-02 12:56:41 +00004901
danielk1977ef73ee92004-11-06 12:26:07 +00004902 /* If the cache contains a page with page-number pgno, remove it
danielk1977599fcba2004-11-08 07:13:13 +00004903 ** from it's hash chain. Also, if the PgHdr.needSync was set for
4904 ** page pgno before the 'move' operation, it needs to be retained
4905 ** for the page moved there.
danielk1977f5fdda82004-11-03 08:44:05 +00004906 */
drh5e385312007-06-16 04:42:12 +00004907 pPg->needSync = 0;
danielk1977687566d2004-11-02 12:56:41 +00004908 pPgOld = pager_lookup(pPager, pgno);
4909 if( pPgOld ){
danielk1977f5fdda82004-11-03 08:44:05 +00004910 assert( pPgOld->nRef==0 );
4911 unlinkHashChain(pPager, pPgOld);
drh605ad8f2006-05-03 23:34:05 +00004912 makeClean(pPgOld);
drh5e385312007-06-16 04:42:12 +00004913 pPg->needSync = pPgOld->needSync;
4914 }else{
4915 pPg->needSync = 0;
4916 }
4917 if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
4918 pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
drh5e385312007-06-16 04:42:12 +00004919 }else{
4920 pPg->inJournal = 0;
drh732c8172007-06-16 11:17:45 +00004921 assert( pPg->needSync==0 || (int)pgno>pPager->origDbSize );
danielk1977687566d2004-11-02 12:56:41 +00004922 }
4923
danielk1977f5fdda82004-11-03 08:44:05 +00004924 /* Change the page number for pPg and insert it into the new hash-chain. */
drh3765df42006-06-28 18:18:09 +00004925 assert( pgno!=0 );
danielk1977f5fdda82004-11-03 08:44:05 +00004926 pPg->pgno = pgno;
drh8ca0c722006-05-07 17:49:38 +00004927 h = pgno & (pPager->nHash-1);
danielk1977f5fdda82004-11-03 08:44:05 +00004928 if( pPager->aHash[h] ){
4929 assert( pPager->aHash[h]->pPrevHash==0 );
4930 pPager->aHash[h]->pPrevHash = pPg;
4931 }
4932 pPg->pNextHash = pPager->aHash[h];
4933 pPager->aHash[h] = pPg;
4934 pPg->pPrevHash = 0;
4935
drh605ad8f2006-05-03 23:34:05 +00004936 makeDirty(pPg);
danielk1977687566d2004-11-02 12:56:41 +00004937 pPager->dirtyCache = 1;
4938
danielk197794daf7f2004-11-08 09:26:09 +00004939 if( needSyncPgno ){
4940 /* If needSyncPgno is non-zero, then the journal file needs to be
4941 ** sync()ed before any data is written to database file page needSyncPgno.
4942 ** Currently, no such page exists in the page-cache and the
4943 ** Pager.aInJournal bit has been set. This needs to be remedied by loading
4944 ** the page into the pager-cache and setting the PgHdr.needSync flag.
danielk1977ae825582004-11-23 09:06:55 +00004945 **
danielk19773b8a05f2007-03-19 17:44:26 +00004946 ** The sqlite3PagerGet() call may cause the journal to sync. So make
danielk1977ae825582004-11-23 09:06:55 +00004947 ** sure the Pager.needSync flag is set too.
danielk197794daf7f2004-11-08 09:26:09 +00004948 */
4949 int rc;
danielk19773b8a05f2007-03-19 17:44:26 +00004950 PgHdr *pPgHdr;
danielk1977ae825582004-11-23 09:06:55 +00004951 assert( pPager->needSync );
danielk19773b8a05f2007-03-19 17:44:26 +00004952 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
danielk197794daf7f2004-11-08 09:26:09 +00004953 if( rc!=SQLITE_OK ) return rc;
danielk1977ae825582004-11-23 09:06:55 +00004954 pPager->needSync = 1;
danielk19773b8a05f2007-03-19 17:44:26 +00004955 pPgHdr->needSync = 1;
4956 pPgHdr->inJournal = 1;
4957 makeDirty(pPgHdr);
4958 sqlite3PagerUnref(pPgHdr);
danielk197794daf7f2004-11-08 09:26:09 +00004959 }
4960
drh86f8c192007-08-22 00:39:19 +00004961 pagerLeave(pPager);
danielk1977687566d2004-11-02 12:56:41 +00004962 return SQLITE_OK;
4963}
4964#endif
4965
danielk19773b8a05f2007-03-19 17:44:26 +00004966/*
4967** Return a pointer to the data for the specified page.
4968*/
4969void *sqlite3PagerGetData(DbPage *pPg){
4970 return PGHDR_TO_DATA(pPg);
4971}
4972
4973/*
4974** Return a pointer to the Pager.nExtra bytes of "extra" space
4975** allocated along with the specified page.
4976*/
4977void *sqlite3PagerGetExtra(DbPage *pPg){
4978 Pager *pPager = pPg->pPager;
4979 return (pPager?PGHDR_TO_EXTRA(pPg, pPager):0);
4980}
4981
danielk197741483462007-03-24 16:45:04 +00004982/*
4983** Get/set the locking-mode for this pager. Parameter eMode must be one
4984** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
4985** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
4986** the locking-mode is set to the value specified.
4987**
4988** The returned value is either PAGER_LOCKINGMODE_NORMAL or
4989** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
4990** locking-mode.
4991*/
4992int sqlite3PagerLockingMode(Pager *pPager, int eMode){
drh369339d2007-03-30 16:01:55 +00004993 assert( eMode==PAGER_LOCKINGMODE_QUERY
4994 || eMode==PAGER_LOCKINGMODE_NORMAL
4995 || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
4996 assert( PAGER_LOCKINGMODE_QUERY<0 );
4997 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
4998 if( eMode>=0 && !pPager->tempFile ){
danielk197741483462007-03-24 16:45:04 +00004999 pPager->exclusiveMode = eMode;
5000 }
5001 return (int)pPager->exclusiveMode;
5002}
5003
dougcurrie81c95ef2004-06-18 23:21:47 +00005004#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
drh89ac8c12004-06-09 14:17:20 +00005005/*
5006** Return the current state of the file lock for the given pager.
5007** The return value is one of NO_LOCK, SHARED_LOCK, RESERVED_LOCK,
5008** PENDING_LOCK, or EXCLUSIVE_LOCK.
5009*/
danielk19773b8a05f2007-03-19 17:44:26 +00005010int sqlite3PagerLockstate(Pager *pPager){
drh054889e2005-11-30 03:20:31 +00005011 return sqlite3OsLockState(pPager->fd);
drh89ac8c12004-06-09 14:17:20 +00005012}
5013#endif
5014
danielk197793758c82005-01-21 08:13:14 +00005015#ifdef SQLITE_DEBUG
drhdd793422001-06-28 01:54:48 +00005016/*
5017** Print a listing of all referenced pages and their ref count.
5018*/
danielk19773b8a05f2007-03-19 17:44:26 +00005019void sqlite3PagerRefdump(Pager *pPager){
drhdd793422001-06-28 01:54:48 +00005020 PgHdr *pPg;
5021 for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
5022 if( pPg->nRef<=0 ) continue;
drhfe63d1c2004-09-08 20:13:04 +00005023 sqlite3DebugPrintf("PAGE %3d addr=%p nRef=%d\n",
5024 pPg->pgno, PGHDR_TO_DATA(pPg), pPg->nRef);
drhdd793422001-06-28 01:54:48 +00005025 }
5026}
5027#endif
drh2e66f0b2005-04-28 17:18:48 +00005028
5029#endif /* SQLITE_OMIT_DISKIO */