--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/drivers/debug/rmdebug/d_target_process.cpp Wed Sep 01 12:34:56 2010 +0100
@@ -0,0 +1,420 @@
+// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Purpose: The DProcessTracker object tracks which processes are being
+// debugged. The DProcessTracker class uses a DTargetProcess object for
+// each process being debugged.
+// Note: Although TheDProcessTracker object is a global, it should be unique
+// as only the Debug Security Server should load and use this driver.
+//
+//
+
+#include <e32def.h>
+#include <e32def_private.h>
+#include <e32cmn.h>
+#include <e32cmn_private.h>
+#include <kernel/kernel.h>
+#include <kernel/kern_priv.h>
+#include "nk_priv.h"
+#include <rm_debug_api.h>
+
+#include "d_target_process.h"
+#include "debug_logging.h"
+#include "debug_utils.h"
+
+// ctor
+DTargetProcess::DTargetProcess()
+ :iProcessName(0,0,0)
+ {
+ }
+
+// dtor
+DTargetProcess::~DTargetProcess()
+ {
+ // Delete the space allocated for the name if any
+ if (iProcessName.Ptr() != 0)
+ {
+ NKern::ThreadEnterCS();
+ Kern::Free((TAny*)iProcessName.Ptr());
+ NKern::ThreadLeaveCS();
+ }
+ //Reset the array and delete the objects that its members point to
+ NKern::ThreadEnterCS();
+ iAgentList.ResetAndDestroy();
+ NKern::ThreadLeaveCS();
+ }
+
+// Compare two DTargetProcess items. They are the same if they have the same name.
+TInt DTargetProcess::Compare(const DTargetProcess& aFirst, const DTargetProcess& aSecond)
+ {
+ return aFirst.iProcessName.Compare(aSecond.iProcessName);
+ }
+
+// Set the name of the process we are tracking
+TInt DTargetProcess::SetProcessName(const TDesC8& aProcessName)
+ {
+ // Argument checking
+ if (aProcessName.Length() < 1)
+ {
+ return KErrArgument;
+ }
+
+ // Allocate some memory to store the name
+ TUint length = aProcessName.Length();
+
+ NKern::ThreadEnterCS();
+ TUint8* buffer = (TUint8*)Kern::AllocZ(length);
+ NKern::ThreadLeaveCS();
+ if (buffer==NULL)
+ {
+ // Out of memory
+ return KErrNoMemory;
+ }
+
+ // Set iProcessName to use the alloc'd buffer
+ iProcessName.Set(buffer,length,length);
+
+ // Store aProcessName within this object
+ iProcessName.Copy(aProcessName);
+
+ return KErrNone;
+ }
+
+// Obtain the name of the process being tracked
+const TPtr8& DTargetProcess::ProcessName(void)
+ {
+ return iProcessName;
+ }
+
+// Returns a pointer to the DDebugAgent with aAgentId.
+// If the agent is not in the list, it returns NULL.
+DDebugAgent* DTargetProcess::Agent(TUint64 aAgentId)
+ {
+ for(TInt i = 0; i < iAgentList.Count(); i++)
+ {
+ if (iAgentList[i]->Id() == aAgentId)
+ {
+ return iAgentList[i];
+ }
+ }
+
+ // what do we return if we don't have any agents?
+ return NULL;
+ }
+
+// Adds aAgentId as a tracking agent for this process.
+TInt DTargetProcess::AddAgent(TUint64 aAgentId)
+ {
+
+ DDebugAgent* agent = DDebugAgent::New(aAgentId);
+ LOG_MSG4("DTargetProcess::AddAgent(), agentId=%d, curr iAgentList.Count=%d, new agent=0x%08x",
+ I64LOW(aAgentId), iAgentList.Count(), agent );
+
+ if(agent == NULL)
+ {
+ LOG_MSG("DTargetProcess::AddAgent() couldn't allocate memory for DDebugAgent");
+ return KErrNoMemory;
+ }
+ return iAgentList.Insert(agent,0);
+ }
+
+// Stops tracking the process with this agent
+TInt DTargetProcess::RemoveAgent(TUint64 aAgentId)
+ {
+ // We need to find and then remove the agent
+ for(TUint i = 0; i < iAgentList.Count(); i++)
+ {
+ if (iAgentList[i]->Id() == aAgentId)
+ {
+ delete iAgentList[i];
+ iAgentList.Remove(i);
+ return KErrNone;
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+// Index through the agents by position
+DDebugAgent* DTargetProcess::operator[](TInt aIndex)
+ {
+ return iAgentList[aIndex];
+ }
+
+// returns the number of agents tracking this process.
+TInt DTargetProcess::AgentCount(void)
+ {
+ return iAgentList.Count();
+ }
+
+/**
+ Resume the specified thread
+
+ @param aThread thread to resume
+
+ @return KErrNone if the thread has previously been suspended and is resumed,
+ KErrNotFound if the thread has not previously been suspended
+ */
+TInt DTargetProcess::ResumeThread(DThread* aThread)
+ {
+ LOG_MSG2("DTargetProcess::ResumeSuspendedThread(): thread=0x%08x", aThread);
+ TInt err1 = ResumeSuspendedThread(aThread);
+ LOG_MSG2("DTargetProcess::ResumeSuspendedThread(): ret=%d)", err1);
+ TInt err2 = ResumeFrozenThread(aThread->iNThread);
+ LOG_MSG2("DTargetProcess::ResumeFrozenThread(): ret=%d)", err2);
+ //if resuming the suspended thread failed for an obscure reason return it
+ if((err1 != KErrNotFound) && (err1 != KErrNone))
+ {
+ LOG_MSG2("DTargetProcess::ResumeThread() BUG : unexpected exit, err1: %d", err1);
+ return err1;
+ }
+ //if resuming the frozen thread failed for an obscure reason return it
+ if((err2 != KErrNotFound) && (err2 != KErrNone))
+ {
+ LOG_MSG2("DTargetProcess::ResumeThread() BUG : unexpected exit, err2: %d", err2);
+ return err2;
+ }
+ // if resuming the suspended thread succeeded in both cases, we have a consistency problem
+ if ((err1 == KErrNone) && (err2 == KErrNone))
+ {
+ LOG_MSG("DTargetProcess::ResumeThread() BUG : unexpected exit, err1 == err2 == KErrNone");
+ }
+
+ //if the thread was in neither list return KErrNotFound, otherwise KErrNone
+ return ((err1 == KErrNone) || (err2 == KErrNone)) ? KErrNone : KErrNotFound;
+ }
+
+/**
+ Resume the specified frozen thread
+
+ @param aThread thread to resume
+
+ @return KErrNone if the thread has previously been suspended and is resumed,
+ KErrNotFound if the thread has not previously been suspended
+ */
+TInt DTargetProcess::ResumeFrozenThread(NThread& aThread)
+ {
+ for(TInt i=0; i<iFrozenThreadSemaphores.Count(); i++)
+ {
+ if(iFrozenThreadSemaphores[i]->iOwningThread == &aThread)
+ {
+ NKern::FSSignal(iFrozenThreadSemaphores[i]);
+ NKern::ThreadEnterCS();
+ delete iFrozenThreadSemaphores[i];
+ NKern::ThreadLeaveCS();
+ iFrozenThreadSemaphores.Remove(i);
+ return KErrNone;
+ }
+ }
+ return KErrNotFound;
+ }
+
+/**
+ Resume the specified suspended thread
+
+ @param aThread thread to resume
+
+ @return KErrNone if the thread has previously been suspended and is resumed,
+ KErrNotFound if the thread has not previously been suspended
+ */
+TInt DTargetProcess::ResumeSuspendedThread(DThread* aThread)
+ {
+ TUint64 threadId = (TUint64)aThread->iId;
+ for(TInt i=0; i<iSuspendedThreads.Count(); i++)
+ {
+ if(iSuspendedThreads[i] == threadId)
+ {
+ iSuspendedThreads.Remove(i);
+ LOG_MSG2("DTargetProcess::ResumeSuspendedThread()> Kern::ThreadResume() 0x%08x", aThread);
+ Kern::ThreadResume(*aThread);
+ return KErrNone;
+ }
+ }
+ return KErrNotFound;
+ }
+
+/**
+ Suspend the specified thread
+
+ @param aThread thread to suspend
+
+ @param aFreezeThread suspend the thread on a Fast Semaphore if
+ ETrue. EFalse means suspend by calling Kern::Suspend.
+
+ @return KErrNone if the thread is successfully suspended,
+ KErrAlreadyExists if the agent has already suspended the thread,
+ or one of the other system wide error codes
+
+ This function suspends a thread by calling Kern::Thread Suspend.
+
+ An alternative means of suspending the _current_ thread only
+ is by call DTargetProcess::FreezeThread. This will ensure that
+ the current thread is suspended when exception processing for this
+ thread completes (see rm_debug_eventhandler.cpp)
+
+ */
+TInt DTargetProcess::SuspendThread(DThread* aThread, TBool aFreezeThread)
+ {
+ // should check if this thread is already suspended/frozen and return if so
+ // but just warn for the moment.
+ if (CheckSuspended(aThread))
+ {
+ // thread was already suspended, don't bother doing it again
+ LOG_MSG2("DTargetProcess::SuspendThread - Thread Id 0x%08x already suspended\n",aThread->iId);
+ //return KErrAlreadyExists;
+ }
+
+ return aFreezeThread ? FreezeThread() : DoSuspendThread(aThread);
+ }
+
+/**
+ Freeze the current thread
+
+ @return KErrNone if the thread is successfully suspended,
+ KErrAlreadyExists if the agent has already suspended the thread,
+ or one of the other system wide error codes
+
+ This marks the current thread for waiting on a Fast Semaphore
+ when exception handling for this thread has completed - see
+ rm_debug_eventhandler.cpp for details.
+ */
+TInt DTargetProcess::FreezeThread()
+ {
+ // create and store a fast semaphore to stop the thread on
+ NKern::ThreadEnterCS();
+ NFastSemaphore* sem = new NFastSemaphore();
+ NKern::ThreadLeaveCS();
+ sem->iOwningThread = &(Kern::CurrentThread().iNThread);
+ LOG_MSG3("DTargetProcess::FreezeThread(): new NFastSemaphore() owning thread==curr NThread=0x%08x, DThread=0x%08x",
+ sem->iOwningThread, &(Kern::CurrentThread()) );
+ return iFrozenThreadSemaphores.Append(sem);
+ }
+
+/**
+ Suspend the specified thread
+
+ @param aThread thread to suspend
+
+ @return KErrNone if the thread is successfully suspended,
+ KErrAlreadyExists if the agent has already suspended the thread,
+ or one of the other system wide error codes
+ */
+TInt DTargetProcess::DoSuspendThread(DThread* aThread)
+ {
+ TUint64 threadId = (TUint64)aThread->iId;
+
+ // Don't suspend if this thread is already suspended (by FSWait or
+ // Kern::ThreadSuspend
+ if (CheckSuspended(aThread))
+ {
+ // thread was already suspended, don't bother doing it again
+ LOG_MSG2("DTargetProcess::SuspendThread - Thread Id 0x%08x already suspended\n",threadId);
+ return KErrAlreadyExists;
+ }
+
+ // Add thread to the suspend list
+ TInt err = iSuspendedThreads.Append(threadId);
+ if(err == KErrNone)
+ {
+ LOG_MSG2("DTargetProcess::DoSuspendThread >Kern::ThreadSuspend() 0x%08x", aThread );
+ Kern::ThreadSuspend(*aThread, 1);
+ }
+ return err;
+ }
+
+/**
+ Waits the current thread on a Fast Semaphore.
+
+ This is useful for situations where the current thread
+ has hit a breakpoint within a critical section, and
+ otherwise could not be suspended at this point.
+
+ Note that the Fast Semaphore structure on which the thread
+ waits must be a member data item of this class instance,
+ as it needs to be FSSignal()'d by another thread to resume
+ again.
+ */
+void DTargetProcess::FSWait()
+ {
+ NThread* currentNThread = &(Kern::CurrentThread().iNThread);
+ for(TInt i=0; i<iFrozenThreadSemaphores.Count(); i++)
+ {
+ if(iFrozenThreadSemaphores[i]->iOwningThread == currentNThread)
+ {
+ LOG_MSG4("DTargetProcess::FSWait(): > FSWait frozen sem %d, currentNThread=0x%08x, id=0x%x",
+ i, currentNThread, Kern::CurrentThread().iId );
+ NKern::FSWait(iFrozenThreadSemaphores[i]);
+ return;
+ }
+ }
+ }
+
+/**
+ Checks that the thread has been suspended
+
+ @param aThread thread to check suspended
+
+ @return ETrue if the thread has been suspended,
+ EFalse if the thread has not been suspended
+ */
+TBool DTargetProcess::CheckSuspended(DThread* aThread) const
+ {
+ if(!aThread)
+ {
+ return EFalse;
+ }
+ //check if the thread is in the suspended threads list
+ for(TInt i=0; i<iSuspendedThreads.Count(); i++)
+ {
+ if(iSuspendedThreads[i] == (TUint64)aThread->iId)
+ {
+ return ETrue;
+ }
+ }
+ // not in the suspended threads list so check in the frozen threads list
+ NThread* nThread = &(aThread->iNThread);
+ for(TInt i=0; i<iFrozenThreadSemaphores.Count(); i++)
+ {
+ if(iFrozenThreadSemaphores[i]->iOwningThread == nThread)
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+/*
+@return ETrue if the debug driver has suspended any of the process' threads, EFalse otherwise
+*/
+TBool DTargetProcess::HasSuspendedThreads() const
+ {
+ return (iSuspendedThreads.Count() > 0) || (iFrozenThreadSemaphores.Count() > 0);
+ }
+
+void DTargetProcess::NotifyEvent(const TDriverEventInfo& aEventInfo)
+ {
+ // Stuff the event info into all the tracking agents event queues
+ LOG_MSG4("DTargetProcess::NotifyEvent(): num attached agents: %d, iEventType=%d, this=0x%08x",
+ AgentCount(), aEventInfo.iEventType, this);
+
+ for(TInt i = 0; i < AgentCount(); i++)
+ {
+ // Index through all the relevant debug agents
+ DDebugAgent* debugAgent = iAgentList[i];
+ if(debugAgent != NULL)
+ {
+ debugAgent->NotifyEvent(aEventInfo);
+ }
+ }
+ }
+