PDMInternal.h@ 19969

Last change on this file since 19969 was 19785, checked in by vboxsync, 15 years ago
Locking should not be required after all
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 37.8 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: