VirtualBox

source: vbox/trunk/src/VBox/VMM/include/PDMInternal.h@ 62767

Last change on this file since 62767 was 62478, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 55.7 KB
Line 
1/* $Id: PDMInternal.h 62478 2016-07-22 18:29:06Z vboxsync $ */
2/** @file
3 * PDM - Internal header file.
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef ___PDMInternal_h
19#define ___PDMInternal_h
20
21#include <VBox/types.h>
22#include <VBox/param.h>
23#include <VBox/vmm/cfgm.h>
24#include <VBox/vmm/stam.h>
25#include <VBox/vusb.h>
26#include <VBox/vmm/pdmasynccompletion.h>
27#ifdef VBOX_WITH_NETSHAPER
28# include <VBox/vmm/pdmnetshaper.h>
29#endif
30#ifdef VBOX_WITH_PDM_ASYNC_COMPLETION
31# include <VBox/vmm/pdmasynccompletion.h>
32#endif
33#include <VBox/vmm/pdmblkcache.h>
34#include <VBox/vmm/pdmcommon.h>
35#include <VBox/sup.h>
36#include <iprt/assert.h>
37#include <iprt/critsect.h>
38#ifdef IN_RING3
39# include <iprt/thread.h>
40#endif
41
42RT_C_DECLS_BEGIN
43
44
45/** @defgroup grp_pdm_int Internal
46 * @ingroup grp_pdm
47 * @internal
48 * @{
49 */
50
51/** @def PDM_WITH_R3R0_CRIT_SECT
52 * Enables or disabled ring-3/ring-0 critical sections. */
53#if defined(DOXYGEN_RUNNING) || 1
54# define PDM_WITH_R3R0_CRIT_SECT
55#endif
56
57/** @def PDMCRITSECT_STRICT
58 * Enables/disables PDM critsect strictness like deadlock detection. */
59#if (defined(RT_LOCK_STRICT) && defined(IN_RING3) && !defined(IEM_VERIFICATION_MODE) && !defined(PDMCRITSECT_STRICT)) \
60 || defined(DOXYGEN_RUNNING)
61# define PDMCRITSECT_STRICT
62#endif
63
64/** @def PDMCRITSECT_STRICT
65 * Enables/disables PDM read/write critsect strictness like deadlock
66 * detection. */
67#if (defined(RT_LOCK_STRICT) && defined(IN_RING3) && !defined(IEM_VERIFICATION_MODE) && !defined(PDMCRITSECTRW_STRICT)) \
68 || defined(DOXYGEN_RUNNING)
69# define PDMCRITSECTRW_STRICT
70#endif
71
72
73/*******************************************************************************
74* Structures and Typedefs *
75*******************************************************************************/
76
77/** Pointer to a PDM Device. */
78typedef struct PDMDEV *PPDMDEV;
79/** Pointer to a pointer to a PDM Device. */
80typedef PPDMDEV *PPPDMDEV;
81
82/** Pointer to a PDM USB Device. */
83typedef struct PDMUSB *PPDMUSB;
84/** Pointer to a pointer to a PDM USB Device. */
85typedef PPDMUSB *PPPDMUSB;
86
87/** Pointer to a PDM Driver. */
88typedef struct PDMDRV *PPDMDRV;
89/** Pointer to a pointer to a PDM Driver. */
90typedef PPDMDRV *PPPDMDRV;
91
92/** Pointer to a PDM Logical Unit. */
93typedef struct PDMLUN *PPDMLUN;
94/** Pointer to a pointer to a PDM Logical Unit. */
95typedef PPDMLUN *PPPDMLUN;
96
97/** Pointer to a PDM PCI Bus instance. */
98typedef struct PDMPCIBUS *PPDMPCIBUS;
99/** Pointer to a DMAC instance. */
100typedef struct PDMDMAC *PPDMDMAC;
101/** Pointer to a RTC instance. */
102typedef struct PDMRTC *PPDMRTC;
103
104/** Pointer to an USB HUB registration record. */
105typedef struct PDMUSBHUB *PPDMUSBHUB;
106
107/**
108 * Supported asynchronous completion endpoint classes.
109 */
110typedef enum PDMASYNCCOMPLETIONEPCLASSTYPE
111{
112 /** File class. */
113 PDMASYNCCOMPLETIONEPCLASSTYPE_FILE = 0,
114 /** Number of supported classes. */
115 PDMASYNCCOMPLETIONEPCLASSTYPE_MAX,
116 /** 32bit hack. */
117 PDMASYNCCOMPLETIONEPCLASSTYPE_32BIT_HACK = 0x7fffffff
118} PDMASYNCCOMPLETIONEPCLASSTYPE;
119
120/**
121 * Private device instance data.
122 */
123typedef struct PDMDEVINSINT
124{
125 /** Pointer to the next instance (HC Ptr).
126 * (Head is pointed to by PDM::pDevInstances.) */
127 R3PTRTYPE(PPDMDEVINS) pNextR3;
128 /** Pointer to the next per device instance (HC Ptr).
129 * (Head is pointed to by PDMDEV::pInstances.) */
130 R3PTRTYPE(PPDMDEVINS) pPerDeviceNextR3;
131 /** Pointer to device structure - HC Ptr. */
132 R3PTRTYPE(PPDMDEV) pDevR3;
133 /** Pointer to the list of logical units associated with the device. (FIFO) */
134 R3PTRTYPE(PPDMLUN) pLunsR3;
135 /** Pointer to the asynchronous notification callback set while in
136 * FNPDMDEVSUSPEND or FNPDMDEVPOWEROFF. */
137 R3PTRTYPE(PFNPDMDEVASYNCNOTIFY) pfnAsyncNotify;
138 /** Configuration handle to the instance node. */
139 R3PTRTYPE(PCFGMNODE) pCfgHandle;
140
141 /** R3 pointer to the VM this instance was created for. */
142 PVMR3 pVMR3;
143 /** R3 pointer to associated PCI device structure. */
144 R3PTRTYPE(struct PCIDevice *) pPciDeviceR3;
145 /** R3 pointer to associated PCI bus structure. */
146 R3PTRTYPE(PPDMPCIBUS) pPciBusR3;
147
148 /** R0 pointer to the VM this instance was created for. */
149 PVMR0 pVMR0;
150 /** R0 pointer to associated PCI device structure. */
151 R0PTRTYPE(struct PCIDevice *) pPciDeviceR0;
152 /** R0 pointer to associated PCI bus structure. */
153 R0PTRTYPE(PPDMPCIBUS) pPciBusR0;
154
155 /** RC pointer to the VM this instance was created for. */
156 PVMRC pVMRC;
157 /** RC pointer to associated PCI device structure. */
158 RCPTRTYPE(struct PCIDevice *) pPciDeviceRC;
159 /** RC pointer to associated PCI bus structure. */
160 RCPTRTYPE(PPDMPCIBUS) pPciBusRC;
161
162 /** Flags, see PDMDEVINSINT_FLAGS_XXX. */
163 uint32_t fIntFlags;
164 /** The last IRQ tag (for tracing it thru clearing). */
165 uint32_t uLastIrqTag;
166 /** Size padding. */
167 uint32_t u32Padding;
168} PDMDEVINSINT;
169
170/** @name PDMDEVINSINT::fIntFlags
171 * @{ */
172/** Used by pdmR3Load to mark device instances it found in the saved state. */
173#define PDMDEVINSINT_FLAGS_FOUND RT_BIT_32(0)
174/** Indicates that the device hasn't been powered on or resumed.
175 * This is used by PDMR3PowerOn, PDMR3Resume, PDMR3Suspend and PDMR3PowerOff
176 * to make sure each device gets exactly one notification for each of those
177 * events. PDMR3Resume and PDMR3PowerOn also makes use of it to bail out on
178 * a failure (already resumed/powered-on devices are suspended).
179 * PDMR3PowerOff resets this flag once before going through the devices to make sure
180 * every device gets the power off notification even if it was suspended before with
181 * PDMR3Suspend.
182 */
183#define PDMDEVINSINT_FLAGS_SUSPENDED RT_BIT_32(1)
184/** Indicates that the device has been reset already. Used by PDMR3Reset. */
185#define PDMDEVINSINT_FLAGS_RESET RT_BIT_32(2)
186/** @} */
187
188
189/**
190 * Private USB device instance data.
191 */
192typedef struct PDMUSBINSINT
193{
194 /** The UUID of this instance. */
195 RTUUID Uuid;
196 /** Pointer to the next instance.
197 * (Head is pointed to by PDM::pUsbInstances.) */
198 R3PTRTYPE(PPDMUSBINS) pNext;
199 /** Pointer to the next per USB device instance.
200 * (Head is pointed to by PDMUSB::pInstances.) */
201 R3PTRTYPE(PPDMUSBINS) pPerDeviceNext;
202
203 /** Pointer to device structure. */
204 R3PTRTYPE(PPDMUSB) pUsbDev;
205
206 /** Pointer to the VM this instance was created for. */
207 PVMR3 pVM;
208 /** Pointer to the list of logical units associated with the device. (FIFO) */
209 R3PTRTYPE(PPDMLUN) pLuns;
210 /** The per instance device configuration. */
211 R3PTRTYPE(PCFGMNODE) pCfg;
212 /** Same as pCfg if the configuration should be deleted when detaching the device. */
213 R3PTRTYPE(PCFGMNODE) pCfgDelete;
214 /** The global device configuration. */
215 R3PTRTYPE(PCFGMNODE) pCfgGlobal;
216
217 /** Pointer to the USB hub this device is attached to.
218 * This is NULL if the device isn't connected to any HUB. */
219 R3PTRTYPE(PPDMUSBHUB) pHub;
220 /** The port number that we're connected to. */
221 uint32_t iPort;
222 /** Indicates that the USB device hasn't been powered on or resumed.
223 * See PDMDEVINSINT_FLAGS_SUSPENDED. */
224 bool fVMSuspended;
225 /** Indicates that the USB device has been reset. */
226 bool fVMReset;
227 /** Pointer to the asynchronous notification callback set while in
228 * FNPDMDEVSUSPEND or FNPDMDEVPOWEROFF. */
229 R3PTRTYPE(PFNPDMUSBASYNCNOTIFY) pfnAsyncNotify;
230} PDMUSBINSINT;
231
232
233/**
234 * Private driver instance data.
235 */
236typedef struct PDMDRVINSINT
237{
238 /** Pointer to the driver instance above.
239 * This is NULL for the topmost drive. */
240 R3PTRTYPE(PPDMDRVINS) pUp;
241 /** Pointer to the driver instance below.
242 * This is NULL for the bottommost driver. */
243 R3PTRTYPE(PPDMDRVINS) pDown;
244 /** Pointer to the logical unit this driver chained on. */
245 R3PTRTYPE(PPDMLUN) pLun;
246 /** Pointer to driver structure from which this was instantiated. */
247 R3PTRTYPE(PPDMDRV) pDrv;
248 /** Pointer to the VM this instance was created for, ring-3 context. */
249 PVMR3 pVMR3;
250 /** Pointer to the VM this instance was created for, ring-0 context. */
251 PVMR0 pVMR0;
252 /** Pointer to the VM this instance was created for, raw-mode context. */
253 PVMRC pVMRC;
254 /** Flag indicating that the driver is being detached and destroyed.
255 * (Helps detect potential recursive detaching.) */
256 bool fDetaching;
257 /** Indicates that the driver hasn't been powered on or resumed.
258 * See PDMDEVINSINT_FLAGS_SUSPENDED. */
259 bool fVMSuspended;
260 /** Indicates that the driver has been reset already. */
261 bool fVMReset;
262 /** Set if allocated on the hyper heap, false if on the ring-3 heap. */
263 bool fHyperHeap;
264 /** Pointer to the asynchronous notification callback set while in
265 * PDMUSBREG::pfnVMSuspend or PDMUSBREG::pfnVMPowerOff. */
266 R3PTRTYPE(PFNPDMDRVASYNCNOTIFY) pfnAsyncNotify;
267 /** Configuration handle to the instance node. */
268 R3PTRTYPE(PCFGMNODE) pCfgHandle;
269 /** Pointer to the ring-0 request handler function. */
270 PFNPDMDRVREQHANDLERR0 pfnReqHandlerR0;
271} PDMDRVINSINT;
272
273
274/**
275 * Private critical section data.
276 */
277typedef struct PDMCRITSECTINT
278{
279 /** The critical section core which is shared with IPRT.
280 * @note The semaphore is a SUPSEMEVENT. */
281 RTCRITSECT Core;
282 /** Pointer to the next critical section.
283 * This chain is used for relocating pVMRC and device cleanup. */
284 R3PTRTYPE(struct PDMCRITSECTINT *) pNext;
285 /** Owner identifier.
286 * This is pDevIns if the owner is a device. Similarly for a driver or service.
287 * PDMR3CritSectInit() sets this to point to the critsect itself. */
288 RTR3PTR pvKey;
289 /** Pointer to the VM - R3Ptr. */
290 PVMR3 pVMR3;
291 /** Pointer to the VM - R0Ptr. */
292 PVMR0 pVMR0;
293 /** Pointer to the VM - GCPtr. */
294 PVMRC pVMRC;
295 /** Set if this critical section is the automatically created default
296 * section of a device. */
297 bool fAutomaticDefaultCritsect;
298 /** Set if the critical section is used by a timer or similar.
299 * See PDMR3DevGetCritSect. */
300 bool fUsedByTimerOrSimilar;
301 /** Alignment padding. */
302 bool afPadding[2];
303 /** Support driver event semaphore that is scheduled to be signaled upon leaving
304 * the critical section. This is only for Ring-3 and Ring-0. */
305 SUPSEMEVENT hEventToSignal;
306 /** The lock name. */
307 R3PTRTYPE(const char *) pszName;
308 /** R0/RC lock contention. */
309 STAMCOUNTER StatContentionRZLock;
310 /** R0/RC unlock contention. */
311 STAMCOUNTER StatContentionRZUnlock;
312 /** R3 lock contention. */
313 STAMCOUNTER StatContentionR3;
314 /** Profiling the time the section is locked. */
315 STAMPROFILEADV StatLocked;
316} PDMCRITSECTINT;
317AssertCompileMemberAlignment(PDMCRITSECTINT, StatContentionRZLock, 8);
318/** Pointer to private critical section data. */
319typedef PDMCRITSECTINT *PPDMCRITSECTINT;
320
321/** Indicates that the critical section is queued for unlock.
322 * PDMCritSectIsOwner and PDMCritSectIsOwned optimizations. */
323#define PDMCRITSECT_FLAGS_PENDING_UNLOCK RT_BIT_32(17)
324
325
326/**
327 * Private critical section data.
328 */
329typedef struct PDMCRITSECTRWINT
330{
331 /** The read/write critical section core which is shared with IPRT.
332 * @note The semaphores are SUPSEMEVENT and SUPSEMEVENTMULTI. */
333 RTCRITSECTRW Core;
334
335 /** Pointer to the next critical section.
336 * This chain is used for relocating pVMRC and device cleanup. */
337 R3PTRTYPE(struct PDMCRITSECTRWINT *) pNext;
338 /** Owner identifier.
339 * This is pDevIns if the owner is a device. Similarly for a driver or service.
340 * PDMR3CritSectInit() sets this to point to the critsect itself. */
341 RTR3PTR pvKey;
342 /** Pointer to the VM - R3Ptr. */
343 PVMR3 pVMR3;
344 /** Pointer to the VM - R0Ptr. */
345 PVMR0 pVMR0;
346 /** Pointer to the VM - GCPtr. */
347 PVMRC pVMRC;
348#if HC_ARCH_BITS == 64
349 /** Alignment padding. */
350 RTRCPTR RCPtrPadding;
351#endif
352 /** The lock name. */
353 R3PTRTYPE(const char *) pszName;
354 /** R0/RC write lock contention. */
355 STAMCOUNTER StatContentionRZEnterExcl;
356 /** R0/RC write unlock contention. */
357 STAMCOUNTER StatContentionRZLeaveExcl;
358 /** R0/RC read lock contention. */
359 STAMCOUNTER StatContentionRZEnterShared;
360 /** R0/RC read unlock contention. */
361 STAMCOUNTER StatContentionRZLeaveShared;
362 /** R0/RC writes. */
363 STAMCOUNTER StatRZEnterExcl;
364 /** R0/RC reads. */
365 STAMCOUNTER StatRZEnterShared;
366 /** R3 write lock contention. */
367 STAMCOUNTER StatContentionR3EnterExcl;
368 /** R3 read lock contention. */
369 STAMCOUNTER StatContentionR3EnterShared;
370 /** R3 writes. */
371 STAMCOUNTER StatR3EnterExcl;
372 /** R3 reads. */
373 STAMCOUNTER StatR3EnterShared;
374 /** Profiling the time the section is write locked. */
375 STAMPROFILEADV StatWriteLocked;
376} PDMCRITSECTRWINT;
377AssertCompileMemberAlignment(PDMCRITSECTRWINT, StatContentionRZEnterExcl, 8);
378AssertCompileMemberAlignment(PDMCRITSECTRWINT, Core.u64State, 8);
379/** Pointer to private critical section data. */
380typedef PDMCRITSECTRWINT *PPDMCRITSECTRWINT;
381
382
383
384/**
385 * The usual device/driver/internal/external stuff.
386 */
387typedef enum
388{
389 /** The usual invalid entry. */
390 PDMTHREADTYPE_INVALID = 0,
391 /** Device type. */
392 PDMTHREADTYPE_DEVICE,
393 /** USB Device type. */
394 PDMTHREADTYPE_USB,
395 /** Driver type. */
396 PDMTHREADTYPE_DRIVER,
397 /** Internal type. */
398 PDMTHREADTYPE_INTERNAL,
399 /** External type. */
400 PDMTHREADTYPE_EXTERNAL,
401 /** The usual 32-bit hack. */
402 PDMTHREADTYPE_32BIT_HACK = 0x7fffffff
403} PDMTHREADTYPE;
404
405
406/**
407 * The internal structure for the thread.
408 */
409typedef struct PDMTHREADINT
410{
411 /** The VM pointer. */
412 PVMR3 pVM;
413 /** The event semaphore the thread blocks on when not running. */
414 RTSEMEVENTMULTI BlockEvent;
415 /** The event semaphore the thread sleeps on while running. */
416 RTSEMEVENTMULTI SleepEvent;
417 /** Pointer to the next thread. */
418 R3PTRTYPE(struct PDMTHREAD *) pNext;
419 /** The thread type. */
420 PDMTHREADTYPE enmType;
421} PDMTHREADINT;
422
423
424
425/* Must be included after PDMDEVINSINT is defined. */
426#define PDMDEVINSINT_DECLARED
427#define PDMUSBINSINT_DECLARED
428#define PDMDRVINSINT_DECLARED
429#define PDMCRITSECTINT_DECLARED
430#define PDMCRITSECTRWINT_DECLARED
431#define PDMTHREADINT_DECLARED
432#ifdef ___VBox_pdm_h
433# error "Invalid header PDM order. Include PDMInternal.h before VBox/vmm/pdm.h!"
434#endif
435RT_C_DECLS_END
436#include <VBox/vmm/pdm.h>
437RT_C_DECLS_BEGIN
438
439/**
440 * PDM Logical Unit.
441 *
442 * This typically the representation of a physical port on a
443 * device, like for instance the PS/2 keyboard port on the
444 * keyboard controller device. The LUNs are chained on the
445 * device the belong to (PDMDEVINSINT::pLunsR3).
446 */
447typedef struct PDMLUN
448{
449 /** The LUN - The Logical Unit Number. */
450 RTUINT iLun;
451 /** Pointer to the next LUN. */
452 PPDMLUN pNext;
453 /** Pointer to the top driver in the driver chain. */
454 PPDMDRVINS pTop;
455 /** Pointer to the bottom driver in the driver chain. */
456 PPDMDRVINS pBottom;
457 /** Pointer to the device instance which the LUN belongs to.
458 * Either this is set or pUsbIns is set. Both is never set at the same time. */
459 PPDMDEVINS pDevIns;
460 /** Pointer to the USB device instance which the LUN belongs to. */
461 PPDMUSBINS pUsbIns;
462 /** Pointer to the device base interface. */
463 PPDMIBASE pBase;
464 /** Description of this LUN. */
465 const char *pszDesc;
466} PDMLUN;
467
468
469/**
470 * PDM Device.
471 */
472typedef struct PDMDEV
473{
474 /** Pointer to the next device (R3 Ptr). */
475 R3PTRTYPE(PPDMDEV) pNext;
476 /** Device name length. (search optimization) */
477 RTUINT cchName;
478 /** Registration structure. */
479 R3PTRTYPE(const struct PDMDEVREG *) pReg;
480 /** Number of instances. */
481 uint32_t cInstances;
482 /** Pointer to chain of instances (R3 Ptr). */
483 PPDMDEVINSR3 pInstances;
484 /** The search path for raw-mode context modules (';' as separator). */
485 char *pszRCSearchPath;
486 /** The search path for ring-0 context modules (';' as separator). */
487 char *pszR0SearchPath;
488} PDMDEV;
489
490
491/**
492 * PDM USB Device.
493 */
494typedef struct PDMUSB
495{
496 /** Pointer to the next device (R3 Ptr). */
497 R3PTRTYPE(PPDMUSB) pNext;
498 /** Device name length. (search optimization) */
499 RTUINT cchName;
500 /** Registration structure. */
501 R3PTRTYPE(const struct PDMUSBREG *) pReg;
502 /** Next instance number. */
503 uint32_t iNextInstance;
504 /** Pointer to chain of instances (R3 Ptr). */
505 R3PTRTYPE(PPDMUSBINS) pInstances;
506} PDMUSB;
507
508
509/**
510 * PDM Driver.
511 */
512typedef struct PDMDRV
513{
514 /** Pointer to the next device. */
515 PPDMDRV pNext;
516 /** Registration structure. */
517 const struct PDMDRVREG * pReg;
518 /** Current number of instances. */
519 uint32_t cInstances;
520 /** The next instance number. */
521 uint32_t iNextInstance;
522 /** The search path for raw-mode context modules (';' as separator). */
523 char *pszRCSearchPath;
524 /** The search path for ring-0 context modules (';' as separator). */
525 char *pszR0SearchPath;
526} PDMDRV;
527
528
529/**
530 * PDM registered PIC device.
531 */
532typedef struct PDMPIC
533{
534 /** Pointer to the PIC device instance - R3. */
535 PPDMDEVINSR3 pDevInsR3;
536 /** @copydoc PDMPICREG::pfnSetIrqR3 */
537 DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
538 /** @copydoc PDMPICREG::pfnGetInterruptR3 */
539 DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns, uint32_t *puTagSrc));
540
541 /** Pointer to the PIC device instance - R0. */
542 PPDMDEVINSR0 pDevInsR0;
543 /** @copydoc PDMPICREG::pfnSetIrqR3 */
544 DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
545 /** @copydoc PDMPICREG::pfnGetInterruptR3 */
546 DECLR0CALLBACKMEMBER(int, pfnGetInterruptR0,(PPDMDEVINS pDevIns, uint32_t *puTagSrc));
547
548 /** Pointer to the PIC device instance - RC. */
549 PPDMDEVINSRC pDevInsRC;
550 /** @copydoc PDMPICREG::pfnSetIrqR3 */
551 DECLRCCALLBACKMEMBER(void, pfnSetIrqRC,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
552 /** @copydoc PDMPICREG::pfnGetInterruptR3 */
553 DECLRCCALLBACKMEMBER(int, pfnGetInterruptRC,(PPDMDEVINS pDevIns, uint32_t *puTagSrc));
554 /** Alignment padding. */
555 RTRCPTR RCPtrPadding;
556} PDMPIC;
557
558
559/**
560 * PDM registered APIC device.
561 */
562typedef struct PDMAPIC
563{
564 /** Pointer to the APIC device instance - R3 Ptr. */
565 PPDMDEVINSR3 pDevInsR3;
566 /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
567 DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t *pu8Vector,
568 uint32_t *pu32TagSrc));
569 /** @copydoc PDMAPICREG::pfnSetBaseMsrR3 */
570 DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnSetBaseMsrR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint64_t u64Base));
571 /** @copydoc PDMAPICREG::pfnGetBaseMsrR3 */
572 DECLR3CALLBACKMEMBER(uint64_t, pfnGetBaseMsrR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu));
573 /** @copydoc PDMAPICREG::pfnSetTprR3 */
574 DECLR3CALLBACKMEMBER(void, pfnSetTprR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t u8Tpr));
575 /** @copydoc PDMAPICREG::pfnGetTprR3 */
576 DECLR3CALLBACKMEMBER(uint8_t, pfnGetTprR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, bool *pfPending, uint8_t *pu8PendingIntr));
577 /** @copydoc PDMAPICREG::pfnWriteMsrR3 */
578 DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnWriteMsrR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint32_t u32Reg, uint64_t u64Value));
579 /** @copydoc PDMAPICREG::pfnReadMsrR3 */
580 DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnReadMsrR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint32_t u32Reg, uint64_t *pu64Value));
581 /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
582 DECLR3CALLBACKMEMBER(int, pfnBusDeliverR3,(PPDMDEVINS pDevIns, uint8_t uDest, uint8_t uDestMode,
583 uint8_t uDeliveryMode, uint8_t uVector, uint8_t uPolarity,
584 uint8_t uTriggerMode, uint32_t uTagSrc));
585 /** @copydoc PDMAPICREG::pfnLocalInterruptR3 */
586 DECLR3CALLBACKMEMBER(VBOXSTRICTRC, pfnLocalInterruptR3,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t u8Pin, uint8_t u8Level,
587 int rcRZ));
588 /** @copydoc PDMAPICREG::pfnGetTimerFreqR3 */
589 DECLR3CALLBACKMEMBER(uint64_t, pfnGetTimerFreqR3,(PPDMDEVINS pDevIns));
590
591 /** Pointer to the APIC device instance - R0 Ptr. */
592 PPDMDEVINSR0 pDevInsR0;
593 /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
594 DECLR0CALLBACKMEMBER(int, pfnGetInterruptR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t *pu8Vector,
595 uint32_t *pu32TagSrc));
596 /** @copydoc PDMAPICREG::pfnSetBaseMsrR3 */
597 DECLR0CALLBACKMEMBER(VBOXSTRICTRC, pfnSetBaseMsrR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint64_t u64Base));
598 /** @copydoc PDMAPICREG::pfnGetBaseMsrR3 */
599 DECLR0CALLBACKMEMBER(uint64_t, pfnGetBaseMsrR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu));
600 /** @copydoc PDMAPICREG::pfnSetTprR3 */
601 DECLR0CALLBACKMEMBER(void, pfnSetTprR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t u8Tpr));
602 /** @copydoc PDMAPICREG::pfnGetTprR3 */
603 DECLR0CALLBACKMEMBER(uint8_t, pfnGetTprR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, bool *pfPending, uint8_t *pu8PendingIntr));
604 /** @copydoc PDMAPICREG::pfnWriteMsrR3 */
605 DECLR0CALLBACKMEMBER(VBOXSTRICTRC, pfnWriteMsrR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint32_t u32Reg, uint64_t u64Value));
606 /** @copydoc PDMAPICREG::pfnReadMsrR3 */
607 DECLR0CALLBACKMEMBER(VBOXSTRICTRC, pfnReadMsrR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint32_t u32Reg, uint64_t *pu64Value));
608 /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
609 DECLR0CALLBACKMEMBER(int, pfnBusDeliverR0,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode,
610 uint8_t u8DeliveryMode, uint8_t iVector, uint8_t u8Polarity,
611 uint8_t u8TriggerMode, uint32_t uTagSrc));
612 /** @copydoc PDMAPICREG::pfnLocalInterruptR3 */
613 DECLR0CALLBACKMEMBER(VBOXSTRICTRC, pfnLocalInterruptR0,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t u8Pin, uint8_t u8Level,
614 int rcRZ));
615 /** @copydoc PDMAPICREG::pfnGetTimerFreqR3 */
616 DECLR0CALLBACKMEMBER(uint64_t, pfnGetTimerFreqR0,(PPDMDEVINS pDevIns));
617
618 /** Pointer to the APIC device instance - RC Ptr. */
619 PPDMDEVINSRC pDevInsRC;
620 /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
621 DECLRCCALLBACKMEMBER(int, pfnGetInterruptRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t *pu8Vector,
622 uint32_t *pu32TagSrc));
623 /** @copydoc PDMAPICREG::pfnSetBaseMsrR3 */
624 DECLRCCALLBACKMEMBER(VBOXSTRICTRC, pfnSetBaseMsrRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint64_t u64Base));
625 /** @copydoc PDMAPICREG::pfnGetBaseMsrR3 */
626 DECLRCCALLBACKMEMBER(uint64_t, pfnGetBaseMsrRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu));
627 /** @copydoc PDMAPICREG::pfnSetTprR3 */
628 DECLRCCALLBACKMEMBER(void, pfnSetTprRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t u8Tpr));
629 /** @copydoc PDMAPICREG::pfnGetTprR3 */
630 DECLRCCALLBACKMEMBER(uint8_t, pfnGetTprRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, bool *pfPending, uint8_t *pu8PendingIntr));
631 /** @copydoc PDMAPICREG::pfnWriteMsrR3 */
632 DECLRCCALLBACKMEMBER(VBOXSTRICTRC, pfnWriteMsrRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint32_t u32Reg, uint64_t u64Value));
633 /** @copydoc PDMAPICREG::pfnReadMsrR3 */
634 DECLRCCALLBACKMEMBER(VBOXSTRICTRC, pfnReadMsrRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint32_t u32Reg, uint64_t *pu64Value));
635 /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
636 DECLRCCALLBACKMEMBER(int, pfnBusDeliverRC,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode,
637 uint8_t u8DeliveryMode, uint8_t iVector, uint8_t u8Polarity,
638 uint8_t u8TriggerMode, uint32_t uTagSrc));
639 /** @copydoc PDMAPICREG::pfnLocalInterruptR3 */
640 DECLRCCALLBACKMEMBER(VBOXSTRICTRC, pfnLocalInterruptRC,(PPDMDEVINS pDevIns, PVMCPU pVCpu, uint8_t u8Pin, uint8_t u8Level,
641 int rcRZ));
642 /** @copydoc PDMAPICREG::pfnGetTimerFreqR3 */
643 DECLRCCALLBACKMEMBER(uint64_t, pfnGetTimerFreqRC,(PPDMDEVINS pDevIns));
644
645 uint8_t Alignment[4];
646} PDMAPIC;
647
648
649/**
650 * PDM registered I/O APIC device.
651 */
652typedef struct PDMIOAPIC
653{
654 /** Pointer to the APIC device instance - R3 Ptr. */
655 PPDMDEVINSR3 pDevInsR3;
656 /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
657 DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
658 /** @copydoc PDMIOAPICREG::pfnSendMsiR3 */
659 DECLR3CALLBACKMEMBER(void, pfnSendMsiR3,(PPDMDEVINS pDevIns, RTGCPHYS GCAddr, uint32_t uValue, uint32_t uTagSrc));
660 /** @copydoc PDMIOAPICREG::pfnSetEoiR3 */
661 DECLR3CALLBACKMEMBER(int, pfnSetEoiR3,(PPDMDEVINS pDevIns, uint8_t u8Vector));
662
663 /** Pointer to the PIC device instance - R0. */
664 PPDMDEVINSR0 pDevInsR0;
665 /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
666 DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
667 /** @copydoc PDMIOAPICREG::pfnSendMsiR3 */
668 DECLR0CALLBACKMEMBER(void, pfnSendMsiR0,(PPDMDEVINS pDevIns, RTGCPHYS GCAddr, uint32_t uValue, uint32_t uTagSrc));
669 /** @copydoc PDMIOAPICREG::pfnSetEoiR3 */
670 DECLR0CALLBACKMEMBER(int, pfnSetEoiR0,(PPDMDEVINS pDevIns, uint8_t u8Vector));
671
672 /** Pointer to the APIC device instance - RC Ptr. */
673 PPDMDEVINSRC pDevInsRC;
674 /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
675 DECLRCCALLBACKMEMBER(void, pfnSetIrqRC,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));
676 /** @copydoc PDMIOAPICREG::pfnSendMsiR3 */
677 DECLRCCALLBACKMEMBER(void, pfnSendMsiRC,(PPDMDEVINS pDevIns, RTGCPHYS GCAddr, uint32_t uValue, uint32_t uTagSrc));
678 /** @copydoc PDMIOAPICREG::pfnSendMsiR3 */
679 DECLRCCALLBACKMEMBER(int, pfnSetEoiRC,(PPDMDEVINS pDevIns, uint8_t u8Vector));
680} PDMIOAPIC;
681
682/** Maximum number of PCI busses for a VM. */
683#define PDM_PCI_BUSSES_MAX 8
684
685
686#ifdef IN_RING3
687/**
688 * PDM registered firmware device.
689 */
690typedef struct PDMFW
691{
692 /** Pointer to the firmware device instance. */
693 PPDMDEVINSR3 pDevIns;
694 /** Copy of the registration structure. */
695 PDMFWREG Reg;
696} PDMFW;
697/** Pointer to a firmware instance. */
698typedef PDMFW *PPDMFW;
699#endif
700
701
702/**
703 * PDM PCI Bus instance.
704 */
705typedef struct PDMPCIBUS
706{
707 /** PCI bus number. */
708 RTUINT iBus;
709 RTUINT uPadding0; /**< Alignment padding.*/
710
711 /** Pointer to PCI Bus device instance. */
712 PPDMDEVINSR3 pDevInsR3;
713 /** @copydoc PDMPCIBUSREG::pfnSetIrqR3 */
714 DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel, uint32_t uTagSrc));
715 /** @copydoc PDMPCIBUSREG::pfnRegisterR3 */
716 DECLR3CALLBACKMEMBER(int, pfnRegisterR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, const char *pszName, int iDev));
717 /** @copydoc PDMPCIBUSREG::pfnRegisterMsiR3 */
718 DECLR3CALLBACKMEMBER(int, pfnRegisterMsiR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PPDMMSIREG pMsiReg));
719 /** @copydoc PDMPCIBUSREG::pfnIORegionRegisterR3 */
720 DECLR3CALLBACKMEMBER(int, pfnIORegionRegisterR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iRegion, uint32_t cbRegion,
721 PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback));
722 /** @copydoc PDMPCIBUSREG::pfnSetConfigCallbacksR3 */
723 DECLR3CALLBACKMEMBER(void, pfnSetConfigCallbacksR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PFNPCICONFIGREAD pfnRead,
724 PPFNPCICONFIGREAD ppfnReadOld, PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld));
725 /** @copydoc PDMPCIBUSREG::pfnFakePCIBIOSR3 */
726 DECLR3CALLBACKMEMBER(int, pfnFakePCIBIOSR3,(PPDMDEVINS pDevIns));
727
728 /** Pointer to the PIC device instance - R0. */
729 R0PTRTYPE(PPDMDEVINS) pDevInsR0;
730 /** @copydoc PDMPCIBUSREG::pfnSetIrqR3 */
731 DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel, uint32_t uTagSrc));
732
733 /** Pointer to PCI Bus device instance. */
734 PPDMDEVINSRC pDevInsRC;
735 /** @copydoc PDMPCIBUSREG::pfnSetIrqR3 */
736 DECLRCCALLBACKMEMBER(void, pfnSetIrqRC,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel, uint32_t uTagSrc));
737} PDMPCIBUS;
738
739
740#ifdef IN_RING3
741/**
742 * PDM registered DMAC (DMA Controller) device.
743 */
744typedef struct PDMDMAC
745{
746 /** Pointer to the DMAC device instance. */
747 PPDMDEVINSR3 pDevIns;
748 /** Copy of the registration structure. */
749 PDMDMACREG Reg;
750} PDMDMAC;
751
752
753/**
754 * PDM registered RTC (Real Time Clock) device.
755 */
756typedef struct PDMRTC
757{
758 /** Pointer to the RTC device instance. */
759 PPDMDEVINSR3 pDevIns;
760 /** Copy of the registration structure. */
761 PDMRTCREG Reg;
762} PDMRTC;
763
764#endif /* IN_RING3 */
765
766/**
767 * Module type.
768 */
769typedef enum PDMMODTYPE
770{
771 /** Raw-mode (RC) context module. */
772 PDMMOD_TYPE_RC,
773 /** Ring-0 (host) context module. */
774 PDMMOD_TYPE_R0,
775 /** Ring-3 (host) context module. */
776 PDMMOD_TYPE_R3
777} PDMMODTYPE;
778
779
780/** The module name length including the terminator. */
781#define PDMMOD_NAME_LEN 32
782
783/**
784 * Loaded module instance.
785 */
786typedef struct PDMMOD
787{
788 /** Module name. This is used for referring to
789 * the module internally, sort of like a handle. */
790 char szName[PDMMOD_NAME_LEN];
791 /** Module type. */
792 PDMMODTYPE eType;
793 /** Loader module handle. Not used for R0 modules. */
794 RTLDRMOD hLdrMod;
795 /** Loaded address.
796 * This is the 'handle' for R0 modules. */
797 RTUINTPTR ImageBase;
798 /** Old loaded address.
799 * This is used during relocation of GC modules. Not used for R0 modules. */
800 RTUINTPTR OldImageBase;
801 /** Where the R3 HC bits are stored.
802 * This can be equal to ImageBase but doesn't have to. Not used for R0 modules. */
803 void *pvBits;
804
805 /** Pointer to next module. */
806 struct PDMMOD *pNext;
807 /** Module filename. */
808 char szFilename[1];
809} PDMMOD;
810/** Pointer to loaded module instance. */
811typedef PDMMOD *PPDMMOD;
812
813
814
815/** Extra space in the free array. */
816#define PDMQUEUE_FREE_SLACK 16
817
818/**
819 * Queue type.
820 */
821typedef enum PDMQUEUETYPE
822{
823 /** Device consumer. */
824 PDMQUEUETYPE_DEV = 1,
825 /** Driver consumer. */
826 PDMQUEUETYPE_DRV,
827 /** Internal consumer. */
828 PDMQUEUETYPE_INTERNAL,
829 /** External consumer. */
830 PDMQUEUETYPE_EXTERNAL
831} PDMQUEUETYPE;
832
833/** Pointer to a PDM Queue. */
834typedef struct PDMQUEUE *PPDMQUEUE;
835
836/**
837 * PDM Queue.
838 */
839typedef struct PDMQUEUE
840{
841 /** Pointer to the next queue in the list. */
842 R3PTRTYPE(PPDMQUEUE) pNext;
843 /** Type specific data. */
844 union
845 {
846 /** PDMQUEUETYPE_DEV */
847 struct
848 {
849 /** Pointer to consumer function. */
850 R3PTRTYPE(PFNPDMQUEUEDEV) pfnCallback;
851 /** Pointer to the device instance owning the queue. */
852 R3PTRTYPE(PPDMDEVINS) pDevIns;
853 } Dev;
854 /** PDMQUEUETYPE_DRV */
855 struct
856 {
857 /** Pointer to consumer function. */
858 R3PTRTYPE(PFNPDMQUEUEDRV) pfnCallback;
859 /** Pointer to the driver instance owning the queue. */
860 R3PTRTYPE(PPDMDRVINS) pDrvIns;
861 } Drv;
862 /** PDMQUEUETYPE_INTERNAL */
863 struct
864 {
865 /** Pointer to consumer function. */
866 R3PTRTYPE(PFNPDMQUEUEINT) pfnCallback;
867 } Int;
868 /** PDMQUEUETYPE_EXTERNAL */
869 struct
870 {
871 /** Pointer to consumer function. */
872 R3PTRTYPE(PFNPDMQUEUEEXT) pfnCallback;
873 /** Pointer to user argument. */
874 R3PTRTYPE(void *) pvUser;
875 } Ext;
876 } u;
877 /** Queue type. */
878 PDMQUEUETYPE enmType;
879 /** The interval between checking the queue for events.
880 * The realtime timer below is used to do the waiting.
881 * If 0, the queue will use the VM_FF_PDM_QUEUE forced action. */
882 uint32_t cMilliesInterval;
883 /** Interval timer. Only used if cMilliesInterval is non-zero. */
884 PTMTIMERR3 pTimer;
885 /** Pointer to the VM - R3. */
886 PVMR3 pVMR3;
887 /** LIFO of pending items - R3. */
888 R3PTRTYPE(PPDMQUEUEITEMCORE) volatile pPendingR3;
889 /** Pointer to the VM - R0. */
890 PVMR0 pVMR0;
891 /** LIFO of pending items - R0. */
892 R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pPendingR0;
893 /** Pointer to the GC VM and indicator for GC enabled queue.
894 * If this is NULL, the queue cannot be used in GC.
895 */
896 PVMRC pVMRC;
897 /** LIFO of pending items - GC. */
898 RCPTRTYPE(PPDMQUEUEITEMCORE) volatile pPendingRC;
899
900 /** Item size (bytes). */
901 uint32_t cbItem;
902 /** Number of items in the queue. */
903 uint32_t cItems;
904 /** Index to the free head (where we insert). */
905 uint32_t volatile iFreeHead;
906 /** Index to the free tail (where we remove). */
907 uint32_t volatile iFreeTail;
908
909 /** Unique queue name. */
910 R3PTRTYPE(const char *) pszName;
911#if HC_ARCH_BITS == 32
912 RTR3PTR Alignment1;
913#endif
914 /** Stat: Times PDMQueueAlloc fails. */
915 STAMCOUNTER StatAllocFailures;
916 /** Stat: PDMQueueInsert calls. */
917 STAMCOUNTER StatInsert;
918 /** Stat: Queue flushes. */
919 STAMCOUNTER StatFlush;
920 /** Stat: Queue flushes with pending items left over. */
921 STAMCOUNTER StatFlushLeftovers;
922#ifdef VBOX_WITH_STATISTICS
923 /** State: Profiling the flushing. */
924 STAMPROFILE StatFlushPrf;
925 /** State: Pending items. */
926 uint32_t volatile cStatPending;
927 uint32_t volatile cAlignment;
928#endif
929
930 /** Array of pointers to free items. Variable size. */
931 struct PDMQUEUEFREEITEM
932 {
933 /** Pointer to the free item - HC Ptr. */
934 R3PTRTYPE(PPDMQUEUEITEMCORE) volatile pItemR3;
935 /** Pointer to the free item - HC Ptr. */
936 R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pItemR0;
937 /** Pointer to the free item - GC Ptr. */
938 RCPTRTYPE(PPDMQUEUEITEMCORE) volatile pItemRC;
939#if HC_ARCH_BITS == 64
940 RTRCPTR Alignment0;
941#endif
942 } aFreeItems[1];
943} PDMQUEUE;
944
945/** @name PDM::fQueueFlushing
946 * @{ */
947/** Used to make sure only one EMT will flush the queues.
948 * Set when an EMT is flushing queues, clear otherwise. */
949#define PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT 0
950/** Indicating there are queues with items pending.
951 * This is make sure we don't miss inserts happening during flushing. The FF
952 * cannot be used for this since it has to be cleared immediately to prevent
953 * other EMTs from spinning. */
954#define PDM_QUEUE_FLUSH_FLAG_PENDING_BIT 1
955/** @} */
956
957
958/**
959 * Queue device helper task operation.
960 */
961typedef enum PDMDEVHLPTASKOP
962{
963 /** The usual invalid 0 entry. */
964 PDMDEVHLPTASKOP_INVALID = 0,
965 /** ISASetIrq */
966 PDMDEVHLPTASKOP_ISA_SET_IRQ,
967 /** PCISetIrq */
968 PDMDEVHLPTASKOP_PCI_SET_IRQ,
969 /** PCISetIrq */
970 PDMDEVHLPTASKOP_IOAPIC_SET_IRQ,
971 /** The usual 32-bit hack. */
972 PDMDEVHLPTASKOP_32BIT_HACK = 0x7fffffff
973} PDMDEVHLPTASKOP;
974
975/**
976 * Queued Device Helper Task.
977 */
978typedef struct PDMDEVHLPTASK
979{
980 /** The queue item core (don't touch). */
981 PDMQUEUEITEMCORE Core;
982 /** Pointer to the device instance (R3 Ptr). */
983 PPDMDEVINSR3 pDevInsR3;
984 /** This operation to perform. */
985 PDMDEVHLPTASKOP enmOp;
986#if HC_ARCH_BITS == 64
987 uint32_t Alignment0;
988#endif
989 /** Parameters to the operation. */
990 union PDMDEVHLPTASKPARAMS
991 {
992 /**
993 * PDMDEVHLPTASKOP_ISA_SET_IRQ and PDMDEVHLPTASKOP_PCI_SET_IRQ.
994 */
995 struct PDMDEVHLPTASKSETIRQ
996 {
997 /** The IRQ */
998 int iIrq;
999 /** The new level. */
1000 int iLevel;
1001 /** The IRQ tag and source. */
1002 uint32_t uTagSrc;
1003 } SetIRQ;
1004
1005 /** Expanding the structure. */
1006 uint64_t au64[2];
1007 } u;
1008} PDMDEVHLPTASK;
1009/** Pointer to a queued Device Helper Task. */
1010typedef PDMDEVHLPTASK *PPDMDEVHLPTASK;
1011/** Pointer to a const queued Device Helper Task. */
1012typedef const PDMDEVHLPTASK *PCPDMDEVHLPTASK;
1013
1014
1015
1016/**
1017 * An USB hub registration record.
1018 */
1019typedef struct PDMUSBHUB
1020{
1021 /** The USB versions this hub support.
1022 * Note that 1.1 hubs can take on 2.0 devices. */
1023 uint32_t fVersions;
1024 /** The number of ports on the hub. */
1025 uint32_t cPorts;
1026 /** The number of available ports (0..cPorts). */
1027 uint32_t cAvailablePorts;
1028 /** The driver instance of the hub. */
1029 PPDMDRVINS pDrvIns;
1030 /** Copy of the to the registration structure. */
1031 PDMUSBHUBREG Reg;
1032
1033 /** Pointer to the next hub in the list. */
1034 struct PDMUSBHUB *pNext;
1035} PDMUSBHUB;
1036
1037/** Pointer to a const USB HUB registration record. */
1038typedef const PDMUSBHUB *PCPDMUSBHUB;
1039
1040/** Pointer to a PDM Async I/O template. */
1041typedef struct PDMASYNCCOMPLETIONTEMPLATE *PPDMASYNCCOMPLETIONTEMPLATE;
1042
1043/** Pointer to the main PDM Async completion endpoint class. */
1044typedef struct PDMASYNCCOMPLETIONEPCLASS *PPDMASYNCCOMPLETIONEPCLASS;
1045
1046/** Pointer to the global block cache structure. */
1047typedef struct PDMBLKCACHEGLOBAL *PPDMBLKCACHEGLOBAL;
1048
1049/**
1050 * PDM VMCPU Instance data.
1051 * Changes to this must checked against the padding of the pdm union in VMCPU!
1052 */
1053typedef struct PDMCPU
1054{
1055 /** The number of entries in the apQueuedCritSectsLeaves table that's currently
1056 * in use. */
1057 uint32_t cQueuedCritSectLeaves;
1058 uint32_t uPadding0; /**< Alignment padding.*/
1059 /** Critical sections queued in RC/R0 because of contention preventing leave to
1060 * complete. (R3 Ptrs)
1061 * We will return to Ring-3 ASAP, so this queue doesn't have to be very long. */
1062 R3PTRTYPE(PPDMCRITSECT) apQueuedCritSectLeaves[8];
1063
1064 /** The number of entries in the apQueuedCritSectRwExclLeaves table that's
1065 * currently in use. */
1066 uint32_t cQueuedCritSectRwExclLeaves;
1067 uint32_t uPadding1; /**< Alignment padding.*/
1068 /** Read/write critical sections queued in RC/R0 because of contention
1069 * preventing exclusive leave to complete. (R3 Ptrs)
1070 * We will return to Ring-3 ASAP, so this queue doesn't have to be very long. */
1071 R3PTRTYPE(PPDMCRITSECTRW) apQueuedCritSectRwExclLeaves[8];
1072
1073 /** The number of entries in the apQueuedCritSectsRwShrdLeaves table that's
1074 * currently in use. */
1075 uint32_t cQueuedCritSectRwShrdLeaves;
1076 uint32_t uPadding2; /**< Alignment padding.*/
1077 /** Read/write critical sections queued in RC/R0 because of contention
1078 * preventing shared leave to complete. (R3 Ptrs)
1079 * We will return to Ring-3 ASAP, so this queue doesn't have to be very long. */
1080 R3PTRTYPE(PPDMCRITSECTRW) apQueuedCritSectRwShrdLeaves[8];
1081} PDMCPU;
1082
1083
1084/**
1085 * PDM VM Instance data.
1086 * Changes to this must checked against the padding of the cfgm union in VM!
1087 */
1088typedef struct PDM
1089{
1090 /** The PDM lock.
1091 * This is used to protect everything that deals with interrupts, i.e.
1092 * the PIC, APIC, IOAPIC and PCI devices plus some PDM functions. */
1093 PDMCRITSECT CritSect;
1094 /** The NOP critical section.
1095 * This is a dummy critical section that will not do any thread
1096 * serialization but instead let all threads enter immediately and
1097 * concurrently. */
1098 PDMCRITSECT NopCritSect;
1099
1100 /** List of registered devices. (FIFO) */
1101 R3PTRTYPE(PPDMDEV) pDevs;
1102 /** List of devices instances. (FIFO) */
1103 R3PTRTYPE(PPDMDEVINS) pDevInstances;
1104 /** List of registered USB devices. (FIFO) */
1105 R3PTRTYPE(PPDMUSB) pUsbDevs;
1106 /** List of USB devices instances. (FIFO) */
1107 R3PTRTYPE(PPDMUSBINS) pUsbInstances;
1108 /** List of registered drivers. (FIFO) */
1109 R3PTRTYPE(PPDMDRV) pDrvs;
1110 /** The registered firmware device (can be NULL). */
1111 R3PTRTYPE(PPDMFW) pFirmware;
1112 /** PCI Buses. */
1113 PDMPCIBUS aPciBuses[PDM_PCI_BUSSES_MAX];
1114 /** The register PIC device. */
1115 PDMPIC Pic;
1116 /** The registered APIC device. */
1117 PDMAPIC Apic;
1118 /** The registered I/O APIC device. */
1119 PDMIOAPIC IoApic;
1120 /** The registered DMAC device. */
1121 R3PTRTYPE(PPDMDMAC) pDmac;
1122 /** The registered RTC device. */
1123 R3PTRTYPE(PPDMRTC) pRtc;
1124 /** The registered USB HUBs. (FIFO) */
1125 R3PTRTYPE(PPDMUSBHUB) pUsbHubs;
1126
1127 /** Queue in which devhlp tasks are queued for R3 execution - R3 Ptr. */
1128 R3PTRTYPE(PPDMQUEUE) pDevHlpQueueR3;
1129 /** Queue in which devhlp tasks are queued for R3 execution - R0 Ptr. */
1130 R0PTRTYPE(PPDMQUEUE) pDevHlpQueueR0;
1131 /** Queue in which devhlp tasks are queued for R3 execution - RC Ptr. */
1132 RCPTRTYPE(PPDMQUEUE) pDevHlpQueueRC;
1133 /** Pointer to the queue which should be manually flushed - RC Ptr.
1134 * Only touched by EMT. */
1135 RCPTRTYPE(struct PDMQUEUE *) pQueueFlushRC;
1136 /** Pointer to the queue which should be manually flushed - R0 Ptr.
1137 * Only touched by EMT. */
1138 R0PTRTYPE(struct PDMQUEUE *) pQueueFlushR0;
1139 /** Bitmask controlling the queue flushing.
1140 * See PDM_QUEUE_FLUSH_FLAG_ACTIVE and PDM_QUEUE_FLUSH_FLAG_PENDING. */
1141 uint32_t volatile fQueueFlushing;
1142
1143 /** The current IRQ tag (tracing purposes). */
1144 uint32_t volatile uIrqTag;
1145
1146 /** Pending reset flags (PDMVMRESET_F_XXX). */
1147 uint32_t volatile fResetFlags;
1148 /** Alignment padding. */
1149 uint32_t volatile u32Padding;
1150
1151 /** The tracing ID of the next device instance.
1152 *
1153 * @remarks We keep the device tracing ID seperate from the rest as these are
1154 * then more likely to end up with the same ID from one run to
1155 * another, making analysis somewhat easier. Drivers and USB devices
1156 * are more volatile and can be changed at runtime, thus these are much
1157 * less likely to remain stable, so just heap them all together. */
1158 uint32_t idTracingDev;
1159 /** The tracing ID of the next driver instance, USB device instance or other
1160 * PDM entity requiring an ID. */
1161 uint32_t idTracingOther;
1162
1163 /** @name VMM device heap
1164 * @{ */
1165 /** The heap size. */
1166 uint32_t cbVMMDevHeap;
1167 /** Free space. */
1168 uint32_t cbVMMDevHeapLeft;
1169 /** Pointer to the heap base (MMIO2 ring-3 mapping). NULL if not registered. */
1170 RTR3PTR pvVMMDevHeap;
1171 /** Ring-3 mapping/unmapping notification callback for the user. */
1172 PFNPDMVMMDEVHEAPNOTIFY pfnVMMDevHeapNotify;
1173 /** The current mapping. NIL_RTGCPHYS if not mapped or registered. */
1174 RTGCPHYS GCPhysVMMDevHeap;
1175 /** @} */
1176
1177 /** Number of times a critical section leave request needed to be queued for ring-3 execution. */
1178 STAMCOUNTER StatQueuedCritSectLeaves;
1179} PDM;
1180AssertCompileMemberAlignment(PDM, GCPhysVMMDevHeap, sizeof(RTGCPHYS));
1181AssertCompileMemberAlignment(PDM, CritSect, 8);
1182AssertCompileMemberAlignment(PDM, StatQueuedCritSectLeaves, 8);
1183/** Pointer to PDM VM instance data. */
1184typedef PDM *PPDM;
1185
1186
1187
1188/**
1189 * PDM data kept in the UVM.
1190 */
1191typedef struct PDMUSERPERVM
1192{
1193 /** @todo move more stuff over here. */
1194
1195 /** Linked list of timer driven PDM queues.
1196 * Currently serialized by PDM::CritSect. */
1197 R3PTRTYPE(struct PDMQUEUE *) pQueuesTimer;
1198 /** Linked list of force action driven PDM queues.
1199 * Currently serialized by PDM::CritSect. */
1200 R3PTRTYPE(struct PDMQUEUE *) pQueuesForced;
1201
1202 /** Lock protecting the lists below it. */
1203 RTCRITSECT ListCritSect;
1204 /** Pointer to list of loaded modules. */
1205 PPDMMOD pModules;
1206 /** List of initialized critical sections. (LIFO) */
1207 R3PTRTYPE(PPDMCRITSECTINT) pCritSects;
1208 /** List of initialized read/write critical sections. (LIFO) */
1209 R3PTRTYPE(PPDMCRITSECTRWINT) pRwCritSects;
1210 /** Head of the PDM Thread list. (singly linked) */
1211 R3PTRTYPE(PPDMTHREAD) pThreads;
1212 /** Tail of the PDM Thread list. (singly linked) */
1213 R3PTRTYPE(PPDMTHREAD) pThreadsTail;
1214
1215 /** @name PDM Async Completion
1216 * @{ */
1217 /** Pointer to the array of supported endpoint classes. */
1218 PPDMASYNCCOMPLETIONEPCLASS apAsyncCompletionEndpointClass[PDMASYNCCOMPLETIONEPCLASSTYPE_MAX];
1219 /** Head of the templates. Singly linked, protected by ListCritSect. */
1220 R3PTRTYPE(PPDMASYNCCOMPLETIONTEMPLATE) pAsyncCompletionTemplates;
1221 /** @} */
1222
1223 /** Global block cache data. */
1224 R3PTRTYPE(PPDMBLKCACHEGLOBAL) pBlkCacheGlobal;
1225#ifdef VBOX_WITH_NETSHAPER
1226 /** Pointer to network shaper instance. */
1227 R3PTRTYPE(PPDMNETSHAPER) pNetShaper;
1228#endif /* VBOX_WITH_NETSHAPER */
1229
1230} PDMUSERPERVM;
1231/** Pointer to the PDM data kept in the UVM. */
1232typedef PDMUSERPERVM *PPDMUSERPERVM;
1233
1234
1235
1236/*******************************************************************************
1237* Global Variables *
1238*******************************************************************************/
1239#ifdef IN_RING3
1240extern const PDMDRVHLPR3 g_pdmR3DrvHlp;
1241extern const PDMDEVHLPR3 g_pdmR3DevHlpTrusted;
1242extern const PDMDEVHLPR3 g_pdmR3DevHlpUnTrusted;
1243extern const PDMPICHLPR3 g_pdmR3DevPicHlp;
1244extern const PDMAPICHLPR3 g_pdmR3DevApicHlp;
1245extern const PDMIOAPICHLPR3 g_pdmR3DevIoApicHlp;
1246extern const PDMFWHLPR3 g_pdmR3DevFirmwareHlp;
1247extern const PDMPCIHLPR3 g_pdmR3DevPciHlp;
1248extern const PDMDMACHLP g_pdmR3DevDmacHlp;
1249extern const PDMRTCHLP g_pdmR3DevRtcHlp;
1250extern const PDMHPETHLPR3 g_pdmR3DevHpetHlp;
1251extern const PDMPCIRAWHLPR3 g_pdmR3DevPciRawHlp;
1252#endif
1253
1254
1255/*******************************************************************************
1256* Defined Constants And Macros *
1257*******************************************************************************/
1258/** @def PDMDEV_ASSERT_DEVINS
1259 * Asserts the validity of the device instance.
1260 */
1261#ifdef VBOX_STRICT
1262# define PDMDEV_ASSERT_DEVINS(pDevIns) \
1263 do { \
1264 AssertPtr(pDevIns); \
1265 Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
1266 Assert(pDevIns->CTX_SUFF(pvInstanceData) == (void *)&pDevIns->achInstanceData[0]); \
1267 } while (0)
1268#else
1269# define PDMDEV_ASSERT_DEVINS(pDevIns) do { } while (0)
1270#endif
1271
1272/** @def PDMDRV_ASSERT_DRVINS
1273 * Asserts the validity of the driver instance.
1274 */
1275#ifdef VBOX_STRICT
1276# define PDMDRV_ASSERT_DRVINS(pDrvIns) \
1277 do { \
1278 AssertPtr(pDrvIns); \
1279 Assert(pDrvIns->u32Version == PDM_DRVINS_VERSION); \
1280 Assert(pDrvIns->CTX_SUFF(pvInstanceData) == (void *)&pDrvIns->achInstanceData[0]); \
1281 } while (0)
1282#else
1283# define PDMDRV_ASSERT_DRVINS(pDrvIns) do { } while (0)
1284#endif
1285
1286
1287/*******************************************************************************
1288* Internal Functions *
1289*******************************************************************************/
1290#ifdef IN_RING3
1291bool pdmR3IsValidName(const char *pszName);
1292
1293int pdmR3CritSectBothInitStats(PVM pVM);
1294void pdmR3CritSectBothRelocate(PVM pVM);
1295int pdmR3CritSectBothDeleteDevice(PVM pVM, PPDMDEVINS pDevIns);
1296int pdmR3CritSectBothDeleteDriver(PVM pVM, PPDMDRVINS pDrvIns);
1297int pdmR3CritSectInitDevice( PVM pVM, PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
1298 const char *pszNameFmt, va_list va);
1299int pdmR3CritSectInitDeviceAuto( PVM pVM, PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
1300 const char *pszNameFmt, ...);
1301int pdmR3CritSectInitDriver( PVM pVM, PPDMDRVINS pDrvIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
1302 const char *pszNameFmt, ...);
1303int pdmR3CritSectRwInitDevice( PVM pVM, PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
1304 const char *pszNameFmt, va_list va);
1305int pdmR3CritSectRwInitDeviceAuto( PVM pVM, PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
1306 const char *pszNameFmt, ...);
1307int pdmR3CritSectRwInitDriver( PVM pVM, PPDMDRVINS pDrvIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
1308 const char *pszNameFmt, ...);
1309
1310int pdmR3DevInit(PVM pVM);
1311int pdmR3DevInitComplete(PVM pVM);
1312PPDMDEV pdmR3DevLookup(PVM pVM, const char *pszName);
1313int pdmR3DevFindLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMLUN *ppLun);
1314DECLCALLBACK(bool) pdmR3DevHlpQueueConsumer(PVM pVM, PPDMQUEUEITEMCORE pItem);
1315
1316int pdmR3UsbLoadModules(PVM pVM);
1317int pdmR3UsbInstantiateDevices(PVM pVM);
1318PPDMUSB pdmR3UsbLookup(PVM pVM, const char *pszName);
1319int pdmR3UsbRegisterHub(PVM pVM, PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp);
1320int pdmR3UsbVMInitComplete(PVM pVM);
1321
1322int pdmR3DrvInit(PVM pVM);
1323int pdmR3DrvInstantiate(PVM pVM, PCFGMNODE pNode, PPDMIBASE pBaseInterface, PPDMDRVINS pDrvAbove,
1324 PPDMLUN pLun, PPDMIBASE *ppBaseInterface);
1325int pdmR3DrvDetach(PPDMDRVINS pDrvIns, uint32_t fFlags);
1326void pdmR3DrvDestroyChain(PPDMDRVINS pDrvIns, uint32_t fFlags);
1327PPDMDRV pdmR3DrvLookup(PVM pVM, const char *pszName);
1328
1329int pdmR3LdrInitU(PUVM pUVM);
1330void pdmR3LdrTermU(PUVM pUVM);
1331char *pdmR3FileR3(const char *pszFile, bool fShared);
1332int pdmR3LoadR3U(PUVM pUVM, const char *pszFilename, const char *pszName);
1333
1334void pdmR3QueueRelocate(PVM pVM, RTGCINTPTR offDelta);
1335
1336int pdmR3ThreadCreateDevice(PVM pVM, PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
1337 PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
1338int pdmR3ThreadCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADUSB pfnThread,
1339 PFNPDMTHREADWAKEUPUSB pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
1340int pdmR3ThreadCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
1341 PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
1342int pdmR3ThreadDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);
1343int pdmR3ThreadDestroyUsb(PVM pVM, PPDMUSBINS pUsbIns);
1344int pdmR3ThreadDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns);
1345void pdmR3ThreadDestroyAll(PVM pVM);
1346int pdmR3ThreadResumeAll(PVM pVM);
1347int pdmR3ThreadSuspendAll(PVM pVM);
1348
1349#ifdef VBOX_WITH_PDM_ASYNC_COMPLETION
1350int pdmR3AsyncCompletionInit(PVM pVM);
1351int pdmR3AsyncCompletionTerm(PVM pVM);
1352void pdmR3AsyncCompletionResume(PVM pVM);
1353int pdmR3AsyncCompletionTemplateCreateDevice(PVM pVM, PPDMDEVINS pDevIns, PPPDMASYNCCOMPLETIONTEMPLATE ppTemplate, PFNPDMASYNCCOMPLETEDEV pfnCompleted, const char *pszDesc);
1354int pdmR3AsyncCompletionTemplateCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, PPPDMASYNCCOMPLETIONTEMPLATE ppTemplate,
1355 PFNPDMASYNCCOMPLETEDRV pfnCompleted, void *pvTemplateUser, const char *pszDesc);
1356int pdmR3AsyncCompletionTemplateCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, PPPDMASYNCCOMPLETIONTEMPLATE ppTemplate, PFNPDMASYNCCOMPLETEUSB pfnCompleted, const char *pszDesc);
1357int pdmR3AsyncCompletionTemplateDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);
1358int pdmR3AsyncCompletionTemplateDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns);
1359int pdmR3AsyncCompletionTemplateDestroyUsb(PVM pVM, PPDMUSBINS pUsbIns);
1360#endif
1361
1362#ifdef VBOX_WITH_NETSHAPER
1363int pdmR3NetShaperInit(PVM pVM);
1364int pdmR3NetShaperTerm(PVM pVM);
1365#endif
1366
1367int pdmR3BlkCacheInit(PVM pVM);
1368void pdmR3BlkCacheTerm(PVM pVM);
1369int pdmR3BlkCacheResume(PVM pVM);
1370
1371#endif /* IN_RING3 */
1372
1373void pdmLock(PVM pVM);
1374int pdmLockEx(PVM pVM, int rc);
1375void pdmUnlock(PVM pVM);
1376
1377#if defined(IN_RING3) || defined(IN_RING0)
1378void pdmCritSectRwLeaveSharedQueued(PPDMCRITSECTRW pThis);
1379void pdmCritSectRwLeaveExclQueued(PPDMCRITSECTRW pThis);
1380#endif
1381
1382/** @} */
1383
1384RT_C_DECLS_END
1385
1386#endif
1387
Note: See TracBrowser for help on using the repository browser.

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