database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-11-15 11:41:13 +03:00
Code Activity

Initial work on reforming usage of OSTRACE by the Windows VFS.

Browse Source 
FossilOrigin-Name: b347b5d1a01301f44e6fd20ee03a9529ffd25788
This commit is contained in:
mistachkin
2013-04-28 01:44:43 +00:00
parent 015db9c859
commit f2c1c99f15
5 changed files with 242 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
manifest
View File

@@ -1,5 +1,5 @@
C Remove\sspellfix\svirtual\stable\sdocumentation\sfrom\sthe\ssource\stree.\nReference\sthe\sseparate\sdocumentation\son\sthe\swebsite\sinstead. C Initial\swork\son\sreforming\susage\sof\sOSTRACE\sby\sthe\sWindows\sVFS.
D 2013-04-27T18:06:40.561 D 2013-04-28T01:44:43.497
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
F Makefile.in ce81671efd6223d19d4c8c6b88ac2c4134427111 F Makefile.in ce81671efd6223d19d4c8c6b88ac2c4134427111
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23 F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
@@ -158,7 +158,7 @@ F src/journal.c b4124532212b6952f42eb2c12fa3c25701d8ba8d
F src/legacy.c 0df0b1550b9cc1f58229644735e317ac89131f12 F src/legacy.c 0df0b1550b9cc1f58229644735e317ac89131f12
F src/lempar.c cdf0a000315332fc9b50b62f3b5e22e080a0952b F src/lempar.c cdf0a000315332fc9b50b62f3b5e22e080a0952b
F src/loadext.c c48f7f3f170e502fe0cc20748e03c6e0b5a016c2 F src/loadext.c c48f7f3f170e502fe0cc20748e03c6e0b5a016c2
F src/main.c de47c3e6b68f512b9e64ba2533ee4eecc9d501c1 F src/main.c d89118abab8becbefd22e88f14dccbff4aef0aa6
F src/malloc.c fe085aa851b666b7c375c1ff957643dc20a04bf6 F src/malloc.c fe085aa851b666b7c375c1ff957643dc20a04bf6
F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
F src/mem1.c 437c7c4af964895d4650f29881df63535caaa1fa F src/mem1.c 437c7c4af964895d4650f29881df63535caaa1fa
@@ -176,7 +176,7 @@ F src/os.c b4ad71336fd96f97776f75587cd9e8218288f5be
F src/os.h 4a46270a64e9193af4a0aaa3bc2c66dc07c29b3f F src/os.h 4a46270a64e9193af4a0aaa3bc2c66dc07c29b3f
F src/os_common.h 92815ed65f805560b66166e3583470ff94478f04 F src/os_common.h 92815ed65f805560b66166e3583470ff94478f04
F src/os_unix.c 5a214c5431fd005dbb3b8bbaaa306433e8e9b48f F src/os_unix.c 5a214c5431fd005dbb3b8bbaaa306433e8e9b48f
F src/os_win.c 673b3e3d1fa3040d8d95a7f1f5e0e553aed56cfb F src/os_win.c 79bf8963cfb91a544b03c4be07b67488f892e929
F src/pager.c 4a9160d268977e56ae2df90182050ab30fca715d F src/pager.c 4a9160d268977e56ae2df90182050ab30fca715d
F src/pager.h 5cb78b8e1adfd5451e600be7719f5a99d87ac3b1 F src/pager.h 5cb78b8e1adfd5451e600be7719f5a99d87ac3b1
F src/parse.y 5d5e12772845805fdfeb889163516b84fbb9ae95 F src/parse.y 5d5e12772845805fdfeb889163516b84fbb9ae95
@@ -194,7 +194,7 @@ F src/shell.c 5d527e5d08f05ec2c43ff194ea44bf62b974f4c9
F src/sqlite.h.in e6c241170da854abf6f15ec7e6c565348b690169 F src/sqlite.h.in e6c241170da854abf6f15ec7e6c565348b690169
F src/sqlite3.rc fea433eb0a59f4c9393c8e6d76a6e2596b1fe0c0 F src/sqlite3.rc fea433eb0a59f4c9393c8e6d76a6e2596b1fe0c0
F src/sqlite3ext.h d936f797812c28b81b26ed18345baf8db28a21a5 F src/sqlite3ext.h d936f797812c28b81b26ed18345baf8db28a21a5
F src/sqliteInt.h de835c584032769461c123a564381f9808542c0e F src/sqliteInt.h 1a2b576d605505f6584b0ed6c59f3e85eb8ff5dc
F src/sqliteLimit.h 164b0e6749d31e0daa1a4589a169d31c0dec7b3d F src/sqliteLimit.h 164b0e6749d31e0daa1a4589a169d31c0dec7b3d
F src/status.c bedc37ec1a6bb9399944024d63f4c769971955a9 F src/status.c bedc37ec1a6bb9399944024d63f4c769971955a9
F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
@@ -1060,7 +1060,10 @@ F tool/vdbe-compress.tcl f12c884766bd14277f4fcedcae07078011717381
F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4 F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
F tool/warnings.sh fbc018d67fd7395f440c28f33ef0f94420226381 F tool/warnings.sh fbc018d67fd7395f440c28f33ef0f94420226381
F tool/win/sqlite.vsix 97894c2790eda7b5bce3cc79cb2a8ec2fde9b3ac F tool/win/sqlite.vsix 97894c2790eda7b5bce3cc79cb2a8ec2fde9b3ac
P f14d55cf358b0392d3b8cd61dc85f43a610a8edf P adcf78909ff9064b6e3c4dd15ccd3245c8cf270b
R 1d8237b86dffdd5327eb650dcb291120 R f41b19fed2521384396fcf0a1effb849
U drh T *branch * winOsTrace
Z 369cfa66c298e6ca3c71b08895115463 T *sym-winOsTrace *
T -sym-trunk *
U mistachkin
Z fd47dbd9998a9c91c0e16a40715c418b

