Refactoring the VFS-SHM methods used by WAL. This version compiles and

runs non-WAL test cases but crashes and burns on wal.test.

FossilOrigin-Name: 2b00152c1ac0b3735aa6cfab61259ff04d81c701

doc/vfs-shm.txt

@@ -78,14 +78,24 @@ during testing using an instrumented lock manager.
 
 (5)  No part of the wal-index will be read without holding either some
      kind of SHM lock or an EXCLUSIVE lock on the original database.
+     The original database is the file named in the 2nd parameter to
+     the xShmOpen method.
+
 (6)  A holder of a READ_FULL will never read any page of the database
      file that is contained anywhere in the wal-index.
+
 (7)  No part of the wal-index other than the header will be written nor
-     will the size of the wal-index grow without holding a WRITE.
+     will the size of the wal-index grow without holding a WRITE or
+     an EXCLUSIVE on the original database file.
+
 (8)  The wal-index header will not be written without holding one of
-     WRITE, CHECKPOINT, or RECOVER.
+     WRITE, CHECKPOINT, or RECOVER on the wal-index or an EXCLUSIVE on
-(9)  A CHECKPOINT or RECOVER must be held in order to reset the last valid
+     the original database files.
-     frame counter in the header of the wal-index back to zero.
+
+(9)  A CHECKPOINT or RECOVER must be held on the wal-index, or an
+     EXCLUSIVE on the original database file, in order to reset the 
+     last valid frame counter in the header of the wal-index back to zero.
+
 (10) A WRITE can only increase the last valid frame pointer in the header.
 
 The SQLite core will only ever send requests for UNLOCK, READ, WRITE,

manifest

@@ -1,8 +1,8 @@
 -----BEGIN PGP SIGNED MESSAGE-----
 Hash: SHA1
 
-C Remove\sthe\sOP_Variable\soptimization\sof\scheck-in\s[48b77b04935d894]\ssince\sit\ncan\slead\sto\smalfunctions\sas\sdescribed\sin\sticket\s[26ff0c82d1e90].
+C Refactoring\sthe\sVFS-SHM\smethods\sused\sby\sWAL.\s\sThis\sversion\scompiles\sand\nruns\snon-WAL\stest\scases\sbut\scrashes\sand\sburns\son\swal.test.
-D 2010-05-12T13:50:23
+D 2010-05-12T18:01:40
 F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0
 F Makefile.in a5cad1f8f3e021356bfcc6c77dc16f6f1952bbc3
 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
@@ -27,7 +27,7 @@ F configure.ac 14740970ddb674d92a9f5da89083dff1179014ff
 F contrib/sqlitecon.tcl 210a913ad63f9f991070821e599d600bd913e0ad
 F doc/lemon.html f0f682f50210928c07e562621c3b7e8ab912a538
 F doc/pager-invariants.txt 870107036470d7c419e93768676fae2f8749cf9e
-F doc/vfs-shm.txt 7945d691a41ec90f358f6415095ffe70cfc9fe9e
+F doc/vfs-shm.txt e101f27ea02a8387ce46a05be2b1a902a021d37a
 F ext/README.txt 913a7bd3f4837ab14d7e063304181787658b14e1
 F ext/async/README.txt 0c541f418b14b415212264cbaaf51c924ec62e5b
 F ext/async/sqlite3async.c 676066c2a111a8b3107aeb59bdbbbf335c348f4a
@@ -151,14 +151,14 @@ F src/mutex_os2.c 20477db50cf3817c2f1cd3eb61e5c177e50231db
 F src/mutex_unix.c 04a25238abce7e3d06b358dcf706e26624270809
 F src/mutex_w32.c 4cc201c1bfd11d1562810554ff5500e735559d7e
 F src/notify.c cbfa66a836da3a51567209636e6a94059c137930
-F src/os.c aec6922553585a25d5655666defc125a7e217674
+F src/os.c c0a5dfce2a214dacb679425632d04f8a2021f364
-F src/os.h b389844e5469a2918e8a45fe6ae52b4c28dfb2b2
+F src/os.h 8a7e2456237ecf3a2e55b02f9fe6091f1ad36902
 F src/os_common.h 0d6ee583b6ee3185eb9d951f890c6dd03021a08d
 F src/os_os2.c 8ad77a418630d7dee91d1bb04f79c2096301d3a0
-F src/os_unix.c c306feb1be41283afc47f1da74363d2bde466aae
+F src/os_unix.c c7ff5a947fc0a09de1c9c2008e3646551a1a8137
 F src/os_win.c a8fc01d8483be472e495793c01064fd87e56a5c1
-F src/pager.c ad9cb3bea70d8b159de1a9b235c94c7abc340956
+F src/pager.c 1e163a82ae8405433dca559831caa06aafbba3b0
-F src/pager.h 934b598583a9d936bb13c37d62a2fe68ac48781c
+F src/pager.h 76466c3a5af56943537f68b1f16567101a0cd1d0
 F src/parse.y ace5c7a125d9f2a410e431ee3209034105045f7e
 F src/pcache.c ace8f6a5ecd4711cc66a1b23053be7109bd437cf
 F src/pcache.h c683390d50f856d4cd8e24342ae62027d1bb6050
@@ -171,7 +171,7 @@ F src/resolve.c ac5f1a713cd1ae77f08b83cc69581e11bf5ae6f9
 F src/rowset.c 69afa95a97c524ba6faf3805e717b5b7ae85a697
 F src/select.c c03d8a0565febcde8c6a12c5d77d065fddae889b
 F src/shell.c fd4ccdb37c3b68de0623eb938a649e0990710714
-F src/sqlite.h.in aa54957165356be128b9c8baf3fc66592cb2da7f
+F src/sqlite.h.in a86bb87f5c9e97ed286a70d515d6c19de031f382
 F src/sqlite3ext.h 69dfb8116af51b84a029cddb3b35062354270c89
 F src/sqliteInt.h 9819b45610abeca390176243a9a31758c1f0ac7a
 F src/sqliteLimit.h 196e2f83c3b444c4548fc1874f52f84fdbda40f3
@@ -183,7 +183,7 @@ F src/test2.c 31f1b9d076b4774a22d2605d0af1f34e14a9a7bd
 F src/test3.c 4c21700c73a890a47fc685c1097bfb661346ac94
 F src/test4.c ad03bb987ddedce928f4258c1e7fa4109a73497d
 F src/test5.c cc55900118fa4add8ec9cf69fc4225a4662f76b1
-F src/test6.c 8b9eedc2fee0850636797bcd30a9dd740b449cd7
+F src/test6.c d00c3930e2d22a9dc84415b1a2ead2ca4ab430ae
 F src/test7.c 3f2d63e4ccf97f8c2cf1a7fa0a3c8e2e2a354e6e
 F src/test8.c f959db9a22d882013b64c92753fa793b2ce3bdea
 F src/test9.c bea1e8cf52aa93695487badedd6e1886c321ea60
@@ -193,7 +193,7 @@ F src/test_backup.c c129c91127e9b46e335715ae2e75756e25ba27de
 F src/test_btree.c 47cd771250f09cdc6e12dda5bc71bc0b3abc96e2
 F src/test_config.c 6210f501d358bde619ae761f06f123529c6ba24f
 F src/test_demovfs.c da81a5f7785bb352bda7911c332a983ec4f17f27
-F src/test_devsym.c 257adf02150986902f1f15b478f8a319ecfce7f3
+F src/test_devsym.c c910ea795b7cd9dc1bb8e90776816ef5ed8833ea
 F src/test_func.c 13b582345fb1185a93e46c53310fae8547dcce20
 F src/test_hexio.c 1237f000ec7a491009b1233f5c626ea71bce1ea2
 F src/test_init.c 5d624ffd0409d424cf9adbfe1f056b200270077c
@@ -203,14 +203,14 @@ F src/test_journal.c 51da4dd6118ee843349592fde29429fab84a6243
 F src/test_loadext.c df586c27176e3c2cb2e099c78da67bf14379a56e
 F src/test_malloc.c 2842c922b8e8d992aba722214952204ca025b411
 F src/test_mutex.c ce06b59aca168cd8c520b77159a24352a7469bd3
-F src/test_onefile.c d9585f6e2056868f208b0c21378a05b68c9ceae2
+F src/test_onefile.c df4d7858b5cd1dffe92d36ec9dbad11f0037ffd1
 F src/test_osinst.c f5d1a4ee8b80fc58d1430c56146de748584013a9
 F src/test_pcache.c 7bf828972ac0d2403f5cfa4cd14da41f8ebe73d8
 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 c1e13b5f787042130878996f31827ffb5d4d8efc
+F src/test_vfs.c 6e828b42e1b50ce923f9bde890f84f78f8cc8b74
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/tokenize.c 25ceb0f0a746ea1d0f9553787f3f0a56853cfaeb
 F src/trigger.c 8927588cb9e6d47f933b53bfe74200fbb504100d
@@ -218,7 +218,7 @@ F src/update.c c0dc6b75ad28b76b619042d934f337b02acee208
 F src/utf.c 1baeeac91707a4df97ccc6141ec0f808278af685
 F src/util.c 32aebf04c10e51ad3977a928b7416bed671b620b
 F src/vacuum.c b17355fc10cef0875626932ec2f1fa1deb0daa48
-F src/vdbe.c f41188f624dccabf9f1fd1cb6af57314857e9dd2
+F src/vdbe.c 8c6301a7dd844d2d6370ebd46f4e2d0cf449c2de
 F src/vdbe.h 471f6a3dcec4817ca33596fe7f6654d56c0e75f3
 F src/vdbeInt.h 19ebc8c2a2e938340051ee65af3f377fb99102d1
 F src/vdbeapi.c dc3138f10afbc95ed3c21dd25abb154504b1db9d
@@ -227,8 +227,8 @@ F src/vdbeblob.c 5327132a42a91e8b7acfb60b9d2c3b1c5c863e0e
 F src/vdbemem.c 2a82f455f6ca6f78b59fb312f96054c04ae0ead1
 F src/vdbetrace.c 864cef96919323482ebd9986f2132435115e9cc2
 F src/vtab.c a0f8a40274e4261696ef57aa806de2776ab72cda
-F src/wal.c 2f747b6a6bfd9b75b837a1e31176235a21342e0f
+F src/wal.c 5f52f5ea690e1d542e094ca8c83bea43c2f7ad96
-F src/wal.h 32f36b2a827b78373658dac5521291485dfa52b6
+F src/wal.h 434f76f51225bb614e43ccb6bd2341541ba6a06e
 F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
 F src/where.c 75fee9e255b62f773fcadd1d1f25b6f63ac7a356
 F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
@@ -817,14 +817,18 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
 F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
 F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
 F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P c501b2ede6aad123bef0aa7ce8b356a134eb6d26
+P 7838163d087780a6fb403a17641b96f71baec088
-R f34b360b99a8eca6d2a66ca5009c7cf8
+R 6b207856113b77baacd412d73fab162a
+T *bgcolor * #c0ffc0
+T *branch * wal-refactor
+T *sym-wal-refactor *
+T -sym-trunk *
 U drh
-Z ec71604d99e1c3eded3bf24db26ac01b
+Z 917cc375618b87c5f919c29d2da7a2ff
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.6 (GNU/Linux)
 
-iD8DBQFL6rIioxKgR168RlERArxoAJ96khmiBmpRdJSt374I6oMPRFYeDgCeJaEi
+iD8DBQFL6u0HoxKgR168RlERAnOPAJ9UCbogkeIyu/LrQqmeBg4rRTUaswCdFBEg
-RMst0QQ2MlMNKv1/iZMvQcE=
+ymzYvEeQKLujVf/zBF2BuxA=
-=vEcN
+=vRvp
 -----END PGP SIGNATURE-----

manifest.uuid

@@ -1 +1 @@
-7838163d087780a6fb403a17641b96f71baec088
+2b00152c1ac0b3735aa6cfab61259ff04d81c701

src/os.c

@@ -98,6 +98,24 @@ int sqlite3OsSectorSize(sqlite3_file *id){
 int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
   return id->pMethods->xDeviceCharacteristics(id);
 }
+int sqlite3OsShmOpen(sqlite3_file *id){
+  return id->pMethods->xShmOpen(id);
+}
+int sqlite3OsShmSize(sqlite3_file *id, int reqSize, int *pNewSize){
+  return id->pMethods->xShmSize(id, reqSize, pNewSize);
+}
+int sqlite3OsShmGet(sqlite3_file *id, int reqSize, int *pSize, void **pp){
+  return id->pMethods->xShmGet(id, reqSize, pSize, pp);
+}
+int sqlite3OsShmRelease(sqlite3_file *id){
+  return id->pMethods->xShmRelease(id);
+}
+int sqlite3OsShmLock(sqlite3_file *id, int desiredLock, int *pGotLock){
+  return id->pMethods->xShmLock(id, desiredLock, pGotLock);
+}
+int sqlite3OsShmClose(sqlite3_file *id, int deleteFlag){
+  return id->pMethods->xShmClose(id, deleteFlag);
+}
 
 /*
 ** The next group of routines are convenience wrappers around the

src/os.h

@@ -243,6 +243,12 @@ int sqlite3OsFileControl(sqlite3_file*,int,void*);
 #define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
 int sqlite3OsSectorSize(sqlite3_file *id);
 int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
+int sqlite3OsShmOpen(sqlite3_file *id);
+int sqlite3OsShmSize(sqlite3_file *id, int, int*);
+int sqlite3OsShmGet(sqlite3_file *id, int, int*, void**);
+int sqlite3OsShmRelease(sqlite3_file *id);
+int sqlite3OsShmLock(sqlite3_file *id, int, int*);
+int sqlite3OsShmClose(sqlite3_file *id, int);
 
 /* 
 ** Functions for accessing sqlite3_vfs methods 

src/pager.c

@@ -3077,7 +3077,7 @@ int sqlite3PagerClose(Pager *pPager){
   pPager->errCode = 0;
   pPager->exclusiveMode = 0;
 #ifndef SQLITE_OMIT_WAL
-  sqlite3WalClose(pPager->pWal, pPager->fd, 
+  sqlite3WalClose(pPager->pWal,
     (pPager->noSync ? 0 : pPager->sync_flags), 
     pPager->pageSize, pTmp
   );
@@ -5878,7 +5878,7 @@ int sqlite3PagerCheckpoint(Pager *pPager){
   int rc = SQLITE_OK;
   if( pPager->pWal ){
     u8 *zBuf = (u8 *)pPager->pTmpSpace;
-    rc = sqlite3WalCheckpoint(pPager->pWal, pPager->fd, 
+    rc = sqlite3WalCheckpoint(pPager->pWal,
         (pPager->noSync ? 0 : pPager->sync_flags),
         pPager->pageSize, zBuf, 
         pPager->xBusyHandler, pPager->pBusyHandlerArg
@@ -5891,6 +5891,15 @@ int sqlite3PagerWalCallback(Pager *pPager){
   return sqlite3WalCallback(pPager->pWal);
 }
 
+/*
+** Return true if the underlying VFS for the given pager supports the
+** primitives necessary for write-ahead logging.
+*/
+int sqlite3PagerWalSupported(Pager *pPager){
+  const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
+  return pMethods->iVersion>=2 && pMethods->xShmOpen!=0;
+}
+
 /*
 ** Open a connection to the write-ahead log file for pager pPager. If
 ** the log connection is already open, this function is a no-op.
@@ -5903,12 +5912,14 @@ int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen){
 
   assert( pPager->state>=PAGER_SHARED );
   if( !pPager->pWal ){
+    if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
 
     /* Open the connection to the log file. If this operation fails, 
     ** (e.g. due to malloc() failure), unlock the database file and 
     ** return an error code.
     */
-    rc = sqlite3WalOpen(pPager->pVfs, pPager->zFilename, &pPager->pWal);
+    rc = sqlite3WalOpen(pPager->pVfs, pPager->fd,
+                        pPager->zFilename, &pPager->pWal);
     if( rc==SQLITE_OK ){
       pPager->journalMode = PAGER_JOURNALMODE_WAL;
     }
@@ -5944,7 +5955,8 @@ int sqlite3PagerCloseWal(Pager *pPager){
       rc = pagerHasWAL(pPager, &logexists);
     }
     if( rc==SQLITE_OK && logexists ){
-      rc = sqlite3WalOpen(pPager->pVfs, pPager->zFilename, &pPager->pWal);
+      rc = sqlite3WalOpen(pPager->pVfs, pPager->fd,
+                          pPager->zFilename, &pPager->pWal);
     }
   }
     
@@ -5954,8 +5966,8 @@ int sqlite3PagerCloseWal(Pager *pPager){
   if( rc==SQLITE_OK && pPager->pWal ){
     rc = sqlite3OsLock(pPager->fd, SQLITE_LOCK_EXCLUSIVE);
     if( rc==SQLITE_OK ){
-      rc = sqlite3WalClose(pPager->pWal, pPager->fd,
+      rc = sqlite3WalClose(pPager->pWal,
-        (pPager->noSync ? 0 : pPager->sync_flags), 
+                           (pPager->noSync ? 0 : pPager->sync_flags), 
         pPager->pageSize, (u8*)pPager->pTmpSpace
       );
       pPager->pWal = 0;

src/pager.h

@@ -135,6 +135,7 @@ int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
 int sqlite3PagerSharedLock(Pager *pPager);
 
 int sqlite3PagerCheckpoint(Pager *pPager);
+int sqlite3PagerWalSupported(Pager *pPager);
 int sqlite3PagerWalCallback(Pager *pPager);
 int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
 int sqlite3PagerCloseWal(Pager *pPager);

src/sqlite.h.in

@@ -653,6 +653,14 @@ struct sqlite3_io_methods {
   int (*xFileControl)(sqlite3_file*, int op, void *pArg);
   int (*xSectorSize)(sqlite3_file*);
   int (*xDeviceCharacteristics)(sqlite3_file*);
+  /* Methods above are valid for version 1 */
+  int (*xShmOpen)(sqlite3_file*);
+  int (*xShmSize)(sqlite3_file*, int reqSize, int *pNewSize);
+  int (*xShmGet)(sqlite3_file*, int reqSize, int *pSize, void**);
+  int (*xShmRelease)(sqlite3_file*);
+  int (*xShmLock)(sqlite3_file*, int desiredLock, int *gotLock);
+  int (*xShmClose)(sqlite3_file*, int deleteFlag);
+  /* Methods above are valid for version 2 */
   /* Additional methods may be added in future releases */
 };
 
@@ -818,7 +826,6 @@ typedef struct sqlite3_mutex sqlite3_mutex;
 **
 */
 typedef struct sqlite3_vfs sqlite3_vfs;
-typedef struct sqlite3_shm sqlite3_shm;
 struct sqlite3_vfs {
   int iVersion;            /* Structure version number (currently 2) */
   int szOsFile;            /* Size of subclassed sqlite3_file */
@@ -843,12 +850,6 @@ struct sqlite3_vfs {
   ** The methods above are in version 1 of the sqlite_vfs object
   ** definition.  Those that follow are added in version 2 or later
   */
-  int (*xShmOpen)(sqlite3_vfs*, const char *zName, sqlite3_shm**);
-  int (*xShmSize)(sqlite3_vfs*, sqlite3_shm*, int reqSize, int *pNewSize);
-  int (*xShmGet)(sqlite3_vfs*, sqlite3_shm*, int reqSize, int *pSize, void**);
-  int (*xShmRelease)(sqlite3_vfs*, sqlite3_shm*);
-  int (*xShmLock)(sqlite3_vfs*, sqlite3_shm*, int desiredLock, int *gotLock);
-  int (*xShmClose)(sqlite3_vfs*, sqlite3_shm*, int deleteFlag);
   int (*xRename)(sqlite3_vfs*, const char *zOld, const char *zNew, int dirSync);
   int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
   /*

src/test6.c

@@ -520,8 +520,31 @@ static int cfDeviceCharacteristics(sqlite3_file *pFile){
   return g.iDeviceCharacteristics;
 }
 
+/*
+** Pass-throughs for WAL support.
+*/
+static int cfShmOpen(sqlite3_file *pFile){
+  return sqlite3OsShmOpen(((CrashFile*)pFile)->pRealFile);
+}
+static int cfShmSize(sqlite3_file *pFile, int reqSize, int *pNew){
+  return sqlite3OsShmSize(((CrashFile*)pFile)->pRealFile, reqSize, pNew);
+}
+static int cfShmGet(sqlite3_file *pFile, int reqSize, int *pSize, void **pp){
+  return sqlite3OsShmGet(((CrashFile*)pFile)->pRealFile, reqSize, pSize, pp);
+}
+static int cfShmRelease(sqlite3_file *pFile){
+  return sqlite3OsShmRelease(((CrashFile*)pFile)->pRealFile);
+}
+static int cfShmLock(sqlite3_file *pFile, int desired, int *pGot){
+  return sqlite3OsShmLock(((CrashFile*)pFile)->pRealFile, desired, pGot);
+}
+static int cfShmClose(sqlite3_file *pFile, int delFlag){
+  return sqlite3OsShmClose(((CrashFile*)pFile)->pRealFile, delFlag);
+}
+
+
 static const sqlite3_io_methods CrashFileVtab = {
-  1,                            /* iVersion */
+  2,                            /* iVersion */
   cfClose,                      /* xClose */
   cfRead,                       /* xRead */
   cfWrite,                      /* xWrite */
@@ -533,7 +556,13 @@ static const sqlite3_io_methods CrashFileVtab = {
   cfCheckReservedLock,          /* xCheckReservedLock */
   cfFileControl,                /* xFileControl */
   cfSectorSize,                 /* xSectorSize */
-  cfDeviceCharacteristics       /* xDeviceCharacteristics */
+  cfDeviceCharacteristics,      /* xDeviceCharacteristics */
+  cfShmOpen,                    /* xShmOpen */
+  cfShmSize,                    /* xShmSize */
+  cfShmGet,                     /* xShmGet */
+  cfShmRelease,                 /* xShmRelease */
+  cfShmLock,                    /* xShmLock */
+  cfShmClose                    /* xShmClose */
 };
 
 /*
@@ -657,33 +686,6 @@ static int cfCurrentTime(sqlite3_vfs *pCfVfs, double *pTimeOut){
   sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
   return pVfs->xCurrentTime(pVfs, pTimeOut);
 }
-static int cfShmOpen(sqlite3_vfs *pCfVfs, const char *zName, sqlite3_shm **pp){
-  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
-  return pVfs->xShmOpen(pVfs, zName, pp);
-}
-static int cfShmSize(sqlite3_vfs *pCfVfs, sqlite3_shm *p,
-                     int reqSize, int *pNew){
-  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
-  return pVfs->xShmSize(pVfs, p, reqSize, pNew);
-}
-static int cfShmGet(sqlite3_vfs *pCfVfs, sqlite3_shm *p,
-                    int reqSize, int *pSize, void **pp){
-  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
-  return pVfs->xShmGet(pVfs, p, reqSize, pSize, pp);
-}
-static int cfShmRelease(sqlite3_vfs *pCfVfs, sqlite3_shm *p){
-  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
-  return pVfs->xShmRelease(pVfs, p);
-}
-static int cfShmLock(sqlite3_vfs *pCfVfs, sqlite3_shm *p,
-                     int desiredLock, int *gotLock){
-  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
-  return pVfs->xShmLock(pVfs, p, desiredLock, gotLock);
-}
-static int cfShmClose(sqlite3_vfs *pCfVfs, sqlite3_shm *p, int delFlag){
-  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
-  return pVfs->xShmClose(pVfs, p, delFlag);
-}
 
 static int processDevSymArgs(
   Tcl_Interp *interp,
@@ -810,12 +812,6 @@ static int crashEnableCmd(
     cfSleep,              /* xSleep */
     cfCurrentTime,        /* xCurrentTime */
     0,                    /* xGetlastError */
-    cfShmOpen,            /* xShmOpen */
-    cfShmSize,            /* xShmSize */
-    cfShmGet,             /* xShmGet */
-    cfShmRelease,         /* xShmRelease */
-    cfShmLock,            /* xShmLock */
-    cfShmClose,           /* xShmClose */
     0,                    /* xRename */
     0,                    /* xCurrentTimeInt64 */
   };
@@ -838,11 +834,6 @@ static int crashEnableCmd(
     crashVfs.mxPathname = pOriginalVfs->mxPathname;
     crashVfs.pAppData = (void *)pOriginalVfs;
     crashVfs.szOsFile = sizeof(CrashFile) + pOriginalVfs->szOsFile;
-    if( pOriginalVfs->iVersion<2 || pOriginalVfs->xShmOpen==0 ){
-      crashVfs.xShmOpen = 0;
-    }else{
-      crashVfs.xShmOpen = cfShmOpen;
-    }
     sqlite3_vfs_register(&crashVfs, 0);
   }else{
     crashVfs.pAppData = 0;

src/test_devsym.c

@@ -68,13 +68,6 @@ static int devsymRandomness(sqlite3_vfs*, int nByte, char *zOut);
 static int devsymSleep(sqlite3_vfs*, int microseconds);
 static int devsymCurrentTime(sqlite3_vfs*, double*);
 
-static int devsymShmOpen(sqlite3_vfs *, const char *, sqlite3_shm **);
-static int devsymShmSize(sqlite3_vfs*, sqlite3_shm *, int , int *);
-static int devsymShmGet(sqlite3_vfs*, sqlite3_shm *, int , int *, void **);
-static int devsymShmRelease(sqlite3_vfs*, sqlite3_shm *);
-static int devsymShmLock(sqlite3_vfs*, sqlite3_shm *, int , int *);
-static int devsymShmClose(sqlite3_vfs*, sqlite3_shm *, int);
-
 static sqlite3_vfs devsym_vfs = {
   2,                     /* iVersion */
   sizeof(devsym_file),      /* szOsFile */
@@ -101,18 +94,12 @@ static sqlite3_vfs devsym_vfs = {
   devsymSleep,              /* xSleep */
   devsymCurrentTime,        /* xCurrentTime */
   0,                        /* xGetLastError */
-  devsymShmOpen,
+  0,                        /* xRename */
-  devsymShmSize,
+  0                         /* xCurrentTimeInt64 */
-  devsymShmGet,
-  devsymShmRelease,
-  devsymShmLock,
-  devsymShmClose,
-  0,
-  0,
 };
 
 static sqlite3_io_methods devsym_io_methods = {
-  1,                            /* iVersion */
+  2,                                /* iVersion */
   devsymClose,                      /* xClose */
   devsymRead,                       /* xRead */
   devsymWrite,                      /* xWrite */
@@ -124,7 +111,13 @@ static sqlite3_io_methods devsym_io_methods = {
   devsymCheckReservedLock,          /* xCheckReservedLock */
   devsymFileControl,                /* xFileControl */
   devsymSectorSize,                 /* xSectorSize */
-  devsymDeviceCharacteristics       /* xDeviceCharacteristics */
+  devsymDeviceCharacteristics,      /* xDeviceCharacteristics */
+  0,                                /* xShmOpen */
+  0,                                /* xShmSize */
+  0,                                /* xShmGet */
+  0,                                /* xShmRelease */
+  0,                                /* xShmLock */
+  0                                 /* xShmClose */
 };
 
 struct DevsymGlobal {
@@ -350,45 +343,6 @@ static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
 }
 
 
-static int devsymShmOpen(
-  sqlite3_vfs *pVfs, 
-  const char *zName, 
-  sqlite3_shm **pp
-){
-  return g.pVfs->xShmOpen(g.pVfs, zName, pp);
-}
-static int devsymShmSize(
-  sqlite3_vfs *pVfs,
-  sqlite3_shm *p,
-  int reqSize,
-  int *pNewSize
-){
-  return g.pVfs->xShmSize(g.pVfs, p, reqSize, pNewSize);
-}
-static int devsymShmGet(
-  sqlite3_vfs *pVfs,
-  sqlite3_shm *p, 
-  int reqMapSize, 
-  int *pMapSize, 
-  void **pp
-){
-  return g.pVfs->xShmGet(g.pVfs, p, reqMapSize, pMapSize, pp);
-}
-static int devsymShmRelease(sqlite3_vfs *pVfs, sqlite3_shm *p){
-  return g.pVfs->xShmRelease(g.pVfs, p);
-}
-static int devsymShmLock(
-  sqlite3_vfs *pVfs,
-  sqlite3_shm *p,
-  int desiredLock,
-  int *gotLock
-){
-  return g.pVfs->xShmLock(g.pVfs, p, desiredLock, gotLock);
-}
-static int devsymShmClose(sqlite3_vfs *pVfs, sqlite3_shm *p, int deleteFlag){
-  return g.pVfs->xShmClose(g.pVfs, p, deleteFlag);
-}
-
 /*
 ** This procedure registers the devsym vfs with SQLite. If the argument is
 ** true, the devsym vfs becomes the new default vfs. It is the only publicly
@@ -398,12 +352,6 @@ void devsym_register(int iDeviceChar, int iSectorSize){
   if( g.pVfs==0 ){
     g.pVfs = sqlite3_vfs_find(0);
     devsym_vfs.szOsFile += g.pVfs->szOsFile;
-    devsym_vfs.xShmOpen = (g.pVfs->xShmOpen ? devsymShmOpen : 0);
-    devsym_vfs.xShmSize = (g.pVfs->xShmSize ? devsymShmSize : 0);
-    devsym_vfs.xShmGet = (g.pVfs->xShmGet ? devsymShmGet : 0);
-    devsym_vfs.xShmRelease = (g.pVfs->xShmRelease ? devsymShmRelease : 0);
-    devsym_vfs.xShmLock = (g.pVfs->xShmLock ? devsymShmLock : 0);
-    devsym_vfs.xShmClose = (g.pVfs->xShmClose ? devsymShmClose : 0);
     sqlite3_vfs_register(&devsym_vfs, 0);
   }
   if( iDeviceChar>=0 ){

src/test_onefile.c

@@ -199,11 +199,6 @@ static fs_vfs_t fs_vfs = {
     fsRandomness,                               /* xRandomness */
     fsSleep,                                    /* xSleep */
     fsCurrentTime,                              /* xCurrentTime */
-    0,                                          /* xShmOpen */
-    0,                                          /* xShmSize */
-    0,                                          /* xShmLock */
-    0,                                          /* xShmClose */
-    0,                                          /* xShmDelete */
     0,                                          /* xRename */
     0                                           /* xCurrentTimeInt64 */
   }, 
@@ -224,7 +219,12 @@ static sqlite3_io_methods fs_io_methods = {
   fsCheckReservedLock,          /* xCheckReservedLock */
   fsFileControl,                /* xFileControl */
   fsSectorSize,                 /* xSectorSize */
-  fsDeviceCharacteristics       /* xDeviceCharacteristics */
+  fsDeviceCharacteristics,      /* xDeviceCharacteristics */
+  0,                            /* xShmOpen */
+  0,                            /* xShmSize */
+  0,                            /* xShmLock */
+  0,                            /* xShmClose */
+  0,                            /* xShmDelete */
 };
 
 
@@ -241,7 +241,12 @@ static sqlite3_io_methods tmp_io_methods = {
   tmpCheckReservedLock,         /* xCheckReservedLock */
   tmpFileControl,               /* xFileControl */
   tmpSectorSize,                /* xSectorSize */
-  tmpDeviceCharacteristics      /* xDeviceCharacteristics */
+  tmpDeviceCharacteristics,     /* xDeviceCharacteristics */
+  0,                            /* xShmOpen */
+  0,                            /* xShmSize */
+  0,                            /* xShmLock */
+  0,                            /* xShmClose */
+  0,                            /* xShmDelete */
 };
 
 /* Useful macros used in several places */

src/test_vfs.c

@@ -16,15 +16,20 @@
 #include "sqlite3.h"
 #include "sqliteInt.h"
 
-typedef struct tvfs_file tvfs_file;
+#if 0  /* FIX THIS LATER */
-struct tvfs_file {
-  sqlite3_file base;
-  sqlite3_file *pReal;
-};
 
 typedef struct Testvfs Testvfs;
 typedef struct TestvfsShm TestvfsShm;
 typedef struct TestvfsBuffer TestvfsBuffer;
+typedef struct tvfs_file tvfs_file;
+struct tvfs_file {
+  sqlite3_file base;        /* Base class.  Must be first */
+  sqlite3_vfs *pVfs;        /* the VFS */
+  TestvfsShm *pShm;         /* Shared memory segment */
+  const char *zFilename;    /* Filename */
+  sqlite3_file *pReal;      /* The real, underlying file descriptor */
+};
+
 
 /*
 ** An instance of this structure is allocated for each VFS created. The
@@ -97,15 +102,15 @@ 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 tvfsShmOpen(sqlite3_file*);
-static int tvfsShmSize(sqlite3_vfs*, sqlite3_shm *, int , int *);
+static int tvfsShmSize(sqlite3_file*, int , int *);
-static int tvfsShmGet(sqlite3_vfs*, sqlite3_shm *, int , int *, void **);
+static int tvfsShmGet(sqlite3_file*, int , int *, void **);
-static int tvfsShmRelease(sqlite3_vfs*, sqlite3_shm *);
+static int tvfsShmRelease(sqlite3_file*);
-static int tvfsShmLock(sqlite3_vfs*, sqlite3_shm *, int , int *);
+static int tvfsShmLock(sqlite3_file*, int , int *);
-static int tvfsShmClose(sqlite3_vfs*, sqlite3_shm *, int);
+static int tvfsShmClose(sqlite3_file*, int);
 
 static sqlite3_io_methods tvfs_io_methods = {
-  1,                            /* iVersion */
+  2,                            /* iVersion */
   tvfsClose,                      /* xClose */
   tvfsRead,                       /* xRead */
   tvfsWrite,                      /* xWrite */
@@ -117,7 +122,13 @@ static sqlite3_io_methods tvfs_io_methods = {
   tvfsCheckReservedLock,          /* xCheckReservedLock */
   tvfsFileControl,                /* xFileControl */
   tvfsSectorSize,                 /* xSectorSize */
-  tvfsDeviceCharacteristics       /* xDeviceCharacteristics */
+  tvfsDeviceCharacteristics,      /* xDeviceCharacteristics */
+  tvfsShmOpen,                    /* xShmOpen */
+  tvfsShmSize,                    /* xShmSize */
+  tvfsShmGet,                     /* xShmGet */
+  tvfsShmRelease,                 /* xShmRelease */
+  tvfsShmLock,                    /* xShmLock */
+  tvfsShmClose                    /* xShmClose */
 };
 
 /*
@@ -238,6 +249,9 @@ static int tvfsOpen(
 ){
   int rc;
   tvfs_file *p = (tvfs_file *)pFile;
+  p->pShm = 0;
+  p->zFilename = zName;
+  p->pVfs = pVfs;
   p->pReal = (sqlite3_file *)&p[1];
   rc = sqlite3OsOpen(PARENTVFS(pVfs), zName, p->pReal, flags, pOutFlags);
   if( p->pReal->pMethods ){
@@ -405,15 +419,16 @@ static int tvfsResultCode(Testvfs *p, int *pRc){
 }
 
 static int tvfsShmOpen(
-  sqlite3_vfs *pVfs, 
+  sqlite3_file *pFileDes
-  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 */
+  tvfs_file *pFd;                 /* The file descriptor */
+
+  pFd = (tvfs_file*)pFileDes;
 
   /* Evaluate the Tcl script: 
   **
@@ -424,7 +439,7 @@ static int tvfsShmOpen(
   ** 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);
+  tvfsExecTcl(p, "xShmOpen", Tcl_NewStringObj(pFd->zFilename, -1), 0, 0);
   if( tvfsResultCode(p, &rc) ){
     if( rc!=SQLITE_OK ) return rc;
     pId = Tcl_NewStringObj("anon", -1);
@@ -714,12 +729,6 @@ static int testvfs_cmd(
     tvfsSleep,                    /* xSleep */
     tvfsCurrentTime,              /* xCurrentTime */
     0,                            /* xGetLastError */
-    tvfsShmOpen,
-    tvfsShmSize,
-    tvfsShmGet,
-    tvfsShmRelease,
-    tvfsShmLock,
-    tvfsShmClose,
     0,
     0,
   };
@@ -788,9 +797,10 @@ static int testvfs_cmd(
   Tcl_WrongNumArgs(interp, 1, objv, "?-noshm? VFSNAME SCRIPT");
   return TCL_ERROR;
 }
+#endif /* 0 */
 
 int Sqlitetestvfs_Init(Tcl_Interp *interp){
-  Tcl_CreateObjCommand(interp, "testvfs", testvfs_cmd, 0, 0);
+  /* Tcl_CreateObjCommand(interp, "testvfs", testvfs_cmd, 0, 0); */
   return TCL_OK;
 }
 

src/vdbe.c

@@ -5248,8 +5248,8 @@ case OP_JournalMode: {    /* out2-prerelease */
   ** in temporary storage or if the VFS does not support xShmOpen.
   */
   if( eNew==PAGER_JOURNALMODE_WAL
-   && (zFilename[0]==0                               /* Temp file */
+   && (zFilename[0]==0                         /* Temp file */
-         || pVfs->iVersion<2 || pVfs->xShmOpen==0)   /* No xShmOpen support */
+       || !sqlite3PagerWalSupported(pPager))   /* No xShmOpen support */
   ){
     eNew = PAGER_JOURNALMODE_QUERY;
   }

src/wal.c

@@ -125,16 +125,17 @@ struct WalIndexHdr {
 */
 struct Wal {
   sqlite3_vfs *pVfs;         /* The VFS used to create pFd */
-  sqlite3_file *pFd;         /* File handle for WAL file */
+  sqlite3_file *pDbFd;       /* File handle for the database file */
+  sqlite3_file *pWalFd;      /* File handle for WAL file */
   u32 iCallback;             /* Value to pass to log callback (or 0) */
-  sqlite3_shm *pWIndex;      /* The open wal-index file */
   int szWIndex;              /* Size of the wal-index that is mapped in mem */
   u32 *pWiData;              /* Pointer to wal-index content in memory */
   u8 lockState;              /* SQLITE_SHM_xxxx constant showing lock state */
   u8 readerType;             /* SQLITE_SHM_READ or SQLITE_SHM_READ_FULL */
   u8 exclusiveMode;          /* Non-zero if connection is in exclusive mode */
+  u8 isWindexOpen;           /* True if ShmOpen() called on pDbFd */
   WalIndexHdr hdr;           /* Wal-index for current snapshot */
-  char *zName;               /* Name of underlying storage */
+  char *zWalName;            /* Name of WAL file */
 };
 
 
@@ -223,7 +224,7 @@ static int walSetLock(Wal *pWal, int desiredStatus){
     pWal->lockState = desiredStatus;
   }else{
     int got = pWal->lockState;
-    rc = pWal->pVfs->xShmLock(pWal->pVfs, pWal->pWIndex, desiredStatus, &got);
+    rc = sqlite3OsShmLock(pWal->pWalFd, desiredStatus, &got);
     pWal->lockState = got;
     if( got==SQLITE_SHM_READ_FULL || got==SQLITE_SHM_READ ){
       pWal->readerType = got;
@@ -404,7 +405,7 @@ static int walMappingSize(u32 iFrame){
 */
 static void walIndexUnmap(Wal *pWal){
   if( pWal->pWiData ){
-    pWal->pVfs->xShmRelease(pWal->pVfs, pWal->pWIndex);
+    sqlite3OsShmRelease(pWal->pDbFd);
     pWal->pWiData = 0;
   }
 }
@@ -418,8 +419,8 @@ static void walIndexUnmap(Wal *pWal){
 static int walIndexMap(Wal *pWal, int reqSize){
   int rc = SQLITE_OK;
   if( pWal->pWiData==0 || reqSize>pWal->szWIndex ){
-    rc = pWal->pVfs->xShmGet(pWal->pVfs, pWal->pWIndex, reqSize,
+    rc = sqlite3OsShmGet(pWal->pDbFd, reqSize, &pWal->szWIndex,
-                             &pWal->szWIndex, (void**)(char*)&pWal->pWiData);
+                             (void**)(char*)&pWal->pWiData);
     if( rc==SQLITE_OK && pWal->pWiData==0 ){
       /* Make sure pWal->pWiData is not NULL while we are holding the
       ** lock on the mapping. */
@@ -443,7 +444,7 @@ static int walIndexMap(Wal *pWal, int reqSize){
 static int walIndexRemap(Wal *pWal, int enlargeTo){
   int rc;
   int sz;
-  rc = pWal->pVfs->xShmSize(pWal->pVfs, pWal->pWIndex, enlargeTo, &sz);
+  rc = sqlite3OsShmSize(pWal->pDbFd, enlargeTo, &sz);
   if( rc==SQLITE_OK && sz>pWal->szWIndex ){
     walIndexUnmap(pWal);
     rc = walIndexMap(pWal, sz);
@@ -561,7 +562,7 @@ static int walIndexRecover(Wal *pWal){
   assert( pWal->lockState>SQLITE_SHM_READ );
   memset(&hdr, 0, sizeof(hdr));
 
-  rc = sqlite3OsFileSize(pWal->pFd, &nSize);
+  rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
   if( rc!=SQLITE_OK ){
     return rc;
   }
@@ -579,7 +580,7 @@ static int walIndexRecover(Wal *pWal){
     /* Read in the first frame header in the file (to determine the 
     ** database page size).
     */
-    rc = sqlite3OsRead(pWal->pFd, aBuf, WAL_HDRSIZE, 0);
+    rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
     if( rc!=SQLITE_OK ){
       return rc;
     }
@@ -610,7 +611,7 @@ static int walIndexRecover(Wal *pWal){
       int isValid;                /* True if this frame is valid */
 
       /* Read and decode the next log frame. */
-      rc = sqlite3OsRead(pWal->pFd, aFrame, nFrame, iOffset);
+      rc = sqlite3OsRead(pWal->pWalFd, aFrame, nFrame, iOffset);
       if( rc!=SQLITE_OK ) break;
       isValid = walDecodeFrame(aCksum, &pgno, &nTruncate, nPgsz, aData, aFrame);
       if( !isValid ) break;
@@ -648,12 +649,11 @@ finished:
 ** Close an open wal-index.
 */
 static void walIndexClose(Wal *pWal, int isDelete){
-  sqlite3_shm *pWIndex = pWal->pWIndex;
+  if( pWal->isWindexOpen ){
-  if( pWIndex ){
-    sqlite3_vfs *pVfs = pWal->pVfs;
     int notUsed;
-    pVfs->xShmLock(pVfs, pWIndex, SQLITE_SHM_UNLOCK, &notUsed);
+    sqlite3OsShmLock(pWal->pDbFd, SQLITE_SHM_UNLOCK, &notUsed);
-    pVfs->xShmClose(pVfs, pWIndex, isDelete);
+    sqlite3OsShmClose(pWal->pDbFd, isDelete);
+    pWal->isWindexOpen = 0;
   }
 }
 
@@ -675,41 +675,44 @@ static void walIndexClose(Wal *pWal, int isDelete){
 */
 int sqlite3WalOpen(
   sqlite3_vfs *pVfs,              /* vfs module to open wal and wal-index */
-  const char *zDb,                /* Name of database file */
+  sqlite3_file *pDbFd,            /* The open database file */
+  const char *zDbName,            /* Name of the database file */
   Wal **ppWal                     /* OUT: Allocated Wal handle */
 ){
   int rc;                         /* Return Code */
   Wal *pRet;                      /* Object to allocate and return */
   int flags;                      /* Flags passed to OsOpen() */
-  char *zWal;                     /* Path to WAL file */
+  char *zWal;                     /* Name of write-ahead log file */
   int nWal;                       /* Length of zWal in bytes */
 
-  assert( zDb );
+  assert( zDbName && zDbName[0] );
-  if( pVfs->xShmOpen==0 ) return SQLITE_CANTOPEN_BKPT;
+  assert( pDbFd );
 
   /* Allocate an instance of struct Wal to return. */
   *ppWal = 0;
-  nWal = strlen(zDb);
+  nWal = sqlite3Strlen30(zWal) + 5;
-  pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile + nWal+5);
+  pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile + nWal);
   if( !pRet ){
     return SQLITE_NOMEM;
   }
 
   pRet->pVfs = pVfs;
-  pRet->pFd = (sqlite3_file *)&pRet[1];
+  pRet->pWalFd = (sqlite3_file *)&pRet[1];
-  pRet->zName = zWal = pVfs->szOsFile + (char*)pRet->pFd;
+  pRet->pDbFd = pDbFd;
-  sqlite3_snprintf(nWal+5, zWal, "%s-wal", zDb);
+  pRet->zWalName = zWal = pVfs->szOsFile + (char*)pRet->pWalFd;
-  rc = pVfs->xShmOpen(pVfs, zDb, &pRet->pWIndex);
+  sqlite3_snprintf(nWal, zWal, "%s-wal", zDbName);
+  rc = sqlite3OsShmOpen(pDbFd);
+  pRet->isWindexOpen = 1;
 
   /* Open file handle on the write-ahead log file. */
   if( rc==SQLITE_OK ){
     flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MAIN_JOURNAL);
-    rc = sqlite3OsOpen(pVfs, zWal, pRet->pFd, flags, &flags);
+    rc = sqlite3OsOpen(pVfs, zWal, pRet->pWalFd, flags, &flags);
   }
 
   if( rc!=SQLITE_OK ){
     walIndexClose(pRet, 0);
-    sqlite3OsClose(pRet->pFd);
+    sqlite3OsClose(pRet->pWalFd);
     sqlite3_free(pRet);
   }else{
     *ppWal = pRet;
@@ -809,7 +812,6 @@ static void walIteratorFree(WalIterator *p){
 */
 static int walCheckpoint(
   Wal *pWal,                      /* Wal connection */
-  sqlite3_file *pFd,              /* File descriptor open on db file */
   int sync_flags,                 /* Flags for OsSync() (or 0) */
   int nBuf,                       /* Size of zBuf in bytes */
   u8 *zBuf                        /* Temporary buffer to use */
@@ -833,27 +835,27 @@ static int walCheckpoint(
 
   /* Sync the log file to disk */
   if( sync_flags ){
-    rc = sqlite3OsSync(pWal->pFd, sync_flags);
+    rc = sqlite3OsSync(pWal->pWalFd, sync_flags);
     if( rc!=SQLITE_OK ) goto out;
   }
 
   /* Iterate through the contents of the log, copying data to the db file. */
   while( 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
-    rc = sqlite3OsRead(pWal->pFd, zBuf, pgsz, 
+    rc = sqlite3OsRead(pWal->pWalFd, zBuf, pgsz, 
         walFrameOffset(iFrame, pgsz) + WAL_FRAME_HDRSIZE
     );
     if( rc!=SQLITE_OK ) goto out;
-    rc = sqlite3OsWrite(pFd, zBuf, pgsz, (iDbpage-1)*pgsz);
+    rc = sqlite3OsWrite(pWal->pDbFd, zBuf, pgsz, (iDbpage-1)*pgsz);
     if( rc!=SQLITE_OK ) goto out;
   }
 
   /* Truncate the database file */
-  rc = sqlite3OsTruncate(pFd, ((i64)pWal->hdr.nPage*(i64)pgsz));
+  rc = sqlite3OsTruncate(pWal->pDbFd, ((i64)pWal->hdr.nPage*(i64)pgsz));
   if( rc!=SQLITE_OK ) goto out;
 
   /* Sync the database file. If successful, update the wal-index. */
   if( sync_flags ){
-    rc = sqlite3OsSync(pFd, sync_flags);
+    rc = sqlite3OsSync(pWal->pDbFd, sync_flags);
     if( rc!=SQLITE_OK ) goto out;
   }
   pWal->hdr.iLastPg = 0;
@@ -876,9 +878,9 @@ static int walCheckpoint(
   */
 #if 0 
   memset(zBuf, 0, WAL_FRAME_HDRSIZE);
-  rc = sqlite3OsWrite(pWal->pFd, zBuf, WAL_FRAME_HDRSIZE, 0);
+  rc = sqlite3OsWrite(pWal->pWalFd, zBuf, WAL_FRAME_HDRSIZE, 0);
   if( rc!=SQLITE_OK ) goto out;
-  rc = sqlite3OsSync(pWal->pFd, pWal->sync_flags);
+  rc = sqlite3OsSync(pWal->pWalFd, pWal->sync_flags);
 #endif
 
  out:
@@ -891,7 +893,6 @@ static int walCheckpoint(
 */
 int sqlite3WalClose(
   Wal *pWal,                      /* Wal to close */
-  sqlite3_file *pFd,              /* Database file */
   int sync_flags,                 /* Flags to pass to OsSync() (or 0) */
   int nBuf,
   u8 *zBuf                        /* Buffer of at least nBuf bytes */
@@ -908,9 +909,9 @@ int sqlite3WalClose(
     **
     ** The EXCLUSIVE lock is not released before returning.
     */
-    rc = sqlite3OsLock(pFd, SQLITE_LOCK_EXCLUSIVE);
+    rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE);
     if( rc==SQLITE_OK ){
-      rc = sqlite3WalCheckpoint(pWal, pFd, sync_flags, nBuf, zBuf, 0, 0);
+      rc = sqlite3WalCheckpoint(pWal, sync_flags, nBuf, zBuf, 0, 0);
       if( rc==SQLITE_OK ){
         isDelete = 1;
       }
@@ -918,9 +919,9 @@ int sqlite3WalClose(
     }
 
     walIndexClose(pWal, isDelete);
-    sqlite3OsClose(pWal->pFd);
+    sqlite3OsClose(pWal->pWalFd);
     if( isDelete ){
-      sqlite3OsDelete(pWal->pVfs, pWal->zName, 0);
+      sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
     }
     sqlite3_free(pWal);
   }
@@ -1191,7 +1192,7 @@ int sqlite3WalRead(
   if( iRead ){
     i64 iOffset = walFrameOffset(iRead, pWal->hdr.pgsz) + WAL_FRAME_HDRSIZE;
     *pInWal = 1;
-    return sqlite3OsRead(pWal->pFd, pOut, nOut, iOffset);
+    return sqlite3OsRead(pWal->pWalFd, pOut, nOut, iOffset);
   }
 
   *pInWal = 0;
@@ -1290,7 +1291,7 @@ int sqlite3WalSavepointUndo(Wal *pWal, u32 iFrame){
   pWal->hdr.iLastPg = iFrame;
   if( iFrame>0 ){
     i64 iOffset = walFrameOffset(iFrame, pWal->hdr.pgsz) + sizeof(u32)*2;
-    rc = sqlite3OsRead(pWal->pFd, aCksum, sizeof(aCksum), iOffset);
+    rc = sqlite3OsRead(pWal->pWalFd, aCksum, sizeof(aCksum), iOffset);
     pWal->hdr.iCheck1 = sqlite3Get4byte(&aCksum[0]);
     pWal->hdr.iCheck2 = sqlite3Get4byte(&aCksum[4]);
   }
@@ -1334,7 +1335,7 @@ int sqlite3WalFrames(
     sqlite3_randomness(8, &aFrame[4]);
     pWal->hdr.iCheck1 = sqlite3Get4byte(&aFrame[4]);
     pWal->hdr.iCheck2 = sqlite3Get4byte(&aFrame[8]);
-    rc = sqlite3OsWrite(pWal->pFd, aFrame, WAL_HDRSIZE, 0);
+    rc = sqlite3OsWrite(pWal->pWalFd, aFrame, WAL_HDRSIZE, 0);
     if( rc!=SQLITE_OK ){
       return rc;
     }
@@ -1353,13 +1354,13 @@ int sqlite3WalFrames(
     /* Populate and write the frame header */
     nDbsize = (isCommit && p->pDirty==0) ? nTruncate : 0;
     walEncodeFrame(aCksum, p->pgno, nDbsize, nPgsz, p->pData, aFrame);
-    rc = sqlite3OsWrite(pWal->pFd, aFrame, sizeof(aFrame), iOffset);
+    rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
     if( rc!=SQLITE_OK ){
       return rc;
     }
 
     /* Write the page data */
-    rc = sqlite3OsWrite(pWal->pFd, p->pData, nPgsz, iOffset + sizeof(aFrame));
+    rc = sqlite3OsWrite(pWal->pWalFd, p->pData, nPgsz, iOffset + sizeof(aFrame));
     if( rc!=SQLITE_OK ){
       return rc;
     }
@@ -1368,7 +1369,7 @@ int sqlite3WalFrames(
 
   /* Sync the log file if the 'isSync' flag was specified. */
   if( sync_flags ){
-    i64 iSegment = sqlite3OsSectorSize(pWal->pFd);
+    i64 iSegment = sqlite3OsSectorSize(pWal->pWalFd);
     i64 iOffset = walFrameOffset(iFrame+1, nPgsz);
 
     assert( isCommit );
@@ -1379,13 +1380,13 @@ int sqlite3WalFrames(
     iSegment = (((iOffset+iSegment-1)/iSegment) * iSegment);
     while( iOffset<iSegment ){
       walEncodeFrame(aCksum,pLast->pgno,nTruncate,nPgsz,pLast->pData,aFrame);
-      rc = sqlite3OsWrite(pWal->pFd, aFrame, sizeof(aFrame), iOffset);
+      rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
       if( rc!=SQLITE_OK ){
         return rc;
       }
 
       iOffset += WAL_FRAME_HDRSIZE;
-      rc = sqlite3OsWrite(pWal->pFd, pLast->pData, nPgsz, iOffset); 
+      rc = sqlite3OsWrite(pWal->pWalFd, pLast->pData, nPgsz, iOffset); 
       if( rc!=SQLITE_OK ){
         return rc;
       }
@@ -1393,7 +1394,7 @@ int sqlite3WalFrames(
       iOffset += nPgsz;
     }
 
-    rc = sqlite3OsSync(pWal->pFd, sync_flags);
+    rc = sqlite3OsSync(pWal->pWalFd, sync_flags);
   }
   assert( pWal->pWiData==0 );
 
@@ -1445,7 +1446,6 @@ int sqlite3WalFrames(
 */
 int sqlite3WalCheckpoint(
   Wal *pWal,                      /* Wal connection */
-  sqlite3_file *pFd,              /* File descriptor open on db file */
   int sync_flags,                 /* Flags to sync db file with (or 0) */
   int nBuf,                       /* Size of temporary buffer */
   u8 *zBuf,                       /* Temporary buffer to use */
@@ -1479,7 +1479,7 @@ int sqlite3WalCheckpoint(
   /* Copy data from the log to the database file. */
   rc = walIndexReadHdr(pWal, &isChanged);
   if( rc==SQLITE_OK ){
-    rc = walCheckpoint(pWal, pFd, sync_flags, nBuf, zBuf);
+    rc = walCheckpoint(pWal, sync_flags, nBuf, zBuf);
   }
   if( isChanged ){
     /* If a new wal-index header was loaded before the checkpoint was 

src/wal.h

@@ -41,8 +41,8 @@
 typedef struct Wal Wal;
 
 /* Open and close a connection to a write-ahead log. */
-int sqlite3WalOpen(sqlite3_vfs*, const char *zDb, Wal **ppWal);
+int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *zName, Wal**);
-int sqlite3WalClose(Wal *pWal, sqlite3_file *pFd, int sync_flags, int, u8 *);
+int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *);
 
 /* Used by readers to open (lock) and close (unlock) a snapshot.  A 
 ** snapshot is like a read-transaction.  It is the state of the database
@@ -81,7 +81,6 @@ int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
 /* Copy pages from the log to the database file */ 
 int sqlite3WalCheckpoint(
   Wal *pWal,                      /* Write-ahead log connection */
-  sqlite3_file *pFd,              /* File descriptor open on db file */
   int sync_flags,                 /* Flags to sync db file with (or 0) */
   int nBuf,                       /* Size of buffer nBuf */
   u8 *zBuf,                       /* Temporary buffer to use */