Import SQLite 3.8.7.4.

third_party/sqlite/src/src/test6.c

 /*
 ** 2004 May 22
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
@@ skipping 69 matching lines @@
 **
 ** Device Characteristic flag handling:
 **
 **   If the IOCAP_ATOMIC flag is set, then option (3) above is 
 **   never selected.
 **
 **   If the IOCAP_ATOMIC512 flag is set, and the WriteBuffer represents
 **   an aligned write() of an integer number of 512 byte regions, then
 **   option (3) above is never selected. Instead, each 512 byte region
 **   is either correctly written or left completely untouched. Similar
-**   logic governs the behaviour if any of the other ATOMICXXX flags
+**   logic governs the behavior if any of the other ATOMICXXX flags
 **   is set.
 **
 **   If either the IOCAP_SAFEAPPEND or IOCAP_SEQUENTIAL flags are set
 **   and a crash is being simulated, then an entry of the write-list is
 **   selected at random. Everything in the list after the selected entry 
 **   is discarded before processing begins.
 **
 **   If IOCAP_SEQUENTIAL is set and a crash is being simulated, option 
 **   (1) is selected for all write-list entries except the last. If a 
 **   crash is not being simulated, then all entries in the write-list
@@ skipping 25 matching lines @@
 struct CrashFile {
   const sqlite3_io_methods *pMethod;   /* Must be first */
   sqlite3_file *pRealFile;             /* Underlying "real" file handle */
   char *zName;
   int flags;                           /* Flags the file was opened with */
 
   /* Cache of the entire file. This is used to speed up OsRead() and 
   ** OsFileSize() calls. Although both could be done by traversing the
   ** write-list, in practice this is impractically slow.
   */
-  int iSize;                           /* Size of file in bytes */
+  u8 *zData;                           /* Buffer containing file contents */
   int nData;                           /* Size of buffer allocated at zData */
