VirtualBox

source: vbox/trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp@ 73135

最後變更 在這個檔案從73135是 73135,由 vboxsync 提交於 7 年 前

Serial: Split out the generic UART functionality into a separate module so it can be reused.

Add a PCI Express 16 port UART controller emulation based on the Oxford Semiconductor OXPCIe958
PCI Express to octa UART controller (supports chaining two of those together in a single device
to get up to 16 UARTs). This somewhat revives the incomplete and never enabled PCI UART controller
in the old code. Linux detects the device and apparently configures all 16 UARTs but data transfers
were not tested and the code is pretty incomplete still.
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Id Revision
檔案大小: 83.0 KB
行 
1/* $Id: tstDeviceStructSizeRC.cpp 73135 2018-07-15 16:43:16Z vboxsync $ */
2/** @file
3 * tstDeviceStructSizeGC - Generate structure member and size checks from the RC perspective.
4 *
5 * This is built using the VBoxRc template but linked into a host
6 * ring-3 executable, rather hacky.
7 */
8
9/*
10 * Copyright (C) 2006-2017 Oracle Corporation
11 *
12 * This file is part of VirtualBox Open Source Edition (OSE), as
13 * available from http://www.alldomusa.eu.org. This file is free software;
14 * you can redistribute it and/or modify it under the terms of the GNU
15 * General Public License (GPL) as published by the Free Software
16 * Foundation, in version 2 as it comes in the "COPYING" file of the
17 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19 */
20
21
22/*
23 * Sanity checks.
24 */
25#ifndef IN_RC
26# error Incorrect template!
27#endif
28#if defined(IN_RING3) || defined(IN_RING0)
29# error Incorrect template!
30#endif
31
32
33/*********************************************************************************************************************************
34* Header Files *
35*********************************************************************************************************************************/
36#define VBOX_DEVICE_STRUCT_TESTCASE
37#define VBOX_WITH_HGCM /* grumble */
38
39/* Check that important preprocessor macros does not get redefined: */
40#include <VBox/cdefs.h>
41#include <VBox/log.h>
42#ifdef DEBUG
43# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG
44#else
45# undef VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG
46#endif
47#ifdef LOG_ENABLED
48# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED
49#else
50# undef VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED
51#endif
52#ifdef VBOX_STRICT
53# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT
54#else
55# undef VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT
56#endif
57#ifdef RT_STRICT
58# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT
59#else
60# undef VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT
61#endif
62
63/* The structures we're checking: */
64#undef LOG_GROUP
65#include "../Bus/DevPciInternal.h"
66#undef LOG_GROUP
67#include "../EFI/DevSmc.cpp"
68#undef LOG_GROUP
69#include "../Graphics/DevVGA.cpp"
70#undef LOG_GROUP
71#include "../Input/DevPS2.cpp"
72#undef LOG_GROUP
73#include "../Input/PS2K.cpp"
74#undef LOG_GROUP
75#include "../Input/PS2M.cpp"
76#undef LOG_GROUP
77#include "../Network/DevPCNet.cpp"
78#undef LOG_GROUP
79#include "../PC/DevACPI.cpp"
80#undef LOG_GROUP
81#include "../PC/DevPIC.cpp"
82#undef LOG_GROUP
83#include "../PC/DevPit-i8254.cpp"
84#undef LOG_GROUP
85#include "../PC/DevRTC.cpp"
86# undef LOG_GROUP
87# include "../../VMM/VMMR3/APIC.cpp"
88#undef LOG_GROUP
89#include "../PC/DevIoApic.cpp"
90#undef LOG_GROUP
91#include "../PC/DevDMA.cpp"
92#undef LOG_GROUP
93#include "../Storage/DevATA.cpp"
94#ifdef VBOX_WITH_USB
95# undef LOG_GROUP
96# include "../USB/DevOHCI.cpp"
97# ifdef VBOX_WITH_EHCI_IMPL
98# undef LOG_GROUP
99# include "../USB/DevEHCI.cpp"
100# endif
101# ifdef VBOX_WITH_XHCI_IMPL
102# undef LOG_GROUP
103# include "../USB/DevXHCI.cpp"
104# endif
105#endif
106#undef LOG_GROUP
107#include "../VMMDev/VMMDev.cpp"
108#undef LOG_GROUP
109#include "../Parallel/DevParallel.cpp"
110#undef LOG_GROUP
111#ifndef VBOX_WITH_NEW_SERIAL
112# include "../Serial/DevSerial.cpp"
113#else
114# include "../Serial/DevSerialNew.cpp"
115# include "../Serial/DevOxPcie958.cpp"
116# include "../Serial/UartCore.h"
117#endif
118#ifdef VBOX_WITH_AHCI
119# undef LOG_GROUP
120# include "../Storage/DevAHCI.cpp"
121#endif
122#ifdef VBOX_WITH_E1000
123# undef LOG_GROUP
124# include "../Network/DevE1000.cpp"
125#endif
126#ifdef VBOX_WITH_VIRTIO
127# undef LOG_GROUP
128# include "../Network/DevVirtioNet.cpp"
129#endif
130#ifdef VBOX_WITH_BUSLOGIC
131# undef LOG_GROUP
132# include "../Storage/DevBusLogic.cpp"
133#endif
134#ifdef VBOX_WITH_LSILOGIC
135# undef LOG_GROUP
136# include "../Storage/DevLsiLogicSCSI.cpp"
137#endif
138#undef LOG_GROUP
139#include "../PC/DevHPET.cpp"
140#undef LOG_GROUP
141#include "../Audio/DevIchAc97.cpp"
142#undef LOG_GROUP
143#include "../Audio/DevHDA.cpp"
144#ifdef VBOX_WITH_NVME_IMPL
145# undef LOG_GROUP
146# include "../Storage/DevNVMe.cpp"
147#endif
148
149/* Check that important preprocessor macros didn't get redefined: */
150#if defined(DEBUG) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG)
151# error "DEBUG was modified! This may throw off structure tests."
152#endif
153#if defined(LOG_ENABLED) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED)
154# error "LOG_ENABLED was modified! This may throw off structure tests."
155#endif
156#if defined(RT_STRICT) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT)
157# error "RT_STRICT was modified! This may throw off structure tests."
158#endif
159#if defined(VBOX_STRICT) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT)
160# error "VBOX_STRICT was modified! This may throw off structure tests."
161#endif
162
163
164/* we don't use iprt here because we're pretending to be in GC! */
165#include <stdio.h>
166
167#define GEN_CHECK_SIZE(s) printf(" CHECK_SIZE(%s, %d);\n", #s, (int)sizeof(s))
168#define GEN_CHECK_OFF(s, m) printf(" CHECK_OFF(%s, %d, %s);\n", #s, (int)RT_OFFSETOF(s, m), #m)
169#define GEN_CHECK_PADDING(s, m, a) printf(" CHECK_PADDING(%s, %s, %u);\n", #s, #m, (a))
170
171int main()
172{
173 /* misc */
174 GEN_CHECK_SIZE(PDMDEVINS);
175 GEN_CHECK_OFF(PDMDEVINS, Internal);
176 GEN_CHECK_OFF(PDMDEVINS, pReg);
177 GEN_CHECK_OFF(PDMDEVINS, pCfg);
178 GEN_CHECK_OFF(PDMDEVINS, iInstance);
179 GEN_CHECK_OFF(PDMDEVINS, IBase);
180 GEN_CHECK_OFF(PDMDEVINS, pHlpR3);
181 GEN_CHECK_OFF(PDMDEVINS, pHlpR0);
182 GEN_CHECK_OFF(PDMDEVINS, pHlpRC);
183 GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR3);
184 GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR0);
185 GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataRC);
186 GEN_CHECK_OFF(PDMDEVINS, achInstanceData);
187
188 /* PDMPCIDEV */
189 GEN_CHECK_SIZE(PDMPCIDEV);
190 GEN_CHECK_SIZE(PDMPCIDEVINT);
191 GEN_CHECK_SIZE(PCIIOREGION); /** @todo fix name of PCIIOREGION */
192 GEN_CHECK_OFF(PDMPCIDEV, abConfig);
193 GEN_CHECK_OFF(PDMPCIDEV, uDevFn);
194 GEN_CHECK_OFF(PDMPCIDEV, pszNameR3);
195 GEN_CHECK_OFF(PDMPCIDEV, pfnRegionLoadChangeHookR3);
196 GEN_CHECK_OFF(PDMPCIDEV, Int);
197 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions);
198 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[1]);
199 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[VBOX_PCI_NUM_REGIONS - 1]);
200 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].addr);
201 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].size);
202 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].type);
203 GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].padding);
204 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pBusR3);
205 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pBusR0);
206 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pBusRC);
207 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnConfigRead);
208 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnConfigWrite);
209 GEN_CHECK_OFF(PDMPCIDEV, Int.s.fFlags);
210 GEN_CHECK_OFF(PDMPCIDEV, Int.s.uIrqPinState);
211 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnBridgeConfigRead);
212 GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnBridgeConfigWrite);
213 GEN_CHECK_PADDING(PDMPCIDEV, Int, 8);
214
215 /* DevPciInternal.h */
216 GEN_CHECK_SIZE(DEVPCIBUS);
217 GEN_CHECK_OFF(DEVPCIBUS, iBus);
218 GEN_CHECK_OFF(DEVPCIBUS, iDevSearch);
219 GEN_CHECK_OFF(DEVPCIBUS, cBridges);
220 GEN_CHECK_OFF(DEVPCIBUS, apDevices);
221 GEN_CHECK_OFF(DEVPCIBUS, apDevices[1]);
222 GEN_CHECK_OFF(DEVPCIBUS, pDevInsR3);
223 GEN_CHECK_OFF(DEVPCIBUS, pPciHlpR3);
224 GEN_CHECK_OFF(DEVPCIBUS, papBridgesR3);
225 GEN_CHECK_OFF(DEVPCIBUS, pDevInsR0);
226 GEN_CHECK_OFF(DEVPCIBUS, pPciHlpR0);
227 GEN_CHECK_OFF(DEVPCIBUS, pDevInsRC);
228 GEN_CHECK_OFF(DEVPCIBUS, pPciHlpRC);
229 GEN_CHECK_OFF(DEVPCIBUS, PciDev);
230 GEN_CHECK_SIZE(PIIX3ISABRIDGE);
231 GEN_CHECK_SIZE(DEVPCIROOT);
232 GEN_CHECK_OFF(DEVPCIROOT, PciBus);
233 GEN_CHECK_OFF(DEVPCIROOT, pDevInsR3);
234 GEN_CHECK_OFF(DEVPCIROOT, pDevInsR0);
235 GEN_CHECK_OFF(DEVPCIROOT, pDevInsRC);
236 GEN_CHECK_OFF(DEVPCIROOT, fUseIoApic);
237 GEN_CHECK_OFF(DEVPCIROOT, u64PciConfigMMioAddress);
238 GEN_CHECK_OFF(DEVPCIROOT, u64PciConfigMMioLength);
239 GEN_CHECK_OFF(DEVPCIROOT, auPciApicIrqLevels);
240 GEN_CHECK_OFF(DEVPCIROOT, auPciApicIrqLevels[1]);
241 GEN_CHECK_OFF(DEVPCIROOT, uConfigReg);
242 GEN_CHECK_OFF(DEVPCIROOT, Piix3.iAcpiIrqLevel);
243 GEN_CHECK_OFF(DEVPCIROOT, Piix3.iAcpiIrq);
244 GEN_CHECK_OFF(DEVPCIROOT, Piix3.auPciLegacyIrqLevels);
245 GEN_CHECK_OFF(DEVPCIROOT, Piix3.auPciLegacyIrqLevels[1]);
246 GEN_CHECK_OFF(DEVPCIROOT, Piix3.PIIX3State);
247 GEN_CHECK_OFF(DEVPCIROOT, uPciBiosBus);
248 GEN_CHECK_OFF(DEVPCIROOT, uPciBiosIo);
249 GEN_CHECK_OFF(DEVPCIROOT, uPciBiosMmio);
250 GEN_CHECK_OFF(DEVPCIROOT, uPciBiosMmio64);
251
252 /* EFI/DevSMC.cpp */
253 GEN_CHECK_SIZE(DEVSMC);
254 GEN_CHECK_OFF(DEVSMC, bCmd);
255 GEN_CHECK_OFF(DEVSMC, offKey);
256 GEN_CHECK_OFF(DEVSMC, offValue);
257 GEN_CHECK_OFF(DEVSMC, cKeys);
258 GEN_CHECK_OFF(DEVSMC, CurKey);
259 GEN_CHECK_OFF(DEVSMC, u);
260 GEN_CHECK_OFF(DEVSMC, u.s);
261 GEN_CHECK_OFF(DEVSMC, u.s.bState);
262 GEN_CHECK_OFF(DEVSMC, u.s.bStatusCode);
263 GEN_CHECK_OFF(DEVSMC, u.s.bStatusCode);
264 GEN_CHECK_OFF(DEVSMC, szOsk0And1);
265 GEN_CHECK_OFF(DEVSMC, bDollaryNumber);
266 GEN_CHECK_OFF(DEVSMC, bShutdownReason);
267 GEN_CHECK_OFF(DEVSMC, bNinjaActionTimerJob);
268
269 /* DevVGA.cpp */
270 GEN_CHECK_SIZE(VGASTATE);
271 GEN_CHECK_OFF(VGASTATE, vram_ptrR3);
272 GEN_CHECK_OFF(VGASTATE, get_bpp);
273 GEN_CHECK_OFF(VGASTATE, get_offsets);
274 GEN_CHECK_OFF(VGASTATE, get_resolution);
275 GEN_CHECK_OFF(VGASTATE, rgb_to_pixel);
276 GEN_CHECK_OFF(VGASTATE, cursor_invalidate);
277 GEN_CHECK_OFF(VGASTATE, cursor_draw_line);
278 GEN_CHECK_OFF(VGASTATE, vram_size);
279 GEN_CHECK_OFF(VGASTATE, latch);
280 GEN_CHECK_OFF(VGASTATE, sr_index);
281 GEN_CHECK_OFF(VGASTATE, sr);
282 GEN_CHECK_OFF(VGASTATE, sr[1]);
283 GEN_CHECK_OFF(VGASTATE, gr_index);
284 GEN_CHECK_OFF(VGASTATE, gr);
285 GEN_CHECK_OFF(VGASTATE, gr[1]);
286 GEN_CHECK_OFF(VGASTATE, ar_index);
287 GEN_CHECK_OFF(VGASTATE, ar);
288 GEN_CHECK_OFF(VGASTATE, ar[1]);
289 GEN_CHECK_OFF(VGASTATE, ar_flip_flop);
290 GEN_CHECK_OFF(VGASTATE, cr_index);
291 GEN_CHECK_OFF(VGASTATE, cr);
292 GEN_CHECK_OFF(VGASTATE, cr[1]);
293 GEN_CHECK_OFF(VGASTATE, msr);
294 GEN_CHECK_OFF(VGASTATE, msr);
295 GEN_CHECK_OFF(VGASTATE, fcr);
296 GEN_CHECK_OFF(VGASTATE, st00);
297 GEN_CHECK_OFF(VGASTATE, st01);
298 GEN_CHECK_OFF(VGASTATE, dac_state);
299 GEN_CHECK_OFF(VGASTATE, dac_sub_index);
300 GEN_CHECK_OFF(VGASTATE, dac_read_index);
301 GEN_CHECK_OFF(VGASTATE, dac_write_index);
302 GEN_CHECK_OFF(VGASTATE, dac_cache);
303 GEN_CHECK_OFF(VGASTATE, dac_cache[1]);
304 GEN_CHECK_OFF(VGASTATE, palette);
305 GEN_CHECK_OFF(VGASTATE, palette[1]);
306 GEN_CHECK_OFF(VGASTATE, bank_offset);
307#ifdef CONFIG_BOCHS_VBE
308 GEN_CHECK_OFF(VGASTATE, vbe_index);
309 GEN_CHECK_OFF(VGASTATE, vbe_regs);
310 GEN_CHECK_OFF(VGASTATE, vbe_regs[1]);
311 GEN_CHECK_OFF(VGASTATE, vbe_regs[VBE_DISPI_INDEX_NB - 1]);
312 GEN_CHECK_OFF(VGASTATE, vbe_start_addr);
313 GEN_CHECK_OFF(VGASTATE, vbe_line_offset);
314 GEN_CHECK_OFF(VGASTATE, vbe_bank_max);
315#endif
316 GEN_CHECK_OFF(VGASTATE, font_offsets);
317 GEN_CHECK_OFF(VGASTATE, font_offsets[1]);
318 GEN_CHECK_OFF(VGASTATE, graphic_mode);
319 GEN_CHECK_OFF(VGASTATE, shift_control);
320 GEN_CHECK_OFF(VGASTATE, double_scan);
321 GEN_CHECK_OFF(VGASTATE, line_offset);
322 GEN_CHECK_OFF(VGASTATE, line_compare);
323 GEN_CHECK_OFF(VGASTATE, start_addr);
324 GEN_CHECK_OFF(VGASTATE, plane_updated);
325 GEN_CHECK_OFF(VGASTATE, last_cw);
326 GEN_CHECK_OFF(VGASTATE, last_ch);
327 GEN_CHECK_OFF(VGASTATE, last_width);
328 GEN_CHECK_OFF(VGASTATE, last_height);
329 GEN_CHECK_OFF(VGASTATE, last_scr_width);
330 GEN_CHECK_OFF(VGASTATE, last_scr_height);
331 GEN_CHECK_OFF(VGASTATE, last_bpp);
332 GEN_CHECK_OFF(VGASTATE, cursor_start);
333 GEN_CHECK_OFF(VGASTATE, cursor_end);
334 GEN_CHECK_OFF(VGASTATE, cursor_offset);
335 GEN_CHECK_OFF(VGASTATE, invalidated_y_table);
336 GEN_CHECK_OFF(VGASTATE, invalidated_y_table[1]);
337 GEN_CHECK_OFF(VGASTATE, invalidated_y_table[(VGA_MAX_HEIGHT / 32) - 1]);
338 GEN_CHECK_OFF(VGASTATE, last_palette);
339 GEN_CHECK_OFF(VGASTATE, last_palette[1]);
340 GEN_CHECK_OFF(VGASTATE, last_ch_attr);
341 GEN_CHECK_OFF(VGASTATE, last_ch_attr[CH_ATTR_SIZE - 1]);
342 GEN_CHECK_OFF(VGASTATE, u32Marker);
343 GEN_CHECK_OFF(VGASTATE, pDevInsRC);
344 GEN_CHECK_OFF(VGASTATE, vram_ptrRC);
345 GEN_CHECK_OFF(VGASTATE, pDevInsR3);
346#ifdef VBOX_WITH_HGSMI
347 GEN_CHECK_OFF(VGASTATE, pHGSMI);
348#endif
349#ifdef VBOX_WITH_VDMA
350 GEN_CHECK_OFF(VGASTATE, pVdma);
351#endif
352 GEN_CHECK_OFF(VGASTATE, IBase);
353 GEN_CHECK_OFF(VGASTATE, IPort);
354#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_CRHGSMI))
355 GEN_CHECK_OFF(VGASTATE, IVBVACallbacks);
356#endif
357 GEN_CHECK_OFF(VGASTATE, pDrvBase);
358 GEN_CHECK_OFF(VGASTATE, pDrv);
359 GEN_CHECK_OFF(VGASTATE, RefreshTimer);
360 GEN_CHECK_OFF(VGASTATE, pDevInsR0);
361#ifdef VBOX_WITH_VMSVGA
362 GEN_CHECK_OFF(VGASTATE, svga.u64HostWindowId);
363 GEN_CHECK_OFF(VGASTATE, svga.pFIFOR3);
364 GEN_CHECK_OFF(VGASTATE, svga.pFIFOR0);
365 GEN_CHECK_OFF(VGASTATE, svga.pSvgaR3State);
366 GEN_CHECK_OFF(VGASTATE, svga.p3dState);
367 GEN_CHECK_OFF(VGASTATE, svga.pbVgaFrameBufferR3);
368 GEN_CHECK_OFF(VGASTATE, svga.GCPhysFIFO);
369 GEN_CHECK_OFF(VGASTATE, svga.cbFIFO);
370 GEN_CHECK_OFF(VGASTATE, svga.cbFIFOConfig);
371 GEN_CHECK_OFF(VGASTATE, svga.u32SVGAId);
372 GEN_CHECK_OFF(VGASTATE, svga.fConfigured);
373 GEN_CHECK_OFF(VGASTATE, svga.fBusy);
374 GEN_CHECK_OFF(VGASTATE, svga.fTraces);
375 GEN_CHECK_OFF(VGASTATE, svga.u32GuestId);
376 GEN_CHECK_OFF(VGASTATE, svga.cScratchRegion);
377 GEN_CHECK_OFF(VGASTATE, svga.u32IrqStatus);
378 GEN_CHECK_OFF(VGASTATE, svga.u32IrqMask);
379 GEN_CHECK_OFF(VGASTATE, svga.u32PitchLock);
380 GEN_CHECK_OFF(VGASTATE, svga.u32CurrentGMRId);
381 GEN_CHECK_OFF(VGASTATE, svga.u32RegCaps);
382 GEN_CHECK_OFF(VGASTATE, svga.BasePort);
383 GEN_CHECK_OFF(VGASTATE, svga.u32IndexReg);
384 GEN_CHECK_OFF(VGASTATE, svga.pSupDrvSession);
385 GEN_CHECK_OFF(VGASTATE, svga.FIFORequestSem);
386 GEN_CHECK_OFF(VGASTATE, svga.FIFOExtCmdSem);
387 GEN_CHECK_OFF(VGASTATE, svga.pFIFOIOThread);
388 GEN_CHECK_OFF(VGASTATE, svga.uWidth);
389 GEN_CHECK_OFF(VGASTATE, svga.uHeight);
390 GEN_CHECK_OFF(VGASTATE, svga.uBpp);
391 GEN_CHECK_OFF(VGASTATE, svga.cbScanline);
392 GEN_CHECK_OFF(VGASTATE, svga.u32MaxWidth);
393 GEN_CHECK_OFF(VGASTATE, svga.u32MaxHeight);
394 GEN_CHECK_OFF(VGASTATE, svga.viewport);
395 GEN_CHECK_OFF(VGASTATE, svga.u32ActionFlags);
396 GEN_CHECK_OFF(VGASTATE, svga.f3DEnabled);
397 GEN_CHECK_OFF(VGASTATE, svga.fVRAMTracking);
398 GEN_CHECK_OFF(VGASTATE, svga.u8FIFOExtCommand);
399 GEN_CHECK_OFF(VGASTATE, svga.fFifoExtCommandWakeup);
400 GEN_CHECK_OFF(VGASTATE, svga.au32ScratchRegion);
401 GEN_CHECK_OFF(VGASTATE, svga.StatRegBitsPerPixelWr);
402 GEN_CHECK_OFF(VGASTATE, svga.StatRegWriteOnlyRd);
403#endif
404 GEN_CHECK_OFF(VGASTATE, cMonitors);
405 GEN_CHECK_OFF(VGASTATE, cMilliesRefreshInterval);
406 GEN_CHECK_OFF(VGASTATE, au32DirtyBitmap);
407 GEN_CHECK_OFF(VGASTATE, au32DirtyBitmap[1]);
408 GEN_CHECK_OFF(VGASTATE, au32DirtyBitmap[(VGA_VRAM_MAX / PAGE_SIZE / 32) - 1]);
409 GEN_CHECK_OFF(VGASTATE, fHasDirtyBits);
410 GEN_CHECK_OFF(VGASTATE, fLFBUpdated);
411 GEN_CHECK_OFF(VGASTATE, fGCEnabled);
412 GEN_CHECK_OFF(VGASTATE, fR0Enabled);
413 GEN_CHECK_OFF(VGASTATE, fRemappedVGA);
414 GEN_CHECK_OFF(VGASTATE, fRenderVRAM);
415 GEN_CHECK_OFF(VGASTATE, GCPhysVRAM);
416 GEN_CHECK_OFF(VGASTATE, CritSect);
417 GEN_CHECK_OFF(VGASTATE, Dev);
418 GEN_CHECK_OFF(VGASTATE, StatRZMemoryRead);
419 GEN_CHECK_OFF(VGASTATE, StatR3MemoryRead);
420 GEN_CHECK_OFF(VGASTATE, StatRZMemoryWrite);
421 GEN_CHECK_OFF(VGASTATE, StatR3MemoryWrite);
422#ifdef VBE_BYTEWISE_IO
423 GEN_CHECK_OFF(VGASTATE, fReadVBEData);
424 GEN_CHECK_OFF(VGASTATE, fWriteVBEData);
425 GEN_CHECK_OFF(VGASTATE, fReadVBEIndex);
426 GEN_CHECK_OFF(VGASTATE, fWriteVBEIndex);
427 GEN_CHECK_OFF(VGASTATE, cbWriteVBEData);
428 GEN_CHECK_OFF(VGASTATE, cbWriteVBEIndex);
429# ifdef VBE_NEW_DYN_LIST
430 GEN_CHECK_OFF(VGASTATE, cbWriteVBEExtraAddress);
431# endif
432#endif
433#ifdef VBE_NEW_DYN_LIST
434 GEN_CHECK_OFF(VGASTATE, pbVBEExtraData);
435 GEN_CHECK_OFF(VGASTATE, cbVBEExtraData);
436 GEN_CHECK_OFF(VGASTATE, u16VBEExtraAddress);
437#endif
438 GEN_CHECK_OFF(VGASTATE, pbLogo);
439 GEN_CHECK_OFF(VGASTATE, pszLogoFile);
440 GEN_CHECK_OFF(VGASTATE, pbLogoBitmap);
441 GEN_CHECK_OFF(VGASTATE, offLogoData);
442 GEN_CHECK_OFF(VGASTATE, cbLogo);
443 GEN_CHECK_OFF(VGASTATE, LogoCommand);
444 GEN_CHECK_OFF(VGASTATE, cxLogo);
445 GEN_CHECK_OFF(VGASTATE, cyLogo);
446 GEN_CHECK_OFF(VGASTATE, cLogoPlanes);
447 GEN_CHECK_OFF(VGASTATE, cLogoBits);
448 GEN_CHECK_OFF(VGASTATE, LogoCompression);
449 GEN_CHECK_OFF(VGASTATE, cLogoUsedColors);
450 GEN_CHECK_OFF(VGASTATE, cLogoPalEntries);
451 GEN_CHECK_OFF(VGASTATE, fLogoClearScreen);
452 GEN_CHECK_OFF(VGASTATE, au32LogoPalette);
453 GEN_CHECK_OFF(VGASTATE, pbVgaBios);
454 GEN_CHECK_OFF(VGASTATE, cbVgaBios);
455 GEN_CHECK_OFF(VGASTATE, pszVgaBiosFile);
456#ifdef VBOX_WITH_HGSMI
457 GEN_CHECK_OFF(VGASTATE, IOPortBase);
458#endif
459#ifdef VBOX_WITH_WDDM
460 GEN_CHECK_OFF(VGASTATE, fGuestCaps);
461#endif
462
463 /* Input/pckbd.c */
464 GEN_CHECK_SIZE(KBDState);
465 GEN_CHECK_OFF(KBDState, write_cmd);
466 GEN_CHECK_OFF(KBDState, status);
467 GEN_CHECK_OFF(KBDState, mode);
468 GEN_CHECK_OFF(KBDState, pDevInsR3);
469 GEN_CHECK_OFF(KBDState, pDevInsR0);
470 GEN_CHECK_OFF(KBDState, pDevInsRC);
471 GEN_CHECK_SIZE(KbdKeyQ);
472 GEN_CHECK_OFF(KbdCmdQ, rpos);
473 GEN_CHECK_OFF(KbdCmdQ, wpos);
474 GEN_CHECK_OFF(KbdCmdQ, cUsed);
475 GEN_CHECK_OFF(KbdCmdQ, cSize);
476 GEN_CHECK_OFF(KbdCmdQ, abQueue);
477 GEN_CHECK_SIZE(KbdCmdQ);
478 /* Input/PS2K.c */
479 GEN_CHECK_SIZE(PS2K);
480 GEN_CHECK_OFF(PS2K, fScanning);
481 GEN_CHECK_OFF(PS2K, fNumLockOn);
482 GEN_CHECK_OFF(PS2K, u8ScanSet);
483 GEN_CHECK_OFF(PS2K, u8TypematicCfg);
484 GEN_CHECK_OFF(PS2K, enmTypematicState);
485 GEN_CHECK_OFF(PS2K, keyQ);
486 GEN_CHECK_OFF(PS2K, cmdQ);
487 GEN_CHECK_OFF(PS2K, uTypematicDelay);
488 GEN_CHECK_OFF(PS2K, fThrottleActive);
489 GEN_CHECK_OFF(PS2K, pKbdDelayTimerRC);
490 GEN_CHECK_OFF(PS2K, pKbdDelayTimerR3);
491 GEN_CHECK_OFF(PS2K, pKbdDelayTimerR0);
492 GEN_CHECK_OFF(PS2K, pKbdTypematicTimerRC);
493 GEN_CHECK_OFF(PS2K, pKbdTypematicTimerR3);
494 GEN_CHECK_OFF(PS2K, pKbdTypematicTimerR0);
495 GEN_CHECK_OFF(PS2K, pThrottleTimerRC);
496 GEN_CHECK_OFF(PS2K, pThrottleTimerR3);
497 GEN_CHECK_OFF(PS2K, pThrottleTimerR0);
498 GEN_CHECK_OFF(PS2K, pCritSectR3);
499 GEN_CHECK_OFF(PS2K, Keyboard.IBase);
500 GEN_CHECK_OFF(PS2K, Keyboard.IPort);
501 GEN_CHECK_OFF(PS2K, Keyboard.pDrvBase);
502 GEN_CHECK_OFF(PS2K, Keyboard.pDrv);
503 /* Input/PS2M.c */
504 GEN_CHECK_SIZE(PS2M);
505 GEN_CHECK_OFF(PS2M, u8State);
506 GEN_CHECK_OFF(PS2M, u8SampleRate);
507 GEN_CHECK_OFF(PS2M, u8Resolution);
508 GEN_CHECK_OFF(PS2M, u8CurrCmd);
509 GEN_CHECK_OFF(PS2M, fThrottleActive);
510 GEN_CHECK_OFF(PS2M, fDelayReset);
511 GEN_CHECK_OFF(PS2M, enmMode);
512 GEN_CHECK_OFF(PS2M, enmProtocol);
513 GEN_CHECK_OFF(PS2M, enmKnockState);
514 GEN_CHECK_OFF(PS2M, evtQ);
515 GEN_CHECK_OFF(PS2M, cmdQ);
516 GEN_CHECK_OFF(PS2M, iAccumX);
517 GEN_CHECK_OFF(PS2M, fAccumB);
518 GEN_CHECK_OFF(PS2M, fCurrB);
519 GEN_CHECK_OFF(PS2M, uThrottleDelay);
520 GEN_CHECK_OFF(PS2M, pCritSectR3);
521 GEN_CHECK_OFF(PS2M, pDelayTimerR3);
522 GEN_CHECK_OFF(PS2M, pThrottleTimerR3);
523 GEN_CHECK_OFF(PS2M, pDelayTimerRC);
524 GEN_CHECK_OFF(PS2M, pThrottleTimerRC);
525 GEN_CHECK_OFF(PS2M, pDelayTimerR0);
526 GEN_CHECK_OFF(PS2M, pThrottleTimerR0);
527 GEN_CHECK_OFF(PS2M, Mouse.IBase);
528 GEN_CHECK_OFF(PS2M, Mouse.IPort);
529 GEN_CHECK_OFF(PS2M, Mouse.pDrvBase);
530 GEN_CHECK_OFF(PS2M, Mouse.pDrv);
531
532 /* Network/DevPCNet.cpp */
533 GEN_CHECK_SIZE(PCNETSTATE);
534 GEN_CHECK_OFF(PCNETSTATE, PciDev);
535#ifndef PCNET_NO_POLLING
536 GEN_CHECK_OFF(PCNETSTATE, pTimerPollR3);
537 GEN_CHECK_OFF(PCNETSTATE, pTimerPollR0);
538 GEN_CHECK_OFF(PCNETSTATE, pTimerPollRC);
539#endif
540 GEN_CHECK_OFF(PCNETSTATE, pTimerSoftIntR3);
541 GEN_CHECK_OFF(PCNETSTATE, pTimerSoftIntR0);
542 GEN_CHECK_OFF(PCNETSTATE, pTimerSoftIntRC);
543 GEN_CHECK_OFF(PCNETSTATE, u32RAP);
544 GEN_CHECK_OFF(PCNETSTATE, iISR);
545 GEN_CHECK_OFF(PCNETSTATE, u32Lnkst);
546 GEN_CHECK_OFF(PCNETSTATE, GCRDRA);
547 GEN_CHECK_OFF(PCNETSTATE, GCTDRA);
548 GEN_CHECK_OFF(PCNETSTATE, aPROM);
549 GEN_CHECK_OFF(PCNETSTATE, aPROM[1]);
550 GEN_CHECK_OFF(PCNETSTATE, aCSR);
551 GEN_CHECK_OFF(PCNETSTATE, aCSR[1]);
552 GEN_CHECK_OFF(PCNETSTATE, aCSR[CSR_MAX_REG - 1]);
553 GEN_CHECK_OFF(PCNETSTATE, aBCR);
554 GEN_CHECK_OFF(PCNETSTATE, aBCR[1]);
555 GEN_CHECK_OFF(PCNETSTATE, aBCR[BCR_MAX_RAP - 1]);
556 GEN_CHECK_OFF(PCNETSTATE, aMII);
557 GEN_CHECK_OFF(PCNETSTATE, aMII[1]);
558 GEN_CHECK_OFF(PCNETSTATE, aMII[MII_MAX_REG - 1]);
559 GEN_CHECK_OFF(PCNETSTATE, u16CSR0LastSeenByGuest);
560 GEN_CHECK_OFF(PCNETSTATE, u64LastPoll);
561 GEN_CHECK_OFF(PCNETSTATE, abLoopBuf);
562 GEN_CHECK_OFF(PCNETSTATE, abRecvBuf);
563 GEN_CHECK_OFF(PCNETSTATE, iLog2DescSize);
564 GEN_CHECK_OFF(PCNETSTATE, GCUpperPhys);
565 GEN_CHECK_OFF(PCNETSTATE, pXmitQueueR3);
566 GEN_CHECK_OFF(PCNETSTATE, pXmitQueueR0);
567 GEN_CHECK_OFF(PCNETSTATE, pXmitQueueRC);
568 GEN_CHECK_OFF(PCNETSTATE, pCanRxQueueR3);
569 GEN_CHECK_OFF(PCNETSTATE, pCanRxQueueR0);
570 GEN_CHECK_OFF(PCNETSTATE, pCanRxQueueRC);
571 GEN_CHECK_OFF(PCNETSTATE, pTimerRestore);
572 GEN_CHECK_OFF(PCNETSTATE, pDevInsR3);
573 GEN_CHECK_OFF(PCNETSTATE, pDevInsR0);
574 GEN_CHECK_OFF(PCNETSTATE, pDevInsRC);
575 GEN_CHECK_OFF(PCNETSTATE, pDrvR3);
576 GEN_CHECK_OFF(PCNETSTATE, pDrvBase);
577 GEN_CHECK_OFF(PCNETSTATE, IBase);
578 GEN_CHECK_OFF(PCNETSTATE, INetworkDown);
579 GEN_CHECK_OFF(PCNETSTATE, INetworkConfig);
580 GEN_CHECK_OFF(PCNETSTATE, MMIOBase);
581 GEN_CHECK_OFF(PCNETSTATE, IOPortBase);
582 GEN_CHECK_OFF(PCNETSTATE, fLinkUp);
583 GEN_CHECK_OFF(PCNETSTATE, fLinkTempDown);
584 GEN_CHECK_OFF(PCNETSTATE, cLinkDownReported);
585 GEN_CHECK_OFF(PCNETSTATE, MacConfigured);
586 GEN_CHECK_OFF(PCNETSTATE, Led);
587 GEN_CHECK_OFF(PCNETSTATE, ILeds);
588 GEN_CHECK_OFF(PCNETSTATE, pLedsConnector);
589 GEN_CHECK_OFF(PCNETSTATE, CritSect);
590#ifdef PCNET_NO_POLLING
591 GEN_CHECK_OFF(PCNETSTATE, TDRAPhysOld);
592 GEN_CHECK_OFF(PCNETSTATE, cbTDRAOld);
593 GEN_CHECK_OFF(PCNETSTATE, RDRAPhysOld);
594 GEN_CHECK_OFF(PCNETSTATE, cbRDRAOld);
595 GEN_CHECK_OFF(PCNETSTATE, pfnEMInterpretInstructionGC
596 GEN_CHECK_OFF(PCNETSTATE, pfnEMInterpretInstructionR0
597#endif
598 GEN_CHECK_OFF(PCNETSTATE, fGCEnabled);
599 GEN_CHECK_OFF(PCNETSTATE, fR0Enabled);
600 GEN_CHECK_OFF(PCNETSTATE, fAm79C973);
601 GEN_CHECK_OFF(PCNETSTATE, u32LinkSpeed);
602 GEN_CHECK_OFF(PCNETSTATE, StatReceiveBytes);
603 GEN_CHECK_OFF(PCNETSTATE, StatTransmitBytes);
604#ifdef VBOX_WITH_STATISTICS
605 GEN_CHECK_OFF(PCNETSTATE, StatMMIOReadR3);
606 GEN_CHECK_OFF(PCNETSTATE, StatMMIOReadRZ);
607 GEN_CHECK_OFF(PCNETSTATE, StatMIIReads);
608# ifdef PCNET_NO_POLLING
609 GEN_CHECK_OFF(PCNETSTATE, StatRCVRingWrite);
610 GEN_CHECK_OFF(PCNETSTATE, StatRingWriteOutsideRangeR3);
611# endif
612#endif
613
614 /* PC/DevACPI.cpp */
615 GEN_CHECK_SIZE(ACPIState);
616 GEN_CHECK_OFF(ACPIState, dev);
617 GEN_CHECK_OFF(ACPIState, pm1a_en);
618 GEN_CHECK_OFF(ACPIState, pm1a_sts);
619 GEN_CHECK_OFF(ACPIState, pm1a_ctl);
620 GEN_CHECK_OFF(ACPIState, u64PmTimerInitial);
621 GEN_CHECK_OFF(ACPIState, pPmTimerR3);
622 GEN_CHECK_OFF(ACPIState, pPmTimerR0);
623 GEN_CHECK_OFF(ACPIState, pPmTimerRC);
624 GEN_CHECK_OFF(ACPIState, uPmTimerVal);
625 GEN_CHECK_OFF(ACPIState, gpe0_en);
626 GEN_CHECK_OFF(ACPIState, gpe0_sts);
627 GEN_CHECK_OFF(ACPIState, uBatteryIndex);
628 GEN_CHECK_OFF(ACPIState, au8BatteryInfo);
629 GEN_CHECK_OFF(ACPIState, uSystemInfoIndex);
630 GEN_CHECK_OFF(ACPIState, u64RamSize);
631 GEN_CHECK_OFF(ACPIState, uSleepState);
632 GEN_CHECK_OFF(ACPIState, au8RSDPPage);
633 GEN_CHECK_OFF(ACPIState, u8IndexShift);
634 GEN_CHECK_OFF(ACPIState, u8UseIOApic);
635 GEN_CHECK_OFF(ACPIState, fUseFdc);
636 GEN_CHECK_OFF(ACPIState, fUseHpet);
637 GEN_CHECK_OFF(ACPIState, fUseSmc);
638 GEN_CHECK_OFF(ACPIState, CpuSetAttached);
639 GEN_CHECK_OFF(ACPIState, idCpuLockCheck);
640 GEN_CHECK_OFF(ACPIState, CpuSetLocked);
641 GEN_CHECK_OFF(ACPIState, u32CpuEventType);
642 GEN_CHECK_OFF(ACPIState, u32CpuEvent);
643 GEN_CHECK_OFF(ACPIState, fCpuHotPlug);
644 GEN_CHECK_OFF(ACPIState, u32NicPciAddress);
645 GEN_CHECK_OFF(ACPIState, u32HbcPciAddress);
646 GEN_CHECK_OFF(ACPIState, u64PciConfigMMioAddress);
647 GEN_CHECK_OFF(ACPIState, IBase);
648 GEN_CHECK_OFF(ACPIState, IACPIPort);
649 GEN_CHECK_OFF(ACPIState, pDevInsR3);
650 GEN_CHECK_OFF(ACPIState, pDevInsR0);
651 GEN_CHECK_OFF(ACPIState, pDrvBase);
652 GEN_CHECK_OFF(ACPIState, pDrv);
653 GEN_CHECK_OFF(ACPIState, u16SMBusSlvDat);
654
655 /* PC/DevPIC.cpp */
656 GEN_CHECK_SIZE(PICSTATE);
657 GEN_CHECK_OFF(PICSTATE, last_irr);
658 GEN_CHECK_OFF(PICSTATE, irr);
659 GEN_CHECK_OFF(PICSTATE, imr);
660 GEN_CHECK_OFF(PICSTATE, isr);
661 GEN_CHECK_OFF(PICSTATE, priority_add);
662 GEN_CHECK_OFF(PICSTATE, irq_base);
663 GEN_CHECK_OFF(PICSTATE, read_reg_select);
664 GEN_CHECK_OFF(PICSTATE, poll);
665 GEN_CHECK_OFF(PICSTATE, special_mask);
666 GEN_CHECK_OFF(PICSTATE, init_state);
667 GEN_CHECK_OFF(PICSTATE, auto_eoi);
668 GEN_CHECK_OFF(PICSTATE, rotate_on_auto_eoi);
669 GEN_CHECK_OFF(PICSTATE, special_fully_nested_mode);
670 GEN_CHECK_OFF(PICSTATE, init4);
671 GEN_CHECK_OFF(PICSTATE, elcr);
672 GEN_CHECK_OFF(PICSTATE, elcr_mask);
673 GEN_CHECK_OFF(PICSTATE, pDevInsR3);
674 GEN_CHECK_OFF(PICSTATE, pDevInsR0);
675 GEN_CHECK_OFF(PICSTATE, pDevInsRC);
676 GEN_CHECK_OFF(PICSTATE, idxPic);
677 GEN_CHECK_OFF(PICSTATE, auTags);
678
679 GEN_CHECK_SIZE(DEVPIC);
680 GEN_CHECK_OFF(DEVPIC, aPics);
681 GEN_CHECK_OFF(DEVPIC, aPics[1]);
682 GEN_CHECK_OFF(DEVPIC, pDevInsR3);
683 GEN_CHECK_OFF(DEVPIC, pDevInsR0);
684 GEN_CHECK_OFF(DEVPIC, pDevInsRC);
685 GEN_CHECK_OFF(DEVPIC, pPicHlpR3);
686 GEN_CHECK_OFF(DEVPIC, pPicHlpR0);
687 GEN_CHECK_OFF(DEVPIC, pPicHlpRC);
688#ifdef VBOX_WITH_STATISTICS
689 GEN_CHECK_OFF(DEVPIC, StatSetIrqGC);
690 GEN_CHECK_OFF(DEVPIC, StatClearedActiveSlaveIRQ);
691#endif
692
693 /* PC/DevPit-i8254.cpp */
694 GEN_CHECK_SIZE(DMAState);
695 GEN_CHECK_OFF(DMAState, DMAC);
696 GEN_CHECK_OFF(DMAState, DMAC[0].ChState[0]);
697 GEN_CHECK_OFF(DMAState, DMAC[0].ChState[1]);
698 GEN_CHECK_OFF(DMAState, DMAC[0].u8Mask);
699 GEN_CHECK_OFF(DMAState, DMAC[1].ChState[0]);
700 GEN_CHECK_OFF(DMAState, DMAC[1].ChState[1]);
701 GEN_CHECK_OFF(DMAState, DMAC[1].u8Mask);
702
703 /* PC/DevPit-i8254.cpp */
704 GEN_CHECK_SIZE(PITCHANNEL);
705 GEN_CHECK_OFF(PITCHANNEL, pPitR3);
706 GEN_CHECK_OFF(PITCHANNEL, pTimerR3);
707 GEN_CHECK_OFF(PITCHANNEL, pPitR0);
708 GEN_CHECK_OFF(PITCHANNEL, pTimerR0);
709 GEN_CHECK_OFF(PITCHANNEL, pPitRC);
710 GEN_CHECK_OFF(PITCHANNEL, pTimerRC);
711 GEN_CHECK_OFF(PITCHANNEL, u64ReloadTS);
712 GEN_CHECK_OFF(PITCHANNEL, u64NextTS);
713 GEN_CHECK_OFF(PITCHANNEL, count_load_time);
714 GEN_CHECK_OFF(PITCHANNEL, next_transition_time);
715 GEN_CHECK_OFF(PITCHANNEL, irq);
716 GEN_CHECK_OFF(PITCHANNEL, cRelLogEntries);
717 GEN_CHECK_OFF(PITCHANNEL, count);
718 GEN_CHECK_OFF(PITCHANNEL, latched_count);
719 GEN_CHECK_OFF(PITCHANNEL, count_latched);
720 GEN_CHECK_OFF(PITCHANNEL, status_latched);
721 GEN_CHECK_OFF(PITCHANNEL, status);
722 GEN_CHECK_OFF(PITCHANNEL, read_state);
723 GEN_CHECK_OFF(PITCHANNEL, write_state);
724 GEN_CHECK_OFF(PITCHANNEL, write_latch);
725 GEN_CHECK_OFF(PITCHANNEL, rw_mode);
726 GEN_CHECK_OFF(PITCHANNEL, mode);
727 GEN_CHECK_OFF(PITCHANNEL, bcd);
728 GEN_CHECK_OFF(PITCHANNEL, gate);
729 GEN_CHECK_SIZE(PITSTATE);
730 GEN_CHECK_OFF(PITSTATE, channels);
731 GEN_CHECK_OFF(PITSTATE, channels[1]);
732 GEN_CHECK_OFF(PITSTATE, speaker_data_on);
733// GEN_CHECK_OFF(PITSTATE, dummy_refresh_clock);
734 GEN_CHECK_OFF(PITSTATE, IOPortBaseCfg);
735 GEN_CHECK_OFF(PITSTATE, fSpeakerCfg);
736 GEN_CHECK_OFF(PITSTATE, pDevIns);
737 GEN_CHECK_OFF(PITSTATE, StatPITIrq);
738 GEN_CHECK_OFF(PITSTATE, StatPITHandler);
739
740 /* PC/DevRTC.cpp */
741 GEN_CHECK_SIZE(RTCSTATE);
742 GEN_CHECK_OFF(RTCSTATE, cmos_data);
743 GEN_CHECK_OFF(RTCSTATE, cmos_data[1]);
744 GEN_CHECK_OFF(RTCSTATE, cmos_index);
745 GEN_CHECK_OFF(RTCSTATE, current_tm);
746 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_sec);
747 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_min);
748 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_hour);
749 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_mday);
750 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_mon);
751 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_year);
752 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_wday);
753 GEN_CHECK_OFF(RTCSTATE, current_tm.tm_yday);
754 GEN_CHECK_OFF(RTCSTATE, irq);
755 GEN_CHECK_OFF(RTCSTATE, fUTC);
756 GEN_CHECK_OFF(RTCSTATE, IOPortBase);
757 GEN_CHECK_OFF(RTCSTATE, pPeriodicTimerR0);
758 GEN_CHECK_OFF(RTCSTATE, pPeriodicTimerR3);
759 GEN_CHECK_OFF(RTCSTATE, pPeriodicTimerRC);
760 GEN_CHECK_OFF(RTCSTATE, next_periodic_time);
761 GEN_CHECK_OFF(RTCSTATE, next_second_time);
762 GEN_CHECK_OFF(RTCSTATE, pSecondTimerR0);
763 GEN_CHECK_OFF(RTCSTATE, pSecondTimerR3);
764 GEN_CHECK_OFF(RTCSTATE, pSecondTimerRC);
765 GEN_CHECK_OFF(RTCSTATE, pSecondTimer2R0);
766 GEN_CHECK_OFF(RTCSTATE, pSecondTimer2R3);
767 GEN_CHECK_OFF(RTCSTATE, pSecondTimer2RC);
768 GEN_CHECK_OFF(RTCSTATE, pDevInsR0);
769 GEN_CHECK_OFF(RTCSTATE, pDevInsR3);
770 GEN_CHECK_OFF(RTCSTATE, pDevInsRC);
771 GEN_CHECK_OFF(RTCSTATE, RtcReg);
772 GEN_CHECK_OFF(RTCSTATE, pRtcHlpR3);
773 GEN_CHECK_OFF(RTCSTATE, cRelLogEntries);
774 GEN_CHECK_OFF(RTCSTATE, CurLogPeriod);
775 GEN_CHECK_OFF(RTCSTATE, CurHintPeriod);
776
777 GEN_CHECK_SIZE(APIC);
778 GEN_CHECK_OFF(APIC, pApicDevR0);
779 GEN_CHECK_OFF(APIC, pApicDevR3);
780 GEN_CHECK_OFF(APIC, pApicDevRC);
781 GEN_CHECK_OFF(APIC, HCPhysApicPib);
782 GEN_CHECK_OFF(APIC, pvApicPibR0);
783 GEN_CHECK_OFF(APIC, pvApicPibR3);
784 GEN_CHECK_OFF(APIC, pvApicPibRC);
785 GEN_CHECK_OFF(APIC, cbApicPib);
786 GEN_CHECK_OFF(APIC, fVirtApicRegsEnabled);
787 GEN_CHECK_OFF(APIC, fPostedIntrsEnabled);
788 GEN_CHECK_OFF(APIC, fSupportsTscDeadline);
789 GEN_CHECK_OFF(APIC, fIoApicPresent);
790 GEN_CHECK_OFF(APIC, fRZEnabled);
791 GEN_CHECK_OFF(APIC, enmMaxMode);
792
793 GEN_CHECK_SIZE(APICCPU);
794 GEN_CHECK_OFF(APICCPU, pvApicPageR0);
795 GEN_CHECK_OFF(APICCPU, pvApicPageR3);
796 GEN_CHECK_OFF(APICCPU, pvApicPageRC);
797 GEN_CHECK_OFF(APICCPU, cbApicPage);
798 GEN_CHECK_OFF(APICCPU, uEsrInternal);
799 GEN_CHECK_OFF(APICCPU, uApicBaseMsr);
800 GEN_CHECK_OFF(APICCPU, HCPhysApicPib);
801 GEN_CHECK_OFF(APICCPU, pvApicPibR0);
802 GEN_CHECK_OFF(APICCPU, pvApicPibR3);
803 GEN_CHECK_OFF(APICCPU, pvApicPibRC);
804 GEN_CHECK_OFF(APICCPU, ApicPibLevel);
805 GEN_CHECK_OFF(APICCPU, pTimerR0);
806 GEN_CHECK_OFF(APICCPU, pTimerR3);
807 GEN_CHECK_OFF(APICCPU, pTimerRC);
808 GEN_CHECK_OFF(APICCPU, TimerCritSect);
809 GEN_CHECK_OFF(APICCPU, u64TimerInitial);
810 GEN_CHECK_OFF(APICCPU, uHintedTimerInitialCount);
811 GEN_CHECK_OFF(APICCPU, uHintedTimerShift);
812# ifdef VBOX_WITH_STATISTICS
813 GEN_CHECK_OFF(APICCPU, StatMmioReadRZ);
814 GEN_CHECK_OFF(APICCPU, StatMmioReadR3);
815 GEN_CHECK_OFF(APICCPU, StatMmioWriteRZ);
816 GEN_CHECK_OFF(APICCPU, StatMmioWriteR3);
817 GEN_CHECK_OFF(APICCPU, StatMsrReadRZ);
818 GEN_CHECK_OFF(APICCPU, StatMsrReadR3);
819 GEN_CHECK_OFF(APICCPU, StatMsrWriteRZ);
820 GEN_CHECK_OFF(APICCPU, StatMsrWriteR3);
821 GEN_CHECK_OFF(APICCPU, StatUpdatePendingIntrs);
822 GEN_CHECK_OFF(APICCPU, StatPostIntr);
823 GEN_CHECK_OFF(APICCPU, StatPostIntrAlreadyPending);
824 GEN_CHECK_OFF(APICCPU, StatTimerCallback);
825 GEN_CHECK_OFF(APICCPU, StatTprWrite);
826 GEN_CHECK_OFF(APICCPU, StatTprRead);
827 GEN_CHECK_OFF(APICCPU, StatEoiWrite);
828 GEN_CHECK_OFF(APICCPU, StatMaskedByTpr);
829 GEN_CHECK_OFF(APICCPU, StatMaskedByPpr);
830 GEN_CHECK_OFF(APICCPU, StatTimerIcrWrite);
831 GEN_CHECK_OFF(APICCPU, StatIcrLoWrite);
832 GEN_CHECK_OFF(APICCPU, StatIcrHiWrite);
833 GEN_CHECK_OFF(APICCPU, StatIcrFullWrite);
834# endif /* VBOX_WITH_STATISTICS */
835
836 /* PC/DevIoApic.cpp */
837 GEN_CHECK_SIZE(IOAPIC);
838 GEN_CHECK_OFF(IOAPIC, pDevInsR3);
839 GEN_CHECK_OFF(IOAPIC, pIoApicHlpR3);
840 GEN_CHECK_OFF(IOAPIC, pDevInsR0);
841 GEN_CHECK_OFF(IOAPIC, pIoApicHlpR0);
842 GEN_CHECK_OFF(IOAPIC, pDevInsRC);
843 GEN_CHECK_OFF(IOAPIC, pIoApicHlpRC);
844 GEN_CHECK_OFF(IOAPIC, u8Id);
845 GEN_CHECK_OFF(IOAPIC, u8Index);
846 GEN_CHECK_OFF(IOAPIC, cCpus);
847 GEN_CHECK_OFF(IOAPIC, au64RedirTable);
848 GEN_CHECK_OFF(IOAPIC, uIrr);
849# ifdef VBOX_WITH_STATISTICS
850 GEN_CHECK_OFF(IOAPIC, StatMmioReadRZ);
851 GEN_CHECK_OFF(IOAPIC, StatMmioReadR3);
852 GEN_CHECK_OFF(IOAPIC, StatMmioWriteRZ);
853 GEN_CHECK_OFF(IOAPIC, StatMmioWriteR3);
854 GEN_CHECK_OFF(IOAPIC, StatSetIrqRZ);
855 GEN_CHECK_OFF(IOAPIC, StatSetIrqR3);
856 GEN_CHECK_OFF(IOAPIC, StatSetEoiRZ);
857 GEN_CHECK_OFF(IOAPIC, StatSetEoiR3);
858# endif
859
860 /* Storage/DevATA.cpp */
861 GEN_CHECK_SIZE(BMDMAState);
862 GEN_CHECK_OFF(BMDMAState, u8Cmd);
863 GEN_CHECK_OFF(BMDMAState, u8Status);
864 GEN_CHECK_OFF(BMDMAState, GCPhysAddr);
865 GEN_CHECK_SIZE(BMDMADesc);
866 GEN_CHECK_OFF(BMDMADesc, GCPhysBuffer);
867 GEN_CHECK_OFF(BMDMADesc, cbBuffer);
868 GEN_CHECK_SIZE(ATADevState);
869 GEN_CHECK_OFF(ATADevState, fLBA48);
870 GEN_CHECK_OFF(ATADevState, fATAPI);
871 GEN_CHECK_OFF(ATADevState, fIrqPending);
872 GEN_CHECK_OFF(ATADevState, cMultSectors);
873 GEN_CHECK_OFF(ATADevState, cbSector);
874 GEN_CHECK_OFF(ATADevState, PCHSGeometry.cCylinders);
875 GEN_CHECK_OFF(ATADevState, PCHSGeometry.cHeads);
876 GEN_CHECK_OFF(ATADevState, PCHSGeometry.cSectors);
877 GEN_CHECK_OFF(ATADevState, cSectorsPerIRQ);
878 GEN_CHECK_OFF(ATADevState, cTotalSectors);
879 GEN_CHECK_OFF(ATADevState, uATARegFeature);
880 GEN_CHECK_OFF(ATADevState, uATARegFeatureHOB);
881 GEN_CHECK_OFF(ATADevState, uATARegError);
882 GEN_CHECK_OFF(ATADevState, uATARegNSector);
883 GEN_CHECK_OFF(ATADevState, uATARegNSectorHOB);
884 GEN_CHECK_OFF(ATADevState, uATARegSector);
885 GEN_CHECK_OFF(ATADevState, uATARegSectorHOB);
886 GEN_CHECK_OFF(ATADevState, uATARegLCyl);
887 GEN_CHECK_OFF(ATADevState, uATARegLCylHOB);
888 GEN_CHECK_OFF(ATADevState, uATARegHCyl);
889 GEN_CHECK_OFF(ATADevState, uATARegHCylHOB);
890 GEN_CHECK_OFF(ATADevState, uATARegSelect);
891 GEN_CHECK_OFF(ATADevState, uATARegStatus);
892 GEN_CHECK_OFF(ATADevState, uATARegCommand);
893 GEN_CHECK_OFF(ATADevState, uATARegDevCtl);
894 GEN_CHECK_OFF(ATADevState, uATATransferMode);
895 GEN_CHECK_OFF(ATADevState, uTxDir);
896 GEN_CHECK_OFF(ATADevState, iBeginTransfer);
897 GEN_CHECK_OFF(ATADevState, iSourceSink);
898 GEN_CHECK_OFF(ATADevState, fDMA);
899 GEN_CHECK_OFF(ATADevState, fATAPITransfer);
900 GEN_CHECK_OFF(ATADevState, cbTotalTransfer);
901 GEN_CHECK_OFF(ATADevState, cbElementaryTransfer);
902 GEN_CHECK_OFF(ATADevState, iIOBufferCur);
903 GEN_CHECK_OFF(ATADevState, iIOBufferEnd);
904 GEN_CHECK_OFF(ATADevState, iIOBufferPIODataStart);
905 GEN_CHECK_OFF(ATADevState, iIOBufferPIODataEnd);
906 GEN_CHECK_OFF(ATADevState, iATAPILBA);
907 GEN_CHECK_OFF(ATADevState, cbATAPISector);
908 GEN_CHECK_OFF(ATADevState, aATAPICmd);
909 GEN_CHECK_OFF(ATADevState, aATAPICmd[ATAPI_PACKET_SIZE - 1]);
910 GEN_CHECK_OFF(ATADevState, abATAPISense);
911 GEN_CHECK_OFF(ATADevState, abATAPISense[ATAPI_SENSE_SIZE - 1]);
912 GEN_CHECK_OFF(ATADevState, cNotifiedMediaChange);
913 GEN_CHECK_OFF(ATADevState, MediaEventStatus);
914 GEN_CHECK_OFF(ATADevState, MediaTrackType);
915 GEN_CHECK_OFF(ATADevState, Led);
916 GEN_CHECK_OFF(ATADevState, cbIOBuffer);
917 GEN_CHECK_OFF(ATADevState, pbIOBufferR3);
918 GEN_CHECK_OFF(ATADevState, pbIOBufferR0);
919 GEN_CHECK_OFF(ATADevState, pbIOBufferRC);
920 GEN_CHECK_OFF(ATADevState, StatATADMA);
921 GEN_CHECK_OFF(ATADevState, StatATAPIO);
922 GEN_CHECK_OFF(ATADevState, StatATAPIDMA);
923 GEN_CHECK_OFF(ATADevState, StatATAPIPIO);
924 GEN_CHECK_OFF(ATADevState, StatReads);
925 GEN_CHECK_OFF(ATADevState, StatBytesRead);
926 GEN_CHECK_OFF(ATADevState, StatWrites);
927 GEN_CHECK_OFF(ATADevState, StatBytesWritten);
928 GEN_CHECK_OFF(ATADevState, StatFlushes);
929 GEN_CHECK_OFF(ATADevState, fATAPIPassthrough);
930 GEN_CHECK_OFF(ATADevState, fOverwriteInquiry);
931 GEN_CHECK_OFF(ATADevState, cErrors);
932 GEN_CHECK_OFF(ATADevState, pDrvBase);
933 GEN_CHECK_OFF(ATADevState, pDrvMedia);
934 GEN_CHECK_OFF(ATADevState, pDrvMount);
935 GEN_CHECK_OFF(ATADevState, IBase);
936 GEN_CHECK_OFF(ATADevState, IPort);
937 GEN_CHECK_OFF(ATADevState, IMountNotify);
938 GEN_CHECK_OFF(ATADevState, iLUN);
939 GEN_CHECK_OFF(ATADevState, pDevInsR3);
940 GEN_CHECK_OFF(ATADevState, pDevInsR0);
941 GEN_CHECK_OFF(ATADevState, pDevInsRC);
942 GEN_CHECK_OFF(ATADevState, pControllerR3);
943 GEN_CHECK_OFF(ATADevState, pControllerR0);
944 GEN_CHECK_OFF(ATADevState, pControllerRC);
945 GEN_CHECK_OFF(ATADevState, szSerialNumber);
946 GEN_CHECK_OFF(ATADevState, szSerialNumber[ATA_SERIAL_NUMBER_LENGTH]);
947 GEN_CHECK_OFF(ATADevState, szFirmwareRevision);
948 GEN_CHECK_OFF(ATADevState, szFirmwareRevision[ATA_FIRMWARE_REVISION_LENGTH]);
949 GEN_CHECK_OFF(ATADevState, szModelNumber);
950 GEN_CHECK_OFF(ATADevState, szModelNumber[ATA_MODEL_NUMBER_LENGTH]);
951 GEN_CHECK_OFF(ATADevState, szInquiryVendorId);
952 GEN_CHECK_OFF(ATADevState, szInquiryVendorId[SCSI_INQUIRY_VENDOR_ID_LENGTH]);
953 GEN_CHECK_OFF(ATADevState, szInquiryProductId);
954 GEN_CHECK_OFF(ATADevState, szInquiryProductId[SCSI_INQUIRY_PRODUCT_ID_LENGTH]);
955 GEN_CHECK_OFF(ATADevState, szInquiryRevision);
956 GEN_CHECK_OFF(ATADevState, szInquiryRevision[SCSI_INQUIRY_REVISION_LENGTH]);
957 GEN_CHECK_OFF(ATADevState, pTrackList);
958 GEN_CHECK_SIZE(ATATransferRequest);
959 GEN_CHECK_OFF(ATATransferRequest, iIf);
960 GEN_CHECK_OFF(ATATransferRequest, iBeginTransfer);
961 GEN_CHECK_OFF(ATATransferRequest, iSourceSink);
962 GEN_CHECK_OFF(ATATransferRequest, cbTotalTransfer);
963 GEN_CHECK_OFF(ATATransferRequest, uTxDir);
964 GEN_CHECK_SIZE(ATAAbortRequest);
965 GEN_CHECK_OFF(ATAAbortRequest, iIf);
966 GEN_CHECK_OFF(ATAAbortRequest, fResetDrive);
967 GEN_CHECK_SIZE(ATARequest);
968 GEN_CHECK_OFF(ATARequest, ReqType);
969 GEN_CHECK_OFF(ATARequest, u);
970 GEN_CHECK_OFF(ATARequest, u.t);
971 GEN_CHECK_OFF(ATARequest, u.a);
972 GEN_CHECK_SIZE(ATACONTROLLER);
973 GEN_CHECK_OFF(ATACONTROLLER, IOPortBase1);
974 GEN_CHECK_OFF(ATACONTROLLER, IOPortBase2);
975 GEN_CHECK_OFF(ATACONTROLLER, irq);
976 GEN_CHECK_OFF(ATACONTROLLER, lock);
977 GEN_CHECK_OFF(ATACONTROLLER, iSelectedIf);
978 GEN_CHECK_OFF(ATACONTROLLER, iAIOIf);
979 GEN_CHECK_OFF(ATACONTROLLER, uAsyncIOState);
980 GEN_CHECK_OFF(ATACONTROLLER, fChainedTransfer);
981 GEN_CHECK_OFF(ATACONTROLLER, fReset);
982 GEN_CHECK_OFF(ATACONTROLLER, fRedo);
983 GEN_CHECK_OFF(ATACONTROLLER, fRedoIdle);
984 GEN_CHECK_OFF(ATACONTROLLER, fRedoDMALastDesc);
985 GEN_CHECK_OFF(ATACONTROLLER, BmDma);
986 GEN_CHECK_OFF(ATACONTROLLER, GCPhysFirstDMADesc);
987 GEN_CHECK_OFF(ATACONTROLLER, GCPhysLastDMADesc);
988 GEN_CHECK_OFF(ATACONTROLLER, GCPhysRedoDMABuffer);
989 GEN_CHECK_OFF(ATACONTROLLER, cbRedoDMABuffer);
990 GEN_CHECK_OFF(ATACONTROLLER, aIfs);
991 GEN_CHECK_OFF(ATACONTROLLER, aIfs[1]);
992 GEN_CHECK_OFF(ATACONTROLLER, pDevInsR3);
993 GEN_CHECK_OFF(ATACONTROLLER, pDevInsR0);
994 GEN_CHECK_OFF(ATACONTROLLER, pDevInsRC);
995 GEN_CHECK_OFF(ATACONTROLLER, fShutdown);
996 GEN_CHECK_OFF(ATACONTROLLER, AsyncIOThread);
997 GEN_CHECK_OFF(ATACONTROLLER, hAsyncIOSem);
998 GEN_CHECK_OFF(ATACONTROLLER, aAsyncIORequests[4]);
999 GEN_CHECK_OFF(ATACONTROLLER, AsyncIOReqHead);
1000 GEN_CHECK_OFF(ATACONTROLLER, AsyncIOReqTail);
1001 GEN_CHECK_OFF(ATACONTROLLER, AsyncIORequestLock);
1002 GEN_CHECK_OFF(ATACONTROLLER, SuspendIOSem);
1003 GEN_CHECK_OFF(ATACONTROLLER, fSignalIdle);
1004 GEN_CHECK_OFF(ATACONTROLLER, DelayIRQMillies);
1005 GEN_CHECK_OFF(ATACONTROLLER, u64ResetTime);
1006 GEN_CHECK_OFF(ATACONTROLLER, StatAsyncOps);
1007 GEN_CHECK_OFF(ATACONTROLLER, StatAsyncMinWait);
1008 GEN_CHECK_OFF(ATACONTROLLER, StatAsyncMaxWait);
1009 GEN_CHECK_OFF(ATACONTROLLER, StatAsyncTimeUS);
1010 GEN_CHECK_OFF(ATACONTROLLER, StatAsyncTime);
1011 GEN_CHECK_OFF(ATACONTROLLER, StatLockWait);
1012 GEN_CHECK_SIZE(PCIATAState);
1013 GEN_CHECK_OFF(PCIATAState, dev);
1014 GEN_CHECK_OFF(PCIATAState, aCts);
1015 GEN_CHECK_OFF(PCIATAState, aCts[1]);
1016 GEN_CHECK_OFF(PCIATAState, pDevIns);
1017 GEN_CHECK_OFF(PCIATAState, IBase);
1018 GEN_CHECK_OFF(PCIATAState, ILeds);
1019 GEN_CHECK_OFF(PCIATAState, pLedsConnector);
1020 GEN_CHECK_OFF(PCIATAState, fRCEnabled);
1021 GEN_CHECK_OFF(PCIATAState, fR0Enabled);
1022
1023#ifdef VBOX_WITH_USB
1024 /* USB/DevOHCI.cpp */
1025 GEN_CHECK_SIZE(OHCIHUBPORT);
1026 GEN_CHECK_OFF(OHCIHUBPORT, fReg);
1027 GEN_CHECK_OFF(OHCIHUBPORT, pDev);
1028
1029 GEN_CHECK_SIZE(OHCIROOTHUB);
1030 GEN_CHECK_OFF(OHCIROOTHUB, pIBase);
1031 GEN_CHECK_OFF(OHCIROOTHUB, pIRhConn);
1032 GEN_CHECK_OFF(OHCIROOTHUB, pIDev);
1033 GEN_CHECK_OFF(OHCIROOTHUB, IBase);
1034 GEN_CHECK_OFF(OHCIROOTHUB, IRhPort);
1035 GEN_CHECK_OFF(OHCIROOTHUB, status);
1036 GEN_CHECK_OFF(OHCIROOTHUB, desc_a);
1037 GEN_CHECK_OFF(OHCIROOTHUB, desc_b);
1038 GEN_CHECK_OFF(OHCIROOTHUB, aPorts);
1039 GEN_CHECK_OFF(OHCIROOTHUB, aPorts[1]);
1040 GEN_CHECK_OFF(OHCIROOTHUB, aPorts[OHCI_NDP_MAX - 1]);
1041 GEN_CHECK_OFF(OHCIROOTHUB, pOhci);
1042
1043 GEN_CHECK_SIZE(OHCI);
1044 GEN_CHECK_OFF(OHCI, PciDev);
1045 GEN_CHECK_OFF(OHCI, MMIOBase);
1046 GEN_CHECK_OFF(OHCI, pEndOfFrameTimerR3);
1047 GEN_CHECK_OFF(OHCI, pEndOfFrameTimerR0);
1048 GEN_CHECK_OFF(OHCI, pEndOfFrameTimerRC);
1049 GEN_CHECK_OFF(OHCI, pDevInsR3);
1050 GEN_CHECK_OFF(OHCI, pDevInsR0);
1051 GEN_CHECK_OFF(OHCI, pDevInsRC);
1052 GEN_CHECK_OFF(OHCI, SofTime);
1053 //GEN_CHECK_OFF(OHCI, dqic:3);
1054 //GEN_CHECK_OFF(OHCI, fno:1);
1055 GEN_CHECK_OFF(OHCI, RootHub);
1056 GEN_CHECK_OFF(OHCI, ctl);
1057 GEN_CHECK_OFF(OHCI, status);
1058 GEN_CHECK_OFF(OHCI, intr_status);
1059 GEN_CHECK_OFF(OHCI, intr);
1060 GEN_CHECK_OFF(OHCI, hcca);
1061 GEN_CHECK_OFF(OHCI, per_cur);
1062 GEN_CHECK_OFF(OHCI, ctrl_cur);
1063 GEN_CHECK_OFF(OHCI, ctrl_head);
1064 GEN_CHECK_OFF(OHCI, bulk_cur);
1065 GEN_CHECK_OFF(OHCI, bulk_head);
1066 GEN_CHECK_OFF(OHCI, done);
1067 //GEN_CHECK_OFF(OHCI, fsmps:15);
1068 //GEN_CHECK_OFF(OHCI, fit:1);
1069 //GEN_CHECK_OFF(OHCI, fi:14);
1070 //GEN_CHECK_OFF(OHCI, frt:1);
1071 GEN_CHECK_OFF(OHCI, HcFmNumber);
1072 GEN_CHECK_OFF(OHCI, pstart);
1073 GEN_CHECK_OFF(OHCI, cTicksPerFrame);
1074 GEN_CHECK_OFF(OHCI, cTicksPerUsbTick);
1075 GEN_CHECK_OFF(OHCI, cInFlight);
1076 GEN_CHECK_OFF(OHCI, aInFlight);
1077 GEN_CHECK_OFF(OHCI, aInFlight[0].GCPhysTD);
1078 GEN_CHECK_OFF(OHCI, aInFlight[0].pUrb);
1079 GEN_CHECK_OFF(OHCI, aInFlight[1]);
1080 GEN_CHECK_OFF(OHCI, cInDoneQueue);
1081 GEN_CHECK_OFF(OHCI, aInDoneQueue);
1082 GEN_CHECK_OFF(OHCI, aInDoneQueue[0].GCPhysTD);
1083 GEN_CHECK_OFF(OHCI, aInDoneQueue[1]);
1084 GEN_CHECK_OFF(OHCI, u32FmDoneQueueTail);
1085 GEN_CHECK_OFF(OHCI, pLoad);
1086# ifdef VBOX_WITH_STATISTICS
1087 GEN_CHECK_OFF(OHCI, StatCanceledIsocUrbs);
1088 GEN_CHECK_OFF(OHCI, StatCanceledGenUrbs);
1089 GEN_CHECK_OFF(OHCI, StatDroppedUrbs);
1090 GEN_CHECK_OFF(OHCI, StatTimer);
1091# endif
1092 GEN_CHECK_OFF(OHCI, CsIrq);
1093 GEN_CHECK_OFF(OHCI, CritSect);
1094
1095# ifdef VBOX_WITH_EHCI_IMPL
1096 /* USB/DevEHCI.cpp */
1097 GEN_CHECK_SIZE(EHCIHUBPORT);
1098 GEN_CHECK_OFF(EHCIHUBPORT, fReg);
1099 GEN_CHECK_OFF(EHCIHUBPORT, pDev);
1100
1101 GEN_CHECK_SIZE(EHCIROOTHUB);
1102 GEN_CHECK_OFF(EHCIROOTHUB, pIBase);
1103 GEN_CHECK_OFF(EHCIROOTHUB, pIRhConn);
1104 GEN_CHECK_OFF(EHCIROOTHUB, pIDev);
1105 GEN_CHECK_OFF(EHCIROOTHUB, IBase);
1106 GEN_CHECK_OFF(EHCIROOTHUB, IRhPort);
1107 GEN_CHECK_OFF(EHCIROOTHUB, Led);
1108 GEN_CHECK_OFF(EHCIROOTHUB, ILeds);
1109 GEN_CHECK_OFF(EHCIROOTHUB, pLedsConnector);
1110 GEN_CHECK_OFF(EHCIROOTHUB, aPorts);
1111 GEN_CHECK_OFF(EHCIROOTHUB, aPorts[1]);
1112 GEN_CHECK_OFF(EHCIROOTHUB, aPorts[EHCI_NDP_MAX - 1]);
1113 GEN_CHECK_OFF(EHCIROOTHUB, pEhci);
1114
1115 GEN_CHECK_SIZE(EHCI);
1116 GEN_CHECK_OFF(EHCI, PciDev);
1117 GEN_CHECK_OFF(EHCI, MMIOBase);
1118 GEN_CHECK_OFF(EHCI, pDevInsR3);
1119 GEN_CHECK_OFF(EHCI, pDevInsR0);
1120 GEN_CHECK_OFF(EHCI, pDevInsRC);
1121 GEN_CHECK_OFF(EHCI, MMIOBase);
1122 GEN_CHECK_OFF(EHCI, SofTime);
1123 GEN_CHECK_OFF(EHCI, RootHub);
1124 GEN_CHECK_OFF(EHCI, cap_length);
1125 GEN_CHECK_OFF(EHCI, hci_version);
1126 GEN_CHECK_OFF(EHCI, hcs_params);
1127 GEN_CHECK_OFF(EHCI, hcc_params);
1128 GEN_CHECK_OFF(EHCI, cmd);
1129 GEN_CHECK_OFF(EHCI, intr_status);
1130 GEN_CHECK_OFF(EHCI, intr);
1131 GEN_CHECK_OFF(EHCI, frame_idx);
1132 GEN_CHECK_OFF(EHCI, ds_segment);
1133 GEN_CHECK_OFF(EHCI, periodic_list_base);
1134 GEN_CHECK_OFF(EHCI, async_list_base);
1135 GEN_CHECK_OFF(EHCI, config);
1136 GEN_CHECK_OFF(EHCI, uIrqInterval);
1137 GEN_CHECK_OFF(EHCI, HcFmNumber);
1138 GEN_CHECK_OFF(EHCI, uFramesPerTimerCall);
1139 GEN_CHECK_OFF(EHCI, cTicksPerFrame);
1140 GEN_CHECK_OFF(EHCI, cTicksPerUsbTick);
1141 GEN_CHECK_OFF(EHCI, cInFlight);
1142 GEN_CHECK_OFF(EHCI, aInFlight);
1143 GEN_CHECK_OFF(EHCI, aInFlight[0].GCPhysTD);
1144 GEN_CHECK_OFF(EHCI, aInFlight[0].pUrb);
1145 GEN_CHECK_OFF(EHCI, aInFlight[1]);
1146 GEN_CHECK_OFF(EHCI, aInFlight[256]);
1147 GEN_CHECK_OFF(EHCI, pLoad);
1148 GEN_CHECK_OFF(EHCI, fAsyncTraversalTimerActive);
1149# ifdef VBOX_WITH_STATISTICS
1150 GEN_CHECK_OFF(EHCI, StatCanceledIsocUrbs);
1151 GEN_CHECK_OFF(EHCI, StatCanceledGenUrbs);
1152 GEN_CHECK_OFF(EHCI, StatDroppedUrbs);
1153# endif
1154 GEN_CHECK_OFF(EHCI, u64TimerHz);
1155 GEN_CHECK_OFF(EHCI, cIdleCycles);
1156 GEN_CHECK_OFF(EHCI, uFrameRate);
1157 GEN_CHECK_OFF(EHCI, fIdle);
1158 GEN_CHECK_OFF(EHCI, hThreadFrame);
1159 GEN_CHECK_OFF(EHCI, hSemEventFrame);
1160 GEN_CHECK_OFF(EHCI, fBusStarted);
1161 GEN_CHECK_OFF(EHCI, CsIrq);
1162 GEN_CHECK_OFF(EHCI, uFrameRateDefault);
1163 GEN_CHECK_OFF(EHCI, nsWait);
1164 GEN_CHECK_OFF(EHCI, CritSect);
1165# endif /* VBOX_WITH_EHCI_IMPL */
1166
1167# ifdef VBOX_WITH_XHCI_IMPL
1168 /* USB/DevXHCI.cpp */
1169 GEN_CHECK_SIZE(XHCIHUBPORT);
1170 GEN_CHECK_OFF(XHCIHUBPORT, portsc);
1171 GEN_CHECK_OFF(XHCIHUBPORT, portpm);
1172 GEN_CHECK_OFF(XHCIHUBPORT, portli);
1173 GEN_CHECK_OFF(XHCIHUBPORT, pDev);
1174
1175 GEN_CHECK_SIZE(XHCIROOTHUB);
1176 GEN_CHECK_OFF(XHCIROOTHUB, pIBase);
1177 GEN_CHECK_OFF(XHCIROOTHUB, pIRhConn);
1178 GEN_CHECK_OFF(XHCIROOTHUB, pIDev);
1179 GEN_CHECK_OFF(XHCIROOTHUB, IBase);
1180 GEN_CHECK_OFF(XHCIROOTHUB, IRhPort);
1181 GEN_CHECK_OFF(XHCIROOTHUB, Led);
1182 GEN_CHECK_OFF(XHCIROOTHUB, cPortsImpl);
1183 GEN_CHECK_OFF(XHCIROOTHUB, pXhci);
1184
1185 GEN_CHECK_SIZE(XHCIINTRPTR);
1186 GEN_CHECK_OFF(XHCIINTRPTR, iman);
1187 GEN_CHECK_OFF(XHCIINTRPTR, imod);
1188 GEN_CHECK_OFF(XHCIINTRPTR, erstba);
1189 GEN_CHECK_OFF(XHCIINTRPTR, erdp);
1190 GEN_CHECK_OFF(XHCIINTRPTR, erep);
1191 GEN_CHECK_OFF(XHCIINTRPTR, erst_idx);
1192 GEN_CHECK_OFF(XHCIINTRPTR, trb_count);
1193 GEN_CHECK_OFF(XHCIINTRPTR, evtr_pcs);
1194 GEN_CHECK_OFF(XHCIINTRPTR, ipe);
1195
1196 GEN_CHECK_SIZE(XHCI);
1197 GEN_CHECK_OFF(XHCI, PciDev);
1198 GEN_CHECK_OFF(XHCI, pDevInsR3);
1199 GEN_CHECK_OFF(XHCI, pDevInsR0);
1200 GEN_CHECK_OFF(XHCI, pDevInsRC);
1201 GEN_CHECK_OFF(XHCI, pNotifierQueueR3);
1202 GEN_CHECK_OFF(XHCI, pNotifierQueueR0);
1203 GEN_CHECK_OFF(XHCI, pNotifierQueueRC);
1204 GEN_CHECK_OFF(XHCI, pWrapTimerR3);
1205 GEN_CHECK_OFF(XHCI, pWrapTimerR0);
1206 GEN_CHECK_OFF(XHCI, pWrapTimerRC);
1207 GEN_CHECK_OFF(XHCI, pWorkerThread);
1208 GEN_CHECK_OFF(XHCI, pSupDrvSession);
1209 GEN_CHECK_OFF(XHCI, hEvtProcess);
1210 GEN_CHECK_OFF(XHCI, fWrkThreadSleeping);
1211 GEN_CHECK_OFF(XHCI, u32TasksNew);
1212 GEN_CHECK_OFF(XHCI, ILeds);
1213 GEN_CHECK_OFF(XHCI, pLedsConnector);
1214 GEN_CHECK_OFF(XHCI, MMIOBase);
1215 GEN_CHECK_OFF(XHCI, RootHub2);
1216 GEN_CHECK_OFF(XHCI, RootHub3);
1217 GEN_CHECK_OFF(XHCI, aPorts);
1218 GEN_CHECK_OFF(XHCI, aPorts[1]);
1219 GEN_CHECK_OFF(XHCI, aPorts[XHCI_NDP_MAX - 1]);
1220 GEN_CHECK_OFF(XHCI, cap_length);
1221 GEN_CHECK_OFF(XHCI, hci_version);
1222 GEN_CHECK_OFF(XHCI, hcs_params3);
1223 GEN_CHECK_OFF(XHCI, hcc_params);
1224 GEN_CHECK_OFF(XHCI, dbell_off);
1225 GEN_CHECK_OFF(XHCI, rts_off);
1226 GEN_CHECK_OFF(XHCI, cmd);
1227 GEN_CHECK_OFF(XHCI, status);
1228 GEN_CHECK_OFF(XHCI, dnctrl);
1229 GEN_CHECK_OFF(XHCI, config);
1230 GEN_CHECK_OFF(XHCI, crcr);
1231 GEN_CHECK_OFF(XHCI, dcbaap);
1232 GEN_CHECK_OFF(XHCI, abExtCap);
1233 GEN_CHECK_OFF(XHCI, cbExtCap);
1234 GEN_CHECK_OFF(XHCI, cmdr_dqp);
1235 GEN_CHECK_OFF(XHCI, cmdr_ccs);
1236 GEN_CHECK_OFF(XHCI, aSlotState);
1237 GEN_CHECK_OFF(XHCI, aBellsRung);
1238 GEN_CHECK_OFF(XHCI, pLoad);
1239# ifdef VBOX_WITH_STATISTICS
1240 GEN_CHECK_OFF(XHCI, StatErrorIsocUrbs);
1241 GEN_CHECK_OFF(XHCI, StatErrorIsocPkts);
1242 GEN_CHECK_OFF(XHCI, StatEventsWritten);
1243 GEN_CHECK_OFF(XHCI, StatEventsDropped);
1244 GEN_CHECK_OFF(XHCI, StatIntrsPending);
1245 GEN_CHECK_OFF(XHCI, StatIntrsSet);
1246 GEN_CHECK_OFF(XHCI, StatIntrsNotSet);
1247 GEN_CHECK_OFF(XHCI, StatIntrsCleared);
1248# endif
1249# endif /* VBOX_WITH_XHCI_IMPL */
1250#endif /* VBOX_WITH_USB */
1251
1252 /* VMMDev/VBoxDev.cpp */
1253
1254 /* Parallel/DevParallel.cpp */
1255 GEN_CHECK_SIZE(PARALLELPORT);
1256 GEN_CHECK_OFF(PARALLELPORT, pDevInsR3);
1257 GEN_CHECK_OFF(PARALLELPORT, pDevInsR0);
1258 GEN_CHECK_OFF(PARALLELPORT, pDevInsRC);
1259 GEN_CHECK_OFF(PARALLELPORT, IBase);
1260 GEN_CHECK_OFF(PARALLELPORT, IHostParallelPort);
1261 GEN_CHECK_OFF(PARALLELPORT, pDrvHostParallelConnector);
1262 GEN_CHECK_OFF(PARALLELPORT, fGCEnabled);
1263 GEN_CHECK_OFF(PARALLELPORT, fR0Enabled);
1264 GEN_CHECK_OFF(PARALLELPORT, fEppTimeout);
1265 GEN_CHECK_OFF(PARALLELPORT, IOBase);
1266 GEN_CHECK_OFF(PARALLELPORT, iIrq);
1267 GEN_CHECK_OFF(PARALLELPORT, regData);
1268 GEN_CHECK_OFF(PARALLELPORT, regStatus);
1269 GEN_CHECK_OFF(PARALLELPORT, regControl);
1270 GEN_CHECK_OFF(PARALLELPORT, regEppAddr);
1271 GEN_CHECK_OFF(PARALLELPORT, regEppData);
1272#if 0
1273 GEN_CHECK_OFF(PARALLELPORT, reg_ecp_ecr);
1274 GEN_CHECK_OFF(PARALLELPORT, reg_ecp_base_plus_400h);
1275 GEN_CHECK_OFF(PARALLELPORT, reg_ecp_config_b);
1276 GEN_CHECK_OFF(PARALLELPORT, ecp_fifo);
1277 GEN_CHECK_OFF(PARALLELPORT, ecp_fifo[1]);
1278 GEN_CHECK_OFF(PARALLELPORT, act_fifo_pos_write);
1279 GEN_CHECK_OFF(PARALLELPORT, act_fifo_pos_read);
1280#endif
1281
1282#ifndef VBOX_WITH_NEW_SERIAL
1283 /* Serial/DevSerial.cpp */
1284 GEN_CHECK_SIZE(SerialState);
1285 GEN_CHECK_OFF(SerialState, CritSect);
1286 GEN_CHECK_OFF(SerialState, pDevInsR3);
1287 GEN_CHECK_OFF(SerialState, pDevInsR0);
1288 GEN_CHECK_OFF(SerialState, pDevInsRC);
1289 GEN_CHECK_OFF(SerialState, IBase);
1290 GEN_CHECK_OFF(SerialState, ICharPort);
1291 GEN_CHECK_OFF(SerialState, pDrvBase);
1292 GEN_CHECK_OFF(SerialState, pDrvChar);
1293 GEN_CHECK_OFF(SerialState, ReceiveSem);
1294 GEN_CHECK_OFF(SerialState, base);
1295 GEN_CHECK_OFF(SerialState, divider);
1296 GEN_CHECK_OFF(SerialState, recv_fifo);
1297 GEN_CHECK_OFF(SerialState, xmit_fifo);
1298 GEN_CHECK_OFF(SerialState, rbr);
1299 GEN_CHECK_OFF(SerialState, thr);
1300 GEN_CHECK_OFF(SerialState, tsr);
1301 GEN_CHECK_OFF(SerialState, ier);
1302 GEN_CHECK_OFF(SerialState, iir);
1303 GEN_CHECK_OFF(SerialState, lcr);
1304 GEN_CHECK_OFF(SerialState, mcr);
1305 GEN_CHECK_OFF(SerialState, lsr);
1306 GEN_CHECK_OFF(SerialState, msr);
1307 GEN_CHECK_OFF(SerialState, scr);
1308 GEN_CHECK_OFF(SerialState, fcr);
1309 GEN_CHECK_OFF(SerialState, fcr_vmstate);
1310 GEN_CHECK_OFF(SerialState, thr_ipending);
1311 GEN_CHECK_OFF(SerialState, timeout_ipending);
1312 GEN_CHECK_OFF(SerialState, irq);
1313 GEN_CHECK_OFF(SerialState, last_break_enable);
1314 GEN_CHECK_OFF(SerialState, tsr_retry);
1315 GEN_CHECK_OFF(SerialState, msr_changed);
1316 GEN_CHECK_OFF(SerialState, fGCEnabled);
1317 GEN_CHECK_OFF(SerialState, fR0Enabled);
1318 GEN_CHECK_OFF(SerialState, fYieldOnLSRRead);
1319 GEN_CHECK_OFF(SerialState, char_transmit_time);
1320#else
1321 /* Serial/UartCore.cpp */
1322 GEN_CHECK_SIZE(UARTCORE);
1323 GEN_CHECK_OFF(UARTCORE, CritSect);
1324 GEN_CHECK_OFF(UARTCORE, pDevInsR3);
1325 GEN_CHECK_OFF(UARTCORE, pDevInsR0);
1326 GEN_CHECK_OFF(UARTCORE, pDevInsRC);
1327 GEN_CHECK_OFF(UARTCORE, iLUN);
1328 GEN_CHECK_OFF(UARTCORE, IBase);
1329 GEN_CHECK_OFF(UARTCORE, ISerialPort);
1330 GEN_CHECK_OFF(UARTCORE, pDrvBase);
1331 GEN_CHECK_OFF(UARTCORE, pDrvSerial);
1332 GEN_CHECK_OFF(UARTCORE, fFlags);
1333 GEN_CHECK_OFF(UARTCORE, enmType);
1334 GEN_CHECK_OFF(UARTCORE, pfnUartIrqReqR3);
1335 GEN_CHECK_OFF(UARTCORE, pfnUartIrqReqR0);
1336 GEN_CHECK_OFF(UARTCORE, pfnUartIrqReqRC);
1337 GEN_CHECK_OFF(UARTCORE, uRegDivisor);
1338 GEN_CHECK_OFF(UARTCORE, uRegRbr);
1339 GEN_CHECK_OFF(UARTCORE, uRegThr);
1340 GEN_CHECK_OFF(UARTCORE, uRegIer);
1341 GEN_CHECK_OFF(UARTCORE, uRegIir);
1342 GEN_CHECK_OFF(UARTCORE, uRegFcr);
1343 GEN_CHECK_OFF(UARTCORE, uRegLcr);
1344 GEN_CHECK_OFF(UARTCORE, uRegMcr);
1345 GEN_CHECK_OFF(UARTCORE, uRegLsr);
1346 GEN_CHECK_OFF(UARTCORE, uRegMsr);
1347 GEN_CHECK_OFF(UARTCORE, uRegScr);
1348 GEN_CHECK_OFF(UARTCORE, FifoXmit);
1349 GEN_CHECK_OFF(UARTCORE, FifoRecv);
1350 GEN_CHECK_OFF(UARTCORE, cbAvailRdr);
1351
1352 /* Serial/DevSerialNew.cpp */
1353 GEN_CHECK_SIZE(DEVSERIAL);
1354 GEN_CHECK_OFF(DEVSERIAL, pDevInsR3);
1355 GEN_CHECK_OFF(DEVSERIAL, pDevInsR0);
1356 GEN_CHECK_OFF(DEVSERIAL, pDevInsRC);
1357 GEN_CHECK_OFF(DEVSERIAL, fR0Enabled);
1358 GEN_CHECK_OFF(DEVSERIAL, fRCEnabled);
1359 GEN_CHECK_OFF(DEVSERIAL, uIrq);
1360 GEN_CHECK_OFF(DEVSERIAL, PortBase);
1361 GEN_CHECK_OFF(DEVSERIAL, UartCore);
1362
1363 /* Serial/DevOxPcie958.cpp */
1364 GEN_CHECK_SIZE(DEVOX958);
1365 GEN_CHECK_OFF(DEVOX958, PciDev);
1366 GEN_CHECK_OFF(DEVOX958, pDevInsR3);
1367 GEN_CHECK_OFF(DEVOX958, pDevInsR0);
1368 GEN_CHECK_OFF(DEVOX958, pDevInsRC);
1369 GEN_CHECK_OFF(DEVOX958, fR0Enabled);
1370 GEN_CHECK_OFF(DEVOX958, fRCEnabled);
1371 GEN_CHECK_OFF(DEVOX958, u32RegIrqStsGlob);
1372 GEN_CHECK_OFF(DEVOX958, u32RegIrqEnGlob);
1373 GEN_CHECK_OFF(DEVOX958, u32RegIrqEnWake);
1374 GEN_CHECK_OFF(DEVOX958, cUarts);
1375 GEN_CHECK_OFF(DEVOX958, GCPhysMMIO);
1376 GEN_CHECK_OFF(DEVOX958, aUarts);
1377 GEN_CHECK_OFF(DEVOX958, aUarts[OX958_UARTS_MAX - 1]);
1378#endif
1379
1380#ifdef VBOX_WITH_AHCI
1381 /* Storage/DevAHCI.cpp */
1382
1383 GEN_CHECK_SIZE(AHCIPort);
1384 GEN_CHECK_OFF(AHCIPort, pDevInsR3);
1385 GEN_CHECK_OFF(AHCIPort, pDevInsR0);
1386 GEN_CHECK_OFF(AHCIPort, pDevInsRC);
1387 GEN_CHECK_OFF(AHCIPort, pAhciR3);
1388 GEN_CHECK_OFF(AHCIPort, pAhciR0);
1389 GEN_CHECK_OFF(AHCIPort, pAhciRC);
1390 GEN_CHECK_OFF(AHCIPort, regCLB);
1391 GEN_CHECK_OFF(AHCIPort, regCLBU);
1392 GEN_CHECK_OFF(AHCIPort, regFB);
1393 GEN_CHECK_OFF(AHCIPort, regFBU);
1394 GEN_CHECK_OFF(AHCIPort, regIS);
1395 GEN_CHECK_OFF(AHCIPort, regIE);
1396 GEN_CHECK_OFF(AHCIPort, regCMD);
1397 GEN_CHECK_OFF(AHCIPort, regTFD);
1398 GEN_CHECK_OFF(AHCIPort, regSIG);
1399 GEN_CHECK_OFF(AHCIPort, regSSTS);
1400 GEN_CHECK_OFF(AHCIPort, regSCTL);
1401 GEN_CHECK_OFF(AHCIPort, regSERR);
1402 GEN_CHECK_OFF(AHCIPort, regSACT);
1403 GEN_CHECK_OFF(AHCIPort, regCI);
1404 GEN_CHECK_OFF(AHCIPort, cTasksActive);
1405 GEN_CHECK_OFF(AHCIPort, GCPhysAddrClb);
1406 GEN_CHECK_OFF(AHCIPort, GCPhysAddrFb);
1407 GEN_CHECK_OFF(AHCIPort, fPoweredOn);
1408 GEN_CHECK_OFF(AHCIPort, fSpunUp);
1409 GEN_CHECK_OFF(AHCIPort, fFirstD2HFisSent);
1410 GEN_CHECK_OFF(AHCIPort, fATAPI);
1411 GEN_CHECK_OFF(AHCIPort, fPortReset);
1412 GEN_CHECK_OFF(AHCIPort, fTrimEnabled);
1413 GEN_CHECK_OFF(AHCIPort, fResetDevice);
1414 GEN_CHECK_OFF(AHCIPort, fHotpluggable);
1415 GEN_CHECK_OFF(AHCIPort, fRedo);
1416 GEN_CHECK_OFF(AHCIPort, fWrkThreadSleeping);
1417 GEN_CHECK_OFF(AHCIPort, cTotalSectors);
1418 GEN_CHECK_OFF(AHCIPort, cbSector);
1419 GEN_CHECK_OFF(AHCIPort, cMultSectors);
1420 GEN_CHECK_OFF(AHCIPort, uATATransferMode);
1421 GEN_CHECK_OFF(AHCIPort, abATAPISense);
1422 GEN_CHECK_OFF(AHCIPort, cLogSectorsPerPhysicalExp);
1423 GEN_CHECK_OFF(AHCIPort, iLUN);
1424 GEN_CHECK_OFF(AHCIPort, u32TasksFinished);
1425 GEN_CHECK_OFF(AHCIPort, u32QueuedTasksFinished);
1426 GEN_CHECK_OFF(AHCIPort, u32TasksNew);
1427 GEN_CHECK_OFF(AHCIPort, u32TasksRedo);
1428 GEN_CHECK_OFF(AHCIPort, u32CurrentCommandSlot);
1429 GEN_CHECK_OFF(AHCIPort, pDrvBase);
1430 GEN_CHECK_OFF(AHCIPort, pDrvMedia);
1431 GEN_CHECK_OFF(AHCIPort, pDrvMediaEx);
1432 GEN_CHECK_OFF(AHCIPort, IBase);
1433 GEN_CHECK_OFF(AHCIPort, IPort);
1434 GEN_CHECK_OFF(AHCIPort, IMediaExPort);
1435 GEN_CHECK_OFF(AHCIPort, PCHSGeometry);
1436 GEN_CHECK_OFF(AHCIPort, Led);
1437 GEN_CHECK_OFF(AHCIPort, pAsyncIOThread);
1438
1439 GEN_CHECK_OFF(AHCIPort, pTaskErr);
1440 GEN_CHECK_OFF(AHCIPort, hEvtProcess);
1441 GEN_CHECK_OFF(AHCIPort, szSerialNumber);
1442 GEN_CHECK_OFF(AHCIPort, szSerialNumber[AHCI_SERIAL_NUMBER_LENGTH]); /* One additional byte for the termination.*/
1443 GEN_CHECK_OFF(AHCIPort, szFirmwareRevision);
1444 GEN_CHECK_OFF(AHCIPort, szFirmwareRevision[AHCI_FIRMWARE_REVISION_LENGTH]); /* One additional byte for the termination.*/
1445 GEN_CHECK_OFF(AHCIPort, szModelNumber);
1446 GEN_CHECK_OFF(AHCIPort, szModelNumber[AHCI_MODEL_NUMBER_LENGTH]); /* One additional byte for the termination.*/
1447 GEN_CHECK_OFF(AHCIPort, szInquiryVendorId);
1448 GEN_CHECK_OFF(AHCIPort, szInquiryVendorId[AHCI_ATAPI_INQUIRY_VENDOR_ID_LENGTH]); /* One additional byte for the termination.*/
1449 GEN_CHECK_OFF(AHCIPort, szInquiryProductId);
1450 GEN_CHECK_OFF(AHCIPort, szInquiryProductId[AHCI_ATAPI_INQUIRY_PRODUCT_ID_LENGTH]); /* One additional byte for the termination.*/
1451 GEN_CHECK_OFF(AHCIPort, szInquiryRevision);
1452 GEN_CHECK_OFF(AHCIPort, szInquiryRevision[AHCI_ATAPI_INQUIRY_REVISION_LENGTH]); /* One additional byte for the termination.*/
1453 GEN_CHECK_OFF(AHCIPort, cErrors);
1454 GEN_CHECK_OFF(AHCIPort, fRedo);
1455
1456 GEN_CHECK_SIZE(AHCI);
1457 GEN_CHECK_OFF(AHCI, dev);
1458 GEN_CHECK_OFF(AHCI, pDevInsR3);
1459 GEN_CHECK_OFF(AHCI, pDevInsR0);
1460 GEN_CHECK_OFF(AHCI, pDevInsRC);
1461 GEN_CHECK_OFF(AHCI, IBase);
1462 GEN_CHECK_OFF(AHCI, ILeds);
1463 GEN_CHECK_OFF(AHCI, pLedsConnector);
1464 GEN_CHECK_OFF(AHCI, MMIOBase);
1465 GEN_CHECK_OFF(AHCI, regHbaCap);
1466 GEN_CHECK_OFF(AHCI, regHbaCtrl);
1467 GEN_CHECK_OFF(AHCI, regHbaIs);
1468 GEN_CHECK_OFF(AHCI, regHbaPi);
1469 GEN_CHECK_OFF(AHCI, regHbaVs);
1470 GEN_CHECK_OFF(AHCI, regHbaCccCtl);
1471 GEN_CHECK_OFF(AHCI, regHbaCccPorts);
1472 GEN_CHECK_OFF(AHCI, regIdx);
1473 GEN_CHECK_OFF(AHCI, pHbaCccTimerR3);
1474 GEN_CHECK_OFF(AHCI, pHbaCccTimerR0);
1475 GEN_CHECK_OFF(AHCI, pHbaCccTimerRC);
1476 GEN_CHECK_OFF(AHCI, pNotifierQueueR3);
1477 GEN_CHECK_OFF(AHCI, pNotifierQueueR0);
1478 GEN_CHECK_OFF(AHCI, pNotifierQueueRC);
1479 GEN_CHECK_OFF(AHCI, uCccPortNr);
1480 GEN_CHECK_OFF(AHCI, uCccTimeout);
1481 GEN_CHECK_OFF(AHCI, uCccNr);
1482 GEN_CHECK_OFF(AHCI, uCccCurrentNr);
1483 GEN_CHECK_OFF(AHCI, ahciPort);
1484 GEN_CHECK_OFF(AHCI, ahciPort[AHCI_MAX_NR_PORTS_IMPL-1]);
1485 GEN_CHECK_OFF(AHCI, lock);
1486 GEN_CHECK_OFF(AHCI, u32PortsInterrupted);
1487 GEN_CHECK_OFF(AHCI, cThreadsActive);
1488 GEN_CHECK_OFF(AHCI, fReset);
1489 GEN_CHECK_OFF(AHCI, f64BitAddr);
1490 GEN_CHECK_OFF(AHCI, fGCEnabled);
1491 GEN_CHECK_OFF(AHCI, fR0Enabled);
1492 GEN_CHECK_OFF(AHCI, fSignalIdle);
1493 GEN_CHECK_OFF(AHCI, fBootable);
1494 GEN_CHECK_OFF(AHCI, fLegacyPortResetMethod);
1495 GEN_CHECK_OFF(AHCI, cPortsImpl);
1496 GEN_CHECK_OFF(AHCI, cCmdSlotsAvail);
1497 GEN_CHECK_OFF(AHCI, f8ByteMMIO4BytesWrittenSuccessfully);
1498 GEN_CHECK_OFF(AHCI, pSupDrvSession);
1499#endif /* VBOX_WITH_AHCI */
1500
1501#ifdef VBOX_WITH_E1000
1502 GEN_CHECK_SIZE(EEPROM93C46);
1503 GEN_CHECK_OFF(EEPROM93C46, m_eState);
1504 GEN_CHECK_OFF(EEPROM93C46, m_au16Data);
1505 GEN_CHECK_OFF(EEPROM93C46, m_fWriteEnabled);
1506 GEN_CHECK_OFF(EEPROM93C46, m_u16Word);
1507 GEN_CHECK_OFF(EEPROM93C46, m_u16Mask);
1508 GEN_CHECK_OFF(EEPROM93C46, m_u16Addr);
1509 GEN_CHECK_OFF(EEPROM93C46, m_u32InternalWires);
1510 GEN_CHECK_OFF(EEPROM93C46, m_eOp);
1511
1512 GEN_CHECK_SIZE(E1KSTATE);
1513 GEN_CHECK_OFF(E1KSTATE, IBase);
1514 GEN_CHECK_OFF(E1KSTATE, INetworkDown);
1515 GEN_CHECK_OFF(E1KSTATE, INetworkConfig);
1516 GEN_CHECK_OFF(E1KSTATE, ILeds);
1517 GEN_CHECK_OFF(E1KSTATE, pDrvBase);
1518 GEN_CHECK_OFF(E1KSTATE, pDrvR3);
1519 GEN_CHECK_OFF(E1KSTATE, pDrvR0);
1520 GEN_CHECK_OFF(E1KSTATE, pDrvRC);
1521 GEN_CHECK_OFF(E1KSTATE, pLedsConnector);
1522 GEN_CHECK_OFF(E1KSTATE, pDevInsR3);
1523 GEN_CHECK_OFF(E1KSTATE, pDevInsR0);
1524 GEN_CHECK_OFF(E1KSTATE, pDevInsRC);
1525 GEN_CHECK_OFF(E1KSTATE, pTxQueueR3);
1526 GEN_CHECK_OFF(E1KSTATE, pTxQueueR0);
1527 GEN_CHECK_OFF(E1KSTATE, pTxQueueRC);
1528 GEN_CHECK_OFF(E1KSTATE, pCanRxQueueR3);
1529 GEN_CHECK_OFF(E1KSTATE, pCanRxQueueR0);
1530 GEN_CHECK_OFF(E1KSTATE, pCanRxQueueRC);
1531 GEN_CHECK_OFF(E1KSTATE, pRIDTimerR3);
1532 GEN_CHECK_OFF(E1KSTATE, pRIDTimerR0);
1533 GEN_CHECK_OFF(E1KSTATE, pRIDTimerRC);
1534 GEN_CHECK_OFF(E1KSTATE, pRADTimerR3);
1535 GEN_CHECK_OFF(E1KSTATE, pRADTimerR0);
1536 GEN_CHECK_OFF(E1KSTATE, pRADTimerRC);
1537 GEN_CHECK_OFF(E1KSTATE, pTIDTimerR3);
1538 GEN_CHECK_OFF(E1KSTATE, pTIDTimerR0);
1539 GEN_CHECK_OFF(E1KSTATE, pTIDTimerRC);
1540 GEN_CHECK_OFF(E1KSTATE, pTADTimerR3);
1541 GEN_CHECK_OFF(E1KSTATE, pTADTimerR0);
1542 GEN_CHECK_OFF(E1KSTATE, pTADTimerRC);
1543 GEN_CHECK_OFF(E1KSTATE, pIntTimerR3);
1544 GEN_CHECK_OFF(E1KSTATE, pIntTimerR0);
1545 GEN_CHECK_OFF(E1KSTATE, pIntTimerRC);
1546 GEN_CHECK_OFF(E1KSTATE, pLUTimerR3);
1547 GEN_CHECK_OFF(E1KSTATE, pLUTimerR0);
1548 GEN_CHECK_OFF(E1KSTATE, pLUTimerRC);
1549 GEN_CHECK_OFF(E1KSTATE, cs);
1550# ifndef E1K_GLOBAL_MUTEX
1551 GEN_CHECK_OFF(E1KSTATE, csRx);
1552# endif
1553 GEN_CHECK_OFF(E1KSTATE, addrMMReg);
1554 GEN_CHECK_OFF(E1KSTATE, macConfigured);
1555 GEN_CHECK_OFF(E1KSTATE, IOPortBase);
1556 GEN_CHECK_OFF(E1KSTATE, pciDevice);
1557 GEN_CHECK_OFF(E1KSTATE, u64AckedAt);
1558 GEN_CHECK_OFF(E1KSTATE, fIntRaised);
1559 GEN_CHECK_OFF(E1KSTATE, fCableConnected);
1560 GEN_CHECK_OFF(E1KSTATE, fR0Enabled);
1561 GEN_CHECK_OFF(E1KSTATE, fRCEnabled);
1562 GEN_CHECK_OFF(E1KSTATE, auRegs[E1K_NUM_OF_32BIT_REGS]);
1563 GEN_CHECK_OFF(E1KSTATE, led);
1564 GEN_CHECK_OFF(E1KSTATE, u32PktNo);
1565 GEN_CHECK_OFF(E1KSTATE, uSelectedReg);
1566 GEN_CHECK_OFF(E1KSTATE, auMTA[128]);
1567 GEN_CHECK_OFF(E1KSTATE, aRecAddr);
1568 GEN_CHECK_OFF(E1KSTATE, auVFTA[128]);
1569 GEN_CHECK_OFF(E1KSTATE, u16RxBSize);
1570 GEN_CHECK_OFF(E1KSTATE, fLocked);
1571 GEN_CHECK_OFF(E1KSTATE, fDelayInts);
1572 GEN_CHECK_OFF(E1KSTATE, fIntMaskUsed);
1573 GEN_CHECK_OFF(E1KSTATE, fMaybeOutOfSpace);
1574 GEN_CHECK_OFF(E1KSTATE, hEventMoreRxDescAvail);
1575 GEN_CHECK_OFF(E1KSTATE, contextTSE);
1576 GEN_CHECK_OFF(E1KSTATE, contextNormal);
1577# ifdef E1K_WITH_TXD_CACHE
1578 GEN_CHECK_OFF(E1KSTATE, aTxDescriptors);
1579 GEN_CHECK_OFF(E1KSTATE, nTxDFetched);
1580 GEN_CHECK_OFF(E1KSTATE, iTxDCurrent);
1581 GEN_CHECK_OFF(E1KSTATE, fGSO);
1582 GEN_CHECK_OFF(E1KSTATE, cbTxAlloc);
1583# endif
1584 GEN_CHECK_OFF(E1KSTATE, GsoCtx);
1585 GEN_CHECK_OFF(E1KSTATE, uTxFallback);
1586 GEN_CHECK_OFF(E1KSTATE, fVTag);
1587 GEN_CHECK_OFF(E1KSTATE, u16VTagTCI);
1588 GEN_CHECK_OFF(E1KSTATE, aTxPacketFallback[E1K_MAX_TX_PKT_SIZE]);
1589 GEN_CHECK_OFF(E1KSTATE, u16TxPktLen);
1590 GEN_CHECK_OFF(E1KSTATE, fIPcsum);
1591 GEN_CHECK_OFF(E1KSTATE, fTCPcsum);
1592 GEN_CHECK_OFF(E1KSTATE, u32PayRemain);
1593 GEN_CHECK_OFF(E1KSTATE, u16HdrRemain);
1594 GEN_CHECK_OFF(E1KSTATE, u16SavedFlags);
1595 GEN_CHECK_OFF(E1KSTATE, u32SavedCsum);
1596 GEN_CHECK_OFF(E1KSTATE, eeprom);
1597 GEN_CHECK_OFF(E1KSTATE, phy);
1598 GEN_CHECK_OFF(E1KSTATE, StatReceiveBytes);
1599#endif /* VBOX_WITH_E1000 */
1600
1601#ifdef VBOX_WITH_VIRTIO
1602 GEN_CHECK_OFF(VPCISTATE, cs);
1603 GEN_CHECK_OFF(VPCISTATE, szInstance);
1604 GEN_CHECK_OFF(VPCISTATE, IBase);
1605 GEN_CHECK_OFF(VPCISTATE, ILeds);
1606 GEN_CHECK_OFF(VPCISTATE, pLedsConnector);
1607 GEN_CHECK_OFF(VPCISTATE, pDevInsR3);
1608 GEN_CHECK_OFF(VPCISTATE, pDevInsR0);
1609 GEN_CHECK_OFF(VPCISTATE, pDevInsRC);
1610 GEN_CHECK_OFF(VPCISTATE, pciDevice);
1611 GEN_CHECK_OFF(VPCISTATE, IOPortBase);
1612 GEN_CHECK_OFF(VPCISTATE, led);
1613 GEN_CHECK_OFF(VPCISTATE, uGuestFeatures);
1614 GEN_CHECK_OFF(VPCISTATE, uQueueSelector);
1615 GEN_CHECK_OFF(VPCISTATE, uStatus);
1616 GEN_CHECK_OFF(VPCISTATE, uISR);
1617 GEN_CHECK_OFF(VPCISTATE, Queues);
1618 GEN_CHECK_OFF(VPCISTATE, Queues[VIRTIO_MAX_NQUEUES]);
1619 GEN_CHECK_OFF(VNETSTATE, VPCI);
1620 GEN_CHECK_OFF(VNETSTATE, INetworkDown);
1621 GEN_CHECK_OFF(VNETSTATE, INetworkConfig);
1622 GEN_CHECK_OFF(VNETSTATE, pDrvBase);
1623 GEN_CHECK_OFF(VNETSTATE, pCanRxQueueR3);
1624 GEN_CHECK_OFF(VNETSTATE, pCanRxQueueR0);
1625 GEN_CHECK_OFF(VNETSTATE, pCanRxQueueRC);
1626 GEN_CHECK_OFF(VNETSTATE, pLinkUpTimer);
1627# ifdef VNET_TX_DELAY
1628 GEN_CHECK_OFF(VNETSTATE, pTxTimerR3);
1629 GEN_CHECK_OFF(VNETSTATE, pTxTimerR0);
1630 GEN_CHECK_OFF(VNETSTATE, pTxTimerRC);
1631# endif /* VNET_TX_DELAY */
1632 GEN_CHECK_OFF(VNETSTATE, config);
1633 GEN_CHECK_OFF(VNETSTATE, macConfigured);
1634 GEN_CHECK_OFF(VNETSTATE, fCableConnected);
1635 GEN_CHECK_OFF(VNETSTATE, u32PktNo);
1636 GEN_CHECK_OFF(VNETSTATE, fPromiscuous);
1637 GEN_CHECK_OFF(VNETSTATE, fAllMulti);
1638 GEN_CHECK_OFF(VNETSTATE, pRxQueue);
1639 GEN_CHECK_OFF(VNETSTATE, pTxQueue);
1640 GEN_CHECK_OFF(VNETSTATE, pCtlQueue);
1641 GEN_CHECK_OFF(VNETSTATE, fMaybeOutOfSpace);
1642 GEN_CHECK_OFF(VNETSTATE, hEventMoreRxDescAvail);
1643#endif /* VBOX_WITH_VIRTIO */
1644
1645#ifdef VBOX_WITH_SCSI
1646 GEN_CHECK_SIZE(VBOXSCSI);
1647 GEN_CHECK_OFF(VBOXSCSI, regIdentify);
1648 GEN_CHECK_OFF(VBOXSCSI, uTargetDevice);
1649 GEN_CHECK_OFF(VBOXSCSI, uTxDir);
1650 GEN_CHECK_OFF(VBOXSCSI, cbCDB);
1651 GEN_CHECK_OFF(VBOXSCSI, abCDB);
1652 GEN_CHECK_OFF(VBOXSCSI, abCDB[11]);
1653 GEN_CHECK_OFF(VBOXSCSI, iCDB);
1654 GEN_CHECK_OFF(VBOXSCSI, pbBuf);
1655 GEN_CHECK_OFF(VBOXSCSI, cbBuf);
1656 GEN_CHECK_OFF(VBOXSCSI, iBuf);
1657 GEN_CHECK_OFF(VBOXSCSI, fBusy);
1658 GEN_CHECK_OFF(VBOXSCSI, enmState);
1659#endif
1660
1661 /* VMMDev*.cpp/h */
1662 GEN_CHECK_SIZE(VMMDEV);
1663 GEN_CHECK_OFF(VMMDEV, PciDev);
1664 GEN_CHECK_OFF(VMMDEV, CritSect);
1665 GEN_CHECK_OFF(VMMDEV, hypervisorSize);
1666 GEN_CHECK_OFF(VMMDEV, mouseCapabilities);
1667 GEN_CHECK_OFF(VMMDEV, mouseXAbs);
1668 GEN_CHECK_OFF(VMMDEV, mouseYAbs);
1669 GEN_CHECK_OFF(VMMDEV, fHostCursorRequested);
1670 GEN_CHECK_OFF(VMMDEV, pDevIns);
1671 GEN_CHECK_OFF(VMMDEV, IBase);
1672 GEN_CHECK_OFF(VMMDEV, IPort);
1673#ifdef VBOX_WITH_HGCM
1674 GEN_CHECK_OFF(VMMDEV, IHGCMPort);
1675#endif
1676 GEN_CHECK_OFF(VMMDEV, pDrvBase);
1677 GEN_CHECK_OFF(VMMDEV, pDrv);
1678#ifdef VBOX_WITH_HGCM
1679 GEN_CHECK_OFF(VMMDEV, pHGCMDrv);
1680#endif
1681 GEN_CHECK_OFF(VMMDEV, szMsg);
1682 GEN_CHECK_OFF(VMMDEV, iMsg);
1683 GEN_CHECK_OFF(VMMDEV, irq);
1684 GEN_CHECK_OFF(VMMDEV, u32HostEventFlags);
1685 GEN_CHECK_OFF(VMMDEV, u32GuestFilterMask);
1686 GEN_CHECK_OFF(VMMDEV, u32NewGuestFilterMask);
1687 GEN_CHECK_OFF(VMMDEV, fNewGuestFilterMask);
1688 GEN_CHECK_OFF(VMMDEV, GCPhysVMMDevRAM);
1689 GEN_CHECK_OFF(VMMDEV, pVMMDevRAMR3);
1690 GEN_CHECK_OFF(VMMDEV, pVMMDevHeapR3);
1691 GEN_CHECK_OFF(VMMDEV, GCPhysVMMDevHeap);
1692 GEN_CHECK_OFF(VMMDEV, guestInfo);
1693 GEN_CHECK_OFF(VMMDEV, guestCaps);
1694 GEN_CHECK_OFF(VMMDEV, fu32AdditionsOk);
1695 GEN_CHECK_OFF(VMMDEV, u32VideoAccelEnabled);
1696 GEN_CHECK_OFF(VMMDEV, displayChangeData);
1697 GEN_CHECK_OFF(VMMDEV, pCredentials);
1698 GEN_CHECK_OFF(VMMDEV, cMbMemoryBalloon);
1699 GEN_CHECK_OFF(VMMDEV, cMbMemoryBalloonLast);
1700 GEN_CHECK_OFF(VMMDEV, cbGuestRAM);
1701 GEN_CHECK_OFF(VMMDEV, idSession);
1702 GEN_CHECK_OFF(VMMDEV, u32StatIntervalSize);
1703 GEN_CHECK_OFF(VMMDEV, u32LastStatIntervalSize);
1704 GEN_CHECK_OFF(VMMDEV, fLastSeamlessEnabled),
1705 GEN_CHECK_OFF(VMMDEV, fSeamlessEnabled);
1706 GEN_CHECK_OFF(VMMDEV, fVRDPEnabled);
1707 GEN_CHECK_OFF(VMMDEV, uVRDPExperienceLevel);
1708#ifdef VMMDEV_WITH_ALT_TIMESYNC
1709 GEN_CHECK_OFF(VMMDEV, hostTime);
1710 GEN_CHECK_OFF(VMMDEV, fTimesyncBackdoorLo);
1711#endif
1712 GEN_CHECK_OFF(VMMDEV, fGetHostTimeDisabled);
1713 GEN_CHECK_OFF(VMMDEV, fBackdoorLogDisabled);
1714 GEN_CHECK_OFF(VMMDEV, fKeepCredentials);
1715 GEN_CHECK_OFF(VMMDEV, fHeapEnabled);
1716#ifdef VBOX_WITH_HGCM
1717 GEN_CHECK_OFF(VMMDEV, listHGCMCmd);
1718 GEN_CHECK_OFF(VMMDEV, critsectHGCMCmdList);
1719 GEN_CHECK_OFF(VMMDEV, u32HGCMEnabled);
1720#endif
1721 GEN_CHECK_OFF(VMMDEV, SharedFolders);
1722 GEN_CHECK_OFF(VMMDEV, SharedFolders.Led);
1723 GEN_CHECK_OFF(VMMDEV, SharedFolders.ILeds);
1724 GEN_CHECK_OFF(VMMDEV, SharedFolders.pLedsConnector);
1725 GEN_CHECK_OFF(VMMDEV, fCpuHotPlugEventsEnabled);
1726 GEN_CHECK_OFF(VMMDEV, enmCpuHotPlugEvent);
1727 GEN_CHECK_OFF(VMMDEV, idCpuCore);
1728 GEN_CHECK_OFF(VMMDEV, idCpuPackage);
1729 GEN_CHECK_OFF(VMMDEV, StatMemBalloonChunks);
1730 GEN_CHECK_OFF(VMMDEV, fRZEnabled);
1731 GEN_CHECK_OFF(VMMDEV, fTestingEnabled);
1732 GEN_CHECK_OFF(VMMDEV, fTestingMMIO);
1733 GEN_CHECK_OFF(VMMDEV, u32TestingHighTimestamp);
1734 GEN_CHECK_OFF(VMMDEV, u32TestingCmd);
1735 GEN_CHECK_OFF(VMMDEV, offTestingData);
1736 GEN_CHECK_OFF(VMMDEV, TestingData);
1737 GEN_CHECK_OFF(VMMDEV, TestingData.Value.u64Value);
1738 GEN_CHECK_OFF(VMMDEV, TestingData.Value.u32Unit);
1739 GEN_CHECK_OFF(VMMDEV, TestingData.Value.szName);
1740 GEN_CHECK_OFF(VMMDEV, nsLastHeartbeatTS);
1741 GEN_CHECK_OFF(VMMDEV, fFlatlined);
1742 GEN_CHECK_OFF(VMMDEV, fHeartbeatActive);
1743 GEN_CHECK_OFF(VMMDEV, cNsHeartbeatInterval);
1744 GEN_CHECK_OFF(VMMDEV, cNsHeartbeatTimeout);
1745 GEN_CHECK_OFF(VMMDEV, pFlatlinedTimer);
1746
1747#ifdef VBOX_WITH_BUSLOGIC
1748 GEN_CHECK_SIZE(BUSLOGICDEVICE);
1749 GEN_CHECK_OFF(BUSLOGICDEVICE, pBusLogicR3);
1750 GEN_CHECK_OFF(BUSLOGICDEVICE, pBusLogicR0);
1751 GEN_CHECK_OFF(BUSLOGICDEVICE, pBusLogicRC);
1752 GEN_CHECK_OFF(BUSLOGICDEVICE, fPresent);
1753 GEN_CHECK_OFF(BUSLOGICDEVICE, iLUN);
1754 GEN_CHECK_OFF(BUSLOGICDEVICE, IBase);
1755 GEN_CHECK_OFF(BUSLOGICDEVICE, IMediaPort);
1756 GEN_CHECK_OFF(BUSLOGICDEVICE, IMediaExPort);
1757 GEN_CHECK_OFF(BUSLOGICDEVICE, ILed);
1758 GEN_CHECK_OFF(BUSLOGICDEVICE, pDrvBase);
1759 GEN_CHECK_OFF(BUSLOGICDEVICE, pDrvMedia);
1760 GEN_CHECK_OFF(BUSLOGICDEVICE, pDrvMediaEx);
1761 GEN_CHECK_OFF(BUSLOGICDEVICE, Led);
1762 GEN_CHECK_OFF(BUSLOGICDEVICE, cOutstandingRequests);
1763
1764 GEN_CHECK_SIZE(BUSLOGIC);
1765 GEN_CHECK_OFF(BUSLOGIC, dev);
1766 GEN_CHECK_OFF(BUSLOGIC, pDevInsR3);
1767 GEN_CHECK_OFF(BUSLOGIC, pDevInsR0);
1768 GEN_CHECK_OFF(BUSLOGIC, pDevInsRC);
1769 GEN_CHECK_OFF(BUSLOGIC, IOPortBase);
1770 GEN_CHECK_OFF(BUSLOGIC, MMIOBase);
1771 GEN_CHECK_OFF(BUSLOGIC, regStatus);
1772 GEN_CHECK_OFF(BUSLOGIC, regInterrupt);
1773 GEN_CHECK_OFF(BUSLOGIC, regGeometry);
1774 GEN_CHECK_OFF(BUSLOGIC, LocalRam);
1775 GEN_CHECK_OFF(BUSLOGIC, uOperationCode);
1776 GEN_CHECK_OFF(BUSLOGIC, aCommandBuffer);
1777 GEN_CHECK_OFF(BUSLOGIC, aCommandBuffer[BUSLOGIC_COMMAND_SIZE_MAX]);
1778 GEN_CHECK_OFF(BUSLOGIC, iParameter);
1779 GEN_CHECK_OFF(BUSLOGIC, cbCommandParametersLeft);
1780 GEN_CHECK_OFF(BUSLOGIC, fUseLocalRam);
1781 GEN_CHECK_OFF(BUSLOGIC, aReplyBuffer);
1782 GEN_CHECK_OFF(BUSLOGIC, aReplyBuffer[BUSLOGIC_REPLY_SIZE_MAX]);
1783 GEN_CHECK_OFF(BUSLOGIC, iReply);
1784 GEN_CHECK_OFF(BUSLOGIC, cbReplyParametersLeft);
1785 GEN_CHECK_OFF(BUSLOGIC, fIRQEnabled);
1786 GEN_CHECK_OFF(BUSLOGIC, cMailbox);
1787 GEN_CHECK_OFF(BUSLOGIC, GCPhysAddrMailboxOutgoingBase);
1788 GEN_CHECK_OFF(BUSLOGIC, uMailboxOutgoingPositionCurrent);
1789 GEN_CHECK_OFF(BUSLOGIC, cMailboxesReady);
1790 GEN_CHECK_OFF(BUSLOGIC, fNotificationSent);
1791 GEN_CHECK_OFF(BUSLOGIC, GCPhysAddrMailboxIncomingBase);
1792 GEN_CHECK_OFF(BUSLOGIC, uMailboxIncomingPositionCurrent);
1793 GEN_CHECK_OFF(BUSLOGIC, fStrictRoundRobinMode);
1794 GEN_CHECK_OFF(BUSLOGIC, fExtendedLunCCBFormat);
1795 GEN_CHECK_OFF(BUSLOGIC, pNotifierQueueR3);
1796 GEN_CHECK_OFF(BUSLOGIC, pNotifierQueueR0);
1797 GEN_CHECK_OFF(BUSLOGIC, pNotifierQueueRC);
1798 GEN_CHECK_OFF(BUSLOGIC, CritSectIntr);
1799 GEN_CHECK_OFF(BUSLOGIC, VBoxSCSI);
1800 GEN_CHECK_OFF(BUSLOGIC, aDeviceStates);
1801 GEN_CHECK_OFF(BUSLOGIC, aDeviceStates[BUSLOGIC_MAX_DEVICES-1]);
1802 GEN_CHECK_OFF(BUSLOGIC, IBase);
1803 GEN_CHECK_OFF(BUSLOGIC, ILeds);
1804 GEN_CHECK_OFF(BUSLOGIC, pLedsConnector);
1805 GEN_CHECK_OFF(BUSLOGIC, pMediaNotify);
1806 GEN_CHECK_OFF(BUSLOGIC, fSignalIdle);
1807 GEN_CHECK_OFF(BUSLOGIC, fWrkThreadSleeping);
1808 GEN_CHECK_OFF(BUSLOGIC, fBiosReqPending);
1809 GEN_CHECK_OFF(BUSLOGIC, pSupDrvSession);
1810 GEN_CHECK_OFF(BUSLOGIC, hEvtProcess);
1811 GEN_CHECK_OFF(BUSLOGIC, paGCPhysAddrCCBRedo);
1812 GEN_CHECK_OFF(BUSLOGIC, cReqsRedo);
1813# ifdef LOG_ENABLED
1814 GEN_CHECK_OFF(BUSLOGIC, cInMailboxesReady);
1815# endif
1816#endif /* VBOX_WITH_BUSLOGIC */
1817
1818#ifdef VBOX_WITH_LSILOGIC
1819 GEN_CHECK_SIZE(LSILOGICSCSI);
1820 GEN_CHECK_OFF(LSILOGICSCSI, PciDev);
1821 GEN_CHECK_OFF(LSILOGICSCSI, pDevInsR3);
1822 GEN_CHECK_OFF(LSILOGICSCSI, pDevInsR0);
1823 GEN_CHECK_OFF(LSILOGICSCSI, pDevInsRC);
1824 GEN_CHECK_OFF(LSILOGICSCSI, fGCEnabled);
1825 GEN_CHECK_OFF(LSILOGICSCSI, fR0Enabled);
1826 GEN_CHECK_OFF(LSILOGICSCSI, enmState);
1827 GEN_CHECK_OFF(LSILOGICSCSI, enmWhoInit);
1828 GEN_CHECK_OFF(LSILOGICSCSI, enmDoorbellState);
1829 GEN_CHECK_OFF(LSILOGICSCSI, fDiagnosticEnabled);
1830 GEN_CHECK_OFF(LSILOGICSCSI, fNotificationSent);
1831 GEN_CHECK_OFF(LSILOGICSCSI, fEventNotificationEnabled);
1832 GEN_CHECK_OFF(LSILOGICSCSI, fDiagRegsEnabled);
1833 GEN_CHECK_OFF(LSILOGICSCSI, pNotificationQueueR3);
1834 GEN_CHECK_OFF(LSILOGICSCSI, pNotificationQueueR0);
1835 GEN_CHECK_OFF(LSILOGICSCSI, pNotificationQueueRC);
1836 GEN_CHECK_OFF(LSILOGICSCSI, cDeviceStates);
1837 GEN_CHECK_OFF(LSILOGICSCSI, paDeviceStates);
1838 GEN_CHECK_OFF(LSILOGICSCSI, GCPhysMMIOBase);
1839 GEN_CHECK_OFF(LSILOGICSCSI, IOPortBase);
1840 GEN_CHECK_OFF(LSILOGICSCSI, uInterruptMask);
1841 GEN_CHECK_OFF(LSILOGICSCSI, uInterruptStatus);
1842 GEN_CHECK_OFF(LSILOGICSCSI, aMessage);
1843 GEN_CHECK_OFF(LSILOGICSCSI, aMessage[sizeof(MptConfigurationRequest)-1]);
1844 GEN_CHECK_OFF(LSILOGICSCSI, iMessage);
1845 GEN_CHECK_OFF(LSILOGICSCSI, cMessage);
1846 GEN_CHECK_OFF(LSILOGICSCSI, ReplyBuffer);
1847 GEN_CHECK_OFF(LSILOGICSCSI, uNextReplyEntryRead);
1848 GEN_CHECK_OFF(LSILOGICSCSI, cReplySize);
1849 GEN_CHECK_OFF(LSILOGICSCSI, u16IOCFaultCode);
1850 GEN_CHECK_OFF(LSILOGICSCSI, u32HostMFAHighAddr);
1851 GEN_CHECK_OFF(LSILOGICSCSI, u32SenseBufferHighAddr);
1852 GEN_CHECK_OFF(LSILOGICSCSI, cMaxDevices);
1853 GEN_CHECK_OFF(LSILOGICSCSI, cMaxBuses);
1854 GEN_CHECK_OFF(LSILOGICSCSI, cbReplyFrame);
1855 GEN_CHECK_OFF(LSILOGICSCSI, iDiagnosticAccess);
1856 GEN_CHECK_OFF(LSILOGICSCSI, cReplyQueueEntries);
1857 GEN_CHECK_OFF(LSILOGICSCSI, cRequestQueueEntries);
1858 GEN_CHECK_OFF(LSILOGICSCSI, ReplyPostQueueCritSect);
1859 GEN_CHECK_OFF(LSILOGICSCSI, ReplyFreeQueueCritSect);
1860 GEN_CHECK_OFF(LSILOGICSCSI, RequestQueueCritSect);
1861 GEN_CHECK_OFF(LSILOGICSCSI, ReplyFreeQueueWriteCritSect);
1862 GEN_CHECK_OFF(LSILOGICSCSI, pReplyFreeQueueBaseR3);
1863 GEN_CHECK_OFF(LSILOGICSCSI, pReplyPostQueueBaseR3);
1864 GEN_CHECK_OFF(LSILOGICSCSI, pRequestQueueBaseR3);
1865 GEN_CHECK_OFF(LSILOGICSCSI, pReplyFreeQueueBaseR0);
1866 GEN_CHECK_OFF(LSILOGICSCSI, pReplyPostQueueBaseR0);
1867 GEN_CHECK_OFF(LSILOGICSCSI, pRequestQueueBaseR0);
1868 GEN_CHECK_OFF(LSILOGICSCSI, pReplyFreeQueueBaseRC);
1869 GEN_CHECK_OFF(LSILOGICSCSI, pReplyPostQueueBaseRC);
1870 GEN_CHECK_OFF(LSILOGICSCSI, pRequestQueueBaseRC);
1871 GEN_CHECK_OFF(LSILOGICSCSI, uReplyFreeQueueNextEntryFreeWrite);
1872 GEN_CHECK_OFF(LSILOGICSCSI, uReplyFreeQueueNextAddressRead);
1873 GEN_CHECK_OFF(LSILOGICSCSI, uReplyPostQueueNextEntryFreeWrite);
1874 GEN_CHECK_OFF(LSILOGICSCSI, uReplyPostQueueNextAddressRead);
1875 GEN_CHECK_OFF(LSILOGICSCSI, uRequestQueueNextEntryFreeWrite);
1876 GEN_CHECK_OFF(LSILOGICSCSI, uRequestQueueNextAddressRead);
1877 GEN_CHECK_OFF(LSILOGICSCSI, u16NextHandle);
1878 GEN_CHECK_OFF(LSILOGICSCSI, enmCtrlType);
1879 GEN_CHECK_OFF(LSILOGICSCSI, VBoxSCSI);
1880 GEN_CHECK_OFF(LSILOGICSCSI, IBase);
1881 GEN_CHECK_OFF(LSILOGICSCSI, ILeds);
1882 GEN_CHECK_OFF(LSILOGICSCSI, pLedsConnector);
1883 GEN_CHECK_OFF(LSILOGICSCSI, pMediaNotify);
1884 GEN_CHECK_OFF(LSILOGICSCSI, pConfigurationPages);
1885 GEN_CHECK_OFF(LSILOGICSCSI, fSignalIdle);
1886 GEN_CHECK_OFF(LSILOGICSCSI, fRedo);
1887 GEN_CHECK_OFF(LSILOGICSCSI, fWrkThreadSleeping);
1888 GEN_CHECK_OFF(LSILOGICSCSI, pTasksRedoHead);
1889 GEN_CHECK_OFF(LSILOGICSCSI, u32DiagMemAddr);
1890 GEN_CHECK_OFF(LSILOGICSCSI, cbMemRegns);
1891 GEN_CHECK_OFF(LSILOGICSCSI, ListMemRegns);
1892 GEN_CHECK_OFF(LSILOGICSCSI, pSupDrvSession);
1893 GEN_CHECK_OFF(LSILOGICSCSI, pThreadWrk);
1894 GEN_CHECK_OFF(LSILOGICSCSI, hEvtProcess);
1895#endif /* VBOX_WITH_LSILOGIC */
1896
1897 GEN_CHECK_SIZE(HPET);
1898 GEN_CHECK_OFF(HPET, pDevInsR3);
1899 GEN_CHECK_OFF(HPET, pDevInsR0);
1900 GEN_CHECK_OFF(HPET, pDevInsRC);
1901 GEN_CHECK_OFF(HPET, u64HpetOffset);
1902 GEN_CHECK_OFF(HPET, u32Capabilities);
1903 GEN_CHECK_OFF(HPET, u32Period);
1904 GEN_CHECK_OFF(HPET, u64HpetConfig);
1905 GEN_CHECK_OFF(HPET, u64Isr);
1906 GEN_CHECK_OFF(HPET, u64HpetCounter);
1907 GEN_CHECK_OFF(HPET, CritSect);
1908 GEN_CHECK_OFF(HPET, fIch9);
1909
1910 GEN_CHECK_SIZE(HPETTIMER);
1911 GEN_CHECK_OFF(HPETTIMER, pTimerR3);
1912 GEN_CHECK_OFF(HPETTIMER, pHpetR3);
1913 GEN_CHECK_OFF(HPETTIMER, pTimerR0);
1914 GEN_CHECK_OFF(HPETTIMER, pHpetR0);
1915 GEN_CHECK_OFF(HPETTIMER, pTimerRC);
1916 GEN_CHECK_OFF(HPETTIMER, pHpetRC);
1917 GEN_CHECK_OFF(HPETTIMER, idxTimer);
1918 GEN_CHECK_OFF(HPETTIMER, u64Config);
1919 GEN_CHECK_OFF(HPETTIMER, u64Cmp);
1920 GEN_CHECK_OFF(HPETTIMER, u64Fsb);
1921 GEN_CHECK_OFF(HPETTIMER, u64Period);
1922 GEN_CHECK_OFF(HPETTIMER, u8Wrap);
1923
1924 GEN_CHECK_SIZE(AC97DRIVER);
1925 GEN_CHECK_OFF(AC97DRIVER, Node);
1926 GEN_CHECK_OFF(AC97DRIVER, pAC97State);
1927 GEN_CHECK_OFF(AC97DRIVER, fFlags);
1928 GEN_CHECK_OFF(AC97DRIVER, uLUN);
1929 GEN_CHECK_OFF(AC97DRIVER, fAttached);
1930 GEN_CHECK_OFF(AC97DRIVER, pConnector);
1931 GEN_CHECK_OFF(AC97DRIVER, LineIn);
1932 GEN_CHECK_OFF(AC97DRIVER, MicIn);
1933 GEN_CHECK_OFF(AC97DRIVER, Out);
1934
1935 GEN_CHECK_SIZE(AC97STATE);
1936 GEN_CHECK_OFF(AC97STATE, CritSect);
1937 GEN_CHECK_OFF(AC97STATE, pDevInsR3);
1938 GEN_CHECK_OFF(AC97STATE, pDevInsR0);
1939 GEN_CHECK_OFF(AC97STATE, pDevInsRC);
1940 GEN_CHECK_OFF(AC97STATE, fRZEnabled);
1941 GEN_CHECK_OFF(AC97STATE, glob_cnt);
1942 GEN_CHECK_OFF(AC97STATE, glob_sta);
1943 GEN_CHECK_OFF(AC97STATE, cas);
1944 GEN_CHECK_OFF(AC97STATE, last_samp);
1945 GEN_CHECK_OFF(AC97STATE, mixer_data);
1946 GEN_CHECK_OFF(AC97STATE, StreamLineIn);
1947 GEN_CHECK_OFF(AC97STATE, StreamMicIn);
1948 GEN_CHECK_OFF(AC97STATE, StreamOut);
1949 GEN_CHECK_OFF(AC97STATE, cStreamsActive);
1950#ifndef VBOX_WITH_AUDIO_AC97_CALLBACKS
1951 GEN_CHECK_OFF(AC97STATE, pTimerR3);
1952 GEN_CHECK_OFF(AC97STATE, pTimerR0);
1953 GEN_CHECK_OFF(AC97STATE, pTimerRC);
1954 GEN_CHECK_OFF(AC97STATE, fTimerActive);
1955 GEN_CHECK_OFF(AC97STATE, u8Padding1);
1956 GEN_CHECK_OFF(AC97STATE, cTimerTicks);
1957 GEN_CHECK_OFF(AC97STATE, uTimerTS);
1958#endif
1959#ifdef VBOX_WITH_STATISTICS
1960 GEN_CHECK_OFF(AC97STATE, StatTimer);
1961 GEN_CHECK_OFF(AC97STATE, StatIn);
1962 GEN_CHECK_OFF(AC97STATE, StatOut);
1963 GEN_CHECK_OFF(AC97STATE, StatBytesRead);
1964 GEN_CHECK_OFF(AC97STATE, StatBytesWritten);
1965#endif
1966 GEN_CHECK_OFF(AC97STATE, lstDrv);
1967 GEN_CHECK_OFF(AC97STATE, pMixer);
1968 GEN_CHECK_OFF(AC97STATE, pSinkOut);
1969 GEN_CHECK_OFF(AC97STATE, pSinkLineIn);
1970 GEN_CHECK_OFF(AC97STATE, pSinkMicIn);
1971 GEN_CHECK_OFF(AC97STATE, silence);
1972 GEN_CHECK_OFF(AC97STATE, bup_flag);
1973 GEN_CHECK_OFF(AC97STATE, IBase);
1974 GEN_CHECK_OFF(AC97STATE, IOPortBase);
1975 GEN_CHECK_OFF(AC97STATE, uCodecModel);
1976
1977 GEN_CHECK_SIZE(HDADRIVERSTREAM);
1978 GEN_CHECK_OFF(HDADRIVERSTREAM, DestSource);
1979 GEN_CHECK_OFF(HDADRIVERSTREAM, pMixStrm);
1980
1981 GEN_CHECK_SIZE(HDADRIVER);
1982 GEN_CHECK_OFF(HDADRIVER, Node);
1983 GEN_CHECK_OFF(HDADRIVER, pHDAState);
1984 GEN_CHECK_OFF(HDADRIVER, fFlags);
1985 GEN_CHECK_OFF(HDADRIVER, uLUN);
1986 GEN_CHECK_OFF(HDADRIVER, fAttached);
1987 GEN_CHECK_OFF(HDADRIVER, pConnector);
1988 GEN_CHECK_OFF(HDADRIVER, LineIn);
1989#ifdef VBOX_WITH_HDA_MIC_IN
1990 GEN_CHECK_OFF(HDADRIVER, MicIn);
1991#endif
1992 GEN_CHECK_OFF(HDADRIVER, Front);
1993#ifdef VBOX_WITH_HDA_51_SURROUND
1994 GEN_CHECK_OFF(HDADRIVER, CenterLFE);
1995 GEN_CHECK_OFF(HDADRIVER, Rear);
1996#endif
1997
1998 GEN_CHECK_SIZE(HDABDLESTATE);
1999 GEN_CHECK_OFF(HDABDLESTATE, u32BDLIndex);
2000 GEN_CHECK_OFF(HDABDLESTATE, cbBelowFIFOW);
2001 GEN_CHECK_OFF(HDABDLESTATE, u32BufOff);
2002
2003 GEN_CHECK_SIZE(HDABDLEDESC);
2004 GEN_CHECK_OFF(HDABDLEDESC, u64BufAdr);
2005 GEN_CHECK_OFF(HDABDLEDESC, u32BufSize);
2006 GEN_CHECK_OFF(HDABDLEDESC, fFlags);
2007
2008 GEN_CHECK_SIZE(HDABDLE);
2009 GEN_CHECK_OFF(HDABDLE, Desc);
2010 GEN_CHECK_OFF(HDABDLE, State);
2011
2012 GEN_CHECK_SIZE(HDASTREAMSTATE);
2013 GEN_CHECK_OFF(HDASTREAMSTATE, uCurBDLE);
2014 GEN_CHECK_OFF(HDASTREAMSTATE, fInReset);
2015 GEN_CHECK_OFF(HDASTREAMSTATE, Mapping);
2016 GEN_CHECK_OFF(HDASTREAMSTATE, BDLE);
2017 GEN_CHECK_OFF(HDASTREAMSTATE, pCircBuf);
2018
2019 GEN_CHECK_SIZE(HDASTREAMDBGINFORT);
2020
2021 GEN_CHECK_SIZE(HDASTREAMDBGINFO);
2022 GEN_CHECK_OFF(HDASTREAMDBGINFO, Runtime);
2023
2024 GEN_CHECK_SIZE(HDASTREAM);
2025 GEN_CHECK_OFF(HDASTREAM, u8SD);
2026 GEN_CHECK_OFF(HDASTREAM, u64BDLBase);
2027 GEN_CHECK_OFF(HDASTREAM, u16FMT);
2028 GEN_CHECK_OFF(HDASTREAM, u16FIFOS);
2029 GEN_CHECK_OFF(HDASTREAM, u16LVI);
2030 GEN_CHECK_OFF(HDASTREAM, State);
2031 GEN_CHECK_OFF(HDASTREAM, Dbg);
2032 GEN_CHECK_OFF(HDASTREAM, CritSect);
2033
2034 GEN_CHECK_SIZE(HDASTATE);
2035 GEN_CHECK_OFF(HDASTATE, PciDev);
2036 GEN_CHECK_OFF(HDASTATE, pDevInsR3);
2037 GEN_CHECK_OFF(HDASTATE, pDevInsR0);
2038 GEN_CHECK_OFF(HDASTATE, pDevInsRC);
2039 GEN_CHECK_OFF(HDASTATE, IBase);
2040 GEN_CHECK_OFF(HDASTATE, MMIOBaseAddr);
2041 GEN_CHECK_OFF(HDASTATE, au32Regs[0]);
2042 GEN_CHECK_OFF(HDASTATE, au32Regs[HDA_NUM_REGS]);
2043 GEN_CHECK_OFF(HDASTATE, aStreams);
2044 GEN_CHECK_OFF(HDASTATE, aTags);
2045 GEN_CHECK_OFF(HDASTATE, u64CORBBase);
2046 GEN_CHECK_OFF(HDASTATE, u64RIRBBase);
2047 GEN_CHECK_OFF(HDASTATE, u64DPBase);
2048 GEN_CHECK_OFF(HDASTATE, pu32CorbBuf);
2049 GEN_CHECK_OFF(HDASTATE, cbCorbBuf);
2050 GEN_CHECK_OFF(HDASTATE, pu64RirbBuf);
2051 GEN_CHECK_OFF(HDASTATE, cbRirbBuf);
2052 GEN_CHECK_OFF(HDASTATE, fRZEnabled);
2053#ifdef VBOX_WITH_STATISTICS
2054# ifndef VBOX_WITH_AUDIO_CALLBACKS
2055 GEN_CHECK_OFF(HDASTATE, StatTimer);
2056# endif
2057 GEN_CHECK_OFF(HDASTATE, StatBytesRead);
2058 GEN_CHECK_OFF(HDASTATE, StatBytesWritten);
2059#endif /* VBOX_WITH_STATISTICS */
2060 GEN_CHECK_OFF(HDASTATE, pCodec);
2061 GEN_CHECK_OFF(HDASTATE, lstDrv);
2062 GEN_CHECK_OFF(HDASTATE, pMixer);
2063 GEN_CHECK_OFF(HDASTATE, SinkFront);
2064#ifdef VBOX_WITH_HDA_51_SURROUND
2065 GEN_CHECK_OFF(HDASTATE, SinkCenterLFE);
2066 GEN_CHECK_OFF(HDASTATE, SinkRear);
2067#endif
2068 GEN_CHECK_OFF(HDASTATE, SinkLineIn);
2069#ifdef VBOX_WITH_HDA_MIC_IN
2070 GEN_CHECK_OFF(HDASTATE, SinkMicIn);
2071#endif
2072 GEN_CHECK_OFF(HDASTATE, u64WalClk);
2073 GEN_CHECK_OFF(HDASTATE, u16RespIntCnt);
2074 GEN_CHECK_OFF(HDASTATE, cPosAdjustFrames);
2075 GEN_CHECK_OFF(HDASTATE, u8IRQL);
2076
2077#ifdef VBOX_WITH_NVME_IMPL
2078 GEN_CHECK_SIZE(NVMEQUEUEHDR);
2079 GEN_CHECK_OFF(NVMEQUEUEHDR, u16Id);
2080 GEN_CHECK_OFF(NVMEQUEUEHDR, cEntries);
2081 GEN_CHECK_OFF(NVMEQUEUEHDR, enmState);
2082 GEN_CHECK_OFF(NVMEQUEUEHDR, GCPhysBase);
2083 GEN_CHECK_OFF(NVMEQUEUEHDR, cbEntry);
2084 GEN_CHECK_OFF(NVMEQUEUEHDR, idxHead);
2085 GEN_CHECK_OFF(NVMEQUEUEHDR, idxTail);
2086 GEN_CHECK_OFF(NVMEQUEUEHDR, fPhysCont);
2087 GEN_CHECK_OFF(NVMEQUEUEHDR, enmType);
2088
2089 GEN_CHECK_SIZE(NVMEQUEUESUBM);
2090 GEN_CHECK_OFF(NVMEQUEUESUBM, Hdr);
2091 GEN_CHECK_OFF(NVMEQUEUESUBM, u16CompletionQueueId);
2092 GEN_CHECK_OFF(NVMEQUEUESUBM, enmPriority);
2093 GEN_CHECK_OFF(NVMEQUEUESUBM, hEvtProcess);
2094 GEN_CHECK_OFF(NVMEQUEUESUBM, pWrkThrdR3);
2095 GEN_CHECK_OFF(NVMEQUEUESUBM, NdLstWrkThrdAssgnd);
2096 GEN_CHECK_OFF(NVMEQUEUESUBM, cReqsActive);
2097
2098 GEN_CHECK_SIZE(NVMEQUEUECOMP);
2099 GEN_CHECK_OFF(NVMEQUEUECOMP, Hdr);
2100 GEN_CHECK_OFF(NVMEQUEUECOMP, fIntrEnabled);
2101 GEN_CHECK_OFF(NVMEQUEUECOMP, u32IntrVec);
2102 GEN_CHECK_OFF(NVMEQUEUECOMP, cSubmQueuesRef);
2103 GEN_CHECK_OFF(NVMEQUEUECOMP, cWaiters);
2104 GEN_CHECK_OFF(NVMEQUEUECOMP, LstCompletionsWaiting);
2105 GEN_CHECK_OFF(NVMEQUEUECOMP, hMtx);
2106
2107 GEN_CHECK_SIZE(NVME);
2108 GEN_CHECK_OFF(NVME, PciDev);
2109 GEN_CHECK_OFF(NVME, pDevInsR3);
2110 GEN_CHECK_OFF(NVME, pDevInsR0);
2111 GEN_CHECK_OFF(NVME, pDevInsRC);
2112 GEN_CHECK_OFF(NVME, IBase);
2113 GEN_CHECK_OFF(NVME, ILeds);
2114 GEN_CHECK_OFF(NVME, pLedsConnector);
2115 GEN_CHECK_OFF(NVME, pSupDrvSession);
2116 GEN_CHECK_OFF(NVME, GCPhysMMIO);
2117 GEN_CHECK_OFF(NVME, IOPortBase);
2118 GEN_CHECK_OFF(NVME, cQueuesSubmMax);
2119 GEN_CHECK_OFF(NVME, cQueuesCompMax);
2120 GEN_CHECK_OFF(NVME, cQueueEntriesMax);
2121 GEN_CHECK_OFF(NVME, cTimeoutMax);
2122 GEN_CHECK_OFF(NVME, cWrkThrdsMax);
2123 GEN_CHECK_OFF(NVME, cCompQueuesWaitersMax);
2124 GEN_CHECK_OFF(NVME, cNamespaces);
2125 GEN_CHECK_OFF(NVME, szSerialNumber);
2126 GEN_CHECK_OFF(NVME, szModelNumber);
2127 GEN_CHECK_OFF(NVME, szFirmwareRevision);
2128 GEN_CHECK_OFF(NVME, fRCEnabled);
2129 GEN_CHECK_OFF(NVME, fR0Enabled);
2130 GEN_CHECK_OFF(NVME, enmState);
2131 GEN_CHECK_OFF(NVME, u32IntrMask);
2132 GEN_CHECK_OFF(NVME, aIntrVecs);
2133 GEN_CHECK_OFF(NVME, u32IoCompletionQueueEntrySize);
2134 GEN_CHECK_OFF(NVME, u32IoSubmissionQueueEntrySize);
2135 GEN_CHECK_OFF(NVME, uShutdwnNotifierLast);
2136 GEN_CHECK_OFF(NVME, uAmsSet);
2137 GEN_CHECK_OFF(NVME, uMpsSet);
2138 GEN_CHECK_OFF(NVME, uCssSet);
2139 GEN_CHECK_OFF(NVME, u32RegIdx);
2140 GEN_CHECK_OFF(NVME, cbPage);
2141 GEN_CHECK_OFF(NVME, paQueuesSubmR3);
2142 GEN_CHECK_OFF(NVME, paQueuesCompR3);
2143 GEN_CHECK_OFF(NVME, paQueuesSubmR0);
2144 GEN_CHECK_OFF(NVME, paQueuesCompR0);
2145 GEN_CHECK_OFF(NVME, paQueuesSubmRC);
2146 GEN_CHECK_OFF(NVME, paQueuesCompRC);
2147 GEN_CHECK_OFF(NVME, pvCtrlMemBufR3);
2148 GEN_CHECK_OFF(NVME, GCPhysCtrlMemBuf);
2149 GEN_CHECK_OFF(NVME, cbCtrlMemBuf);
2150 GEN_CHECK_OFF(NVME, u32CtrlMemBufSz);
2151 GEN_CHECK_OFF(NVME, pWakeQueueR3);
2152 GEN_CHECK_OFF(NVME, pWakeQueueR0);
2153 GEN_CHECK_OFF(NVME, pWakeQueueRC);
2154 GEN_CHECK_OFF(NVME, cAsyncEvtReqsMax);
2155 GEN_CHECK_OFF(NVME, CritSectAsyncEvtReqs);
2156 GEN_CHECK_OFF(NVME, paAsyncEvtReqCids);
2157 GEN_CHECK_OFF(NVME, paNamespaces);
2158 GEN_CHECK_OFF(NVME, cWrkThrdsCur);
2159 GEN_CHECK_OFF(NVME, cWrkThrdsActive);
2160 GEN_CHECK_OFF(NVME, LstWrkThrds);
2161 GEN_CHECK_OFF(NVME, CritSectWrkThrds);
2162 GEN_CHECK_OFF(NVME, fSignalIdle);
2163# ifdef VBOX_WITH_STATISTICS
2164 GEN_CHECK_OFF(NVME, aStatMemXfer[0]);
2165 GEN_CHECK_OFF(NVME, aStatMemXfer[NVME_CMBSZ_SUPP_BIT_IDX_MAX]);
2166# endif
2167#endif
2168
2169 return (0);
2170}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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