VirtualBox

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

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

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