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