VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstVMM.cpp@ 25517

Last change on this file since 25517 was 25255, checked in by vboxsync, 15 years ago

tstVMM.cpp: -Wshadow
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.2 KB
Line 
1/* $Id: tstVMM.cpp 25255 2009-12-08 18:29:06Z vboxsync $ */
2/** @file
3 * VMM Testcase.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#include <VBox/vm.h>
27#include <VBox/vmm.h>
28#include <VBox/cpum.h>
29#include <VBox/pdm.h>
30#include <VBox/err.h>
31#include <VBox/log.h>
32#include <iprt/assert.h>
33#include <iprt/initterm.h>
34#include <iprt/semaphore.h>
35#include <iprt/stream.h>
36#include <iprt/test.h>
37#include <iprt/getopt.h>
38#include <iprt/ctype.h>
39#include <iprt/string.h>
40
41
42/*******************************************************************************
43* Defined Constants And Macros *
44*******************************************************************************/
45#define TESTCASE "tstVMM"
46
47
48
49/*******************************************************************************
50* Global Variables *
51*******************************************************************************/
52static uint32_t g_cCpus = 1;
53
54
55/*******************************************************************************
56* Internal Functions *
57*******************************************************************************/
58VMMR3DECL(int) VMMDoTest(PVM pVM); /* Linked into VMM, see ../VMMTests.cpp. */
59
60
61/** Dummy timer callback. */
62static DECLCALLBACK(void) tstTMDummyCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
63{
64 NOREF(pVM);
65 NOREF(pTimer);
66 NOREF(pvUser);
67}
68
69
70/**
71 * This is called on each EMT and will beat TM.
72 *
73 * @returns VINF_SUCCESS, test failure is reported via RTTEST.
74 * @param pVM The VM handle.
75 * @param hTest The test handle.
76 */
77DECLCALLBACK(int) tstTMWorker(PVM pVM, RTTEST hTest)
78{
79 VMCPUID idCpu = VMMGetCpuId(pVM);
80 RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "idCpu=%d STARTING\n", idCpu);
81
82 /*
83 * Create the test set.
84 */
85 int rc;
86 PTMTIMER apTimers[5];
87 for (size_t i = 0; i < RT_ELEMENTS(apTimers); i++)
88 {
89 rc = TMR3TimerCreateInternal(pVM, i & 1 ? TMCLOCK_VIRTUAL : TMCLOCK_VIRTUAL_SYNC,
90 tstTMDummyCallback, NULL, "test timer", &apTimers[i]);
91 RTTEST_CHECK_RET(hTest, RT_SUCCESS(rc), rc);
92 }
93
94 /*
95 * The run loop.
96 */
97 unsigned uPrevPct = 0;
98 uint32_t const cLoops = 100000;
99 for (uint32_t iLoop = 0; iLoop < cLoops; iLoop++)
100 {
101 size_t cLeft = RT_ELEMENTS(apTimers);
102 unsigned i = iLoop % RT_ELEMENTS(apTimers);
103 while (cLeft-- > 0)
104 {
105 PTMTIMER pTimer = apTimers[i];
106
107 if ( cLeft == RT_ELEMENTS(apTimers) / 2
108 && TMTimerIsActive(pTimer))
109 {
110 rc = TMTimerStop(pTimer);
111 RTTEST_CHECK_MSG(hTest, RT_SUCCESS(rc), (hTest, "TMTimerStop: %Rrc\n", rc));
112 }
113 else
114 {
115 rc = TMTimerSetMicro(pTimer, 50 + cLeft);
116 RTTEST_CHECK_MSG(hTest, RT_SUCCESS(rc), (hTest, "TMTimerSetMicro: %Rrc\n", rc));
117 }
118
119 /* next */
120 i = (i + 1) % RT_ELEMENTS(apTimers);
121 }
122
123 if (i % 3)
124 TMR3TimerQueuesDo(pVM);
125
126 /* Progress report. */
127 unsigned uPct = (unsigned)(100.0 * iLoop / cLoops);
128 if (uPct != uPrevPct)
129 {
130 uPrevPct = uPct;
131 if (!(uPct % 10))
132 RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "idCpu=%d - %3u%%\n", idCpu, uPct);
133 }
134 }
135
136 RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "idCpu=%d DONE\n", idCpu);
137 return 0;
138}
139
140
141/** PDMR3LdrEnumModules callback, see FNPDMR3ENUM. */
142static DECLCALLBACK(int)
143tstVMMLdrEnum(PVM pVM, const char *pszFilename, const char *pszName, RTUINTPTR ImageBase, size_t cbImage, bool fGC, void *pvUser)
144{
145 NOREF(pVM); NOREF(pszFilename); NOREF(fGC); NOREF(pvUser);
146 RTPrintf("tstVMM: %RTptr %s\n", ImageBase, pszName);
147 return VINF_SUCCESS;
148}
149
150static DECLCALLBACK(int)
151tstVMMConfigConstructor(PVM pVM, void *pvUser)
152{
153 int rc = CFGMR3ConstructDefaultTree(pVM);
154 if ( RT_SUCCESS(rc)
155 && g_cCpus > 1)
156 {
157 PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
158 CFGMR3RemoveValue(pRoot, "NumCPUs");
159 rc = CFGMR3InsertInteger(pRoot, "NumCPUs", g_cCpus);
160 RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pRoot,\"NumCPUs\",) -> %Rrc\n", rc), rc);
161
162 CFGMR3RemoveValue(pRoot, "HwVirtExtForced");
163 rc = CFGMR3InsertInteger(pRoot, "HwVirtExtForced", true);
164 RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pRoot,\"HwVirtExtForced\",) -> %Rrc\n", rc), rc);
165
166 PCFGMNODE pHwVirtExt = CFGMR3GetChild(pRoot, "HWVirtExt");
167 CFGMR3RemoveNode(pHwVirtExt);
168 rc = CFGMR3InsertNode(pRoot, "HWVirtExt", &pHwVirtExt);
169 RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertNode(pRoot,\"HWVirtExt\",) -> %Rrc\n", rc), rc);
170 rc = CFGMR3InsertInteger(pHwVirtExt, "Enabled", true);
171 RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pHwVirtExt,\"Enabled\",) -> %Rrc\n", rc), rc);
172 rc = CFGMR3InsertInteger(pHwVirtExt, "64bitEnabled", false);
173 RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc), ("CFGMR3InsertInteger(pHwVirtExt,\"64bitEnabled\",) -> %Rrc\n", rc), rc);
174 }
175 return rc;
176}
177
178
179int main(int argc, char **argv)
180{
181 /*
182 * Init runtime and the test environment.
183 */
184 int rc = RTR3InitAndSUPLib();
185 if (RT_FAILURE(rc))
186 {
187 RTPrintf("tstVMM: RTR3InitAndSUPLib failed: %Rrc\n", rc);
188 return 1;
189 }
190 RTTEST hTest;
191 rc = RTTestCreate("tstVMM", &hTest);
192 if (RT_FAILURE(rc))
193 {
194 RTPrintf("tstVMM: RTTestCreate failed: %Rrc\n", rc);
195 return 1;
196 }
197
198 /*
199 * Parse arguments.
200 */
201 static const RTGETOPTDEF s_aOptions[] =
202 {
203 { "--cpus", 'c', RTGETOPT_REQ_UINT8 },
204 { "--test", 't', RTGETOPT_REQ_STRING },
205 { "--help", 'h', 0 },
206 };
207 enum
208 {
209 kTstVMMTest_VMM, kTstVMMTest_TM
210 } enmTestOpt = kTstVMMTest_VMM;
211
212 int ch;
213 int i = 1;
214 RTGETOPTUNION ValueUnion;
215 RTGETOPTSTATE GetState;
216 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
217 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
218 {
219 switch (ch)
220 {
221 case 'c':
222 g_cCpus = ValueUnion.u8;
223 break;
224
225 case 't':
226 if (!strcmp("vmm", ValueUnion.psz))
227 enmTestOpt = kTstVMMTest_VMM;
228 else if (!strcmp("tm", ValueUnion.psz))
229 enmTestOpt = kTstVMMTest_TM;
230 else
231 {
232 RTPrintf("tstVMM: unknown test: '%s'\n", ValueUnion.psz);
233 return 1;
234 }
235 break;
236
237 case 'h':
238 RTPrintf("usage: tstVMM [--cpus|-c cpus] [--test <vmm|tm>]\n");
239 return 1;
240
241 case VINF_GETOPT_NOT_OPTION:
242 RTPrintf("tstVMM: syntax error: non option '%s'\n", ValueUnion.psz);
243 break;
244
245 default:
246 if (ch > 0)
247 {
248 if (RT_C_IS_GRAPH(ch))
249 RTPrintf("tstVMM: unhandled option: -%c\n", ch);
250 else
251 RTPrintf("tstVMM: unhandled option: %i\n", ch);
252 }
253 else if (ch == VERR_GETOPT_UNKNOWN_OPTION)
254 RTPrintf("tstVMM: unknown option: %s\n", ValueUnion.psz);
255 else if (ValueUnion.pDef)
256 RTPrintf("tstVMM: %s: %Rrs\n", ValueUnion.pDef->pszLong, ch);
257 else
258 RTPrintf("tstVMM: %Rrs\n", ch);
259 return 1;
260 }
261 }
262
263 /*
264 * Create the test VM.
265 */
266 RTPrintf(TESTCASE ": Initializing...\n");
267 PVM pVM;
268 rc = VMR3Create(g_cCpus, NULL, NULL, tstVMMConfigConstructor, NULL, &pVM);
269 if (RT_SUCCESS(rc))
270 {
271 PDMR3LdrEnumModules(pVM, tstVMMLdrEnum, NULL);
272 RTStrmFlush(g_pStdOut);
273 RTThreadSleep(256);
274
275 /*
276 * Do the requested testing.
277 */
278 switch (enmTestOpt)
279 {
280 case kTstVMMTest_VMM:
281 {
282 RTTestSub(hTest, "VMM");
283 rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMMDoTest, 1, pVM);
284 if (RT_FAILURE(rc))
285 RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
286 break;
287 }
288
289 case kTstVMMTest_TM:
290 {
291 RTTestSub(hTest, "TM");
292 for (VMCPUID idCpu = 1; idCpu < g_cCpus; idCpu++)
293 {
294 rc = VMR3ReqCallNoWaitU(pVM->pUVM, idCpu, (PFNRT)tstTMWorker, 2, pVM, hTest);
295 if (RT_FAILURE(rc))
296 RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
297 }
298
299 rc = VMR3ReqCallWait(pVM, 0 /*idDstCpu*/, (PFNRT)tstTMWorker, 2, pVM, hTest);
300 if (RT_FAILURE(rc))
301 RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
302 break;
303 }
304 }
305
306 STAMR3Dump(pVM, "*");
307
308 /*
309 * Cleanup.
310 */
311 rc = VMR3Destroy(pVM);
312 if (RT_FAILURE(rc))
313 RTTestFailed(hTest, "VMR3Destroy failed: rc=%Rrc\n", rc);
314 }
315 else
316 RTTestFailed(hTest, "VMR3Create failed: rc=%Rrc\n", rc);
317
318 return RTTestSummaryAndDestroy(hTest);
319}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette