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

equal deleted inserted replaced

-:d6ef85bc5971
+:7a522c0700d3
 	EPanicInvalidSectorSize		=18,
 	EPanicInternalError			=19,
 	EPanicNullDbFilePtr			=20,
 	EPanicFastCounterFreq		=21
 	};
+//Bit-mask constant. If xOpen()'s "aFlag" parameter contains one of these bits set, then the the file top be
+//opened or created is a journal file.
+const TUint KJournalFileTypeBitMask = SQLITE_OPEN_MAIN_JOURNAL | SQLITE_OPEN_TEMP_JOURNAL | SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_MASTER_JOURNAL;
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #ifdef _SQLPROFILER
 	//the function was used on the main database file
 	TOsCallProfile TheOsCallMProfile[EOsOpLast] =
 		{
 		TOsCallProfile('M', "CL"), TOsCallProfile('M', "RD"), TOsCallProfile('M', "WR"), TOsCallProfile('M', "TR"),
 		TOsCallProfile('M', "SY"), TOsCallProfile('M', "FS"), TOsCallProfile('M', "LK"), TOsCallProfile('M', "UL"),
-		TOsCallProfile('M', "CL"), TOsCallProfile('M', "FC"), TOsCallProfile('M', "SS"), TOsCallProfile('M', "DC"),
+		TOsCallProfile('M', "RL"), TOsCallProfile('M', "FC"), TOsCallProfile('M', "SS"), TOsCallProfile('M', "DC"),
 		TOsCallProfile('M', "OP"), TOsCallProfile('M', "DE"), TOsCallProfile('M', "AC"), TOsCallProfile('M', "FN"),
 		TOsCallProfile('M', "RN"), TOsCallProfile('M', "SL"), TOsCallProfile('M', "CT"), TOsCallProfile('M', "LE")
 		};
 	//An array of TOsCallProfile entries, each entry keeps the profile of a specifc OS porting layer function, when
 	//the function was used on the journal file
 	TOsCallProfile TheOsCallJProfile[EOsOpLast] =
 		{
 		TOsCallProfile('J', "CL"), TOsCallProfile('J', "RD"), TOsCallProfile('J', "WR"), TOsCallProfile('J', "TR"),
 		TOsCallProfile('J', "SY"), TOsCallProfile('J', "FS"), TOsCallProfile('J', "LK"), TOsCallProfile('J', "UL"),
-		TOsCallProfile('J', "CL"), TOsCallProfile('J', "FC"), TOsCallProfile('J', "SS"), TOsCallProfile('J', "DC"),
+		TOsCallProfile('J', "RL"), TOsCallProfile('J', "FC"), TOsCallProfile('J', "SS"), TOsCallProfile('J', "DC"),
 		TOsCallProfile('J', "OP"), TOsCallProfile('J', "DE"), TOsCallProfile('J', "AC"), TOsCallProfile('J', "FN"),
 		TOsCallProfile('J', "RN"), TOsCallProfile('J', "SL"), TOsCallProfile('J', "CT"), TOsCallProfile('J', "LE")
 		};
 	//The main class for the OS porting layer call profiles.
 	public:
 		//aOsCallTicksEntryRef - a reference to the related TheOsCallTicks[] entry;
 		//aProfileRef          - a reference to the related TOsCallProfile object - TheOsCallMProfile[] or TheOsCallJProfile[] entry;
 		//aOffset              - file offset in bytes;
 		//aBytes               - amount of bytes to be read/written;
-		TOsCallCounter(TInt64& aOsCallTicksEntryRef, TOsCallProfile& aOsCallProfileRef, TInt64 aOffset, TInt aBytes) :
+		//aOptional			   - might be NULL. Used to print out the name of the file being processed.
+		TOsCallCounter(TInt64& aOsCallTicksEntryRef, TOsCallProfile& aOsCallProfileRef, TInt64 aOffset, TInt aBytes,
+				       const sqlite3_file* aHandle, const char* aOptional) :
 			iOsCallTicksEntryRef(aOsCallTicksEntryRef),
 			iOsCallProfileRef(aOsCallProfileRef),
 			iOffset(aOffset),
-			iBytes(aBytes)
+			iBytes(aBytes),
+			iHandle((TUint)aHandle),
+			iOptional((const TUint8*)aOptional)
 			{
 			if(TheOsCallTimeProfileEnabled)
 				{
 				iStartTicks = User::FastCounter();
 				}
 					{
 					++TheOpCounter;
 					++iOsCallProfileRef.iCallCounter;
 					iOsCallProfileRef.iTicksTotal += diffTicks;
 					iOsCallProfileRef.iBytesTotal += iBytes;
-					//                 1    2 3   4  5  6   7   8   9   10
+					TFileName fname;
-					RDebug::Print(_L("'%c','%c%c',%d,%d,%ld,%d,%ld,%ld,%ld\n"),
+					if(iOptional)
-						iOsCallProfileRef.iType, 			//1
+						{
-						iOsCallProfileRef.iIdentifier[0], 	//2
+						TPtrC8 fn8(iOptional);
-						iOsCallProfileRef.iIdentifier[1],	//3
+						fname.Copy(fn8);
-						TheOpCounter, 						//4
+						}
-						iOsCallProfileRef.iCallCounter, 	//5
+					//                                           0    1  2 3  4  5  6   7  8   9   10 11
-						iOffset, 							//6
+					RDebug::Print(_L("[SQL-OS]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬%c¬%c%c¬%d¬%d¬%ld¬%d¬%ld¬%ld¬%ld¬%S\n"),
-						iBytes, 							//7
+															//[SQL-OS]
-						diffTicks, 							//8
+															//Handle
-						iOsCallProfileRef.iBytesTotal, 		//9
+															//Time from start, microseconds
-						iOsCallProfileRef.iTicksTotal);		//10
+															//Subtype
+															//IPC sequence counter
+															//IPC call name
+					    iHandle,							//sqlite3_file*
+						iOsCallProfileRef.iType, 			//1 - main or journal file
+						iOsCallProfileRef.iIdentifier[0], 	//2 - 1st letter - operation type
+						iOsCallProfileRef.iIdentifier[1],	//3 - 2nd letter - operation type
+						TheOpCounter, 						//4 - Operation counter
+						iOsCallProfileRef.iCallCounter, 	//5 - This call type counter
+						iOffset, 							//6 - File offset
+						iBytes, 							//7 - Data, bytes
+						diffTicks, 							//8 - Ticks
+						iOsCallProfileRef.iBytesTotal, 		//9 - Data total, bytes
+						iOsCallProfileRef.iTicksTotal,		//10- Ticks total
+						&fname);							//11- File name
 					}
 				}
 			}
 	private:
 		TInt64&			iOsCallTicksEntryRef;
 		TOsCallProfile&	iOsCallProfileRef;
 		TInt64			iOffset;
 		TInt			iBytes;
 		TUint32 		iStartTicks;
+		TUint			iHandle;
+		const TUint8*	iOptional;
 		};
 	inline TOsCallProfile& OsCallProfile(TBool aType, TInt aIndex)
 		{
 		return aType ? TheOsCallJProfile[aIndex] : TheOsCallMProfile[aIndex];
 		}
-#	define __OSTIME_COUNTER(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes)	TOsCallCounter osCallCounter(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes)
+#	define __OSTIME_COUNTER(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes, aHandle, aOpt)	TOsCallCounter osCallCounter(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes, aHandle, aOpt)
 #else //_SQLPROFILER
 #   define __COUNTER_INCR(counter) void(0)
 #	define __MEM_CALL(aMemOpType, a1, a2) void(0)
 #	define __OS_CALL(aOpType, a1, a2) void(0)
-#	define __OSTIME_COUNTER(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes)	void(0)
+#	define __OSTIME_COUNTER(aOsCallTicksRef, aOsCallProfileRef, aOffset, aBytes, aHandle, aOpt)	void(0)
 #endif//_SQLPROFILER
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////       Profiling                          ////////////////////////////////////////////////////////////////
 	{
 	if(aFileName)
 		{
 		wchar_t* dest = reinterpret_cast <wchar_t*> (const_cast <TUint16*> (aFileNameDestBuf.Ptr()));
 		TInt len = mbstowcs(dest, aFileName, aFileNameDestBuf.MaxLength());
+		__ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError));
 		//If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small.
-		if(len > 0 && len < aFileNameDestBuf.MaxLength())
+		if(len < aFileNameDestBuf.MaxLength())
 			{
 			aFileNameDestBuf.SetLength(len);
 			return ETrue;
 			}
 		}
 static TBool ConvertFromUnicode(const TDesC& aFileName, TDes8& aFileNameDestBuf)
 	{
 	char* dest = reinterpret_cast <char*> (const_cast <TUint8*> (aFileNameDestBuf.Ptr()));
 	const wchar_t* src = reinterpret_cast <const wchar_t*> (aFileName.Ptr());
 	TInt len = wcstombs(dest, src, aFileNameDestBuf.MaxLength());
+	__ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError));
 	//If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small.
