tstVMStructSize.cpp@ 37354

Last change on this file since 37354 was 37354, checked in by vboxsync, 14 years ago
PGM: Fixed locking issues in PGMR3PhysMMIORegister and PGMR3PhysMMIODeregister. Also addressed a harmless on in PGMR3PhysRomRegister (only used at init time, so no races). Fortified the code with assertions more lock assertion, replacing the incorrect PGMIsLocked() checks (we only care if the current thread is the lock owner). Cleaned up some ReturnStmt macros and adding more of them.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 20.4 KB

Line
1	/* $Id: tstVMStructSize.cpp 37354 2011-06-07 15:05:32Z 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 <VBox/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	CHECK_PADDING_VM(64, pgm);
205	CHECK_PADDING_VM(64, hwaccm);
206	CHECK_PADDING_VM(64, trpm);
207	CHECK_PADDING_VM(64, selm);
208	CHECK_PADDING_VM(64, mm);
209	CHECK_PADDING_VM(64, pdm);
210	CHECK_PADDING_VM(64, iom);
211	CHECK_PADDING_VM(64, patm);
212	CHECK_PADDING_VM(64, csam);
213	CHECK_PADDING_VM(64, em);
214	/CHECK_PADDING_VM(64, iem);/
215	CHECK_PADDING_VM(64, tm);
216	CHECK_PADDING_VM(64, dbgf);
217	CHECK_PADDING_VM(64, ssm);
218	CHECK_PADDING_VM(64, rem);
219	CHECK_PADDING_VM(8, vm);
220	CHECK_PADDING_VM(8, cfgm);
221
222	PRINT_OFFSET(VMCPU, cpum);
223	CHECK_PADDING_VMCPU(64, cpum);
224	CHECK_PADDING_VMCPU(64, hwaccm);
225	CHECK_PADDING_VMCPU(64, em);
226	CHECK_PADDING_VMCPU(64, iem);
227	CHECK_PADDING_VMCPU(64, trpm);
228	CHECK_PADDING_VMCPU(64, tm);
229	CHECK_PADDING_VMCPU(64, vmm);
230	CHECK_PADDING_VMCPU(64, pdm);
231	CHECK_PADDING_VMCPU(64, iom);
232	CHECK_PADDING_VMCPU(64, dbgf);
233	#if 0
234	PRINT_OFFSET(VMCPU, abAlignment2);
235	#endif
236	PRINT_OFFSET(VMCPU, pgm);
237	CHECK_PADDING_VMCPU(4096, pgm);
238	#ifdef VBOX_WITH_STATISTICS
239	PRINT_OFFSET(VMCPU, pgm.s.pStatTrap0eAttributionRC);
240	#endif
241
242	CHECK_MEMBER_ALIGNMENT(VM, selm.s.Tss, 16);
243	PRINT_OFFSET(VM, selm.s.Tss);
244	PVM pVM = NULL; NOREF(pVM);
245	if ((RT_OFFSETOF(VM, selm.s.Tss) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.Tss))
246	{
247	printf("error! SELM:Tss is crossing a page!\n");
248	rc++;
249	}
250	PRINT_OFFSET(VM, selm.s.TssTrap08);
251	if ((RT_OFFSETOF(VM, selm.s.TssTrap08) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.TssTrap08))
252	{
253	printf("error! SELM:TssTrap08 is crossing a page!\n");
254	rc++;
255	}
256	CHECK_MEMBER_ALIGNMENT(VM, trpm.s.aIdt, 16);
257	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0], PAGE_SIZE);
258	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1], PAGE_SIZE);
259	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Host, 64);
260	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Guest, 64);
261	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Host, 64);
262	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Guest, 64);
263	CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Hyper, 64);
264	CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Hyper, 64);
265	#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
266	CHECK_MEMBER_ALIGNMENT(VM, cpum.s.pvApicBase, 8);
267	#endif
268	CHECK_MEMBER_ALIGNMENT(VM, cpum.s.GuestEntry, 64);
269
270	CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.u64CallRing3Arg, 8);
271	#if defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)
272	CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0, 16);
273	CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0.xmm6, 16);
274	#endif
275	CHECK_MEMBER_ALIGNMENT(VM, vmm.s.u64LastYield, 8);
276	CHECK_MEMBER_ALIGNMENT(VM, vmm.s.StatRunRC, 8);
277	CHECK_MEMBER_ALIGNMENT(VM, StatTotalQemuToGC, 8);
278	CHECK_MEMBER_ALIGNMENT(VM, rem.s.uPendingExcptCR2, 8);
279	CHECK_MEMBER_ALIGNMENT(VM, rem.s.StatsInQEMU, 8);
280	CHECK_MEMBER_ALIGNMENT(VM, rem.s.Env, 64);
281
282	/* the VMCPUs are page aligned TLB hit reasons. */
283	CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096);
284	CHECK_SIZE_ALIGNMENT(VMCPU, 4096);
285
286	/* cpumctx */
287	CHECK_MEMBER_ALIGNMENT(CPUMCTX, fpu, 32);
288	CHECK_MEMBER_ALIGNMENT(CPUMCTX, edi, 32);
289	CHECK_MEMBER_ALIGNMENT(CPUMCTX, idtr, 4);
290	CHECK_MEMBER_ALIGNMENT(CPUMCTX, SysEnter, 8);
291	CHECK_CPUMCTXCORE(eax);
292	CHECK_CPUMCTXCORE(ebx);
293	CHECK_CPUMCTXCORE(ecx);
294	CHECK_CPUMCTXCORE(edx);
295	CHECK_CPUMCTXCORE(ebp);
296	CHECK_CPUMCTXCORE(esp);
297	CHECK_CPUMCTXCORE(edi);
298	CHECK_CPUMCTXCORE(esi);
299	CHECK_CPUMCTXCORE(eip);
300	CHECK_CPUMCTXCORE(eflags);
301	CHECK_CPUMCTXCORE(cs);
302	CHECK_CPUMCTXCORE(ds);
303	CHECK_CPUMCTXCORE(es);
304	CHECK_CPUMCTXCORE(fs);
305	CHECK_CPUMCTXCORE(gs);
306	CHECK_CPUMCTXCORE(ss);
307	CHECK_CPUMCTXCORE(r8);
308	CHECK_CPUMCTXCORE(r9);
309	CHECK_CPUMCTXCORE(r10);
310	CHECK_CPUMCTXCORE(r11);
311	CHECK_CPUMCTXCORE(r12);
312	CHECK_CPUMCTXCORE(r13);
313	CHECK_CPUMCTXCORE(r14);
314	CHECK_CPUMCTXCORE(r15);
315	CHECK_CPUMCTXCORE(esHid);
316	CHECK_CPUMCTXCORE(csHid);
317	CHECK_CPUMCTXCORE(ssHid);
318	CHECK_CPUMCTXCORE(dsHid);
319	CHECK_CPUMCTXCORE(fsHid);
320	CHECK_CPUMCTXCORE(gsHid);
321
322	#if HC_ARCH_BITS == 32
323	/* CPUMHOSTCTX - lss pair */
324	if (RT_OFFSETOF(CPUMHOSTCTX, esp) + 4 != RT_OFFSETOF(CPUMHOSTCTX, ss))
325	{
326	printf("error! CPUMHOSTCTX lss has been split up!\n");
327	rc++;
328	}
329	#endif
330	CHECK_SIZE_ALIGNMENT(CPUMCTX, 64);
331	CHECK_SIZE_ALIGNMENT(CPUMHOSTCTX, 64);
332	CHECK_SIZE_ALIGNMENT(CPUMCTXMSR, 64);
333
334	/* pdm */
335	CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64);
336	CHECK_PADDING(PDMDEVINS, Internal, 1);
337	CHECK_MEMBER_ALIGNMENT(PDMUSBINS, achInstanceData, 16);
338	CHECK_PADDING(PDMUSBINS, Internal, 1);
339	CHECK_MEMBER_ALIGNMENT(PDMDRVINS, achInstanceData, 16);
340	CHECK_PADDING(PDMDRVINS, Internal, 1);
341	CHECK_PADDING2(PDMCRITSECT);
342
343	/* pgm */
344	#if defined(VBOX_WITH_2X_4GB_ADDR_SPACE) \|\| defined(VBOX_WITH_RAW_MODE)
345	CHECK_MEMBER_ALIGNMENT(PGMCPU, AutoSet, 8);
346	#endif
347	CHECK_MEMBER_ALIGNMENT(PGMCPU, GCPhysCR3, sizeof(RTGCPHYS));
348	CHECK_MEMBER_ALIGNMENT(PGMCPU, aGCPhysGstPaePDs, sizeof(RTGCPHYS));
349	CHECK_MEMBER_ALIGNMENT(PGMCPU, DisState, 8);
350	CHECK_MEMBER_ALIGNMENT(PGMCPU, cPoolAccessHandler, 8);
351	CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, idx, sizeof(uint16_t));
352	CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, pvPageR3, sizeof(RTHCPTR));
353	CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, GCPhys, sizeof(RTGCPHYS));
354	CHECK_SIZE(PGMPAGE, 16);
355	CHECK_MEMBER_ALIGNMENT(PGMRAMRANGE, aPages, 16);
356	CHECK_MEMBER_ALIGNMENT(PGMMMIO2RANGE, RamRange, 16);
357
358	/* rem */
359	CHECK_MEMBER_ALIGNMENT(REM, aGCPtrInvalidatedPages, 8);
360	CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalRegister, u.padding);
361	CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalDeregister, u.padding);
362	CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalModify, u.padding);
363	CHECK_SIZE_ALIGNMENT(REMHANDLERNOTIFICATION, 8);
364	CHECK_MEMBER_ALIGNMENT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.GCPhys, 8);
365
366	/* TM */
367	CHECK_MEMBER_ALIGNMENT(TM, TimerCritSect, sizeof(uintptr_t));
368	CHECK_MEMBER_ALIGNMENT(TM, VirtualSyncLock, sizeof(uintptr_t));
369
370	/* misc */
371	CHECK_PADDING3(EMCPU, u.FatalLongJump, u.achPaddingFatalLongJump);
372	CHECK_SIZE_ALIGNMENT(VMMR0JMPBUF, 8);
373	CHECK_SIZE_ALIGNMENT(PATCHINFO, 8);
374	#if 0
375	PRINT_OFFSET(VM, fForcedActions);
376	PRINT_OFFSET(VM, StatQemuToGC);
377	PRINT_OFFSET(VM, StatGCToQemu);
378	#endif
379
380	CHECK_MEMBER_ALIGNMENT(IOM, EmtLock, sizeof(uintptr_t));
381	CHECK_MEMBER_ALIGNMENT(EM, CritSectREM, sizeof(uintptr_t));
382	CHECK_MEMBER_ALIGNMENT(PGM, CritSect, sizeof(uintptr_t));
383	CHECK_MEMBER_ALIGNMENT(PDM, CritSect, sizeof(uintptr_t));
384	CHECK_MEMBER_ALIGNMENT(MMHYPERHEAP, Lock, sizeof(uintptr_t));
385
386	/* hwaccm - 32-bit gcc won't align uint64_t naturally, so check. */
387	CHECK_MEMBER_ALIGNMENT(HWACCM, u64RegisterMask, 8);
388	CHECK_MEMBER_ALIGNMENT(HWACCM, vmx.hostCR4, 8);
389	CHECK_MEMBER_ALIGNMENT(HWACCM, vmx.msr.feature_ctrl, 8);
390	CHECK_MEMBER_ALIGNMENT(HWACCM, StatTPRPatchSuccess, 8);
391	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, StatEntry, 8);
392	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, vmx.HCPhysVMCS, sizeof(RTHCPHYS));
393	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, vmx.proc_ctls, 8);
394	CHECK_MEMBER_ALIGNMENT(HWACCMCPU, Event.intInfo, 8);
395
396	/* The various disassembler state members. */
397	CHECK_PADDING3(EMCPU, DisState, abDisStatePadding);
398	CHECK_PADDING3(HWACCMCPU, DisState, abDisStatePadding);
399	CHECK_PADDING3(IOMCPU, DisState, abDisStatePadding);
400	CHECK_PADDING3(PGMCPU, DisState, abDisStatePadding);
401
402	/* Make sure the set is large enough and has the correct size. */
403	CHECK_SIZE(VMCPUSET, 32);
404	if (sizeof(VMCPUSET) * 8 < VMM_MAX_CPU_COUNT)
405	{
406	printf("error! VMCPUSET is too small for VMM_MAX_CPU_COUNT=%u!\n", VMM_MAX_CPU_COUNT);
407	rc++;
408	}
409
410	printf("info: struct UVM: %d bytes\n", (int)sizeof(UVM));
411
412	CHECK_PADDING_UVM(32, vm);
413	CHECK_PADDING_UVM(32, mm);
414	CHECK_PADDING_UVM(32, pdm);
415	CHECK_PADDING_UVM(32, stam);
416
417	printf("info: struct UVMCPU: %d bytes\n", (int)sizeof(UVMCPU));
418	CHECK_PADDING_UVMCPU(32, vm);
419
420	#ifdef VBOX_WITH_RAW_MODE
421	/*
422	* Compare HC and RC.
423	*/
424	printf("tstVMStructSize: Comparing HC and RC...\n");
425	# include "tstVMStructRC.h"
426	#endif /* VBOX_WITH_RAW_MODE */
427
428	CHECK_PADDING_GVM(4, gvmm);
429	CHECK_PADDING_GVM(4, gmm);
430	CHECK_PADDING_GVMCPU(4, gvmm);
431
432	/*
433	* Check that the optimized access macros for PGMPAGE works correctly.
434	*/
435	PGMPAGE Page;
436	PGM_PAGE_CLEAR(&Page);
437
438	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_NONE);
439	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == false);
440	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == false);
441	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
442
443	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_ALL);
444	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_ALL);
445	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
446	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
447	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
448
449	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE);
450	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
451	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
452	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
453	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
454
455	PGM_PAGE_CLEAR(&Page);
456	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_ALL);
457	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_ALL);
458	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
459	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
460	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
461
462	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE);
463	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE);
464	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
465	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
466	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
467
468
469	PGM_PAGE_CLEAR(&Page);
470	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_ALL);
471	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE);
472	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_ALL);
473	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE);
474	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
475	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
476	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
477
478	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE);
479	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_ALL);
480	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
481	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_ALL);
482	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
483	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
484	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true);
485
486	PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE);
487	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE);
488	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
489	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE);
490	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
491	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
492	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
493
494	PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_NONE);
495	CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE);
496	CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_NONE);
497	CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true);
498	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true);
499	CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false);
500
501	#undef AssertFatal
502	#define AssertFatal(expr) do { } while (0)
503	#undef Assert
504	#define Assert(expr) do { } while (0)
505
506	PGM_PAGE_CLEAR(&Page);
507	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == 0);
508	PGM_PAGE_SET_HCPHYS(NULL, &Page, UINT64_C(0x0000fffeff1ff000));
509	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000fffeff1ff000));
510	PGM_PAGE_SET_HCPHYS(NULL, &Page, UINT64_C(0x0000000000001000));
511	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000000000001000));
512
513	PGM_PAGE_INIT(&Page, UINT64_C(0x0000feedfacef000), UINT32_C(0x12345678), PGMPAGETYPE_RAM, PGM_PAGE_STATE_ALLOCATED);
514	CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000feedfacef000));
515	CHECK_EXPR(PGM_PAGE_GET_PAGEID(&Page) == UINT32_C(0x12345678));
516	CHECK_EXPR(PGM_PAGE_GET_TYPE_NA(&Page) == PGMPAGETYPE_RAM);
517	CHECK_EXPR(PGM_PAGE_GET_STATE_NA(&Page) == PGM_PAGE_STATE_ALLOCATED);
518
519
520	/*
521	* Report result.
522	*/
523	if (rc)
524	printf("tstVMStructSize: FAILURE - %d errors\n", rc);
525	else
526	printf("tstVMStructSize: SUCCESS\n");
527	return rc;
528	}
529

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

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

Download in other formats: