--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/mmu/t_wsd_tst.cpp Mon Mar 15 12:45:50 2010 +0200
@@ -0,0 +1,466 @@
+// 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:
+// e32test\mmu\t_wsd_tst.cpp
+// Test exporting and importing writable static data in DLLs.
+// This test relies on three dlls:
+// - t_wsd_dl1_[cx][pu] Which is statically linked, and exports both code & data
+// - t_wsd_dl2_[cx][pu] Which is dyanamically loaded, and imports code & writable static data from
+// - t_wsd_dl3_[cx][pu] Which exports code and writable static data
+// The [cx] suffix indicates code-in-RAM vs XIP (ROM), and [pu] indicate paged or unpaged code.
+//
+
+//! @SYMTestCaseID KBASE-T_CODEPAGING-0335
+//! @SYMTestType UT
+//! @SYMPREQ PREQ1110
+//! @SYMTestCaseDesc Demand Paging Code Paging tests.
+//! @SYMTestActions 001 Code paging tests
+//! @SYMTestExpectedResults All tests should pass.
+//! @SYMTestPriority High
+//! @SYMTestStatus Implemented
+
+#define __E32TEST_EXTENSION__
+#include <e32test.h>
+#include <e32math.h>
+#include <f32file.h>
+#include <f32dbg.h>
+
+#include "mmudetect.h"
+#include "t_wsd_tst.h"
+
+// Global data /////////////////////////////////////////////////////////////////
+
+_LIT(KSearchPathTemplate, "%c:\\sys\\bin"); // drive letter
+_LIT(KLibraryName, "t_wsd_dl%d_%c%c"); // [23] [cx] [pu]
+
+TInt TheFailure = KErrNone;
+TChar CurrentDrive = 'Z';
+
+void SetCurrentDrive(TChar aDrive)
+ {
+ CurrentDrive = aDrive;
+ }
+
+class TPagingDriveInfo
+ {
+public:
+ TChar iDriveLetter;
+ TDriveInfo iDriveInfo;
+ };
+
+RArray<TPagingDriveInfo> SupportedDrives;
+
+// RTest stuff /////////////////////////////////////////////////////////////////
+
+RTest test(_L("T_WSD"));
+
+#define test_noError(x) { TInt _r = (x); if (_r < 0) HandleError(_r, __LINE__); }
+#define test_notNull(x) { TAny* _a = (TAny*)(x); if (_a == NULL) HandleNull(__LINE__); }
+#define test_equal(e, a) { TInt _e = TInt(e); TInt _a = TInt(a); if (_e != _a) HandleNotEqual(_e, _a, __LINE__); }
+
+void HandleError(TInt aError, TInt aLine)
+ {
+ test.Printf(_L("Error %d\n"), aError);
+ test.operator()(EFalse, aLine);
+ }
+
+void HandleNull(TInt aLine)
+ {
+ test.Printf(_L("Null value\n"));
+ test.operator()(EFalse, aLine);
+ }
+
+void HandleNotEqual(TInt aExpected, TInt aActual, TInt aLine)
+ {
+ test.Printf(_L("Expected 0x%x but got 0x%x\n"), aExpected, aActual);
+ test.operator()(EFalse, aLine);
+ }
+
+// Utility functions ///////////////////////////////////////////////////////////
+
+TPtrC16 GetMediaType(TInt aMediaType)
+ {
+ _LIT(KMediaNotPresent, "MediaNotPresent");
+ _LIT(KMediaUnknown, "MediaUnknown");
+ _LIT(KMediaFloppy, "MediaFloppy");
+ _LIT(KMediaHardDisk, "MediaHardDisk");
+ _LIT(KMediaCdRom, "MediaCdRom");
+ _LIT(KMediaRam, "MediaRam");
+ _LIT(KMediaFlash, "MediaFlash");
+ _LIT(KMediaRom, "MediaRom");
+ _LIT(KMediaRemote, "MediaRemote");
+ _LIT(KMediaNANDFlash, "MediaNANDFlash");
+ _LIT(KMediaUnKnown, "MediaUnKnown");
+
+ switch (aMediaType)
+ {
+ case EMediaNotPresent:
+ return KMediaNotPresent();
+ case EMediaUnknown:
+ return KMediaUnknown();
+ case EMediaFloppy:
+ return KMediaFloppy();
+ case EMediaHardDisk:
+ return KMediaHardDisk();
+ case EMediaCdRom:
+ return KMediaCdRom();
+ case EMediaRam:
+ return KMediaRam();
+ case EMediaFlash:
+ return KMediaFlash();
+ case EMediaRom:
+ return KMediaRom();
+ case EMediaRemote:
+ return KMediaRemote();
+ case EMediaNANDFlash:
+ return KMediaNANDFlash();
+ default:
+ return KMediaUnKnown();
+ }
+ }
+
+// Get the list of testable drives
+void GetSupportedDrives(TBool aVerbose = EFalse)
+ {
+ TUint32 memModelAttributes = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);
+ TBool codePagingSupported = (memModelAttributes & EMemModelAttrCodePaging) != 0;
+ TUint32 pagingPolicy = E32Loader::PagingPolicy();
+ TBool pagingPolicyAllowsPaging = pagingPolicy != EKernelConfigCodePagingPolicyNoPaging;
+ test_Equal(codePagingSupported, pagingPolicyAllowsPaging);
+ if (codePagingSupported)
+ test.Printf(_L("Code paging is enabled.\n"));
+ else
+ test.Printf(_L("Code paging is NOT enabled.\n"));
+
+ if (aVerbose)
+ {
+ test.Printf(_L("Available drives:\n"));
+ test.Printf(_L(" Type Attr MedAttr Filesystem\n"));
+ }
+
+ RFs fs;
+ test_noError(fs.Connect());
+
+ TDriveList driveList;
+ TInt r = fs.DriveList(driveList);
+ test_noError(r);
+
+ TBool NandPageableMediaFound = EFalse;
+ for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)
+ {
+ if (!driveList[drvNum])
+ continue; //-- skip unexisting drive
+
+ TDriveInfo driveInfo;
+ r = fs.Drive(driveInfo, drvNum);
+ test_noError(r);
+
+ TChar ch;
+ r = fs.DriveToChar(drvNum, ch);
+ test_noError(r);
+
+ TBuf<256> fileSystemName;
+ r = fs.FileSystemName(fileSystemName, drvNum);
+ test_noError(r);
+
+ // Decide which drives to exclude:
+ // Locked/nonwritable drives, except the Z: ROM drive
+ // Win32 drives on the emulator
+ // Remote/nonlocal, removable/noninternal, redirected, substed drives
+ // All others are included by default iff code paging is supported
+ // If not, only the Z: ROM/XIP drive is tested
+ _LIT(KWin32FS, "Win32");
+ TBool include = codePagingSupported;
+ if (driveInfo.iDriveAtt & KDriveAttRom)
+ include = (ch == 'Z');
+ else if (driveInfo.iMediaAtt & (KMediaAttWriteProtected|KMediaAttLocked))
+ include = EFalse;
+ else if (fileSystemName == KWin32FS())
+ include = EFalse;
+ else if (driveInfo.iDriveAtt & (KDriveAttRedirected|KDriveAttSubsted|KDriveAttRemovable|KDriveAttRemote))
+ include = EFalse;
+ else if ((KDriveAttInternal|KDriveAttLocal) & ~driveInfo.iDriveAtt)
+ include = EFalse;
+
+ if (include)
+ {
+ TPagingDriveInfo pagingDriveInfo;
+ pagingDriveInfo.iDriveLetter = ch;
+ pagingDriveInfo.iDriveInfo = driveInfo;
+ r = SupportedDrives.Append(pagingDriveInfo);
+ test_noError(r);
+ }
+
+ TBool pageable = EFalse;
+ if (driveInfo.iDriveAtt & KDriveAttPageable)
+ {
+ pageable = ETrue;
+ if (driveInfo.iType == EMediaNANDFlash)
+ NandPageableMediaFound = ETrue;
+ }
+
+ // If we've already found a pageable NAND drive, then assume the
+ // Z: drive is pageable too if it's got a composite file system
+ _LIT(KCompositeName,"Composite");
+ if (NandPageableMediaFound && fileSystemName == KCompositeName())
+ pageable = ETrue;
+
+ if (aVerbose)
+ {
+ TPtrC16 mediaType = GetMediaType(driveInfo.iType);
+ _LIT(KPageable, "pageable");
+ test.Printf(_L("%c %c: %16S %08x %08x %10S %S\n"),
+ include ? '*' : ' ', (TUint)ch, &mediaType,
+ driveInfo.iDriveAtt, driveInfo.iMediaAtt,
+ &fileSystemName, (pageable ? &KPageable : &KNullDesC));
+ }
+ }
+
+ fs.Close();
+ }
+
+const TDesC& LibrarySearchPath(TChar aDrive)
+ {
+ static TBuf<64> path;
+ path.Format(KSearchPathTemplate, (TUint)aDrive);
+ return path;
+ }
+
+const TDesC& LibraryName(TChar aDrive, TInt aLibNo, TBool aRam, TBool aPaged)
+ {
+ // this gives DLL#2 a different name on each drive so we can be sure we're loading the right one
+ static TBuf<64> name;
+ name.Format(KLibraryName, aLibNo, aRam ? 'c' : 'x', aPaged ? 'p' : 'u');
+ if (aLibNo == 2 && aDrive != 'Z')
+ name.AppendFormat(_L("_%c"), (TUint)aDrive);
+ return name;
+ }
+
+const TDesC& LibraryFilename(TChar aDrive, TInt aLibNo, TBool aRam, TBool aPaged)
+ {
+ static TBuf<64> filename;
+ filename = LibrarySearchPath(aDrive);
+ filename.AppendFormat(_L("\\%S.dll"), &LibraryName(aDrive, aLibNo, aRam, aPaged));
+ return filename;
+ }
+
+TInt LoadSpecificLibrary(RLibrary& aLibrary, TChar aDrive, TInt aLibNo, TBool aRam, TBool aPaged)
+ {
+ const TDesC& path = LibrarySearchPath(aDrive);
+ const TDesC& name = LibraryName(aDrive, aLibNo, aRam, aPaged);
+ TInt err = aLibrary.Load(name, path);
+ TBuf<256> message;
+ message.Format(_L("Loading %S\\%S.dll returns %d\n"), &path, &name, err);
+ test.Printf(message);
+ return err;
+ }
+
+// Test functions //////////////////////////////////////////////////////////////
+
+void CopyDllToCurrentDrive(RFs& aFs, TBool aPaged, TInt aLibNo)
+ {
+ TBuf<64> source = LibraryFilename('Z', aLibNo, ETrue, aPaged);
+ TBuf<64> dest = LibraryFilename(CurrentDrive, aLibNo, ETrue, aPaged);
+ test.Printf(_L("Copying %S to %S\n"), &source, &dest);
+
+ TInt r = aFs.MkDirAll(dest);
+ test(r == KErrNone || r == KErrAlreadyExists);
+
+ TBuf<64> tempName(dest);
+ tempName.Append(_L(".tmp"));
+
+ RFile in, out, temp;
+ test_noError(in.Open(aFs, source, EFileRead));
+ test_noError(out.Replace(aFs, dest, EFileWrite));
+ test_noError(temp.Replace(aFs, tempName, EFileWrite));
+
+ const TInt KBufferSize = 3333;
+ TBuf8<KBufferSize> buffer;
+
+ test_noError(temp.Write(buffer));
+ test_noError(temp.Flush());
+
+ TInt size;
+ test_noError(in.Size(size));
+ TInt pos = 0;
+ while (pos < size)
+ {
+ test_noError(in.Read(buffer));
+ test_noError(out.Write(buffer));
+ test_noError(out.Flush());
+ test_noError(temp.Write(buffer));
+ test_noError(temp.Flush());
+ pos += buffer.Length();
+ }
+
+ out.SetAtt(KEntryAttNormal, KEntryAttReadOnly|
+ KEntryAttHidden|
+ KEntryAttSystem|
+ KEntryAttArchive|
+ KEntryAttXIP);
+
+ in.Close();
+ out.Close();
+ temp.Close();
+ }
+
+void CopyDllsToCurrentDrive()
+ {
+ RFs fs;
+ test_noError(fs.Connect());
+
+ CopyDllToCurrentDrive(fs, EFalse, 2); // Unpaged library 2
+ CopyDllToCurrentDrive(fs, EFalse, 3); // Unpaged library 3
+ CopyDllToCurrentDrive(fs, ETrue, 2); // Paged library 2
+ CopyDllToCurrentDrive(fs, ETrue, 3); // Paged library 3
+
+ fs.Close();
+ }
+
+void EraseDllsFromCurrentDrive()
+ {
+ RFs fs;
+ test_noError(fs.Connect());
+
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+ test_notNull(cleanup);
+
+ CFileMan* fileMan = NULL;
+ TRAPD(r, fileMan = CFileMan::NewL(fs));
+ test_noError(r);
+
+ TBuf<64> libdir = LibrarySearchPath(CurrentDrive);
+ test.Printf(_L("Erasing %S\n"), &libdir);
+ fileMan->RmDir(libdir);
+
+ delete fileMan;
+ delete cleanup;
+ fs.Close();
+ }
+
+void CheckRelocatableData(RLibrary& library)
+ {
+ TGetAddressOfDataFunction func = (TGetAddressOfDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);
+ test_notNull(func);
+
+ TInt size;
+ void* codeAddr;
+ void* dataAddr;
+ void*** dataPtrPtr = (void***)func(size, codeAddr, dataAddr);
+ void **dp = (void **)dataAddr;
+
+ for (TInt i = 0; i < size/4; i += 2)
+ {
+ test_equal(dp[i], codeAddr);
+ test_equal(dp[i+1], dataAddr);
+ }
+
+ test_equal(*dataPtrPtr, dp);
+ }
+
+void CheckWritableStaticData(RLibrary& library)
+ {
+ TInt (*func)(void) = (TInt (*)(void))library.Lookup(KCheckWritableStaticDataFunctionOrdinal);
+ RDebug::Printf("CheckWritableStaticData() is export %d at %08x", KCheckWritableStaticDataFunctionOrdinal, func);
+ test_notNull(func);
+ TInt err = func();
+ RDebug::Printf("CheckWritableStaticData() returned %d", err);
+ // test_noError(err);
+ if (TheFailure == KErrNone)
+ TheFailure = err;
+ }
+
+void RunPerDriveTests(TBool aPaged, TBool aRam)
+ {
+ TBuf<64> message = _L("Running ");
+ if (!aPaged)
+ message.Append(_L("un"));
+ message.AppendFormat(_L("paged R%cM tests on drive %c:"),
+ aRam ? 'A' : 'O', (TUint)CurrentDrive);
+ test.Next(message);
+
+ RFs fs;
+ test_noError(fs.Connect());
+ fs.SetDebugRegister(KFLDR);
+
+ // Explicitly loading dl2 will implicitly load dl3 as well
+ RLibrary dl2;
+ test_noError(LoadSpecificLibrary(dl2, CurrentDrive, 2, aRam, aPaged));
+ CheckRelocatableData(dl2);
+ CheckWritableStaticData(dl2);
+ dl2.Close();
+
+ fs.SetDebugRegister(0);
+ fs.Close();
+ }
+
+TInt E32Main()
+ {
+ test.Title();
+ test.Start(_L("WSD tests"));
+
+ // Check static linkage to dl1
+ test_noError(CheckExportedDataAddress(&ExportedData));
+
+ GetSupportedDrives(ETrue);
+ test(SupportedDrives.Count() > 0);
+
+ // Turn off evil lazy dll unloading
+ RLoader l;
+ test(l.Connect()==KErrNone);
+ test(l.CancelLazyDllUnload()==KErrNone);
+ l.Close();
+
+ // Make sure there aren't any DLLs left over from earlier tests
+ TInt i = SupportedDrives.Count();
+ while (--i >= 0)
+ {
+ SetCurrentDrive(SupportedDrives[i].iDriveLetter);
+ if (CurrentDrive != 'Z')
+ EraseDllsFromCurrentDrive();
+ }
+
+ // We want to test all supported drives in order of increasing priority, so
+ // that the CurrentDrive is always the hghest priority of those tested so far.
+ // Therefore, if Z (XIP ROM, lowest priority) is a valid test drive, do it first
+ i = SupportedDrives.Count();
+ if (--i >= 0)
+ {
+ SetCurrentDrive(SupportedDrives[i].iDriveLetter);
+ if (CurrentDrive == 'Z')
+ {
+ // ROM (XIP) tests can only be run from Z:
+ RunPerDriveTests(EFalse, EFalse); // Unpaged ROM
+ RunPerDriveTests(ETrue, EFalse); // Paged ROM
+ RunPerDriveTests(EFalse, ETrue); // Unpaged RAM
+ RunPerDriveTests(ETrue, ETrue); // Paged RAM
+ }
+ }
+
+ // Now run the RAM-based versions from each remaining drive in turn
+ for (i = 0; i < SupportedDrives.Count(); ++i)
+ {
+ SetCurrentDrive(SupportedDrives[i].iDriveLetter);
+ if (CurrentDrive != 'Z')
+ {
+ CopyDllsToCurrentDrive();
+ RunPerDriveTests(EFalse, ETrue); // Unpaged RAM
+ RunPerDriveTests(ETrue, ETrue); // Paged RAM
+ }
+ }
+
+ test_noError(TheFailure);
+ test.End();
+ return 0;
+ }
+