2
manifest.uuid
View File

@@ -1 +1 @@
adcf78909ff9064b6e3c4dd15ccd3245c8cf270b b347b5d1a01301f44e6fd20ee03a9529ffd25788

80
src/main.c
View File

@@ -1029,6 +1029,86 @@ void sqlite3RollbackAll(sqlite3 *db, int tripCode){
} }
} }
/*
** Return a static string containing the name corresponding to the error code
** specified in the argument.
*/
const char *sqlite3ErrName(int rc){
const char *zName = 0;
int i;
for(i=0; i<2 && zName==0; i++, rc &= 0xff){
switch( rc ){
case SQLITE_OK: zName = "SQLITE_OK"; break;
case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
case SQLITE_PERM: zName = "SQLITE_PERM"; break;
case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
case SQLITE_FULL: zName = "SQLITE_FULL"; break;
case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
case SQLITE_CONSTRAINT_FOREIGNKEY:
zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
case SQLITE_CONSTRAINT_PRIMARYKEY:
zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
case SQLITE_CONSTRAINT_COMMITHOOK:
zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
case SQLITE_CONSTRAINT_FUNCTION:
zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
case SQLITE_ROW: zName = "SQLITE_ROW"; break;
case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
case SQLITE_DONE: zName = "SQLITE_DONE"; break;
case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
case SQLITE_IOERR_BLOCKED: zName = "SQLITE_IOERR_BLOCKED"; break;
case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
case SQLITE_IOERR_CHECKRESERVEDLOCK:
zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
case SQLITE_READONLY_CANTLOCK: zName = "SQLITE_READONLY_CANTLOCK"; break;
case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
}
}
if( zName==0 ) zName = "SQLITE_Unknown";
return zName;
}
/* /*
** Return a static string that describes the kind of error specified in the ** Return a static string that describes the kind of error specified in the
** argument. ** argument.

187
src/os_win.c
View File

@@ -2027,6 +2027,8 @@ static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
DWORD dwRet; /* Value returned by SetFilePointer() */ DWORD dwRet; /* Value returned by SetFilePointer() */
DWORD lastErrno; /* Value returned by GetLastError() */ DWORD lastErrno; /* Value returned by GetLastError() */
OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
upperBits = (LONG)((iOffset>>32) & 0x7fffffff); upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
lowerBits = (LONG)(iOffset & 0xffffffff); lowerBits = (LONG)(iOffset & 0xffffffff);
@@ -2044,9 +2046,11 @@ static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
pFile->lastErrno = lastErrno; pFile->lastErrno = lastErrno;
winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
"seekWinFile", pFile->zPath); "seekWinFile", pFile->zPath);
OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
return 1; return 1;
} }
OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
return 0; return 0;
#else #else
/* /*
@@ -2063,9 +2067,11 @@ static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
pFile->lastErrno = osGetLastError(); pFile->lastErrno = osGetLastError();
winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
"seekWinFile", pFile->zPath); "seekWinFile", pFile->zPath);
OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
return 1; return 1;
} }
OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
return 0; return 0;
#endif #endif
} }
@@ -2094,8 +2100,8 @@ static int winClose(sqlite3_file *id){
#ifndef SQLITE_OMIT_WAL #ifndef SQLITE_OMIT_WAL
assert( pFile->pShm==0 ); assert( pFile->pShm==0 );
#endif #endif
OSTRACE(("CLOSE %d\n", pFile->h));
assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE ); assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
OSTRACE(("CLOSE file=%p\n", pFile->h));
#if SQLITE_MAX_MMAP_SIZE>0 #if SQLITE_MAX_MMAP_SIZE>0
rc = winUnmapfile(pFile); rc = winUnmapfile(pFile);
@@ -2121,11 +2127,11 @@ static int winClose(sqlite3_file *id){
sqlite3_free(pFile->zDeleteOnClose); sqlite3_free(pFile->zDeleteOnClose);
} }
#endif #endif
OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
if( rc ){ if( rc ){
pFile->h = NULL; pFile->h = NULL;
} }
OpenCounter(-1); OpenCounter(-1);
OSTRACE(("CLOSE file=%p, rc=%s\n", pFile->h, rc ? "ok" : "failed"));
return rc ? SQLITE_OK return rc ? SQLITE_OK
: winLogError(SQLITE_IOERR_CLOSE, osGetLastError(), : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(),
"winClose", pFile->zPath); "winClose", pFile->zPath);
@@ -2152,7 +2158,8 @@ static int winRead(
assert( id!=0 ); assert( id!=0 );
assert( amt>0 ); assert( amt>0 );
SimulateIOError(return SQLITE_IOERR_READ); SimulateIOError(return SQLITE_IOERR_READ);
OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype)); OSTRACE(("READ file=%p, buffer=%p, amount=%d, offset=%lld, lock=%d\n",
pFile->h, pBuf, amt, offset, pFile->locktype));
#if SQLITE_MAX_MMAP_SIZE>0 #if SQLITE_MAX_MMAP_SIZE>0
/* Deal with as much of this read request as possible by transfering /* Deal with as much of this read request as possible by transfering
@@ -2160,6 +2167,7 @@ static int winRead(
if( offset<pFile->mmapSize ){ if( offset<pFile->mmapSize ){
if( offset+amt <= pFile->mmapSize ){ if( offset+amt <= pFile->mmapSize ){
memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
OSTRACE(("READ-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
}else{ }else{
int nCopy = (int)(pFile->mmapSize - offset); int nCopy = (int)(pFile->mmapSize - offset);
@@ -2173,6 +2181,7 @@ static int winRead(
#if SQLITE_OS_WINCE #if SQLITE_OS_WINCE
if( seekWinFile(pFile, offset) ){ if( seekWinFile(pFile, offset) ){
OSTRACE(("READ file=%p, rc=SQLITE_FULL\n", pFile->h));
return SQLITE_FULL; return SQLITE_FULL;
} }
while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){ while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
@@ -2186,6 +2195,7 @@ static int winRead(
DWORD lastErrno; DWORD lastErrno;
if( retryIoerr(&nRetry, &lastErrno) ) continue; if( retryIoerr(&nRetry, &lastErrno) ) continue;
pFile->lastErrno = lastErrno; pFile->lastErrno = lastErrno;
OSTRACE(("READ file=%p, rc=SQLITE_IOERR_READ\n", pFile->h));
return winLogError(SQLITE_IOERR_READ, pFile->lastErrno, return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
"winRead", pFile->zPath); "winRead", pFile->zPath);
} }
@@ -2193,9 +2203,11 @@ static int winRead(
if( nRead<(DWORD)amt ){ if( nRead<(DWORD)amt ){
/* Unread parts of the buffer must be zero-filled */ /* Unread parts of the buffer must be zero-filled */
memset(&((char*)pBuf)[nRead], 0, amt-nRead); memset(&((char*)pBuf)[nRead], 0, amt-nRead);
OSTRACE(("READ file=%p, rc=SQLITE_IOERR_SHORT_READ\n", pFile->h));
return SQLITE_IOERR_SHORT_READ; return SQLITE_IOERR_SHORT_READ;
} }
OSTRACE(("READ file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -2218,7 +2230,8 @@ static int winWrite(
SimulateIOError(return SQLITE_IOERR_WRITE); SimulateIOError(return SQLITE_IOERR_WRITE);
SimulateDiskfullError(return SQLITE_FULL); SimulateDiskfullError(return SQLITE_FULL);
OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype)); OSTRACE(("WRITE file=%p, buffer=%p, amount=%d, offset=%lld, lock=%d\n",
pFile->h, pBuf, amt, offset, pFile->locktype));
#if SQLITE_MAX_MMAP_SIZE>0 #if SQLITE_MAX_MMAP_SIZE>0
/* Deal with as much of this write request as possible by transfering /* Deal with as much of this write request as possible by transfering
@@ -2226,6 +2239,7 @@ static int winWrite(
if( offset<pFile->mmapSize ){ if( offset<pFile->mmapSize ){
if( offset+amt <= pFile->mmapSize ){ if( offset+amt <= pFile->mmapSize ){
memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
OSTRACE(("WRITE-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
}else{ }else{
int nCopy = (int)(pFile->mmapSize - offset); int nCopy = (int)(pFile->mmapSize - offset);
@@ -2288,13 +2302,16 @@ static int winWrite(
if( rc ){ if( rc ){
if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ) if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
|| ( pFile->lastErrno==ERROR_DISK_FULL )){ || ( pFile->lastErrno==ERROR_DISK_FULL )){
OSTRACE(("WRITE file=%p, rc=SQLITE_FULL\n", pFile->h));
return SQLITE_FULL; return SQLITE_FULL;
} }
OSTRACE(("WRITE file=%p, rc=SQLITE_IOERR_WRITE\n", pFile->h));
return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno, return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
"winWrite", pFile->zPath); "winWrite", pFile->zPath);
}else{ }else{
logIoerr(nRetry); logIoerr(nRetry);
} }
OSTRACE(("WRITE file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -2307,9 +2324,9 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
DWORD lastErrno; DWORD lastErrno;
assert( pFile ); assert( pFile );
OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
SimulateIOError(return SQLITE_IOERR_TRUNCATE); SimulateIOError(return SQLITE_IOERR_TRUNCATE);
OSTRACE(("TRUNCATE file=%d, size=%lld, lock=%d\n",
pFile->h, nByte, pFile->locktype));
/* If the user has configured a chunk-size for this file, truncate the /* If the user has configured a chunk-size for this file, truncate the
** file so that it consists of an integer number of chunks (i.e. the ** file so that it consists of an integer number of chunks (i.e. the
@@ -2341,7 +2358,7 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
} }
#endif #endif
OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok")); OSTRACE(("TRUNCATE file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
return rc; return rc;
} }
@@ -2381,13 +2398,14 @@ static int winSync(sqlite3_file *id, int flags){
|| (flags&0x0F)==SQLITE_SYNC_FULL || (flags&0x0F)==SQLITE_SYNC_FULL
); );
OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
/* Unix cannot, but some systems may return SQLITE_FULL from here. This /* Unix cannot, but some systems may return SQLITE_FULL from here. This
** line is to test that doing so does not cause any problems. ** line is to test that doing so does not cause any problems.
*/ */
SimulateDiskfullError( return SQLITE_FULL ); SimulateDiskfullError( return SQLITE_FULL );
OSTRACE(("SYNC file=%p, flags=%x, lock=%d\n",
pFile->h, flags, pFile->locktype));
#ifndef SQLITE_TEST #ifndef SQLITE_TEST
UNUSED_PARAMETER(flags); UNUSED_PARAMETER(flags);
#else #else
@@ -2406,9 +2424,11 @@ static int winSync(sqlite3_file *id, int flags){
rc = osFlushFileBuffers(pFile->h); rc = osFlushFileBuffers(pFile->h);
SimulateIOError( rc=FALSE ); SimulateIOError( rc=FALSE );
if( rc ){ if( rc ){
OSTRACE(("SYNC file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
}else{ }else{
pFile->lastErrno = osGetLastError(); pFile->lastErrno = osGetLastError();
OSTRACE(("SYNC file=%p, rc=SQLITE_IOERR_FSYNC\n", pFile->h));
return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno, return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
"winSync", pFile->zPath); "winSync", pFile->zPath);
} }
@@ -2423,7 +2443,10 @@ static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
int rc = SQLITE_OK; int rc = SQLITE_OK;
assert( id!=0 ); assert( id!=0 );
assert( pSize!=0 );
SimulateIOError(return SQLITE_IOERR_FSTAT); SimulateIOError(return SQLITE_IOERR_FSTAT);
OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize));
#if SQLITE_OS_WINRT #if SQLITE_OS_WINRT
{ {
FILE_STANDARD_INFO info; FILE_STANDARD_INFO info;
@@ -2452,6 +2475,8 @@ static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
} }
} }
#endif #endif
OSTRACE(("SIZE file=%p, pSize=%p, *pSize=%lld, rc=%s\n",
pFile->h, pSize, *pSize, sqlite3ErrName(rc)));
return rc; return rc;
} }
@@ -2493,6 +2518,7 @@ static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
*/ */
static int getReadLock(winFile *pFile){ static int getReadLock(winFile *pFile){
int res; int res;
OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
if( isNT() ){ if( isNT() ){
#if SQLITE_OS_WINCE #if SQLITE_OS_WINCE
/* /*
@@ -2518,6 +2544,7 @@ static int getReadLock(winFile *pFile){
pFile->lastErrno = osGetLastError(); pFile->lastErrno = osGetLastError();
/* No need to log a failure to lock */ /* No need to log a failure to lock */
} }
OSTRACE(("READ-LOCK file=%p, rc=%s\n", pFile->h, sqlite3ErrName(res)));
return res; return res;
} }
@@ -2527,6 +2554,7 @@ static int getReadLock(winFile *pFile){
static int unlockReadLock(winFile *pFile){ static int unlockReadLock(winFile *pFile){
int res; int res;
DWORD lastErrno; DWORD lastErrno;
OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
if( isNT() ){ if( isNT() ){
res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
} }
@@ -2540,6 +2568,7 @@ static int unlockReadLock(winFile *pFile){
winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno, winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
"unlockReadLock", pFile->zPath); "unlockReadLock", pFile->zPath);
} }
OSTRACE(("READ-UNLOCK file=%p, rc=%s\n", pFile->h, sqlite3ErrName(res)));
return res; return res;
} }
@@ -2578,14 +2607,15 @@ static int winLock(sqlite3_file *id, int locktype){
DWORD lastErrno = NO_ERROR; DWORD lastErrno = NO_ERROR;
assert( id!=0 ); assert( id!=0 );
OSTRACE(("LOCK %d %d was %d(%d)\n", OSTRACE(("LOCK file=%p, oldLock=%d(%d), newLock=%d\n",
pFile->h, locktype, pFile->locktype, pFile->sharedLockByte)); pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
/* If there is already a lock of this type or more restrictive on the /* If there is already a lock of this type or more restrictive on the
** OsFile, do nothing. Don't use the end_lock: exit path, as ** OsFile, do nothing. Don't use the end_lock: exit path, as
** sqlite3OsEnterMutex() hasn't been called yet. ** sqlite3OsEnterMutex() hasn't been called yet.
*/ */
if( pFile->locktype>=locktype ){ if( pFile->locktype>=locktype ){
OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -2613,7 +2643,8 @@ static int winLock(sqlite3_file *id, int locktype){
** If you are using this code as a model for alternative VFSes, do not ** If you are using this code as a model for alternative VFSes, do not
** copy this retry logic. It is a hack intended for Windows only. ** copy this retry logic. It is a hack intended for Windows only.
*/ */
OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt)); OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, rc=%s\n",
pFile->h, cnt, sqlite3ErrName(res)));
if( cnt ) sqlite3_win32_sleep(1); if( cnt ) sqlite3_win32_sleep(1);
} }
gotPendingLock = res; gotPendingLock = res;
@@ -2658,14 +2689,12 @@ static int winLock(sqlite3_file *id, int locktype){
if( locktype==EXCLUSIVE_LOCK && res ){ if( locktype==EXCLUSIVE_LOCK && res ){
assert( pFile->locktype>=SHARED_LOCK ); assert( pFile->locktype>=SHARED_LOCK );
res = unlockReadLock(pFile); res = unlockReadLock(pFile);
OSTRACE(("unreadlock = %d\n", res));
res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0, res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0,
SHARED_SIZE, 0); SHARED_SIZE, 0);
if( res ){ if( res ){
newLocktype = EXCLUSIVE_LOCK; newLocktype = EXCLUSIVE_LOCK;
}else{ }else{
lastErrno = osGetLastError(); lastErrno = osGetLastError();
OSTRACE(("error-code = %d\n", lastErrno));
getReadLock(pFile); getReadLock(pFile);
} }
} }
@@ -2683,12 +2712,14 @@ static int winLock(sqlite3_file *id, int locktype){
if( res ){ if( res ){
rc = SQLITE_OK; rc = SQLITE_OK;
}else{ }else{
OSTRACE(("LOCK FAILED %d trying for %d but got %d\n", pFile->h, OSTRACE(("LOCK-FAIL file=%p, wanted=%d, got=%d\n",
locktype, newLocktype)); pFile->h, locktype, newLocktype));
pFile->lastErrno = lastErrno; pFile->lastErrno = lastErrno;
rc = SQLITE_BUSY; rc = SQLITE_BUSY;
} }
pFile->locktype = (u8)newLocktype; pFile->locktype = (u8)newLocktype;
OSTRACE(("LOCK file=%p, lock=%d, rc=%s\n",
pFile->h, pFile->locktype, sqlite3ErrName(rc)));
return rc; return rc;
} }
@@ -2702,20 +2733,23 @@ static int winCheckReservedLock(sqlite3_file *id, int *pResOut){
winFile *pFile = (winFile*)id; winFile *pFile = (winFile*)id;
SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut));
assert( id!=0 ); assert( id!=0 );
if( pFile->locktype>=RESERVED_LOCK ){ if( pFile->locktype>=RESERVED_LOCK ){
rc = 1; rc = 1;
OSTRACE(("TEST WR-LOCK %d %d (local)\n", pFile->h, rc)); OSTRACE(("TEST-WR-LOCK file=%p, rc=%d (local)\n", pFile->h, rc));
}else{ }else{
rc = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE, 0, 1, 0); rc = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE, 0, 1, 0);
if( rc ){ if( rc ){
winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
} }
rc = !rc; rc = !rc;
OSTRACE(("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc)); OSTRACE(("TEST-WR-LOCK file=%p, rc=%d (remote)\n", pFile->h, rc));
} }
*pResOut = rc; *pResOut = rc;
OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
pFile->h, pResOut, *pResOut));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -2736,8 +2770,8 @@ static int winUnlock(sqlite3_file *id, int locktype){
int rc = SQLITE_OK; int rc = SQLITE_OK;
assert( pFile!=0 ); assert( pFile!=0 );
assert( locktype<=SHARED_LOCK ); assert( locktype<=SHARED_LOCK );
OSTRACE(("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype, OSTRACE(("UNLOCK file=%p, oldLock=%d(%d), newLock=%d\n",
pFile->locktype, pFile->sharedLockByte)); pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
type = pFile->locktype; type = pFile->locktype;
if( type>=EXCLUSIVE_LOCK ){ if( type>=EXCLUSIVE_LOCK ){
winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
@@ -2758,6 +2792,8 @@ static int winUnlock(sqlite3_file *id, int locktype){
winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
} }
pFile->locktype = (u8)locktype; pFile->locktype = (u8)locktype;
OSTRACE(("UNLOCK file=%p, lock=%d, rc=%s\n",
pFile->h, pFile->locktype, sqlite3ErrName(rc)));
return rc; return rc;
} }
@@ -2785,17 +2821,21 @@ static int getTempname(int nBuf, char *zBuf);
*/ */
static int winFileControl(sqlite3_file *id, int op, void *pArg){ static int winFileControl(sqlite3_file *id, int op, void *pArg){
winFile *pFile = (winFile*)id; winFile *pFile = (winFile*)id;
OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
switch( op ){ switch( op ){
case SQLITE_FCNTL_LOCKSTATE: { case SQLITE_FCNTL_LOCKSTATE: {
*(int*)pArg = pFile->locktype; *(int*)pArg = pFile->locktype;
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_LAST_ERRNO: { case SQLITE_LAST_ERRNO: {
*(int*)pArg = (int)pFile->lastErrno; *(int*)pArg = (int)pFile->lastErrno;
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_CHUNK_SIZE: { case SQLITE_FCNTL_CHUNK_SIZE: {
pFile->szChunk = *(int *)pArg; pFile->szChunk = *(int *)pArg;
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_SIZE_HINT: { case SQLITE_FCNTL_SIZE_HINT: {
@@ -2810,20 +2850,25 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){
SimulateIOErrorBenign(0); SimulateIOErrorBenign(0);
} }
} }
OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
return rc; return rc;
} }
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_PERSIST_WAL: { case SQLITE_FCNTL_PERSIST_WAL: {
winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg); winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
winModeBit(pFile, WINFILE_PSOW, (int*)pArg); winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_VFSNAME: { case SQLITE_FCNTL_VFSNAME: {
*(char**)pArg = sqlite3_mprintf("win32"); *(char**)pArg = sqlite3_mprintf("win32");
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_WIN32_AV_RETRY: { case SQLITE_FCNTL_WIN32_AV_RETRY: {
@@ -2838,6 +2883,7 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){
}else{ }else{
a[1] = win32IoerrRetryDelay; a[1] = win32IoerrRetryDelay;
} }
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
case SQLITE_FCNTL_TEMPFILENAME: { case SQLITE_FCNTL_TEMPFILENAME: {
@@ -2846,6 +2892,7 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){
getTempname(pFile->pVfs->mxPathname, zTFile); getTempname(pFile->pVfs->mxPathname, zTFile);
*(char**)pArg = zTFile; *(char**)pArg = zTFile;
} }
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
#if SQLITE_MAX_MMAP_SIZE>0 #if SQLITE_MAX_MMAP_SIZE>0
@@ -2856,10 +2903,12 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){
} }
*(i64*)pArg = pFile->mmapSizeMax; *(i64*)pArg = pFile->mmapSizeMax;
if( newLimit>=0 ) pFile->mmapSizeMax = newLimit; if( newLimit>=0 ) pFile->mmapSizeMax = newLimit;
OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
return SQLITE_OK; return SQLITE_OK;
} }
#endif #endif
} }
OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h));
return SQLITE_NOTFOUND; return SQLITE_NOTFOUND;
} }
@@ -3020,6 +3069,9 @@ static int winShmSystemLock(
/* Access to the winShmNode object is serialized by the caller */ /* Access to the winShmNode object is serialized by the caller */
assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 ); assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n",
pFile->hFile.h, lockType, ofst, nByte));
/* Release/Acquire the system-level lock */ /* Release/Acquire the system-level lock */
if( lockType==_SHM_UNLCK ){ if( lockType==_SHM_UNLCK ){
rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0); rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
@@ -3037,11 +3089,9 @@ static int winShmSystemLock(
rc = SQLITE_BUSY; rc = SQLITE_BUSY;
} }
OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n", OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%d, rc=%s\n", pFile->hFile.h,
pFile->hFile.h, (lockType == _SHM_UNLCK) ? "winUnlockFile" : "winLockFile",
rc==SQLITE_OK ? "ok" : "failed", pFile->lastErrno, sqlite3ErrName(rc)));
lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
pFile->lastErrno));
return rc; return rc;
} }
@@ -3061,6 +3111,8 @@ static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){
winShmNode *p; winShmNode *p;
BOOL bRc; BOOL bRc;
assert( winShmMutexHeld() ); assert( winShmMutexHeld() );
OSTRACE(("SHM-PURGE pid=%d, deleteFlag=%d\n",
(int)osGetCurrentProcessId(), deleteFlag));
pp = &winShmNodeList; pp = &winShmNodeList;
while( (p = *pp)!=0 ){ while( (p = *pp)!=0 ){
if( p->nRef==0 ){ if( p->nRef==0 ){
@@ -3068,11 +3120,11 @@ static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){
if( p->mutex ) sqlite3_mutex_free(p->mutex); if( p->mutex ) sqlite3_mutex_free(p->mutex);
for(i=0; i<p->nRegion; i++){ for(i=0; i<p->nRegion; i++){
bRc = osUnmapViewOfFile(p->aRegion[i].pMap); bRc = osUnmapViewOfFile(p->aRegion[i].pMap);
OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n", OSTRACE(("SHM-PURGE-UNMAP pid=%d, region=%d, rc=%s\n",
(int)osGetCurrentProcessId(), i, (int)osGetCurrentProcessId(), i,
bRc ? "ok" : "failed")); bRc ? "ok" : "failed"));
bRc = osCloseHandle(p->aRegion[i].hMap); bRc = osCloseHandle(p->aRegion[i].hMap);
OSTRACE(("SHM-PURGE pid-%d close region=%d %s\n", OSTRACE(("SHM-PURGE-CLOSE pid=%d, region=%d, rc=%s\n",
(int)osGetCurrentProcessId(), i, (int)osGetCurrentProcessId(), i,
bRc ? "ok" : "failed")); bRc ? "ok" : "failed"));
} }
@@ -3353,9 +3405,9 @@ static int winShmLock(
} }
} }
sqlite3_mutex_leave(pShmNode->mutex); sqlite3_mutex_leave(pShmNode->mutex);
OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n", OSTRACE(("SHM-LOCK pid=%d, id=%d, sharedMask=%03x, exclMask=%03x, rc=%s\n",
p->id, (int)osGetCurrentProcessId(), p->sharedMask, p->exclMask, (int)osGetCurrentProcessId(), p->id, p->sharedMask, p->exclMask,
rc ? "failed" : "ok")); sqlite3ErrName(rc)));
return rc; return rc;
} }
@@ -3476,7 +3528,7 @@ static int winShmMap(
NULL, PAGE_READWRITE, 0, nByte, NULL NULL, PAGE_READWRITE, 0, nByte, NULL
); );
#endif #endif
OSTRACE(("SHM-MAP pid-%d create region=%d nbyte=%d %s\n", OSTRACE(("SHM-MAP-CREATE pid=%d, region=%d, size=%d, rc=%s\n",
(int)osGetCurrentProcessId(), pShmNode->nRegion, nByte, (int)osGetCurrentProcessId(), pShmNode->nRegion, nByte,
hMap ? "ok" : "failed")); hMap ? "ok" : "failed"));
if( hMap ){ if( hMap ){
@@ -3491,7 +3543,7 @@ static int winShmMap(
0, iOffset - iOffsetShift, szRegion + iOffsetShift 0, iOffset - iOffsetShift, szRegion + iOffsetShift
); );
#endif #endif
OSTRACE(("SHM-MAP pid-%d map region=%d offset=%d size=%d %s\n", OSTRACE(("SHM-MAP-MAP pid=%d, region=%d, offset=%d, size=%d, rc=%s\n",
(int)osGetCurrentProcessId(), pShmNode->nRegion, iOffset, (int)osGetCurrentProcessId(), pShmNode->nRegion, iOffset,
szRegion, pMap ? "ok" : "failed")); szRegion, pMap ? "ok" : "failed"));
} }
@@ -3535,9 +3587,17 @@ shmpage_out:
#if SQLITE_MAX_MMAP_SIZE>0 #if SQLITE_MAX_MMAP_SIZE>0
static int winUnmapfile(winFile *pFile){ static int winUnmapfile(winFile *pFile){
assert( pFile!=0 ); assert( pFile!=0 );
OSTRACE(("UNMAP-FILE pid=%d, pFile=%p, hMap=%p, pMapRegion=%p, "
"mmapSize=%lld, mmapSizeActual=%lld, mmapSizeMax=%lld\n",
(int)osGetCurrentProcessId(), pFile, pFile->hMap,
pFile->pMapRegion, pFile->mmapSize, pFile->mmapSizeActual,
pFile->mmapSizeMax));
if( pFile->pMapRegion ){ if( pFile->pMapRegion ){
if( !osUnmapViewOfFile(pFile->pMapRegion) ){ if( !osUnmapViewOfFile(pFile->pMapRegion) ){
pFile->lastErrno = osGetLastError(); pFile->lastErrno = osGetLastError();
OSTRACE(("UNMAP-FILE pid=%d, pFile=%p, pMapRegion=%p, "
"rc=SQLITE_IOERR_MMAP\n", (int)osGetCurrentProcessId(),
pFile, pFile->pMapRegion));
return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
"winUnmap1", pFile->zPath); "winUnmap1", pFile->zPath);
} }
@@ -3548,11 +3608,15 @@ static int winUnmapfile(winFile *pFile){
if( pFile->hMap!=NULL ){ if( pFile->hMap!=NULL ){
if( !osCloseHandle(pFile->hMap) ){ if( !osCloseHandle(pFile->hMap) ){
pFile->lastErrno = osGetLastError(); pFile->lastErrno = osGetLastError();
OSTRACE(("UNMAP-FILE pid=%d, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n",
(int)osGetCurrentProcessId(), pFile, pFile->hMap));
return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
"winUnmap2", pFile->zPath); "winUnmap2", pFile->zPath);
} }
pFile->hMap = NULL; pFile->hMap = NULL;
} }
OSTRACE(("UNMAP-FILE pid=%d, pFile=%p, rc=SQLITE_OK\n",
(int)osGetCurrentProcessId(), pFile));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -3577,11 +3641,16 @@ static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
int rc; int rc;
assert( nMap>=0 || pFd->nFetchOut==0 ); assert( nMap>=0 || pFd->nFetchOut==0 );
OSTRACE(("MAP-FILE pid=%d, pFile=%p, size=%lld\n",
(int)osGetCurrentProcessId(), pFd, nByte));
if( pFd->nFetchOut>0 ) return SQLITE_OK; if( pFd->nFetchOut>0 ) return SQLITE_OK;
if( nMap<0 ){ if( nMap<0 ){
rc = winFileSize((sqlite3_file*)pFd, &nMap); rc = winFileSize((sqlite3_file*)pFd, &nMap);
if( rc ){ if( rc ){
OSTRACE(("MAP-FILE pid=%d, pFile=%p, rc=SQLITE_IOERR_FSTAT\n",
(int)osGetCurrentProcessId(), pFd));
return SQLITE_IOERR_FSTAT; return SQLITE_IOERR_FSTAT;
} }
} }
@@ -3619,6 +3688,8 @@ static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno,
"winMapfile", pFd->zPath); "winMapfile", pFd->zPath);
/* Log the error, but continue normal operation using xRead/xWrite */ /* Log the error, but continue normal operation using xRead/xWrite */
OSTRACE(("MAP-FILE-CREATE pid=%d, pFile=%p, rc=SQLITE_IOERR_MMAP\n",
(int)osGetCurrentProcessId(), pFd));
return SQLITE_OK; return SQLITE_OK;
} }
assert( (nMap % winSysInfo.dwPageSize)==0 ); assert( (nMap % winSysInfo.dwPageSize)==0 );
@@ -3634,6 +3705,8 @@ static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
pFd->lastErrno = osGetLastError(); pFd->lastErrno = osGetLastError();
winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno,
"winMapfile", pFd->zPath); "winMapfile", pFd->zPath);
OSTRACE(("MAP-FILE-MAP pid=%d, pFile=%p, rc=SQLITE_IOERR_MMAP\n",
(int)osGetCurrentProcessId(), pFd));
return SQLITE_OK; return SQLITE_OK;
} }
pFd->pMapRegion = pNew; pFd->pMapRegion = pNew;
@@ -3641,6 +3714,8 @@ static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
pFd->mmapSizeActual = nMap; pFd->mmapSizeActual = nMap;
} }
OSTRACE(("MAP-FILE pid=%d, pFile=%p, rc=SQLITE_OK\n",
(int)osGetCurrentProcessId(), pFd));
return SQLITE_OK; return SQLITE_OK;
} }
#endif /* SQLITE_MAX_MMAP_SIZE>0 */ #endif /* SQLITE_MAX_MMAP_SIZE>0 */
@@ -3663,11 +3738,18 @@ static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
#endif #endif
*pp = 0; *pp = 0;
OSTRACE(("FETCH pid=%d, pFile=%p, offset=%lld, amount=%d, pp=%p\n",
(int)osGetCurrentProcessId(), fd, iOff, nAmt, pp));
#if SQLITE_MAX_MMAP_SIZE>0 #if SQLITE_MAX_MMAP_SIZE>0
if( pFd->mmapSizeMax>0 ){ if( pFd->mmapSizeMax>0 ){
if( pFd->pMapRegion==0 ){ if( pFd->pMapRegion==0 ){
int rc = winMapfile(pFd, -1); int rc = winMapfile(pFd, -1);
if( rc!=SQLITE_OK ) return rc; if( rc!=SQLITE_OK ){
OSTRACE(("FETCH pid=%d, pFile=%p, rc=%s\n",
(int)osGetCurrentProcessId(), pFd, sqlite3ErrName(rc)));
return rc;
}
} }
if( pFd->mmapSize >= iOff+nAmt ){ if( pFd->mmapSize >= iOff+nAmt ){
*pp = &((u8 *)pFd->pMapRegion)[iOff]; *pp = &((u8 *)pFd->pMapRegion)[iOff];
@@ -3675,6 +3757,9 @@ static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
} }
} }
#endif #endif
OSTRACE(("FETCH pid=%d, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
(int)osGetCurrentProcessId(), fd, pp, pp ? *pp : 0));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -3700,6 +3785,9 @@ static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){
/* If p!=0, it must match the iOff value. */ /* If p!=0, it must match the iOff value. */
assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
OSTRACE(("UNFETCH pid=%d, pFile=%p, offset=%lld, p=%p\n",
(int)osGetCurrentProcessId(), pFd, iOff, p));
if( p ){ if( p ){
pFd->nFetchOut--; pFd->nFetchOut--;
}else{ }else{
@@ -3712,6 +3800,9 @@ static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){
assert( pFd->nFetchOut>=0 ); assert( pFd->nFetchOut>=0 );
#endif #endif
OSTRACE(("UNFETCH pid=%d, pFile=%p, rc=SQLITE_OK\n",
(int)osGetCurrentProcessId(), fd));
return SQLITE_OK; return SQLITE_OK;
} }
@@ -3808,6 +3899,7 @@ static int getTempname(int nBuf, char *zBuf){
sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti); sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
sqlite3_free(zMulti); sqlite3_free(zMulti);
}else{ }else{
OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
return SQLITE_IOERR_NOMEM; return SQLITE_IOERR_NOMEM;
} }
} }
@@ -3821,6 +3913,7 @@ static int getTempname(int nBuf, char *zBuf){
sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8); sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
sqlite3_free(zUtf8); sqlite3_free(zUtf8);
}else{ }else{
OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
return SQLITE_IOERR_NOMEM; return SQLITE_IOERR_NOMEM;
} }
} }
@@ -3833,6 +3926,7 @@ static int getTempname(int nBuf, char *zBuf){
nTempPath = sqlite3Strlen30(zTempPath); nTempPath = sqlite3Strlen30(zTempPath);
if( (nTempPath + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 18) >= nBuf ){ if( (nTempPath + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 18) >= nBuf ){
OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
return SQLITE_ERROR; return SQLITE_ERROR;
} }
@@ -3850,8 +3944,8 @@ static int getTempname(int nBuf, char *zBuf){
zBuf[j] = 0; zBuf[j] = 0;
zBuf[j+1] = 0; zBuf[j+1] = 0;
OSTRACE(("TEMP FILENAME: %s\n", zBuf)); OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
return SQLITE_OK; return SQLITE_OK;
} }
/* /*
@@ -3931,6 +4025,9 @@ static int winOpen(
)); ));
#endif #endif
OSTRACE(("OPEN name=%s, pFile=%p, flags=%x, pOutFlags=%p\n",
zUtf8Name, id, flags, pOutFlags));
/* Check the following statements are true: /* Check the following statements are true:
** **
** (a) Exactly one of the READWRITE and READONLY flags must be set, and ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
@@ -3976,6 +4073,8 @@ static int winOpen(
memset(zTmpname, 0, MAX_PATH+2); memset(zTmpname, 0, MAX_PATH+2);
rc = getTempname(MAX_PATH+2, zTmpname); rc = getTempname(MAX_PATH+2, zTmpname);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
OSTRACE(("OPEN name=%s, rc=%s",
zUtf8Name, sqlite3ErrName(rc)));
return rc; return rc;
} }
zUtf8Name = zTmpname; zUtf8Name = zTmpname;
@@ -3991,11 +4090,13 @@ static int winOpen(
/* Convert the filename to the system encoding. */ /* Convert the filename to the system encoding. */
zConverted = convertUtf8Filename(zUtf8Name); zConverted = convertUtf8Filename(zUtf8Name);
if( zConverted==0 ){ if( zConverted==0 ){
OSTRACE(("OPEN name=%s, rc=SQLITE_IOERR_NOMEM", zUtf8Name));
return SQLITE_IOERR_NOMEM; return SQLITE_IOERR_NOMEM;
} }
if( winIsDir(zConverted) ){ if( winIsDir(zConverted) ){
sqlite3_free(zConverted); sqlite3_free(zConverted);
OSTRACE(("OPEN name=%s, rc=SQLITE_CANTOPEN_ISDIR", zUtf8Name));
return SQLITE_CANTOPEN_ISDIR; return SQLITE_CANTOPEN_ISDIR;
} }
@@ -4086,9 +4187,8 @@ static int winOpen(
#endif #endif
logIoerr(cnt); logIoerr(cnt);
OSTRACE(("OPEN %d %s 0x%lx %s\n", OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name,
h, zName, dwDesiredAccess, dwDesiredAccess, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok"));
h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
if( h==INVALID_HANDLE_VALUE ){ if( h==INVALID_HANDLE_VALUE ){
pFile->lastErrno = lastErrno; pFile->lastErrno = lastErrno;
@@ -4118,6 +4218,7 @@ static int winOpen(
){ ){
osCloseHandle(h); osCloseHandle(h);
sqlite3_free(zConverted); sqlite3_free(zConverted);
OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
return rc; return rc;
} }
if( isTemp ){ if( isTemp ){
@@ -4177,6 +4278,8 @@ static int winDelete(
UNUSED_PARAMETER(syncDir); UNUSED_PARAMETER(syncDir);
SimulateIOError(return SQLITE_IOERR_DELETE); SimulateIOError(return SQLITE_IOERR_DELETE);
OSTRACE(("DELETE name=%s, syncDir=%d\n", zFilename, syncDir));
zConverted = convertUtf8Filename(zFilename); zConverted = convertUtf8Filename(zFilename);
if( zConverted==0 ){ if( zConverted==0 ){
return SQLITE_IOERR_NOMEM; return SQLITE_IOERR_NOMEM;
@@ -4262,7 +4365,7 @@ static int winDelete(
logIoerr(cnt); logIoerr(cnt);
} }
sqlite3_free(zConverted); sqlite3_free(zConverted);
OSTRACE(("DELETE \"%s\" %s\n", zFilename, (rc ? "failed" : "ok" ))); OSTRACE(("DELETE name=%s, rc=%s\n", zFilename, sqlite3ErrName(rc)));
return rc; return rc;
} }
@@ -4282,8 +4385,12 @@ static int winAccess(
UNUSED_PARAMETER(pVfs); UNUSED_PARAMETER(pVfs);
SimulateIOError( return SQLITE_IOERR_ACCESS; ); SimulateIOError( return SQLITE_IOERR_ACCESS; );
OSTRACE(("ACCESS name=%s, flags=%x, pResOut=%p\n",
zFilename, flags, pResOut));
zConverted = convertUtf8Filename(zFilename); zConverted = convertUtf8Filename(zFilename);
if( zConverted==0 ){ if( zConverted==0 ){
OSTRACE(("ACCESS name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename));
return SQLITE_IOERR_NOMEM; return SQLITE_IOERR_NOMEM;
} }
if( isNT() ){ if( isNT() ){
@@ -4334,6 +4441,8 @@ static int winAccess(
assert(!"Invalid flags argument"); assert(!"Invalid flags argument");
} }
*pResOut = rc; *pResOut = rc;
OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
zFilename, pResOut, *pResOut));
return SQLITE_OK; return SQLITE_OK;
} }

1
src/sqliteInt.h
View File

@@ -3092,6 +3092,7 @@ void sqlite3Error(sqlite3*, int, const char*,...);
void *sqlite3HexToBlob(sqlite3*, const char *z, int n); void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
u8 sqlite3HexToInt(int h); u8 sqlite3HexToInt(int h);
int sqlite3TwoPartName(Parse *, Token *, Token *, Token **); int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
const char *sqlite3ErrName(int);
const char *sqlite3ErrStr(int); const char *sqlite3ErrStr(int);
int sqlite3ReadSchema(Parse *pParse); int sqlite3ReadSchema(Parse *pParse);
CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int); CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);