-  u8 *zData;                           /* Buffer containing file contents */
+  i64 iSize;                           /* Size of file in bytes */
 };
 
 struct CrashGlobal {
   WriteBuffer *pWriteList;     /* Head of write-list */
   WriteBuffer *pWriteListEnd;  /* End of write-list */
 
   int iSectorSize;             /* Value of simulated sector size */
   int iDeviceCharacteristics;  /* Value of simulated device characteristics */
 
   int iCrash;                  /* Crash on the iCrash'th call to xSync() */
@@ skipping 17 matching lines @@
   return (void *)Tcl_Realloc(p, (size_t)n);
 }
 
 /*
 ** Wrapper around the sqlite3OsWrite() function that avoids writing to the
 ** 512 byte block begining at offset PENDING_BYTE.
 */
 static int writeDbFile(CrashFile *p, u8 *z, i64 iAmt, i64 iOff){
   int rc = SQLITE_OK;
   int iSkip = 0;
-  if( iOff==PENDING_BYTE && (p->flags&SQLITE_OPEN_MAIN_DB) ){
-    iSkip = 512;
-  }
   if( (iAmt-iSkip)>0 ){
-    rc = sqlite3OsWrite(p->pRealFile, &z[iSkip], iAmt-iSkip, iOff+iSkip);
+    rc = sqlite3OsWrite(p->pRealFile, &z[iSkip], (int)(iAmt-iSkip), iOff+iSkip);
   }
   return rc;
 }
 
 /*
 ** Flush the write-list as if xSync() had been called on file handle
 ** pFile. If isCrash is true, simulate a crash.
 */
 static int writeListSync(CrashFile *pFile, int isCrash){
   int rc = SQLITE_OK;
@@ skipping 108 matching lines @@
         if( isCrash ){
           printf("Omiting %d bytes @ %d (%s)\n", 
             pWrite->nBuf, (int)pWrite->iOffset, pWrite->pFile->zName
           );
         }
 #endif
         break;
       }
       case 3: {               /* Trash sectors */
         u8 *zGarbage;
-        int iFirst = (pWrite->iOffset/g.iSectorSize);
-        int iLast = (pWrite->iOffset+pWrite->nBuf-1)/g.iSectorSize;
+        int iFirst = (int)(pWrite->iOffset/g.iSectorSize);
+        int iLast = (int)((pWrite->iOffset+pWrite->nBuf-1)/g.iSectorSize);
 
         assert(pWrite->zBuf);
 
 #ifdef TRACE_CRASHTEST
-        printf("Trashing %d sectors @ sector %d (%s)\n", 
-            1+iLast-iFirst, iFirst, pWrite->pFile->zName
+        printf("Trashing %d sectors @ %lld (sector %d) (%s)\n", 
+            1+iLast-iFirst, pWrite->iOffset, iFirst, pWrite->pFile->zName
         );
 #endif
 
         zGarbage = crash_malloc(g.iSectorSize);
         if( zGarbage ){
           sqlite3_int64 i;
           for(i=iFirst; rc==SQLITE_OK && i<=iLast; i++){
             sqlite3_randomness(g.iSectorSize, zGarbage); 
             rc = writeDbFile(
               pWrite->pFile, zGarbage, g.iSectorSize, i*g.iSectorSize
@@ skipping 75 matching lines @@
 /*
 ** Read data from a crash-file.
 */
 static int cfRead(
   sqlite3_file *pFile, 
   void *zBuf, 
   int iAmt, 
   sqlite_int64 iOfst
 ){
   CrashFile *pCrash = (CrashFile *)pFile;
+  int nCopy = (int)MIN((i64)iAmt, (pCrash->iSize - iOfst));
+
+  if( nCopy>0 ){
+    memcpy(zBuf, &pCrash->zData[iOfst], nCopy);
+  }
 
   /* Check the file-size to see if this is a short-read */
-  if( pCrash->iSize<(iOfst+iAmt) ){
+  if( nCopy<iAmt ){
     return SQLITE_IOERR_SHORT_READ;
   }
 
-  memcpy(zBuf, &pCrash->zData[iOfst], iAmt);
   return SQLITE_OK;
 }
 
 /*
 ** Write data to a crash-file.
 */
 static int cfWrite(
   sqlite3_file *pFile, 
   const void *zBuf, 
   int iAmt, 
   sqlite_int64 iOfst
 ){
   CrashFile *pCrash = (CrashFile *)pFile;
   if( iAmt+iOfst>pCrash->iSize ){
-    pCrash->iSize = iAmt+iOfst;
+    pCrash->iSize = (int)(iAmt+iOfst);
   }
   while( pCrash->iSize>pCrash->nData ){
     u8 *zNew;
     int nNew = (pCrash->nData*2) + 4096;
     zNew = crash_realloc(pCrash->zData, nNew);
     if( !zNew ){
       return SQLITE_NOMEM;
     }
     memset(&zNew[pCrash->nData], 0, nNew-pCrash->nData);
     pCrash->nData = nNew;
     pCrash->zData = zNew;
   }
   memcpy(&pCrash->zData[iOfst], zBuf, iAmt);
   return writeListAppend(pFile, iOfst, zBuf, iAmt);
 }
 
 /*
 ** Truncate a crash-file.
 */
 static int cfTruncate(sqlite3_file *pFile, sqlite_int64 size){
   CrashFile *pCrash = (CrashFile *)pFile;
   assert(size>=0);
   if( pCrash->iSize>size ){
-    pCrash->iSize = size;
+    pCrash->iSize = (int)size;
   }
   return writeListAppend(pFile, size, 0, 0);
 }
 
 /*
 ** Sync a crash-file.
 */
 static int cfSync(sqlite3_file *pFile, int flags){
   CrashFile *pCrash = (CrashFile *)pFile;
   int isCrash = 0;
 
   const char *zName = pCrash->zName;
   const char *zCrashFile = g.zCrashFile;
-  int nName = strlen(zName);
-  int nCrashFile = strlen(zCrashFile);
+  int nName = (int)strlen(zName);
+  int nCrashFile = (int)strlen(zCrashFile);
 
   if( nCrashFile>0 && zCrashFile[nCrashFile-1]=='*' ){
     nCrashFile--;
     if( nName>nCrashFile ) nName = nCrashFile;
   }
 
+#ifdef TRACE_CRASHTEST
+  printf("cfSync(): nName = %d, nCrashFile = %d, zName = %s, zCrashFile = %s\n",
+         nName, nCrashFile, zName, zCrashFile);
+#endif
+
   if( nName==nCrashFile && 0==memcmp(zName, zCrashFile, nName) ){
+#ifdef TRACE_CRASHTEST
+    printf("cfSync(): name matched, g.iCrash = %d\n", g.iCrash);
+#endif
     if( (--g.iCrash)==0 ) isCrash = 1;
   }
 
   return writeListSync(pCrash, isCrash);
 }
 
 /*
 ** Return the current file-size of the crash-file.
 */
 static int cfFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
   CrashFile *pCrash = (CrashFile *)pFile;
   *pSize = (i64)pCrash->iSize;
   return SQLITE_OK;
 }
 
 /*
 ** Calls related to file-locks are passed on to the real file handle.
 */
 static int cfLock(sqlite3_file *pFile, int eLock){
   return sqlite3OsLock(((CrashFile *)pFile)->pRealFile, eLock);
 }
 static int cfUnlock(sqlite3_file *pFile, int eLock){
   return sqlite3OsUnlock(((CrashFile *)pFile)->pRealFile, eLock);
 }
 static int cfCheckReservedLock(sqlite3_file *pFile, int *pResOut){
   return sqlite3OsCheckReservedLock(((CrashFile *)pFile)->pRealFile, pResOut);
 }
 static int cfFileControl(sqlite3_file *pFile, int op, void *pArg){
+  if( op==SQLITE_FCNTL_SIZE_HINT ){
+    CrashFile *pCrash = (CrashFile *)pFile;
+    i64 nByte = *(i64 *)pArg;
+    if( nByte>pCrash->iSize ){
+      if( SQLITE_OK==writeListAppend(pFile, nByte, 0, 0) ){
+        pCrash->iSize = (int)nByte;
+      }
+    }
+    return SQLITE_OK;
+  }
   return sqlite3OsFileControl(((CrashFile *)pFile)->pRealFile, op, pArg);
 }
 
 /*
 ** The xSectorSize() and xDeviceCharacteristics() functions return
 ** the global values configured by the [sqlite_crashparams] tcl
 *  interface.
 */
 static int cfSectorSize(sqlite3_file *pFile){
   return g.iSectorSize;
@@ skipping 78 matching lines @@
   if( rc==SQLITE_OK ){
     i64 iSize;
     pWrapper->pMethod = &CrashFileVtab;
     pWrapper->zName = (char *)zName;
     pWrapper->pRealFile = pReal;
     rc = sqlite3OsFileSize(pReal, &iSize);
     pWrapper->iSize = (int)iSize;
     pWrapper->flags = flags;
   }
   if( rc==SQLITE_OK ){
-    pWrapper->nData = (4096 + pWrapper->iSize);
+    pWrapper->nData = (int)(4096 + pWrapper->iSize);
     pWrapper->zData = crash_malloc(pWrapper->nData);
     if( pWrapper->zData ){
       /* os_unix.c contains an assert() that fails if the caller attempts
       ** to read data from the 512-byte locking region of a file opened
       ** with the SQLITE_OPEN_MAIN_DB flag. This region of a database file
       ** never contains valid data anyhow. So avoid doing such a read here.
+      **
+      ** UPDATE: It also contains an assert() verifying that each call
+      ** to the xRead() method reads less than 128KB of data.
       */
-      const int isDb = (flags&SQLITE_OPEN_MAIN_DB);
-      i64 iChunk = pWrapper->iSize;
-      if( iChunk>PENDING_BYTE && isDb ){
-        iChunk = PENDING_BYTE;
-      }
+      i64 iOff;
+
       memset(pWrapper->zData, 0, pWrapper->nData);
-      rc = sqlite3OsRead(pReal, pWrapper->zData, iChunk, 0); 
-      if( SQLITE_OK==rc && pWrapper->iSize>(PENDING_BYTE+512) && isDb ){
-        i64 iOff = PENDING_BYTE+512;
-        iChunk = pWrapper->iSize - iOff;
-        rc = sqlite3OsRead(pReal, &pWrapper->zData[iOff], iChunk, iOff);
+      for(iOff=0; iOff<pWrapper->iSize; iOff += 512){
+        int nRead = (int)(pWrapper->iSize - iOff);
+        if( nRead>512 ) nRead = 512;
+        rc = sqlite3OsRead(pReal, &pWrapper->zData[iOff], nRead, iOff);
       }
     }else{
       rc = SQLITE_NOMEM;
     }
   }
   if( rc!=SQLITE_OK && pWrapper->pMethod ){
     sqlite3OsClose(pFile);
   }
   return rc;
 }
@@ skipping 53 matching lines @@
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[],
   int *piDeviceChar,
   int *piSectorSize
 ){
   struct DeviceFlag {
     char *zName;
     int iValue;
   } aFlag[] = {
-    { "atomic",      SQLITE_IOCAP_ATOMIC      },
-    { "atomic512",   SQLITE_IOCAP_ATOMIC512   },
-    { "atomic1k",    SQLITE_IOCAP_ATOMIC1K    },
-    { "atomic2k",    SQLITE_IOCAP_ATOMIC2K    },
-    { "atomic4k",    SQLITE_IOCAP_ATOMIC4K    },
-    { "atomic8k",    SQLITE_IOCAP_ATOMIC8K    },
-    { "atomic16k",   SQLITE_IOCAP_ATOMIC16K   },
-    { "atomic32k",   SQLITE_IOCAP_ATOMIC32K   },
-    { "atomic64k",   SQLITE_IOCAP_ATOMIC64K   },
-    { "sequential",  SQLITE_IOCAP_SEQUENTIAL  },
-    { "safe_append", SQLITE_IOCAP_SAFE_APPEND },
+    { "atomic",              SQLITE_IOCAP_ATOMIC                },
+    { "atomic512",           SQLITE_IOCAP_ATOMIC512             },
+    { "atomic1k",            SQLITE_IOCAP_ATOMIC1K              },
+    { "atomic2k",            SQLITE_IOCAP_ATOMIC2K              },
+    { "atomic4k",            SQLITE_IOCAP_ATOMIC4K              },
+    { "atomic8k",            SQLITE_IOCAP_ATOMIC8K              },
+    { "atomic16k",           SQLITE_IOCAP_ATOMIC16K             },
+    { "atomic32k",           SQLITE_IOCAP_ATOMIC32K             },
+    { "atomic64k",           SQLITE_IOCAP_ATOMIC64K             },
+    { "sequential",          SQLITE_IOCAP_SEQUENTIAL            },
+    { "safe_append",         SQLITE_IOCAP_SAFE_APPEND           },
+    { "powersafe_overwrite", SQLITE_IOCAP_POWERSAFE_OVERWRITE   },
     { 0, 0 }
   };
 
   int i;
   int iDc = 0;
   int iSectorSize = 0;
   int setSectorsize = 0;
   int setDeviceChar = 0;
 
   for(i=0; i<objc; i+=2){
@@ skipping 272 matching lines @@
   Tcl_CreateObjCommand(interp, "sqlite3_crash_enable", crashEnableCmd, 0, 0);
   Tcl_CreateObjCommand(interp, "sqlite3_crashparams", crashParamsObjCmd, 0, 0);
   Tcl_CreateObjCommand(interp, "sqlite3_simulate_device", devSymObjCmd, 0, 0);
   Tcl_CreateObjCommand(interp, "register_jt_vfs", jtObjCmd, 0, 0);
   Tcl_CreateObjCommand(interp, "unregister_jt_vfs", jtUnregisterObjCmd, 0, 0);
 #endif
   return TCL_OK;
 }
 
 #endif /* SQLITE_TEST */