VirtualBox

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

Last change on this file since 40243 was 40170, checked in by vboxsync, 13 years ago

MSRs and MTRRs, CPUM saved state changed. (linux 2.4.31 seems to ignore the capabilites when it comes to fixed MTRRs.)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 20.5 KB
Line 
1/* $Id: tstVMStructSize.cpp 40170 2012-02-17 14:22:26Z 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
66int 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(CPUMCTXMSRS, 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.

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