-	if(len > 0 && len < aFileNameDestBuf.MaxLength())
+	if(len < aFileNameDestBuf.MaxLength())
 		{
 		aFileNameDestBuf.SetLength(len);
 		return ETrue;
 		}
 	return EFalse;
 /* static */ int TFileIo::Close(sqlite3_file* aDbFile)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileClose, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileClose], ::OsCallProfile(dbFile.iIsJournal, EOsFileClose), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileClose], ::OsCallProfile(dbFile.iIsJournal, EOsFileClose), 0, 0, aDbFile, 0);
 	__FS_CALL(EFsOpFileClose, 0);
 	dbFile.iFileBuf.Close();
 	if(dbFile.iFullName)
 		{//"iFullName" will not be NULL only when TVfs::Open() is called with SQLITE_OPEN_DELETEONCLOSE flag.
 		 //That means - SQlite expects the file to be deleted after the file close operation.
 	SQLUTRACE_PROFILER(aDbFile);
 	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileRead, aAmt, aOffset));
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileRead, 0, 0);
 	__COUNTER_INCR(TheSqlSrvProfilerFileRead);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileRead], ::OsCallProfile(dbFile.iIsJournal, EOsFileRead), aOffset, aAmt);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileRead], ::OsCallProfile(dbFile.iIsJournal, EOsFileRead), aOffset, aAmt, aDbFile, 0);
 	TPtr8 ptr((TUint8*)aBuf, 0, aAmt);
 	TInt err = dbFile.iFileBuf.Read(aOffset, ptr);
 	TInt cnt = ptr.Length();
 	TInt sqliteErr = SQLITE_IOERR_READ;
 	switch(err)
 	SQLUTRACE_PROFILER(aDbFile);
 	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileWrite, aAmt, aOffset));
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileWrite, 0, 0);
 __COUNTER_INCR(TheSqlSrvProfilerFileWrite);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0);
 	TInt err = KErrAccessDenied;
 	if(!dbFile.iReadOnly)
 		{
 		TPtrC8 ptr((const TUint8*)aData, aAmt);
 		err = dbFile.iFileBuf.Write(aOffset, ptr);
 	SQLUTRACE_PROFILER(aDbFile);
 	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileTruncate, aLength));
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileTruncate, 0, 0);
 __COUNTER_INCR(TheSqlSrvProfilerFileSetSize);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileTruncate], ::OsCallProfile(dbFile.iIsJournal, EOsFileTruncate), aLength, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileTruncate], ::OsCallProfile(dbFile.iIsJournal, EOsFileTruncate), aLength, 0, aDbFile, 0);
 	if(dbFile.iReadOnly)
 		{
 		COsLayerData::Instance().SetOsErrorCode(KErrAccessDenied);
 		return SQLITE_IOERR;
 		}
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileSync, 0, 0);
 __COUNTER_INCR(TheSqlSrvProfilerFileSync);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileSync], ::OsCallProfile(dbFile.iIsJournal, EOsFileSync), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileSync], ::OsCallProfile(dbFile.iIsJournal, EOsFileSync), 0, 0, aDbFile, 0);
 	if(dbFile.iReadOnly)
 		{
 		COsLayerData::Instance().SetOsErrorCode(KErrAccessDenied);
 		return SQLITE_IOERR;
 		}
 /* static */ int TFileIo::FileSize(sqlite3_file* aDbFile, sqlite3_int64* aSize)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileFileSize, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileSize), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileSize), 0, 0, aDbFile, 0);
 	__FS_CALL(EFsOpFileSize, 0);
 	TInt err =  dbFile.iFileBuf.Size(*aSize);
 	COsLayerData::Instance().SetOsErrorCode(err);
 	if(err == KErrNone)
 		{
 /* static */ int TFileIo::Lock(sqlite3_file* aDbFile, int aLockType)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileLock, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileLock), aLockType, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileLock), aLockType, 0, aDbFile, 0);
 	//If there is already a lock of this type or more restrictive on the database file, do nothing.
 	if(dbFile.iLockType >= aLockType)
 		{
 		return SQLITE_OK;
 		}
 /* static */ int TFileIo::Unlock(sqlite3_file* aDbFile, int aLockType)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileUnlock, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileUnlock], ::OsCallProfile(dbFile.iIsJournal, EOsFileUnlock), aLockType, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileUnlock], ::OsCallProfile(dbFile.iIsJournal, EOsFileUnlock), aLockType, 0, aDbFile, 0);
 	dbFile.iLockType = aLockType;
 	return SQLITE_OK;
 	}
 /**
 /* static */ int TFileIo::CheckReservedLock(sqlite3_file* aDbFile, int *aResOut)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileCheckReservedLock, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileCheckReservedLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileCheckReservedLock), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileCheckReservedLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileCheckReservedLock), 0, 0, aDbFile, 0);
 	*aResOut = dbFile.iLockType >= SQLITE_LOCK_RESERVED ? 1 : 0;
 	return SQLITE_OK;
 	}
 /**
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileFileCtr, aOp));
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileFileControl, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileControl], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileControl), aOp, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileControl], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileControl), aOp, 0, aDbFile, 0);
 	TInt err = KErrNone;
 	switch(aOp)
 		{
 		case SQLITE_FCNTL_LOCKSTATE:
 			*(int*)aArg = dbFile.iLockType;
 /* static */ int TFileIo::SectorSize(sqlite3_file* aDbFile)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileSectorSize, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileSectorSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileSectorSize), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileSectorSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileSectorSize), 0, 0, aDbFile, 0);
 	__ASSERT_DEBUG(dbFile.iSectorSize > 0, User::Panic(KPanicCategory, EPanicInternalError));
 	if(dbFile.iSectorSize > 0)
 		{
 		return dbFile.iSectorSize;
 		}
 /* static */ int TFileIo::DeviceCharacteristics(sqlite3_file* aDbFile)
 	{
 	SQLUTRACE_PROFILER(aDbFile);
 	TDbFile& dbFile = ::DbFile(aDbFile);
 	__OS_CALL(EOsFileDeviceCharacteristics, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsFileDeviceCharacteristics], ::OsCallProfile(dbFile.iIsJournal, EOsFileDeviceCharacteristics), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsFileDeviceCharacteristics], ::OsCallProfile(dbFile.iIsJournal, EOsFileDeviceCharacteristics), 0, 0, aDbFile, 0);
 	__ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, User::Panic(KPanicCategory, EPanicInternalError));
 	if(dbFile.iDeviceCharacteristics >= 0)
 		{
 		return dbFile.iDeviceCharacteristics;
 		}
 		}
 	if(aDriveInfo.iDriveAtt & KDriveAttTransaction)
 		{
 		deviceCharacteristics |= SQLITE_IOCAP_ATOMIC;
 		}
