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 1693