Test the handling of errors returned by the xShmXXX() APIs.

FossilOrigin-Name: 72663123d6be2b194cad7a6057d0f20dd0d9fe05

main.mk

@@ -249,6 +249,7 @@ TESTSRC = \
   $(TOP)/src/test_server.c \
   $(TOP)/src/test_tclvar.c \
   $(TOP)/src/test_thread.c \
+  $(TOP)/src/test_vfs.c \
   $(TOP)/src/test_wsd.c
 
 #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c

manifest

@@ -1,8 +1,5 @@
------BEGIN PGP SIGNED MESSAGE-----
+C Test\sthe\shandling\sof\serrors\sreturned\sby\sthe\sxShmXXX()\sAPIs.
-Hash: SHA1
+D 2010-05-05T19:04:59
-
-C Do\snot\scompare\spage\ssizes\son\ssource\sand\sdestination\sof\sbackup\suntil\ntransactions\sare\sstarted\sand\sthe\spage\ssizes\sare\slocked.\s\sThis\sis\sa\nfix\sto\scheck-in\s[7bd44794c4].
-D 2010-05-05T18:46:45
 F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0
 F Makefile.in d83a0ffef3dcbfb08b410a6c6dd6c009ec9167fb
 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
@@ -92,7 +89,7 @@ F ext/rtree/tkt3363.test 2bf324f7908084a5f463de3109db9c6e607feb1b
 F ext/rtree/viewrtree.tcl eea6224b3553599ae665b239bd827e182b466024
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
-F main.mk b681194d6bf557b80ca363306e9c172f81f15b1d
+F main.mk b39182f15fd980b86aceb7e4b9a1ba88abd75e2d
 F mkdll.sh 7d09b23c05d56532e9d44a50868eb4b12ff4f74a
 F mkextu.sh 416f9b7089d80e5590a29692c9d9280a10dbad9f
 F mkextw.sh 4123480947681d9b434a5e7b1ee08135abe409ac
@@ -175,7 +172,7 @@ F src/sqliteInt.h 9819b45610abeca390176243a9a31758c1f0ac7a
 F src/sqliteLimit.h 196e2f83c3b444c4548fc1874f52f84fdbda40f3
 F src/status.c 4df6fe7dce2d256130b905847c6c60055882bdbe
 F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
-F src/tclsqlite.c 4de81521174fedacd8393ea7b70b730ce17f8eae
+F src/tclsqlite.c a6d69438c21e89c26dc791bfa4c5ba6da9dbb515
 F src/test1.c ff95ca772d1df51618f9f1ef7ea432cdf851f97b
 F src/test2.c 31f1b9d076b4774a22d2605d0af1f34e14a9a7bd
 F src/test3.c 4c21700c73a890a47fc685c1097bfb661346ac94
@@ -208,6 +205,7 @@ F src/test_schema.c 8c06ef9ddb240c7a0fcd31bc221a6a2aade58bf0
 F src/test_server.c bbba05c144b5fc4b52ff650a4328027b3fa5fcc6
 F src/test_tclvar.c f4dc67d5f780707210d6bb0eb6016a431c04c7fa
 F src/test_thread.c aa9919c885a1fe53eafc73492f0898ee6c0a0726
+F src/test_vfs.c 4e84d17c6f64913684cd9c92c41337c55b3f3dc9
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/tokenize.c 25ceb0f0a746ea1d0f9553787f3f0a56853cfaeb
 F src/trigger.c 8927588cb9e6d47f933b53bfe74200fbb504100d
@@ -224,7 +222,7 @@ F src/vdbeblob.c 5327132a42a91e8b7acfb60b9d2c3b1c5c863e0e
 F src/vdbemem.c 2a82f455f6ca6f78b59fb312f96054c04ae0ead1
 F src/vdbetrace.c 864cef96919323482ebd9986f2132435115e9cc2
 F src/vtab.c a0f8a40274e4261696ef57aa806de2776ab72cda
-F src/wal.c faafbea1d530e0ad60a2b77a9c32627077527d37
+F src/wal.c 85311299e9032957284b4c5b0f801fc4cb9416d6
 F src/wal.h b4c42014b5fa3b4e6244ac8c65de7ff67adeb27c
 F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
 F src/where.c 75fee9e255b62f773fcadd1d1f25b6f63ac7a356
@@ -764,7 +762,7 @@ F test/vtab_shared.test 0eff9ce4f19facbe0a3e693f6c14b80711a4222d
 F test/wal.test f0b331017a12a31dd4bbb20aee9c179fbfdd5921
 F test/walbak.test a0e45187c7d8928df035dfea29b99b016b21ca3c
 F test/walcrash.test f6d5fb2bb108876f04848720a488065d9deef69f
-F test/walfault.test 2504c5c50d8f9a9e48969de381eb98e2a8b89195
+F test/walfault.test 9146e22807d6c75885614f623f5c8b1272c8488e
 F test/walhook.test 5f18e0fc8787f1f8889d7a9971af18f334f83786
 F test/walmode.test bac6f06544a8554588a1543def996bbe2fc41792
 F test/walslow.test d21625e2e99e11c032ce949e8a94661576548933
@@ -812,14 +810,7 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
 F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
 F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
 F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P 9de05bfb09e29bafdf5782263330fe8eefcfaba3
+P ec7157788b16936b4b6e4642107b3c86aa44df24
-R 37171b2dee1e2cfb0d4c65563316cb42
+R 6831c56fbef38774f5073956c09582ec
-U drh
+U dan
-Z 23a5102ed1b42825806ab1e4a794b6d7
+Z 80e37064d0fb8ee254d6e645af9fdd96
------BEGIN PGP SIGNATURE-----
-Version: GnuPG v1.4.6 (GNU/Linux)
-
-iD8DBQFL4b0ZoxKgR168RlERAiSAAJ417bV1PGOMpJIz3ysmcloS8N8BuwCcDdW2
-cZ5DIznx/YBIFs/Nrb9NWhQ=
-=nHgc
------END PGP SIGNATURE-----

manifest.uuid

@@ -1 +1 @@
-ec7157788b16936b4b6e4642107b3c86aa44df24
+72663123d6be2b194cad7a6057d0f20dd0d9fe05

src/tclsqlite.c

@@ -3530,6 +3530,7 @@ int TCLSH_MAIN(int argc, char **argv){
     extern int SqlitetestOsinst_Init(Tcl_Interp*);
     extern int Sqlitetestbackup_Init(Tcl_Interp*);
     extern int Sqlitetestintarray_Init(Tcl_Interp*);
+    extern int Sqlitetestvfs_Init(Tcl_Interp *);
 
     Sqliteconfig_Init(interp);
     Sqlitetest1_Init(interp);
@@ -3556,6 +3557,7 @@ int TCLSH_MAIN(int argc, char **argv){
     SqlitetestOsinst_Init(interp);
     Sqlitetestbackup_Init(interp);
     Sqlitetestintarray_Init(interp);
+    Sqlitetestvfs_Init(interp);
 
 #ifdef SQLITE_SSE
     Sqlitetestsse_Init(interp);

src/test_vfs.c

@@ -0,0 +1,774 @@
+/*
+** 2010 May 05
+**
+** 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.
+**
+******************************************************************************
+**
+*/
+#if SQLITE_TEST          /* This file is used for testing only */
+
+#include "sqlite3.h"
+#include "sqliteInt.h"
+
+typedef struct tvfs_file tvfs_file;
+struct tvfs_file {
+  sqlite3_file base;
+  sqlite3_file *pReal;
+};
+
+typedef struct Testvfs Testvfs;
+typedef struct TestvfsShm TestvfsShm;
+typedef struct TestvfsBuffer TestvfsBuffer;
+
+/*
+** An instance of this structure is allocated for each VFS created. The
+** sqlite3_vfs.pAppData field of the VFS structure registered with SQLite
+** is set to point to it.
+*/
+struct Testvfs {
+  char *zName;                    /* Name of this VFS */
+  sqlite3_vfs *pParent;           /* The VFS to use for file IO */
+  sqlite3_vfs *pVfs;              /* The testvfs registered with SQLite */
+  Tcl_Interp *interp;             /* Interpreter to run script in */
+  int nScript;                    /* Number of elements in array apScript */
+  Tcl_Obj **apScript;             /* Script to execute */
+  TestvfsBuffer *pBuffer;         /* List of shared buffers */
+};
+
+/*
+** A shared-memory buffer.
+*/
+struct TestvfsBuffer {
+  char *zFile;                    /* Associated file name */
+  int n;                          /* Size of allocated buffer in bytes */
+  u8 *a;                          /* Buffer allocated using ckalloc() */
+  int nRef;                       /* Number of references to this object */
+  TestvfsBuffer *pNext;           /* Next in linked list of all buffers */
+};
+
+/*
+** A shared-memory handle returned by tvfsShmOpen().
+*/
+struct TestvfsShm {
+  Tcl_Obj *id;                    /* Name of this handle */
+  TestvfsBuffer *pBuffer;         /* Underlying buffer */
+};
+
+
+#define PARENTVFS(x) (((Testvfs *)((x)->pAppData))->pParent)
+
+
+/*
+** Method declarations for tvfs_file.
+*/
+static int tvfsClose(sqlite3_file*);
+static int tvfsRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+static int tvfsWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
+static int tvfsTruncate(sqlite3_file*, sqlite3_int64 size);
+static int tvfsSync(sqlite3_file*, int flags);
+static int tvfsFileSize(sqlite3_file*, sqlite3_int64 *pSize);
+static int tvfsLock(sqlite3_file*, int);
+static int tvfsUnlock(sqlite3_file*, int);
+static int tvfsCheckReservedLock(sqlite3_file*, int *);
+static int tvfsFileControl(sqlite3_file*, int op, void *pArg);
+static int tvfsSectorSize(sqlite3_file*);
+static int tvfsDeviceCharacteristics(sqlite3_file*);
+
+/*
+** Method declarations for tvfs_vfs.
+*/
+static int tvfsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
+static int tvfsDelete(sqlite3_vfs*, const char *zName, int syncDir);
+static int tvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
+static int tvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+static void *tvfsDlOpen(sqlite3_vfs*, const char *zFilename);
+static void tvfsDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
+static void (*tvfsDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);
+static void tvfsDlClose(sqlite3_vfs*, void*);
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+static int tvfsRandomness(sqlite3_vfs*, int nByte, char *zOut);
+static int tvfsSleep(sqlite3_vfs*, int microseconds);
+static int tvfsCurrentTime(sqlite3_vfs*, double*);
+
+static int tvfsShmOpen(sqlite3_vfs *, const char *, sqlite3_shm **);
+static int tvfsShmSize(sqlite3_vfs*, sqlite3_shm *, int , int *);
+static int tvfsShmGet(sqlite3_vfs*, sqlite3_shm *, int , int *, void **);
+static int tvfsShmRelease(sqlite3_vfs*, sqlite3_shm *);
+static int tvfsShmLock(sqlite3_vfs*, sqlite3_shm *, int , int *);
+static int tvfsShmClose(sqlite3_vfs*, sqlite3_shm *, int);
+
+static sqlite3_io_methods tvfs_io_methods = {
+  1,                            /* iVersion */
+  tvfsClose,                      /* xClose */
+  tvfsRead,                       /* xRead */
+  tvfsWrite,                      /* xWrite */
+  tvfsTruncate,                   /* xTruncate */
+  tvfsSync,                       /* xSync */
+  tvfsFileSize,                   /* xFileSize */
+  tvfsLock,                       /* xLock */
+  tvfsUnlock,                     /* xUnlock */
+  tvfsCheckReservedLock,          /* xCheckReservedLock */
+  tvfsFileControl,                /* xFileControl */
+  tvfsSectorSize,                 /* xSectorSize */
+  tvfsDeviceCharacteristics       /* xDeviceCharacteristics */
+};
+
+/*
+** Close an tvfs-file.
+*/
+static int tvfsClose(sqlite3_file *pFile){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsClose(p->pReal);
+}
+
+/*
+** Read data from an tvfs-file.
+*/
+static int tvfsRead(
+  sqlite3_file *pFile, 
+  void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Write data to an tvfs-file.
+*/
+static int tvfsWrite(
+  sqlite3_file *pFile, 
+  const void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Truncate an tvfs-file.
+*/
+static int tvfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsTruncate(p->pReal, size);
+}
+
+/*
+** Sync an tvfs-file.
+*/
+static int tvfsSync(sqlite3_file *pFile, int flags){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsSync(p->pReal, flags);
+}
+
+/*
+** Return the current file-size of an tvfs-file.
+*/
+static int tvfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsFileSize(p->pReal, pSize);
+}
+
+/*
+** Lock an tvfs-file.
+*/
+static int tvfsLock(sqlite3_file *pFile, int eLock){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsLock(p->pReal, eLock);
+}
+
+/*
+** Unlock an tvfs-file.
+*/
+static int tvfsUnlock(sqlite3_file *pFile, int eLock){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsUnlock(p->pReal, eLock);
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on an tvfs-file.
+*/
+static int tvfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsCheckReservedLock(p->pReal, pResOut);
+}
+
+/*
+** File control method. For custom operations on an tvfs-file.
+*/
+static int tvfsFileControl(sqlite3_file *pFile, int op, void *pArg){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsFileControl(p->pReal, op, pArg);
+}
+
+/*
+** Return the sector-size in bytes for an tvfs-file.
+*/
+static int tvfsSectorSize(sqlite3_file *pFile){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsSectorSize(p->pReal);
+}
+
+/*
+** Return the device characteristic flags supported by an tvfs-file.
+*/
+static int tvfsDeviceCharacteristics(sqlite3_file *pFile){
+  tvfs_file *p = (tvfs_file *)pFile;
+  return sqlite3OsDeviceCharacteristics(p->pReal);
+}
+
+/*
+** Open an tvfs file handle.
+*/
+static int tvfsOpen(
+  sqlite3_vfs *pVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+  int rc;
+  tvfs_file *p = (tvfs_file *)pFile;
+  p->pReal = (sqlite3_file *)&p[1];
+  rc = sqlite3OsOpen(PARENTVFS(pVfs), zName, p->pReal, flags, pOutFlags);
+  if( p->pReal->pMethods ){
+    pFile->pMethods = &tvfs_io_methods;
+  }
+  return rc;
+}
+
+/*
+** Delete the file located at zPath. If the dirSync argument is true,
+** ensure the file-system modifications are synced to disk before
+** returning.
+*/
+static int tvfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  return sqlite3OsDelete(PARENTVFS(pVfs), zPath, dirSync);
+}
+
+/*
+** Test for access permissions. Return true if the requested permission
+** is available, or false otherwise.
+*/
+static int tvfsAccess(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  int flags, 
+  int *pResOut
+){
+  return sqlite3OsAccess(PARENTVFS(pVfs), zPath, flags, pResOut);
+}
+
+/*
+** Populate buffer zOut with the full canonical pathname corresponding
+** to the pathname in zPath. zOut is guaranteed to point to a buffer
+** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
+*/
+static int tvfsFullPathname(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  int nOut, 
+  char *zOut
+){
+  return sqlite3OsFullPathname(PARENTVFS(pVfs), zPath, nOut, zOut);
+}
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+/*
+** Open the dynamic library located at zPath and return a handle.
+*/
+static void *tvfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  return sqlite3OsDlOpen(PARENTVFS(pVfs), zPath);
+}
+
+/*
+** Populate the buffer zErrMsg (size nByte bytes) with a human readable
+** utf-8 string describing the most recent error encountered associated 
+** with dynamic libraries.
+*/
+static void tvfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
+  sqlite3OsDlError(PARENTVFS(pVfs), nByte, zErrMsg);
+}
+
+/*
+** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
+*/
+static void (*tvfsDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
+  return sqlite3OsDlSym(PARENTVFS(pVfs), p, zSym);
+}
+
+/*
+** Close the dynamic library handle pHandle.
+*/
+static void tvfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  sqlite3OsDlClose(PARENTVFS(pVfs), pHandle);
+}
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+
+/*
+** Populate the buffer pointed to by zBufOut with nByte bytes of 
+** random data.
+*/
+static int tvfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  return sqlite3OsRandomness(PARENTVFS(pVfs), nByte, zBufOut);
+}
+
+/*
+** Sleep for nMicro microseconds. Return the number of microseconds 
+** actually slept.
+*/
+static int tvfsSleep(sqlite3_vfs *pVfs, int nMicro){
+  return sqlite3OsSleep(PARENTVFS(pVfs), nMicro);
+}
+
+/*
+** Return the current time as a Julian Day number in *pTimeOut.
+*/
+static int tvfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+  return PARENTVFS(pVfs)->xCurrentTime(PARENTVFS(pVfs), pTimeOut);
+}
+
+static void tvfsGrowBuffer(TestvfsShm *pShm, int reqSize, int *pNewSize){
+  TestvfsBuffer *pBuffer = pShm->pBuffer;
+  if( reqSize>pBuffer->n ){
+    pBuffer->a = (u8 *)ckrealloc((char *)pBuffer->a, reqSize);
+    pBuffer->n = reqSize;
+  }
+  *pNewSize = pBuffer->n;
+}
+
+static void tvfsExecTcl(
+  Testvfs *p, 
+  const char *zMethod,
+  Tcl_Obj *arg1,
+  Tcl_Obj *arg2,
+  Tcl_Obj *arg3
+){
+  int rc;                         /* Return code from Tcl_EvalObj() */
+  int nArg;                       /* Elements in eval'd list */
+
+  p->apScript[p->nScript] = Tcl_NewStringObj(zMethod, -1);
+  p->apScript[p->nScript+1] = arg1;
+  p->apScript[p->nScript+2] = arg2;
+  p->apScript[p->nScript+3] = arg3;
+
+  for(nArg=p->nScript; p->apScript[nArg]; nArg++){
+    Tcl_IncrRefCount(p->apScript[nArg]);
+  }
+
+  rc = Tcl_EvalObjv(p->interp, nArg, p->apScript, TCL_EVAL_GLOBAL);
+  if( rc!=TCL_OK ){
+    Tcl_BackgroundError(p->interp);
+    Tcl_ResetResult(p->interp);
+  }
+
+  for(nArg=p->nScript; p->apScript[nArg]; nArg++){
+    Tcl_DecrRefCount(p->apScript[nArg]);
+    p->apScript[nArg] = 0;
+  }
+}
+
+static int tvfsResultCode(Testvfs *p, int *pRc){
+  struct errcode {
+    int eCode;
+    const char *zCode;
+  } aCode[] = {
+    { SQLITE_OK,     "SQLITE_OK"     },
+    { SQLITE_ERROR,  "SQLITE_ERROR"  },
+    { SQLITE_IOERR,  "SQLITE_IOERR"  },
+    { SQLITE_LOCKED, "SQLITE_LOCKED" },
+  };
+
+  const char *z;
+  int i;
+
+  z = Tcl_GetStringResult(p->interp);
+  for(i=0; i<ArraySize(aCode); i++){
+    if( 0==strcmp(z, aCode[i].zCode) ){
+      *pRc = aCode[i].eCode;
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+static int tvfsShmOpen(
+  sqlite3_vfs *pVfs, 
+  const char *zName, 
+  sqlite3_shm **pp
+){
+  Testvfs *p = (Testvfs *)(pVfs->pAppData);
+  int rc = SQLITE_OK;             /* Return code */
+  Tcl_Obj *pId = 0;               /* Id for this connection */
+  TestvfsBuffer *pBuffer;         /* Buffer to open connection to */
+  TestvfsShm *pShm;               /* New shm handle */
+
+  /* Evaluate the Tcl script: 
+  **
+  **   SCRIPT xShmOpen FILENAME
+  **
+  ** If the script returns an SQLite error code other than SQLITE_OK, an
+  ** error is returned to the caller. If it returns SQLITE_OK, the new
+  ** connection is named "anon". Otherwise, the value returned by the
+  ** script is used as the connection name.
+  */
+  tvfsExecTcl(p, "xShmOpen", Tcl_NewStringObj(zName, -1), 0, 0);
+  if( tvfsResultCode(p, &rc) ){
+    if( rc!=SQLITE_OK ) return rc;
+    pId = Tcl_NewStringObj("anon", -1);
+  }else{
+    pId = Tcl_GetObjResult(p->interp);
+  }
+  Tcl_IncrRefCount(pId);
+
+  /* Allocate the TestvfsShm handle. */
+  pShm = (TestvfsShm *)ckalloc(sizeof(TestvfsShm));
+  memset(pShm, 0, sizeof(TestvfsShm));
+  pShm->id = pId;
+
+  /* Search for a TestvfsBuffer. Create a new one if required. */
+  for(pBuffer=p->pBuffer; pBuffer; pBuffer=pBuffer->pNext){
+    if( 0==strcmp(zName, pBuffer->zFile) ) break;
+  }
+  if( !pBuffer ){
+    int nByte = sizeof(TestvfsBuffer) + strlen(zName) + 1;
+    pBuffer = (TestvfsBuffer *)ckalloc(nByte);
+    memset(pBuffer, 0, nByte);
+    pBuffer->zFile = (char *)&pBuffer[1];
+    strcpy(pBuffer->zFile, zName);
+    pBuffer->pNext = p->pBuffer;
+    p->pBuffer = pBuffer;
+  }
+
+  /* Connect the TestvfsBuffer to the new TestvfsShm handle and return. */
+  pBuffer->nRef++;
+  pShm->pBuffer = pBuffer;
+  *pp = (sqlite3_shm *)pShm;
+  return SQLITE_OK;
+}
+
+static int tvfsShmSize(
+  sqlite3_vfs *pVfs,
+  sqlite3_shm *pShmHandle,
+  int reqSize,
+  int *pNewSize
+){
+  int rc = SQLITE_OK;
+  Testvfs *p = (Testvfs *)(pVfs->pAppData);
+  TestvfsShm *pShm = (TestvfsShm *)pShmHandle;
+
+  tvfsGrowBuffer(pShm, reqSize, pNewSize);
+  tvfsExecTcl(p, "xShmSize", 
+      Tcl_NewStringObj(pShm->pBuffer->zFile, -1), pShm->id, 0
+  );
+  tvfsResultCode(p, &rc);
+  return rc;
+}
+
+static int tvfsShmGet(
+  sqlite3_vfs *pVfs,
+  sqlite3_shm *pShmHandle, 
+  int reqMapSize, 
+  int *pMapSize, 
+  void **pp
+){
+  int rc = SQLITE_OK;
+  Testvfs *p = (Testvfs *)(pVfs->pAppData);
+  TestvfsShm *pShm = (TestvfsShm *)pShmHandle;
+
+  tvfsGrowBuffer(pShm, reqMapSize, pMapSize);
+  tvfsExecTcl(p, "xShmGet", 
+      Tcl_NewStringObj(pShm->pBuffer->zFile, -1), pShm->id, 0
+  );
+  tvfsResultCode(p, &rc);
+  *pp = pShm->pBuffer->a;
+  return rc;
+}
+
+static int tvfsShmRelease(sqlite3_vfs *pVfs, sqlite3_shm *pShmHandle){
+  int rc = SQLITE_OK;
+  Testvfs *p = (Testvfs *)(pVfs->pAppData);
+  TestvfsShm *pShm = (TestvfsShm *)pShmHandle;
+
+  tvfsExecTcl(p, "xShmRelease", 
+      Tcl_NewStringObj(pShm->pBuffer->zFile, -1), pShm->id, 0
+  );
+  tvfsResultCode(p, &rc);
+
+  return rc;
+}
+
+static int tvfsShmLock(
+  sqlite3_vfs *pVfs,
+  sqlite3_shm *pShmHandle,
+  int desiredLock,
+  int *gotLock
+){
+  int rc = SQLITE_OK;
+  Testvfs *p = (Testvfs *)(pVfs->pAppData);
+  TestvfsShm *pShm = (TestvfsShm *)pShmHandle;
+  char *zLock = "";
+
+  switch( desiredLock ){
+    case SQLITE_SHM_READ:         zLock = "READ";       break;
+    case SQLITE_SHM_WRITE:        zLock = "WRITE";      break;
+    case SQLITE_SHM_CHECKPOINT:   zLock = "CHECKPOINT"; break;
+    case SQLITE_SHM_RECOVER:      zLock = "RECOVER";    break;
+    case SQLITE_SHM_PENDING:      zLock = "PENDING";    break;
+    case SQLITE_SHM_UNLOCK:       zLock = "UNLOCK";     break;
+  }
+  tvfsExecTcl(p, "xShmLock", 
+      Tcl_NewStringObj(pShm->pBuffer->zFile, -1), pShm->id,
+      Tcl_NewStringObj(zLock, -1)
+  );
+  tvfsResultCode(p, &rc);
+  if( rc==SQLITE_OK ){
+    *gotLock = desiredLock;
+  }
+
+  return rc;
+}
+
+static int tvfsShmClose(
+  sqlite3_vfs *pVfs, 
+  sqlite3_shm *pShmHandle, 
+  int deleteFlag
+){
+  int rc = SQLITE_OK;
+  Testvfs *p = (Testvfs *)(pVfs->pAppData);
+  TestvfsShm *pShm = (TestvfsShm *)pShmHandle;
+  TestvfsBuffer *pBuffer = pShm->pBuffer;
+
+  assert( (deleteFlag!=0)==(pBuffer->nRef==1) );
+
+  tvfsExecTcl(p, "xShmClose", 
+      Tcl_NewStringObj(pShm->pBuffer->zFile, -1), pShm->id, 0
+  );
+  tvfsResultCode(p, &rc);
+
+  pBuffer->nRef--;
+  if( pBuffer->nRef==0 ){
+    TestvfsBuffer **pp;
+    for(pp=&p->pBuffer; *pp!=pBuffer; pp=&((*pp)->pNext));
+    *pp = (*pp)->pNext;
+    ckfree((char *)pBuffer->a);
+    ckfree((char *)pBuffer);
+  }
+  Tcl_DecrRefCount(pShm->id);
+  ckfree((char *)pShm);
+
+  return rc;
+}
+
+static int testvfs_obj_cmd(
+  ClientData cd,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Testvfs *p = (Testvfs *)cd;
+
+  static const char *CMD_strs[] = { "shm", "delete", 0 };
+  enum DB_enum { CMD_SHM, CMD_DELETE };
+  int i;
+  
+  if( objc<2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIndexFromObj(interp, objv[1], CMD_strs, "subcommand", 0, &i) ){
+    return TCL_ERROR;
+  }
+  Tcl_ResetResult(interp);
+
+  switch( (enum DB_enum)i ){
+    case CMD_SHM: {
+      TestvfsBuffer *pBuffer;
+      char *zName;
+      if( objc!=3 && objc!=4 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "FILE ?VALUE?");
+        return TCL_ERROR;
+      }
+      zName = Tcl_GetString(objv[2]);
+      for(pBuffer=p->pBuffer; pBuffer; pBuffer=pBuffer->pNext){
+        if( 0==strcmp(pBuffer->zFile, zName) ) break;
+      }
+      if( !pBuffer ){
+        Tcl_AppendResult(interp, "no such file: ", zName, 0);
+        return TCL_ERROR;
+      }
+      if( objc==4 ){
+        int n;
+        u8 *a = Tcl_GetByteArrayFromObj(objv[3], &n);
+        pBuffer->a = (u8 *)ckrealloc((char *)pBuffer->a, n);
+        pBuffer->n = n;
+        memcpy(pBuffer->a, a, n);
+      }
+      Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBuffer->a, pBuffer->n));
+      break;
+    }
+    case CMD_DELETE: {
+      Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
+      break;
+    }
+  }
+
+  return TCL_OK;
+}
+
+static void testvfs_obj_del(ClientData cd){
+  int i;
+  Testvfs *p = (Testvfs *)cd;
+  for(i=0; i<p->nScript; i++){
+    Tcl_DecrRefCount(p->apScript[i]);
+  }
+  sqlite3_vfs_unregister(p->pVfs);
+  ckfree((char *)p->pVfs);
+  ckfree((char *)p);
+}
+
+#define TESTVFS_MAX_ARGS 12
+
+/*
+** Usage:  testvfs VFSNAME SCRIPT
+**
+** This command creates two things when it is invoked: an SQLite VFS, and
+** a Tcl command. Both are named VFSNAME. The VFS is installed. It is not
+** installed as the default VFS.
+**
+** The VFS passes all file I/O calls through to the underlying VFS.
+**
+** Whenever one of the xShmSize, xShmGet or xShmRelease methods of the VFS
+** are invoked, the SCRIPT is executed as follows:
+**
+**   SCRIPT xShmSize    FILENAME ID
+**   SCRIPT xShmGet     FILENAME ID
+**   SCRIPT xShmRelease FILENAME ID
+**
+** The value returned by the invocation of SCRIPT above is interpreted as
+** an SQLite error code and returned to SQLite. Either a symbolic 
+** "SQLITE_OK" or numeric "0" value may be returned.
+**
+** The contents of the shared-memory buffer associated with a given file
+** may be read and set using the following command:
+**
+**   VFSNAME shm FILENAME ?NEWVALUE?
+**
+** When the xShmLock method is invoked by SQLite, the following script is
+** run:
+**
+**   SCRIPT xShmLock    FILENAME ID LOCK
+**
+** where LOCK is one of "UNLOCK", "READ", "READ_FULL", "WRITE", "PENDING",
+** "CHECKPOINT" or "RECOVER". The script should return an SQLite error
+** code.
+*/
+static int testvfs_cmd(
+  ClientData cd,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+
+  static sqlite3_vfs tvfs_vfs = {
+    2,                            /* iVersion */
+    sizeof(tvfs_file),            /* szOsFile */
+    0,                            /* mxPathname */
+    0,                            /* pNext */
+    0,                            /* zName */
+    0,                            /* pAppData */
+    tvfsOpen,                     /* xOpen */
+    tvfsDelete,                   /* xDelete */
+    tvfsAccess,                   /* xAccess */
+    tvfsFullPathname,             /* xFullPathname */
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+    tvfsDlOpen,                   /* xDlOpen */
+    tvfsDlError,                  /* xDlError */
+    tvfsDlSym,                    /* xDlSym */
+    tvfsDlClose,                  /* xDlClose */
+#else
+    0,                            /* xDlOpen */
+    0,                            /* xDlError */
+    0,                            /* xDlSym */
+    0,                            /* xDlClose */
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+    tvfsRandomness,               /* xRandomness */
+    tvfsSleep,                    /* xSleep */
+    tvfsCurrentTime,              /* xCurrentTime */
+    0,                            /* xGetLastError */
+    tvfsShmOpen,
+    tvfsShmSize,
+    tvfsShmGet,
+    tvfsShmRelease,
+    tvfsShmLock,
+    tvfsShmClose,
+    0,
+    0,
+  };
+
+  Testvfs *p;                     /* New object */
+  sqlite3_vfs *pVfs;              /* New VFS */
+  char *zVfs;
+  Tcl_Obj *pScript;
+  int nScript;                    /* Number of elements in list pScript */
+  Tcl_Obj **apScript;             /* Array of pScript elements */
+  int nByte;                      /* Bytes of space to allocate at p */
+  int i;                          /* Counter variable */
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "VFSNAME SCRIPT");
+    return TCL_ERROR;
+  }
+  zVfs = Tcl_GetString(objv[1]);
+  pScript = objv[2];
+
+  if( TCL_OK!=Tcl_ListObjGetElements(interp, pScript, &nScript, &apScript) ){
+    return TCL_ERROR;
+  }
+
+  nByte = sizeof(Testvfs)
+        + (nScript+TESTVFS_MAX_ARGS)*sizeof(Tcl_Obj *) 
+        + strlen(zVfs)+1;
+  p = (Testvfs *)ckalloc(nByte);
+  memset(p, 0, nByte);
+
+  p->pParent = sqlite3_vfs_find(0);
+  p->interp = interp;
+  p->nScript = nScript;
+  p->apScript = (Tcl_Obj **)&p[1];
+  for(i=0; i<nScript; i++){
+    p->apScript[i] = apScript[i];
+    Tcl_IncrRefCount(p->apScript[i]);
+  }
+  p->zName = (char *)&p->apScript[nScript+TESTVFS_MAX_ARGS];
+  strcpy(p->zName, zVfs);
+
+  pVfs = (sqlite3_vfs *)ckalloc(sizeof(sqlite3_vfs));
+  memcpy(pVfs, &tvfs_vfs, sizeof(sqlite3_vfs));
+  pVfs->pAppData = (void *)p;
+  pVfs->zName = p->zName;
+  pVfs->mxPathname = p->pParent->mxPathname;
+  pVfs->szOsFile += p->pParent->szOsFile;
+
+  Tcl_CreateObjCommand(interp, zVfs, testvfs_obj_cmd, p, testvfs_obj_del);
+  sqlite3_vfs_register(pVfs, 0);
+
+  return TCL_OK;
+}
+
+int Sqlitetestvfs_Init(Tcl_Interp *interp){
+  Tcl_CreateObjCommand(interp, "testvfs", testvfs_cmd, 0, 0);
+  return TCL_OK;
+}
+
+#endif

