AryaWu/sqlite

1/*2** 2008 Jan 223**4** The author disclaims copyright to this source code.  In place of5** 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 around14** an existing VFS. The code in this file attempts to verify that SQLite15** correctly populates and syncs a journal file before writing to a16** corresponding database file.17**18** INTERFACE19**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** LIMITATIONS29**30**   This wrapper will not work if "PRAGMA synchronous = off" is used.31**32** OPERATION33**34**  Starting a Transaction:35**36**   When a write-transaction is started, the contents of the database is37**   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, the52**   contents of the journal file are read. For each page written to53**   the journal file, a check-sum is calculated and compared to the  54**   check-sum calculated for the corresponding database page when the55**   write-transaction was initialized. The success of the comparison56**   is assert()ed. So if SQLite has written something other than the57**   original content to the database file, an assert() will fail.58**59**   Additionally, the set of page numbers for which records exist in60**   the journal file is added to (unioned with) the set of page numbers61**   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 following68**   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), then74**        the journal-file must have been synced at least once since75**        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-list79**        leaf page at the start of the transaction, or else must have80**        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 of85**   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 512105 106/*107** Name used to identify this VFS.108*/109#define JT_VFS_NAME "jt"110 111typedef struct jt_file jt_file;112struct 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*/135static int jtClose(sqlite3_file*);136static int jtRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);137static int jtWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);138static int jtTruncate(sqlite3_file*, sqlite3_int64 size);139static int jtSync(sqlite3_file*, int flags);140static int jtFileSize(sqlite3_file*, sqlite3_int64 *pSize);141static int jtLock(sqlite3_file*, int);142static int jtUnlock(sqlite3_file*, int);143static int jtCheckReservedLock(sqlite3_file*, int *);144static int jtFileControl(sqlite3_file*, int op, void *pArg);145static int jtSectorSize(sqlite3_file*);146static int jtDeviceCharacteristics(sqlite3_file*);147 148/*149** Method declarations for jt_vfs.150*/151static int jtOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);152static int jtDelete(sqlite3_vfs*, const char *zName, int syncDir);153static int jtAccess(sqlite3_vfs*, const char *zName, int flags, int *);154static int jtFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);155static void *jtDlOpen(sqlite3_vfs*, const char *zFilename);156static void jtDlError(sqlite3_vfs*, int nByte, char *zErrMsg);157static void (*jtDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);158static void jtDlClose(sqlite3_vfs*, void*);159static int jtRandomness(sqlite3_vfs*, int nByte, char *zOut);160static int jtSleep(sqlite3_vfs*, int microseconds);161static int jtCurrentTime(sqlite3_vfs*, double*);162static int jtCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);163static int jtGetLastError(sqlite3_vfs*, int, char*);164 165static sqlite3_vfs jt_vfs = {166  2,                             /* iVersion */167  sizeof(jt_file),               /* szOsFile */168  JT_MAX_PATHNAME,               /* mxPathname */169  0,                             /* pNext */170  JT_VFS_NAME,                   /* zName */171  0,                             /* pAppData */172  jtOpen,                        /* xOpen */173  jtDelete,                      /* xDelete */174  jtAccess,                      /* xAccess */175  jtFullPathname,                /* xFullPathname */176  jtDlOpen,                      /* xDlOpen */177  jtDlError,                     /* xDlError */178  jtDlSym,                       /* xDlSym */179  jtDlClose,                     /* xDlClose */180  jtRandomness,                  /* xRandomness */181  jtSleep,                       /* xSleep */182  jtCurrentTime,                 /* xCurrentTime */183  jtGetLastError,                /* xGetLastError */184  jtCurrentTimeInt64             /* xCurrentTimeInt64 */185};186 187static sqlite3_io_methods jt_io_methods = {188  1,                             /* iVersion */189  jtClose,                       /* xClose */190  jtRead,                        /* xRead */191  jtWrite,                       /* xWrite */192  jtTruncate,                    /* xTruncate */193  jtSync,                        /* xSync */194  jtFileSize,                    /* xFileSize */195  jtLock,                        /* xLock */196  jtUnlock,                      /* xUnlock */197  jtCheckReservedLock,           /* xCheckReservedLock */198  jtFileControl,                 /* xFileControl */199  jtSectorSize,                  /* xSectorSize */200  jtDeviceCharacteristics        /* xDeviceCharacteristics */201};202 203struct JtGlobal {204  sqlite3_vfs *pVfs;             /* Parent VFS */205  jt_file *pList;                /* List of all open files */206};207static struct JtGlobal g = {0, 0};208 209/*210** Functions to obtain and relinquish a mutex to protect g.pList. The211** STATIC_PRNG mutex is reused, purely for the sake of convenience.212*/213static void enterJtMutex(void){214  sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PRNG));215}216static void leaveJtMutex(void){217  sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PRNG));218}219 220extern int sqlite3_io_error_pending;221extern int sqlite3_io_error_hit;222static void stop_ioerr_simulation(int *piSave, int *piSave2){223  *piSave = sqlite3_io_error_pending;224  *piSave2 = sqlite3_io_error_hit;225  sqlite3_io_error_pending = -1;226  sqlite3_io_error_hit = 0;227}228static void start_ioerr_simulation(int iSave, int iSave2){229  sqlite3_io_error_pending = iSave;230  sqlite3_io_error_hit = iSave2;231}232 233/*234** The jt_file pointed to by the argument may or may not be a file-handle235** open on a main database file. If it is, and a transaction is currently236** opened on the file, then discard all transaction related data.237*/238static void closeTransaction(jt_file *p){239  sqlite3BitvecDestroy(p->pWritable);240  sqlite3_free(p->aCksum);241  p->pWritable = 0;242  p->aCksum = 0;243  p->nSync = 0;244}245 246/*247** Close an jt-file.248*/249static int jtClose(sqlite3_file *pFile){250  jt_file **pp;251  jt_file *p = (jt_file *)pFile;252 253  closeTransaction(p);254  enterJtMutex();255  if( p->zName ){256    for(pp=&g.pList; *pp!=p; pp=&(*pp)->pNext);257    *pp = p->pNext;258  }259  leaveJtMutex();260  sqlite3OsClose(p->pReal);261  return SQLITE_OK;262}263 264/*265** Read data from an jt-file.266*/267static int jtRead(268  sqlite3_file *pFile, 269  void *zBuf, 270  int iAmt, 271  sqlite_int64 iOfst272){273  jt_file *p = (jt_file *)pFile;274  return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);275}276 277/*278** Parameter zJournal is the name of a journal file that is currently 279** open. This function locates and returns the handle opened on the280** corresponding database file by the pager that currently has the281** journal file opened. This file-handle is identified by the 282** following properties:283**284**   a) SQLITE_OPEN_MAIN_DB was specified when the file was opened.285**286**   b) The file-name specified when the file was opened matches287**      all but the final 8 characters of the journal file name.288**289**   c) There is currently a reserved lock on the file. This 290**      condition is waived if the noLock argument is non-zero.291**/292static jt_file *locateDatabaseHandle(const char *zJournal, int noLock){293  jt_file *pMain = 0;294  enterJtMutex();295  for(pMain=g.pList; pMain; pMain=pMain->pNext){296    int nName = (int)(strlen(zJournal) - strlen("-journal"));297    if( (pMain->flags&SQLITE_OPEN_MAIN_DB)298     && ((int)strlen(pMain->zName)==nName)299     && 0==memcmp(pMain->zName, zJournal, nName)300     && ((pMain->eLock>=SQLITE_LOCK_RESERVED) || noLock)301    ){302      break;303    }304  }305  leaveJtMutex();306  return pMain;307}308 309/*310** Parameter z points to a buffer of 4 bytes in size containing a 311** unsigned 32-bit integer stored in big-endian format. Decode the 312** integer and return its value.313*/314static u32 decodeUint32(const unsigned char *z){315  return (z[0]<<24) + (z[1]<<16) + (z[2]<<8) + z[3];316}317 318/*319** Calculate a checksum from the buffer of length n bytes pointed to320** by parameter z.321*/322static u32 genCksum(const unsigned char *z, int n){323  int i;324  u32 cksum = 0;325  for(i=0; i<n; i++){326    cksum = cksum + z[i] + (cksum<<3);327  }328  return cksum;329}330 331/*332** The first argument, zBuf, points to a buffer containing a 28 byte333** serialized journal header. This function deserializes four of the334** integer fields contained in the journal header and writes their335** values to the output variables.336**337** SQLITE_OK is returned if the journal-header is successfully 338** decoded. Otherwise, SQLITE_ERROR.339*/340static int decodeJournalHdr(341  const unsigned char *zBuf,         /* Input: 28 byte journal header */342  u32 *pnRec,                        /* Out: Number of journalled records */343  u32 *pnPage,                       /* Out: Original database page count */344  u32 *pnSector,                     /* Out: Sector size in bytes */345  u32 *pnPagesize                    /* Out: Page size in bytes */346){347  unsigned char aMagic[] = { 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7 };348  if( memcmp(aMagic, zBuf, 8) ) return SQLITE_ERROR;349  if( pnRec ) *pnRec = decodeUint32(&zBuf[8]);350  if( pnPage ) *pnPage = decodeUint32(&zBuf[16]);351  if( pnSector ) *pnSector = decodeUint32(&zBuf[20]);352  if( pnPagesize ) *pnPagesize = decodeUint32(&zBuf[24]);353  return SQLITE_OK;354}355 356/*357** This function is called when a new transaction is opened, just after358** the first journal-header is written to the journal file.359*/360static int openTransaction(jt_file *pMain, jt_file *pJournal){361  unsigned char *aData;362  sqlite3_file *p = pMain->pReal;363  int rc = SQLITE_OK;364 365  closeTransaction(pMain);366  aData = sqlite3_malloc(pMain->nPagesize);367  pMain->pWritable = sqlite3BitvecCreate(pMain->nPage);368  pMain->aCksum = sqlite3_malloc(sizeof(u32) * (pMain->nPage + 1));369  pJournal->iMaxOff = 0;370 371  if( !pMain->pWritable || !pMain->aCksum || !aData ){372    rc = SQLITE_IOERR_NOMEM;373  }else if( pMain->nPage>0 ){374    u32 iTrunk;375    int iSave;376    int iSave2;377 378    stop_ioerr_simulation(&iSave, &iSave2);379 380    /* Read the database free-list. Add the page-number for each free-list381    ** leaf to the jt_file.pWritable bitvec.382    */383    rc = sqlite3OsRead(p, aData, pMain->nPagesize, 0);384    if( rc==SQLITE_OK ){385      u32 nDbsize = decodeUint32(&aData[28]);386      if( nDbsize>0 && memcmp(&aData[24], &aData[92], 4)==0 ){387        u32 iPg;388        for(iPg=nDbsize+1; iPg<=pMain->nPage; iPg++){389          sqlite3BitvecSet(pMain->pWritable, iPg);390        }391      }392    }393    iTrunk = decodeUint32(&aData[32]);394    while( rc==SQLITE_OK && iTrunk>0 ){395      u32 nLeaf;396      u32 iLeaf;397      sqlite3_int64 iOff = (i64)(iTrunk-1)*pMain->nPagesize;398      rc = sqlite3OsRead(p, aData, pMain->nPagesize, iOff);399      nLeaf = decodeUint32(&aData[4]);400      for(iLeaf=0; rc==SQLITE_OK && iLeaf<nLeaf; iLeaf++){401        u32 pgno = decodeUint32(&aData[8+4*iLeaf]);402        sqlite3BitvecSet(pMain->pWritable, pgno);403      }404      iTrunk = decodeUint32(aData);405    }406 407    /* Calculate and store a checksum for each page in the database file. */408    if( rc==SQLITE_OK ){409      int ii;410      for(ii=0; rc==SQLITE_OK && ii<(int)pMain->nPage; ii++){411        i64 iOff = (i64)(pMain->nPagesize) * (i64)ii;412        if( iOff==PENDING_BYTE ) continue;413        rc = sqlite3OsRead(pMain->pReal, aData, pMain->nPagesize, iOff);414        pMain->aCksum[ii] = genCksum(aData, pMain->nPagesize);415        if( ii+1==(int)pMain->nPage && rc==SQLITE_IOERR_SHORT_READ ){416          rc = SQLITE_OK;417        }418      }419    }420 421    start_ioerr_simulation(iSave, iSave2);422  }423 424  sqlite3_free(aData);425  return rc;426}427 428/*429** The first argument to this function is a handle open on a journal file.430** This function reads the journal file and adds the page number for each431** page in the journal to the Bitvec object passed as the second argument.432*/433static int readJournalFile(jt_file *p, jt_file *pMain){434  int rc = SQLITE_OK;435  unsigned char zBuf[28];436  sqlite3_file *pReal = p->pReal;437  sqlite3_int64 iOff = 0;438  sqlite3_int64 iSize = p->iMaxOff;439  unsigned char *aPage;440  int iSave;441  int iSave2;442 443  aPage = sqlite3_malloc(pMain->nPagesize);444  if( !aPage ){445    return SQLITE_IOERR_NOMEM;446  }447 448  stop_ioerr_simulation(&iSave, &iSave2);449 450  while( rc==SQLITE_OK && iOff<iSize ){451    u32 nRec, nPage, nSector, nPagesize;452    u32 ii;453 454    /* Read and decode the next journal-header from the journal file. */455    rc = sqlite3OsRead(pReal, zBuf, 28, iOff);456    if( rc!=SQLITE_OK 457     || decodeJournalHdr(zBuf, &nRec, &nPage, &nSector, &nPagesize) 458    ){459      goto finish_rjf;460    }461    iOff += nSector;462 463    if( nRec==0 ){464      /* A trick. There might be another journal-header immediately 465      ** following this one. In this case, 0 records means 0 records, 466      ** not "read until the end of the file". See also ticket #2565.467      */468      if( iSize>=(iOff+nSector) ){469        rc = sqlite3OsRead(pReal, zBuf, 28, iOff);470        if( rc!=SQLITE_OK || 0==decodeJournalHdr(zBuf, 0, 0, 0, 0) ){471          continue;472        }473      }474      nRec = (u32)((iSize-iOff) / (pMain->nPagesize+8));475    }476 477    /* Read all the records that follow the journal-header just read. */478    for(ii=0; rc==SQLITE_OK && ii<nRec && iOff<iSize; ii++){479      u32 pgno;480      rc = sqlite3OsRead(pReal, zBuf, 4, iOff);481      if( rc==SQLITE_OK ){482        pgno = decodeUint32(zBuf);483        if( pgno>0 && pgno<=pMain->nPage ){484          if( 0==sqlite3BitvecTest(pMain->pWritable, pgno) ){485            rc = sqlite3OsRead(pReal, aPage, pMain->nPagesize, iOff+4);486            if( rc==SQLITE_OK ){487              u32 cksum = genCksum(aPage, pMain->nPagesize);488              assert( cksum==pMain->aCksum[pgno-1] );489            }490          }491          sqlite3BitvecSet(pMain->pWritable, pgno);492        }493        iOff += (8 + pMain->nPagesize);494      }495    }496 497    iOff = ((iOff + (nSector-1)) / nSector) * nSector;498  }499 500finish_rjf:501  start_ioerr_simulation(iSave, iSave2);502  sqlite3_free(aPage);503  if( rc==SQLITE_IOERR_SHORT_READ ){504    rc = SQLITE_OK;505  }506  return rc;507}508 509/*510** Write data to an jt-file.511*/512static int jtWrite(513  sqlite3_file *pFile, 514  const void *zBuf, 515  int iAmt, 516  sqlite_int64 iOfst517){518  int rc;519  jt_file *p = (jt_file *)pFile;520  if( p->flags&SQLITE_OPEN_MAIN_JOURNAL ){521    if( iOfst==0 ){522      jt_file *pMain = locateDatabaseHandle(p->zName, 0);523      assert( pMain );524  525      if( iAmt==28 ){526        /* Zeroing the first journal-file header. This is the end of a527        ** transaction. */528        closeTransaction(pMain);529      }else if( iAmt!=12 ){530        /* Writing the first journal header to a journal file. This happens531        ** when a transaction is first started.  */532        u8 *z = (u8 *)zBuf;533        pMain->nPage = decodeUint32(&z[16]);534        pMain->nPagesize = decodeUint32(&z[24]);535        if( SQLITE_OK!=(rc=openTransaction(pMain, p)) ){536          return rc;537        }538      }539    }540    if( p->iMaxOff<(iOfst + iAmt) ){541      p->iMaxOff = iOfst + iAmt;542    }543  }544 545  if( p->flags&SQLITE_OPEN_MAIN_DB && p->pWritable ){546    if( iAmt<(int)p->nPagesize 547     && p->nPagesize%iAmt==0 548     && iOfst>=(PENDING_BYTE+512) 549     && iOfst+iAmt<=PENDING_BYTE+p->nPagesize550    ){551      /* No-op. This special case is hit when the backup code is copying a552      ** to a database with a larger page-size than the source database and553      ** it needs to fill in the non-locking-region part of the original554      ** pending-byte page.555      */556    }else{557      u32 pgno = (u32)(iOfst/p->nPagesize + 1);558      assert( (iAmt==1||iAmt==(int)p->nPagesize) &&559              ((iOfst+iAmt)%p->nPagesize)==0 );560      /* The following assert() statements may fail if this layer is used561      ** with a connection in "PRAGMA synchronous=off" mode. If they562      ** fail with sync=normal or sync=full, this may indicate problem.  */563      assert( p->nPage==0 || pgno<=p->nPage || p->nSync>0 );564      assert( pgno>p->nPage || sqlite3BitvecTest(p->pWritable, pgno) );565    }566  }567 568  rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);569  if( (p->flags&SQLITE_OPEN_MAIN_JOURNAL) && iAmt==12 ){570    jt_file *pMain = locateDatabaseHandle(p->zName, 0);571    int rc2 = readJournalFile(p, pMain);572    if( rc==SQLITE_OK ) rc = rc2;573  }574  return rc;575}576 577/*578** Truncate an jt-file.579*/580static int jtTruncate(sqlite3_file *pFile, sqlite_int64 size){581  jt_file *p = (jt_file *)pFile;582  if( p->flags&SQLITE_OPEN_MAIN_JOURNAL && size==0 ){583    /* Truncating a journal file. This is the end of a transaction. */584    jt_file *pMain = locateDatabaseHandle(p->zName, 0);585    closeTransaction(pMain);586  }587  if( p->flags&SQLITE_OPEN_MAIN_DB && p->pWritable ){588    u32 pgno;589    u32 locking_page = (u32)(PENDING_BYTE/p->nPagesize+1);590    for(pgno=(u32)(size/p->nPagesize+1); pgno<=p->nPage; pgno++){591      assert( pgno==locking_page || sqlite3BitvecTest(p->pWritable, pgno) );592    }593  }594  return sqlite3OsTruncate(p->pReal, size);595}596 597/*598** Sync an jt-file.599*/600static int jtSync(sqlite3_file *pFile, int flags){601  jt_file *p = (jt_file *)pFile;602 603  if( p->flags&SQLITE_OPEN_MAIN_JOURNAL ){604    int rc;605    jt_file *pMain;                   /* The associated database file */606 607    /* The journal file is being synced. At this point, we inspect the 608    ** contents of the file up to this point and set each bit in the 609    ** jt_file.pWritable bitvec of the main database file associated with610    ** this journal file.611    */612    pMain = locateDatabaseHandle(p->zName, 0);613 614    /* Set the bitvec values */615    if( pMain && pMain->pWritable ){616      pMain->nSync++;617      rc = readJournalFile(p, pMain);618      if( rc!=SQLITE_OK ){619        return rc;620      }621    }622  }623 624  return sqlite3OsSync(p->pReal, flags);625}626 627/*628** Return the current file-size of an jt-file.629*/630static int jtFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){631  jt_file *p = (jt_file *)pFile;632  return sqlite3OsFileSize(p->pReal, pSize);633}634 635/*636** Lock an jt-file.637*/638static int jtLock(sqlite3_file *pFile, int eLock){639  int rc;640  jt_file *p = (jt_file *)pFile;641  rc = sqlite3OsLock(p->pReal, eLock);642  if( rc==SQLITE_OK && eLock>p->eLock ){643    p->eLock = eLock;644  }645  return rc;646}647 648/*649** Unlock an jt-file.650*/651static int jtUnlock(sqlite3_file *pFile, int eLock){652  int rc;653  jt_file *p = (jt_file *)pFile;654  rc = sqlite3OsUnlock(p->pReal, eLock);655  if( rc==SQLITE_OK && eLock<p->eLock ){656    p->eLock = eLock;657  }658  return rc;659}660 661/*662** Check if another file-handle holds a RESERVED lock on an jt-file.663*/664static int jtCheckReservedLock(sqlite3_file *pFile, int *pResOut){665  jt_file *p = (jt_file *)pFile;666  return sqlite3OsCheckReservedLock(p->pReal, pResOut);667}668 669/*670** File control method. For custom operations on an jt-file.671*/672static int jtFileControl(sqlite3_file *pFile, int op, void *pArg){673  jt_file *p = (jt_file *)pFile;674  return p->pReal->pMethods->xFileControl(p->pReal, op, pArg);675}676 677/*678** Return the sector-size in bytes for an jt-file.679*/680static int jtSectorSize(sqlite3_file *pFile){681  jt_file *p = (jt_file *)pFile;682  return sqlite3OsSectorSize(p->pReal);683}684 685/*686** Return the device characteristic flags supported by an jt-file.687*/688static int jtDeviceCharacteristics(sqlite3_file *pFile){689  jt_file *p = (jt_file *)pFile;690  return sqlite3OsDeviceCharacteristics(p->pReal);691}692 693/*694** Open an jt file handle.695*/696static int jtOpen(697  sqlite3_vfs *pVfs,698  const char *zName,699  sqlite3_file *pFile,700  int flags,701  int *pOutFlags702){703  int rc;704  jt_file *p = (jt_file *)pFile;705  pFile->pMethods = 0;706  p->pReal = (sqlite3_file *)&p[1];707  p->pReal->pMethods = 0;708  rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);709  assert( rc==SQLITE_OK || p->pReal->pMethods==0 );710  if( rc==SQLITE_OK ){711    pFile->pMethods = &jt_io_methods;712    p->eLock = 0;713    p->zName = zName;714    p->flags = flags;715    p->pNext = 0;716    p->pWritable = 0;717    p->aCksum = 0;718    enterJtMutex();719    if( zName ){720      p->pNext = g.pList;721      g.pList = p;722    }723    leaveJtMutex();724  }725  return rc;726}727 728/*729** Delete the file located at zPath. If the dirSync argument is true,730** ensure the file-system modifications are synced to disk before731** returning.732*/733static int jtDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){734  int nPath = (int)strlen(zPath);735  if( nPath>8 && 0==strcmp("-journal", &zPath[nPath-8]) ){736    /* Deleting a journal file. The end of a transaction. */737    jt_file *pMain = locateDatabaseHandle(zPath, 0);738    if( pMain ){739      closeTransaction(pMain);740    }741  }742 743  return sqlite3OsDelete(g.pVfs, zPath, dirSync);744}745 746/*747** Test for access permissions. Return true if the requested permission748** is available, or false otherwise.749*/750static int jtAccess(751  sqlite3_vfs *pVfs, 752  const char *zPath, 753  int flags, 754  int *pResOut755){756  return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut);757}758 759/*760** Populate buffer zOut with the full canonical pathname corresponding761** to the pathname in zPath. zOut is guaranteed to point to a buffer762** of at least (JT_MAX_PATHNAME+1) bytes.763*/764static int jtFullPathname(765  sqlite3_vfs *pVfs, 766  const char *zPath, 767  int nOut, 768  char *zOut769){770  return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut);771}772 773/*774** Open the dynamic library located at zPath and return a handle.775*/776static void *jtDlOpen(sqlite3_vfs *pVfs, const char *zPath){777  return g.pVfs->xDlOpen(g.pVfs, zPath);778}779 780/*781** Populate the buffer zErrMsg (size nByte bytes) with a human readable782** utf-8 string describing the most recent error encountered associated 783** with dynamic libraries.784*/785static void jtDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){786  g.pVfs->xDlError(g.pVfs, nByte, zErrMsg);787}788 789/*790** Return a pointer to the symbol zSymbol in the dynamic library pHandle.791*/792static void (*jtDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){793  return g.pVfs->xDlSym(g.pVfs, p, zSym);794}795 796/*797** Close the dynamic library handle pHandle.798*/799static void jtDlClose(sqlite3_vfs *pVfs, void *pHandle){800  g.pVfs->xDlClose(g.pVfs, pHandle);801}802 803/*804** Populate the buffer pointed to by zBufOut with nByte bytes of 805** random data.806*/807static int jtRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){808  return sqlite3OsRandomness(g.pVfs, nByte, zBufOut);809}810 811/*812** Sleep for nMicro microseconds. Return the number of microseconds 813** actually slept.814*/815static int jtSleep(sqlite3_vfs *pVfs, int nMicro){816  return sqlite3OsSleep(g.pVfs, nMicro);817}818 819/*820** Return the current time as a Julian Day number in *pTimeOut.821*/822static int jtCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){823  return g.pVfs->xCurrentTime(g.pVfs, pTimeOut);824}825/*826** Return the current time as a Julian Day number in *pTimeOut.827*/828static int jtCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){829  return g.pVfs->xCurrentTimeInt64(g.pVfs, pTimeOut);830}831 832static int jtGetLastError(sqlite3_vfs *pVfs, int n, char *z){833  return g.pVfs->xGetLastError(g.pVfs, n, z);834}835 836/**************************************************************************837** Start of public API.838*/839 840/*841** Configure the jt VFS as a wrapper around the VFS named by parameter 842** zWrap. If the isDefault parameter is true, then the jt VFS is installed843** as the new default VFS for SQLite connections. If isDefault is not844** true, then the jt VFS is installed as non-default. In this case it845** is available via its name, "jt".846*/847int jt_register(char *zWrap, int isDefault){848  g.pVfs = sqlite3_vfs_find(zWrap);849  if( g.pVfs==0 ){850    return SQLITE_ERROR;851  }852  jt_vfs.szOsFile = sizeof(jt_file) + g.pVfs->szOsFile;853  if( g.pVfs->iVersion==1 ){854    jt_vfs.iVersion = 1;855  }else if( g.pVfs->xCurrentTimeInt64==0 ){856    jt_vfs.xCurrentTimeInt64 = 0;857  }858  sqlite3_vfs_register(&jt_vfs, isDefault);859  return SQLITE_OK;860}861 862/*863** Uninstall the jt VFS, if it is installed.864*/865void jt_unregister(void){866  sqlite3_vfs_unregister(&jt_vfs);867}868 869#endif870