/*

** 2008 April 10

**

** The author disclaims copyright to this source code.  In place of

** a legal notice, here is a blessing:

**

**    May you do good and not evil.

**    May you find forgiveness for yourself and forgive others.

**    May you share freely, never taking more than you give.

**

******************************************************************************

**

** This file contains the implementation of an SQLite vfs wrapper that

** adds instrumentation to all vfs and file methods. C and Tcl interfaces

** are provided to control the instrumentation.

**

** $Id: test_osinst.c,v 1.18 2008/07/25 13:32:45 drh Exp $

*/

#ifdef SQLITE_ENABLE_INSTVFS

/*

** C interface:

**

**   sqlite3_instvfs_create()

**   sqlite3_instvfs_destroy()

**   sqlite3_instvfs_configure()

**

**   sqlite3_instvfs_reset()

**   sqlite3_instvfs_get()

**

**   sqlite3_instvfs_binarylog

**   sqlite3_instvfs_binarylog_marker

**

** Tcl interface (omitted if SQLITE_TEST is not set):

** 

**   sqlite3_instvfs create NAME ?PARENT?

**

**       Create and register new vfs called $NAME, which is a wrapper around

**       the existing vfs $PARENT. If the PARENT argument is omitted, the

**       new vfs is a wrapper around the current default vfs.

**

**   sqlite3_instvfs destroy NAME

**

**       Deregister and destroy the vfs named $NAME, which must have been

**       created by an earlier invocation of [sqlite3_instvfs create].

**

**   sqlite3_instvfs configure NAME SCRIPT

**

**       Configure the callback script for the vfs $NAME, which much have

**       been created by an earlier invocation of [sqlite3_instvfs create].

**       After a callback script has been configured, it is invoked each

**       time a vfs or file method is called by SQLite. Before invoking

**       the callback script, five arguments are appended to it:

**

**         * The name of the invoked method - i.e. "xRead".

**

**         * The time consumed by the method call as measured by 

**           sqlite3Hwtime() (an integer value)

**

**         * A string value with a different meaning for different calls. 

**           For file methods, the name of the file being operated on. For

**           other methods it is the filename argument, if any.

**

**         * A 32-bit integer value with a call-specific meaning.

**

**         * A 64-bit integer value. For xRead() and xWrite() calls this

**           is the file offset being written to or read from. Unused by

**           all other calls.

**

**   sqlite3_instvfs reset NAME

**

**       Zero the internal event counters associated with vfs $NAME, 

**       which must have been created by an earlier invocation of 

**       [sqlite3_instvfs create].

**

**   sqlite3_instvfs report NAME

**

**       Return the values of the internal event counters associated 

**       with vfs $NAME. The report format is a list with one element

**       for each method call (xWrite, xRead etc.). Each element is

**       itself a list with three elements:

**

**         * The name of the method call - i.e. "xWrite",

**         * The total number of calls to the method (an integer).

**         * The aggregate time consumed by all calls to the method as

**           measured by sqlite3Hwtime() (an integer).

*/

#include "sqlite3.h"

#include <string.h>

#include <assert.h>

/*

** Maximum pathname length supported by the inst backend.

*/

#define INST_MAX_PATHNAME 512

/* File methods */

/* Vfs methods */

#define OS_ACCESS            1

#define OS_CHECKRESERVEDLOCK 2

#define OS_CLOSE             3

#define OS_CURRENTTIME       4

#define OS_DELETE            5

#define OS_DEVCHAR           6

#define OS_FILECONTROL       7

#define OS_FILESIZE          8

#define OS_FULLPATHNAME      9

#define OS_LOCK              11

#define OS_OPEN              12

#define OS_RANDOMNESS        13

#define OS_READ              14 

#define OS_SECTORSIZE        15

#define OS_SLEEP             16

#define OS_SYNC              17

#define OS_TRUNCATE          18

#define OS_UNLOCK            19

#define OS_WRITE             20

#define OS_NUMEVENTS         21

#define BINARYLOG_STRING     30

#define BINARYLOG_MARKER     31

#define BINARYLOG_PREPARE_V2 64

#define BINARYLOG_STEP       65

#define BINARYLOG_FINALIZE   66

struct InstVfs {

  sqlite3_vfs base;

  sqlite3_vfs *pVfs;

  void *pClient;

  void (*xDel)(void *);

  void (*xCall)(void *, int, int, sqlite3_int64, int, const char *, int, int, sqlite3_int64);

