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

// e32test\demandpaging\t_dpcmn.cpp

// 

//

#include <e32test.h>

#include <dptest.h>

#include <e32hal.h>

#include <u32exec.h>

#include <e32svr.h>

#include <e32panic.h>

#include "u32std.h"

TInt gPageSize;

TBool gPagingSupported = EFalse;

TBool gRomPagingSupported = EFalse;

TBool gCodePagingSupported = EFalse;

TBool gDataPagingSupported = EFalse;

TInt gDataPagingPolicy;

TBool gProcessPaged;

TBool gGlobalNoPaging = EFalse;		

TBool gGlobalAlwaysPage = EFalse;

TBool gGlobalDefaultUnpaged = EFalse;	

TBool gGlobalDefaultPage = EFalse;

// Size of paging cache in pages

TUint gMinCacheSize = 0;

TUint gMaxCacheSize = 0;

TUint gCurrentCacheSize = 0;

RChunk gChunk;

//

// GetGlobalPolicies

//

// Determine the global dapaging policies as specified at rombuild time

//

TInt GetGlobalPolicies()

	{

	// Determine which types of paging are supported

	TUint32 attrs = DPTest::Attributes();

	gRomPagingSupported = (attrs & DPTest::ERomPaging) != 0;

	gCodePagingSupported = (attrs & DPTest::ECodePaging) != 0;

	gDataPagingSupported = (attrs & DPTest::EDataPaging) != 0;

	gPagingSupported = gRomPagingSupported || gCodePagingSupported || gDataPagingSupported;

	if (gRomPagingSupported)

		RDebug::Printf("Rom paging supported");

	if (gCodePagingSupported)

		RDebug::Printf("Code paging supported");

	if (gDataPagingSupported)

		RDebug::Printf("Data paging supported");	

	// Determine the data paging attributes

	TInt kernelFlags = UserSvr::HalFunction(EHalGroupKernel, EKernelHalConfigFlags, 0, 0);

	if (kernelFlags < 0)

		return kernelFlags;

	gDataPagingPolicy = kernelFlags & EKernelConfigDataPagingPolicyMask;

	if (gDataPagingPolicy == EKernelConfigDataPagingPolicyNoPaging)

		{

		RDebug::Printf("Global NO PAGING policy is set");

		gGlobalNoPaging = ETrue;

		}

	if (gDataPagingPolicy == EKernelConfigDataPagingPolicyAlwaysPage)

		{

		RDebug::Printf("Global ALWAYS PAGE policy is set");

		gGlobalAlwaysPage = ETrue;

		}

	if (gDataPagingPolicy == EKernelConfigDataPagingPolicyDefaultUnpaged)

		{

		RDebug::Printf("Global DEFAULT UNPAGED policy is set");

		gGlobalDefaultUnpaged = ETrue;

		}

	if (gDataPagingPolicy == EKernelConfigDataPagingPolicyDefaultPaged)

		{

		RDebug::Printf("Global DEFAULT PAGED policy is set");

		gGlobalDefaultPage = ETrue;

		}

	// Determine this process' data paging attribute

	RProcess process;	// Default to point to current process.

	gProcessPaged = process.DefaultDataPaged();

	RDebug::Printf(gProcessPaged ? "This process is paged" : "This process is not paged");

	// Get page size

	TInt r = UserHal::PageSizeInBytes(gPageSize);

	if (r != KErrNone)

		return r;

	if (gPagingSupported)

		{

		TUint minSize;

		TUint maxSize;

		TUint currentSize;

		r = DPTest::CacheSize(minSize, maxSize, currentSize);

		if (r != KErrNone)

			return r;

		gMinCacheSize = minSize / gPageSize;

		gMaxCacheSize = maxSize / gPageSize;

		gCurrentCacheSize = currentSize / gPageSize;

		RDebug::Printf("Cache size (pages): min == %d, max == %d, current == %d",

					   gMinCacheSize, gMaxCacheSize, gCurrentCacheSize);

		}

	return r;

	}

//

// IsDataPagingSupported

//

// Determine whether data paging is supported

//

TBool IsDataPagingSupported()

	{

	return gDataPagingSupported;

	}

//

// UpdatePaged

//

// Update whether the expected paged status based on the global paging policy.

//

void UpdatePaged(TBool& aPaged)

	{

	if (gGlobalNoPaging)

		aPaged = EFalse;

	if (gGlobalAlwaysPage)

		aPaged = ETrue;

	if (!gDataPagingSupported)

		aPaged = EFalse;

	}

// 

// TestThreadExit

//

// Resume the specified thread and verify the exit reason.

//

TInt TestThreadExit(RThread& aThread, TExitType aExitType, TInt aExitReason)

	{

	// Disable JIT debugging.

	TBool justInTime=User::JustInTime();

	User::SetJustInTime(EFalse);

	TRequestStatus status;

	aThread.Logon(status); 

	aThread.Resume();

	User::WaitForRequest(status);

	if (aExitType != aThread.ExitType())

		return KErrGeneral;

	if (aExitReason != status.Int())

		return KErrGeneral;

	if (aExitReason != aThread.ExitReason())

		return KErrGeneral;

	if (aExitType == EExitPanic)

		{

		if (aThread.ExitCategory()!=_L("USER"))

			{

			return KErrGeneral;

			}

		}

	CLOSE_AND_WAIT(aThread);

	// Put JIT debugging back to previous status.

	User::SetJustInTime(justInTime);

	return KErrNone;

	}