VirtualBox

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

Last change on this file since 12975 was 12975, checked in by vboxsync, 16 years ago

#1865: PDMLdr.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 34.7 KB
Line 
1/* $Id: PDMInternal.h 12975 2008-10-03 22:22:37Z vboxsync $ */
2/** @file
3 * PDM - Internal header file.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#ifndef ___PDMInternal_h
23#define ___PDMInternal_h
24
25#include <VBox/cdefs.h>
26#include <VBox/types.h>
27#include <VBox/param.h>
28#include <VBox/cfgm.h>
29#include <VBox/stam.h>
30#include <VBox/vusb.h>
31#include <VBox/pdmasynccompletion.h>
32#include <iprt/critsect.h>
33#ifdef IN_RING3
34# include <iprt/thread.h>
35#endif
36
37__BEGIN_DECLS
38
39
40/** @defgroup grp_pdm_int Internal
41 * @ingroup grp_pdm
42 * @internal
43 * @{
44 */
45
46/*******************************************************************************
47* Structures and Typedefs *
48*******************************************************************************/
49
50/** Pointer to a PDM Device. */
51typedef struct PDMDEV *PPDMDEV;
52/** Pointer to a pointer to a PDM Device. */
53typedef PPDMDEV *PPPDMDEV;
54
55/** Pointer to a PDM USB Device. */
56typedef struct PDMUSB *PPDMUSB;
57/** Pointer to a pointer to a PDM USB Device. */
58typedef PPDMUSB *PPPDMUSB;
59
60/** Pointer to a PDM Driver. */
61typedef struct PDMDRV *PPDMDRV;
62/** Pointer to a pointer to a PDM Driver. */
63typedef PPDMDRV *PPPDMDRV;
64
65/** Pointer to a PDM Logical Unit. */
66typedef struct PDMLUN *PPDMLUN;
67/** Pointer to a pointer to a PDM Logical Unit. */
68typedef PPDMLUN *PPPDMLUN;
69
70/** Pointer to a PDM PCI Bus instance. */
71typedef struct PDMPCIBUS *PPDMPCIBUS;
72/** Pointer to a DMAC instance. */
73typedef struct PDMDMAC *PPDMDMAC;
74/** Pointer to a RTC instance. */
75typedef struct PDMRTC *PPDMRTC;
76
77/** Pointer to an USB HUB registration record. */
78typedef struct PDMUSBHUB *PPDMUSBHUB;
79
80/**
81 * Private device instance data.
82 */
83typedef struct PDMDEVINSINT
84{
85 /** Pointer to the next instance (HC Ptr).
86 * (Head is pointed to by PDM::pDevInstances.) */
87 R3PTRTYPE(PPDMDEVINS) pNextR3;
88 /** Pointer to the next per device instance (HC Ptr).
89 * (Head is pointed to by PDMDEV::pInstances.) */
90 R3PTRTYPE(PPDMDEVINS) pPerDeviceNextR3;
91 /** Pointer to device structure - HC Ptr. */
92 R3PTRTYPE(PPDMDEV) pDevR3;
93 /** Pointer to the list of logical units associated with the device. (FIFO) */
94 R3PTRTYPE(PPDMLUN) pLunsR3;
95 /** Configuration handle to the instance node. */
96 R3PTRTYPE(PCFGMNODE) pCfgHandle;
97
98 /** R3 pointer to the VM this instance was created for. */
99 PVMR3 pVMR3;
100 /** R3 pointer to associated PCI device structure. */
101 R3PTRTYPE(struct PCIDevice *) pPciDeviceR3;
102 /** R3 pointer to associated PCI bus structure. */
103 R3PTRTYPE(PPDMPCIBUS) pPciBusR3;
104
105 /** R0 pointer to the VM this instance was created for. */
106 PVMR0 pVMR0;
107 /** R0 pointer to associated PCI device structure. */
108 R0PTRTYPE(struct PCIDevice *) pPciDeviceR0;
109 /** R0 pointer to associated PCI bus structure. */
110 R0PTRTYPE(PPDMPCIBUS) pPciBusR0;
111 /** Alignment padding. */
112 RTR0PTR Alignment0;
113
114 /** RC pointer to the VM this instance was created for. */
115 PVMRC pVMRC;
116 /** RC pointer to associated PCI device structure. */
117 RCPTRTYPE(struct PCIDevice *) pPciDeviceRC;
118 /** RC pointer to associated PCI bus structure. */
119 RCPTRTYPE(PPDMPCIBUS) pPciBusRC;
120 /** Alignment padding. */
121 RTRCPTR Alignment1;
122} PDMDEVINSINT;
123
124
125/**
126 * Private USB device instance data.
127 */
128typedef struct PDMUSBINSINT
129{
130 /** The UUID of this instance. */
131 RTUUID Uuid;
132 /** Pointer to the next instance.
133 * (Head is pointed to by PDM::pUsbInstances.) */
134 R3PTRTYPE(PPDMUSBINS) pNext;
135 /** Pointer to the next per USB device instance.
136 * (Head is pointed to by PDMUSB::pInstances.) */
137 R3PTRTYPE(PPDMUSBINS) pPerDeviceNext;
138
139 /** Pointer to device structure. */
140 R3PTRTYPE(PPDMUSB) pUsbDev;
141
142 /** Pointer to the VM this instance was created for. */
143 PVMR3 pVM;
144 /** Pointer to the list of logical units associated with the device. (FIFO) */
145 R3PTRTYPE(PPDMLUN) pLuns;
146 /** The per instance device configuration. */
147 R3PTRTYPE(PCFGMNODE) pCfg;
148 /** Same as pCfg if the configuration should be deleted when detaching the device. */
149 R3PTRTYPE(PCFGMNODE) pCfgDelete;
150 /** The global device configuration. */
151 R3PTRTYPE(PCFGMNODE) pCfgGlobal;
152
153 /** Pointer to the USB hub this device is attached to.
154 * This is NULL if the device isn't connected to any HUB. */
155 R3PTRTYPE(PPDMUSBHUB) pHub;
156 /** The port number that we're connected to. */
157 uint32_t iPort;
158#if HC_ARCH_BITS == 64
159 uint32_t Alignment0;
160#endif
161} PDMUSBINSINT;
162
163
164/**
165 * Private driver instance data.
166 */
167typedef struct PDMDRVINSINT
168{
169 /** Pointer to the driver instance above.
170 * This is NULL for the topmost drive. */
171 PPDMDRVINS pUp;
172 /** Pointer to the driver instance below.
173 * This is NULL for the bottommost driver. */
174 PPDMDRVINS pDown;
175 /** Pointer to the logical unit this driver chained on. */
176 PPDMLUN pLun;
177 /** Pointer to driver structure from which this was instantiated. */
178 PPDMDRV pDrv;
179 /** Pointer to the VM this instance was created for. */
180 PVM pVM;
181 /** Flag indicating that the driver is being detached and destroyed.
182 * (Helps detect potential recursive detaching.) */
183 bool fDetaching;
184 /** Configuration handle to the instance node. */
185 PCFGMNODE pCfgHandle;
186
187} PDMDRVINSINT;
188
189
190/**
191 * Private critical section data.
192 */
193typedef struct PDMCRITSECTINT
194{
195 /** The critical section core which is shared with IPRT. */
196 RTCRITSECT Core;
197 /** Pointer to the next critical section.
198 * This chain is used for relocating pVMGC and device cleanup. */
199 R3PTRTYPE(struct PDMCRITSECTINT *) pNext;
200 /** Owner identifier.
201 * This is pDevIns if the owner is a device. Similarily for a driver or service.
202 * PDMR3CritSectInit() sets this to point to the critsect itself. */
203 RTR3PTR pvKey;
204 /** Pointer to the VM - R3Ptr. */
205 R3PTRTYPE(PVM) pVMR3;
206 /** Pointer to the VM - R0Ptr. */
207 R0PTRTYPE(PVM) pVMR0;
208 /** Pointer to the VM - GCPtr. */
209 RCPTRTYPE(PVM) pVMGC;
210#if HC_ARCH_BITS == 64
211 uint32_t padding;
212#endif
213 /** Event semaphore that is scheduled to be signaled upon leaving the
214 * critical section. This is Ring-3 only of course. */
215 RTSEMEVENT EventToSignal;
216 /** R0/GC lock contention. */
217 STAMCOUNTER StatContentionR0GCLock;
218 /** R0/GC unlock contention. */
219 STAMCOUNTER StatContentionR0GCUnlock;
220 /** R3 lock contention. */
221 STAMCOUNTER StatContentionR3;
222 /** Profiling the time the section is locked. */
223 STAMPROFILEADV StatLocked;
224} PDMCRITSECTINT, *PPDMCRITSECTINT;
225
226
227/**
228 * The usual device/driver/internal/external stuff.
229 */
230typedef enum
231{
232 /** The usual invalid entry. */
233 PDMTHREADTYPE_INVALID = 0,
234 /** Device type. */
235 PDMTHREADTYPE_DEVICE,
236 /** USB Device type. */
237 PDMTHREADTYPE_USB,
238 /** Driver type. */
239 PDMTHREADTYPE_DRIVER,
240 /** Internal type. */
241 PDMTHREADTYPE_INTERNAL,
242 /** External type. */
243 PDMTHREADTYPE_EXTERNAL,
244 /** The usual 32-bit hack. */
245 PDMTHREADTYPE_32BIT_HACK = 0x7fffffff
246} PDMTHREADTYPE;
247
248
249/**
250 * The internal structure for the thread.
251 */
252typedef struct PDMTHREADINT
253{
254 /** The VM pointer. */
255 PVMR3 pVM;
256 /** The event semaphore the thread blocks on when not running. */
257 RTSEMEVENTMULTI BlockEvent;
258 /** The event semaphore the thread sleeps on while running. */
259 RTSEMEVENTMULTI SleepEvent;
260 /** Pointer to the next thread. */
261 R3PTRTYPE(struct PDMTHREAD *) pNext;
262 /** The thread type. */
263 PDMTHREADTYPE enmType;
264} PDMTHREADINT;
265
266
267
268/* Must be included after PDMDEVINSINT is defined. */
269#define PDMDEVINSINT_DECLARED
270#define PDMUSBINSINT_DECLARED
271#define PDMDRVINSINT_DECLARED
272#define PDMCRITSECTINT_DECLARED
273#define PDMTHREADINT_DECLARED
274#ifdef ___VBox_pdm_h
275# error "Invalid header PDM order. Include PDMInternal.h before VBox/pdm.h!"
276#endif
277__END_DECLS
278#include <VBox/pdm.h>
279__BEGIN_DECLS
280
281/**
282 * PDM Logical Unit.
283 *
284 * This typically the representation of a physical port on a
285 * device, like for instance the PS/2 keyboard port on the
286 * keyboard controller device. The LUNs are chained on the
287 * device the belong to (PDMDEVINSINT::pLunsR3).
288 */
289typedef struct PDMLUN
290{
291 /** The LUN - The Logical Unit Number. */
292 RTUINT iLun;
293 /** Pointer to the next LUN. */
294 PPDMLUN pNext;
295 /** Pointer to the top driver in the driver chain. */
296 PPDMDRVINS pTop;
297 /** Pointer to the bottom driver in the driver chain. */
298 PPDMDRVINS pBottom;
299 /** Pointer to the device instance which the LUN belongs to.
300 * Either this is set or pUsbIns is set. Both is never set at the same time. */
301 PPDMDEVINS pDevIns;
302 /** Pointer to the USB device instance which the LUN belongs to. */
303 PPDMUSBINS pUsbIns;
304 /** Pointer to the device base interface. */
305 PPDMIBASE pBase;
306 /** Description of this LUN. */
307 const char *pszDesc;
308} PDMLUN;
309
310
311/**
312 * PDM Device.
313 */
314typedef struct PDMDEV
315{
316 /** Pointer to the next device (HC Ptr). */
317 R3PTRTYPE(PPDMDEV) pNext;
318 /** Device name length. (search optimization) */
319 RTUINT cchName;
320 /** Registration structure. */
321 R3PTRTYPE(const struct PDMDEVREG *) pDevReg;
322 /** Number of instances. */
323 RTUINT cInstances;
324 /** Pointer to chain of instances (HC Ptr). */
325 R3PTRTYPE(PPDMDEVINS) pInstances;
326} PDMDEV;
327
328
329/**
330 * PDM USB Device.
331 */
332typedef struct PDMUSB
333{
334 /** Pointer to the next device (R3 Ptr). */
335 R3PTRTYPE(PPDMUSB) pNext;
336 /** Device name length. (search optimization) */
337 RTUINT cchName;
338 /** Registration structure. */
339 R3PTRTYPE(const struct PDMUSBREG *) pUsbReg;
340 /** Next instance number. */
341 RTUINT iNextInstance;
342 /** Pointer to chain of instances (R3 Ptr). */
343 R3PTRTYPE(PPDMUSBINS) pInstances;
344} PDMUSB;
345
346
347/**
348 * PDM Driver.
349 */
350typedef struct PDMDRV
351{
352 /** Pointer to the next device. */
353 PPDMDRV pNext;
354 /** Registration structure. */
355 const struct PDMDRVREG * pDrvReg;
356 /** Number of instances. */
357 RTUINT cInstances;
358} PDMDRV;
359
360
361/**
362 * PDM registered PIC device.
363 */
364typedef struct PDMPIC
365{
366 /** Pointer to the PIC device instance - R3. */
367 R3PTRTYPE(PPDMDEVINS) pDevInsR3;
368 /** @copydoc PDMPICREG::pfnSetIrqR3 */
369 DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
370 /** @copydoc PDMPICREG::pfnGetInterruptR3 */
371 DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns));
372
373 /** Pointer to the PIC device instance - R0. */
374 R0PTRTYPE(PPDMDEVINS) pDevInsR0;
375 /** @copydoc PDMPICREG::pfnSetIrqR3 */
376 DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
377 /** @copydoc PDMPICREG::pfnGetInterruptR3 */
378 DECLR0CALLBACKMEMBER(int, pfnGetInterruptR0,(PPDMDEVINS pDevIns));
379
380 /** Pointer to the PIC device instance - RC. */
381 RCPTRTYPE(PPDMDEVINS) pDevInsRC;
382 /** @copydoc PDMPICREG::pfnSetIrqR3 */
383 DECLRCCALLBACKMEMBER(void, pfnSetIrqRC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
384 /** @copydoc PDMPICREG::pfnGetInterruptR3 */
385 DECLRCCALLBACKMEMBER(int, pfnGetInterruptRC,(PPDMDEVINS pDevIns));
386 /** Alignment padding. */
387 RTRCPTR RCPtrPadding;
388} PDMPIC;
389
390
391/**
392 * PDM registered APIC device.
393 */
394typedef struct PDMAPIC
395{
396 /** Pointer to the APIC device instance - R3 Ptr. */
397 PPDMDEVINSR3 pDevInsR3;
398 /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
399 DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns));
400 /** @copydoc PDMAPICREG::pfnHasPendingIrqR3 */
401 DECLR3CALLBACKMEMBER(bool, pfnHasPendingIrqR3,(PPDMDEVINS pDevIns));
402 /** @copydoc PDMAPICREG::pfnSetBaseR3 */
403 DECLR3CALLBACKMEMBER(void, pfnSetBaseR3,(PPDMDEVINS pDevIns, uint64_t u64Base));
404 /** @copydoc PDMAPICREG::pfnGetBaseR3 */
405 DECLR3CALLBACKMEMBER(uint64_t, pfnGetBaseR3,(PPDMDEVINS pDevIns));
406 /** @copydoc PDMAPICREG::pfnSetTPRR3 */
407 DECLR3CALLBACKMEMBER(void, pfnSetTPRR3,(PPDMDEVINS pDevIns, uint8_t u8TPR));
408 /** @copydoc PDMAPICREG::pfnGetTPRR3 */
409 DECLR3CALLBACKMEMBER(uint8_t, pfnGetTPRR3,(PPDMDEVINS pDevIns));
410 /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
411 DECLR3CALLBACKMEMBER(void, pfnBusDeliverR3,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
412 uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
413
414 /** Pointer to the APIC device instance - R0. */
415 R0PTRTYPE(PPDMDEVINS) pDevInsR0;
416 /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
417 DECLR0CALLBACKMEMBER(int, pfnGetInterruptR0,(PPDMDEVINS pDevIns));
418 /** @copydoc PDMAPICREG::pfnHasPendingIrqR3 */
419 DECLR0CALLBACKMEMBER(bool, pfnHasPendingIrqR0,(PPDMDEVINS pDevIns));
420 /** @copydoc PDMAPICREG::pfnSetBaseR3 */
421 DECLR0CALLBACKMEMBER(void, pfnSetBaseR0,(PPDMDEVINS pDevIns, uint64_t u64Base));
422 /** @copydoc PDMAPICREG::pfnGetBaseR3 */
423 DECLR0CALLBACKMEMBER(uint64_t, pfnGetBaseR0,(PPDMDEVINS pDevIns));
424 /** @copydoc PDMAPICREG::pfnSetTPRR3 */
425 DECLR0CALLBACKMEMBER(void, pfnSetTPRR0,(PPDMDEVINS pDevIns, uint8_t u8TPR));
426 /** @copydoc PDMAPICREG::pfnGetTPRR3 */
427 DECLR0CALLBACKMEMBER(uint8_t, pfnGetTPRR0,(PPDMDEVINS pDevIns));
428 /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
429 DECLR0CALLBACKMEMBER(void, pfnBusDeliverR0,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
430 uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
431
432 /** Pointer to the APIC device instance - RC Ptr. */
433 PPDMDEVINSRC pDevInsRC;
434 /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
435 DECLRCCALLBACKMEMBER(int, pfnGetInterruptRC,(PPDMDEVINS pDevIns));
436 /** @copydoc PDMAPICREG::pfnHasPendingIrqR3 */
437 DECLRCCALLBACKMEMBER(bool, pfnHasPendingIrqRC,(PPDMDEVINS pDevIns));
438 /** @copydoc PDMAPICREG::pfnSetBaseR3 */
439 DECLRCCALLBACKMEMBER(void, pfnSetBaseRC,(PPDMDEVINS pDevIns, uint64_t u64Base));
440 /** @copydoc PDMAPICREG::pfnGetBaseR3 */
441 DECLRCCALLBACKMEMBER(uint64_t, pfnGetBaseRC,(PPDMDEVINS pDevIns));
442 /** @copydoc PDMAPICREG::pfnSetTPRR3 */
443 DECLRCCALLBACKMEMBER(void, pfnSetTPRRC,(PPDMDEVINS pDevIns, uint8_t u8TPR));
444 /** @copydoc PDMAPICREG::pfnGetTPRR3 */
445 DECLRCCALLBACKMEMBER(uint8_t, pfnGetTPRRC,(PPDMDEVINS pDevIns));
446 /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
447 DECLRCCALLBACKMEMBER(void, pfnBusDeliverRC,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
448 uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
449} PDMAPIC;
450
451
452/**
453 * PDM registered I/O APIC device.
454 */
455typedef struct PDMIOAPIC
456{
457 /** Pointer to the APIC device instance - R3 Ptr. */
458 PPDMDEVINSR3 pDevInsR3;
459 /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
460 DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
461
462 /** Pointer to the PIC device instance - R0. */
463 R0PTRTYPE(PPDMDEVINS) pDevInsR0;
464 /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
465 DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
466
467 /** Pointer to the APIC device instance - RC Ptr. */
468 PPDMDEVINSRC pDevInsRC;
469 /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
470 DECLRCCALLBACKMEMBER(void, pfnSetIrqRC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
471} PDMIOAPIC;
472
473
474/**
475 * PDM PCI Bus instance.
476 */
477typedef struct PDMPCIBUS
478{
479 /** PCI bus number. */
480 RTUINT iBus;
481 RTUINT uPadding0; /**< Alignment padding.*/
482
483 /** Pointer to PCI Bus device instance. */
484 PPDMDEVINSR3 pDevInsR3;
485 /** @copydoc PDMPCIBUSREG::pfnSetIrqR3 */
486 DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
487 /** @copydoc PDMPCIBUSREG::pfnRegisterR3 */
488 DECLR3CALLBACKMEMBER(int, pfnRegisterR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, const char *pszName, int iDev));
489 /** @copydoc PDMPCIBUSREG::pfnIORegionRegisterR3 */
490 DECLR3CALLBACKMEMBER(int, pfnIORegionRegisterR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iRegion, uint32_t cbRegion,
491 PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback));
492 /** @copydoc PDMPCIBUSREG::pfnSetConfigCallbacksR3 */
493 DECLR3CALLBACKMEMBER(void, pfnSetConfigCallbacksR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PFNPCICONFIGREAD pfnRead,
494 PPFNPCICONFIGREAD ppfnReadOld, PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld));
495 /** @copydoc PDMPCIBUSREG::pfnSaveExecR3 */
496 DECLR3CALLBACKMEMBER(int, pfnSaveExecR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSMHandle));
497 /** @copydoc PDMPCIBUSREG::pfnLoadExecR3 */
498 DECLR3CALLBACKMEMBER(int, pfnLoadExecR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSMHandle));
499 /** @copydoc PDMPCIBUSREG::pfnFakePCIBIOSR3 */
500 DECLR3CALLBACKMEMBER(int, pfnFakePCIBIOSR3,(PPDMDEVINS pDevIns));
501
502 /** Pointer to the PIC device instance - R0. */
503 R0PTRTYPE(PPDMDEVINS) pDevInsR0;
504 /** @copydoc PDMPCIBUSREG::pfnSetIrqR3 */
505 DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
506
507 /** Pointer to PCI Bus device instance. */
508 PPDMDEVINSRC pDevInsRC;
509 /** @copydoc PDMPCIBUSREG::pfnSetIrqR3 */
510 DECLRCCALLBACKMEMBER(void, pfnSetIrqRC,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
511} PDMPCIBUS;
512
513
514#ifdef IN_RING3
515/**
516 * PDM registered DMAC (DMA Controller) device.
517 */
518typedef struct PDMDMAC
519{
520 /** Pointer to the DMAC device instance. */
521 PPDMDEVINS pDevIns;
522 /** Copy of the registration structure. */
523 PDMDMACREG Reg;
524} PDMDMAC;
525
526
527/**
528 * PDM registered RTC (Real Time Clock) device.
529 */
530typedef struct PDMRTC
531{
532 /** Pointer to the RTC device instance. */
533 PPDMDEVINS pDevIns;
534 /** Copy of the registration structure. */
535 PDMRTCREG Reg;
536} PDMRTC;
537
538#endif /* IN_RING3 */
539
540/**
541 * Module type.
542 */
543typedef enum PDMMODTYPE
544{
545 /** Raw-mode (RC) context module. */
546 PDMMOD_TYPE_RC,
547 /** Ring-0 (host) context module. */
548 PDMMOD_TYPE_R0,
549 /** Ring-3 (host) context module. */
550 PDMMOD_TYPE_R3
551} PDMMODTYPE, *PPDMMODTYPE;
552
553
554/** The module name length including the terminator. */
555#define PDMMOD_NAME_LEN 32
556
557/**
558 * Loaded module instance.
559 */
560typedef struct PDMMOD
561{
562 /** Module name. This is used for refering to
563 * the module internally, sort of like a handle. */
564 char szName[PDMMOD_NAME_LEN];
565 /** Module type. */
566 PDMMODTYPE eType;
567 /** Loader module handle. Not used for R0 modules. */
568 RTLDRMOD hLdrMod;
569 /** Loaded address.
570 * This is the 'handle' for R0 modules. */
571 RTUINTPTR ImageBase;
572 /** Old loaded address.
573 * This is used during relocation of GC modules. Not used for R0 modules. */
574 RTUINTPTR OldImageBase;
575 /** Where the R3 HC bits are stored.
576 * This can be equal to ImageBase but doesn't have to. Not used for R0 modules. */
577 void *pvBits;
578
579 /** Pointer to next module. */
580 struct PDMMOD *pNext;
581 /** Module filename. */
582 char szFilename[1];
583} PDMMOD;
584/** Pointer to loaded module instance. */
585typedef PDMMOD *PPDMMOD;
586
587
588
589/** Extra space in the free array. */
590#define PDMQUEUE_FREE_SLACK 16
591
592/**
593 * Queue type.
594 */
595typedef enum PDMQUEUETYPE
596{
597 /** Device consumer. */
598 PDMQUEUETYPE_DEV = 1,
599 /** Driver consumer. */
600 PDMQUEUETYPE_DRV,
601 /** Internal consumer. */
602 PDMQUEUETYPE_INTERNAL,
603 /** External consumer. */
604 PDMQUEUETYPE_EXTERNAL
605} PDMQUEUETYPE;
606
607/** Pointer to a PDM Queue. */
608typedef struct PDMQUEUE *PPDMQUEUE;
609
610/**
611 * PDM Queue.
612 */
613typedef struct PDMQUEUE
614{
615 /** Pointer to the next queue in the list. */
616 R3PTRTYPE(PPDMQUEUE) pNext;
617 /** Type specific data. */
618 union
619 {
620 /** PDMQUEUETYPE_DEV */
621 struct
622 {
623 /** Pointer to consumer function. */
624 R3PTRTYPE(PFNPDMQUEUEDEV) pfnCallback;
625 /** Pointer to the device instance owning the queue. */
626 R3PTRTYPE(PPDMDEVINS) pDevIns;
627 } Dev;
628 /** PDMQUEUETYPE_DRV */
629 struct
630 {
631 /** Pointer to consumer function. */
632 R3PTRTYPE(PFNPDMQUEUEDRV) pfnCallback;
633 /** Pointer to the driver instance owning the queue. */
634 R3PTRTYPE(PPDMDRVINS) pDrvIns;
635 } Drv;
636 /** PDMQUEUETYPE_INTERNAL */
637 struct
638 {
639 /** Pointer to consumer function. */
640 R3PTRTYPE(PFNPDMQUEUEINT) pfnCallback;
641 } Int;
642 /** PDMQUEUETYPE_EXTERNAL */
643 struct
644 {
645 /** Pointer to consumer function. */
646 R3PTRTYPE(PFNPDMQUEUEEXT) pfnCallback;
647 /** Pointer to user argument. */
648 R3PTRTYPE(void *) pvUser;
649 } Ext;
650 } u;
651 /** Queue type. */
652 PDMQUEUETYPE enmType;
653 /** The interval between checking the queue for events.
654 * The realtime timer below is used to do the waiting.
655 * If 0, the queue will use the VM_FF_PDM_QUEUE forced action. */
656 uint32_t cMilliesInterval;
657 /** Interval timer. Only used if cMilliesInterval is non-zero. */
658 PTMTIMERR3 pTimer;
659 /** Pointer to the VM. */
660 R3R0PTRTYPE(PVM) pVMHC;
661 /** LIFO of pending items - HC. */
662 R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pPendingHC;
663 /** Pointer to the GC VM and indicator for GC enabled queue.
664 * If this is NULL, the queue cannot be used in GC.
665 */
666 RCPTRTYPE(PVM) pVMGC;
667 /** LIFO of pending items - GC. */
668 RCPTRTYPE(PPDMQUEUEITEMCORE) pPendingGC;
669 /** Item size (bytes). */
670 RTUINT cbItem;
671 /** Number of items in the queue. */
672 RTUINT cItems;
673 /** Index to the free head (where we insert). */
674 uint32_t volatile iFreeHead;
675 /** Index to the free tail (where we remove). */
676 uint32_t volatile iFreeTail;
677 /** Array of pointers to free items. Variable size. */
678 struct PDMQUEUEFREEITEM
679 {
680 /** Pointer to the free item - HC Ptr. */
681 R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pItemHC;
682 /** Pointer to the free item - GC Ptr. */
683 RCPTRTYPE(PPDMQUEUEITEMCORE) volatile pItemGC;
684#if HC_ARCH_BITS == 64
685 uint32_t Alignment0;
686#endif
687 } aFreeItems[1];
688} PDMQUEUE;
689
690
691/**
692 * Queue device helper task operation.
693 */
694typedef enum PDMDEVHLPTASKOP
695{
696 /** The usual invalid 0 entry. */
697 PDMDEVHLPTASKOP_INVALID = 0,
698 /** ISASetIrq */
699 PDMDEVHLPTASKOP_ISA_SET_IRQ,
700 /** PCISetIrq */
701 PDMDEVHLPTASKOP_PCI_SET_IRQ,
702 /** PCISetIrq */
703 PDMDEVHLPTASKOP_IOAPIC_SET_IRQ,
704 /** The usual 32-bit hack. */
705 PDMDEVHLPTASKOP_32BIT_HACK = 0x7fffffff
706} PDMDEVHLPTASKOP;
707
708/**
709 * Queued Device Helper Task.
710 */
711typedef struct PDMDEVHLPTASK
712{
713 /** The queue item core (don't touch). */
714 PDMQUEUEITEMCORE Core;
715 /** Pointer to the device instance (HC Ptr). */
716 R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
717 /** This operation to perform. */
718 PDMDEVHLPTASKOP enmOp;
719#if HC_ARCH_BITS == 64
720 uint32_t Alignment0;
721#endif
722 /** Parameters to the operation. */
723 union PDMDEVHLPTASKPARAMS
724 {
725 /**
726 * PDMDEVHLPTASKOP_ISA_SET_IRQ and PDMDEVHLPTASKOP_PCI_SET_IRQ.
727 */
728 struct PDMDEVHLPTASKSETIRQ
729 {
730 /** The IRQ */
731 int iIrq;
732 /** The new level. */
733 int iLevel;
734 } SetIRQ;
735 } u;
736} PDMDEVHLPTASK;
737/** Pointer to a queued Device Helper Task. */
738typedef PDMDEVHLPTASK *PPDMDEVHLPTASK;
739/** Pointer to a const queued Device Helper Task. */
740typedef const PDMDEVHLPTASK *PCPDMDEVHLPTASK;
741
742
743
744/**
745 * An USB hub registration record.
746 */
747typedef struct PDMUSBHUB
748{
749 /** The USB versions this hub support.
750 * Note that 1.1 hubs can take on 2.0 devices. */
751 uint32_t fVersions;
752 /** The number of ports on the hub. */
753 uint32_t cPorts;
754 /** The number of available ports (0..cPorts). */
755 uint32_t cAvailablePorts;
756 /** The driver instance of the hub. */
757 PPDMDRVINS pDrvIns;
758 /** Copy of the to the registration structure. */
759 PDMUSBHUBREG Reg;
760
761 /** Pointer to the next hub in the list. */
762 struct PDMUSBHUB *pNext;
763} PDMUSBHUB;
764
765/** Pointer to a const USB HUB registration record. */
766typedef const PDMUSBHUB *PCPDMUSBHUB;
767
768/** Pointer to a PDM Async I/O template. */
769typedef struct PDMASYNCCOMPLETIONTEMPLATE *PPDMASYNCCOMPLETIONTEMPLATE;
770
771/** Pointer to the main PDM Async completion structure. */
772typedef struct PDMASYNCCOMPLETIONMANAGER *PPDMASYNCCOMPLETIONMANAGER;
773
774/**
775 * Converts a PDM pointer into a VM pointer.
776 * @returns Pointer to the VM structure the PDM is part of.
777 * @param pPDM Pointer to PDM instance data.
778 */
779#define PDM2VM(pPDM) ( (PVM)((char*)pPDM - pPDM->offVM) )
780
781
782/**
783 * PDM VM Instance data.
784 * Changes to this must checked against the padding of the cfgm union in VM!
785 */
786typedef struct PDM
787{
788 /** Offset to the VM structure.
789 * See PDM2VM(). */
790 RTUINT offVM;
791 RTUINT uPadding0; /**< Alignment padding.*/
792
793 /** List of registered devices. (FIFO) */
794 R3PTRTYPE(PPDMDEV) pDevs;
795 /** List of devices instances. (FIFO) */
796 R3PTRTYPE(PPDMDEVINS) pDevInstances;
797 /** List of registered USB devices. (FIFO) */
798 R3PTRTYPE(PPDMUSB) pUsbDevs;
799 /** List of USB devices instances. (FIFO) */
800 R3PTRTYPE(PPDMUSBINS) pUsbInstances;
801 /** List of registered drivers. (FIFO) */
802 R3PTRTYPE(PPDMDRV) pDrvs;
803 /** List of initialized critical sections. (LIFO) */
804 R3PTRTYPE(PPDMCRITSECTINT) pCritSects;
805 /** PCI Buses. */
806 PDMPCIBUS aPciBuses[1];
807 /** The register PIC device. */
808 PDMPIC Pic;
809 /** The registerd APIC device. */
810 PDMAPIC Apic;
811 /** The registerd I/O APIC device. */
812 PDMIOAPIC IoApic;
813 /** The registered DMAC device. */
814 R3PTRTYPE(PPDMDMAC) pDmac;
815 /** The registered RTC device. */
816 R3PTRTYPE(PPDMRTC) pRtc;
817 /** The registered USB HUBs. (FIFO) */
818 R3PTRTYPE(PPDMUSBHUB) pUsbHubs;
819
820 /** Queue in which devhlp tasks are queued for R3 execution - HC Ptr. */
821 R3R0PTRTYPE(PPDMQUEUE) pDevHlpQueueHC;
822 /** Queue in which devhlp tasks are queued for R3 execution - GC Ptr. */
823 RCPTRTYPE(PPDMQUEUE) pDevHlpQueueGC;
824
825 /** The number of entries in the apQueuedCritSectsLeaves table that's currnetly in use. */
826 RTUINT cQueuedCritSectLeaves;
827 /** Critical sections queued in GC/R0 because of contention preventing leave to complete. (R3 Ptrs)
828 * We will return to Ring-3 ASAP, so this queue doesn't has to be very long. */
829 R3PTRTYPE(PPDMCRITSECT) apQueuedCritSectsLeaves[8];
830
831 /** Linked list of timer driven PDM queues. */
832 R3PTRTYPE(struct PDMQUEUE *) pQueuesTimer;
833 /** Linked list of force action driven PDM queues. */
834 R3PTRTYPE(struct PDMQUEUE *) pQueuesForced;
835 /** Pointer to the queue which should be manually flushed - HCPtr.
836 * Only touched by EMT. */
837 R3R0PTRTYPE(struct PDMQUEUE *) pQueueFlushHC;
838 /** Pointer to the queue which should be manually flushed - GCPtr. */
839 RCPTRTYPE(struct PDMQUEUE *) pQueueFlushGC;
840#if HC_ARCH_BITS == 64
841 uint32_t padding0;
842#endif
843
844 /** Head of the PDM Thread list. (singly linked) */
845 R3PTRTYPE(PPDMTHREAD) pThreads;
846 /** Tail of the PDM Thread list. (singly linked) */
847 R3PTRTYPE(PPDMTHREAD) pThreadsTail;
848
849 /** Head of the asychronous tasks managers. (singly linked) */
850 R3PTRTYPE(PPDMASYNCCOMPLETIONMANAGER) pAsyncCompletionManagerHead;
851 /** Head of the templates. (singly linked) */
852 R3PTRTYPE(PPDMASYNCCOMPLETIONTEMPLATE) pAsyncCompletionTemplates;
853
854 /** @name VMM device heap
855 * @{ */
856 /** Pointer to the heap base (MMIO2 ring-3 mapping). NULL if not registered. */
857 RTR3PTR pvVMMDevHeap;
858 /** The heap size. */
859 RTUINT cbVMMDevHeap;
860 /** Free space. */
861 RTUINT cbVMMDevHeapLeft;
862 /** The current mapping. NIL_RTGCPHYS if not mapped or registered. */
863 RTGCPHYS GCPhysVMMDevHeap;
864 /** @} */
865
866 /** TEMPORARY HACKS FOR NETWORK POLLING.
867 * @todo fix NAT and kill this!
868 * @{ */
869 RTUINT cPollers;
870#if HC_ARCH_BITS == 64
871 RTUINT padding1;
872#endif
873 R3PTRTYPE(PFNPDMDRVPOLLER) apfnPollers[16];
874 R3PTRTYPE(PPDMDRVINS) aDrvInsPollers[16];
875 PTMTIMERR3 pTimerPollers;
876 /** @} */
877
878 /** The PDM lock.
879 * This is used to protect everything that deals with interrupts, i.e.
880 * the PIC, APIC, IOAPIC and PCI devices pluss some PDM functions. */
881 PDMCRITSECT CritSect;
882
883 /** Number of times a critical section leave requesed needed to be queued for ring-3 execution. */
884 STAMCOUNTER StatQueuedCritSectLeaves;
885} PDM;
886/** Pointer to PDM VM instance data. */
887typedef PDM *PPDM;
888
889
890/**
891 * PDM data kept in the UVM.
892 */
893typedef struct PDMUSERPERVM
894{
895 /** Pointer to list of loaded modules. */
896 PPDMMOD pModules;
897 /** @todo move more stuff over here. */
898} PDMUSERPERVM;
899/** Pointer to the PDM data kept in the UVM. */
900typedef PDMUSERPERVM *PPDMUSERPERVM;
901
902
903
904/*******************************************************************************
905* Global Variables *
906*******************************************************************************/
907#ifdef IN_RING3
908extern const PDMDRVHLP g_pdmR3DrvHlp;
909#endif
910
911
912/*******************************************************************************
913* Internal Functions *
914*******************************************************************************/
915#ifdef IN_RING3
916int pdmR3CritSectInit(PVM pVM);
917int pdmR3CritSectTerm(PVM pVM);
918void pdmR3CritSectRelocate(PVM pVM);
919int pdmR3CritSectInitDevice(PVM pVM, PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, const char *pszName);
920int pdmR3CritSectDeleteDevice(PVM pVM, PPDMDEVINS pDevIns);
921
922int pdmR3DevInit(PVM pVM);
923PPDMDEV pdmR3DevLookup(PVM pVM, const char *pszName);
924int pdmR3DevFindLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMLUN *ppLun);
925
926int pdmR3UsbLoadModules(PVM pVM);
927int pdmR3UsbInstantiateDevices(PVM pVM);
928PPDMUSB pdmR3UsbLookup(PVM pVM, const char *pszName);
929int pdmR3UsbFindLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMLUN *ppLun);
930int pdmR3UsbRegisterHub(PVM pVM, PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp);
931int pdmR3UsbVMInitComplete(PVM pVM);
932
933int pdmR3DrvInit(PVM pVM);
934int pdmR3DrvDetach(PPDMDRVINS pDrvIns);
935void pdmR3DrvDestroyChain(PPDMDRVINS pDrvIns);
936PPDMDRV pdmR3DrvLookup(PVM pVM, const char *pszName);
937
938int pdmR3LdrInitU(PUVM pUVM);
939void pdmR3LdrTermU(PUVM pUVM);
940char * pdmR3FileR3(const char *pszFile, bool fShared = false);
941int pdmR3LoadR3U(PUVM pUVM, const char *pszFilename, const char *pszName);
942
943void pdmR3QueueRelocate(PVM pVM, RTGCINTPTR offDelta);
944
945int pdmR3ThreadCreateDevice(PVM pVM, PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
946 PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
947int pdmR3ThreadCreateUsb(PVM pVM, PPDMDRVINS pUsbIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADUSB pfnThread,
948 PFNPDMTHREADWAKEUPUSB pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
949int pdmR3ThreadCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
950 PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
951int pdmR3ThreadDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);
952int pdmR3ThreadDestroyUsb(PVM pVM, PPDMUSBINS pUsbIns);
953int pdmR3ThreadDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns);
954void pdmR3ThreadDestroyAll(PVM pVM);
955int pdmR3ThreadResumeAll(PVM pVM);
956int pdmR3ThreadSuspendAll(PVM pVM);
957
958#ifdef VBOX_WITH_PDM_ASYNC_COMPLETION
959int pdmR3AsyncCompletionInit(PVM pVM);
960int pdmR3AsyncCompletionTerm(PVM pVM);
961#endif
962
963#endif /* IN_RING3 */
964
965void pdmLock(PVM pVM);
966int pdmLockEx(PVM pVM, int rc);
967void pdmUnlock(PVM pVM);
968
969/** @} */
970
971__END_DECLS
972
973#endif
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