1 // Copyright (c) 1998-2009 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 the License "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 // e32\memmodel\epoc\putils.cpp

    15 // EPOC implementation of the ROM related parts of the system

    16 // 

    17 //

    18 

    19 #include "plat_priv.h"

    20 #include <e32uid.h>

    21 #include "execs.h"

    22 #include "cache_maintenance.h"

    23 

    24 _LIT(KKernelFullPathNameSysBin,"z:\\sys\\bin\\ekern.exe");

    25 

    26 #ifdef __MARM__

    27 #define	CHECK_ROM_ENTRY_POINT(a)	__ASSERT_ALWAYS( ((a).iFlags & KRomImageEptMask) == KRomImageEpt_Eka2, PP::Panic(PP::EUnsupportedOldBinary) )

    28 #else

    29 #define	CHECK_ROM_ENTRY_POINT(a)

    30 #endif

    31 

    32 void PP::Panic(TPlatPanic aPanic)

    33 	{

    34 	Kern::Fault("PLAT",aPanic);

    35 	}

    36  

    37 void PP::InitSuperPageFromRom(TLinAddr aRomHeader, TLinAddr aSuperPage)

    38 	{

    39 	RomHeaderAddress = aRomHeader;

    40 	SuperPageAddress = aSuperPage;

    41 

    42 	TInt j;

    43 	for (j = 0; j < KNumTraceMaskWords; j++)

    44 		TheSuperPage().iDebugMask[j] = TheRomHeader().iTraceMask[j];

    45 

    46 	for (j = 0; j < 8; j++)

    47 		TheSuperPage().iInitialBTraceFilter[j] = TheRomHeader().iInitialBTraceFilter[j];

    48 

    49 	Kern::SuperPage().iInitialBTraceBuffer = TheRomHeader().iInitialBTraceBuffer;

    50 	Kern::SuperPage().iInitialBTraceMode = TheRomHeader().iInitialBTraceMode;

    51 

    52 	TheSuperPage().SetKernelConfigFlags(TheRomHeader().iKernelConfigFlags);

    53 

    54 	memcpy(&TheSuperPage().iDisabledCapabilities, &TheRomHeader().iDisabledCapabilities, sizeof(TheRomHeader().iDisabledCapabilities));

    55 	}

    56 

    57 TInt P::DefaultInitialTime()

    58 	{

    59 //

    60 // Default implementation of the kernel hook for getting the initial system

    61 // time, can be overriden by variant.

    62 //

    63     TInt seconds;

    64 	if (K::ColdStart || A::SystemTimeInSecondsFrom2000(seconds)!=KErrNone)

    65 		return KErrCorrupt;

    66 	else

    67 		return seconds;

    68 	}

    69 

    70 TInt P::InitSystemTime()

    71 	{

    72 //

    73 //  Initialise system time

    74 //	Return the initial time in seconds from 00:00:00 01-01-2000

    75 //

    76 

    77 	// Reset the UTC offset (I assume this gets loaded from storage at some point after F32 loads)

    78 	TUint dummy;

    79 	K::SetSystemTimeAndOffset(0, 0, 0, dummy, ETimeSetOffset | ETimeSetNoTimeUpdate);

    80 

    81 	// Read the hardware clock value. If this is negative it means it couldnt be read.

    82     TInt seconds = K::InitialTimeHandler()();	

    83 

    84 	if (seconds >= 0)

    85 		{

    86 		K::SecureClockStatus |= ESecureClockPresent;

    87 		__KTRACE_OPT(KBOOT,Kern::Printf("Read initial system time"));

    88 		// now=Hardware RTC value

    89 		}

    90 	else 

    91 		{

    92 		__KTRACE_OPT(KBOOT,Kern::Printf("Could not read initial system time - using ROM timestamp to set system time"));

    93 		TTimeK rom_time=*(const TTimeK*)&TheRomHeader().iTime;

    94 		rom_time -= TTimeK(K::HomeTimeOffsetSeconds)*1000000;

    95 		TInt s;

    96 		TInt r=K::SecondsFrom2000(rom_time,s);

    97 		if (r!=KErrNone)

    98 			PP::Panic(PP::EInitialSystemTimeInvalid);

    99 		seconds=s;

   100 

   101 		// write the ROM timestamp to the hardware RTC

   102 		A::SetSystemTimeInSecondsFrom2000(seconds);

   103 		}

   104 	return seconds;

   105 	}

   106 

   107 

   108 void FindRomRootDirectory()

   109 	{

   110 	TUint variant = TheSuperPage().iActiveVariant;

   111 	TUint cpu = (variant >> 16) & 0xff;

   112 	TUint asic = (variant >> 24);

   113 	PP::RomRootDirAddress=0;

   114 	TRomRootDirectoryList* pL=(TRomRootDirectoryList*)TheSuperPage().iRootDirList;

   115 	if (!pL)

   116 		pL=(TRomRootDirectoryList*)TheRomHeader().iRomRootDirectoryList;

   117 	TInt i;

   118 	for (i=0; i<pL->iNumRootDirs; i++)

   119 		{

   120 		if (THardwareVariant(pL->iRootDir[i].iHardwareVariant).IsCompatibleWith(cpu,asic,variant))

   121 			{

   122 			__KTRACE_OPT(KBOOT,Kern::Printf("Found ROM root dir index %d addr %08x",

   123 				i, pL->iRootDir[i].iAddressLin));

   124 			PP::RomRootDirAddress=pL->iRootDir[i].iAddressLin;

   125 			return;

   126 			}

   127 		}

   128 	}

   129 

   130 typedef TInt (*TInitVarExtFn)(const TRomImageHeader&);

   131 

   132 #ifdef KBOOT

   133 void DumpRomFileInfo(const TRomEntry& aRomEntry)

   134 	{

   135 	TBuf8<128> name;

   136 	TInt i;

   137 	for (i=0; i<aRomEntry.iNameLength; ++i)

   138 		{

   139 		name.Append(TChar(aRomEntry.iName[i<<1]&0xff));

   140 		}

   141 	const TRomImageHeader& img = *(const TRomImageHeader*)aRomEntry.iAddressLin;

   142 	__KTRACE_OPT(KBOOT,Kern::Printf("File %S[%08x]", &name, TUint(img.iHardwareVariant) ));

   143 	}

   144 #endif

   145 

   146 void InitVarExt(TBool aVar, TInitVarExtFn aFn)

   147 	{

   148 	__KTRACE_OPT(KBOOT,Kern::Printf("InitVarExt var=%d, fn=%08x", aVar, aFn));

   149 	TUint variant = TheSuperPage().iActiveVariant;

   150 	TUint cpu = (variant >> 16) & 0xff;

   151 	TUint asic = (variant >> 24);

   152 	__KTRACE_OPT(KBOOT,Kern::Printf("cpu=%d, asic=%d, variant=%x", cpu, asic, variant));

   153 	const TRomHeader& rh = TheRomHeader();

   154 	TRomEntry* pE = aVar ? (TRomEntry*)rh.iVariantFile : (TRomEntry*)rh.iExtensionFile;

   155 	while(pE)

   156 		{

   157 #ifdef KBOOT

   158 		DumpRomFileInfo(*pE);

   159 #endif

   160 		const TRomImageHeader& img = *(const TRomImageHeader*)pE->iAddressLin;

   161 		if (THardwareVariant(img.iHardwareVariant).IsCompatibleWith(cpu,asic,variant))

   162 			{

   163 			__KTRACE_OPT(KBOOT,Kern::Printf("Processing"));

   164 			(*aFn)(img);

   165 			if (aVar)

   166 				{

   167 				__KTRACE_OPT(KBOOT,Kern::Printf("Variant installed"));

   168 				return;

   169 				}

   170 			}

   171 		pE=(TRomEntry*)img.iNextExtension;

   172 		}

   173 	if (aVar)

   174 		Kern::Fault("NoVariant",0);

   175 	}

   176 

   177 TInt InitData(const TRomImageHeader& a)

   178 	{

   179 	__KTRACE_OPT(KBOOT,Kern::Printf("InitData %08x+%x->%08x", a.iDataAddress, a.iDataSize, a.iDataBssLinearBase));

   180 	CHECK_ROM_ENTRY_POINT(a);

   181 	if (a.iDataSize)

   182 		memcpy((TAny*)a.iDataBssLinearBase,(TAny*)a.iDataAddress,a.iDataSize);

   183 	TLibraryEntry ep = (TLibraryEntry)a.iEntryPoint;

   184 	__KTRACE_OPT(KBOOT,Kern::Printf("Calling entrypoint %08x(VariantInit0)", ep));

   185 	TInt r = ep(KModuleEntryReasonVariantInit0);

   186 	__KTRACE_OPT(KBOOT,Kern::Printf("Entrypoint returned %d",r));

   187 	if(!(++K::ExtensionCount&0x7fffffff))

   188 		K::Fault(K::ETooManyExtensions);

   189 	return r;

   190 	}

   191 

   192 TInt InitVariant(const TRomImageHeader& a)

   193 	{

   194 	TInt r = InitData(a);

   195 	__KTRACE_OPT(KBOOT,Kern::Printf("InitVariant: entry point returns %08x", r));

   196 	if (r<0)

   197 		Kern::Fault("VariantEntry",r);

   198 

   199 	// Initialise and create the variant object

   200 	r = A::CreateVariant(&a, r);

   201 	if (r<0)

   202 		Kern::Fault("VariantInit",r);

   203 	return r;

   204 	}

   205 

   206 void P::CreateVariant()

   207 	{

   208 	__KTRACE_OPT(KBOOT,Kern::Printf("CreateVariant"));

   209 	BTrace::Init0();

   210 	InitVarExt(EFalse, &InitData);		// initialise .data for all extensions

   211 	InitVarExt(ETrue, &InitVariant);	// find variant and initialise it

   212 	FindRomRootDirectory();

   213 	}

   214 

   215 struct SExtInit1EntryPoint

   216 	{

   217 	inline SExtInit1EntryPoint() : iEntryPoint(0),iReturnCode(0)

   218 		{}

   219 	inline SExtInit1EntryPoint(TLibraryEntry aEp, TInt aVal) : iEntryPoint(aEp),iReturnCode(aVal)

   220 		{}

   221 	TLibraryEntry iEntryPoint;

   222 	TInt iReturnCode;		// bits 7-0 used for extension startup priority order

   223 	};

   224 

   225 // This ordering function when used in conjunction with RArray<>::InsertInOrderAllowRepeats

   226 // orders the array of extensions as follow:

   227 //		highest priority -> lowest priority

   228 //		if same priority -> first in, lowest index

   229 //

   230 TInt priorityOrder(const SExtInit1EntryPoint& aMatch, const SExtInit1EntryPoint& aEntry)

   231 	{

   232 	TUint8 l=(TUint8)aMatch.iReturnCode;

   233 	TUint8 r=(TUint8)aEntry.iReturnCode;

   234 	if(l>r)

   235 		return -1;

   236 	else if(l<r)

   237 		return 1;

   238 	else

   239 		return 0;

   240 	}

   241 

   242 TInt InitExt0(const TRomImageHeader& a)

   243 	{

   244 	CHECK_ROM_ENTRY_POINT(a);

   245 	TLibraryEntry ep = (TLibraryEntry)a.iEntryPoint;

   246 	__KTRACE_OPT(KBOOT,Kern::Printf("InitExt0 %08x ep=%08x", &a, ep));

   247 	TInt r = (*ep)(KModuleEntryReasonExtensionInit0);

   248 	if (r<KErrNone)

   249 		{

   250 		__KTRACE_OPT(KBOOT,Kern::Printf("Already started"));

   251 		return r;

   252 		}

   253 	SExtInit1EntryPoint s(ep,r);

   254 	TInt count=K::ExtensionArray->Count();

   255 	if(count==K::ExtensionCount)					// this function is only called if extensions exist, i.e. K::ExtensionCount>0

   256 		K::Fault(K::EExtensionArrayOverflowed);		// the first insertion will allocate space for K::ExtensionCount entries and that is the maximum number of entries allowed

   257 	TLinearOrder<SExtInit1EntryPoint> PriorityOrder(priorityOrder);

   258 	if(K::ExtensionArray->InsertInOrderAllowRepeats(s,PriorityOrder)!=KErrNone)

   259 		K::Fault(K::EInsertExtensionFailed);

   260 	__KTRACE_OPT(KBOOT,Kern::Printf("Inserted at index %d, priority %d, last index %d", K::ExtensionArray->SpecificFindInOrder(s,PriorityOrder,EArrayFindMode_Last)-1, (TUint8)r, count));

   261 	return KErrNone;

   262 	}

   263 

   264 void P::StartExtensions()

   265 	{

   266 	// start extensions...

   267 	__KTRACE_OPT(KBOOT, Kern::Printf("Starting kernel extensions..."));

   268 

   269 	K::ExtensionArray = new RArray<SExtInit1EntryPoint>(--K::ExtensionCount);	// ordered array of extensions excluding Variant

   270 	if(!K::ExtensionArray)

   271 		K::Fault(K::EExtensionArrayAllocationFailed);

   272 	__KTRACE_OPT(KBOOT, Kern::Printf("Entry point array at %08x, max size %d",K::ExtensionArray,K::ExtensionCount));

   273 

   274 	InitVarExt(EFalse, &InitExt0);		// populates the array of entry points in priority order

   275 

   276 	for(TInt i=0; i<K::ExtensionArray->Count(); i++)	// call entry points in combined priority and temporal orders

   277 		{

   278 		TLibraryEntry ep = (*K::ExtensionArray)[i].iEntryPoint;

   279 		__KTRACE_OPT(KBOOT,Kern::Printf("InitExt1: calling entrypoint %08x", ep));

   280 		TInt r = ep(KModuleEntryReasonExtensionInit1);

   281 		__KTRACE_OPT(KBOOT,Kern::Printf("Entrypoint returned %d", r));

   282 		if (r!=KErrNone)

   283 			K::Fault(K::EStartExtensionsFailed);

   284 		}

   285 	// preserve array of extensions, it contains the returned codes from ExtInit0 which may be useful for future use

   286 	//delete K::ExtensionArray;

   287 	//K::ExtensionArray=NULL;

   288 	}

   289 

   290 void P::KernelInfo(TProcessCreateInfo& aInfo, TAny*& aStack, TAny*& aHeap)

   291 //

   292 // Provide the initial supervisor data information from the ROM

   293 //

   294 	{

   295 	aInfo.iFileName=KKernelFullPathNameSysBin;

   296 	aInfo.iRootNameOffset=11;

   297 	aInfo.iRootNameLength=9;

   298 	aInfo.iExtOffset = 16;

   299 

   300 	aInfo.iAttr=ECodeSegAttKernel|ECodeSegAttFixed;

   301 

   302 	const TRomHeader& romHdr=TheRomHeader();

   303 	const TRomEntry* primaryEntry=(const TRomEntry*)TheSuperPage().iPrimaryEntry;

   304 	const TRomImageHeader* primaryImageHeader=(const TRomImageHeader*)primaryEntry->iAddressLin;

   305 	Epoc::RomProcessInfo(aInfo, *primaryImageHeader);

   306 	aStack = (TAny*)(romHdr.iKernDataAddress + Kern::RoundToPageSize(romHdr.iTotalSvDataSize));

   307 	aHeap = (TAny*)(TLinAddr(aStack) + Kern::RoundToPageSize(aInfo.iStackSize));

   308 	aInfo.iTotalDataSize=romHdr.iTotalSvDataSize;

   309 	aInfo.iHeapSizeMin=TheSuperPage().iInitialHeapSize;

   310 	}

   311 

   312 EXPORT_C void Epoc::RomProcessInfo(TProcessCreateInfo& aInfo, const TRomImageHeader& a)

   313 	{

   314 	CHECK_PAGING_SAFE;

   315 	aInfo.iUids=*(const TUidType*)&a.iUid1;

   316 	aInfo.iCodeSize=a.iCodeSize;

   317 	aInfo.iTextSize=a.iTextSize;

   318 	aInfo.iDataSize=a.iDataSize;

   319 	aInfo.iBssSize=a.iBssSize;

   320 	aInfo.iTotalDataSize=a.iTotalDataSize;

   321 	aInfo.iEntryPtVeneer=a.iEntryPoint;

   322 	aInfo.iFileEntryPoint=a.iEntryPoint;

   323 	aInfo.iDepCount=a.iDllRefTable ? a.iDllRefTable->iNumberOfEntries : 0;

   324 	aInfo.iExportDir=a.iExportDir;

   325 	aInfo.iExportDirCount=a.iExportDirCount;

   326 	aInfo.iCodeLoadAddress=(TLinAddr)&a;//a.iCodeAddress;

   327 	aInfo.iCodeRunAddress=a.iCodeAddress;

   328 	aInfo.iDataLoadAddress=a.iDataAddress;

   329 	aInfo.iDataRunAddress=a.iDataBssLinearBase;

   330 	aInfo.iExceptionDescriptor = a.iExceptionDescriptor;

   331 	aInfo.iHeapSizeMin=a.iHeapSizeMin;

   332 	aInfo.iHeapSizeMax=a.iHeapSizeMax;

   333 	aInfo.iStackSize=a.iStackSize;

   334 	aInfo.iPriority=a.iPriority;

   335 	aInfo.iHandle=NULL;

   336 	aInfo.iS = a.iS;

   337 	aInfo.iModuleVersion = a.iModuleVersion;

   338 	if (a.iFlags&KRomImageFlagsKernelMask)

   339 		aInfo.iAttr=ECodeSegAttKernel;

   340 	else

   341 		aInfo.iAttr=ECodeSegAttGlobal;

   342 	if (a.iFlags&KRomImageFlagFixedAddressExe)

   343 		aInfo.iAttr|=ECodeSegAttFixed;

   344 	aInfo.iAttr &= ~ECodeSegAttABIMask;

   345 	aInfo.iAttr |= (a.iFlags & KRomImageABIMask);

   346 	if(a.iFlags&KRomImageSMPSafe)

   347 		aInfo.iAttr |= ECodeSegAttSMPSafe;

   348 	aInfo.iClientHandle = KCurrentThreadHandle;

   349 	aInfo.iClientProcessHandle = 0;

   350 	aInfo.iFinalHandle = 0;

   351 	aInfo.iOwnerType = EOwnerProcess;

   352 	aInfo.iFlags &= ~(TProcessCreateInfo::EDataPagingMask);

   353 	if(a.iFlags&KRomImageFlagDataPaged)

   354 		aInfo.iFlags |= TProcessCreateInfo::EDataPaged;

   355 	if(a.iFlags&KRomImageFlagDataUnpaged)

   356 		aInfo.iFlags |= TProcessCreateInfo::EDataUnpaged;

   357 	CHECK_ROM_ENTRY_POINT(a);

   358 	}

   359 

   360 EXPORT_C void Epoc::SetMonitorEntryPoint(TDfcFn aFn)

   361 	{

   362 	if (aFn)

   363 		{

   364 		TUint32 x=(TUint32)aFn;

   365 		PP::MonitorEntryPoint[0]=x;

   366 		PP::MonitorEntryPoint[1]=~x;

   367 		PP::MonitorEntryPoint[2]=((x>>2)*~x);

   368 		}

   369 	else

   370 		{

   371 		PP::MonitorEntryPoint[0]=0;

   372 		PP::MonitorEntryPoint[1]=0;

   373 		PP::MonitorEntryPoint[2]=0;

   374 		}

   375 	}

   376 

   377 EXPORT_C void Epoc::SetMonitorExceptionHandler(TLinAddr aHandler)

   378 	{

   379 	TheScheduler.iMonitorExceptionHandler=aHandler;

   380 	}

   381 

   382 EXPORT_C TAny* Epoc::ExceptionInfo()

   383 	{

   384 #ifdef __SMP__

   385 	return 0;	// separate for each CPU

   386 #else

   387 	return TheScheduler.i_ExcInfo;

   388 #endif

   389 	}

   390 

   391 EXPORT_C const TRomHeader& Epoc::RomHeader()

   392 	{

   393 	return TheRomHeader();

   394 	}

   395 

   396 TLinAddr ExecHandler::RomHeaderAddress()

   397 	{

   398 	return ::RomHeaderAddress;

   399 	}

   400 

   401 TLinAddr ExecHandler::RomRootDirectoryAddress()

   402 	{

   403 	return PP::RomRootDirAddress;

   404 	}

   405 

   406 TBool M::IsRomAddress(const TAny* aPtr)

   407 	{

   408     TLinAddr start=::RomHeaderAddress;

   409     TLinAddr end=start+TheRomHeader().iUncompressedSize;

   410 	return ((TLinAddr)aPtr>=start) && ((TLinAddr)aPtr<end);

   411 	}

   412 

   413 void P::SetSuperPageSignature()

   414 	{

   415 	TUint32* sig = TheSuperPage().iSignature;

   416 	const TUint32* time = (const TUint32*)&TheRomHeader().iTime;

   417 	sig[0] = time[0] ^ 0xb504f333;

   418 	sig[1] = time[1] ^ 0xf9de6484;

   419 	}

   420 

   421 TBool P::CheckSuperPageSignature()

   422 	{

   423 	const TUint32* sig = TheSuperPage().iSignature;

   424 	const TUint32* time = (const TUint32*)&TheRomHeader().iTime;

   425 	return ( (sig[0]^time[0])==0xb504f333 && (sig[1]^time[1])==0xf9de6484 );

   426 	}

   427 

   428 static const TUint32 KMapAttrType2 = 0x80000000;

   429 static const TUint32 KMapAttrTypeShift 		 = 26;

   430 

   431 #if defined(__CPU_MEMORY_TYPE_REMAPPING)

   432 extern TUint32 PrimaryRegionRemapRegister();

   433 extern TUint32 NormalMemoryRemapRegister();

   434 #endif

   435 

   436 EXPORT_C TMappingAttributes2::TMappingAttributes2(TMemoryType	aType,

   437 														TBool	aUserAccess,

   438 														TBool	aWritable,

   439 														TBool	aExecutable,

   440 														TInt	aShared,

   441 														TInt	aParity)

   442 	{

   443 	//Sort out default values:

   444 	if (aShared<0)

   445 		#if defined	(__CPU_USE_SHARED_MEMORY)

   446 		aShared = 1;

   447 		#else

   448 		aShared = 0;	

   449 		#endif

   450 	if (aParity<0)

   451 		aParity = 0;

   452 	

   453 	// KMapAttrType2 bit marks the object as of TMappingAttributes2 type (as opposed to TMappingAttributes bitmask).

   454 	// We have to make sure that these two types can work together.

   455 

   456 	iAttributes =	KMapAttrType2				|	// Mark it as TMappingAttributes2 object

   457 					EMapAttrReadSup				|	// All memory is readable from Kernel (Supervisor) mode

   458 					(aType <<KMapAttrTypeShift)	|

   459 					(aUserAccess ? EMapAttrReadUser : 0)|

   460 					(aWritable	 ? EMapAttrWriteSup : 0)|

   461 		((aWritable&&aUserAccess)? EMapAttrWriteUser: 0)|

   462 #ifdef __MMU_USE_SYMMETRIC_ACCESS_PERMISSIONS

   463 					(aExecutable   ? EMapAttrExecSup : 0)|

   464 		((aExecutable&&aUserAccess)? EMapAttrExecUser: 0)|

   465 #else

   466 					(aExecutable ? EMapAttrExecUser|EMapAttrExecSup : 0)|

   467 #endif

   468 					(aShared	 ? EMapAttrShared	: 0)|

   469 					(aParity	 ? EMapAttrUseECC	: 0);

   470 	

   471 	// Kernel relies on TMappingAttributes bitmask when dealing with various memory mappings.

   472 	// Set cache attribute bits as they are in TMappingAttributes.

   473 	iAttributes |= InternalCache::TypeToCachingAttributes(aType);

   474 	}

   475 

   476 TMappingAttributes2::TMappingAttributes2(TUint aMapAttr):iAttributes(aMapAttr)

   477 	{

   478 	};

   479 

   480 TMemoryType TMappingAttributes2::Type()

   481 	{

   482 	if(iAttributes&KMapAttrType2)

   483 		return (TMemoryType)(iAttributes>>KMapAttrTypeShift & 0x7); //three bits for memory type.

   484 

   485 	switch(iAttributes&EMapAttrL1CacheMask)

   486 		{

   487 	case EMapAttrFullyBlocking:

   488 		return EMemAttStronglyOrdered;

   489 

   490 	case EMapAttrBufferedNC:

   491 		return EMemAttDevice;

   492 

   493 	case EMapAttrBufferedC:

   494 	case EMapAttrL1Uncached:

   495 	case EMapAttrCachedWTRA:

   496 	case EMapAttrCachedWTWA:

   497 	case EMapAttrAltCacheWTRA:

   498 	case EMapAttrAltCacheWTWA:

   499 		return EMemAttNormalUncached;

   500 

   501 	case EMapAttrCachedWBRA:

   502 	case EMapAttrCachedWBWA:

   503 	case EMapAttrAltCacheWBRA:

   504 	case EMapAttrAltCacheWBWA:

   505 	case EMapAttrL1CachedMax:

   506 		return EMemAttNormalCached;

   507 

   508 	default:

   509 		Panic(KErrArgument);

   510 		return EMemAttNormalCached;

   511 		}

   512 	}

   513 

   514 TBool TMappingAttributes2::UserAccess()	{return (iAttributes&EMapAttrUserRw   ?	(TBool)ETrue : (TBool)EFalse);}

   515 TBool TMappingAttributes2::Writable()	{return (iAttributes&EMapAttrWriteMask? (TBool)ETrue : (TBool)EFalse);}

   516 #ifdef __MMU_USE_SYMMETRIC_ACCESS_PERMISSIONS

   517 TBool TMappingAttributes2::Executable()	{return (iAttributes&EMapAttrExecMask ? (TBool)ETrue : (TBool)EFalse);}

   518 #else

   519 TBool TMappingAttributes2::Executable()	{return (iAttributes&EMapAttrExecUser ? (TBool)ETrue : (TBool)EFalse);}

   520 #endif

   521 TBool TMappingAttributes2::Shared()		{return (iAttributes&EMapAttrShared   ?	(TBool)ETrue : (TBool)EFalse);}

   522 TBool TMappingAttributes2::Parity()		{return (iAttributes&EMapAttrUseECC	  ?	(TBool)ETrue : (TBool)EFalse);}

   523 TBool TMappingAttributes2::ObjectType2(){return (iAttributes&KMapAttrType2	  ?	(TBool)ETrue : (TBool)EFalse);}

   524 void  TMappingAttributes2::Panic(TInt aPanic)	{Kern::Fault("TMappingAttributes2",aPanic);}

   525 

   526 

   527 #ifdef __DEBUGGER_SUPPORT__

   528  /**

   529  Initialises the breakpoint pool.

   530  There is only one breakpoint pool in the system. The breakpoint pool should be initialised only once - usually from

   531  the run-mode debugger device driver.

   532 

   533  @param aCapabilities	On return this is set to a bitmask of values from enum DebugSupport::TType which represents the

   534  						supported breakpoint types. At the moment only DebugSupport::EBreakpointGlobal type is supported.

   535  @param aMaxBreakpoints The number of breakpoints for which resources should be reserved. It represents

   536                         the maximum number of the breakpoints at a time.

   537 

   538  @return KErrNoMemory, 		if not enough memory to reserve breakpoint resources.

   539    		 KErrInUse,    		if breakpoint pool already exists. Indicates that another debug tool might be using it at the moment.

   540    		 KErrNotSupported, 	if Kernel is not built with __DEBUGGER_SUPPORT__ option

   541    		 KErrNone,			on success.

   542 

   543  @pre   No fast mutex can be held.

   544  @pre   Kernel must be unlocked.

   545  @pre	Call in a thread context.

   546  @pre	Interrupts must be enabled.

   547  */

   548 EXPORT_C TInt DebugSupport::InitialiseCodeModifier(TUint& aCapabilities, TInt aMaxBreakpoints)

   549 	{

   550 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DebugSupport::InitialiseCodeModifier");

   551 	TInt err;

   552 	NKern::ThreadEnterCS();

   553 	Kern::MutexWait(CodeModifier::Mutex());

   554 

   555 	if ( KErrNone == (err =CodeModifier::CreateAndInitialise(aMaxBreakpoints)))

   556 		aCapabilities = EBreakpointGlobal;

   557 	

   558 	Kern::MutexSignal(CodeModifier::Mutex());

   559 	NKern::ThreadLeaveCS(); 

   560 	return err;

   561 	}

   562 

   563  /**

   564  Restore all breakpoints and free resources.

   565  Must not be called before Initialise().

   566 

   567  @panic CodeModifier 0 if called before InitialiseCodeModifier().

   568 

   569  @pre   No fast mutex can be held.

   570  @pre   Kernel must be unlocked.

   571  @pre	Call in a thread context.

   572  @pre	Interrupts must be enabled.

   573  */

   574 EXPORT_C void DebugSupport::CloseCodeModifier()

   575 	{

   576 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DebugSupport::CloseCodeModifier");

   577 	NKern::ThreadEnterCS(); 

   578 	Kern::MutexWait(CodeModifier::Mutex());

   579 

   580 	if (!TheCodeModifier)

   581 		{

   582 		Kern::MutexSignal(CodeModifier::Mutex());

   583 		NKern::ThreadLeaveCS(); 

   584 		CodeModifier::Fault(CodeModifier::EPanicNotInitialised);

   585 		}

   586 	TheCodeModifier->Close();

   587 

   588 	Kern::MutexSignal(CodeModifier::Mutex());

   589 	NKern::ThreadLeaveCS(); 

   590 	}

   591 

   592 /**

   593 Write a single breakpoint.

   594 I.e. store aValue at location aAddress in the address space of aThread.

   595 If the address resides in XIP code (ROM image), the memory page is shadowed before the content of the aAddress is altered.

   596 

   597 The breakpoint should be cleared/restored by DebugSupport::RestoreCode with matching aThread and aAddress.

   598 The breakpoints are owned by the corresponding process. Therefore:

   599 @code 

   600 DebugSupport::ModifyCode(thread1, address, size, value, type);

   601 and

   602 DebugSupport::ModifyCode(thread2, address size, value, type);

   603 @endcode

   604 have the same effect if thread1 and thread2 belong to the same process.

   605 

   606 Breakpoints of the diferent type(size) cannot overlap each other. For example:

   607 @code 

   608 DebugSupport::ModifyCode(thread, address,   4, value, type); //address is word aligned address

   609 DebugSupport::ModifyCode(thread, address,   2, value, type); //will return KErrAccessDenied

   610 DebugSupport::ModifyCode(thread, address+2, 2, value, type); //will return KErrAccessDenied

   611 DebugSupport::ModifyCode(thread, address+1, 1, value, type); //will return KErrAccessDenied

   612 @endcode

   613 

   614 After the content of aAddress is altered, instruction cache invalidation is performed on the cache line that aAddress

   615 belongs to. Therefore, the device driver doesn't have to call Cache::IMB_Range().

   616 

   617 If a code segment (which a valid breakpoint belongs to) is removed from the given process, the breakpoint will be

   618 automatically removed. This occures just before EEventRemoveCodeSeg event is issued with DProcess* matching

   619 the breakpoint's process. This also applies to the terminating/killed process, as all breakpoints belonging to it will be removed too.

   620 

   621 @param aThread 	The thread in who's address space the breakpoint is to be written.

   622 @param aAddress The linear address of the breakpoint. Must be a multiple of aSize.

   623 @param aSize 	The size, in bytes, of the breakpoint. Must be 1,2 or 4.

   624 @param aValue 	The value to be stored at aAddress. This value is trucated to the

   625      			number of bits relevent to aSize.

   626 @param aType 	The breakpoint type required. This is a bitmask of values from enum TType.

   627      			If this specifies more than one type, then the type with least scope

   628      			(i.e. EBreakpointLocal) is used when this is supported.

   629 

   630  @return KErrNoMemory,      if no resources are available.

   631    		 KErrAlreadyExists, if a breakpoint with the same address, size and the same owning process already exists in the pool.

   632    		 KErrAccessDenied, 	if an existing breakpoint of a different size and the same owning process overlaps the specified breakpoint.

   633    		 KErrNotSupported,  if none of the breakpoints types specified are supported or if Kernel is not built with __DEBUGGER_SUPPORT__ option

   634    		 Otherwise,         a positive value from enum TType which represents the type of breakpoint written.

   635 

   636  @panic CodeModifier 0 if called before InitialiseCodeModifier().

   637  @panic CodeModifier 1 if aSize value or aAdress alignement is invalid.

   638 

   639  @pre   No fast mutex can be held.

   640  @pre   Kernel must be unlocked.

   641  @pre	Call in a thread context.

   642  @pre	Interrupts must be enabled.

   643  */

   644 EXPORT_C TInt DebugSupport::ModifyCode(DThread* aThread, TLinAddr aAddress, TInt aSize, TUint aValue, TUint aType)

   645 	{

   646 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DebugSupport::ModifyCode");

   647 	switch(aSize) //Chack aSize and aValue

   648 	{

   649 	case CodeModifier::EByte:

   650 		break;

   651 	case CodeModifier::EHalfword:

   652 		if ((TInt)aAddress & 1)

   653 			CodeModifier::Fault(CodeModifier::EPanicInvalidSizeOrAlignment);

   654 		break;

   655 	case CodeModifier::EWord:	

   656 		if ((TInt)aAddress & 3)

   657 			CodeModifier::Fault(CodeModifier::EPanicInvalidSizeOrAlignment);

   658 		break;

   659 	default:

   660 		CodeModifier::Fault(CodeModifier::EPanicInvalidSizeOrAlignment);

   661 	}

   662 

   663 	if (aType != DebugSupport::EBreakpointGlobal)//Check breakpoint type

   664 		return KErrNotSupported;

   665 	

   666 	NKern::ThreadEnterCS(); 

   667 	Kern::MutexWait(CodeModifier::Mutex());

   668 	

   669 	if (!TheCodeModifier)

   670 		{

   671 		Kern::MutexSignal(CodeModifier::Mutex());

   672 		NKern::ThreadLeaveCS(); 

   673 		CodeModifier::Fault(CodeModifier::EPanicNotInitialised);	

   674 		}

   675 	TInt r = TheCodeModifier->Modify(aThread, aAddress, aSize, aValue);

   676 

   677 	Kern::MutexSignal(CodeModifier::Mutex());

   678 	NKern::ThreadLeaveCS(); 

   679 

   680 	if (r)

   681 		return r;

   682 	return EBreakpointGlobal;

   683 	}

   684 

   685  /**

   686  Restore a previousely written breakpoint.

   687  I.e. restore the value at location aAddress in the address space of aProcess.

   688 

   689  After the content of aAddress is altered, instruction cache invalidation is performed on the cache line

   690  that aAddress belongs to. Therefore, the device driver doesn't have to call Cache::IMB_Range().

   691 

   692  If the address resides in shadowed memory, the memory page will be un-shadowed if this is the last breakpoint

   693  in the page. However, if the page had been already shadowed before the first breakpoint in the page was applied,

   694  the page will remain shadowed.

   695 

   696  @param aProcess The process in who's address space aAddress lies.

   697  @param aAddress The linear address of an existing breakpoint.

   698 

   699  @return KErrNotFound,		if the breakpoint hadn't been previously written. It is also returned if the breakpoint

   700                         	was previously removed from the list because the code segment (which the breakpoint belongs to) was

   701                         	unloaded/removed from the process associated with the breakpoint.

   702    		 KErrNotSupported, 	if Kernel is not built with __DEBUGGER_SUPPORT__ option

   703     	 KErrNone,			on success.

   704 

   705  @panic CodeModifier 0 if called before InitialiseCodeModifier().

   706 

   707  @pre   No fast mutex can be held.

   708  @pre   Kernel must be unlocked.

   709  @pre	Call in a thread context.

   710  @pre	Interrupts must be enabled.

   711  */

   712 EXPORT_C TInt DebugSupport::RestoreCode(DThread* aThread, TLinAddr aAddress)

   713 	{

   714 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DebugSupport::RestoreCode");

   715 	NKern::ThreadEnterCS(); 

   716 	Kern::MutexWait(CodeModifier::Mutex());

   717 

   718 	if (!TheCodeModifier)

   719 		{

   720 		Kern::MutexSignal(CodeModifier::Mutex());

   721 		NKern::ThreadLeaveCS(); 

   722 		CodeModifier::Fault(CodeModifier::EPanicNotInitialised);

   723 		}

   724 	TInt r = TheCodeModifier->Restore(aThread, aAddress);

   725 

   726 	Kern::MutexSignal(CodeModifier::Mutex());

   727 	NKern::ThreadLeaveCS(); 

   728 	return r;

   729 	}

   730 

   731  /**

   732  Terminates a specified process on behalf of a debugger.

   733 

   734  @param aProcess The process in who's address space aAddress lies.

   735  @param aReason The reason code to supply when terminating a process

   736 

   737  @return N/A.

   738 

   739  @pre   No fast mutex can be held.

   740  @pre   Kernel must be unlocked.

   741  @pre	Call in a thread context.

   742  @pre	Interrupts must be enabled.

   743  */

   744 EXPORT_C void DebugSupport::TerminateProcess(DProcess* aProcess, const TInt aReason)

   745 	{

   746 	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"DebugSupport::TerminateProcess");

   747 	NKern::ThreadEnterCS(); 

   748 	aProcess->Die(EExitTerminate,aReason,KNullDesC);

   749 	NKern::ThreadLeaveCS(); 

   750 	return;

   751 	}

   752 

   753 /**

   754 Creates CodeModifier.

   755 @param aMaxBreakpoints The number of breakpoints to be allocated.

   756 @return KErrInUse 	 if code modifier already exists.

   757 		KErrNoMemory if out of memory

   758 		KErrNone 	 on success

   759 @pre Calling thread must be in the critical section

   760 @pre CodeSeg mutex held

   761 */

   762 TInt CodeModifier::CreateAndInitialise(TInt aMaxBreakpoints)

   763 	{

   764 	if (TheCodeModifier)

   765 		return KErrInUse;

   766 

   767 	CodeModifier* modifier = new CodeModifier;

   768 	if (!modifier)

   769 		return KErrNoMemory;

   770 	

   771 	modifier->iBreakpoints = new TBreakpoint[aMaxBreakpoints];

   772 	if (!modifier->iBreakpoints)

   773 		{

   774 		delete modifier;	

   775 		return KErrNoMemory;

   776 		};

   777 		

   778 	modifier->iPages = new TPageInfo[aMaxBreakpoints];

   779 	if (!modifier->iPages)

   780 		{

   781 		delete[] modifier->iBreakpoints;

   782 		delete modifier;	

   783 		return KErrNoMemory;

   784 		}

   785 

   786 	modifier->iPoolSize = aMaxBreakpoints;

   787 	modifier->iPageSize = Kern::RoundToPageSize(1);

   788 	modifier->iPageMask = ~(modifier->iPageSize-1);

   789 

   790 	TheCodeModifier = modifier;

   791 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::CreateAndInitialise() Size:%d created", aMaxBreakpoints));

   792 	return KErrNone;	

   793 	}

   794 

   795 /**

   796 Sets breakpoint.

   797 @pre Calling thread must be in the critical section

   798 @pre CodeSeg mutex held

   799 */

   800 TInt CodeModifier::Modify(DThread* aThread, TLinAddr aAddress, TInt aSize, TUint aValue)

   801 	{

   802 	TInt r;

   803 	TUint oldValue;

   804 	TBool overlap;

   805 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::Modify() T:%x Addr:%x, Size:%d Val:%x", aThread, aAddress, aSize, aValue));

   806 	

   807 	TBreakpoint* brk =FindBreakpoint(aThread, aAddress,aSize,overlap);

   808 	if (overlap)

   809 		return KErrAccessDenied;

   810 	if (brk)

   811 		return KErrAlreadyExists;

   812 	

   813 	if(NULL==(brk = FindEmptyBrk()))

   814 		return KErrNoMemory;

   815 	

   816 	//Find the page (if exists). Shadow the page if necessery.

   817 	TInt pageIndex = -1;

   818 

   819 #ifndef __DEMAND_PAGING__ 

   820 	if (IsRom(aAddress))  // If no demand paging, only need to do this if the address is in rom

   821 #endif

   822 		{

   823 		pageIndex = FindPageInfo(aAddress);

   824 		if (pageIndex < 0)

   825 			{

   826 			pageIndex = FindEmptyPageInfo();

   827 			if (pageIndex < 0)

   828 				return KErrNoMemory;

   829 			TPageInfo& page = iPages[pageIndex];

   830 			memclr(&page, sizeof(page));

   831 			page.iAddress = aAddress & iPageMask;

   832 			

   833 			if (IsRom(aAddress))

   834 				{

   835 				__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::Modify() - Shadowing Page"));

   836 				r = Epoc::AllocShadowPage(aAddress & iPageMask);

   837 				if (r==KErrAlreadyExists)

   838 					page.iWasShadowed = ETrue;

   839 				else if (r!=KErrNone)

   840 					return r;

   841 				}

   842 #ifdef __DEMAND_PAGING__

   843 			else

   844 				{

   845 				DDemandPagingLock* lock = new DDemandPagingLock;

   846 				if (lock == NULL)

   847 					return KErrNoMemory;

   848 				r = lock->Alloc(iPageSize);

   849 				if (r != KErrNone)

   850 					{

   851 					delete lock;

   852 					return r;

   853 					}

   854 				lock->Lock(aThread, aAddress & iPageMask, iPageSize);

   855 				page.iPagingLock = lock;

   856 				}

   857 #endif

   858 			}

   859 		iPages[pageIndex].iCounter++;

   860 		}

   861 

   862 	r = SafeWriteCode(aThread->iOwningProcess, aAddress, aSize, aValue, &oldValue);

   863 	if (r != KErrNone)

   864 		{//aAddress is invalid

   865 		if (pageIndex >= 0)

   866 			RestorePage(pageIndex);

   867 		return r;

   868 		}

   869 

   870 	//All done. Update the internal structures.

   871 	brk->iAddress = aAddress;

   872 	brk->iProcessId = (aThread->iOwningProcess)->iId;

   873 	brk->iOldValue = oldValue;

   874 	brk->iSize = aSize;

   875 	brk->iPageIndex = pageIndex;

   876 	return KErrNone;

   877 	}

   878 

   879 /**

   880 @pre Calling thread must be in the critical section

   881 @pre CodeSeg mutex held

   882 */

   883 TInt CodeModifier::Restore(DThread* aThread, TLinAddr aAddress)

   884 	{

   885 	TUint oldValue;

   886 	TBool overlaps;

   887 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::Restore() T:%x Addr:%x", aThread, aAddress));

   888 	TInt r = KErrNone;;

   889 	TBreakpoint* br = FindBreakpoint(aThread, aAddress, 0, overlaps);

   890 	if (br==NULL)

   891 		return KErrNotFound;

   892 	

   893 	r = SafeWriteCode(aThread->iOwningProcess, br->iAddress, br->iSize, br->iOldValue, &oldValue);

   894 	if (r)

   895 		r=KErrNotFound;

   896 	

   897 	br->iSize = (TUint)EEmpty;

   898 		

   899 	TInt pageIndex = br->iPageIndex;

   900 	if (pageIndex>=0)

   901 		RestorePage(pageIndex);

   902 	

   903 	return r;

   904 	}

   905 

   906 /*

   907 @pre Calling thread must be in the critical section

   908 @pre CodeSeg mutex held

   909 */

   910 void CodeModifier::Close()

   911 	{

   912 	TUint oldValue;

   913 	TInt brkIndex;

   914 

   915 	TheCodeModifier = NULL;

   916 	

   917 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::Close()"));

   918 

   919 	for (brkIndex=0; brkIndex<iPoolSize; brkIndex++)	

   920 		{

   921 		if (iBreakpoints[brkIndex].iSize ==(TUint16)EEmpty)

   922 			continue;

   923 		DProcess* process = Process(iBreakpoints[brkIndex].iProcessId);

   924 		

   925 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::Close() - Removing Brk:%x",iBreakpoints[brkIndex].iAddress));

   926 		

   927 		//Write back the original value

   928 		if (process)

   929 			SafeWriteCode(process, iBreakpoints[brkIndex].iAddress, iBreakpoints[brkIndex].iSize, iBreakpoints[brkIndex].iOldValue, &oldValue);

   930 			

   931 		iBreakpoints[brkIndex].iSize = (TUint)EEmpty;

   932 		TInt pageIndex = iBreakpoints[brkIndex].iPageIndex;

   933 		if (pageIndex>=0)

   934 			RestorePage(pageIndex);

   935 		}

   936 

   937 	delete this;

   938 	}

   939 

   940 /*

   941 Destructor. The object is deleted asynchroniously from Kernel Supervisor thread.

   942 */

   943 CodeModifier::~CodeModifier()

   944 	{

   945 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::~CodeModifier()"));

   946 	delete[] iPages;

   947 	delete[] iBreakpoints;

   948 	}

   949 

   950 /**

   951 This is executed when a code segment is about to be unmapped from the process. It corresponds to EEventRemoveCodeSeg Kernel event.

   952 Removes breakpoints that belong to the threads from aProcess. Also, removes shadow pages if there is no breakpoint left in them.

   953 

   954 @param aCodeSeg Code Segment that is removed from aProcess.

   955 @param aProcess Process from whom the code segment is removed.

   956 

   957 @pre Calling thread must be in the critical section

   958 @pre CodeSeg mutex held

   959 */

   960 void CodeModifier::CodeSegRemoved(DCodeSeg* aCodeSeg, DProcess* aProcess)

   961 	{

   962 	if (!TheCodeModifier)

   963 		return;

   964 	TheCodeModifier->DoCodeSegRemoved(aCodeSeg, aProcess);

   965 	}

   966 

   967 void CodeModifier::DoCodeSegRemoved(DCodeSeg* aCodeSeg, DProcess* aProcess)

   968 	{

   969 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::CodeSegRemoved()"));

   970 	

   971 	TUint oldValue;

   972 	TUint minAddr = aCodeSeg->iRunAddress;

   973 	TUint maxAddr = aCodeSeg->iRunAddress + aCodeSeg->iSize;

   974 

   975 	TBreakpoint* bp = iBreakpoints;

   976 	TBreakpoint* bpEnd = bp+iPoolSize; //points right behind iBreakpoints

   977 	for (; bp<bpEnd; ++bp)

   978 		{

   979 		if (bp->iSize == (TUint)EEmpty) continue;

   980 

   981 		if (aProcess->iId == bp->iProcessId)

   982 			{

   983 			if (bp->iAddress >= minAddr && bp->iAddress <  maxAddr)   

   984 				{

   985 				__KTRACE_OPT(KDEBUGGER,Kern::Printf("CodeModifier::CodeSegRemoved()- a breakpoint"));

   986 

   987 				//Remove breakpoint. Don't examine error code as there is nobody to report to.

   988 				SafeWriteCode(aProcess, bp->iAddress, bp->iSize, bp->iOldValue, &oldValue);

   989 

   990 				//Mark the slot as empty and decrease the counter of the shadow page slot (if there is any associated)

   991 				bp->iSize = (TUint)EEmpty;

   992 				if (bp->iPageIndex >= 0)

   993 					RestorePage(bp->iPageIndex);

   994 				}

   995 			}

   996 		}

   997 

   998 	}

   999 

  1000 /*

  1001 Finds DProcess that matches to processId

  1002 @param aProcessId ProcessId

  1003 @return Pointer to matching DProcess or NULL

  1004 */

  1005 DProcess* CodeModifier::Process(TUint aProcessId)

  1006 	{

  1007 	TInt i;

  1008 	DProcess* process = NULL;

  1009 	DObjectCon* processCon = Kern::Containers()[EProcess];

  1010 	processCon->Wait();

  1011 

  1012 	for (i=0;i<processCon->Count();i++)

  1013 		{

  1014 		DProcess* pr = (DProcess*)(*processCon)[i];

  1015 		if (pr->iId == aProcessId)

  1016 			{

  1017 			process=(DProcess*)pr;

  1018 			break;

  1019 			}

  1020 		}

  1021 

  1022 	processCon->Signal();

  1023 	return process;

  1024 	}

  1025 

  1026 /*

  1027 Returns eTrue if given virtual address belongs to rom image, EFalse otherwise

  1028 */

  1029 TBool CodeModifier::IsRom(TLinAddr aAddress)

  1030 	{

  1031 	TRomHeader romHeader = Epoc::RomHeader();

  1032 	if ( (aAddress >= romHeader.iRomBase ) && (aAddress < (romHeader.iRomBase + romHeader.iUncompressedSize)) )

  1033 		return ETrue;

  1034 	return EFalse;

  1035 	}

  1036 

  1037 /*

  1038 Finds the first available(empty) breakpoint slot.

  1039 @return The pointer of the empty slot or NULL if all occupied.

  1040 */

  1041 CodeModifier::TBreakpoint* CodeModifier::FindEmptyBrk()

  1042 	{

  1043 	TBreakpoint* bp = TheCodeModifier->iBreakpoints;

  1044 	TBreakpoint* bpEnd = bp+TheCodeModifier->iPoolSize; //points right behind iBreakpoints

  1045 	for (; bp<bpEnd; ++bp)

  1046 		if (bp->iSize == (TInt16)EEmpty)

  1047 			return bp;

  1048 		

  1049 	return NULL;	

  1050 	}

  1051 	

  1052 /*

  1053 Finds matching breakpoint.

  1054 

  1055 @param aThread 		The thread who's process owns the breakpoint

  1056 @param aAddress 	Address of the breakpoint.

  1057 @param aSize 		The size of the breakpoint. Value 0, 1,2 or 4 is assumed. If 0, it doesn't check the size nor overlaps(used to remove breakpoint).

  1058 @param aOverlap 	On return, it is true if a breakpoint is found that doesn't match the size but overlaps with

  1059 					the specified breakpoint(i.e. address and process are the same but the size is different).

  1060 

  1061 @return - The pointer to the breakpoint slot that matches the entry (adress, size and the owning process)

  1062 		- NULL - if could't find the matching breakpoint.

  1063 */

  1064 CodeModifier::TBreakpoint* CodeModifier::FindBreakpoint(DThread* aThread, TLinAddr aAddress, TInt aSize, TBool& aOverlap)

  1065 	{

  1066 	TInt bytes=0;

  1067 	aOverlap = EFalse;

  1068 	TUint processId = aThread->iOwningProcess->iId;//processId of the thread that owns aThread

  1069 

  1070 	if (aSize) //if size==0, we do not check overlaps.

  1071 		bytes = ((1<<aSize)-1)<<(aAddress&3);	//bits[3-0] marks the bytes that are contained in the breakpoint:

  1072 												//	address: ...00b size: 1 => bytes=0001b 

  1073 												//	address: ...01b size: 1 => bytes=0010b 

  1074 												//	address: ...10b size: 1 => bytes=0100b 

  1075 												//	address: ...11b size: 1 => bytes=1000b 

  1076 												//	address: ...00b size: 2 => bytes=0011b 

  1077 												//	address: ...10b size: 2 => bytes=1100b 

  1078 												//	address: ...00b size: 4 => bytes=1111b 

  1079 

  1080 	TBreakpoint* bp = TheCodeModifier->iBreakpoints;

  1081 	TBreakpoint* bpEnd = bp+TheCodeModifier->iPoolSize; //points right behind iBreakpoints

  1082 	for (; bp<bpEnd; ++bp)

  1083 		{

  1084 		if (bp->iSize == (TInt16)EEmpty || bp->iProcessId != processId)

  1085 			continue;//Either empty or not matchng process. 

  1086 

  1087 		if (!aSize)

  1088 			{ //Do not check the size. If the address does not match, do not check for overlap.

  1089 			if (bp->iAddress == aAddress)

  1090 				return bp;

  1091 			else

  1092 				continue;

  1093 			}

  1094 			

  1095 		if (bp->iAddress == aAddress && bp->iSize == aSize)

  1096 			return bp;//If we find a matching breakpoint, there cannot be another one that overlaps

  1097 		

  1098 		//Check if bp breakpoint overlaps with the specified one.

  1099 		if ((bp->iAddress^aAddress)>>2)

  1100 			continue;//Not in the same word

  1101 			

  1102 		if (((1<<bp->iSize)-1)<<(bp->iAddress&3)&bytes)

  1103 			{//Two brakpoints are within the same word with some overlaping bytes.

  1104 			aOverlap = ETrue;

  1105 			return NULL; //If we find an overlaping breakpoint, there cannot be another one that matches exactly.

  1106 			}

  1107 		}

  1108 	return NULL;	

  1109 	}

  1110 

  1111 /*

  1112 Finds the first available(empty) page info slot.

  1113 @return The index of the slot or KErrNotFound if all occupied.

  1114 */

  1115 TInt CodeModifier::FindEmptyPageInfo()

  1116 	{

  1117 	TInt i;

  1118 	for (i=0; i<iPoolSize; i++)

  1119 		if (!iPages[i].iCounter)

  1120 			return i;

  1121 	return KErrNotFound;

  1122 	}

  1123 

  1124 /*

  1125 Finds the page info structure that contains given virtual address

  1126 @return The index of the page info slot or KErrNotFound.

  1127 */

  1128 TInt CodeModifier::FindPageInfo(TLinAddr aAddress)

  1129 	{

  1130 	TInt i;

  1131 	aAddress &= iPageMask; //round down to the page base address

  1132 	for (i=0; i<iPoolSize; i++)

  1133 		if(iPages[i].iCounter)

  1134 			if (iPages[i].iAddress == aAddress)