diff -r 26645d81f48d -r cc28652e0254 persistentstorage/sql/OsLayer/os_symbian.cpp --- a/persistentstorage/sql/OsLayer/os_symbian.cpp Tue Aug 31 16:57:14 2010 +0300 +++ b/persistentstorage/sql/OsLayer/os_symbian.cpp Wed Sep 01 12:39:58 2010 +0100 @@ -40,21 +40,50 @@ #include "SqliteSymbian.h" #include "FileBuf64.h" #include +#include "UTraceSql.h" #ifdef _SQLPROFILER #include #include "../INC/SqlResourceProfiler.h" #endif -#include "SqliteUtil.h" -#include "OstTraceDefinitions.h" -#ifdef OST_TRACE_COMPILER_IN_USE -#include "os_symbianTraces.h" -#endif -#include "SqliteTraceDef.h" ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/** +Panic category - used by asserts in this file (the OS porting layer). + +@see TPanicCodes + +@internalComponent +*/ +_LIT(KPanicCategory, "Sqlite"); + +/** +Panic codes - used by asserts in this file (the OS porting layer). + +@see KPanicCategory + +@internalComponent +*/ +enum TPanicCodes + { + EPanicNullOsLayerDataPtr = 1, + EPanicInvalidWAmount = 2, + EPanicOffset64bit = 3, + EPanicInvalidOpType =11, + EPanicInvalidFhStr =12, + EPanicInvalidFhData =13, + EPanicInvalidArg =14, + EPanicInvalidRAmount =15, + EPanicOsLayerDataExists =16, + EPanicInvalidDrive =17, + EPanicInvalidSectorSize =18, + EPanicInternalError =19, + EPanicNullDbFilePtr =20, + EPanicFastCounterFreq =21 + }; + //The SQLite temp files willl be created in this subdir _LIT(KTempFileDir, "temp"); @@ -395,7 +424,7 @@ fname.Copy(fn8); } // 0 1 2 3 4 5 6 7 8 9 10 - RDebug::Print(_L("[SQL-OS]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬%c¬%S¬%d¬%d¬%ld¬%d¬%ld¬%ld¬%ld¬%S\n"), + RDebug::Print(_L("[SQL-OS]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬%c¬%S¬%d¬%d¬%ld¬%d¬%ld¬%ld¬%ld¬%S\r\n"), //[SQL-OS] //Handle //Time from start, microseconds @@ -459,7 +488,7 @@ { TInt ticksPerSec = 0; TInt err = HAL::Get(HAL::EFastCounterFrequency, ticksPerSec); - __ASSERT_ALWAYS(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicFastCounterFreq)); + __ASSERT_ALWAYS(err == KErrNone, User::Panic(KPanicCategory, EPanicFastCounterFreq)); return ticksPerSec; } @@ -653,47 +682,6 @@ #endif//_SQLPROFILER /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/** -Os2SqliteErr() is called at the end of many of the interface functions of the OS porting layer (wherever it is appropriate - -TFileIo and TVfs interfaces). The purpose of this function is to identify the "out of memory" and "disk is full" errors -reported by the used Symbian OS APIs (aOsErr parameter) and report them to SQLite as SQLITE_FULL and SQLITE_NOMEM errors. -The KErrEof error (TFileIo::Read() can return KErrEof) is reported to SQLite as SQLITE_IOERR_SHORT_READ. The rest of failures -are reported as the error specified in aDefaultErr parameter. - -@param aOsErr Symbian OS error -@param aDefaultErr The default SQLite error that should be used if the aOsErr parameter is not one of: - KErrNone, KErrEof, KErrNoMemory, KErrDiskFull -@return SQLITE_OK, The OS porting layer function call has completed successfully, - SQLITE_IOERR_SHORT_READ, The amount of the data read is less than the requested amount, - SQLITE_IOERR_NOMEM, Out of memory, - SQLITE_FULL, The disk is full, - aDefaultErr, The rest of failures will be reported as aDefaultErr. -*/ -static TInt Os2SqliteErr(TInt aOsErr, TInt aDefaultErr) - { - switch(aOsErr) - { - case KErrNone: - return SQLITE_OK; - case KErrEof: - return SQLITE_IOERR_SHORT_READ; - case KErrNoMemory: - return SQLITE_IOERR_NOMEM; - case KErrDiskFull: - return SQLITE_FULL; - default: -#ifdef _DEBUG - RDebug::Print(_L("SQLite OS porting layer, Os2SqliteErr(), err=%d\n"), aOsErr); - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, OS2SQLITEERR, "OS;0;Os2SqliteErr;aOsErr=%d", aOsErr)); -#endif - break; - } - return aDefaultErr; - } - - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////// COsLayerData class declaration ////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -859,7 +847,8 @@ static int Sleep(sqlite3_vfs* aVfs, int aMicrosec); static int CurrentTime(sqlite3_vfs* aVfs, double* aNow); static int GetLastError(sqlite3_vfs *sVfs, int aBufLen, char* aBuf); - static TInt DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize); + static TInt DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize); + private: static TInt DoOpenFromHandle(TDbFile& aDbFile, const RMessage2& aMsg, TBool aReadOnly); static inline TInt DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo); @@ -969,14 +958,12 @@ */ /* static */ TInt COsLayerData::Create() { - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_ENTRY, "OS-Entry;0;COsLayerData::Create")); - __ASSERT_DEBUG(!COsLayerData::iOsLayerData, __SQLITEPANIC2(ESqliteOsPanicOsLayerDataExists)); + __ASSERT_DEBUG(!COsLayerData::iOsLayerData, User::Panic(KPanicCategory, EPanicOsLayerDataExists)); if(!COsLayerData::iOsLayerData) { COsLayerData::iOsLayerData = new COsLayerData; if(!COsLayerData::iOsLayerData) { - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT1, "OS-Exit;0;COsLayerData::Create;err=KErrNoMemory")); return KErrNoMemory; } TInt err = COsLayerData::iOsLayerData->DoCreate(); @@ -984,11 +971,9 @@ { delete COsLayerData::iOsLayerData; COsLayerData::iOsLayerData = NULL; - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT2, "OS-Exit;0;COsLayerData::Create;err=%d", err)); return err; } } - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT3, "OS-Exit;0;COsLayerData::Create;err=KErrNone")); return KErrNone; } @@ -999,7 +984,6 @@ { delete COsLayerData::iOsLayerData; COsLayerData::iOsLayerData = NULL; - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_DESTROY, "OS;0;COsLayerData::Destroy")); } /** @@ -1009,7 +993,7 @@ */ /* static */ inline COsLayerData& COsLayerData::Instance() { - __ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, __SQLITEPANIC2(ESqliteOsPanicNullOsLayerDataPtr)); + __ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, User::Panic(KPanicCategory, EPanicNullOsLayerDataPtr)); return *COsLayerData::iOsLayerData; } @@ -1083,7 +1067,7 @@ */ inline void COsLayerData::RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly) { - __ASSERT_DEBUG(iMessage != NULL, __SQLITEPANIC(ESqliteOsPanicInvalidFhData)); + __ASSERT_DEBUG(iMessage != NULL, User::Panic(KPanicCategory, EPanicInvalidFhData)); aMsg = iMessage; aReadOnly = iReadOnly; iMessage = NULL; @@ -1109,7 +1093,6 @@ */ inline COsLayerData::~COsLayerData() { - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, COSLAYERDATA_COSLAYERDATA2, "OS;0;COsLayerData::~COsLayerData;iFs.Handle()=0x%X", (TUint)iFs.Handle())); __FS_CALL(EFsOpFsClose, 0); iFs.Close(); } @@ -1166,7 +1149,6 @@ { return err; } - SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, COSLAYERDATA_DOCREATE, "OS;0;COsLayerData::DoCreate;iFs.Handle()=0x%X;sysDrive=%d;iSysPrivDir=%S", (TUint)iFs.Handle(), sysDrive, __SQLITEPRNSTR(iSysPrivDir))); return KErrNone; } @@ -1216,7 +1198,6 @@ osErr = sqliteErr == SQLITE_NOMEM ? KErrNoMemory : KErrGeneral; COsLayerData::Destroy(); } - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3SYMBIANLIBINIT, "OS;0;sqlite3SymbianLibInit;osErr=%d", osErr)); return osErr; } @@ -1236,7 +1217,6 @@ { (void)sqlite3_shutdown(); COsLayerData::Destroy(); - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, SQLITE3SYMBIANLIBFINALIZE, "OS;0;sqlite3SymbianLibFinalize")); } /** @@ -1273,7 +1253,7 @@ { wchar_t* dest = reinterpret_cast (const_cast (aFileNameDestBuf.Ptr())); TInt len = mbstowcs(dest, aFileName, aFileNameDestBuf.MaxLength()); - __ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); + __ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError)); //If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small. if(len < aFileNameDestBuf.MaxLength()) { @@ -1302,7 +1282,7 @@ char* dest = reinterpret_cast (const_cast (aFileNameDestBuf.Ptr())); const wchar_t* src = reinterpret_cast (aFileName.Ptr()); TInt len = wcstombs(dest, src, aFileNameDestBuf.MaxLength()); - __ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); + __ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError)); //If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small. if(len < aFileNameDestBuf.MaxLength()) { @@ -1444,7 +1424,7 @@ static void FhExtractAndStore(TDes& aDbFileName) { TInt fhStartPos = aDbFileName.Locate(TChar(KFhSeparator)); - __ASSERT_DEBUG(fhStartPos == KFhMarkPos, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr)); + __ASSERT_DEBUG(fhStartPos == KFhMarkPos, User::Panic(KPanicCategory, EPanicInvalidFhStr)); //If this file name string contains file handles if(fhStartPos == KFhMarkPos) { @@ -1452,12 +1432,12 @@ TLex lex(aDbFileName.Mid(fhStartPos + KFhMsgAddrPos, KFhMsgAddrLen)); TUint32 addr; TInt err = lex.Val(addr, EHex); - __ASSERT_DEBUG(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr)); + __ASSERT_DEBUG(err == KErrNone, User::Panic(KPanicCategory, EPanicInvalidFhStr)); if(err == KErrNone) { //Cast the address to RMessage2 pointer. const RMessage2* msg = reinterpret_cast (addr); - __ASSERT_DEBUG(msg != NULL, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr)); + __ASSERT_DEBUG(msg != NULL, User::Panic(KPanicCategory, EPanicInvalidFhStr)); if(msg) { //Store the data from aDbFileName in the single COsLayerData instance. @@ -1489,7 +1469,6 @@ iIsJournal = EFalse; #endif pMethods = 0; - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TDBFILE_TDBFILE, "OS;0x%X;TDbFile::TDbFile", (TUint)this)); } /** @@ -1510,7 +1489,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)); } @@ -1531,12 +1510,12 @@ */ /* 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)); __OS_CALL(EOsFileClose, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileClose], ::OsCallProfile(dbFile.iIsJournal, EOsFileClose), 0, 0, aDbFile, 0); __FS_CALL(EFsOpFileClose, 0); - dbFile.iFileBuf.Close(); + dbFile.iFileBuf.Close(); return SQLITE_OK; } @@ -1564,23 +1543,38 @@ */ /* static */ int TFileIo::Read(sqlite3_file* aDbFile, void* aBuf, int aAmt, sqlite3_int64 aOffset) { + SQLUTRACE_PROFILER(aDbFile); + SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileRead, aAmt, aOffset)); 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)); __OS_CALL(EOsFileRead, 0, 0); __COUNTER_INCR(TheSqlSrvProfilerFileRead); __OSTIME_COUNTER(TheOsCallTicks[EOsFileRead], ::OsCallProfile(dbFile.iIsJournal, EOsFileRead), aOffset, aAmt, aDbFile, 0); TPtr8 ptr((TUint8*)aBuf, 0, aAmt); TInt err = dbFile.iFileBuf.Read(aOffset, ptr); TInt cnt = ptr.Length(); - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_READ); - if(cnt != aAmt && (sqliteErr == SQLITE_OK || sqliteErr == SQLITE_IOERR_SHORT_READ)) + TInt sqliteErr = SQLITE_IOERR_READ; + switch(err) { - Mem::FillZ(static_cast (aBuf) + cnt, aAmt - cnt); - err = KErrEof; - sqliteErr = SQLITE_IOERR_SHORT_READ; + case KErrNone: + sqliteErr = SQLITE_OK; + if(cnt != aAmt) + { + Mem::FillZ(static_cast (aBuf) + cnt, aAmt - cnt); + sqliteErr = SQLITE_IOERR_SHORT_READ; + err = KErrEof; + } + break; + case KErrEof: + Mem::FillZ(static_cast (aBuf) + cnt, aAmt - cnt); + sqliteErr = SQLITE_IOERR_SHORT_READ; + break; + case KErrNoMemory: + sqliteErr = SQLITE_IOERR_NOMEM; + break; + default: + break; } COsLayerData::Instance().SetOsErrorCode(err); - 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; } @@ -1659,11 +1653,9 @@ */ /* static */ int TFileIo::Write(sqlite3_file* aDbFile, const void* aData, int aAmt, sqlite3_int64 aOffset) { + SQLUTRACE_PROFILER(aDbFile); + SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileWrite, aAmt, aOffset)); 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)); - __OS_CALL(EOsFileWrite, 0, 0); - __COUNTER_INCR(TheSqlSrvProfilerFileWrite); - __OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0); TInt err = KErrNone; if(!dbFile.iIsFileCreated) {//Create a temp file if it has not been created. @@ -1672,34 +1664,35 @@ if(err != KErrNone) { COsLayerData::Instance().SetOsErrorCode(err); - return ::Os2SqliteErr(err, SQLITE_FULL); + return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_FULL; } - err = KErrAccessDenied; - if(!dbFile.iReadOnly) - { - TPtrC8 ptr((const TUint8*)aData, aAmt); - err = dbFile.iFileBuf.Write(aOffset, ptr); - } - COsLayerData::Instance().SetOsErrorCode(err); - const TInt KFreePageCountOffset = 36;//hard-coded constant. SQLite does not offer anything - a constant or #define. - //The checks in the "if" bellow do: - // - "err == KErrNone" - check the free page count only after a successful "write"; - // - "aOffset == 0" - check the free page count only if the write operation affects the system page (at aOffset = 0); - // - "aAmt >= (KFreePageCountOffset + sizeof(int))" - check the free page count only if the amount of bytes to be written - // is more than the offset of the free page counter (othewrise the free page counter is not affected - // by this write operation); - // - "dbFile.iFreePageCallback.IsValid()" - check the free page count only if there is a valid callback; - if(err == KErrNone && aOffset == 0 && aAmt >= (KFreePageCountOffset + sizeof(int)) && dbFile.iFreePageCallback.IsValid()) - { - const TUint8* ptr = static_cast (aData) + KFreePageCountOffset; - TInt freePageCount = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3]; - dbFile.iFreePageCallback.CheckAndCallback(freePageCount); - } - - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_FULL); - 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; + __OS_CALL(EOsFileWrite, 0, 0); + __COUNTER_INCR(TheSqlSrvProfilerFileWrite); + __OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0); + err = KErrAccessDenied; + if(!dbFile.iReadOnly) + { + TPtrC8 ptr((const TUint8*)aData, aAmt); + err = dbFile.iFileBuf.Write(aOffset, ptr); + } + COsLayerData::Instance().SetOsErrorCode(err); + + const TInt KFreePageCountOffset = 36;//hard-coded constant. SQLite does not offer anything - a constant or #define. + //The checks in the "if" bellow do: + // - "err == KErrNone" - check the free page count only after a successful "write"; + // - "aOffset == 0" - check the free page count only if the write operation affects the system page (at aOffset = 0); + // - "aAmt >= (KFreePageCountOffset + sizeof(int))" - check the free page count only if the amount of bytes to be written + // is more than the offset of the free page counter (othewrise the free page counter is not affected + // by this write operation); + // - "dbFile.iFreePageCallback.IsValid()" - check the free page count only if there is a valid callback; + if(err == KErrNone && aOffset == 0 && aAmt >= (KFreePageCountOffset + sizeof(int)) && dbFile.iFreePageCallback.IsValid()) + { + const TUint8* ptr = static_cast (aData) + KFreePageCountOffset; + TInt freePageCount = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3]; + dbFile.iFreePageCallback.CheckAndCallback(freePageCount); + } + return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_FULL); } /** @@ -1724,8 +1717,9 @@ */ /* static */ int TFileIo::Truncate(sqlite3_file* aDbFile, sqlite3_int64 aLength) { + SQLUTRACE_PROFILER(aDbFile); + SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileTruncate, aLength)); TDbFile& dbFile = ::DbFile(aDbFile); - SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_TRUNCATE_ENTRY, "OS-Entry;0x%X;TFileIo::Truncate;aLength=%lld", (TUint)&dbFile, aLength)); __OS_CALL(EOsFileTruncate, 0, 0); __COUNTER_INCR(TheSqlSrvProfilerFileSetSize); __OSTIME_COUNTER(TheOsCallTicks[EOsFileTruncate], ::OsCallProfile(dbFile.iIsJournal, EOsFileTruncate), aLength, 0, aDbFile, 0); @@ -1737,9 +1731,7 @@ __FS_CALL(EFsOpFileSetSize, 0); TInt err = dbFile.iFileBuf.SetSize(aLength); COsLayerData::Instance().SetOsErrorCode(err); - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR); - 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 err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR); } /** @@ -1762,8 +1754,8 @@ */ /* static */int TFileIo::Sync(sqlite3_file* aDbFile, int /* aFlags */) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_SYNC_ENTRY, "OS-Entry;0x%X;TFileIo::Sync", (TUint)&dbFile)); __OS_CALL(EOsFileSync, 0, 0); __COUNTER_INCR(TheSqlSrvProfilerFileSync); __OSTIME_COUNTER(TheOsCallTicks[EOsFileSync], ::OsCallProfile(dbFile.iIsJournal, EOsFileSync), 0, 0, aDbFile, 0); @@ -1775,9 +1767,7 @@ __FS_CALL(EFsOpFileSync, 0); TInt err = dbFile.iFileBuf.Flush(); COsLayerData::Instance().SetOsErrorCode(err); - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR); - 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 err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR); } /** @@ -1800,16 +1790,18 @@ */ /* static */ int TFileIo::FileSize(sqlite3_file* aDbFile, sqlite3_int64* aSize) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_FILESIZE_ENTRY, "OS-Entry;0x%X;TFileIo::FileSize", (TUint)&dbFile)); __OS_CALL(EOsFileFileSize, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileFileSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileSize), 0, 0, aDbFile, 0); __FS_CALL(EFsOpFileSize, 0); TInt err = dbFile.iFileBuf.Size(*aSize); COsLayerData::Instance().SetOsErrorCode(err); - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR); - SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILESIZE_EXIT, "OS-Exit;0x%X;TFileIo::FileSize;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr)); - return sqliteErr; + if(err == KErrNone) + { + return SQLITE_OK; + } + return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR; } /** @@ -1832,6 +1824,7 @@ */ /* static */ int TFileIo::Lock(sqlite3_file* aDbFile, int aLockType) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); __OS_CALL(EOsFileLock, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileLock), aLockType, 0, aDbFile, 0); @@ -1864,6 +1857,7 @@ */ /* static */ int TFileIo::Unlock(sqlite3_file* aDbFile, int aLockType) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); __OS_CALL(EOsFileUnlock, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileUnlock], ::OsCallProfile(dbFile.iIsJournal, EOsFileUnlock), aLockType, 0, aDbFile, 0); @@ -1892,6 +1886,7 @@ */ /* static */ int TFileIo::CheckReservedLock(sqlite3_file* aDbFile, int *aResOut) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); __OS_CALL(EOsFileCheckReservedLock, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileCheckReservedLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileCheckReservedLock), 0, 0, aDbFile, 0); @@ -1926,8 +1921,9 @@ */ /* static */ int TFileIo::FileControl(sqlite3_file* aDbFile, int aOp, void* aArg) { + SQLUTRACE_PROFILER(aDbFile); + SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileFileCtr, aOp)); TDbFile& dbFile = ::DbFile(aDbFile); - SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_FILECONTROL_ENTRY, "OS-Entry;0x%X;TFileIo::FileControl;aOp=%d", (TUint)&dbFile, aOp)); __OS_CALL(EOsFileFileControl, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileFileControl], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileControl), aOp, 0, aDbFile, 0); TInt err = KErrNone; @@ -1955,9 +1951,7 @@ break; } COsLayerData::Instance().SetOsErrorCode(err); - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_ERROR); - SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILECONTROL_EXIT, "OS-Exit;0x%X;TFileIo::FileControl;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr)); - return sqliteErr; + return err == KErrNone ? SQLITE_OK : SQLITE_ERROR; } /** @@ -1979,10 +1973,11 @@ */ /* static */ int TFileIo::SectorSize(sqlite3_file* aDbFile) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); __OS_CALL(EOsFileSectorSize, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileSectorSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileSectorSize), 0, 0, aDbFile, 0); - __ASSERT_DEBUG(dbFile.iSectorSize > 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); + __ASSERT_DEBUG(dbFile.iSectorSize > 0, User::Panic(KPanicCategory, EPanicInternalError)); if(dbFile.iSectorSize > 0) { return dbFile.iSectorSize; @@ -2009,10 +2004,11 @@ */ /* static */ int TFileIo::DeviceCharacteristics(sqlite3_file* aDbFile) { + SQLUTRACE_PROFILER(aDbFile); TDbFile& dbFile = ::DbFile(aDbFile); __OS_CALL(EOsFileDeviceCharacteristics, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsFileDeviceCharacteristics], ::OsCallProfile(dbFile.iIsJournal, EOsFileDeviceCharacteristics), 0, 0, aDbFile, 0); - __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); + __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, User::Panic(KPanicCategory, EPanicInternalError)); if(dbFile.iDeviceCharacteristics >= 0) { return dbFile.iDeviceCharacteristics; @@ -2069,9 +2065,7 @@ /* static */ inline TInt TVfs::DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo) { __FS_CALL(EFsOpFsVolumeIoParam, 0); - 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); } /** @@ -2159,7 +2153,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; } @@ -2188,8 +2182,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; __FS_CALL(EFsOpFileDrive, 0); @@ -2207,7 +2201,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; } @@ -2263,10 +2256,8 @@ COsLayerData& osLayerData = COsLayerData::Instance(); aDbFile.iFileBuf.Close(); - __SQLITETRACE_OSEXPR(TInt err2 =) osLayerData.iFs.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)); + (void) osLayerData.iFs.Delete(aFname); err = aDbFile.iFileBuf.Create(osLayerData.iFs, aFname, aFmode); - SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK2, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;createErr=%d", (TUint)&aDbFile, err)); } return err; } @@ -2304,95 +2295,101 @@ @see TDbFile */ /* static */ int TVfs::Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags) - { - __OS_CALL(EOsVfsOpen, 0, 0); - __OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName); - COsLayerData& osLayerData = COsLayerData::Instance(); - new (aDbFile) TDbFile; - TDbFile& dbFile = ::DbFile(aDbFile); + { + SQLUTRACE_PROFILER(aVfs); + __OS_CALL(EOsVfsOpen, 0, 0); + __OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName); + + COsLayerData& osLayerData = COsLayerData::Instance(); + TFhStrType fhStrType = ENotFhStr; + new (aDbFile) TDbFile; + TDbFile& dbFile = ::DbFile(aDbFile); + if(!aFileName) { //It is to create and open a temp file if aFileName is NULL. In this case, //we will defer the file creation util it is needed. + dbFile.pMethods = &TheFileIoApi; dbFile.iIsFileCreated = EFalse; if(aOutFlags) { *aOutFlags = SQLITE_OPEN_READWRITE; } - osLayerData.SetOsErrorCode(KErrNone); return SQLITE_OK; } - TFileName fname; + + TFileName fname; if(!::ConvertToUnicode(aFileName, fname)) - { + { osLayerData.SetOsErrorCode(KErrBadName); return SQLITE_CANTOPEN; - } - 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)); - TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr; - TInt err = KErrNone; - if(fhStrType == EFhMainDbStr) - {//Main db file, open from handle - const RMessage2* msg; - TBool readOnly; - osLayerData.RetrieveAndResetFhData(msg, readOnly); - err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral; - } - else - { - if(fhStrType == EFhStr) - {//Not the main db file. Remove invalid characters in the file name - ::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used - } - TInt fmode = EFileRead; - if(aFlags & SQLITE_OPEN_READWRITE) - { - fmode |= EFileWrite; - } - if(aFlags & SQLITE_OPEN_EXCLUSIVE) - { - fmode |= EFileShareExclusive; - } - if(aFlags & SQLITE_OPEN_DELETEONCLOSE) - { - fmode |= EDeleteOnClose; - } - err = KErrAccessDenied; - TInt prevErr = KErrNone; - if(aFlags & SQLITE_OPEN_CREATE) - { - __FS_CALL(EFsOpFileCreate, 0); - prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode); - } - if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) - { - __FS_CALL(EFsOpFileOpen, 0); - err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode); - - if(err == KErrNone && (aFlags & KJournalFileTypeBitMask)) - { - err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode); - } - } - if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE)) - { - aFlags &= ~SQLITE_OPEN_READWRITE; - aFlags |= SQLITE_OPEN_READONLY; - fmode &= ~EFileWrite; - __FS_CALL(EFsOpFileOpen, 0); - err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode); - } - if(err != KErrNone && prevErr == KErrAccessDenied) - { - err = KErrAccessDenied; - } - } - TInt recReadBufSize = -1; - if(err == KErrNone) - { - err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize); - } + } + SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileOpen, aDbFile, &fname)); + fhStrType = ::FhStringProps(aFileName); + TInt err = KErrNone; + TInt recReadBufSize = -1; + if(fhStrType == EFhMainDbStr) + {//Main db file, open from handle + const RMessage2* msg; + TBool readOnly; + osLayerData.RetrieveAndResetFhData(msg, readOnly); + err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral; + } + else + { + if(fhStrType == EFhStr) + {//Not the main db file. Remove invalid characters in the file name + ::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used + } + TInt fmode = EFileRead; + if(aFlags & SQLITE_OPEN_READWRITE) + { + fmode |= EFileWrite; + } + if(aFlags & SQLITE_OPEN_EXCLUSIVE) + { + fmode |= EFileShareExclusive; + } + err = KErrAccessDenied; + TInt prevErr = KErrNone; + if(aFlags & SQLITE_OPEN_DELETEONCLOSE) + { + fmode |= EDeleteOnClose; + } + if(aFlags & SQLITE_OPEN_CREATE) + { + __FS_CALL(EFsOpFileCreate, 0); + prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode); + } + if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) + { + __FS_CALL(EFsOpFileOpen, 0); + err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode); + + if(err == KErrNone && (aFlags & KJournalFileTypeBitMask)) + { + err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode); + } + } + if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE)) + { + aFlags &= ~SQLITE_OPEN_READWRITE; + aFlags |= SQLITE_OPEN_READONLY; + fmode &= ~EFileWrite; + __FS_CALL(EFsOpFileOpen, 0); + err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode); + } + if(err != KErrNone && prevErr == KErrAccessDenied) + { + err = KErrAccessDenied; + } + } + if(err == KErrNone) + { + err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize); + } + osLayerData.SetOsErrorCode(err); if(err != KErrNone) { @@ -2415,9 +2412,7 @@ #ifdef _SQLPROFILER dbFile.iIsJournal = aFlags & KJournalFileTypeBitMask; #endif - 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 err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_CANTOPEN); } /** @@ -2440,6 +2435,7 @@ */ /* static */ int TVfs::Delete(sqlite3_vfs* aVfs, const char* aFileName, int /*aSyncDir*/) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsDelete, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsDelete], ::OsCallProfile(EFalse, EOsVfsDelete), 0, 0, 0, aFileName); COsLayerData& osLayerData = COsLayerData::Instance(); @@ -2447,15 +2443,13 @@ if(!::ConvertToUnicode(aFileName, fname)) { osLayerData.SetOsErrorCode(KErrBadName); - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_DELETE1, "OS;0;TVfs::Delete;err=KErrBadName")); return SQLITE_ERROR; } - SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE_ENTRY, "OS-Entry;0;TVfs::Delete;fname=%S", __SQLITEPRNSTR(fname))); + SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname)); TFhStrType fhStrType = FhStringProps(aFileName); if(fhStrType == EFhMainDbStr) {//Deleting files not in your own private data cage - not allowed! osLayerData.SetOsErrorCode(KErrPermissionDenied); - SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE2, "OS;0;TVfs::Delete;err=KErrPermissionDenied;fname=%S", __SQLITEPRNSTR(fname))); return SQLITE_ERROR; } if(fhStrType == EFhStr) @@ -2465,9 +2459,7 @@ __FS_CALL(EFsOpFileDelete, 0); TInt err = osLayerData.iFs.Delete(fname); osLayerData.SetOsErrorCode(err); - TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_DELETE); - SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DELETE_EXIT, "OS-Exit;0;TVfs::Delete;err=%d;sqliteErr=%d", err, sqliteErr)); - return sqliteErr; + return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR_DELETE); } /** @@ -2491,6 +2483,7 @@ */ /* static */ int TVfs::Access(sqlite3_vfs* aVfs, const char* aFileName, int aFlags, int* aResOut) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsAccess, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsAccess], ::OsCallProfile(EFalse, EOsVfsAccess), aFlags, 0, 0, aFileName); COsLayerData& osLayerData = COsLayerData::Instance(); @@ -2498,10 +2491,9 @@ if(!::ConvertToUnicode(aFileName, fname)) { osLayerData.SetOsErrorCode(KErrGeneral); - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS1, "OS;0;TVfs::Access;err=KErrGeneral")); 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_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname)); TFhStrType fhStrType = ::FhStringProps(aFileName); if(fhStrType == EFhStr) { @@ -2514,13 +2506,11 @@ { osLayerData.SetOsErrorCode(KErrNone); *aResOut = 0; - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS_EXIT1, "OS-Exit;0;TVfs::Access;Exists-NoFound")); return SQLITE_OK; } if(err != KErrNone) { osLayerData.SetOsErrorCode(err); - 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; @@ -2539,7 +2529,6 @@ break; } osLayerData.SetOsErrorCode(KErrNone); - SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT3, "OS-Exit;0;TVfs::Access;aResOut=%d", *aResOut)); return SQLITE_OK; } @@ -2571,6 +2560,7 @@ */ /* static */ int TVfs::FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsFullPathName, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsFullPathName], ::OsCallProfile(EFalse, EOsVfsFullPathName), aBufLen, 0, 0, aRelative); COsLayerData& osLayerData = COsLayerData::Instance(); @@ -2579,10 +2569,9 @@ TBuf fname; if(!::ConvertToUnicode(aRelative, fname)) { - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME1, "OS;0;TVfs::FullPathName;err=SQLITE_ERROR")); 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_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname)); //Zero-terminate the converted file name fname.Append(TChar(0)); TParse parse; @@ -2601,10 +2590,8 @@ if(!::ConvertFromUnicode(parse.FullName(), dest8)) {//Zero the stored fh data, because it has been initialized by the FhExtractAndStore(fname) call (couple of lines above) osLayerData.StoreFhData(NULL, EFalse); - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT1, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_ERROR")); return SQLITE_ERROR; } - SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT2, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_OK")); return SQLITE_OK; } @@ -2620,6 +2607,7 @@ */ /* static */ int TVfs::Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsRandomness, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsRandomness], ::OsCallProfile(EFalse, EOsVfsRandomness), aBufLen, 0, 0, 0); COsLayerData& osLayerData = COsLayerData::Instance(); @@ -2643,6 +2631,7 @@ */ /* static */ int TVfs::Sleep(sqlite3_vfs* aVfs, int aMicrosec) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsSleep, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsSleep], ::OsCallProfile(EFalse, EOsVfsSleep), aMicrosec, 0, 0, 0); User::AfterHighRes(TTimeIntervalMicroSeconds32(aMicrosec)); @@ -2662,6 +2651,7 @@ */ /* static */ int TVfs::CurrentTime(sqlite3_vfs* aVfs, double* aNow) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsCurrentTime, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsCurrentTime], ::OsCallProfile(EFalse, EOsVfsCurrentTime), 0, 0, 0, 0); TTime now; @@ -2697,6 +2687,7 @@ */ /* static */int TVfs::GetLastError(sqlite3_vfs* aVfs, int /*aBufLen*/, char* /*aBuf*/) { + SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsGetLastError, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsGetLastError], ::OsCallProfile(EFalse, EOsVfsGetLastError), 0, 0, 0, 0); return 0; @@ -2711,11 +2702,9 @@ Memory allocation routine. -EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning - @internalComponent */ -extern "C" EXPORT_C void* sqlite3SymbianMalloc(size_t aSize) +extern "C" void* sqlite3SymbianMalloc(size_t aSize) { __MEM_CALL(EMemOpAlloc, aSize, 0); return Allocator().Alloc(aSize); @@ -2726,11 +2715,9 @@ Memory reallocation routine. -EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning - @internalComponent */ -extern "C" EXPORT_C void* sqlite3SymbianRealloc(void* aPtr, size_t aSize) +extern "C" void* sqlite3SymbianRealloc(void* aPtr, size_t aSize) { #ifdef _SQLPROFILER TInt size = Allocator().AllocLen(aPtr); @@ -2744,11 +2731,9 @@ Memory free routine. -EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning - @internalComponent */ -extern "C" EXPORT_C void sqlite3SymbianFree(void* aPtr) +extern "C" void sqlite3SymbianFree(void* aPtr) { #ifdef _SQLPROFILER TInt size = Allocator().AllocLen(aPtr);