// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// The Symbian OS porting layer - single-threaded implementation.

// SQLite never accesses the file system and the OS services directly.

// SQLite uses for that sqlite3_vfs and sqlite3_file objects.

// sqlite3_vfs and sqlite3_file functionality is implemented in this file - 

// TVfs and TFileIo classes.

// This file is also used for the COsLayerData implementation. A single COslayerData

// object is used by the OS porting layer for managing some global data.

// 

//

/**

 @file

 @see TVfs

 @see TFileIo

*/

#ifdef  SQLITE_OS_SYMBIAN

//#define _SQLPROFILER // Enable profiling //The same macro has to be enabled in SqlAssert.h file

extern "C" 

{

#include "sqliteInt.h"

#include "os.h"

}

#include "os_common.h"

#include "SqliteSymbian.h"

#include "FileBuf64.h"

#include <e32math.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

_LIT(KTempFileDir, "temp");

//Bit-mask constant. If xOpen()'s "aFlag" parameter contains one of these bits set, then the the file top be

//opened or created is a journal file.

const TUint KJournalFileTypeBitMask = SQLITE_OPEN_MAIN_JOURNAL | SQLITE_OPEN_TEMP_JOURNAL | SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_MASTER_JOURNAL; 

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef _SQLPROFILER

    //Profiling counters, defined in SqlSrvResourceprofiler.cpp

    extern TInt TheSqlSrvProfilerFileRead;

    extern TInt TheSqlSrvProfilerFileWrite;

    extern TInt TheSqlSrvProfilerFileSync;

    extern TInt TheSqlSrvProfilerFileSetSize;

#   define  __COUNTER_INCR(counter) ++counter

	//////////////////////////////////////////////////////////////////////////////

	////////////////////////// File I/O //////////////////////////////////////////

	//////////////////////////////////////////////////////////////////////////////

	/**

	This enum is used only in _SQLPROFILER mode for tracing the file system calls.

	@internalComponent

	@see FsCallBrkPt()

	*/

	enum TFsOpType

		{

		EFsOpFileCreate,

		EFsOpFileOpen,

		EFsOpFileClose,

		EFsOpFileDelete,

		EFsOpFileRead,

		EFsOpFileWrite,

		EFsOpFileSeek,

		EFsOpFileSize,

		EFsOpFileSetSize,

		EFsOpFileSync,

		EFsOpFileDrive,

		EFsOpFileAdopt,

		EFsOpFsClose,

		EFsOpFsConnect,

		EFsOpFsGetSystemDrive,

		EFsOpFsCreatePrivatePath,

		EFsOpFsPrivatePath,

		EFsOpFsVolumeIoParam,

		EFsOpFsEntry,

		EFsOpFsAtt,

		EFsOpFileCreateTemp,

		EFsOpFileAttach,

		//

		EFsOpLast

		};

	TBool   TheFileIoProfileEnabled = EFalse;

	TUint32 TheFileOpCounter[EFsOpLast] = {0};

	TInt64	TheFileWriteAmount = 0;

	TInt64	TheFileReadAmount = 0;

	/**

	This function is used only in _SQLPROFILER mode as an appropriate place for:

	 	- setting breakpoints for tracing the file system calls;

	 	- collection information about the number of the file system calls;

	@param aFsOpType A TFsOpType enum item value, identifying the file system operation that will be executed;

	@param a1 If the operation is "file read" or "file write" - the amount of data read/written;

	@internalComponent

	@see TFsOpType

	*/

	void FsCallBrkPt(TInt aFsOpType, TInt a1)

		{

		__ASSERT_DEBUG(aFsOpType >= 0 && aFsOpType < EFsOpLast, User::Invariant());

		if(!TheFileIoProfileEnabled)

			{

			return;	

			}

		TFsOpType fsOpType = (TFsOpType)aFsOpType;

		++TheFileOpCounter[fsOpType];

		if(fsOpType == EFsOpFileWrite)

			{

			TheFileWriteAmount += a1;

			}

		else if(fsOpType == EFsOpFileRead)

			{

			TheFileReadAmount += a1;

			}

		}

