tstAnimate.cpp@ 92613

Last change on this file since 92613 was 92613, checked in by vboxsync, 3 years ago
SUP,IPRT,++: Adding SUPSECMAIN_FLAGS_DRIVERLESS_IEM_ALLOWED and SUPR3INIT_F_DRIVERLESS_NEM_FALLBACK to SUPLib and RTR3INIT_FLAGS_TRY_SUPLIB to RTR3Init*, the latter probably reflects the actual state there a lot better. Currently only the TRY_SUPLIB option works, the other two aren't really implemented in SUPLib yet. bugref:10138
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 32.2 KB

Line
1	/* $Id: tstAnimate.cpp 92613 2021-11-26 21:53:47Z 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	*********************************************************************************************************************************/
51	static volatile bool g_fSignaled = false;
52
53
54	static void SigInterrupt(int iSignal) RT_NOTHROW_DEF
55	{
56	NOREF(iSignal);
57	signal(SIGINT, SigInterrupt);
58	g_fSignaled = true;
59	RTPrintf("caught SIGINT\n");
60	}
61
62	typedef DECLCALLBACKTYPE(int, FNSETGUESTGPR,(PVM, uint32_t));
63	typedef FNSETGUESTGPR *PFNSETGUESTGPR;
64	static 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
74	typedef DECLCALLBACKTYPE(int, FNSETGUESTSEL,(PVM, uint16_t));
75	typedef FNSETGUESTSEL *PFNSETGUESTSEL;
76	static 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
86	typedef DECLCALLBACKTYPE(int, FNSETGUESTSYS,(PVM, uint32_t));
87	typedef FNSETGUESTSYS *PFNSETGUESTSYS;
88	static 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
99	typedef DECLCALLBACKTYPE(int, FNSETGUESTDTR,(PVM, uint32_t, uint16_t));
100	typedef FNSETGUESTDTR *PFNSETGUESTDTR;
101	static 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. */
128	static 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
162	static 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
192	static 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
276	static 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	*/
327	static 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
601	static 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	*/
618	extern "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_TRY_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	*/
938	int 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.

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

Download in other formats: