sl@0: /*
sl@0: ** 2008 April 10
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: ******************************************************************************
sl@0: **
sl@0: ** This file contains the implementation of an SQLite vfs wrapper that
sl@0: ** adds instrumentation to all vfs and file methods. C and Tcl interfaces
sl@0: ** are provided to control the instrumentation.
sl@0: **
sl@0: ** $Id: test_osinst.c,v 1.18 2008/07/25 13:32:45 drh Exp $
sl@0: */
sl@0: 
sl@0: #ifdef SQLITE_ENABLE_INSTVFS
sl@0: /*
sl@0: ** C interface:
sl@0: **
sl@0: **   sqlite3_instvfs_create()
sl@0: **   sqlite3_instvfs_destroy()
sl@0: **   sqlite3_instvfs_configure()
sl@0: **
sl@0: **   sqlite3_instvfs_reset()
sl@0: **   sqlite3_instvfs_get()
sl@0: **
sl@0: **   sqlite3_instvfs_binarylog
sl@0: **   sqlite3_instvfs_binarylog_marker
sl@0: **
sl@0: ** Tcl interface (omitted if SQLITE_TEST is not set):
sl@0: ** 
sl@0: **   sqlite3_instvfs create NAME ?PARENT?
sl@0: **
sl@0: **       Create and register new vfs called $NAME, which is a wrapper around
sl@0: **       the existing vfs $PARENT. If the PARENT argument is omitted, the
sl@0: **       new vfs is a wrapper around the current default vfs.
sl@0: **
sl@0: **   sqlite3_instvfs destroy NAME
sl@0: **
sl@0: **       Deregister and destroy the vfs named $NAME, which must have been
sl@0: **       created by an earlier invocation of [sqlite3_instvfs create].
sl@0: **
sl@0: **   sqlite3_instvfs configure NAME SCRIPT
sl@0: **
sl@0: **       Configure the callback script for the vfs $NAME, which much have
sl@0: **       been created by an earlier invocation of [sqlite3_instvfs create].
sl@0: **       After a callback script has been configured, it is invoked each
sl@0: **       time a vfs or file method is called by SQLite. Before invoking
sl@0: **       the callback script, five arguments are appended to it:
sl@0: **
sl@0: **         * The name of the invoked method - i.e. "xRead".
sl@0: **
sl@0: **         * The time consumed by the method call as measured by 
sl@0: **           sqlite3Hwtime() (an integer value)
sl@0: **
sl@0: **         * A string value with a different meaning for different calls. 
sl@0: **           For file methods, the name of the file being operated on. For
sl@0: **           other methods it is the filename argument, if any.
sl@0: **
sl@0: **         * A 32-bit integer value with a call-specific meaning.
sl@0: **
sl@0: **         * A 64-bit integer value. For xRead() and xWrite() calls this
sl@0: **           is the file offset being written to or read from. Unused by
sl@0: **           all other calls.
sl@0: **
sl@0: **   sqlite3_instvfs reset NAME
sl@0: **
sl@0: **       Zero the internal event counters associated with vfs $NAME, 
sl@0: **       which must have been created by an earlier invocation of 
sl@0: **       [sqlite3_instvfs create].
sl@0: **
sl@0: **   sqlite3_instvfs report NAME
sl@0: **
sl@0: **       Return the values of the internal event counters associated 
sl@0: **       with vfs $NAME. The report format is a list with one element
sl@0: **       for each method call (xWrite, xRead etc.). Each element is
sl@0: **       itself a list with three elements:
sl@0: **
sl@0: **         * The name of the method call - i.e. "xWrite",
sl@0: **         * The total number of calls to the method (an integer).
sl@0: **         * The aggregate time consumed by all calls to the method as
sl@0: **           measured by sqlite3Hwtime() (an integer).
sl@0: */
sl@0: 
sl@0: #include "sqlite3.h"
sl@0: #include <string.h>
sl@0: #include <assert.h>
sl@0: 
sl@0: /*
sl@0: ** Maximum pathname length supported by the inst backend.
sl@0: */
sl@0: #define INST_MAX_PATHNAME 512
sl@0: 
sl@0: 
sl@0: /* File methods */
sl@0: /* Vfs methods */
sl@0: #define OS_ACCESS            1
sl@0: #define OS_CHECKRESERVEDLOCK 2
sl@0: #define OS_CLOSE             3
sl@0: #define OS_CURRENTTIME       4
sl@0: #define OS_DELETE            5
sl@0: #define OS_DEVCHAR           6
sl@0: #define OS_FILECONTROL       7
sl@0: #define OS_FILESIZE          8
sl@0: #define OS_FULLPATHNAME      9
sl@0: #define OS_LOCK              11
sl@0: #define OS_OPEN              12
sl@0: #define OS_RANDOMNESS        13
sl@0: #define OS_READ              14 
sl@0: #define OS_SECTORSIZE        15
sl@0: #define OS_SLEEP             16
sl@0: #define OS_SYNC              17
sl@0: #define OS_TRUNCATE          18
sl@0: #define OS_UNLOCK            19
sl@0: #define OS_WRITE             20
sl@0: 
sl@0: #define OS_NUMEVENTS         21
sl@0: 
sl@0: #define BINARYLOG_STRING     30
sl@0: #define BINARYLOG_MARKER     31
sl@0: 
sl@0: #define BINARYLOG_PREPARE_V2 64
sl@0: #define BINARYLOG_STEP       65
sl@0: #define BINARYLOG_FINALIZE   66
sl@0: 
sl@0: struct InstVfs {
sl@0:   sqlite3_vfs base;
sl@0:   sqlite3_vfs *pVfs;
sl@0: 
sl@0:   void *pClient;
sl@0:   void (*xDel)(void *);
sl@0:   void (*xCall)(void *, int, int, sqlite3_int64, int, const char *, int, int, sqlite3_int64);
sl@0: 
sl@0:   /* Counters */
sl@0:   sqlite3_int64 aTime[OS_NUMEVENTS];
sl@0:   int aCount[OS_NUMEVENTS];
sl@0: 
sl@0:   int iNextFileId;
sl@0: };
sl@0: typedef struct InstVfs InstVfs;
sl@0: 
sl@0: #define REALVFS(p) (((InstVfs *)(p))->pVfs)
sl@0: 
sl@0: typedef struct inst_file inst_file;
sl@0: struct inst_file {
sl@0:   sqlite3_file base;
sl@0:   sqlite3_file *pReal;
sl@0:   InstVfs *pInstVfs;
sl@0:   const char *zName;
sl@0:   int iFileId;               /* File id number */
sl@0:   int flags;
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** Method declarations for inst_file.
sl@0: */
sl@0: static int instClose(sqlite3_file*);
sl@0: static int instRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
sl@0: static int instWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
sl@0: static int instTruncate(sqlite3_file*, sqlite3_int64 size);
sl@0: static int instSync(sqlite3_file*, int flags);
sl@0: static int instFileSize(sqlite3_file*, sqlite3_int64 *pSize);
sl@0: static int instLock(sqlite3_file*, int);
sl@0: static int instUnlock(sqlite3_file*, int);
sl@0: static int instCheckReservedLock(sqlite3_file*, int *pResOut);
sl@0: static int instFileControl(sqlite3_file*, int op, void *pArg);
sl@0: static int instSectorSize(sqlite3_file*);
sl@0: static int instDeviceCharacteristics(sqlite3_file*);
sl@0: 
sl@0: /*
sl@0: ** Method declarations for inst_vfs.
sl@0: */
sl@0: static int instOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
sl@0: static int instDelete(sqlite3_vfs*, const char *zName, int syncDir);
sl@0: static int instAccess(sqlite3_vfs*, const char *zName, int flags, int *);
sl@0: static int instFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
sl@0: static void *instDlOpen(sqlite3_vfs*, const char *zFilename);
sl@0: static void instDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
sl@0: static void *instDlSym(sqlite3_vfs*,void*, const char *zSymbol);
sl@0: static void instDlClose(sqlite3_vfs*, void*);
sl@0: static int instRandomness(sqlite3_vfs*, int nByte, char *zOut);
sl@0: static int instSleep(sqlite3_vfs*, int microseconds);
sl@0: static int instCurrentTime(sqlite3_vfs*, double*);
sl@0: 
sl@0: static void binarylog_blob(sqlite3_vfs *, const char *, int, int); 
sl@0: 
sl@0: static sqlite3_vfs inst_vfs = {
sl@0:   1,                      /* iVersion */
sl@0:   sizeof(inst_file),      /* szOsFile */
sl@0:   INST_MAX_PATHNAME,      /* mxPathname */
sl@0:   0,                      /* pNext */
sl@0:   0,                      /* zName */
sl@0:   0,                      /* pAppData */
sl@0:   instOpen,               /* xOpen */
sl@0:   instDelete,             /* xDelete */
sl@0:   instAccess,             /* xAccess */
sl@0:   instFullPathname,       /* xFullPathname */
sl@0:   instDlOpen,             /* xDlOpen */
sl@0:   instDlError,            /* xDlError */
sl@0:   instDlSym,              /* xDlSym */
sl@0:   instDlClose,            /* xDlClose */
sl@0:   instRandomness,         /* xRandomness */
sl@0:   instSleep,              /* xSleep */
sl@0:   instCurrentTime         /* xCurrentTime */
sl@0: };
sl@0: 
sl@0: static sqlite3_io_methods inst_io_methods = {
sl@0:   1,                            /* iVersion */
sl@0:   instClose,                      /* xClose */
sl@0:   instRead,                       /* xRead */
sl@0:   instWrite,                      /* xWrite */
sl@0:   instTruncate,                   /* xTruncate */
sl@0:   instSync,                       /* xSync */
sl@0:   instFileSize,                   /* xFileSize */
sl@0:   instLock,                       /* xLock */
sl@0:   instUnlock,                     /* xUnlock */
sl@0:   instCheckReservedLock,          /* xCheckReservedLock */
sl@0:   instFileControl,                /* xFileControl */
sl@0:   instSectorSize,                 /* xSectorSize */
sl@0:   instDeviceCharacteristics       /* xDeviceCharacteristics */
sl@0: };
sl@0: 
sl@0: /* 
sl@0: ** hwtime.h contains inline assembler code for implementing 
sl@0: ** high-performance timing routines.
sl@0: */
sl@0: #include "hwtime.h"
sl@0: 
sl@0: #define OS_TIME_IO(eEvent, A, B, Call) {     \
sl@0:   inst_file *p = (inst_file *)pFile;         \
sl@0:   InstVfs *pInstVfs = p->pInstVfs;           \
sl@0:   int rc;                                    \
sl@0:   sqlite_uint64 t = sqlite3Hwtime();         \
sl@0:   rc = Call;                                 \
sl@0:   t = sqlite3Hwtime() - t;                   \
sl@0:   pInstVfs->aTime[eEvent] += t;              \
sl@0:   pInstVfs->aCount[eEvent] += 1;             \
sl@0:   if( pInstVfs->xCall ){                     \
sl@0:     pInstVfs->xCall(                         \
sl@0:       pInstVfs->pClient,eEvent,p->iFileId,t,rc,p->zName,p->flags,A,B  \
sl@0:     );                                       \
sl@0:   }                                          \
sl@0:   return rc;                                 \
sl@0: }
sl@0: 
sl@0: #define OS_TIME_VFS(eEvent, Z, flags, A, B, Call) {      \
sl@0:   InstVfs *pInstVfs = (InstVfs *)pVfs;   \
sl@0:   int rc;                                \
sl@0:   sqlite_uint64 t = sqlite3Hwtime();     \
sl@0:   rc = Call;                             \
sl@0:   t = sqlite3Hwtime() - t;               \
sl@0:   pInstVfs->aTime[eEvent] += t;          \
sl@0:   pInstVfs->aCount[eEvent] += 1;         \
sl@0:   if( pInstVfs->xCall ){                 \
sl@0:     pInstVfs->xCall(pInstVfs->pClient,eEvent,0, t, rc, Z, flags, A, B); \
sl@0:   }                                      \
sl@0:   return rc;                             \
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Close an inst-file.
sl@0: */
sl@0: static int instClose(sqlite3_file *pFile){
sl@0:   OS_TIME_IO(OS_CLOSE, 0, 0, 
sl@0:     (p->pReal->pMethods ? p->pReal->pMethods->xClose(p->pReal) : SQLITE_OK)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Read data from an inst-file.
sl@0: */
sl@0: static int instRead(
sl@0:   sqlite3_file *pFile, 
sl@0:   void *zBuf, 
sl@0:   int iAmt, 
sl@0:   sqlite_int64 iOfst
sl@0: ){
sl@0:   sqlite3_vfs *pVfs = (sqlite3_vfs *)(((inst_file *)pFile)->pInstVfs);
sl@0:   OS_TIME_IO(OS_READ, iAmt, (binarylog_blob(pVfs, zBuf, iAmt, 1), iOfst), 
sl@0:       p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Write data to an inst-file.
sl@0: */
sl@0: static int instWrite(
sl@0:   sqlite3_file *pFile,
sl@0:   const void *z,
sl@0:   int iAmt,
sl@0:   sqlite_int64 iOfst
sl@0: ){
sl@0:   sqlite3_vfs *pVfs = (sqlite3_vfs *)(((inst_file *)pFile)->pInstVfs);
sl@0:   binarylog_blob(pVfs, z, iAmt, 1);
sl@0:   OS_TIME_IO(OS_WRITE, iAmt, iOfst, 
sl@0:       p->pReal->pMethods->xWrite(p->pReal, z, iAmt, iOfst)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Truncate an inst-file.
sl@0: */
sl@0: static int instTruncate(sqlite3_file *pFile, sqlite_int64 size){
sl@0:   OS_TIME_IO(OS_TRUNCATE, 0, (int)size, 
sl@0:     p->pReal->pMethods->xTruncate(p->pReal, size)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Sync an inst-file.
sl@0: */
sl@0: static int instSync(sqlite3_file *pFile, int flags){
sl@0:   OS_TIME_IO(OS_SYNC, flags, 0, p->pReal->pMethods->xSync(p->pReal, flags));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the current file-size of an inst-file.
sl@0: */
sl@0: static int instFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
sl@0:   OS_TIME_IO(OS_FILESIZE, (int)(*pSize), 0, 
sl@0:     p->pReal->pMethods->xFileSize(p->pReal, pSize)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Lock an inst-file.
sl@0: */
sl@0: static int instLock(sqlite3_file *pFile, int eLock){
sl@0:   OS_TIME_IO(OS_LOCK, eLock, 0, p->pReal->pMethods->xLock(p->pReal, eLock));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Unlock an inst-file.
sl@0: */
sl@0: static int instUnlock(sqlite3_file *pFile, int eLock){
sl@0:   OS_TIME_IO(OS_UNLOCK, eLock, 0, p->pReal->pMethods->xUnlock(p->pReal, eLock));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Check if another file-handle holds a RESERVED lock on an inst-file.
sl@0: */
sl@0: static int instCheckReservedLock(sqlite3_file *pFile, int *pResOut){
sl@0:   OS_TIME_IO(OS_CHECKRESERVEDLOCK, 0, 0, 
sl@0:       p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** File control method. For custom operations on an inst-file.
sl@0: */
sl@0: static int instFileControl(sqlite3_file *pFile, int op, void *pArg){
sl@0:   OS_TIME_IO(OS_FILECONTROL, 0, 0, p->pReal->pMethods->xFileControl(p->pReal, op, pArg));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the sector-size in bytes for an inst-file.
sl@0: */
sl@0: static int instSectorSize(sqlite3_file *pFile){
sl@0:   OS_TIME_IO(OS_SECTORSIZE, 0, 0, p->pReal->pMethods->xSectorSize(p->pReal));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the device characteristic flags supported by an inst-file.
sl@0: */
sl@0: static int instDeviceCharacteristics(sqlite3_file *pFile){
sl@0:   OS_TIME_IO(OS_DEVCHAR, 0, 0, p->pReal->pMethods->xDeviceCharacteristics(p->pReal));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Open an inst file handle.
sl@0: */
sl@0: static int instOpen(
sl@0:   sqlite3_vfs *pVfs,
sl@0:   const char *zName,
sl@0:   sqlite3_file *pFile,
sl@0:   int flags,
sl@0:   int *pOutFlags
sl@0: ){
sl@0:   inst_file *p = (inst_file *)pFile;
sl@0:   pFile->pMethods = &inst_io_methods;
sl@0:   p->pReal = (sqlite3_file *)&p[1];
sl@0:   p->pInstVfs = (InstVfs *)pVfs;
sl@0:   p->zName = zName;
sl@0:   p->flags = flags;
sl@0:   p->iFileId = ++p->pInstVfs->iNextFileId;
sl@0: 
sl@0:   binarylog_blob(pVfs, zName, -1, 0);
sl@0:   OS_TIME_VFS(OS_OPEN, zName, flags, p->iFileId, 0,
sl@0:     REALVFS(pVfs)->xOpen(REALVFS(pVfs), zName, p->pReal, flags, pOutFlags)
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Delete the file located at zPath. If the dirSync argument is true,
sl@0: ** ensure the file-system modifications are synced to disk before
sl@0: ** returning.
sl@0: */
sl@0: static int instDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
sl@0:   binarylog_blob(pVfs, zPath, -1, 0);
sl@0:   OS_TIME_VFS(OS_DELETE, zPath, 0, dirSync, 0,
sl@0:     REALVFS(pVfs)->xDelete(REALVFS(pVfs), zPath, dirSync) 
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Test for access permissions. Return true if the requested permission
sl@0: ** is available, or false otherwise.
sl@0: */
sl@0: static int instAccess(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   const char *zPath, 
sl@0:   int flags, 
sl@0:   int *pResOut
sl@0: ){
sl@0:   binarylog_blob(pVfs, zPath, -1, 0);
sl@0:   OS_TIME_VFS(OS_ACCESS, zPath, 0, flags, *pResOut, 
sl@0:     REALVFS(pVfs)->xAccess(REALVFS(pVfs), zPath, flags, pResOut) 
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Populate buffer zOut with the full canonical pathname corresponding
sl@0: ** to the pathname in zPath. zOut is guaranteed to point to a buffer
sl@0: ** of at least (INST_MAX_PATHNAME+1) bytes.
sl@0: */
sl@0: static int instFullPathname(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   const char *zPath, 
sl@0:   int nOut, 
sl@0:   char *zOut
sl@0: ){
sl@0:   OS_TIME_VFS( OS_FULLPATHNAME, zPath, 0, 0, 0,
sl@0:     REALVFS(pVfs)->xFullPathname(REALVFS(pVfs), zPath, nOut, zOut);
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Open the dynamic library located at zPath and return a handle.
sl@0: */
sl@0: static void *instDlOpen(sqlite3_vfs *pVfs, const char *zPath){
sl@0:   return REALVFS(pVfs)->xDlOpen(REALVFS(pVfs), zPath);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
sl@0: ** utf-8 string describing the most recent error encountered associated 
sl@0: ** with dynamic libraries.
sl@0: */
sl@0: static void instDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
sl@0:   REALVFS(pVfs)->xDlError(REALVFS(pVfs), nByte, zErrMsg);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
sl@0: */
sl@0: static void *instDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
sl@0:   return REALVFS(pVfs)->xDlSym(REALVFS(pVfs), pHandle, zSymbol);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Close the dynamic library handle pHandle.
sl@0: */
sl@0: static void instDlClose(sqlite3_vfs *pVfs, void *pHandle){
sl@0:   REALVFS(pVfs)->xDlClose(REALVFS(pVfs), pHandle);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Populate the buffer pointed to by zBufOut with nByte bytes of 
sl@0: ** random data.
sl@0: */
sl@0: static int instRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
sl@0:   OS_TIME_VFS( OS_RANDOMNESS, 0, 0, nByte, 0,
sl@0:     REALVFS(pVfs)->xRandomness(REALVFS(pVfs), nByte, zBufOut);
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Sleep for nMicro microseconds. Return the number of microseconds 
sl@0: ** actually slept.
sl@0: */
sl@0: static int instSleep(sqlite3_vfs *pVfs, int nMicro){
sl@0:   OS_TIME_VFS( OS_SLEEP, 0, 0, nMicro, 0, 
sl@0:     REALVFS(pVfs)->xSleep(REALVFS(pVfs), nMicro) 
sl@0:   );
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the current time as a Julian Day number in *pTimeOut.
sl@0: */
sl@0: static int instCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
sl@0:   OS_TIME_VFS( OS_CURRENTTIME, 0, 0, 0, 0,
sl@0:     REALVFS(pVfs)->xCurrentTime(REALVFS(pVfs), pTimeOut) 
sl@0:   );
sl@0: }
sl@0: 
sl@0: sqlite3_vfs *sqlite3_instvfs_create(const char *zName, const char *zParent){
sl@0:   int nByte;
sl@0:   InstVfs *p;
sl@0:   sqlite3_vfs *pParent;
sl@0: 
sl@0:   pParent = sqlite3_vfs_find(zParent);
sl@0:   if( !pParent ){
sl@0:     return 0;
sl@0:   }
sl@0: 
sl@0:   nByte = strlen(zName) + 1 + sizeof(InstVfs);
sl@0:   p = (InstVfs *)sqlite3_malloc(nByte);
sl@0:   if( p ){
sl@0:     char *zCopy = (char *)&p[1];
sl@0:     memset(p, 0, nByte);
sl@0:     memcpy(p, &inst_vfs, sizeof(sqlite3_vfs));
sl@0:     p->pVfs = pParent;
sl@0:     memcpy(zCopy, zName, strlen(zName));
sl@0:     p->base.zName = (const char *)zCopy;
sl@0:     p->base.szOsFile += pParent->szOsFile;
sl@0:     sqlite3_vfs_register((sqlite3_vfs *)p, 0);
sl@0:   }
sl@0: 
sl@0:   return (sqlite3_vfs *)p;
sl@0: }
sl@0: 
sl@0: void sqlite3_instvfs_configure(
sl@0:   sqlite3_vfs *pVfs,
sl@0:   void (*xCall)(
sl@0:       void*, 
sl@0:       int,                           /* File id */
sl@0:       int,                           /* Event code */
sl@0:       sqlite3_int64, 
sl@0:       int,                           /* Return code */
sl@0:       const char*,                   /* File name */
sl@0:       int, 
sl@0:       int, 
sl@0:       sqlite3_int64
sl@0:   ),
sl@0:   void *pClient,
sl@0:   void (*xDel)(void *)
sl@0: ){
sl@0:   InstVfs *p = (InstVfs *)pVfs;
sl@0:   assert( pVfs->xOpen==instOpen );
sl@0:   if( p->xDel ){
sl@0:     p->xDel(p->pClient);
sl@0:   }
sl@0:   p->xCall = xCall;
sl@0:   p->xDel = xDel;
sl@0:   p->pClient = pClient;
sl@0: }
sl@0: 
sl@0: void sqlite3_instvfs_destroy(sqlite3_vfs *pVfs){
sl@0:   if( pVfs ){
sl@0:     sqlite3_vfs_unregister(pVfs);
sl@0:     sqlite3_instvfs_configure(pVfs, 0, 0, 0);
sl@0:     sqlite3_free(pVfs);
sl@0:   }
sl@0: }
sl@0: 
sl@0: void sqlite3_instvfs_reset(sqlite3_vfs *pVfs){
sl@0:   InstVfs *p = (InstVfs *)pVfs;
sl@0:   assert( pVfs->xOpen==instOpen );
sl@0:   memset(p->aTime, 0, sizeof(sqlite3_int64)*OS_NUMEVENTS);
sl@0:   memset(p->aCount, 0, sizeof(int)*OS_NUMEVENTS);
sl@0: }
sl@0: 
sl@0: const char *sqlite3_instvfs_name(int eEvent){
sl@0:   const char *zEvent = 0;
sl@0: 
sl@0:   switch( eEvent ){
sl@0:     case OS_CLOSE:             zEvent = "xClose"; break;
sl@0:     case OS_READ:              zEvent = "xRead"; break;
sl@0:     case OS_WRITE:             zEvent = "xWrite"; break;
sl@0:     case OS_TRUNCATE:          zEvent = "xTruncate"; break;
sl@0:     case OS_SYNC:              zEvent = "xSync"; break;
sl@0:     case OS_FILESIZE:          zEvent = "xFilesize"; break;
sl@0:     case OS_LOCK:              zEvent = "xLock"; break;
sl@0:     case OS_UNLOCK:            zEvent = "xUnlock"; break;
sl@0:     case OS_CHECKRESERVEDLOCK: zEvent = "xCheckReservedLock"; break;
sl@0:     case OS_FILECONTROL:       zEvent = "xFileControl"; break;
sl@0:     case OS_SECTORSIZE:        zEvent = "xSectorSize"; break;
sl@0:     case OS_DEVCHAR:           zEvent = "xDeviceCharacteristics"; break;
sl@0:     case OS_OPEN:              zEvent = "xOpen"; break;
sl@0:     case OS_DELETE:            zEvent = "xDelete"; break;
sl@0:     case OS_ACCESS:            zEvent = "xAccess"; break;
sl@0:     case OS_FULLPATHNAME:      zEvent = "xFullPathname"; break;
sl@0:     case OS_RANDOMNESS:        zEvent = "xRandomness"; break;
sl@0:     case OS_SLEEP:             zEvent = "xSleep"; break;
sl@0:     case OS_CURRENTTIME:       zEvent = "xCurrentTime"; break;
sl@0:   }
sl@0: 
sl@0:   return zEvent;
sl@0: }
sl@0: 
sl@0: void sqlite3_instvfs_get(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   int eEvent, 
sl@0:   const char **pzEvent, 
sl@0:   sqlite3_int64 *pnClick, 
sl@0:   int *pnCall
sl@0: ){
sl@0:   InstVfs *p = (InstVfs *)pVfs;
sl@0:   assert( pVfs->xOpen==instOpen );
sl@0:   if( eEvent<1 || eEvent>=OS_NUMEVENTS ){
sl@0:     *pzEvent = 0;
sl@0:     *pnClick = 0;
sl@0:     *pnCall = 0;
sl@0:     return;
sl@0:   }
sl@0: 
sl@0:   *pzEvent = sqlite3_instvfs_name(eEvent);
sl@0:   *pnClick = p->aTime[eEvent];
sl@0:   *pnCall = p->aCount[eEvent];
sl@0: }
sl@0: 
sl@0: #define BINARYLOG_BUFFERSIZE 8192
sl@0: 
sl@0: struct InstVfsBinaryLog {
sl@0:   int nBuf;
sl@0:   char *zBuf;
sl@0:   sqlite3_int64 iOffset;
sl@0:   int log_data;
sl@0:   sqlite3_file *pOut;
sl@0:   char *zOut;                       /* Log file name */
sl@0: };
sl@0: typedef struct InstVfsBinaryLog InstVfsBinaryLog;
sl@0: 
sl@0: static void put32bits(unsigned char *p, unsigned int v){
sl@0:   p[0] = v>>24;
sl@0:   p[1] = v>>16;
sl@0:   p[2] = v>>8;
sl@0:   p[3] = v;
sl@0: }
sl@0: 
sl@0: static void binarylog_flush(InstVfsBinaryLog *pLog){
sl@0:   sqlite3_file *pFile = pLog->pOut;
sl@0: 
sl@0: #ifdef SQLITE_TEST
sl@0:   extern int sqlite3_io_error_pending;
sl@0:   extern int sqlite3_io_error_persist;
sl@0:   extern int sqlite3_diskfull_pending;
sl@0: 
sl@0:   int pending = sqlite3_io_error_pending;
sl@0:   int persist = sqlite3_io_error_persist;
sl@0:   int diskfull = sqlite3_diskfull_pending;
sl@0: 
sl@0:   sqlite3_io_error_pending = 0;
sl@0:   sqlite3_io_error_persist = 0;
sl@0:   sqlite3_diskfull_pending = 0;
sl@0: #endif
sl@0: 
sl@0:   pFile->pMethods->xWrite(pFile, pLog->zBuf, pLog->nBuf, pLog->iOffset);
sl@0:   pLog->iOffset += pLog->nBuf;
sl@0:   pLog->nBuf = 0;
sl@0: 
sl@0: #ifdef SQLITE_TEST
sl@0:   sqlite3_io_error_pending = pending;
sl@0:   sqlite3_io_error_persist = persist;
sl@0:   sqlite3_diskfull_pending = diskfull;
sl@0: #endif
sl@0: }
sl@0: 
sl@0: static void binarylog_xcall(
sl@0:   void *p,
sl@0:   int eEvent,
sl@0:   int iFileId,
sl@0:   sqlite3_int64 nClick,
sl@0:   int return_code,
sl@0:   const char *zName,
sl@0:   int flags,
sl@0:   int nByte,
sl@0:   sqlite3_int64 iOffset
sl@0: ){
sl@0:   InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)p;
sl@0:   unsigned char *zRec;
sl@0:   if( (28+pLog->nBuf)>BINARYLOG_BUFFERSIZE ){
sl@0:     binarylog_flush(pLog);
sl@0:   }
sl@0:   zRec = (unsigned char *)&pLog->zBuf[pLog->nBuf];
sl@0:   put32bits(&zRec[0], eEvent);
sl@0:   put32bits(&zRec[4], (int)iFileId);
sl@0:   put32bits(&zRec[8], (int)nClick);
sl@0:   put32bits(&zRec[12], return_code);
sl@0:   put32bits(&zRec[16], flags);
sl@0:   put32bits(&zRec[20], nByte);
sl@0:   put32bits(&zRec[24], (int)iOffset);
sl@0:   pLog->nBuf += 28;
sl@0: }
sl@0: 
sl@0: static void binarylog_xdel(void *p){
sl@0:   /* Close the log file and free the memory allocated for the 
sl@0:   ** InstVfsBinaryLog structure.
sl@0:   */
sl@0:   InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)p;
sl@0:   sqlite3_file *pFile = pLog->pOut;
sl@0:   if( pLog->nBuf ){
sl@0:     binarylog_flush(pLog);
sl@0:   }
sl@0:   pFile->pMethods->xClose(pFile);
sl@0:   sqlite3_free(pLog->pOut);
sl@0:   sqlite3_free(pLog->zBuf);
sl@0:   sqlite3_free(pLog);
sl@0: }
sl@0: 
sl@0: static void binarylog_blob(
sl@0:   sqlite3_vfs *pVfs,
sl@0:   const char *zBlob,
sl@0:   int nBlob,
sl@0:   int isBinary
sl@0: ){
sl@0:   InstVfsBinaryLog *pLog;
sl@0:   InstVfs *pInstVfs = (InstVfs *)pVfs;
sl@0: 
sl@0:   if( pVfs->xOpen!=instOpen || pInstVfs->xCall!=binarylog_xcall ){
sl@0:     return;
sl@0:   }
sl@0:   pLog = (InstVfsBinaryLog *)pInstVfs->pClient;
sl@0:   if( zBlob && (!isBinary || pLog->log_data) ){
sl@0:     unsigned char *zRec;
sl@0:     int nWrite;
sl@0: 
sl@0:     if( nBlob<0 ){
sl@0:       nBlob = strlen(zBlob);
sl@0:     }
sl@0:     nWrite = nBlob + 28;
sl@0:   
sl@0:     if( (nWrite+pLog->nBuf)>BINARYLOG_BUFFERSIZE ){
sl@0:       binarylog_flush(pLog);
sl@0:     }
sl@0:   
sl@0:     zRec = (unsigned char *)&pLog->zBuf[pLog->nBuf];
sl@0:     memset(zRec, 0, nWrite);
sl@0:     put32bits(&zRec[0], BINARYLOG_STRING);
sl@0:     put32bits(&zRec[4], (int)nBlob);
sl@0:     put32bits(&zRec[8], (int)isBinary);
sl@0:     memcpy(&zRec[28], zBlob, nBlob);
sl@0:     pLog->nBuf += nWrite;
sl@0:   }
sl@0: }
sl@0: 
sl@0: void sqlite3_instvfs_binarylog_call(
sl@0:   sqlite3_vfs *pVfs,
sl@0:   int eEvent,
sl@0:   sqlite3_int64 nClick,
sl@0:   int return_code,
sl@0:   const char *zString
sl@0: ){
sl@0:   InstVfs *pInstVfs = (InstVfs *)pVfs;
sl@0:   InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)pInstVfs->pClient;
sl@0: 
sl@0:   if( zString ){
sl@0:     binarylog_blob(pVfs, zString, -1, 0);
sl@0:   }
sl@0:   binarylog_xcall(pLog, eEvent, 0, nClick, return_code, 0, 0, 0, 0);
sl@0: }
sl@0: 
sl@0: void sqlite3_instvfs_binarylog_marker(
sl@0:   sqlite3_vfs *pVfs,
sl@0:   const char *zMarker
sl@0: ){
sl@0:   InstVfs *pInstVfs = (InstVfs *)pVfs;
sl@0:   InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)pInstVfs->pClient;
sl@0:   binarylog_blob(pVfs, zMarker, -1, 0);
sl@0:   binarylog_xcall(pLog, BINARYLOG_MARKER, 0, 0, 0, 0, 0, 0, 0);
sl@0: }
sl@0: 
sl@0: sqlite3_vfs *sqlite3_instvfs_binarylog(
sl@0:   const char *zVfs,
sl@0:   const char *zParentVfs, 
sl@0:   const char *zLog,
sl@0:   int log_data
sl@0: ){
sl@0:   InstVfsBinaryLog *p;
sl@0:   sqlite3_vfs *pVfs;
sl@0:   sqlite3_vfs *pParent;
sl@0:   int nByte;
sl@0:   int flags;
sl@0:   int rc;
sl@0: 
sl@0:   pParent = sqlite3_vfs_find(zParentVfs);
sl@0:   if( !pParent ){
sl@0:     return 0;
sl@0:   }
sl@0: 
sl@0:   nByte = sizeof(InstVfsBinaryLog) + pParent->mxPathname+1;
sl@0:   p = (InstVfsBinaryLog *)sqlite3_malloc(nByte);
sl@0:   memset(p, 0, nByte);
sl@0:   p->zBuf = sqlite3_malloc(BINARYLOG_BUFFERSIZE);
sl@0:   p->zOut = (char *)&p[1];
sl@0:   p->pOut = (sqlite3_file *)sqlite3_malloc(pParent->szOsFile);
sl@0:   p->log_data = log_data;
sl@0:   pParent->xFullPathname(pParent, zLog, pParent->mxPathname, p->zOut);
sl@0:   flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MASTER_JOURNAL;
sl@0:   pParent->xDelete(pParent, p->zOut, 0);
sl@0:   rc = pParent->xOpen(pParent, p->zOut, p->pOut, flags, &flags);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     memcpy(p->zBuf, "sqlite_ostrace1.....", 20);
sl@0:     p->iOffset = 0;
sl@0:     p->nBuf = 20;
sl@0:   }
sl@0:   if( rc ){
sl@0:     binarylog_xdel(p);
sl@0:     return 0;
sl@0:   }
sl@0: 
sl@0:   pVfs = sqlite3_instvfs_create(zVfs, zParentVfs);
sl@0:   if( pVfs ){
sl@0:     sqlite3_instvfs_configure(pVfs, binarylog_xcall, p, binarylog_xdel);
sl@0:   }
sl@0: 
sl@0:   return pVfs;
sl@0: }
sl@0: #endif /* SQLITE_ENABLE_INSTVFS */
sl@0: 
sl@0: /**************************************************************************
sl@0: ***************************************************************************
sl@0: ** Tcl interface starts here.
sl@0: */
sl@0: #if SQLITE_TEST
sl@0: 
sl@0: #include "tcl.h"
sl@0: 
sl@0: #ifdef SQLITE_ENABLE_INSTVFS
sl@0: struct InstVfsCall {
sl@0:   Tcl_Interp *interp;
sl@0:   Tcl_Obj *pScript;
sl@0: };
sl@0: typedef struct InstVfsCall InstVfsCall;
sl@0: 
sl@0: static void test_instvfs_xcall(
sl@0:   void *p,
sl@0:   int eEvent,
sl@0:   int iFileId,
sl@0:   sqlite3_int64 nClick,
sl@0:   int return_code,
sl@0:   const char *zName,
sl@0:   int flags,
sl@0:   int nByte,
sl@0:   sqlite3_int64 iOffset
sl@0: ){
sl@0:   int rc;
sl@0:   InstVfsCall *pCall = (InstVfsCall *)p;
sl@0:   Tcl_Obj *pObj = Tcl_DuplicateObj( pCall->pScript);
sl@0:   const char *zEvent = sqlite3_instvfs_name(eEvent);
sl@0: 
sl@0:   Tcl_IncrRefCount(pObj);
sl@0:   Tcl_ListObjAppendElement(0, pObj, Tcl_NewStringObj(zEvent, -1));
sl@0:   Tcl_ListObjAppendElement(0, pObj, Tcl_NewWideIntObj(nClick));
sl@0:   Tcl_ListObjAppendElement(0, pObj, Tcl_NewStringObj(zName, -1));
sl@0:   Tcl_ListObjAppendElement(0, pObj, Tcl_NewIntObj(nByte));
sl@0:   Tcl_ListObjAppendElement(0, pObj, Tcl_NewWideIntObj(iOffset));
sl@0: 
sl@0:   rc = Tcl_EvalObjEx(pCall->interp, pObj, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
sl@0:   if( rc ){
sl@0:     Tcl_BackgroundError(pCall->interp);
sl@0:   }
sl@0:   Tcl_DecrRefCount(pObj);
sl@0: }
sl@0: 
sl@0: static void test_instvfs_xdel(void *p){
sl@0:   InstVfsCall *pCall = (InstVfsCall *)p;
sl@0:   Tcl_DecrRefCount(pCall->pScript);
sl@0:   sqlite3_free(pCall);
sl@0: }
sl@0: 
sl@0: static int test_sqlite3_instvfs(
sl@0:   void * clientData,
sl@0:   Tcl_Interp *interp,
sl@0:   int objc,
sl@0:   Tcl_Obj *CONST objv[]
sl@0: ){
sl@0:   static const char *IV_strs[] = 
sl@0:                { "create",  "destroy",  "reset",  "report", "configure", "binarylog", "marker", 0 };
sl@0:   enum IV_enum { IV_CREATE, IV_DESTROY, IV_RESET, IV_REPORT, IV_CONFIGURE, IV_BINARYLOG, IV_MARKER };
sl@0:   int iSub;
sl@0: 
sl@0:   if( objc<2 ){
sl@0:     Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
sl@0:   }
sl@0:   if( Tcl_GetIndexFromObj(interp, objv[1], IV_strs, "sub-command", 0, &iSub) ){
sl@0:     return TCL_ERROR;
sl@0:   }
sl@0: 
sl@0:   switch( (enum IV_enum)iSub ){
sl@0:     case IV_CREATE: {
sl@0:       char *zParent = 0;
sl@0:       sqlite3_vfs *p;
sl@0:       int isDefault = 0;
sl@0:       if( objc>2 && 0==strcmp("-default", Tcl_GetString(objv[2])) ){
sl@0:         isDefault = 1;
sl@0:       }
sl@0:       if( (objc-isDefault)!=4 && (objc-isDefault)!=3 ){
sl@0:         Tcl_WrongNumArgs(interp, 2, objv, "?-default? NAME ?PARENT-VFS?");
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       if( objc==(4+isDefault) ){
sl@0:         zParent = Tcl_GetString(objv[3+isDefault]);
sl@0:       }
sl@0:       p = sqlite3_instvfs_create(Tcl_GetString(objv[2+isDefault]), zParent);
sl@0:       if( !p ){
sl@0:         Tcl_AppendResult(interp, "error creating vfs ", 0);
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       if( isDefault ){
sl@0:         sqlite3_vfs_register(p, 1);
sl@0:       }
sl@0:       Tcl_SetObjResult(interp, objv[2]);
sl@0:       break;
sl@0:     }
sl@0:     case IV_BINARYLOG: {
sl@0:       char *zName = 0;
sl@0:       char *zLog = 0;
sl@0:       char *zParent = 0;
sl@0:       sqlite3_vfs *p;
sl@0:       int isDefault = 0;
sl@0:       int isLogdata = 0;
sl@0:       int argbase = 2;
sl@0: 
sl@0:       for(argbase=2; argbase<(objc-2); argbase++){
sl@0:         if( 0==strcmp("-default", Tcl_GetString(objv[argbase])) ){
sl@0:           isDefault = 1;
sl@0:         }
sl@0:         else if( 0==strcmp("-parent", Tcl_GetString(objv[argbase])) ){
sl@0:           argbase++;
sl@0:           zParent = Tcl_GetString(objv[argbase]);
sl@0:         }
sl@0:         else if( 0==strcmp("-logdata", Tcl_GetString(objv[argbase])) ){
sl@0:           isLogdata = 1;
sl@0:         }else{
sl@0:           break;
sl@0:         }
sl@0:       }
sl@0: 
sl@0:       if( (objc-argbase)!=2 ){
sl@0:         Tcl_WrongNumArgs(
sl@0:             interp, 2, objv, "?-default? ?-parent VFS? ?-logdata? NAME LOGFILE"
sl@0:         );
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       zName = Tcl_GetString(objv[argbase]);
sl@0:       zLog = Tcl_GetString(objv[argbase+1]);
sl@0:       p = sqlite3_instvfs_binarylog(zName, zParent, zLog, isLogdata);
sl@0:       if( !p ){
sl@0:         Tcl_AppendResult(interp, "error creating vfs ", 0);
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       if( isDefault ){
sl@0:         sqlite3_vfs_register(p, 1);
sl@0:       }
sl@0:       Tcl_SetObjResult(interp, objv[2]);
sl@0:       break;
sl@0:     }
sl@0: 
sl@0:     case IV_MARKER: {
sl@0:       sqlite3_vfs *p;
sl@0:       if( objc!=4 ){
sl@0:         Tcl_WrongNumArgs(interp, 2, objv, "VFS MARKER");
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       p = sqlite3_vfs_find(Tcl_GetString(objv[2]));
sl@0:       if( !p || p->xOpen!=instOpen ){
sl@0:         Tcl_AppendResult(interp, "no such vfs: ", Tcl_GetString(objv[2]), 0);
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       sqlite3_instvfs_binarylog_marker(p, Tcl_GetString(objv[3]));
sl@0:       Tcl_ResetResult(interp);
sl@0:       break;
sl@0:     }
sl@0: 
sl@0:     case IV_CONFIGURE: {
sl@0:       InstVfsCall *pCall;
sl@0: 
sl@0:       sqlite3_vfs *p;
sl@0:       if( objc!=4 ){
sl@0:         Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       p = sqlite3_vfs_find(Tcl_GetString(objv[2]));
sl@0:       if( !p || p->xOpen!=instOpen ){
sl@0:         Tcl_AppendResult(interp, "no such vfs: ", Tcl_GetString(objv[2]), 0);
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0: 
sl@0:       if( strlen(Tcl_GetString(objv[3])) ){
sl@0:         pCall = (InstVfsCall *)sqlite3_malloc(sizeof(InstVfsCall));
sl@0:         pCall->interp = interp;
sl@0:         pCall->pScript = Tcl_DuplicateObj(objv[3]);
sl@0:         Tcl_IncrRefCount(pCall->pScript);
sl@0:         sqlite3_instvfs_configure(p, 
sl@0:             test_instvfs_xcall, (void *)pCall, test_instvfs_xdel
sl@0:         );
sl@0:       }else{
sl@0:         sqlite3_instvfs_configure(p, 0, 0, 0);
sl@0:       }
sl@0:       break;
sl@0:     }
sl@0: 
sl@0:     case IV_REPORT:
sl@0:     case IV_DESTROY:
sl@0:     case IV_RESET: {
sl@0:       sqlite3_vfs *p;
sl@0:       if( objc!=3 ){
sl@0:         Tcl_WrongNumArgs(interp, 2, objv, "NAME");
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0:       p = sqlite3_vfs_find(Tcl_GetString(objv[2]));
sl@0:       if( !p || p->xOpen!=instOpen ){
sl@0:         Tcl_AppendResult(interp, "no such vfs: ", Tcl_GetString(objv[2]), 0);
sl@0:         return TCL_ERROR;
sl@0:       }
sl@0: 
sl@0:       if( ((enum IV_enum)iSub)==IV_DESTROY ){
sl@0:         sqlite3_instvfs_destroy(p);
sl@0:       }
sl@0:       if( ((enum IV_enum)iSub)==IV_RESET ){
sl@0:         sqlite3_instvfs_reset(p);
sl@0:       }
sl@0:       if( ((enum IV_enum)iSub)==IV_REPORT ){
sl@0:         int ii;
sl@0:         Tcl_Obj *pRet = Tcl_NewObj();
sl@0: 
sl@0:         const char *zName = (char *)1;
sl@0:         sqlite3_int64 nClick;
sl@0:         int nCall;
sl@0:         for(ii=1; zName; ii++){
sl@0:           sqlite3_instvfs_get(p, ii, &zName, &nClick, &nCall);
sl@0:           if( zName ){
sl@0:             Tcl_Obj *pElem = Tcl_NewObj();
sl@0:             Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj(zName, -1));
sl@0:             Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(nCall));
sl@0:             Tcl_ListObjAppendElement(0, pElem, Tcl_NewWideIntObj(nClick));
sl@0:             Tcl_ListObjAppendElement(0, pRet, pElem);
sl@0:           }
sl@0:         }
sl@0: 
sl@0:         Tcl_SetObjResult(interp, pRet);
sl@0:       }
sl@0: 
sl@0:       break;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   return TCL_OK;
sl@0: }
sl@0: #endif /* SQLITE_ENABLE_INSTVFS */
sl@0: 
sl@0: /* Alternative implementation of sqlite3_instvfs when the real
sl@0: ** implementation is unavailable. 
sl@0: */
sl@0: #ifndef SQLITE_ENABLE_INSTVFS
sl@0: static int test_sqlite3_instvfs(
sl@0:   void * clientData,
sl@0:   Tcl_Interp *interp,
sl@0:   int objc,
sl@0:   Tcl_Obj *CONST objv[]
sl@0: ){
sl@0:   Tcl_AppendResult(interp, 
sl@0:      "not compiled with -DSQLITE_ENABLE_INSTVFS; sqlite3_instvfs is "
sl@0:      "unavailable", (char*)0);
sl@0:   return TCL_ERROR;
sl@0: }
sl@0: #endif /* !defined(SQLITE_ENABLE_INSTVFS) */
sl@0: 
sl@0: int SqlitetestOsinst_Init(Tcl_Interp *interp){
sl@0:   Tcl_CreateObjCommand(interp, "sqlite3_instvfs", test_sqlite3_instvfs, 0, 0);
sl@0:   return TCL_OK;
sl@0: }
sl@0: 
sl@0: #endif /* SQLITE_TEST */