Annotation of embedaddon/php/ext/sqlite/libsqlite/src/pager.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2001 September 15
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** This is the implementation of the page cache subsystem or "pager".
13: **
14: ** 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.
20: **
21: ** @(#) $Id: pager.c 203289 2005-12-20 15:26:26Z iliaa $
22: */
23: #include "os.h" /* Must be first to enable large file support */
24: #include "sqliteInt.h"
25: #include "pager.h"
26: #include <assert.h>
27: #include <string.h>
28:
29: /*
30: ** Macros for troubleshooting. Normally turned off
31: */
32: #if 0
33: static Pager *mainPager = 0;
34: #define SET_PAGER(X) if( mainPager==0 ) mainPager = (X)
35: #define CLR_PAGER(X) if( mainPager==(X) ) mainPager = 0
36: #define TRACE1(X) if( pPager==mainPager ) fprintf(stderr,X)
37: #define TRACE2(X,Y) if( pPager==mainPager ) fprintf(stderr,X,Y)
38: #define TRACE3(X,Y,Z) if( pPager==mainPager ) fprintf(stderr,X,Y,Z)
39: #else
40: #define SET_PAGER(X)
41: #define CLR_PAGER(X)
42: #define TRACE1(X)
43: #define TRACE2(X,Y)
44: #define TRACE3(X,Y,Z)
45: #endif
46:
47:
48: /*
49: ** The page cache as a whole is always in one of the following
50: ** states:
51: **
52: ** SQLITE_UNLOCK The page cache is not currently reading or
53: ** writing the database file. There is no
54: ** data held in memory. This is the initial
55: ** state.
56: **
57: ** SQLITE_READLOCK The page cache is reading the database.
58: ** Writing is not permitted. There can be
59: ** multiple readers accessing the same database
60: ** file at the same time.
61: **
62: ** SQLITE_WRITELOCK The page cache is writing the database.
63: ** Access is exclusive. No other processes or
64: ** threads can be reading or writing while one
65: ** process is writing.
66: **
67: ** The page cache comes up in SQLITE_UNLOCK. The first time a
68: ** sqlite_page_get() occurs, the state transitions to SQLITE_READLOCK.
69: ** After all pages have been released using sqlite_page_unref(),
70: ** the state transitions back to SQLITE_UNLOCK. The first time
71: ** that sqlite_page_write() is called, the state transitions to
72: ** SQLITE_WRITELOCK. (Note that sqlite_page_write() can only be
73: ** called on an outstanding page which means that the pager must
74: ** be in SQLITE_READLOCK before it transitions to SQLITE_WRITELOCK.)
75: ** The sqlite_page_rollback() and sqlite_page_commit() functions
76: ** transition the state from SQLITE_WRITELOCK back to SQLITE_READLOCK.
77: */
78: #define SQLITE_UNLOCK 0
79: #define SQLITE_READLOCK 1
80: #define SQLITE_WRITELOCK 2
81:
82:
83: /*
84: ** Each in-memory image of a page begins with the following header.
85: ** This header is only visible to this pager module. The client
86: ** code that calls pager sees only the data that follows the header.
87: **
88: ** Client code should call sqlitepager_write() on a page prior to making
89: ** any modifications to that page. The first time sqlitepager_write()
90: ** is called, the original page contents are written into the rollback
91: ** journal and PgHdr.inJournal and PgHdr.needSync are set. Later, once
92: ** the journal page has made it onto the disk surface, PgHdr.needSync
93: ** is cleared. The modified page cannot be written back into the original
94: ** database file until the journal pages has been synced to disk and the
95: ** PgHdr.needSync has been cleared.
96: **
97: ** The PgHdr.dirty flag is set when sqlitepager_write() is called and
98: ** is cleared again when the page content is written back to the original
99: ** database file.
100: */
101: typedef struct PgHdr PgHdr;
102: struct PgHdr {
103: Pager *pPager; /* The pager to which this page belongs */
104: Pgno pgno; /* The page number for this page */
105: PgHdr *pNextHash, *pPrevHash; /* Hash collision chain for PgHdr.pgno */
106: int nRef; /* Number of users of this page */
107: PgHdr *pNextFree, *pPrevFree; /* Freelist of pages where nRef==0 */
108: PgHdr *pNextAll, *pPrevAll; /* A list of all pages */
109: PgHdr *pNextCkpt, *pPrevCkpt; /* List of pages in the checkpoint journal */
110: u8 inJournal; /* TRUE if has been written to journal */
111: u8 inCkpt; /* TRUE if written to the checkpoint journal */
112: u8 dirty; /* TRUE if we need to write back changes */
113: u8 needSync; /* Sync journal before writing this page */
114: u8 alwaysRollback; /* Disable dont_rollback() for this page */
115: PgHdr *pDirty; /* Dirty pages sorted by PgHdr.pgno */
116: /* SQLITE_PAGE_SIZE bytes of page data follow this header */
117: /* Pager.nExtra bytes of local data follow the page data */
118: };
119:
120:
121: /*
122: ** A macro used for invoking the codec if there is one
123: */
124: #ifdef SQLITE_HAS_CODEC
125: # define CODEC(P,D,N,X) if( P->xCodec ){ P->xCodec(P->pCodecArg,D,N,X); }
126: #else
127: # define CODEC(P,D,N,X)
128: #endif
129:
130: /*
131: ** Convert a pointer to a PgHdr into a pointer to its data
132: ** and back again.
133: */
134: #define PGHDR_TO_DATA(P) ((void*)(&(P)[1]))
135: #define DATA_TO_PGHDR(D) (&((PgHdr*)(D))[-1])
136: #define PGHDR_TO_EXTRA(P) ((void*)&((char*)(&(P)[1]))[SQLITE_PAGE_SIZE])
137:
138: /*
139: ** How big to make the hash table used for locating in-memory pages
140: ** by page number.
141: */
142: #define N_PG_HASH 2048
143:
144: /*
145: ** Hash a page number
146: */
147: #define pager_hash(PN) ((PN)&(N_PG_HASH-1))
148:
149: /*
150: ** A open page cache is an instance of the following structure.
151: */
152: struct Pager {
153: char *zFilename; /* Name of the database file */
154: char *zJournal; /* Name of the journal file */
155: char *zDirectory; /* Directory hold database and journal files */
156: OsFile fd, jfd; /* File descriptors for database and journal */
157: OsFile cpfd; /* File descriptor for the checkpoint journal */
158: int dbSize; /* Number of pages in the file */
159: int origDbSize; /* dbSize before the current change */
160: int ckptSize; /* Size of database (in pages) at ckpt_begin() */
161: off_t ckptJSize; /* Size of journal at ckpt_begin() */
162: int nRec; /* Number of pages written to the journal */
163: u32 cksumInit; /* Quasi-random value added to every checksum */
164: int ckptNRec; /* Number of records in the checkpoint journal */
165: int nExtra; /* Add this many bytes to each in-memory page */
166: void (*xDestructor)(void*); /* Call this routine when freeing pages */
167: int nPage; /* Total number of in-memory pages */
168: int nRef; /* Number of in-memory pages with PgHdr.nRef>0 */
169: int mxPage; /* Maximum number of pages to hold in cache */
170: int nHit, nMiss, nOvfl; /* Cache hits, missing, and LRU overflows */
171: void (*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
172: void *pCodecArg; /* First argument to xCodec() */
173: u8 journalOpen; /* True if journal file descriptors is valid */
174: u8 journalStarted; /* True if header of journal is synced */
175: u8 useJournal; /* Use a rollback journal on this file */
176: u8 ckptOpen; /* True if the checkpoint journal is open */
177: u8 ckptInUse; /* True we are in a checkpoint */
178: u8 ckptAutoopen; /* Open ckpt journal when main journal is opened*/
179: u8 noSync; /* Do not sync the journal if true */
180: u8 fullSync; /* Do extra syncs of the journal for robustness */
181: u8 state; /* SQLITE_UNLOCK, _READLOCK or _WRITELOCK */
182: u8 errMask; /* One of several kinds of errors */
183: u8 tempFile; /* zFilename is a temporary file */
184: u8 readOnly; /* True for a read-only database */
185: u8 needSync; /* True if an fsync() is needed on the journal */
186: u8 dirtyFile; /* True if database file has changed in any way */
187: u8 alwaysRollback; /* Disable dont_rollback() for all pages */
188: u8 *aInJournal; /* One bit for each page in the database file */
189: u8 *aInCkpt; /* One bit for each page in the database */
190: PgHdr *pFirst, *pLast; /* List of free pages */
191: PgHdr *pFirstSynced; /* First free page with PgHdr.needSync==0 */
192: PgHdr *pAll; /* List of all pages */
193: PgHdr *pCkpt; /* List of pages in the checkpoint journal */
194: PgHdr *aHash[N_PG_HASH]; /* Hash table to map page number of PgHdr */
195: };
196:
197: /*
198: ** These are bits that can be set in Pager.errMask.
199: */
200: #define PAGER_ERR_FULL 0x01 /* a write() failed */
201: #define PAGER_ERR_MEM 0x02 /* malloc() failed */
202: #define PAGER_ERR_LOCK 0x04 /* error in the locking protocol */
203: #define PAGER_ERR_CORRUPT 0x08 /* database or journal corruption */
204: #define PAGER_ERR_DISK 0x10 /* general disk I/O error - bad hard drive? */
205:
206: /*
207: ** The journal file contains page records in the following
208: ** format.
209: **
210: ** Actually, this structure is the complete page record for pager
211: ** formats less than 3. Beginning with format 3, this record is surrounded
212: ** by two checksums.
213: */
214: typedef struct PageRecord PageRecord;
215: struct PageRecord {
216: Pgno pgno; /* The page number */
217: char aData[SQLITE_PAGE_SIZE]; /* Original data for page pgno */
218: };
219:
220: /*
221: ** Journal files begin with the following magic string. The data
222: ** was obtained from /dev/random. It is used only as a sanity check.
223: **
224: ** There are three journal formats (so far). The 1st journal format writes
225: ** 32-bit integers in the byte-order of the host machine. New
226: ** formats writes integers as big-endian. All new journals use the
227: ** new format, but we have to be able to read an older journal in order
228: ** to rollback journals created by older versions of the library.
229: **
230: ** The 3rd journal format (added for 2.8.0) adds additional sanity
231: ** checking information to the journal. If the power fails while the
232: ** journal is being written, semi-random garbage data might appear in
233: ** the journal file after power is restored. If an attempt is then made
234: ** to roll the journal back, the database could be corrupted. The additional
235: ** sanity checking data is an attempt to discover the garbage in the
236: ** journal and ignore it.
237: **
238: ** The sanity checking information for the 3rd journal format consists
239: ** of a 32-bit checksum on each page of data. The checksum covers both
240: ** the page number and the SQLITE_PAGE_SIZE bytes of data for the page.
241: ** This cksum is initialized to a 32-bit random value that appears in the
242: ** journal file right after the header. The random initializer is important,
243: ** because garbage data that appears at the end of a journal is likely
244: ** data that was once in other files that have now been deleted. If the
245: ** garbage data came from an obsolete journal file, the checksums might
246: ** be correct. But by initializing the checksum to random value which
247: ** is different for every journal, we minimize that risk.
248: */
249: static const unsigned char aJournalMagic1[] = {
250: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd4,
251: };
252: static const unsigned char aJournalMagic2[] = {
253: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd5,
254: };
255: static const unsigned char aJournalMagic3[] = {
256: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd6,
257: };
258: #define JOURNAL_FORMAT_1 1
259: #define JOURNAL_FORMAT_2 2
260: #define JOURNAL_FORMAT_3 3
261:
262: /*
263: ** The following integer determines what format to use when creating
264: ** new primary journal files. By default we always use format 3.
265: ** When testing, we can set this value to older journal formats in order to
266: ** make sure that newer versions of the library are able to rollback older
267: ** journal files.
268: **
269: ** Note that checkpoint journals always use format 2 and omit the header.
270: */
271: #ifdef SQLITE_TEST
272: int journal_format = 3;
273: #else
274: # define journal_format 3
275: #endif
276:
277: /*
278: ** The size of the header and of each page in the journal varies according
279: ** to which journal format is being used. The following macros figure out
280: ** the sizes based on format numbers.
281: */
282: #define JOURNAL_HDR_SZ(X) \
283: (sizeof(aJournalMagic1) + sizeof(Pgno) + ((X)>=3)*2*sizeof(u32))
284: #define JOURNAL_PG_SZ(X) \
285: (SQLITE_PAGE_SIZE + sizeof(Pgno) + ((X)>=3)*sizeof(u32))
286:
287: /*
288: ** Enable reference count tracking here:
289: */
290: #ifdef SQLITE_TEST
291: int pager_refinfo_enable = 0;
292: static void pager_refinfo(PgHdr *p){
293: static int cnt = 0;
294: if( !pager_refinfo_enable ) return;
295: printf(
296: "REFCNT: %4d addr=0x%08x nRef=%d\n",
297: p->pgno, (int)PGHDR_TO_DATA(p), p->nRef
298: );
299: cnt++; /* Something to set a breakpoint on */
300: }
301: # define REFINFO(X) pager_refinfo(X)
302: #else
303: # define REFINFO(X)
304: #endif
305:
306: /*
307: ** Read a 32-bit integer from the given file descriptor. Store the integer
308: ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
309: ** error code is something goes wrong.
310: **
311: ** If the journal format is 2 or 3, read a big-endian integer. If the
312: ** journal format is 1, read an integer in the native byte-order of the
313: ** host machine.
314: */
315: static int read32bits(int format, OsFile *fd, u32 *pRes){
316: u32 res;
317: int rc;
318: rc = sqliteOsRead(fd, &res, sizeof(res));
319: if( rc==SQLITE_OK && format>JOURNAL_FORMAT_1 ){
320: unsigned char ac[4];
321: memcpy(ac, &res, 4);
322: res = (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3];
323: }
324: *pRes = res;
325: return rc;
326: }
327:
328: /*
329: ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
330: ** on success or an error code is something goes wrong.
331: **
332: ** If the journal format is 2 or 3, write the integer as 4 big-endian
333: ** bytes. If the journal format is 1, write the integer in the native
334: ** byte order. In normal operation, only formats 2 and 3 are used.
335: ** Journal format 1 is only used for testing.
336: */
337: static int write32bits(OsFile *fd, u32 val){
338: unsigned char ac[4];
339: if( journal_format<=1 ){
340: return sqliteOsWrite(fd, &val, 4);
341: }
342: ac[0] = (val>>24) & 0xff;
343: ac[1] = (val>>16) & 0xff;
344: ac[2] = (val>>8) & 0xff;
345: ac[3] = val & 0xff;
346: return sqliteOsWrite(fd, ac, 4);
347: }
348:
349: /*
350: ** Write a 32-bit integer into a page header right before the
351: ** page data. This will overwrite the PgHdr.pDirty pointer.
352: **
353: ** The integer is big-endian for formats 2 and 3 and native byte order
354: ** for journal format 1.
355: */
356: static void store32bits(u32 val, PgHdr *p, int offset){
357: unsigned char *ac;
358: ac = &((unsigned char*)PGHDR_TO_DATA(p))[offset];
359: if( journal_format<=1 ){
360: memcpy(ac, &val, 4);
361: }else{
362: ac[0] = (val>>24) & 0xff;
363: ac[1] = (val>>16) & 0xff;
364: ac[2] = (val>>8) & 0xff;
365: ac[3] = val & 0xff;
366: }
367: }
368:
369:
370: /*
371: ** Convert the bits in the pPager->errMask into an approprate
372: ** return code.
373: */
374: static int pager_errcode(Pager *pPager){
375: int rc = SQLITE_OK;
376: if( pPager->errMask & PAGER_ERR_LOCK ) rc = SQLITE_PROTOCOL;
377: if( pPager->errMask & PAGER_ERR_DISK ) rc = SQLITE_IOERR;
378: if( pPager->errMask & PAGER_ERR_FULL ) rc = SQLITE_FULL;
379: if( pPager->errMask & PAGER_ERR_MEM ) rc = SQLITE_NOMEM;
380: if( pPager->errMask & PAGER_ERR_CORRUPT ) rc = SQLITE_CORRUPT;
381: return rc;
382: }
383:
384: /*
385: ** Add or remove a page from the list of all pages that are in the
386: ** checkpoint journal.
387: **
388: ** The Pager keeps a separate list of pages that are currently in
389: ** the checkpoint journal. This helps the sqlitepager_ckpt_commit()
390: ** routine run MUCH faster for the common case where there are many
391: ** pages in memory but only a few are in the checkpoint journal.
392: */
393: static void page_add_to_ckpt_list(PgHdr *pPg){
394: Pager *pPager = pPg->pPager;
395: if( pPg->inCkpt ) return;
396: assert( pPg->pPrevCkpt==0 && pPg->pNextCkpt==0 );
397: pPg->pPrevCkpt = 0;
398: if( pPager->pCkpt ){
399: pPager->pCkpt->pPrevCkpt = pPg;
400: }
401: pPg->pNextCkpt = pPager->pCkpt;
402: pPager->pCkpt = pPg;
403: pPg->inCkpt = 1;
404: }
405: static void page_remove_from_ckpt_list(PgHdr *pPg){
406: if( !pPg->inCkpt ) return;
407: if( pPg->pPrevCkpt ){
408: assert( pPg->pPrevCkpt->pNextCkpt==pPg );
409: pPg->pPrevCkpt->pNextCkpt = pPg->pNextCkpt;
410: }else{
411: assert( pPg->pPager->pCkpt==pPg );
412: pPg->pPager->pCkpt = pPg->pNextCkpt;
413: }
414: if( pPg->pNextCkpt ){
415: assert( pPg->pNextCkpt->pPrevCkpt==pPg );
416: pPg->pNextCkpt->pPrevCkpt = pPg->pPrevCkpt;
417: }
418: pPg->pNextCkpt = 0;
419: pPg->pPrevCkpt = 0;
420: pPg->inCkpt = 0;
421: }
422:
423: /*
424: ** Find a page in the hash table given its page number. Return
425: ** a pointer to the page or NULL if not found.
426: */
427: static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
428: PgHdr *p = pPager->aHash[pager_hash(pgno)];
429: while( p && p->pgno!=pgno ){
430: p = p->pNextHash;
431: }
432: return p;
433: }
434:
435: /*
436: ** Unlock the database and clear the in-memory cache. This routine
437: ** sets the state of the pager back to what it was when it was first
438: ** opened. Any outstanding pages are invalidated and subsequent attempts
439: ** to access those pages will likely result in a coredump.
440: */
441: static void pager_reset(Pager *pPager){
442: PgHdr *pPg, *pNext;
443: for(pPg=pPager->pAll; pPg; pPg=pNext){
444: pNext = pPg->pNextAll;
445: sqliteFree(pPg);
446: }
447: pPager->pFirst = 0;
448: pPager->pFirstSynced = 0;
449: pPager->pLast = 0;
450: pPager->pAll = 0;
451: memset(pPager->aHash, 0, sizeof(pPager->aHash));
452: pPager->nPage = 0;
453: if( pPager->state>=SQLITE_WRITELOCK ){
454: sqlitepager_rollback(pPager);
455: }
456: sqliteOsUnlock(&pPager->fd);
457: pPager->state = SQLITE_UNLOCK;
458: pPager->dbSize = -1;
459: pPager->nRef = 0;
460: assert( pPager->journalOpen==0 );
461: }
462:
463: /*
464: ** When this routine is called, the pager has the journal file open and
465: ** a write lock on the database. This routine releases the database
466: ** write lock and acquires a read lock in its place. The journal file
467: ** is deleted and closed.
468: **
469: ** TODO: Consider keeping the journal file open for temporary databases.
470: ** This might give a performance improvement on windows where opening
471: ** a file is an expensive operation.
472: */
473: static int pager_unwritelock(Pager *pPager){
474: int rc;
475: PgHdr *pPg;
476: if( pPager->state<SQLITE_WRITELOCK ) return SQLITE_OK;
477: sqlitepager_ckpt_commit(pPager);
478: if( pPager->ckptOpen ){
479: sqliteOsClose(&pPager->cpfd);
480: pPager->ckptOpen = 0;
481: }
482: if( pPager->journalOpen ){
483: sqliteOsClose(&pPager->jfd);
484: pPager->journalOpen = 0;
485: sqliteOsDelete(pPager->zJournal);
486: sqliteFree( pPager->aInJournal );
487: pPager->aInJournal = 0;
488: for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
489: pPg->inJournal = 0;
490: pPg->dirty = 0;
491: pPg->needSync = 0;
492: }
493: }else{
494: assert( pPager->dirtyFile==0 || pPager->useJournal==0 );
495: }
496: rc = sqliteOsReadLock(&pPager->fd);
497: if( rc==SQLITE_OK ){
498: pPager->state = SQLITE_READLOCK;
499: }else{
500: /* This can only happen if a process does a BEGIN, then forks and the
501: ** child process does the COMMIT. Because of the semantics of unix
502: ** file locking, the unlock will fail.
503: */
504: pPager->state = SQLITE_UNLOCK;
505: }
506: return rc;
507: }
508:
509: /*
510: ** Compute and return a checksum for the page of data.
511: **
512: ** This is not a real checksum. It is really just the sum of the
513: ** random initial value and the page number. We considered do a checksum
514: ** of the database, but that was found to be too slow.
515: */
516: static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){
517: u32 cksum = pPager->cksumInit + pgno;
518: return cksum;
519: }
520:
521: /*
522: ** Read a single page from the journal file opened on file descriptor
523: ** jfd. Playback this one page.
524: **
525: ** There are three different journal formats. The format parameter determines
526: ** which format is used by the journal that is played back.
527: */
528: static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int format){
529: int rc;
530: PgHdr *pPg; /* An existing page in the cache */
531: PageRecord pgRec;
532: u32 cksum;
533:
534: rc = read32bits(format, jfd, &pgRec.pgno);
535: if( rc!=SQLITE_OK ) return rc;
536: rc = sqliteOsRead(jfd, &pgRec.aData, sizeof(pgRec.aData));
537: if( rc!=SQLITE_OK ) return rc;
538:
539: /* Sanity checking on the page. This is more important that I originally
540: ** thought. If a power failure occurs while the journal is being written,
541: ** it could cause invalid data to be written into the journal. We need to
542: ** detect this invalid data (with high probability) and ignore it.
543: */
544: if( pgRec.pgno==0 ){
545: return SQLITE_DONE;
546: }
547: if( pgRec.pgno>(unsigned)pPager->dbSize ){
548: return SQLITE_OK;
549: }
550: if( format>=JOURNAL_FORMAT_3 ){
551: rc = read32bits(format, jfd, &cksum);
552: if( rc ) return rc;
553: if( pager_cksum(pPager, pgRec.pgno, pgRec.aData)!=cksum ){
554: return SQLITE_DONE;
555: }
556: }
557:
558: /* Playback the page. Update the in-memory copy of the page
559: ** at the same time, if there is one.
560: */
561: pPg = pager_lookup(pPager, pgRec.pgno);
562: TRACE2("PLAYBACK %d\n", pgRec.pgno);
563: sqliteOsSeek(&pPager->fd, (pgRec.pgno-1)*(off_t)SQLITE_PAGE_SIZE);
564: rc = sqliteOsWrite(&pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE);
565: if( pPg ){
566: /* No page should ever be rolled back that is in use, except for page
567: ** 1 which is held in use in order to keep the lock on the database
568: ** active.
569: */
570: assert( pPg->nRef==0 || pPg->pgno==1 );
571: memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE);
572: memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
573: pPg->dirty = 0;
574: pPg->needSync = 0;
575: CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
576: }
577: return rc;
578: }
579:
580: /*
581: ** Playback the journal and thus restore the database file to
582: ** the state it was in before we started making changes.
583: **
584: ** The journal file format is as follows:
585: **
586: ** * 8 byte prefix. One of the aJournalMagic123 vectors defined
587: ** above. The format of the journal file is determined by which
588: ** of the three prefix vectors is seen.
589: ** * 4 byte big-endian integer which is the number of valid page records
590: ** in the journal. If this value is 0xffffffff, then compute the
591: ** number of page records from the journal size. This field appears
592: ** in format 3 only.
593: ** * 4 byte big-endian integer which is the initial value for the
594: ** sanity checksum. This field appears in format 3 only.
595: ** * 4 byte integer which is the number of pages to truncate the
596: ** database to during a rollback.
597: ** * Zero or more pages instances, each as follows:
598: ** + 4 byte page number.
599: ** + SQLITE_PAGE_SIZE bytes of data.
600: ** + 4 byte checksum (format 3 only)
601: **
602: ** When we speak of the journal header, we mean the first 4 bullets above.
603: ** Each entry in the journal is an instance of the 5th bullet. Note that
604: ** bullets 2 and 3 only appear in format-3 journals.
605: **
606: ** Call the value from the second bullet "nRec". nRec is the number of
607: ** valid page entries in the journal. In most cases, you can compute the
608: ** value of nRec from the size of the journal file. But if a power
609: ** failure occurred while the journal was being written, it could be the
610: ** case that the size of the journal file had already been increased but
611: ** the extra entries had not yet made it safely to disk. In such a case,
612: ** the value of nRec computed from the file size would be too large. For
613: ** that reason, we always use the nRec value in the header.
614: **
615: ** If the nRec value is 0xffffffff it means that nRec should be computed
616: ** from the file size. This value is used when the user selects the
617: ** no-sync option for the journal. A power failure could lead to corruption
618: ** in this case. But for things like temporary table (which will be
619: ** deleted when the power is restored) we don't care.
620: **
621: ** Journal formats 1 and 2 do not have an nRec value in the header so we
622: ** have to compute nRec from the file size. This has risks (as described
623: ** above) which is why all persistent tables have been changed to use
624: ** format 3.
625: **
626: ** If the file opened as the journal file is not a well-formed
627: ** journal file then the database will likely already be
628: ** corrupted, so the PAGER_ERR_CORRUPT bit is set in pPager->errMask
629: ** and SQLITE_CORRUPT is returned. If it all works, then this routine
630: ** returns SQLITE_OK.
631: */
632: static int pager_playback(Pager *pPager, int useJournalSize){
633: off_t szJ; /* Size of the journal file in bytes */
634: int nRec; /* Number of Records in the journal */
635: int i; /* Loop counter */
636: Pgno mxPg = 0; /* Size of the original file in pages */
637: int format; /* Format of the journal file. */
638: unsigned char aMagic[sizeof(aJournalMagic1)];
639: int rc;
640:
641: /* Figure out how many records are in the journal. Abort early if
642: ** the journal is empty.
643: */
644: assert( pPager->journalOpen );
645: sqliteOsSeek(&pPager->jfd, 0);
646: rc = sqliteOsFileSize(&pPager->jfd, &szJ);
647: if( rc!=SQLITE_OK ){
648: goto end_playback;
649: }
650:
651: /* If the journal file is too small to contain a complete header,
652: ** it must mean that the process that created the journal was just
653: ** beginning to write the journal file when it died. In that case,
654: ** the database file should have still been completely unchanged.
655: ** Nothing needs to be rolled back. We can safely ignore this journal.
656: */
657: if( szJ < sizeof(aMagic)+sizeof(Pgno) ){
658: goto end_playback;
659: }
660:
661: /* Read the beginning of the journal and truncate the
662: ** database file back to its original size.
663: */
664: rc = sqliteOsRead(&pPager->jfd, aMagic, sizeof(aMagic));
665: if( rc!=SQLITE_OK ){
666: rc = SQLITE_PROTOCOL;
667: goto end_playback;
668: }
669: if( memcmp(aMagic, aJournalMagic3, sizeof(aMagic))==0 ){
670: format = JOURNAL_FORMAT_3;
671: }else if( memcmp(aMagic, aJournalMagic2, sizeof(aMagic))==0 ){
672: format = JOURNAL_FORMAT_2;
673: }else if( memcmp(aMagic, aJournalMagic1, sizeof(aMagic))==0 ){
674: format = JOURNAL_FORMAT_1;
675: }else{
676: rc = SQLITE_PROTOCOL;
677: goto end_playback;
678: }
679: if( format>=JOURNAL_FORMAT_3 ){
680: if( szJ < sizeof(aMagic) + 3*sizeof(u32) ){
681: /* Ignore the journal if it is too small to contain a complete
682: ** header. We already did this test once above, but at the prior
683: ** test, we did not know the journal format and so we had to assume
684: ** the smallest possible header. Now we know the header is bigger
685: ** than the minimum so we test again.
686: */
687: goto end_playback;
688: }
689: rc = read32bits(format, &pPager->jfd, (u32*)&nRec);
690: if( rc ) goto end_playback;
691: rc = read32bits(format, &pPager->jfd, &pPager->cksumInit);
692: if( rc ) goto end_playback;
693: if( nRec==0xffffffff || useJournalSize ){
694: nRec = (szJ - JOURNAL_HDR_SZ(3))/JOURNAL_PG_SZ(3);
695: }
696: }else{
697: nRec = (szJ - JOURNAL_HDR_SZ(2))/JOURNAL_PG_SZ(2);
698: assert( nRec*JOURNAL_PG_SZ(2)+JOURNAL_HDR_SZ(2)==szJ );
699: }
700: rc = read32bits(format, &pPager->jfd, &mxPg);
701: if( rc!=SQLITE_OK ){
702: goto end_playback;
703: }
704: assert( pPager->origDbSize==0 || pPager->origDbSize==mxPg );
705: rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)mxPg);
706: if( rc!=SQLITE_OK ){
707: goto end_playback;
708: }
709: pPager->dbSize = mxPg;
710:
711: /* Copy original pages out of the journal and back into the database file.
712: */
713: for(i=0; i<nRec; i++){
714: rc = pager_playback_one_page(pPager, &pPager->jfd, format);
715: if( rc!=SQLITE_OK ){
716: if( rc==SQLITE_DONE ){
717: rc = SQLITE_OK;
718: }
719: break;
720: }
721: }
722:
723: /* Pages that have been written to the journal but never synced
724: ** where not restored by the loop above. We have to restore those
725: ** pages by reading them back from the original database.
726: */
727: if( rc==SQLITE_OK ){
728: PgHdr *pPg;
729: for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
730: char zBuf[SQLITE_PAGE_SIZE];
731: if( !pPg->dirty ) continue;
732: if( (int)pPg->pgno <= pPager->origDbSize ){
733: sqliteOsSeek(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)(pPg->pgno-1));
734: rc = sqliteOsRead(&pPager->fd, zBuf, SQLITE_PAGE_SIZE);
735: TRACE2("REFETCH %d\n", pPg->pgno);
736: CODEC(pPager, zBuf, pPg->pgno, 2);
737: if( rc ) break;
738: }else{
739: memset(zBuf, 0, SQLITE_PAGE_SIZE);
740: }
741: if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE) ){
742: memcpy(PGHDR_TO_DATA(pPg), zBuf, SQLITE_PAGE_SIZE);
743: memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
744: }
745: pPg->needSync = 0;
746: pPg->dirty = 0;
747: }
748: }
749:
750: end_playback:
751: if( rc!=SQLITE_OK ){
752: pager_unwritelock(pPager);
753: pPager->errMask |= PAGER_ERR_CORRUPT;
754: rc = SQLITE_CORRUPT;
755: }else{
756: rc = pager_unwritelock(pPager);
757: }
758: return rc;
759: }
760:
761: /*
762: ** Playback the checkpoint journal.
763: **
764: ** This is similar to playing back the transaction journal but with
765: ** a few extra twists.
766: **
767: ** (1) The number of pages in the database file at the start of
768: ** the checkpoint is stored in pPager->ckptSize, not in the
769: ** journal file itself.
770: **
771: ** (2) In addition to playing back the checkpoint journal, also
772: ** playback all pages of the transaction journal beginning
773: ** at offset pPager->ckptJSize.
774: */
775: static int pager_ckpt_playback(Pager *pPager){
776: off_t szJ; /* Size of the full journal */
777: int nRec; /* Number of Records */
778: int i; /* Loop counter */
779: int rc;
780:
781: /* Truncate the database back to its original size.
782: */
783: rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)pPager->ckptSize);
784: pPager->dbSize = pPager->ckptSize;
785:
786: /* Figure out how many records are in the checkpoint journal.
787: */
788: assert( pPager->ckptInUse && pPager->journalOpen );
789: sqliteOsSeek(&pPager->cpfd, 0);
790: nRec = pPager->ckptNRec;
791:
792: /* Copy original pages out of the checkpoint journal and back into the
793: ** database file. Note that the checkpoint journal always uses format
794: ** 2 instead of format 3 since it does not need to be concerned with
795: ** power failures corrupting the journal and can thus omit the checksums.
796: */
797: for(i=nRec-1; i>=0; i--){
798: rc = pager_playback_one_page(pPager, &pPager->cpfd, 2);
799: assert( rc!=SQLITE_DONE );
800: if( rc!=SQLITE_OK ) goto end_ckpt_playback;
801: }
802:
803: /* Figure out how many pages need to be copied out of the transaction
804: ** journal.
805: */
806: rc = sqliteOsSeek(&pPager->jfd, pPager->ckptJSize);
807: if( rc!=SQLITE_OK ){
808: goto end_ckpt_playback;
809: }
810: rc = sqliteOsFileSize(&pPager->jfd, &szJ);
811: if( rc!=SQLITE_OK ){
812: goto end_ckpt_playback;
813: }
814: nRec = (szJ - pPager->ckptJSize)/JOURNAL_PG_SZ(journal_format);
815: for(i=nRec-1; i>=0; i--){
816: rc = pager_playback_one_page(pPager, &pPager->jfd, journal_format);
817: if( rc!=SQLITE_OK ){
818: assert( rc!=SQLITE_DONE );
819: goto end_ckpt_playback;
820: }
821: }
822:
823: end_ckpt_playback:
824: if( rc!=SQLITE_OK ){
825: pPager->errMask |= PAGER_ERR_CORRUPT;
826: rc = SQLITE_CORRUPT;
827: }
828: return rc;
829: }
830:
831: /*
832: ** Change the maximum number of in-memory pages that are allowed.
833: **
834: ** The maximum number is the absolute value of the mxPage parameter.
835: ** If mxPage is negative, the noSync flag is also set. noSync bypasses
836: ** calls to sqliteOsSync(). The pager runs much faster with noSync on,
837: ** but if the operating system crashes or there is an abrupt power
838: ** failure, the database file might be left in an inconsistent and
839: ** unrepairable state.
840: */
841: void sqlitepager_set_cachesize(Pager *pPager, int mxPage){
842: if( mxPage>=0 ){
843: pPager->noSync = pPager->tempFile;
844: if( pPager->noSync==0 ) pPager->needSync = 0;
845: }else{
846: pPager->noSync = 1;
847: mxPage = -mxPage;
848: }
849: if( mxPage>10 ){
850: pPager->mxPage = mxPage;
851: }
852: }
853:
854: /*
855: ** Adjust the robustness of the database to damage due to OS crashes
856: ** or power failures by changing the number of syncs()s when writing
857: ** the rollback journal. There are three levels:
858: **
859: ** OFF sqliteOsSync() is never called. This is the default
860: ** for temporary and transient files.
861: **
862: ** NORMAL The journal is synced once before writes begin on the
863: ** database. This is normally adequate protection, but
864: ** it is theoretically possible, though very unlikely,
865: ** that an inopertune power failure could leave the journal
866: ** in a state which would cause damage to the database
867: ** when it is rolled back.
868: **
869: ** FULL The journal is synced twice before writes begin on the
870: ** database (with some additional information - the nRec field
871: ** of the journal header - being written in between the two
872: ** syncs). If we assume that writing a
873: ** single disk sector is atomic, then this mode provides
874: ** assurance that the journal will not be corrupted to the
875: ** point of causing damage to the database during rollback.
876: **
877: ** Numeric values associated with these states are OFF==1, NORMAL=2,
878: ** and FULL=3.
879: */
880: void sqlitepager_set_safety_level(Pager *pPager, int level){
881: pPager->noSync = level==1 || pPager->tempFile;
882: pPager->fullSync = level==3 && !pPager->tempFile;
883: if( pPager->noSync==0 ) pPager->needSync = 0;
884: }
885:
886: /*
887: ** Open a temporary file. Write the name of the file into zName
888: ** (zName must be at least SQLITE_TEMPNAME_SIZE bytes long.) Write
889: ** the file descriptor into *fd. Return SQLITE_OK on success or some
890: ** other error code if we fail.
891: **
892: ** The OS will automatically delete the temporary file when it is
893: ** closed.
894: */
895: static int sqlitepager_opentemp(char *zFile, OsFile *fd){
896: int cnt = 8;
897: int rc;
898: do{
899: cnt--;
900: sqliteOsTempFileName(zFile);
901: rc = sqliteOsOpenExclusive(zFile, fd, 1);
902: }while( cnt>0 && rc!=SQLITE_OK );
903: return rc;
904: }
905:
906: /*
907: ** Create a new page cache and put a pointer to the page cache in *ppPager.
908: ** The file to be cached need not exist. The file is not locked until
909: ** the first call to sqlitepager_get() and is only held open until the
910: ** last page is released using sqlitepager_unref().
911: **
912: ** If zFilename is NULL then a randomly-named temporary file is created
913: ** and used as the file to be cached. The file will be deleted
914: ** automatically when it is closed.
915: */
916: int sqlitepager_open(
917: Pager **ppPager, /* Return the Pager structure here */
918: const char *zFilename, /* Name of the database file to open */
919: int mxPage, /* Max number of in-memory cache pages */
920: int nExtra, /* Extra bytes append to each in-memory page */
921: int useJournal /* TRUE to use a rollback journal on this file */
922: ){
923: Pager *pPager;
924: char *zFullPathname;
925: int nameLen;
926: OsFile fd;
927: int rc, i;
928: int tempFile;
929: int readOnly = 0;
930: char zTemp[SQLITE_TEMPNAME_SIZE];
931:
932: *ppPager = 0;
933: if( sqlite_malloc_failed ){
934: return SQLITE_NOMEM;
935: }
936: if( zFilename && zFilename[0] ){
937: zFullPathname = sqliteOsFullPathname(zFilename);
938: rc = sqliteOsOpenReadWrite(zFullPathname, &fd, &readOnly);
939: tempFile = 0;
940: }else{
941: rc = sqlitepager_opentemp(zTemp, &fd);
942: zFilename = zTemp;
943: zFullPathname = sqliteOsFullPathname(zFilename);
944: tempFile = 1;
945: }
946: if( sqlite_malloc_failed ){
947: return SQLITE_NOMEM;
948: }
949: if( rc!=SQLITE_OK ){
950: sqliteFree(zFullPathname);
951: return SQLITE_CANTOPEN;
952: }
953: nameLen = strlen(zFullPathname);
954: pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 );
955: if( pPager==0 ){
956: sqliteOsClose(&fd);
957: sqliteFree(zFullPathname);
958: return SQLITE_NOMEM;
959: }
960: SET_PAGER(pPager);
961: pPager->zFilename = (char*)&pPager[1];
962: pPager->zDirectory = &pPager->zFilename[nameLen+1];
963: pPager->zJournal = &pPager->zDirectory[nameLen+1];
964: strcpy(pPager->zFilename, zFullPathname);
965: strcpy(pPager->zDirectory, zFullPathname);
966: for(i=nameLen; i>0 && pPager->zDirectory[i-1]!='/'; i--){}
967: if( i>0 ) pPager->zDirectory[i-1] = 0;
968: strcpy(pPager->zJournal, zFullPathname);
969: sqliteFree(zFullPathname);
970: strcpy(&pPager->zJournal[nameLen], "-journal");
971: pPager->fd = fd;
972: pPager->journalOpen = 0;
973: pPager->useJournal = useJournal;
974: pPager->ckptOpen = 0;
975: pPager->ckptInUse = 0;
976: pPager->nRef = 0;
977: pPager->dbSize = -1;
978: pPager->ckptSize = 0;
979: pPager->ckptJSize = 0;
980: pPager->nPage = 0;
981: pPager->mxPage = mxPage>5 ? mxPage : 10;
982: pPager->state = SQLITE_UNLOCK;
983: pPager->errMask = 0;
984: pPager->tempFile = tempFile;
985: pPager->readOnly = readOnly;
986: pPager->needSync = 0;
987: pPager->noSync = pPager->tempFile || !useJournal;
988: pPager->pFirst = 0;
989: pPager->pFirstSynced = 0;
990: pPager->pLast = 0;
991: pPager->nExtra = nExtra;
992: memset(pPager->aHash, 0, sizeof(pPager->aHash));
993: *ppPager = pPager;
994: return SQLITE_OK;
995: }
996:
997: /*
998: ** Set the destructor for this pager. If not NULL, the destructor is called
999: ** when the reference count on each page reaches zero. The destructor can
1000: ** be used to clean up information in the extra segment appended to each page.
1001: **
1002: ** The destructor is not called as a result sqlitepager_close().
1003: ** Destructors are only called by sqlitepager_unref().
1004: */
1005: void sqlitepager_set_destructor(Pager *pPager, void (*xDesc)(void*)){
1006: pPager->xDestructor = xDesc;
1007: }
1008:
1009: /*
1010: ** Return the total number of pages in the disk file associated with
1011: ** pPager.
1012: */
1013: int sqlitepager_pagecount(Pager *pPager){
1014: off_t n;
1015: assert( pPager!=0 );
1016: if( pPager->dbSize>=0 ){
1017: return pPager->dbSize;
1018: }
1019: if( sqliteOsFileSize(&pPager->fd, &n)!=SQLITE_OK ){
1020: pPager->errMask |= PAGER_ERR_DISK;
1021: return 0;
1022: }
1023: n /= SQLITE_PAGE_SIZE;
1024: if( pPager->state!=SQLITE_UNLOCK ){
1025: pPager->dbSize = n;
1026: }
1027: return n;
1028: }
1029:
1030: /*
1031: ** Forward declaration
1032: */
1033: static int syncJournal(Pager*);
1034:
1035: /*
1036: ** Truncate the file to the number of pages specified.
1037: */
1038: int sqlitepager_truncate(Pager *pPager, Pgno nPage){
1039: int rc;
1040: if( pPager->dbSize<0 ){
1041: sqlitepager_pagecount(pPager);
1042: }
1043: if( pPager->errMask!=0 ){
1044: rc = pager_errcode(pPager);
1045: return rc;
1046: }
1047: if( nPage>=(unsigned)pPager->dbSize ){
1048: return SQLITE_OK;
1049: }
1050: syncJournal(pPager);
1051: rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)nPage);
1052: if( rc==SQLITE_OK ){
1053: pPager->dbSize = nPage;
1054: }
1055: return rc;
1056: }
1057:
1058: /*
1059: ** Shutdown the page cache. Free all memory and close all files.
1060: **
1061: ** If a transaction was in progress when this routine is called, that
1062: ** transaction is rolled back. All outstanding pages are invalidated
1063: ** and their memory is freed. Any attempt to use a page associated
1064: ** with this page cache after this function returns will likely
1065: ** result in a coredump.
1066: */
1067: int sqlitepager_close(Pager *pPager){
1068: PgHdr *pPg, *pNext;
1069: switch( pPager->state ){
1070: case SQLITE_WRITELOCK: {
1071: sqlitepager_rollback(pPager);
1072: sqliteOsUnlock(&pPager->fd);
1073: assert( pPager->journalOpen==0 );
1074: break;
1075: }
1076: case SQLITE_READLOCK: {
1077: sqliteOsUnlock(&pPager->fd);
1078: break;
1079: }
1080: default: {
1081: /* Do nothing */
1082: break;
1083: }
1084: }
1085: for(pPg=pPager->pAll; pPg; pPg=pNext){
1086: pNext = pPg->pNextAll;
1087: sqliteFree(pPg);
1088: }
1089: sqliteOsClose(&pPager->fd);
1090: assert( pPager->journalOpen==0 );
1091: /* Temp files are automatically deleted by the OS
1092: ** if( pPager->tempFile ){
1093: ** sqliteOsDelete(pPager->zFilename);
1094: ** }
1095: */
1096: CLR_PAGER(pPager);
1097: if( pPager->zFilename!=(char*)&pPager[1] ){
1098: assert( 0 ); /* Cannot happen */
1099: sqliteFree(pPager->zFilename);
1100: sqliteFree(pPager->zJournal);
1101: sqliteFree(pPager->zDirectory);
1102: }
1103: sqliteFree(pPager);
1104: return SQLITE_OK;
1105: }
1106:
1107: /*
1108: ** Return the page number for the given page data.
1109: */
1110: Pgno sqlitepager_pagenumber(void *pData){
1111: PgHdr *p = DATA_TO_PGHDR(pData);
1112: return p->pgno;
1113: }
1114:
1115: /*
1116: ** Increment the reference count for a page. If the page is
1117: ** currently on the freelist (the reference count is zero) then
1118: ** remove it from the freelist.
1119: */
1120: #define page_ref(P) ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++)
1121: static void _page_ref(PgHdr *pPg){
1122: if( pPg->nRef==0 ){
1123: /* The page is currently on the freelist. Remove it. */
1124: if( pPg==pPg->pPager->pFirstSynced ){
1125: PgHdr *p = pPg->pNextFree;
1126: while( p && p->needSync ){ p = p->pNextFree; }
1127: pPg->pPager->pFirstSynced = p;
1128: }
1129: if( pPg->pPrevFree ){
1130: pPg->pPrevFree->pNextFree = pPg->pNextFree;
1131: }else{
1132: pPg->pPager->pFirst = pPg->pNextFree;
1133: }
1134: if( pPg->pNextFree ){
1135: pPg->pNextFree->pPrevFree = pPg->pPrevFree;
1136: }else{
1137: pPg->pPager->pLast = pPg->pPrevFree;
1138: }
1139: pPg->pPager->nRef++;
1140: }
1141: pPg->nRef++;
1142: REFINFO(pPg);
1143: }
1144:
1145: /*
1146: ** Increment the reference count for a page. The input pointer is
1147: ** a reference to the page data.
1148: */
1149: int sqlitepager_ref(void *pData){
1150: PgHdr *pPg = DATA_TO_PGHDR(pData);
1151: page_ref(pPg);
1152: return SQLITE_OK;
1153: }
1154:
1155: /*
1156: ** Sync the journal. In other words, make sure all the pages that have
1157: ** been written to the journal have actually reached the surface of the
1158: ** disk. It is not safe to modify the original database file until after
1159: ** the journal has been synced. If the original database is modified before
1160: ** the journal is synced and a power failure occurs, the unsynced journal
1161: ** data would be lost and we would be unable to completely rollback the
1162: ** database changes. Database corruption would occur.
1163: **
1164: ** This routine also updates the nRec field in the header of the journal.
1165: ** (See comments on the pager_playback() routine for additional information.)
1166: ** If the sync mode is FULL, two syncs will occur. First the whole journal
1167: ** is synced, then the nRec field is updated, then a second sync occurs.
1168: **
1169: ** For temporary databases, we do not care if we are able to rollback
1170: ** after a power failure, so sync occurs.
1171: **
1172: ** This routine clears the needSync field of every page current held in
1173: ** memory.
1174: */
1175: static int syncJournal(Pager *pPager){
1176: PgHdr *pPg;
1177: int rc = SQLITE_OK;
1178:
1179: /* Sync the journal before modifying the main database
1180: ** (assuming there is a journal and it needs to be synced.)
1181: */
1182: if( pPager->needSync ){
1183: if( !pPager->tempFile ){
1184: assert( pPager->journalOpen );
1185: /* assert( !pPager->noSync ); // noSync might be set if synchronous
1186: ** was turned off after the transaction was started. Ticket #615 */
1187: #ifndef NDEBUG
1188: {
1189: /* Make sure the pPager->nRec counter we are keeping agrees
1190: ** with the nRec computed from the size of the journal file.
1191: */
1192: off_t hdrSz, pgSz, jSz;
1193: hdrSz = JOURNAL_HDR_SZ(journal_format);
1194: pgSz = JOURNAL_PG_SZ(journal_format);
1195: rc = sqliteOsFileSize(&pPager->jfd, &jSz);
1196: if( rc!=0 ) return rc;
1197: assert( pPager->nRec*pgSz+hdrSz==jSz );
1198: }
1199: #endif
1200: if( journal_format>=3 ){
1201: /* Write the nRec value into the journal file header */
1202: off_t szJ;
1203: if( pPager->fullSync ){
1204: TRACE1("SYNC\n");
1205: rc = sqliteOsSync(&pPager->jfd);
1206: if( rc!=0 ) return rc;
1207: }
1208: sqliteOsSeek(&pPager->jfd, sizeof(aJournalMagic1));
1209: rc = write32bits(&pPager->jfd, pPager->nRec);
1210: if( rc ) return rc;
1211: szJ = JOURNAL_HDR_SZ(journal_format) +
1212: pPager->nRec*JOURNAL_PG_SZ(journal_format);
1213: sqliteOsSeek(&pPager->jfd, szJ);
1214: }
1215: TRACE1("SYNC\n");
1216: rc = sqliteOsSync(&pPager->jfd);
1217: if( rc!=0 ) return rc;
1218: pPager->journalStarted = 1;
1219: }
1220: pPager->needSync = 0;
1221:
1222: /* Erase the needSync flag from every page.
1223: */
1224: for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
1225: pPg->needSync = 0;
1226: }
1227: pPager->pFirstSynced = pPager->pFirst;
1228: }
1229:
1230: #ifndef NDEBUG
1231: /* If the Pager.needSync flag is clear then the PgHdr.needSync
1232: ** flag must also be clear for all pages. Verify that this
1233: ** invariant is true.
1234: */
1235: else{
1236: for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
1237: assert( pPg->needSync==0 );
1238: }
1239: assert( pPager->pFirstSynced==pPager->pFirst );
1240: }
1241: #endif
1242:
1243: return rc;
1244: }
1245:
1246: /*
1247: ** Given a list of pages (connected by the PgHdr.pDirty pointer) write
1248: ** every one of those pages out to the database file and mark them all
1249: ** as clean.
1250: */
1251: static int pager_write_pagelist(PgHdr *pList){
1252: Pager *pPager;
1253: int rc;
1254:
1255: if( pList==0 ) return SQLITE_OK;
1256: pPager = pList->pPager;
1257: while( pList ){
1258: assert( pList->dirty );
1259: sqliteOsSeek(&pPager->fd, (pList->pgno-1)*(off_t)SQLITE_PAGE_SIZE);
1260: CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);
1261: TRACE2("STORE %d\n", pList->pgno);
1262: rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pList), SQLITE_PAGE_SIZE);
1263: CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 0);
1264: if( rc ) return rc;
1265: pList->dirty = 0;
1266: pList = pList->pDirty;
1267: }
1268: return SQLITE_OK;
1269: }
1270:
1271: /*
1272: ** Collect every dirty page into a dirty list and
1273: ** return a pointer to the head of that list. All pages are
1274: ** collected even if they are still in use.
1275: */
1276: static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
1277: PgHdr *p, *pList;
1278: pList = 0;
1279: for(p=pPager->pAll; p; p=p->pNextAll){
1280: if( p->dirty ){
1281: p->pDirty = pList;
1282: pList = p;
1283: }
1284: }
1285: return pList;
1286: }
1287:
1288: /*
1289: ** Acquire a page.
1290: **
1291: ** A read lock on the disk file is obtained when the first page is acquired.
1292: ** This read lock is dropped when the last page is released.
1293: **
1294: ** A _get works for any page number greater than 0. If the database
1295: ** file is smaller than the requested page, then no actual disk
1296: ** read occurs and the memory image of the page is initialized to
1297: ** all zeros. The extra data appended to a page is always initialized
1298: ** to zeros the first time a page is loaded into memory.
1299: **
1300: ** The acquisition might fail for several reasons. In all cases,
1301: ** an appropriate error code is returned and *ppPage is set to NULL.
1302: **
1303: ** See also sqlitepager_lookup(). Both this routine and _lookup() attempt
1304: ** to find a page in the in-memory cache first. If the page is not already
1305: ** in memory, this routine goes to disk to read it in whereas _lookup()
1306: ** just returns 0. This routine acquires a read-lock the first time it
1307: ** has to go to disk, and could also playback an old journal if necessary.
1308: ** Since _lookup() never goes to disk, it never has to deal with locks
1309: ** or journal files.
1310: */
1311: int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
1312: PgHdr *pPg;
1313: int rc;
1314:
1315: /* Make sure we have not hit any critical errors.
1316: */
1317: assert( pPager!=0 );
1318: assert( pgno!=0 );
1319: *ppPage = 0;
1320: if( pPager->errMask & ~(PAGER_ERR_FULL) ){
1321: return pager_errcode(pPager);
1322: }
1323:
1324: /* If this is the first page accessed, then get a read lock
1325: ** on the database file.
1326: */
1327: if( pPager->nRef==0 ){
1328: rc = sqliteOsReadLock(&pPager->fd);
1329: if( rc!=SQLITE_OK ){
1330: return rc;
1331: }
1332: pPager->state = SQLITE_READLOCK;
1333:
1334: /* If a journal file exists, try to play it back.
1335: */
1336: if( pPager->useJournal && sqliteOsFileExists(pPager->zJournal) ){
1337: int rc;
1338:
1339: /* Get a write lock on the database
1340: */
1341: rc = sqliteOsWriteLock(&pPager->fd);
1342: if( rc!=SQLITE_OK ){
1343: if( sqliteOsUnlock(&pPager->fd)!=SQLITE_OK ){
1344: /* This should never happen! */
1345: rc = SQLITE_INTERNAL;
1346: }
1347: return rc;
1348: }
1349: pPager->state = SQLITE_WRITELOCK;
1350:
1351: /* Open the journal for reading only. Return SQLITE_BUSY if
1352: ** we are unable to open the journal file.
1353: **
1354: ** The journal file does not need to be locked itself. The
1355: ** journal file is never open unless the main database file holds
1356: ** a write lock, so there is never any chance of two or more
1357: ** processes opening the journal at the same time.
1358: */
1359: rc = sqliteOsOpenReadOnly(pPager->zJournal, &pPager->jfd);
1360: if( rc!=SQLITE_OK ){
1361: rc = sqliteOsUnlock(&pPager->fd);
1362: assert( rc==SQLITE_OK );
1363: return SQLITE_BUSY;
1364: }
1365: pPager->journalOpen = 1;
1366: pPager->journalStarted = 0;
1367:
1368: /* Playback and delete the journal. Drop the database write
1369: ** lock and reacquire the read lock.
1370: */
1371: rc = pager_playback(pPager, 0);
1372: if( rc!=SQLITE_OK ){
1373: return rc;
1374: }
1375: }
1376: pPg = 0;
1377: }else{
1378: /* Search for page in cache */
1379: pPg = pager_lookup(pPager, pgno);
1380: }
1381: if( pPg==0 ){
1382: /* The requested page is not in the page cache. */
1383: int h;
1384: pPager->nMiss++;
1385: if( pPager->nPage<pPager->mxPage || pPager->pFirst==0 ){
1386: /* Create a new page */
1387: pPg = sqliteMallocRaw( sizeof(*pPg) + SQLITE_PAGE_SIZE
1388: + sizeof(u32) + pPager->nExtra );
1389: if( pPg==0 ){
1390: pager_unwritelock(pPager);
1391: pPager->errMask |= PAGER_ERR_MEM;
1392: return SQLITE_NOMEM;
1393: }
1394: memset(pPg, 0, sizeof(*pPg));
1395: pPg->pPager = pPager;
1396: pPg->pNextAll = pPager->pAll;
1397: if( pPager->pAll ){
1398: pPager->pAll->pPrevAll = pPg;
1399: }
1400: pPg->pPrevAll = 0;
1401: pPager->pAll = pPg;
1402: pPager->nPage++;
1403: }else{
1404: /* Find a page to recycle. Try to locate a page that does not
1405: ** require us to do an fsync() on the journal.
1406: */
1407: pPg = pPager->pFirstSynced;
1408:
1409: /* If we could not find a page that does not require an fsync()
1410: ** on the journal file then fsync the journal file. This is a
1411: ** very slow operation, so we work hard to avoid it. But sometimes
1412: ** it can't be helped.
1413: */
1414: if( pPg==0 ){
1415: int rc = syncJournal(pPager);
1416: if( rc!=0 ){
1417: sqlitepager_rollback(pPager);
1418: return SQLITE_IOERR;
1419: }
1420: pPg = pPager->pFirst;
1421: }
1422: assert( pPg->nRef==0 );
1423:
1424: /* Write the page to the database file if it is dirty.
1425: */
1426: if( pPg->dirty ){
1427: assert( pPg->needSync==0 );
1428: pPg->pDirty = 0;
1429: rc = pager_write_pagelist( pPg );
1430: if( rc!=SQLITE_OK ){
1431: sqlitepager_rollback(pPager);
1432: return SQLITE_IOERR;
1433: }
1434: }
1435: assert( pPg->dirty==0 );
1436:
1437: /* If the page we are recycling is marked as alwaysRollback, then
1438: ** set the global alwaysRollback flag, thus disabling the
1439: ** sqlite_dont_rollback() optimization for the rest of this transaction.
1440: ** It is necessary to do this because the page marked alwaysRollback
1441: ** might be reloaded at a later time but at that point we won't remember
1442: ** that is was marked alwaysRollback. This means that all pages must
1443: ** be marked as alwaysRollback from here on out.
1444: */
1445: if( pPg->alwaysRollback ){
1446: pPager->alwaysRollback = 1;
1447: }
1448:
1449: /* Unlink the old page from the free list and the hash table
1450: */
1451: if( pPg==pPager->pFirstSynced ){
1452: PgHdr *p = pPg->pNextFree;
1453: while( p && p->needSync ){ p = p->pNextFree; }
1454: pPager->pFirstSynced = p;
1455: }
1456: if( pPg->pPrevFree ){
1457: pPg->pPrevFree->pNextFree = pPg->pNextFree;
1458: }else{
1459: assert( pPager->pFirst==pPg );
1460: pPager->pFirst = pPg->pNextFree;
1461: }
1462: if( pPg->pNextFree ){
1463: pPg->pNextFree->pPrevFree = pPg->pPrevFree;
1464: }else{
1465: assert( pPager->pLast==pPg );
1466: pPager->pLast = pPg->pPrevFree;
1467: }
1468: pPg->pNextFree = pPg->pPrevFree = 0;
1469: if( pPg->pNextHash ){
1470: pPg->pNextHash->pPrevHash = pPg->pPrevHash;
1471: }
1472: if( pPg->pPrevHash ){
1473: pPg->pPrevHash->pNextHash = pPg->pNextHash;
1474: }else{
1475: h = pager_hash(pPg->pgno);
1476: assert( pPager->aHash[h]==pPg );
1477: pPager->aHash[h] = pPg->pNextHash;
1478: }
1479: pPg->pNextHash = pPg->pPrevHash = 0;
1480: pPager->nOvfl++;
1481: }
1482: pPg->pgno = pgno;
1483: if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
1484: sqliteCheckMemory(pPager->aInJournal, pgno/8);
1485: assert( pPager->journalOpen );
1486: pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
1487: pPg->needSync = 0;
1488: }else{
1489: pPg->inJournal = 0;
1490: pPg->needSync = 0;
1491: }
1492: if( pPager->aInCkpt && (int)pgno<=pPager->ckptSize
1493: && (pPager->aInCkpt[pgno/8] & (1<<(pgno&7)))!=0 ){
1494: page_add_to_ckpt_list(pPg);
1495: }else{
1496: page_remove_from_ckpt_list(pPg);
1497: }
1498: pPg->dirty = 0;
1499: pPg->nRef = 1;
1500: REFINFO(pPg);
1501: pPager->nRef++;
1502: h = pager_hash(pgno);
1503: pPg->pNextHash = pPager->aHash[h];
1504: pPager->aHash[h] = pPg;
1505: if( pPg->pNextHash ){
1506: assert( pPg->pNextHash->pPrevHash==0 );
1507: pPg->pNextHash->pPrevHash = pPg;
1508: }
1509: if( pPager->nExtra>0 ){
1510: memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
1511: }
1512: if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager);
1513: if( pPager->errMask!=0 ){
1514: sqlitepager_unref(PGHDR_TO_DATA(pPg));
1515: rc = pager_errcode(pPager);
1516: return rc;
1517: }
1518: if( pPager->dbSize<(int)pgno ){
1519: memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE);
1520: }else{
1521: int rc;
1522: sqliteOsSeek(&pPager->fd, (pgno-1)*(off_t)SQLITE_PAGE_SIZE);
1523: rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE);
1524: TRACE2("FETCH %d\n", pPg->pgno);
1525: CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
1526: if( rc!=SQLITE_OK ){
1527: off_t fileSize;
1528: if( sqliteOsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK
1529: || fileSize>=pgno*SQLITE_PAGE_SIZE ){
1530: sqlitepager_unref(PGHDR_TO_DATA(pPg));
1531: return rc;
1532: }else{
1533: memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE);
1534: }
1535: }
1536: }
1537: }else{
1538: /* The requested page is in the page cache. */
1539: pPager->nHit++;
1540: page_ref(pPg);
1541: }
1542: *ppPage = PGHDR_TO_DATA(pPg);
1543: return SQLITE_OK;
1544: }
1545:
1546: /*
1547: ** Acquire a page if it is already in the in-memory cache. Do
1548: ** not read the page from disk. Return a pointer to the page,
1549: ** or 0 if the page is not in cache.
1550: **
1551: ** See also sqlitepager_get(). The difference between this routine
1552: ** and sqlitepager_get() is that _get() will go to the disk and read
1553: ** in the page if the page is not already in cache. This routine
1554: ** returns NULL if the page is not in cache or if a disk I/O error
1555: ** has ever happened.
1556: */
1557: void *sqlitepager_lookup(Pager *pPager, Pgno pgno){
1558: PgHdr *pPg;
1559:
1560: assert( pPager!=0 );
1561: assert( pgno!=0 );
1562: if( pPager->errMask & ~(PAGER_ERR_FULL) ){
1563: return 0;
1564: }
1565: /* if( pPager->nRef==0 ){
1566: ** return 0;
1567: ** }
1568: */
1569: pPg = pager_lookup(pPager, pgno);
1570: if( pPg==0 ) return 0;
1571: page_ref(pPg);
1572: return PGHDR_TO_DATA(pPg);
1573: }
1574:
1575: /*
1576: ** Release a page.
1577: **
1578: ** If the number of references to the page drop to zero, then the
1579: ** page is added to the LRU list. When all references to all pages
1580: ** are released, a rollback occurs and the lock on the database is
1581: ** removed.
1582: */
1583: int sqlitepager_unref(void *pData){
1584: PgHdr *pPg;
1585:
1586: /* Decrement the reference count for this page
1587: */
1588: pPg = DATA_TO_PGHDR(pData);
1589: assert( pPg->nRef>0 );
1590: pPg->nRef--;
1591: REFINFO(pPg);
1592:
1593: /* When the number of references to a page reach 0, call the
1594: ** destructor and add the page to the freelist.
1595: */
1596: if( pPg->nRef==0 ){
1597: Pager *pPager;
1598: pPager = pPg->pPager;
1599: pPg->pNextFree = 0;
1600: pPg->pPrevFree = pPager->pLast;
1601: pPager->pLast = pPg;
1602: if( pPg->pPrevFree ){
1603: pPg->pPrevFree->pNextFree = pPg;
1604: }else{
1605: pPager->pFirst = pPg;
1606: }
1607: if( pPg->needSync==0 && pPager->pFirstSynced==0 ){
1608: pPager->pFirstSynced = pPg;
1609: }
1610: if( pPager->xDestructor ){
1611: pPager->xDestructor(pData);
1612: }
1613:
1614: /* When all pages reach the freelist, drop the read lock from
1615: ** the database file.
1616: */
1617: pPager->nRef--;
1618: assert( pPager->nRef>=0 );
1619: if( pPager->nRef==0 ){
1620: pager_reset(pPager);
1621: }
1622: }
1623: return SQLITE_OK;
1624: }
1625:
1626: /*
1627: ** Create a journal file for pPager. There should already be a write
1628: ** lock on the database file when this routine is called.
1629: **
1630: ** Return SQLITE_OK if everything. Return an error code and release the
1631: ** write lock if anything goes wrong.
1632: */
1633: static int pager_open_journal(Pager *pPager){
1634: int rc;
1635: assert( pPager->state==SQLITE_WRITELOCK );
1636: assert( pPager->journalOpen==0 );
1637: assert( pPager->useJournal );
1638: sqlitepager_pagecount(pPager);
1639: pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 );
1640: if( pPager->aInJournal==0 ){
1641: sqliteOsReadLock(&pPager->fd);
1642: pPager->state = SQLITE_READLOCK;
1643: return SQLITE_NOMEM;
1644: }
1645: rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd,pPager->tempFile);
1646: if( rc!=SQLITE_OK ){
1647: sqliteFree(pPager->aInJournal);
1648: pPager->aInJournal = 0;
1649: sqliteOsReadLock(&pPager->fd);
1650: pPager->state = SQLITE_READLOCK;
1651: return SQLITE_CANTOPEN;
1652: }
1653: sqliteOsOpenDirectory(pPager->zDirectory, &pPager->jfd);
1654: pPager->journalOpen = 1;
1655: pPager->journalStarted = 0;
1656: pPager->needSync = 0;
1657: pPager->alwaysRollback = 0;
1658: pPager->nRec = 0;
1659: if( pPager->errMask!=0 ){
1660: rc = pager_errcode(pPager);
1661: return rc;
1662: }
1663: pPager->origDbSize = pPager->dbSize;
1664: if( journal_format==JOURNAL_FORMAT_3 ){
1665: rc = sqliteOsWrite(&pPager->jfd, aJournalMagic3, sizeof(aJournalMagic3));
1666: if( rc==SQLITE_OK ){
1667: rc = write32bits(&pPager->jfd, pPager->noSync ? 0xffffffff : 0);
1668: }
1669: if( rc==SQLITE_OK ){
1670: sqliteRandomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
1671: rc = write32bits(&pPager->jfd, pPager->cksumInit);
1672: }
1673: }else if( journal_format==JOURNAL_FORMAT_2 ){
1674: rc = sqliteOsWrite(&pPager->jfd, aJournalMagic2, sizeof(aJournalMagic2));
1675: }else{
1676: assert( journal_format==JOURNAL_FORMAT_1 );
1677: rc = sqliteOsWrite(&pPager->jfd, aJournalMagic1, sizeof(aJournalMagic1));
1678: }
1679: if( rc==SQLITE_OK ){
1680: rc = write32bits(&pPager->jfd, pPager->dbSize);
1681: }
1682: if( pPager->ckptAutoopen && rc==SQLITE_OK ){
1683: rc = sqlitepager_ckpt_begin(pPager);
1684: }
1685: if( rc!=SQLITE_OK ){
1686: rc = pager_unwritelock(pPager);
1687: if( rc==SQLITE_OK ){
1688: rc = SQLITE_FULL;
1689: }
1690: }
1691: return rc;
1692: }
1693:
1694: /*
1695: ** Acquire a write-lock on the database. The lock is removed when
1696: ** the any of the following happen:
1697: **
1698: ** * sqlitepager_commit() is called.
1699: ** * sqlitepager_rollback() is called.
1700: ** * sqlitepager_close() is called.
1701: ** * sqlitepager_unref() is called to on every outstanding page.
1702: **
1703: ** The parameter to this routine is a pointer to any open page of the
1704: ** database file. Nothing changes about the page - it is used merely
1705: ** to acquire a pointer to the Pager structure and as proof that there
1706: ** is already a read-lock on the database.
1707: **
1708: ** A journal file is opened if this is not a temporary file. For
1709: ** temporary files, the opening of the journal file is deferred until
1710: ** there is an actual need to write to the journal.
1711: **
1712: ** If the database is already write-locked, this routine is a no-op.
1713: */
1714: int sqlitepager_begin(void *pData){
1715: PgHdr *pPg = DATA_TO_PGHDR(pData);
1716: Pager *pPager = pPg->pPager;
1717: int rc = SQLITE_OK;
1718: assert( pPg->nRef>0 );
1719: assert( pPager->state!=SQLITE_UNLOCK );
1720: if( pPager->state==SQLITE_READLOCK ){
1721: assert( pPager->aInJournal==0 );
1722: rc = sqliteOsWriteLock(&pPager->fd);
1723: if( rc!=SQLITE_OK ){
1724: return rc;
1725: }
1726: pPager->state = SQLITE_WRITELOCK;
1727: pPager->dirtyFile = 0;
1728: TRACE1("TRANSACTION\n");
1729: if( pPager->useJournal && !pPager->tempFile ){
1730: rc = pager_open_journal(pPager);
1731: }
1732: }
1733: return rc;
1734: }
1735:
1736: /*
1737: ** Mark a data page as writeable. The page is written into the journal
1738: ** if it is not there already. This routine must be called before making
1739: ** changes to a page.
1740: **
1741: ** The first time this routine is called, the pager creates a new
1742: ** journal and acquires a write lock on the database. If the write
1743: ** lock could not be acquired, this routine returns SQLITE_BUSY. The
1744: ** calling routine must check for that return value and be careful not to
1745: ** change any page data until this routine returns SQLITE_OK.
1746: **
1747: ** If the journal file could not be written because the disk is full,
1748: ** then this routine returns SQLITE_FULL and does an immediate rollback.
1749: ** All subsequent write attempts also return SQLITE_FULL until there
1750: ** is a call to sqlitepager_commit() or sqlitepager_rollback() to
1751: ** reset.
1752: */
1753: int sqlitepager_write(void *pData){
1754: PgHdr *pPg = DATA_TO_PGHDR(pData);
1755: Pager *pPager = pPg->pPager;
1756: int rc = SQLITE_OK;
1757:
1758: /* Check for errors
1759: */
1760: if( pPager->errMask ){
1761: return pager_errcode(pPager);
1762: }
1763: if( pPager->readOnly ){
1764: return SQLITE_PERM;
1765: }
1766:
1767: /* Mark the page as dirty. If the page has already been written
1768: ** to the journal then we can return right away.
1769: */
1770: pPg->dirty = 1;
1771: if( pPg->inJournal && (pPg->inCkpt || pPager->ckptInUse==0) ){
1772: pPager->dirtyFile = 1;
1773: return SQLITE_OK;
1774: }
1775:
1776: /* If we get this far, it means that the page needs to be
1777: ** written to the transaction journal or the ckeckpoint journal
1778: ** or both.
1779: **
1780: ** First check to see that the transaction journal exists and
1781: ** create it if it does not.
1782: */
1783: assert( pPager->state!=SQLITE_UNLOCK );
1784: rc = sqlitepager_begin(pData);
1785: if( rc!=SQLITE_OK ){
1786: return rc;
1787: }
1788: assert( pPager->state==SQLITE_WRITELOCK );
1789: if( !pPager->journalOpen && pPager->useJournal ){
1790: rc = pager_open_journal(pPager);
1791: if( rc!=SQLITE_OK ) return rc;
1792: }
1793: assert( pPager->journalOpen || !pPager->useJournal );
1794: pPager->dirtyFile = 1;
1795:
1796: /* The transaction journal now exists and we have a write lock on the
1797: ** main database file. Write the current page to the transaction
1798: ** journal if it is not there already.
1799: */
1800: if( !pPg->inJournal && pPager->useJournal ){
1801: if( (int)pPg->pgno <= pPager->origDbSize ){
1802: int szPg;
1803: u32 saved;
1804: if( journal_format>=JOURNAL_FORMAT_3 ){
1805: u32 cksum = pager_cksum(pPager, pPg->pgno, pData);
1806: saved = *(u32*)PGHDR_TO_EXTRA(pPg);
1807: store32bits(cksum, pPg, SQLITE_PAGE_SIZE);
1808: szPg = SQLITE_PAGE_SIZE+8;
1809: }else{
1810: szPg = SQLITE_PAGE_SIZE+4;
1811: }
1812: store32bits(pPg->pgno, pPg, -4);
1813: CODEC(pPager, pData, pPg->pgno, 7);
1814: rc = sqliteOsWrite(&pPager->jfd, &((char*)pData)[-4], szPg);
1815: TRACE3("JOURNAL %d %d\n", pPg->pgno, pPg->needSync);
1816: CODEC(pPager, pData, pPg->pgno, 0);
1817: if( journal_format>=JOURNAL_FORMAT_3 ){
1818: *(u32*)PGHDR_TO_EXTRA(pPg) = saved;
1819: }
1820: if( rc!=SQLITE_OK ){
1821: sqlitepager_rollback(pPager);
1822: pPager->errMask |= PAGER_ERR_FULL;
1823: return rc;
1824: }
1825: pPager->nRec++;
1826: assert( pPager->aInJournal!=0 );
1827: pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
1828: pPg->needSync = !pPager->noSync;
1829: pPg->inJournal = 1;
1830: if( pPager->ckptInUse ){
1831: pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
1832: page_add_to_ckpt_list(pPg);
1833: }
1834: }else{
1835: pPg->needSync = !pPager->journalStarted && !pPager->noSync;
1836: TRACE3("APPEND %d %d\n", pPg->pgno, pPg->needSync);
1837: }
1838: if( pPg->needSync ){
1839: pPager->needSync = 1;
1840: }
1841: }
1842:
1843: /* If the checkpoint journal is open and the page is not in it,
1844: ** then write the current page to the checkpoint journal. Note that
1845: ** the checkpoint journal always uses the simplier format 2 that lacks
1846: ** checksums. The header is also omitted from the checkpoint journal.
1847: */
1848: if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){
1849: assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
1850: store32bits(pPg->pgno, pPg, -4);
1851: CODEC(pPager, pData, pPg->pgno, 7);
1852: rc = sqliteOsWrite(&pPager->cpfd, &((char*)pData)[-4], SQLITE_PAGE_SIZE+4);
1853: TRACE2("CKPT-JOURNAL %d\n", pPg->pgno);
1854: CODEC(pPager, pData, pPg->pgno, 0);
1855: if( rc!=SQLITE_OK ){
1856: sqlitepager_rollback(pPager);
1857: pPager->errMask |= PAGER_ERR_FULL;
1858: return rc;
1859: }
1860: pPager->ckptNRec++;
1861: assert( pPager->aInCkpt!=0 );
1862: pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
1863: page_add_to_ckpt_list(pPg);
1864: }
1865:
1866: /* Update the database size and return.
1867: */
1868: if( pPager->dbSize<(int)pPg->pgno ){
1869: pPager->dbSize = pPg->pgno;
1870: }
1871: return rc;
1872: }
1873:
1874: /*
1875: ** Return TRUE if the page given in the argument was previously passed
1876: ** to sqlitepager_write(). In other words, return TRUE if it is ok
1877: ** to change the content of the page.
1878: */
1879: int sqlitepager_iswriteable(void *pData){
1880: PgHdr *pPg = DATA_TO_PGHDR(pData);
1881: return pPg->dirty;
1882: }
1883:
1884: /*
1885: ** Replace the content of a single page with the information in the third
1886: ** argument.
1887: */
1888: int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){
1889: void *pPage;
1890: int rc;
1891:
1892: rc = sqlitepager_get(pPager, pgno, &pPage);
1893: if( rc==SQLITE_OK ){
1894: rc = sqlitepager_write(pPage);
1895: if( rc==SQLITE_OK ){
1896: memcpy(pPage, pData, SQLITE_PAGE_SIZE);
1897: }
1898: sqlitepager_unref(pPage);
1899: }
1900: return rc;
1901: }
1902:
1903: /*
1904: ** A call to this routine tells the pager that it is not necessary to
1905: ** write the information on page "pgno" back to the disk, even though
1906: ** that page might be marked as dirty.
1907: **
1908: ** The overlying software layer calls this routine when all of the data
1909: ** on the given page is unused. The pager marks the page as clean so
1910: ** that it does not get written to disk.
1911: **
1912: ** Tests show that this optimization, together with the
1913: ** sqlitepager_dont_rollback() below, more than double the speed
1914: ** of large INSERT operations and quadruple the speed of large DELETEs.
1915: **
1916: ** When this routine is called, set the alwaysRollback flag to true.
1917: ** Subsequent calls to sqlitepager_dont_rollback() for the same page
1918: ** will thereafter be ignored. This is necessary to avoid a problem
1919: ** where a page with data is added to the freelist during one part of
1920: ** a transaction then removed from the freelist during a later part
1921: ** of the same transaction and reused for some other purpose. When it
1922: ** is first added to the freelist, this routine is called. When reused,
1923: ** the dont_rollback() routine is called. But because the page contains
1924: ** critical data, we still need to be sure it gets rolled back in spite
1925: ** of the dont_rollback() call.
1926: */
1927: void sqlitepager_dont_write(Pager *pPager, Pgno pgno){
1928: PgHdr *pPg;
1929:
1930: pPg = pager_lookup(pPager, pgno);
1931: pPg->alwaysRollback = 1;
1932: if( pPg && pPg->dirty && !pPager->ckptInUse ){
1933: if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){
1934: /* If this pages is the last page in the file and the file has grown
1935: ** during the current transaction, then do NOT mark the page as clean.
1936: ** When the database file grows, we must make sure that the last page
1937: ** gets written at least once so that the disk file will be the correct
1938: ** size. If you do not write this page and the size of the file
1939: ** on the disk ends up being too small, that can lead to database
1940: ** corruption during the next transaction.
1941: */
1942: }else{
1943: TRACE2("DONT_WRITE %d\n", pgno);
1944: pPg->dirty = 0;
1945: }
1946: }
1947: }
1948:
1949: /*
1950: ** A call to this routine tells the pager that if a rollback occurs,
1951: ** it is not necessary to restore the data on the given page. This
1952: ** means that the pager does not have to record the given page in the
1953: ** rollback journal.
1954: */
1955: void sqlitepager_dont_rollback(void *pData){
1956: PgHdr *pPg = DATA_TO_PGHDR(pData);
1957: Pager *pPager = pPg->pPager;
1958:
1959: if( pPager->state!=SQLITE_WRITELOCK || pPager->journalOpen==0 ) return;
1960: if( pPg->alwaysRollback || pPager->alwaysRollback ) return;
1961: if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){
1962: assert( pPager->aInJournal!=0 );
1963: pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
1964: pPg->inJournal = 1;
1965: if( pPager->ckptInUse ){
1966: pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
1967: page_add_to_ckpt_list(pPg);
1968: }
1969: TRACE2("DONT_ROLLBACK %d\n", pPg->pgno);
1970: }
1971: if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){
1972: assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
1973: assert( pPager->aInCkpt!=0 );
1974: pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
1975: page_add_to_ckpt_list(pPg);
1976: }
1977: }
1978:
1979: /*
1980: ** Commit all changes to the database and release the write lock.
1981: **
1982: ** If the commit fails for any reason, a rollback attempt is made
1983: ** and an error code is returned. If the commit worked, SQLITE_OK
1984: ** is returned.
1985: */
1986: int sqlitepager_commit(Pager *pPager){
1987: int rc;
1988: PgHdr *pPg;
1989:
1990: if( pPager->errMask==PAGER_ERR_FULL ){
1991: rc = sqlitepager_rollback(pPager);
1992: if( rc==SQLITE_OK ){
1993: rc = SQLITE_FULL;
1994: }
1995: return rc;
1996: }
1997: if( pPager->errMask!=0 ){
1998: rc = pager_errcode(pPager);
1999: return rc;
2000: }
2001: if( pPager->state!=SQLITE_WRITELOCK ){
2002: return SQLITE_ERROR;
2003: }
2004: TRACE1("COMMIT\n");
2005: if( pPager->dirtyFile==0 ){
2006: /* Exit early (without doing the time-consuming sqliteOsSync() calls)
2007: ** if there have been no changes to the database file. */
2008: assert( pPager->needSync==0 );
2009: rc = pager_unwritelock(pPager);
2010: pPager->dbSize = -1;
2011: return rc;
2012: }
2013: assert( pPager->journalOpen );
2014: rc = syncJournal(pPager);
2015: if( rc!=SQLITE_OK ){
2016: goto commit_abort;
2017: }
2018: pPg = pager_get_all_dirty_pages(pPager);
2019: if( pPg ){
2020: rc = pager_write_pagelist(pPg);
2021: if( rc || (!pPager->noSync && sqliteOsSync(&pPager->fd)!=SQLITE_OK) ){
2022: goto commit_abort;
2023: }
2024: }
2025: rc = pager_unwritelock(pPager);
2026: pPager->dbSize = -1;
2027: return rc;
2028:
2029: /* Jump here if anything goes wrong during the commit process.
2030: */
2031: commit_abort:
2032: rc = sqlitepager_rollback(pPager);
2033: if( rc==SQLITE_OK ){
2034: rc = SQLITE_FULL;
2035: }
2036: return rc;
2037: }
2038:
2039: /*
2040: ** Rollback all changes. The database falls back to read-only mode.
2041: ** All in-memory cache pages revert to their original data contents.
2042: ** The journal is deleted.
2043: **
2044: ** This routine cannot fail unless some other process is not following
2045: ** the correct locking protocol (SQLITE_PROTOCOL) or unless some other
2046: ** process is writing trash into the journal file (SQLITE_CORRUPT) or
2047: ** unless a prior malloc() failed (SQLITE_NOMEM). Appropriate error
2048: ** codes are returned for all these occasions. Otherwise,
2049: ** SQLITE_OK is returned.
2050: */
2051: int sqlitepager_rollback(Pager *pPager){
2052: int rc;
2053: TRACE1("ROLLBACK\n");
2054: if( !pPager->dirtyFile || !pPager->journalOpen ){
2055: rc = pager_unwritelock(pPager);
2056: pPager->dbSize = -1;
2057: return rc;
2058: }
2059:
2060: if( pPager->errMask!=0 && pPager->errMask!=PAGER_ERR_FULL ){
2061: if( pPager->state>=SQLITE_WRITELOCK ){
2062: pager_playback(pPager, 1);
2063: }
2064: return pager_errcode(pPager);
2065: }
2066: if( pPager->state!=SQLITE_WRITELOCK ){
2067: return SQLITE_OK;
2068: }
2069: rc = pager_playback(pPager, 1);
2070: if( rc!=SQLITE_OK ){
2071: rc = SQLITE_CORRUPT;
2072: pPager->errMask |= PAGER_ERR_CORRUPT;
2073: }
2074: pPager->dbSize = -1;
2075: return rc;
2076: }
2077:
2078: /*
2079: ** Return TRUE if the database file is opened read-only. Return FALSE
2080: ** if the database is (in theory) writable.
2081: */
2082: int sqlitepager_isreadonly(Pager *pPager){
2083: return pPager->readOnly;
2084: }
2085:
2086: /*
2087: ** This routine is used for testing and analysis only.
2088: */
2089: int *sqlitepager_stats(Pager *pPager){
2090: static int a[9];
2091: a[0] = pPager->nRef;
2092: a[1] = pPager->nPage;
2093: a[2] = pPager->mxPage;
2094: a[3] = pPager->dbSize;
2095: a[4] = pPager->state;
2096: a[5] = pPager->errMask;
2097: a[6] = pPager->nHit;
2098: a[7] = pPager->nMiss;
2099: a[8] = pPager->nOvfl;
2100: return a;
2101: }
2102:
2103: /*
2104: ** Set the checkpoint.
2105: **
2106: ** This routine should be called with the transaction journal already
2107: ** open. A new checkpoint journal is created that can be used to rollback
2108: ** changes of a single SQL command within a larger transaction.
2109: */
2110: int sqlitepager_ckpt_begin(Pager *pPager){
2111: int rc;
2112: char zTemp[SQLITE_TEMPNAME_SIZE];
2113: if( !pPager->journalOpen ){
2114: pPager->ckptAutoopen = 1;
2115: return SQLITE_OK;
2116: }
2117: assert( pPager->journalOpen );
2118: assert( !pPager->ckptInUse );
2119: pPager->aInCkpt = sqliteMalloc( pPager->dbSize/8 + 1 );
2120: if( pPager->aInCkpt==0 ){
2121: sqliteOsReadLock(&pPager->fd);
2122: return SQLITE_NOMEM;
2123: }
2124: #ifndef NDEBUG
2125: rc = sqliteOsFileSize(&pPager->jfd, &pPager->ckptJSize);
2126: if( rc ) goto ckpt_begin_failed;
2127: assert( pPager->ckptJSize ==
2128: pPager->nRec*JOURNAL_PG_SZ(journal_format)+JOURNAL_HDR_SZ(journal_format) );
2129: #endif
2130: pPager->ckptJSize = pPager->nRec*JOURNAL_PG_SZ(journal_format)
2131: + JOURNAL_HDR_SZ(journal_format);
2132: pPager->ckptSize = pPager->dbSize;
2133: if( !pPager->ckptOpen ){
2134: rc = sqlitepager_opentemp(zTemp, &pPager->cpfd);
2135: if( rc ) goto ckpt_begin_failed;
2136: pPager->ckptOpen = 1;
2137: pPager->ckptNRec = 0;
2138: }
2139: pPager->ckptInUse = 1;
2140: return SQLITE_OK;
2141:
2142: ckpt_begin_failed:
2143: if( pPager->aInCkpt ){
2144: sqliteFree(pPager->aInCkpt);
2145: pPager->aInCkpt = 0;
2146: }
2147: return rc;
2148: }
2149:
2150: /*
2151: ** Commit a checkpoint.
2152: */
2153: int sqlitepager_ckpt_commit(Pager *pPager){
2154: if( pPager->ckptInUse ){
2155: PgHdr *pPg, *pNext;
2156: sqliteOsSeek(&pPager->cpfd, 0);
2157: /* sqliteOsTruncate(&pPager->cpfd, 0); */
2158: pPager->ckptNRec = 0;
2159: pPager->ckptInUse = 0;
2160: sqliteFree( pPager->aInCkpt );
2161: pPager->aInCkpt = 0;
2162: for(pPg=pPager->pCkpt; pPg; pPg=pNext){
2163: pNext = pPg->pNextCkpt;
2164: assert( pPg->inCkpt );
2165: pPg->inCkpt = 0;
2166: pPg->pPrevCkpt = pPg->pNextCkpt = 0;
2167: }
2168: pPager->pCkpt = 0;
2169: }
2170: pPager->ckptAutoopen = 0;
2171: return SQLITE_OK;
2172: }
2173:
2174: /*
2175: ** Rollback a checkpoint.
2176: */
2177: int sqlitepager_ckpt_rollback(Pager *pPager){
2178: int rc;
2179: if( pPager->ckptInUse ){
2180: rc = pager_ckpt_playback(pPager);
2181: sqlitepager_ckpt_commit(pPager);
2182: }else{
2183: rc = SQLITE_OK;
2184: }
2185: pPager->ckptAutoopen = 0;
2186: return rc;
2187: }
2188:
2189: /*
2190: ** Return the full pathname of the database file.
2191: */
2192: const char *sqlitepager_filename(Pager *pPager){
2193: return pPager->zFilename;
2194: }
2195:
2196: /*
2197: ** Set the codec for this pager
2198: */
2199: void sqlitepager_set_codec(
2200: Pager *pPager,
2201: void (*xCodec)(void*,void*,Pgno,int),
2202: void *pCodecArg
2203: ){
2204: pPager->xCodec = xCodec;
2205: pPager->pCodecArg = pCodecArg;
2206: }
2207:
2208: #ifdef SQLITE_TEST
2209: /*
2210: ** Print a listing of all referenced pages and their ref count.
2211: */
2212: void sqlitepager_refdump(Pager *pPager){
2213: PgHdr *pPg;
2214: for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
2215: if( pPg->nRef<=0 ) continue;
2216: printf("PAGE %3d addr=0x%08x nRef=%d\n",
2217: pPg->pgno, (int)PGHDR_TO_DATA(pPg), pPg->nRef);
2218: }
2219: }
2220: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pager.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src