src/test_vfs.c

   1 /*
   2 ** 2010 May 05
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 ******************************************************************************
  12 **
  13 ** This file contains the implementation of the Tcl [testvfs] command,
  14 ** used to create SQLite VFS implementations with various properties and
  15 ** instrumentation to support testing SQLite.
  16 **
  17 **   testvfs VFSNAME ?OPTIONS?
  18 **
  19 ** Available options are:
  20 **
  21 **   -noshm      BOOLEAN        (True to omit shm methods. Default false)
  22 **   -default    BOOLEAN        (True to make the vfs default. Default false)
  23 **   -szosfile   INTEGER        (Value for sqlite3_vfs.szOsFile)
  24 **   -mxpathname INTEGER        (Value for sqlite3_vfs.mxPathname)
  25 **   -iversion   INTEGER        (Value for sqlite3_vfs.iVersion)
  26 */
  27 #if SQLITE_TEST          /* This file is used for testing only */
  28
  29 #include "sqlite3.h"
  30 #include "sqliteInt.h"
  31 #if defined(INCLUDE_SQLITE_TCL_H)
  32 #  include "sqlite_tcl.h"
  33 #else
  34 #  include "tcl.h"
  35 #endif
  36
  37 typedef struct Testvfs Testvfs;
  38 typedef struct TestvfsShm TestvfsShm;
  39 typedef struct TestvfsBuffer TestvfsBuffer;
  40 typedef struct TestvfsFile TestvfsFile;
  41 typedef struct TestvfsFd TestvfsFd;
  42
  43 /*
  44 ** An open file handle.
  45 */
  46 struct TestvfsFile {
  47   sqlite3_file base;              /* Base class.  Must be first */
  48   TestvfsFd *pFd;                 /* File data */
  49 };
  50 #define tvfsGetFd(pFile) (((TestvfsFile *)pFile)->pFd)
  51
  52 struct TestvfsFd {
  53   sqlite3_vfs *pVfs;              /* The VFS */
  54   const char *zFilename;          /* Filename as passed to xOpen() */
  55   sqlite3_file *pReal;            /* The real, underlying file descriptor */
  56   Tcl_Obj *pShmId;                /* Shared memory id for Tcl callbacks */
  57
  58   TestvfsBuffer *pShm;            /* Shared memory buffer */
  59   u32 excllock;                   /* Mask of exclusive locks */
  60   u32 sharedlock;                 /* Mask of shared locks */
  61   TestvfsFd *pNext;               /* Next handle opened on the same file */
  62 };
  63
  64
  65 #define FAULT_INJECT_NONE       0
  66 #define FAULT_INJECT_TRANSIENT  1
  67 #define FAULT_INJECT_PERSISTENT 2
  68
  69 typedef struct TestFaultInject TestFaultInject;
  70 struct TestFaultInject {
  71   int iCnt;                       /* Remaining calls before fault injection */
  72   int eFault;                     /* A FAULT_INJECT_* value */
  73   int nFail;                      /* Number of faults injected */
  74 };
  75
  76 /*
  77 ** An instance of this structure is allocated for each VFS created. The
  78 ** sqlite3_vfs.pAppData field of the VFS structure registered with SQLite
  79 ** is set to point to it.
  80 */
  81 struct Testvfs {
  82   char *zName;                    /* Name of this VFS */
  83   sqlite3_vfs *pParent;           /* The VFS to use for file IO */
  84   sqlite3_vfs *pVfs;              /* The testvfs registered with SQLite */
  85   Tcl_Interp *interp;             /* Interpreter to run script in */
  86   Tcl_Obj *pScript;               /* Script to execute */
  87   TestvfsBuffer *pBuffer;         /* List of shared buffers */
  88   int isNoshm;
  89   int isFullshm;
  90
  91   int mask;                       /* Mask controlling [script] and [ioerr] */
  92
  93   TestFaultInject ioerr_err;
  94   TestFaultInject full_err;
  95   TestFaultInject cantopen_err;
  96
  97 #if 0
  98   int iIoerrCnt;
  99   int ioerr;
 100   int nIoerrFail;
 101   int iFullCnt;
 102   int fullerr;
 103   int nFullFail;
 104 #endif
 105
 106   int iDevchar;
 107   int iSectorsize;
 108 };
 109
 110 /*
 111 ** The Testvfs.mask variable is set to a combination of the following.
 112 ** If a bit is clear in Testvfs.mask, then calls made by SQLite to the
 113 ** corresponding VFS method is ignored for purposes of:
 114 **
 115 **   + Simulating IO errors, and
 116 **   + Invoking the Tcl callback script.
 117 */
 118 #define TESTVFS_SHMOPEN_MASK      0x00000001
 119 #define TESTVFS_SHMLOCK_MASK      0x00000010
 120 #define TESTVFS_SHMMAP_MASK       0x00000020
 121 #define TESTVFS_SHMBARRIER_MASK   0x00000040
 122 #define TESTVFS_SHMCLOSE_MASK     0x00000080
 123
 124 #define TESTVFS_OPEN_MASK         0x00000100
 125 #define TESTVFS_SYNC_MASK         0x00000200
 126 #define TESTVFS_DELETE_MASK       0x00000400
 127 #define TESTVFS_CLOSE_MASK        0x00000800
 128 #define TESTVFS_WRITE_MASK        0x00001000
 129 #define TESTVFS_TRUNCATE_MASK     0x00002000
 130 #define TESTVFS_ACCESS_MASK       0x00004000
 131 #define TESTVFS_FULLPATHNAME_MASK 0x00008000
 132 #define TESTVFS_READ_MASK         0x00010000
 133 #define TESTVFS_UNLOCK_MASK       0x00020000
 134 #define TESTVFS_LOCK_MASK         0x00040000
 135 #define TESTVFS_CKLOCK_MASK       0x00080000
 136 #define TESTVFS_FCNTL_MASK        0x00100000
 137
 138 #define TESTVFS_ALL_MASK          0x001FFFFF
 139
 140
 141 #define TESTVFS_MAX_PAGES 1024
 142
 143 /*
 144 ** A shared-memory buffer. There is one of these objects for each shared
 145 ** memory region opened by clients. If two clients open the same file,
 146 ** there are two TestvfsFile structures but only one TestvfsBuffer structure.
 147 */
 148 struct TestvfsBuffer {
 149   char *zFile;                    /* Associated file name */
 150   int pgsz;                       /* Page size */
 151   u8 *aPage[TESTVFS_MAX_PAGES];   /* Array of ckalloc'd pages */
 152   TestvfsFd *pFile;               /* List of open handles */
 153   TestvfsBuffer *pNext;           /* Next in linked list of all buffers */
 154 };
 155
 156
 157 #define PARENTVFS(x) (((Testvfs *)((x)->pAppData))->pParent)
 158
 159 #define TESTVFS_MAX_ARGS 12
 160
 161
 162 /*
 163 ** Method declarations for TestvfsFile.
 164 */
 165 static int tvfsClose(sqlite3_file*);
 166 static int tvfsRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
 167 static int tvfsWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
 168 static int tvfsTruncate(sqlite3_file*, sqlite3_int64 size);
 169 static int tvfsSync(sqlite3_file*, int flags);
 170 static int tvfsFileSize(sqlite3_file*, sqlite3_int64 *pSize);
 171 static int tvfsLock(sqlite3_file*, int);
 172 static int tvfsUnlock(sqlite3_file*, int);
 173 static int tvfsCheckReservedLock(sqlite3_file*, int *);
 174 static int tvfsFileControl(sqlite3_file*, int op, void *pArg);
 175 static int tvfsSectorSize(sqlite3_file*);
 176 static int tvfsDeviceCharacteristics(sqlite3_file*);
 177
 178 /*
 179 ** Method declarations for tvfs_vfs.
 180 */
 181 static int tvfsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
 182 static int tvfsDelete(sqlite3_vfs*, const char *zName, int syncDir);
 183 static int tvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
 184 static int tvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
 185 #ifndef SQLITE_OMIT_LOAD_EXTENSION
 186 static void *tvfsDlOpen(sqlite3_vfs*, const char *zFilename);
 187 static void tvfsDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
 188 static void (*tvfsDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);
 189 static void tvfsDlClose(sqlite3_vfs*, void*);
 190 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
 191 static int tvfsRandomness(sqlite3_vfs*, int nByte, char *zOut);
 192 static int tvfsSleep(sqlite3_vfs*, int microseconds);
 193 static int tvfsCurrentTime(sqlite3_vfs*, double*);
 194
 195 static int tvfsShmOpen(sqlite3_file*);
 196 static int tvfsShmLock(sqlite3_file*, int , int, int);
 197 static int tvfsShmMap(sqlite3_file*,int,int,int, void volatile **);
 198 static void tvfsShmBarrier(sqlite3_file*);
 199 static int tvfsShmUnmap(sqlite3_file*, int);
 200
 201 static int tvfsFetch(sqlite3_file*, sqlite3_int64, int, void**);
 202 static int tvfsUnfetch(sqlite3_file*, sqlite3_int64, void*);
 203
 204 static sqlite3_io_methods tvfs_io_methods = {
 205   3,                              /* iVersion */
 206   tvfsClose,                      /* xClose */
 207   tvfsRead,                       /* xRead */
 208   tvfsWrite,                      /* xWrite */
 209   tvfsTruncate,                   /* xTruncate */
 210   tvfsSync,                       /* xSync */
 211   tvfsFileSize,                   /* xFileSize */
 212   tvfsLock,                       /* xLock */
 213   tvfsUnlock,                     /* xUnlock */
 214   tvfsCheckReservedLock,          /* xCheckReservedLock */
 215   tvfsFileControl,                /* xFileControl */
 216   tvfsSectorSize,                 /* xSectorSize */
 217   tvfsDeviceCharacteristics,      /* xDeviceCharacteristics */
 218   tvfsShmMap,                     /* xShmMap */
 219   tvfsShmLock,                    /* xShmLock */
 220   tvfsShmBarrier,                 /* xShmBarrier */
 221   tvfsShmUnmap,                   /* xShmUnmap */
 222   tvfsFetch,
 223   tvfsUnfetch
 224 };
 225
 226 static int tvfsResultCode(Testvfs *p, int *pRc){
 227   struct errcode {
 228     int eCode;
 229     const char *zCode;
 230   } aCode[] = {
 231     { SQLITE_OK,       "SQLITE_OK"     },
 232     { SQLITE_ERROR,    "SQLITE_ERROR"  },
 233     { SQLITE_IOERR,    "SQLITE_IOERR"  },
 234     { SQLITE_LOCKED,   "SQLITE_LOCKED" },
 235     { SQLITE_BUSY,     "SQLITE_BUSY"   },
 236     { SQLITE_READONLY, "SQLITE_READONLY"   },
 237     { SQLITE_READONLY_CANTINIT, "SQLITE_READONLY_CANTINIT"   },
 238     { SQLITE_NOTFOUND, "SQLITE_NOTFOUND"   },
 239     { -1,              "SQLITE_OMIT"   },
 240   };
 241
 242   const char *z;
 243   int i;
 244
 245   z = Tcl_GetStringResult(p->interp);
 246   for(i=0; i<ArraySize(aCode); i++){
 247     if( 0==strcmp(z, aCode[i].zCode) ){
 248       *pRc = aCode[i].eCode;
 249       return 1;
 250     }
 251   }
 252
 253   return 0;
 254 }
 255
 256 static int tvfsInjectFault(TestFaultInject *p){
 257   int ret = 0;
 258   if( p->eFault ){
 259     p->iCnt--;
 260     if( p->iCnt==0 || (p->iCnt<0 && p->eFault==FAULT_INJECT_PERSISTENT ) ){
 261       ret = 1;
 262       p->nFail++;
 263     }
 264   }
 265   return ret;
 266 }
 267
 268
 269 static int tvfsInjectIoerr(Testvfs *p){
 270   return tvfsInjectFault(&p->ioerr_err);
 271 }
 272
 273 static int tvfsInjectFullerr(Testvfs *p){
 274   return tvfsInjectFault(&p->full_err);
 275 }
 276 static int tvfsInjectCantopenerr(Testvfs *p){
 277   return tvfsInjectFault(&p->cantopen_err);
 278 }
 279
 280
 281 static void tvfsExecTcl(
 282   Testvfs *p,
 283   const char *zMethod,
 284   Tcl_Obj *arg1,
 285   Tcl_Obj *arg2,
 286   Tcl_Obj *arg3,
 287   Tcl_Obj *arg4
 288 ){
 289   int rc;                         /* Return code from Tcl_EvalObj() */
 290   Tcl_Obj *pEval;
 291   assert( p->pScript );
 292
 293   assert( zMethod );
 294   assert( p );
 295   assert( arg2==0 || arg1!=0 );
 296   assert( arg3==0 || arg2!=0 );
 297
 298   pEval = Tcl_DuplicateObj(p->pScript);
 299   Tcl_IncrRefCount(p->pScript);
 300   Tcl_ListObjAppendElement(p->interp, pEval, Tcl_NewStringObj(zMethod, -1));
 301   if( arg1 ) Tcl_ListObjAppendElement(p->interp, pEval, arg1);
 302   if( arg2 ) Tcl_ListObjAppendElement(p->interp, pEval, arg2);
 303   if( arg3 ) Tcl_ListObjAppendElement(p->interp, pEval, arg3);
 304   if( arg4 ) Tcl_ListObjAppendElement(p->interp, pEval, arg4);
 305
 306   rc = Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL);
 307   if( rc!=TCL_OK ){
 308     Tcl_BackgroundError(p->interp);
 309     Tcl_ResetResult(p->interp);
 310   }
 311 }
 312
 313
 314 /*
 315 ** Close an tvfs-file.
 316 */
 317 static int tvfsClose(sqlite3_file *pFile){
 318   TestvfsFile *pTestfile = (TestvfsFile *)pFile;
 319   TestvfsFd *pFd = pTestfile->pFd;
 320   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 321
 322   if( p->pScript && p->mask&TESTVFS_CLOSE_MASK ){
 323     tvfsExecTcl(p, "xClose",
 324         Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, 0, 0
 325     );
 326   }
 327
 328   if( pFd->pShmId ){
 329     Tcl_DecrRefCount(pFd->pShmId);
 330     pFd->pShmId = 0;
 331   }
 332   if( pFile->pMethods ){
 333     ckfree((char *)pFile->pMethods);
 334   }
 335   sqlite3OsClose(pFd->pReal);
 336   ckfree((char *)pFd);
 337   pTestfile->pFd = 0;
 338   return SQLITE_OK;
 339 }
 340
 341 /*
 342 ** Read data from an tvfs-file.
 343 */
 344 static int tvfsRead(
 345   sqlite3_file *pFile,
 346   void *zBuf,
 347   int iAmt,
 348   sqlite_int64 iOfst
 349 ){
 350   int rc = SQLITE_OK;
 351   TestvfsFd *pFd = tvfsGetFd(pFile);
 352   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 353   if( p->pScript && p->mask&TESTVFS_READ_MASK ){
 354     tvfsExecTcl(p, "xRead",
 355         Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, 0, 0
 356     );
 357     tvfsResultCode(p, &rc);
 358   }
 359   if( rc==SQLITE_OK && p->mask&TESTVFS_READ_MASK && tvfsInjectIoerr(p) ){
 360     rc = SQLITE_IOERR;
 361   }
 362   if( rc==SQLITE_OK ){
 363     rc = sqlite3OsRead(pFd->pReal, zBuf, iAmt, iOfst);
 364   }
 365   return rc;
 366 }
 367
 368 /*
 369 ** Write data to an tvfs-file.
 370 */
 371 static int tvfsWrite(
 372   sqlite3_file *pFile,
 373   const void *zBuf,
 374   int iAmt,
 375   sqlite_int64 iOfst
 376 ){
 377   int rc = SQLITE_OK;
 378   TestvfsFd *pFd = tvfsGetFd(pFile);
 379   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 380
 381   if( p->pScript && p->mask&TESTVFS_WRITE_MASK ){
 382     tvfsExecTcl(p, "xWrite",
 383         Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId,
 384         Tcl_NewWideIntObj(iOfst), Tcl_NewIntObj(iAmt)
 385     );
 386     tvfsResultCode(p, &rc);
 387     if( rc<0 ) return SQLITE_OK;
 388   }
 389
 390   if( rc==SQLITE_OK && tvfsInjectFullerr(p) ){
 391     rc = SQLITE_FULL;
 392   }
 393   if( rc==SQLITE_OK && p->mask&TESTVFS_WRITE_MASK && tvfsInjectIoerr(p) ){
 394     rc = SQLITE_IOERR;
 395   }
 396
 397   if( rc==SQLITE_OK ){
 398     rc = sqlite3OsWrite(pFd->pReal, zBuf, iAmt, iOfst);
 399   }
 400   return rc;
 401 }
 402
 403 /*
 404 ** Truncate an tvfs-file.
 405 */
 406 static int tvfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
 407   int rc = SQLITE_OK;
 408   TestvfsFd *pFd = tvfsGetFd(pFile);
 409   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 410
 411   if( p->pScript && p->mask&TESTVFS_TRUNCATE_MASK ){
 412     tvfsExecTcl(p, "xTruncate",
 413         Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, 0, 0
 414     );
 415     tvfsResultCode(p, &rc);
 416   }
 417
 418   if( rc==SQLITE_OK ){
 419     rc = sqlite3OsTruncate(pFd->pReal, size);
 420   }
 421   return rc;
 422 }
 423
 424 /*
 425 ** Sync an tvfs-file.
 426 */
 427 static int tvfsSync(sqlite3_file *pFile, int flags){
 428   int rc = SQLITE_OK;
 429   TestvfsFd *pFd = tvfsGetFd(pFile);
 430   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 431
 432   if( p->pScript && p->mask&TESTVFS_SYNC_MASK ){
 433     char *zFlags = 0;
 434
 435     switch( flags ){
 436       case SQLITE_SYNC_NORMAL:
 437         zFlags = "normal";
 438         break;
 439       case SQLITE_SYNC_FULL:
 440         zFlags = "full";
 441         break;
 442       case SQLITE_SYNC_NORMAL|SQLITE_SYNC_DATAONLY:
 443         zFlags = "normal|dataonly";
 444         break;
 445       case SQLITE_SYNC_FULL|SQLITE_SYNC_DATAONLY:
 446         zFlags = "full|dataonly";
 447         break;
 448       default:
 449         assert(0);
 450     }
 451
 452     tvfsExecTcl(p, "xSync",
 453         Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId,
 454         Tcl_NewStringObj(zFlags, -1), 0
 455     );
 456     tvfsResultCode(p, &rc);
 457   }
 458
 459   if( rc==SQLITE_OK && tvfsInjectFullerr(p) ) rc = SQLITE_FULL;
 460
 461   if( rc==SQLITE_OK ){
 462     rc = sqlite3OsSync(pFd->pReal, flags);
 463   }
 464
 465   return rc;
 466 }
 467
 468 /*
 469 ** Return the current file-size of an tvfs-file.
 470 */
 471 static int tvfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
 472   TestvfsFd *p = tvfsGetFd(pFile);
 473   return sqlite3OsFileSize(p->pReal, pSize);
 474 }
 475
 476 /*
 477 ** Lock an tvfs-file.
 478 */
 479 static int tvfsLock(sqlite3_file *pFile, int eLock){
 480   TestvfsFd *pFd = tvfsGetFd(pFile);
 481   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 482   if( p->pScript && p->mask&TESTVFS_LOCK_MASK ){
 483     char zLock[30];
 484     sqlite3_snprintf(sizeof(zLock),zLock,"%d",eLock);
 485     tvfsExecTcl(p, "xLock", Tcl_NewStringObj(pFd->zFilename, -1),
 486                    Tcl_NewStringObj(zLock, -1), 0, 0);
 487   }
 488   return sqlite3OsLock(pFd->pReal, eLock);
 489 }
 490
 491 /*
 492 ** Unlock an tvfs-file.
 493 */
 494 static int tvfsUnlock(sqlite3_file *pFile, int eLock){
 495   TestvfsFd *pFd = tvfsGetFd(pFile);
 496   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 497   if( p->pScript && p->mask&TESTVFS_UNLOCK_MASK ){
 498     char zLock[30];
 499     sqlite3_snprintf(sizeof(zLock),zLock,"%d",eLock);
 500     tvfsExecTcl(p, "xUnlock", Tcl_NewStringObj(pFd->zFilename, -1),
 501                    Tcl_NewStringObj(zLock, -1), 0, 0);
 502   }
 503   if( p->mask&TESTVFS_WRITE_MASK && tvfsInjectIoerr(p) ){
 504     return SQLITE_IOERR_UNLOCK;
 505   }
 506   return sqlite3OsUnlock(pFd->pReal, eLock);
 507 }
 508
 509 /*
 510 ** Check if another file-handle holds a RESERVED lock on an tvfs-file.
 511 */
 512 static int tvfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
 513   TestvfsFd *pFd = tvfsGetFd(pFile);
 514   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 515   if( p->pScript && p->mask&TESTVFS_CKLOCK_MASK ){
 516     tvfsExecTcl(p, "xCheckReservedLock", Tcl_NewStringObj(pFd->zFilename, -1),
 517                    0, 0, 0);
 518   }
 519   return sqlite3OsCheckReservedLock(pFd->pReal, pResOut);
 520 }
 521
 522 /*
 523 ** File control method. For custom operations on an tvfs-file.
 524 */
 525 static int tvfsFileControl(sqlite3_file *pFile, int op, void *pArg){
 526   TestvfsFd *pFd = tvfsGetFd(pFile);
 527   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 528   if( op==SQLITE_FCNTL_PRAGMA ){
 529     char **argv = (char**)pArg;
 530     if( sqlite3_stricmp(argv[1],"error")==0 ){
 531       int rc = SQLITE_ERROR;
 532       if( argv[2] ){
 533         const char *z = argv[2];
 534         int x = atoi(z);
 535         if( x ){
 536           rc = x;
 537           while( sqlite3Isdigit(z[0]) ){ z++; }
 538           while( sqlite3Isspace(z[0]) ){ z++; }
 539         }
 540         if( z[0] ) argv[0] = sqlite3_mprintf("%s", z);
 541       }
 542       return rc;
 543     }
 544     if( sqlite3_stricmp(argv[1], "filename")==0 ){
 545       argv[0] = sqlite3_mprintf("%s", pFd->zFilename);
 546       return SQLITE_OK;
 547     }
 548   }
 549   if( p->pScript && (p->mask&TESTVFS_FCNTL_MASK) ){
 550     struct Fcntl {
 551       int iFnctl;
 552       const char *zFnctl;
 553     } aF[] = {
 554       { SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, "BEGIN_ATOMIC_WRITE" },
 555       { SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, "COMMIT_ATOMIC_WRITE" },
 556       { SQLITE_FCNTL_ZIPVFS, "ZIPVFS" },
 557     };
 558     int i;
 559     for(i=0; i<sizeof(aF)/sizeof(aF[0]); i++){
 560       if( op==aF[i].iFnctl ) break;
 561     }
 562     if( i<sizeof(aF)/sizeof(aF[0]) ){
 563       int rc = 0;
 564       tvfsExecTcl(p, "xFileControl",
 565           Tcl_NewStringObj(pFd->zFilename, -1),
 566           Tcl_NewStringObj(aF[i].zFnctl, -1),
 567           0, 0
 568       );
 569       tvfsResultCode(p, &rc);
 570       if( rc ) return (rc<0 ? SQLITE_OK : rc);
 571     }
 572   }
 573   return sqlite3OsFileControl(pFd->pReal, op, pArg);
 574 }
 575
 576 /*
 577 ** Return the sector-size in bytes for an tvfs-file.
 578 */
 579 static int tvfsSectorSize(sqlite3_file *pFile){
 580   TestvfsFd *pFd = tvfsGetFd(pFile);
 581   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 582   if( p->iSectorsize>=0 ){
 583     return p->iSectorsize;
 584   }
 585   return sqlite3OsSectorSize(pFd->pReal);
 586 }
 587
 588 /*
 589 ** Return the device characteristic flags supported by an tvfs-file.
 590 */
 591 static int tvfsDeviceCharacteristics(sqlite3_file *pFile){
 592   TestvfsFd *pFd = tvfsGetFd(pFile);
 593   Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
 594   if( p->iDevchar>=0 ){
 595     return p->iDevchar;
 596   }
 597   return sqlite3OsDeviceCharacteristics(pFd->pReal);
 598 }
 599
 600 /*
 601 ** Open an tvfs file handle.
 602 */
 603 static int tvfsOpen(
 604   sqlite3_vfs *pVfs,
 605   const char *zName,
 606   sqlite3_file *pFile,
 607   int flags,
 608   int *pOutFlags
 609 ){
 610   int rc;
 611   TestvfsFile *pTestfile = (TestvfsFile *)pFile;
 612   TestvfsFd *pFd;
 613   Tcl_Obj *pId = 0;
 614   Testvfs *p = (Testvfs *)pVfs->pAppData;
 615
 616   pFd = (TestvfsFd *)ckalloc(sizeof(TestvfsFd) + PARENTVFS(pVfs)->szOsFile);
 617   memset(pFd, 0, sizeof(TestvfsFd) + PARENTVFS(pVfs)->szOsFile);
 618   pFd->pShm = 0;
 619   pFd->pShmId = 0;
 620   pFd->zFilename = zName;
 621   pFd->pVfs = pVfs;
 622   pFd->pReal = (sqlite3_file *)&pFd[1];
 623   memset(pTestfile, 0, sizeof(TestvfsFile));
 624   pTestfile->pFd = pFd;
 625
 626   /* Evaluate the Tcl script:
 627   **
 628   **   SCRIPT xOpen FILENAME KEY-VALUE-ARGS
 629   **
 630   ** If the script returns an SQLite error code other than SQLITE_OK, an
 631   ** error is returned to the caller. If it returns SQLITE_OK, the new
 632   ** connection is named "anon". Otherwise, the value returned by the
 633   ** script is used as the connection name.
 634   */
 635   Tcl_ResetResult(p->interp);
 636   if( p->pScript && p->mask&TESTVFS_OPEN_MASK ){
 637     Tcl_Obj *pArg = Tcl_NewObj();
 638     Tcl_IncrRefCount(pArg);
 639     if( flags&SQLITE_OPEN_MAIN_DB ){
 640       const char *z = &zName[strlen(zName)+1];
 641       while( *z ){
 642         Tcl_ListObjAppendElement(0, pArg, Tcl_NewStringObj(z, -1));
 643         z += strlen(z) + 1;
 644         Tcl_ListObjAppendElement(0, pArg, Tcl_NewStringObj(z, -1));
 645         z += strlen(z) + 1;
 646       }
 647     }
 648     tvfsExecTcl(p, "xOpen", Tcl_NewStringObj(pFd->zFilename, -1), pArg, 0, 0);
 649     Tcl_DecrRefCount(pArg);
 650     if( tvfsResultCode(p, &rc) ){
 651       if( rc!=SQLITE_OK ) return rc;
 652     }else{
 653       pId = Tcl_GetObjResult(p->interp);
 654     }
 655   }
 656
 657   if( (p->mask&TESTVFS_OPEN_MASK) &&  tvfsInjectIoerr(p) ) return SQLITE_IOERR;
 658   if( tvfsInjectCantopenerr(p) ) return SQLITE_CANTOPEN;
 659   if( tvfsInjectFullerr(p) ) return SQLITE_FULL;
 660
 661   if( !pId ){
 662     pId = Tcl_NewStringObj("anon", -1);
 663   }
 664   Tcl_IncrRefCount(pId);
 665   pFd->pShmId = pId;
 666   Tcl_ResetResult(p->interp);
 667
 668   rc = sqlite3OsOpen(PARENTVFS(pVfs), zName, pFd->pReal, flags, pOutFlags);
 669   if( pFd->pReal->pMethods ){
 670     sqlite3_io_methods *pMethods;
 671     int nByte;
 672
 673     if( pVfs->iVersion>1 ){
 674       nByte = sizeof(sqlite3_io_methods);
 675     }else{
 676       nByte = offsetof(sqlite3_io_methods, xShmMap);
 677     }
 678
 679     pMethods = (sqlite3_io_methods *)ckalloc(nByte);
 680     memcpy(pMethods, &tvfs_io_methods, nByte);
 681     pMethods->iVersion = pFd->pReal->pMethods->iVersion;
 682     if( pMethods->iVersion>pVfs->iVersion ){
 683       pMethods->iVersion = pVfs->iVersion;
 684     }
 685     if( pVfs->iVersion>1 && ((Testvfs *)pVfs->pAppData)->isNoshm ){
 686       pMethods->xShmUnmap = 0;
 687       pMethods->xShmLock = 0;
 688       pMethods->xShmBarrier = 0;
 689       pMethods->xShmMap = 0;
 690     }
 691     pFile->pMethods = pMethods;
 692   }
 693
 694   return rc;
 695 }
 696
 697 /*
 698 ** Delete the file located at zPath. If the dirSync argument is true,
 699 ** ensure the file-system modifications are synced to disk before
 700 ** returning.
 701 */
 702 static int tvfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
 703   int rc = SQLITE_OK;
 704   Testvfs *p = (Testvfs *)pVfs->pAppData;
 705
 706   if( p->pScript && p->mask&TESTVFS_DELETE_MASK ){
 707     tvfsExecTcl(p, "xDelete",
 708         Tcl_NewStringObj(zPath, -1), Tcl_NewIntObj(dirSync), 0, 0
 709     );
 710     tvfsResultCode(p, &rc);
 711   }
 712   if( rc==SQLITE_OK ){
 713     rc = sqlite3OsDelete(PARENTVFS(pVfs), zPath, dirSync);
 714   }
 715   return rc;
 716 }
 717
 718 /*
 719 ** Test for access permissions. Return true if the requested permission
 720 ** is available, or false otherwise.
 721 */
 722 static int tvfsAccess(
 723   sqlite3_vfs *pVfs,
 724   const char *zPath,
 725   int flags,
 726   int *pResOut
 727 ){
 728   Testvfs *p = (Testvfs *)pVfs->pAppData;
 729   if( p->pScript && p->mask&TESTVFS_ACCESS_MASK ){
 730     int rc;
 731     char *zArg = 0;
 732     if( flags==SQLITE_ACCESS_EXISTS ) zArg = "SQLITE_ACCESS_EXISTS";
 733     if( flags==SQLITE_ACCESS_READWRITE ) zArg = "SQLITE_ACCESS_READWRITE";
 734     if( flags==SQLITE_ACCESS_READ ) zArg = "SQLITE_ACCESS_READ";
 735     tvfsExecTcl(p, "xAccess",
 736         Tcl_NewStringObj(zPath, -1), Tcl_NewStringObj(zArg, -1), 0, 0
 737     );
 738     if( tvfsResultCode(p, &rc) ){
 739       if( rc!=SQLITE_OK ) return rc;
 740     }else{
 741       Tcl_Interp *interp = p->interp;
 742       if( TCL_OK==Tcl_GetBooleanFromObj(0, Tcl_GetObjResult(interp), pResOut) ){
 743         return SQLITE_OK;
 744       }
 745     }
 746   }
 747   return sqlite3OsAccess(PARENTVFS(pVfs), zPath, flags, pResOut);
 748 }
 749
 750 /*
 751 ** Populate buffer zOut with the full canonical pathname corresponding
 752 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
 753 ** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
 754 */
 755 static int tvfsFullPathname(
 756   sqlite3_vfs *pVfs,
 757   const char *zPath,
 758   int nOut,
 759   char *zOut
 760 ){
 761   Testvfs *p = (Testvfs *)pVfs->pAppData;
 762   if( p->pScript && p->mask&TESTVFS_FULLPATHNAME_MASK ){
 763     int rc;
 764     tvfsExecTcl(p, "xFullPathname", Tcl_NewStringObj(zPath, -1), 0, 0, 0);
 765     if( tvfsResultCode(p, &rc) ){
 766       if( rc!=SQLITE_OK ) return rc;
 767     }
 768   }
 769   return sqlite3OsFullPathname(PARENTVFS(pVfs), zPath, nOut, zOut);
 770 }
 771
 772 #ifndef SQLITE_OMIT_LOAD_EXTENSION
 773 /*
 774 ** Open the dynamic library located at zPath and return a handle.
 775 */
 776 static void *tvfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
 777   return sqlite3OsDlOpen(PARENTVFS(pVfs), zPath);
 778 }
 779
 780 /*
 781 ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
 782 ** utf-8 string describing the most recent error encountered associated
 783 ** with dynamic libraries.
 784 */
 785 static void tvfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
 786   sqlite3OsDlError(PARENTVFS(pVfs), nByte, zErrMsg);
 787 }
 788
 789 /*
 790 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
 791 */
 792 static void (*tvfsDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
 793   return sqlite3OsDlSym(PARENTVFS(pVfs), p, zSym);
 794 }
 795
 796 /*
 797 ** Close the dynamic library handle pHandle.
 798 */
 799 static void tvfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
 800   sqlite3OsDlClose(PARENTVFS(pVfs), pHandle);
 801 }
 802 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
 803
 804 /*
 805 ** Populate the buffer pointed to by zBufOut with nByte bytes of
 806 ** random data.
 807 */
 808 static int tvfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
 809   return sqlite3OsRandomness(PARENTVFS(pVfs), nByte, zBufOut);
 810 }
 811
 812 /*
 813 ** Sleep for nMicro microseconds. Return the number of microseconds
 814 ** actually slept.
 815 */
 816 static int tvfsSleep(sqlite3_vfs *pVfs, int nMicro){
 817   return sqlite3OsSleep(PARENTVFS(pVfs), nMicro);
 818 }
 819
 820 /*
 821 ** Return the current time as a Julian Day number in *pTimeOut.
 822 */
 823 static int tvfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
 824   return PARENTVFS(pVfs)->xCurrentTime(PARENTVFS(pVfs), pTimeOut);
 825 }
 826
 827 static int tvfsShmOpen(sqlite3_file *pFile){
 828   Testvfs *p;
 829   int rc = SQLITE_OK;             /* Return code */
 830   TestvfsBuffer *pBuffer;         /* Buffer to open connection to */
 831   TestvfsFd *pFd;                 /* The testvfs file structure */
 832
 833   pFd = tvfsGetFd(pFile);
 834   p = (Testvfs *)pFd->pVfs->pAppData;
 835   assert( 0==p->isFullshm );
 836   assert( pFd->pShmId && pFd->pShm==0 && pFd->pNext==0 );
 837
 838   /* Evaluate the Tcl script:
 839   **
 840   **   SCRIPT xShmOpen FILENAME
 841   */
 842   Tcl_ResetResult(p->interp);
 843   if( p->pScript && p->mask&TESTVFS_SHMOPEN_MASK ){
 844     tvfsExecTcl(p, "xShmOpen", Tcl_NewStringObj(pFd->zFilename, -1), 0, 0, 0);
 845     if( tvfsResultCode(p, &rc) ){
 846       if( rc!=SQLITE_OK ) return rc;
 847     }
 848   }
 849
 850   assert( rc==SQLITE_OK );
 851   if( p->mask&TESTVFS_SHMOPEN_MASK && tvfsInjectIoerr(p) ){
 852     return SQLITE_IOERR;
 853   }
 854
 855   /* Search for a TestvfsBuffer. Create a new one if required. */
 856   for(pBuffer=p->pBuffer; pBuffer; pBuffer=pBuffer->pNext){
 857     if( 0==strcmp(pFd->zFilename, pBuffer->zFile) ) break;
 858   }
 859   if( !pBuffer ){
 860     int szName = (int)strlen(pFd->zFilename);
 861     int nByte = sizeof(TestvfsBuffer) + szName + 1;
 862     pBuffer = (TestvfsBuffer *)ckalloc(nByte);
 863     memset(pBuffer, 0, nByte);
 864     pBuffer->zFile = (char *)&pBuffer[1];
 865     memcpy(pBuffer->zFile, pFd->zFilename, szName+1);
 866     pBuffer->pNext = p->pBuffer;
 867     p->pBuffer = pBuffer;
 868   }
 869
 870   /* Connect the TestvfsBuffer to the new TestvfsShm handle and return. */
 871   pFd->pNext = pBuffer->pFile;
 872   pBuffer->pFile = pFd;
 873   pFd->pShm = pBuffer;
 874   return rc;
 875 }
 876
 877 static void tvfsAllocPage(TestvfsBuffer *p, int iPage, int pgsz){
 878   assert( iPage<TESTVFS_MAX_PAGES );
 879   if( p->aPage[iPage]==0 ){
 880     p->aPage[iPage] = (u8 *)ckalloc(pgsz);
 881     memset(p->aPage[iPage], 0, pgsz);
 882     p->pgsz = pgsz;
 883   }
 884 }
 885
 886 static int tvfsShmMap(
 887   sqlite3_file *pFile,            /* Handle open on database file */
 888   int iPage,                      /* Page to retrieve */
 889   int pgsz,                       /* Size of pages */
 890   int isWrite,                    /* True to extend file if necessary */
 891   void volatile **pp              /* OUT: Mapped memory */
 892 ){
 893   int rc = SQLITE_OK;
 894   TestvfsFd *pFd = tvfsGetFd(pFile);
 895   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
 896
 897   if( p->isFullshm ){
 898     return sqlite3OsShmMap(pFd->pReal, iPage, pgsz, isWrite, pp);
 899   }
 900
 901   if( 0==pFd->pShm ){
 902     rc = tvfsShmOpen(pFile);
 903     if( rc!=SQLITE_OK ){
 904       return rc;
 905     }
 906   }
 907
 908   if( p->pScript && p->mask&TESTVFS_SHMMAP_MASK ){
 909     Tcl_Obj *pArg = Tcl_NewObj();
 910     Tcl_IncrRefCount(pArg);
 911     Tcl_ListObjAppendElement(p->interp, pArg, Tcl_NewIntObj(iPage));
 912     Tcl_ListObjAppendElement(p->interp, pArg, Tcl_NewIntObj(pgsz));
 913     Tcl_ListObjAppendElement(p->interp, pArg, Tcl_NewIntObj(isWrite));
 914     tvfsExecTcl(p, "xShmMap",
 915         Tcl_NewStringObj(pFd->pShm->zFile, -1), pFd->pShmId, pArg, 0
 916     );
 917     tvfsResultCode(p, &rc);
 918     Tcl_DecrRefCount(pArg);
 919   }
 920   if( rc==SQLITE_OK && p->mask&TESTVFS_SHMMAP_MASK && tvfsInjectIoerr(p) ){
 921     rc = SQLITE_IOERR;
 922   }
 923
 924   if( rc==SQLITE_OK && isWrite && !pFd->pShm->aPage[iPage] ){
 925     tvfsAllocPage(pFd->pShm, iPage, pgsz);
 926   }
 927   if( rc==SQLITE_OK || rc==SQLITE_READONLY ){
 928     *pp = (void volatile *)pFd->pShm->aPage[iPage];
 929   }
 930
 931   return rc;
 932 }
 933
 934
 935 static int tvfsShmLock(
 936   sqlite3_file *pFile,
 937   int ofst,
 938   int n,
 939   int flags
 940 ){
 941   int rc = SQLITE_OK;
 942   TestvfsFd *pFd = tvfsGetFd(pFile);
 943   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
 944   int nLock;
 945   char zLock[80];
 946
 947   if( p->isFullshm ){
 948     return sqlite3OsShmLock(pFd->pReal, ofst, n, flags);
 949   }
 950
 951   if( p->pScript && p->mask&TESTVFS_SHMLOCK_MASK ){
 952     sqlite3_snprintf(sizeof(zLock), zLock, "%d %d", ofst, n);
 953     nLock = (int)strlen(zLock);
 954     if( flags & SQLITE_SHM_LOCK ){
 955       strcpy(&zLock[nLock], " lock");
 956     }else{
 957       strcpy(&zLock[nLock], " unlock");
 958     }
 959     nLock += (int)strlen(&zLock[nLock]);
 960     if( flags & SQLITE_SHM_SHARED ){
 961       strcpy(&zLock[nLock], " shared");
 962     }else{
 963       strcpy(&zLock[nLock], " exclusive");
 964     }
 965     tvfsExecTcl(p, "xShmLock",
 966         Tcl_NewStringObj(pFd->pShm->zFile, -1), pFd->pShmId,
 967         Tcl_NewStringObj(zLock, -1), 0
 968     );
 969     tvfsResultCode(p, &rc);
 970   }
 971
 972   if( rc==SQLITE_OK && p->mask&TESTVFS_SHMLOCK_MASK && tvfsInjectIoerr(p) ){
 973     rc = SQLITE_IOERR;
 974   }
 975
 976   if( rc==SQLITE_OK ){
 977     int isLock = (flags & SQLITE_SHM_LOCK);
 978     int isExcl = (flags & SQLITE_SHM_EXCLUSIVE);
 979     u32 mask = (((1<<n)-1) << ofst);
 980     if( isLock ){
 981       TestvfsFd *p2;
 982       for(p2=pFd->pShm->pFile; p2; p2=p2->pNext){
 983         if( p2==pFd ) continue;
 984         if( (p2->excllock&mask) || (isExcl && p2->sharedlock&mask) ){
 985           rc = SQLITE_BUSY;
 986           break;
 987         }
 988       }
 989       if( rc==SQLITE_OK ){
 990         if( isExcl )  pFd->excllock |= mask;
 991         if( !isExcl ) pFd->sharedlock |= mask;
 992       }
 993     }else{
 994       if( isExcl )  pFd->excllock &= (~mask);
 995       if( !isExcl ) pFd->sharedlock &= (~mask);
 996     }
 997   }
 998
 999   return rc;
1000 }
1001
1002 static void tvfsShmBarrier(sqlite3_file *pFile){
1003   TestvfsFd *pFd = tvfsGetFd(pFile);
1004   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
1005
1006   if( p->pScript && p->mask&TESTVFS_SHMBARRIER_MASK ){
1007     const char *z = pFd->pShm ? pFd->pShm->zFile : "";
1008     tvfsExecTcl(p, "xShmBarrier", Tcl_NewStringObj(z, -1), pFd->pShmId, 0, 0);
1009   }
1010
1011   if( p->isFullshm ){
1012     sqlite3OsShmBarrier(pFd->pReal);
1013     return;
1014   }
1015 }
1016
1017 static int tvfsShmUnmap(
1018   sqlite3_file *pFile,
1019   int deleteFlag
1020 ){
1021   int rc = SQLITE_OK;
1022   TestvfsFd *pFd = tvfsGetFd(pFile);
1023   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
1024   TestvfsBuffer *pBuffer = pFd->pShm;
1025   TestvfsFd **ppFd;
1026
1027   if( p->isFullshm ){
1028     return sqlite3OsShmUnmap(pFd->pReal, deleteFlag);
1029   }
1030
1031   if( !pBuffer ) return SQLITE_OK;
1032   assert( pFd->pShmId && pFd->pShm );
1033
1034   if( p->pScript && p->mask&TESTVFS_SHMCLOSE_MASK ){
1035     tvfsExecTcl(p, "xShmUnmap",
1036         Tcl_NewStringObj(pFd->pShm->zFile, -1), pFd->pShmId, 0, 0
1037     );
1038     tvfsResultCode(p, &rc);
1039   }
1040
1041   for(ppFd=&pBuffer->pFile; *ppFd!=pFd; ppFd=&((*ppFd)->pNext));
1042   assert( (*ppFd)==pFd );
1043   *ppFd = pFd->pNext;
1044   pFd->pNext = 0;
1045
1046   if( pBuffer->pFile==0 ){
1047     int i;
1048     TestvfsBuffer **pp;
1049     for(pp=&p->pBuffer; *pp!=pBuffer; pp=&((*pp)->pNext));
1050     *pp = (*pp)->pNext;
1051     for(i=0; pBuffer->aPage[i]; i++){
1052       ckfree((char *)pBuffer->aPage[i]);
1053     }
1054     ckfree((char *)pBuffer);
1055   }
1056   pFd->pShm = 0;
1057
1058   return rc;
1059 }
1060
1061 static int tvfsFetch(
1062     sqlite3_file *pFile,
1063     sqlite3_int64 iOfst,
1064     int iAmt,
1065     void **pp
1066 ){
1067   TestvfsFd *pFd = tvfsGetFd(pFile);
1068   return sqlite3OsFetch(pFd->pReal, iOfst, iAmt, pp);
1069 }
1070
1071 static int tvfsUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *p){
1072   TestvfsFd *pFd = tvfsGetFd(pFile);
1073   return sqlite3OsUnfetch(pFd->pReal, iOfst, p);
1074 }
1075
1076 static int SQLITE_TCLAPI testvfs_obj_cmd(
1077   ClientData cd,
1078   Tcl_Interp *interp,
1079   int objc,
1080   Tcl_Obj *CONST objv[]
1081 ){
1082   Testvfs *p = (Testvfs *)cd;
1083
1084   enum DB_enum {
1085     CMD_SHM, CMD_DELETE, CMD_FILTER, CMD_IOERR, CMD_SCRIPT,
1086     CMD_DEVCHAR, CMD_SECTORSIZE, CMD_FULLERR, CMD_CANTOPENERR
1087   };
1088   struct TestvfsSubcmd {
1089     char *zName;
1090     enum DB_enum eCmd;
1091   } aSubcmd[] = {
1092     { "shm",         CMD_SHM         },
1093     { "delete",      CMD_DELETE      },
1094     { "filter",      CMD_FILTER      },
1095     { "ioerr",       CMD_IOERR       },
1096     { "fullerr",     CMD_FULLERR     },
1097     { "cantopenerr", CMD_CANTOPENERR },
1098     { "script",      CMD_SCRIPT      },
1099     { "devchar",     CMD_DEVCHAR     },
1100     { "sectorsize",  CMD_SECTORSIZE  },
1101     { 0, 0 }
1102   };
1103   int i;
1104
1105   if( objc<2 ){
1106     Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
1107     return TCL_ERROR;
1108   }
1109   if( Tcl_GetIndexFromObjStruct(
1110         interp, objv[1], aSubcmd, sizeof(aSubcmd[0]), "subcommand", 0, &i)
1111   ){
1112     return TCL_ERROR;
1113   }
1114   Tcl_ResetResult(interp);
1115
1116   switch( aSubcmd[i].eCmd ){
1117     case CMD_SHM: {
1118       Tcl_Obj *pObj;
1119       int rc;
1120       TestvfsBuffer *pBuffer;
1121       char *zName;
1122       if( objc!=3 && objc!=4 ){
1123         Tcl_WrongNumArgs(interp, 2, objv, "FILE ?VALUE?");
1124         return TCL_ERROR;
1125       }
1126       zName = ckalloc(p->pParent->mxPathname);
1127       rc = p->pParent->xFullPathname(
1128           p->pParent, Tcl_GetString(objv[2]),
1129           p->pParent->mxPathname, zName
1130       );
1131       if( rc!=SQLITE_OK ){
1132         Tcl_AppendResult(interp, "failed to get full path: ",
1133                          Tcl_GetString(objv[2]), 0);
1134         ckfree(zName);
1135         return TCL_ERROR;
1136       }
1137       for(pBuffer=p->pBuffer; pBuffer; pBuffer=pBuffer->pNext){
1138         if( 0==strcmp(pBuffer->zFile, zName) ) break;
1139       }
1140       ckfree(zName);
1141       if( !pBuffer ){
1142         Tcl_AppendResult(interp, "no such file: ", Tcl_GetString(objv[2]), 0);
1143         return TCL_ERROR;
1144       }
1145       if( objc==4 ){
1146         int n;
1147         u8 *a = Tcl_GetByteArrayFromObj(objv[3], &n);
1148         int pgsz = pBuffer->pgsz;
1149         if( pgsz==0 ) pgsz = 65536;
1150         for(i=0; i*pgsz<n; i++){
1151           int nByte = pgsz;
1152           tvfsAllocPage(pBuffer, i, pgsz);
1153           if( n-i*pgsz<pgsz ){
1154             nByte = n;
1155           }
1156           memcpy(pBuffer->aPage[i], &a[i*pgsz], nByte);
1157         }
1158       }
1159
1160       pObj = Tcl_NewObj();
1161       for(i=0; pBuffer->aPage[i]; i++){
1162         int pgsz = pBuffer->pgsz;
1163         if( pgsz==0 ) pgsz = 65536;
1164         Tcl_AppendObjToObj(pObj, Tcl_NewByteArrayObj(pBuffer->aPage[i], pgsz));
1165       }
1166       Tcl_SetObjResult(interp, pObj);
1167       break;
1168     }
1169
1170     /*  TESTVFS filter METHOD-LIST
1171     **
1172     **     Activate special processing for those methods contained in the list
1173     */
1174     case CMD_FILTER: {
1175       static struct VfsMethod {
1176         char *zName;
1177         int mask;
1178       } vfsmethod [] = {
1179         { "xShmOpen",           TESTVFS_SHMOPEN_MASK },
1180         { "xShmLock",           TESTVFS_SHMLOCK_MASK },
1181         { "xShmBarrier",        TESTVFS_SHMBARRIER_MASK },
1182         { "xShmUnmap",          TESTVFS_SHMCLOSE_MASK },
1183         { "xShmMap",            TESTVFS_SHMMAP_MASK },
1184         { "xSync",              TESTVFS_SYNC_MASK },
1185         { "xDelete",            TESTVFS_DELETE_MASK },
1186         { "xWrite",             TESTVFS_WRITE_MASK },
1187         { "xRead",              TESTVFS_READ_MASK },
1188         { "xTruncate",          TESTVFS_TRUNCATE_MASK },
1189         { "xOpen",              TESTVFS_OPEN_MASK },
1190         { "xClose",             TESTVFS_CLOSE_MASK },
1191         { "xAccess",            TESTVFS_ACCESS_MASK },
1192         { "xFullPathname",      TESTVFS_FULLPATHNAME_MASK },
1193         { "xUnlock",            TESTVFS_UNLOCK_MASK },
1194         { "xLock",              TESTVFS_LOCK_MASK },
1195         { "xCheckReservedLock", TESTVFS_CKLOCK_MASK },
1196         { "xFileControl",       TESTVFS_FCNTL_MASK },
1197       };
1198       Tcl_Obj **apElem = 0;
1199       int nElem = 0;
1200       int mask = 0;
1201       if( objc!=3 ){
1202         Tcl_WrongNumArgs(interp, 2, objv, "LIST");
1203         return TCL_ERROR;
1204       }
1205       if( Tcl_ListObjGetElements(interp, objv[2], &nElem, &apElem) ){
1206         return TCL_ERROR;
1207       }
1208       Tcl_ResetResult(interp);
1209       for(i=0; i<nElem; i++){
1210         int iMethod;
1211         char *zElem = Tcl_GetString(apElem[i]);
1212         for(iMethod=0; iMethod<ArraySize(vfsmethod); iMethod++){
1213           if( strcmp(zElem, vfsmethod[iMethod].zName)==0 ){
1214             mask |= vfsmethod[iMethod].mask;
1215             break;
1216           }
1217         }
1218         if( iMethod==ArraySize(vfsmethod) ){
1219           Tcl_AppendResult(interp, "unknown method: ", zElem, 0);
1220           return TCL_ERROR;
1221         }
1222       }
1223       p->mask = mask;
1224       break;
1225     }
1226
1227     /*
1228     **  TESTVFS script ?SCRIPT?
1229     **
1230     **  Query or set the script to be run when filtered VFS events
1231     **  occur.
1232     */
1233     case CMD_SCRIPT: {
1234       if( objc==3 ){
1235         int nByte;
1236         if( p->pScript ){
1237           Tcl_DecrRefCount(p->pScript);
1238           p->pScript = 0;
1239         }
1240         Tcl_GetStringFromObj(objv[2], &nByte);
1241         if( nByte>0 ){
1242           p->pScript = Tcl_DuplicateObj(objv[2]);
1243           Tcl_IncrRefCount(p->pScript);
1244         }
1245       }else if( objc!=2 ){
1246         Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
1247         return TCL_ERROR;
1248       }
1249
1250       Tcl_ResetResult(interp);
1251       if( p->pScript ) Tcl_SetObjResult(interp, p->pScript);
1252
1253       break;
1254     }
1255
1256     /*
1257     ** TESTVFS ioerr ?IFAIL PERSIST?
1258     **
1259     **   Where IFAIL is an integer and PERSIST is boolean.
1260     */
1261     case CMD_CANTOPENERR:
1262     case CMD_IOERR:
1263     case CMD_FULLERR: {
1264       TestFaultInject *pTest = 0;
1265       int iRet;
1266
1267       switch( aSubcmd[i].eCmd ){
1268         case CMD_IOERR: pTest = &p->ioerr_err; break;
1269         case CMD_FULLERR: pTest = &p->full_err; break;
1270         case CMD_CANTOPENERR: pTest = &p->cantopen_err; break;
1271         default: assert(0);
1272       }
1273       iRet = pTest->nFail;
1274       pTest->nFail = 0;
1275       pTest->eFault = 0;
1276       pTest->iCnt = 0;
1277
1278       if( objc==4 ){
1279         int iCnt, iPersist;
1280         if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iCnt)
1281          || TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &iPersist)
1282         ){
1283           return TCL_ERROR;
1284         }
1285         pTest->eFault = iPersist?FAULT_INJECT_PERSISTENT:FAULT_INJECT_TRANSIENT;
1286         pTest->iCnt = iCnt;
1287       }else if( objc!=2 ){
1288         Tcl_WrongNumArgs(interp, 2, objv, "?CNT PERSIST?");
1289         return TCL_ERROR;
1290       }
1291       Tcl_SetObjResult(interp, Tcl_NewIntObj(iRet));
1292       break;
1293     }
1294
1295     case CMD_DELETE: {
1296       Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
1297       break;
1298     }
1299
1300     case CMD_DEVCHAR: {
1301       struct DeviceFlag {
1302         char *zName;
1303         int iValue;
1304       } aFlag[] = {
1305         { "default",               -1 },
1306         { "atomic",                SQLITE_IOCAP_ATOMIC                },
1307         { "atomic512",             SQLITE_IOCAP_ATOMIC512             },
1308         { "atomic1k",              SQLITE_IOCAP_ATOMIC1K              },
1309         { "atomic2k",              SQLITE_IOCAP_ATOMIC2K              },
1310         { "atomic4k",              SQLITE_IOCAP_ATOMIC4K              },
1311         { "atomic8k",              SQLITE_IOCAP_ATOMIC8K              },
1312         { "atomic16k",             SQLITE_IOCAP_ATOMIC16K             },
1313         { "atomic32k",             SQLITE_IOCAP_ATOMIC32K             },
1314         { "atomic64k",             SQLITE_IOCAP_ATOMIC64K             },
1315         { "sequential",            SQLITE_IOCAP_SEQUENTIAL            },
1316         { "safe_append",           SQLITE_IOCAP_SAFE_APPEND           },
1317         { "undeletable_when_open", SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN },
1318         { "powersafe_overwrite",   SQLITE_IOCAP_POWERSAFE_OVERWRITE   },
1319         { "immutable",             SQLITE_IOCAP_IMMUTABLE             },
1320         { 0, 0 }
1321       };
1322       Tcl_Obj *pRet;
1323       int iFlag;
1324
1325       if( objc>3 ){
1326         Tcl_WrongNumArgs(interp, 2, objv, "?ATTR-LIST?");
1327         return TCL_ERROR;
1328       }
1329       if( objc==3 ){
1330         int j;
1331         int iNew = 0;
1332         Tcl_Obj **flags = 0;
1333         int nFlags = 0;
1334
1335         if( Tcl_ListObjGetElements(interp, objv[2], &nFlags, &flags) ){
1336           return TCL_ERROR;
1337         }
1338
1339         for(j=0; j<nFlags; j++){
1340           int idx = 0;
1341           if( Tcl_GetIndexFromObjStruct(interp, flags[j], aFlag,
1342                 sizeof(aFlag[0]), "flag", 0, &idx)
1343           ){
1344             return TCL_ERROR;
1345           }
1346           if( aFlag[idx].iValue<0 && nFlags>1 ){
1347             Tcl_AppendResult(interp, "bad flags: ", Tcl_GetString(objv[2]), 0);
1348             return TCL_ERROR;
1349           }
1350           iNew |= aFlag[idx].iValue;
1351         }
1352
1353         p->iDevchar = iNew| 0x10000000;
1354       }
1355
1356       pRet = Tcl_NewObj();
1357       for(iFlag=0; iFlag<sizeof(aFlag)/sizeof(aFlag[0]); iFlag++){
1358         if( p->iDevchar & aFlag[iFlag].iValue ){
1359           Tcl_ListObjAppendElement(
1360               interp, pRet, Tcl_NewStringObj(aFlag[iFlag].zName, -1)
1361           );
1362         }
1363       }
1364       Tcl_SetObjResult(interp, pRet);
1365
1366       break;
1367     }
1368
1369     case CMD_SECTORSIZE: {
1370       if( objc>3 ){
1371         Tcl_WrongNumArgs(interp, 2, objv, "?VALUE?");
1372         return TCL_ERROR;
1373       }
1374       if( objc==3 ){
1375         int iNew = 0;
1376         if( Tcl_GetIntFromObj(interp, objv[2], &iNew) ){
1377           return TCL_ERROR;
1378         }
1379         p->iSectorsize = iNew;
1380       }
1381       Tcl_SetObjResult(interp, Tcl_NewIntObj(p->iSectorsize));
1382       break;
1383     }
1384   }
1385
1386   return TCL_OK;
1387 }
1388
1389 static void SQLITE_TCLAPI testvfs_obj_del(ClientData cd){
1390   Testvfs *p = (Testvfs *)cd;
1391   if( p->pScript ) Tcl_DecrRefCount(p->pScript);
1392   sqlite3_vfs_unregister(p->pVfs);
1393   memset(p->pVfs, 0, sizeof(sqlite3_vfs));
1394   ckfree((char *)p->pVfs);
1395   memset(p, 0, sizeof(Testvfs));
1396   ckfree((char *)p);
1397 }
1398
1399 /*
1400 ** Usage:  testvfs VFSNAME ?SWITCHES?
1401 **
1402 ** Switches are:
1403 **
1404 **   -noshm   BOOLEAN             (True to omit shm methods. Default false)
1405 **   -default BOOLEAN             (True to make the vfs default. Default false)
1406 **
1407 ** This command creates two things when it is invoked: an SQLite VFS, and
1408 ** a Tcl command. Both are named VFSNAME. The VFS is installed. It is not
1409 ** installed as the default VFS.
1410 **
1411 ** The VFS passes all file I/O calls through to the underlying VFS.
1412 **
1413 ** Whenever the xShmMap method of the VFS
1414 ** is invoked, the SCRIPT is executed as follows:
1415 **
1416 **   SCRIPT xShmMap    FILENAME ID
1417 **
1418 ** The value returned by the invocation of SCRIPT above is interpreted as
1419 ** an SQLite error code and returned to SQLite. Either a symbolic
1420 ** "SQLITE_OK" or numeric "0" value may be returned.
1421 **
1422 ** The contents of the shared-memory buffer associated with a given file
1423 ** may be read and set using the following command:
1424 **
1425 **   VFSNAME shm FILENAME ?NEWVALUE?
1426 **
1427 ** When the xShmLock method is invoked by SQLite, the following script is
1428 ** run:
1429 **
1430 **   SCRIPT xShmLock    FILENAME ID LOCK
1431 **
1432 ** where LOCK is of the form "OFFSET NBYTE lock/unlock shared/exclusive"
1433 */
1434 static int SQLITE_TCLAPI testvfs_cmd(
1435   ClientData cd,
1436   Tcl_Interp *interp,
1437   int objc,
1438   Tcl_Obj *CONST objv[]
1439 ){
1440   static sqlite3_vfs tvfs_vfs = {
1441     3,                            /* iVersion */
1442     0,                            /* szOsFile */
1443     0,                            /* mxPathname */
1444     0,                            /* pNext */
1445     0,                            /* zName */
1446     0,                            /* pAppData */
1447     tvfsOpen,                     /* xOpen */
1448     tvfsDelete,                   /* xDelete */
1449     tvfsAccess,                   /* xAccess */
1450     tvfsFullPathname,             /* xFullPathname */
1451 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1452     tvfsDlOpen,                   /* xDlOpen */
1453     tvfsDlError,                  /* xDlError */
1454     tvfsDlSym,                    /* xDlSym */
1455     tvfsDlClose,                  /* xDlClose */
1456 #else
1457     0,                            /* xDlOpen */
1458     0,                            /* xDlError */
1459     0,                            /* xDlSym */
1460     0,                            /* xDlClose */
1461 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
1462     tvfsRandomness,               /* xRandomness */
1463     tvfsSleep,                    /* xSleep */
1464     tvfsCurrentTime,              /* xCurrentTime */
1465     0,                            /* xGetLastError */
1466     0,                            /* xCurrentTimeInt64 */
1467     0,                            /* xSetSystemCall */
1468     0,                            /* xGetSystemCall */
1469     0,                            /* xNextSystemCall */
1470   };
1471
1472   Testvfs *p;                     /* New object */
1473   sqlite3_vfs *pVfs;              /* New VFS */
1474   char *zVfs;
1475   int nByte;                      /* Bytes of space to allocate at p */
1476
1477   int i;
1478   int isNoshm = 0;                /* True if -noshm is passed */
1479   int isFullshm = 0;              /* True if -fullshm is passed */
1480   int isDefault = 0;              /* True if -default is passed */
1481   int szOsFile = 0;               /* Value passed to -szosfile */
1482   int mxPathname = -1;            /* Value passed to -mxpathname */
1483   int iVersion = 3;               /* Value passed to -iversion */
1484
1485   if( objc<2 || 0!=(objc%2) ) goto bad_args;
1486   for(i=2; i<objc; i += 2){
1487     int nSwitch;
1488     char *zSwitch;
1489     zSwitch = Tcl_GetStringFromObj(objv[i], &nSwitch);
1490
1491     if( nSwitch>2 && 0==strncmp("-noshm", zSwitch, nSwitch) ){
1492       if( Tcl_GetBooleanFromObj(interp, objv[i+1], &isNoshm) ){
1493         return TCL_ERROR;
1494       }
1495       if( isNoshm ) isFullshm = 0;
1496     }
1497     else if( nSwitch>2 && 0==strncmp("-default", zSwitch, nSwitch) ){
1498       if( Tcl_GetBooleanFromObj(interp, objv[i+1], &isDefault) ){
1499         return TCL_ERROR;
1500       }
1501     }
1502     else if( nSwitch>2 && 0==strncmp("-szosfile", zSwitch, nSwitch) ){
1503       if( Tcl_GetIntFromObj(interp, objv[i+1], &szOsFile) ){
1504         return TCL_ERROR;
1505       }
1506     }
1507     else if( nSwitch>2 && 0==strncmp("-mxpathname", zSwitch, nSwitch) ){
1508       if( Tcl_GetIntFromObj(interp, objv[i+1], &mxPathname) ){
1509         return TCL_ERROR;
1510       }
1511     }
1512     else if( nSwitch>2 && 0==strncmp("-iversion", zSwitch, nSwitch) ){
1513       if( Tcl_GetIntFromObj(interp, objv[i+1], &iVersion) ){
1514         return TCL_ERROR;
1515       }
1516     }
1517     else if( nSwitch>2 && 0==strncmp("-fullshm", zSwitch, nSwitch) ){
1518       if( Tcl_GetBooleanFromObj(interp, objv[i+1], &isFullshm) ){
1519         return TCL_ERROR;
1520       }
1521       if( isFullshm ) isNoshm = 0;
1522     }
1523     else{
1524       goto bad_args;
1525     }
1526   }
1527
1528   if( szOsFile<sizeof(TestvfsFile) ){
1529     szOsFile = sizeof(TestvfsFile);
1530   }
1531
1532   zVfs = Tcl_GetString(objv[1]);
1533   nByte = sizeof(Testvfs) + (int)strlen(zVfs)+1;
1534   p = (Testvfs *)ckalloc(nByte);
1535   memset(p, 0, nByte);
1536   p->iDevchar = -1;
1537   p->iSectorsize = -1;
1538
1539   /* Create the new object command before querying SQLite for a default VFS
1540   ** to use for 'real' IO operations. This is because creating the new VFS
1541   ** may delete an existing [testvfs] VFS of the same name. If such a VFS
1542   ** is currently the default, the new [testvfs] may end up calling the
1543   ** methods of a deleted object.
1544   */
1545   Tcl_CreateObjCommand(interp, zVfs, testvfs_obj_cmd, p, testvfs_obj_del);
1546   p->pParent = sqlite3_vfs_find(0);
1547   p->interp = interp;
1548
1549   p->zName = (char *)&p[1];
1550   memcpy(p->zName, zVfs, strlen(zVfs)+1);
1551
1552   pVfs = (sqlite3_vfs *)ckalloc(sizeof(sqlite3_vfs));
1553   memcpy(pVfs, &tvfs_vfs, sizeof(sqlite3_vfs));
1554   pVfs->pAppData = (void *)p;
1555   pVfs->iVersion = iVersion;
1556   pVfs->zName = p->zName;
1557   pVfs->mxPathname = p->pParent->mxPathname;
1558   if( mxPathname>=0 && mxPathname<pVfs->mxPathname ){
1559     pVfs->mxPathname = mxPathname;
1560   }
1561   pVfs->szOsFile = szOsFile;
1562   p->pVfs = pVfs;
1563   p->isNoshm = isNoshm;
1564   p->isFullshm = isFullshm;
1565   p->mask = TESTVFS_ALL_MASK;
1566
1567   sqlite3_vfs_register(pVfs, isDefault);
1568
1569   return TCL_OK;
1570
1571  bad_args:
1572   Tcl_WrongNumArgs(interp, 1, objv, "VFSNAME ?-noshm BOOL? ?-fullshm BOOL? ?-default BOOL? ?-mxpathname INT? ?-szosfile INT? ?-iversion INT?");
1573   return TCL_ERROR;
1574 }
1575
1576 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
1577 extern const char *sqlite3ErrName(int);
1578
1579 /*
1580 ** tclcmd: vfs_shmlock DB DBNAME (shared|exclusive) (lock|unlock) OFFSET N
1581 */
1582 static int SQLITE_TCLAPI test_vfs_shmlock(
1583   void * clientData,
1584   Tcl_Interp *interp,
1585   int objc,
1586   Tcl_Obj *CONST objv[]
1587 ){
1588   const char *azArg1[] = {"shared", "exclusive", 0};
1589   const char *azArg2[] = {"lock", "unlock", 0};
1590   sqlite3 *db = 0;
1591   int rc = SQLITE_OK;
1592   const char *zDbname = 0;
1593   int iArg1 = 0;
1594   int iArg2 = 0;
1595   int iOffset = 0;
1596   int n = 0;
1597   sqlite3_file *pFd;
1598
1599   if( objc!=7 ){
1600     Tcl_WrongNumArgs(interp, 1, objv,
1601         "DB DBNAME (shared|exclusive) (lock|unlock) OFFSET N"
1602     );
1603     return TCL_ERROR;
1604   }
1605
1606   zDbname = Tcl_GetString(objv[2]);
1607   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
1608    || Tcl_GetIndexFromObj(interp, objv[3], azArg1, "ARG", 0, &iArg1)
1609    || Tcl_GetIndexFromObj(interp, objv[4], azArg2, "ARG", 0, &iArg2)
1610    || Tcl_GetIntFromObj(interp, objv[5], &iOffset)
1611    || Tcl_GetIntFromObj(interp, objv[6], &n)
1612   ){
1613     return TCL_ERROR;
1614   }
1615
1616   sqlite3_file_control(db, zDbname, SQLITE_FCNTL_FILE_POINTER, (void*)&pFd);
1617   if( pFd==0 ){
1618     return TCL_ERROR;
1619   }
1620   rc = pFd->pMethods->xShmLock(pFd, iOffset, n,
1621       (iArg1==0 ? SQLITE_SHM_SHARED : SQLITE_SHM_EXCLUSIVE)
1622     | (iArg2==0 ? SQLITE_SHM_LOCK : SQLITE_SHM_UNLOCK)
1623   );
1624   Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
1625   return TCL_OK;
1626 }
1627
1628 static int SQLITE_TCLAPI test_vfs_set_readmark(
1629   void * clientData,
1630   Tcl_Interp *interp,
1631   int objc,
1632   Tcl_Obj *CONST objv[]
1633 ){
1634   sqlite3 *db = 0;
1635   int rc = SQLITE_OK;
1636   const char *zDbname = 0;
1637   int iSlot = 0;
1638   int iVal = -1;
1639   sqlite3_file *pFd;
1640   void volatile *pShm = 0;
1641   u32 *aShm;
1642   int iOff;
1643
1644   if( objc!=4 && objc!=5 ){
1645     Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SLOT ?VALUE?");
1646     return TCL_ERROR;
1647   }
1648
1649   zDbname = Tcl_GetString(objv[2]);
1650   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
1651    || Tcl_GetIntFromObj(interp, objv[3], &iSlot)
1652    || (objc==5 && Tcl_GetIntFromObj(interp, objv[4], &iVal))
1653   ){
1654     return TCL_ERROR;
1655   }
1656
1657   sqlite3_file_control(db, zDbname, SQLITE_FCNTL_FILE_POINTER, (void*)&pFd);
1658   if( pFd==0 ){
1659     return TCL_ERROR;
1660   }
1661   rc = pFd->pMethods->xShmMap(pFd, 0, 32*1024, 0, &pShm);
1662   if( rc!=SQLITE_OK ){
1663     Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
1664     return TCL_ERROR;
1665   }
1666   if( pShm==0 ){
1667     Tcl_AppendResult(interp, "*-shm is not yet mapped", 0);
1668     return TCL_ERROR;
1669   }
1670   aShm = (u32*)pShm;
1671   iOff = 12*2+1+iSlot;
1672
1673   if( objc==5 ){
1674     aShm[iOff] = iVal;
1675   }
1676   Tcl_SetObjResult(interp, Tcl_NewIntObj(aShm[iOff]));
1677
1678   return TCL_OK;
1679 }
1680
1681 int Sqlitetestvfs_Init(Tcl_Interp *interp){
1682   Tcl_CreateObjCommand(interp, "testvfs", testvfs_cmd, 0, 0);
1683   Tcl_CreateObjCommand(interp, "vfs_shmlock", test_vfs_shmlock, 0, 0);
1684   Tcl_CreateObjCommand(interp, "vfs_set_readmark", test_vfs_set_readmark, 0, 0);
1685   return TCL_OK;
1686 }
1687
1688 #endif