diff -r 26645d81f48d -r cc28652e0254 persistentstorage/sqlite3api/OsLayer/os_symbian_mt.cpp --- 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 #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 (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 (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 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 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 (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