VirtualBox

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

Last change on this file since 28800 was 28800, checked in by vboxsync, 15 years ago

Automated rebranding to Oracle copyright/license strings via filemuncher
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 14.1 KB
Line 
1/* $Id: tstVMStructSize.cpp 28800 2010-04-27 08:22: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/cfgm.h>
24#include <VBox/cpum.h>
25#include <VBox/mm.h>
26#include <VBox/pgm.h>
27#include <VBox/selm.h>
28#include <VBox/trpm.h>
29#include <VBox/vmm.h>
30#include <VBox/stam.h>
31#include "PDMInternal.h"
32#include <VBox/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#ifdef VBOX_WITH_VMI
46# include "PARAVInternal.h"
47#endif
48#include "VMMInternal.h"
49#include "DBGFInternal.h"
50#include "STAMInternal.h"
51#include "VMInternal.h"
52#include "CSAMInternal.h"
53#include "EMInternal.h"
54#include "REMInternal.h"
55#include <VBox/vm.h>
56#include <VBox/uvm.h>
57#include <VBox/param.h>
58#include <VBox/x86.h>
59
60#include "tstHelp.h"
61#include <stdio.h>
62
63
64
65int main()
66{
67 int rc = 0;
68 printf("tstVMStructSize: TESTING\n");
69
70 printf("info: struct VM: %d bytes\n", (int)sizeof(VM));
71
72#define CHECK_PADDING_VM(align, member) \
73 do \
74 { \
75 CHECK_PADDING(VM, member, align); \
76 CHECK_MEMBER_ALIGNMENT(VM, member, align); \
77 VM *p; \
78 if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
79 printf("warning: VM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
80 #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
81 (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
82 (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
83 } while (0)
84
85
86#define CHECK_PADDING_VMCPU(align, member) \
87 do \
88 { \
89 CHECK_PADDING(VMCPU, member, align); \
90 CHECK_MEMBER_ALIGNMENT(VMCPU, member, align); \
91 VMCPU *p; \
92 if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
93 printf("warning: VMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
94 #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
95 (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
96 (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
97 } while (0)
98
99#define CHECK_CPUMCTXCORE(member) \
100 do { \
101 if (RT_OFFSETOF(CPUMCTX, member) - RT_OFFSETOF(CPUMCTX, edi) != RT_OFFSETOF(CPUMCTXCORE, member)) \
102 { \
103 printf("error! CPUMCTX/CORE:: %s!\n", #member); \
104 rc++; \
105 } \
106 } while (0)
107
108#define CHECK_PADDING_UVM(align, member) \
109 do \
110 { \
111 CHECK_PADDING(UVM, member, align); \
112 CHECK_MEMBER_ALIGNMENT(UVM, member, align); \
113 UVM *p; \
114 if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
115 printf("warning: UVM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
116 #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
117 (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
118 (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
119 } while (0)
120
121#define CHECK_PADDING_UVMCPU(align, member) \
122 do \
123 { \
124 CHECK_PADDING(UVMCPU, member, align); \
125 CHECK_MEMBER_ALIGNMENT(UVMCPU, member, align); \
126 UVMCPU *p; \
127 if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \
128 printf("warning: UVMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \
129 #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \
130 (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \
131 (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
132 } while (0)
133
134#define PRINT_OFFSET(strct, member) \
135 do \
136 { \
137 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)); \
138 } while (0)
139
140
141
142 CHECK_SIZE(uint128_t, 128/8);
143 CHECK_SIZE(int128_t, 128/8);
144 CHECK_SIZE(uint64_t, 64/8);
145 CHECK_SIZE(int64_t, 64/8);
146 CHECK_SIZE(uint32_t, 32/8);
147 CHECK_SIZE(int32_t, 32/8);
148 CHECK_SIZE(uint16_t, 16/8);
149 CHECK_SIZE(int16_t, 16/8);
150 CHECK_SIZE(uint8_t, 8/8);
151 CHECK_SIZE(int8_t, 8/8);
152
153 CHECK_SIZE(X86DESC, 8);
154 CHECK_SIZE(X86DESC64, 16);
155 CHECK_SIZE(VBOXIDTE, 8);
156 CHECK_SIZE(VBOXIDTR, 10);
157 CHECK_SIZE(VBOXGDTR, 10);
158 CHECK_SIZE(VBOXTSS, 136);
159 CHECK_SIZE(X86FXSTATE, 512);
160 CHECK_SIZE(RTUUID, 16);
161 CHECK_SIZE(X86PTE, 4);
162 CHECK_SIZE(X86PD, PAGE_SIZE);
163 CHECK_SIZE(X86PDE, 4);
164 CHECK_SIZE(X86PT, PAGE_SIZE);
165 CHECK_SIZE(X86PTEPAE, 8);
166 CHECK_SIZE(X86PTPAE, PAGE_SIZE);
167 CHECK_SIZE(X86PDEPAE, 8);
168 CHECK_SIZE(X86PDPAE, PAGE_SIZE);
169 CHECK_SIZE(X86PDPE, 8);
170 CHECK_SIZE(X86PDPT, PAGE_SIZE);
171 CHECK_SIZE(X86PML4E, 8);
172 CHECK_SIZE(X86PML4, PAGE_SIZE);
173
174 PRINT_OFFSET(VM, cpum);
175 CHECK_PADDING_VM(64, cpum);
176 CHECK_PADDING_VM(64, vmm);
177 CHECK_PADDING_VM(64, pgm);
178 CHECK_PADDING_VM(64, hwaccm);
179 CHECK_PADDING_VM(64, trpm);
180 CHECK_PADDING_VM(64, selm);
181 CHECK_PADDING_VM(64, mm);
182 CHECK_PADDING_VM(64, pdm);
183 CHECK_PADDING_VM(64, iom);
184 CHECK_PADDING_VM(64, patm);
185 CHECK_PADDING_VM(64, csam);
186 CHECK_PADDING_VM(64, em);
187 CHECK_PADDING_VM(64, tm);
188 CHECK_PADDING_VM(64, dbgf);
189 CHECK_PADDING_VM(64, ssm);
190 CHECK_PADDING_VM(64, rem);
191 CHECK_PADDING_VM(8, vm);
192 CHECK_PADDING_VM(8, cfgm);
193#ifdef VBOX_WITH_VMI
194 CHECK_PADDING_VM(8, parav);
195#endif
196
197 PRINT_OFFSET(VMCPU, cpum);
198 CHECK_PADDING_VMCPU(64, cpum);
199 CHECK_PADDING_VMCPU(64, hwaccm);
200 CHECK_PADDING_VMCPU(64, em);
201 CHECK_PADDING_VMCPU(64, trpm);
202 CHECK_PADDING_VMCPU(64, tm);
203 CHECK_PADDING_VMCPU(64, vmm);
204 CHECK_PADDING_VMCPU(64, pdm);
205 CHECK_PADDING_VMCPU(64, iom);
206 CHECK_PADDING_VMCPU(64, dbgf);
207 CHECK_PADDING_VMCPU(4096, pgm);
208#ifdef VBOX_WITH_STATISTICS
209 PRINT_OFFSET(VMCPU, pgm.s.pStatTrap0eAttributionRC);
210#endif
211
212 CHECK_MEMBER_ALIGNMENT(VM, selm.s.Tss, 16);
213 PRINT_OFFSET(VM, selm.s.Tss);
214 PVM pVM;
215 if ((RT_OFFSETOF(VM, selm.s.Tss) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.Tss))
216 {
217 printf("error! SELM:Tss is crossing a page!\n");
218 rc++;
219 }
220 PRINT_OFFSET(VM, selm.s.TssTrap08);
221 if ((RT_OFFSETOF(VM, selm.s.TssTrap08) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.TssTrap08))
222 {
223 printf("error! SELM:TssTrap08 is crossing a page!\n");
224 rc++;
225 }
226 CHECK_MEMBER_ALIGNMENT(VM, trpm.s.aIdt, 16);
227 CHECK_MEMBER_ALIGNMENT(VM, aCpus[0], PAGE_SIZE);
228 CHECK_MEMBER_ALIGNMENT(VM, aCpus[1], PAGE_SIZE);
229 CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Host, 64);
230 CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Guest, 64);
231 CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Host, 64);
232 CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Guest, 64);
233 CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Hyper, 64);
234 CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Hyper, 64);
235 CHECK_MEMBER_ALIGNMENT(VM, cpum.s.GuestEntry, 64);
236
237 CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.u64CallRing3Arg, 8);
238#if defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)
239 CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0, 16);
240 CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0.xmm6, 16);
241#endif
242 CHECK_MEMBER_ALIGNMENT(VM, vmm.s.u64LastYield, 8);
243 CHECK_MEMBER_ALIGNMENT(VM, vmm.s.StatRunRC, 8);
244 CHECK_MEMBER_ALIGNMENT(VM, StatTotalQemuToGC, 8);
245 CHECK_MEMBER_ALIGNMENT(VM, rem.s.uPendingExcptCR2, 8);
246 CHECK_MEMBER_ALIGNMENT(VM, rem.s.StatsInQEMU, 8);
247 CHECK_MEMBER_ALIGNMENT(VM, rem.s.Env, 64);
248
249 /* the VMCPUs are page aligned TLB hit reassons. */
250 CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096);
251 CHECK_SIZE_ALIGNMENT(VMCPU, 4096);
252
253 /* cpumctx */
254 CHECK_MEMBER_ALIGNMENT(CPUMCTX, fpu, 32);
255 CHECK_MEMBER_ALIGNMENT(CPUMCTX, edi, 32);
256 CHECK_MEMBER_ALIGNMENT(CPUMCTX, idtr, 4);
257 CHECK_MEMBER_ALIGNMENT(CPUMCTX, SysEnter, 8);
258 CHECK_CPUMCTXCORE(eax);
259 CHECK_CPUMCTXCORE(ebx);
260 CHECK_CPUMCTXCORE(ecx);
261 CHECK_CPUMCTXCORE(edx);
262 CHECK_CPUMCTXCORE(ebp);
263 CHECK_CPUMCTXCORE(esp);
264 CHECK_CPUMCTXCORE(edi);
265 CHECK_CPUMCTXCORE(esi);
266 CHECK_CPUMCTXCORE(eip);
267 CHECK_CPUMCTXCORE(eflags);
268 CHECK_CPUMCTXCORE(cs);
269 CHECK_CPUMCTXCORE(ds);
270 CHECK_CPUMCTXCORE(es);
271 CHECK_CPUMCTXCORE(fs);
272 CHECK_CPUMCTXCORE(gs);
273 CHECK_CPUMCTXCORE(ss);
274 CHECK_CPUMCTXCORE(r8);
275 CHECK_CPUMCTXCORE(r9);
276 CHECK_CPUMCTXCORE(r10);
277 CHECK_CPUMCTXCORE(r11);
278 CHECK_CPUMCTXCORE(r12);
279 CHECK_CPUMCTXCORE(r13);
280 CHECK_CPUMCTXCORE(r14);
281 CHECK_CPUMCTXCORE(r15);
282 CHECK_CPUMCTXCORE(esHid);
283 CHECK_CPUMCTXCORE(csHid);
284 CHECK_CPUMCTXCORE(ssHid);
285 CHECK_CPUMCTXCORE(dsHid);
286 CHECK_CPUMCTXCORE(fsHid);
287 CHECK_CPUMCTXCORE(gsHid);
288
289#if HC_ARCH_BITS == 32
290 /* CPUMHOSTCTX - lss pair */
291 if (RT_OFFSETOF(CPUMHOSTCTX, esp) + 4 != RT_OFFSETOF(CPUMHOSTCTX, ss))
292 {
293 printf("error! CPUMHOSTCTX lss has been split up!\n");
294 rc++;
295 }
296#endif
297 CHECK_SIZE_ALIGNMENT(CPUMCTX, 64);
298 CHECK_SIZE_ALIGNMENT(CPUMHOSTCTX, 64);
299 CHECK_SIZE_ALIGNMENT(CPUMCTXMSR, 64);
300
301 /* pdm */
302 CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64);
303 CHECK_PADDING(PDMDEVINS, Internal, 1);
304 CHECK_MEMBER_ALIGNMENT(PDMUSBINS, achInstanceData, 16);
305 CHECK_PADDING(PDMUSBINS, Internal, 1);
306 CHECK_MEMBER_ALIGNMENT(PDMDRVINS, achInstanceData, 16);
307 CHECK_PADDING(PDMDRVINS, Internal, 1);
308 CHECK_PADDING2(PDMCRITSECT);
309
310 /* pgm */
311#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
312 CHECK_MEMBER_ALIGNMENT(PGMCPU, AutoSet, 8);
313#endif
314 CHECK_MEMBER_ALIGNMENT(PGMCPU, GCPhysCR3, sizeof(RTGCPHYS));
315 CHECK_MEMBER_ALIGNMENT(PGMCPU, aGCPhysGstPaePDs, sizeof(RTGCPHYS));
316 CHECK_MEMBER_ALIGNMENT(PGMCPU, DisState, 8);
317 CHECK_MEMBER_ALIGNMENT(PGMCPU, cPoolAccessHandler, 8);
318#ifdef VBOX_WITH_STATISTICS
319 CHECK_MEMBER_ALIGNMENT(PGMCPU, StatSyncPtPD, 8);
320 CHECK_MEMBER_ALIGNMENT(PGMCPU, StatR3Prefetch, 8);
321#endif
322 CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, idx, sizeof(uint16_t));
323 CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, pvPageR3, sizeof(RTHCPTR));
324 CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, GCPhys, sizeof(RTGCPHYS));
325 CHECK_SIZE(PGMPAGE, 16);
326 CHECK_MEMBER_ALIGNMENT(PGMRAMRANGE, aPages, 16);
327 CHECK_MEMBER_ALIGNMENT(PGMMMIO2RANGE, RamRange, 16);
328
329 /* rem */
330 CHECK_MEMBER_ALIGNMENT(REM, aGCPtrInvalidatedPages, 8);
331 CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalRegister, u.padding);
332 CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalDeregister, u.padding);
333 CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalModify, u.padding);
334 CHECK_SIZE_ALIGNMENT(REMHANDLERNOTIFICATION, 8);
335 CHECK_MEMBER_ALIGNMENT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.GCPhys, 8);
336
337 /* TM */
338 CHECK_MEMBER_ALIGNMENT(TM, TimerCritSect, sizeof(uintptr_t));
339 CHECK_MEMBER_ALIGNMENT(TM, VirtualSyncLock, sizeof(uintptr_t));
340
341 /* misc */
342 CHECK_PADDING3(EMCPU, u.FatalLongJump, u.achPaddingFatalLongJump);
343 CHECK_SIZE_ALIGNMENT(VMMR0JMPBUF, 8);
344 CHECK_SIZE_ALIGNMENT(PATCHINFO, 8);
345#if 0
346 PRINT_OFFSET(VM, fForcedActions);
347 PRINT_OFFSET(VM, StatQemuToGC);
348 PRINT_OFFSET(VM, StatGCToQemu);
349#endif
350
351 CHECK_MEMBER_ALIGNMENT(IOM, EmtLock, sizeof(uintptr_t));
352 CHECK_MEMBER_ALIGNMENT(EM, CritSectREM, sizeof(uintptr_t));
353 CHECK_MEMBER_ALIGNMENT(PGM, CritSect, sizeof(uintptr_t));
354 CHECK_MEMBER_ALIGNMENT(PDM, CritSect, sizeof(uintptr_t));
355 CHECK_MEMBER_ALIGNMENT(MMHYPERHEAP, Lock, sizeof(uintptr_t));
356
357 /* hwaccm - 32-bit gcc won't align uint64_t naturally, so check. */
358 CHECK_MEMBER_ALIGNMENT(HWACCM, u64RegisterMask, 8);
359 CHECK_MEMBER_ALIGNMENT(HWACCM, vmx.hostCR4, 8);
360 CHECK_MEMBER_ALIGNMENT(HWACCM, vmx.msr.feature_ctrl, 8);
361 CHECK_MEMBER_ALIGNMENT(HWACCM, StatTPRPatchSuccess, 8);
362 CHECK_MEMBER_ALIGNMENT(HWACCMCPU, StatEntry, 8);
363 CHECK_MEMBER_ALIGNMENT(HWACCMCPU, vmx.pVMCSPhys, sizeof(RTHCPHYS));
364 CHECK_MEMBER_ALIGNMENT(HWACCMCPU, vmx.proc_ctls, 8);
365 CHECK_MEMBER_ALIGNMENT(HWACCMCPU, Event.intInfo, 8);
366
367 /* The various disassembler state members. */
368 CHECK_PADDING3(EMCPU, DisState, abDisStatePadding);
369 CHECK_PADDING3(HWACCMCPU, DisState, abDisStatePadding);
370 CHECK_PADDING3(IOMCPU, DisState, abDisStatePadding);
371 CHECK_PADDING3(PGMCPU, DisState, abDisStatePadding);
372
373 /* Make sure the set is large enough and has the correct size. */
374 CHECK_SIZE(VMCPUSET, 32);
375 if (sizeof(VMCPUSET) * 8 < VMM_MAX_CPU_COUNT)
376 {
377 printf("error! VMCPUSET is too small for VMM_MAX_CPU_COUNT=%u!\n", VMM_MAX_CPU_COUNT);
378 rc++;
379 }
380
381 printf("info: struct UVM: %d bytes\n", (int)sizeof(UVM));
382
383 CHECK_PADDING_UVM(32, vm);
384 CHECK_PADDING_UVM(32, mm);
385 CHECK_PADDING_UVM(32, pdm);
386 CHECK_PADDING_UVM(32, stam);
387
388 printf("info: struct UVMCPU: %d bytes\n", (int)sizeof(UVMCPU));
389 CHECK_PADDING_UVMCPU(32, vm);
390
391#ifdef VBOX_WITH_RAW_MODE
392 /*
393 * Compare HC and RC.
394 */
395 printf("tstVMStructSize: Comparing HC and RC...\n");
396# include "tstVMStructRC.h"
397#endif /* VBOX_WITH_RAW_MODE */
398
399 /*
400 * Report result.
401 */
402 if (rc)
403 printf("tstVMStructSize: FAILURE - %d errors\n", rc);
404 else
405 printf("tstVMStructSize: SUCCESS\n");
406 return rc;
407}
408
Note: See TracBrowser for help on using the repository browser.

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