FCL/sf/os/fshell: comparison libraries/memoryaccess/MemoryAccess.cpp

equal deleted inserted replaced

-:96d581d2147d
+:184a1eb85cf2
 //#include <m32std.h>
 #include <nkern.h>
 #include <kernel.h>
 #include <kern_priv.h>
+#ifdef __EPOC32__
+#include <memmodel/epoc/plat_priv.h> // For DEpocCodeSeg
+#endif
 #include <fshell/common.mmh>
 #ifdef FSHELL_DOBJECTIX_SUPPORT
 #include "dobject.h" // To pick up my defn of DObjectIx/DObjectIxNinePointOneHack
 	TInt GetObjectInfoByName(TObjectType aObjectType, const TDesC8& aObjectName, TDes8* aKernelInfoBuf);
 	TInt GetObjectInfoByHandle(TObjectType aObjectType, TInt aThreadId, TInt aObjectHandle, TDes8* aKernelInfoBuf);
 	TInt GetObjectAddresses(TObjectType aObjectType, const TDesC8& aOwningProcess, TDes8* aKernelInfoBuf);
 	TInt GetChunkAddresses(TUint aControllingProcessId, TDes8* aKernelInfoBuf);
 	TInt AcquireCodeSegMutex();
+	TInt AcquireCodeSegMutexAndFilterCodesegsForProcess(TUint aProcessId);
 	TInt ReleaseCodeSegMutex();
 	TInt GetNextCodeSegInfo(TDes8* aCodeSegInfoBuf);
 	TInt ObjectDie(TObjectKillParamsBuf& aObjectKillParamsBuf);
 	TInt FindPtrInCodeSegments(TAny* aDllNamePtr, TAny* aPtr);
 	TInt GetHandleOwners(TAny* aObj, TAny* aOwnersBuf);
 	void BreakpointHit(TDes& aPkg);
 private:
 	DThread* iClient;
 	TBool iLocks[ENumObjectTypes];
-	TBool iCodeSegLock;
+	enum TCodesegLogStatus
-	DCodeSeg* iCurrentCodeSeg;
+		{
+		ENotHeld,
+		EHeld,
+		EHeldAndTraversing,
+		} iCodeSegLock;
+	SDblQueLink* iCurrentCodeSegLink;
 	DThreadChangeHandler* iEventHandler;
 	DPropertyAccess* iPropertyAccess;
 	TAny* iClientBreakpointNotifyPkg;
 	TRequestStatus* iClientBreakpointNotifyStatus;
+	SDblQue iFilteredCodesegQue;
 	};
 NONSHARABLE_CLASS(DThreadChangeHandler) : public DKernelEventHandler
 	{
 			}
 		return err;
 		}
 case RMemoryAccess::EControlAcquireCodeSegMutex:
 	return AcquireCodeSegMutex();
+case RMemoryAccess::EControlAcquireCodeSegMutexAndFilterCodesegsForProcess:
+		return AcquireCodeSegMutexAndFilterCodesegsForProcess((TUint)a1);
 case RMemoryAccess::EControlReleaseCodeSegMutex:
 	return ReleaseCodeSegMutex();
 case RMemoryAccess::EControlGetNextCodeSegInfo:
 	return GetNextCodeSegInfo((TDes8*)a1);
 case RMemoryAccess::EControlObjectDie:
 	if (!err)
 		{
 		if (codeSegLock)
 			{
 			Kern::MutexWait(*codeSegLock);
-			iCodeSegLock = ETrue;
+			iCodeSegLock = EHeld;
 			}
 		else
 			{
 			err = KErrNotFound;
 			}
 		}
 	// Kern::Printf("[DMemoryAccess] ::AcquireCodeSegMutex returning %d", err);
 	return err;
