Annotation of embedaddon/sqlite3/src/test_journal.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2008 Jan 22
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: ******************************************************************************
! 12: **
! 13: ** This file contains code for a VFS layer that acts as a wrapper around
! 14: ** an existing VFS. The code in this file attempts to verify that SQLite
! 15: ** correctly populates and syncs a journal file before writing to a
! 16: ** corresponding database file.
! 17: **
! 18: ** INTERFACE
! 19: **
! 20: ** The public interface to this wrapper VFS is two functions:
! 21: **
! 22: ** jt_register()
! 23: ** jt_unregister()
! 24: **
! 25: ** See header comments associated with those two functions below for
! 26: ** details.
! 27: **
! 28: ** LIMITATIONS
! 29: **
! 30: ** This wrapper will not work if "PRAGMA synchronous = off" is used.
! 31: **
! 32: ** OPERATION
! 33: **
! 34: ** Starting a Transaction:
! 35: **
! 36: ** When a write-transaction is started, the contents of the database is
! 37: ** inspected and the following data stored as part of the database file
! 38: ** handle (type struct jt_file):
! 39: **
! 40: ** a) The page-size of the database file.
! 41: ** b) The number of pages that are in the database file.
! 42: ** c) The set of page numbers corresponding to free-list leaf pages.
! 43: ** d) A check-sum for every page in the database file.
! 44: **
! 45: ** The start of a write-transaction is deemed to have occurred when a
! 46: ** 28-byte journal header is written to byte offset 0 of the journal
! 47: ** file.
! 48: **
! 49: ** Syncing the Journal File:
! 50: **
! 51: ** Whenever the xSync method is invoked to sync a journal-file, the
! 52: ** contents of the journal file are read. For each page written to
! 53: ** the journal file, a check-sum is calculated and compared to the
! 54: ** check-sum calculated for the corresponding database page when the
! 55: ** write-transaction was initialized. The success of the comparison
! 56: ** is assert()ed. So if SQLite has written something other than the
! 57: ** original content to the database file, an assert() will fail.
! 58: **
! 59: ** Additionally, the set of page numbers for which records exist in
! 60: ** the journal file is added to (unioned with) the set of page numbers
! 61: ** corresponding to free-list leaf pages collected when the
! 62: ** write-transaction was initialized. This set comprises the page-numbers
! 63: ** corresponding to those pages that SQLite may now safely modify.
! 64: **
! 65: ** Writing to the Database File:
! 66: **
! 67: ** When a block of data is written to a database file, the following
! 68: ** invariants are asserted:
! 69: **
! 70: ** a) That the block of data is an aligned block of page-size bytes.
! 71: **
! 72: ** b) That if the page being written did not exist when the
! 73: ** transaction was started (i.e. the database file is growing), then
! 74: ** the journal-file must have been synced at least once since
! 75: ** the start of the transaction.
! 76: **
! 77: ** c) That if the page being written did exist when the transaction
! 78: ** was started, then the page must have either been a free-list
! 79: ** leaf page at the start of the transaction, or else must have
! 80: ** been stored in the journal file prior to the most recent sync.
! 81: **
! 82: ** Closing a Transaction:
! 83: **
! 84: ** When a transaction is closed, all data collected at the start of
! 85: ** the transaction, or following an xSync of a journal-file, is
! 86: ** discarded. The end of a transaction is recognized when any one
! 87: ** of the following occur:
! 88: **
! 89: ** a) A block of zeroes (or anything else that is not a valid
! 90: ** journal-header) is written to the start of the journal file.
! 91: **
! 92: ** b) A journal file is truncated to zero bytes in size using xTruncate.
! 93: **
! 94: ** c) The journal file is deleted using xDelete.
! 95: */
! 96: #if SQLITE_TEST /* This file is used for testing only */
! 97:
! 98: #include "sqlite3.h"
! 99: #include "sqliteInt.h"
! 100:
! 101: /*
! 102: ** Maximum pathname length supported by the jt backend.
! 103: */
! 104: #define JT_MAX_PATHNAME 512
! 105:
! 106: /*
! 107: ** Name used to identify this VFS.
! 108: */
! 109: #define JT_VFS_NAME "jt"
! 110:
! 111: typedef struct jt_file jt_file;
! 112: struct jt_file {
! 113: sqlite3_file base;
! 114: const char *zName; /* Name of open file */
! 115: int flags; /* Flags the file was opened with */
! 116:
! 117: /* The following are only used by database file file handles */
! 118: int eLock; /* Current lock held on the file */
! 119: u32 nPage; /* Size of file in pages when transaction started */
! 120: u32 nPagesize; /* Page size when transaction started */
! 121: Bitvec *pWritable; /* Bitvec of pages that may be written to the file */
! 122: u32 *aCksum; /* Checksum for first nPage pages */
! 123: int nSync; /* Number of times journal file has been synced */
! 124:
! 125: /* Only used by journal file-handles */
! 126: sqlite3_int64 iMaxOff; /* Maximum offset written to this transaction */
! 127:
! 128: jt_file *pNext; /* All files are stored in a linked list */
! 129: sqlite3_file *pReal; /* The file handle for the underlying vfs */
! 130: };
! 131:
! 132: /*
! 133: ** Method declarations for jt_file.
! 134: */
! 135: static int jtClose(sqlite3_file*);
! 136: static int jtRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
! 137: static int jtWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
! 138: static int jtTruncate(sqlite3_file*, sqlite3_int64 size);
! 139: static int jtSync(sqlite3_file*, int flags);
! 140: static int jtFileSize(sqlite3_file*, sqlite3_int64 *pSize);
! 141: static int jtLock(sqlite3_file*, int);
! 142: static int jtUnlock(sqlite3_file*, int);
! 143: static int jtCheckReservedLock(sqlite3_file*, int *);
! 144: static int jtFileControl(sqlite3_file*, int op, void *pArg);
! 145: static int jtSectorSize(sqlite3_file*);
! 146: static int jtDeviceCharacteristics(sqlite3_file*);
! 147:
! 148: /*
! 149: ** Method declarations for jt_vfs.
! 150: */
! 151: static int jtOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
! 152: static int jtDelete(sqlite3_vfs*, const char *zName, int syncDir);
! 153: static int jtAccess(sqlite3_vfs*, const char *zName, int flags, int *);
! 154: static int jtFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
! 155: static void *jtDlOpen(sqlite3_vfs*, const char *zFilename);
! 156: static void jtDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
! 157: static void (*jtDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);
! 158: static void jtDlClose(sqlite3_vfs*, void*);
! 159: static int jtRandomness(sqlite3_vfs*, int nByte, char *zOut);
! 160: static int jtSleep(sqlite3_vfs*, int microseconds);
! 161: static int jtCurrentTime(sqlite3_vfs*, double*);
! 162: static int jtCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
! 163:
! 164: static sqlite3_vfs jt_vfs = {
! 165: 2, /* iVersion */
! 166: sizeof(jt_file), /* szOsFile */
! 167: JT_MAX_PATHNAME, /* mxPathname */
! 168: 0, /* pNext */
! 169: JT_VFS_NAME, /* zName */
! 170: 0, /* pAppData */
! 171: jtOpen, /* xOpen */
! 172: jtDelete, /* xDelete */
! 173: jtAccess, /* xAccess */
! 174: jtFullPathname, /* xFullPathname */
! 175: jtDlOpen, /* xDlOpen */
! 176: jtDlError, /* xDlError */
! 177: jtDlSym, /* xDlSym */
! 178: jtDlClose, /* xDlClose */
! 179: jtRandomness, /* xRandomness */
! 180: jtSleep, /* xSleep */
! 181: jtCurrentTime, /* xCurrentTime */
! 182: 0, /* xGetLastError */
! 183: jtCurrentTimeInt64 /* xCurrentTimeInt64 */
! 184: };
! 185:
! 186: static sqlite3_io_methods jt_io_methods = {
! 187: 1, /* iVersion */
! 188: jtClose, /* xClose */
! 189: jtRead, /* xRead */
! 190: jtWrite, /* xWrite */
! 191: jtTruncate, /* xTruncate */
! 192: jtSync, /* xSync */
! 193: jtFileSize, /* xFileSize */
! 194: jtLock, /* xLock */
! 195: jtUnlock, /* xUnlock */
! 196: jtCheckReservedLock, /* xCheckReservedLock */
! 197: jtFileControl, /* xFileControl */
! 198: jtSectorSize, /* xSectorSize */
! 199: jtDeviceCharacteristics /* xDeviceCharacteristics */
! 200: };
! 201:
! 202: struct JtGlobal {
! 203: sqlite3_vfs *pVfs; /* Parent VFS */
! 204: jt_file *pList; /* List of all open files */
! 205: };
! 206: static struct JtGlobal g = {0, 0};
! 207:
! 208: /*
! 209: ** Functions to obtain and relinquish a mutex to protect g.pList. The
! 210: ** STATIC_PRNG mutex is reused, purely for the sake of convenience.
! 211: */
! 212: static void enterJtMutex(void){
! 213: sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PRNG));
! 214: }
! 215: static void leaveJtMutex(void){
! 216: sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PRNG));
! 217: }
! 218:
! 219: extern int sqlite3_io_error_pending;
! 220: extern int sqlite3_io_error_hit;
! 221: static void stop_ioerr_simulation(int *piSave, int *piSave2){
! 222: *piSave = sqlite3_io_error_pending;
! 223: *piSave2 = sqlite3_io_error_hit;
! 224: sqlite3_io_error_pending = -1;
! 225: sqlite3_io_error_hit = 0;
! 226: }
! 227: static void start_ioerr_simulation(int iSave, int iSave2){
! 228: sqlite3_io_error_pending = iSave;
! 229: sqlite3_io_error_hit = iSave2;
! 230: }
! 231:
! 232: /*
! 233: ** The jt_file pointed to by the argument may or may not be a file-handle
! 234: ** open on a main database file. If it is, and a transaction is currently
! 235: ** opened on the file, then discard all transaction related data.
! 236: */
! 237: static void closeTransaction(jt_file *p){
! 238: sqlite3BitvecDestroy(p->pWritable);
! 239: sqlite3_free(p->aCksum);
! 240: p->pWritable = 0;
! 241: p->aCksum = 0;
! 242: p->nSync = 0;
! 243: }
! 244:
! 245: /*
! 246: ** Close an jt-file.
! 247: */
! 248: static int jtClose(sqlite3_file *pFile){
! 249: jt_file **pp;
! 250: jt_file *p = (jt_file *)pFile;
! 251:
! 252: closeTransaction(p);
! 253: enterJtMutex();
! 254: if( p->zName ){
! 255: for(pp=&g.pList; *pp!=p; pp=&(*pp)->pNext);
! 256: *pp = p->pNext;
! 257: }
! 258: leaveJtMutex();
! 259: return sqlite3OsClose(p->pReal);
! 260: }
! 261:
! 262: /*
! 263: ** Read data from an jt-file.
! 264: */
! 265: static int jtRead(
! 266: sqlite3_file *pFile,
! 267: void *zBuf,
! 268: int iAmt,
! 269: sqlite_int64 iOfst
! 270: ){
! 271: jt_file *p = (jt_file *)pFile;
! 272: return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
! 273: }
! 274:
! 275: /*
! 276: ** Parameter zJournal is the name of a journal file that is currently
! 277: ** open. This function locates and returns the handle opened on the
! 278: ** corresponding database file by the pager that currently has the
! 279: ** journal file opened. This file-handle is identified by the
! 280: ** following properties:
! 281: **
! 282: ** a) SQLITE_OPEN_MAIN_DB was specified when the file was opened.
! 283: **
! 284: ** b) The file-name specified when the file was opened matches
! 285: ** all but the final 8 characters of the journal file name.
! 286: **
! 287: ** c) There is currently a reserved lock on the file.
! 288: **/
! 289: static jt_file *locateDatabaseHandle(const char *zJournal){
! 290: jt_file *pMain = 0;
! 291: enterJtMutex();
! 292: for(pMain=g.pList; pMain; pMain=pMain->pNext){
! 293: int nName = strlen(zJournal) - strlen("-journal");
! 294: if( (pMain->flags&SQLITE_OPEN_MAIN_DB)
! 295: && (strlen(pMain->zName)==nName)
! 296: && 0==memcmp(pMain->zName, zJournal, nName)
! 297: && (pMain->eLock>=SQLITE_LOCK_RESERVED)
! 298: ){
! 299: break;
! 300: }
! 301: }
! 302: leaveJtMutex();
! 303: return pMain;
! 304: }
! 305:
! 306: /*
! 307: ** Parameter z points to a buffer of 4 bytes in size containing a
! 308: ** unsigned 32-bit integer stored in big-endian format. Decode the
! 309: ** integer and return its value.
! 310: */
! 311: static u32 decodeUint32(const unsigned char *z){
! 312: return (z[0]<<24) + (z[1]<<16) + (z[2]<<8) + z[3];
! 313: }
! 314:
! 315: /*
! 316: ** Calculate a checksum from the buffer of length n bytes pointed to
! 317: ** by parameter z.
! 318: */
! 319: static u32 genCksum(const unsigned char *z, int n){
! 320: int i;
! 321: u32 cksum = 0;
! 322: for(i=0; i<n; i++){
! 323: cksum = cksum + z[i] + (cksum<<3);
! 324: }
! 325: return cksum;
! 326: }
! 327:
! 328: /*
! 329: ** The first argument, zBuf, points to a buffer containing a 28 byte
! 330: ** serialized journal header. This function deserializes four of the
! 331: ** integer fields contained in the journal header and writes their
! 332: ** values to the output variables.
! 333: **
! 334: ** SQLITE_OK is returned if the journal-header is successfully
! 335: ** decoded. Otherwise, SQLITE_ERROR.
! 336: */
! 337: static int decodeJournalHdr(
! 338: const unsigned char *zBuf, /* Input: 28 byte journal header */
! 339: u32 *pnRec, /* Out: Number of journalled records */
! 340: u32 *pnPage, /* Out: Original database page count */
! 341: u32 *pnSector, /* Out: Sector size in bytes */
! 342: u32 *pnPagesize /* Out: Page size in bytes */
! 343: ){
! 344: unsigned char aMagic[] = { 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7 };
! 345: if( memcmp(aMagic, zBuf, 8) ) return SQLITE_ERROR;
! 346: if( pnRec ) *pnRec = decodeUint32(&zBuf[8]);
! 347: if( pnPage ) *pnPage = decodeUint32(&zBuf[16]);
! 348: if( pnSector ) *pnSector = decodeUint32(&zBuf[20]);
! 349: if( pnPagesize ) *pnPagesize = decodeUint32(&zBuf[24]);
! 350: return SQLITE_OK;
! 351: }
! 352:
! 353: /*
! 354: ** This function is called when a new transaction is opened, just after
! 355: ** the first journal-header is written to the journal file.
! 356: */
! 357: static int openTransaction(jt_file *pMain, jt_file *pJournal){
! 358: unsigned char *aData;
! 359: sqlite3_file *p = pMain->pReal;
! 360: int rc = SQLITE_OK;
! 361:
! 362: closeTransaction(pMain);
! 363: aData = sqlite3_malloc(pMain->nPagesize);
! 364: pMain->pWritable = sqlite3BitvecCreate(pMain->nPage);
! 365: pMain->aCksum = sqlite3_malloc(sizeof(u32) * (pMain->nPage + 1));
! 366: pJournal->iMaxOff = 0;
! 367:
! 368: if( !pMain->pWritable || !pMain->aCksum || !aData ){
! 369: rc = SQLITE_IOERR_NOMEM;
! 370: }else if( pMain->nPage>0 ){
! 371: u32 iTrunk;
! 372: int iSave;
! 373: int iSave2;
! 374:
! 375: stop_ioerr_simulation(&iSave, &iSave2);
! 376:
! 377: /* Read the database free-list. Add the page-number for each free-list
! 378: ** leaf to the jt_file.pWritable bitvec.
! 379: */
! 380: rc = sqlite3OsRead(p, aData, pMain->nPagesize, 0);
! 381: if( rc==SQLITE_OK ){
! 382: u32 nDbsize = decodeUint32(&aData[28]);
! 383: if( nDbsize>0 && memcmp(&aData[24], &aData[92], 4)==0 ){
! 384: u32 iPg;
! 385: for(iPg=nDbsize+1; iPg<=pMain->nPage; iPg++){
! 386: sqlite3BitvecSet(pMain->pWritable, iPg);
! 387: }
! 388: }
! 389: }
! 390: iTrunk = decodeUint32(&aData[32]);
! 391: while( rc==SQLITE_OK && iTrunk>0 ){
! 392: u32 nLeaf;
! 393: u32 iLeaf;
! 394: sqlite3_int64 iOff = (i64)(iTrunk-1)*pMain->nPagesize;
! 395: rc = sqlite3OsRead(p, aData, pMain->nPagesize, iOff);
! 396: nLeaf = decodeUint32(&aData[4]);
! 397: for(iLeaf=0; rc==SQLITE_OK && iLeaf<nLeaf; iLeaf++){
! 398: u32 pgno = decodeUint32(&aData[8+4*iLeaf]);
! 399: sqlite3BitvecSet(pMain->pWritable, pgno);
! 400: }
! 401: iTrunk = decodeUint32(aData);
! 402: }
! 403:
! 404: /* Calculate and store a checksum for each page in the database file. */
! 405: if( rc==SQLITE_OK ){
! 406: int ii;
! 407: for(ii=0; rc==SQLITE_OK && ii<pMain->nPage; ii++){
! 408: i64 iOff = (i64)(pMain->nPagesize) * (i64)ii;
! 409: if( iOff==PENDING_BYTE ) continue;
! 410: rc = sqlite3OsRead(pMain->pReal, aData, pMain->nPagesize, iOff);
! 411: pMain->aCksum[ii] = genCksum(aData, pMain->nPagesize);
! 412: if( ii+1==pMain->nPage && rc==SQLITE_IOERR_SHORT_READ ) rc = SQLITE_OK;
! 413: }
! 414: }
! 415:
! 416: start_ioerr_simulation(iSave, iSave2);
! 417: }
! 418:
! 419: sqlite3_free(aData);
! 420: return rc;
! 421: }
! 422:
! 423: /*
! 424: ** The first argument to this function is a handle open on a journal file.
! 425: ** This function reads the journal file and adds the page number for each
! 426: ** page in the journal to the Bitvec object passed as the second argument.
! 427: */
! 428: static int readJournalFile(jt_file *p, jt_file *pMain){
! 429: int rc = SQLITE_OK;
! 430: unsigned char zBuf[28];
! 431: sqlite3_file *pReal = p->pReal;
! 432: sqlite3_int64 iOff = 0;
! 433: sqlite3_int64 iSize = p->iMaxOff;
! 434: unsigned char *aPage;
! 435: int iSave;
! 436: int iSave2;
! 437:
! 438: aPage = sqlite3_malloc(pMain->nPagesize);
! 439: if( !aPage ){
! 440: return SQLITE_IOERR_NOMEM;
! 441: }
! 442:
! 443: stop_ioerr_simulation(&iSave, &iSave2);
! 444:
! 445: while( rc==SQLITE_OK && iOff<iSize ){
! 446: u32 nRec, nPage, nSector, nPagesize;
! 447: u32 ii;
! 448:
! 449: /* Read and decode the next journal-header from the journal file. */
! 450: rc = sqlite3OsRead(pReal, zBuf, 28, iOff);
! 451: if( rc!=SQLITE_OK
! 452: || decodeJournalHdr(zBuf, &nRec, &nPage, &nSector, &nPagesize)
! 453: ){
! 454: goto finish_rjf;
! 455: }
! 456: iOff += nSector;
! 457:
! 458: if( nRec==0 ){
! 459: /* A trick. There might be another journal-header immediately
! 460: ** following this one. In this case, 0 records means 0 records,
! 461: ** not "read until the end of the file". See also ticket #2565.
! 462: */
! 463: if( iSize>=(iOff+nSector) ){
! 464: rc = sqlite3OsRead(pReal, zBuf, 28, iOff);
! 465: if( rc!=SQLITE_OK || 0==decodeJournalHdr(zBuf, 0, 0, 0, 0) ){
! 466: continue;
! 467: }
! 468: }
! 469: nRec = (iSize-iOff) / (pMain->nPagesize+8);
! 470: }
! 471:
! 472: /* Read all the records that follow the journal-header just read. */
! 473: for(ii=0; rc==SQLITE_OK && ii<nRec && iOff<iSize; ii++){
! 474: u32 pgno;
! 475: rc = sqlite3OsRead(pReal, zBuf, 4, iOff);
! 476: if( rc==SQLITE_OK ){
! 477: pgno = decodeUint32(zBuf);
! 478: if( pgno>0 && pgno<=pMain->nPage ){
! 479: if( 0==sqlite3BitvecTest(pMain->pWritable, pgno) ){
! 480: rc = sqlite3OsRead(pReal, aPage, pMain->nPagesize, iOff+4);
! 481: if( rc==SQLITE_OK ){
! 482: u32 cksum = genCksum(aPage, pMain->nPagesize);
! 483: assert( cksum==pMain->aCksum[pgno-1] );
! 484: }
! 485: }
! 486: sqlite3BitvecSet(pMain->pWritable, pgno);
! 487: }
! 488: iOff += (8 + pMain->nPagesize);
! 489: }
! 490: }
! 491:
! 492: iOff = ((iOff + (nSector-1)) / nSector) * nSector;
! 493: }
! 494:
! 495: finish_rjf:
! 496: start_ioerr_simulation(iSave, iSave2);
! 497: sqlite3_free(aPage);
! 498: if( rc==SQLITE_IOERR_SHORT_READ ){
! 499: rc = SQLITE_OK;
! 500: }
! 501: return rc;
! 502: }
! 503:
! 504: /*
! 505: ** Write data to an jt-file.
! 506: */
! 507: static int jtWrite(
! 508: sqlite3_file *pFile,
! 509: const void *zBuf,
! 510: int iAmt,
! 511: sqlite_int64 iOfst
! 512: ){
! 513: int rc;
! 514: jt_file *p = (jt_file *)pFile;
! 515: if( p->flags&SQLITE_OPEN_MAIN_JOURNAL ){
! 516: if( iOfst==0 ){
! 517: jt_file *pMain = locateDatabaseHandle(p->zName);
! 518: assert( pMain );
! 519:
! 520: if( iAmt==28 ){
! 521: /* Zeroing the first journal-file header. This is the end of a
! 522: ** transaction. */
! 523: closeTransaction(pMain);
! 524: }else if( iAmt!=12 ){
! 525: /* Writing the first journal header to a journal file. This happens
! 526: ** when a transaction is first started. */
! 527: u8 *z = (u8 *)zBuf;
! 528: pMain->nPage = decodeUint32(&z[16]);
! 529: pMain->nPagesize = decodeUint32(&z[24]);
! 530: if( SQLITE_OK!=(rc=openTransaction(pMain, p)) ){
! 531: return rc;
! 532: }
! 533: }
! 534: }
! 535: if( p->iMaxOff<(iOfst + iAmt) ){
! 536: p->iMaxOff = iOfst + iAmt;
! 537: }
! 538: }
! 539:
! 540: if( p->flags&SQLITE_OPEN_MAIN_DB && p->pWritable ){
! 541: if( iAmt<p->nPagesize
! 542: && p->nPagesize%iAmt==0
! 543: && iOfst>=(PENDING_BYTE+512)
! 544: && iOfst+iAmt<=PENDING_BYTE+p->nPagesize
! 545: ){
! 546: /* No-op. This special case is hit when the backup code is copying a
! 547: ** to a database with a larger page-size than the source database and
! 548: ** it needs to fill in the non-locking-region part of the original
! 549: ** pending-byte page.
! 550: */
! 551: }else{
! 552: u32 pgno = iOfst/p->nPagesize + 1;
! 553: assert( (iAmt==1||iAmt==p->nPagesize) && ((iOfst+iAmt)%p->nPagesize)==0 );
! 554: assert( pgno<=p->nPage || p->nSync>0 );
! 555: assert( pgno>p->nPage || sqlite3BitvecTest(p->pWritable, pgno) );
! 556: }
! 557: }
! 558:
! 559: rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
! 560: if( (p->flags&SQLITE_OPEN_MAIN_JOURNAL) && iAmt==12 ){
! 561: jt_file *pMain = locateDatabaseHandle(p->zName);
! 562: int rc2 = readJournalFile(p, pMain);
! 563: if( rc==SQLITE_OK ) rc = rc2;
! 564: }
! 565: return rc;
! 566: }
! 567:
! 568: /*
! 569: ** Truncate an jt-file.
! 570: */
! 571: static int jtTruncate(sqlite3_file *pFile, sqlite_int64 size){
! 572: jt_file *p = (jt_file *)pFile;
! 573: if( p->flags&SQLITE_OPEN_MAIN_JOURNAL && size==0 ){
! 574: /* Truncating a journal file. This is the end of a transaction. */
! 575: jt_file *pMain = locateDatabaseHandle(p->zName);
! 576: closeTransaction(pMain);
! 577: }
! 578: if( p->flags&SQLITE_OPEN_MAIN_DB && p->pWritable ){
! 579: u32 pgno;
! 580: u32 locking_page = (u32)(PENDING_BYTE/p->nPagesize+1);
! 581: for(pgno=size/p->nPagesize+1; pgno<=p->nPage; pgno++){
! 582: assert( pgno==locking_page || sqlite3BitvecTest(p->pWritable, pgno) );
! 583: }
! 584: }
! 585: return sqlite3OsTruncate(p->pReal, size);
! 586: }
! 587:
! 588: /*
! 589: ** Sync an jt-file.
! 590: */
! 591: static int jtSync(sqlite3_file *pFile, int flags){
! 592: jt_file *p = (jt_file *)pFile;
! 593:
! 594: if( p->flags&SQLITE_OPEN_MAIN_JOURNAL ){
! 595: int rc;
! 596: jt_file *pMain; /* The associated database file */
! 597:
! 598: /* The journal file is being synced. At this point, we inspect the
! 599: ** contents of the file up to this point and set each bit in the
! 600: ** jt_file.pWritable bitvec of the main database file associated with
! 601: ** this journal file.
! 602: */
! 603: pMain = locateDatabaseHandle(p->zName);
! 604: assert(pMain);
! 605:
! 606: /* Set the bitvec values */
! 607: if( pMain->pWritable ){
! 608: pMain->nSync++;
! 609: rc = readJournalFile(p, pMain);
! 610: if( rc!=SQLITE_OK ){
! 611: return rc;
! 612: }
! 613: }
! 614: }
! 615:
! 616: return sqlite3OsSync(p->pReal, flags);
! 617: }
! 618:
! 619: /*
! 620: ** Return the current file-size of an jt-file.
! 621: */
! 622: static int jtFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
! 623: jt_file *p = (jt_file *)pFile;
! 624: return sqlite3OsFileSize(p->pReal, pSize);
! 625: }
! 626:
! 627: /*
! 628: ** Lock an jt-file.
! 629: */
! 630: static int jtLock(sqlite3_file *pFile, int eLock){
! 631: int rc;
! 632: jt_file *p = (jt_file *)pFile;
! 633: rc = sqlite3OsLock(p->pReal, eLock);
! 634: if( rc==SQLITE_OK && eLock>p->eLock ){
! 635: p->eLock = eLock;
! 636: }
! 637: return rc;
! 638: }
! 639:
! 640: /*
! 641: ** Unlock an jt-file.
! 642: */
! 643: static int jtUnlock(sqlite3_file *pFile, int eLock){
! 644: int rc;
! 645: jt_file *p = (jt_file *)pFile;
! 646: rc = sqlite3OsUnlock(p->pReal, eLock);
! 647: if( rc==SQLITE_OK && eLock<p->eLock ){
! 648: p->eLock = eLock;
! 649: }
! 650: return rc;
! 651: }
! 652:
! 653: /*
! 654: ** Check if another file-handle holds a RESERVED lock on an jt-file.
! 655: */
! 656: static int jtCheckReservedLock(sqlite3_file *pFile, int *pResOut){
! 657: jt_file *p = (jt_file *)pFile;
! 658: return sqlite3OsCheckReservedLock(p->pReal, pResOut);
! 659: }
! 660:
! 661: /*
! 662: ** File control method. For custom operations on an jt-file.
! 663: */
! 664: static int jtFileControl(sqlite3_file *pFile, int op, void *pArg){
! 665: jt_file *p = (jt_file *)pFile;
! 666: return p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
! 667: }
! 668:
! 669: /*
! 670: ** Return the sector-size in bytes for an jt-file.
! 671: */
! 672: static int jtSectorSize(sqlite3_file *pFile){
! 673: jt_file *p = (jt_file *)pFile;
! 674: return sqlite3OsSectorSize(p->pReal);
! 675: }
! 676:
! 677: /*
! 678: ** Return the device characteristic flags supported by an jt-file.
! 679: */
! 680: static int jtDeviceCharacteristics(sqlite3_file *pFile){
! 681: jt_file *p = (jt_file *)pFile;
! 682: return sqlite3OsDeviceCharacteristics(p->pReal);
! 683: }
! 684:
! 685: /*
! 686: ** Open an jt file handle.
! 687: */
! 688: static int jtOpen(
! 689: sqlite3_vfs *pVfs,
! 690: const char *zName,
! 691: sqlite3_file *pFile,
! 692: int flags,
! 693: int *pOutFlags
! 694: ){
! 695: int rc;
! 696: jt_file *p = (jt_file *)pFile;
! 697: pFile->pMethods = 0;
! 698: p->pReal = (sqlite3_file *)&p[1];
! 699: p->pReal->pMethods = 0;
! 700: rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);
! 701: assert( rc==SQLITE_OK || p->pReal->pMethods==0 );
! 702: if( rc==SQLITE_OK ){
! 703: pFile->pMethods = &jt_io_methods;
! 704: p->eLock = 0;
! 705: p->zName = zName;
! 706: p->flags = flags;
! 707: p->pNext = 0;
! 708: p->pWritable = 0;
! 709: p->aCksum = 0;
! 710: enterJtMutex();
! 711: if( zName ){
! 712: p->pNext = g.pList;
! 713: g.pList = p;
! 714: }
! 715: leaveJtMutex();
! 716: }
! 717: return rc;
! 718: }
! 719:
! 720: /*
! 721: ** Delete the file located at zPath. If the dirSync argument is true,
! 722: ** ensure the file-system modifications are synced to disk before
! 723: ** returning.
! 724: */
! 725: static int jtDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
! 726: int nPath = strlen(zPath);
! 727: if( nPath>8 && 0==strcmp("-journal", &zPath[nPath-8]) ){
! 728: /* Deleting a journal file. The end of a transaction. */
! 729: jt_file *pMain = locateDatabaseHandle(zPath);
! 730: if( pMain ){
! 731: closeTransaction(pMain);
! 732: }
! 733: }
! 734:
! 735: return sqlite3OsDelete(g.pVfs, zPath, dirSync);
! 736: }
! 737:
! 738: /*
! 739: ** Test for access permissions. Return true if the requested permission
! 740: ** is available, or false otherwise.
! 741: */
! 742: static int jtAccess(
! 743: sqlite3_vfs *pVfs,
! 744: const char *zPath,
! 745: int flags,
! 746: int *pResOut
! 747: ){
! 748: return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut);
! 749: }
! 750:
! 751: /*
! 752: ** Populate buffer zOut with the full canonical pathname corresponding
! 753: ** to the pathname in zPath. zOut is guaranteed to point to a buffer
! 754: ** of at least (JT_MAX_PATHNAME+1) bytes.
! 755: */
! 756: static int jtFullPathname(
! 757: sqlite3_vfs *pVfs,
! 758: const char *zPath,
! 759: int nOut,
! 760: char *zOut
! 761: ){
! 762: return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut);
! 763: }
! 764:
! 765: /*
! 766: ** Open the dynamic library located at zPath and return a handle.
! 767: */
! 768: static void *jtDlOpen(sqlite3_vfs *pVfs, const char *zPath){
! 769: return g.pVfs->xDlOpen(g.pVfs, zPath);
! 770: }
! 771:
! 772: /*
! 773: ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
! 774: ** utf-8 string describing the most recent error encountered associated
! 775: ** with dynamic libraries.
! 776: */
! 777: static void jtDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
! 778: g.pVfs->xDlError(g.pVfs, nByte, zErrMsg);
! 779: }
! 780:
! 781: /*
! 782: ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
! 783: */
! 784: static void (*jtDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
! 785: return g.pVfs->xDlSym(g.pVfs, p, zSym);
! 786: }
! 787:
! 788: /*
! 789: ** Close the dynamic library handle pHandle.
! 790: */
! 791: static void jtDlClose(sqlite3_vfs *pVfs, void *pHandle){
! 792: g.pVfs->xDlClose(g.pVfs, pHandle);
! 793: }
! 794:
! 795: /*
! 796: ** Populate the buffer pointed to by zBufOut with nByte bytes of
! 797: ** random data.
! 798: */
! 799: static int jtRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
! 800: return sqlite3OsRandomness(g.pVfs, nByte, zBufOut);
! 801: }
! 802:
! 803: /*
! 804: ** Sleep for nMicro microseconds. Return the number of microseconds
! 805: ** actually slept.
! 806: */
! 807: static int jtSleep(sqlite3_vfs *pVfs, int nMicro){
! 808: return sqlite3OsSleep(g.pVfs, nMicro);
! 809: }
! 810:
! 811: /*
! 812: ** Return the current time as a Julian Day number in *pTimeOut.
! 813: */
! 814: static int jtCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
! 815: return g.pVfs->xCurrentTime(g.pVfs, pTimeOut);
! 816: }
! 817: /*
! 818: ** Return the current time as a Julian Day number in *pTimeOut.
! 819: */
! 820: static int jtCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
! 821: return g.pVfs->xCurrentTimeInt64(g.pVfs, pTimeOut);
! 822: }
! 823:
! 824: /**************************************************************************
! 825: ** Start of public API.
! 826: */
! 827:
! 828: /*
! 829: ** Configure the jt VFS as a wrapper around the VFS named by parameter
! 830: ** zWrap. If the isDefault parameter is true, then the jt VFS is installed
! 831: ** as the new default VFS for SQLite connections. If isDefault is not
! 832: ** true, then the jt VFS is installed as non-default. In this case it
! 833: ** is available via its name, "jt".
! 834: */
! 835: int jt_register(char *zWrap, int isDefault){
! 836: g.pVfs = sqlite3_vfs_find(zWrap);
! 837: if( g.pVfs==0 ){
! 838: return SQLITE_ERROR;
! 839: }
! 840: jt_vfs.szOsFile = sizeof(jt_file) + g.pVfs->szOsFile;
! 841: if( g.pVfs->iVersion==1 ){
! 842: jt_vfs.iVersion = 1;
! 843: }else if( g.pVfs->xCurrentTimeInt64==0 ){
! 844: jt_vfs.xCurrentTimeInt64 = 0;
! 845: }
! 846: sqlite3_vfs_register(&jt_vfs, isDefault);
! 847: return SQLITE_OK;
! 848: }
! 849:
! 850: /*
! 851: ** Uninstall the jt VFS, if it is installed.
! 852: */
! 853: void jt_unregister(void){
! 854: sqlite3_vfs_unregister(&jt_vfs);
! 855: }
! 856:
! 857: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_journal.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src