database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-08-07 02:42:48 +03:00
Code Activity

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

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

FossilOrigin-Name: 2b00152c1ac0b3735aa6cfab61259ff04d81c701
This commit is contained in:
drh
2010-05-12 18:01:39 +00:00
parent eaf52d883a
commit d9e5c4f6ed
16 changed files with 1061 additions and 1045 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
doc/vfs-shm.txt
View File

@@ -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.
(9) A CHECKPOINT or RECOVER must be held in order to reset the last valid
frame counter in the header of the wal-index back to zero.
WRITE, CHECKPOINT, or RECOVER on the wal-index or an EXCLUSIVE on
the original database files.
(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,

48
manifest
View File

@@ -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].
D 2010-05-12T13:50:23
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-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.h b389844e5469a2918e8a45fe6ae52b4c28dfb2b2
F src/os.c c0a5dfce2a214dacb679425632d04f8a2021f364
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.h 934b598583a9d936bb13c37d62a2fe68ac48781c
F src/pager.c 1e163a82ae8405433dca559831caa06aafbba3b0
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.h 32f36b2a827b78373658dac5521291485dfa52b6
F src/wal.c 5f52f5ea690e1d542e094ca8c83bea43c2f7ad96
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
R f34b360b99a8eca6d2a66ca5009c7cf8
P 7838163d087780a6fb403a17641b96f71baec088
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
RMst0QQ2MlMNKv1/iZMvQcE=
=vEcN
iD8DBQFL6u0HoxKgR168RlERAnOPAJ9UCbogkeIyu/LrQqmeBg4rRTUaswCdFBEg
ymzYvEeQKLujVf/zBF2BuxA=
=vRvp
-----END PGP SIGNATURE-----

2
manifest.uuid
View File

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

18
src/os.c
View File

@@ -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

6
src/os.h
View File

@@ -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

1641
src/os_unix.c
View File

File diff suppressed because it is too large Load Diff

22
src/pager.c
View File

@@ -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,7 +5966,7 @@ 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->pageSize, (u8*)pPager->pTmpSpace
);

1
src/pager.h
View File

@@ -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);

15
src/sqlite.h.in
View File

@@ -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*);
/*

71
src/test6.c
View File

@@ -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;

72
src/test_devsym.c
View File

@@ -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,
devsymShmSize,
devsymShmGet,
devsymShmRelease,
devsymShmLock,
devsymShmClose,
0,
0,
0, /* xRename */
0 /* xCurrentTimeInt64 */
};
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 ){

19
src/test_onefile.c
View File

@@ -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 */

58
src/test_vfs.c
View File

@@ -16,15 +16,20 @@
#include "sqlite3.h"
#include "sqliteInt.h"
typedef struct tvfs_file tvfs_file;
struct tvfs_file {
sqlite3_file base;
sqlite3_file *pReal;
};
#if 0 /* FIX THIS LATER */
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 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 int tvfsShmOpen(sqlite3_file*);
static int tvfsShmSize(sqlite3_file*, int , int *);
static int tvfsShmGet(sqlite3_file*, int , int *, void **);
static int tvfsShmRelease(sqlite3_file*);
static int tvfsShmLock(sqlite3_file*, int , 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,
const char *zName,
sqlite3_shm **pp
sqlite3_file *pFileDes
){
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;
}

2
src/vdbe.c
View File

@@ -5249,7 +5249,7 @@ case OP_JournalMode: { /* out2-prerelease */
*/
if( eNew==PAGER_JOURNALMODE_WAL
&& (zFilename[0]==0 /* Temp file */
|| pVfs->iVersion<2 || pVfs->xShmOpen==0) /* No xShmOpen support */
|| !sqlite3PagerWalSupported(pPager)) /* No xShmOpen support */
){
eNew = PAGER_JOURNALMODE_QUERY;
}

104
src/wal.c
View File

@@ -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,
&pWal->szWIndex, (void**)(char*)&pWal->pWiData);
rc = sqlite3OsShmGet(pWal->pDbFd, reqSize, &pWal->szWIndex,
(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( pWIndex ){
sqlite3_vfs *pVfs = pWal->pVfs;
if( pWal->isWindexOpen ){
int notUsed;
pVfs->xShmLock(pVfs, pWIndex, SQLITE_SHM_UNLOCK, &notUsed);
pVfs->xShmClose(pVfs, pWIndex, isDelete);
sqlite3OsShmLock(pWal->pDbFd, SQLITE_SHM_UNLOCK, &notUsed);
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 );
if( pVfs->xShmOpen==0 ) return SQLITE_CANTOPEN_BKPT;
assert( zDbName && zDbName[0] );
assert( pDbFd );
/* Allocate an instance of struct Wal to return. */
*ppWal = 0;
nWal = strlen(zDb);
pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile + nWal+5);
nWal = sqlite3Strlen30(zWal) + 5;
pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile + nWal);
if( !pRet ){
return SQLITE_NOMEM;
}
pRet->pVfs = pVfs;
pRet->pFd = (sqlite3_file *)&pRet[1];
pRet->zName = zWal = pVfs->szOsFile + (char*)pRet->pFd;
sqlite3_snprintf(nWal+5, zWal, "%s-wal", zDb);
rc = pVfs->xShmOpen(pVfs, zDb, &pRet->pWIndex);
pRet->pWalFd = (sqlite3_file *)&pRet[1];
pRet->pDbFd = pDbFd;
pRet->zWalName = zWal = pVfs->szOsFile + (char*)pRet->pWalFd;
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

5
src/wal.h
View File

@@ -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 sqlite3WalClose(Wal *pWal, sqlite3_file *pFd, int sync_flags, int, u8 *);
int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *zName, Wal**);
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 */