PDMInternal.h@ 9212

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

Major changes for sizeof(RTGCPTR) == uint64_t.
Introduced RCPTRTYPE for pointers valid in raw mode only (RTGCPTR32).

Disabled by default. Enable by adding VBOX_WITH_64_BITS_GUESTS to your LocalConfig.kmk.

Property svn:eol-style set to native
Property svn:keywords set to Id

File size: 33.6 KB

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

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

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

Download in other formats: