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

equal deleted inserted replaced

-:26645d81f48d
+:cc28652e0254
 }
 #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\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
 															//Subtype
 															//IPC sequence counter
 TInt FastCounterFrequency()
 	{
 	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;
 	}
 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()
 	{
-	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_ENTRY, "OS-Entry;0;COsLayerData::Create"));
+	__ASSERT_DEBUG(!COsLayerData::iOsLayerData, User::Panic(KPanicCategory, EPanicOsLayerDataExists));
-	__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, __SQLITEPANIC2(ESqliteOsPanicNullOsLayerDataPtr));
+	__ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, User::Panic(KPanicCategory, EPanicNullOsLayerDataPtr));
 	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, __SQLITEPANIC(ESqliteOsPanicInvalidFhData));
+	__ASSERT_DEBUG(iMessage != NULL, User::Panic(KPanicCategory, EPanicInvalidFhData));
 	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, __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())
 			{
 			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, __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())
 		{
 		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, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));
+	__ASSERT_DEBUG(fhStartPos == KFhMarkPos, User::Panic(KPanicCategory, EPanicInvalidFhStr));
 	//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, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));
+		__ASSERT_DEBUG(err == KErrNone, User::Panic(KPanicCategory, EPanicInvalidFhStr));
 		if(err == KErrNone)
 			{
 			//Cast the address to RMessage2 pointer.
 			const RMessage2* msg = reinterpret_cast <const RMessage2*> (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.
 				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, __SQLITEPANIC2(ESqliteOsPanicNullDbFilePtr));
+	__ASSERT_DEBUG(aDbFile != 0, User::Panic(KPanicCategory, EPanicNullDbFilePtr));
 	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 = ::Os2SqliteErr(err, SQLITE_IOERR_READ);
+	TInt sqliteErr = SQLITE_IOERR_READ;
-	if(cnt != aAmt && (sqliteErr == SQLITE_OK || sqliteErr == SQLITE_IOERR_SHORT_READ))
+	switch(err)
 		{
-		Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
+		case KErrNone:
-		err = KErrEof;
+			sqliteErr = SQLITE_OK;
-		sqliteErr = SQLITE_IOERR_SHORT_READ;
+			if(cnt != aAmt)
+				{
+				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 ::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.
+__OS_CALL(EOsFileWrite, 0, 0);
-	//The checks in the "if" bellow do:
+__COUNTER_INCR(TheSqlSrvProfilerFileWrite);
-	// - "err == KErrNone" - check the free page count only after a successful "write";
+__OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0);
-	// - "aOffset == 0"    - check the free page count only if the write operation affects the system page (at aOffset = 0);
+err = KErrAccessDenied;
-	// - "aAmt >= (KFreePageCountOffset + sizeof(int))" - check the free page count only if the amount of bytes to be written
+if(!dbFile.iReadOnly)
-	//						 is more than the offset of the free page counter (othewrise the free page counter is not affected
+{
-	//						 by this write operation);
+TPtrC8 ptr((const TUint8*)aData, aAmt);
-	// - "dbFile.iFreePageCallback.IsValid()" - check the free page count only if there is a valid callback;
+err = dbFile.iFileBuf.Write(aOffset, ptr);
-	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;
-		TInt freePageCount = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+const TInt KFreePageCountOffset = 36;//hard-coded constant. SQLite does not offer anything - a constant or #define.
-		dbFile.iFreePageCallback.CheckAndCallback(freePageCount);
+//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);
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_FULL);
+// - "aAmt >= (KFreePageCountOffset + sizeof(int))" - check the free page count only if the amount of bytes to be written
-	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_EXIT, "OS-Exit;0x%X;TFileIo::Write;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
+//						 is more than the offset of the free page counter (othewrise the free page counter is not affected
-	return sqliteErr;
+//						 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 <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);
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);
+	return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : 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);
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);
+	return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : 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);
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);
+	if(err == KErrNone)
-	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;
+		return SQLITE_OK;
+		}
+	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);
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_ERROR);
+	return err == KErrNone ? SQLITE_OK : 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, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+	__ASSERT_DEBUG(dbFile.iSectorSize > 0, User::Panic(KPanicCategory, EPanicInternalError));
 	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, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+	__ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, User::Panic(KPanicCategory, EPanicInternalError));
 	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);
-	TInt err = aFs.VolumeIOParam(aDriveNo, aVolumeInfo);
+	return 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, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+	__ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, User::Panic(KPanicCategory, EPanicInternalError));
 	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, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+	__ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, User::Panic(KPanicCategory, EPanicInternalError));
-	__ASSERT_DEBUG(aDbFile.iSectorSize <= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+	__ASSERT_DEBUG(aDbFile.iSectorSize <= 0, User::Panic(KPanicCategory, EPanicInternalError));
 	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();
-__SQLITETRACE_OSEXPR(TInt err2 =) osLayerData.iFs.Delete(aFname);
+(void) 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)
 	{
-	__OS_CALL(EOsVfsOpen, 0, 0);
+SQLUTRACE_PROFILER(aVfs);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);
+__OS_CALL(EOsVfsOpen, 0, 0);
-	COsLayerData& osLayerData = COsLayerData::Instance();
+__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);
-	new (aDbFile) TDbFile;
-	TDbFile& dbFile = ::DbFile(aDbFile);
+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));
+SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileOpen, aDbFile, &fname));
-	TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr;
+fhStrType = ::FhStringProps(aFileName);
-	TInt err = KErrNone;
+TInt err = KErrNone;
-	if(fhStrType == EFhMainDbStr)
+TInt recReadBufSize = -1;
-		{//Main db file, open from handle
+if(fhStrType == EFhMainDbStr)
-		const RMessage2* msg;
+{//Main db file, open from handle
-		TBool readOnly;
+const RMessage2* msg;
-		osLayerData.RetrieveAndResetFhData(msg, readOnly);
+TBool readOnly;
-		err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral;
+osLayerData.RetrieveAndResetFhData(msg, readOnly);
-		}
+err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral;
-	else
+}
-		{
+else
-		if(fhStrType == EFhStr)
+{
-			{//Not the main db file. Remove invalid characters in the file name
+if(fhStrType == EFhStr)
-			::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used
+{//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)
+TInt fmode = EFileRead;
-			{
+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;
-			fmode |= EDeleteOnClose;
+TInt prevErr = KErrNone;
-			}
+if(aFlags & SQLITE_OPEN_DELETEONCLOSE)
-		err = KErrAccessDenied;
+{
-		TInt prevErr = KErrNone;
+fmode |= EDeleteOnClose;
-		if(aFlags & SQLITE_OPEN_CREATE)
+}
-			{
+if(aFlags & SQLITE_OPEN_CREATE)
-			__FS_CALL(EFsOpFileCreate, 0);
+{
-			prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);
+__FS_CALL(EFsOpFileCreate, 0);
-			}
+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);
+{
-			err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
+__FS_CALL(EFsOpFileOpen, 0);
+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_READONLY;
+aFlags &= ~SQLITE_OPEN_READWRITE;
-			fmode &= ~EFileWrite;
+aFlags |= SQLITE_OPEN_READONLY;
-			__FS_CALL(EFsOpFileOpen, 0);
+fmode &= ~EFileWrite;
-			err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
+__FS_CALL(EFsOpFileOpen, 0);
-			}
+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
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_CANTOPEN);
+	return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : 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;
 		}
-	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)
 		{
 		::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);
-	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_DELETE);
+	return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : 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;
 		}
-	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)
 		{
 		::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;
 		}
-	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;
 	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" EXPORT_C void* sqlite3SymbianMalloc(size_t aSize)
+extern "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" 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);
 	__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" EXPORT_C void sqlite3SymbianFree(void* aPtr)
+extern "C" void sqlite3SymbianFree(void* aPtr)
 	{
 #ifdef _SQLPROFILER
 	TInt size = Allocator().AllocLen(aPtr);
 	__MEM_CALL(EMemOpFree, size, 0);
 #endif

branch	RCL_3
changeset 24	cc28652e0254
parent 23	26645d81f48d