diff -r 000000000000 -r a41df078684a kerneltest/e32test/smr/d_smr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/smr/d_smr.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,448 @@ +// 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: +// Bootstrap Shadow Memory Region Test Driver +// + + +// -- INCLUDES ---------------------------------------------------------------- + +#include "d_trace.h" + +#include +#include +#include +#include +#include +#include +#include "d_smr.h" + + +// -- CLASSES ----------------------------------------------------------------- + + +class DSMRTestFactory : public DLogicalDevice + { +public: + virtual TInt Install(); + virtual void GetCaps(TDes8& aDes) const; + virtual TInt Create(DLogicalChannelBase*& aChannel); + }; + + +class DSMRTestChannel : public DLogicalChannelBase + { +public: + DSMRTestChannel(); + virtual ~DSMRTestChannel(); + + // Inherited from DObject + virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType); + + // Inherited from DLogicalChannelBase + virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer); + virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2); + +public: + static void TestTrace(DSMRTestChannel* aSelf); + +private: + DThread* iClient; + + }; + +TInt OpenDumpCloseChunk(TUint32 aBase, TUint32 aSize); + + +// -- GLOBALS ----------------------------------------------------------------- +// + + + +// -- METHODS ----------------------------------------------------------------- +// +// TEST FUNCTIONS +// + +static TInt ECtrlCheckSMRIBPtr() + { + SMR_FUNC("DSMRTestChannel::Request::ECtrlCheckSMRIBPtr"); + + TSuperPage& superPage = Kern::SuperPage(); + TLinAddr smrib = superPage.iSmrData; + + SMR_TRACE1("SMRIB - Virtual address %x", smrib); + + return smrib; + } + +static TInt ECtrlPrintSMRIB() + { + SMR_FUNC("DSMRTestChannel::Request::ECtrlPrintSMRIB"); + + TSuperPage& superPage = Kern::SuperPage(); + TLinAddr smrib = superPage.iSmrData; + + SMR_TRACE1("SMRIB - Virtual address %x", smrib); + + if (smrib == KSuperPageAddressFieldUndefined) + SMR_LOGMSG_RETURN ("SMRIB Does not exist!", KErrBadHandle); + + SSmrBank* smrPtr = (SSmrBank*)(smrib); + int x=0; + while (smrPtr->iBase != 0) + { + SMR_TRACE6("SMRIB entry %d (0x%x): %x, %x, %x, %x", x, smrPtr, smrPtr->iBase, smrPtr->iSize, smrPtr->iPayloadUID, smrPtr->iPayloadFlags); + x++; + smrPtr++; + } + if (x==0) + SMR_TRACE0("SMRIB Zero, no valid entries"); + else + SMR_TRACE1("SMRIB Contained %d entries", x); + + return x; + } + + +static TInt ECtrlAccessAllSMRs() + { + SMR_FUNC("DSMRTestChannel::Request::ECtrlAccessAllSMRs"); + + TInt err=0; + TSuperPage& superPage = Kern::SuperPage(); + TLinAddr smrib = superPage.iSmrData; + + if (smrib == KSuperPageAddressFieldUndefined) + return KErrBadHandle; + + SSmrBank* smrPtr = (SSmrBank*)(smrib); + int x=0; + while (smrPtr->iBase != 0) + { + SMR_TRACE6("SMRIB item %d (0x%x): %x, %x, %x, %x", x, smrPtr, smrPtr->iBase, smrPtr->iSize, smrPtr->iPayloadUID, smrPtr->iPayloadFlags); + + err = OpenDumpCloseChunk(smrPtr->iBase, smrPtr->iSize); + if (err != KErrNone) + return err; + + x++; + smrPtr++; + } + if (x==0) + SMR_TRACE0("SMRIB Zero, no valid entries"); + else + SMR_TRACE1("SMRIB Contained %d entries", x); + + return x; + } + + +static TInt ECtrlFreeHalfSMR1PhysicalRam() + { + SMR_FUNC("DSMRTestChannel::Request::ECtrlFreeHalfSMR1PhysicalRam"); + + TInt err=0; + TSuperPage& superPage = Kern::SuperPage(); + TLinAddr smrib = superPage.iSmrData; + + + if (smrib == KSuperPageAddressFieldUndefined) + return KErrBadHandle; + + SSmrBank* smrPtr = (SSmrBank*)(smrib); + int x=0; + + if ((smrPtr->iBase == 0) || (smrPtr->iSize == 0)) + SMR_LOGMSG_RETURN("SMRIB Does not contain one entry!", 0); + + SMR_TRACE6("SMRIB item before %d (0x%x): %x, %x, %x, %x", x, smrPtr, smrPtr->iBase, smrPtr->iSize, smrPtr->iPayloadUID, smrPtr->iPayloadFlags); + + TInt halfSize = smrPtr->iSize >> 1; + + NKern::ThreadEnterCS(); + err = Epoc::FreePhysicalRam(smrPtr->iBase+halfSize, halfSize); + NKern::ThreadLeaveCS(); + if (err != KErrNone) + SMR_LOGMSG_RETURN("Epoc::FreePhysicalRam() gave error", err) + else + SMR_TRACE0("Success - half of physical ram freed for SMR 1"); + + smrPtr->iSize = halfSize; + + SMR_TRACE6("SMRIB item after %d (0x%x): %x, %x, %x, %x", x, smrPtr, smrPtr->iBase, smrPtr->iSize, smrPtr->iPayloadUID, smrPtr->iPayloadFlags); + + err = OpenDumpCloseChunk(smrPtr->iBase, smrPtr->iSize); + if (err != KErrNone) + return err; + + return halfSize; + } + + +static TInt ECtrlFreeAllSMR2PhysicalRam() + { + SMR_FUNC("DSMRTestChannel::Request::ECtrlFreeAllSMR2PhysicalRam"); + + TInt err=0; + TSuperPage& superPage = Kern::SuperPage(); + TLinAddr smrib = superPage.iSmrData; + + if (smrib == KSuperPageAddressFieldUndefined) + return KErrBadHandle; + + SSmrBank* smrPtr = (SSmrBank*)(smrib); + int x=0; + + if ((smrPtr->iBase == 0) || (smrPtr->iSize == 0)) + SMR_LOGMSG_RETURN("SMRIB Does not contain first entry!", 0); + + smrPtr++; x++; + if ((smrPtr->iBase == 0) || (smrPtr->iSize == 0)) + SMR_LOGMSG_RETURN("SMRIB Does not contain two entries!", 0); + + smrPtr++; x++; + if ((smrPtr->iBase == 0) || (smrPtr->iSize == 0)) + SMR_LOGMSG_RETURN("SMRIB Does not contain three entries!", 0); + + SMR_TRACE6("SMRIB item before %d (0x%x): %x, %x, %x, %x", x, smrPtr, smrPtr->iBase, smrPtr->iSize, smrPtr->iPayloadUID, smrPtr->iPayloadFlags); + TInt sizeToFree = smrPtr->iSize; + + NKern::ThreadEnterCS(); + err = Epoc::FreePhysicalRam(smrPtr->iBase, sizeToFree); + NKern::ThreadLeaveCS(); + if (err != KErrNone) + SMR_LOGMSG_RETURN("Epoc::FreePhysicalRam() gave error", err) + else + SMR_TRACE0("Success - all physical ram freed for SMR 2"); + + + smrPtr->iBase = 0; + smrPtr->iSize = 0; + smrPtr->iPayloadUID = 0; + smrPtr->iPayloadFlags = 0; + + SMR_TRACE6("SMRIB item after %d (0x%x): %x, %x, %x, %x", x, smrPtr, smrPtr->iBase, smrPtr->iSize, smrPtr->iPayloadUID, smrPtr->iPayloadFlags); + return sizeToFree; + } + + +TInt OpenDumpCloseChunk(TUint32 aBase, TUint32 aSize) + { + TInt err; + TChunkCreateInfo cci; + DChunk *chunkPtr; + TLinAddr kernAddr = 0; + TUint32 mapAttr = 0; + + cci.iType = TChunkCreateInfo::ESharedKernelSingle; + cci.iMaxSize = 0x800000; + cci.iMapAttr = EMapAttrCachedMax | EMapAttrSupRw; + cci.iOwnsMemory = EFalse; + cci.iDestroyedDfc = 0; + + NKern::ThreadEnterCS(); + err = Kern::ChunkCreate(cci, chunkPtr, kernAddr, mapAttr); + NKern::ThreadLeaveCS(); + if (err != KErrNone) + SMR_LOGMSG_RETURN("Kern::ChunkCreate() gave error", err); + + NKern::ThreadEnterCS(); + err = Kern::ChunkCommitPhysical(chunkPtr, 0, aSize, aBase); + NKern::ThreadLeaveCS(); + if (err != KErrNone) + SMR_LOGMSG_RETURN("Kern::ChunkCommitPhysical() gave error", err); + + TUint32* setting = (TUint32*)(kernAddr); + SMR_TRACE1("SMR Image Memory Dump First Kb @ %08x", setting); + + for (TInt y=0; y < 0x80; y+=16) + { + SMR_TRACE5(" %08x: %08x %08x %08x %08x", setting, setting[0], setting[1], setting[2], setting[3]); + setting+=4; + } + + setting = (TUint32*)(kernAddr+aSize-0x80); + SMR_TRACE1("SMR Image Memory Dump Last Kb @ %08x", setting); + + for (TInt y=0; y < 0x80; y+=16) + { + SMR_TRACE5(" %08x: %08x %08x %08x %08x", setting, setting[0], setting[1], setting[2], setting[3]); + setting+=4; + } + + NKern::ThreadEnterCS(); + TBool chunkRefCntZero = Kern::ChunkClose(chunkPtr); + NKern::ThreadLeaveCS(); + if (chunkRefCntZero == 0) + SMR_LOGMSG_RETURN("Kern::ChunkClose gave false result", KErrGeneral); + + return KErrNone; + } + +// -- METHODS ----------------------------------------------------------------- +// +// DSMRTestFactory +// + +TInt DSMRTestFactory::Install() + { + SMR_FUNC("DSMRTestFactory::Install"); + return SetName(&RSMRTest::Name()); + } + +void DSMRTestFactory::GetCaps(TDes8& aDes) const + { + SMR_FUNC("DSMRTestFactory::GetCaps"); + Kern::InfoCopy(aDes,0,0); + } + +TInt DSMRTestFactory::Create(DLogicalChannelBase*& aChannel) + { + SMR_FUNC("DSMRTestFactory::Create"); + + aChannel=new DSMRTestChannel(); + if(!aChannel) + return KErrNoMemory; + return KErrNone; + } + + +// -- METHODS ----------------------------------------------------------------- +// +// DSMRTestChannel +// + +DSMRTestChannel::DSMRTestChannel() + { + SMR_FUNC("DSMRTestChannel"); + } + +DSMRTestChannel::~DSMRTestChannel() + { + SMR_FUNC("~DSMRTestChannel"); + } + +TInt DSMRTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/) + { + SMR_FUNC("DSMRTestChannel::DoCreate"); + + iClient = &Kern::CurrentThread(); + return KErrNone; + } + +TInt DSMRTestChannel::RequestUserHandle(DThread* aThread, TOwnerType aType) + { + SMR_FUNC("DSMRTestChannel::RequestUserHandle"); + + if (aType!=EOwnerThread || aThread!=iClient) + return KErrAccessDenied; + return KErrNone; + } + +TInt DSMRTestChannel::Request(TInt aReqNo, TAny* a1, TAny*) + { + SMR_FUNC("DSMRTestChannel::Request"); + TBool aEnforce = (TBool) a1; + + switch(aReqNo) + { + + case RSMRTest::ECtrlCheckSMRIBPtr: + { + TInt rc = ECtrlCheckSMRIBPtr(); + if (rc < 0) + return rc; + if (aEnforce && rc == 0) + return KErrBadHandle; + + break; // fall through, return KErrNone + } + + case RSMRTest::ECtrlPrintSMRIB: + { + TInt rc = ECtrlPrintSMRIB(); + if (rc < 0) + return rc; + if (aEnforce && rc == 0) + return KErrNotFound; + + break; // fall through, return KErrNone + } + + case RSMRTest::ECtrlAccessAllSMRs: + { + TInt rc = ECtrlAccessAllSMRs(); + if (rc < 0) + return rc; + if (aEnforce && rc == 0) + return KErrNotFound; + + break; // fall through, return KErrNone + } + + case RSMRTest::ECtrlFreeHalfSMR1PhysicalRam: + { + TInt rc = ECtrlFreeHalfSMR1PhysicalRam(); + if (rc < 0) + return rc; + if (aEnforce && rc == 0) + return KErrNotFound; + + break; // fall through, return KErrNone + } + + case RSMRTest::ECtrlFreeAllSMR2PhysicalRam: + { + + TInt rc = ECtrlFreeAllSMR2PhysicalRam(); + if (rc < 0) + return rc; + if (aEnforce && rc == 0) + return KErrNotFound; + + break; // fall through, return KErrNone + } + + default: + return KErrNotSupported; + } + + return KErrNone; + } + + +// -- GLOBALS ----------------------------------------------------------------- + + +DECLARE_STANDARD_LDD() + { + SMR_FUNC("D_SMR_DECLARE_STANDARD_LDD"); + + const TRomHeader& romHdr = Epoc::RomHeader(); + + TInt RHsize = sizeof(TRomHeader); + SMR_TRACE2("RomHeader - addr %0x; size %d", &romHdr, RHsize); + + TSuperPage& superPage = Kern::SuperPage(); + TInt SPsize = sizeof(SSuperPageBase); + + TInt startupReason = superPage.iHwStartupReason; + TLinAddr rootDirList = superPage.iRootDirList; + + SMR_TRACE2("SuperPage - addr %0x; size %d", &superPage, SPsize); + SMR_TRACE2("SuperPage - StartupReason: %0x; rootDirList %0x", startupReason, rootDirList); + + return new DSMRTestFactory; + } +