[sql] Import reference version of SQLite 3.8.7.4.

third_party/sqlite/sqlite-src-3080704/src/test_syscall.c

 /*
 ** 2011 March 28
 **
 ** 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.
 **
 *************************************************************************
 **
 ** The code in this file implements a Tcl interface used to test error
 ** handling in the os_unix.c module. Wrapper functions that support fault
 ** injection are registered as the low-level OS functions using the 
 ** xSetSystemCall() method of the VFS. The Tcl interface is as follows:
 **
 **
 **   test_syscall install LIST
 **     Install wrapper functions for all system calls in argument LIST.
 **     LIST must be a list consisting of zero or more of the following
 **     literal values:
 **
 **         open        close      access   getcwd   stat      fstat    
 **         ftruncate   fcntl      read     pread    pread64   write
-**         pwrite      pwrite64   fchmod   fallocate
+**         pwrite      pwrite64   fchmod   fallocate mmap
 **
 **   test_syscall uninstall
 **     Uninstall all wrapper functions.
 **
 **   test_syscall fault ?COUNT PERSIST?
 **     If [test_syscall fault] is invoked without the two arguments, fault
 **     injection is disabled. Otherwise, fault injection is configured to
 **     cause a failure on the COUNT'th next call to a system call with a
 **     wrapper function installed. A COUNT value of 1 means fail the next
 **     system call. 
@@ skipping 23 matching lines @@
 **
 **     With an argument, this command attempts to reset the system call named
 **     by the parameter using the same method as [uninstall].
 **
 **   test_syscall exists SYSTEM-CALL
 **     Return true if the named system call exists. Or false otherwise.
 **
 **   test_syscall list
 **     Return a list of all system calls. The list is constructed using
 **     the xNextSystemCall() VFS method.
+**
+**   test_syscall pagesize PGSZ
+**     If PGSZ is a power of two greater than 256, install a wrapper around
+**     OS function getpagesize() that reports the system page size as PGSZ.
+**     Or, if PGSZ is less than zero, remove any wrapper already installed.
 */
 
+#include "sqliteInt.h"
 #include "sqlite3.h"
 #include "tcl.h"
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 
-#include "sqliteInt.h"
 #if SQLITE_OS_UNIX
 
-/* From test1.c */
-extern const char *sqlite3TestErrorName(int);
+/* From main.c */
+extern const char *sqlite3ErrName(int);
 
+#include <sys/mman.h>
 #include <sys/types.h>
 #include <errno.h>
 
 static struct TestSyscallGlobal {
   int bPersist;                   /* 1 for persistent errors, 0 for transient */
   int nCount;                     /* Fail after this many more calls */
   int nFail;                      /* Number of failures that have occurred */
-} gSyscall = { 0, 0 };
+  int pgsz;
+  sqlite3_syscall_ptr orig_getpagesize;
+} gSyscall = { 0, 0, 0, 0, 0 };
 
 static int ts_open(const char *, int, int);
 static int ts_close(int fd);
 static int ts_access(const char *zPath, int mode);
 static char *ts_getcwd(char *zPath, size_t nPath);
 static int ts_stat(const char *zPath, struct stat *p);
 static int ts_fstat(int fd, struct stat *p);
 static int ts_ftruncate(int fd, off_t n);
 static int ts_fcntl(int fd, int cmd, ... );
 static int ts_read(int fd, void *aBuf, size_t nBuf);
 static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off);
 static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off);
 static int ts_write(int fd, const void *aBuf, size_t nBuf);
 static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off);
 static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off);
 static int ts_fchmod(int fd, mode_t mode);
 static int ts_fallocate(int fd, off_t off, off_t len);