-	if(aVolumeInfo.iBlockSize >= SQLITE_DEFAULT_SECTOR_SIZE && (aVolumeInfo.iBlockSize & (aVolumeInfo.iBlockSize - 1)) == 0)
+	switch(aVolumeInfo.iBlockSize)
 		{
-		switch(aVolumeInfo.iBlockSize)
+		case 512:
-			{
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC512;
-			case 512:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC512;
+		case 1024:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC1K;
-			case 1024:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC1K;
+		case 2048:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC2K;
-			case 2048:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC2K;
+		case 4096:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC4K;
-			case 4096:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC4K;
+		case 8192:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC8K;
-			case 8192:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC8K;
+		case 16384:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC16K;
-			case 16384:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC16K;
+		case 32768:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC32K;
-			case 32768:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC32K;
+		case 65536:
-				break;
+			deviceCharacteristics |= SQLITE_IOCAP_ATOMIC64K;
-			case 65536:
+			break;
-				deviceCharacteristics |= SQLITE_IOCAP_ATOMIC64K;
+		default:
-				break;
+			//Do nothing. deviceCharacteristics was initialized with 0 at the beginning of the function body.
-			default:
+			break;
-				//Do nothing. deviceCharacteristics was initialized with 0 at the beginning of the function body.
-				break;
-			}
 		}
 	return deviceCharacteristics;
 	}
 /**
 */
 /* static */ int TVfs::Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsOpen, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);
 	COsLayerData& osLayerData = COsLayerData::Instance();
 	TFileName fname;
 	if(aFileName && !::ConvertToUnicode(aFileName, fname))
 		{
 		osLayerData.SetOsErrorCode(KErrBadName);
 			if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
 				{
 				__FS_CALL(EFsOpFileOpen, 0);
 				err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
-				if(err == KErrNone && ((aFlags & SQLITE_OPEN_MAIN_JOURNAL) || (aFlags & SQLITE_OPEN_TEMP_JOURNAL) ||
+				if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
-(aFlags & SQLITE_OPEN_SUBJOURNAL) || (aFlags & SQLITE_OPEN_MASTER_JOURNAL)))
 				    {
 err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
 				    }
 				}
 			if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
 			*aOutFlags = dbFile.iReadOnly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_READWRITE;
 			}
 		(void)dbFile.iFileBuf.SetReadAheadSize(dbFile.iSectorSize, recReadBufSize);
 		}
 #ifdef _SQLPROFILER
-	dbFile.iIsJournal = (aFlags & SQLITE_OPEN_MAIN_JOURNAL) || (aFlags & SQLITE_OPEN_TEMP_JOURNAL) ||
+	dbFile.iIsJournal = aFlags & KJournalFileTypeBitMask;
-						(aFlags & SQLITE_OPEN_SUBJOURNAL) || (aFlags & SQLITE_OPEN_MASTER_JOURNAL);
 #endif
 	return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_CANTOPEN);
 	}
 /**
 */
 /* static */ int TVfs::Delete(sqlite3_vfs* aVfs, const char* aFileName, int /*aSyncDir*/)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsDelete, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsDelete], ::OsCallProfile(EFalse, EOsVfsDelete), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsDelete], ::OsCallProfile(EFalse, EOsVfsDelete), 0, 0, 0, aFileName);
 	COsLayerData& osLayerData = COsLayerData::Instance();
 	TBuf<KMaxFileName + 1> fname;
 	if(!::ConvertToUnicode(aFileName, fname))
 		{
 		osLayerData.SetOsErrorCode(KErrBadName);
 */
 /* static */ int TVfs::Access(sqlite3_vfs* aVfs, const char* aFileName, int aFlags, int* aResOut)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsAccess, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsAccess], ::OsCallProfile(EFalse, EOsVfsAccess), aFlags, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsAccess], ::OsCallProfile(EFalse, EOsVfsAccess), aFlags, 0, 0, aFileName);
 	COsLayerData& osLayerData = COsLayerData::Instance();
 	TBuf<KMaxFileName + 1> fname;
 	if(!::ConvertToUnicode(aFileName, fname))
 		{
 		osLayerData.SetOsErrorCode(KErrGeneral);
 */
 /* static */ int TVfs::FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsFullPathName, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsFullPathName], ::OsCallProfile(EFalse, EOsVfsFullPathName), aBufLen, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsFullPathName], ::OsCallProfile(EFalse, EOsVfsFullPathName), aBufLen, 0, 0, aRelative);
 	COsLayerData& osLayerData = COsLayerData::Instance();
 	osLayerData.StoreFhData(NULL, EFalse);
 	//Convert the received file name to UTF16
 	TBuf<KMaxFileName + 1> fname;
 	if(!::ConvertToUnicode(aRelative, fname))
 */
 /* static */ int TVfs::Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsRandomness, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsRandomness], ::OsCallProfile(EFalse, EOsVfsRandomness), aBufLen, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsRandomness], ::OsCallProfile(EFalse, EOsVfsRandomness), aBufLen, 0, 0, 0);
 	COsLayerData& osLayerData = COsLayerData::Instance();
 	const TInt KRandIterations = aBufLen / sizeof(int);
 	for(TInt i=0;i<KRandIterations;++i)
 		{
 		TInt val = Math::Rand(osLayerData.iSeed);
 */
 /* static */ int TVfs::Sleep(sqlite3_vfs* aVfs, int aMicrosec)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsSleep, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsSleep], ::OsCallProfile(EFalse, EOsVfsSleep), aMicrosec, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsSleep], ::OsCallProfile(EFalse, EOsVfsSleep), aMicrosec, 0, 0, 0);
 	User::AfterHighRes(TTimeIntervalMicroSeconds32(aMicrosec));
 	return aMicrosec;
 	}
 /**
 */
 /* static */ int TVfs::CurrentTime(sqlite3_vfs* aVfs, double* aNow)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsCurrentTime, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsCurrentTime], ::OsCallProfile(EFalse, EOsVfsCurrentTime), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsCurrentTime], ::OsCallProfile(EFalse, EOsVfsCurrentTime), 0, 0, 0, 0);
 	TTime now;
 	now.UniversalTime();
 	TDateTime date = now.DateTime();
 	TInt year = date.Year();
 	TInt month = date.Month() + 1;
 */
 /* static */int TVfs::GetLastError(sqlite3_vfs* aVfs, int /*aBufLen*/, char* /*aBuf*/)
 	{
 	SQLUTRACE_PROFILER(aVfs);
 	__OS_CALL(EOsVfsGetLastError, 0, 0);
-	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsGetLastError], ::OsCallProfile(EFalse, EOsVfsGetLastError), 0, 0);
+	__OSTIME_COUNTER(TheOsCallTicks[EOsVfsGetLastError], ::OsCallProfile(EFalse, EOsVfsGetLastError), 0, 0, 0, 0);
 	return 0;
 	}
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////       Memory allocation functions     /////////////////////////////////////////////////////

changeset 28	7a522c0700d3
parent 17	55f2396f6d25
child 29	cce6680bbf1c