#	define __FS_CALL(aFsOpType, a1) FsCallBrkPt(aFsOpType, a1)

	//////////////////////////////////////////////////////////////////////////////

	////////////////////////// Heap Stats ////////////////////////////////////////

	//////////////////////////////////////////////////////////////////////////////

	/**

	Memory operation type: alloc, realloc, free. Used during the profiling.

	@internalComponent

	*/

	enum TMemOpType

		{

		EMemOpAlloc,

		EMemOpRealloc,

		EMemOpFree,

		//

		EMemOpLast

		};

	TBool   TheMemProfileEnabled = EFalse;//Mem operation call counters and time counters enabled/disabled

	TBool   TheMaxAllocProfileEnabled = EFalse;//Max mem allocation enabled/disabled

	TUint32 TheMemOpCounter[EMemOpLast] = {0};

	TInt64 	TheMemOpTicks[EMemOpLast] = {0};

	TInt64 	TheAllocated = 0;

	TInt64 	TheFreed = 0;

	TInt	TheAllocMax = 0;

	/**

	This class is used only in _SQLPROFILER mode as an appropriate place for:

	 	- setting breakpoints for tracing the memory allocation/deallocation calls;

	 	- collection information about the number of the memory allocation/deallocation calls and the time spent in the calls;

	The constructor's parameters are:	 	

	 - aOpType A TMemOpType enum item value, identifying the operation that will be executed;

	 - aAmt1 The allocated/deallocated size;

	 - aAmt2 Used only if a block of memory is reallocated in which case a2 is the old size of the block;

	@internalComponent

	@see TMemOpType

	*/

	class TMemCallCounter

		{

	public:			

		TMemCallCounter(TMemOpType aOpType, TInt aAmt1, TInt aAmt2) :

			iOpType(aOpType),

			iStartTicks(0)

			{

			if(TheMaxAllocProfileEnabled && (iOpType == EMemOpAlloc || iOpType == EMemOpRealloc) && aAmt1 > TheAllocMax)

				{

				TheAllocMax = aAmt1;	

				}

			if(TheMemProfileEnabled)

				{

				++TheMemOpCounter[iOpType];

				switch(iOpType)

					{

					case EMemOpAlloc:

						TheAllocated += aAmt1;

						break;

					case EMemOpRealloc:

						TheAllocated += aAmt1;

						TheFreed += aAmt2;

						break;

					case EMemOpFree:

						TheFreed += aAmt1;

						break;

					default:

						__ASSERT_DEBUG(0, User::Invariant());

						break;

					}

				iStartTicks = User::FastCounter();

				}

			}

		~TMemCallCounter()

			{

			if(TheMemProfileEnabled)

				{

				TInt64 diffTicks = (TInt64)User::FastCounter() - (TInt64)iStartTicks;

				if(diffTicks < 0)

					{

					diffTicks = KMaxTUint + diffTicks + 1;

					}

				TheMemOpTicks[iOpType] += diffTicks;

				}

			}

	private:

		TMemOpType	iOpType;

		TUint32 	iStartTicks;

		};

#	define __MEM_CALL(aMemOpType, a1, a2) TMemCallCounter memCallCounter(aMemOpType, a1, a2)

	//////////////////////////////////////////////////////////////////////////////

	////////////////////////// OS layer calls ////////////////////////////////////

	//////////////////////////////////////////////////////////////////////////////

	//The OS porting layer call types

	enum TOsOpType

		{

		EOsFileClose,

		EOsFileRead,

		EOsFileWrite,

		EOsFileTruncate,

		EOsFileSync,

		EOsFileFileSize,

		EOsFileLock,

		EOsFileUnlock,

		EOsFileCheckReservedLock,

		EOsFileFileControl,

		EOsFileSectorSize,

		EOsFileDeviceCharacteristics,

		//

		EOsVfsOpen,

		EOsVfsDelete,

		EOsVfsAccess,

		EOsVfsFullPathName,

		EOsVfsRandomness,

		EOsVfsSleep,

		EOsVfsCurrentTime,

		EOsVfsGetLastError,

		//

		EOsOpLast

		};

	TBool   TheOsProfileEnabled = EFalse;

	TUint32 TheOsOpCounter[EOsOpLast] = {0};//Each entry is a counter - how many times specific OS porting layer function has been called

