--- a/persistentstorage/sqlite3api/OsLayer/os_symbian_mt.cpp Tue Aug 31 16:57:14 2010 +0300
+++ b/persistentstorage/sqlite3api/OsLayer/os_symbian_mt.cpp Wed Sep 01 12:39:58 2010 +0100
@@ -36,16 +36,7 @@
}
#include <e32math.h>
#include "os_symbian.h"
-#include "SqliteUtil.h"
-#include "OstTraceDefinitions.h"
-#ifdef OST_TRACE_COMPILER_IN_USE
-#include "os_symbian_mtTraces.h"
-#endif
-#include "SqliteTraceDef.h"
-
-//Bit-mask constant. If xOpen()'s "aFlag" parameter contains one of these bits set, then the the file top be
-//opened or created is a journal file.
-const TUint KJournalFileTypeBitMask = SQLITE_OPEN_MAIN_JOURNAL | SQLITE_OPEN_TEMP_JOURNAL | SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_MASTER_JOURNAL;
+#include "UTraceSqlite.h"
#ifdef SQLITE_TEST
@@ -105,7 +96,7 @@
return SQLITE_FULL;
default:
#ifdef _DEBUG
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, OS2SQLITEERR, "OS;0;Os2SqliteErr;aOsErr=%d", aOsErr));
+ RDebug::Print(_L("SQLite3 C API, Os2SqliteErr(), err=%d\n"), aOsErr);
#endif
break;
}
@@ -134,7 +125,6 @@
{
iFs.Close();
}
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TSTATICFS_CONNECT, "OS;0;TStaticFs::Connect;iFs.Handle()=0x%X;err=%d", iFs.Handle(), err));
return err;
}
@@ -149,7 +139,6 @@
iRefCount(0),
iOwnerThreadId(KMaxTUint64)
{
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3_MUTEX_SQLITE3_MUTEX, "OS;0x%X;sqlite3_mutex::sqlite3_mutex", (TUint)this));
}
/**
@@ -157,7 +146,6 @@
*/
sqlite3_mutex::~sqlite3_mutex()
{
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3_MUTEX_SQLITE3_MUTEX2, "OS;0x%X;sqlite3_mutex::~sqlite3_mutex", (TUint)this));
iMutex.Close();
}
@@ -171,7 +159,7 @@
*/
void sqlite3_mutex::Enter()
{
- __ASSERT_DEBUG(iRefCount >= 0, __SQLITEPANIC(ESqliteOsPanicMutexLockCounter));
+ __ASSERT_DEBUG(iRefCount >= 0, User::Panic(KPanicCategory, EPanicMutexLockCounter));
iMutex.Wait();
RThread currThread;
iOwnerThreadId = currThread.Id();
@@ -189,10 +177,10 @@
*/
void sqlite3_mutex::Leave()
{
- __ASSERT_DEBUG(iRefCount > 0, __SQLITEPANIC(ESqliteOsPanicMutexLockCounter));
+ __ASSERT_DEBUG(iRefCount > 0, User::Panic(KPanicCategory, EPanicMutexLockCounter));
#ifdef _DEBUG
RThread currThread;
- __ASSERT_DEBUG(iOwnerThreadId == currThread.Id(), __SQLITEPANIC(ESqliteOsPanicMutexOwner));
+ __ASSERT_DEBUG(iOwnerThreadId == currThread.Id(), User::Panic(KPanicCategory, EPanicMutexOwner));
#endif
--iRefCount;
iMutex.Signal();
@@ -217,9 +205,7 @@
*/
TInt sqlite3_mutex::Create()
{
- TInt err = iMutex.CreateLocal();
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, SQLITE3_MUTEX_CREATE, "OS;0x%X;sqlite3_mutex::Create;err=%d", (TUint)this, err));
- return err;
+ return iMutex.CreateLocal();
}
/**
@@ -238,7 +224,6 @@
self = NULL;
}
}
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, CRECURSIVEMUTEX_NEWL, "OS;0x%X;CRecursiveMutex::New", (TUint)self));
return self;
}
@@ -258,6 +243,7 @@
*/
int TMutexApi::Init()
{
+ SQLUTRACE_PROFILER(0);
return SQLITE_OK;
}
@@ -269,6 +255,7 @@
*/
int TMutexApi::End()
{
+ SQLUTRACE_PROFILER(0);
return SQLITE_OK;
}
@@ -281,6 +268,7 @@
*/
sqlite3_mutex* TMutexApi::Alloc(int aType)
{
+ SQLUTRACE_PROFILER(0);
sqlite3_mutex* mutex = NULL;
switch(aType)
{
@@ -293,7 +281,6 @@
//value is 2 (SQLITE_MUTEX_FAST is 0, SQLITE_MUTEX_RECURSIVE is 1).
break;
}
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TMUTEXAPI_ALLOC, "OS;0;TMutexApi::Alloc;aType=%d;mutex=0x%X", aType, (TUint)mutex));
return mutex;
}
@@ -303,7 +290,7 @@
*/
void TMutexApi::Free(sqlite3_mutex* aMutex)
{
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TMUTEXAPI_FREE, "OS;0;TMutexApi::Free;mutex=0x%X", (TUint)aMutex));
+ SQLUTRACE_PROFILER(0);
delete aMutex;
}
@@ -317,6 +304,7 @@
*/
void TMutexApi::Enter(sqlite3_mutex* aMutex)
{
+ SQLUTRACE_PROFILER(0);
aMutex->Enter();
}
@@ -327,6 +315,7 @@
*/
int TMutexApi::Try(sqlite3_mutex*)
{
+ SQLUTRACE_PROFILER(0);
return SQLITE_BUSY;
}
@@ -340,6 +329,7 @@
*/
void TMutexApi::Leave(sqlite3_mutex* aMutex)
{
+ SQLUTRACE_PROFILER(0);
aMutex->Leave();
}
@@ -355,6 +345,7 @@
*/
int TMutexApi::Held(sqlite3_mutex* aMutex)
{
+ SQLUTRACE_PROFILER(0);
return aMutex->IsHeld();
}
@@ -370,6 +361,7 @@
*/
int TMutexApi::Notheld(sqlite3_mutex* aMutex)
{
+ SQLUTRACE_PROFILER(0);
return !aMutex->IsHeld();
}
@@ -382,9 +374,7 @@
*/
extern "C" SQLITE_EXPORT int sqlite3_os_init(void)
{
- TInt err = sqlite3_vfs_register(VfsApi(), 1);
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3_OS_INIT, "OS;0;sqlite3_os_init;err=%d", err));
- return err;
+ return sqlite3_vfs_register(VfsApi(), 1);
}
/**
@@ -392,9 +382,7 @@
*/
extern "C" SQLITE_EXPORT int sqlite3_os_end(void)
{
- TInt err = sqlite3_vfs_unregister(VfsApi());
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3_OS_END, "OS;0;sqlite3_os_end;err=%d", err));
- return err;
+ return sqlite3_vfs_unregister(VfsApi());
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -533,7 +521,6 @@
iDeviceCharacteristics(-1)
{
pMethods = 0;
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TDBFILE_TDBFILE, "OS;0x%X;TDbFile::TDbFile", (TUint)this));
}
/**
@@ -554,7 +541,7 @@
*/
static inline TDbFile& DbFile(sqlite3_file* aDbFile)
{
- __ASSERT_DEBUG(aDbFile != 0, __SQLITEPANIC2(ESqliteOsPanicNullDbFilePtr));
+ __ASSERT_DEBUG(aDbFile != 0, User::Panic(KPanicCategory, EPanicNullDbFilePtr));
return *(static_cast <TDbFile*> (aDbFile));
}
@@ -576,14 +563,13 @@
*/
/* static */ int TFileIo::Close(sqlite3_file* aDbFile)
{
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_CLOSE1, "OS;0x%X;TFileIo::Close", (TUint)&dbFile));
dbFile.iFileBuf.Close();
if(dbFile.iFullName)
{//"iFullName" will not be NULL only when TVfs::Open() is called with SQLITE_OPEN_DELETEONCLOSE flag.
//That means - SQlite expects the file to be deleted after the file close operation.
- __SQLITETRACE_OSEXPR(TInt err = ) TStaticFs::Fs().Delete(*dbFile.iFullName);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_CLOSE2, "OS;0x%X;TFileIo::Close;delete fileName=%S;err=%d", (TUint)&dbFile, __SQLITEPRNSTR(*dbFile.iFullName), err));
+ (void)TStaticFs::Fs().Delete(*dbFile.iFullName);
delete dbFile.iFullName;
dbFile.iFullName = NULL;
}
@@ -612,9 +598,10 @@
*/
/* static */ int TFileIo::Read(sqlite3_file* aDbFile, void* aBuf, int aAmt, sqlite3_int64 aOffset)
{
+ SQLUTRACE_PROFILER(aDbFile);
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileRead, aAmt, aOffset));
SimulateIOError(return SQLITE_IOERR_READ);
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_READ_ENTRY, "OS-Entry;0x%X;TFileIo::Read;aAmt=%d;aOffset=%lld", (TUint)&dbFile, aAmt, aOffset));
TPtr8 ptr((TUint8*)aBuf, 0, aAmt);
TInt err = dbFile.iFileBuf.Read(aOffset, ptr);
TInt cnt = ptr.Length();
@@ -624,7 +611,6 @@
Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
sqliteErr = SQLITE_IOERR_SHORT_READ;
}
- SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TFILEIO_READ_EXIT, "OS-Exit;0x%X;TFileIo::Read;cnt=%d;err=%d;sqliteErr=%d", (TUint)&dbFile, cnt, err, sqliteErr));
return sqliteErr;
}
@@ -648,19 +634,18 @@
*/
/* static */ int TFileIo::Write(sqlite3_file* aDbFile, const void* aData, int aAmt, sqlite3_int64 aOffset)
{
+ SQLUTRACE_PROFILER(aDbFile);
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileWrite, aAmt, aOffset));
SimulateIOError(return SQLITE_IOERR_WRITE);
SimulateDiskfullError(return SQLITE_FULL);
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_ENTRY, "OS-Entry;0x%X;TFileIo::Write;aAmt=%d;aOffset=%lld", (TUint)&dbFile, aAmt, aOffset));
TInt err = KErrAccessDenied;
if(!dbFile.iReadOnly)
{
TPtrC8 ptr((const TUint8*)aData, aAmt);
err = dbFile.iFileBuf.Write(aOffset, ptr);
}
- TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_WRITE);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_EXIT, "OS-Exit;0x%X;TFileIo::Write;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
- return sqliteErr;
+ return ::Os2SqliteErr(err, SQLITE_IOERR_WRITE);
}
/**
@@ -681,17 +666,16 @@
*/
/* static */ int TFileIo::Truncate(sqlite3_file* aDbFile, sqlite3_int64 aLength)
{
+ SQLUTRACE_PROFILER(aDbFile);
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileTruncate, aLength));
SimulateIOError(return SQLITE_IOERR_TRUNCATE);
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_TRUNCATE_ENTRY, "OS-Entry;0x%X;TFileIo::Truncate;aLength=%lld", (TUint)&dbFile, aLength));
TInt err = KErrAccessDenied;
if(!dbFile.iReadOnly)
{
err = dbFile.iFileBuf.SetSize(aLength);
}
- TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_TRUNCATE);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_TRUNCATE_EXIT, "OS-Exit;0x%X;TFileIo::Truncate;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
- return sqliteErr;
+ return ::Os2SqliteErr(err, SQLITE_IOERR_TRUNCATE);
}
/**
@@ -712,9 +696,9 @@
*/
/* static */int TFileIo::Sync(sqlite3_file* aDbFile, int aFlags)
{
+ SQLUTRACE_PROFILER(aDbFile);
SimulateIOError(return SQLITE_IOERR_FSYNC);
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_SYNC_ENTRY, "OS-Entry;0x%X;TFileIo::Sync", (TUint)&dbFile));
#ifdef SQLITE_TEST
if(aFlags & SQLITE_SYNC_FULL)
{
@@ -729,9 +713,7 @@
{
err = dbFile.iFileBuf.Flush();
}
- TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_FSYNC);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_SYNC_EXIT, "OS-Exit;0x%X;TFileIo::Sync;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
- return sqliteErr;
+ return ::Os2SqliteErr(err, SQLITE_IOERR_FSYNC);
}
/**
@@ -750,13 +732,11 @@
*/
/* static */ int TFileIo::FileSize(sqlite3_file* aDbFile, sqlite3_int64* aSize)
{
+ SQLUTRACE_PROFILER(aDbFile);
SimulateIOError(return SQLITE_IOERR_FSTAT);
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_FILESIZE_ENTRY, "OS-Entry;0x%X;TFileIo::FileSize", (TUint)&dbFile));
TInt err = dbFile.iFileBuf.Size(*aSize);
- TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_FSTAT);
- SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TFILEIO_FILESIZE_EXIT, "OS-Exit;0x%X;TFileIo::FileSize;aSize=%lld;err=%d;sqliteErr=%d", (TUint)&dbFile, *aSize, err, sqliteErr));
- return sqliteErr;
+ return ::Os2SqliteErr(err, SQLITE_IOERR_FSTAT);
}
/**
@@ -799,7 +779,6 @@
break;
}
}
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_GETREADLOCK, "OS;0x%X;TFileIo::GetReadLock;rc=%d", (TUint)&aDbFile, rc));
return rc;
}
@@ -816,9 +795,7 @@
*/
/* static */TInt TFileIo::UnlockReadLock(TDbFile& aDbFile)
{
- TInt err = aDbFile.iFileBuf.UnLock(SHARED_FIRST + aDbFile.iSharedLockByte, 1);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_UNLOCKREADLOCK, "OS;0x%X;TFileIo::UnlockReadLock;err=%d", (TUint)&aDbFile, err));
- return err;
+ return aDbFile.iFileBuf.UnLock(SHARED_FIRST + aDbFile.iSharedLockByte, 1);
}
/**
@@ -855,11 +832,11 @@
*/
/* static */ int TFileIo::Lock(sqlite3_file* aDbFile, int aLockType)
{
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
//If there is already a lock of this type or more restrictive on the aDbFile, then - do nothing.
if(dbFile.iLockType >= aLockType)
{
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_LOCK1, "OS;0x%X;TFileIo::Lock;dbFile.iLockType=%d;aLockType=%d", (TUint)&dbFile, dbFile.iLockType, aLockType));
return SQLITE_OK;
}
@@ -871,15 +848,14 @@
TInt err = dbFile.iFileBuf.Flush(ETrue);
if(err != KErrNone)
{
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_LOCK2, "OS;0x%X;TFileIo::Lock;iFileBuf.Flush() failed, err=%d", (TUint)&dbFile, err));
return ::Os2SqliteErr(err, SQLITE_IOERR_LOCK);
}
}
//Make sure the locking sequence is correct
- __ASSERT_DEBUG(dbFile.iLockType != SQLITE_LOCK_NONE || aLockType == SQLITE_LOCK_SHARED, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
- __ASSERT_DEBUG(aLockType != SQLITE_LOCK_PENDING, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
- __ASSERT_DEBUG(aLockType != SQLITE_LOCK_RESERVED || dbFile.iLockType == SQLITE_LOCK_SHARED, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
+ __ASSERT_DEBUG(dbFile.iLockType != SQLITE_LOCK_NONE || aLockType == SQLITE_LOCK_SHARED, User::Panic(KPanicCategory, EPanicInvalidLock));
+ __ASSERT_DEBUG(aLockType != SQLITE_LOCK_PENDING, User::Panic(KPanicCategory, EPanicInvalidLock));
+ __ASSERT_DEBUG(aLockType != SQLITE_LOCK_RESERVED || dbFile.iLockType == SQLITE_LOCK_SHARED, User::Panic(KPanicCategory, EPanicInvalidLock));
TInt rc = SQLITE_OK; //Return code from subroutines
TBool locked = ETrue; //Result of a file lock call (the default value means: "lock accuired")
@@ -916,11 +892,10 @@
//Acquire a shared lock
if(aLockType == SQLITE_LOCK_SHARED && locked)
{
- __ASSERT_DEBUG(dbFile.iLockType == SQLITE_LOCK_NONE, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
+ __ASSERT_DEBUG(dbFile.iLockType == SQLITE_LOCK_NONE, User::Panic(KPanicCategory, EPanicInvalidLock));
TInt err = TFileIo::GetReadLock(dbFile);
if(err != KErrNone && err != KErrLocked)
{
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_LOCK3, "OS;0x%X;TFileIo::Lock;TFileIo::GetReadLock() failed, err=%d", (TUint)&dbFile, err));
return ::Os2SqliteErr(err, SQLITE_IOERR_LOCK);
}
locked = (err == KErrNone);
@@ -933,11 +908,10 @@
//Acquire a RESERVED lock
if(aLockType == SQLITE_LOCK_RESERVED && locked)
{
- __ASSERT_DEBUG(dbFile.iLockType == SQLITE_LOCK_SHARED, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
+ __ASSERT_DEBUG(dbFile.iLockType == SQLITE_LOCK_SHARED, User::Panic(KPanicCategory, EPanicInvalidLock));
TInt err = dbFile.iFileBuf.Lock(RESERVED_BYTE, 1);
if(err != KErrNone && err != KErrLocked)
{
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_LOCK4, "OS;0x%X;TFileIo::Lock;iFileBuf.Lock() failed, err=%d", (TUint)&dbFile, err));
return ::Os2SqliteErr(err, SQLITE_IOERR_LOCK);
}
locked = (err == KErrNone);
@@ -957,12 +931,11 @@
//Acquire an EXCLUSIVE lock
if(aLockType == SQLITE_LOCK_EXCLUSIVE && locked)
{
- __ASSERT_DEBUG(dbFile.iLockType >= SQLITE_LOCK_SHARED, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
+ __ASSERT_DEBUG(dbFile.iLockType >= SQLITE_LOCK_SHARED, User::Panic(KPanicCategory, EPanicInvalidLock));
(void)TFileIo::UnlockReadLock(dbFile);
TInt err = dbFile.iFileBuf.Lock(SHARED_FIRST, SHARED_SIZE);
if(err != KErrNone && err != KErrLocked)
{
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_LOCK5, "OS;0x%X;TFileIo::Lock;iFileBuf.Lock()-2 failed, err=%d", (TUint)&dbFile, err));
return ::Os2SqliteErr(err, SQLITE_IOERR_LOCK);
}
locked = (err == KErrNone);
@@ -976,15 +949,13 @@
// release it now.
if(gotPendingLock && aLockType == SQLITE_LOCK_SHARED)
{
- __SQLITETRACE_OSEXPR(TInt err =) dbFile.iFileBuf.UnLock(PENDING_BYTE, 1);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_LOCK6, "OS;0x%X;TFileIo::Lock;iFileBuf.UnLock()=%d", (TUint)&dbFile, err));
+ (void)dbFile.iFileBuf.UnLock(PENDING_BYTE, 1);
}
// Update the state of the lock has held in the file descriptor then
// return the appropriate result code.
rc = locked ? SQLITE_OK : SQLITE_BUSY;
dbFile.iLockType = newLockType;
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_LOCK7, "OS;0x%X;TFileIo::Lock;rc=%d;newLockType=%d", (TUint)&dbFile, rc, newLockType));
return rc;
}
@@ -1015,22 +986,21 @@
*/
/* static */ int TFileIo::Unlock(sqlite3_file* aDbFile, int aLockType)
{
- __ASSERT_DEBUG(aLockType <= SQLITE_LOCK_SHARED, __SQLITEPANIC2(ESqliteOsPanicInvalidLock));
+ __ASSERT_DEBUG(aLockType <= SQLITE_LOCK_SHARED, User::Panic(KPanicCategory, EPanicInvalidLock));
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
TInt rc = SQLITE_OK;
TInt currLockType = dbFile.iLockType;
if(currLockType >= SQLITE_LOCK_EXCLUSIVE)
{
- __SQLITETRACE_OSEXPR(TInt err2 =) dbFile.iFileBuf.UnLock(SHARED_FIRST, SHARED_SIZE);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_UNLOCK1, "OS;0x%X;TFileIo::Unlock;iFileBuf.UnLock()=%d", (TUint)&dbFile, err2));
+ (void)dbFile.iFileBuf.UnLock(SHARED_FIRST, SHARED_SIZE);
if(aLockType == SQLITE_LOCK_SHARED)
{
TInt err = TFileIo::GetReadLock(dbFile);
if(err != KErrNone && err != KErrLocked)
{
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_UNLOCK2, "OS;0x%X;TFileIo::Unlock;TFileIo::GetReadLock() failed, err=%d", (TUint)&dbFile, err));
return ::Os2SqliteErr(err, SQLITE_IOERR_UNLOCK);
}
if(err == KErrLocked)
@@ -1042,22 +1012,18 @@
}
if(currLockType >= SQLITE_LOCK_RESERVED)
{
- __SQLITETRACE_OSEXPR(TInt err2 =) dbFile.iFileBuf.UnLock(RESERVED_BYTE, 1);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_UNLOCK3, "OS;0x%X;TFileIo::Unlock;iFileBuf.UnLock()-2=%d", (TUint)&dbFile, err2));
+ (void)dbFile.iFileBuf.UnLock(RESERVED_BYTE, 1);
}
if(aLockType == SQLITE_LOCK_NONE && currLockType >= SQLITE_LOCK_SHARED)
{
- __SQLITETRACE_OSEXPR(TInt err2 =) TFileIo::UnlockReadLock(dbFile);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_UNLOCK4, "OS;0x%X;TFileIo::Unlock;TFileIo::UnlockReadLock()=%d", (TUint)&dbFile, err2));
+ (void)TFileIo::UnlockReadLock(dbFile);
}
if(currLockType>= SQLITE_LOCK_PENDING)
{
- __SQLITETRACE_OSEXPR(TInt err2 =) dbFile.iFileBuf.UnLock(PENDING_BYTE, 1);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_UNLOCK5, "OS;0x%X;TFileIo::Unlock;iFileBuf.UnLock()-3=%d", (TUint)&dbFile, err2));
+ (void)dbFile.iFileBuf.UnLock(PENDING_BYTE, 1);
}
dbFile.iLockType = aLockType;
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_UNLOCK6, "OS;0x%X;TFileIo::Unlock;rc=%d;newLockType=%d", (TUint)&dbFile, rc, aLockType));
return rc;
}
@@ -1080,6 +1046,7 @@
*/
/* static */ int TFileIo::CheckReservedLock(sqlite3_file* aDbFile, int *aResOut)
{
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
TInt rc;
if(dbFile.iLockType >= SQLITE_LOCK_RESERVED)
@@ -1091,19 +1058,16 @@
TInt err = dbFile.iFileBuf.Lock(RESERVED_BYTE, 1);
if(err != KErrNone && err != KErrLocked)
{
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_CHECKRESERVEDLOCK1, "OS;0x%X;TFileIo::CheckReservedLock;iFileBuf.Lock(), err=%d", (TUint)&dbFile, err));
return ::Os2SqliteErr(err, SQLITE_IOERR_CHECKRESERVEDLOCK);
}
rc = (err == KErrNone);
if(rc) //non-zero rc means: the lock has been successful (there wasn't a reserved lock on this file)
{
- __SQLITETRACE_OSEXPR(TInt err2 =) dbFile.iFileBuf.UnLock(RESERVED_BYTE, 1);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_CHECKRESERVEDLOCK2, "OS;0x%X;TFileIo::CheckReservedLock;iFileBuf.UnLock()=%d", (TUint)&dbFile, err2));
+ (void)dbFile.iFileBuf.UnLock(RESERVED_BYTE, 1);
}
rc = !rc;
}
*aResOut = rc;
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_CHECKRESERVEDLOCK3, "OS;0x%X;TFileIo::CheckReservedLock;rc=%d", (TUint)&dbFile, rc));
return SQLITE_OK;
}
@@ -1128,7 +1092,9 @@
*/
/* static */ int TFileIo::FileControl(sqlite3_file* aDbFile, int aOp, void* aArg)
{
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileFileCtr, aOp, dbFile.iFullName));
TInt err = KErrNone;
switch(aOp)
{
@@ -1139,9 +1105,7 @@
err = KErrArgument;
break;
}
- TInt sqliteErr = err == KErrNone ? SQLITE_OK : SQLITE_ERROR;
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILECONTROL, "OS;0x%X;TFileIo::FileControl;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
- return sqliteErr;
+ return err == KErrNone ? SQLITE_OK : SQLITE_ERROR;
}
/**
@@ -1163,8 +1127,9 @@
*/
/* static */ int TFileIo::SectorSize(sqlite3_file* aDbFile)
{
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
- __ASSERT_DEBUG(dbFile.iSectorSize > 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+ __ASSERT_DEBUG(dbFile.iSectorSize > 0, User::Panic(KPanicCategory, EPanicInternalError));
if(dbFile.iSectorSize > 0)
{
return dbFile.iSectorSize;
@@ -1191,8 +1156,9 @@
*/
/* static */ int TFileIo::DeviceCharacteristics(sqlite3_file* aDbFile)
{
+ SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
- __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+ __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, User::Panic(KPanicCategory, EPanicInternalError));
if(dbFile.iDeviceCharacteristics >= 0)
{
return dbFile.iDeviceCharacteristics;
@@ -1219,9 +1185,7 @@
*/
/* static */ inline TInt TVfs::DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo)
{
- TInt err = aFs.VolumeIOParam(aDriveNo, aVolumeInfo);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOGETVOLUMEIOPARAMINFO, "OS;0;TVfs::DoGetVolumeIoParamInfo;aDriveNo=%d;err=%d", aDriveNo, err));
- return err;
+ return aFs.VolumeIOParam(aDriveNo, aVolumeInfo);
}
/**
@@ -1313,7 +1277,7 @@
sectorSize = aVolumeInfo.iBlockSize;
}
}
- __ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+ __ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, User::Panic(KPanicCategory, EPanicInternalError));
return sectorSize;
}
@@ -1342,8 +1306,8 @@
*/
/* static */ TInt TVfs::DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize)
{
- __ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
- __ASSERT_DEBUG(aDbFile.iSectorSize <= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+ __ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(aDbFile.iSectorSize <= 0, User::Panic(KPanicCategory, EPanicInternalError));
TInt driveNo;
TDriveInfo driveInfo;
TInt err = aDbFile.iFileBuf.Drive(driveNo, driveInfo);
@@ -1360,7 +1324,6 @@
aDbFile.iDeviceCharacteristics = TVfs::DoGetDeviceCharacteristics(driveInfo, volumeInfo);
aDbFile.iSectorSize = TVfs::DoGetSectorSize(driveInfo, volumeInfo);
aRecReadBufSize = volumeInfo.iRecReadBufSize;
- SQLITE_TRACE_OS(OstTraceExt5(TRACE_INTERNALS, TVFS_DOGETGETDEVICECHARACTERISTICSANDSECTORSIZE, "OS;0x%X;TVfs::DoGetDeviceCharacteristicsAndSectorSize;driveNo=%d;sectorSize=%d;devCharact=0x%X;readBufSize=%d", (TUint)&aDbFile, driveNo, aDbFile.iSectorSize, (TUint)aDbFile.iDeviceCharacteristics, volumeInfo.iRecReadBufSize));
return KErrNone;
}
@@ -1398,64 +1361,6 @@
/**
SQLite OS porting layer API.
-The behaviour of the RFile/RFile64::SetSize operation is not atomic for non-rugged drives.
-When RFile/RFile64::SetSize() is called 2 operations occurs:-
-
-1)The cluster chain of the file is updated.
-2)The new file size is added to the file cache.
-
-If a power loss occurs after a SetSize there is a chance that the cluster chain was updated
-but the new file size is not yet flushed to the file. This puts the file into an inconsistent state.
-This is most likely to occur in the journal file where the time between a SetSize and Flush can
-be long.
-
-For this reason this check is added when the file is opened to see if the end of the file can
-be read straight away, if an error is returned then it is assumed that the SetSize has not be
-completed previously. In this case the file is deleted and re-created.
-
-@param aDbFile A pointer to a TDbFile instance, that contains the file handle.
-@param aFname A string of 16-bit wide characters containing name of the file to be checked.
-@param aFmode The mode in which the file is opened. These mode are documented in TFileMode.
-
-@return KErrNone, The operation has completed succesfully;
- Note that other system-wide error codes may also be returned.
-@see TFileMode
-@see TVfs::Open()
-@see TDbFile
-*/
-/* static */ TInt TVfs::DoFileSizeCorruptionCheck(TDbFile& aDbFile, const TDesC& aFname, TInt aFmode)
- {
- const TInt KMinSize = 16;
- TInt64 size;
- TInt err = KErrNone ;
- TBuf8<KMinSize> buf;
-
- err = aDbFile.iFileBuf.Size(size);
- if (err != KErrNone)
- {
- return err;
- }
- TBool IsMinFileSize = (size >= KMinSize);
-
- if (IsMinFileSize)
- {
- err = aDbFile.iFileBuf.Read(size - KMinSize, buf);
- }
-
- if (err == KErrCorrupt || err == KErrEof || !IsMinFileSize)
- {
- aDbFile.iFileBuf.Close();
- __SQLITETRACE_OSEXPR(TInt err2 =) TStaticFs::Fs().Delete(aFname);
- SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK1, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;size=%lld;err=%d;deleteErr=%d", (TUint)&aDbFile, size, err, err2));
- err = aDbFile.iFileBuf.Create(TStaticFs::Fs(), aFname, aFmode);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK2, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;createErr=%d", (TUint)&aDbFile, err));
- }
- return err;
- }
-
-/**
-SQLite OS porting layer API.
-
Opens or creates a file which name is in the aFileName parameter.
If the function succeeds, the file handle and other related information will be stored in the place pointed by the
aDbFile parameter, a memory block of sizeof(TDbFile) size for which is allocated by the caller.
@@ -1483,21 +1388,20 @@
*/
/* static */ int TVfs::Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags)
{
+ SQLUTRACE_PROFILER(aVfs);
TFileName fname;
if(aFileName && !::ConvertToUnicode(aFileName, fname))
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_OPEN1, "OS;0;TVfs::Open;ConvertToUnicode() failed"));
return SQLITE_CANTOPEN;
}
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileOpen, aDbFile, &fname));
new (aDbFile) TDbFile;
TDbFile& dbFile = ::DbFile(aDbFile);
- SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TVFS_OPEN_ENTRY, "OS-Entry;0x%X;TVfs::Open;fname=%S;aFlags=0x%X", (TUint)&aDbFile, __SQLITEPRNSTR(fname), (TUint)aFlags));
if(aFileName && (aFlags & SQLITE_OPEN_DELETEONCLOSE))
{
dbFile.iFullName = fname.Alloc();
if(!dbFile.iFullName)
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_OPEN2, "OS;0;TVfs::Open;fname.Alloc() failed"));
return SQLITE_IOERR_NOMEM;
}
}
@@ -1523,31 +1427,22 @@
}
else
{
- err = KErrAccessDenied;//The error has to be set here, because, there is a case where none of the file create/open operations will be executed
- TInt prevErr = KErrNone;
+ err = KErrGeneral;//The error has to be set here, because, there is case where none of the file create/open operations will be executed
if(aFlags & SQLITE_OPEN_CREATE)
{
- prevErr = err = dbFile.iFileBuf.Create(TStaticFs::Fs(), fname, fmode);
+ err = dbFile.iFileBuf.Create(TStaticFs::Fs(), fname, fmode);
}
- if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
+ if(err != KErrNone && err != KErrNoMemory)
{
err = dbFile.iFileBuf.Open(TStaticFs::Fs(), fname, fmode);
- if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
- {
- err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
- }
}
- if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
+ if((err != KErrNone && err != KErrNoMemory) && (aFlags & SQLITE_OPEN_READWRITE))
{
aFlags &= ~SQLITE_OPEN_READWRITE;
aFlags |= SQLITE_OPEN_READONLY;
fmode &= ~EFileWrite;
err = dbFile.iFileBuf.Open(TStaticFs::Fs(), fname, fmode);
}
- if(err != KErrNone && prevErr == KErrAccessDenied)
- {
- err = KErrAccessDenied;
- }
}
if(err == KErrNone)
{
@@ -1558,11 +1453,6 @@
dbFile.iFileBuf.Close();
delete dbFile.iFullName;
dbFile.iFullName = NULL;
- if(!aFileName && fname.Length() > 0)
- {//temporary file, the error is not KErrNone. Then delete the file (after a successfull
- //temporary file creation there could be a failed memory allocation)
- (void)TStaticFs::Fs().Delete(fname);
- }
}
else
{
@@ -1575,9 +1465,7 @@
(void)dbFile.iFileBuf.SetReadAheadSize(dbFile.iSectorSize, recReadBufSize);
OpenCounter(+1);
}
- TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_CANTOPEN);
- SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TVFS_OPEN_EXIT, "OS-Exit;0x%X;TVfs::Open;outFlags=0x%X;err=%d;sqliteErr=%d", (TUint)&aDbFile, aOutFlags ? (TUint)*aOutFlags : 0, err, sqliteErr));
- return sqliteErr;
+ return ::Os2SqliteErr(err, SQLITE_CANTOPEN);
}
/**
@@ -1595,17 +1483,16 @@
*/
/* static */ int TVfs::Delete(sqlite3_vfs* aVfs, const char* aFileName, int /*aSyncDir*/)
{
+ SQLUTRACE_PROFILER(aVfs);
SimulateIOError(return SQLITE_IOERR_DELETE);
TFileName fname;
if(!::ConvertToUnicode(aFileName, fname))
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_DELETE1, "OS;0;TVfs::Delete;ConvertToUnicode() failed"));
return SQLITE_ERROR;
}
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname));
TInt err = TStaticFs::Fs().Delete(fname);
- TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_DELETE);
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DELETE2, "OS;0;TVfs::Delete;err=%d;sqliteErr=%d", err, sqliteErr));
- return sqliteErr;
+ return ::Os2SqliteErr(err, SQLITE_IOERR_DELETE);
}
/**
@@ -1624,24 +1511,22 @@
*/
/* static */ int TVfs::Access(sqlite3_vfs* aVfs, const char* aFileName, int aFlags, int* aResOut)
{
+ SQLUTRACE_PROFILER(aVfs);
TFileName fname;
if(!::ConvertToUnicode(aFileName, fname))
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS1, "OS;0;TVfs::Access;ConvertToUnicode() failed"));
return SQLITE_IOERR_ACCESS;
}
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_ACCESS_ENTRY, "OS-Entry;0;TVfs::Access;fname=%S;aFlags=0x%X", __SQLITEPRNSTR(fname), (TUint)aFlags));
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname));
TEntry entry;
TInt err = TStaticFs::Fs().Entry(fname, entry);
if(aFlags == SQLITE_ACCESS_EXISTS && err == KErrNotFound)
{
*aResOut = 0;
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS_EXIT1, "OS-Exit;0;TVfs::Access;Exists-NoFound"));
return SQLITE_OK;
}
if(err != KErrNone)
{
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT2, "OS-Exit;0;TVfs::Access;err=%d", err));
return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR_ACCESS;
}
*aResOut = 0;
@@ -1659,7 +1544,6 @@
default:
break;
}
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT3, "OS-Exit;0;TVfs::Access;aResOut=%d", *aResOut));
return SQLITE_OK;
}
@@ -1691,19 +1575,18 @@
*/
/* static */ int TVfs::FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf)
{
+ SQLUTRACE_PROFILER(aVfs);
if(!aRelative) //NULL argument
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME1, "OS;0;TVfs::FullPathName;err=SQLITE_ERROR"));
return SQLITE_ERROR;
}
//Convert the received file name to UTF16
TBuf<KMaxFileName + 1> fname;
if(!::ConvertToUnicode(aRelative, fname))
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT1, "OS-Exit;0;TVfs::FullPathName;ConvertToUnicode() failed"));
return SQLITE_ERROR;
}
- SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_FULLPATHNAME_ENTRY, "OS-Entry;0;TVfs::FullPathName;fname=%S;aBufLen=%d", __SQLITEPRNSTR(fname), aBufLen));
+ SYMBIAN_TRACE_SQLITE_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname));
//Search if the file name begins with ".\" - current directory
if(fname.Find(KCwd) == 0)
{
@@ -1714,7 +1597,6 @@
TInt err = TStaticFs::Fs().SessionPath(defaultPath);
if(err != KErrNone)
{
- SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT4, "OS-Exit;0;TVfs::FullPathName;SessionPath() failed, err=%d", err));
return SQLITE_ERROR;
}
TParse parse;
@@ -1722,10 +1604,8 @@
TPtr8 dest8(reinterpret_cast <TUint8*> (aBuf), aBufLen);
if(!::ConvertFromUnicode(parse.FullName(), dest8))
{
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT2, "OS-Exit;0;TVfs::FullPathName;ConvertFromUnicode() failed"));
return SQLITE_ERROR;
}
- SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT3, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_OK"));
return SQLITE_OK;
}
@@ -1741,6 +1621,7 @@
*/
/* static */ int TVfs::Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf)
{
+ SQLUTRACE_PROFILER(aVfs);
const TInt KRandIterations = aBufLen / sizeof(int);
for(TInt i=0;i<KRandIterations;++i)
{
@@ -1761,6 +1642,7 @@
*/
/* static */ int TVfs::Sleep(sqlite3_vfs* aVfs, int aMicrosec)
{
+ SQLUTRACE_PROFILER(aVfs);
User::AfterHighRes(TTimeIntervalMicroSeconds32(aMicrosec));
return aMicrosec;
}
@@ -1778,6 +1660,7 @@
*/
/* static */ int TVfs::CurrentTime(sqlite3_vfs* aVfs, double* aNow)
{
+ SQLUTRACE_PROFILER(aVfs);
TTime now;
now.UniversalTime();
TDateTime date = now.DateTime();
@@ -1817,6 +1700,7 @@
*/
/* static */int TVfs::GetLastError(sqlite3_vfs* aVfs, int /*aBufLen*/, char* /*aBuf*/)
{
+ SQLUTRACE_PROFILER(aVfs);
return 0;
}