  /* Counters */

  sqlite3_int64 aTime[OS_NUMEVENTS];

  int aCount[OS_NUMEVENTS];

  int iNextFileId;

};

typedef struct InstVfs InstVfs;

#define REALVFS(p) (((InstVfs *)(p))->pVfs)

typedef struct inst_file inst_file;

struct inst_file {

  sqlite3_file base;

  sqlite3_file *pReal;

  InstVfs *pInstVfs;

  const char *zName;

  int iFileId;               /* File id number */

  int flags;

};

/*

** Method declarations for inst_file.

*/

static int instClose(sqlite3_file*);

static int instRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);

static int instWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);

static int instTruncate(sqlite3_file*, sqlite3_int64 size);

static int instSync(sqlite3_file*, int flags);

static int instFileSize(sqlite3_file*, sqlite3_int64 *pSize);

static int instLock(sqlite3_file*, int);

static int instUnlock(sqlite3_file*, int);

static int instCheckReservedLock(sqlite3_file*, int *pResOut);

static int instFileControl(sqlite3_file*, int op, void *pArg);

static int instSectorSize(sqlite3_file*);

static int instDeviceCharacteristics(sqlite3_file*);

/*

** Method declarations for inst_vfs.

*/

static int instOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);

static int instDelete(sqlite3_vfs*, const char *zName, int syncDir);

static int instAccess(sqlite3_vfs*, const char *zName, int flags, int *);

static int instFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);

static void *instDlOpen(sqlite3_vfs*, const char *zFilename);

static void instDlError(sqlite3_vfs*, int nByte, char *zErrMsg);

static void *instDlSym(sqlite3_vfs*,void*, const char *zSymbol);

static void instDlClose(sqlite3_vfs*, void*);

static int instRandomness(sqlite3_vfs*, int nByte, char *zOut);

static int instSleep(sqlite3_vfs*, int microseconds);

static int instCurrentTime(sqlite3_vfs*, double*);

static void binarylog_blob(sqlite3_vfs *, const char *, int, int); 

static sqlite3_vfs inst_vfs = {

  1,                      /* iVersion */

  sizeof(inst_file),      /* szOsFile */

  INST_MAX_PATHNAME,      /* mxPathname */

  0,                      /* pNext */

  0,                      /* zName */

  0,                      /* pAppData */

  instOpen,               /* xOpen */

  instDelete,             /* xDelete */

  instAccess,             /* xAccess */

  instFullPathname,       /* xFullPathname */

  instDlOpen,             /* xDlOpen */

  instDlError,            /* xDlError */

  instDlSym,              /* xDlSym */

  instDlClose,            /* xDlClose */

  instRandomness,         /* xRandomness */

  instSleep,              /* xSleep */

  instCurrentTime         /* xCurrentTime */

};

static sqlite3_io_methods inst_io_methods = {

  1,                            /* iVersion */

  instClose,                      /* xClose */

  instRead,                       /* xRead */

  instWrite,                      /* xWrite */

  instTruncate,                   /* xTruncate */

  instSync,                       /* xSync */

  instFileSize,                   /* xFileSize */

  instLock,                       /* xLock */

  instUnlock,                     /* xUnlock */

  instCheckReservedLock,          /* xCheckReservedLock */

  instFileControl,                /* xFileControl */

  instSectorSize,                 /* xSectorSize */

  instDeviceCharacteristics       /* xDeviceCharacteristics */

};

/* 

** hwtime.h contains inline assembler code for implementing 

** high-performance timing routines.

*/

#include "hwtime.h"

#define OS_TIME_IO(eEvent, A, B, Call) {     \

  inst_file *p = (inst_file *)pFile;         \

  InstVfs *pInstVfs = p->pInstVfs;           \

  int rc;                                    \

  sqlite_uint64 t = sqlite3Hwtime();         \

  rc = Call;                                 \

  t = sqlite3Hwtime() - t;                   \

  pInstVfs->aTime[eEvent] += t;              \

  pInstVfs->aCount[eEvent] += 1;             \

  if( pInstVfs->xCall ){                     \

    pInstVfs->xCall(                         \

      pInstVfs->pClient,eEvent,p->iFileId,t,rc,p->zName,p->flags,A,B  \

    );                                       \

  }                                          \

  return rc;                                 \

}

#define OS_TIME_VFS(eEvent, Z, flags, A, B, Call) {      \

  InstVfs *pInstVfs = (InstVfs *)pVfs;   \

  int rc;                                \

  sqlite_uint64 t = sqlite3Hwtime();     \

  rc = Call;                             \

  t = sqlite3Hwtime() - t;               \

  pInstVfs->aTime[eEvent] += t;          \

  pInstVfs->aCount[eEvent] += 1;         \

  if( pInstVfs->xCall ){                 \

    pInstVfs->xCall(pInstVfs->pClient,eEvent,0, t, rc, Z, flags, A, B); \

  }                                      \

  return rc;                             \

}

/*

** Close an inst-file.

*/

static int instClose(sqlite3_file *pFile){

  OS_TIME_IO(OS_CLOSE, 0, 0, 

    (p->pReal->pMethods ? p->pReal->pMethods->xClose(p->pReal) : SQLITE_OK)

  );

}

/*

** Read data from an inst-file.

*/

static int instRead(

  sqlite3_file *pFile, 

  void *zBuf, 

  int iAmt, 

  sqlite_int64 iOfst

){

  sqlite3_vfs *pVfs = (sqlite3_vfs *)(((inst_file *)pFile)->pInstVfs);

  OS_TIME_IO(OS_READ, iAmt, (binarylog_blob(pVfs, zBuf, iAmt, 1), iOfst), 

      p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst)

  );

}

/*

** Write data to an inst-file.

*/

static int instWrite(

  sqlite3_file *pFile,

  const void *z,

  int iAmt,

  sqlite_int64 iOfst

){

  sqlite3_vfs *pVfs = (sqlite3_vfs *)(((inst_file *)pFile)->pInstVfs);

  binarylog_blob(pVfs, z, iAmt, 1);

  OS_TIME_IO(OS_WRITE, iAmt, iOfst, 

      p->pReal->pMethods->xWrite(p->pReal, z, iAmt, iOfst)

  );

}

/*

** Truncate an inst-file.

*/

static int instTruncate(sqlite3_file *pFile, sqlite_int64 size){

  OS_TIME_IO(OS_TRUNCATE, 0, (int)size, 

    p->pReal->pMethods->xTruncate(p->pReal, size)

  );

}

/*

** Sync an inst-file.

*/

static int instSync(sqlite3_file *pFile, int flags){

  OS_TIME_IO(OS_SYNC, flags, 0, p->pReal->pMethods->xSync(p->pReal, flags));

}

/*

** Return the current file-size of an inst-file.

*/

static int instFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){

  OS_TIME_IO(OS_FILESIZE, (int)(*pSize), 0, 

    p->pReal->pMethods->xFileSize(p->pReal, pSize)

  );

}

/*

** Lock an inst-file.

*/

static int instLock(sqlite3_file *pFile, int eLock){

  OS_TIME_IO(OS_LOCK, eLock, 0, p->pReal->pMethods->xLock(p->pReal, eLock));

}

/*

** Unlock an inst-file.

*/

static int instUnlock(sqlite3_file *pFile, int eLock){

  OS_TIME_IO(OS_UNLOCK, eLock, 0, p->pReal->pMethods->xUnlock(p->pReal, eLock));

}

/*

** Check if another file-handle holds a RESERVED lock on an inst-file.

*/

static int instCheckReservedLock(sqlite3_file *pFile, int *pResOut){

  OS_TIME_IO(OS_CHECKRESERVEDLOCK, 0, 0, 

      p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut)

  );

}

/*

** File control method. For custom operations on an inst-file.

*/

static int instFileControl(sqlite3_file *pFile, int op, void *pArg){

  OS_TIME_IO(OS_FILECONTROL, 0, 0, p->pReal->pMethods->xFileControl(p->pReal, op, pArg));

}

/*

** Return the sector-size in bytes for an inst-file.

*/

static int instSectorSize(sqlite3_file *pFile){

  OS_TIME_IO(OS_SECTORSIZE, 0, 0, p->pReal->pMethods->xSectorSize(p->pReal));

}

/*

** Return the device characteristic flags supported by an inst-file.

*/

static int instDeviceCharacteristics(sqlite3_file *pFile){

  OS_TIME_IO(OS_DEVCHAR, 0, 0, p->pReal->pMethods->xDeviceCharacteristics(p->pReal));

}

/*

** Open an inst file handle.

*/

