VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstAnimate.cpp@ 84044

Last change on this file since 84044 was 82968, checked in by vboxsync, 4 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 32.1 KB
Line 
1/* $Id: tstAnimate.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * VBox Animation Testcase / Tool.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
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
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include <VBox/vmm/vm.h>
23#include <VBox/vmm/vmm.h>
24#include <VBox/vmm/cpum.h>
25#include <VBox/vmm/cfgm.h>
26#include <VBox/vmm/em.h>
27#include <VBox/vmm/pgm.h>
28#include <VBox/vmm/ssm.h>
29#include <VBox/vmm/dbgf.h>
30#include <VBox/err.h>
31#include <VBox/vmm/pdmifs.h>
32#include <VBox/param.h>
33#include <VBox/log.h>
34#include <iprt/assert.h>
35#include <iprt/alloc.h>
36#include <iprt/initterm.h>
37#include <iprt/semaphore.h>
38#include <iprt/string.h>
39#include <iprt/stream.h>
40#include <iprt/file.h>
41#include <iprt/thread.h>
42#include <iprt/ctype.h>
43#include <iprt/uuid.h>
44
45#include <signal.h>
46
47
48/*********************************************************************************************************************************
49* Global Variables *
50*********************************************************************************************************************************/
51static volatile bool g_fSignaled = false;
52
53
54static void SigInterrupt(int iSignal)
55{
56 NOREF(iSignal);
57 signal(SIGINT, SigInterrupt);
58 g_fSignaled = true;
59 RTPrintf("caught SIGINT\n");
60}
61
62typedef DECLCALLBACK(int) FNSETGUESTGPR(PVM, uint32_t);
63typedef FNSETGUESTGPR *PFNSETGUESTGPR;
64static int scriptGPReg(PVM pVM, char *pszVar, char *pszValue, void *pvUser)
65{
66 NOREF(pszVar);
67 uint32_t u32;
68 int rc = RTStrToUInt32Ex(pszValue, NULL, 16, &u32);
69 if (RT_FAILURE(rc))
70 return rc;
71 return ((PFNSETGUESTGPR)(uintptr_t)pvUser)(pVM, u32);
72}
73
74typedef DECLCALLBACK(int) FNSETGUESTSEL(PVM, uint16_t);
75typedef FNSETGUESTSEL *PFNSETGUESTSEL;
76static int scriptSelReg(PVM pVM, char *pszVar, char *pszValue, void *pvUser)
77{
78 NOREF(pszVar);
79 uint16_t u16;
80 int rc = RTStrToUInt16Ex(pszValue, NULL, 16, &u16);
81 if (RT_FAILURE(rc))
82 return rc;
83 return ((PFNSETGUESTSEL)(uintptr_t)pvUser)(pVM, u16);
84}
85
86typedef DECLCALLBACK(int) FNSETGUESTSYS(PVM, uint32_t);
87typedef FNSETGUESTSYS *PFNSETGUESTSYS;
88static int scriptSysReg(PVM pVM, char *pszVar, char *pszValue, void *pvUser)
89{
90 NOREF(pszVar);
91 uint32_t u32;
92 int rc = RTStrToUInt32Ex(pszValue, NULL, 16, &u32);
93 if (RT_FAILURE(rc))
94 return rc;
95 return ((PFNSETGUESTSYS)(uintptr_t)pvUser)(pVM, u32);
96}
97
98
99typedef DECLCALLBACK(int) FNSETGUESTDTR(PVM, uint32_t, uint16_t);
100typedef FNSETGUESTDTR *PFNSETGUESTDTR;
101static int scriptDtrReg(PVM pVM, char *pszVar, char *pszValue, void *pvUser)
102{
103 NOREF(pszVar);
104 char *pszPart2 = strchr(pszValue, ':');
105 if (!pszPart2)
106 return -1;
107 *pszPart2++ = '\0';
108 pszPart2 = RTStrStripL(pszPart2);
109 pszValue = RTStrStripR(pszValue);
110
111 uint32_t u32;
112 int rc = RTStrToUInt32Ex(pszValue, NULL, 16, &u32);
113 if (RT_FAILURE(rc))
114 return rc;
115
116 uint16_t u16;
117 rc = RTStrToUInt16Ex(pszPart2, NULL, 16, &u16);
118 if (RT_FAILURE(rc))
119 return rc;
120
121 return ((PFNSETGUESTDTR)(uintptr_t)pvUser)(pVM, u32, u16);
122}
123
124
125
126
127/* variables - putting in global scope to avoid MSC warning C4640. */
128static struct
129{
130 const char *pszVar;
131 int (*pfnHandler)(PVM pVM, char *pszVar, char *pszValue, void *pvUser);
132 PFNRT pvUser;
133} g_aVars[] =
134{
135 { "eax", scriptGPReg, (PFNRT)CPUMSetGuestEAX },
136 { "ebx", scriptGPReg, (PFNRT)CPUMSetGuestEBX },
137 { "ecx", scriptGPReg, (PFNRT)CPUMSetGuestECX },
138 { "edx", scriptGPReg, (PFNRT)CPUMSetGuestEDX },
139 { "esp", scriptGPReg, (PFNRT)CPUMSetGuestESP },
140 { "ebp", scriptGPReg, (PFNRT)CPUMSetGuestEBP },
141 { "esi", scriptGPReg, (PFNRT)CPUMSetGuestESI },
142 { "edi", scriptGPReg, (PFNRT)CPUMSetGuestEDI },
143 { "efl", scriptGPReg, (PFNRT)CPUMSetGuestEFlags },
144 { "eip", scriptGPReg, (PFNRT)CPUMSetGuestEIP },
145 { "ss", scriptSelReg, (PFNRT)CPUMSetGuestSS },
146 { "cs", scriptSelReg, (PFNRT)CPUMSetGuestCS },
147 { "ds", scriptSelReg, (PFNRT)CPUMSetGuestDS },
148 { "es", scriptSelReg, (PFNRT)CPUMSetGuestES },
149 { "fs", scriptSelReg, (PFNRT)CPUMSetGuestFS },
150 { "gs", scriptSelReg, (PFNRT)CPUMSetGuestGS },
151 { "cr0", scriptSysReg, (PFNRT)CPUMSetGuestCR0 },
152 { "cr2", scriptSysReg, (PFNRT)CPUMSetGuestCR2 },
153 { "cr3", scriptSysReg, (PFNRT)CPUMSetGuestCR3 },
154 { "cr4", scriptSysReg, (PFNRT)CPUMSetGuestCR4 },
155 { "ldtr",scriptSelReg, (PFNRT)CPUMSetGuestLDTR },
156 { "tr", scriptSelReg, (PFNRT)CPUMSetGuestTR },
157 { "idtr",scriptDtrReg, (PFNRT)CPUMSetGuestIDTR },
158 { "gdtr",scriptDtrReg, (PFNRT)CPUMSetGuestGDTR }
159};
160
161
162static int scriptCommand(PVM pVM, const char *pszIn, size_t cch)
163{
164 NOREF(cch);
165 int rc = VINF_SUCCESS;
166 char *psz = RTStrDup(pszIn);
167 char *pszEqual = strchr(psz, '=');
168 if (pszEqual)
169 {
170 /*
171 * var = value
172 */
173 *pszEqual = '\0';
174 RTStrStripR(psz);
175 char *pszValue = RTStrStrip(pszEqual + 1);
176
177 rc = -1;
178 for (unsigned i = 0; i < RT_ELEMENTS(g_aVars); i++)
179 {
180 if (!strcmp(psz, g_aVars[i].pszVar))
181 {
182 rc = g_aVars[i].pfnHandler(pVM, psz, pszValue, (void *)(uintptr_t)g_aVars[i].pvUser);
183 break;
184 }
185 }
186 }
187
188 RTStrFree(psz);
189 return rc;
190}
191
192static DECLCALLBACK(int) scriptRun(PVM pVM, RTFILE File)
193{
194 RTPrintf("info: running script...\n");
195 uint64_t cb;
196 int rc = RTFileQuerySize(File, &cb);
197 if (RT_SUCCESS(rc))
198 {
199 if (cb == 0)
200 return VINF_SUCCESS;
201 if (cb < _1M)
202 {
203 char *pszBuf = (char *)RTMemAllocZ(cb + 1);
204 if (pszBuf)
205 {
206 rc = RTFileRead(File, pszBuf, cb, NULL);
207 if (RT_SUCCESS(rc))
208 {
209 pszBuf[cb] = '\0';
210
211 /*
212 * Now process what's in the buffer.
213 */
214 char *psz = pszBuf;
215 while (psz && *psz)
216 {
217 /* skip blanks. */
218 while (RT_C_IS_SPACE(*psz))
219 psz++;
220 if (!*psz)
221 break;
222
223 /* end of line */
224 char *pszNext;
225 char *pszEnd = strchr(psz, '\n');
226 if (!pszEnd)
227 pszEnd = strchr(psz, '\r');
228 if (!pszEnd)
229 pszNext = pszEnd = strchr(psz, '\0');
230 else
231 pszNext = pszEnd + 1;
232
233 if (*psz != ';' && *psz != '#' && *psz != '/')
234 {
235 /* strip end */
236 *pszEnd = '\0';
237 while (pszEnd > psz && RT_C_IS_SPACE(pszEnd[-1]))
238 *--pszEnd = '\0';
239
240 /* process the line */
241 RTPrintf("debug: executing script line '%s'\n", psz);
242 rc = scriptCommand(pVM, psz, pszEnd - psz);
243 if (RT_FAILURE(rc))
244 {
245 RTPrintf("error: '%s' failed: %Rrc\n", psz, rc);
246 break;
247 }
248 }
249 /* else comment line */
250
251 /* next */
252 psz = pszNext;
253 }
254
255 }
256 else
257 RTPrintf("error: failed to read script file: %Rrc\n", rc);
258 RTMemFree(pszBuf);
259 }
260 else
261 {
262 RTPrintf("error: Out of memory. (%d bytes)\n", cb + 1);
263 rc = VERR_NO_MEMORY;
264 }
265 }
266 else
267 RTPrintf("error: script file is too large (0x%llx bytes)\n", cb);
268 }
269 else
270 RTPrintf("error: couldn't get size of script file: %Rrc\n", rc);
271
272 return rc;
273}
274
275
276static DECLCALLBACK(int) loadMem(PVM pVM, RTFILE File, uint64_t *poff)
277{
278 uint64_t off = *poff;
279 RTPrintf("info: loading memory...\n");
280
281 int rc = RTFileSeek(File, off, RTFILE_SEEK_BEGIN, NULL);
282 if (RT_SUCCESS(rc))
283 {
284 RTGCPHYS GCPhys = 0;
285 for (;;)
286 {
287 if (!(GCPhys % (PAGE_SIZE * 0x1000)))
288 RTPrintf("info: %RGp...\n", GCPhys);
289
290 /* read a page from the file */
291 size_t cbRead = 0;
292 uint8_t au8Page[PAGE_SIZE * 16];
293 rc = RTFileRead(File, &au8Page, sizeof(au8Page), &cbRead);
294 if (RT_SUCCESS(rc) && !cbRead)
295 rc = RTFileRead(File, &au8Page, sizeof(au8Page), &cbRead);
296 if (RT_SUCCESS(rc) && !cbRead)
297 rc = VERR_EOF;
298 if (RT_FAILURE(rc) || rc == VINF_EOF)
299 {
300 if (rc == VERR_EOF)
301 rc = VINF_SUCCESS;
302 else
303 RTPrintf("error: Read error %Rrc while reading the raw memory file.\n", rc);
304 break;
305 }
306
307 /* Write that page to the guest - skip known rom areas for now. */
308 if (GCPhys < 0xa0000 || GCPhys >= 0x100000) /* ASSUME size of a8Page is a power of 2. */
309 PGMPhysWrite(pVM, GCPhys, &au8Page, cbRead, PGMACCESSORIGIN_DEBUGGER);
310 GCPhys += cbRead;
311 }
312 }
313 else
314 RTPrintf("error: Failed to seek to 0x%llx in the raw memory file. rc=%Rrc\n", off, rc);
315
316 return rc;
317}
318
319
320/**
321 * Creates the default configuration.
322 * This assumes an empty tree.
323 *
324 * @returns VBox status code.
325 * @param pVM Pointer to the VM.
326 */
327static DECLCALLBACK(int) cfgmR3CreateDefault(PUVM pUVM, PVM pVM, void *pvUser)
328{
329 RT_NOREF1(pUVM);
330 uint64_t cbMem = *(uint64_t *)pvUser;
331 int rc;
332 int rcAll = VINF_SUCCESS;
333 bool fIOAPIC = false;
334#define UPDATERC() do { if (RT_FAILURE(rc) && RT_SUCCESS(rcAll)) rcAll = rc; } while (0)
335
336 /*
337 * Create VM default values.
338 */
339 PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
340 rc = CFGMR3InsertString(pRoot, "Name", "Default VM");
341 UPDATERC();
342 rc = CFGMR3InsertInteger(pRoot, "RamSize", cbMem);
343 UPDATERC();
344 rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10);
345 UPDATERC();
346 rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 0);
347 UPDATERC();
348 /** @todo CFGM Defaults: RawR0, PATMEnabled and CASMEnabled needs attention later. */
349 rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 0);
350 UPDATERC();
351 rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 0);
352 UPDATERC();
353 rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 0);
354 UPDATERC();
355
356 /*
357 * PDM.
358 */
359 PCFGMNODE pPdm;
360 rc = CFGMR3InsertNode(pRoot, "PDM", &pPdm);
361 UPDATERC();
362 PCFGMNODE pDevices = NULL;
363 rc = CFGMR3InsertNode(pPdm, "Devices", &pDevices);
364 UPDATERC();
365 rc = CFGMR3InsertInteger(pDevices, "LoadBuiltin", 1); /* boolean */
366 UPDATERC();
367 PCFGMNODE pDrivers = NULL;
368 rc = CFGMR3InsertNode(pPdm, "Drivers", &pDrivers);
369 UPDATERC();
370 rc = CFGMR3InsertInteger(pDrivers, "LoadBuiltin", 1); /* boolean */
371 UPDATERC();
372
373
374 /*
375 * Devices
376 */
377 pDevices = NULL;
378 rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices);
379 UPDATERC();
380 /* device */
381 PCFGMNODE pDev = NULL;
382 PCFGMNODE pInst = NULL;
383 PCFGMNODE pCfg = NULL;
384#if 0
385 PCFGMNODE pLunL0 = NULL;
386 PCFGMNODE pLunL1 = NULL;
387#endif
388
389 /*
390 * PC Arch.
391 */
392 rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev);
393 UPDATERC();
394 rc = CFGMR3InsertNode(pDev, "0", &pInst);
395 UPDATERC();
396 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
397 UPDATERC();
398 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
399 UPDATERC();
400
401 /*
402 * PC Bios.
403 */
404 rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev);
405 UPDATERC();
406 rc = CFGMR3InsertNode(pDev, "0", &pInst);
407 UPDATERC();
408 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
409 UPDATERC();
410 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
411 UPDATERC();
412 rc = CFGMR3InsertString(pCfg, "BootDevice0", "IDE");
413 UPDATERC();
414 rc = CFGMR3InsertString(pCfg, "BootDevice1", "NONE");
415 UPDATERC();
416 rc = CFGMR3InsertString(pCfg, "BootDevice2", "NONE");
417 UPDATERC();
418 rc = CFGMR3InsertString(pCfg, "BootDevice3", "NONE");
419 UPDATERC();
420 rc = CFGMR3InsertString(pCfg, "HardDiskDevice", "piix3ide");
421 UPDATERC();
422 rc = CFGMR3InsertString(pCfg, "FloppyDevice", "i82078");
423 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); UPDATERC();
424 RTUUID Uuid;
425 RTUuidClear(&Uuid);
426 rc = CFGMR3InsertBytes(pCfg, "UUID", &Uuid, sizeof(Uuid)); UPDATERC();
427 /* Bios logo. */
428 rc = CFGMR3InsertInteger(pCfg, "FadeIn", 0);
429 UPDATERC();
430 rc = CFGMR3InsertInteger(pCfg, "FadeOut", 0);
431 UPDATERC();
432 rc = CFGMR3InsertInteger(pCfg, "LogoTime", 0);
433 UPDATERC();
434 rc = CFGMR3InsertString(pCfg, "LogoFile", "");
435 UPDATERC();
436
437 /*
438 * ACPI
439 */
440 rc = CFGMR3InsertNode(pDevices, "acpi", &pDev); UPDATERC();
441 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
442 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
443 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
444 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); UPDATERC();
445 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 7); UPDATERC();
446 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATERC();
447
448 /*
449 * DMA
450 */
451 rc = CFGMR3InsertNode(pDevices, "8237A", &pDev); UPDATERC();
452 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
453 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
454
455 /*
456 * PCI bus.
457 */
458 rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */
459 UPDATERC();
460 rc = CFGMR3InsertNode(pDev, "0", &pInst);
461 UPDATERC();
462 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
463 UPDATERC();
464 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
465 UPDATERC();
466 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); UPDATERC();
467
468 /*
469 * PS/2 keyboard & mouse
470 */
471 rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev);
472 UPDATERC();
473 rc = CFGMR3InsertNode(pDev, "0", &pInst);
474 UPDATERC();
475 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
476 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
477 UPDATERC();
478
479 /*
480 * Floppy
481 */
482 rc = CFGMR3InsertNode(pDevices, "i82078", &pDev); UPDATERC();
483 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
484 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); UPDATERC();
485 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
486 rc = CFGMR3InsertInteger(pCfg, "IRQ", 6); UPDATERC();
487 rc = CFGMR3InsertInteger(pCfg, "DMA", 2); UPDATERC();
488 rc = CFGMR3InsertInteger(pCfg, "MemMapped", 0 ); UPDATERC();
489 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f0); UPDATERC();
490
491 /*
492 * i8254 Programmable Interval Timer And Dummy Speaker
493 */
494 rc = CFGMR3InsertNode(pDevices, "i8254", &pDev);
495 UPDATERC();
496 rc = CFGMR3InsertNode(pDev, "0", &pInst);
497 UPDATERC();
498 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
499 UPDATERC();
500
501 /*
502 * i8259 Programmable Interrupt Controller.
503 */
504 rc = CFGMR3InsertNode(pDevices, "i8259", &pDev);
505 UPDATERC();
506 rc = CFGMR3InsertNode(pDev, "0", &pInst);
507 UPDATERC();
508 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
509 UPDATERC();
510 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
511 UPDATERC();
512
513 /*
514 * APIC.
515 */
516 rc = CFGMR3InsertNode(pDevices, "apic", &pDev); UPDATERC();
517 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
518 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
519 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
520 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); UPDATERC();
521
522 if (fIOAPIC)
523 {
524 /*
525 * I/O Advanced Programmable Interrupt Controller.
526 */
527 rc = CFGMR3InsertNode(pDevices, "ioapic", &pDev); UPDATERC();
528 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
529 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
530 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
531 }
532
533
534 /*
535 * RTC MC146818.
536 */
537 rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev); UPDATERC();
538 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
539 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
540
541 /*
542 * VGA.
543 */
544 rc = CFGMR3InsertNode(pDevices, "vga", &pDev); UPDATERC();
545 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
546 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
547 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 2); UPDATERC();
548 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATERC();
549 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
550 rc = CFGMR3InsertInteger(pCfg, "VRamSize", 8 * _1M); UPDATERC();
551 rc = CFGMR3InsertInteger(pCfg, "CustomVideoModes", 0);
552 rc = CFGMR3InsertInteger(pCfg, "HeightReduction", 0); UPDATERC();
553 //rc = CFGMR3InsertInteger(pCfg, "MonitorCount", 1); UPDATERC();
554
555 /*
556 * IDE controller.
557 */
558 rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */
559 UPDATERC();
560 rc = CFGMR3InsertNode(pDev, "0", &pInst);
561 UPDATERC();
562 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */
563 UPDATERC();
564 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
565 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 1); UPDATERC();
566 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 1); UPDATERC();
567
568 /*
569 * Network card.
570 */
571 rc = CFGMR3InsertNode(pDevices, "pcnet", &pDev); UPDATERC();
572 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
573 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
574 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 3); UPDATERC();
575 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATERC();
576 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
577 rc = CFGMR3InsertInteger(pCfg, "Am79C973", 1); UPDATERC();
578 RTMAC Mac;
579 Mac.au16[0] = 0x0080;
580 Mac.au16[2] = Mac.au16[1] = 0x8086;
581 rc = CFGMR3InsertBytes(pCfg, "MAC", &Mac, sizeof(Mac)); UPDATERC();
582
583 /*
584 * VMM Device
585 */
586 rc = CFGMR3InsertNode(pDevices, "VMMDev", &pDev); UPDATERC();
587 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATERC();
588 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATERC();
589 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATERC();
590 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 4); UPDATERC();
591 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATERC();
592
593 /*
594 * ...
595 */
596
597#undef UPDATERC
598 return rcAll;
599}
600
601static void syntax(void)
602{
603 RTPrintf("Syntax: tstAnimate < -r <raw-mem-file> | -z <saved-state> > \n"
604 " [-o <rawmem offset>]\n"
605 " [-s <script file>]\n"
606 " [-m <memory size>]\n"
607 " [-w <warp drive percent>]\n"
608 " [-p]\n"
609 "\n"
610 "The script is on the form:\n"
611 "<reg>=<value>\n");
612}
613
614
615/**
616 * Entry point.
617 */
618extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
619{
620 RT_NOREF1(envp);
621 int rcRet = 1;
622 int rc;
623 RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
624
625 /*
626 * Parse input.
627 */
628 if (argc <= 1)
629 {
630 syntax();
631 return 1;
632 }
633
634 bool fPowerOn = false;
635 uint32_t u32WarpDrive = 100; /* % */
636 uint64_t cbMem = ~0ULL;
637 const char *pszSavedState = NULL;
638 const char *pszRawMem = NULL;
639 uint64_t offRawMem = 0;
640 const char *pszScript = NULL;
641 for (int i = 1; i < argc; i++)
642 {
643 if (argv[i][0] == '-')
644 {
645 /* check that it's on short form */
646 if (argv[i][2])
647 {
648 if ( strcmp(argv[i], "--help")
649 && strcmp(argv[i], "-help"))
650 RTPrintf("tstAnimate: Syntax error: Unknown argument '%s'.\n", argv[i]);
651 else
652 syntax();
653 return 1;
654 }
655
656 /* check for 2nd argument */
657 switch (argv[i][1])
658 {
659 case 'r':
660 case 'o':
661 case 'c':
662 case 'm':
663 case 'w':
664 case 'z':
665 if (i + 1 < argc)
666 break;
667 RTPrintf("tstAnimate: Syntax error: '%s' takes a 2nd argument.\n", argv[i]);
668 return 1;
669 }
670
671 /* process argument */
672 switch (argv[i][1])
673 {
674 case 'r':
675 pszRawMem = argv[++i];
676 break;
677
678 case 'z':
679 pszSavedState = argv[++i];
680 break;
681
682 case 'o':
683 {
684 rc = RTStrToUInt64Ex(argv[++i], NULL, 0, &offRawMem);
685 if (RT_FAILURE(rc))
686 {
687 RTPrintf("tstAnimate: Syntax error: Invalid offset given to -o.\n");
688 return 1;
689 }
690 break;
691 }
692
693 case 'm':
694 {
695 char *pszNext;
696 rc = RTStrToUInt64Ex(argv[++i], &pszNext, 0, &cbMem);
697 if (RT_FAILURE(rc))
698 {
699 RTPrintf("tstAnimate: Syntax error: Invalid memory size given to -m.\n");
700 return 1;
701 }
702 switch (*pszNext)
703 {
704 case 'G': cbMem *= _1G; pszNext++; break;
705 case 'M': cbMem *= _1M; pszNext++; break;
706 case 'K': cbMem *= _1K; pszNext++; break;
707 case '\0': break;
708 default:
709 RTPrintf("tstAnimate: Syntax error: Invalid memory size given to -m.\n");
710 return 1;
711 }
712 if (*pszNext)
713 {
714 RTPrintf("tstAnimate: Syntax error: Invalid memory size given to -m.\n");
715 return 1;
716 }
717 break;
718 }
719
720 case 's':
721 pszScript = argv[++i];
722 break;
723
724 case 'p':
725 fPowerOn = true;
726 break;
727
728 case 'w':
729 {
730 rc = RTStrToUInt32Ex(argv[++i], NULL, 0, &u32WarpDrive);
731 if (RT_FAILURE(rc))
732 {
733 RTPrintf("tstAnimate: Syntax error: Invalid number given to -w.\n");
734 return 1;
735 }
736 break;
737 }
738
739 case 'h':
740 case 'H':
741 case '?':
742 syntax();
743 return 1;
744
745 default:
746 RTPrintf("tstAnimate: Syntax error: Unknown argument '%s'.\n", argv[i]);
747 return 1;
748 }
749 }
750 else
751 {
752 RTPrintf("tstAnimate: Syntax error at arg no. %d '%s'.\n", i, argv[i]);
753 syntax();
754 return 1;
755 }
756 }
757
758 /*
759 * Check that the basic requirements are met.
760 */
761 if (pszRawMem && pszSavedState)
762 {
763 RTPrintf("tstAnimate: Syntax error: Either -z or -r, not both.\n");
764 return 1;
765 }
766 if (!pszRawMem && !pszSavedState)
767 {
768 RTPrintf("tstAnimate: Syntax error: The -r argument is compulsory.\n");
769 return 1;
770 }
771
772 /*
773 * Open the files.
774 */
775 RTFILE FileRawMem = NIL_RTFILE;
776 if (pszRawMem)
777 {
778 rc = RTFileOpen(&FileRawMem, pszRawMem, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
779 if (RT_FAILURE(rc))
780 {
781 RTPrintf("tstAnimate: error: Failed to open '%s': %Rrc\n", pszRawMem, rc);
782 return 1;
783 }
784 }
785 RTFILE FileScript = NIL_RTFILE;
786 if (pszScript)
787 {
788 rc = RTFileOpen(&FileScript, pszScript, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
789 if (RT_FAILURE(rc))
790 {
791 RTPrintf("tstAnimate: error: Failed to open '%s': %Rrc\n", pszScript, rc);
792 return 1;
793 }
794 }
795
796 /*
797 * Figure the memsize if not specified.
798 */
799 if (cbMem == ~0ULL)
800 {
801 if (FileRawMem != NIL_RTFILE)
802 {
803 rc = RTFileQuerySize(FileRawMem, &cbMem);
804 AssertReleaseRC(rc);
805 cbMem -= offRawMem;
806 cbMem &= ~(PAGE_SIZE - 1);
807 }
808 else
809 {
810 RTPrintf("tstAnimate: error: too lazy to figure out the memsize in a saved state.\n");
811 return 1;
812 }
813 }
814 RTPrintf("tstAnimate: info: cbMem=0x%llx bytes\n", cbMem);
815
816 /*
817 * Open a release log.
818 */
819 static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
820 PRTLOGGER pRelLogger;
821 rc = RTLogCreate(&pRelLogger, RTLOGFLAGS_PREFIX_TIME_PROG, "all", "VBOX_RELEASE_LOG",
822 RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_FILE, "./tstAnimate.log");
823 if (RT_SUCCESS(rc))
824 RTLogRelSetDefaultInstance(pRelLogger);
825 else
826 RTPrintf("tstAnimate: rtLogCreateEx failed - %Rrc\n", rc);
827
828 /*
829 * Create empty VM.
830 */
831 PVM pVM;
832 PUVM pUVM;
833 rc = VMR3Create(1, NULL, NULL, NULL, cfgmR3CreateDefault, &cbMem, &pVM, &pUVM);
834 if (RT_SUCCESS(rc))
835 {
836 /*
837 * Load memory.
838 */
839 if (FileRawMem != NIL_RTFILE)
840 rc = VMR3ReqCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)loadMem, 3, pVM, FileRawMem, &offRawMem);
841 else
842 rc = VMR3ReqCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)SSMR3Load,
843 7, pVM, pszSavedState, (uintptr_t)NULL /*pStreamOps*/, (uintptr_t)NULL /*pvUser*/,
844 SSMAFTER_DEBUG_IT, (uintptr_t)NULL /*pfnProgress*/, (uintptr_t)NULL /*pvProgressUser*/);
845 if (RT_SUCCESS(rc))
846 {
847 /*
848 * Load register script.
849 */
850 if (FileScript != NIL_RTFILE)
851 rc = VMR3ReqCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)scriptRun, 2, pVM, FileScript);
852 if (RT_SUCCESS(rc))
853 {
854 if (fPowerOn)
855 {
856 /*
857 * Adjust warpspeed?
858 */
859 if (u32WarpDrive != 100)
860 {
861 rc = TMR3SetWarpDrive(pUVM, u32WarpDrive);
862 if (RT_FAILURE(rc))
863 RTPrintf("warning: TMVirtualSetWarpDrive(,%u) -> %Rrc\n", u32WarpDrive, rc);
864 }
865
866 /*
867 * Start the thing with single stepping and stuff enabled.
868 * (Try make sure we don't execute anything in raw mode.)
869 */
870 RTPrintf("info: powering on the VM...\n");
871 RTLogGroupSettings(NULL, "+REM_DISAS.e.l.f");
872 rc = VERR_NOT_IMPLEMENTED; /** @todo need some EM single-step indicator (was REMR3DisasEnableStepping) */
873 if (RT_SUCCESS(rc))
874 {
875 rc = EMR3SetExecutionPolicy(pUVM, EMEXECPOLICY_RECOMPILE_RING0, true); AssertReleaseRC(rc);
876 rc = EMR3SetExecutionPolicy(pUVM, EMEXECPOLICY_RECOMPILE_RING3, true); AssertReleaseRC(rc);
877 DBGFR3Info(pUVM, "cpumguest", "verbose", NULL);
878 if (fPowerOn)
879 rc = VMR3PowerOn(pUVM);
880 if (RT_SUCCESS(rc))
881 {
882 RTPrintf("info: VM is running\n");
883 signal(SIGINT, SigInterrupt);
884 while (!g_fSignaled)
885 RTThreadSleep(1000);
886 }
887 else
888 RTPrintf("error: Failed to power on the VM: %Rrc\n", rc);
889 }
890 else
891 RTPrintf("error: Failed to enabled singlestepping: %Rrc\n", rc);
892 }
893 else
894 {
895 /*
896 * Don't start it, just enter the debugger.
897 */
898 RTPrintf("info: entering debugger...\n");
899 DBGFR3Info(pUVM, "cpumguest", "verbose", NULL);
900 signal(SIGINT, SigInterrupt);
901 while (!g_fSignaled)
902 RTThreadSleep(1000);
903 }
904 RTPrintf("info: shutting down the VM...\n");
905 }
906 /* execScript complains */
907 }
908 else if (FileRawMem == NIL_RTFILE) /* loadMem complains, SSMR3Load doesn't */
909 RTPrintf("tstAnimate: error: SSMR3Load failed: rc=%Rrc\n", rc);
910 rcRet = RT_SUCCESS(rc) ? 0 : 1;
911
912 /*
913 * Cleanup.
914 */
915 rc = VMR3Destroy(pUVM);
916 if (!RT_SUCCESS(rc))
917 {
918 RTPrintf("tstAnimate: error: failed to destroy vm! rc=%Rrc\n", rc);
919 rcRet++;
920 }
921
922 VMR3ReleaseUVM(pUVM);
923 }
924 else
925 {
926 RTPrintf("tstAnimate: fatal error: failed to create vm! rc=%Rrc\n", rc);
927 rcRet++;
928 }
929
930 return rcRet;
931}
932
933
934#if !defined(VBOX_WITH_HARDENING) || !defined(RT_OS_WINDOWS)
935/**
936 * Main entry point.
937 */
938int main(int argc, char **argv, char **envp)
939{
940 return TrustedMain(argc, argv, envp);
941}
942#endif
943
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use