-
+static void *ts_mmap(void *, size_t, int, int, int, off_t);
+static void *ts_mremap(void*, size_t, size_t, int, ...);
 
 struct TestSyscallArray {
   const char *zName;
   sqlite3_syscall_ptr xTest;
   sqlite3_syscall_ptr xOrig;
   int default_errno;              /* Default value for errno following errors */
   int custom_errno;               /* Current value for errno if error */
 } aSyscall[] = {
   /*  0 */ { "open",      (sqlite3_syscall_ptr)ts_open,      0, EACCES, 0 },
   /*  1 */ { "close",     (sqlite3_syscall_ptr)ts_close,     0, 0, 0 },
   /*  2 */ { "access",    (sqlite3_syscall_ptr)ts_access,    0, 0, 0 },
   /*  3 */ { "getcwd",    (sqlite3_syscall_ptr)ts_getcwd,    0, 0, 0 },
   /*  4 */ { "stat",      (sqlite3_syscall_ptr)ts_stat,      0, 0, 0 },
   /*  5 */ { "fstat",     (sqlite3_syscall_ptr)ts_fstat,     0, 0, 0 },
   /*  6 */ { "ftruncate", (sqlite3_syscall_ptr)ts_ftruncate, 0, EIO, 0 },
   /*  7 */ { "fcntl",     (sqlite3_syscall_ptr)ts_fcntl,     0, EACCES, 0 },
   /*  8 */ { "read",      (sqlite3_syscall_ptr)ts_read,      0, 0, 0 },
   /*  9 */ { "pread",     (sqlite3_syscall_ptr)ts_pread,     0, 0, 0 },
   /* 10 */ { "pread64",   (sqlite3_syscall_ptr)ts_pread64,   0, 0, 0 },
   /* 11 */ { "write",     (sqlite3_syscall_ptr)ts_write,     0, 0, 0 },
   /* 12 */ { "pwrite",    (sqlite3_syscall_ptr)ts_pwrite,    0, 0, 0 },
   /* 13 */ { "pwrite64",  (sqlite3_syscall_ptr)ts_pwrite64,  0, 0, 0 },
   /* 14 */ { "fchmod",    (sqlite3_syscall_ptr)ts_fchmod,    0, 0, 0 },
   /* 15 */ { "fallocate", (sqlite3_syscall_ptr)ts_fallocate, 0, 0, 0 },
+  /* 16 */ { "mmap",      (sqlite3_syscall_ptr)ts_mmap,      0, 0, 0 },
+  /* 17 */ { "mremap",    (sqlite3_syscall_ptr)ts_mremap,    0, 0, 0 },
            { 0, 0, 0, 0, 0 }
 };
 
 #define orig_open      ((int(*)(const char *, int, int))aSyscall[0].xOrig)
 #define orig_close     ((int(*)(int))aSyscall[1].xOrig)
 #define orig_access    ((int(*)(const char*,int))aSyscall[2].xOrig)
 #define orig_getcwd    ((char*(*)(char*,size_t))aSyscall[3].xOrig)
 #define orig_stat      ((int(*)(const char*,struct stat*))aSyscall[4].xOrig)
 #define orig_fstat     ((int(*)(int,struct stat*))aSyscall[5].xOrig)
 #define orig_ftruncate ((int(*)(int,off_t))aSyscall[6].xOrig)
 #define orig_fcntl     ((int(*)(int,int,...))aSyscall[7].xOrig)
 #define orig_read      ((ssize_t(*)(int,void*,size_t))aSyscall[8].xOrig)
 #define orig_pread     ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].xOrig)
 #define orig_pread64   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].xOrig)
 #define orig_write     ((ssize_t(*)(int,const void*,size_t))aSyscall[11].xOrig)
 #define orig_pwrite    ((ssize_t(*)(int,const void*,size_t,off_t))\
                        aSyscall[12].xOrig)
 #define orig_pwrite64  ((ssize_t(*)(int,const void*,size_t,off_t))\
                        aSyscall[13].xOrig)
 #define orig_fchmod    ((int(*)(int,mode_t))aSyscall[14].xOrig)
 #define orig_fallocate ((int(*)(int,off_t,off_t))aSyscall[15].xOrig)
+#define orig_mmap      ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[16].xOrig)
+#define orig_mremap    ((void*(*)(void*,size_t,size_t,int,...))aSyscall[17].xOrig)
 
 /*
 ** This function is called exactly once from within each invocation of a
 ** system call wrapper in this file. It returns 1 if the function should
 ** fail, or 0 if it should succeed.
 */
 static int tsIsFail(void){
   gSyscall.nCount--;
   if( gSyscall.nCount==0 || (gSyscall.nFail && gSyscall.bPersist) ){
     gSyscall.nFail++;
@@ skipping 153 matching lines @@
     return -1;
   }
   return orig_pread64(fd, aBuf, nBuf, off);
 }
 
 /*
 ** A wrapper around write().
 */
 static int ts_write(int fd, const void *aBuf, size_t nBuf){
   if( tsIsFailErrno("write") ){
+    if( tsErrno("write")==EINTR ) orig_write(fd, aBuf, nBuf/2);
     return -1;
   }
   return orig_write(fd, aBuf, nBuf);
 }
 
 /*
 ** A wrapper around pwrite().
 */
 static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off){
   if( tsIsFailErrno("pwrite") ){
@@ skipping 31 matching lines @@
 **   posix_fallocate() returns  zero on success, or an error number on
 **   failure. Note that errno is not set.
 */
 static int ts_fallocate(int fd, off_t off, off_t len){
   if( tsIsFail() ){
     return tsErrno("fallocate");
   }
   return orig_fallocate(fd, off, len);
 }
 
+static void *ts_mmap(
+  void *pAddr, 
+  size_t nByte, 
+  int prot, 
+  int flags, 
+  int fd, 
+  off_t iOff
+){
+  if( tsIsFailErrno("mmap") ){
+    return MAP_FAILED;
+  }
+  return orig_mmap(pAddr, nByte, prot, flags, fd, iOff);
+}
+
+static void *ts_mremap(void *a, size_t b, size_t c, int d, ...){
+  va_list ap;
+  void *pArg;
+  if( tsIsFailErrno("mremap") ){
+    return MAP_FAILED;
+  }
+  va_start(ap, d);
+  pArg = va_arg(ap, void *);
+  return orig_mremap(a, b, c, d, pArg);
+}
+
 static int test_syscall_install(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_vfs *pVfs; 
   int nElem;
   int i;
   Tcl_Obj **apElem;
@@ skipping 70 matching lines @@
     int nFunc;
     char *zFunc = Tcl_GetStringFromObj(objv[2], &nFunc);
     rc = pVfs->xSetSystemCall(pVfs, Tcl_GetString(objv[2]), 0);
     for(i=0; rc==SQLITE_OK && aSyscall[i].zName; i++){
       if( strlen(aSyscall[i].zName)!=nFunc ) continue;
       if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue;
       aSyscall[i].xOrig = 0;
     }
   }
   if( rc!=SQLITE_OK ){
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3TestErrorName(rc), -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
     return TCL_ERROR;
   }
 
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
 
 static int test_syscall_exists(
   void * clientData,
   Tcl_Interp *interp,
@@ skipping 131 matching lines @@
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 2, objv, "");
     return TCL_ERROR;
   }
 
   pVfs = sqlite3_vfs_find(0);
   Tcl_SetObjResult(interp, Tcl_NewStringObj(pVfs->zName, -1));
   return TCL_OK;
 }
 
+static int ts_getpagesize(void){
+  return gSyscall.pgsz;
+}
+
+static int test_syscall_pagesize(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
+  int pgsz;
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 2, objv, "PGSZ");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &pgsz) ){
+    return TCL_ERROR;
+  }
+
+  if( pgsz<0 ){
+    if( gSyscall.orig_getpagesize ){
+      pVfs->xSetSystemCall(pVfs, "getpagesize", gSyscall.orig_getpagesize);
+    }
+  }else{
+    if( pgsz<512 || (pgsz & (pgsz-1)) ){
+      Tcl_AppendResult(interp, "pgsz out of range", 0);
+      return TCL_ERROR;
+    }
+    gSyscall.orig_getpagesize = pVfs->xGetSystemCall(pVfs, "getpagesize");
+    gSyscall.pgsz = pgsz;
+    pVfs->xSetSystemCall(
+        pVfs, "getpagesize", (sqlite3_syscall_ptr)ts_getpagesize
+    );
+  }
+
+  return TCL_OK;
+}
+
 static int test_syscall(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   struct SyscallCmd {
     const char *zName;
     Tcl_ObjCmdProc *xCmd;
   } aCmd[] = {
     { "fault",      test_syscall_fault },
     { "install",    test_syscall_install },
     { "uninstall",  test_syscall_uninstall },
     { "reset",      test_syscall_reset },
     { "errno",      test_syscall_errno },
     { "exists",     test_syscall_exists },
     { "list",       test_syscall_list },
     { "defaultvfs", test_syscall_defaultvfs },
+    { "pagesize",   test_syscall_pagesize },
     { 0, 0 }
   };
   int iCmd;
   int rc;
 
   if( objc<2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
     return TCL_ERROR;
   }
   rc = Tcl_GetIndexFromObjStruct(interp, 
@@ skipping 15 matching lines @@
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xCmd, 0, 0);
   }
   return TCL_OK;
 }
 #else
 int SqlitetestSyscall_Init(Tcl_Interp *interp){
   return TCL_OK;
 }
 #endif
-