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>