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

		}