Changeset 19466 in vbox for trunk/src/VBox

Timestamp:

May 7, 2009 12:22:56 AM (16 years ago)

Author:

vboxsync

Message:

tstVMM,CFGM: Hacked together a TM testcase in tstVMM.

Location:

trunk/src/VBox/VMM

Files:

• CFGM.cpp (modified) (5 diffs)
• DBGFSym.cpp (modified) (1 diff)
• testcase/tstVMM.cpp (modified) (5 diffs)

trunk/src/VBox/VMM/CFGM.cpp

@@ -30 +30 @@
  * via the pfnCFGMConstructor parameter. To make testcase writing a bit simpler,
  * we allow the callback to be NULL, in which case a simple default
- * configuration will be created by cfgmR3CreateDefaultTree(). The
+ * configuration will be created by CFGMR3ConstructDefaultTree(). The
  * Console::configConstructor() method in Main/ConsoleImpl2.cpp creates the
  * configuration from the XML.
@@ -76 +76 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static int  cfgmR3CreateDefaultTree(PVM pVM);
 static void cfgmR3DumpPath(PCFGMNODE pNode, PCDBGFINFOHLP pHlp);
 static void cfgmR3Dump(PCFGMNODE pRoot, unsigned iLevel, PCDBGFINFOHLP pHlp);
@@ -114 +113 @@
 
     /*
-     * Create the configuration tree.
+     * Root Node.
      */
+    PCFGMNODE pRoot = (PCFGMNODE)MMR3HeapAllocZ(pVM, MM_TAG_CFGM, sizeof(*pRoot));
+    if (!pRoot)
+        return VERR_NO_MEMORY;
+    pRoot->pVM        = pVM;
+    pRoot->cchName    = 0;
+    pVM->cfgm.s.pRoot = pRoot;
+
+        /*
+         * Call the constructor if specified, if not use the default one.
+         */
     if (pfnCFGMConstructor)
-    {
-        /*
-         * Root Node.
-         */
-        PCFGMNODE pRoot = (PCFGMNODE)MMR3HeapAllocZ(pVM, MM_TAG_CFGM, sizeof(*pRoot));
-        if (!pRoot)
-            return VERR_NO_MEMORY;
-        pRoot->pVM           = pVM;
-        pRoot->cchName       = 0;
-        pVM->cfgm.s.pRoot   = pRoot;
-
-        /*
-         * Call the constructor.
-         */
         rc = pfnCFGMConstructor(pVM, pvUser);
-    }
     else
-        rc = cfgmR3CreateDefaultTree(pVM);
+        rc = CFGMR3ConstructDefaultTree(pVM);
     if (RT_SUCCESS(rc))
     {
@@ -740 +734 @@
 
 /**
- * Creates the default configuration.
- * This assumes an empty tree.
+ * Populates the CFGM tree with the default configuration.
+ *
+ * This assumes an empty tree and is intended for testcases and such that only
+ * need to do very small adjustments to the config.
  *
  * @returns VBox status code.
  * @param   pVM     VM handle.
  */
-static int cfgmR3CreateDefaultTree(PVM pVM)
+VMMR3DECL(int) CFGMR3ConstructDefaultTree(PVM pVM)
 {
     int rc;
@@ -752 +748 @@
 #define UPDATERC() do { if (RT_FAILURE(rc) && RT_SUCCESS(rcAll)) rcAll = rc; } while (0)
 
-    /*
-     * Root level.
-     */
-    PCFGMNODE pRoot = (PCFGMNODE)MMR3HeapAllocZ(pVM, MM_TAG_CFGM, sizeof(*pRoot));
-    if (!pRoot)
-        return VERR_NO_MEMORY;
-    pRoot->pVM           = pVM;
-    pRoot->cchName       = 0;
-
-    Assert(!pVM->cfgm.s.pRoot);
-    pVM->cfgm.s.pRoot   = pRoot;
+    PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
+    AssertReturn(pRoot, VERR_WRONG_ORDER);
 
     /*

trunk/src/VBox/VMM/DBGFSym.cpp

@@ -25 +25 @@
 *******************************************************************************/
 #define LOG_GROUP LOG_GROUP_DBGF
-#if defined(RT_OS_WINDOWS) && 0 //defined(DEBUG_bird) // enabled this is you want to debug win32 guests, the hypervisor of EFI.
+#if defined(RT_OS_WINDOWS) && 1 //defined(DEBUG_bird) // enabled this is you want to debug win32 guests, the hypervisor of EFI.
 # include <Windows.h>
 # define _IMAGEHLP64

trunk/src/VBox/VMM/testcase/tstVMM.cpp

@@ -34 +34 @@
 #include <iprt/semaphore.h>
 #include <iprt/stream.h>
+#include <iprt/test.h>
+#include <iprt/getopt.h>
+#include <iprt/ctype.h>
 
 
@@ -41 +44 @@
 #define TESTCASE    "tstVMM"
 
-VMMR3DECL(int) VMMDoTest(PVM pVM);
+
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+static uint32_t g_cCpus = 1;
+
+
+/*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+VMMR3DECL(int) VMMDoTest(PVM pVM); /* Linked into VMM, see ../VMMTests.cpp. */
+
+
+/** Dummy timer callback. */
+static DECLCALLBACK(void) tstTMDummyCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
+{
+    NOREF(pVM);
+    NOREF(pTimer);
+    NOREF(pvUser);
+}
+
+
+/**
+ * This is called on each EMT and will beat TM.
+ *
+ * @returns VINF_SUCCESS, test failure is reported via RTTEST.
+ * @param   pVM         The VM handle.
+ * @param   hTest       The test handle.
+ */
+DECLCALLBACK(int) tstTMWorker(PVM pVM, RTTEST hTest)
+{
+    VMCPUID idCpu = VMMGetCpuId(pVM);
+    RTTestPrintfNl(hTest,  RTTESTLVL_ALWAYS,  "idCpu=%d STARTING\n", idCpu);
+
+    /*
+     * Create the test set.
+     */
+    int rc;
+    PTMTIMER apTimers[5];
+    for (size_t i = 0; i < RT_ELEMENTS(apTimers); i++)
+    {
+        int rc = TMR3TimerCreateInternal(pVM, i & 1 ? TMCLOCK_VIRTUAL :  TMCLOCK_VIRTUAL_SYNC,
+                                         tstTMDummyCallback, NULL, "test timer",  &apTimers[i]);
+        RTTEST_CHECK_RET(hTest, RT_SUCCESS(rc), rc);
+    }
+
+    /*
+     * The run loop.
+     */
+    unsigned        uPrevPct = 0;
+    uint32_t const  cLoops   = 100000;
+    for (uint32_t iLoop = 0; iLoop < cLoops; iLoop++)
+    {
+        size_t      cLeft = RT_ELEMENTS(apTimers);
+        unsigned    i     = iLoop % RT_ELEMENTS(apTimers);
+        while (cLeft-- > 0)
+        {
+            PTMTIMER pTimer = apTimers[i];
+
+            if (cLeft == RT_ELEMENTS(apTimers) / 2
+                && TMTimerIsActive(pTimer))
+            {
+                rc = TMTimerStop(pTimer);
+                RTTEST_CHECK_MSG(hTest, RT_SUCCESS(rc), (hTest, "TMTimerStop: %Rrc\n",  rc));
+            }
+            else
+            {
+                rc = TMTimerSetMicro(pTimer, 50 + cLeft);
+                RTTEST_CHECK_MSG(hTest, RT_SUCCESS(rc), (hTest, "TMTimerSetMicro: %Rrc\n", rc));
+            }
+
+            /* next */
+            i = (i + 1) % RT_ELEMENTS(apTimers);
+        }
+
+        if (i % 3)
+            TMR3TimerQueuesDo(pVM);
+
+        /* Progress report. */
+        unsigned uPct = (unsigned)(100.0 * iLoop / cLoops);
+        if (uPct != uPrevPct)
+        {
+            uPrevPct = uPct;
+            if (!(uPct % 10))
+                RTTestPrintfNl(hTest,  RTTESTLVL_ALWAYS,  "idCpu=%d - %3u%%\n", idCpu, uPct);
+        }
+    }
+
+    RTTestPrintfNl(hTest,  RTTESTLVL_ALWAYS,  "idCpu=%d DONE\n", idCpu);
+    return 0;
+}
+
 
 /** PDMR3LdrEnumModules callback, see FNPDMR3ENUM. */
@@ -52 +147 @@
 }
 
+static DECLCALLBACK(int)
+tstVMMConfigConstructor(PVM pVM, void *pvUser)
+{
+    int rc = CFGMR3ConstructDefaultTree(pVM);
+    if (    RT_SUCCESS(rc)
+        &&  g_cCpus > 1)
+    {
+        PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
+        CFGMR3RemoveValue(pRoot, "NumCPUs");
+        rc = CFGMR3InsertInteger(pRoot, "NumCPUs", g_cCpus);
+        RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pRoot,\"NumCPUs\",) -> %Rrc\n", rc), rc);
+
+        CFGMR3RemoveValue(pRoot, "HwVirtExtForced");
+        rc = CFGMR3InsertInteger(pRoot, "HwVirtExtForced", true);
+        RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pRoot,\"HwVirtExtForced\",) -> %Rrc\n", rc), rc);
+
+        PCFGMNODE pHwVirtExt = CFGMR3GetChild(pRoot, "HWVirtExt");
+        CFGMR3RemoveNode(pHwVirtExt);
+        rc = CFGMR3InsertNode(pRoot, "HWVirtExt", &pHwVirtExt);
+        RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertNode(pRoot,\"HWVirtExt\",) -> %Rrc\n", rc), rc);
+        rc = CFGMR3InsertInteger(pHwVirtExt, "Enabled", true);
+        RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pHwVirtExt,\"Enabled\",) -> %Rrc\n", rc), rc);
+        rc = CFGMR3InsertInteger(pHwVirtExt, "64bitEnabled", false);
+        RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pHwVirtExt,\"64bitEnabled\",) -> %Rrc\n", rc), rc);
+    }
+    return rc;
+}
+
 
 int main(int argc, char **argv)
 {
-    int     rcRet = 0;                  /* error count. */
-
-    RTR3InitAndSUPLib();
-
-    /*
-     * Create empty VM.
+    /*
+     * Init runtime and the test environment.
+     */
+    int rc = RTR3InitAndSUPLib();
+    if (RT_FAILURE(rc))
+    {
+        RTPrintf("tstVMM: RTR3InitAndSUPLib failed: %Rrc\n", rc);
+        return 1;
+    }
+    RTTEST hTest;
+    rc = RTTestCreate("tstVMM", &hTest);
+    if (RT_FAILURE(rc))
+    {
+        RTPrintf("tstVMM: RTTestCreate failed: %Rrc\n", rc);
+        return 1;
+    }
+
+    /*
+     * Parse arguments.
+     */
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--cpus",          'c', RTGETOPT_REQ_UINT8 },
+        { "--test",          't', RTGETOPT_REQ_STRING },
+        { "--help",          'h', 0 },
+    };
+    enum
+    {
+        kTstVMMTest_VMM,  kTstVMMTest_TM
+    } enmTestOpt = kTstVMMTest_VMM;
+
+    int ch;
+    int i = 1;
+    RTGETOPTUNION ValueUnion;
+    RTGETOPTSTATE GetState;
+    RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
+    while ((ch = RTGetOpt(&GetState, &ValueUnion)))
+    {
+        switch (ch)
+        {
+            case 'c':
+                g_cCpus = ValueUnion.u8;
+                break;
+
+            case 't':
+                if (!strcmp("vmm", ValueUnion.psz))
+                    enmTestOpt = kTstVMMTest_VMM;
+                else if (!strcmp("tm", ValueUnion.psz))
+                    enmTestOpt = kTstVMMTest_TM;
+                else
+                {
+                    RTPrintf("tstVMM: unknown test: '%s'\n", ValueUnion.psz);
+                    return 1;
+                }
+                break;
+
+            case 'h':
+                RTPrintf("usage: tstVMM [--cpus|-c cpus] [--test <vmm|tm>]\n");
+                return 1;
+
+            case VINF_GETOPT_NOT_OPTION:
+                RTPrintf("tstVMM: syntax error: non option '%s'\n", ValueUnion.psz);
+                break;
+
+            default:
+                if (ch > 0)
+                {
+                    if (RT_C_IS_GRAPH(ch))
+                        RTPrintf("tstVMM: unhandled option: -%c\n", ch);
+                    else
+                        RTPrintf("tstVMM: unhandled option: %i\n", ch);
+                }
+                else if (ch == VERR_GETOPT_UNKNOWN_OPTION)
+                    RTPrintf("tstVMM: unknown option: %s\n", ValueUnion.psz);
+                else if (ValueUnion.pDef)
+                    RTPrintf("tstVMM: %s: %Rrs\n", ValueUnion.pDef->pszLong, ch);
+                else
+                    RTPrintf("tstVMM: %Rrs\n", ch);
+                return 1;
+        }
+    }
+
+    /*
+     * Create the test VM.
      */
     RTPrintf(TESTCASE ": Initializing...\n");
     PVM pVM;
-    int rc = VMR3Create(1, NULL, NULL, NULL, NULL, &pVM);
+    rc = VMR3Create(g_cCpus, NULL, NULL, tstVMMConfigConstructor, NULL, &pVM);
     if (RT_SUCCESS(rc))
     {
@@ -72 +273 @@
 
         /*
-         * Do testing.
+         * Do the requested testing.
          */
-        RTPrintf(TESTCASE ": Testing...\n");
-        PVMREQ pReq1 = NULL;
-        rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)VMMDoTest, 1, pVM);
-        AssertRC(rc);
-        VMR3ReqFree(pReq1);
+        switch (enmTestOpt)
+        {
+            case kTstVMMTest_VMM:
+            {
+                RTTestSub(hTest, "VMM");
+                PVMREQ pReq1 = NULL;
+                rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)VMMDoTest, 1, pVM);
+                if (RT_FAILURE(rc))
+                    RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
+                else if (RT_FAILURE(pReq1->iStatus))
+                    RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
+                VMR3ReqFree(pReq1);
+                break;
+            }
+
+            case kTstVMMTest_TM:
+            {
+                RTTestSub(hTest, "TM");
+                for (VMCPUID idCpu = 1; idCpu < g_cCpus; idCpu++)
+                {
+                    PVMREQ pReq = NULL;
+                    rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, 0, VMREQFLAGS_NO_WAIT,  (PFNRT)tstTMWorker, 2, pVM, hTest);
+                    if (RT_FAILURE(rc))
+                        RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
+                }
+
+                PVMREQ pReq1 = NULL;
+                rc = VMR3ReqCall(pVM, 0, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)tstTMWorker, 2, pVM, hTest);
+                if (RT_FAILURE(rc))
+                    RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
+                else if (RT_FAILURE(pReq1->iStatus))
+                    RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
+                VMR3ReqFree(pReq1);
+                break;
+            }
+        }
 
         STAMR3Dump(pVM, "*");
@@ -86 +318 @@
          */
         rc = VMR3Destroy(pVM);
-        if (!RT_SUCCESS(rc))
-        {
-            RTPrintf(TESTCASE ": error: failed to destroy vm! rc=%Rrc\n", rc);
-            rcRet++;
-        }
+        if (RT_FAILURE(rc))
+            RTTestFailed(hTest, "VMR3Destroy failed: rc=%Rrc\n", rc);
     }
     else
-    {
-        RTPrintf(TESTCASE ": fatal error: failed to create vm! rc=%Rrc\n", rc);
-        rcRet++;
-    }
-
-    return rcRet;
-}
+        RTTestFailed(hTest, "VMR3Create failed: rc=%Rrc\n", rc);
+
+    return RTTestSummaryAndDestroy(hTest);
+}