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     sqlite3_file *pReal = pFd->pReal;
 899     return pReal->pMethods->xShmMap(pReal, iPage, pgsz, isWrite, pp);
 900   }
 901
 902   if( 0==pFd->pShm ){
 903     rc = tvfsShmOpen(pFile);
 904     if( rc!=SQLITE_OK ){
 905       return rc;
 906     }
 907   }
 908
 909   if( p->pScript && p->mask&TESTVFS_SHMMAP_MASK ){
 910     Tcl_Obj *pArg = Tcl_NewObj();
 911     Tcl_IncrRefCount(pArg);
 912     Tcl_ListObjAppendElement(p->interp, pArg, Tcl_NewIntObj(iPage));
 913     Tcl_ListObjAppendElement(p->interp, pArg, Tcl_NewIntObj(pgsz));
 914     Tcl_ListObjAppendElement(p->interp, pArg, Tcl_NewIntObj(isWrite));
 915     tvfsExecTcl(p, "xShmMap",
 916         Tcl_NewStringObj(pFd->pShm->zFile, -1), pFd->pShmId, pArg, 0
 917     );
 918     tvfsResultCode(p, &rc);
 919     Tcl_DecrRefCount(pArg);
 920   }
 921   if( rc==SQLITE_OK && p->mask&TESTVFS_SHMMAP_MASK && tvfsInjectIoerr(p) ){
 922     rc = SQLITE_IOERR;
 923   }
 924
 925   if( rc==SQLITE_OK && isWrite && !pFd->pShm->aPage[iPage] ){
 926     tvfsAllocPage(pFd->pShm, iPage, pgsz);
 927   }
 928   if( rc==SQLITE_OK || rc==SQLITE_READONLY ){
 929     *pp = (void volatile *)pFd->pShm->aPage[iPage];
 930   }
 931
 932   return rc;
 933 }
 934
 935
 936 static int tvfsShmLock(
 937   sqlite3_file *pFile,
 938   int ofst,
 939   int n,
 940   int flags
 941 ){
 942   int rc = SQLITE_OK;
 943   TestvfsFd *pFd = tvfsGetFd(pFile);
 944   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
 945   int nLock;
 946   char zLock[80];
 947
 948   if( p->isFullshm ){
 949     sqlite3_file *pReal = pFd->pReal;
 950     return pReal->pMethods->xShmLock(pReal, ofst, n, flags);
 951   }
 952
 953   if( p->pScript && p->mask&TESTVFS_SHMLOCK_MASK ){
 954     sqlite3_snprintf(sizeof(zLock), zLock, "%d %d", ofst, n);
 955     nLock = (int)strlen(zLock);
 956     if( flags & SQLITE_SHM_LOCK ){
 957       strcpy(&zLock[nLock], " lock");
 958     }else{
 959       strcpy(&zLock[nLock], " unlock");
 960     }
 961     nLock += (int)strlen(&zLock[nLock]);
 962     if( flags & SQLITE_SHM_SHARED ){
 963       strcpy(&zLock[nLock], " shared");
 964     }else{
 965       strcpy(&zLock[nLock], " exclusive");
 966     }
 967     tvfsExecTcl(p, "xShmLock",
 968         Tcl_NewStringObj(pFd->pShm->zFile, -1), pFd->pShmId,
 969         Tcl_NewStringObj(zLock, -1), 0
 970     );
 971     tvfsResultCode(p, &rc);
 972   }
 973
 974   if( rc==SQLITE_OK && p->mask&TESTVFS_SHMLOCK_MASK && tvfsInjectIoerr(p) ){
 975     rc = SQLITE_IOERR;
 976   }
 977
 978   if( rc==SQLITE_OK ){
 979     int isLock = (flags & SQLITE_SHM_LOCK);
 980     int isExcl = (flags & SQLITE_SHM_EXCLUSIVE);
 981     u32 mask = (((1<<n)-1) << ofst);
 982     if( isLock ){
 983       TestvfsFd *p2;
 984       for(p2=pFd->pShm->pFile; p2; p2=p2->pNext){
 985         if( p2==pFd ) continue;
 986         if( (p2->excllock&mask) || (isExcl && p2->sharedlock&mask) ){
 987           rc = SQLITE_BUSY;
 988           break;
 989         }
 990       }
 991       if( rc==SQLITE_OK ){
 992         if( isExcl )  pFd->excllock |= mask;
 993         if( !isExcl ) pFd->sharedlock |= mask;
 994       }
 995     }else{
 996       if( isExcl )  pFd->excllock &= (~mask);
 997       if( !isExcl ) pFd->sharedlock &= (~mask);
 998     }
 999   }
1000
1001   return rc;
1002 }
1003
1004 static void tvfsShmBarrier(sqlite3_file *pFile){
1005   TestvfsFd *pFd = tvfsGetFd(pFile);
1006   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
1007
1008   if( p->pScript && p->mask&TESTVFS_SHMBARRIER_MASK ){
1009     const char *z = pFd->pShm ? pFd->pShm->zFile : "";
1010     tvfsExecTcl(p, "xShmBarrier", Tcl_NewStringObj(z, -1), pFd->pShmId, 0, 0);
1011   }
1012
1013   if( p->isFullshm ){
1014     sqlite3_file *pReal = pFd->pReal;
1015     pReal->pMethods->xShmBarrier(pReal);
1016     return;
1017   }
1018 }
1019
1020 static int tvfsShmUnmap(
1021   sqlite3_file *pFile,
1022   int deleteFlag
1023 ){
1024   int rc = SQLITE_OK;
1025   TestvfsFd *pFd = tvfsGetFd(pFile);
1026   Testvfs *p = (Testvfs *)(pFd->pVfs->pAppData);
1027   TestvfsBuffer *pBuffer = pFd->pShm;
1028   TestvfsFd **ppFd;
1029
1030   if( p->isFullshm ){
1031     sqlite3_file *pReal = pFd->pReal;
1032     return pReal->pMethods->xShmUnmap(pReal, deleteFlag);
1033   }
1034
1035   if( !pBuffer ) return SQLITE_OK;
1036   assert( pFd->pShmId && pFd->pShm );
1037
1038   if( p->pScript && p->mask&TESTVFS_SHMCLOSE_MASK ){
1039     tvfsExecTcl(p, "xShmUnmap",
1040         Tcl_NewStringObj(pFd->pShm->zFile, -1), pFd->pShmId, 0, 0
1041     );
1042     tvfsResultCode(p, &rc);
1043   }
1044
1045   for(ppFd=&pBuffer->pFile; *ppFd!=pFd; ppFd=&((*ppFd)->pNext));
1046   assert( (*ppFd)==pFd );
1047   *ppFd = pFd->pNext;
1048   pFd->pNext = 0;
1049
1050   if( pBuffer->pFile==0 ){
1051     int i;
1052     TestvfsBuffer **pp;
1053     for(pp=&p->pBuffer; *pp!=pBuffer; pp=&((*pp)->pNext));
1054     *pp = (*pp)->pNext;
1055     for(i=0; pBuffer->aPage[i]; i++){
1056       ckfree((char *)pBuffer->aPage[i]);
1057     }
1058     ckfree((char *)pBuffer);
1059   }
1060   pFd->pShm = 0;
1061
1062   return rc;
1063 }
1064
1065 static int tvfsFetch(
1066     sqlite3_file *pFile,
1067     sqlite3_int64 iOfst,
1068     int iAmt,
1069     void **pp
1070 ){
1071   TestvfsFd *pFd = tvfsGetFd(pFile);
1072   return sqlite3OsFetch(pFd->pReal, iOfst, iAmt, pp);
1073 }
1074
1075 static int tvfsUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *p){
1076   TestvfsFd *pFd = tvfsGetFd(pFile);
1077   return sqlite3OsUnfetch(pFd->pReal, iOfst, p);
1078 }
1079
1080 static int SQLITE_TCLAPI testvfs_obj_cmd(
1081   ClientData cd,
1082   Tcl_Interp *interp,
1083   int objc,
1084   Tcl_Obj *CONST objv[]
1085 ){
1086   Testvfs *p = (Testvfs *)cd;
1087
1088   enum DB_enum {
1089     CMD_SHM, CMD_DELETE, CMD_FILTER, CMD_IOERR, CMD_SCRIPT,
1090     CMD_DEVCHAR, CMD_SECTORSIZE, CMD_FULLERR, CMD_CANTOPENERR
1091   };
1092   struct TestvfsSubcmd {
1093     char *zName;
1094     enum DB_enum eCmd;
1095   } aSubcmd[] = {
1096     { "shm",         CMD_SHM         },
1097     { "delete",      CMD_DELETE      },
1098     { "filter",      CMD_FILTER      },
1099     { "ioerr",       CMD_IOERR       },
1100     { "fullerr",     CMD_FULLERR     },
1101     { "cantopenerr", CMD_CANTOPENERR },
1102     { "script",      CMD_SCRIPT      },
1103     { "devchar",     CMD_DEVCHAR     },
1104     { "sectorsize",  CMD_SECTORSIZE  },
1105     { 0, 0 }
1106   };
1107   int i;
1108
1109   if( objc<2 ){
1110     Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
1111     return TCL_ERROR;
1112   }
1113   if( Tcl_GetIndexFromObjStruct(
1114         interp, objv[1], aSubcmd, sizeof(aSubcmd[0]), "subcommand", 0, &i)
1115   ){
1116     return TCL_ERROR;
1117   }
1118   Tcl_ResetResult(interp);
1119
1120   switch( aSubcmd[i].eCmd ){
1121     case CMD_SHM: {
1122       Tcl_Obj *pObj;
1123       int rc;
1124       TestvfsBuffer *pBuffer;
1125       char *zName;
1126       if( objc!=3 && objc!=4 ){
1127         Tcl_WrongNumArgs(interp, 2, objv, "FILE ?VALUE?");
1128         return TCL_ERROR;
1129       }
1130       zName = ckalloc(p->pParent->mxPathname);
1131       rc = p->pParent->xFullPathname(
1132           p->pParent, Tcl_GetString(objv[2]),
1133           p->pParent->mxPathname, zName
1134       );
1135       if( rc!=SQLITE_OK ){
1136         Tcl_AppendResult(interp, "failed to get full path: ",
1137                          Tcl_GetString(objv[2]), 0);
1138         ckfree(zName);
1139         return TCL_ERROR;
1140       }
1141       for(pBuffer=p->pBuffer; pBuffer; pBuffer=pBuffer->pNext){
1142         if( 0==strcmp(pBuffer->zFile, zName) ) break;
1143       }
1144       ckfree(zName);
1145       if( !pBuffer ){
1146         Tcl_AppendResult(interp, "no such file: ", Tcl_GetString(objv[2]), 0);
1147         return TCL_ERROR;
1148       }
1149       if( objc==4 ){
1150         int n;
1151         u8 *a = Tcl_GetByteArrayFromObj(objv[3], &n);
1152         int pgsz = pBuffer->pgsz;
1153         if( pgsz==0 ) pgsz = 65536;
1154         for(i=0; i*pgsz<n; i++){
1155           int nByte = pgsz;
1156           tvfsAllocPage(pBuffer, i, pgsz);
1157           if( n-i*pgsz<pgsz ){
1158             nByte = n;
1159           }
1160           memcpy(pBuffer->aPage[i], &a[i*pgsz], nByte);
1161         }
1162       }
1163
1164       pObj = Tcl_NewObj();
1165       for(i=0; pBuffer->aPage[i]; i++){
1166         int pgsz = pBuffer->pgsz;
1167         if( pgsz==0 ) pgsz = 65536;
1168         Tcl_AppendObjToObj(pObj, Tcl_NewByteArrayObj(pBuffer->aPage[i], pgsz));
1169       }
1170       Tcl_SetObjResult(interp, pObj);
1171       break;
1172     }
1173
1174     /*  TESTVFS filter METHOD-LIST
1175     **
1176     **     Activate special processing for those methods contained in the list
1177     */
1178     case CMD_FILTER: {
1179       static struct VfsMethod {
1180         char *zName;
1181         int mask;
1182       } vfsmethod [] = {
1183         { "xShmOpen",           TESTVFS_SHMOPEN_MASK },
1184         { "xShmLock",           TESTVFS_SHMLOCK_MASK },
1185         { "xShmBarrier",        TESTVFS_SHMBARRIER_MASK },
1186         { "xShmUnmap",          TESTVFS_SHMCLOSE_MASK },
1187         { "xShmMap",            TESTVFS_SHMMAP_MASK },
1188         { "xSync",              TESTVFS_SYNC_MASK },
1189         { "xDelete",            TESTVFS_DELETE_MASK },
1190         { "xWrite",             TESTVFS_WRITE_MASK },
1191         { "xRead",              TESTVFS_READ_MASK },
1192         { "xTruncate",          TESTVFS_TRUNCATE_MASK },
1193         { "xOpen",              TESTVFS_OPEN_MASK },
1194         { "xClose",             TESTVFS_CLOSE_MASK },
1195         { "xAccess",            TESTVFS_ACCESS_MASK },
1196         { "xFullPathname",      TESTVFS_FULLPATHNAME_MASK },
1197         { "xUnlock",            TESTVFS_UNLOCK_MASK },
1198         { "xLock",              TESTVFS_LOCK_MASK },
1199         { "xCheckReservedLock", TESTVFS_CKLOCK_MASK },
1200         { "xFileControl",       TESTVFS_FCNTL_MASK },
1201       };
1202       Tcl_Obj **apElem = 0;
1203       int nElem = 0;
1204       int mask = 0;
1205       if( objc!=3 ){
1206         Tcl_WrongNumArgs(interp, 2, objv, "LIST");
1207         return TCL_ERROR;
1208       }
1209       if( Tcl_ListObjGetElements(interp, objv[2], &nElem, &apElem) ){
1210         return TCL_ERROR;
1211       }
1212       Tcl_ResetResult(interp);
1213       for(i=0; i<nElem; i++){
1214         int iMethod;
1215         char *zElem = Tcl_GetString(apElem[i]);
1216         for(iMethod=0; iMethod<ArraySize(vfsmethod); iMethod++){
1217           if( strcmp(zElem, vfsmethod[iMethod].zName)==0 ){
1218             mask |= vfsmethod[iMethod].mask;
1219             break;
1220           }
1221         }
1222         if( iMethod==ArraySize(vfsmethod) ){
1223           Tcl_AppendResult(interp, "unknown method: ", zElem, 0);
1224           return TCL_ERROR;
1225         }
1226       }
1227       p->mask = mask;
1228       break;
1229     }
1230
1231     /*
1232     **  TESTVFS script ?SCRIPT?
1233     **
1234     **  Query or set the script to be run when filtered VFS events
1235     **  occur.
1236     */
1237     case CMD_SCRIPT: {
1238       if( objc==3 ){
1239         int nByte;
1240         if( p->pScript ){
1241           Tcl_DecrRefCount(p->pScript);
1242           p->pScript = 0;
1243         }
1244         Tcl_GetStringFromObj(objv[2], &nByte);
1245         if( nByte>0 ){
1246           p->pScript = Tcl_DuplicateObj(objv[2]);
1247           Tcl_IncrRefCount(p->pScript);
1248         }
1249       }else if( objc!=2 ){
1250         Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
1251         return TCL_ERROR;
1252       }
1253
1254       Tcl_ResetResult(interp);
1255       if( p->pScript ) Tcl_SetObjResult(interp, p->pScript);
1256
1257       break;
1258     }
1259
1260     /*
1261     ** TESTVFS ioerr ?IFAIL PERSIST?
1262     **
1263     **   Where IFAIL is an integer and PERSIST is boolean.
1264     */
1265     case CMD_CANTOPENERR:
1266     case CMD_IOERR:
1267     case CMD_FULLERR: {
1268       TestFaultInject *pTest = 0;
1269       int iRet;
1270
1271       switch( aSubcmd[i].eCmd ){
1272         case CMD_IOERR: pTest = &p->ioerr_err; break;
1273         case CMD_FULLERR: pTest = &p->full_err; break;
1274         case CMD_CANTOPENERR: pTest = &p->cantopen_err; break;
1275         default: assert(0);
1276       }
1277       iRet = pTest->nFail;
1278       pTest->nFail = 0;
1279       pTest->eFault = 0;
1280       pTest->iCnt = 0;
1281
1282       if( objc==4 ){
1283         int iCnt, iPersist;
1284         if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iCnt)
1285          || TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &iPersist)
1286         ){
1287           return TCL_ERROR;
1288         }
1289         pTest->eFault = iPersist?FAULT_INJECT_PERSISTENT:FAULT_INJECT_TRANSIENT;
1290         pTest->iCnt = iCnt;
1291       }else if( objc!=2 ){
1292         Tcl_WrongNumArgs(interp, 2, objv, "?CNT PERSIST?");
1293         return TCL_ERROR;
1294       }
1295       Tcl_SetObjResult(interp, Tcl_NewIntObj(iRet));
1296       break;
1297     }
1298
1299     case CMD_DELETE: {
1300       Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
1301       break;
1302     }
1303
1304     case CMD_DEVCHAR: {
1305       struct DeviceFlag {
1306         char *zName;
1307         int iValue;
1308       } aFlag[] = {
1309         { "default",               -1 },
1310         { "atomic",                SQLITE_IOCAP_ATOMIC                },
1311         { "atomic512",             SQLITE_IOCAP_ATOMIC512             },
1312         { "atomic1k",              SQLITE_IOCAP_ATOMIC1K              },
1313         { "atomic2k",              SQLITE_IOCAP_ATOMIC2K              },
1314         { "atomic4k",              SQLITE_IOCAP_ATOMIC4K              },
1315         { "atomic8k",              SQLITE_IOCAP_ATOMIC8K              },
1316         { "atomic16k",             SQLITE_IOCAP_ATOMIC16K             },
1317         { "atomic32k",             SQLITE_IOCAP_ATOMIC32K             },
1318         { "atomic64k",             SQLITE_IOCAP_ATOMIC64K             },
1319         { "sequential",            SQLITE_IOCAP_SEQUENTIAL            },
1320         { "safe_append",           SQLITE_IOCAP_SAFE_APPEND           },
1321         { "undeletable_when_open", SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN },
1322         { "powersafe_overwrite",   SQLITE_IOCAP_POWERSAFE_OVERWRITE   },
1323         { "immutable",             SQLITE_IOCAP_IMMUTABLE             },
1324         { 0, 0 }
1325       };
1326       Tcl_Obj *pRet;
1327       int iFlag;
1328
1329       if( objc>3 ){
1330         Tcl_WrongNumArgs(interp, 2, objv, "?ATTR-LIST?");
1331         return TCL_ERROR;
1332       }
1333       if( objc==3 ){
1334         int j;
1335         int iNew = 0;
1336         Tcl_Obj **flags = 0;
1337         int nFlags = 0;
1338
1339         if( Tcl_ListObjGetElements(interp, objv[2], &nFlags, &flags) ){
1340           return TCL_ERROR;
1341         }
1342
1343         for(j=0; j<nFlags; j++){
1344           int idx = 0;
1345           if( Tcl_GetIndexFromObjStruct(interp, flags[j], aFlag,
1346                 sizeof(aFlag[0]), "flag", 0, &idx)
1347           ){
1348             return TCL_ERROR;
1349           }
1350           if( aFlag[idx].iValue<0 && nFlags>1 ){
1351             Tcl_AppendResult(interp, "bad flags: ", Tcl_GetString(objv[2]), 0);
1352             return TCL_ERROR;
1353           }
1354           iNew |= aFlag[idx].iValue;
1355         }
1356
1357         p->iDevchar = iNew| 0x10000000;
1358       }
1359
1360       pRet = Tcl_NewObj();
1361       for(iFlag=0; iFlag<sizeof(aFlag)/sizeof(aFlag[0]); iFlag++){
1362         if( p->iDevchar & aFlag[iFlag].iValue ){
1363           Tcl_ListObjAppendElement(
1364               interp, pRet, Tcl_NewStringObj(aFlag[iFlag].zName, -1)
1365           );
1366         }
1367       }
1368       Tcl_SetObjResult(interp, pRet);
1369
1370       break;
1371     }
1372
1373     case CMD_SECTORSIZE: {
1374       if( objc>3 ){
1375         Tcl_WrongNumArgs(interp, 2, objv, "?VALUE?");
1376         return TCL_ERROR;
1377       }
1378       if( objc==3 ){
1379         int iNew = 0;
1380         if( Tcl_GetIntFromObj(interp, objv[2], &iNew) ){
1381           return TCL_ERROR;
1382         }
1383         p->iSectorsize = iNew;
1384       }
1385       Tcl_SetObjResult(interp, Tcl_NewIntObj(p->iSectorsize));
1386       break;
1387     }
1388   }
1389
1390   return TCL_OK;
1391 }
1392
1393 static void SQLITE_TCLAPI testvfs_obj_del(ClientData cd){
1394   Testvfs *p = (Testvfs *)cd;
1395   if( p->pScript ) Tcl_DecrRefCount(p->pScript);
1396   sqlite3_vfs_unregister(p->pVfs);
1397   memset(p->pVfs, 0, sizeof(sqlite3_vfs));
1398   ckfree((char *)p->pVfs);
1399   memset(p, 0, sizeof(Testvfs));
1400   ckfree((char *)p);
1401 }
1402
1403 /*
1404 ** Usage:  testvfs VFSNAME ?SWITCHES?
1405 **
1406 ** Switches are:
1407 **
1408 **   -noshm   BOOLEAN             (True to omit shm methods. Default false)
1409 **   -default BOOLEAN             (True to make the vfs default. Default false)
1410 **
1411 ** This command creates two things when it is invoked: an SQLite VFS, and
1412 ** a Tcl command. Both are named VFSNAME. The VFS is installed. It is not
1413 ** installed as the default VFS.
1414 **
1415 ** The VFS passes all file I/O calls through to the underlying VFS.
1416 **
1417 ** Whenever the xShmMap method of the VFS
1418 ** is invoked, the SCRIPT is executed as follows:
1419 **
1420 **   SCRIPT xShmMap    FILENAME ID
1421 **
1422 ** The value returned by the invocation of SCRIPT above is interpreted as
1423 ** an SQLite error code and returned to SQLite. Either a symbolic
1424 ** "SQLITE_OK" or numeric "0" value may be returned.
1425 **
1426 ** The contents of the shared-memory buffer associated with a given file
1427 ** may be read and set using the following command:
1428 **
1429 **   VFSNAME shm FILENAME ?NEWVALUE?
1430 **
1431 ** When the xShmLock method is invoked by SQLite, the following script is
1432 ** run:
1433 **
1434 **   SCRIPT xShmLock    FILENAME ID LOCK
1435 **
1436 ** where LOCK is of the form "OFFSET NBYTE lock/unlock shared/exclusive"
1437 */
1438 static int SQLITE_TCLAPI testvfs_cmd(
1439   ClientData cd,
1440   Tcl_Interp *interp,
1441   int objc,
1442   Tcl_Obj *CONST objv[]
1443 ){
1444   static sqlite3_vfs tvfs_vfs = {
1445     3,                            /* iVersion */
1446     0,                            /* szOsFile */
1447     0,                            /* mxPathname */
1448     0,                            /* pNext */
1449     0,                            /* zName */
1450     0,                            /* pAppData */
1451     tvfsOpen,                     /* xOpen */
1452     tvfsDelete,                   /* xDelete */
1453     tvfsAccess,                   /* xAccess */
1454     tvfsFullPathname,             /* xFullPathname */
1455 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1456     tvfsDlOpen,                   /* xDlOpen */
1457     tvfsDlError,                  /* xDlError */
1458     tvfsDlSym,                    /* xDlSym */
1459     tvfsDlClose,                  /* xDlClose */
1460 #else
1461     0,                            /* xDlOpen */
1462     0,                            /* xDlError */
1463     0,                            /* xDlSym */
1464     0,                            /* xDlClose */
1465 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
1466     tvfsRandomness,               /* xRandomness */
1467     tvfsSleep,                    /* xSleep */
1468     tvfsCurrentTime,              /* xCurrentTime */
1469     0,                            /* xGetLastError */
1470     0,                            /* xCurrentTimeInt64 */
1471     0,                            /* xSetSystemCall */
1472     0,                            /* xGetSystemCall */
1473     0,                            /* xNextSystemCall */
1474   };
1475
1476   Testvfs *p;                     /* New object */
1477   sqlite3_vfs *pVfs;              /* New VFS */
1478   char *zVfs;
1479   int nByte;                      /* Bytes of space to allocate at p */
1480
1481   int i;
1482   int isNoshm = 0;                /* True if -noshm is passed */
1483   int isFullshm = 0;              /* True if -fullshm is passed */
1484   int isDefault = 0;              /* True if -default is passed */
1485   int szOsFile = 0;               /* Value passed to -szosfile */
1486   int mxPathname = -1;            /* Value passed to -mxpathname */
1487   int iVersion = 3;               /* Value passed to -iversion */
1488
1489   if( objc<2 || 0!=(objc%2) ) goto bad_args;
1490   for(i=2; i<objc; i += 2){
1491     int nSwitch;
1492     char *zSwitch;
1493     zSwitch = Tcl_GetStringFromObj(objv[i], &nSwitch);
1494
1495     if( nSwitch>2 && 0==strncmp("-noshm", zSwitch, nSwitch) ){
1496       if( Tcl_GetBooleanFromObj(interp, objv[i+1], &isNoshm) ){
1497         return TCL_ERROR;
1498       }
1499       if( isNoshm ) isFullshm = 0;
1500     }
1501     else if( nSwitch>2 && 0==strncmp("-default", zSwitch, nSwitch) ){
1502       if( Tcl_GetBooleanFromObj(interp, objv[i+1], &isDefault) ){
1503         return TCL_ERROR;
1504       }
1505     }
1506     else if( nSwitch>2 && 0==strncmp("-szosfile", zSwitch, nSwitch) ){
1507       if( Tcl_GetIntFromObj(interp, objv[i+1], &szOsFile) ){
1508         return TCL_ERROR;
1509       }
1510     }
1511     else if( nSwitch>2 && 0==strncmp("-mxpathname", zSwitch, nSwitch) ){
1512       if( Tcl_GetIntFromObj(interp, objv[i+1], &mxPathname) ){
1513         return TCL_ERROR;
1514       }
1515     }
1516     else if( nSwitch>2 && 0==strncmp("-iversion", zSwitch, nSwitch) ){
1517       if( Tcl_GetIntFromObj(interp, objv[i+1], &iVersion) ){
1518         return TCL_ERROR;
1519       }
1520     }
1521     else if( nSwitch>2 && 0==strncmp("-fullshm", zSwitch, nSwitch) ){
1522       if( Tcl_GetBooleanFromObj(interp, objv[i+1], &isFullshm) ){
1523         return TCL_ERROR;
1524       }
1525       if( isFullshm ) isNoshm = 0;
1526     }
1527     else{
1528       goto bad_args;
1529     }
1530   }
1531
1532   if( szOsFile<sizeof(TestvfsFile) ){
1533     szOsFile = sizeof(TestvfsFile);
1534   }
1535
1536   zVfs = Tcl_GetString(objv[1]);
1537   nByte = sizeof(Testvfs) + (int)strlen(zVfs)+1;
1538   p = (Testvfs *)ckalloc(nByte);
1539   memset(p, 0, nByte);
1540   p->iDevchar = -1;
1541   p->iSectorsize = -1;
1542
1543   /* Create the new object command before querying SQLite for a default VFS
1544   ** to use for 'real' IO operations. This is because creating the new VFS
1545   ** may delete an existing [testvfs] VFS of the same name. If such a VFS
1546   ** is currently the default, the new [testvfs] may end up calling the
1547   ** methods of a deleted object.
1548   */
1549   Tcl_CreateObjCommand(interp, zVfs, testvfs_obj_cmd, p, testvfs_obj_del);
1550   p->pParent = sqlite3_vfs_find(0);
1551   p->interp = interp;
1552
1553   p->zName = (char *)&p[1];
1554   memcpy(p->zName, zVfs, strlen(zVfs)+1);
1555
1556   pVfs = (sqlite3_vfs *)ckalloc(sizeof(sqlite3_vfs));
1557   memcpy(pVfs, &tvfs_vfs, sizeof(sqlite3_vfs));
1558   pVfs->pAppData = (void *)p;
1559   pVfs->iVersion = iVersion;
1560   pVfs->zName = p->zName;
1561   pVfs->mxPathname = p->pParent->mxPathname;
1562   if( mxPathname>=0 && mxPathname<pVfs->mxPathname ){
1563     pVfs->mxPathname = mxPathname;
1564   }
1565   pVfs->szOsFile = szOsFile;
1566   p->pVfs = pVfs;
1567   p->isNoshm = isNoshm;
1568   p->isFullshm = isFullshm;
1569   p->mask = TESTVFS_ALL_MASK;
1570
1571   sqlite3_vfs_register(pVfs, isDefault);
1572
1573   return TCL_OK;
1574
1575  bad_args:
1576   Tcl_WrongNumArgs(interp, 1, objv, "VFSNAME ?-noshm BOOL? ?-fullshm BOOL? ?-default BOOL? ?-mxpathname INT? ?-szosfile INT? ?-iversion INT?");
1577   return TCL_ERROR;
1578 }
1579
1580 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
1581 extern const char *sqlite3ErrName(int);
1582
1583 /*
1584 ** tclcmd: vfs_shmlock DB DBNAME (shared|exclusive) (lock|unlock) OFFSET N
1585 */
1586 static int SQLITE_TCLAPI test_vfs_shmlock(
1587   void * clientData,
1588   Tcl_Interp *interp,
1589   int objc,
1590   Tcl_Obj *CONST objv[]
1591 ){
1592   const char *azArg1[] = {"shared", "exclusive", 0};
1593   const char *azArg2[] = {"lock", "unlock", 0};
1594   sqlite3 *db = 0;
1595   int rc = SQLITE_OK;
1596   const char *zDbname = 0;
1597   int iArg1 = 0;
1598   int iArg2 = 0;
1599   int iOffset = 0;
1600   int n = 0;
1601   sqlite3_file *pFd;
1602
1603   if( objc!=7 ){
1604     Tcl_WrongNumArgs(interp, 1, objv,
1605         "DB DBNAME (shared|exclusive) (lock|unlock) OFFSET N"
1606     );
1607     return TCL_ERROR;
1608   }
1609
1610   zDbname = Tcl_GetString(objv[2]);
1611   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
1612    || Tcl_GetIndexFromObj(interp, objv[3], azArg1, "ARG", 0, &iArg1)
1613    || Tcl_GetIndexFromObj(interp, objv[4], azArg2, "ARG", 0, &iArg2)
1614    || Tcl_GetIntFromObj(interp, objv[5], &iOffset)
1615    || Tcl_GetIntFromObj(interp, objv[6], &n)
1616   ){
1617     return TCL_ERROR;
1618   }
1619
1620   sqlite3_file_control(db, zDbname, SQLITE_FCNTL_FILE_POINTER, (void*)&pFd);
1621   if( pFd==0 ){
1622     return TCL_ERROR;
1623   }
1624   rc = pFd->pMethods->xShmLock(pFd, iOffset, n,
1625       (iArg1==0 ? SQLITE_SHM_SHARED : SQLITE_SHM_EXCLUSIVE)
1626     | (iArg2==0 ? SQLITE_SHM_LOCK : SQLITE_SHM_UNLOCK)
1627   );
1628   Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
1629   return TCL_OK;
1630 }
1631
1632 static int SQLITE_TCLAPI test_vfs_set_readmark(
1633   void * clientData,
1634   Tcl_Interp *interp,
1635   int objc,
1636   Tcl_Obj *CONST objv[]
1637 ){
1638   sqlite3 *db = 0;
1639   int rc = SQLITE_OK;
1640   const char *zDbname = 0;
1641   int iSlot = 0;
1642   int iVal = -1;
1643   sqlite3_file *pFd;
1644   void volatile *pShm = 0;
1645   u32 *aShm;
1646   int iOff;
1647
1648   if( objc!=4 && objc!=5 ){
1649     Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SLOT ?VALUE?");
1650     return TCL_ERROR;
1651   }
1652
1653   zDbname = Tcl_GetString(objv[2]);
1654   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
1655    || Tcl_GetIntFromObj(interp, objv[3], &iSlot)
1656    || (objc==5 && Tcl_GetIntFromObj(interp, objv[4], &iVal))
1657   ){
1658     return TCL_ERROR;
1659   }
1660
1661   sqlite3_file_control(db, zDbname, SQLITE_FCNTL_FILE_POINTER, (void*)&pFd);
1662   if( pFd==0 ){
1663     return TCL_ERROR;
1664   }
1665   rc = pFd->pMethods->xShmMap(pFd, 0, 32*1024, 0, &pShm);
1666   if( rc!=SQLITE_OK ){
1667     Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
1668     return TCL_ERROR;
1669   }
1670   if( pShm==0 ){
1671     Tcl_AppendResult(interp, "*-shm is not yet mapped", 0);
1672     return TCL_ERROR;
1673   }
1674   aShm = (u32*)pShm;
1675   iOff = 12*2+1+iSlot;
1676
1677   if( objc==5 ){
1678     aShm[iOff] = iVal;
1679   }
1680   Tcl_SetObjResult(interp, Tcl_NewIntObj(aShm[iOff]));
1681
1682   return TCL_OK;
1683 }
1684
1685 int Sqlitetestvfs_Init(Tcl_Interp *interp){
1686   Tcl_CreateObjCommand(interp, "testvfs", testvfs_cmd, 0, 0);
1687   Tcl_CreateObjCommand(interp, "vfs_shmlock", test_vfs_shmlock, 0, 0);
1688   Tcl_CreateObjCommand(interp, "vfs_set_readmark", test_vfs_set_readmark, 0, 0);
1689   return TCL_OK;
1690 }
1691
1692 #endif