tstVMStructSize.cpp@ 39398

Last change on this file since 39398 was 38953, checked in by vboxsync, 13 years ago
PGM: Attempt at fixing the VERR_MAP_FAILED during state save problem on 32-bit hosts when assigning lots of memory to the guest. PGM should lock down guest RAM pages before use and release them afterwards like everyone else. Still quite some stuff left to do there, so I've deviced a little hack for tracking unlocked mappings and using this as input when deciding to do async or sync chunk unmapping at save/load time. See xtracker #5912 and public ticket 7929.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 20.5 KB

Line
1	/* $Id: tstVMStructSize.cpp 38953 2011-10-06 08:49:36Z vboxsync $ */
2	/** @file
3	* tstVMStructSize - testcase for check structure sizes/alignment
4	* and to verify that HC and GC uses the same
5	* representation of the structures.
6	*/
7
8	/*
9	* Copyright (C) 2006-2007 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*/
19
20	/*******************************************************************************
21	* Header Files *
22	*******************************************************************************/
23	#include <VBox/vmm/cfgm.h>
24	#include <VBox/vmm/cpum.h>
25	#include <VBox/vmm/mm.h>
26	#include <VBox/vmm/pgm.h>
27	#include <VBox/vmm/selm.h>
28	#include <VBox/vmm/trpm.h>
29	#include <VBox/vmm/vmm.h>
30	#include <VBox/vmm/stam.h>
31	#include "PDMInternal.h"
32	#include <VBox/vmm/pdm.h>
33	#include "CFGMInternal.h"
34	#include "CPUMInternal.h"
35	#include "MMInternal.h"
36	#include "PGMInternal.h"
37	#include "SELMInternal.h"
38	#include "TRPMInternal.h"
39	#include "TMInternal.h"
40	#include "IOMInternal.h"
41	#include "REMInternal.h"
42	#include "SSMInternal.h"
43	#include "HWACCMInternal.h"
44	#include "PATMInternal.h"
45	#include "VMMInternal.h"
46	#include "DBGFInternal.h"
47	#include "STAMInternal.h"
48	#include "VMInternal.h"
49	#include "CSAMInternal.h"
50	#include "EMInternal.h"
51	#include "IEMInternal.h"
52	#include "REMInternal.h"
53	#include "../VMMR0/GMMR0Internal.h"
54	#include "../VMMR0/GVMMR0Internal.h"
55	#include <VBox/vmm/vm.h>
56	#include <VBox/vmm/uvm.h>
57	#include <VBox/vmm/gvm.h>
58	#include <VBox/param.h>
59	#include <iprt/x86.h>
60
61	#include "tstHelp.h"
62	#include <stdio.h>
63
64
65
66	int main()
67	{
68	int rc = 0;
69	printf("tstVMStructSize: TESTING\n");
70
71	printf("info: struct VM: %d bytes\n", (int)sizeof(VM));
72
73	#define CHECK_PADDING_VM(align, member) \
74	do \
75	{ \
76	CHECK_PADDING(VM, member, align); \
77	CHECK_MEMBER_ALIGNMENT(VM, member, align); \
78	VM *p = NULL; NOREF(p); \
79	if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
80	printf("warning: VM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
81	#member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
82	(int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
83	(int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
84	} while (0)
85
86
87	#define CHECK_PADDING_VMCPU(align, member) \
88	do \
89	{ \
90	CHECK_PADDING(VMCPU, member, align); \
91	CHECK_MEMBER_ALIGNMENT(VMCPU, member, align); \
92	VMCPU *p = NULL; NOREF(p); \
93	if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
94	printf("warning: VMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
95	#member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
96	(int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
97	(int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
98	} while (0)
99
100	#define CHECK_CPUMCTXCORE(member) \
101	do { \
102	if (RT_OFFSETOF(CPUMCTX, member) - RT_OFFSETOF(CPUMCTX, edi) != RT_OFFSETOF(CPUMCTXCORE, member)) \
103	{ \
104	printf("error! CPUMCTX/CORE:: %s!\n", #member); \
105	rc++; \
106	} \
107	} while (0)
108
109	#define CHECK_PADDING_UVM(align, member) \
110	do \
111	{ \
112	CHECK_PADDING(UVM, member, align); \
113	CHECK_MEMBER_ALIGNMENT(UVM, member, align); \
114	UVM *p = NULL; NOREF(p); \
115	if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
116	printf("warning: UVM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
117	#member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
118	(int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
119	(int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
120	} while (0)
121
122	#define CHECK_PADDING_UVMCPU(align, member) \
123	do \
124	{ \
125	CHECK_PADDING(UVMCPU, member, align); \
126	CHECK_MEMBER_ALIGNMENT(UVMCPU, member, align); \
127	UVMCPU *p = NULL; NOREF(p); \
128	if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
129	printf("warning: UVMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
130	#member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
131	(int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
132	(int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
133	} while (0)
134
135	#define CHECK_PADDING_GVM(align, member) \
136	do \
137	{ \
138	CHECK_PADDING(GVM, member, align); \
139	CHECK_MEMBER_ALIGNMENT(GVM, member, align); \
140	GVM *p = NULL; NOREF(p); \
141	if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
142	printf("warning: GVM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
143	#member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
144	(int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
145	(int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
146	} while (0)
147
148	#define CHECK_PADDING_GVMCPU(align, member) \
149	do \
150	{ \
151	CHECK_PADDING(GVMCPU, member, align); \
152	CHECK_MEMBER_ALIGNMENT(GVMCPU, member, align); \
153	GVMCPU *p = NULL; NOREF(p); \
154	if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
155	printf("warning: GVMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
156	#member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
157	(int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
158	(int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
159	} while (0)
160
161	#define PRINT_OFFSET(strct, member) \
162	do \
163	{ \
164	printf("info: %s::%s offset %#x (%d) sizeof %d\n", #strct, #member, (int)RT_OFFSETOF(strct, member), (int)RT_OFFSETOF(strct, member), (int)RT_SIZEOFMEMB(strct, member)); \
165	} while (0)
166
167
168
169	CHECK_SIZE(uint128_t, 128/8);
170	CHECK_SIZE(int128_t, 128/8);
171	CHECK_SIZE(uint64_t, 64/8);
172	CHECK_SIZE(int64_t, 64/8);
173	CHECK_SIZE(uint32_t, 32/8);
174	CHECK_SIZE(int32_t, 32/8);
175	CHECK_SIZE(uint16_t, 16/8);
176	CHECK_SIZE(int16_t, 16/8);
177	CHECK_SIZE(uint8_t, 8/8);
178	CHECK_SIZE(int8_t, 8/8);
179
180	CHECK_SIZE(X86DESC, 8);
181	CHECK_SIZE(X86DESC64, 16);
182	CHECK_SIZE(VBOXIDTE, 8);
183	CHECK_SIZE(VBOXIDTR, 10);
184	CHECK_SIZE(VBOXGDTR, 10);
185	CHECK_SIZE(VBOXTSS, 136);
186	CHECK_SIZE(X86FXSTATE, 512);
187	CHECK_SIZE(RTUUID, 16);
188	CHECK_SIZE(X86PTE, 4);
189	CHECK_SIZE(X86PD, PAGE_SIZE);
190	CHECK_SIZE(X86PDE, 4);
191	CHECK_SIZE(X86PT, PAGE_SIZE);
192	CHECK_SIZE(X86PTEPAE, 8);
193	CHECK_SIZE(X86PTPAE, PAGE_SIZE);
194	CHECK_SIZE(X86PDEPAE, 8);
195	CHECK_SIZE(X86PDPAE, PAGE_SIZE);
196	CHECK_SIZE(X86PDPE, 8);
197	CHECK_SIZE(X86PDPT, PAGE_SIZE);
198	CHECK_SIZE(X86PML4E, 8);
199	CHECK_SIZE(X86PML4, PAGE_SIZE);
200
201	PRINT_OFFSET(VM, cpum);
202	CHECK_PADDING_VM(64, cpum);
203	CHECK_PADDING_VM(64, vmm);
204	PRINT_OFFSET(VM, pgm);
205	PRINT_OFFSET(VM, pgm.s.CritSectX);
206	CHECK_PADDING_VM(64, pgm);
207	PRINT_OFFSET(VM, hwaccm);
208	CHECK_PADDING_VM(64, hwaccm);
209	CHECK_PADDING_VM(64, trpm);
210	CHECK_PADDING_VM(64, selm);
211	CHECK_PADDING_VM(64, mm);
212	CHECK_PADDING_VM(64, pdm);
213	CHECK_PADDING_VM(64, iom);
214	CHECK_PADDING_VM(64, patm);
215	CHECK_PADDING_VM(64, csam);
216	CHECK_PADDING_VM(64, em);
217	/CHECK_PADDING_VM(64, iem);/
218	CHECK_PADDING_VM(64, tm);
219	CHECK_PADDING_VM(64, dbgf);
220	CHECK_PADDING_VM(64, ssm);
221	CHECK_PADDING_VM(64, rem);
222	CHECK_PADDING_VM(8, vm);
223	CHECK_PADDING_VM(8, cfgm);
224
225	PRINT_OFFSET(VMCPU, cpum);
226	CHECK_PADDING_VMCPU(64, cpum);
227	CHECK_PADDING_VMCPU(64, hwaccm);
228	CHECK_PADDING_VMCPU(64, em);
229	CHECK_PADDING_VMCPU(64, iem);
230	CHECK_PADDING_VMCPU(64, trpm);
231	CHECK_PADDING_VMCPU(64, tm);
232	CHECK_PADDING_VMCPU(64, vmm);
233	CHECK_PADDING_VMCPU(64, pdm);
234	CHECK_PADDING_VMCPU(64, iom);
235	CHECK_PADDING_VMCPU(64, dbgf);
236	#if 0
237	PRINT_OFFSET(VMCPU, abAlignment2);
238	#endif
239	PRINT_OFFSET(VMCPU, pgm);
240	CHECK_PADDING_VMCPU(4096, pgm);
241	#ifdef VBOX_WITH_STATISTICS
242	PRINT_OFFSET(VMCPU, pgm.s.pStatTrap0eAttributionRC);
243	#endif
244
245	CHECK_MEMBER_ALIGNMENT(VM, selm.s.Tss, 16);
246	PRINT_OFFSET(VM, selm.s.Tss);
247	PVM pVM = NULL; NOREF(pVM);
248	if ((RT_OFFSETOF(VM, selm.s.Tss) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.Tss))
249	{
250	printf("error! SELM:Tss is crossing a page!\n");
251	rc++;
252	}
253	PRINT_OFFSET(VM, selm.s.TssTrap08);
254	if ((RT_OFFSETOF(VM, selm.s.TssTrap08) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.TssTrap08))
255	{
256	printf("error! SELM:TssTrap08 is crossing a page!\n");
257	rc++;
258	}
259	CHECK_MEMBER_ALIGNMENT(VM, trpm.s.aIdt, 16);
260	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0], PAGE_SIZE);
261	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1], PAGE_SIZE);
262	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Host, 64);
263	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Guest, 64);
264	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Host, 64);
265	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Guest, 64);
266	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Hyper, 64);
267	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Hyper, 64);
268	#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
269	CHECK_MEMBER_ALIGNMENT(VM, cpum.s.pvApicBase, 8);
270	#endif
271	CHECK_MEMBER_ALIGNMENT(VM, cpum.s.GuestEntry, 64);
272
273	CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.u64CallRing3Arg, 8);
274	#if defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)
275	CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0, 16);
276	CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0.xmm6, 16);
277	#endif
278	CHECK_MEMBER_ALIGNMENT(VM, vmm.s.u64LastYield, 8);
279	CHECK_MEMBER_ALIGNMENT(VM, vmm.s.StatRunRC, 8);
280	CHECK_MEMBER_ALIGNMENT(VM, StatTotalQemuToGC, 8);
281	CHECK_MEMBER_ALIGNMENT(VM, rem.s.uPendingExcptCR2, 8);
282	CHECK_MEMBER_ALIGNMENT(VM, rem.s.StatsInQEMU, 8);
283	CHECK_MEMBER_ALIGNMENT(VM, rem.s.Env, 64);
284
285	/* the VMCPUs are page aligned TLB hit reasons. */
286	CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096);
287	CHECK_SIZE_ALIGNMENT(VMCPU, 4096);
288
289	/* cpumctx */
290	CHECK_MEMBER_ALIGNMENT(CPUMCTX, fpu, 32);
291	CHECK_MEMBER_ALIGNMENT(CPUMCTX, edi, 32);
292	CHECK_MEMBER_ALIGNMENT(CPUMCTX, idtr, 4);
293	CHECK_MEMBER_ALIGNMENT(CPUMCTX, SysEnter, 8);
294	CHECK_CPUMCTXCORE(eax);
295	CHECK_CPUMCTXCORE(ebx);
296	CHECK_CPUMCTXCORE(ecx);
297	CHECK_CPUMCTXCORE(edx);
298	CHECK_CPUMCTXCORE(ebp);
299	CHECK_CPUMCTXCORE(esp);
300	CHECK_CPUMCTXCORE(edi);
301	CHECK_CPUMCTXCORE(esi);
302	CHECK_CPUMCTXCORE(eip);
303	CHECK_CPUMCTXCORE(eflags);
304	CHECK_CPUMCTXCORE(cs);
305	CHECK_CPUMCTXCORE(ds);
306	CHECK_CPUMCTXCORE(es);
307	CHECK_CPUMCTXCORE(fs);
308	CHECK_CPUMCTXCORE(gs);
309	CHECK_CPUMCTXCORE(ss);
310	CHECK_CPUMCTXCORE(r8);
311	CHECK_CPUMCTXCORE(r9);
312	CHECK_CPUMCTXCORE(r10);
313	CHECK_CPUMCTXCORE(r11);
314	CHECK_CPUMCTXCORE(r12);
315	CHECK_CPUMCTXCORE(r13);
316	CHECK_CPUMCTXCORE(r14);
317	CHECK_CPUMCTXCORE(r15);
318	CHECK_CPUMCTXCORE(esHid);
319	CHECK_CPUMCTXCORE(csHid);
320	CHECK_CPUMCTXCORE(ssHid);
321	CHECK_CPUMCTXCORE(dsHid);
322	CHECK_CPUMCTXCORE(fsHid);
323	CHECK_CPUMCTXCORE(gsHid);
324
325	#if HC_ARCH_BITS == 32
326	/* CPUMHOSTCTX - lss pair */
327	if (RT_OFFSETOF(CPUMHOSTCTX, esp) + 4 != RT_OFFSETOF(CPUMHOSTCTX, ss))
328	{
329	printf("error! CPUMHOSTCTX lss has been split up!\n");
330	rc++;
331	}
332	#endif
333	CHECK_SIZE_ALIGNMENT(CPUMCTX, 64);
334	CHECK_SIZE_ALIGNMENT(CPUMHOSTCTX, 64);
335	CHECK_SIZE_ALIGNMENT(CPUMCTXMSR, 64);
336
337	/* pdm */
338	CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64);
339	CHECK_PADDING(PDMDEVINS, Internal, 1);
340	CHECK_MEMBER_ALIGNMENT(PDMUSBINS, achInstanceData, 16);
341	CHECK_PADDING(PDMUSBINS, Internal, 1);
342	CHECK_MEMBER_ALIGNMENT(PDMDRVINS, achInstanceData, 16);
343	CHECK_PADDING(PDMDRVINS, Internal, 1);
344	CHECK_PADDING2(PDMCRITSECT);
345
346	/* pgm */
347	#if defined(VBOX_WITH_2X_4GB_ADDR_SPACE) \|\| defined(VBOX_WITH_RAW_MODE)
348	CHECK_MEMBER_ALIGNMENT(PGMCPU, AutoSet, 8);
349	#endif
350	CHECK_MEMBER_ALIGNMENT(PGMCPU, GCPhysCR3, sizeof(RTGCPHYS));
351	CHECK_MEMBER_ALIGNMENT(PGMCPU, aGCPhysGstPaePDs, sizeof(RTGCPHYS));
352	CHECK_MEMBER_ALIGNMENT(PGMCPU, DisState, 8);
353	CHECK_MEMBER_ALIGNMENT(PGMCPU, cPoolAccessHandler, 8);
354	CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, idx, sizeof(uint16_t));
355	CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, pvPageR3, sizeof(RTHCPTR));
356	CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, GCPhys, sizeof(RTGCPHYS));
357	CHECK_SIZE(PGMPAGE, 16);
358	CHECK_MEMBER_ALIGNMENT(PGMRAMRANGE, aPages, 16);
359	CHECK_MEMBER_ALIGNMENT(PGMMMIO2RANGE, RamRange, 16);
360
361	/* rem */
362	CHECK_MEMBER_ALIGNMENT(REM, aGCPtrInvalidatedPages, 8);
363	CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalRegister, u.padding);
364	CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalDeregister, u.padding);
365	CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalModify, u.padding);
366	CHECK_SIZE_ALIGNMENT(REMHANDLERNOTIFICATION, 8);
367	CHECK_MEMBER_ALIGNMENT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.GCPhys, 8);
368
369	/* TM */
370	CHECK_MEMBER_ALIGNMENT(TM, TimerCritSect, sizeof(uintptr_t));
371	CHECK_MEMBER_ALIGNMENT(TM, VirtualSyncLock, sizeof(uintptr_t));
372
373	/* misc */
374	CHECK_PADDING3(EMCPU, u.FatalLongJump, u.achPaddingFatalLongJump);
375	CHECK_SIZE_ALIGNMENT(VMMR0JMPBUF, 8);
376	CHECK_SIZE_ALIGNMENT(PATCHINFO, 8);
377	#if 0
378	PRINT_OFFSET(VM, fForcedActions);
379	PRINT_OFFSET(VM, StatQemuToGC);
380	PRINT_OFFSET(VM, StatGCToQemu);
381	#endif
382
383	CHECK_MEMBER_ALIGNMENT(IOM, CritSect, sizeof(uintptr_t));
384	CHECK_MEMBER_ALIGNMENT(EM, CritSectREM, sizeof(uintptr_t));
385	CHECK_MEMBER_ALIGNMENT(PGM, CritSectX, sizeof(uintptr_t));
386	CHECK_MEMBER_ALIGNMENT(PDM, CritSect, sizeof(uintptr_t));
387	CHECK_MEMBER_ALIGNMENT(MMHYPERHEAP, Lock, sizeof(uintptr_t));
388
389	/* hwaccm - 32-bit gcc won't align uint64_t naturally, so check. */
390	CHECK_MEMBER_ALIGNMENT(HWACCM, u64RegisterMask, 8);
391	CHECK_MEMBER_ALIGNMENT(HWACCM, vmx.hostCR4, 8);
392	CHECK_MEMBER_ALIGNMENT(HWACCM, vmx.msr.feature_ctrl, 8);
393	CHECK_MEMBER_ALIGNMENT(HWACCM, StatTPRPatchSuccess, 8);
394	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, StatEntry, 8);
395	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, vmx.HCPhysVMCS, sizeof(RTHCPHYS));
396	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, vmx.proc_ctls, 8);
397	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, Event.intInfo, 8);
398
399	/* The various disassembler state members. */
400	CHECK_PADDING3(EMCPU, DisState, abDisStatePadding);
401	CHECK_PADDING3(HWACCMCPU, DisState, abDisStatePadding);
402	CHECK_PADDING3(IOMCPU, DisState, abDisStatePadding);
403	CHECK_PADDING3(PGMCPU, DisState, abDisStatePadding);
404
405	/* Make sure the set is large enough and has the correct size. */
406	CHECK_SIZE(VMCPUSET, 32);
407	if (sizeof(VMCPUSET) * 8 < VMM_MAX_CPU_COUNT)
408	{
409	printf("error! VMCPUSET is too small for VMM_MAX_CPU_COUNT=%u!\n", VMM_MAX_CPU_COUNT);
410	rc++;
411	}
412
413	printf("info: struct UVM: %d bytes\n", (int)sizeof(UVM));
414
415	CHECK_PADDING_UVM(32, vm);
416	CHECK_PADDING_UVM(32, mm);
417	CHECK_PADDING_UVM(32, pdm);
418	CHECK_PADDING_UVM(32, stam);
419
420	printf("info: struct UVMCPU: %d bytes\n", (int)sizeof(UVMCPU));
421	CHECK_PADDING_UVMCPU(32, vm);
422
423	#ifdef VBOX_WITH_RAW_MODE
424	/*
425	* Compare HC and RC.
426	*/
427	printf("tstVMStructSize: Comparing HC and RC...\n");
428	# include "tstVMStructRC.h"
429	#endif /* VBOX_WITH_RAW_MODE */
430
431	CHECK_PADDING_GVM(4, gvmm);
432	CHECK_PADDING_GVM(4, gmm);
433	CHECK_PADDING_GVMCPU(4, gvmm);
434
435	/*
436	* Check that the optimized access macros for PGMPAGE works correctly.
437	*/
438	PGMPAGE Page;
439	PGM_PAGE_CLEAR(&Page);
440
441	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_NONE);
442	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == false);
443	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == false);
444	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
445
446	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_ALL);
447	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_ALL);
448	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
449	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
450	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
451
452	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE);
453	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
454	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
455	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
456	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
457
458	PGM_PAGE_CLEAR(&Page);
459	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_ALL);
460	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_ALL);
461	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
462	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
463	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
464
465	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE);
466	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE);
467	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
468	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
469	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
470
471
472	PGM_PAGE_CLEAR(&Page);
473	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_ALL);
474	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE);
475	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_ALL);
476	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE);
477	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
478	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
479	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
480
481	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE);
482	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_ALL);
483	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
484	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_ALL);
485	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
486	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
487	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
488
489	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE);
490	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE);
491	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
492	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE);
493	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
494	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
495	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
496
497	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_NONE);
498	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
499	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_NONE);
500	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
501	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
502	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
503
504	#undef AssertFatal
505	#define AssertFatal(expr) do { } while (0)
506	#undef Assert
507	#define Assert(expr) do { } while (0)
508
509	PGM_PAGE_CLEAR(&Page);
510	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == 0);
511	PGM_PAGE_SET_HCPHYS(NULL, &Page, UINT64_C(0x0000fffeff1ff000));
512	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000fffeff1ff000));
513	PGM_PAGE_SET_HCPHYS(NULL, &Page, UINT64_C(0x0000000000001000));
514	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000000000001000));
515
516	PGM_PAGE_INIT(&Page, UINT64_C(0x0000feedfacef000), UINT32_C(0x12345678), PGMPAGETYPE_RAM, PGM_PAGE_STATE_ALLOCATED);
517	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000feedfacef000));
518	CHECK_EXPR(PGM_PAGE_GET_PAGEID(&Page) == UINT32_C(0x12345678));
519	CHECK_EXPR(PGM_PAGE_GET_TYPE_NA(&Page) == PGMPAGETYPE_RAM);
520	CHECK_EXPR(PGM_PAGE_GET_STATE_NA(&Page) == PGM_PAGE_STATE_ALLOCATED);
521
522
523	/*
524	* Report result.
525	*/
526	if (rc)
527	printf("tstVMStructSize: FAILURE - %d errors\n", rc);
528	else
529	printf("tstVMStructSize: SUCCESS\n");
530	return rc;
531	}
532

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/testcase/tstVMStructSize.cpp@ 39398

Download in other formats: