// Copyright (c) 2007-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:

// Provides a class to manage the generation of lists

// 

//

#include "d_list_manager.h"

#include "d_process_tracker.h"

#include "debug_utils.h"

#include "plat_priv.h"

#include "debug_logging.h"

#include <arm.h>

// make accessing DThread's MState more intuitive

#define iMState iWaitLink.iSpare1

// make accessing NThread's NState more intuitive

#define iNState iSpare3

//constants to match against a rom entry's attributes,

//these are defined in the file server (can't be included kernel side)

//and in the ROM tools (also inaccessible) so redefined here

const TUint KEntryAttXIP=0x0080;

const TUint KEntryAttDir=0x0010;

using namespace Debug;

/**

  Get thread listing for the specified thread, if the thread data will not fit

  in the buffer then an error is returned.

  @param aBuffer buffer to put data in

  @param aDataSize on return will contain size of data

  @param aTargetThreadId thread ID to return listing for

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer

  or one of the other system wide error codes on failure

  */

TInt TListManager::GetThreadListForThread(TDes8& aBuffer, TUint32& aDataSize, const TUint64 aTargetThreadId) const

	{

	LOG_MSG("TListManager::GetThreadListForThread()");

	// open a handle to check whether the thread actually exists

	DThread* thread = DebugUtils::OpenThreadHandle(aTargetThreadId);

	if(!thread)

		{

		return KErrArgument;

		}

	DProcess* process = thread->iOwningProcess;

	if(!process)

		{

		return KErrArgument;

		}

	TUint64 processId = process->iId;

	thread->Close(NULL);

	//request a process specific list

	return GetThreadListForProcess(aBuffer, aDataSize, processId);

	}

TInt TListManager::GetThreadListForProcess(TDes8& aBuffer, TUint32& aDataSize, const TUint64 aTargetProcessId) const

	{

	LOG_MSG("TListManager::GetThreadListForProcess()");

	// open a handle to check whether the process actually exists

	DProcess* process = DebugUtils::OpenProcessHandle(aTargetProcessId);

	if(!process)

		{

		return KErrArgument;

		}

	process->Close(NULL);

	//request a process specific list

	return GetThreadList(aBuffer, aDataSize, EFalse, aTargetProcessId);

	}

/**

  Get global thread listing

  @param aBuffer buffer to put data in

  @param aDataSize on return will contain size of data

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer

  or one of the other system wide error codes on failure

  */

TInt TListManager::GetGlobalThreadList(TDes8& aBuffer, TUint32& aDataSize) const

	{

	LOG_MSG("TListManager::GetGlobalThreadList()");

	//request a global list

	return GetThreadList(aBuffer, aDataSize, ETrue, 0);

	}

/**

  Get thread listing, if the thread data will not fit

  in the buffer then an error is returned.

  @param aBuffer buffer to put data in

  @param aDataSize on return will contain size of data

  @param aGlobal whether or not the listing should be global or thread specific

  @param aTargetProcessId process ID to return listing for, relevant only if aGlobal == ETrue

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer

  or one of the other system wide error codes on failure

  */

TInt TListManager::GetThreadList(TDes8& aBuffer, TUint32& aDataSize, TBool aGlobal, const TUint64 aTargetProcessId) const

	{

	LOG_MSG("TListManager::GetThreadList\n");

	//have to read the threads in a critical section

	NKern::ThreadEnterCS();

	//get a pointer to the kernel's thread list

	DObjectCon *threads = Kern::Containers()[EThread];

	//if can't get container then exit

	if(threads == NULL)

		{

		NKern::ThreadLeaveCS();

		return KErrGeneral;

		}

	//stop the thread list from changing while we are processing them

	threads->Wait();

	aDataSize = 0;

	aBuffer.SetLength(0);

	//iterate through the threads adding them to the buffer

	for(TInt i=0; i<threads->Count(); i++)

		{

		DThread* thread = (DThread*)(*threads)[i];

		//skip this thread pointer is the thread is NULL

		if(thread)

			{

			NThread& nThread = thread->iNThread;

			// if the thread is marked as being dead then don't return information about it in the listing

#ifndef __SMP__

			if((NThread::EDead != nThread.iNState) && (DThread::EDead != thread->iMState))

#else

 			if((!nThread.IsDead()) && (DThread::EDead != thread->iMState))

#endif

				{

				if( aGlobal || (aTargetProcessId == (TUint64)thread->iOwningProcess->iId))

					{

					//store the data in the buffer

					AppendThreadData(aBuffer, aDataSize, thread);

					}

				}

			}

		}

	//leave critical section

	threads->Signal();

	NKern::ThreadLeaveCS();

	//return indication of whether the kernel's data was too big

	return (aDataSize > aBuffer.Length()) ? KErrTooBig : KErrNone;

	}

/**

  Helper function for writing thread data into a buffer

  @pre call in a critical section

  @pre call only on threads which have NThread state not equal to NThread::EDead

  @param aBuffer buffer to put data in

  @param aDataSize on return will contain size of data

  @param aThread thread object to include information about

  @return KErrNone on success, or one of the other system wide error codes

*/

void TListManager::AppendThreadData(TDes8& aBuffer, TUint32& aDataSize, DThread* aThread) const

	{

	//get aThread's name

	TFileName fileName;

	aThread->FullName(fileName);

	TUint16 nameLength = fileName.Length();

	//increase aDataSize by the size of this entry

	aDataSize = Align4(aDataSize + (2*nameLength) + sizeof(TThreadListEntry) - sizeof(TUint16));

	//if the data would not cause overflow then add it to the buffer

	if(aDataSize <= aBuffer.MaxLength())

		{

		//Create a TThreadListEntry which references the buffer.

		TThreadListEntry& entry = *(TThreadListEntry*)(aBuffer.Ptr()+aBuffer.Length());

		//add data to entry

		entry.iProcessId = (TUint64)aThread->iOwningProcess->iId;

		entry.iThreadId = (TUint64)aThread->iId;

		entry.iSupervisorStackBase = (TUint32)aThread->iSupervisorStack;

		entry.iSupervisorStackBaseValid = ETrue;

		entry.iSupervisorStackSize = aThread->iSupervisorStackSize;

		entry.iSupervisorStackSizeValid = ETrue;

		entry.iNameLength = nameLength;

		//only ask for the supervisor stack pointer if aThread is suspended

		entry.iSupervisorStackPtrValid = EInValid;

		entry.iSupervisorStackPtr = 0;

		if(TheDProcessTracker.CheckSuspended(aThread))

			{

			NThread& nThread = aThread->iNThread;

			TArmRegSet regSet;

			TUint32 flags;

			NKern::ThreadGetSystemContext(&nThread, &regSet, flags);

			entry.iSupervisorStackPtr = (TUint32)regSet.iR13;

			//need to check that the stack pointer flag is valid

			if(flags & (1<<EArmSp))

				{

				entry.iSupervisorStackPtrValid = EValid;

				}

			}

		//copy name data into the buffer

		TUint16* ptr = &(entry.iName[0]);

		const TUint8* ptr8 = fileName.Ptr();

		const TUint8* ptr8End = ptr8 + nameLength;

		while(ptr8 < ptr8End)

			{

			*ptr++ = (TUint16)*ptr8++;

			}

		aBuffer.SetLength(aDataSize);

		}

	}

/**

  Get global process listing

  @param aBuffer buffer to put data in

  @param aDataSize on return will contain size of data

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer

  or one of the other system wide error codes on failure

  */

TInt TListManager::GetProcessList(TDes8& aBuffer, TUint32& aDataSize) const

	{

	LOG_MSG("TListManager::GetProcessList()");

	//get a pointer to the kernel's process list

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

	if(processes == NULL)

		{

		//if can't get container then something is seriously wrong

		return KErrNotFound;

		}

	//have to read the processes in a critical section

	NKern::ThreadEnterCS();

	processes->Wait();

	aDataSize = 0;

	//iterate through the processes adding them to the buffer

	for(TInt i=0; i<processes->Count(); i++)

		{

		DProcess* process = (DProcess*)(*processes)[i];

		if(process)

			{

			//get process's file name length

			DCodeSeg* codeSeg = process->iCodeSeg;

			TUint16 fileNameLength = (codeSeg) ? (*codeSeg->iFileName).Length() : 0;

			//get process's dynamic name length and name

			TFullName fullName;

			process->FullName(fullName);

			TUint16 dynamicNameLength = fullName.Length();

			//increase aDataSize to reflect size of entry

			aDataSize = Align4(aDataSize + (2*fileNameLength) + (2*dynamicNameLength) + sizeof(TProcessListEntry) - sizeof(TUint16));

			//if the data would not cause overflow then add it to the buffer

			if(aDataSize <= aBuffer.MaxLength())

				{

				//Create a TProcessListEntry which references the buffer.

				TProcessListEntry& entry = *(TProcessListEntry*)(aBuffer.Ptr() + aBuffer.Length());

				//set values

				entry.iProcessId = (TUint64)process->iId;

				entry.iFileNameLength = fileNameLength;

				entry.iDynamicNameLength = dynamicNameLength;

				entry.iUid3 = process->iUids.iUid[2].iUid;

				if(codeSeg)

					{

					//create TPtr to where the file name should be written

					TPtr name = TPtr((TUint8*)&(entry.iNames[0]), fileNameLength*2, fileNameLength*2);

					//copy the file name

					TInt err = CopyAndExpandDes(*codeSeg->iFileName, name);

					if(err != KErrNone)

						{

						processes->Signal();

						NKern::ThreadLeaveCS();

						return KErrGeneral;

						}

					}

				//create TPtr to where the dynamic name should be written

				TPtr name = TPtr((TUint8*)(&(entry.iNames[0]) + fileNameLength), dynamicNameLength*2, dynamicNameLength*2);

				//copy the dynamic name

				TInt err = CopyAndExpandDes(fullName, name);

				if(err != KErrNone)

					{

					processes->Signal();

					NKern::ThreadLeaveCS();

					return KErrGeneral;

					}

				//set length same as aDataSize

				aBuffer.SetLength(aDataSize);

				}

			}

		}

	//leave critical section

	processes->Signal();

	NKern::ThreadLeaveCS();

	//return indication of whether the kernel's data was too big

	return (aDataSize > aBuffer.Length()) ? KErrTooBig : KErrNone;

	}

/**

  Copy the descriptor aSrc to aDest and converting each byte from aSrc

  into the two-byte equivalent. For example if aSrc contains 'XYZ' then

  aDest will be filled with 'X\0Y\0Z\0' where \0 is the null character.

  The length of aDest is set to twice the length of aSrc.

  @param aSrc source descriptor

  @param aDest destination descriptor to copy and expand aSrc into

  @return KErrNone on success,

  KErrArgument if the max length of aDest is less than twice the length of aSrc

  */

TInt TListManager::CopyAndExpandDes(const TDesC& aSrc, TDes& aDest) const

	{

	//check bounds

	if(aSrc.Length() * 2 > aDest.MaxLength())

		{

		return KErrArgument;

		}

	//get a pointer to the start of the destination descriptor

	TUint16* destPtr = (TUint16*)aDest.Ptr();

	//get pointers to the start and end of the aSrc descriptor

	const TUint8* srcPtr = aSrc.Ptr();

	const TUint8* srcEnd = srcPtr + aSrc.Length();

	//copy the characters from aSrc into aDest, expanding to make them 16-bit characters

	while(srcPtr < srcEnd)

		{

		*destPtr = (TUint16)*srcPtr;

		destPtr++;

		srcPtr++;

		}

	//set aDest's length to reflect the new contents

	aDest.SetLength(2*aSrc.Length());

	return KErrNone;

	}

/**

  Get global code segment listing

  @param aBuffer buffer to put data in

  @param aDataSize on return will contain size of data

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer,

  or one of the other system wide error codes

  */

TInt TListManager::GetGlobalCodeSegList(TDes8& aBuffer, TUint32& aDataSize) const

	{

	LOG_MSG("TListManager::GetGlobalCodeSegList()");

	// Acquire code seg lock mutex

	NKern::ThreadEnterCS();

	DMutex* codeMutex = Kern::CodeSegLock();

	Kern::MutexWait(*codeMutex);

	//get global code seg list

	SDblQue* codeSegList = Kern::CodeSegList();

	//create a memory info object for use in the loop

	TModuleMemoryInfo memoryInfo;

	//iterate through the list

	aDataSize = 0;

	for (SDblQueLink* codeSegPtr= codeSegList->First(); codeSegPtr!=(SDblQueLink*) (codeSegList); codeSegPtr=codeSegPtr->iNext)

		{

		DEpocCodeSeg* codeSeg = (DEpocCodeSeg*)_LOFF(codeSegPtr,DCodeSeg, iLink);

		//the code seg shouldn't be null as we're in critical section, ignore if it is null

		if(codeSeg)

			{

			//get the memory info

			TInt err = codeSeg->GetMemoryInfo(memoryInfo, NULL);

			if(err != KErrNone)

				{

				// Release the codeseglock mutex again

				Kern::MutexSignal(*codeMutex);

				NKern::ThreadLeaveCS();

				//there's been an error so return it

				return err;

				}

			//calculate data values

			TFileName fileName(codeSeg->iFileName->Ptr());

			TBool isXip = (codeSeg->iXIP) ? ETrue : EFalse;

			//get the code seg type, can ignore error as have already checked codeSeg is not NULL

			TCodeSegType type = EUnknownCodeSegType;

			err = GetCodeSegType(codeSeg, type);

			if(err != KErrNone)

				{

				LOG_MSG("TListManager::GetGlobalCodeSegList() : code seg is NULL");

				}

			TUint32 uid3 = codeSeg->iUids.iUid[2].iUid;

			//append data to buffer

			err = AppendCodeSegData(aBuffer, aDataSize, memoryInfo, isXip, type, fileName, uid3);

			if(err != KErrNone)

				{

				// Release the codeseglock mutex again

				Kern::MutexSignal(*codeMutex);

				NKern::ThreadLeaveCS();

				return KErrGeneral;

				}

			}

		}

	// Release the codeseglock mutex again

	Kern::MutexSignal(*codeMutex);

	NKern::ThreadLeaveCS();

	return (aDataSize > aBuffer.MaxLength()) ? KErrTooBig : KErrNone;

	}

/**

  Get code segment list for a thread

  @param aBuffer buffer to store data in

  @param aDataSize size of kernel's data

  @param thread ID to get listing for

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer,

  or one of the other system wide error codes

  */

TInt TListManager::GetCodeSegListForThread(TDes8& aBuffer, TUint32& aDataSize, const TUint64 aTargetThreadId) const

	{

	LOG_MSG("TListManager::GetCodeSegListForThread()");

	// open a handle to check whether the thread actually exists

	DThread* thread = DebugUtils::OpenThreadHandle(aTargetThreadId);

	if(!thread)

		{

		return KErrArgument;

		}

	DProcess* process = thread->iOwningProcess;

	if(!process)

		{

		return KErrArgument;

		}

	TUint64 processId = process->iId;

	thread->Close(NULL);

	return GetCodeSegListForProcess(aBuffer, aDataSize, processId);

	}

/**

  Get code segment list for a process

  @param aBuffer buffer to store data in

  @param aDataSize size of kernel's data

  @param process ID to get listing for

  @return KErrNone on success,

  KErrTooBig if data won't fit in aBuffer,

  or one of the other system wide error codes

  */

TInt TListManager::GetCodeSegListForProcess(TDes8& aBuffer, TUint32& aDataSize, const TUint64 aTargetProcessId) const

	{

	LOG_MSG("TListManager::GetCodeSegListForProcess()");

	//get the process

	DProcess* process = DebugUtils::OpenProcessHandle(aTargetProcessId);

	if(!process)

		{

		return KErrArgument;

		}

	//enter thread critical section and acquire code segment mutex

	Kern::AccessCode();

	//memory info object to use in loop

	TModuleMemoryInfo memoryInfo;

	//get code seg list

	SDblQue queue;

	process->TraverseCodeSegs(&queue, NULL, DCodeSeg::EMarkDebug, DProcess::ETraverseFlagAdd);

	//iterate through the list

	aDataSize = 0;

	for(SDblQueLink* codeSegPtr= queue.First(); codeSegPtr!=(SDblQueLink*) (&queue); codeSegPtr=codeSegPtr->iNext)

		{

		//get the code seg

		DEpocCodeSeg* codeSeg = (DEpocCodeSeg*)_LOFF(codeSegPtr,DCodeSeg, iTempLink);

		//the code seg shouldn't be null as we're in critical section, ignore if it is null

		if(codeSeg)