1 /* 2 ** 2011 March 16 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 code implements a VFS shim that writes diagnostic 14 ** output for each VFS call, similar to "strace". 15 */ 16 #include <stdlib.h> 17 #include <string.h> 18 #include "sqlite3.h" 19 20 /* 21 ** An instance of this structure is attached to the each trace VFS to 22 ** provide auxiliary information. 23 */ 24 typedef struct vfstrace_info vfstrace_info; 25 struct vfstrace_info { 26 sqlite3_vfs *pRootVfs; /* The underlying real VFS */ 27 int (*xOut)(const char*, void*); /* Send output here */ 28 void *pOutArg; /* First argument to xOut */ 29 const char *zVfsName; /* Name of this trace-VFS */ 30 sqlite3_vfs *pTraceVfs; /* Pointer back to the trace VFS */ 31 }; 32 33 /* 34 ** The sqlite3_file object for the trace VFS 35 */ 36 typedef struct vfstrace_file vfstrace_file; 37 struct vfstrace_file { 38 sqlite3_file base; /* Base class. Must be first */ 39 vfstrace_info *pInfo; /* The trace-VFS to which this file belongs */ 40 const char *zFName; /* Base name of the file */ 41 sqlite3_file *pReal; /* The real underlying file */ 42 }; 43 44 /* 45 ** Method declarations for vfstrace_file. 46 */ 47 static int vfstraceClose(sqlite3_file*); 48 static int vfstraceRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 49 static int vfstraceWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64); 50 static int vfstraceTruncate(sqlite3_file*, sqlite3_int64 size); 51 static int vfstraceSync(sqlite3_file*, int flags); 52 static int vfstraceFileSize(sqlite3_file*, sqlite3_int64 *pSize); 53 static int vfstraceLock(sqlite3_file*, int); 54 static int vfstraceUnlock(sqlite3_file*, int); 55 static int vfstraceCheckReservedLock(sqlite3_file*, int *); 56 static int vfstraceFileControl(sqlite3_file*, int op, void *pArg); 57 static int vfstraceSectorSize(sqlite3_file*); 58 static int vfstraceDeviceCharacteristics(sqlite3_file*); 59 static int vfstraceShmLock(sqlite3_file*,int,int,int); 60 static int vfstraceShmMap(sqlite3_file*,int,int,int, void volatile **); 61 static void vfstraceShmBarrier(sqlite3_file*); 62 static int vfstraceShmUnmap(sqlite3_file*,int); 63 64 /* 65 ** Method declarations for vfstrace_vfs. 66 */ 67 static int vfstraceOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); 68 static int vfstraceDelete(sqlite3_vfs*, const char *zName, int syncDir); 69 static int vfstraceAccess(sqlite3_vfs*, const char *zName, int flags, int *); 70 static int vfstraceFullPathname(sqlite3_vfs*, const char *zName, int, char *); 71 static void *vfstraceDlOpen(sqlite3_vfs*, const char *zFilename); 72 static void vfstraceDlError(sqlite3_vfs*, int nByte, char *zErrMsg); 73 static void (*vfstraceDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void); 74 static void vfstraceDlClose(sqlite3_vfs*, void*); 75 static int vfstraceRandomness(sqlite3_vfs*, int nByte, char *zOut); 76 static int vfstraceSleep(sqlite3_vfs*, int microseconds); 77 static int vfstraceCurrentTime(sqlite3_vfs*, double*); 78 static int vfstraceGetLastError(sqlite3_vfs*, int, char*); 79 static int vfstraceCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); 80 static int vfstraceSetSystemCall(sqlite3_vfs*,const char*, sqlite3_syscall_ptr); 81 static sqlite3_syscall_ptr vfstraceGetSystemCall(sqlite3_vfs*, const char *); 82 static const char *vfstraceNextSystemCall(sqlite3_vfs*, const char *zName); 83 84 /* 85 ** Return a pointer to the tail of the pathname. Examples: 86 ** 87 ** /home/drh/xyzzy.txt -> xyzzy.txt 88 ** xyzzy.txt -> xyzzy.txt 89 */ 90 static const char *fileTail(const char *z){ 91 int i; 92 if( z==0 ) return 0; 93 i = strlen(z)-1; 94 while( i>0 && z[i-1]!='/' ){ i--; } 95 return &z[i]; 96 } 97 98 /* 99 ** Send trace output defined by zFormat and subsequent arguments. 100 */ 101 static void vfstrace_printf( 102 vfstrace_info *pInfo, 103 const char *zFormat, 104 ... 105 ){ 106 va_list ap; 107 char *zMsg; 108 va_start(ap, zFormat); 109 zMsg = sqlite3_vmprintf(zFormat, ap); 110 va_end(ap); 111 pInfo->xOut(zMsg, pInfo->pOutArg); 112 sqlite3_free(zMsg); 113 } 114 115 /* 116 ** Convert value rc into a string and print it using zFormat. zFormat 117 ** should have exactly one %s 118 */ 119 static void vfstrace_print_errcode( 120 vfstrace_info *pInfo, 121 const char *zFormat, 122 int rc 123 ){ 124 char zBuf[50]; 125 char *zVal; 126 switch( rc ){ 127 case SQLITE_OK: zVal = "SQLITE_OK"; break; 128 case SQLITE_ERROR: zVal = "SQLITE_ERROR"; break; 129 case SQLITE_PERM: zVal = "SQLITE_PERM"; break; 130 case SQLITE_ABORT: zVal = "SQLITE_ABORT"; break; 131 case SQLITE_BUSY: zVal = "SQLITE_BUSY"; break; 132 case SQLITE_NOMEM: zVal = "SQLITE_NOMEM"; break; 133 case SQLITE_READONLY: zVal = "SQLITE_READONLY"; break; 134 case SQLITE_INTERRUPT: zVal = "SQLITE_INTERRUPT"; break; 135 case SQLITE_IOERR: zVal = "SQLITE_IOERR"; break; 136 case SQLITE_CORRUPT: zVal = "SQLITE_CORRUPT"; break; 137 case SQLITE_FULL: zVal = "SQLITE_FULL"; break; 138 case SQLITE_CANTOPEN: zVal = "SQLITE_CANTOPEN"; break; 139 case SQLITE_PROTOCOL: zVal = "SQLITE_PROTOCOL"; break; 140 case SQLITE_EMPTY: zVal = "SQLITE_EMPTY"; break; 141 case SQLITE_SCHEMA: zVal = "SQLITE_SCHEMA"; break; 142 case SQLITE_CONSTRAINT: zVal = "SQLITE_CONSTRAINT"; break; 143 case SQLITE_MISMATCH: zVal = "SQLITE_MISMATCH"; break; 144 case SQLITE_MISUSE: zVal = "SQLITE_MISUSE"; break; 145 case SQLITE_NOLFS: zVal = "SQLITE_NOLFS"; break; 146 case SQLITE_IOERR_READ: zVal = "SQLITE_IOERR_READ"; break; 147 case SQLITE_IOERR_SHORT_READ: zVal = "SQLITE_IOERR_SHORT_READ"; break; 148 case SQLITE_IOERR_WRITE: zVal = "SQLITE_IOERR_WRITE"; break; 149 case SQLITE_IOERR_FSYNC: zVal = "SQLITE_IOERR_FSYNC"; break; 150 case SQLITE_IOERR_DIR_FSYNC: zVal = "SQLITE_IOERR_DIR_FSYNC"; break; 151 case SQLITE_IOERR_TRUNCATE: zVal = "SQLITE_IOERR_TRUNCATE"; break; 152 case SQLITE_IOERR_FSTAT: zVal = "SQLITE_IOERR_FSTAT"; break; 153 case SQLITE_IOERR_UNLOCK: zVal = "SQLITE_IOERR_UNLOCK"; break; 154 case SQLITE_IOERR_RDLOCK: zVal = "SQLITE_IOERR_RDLOCK"; break; 155 case SQLITE_IOERR_DELETE: zVal = "SQLITE_IOERR_DELETE"; break; 156 case SQLITE_IOERR_BLOCKED: zVal = "SQLITE_IOERR_BLOCKED"; break; 157 case SQLITE_IOERR_NOMEM: zVal = "SQLITE_IOERR_NOMEM"; break; 158 case SQLITE_IOERR_ACCESS: zVal = "SQLITE_IOERR_ACCESS"; break; 159 case SQLITE_IOERR_CHECKRESERVEDLOCK: 160 zVal = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break; 161 case SQLITE_IOERR_LOCK: zVal = "SQLITE_IOERR_LOCK"; break; 162 case SQLITE_IOERR_CLOSE: zVal = "SQLITE_IOERR_CLOSE"; break; 163 case SQLITE_IOERR_DIR_CLOSE: zVal = "SQLITE_IOERR_DIR_CLOSE"; break; 164 case SQLITE_IOERR_SHMOPEN: zVal = "SQLITE_IOERR_SHMOPEN"; break; 165 case SQLITE_IOERR_SHMSIZE: zVal = "SQLITE_IOERR_SHMSIZE"; break; 166 case SQLITE_IOERR_SHMLOCK: zVal = "SQLITE_IOERR_SHMLOCK"; break; 167 case SQLITE_LOCKED_SHAREDCACHE: zVal = "SQLITE_LOCKED_SHAREDCACHE"; break; 168 case SQLITE_BUSY_RECOVERY: zVal = "SQLITE_BUSY_RECOVERY"; break; 169 case SQLITE_CANTOPEN_NOTEMPDIR: zVal = "SQLITE_CANTOPEN_NOTEMPDIR"; break; 170 default: { 171 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc); 172 zVal = zBuf; 173 break; 174 } 175 } 176 vfstrace_printf(pInfo, zFormat, zVal); 177 } 178 179 /* 180 ** Append to a buffer. 181 */ 182 static void strappend(char *z, int *pI, const char *zAppend){ 183 int i = *pI; 184 while( zAppend[0] ){ z[i++] = *(zAppend++); } 185 z[i] = 0; 186 *pI = i; 187 } 188 189 /* 190 ** Close an vfstrace-file. 191 */ 192 static int vfstraceClose(sqlite3_file *pFile){ 193 vfstrace_file *p = (vfstrace_file *)pFile; 194 vfstrace_info *pInfo = p->pInfo; 195 int rc; 196 vfstrace_printf(pInfo, "%s.xClose(%s)", pInfo->zVfsName, p->zFName); 197 rc = p->pReal->pMethods->xClose(p->pReal); 198 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 199 if( rc==SQLITE_OK ){ 200 sqlite3_free((void*)p->base.pMethods); 201 p->base.pMethods = 0; 202 } 203 return rc; 204 } 205 206 /* 207 ** Read data from an vfstrace-file. 208 */ 209 static int vfstraceRead( 210 sqlite3_file *pFile, 211 void *zBuf, 212 int iAmt, 213 sqlite_int64 iOfst 214 ){ 215 vfstrace_file *p = (vfstrace_file *)pFile; 216 vfstrace_info *pInfo = p->pInfo; 217 int rc; 218 vfstrace_printf(pInfo, "%s.xRead(%s,n=%d,ofst=%lld)", 219 pInfo->zVfsName, p->zFName, iAmt, iOfst); 220 rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst); 221 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 222 return rc; 223 } 224 225 /* 226 ** Write data to an vfstrace-file. 227 */ 228 static int vfstraceWrite( 229 sqlite3_file *pFile, 230 const void *zBuf, 231 int iAmt, 232 sqlite_int64 iOfst 233 ){ 234 vfstrace_file *p = (vfstrace_file *)pFile; 235 vfstrace_info *pInfo = p->pInfo; 236 int rc; 237 vfstrace_printf(pInfo, "%s.xWrite(%s,n=%d,ofst=%lld)", 238 pInfo->zVfsName, p->zFName, iAmt, iOfst); 239 rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst); 240 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 241 return rc; 242 } 243 244 /* 245 ** Truncate an vfstrace-file. 246 */ 247 static int vfstraceTruncate(sqlite3_file *pFile, sqlite_int64 size){ 248 vfstrace_file *p = (vfstrace_file *)pFile; 249 vfstrace_info *pInfo = p->pInfo; 250 int rc; 251 vfstrace_printf(pInfo, "%s.xTruncate(%s,%lld)", pInfo->zVfsName, p->zFName, 252 size); 253 rc = p->pReal->pMethods->xTruncate(p->pReal, size); 254 vfstrace_printf(pInfo, " -> %d\n", rc); 255 return rc; 256 } 257 258 /* 259 ** Sync an vfstrace-file. 260 */ 261 static int vfstraceSync(sqlite3_file *pFile, int flags){ 262 vfstrace_file *p = (vfstrace_file *)pFile; 263 vfstrace_info *pInfo = p->pInfo; 264 int rc; 265 int i; 266 char zBuf[100]; 267 memcpy(zBuf, "|0", 3); 268 i = 0; 269 if( flags & SQLITE_SYNC_FULL ) strappend(zBuf, &i, "|FULL"); 270 else if( flags & SQLITE_SYNC_NORMAL ) strappend(zBuf, &i, "|NORMAL"); 271 if( flags & SQLITE_SYNC_DATAONLY ) strappend(zBuf, &i, "|DATAONLY"); 272 if( flags & ~(SQLITE_SYNC_FULL|SQLITE_SYNC_DATAONLY) ){ 273 sqlite3_snprintf(sizeof(zBuf)-i, &zBuf[i], "|0x%x", flags); 274 } 275 vfstrace_printf(pInfo, "%s.xSync(%s,%s)", pInfo->zVfsName, p->zFName, 276 &zBuf[1]); 277 rc = p->pReal->pMethods->xSync(p->pReal, flags); 278 vfstrace_printf(pInfo, " -> %d\n", rc); 279 return rc; 280 } 281 282 /* 283 ** Return the current file-size of an vfstrace-file. 284 */ 285 static int vfstraceFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 286 vfstrace_file *p = (vfstrace_file *)pFile; 287 vfstrace_info *pInfo = p->pInfo; 288 int rc; 289 vfstrace_printf(pInfo, "%s.xFileSize(%s)", pInfo->zVfsName, p->zFName); 290 rc = p->pReal->pMethods->xFileSize(p->pReal, pSize); 291 vfstrace_print_errcode(pInfo, " -> %s,", rc); 292 vfstrace_printf(pInfo, " size=%lld\n", *pSize); 293 return rc; 294 } 295 296 /* 297 ** Return the name of a lock. 298 */ 299 static const char *lockName(int eLock){ 300 const char *azLockNames[] = { 301 "NONE", "SHARED", "RESERVED", "PENDING", "EXCLUSIVE" 302 }; 303 if( eLock<0 || eLock>=sizeof(azLockNames)/sizeof(azLockNames[0]) ){ 304 return "???"; 305 }else{ 306 return azLockNames[eLock]; 307 } 308 } 309 310 /* 311 ** Lock an vfstrace-file. 312 */ 313 static int vfstraceLock(sqlite3_file *pFile, int eLock){ 314 vfstrace_file *p = (vfstrace_file *)pFile; 315 vfstrace_info *pInfo = p->pInfo; 316 int rc; 317 vfstrace_printf(pInfo, "%s.xLock(%s,%s)", pInfo->zVfsName, p->zFName, 318 lockName(eLock)); 319 rc = p->pReal->pMethods->xLock(p->pReal, eLock); 320 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 321 return rc; 322 } 323 324 /* 325 ** Unlock an vfstrace-file. 326 */ 327 static int vfstraceUnlock(sqlite3_file *pFile, int eLock){ 328 vfstrace_file *p = (vfstrace_file *)pFile; 329 vfstrace_info *pInfo = p->pInfo; 330 int rc; 331 vfstrace_printf(pInfo, "%s.xUnlock(%s,%s)", pInfo->zVfsName, p->zFName, 332 lockName(eLock)); 333 rc = p->pReal->pMethods->xUnlock(p->pReal, eLock); 334 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 335 return rc; 336 } 337 338 /* 339 ** Check if another file-handle holds a RESERVED lock on an vfstrace-file. 340 */ 341 static int vfstraceCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 342 vfstrace_file *p = (vfstrace_file *)pFile; 343 vfstrace_info *pInfo = p->pInfo; 344 int rc; 345 vfstrace_printf(pInfo, "%s.xCheckReservedLock(%s,%d)", 346 pInfo->zVfsName, p->zFName); 347 rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut); 348 vfstrace_print_errcode(pInfo, " -> %s", rc); 349 vfstrace_printf(pInfo, ", out=%d\n", *pResOut); 350 return rc; 351 } 352 353 /* 354 ** File control method. For custom operations on an vfstrace-file. 355 */ 356 static int vfstraceFileControl(sqlite3_file *pFile, int op, void *pArg){ 357 vfstrace_file *p = (vfstrace_file *)pFile; 358 vfstrace_info *pInfo = p->pInfo; 359 int rc; 360 char zBuf[100]; 361 char *zOp; 362 switch( op ){ 363 case SQLITE_FCNTL_LOCKSTATE: zOp = "LOCKSTATE"; break; 364 case SQLITE_GET_LOCKPROXYFILE: zOp = "GET_LOCKPROXYFILE"; break; 365 case SQLITE_SET_LOCKPROXYFILE: zOp = "SET_LOCKPROXYFILE"; break; 366 case SQLITE_LAST_ERRNO: zOp = "LAST_ERRNO"; break; 367 case SQLITE_FCNTL_SIZE_HINT: { 368 sqlite3_snprintf(sizeof(zBuf), zBuf, "SIZE_HINT,%lld", 369 *(sqlite3_int64*)pArg); 370 zOp = zBuf; 371 break; 372 } 373 case SQLITE_FCNTL_CHUNK_SIZE: { 374 sqlite3_snprintf(sizeof(zBuf), zBuf, "CHUNK_SIZE,%d", *(int*)pArg); 375 zOp = zBuf; 376 break; 377 } 378 case SQLITE_FCNTL_FILE_POINTER: zOp = "FILE_POINTER"; break; 379 case SQLITE_FCNTL_SYNC_OMITTED: zOp = "SYNC_OMITTED"; break; 380 case 0xca093fa0: zOp = "DB_UNCHANGED"; break; 381 default: { 382 sqlite3_snprintf(sizeof zBuf, zBuf, "%d", op); 383 zOp = zBuf; 384 break; 385 } 386 } 387 vfstrace_printf(pInfo, "%s.xFileControl(%s,%s)", 388 pInfo->zVfsName, p->zFName, zOp); 389 rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg); 390 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 391 return rc; 392 } 393 394 /* 395 ** Return the sector-size in bytes for an vfstrace-file. 396 */ 397 static int vfstraceSectorSize(sqlite3_file *pFile){ 398 vfstrace_file *p = (vfstrace_file *)pFile; 399 vfstrace_info *pInfo = p->pInfo; 400 int rc; 401 vfstrace_printf(pInfo, "%s.xSectorSize(%s)", pInfo->zVfsName, p->zFName); 402 rc = p->pReal->pMethods->xSectorSize(p->pReal); 403 vfstrace_printf(pInfo, " -> %d\n", rc); 404 return rc; 405 } 406 407 /* 408 ** Return the device characteristic flags supported by an vfstrace-file. 409 */ 410 static int vfstraceDeviceCharacteristics(sqlite3_file *pFile){ 411 vfstrace_file *p = (vfstrace_file *)pFile; 412 vfstrace_info *pInfo = p->pInfo; 413 int rc; 414 vfstrace_printf(pInfo, "%s.xDeviceCharacteristics(%s)", 415 pInfo->zVfsName, p->zFName); 416 rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal); 417 vfstrace_printf(pInfo, " -> 0x%08x\n", rc); 418 return rc; 419 } 420 421 /* 422 ** Shared-memory operations. 423 */ 424 static int vfstraceShmLock(sqlite3_file *pFile, int ofst, int n, int flags){ 425 vfstrace_file *p = (vfstrace_file *)pFile; 426 vfstrace_info *pInfo = p->pInfo; 427 int rc; 428 char zLck[100]; 429 int i = 0; 430 memcpy(zLck, "|0", 3); 431 if( flags & SQLITE_SHM_UNLOCK ) strappend(zLck, &i, "|UNLOCK"); 432 if( flags & SQLITE_SHM_LOCK ) strappend(zLck, &i, "|LOCK"); 433 if( flags & SQLITE_SHM_SHARED ) strappend(zLck, &i, "|SHARED"); 434 if( flags & SQLITE_SHM_EXCLUSIVE ) strappend(zLck, &i, "|EXCLUSIVE"); 435 if( flags & ~(0xf) ){ 436 sqlite3_snprintf(sizeof(zLck)-i, &zLck[i], "|0x%x", flags); 437 } 438 vfstrace_printf(pInfo, "%s.xShmLock(%s,ofst=%d,n=%d,%s)", 439 pInfo->zVfsName, p->zFName, ofst, n, &zLck[1]); 440 rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags); 441 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 442 return rc; 443 } 444 static int vfstraceShmMap( 445 sqlite3_file *pFile, 446 int iRegion, 447 int szRegion, 448 int isWrite, 449 void volatile **pp 450 ){ 451 vfstrace_file *p = (vfstrace_file *)pFile; 452 vfstrace_info *pInfo = p->pInfo; 453 int rc; 454 vfstrace_printf(pInfo, "%s.xShmMap(%s,iRegion=%d,szRegion=%d,isWrite=%d,*)", 455 pInfo->zVfsName, p->zFName, iRegion, szRegion, isWrite); 456 rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp); 457 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 458 return rc; 459 } 460 static void vfstraceShmBarrier(sqlite3_file *pFile){ 461 vfstrace_file *p = (vfstrace_file *)pFile; 462 vfstrace_info *pInfo = p->pInfo; 463 vfstrace_printf(pInfo, "%s.xShmBarrier(%s)\n", pInfo->zVfsName, p->zFName); 464 p->pReal->pMethods->xShmBarrier(p->pReal); 465 } 466 static int vfstraceShmUnmap(sqlite3_file *pFile, int delFlag){ 467 vfstrace_file *p = (vfstrace_file *)pFile; 468 vfstrace_info *pInfo = p->pInfo; 469 int rc; 470 vfstrace_printf(pInfo, "%s.xShmUnmap(%s,delFlag=%d)", 471 pInfo->zVfsName, p->zFName, delFlag); 472 rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag); 473 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 474 return rc; 475 } 476 477 478 479 /* 480 ** Open an vfstrace file handle. 481 */ 482 static int vfstraceOpen( 483 sqlite3_vfs *pVfs, 484 const char *zName, 485 sqlite3_file *pFile, 486 int flags, 487 int *pOutFlags 488 ){ 489 int rc; 490 vfstrace_file *p = (vfstrace_file *)pFile; 491 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 492 sqlite3_vfs *pRoot = pInfo->pRootVfs; 493 p->pInfo = pInfo; 494 p->zFName = zName ? fileTail(zName) : "<temp>"; 495 p->pReal = (sqlite3_file *)&p[1]; 496 rc = pRoot->xOpen(pRoot, zName, p->pReal, flags, pOutFlags); 497 vfstrace_printf(pInfo, "%s.xOpen(%s,flags=0x%x)", 498 pInfo->zVfsName, p->zFName, flags); 499 if( p->pReal->pMethods ){ 500 sqlite3_io_methods *pNew = sqlite3_malloc( sizeof(*pNew) ); 501 const sqlite3_io_methods *pSub = p->pReal->pMethods; 502 memset(pNew, 0, sizeof(*pNew)); 503 pNew->iVersion = pSub->iVersion; 504 pNew->xClose = vfstraceClose; 505 pNew->xRead = vfstraceRead; 506 pNew->xWrite = vfstraceWrite; 507 pNew->xTruncate = vfstraceTruncate; 508 pNew->xSync = vfstraceSync; 509 pNew->xFileSize = vfstraceFileSize; 510 pNew->xLock = vfstraceLock; 511 pNew->xUnlock = vfstraceUnlock; 512 pNew->xCheckReservedLock = vfstraceCheckReservedLock; 513 pNew->xFileControl = vfstraceFileControl; 514 pNew->xSectorSize = vfstraceSectorSize; 515 pNew->xDeviceCharacteristics = vfstraceDeviceCharacteristics; 516 if( pNew->iVersion>=2 ){ 517 pNew->xShmMap = pSub->xShmMap ? vfstraceShmMap : 0; 518 pNew->xShmLock = pSub->xShmLock ? vfstraceShmLock : 0; 519 pNew->xShmBarrier = pSub->xShmBarrier ? vfstraceShmBarrier : 0; 520 pNew->xShmUnmap = pSub->xShmUnmap ? vfstraceShmUnmap : 0; 521 } 522 pFile->pMethods = pNew; 523 } 524 vfstrace_print_errcode(pInfo, " -> %s", rc); 525 if( pOutFlags ){ 526 vfstrace_printf(pInfo, ", outFlags=0x%x\n", *pOutFlags); 527 }else{ 528 vfstrace_printf(pInfo, "\n"); 529 } 530 return rc; 531 } 532 533 /* 534 ** Delete the file located at zPath. If the dirSync argument is true, 535 ** ensure the file-system modifications are synced to disk before 536 ** returning. 537 */ 538 static int vfstraceDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 539 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 540 sqlite3_vfs *pRoot = pInfo->pRootVfs; 541 int rc; 542 vfstrace_printf(pInfo, "%s.xDelete(\"%s\",%d)", 543 pInfo->zVfsName, zPath, dirSync); 544 rc = pRoot->xDelete(pRoot, zPath, dirSync); 545 vfstrace_print_errcode(pInfo, " -> %s\n", rc); 546 return rc; 547 } 548 549 /* 550 ** Test for access permissions. Return true if the requested permission 551 ** is available, or false otherwise. 552 */ 553 static int vfstraceAccess( 554 sqlite3_vfs *pVfs, 555 const char *zPath, 556 int flags, 557 int *pResOut 558 ){ 559 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 560 sqlite3_vfs *pRoot = pInfo->pRootVfs; 561 int rc; 562 vfstrace_printf(pInfo, "%s.xDelete(\"%s\",%d)", 563 pInfo->zVfsName, zPath, flags); 564 rc = pRoot->xAccess(pRoot, zPath, flags, pResOut); 565 vfstrace_print_errcode(pInfo, " -> %s", rc); 566 vfstrace_printf(pInfo, ", out=%d\n", *pResOut); 567 return rc; 568 } 569 570 /* 571 ** Populate buffer zOut with the full canonical pathname corresponding 572 ** to the pathname in zPath. zOut is guaranteed to point to a buffer 573 ** of at least (DEVSYM_MAX_PATHNAME+1) bytes. 574 */ 575 static int vfstraceFullPathname( 576 sqlite3_vfs *pVfs, 577 const char *zPath, 578 int nOut, 579 char *zOut 580 ){ 581 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 582 sqlite3_vfs *pRoot = pInfo->pRootVfs; 583 int rc; 584 vfstrace_printf(pInfo, "%s.xFullPathname(\"%s\")", 585 pInfo->zVfsName, zPath); 586 rc = pRoot->xFullPathname(pRoot, zPath, nOut, zOut); 587 vfstrace_print_errcode(pInfo, " -> %s", rc); 588 vfstrace_printf(pInfo, ", out=\"%.*s\"\n", nOut, zOut); 589 return rc; 590 } 591 592 /* 593 ** Open the dynamic library located at zPath and return a handle. 594 */ 595 static void *vfstraceDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 596 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 597 sqlite3_vfs *pRoot = pInfo->pRootVfs; 598 vfstrace_printf(pInfo, "%s.xDlOpen(\"%s\")\n", pInfo->zVfsName, zPath); 599 return pRoot->xDlOpen(pRoot, zPath); 600 } 601 602 /* 603 ** Populate the buffer zErrMsg (size nByte bytes) with a human readable 604 ** utf-8 string describing the most recent error encountered associated 605 ** with dynamic libraries. 606 */ 607 static void vfstraceDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 608 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 609 sqlite3_vfs *pRoot = pInfo->pRootVfs; 610 vfstrace_printf(pInfo, "%s.xDlError(%d)", pInfo->zVfsName, nByte); 611 pRoot->xDlError(pRoot, nByte, zErrMsg); 612 vfstrace_printf(pInfo, " -> \"%s\"", zErrMsg); 613 } 614 615 /* 616 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle. 617 */ 618 static void (*vfstraceDlSym(sqlite3_vfs *pVfs,void *p,const char *zSym))(void){ 619 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 620 sqlite3_vfs *pRoot = pInfo->pRootVfs; 621 vfstrace_printf(pInfo, "%s.xDlSym(\"%s\")\n", pInfo->zVfsName, zSym); 622 return pRoot->xDlSym(pRoot, p, zSym); 623 } 624 625 /* 626 ** Close the dynamic library handle pHandle. 627 */ 628 static void vfstraceDlClose(sqlite3_vfs *pVfs, void *pHandle){ 629 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 630 sqlite3_vfs *pRoot = pInfo->pRootVfs; 631 vfstrace_printf(pInfo, "%s.xDlOpen()\n", pInfo->zVfsName); 632 pRoot->xDlClose(pRoot, pHandle); 633 } 634 635 /* 636 ** Populate the buffer pointed to by zBufOut with nByte bytes of 637 ** random data. 638 */ 639 static int vfstraceRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 640 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 641 sqlite3_vfs *pRoot = pInfo->pRootVfs; 642 vfstrace_printf(pInfo, "%s.xRandomness(%d)\n", pInfo->zVfsName, nByte); 643 return pRoot->xRandomness(pRoot, nByte, zBufOut); 644 } 645 646 /* 647 ** Sleep for nMicro microseconds. Return the number of microseconds 648 ** actually slept. 649 */ 650 static int vfstraceSleep(sqlite3_vfs *pVfs, int nMicro){ 651 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 652 sqlite3_vfs *pRoot = pInfo->pRootVfs; 653 return pRoot->xSleep(pRoot, nMicro); 654 } 655 656 /* 657 ** Return the current time as a Julian Day number in *pTimeOut. 658 */ 659 static int vfstraceCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 660 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 661 sqlite3_vfs *pRoot = pInfo->pRootVfs; 662 return pRoot->xCurrentTime(pRoot, pTimeOut); 663 } 664 static int vfstraceCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){ 665 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 666 sqlite3_vfs *pRoot = pInfo->pRootVfs; 667 return pRoot->xCurrentTimeInt64(pRoot, pTimeOut); 668 } 669 670 /* 671 ** Return th3 emost recent error code and message 672 */ 673 static int vfstraceGetLastError(sqlite3_vfs *pVfs, int iErr, char *zErr){ 674 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 675 sqlite3_vfs *pRoot = pInfo->pRootVfs; 676 return pRoot->xGetLastError(pRoot, iErr, zErr); 677 } 678 679 /* 680 ** Override system calls. 681 */ 682 static int vfstraceSetSystemCall( 683 sqlite3_vfs *pVfs, 684 const char *zName, 685 sqlite3_syscall_ptr pFunc 686 ){ 687 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 688 sqlite3_vfs *pRoot = pInfo->pRootVfs; 689 return pRoot->xSetSystemCall(pRoot, zName, pFunc); 690 } 691 static sqlite3_syscall_ptr vfstraceGetSystemCall( 692 sqlite3_vfs *pVfs, 693 const char *zName 694 ){ 695 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 696 sqlite3_vfs *pRoot = pInfo->pRootVfs; 697 return pRoot->xGetSystemCall(pRoot, zName); 698 } 699 static const char *vfstraceNextSystemCall(sqlite3_vfs *pVfs, const char *zName){ 700 vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; 701 sqlite3_vfs *pRoot = pInfo->pRootVfs; 702 return pRoot->xNextSystemCall(pRoot, zName); 703 } 704 705 706 /* 707 ** Clients invoke this routine to construct a new trace-vfs shim. 708 ** 709 ** Return SQLITE_OK on success. 710 ** 711 ** SQLITE_NOMEM is returned in the case of a memory allocation error. 712 ** SQLITE_NOTFOUND is returned if zOldVfsName does not exist. 713 */ 714 int vfstrace_register( 715 const char *zTraceName, /* Name of the newly constructed VFS */ 716 const char *zOldVfsName, /* Name of the underlying VFS */ 717 int (*xOut)(const char*,void*), /* Output routine. ex: fputs */ 718 void *pOutArg, /* 2nd argument to xOut. ex: stderr */ 719 int makeDefault /* True to make the new VFS the default */ 720 ){ 721 sqlite3_vfs *pNew; 722 sqlite3_vfs *pRoot; 723 vfstrace_info *pInfo; 724 int nName; 725 int nByte; 726 727 pRoot = sqlite3_vfs_find(zOldVfsName); 728 if( pRoot==0 ) return SQLITE_NOTFOUND; 729 nName = strlen(zTraceName); 730 nByte = sizeof(*pNew) + sizeof(*pInfo) + nName + 1; 731 pNew = sqlite3_malloc( nByte ); 732 if( pNew==0 ) return SQLITE_NOMEM; 733 memset(pNew, 0, nByte); 734 pInfo = (vfstrace_info*)&pNew[1]; 735 pNew->iVersion = pRoot->iVersion; 736 pNew->szOsFile = pRoot->szOsFile + sizeof(vfstrace_file); 737 pNew->mxPathname = pRoot->mxPathname; 738 pNew->zName = (char*)&pInfo[1]; 739 memcpy((char*)&pInfo[1], zTraceName, nName+1); 740 pNew->pAppData = pInfo; 741 pNew->xOpen = vfstraceOpen; 742 pNew->xDelete = vfstraceDelete; 743 pNew->xAccess = vfstraceAccess; 744 pNew->xFullPathname = vfstraceFullPathname; 745 pNew->xDlOpen = pRoot->xDlOpen==0 ? 0 : vfstraceDlOpen; 746 pNew->xDlError = pRoot->xDlError==0 ? 0 : vfstraceDlError; 747 pNew->xDlSym = pRoot->xDlSym==0 ? 0 : vfstraceDlSym; 748 pNew->xDlClose = pRoot->xDlClose==0 ? 0 : vfstraceDlClose; 749 pNew->xRandomness = vfstraceRandomness; 750 pNew->xSleep = vfstraceSleep; 751 pNew->xCurrentTime = vfstraceCurrentTime; 752 pNew->xGetLastError = pRoot->xGetLastError==0 ? 0 : vfstraceGetLastError; 753 if( pNew->iVersion>=2 ){ 754 pNew->xCurrentTimeInt64 = pRoot->xCurrentTimeInt64==0 ? 0 : 755 vfstraceCurrentTimeInt64; 756 if( pNew->iVersion>=3 ){ 757 pNew->xSetSystemCall = pRoot->xSetSystemCall==0 ? 0 : 758 vfstraceSetSystemCall; 759 pNew->xGetSystemCall = pRoot->xGetSystemCall==0 ? 0 : 760 vfstraceGetSystemCall; 761 pNew->xNextSystemCall = pRoot->xNextSystemCall==0 ? 0 : 762 vfstraceNextSystemCall; 763 } 764 } 765 pInfo->pRootVfs = pRoot; 766 pInfo->xOut = xOut; 767 pInfo->pOutArg = pOutArg; 768 pInfo->zVfsName = pNew->zName; 769 pInfo->pTraceVfs = pNew; 770 vfstrace_printf(pInfo, "%s.enabled_for(\"%s\")\n", 771 pInfo->zVfsName, pRoot->zName); 772 return sqlite3_vfs_register(pNew, makeDefault); 773 } 774
