// setpriority.cpp

// 

// Copyright (c) 2008 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/memoryaccesscmd.h>

using namespace IoUtils;

class CCmdSetpriority;

class CNewThreadNotifier : public CActive

	{

public:

	CNewThreadNotifier(CCmdSetpriority& aCmd, RMemoryAccess& aMemAccess);

	void Start();

	~CNewThreadNotifier();

	void DoCancel();

	void RunL();

private:

	CCmdSetpriority& iCmd;

	RMemoryAccess& iMemAccess;

	};

class CCmdSetpriority : public CMemoryAccessCommandBase

	{

public:

	static CCommandBase* NewLC();

	~CCmdSetpriority();

	void NewThread(TInt aHandle);

private:

	CCmdSetpriority();

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual void DoRunL();

	virtual void ArgumentsL(RCommandArgumentList& aArguments);

	virtual void OptionsL(RCommandOptionList& aOptions);

private:

	RArray<TUint> iTids;

	RArray<TUint> iPids;

	TInt iPriority;

	HBufC* iName;

	TProcessKernelInfo iProcInfo;

	TThreadKernelInfo iThreadInfo;

	CNewThreadNotifier* iNotifier;

	};

CCommandBase* CCmdSetpriority::NewLC()

	{

	CCmdSetpriority* self = new(ELeave) CCmdSetpriority();

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdSetpriority::~CCmdSetpriority()

	{

	delete iNotifier;

	delete iName;

	iTids.Close();

	iPids.Close();

	}

CCmdSetpriority::CCmdSetpriority()

	: CMemoryAccessCommandBase(EManualComplete)

	{

	}

const TDesC& CCmdSetpriority::Name() const

	{

	_LIT(KName, "setpriority");

	return KName;

	}

void CCmdSetpriority::ArgumentsL(RCommandArgumentList& aArguments)

	{

	aArguments.AppendIntL(iPriority, _L("priority"));

	}

void CCmdSetpriority::OptionsL(RCommandOptionList& aOptions)

	{

	aOptions.AppendStringL(iName, _L("match"));

	aOptions.AppendUintL(iPids, _L("pid"));

	aOptions.AppendUintL(iTids, _L("tid"));

	}

EXE_BOILER_PLATE(CCmdSetpriority)

void CCmdSetpriority::DoRunL()

	{

	LoadMemoryAccessL();

	TInt err = KErrNone;

	// Fix up priorities that we had to make different to kernel cos fshell can't handle negative arguments

	// See enum TThrdPriority in kern_priv.h for the meaning of these negative numbers

	switch(iPriority)

		{

		case 101: iPriority = -8; break;

		case 102: iPriority = -7; break;

		case 103: iPriority = -6; break;

		case 104: iPriority = -5; break;

		case 105: iPriority = -4; break;

		case 106: iPriority = -3; break;

		case 107: iPriority = -2; break;

		default:

			break;

		}

	if (iName)

		{

		TPtrC8 name8 = iName->Des().Collapse();

		LeaveIfErr(iMemAccess.SetPriorityOverride(iPriority, name8), _L("Couldn't set priority override"));

		iNotifier = new(ELeave) CNewThreadNotifier(*this, iMemAccess);

		iNotifier->Start();

		return;

		}

	if (iTids.Count() && iPids.Count())

		{

		LeaveIfErr(KErrArgument, _L("You cannot specify both --tid and --pid - a single priority cannot be valid for thread and process."));

		}

	for (TInt i = 0; i < iTids.Count(); i++)

		{

		TUint id = iTids[i];

		RThread thread;

		err = iMemAccess.RThreadForceOpen(thread, id);

		if (!err) err = iMemAccess.SetThreadPriority(thread, iPriority);

		if (err) PrintError(err, _L("Couldn't set priority for thread %u"), id);

		thread.Close();

		}

	for (TInt i = 0; i < iPids.Count(); i++)

		{

		TUint id = iPids[i];

		// Get KProcessFlagPriorityControl flag

		RProcess process;

		err = process.Open(id);

		LeaveIfErr(err, _L("Couldn't open process with ID %u"), id);

		TBool priorityControlAllowed = EFalse;

		TPckg<TProcessKernelInfo> pkg(iProcInfo);

		err = iMemAccess.GetObjectInfoByHandle(EProcess, RThread().Id(), process.Handle(), pkg);

		if (err)

			{

			PrintWarning(_L("Couldn't get priority control flag setting (%d)\r\n"), err);

			}

		else

			{

			if (iProcInfo.iFlags & KProcessFlagPriorityControl) priorityControlAllowed = ETrue;

			}

		if (!priorityControlAllowed)

			{

			PrintError(KErrAccessDenied, _L("This process does not allow setting of its priority"));

			}

		else if (iPriority != EPriorityBackground && iPriority != EPriorityForeground)

			{

			PrintError(KErrAccessDenied, _L("The kernel will ignore requests to set a process priority that isn't Background (250) or Foreground (350). I can't see how to get round this even using memory access. Sorry."));

			}

		process.SetPriority((TProcessPriority)iPriority);

		process.Close();

		}

	Complete(KErrNone);

	}

void CCmdSetpriority::NewThread(TInt aHandle)

	{

	if (aHandle == KErrNotSupported)

		{

		PrintError(KErrNotSupported, _L("Kernel was not compiled with __DEBUGGER_SUPPORT__, can't get thread creation notifications."));

		Complete(aHandle);

		}

	else if (aHandle < 0)

		{

		PrintError(aHandle, _L("Failed to get new thread notification, or couldn't open handle to thread."));

		Complete(aHandle);

		}

	else

		{

		RThread thread;

		thread.SetHandle(aHandle);

		TFullName name(thread.FullName());

		TInt priority = 0;

		TPckg<TThreadKernelInfo> pkg(iThreadInfo);

		TInt err = iMemAccess.GetObjectInfoByHandle(EThread, RThread().Id(), aHandle, pkg);

		if (!err)

			{

			priority = iThreadInfo.iThreadPriority;

			}

		TUint tid = thread.Id();

		Printf(_L("New thread id %u name %S priority adjusted to %d\r\n"), tid, &name, priority);

		thread.Close();

		}

	}

CNewThreadNotifier::CNewThreadNotifier(CCmdSetpriority& aCmd, RMemoryAccess& aMemAccess)

	: CActive(CActive::EPriorityStandard), iCmd(aCmd), iMemAccess(aMemAccess)

	{

	CActiveScheduler::Add(this);

	}

CNewThreadNotifier::~CNewThreadNotifier()

	{

	Cancel();

	}

void CNewThreadNotifier::DoCancel()

	{

	iMemAccess.CancelNotifyThreadCreation();

	}

void CNewThreadNotifier::RunL()

	{

	TInt stat = iStatus.Int();

	if (stat >= 0)

		{

		Start();

		}

	iCmd.NewThread(stat);

	}

void CNewThreadNotifier::Start()

	{

	if (!IsActive())

		{

		iMemAccess.NotifyThreadCreation(iStatus);

		SetActive();

		}

	}