src/wal.c

@@ -433,11 +433,14 @@ static int walIndexRemap(Wal *pWal, int enlargeTo){
 ** here.
 */
 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
+  int rc;
   u32 iSlot = walIndexEntry(iFrame);
   
-  walIndexMap(pWal, -1);
+  rc = walIndexMap(pWal, -1);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
   while( ((iSlot+128)*sizeof(u32))>=pWal->szWIndex ){
-    int rc;
     int nByte = pWal->szWIndex + WALINDEX_MMAP_INCREMENT;
 
     /* Enlarge the storage, then remap it. */
@@ -539,7 +542,8 @@ static int walIndexRecover(Wal *pWal){
       if( rc!=SQLITE_OK ) break;
       isValid = walDecodeFrame(aCksum, &pgno, &nTruncate, nPgsz, aData, aFrame);
       if( !isValid ) break;
-      walIndexAppend(pWal, ++iFrame, pgno);
+      rc = walIndexAppend(pWal, ++iFrame, pgno);
+      if( rc!=SQLITE_OK ) break;
 
       /* If nTruncate is non-zero, this is a commit record. */
       if( nTruncate ){
@@ -851,7 +855,7 @@ int sqlite3WalClose(
 **
 ** If the checksum cannot be verified return SQLITE_ERROR.
 */
-int walIndexTryHdr(Wal *pWal, int *pChanged){
+int walIndexTryHdr(Wal *pWal, int *pisValid, int *pChanged){
   u32 aCksum[2] = {1, 1};
   u32 aHdr[WALINDEX_HDR_NFIELD+2];
 
@@ -874,8 +878,9 @@ int walIndexTryHdr(Wal *pWal, int *pChanged){
   if( aCksum[0]!=aHdr[WALINDEX_HDR_NFIELD]
    || aCksum[1]!=aHdr[WALINDEX_HDR_NFIELD+1]
   ){
-    return SQLITE_ERROR;
+    return SQLITE_OK;
   }
+  *pisValid = 1;
 
   if( memcmp(&pWal->hdr, aHdr, sizeof(WalIndexHdr)) ){
     if( pChanged ){
@@ -896,15 +901,20 @@ int walIndexTryHdr(Wal *pWal, int *pChanged){
 */
 static int walIndexReadHdr(Wal *pWal, int *pChanged){
   int rc;
+  int isValid = 0;
 
   assert( pWal->lockState>=SQLITE_SHM_READ );
-  walIndexMap(pWal, -1);
+  rc = walIndexMap(pWal, -1);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
 
   /* First try to read the header without a lock. Verify the checksum
   ** before returning. This will almost always work.  
   */
-  if( SQLITE_OK==walIndexTryHdr(pWal, pChanged) ){
+  rc = walIndexTryHdr(pWal, &isValid, pChanged);
-    return SQLITE_OK;
+  if( isValid || rc!=SQLITE_OK ){
+    return rc;
   }
 
   /* If the first attempt to read the header failed, lock the wal-index
@@ -912,18 +922,22 @@ static int walIndexReadHdr(Wal *pWal, int *pChanged){
   ** time as well, run log recovery.
   */
   if( SQLITE_OK==(rc = walSetLock(pWal, SQLITE_SHM_RECOVER)) ){
-    if( SQLITE_OK!=walIndexTryHdr(pWal, pChanged) ){
+    rc = walIndexTryHdr(pWal, &isValid, pChanged);
+    if( rc==SQLITE_OK && isValid==0 ){
       if( pChanged ){
         *pChanged = 1;
       }
       rc = walIndexRecover(pWal);
       if( rc==SQLITE_OK ){
-        rc = walIndexTryHdr(pWal, 0);
+        rc = walIndexTryHdr(pWal, &isValid, 0);
       }
     }
     walSetLock(pWal, SQLITE_SHM_READ);
   }
 
+  if( rc==SQLITE_OK && isValid==0 ){
+    rc = SQLITE_ERROR;
+  }
   return rc;
 }
 
@@ -981,12 +995,16 @@ int sqlite3WalRead(
   int nOut,
   u8 *pOut
 ){
+  int rc;                         /* Return code */
   u32 iRead = 0;
   u32 *aData; 
   int iFrame = (pWal->hdr.iLastPg & 0xFFFFFF00);
 
   assert( pWal->lockState==SQLITE_SHM_READ||pWal->lockState==SQLITE_SHM_WRITE );
-  walIndexMap(pWal, -1);
+  rc = walIndexMap(pWal, -1);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
 
   /* Do a linear search of the unindexed block of page-numbers (if any) 
   ** at the end of the wal-index. An alternative to this would be to
@@ -1105,7 +1123,7 @@ int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
   Pgno iMax = pWal->hdr.iLastPg;
   Pgno iFrame;
 
-  walIndexReadHdr(pWal, 0);
+  rc = walIndexReadHdr(pWal, 0);
   for(iFrame=pWal->hdr.iLastPg+1; iFrame<=iMax && rc==SQLITE_OK; iFrame++){
     assert( pWal->lockState==SQLITE_SHM_WRITE );
     rc = xUndo(pUndoCtx, pWal->pWiData[walIndexEntry(iFrame)]);
@@ -1237,9 +1255,6 @@ int sqlite3WalFrames(
     }
 
     rc = sqlite3OsSync(pWal->pFd, sync_flags);
-    if( rc!=SQLITE_OK ){
-      return rc;
-    }
   }
   assert( pWal->pWiData==0 );
 
@@ -1249,33 +1264,35 @@ int sqlite3WalFrames(
   ** be in use by existing readers is being overwritten.
   */
   iFrame = pWal->hdr.iLastPg;
-  for(p=pList; p; p=p->pDirty){
+  for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
     iFrame++;
-    walIndexAppend(pWal, iFrame, p->pgno);
+    rc = walIndexAppend(pWal, iFrame, p->pgno);
   }
-  while( nLast>0 ){
+  while( nLast>0 && rc==SQLITE_OK ){
     iFrame++;
     nLast--;
-    walIndexAppend(pWal, iFrame, pLast->pgno);
+    rc = walIndexAppend(pWal, iFrame, pLast->pgno);
   }
 
-  /* Update the private copy of the header. */
+  if( rc==SQLITE_OK ){
-  pWal->hdr.pgsz = nPgsz;
+    /* Update the private copy of the header. */
-  pWal->hdr.iLastPg = iFrame;
+    pWal->hdr.pgsz = nPgsz;
-  if( isCommit ){
+    pWal->hdr.iLastPg = iFrame;
-    pWal->hdr.iChange++;
+    if( isCommit ){
-    pWal->hdr.nPage = nTruncate;
+      pWal->hdr.iChange++;
-  }
+      pWal->hdr.nPage = nTruncate;
-  pWal->hdr.iCheck1 = aCksum[0];
+    }
-  pWal->hdr.iCheck2 = aCksum[1];
+    pWal->hdr.iCheck1 = aCksum[0];
+    pWal->hdr.iCheck2 = aCksum[1];
 
-  /* If this is a commit, update the wal-index header too. */
+    /* If this is a commit, update the wal-index header too. */
-  if( isCommit ){
+    if( isCommit ){
-    walIndexWriteHdr(pWal, &pWal->hdr);
+      walIndexWriteHdr(pWal, &pWal->hdr);
-    pWal->iCallback = iFrame;
+      pWal->iCallback = iFrame;
+    }
   }
+
   walIndexUnmap(pWal);
-
   return rc;
 }
 

test/walfault.test

@@ -52,5 +52,75 @@ do_malloc_test walfault-oom-2 -tclprep {
   SELECT count(*) FROM x;
 }
 
+# A [testvfs] callback for the VFS created by [do_shmfault_test]. This
+# callback injects SQLITE_IOERR faults into the following methods:
+#
+#   xShmOpen
+#   xShmSize
+#   xShmGet
+# 
+# Faults are not injected into xShmRelease, xShmClose or xShmLock method 
+# calls. The global tcl variables used are:
+#
+#   $::shmfault_ioerr_countdown
+#   $::shmfault_ioerr_persist
+#
+proc shmfault_vfs_cb {method args} {
+
+  # If ::shmfault_ioerr_countdown is not set, always return SQLITE_OK.
+  #
+  if {[info exists ::shmfault_ioerr_countdown]==0} { return SQLITE_OK }
+
+  if {$method == "xShmOpen"
+   || $method == "xShmSize"
+   || $method == "xShmGet"
+  } {
+    incr ::shmfault_ioerr_countdown -1
+    if { ($::shmfault_ioerr_countdown==0)
+      || ($::shmfault_ioerr_countdown<=0 && $::shmfault_ioerr_persist)
+    } {
+      return SQLITE_IOERR
+    }
+  }
+  return SQLITE_OK
+}
+
+proc do_shmfault_test {name args} {
+  array set A $args
+
+  # Create a VFS to use:
+  testvfs shmfault shmfault_vfs_cb
+  
+  foreach mode {transient persistent} {
+    set ::shmfault_ioerr_persist [expr {$mode == "persistent"}]
+    for {set nDelay 1} {$nDelay < 10000} {incr nDelay} {
+      set ::shmfault_ioerr_countdown $nDelay
+  
+      file delete -force test.db test.db-wal test.db-journal
+      
+      set rc [catch {
+        sqlite3 db test.db -vfs shmfault
+        db eval $A(-sqlbody)
+      } msg]
+      set hit_error [expr {$::shmfault_ioerr_countdown<=0}]
+      unset ::shmfault_ioerr_countdown
+      catch { db close }
+      
+      do_test $name-$mode.$nDelay.1 [list set {} $hit_error] $rc
+  
+      if {$hit_error==0} break
+    }
+  }
+
+  shmfault delete
+}
+
+do_shmfault_test walfault-shm-1 -sqlbody {
+  PRAGMA journal_mode = WAL;
+  CREATE TABLE t1(a PRIMARY KEY, b);
+  INSERT INTO t1 VALUES('a', 'b');
+  PRAGMA wal_checkpoint;
+}
 
 finish_test
+