+	}
+TInt DMemoryAccess::AcquireCodeSegMutexAndFilterCodesegsForProcess(TUint aProcessId)
+	{
+	TInt err = KErrNone;
+	NKern::ThreadEnterCS();
+	Kern::Containers()[EProcess]->Wait();
+	DProcess* process = Kern::ProcessFromId(aProcessId);
+	if (process == NULL || process->Open() != KErrNone)
+		{
+		err = KErrNotFound;
+		}
+	Kern::Containers()[EProcess]->Signal();
+	if (!err)
+		{
+		err = AcquireCodeSegMutex();
+		}
+	if (!err)
+		{
+		iCodeSegLock = EHeldAndTraversing;
+		TInt numTraversed = process->TraverseCodeSegs(&iFilteredCodesegQue, NULL, DCodeSeg::EMarkDebug, DProcess::ETraverseFlagAdd);
+		err = numTraversed;
+		}
+	if (process) process->Close(NULL);
+	NKern::ThreadLeaveCS();
+	return err;
 	}
 TInt DMemoryAccess::GetObjectAddresses(TObjectType aObjectType, const TDesC8& aOwningProcess, TDes8* aKernelInfoBuf)
 	{
 	DObjectCon* const * cons = Kern::Containers();
 // DMemoryAccess::ReleaseCodeSegMutex
 //  Releases the code segment mutex
 TInt DMemoryAccess::ReleaseCodeSegMutex()
 	{
 	// Kern::Printf("[DMemoryAccess] ::ReleaseCodeSegMutex");
-	TInt err=KErrNone;
+	if (iCodeSegLock == ENotHeld)
+		{
-	if (!iCodeSegLock)
+		return KErrNotReady;
-		{ //Check the lock on code segs is not currently held
+		}
-		Kern::ThreadKill(iClient, EExitPanic, EMemAccessMutexNotHeld, KMemAccessPanicCategory);
-		err = KErrAbort;
+	if (iCodeSegLock == EHeldAndTraversing)
-		}
+		{
+		DCodeSeg::EmptyQueue(iFilteredCodesegQue, DCodeSeg::EMarkDebug);
-	DMutex* const codeSegLock = Kern::CodeSegLock();
+		}
-	if (!err)
+	Kern::MutexSignal(*Kern::CodeSegLock());
-		{
+	iCodeSegLock = ENotHeld;
-		if (codeSegLock)
-			{
-			Kern::MutexSignal(*codeSegLock);
-			iCodeSegLock = EFalse;
-			}
-		else
-			{
-			err = KErrNotFound;
-			}
-		}
 	// Kern::Printf("[DMemoryAccess] ::ReleaseCodeSegMutex returning %d", err);
-	return err;
+	return KErrNone;
 	}
 TInt DMemoryAccess::GetNextCodeSegInfo(TDes8* aCodeSegInfoBuf)
 	{
 	// Kern::Printf("[DMemoryAccess] ::GetNextCodeSegInfo");
 	TInt err = KErrNone;
-	SDblQue* p = Kern::CodeSegList();
+	SDblQue* p;
+	if (iCodeSegLock == EHeldAndTraversing)
+		{
+		p = &iFilteredCodesegQue;
+		}
+	else
+		{
+		p = Kern::CodeSegList();
+		}
 	SDblQueLink* anchor=&p->iA;
-	if (!iCurrentCodeSeg)
+	if (!iCurrentCodeSegLink)
 		{
-		iCurrentCodeSeg = _LOFF(anchor->iNext, DCodeSeg, iLink);
+		iCurrentCodeSegLink = anchor;
 		}
-	if (iCurrentCodeSeg->iLink.iNext != anchor)
+	if (iCurrentCodeSegLink->iNext != anchor)
 		{
-		iCurrentCodeSeg = _LOFF(iCurrentCodeSeg->iLink.iNext, DCodeSeg, iLink);
+		iCurrentCodeSegLink = iCurrentCodeSegLink->iNext;
 		}
 	else
 		{
-		iCurrentCodeSeg = NULL;
+		iCurrentCodeSegLink = NULL;
 		err = KErrNotFound;
 		}
 	if (!err)
 		{
 		//TCodeSegKernelInfoBuf* localInfoBuf = new TCodeSegKernelInfoBuf;
-		TPckgBuf<TTomsciCodeSegKernelInfo>* localInfoBuf = new TPckgBuf<TTomsciCodeSegKernelInfo>;
+		DCodeSeg* currentCodeseg = (iCodeSegLock == EHeldAndTraversing) ? _LOFF(iCurrentCodeSegLink, DCodeSeg, iTempLink) : _LOFF(iCurrentCodeSegLink, DCodeSeg, iLink);
+		TPckgBuf<TCodeSegKernelInfo>* localInfoBuf = new TPckgBuf<TCodeSegKernelInfo>;
 		if (!localInfoBuf)
 			{
 			err = KErrNoMemory;
 			}
 		else
 			{
 			//Get the code seg info
-			(*localInfoBuf)().iRunAddress = iCurrentCodeSeg->iRunAddress;
+			(*localInfoBuf)().iRunAddress = currentCodeseg->iRunAddress;
-			(*localInfoBuf)().iSize = iCurrentCodeSeg->iSize;
+			(*localInfoBuf)().iSize = currentCodeseg->iSize;
-			(*localInfoBuf)().iFileName = iCurrentCodeSeg->iFileName->Right((*localInfoBuf)().iFileName.MaxLength());
+			if (currentCodeseg->iFileName)
-			(*localInfoBuf)().iAccessCount = iCurrentCodeSeg->iAccessCount;
+				{
-			(*localInfoBuf)().iAddressOfKernelObject = (TUint8*)iCurrentCodeSeg;
+				(*localInfoBuf)().iFileName = currentCodeseg->iFileName->Right((*localInfoBuf)().iFileName.MaxLength());
-			(*localInfoBuf)().iName = iCurrentCodeSeg->iRootName;
+				}
-			(*localInfoBuf)().iDepCount = iCurrentCodeSeg->iDepCount;
+			(*localInfoBuf)().iAccessCount = currentCodeseg->iAccessCount;
+			(*localInfoBuf)().iAddressOfKernelObject = (TUint8*)currentCodeseg;
+			(*localInfoBuf)().iName = currentCodeseg->iRootName;
+			(*localInfoBuf)().iDepCount = currentCodeseg->iDepCount;
+#ifdef __EPOC32__
+			(*localInfoBuf)().iXip = ((DEpocCodeSeg*)currentCodeseg)->iXIP;
+#else
+			(*localInfoBuf)().iXip = EFalse;
+#endif
 			//Copy the local info buffer into the client's address space
 		    err = Kern::ThreadDesWrite(iClient, aCodeSegInfoBuf, *localInfoBuf, 0, KTruncateToMaxLength, NULL);
 			delete localInfoBuf;
 			}
 		}

changeset 7	184a1eb85cf2
parent 0	7f656887cf89
child 93	2f382fb2036c