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

equal deleted inserted replaced

-:0d6db0a14001
+:3256212fc81f
 }
 #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"
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
+//The SQLite temp files willl be created in this subdir
-Panic category - used by asserts in this file (the OS porting layer).
+_LIT(KTempFileDir, "temp");
-@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
-	};
 //Bit-mask constant. If xOpen()'s "aFlag" parameter contains one of these bits set, then the the file top be
 //opened or created is a journal file.
 const TUint KJournalFileTypeBitMask = SQLITE_OPEN_MAIN_JOURNAL | SQLITE_OPEN_TEMP_JOURNAL | SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_MASTER_JOURNAL;
 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:
 	TInt DoCreate();
 public:
 	RFs			iFs;		//File session instance.
 	TFileName	iSysPrivDir;//"<system drive>:\" + process's private data path. Initialized in sqlite3SymbianFsOpen().
-							//Used for storing sqlite temporary files.
 	TInt64		iSeed;
 private:
 	static COsLayerData* 	iOsLayerData;
 	TInt					iStoredOsErrorCode;	//Contains the last OS error code.
 */
 NONSHARABLE_STRUCT(TDbFile) : public sqlite3_file
 	{
 	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
 	};
 	static int Unlock(sqlite3_file* aDbFile, int aLockType);
 	static int CheckReservedLock(sqlite3_file* aDbFile, int *aResOut);
 	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);
 	};
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////       TVfs class declaration      /////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	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);
 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);
 	};
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////       Global variables, constants    ////////////////////////////////////////////////////////////////////
 @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();
 	}
 /**
 	TDriveUnit drive(sysDrive);
 	TDriveName driveName = drive.Name();
 	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;
 	}
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////     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);
 /**
 Initializes TDbFile data members with their default values.
 */
 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));
 	}
 /**
 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    ///////////////////////////////////////////////////////////////////////
 /**
 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.
 @return SQLITE_OK
 @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();
-	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;
 	}
 /**
 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,
+//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 <TFileName&> (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.
 Writes to the file referred by the aDbFile parameter.
 "Write beyond the end of the file" operations are allowed.
 If the write operation is in the 1st db file page and there is a registered "free pages" callback
 (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.
 @param aOffset The offset in the file where the write operation should start.
 @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 = 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);
 		err = dbFile.iFileBuf.Write(aOffset, ptr);
 		}
 		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);
+	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;
 	}
 /**
 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);
 	__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);
+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))
+		{
+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;
-	if(aFileName && (aFlags & SQLITE_OPEN_DELETEONCLOSE))
-		{
-		dbFile.iFullName = fname.Alloc();
-		if(!dbFile.iFullName)
-			{
-			osLayerData.SetOsErrorCode(KErrNoMemory);
-			return SQLITE_IOERR_NOMEM;
-			}
-		}
-	TInt recReadBufSize = -1;
 	TInt err = KErrNone;
 	if(fhStrType == EFhMainDbStr)
 		{//Main db file, open from handle
 		const RMessage2* msg;
 		TBool readOnly;
 			}
 		if(aFlags & SQLITE_OPEN_EXCLUSIVE)
 			{
 			fmode |= EFileShareExclusive;
 			}
-		if(!aFileName)
+		if(aFlags & SQLITE_OPEN_DELETEONCLOSE)
 			{
-			__FS_CALL(EFsOpFileCreateTemp, 0);
+			fmode |= EDeleteOnClose;
-			err = dbFile.iFileBuf.Temp(osLayerData.iFs, osLayerData.iSysPrivDir, fname, fmode);
+			}
-			if(err == KErrNone)
+		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))
 				{
-				dbFile.iFullName = fname.Alloc();
+				err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
-				if(!dbFile.iFullName)
-					{
-					err = KErrNoMemory;
-					}
 				}
 			}
-		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)
+		}
-				{
+	TInt recReadBufSize = -1;
-				__FS_CALL(EFsOpFileCreate, 0);
-				prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);
-				}
-			if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
-				{
-				__FS_CALL(EFsOpFileOpen, 0);
-				err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
-				if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
-				    {
-err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
-				    }
-				}
-			if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
-				{
-				aFlags &= ~SQLITE_OPEN_READWRITE;
-				aFlags |= SQLITE_OPEN_READONLY;
-				fmode &= ~EFileWrite;
-				__FS_CALL(EFsOpFileOpen, 0);
-				err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
-				}
-			if(err != KErrNone && prevErr == KErrAccessDenied)
-				{
-				err = KErrAccessDenied;
-				}
-			}
-		}
 	if(err == KErrNone)
 		{
 		err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize);
 		}
 	osLayerData.SetOsErrorCode(err);
 	if(err != KErrNone)
 		{
 		__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
 		{
 		dbFile.pMethods = &TheFileIoApi;
 		if(fhStrType != EFhMainDbStr)
 		(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;
 	}

changeset 41	3256212fc81f
parent 35	0d6db0a14001
child 46	826b40dcb0a8