diff -r 0d6db0a14001 -r 3256212fc81f persistentstorage/sql/OsLayer/os_symbian.cpp --- a/persistentstorage/sql/OsLayer/os_symbian.cpp Tue Jul 06 16:18:30 2010 +0300 +++ b/persistentstorage/sql/OsLayer/os_symbian.cpp Wed Aug 18 11:30:17 2010 +0300 @@ -40,49 +40,23 @@ #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"); //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. @@ -485,7 +459,7 @@ { TInt ticksPerSec = 0; TInt err = HAL::Get(HAL::EFastCounterFrequency, ticksPerSec); - __ASSERT_ALWAYS(err == KErrNone, User::Panic(KPanicCategory, EPanicFastCounterFreq)); + __ASSERT_ALWAYS(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicFastCounterFreq)); return ticksPerSec; } @@ -679,6 +653,47 @@ #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 ////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -720,7 +735,6 @@ public: RFs iFs; //File session instance. TFileName iSysPrivDir;//":\" + process's private data path. Initialized in sqlite3SymbianFsOpen(). - //Used for storing sqlite temporary files. TInt64 iSeed; private: @@ -767,12 +781,13 @@ { inline TDbFile(); RFileBuf64 iFileBuf; - HBufC* iFullName; //Used for the "delete file" operation (RFile64::FullName() makes an IPC call!) TInt iLockType; //File lock type TBool iReadOnly; //True if the file is read-only TInt iSectorSize; //Media sector-size TInt iDeviceCharacteristics; TSqlFreePageCallback iFreePageCallback; + TBool iIsFileCreated; //If the file to be created is a temp file, + //it will not be created until the data is to be written to. #ifdef _SQLPROFILER TBool iIsJournal; #endif @@ -814,6 +829,8 @@ static int FileControl(sqlite3_file* aDbFile, int aOp, void* aArg); static int SectorSize(sqlite3_file* aDbFile); static int DeviceCharacteristics(sqlite3_file* aDbFile); +private: + static TInt DoCreateTempFile(TDbFile& aDbFile); }; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -842,12 +859,12 @@ 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); private: static TInt DoOpenFromHandle(TDbFile& aDbFile, const RMessage2& aMsg, TBool aReadOnly); static inline TInt DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo); static TInt DoGetDeviceCharacteristics(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo); static TInt DoGetSectorSize(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo); - static TInt DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize); static TInt DoFileSizeCorruptionCheck(TDbFile& aDbFile, const TDesC& aFname, TInt aFmode); }; @@ -952,12 +969,14 @@ */ /* static */ TInt COsLayerData::Create() { - __ASSERT_DEBUG(!COsLayerData::iOsLayerData, User::Panic(KPanicCategory, EPanicOsLayerDataExists)); + SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_ENTRY, "OS-Entry;0;COsLayerData::Create")); + __ASSERT_DEBUG(!COsLayerData::iOsLayerData, __SQLITEPANIC2(ESqliteOsPanicOsLayerDataExists)); 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(); @@ -965,9 +984,11 @@ { 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; } @@ -978,6 +999,7 @@ { delete COsLayerData::iOsLayerData; COsLayerData::iOsLayerData = NULL; + SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_DESTROY, "OS;0;COsLayerData::Destroy")); } /** @@ -987,7 +1009,7 @@ */ /* static */ inline COsLayerData& COsLayerData::Instance() { - __ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, User::Panic(KPanicCategory, EPanicNullOsLayerDataPtr)); + __ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, __SQLITEPANIC2(ESqliteOsPanicNullOsLayerDataPtr)); return *COsLayerData::iOsLayerData; } @@ -1061,7 +1083,7 @@ */ inline void COsLayerData::RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly) { - __ASSERT_DEBUG(iMessage != NULL, User::Panic(KPanicCategory, EPanicInvalidFhData)); + __ASSERT_DEBUG(iMessage != NULL, __SQLITEPANIC(ESqliteOsPanicInvalidFhData)); aMsg = iMessage; aReadOnly = iReadOnly; iMessage = NULL; @@ -1087,6 +1109,7 @@ */ 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(); } @@ -1136,6 +1159,14 @@ TParse parse; (void)parse.Set(driveName, &privateDir, 0);//this call can't fail iSysPrivDir.Copy(parse.DriveAndPath()); + //Create the temp files directory + (void)parse.AddDir(KTempFileDir);//this call can't fail + err = iFs.MkDir(parse.DriveAndPath()); + if(err != KErrNone && err != KErrAlreadyExists) + { + 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; } @@ -1185,6 +1216,7 @@ osErr = sqliteErr == SQLITE_NOMEM ? KErrNoMemory : KErrGeneral; COsLayerData::Destroy(); } + SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3SYMBIANLIBINIT, "OS;0;sqlite3SymbianLibInit;osErr=%d", osErr)); return osErr; } @@ -1204,6 +1236,7 @@ { (void)sqlite3_shutdown(); COsLayerData::Destroy(); + SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, SQLITE3SYMBIANLIBFINALIZE, "OS;0;sqlite3SymbianLibFinalize")); } /** @@ -1240,7 +1273,7 @@ { wchar_t* dest = reinterpret_cast (const_cast (aFileNameDestBuf.Ptr())); TInt len = mbstowcs(dest, aFileName, aFileNameDestBuf.MaxLength()); - __ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError)); + __ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); //If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small. if(len < aFileNameDestBuf.MaxLength()) { @@ -1269,7 +1302,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, User::Panic(KPanicCategory, EPanicInternalError)); + __ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); //If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small. if(len < aFileNameDestBuf.MaxLength()) { @@ -1411,7 +1444,7 @@ static void FhExtractAndStore(TDes& aDbFileName) { TInt fhStartPos = aDbFileName.Locate(TChar(KFhSeparator)); - __ASSERT_DEBUG(fhStartPos == KFhMarkPos, User::Panic(KPanicCategory, EPanicInvalidFhStr)); + __ASSERT_DEBUG(fhStartPos == KFhMarkPos, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr)); //If this file name string contains file handles if(fhStartPos == KFhMarkPos) { @@ -1419,12 +1452,12 @@ TLex lex(aDbFileName.Mid(fhStartPos + KFhMsgAddrPos, KFhMsgAddrLen)); TUint32 addr; TInt err = lex.Val(addr, EHex); - __ASSERT_DEBUG(err == KErrNone, User::Panic(KPanicCategory, EPanicInvalidFhStr)); + __ASSERT_DEBUG(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr)); if(err == KErrNone) { //Cast the address to RMessage2 pointer. const RMessage2* msg = reinterpret_cast (addr); - __ASSERT_DEBUG(msg != NULL, User::Panic(KPanicCategory, EPanicInvalidFhStr)); + __ASSERT_DEBUG(msg != NULL, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr)); if(msg) { //Store the data from aDbFileName in the single COsLayerData instance. @@ -1446,16 +1479,17 @@ */ inline TDbFile::TDbFile() : iFileBuf(KFileBufSize), - iFullName(0), iLockType(SQLITE_LOCK_NONE), iReadOnly(EFalse), iSectorSize(0), - iDeviceCharacteristics(-1) + iDeviceCharacteristics(-1), + iIsFileCreated(ETrue) { #ifdef _SQLPROFILER iIsJournal = EFalse; #endif pMethods = 0; + SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TDBFILE_TDBFILE, "OS;0x%X;TDbFile::TDbFile", (TUint)this)); } /** @@ -1476,7 +1510,7 @@ */ static inline TDbFile& DbFile(sqlite3_file* aDbFile) { - __ASSERT_DEBUG(aDbFile != 0, User::Panic(KPanicCategory, EPanicNullDbFilePtr)); + __ASSERT_DEBUG(aDbFile != 0, __SQLITEPANIC2(ESqliteOsPanicNullDbFilePtr)); return *(static_cast (aDbFile)); } @@ -1488,7 +1522,6 @@ SQLite OS porting layer API. Closes the file referred by aDbFile parameter. -If aDbFile.iFullName data member is not NULL, then the file will be deleted. @param aDbFile A pointer to a TDbFile instance, than contains the file handle to be closed. @@ -1498,19 +1531,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(); - 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. - __FS_CALL(EFsOpFileDelete, 0); - (void)COsLayerData::Instance().iFs.Delete(*dbFile.iFullName); - delete dbFile.iFullName; - } return SQLITE_OK; } @@ -1538,41 +1564,63 @@ */ /* 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 = SQLITE_IOERR_READ; - switch(err) + TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_READ); + if(cnt != aAmt && (sqliteErr == SQLITE_OK || 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; + Mem::FillZ(static_cast (aBuf) + cnt, aAmt - cnt); + err = KErrEof; + sqliteErr = SQLITE_IOERR_SHORT_READ; } 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; } +//Creates a temporary file in "\temp" subdirectory of osLayerData.iSysPrivDir directory. +//If the function fails, the temp file will be closed and deleted, +//the related Symbian OS error will be returned to the caller. +/* static */TInt TFileIo::DoCreateTempFile(TDbFile& aDbFile) + { + COsLayerData& osLayerData = COsLayerData::Instance(); + //TParse2 is used in order to avoid the need of another TFileName stack based variable + class TParse2 : public TParse + { + public: + inline TFileName& FileName() + { + return static_cast (NameBuf()); + } + }; + TParse2 parse; + (void)parse.Set(osLayerData.iSysPrivDir, 0, 0);//this call can't fail + (void)parse.AddDir(KTempFileDir);//this call can't fail + __FS_CALL(EFsOpFileCreateTemp, 0); + TInt err = aDbFile.iFileBuf.Temp(osLayerData.iFs, parse.FullName(), parse.FileName(), EFileRead|EFileWrite|EDeleteOnClose); + if(err == KErrNone) + { + TInt recReadBufSize = -1; + err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(aDbFile, recReadBufSize); + if(err != KErrNone) + { + aDbFile.iFileBuf.Close();//With EDeleteOnClose flag set, the file will be deleted + } + else + { + (void)aDbFile.iFileBuf.SetReadAheadSize(aDbFile.iSectorSize, recReadBufSize); + aDbFile.iIsFileCreated = ETrue; + } + } + return err; + } + /** SQLite OS porting layer API. @@ -1583,6 +1631,8 @@ (TDbFile::iFreePageCallback) and the free pages count is above the defined value, then the callback will be called. +If the file to be written to is a temp file, which is not created yet, then the file will be created. + @param aDbFile A pointer to a TDbFile instance, that contains the file handle to be written to. @param aData The data to be written to the file. The buffer size must be at least aAmt bytes. @param aAmt The amount of data to be written to the file. @@ -1601,13 +1651,22 @@ */ /* 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 = KErrAccessDenied; + TInt err = KErrNone; + if(!dbFile.iIsFileCreated) + {//Create a temp file if it has not been created. + err = TFileIo::DoCreateTempFile(dbFile); + } + if(err != KErrNone) + { + COsLayerData::Instance().SetOsErrorCode(err); + return ::Os2SqliteErr(err, SQLITE_FULL); + } + err = KErrAccessDenied; if(!dbFile.iReadOnly) { TPtrC8 ptr((const TUint8*)aData, aAmt); @@ -1630,7 +1689,9 @@ dbFile.iFreePageCallback.CheckAndCallback(freePageCount); } - return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_FULL); + 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; } /** @@ -1655,9 +1716,8 @@ */ /* 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); @@ -1669,7 +1729,9 @@ __FS_CALL(EFsOpFileSetSize, 0); TInt err = dbFile.iFileBuf.SetSize(aLength); COsLayerData::Instance().SetOsErrorCode(err); - return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR); + 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; } /** @@ -1692,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); @@ -1705,7 +1767,9 @@ __FS_CALL(EFsOpFileSync, 0); TInt err = dbFile.iFileBuf.Flush(); COsLayerData::Instance().SetOsErrorCode(err); - return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR); + 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; } /** @@ -1728,18 +1792,16 @@ */ /* 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); - if(err == KErrNone) - { - return SQLITE_OK; - } - return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR; + 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; } /** @@ -1762,7 +1824,6 @@ */ /* 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); @@ -1795,7 +1856,6 @@ */ /* 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); @@ -1824,7 +1884,6 @@ */ /* 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); @@ -1859,9 +1918,8 @@ */ /* 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; @@ -1889,7 +1947,9 @@ break; } COsLayerData::Instance().SetOsErrorCode(err); - return err == KErrNone ? SQLITE_OK : SQLITE_ERROR; + 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; } /** @@ -1911,11 +1971,10 @@ */ /* 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, User::Panic(KPanicCategory, EPanicInternalError)); + __ASSERT_DEBUG(dbFile.iSectorSize > 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); if(dbFile.iSectorSize > 0) { return dbFile.iSectorSize; @@ -1942,11 +2001,10 @@ */ /* 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, User::Panic(KPanicCategory, EPanicInternalError)); + __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); if(dbFile.iDeviceCharacteristics >= 0) { return dbFile.iDeviceCharacteristics; @@ -2003,7 +2061,9 @@ /* static */ inline TInt TVfs::DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo) { __FS_CALL(EFsOpFsVolumeIoParam, 0); - return aFs.VolumeIOParam(aDriveNo, 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; } /** @@ -2091,7 +2151,7 @@ sectorSize = aVolumeInfo.iBlockSize; } } - __ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, User::Panic(KPanicCategory, EPanicInternalError)); + __ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); return sectorSize; } @@ -2120,8 +2180,8 @@ */ /* static */ TInt TVfs::DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize) { - __ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, User::Panic(KPanicCategory, EPanicInternalError)); - __ASSERT_DEBUG(aDbFile.iSectorSize <= 0, User::Panic(KPanicCategory, EPanicInternalError)); + __ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); + __ASSERT_DEBUG(aDbFile.iSectorSize <= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError)); TInt driveNo; TDriveInfo driveInfo; __FS_CALL(EFsOpFileDrive, 0); @@ -2139,6 +2199,7 @@ 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; } @@ -2194,8 +2255,10 @@ COsLayerData& osLayerData = COsLayerData::Instance(); aDbFile.iFileBuf.Close(); - (void) osLayerData.iFs.Delete(aFname); + __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)); 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; } @@ -2234,30 +2297,32 @@ */ /* static */ int TVfs::Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags) { - SQLUTRACE_PROFILER(aVfs); __OS_CALL(EOsVfsOpen, 0, 0); __OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName); COsLayerData& osLayerData = COsLayerData::Instance(); - TFileName fname; - if(aFileName && !::ConvertToUnicode(aFileName, fname)) - { - osLayerData.SetOsErrorCode(KErrBadName); - return SQLITE_CANTOPEN; - } - SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileOpen, aDbFile, &fname)); new (aDbFile) TDbFile; TDbFile& dbFile = ::DbFile(aDbFile); - TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr; - if(aFileName && (aFlags & SQLITE_OPEN_DELETEONCLOSE)) + 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; + if(!::ConvertToUnicode(aFileName, fname)) { - dbFile.iFullName = fname.Alloc(); - if(!dbFile.iFullName) - { - osLayerData.SetOsErrorCode(KErrNoMemory); - return SQLITE_IOERR_NOMEM; - } - } - TInt recReadBufSize = -1; + 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 @@ -2281,52 +2346,41 @@ { fmode |= EFileShareExclusive; } - if(!aFileName) + if(aFlags & SQLITE_OPEN_DELETEONCLOSE) + { + fmode |= EDeleteOnClose; + } + err = KErrAccessDenied; + TInt prevErr = KErrNone; + if(aFlags & SQLITE_OPEN_CREATE) { - __FS_CALL(EFsOpFileCreateTemp, 0); - err = dbFile.iFileBuf.Temp(osLayerData.iFs, osLayerData.iSysPrivDir, fname, fmode); - if(err == KErrNone) + __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)) { - dbFile.iFullName = fname.Alloc(); - if(!dbFile.iFullName) - { - err = KErrNoMemory; - } + err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode); } } - else + 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 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); @@ -2336,13 +2390,6 @@ { __FS_CALL(EFsOpFileClose, 0); 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)osLayerData.iFs.Delete(fname); - } } else { @@ -2360,7 +2407,9 @@ #ifdef _SQLPROFILER dbFile.iIsJournal = aFlags & KJournalFileTypeBitMask; #endif - return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_CANTOPEN); + 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; } /** @@ -2383,7 +2432,6 @@ */ /* 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(); @@ -2391,13 +2439,15 @@ if(!::ConvertToUnicode(aFileName, fname)) { osLayerData.SetOsErrorCode(KErrBadName); + SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_DELETE1, "OS;0;TVfs::Delete;err=KErrBadName")); return SQLITE_ERROR; } - SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname)); + SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE_ENTRY, "OS-Entry;0;TVfs::Delete;fname=%S", __SQLITEPRNSTR(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) @@ -2407,7 +2457,9 @@ __FS_CALL(EFsOpFileDelete, 0); TInt err = osLayerData.iFs.Delete(fname); osLayerData.SetOsErrorCode(err); - return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR_DELETE); + 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; } /** @@ -2431,7 +2483,6 @@ */ /* 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(); @@ -2439,9 +2490,10 @@ 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; } - SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname)); + SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_ACCESS_ENTRY, "OS-Entry;0;TVfs::Access;fname=%S;aFlags=0x%X", __SQLITEPRNSTR(fname), (TUint)aFlags)); TFhStrType fhStrType = ::FhStringProps(aFileName); if(fhStrType == EFhStr) { @@ -2454,11 +2506,13 @@ { 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; @@ -2477,6 +2531,7 @@ break; } osLayerData.SetOsErrorCode(KErrNone); + SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT3, "OS-Exit;0;TVfs::Access;aResOut=%d", *aResOut)); return SQLITE_OK; } @@ -2508,7 +2563,6 @@ */ /* 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(); @@ -2517,9 +2571,10 @@ TBuf fname; if(!::ConvertToUnicode(aRelative, fname)) { + SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME1, "OS;0;TVfs::FullPathName;err=SQLITE_ERROR")); return SQLITE_ERROR; } - SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname)); + SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_FULLPATHNAME_ENTRY, "OS-Entry;0;TVfs::FullPathName;fname=%S;aBufLen=%d", __SQLITEPRNSTR(fname), aBufLen)); //Zero-terminate the converted file name fname.Append(TChar(0)); TParse parse; @@ -2538,8 +2593,10 @@ 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; } @@ -2555,7 +2612,6 @@ */ /* 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(); @@ -2579,7 +2635,6 @@ */ /* 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)); @@ -2599,7 +2654,6 @@ */ /* 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; @@ -2635,7 +2689,6 @@ */ /* 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;