MCL/sf/os/persistentdata: comparison persistentstorage/sql/OsLayer/os

equal deleted inserted replaced

-:28839de615b4
+:26645d81f48d
 }
 #include "os_common.h"
 #include "SqliteSymbian.h"
 #include "FileBuf64.h"
 #include <e32math.h>
-#include "UTraceSql.h"
 #ifdef _SQLPROFILER
 #include <hal.h>
 #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
 						{
 						TPtrC8 fn8(iOptional);
 						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\r\n"),
+					RDebug::Print(_L("[SQL-OS]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬%c¬%S¬%d¬%d¬%ld¬%d¬%ld¬%ld¬%ld¬%S\n"),
 															//[SQL-OS]
 															//Handle
 															//Time from start, microseconds
 															//Subtype
 															//IPC sequence counter
 TInt FastCounterFrequency()
 	{
 	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;
 	}
 TInt sqlite3SymbianProfilerStart(TInt aCounterType)
 	{
 	}
 #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   //////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /**
 COsLayerData singleton class manages a single SQLite OS layer copy of the following data:
 	static int FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf);
 	static int Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf);
 	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);
 	static TInt DoGetDeviceCharacteristics(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo);
 	static TInt DoGetSectorSize(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo);
 @panic Sqlite 16 In _DEBUG mode - the COsLayerData instance has been created already.
 */
 /* 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();
 		if(err != KErrNone)
 			{
 			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;
 	}
 /**
 Destroys the COsLayerData instance.
 */
 /* static */ inline void COsLayerData::Destroy()
 	{
 	delete COsLayerData::iOsLayerData;
 	COsLayerData::iOsLayerData = NULL;
+	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_DESTROY, "OS;0;COsLayerData::Destroy"));
 	}
 /**
 Returns a reference to the single COsLayerData instance.
 @panic Sqlite 1 In _DEBUG mode if the COsLayerData instance is NULL.
 */
 /* static */ inline COsLayerData& COsLayerData::Instance()
 	{
-	__ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, User::Panic(KPanicCategory, EPanicNullOsLayerDataPtr));
+	__ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, __SQLITEPANIC2(ESqliteOsPanicNullOsLayerDataPtr));
 	return *COsLayerData::iOsLayerData;
 	}
 /**
 Sets the last OS error code data member. The stored OS error code data member will be set only if it is
 @panic Sqlite 13 In _DEBUG mode - aMsg is NULL.
 */
 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;
 	}
 Note: No SQLite functions should be called inside the destructor, because SQLite is already shutdown-ed!
 */
 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();
 	}
 /**
 	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;
 	}
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////     Symbian OS specific functions (called by the SQL server)        ///////////////////////////////////
 	if(sqliteErr != SQLITE_OK)
 		{
 		osErr = sqliteErr == SQLITE_NOMEM ? KErrNoMemory : KErrGeneral;
 		COsLayerData::Destroy();
 		}
+	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3SYMBIANLIBINIT, "OS;0;sqlite3SymbianLibInit;osErr=%d", osErr));
 	return osErr;
 	}
 /**
 This function must be called once after finishing working with sqlite.
 */
 void sqlite3SymbianLibFinalize(void)
 	{
 	(void)sqlite3_shutdown();
 	COsLayerData::Destroy();
+	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, SQLITE3SYMBIANLIBFINALIZE, "OS;0;sqlite3SymbianLibFinalize"));
 	}
 /**
 This function is part of Symbian OS specific SQLITE API.
 	{
 	if(aFileName)
 		{
 		wchar_t* dest = reinterpret_cast <wchar_t*> (const_cast <TUint16*> (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())
 			{
 			aFileNameDestBuf.SetLength(len);
 			return ETrue;
 static TBool ConvertFromUnicode(const TDesC& aFileName, TDes8& aFileNameDestBuf)
 	{
 	char* dest = reinterpret_cast <char*> (const_cast <TUint8*> (aFileNameDestBuf.Ptr()));
 	const wchar_t* src = reinterpret_cast <const wchar_t*> (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())
 		{
 		aFileNameDestBuf.SetLength(len);
 		return ETrue;
 @panic Sqlite 12 In _DEBUG mode - the extracted RMessage2 pointer is NULL.
 */
 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)
 		{
 		//Extract from aDbFileName string RMessage2 object's address
 		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 <const RMessage2*> (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.
 				TBool readOnly = aDbFileName[fhStartPos + KFhRoPos] > '0';
 				COsLayerData::Instance().StoreFhData(msg, readOnly);
 	{
 #ifdef _SQLPROFILER
 	iIsJournal = EFalse;
 #endif
 	pMethods = 0;
+	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TDBFILE_TDBFILE, "OS;0x%X;TDbFile::TDbFile", (TUint)this));
 	}
 /**
 Casts the passed sqlite3_file pointer to a reference to the derived class - TDbFile&.
 All sqlite3_file pointers passed to TFileIo methods are actually pointers to TDbFile instances.
 @internalComponent
 */
 static inline TDbFile& DbFile(sqlite3_file* aDbFile)
 	{
-	__ASSERT_DEBUG(aDbFile != 0, User::Panic(KPanicCategory, EPanicNullDbFilePtr));
+	__ASSERT_DEBUG(aDbFile != 0, __SQLITEPANIC2(ESqliteOsPanicNullDbFilePtr));
 	return *(static_cast <TDbFile*> (aDbFile));
 	}
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////       TFileIo class definition    ///////////////////////////////////////////////////////////////////////
 @see TDbFile
 */
 /* 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;
 	}
 /**
 SQLite OS porting layer API.
 @see COsLayerData::SetOsErrorCode()
 @see TDbFile
 */
 /* 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;
+	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_READ);
-	switch(err)
+	if(cnt != aAmt && (sqliteErr == SQLITE_OK || sqliteErr == SQLITE_IOERR_SHORT_READ))
 		{
-		case KErrNone:
+		Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
-			sqliteErr = SQLITE_OK;
+		err = KErrEof;
-			if(cnt != aAmt)
+		sqliteErr = SQLITE_IOERR_SHORT_READ;
-				{
-				Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
-				sqliteErr = SQLITE_IOERR_SHORT_READ;
-				err = KErrEof;
-				}
-			break;
-		case KErrEof:
-			Mem::FillZ(static_cast <TUint8*> (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;
 	}
 //Creates a temporary file in "\temp" subdirectory of osLayerData.iSysPrivDir directory.
 //If the function fails, the temp file will be closed and deleted,
 @see COsLayerData::SetOsErrorCode()
 @see TDbFile
 */
 /* 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.
 	    err = TFileIo::DoCreateTempFile(dbFile);
 	    }
 	if(err != KErrNone)
 	    {
 COsLayerData::Instance().SetOsErrorCode(err);
-return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_FULL;
+		return ::Os2SqliteErr(err, SQLITE_FULL);
 	    }
+	err = KErrAccessDenied;
+	if(!dbFile.iReadOnly)
+		{
+		TPtrC8 ptr((const TUint8*)aData, aAmt);
+		err = dbFile.iFileBuf.Write(aOffset, ptr);
+		}
+	COsLayerData::Instance().SetOsErrorCode(err);
-__OS_CALL(EOsFileWrite, 0, 0);
+	const TInt KFreePageCountOffset = 36;//hard-coded constant. SQLite does not offer anything - a constant or #define.
-__COUNTER_INCR(TheSqlSrvProfilerFileWrite);
+	//The checks in the "if" bellow do:
-__OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0);
+	// - "err == KErrNone" - check the free page count only after a successful "write";
-err = KErrAccessDenied;
+	// - "aOffset == 0"    - check the free page count only if the write operation affects the system page (at aOffset = 0);
-if(!dbFile.iReadOnly)
+	// - "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
-TPtrC8 ptr((const TUint8*)aData, aAmt);
+	//						 by this write operation);
-err = dbFile.iFileBuf.Write(aOffset, ptr);
+	// - "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())
-COsLayerData::Instance().SetOsErrorCode(err);
+		{
+		const TUint8* ptr = static_cast <const TUint8*> (aData) + KFreePageCountOffset;
-const TInt KFreePageCountOffset = 36;//hard-coded constant. SQLite does not offer anything - a constant or #define.
+		TInt freePageCount = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
-//The checks in the "if" bellow do:
+		dbFile.iFreePageCallback.CheckAndCallback(freePageCount);
-// - "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
+	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_FULL);
-//						 is more than the offset of the free page counter (othewrise the free page counter is not affected
+	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_EXIT, "OS-Exit;0x%X;TFileIo::Write;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
-//						 by this write operation);
+	return sqliteErr;
-// - "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 <const TUint8*> (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);
 	}
 /**
 SQLite OS porting layer API.
 @see COsLayerData::SetOsErrorCode()
 @see TDbFile
 */
 /* 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);
 	if(dbFile.iReadOnly)
 		{
 		return SQLITE_IOERR;
 		}
 	__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;
 	}
 /**
 SQLite OS porting layer API.
 @see COsLayerData::SetOsErrorCode()
 @see TDbFile
 */
 /* 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);
 	if(dbFile.iReadOnly)
 		{
 		return SQLITE_IOERR;
 		}
 	__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;
 	}
 /**
 SQLite OS porting layer API.
 @see COsLayerData::SetOsErrorCode()
 @see TDbFile
 */
 /* 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)
+	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 SQLITE_OK;
+	return sqliteErr;
-		}
-	return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR;
 	}
 /**
 SQLite OS porting layer API.
 @see TDbFile
 */
 /* 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);
 	//If there is already a lock of this type or more restrictive on the database file, do nothing.
 	if(dbFile.iLockType >= aLockType)
 @see TDbFile
 */
 /* 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);
 	dbFile.iLockType = aLockType;
 	return SQLITE_OK;
 @see TDbFile
 */
 /* 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);
 	*aResOut = dbFile.iLockType >= SQLITE_LOCK_RESERVED ? 1 : 0;
 	return SQLITE_OK;
 @see TDbFile
 */
 /* 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;
 	switch(aOp)
 		{
 		default:
 			err = KErrArgument;
 			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;
 	}
 /**
 SQLite OS porting layer API.
 @see TDbFile
 @see TVfs::Open()
 */
 /* 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;
 		}
 	return SQLITE_DEFAULT_SECTOR_SIZE;
 @see TDbFile
 @see TVfs::Open()
 */
 /* 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;
 		}
 	return 0;
 @see TVfs::Open()
 */
 /* 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;
 	}
 /**
 Retrieves and returns in a bit set the device characteristics.
 		if(aVolumeInfo.iBlockSize > SQLITE_DEFAULT_SECTOR_SIZE && (aVolumeInfo.iBlockSize & (aVolumeInfo.iBlockSize - 1)) == 0)
 			{
 			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;
 	}
 /**
 Retrieves in a bit set the device characteristics of the device of the file referred by the aDbFile parameter.
 @see TFileIo::DeviceCharacteristics()
 @see TFileIo::SectorSize()
 */
 /* static */ TInt TVfs::DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize)
 	{
-	__ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, User::Panic(KPanicCategory, EPanicInternalError));
+	__ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
-	__ASSERT_DEBUG(aDbFile.iSectorSize <= 0, User::Panic(KPanicCategory, EPanicInternalError));
+	__ASSERT_DEBUG(aDbFile.iSectorSize <= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
 	TInt driveNo;
 	TDriveInfo driveInfo;
 	__FS_CALL(EFsOpFileDrive, 0);
 	TInt err = aDbFile.iFileBuf.Drive(driveNo, driveInfo);
 	if(err != KErrNone)
 		return err;
 		}
 	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;
 	}
 /**
 SQLite OS porting layer API.
 if (err == KErrCorrupt || err == KErrEof || !IsMinFileSize)
 {
 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;
 }
 /**
 @see COsLayerData::SetOsErrorCode()
 @see TDbFile
 */
 /* 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);
-__OS_CALL(EOsVfsOpen, 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);
-__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);
+	COsLayerData& osLayerData = COsLayerData::Instance();
+	new (aDbFile) TDbFile;
-COsLayerData& osLayerData = COsLayerData::Instance();
+	TDbFile& dbFile = ::DbFile(aDbFile);
-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;
-}
+	}
-SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileOpen, aDbFile, &fname));
+	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));
-fhStrType = ::FhStringProps(aFileName);
+	TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr;
-TInt err = KErrNone;
+	TInt err = KErrNone;
-TInt recReadBufSize = -1;
+	if(fhStrType == EFhMainDbStr)
-if(fhStrType == EFhMainDbStr)
+		{//Main db file, open from handle
-{//Main db file, open from handle
+		const RMessage2* msg;
-const RMessage2* msg;
+		TBool readOnly;
-TBool readOnly;
+		osLayerData.RetrieveAndResetFhData(msg, readOnly);
-osLayerData.RetrieveAndResetFhData(msg, readOnly);
+		err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral;
-err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral;
+		}
-}
+	else
-else
+		{
-{
+		if(fhStrType == EFhStr)
-if(fhStrType == EFhStr)
+			{//Not the main db file. Remove invalid characters in the file name
-{//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
-::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used
+			}
-}
+		TInt fmode = EFileRead;
-TInt fmode = EFileRead;
+		if(aFlags & SQLITE_OPEN_READWRITE)
-if(aFlags & SQLITE_OPEN_READWRITE)
+			{
-{
+			fmode |= EFileWrite;
-fmode |= EFileWrite;
+			}
-}
+		if(aFlags & SQLITE_OPEN_EXCLUSIVE)
-if(aFlags & SQLITE_OPEN_EXCLUSIVE)
+			{
-{
+			fmode |= EFileShareExclusive;
-fmode |= EFileShareExclusive;
+			}
-}
+		if(aFlags & SQLITE_OPEN_DELETEONCLOSE)
-err = KErrAccessDenied;
+			{
-TInt prevErr = KErrNone;
+			fmode |= EDeleteOnClose;
-if(aFlags & SQLITE_OPEN_DELETEONCLOSE)
+			}
-{
+		err = KErrAccessDenied;
-fmode |= EDeleteOnClose;
+		TInt prevErr = KErrNone;
-}
+		if(aFlags & SQLITE_OPEN_CREATE)
-if(aFlags & SQLITE_OPEN_CREATE)
+			{
-{
+			__FS_CALL(EFsOpFileCreate, 0);
-__FS_CALL(EFsOpFileCreate, 0);
+			prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);
-prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);
+			}
-}
+		if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
-if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
+			{
-{
+			__FS_CALL(EFsOpFileOpen, 0);
-__FS_CALL(EFsOpFileOpen, 0);
+			err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
-err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
+			if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
-if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
+				{
-{
+				err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
-err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
+				}
-}
+			}
-}
+		if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
-if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
+			{
-{
+			aFlags &= ~SQLITE_OPEN_READWRITE;
-aFlags &= ~SQLITE_OPEN_READWRITE;
+			aFlags |= SQLITE_OPEN_READONLY;
-aFlags |= SQLITE_OPEN_READONLY;
+			fmode &= ~EFileWrite;
-fmode &= ~EFileWrite;
+			__FS_CALL(EFsOpFileOpen, 0);
-__FS_CALL(EFsOpFileOpen, 0);
+			err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
-err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
+			}
-}
+		if(err != KErrNone && prevErr == KErrAccessDenied)
-if(err != KErrNone && prevErr == KErrAccessDenied)
+			{
-{
+			err = KErrAccessDenied;
-err = KErrAccessDenied;
+			}
-}
+		}
-}
+	TInt recReadBufSize = -1;
-if(err == KErrNone)
+	if(err == KErrNone)
-{
+		{
-err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize);
+		err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize);
-}
+		}
 	osLayerData.SetOsErrorCode(err);
 	if(err != KErrNone)
 		{
 		__FS_CALL(EFsOpFileClose, 0);
 		dbFile.iFileBuf.Close();
 		(void)dbFile.iFileBuf.SetReadAheadSize(dbFile.iSectorSize, recReadBufSize);
 		}
 #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;
 	}
 /**
 SQLite OS porting layer API.
 @see COsLayerData::SetOsErrorCode()
 */
 /* 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();
 	TBuf<KMaxFileName + 1> fname;
 	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)
 		{
 		::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used
 		}
 	__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;
 	}
 /**
 SQLite OS porting layer API.
 @see COsLayerData::SetOsErrorCode()
 */
 /* 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();
 	TBuf<KMaxFileName + 1> fname;
 	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)
 		{
 		::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used
 		}
 	TInt err = osLayerData.iFs.Entry(fname, entry);
 	if(aFlags == SQLITE_ACCESS_EXISTS && err == KErrNotFound)
 		{
 		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;
 	switch(aFlags)
 		{
 			break;
 		default:
 			break;
 		}
 	osLayerData.SetOsErrorCode(KErrNone);
+	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT3, "OS-Exit;0;TVfs::Access;aResOut=%d", *aResOut));
 	return SQLITE_OK;
 	}
 /**
 SQLite OS porting layer API.
 @return SQLITE_ERROR, The aRelative parameter is NULL or cannot be converted to UTF16;
 		SQLITE_OK The operation has completed successfully.
 */
 /* 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();
 	osLayerData.StoreFhData(NULL, EFalse);
 	//Convert the received file name to UTF16
 	TBuf<KMaxFileName + 1> 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;
 	TFhStrType strType = ::FhStringProps(aRelative);//Detect string type - it may not be a real file name
 	if(strType == EFhMainDbStr)
 		}
 	TPtr8 dest8(reinterpret_cast <TUint8*> (aBuf), aBufLen);
 	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;
 	}
 /**
 SQLite OS porting layer API.
 @return The length of the used part of the output buffer.
 */
 /* 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();
 	const TInt KRandIterations = aBufLen / sizeof(int);
 	for(TInt i=0;i<KRandIterations;++i)
 @return The aMicrosec value.
 */
 /* 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));
 	return aMicrosec;
 	}
 @return 0.
 */
 /* 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;
 	now.UniversalTime();
 	TDateTime date = now.DateTime();
 @return 0.
 */
 /* 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;
 	}
 /**
 SQLite OS porting layer API.
 Memory allocation routine.
+EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning
 @internalComponent
 */
-extern "C" void* sqlite3SymbianMalloc(size_t aSize)
+extern "C" EXPORT_C void* sqlite3SymbianMalloc(size_t aSize)
 	{
 	__MEM_CALL(EMemOpAlloc, aSize, 0);
 	return Allocator().Alloc(aSize);
 	}
 /**
 SQLite OS porting layer API.
 Memory reallocation routine.
+EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning
 @internalComponent
 */
-extern "C" void* sqlite3SymbianRealloc(void* aPtr, size_t aSize)
+extern "C" EXPORT_C void* sqlite3SymbianRealloc(void* aPtr, size_t aSize)
 	{
 #ifdef _SQLPROFILER
 	TInt size = Allocator().AllocLen(aPtr);
 	__MEM_CALL(EMemOpRealloc, aSize, size);
 #endif
 /**
 SQLite OS porting layer API.
 Memory free routine.
+EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning
 @internalComponent
 */
-extern "C" void sqlite3SymbianFree(void* aPtr)
+extern "C" EXPORT_C void sqlite3SymbianFree(void* aPtr)
 	{
 #ifdef _SQLPROFILER
 	TInt size = Allocator().AllocLen(aPtr);
 	__MEM_CALL(EMemOpFree, size, 0);
 #endif

branch	RCL_3
changeset 23	26645d81f48d
parent 21	28839de615b4
child 24	cc28652e0254