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 1689