Symaptic: os/persistentdata/persistentstorage/sql/OsLayer/os

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

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

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

    16 // SQLite uses for that sqlite3_vfs and sqlite3_file objects.

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

    18 // TVfs and TFileIo classes.

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

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

    21 //

    22 //

    24 /**

    25  @file

    26  @see TVfs

    27  @see TFileIo

    28 */

    30 #ifdef  SQLITE_OS_SYMBIAN

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

    34 extern "C"

    35 {

    36 #include "sqliteInt.h"

    37 #include "os.h"

    38 }

    39 #include "os_common.h"

    40 #include "SqliteSymbian.h"

    41 #include "FileBuf64.h"

    42 #include <e32math.h>

    43 #ifdef _SQLPROFILER

    44 #include <hal.h>

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

    46 #endif

    47 #include "SqliteUtil.h"

    48 #include "OstTraceDefinitions.h"

    49 #ifdef OST_TRACE_COMPILER_IN_USE

    50 #include "os_symbianTraces.h"

    51 #endif

    52 #include "SqliteTraceDef.h"

    54 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    55 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    56 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    58 //The SQLite temp files willl be created in this subdir

    59 _LIT(KTempFileDir, "temp");

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

    62 //opened or created is a journal file.

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

    65 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    66 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    67 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    68 #ifdef _SQLPROFILER

    70     //Profiling counters, defined in SqlSrvResourceprofiler.cpp

    71     extern TInt TheSqlSrvProfilerFileRead;

    72     extern TInt TheSqlSrvProfilerFileWrite;

    73     extern TInt TheSqlSrvProfilerFileSync;

    74     extern TInt TheSqlSrvProfilerFileSetSize;

    76 #   define  __COUNTER_INCR(counter) ++counter

    78 	//////////////////////////////////////////////////////////////////////////////

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

    80 	//////////////////////////////////////////////////////////////////////////////

    82 	/**

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

    84 	@internalComponent

    85 	@see FsCallBrkPt()

    86 	*/

    87 	enum TFsOpType

    88 		{

    89 		EFsOpFileCreate,

    90 		EFsOpFileOpen,

    91 		EFsOpFileClose,

    92 		EFsOpFileDelete,

    93 		EFsOpFileRead,

    94 		EFsOpFileWrite,

    95 		EFsOpFileSeek,

    96 		EFsOpFileSize,

    97 		EFsOpFileSetSize,

    98 		EFsOpFileSync,

    99 		EFsOpFileDrive,

   100 		EFsOpFileAdopt,

   101 		EFsOpFsClose,

   102 		EFsOpFsConnect,

   103 		EFsOpFsGetSystemDrive,

   104 		EFsOpFsCreatePrivatePath,

   105 		EFsOpFsPrivatePath,

   106 		EFsOpFsVolumeIoParam,

   107 		EFsOpFsEntry,

   108 		EFsOpFsAtt,

   109 		EFsOpFileCreateTemp,

   110 		EFsOpFileAttach,

   111 		//

   112 		EFsOpLast

   113 		};

   115 	TBool   TheFileIoProfileEnabled = EFalse;

   116 	TUint32 TheFileOpCounter[EFsOpLast] = {0};

   117 	TInt64	TheFileWriteAmount = 0;

   118 	TInt64	TheFileReadAmount = 0;

   120 	/**

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

   122 	 	- setting breakpoints for tracing the file system calls;

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

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

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

   128 	@internalComponent

   130 	@see TFsOpType

   131 	*/

   132 	void FsCallBrkPt(TInt aFsOpType, TInt a1)

   133 		{

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

   135 		if(!TheFileIoProfileEnabled)

   136 			{

   137 			return;

   138 			}

   139 		TFsOpType fsOpType = (TFsOpType)aFsOpType;

   140 		++TheFileOpCounter[fsOpType];

   141 		if(fsOpType == EFsOpFileWrite)

   142 			{

   143 			TheFileWriteAmount += a1;

   144 			}

   145 		else if(fsOpType == EFsOpFileRead)

   146 			{

   147 			TheFileReadAmount += a1;

   148 			}

   149 		}

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

   153 	//////////////////////////////////////////////////////////////////////////////

   154 	////////////////////////// Heap Stats ////////////////////////////////////////

   155 	//////////////////////////////////////////////////////////////////////////////

   157 	/**

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

   160 	@internalComponent

   161 	*/

   162 	enum TMemOpType

   163 		{

   164 		EMemOpAlloc,

   165 		EMemOpRealloc,

   166 		EMemOpFree,

   167 		//

   168 		EMemOpLast

   169 		};

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

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

   173 	TUint32 TheMemOpCounter[EMemOpLast] = {0};

   174 	TInt64 	TheMemOpTicks[EMemOpLast] = {0};

   175 	TInt64 	TheAllocated = 0;

   176 	TInt64 	TheFreed = 0;

   177 	TInt	TheAllocMax = 0;

   179 	/**

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

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

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

   184 	The constructor's parameters are:

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

   186 	 - aAmt1 The allocated/deallocated size;

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

   189 	@internalComponent

   191 	@see TMemOpType

   192 	*/

   193 	class TMemCallCounter

   194 		{

   195 	public:

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

   197 			iOpType(aOpType),

   198 			iStartTicks(0)

   199 			{

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

   201 				{

   202 				TheAllocMax = aAmt1;

   203 				}

   204 			if(TheMemProfileEnabled)

   205 				{

   206 				++TheMemOpCounter[iOpType];

   207 				switch(iOpType)

   208 					{

   209 					case EMemOpAlloc:

   210 						TheAllocated += aAmt1;

   211 						break;

   212 					case EMemOpRealloc:

   213 						TheAllocated += aAmt1;

   214 						TheFreed += aAmt2;

   215 						break;

   216 					case EMemOpFree:

   217 						TheFreed += aAmt1;

   218 						break;

   219 					default:

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

   221 						break;

   222 					}

   223 				iStartTicks = User::FastCounter();

   224 				}

   225 			}

   226 		~TMemCallCounter()

   227 			{

   228 			if(TheMemProfileEnabled)

   229 				{

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

   231 				if(diffTicks < 0)

   232 					{

   233 					diffTicks = KMaxTUint + diffTicks + 1;

   234 					}

   235 				TheMemOpTicks[iOpType] += diffTicks;

   236 				}

   237 			}

   238 	private:

   239 		TMemOpType	iOpType;

   240 		TUint32 	iStartTicks;

   241 		};

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

   245 	//////////////////////////////////////////////////////////////////////////////

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

   247 	//////////////////////////////////////////////////////////////////////////////

   249 	//The OS porting layer call types

   250 	enum TOsOpType

   251 		{

   252 		EOsFileClose,

   253 		EOsFileRead,

   254 		EOsFileWrite,

   255 		EOsFileTruncate,

   256 		EOsFileSync,

   257 		EOsFileFileSize,

   258 		EOsFileLock,

   259 		EOsFileUnlock,

   260 		EOsFileCheckReservedLock,

   261 		EOsFileFileControl,

   262 		EOsFileSectorSize,

   263 		EOsFileDeviceCharacteristics,

   264 		//

   265 		EOsVfsOpen,

   266 		EOsVfsDelete,

   267 		EOsVfsAccess,

   268 		EOsVfsFullPathName,

   269 		EOsVfsRandomness,

   270 		EOsVfsSleep,

   271 		EOsVfsCurrentTime,

   272 		EOsVfsGetLastError,

   273 		//

   274 		EOsOpLast

   275 		};

   277 	TBool   TheOsProfileEnabled = EFalse;

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

   280 #	define __OS_CALL(aOsOpType, a1, a2) 		\

   281 			do									\

   282 				{								\

   283 				if(TheOsProfileEnabled) 		\

   284 					{							\

   285 					++TheOsOpCounter[aOsOpType];\

   286 					}							\

   287 				}								\

   288 			while(0)

   290 	//////////////////////////////////////////////////////////////////////////////

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

   292 	//////////////////////////////////////////////////////////////////////////////

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

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

   296 									 //disregarding the file type (main or journal)

   298 	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).

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

   301 	//Used for storing the OS call details:

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

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

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

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

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

   307 	struct TOsCallProfile

   308 		{

   309 		TOsCallProfile(char aType, const TDesC& aIdentifier) :

   310 			iType(aType),

   311 			iIdentifier(aIdentifier),

   312 			iCallCounter(0),

   313 			iTicksTotal(0),

   314 			iBytesTotal(0)

   315 			{

   316 			}

   317 		void Zero()

   318 			{

   319 			iCallCounter = 0;

   320 			iTicksTotal = 0;

   321 			iBytesTotal = 0;

   322 			}

   323 		char	iType;

   324 		TBuf<32> iIdentifier;

   325 		TInt	iCallCounter;

   326 		TInt64	iTicksTotal;

   327 		TInt64	iBytesTotal;

   328 		};

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

   331 	//the function was used on the main database file

   332 	TOsCallProfile TheOsCallMProfile[EOsOpLast] =

   333 		{

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

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

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

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

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

   339 		};

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

   342 	//the function was used on the journal file

   343 	TOsCallProfile TheOsCallJProfile[EOsOpLast] =

   344 		{

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

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

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

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

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

   350 		};

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

   353 	class TOsCallCounter

   354 		{

   355 	public:

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

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

   358 		//aOffset              - file offset in bytes;

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

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

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

   362 				       const sqlite3_file* aHandle, const char* aOptional) :

   363 			iOsCallTicksEntryRef(aOsCallTicksEntryRef),

   364 			iOsCallProfileRef(aOsCallProfileRef),

   365 			iOffset(aOffset),

   366 			iBytes(aBytes),

   367 			iHandle((TUint)aHandle),

   368 			iOptional((const TUint8*)aOptional)

   369 			{

   370 			if(TheOsCallTimeProfileEnabled)

   371 				{

   372 				iStartTicks = User::FastCounter();

   373 				}

   374 			}

   375 		~TOsCallCounter()

   376 			{

   377 			if(TheOsCallTimeProfileEnabled)

   378 				{

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

   380 				if(diffTicks < 0)

   381 					{

   382 					diffTicks = KMaxTUint + diffTicks + 1;

   383 					}

   384 				iOsCallTicksEntryRef += diffTicks;

   385 				if(TheOsCallTimeDetailedProfileEnabled)

   386 					{

   387 					++TheOpCounter;

   388 					++iOsCallProfileRef.iCallCounter;

   389 					iOsCallProfileRef.iTicksTotal += diffTicks;

   390 					iOsCallProfileRef.iBytesTotal += iBytes;

   391 					TFileName fname;

   392 					if(iOptional)

   393 						{

   394 						TPtrC8 fn8(iOptional);

   395 						fname.Copy(fn8);

   396 						}

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

   398 					RDebug::Print(_L("[SQL-OS]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬%c¬%S¬%d¬%d¬%ld¬%d¬%ld¬%ld¬%ld¬%S\n"),

   399 															//[SQL-OS]

   400 															//Handle

   401 															//Time from start, microseconds

   402 															//Subtype

   403 															//IPC sequence counter

   404 															//IPC call name

   405 					    iHandle,							//sqlite3_file*

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

   407 						&iOsCallProfileRef.iIdentifier, 	//2 - operation type

   408 						TheOpCounter, 						//3 - Operation counter

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

   410 						iOffset, 							//5 - File offset

   411 						iBytes, 							//6 - Data, bytes

   412 						diffTicks, 							//7 - Ticks

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

   414 						iOsCallProfileRef.iTicksTotal,		//9 - Ticks total

   415 						&fname);							//10- File name

   416 					}

   417 				}

   418 			}

   419 	private:

   420 		TInt64&			iOsCallTicksEntryRef;

   421 		TOsCallProfile&	iOsCallProfileRef;

   422 		TInt64			iOffset;

   423 		TInt			iBytes;

   424 		TUint32 		iStartTicks;

   425 		TUint			iHandle;

   426 		const TUint8*	iOptional;

   427 		};

   429 	inline TOsCallProfile& OsCallProfile(TBool aType, TInt aIndex)

   430 		{

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

   432 		}

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

   436 #else //_SQLPROFILER

   438 #   define __COUNTER_INCR(counter) void(0)

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

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

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

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

   448 #endif//_SQLPROFILER

   450 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   451 /////////////////////       Profiling                          ////////////////////////////////////////////////////////////////

   452 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   454 #ifdef _SQLPROFILER

   456 const TInt KMicroSecIn1Sec = 1000000;

   458 TInt FastCounterFrequency()

   459 	{

   460 	TInt ticksPerSec = 0;

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

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

   463 	return ticksPerSec;

   464 	}

   466 TInt sqlite3SymbianProfilerStart(TInt aCounterType)

   467 	{

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

   469 	switch(KCounterType)

   470 		{

   471 		case TSqlResourceProfiler::ESqlCounterFileIO:

   472 			TheFileIoProfileEnabled = ETrue;

   473 			break;

   474 		case TSqlResourceProfiler::ESqlCounterOsCall:

   475 			TheOsProfileEnabled = ETrue;

   476 			break;

   477 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   478 			TheOsCallTimeProfileEnabled = ETrue;

   479 			break;

   480 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   481 			TheOsCallTimeProfileEnabled = ETrue;

   482 			TheOsCallTimeDetailedProfileEnabled = ETrue;

   483 			break;

   484 		case TSqlResourceProfiler::ESqlCounterMemory:

   485 			TheMemProfileEnabled = ETrue;

   486 			break;

   487 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   488 			TheMaxAllocProfileEnabled = ETrue;

   489 			break;

   490 		default:

   491 			return KErrNotSupported;

   492 		}

   493 	return KErrNone;

   494 	}

   496 TInt sqlite3SymbianProfilerStop(TInt aCounterType)

   497 	{

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

   499 	switch(KCounterType)

   500 		{

   501 		case TSqlResourceProfiler::ESqlCounterFileIO:

   502 			TheFileIoProfileEnabled = EFalse;

   503 			break;

   504 		case TSqlResourceProfiler::ESqlCounterOsCall:

   505 			TheOsProfileEnabled = EFalse;

   506 			break;

   507 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   508 			TheOsCallTimeProfileEnabled = EFalse;

   509 			break;

   510 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   511 			TheOsCallTimeDetailedProfileEnabled = EFalse;

   512 			TheOsCallTimeProfileEnabled = EFalse;

   513 			break;

   514 		case TSqlResourceProfiler::ESqlCounterMemory:

   515 			TheMemProfileEnabled = EFalse;

   516 			break;

   517 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   518 			TheMaxAllocProfileEnabled = EFalse;

   519 			break;

   520 		default:

   521 			return KErrNotSupported;

   522 		}

   523 	return KErrNone;

   524 	}

   526 TInt sqlite3SymbianProfilerReset(TInt aCounterType)

   527 	{

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

   529 	switch(KCounterType)

   530 		{

   531 		case TSqlResourceProfiler::ESqlCounterFileIO:

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

   533 			TheFileWriteAmount = TheFileReadAmount = 0;

   534 			break;

   535 		case TSqlResourceProfiler::ESqlCounterOsCall:

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

   537 			break;

   538 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   539 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   540 			TheOpCounter = 0;

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

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

   543 				{

   544 				TheOsCallMProfile[i].Zero();

   545 				TheOsCallJProfile[i].Zero();

   546 				}

   547 			break;

   548 		case TSqlResourceProfiler::ESqlCounterMemory:

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

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

   551 			TheAllocated = TheFreed = 0;

   552 			break;

   553 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   554 			TheAllocMax = 0;

   555 			break;

   556 		default:

   557 			return KErrNotSupported;

   558 		}

   559 	return KErrNone;

   560 	}

   562 TInt sqlite3SymbianProfilerQuery(TInt aCounterType, TDes8& aResult)

   563 	{

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

   565 	switch(KCounterType)

   566 		{

   567 		case TSqlResourceProfiler::ESqlCounterFileIO:

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

   569 				{

   570 				aResult.AppendNum(TheFileOpCounter[i]);

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

   572 				}

   573 			aResult.AppendNum(TheFileWriteAmount);

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

   575 			aResult.AppendNum(TheFileReadAmount);

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

   577 			break;

   578 		case TSqlResourceProfiler::ESqlCounterOsCall:

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

   580 				{

   581 				aResult.AppendNum(TheOsOpCounter[i]);

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

   583 				}

   584 			break;

   585 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   586 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   587 			{

   588 			TInt ticksPerSec = FastCounterFrequency();

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

   590 				{

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

   592 				aResult.AppendNum(osCallTimeUs);

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

   594 				}

   595 			}

   596 			break;

   597 		case TSqlResourceProfiler::ESqlCounterMemory:

   598 			aResult.AppendNum(TheMemOpCounter[EMemOpAlloc]);

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

   600 			aResult.AppendNum(TheMemOpCounter[EMemOpRealloc]);

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

   602 			aResult.AppendNum(TheMemOpCounter[EMemOpFree]);

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

   604 			aResult.AppendNum(TheAllocated);

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

   606 			aResult.AppendNum(TheFreed);

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

   608 			{

   609 			TInt ticksPerSec = FastCounterFrequency();

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

   611 			aResult.AppendNum(memOpCallTimeUs);

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

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

   614 			aResult.AppendNum(memOpCallTimeUs);

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

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

   617 			aResult.AppendNum(memOpCallTimeUs);

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

   619 			}

   620 			break;

   621 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   622 			aResult.AppendNum(TheAllocMax);

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

   624 			break;

   625 		default:

   626 			return KErrNotSupported;

   627 		}

   628 	return KErrNone;

   629 	}

   631 #else//_SQLPROFILER

   633 TInt sqlite3SymbianProfilerStart(TInt)

   634 	{

   635 	return KErrNotSupported;

   636 	}

   638 TInt sqlite3SymbianProfilerStop(TInt)

   639 	{

   640 	return KErrNotSupported;

   641 	}

   643 TInt sqlite3SymbianProfilerReset(TInt)

   644 	{

   645 	return KErrNotSupported;

   646 	}

   648 TInt sqlite3SymbianProfilerQuery(TInt, TDes8&)

   649 	{

   650 	return KErrNotSupported;

   651 	}

   653 #endif//_SQLPROFILER

   655 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   657 /**

   658 Os2SqliteErr() is called at the end of many of the interface functions of the OS porting layer (wherever it is appropriate -

   659 TFileIo and TVfs interfaces). The purpose of this function is to identify the "out of memory" and "disk is full" errors

   660 reported by the used Symbian OS APIs (aOsErr parameter) and report them to SQLite as SQLITE_FULL and SQLITE_NOMEM errors.

   661 The KErrEof error (TFileIo::Read() can return KErrEof) is reported to SQLite as SQLITE_IOERR_SHORT_READ. The rest of failures

   662 are reported as the error specified in aDefaultErr parameter.

   664 @param aOsErr      Symbian OS error

   665 @param aDefaultErr The default SQLite error that should be used if the aOsErr parameter is not one of:

   666                      KErrNone, KErrEof, KErrNoMemory, KErrDiskFull

   667 @return SQLITE_OK,               The OS porting layer function call has completed successfully,

   668           SQLITE_IOERR_SHORT_READ, The amount of the data read is less than the requested amount,

   669           SQLITE_IOERR_NOMEM,      Out of memory,

   670           SQLITE_FULL,             The disk is full,

   671           aDefaultErr,             The rest of failures will be reported as aDefaultErr.

   672 */

   673 static TInt Os2SqliteErr(TInt aOsErr, TInt aDefaultErr)

   674 	{

   675 	switch(aOsErr)

   676 		{

   677 		case KErrNone:

   678 			return SQLITE_OK;

   679 		case KErrEof:

   680 			return SQLITE_IOERR_SHORT_READ;

   681 		case KErrNoMemory:

   682 			return SQLITE_IOERR_NOMEM;

   683 		case KErrDiskFull:

   684 			return SQLITE_FULL;

   685 		default:

   686 #ifdef _DEBUG

   687 			RDebug::Print(_L("SQLite OS porting layer, Os2SqliteErr(), err=%d\n"), aOsErr);

   688 			SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, OS2SQLITEERR, "OS;0;Os2SqliteErr;aOsErr=%d", aOsErr));

   689 #endif

   690 			break;

   691 		}

   692 	return aDefaultErr;

   693 	}

   696 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   697 /////////////////////       COsLayerData class declaration   //////////////////////////////////////////////////////////////////

   698 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   700 /**

   701 COsLayerData singleton class manages a single SQLite OS layer copy of the following data:

   702 @code

   703  - file session instance;

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

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

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

   707 	Each StoredOsErrorCode() call will reset it to KErrNone;

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

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

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

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

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

   713 @endcode

   715 @internalComponent

   716 */

   717 NONSHARABLE_CLASS(COsLayerData)

   718 	{

   719 public:

   720 	static TInt Create();

   721 	static inline void Destroy();

   722 	static inline COsLayerData& Instance();

   724 	inline TInt SetOsErrorCode(TInt aError);

   725 	inline TInt StoredOsErrorCode();

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

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

   730 private:

   731 	inline COsLayerData();

   732 	inline ~COsLayerData();

   733 	TInt DoCreate();

   735 public:

   736 	RFs			iFs;		//File session instance.

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

   738 	TInt64		iSeed;

   740 private:

   741 	static COsLayerData* 	iOsLayerData;

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

   743 	const RMessage2* 		iMessage;			//Fh data

   744 	TBool					iReadOnly;			//Fh data

   745 	};

   747 /**

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

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

   750 first time.

   751 */

   752 static RAllocator& Allocator()

   753     {

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

   755     return allocator;

   756     }

   758 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

   760 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   762 /**

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

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

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

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

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

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

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

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

   774 @internalComponent

   776 @see TVfs

   777 @see TFileIo

   778 @see TVfs::Open()

   779 */

   780 NONSHARABLE_STRUCT(TDbFile) : public sqlite3_file

   781 	{

   782 	inline TDbFile();

   783 	RFileBuf64	iFileBuf;

   784 	TInt		iLockType;				//File lock type

   785 	TBool		iReadOnly;				//True if the file is read-only

   786 	TInt		iSectorSize;			//Media sector-size

   787 	TInt		iDeviceCharacteristics;

   788 	TSqlFreePageCallback iFreePageCallback;

   789 	TBool       iIsFileCreated;          //If the file to be created is a temp file,

   790                                        //it will not be created until the data is to be written to.

   791 #ifdef _SQLPROFILER

   792 	TBool		iIsJournal;

   793 #endif

   794 	};

   796 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

   798 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   800 /**

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

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

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

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

   806 sqlite3_io_methods data members (function pointers).

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

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

   810 @internalComponent

   812 @see TVfs

   813 @see TVfs::Open()

   814 @see TheFileIoApi

   815 @see TDbFile

   816 */

   817 NONSHARABLE_CLASS(TFileIo)

   818 	{

   819 public:

   820 	static int Close(sqlite3_file* aDbFile);

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

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

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

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

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

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

   827 	static int Unlock(sqlite3_file* aDbFile, int aLockType);

   828 	static int CheckReservedLock(sqlite3_file* aDbFile, int *aResOut);

   829 	static int FileControl(sqlite3_file* aDbFile, int aOp, void* aArg);

   830 	static int SectorSize(sqlite3_file* aDbFile);

   831 	static int DeviceCharacteristics(sqlite3_file* aDbFile);

   832 private:

   833 	static TInt DoCreateTempFile(TDbFile& aDbFile);

   834 	};

   836 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   837 ///////////////////////////////////       TVfs class declaration      /////////////////////////////////////////////////////////

   838 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   840 /**

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

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

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

   845 @internalComponent

   847 @see TFileIo

   848 @see TheVfsApi

   849 @see COsLayerData

   850 */

   851 NONSHARABLE_CLASS(TVfs)

   852 	{

   853 public:

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

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

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

   857 	static int FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf);

   858 	static int Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf);

   859 	static int Sleep(sqlite3_vfs* aVfs, int aMicrosec);

   860 	static int CurrentTime(sqlite3_vfs* aVfs, double* aNow);

   861 	static int GetLastError(sqlite3_vfs *sVfs, int aBufLen, char* aBuf);

   862 	static TInt DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize);

   863 private:

   864 	static TInt DoOpenFromHandle(TDbFile& aDbFile, const RMessage2& aMsg, TBool aReadOnly);

   865 	static inline TInt DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo);

   866 	static TInt DoGetDeviceCharacteristics(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo);

   867 	static TInt DoGetSectorSize(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo);

   868 	static TInt DoFileSizeCorruptionCheck(TDbFile& aDbFile, const TDesC& aFname, TInt aFmode);

   869 	};

   871 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

   873 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

   876 //    __SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__

   877 //

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

   879 #if !defined(__SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__)

   880 #define __SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__ 8

   881 #endif

   882 const TInt KFileBufSize = __SQLITE_OS_SYMBIAN_FILEBUF_KBSIZE__ * 1024;

   884 /**

   885 Pointer to the single COsLayerData instance.

   887 @see COsLayerData

   889 @internalComponent

   890 */

   891 COsLayerData* COsLayerData::iOsLayerData = NULL;

   893 /**

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

   895 TFileIo members.

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

   898 @see TFileIo

   899 @see TVfs

   901 @internalComponent

   902 */

   903 static sqlite3_io_methods TheFileIoApi =

   904 	{

   905 	1,						//Version

   906 	&TFileIo::Close,

   907 	&TFileIo::Read,

   908 	&TFileIo::Write,

   909 	&TFileIo::Truncate,

   910 	&TFileIo::Sync,

   911 	&TFileIo::FileSize,

   912 	&TFileIo::Lock,

   913 	&TFileIo::Unlock,

   914 	&TFileIo::CheckReservedLock,

   915 	&TFileIo::FileControl,

   916 	&TFileIo::SectorSize,

   917 	&TFileIo::DeviceCharacteristics

   918 	};

   920 /**

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

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

   923 the TDbFile size and max file name length.

   924 TheVfsApi is used by SQLite for accessing needed OS API.

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

   927 SQLite may have and use a chain of sqlite3_vfs instances.

   929 @see TVfs

   930 @see TTFileIo

   931 @see TDbFile

   933 @internalComponent

   934 */

   935 static sqlite3_vfs TheVfsApi =

   936 	{

   937 	1,					//iVersion

   938 	sizeof(TDbFile),	//szOsFile

   939 	KMaxFileName,		//mxPathname

   940 	0,					//pNext

   941 	"SymbianSql",		//zName

   942 	0,					//pAppData

   943 	&TVfs::Open,

   944 	&TVfs::Delete,

   945 	&TVfs::Access,

   946 	&TVfs::FullPathName,

   947 	0,

   948 	0,

   949 	0,

   950 	0,

   951 	&TVfs::Randomness,

   952 	&TVfs::Sleep,

   953 	&TVfs::CurrentTime,

   954 	&TVfs::GetLastError

   955 	};

   957 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

   959 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   961 /**

   962 Creates a single COsLayerData instance.

   964 @return KErrNone,          The operation has completed succesfully;

   965 	    KErrNoMemory,      Out of memory condition has occured;

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

   968 @panic Sqlite 16 In _DEBUG mode - the COsLayerData instance has been created already.

   969 */

   970 /* static */ TInt COsLayerData::Create()

   971 	{

   972 	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_ENTRY, "OS-Entry;0;COsLayerData::Create"));

   973 	__ASSERT_DEBUG(!COsLayerData::iOsLayerData, __SQLITEPANIC2(ESqliteOsPanicOsLayerDataExists));

   974 	COsLayerData::iOsLayerData = new COsLayerData;

   975 	if(!COsLayerData::iOsLayerData)

   976 		{

   977 		SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT1, "OS-Exit;0;COsLayerData::Create;err=KErrNoMemory"));

   978 		return KErrNoMemory;

   979 		}

   980 	TInt err = COsLayerData::iOsLayerData->DoCreate();

   981 	if(err != KErrNone)

   982 		{

   983 		delete COsLayerData::iOsLayerData;

   984 		COsLayerData::iOsLayerData = NULL;

   985 		SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT2, "OS-Exit;0;COsLayerData::Create;err=%d", err));

   986 		return err;

   987 		}

   988 	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT3, "OS-Exit;0;COsLayerData::Create;err=KErrNone"));

   989 	return KErrNone;

   990 	}

   992 /**

   993 Destroys the COsLayerData instance.

   994 */

   995 /* static */ inline void COsLayerData::Destroy()

   996 	{

   997 	delete COsLayerData::iOsLayerData;

   998 	COsLayerData::iOsLayerData = NULL;

   999 	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_DESTROY, "OS;0;COsLayerData::Destroy"));

  1000 	}

  1002 /**

  1003 Returns a reference to the single COsLayerData instance.

  1005 @panic Sqlite 1 In _DEBUG mode if the COsLayerData instance is NULL.

  1006 */

  1007 /* static */ inline COsLayerData& COsLayerData::Instance()

  1008 	{

  1009 	__ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, __SQLITEPANIC2(ESqliteOsPanicNullOsLayerDataPtr));

  1010 	return *COsLayerData::iOsLayerData;

  1011 	}

  1013 /**

  1014 Sets the last OS error code data member. The stored OS error code data member will be set only if it is

  1015 KErrNone. (If it is not KErrNone it means that its value has not been accessed yet)

  1016 An exception from the rule described above is KErrDiskFull error which, if happens, will be set always, because

  1017 this error has a special meaning for the database clients - special actions may have to be taken if the

  1018 disk is full.

  1020 @param aError The OS error code

  1021 @return The OS error code

  1022 */

  1023 inline TInt COsLayerData::SetOsErrorCode(TInt aError)

  1024 	{

  1025 	if(iStoredOsErrorCode == KErrNone || aError == KErrDiskFull)

  1026 		{

  1027 		iStoredOsErrorCode = aError;

  1028 		}

  1029 	return aError;

  1030 	}

  1032 /**

  1033 Returns the last stored OS error code, which was stored by SetOsErrorCode() call.

  1034 The function also resets the stored OS error code to KErrNone.

  1036 @return The last stored OS error code

  1037 */

  1038 inline TInt COsLayerData::StoredOsErrorCode()

  1039 	{

  1040 	TInt err = iStoredOsErrorCode;

  1041 	iStoredOsErrorCode = KErrNone;

  1042 	return err;

  1043 	}

  1045 /**

  1046 Stores the RMessage2 object address, file and file session handles and the read-only flag for later use when SQLite issues a

  1047 request for open the database file (private secure database).

  1049 The aMsg argument of the function can be NULL, because this fucntion is also used to reset the stored "file handle" data.

  1051 How this function is used:

  1052 1) When the SQL server receives a request to establish a connection with private secure database, the SQL server

  1053    will add additional information to the private secure database file name, such as:

  1054    	- the file handle (the private secure database is opened by the client side dll - sqldb.dll);

  1055    	- a pointer to the RMessage2 object used in this request;

  1056 2) The passed additional information will be used for adopting the file handle by calling RFile64::AdoptFromClient().

  1057 3) Before calling TVfs::Open() to establish a connection with the database, SQLite will call TVfs::FullPathName()

  1058    to retrieve the database file full path

  1059 4) TVfs::FullPathName() will detect that the file name contains an additional information and will extraxt the information

  1060    calling COsLayerData::StoreFhData().

  1061 5) After TVfs::FullPathName() SQLite calls TVfs::Open() where the extracted information will be used for adopting the file handle

  1063 @param aMsg A pointer to the current RMessage2 object

  1064 @param aReadOnly True if the private secure database is read-only

  1065 */

  1066 inline void COsLayerData::StoreFhData(const RMessage2* aMsg, TBool aReadOnly)

  1067 	{

  1068 	iMessage = aMsg;

  1069 	iReadOnly = aReadOnly;

  1070 	}

  1072 /**

  1073 Retrieves the RMessage2 object, file and file session handles. The stored data will be reset.

  1074 This function is used by TVfs::Open(), when a request for opening a secure private database is processed.

  1076 @param aMsg Output parameter. A reference to a RMessage2 pointer, which will be initialized with the stored RMessage2 pointer.

  1077 @param aReadOnly Output parameter. The store read-only flag value will be set there.

  1079 @panic Sqlite 13 In _DEBUG mode - aMsg is NULL.

  1080 */

  1081 inline void COsLayerData::RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly)

  1082 	{

  1083 	__ASSERT_DEBUG(iMessage != NULL, __SQLITEPANIC(ESqliteOsPanicInvalidFhData));

  1084 	aMsg = iMessage;

  1085 	aReadOnly = iReadOnly;

  1086 	iMessage = NULL;

  1087 	}

  1089 /**

  1090 Initializes the COsLayerData data members with their default values.

  1091 */

  1092 inline COsLayerData::COsLayerData() :

  1093 	iStoredOsErrorCode(KErrNone),

  1094 	iMessage(0),

  1095 	iReadOnly(EFalse)

  1096 	{

  1097 	TTime now;

  1098 	now.UniversalTime();

  1099 	iSeed = now.Int64();

  1100 	}

  1102 /**

  1103 Destroys the COsLayerData instance.

  1105 Note: No SQLite functions should be called inside the destructor, because SQLite is already shutdown-ed!

  1106 */

  1107 inline COsLayerData::~COsLayerData()

  1108 	{

  1109 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, COSLAYERDATA_COSLAYERDATA2, "OS;0;COsLayerData::~COsLayerData;iFs.Handle()=0x%X", (TUint)iFs.Handle()));

  1110 	__FS_CALL(EFsOpFsClose, 0);

  1111 	iFs.Close();

  1112 	}

  1114 /**

  1115 Creates a file session instance.

  1117 Creates the private path, where the temporary files will be stored (on the system drive).

  1119 In a case of a failure COsLayerData::DoCreate() does not close the file session.

  1120 This will be made in the calling function - COsLayerData::Create().

  1122 Note: No SQLite functions should be called inside the DoCreate() implementation, because SQLite is not initialized yet!

  1124 @return KErrNone,          The operation has completed succesfully;

  1125 		KErrGeneral		   The registration of TheVfsApi has failed;

  1126 	    KErrNoMemory,      Out of memory condition has occured;

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

  1129 @see TVfs

  1130 @see TheVfsApi

  1131 */

  1132 TInt COsLayerData::DoCreate()

  1133 	{

  1134 	__FS_CALL(EFsOpFsConnect, 0);

  1135 	TInt err = iFs.Connect();

  1136 	if(err != KErrNone)

  1137 		{

  1138 		return err;

  1139 		}

  1140 	//Get the system drive

  1141 	__FS_CALL(EFsOpFsGetSystemDrive, 0);

  1142 	TInt sysDrive = static_cast<TInt>(RFs::GetSystemDrive());

  1143 	__FS_CALL(EFsOpFsCreatePrivatePath, 0);

  1144 	if((err = iFs.CreatePrivatePath(sysDrive)) != KErrNone && err != KErrAlreadyExists)

  1145 		{

  1146 		return err;

  1147 		}

  1148 	TFileName privateDir;

  1149 	__FS_CALL(EFsOpFsPrivatePath, 0);

  1150 	if((err = iFs.PrivatePath(privateDir)) != KErrNone)

  1151 		{

  1152 		return err;

  1153 		}

  1154 	TDriveUnit drive(sysDrive);

  1155 	TDriveName driveName = drive.Name();

  1156 	TParse parse;

  1157 	(void)parse.Set(driveName, &privateDir, 0);//this call can't fail

  1158 	iSysPrivDir.Copy(parse.DriveAndPath());

  1159 	//Create the temp files directory

  1160 	(void)parse.AddDir(KTempFileDir);//this call can't fail

  1161 	err = iFs.MkDir(parse.DriveAndPath());

  1162     if(err != KErrNone && err != KErrAlreadyExists)

  1163     	{

  1164 		return err;

  1165     	}

  1166 	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)));

  1167 	return KErrNone;

  1168 	}

  1170 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1171 ///////////////////////     Symbian OS specific functions (called by the SQL server)        ///////////////////////////////////

  1172 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1174 /**

  1175 Returns the last OS error which occured durring the operations with the database files.

  1176 The per-thread variable, where the last OS error is hold, will be set to KErrNone.

  1178 This function is part of Symbian OS specific SQLITE API.

  1180 @return The last OS error.

  1181 @internalComponent

  1182 */

  1183 TInt sqlite3SymbianLastOsError(void)

  1184 	{

  1185 	return COsLayerData::Instance().StoredOsErrorCode();

  1186 	}

  1188 /**

  1189 This function must be called once before any other SQLITE API call.

  1190 The function:

  1191 @code

  1192  - Initializes the OS poting layer;

  1193  - Initializes the SQLite library;

  1194 @endcode

  1196 This function is part of the Symbian OS specific SQLITE API.

  1198 @return Symbian OS specific error code, including KErrNoMemory.

  1200 @internalComponent

  1201 */

  1202 TInt sqlite3SymbianLibInit(void)

  1203 	{

  1204 	TInt osErr = COsLayerData::Create();

  1205 	if(osErr != KErrNone)

  1206 		{

  1207 		return osErr;

  1208 		}

  1209 	osErr = KErrNone;

  1210 	TInt sqliteErr = sqlite3_initialize();

  1211 	if(sqliteErr != SQLITE_OK)

  1212 		{

  1213 		osErr = sqliteErr == SQLITE_NOMEM ? KErrNoMemory : KErrGeneral;

  1214 		COsLayerData::Destroy();

  1215 		}

  1216 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3SYMBIANLIBINIT, "OS;0;sqlite3SymbianLibInit;osErr=%d", osErr));

  1217 	return osErr;

  1218 	}

  1220 /**

  1221 This function must be called once after finishing working with sqlite.

  1222 The function:

  1223 @code

  1224  - Shuts down the SQLite library;

  1225  - Releases the allocated by the OS porting layer resources;

  1226 @endcode

  1228 This function is part of the Symbian OS specific SQLITE API.

  1230 @internalComponent

  1231 */

  1232 void sqlite3SymbianLibFinalize(void)

  1233 	{

  1234 	(void)sqlite3_shutdown();

  1235 	COsLayerData::Destroy();

  1236 	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, SQLITE3SYMBIANLIBFINALIZE, "OS;0;sqlite3SymbianLibFinalize"));

  1237 	}

  1239 /**

  1240 This function is part of Symbian OS specific SQLITE API.

  1242 @return A reference to RFs instance used for sqlite file I/O operations.

  1243 @internalComponent

  1244 */

  1245 RFs& sqlite3SymbianFs(void)

  1246 	{

  1247 	return COsLayerData::Instance().iFs;

  1248 	}

  1250 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1251 //////////////////          UTF16<-->UTF8, conversion functions    ////////////////////////////////////////////////////////////

  1252 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1254 /**

  1255 The function converts aFileName to UTF16 encoded file name, and stores the UTF16 encoded file name

  1256 to the place pointed by aFileNameDestBuf argument.

  1257 If the UTF16 conversion of the file name failed because the file name is too long or NULL,

  1258 the function returns EFalse.

  1260 @param aFileName Expected to point to UTF8 encoded, zero terminated string.

  1261 				 Max allowed aFileName length is KMaxFileName (excluding terminating 0 character).

  1262 @param aFileNameDestBuf Output parameter. Will hold UTF16, non-zero-terminated string.

  1263 						The max length must be at least KMaxFileName characters.

  1265 @return True if the conversion has been completed successfully

  1266 */

  1267 static TBool ConvertToUnicode(const char *aFileName, TDes& aFileNameDestBuf)

  1268 	{

  1269 	if(aFileName)

  1270 		{

  1271 		wchar_t* dest = reinterpret_cast <wchar_t*> (const_cast <TUint16*> (aFileNameDestBuf.Ptr()));

  1272 		TInt len = mbstowcs(dest, aFileName, aFileNameDestBuf.MaxLength());

  1273 		__ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  1274 		//If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small.

  1275 		if(len < aFileNameDestBuf.MaxLength())

  1276 			{

  1277 			aFileNameDestBuf.SetLength(len);

  1278 			return ETrue;

  1279 			}

  1280 		}

  1281 	return EFalse;

  1282 	}

  1284 /**

  1285 The function converts aFileName to UTF8 encoded file name, and stores the UTF8 encoded file name

  1286 to the place pointed by aFileNameDestBuf argument.

  1287 If the UTF8 conversion of the file name failed because the file name is too long or NULL,

  1288 the function returns EFalse.

  1290 @param aFileName Expected to point to UTF16 encoded, zero terminated string.

  1291 				 Max allowed aFileName length is KMaxFileName (excluding terminating 0 character).

  1292 @param aFileNameDestBuf Output parameter. Will hold UTF8, non-zero-terminated string.

  1293 						The max length must be at least KMaxFileName characters.

  1295 @return True if the conversion has been completed successfully

  1296 */

  1297 static TBool ConvertFromUnicode(const TDesC& aFileName, TDes8& aFileNameDestBuf)

  1298 	{

  1299 	char* dest = reinterpret_cast <char*> (const_cast <TUint8*> (aFileNameDestBuf.Ptr()));

  1300 	const wchar_t* src = reinterpret_cast <const wchar_t*> (aFileName.Ptr());

  1301 	TInt len = wcstombs(dest, src, aFileNameDestBuf.MaxLength());

  1302 	__ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  1303 	//If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small.

  1304 	if(len < aFileNameDestBuf.MaxLength())

  1305 		{

  1306 		aFileNameDestBuf.SetLength(len);

  1307 		return ETrue;

  1308 		}

  1309 	return EFalse;

  1310 	}

  1312 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1313 //////////////////          File name, containing handles, functions   ////////////////////////////////////////////////////////

  1314 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1316 const char KFhSeparator = '|';	//The symbol, which when used in the file name means that the string does not contain a real file name but file handles

  1317 const TInt KFhSessHandleIdx = 2;//The index of the file session handle in RMessage2 object

  1318 const TInt KFhFileHandleIdx = 3;//The index of the file handle in RMessage2 object

  1319 const TInt KFhMarkPos = 0;		//if the symbol in this position is KFhSeparator, then the string contains file handles

  1320 const TInt KFhRoPos = 1;		//read-only flag position in the string

  1321 const TInt KFhMsgAddrPos = 2;	//RMessage2 address position in the string

  1322 const TInt KFhMsgAddrLen = 8;	//RMessage2 address length

  1323 //const TInt KFhDrivePos = 1;	//Drive position in the string (after removing the read-only flag and RMessage2 object's address)

  1325 /**

  1326 File name string types:

  1327 @code

  1328 	- ENotFhStr 	- The string does not contain file handles;

  1329 	- EFhStr		- The string contain file handles, but is not main db file;

  1330 	- EFhMainDbStr	- The string contain file handles and is the main db file;

  1331 @endcode

  1333 Every file name passed to the OS porting layer's TVfs::Open() method falls into one of the following three categories:

  1334 ENotFhStr - the file name does not contain handles, EFhStr - the file name contains handles but is not a name of a private

  1335 secure database, EFhMainDbStr - the file name contains handles and is a name of a private secure database.

  1337 @see TVfs::Open()

  1338 @see FhStringProps()

  1340 @internalComponent

  1341 */

  1342 enum TFhStrType

  1343 	{

  1344 	ENotFhStr,						//The string does not contain file handles

  1345 	EFhStr,							//The string contain file handles, but is not main db file

  1346 	EFhMainDbStr					//The string contain file handles and is the main db file

  1347 	};

  1349 /**

  1350 The TVfs::Open() implementation uses this function to determine the type of the file name, which can be

  1351 one of the TFhStrType enum item values.

  1353 @param aFileName Zero-terminated, UTF8 encoded file name.

  1354 @return The file name type, one of the TFhStrType enum item values.

  1356 @see TVfs::Open()

  1357 @see TFhStrType

  1359 @internalComponent

  1360 */

  1361 static TFhStrType FhStringProps(const char* aFileName)

  1362 	{

  1363 	char* first = strchr(aFileName, KFhSeparator);

  1364 	if(!first)

  1365 		{

  1366 		return ENotFhStr;

  1367 		}

  1368 	char* last = strchr(first + 1, KFhSeparator);

  1369 	if(!last)

  1370 		{

  1371 		return ENotFhStr;

  1372 		}

  1373 	return *(last + 1) == 0 ? EFhMainDbStr : EFhStr;

  1374 	}

  1376 /**

  1377 Removes all invalid characters in aFileName.

  1378 If the file name contains handles (so that's a private secure database related name), the additional

  1379 information (handles, flags, object addresses) has to be excluded from the name in order to make it usable

  1380 by the file system.

  1382 The private file name format is (see FhExtractAndStore() comments):

  1384 "|<R/O flag><RMessage2 pointer><drive><app SID><file_name><file_ext>|"

  1386 Before opening or creating a file, SQLite will call TVfs::FullPathName() passing to the function the name of

  1387 the file and expecting the full file name (including path) as an output from the function.

  1388 After the TVfs::FullPathName() call, the full file name, returned to SQLite, will have the following format:

  1390 "|<drive><path><file_name><file_ext>|"

  1392 FhConvertToFileName() is called from TVfs::Open() and will remove the leading and trialing '|' characters from

  1393 the file name.

  1395 @param aFileName Input/Output parameter. The cleaned file name will be copied there.

  1396 @param aPrivateDir The SQL server private data cage.

  1398 @see TVfs::Open()

  1399 @see TFhStrType

  1400 @see FhStringProps()

  1402 @internalComponent

  1403 */

  1404 static void FhConvertToFileName(TDes& aFileName, const TDesC& aPrivateDir)

  1405 	{

  1406 	TInt firstPos = aFileName.Locate(TChar(KFhSeparator));

  1407 	if(firstPos >= 0)

  1408 		{

  1409 		aFileName.Delete(firstPos, 1);

  1410 		TInt lastPos = aFileName.LocateReverse(TChar(KFhSeparator));

  1411 		if(lastPos >= 0)

  1412 			{

  1413 			aFileName.Delete(lastPos, 1);

  1414 			TParse parse;

  1415 			(void)parse.Set(aFileName, &aPrivateDir, 0);//the file name should be verified by the server

  1416 			aFileName.Copy(parse.FullName());

  1417 			}

  1418 		}

  1419 	}

  1421 /**

  1422 Extracts the read-only flag and RMessage address from aDbFileName and stores them in the single COsLayerData instance.

  1424 @param aDbFileName Input/output parameter. The file name.

  1425 				   It will be reformatted and won't contain the already extracted data.

  1426 				   The aDbFileName format is:

  1427 @code

  1428       				|<R/O flag><RMessage2 pointer><drive><app SID><file_name><file_ext>|

  1429 @endcode

  1431 @see TVfs::Open()

  1432 @see TFhStrType

  1433 @see FhStringProps()

  1435 @internalComponent

  1437 @panic Sqlite 12 In _DEBUG mode - invalid position of the "|" character in the file name.

  1438 @panic Sqlite 12 In _DEBUG mode - no RMessage2 pointer can be extracted from the file name.

  1439 @panic Sqlite 12 In _DEBUG mode - the extracted RMessage2 pointer is NULL.

  1440 */

  1441 static void FhExtractAndStore(TDes& aDbFileName)

  1442 	{

  1443 	TInt fhStartPos = aDbFileName.Locate(TChar(KFhSeparator));

  1444 	__ASSERT_DEBUG(fhStartPos == KFhMarkPos, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));

  1445 	//If this file name string contains file handles

  1446 	if(fhStartPos == KFhMarkPos)

  1447 		{

  1448 		//Extract from aDbFileName string RMessage2 object's address

  1449 		TLex lex(aDbFileName.Mid(fhStartPos + KFhMsgAddrPos, KFhMsgAddrLen));

  1450 		TUint32 addr;

  1451 		TInt err = lex.Val(addr, EHex);

  1452 		__ASSERT_DEBUG(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));

  1453 		if(err == KErrNone)

  1454 			{

  1455 			//Cast the address to RMessage2 pointer.

  1456 			const RMessage2* msg = reinterpret_cast <const RMessage2*> (addr);

  1457 			__ASSERT_DEBUG(msg != NULL, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));

  1458 			if(msg)

  1459 				{

  1460 				//Store the data from aDbFileName in the single COsLayerData instance.

  1461 				TBool readOnly = aDbFileName[fhStartPos + KFhRoPos] > '0';

  1462 				COsLayerData::Instance().StoreFhData(msg, readOnly);

  1463 				//Remove: read-only flag and RMessage2 object's address

  1464 				aDbFileName.Delete(fhStartPos + KFhRoPos, 1 + KFhMsgAddrLen);

  1465 				}

  1466 			}

  1467 		}

  1468 	}

  1470 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1471 /////////////////////       TDbFile class definition    ///////////////////////////////////////////////////////////////////////

  1472 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1474 /**

  1475 Initializes TDbFile data members with their default values.

  1476 */

  1477 inline TDbFile::TDbFile() :

  1478 	iFileBuf(KFileBufSize),

  1479 	iLockType(SQLITE_LOCK_NONE),

  1480 	iReadOnly(EFalse),

  1481 	iSectorSize(0),

  1482 	iDeviceCharacteristics(-1),

  1483 	iIsFileCreated(ETrue)

  1484 	{

  1485 #ifdef _SQLPROFILER

  1486 	iIsJournal = EFalse;

  1487 #endif

  1488 	pMethods = 0;

  1489 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TDBFILE_TDBFILE, "OS;0x%X;TDbFile::TDbFile", (TUint)this));

  1490 	}

  1492 /**

  1493 Casts the passed sqlite3_file pointer to a reference to the derived class - TDbFile&.

  1494 All sqlite3_file pointers passed to TFileIo methods are actually pointers to TDbFile instances.

  1495 So the cast is safe.

  1497 @param aDbFile A pointer to a sqlite3_file instance

  1499 @return A TDbFile reference.

  1500 @see TFileIo

  1501 @see TVfs

  1502 @see TDbFile

  1504 @panic Sqlite 20 In _DEBUG mode if aDbFile is NULL.

  1506 @internalComponent

  1507 */

  1508 static inline TDbFile& DbFile(sqlite3_file* aDbFile)

  1509 	{

  1510 	__ASSERT_DEBUG(aDbFile != 0, __SQLITEPANIC2(ESqliteOsPanicNullDbFilePtr));

  1511 	return *(static_cast <TDbFile*> (aDbFile));

  1512 	}

  1514 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1515 /////////////////////       TFileIo class definition    ///////////////////////////////////////////////////////////////////////

  1516 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1518 /**

  1519 SQLite OS porting layer API.

  1521 Closes the file referred by aDbFile parameter.

  1523 @param aDbFile A pointer to a TDbFile instance, than contains the file handle to be closed.

  1525 @return SQLITE_OK

  1527 @see TDbFile

  1528 */

  1529 /* static */ int TFileIo::Close(sqlite3_file* aDbFile)

  1530 	{

  1531 	TDbFile& dbFile = ::DbFile(aDbFile);

  1532 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_CLOSE1, "OS;0x%X;TFileIo::Close", (TUint)&dbFile));

  1533 	__OS_CALL(EOsFileClose, 0, 0);

  1534 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileClose], ::OsCallProfile(dbFile.iIsJournal, EOsFileClose), 0, 0, aDbFile, 0);

  1535 	__FS_CALL(EFsOpFileClose, 0);

  1536 	dbFile.iFileBuf.Close();

  1537 	return SQLITE_OK;

  1538 	}

  1540 /**

  1541 SQLite OS porting layer API.

  1543 Reads from the file referred by the aDbFile parameter.

  1545 @param aDbFile A pointer to a TDbFile instance, that contains the file handle to be read from.

  1546 @param aBuf Output parameter. The data read from the file will be copied there.

  1547 			The buffer size must be at least aAmt bytes.

  1548 @param aAmt The amount of data to be read form the file.

  1549 @param aOffset The offset in the file where the read operation should start.

  1551 @return SQLITE_IOERR_READ, 			The file read or seek operation has failed;

  1552 	    SQLITE_IOERR_SHORT_READ, 	The amount of the data read is less than aAmt;

  1553 	    SQLITE_IOERR_NOMEM,			An out of memory condition has occured;

  1554 	    SQLITE_OK,					The operation has completed successfully.

  1556 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  1557 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  1559 @see COsLayerData::SetOsErrorCode()

  1560 @see TDbFile

  1561 */

  1562 /* static */ int TFileIo::Read(sqlite3_file* aDbFile, void* aBuf, int aAmt, sqlite3_int64 aOffset)

  1563 	{

  1564 	TDbFile& dbFile = ::DbFile(aDbFile);

  1565 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_READ_ENTRY, "OS-Entry;0x%X;TFileIo::Read;aAmt=%d;aOffset=%lld", (TUint)&dbFile, aAmt, aOffset));

  1566 	__OS_CALL(EOsFileRead, 0, 0);

  1567 	__COUNTER_INCR(TheSqlSrvProfilerFileRead);

  1568 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileRead], ::OsCallProfile(dbFile.iIsJournal, EOsFileRead), aOffset, aAmt, aDbFile, 0);

  1569 	TPtr8 ptr((TUint8*)aBuf, 0, aAmt);

  1570 	TInt err = dbFile.iFileBuf.Read(aOffset, ptr);

  1571 	TInt cnt = ptr.Length();

  1572 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_READ);

  1573 	if(cnt != aAmt && (sqliteErr == SQLITE_OK || sqliteErr == SQLITE_IOERR_SHORT_READ))

  1574 		{

  1575 		Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);

  1576 		err = KErrEof;

  1577 		sqliteErr = SQLITE_IOERR_SHORT_READ;

  1578 		}

  1579 	COsLayerData::Instance().SetOsErrorCode(err);

  1580 	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));

  1581 	return sqliteErr;

  1582 	}

  1584 //Creates a temporary file in "\temp" subdirectory of osLayerData.iSysPrivDir directory.

  1585 //If the function fails, the temp file will be closed and deleted,

  1586 //the related Symbian OS error will be returned to the caller.

  1587 /* static */TInt TFileIo::DoCreateTempFile(TDbFile& aDbFile)

  1588     {

  1589     COsLayerData& osLayerData = COsLayerData::Instance();

  1590     //TParse2 is used in order to avoid the need of another TFileName stack based variable

  1591 	class TParse2 : public TParse

  1592 		{

  1593 	public:

  1594 		inline TFileName& FileName()

  1595 			{

  1596 			return static_cast <TFileName&> (NameBuf());

  1597 			}

  1598 		};

  1599 	TParse2 parse;

  1600 	(void)parse.Set(osLayerData.iSysPrivDir, 0, 0);//this call can't fail

  1601 	(void)parse.AddDir(KTempFileDir);//this call can't fail

  1602     __FS_CALL(EFsOpFileCreateTemp, 0);

  1603     TInt err = aDbFile.iFileBuf.Temp(osLayerData.iFs, parse.FullName(), parse.FileName(), EFileRead|EFileWrite|EDeleteOnClose);

  1604     if(err == KErrPathNotFound)

  1605         {

  1606         err = osLayerData.iFs.MkDirAll(parse.DriveAndPath());

  1607         if(err == KErrNone)

  1608             {

  1609             err = aDbFile.iFileBuf.Temp(osLayerData.iFs, parse.FullName(), parse.FileName(), EFileRead|EFileWrite|EDeleteOnClose);

  1610             }

  1611         }

  1612     if(err == KErrNone)

  1613         {

  1614         TInt recReadBufSize = -1;

  1615         err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(aDbFile, recReadBufSize);

  1616         if(err != KErrNone)

  1617             {

  1618             aDbFile.iFileBuf.Close();//With EDeleteOnClose flag set, the file will be deleted

  1619             }

  1620         else

  1621             {

  1622             (void)aDbFile.iFileBuf.SetReadAheadSize(aDbFile.iSectorSize, recReadBufSize);

  1623             aDbFile.iIsFileCreated = ETrue;

  1624             }

  1625         }

  1626     return err;

  1627     }

  1629 /**

  1630 SQLite OS porting layer API.

  1632 Writes to the file referred by the aDbFile parameter.

  1633 "Write beyond the end of the file" operations are allowed.

  1635 If the write operation is in the 1st db file page and there is a registered "free pages" callback

  1636 (TDbFile::iFreePageCallback) and the free pages count is above the defined value,

  1637 then the callback will be called.

  1639 If the file to be written to is a temp file, which is not created yet, then the file will be created.

  1641 @param aDbFile A pointer to a TDbFile instance, that contains the file handle to be written to.

  1642 @param aData The data to be written to the file. The buffer size must be at least aAmt bytes.

  1643 @param aAmt The amount of data to be written to the file.

  1644 @param aOffset The offset in the file where the write operation should start.

  1646 @return SQLITE_FULL,       	The file write or seek operation has failed.

  1647 							The disk is full;

  1648 	    SQLITE_IOERR_NOMEM,	An out of memory condition has occured;

  1649 	    SQLITE_OK,			The operation has completed successfully.

  1651 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  1652 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  1654 @see COsLayerData::SetOsErrorCode()

  1655 @see TDbFile

  1656 */

  1657 /* static */ int TFileIo::Write(sqlite3_file* aDbFile, const void* aData, int aAmt, sqlite3_int64 aOffset)

  1658 	{

  1659 	TDbFile& dbFile = ::DbFile(aDbFile);

  1660 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_ENTRY, "OS-Entry;0x%X;TFileIo::Write;aAmt=%d;aOffset=%lld", (TUint)&dbFile, aAmt, aOffset));

  1661 	__OS_CALL(EOsFileWrite, 0, 0);

  1662     __COUNTER_INCR(TheSqlSrvProfilerFileWrite);

  1663 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0);

  1664 	TInt err = KErrNone;

  1665 	if(!dbFile.iIsFileCreated)

  1666 	    {//Create a temp file if it has not been created.

  1667 	    err = TFileIo::DoCreateTempFile(dbFile);

  1668 	    }

  1669 	if(err != KErrNone)

  1670 	    {

  1671         COsLayerData::Instance().SetOsErrorCode(err);

  1672 		return ::Os2SqliteErr(err, SQLITE_FULL);

  1673 	    }

  1674 	err = KErrAccessDenied;

  1675 	if(!dbFile.iReadOnly)

  1676 		{

  1677 		TPtrC8 ptr((const TUint8*)aData, aAmt);

  1678 		err = dbFile.iFileBuf.Write(aOffset, ptr);

  1679 		}

  1680 	COsLayerData::Instance().SetOsErrorCode(err);

  1682 	const TInt KFreePageCountOffset = 36;//hard-coded constant. SQLite does not offer anything - a constant or #define.

  1683 	//The checks in the "if" bellow do:

  1684 	// - "err == KErrNone" - check the free page count only after a successful "write";

  1685 	// - "aOffset == 0"    - check the free page count only if the write operation affects the system page (at aOffset = 0);

  1686 	// - "aAmt >= (KFreePageCountOffset + sizeof(int))" - check the free page count only if the amount of bytes to be written

  1687 	//						 is more than the offset of the free page counter (othewrise the free page counter is not affected

  1688 	//						 by this write operation);

  1689 	// - "dbFile.iFreePageCallback.IsValid()" - check the free page count only if there is a valid callback;

  1690 	if(err == KErrNone  && aOffset == 0 && aAmt >= (KFreePageCountOffset + sizeof(int)) && dbFile.iFreePageCallback.IsValid())

  1691 		{

  1692 		const TUint8* ptr = static_cast <const TUint8*> (aData) + KFreePageCountOffset;

  1693 		TInt freePageCount = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];

  1694 		dbFile.iFreePageCallback.CheckAndCallback(freePageCount);

  1695 		}

  1697 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_FULL);

  1698 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_EXIT, "OS-Exit;0x%X;TFileIo::Write;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));

  1699 	return sqliteErr;

  1700 	}

  1702 /**

  1703 SQLite OS porting layer API.

  1705 Truncates the file referred by the aDbFile parameter.

  1707 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1708 @param aLength The new file size in bytes.

  1710 @return SQLITE_FULL,       	The disk is full;

  1711 		SQLITE_IOERR,		This is a read-only file.

  1712 	    					The file truncate operation has failed;

  1713 	    SQLITE_IOERR_NOMEM,	An out of memory condition has occured;

  1714 	    SQLITE_OK,			The operation has completed successfully.

  1716 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  1717 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  1719 @see COsLayerData::SetOsErrorCode()

  1720 @see TDbFile

  1721 */

  1722 /* static */ int TFileIo::Truncate(sqlite3_file* aDbFile, sqlite3_int64 aLength)

  1723 	{

  1724 	TDbFile& dbFile = ::DbFile(aDbFile);

  1725 	SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_TRUNCATE_ENTRY, "OS-Entry;0x%X;TFileIo::Truncate;aLength=%lld", (TUint)&dbFile, aLength));

  1726 	__OS_CALL(EOsFileTruncate, 0, 0);

  1727     __COUNTER_INCR(TheSqlSrvProfilerFileSetSize);

  1728 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileTruncate], ::OsCallProfile(dbFile.iIsJournal, EOsFileTruncate), aLength, 0, aDbFile, 0);

  1729 	if(dbFile.iReadOnly)

  1730 		{

  1731 		COsLayerData::Instance().SetOsErrorCode(KErrAccessDenied);

  1732   		return SQLITE_IOERR;

  1733 		}

  1734 	__FS_CALL(EFsOpFileSetSize, 0);

  1735 	TInt err = dbFile.iFileBuf.SetSize(aLength);

  1736 	COsLayerData::Instance().SetOsErrorCode(err);

  1737 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);

  1738 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_TRUNCATE_EXIT, "OS-Exit;0x%X;TFileIo::Truncate;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));

  1739 	return sqliteErr;

  1740 	}

  1742 /**

  1743 SQLite OS porting layer API.

  1745 Flushes the file referred by the aDbFile parameter.

  1747 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1749 @return SQLITE_IOERR,		This is a read-only file.

  1750 	    					The file flush operation has failed;

  1751 	    SQLITE_IOERR_NOMEM,	An out of memory condition has occured;

  1752 	    SQLITE_OK,			The operation has completed successfully.

  1754 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  1755 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  1757 @see COsLayerData::SetOsErrorCode()

  1758 @see TDbFile

  1759 */

  1760 /* static */int TFileIo::Sync(sqlite3_file* aDbFile, int /* aFlags */)

  1761 	{

  1762 	TDbFile& dbFile = ::DbFile(aDbFile);

  1763 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_SYNC_ENTRY, "OS-Entry;0x%X;TFileIo::Sync", (TUint)&dbFile));

  1764 	__OS_CALL(EOsFileSync, 0, 0);

  1765     __COUNTER_INCR(TheSqlSrvProfilerFileSync);

  1766 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileSync], ::OsCallProfile(dbFile.iIsJournal, EOsFileSync), 0, 0, aDbFile, 0);

  1767 	if(dbFile.iReadOnly)

  1768 		{

  1769 		COsLayerData::Instance().SetOsErrorCode(KErrAccessDenied);

  1770 		return SQLITE_IOERR;

  1771 		}

  1772 	__FS_CALL(EFsOpFileSync, 0);

  1773 	TInt err = dbFile.iFileBuf.Flush();

  1774 	COsLayerData::Instance().SetOsErrorCode(err);

  1775 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);

  1776 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_SYNC_EXIT, "OS-Exit;0x%X;TFileIo::Sync;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));

  1777 	return sqliteErr;

  1778 	}

  1780 /**

  1781 SQLite OS porting layer API.

  1783 Returns the size of the file referred by the aDbFile parameter.

  1785 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1786 @param aSize Output parameter. If the function completes successfully, the file size will be stored there.

  1788 @return SQLITE_IOERR,			The file size operation has failed;

  1789 	    SQLITE_IOERR_NOMEM,		An out of memory condition has occured;

  1790 	    SQLITE_OK,				The operation has completed successfully.

  1792 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  1793 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  1795 @see COsLayerData::SetOsErrorCode()

  1796 @see TDbFile

  1797 */

  1798 /* static */ int TFileIo::FileSize(sqlite3_file* aDbFile, sqlite3_int64* aSize)

  1799 	{

  1800 	TDbFile& dbFile = ::DbFile(aDbFile);

  1801 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_FILESIZE_ENTRY, "OS-Entry;0x%X;TFileIo::FileSize", (TUint)&dbFile));

  1802 	__OS_CALL(EOsFileFileSize, 0, 0);

  1803 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileSize), 0, 0, aDbFile, 0);

  1804 	__FS_CALL(EFsOpFileSize, 0);

  1805 	TInt err =  dbFile.iFileBuf.Size(*aSize);

  1806 	COsLayerData::Instance().SetOsErrorCode(err);

  1807 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);

  1808 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILESIZE_EXIT, "OS-Exit;0x%X;TFileIo::FileSize;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));

  1809 	return sqliteErr;

  1810 	}

  1812 /**

  1813 SQLite OS porting layer API.

  1815 Locks the file, referred by the aDbFile parameter, with the specified lock type.

  1816 Since this is a single-threaded OS porting layer implementation, the file is not actually locked - small

  1817 performance optimisation. The file lock type is stored for later use by the CheckReservedLock() call.

  1819 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1820 @param aLockType Lock type: SQLITE_LOCK_NONE, SQLITE_LOCK_SHARED, SQLITE_LOCK_RESERVED, SQLITE_LOCK_PENDING or

  1821 				 SQLITE_LOCK_EXCLUSIVE.

  1823 @return SQLITE_OK,	The operation has completed successfully.

  1825 @see TFileIo::CheckReservedLock()

  1826 @see TFileIo::Unlock()

  1828 @see TDbFile

  1829 */

  1830 /* static */ int TFileIo::Lock(sqlite3_file* aDbFile, int aLockType)

  1831 	{

  1832 	TDbFile& dbFile = ::DbFile(aDbFile);

  1833 	__OS_CALL(EOsFileLock, 0, 0);

  1834 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileLock), aLockType, 0, aDbFile, 0);

  1835 	//If there is already a lock of this type or more restrictive on the database file, do nothing.

  1836 	if(dbFile.iLockType >= aLockType)

  1837 		{

  1838 		return SQLITE_OK;

  1839 		}

  1840 	dbFile.iLockType = aLockType;

  1841 	return SQLITE_OK;

  1842 	}

  1844 /**

  1845 SQLite OS porting layer API.

  1847 Unlocks the file, referred by the aDbFile parameter.

  1848 Since this is a single-threaded OS porting layer implementation, the file never gets locked - small

  1849 performance optimisation. The Unlock() call only sets the stored file lock type with the aLockType value.

  1851 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1852 @param aLockType Lock type: SQLITE_LOCK_NONE, SQLITE_LOCK_SHARED, SQLITE_LOCK_RESERVED, SQLITE_LOCK_PENDING or

  1853 				 SQLITE_LOCK_EXCLUSIVE.

  1855 @return SQLITE_OK,	The operation has completed successfully.

  1857 @see TFileIo::CheckReservedLock()

  1858 @see TFileIo::Lock()

  1860 @see TDbFile

  1861 */

  1862 /* static */ int TFileIo::Unlock(sqlite3_file* aDbFile, int aLockType)

  1863 	{

  1864 	TDbFile& dbFile = ::DbFile(aDbFile);

  1865 	__OS_CALL(EOsFileUnlock, 0, 0);

  1866 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileUnlock], ::OsCallProfile(dbFile.iIsJournal, EOsFileUnlock), aLockType, 0, aDbFile, 0);

  1867 	dbFile.iLockType = aLockType;

  1868 	return SQLITE_OK;

  1869 	}

  1871 /**

  1872 SQLite OS porting layer API.

  1874 Checks if the file lock type is SQLITE_LOCK_RESERVED or bigger.

  1875 Since this is a single-threaded OS porting layer implementation, the file never gets locked - small

  1876 performance optimisation. The CheckReservedLock() call only checks if the stored file lock type

  1877 is bigger or equal than SQLITE_LOCK_RESERVED.

  1879 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1880 @param aResOut Output parameter. It should be set to 1 if the stored lock type is bigger or equal

  1881 							     than SQLITE_LOCK_RESERVED.

  1883 @return SQLITE_OK.

  1885 @see TFileIo::Lock()

  1886 @see TFileIo::Unlock()

  1888 @see TDbFile

  1889 */

  1890 /* static */ int TFileIo::CheckReservedLock(sqlite3_file* aDbFile, int *aResOut)

  1891 	{

  1892 	TDbFile& dbFile = ::DbFile(aDbFile);

  1893 	__OS_CALL(EOsFileCheckReservedLock, 0, 0);

  1894 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileCheckReservedLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileCheckReservedLock), 0, 0, aDbFile, 0);

  1895 	*aResOut = dbFile.iLockType >= SQLITE_LOCK_RESERVED ? 1 : 0;

  1896   	return SQLITE_OK;

  1897 	}

  1899 /**

  1900 SQLite OS porting layer API.

  1902 Performs an aOp operation on the file referred by the aDbFile parameter.

  1903 Since the only supported operation at the moment is SQLITE_FCNTL_LOCKSTATE, and the current lock type is stored as

  1904 a data memebr of TDbFile, the function implementation has been optimised - no file I/O calls. The stored file lock type

  1905 is retured if the operation is SQLITE_FCNTL_LOCKSTATE.

  1907 Note: The range of supported operations includes KSqlFcntlRegisterFreePageCallback now.

  1908       When the function is called with aOp = KSqlFcntlRegisterFreePageCallback, then a callback will be registered

  1909       and called when the number of the free pages goes above certain threshold.

  1911 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1912 @param aOp File operation type. Currently only SQLITE_FCNTL_LOCKSTATE is supported.

  1913 @param aArg An additional input/output parameter which purpose depends on the type of the current file operation.

  1914 			If the file operation is SQLITE_FCNTL_LOCKSTATE, then aArg is used as an output parameter, where

  1915 			the file lock type is stored.

  1916 			If the operation type is KSqlFcntlRegisterFreePageCallback, then aArg points to a TSqlFreePageCallback object,

  1917 			that contains the free page threshold and the callback.

  1919 @return SQLITE_ERROR,	Non-supported operation;

  1920 		SQLITE_OK,		The operation has completed successfully.

  1922 @see TDbFile

  1923 */

  1924 /* static */ int TFileIo::FileControl(sqlite3_file* aDbFile, int aOp, void* aArg)

  1925 	{

  1926 	TDbFile& dbFile = ::DbFile(aDbFile);

  1927 	SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_FILECONTROL_ENTRY, "OS-Entry;0x%X;TFileIo::FileControl;aOp=%d", (TUint)&dbFile, aOp));

  1928 	__OS_CALL(EOsFileFileControl, 0, 0);

  1929 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileControl], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileControl), aOp, 0, aDbFile, 0);

  1930 	TInt err = KErrNone;

  1931 	switch(aOp)

  1932 		{

  1933 		case SQLITE_FCNTL_LOCKSTATE:

  1934 			*(int*)aArg = dbFile.iLockType;

  1935 			break;

  1936 		case KSqlFcntlRegisterFreePageCallback:

  1937 			{

  1938 			err = KErrArgument;

  1939 			if(aArg)

  1940 				{

  1941 				TSqlFreePageCallback* rq = static_cast <TSqlFreePageCallback*> (aArg);

  1942 				if(rq->IsValid())

  1943 					{

  1944 					dbFile.iFreePageCallback = *rq;

  1945 					err = KErrNone;

  1946 					}

  1947 				}

  1948 			}

  1949 			break;

  1950 		default:

  1951 			err = KErrArgument;

  1952 			break;

  1953 		}

  1954 	COsLayerData::Instance().SetOsErrorCode(err);

  1955 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_ERROR);

  1956 	SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILECONTROL_EXIT, "OS-Exit;0x%X;TFileIo::FileControl;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));

  1957 	return sqliteErr;

  1958 	}

  1960 /**

  1961 SQLite OS porting layer API.

  1963 Retrieves the sector size of the media of the file referred by the aDbFile parameter.

  1964 Since the sector size never changes till the file is open, the function has been optimised - no file I/O calls.

  1965 The sector size is retrieved during the TVfs::Open() call and stored in TDbFile::iSectorSize. The SectorSize()

  1966 call returns the value of TDbFile::iSectorSize.

  1968 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1970 @return The sector size.

  1972 @panic Sqlite 19 In _DEBUG mode - TDbFile::iSectorSize is negative or 0 .

  1974 @see TDbFile

  1975 @see TVfs::Open()

  1976 */

  1977 /* static */ int TFileIo::SectorSize(sqlite3_file* aDbFile)

  1978 	{

  1979 	TDbFile& dbFile = ::DbFile(aDbFile);

  1980 	__OS_CALL(EOsFileSectorSize, 0, 0);

  1981 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileSectorSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileSectorSize), 0, 0, aDbFile, 0);

  1982 	__ASSERT_DEBUG(dbFile.iSectorSize > 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  1983 	return dbFile.iSectorSize;

  1984 	}

  1986 /**

  1987 SQLite OS porting layer API.

  1989 Retrieves the device characteristics of the device of the file referred by the aDbFile parameter.

  1990 Since the device characteristics never change till the file is open, the function has been optimised - no file I/O calls.

  1991 The device characteristics are retrieved during the TVfs::Open() call and stored in TDbFile::iDeviceCharacteristics.

  1992 The DeviceCharacteristics() call returns the value of TDbFile::iDeviceCharacteristics.

  1994 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  1996 @return A bit set containing the device characteristics.

  1998 @panic Sqlite 19 In _DEBUG mode - TDbFile::iDeviceCharacteristics is negative or 0 .

  2000 @see TDbFile

  2001 @see TVfs::Open()

  2002 */

  2003 /* static */ int TFileIo::DeviceCharacteristics(sqlite3_file* aDbFile)

  2004 	{

  2005 	TDbFile& dbFile = ::DbFile(aDbFile);

  2006 	__OS_CALL(EOsFileDeviceCharacteristics, 0, 0);

  2007 	__OSTIME_COUNTER(TheOsCallTicks[EOsFileDeviceCharacteristics], ::OsCallProfile(dbFile.iIsJournal, EOsFileDeviceCharacteristics), 0, 0, aDbFile, 0);

  2008 	__ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  2009 	return dbFile.iDeviceCharacteristics;

  2010 	}

  2012 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2013 ///////////////////////////////////       TVfs class definition     ///////////////////////////////////////////////////////////

  2014 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2017 /**

  2018 Opens a private secure database.

  2019 Actually the database file has been created or opened by the client's process.

  2020 This function only adopts the passed in aMsg parameter file handle.

  2022 @param aDbFile 		Output parameter, where the initialized file handle will be stored.

  2023 @param aMsg    		A reference to the current RMessage2 instance. Contains the file handle of the database created

  2024 					or opened by the client's process.

  2025 @param aReadOnly	True if the file is read-only.

  2027 @return KErrNone,          The operation has completed succesfully;

  2028 	    KErrNoMemory,      Out of memory condition has occured;

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

  2031 @see TDbFile

  2032 @see TVfs::Open()

  2033 */

  2034 /* static */ TInt TVfs::DoOpenFromHandle(TDbFile& aDbFile, const RMessage2& aMsg, TBool aReadOnly)

  2035 	{

  2036 	__FS_CALL(EFsOpFileAdopt, 0);

  2037 	TInt err = aDbFile.iFileBuf.AdoptFromClient(aMsg, KFhSessHandleIdx, KFhFileHandleIdx);

  2038 	if(err == KErrNone)

  2039 		{

  2040 		aDbFile.iReadOnly = aReadOnly;

  2041 		}

  2042 	return err;

  2043 	};

  2045 /**

  2046 Collects information about the drive referred by the aDriveNo parameter.

  2048 @param aFs			RFs instance.

  2049 @param aDriveNo     The drive about which an information will be collected.

  2050 @param aVolumeInfo	Output parameter. A reference to a TVolumeIOParamInfo object where the collected information will be stored.

  2052 @return KErrNone,          The operation has completed succesfully;

  2053 	    KErrNoMemory,      Out of memory condition has occured;

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

  2056 @see TVfs::Open()

  2057 */

  2058 /* static */ inline TInt TVfs::DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo)

  2059 	{

  2060 	__FS_CALL(EFsOpFsVolumeIoParam, 0);

  2061 	TInt err = aFs.VolumeIOParam(aDriveNo, aVolumeInfo);

  2062 	SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOGETVOLUMEIOPARAMINFO, "OS;0;TVfs::DoGetVolumeIoParamInfo;aDriveNo=%d;err=%d", aDriveNo, err));

  2063 	return err;

  2064 	}

  2066 //Maps disk sector sizes to SQLITE_IOCAP_ATOMIC<n> constants

  2068 struct TSqliteSectorSizeMap

  2069 	{

  2070 	TInt	iSectorSize;

  2071 	TInt	iSqliteSectorSizeConstant;

  2072 	};

  2074 //Used in TVfs::DoGetDeviceCharacteristics() to find which SQLITE_IOCAP_ATOMIC<n> constant should be used

  2075 //for the specified sector size

  2076 const TSqliteSectorSizeMap KSqliteSectorSizeMap[] =

  2077 	{

  2078 		{  512, SQLITE_IOCAP_ATOMIC512},

  2079 		{ 1024, SQLITE_IOCAP_ATOMIC1K},

  2080 		{ 2048, SQLITE_IOCAP_ATOMIC2K},

  2081 		{ 4096, SQLITE_IOCAP_ATOMIC4K},

  2082 		{ 8192, SQLITE_IOCAP_ATOMIC8K},

  2083 		{16384, SQLITE_IOCAP_ATOMIC16K},

  2084 		{32768, SQLITE_IOCAP_ATOMIC32K},

  2085 		{65536, SQLITE_IOCAP_ATOMIC64K}

  2086 	};

  2088 /**

  2089 Retrieves and returns in a bit set the device characteristics.

  2091 @param aDriveInfo	A TDriveInfo reference from which the device characteristics will be extracted.

  2092 @param aVolumeInfo	A TVolumeIOParamInfo reference from which the device characteristics will be extracted.

  2094 @return A bit set containing the device characteristics:

  2095 			SQLITE_IOCAP_SAFE_APPEND, SQLITE_IOCAP_ATOMIC, the atomic block size.

  2097 @see TVfs::DoGetVolumeIoParamInfo();

  2098 @see TVfs::Open()

  2099 */

  2100 /* static */ TInt TVfs::DoGetDeviceCharacteristics(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo)

  2101 	{

  2102 	TInt deviceCharacteristics = 0;

  2103 	if(aDriveInfo.iDriveAtt & (KDriveAttLocal | KDriveAttInternal))

  2104 		{

  2105 		deviceCharacteristics |= SQLITE_IOCAP_SAFE_APPEND;//Data written first, file size updated second

  2106 		}

  2107 	if(aDriveInfo.iDriveAtt & KDriveAttTransaction)

  2108 		{

  2109 		deviceCharacteristics |= SQLITE_IOCAP_ATOMIC;

  2110 		}

  2111 	for(TInt i=0;i<(sizeof(KSqliteSectorSizeMap)/sizeof(KSqliteSectorSizeMap[0]));++i)

  2112 		{

  2113 		if(KSqliteSectorSizeMap[i].iSectorSize == aVolumeInfo.iBlockSize)

  2114 			{

  2115 			deviceCharacteristics |= KSqliteSectorSizeMap[i].iSqliteSectorSizeConstant;

  2116 			break;

  2117 			}

  2118 		}

  2119 	return deviceCharacteristics;

  2120 	}

  2122 /**

  2123 Retrieves and returns the sector size of the drive referred by the aDriveInfo parameter.

  2124 The sector size must be a power of two.

  2125 The sector size is extracted only if aDriveInfo refers to a removable device, otherwise the

  2126 SQLITE_DEFAULT_SECTOR_SIZE value (512 bytes) will be used as a sector size.

  2128 @param aDriveInfo	A TDriveInfo reference.

  2129 @param aVolumeInfo	A TVolumeIOParamInfo reference.

  2131 @return The sector size of the drive referred by the aDriveInfo parameter.

  2133 @panic Sqlite 19 In _DEBUG mode - The sector size is negative, zero or is not a power of two.

  2135 @see TVfs::Open()

  2136 */

  2137 /* static */ TInt TVfs::DoGetSectorSize(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo)

  2138 	{

  2139 	//Initialize the sectorSize variable only if:

  2140 	// - aDriveInfo refers to a removable drive

  2141 	// - aVolumeInfo.iBlockSize > SQLITE_DEFAULT_SECTOR_SIZE;

  2142 	// - aVolumeInfo.iBlockSize is power of 2;

  2143 	TInt sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;

  2144 	if(aDriveInfo.iDriveAtt & KDriveAttRemovable)

  2145 		{

  2146 		if(aVolumeInfo.iBlockSize > SQLITE_DEFAULT_SECTOR_SIZE && (aVolumeInfo.iBlockSize & (aVolumeInfo.iBlockSize - 1)) == 0)

  2147 			{

  2148 			sectorSize = aVolumeInfo.iBlockSize;

  2149 			}

  2150 		}

  2151 	__ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  2152 	return sectorSize;

  2153 	}

  2155 /**

  2156 Retrieves in a bit set the device characteristics of the device of the file referred by the aDbFile parameter.

  2157 Retrieves the sector size of the drive of the file referred by the aDbFile parameter.

  2158 The sector size and the device characteristics will be stored in iSectorSize and iDeviceCharacteristics TDbFile data members.

  2159 The stored values will be used later by TFileIo::DeviceCharacteristics() and TFileIo::SectorSize().

  2161 @param aDbFile	Input/Output parameter. A TDriveInfo reference. The collected information will be stored in TDbDrive

  2162 				data members.

  2163 @param aRecReadBufSize Output parameter. The recommended buffer size for optimised reading performance.

  2165 @return KErrNone,          The operation has completed succesfully;

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

  2168 @panic Sqlite 19 In _DEBUG mode - TDbFile::iSectorSize has been already initialized.

  2169 @panic Sqlite 19 In _DEBUG mode - TDbFile::iDeviceCharacteristics has been already initialized.

  2171 @see TVfs::DoGetDeviceCharacteristics();

  2172 @see TVfs::DoGetSectorSize();

  2173 @see TVfs::Open()

  2174 @see TDbFile

  2175 @see TFileIo::DeviceCharacteristics()

  2176 @see TFileIo::SectorSize()

  2177 */

  2178 /* static */ TInt TVfs::DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize)

  2179 	{

  2180 	__ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  2181 	__ASSERT_DEBUG(aDbFile.iSectorSize <= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));

  2182 	TInt driveNo;

  2183 	TDriveInfo driveInfo;

  2184 	__FS_CALL(EFsOpFileDrive, 0);

  2185 	TInt err = aDbFile.iFileBuf.Drive(driveNo, driveInfo);

  2186 	if(err != KErrNone)

  2187 		{

  2188 		return err;

  2189 		}

  2190 	TVolumeIOParamInfo volumeInfo;

  2191 	err = TVfs::DoGetVolumeIoParamInfo(COsLayerData::Instance().iFs, driveNo, volumeInfo);

  2192 	if(err != KErrNone)

  2193 		{

  2194 		return err;

  2195 		}

  2196 	aDbFile.iDeviceCharacteristics = TVfs::DoGetDeviceCharacteristics(driveInfo, volumeInfo);

  2197 	aDbFile.iSectorSize = TVfs::DoGetSectorSize(driveInfo, volumeInfo);

  2198 	aRecReadBufSize = volumeInfo.iRecReadBufSize;

  2199 	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));

  2200 	return KErrNone;

  2201 	}

  2203 /**

  2204 SQLite OS porting layer API.

  2206 The behaviour of the RFile/RFile64::SetSize operation is not atomic for non-rugged drives.

  2207 When RFile/RFile64::SetSize() is called 2 operations occurs:-

  2209 1)The cluster chain of the file is updated.

  2210 2)The new file size is added to the file cache.

  2212 If a power loss occurs after a SetSize there is a chance that the cluster chain was updated

  2213 but the new file size is not yet flushed to the file. This puts the file into an inconsistent state.

  2214 This is most likely to occur in the journal file where the time between a SetSize and Flush can

  2215 be long.

  2217 For this reason this check is added when the file is opened to see if the end of the file can

  2218 be read straight away, if an error is returned then it is assumed that the SetSize has not be

  2219 completed previously. In this case the file is deleted and re-created.

  2221 @param aDbFile A pointer to a TDbFile instance, that contains the file handle.

  2222 @param aFname A string of 16-bit wide characters containing name of the file to be checked.

  2223 @param aFmode The mode in which the file is opened. These mode are documented in TFileMode.

  2225 @return KErrNone,          The operation has completed succesfully;

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

  2227 @see TFileMode

  2228 @see TVfs::Open()

  2229 @see TDbFile

  2230 */

  2231 /* static */ TInt TVfs::DoFileSizeCorruptionCheck(TDbFile& aDbFile, const TDesC& aFname, TInt aFmode)

  2232     {

  2233     const TInt KMinSize = 16;

  2234     TInt64 size;

  2235     TInt err = KErrNone ;

  2236     TBuf8<KMinSize> buf;

  2238     err = aDbFile.iFileBuf.Size(size);

  2239     if (err != KErrNone)

  2240         {

  2241         return err;

  2242         }

  2243     TBool IsMinFileSize = (size >= KMinSize);

  2245     if (IsMinFileSize)

  2246         {

  2247         err = aDbFile.iFileBuf.Read(size - KMinSize, buf);

  2248         }

  2250     if (err == KErrCorrupt || err == KErrEof || !IsMinFileSize)

  2251         {

  2252         COsLayerData& osLayerData = COsLayerData::Instance();

  2254         aDbFile.iFileBuf.Close();

  2255         __SQLITETRACE_OSEXPR(TInt err2 =) osLayerData.iFs.Delete(aFname);

  2256 		SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK1, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;size=%lld;err=%d;deleteErr=%d", (TUint)&aDbFile, size, err, err2));

  2257         err = aDbFile.iFileBuf.Create(osLayerData.iFs, aFname, aFmode);

  2258 		SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK2, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;createErr=%d", (TUint)&aDbFile, err));

  2259         }

  2260     return err;

  2261     }

  2263 /**

  2264 SQLite OS porting layer API.

  2266 Opens or creates a file which name is in the aFileName parameter.

  2267 If the function succeeds, the file handle and other related information will be stored in the place pointed by the

  2268 aDbFile parameter, a memory block of sizeof(TDbFile) size for which is allocated by the caller.

  2269 The function will also retrieve the sector size and the device characteristics and store them in aDbFile,

  2270 which is actually a TDbFile pointer, for later use.

  2272 @param aFileName Zero-terminated, UTF8 encoded file name.

  2273 				 If aFileName is NULL then a temporary file is created.

  2274 @param aDbFile Output parameter. The file handle and other related information will be stored there.

  2275 @param aFlags  "Open/Create" input flags:

  2276 					SQLITE_OPEN_DELETEONCLOSE,

  2277 					SQLITE_OPEN_READWRITE,

  2278 					SQLITE_OPEN_EXCLUSIVE,

  2279 					SQLITE_OPEN_CREATE

  2280 @param aOutFlags  "Open/Create" output flags:

  2281 					SQLITE_OPEN_READWRITE,

  2282 					SQLITE_OPEN_READONLY

  2284 @return SQLITE_CANTOPEN,    The aFileName parameter cannot be converted to UTF16.

  2285 							Any other file I/O error will also be reported as SQLITE_CANTOPEN;

  2286 	    SQLITE_IOERR_NOMEM,	An out of memory condition has occured;

  2287 	    SQLITE_OK,			The operation has completed successfully.

  2289 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  2290 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  2292 @see COsLayerData::SetOsErrorCode()

  2293 @see TDbFile

  2294 */

  2295 /* static */ int TVfs::Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags)

  2296 	{

  2297 	__OS_CALL(EOsVfsOpen, 0, 0);

  2298 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);

  2299 	COsLayerData& osLayerData = COsLayerData::Instance();

  2300 	new (aDbFile) TDbFile;

  2301 	TDbFile& dbFile = ::DbFile(aDbFile);

  2302     if(!aFileName)

  2303         {

  2304         //It is to create and open a temp file if aFileName is NULL. In this case,

  2305         //we will defer the file creation util it is needed.

  2306         dbFile.pMethods = &TheFileIoApi;

  2307         dbFile.iIsFileCreated = EFalse;

  2308         if(aOutFlags)

  2309             {

  2310             *aOutFlags = SQLITE_OPEN_READWRITE;

  2311             }

  2312 		osLayerData.SetOsErrorCode(KErrNone);

  2313         return SQLITE_OK;

  2314         }

  2315 	TFileName fname;

  2316     if(!::ConvertToUnicode(aFileName, fname))

  2317 		{

  2318         osLayerData.SetOsErrorCode(KErrBadName);

  2319         return SQLITE_CANTOPEN;

  2320     	}

  2321 	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));

  2322 	TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr;

  2323 	TInt err = KErrNone;

  2324 	if(fhStrType == EFhMainDbStr)

  2325 		{//Main db file, open from handle

  2326 		const RMessage2* msg;

  2327 		TBool readOnly;

  2328 		osLayerData.RetrieveAndResetFhData(msg, readOnly);

  2329 		err = msg != NULL ? TVfs::DoOpenFromHandle(dbFile, *msg, readOnly) : KErrGeneral;

  2330 		}

  2331 	else

  2332 		{

  2333 		if(fhStrType == EFhStr)

  2334 			{//Not the main db file. Remove invalid characters in the file name

  2335 			::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used

  2336 			}

  2337 		TInt fmode = EFileRead;

  2338 		if(aFlags & SQLITE_OPEN_READWRITE)

  2339 			{

  2340 			fmode |= EFileWrite;

  2341 			}

  2342 		if(aFlags & SQLITE_OPEN_EXCLUSIVE)

  2343 			{

  2344 			fmode |= EFileShareExclusive;

  2345 			}

  2346 		if(aFlags & SQLITE_OPEN_DELETEONCLOSE)

  2347 			{

  2348 			fmode |= EDeleteOnClose;

  2349 			}

  2350 		err = KErrAccessDenied;

  2351 		TInt prevErr = KErrNone;

  2352 		if(aFlags & SQLITE_OPEN_CREATE)

  2353 			{

  2354 			__FS_CALL(EFsOpFileCreate, 0);

  2355 			prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);

  2356 			}

  2357 		if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)

  2358 			{

  2359 			__FS_CALL(EFsOpFileOpen, 0);

  2360 			err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);

  2362 			if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))

  2363 				{

  2364 				err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);

  2365 				}

  2366 			}

  2367 		if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))

  2368 			{

  2369 			aFlags &= ~SQLITE_OPEN_READWRITE;

  2370 			aFlags |= SQLITE_OPEN_READONLY;

  2371 			fmode &= ~EFileWrite;

  2372 			__FS_CALL(EFsOpFileOpen, 0);

  2373 			err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);

  2374 			}

  2375 		if(err != KErrNone && prevErr == KErrAccessDenied)

  2376 			{

  2377 			err = KErrAccessDenied;

  2378 			}

  2379 		}

  2380 	TInt recReadBufSize = -1;

  2381 	if(err == KErrNone)

  2382 		{

  2383 		err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize);

  2384 		}

  2385 	osLayerData.SetOsErrorCode(err);

  2386 	if(err != KErrNone)

  2387 		{

  2388 		__FS_CALL(EFsOpFileClose, 0);

  2389 		dbFile.iFileBuf.Close();

  2390 		}

  2391 	else

  2392 		{

  2393 		dbFile.pMethods = &TheFileIoApi;

  2394 		if(fhStrType != EFhMainDbStr)

  2395 			{

  2396 			dbFile.iReadOnly = !(aFlags & SQLITE_OPEN_READWRITE);

  2397 			}

  2398 		if(aOutFlags)

  2399 			{

  2400 			*aOutFlags = dbFile.iReadOnly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_READWRITE;

  2401 			}

  2402 		(void)dbFile.iFileBuf.SetReadAheadSize(dbFile.iSectorSize, recReadBufSize);

  2403 		}

  2404 #ifdef _SQLPROFILER

  2405 	dbFile.iIsJournal = aFlags & KJournalFileTypeBitMask;

  2406 #endif

  2407 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_CANTOPEN);

  2408 	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));

  2409 	return sqliteErr;

  2410 	}

  2412 /**

  2413 SQLite OS porting layer API.

  2415 Deletes a file which name is in the aFileName parameter.

  2417 @param aFileName Zero-terminated, UTF8 encoded file name.

  2419 @return SQLITE_ERROR,    	The aFileName parameter cannot be converted to UTF16.

  2420 							The file name refers to a private secure database;

  2421 	    SQLITE_IOERR_NOMEM,	An out of memory condition has occured;

  2422 	    SQLITE_IOERR_DELETE,The delete file operation has failed;

  2423 	    SQLITE_OK,			The operation has completed successfully.

  2425 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  2426 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  2428 @see COsLayerData::SetOsErrorCode()

  2429 */

  2430 /* static */ int TVfs::Delete(sqlite3_vfs* aVfs, const char* aFileName, int /*aSyncDir*/)

  2431 	{

  2432 	__OS_CALL(EOsVfsDelete, 0, 0);

  2433 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsDelete], ::OsCallProfile(EFalse, EOsVfsDelete), 0, 0, 0, aFileName);

  2434 	COsLayerData& osLayerData = COsLayerData::Instance();

  2435 	TBuf<KMaxFileName + 1> fname;

  2436 	if(!::ConvertToUnicode(aFileName, fname))

  2437 		{

  2438 		osLayerData.SetOsErrorCode(KErrBadName);

  2439 		SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_DELETE1, "OS;0;TVfs::Delete;err=KErrBadName"));

  2440 		return SQLITE_ERROR;

  2441 		}

  2442 	SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE_ENTRY, "OS-Entry;0;TVfs::Delete;fname=%S", __SQLITEPRNSTR(fname)));

  2443 	TFhStrType fhStrType = FhStringProps(aFileName);

  2444 	if(fhStrType == EFhMainDbStr)

  2445 		{//Deleting files not in your own private data cage - not allowed!

  2446 		osLayerData.SetOsErrorCode(KErrPermissionDenied);

  2447 		SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE2, "OS;0;TVfs::Delete;err=KErrPermissionDenied;fname=%S", __SQLITEPRNSTR(fname)));

  2448 		return SQLITE_ERROR;

  2449 		}

  2450 	if(fhStrType == EFhStr)

  2451 		{

  2452 		::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used

  2453 		}

  2454 	__FS_CALL(EFsOpFileDelete, 0);

  2455 	TInt err = osLayerData.iFs.Delete(fname);

  2456 	osLayerData.SetOsErrorCode(err);

  2457 	TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_DELETE);

  2458 	SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DELETE_EXIT, "OS-Exit;0;TVfs::Delete;err=%d;sqliteErr=%d", err, sqliteErr));

  2459 	return sqliteErr;

  2460 	}

  2462 /**

  2463 SQLite OS porting layer API.

  2465 Retrieves an information about a file which name is in the aFileName parameter.

  2466 The requested information type can be: does the file exist, is the file read-only or read/write.

  2468 @param aFileName Zero-terminated, UTF8 encoded file name.

  2469 @param aFlags This parameter can be one of: SQLITE_ACCESS_READ, SQLITE_ACCESS_EXISTS or SQLITE_ACCESS_READWRITE.

  2470 @param aResOut Output parameter, set to 1 if the tested condition is true, 0 otherwise.

  2472 @return SQLITE_OK, 			The call has completed successfully,

  2473 		SQLITE_IOERR_NOMEM, An out of memory conditon has occured,

  2474 		SQLITE_IOERR_ACCESS,File I/O error;

  2476 If the function succeeds, COsLayerData::SetOsErrorCode() is called with KErrNone, otherwise COsLayerData::SetOsErrorCode() is called

  2477 with the reported by the OS API error. The stored error code will be used later by the SQLite API caller.

  2479 @see COsLayerData::SetOsErrorCode()

  2480 */

  2481 /* static */ int TVfs::Access(sqlite3_vfs* aVfs, const char* aFileName, int aFlags, int* aResOut)

  2482 	{

  2483 	__OS_CALL(EOsVfsAccess, 0, 0);

  2484 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsAccess], ::OsCallProfile(EFalse, EOsVfsAccess), aFlags, 0, 0, aFileName);

  2485 	COsLayerData& osLayerData = COsLayerData::Instance();

  2486 	TBuf<KMaxFileName + 1> fname;

  2487 	if(!::ConvertToUnicode(aFileName, fname))

  2488 		{

  2489 		osLayerData.SetOsErrorCode(KErrGeneral);

  2490 		SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS1, "OS;0;TVfs::Access;err=KErrGeneral"));

  2491 		return SQLITE_IOERR_ACCESS;

  2492 		}

  2493 	SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_ACCESS_ENTRY, "OS-Entry;0;TVfs::Access;fname=%S;aFlags=0x%X", __SQLITEPRNSTR(fname), (TUint)aFlags));

  2494 	TFhStrType fhStrType = ::FhStringProps(aFileName);

  2495 	if(fhStrType == EFhStr)

  2496 		{

  2497 		::FhConvertToFileName(fname, osLayerData.iSysPrivDir);//If fname does not have a path, iSysPrivDir will be used

  2498 		}

  2499 	TEntry entry;

  2500 	__FS_CALL(EFsOpFsEntry, 0);

  2501 	TInt err = osLayerData.iFs.Entry(fname, entry);

  2502 	if(aFlags == SQLITE_ACCESS_EXISTS && err == KErrNotFound)

  2503 		{

  2504 		osLayerData.SetOsErrorCode(KErrNone);

  2505 		*aResOut = 0;

  2506 		SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS_EXIT1, "OS-Exit;0;TVfs::Access;Exists-NoFound"));

  2507 		return SQLITE_OK;

  2508 		}

  2509 	if(err != KErrNone)

  2510 		{

  2511 		osLayerData.SetOsErrorCode(err);

  2512 		SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT2, "OS-Exit;0;TVfs::Access;err=%d", err));

  2513 		return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR_ACCESS;

  2514 		}

  2515 	*aResOut = 0;

  2516 	switch(aFlags)

  2517 		{

  2518 		case SQLITE_ACCESS_READ:

  2519 			*aResOut =  entry.IsReadOnly();

  2520 			break;

  2521 		case SQLITE_ACCESS_EXISTS:

  2522 			*aResOut = 1;

  2523 			break;

  2524 		case SQLITE_ACCESS_READWRITE:

  2525 			*aResOut = !entry.IsReadOnly();

  2526 			break;

  2527 		default:

  2528 			break;

  2529 		}

  2530 	osLayerData.SetOsErrorCode(KErrNone);

  2531 	SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT3, "OS-Exit;0;TVfs::Access;aResOut=%d", *aResOut));

  2532 	return SQLITE_OK;

  2533 	}

  2535 /**

  2536 SQLite OS porting layer API.

  2538 Accepts UTF8 encoded, zero-terminated file as an input argument in the aRelative parameter

  2539 and constructs the full file path in the aBuf output parameter.

  2541 If the format of aRelative argument is <[SID]FileName.[EXT]>, then the database file name will be

  2542 treated as a name of a secure database file which has to be created/opened in the server's private

  2543 directory on the system drive.

  2545 If the format of aRelative argument is <Drive:[SID]FileName.[EXT]>, then the database file name

  2546 will be treated as a name of a secure database file which has to be created/opened in the server's

  2547 private directory on <Drive:> drive.

  2549 If the format of aRelative argument is <Drive:\Path\FileName.[EXT]>, then the database file name

  2550 will be treated as a name of a non-secure database file in <Drive:\Path\> directory.

  2551 If aRelative contains file handles, then it will be treated as a name of a file belonging to server's

  2552 private data cage.

  2554 @param aRelative The input file name, zero-terminated, UTF8 encoded.

  2555 @param aBufLen The output buffer length.

  2556 @param aBuf Output buffer for the constructed full file name path. The allocated buffer length must be at least aBufLen bytes.

  2558 @return SQLITE_ERROR, The aRelative parameter is NULL or cannot be converted to UTF16;

  2559 		SQLITE_OK The operation has completed successfully.

  2560 */

  2561 /* static */ int TVfs::FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf)

  2562 	{

  2563 	__OS_CALL(EOsVfsFullPathName, 0, 0);

  2564 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsFullPathName], ::OsCallProfile(EFalse, EOsVfsFullPathName), aBufLen, 0, 0, aRelative);

  2565 	COsLayerData& osLayerData = COsLayerData::Instance();

  2566 	osLayerData.StoreFhData(NULL, EFalse);

  2567 	//Convert the received file name to UTF16

  2568 	TBuf<KMaxFileName + 1> fname;

  2569 	if(!::ConvertToUnicode(aRelative, fname))

  2570 		{

  2571 		SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME1, "OS;0;TVfs::FullPathName;err=SQLITE_ERROR"));

  2572 		return SQLITE_ERROR;

  2573 		}

  2574 	SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_FULLPATHNAME_ENTRY, "OS-Entry;0;TVfs::FullPathName;fname=%S;aBufLen=%d", __SQLITEPRNSTR(fname), aBufLen));

  2575 	//Zero-terminate the converted file name

  2576 	fname.Append(TChar(0));

  2577 	TParse parse;

  2578 	TFhStrType strType = ::FhStringProps(aRelative);//Detect string type - it may not be a real file name

  2579 	if(strType == EFhMainDbStr)

  2580 		{//The additonal information has to be extracted and fname reformatted, because SQLITE will

  2581 		 //use the returned full file name when making a decission to share the cache.

  2582 		::FhExtractAndStore(fname);

  2583 		(void)parse.Set(fname, 0, 0);//the file name has to be verified by the file server

  2584 		}

  2585 	else

  2586 		{

  2587 		(void)parse.Set(fname, &osLayerData.iSysPrivDir, 0);//If fname does not have a path, iSysPrivDir will be used

  2588 		}

  2589 	TPtr8 dest8(reinterpret_cast <TUint8*> (aBuf), aBufLen);

  2590 	if(!::ConvertFromUnicode(parse.FullName(), dest8))

  2591 		{//Zero the stored fh data, because it has been initialized by the FhExtractAndStore(fname) call (couple of lines above)

  2592 		osLayerData.StoreFhData(NULL, EFalse);

  2593 		SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT1, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_ERROR"));

  2594 		return SQLITE_ERROR;

  2595 		}

  2596 	SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT2, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_OK"));

  2597 	return SQLITE_OK;

  2598 	}

  2600 /**

  2601 SQLite OS porting layer API.

  2603 Generates a set of random numbers and stores them in the aBuf output parameter.

  2605 @param aBufLen The output buffer length.

  2606 @param aBuf Output buffer for the generated random numbers. The allocated buffer length must be at least aBufLen bytes.

  2608 @return The length of the used part of the output buffer.

  2609 */

  2610 /* static */ int TVfs::Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf)

  2611 	{

  2612 	__OS_CALL(EOsVfsRandomness, 0, 0);

  2613 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsRandomness], ::OsCallProfile(EFalse, EOsVfsRandomness), aBufLen, 0, 0, 0);

  2614 	COsLayerData& osLayerData = COsLayerData::Instance();

  2615 	const TInt KRandIterations = aBufLen / sizeof(int);

  2616 	for(TInt i=0;i<KRandIterations;++i)

  2617 		{

  2618 		TInt val = Math::Rand(osLayerData.iSeed);

  2619 		Mem::Copy(&aBuf[i * sizeof(int)], &val, sizeof(val));

  2620 		}

  2621 	return KRandIterations * sizeof(int);

  2622 	}

  2624 /**

  2625 SQLite OS porting layer API.

  2627 Sleeps for aMicrosec microseconds.

  2629 @param aMicrosec The sleep interval in microseconds.

  2631 @return The aMicrosec value.

  2632 */

  2633 /* static */ int TVfs::Sleep(sqlite3_vfs* aVfs, int aMicrosec)

  2634 	{

  2635 	__OS_CALL(EOsVfsSleep, 0, 0);

  2636 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsSleep], ::OsCallProfile(EFalse, EOsVfsSleep), aMicrosec, 0, 0, 0);

  2637 	User::AfterHighRes(TTimeIntervalMicroSeconds32(aMicrosec));

  2638 	return aMicrosec;

  2639 	}

  2641 /**

  2642 SQLite OS porting layer API.

  2644 Retrieves the current date and time.

  2646 @param aNow Output parameter, where the data and time value will be stored.

  2647 			SQLite processes all times and dates as Julian Day numbers and

  2648 			aNow parameter will contain the julian date and time.

  2650 @return 0.

  2651 */

  2652 /* static */ int TVfs::CurrentTime(sqlite3_vfs* aVfs, double* aNow)

  2653 	{

  2654 	__OS_CALL(EOsVfsCurrentTime, 0, 0);

  2655 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsCurrentTime], ::OsCallProfile(EFalse, EOsVfsCurrentTime), 0, 0, 0, 0);

  2656 	TTime now;

  2657 	now.UniversalTime();

  2658 	TDateTime date = now.DateTime();

  2659 	TInt year = date.Year();

  2660 	TInt month = date.Month() + 1;

  2661 	TInt day = date.Day() + 1;

  2663     //Calculate the Julian days

  2664 	TInt jd = day - 32076 +

  2665 	    1461*(year + 4800 + (month - 14)/12)/4 +

  2666 	    367*(month - 2 - (month - 14)/12*12)/12 -

  2667 	    3*((year + 4900 + (month - 14)/12)/100)/4;

  2669 	*aNow = jd;

  2671     // Add the fractional hours, mins and seconds

  2672 	*aNow += (date.Hour() + 12.0) / 24.0;

  2673 	*aNow += date.Minute() / 1440.0;

  2674 	*aNow += date.Second() / 86400.0;

  2676 	return 0;

  2677 	}

  2679 /**

  2680 SQLite OS porting layer API.

  2682 Retrieves a text description of the last OS error.

  2683 Note: the method has a default "no-op" implementation at the moment.

  2685 @return 0.

  2686 */

  2687 /* static */int TVfs::GetLastError(sqlite3_vfs* aVfs, int /*aBufLen*/, char* /*aBuf*/)

  2688 	{

  2689 	__OS_CALL(EOsVfsGetLastError, 0, 0);

  2690 	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsGetLastError], ::OsCallProfile(EFalse, EOsVfsGetLastError), 0, 0, 0, 0);

  2691 	return 0;

  2692 	}

  2694 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2695 ///////////////////////////////////       Memory allocation functions     /////////////////////////////////////////////////////

  2696 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2698 /**

  2699 SQLite OS porting layer API.

  2701 Memory allocation routine.

  2703 EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning

  2705 @internalComponent

  2706 */

  2707 extern "C" EXPORT_C void* sqlite3SymbianMalloc(size_t aSize)

  2708 	{

  2709 	__MEM_CALL(EMemOpAlloc, aSize, 0);

  2710 	return Allocator().Alloc(aSize);

  2711 	}

  2713 /**

  2714 SQLite OS porting layer API.

  2716 Memory reallocation routine.

  2718 EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning

  2720 @internalComponent

  2721 */

  2722 extern "C" EXPORT_C void* sqlite3SymbianRealloc(void* aPtr, size_t aSize)

  2723 	{

  2724 #ifdef _SQLPROFILER

  2725 	TInt size = Allocator().AllocLen(aPtr);

  2726 	__MEM_CALL(EMemOpRealloc, aSize, size);

  2727 #endif

  2728 	return Allocator().ReAlloc(aPtr, aSize);

  2729 	}

  2731 /**

  2732 SQLite OS porting layer API.

  2734 Memory free routine.

  2736 EXPORT_C required to match IMPORT_C in stdlib.h and avoid compiler warning

  2738 @internalComponent

  2739 */

  2740 extern "C" EXPORT_C void sqlite3SymbianFree(void* aPtr)

  2741 	{

  2742 #ifdef _SQLPROFILER

  2743 	TInt size = Allocator().AllocLen(aPtr);

  2744 	__MEM_CALL(EMemOpFree, size, 0);

  2745 #endif

  2746 	Allocator().Free(aPtr);

  2747 	}

  2749 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2750 ///////////////////////////////////       SQLite init/release functions     ///////////////////////////////////////////////////

  2751 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2753 /**

  2754 Registers the single sqlite3_vfs instance ("TheVfsApi" global variable) by calling sqlite3_vfs_register()

  2755 */

  2756 extern "C" int sqlite3_os_init(void)

  2757 	{

  2758 	return sqlite3_vfs_register(&TheVfsApi, 1);//"1" means - make TheVfsApi to be the default VFS object

  2759 	}

  2761 /**

  2762 Unregisters the single sqlite3_vfs instance ("TheVfsApi" global variable) by calling sqlite3_vfs_unregister()

  2763 */

  2764 extern "C" int sqlite3_os_end(void)

  2765 	{

  2766 	return sqlite3_vfs_unregister(&TheVfsApi);

  2767 	}

  2769 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2771 #endif//SQLITE_OS_SYMBIAN

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--