Annotation of embedaddon/sqlite3/src/test_vfstrace.c, revision 1.1
1.1 ! misho 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: ** USAGE:
! 17: **
! 18: ** This source file exports a single symbol which is the name of a
! 19: ** function:
! 20: **
! 21: ** int vfstrace_register(
! 22: ** const char *zTraceName, // Name of the newly constructed VFS
! 23: ** const char *zOldVfsName, // Name of the underlying VFS
! 24: ** int (*xOut)(const char*,void*), // Output routine. ex: fputs
! 25: ** void *pOutArg, // 2nd argument to xOut. ex: stderr
! 26: ** int makeDefault // Make the new VFS the default
! 27: ** );
! 28: **
! 29: ** Applications that want to trace their VFS usage must provide a callback
! 30: ** function with this prototype:
! 31: **
! 32: ** int traceOutput(const char *zMessage, void *pAppData);
! 33: **
! 34: ** This function will "output" the trace messages, where "output" can
! 35: ** mean different things to different applications. The traceOutput function
! 36: ** for the command-line shell (see shell.c) is "fputs" from the standard
! 37: ** library, which means that all trace output is written on the stream
! 38: ** specified by the second argument. In the case of the command-line shell
! 39: ** the second argument is stderr. Other applications might choose to output
! 40: ** trace information to a file, over a socket, or write it into a buffer.
! 41: **
! 42: ** The vfstrace_register() function creates a new "shim" VFS named by
! 43: ** the zTraceName parameter. A "shim" VFS is an SQLite backend that does
! 44: ** not really perform the duties of a true backend, but simply filters or
! 45: ** interprets VFS calls before passing them off to another VFS which does
! 46: ** the actual work. In this case the other VFS - the one that does the
! 47: ** real work - is identified by the second parameter, zOldVfsName. If
! 48: ** the the 2nd parameter is NULL then the default VFS is used. The common
! 49: ** case is for the 2nd parameter to be NULL.
! 50: **
! 51: ** The third and fourth parameters are the pointer to the output function
! 52: ** and the second argument to the output function. For the SQLite
! 53: ** command-line shell, when the -vfstrace option is used, these parameters
! 54: ** are fputs and stderr, respectively.
! 55: **
! 56: ** The fifth argument is true (non-zero) to cause the newly created VFS
! 57: ** to become the default VFS. The common case is for the fifth parameter
! 58: ** to be true.
! 59: **
! 60: ** The call to vfstrace_register() simply creates the shim VFS that does
! 61: ** tracing. The application must also arrange to use the new VFS for
! 62: ** all database connections that are created and for which tracing is
! 63: ** desired. This can be done by specifying the trace VFS using URI filename
! 64: ** notation, or by specifying the trace VFS as the 4th parameter to
! 65: ** sqlite3_open_v2() or by making the trace VFS be the default (by setting
! 66: ** the 5th parameter of vfstrace_register() to 1).
! 67: **
! 68: **
! 69: ** ENABLING VFSTRACE IN A COMMAND-LINE SHELL
! 70: **
! 71: ** The SQLite command line shell implemented by the shell.c source file
! 72: ** can be used with this module. To compile in -vfstrace support, first
! 73: ** gather this file (test_vfstrace.c), the shell source file (shell.c),
! 74: ** and the SQLite amalgamation source files (sqlite3.c, sqlite3.h) into
! 75: ** the working directory. Then compile using a command like the following:
! 76: **
! 77: ** gcc -o sqlite3 -Os -I. -DSQLITE_ENABLE_VFSTRACE \
! 78: ** -DSQLITE_THREADSAFE=0 -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_RTREE \
! 79: ** -DHAVE_READLINE -DHAVE_USLEEP=1 \
! 80: ** shell.c test_vfstrace.c sqlite3.c -ldl -lreadline -lncurses
! 81: **
! 82: ** The gcc command above works on Linux and provides (in addition to the
! 83: ** -vfstrace option) support for FTS3 and FTS4, RTREE, and command-line
! 84: ** editing using the readline library. The command-line shell does not
! 85: ** use threads so we added -DSQLITE_THREADSAFE=0 just to make the code
! 86: ** run a little faster. For compiling on a Mac, you'll probably need
! 87: ** to omit the -DHAVE_READLINE, the -lreadline, and the -lncurses options.
! 88: ** The compilation could be simplified to just this:
! 89: **
! 90: ** gcc -DSQLITE_ENABLE_VFSTRACE \
! 91: ** shell.c test_vfstrace.c sqlite3.c -ldl -lpthread
! 92: **
! 93: ** In this second example, all unnecessary options have been removed
! 94: ** Note that since the code is now threadsafe, we had to add the -lpthread
! 95: ** option to pull in the pthreads library.
! 96: **
! 97: ** To cross-compile for windows using MinGW, a command like this might
! 98: ** work:
! 99: **
! 100: ** /opt/mingw/bin/i386-mingw32msvc-gcc -o sqlite3.exe -Os -I \
! 101: ** -DSQLITE_THREADSAFE=0 -DSQLITE_ENABLE_VFSTRACE \
! 102: ** shell.c test_vfstrace.c sqlite3.c
! 103: **
! 104: ** Similar compiler commands will work on different systems. The key
! 105: ** invariants are (1) you must have -DSQLITE_ENABLE_VFSTRACE so that
! 106: ** the shell.c source file will know to include the -vfstrace command-line
! 107: ** option and (2) you must compile and link the three source files
! 108: ** shell,c, test_vfstrace.c, and sqlite3.c.
! 109: */
! 110: #include <stdlib.h>
! 111: #include <string.h>
! 112: #include "sqlite3.h"
! 113:
! 114: /*
! 115: ** An instance of this structure is attached to the each trace VFS to
! 116: ** provide auxiliary information.
! 117: */
! 118: typedef struct vfstrace_info vfstrace_info;
! 119: struct vfstrace_info {
! 120: sqlite3_vfs *pRootVfs; /* The underlying real VFS */
! 121: int (*xOut)(const char*, void*); /* Send output here */
! 122: void *pOutArg; /* First argument to xOut */
! 123: const char *zVfsName; /* Name of this trace-VFS */
! 124: sqlite3_vfs *pTraceVfs; /* Pointer back to the trace VFS */
! 125: };
! 126:
! 127: /*
! 128: ** The sqlite3_file object for the trace VFS
! 129: */
! 130: typedef struct vfstrace_file vfstrace_file;
! 131: struct vfstrace_file {
! 132: sqlite3_file base; /* Base class. Must be first */
! 133: vfstrace_info *pInfo; /* The trace-VFS to which this file belongs */
! 134: const char *zFName; /* Base name of the file */
! 135: sqlite3_file *pReal; /* The real underlying file */
! 136: };
! 137:
! 138: /*
! 139: ** Method declarations for vfstrace_file.
! 140: */
! 141: static int vfstraceClose(sqlite3_file*);
! 142: static int vfstraceRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
! 143: static int vfstraceWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64);
! 144: static int vfstraceTruncate(sqlite3_file*, sqlite3_int64 size);
! 145: static int vfstraceSync(sqlite3_file*, int flags);
! 146: static int vfstraceFileSize(sqlite3_file*, sqlite3_int64 *pSize);
! 147: static int vfstraceLock(sqlite3_file*, int);
! 148: static int vfstraceUnlock(sqlite3_file*, int);
! 149: static int vfstraceCheckReservedLock(sqlite3_file*, int *);
! 150: static int vfstraceFileControl(sqlite3_file*, int op, void *pArg);
! 151: static int vfstraceSectorSize(sqlite3_file*);
! 152: static int vfstraceDeviceCharacteristics(sqlite3_file*);
! 153: static int vfstraceShmLock(sqlite3_file*,int,int,int);
! 154: static int vfstraceShmMap(sqlite3_file*,int,int,int, void volatile **);
! 155: static void vfstraceShmBarrier(sqlite3_file*);
! 156: static int vfstraceShmUnmap(sqlite3_file*,int);
! 157:
! 158: /*
! 159: ** Method declarations for vfstrace_vfs.
! 160: */
! 161: static int vfstraceOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
! 162: static int vfstraceDelete(sqlite3_vfs*, const char *zName, int syncDir);
! 163: static int vfstraceAccess(sqlite3_vfs*, const char *zName, int flags, int *);
! 164: static int vfstraceFullPathname(sqlite3_vfs*, const char *zName, int, char *);
! 165: static void *vfstraceDlOpen(sqlite3_vfs*, const char *zFilename);
! 166: static void vfstraceDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
! 167: static void (*vfstraceDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);
! 168: static void vfstraceDlClose(sqlite3_vfs*, void*);
! 169: static int vfstraceRandomness(sqlite3_vfs*, int nByte, char *zOut);
! 170: static int vfstraceSleep(sqlite3_vfs*, int microseconds);
! 171: static int vfstraceCurrentTime(sqlite3_vfs*, double*);
! 172: static int vfstraceGetLastError(sqlite3_vfs*, int, char*);
! 173: static int vfstraceCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
! 174: static int vfstraceSetSystemCall(sqlite3_vfs*,const char*, sqlite3_syscall_ptr);
! 175: static sqlite3_syscall_ptr vfstraceGetSystemCall(sqlite3_vfs*, const char *);
! 176: static const char *vfstraceNextSystemCall(sqlite3_vfs*, const char *zName);
! 177:
! 178: /*
! 179: ** Return a pointer to the tail of the pathname. Examples:
! 180: **
! 181: ** /home/drh/xyzzy.txt -> xyzzy.txt
! 182: ** xyzzy.txt -> xyzzy.txt
! 183: */
! 184: static const char *fileTail(const char *z){
! 185: int i;
! 186: if( z==0 ) return 0;
! 187: i = strlen(z)-1;
! 188: while( i>0 && z[i-1]!='/' ){ i--; }
! 189: return &z[i];
! 190: }
! 191:
! 192: /*
! 193: ** Send trace output defined by zFormat and subsequent arguments.
! 194: */
! 195: static void vfstrace_printf(
! 196: vfstrace_info *pInfo,
! 197: const char *zFormat,
! 198: ...
! 199: ){
! 200: va_list ap;
! 201: char *zMsg;
! 202: va_start(ap, zFormat);
! 203: zMsg = sqlite3_vmprintf(zFormat, ap);
! 204: va_end(ap);
! 205: pInfo->xOut(zMsg, pInfo->pOutArg);
! 206: sqlite3_free(zMsg);
! 207: }
! 208:
! 209: /*
! 210: ** Convert value rc into a string and print it using zFormat. zFormat
! 211: ** should have exactly one %s
! 212: */
! 213: static void vfstrace_print_errcode(
! 214: vfstrace_info *pInfo,
! 215: const char *zFormat,
! 216: int rc
! 217: ){
! 218: char zBuf[50];
! 219: char *zVal;
! 220: switch( rc ){
! 221: case SQLITE_OK: zVal = "SQLITE_OK"; break;
! 222: case SQLITE_ERROR: zVal = "SQLITE_ERROR"; break;
! 223: case SQLITE_PERM: zVal = "SQLITE_PERM"; break;
! 224: case SQLITE_ABORT: zVal = "SQLITE_ABORT"; break;
! 225: case SQLITE_BUSY: zVal = "SQLITE_BUSY"; break;
! 226: case SQLITE_NOMEM: zVal = "SQLITE_NOMEM"; break;
! 227: case SQLITE_READONLY: zVal = "SQLITE_READONLY"; break;
! 228: case SQLITE_INTERRUPT: zVal = "SQLITE_INTERRUPT"; break;
! 229: case SQLITE_IOERR: zVal = "SQLITE_IOERR"; break;
! 230: case SQLITE_CORRUPT: zVal = "SQLITE_CORRUPT"; break;
! 231: case SQLITE_FULL: zVal = "SQLITE_FULL"; break;
! 232: case SQLITE_CANTOPEN: zVal = "SQLITE_CANTOPEN"; break;
! 233: case SQLITE_PROTOCOL: zVal = "SQLITE_PROTOCOL"; break;
! 234: case SQLITE_EMPTY: zVal = "SQLITE_EMPTY"; break;
! 235: case SQLITE_SCHEMA: zVal = "SQLITE_SCHEMA"; break;
! 236: case SQLITE_CONSTRAINT: zVal = "SQLITE_CONSTRAINT"; break;
! 237: case SQLITE_MISMATCH: zVal = "SQLITE_MISMATCH"; break;
! 238: case SQLITE_MISUSE: zVal = "SQLITE_MISUSE"; break;
! 239: case SQLITE_NOLFS: zVal = "SQLITE_NOLFS"; break;
! 240: case SQLITE_IOERR_READ: zVal = "SQLITE_IOERR_READ"; break;
! 241: case SQLITE_IOERR_SHORT_READ: zVal = "SQLITE_IOERR_SHORT_READ"; break;
! 242: case SQLITE_IOERR_WRITE: zVal = "SQLITE_IOERR_WRITE"; break;
! 243: case SQLITE_IOERR_FSYNC: zVal = "SQLITE_IOERR_FSYNC"; break;
! 244: case SQLITE_IOERR_DIR_FSYNC: zVal = "SQLITE_IOERR_DIR_FSYNC"; break;
! 245: case SQLITE_IOERR_TRUNCATE: zVal = "SQLITE_IOERR_TRUNCATE"; break;
! 246: case SQLITE_IOERR_FSTAT: zVal = "SQLITE_IOERR_FSTAT"; break;
! 247: case SQLITE_IOERR_UNLOCK: zVal = "SQLITE_IOERR_UNLOCK"; break;
! 248: case SQLITE_IOERR_RDLOCK: zVal = "SQLITE_IOERR_RDLOCK"; break;
! 249: case SQLITE_IOERR_DELETE: zVal = "SQLITE_IOERR_DELETE"; break;
! 250: case SQLITE_IOERR_BLOCKED: zVal = "SQLITE_IOERR_BLOCKED"; break;
! 251: case SQLITE_IOERR_NOMEM: zVal = "SQLITE_IOERR_NOMEM"; break;
! 252: case SQLITE_IOERR_ACCESS: zVal = "SQLITE_IOERR_ACCESS"; break;
! 253: case SQLITE_IOERR_CHECKRESERVEDLOCK:
! 254: zVal = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
! 255: case SQLITE_IOERR_LOCK: zVal = "SQLITE_IOERR_LOCK"; break;
! 256: case SQLITE_IOERR_CLOSE: zVal = "SQLITE_IOERR_CLOSE"; break;
! 257: case SQLITE_IOERR_DIR_CLOSE: zVal = "SQLITE_IOERR_DIR_CLOSE"; break;
! 258: case SQLITE_IOERR_SHMOPEN: zVal = "SQLITE_IOERR_SHMOPEN"; break;
! 259: case SQLITE_IOERR_SHMSIZE: zVal = "SQLITE_IOERR_SHMSIZE"; break;
! 260: case SQLITE_IOERR_SHMLOCK: zVal = "SQLITE_IOERR_SHMLOCK"; break;
! 261: case SQLITE_LOCKED_SHAREDCACHE: zVal = "SQLITE_LOCKED_SHAREDCACHE"; break;
! 262: case SQLITE_BUSY_RECOVERY: zVal = "SQLITE_BUSY_RECOVERY"; break;
! 263: case SQLITE_CANTOPEN_NOTEMPDIR: zVal = "SQLITE_CANTOPEN_NOTEMPDIR"; break;
! 264: default: {
! 265: sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc);
! 266: zVal = zBuf;
! 267: break;
! 268: }
! 269: }
! 270: vfstrace_printf(pInfo, zFormat, zVal);
! 271: }
! 272:
! 273: /*
! 274: ** Append to a buffer.
! 275: */
! 276: static void strappend(char *z, int *pI, const char *zAppend){
! 277: int i = *pI;
! 278: while( zAppend[0] ){ z[i++] = *(zAppend++); }
! 279: z[i] = 0;
! 280: *pI = i;
! 281: }
! 282:
! 283: /*
! 284: ** Close an vfstrace-file.
! 285: */
! 286: static int vfstraceClose(sqlite3_file *pFile){
! 287: vfstrace_file *p = (vfstrace_file *)pFile;
! 288: vfstrace_info *pInfo = p->pInfo;
! 289: int rc;
! 290: vfstrace_printf(pInfo, "%s.xClose(%s)", pInfo->zVfsName, p->zFName);
! 291: rc = p->pReal->pMethods->xClose(p->pReal);
! 292: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 293: if( rc==SQLITE_OK ){
! 294: sqlite3_free((void*)p->base.pMethods);
! 295: p->base.pMethods = 0;
! 296: }
! 297: return rc;
! 298: }
! 299:
! 300: /*
! 301: ** Read data from an vfstrace-file.
! 302: */
! 303: static int vfstraceRead(
! 304: sqlite3_file *pFile,
! 305: void *zBuf,
! 306: int iAmt,
! 307: sqlite_int64 iOfst
! 308: ){
! 309: vfstrace_file *p = (vfstrace_file *)pFile;
! 310: vfstrace_info *pInfo = p->pInfo;
! 311: int rc;
! 312: vfstrace_printf(pInfo, "%s.xRead(%s,n=%d,ofst=%lld)",
! 313: pInfo->zVfsName, p->zFName, iAmt, iOfst);
! 314: rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
! 315: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 316: return rc;
! 317: }
! 318:
! 319: /*
! 320: ** Write data to an vfstrace-file.
! 321: */
! 322: static int vfstraceWrite(
! 323: sqlite3_file *pFile,
! 324: const void *zBuf,
! 325: int iAmt,
! 326: sqlite_int64 iOfst
! 327: ){
! 328: vfstrace_file *p = (vfstrace_file *)pFile;
! 329: vfstrace_info *pInfo = p->pInfo;
! 330: int rc;
! 331: vfstrace_printf(pInfo, "%s.xWrite(%s,n=%d,ofst=%lld)",
! 332: pInfo->zVfsName, p->zFName, iAmt, iOfst);
! 333: rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
! 334: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 335: return rc;
! 336: }
! 337:
! 338: /*
! 339: ** Truncate an vfstrace-file.
! 340: */
! 341: static int vfstraceTruncate(sqlite3_file *pFile, sqlite_int64 size){
! 342: vfstrace_file *p = (vfstrace_file *)pFile;
! 343: vfstrace_info *pInfo = p->pInfo;
! 344: int rc;
! 345: vfstrace_printf(pInfo, "%s.xTruncate(%s,%lld)", pInfo->zVfsName, p->zFName,
! 346: size);
! 347: rc = p->pReal->pMethods->xTruncate(p->pReal, size);
! 348: vfstrace_printf(pInfo, " -> %d\n", rc);
! 349: return rc;
! 350: }
! 351:
! 352: /*
! 353: ** Sync an vfstrace-file.
! 354: */
! 355: static int vfstraceSync(sqlite3_file *pFile, int flags){
! 356: vfstrace_file *p = (vfstrace_file *)pFile;
! 357: vfstrace_info *pInfo = p->pInfo;
! 358: int rc;
! 359: int i;
! 360: char zBuf[100];
! 361: memcpy(zBuf, "|0", 3);
! 362: i = 0;
! 363: if( flags & SQLITE_SYNC_FULL ) strappend(zBuf, &i, "|FULL");
! 364: else if( flags & SQLITE_SYNC_NORMAL ) strappend(zBuf, &i, "|NORMAL");
! 365: if( flags & SQLITE_SYNC_DATAONLY ) strappend(zBuf, &i, "|DATAONLY");
! 366: if( flags & ~(SQLITE_SYNC_FULL|SQLITE_SYNC_DATAONLY) ){
! 367: sqlite3_snprintf(sizeof(zBuf)-i, &zBuf[i], "|0x%x", flags);
! 368: }
! 369: vfstrace_printf(pInfo, "%s.xSync(%s,%s)", pInfo->zVfsName, p->zFName,
! 370: &zBuf[1]);
! 371: rc = p->pReal->pMethods->xSync(p->pReal, flags);
! 372: vfstrace_printf(pInfo, " -> %d\n", rc);
! 373: return rc;
! 374: }
! 375:
! 376: /*
! 377: ** Return the current file-size of an vfstrace-file.
! 378: */
! 379: static int vfstraceFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
! 380: vfstrace_file *p = (vfstrace_file *)pFile;
! 381: vfstrace_info *pInfo = p->pInfo;
! 382: int rc;
! 383: vfstrace_printf(pInfo, "%s.xFileSize(%s)", pInfo->zVfsName, p->zFName);
! 384: rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
! 385: vfstrace_print_errcode(pInfo, " -> %s,", rc);
! 386: vfstrace_printf(pInfo, " size=%lld\n", *pSize);
! 387: return rc;
! 388: }
! 389:
! 390: /*
! 391: ** Return the name of a lock.
! 392: */
! 393: static const char *lockName(int eLock){
! 394: const char *azLockNames[] = {
! 395: "NONE", "SHARED", "RESERVED", "PENDING", "EXCLUSIVE"
! 396: };
! 397: if( eLock<0 || eLock>=sizeof(azLockNames)/sizeof(azLockNames[0]) ){
! 398: return "???";
! 399: }else{
! 400: return azLockNames[eLock];
! 401: }
! 402: }
! 403:
! 404: /*
! 405: ** Lock an vfstrace-file.
! 406: */
! 407: static int vfstraceLock(sqlite3_file *pFile, int eLock){
! 408: vfstrace_file *p = (vfstrace_file *)pFile;
! 409: vfstrace_info *pInfo = p->pInfo;
! 410: int rc;
! 411: vfstrace_printf(pInfo, "%s.xLock(%s,%s)", pInfo->zVfsName, p->zFName,
! 412: lockName(eLock));
! 413: rc = p->pReal->pMethods->xLock(p->pReal, eLock);
! 414: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 415: return rc;
! 416: }
! 417:
! 418: /*
! 419: ** Unlock an vfstrace-file.
! 420: */
! 421: static int vfstraceUnlock(sqlite3_file *pFile, int eLock){
! 422: vfstrace_file *p = (vfstrace_file *)pFile;
! 423: vfstrace_info *pInfo = p->pInfo;
! 424: int rc;
! 425: vfstrace_printf(pInfo, "%s.xUnlock(%s,%s)", pInfo->zVfsName, p->zFName,
! 426: lockName(eLock));
! 427: rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
! 428: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 429: return rc;
! 430: }
! 431:
! 432: /*
! 433: ** Check if another file-handle holds a RESERVED lock on an vfstrace-file.
! 434: */
! 435: static int vfstraceCheckReservedLock(sqlite3_file *pFile, int *pResOut){
! 436: vfstrace_file *p = (vfstrace_file *)pFile;
! 437: vfstrace_info *pInfo = p->pInfo;
! 438: int rc;
! 439: vfstrace_printf(pInfo, "%s.xCheckReservedLock(%s,%d)",
! 440: pInfo->zVfsName, p->zFName);
! 441: rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
! 442: vfstrace_print_errcode(pInfo, " -> %s", rc);
! 443: vfstrace_printf(pInfo, ", out=%d\n", *pResOut);
! 444: return rc;
! 445: }
! 446:
! 447: /*
! 448: ** File control method. For custom operations on an vfstrace-file.
! 449: */
! 450: static int vfstraceFileControl(sqlite3_file *pFile, int op, void *pArg){
! 451: vfstrace_file *p = (vfstrace_file *)pFile;
! 452: vfstrace_info *pInfo = p->pInfo;
! 453: int rc;
! 454: char zBuf[100];
! 455: char *zOp;
! 456: switch( op ){
! 457: case SQLITE_FCNTL_LOCKSTATE: zOp = "LOCKSTATE"; break;
! 458: case SQLITE_GET_LOCKPROXYFILE: zOp = "GET_LOCKPROXYFILE"; break;
! 459: case SQLITE_SET_LOCKPROXYFILE: zOp = "SET_LOCKPROXYFILE"; break;
! 460: case SQLITE_LAST_ERRNO: zOp = "LAST_ERRNO"; break;
! 461: case SQLITE_FCNTL_SIZE_HINT: {
! 462: sqlite3_snprintf(sizeof(zBuf), zBuf, "SIZE_HINT,%lld",
! 463: *(sqlite3_int64*)pArg);
! 464: zOp = zBuf;
! 465: break;
! 466: }
! 467: case SQLITE_FCNTL_CHUNK_SIZE: {
! 468: sqlite3_snprintf(sizeof(zBuf), zBuf, "CHUNK_SIZE,%d", *(int*)pArg);
! 469: zOp = zBuf;
! 470: break;
! 471: }
! 472: case SQLITE_FCNTL_FILE_POINTER: zOp = "FILE_POINTER"; break;
! 473: case SQLITE_FCNTL_SYNC_OMITTED: zOp = "SYNC_OMITTED"; break;
! 474: case SQLITE_FCNTL_WIN32_AV_RETRY: zOp = "WIN32_AV_RETRY"; break;
! 475: case SQLITE_FCNTL_PERSIST_WAL: zOp = "PERSIST_WAL"; break;
! 476: case SQLITE_FCNTL_OVERWRITE: zOp = "OVERWRITE"; break;
! 477: case SQLITE_FCNTL_VFSNAME: zOp = "VFSNAME"; break;
! 478: case 0xca093fa0: zOp = "DB_UNCHANGED"; break;
! 479: default: {
! 480: sqlite3_snprintf(sizeof zBuf, zBuf, "%d", op);
! 481: zOp = zBuf;
! 482: break;
! 483: }
! 484: }
! 485: vfstrace_printf(pInfo, "%s.xFileControl(%s,%s)",
! 486: pInfo->zVfsName, p->zFName, zOp);
! 487: rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
! 488: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 489: if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
! 490: *(char**)pArg = sqlite3_mprintf("vfstrace.%s/%z",
! 491: pInfo->zVfsName, *(char**)pArg);
! 492: }
! 493: return rc;
! 494: }
! 495:
! 496: /*
! 497: ** Return the sector-size in bytes for an vfstrace-file.
! 498: */
! 499: static int vfstraceSectorSize(sqlite3_file *pFile){
! 500: vfstrace_file *p = (vfstrace_file *)pFile;
! 501: vfstrace_info *pInfo = p->pInfo;
! 502: int rc;
! 503: vfstrace_printf(pInfo, "%s.xSectorSize(%s)", pInfo->zVfsName, p->zFName);
! 504: rc = p->pReal->pMethods->xSectorSize(p->pReal);
! 505: vfstrace_printf(pInfo, " -> %d\n", rc);
! 506: return rc;
! 507: }
! 508:
! 509: /*
! 510: ** Return the device characteristic flags supported by an vfstrace-file.
! 511: */
! 512: static int vfstraceDeviceCharacteristics(sqlite3_file *pFile){
! 513: vfstrace_file *p = (vfstrace_file *)pFile;
! 514: vfstrace_info *pInfo = p->pInfo;
! 515: int rc;
! 516: vfstrace_printf(pInfo, "%s.xDeviceCharacteristics(%s)",
! 517: pInfo->zVfsName, p->zFName);
! 518: rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
! 519: vfstrace_printf(pInfo, " -> 0x%08x\n", rc);
! 520: return rc;
! 521: }
! 522:
! 523: /*
! 524: ** Shared-memory operations.
! 525: */
! 526: static int vfstraceShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
! 527: vfstrace_file *p = (vfstrace_file *)pFile;
! 528: vfstrace_info *pInfo = p->pInfo;
! 529: int rc;
! 530: char zLck[100];
! 531: int i = 0;
! 532: memcpy(zLck, "|0", 3);
! 533: if( flags & SQLITE_SHM_UNLOCK ) strappend(zLck, &i, "|UNLOCK");
! 534: if( flags & SQLITE_SHM_LOCK ) strappend(zLck, &i, "|LOCK");
! 535: if( flags & SQLITE_SHM_SHARED ) strappend(zLck, &i, "|SHARED");
! 536: if( flags & SQLITE_SHM_EXCLUSIVE ) strappend(zLck, &i, "|EXCLUSIVE");
! 537: if( flags & ~(0xf) ){
! 538: sqlite3_snprintf(sizeof(zLck)-i, &zLck[i], "|0x%x", flags);
! 539: }
! 540: vfstrace_printf(pInfo, "%s.xShmLock(%s,ofst=%d,n=%d,%s)",
! 541: pInfo->zVfsName, p->zFName, ofst, n, &zLck[1]);
! 542: rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
! 543: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 544: return rc;
! 545: }
! 546: static int vfstraceShmMap(
! 547: sqlite3_file *pFile,
! 548: int iRegion,
! 549: int szRegion,
! 550: int isWrite,
! 551: void volatile **pp
! 552: ){
! 553: vfstrace_file *p = (vfstrace_file *)pFile;
! 554: vfstrace_info *pInfo = p->pInfo;
! 555: int rc;
! 556: vfstrace_printf(pInfo, "%s.xShmMap(%s,iRegion=%d,szRegion=%d,isWrite=%d,*)",
! 557: pInfo->zVfsName, p->zFName, iRegion, szRegion, isWrite);
! 558: rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
! 559: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 560: return rc;
! 561: }
! 562: static void vfstraceShmBarrier(sqlite3_file *pFile){
! 563: vfstrace_file *p = (vfstrace_file *)pFile;
! 564: vfstrace_info *pInfo = p->pInfo;
! 565: vfstrace_printf(pInfo, "%s.xShmBarrier(%s)\n", pInfo->zVfsName, p->zFName);
! 566: p->pReal->pMethods->xShmBarrier(p->pReal);
! 567: }
! 568: static int vfstraceShmUnmap(sqlite3_file *pFile, int delFlag){
! 569: vfstrace_file *p = (vfstrace_file *)pFile;
! 570: vfstrace_info *pInfo = p->pInfo;
! 571: int rc;
! 572: vfstrace_printf(pInfo, "%s.xShmUnmap(%s,delFlag=%d)",
! 573: pInfo->zVfsName, p->zFName, delFlag);
! 574: rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
! 575: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 576: return rc;
! 577: }
! 578:
! 579:
! 580:
! 581: /*
! 582: ** Open an vfstrace file handle.
! 583: */
! 584: static int vfstraceOpen(
! 585: sqlite3_vfs *pVfs,
! 586: const char *zName,
! 587: sqlite3_file *pFile,
! 588: int flags,
! 589: int *pOutFlags
! 590: ){
! 591: int rc;
! 592: vfstrace_file *p = (vfstrace_file *)pFile;
! 593: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 594: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 595: p->pInfo = pInfo;
! 596: p->zFName = zName ? fileTail(zName) : "<temp>";
! 597: p->pReal = (sqlite3_file *)&p[1];
! 598: rc = pRoot->xOpen(pRoot, zName, p->pReal, flags, pOutFlags);
! 599: vfstrace_printf(pInfo, "%s.xOpen(%s,flags=0x%x)",
! 600: pInfo->zVfsName, p->zFName, flags);
! 601: if( p->pReal->pMethods ){
! 602: sqlite3_io_methods *pNew = sqlite3_malloc( sizeof(*pNew) );
! 603: const sqlite3_io_methods *pSub = p->pReal->pMethods;
! 604: memset(pNew, 0, sizeof(*pNew));
! 605: pNew->iVersion = pSub->iVersion;
! 606: pNew->xClose = vfstraceClose;
! 607: pNew->xRead = vfstraceRead;
! 608: pNew->xWrite = vfstraceWrite;
! 609: pNew->xTruncate = vfstraceTruncate;
! 610: pNew->xSync = vfstraceSync;
! 611: pNew->xFileSize = vfstraceFileSize;
! 612: pNew->xLock = vfstraceLock;
! 613: pNew->xUnlock = vfstraceUnlock;
! 614: pNew->xCheckReservedLock = vfstraceCheckReservedLock;
! 615: pNew->xFileControl = vfstraceFileControl;
! 616: pNew->xSectorSize = vfstraceSectorSize;
! 617: pNew->xDeviceCharacteristics = vfstraceDeviceCharacteristics;
! 618: if( pNew->iVersion>=2 ){
! 619: pNew->xShmMap = pSub->xShmMap ? vfstraceShmMap : 0;
! 620: pNew->xShmLock = pSub->xShmLock ? vfstraceShmLock : 0;
! 621: pNew->xShmBarrier = pSub->xShmBarrier ? vfstraceShmBarrier : 0;
! 622: pNew->xShmUnmap = pSub->xShmUnmap ? vfstraceShmUnmap : 0;
! 623: }
! 624: pFile->pMethods = pNew;
! 625: }
! 626: vfstrace_print_errcode(pInfo, " -> %s", rc);
! 627: if( pOutFlags ){
! 628: vfstrace_printf(pInfo, ", outFlags=0x%x\n", *pOutFlags);
! 629: }else{
! 630: vfstrace_printf(pInfo, "\n");
! 631: }
! 632: return rc;
! 633: }
! 634:
! 635: /*
! 636: ** Delete the file located at zPath. If the dirSync argument is true,
! 637: ** ensure the file-system modifications are synced to disk before
! 638: ** returning.
! 639: */
! 640: static int vfstraceDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
! 641: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 642: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 643: int rc;
! 644: vfstrace_printf(pInfo, "%s.xDelete(\"%s\",%d)",
! 645: pInfo->zVfsName, zPath, dirSync);
! 646: rc = pRoot->xDelete(pRoot, zPath, dirSync);
! 647: vfstrace_print_errcode(pInfo, " -> %s\n", rc);
! 648: return rc;
! 649: }
! 650:
! 651: /*
! 652: ** Test for access permissions. Return true if the requested permission
! 653: ** is available, or false otherwise.
! 654: */
! 655: static int vfstraceAccess(
! 656: sqlite3_vfs *pVfs,
! 657: const char *zPath,
! 658: int flags,
! 659: int *pResOut
! 660: ){
! 661: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 662: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 663: int rc;
! 664: vfstrace_printf(pInfo, "%s.xDelete(\"%s\",%d)",
! 665: pInfo->zVfsName, zPath, flags);
! 666: rc = pRoot->xAccess(pRoot, zPath, flags, pResOut);
! 667: vfstrace_print_errcode(pInfo, " -> %s", rc);
! 668: vfstrace_printf(pInfo, ", out=%d\n", *pResOut);
! 669: return rc;
! 670: }
! 671:
! 672: /*
! 673: ** Populate buffer zOut with the full canonical pathname corresponding
! 674: ** to the pathname in zPath. zOut is guaranteed to point to a buffer
! 675: ** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
! 676: */
! 677: static int vfstraceFullPathname(
! 678: sqlite3_vfs *pVfs,
! 679: const char *zPath,
! 680: int nOut,
! 681: char *zOut
! 682: ){
! 683: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 684: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 685: int rc;
! 686: vfstrace_printf(pInfo, "%s.xFullPathname(\"%s\")",
! 687: pInfo->zVfsName, zPath);
! 688: rc = pRoot->xFullPathname(pRoot, zPath, nOut, zOut);
! 689: vfstrace_print_errcode(pInfo, " -> %s", rc);
! 690: vfstrace_printf(pInfo, ", out=\"%.*s\"\n", nOut, zOut);
! 691: return rc;
! 692: }
! 693:
! 694: /*
! 695: ** Open the dynamic library located at zPath and return a handle.
! 696: */
! 697: static void *vfstraceDlOpen(sqlite3_vfs *pVfs, const char *zPath){
! 698: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 699: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 700: vfstrace_printf(pInfo, "%s.xDlOpen(\"%s\")\n", pInfo->zVfsName, zPath);
! 701: return pRoot->xDlOpen(pRoot, zPath);
! 702: }
! 703:
! 704: /*
! 705: ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
! 706: ** utf-8 string describing the most recent error encountered associated
! 707: ** with dynamic libraries.
! 708: */
! 709: static void vfstraceDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
! 710: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 711: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 712: vfstrace_printf(pInfo, "%s.xDlError(%d)", pInfo->zVfsName, nByte);
! 713: pRoot->xDlError(pRoot, nByte, zErrMsg);
! 714: vfstrace_printf(pInfo, " -> \"%s\"", zErrMsg);
! 715: }
! 716:
! 717: /*
! 718: ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
! 719: */
! 720: static void (*vfstraceDlSym(sqlite3_vfs *pVfs,void *p,const char *zSym))(void){
! 721: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 722: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 723: vfstrace_printf(pInfo, "%s.xDlSym(\"%s\")\n", pInfo->zVfsName, zSym);
! 724: return pRoot->xDlSym(pRoot, p, zSym);
! 725: }
! 726:
! 727: /*
! 728: ** Close the dynamic library handle pHandle.
! 729: */
! 730: static void vfstraceDlClose(sqlite3_vfs *pVfs, void *pHandle){
! 731: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 732: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 733: vfstrace_printf(pInfo, "%s.xDlOpen()\n", pInfo->zVfsName);
! 734: pRoot->xDlClose(pRoot, pHandle);
! 735: }
! 736:
! 737: /*
! 738: ** Populate the buffer pointed to by zBufOut with nByte bytes of
! 739: ** random data.
! 740: */
! 741: static int vfstraceRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
! 742: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 743: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 744: vfstrace_printf(pInfo, "%s.xRandomness(%d)\n", pInfo->zVfsName, nByte);
! 745: return pRoot->xRandomness(pRoot, nByte, zBufOut);
! 746: }
! 747:
! 748: /*
! 749: ** Sleep for nMicro microseconds. Return the number of microseconds
! 750: ** actually slept.
! 751: */
! 752: static int vfstraceSleep(sqlite3_vfs *pVfs, int nMicro){
! 753: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 754: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 755: return pRoot->xSleep(pRoot, nMicro);
! 756: }
! 757:
! 758: /*
! 759: ** Return the current time as a Julian Day number in *pTimeOut.
! 760: */
! 761: static int vfstraceCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
! 762: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 763: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 764: return pRoot->xCurrentTime(pRoot, pTimeOut);
! 765: }
! 766: static int vfstraceCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
! 767: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 768: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 769: return pRoot->xCurrentTimeInt64(pRoot, pTimeOut);
! 770: }
! 771:
! 772: /*
! 773: ** Return th3 emost recent error code and message
! 774: */
! 775: static int vfstraceGetLastError(sqlite3_vfs *pVfs, int iErr, char *zErr){
! 776: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 777: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 778: return pRoot->xGetLastError(pRoot, iErr, zErr);
! 779: }
! 780:
! 781: /*
! 782: ** Override system calls.
! 783: */
! 784: static int vfstraceSetSystemCall(
! 785: sqlite3_vfs *pVfs,
! 786: const char *zName,
! 787: sqlite3_syscall_ptr pFunc
! 788: ){
! 789: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 790: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 791: return pRoot->xSetSystemCall(pRoot, zName, pFunc);
! 792: }
! 793: static sqlite3_syscall_ptr vfstraceGetSystemCall(
! 794: sqlite3_vfs *pVfs,
! 795: const char *zName
! 796: ){
! 797: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 798: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 799: return pRoot->xGetSystemCall(pRoot, zName);
! 800: }
! 801: static const char *vfstraceNextSystemCall(sqlite3_vfs *pVfs, const char *zName){
! 802: vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
! 803: sqlite3_vfs *pRoot = pInfo->pRootVfs;
! 804: return pRoot->xNextSystemCall(pRoot, zName);
! 805: }
! 806:
! 807:
! 808: /*
! 809: ** Clients invoke this routine to construct a new trace-vfs shim.
! 810: **
! 811: ** Return SQLITE_OK on success.
! 812: **
! 813: ** SQLITE_NOMEM is returned in the case of a memory allocation error.
! 814: ** SQLITE_NOTFOUND is returned if zOldVfsName does not exist.
! 815: */
! 816: int vfstrace_register(
! 817: const char *zTraceName, /* Name of the newly constructed VFS */
! 818: const char *zOldVfsName, /* Name of the underlying VFS */
! 819: int (*xOut)(const char*,void*), /* Output routine. ex: fputs */
! 820: void *pOutArg, /* 2nd argument to xOut. ex: stderr */
! 821: int makeDefault /* True to make the new VFS the default */
! 822: ){
! 823: sqlite3_vfs *pNew;
! 824: sqlite3_vfs *pRoot;
! 825: vfstrace_info *pInfo;
! 826: int nName;
! 827: int nByte;
! 828:
! 829: pRoot = sqlite3_vfs_find(zOldVfsName);
! 830: if( pRoot==0 ) return SQLITE_NOTFOUND;
! 831: nName = strlen(zTraceName);
! 832: nByte = sizeof(*pNew) + sizeof(*pInfo) + nName + 1;
! 833: pNew = sqlite3_malloc( nByte );
! 834: if( pNew==0 ) return SQLITE_NOMEM;
! 835: memset(pNew, 0, nByte);
! 836: pInfo = (vfstrace_info*)&pNew[1];
! 837: pNew->iVersion = pRoot->iVersion;
! 838: pNew->szOsFile = pRoot->szOsFile + sizeof(vfstrace_file);
! 839: pNew->mxPathname = pRoot->mxPathname;
! 840: pNew->zName = (char*)&pInfo[1];
! 841: memcpy((char*)&pInfo[1], zTraceName, nName+1);
! 842: pNew->pAppData = pInfo;
! 843: pNew->xOpen = vfstraceOpen;
! 844: pNew->xDelete = vfstraceDelete;
! 845: pNew->xAccess = vfstraceAccess;
! 846: pNew->xFullPathname = vfstraceFullPathname;
! 847: pNew->xDlOpen = pRoot->xDlOpen==0 ? 0 : vfstraceDlOpen;
! 848: pNew->xDlError = pRoot->xDlError==0 ? 0 : vfstraceDlError;
! 849: pNew->xDlSym = pRoot->xDlSym==0 ? 0 : vfstraceDlSym;
! 850: pNew->xDlClose = pRoot->xDlClose==0 ? 0 : vfstraceDlClose;
! 851: pNew->xRandomness = vfstraceRandomness;
! 852: pNew->xSleep = vfstraceSleep;
! 853: pNew->xCurrentTime = vfstraceCurrentTime;
! 854: pNew->xGetLastError = pRoot->xGetLastError==0 ? 0 : vfstraceGetLastError;
! 855: if( pNew->iVersion>=2 ){
! 856: pNew->xCurrentTimeInt64 = pRoot->xCurrentTimeInt64==0 ? 0 :
! 857: vfstraceCurrentTimeInt64;
! 858: if( pNew->iVersion>=3 ){
! 859: pNew->xSetSystemCall = pRoot->xSetSystemCall==0 ? 0 :
! 860: vfstraceSetSystemCall;
! 861: pNew->xGetSystemCall = pRoot->xGetSystemCall==0 ? 0 :
! 862: vfstraceGetSystemCall;
! 863: pNew->xNextSystemCall = pRoot->xNextSystemCall==0 ? 0 :
! 864: vfstraceNextSystemCall;
! 865: }
! 866: }
! 867: pInfo->pRootVfs = pRoot;
! 868: pInfo->xOut = xOut;
! 869: pInfo->pOutArg = pOutArg;
! 870: pInfo->zVfsName = pNew->zName;
! 871: pInfo->pTraceVfs = pNew;
! 872: vfstrace_printf(pInfo, "%s.enabled_for(\"%s\")\n",
! 873: pInfo->zVfsName, pRoot->zName);
! 874: return sqlite3_vfs_register(pNew, makeDefault);
! 875: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_vfstrace.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src