static int instOpen(

  sqlite3_vfs *pVfs,

  const char *zName,

  sqlite3_file *pFile,

  int flags,

  int *pOutFlags

){

  inst_file *p = (inst_file *)pFile;

  pFile->pMethods = &inst_io_methods;

  p->pReal = (sqlite3_file *)&p[1];

  p->pInstVfs = (InstVfs *)pVfs;

  p->zName = zName;

  p->flags = flags;

  p->iFileId = ++p->pInstVfs->iNextFileId;

  binarylog_blob(pVfs, zName, -1, 0);

  OS_TIME_VFS(OS_OPEN, zName, flags, p->iFileId, 0,

    REALVFS(pVfs)->xOpen(REALVFS(pVfs), zName, p->pReal, flags, pOutFlags)

  );

}

/*

** Delete the file located at zPath. If the dirSync argument is true,

** ensure the file-system modifications are synced to disk before

** returning.

*/

static int instDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){

  binarylog_blob(pVfs, zPath, -1, 0);

  OS_TIME_VFS(OS_DELETE, zPath, 0, dirSync, 0,

    REALVFS(pVfs)->xDelete(REALVFS(pVfs), zPath, dirSync) 

  );

}

/*

** Test for access permissions. Return true if the requested permission

** is available, or false otherwise.

*/

static int instAccess(

  sqlite3_vfs *pVfs, 

  const char *zPath, 

  int flags, 

  int *pResOut

){

  binarylog_blob(pVfs, zPath, -1, 0);

  OS_TIME_VFS(OS_ACCESS, zPath, 0, flags, *pResOut, 

    REALVFS(pVfs)->xAccess(REALVFS(pVfs), zPath, flags, pResOut) 

  );

}

/*

** Populate buffer zOut with the full canonical pathname corresponding

** to the pathname in zPath. zOut is guaranteed to point to a buffer

** of at least (INST_MAX_PATHNAME+1) bytes.

*/

static int instFullPathname(

  sqlite3_vfs *pVfs, 

  const char *zPath, 

  int nOut, 

  char *zOut

){

  OS_TIME_VFS( OS_FULLPATHNAME, zPath, 0, 0, 0,

    REALVFS(pVfs)->xFullPathname(REALVFS(pVfs), zPath, nOut, zOut);

  );

}

/*

** Open the dynamic library located at zPath and return a handle.

*/

static void *instDlOpen(sqlite3_vfs *pVfs, const char *zPath){

  return REALVFS(pVfs)->xDlOpen(REALVFS(pVfs), zPath);

}

/*

** Populate the buffer zErrMsg (size nByte bytes) with a human readable

** utf-8 string describing the most recent error encountered associated 

** with dynamic libraries.

*/

static void instDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){

  REALVFS(pVfs)->xDlError(REALVFS(pVfs), nByte, zErrMsg);

}

/*

** Return a pointer to the symbol zSymbol in the dynamic library pHandle.

*/

static void *instDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){

  return REALVFS(pVfs)->xDlSym(REALVFS(pVfs), pHandle, zSymbol);

}

/*

** Close the dynamic library handle pHandle.

*/

static void instDlClose(sqlite3_vfs *pVfs, void *pHandle){

  REALVFS(pVfs)->xDlClose(REALVFS(pVfs), pHandle);

}

/*

** Populate the buffer pointed to by zBufOut with nByte bytes of 

** random data.

*/

static int instRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){

  OS_TIME_VFS( OS_RANDOMNESS, 0, 0, nByte, 0,

    REALVFS(pVfs)->xRandomness(REALVFS(pVfs), nByte, zBufOut);

  );

}

/*

** Sleep for nMicro microseconds. Return the number of microseconds 

** actually slept.

*/

static int instSleep(sqlite3_vfs *pVfs, int nMicro){

  OS_TIME_VFS( OS_SLEEP, 0, 0, nMicro, 0, 

    REALVFS(pVfs)->xSleep(REALVFS(pVfs), nMicro) 

  );

}

/*

** Return the current time as a Julian Day number in *pTimeOut.

*/

static int instCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){

  OS_TIME_VFS( OS_CURRENTTIME, 0, 0, 0, 0,

    REALVFS(pVfs)->xCurrentTime(REALVFS(pVfs), pTimeOut) 

  );

}

sqlite3_vfs *sqlite3_instvfs_create(const char *zName, const char *zParent){

  int nByte;

  InstVfs *p;

  sqlite3_vfs *pParent;

  pParent = sqlite3_vfs_find(zParent);

  if( !pParent ){

    return 0;

  }

  nByte = strlen(zName) + 1 + sizeof(InstVfs);

  p = (InstVfs *)sqlite3_malloc(nByte);

  if( p ){

    char *zCopy = (char *)&p[1];

    memset(p, 0, nByte);

    memcpy(p, &inst_vfs, sizeof(sqlite3_vfs));

    p->pVfs = pParent;

    memcpy(zCopy, zName, strlen(zName));

    p->base.zName = (const char *)zCopy;

    p->base.szOsFile += pParent->szOsFile;

    sqlite3_vfs_register((sqlite3_vfs *)p, 0);

  }

  return (sqlite3_vfs *)p;

}

void sqlite3_instvfs_configure(

  sqlite3_vfs *pVfs,

  void (*xCall)(

      void*, 

      int,                           /* File id */

      int,                           /* Event code */

      sqlite3_int64, 

      int,                           /* Return code */

      const char*,                   /* File name */

      int, 

      int, 

      sqlite3_int64

  ),

  void *pClient,

  void (*xDel)(void *)

){

  InstVfs *p = (InstVfs *)pVfs;

  assert( pVfs->xOpen==instOpen );

  if( p->xDel ){

    p->xDel(p->pClient);

  }

  p->xCall = xCall;

  p->xDel = xDel;

  p->pClient = pClient;

}

void sqlite3_instvfs_destroy(sqlite3_vfs *pVfs){

  if( pVfs ){

    sqlite3_vfs_unregister(pVfs);

    sqlite3_instvfs_configure(pVfs, 0, 0, 0);

    sqlite3_free(pVfs);

  }

}

void sqlite3_instvfs_reset(sqlite3_vfs *pVfs){

  InstVfs *p = (InstVfs *)pVfs;

  assert( pVfs->xOpen==instOpen );

  memset(p->aTime, 0, sizeof(sqlite3_int64)*OS_NUMEVENTS);

  memset(p->aCount, 0, sizeof(int)*OS_NUMEVENTS);

}

const char *sqlite3_instvfs_name(int eEvent){

  const char *zEvent = 0;

  switch( eEvent ){

    case OS_CLOSE:             zEvent = "xClose"; break;

    case OS_READ:              zEvent = "xRead"; break;

    case OS_WRITE:             zEvent = "xWrite"; break;

    case OS_TRUNCATE:          zEvent = "xTruncate"; break;

    case OS_SYNC:              zEvent = "xSync"; break;

    case OS_FILESIZE:          zEvent = "xFilesize"; break;

    case OS_LOCK:              zEvent = "xLock"; break;

    case OS_UNLOCK:            zEvent = "xUnlock"; break;

    case OS_CHECKRESERVEDLOCK: zEvent = "xCheckReservedLock"; break;

    case OS_FILECONTROL:       zEvent = "xFileControl"; break;

    case OS_SECTORSIZE:        zEvent = "xSectorSize"; break;

    case OS_DEVCHAR:           zEvent = "xDeviceCharacteristics"; break;

    case OS_OPEN:              zEvent = "xOpen"; break;

    case OS_DELETE:            zEvent = "xDelete"; break;

    case OS_ACCESS:            zEvent = "xAccess"; break;

    case OS_FULLPATHNAME:      zEvent = "xFullPathname"; break;

    case OS_RANDOMNESS:        zEvent = "xRandomness"; break;

    case OS_SLEEP:             zEvent = "xSleep"; break;

    case OS_CURRENTTIME:       zEvent = "xCurrentTime"; break;

  }

  return zEvent;

}

void sqlite3_instvfs_get(

  sqlite3_vfs *pVfs, 

  int eEvent, 

  const char **pzEvent, 

  sqlite3_int64 *pnClick, 

  int *pnCall

){

  InstVfs *p = (InstVfs *)pVfs;

  assert( pVfs->xOpen==instOpen );

  if( eEvent<1 || eEvent>=OS_NUMEVENTS ){

    *pzEvent = 0;

    *pnClick = 0;

    *pnCall = 0;

    return;

  }

  *pzEvent = sqlite3_instvfs_name(eEvent);

  *pnClick = p->aTime[eEvent];

  *pnCall = p->aCount[eEvent];

}

#define BINARYLOG_BUFFERSIZE 8192

struct InstVfsBinaryLog {

  int nBuf;

  char *zBuf;

  sqlite3_int64 iOffset;

  int log_data;

  sqlite3_file *pOut;

  char *zOut;                       /* Log file name */

};

typedef struct InstVfsBinaryLog InstVfsBinaryLog;

static void put32bits(unsigned char *p, unsigned int v){

  p[0] = v>>24;

  p[1] = v>>16;

  p[2] = v>>8;

  p[3] = v;

}

static void binarylog_flush(InstVfsBinaryLog *pLog){

  sqlite3_file *pFile = pLog->pOut;

#ifdef SQLITE_TEST

  extern int sqlite3_io_error_pending;

  extern int sqlite3_io_error_persist;

  extern int sqlite3_diskfull_pending;

  int pending = sqlite3_io_error_pending;

  int persist = sqlite3_io_error_persist;

  int diskfull = sqlite3_diskfull_pending;

  sqlite3_io_error_pending = 0;

  sqlite3_io_error_persist = 0;

  sqlite3_diskfull_pending = 0;

#endif

  pFile->pMethods->xWrite(pFile, pLog->zBuf, pLog->nBuf, pLog->iOffset);

  pLog->iOffset += pLog->nBuf;

  pLog->nBuf = 0;

#ifdef SQLITE_TEST

  sqlite3_io_error_pending = pending;

  sqlite3_io_error_persist = persist;

  sqlite3_diskfull_pending = diskfull;

#endif

}

static void binarylog_xcall(

  void *p,

  int eEvent,

  int iFileId,

  sqlite3_int64 nClick,

  int return_code,

  const char *zName,

  int flags,

  int nByte,

  sqlite3_int64 iOffset

){

  InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)p;

  unsigned char *zRec;

  if( (28+pLog->nBuf)>BINARYLOG_BUFFERSIZE ){

    binarylog_flush(pLog);

  }

  zRec = (unsigned char *)&pLog->zBuf[pLog->nBuf];

  put32bits(&zRec[0], eEvent);

  put32bits(&zRec[4], (int)iFileId);

  put32bits(&zRec[8], (int)nClick);

  put32bits(&zRec[12], return_code);

  put32bits(&zRec[16], flags);

  put32bits(&zRec[20], nByte);

  put32bits(&zRec[24], (int)iOffset);

  pLog->nBuf += 28;

}

static void binarylog_xdel(void *p){

  /* Close the log file and free the memory allocated for the 

  ** InstVfsBinaryLog structure.

  */

  InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)p;

  sqlite3_file *pFile = pLog->pOut;

  if( pLog->nBuf ){

    binarylog_flush(pLog);

  }

  pFile->pMethods->xClose(pFile);

  sqlite3_free(pLog->pOut);

  sqlite3_free(pLog->zBuf);

  sqlite3_free(pLog);

}

static void binarylog_blob(

  sqlite3_vfs *pVfs,

  const char *zBlob,

  int nBlob,

  int isBinary

){

  InstVfsBinaryLog *pLog;

  InstVfs *pInstVfs = (InstVfs *)pVfs;

  if( pVfs->xOpen!=instOpen || pInstVfs->xCall!=binarylog_xcall ){

    return;

  }

  pLog = (InstVfsBinaryLog *)pInstVfs->pClient;

  if( zBlob && (!isBinary || pLog->log_data) ){

    unsigned char *zRec;

    int nWrite;

    if( nBlob<0 ){

      nBlob = strlen(zBlob);

    }

    nWrite = nBlob + 28;

    if( (nWrite+pLog->nBuf)>BINARYLOG_BUFFERSIZE ){

      binarylog_flush(pLog);

    }

    zRec = (unsigned char *)&pLog->zBuf[pLog->nBuf];

    memset(zRec, 0, nWrite);

    put32bits(&zRec[0], BINARYLOG_STRING);

    put32bits(&zRec[4], (int)nBlob);

    put32bits(&zRec[8], (int)isBinary);

    memcpy(&zRec[28], zBlob, nBlob);

    pLog->nBuf += nWrite;

  }

}

void sqlite3_instvfs_binarylog_call(

  sqlite3_vfs *pVfs,

  int eEvent,

  sqlite3_int64 nClick,

  int return_code,

  const char *zString

){

  InstVfs *pInstVfs = (InstVfs *)pVfs;

  InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)pInstVfs->pClient;

  if( zString ){

    binarylog_blob(pVfs, zString, -1, 0);

  }

  binarylog_xcall(pLog, eEvent, 0, nClick, return_code, 0, 0, 0, 0);

}

void sqlite3_instvfs_binarylog_marker(

  sqlite3_vfs *pVfs,

  const char *zMarker

){

  InstVfs *pInstVfs = (InstVfs *)pVfs;

  InstVfsBinaryLog *pLog = (InstVfsBinaryLog *)pInstVfs->pClient;

  binarylog_blob(pVfs, zMarker, -1, 0);

  binarylog_xcall(pLog, BINARYLOG_MARKER, 0, 0, 0, 0, 0, 0, 0);

}

sqlite3_vfs *sqlite3_instvfs_binarylog(

  const char *zVfs,

  const char *zParentVfs, 

  const char *zLog,

  int log_data

){

  InstVfsBinaryLog *p;

  sqlite3_vfs *pVfs;

  sqlite3_vfs *pParent;

  int nByte;

  int flags;

  int rc;

  pParent = sqlite3_vfs_find(zParentVfs);

  if( !pParent ){

    return 0;

  }

  nByte = sizeof(InstVfsBinaryLog) + pParent->mxPathname+1;

  p = (InstVfsBinaryLog *)sqlite3_malloc(nByte);

  memset(p, 0, nByte);

  p->zBuf = sqlite3_malloc(BINARYLOG_BUFFERSIZE);

  p->zOut = (char *)&p[1];

  p->pOut = (sqlite3_file *)sqlite3_malloc(pParent->szOsFile);

  p->log_data = log_data;

  pParent->xFullPathname(pParent, zLog, pParent->mxPathname, p->zOut);

  flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MASTER_JOURNAL;

  pParent->xDelete(pParent, p->zOut, 0);

  rc = pParent->xOpen(pParent, p->zOut, p->pOut, flags, &flags);

  if( rc==SQLITE_OK ){

    memcpy(p->zBuf, "sqlite_ostrace1.....", 20);

    p->iOffset = 0;

    p->nBuf = 20;

  }

  if( rc ){

    binarylog_xdel(p);

    return 0;

  }

  pVfs = sqlite3_instvfs_create(zVfs, zParentVfs);

  if( pVfs ){

    sqlite3_instvfs_configure(pVfs, binarylog_xcall, p, binarylog_xdel);

  }

  return pVfs;

}

#endif /* SQLITE_ENABLE_INSTVFS */

/**************************************************************************

***************************************************************************

** Tcl interface starts here.

*/

#if SQLITE_TEST

#include "tcl.h"

#ifdef SQLITE_ENABLE_INSTVFS

struct InstVfsCall {

  Tcl_Interp *interp;

  Tcl_Obj *pScript;

};

typedef struct InstVfsCall InstVfsCall;

static void test_instvfs_xcall(

  void *p,

  int eEvent,

  int iFileId,

  sqlite3_int64 nClick,

  int return_code,

  const char *zName,

  int flags,

  int nByte,

  sqlite3_int64 iOffset

){

  int rc;

  InstVfsCall *pCall = (InstVfsCall *)p;

  Tcl_Obj *pObj = Tcl_DuplicateObj( pCall->pScript);

  const char *zEvent = sqlite3_instvfs_name(eEvent);

  Tcl_IncrRefCount(pObj);

  Tcl_ListObjAppendElement(0, pObj, Tcl_NewStringObj(zEvent, -1));

  Tcl_ListObjAppendElement(0, pObj, Tcl_NewWideIntObj(nClick));

  Tcl_ListObjAppendElement(0, pObj, Tcl_NewStringObj(zName, -1));

  Tcl_ListObjAppendElement(0, pObj, Tcl_NewIntObj(nByte));

  Tcl_ListObjAppendElement(0, pObj, Tcl_NewWideIntObj(iOffset));

  rc = Tcl_EvalObjEx(pCall->interp, pObj, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);

  if( rc ){

    Tcl_BackgroundError(pCall->interp);

  }

  Tcl_DecrRefCount(pObj);

}

static void test_instvfs_xdel(void *p){

  InstVfsCall *pCall = (InstVfsCall *)p;

  Tcl_DecrRefCount(pCall->pScript);

  sqlite3_free(pCall);

}

static int test_sqlite3_instvfs(

  void * clientData,

  Tcl_Interp *interp,

  int objc,

  Tcl_Obj *CONST objv[]

){

  static const char *IV_strs[] = 

               { "create",  "destroy",  "reset",  "report", "configure", "binarylog", "marker", 0 };

  enum IV_enum { IV_CREATE, IV_DESTROY, IV_RESET, IV_REPORT, IV_CONFIGURE, IV_BINARYLOG, IV_MARKER };

  int iSub;

  if( objc<2 ){

    Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");

  }

  if( Tcl_GetIndexFromObj(interp, objv[1], IV_strs, "sub-command", 0, &iSub) ){

    return TCL_ERROR;

  }

  switch( (enum IV_enum)iSub ){

    case IV_CREATE: {

      char *zParent = 0;

      sqlite3_vfs *p;

      int isDefault = 0;

      if( objc>2 && 0==strcmp("-default", Tcl_GetString(objv[2])) ){

        isDefault = 1;

      }

      if( (objc-isDefault)!=4 && (objc-isDefault)!=3 ){

        Tcl_WrongNumArgs(interp, 2, objv, "?-default? NAME ?PARENT-VFS?");

        return TCL_ERROR;

      }

      if( objc==(4+isDefault) ){

        zParent = Tcl_GetString(objv[3+isDefault]);

      }

      p = sqlite3_instvfs_create(Tcl_GetString(objv[2+isDefault]), zParent);

      if( !p ){

        Tcl_AppendResult(interp, "error creating vfs ", 0);

        return TCL_ERROR;

      }

      if( isDefault ){

        sqlite3_vfs_register(p, 1);

      }

      Tcl_SetObjResult(interp, objv[2]);

      break;

    }

    case IV_BINARYLOG: {

      char *zName = 0;

      char *zLog = 0;

      char *zParent = 0;

      sqlite3_vfs *p;

      int isDefault = 0;

      int isLogdata = 0;

      int argbase = 2;

      for(argbase=2; argbase<(objc-2); argbase++){

        if( 0==strcmp("-default", Tcl_GetString(objv[argbase])) ){

          isDefault = 1;

        }

        else if( 0==strcmp("-parent", Tcl_GetString(objv[argbase])) ){

          argbase++;

          zParent = Tcl_GetString(objv[argbase]);

        }

        else if( 0==strcmp("-logdata", Tcl_GetString(objv[argbase])) ){

          isLogdata = 1;

        }else{

          break;

        }

      }

      if( (objc-argbase)!=2 ){

        Tcl_WrongNumArgs(

            interp, 2, objv, "?-default? ?-parent VFS? ?-logdata? NAME LOGFILE"

        );

        return TCL_ERROR;

      }

      zName = Tcl_GetString(objv[argbase]);

      zLog = Tcl_GetString(objv[argbase+1]);

      p = sqlite3_instvfs_binarylog(zName, zParent, zLog, isLogdata);

      if( !p ){

        Tcl_AppendResult(interp, "error creating vfs ", 0);

        return TCL_ERROR;

      }

      if( isDefault ){

        sqlite3_vfs_register(p, 1);

      }

      Tcl_SetObjResult(interp, objv[2]);

      break;

    }

    case IV_MARKER: {

      sqlite3_vfs *p;

      if( objc!=4 ){

        Tcl_WrongNumArgs(interp, 2, objv, "VFS MARKER");

        return TCL_ERROR;

      }

      p = sqlite3_vfs_find(Tcl_GetString(objv[2]));

      if( !p || p->xOpen!=instOpen ){

        Tcl_AppendResult(interp, "no such vfs: ", Tcl_GetString(objv[2]), 0);

        return TCL_ERROR;

      }

      sqlite3_instvfs_binarylog_marker(p, Tcl_GetString(objv[3]));

      Tcl_ResetResult(interp);

      break;

    }

    case IV_CONFIGURE: {

      InstVfsCall *pCall;

      sqlite3_vfs *p;

      if( objc!=4 ){

        Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");

        return TCL_ERROR;

      }

      p = sqlite3_vfs_find(Tcl_GetString(objv[2]));

      if( !p || p->xOpen!=instOpen ){

        Tcl_AppendResult(interp, "no such vfs: ", Tcl_GetString(objv[2]), 0);

        return TCL_ERROR;

      }

      if( strlen(Tcl_GetString(objv[3])) ){

        pCall = (InstVfsCall *)sqlite3_malloc(sizeof(InstVfsCall));

        pCall->interp = interp;

        pCall->pScript = Tcl_DuplicateObj(objv[3]);

        Tcl_IncrRefCount(pCall->pScript);

        sqlite3_instvfs_configure(p, 

            test_instvfs_xcall, (void *)pCall, test_instvfs_xdel

        );

      }else{

        sqlite3_instvfs_configure(p, 0, 0, 0);

      }