database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-08-05 15:55:57 +03:00
Code Activity

Fix a race condition in the locking code that would sometimes cause

Browse Source 
SQLITE_PROTOCOL or SQLITE_CORRUPT to be returned when SQLITE_BUSY should
have been returned. (CVS 326)

FossilOrigin-Name: b0d218876442187af08161d989e6887b1cb4130c
This commit is contained in:
drh
2001-12-14 15:09:55 +00:00
parent 6a6cfb9b31
commit a7fcb05988
8 changed files with 267 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
2.1.5 2.1.6

22
manifest
View File

@@ -1,9 +1,9 @@
C Version\s2.1.5\s(CVS\s456) C Fix\sa\srace\scondition\sin\sthe\slocking\scode\sthat\swould\ssometimes\scause\nSQLITE_PROTOCOL\sor\sSQLITE_CORRUPT\sto\sbe\sreturned\swhen\sSQLITE_BUSY\sshould\nhave\sbeen\sreturned.\s(CVS\s326)
D 2001-12-06T13:30:00 D 2001-12-14T15:09:56
F Makefile.in 352fed589f09dd94347e0bb391d047118ebd6105 F Makefile.in 352fed589f09dd94347e0bb391d047118ebd6105
F Makefile.template 0fbf0ee1fe38183d760170a13e91fffec64e73f5 F Makefile.template 0fbf0ee1fe38183d760170a13e91fffec64e73f5
F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0 F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0
F VERSION 592b381154fbd36565cdbefe0075aa43623f2f5a F VERSION 1943794ff83649775b2cc2e31bf3e3390e952fbf
F aclocal.m4 11faa843caa38fd451bc6aeb43e248d1723a269d F aclocal.m4 11faa843caa38fd451bc6aeb43e248d1723a269d
F config.guess f38b1e93d1e0fa6f5a6913e9e7b12774b9232588 F config.guess f38b1e93d1e0fa6f5a6913e9e7b12774b9232588
F config.log 6a73d03433669b10a3f0c221198c3f26b9413914 F config.log 6a73d03433669b10a3f0c221198c3f26b9413914
@@ -19,7 +19,7 @@ F libtool c56e618713c9510a103bda6b95f3ea3900dcacd6
F ltmain.sh e9ed72eb1d690f447c13945eaf69e28af531eda1 F ltmain.sh e9ed72eb1d690f447c13945eaf69e28af531eda1
F publish.sh 33cbe6798969f637698044023c139080e5d772a6 F publish.sh 33cbe6798969f637698044023c139080e5d772a6
F src/TODO af7f3cab0228e34149cf98e073aa83d45878e7e6 F src/TODO af7f3cab0228e34149cf98e073aa83d45878e7e6
F src/btree.c 5fbfeb383465ca311ac202cbf6ba8f18196426de F src/btree.c e4ea48618c136694de21e96fea0ed9a3d79c7996
F src/btree.h 0250a0a577a98cc64ddf1582d50c08b8d2451650 F src/btree.h 0250a0a577a98cc64ddf1582d50c08b8d2451650
F src/build.c 83733f96255db003363e786d1b28a5b85611acca F src/build.c 83733f96255db003363e786d1b28a5b85611acca
F src/delete.c 5d93a21c1388cfb1359bda01c072f25583a2f4f2 F src/delete.c 5d93a21c1388cfb1359bda01c072f25583a2f4f2
@@ -29,9 +29,9 @@ F src/hash.h a5f5b3ce2d086a172c5879b0b06a27a82eac9fac
F src/insert.c 3526be771a01035198bef28d8f370cbcab94f46d F src/insert.c 3526be771a01035198bef28d8f370cbcab94f46d
F src/main.c e5fa4773e6684b81fc0bcd9d9ae4578d56660c0c F src/main.c e5fa4773e6684b81fc0bcd9d9ae4578d56660c0c
F src/md5.c 52f677bfc590e09f71d07d7e327bd59da738d07c F src/md5.c 52f677bfc590e09f71d07d7e327bd59da738d07c
F src/os.c f4d19ca9202bfd496a07d2d55e1c4b57b6e5b48c F src/os.c 07882cde5c61f26751b8ee76fd84726c1f7e453c
F src/os.h c5c12f5f25b0a1baf9a62937b456fabcad2c1f49 F src/os.h 00a18e0ae1139a64f1d3ead465ae2b9ff43f3db2
F src/pager.c 16173a7b7aff0c7bd7da94070e46d38778ab0f76 F src/pager.c f39d99e9339e5fff3fd9852f48d2fc8308933d3b
F src/pager.h df1fb8a759ab69112ea88b9f14601a7633d0ccc0 F src/pager.h df1fb8a759ab69112ea88b9f14601a7633d0ccc0
F src/parse.y 5295f393f41ea89958287e5738e6c12c7cd67482 F src/parse.y 5295f393f41ea89958287e5738e6c12c7cd67482
F src/printf.c 300a90554345751f26e1fc0c0333b90a66110a1d F src/printf.c 300a90554345751f26e1fc0c0333b90a66110a1d
@@ -104,7 +104,7 @@ F www/arch.fig d5f9752a4dbf242e9cfffffd3f5762b6c63b3bcf
F www/arch.png 82ef36db1143828a7abc88b1e308a5f55d4336f4 F www/arch.png 82ef36db1143828a7abc88b1e308a5f55d4336f4
F www/arch.tcl 72a0c80e9054cc7025a50928d28d9c75c02c2b8b F www/arch.tcl 72a0c80e9054cc7025a50928d28d9c75c02c2b8b
F www/c_interface.tcl 58922228e8fdb0f6af3561a051ee8ccec6dbfd17 F www/c_interface.tcl 58922228e8fdb0f6af3561a051ee8ccec6dbfd17
F www/changes.tcl 40bf58e136891ce1e5a4bda00d1c59f161560c59 F www/changes.tcl e0be983df11a904e14def78526509080a57fca98
F www/crosscompile.tcl 3622ebbe518927a3854a12de51344673eb2dd060 F www/crosscompile.tcl 3622ebbe518927a3854a12de51344673eb2dd060
F www/download.tcl 1ea61f9d89a2a5a9b2cee36b0d5cf97321bdefe0 F www/download.tcl 1ea61f9d89a2a5a9b2cee36b0d5cf97321bdefe0
F www/dynload.tcl 02eb8273aa78cfa9070dd4501dca937fb22b466c F www/dynload.tcl 02eb8273aa78cfa9070dd4501dca937fb22b466c
@@ -117,7 +117,7 @@ F www/speed.tcl 83457b2bf6bb430900bd48ca3dd98264d9a916a5
F www/sqlite.tcl 8b5884354cb615049aed83039f8dfe1552a44279 F www/sqlite.tcl 8b5884354cb615049aed83039f8dfe1552a44279
F www/tclsqlite.tcl 880ef67cb4f2797b95bf1368fc4e0d8ca0fda956 F www/tclsqlite.tcl 880ef67cb4f2797b95bf1368fc4e0d8ca0fda956
F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218 F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
P 669454060867593290c1ce8c45bd87d011976289 P 8e90ad552fad83568297202848fe7eb2b63db33d
R 283460d2e743d411ca396b1d81679e15 R 11fe1b88a51d4db88bdca916a2550755
U drh U drh
Z 8fa34c42ea83abd5884352fa7c87327e Z fba78b88b4bbf12a6828c6912be362f4

2
manifest.uuid
View File

@@ -1 +1 @@
8e90ad552fad83568297202848fe7eb2b63db33d b0d218876442187af08161d989e6887b1cb4130c

7
src/btree.c
View File

@@ -9,7 +9,7 @@
** May you share freely, never taking more than you give. ** May you share freely, never taking more than you give.
** **
************************************************************************* *************************************************************************
** $Id: btree.c,v 1.42 2001/12/05 00:21:20 drh Exp $ ** $Id: btree.c,v 1.43 2001/12/14 15:09:57 drh Exp $
** **
** This file implements a external (disk-based) database using BTrees. ** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to ** For a detailed discussion of BTrees, refer to
@@ -990,7 +990,10 @@ static int getPayload(BtCursor *pCur, int offset, int amt, char *zBuf){
} }
sqlitepager_unref(pOvfl); sqlitepager_unref(pOvfl);
} }
return amt==0 ? SQLITE_OK : SQLITE_CORRUPT; if( amt>0 ){
return SQLITE_CORRUPT;
}
return SQLITE_OK;
} }
/* /*

288
src/os.c
View File

@@ -108,7 +108,7 @@ struct inodeKey {
*/ */
struct lockInfo { struct lockInfo {
struct inodeKey key; /* The lookup key */ struct inodeKey key; /* The lookup key */
int cnt; /* 0: unlocked. -1: write lock. >=1: read lock */ int cnt; /* 0: unlocked. -1: write lock. 1...: read lock. */
int nRef; /* Number of pointers to this structure */ int nRef; /* Number of pointers to this structure */
}; };
@@ -227,7 +227,7 @@ int sqliteOsFileExists(const char *zFilename){
** fails, try opening it read-only. If the file does not exist, ** fails, try opening it read-only. If the file does not exist,
** try to create it. ** try to create it.
** **
** On success, a handle for the open file is written to *pResult ** On success, a handle for the open file is written to *id
** and *pReadonly is set to 0 if the file was opened for reading and ** and *pReadonly is set to 0 if the file was opened for reading and
** writing or 1 if the file was opened read-only. The function returns ** writing or 1 if the file was opened read-only. The function returns
** SQLITE_OK. ** SQLITE_OK.
@@ -237,15 +237,14 @@ int sqliteOsFileExists(const char *zFilename){
*/ */
int sqliteOsOpenReadWrite( int sqliteOsOpenReadWrite(
const char *zFilename, const char *zFilename,
OsFile *pResult, OsFile *id,
int *pReadonly int *pReadonly
){ ){
#if OS_UNIX #if OS_UNIX
OsFile s; id->fd = open(zFilename, O_RDWR|O_CREAT, 0644);
s.fd = open(zFilename, O_RDWR|O_CREAT, 0644); if( id->fd<0 ){
if( s.fd<0 ){ id->fd = open(zFilename, O_RDONLY);
s.fd = open(zFilename, O_RDONLY); if( id->fd<0 ){
if( s.fd<0 ){
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
*pReadonly = 1; *pReadonly = 1;
@@ -253,13 +252,13 @@ int sqliteOsOpenReadWrite(
*pReadonly = 0; *pReadonly = 0;
} }
sqliteOsEnterMutex(); sqliteOsEnterMutex();
s.pLock = findLockInfo(s.fd); id->pLock = findLockInfo(id->fd);
sqliteOsLeaveMutex(); sqliteOsLeaveMutex();
if( s.pLock==0 ){ if( id->pLock==0 ){
close(s.fd); close(id->fd);
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
*pResult = s; id->locked = 0;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
#if OS_WIN #if OS_WIN
@@ -287,7 +286,8 @@ int sqliteOsOpenReadWrite(
}else{ }else{
*pReadonly = 0; *pReadonly = 0;
} }
*pResult = h; id->h = h;
id->locked = 0;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
@@ -300,32 +300,31 @@ int sqliteOsOpenReadWrite(
** previously existed. Nor do we allow the file to be a symbolic ** previously existed. Nor do we allow the file to be a symbolic
** link. ** link.
** **
** On success, write the file handle into *pResult and return SQLITE_OK. ** On success, write the file handle into *id and return SQLITE_OK.
** **
** On failure, return SQLITE_CANTOPEN. ** On failure, return SQLITE_CANTOPEN.
*/ */
int sqliteOsOpenExclusive(const char *zFilename, OsFile *pResult){ int sqliteOsOpenExclusive(const char *zFilename, OsFile *id){
#if OS_UNIX #if OS_UNIX
OsFile s;
if( access(zFilename, 0)==0 ){ if( access(zFilename, 0)==0 ){
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
#ifndef O_NOFOLLOW #ifndef O_NOFOLLOW
# define O_NOFOLLOW 0 # define O_NOFOLLOW 0
#endif #endif
s.fd = open(zFilename, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW, 0600); id->fd = open(zFilename, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW, 0600);
if( s.fd<0 ){ if( id->fd<0 ){
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
sqliteOsEnterMutex(); sqliteOsEnterMutex();
s.pLock = findLockInfo(s.fd); id->pLock = findLockInfo(id->fd);
sqliteOsLeaveMutex(); sqliteOsLeaveMutex();
if( s.pLock==0 ){ if( id->pLock==0 ){
close(s.fd); close(id->fd);
unlink(zFilename); unlink(zFilename);
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
*pResult = s; id->locked = 0;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
#if OS_WIN #if OS_WIN
@@ -340,7 +339,8 @@ int sqliteOsOpenExclusive(const char *zFilename, OsFile *pResult){
if( h==INVALID_HANDLE_VALUE ){ if( h==INVALID_HANDLE_VALUE ){
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
*pResult = h; id->h = h;
id->locked = 0;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
@@ -348,25 +348,24 @@ int sqliteOsOpenExclusive(const char *zFilename, OsFile *pResult){
/* /*
** Attempt to open a new file for read-only access. ** Attempt to open a new file for read-only access.
** **
** On success, write the file handle into *pResult and return SQLITE_OK. ** On success, write the file handle into *id and return SQLITE_OK.
** **
** On failure, return SQLITE_CANTOPEN. ** On failure, return SQLITE_CANTOPEN.
*/ */
int sqliteOsOpenReadOnly(const char *zFilename, OsFile *pResult){ int sqliteOsOpenReadOnly(const char *zFilename, OsFile *id){
#if OS_UNIX #if OS_UNIX
OsFile s; id->fd = open(zFilename, O_RDONLY);
s.fd = open(zFilename, O_RDONLY); if( id->fd<0 ){
if( s.fd<0 ){
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
sqliteOsEnterMutex(); sqliteOsEnterMutex();
s.pLock = findLockInfo(s.fd); id->pLock = findLockInfo(id->fd);
sqliteOsLeaveMutex(); sqliteOsLeaveMutex();
if( s.pLock==0 ){ if( id->pLock==0 ){
close(s.fd); close(id->fd);
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
*pResult = s; id->locked = 0;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
#if OS_WIN #if OS_WIN
@@ -381,7 +380,8 @@ int sqliteOsOpenReadOnly(const char *zFilename, OsFile *pResult){
if( h==INVALID_HANDLE_VALUE ){ if( h==INVALID_HANDLE_VALUE ){
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
*pResult = h; id->h = h;
id->locked = 0;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
@@ -447,16 +447,16 @@ int sqliteOsTempFileName(char *zBuf){
/* /*
** Close a file ** Close a file
*/ */
int sqliteOsClose(OsFile id){ int sqliteOsClose(OsFile *id){
#if OS_UNIX #if OS_UNIX
close(id.fd); close(id->fd);
sqliteOsEnterMutex(); sqliteOsEnterMutex();
releaseLockInfo(id.pLock); releaseLockInfo(id->pLock);
sqliteOsLeaveMutex(); sqliteOsLeaveMutex();
return SQLITE_OK; return SQLITE_OK;
#endif #endif
#if OS_WIN #if OS_WIN
CloseHandle(id); CloseHandle(id->h);
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
@@ -466,18 +466,18 @@ int sqliteOsClose(OsFile id){
** bytes were read successfully and SQLITE_IOERR if anything goes ** bytes were read successfully and SQLITE_IOERR if anything goes
** wrong. ** wrong.
*/ */
int sqliteOsRead(OsFile id, void *pBuf, int amt){ int sqliteOsRead(OsFile *id, void *pBuf, int amt){
#if OS_UNIX #if OS_UNIX
int got; int got;
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
got = read(id.fd, pBuf, amt); got = read(id->fd, pBuf, amt);
if( got<0 ) got = 0; if( got<0 ) got = 0;
return got==amt ? SQLITE_OK : SQLITE_IOERR; return got==amt ? SQLITE_OK : SQLITE_IOERR;
#endif #endif
#if OS_WIN #if OS_WIN
DWORD got; DWORD got;
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
if( !ReadFile(id, pBuf, amt, &got, 0) ){ if( !ReadFile(id->h, pBuf, amt, &got, 0) ){
got = 0; got = 0;
} }
return got==amt ? SQLITE_OK : SQLITE_IOERR; return got==amt ? SQLITE_OK : SQLITE_IOERR;
@@ -488,18 +488,18 @@ int sqliteOsRead(OsFile id, void *pBuf, int amt){
** Write data from a buffer into a file. Return SQLITE_OK on success ** Write data from a buffer into a file. Return SQLITE_OK on success
** or some other error code on failure. ** or some other error code on failure.
*/ */
int sqliteOsWrite(OsFile id, const void *pBuf, int amt){ int sqliteOsWrite(OsFile *id, const void *pBuf, int amt){
#if OS_UNIX #if OS_UNIX
int wrote; int wrote;
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
wrote = write(id.fd, pBuf, amt); wrote = write(id->fd, pBuf, amt);
if( wrote<amt ) return SQLITE_FULL; if( wrote<amt ) return SQLITE_FULL;
return SQLITE_OK; return SQLITE_OK;
#endif #endif
#if OS_WIN #if OS_WIN
DWORD wrote; DWORD wrote;
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
if( !WriteFile(id, pBuf, amt, &wrote, 0) || wrote<amt ){ if( !WriteFile(id->h, pBuf, amt, &wrote, 0) || wrote<amt ){
return SQLITE_FULL; return SQLITE_FULL;
} }
return SQLITE_OK; return SQLITE_OK;
@@ -509,13 +509,13 @@ int sqliteOsWrite(OsFile id, const void *pBuf, int amt){
/* /*
** Move the read/write pointer in a file. ** Move the read/write pointer in a file.
*/ */
int sqliteOsSeek(OsFile id, int offset){ int sqliteOsSeek(OsFile *id, int offset){
#if OS_UNIX #if OS_UNIX
lseek(id.fd, offset, SEEK_SET); lseek(id->fd, offset, SEEK_SET);
return SQLITE_OK; return SQLITE_OK;
#endif #endif
#if OS_WIN #if OS_WIN
SetFilePointer(id, offset, 0, FILE_BEGIN); SetFilePointer(id->h, offset, 0, FILE_BEGIN);
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
@@ -523,27 +523,27 @@ int sqliteOsSeek(OsFile id, int offset){
/* /*
** Make sure all writes to a particular file are committed to disk. ** Make sure all writes to a particular file are committed to disk.
*/ */
int sqliteOsSync(OsFile id){ int sqliteOsSync(OsFile *id){
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
#if OS_UNIX #if OS_UNIX
return fsync(id.fd)==0 ? SQLITE_OK : SQLITE_IOERR; return fsync(id->fd)==0 ? SQLITE_OK : SQLITE_IOERR;
#endif #endif
#if OS_WIN #if OS_WIN
return FlushFileBuffers(id) ? SQLITE_OK : SQLITE_IOERR; return FlushFileBuffers(id->h) ? SQLITE_OK : SQLITE_IOERR;
#endif #endif
} }
/* /*
** Truncate an open file to a specified size ** Truncate an open file to a specified size
*/ */
int sqliteOsTruncate(OsFile id, int nByte){ int sqliteOsTruncate(OsFile *id, int nByte){
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
#if OS_UNIX #if OS_UNIX
return ftruncate(id.fd, nByte)==0 ? SQLITE_OK : SQLITE_IOERR; return ftruncate(id->fd, nByte)==0 ? SQLITE_OK : SQLITE_IOERR;
#endif #endif
#if OS_WIN #if OS_WIN
SetFilePointer(id, nByte, 0, FILE_BEGIN); SetFilePointer(id->h, nByte, 0, FILE_BEGIN);
SetEndOfFile(id); SetEndOfFile(id->h);
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
@@ -551,11 +551,11 @@ int sqliteOsTruncate(OsFile id, int nByte){
/* /*
** Determine the current size of a file in bytes ** Determine the current size of a file in bytes
*/ */
int sqliteOsFileSize(OsFile id, int *pSize){ int sqliteOsFileSize(OsFile *id, int *pSize){
#if OS_UNIX #if OS_UNIX
struct stat buf; struct stat buf;
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
if( fstat(id.fd, &buf)!=0 ){ if( fstat(id->fd, &buf)!=0 ){
return SQLITE_IOERR; return SQLITE_IOERR;
} }
*pSize = buf.st_size; *pSize = buf.st_size;
@@ -563,89 +563,141 @@ int sqliteOsFileSize(OsFile id, int *pSize){
#endif #endif
#if OS_WIN #if OS_WIN
SimulateIOError(SQLITE_IOERR); SimulateIOError(SQLITE_IOERR);
*pSize = GetFileSize(id, 0); *pSize = GetFileSize(id->h, 0);
return SQLITE_OK; return SQLITE_OK;
#endif #endif
} }
/* /*
** Get a read or write lock on a file. ** Change the status of the lock on the file "id" to be a readlock.
** If the file was write locked, then this reduces the lock to a read.
** If the file was read locked, then this acquires a new read lock.
**
** Return SQLITE_OK on success and SQLITE_BUSY on failure.
*/ */
int sqliteOsLock(OsFile id, int wrlock){ int sqliteOsReadLock(OsFile *id){
#if OS_UNIX #if OS_UNIX
int rc; int rc;
int needSysLock;
sqliteOsEnterMutex(); sqliteOsEnterMutex();
if( wrlock ){ if( id->pLock->cnt>0 ){
if( id.pLock->cnt!=0 ){ if( !id->locked ){
rc = SQLITE_BUSY; id->pLock->cnt++;
}else{ id->locked = 1;
rc = SQLITE_OK;
id.pLock->cnt = -1;
needSysLock = 1;
} }
}else{
if( id.pLock->cnt<0 ){
rc = SQLITE_BUSY;
}else{
rc = SQLITE_OK;
needSysLock = id.pLock->cnt==0;
id.pLock->cnt++;
}
}
if( rc==SQLITE_OK && needSysLock ){
struct flock lock;
lock.l_type = wrlock ? F_WRLCK : F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = lock.l_len = 0L;
rc = fcntl(id.fd, F_SETLK, &lock)==0 ? SQLITE_OK : SQLITE_BUSY;
if( rc ){
id.pLock->cnt = 0;
}
}
sqliteOsLeaveMutex();
return rc;
#endif
#if OS_WIN
if( !LockFile(id, 0, 0, 1024, 0) ){
return SQLITE_BUSY;
}
return SQLITE_OK;
#endif
}
/*
** Release the read or write lock from a file.
*/
int sqliteOsUnlock(OsFile id){
#if OS_UNIX
int rc;
int needSysUnlock;
sqliteOsEnterMutex();
if( id.pLock->cnt<0 ){
needSysUnlock = 1;
id.pLock->cnt = 0;
}else if( id.pLock->cnt>0 ){
id.pLock->cnt--;
needSysUnlock = id.pLock->cnt==0;
}else{
rc = SQLITE_OK; rc = SQLITE_OK;
needSysUnlock = 0; }else if( id->locked || id->pLock->cnt==0 ){
}
if( needSysUnlock ){
struct flock lock; struct flock lock;
lock.l_type = F_UNLCK; lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET; lock.l_whence = SEEK_SET;
lock.l_start = lock.l_len = 0L; lock.l_start = lock.l_len = 0L;
rc = fcntl(id.fd, F_SETLK, &lock)==0 ? SQLITE_OK : SQLITE_IOERR; if( fcntl(id->fd, F_SETLK, &lock)!=0 ){
rc = SQLITE_BUSY;
}else{
rc = SQLITE_OK;
id->pLock->cnt = 1;
id->locked = 1;
}
}else{
rc = SQLITE_BUSY;
} }
sqliteOsLeaveMutex(); sqliteOsLeaveMutex();
return rc; return rc;
#endif #endif
#if OS_WIN #if OS_WIN
return UnlockFile(id, 0, 0, 1024, 0) ? SQLITE_OK : SQLITE_IOERR; int rc;
if( id->locked ){
rc = SQLITE_OK;
}else if( LockFile(id->h, 0, 0, 1024, 0) ){
rc = SQLITE_OK;
id->locked = 1;
}else{
rc = SQLITE_BUSY;
}
return rc;
#endif
}
/*
** Change the lock status to be an exclusive or write lock. Return
** SQLITE_OK on success and SQLITE_BUSY on a failure.
*/
int sqliteOsWriteLock(OsFile *id){
#if OS_UNIX
int rc;
sqliteOsEnterMutex();
if( id->pLock->cnt==0 || (id->pLock->cnt==1 && id->locked==1) ){
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = lock.l_len = 0L;
if( fcntl(id->fd, F_SETLK, &lock)!=0 ){
rc = SQLITE_BUSY;
}else{
rc = SQLITE_OK;
id->pLock->cnt = -1;
id->locked = 1;
}
}else{
rc = SQLITE_BUSY;
}
sqliteOsLeaveMutex();
return rc;
#endif
#if OS_WIN
int rc;
if( id->locked ){
rc = SQLITE_OK;
}else if( LockFile(id->h, 0, 0, 1024, 0) ){
rc = SQLITE_OK;
id->locked = 1;
}else{
rc = SQLITE_BUSY;
}
return rc;
#endif
}
/*
** Unlock the given file descriptor. If the file descriptor was
** not previously locked, then this routine is a no-op.
*/
int sqliteOsUnlock(OsFile *id){
#if OS_UNIX
int rc;
if( !id->locked ) return SQLITE_OK;
sqliteOsEnterMutex();
assert( id->pLock->cnt!=0 );
if( id->pLock->cnt>1 ){
id->pLock->cnt--;
rc = SQLITE_OK;
}else{
struct flock lock;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = lock.l_len = 0L;
if( fcntl(id->fd, F_SETLK, &lock)!=0 ){
rc = SQLITE_BUSY;
}else{
rc = SQLITE_OK;
id->pLock->cnt = 0;
}
}
sqliteOsLeaveMutex();
id->locked = 0;
return rc;
#endif
#if OS_WIN
int rc;
if( !id->locked ){
rc = SQLITE_OK;
}else if( UnlockFile(id->h, 0, 0, 1024, 0) ){
rc = SQLITE_OK;
id->locked = 0;
}else{
rc = SQLITE_BUSY;
}
return rc;
#endif #endif
} }

26
src/os.h
View File

@@ -25,6 +25,7 @@
struct OsFile { struct OsFile {
struct lockInfo *pLock; /* Information about locks on this inode */ struct lockInfo *pLock; /* Information about locks on this inode */
int fd; /* The file descriptor */ int fd; /* The file descriptor */
int locked; /* True if this user holds the lock */
}; };
# define SQLITE_TEMPNAME_SIZE 200 # define SQLITE_TEMPNAME_SIZE 200
# if defined(HAVE_USLEEP) && HAVE_USLEEP # if defined(HAVE_USLEEP) && HAVE_USLEEP
@@ -37,7 +38,11 @@
#if OS_WIN #if OS_WIN
#include <windows.h> #include <windows.h>
#include <winbase.h> #include <winbase.h>
typedef HANDLE OsFile; typedef struct OsFile OsFile;
struct OsFile {
HANDLE h;
int locked;
};
# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) # define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
# define SQLITE_MIN_SLEEP_MS 1 # define SQLITE_MIN_SLEEP_MS 1
#endif #endif
@@ -48,15 +53,16 @@ int sqliteOsOpenReadWrite(const char*, OsFile*, int*);
int sqliteOsOpenExclusive(const char*, OsFile*); int sqliteOsOpenExclusive(const char*, OsFile*);
int sqliteOsOpenReadOnly(const char*, OsFile*); int sqliteOsOpenReadOnly(const char*, OsFile*);
int sqliteOsTempFileName(char*); int sqliteOsTempFileName(char*);
int sqliteOsClose(OsFile); int sqliteOsClose(OsFile*);
int sqliteOsRead(OsFile, void*, int amt); int sqliteOsRead(OsFile*, void*, int amt);
int sqliteOsWrite(OsFile, const void*, int amt); int sqliteOsWrite(OsFile*, const void*, int amt);
int sqliteOsSeek(OsFile, int offset); int sqliteOsSeek(OsFile*, int offset);
int sqliteOsSync(OsFile); int sqliteOsSync(OsFile*);
int sqliteOsTruncate(OsFile, int size); int sqliteOsTruncate(OsFile*, int size);
int sqliteOsFileSize(OsFile, int *pSize); int sqliteOsFileSize(OsFile*, int *pSize);
int sqliteOsLock(OsFile, int wrlock); int sqliteOsReadLock(OsFile*);
int sqliteOsUnlock(OsFile); int sqliteOsWriteLock(OsFile*);
int sqliteOsUnlock(OsFile*);
int sqliteOsRandomSeed(char*); int sqliteOsRandomSeed(char*);
int sqliteOsSleep(int ms); int sqliteOsSleep(int ms);
void sqliteOsEnterMutex(void); void sqliteOsEnterMutex(void);

141
src/pager.c
View File

@@ -18,7 +18,7 @@
** file simultaneously, or one process from reading the database while ** file simultaneously, or one process from reading the database while
** another is writing. ** another is writing.
** **
** @(#) $Id: pager.c,v 1.32 2001/12/05 00:21:20 drh Exp $ ** @(#) $Id: pager.c,v 1.33 2001/12/14 15:09:57 drh Exp $
*/ */
#include "sqliteInt.h" #include "sqliteInt.h"
#include "pager.h" #include "pager.h"
@@ -218,7 +218,7 @@ static void pager_reset(Pager *pPager){
if( pPager->state==SQLITE_WRITELOCK ){ if( pPager->state==SQLITE_WRITELOCK ){
sqlitepager_rollback(pPager); sqlitepager_rollback(pPager);
} }
sqliteOsUnlock(pPager->fd); sqliteOsUnlock(&pPager->fd);
pPager->state = SQLITE_UNLOCK; pPager->state = SQLITE_UNLOCK;
pPager->dbSize = -1; pPager->dbSize = -1;
pPager->nRef = 0; pPager->nRef = 0;
@@ -246,25 +246,18 @@ static int pager_unwritelock(Pager *pPager){
int rc; int rc;
PgHdr *pPg; PgHdr *pPg;
if( pPager->state!=SQLITE_WRITELOCK ) return SQLITE_OK; if( pPager->state!=SQLITE_WRITELOCK ) return SQLITE_OK;
sqliteOsUnlock(pPager->fd); sqliteOsClose(&pPager->jfd);
rc = sqliteOsLock(pPager->fd, 0);
sqliteOsClose(pPager->jfd);
pPager->journalOpen = 0; pPager->journalOpen = 0;
sqliteOsDelete(pPager->zJournal); sqliteOsDelete(pPager->zJournal);
rc = sqliteOsReadLock(&pPager->fd);
assert( rc==SQLITE_OK );
sqliteFree( pPager->aInJournal ); sqliteFree( pPager->aInJournal );
pPager->aInJournal = 0; pPager->aInJournal = 0;
for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
pPg->inJournal = 0; pPg->inJournal = 0;
pPg->dirty = 0; pPg->dirty = 0;
} }
if( rc!=SQLITE_OK ){ pPager->state = SQLITE_READLOCK;
pPager->state = SQLITE_UNLOCK;
rc = SQLITE_PROTOCOL;
pPager->errMask |= PAGER_ERR_LOCK;
}else{
rc = SQLITE_OK;
pPager->state = SQLITE_READLOCK;
}
return rc; return rc;
} }
@@ -304,8 +297,8 @@ static int pager_playback(Pager *pPager){
** the journal is empty. ** the journal is empty.
*/ */
assert( pPager->journalOpen ); assert( pPager->journalOpen );
sqliteOsSeek(pPager->jfd, 0); sqliteOsSeek(&pPager->jfd, 0);
rc = sqliteOsFileSize(pPager->jfd, &nRec); rc = sqliteOsFileSize(&pPager->jfd, &nRec);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
goto end_playback; goto end_playback;
} }
@@ -317,16 +310,16 @@ static int pager_playback(Pager *pPager){
/* Read the beginning of the journal and truncate the /* Read the beginning of the journal and truncate the
** database file back to its original size. ** database file back to its original size.
*/ */
rc = sqliteOsRead(pPager->jfd, aMagic, sizeof(aMagic)); rc = sqliteOsRead(&pPager->jfd, aMagic, sizeof(aMagic));
if( rc!=SQLITE_OK || memcmp(aMagic,aJournalMagic,sizeof(aMagic))!=0 ){ if( rc!=SQLITE_OK || memcmp(aMagic,aJournalMagic,sizeof(aMagic))!=0 ){
rc = SQLITE_PROTOCOL; rc = SQLITE_PROTOCOL;
goto end_playback; goto end_playback;
} }
rc = sqliteOsRead(pPager->jfd, &mxPg, sizeof(mxPg)); rc = sqliteOsRead(&pPager->jfd, &mxPg, sizeof(mxPg));
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
goto end_playback; goto end_playback;
} }
rc = sqliteOsTruncate(pPager->fd, mxPg*SQLITE_PAGE_SIZE); rc = sqliteOsTruncate(&pPager->fd, mxPg*SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
goto end_playback; goto end_playback;
} }
@@ -339,9 +332,9 @@ static int pager_playback(Pager *pPager){
/* Seek to the beginning of the segment */ /* Seek to the beginning of the segment */
int ofst; int ofst;
ofst = i*sizeof(PageRecord) + sizeof(aMagic) + sizeof(Pgno); ofst = i*sizeof(PageRecord) + sizeof(aMagic) + sizeof(Pgno);
rc = sqliteOsSeek(pPager->jfd, ofst); rc = sqliteOsSeek(&pPager->jfd, ofst);
if( rc!=SQLITE_OK ) break; if( rc!=SQLITE_OK ) break;
rc = sqliteOsRead(pPager->jfd, &pgRec, sizeof(pgRec)); rc = sqliteOsRead(&pPager->jfd, &pgRec, sizeof(pgRec));
if( rc!=SQLITE_OK ) break; if( rc!=SQLITE_OK ) break;
/* Sanity checking on the page */ /* Sanity checking on the page */
@@ -358,9 +351,9 @@ static int pager_playback(Pager *pPager){
memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE); memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE);
memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra);
} }
rc = sqliteOsSeek(pPager->fd, (pgRec.pgno-1)*SQLITE_PAGE_SIZE); rc = sqliteOsSeek(&pPager->fd, (pgRec.pgno-1)*SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ) break; if( rc!=SQLITE_OK ) break;
rc = sqliteOsWrite(pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE); rc = sqliteOsWrite(&pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ) break; if( rc!=SQLITE_OK ) break;
} }
@@ -432,7 +425,7 @@ int sqlitepager_open(
nameLen = strlen(zFilename); nameLen = strlen(zFilename);
pPager = sqliteMalloc( sizeof(*pPager) + nameLen*2 + 30 ); pPager = sqliteMalloc( sizeof(*pPager) + nameLen*2 + 30 );
if( pPager==0 ){ if( pPager==0 ){
sqliteOsClose(fd); sqliteOsClose(&fd);
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
pPager->zFilename = (char*)&pPager[1]; pPager->zFilename = (char*)&pPager[1];
@@ -481,7 +474,7 @@ int sqlitepager_pagecount(Pager *pPager){
if( pPager->dbSize>=0 ){ if( pPager->dbSize>=0 ){
return pPager->dbSize; return pPager->dbSize;
} }
if( sqliteOsFileSize(pPager->fd, &n)!=SQLITE_OK ){ if( sqliteOsFileSize(&pPager->fd, &n)!=SQLITE_OK ){
pPager->errMask |= PAGER_ERR_DISK; pPager->errMask |= PAGER_ERR_DISK;
return 0; return 0;
} }
@@ -506,12 +499,12 @@ int sqlitepager_close(Pager *pPager){
switch( pPager->state ){ switch( pPager->state ){
case SQLITE_WRITELOCK: { case SQLITE_WRITELOCK: {
sqlitepager_rollback(pPager); sqlitepager_rollback(pPager);
sqliteOsUnlock(pPager->fd); sqliteOsUnlock(&pPager->fd);
assert( pPager->journalOpen==0 ); assert( pPager->journalOpen==0 );
break; break;
} }
case SQLITE_READLOCK: { case SQLITE_READLOCK: {
sqliteOsUnlock(pPager->fd); sqliteOsUnlock(&pPager->fd);
break; break;
} }
default: { default: {
@@ -523,7 +516,7 @@ int sqlitepager_close(Pager *pPager){
pNext = pPg->pNextAll; pNext = pPg->pNextAll;
sqliteFree(pPg); sqliteFree(pPg);
} }
sqliteOsClose(pPager->fd); sqliteOsClose(&pPager->fd);
assert( pPager->journalOpen==0 ); assert( pPager->journalOpen==0 );
if( pPager->tempFile ){ if( pPager->tempFile ){
sqliteOsDelete(pPager->zFilename); sqliteOsDelete(pPager->zFilename);
@@ -590,14 +583,14 @@ static int syncAllPages(Pager *pPager){
PgHdr *pPg; PgHdr *pPg;
int rc = SQLITE_OK; int rc = SQLITE_OK;
if( pPager->needSync ){ if( pPager->needSync ){
rc = sqliteOsSync(pPager->jfd); rc = sqliteOsSync(&pPager->jfd);
if( rc!=0 ) return rc; if( rc!=0 ) return rc;
pPager->needSync = 0; pPager->needSync = 0;
} }
for(pPg=pPager->pFirst; pPg; pPg=pPg->pNextFree){ for(pPg=pPager->pFirst; pPg; pPg=pPg->pNextFree){
if( pPg->dirty ){ if( pPg->dirty ){
sqliteOsSeek(pPager->fd, (pPg->pgno-1)*SQLITE_PAGE_SIZE); sqliteOsSeek(&pPager->fd, (pPg->pgno-1)*SQLITE_PAGE_SIZE);
rc = sqliteOsWrite(pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ) break; if( rc!=SQLITE_OK ) break;
pPg->dirty = 0; pPg->dirty = 0;
} }
@@ -644,7 +637,7 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
** on the database file. ** on the database file.
*/ */
if( pPager->nRef==0 ){ if( pPager->nRef==0 ){
if( sqliteOsLock(pPager->fd, 0)!=SQLITE_OK ){ if( sqliteOsReadLock(&pPager->fd)!=SQLITE_OK ){
*ppPage = 0; *ppPage = 0;
return SQLITE_BUSY; return SQLITE_BUSY;
} }
@@ -655,6 +648,17 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
if( sqliteOsFileExists(pPager->zJournal) ){ if( sqliteOsFileExists(pPager->zJournal) ){
int rc, dummy; int rc, dummy;
/* Get a write lock on the database
*/
rc = sqliteOsWriteLock(&pPager->fd);
if( rc!=SQLITE_OK ){
rc = sqliteOsReadLock(&pPager->fd);
assert( rc==SQLITE_OK );
*ppPage = 0;
return SQLITE_BUSY;
}
pPager->state = SQLITE_WRITELOCK;
/* Open the journal for exclusive access. Return SQLITE_BUSY if /* Open the journal for exclusive access. Return SQLITE_BUSY if
** we cannot get exclusive access to the journal file. ** we cannot get exclusive access to the journal file.
** **
@@ -663,28 +667,13 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
** exclusive access lock. ** exclusive access lock.
*/ */
rc = sqliteOsOpenReadWrite(pPager->zJournal, &pPager->jfd, &dummy); rc = sqliteOsOpenReadWrite(pPager->zJournal, &pPager->jfd, &dummy);
if( rc==SQLITE_OK ){ if( rc!=SQLITE_OK ){
pPager->journalOpen = 1; rc = sqliteOsUnlock(&pPager->fd);
} assert( rc==SQLITE_OK );
if( rc!=SQLITE_OK || sqliteOsLock(pPager->jfd, 1)!=SQLITE_OK ){
if( pPager->journalOpen ){
sqliteOsClose(pPager->jfd);
pPager->journalOpen = 0;
}
sqliteOsUnlock(pPager->fd);
*ppPage = 0; *ppPage = 0;
return SQLITE_BUSY; return SQLITE_BUSY;
} }
pPager->journalOpen = 1;
/* Get a write lock on the database */
sqliteOsUnlock(pPager->fd);
if( sqliteOsLock(pPager->fd, 1)!=SQLITE_OK ){
sqliteOsClose(pPager->jfd);
pPager->journalOpen = 0;
*ppPage = 0;
return SQLITE_PROTOCOL;
}
pPager->state = SQLITE_WRITELOCK;
/* Playback and delete the journal. Drop the database write /* Playback and delete the journal. Drop the database write
** lock and reacquire the read lock. ** lock and reacquire the read lock.
@@ -804,8 +793,8 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE);
}else{ }else{
int rc; int rc;
sqliteOsSeek(pPager->fd, (pgno-1)*SQLITE_PAGE_SIZE); sqliteOsSeek(&pPager->fd, (pgno-1)*SQLITE_PAGE_SIZE);
rc = sqliteOsRead(pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
return rc; return rc;
} }
@@ -934,48 +923,30 @@ int sqlitepager_write(void *pData){
assert( pPager->state!=SQLITE_UNLOCK ); assert( pPager->state!=SQLITE_UNLOCK );
if( pPager->state==SQLITE_READLOCK ){ if( pPager->state==SQLITE_READLOCK ){
assert( pPager->aInJournal==0 ); assert( pPager->aInJournal==0 );
rc = sqliteOsWriteLock(&pPager->fd);
if( rc!=SQLITE_OK ){
return rc;
}
pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 ); pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 );
if( pPager->aInJournal==0 ){ if( pPager->aInJournal==0 ){
sqliteFree(pPager->aInJournal); sqliteOsReadLock(&pPager->fd);
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd); rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
sqliteFree(pPager->aInJournal); sqliteFree(pPager->aInJournal);
pPager->aInJournal = 0;
sqliteOsReadLock(&pPager->fd);
return SQLITE_CANTOPEN; return SQLITE_CANTOPEN;
} }
pPager->journalOpen = 1; pPager->journalOpen = 1;
pPager->needSync = 0; pPager->needSync = 0;
if( sqliteOsLock(pPager->jfd, 1)!=SQLITE_OK ){
sqliteFree(pPager->aInJournal);
sqliteOsClose(pPager->jfd);
sqliteOsDelete(pPager->zJournal);
pPager->journalOpen = 0;
return SQLITE_BUSY;
}
sqliteOsUnlock(pPager->fd);
if( sqliteOsLock(pPager->fd, 1)!=SQLITE_OK ){
sqliteOsUnlock(pPager->fd);
rc = sqliteOsLock(pPager->fd, 0);
sqliteFree(pPager->aInJournal);
sqliteOsClose(pPager->jfd);
sqliteOsDelete(pPager->zJournal);
pPager->journalOpen = 0;
if( rc ){
pPager->state = SQLITE_UNLOCK;
pPager->errMask |= PAGER_ERR_LOCK;
return SQLITE_PROTOCOL;
}else{
pPager->state = SQLITE_READLOCK;
return SQLITE_BUSY;
}
}
pPager->state = SQLITE_WRITELOCK; pPager->state = SQLITE_WRITELOCK;
sqlitepager_pagecount(pPager); sqlitepager_pagecount(pPager);
pPager->origDbSize = pPager->dbSize; pPager->origDbSize = pPager->dbSize;
rc = sqliteOsWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic)); rc = sqliteOsWrite(&pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
if( rc==SQLITE_OK ){ if( rc==SQLITE_OK ){
rc = sqliteOsWrite(pPager->jfd, &pPager->dbSize, sizeof(Pgno)); rc = sqliteOsWrite(&pPager->jfd, &pPager->dbSize, sizeof(Pgno));
} }
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
rc = pager_unwritelock(pPager); rc = pager_unwritelock(pPager);
@@ -986,9 +957,9 @@ int sqlitepager_write(void *pData){
assert( pPager->state==SQLITE_WRITELOCK ); assert( pPager->state==SQLITE_WRITELOCK );
assert( pPager->journalOpen ); assert( pPager->journalOpen );
if( pPg->pgno <= pPager->origDbSize ){ if( pPg->pgno <= pPager->origDbSize ){
rc = sqliteOsWrite(pPager->jfd, &pPg->pgno, sizeof(Pgno)); rc = sqliteOsWrite(&pPager->jfd, &pPg->pgno, sizeof(Pgno));
if( rc==SQLITE_OK ){ if( rc==SQLITE_OK ){
rc = sqliteOsWrite(pPager->jfd, pData, SQLITE_PAGE_SIZE); rc = sqliteOsWrite(&pPager->jfd, pData, SQLITE_PAGE_SIZE);
} }
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
sqlitepager_rollback(pPager); sqlitepager_rollback(pPager);
@@ -1040,17 +1011,17 @@ int sqlitepager_commit(Pager *pPager){
return SQLITE_ERROR; return SQLITE_ERROR;
} }
assert( pPager->journalOpen ); assert( pPager->journalOpen );
if( pPager->needSync && sqliteOsSync(pPager->jfd)!=SQLITE_OK ){ if( pPager->needSync && sqliteOsSync(&pPager->jfd)!=SQLITE_OK ){
goto commit_abort; goto commit_abort;
} }
for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
if( pPg->dirty==0 ) continue; if( pPg->dirty==0 ) continue;
rc = sqliteOsSeek(pPager->fd, (pPg->pgno-1)*SQLITE_PAGE_SIZE); rc = sqliteOsSeek(&pPager->fd, (pPg->pgno-1)*SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ) goto commit_abort; if( rc!=SQLITE_OK ) goto commit_abort;
rc = sqliteOsWrite(pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE);
if( rc!=SQLITE_OK ) goto commit_abort; if( rc!=SQLITE_OK ) goto commit_abort;
} }
if( sqliteOsSync(pPager->fd)!=SQLITE_OK ) goto commit_abort; if( sqliteOsSync(&pPager->fd)!=SQLITE_OK ) goto commit_abort;
rc = pager_unwritelock(pPager); rc = pager_unwritelock(pPager);
pPager->dbSize = -1; pPager->dbSize = -1;
return rc; return rc;

7
www/changes.tcl
View File

@@ -17,6 +17,13 @@ proc chng {date desc} {
puts "<DD><P><UL>$desc</UL></P></DD>" puts "<DD><P><UL>$desc</UL></P></DD>"
} }
chng {2001 Dec 14 (2.1.6)} {
<li>Fix the locking mechanism yet again to prevent
<b>sqlite_exec()</b> from returning SQLITE_PROTOCOL
unnecessarily. This time the bug was a race condition in
the locking code. This change effects both POSIX and Windows users.</li>
}
chng {2001 Dec 6 (2.1.5)} { chng {2001 Dec 6 (2.1.5)} {
<li>Fix for another problem (unrelated to the one fixed in 2.1.4) <li>Fix for another problem (unrelated to the one fixed in 2.1.4)
that sometimes causes <b>sqlite_exec()</b> to return SQLITE_PROTOCOL that sometimes causes <b>sqlite_exec()</b> to return SQLITE_PROTOCOL