#	define __OS_CALL(aOsOpType, a1, a2) 		\

			do									\

				{								\

				if(TheOsProfileEnabled) 		\

					{							\

					++TheOsOpCounter[aOsOpType];\

					}							\

				}								\

			while(0)				

	//////////////////////////////////////////////////////////////////////////////

	////////////////////////// OS layer timings //////////////////////////////////

	//////////////////////////////////////////////////////////////////////////////

	TBool  TheOsCallTimeProfileEnabled = EFalse;//If true, the OS porting layer call timings are enabled.

	TInt64 TheOsCallTicks[EOsOpLast];//Each entry represents the time in ticks spent in a specific OS porting layer function,

									 //disregarding the file type (main or journal)

	TBool  TheOsCallTimeDetailedProfileEnabled = EFalse;//If true, the OS porting layer call details are enabled and for each call an entry will be added to the log file (epocwind.out).

	TInt   TheOpCounter = 0;//Operations counter. Each OS porting layer function call increments the counter.

	//Used for storing the OS call details:

	// - iType        - on which file the call has been made: main database file - 'M', or journal file - 'J';

	// - iIdentifier  - two letters identifying the monitored OS porting layer function;

	// - iCallCounter - how many times the monitored OS porting layer function has been called;	

	// - iTicksTotal  - the total amount of time in ticks spent in the monitored OS porting layer function;	

	// - iBytesTotal  - the total amount of bytes passed to the monitored OS porting layer function (if it is read or write);

	struct TOsCallProfile

		{

		TOsCallProfile(char aType, const TDesC& aIdentifier) :

			iType(aType),

			iIdentifier(aIdentifier),

			iCallCounter(0),

			iTicksTotal(0),

			iBytesTotal(0)

			{

			}

		void Zero()

			{

			iCallCounter = 0;	

			iTicksTotal = 0;	

			iBytesTotal = 0;

			}

		char	iType;

		TBuf<32> iIdentifier;

		TInt	iCallCounter;

		TInt64	iTicksTotal;

		TInt64	iBytesTotal;

		};

	//An array of TOsCallProfile entries, each entry keeps the profile of a specifc OS porting layer function, when

	//the function was used on the main database file

	TOsCallProfile TheOsCallMProfile[EOsOpLast] = 

		{

		TOsCallProfile('M', _L("Close")), TOsCallProfile('M', _L("Read")), TOsCallProfile('M', _L("Write")), TOsCallProfile('M', _L("Truncate")),

		TOsCallProfile('M', _L("Sync")), TOsCallProfile('M', _L("Size")), TOsCallProfile('M', _L("Lock")), TOsCallProfile('M', _L("Unlock")),

		TOsCallProfile('M', _L("CheckReservedLock")), TOsCallProfile('M', _L("FileControl")), TOsCallProfile('M', _L("SetSize")), TOsCallProfile('M', _L("DeviceCharacteristics")),

		TOsCallProfile('M', _L("Open")), TOsCallProfile('M', _L("Delete")), TOsCallProfile('M', _L("Access")), TOsCallProfile('M', _L("FullPath")),

		TOsCallProfile('M', _L("Randomness")), TOsCallProfile('M', _L("Sleep")), TOsCallProfile('M', _L("CurrentTime")), TOsCallProfile('M', _L("GetLastError"))

		};

	//An array of TOsCallProfile entries, each entry keeps the profile of a specifc OS porting layer function, when

	//the function was used on the journal file

	TOsCallProfile TheOsCallJProfile[EOsOpLast] = 

		{

		TOsCallProfile('J', _L("Close")), TOsCallProfile('J', _L("Read")), TOsCallProfile('J', _L("Write")), TOsCallProfile('J', _L("Truncate")),

		TOsCallProfile('J', _L("Sync")), TOsCallProfile('J', _L("Size")), TOsCallProfile('J', _L("Lock")), TOsCallProfile('J', _L("Unlock")),

		TOsCallProfile('J', _L("CheckReservedLock")), TOsCallProfile('J', _L("FileControl")), TOsCallProfile('J', _L("SetSize")), TOsCallProfile('J', _L("DeviceCharacteristics")),

		TOsCallProfile('J', _L("Open")), TOsCallProfile('J', _L("Delete")), TOsCallProfile('J', _L("Access")), TOsCallProfile('J', _L("FullPath")),

		TOsCallProfile('J', _L("Randomness")), TOsCallProfile('J', _L("Sleep")), TOsCallProfile('J', _L("CurrentTime")), TOsCallProfile('J', _L("GetLastError"))

		};

	//The main class for the OS porting layer call profiles.

	class TOsCallCounter

		{

	public:

		//aOsCallTicksEntryRef - a reference to the related TheOsCallTicks[] entry;

		//aProfileRef          - a reference to the related TOsCallProfile object - TheOsCallMProfile[] or TheOsCallJProfile[] entry;

		//aOffset              - file offset in bytes;

		//aBytes               - amount of bytes to be read/written;

		//aOptional			   - might be NULL. Used to print out the name of the file being processed.

		TOsCallCounter(TInt64& aOsCallTicksEntryRef, TOsCallProfile& aOsCallProfileRef, TInt64 aOffset, TInt aBytes, 

				       const sqlite3_file* aHandle, const char* aOptional) :

			iOsCallTicksEntryRef(aOsCallTicksEntryRef),

			iOsCallProfileRef(aOsCallProfileRef),

			iOffset(aOffset),

			iBytes(aBytes),

			iHandle((TUint)aHandle),

			iOptional((const TUint8*)aOptional)

			{

			if(TheOsCallTimeProfileEnabled)

				{

				iStartTicks = User::FastCounter();

				}

			}

		~TOsCallCounter()

			{

			if(TheOsCallTimeProfileEnabled)

				{

				TInt64 diffTicks = (TInt64)User::FastCounter() - (TInt64)iStartTicks;

				if(diffTicks < 0)

					{

					diffTicks = KMaxTUint + diffTicks + 1;

					}

				iOsCallTicksEntryRef += diffTicks;

				if(TheOsCallTimeDetailedProfileEnabled)

					{

					++TheOpCounter;

					++iOsCallProfileRef.iCallCounter;

					iOsCallProfileRef.iTicksTotal += diffTicks;

					iOsCallProfileRef.iBytesTotal += iBytes;

					TFileName fname;

					if(iOptional)

						{

						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"),

															//[SQL-OS]

															//Handle

															//Time from start, microseconds

															//Subtype

															//IPC sequence counter

															//IPC call name

					    iHandle,							//sqlite3_file*

						iOsCallProfileRef.iType, 			//1 - main or journal file

						&iOsCallProfileRef.iIdentifier, 	//2 - operation type

						TheOpCounter, 						//3 - Operation counter

						iOsCallProfileRef.iCallCounter, 	//4 - This call type counter

						iOffset, 							//5 - File offset

						iBytes, 							//6 - Data, bytes

						diffTicks, 							//7 - Ticks

						iOsCallProfileRef.iBytesTotal, 		//8 - Data total, bytes

						iOsCallProfileRef.iTicksTotal,		//9 - Ticks total

						&fname);							//10- File name

					}

				}

			}

	private:

		TInt64&			iOsCallTicksEntryRef;

		TOsCallProfile&	iOsCallProfileRef;

		TInt64			iOffset;

		TInt			iBytes;			

		TUint32 		iStartTicks;

		TUint			iHandle;

		const TUint8*	iOptional;

		};

	inline TOsCallProfile& OsCallProfile(TBool aType, TInt aIndex)

		{

		return aType ? TheOsCallJProfile[aIndex] : TheOsCallMProfile[aIndex];

		}

#	define __OSTIME_COUNTER(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes, aHandle, aOpt)	TOsCallCounter osCallCounter(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes, aHandle, aOpt)

#else //_SQLPROFILER

#   define __COUNTER_INCR(counter) void(0)

#	define __FS_CALL(aFsOpType, a1) void(0)

#	define __MEM_CALL(aMemOpType, a1, a2) void(0)

#	define __OS_CALL(aOpType, a1, a2) void(0)

#	define __OSTIME_COUNTER(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes, aHandle, aOpt)	void(0)

#endif//_SQLPROFILER

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////       Profiling                          ////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef _SQLPROFILER

const TInt KMicroSecIn1Sec = 1000000;

TInt FastCounterFrequency()

	{

	TInt ticksPerSec = 0;

	TInt err = HAL::Get(HAL::EFastCounterFrequency, ticksPerSec);

	__ASSERT_ALWAYS(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicFastCounterFreq));

	return ticksPerSec;

	}

TInt sqlite3SymbianProfilerStart(TInt aCounterType)

	{

	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aCounterType);

	switch(KCounterType)

		{

		case TSqlResourceProfiler::ESqlCounterFileIO:

			TheFileIoProfileEnabled = ETrue;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCall:

			TheOsProfileEnabled = ETrue;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCallTime:

			TheOsCallTimeProfileEnabled = ETrue;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

			TheOsCallTimeProfileEnabled = ETrue;

			TheOsCallTimeDetailedProfileEnabled = ETrue;

			break;

		case TSqlResourceProfiler::ESqlCounterMemory:

			TheMemProfileEnabled = ETrue;

			break;

		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

			TheMaxAllocProfileEnabled = ETrue;

			break;

		default:

			return KErrNotSupported;

		}

	return KErrNone;

	}

TInt sqlite3SymbianProfilerStop(TInt aCounterType)

	{

	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aCounterType);

	switch(KCounterType)

		{

		case TSqlResourceProfiler::ESqlCounterFileIO:

			TheFileIoProfileEnabled = EFalse;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCall:

			TheOsProfileEnabled = EFalse;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCallTime:

			TheOsCallTimeProfileEnabled = EFalse;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

			TheOsCallTimeDetailedProfileEnabled = EFalse;

			TheOsCallTimeProfileEnabled = EFalse;

			break;

		case TSqlResourceProfiler::ESqlCounterMemory:

			TheMemProfileEnabled = EFalse;

			break;

		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

			TheMaxAllocProfileEnabled = EFalse;

			break;

		default:

			return KErrNotSupported;

		}

	return KErrNone;

	}

TInt sqlite3SymbianProfilerReset(TInt aCounterType)

	{

	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aCounterType);

	switch(KCounterType)

		{

		case TSqlResourceProfiler::ESqlCounterFileIO:

			Mem::FillZ(TheFileOpCounter, sizeof(TheFileOpCounter));

			TheFileWriteAmount = TheFileReadAmount = 0;

			break;

		case TSqlResourceProfiler::ESqlCounterOsCall:

			Mem::FillZ(TheOsOpCounter, sizeof(TheOsOpCounter));

			break;

		case TSqlResourceProfiler::ESqlCounterOsCallTime:

		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

			TheOpCounter = 0;

			Mem::FillZ(TheOsCallTicks, sizeof(TheOsCallTicks));

			for(TInt i=0;i<EOsOpLast;++i)

				{

				TheOsCallMProfile[i].Zero();

				TheOsCallJProfile[i].Zero();

				}

			break;

		case TSqlResourceProfiler::ESqlCounterMemory:

			Mem::FillZ(TheMemOpCounter, sizeof(TheMemOpCounter));

			Mem::FillZ(TheMemOpTicks, sizeof(TheMemOpTicks));

			TheAllocated = TheFreed = 0;

			break;

		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

			TheAllocMax = 0;

			break;

		default:

			return KErrNotSupported;

		}

	return KErrNone;

	}

TInt sqlite3SymbianProfilerQuery(TInt aCounterType, TDes8& aResult)

	{

	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aCounterType);

	switch(KCounterType)

		{

		case TSqlResourceProfiler::ESqlCounterFileIO:

			for(TInt i=0;i<EFsOpLast;++i)

				{

				aResult.AppendNum(TheFileOpCounter[i]);

				aResult.Append(TChar(';'));

				}

			aResult.AppendNum(TheFileWriteAmount);

			aResult.Append(TChar(';'));

			aResult.AppendNum(TheFileReadAmount);

			aResult.Append(TChar(';'));

			break;

		case TSqlResourceProfiler::ESqlCounterOsCall:

			for(TInt i=0;i<EOsOpLast;++i)

				{

				aResult.AppendNum(TheOsOpCounter[i]);

				aResult.Append(TChar(';'));

				}

			break;

		case TSqlResourceProfiler::ESqlCounterOsCallTime:

		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

			{

			TInt ticksPerSec = FastCounterFrequency();

			for(TInt i=0;i<EOsOpLast;++i)

				{

				TInt64 osCallTimeUs = (TheOsCallTicks[i] * KMicroSecIn1Sec) / ticksPerSec;

				aResult.AppendNum(osCallTimeUs);

				aResult.Append(TChar(';'));

				}

			}

			break;

		case TSqlResourceProfiler::ESqlCounterMemory:

			aResult.AppendNum(TheMemOpCounter[EMemOpAlloc]);

			aResult.Append(TChar(';'));

			aResult.AppendNum(TheMemOpCounter[EMemOpRealloc]);

			aResult.Append(TChar(';'));

			aResult.AppendNum(TheMemOpCounter[EMemOpFree]);

			aResult.Append(TChar(';'));

			aResult.AppendNum(TheAllocated);

			aResult.Append(TChar(';'));

			aResult.AppendNum(TheFreed);

			aResult.Append(TChar(';'));

			{

			TInt ticksPerSec = FastCounterFrequency();

			TInt64 memOpCallTimeUs = (TheMemOpTicks[EMemOpAlloc] * KMicroSecIn1Sec) / ticksPerSec;

			aResult.AppendNum(memOpCallTimeUs);

			aResult.Append(TChar(';'));

			memOpCallTimeUs = (TheMemOpTicks[EMemOpRealloc] * KMicroSecIn1Sec) / ticksPerSec;

			aResult.AppendNum(memOpCallTimeUs);

			aResult.Append(TChar(';'));

			memOpCallTimeUs = (TheMemOpTicks[EMemOpFree] * KMicroSecIn1Sec) / ticksPerSec;

			aResult.AppendNum(memOpCallTimeUs);

			aResult.Append(TChar(';'));

			}

			break;

		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

			aResult.AppendNum(TheAllocMax);

			aResult.Append(TChar(';'));

			break;

		default:

			return KErrNotSupported;

		}

	return KErrNone;

	}

#else//_SQLPROFILER	

TInt sqlite3SymbianProfilerStart(TInt)

	{

	return KErrNotSupported;	

	}

TInt sqlite3SymbianProfilerStop(TInt)

	{

	return KErrNotSupported;	

	}

TInt sqlite3SymbianProfilerReset(TInt)

	{

	return KErrNotSupported;	

	}

TInt sqlite3SymbianProfilerQuery(TInt, TDes8&)

	{

	return KErrNotSupported;	

	}

#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: 

@code

 - file session instance;

 - process's private data path, where the temporary file will be stored (on the system drive);

 - the last OS error code, every Symbian OS API call (file system calls, etc.) will set it;

 - the stored OS error code, initialized with the last OS error code only if stored OS error code is KErrNone.

	Each StoredOsErrorCode() call will reset it to KErrNone;

	The reason of having two data members for storing the OS error codes is that if there is just one variable

	and it gets initialized with the error value reported by a failed OS API call, the next successful OS API

	call will reset it and the COsLayerData client will miss the last "real" OS API error.

 - A pointer to the current RMessage2 object, if the current operation is "open a private secure database";

 - A boolean flag - iReadOnly - used only for private secure databases, indicating whether the database is read-only or not;

@endcode

@internalComponent

*/

NONSHARABLE_CLASS(COsLayerData)

	{

public:	

	static TInt Create();

	static inline void Destroy();

	static inline COsLayerData& Instance();

	inline TInt SetOsErrorCode(TInt aError);

	inline TInt StoredOsErrorCode();

	inline void StoreFhData(const RMessage2* aMsg, TBool aReadOnly);

	inline void RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly);

private:

	inline COsLayerData();

	inline ~COsLayerData();

	TInt DoCreate();

public:

	RFs			iFs;		//File session instance.

	TFileName	iSysPrivDir;//"<system drive>:\" + process's private data path. Initialized in sqlite3SymbianFsOpen().

	TInt64		iSeed;

private:	

	static COsLayerData* 	iOsLayerData;

	TInt					iStoredOsErrorCode;	//Contains the last OS error code.

	const RMessage2* 		iMessage;			//Fh data

	TBool					iReadOnly;			//Fh data

	};

/**

This functon returns a reference to the current thread allocator object.

The static RAllocator& variable will be initialized once at the moment when the function is called for 

first time. 

*/

static RAllocator& Allocator()

    {

    static RAllocator& allocator = User::Allocator();

    return allocator;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////       TDbFile struct declaration      /////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

TDbFile derives from the sqlite3_file structure, adding data members needed for processing the SQLite requests to the OS layer.

When SQLite needs an access to a file, SQLite allocates memory for a new TDbFile instance and passes a pointer to that 

instance to TVfs::Open(). TVfs::Open() creates/opens the file and initializes the TDbFile instance. 

SQLite uses the initialized TDbFile instance (actually SQLite knows and uses the sqlite3_file, the base structure) 

every time when needs to read or write from/to the file, using for that an appropriate TFileIo method.

Note: currently RFileBuf64 object is used instead of RFile64. That improves the read/write file performance.

No virtual methods here! sqlite3_file contains data members. If a virtual method is added, that will shift the offset of the

data members from the beginning of the sqlite3_file  object by 4 bytes. This is not what SQLite (C code) expects.

@internalComponent

@see TVfs

@see TFileIo

@see TVfs::Open()

*/

NONSHARABLE_STRUCT(TDbFile) : public sqlite3_file 

	{

	inline TDbFile();

	RFileBuf64	iFileBuf;

	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	

	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////       TFileIo class declaration      //////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

TFileIo class offers static methods for performing operations on a file.

Every TFileIo method has a pointer to a sqlite3_file instance (so, a TDbFile instance) as its first argument.

SQLite never accesses the file system directly, only through function pointers, data members of the sqlite3_io_methods structure.

The OS porting layer defines a single instance of sqlite3_io_methods structure, TheFileIoApi, and uses the TFileIo to initialize the 

sqlite3_io_methods data members (function pointers).

Every time when SQLite creates/opens a file using TVfs::Open(), TVfs::Open() will pass back to SQLite a pointer to the single

initialized sqlite3_io_methods instance (TheFileIoApi) that will be used later by SQLite for accessing the file.

@internalComponent

@see TVfs

@see TVfs::Open()

@see TheFileIoApi

@see TDbFile

*/

NONSHARABLE_CLASS(TFileIo)

	{

public:	

	static int Close(sqlite3_file* aDbFile);

	static int Read(sqlite3_file* aDbFile, void* aBuf, int aAmt, sqlite3_int64 aOffset);

	static int Write(sqlite3_file* aDbFile, const void* aData, int aAmt, sqlite3_int64 aOffset);

	static int Truncate(sqlite3_file* aDbFile, sqlite3_int64 aLength);

	static int Sync(sqlite3_file* aDbFile, int aFlags);

	static int FileSize(sqlite3_file* aDbFile, sqlite3_int64* aSize);

	static int Lock(sqlite3_file* aDbFile, int aLockType);

	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      /////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

TVfs ("VFS" - virtual file system) class offers methods for creating/openning a file, deleting a file,

a "sleep" method, a "time" method, a "rand" method, etc.

SQLite never accesses the OS API directly, only through the API offered by TVfs and TFileIo classes.

@internalComponent

@see TFileIo

@see TheVfsApi

@see COsLayerData

*/

NONSHARABLE_CLASS(TVfs)

	{

public:		

	static int Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags);

	static int Delete(sqlite3_vfs* aVfs, const char* aFileName, int aSyncDir);	

	static int Access(sqlite3_vfs* aVfs, const char* aFileName, int aFlags, int* aResOut);

	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 DoFileSizeCorruptionCheck(TDbFile& aDbFile, const TDesC& aFname, TInt aFmode);

	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////       Global variables, constants    ////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// The following macro specifies the size of the RFileBuf64 file buffer in KB:

//    __SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__

// 

// If not set, a default value of 8 is used	

#if !defined(__SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__)

#define __SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__ 8

#endif	

const TInt KFileBufSize = __SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__ * 1024;	

/**

Pointer to the single COsLayerData instance.

@see COsLayerData

@internalComponent

*/

COsLayerData* COsLayerData::iOsLayerData = NULL;

/**

Single sqlite3_io_methods instance, which data members (function pointers) are initialized with the addresses of

TFileIo members. 

TheFileIoApi is used by SQLite for performing OS independent file I/O.

@see TFileIo

@see TVfs

@internalComponent

*/

static sqlite3_io_methods TheFileIoApi = 

	{

	1,						//Version

	&TFileIo::Close,

	&TFileIo::Read,

	&TFileIo::Write,

	&TFileIo::Truncate,

	&TFileIo::Sync,

	&TFileIo::FileSize,

	&TFileIo::Lock,

	&TFileIo::Unlock,

	&TFileIo::CheckReservedLock,

	&TFileIo::FileControl,

	&TFileIo::SectorSize,

	&TFileIo::DeviceCharacteristics

	};

/**

Single sqlite3_vfs instance, which data members (function pointers) are initialized with the addresses of

TVfs members. TheVfsApi also keeps information regarding some other OS dependend characteristics like 

the TDbFile size and max file name length.

TheVfsApi is used by SQLite for accessing needed OS API.

TheVfsApi can't be a constant definition. SQLite expects the "sqlite3_vfs" object to be a R/W one, because

SQLite may have and use a chain of sqlite3_vfs instances.

@see TVfs

@see TTFileIo

@see TDbFile

@internalComponent

*/

static sqlite3_vfs TheVfsApi = 

	{

	1,					//iVersion

	sizeof(TDbFile),	//szOsFile

	KMaxFileName,		//mxPathname

	0,					//pNext

	"SymbianSql",		//zName

	0,					//pAppData

	&TVfs::Open,

	&TVfs::Delete,

	&TVfs::Access,

	&TVfs::FullPathName,

	0,

	0,

	0,

	0,

	&TVfs::Randomness,

	&TVfs::Sleep,

	&TVfs::CurrentTime,

	&TVfs::GetLastError

	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////       COsLayerData class definition    //////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Creates a single COsLayerData instance.

@return KErrNone,          The operation has completed succesfully;

	    KErrNoMemory,      Out of memory condition has occured;

                           Note that other system-wide error codes may also be returned.

@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, __SQLITEPANIC2(ESqliteOsPanicOsLayerDataExists));

	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.

*/