PDMR0Device.cpp@ 99900

Last change on this file since 99900 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 36.2 KB

Line
1	/* $Id: PDMR0Device.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* PDM - Pluggable Device and Driver Manager, R0 Device parts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_PDM_DEVICE
33	#define PDMPCIDEV_INCLUDE_PRIVATE /* Hack to get pdmpcidevint.h included at the right point. */
34	#include "PDMInternal.h"
35	#include <VBox/vmm/pdm.h>
36	#include <VBox/vmm/apic.h>
37	#include <VBox/vmm/mm.h>
38	#include <VBox/vmm/pgm.h>
39	#include <VBox/vmm/gvm.h>
40	#include <VBox/vmm/vmm.h>
41	#include <VBox/vmm/hm.h>
42	#include <VBox/vmm/vmcc.h>
43	#include <VBox/vmm/gvmm.h>
44
45	#include <VBox/log.h>
46	#include <VBox/err.h>
47	#include <VBox/msi.h>
48	#include <VBox/sup.h>
49	#include <iprt/asm.h>
50	#include <iprt/assert.h>
51	#include <iprt/ctype.h>
52	#include <iprt/mem.h>
53	#include <iprt/memobj.h>
54	#include <iprt/process.h>
55	#include <iprt/string.h>
56
57	#include "dtrace/VBoxVMM.h"
58	#include "PDMInline.h"
59
60
61	/*********************************************************************************************************************************
62	* Global Variables *
63	*********************************************************************************************************************************/
64	RT_C_DECLS_BEGIN
65	extern DECLEXPORT(const PDMDEVHLPR0) g_pdmR0DevHlp;
66	#ifdef VBOX_WITH_DBGF_TRACING
67	extern DECLEXPORT(const PDMDEVHLPR0) g_pdmR0DevHlpTracing;
68	#endif
69	extern DECLEXPORT(const PDMPICHLP) g_pdmR0PicHlp;
70	extern DECLEXPORT(const PDMIOAPICHLP) g_pdmR0IoApicHlp;
71	extern DECLEXPORT(const PDMPCIHLPR0) g_pdmR0PciHlp;
72	extern DECLEXPORT(const PDMIOMMUHLPR0) g_pdmR0IommuHlp;
73	extern DECLEXPORT(const PDMHPETHLPR0) g_pdmR0HpetHlp;
74	extern DECLEXPORT(const PDMPCIRAWHLPR0) g_pdmR0PciRawHlp;
75	RT_C_DECLS_END
76
77	/** List of PDMDEVMODREGR0 structures protected by the loader lock. */
78	static RTLISTANCHOR g_PDMDevModList;
79
80
81	/**
82	* Pointer to the ring-0 device registrations for VMMR0.
83	*/
84	static const PDMDEVREGR0 *g_apVMM0DevRegs[] =
85	{
86	&g_DeviceAPIC,
87	};
88
89	/**
90	* Module device registration record for VMMR0.
91	*/
92	static PDMDEVMODREGR0 g_VBoxDDR0ModDevReg =
93	{
94	/* .u32Version = */ PDM_DEVMODREGR0_VERSION,
95	/* .cDevRegs = */ RT_ELEMENTS(g_apVMM0DevRegs),
96	/* .papDevRegs = */ &g_apVMM0DevRegs[0],
97	/* .hMod = */ NULL,
98	/* .ListEntry = */ { NULL, NULL },
99	};
100
101
102	/*********************************************************************************************************************************
103	* Internal Functions *
104	*********************************************************************************************************************************/
105
106
107	/**
108	* Initializes the global ring-0 PDM data.
109	*/
110	VMMR0_INT_DECL(void) PDMR0Init(void *hMod)
111	{
112	RTListInit(&g_PDMDevModList);
113	g_VBoxDDR0ModDevReg.hMod = hMod;
114	RTListAppend(&g_PDMDevModList, &g_VBoxDDR0ModDevReg.ListEntry);
115	}
116
117
118	/**
119	* Used by PDMR0CleanupVM to destroy a device instance.
120	*
121	* This is done during VM cleanup so that we're sure there are no active threads
122	* inside the device code.
123	*
124	* @param pGVM The global (ring-0) VM structure.
125	* @param pDevIns The device instance.
126	* @param idxR0Device The device instance handle.
127	*/
128	static int pdmR0DeviceDestroy(PGVM pGVM, PPDMDEVINSR0 pDevIns, uint32_t idxR0Device)
129	{
130	/*
131	* Assert sanity.
132	*/
133	Assert(idxR0Device < pGVM->pdmr0.s.cDevInstances);
134	AssertPtrReturn(pDevIns, VERR_INVALID_HANDLE);
135	Assert(pDevIns->u32Version == PDM_DEVINSR0_VERSION);
136	Assert(pDevIns->Internal.s.idxR0Device == idxR0Device);
137
138	/*
139	* Call the final destructor if there is one.
140	*/
141	if (pDevIns->pReg->pfnFinalDestruct)
142	pDevIns->pReg->pfnFinalDestruct(pDevIns);
143	pDevIns->u32Version = ~PDM_DEVINSR0_VERSION;
144
145	/*
146	* Remove the device from the instance table.
147	*/
148	Assert(pGVM->pdmr0.s.apDevInstances[idxR0Device] == pDevIns);
149	pGVM->pdmr0.s.apDevInstances[idxR0Device] = NULL;
150	if (idxR0Device + 1 == pGVM->pdmr0.s.cDevInstances)
151	pGVM->pdmr0.s.cDevInstances = idxR0Device;
152
153	/*
154	* Free the DBGF tracing tracking structures if necessary.
155	*/
156	if (pDevIns->Internal.s.hDbgfTraceEvtSrc != NIL_DBGFTRACEREVTSRC)
157	{
158	RTR0MemObjFree(pDevIns->Internal.s.hDbgfTraceObj, true);
159	pDevIns->Internal.s.hDbgfTraceObj = NIL_RTR0MEMOBJ;
160	}
161
162	/*
163	* Free the ring-3 mapping and instance memory.
164	*/
165	RTR0MEMOBJ hMemObj = pDevIns->Internal.s.hMapObj;
166	pDevIns->Internal.s.hMapObj = NIL_RTR0MEMOBJ;
167	RTR0MemObjFree(hMemObj, true);
168
169	hMemObj = pDevIns->Internal.s.hMemObj;
170	pDevIns->Internal.s.hMemObj = NIL_RTR0MEMOBJ;
171	RTR0MemObjFree(hMemObj, true);
172
173	return VINF_SUCCESS;
174	}
175
176
177	/**
178	* Initializes the per-VM data for the PDM.
179	*
180	* This is called from under the GVMM lock, so it only need to initialize the
181	* data so PDMR0CleanupVM and others will work smoothly.
182	*
183	* @param pGVM Pointer to the global VM structure.
184	*/
185	VMMR0_INT_DECL(void) PDMR0InitPerVMData(PGVM pGVM)
186	{
187	AssertCompile(sizeof(pGVM->pdm.s) <= sizeof(pGVM->pdm.padding));
188	AssertCompile(sizeof(pGVM->pdmr0.s) <= sizeof(pGVM->pdmr0.padding));
189
190	pGVM->pdmr0.s.cDevInstances = 0;
191	}
192
193
194	/**
195	* Cleans up any loose ends before the GVM structure is destroyed.
196	*/
197	VMMR0_INT_DECL(void) PDMR0CleanupVM(PGVM pGVM)
198	{
199	uint32_t i = pGVM->pdmr0.s.cDevInstances;
200	while (i-- > 0)
201	{
202	PPDMDEVINSR0 pDevIns = pGVM->pdmr0.s.apDevInstances[i];
203	if (pDevIns)
204	pdmR0DeviceDestroy(pGVM, pDevIns, i);
205	}
206
207	i = pGVM->pdmr0.s.cQueues;
208	while (i-- > 0)
209	{
210	if (pGVM->pdmr0.s.aQueues[i].pQueue != NULL)
211	pdmR0QueueDestroy(pGVM, i);
212	}
213	}
214
215
216	/**
217	* Worker for PDMR0DeviceCreate that does the actual instantiation.
218	*
219	* Allocates a memory object and divides it up as follows:
220	* @verbatim
221	--------------------------------------
222	ring-0 devins
223	--------------------------------------
224	ring-0 instance data
225	--------------------------------------
226	ring-0 PCI device data (optional) ??
227	--------------------------------------
228	page alignment padding
229	--------------------------------------
230	ring-3 devins
231	--------------------------------------
232	ring-3 instance data
233	--------------------------------------
234	ring-3 PCI device data (optional) ??
235	--------------------------------------
236	[page alignment padding ] -
237	[--------------------------------------] \
238	[raw-mode devins ] \
239	[--------------------------------------] - Optional, only when raw-mode is enabled.
240	[raw-mode instance data ] /
241	[--------------------------------------] /
242	[raw-mode PCI device data (optional)?? ] -
243	--------------------------------------
244	shared instance data
245	--------------------------------------
246	default crit section
247	--------------------------------------
248	shared PCI device data (optional)
249	--------------------------------------
250	@endverbatim
251	*
252	* @returns VBox status code.
253	* @param pGVM The global (ring-0) VM structure.
254	* @param pDevReg The device registration structure.
255	* @param iInstance The device instance number.
256	* @param cbInstanceR3 The size of the ring-3 instance data.
257	* @param cbInstanceRC The size of the raw-mode instance data.
258	* @param hMod The module implementing the device.
259	* @param hDbgfTraceEvtSrc The DBGF tarcer event source handle.
260	* @param RCPtrMapping The raw-mode context mapping address, NIL_RTGCPTR if
261	* not to include raw-mode.
262	* @param ppDevInsR3 Where to return the ring-3 device instance address.
263	* @thread EMT(0)
264	*/
265	static int pdmR0DeviceCreateWorker(PGVM pGVM, PCPDMDEVREGR0 pDevReg, uint32_t iInstance, uint32_t cbInstanceR3,
266	uint32_t cbInstanceRC, RTRGPTR RCPtrMapping, DBGFTRACEREVTSRC hDbgfTraceEvtSrc,
267	void hMod, PPDMDEVINSR3 ppDevInsR3)
268	{
269	/*
270	* Check that the instance number isn't a duplicate.
271	*/
272	for (size_t i = 0; i < pGVM->pdmr0.s.cDevInstances; i++)
273	{
274	PPDMDEVINS pCur = pGVM->pdmr0.s.apDevInstances[i];
275	AssertLogRelReturn(!pCur \|\| pCur->pReg != pDevReg \|\| pCur->iInstance != iInstance, VERR_DUPLICATE);
276	}
277
278	/*
279	* Figure out how much memory we need and allocate it.
280	*/
281	uint32_t const cbRing0 = RT_ALIGN_32(RT_UOFFSETOF(PDMDEVINSR0, achInstanceData) + pDevReg->cbInstanceCC, HOST_PAGE_SIZE);
282	uint32_t const cbRing3 = RT_ALIGN_32(RT_UOFFSETOF(PDMDEVINSR3, achInstanceData) + cbInstanceR3,
283	RCPtrMapping != NIL_RTRGPTR ? HOST_PAGE_SIZE : 64);
284	uint32_t const cbRC = RCPtrMapping != NIL_RTRGPTR ? 0
285	: RT_ALIGN_32(RT_UOFFSETOF(PDMDEVINSRC, achInstanceData) + cbInstanceRC, 64);
286	uint32_t const cbShared = RT_ALIGN_32(pDevReg->cbInstanceShared, 64);
287	uint32_t const cbCritSect = RT_ALIGN_32(sizeof(PDMCRITSECT), 64);
288	uint32_t const cbMsixState = RT_ALIGN_32(pDevReg->cMaxMsixVectors * 16 + (pDevReg->cMaxMsixVectors + 7) / 8, _4K);
289	uint32_t const cbPciDev = RT_ALIGN_32(RT_UOFFSETOF_DYN(PDMPCIDEV, abMsixState[cbMsixState]), 64);
290	uint32_t const cPciDevs = RT_MIN(pDevReg->cMaxPciDevices, 8);
291	uint32_t const cbPciDevs = cbPciDev * cPciDevs;
292	uint32_t const cbTotal = RT_ALIGN_32(cbRing0 + cbRing3 + cbRC + cbShared + cbCritSect + cbPciDevs, HOST_PAGE_SIZE);
293	AssertLogRelMsgReturn(cbTotal <= PDM_MAX_DEVICE_INSTANCE_SIZE,
294	("Instance of '%s' is too big: cbTotal=%u, max %u\n",
295	pDevReg->szName, cbTotal, PDM_MAX_DEVICE_INSTANCE_SIZE),
296	VERR_OUT_OF_RANGE);
297
298	RTR0MEMOBJ hMemObj;
299	int rc = RTR0MemObjAllocPage(&hMemObj, cbTotal, false /fExecutable/);
300	if (RT_FAILURE(rc))
301	return rc;
302	RT_BZERO(RTR0MemObjAddress(hMemObj), cbTotal);
303
304	/* Map it. */
305	RTR0MEMOBJ hMapObj;
306	rc = RTR0MemObjMapUserEx(&hMapObj, hMemObj, (RTR3PTR)-1, 0, RTMEM_PROT_READ \| RTMEM_PROT_WRITE, RTR0ProcHandleSelf(),
307	cbRing0, cbTotal - cbRing0);
308	if (RT_SUCCESS(rc))
309	{
310	PPDMDEVINSR0 pDevIns = (PPDMDEVINSR0)RTR0MemObjAddress(hMemObj);
311	struct PDMDEVINSR3 pDevInsR3 = (struct PDMDEVINSR3 )((uint8_t *)pDevIns + cbRing0);
312
313	/*
314	* Initialize the ring-0 instance.
315	*/
316	pDevIns->u32Version = PDM_DEVINSR0_VERSION;
317	pDevIns->iInstance = iInstance;
318	#ifdef VBOX_WITH_DBGF_TRACING
319	pDevIns->pHlpR0 = hDbgfTraceEvtSrc == NIL_DBGFTRACEREVTSRC ? &g_pdmR0DevHlp : &g_pdmR0DevHlpTracing;
320	#else
321	pDevIns->pHlpR0 = &g_pdmR0DevHlp;
322	#endif
323	pDevIns->pvInstanceDataR0 = (uint8_t *)pDevIns + cbRing0 + cbRing3 + cbRC;
324	pDevIns->pvInstanceDataForR0 = &pDevIns->achInstanceData[0];
325	pDevIns->pCritSectRoR0 = (PPDMCRITSECT)((uint8_t *)pDevIns->pvInstanceDataR0 + cbShared);
326	pDevIns->pReg = pDevReg;
327	pDevIns->pDevInsForR3 = RTR0MemObjAddressR3(hMapObj);
328	pDevIns->pDevInsForR3R0 = pDevInsR3;
329	pDevIns->pvInstanceDataForR3R0 = &pDevInsR3->achInstanceData[0];
330	pDevIns->cbPciDev = cbPciDev;
331	pDevIns->cPciDevs = cPciDevs;
332	for (uint32_t iPciDev = 0; iPciDev < cPciDevs; iPciDev++)
333	{
334	/* Note! PDMDevice.cpp has a copy of this code. Keep in sync. */
335	PPDMPCIDEV pPciDev = (PPDMPCIDEV)((uint8_t )pDevIns->pCritSectRoR0 + cbCritSect + cbPciDev iPciDev);
336	if (iPciDev < RT_ELEMENTS(pDevIns->apPciDevs))
337	pDevIns->apPciDevs[iPciDev] = pPciDev;
338	pPciDev->cbConfig = _4K;
339	pPciDev->cbMsixState = cbMsixState;
340	pPciDev->idxSubDev = (uint16_t)iPciDev;
341	pPciDev->Int.s.idxSubDev = (uint16_t)iPciDev;
342	pPciDev->u32Magic = PDMPCIDEV_MAGIC;
343	}
344	pDevIns->Internal.s.pGVM = pGVM;
345	pDevIns->Internal.s.pRegR0 = pDevReg;
346	pDevIns->Internal.s.hMod = hMod;
347	pDevIns->Internal.s.hMemObj = hMemObj;
348	pDevIns->Internal.s.hMapObj = hMapObj;
349	pDevIns->Internal.s.pInsR3R0 = pDevInsR3;
350	pDevIns->Internal.s.pIntR3R0 = &pDevInsR3->Internal.s;
351	pDevIns->Internal.s.hDbgfTraceEvtSrc = hDbgfTraceEvtSrc;
352
353	/*
354	* Initialize the ring-3 instance data as much as we can.
355	* Note! PDMDevice.cpp does this job for ring-3 only devices. Keep in sync.
356	*/
357	pDevInsR3->u32Version = PDM_DEVINSR3_VERSION;
358	pDevInsR3->iInstance = iInstance;
359	pDevInsR3->cbRing3 = cbTotal - cbRing0;
360	pDevInsR3->fR0Enabled = true;
361	pDevInsR3->fRCEnabled = RCPtrMapping != NIL_RTRGPTR;
362	pDevInsR3->pvInstanceDataR3 = pDevIns->pDevInsForR3 + cbRing3 + cbRC;
363	pDevInsR3->pvInstanceDataForR3 = pDevIns->pDevInsForR3 + RT_UOFFSETOF(PDMDEVINSR3, achInstanceData);
364	pDevInsR3->pCritSectRoR3 = pDevIns->pDevInsForR3 + cbRing3 + cbRC + cbShared;
365	pDevInsR3->pDevInsR0RemoveMe = pDevIns;
366	pDevInsR3->pvInstanceDataR0 = pDevIns->pvInstanceDataR0;
367	pDevInsR3->pvInstanceDataRC = RCPtrMapping == NIL_RTRGPTR
368	? NIL_RTRGPTR : pDevIns->pDevInsForRC + RT_UOFFSETOF(PDMDEVINSRC, achInstanceData);
369	pDevInsR3->pDevInsForRC = pDevIns->pDevInsForRC;
370	pDevInsR3->pDevInsForRCR3 = pDevIns->pDevInsForR3 + cbRing3;
371	pDevInsR3->pDevInsForRCR3 = pDevInsR3->pDevInsForRCR3 + RT_UOFFSETOF(PDMDEVINSRC, achInstanceData);
372	pDevInsR3->cbPciDev = cbPciDev;
373	pDevInsR3->cPciDevs = cPciDevs;
374	for (uint32_t i = 0; i < RT_MIN(cPciDevs, RT_ELEMENTS(pDevIns->apPciDevs)); i++)
375	pDevInsR3->apPciDevs[i] = pDevInsR3->pCritSectRoR3 + cbCritSect + cbPciDev * i;
376
377	pDevInsR3->Internal.s.pVMR3 = pGVM->pVMR3;
378	pDevInsR3->Internal.s.fIntFlags = RCPtrMapping == NIL_RTRGPTR ? PDMDEVINSINT_FLAGS_R0_ENABLED
379	: PDMDEVINSINT_FLAGS_R0_ENABLED \| PDMDEVINSINT_FLAGS_RC_ENABLED;
380	pDevInsR3->Internal.s.hDbgfTraceEvtSrc = hDbgfTraceEvtSrc;
381
382	/*
383	* Initialize the raw-mode instance data as much as possible.
384	*/
385	if (RCPtrMapping != NIL_RTRGPTR)
386	{
387	struct PDMDEVINSRC *pDevInsRC = RCPtrMapping == NIL_RTRGPTR ? NULL
388	: (struct PDMDEVINSRC )((uint8_t )pDevIns + cbRing0 + cbRing3);
389
390	pDevIns->pDevInsForRC = RCPtrMapping;
391	pDevIns->pDevInsForRCR0 = pDevInsRC;
392	pDevIns->pvInstanceDataForRCR0 = &pDevInsRC->achInstanceData[0];
393
394	pDevInsRC->u32Version = PDM_DEVINSRC_VERSION;
395	pDevInsRC->iInstance = iInstance;
396	pDevInsRC->pvInstanceDataRC = pDevIns->pDevInsForRC + cbRC;
397	pDevInsRC->pvInstanceDataForRC = pDevIns->pDevInsForRC + RT_UOFFSETOF(PDMDEVINSRC, achInstanceData);
398	pDevInsRC->pCritSectRoRC = pDevIns->pDevInsForRC + cbRC + cbShared;
399	pDevInsRC->cbPciDev = cbPciDev;
400	pDevInsRC->cPciDevs = cPciDevs;
401	for (uint32_t i = 0; i < RT_MIN(cPciDevs, RT_ELEMENTS(pDevIns->apPciDevs)); i++)
402	pDevInsRC->apPciDevs[i] = pDevInsRC->pCritSectRoRC + cbCritSect + cbPciDev * i;
403
404	pDevInsRC->Internal.s.pVMRC = pGVM->pVMRC;
405	}
406
407	/*
408	* If the device is being traced we have to set up a single page for tracking
409	* I/O and MMIO region registrations so we can inject our own handlers.
410	*/
411	if (hDbgfTraceEvtSrc != NIL_DBGFTRACEREVTSRC)
412	{
413	pDevIns->Internal.s.hDbgfTraceObj = NIL_RTR0MEMOBJ;
414	rc = RTR0MemObjAllocPage(&pDevIns->Internal.s.hDbgfTraceObj, PDM_MAX_DEVICE_DBGF_TRACING_TRACK, false /fExecutable/);
415	if (RT_SUCCESS(rc))
416	{
417	pDevIns->Internal.s.paDbgfTraceTrack = (PPDMDEVINSDBGFTRACK)RTR0MemObjAddress(pDevIns->Internal.s.hDbgfTraceObj);
418	pDevIns->Internal.s.idxDbgfTraceTrackNext = 0;
419	pDevIns->Internal.s.cDbgfTraceTrackMax = PDM_MAX_DEVICE_DBGF_TRACING_TRACK / sizeof(PDMDEVINSDBGFTRACK);
420	RT_BZERO(pDevIns->Internal.s.paDbgfTraceTrack, PDM_MAX_DEVICE_DBGF_TRACING_TRACK);
421	}
422	}
423
424	if (RT_SUCCESS(rc))
425	{
426	/*
427	* Add to the device instance array and set its handle value.
428	*/
429	AssertCompile(sizeof(pGVM->pdmr0.padding) == sizeof(pGVM->pdmr0));
430	uint32_t idxR0Device = pGVM->pdmr0.s.cDevInstances;
431	if (idxR0Device < RT_ELEMENTS(pGVM->pdmr0.s.apDevInstances))
432	{
433	pGVM->pdmr0.s.apDevInstances[idxR0Device] = pDevIns;
434	pGVM->pdmr0.s.cDevInstances = idxR0Device + 1;
435	pGVM->pdm.s.apDevRing0Instances[idxR0Device] = pDevIns->pDevInsForR3;
436	pDevIns->Internal.s.idxR0Device = idxR0Device;
437	pDevInsR3->Internal.s.idxR0Device = idxR0Device;
438
439	/*
440	* Call the early constructor if present.
441	*/
442	if (pDevReg->pfnEarlyConstruct)
443	rc = pDevReg->pfnEarlyConstruct(pDevIns);
444	if (RT_SUCCESS(rc))
445	{
446	/*
447	* We're done.
448	*/
449	*ppDevInsR3 = RTR0MemObjAddressR3(hMapObj);
450	return rc;
451	}
452
453	/*
454	* Bail out.
455	*/
456	if (pDevIns->pReg->pfnFinalDestruct)
457	pDevIns->pReg->pfnFinalDestruct(pDevIns);
458
459	pGVM->pdmr0.s.apDevInstances[idxR0Device] = NULL;
460	Assert(pGVM->pdmr0.s.cDevInstances == idxR0Device + 1);
461	pGVM->pdmr0.s.cDevInstances = idxR0Device;
462	}
463	}
464
465	if ( hDbgfTraceEvtSrc != NIL_DBGFTRACEREVTSRC
466	&& pDevIns->Internal.s.hDbgfTraceObj != NIL_RTR0MEMOBJ)
467	RTR0MemObjFree(pDevIns->Internal.s.hDbgfTraceObj, true);
468
469	RTR0MemObjFree(hMapObj, true);
470	}
471	RTR0MemObjFree(hMemObj, true);
472	return rc;
473	}
474
475
476	/**
477	* Used by ring-3 PDM to create a device instance that operates both in ring-3
478	* and ring-0.
479	*
480	* Creates an instance of a device (for both ring-3 and ring-0, and optionally
481	* raw-mode context).
482	*
483	* @returns VBox status code.
484	* @param pGVM The global (ring-0) VM structure.
485	* @param pReq Pointer to the request buffer.
486	* @thread EMT(0)
487	*/
488	VMMR0_INT_DECL(int) PDMR0DeviceCreateReqHandler(PGVM pGVM, PPDMDEVICECREATEREQ pReq)
489	{
490	LogFlow(("PDMR0DeviceCreateReqHandler: %s in %s\n", pReq->szDevName, pReq->szModName));
491
492	/*
493	* Validate the request.
494	*/
495	AssertReturn(pReq->Hdr.cbReq == sizeof(*pReq), VERR_INVALID_PARAMETER);
496	pReq->pDevInsR3 = NIL_RTR3PTR;
497
498	int rc = GVMMR0ValidateGVMandEMT(pGVM, 0);
499	AssertRCReturn(rc, rc);
500
501	AssertReturn(pReq->fFlags != 0, VERR_INVALID_FLAGS);
502	AssertReturn(pReq->fClass != 0, VERR_WRONG_TYPE);
503	AssertReturn(pReq->uSharedVersion != 0, VERR_INVALID_PARAMETER);
504	AssertReturn(pReq->cbInstanceShared != 0, VERR_INVALID_PARAMETER);
505	size_t const cchDevName = RTStrNLen(pReq->szDevName, sizeof(pReq->szDevName));
506	AssertReturn(cchDevName < sizeof(pReq->szDevName), VERR_NO_STRING_TERMINATOR);
507	AssertReturn(cchDevName > 0, VERR_EMPTY_STRING);
508	AssertReturn(cchDevName < RT_SIZEOFMEMB(PDMDEVREG, szName), VERR_NOT_FOUND);
509
510	size_t const cchModName = RTStrNLen(pReq->szModName, sizeof(pReq->szModName));
511	AssertReturn(cchModName < sizeof(pReq->szModName), VERR_NO_STRING_TERMINATOR);
512	AssertReturn(cchModName > 0, VERR_EMPTY_STRING);
513	AssertReturn(pReq->cbInstanceShared <= PDM_MAX_DEVICE_INSTANCE_SIZE, VERR_OUT_OF_RANGE);
514	AssertReturn(pReq->cbInstanceR3 <= PDM_MAX_DEVICE_INSTANCE_SIZE, VERR_OUT_OF_RANGE);
515	AssertReturn(pReq->cbInstanceRC <= PDM_MAX_DEVICE_INSTANCE_SIZE, VERR_OUT_OF_RANGE);
516	AssertReturn(pReq->iInstance < 1024, VERR_OUT_OF_RANGE);
517	AssertReturn(pReq->iInstance < pReq->cMaxInstances, VERR_OUT_OF_RANGE);
518	AssertReturn(pReq->cMaxPciDevices <= 8, VERR_OUT_OF_RANGE);
519	AssertReturn(pReq->cMaxMsixVectors <= VBOX_MSIX_MAX_ENTRIES, VERR_OUT_OF_RANGE);
520
521	/*
522	* Reference the module.
523	*/
524	void *hMod = NULL;
525	rc = SUPR0LdrModByName(pGVM->pSession, pReq->szModName, &hMod);
526	if (RT_FAILURE(rc))
527	{
528	LogRel(("PDMR0DeviceCreateReqHandler: SUPR0LdrModByName(,%s,) failed: %Rrc\n", pReq->szModName, rc));
529	return rc;
530	}
531
532	/*
533	* Look for the the module and the device registration structure.
534	*/
535	int rcLock = SUPR0LdrLock(pGVM->pSession);
536	AssertRC(rc);
537
538	rc = VERR_NOT_FOUND;
539	PPDMDEVMODREGR0 pMod;
540	RTListForEach(&g_PDMDevModList, pMod, PDMDEVMODREGR0, ListEntry)
541	{
542	if (pMod->hMod == hMod)
543	{
544	/*
545	* Found the module. We can drop the loader lock now before we
546	* search the devices it registers.
547	*/
548	if (RT_SUCCESS(rcLock))
549	{
550	rcLock = SUPR0LdrUnlock(pGVM->pSession);
551	AssertRC(rcLock);
552	}
553	rcLock = VERR_ALREADY_RESET;
554
555	PCPDMDEVREGR0 *papDevRegs = pMod->papDevRegs;
556	size_t i = pMod->cDevRegs;
557	while (i-- > 0)
558	{
559	PCPDMDEVREGR0 pDevReg = papDevRegs[i];
560	LogFlow(("PDMR0DeviceCreateReqHandler: candidate #%u: %s %#x\n", i, pReq->szDevName, pDevReg->u32Version));
561	if ( PDM_VERSION_ARE_COMPATIBLE(pDevReg->u32Version, PDM_DEVREGR0_VERSION)
562	&& pDevReg->szName[cchDevName] == '\0'
563	&& memcmp(pDevReg->szName, pReq->szDevName, cchDevName) == 0)
564	{
565
566	/*
567	* Found the device, now check whether it matches the ring-3 registration.
568	*/
569	if ( pReq->uSharedVersion == pDevReg->uSharedVersion
570	&& pReq->cbInstanceShared == pDevReg->cbInstanceShared
571	&& pReq->cbInstanceRC == pDevReg->cbInstanceRC
572	&& pReq->fFlags == pDevReg->fFlags
573	&& pReq->fClass == pDevReg->fClass
574	&& pReq->cMaxInstances == pDevReg->cMaxInstances
575	&& pReq->cMaxPciDevices == pDevReg->cMaxPciDevices
576	&& pReq->cMaxMsixVectors == pDevReg->cMaxMsixVectors)
577	{
578	rc = pdmR0DeviceCreateWorker(pGVM, pDevReg, pReq->iInstance, pReq->cbInstanceR3, pReq->cbInstanceRC,
579	NIL_RTRCPTR /** @todo new raw-mode */, pReq->hDbgfTracerEvtSrc,
580	hMod, &pReq->pDevInsR3);
581	if (RT_SUCCESS(rc))
582	hMod = NULL; /* keep the module reference */
583	}
584	else
585	{
586	LogRel(("PDMR0DeviceCreate: Ring-3 does not match ring-0 device registration (%s):\n"
587	" uSharedVersion: %#x vs %#x\n"
588	" cbInstanceShared: %#x vs %#x\n"
589	" cbInstanceRC: %#x vs %#x\n"
590	" fFlags: %#x vs %#x\n"
591	" fClass: %#x vs %#x\n"
592	" cMaxInstances: %#x vs %#x\n"
593	" cMaxPciDevices: %#x vs %#x\n"
594	" cMaxMsixVectors: %#x vs %#x\n"
595	,
596	pReq->szDevName,
597	pReq->uSharedVersion, pDevReg->uSharedVersion,
598	pReq->cbInstanceShared, pDevReg->cbInstanceShared,
599	pReq->cbInstanceRC, pDevReg->cbInstanceRC,
600	pReq->fFlags, pDevReg->fFlags,
601	pReq->fClass, pDevReg->fClass,
602	pReq->cMaxInstances, pDevReg->cMaxInstances,
603	pReq->cMaxPciDevices, pDevReg->cMaxPciDevices,
604	pReq->cMaxMsixVectors, pDevReg->cMaxMsixVectors));
605	rc = VERR_INCOMPATIBLE_CONFIG;
606	}
607	}
608	}
609	break;
610	}
611	}
612
613	if (RT_SUCCESS_NP(rcLock))
614	{
615	rcLock = SUPR0LdrUnlock(pGVM->pSession);
616	AssertRC(rcLock);
617	}
618	SUPR0LdrModRelease(pGVM->pSession, hMod);
619	return rc;
620	}
621
622
623	/**
624	* Used by ring-3 PDM to call standard ring-0 device methods.
625	*
626	* @returns VBox status code.
627	* @param pGVM The global (ring-0) VM structure.
628	* @param pReq Pointer to the request buffer.
629	* @param idCpu The ID of the calling EMT.
630	* @thread EMT(0), except for PDMDEVICEGENCALL_REQUEST which can be any EMT.
631	*/
632	VMMR0_INT_DECL(int) PDMR0DeviceGenCallReqHandler(PGVM pGVM, PPDMDEVICEGENCALLREQ pReq, VMCPUID idCpu)
633	{
634	/*
635	* Validate the request.
636	*/
637	AssertReturn(pReq->Hdr.cbReq == sizeof(*pReq), VERR_INVALID_PARAMETER);
638
639	int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
640	AssertRCReturn(rc, rc);
641
642	AssertReturn(pReq->idxR0Device < pGVM->pdmr0.s.cDevInstances, VERR_INVALID_HANDLE);
643	PPDMDEVINSR0 pDevIns = pGVM->pdmr0.s.apDevInstances[pReq->idxR0Device];
644	AssertPtrReturn(pDevIns, VERR_INVALID_HANDLE);
645	AssertReturn(pDevIns->pDevInsForR3 == pReq->pDevInsR3, VERR_INVALID_HANDLE);
646
647	/*
648	* Make the call.
649	*/
650	rc = VINF_SUCCESS /VINF_NOT_IMPLEMENTED/;
651	switch (pReq->enmCall)
652	{
653	case PDMDEVICEGENCALL_CONSTRUCT:
654	AssertMsgBreakStmt(pGVM->enmVMState < VMSTATE_CREATED, ("enmVMState=%d\n", pGVM->enmVMState), rc = VERR_INVALID_STATE);
655	AssertReturn(idCpu == 0, VERR_VM_THREAD_NOT_EMT);
656	if (pDevIns->pReg->pfnConstruct)
657	rc = pDevIns->pReg->pfnConstruct(pDevIns);
658	break;
659
660	case PDMDEVICEGENCALL_DESTRUCT:
661	AssertMsgBreakStmt(pGVM->enmVMState < VMSTATE_CREATED \|\| pGVM->enmVMState >= VMSTATE_DESTROYING,
662	("enmVMState=%d\n", pGVM->enmVMState), rc = VERR_INVALID_STATE);
663	AssertReturn(idCpu == 0, VERR_VM_THREAD_NOT_EMT);
664	if (pDevIns->pReg->pfnDestruct)
665	{
666	pDevIns->pReg->pfnDestruct(pDevIns);
667	rc = VINF_SUCCESS;
668	}
669	break;
670
671	case PDMDEVICEGENCALL_REQUEST:
672	if (pDevIns->pReg->pfnRequest)
673	rc = pDevIns->pReg->pfnRequest(pDevIns, pReq->Params.Req.uReq, pReq->Params.Req.uArg);
674	else
675	rc = VERR_INVALID_FUNCTION;
676	break;
677
678	default:
679	AssertMsgFailed(("enmCall=%d\n", pReq->enmCall));
680	rc = VERR_INVALID_FUNCTION;
681	break;
682	}
683
684	return rc;
685	}
686
687
688	/**
689	* Legacy device mode compatiblity.
690	*
691	* @returns VBox status code.
692	* @param pGVM The global (ring-0) VM structure.
693	* @param pReq Pointer to the request buffer.
694	* @thread EMT(0)
695	*/
696	VMMR0_INT_DECL(int) PDMR0DeviceCompatSetCritSectReqHandler(PGVM pGVM, PPDMDEVICECOMPATSETCRITSECTREQ pReq)
697	{
698	/*
699	* Validate the request.
700	*/
701	AssertReturn(pReq->Hdr.cbReq == sizeof(*pReq), VERR_INVALID_PARAMETER);
702
703	int rc = GVMMR0ValidateGVMandEMT(pGVM, 0);
704	AssertRCReturn(rc, rc);
705
706	AssertReturn(pReq->idxR0Device < pGVM->pdmr0.s.cDevInstances, VERR_INVALID_HANDLE);
707	PPDMDEVINSR0 pDevIns = pGVM->pdmr0.s.apDevInstances[pReq->idxR0Device];
708	AssertPtrReturn(pDevIns, VERR_INVALID_HANDLE);
709	AssertReturn(pDevIns->pDevInsForR3 == pReq->pDevInsR3, VERR_INVALID_HANDLE);
710
711	AssertReturn(pGVM->enmVMState == VMSTATE_CREATING, VERR_INVALID_STATE);
712
713	/*
714	* The critical section address can be in a few different places:
715	* 1. shared data.
716	* 2. nop section.
717	* 3. pdm critsect.
718	*/
719	PPDMCRITSECT pCritSect;
720	if (pReq->pCritSectR3 == pGVM->pVMR3 + RT_UOFFSETOF(VM, pdm.s.NopCritSect))
721	{
722	pCritSect = &pGVM->pdm.s.NopCritSect;
723	Log(("PDMR0DeviceCompatSetCritSectReqHandler: Nop - %p %#x\n", pCritSect, pCritSect->s.Core.u32Magic));
724	}
725	else if (pReq->pCritSectR3 == pGVM->pVMR3 + RT_UOFFSETOF(VM, pdm.s.CritSect))
726	{
727	pCritSect = &pGVM->pdm.s.CritSect;
728	Log(("PDMR0DeviceCompatSetCritSectReqHandler: PDM - %p %#x\n", pCritSect, pCritSect->s.Core.u32Magic));
729	}
730	else
731	{
732	size_t offCritSect = pReq->pCritSectR3 - pDevIns->pDevInsForR3R0->pvInstanceDataR3;
733	AssertLogRelMsgReturn( offCritSect < pDevIns->pReg->cbInstanceShared
734	&& offCritSect + sizeof(PDMCRITSECT) <= pDevIns->pReg->cbInstanceShared,
735	("offCritSect=%p pCritSectR3=%p cbInstanceShared=%#x (%s)\n",
736	offCritSect, pReq->pCritSectR3, pDevIns->pReg->cbInstanceShared, pDevIns->pReg->szName),
737	VERR_INVALID_POINTER);
738	pCritSect = (PPDMCRITSECT)((uint8_t *)pDevIns->pvInstanceDataR0 + offCritSect);
739	Log(("PDMR0DeviceCompatSetCritSectReqHandler: custom - %#x/%p %#x\n", offCritSect, pCritSect, pCritSect->s.Core.u32Magic));
740	}
741	AssertLogRelMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC,
742	("cs=%p magic=%#x dev=%s\n", pCritSect, pCritSect->s.Core.u32Magic, pDevIns->pReg->szName),
743	VERR_INVALID_MAGIC);
744
745	/*
746	* Make the update.
747	*/
748	pDevIns->pCritSectRoR0 = pCritSect;
749
750	return VINF_SUCCESS;
751	}
752
753
754	/**
755	* Registers the device implementations living in a module.
756	*
757	* This should normally only be called during ModuleInit(). The should be a
758	* call to PDMR0DeviceDeregisterModule from the ModuleTerm() function to undo
759	* the effects of this call.
760	*
761	* @returns VBox status code.
762	* @param hMod The module handle of the module being registered.
763	* @param pModReg The module registration structure. This will be
764	* used directly so it must live as long as the module
765	* and be writable.
766	*
767	* @note Caller must own the loader lock!
768	*/
769	VMMR0DECL(int) PDMR0DeviceRegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg)
770	{
771	/*
772	* Validate the input.
773	*/
774	AssertPtrReturn(hMod, VERR_INVALID_HANDLE);
775	Assert(SUPR0LdrIsLockOwnerByMod(hMod, true));
776
777	AssertPtrReturn(pModReg, VERR_INVALID_POINTER);
778	AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE(pModReg->u32Version, PDM_DEVMODREGR0_VERSION),
779	("pModReg->u32Version=%#x vs %#x\n", pModReg->u32Version, PDM_DEVMODREGR0_VERSION),
780	VERR_VERSION_MISMATCH);
781	AssertLogRelMsgReturn(pModReg->cDevRegs <= 256 && pModReg->cDevRegs > 0, ("cDevRegs=%u\n", pModReg->cDevRegs),
782	VERR_OUT_OF_RANGE);
783	AssertLogRelMsgReturn(pModReg->hMod == NULL, ("hMod=%p\n", pModReg->hMod), VERR_INVALID_PARAMETER);
784	AssertLogRelMsgReturn(pModReg->ListEntry.pNext == NULL, ("pNext=%p\n", pModReg->ListEntry.pNext), VERR_INVALID_PARAMETER);
785	AssertLogRelMsgReturn(pModReg->ListEntry.pPrev == NULL, ("pPrev=%p\n", pModReg->ListEntry.pPrev), VERR_INVALID_PARAMETER);
786
787	for (size_t i = 0; i < pModReg->cDevRegs; i++)
788	{
789	PCPDMDEVREGR0 pDevReg = pModReg->papDevRegs[i];
790	AssertLogRelMsgReturn(RT_VALID_PTR(pDevReg), ("[%u]: %p\n", i, pDevReg), VERR_INVALID_POINTER);
791	AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE(pDevReg->u32Version, PDM_DEVREGR0_VERSION),
792	("pDevReg->u32Version=%#x vs %#x\n", pModReg->u32Version, PDM_DEVREGR0_VERSION), VERR_VERSION_MISMATCH);
793	AssertLogRelMsgReturn(RT_VALID_PTR(pDevReg->pszDescription), ("[%u]: %p\n", i, pDevReg->pszDescription), VERR_INVALID_POINTER);
794	AssertLogRelMsgReturn(pDevReg->uReserved0 == 0, ("[%u]: %#x\n", i, pDevReg->uReserved0), VERR_INVALID_PARAMETER);
795	AssertLogRelMsgReturn(pDevReg->fClass != 0, ("[%u]: %#x\n", i, pDevReg->fClass), VERR_INVALID_PARAMETER);
796	AssertLogRelMsgReturn(pDevReg->fFlags != 0, ("[%u]: %#x\n", i, pDevReg->fFlags), VERR_INVALID_PARAMETER);
797	AssertLogRelMsgReturn(pDevReg->cMaxInstances > 0, ("[%u]: %#x\n", i, pDevReg->cMaxInstances), VERR_INVALID_PARAMETER);
798	AssertLogRelMsgReturn(pDevReg->cMaxPciDevices <= 8, ("[%u]: %#x\n", i, pDevReg->cMaxPciDevices), VERR_INVALID_PARAMETER);
799	AssertLogRelMsgReturn(pDevReg->cMaxMsixVectors <= VBOX_MSIX_MAX_ENTRIES,
800	("[%u]: %#x\n", i, pDevReg->cMaxMsixVectors), VERR_INVALID_PARAMETER);
801
802	/* The name must be printable ascii and correctly terminated. */
803	for (size_t off = 0; off < RT_ELEMENTS(pDevReg->szName); off++)
804	{
805	char ch = pDevReg->szName[off];
806	AssertLogRelMsgReturn(RT_C_IS_PRINT(ch) \|\| (ch == '\0' && off > 0),
807	("[%u]: off=%u szName: %.*Rhxs\n", i, off, sizeof(pDevReg->szName), &pDevReg->szName[0]),
808	VERR_INVALID_NAME);
809	if (ch == '\0')
810	break;
811	}
812	}
813
814	/*
815	* Add it, assuming we're being called at ModuleInit/ModuleTerm time only, or
816	* that the caller has already taken the loader lock.
817	*/
818	pModReg->hMod = hMod;
819	RTListAppend(&g_PDMDevModList, &pModReg->ListEntry);
820
821	return VINF_SUCCESS;
822	}
823
824
825	/**
826	* Deregisters the device implementations living in a module.
827	*
828	* This should normally only be called during ModuleTerm().
829	*
830	* @returns VBox status code.
831	* @param hMod The module handle of the module being registered.
832	* @param pModReg The module registration structure. This will be
833	* used directly so it must live as long as the module
834	* and be writable.
835	*
836	* @note Caller must own the loader lock!
837	*/
838	VMMR0DECL(int) PDMR0DeviceDeregisterModule(void *hMod, PPDMDEVMODREGR0 pModReg)
839	{
840	/*
841	* Validate the input.
842	*/
843	AssertPtrReturn(hMod, VERR_INVALID_HANDLE);
844	Assert(SUPR0LdrIsLockOwnerByMod(hMod, true));
845
846	AssertPtrReturn(pModReg, VERR_INVALID_POINTER);
847	AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE(pModReg->u32Version, PDM_DEVMODREGR0_VERSION),
848	("pModReg->u32Version=%#x vs %#x\n", pModReg->u32Version, PDM_DEVMODREGR0_VERSION),
849	VERR_VERSION_MISMATCH);
850	AssertLogRelMsgReturn(pModReg->hMod == hMod \|\| pModReg->hMod == NULL, ("pModReg->hMod=%p vs %p\n", pModReg->hMod, hMod),
851	VERR_INVALID_PARAMETER);
852
853	/*
854	* Unlink the registration record and return it to virgin conditions. Ignore
855	* the call if not registered.
856	*/
857	if (pModReg->hMod)
858	{
859	pModReg->hMod = NULL;
860	RTListNodeRemove(&pModReg->ListEntry);
861	pModReg->ListEntry.pNext = NULL;
862	pModReg->ListEntry.pPrev = NULL;
863	return VINF_SUCCESS;
864	}
865	return VWRN_NOT_FOUND;
866	}
867

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

source: vbox/trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp@ 99900

Download in other formats: