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

#include "UTraceSql.h"

#ifdef _SQLPROFILER

#include <hal.h>

#include "../INC/SqlResourceProfiler.h"

#endif

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

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

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

/**

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

	};

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

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

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

#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, char aIdentifier[]) :

			iType(aType),

			iCallCounter(0),

			iTicksTotal(0),

			iBytesTotal(0)

			{

			iIdentifier[0] = aIdentifier[0];

			iIdentifier[1] = aIdentifier[1];

			}

		void Zero()

			{

			iCallCounter = 0;	

			iTicksTotal = 0;	

			iBytesTotal = 0;

			}

		char	iType;

		char	iIdentifier[2];

		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', "CL"), TOsCallProfile('M', "RD"), TOsCallProfile('M', "WR"), TOsCallProfile('M', "TR"),

		TOsCallProfile('M', "SY"), TOsCallProfile('M', "FS"), TOsCallProfile('M', "LK"), TOsCallProfile('M', "UL"),

		TOsCallProfile('M', "CL"), TOsCallProfile('M', "FC"), TOsCallProfile('M', "SS"), TOsCallProfile('M', "DC"),

		TOsCallProfile('M', "OP"), TOsCallProfile('M', "DE"), TOsCallProfile('M', "AC"), TOsCallProfile('M', "FN"),

		TOsCallProfile('M', "RN"), TOsCallProfile('M', "SL"), TOsCallProfile('M', "CT"), TOsCallProfile('M', "LE")

		};

	//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', "CL"), TOsCallProfile('J', "RD"), TOsCallProfile('J', "WR"), TOsCallProfile('J', "TR"),

		TOsCallProfile('J', "SY"), TOsCallProfile('J', "FS"), TOsCallProfile('J', "LK"), TOsCallProfile('J', "UL"),

		TOsCallProfile('J', "CL"), TOsCallProfile('J', "FC"), TOsCallProfile('J', "SS"), TOsCallProfile('J', "DC"),

		TOsCallProfile('J', "OP"), TOsCallProfile('J', "DE"), TOsCallProfile('J', "AC"), TOsCallProfile('J', "FN"),

		TOsCallProfile('J', "RN"), TOsCallProfile('J', "SL"), TOsCallProfile('J', "CT"), TOsCallProfile('J', "LE")

		};

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

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

			iOsCallTicksEntryRef(aOsCallTicksEntryRef),

			iOsCallProfileRef(aOsCallProfileRef),

			iOffset(aOffset),

			iBytes(aBytes)	

			{

			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;

					//                 1    2 3   4  5  6   7   8   9   10

					RDebug::Print(_L("'%c','%c%c',%d,%d,%ld,%d,%ld,%ld,%ld\n"), 

						iOsCallProfileRef.iType, 			//1

						iOsCallProfileRef.iIdentifier[0], 	//2

						iOsCallProfileRef.iIdentifier[1],	//3

						TheOpCounter, 						//4

						iOsCallProfileRef.iCallCounter, 	//5

						iOffset, 							//6

						iBytes, 							//7

						diffTicks, 							//8

						iOsCallProfileRef.iBytesTotal, 		//9

						iOsCallProfileRef.iTicksTotal);		//10

					}

				}

			}

	private:

		TInt64&			iOsCallTicksEntryRef;

		TOsCallProfile&	iOsCallProfileRef;

		TInt64			iOffset;

		TInt			iBytes;			

		TUint32 		iStartTicks;

		};

	inline TOsCallProfile& OsCallProfile(TBool aType, TInt aIndex)

		{

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

		}

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

#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)	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, User::Panic(KPanicCategory, EPanicFastCounterFreq));

	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;

	}