PDMDevice.cpp@ 24911

Last change on this file since 24911 was 24730, checked in by vboxsync, 15 years ago
PDM: Implemented making device/driver/usb-device suspend and poweroff notifications asynchronous when needed. Also prepped the way for failing poweron and resume.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 37.2 KB

Line
1	/* $Id: PDMDevice.cpp 24730 2009-11-17 16:51:03Z vboxsync $ */
2	/** @file
3	* PDM - Pluggable Device and Driver Manager, Device parts.
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
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_PDM_DEVICE
27	#include "PDMInternal.h"
28	#include <VBox/pdm.h>
29	#include <VBox/mm.h>
30	#include <VBox/pgm.h>
31	#include <VBox/iom.h>
32	#include <VBox/cfgm.h>
33	#include <VBox/rem.h>
34	#include <VBox/dbgf.h>
35	#include <VBox/vm.h>
36	#include <VBox/vmm.h>
37
38	#include <VBox/version.h>
39	#include <VBox/log.h>
40	#include <VBox/err.h>
41	#include <iprt/alloc.h>
42	#include <iprt/alloca.h>
43	#include <iprt/asm.h>
44	#include <iprt/assert.h>
45	#include <iprt/path.h>
46	#include <iprt/semaphore.h>
47	#include <iprt/string.h>
48	#include <iprt/thread.h>
49
50
51	/*******************************************************************************
52	* Structures and Typedefs *
53	*******************************************************************************/
54	/**
55	* Internal callback structure pointer.
56	* The main purpose is to define the extra data we associate
57	* with PDMDEVREGCB so we can find the VM instance and so on.
58	*/
59	typedef struct PDMDEVREGCBINT
60	{
61	/** The callback structure. */
62	PDMDEVREGCB Core;
63	/** A bit of padding. */
64	uint32_t u32[4];
65	/** VM Handle. */
66	PVM pVM;
67	} PDMDEVREGCBINT;
68	/** Pointer to a PDMDEVREGCBINT structure. */
69	typedef PDMDEVREGCBINT *PPDMDEVREGCBINT;
70	/** Pointer to a const PDMDEVREGCBINT structure. */
71	typedef const PDMDEVREGCBINT *PCPDMDEVREGCBINT;
72
73
74	/*******************************************************************************
75	* Internal Functions *
76	*******************************************************************************/
77	static DECLCALLBACK(int) pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pDevReg);
78	static DECLCALLBACK(void *) pdmR3DevReg_MMHeapAlloc(PPDMDEVREGCB pCallbacks, size_t cb);
79	static int pdmR3DevLoadModules(PVM pVM);
80	static int pdmR3DevLoad(PVM pVM, PPDMDEVREGCBINT pRegCB, const char pszFilename, const char pszName);
81
82
83
84
85	/**
86	* This function will initialize the devices for this VM instance.
87	*
88	*
89	* First of all this mean loading the builtin device and letting them
90	* register themselves. Beyond that any additional device modules are
91	* loaded and called for registration.
92	*
93	* Then the device configuration is enumerated, the instantiation order
94	* is determined, and finally they are instantiated.
95	*
96	* After all devices have been successfully instantiated the primary
97	* PCI Bus device is called to emulate the PCI BIOS, i.e. making the
98	* resource assignments. If there is no PCI device, this step is of course
99	* skipped.
100	*
101	* Finally the init completion routines of the instantiated devices
102	* are called.
103	*
104	* @returns VBox status code.
105	* @param pVM VM Handle.
106	*/
107	int pdmR3DevInit(PVM pVM)
108	{
109	LogFlow(("pdmR3DevInit:\n"));
110
111	AssertRelease(!(RT_OFFSETOF(PDMDEVINS, achInstanceData) & 15));
112	AssertRelease(sizeof(pVM->pdm.s.pDevInstances->Internal.s) <= sizeof(pVM->pdm.s.pDevInstances->Internal.padding));
113
114	/*
115	* Load device modules.
116	*/
117	int rc = pdmR3DevLoadModules(pVM);
118	if (RT_FAILURE(rc))
119	return rc;
120
121	#ifdef VBOX_WITH_USB
122	/* ditto for USB Devices. */
123	rc = pdmR3UsbLoadModules(pVM);
124	if (RT_FAILURE(rc))
125	return rc;
126	#endif
127
128	/*
129	* Get the RC & R0 devhlps and create the devhlp R3 task queue.
130	*/
131	PCPDMDEVHLPRC pDevHlpRC;
132	rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDevHlp", &pDevHlpRC);
133	AssertReleaseRCReturn(rc, rc);
134
135	PCPDMDEVHLPR0 pDevHlpR0;
136	rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0DevHlp", &pDevHlpR0);
137	AssertReleaseRCReturn(rc, rc);
138
139	rc = PDMR3QueueCreateInternal(pVM, sizeof(PDMDEVHLPTASK), 8, 0, pdmR3DevHlpQueueConsumer, true, "DevHlp",
140	&pVM->pdm.s.pDevHlpQueueR3);
141	AssertRCReturn(rc, rc);
142	pVM->pdm.s.pDevHlpQueueR0 = PDMQueueR0Ptr(pVM->pdm.s.pDevHlpQueueR3);
143	pVM->pdm.s.pDevHlpQueueRC = PDMQueueRCPtr(pVM->pdm.s.pDevHlpQueueR3);
144
145
146	/*
147	*
148	* Enumerate the device instance configurations
149	* and come up with a instantiation order.
150	*
151	*/
152	/* Switch to /Devices, which contains the device instantiations. */
153	PCFGMNODE pDevicesNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "Devices");
154
155	/*
156	* Count the device instances.
157	*/
158	PCFGMNODE pCur;
159	PCFGMNODE pInstanceNode;
160	unsigned cDevs = 0;
161	for (pCur = CFGMR3GetFirstChild(pDevicesNode); pCur; pCur = CFGMR3GetNextChild(pCur))
162	for (pInstanceNode = CFGMR3GetFirstChild(pCur); pInstanceNode; pInstanceNode = CFGMR3GetNextChild(pInstanceNode))
163	cDevs++;
164	if (!cDevs)
165	{
166	Log(("PDM: No devices were configured!\n"));
167	return VINF_SUCCESS;
168	}
169	Log2(("PDM: cDevs=%d!\n", cDevs));
170
171	/*
172	* Collect info on each device instance.
173	*/
174	struct DEVORDER
175	{
176	/** Configuration node. */
177	PCFGMNODE pNode;
178	/** Pointer to device. */
179	PPDMDEV pDev;
180	/** Init order. */
181	uint32_t u32Order;
182	/** VBox instance number. */
183	uint32_t iInstance;
184	} paDevs = (struct DEVORDER )alloca(sizeof(paDevs[0]) * (cDevs + 1)); /* (One extra for swapping) */
185	Assert(paDevs);
186	unsigned i = 0;
187	for (pCur = CFGMR3GetFirstChild(pDevicesNode); pCur; pCur = CFGMR3GetNextChild(pCur))
188	{
189	/* Get the device name. */
190	char szName[sizeof(paDevs[0].pDev->pDevReg->szDeviceName)];
191	rc = CFGMR3GetName(pCur, szName, sizeof(szName));
192	AssertMsgRCReturn(rc, ("Configuration error: device name is too long (or something)! rc=%Rrc\n", rc), rc);
193
194	/* Find the device. */
195	PPDMDEV pDev = pdmR3DevLookup(pVM, szName);
196	AssertMsgReturn(pDev, ("Configuration error: device '%s' not found!\n", szName), VERR_PDM_DEVICE_NOT_FOUND);
197
198	/* Configured priority or use default based on device class? */
199	uint32_t u32Order;
200	rc = CFGMR3QueryU32(pCur, "Priority", &u32Order);
201	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
202	{
203	uint32_t u32 = pDev->pDevReg->fClass;
204	for (u32Order = 1; !(u32 & u32Order); u32Order <<= 1)
205	/* nop */;
206	}
207	else
208	AssertMsgRCReturn(rc, ("Configuration error: reading \"Priority\" for the '%s' device failed rc=%Rrc!\n", szName, rc), rc);
209
210	/* Enumerate the device instances. */
211	uint32_t const iStart = i;
212	for (pInstanceNode = CFGMR3GetFirstChild(pCur); pInstanceNode; pInstanceNode = CFGMR3GetNextChild(pInstanceNode))
213	{
214	paDevs[i].pNode = pInstanceNode;
215	paDevs[i].pDev = pDev;
216	paDevs[i].u32Order = u32Order;
217
218	/* Get the instance number. */
219	char szInstance[32];
220	rc = CFGMR3GetName(pInstanceNode, szInstance, sizeof(szInstance));
221	AssertMsgRCReturn(rc, ("Configuration error: instance name is too long (or something)! rc=%Rrc\n", rc), rc);
222	char *pszNext = NULL;
223	rc = RTStrToUInt32Ex(szInstance, &pszNext, 0, &paDevs[i].iInstance);
224	AssertMsgRCReturn(rc, ("Configuration error: RTStrToInt32Ex failed on the instance name '%s'! rc=%Rrc\n", szInstance, rc), rc);
225	AssertMsgReturn(!*pszNext, ("Configuration error: the instance name '%s' isn't all digits. (%s)\n", szInstance, pszNext), VERR_INVALID_PARAMETER);
226
227	/* next instance */
228	i++;
229	}
230
231	/* check the number of instances */
232	if (i - iStart > pDev->pDevReg->cMaxInstances)
233	AssertLogRelMsgFailedReturn(("Configuration error: Too many instances of %s was configured: %u, max %u\n",
234	szName, i - iStart, pDev->pDevReg->cMaxInstances),
235	VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
236	} /* devices */
237	Assert(i == cDevs);
238
239	/*
240	* Sort the device array ascending on u32Order. (bubble)
241	*/
242	unsigned c = cDevs - 1;
243	while (c)
244	{
245	unsigned j = 0;
246	for (i = 0; i < c; i++)
247	if (paDevs[i].u32Order > paDevs[i + 1].u32Order)
248	{
249	paDevs[cDevs] = paDevs[i + 1];
250	paDevs[i + 1] = paDevs[i];
251	paDevs[i] = paDevs[cDevs];
252	j = i;
253	}
254	c = j;
255	}
256
257
258	/*
259	*
260	* Instantiate the devices.
261	*
262	*/
263	for (i = 0; i < cDevs; i++)
264	{
265	/*
266	* Gather a bit of config.
267	*/
268	/* trusted */
269	bool fTrusted;
270	rc = CFGMR3QueryBool(paDevs[i].pNode, "Trusted", &fTrusted);
271	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
272	fTrusted = false;
273	else if (RT_FAILURE(rc))
274	{
275	AssertMsgFailed(("configuration error: failed to query boolean \"Trusted\", rc=%Rrc\n", rc));
276	return rc;
277	}
278	/* config node */
279	PCFGMNODE pConfigNode = CFGMR3GetChild(paDevs[i].pNode, "Config");
280	if (!pConfigNode)
281	{
282	rc = CFGMR3InsertNode(paDevs[i].pNode, "Config", &pConfigNode);
283	if (RT_FAILURE(rc))
284	{
285	AssertMsgFailed(("Failed to create Config node! rc=%Rrc\n", rc));
286	return rc;
287	}
288	}
289	CFGMR3SetRestrictedRoot(pConfigNode);
290
291	/*
292	* Allocate the device instance.
293	*/
294	AssertReturn(paDevs[i].pDev->cInstances < paDevs[i].pDev->pDevReg->cMaxInstances, VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
295	size_t cb = RT_OFFSETOF(PDMDEVINS, achInstanceData[paDevs[i].pDev->pDevReg->cbInstance]);
296	cb = RT_ALIGN_Z(cb, 16);
297	PPDMDEVINS pDevIns;
298	if (paDevs[i].pDev->pDevReg->fFlags & (PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0))
299	rc = MMR3HyperAllocOnceNoRel(pVM, cb, 0, MM_TAG_PDM_DEVICE, (void **)&pDevIns);
300	else
301	rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_DEVICE, cb, (void **)&pDevIns);
302	if (RT_FAILURE(rc))
303	{
304	AssertMsgFailed(("Failed to allocate %d bytes of instance data for device '%s'. rc=%Rrc\n",
305	cb, paDevs[i].pDev->pDevReg->szDeviceName, rc));
306	return rc;
307	}
308
309	/*
310	* Initialize it.
311	*/
312	pDevIns->u32Version = PDM_DEVINS_VERSION;
313	//pDevIns->Internal.s.pNextR3 = NULL;
314	//pDevIns->Internal.s.pPerDeviceNextR3 = NULL;
315	pDevIns->Internal.s.pDevR3 = paDevs[i].pDev;
316	pDevIns->Internal.s.pVMR3 = pVM;
317	pDevIns->Internal.s.pVMR0 = pVM->pVMR0;
318	pDevIns->Internal.s.pVMRC = pVM->pVMRC;
319	//pDevIns->Internal.s.pLunsR3 = NULL;
320	pDevIns->Internal.s.pCfgHandle = paDevs[i].pNode;
321	//pDevIns->Internal.s.pPciDeviceR3 = NULL;
322	//pDevIns->Internal.s.pPciBusR3 = NULL;
323	//pDevIns->Internal.s.pPciDeviceR0 = 0;
324	//pDevIns->Internal.s.pPciBusR0 = 0;
325	//pDevIns->Internal.s.pPciDeviceRC = 0;
326	//pDevIns->Internal.s.pPciBusRC = 0;
327	pDevIns->Internal.s.fIntFlags = PDMDEVINSINT_FLAGS_SUSPENDED;
328	pDevIns->pDevHlpR3 = fTrusted ? &g_pdmR3DevHlpTrusted : &g_pdmR3DevHlpUnTrusted;
329	pDevIns->pDevHlpRC = pDevHlpRC;
330	pDevIns->pDevHlpR0 = pDevHlpR0;
331	pDevIns->pDevReg = paDevs[i].pDev->pDevReg;
332	pDevIns->pCfgHandle = pConfigNode;
333	pDevIns->iInstance = paDevs[i].iInstance;
334	pDevIns->pvInstanceDataR3 = &pDevIns->achInstanceData[0];
335	pDevIns->pvInstanceDataRC = pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC
336	? MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3) : NIL_RTRCPTR;
337	pDevIns->pvInstanceDataR0 = pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0
338	? MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3) : NIL_RTR0PTR;
339
340	/*
341	* Link it into all the lists.
342	*/
343	/* The global instance FIFO. */
344	PPDMDEVINS pPrev1 = pVM->pdm.s.pDevInstances;
345	if (!pPrev1)
346	pVM->pdm.s.pDevInstances = pDevIns;
347	else
348	{
349	while (pPrev1->Internal.s.pNextR3)
350	pPrev1 = pPrev1->Internal.s.pNextR3;
351	pPrev1->Internal.s.pNextR3 = pDevIns;
352	}
353
354	/* The per device instance FIFO. */
355	PPDMDEVINS pPrev2 = paDevs[i].pDev->pInstances;
356	if (!pPrev2)
357	paDevs[i].pDev->pInstances = pDevIns;
358	else
359	{
360	while (pPrev2->Internal.s.pPerDeviceNextR3)
361	pPrev2 = pPrev2->Internal.s.pPerDeviceNextR3;
362	pPrev2->Internal.s.pPerDeviceNextR3 = pDevIns;
363	}
364
365	/*
366	* Call the constructor.
367	*/
368	paDevs[i].pDev->cInstances++;
369	Log(("PDM: Constructing device '%s' instance %d...\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
370	rc = pDevIns->pDevReg->pfnConstruct(pDevIns, pDevIns->iInstance, pDevIns->pCfgHandle);
371	if (RT_FAILURE(rc))
372	{
373	LogRel(("PDM: Failed to construct '%s'/%d! %Rra\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
374	paDevs[i].pDev->cInstances--;
375	/* because we're damn lazy right now, we'll say that the destructor will be called even if the constructor fails. */
376	return rc;
377	}
378	} /* for device instances */
379
380	#ifdef VBOX_WITH_USB
381	/* ditto for USB Devices. */
382	rc = pdmR3UsbInstantiateDevices(pVM);
383	if (RT_FAILURE(rc))
384	return rc;
385	#endif
386
387
388	/*
389	*
390	* PCI BIOS Fake and Init Complete.
391	*
392	*/
393	if (pVM->pdm.s.aPciBuses[0].pDevInsR3)
394	{
395	pdmLock(pVM);
396	rc = pVM->pdm.s.aPciBuses[0].pfnFakePCIBIOSR3(pVM->pdm.s.aPciBuses[0].pDevInsR3);
397	pdmUnlock(pVM);
398	if (RT_FAILURE(rc))
399	{
400	AssertMsgFailed(("PCI BIOS fake failed rc=%Rrc\n", rc));
401	return rc;
402	}
403	}
404
405	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
406	{
407	if (pDevIns->pDevReg->pfnInitComplete)
408	{
409	rc = pDevIns->pDevReg->pfnInitComplete(pDevIns);
410	if (RT_FAILURE(rc))
411	{
412	AssertMsgFailed(("InitComplete on device '%s'/%d failed with rc=%Rrc\n",
413	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
414	return rc;
415	}
416	}
417	}
418
419	#ifdef VBOX_WITH_USB
420	/* ditto for USB Devices. */
421	rc = pdmR3UsbVMInitComplete(pVM);
422	if (RT_FAILURE(rc))
423	return rc;
424	#endif
425
426	LogFlow(("pdmR3DevInit: returns %Rrc\n", VINF_SUCCESS));
427	return VINF_SUCCESS;
428	}
429
430
431	/**
432	* Lookups a device structure by name.
433	* @internal
434	*/
435	PPDMDEV pdmR3DevLookup(PVM pVM, const char *pszName)
436	{
437	size_t cchName = strlen(pszName);
438	for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
439	if ( pDev->cchName == cchName
440	&& !strcmp(pDev->pDevReg->szDeviceName, pszName))
441	return pDev;
442	return NULL;
443	}
444
445
446	/**
447	* Loads the device modules.
448	*
449	* @returns VBox status code.
450	* @param pVM Pointer to the shared VM structure.
451	*/
452	static int pdmR3DevLoadModules(PVM pVM)
453	{
454	/*
455	* Initialize the callback structure.
456	*/
457	PDMDEVREGCBINT RegCB;
458	RegCB.Core.u32Version = PDM_DEVREG_CB_VERSION;
459	RegCB.Core.pfnRegister = pdmR3DevReg_Register;
460	RegCB.Core.pfnMMHeapAlloc = pdmR3DevReg_MMHeapAlloc;
461	RegCB.pVM = pVM;
462
463	/*
464	* Load the builtin module
465	*/
466	PCFGMNODE pDevicesNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM/Devices");
467	bool fLoadBuiltin;
468	int rc = CFGMR3QueryBool(pDevicesNode, "LoadBuiltin", &fLoadBuiltin);
469	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
470	fLoadBuiltin = true;
471	else if (RT_FAILURE(rc))
472	{
473	AssertMsgFailed(("Configuration error: Querying boolean \"LoadBuiltin\" failed with %Rrc\n", rc));
474	return rc;
475	}
476	if (fLoadBuiltin)
477	{
478	/* make filename */
479	char pszFilename = pdmR3FileR3("VBoxDD", / fShared = */ true);
480	if (!pszFilename)
481	return VERR_NO_TMP_MEMORY;
482	rc = pdmR3DevLoad(pVM, &RegCB, pszFilename, "VBoxDD");
483	RTMemTmpFree(pszFilename);
484	if (RT_FAILURE(rc))
485	return rc;
486
487	/* make filename */
488	pszFilename = pdmR3FileR3("VBoxDD2", /* fShared = */ true);
489	if (!pszFilename)
490	return VERR_NO_TMP_MEMORY;
491	rc = pdmR3DevLoad(pVM, &RegCB, pszFilename, "VBoxDD2");
492	RTMemTmpFree(pszFilename);
493	if (RT_FAILURE(rc))
494	return rc;
495	}
496
497	/*
498	* Load additional device modules.
499	*/
500	PCFGMNODE pCur;
501	for (pCur = CFGMR3GetFirstChild(pDevicesNode); pCur; pCur = CFGMR3GetNextChild(pCur))
502	{
503	/*
504	* Get the name and path.
505	*/
506	char szName[PDMMOD_NAME_LEN];
507	rc = CFGMR3GetName(pCur, &szName[0], sizeof(szName));
508	if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
509	{
510	AssertMsgFailed(("configuration error: The module name is too long, cchName=%zu.\n", CFGMR3GetNameLen(pCur)));
511	return VERR_PDM_MODULE_NAME_TOO_LONG;
512	}
513	else if (RT_FAILURE(rc))
514	{
515	AssertMsgFailed(("CFGMR3GetName -> %Rrc.\n", rc));
516	return rc;
517	}
518
519	/* the path is optional, if no path the module name + path is used. */
520	char szFilename[RTPATH_MAX];
521	rc = CFGMR3QueryString(pCur, "Path", &szFilename[0], sizeof(szFilename));
522	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
523	strcpy(szFilename, szName);
524	else if (RT_FAILURE(rc))
525	{
526	AssertMsgFailed(("configuration error: Failure to query the module path, rc=%Rrc.\n", rc));
527	return rc;
528	}
529
530	/* prepend path? */
531	if (!RTPathHavePath(szFilename))
532	{
533	char *psz = pdmR3FileR3(szFilename);
534	if (!psz)
535	return VERR_NO_TMP_MEMORY;
536	size_t cch = strlen(psz) + 1;
537	if (cch > sizeof(szFilename))
538	{
539	RTMemTmpFree(psz);
540	AssertMsgFailed(("Filename too long! cch=%d '%s'\n", cch, psz));
541	return VERR_FILENAME_TOO_LONG;
542	}
543	memcpy(szFilename, psz, cch);
544	RTMemTmpFree(psz);
545	}
546
547	/*
548	* Load the module and register it's devices.
549	*/
550	rc = pdmR3DevLoad(pVM, &RegCB, szFilename, szName);
551	if (RT_FAILURE(rc))
552	return rc;
553	}
554
555	return VINF_SUCCESS;
556	}
557
558
559	/**
560	* Loads one device module and call the registration entry point.
561	*
562	* @returns VBox status code.
563	* @param pVM VM handle.
564	* @param pRegCB The registration callback stuff.
565	* @param pszFilename Module filename.
566	* @param pszName Module name.
567	*/
568	static int pdmR3DevLoad(PVM pVM, PPDMDEVREGCBINT pRegCB, const char pszFilename, const char pszName)
569	{
570	/*
571	* Load it.
572	*/
573	int rc = pdmR3LoadR3U(pVM->pUVM, pszFilename, pszName);
574	if (RT_SUCCESS(rc))
575	{
576	/*
577	* Get the registration export and call it.
578	*/
579	FNPDMVBOXDEVICESREGISTER *pfnVBoxDevicesRegister;
580	rc = PDMR3LdrGetSymbolR3(pVM, pszName, "VBoxDevicesRegister", (void **)&pfnVBoxDevicesRegister);
581	if (RT_SUCCESS(rc))
582	{
583	Log(("PDM: Calling VBoxDevicesRegister (%p) of %s (%s)\n", pfnVBoxDevicesRegister, pszName, pszFilename));
584	rc = pfnVBoxDevicesRegister(&pRegCB->Core, VBOX_VERSION);
585	if (RT_SUCCESS(rc))
586	Log(("PDM: Successfully loaded device module %s (%s).\n", pszName, pszFilename));
587	else
588	AssertMsgFailed(("VBoxDevicesRegister failed with rc=%Rrc for module %s (%s)\n", rc, pszName, pszFilename));
589	}
590	else
591	{
592	AssertMsgFailed(("Failed to locate 'VBoxDevicesRegister' in %s (%s) rc=%Rrc\n", pszName, pszFilename, rc));
593	if (rc == VERR_SYMBOL_NOT_FOUND)
594	rc = VERR_PDM_NO_REGISTRATION_EXPORT;
595	}
596	}
597	else
598	AssertMsgFailed(("Failed to load %s %s!\n", pszFilename, pszName));
599	return rc;
600	}
601
602
603	/**
604	* Registers a device with the current VM instance.
605	*
606	* @returns VBox status code.
607	* @param pCallbacks Pointer to the callback table.
608	* @param pDevReg Pointer to the device registration record.
609	* This data must be permanent and readonly.
610	*/
611	static DECLCALLBACK(int) pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pDevReg)
612	{
613	/*
614	* Validate the registration structure.
615	*/
616	Assert(pDevReg);
617	if (pDevReg->u32Version != PDM_DEVREG_VERSION)
618	{
619	AssertMsgFailed(("Unknown struct version %#x!\n", pDevReg->u32Version));
620	return VERR_PDM_UNKNOWN_DEVREG_VERSION;
621	}
622	if ( !pDevReg->szDeviceName[0]
623	\|\| strlen(pDevReg->szDeviceName) >= sizeof(pDevReg->szDeviceName))
624	{
625	AssertMsgFailed(("Invalid name '%s'\n", pDevReg->szDeviceName));
626	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
627	}
628	if ( (pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
629	&& ( !pDevReg->szRCMod[0]
630	\|\| strlen(pDevReg->szRCMod) >= sizeof(pDevReg->szRCMod)))
631	{
632	AssertMsgFailed(("Invalid GC module name '%s' - (Device %s)\n", pDevReg->szRCMod, pDevReg->szDeviceName));
633	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
634	}
635	if ( (pDevReg->fFlags & PDM_DEVREG_FLAGS_R0)
636	&& ( !pDevReg->szR0Mod[0]
637	\|\| strlen(pDevReg->szR0Mod) >= sizeof(pDevReg->szR0Mod)))
638	{
639	AssertMsgFailed(("Invalid R0 module name '%s' - (Device %s)\n", pDevReg->szR0Mod, pDevReg->szDeviceName));
640	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
641	}
642	if ((pDevReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) != PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT)
643	{
644	AssertMsgFailed(("Invalid host bits flags! fFlags=%#x (Device %s)\n", pDevReg->fFlags, pDevReg->szDeviceName));
645	return VERR_PDM_INVALID_DEVICE_HOST_BITS;
646	}
647	if (!(pDevReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK))
648	{
649	AssertMsgFailed(("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pDevReg->fFlags, pDevReg->szDeviceName));
650	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
651	}
652	if (!pDevReg->fClass)
653	{
654	AssertMsgFailed(("No class! (Device %s)\n", pDevReg->szDeviceName));
655	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
656	}
657	if (pDevReg->cMaxInstances <= 0)
658	{
659	AssertMsgFailed(("Max instances %u! (Device %s)\n", pDevReg->cMaxInstances, pDevReg->szDeviceName));
660	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
661	}
662	if (pDevReg->cbInstance > (RTUINT)(pDevReg->fFlags & (PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0) ? 96 * _1K : _1M))
663	{
664	AssertMsgFailed(("Instance size %d bytes! (Device %s)\n", pDevReg->cbInstance, pDevReg->szDeviceName));
665	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
666	}
667	if (!pDevReg->pfnConstruct)
668	{
669	AssertMsgFailed(("No constructore! (Device %s)\n", pDevReg->szDeviceName));
670	return VERR_PDM_INVALID_DEVICE_REGISTRATION;
671	}
672	/* Check matching guest bits last without any asserting. Enables trial and error registration. */
673	if (!(pDevReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT))
674	{
675	Log(("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pDevReg->szDeviceName));
676	return VERR_PDM_INVALID_DEVICE_GUEST_BITS;
677	}
678	AssertLogRelMsg(pDevReg->u32VersionEnd == PDM_DEVREG_VERSION,
679	("u32VersionEnd=%#x, expected %#x. (szDeviceName=%s)\n",
680	pDevReg->u32VersionEnd, PDM_DEVREG_VERSION, pDevReg->szDeviceName));
681
682	/*
683	* Check for duplicate and find FIFO entry at the same time.
684	*/
685	PCPDMDEVREGCBINT pRegCB = (PCPDMDEVREGCBINT)pCallbacks;
686	PPDMDEV pDevPrev = NULL;
687	PPDMDEV pDev = pRegCB->pVM->pdm.s.pDevs;
688	for (; pDev; pDevPrev = pDev, pDev = pDev->pNext)
689	{
690	if (!strcmp(pDev->pDevReg->szDeviceName, pDevReg->szDeviceName))
691	{
692	AssertMsgFailed(("Device '%s' already exists\n", pDevReg->szDeviceName));
693	return VERR_PDM_DEVICE_NAME_CLASH;
694	}
695	}
696
697	/*
698	* Allocate new device structure and insert it into the list.
699	*/
700	pDev = (PPDMDEV)MMR3HeapAlloc(pRegCB->pVM, MM_TAG_PDM_DEVICE, sizeof(*pDev));
701	if (pDev)
702	{
703	pDev->pNext = NULL;
704	pDev->cInstances = 0;
705	pDev->pInstances = NULL;
706	pDev->pDevReg = pDevReg;
707	pDev->cchName = (uint32_t)strlen(pDevReg->szDeviceName);
708
709	if (pDevPrev)
710	pDevPrev->pNext = pDev;
711	else
712	pRegCB->pVM->pdm.s.pDevs = pDev;
713	Log(("PDM: Registered device '%s'\n", pDevReg->szDeviceName));
714	return VINF_SUCCESS;
715	}
716	return VERR_NO_MEMORY;
717	}
718
719
720	/**
721	* Allocate memory which is associated with current VM instance
722	* and automatically freed on it's destruction.
723	*
724	* @returns Pointer to allocated memory. The memory is NOT zero-ed.
725	* @param pCallbacks Pointer to the callback table.
726	* @param cb Number of bytes to allocate.
727	*/
728	static DECLCALLBACK(void *) pdmR3DevReg_MMHeapAlloc(PPDMDEVREGCB pCallbacks, size_t cb)
729	{
730	Assert(pCallbacks);
731	Assert(pCallbacks->u32Version == PDM_DEVREG_CB_VERSION);
732
733	void *pv = MMR3HeapAlloc(((PPDMDEVREGCBINT)pCallbacks)->pVM, MM_TAG_PDM_DEVICE_USER, cb);
734	LogFlow(("pdmR3DevReg_MMHeapAlloc(,%#zx): returns %p\n", cb, pv));
735	return pv;
736	}
737
738
739	/**
740	* Locates a LUN.
741	*
742	* @returns VBox status code.
743	* @param pVM VM Handle.
744	* @param pszDevice Device name.
745	* @param iInstance Device instance.
746	* @param iLun The Logical Unit to obtain the interface of.
747	* @param ppLun Where to store the pointer to the LUN if found.
748	* @thread Try only do this in EMT...
749	*/
750	int pdmR3DevFindLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPPDMLUN ppLun)
751	{
752	/*
753	* Iterate registered devices looking for the device.
754	*/
755	size_t cchDevice = strlen(pszDevice);
756	for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
757	{
758	if ( pDev->cchName == cchDevice
759	&& !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
760	{
761	/*
762	* Iterate device instances.
763	*/
764	for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextR3)
765	{
766	if (pDevIns->iInstance == iInstance)
767	{
768	/*
769	* Iterate luns.
770	*/
771	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
772	{
773	if (pLun->iLun == iLun)
774	{
775	*ppLun = pLun;
776	return VINF_SUCCESS;
777	}
778	}
779	return VERR_PDM_LUN_NOT_FOUND;
780	}
781	}
782	return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
783	}
784	}
785	return VERR_PDM_DEVICE_NOT_FOUND;
786	}
787
788
789	/**
790	* Attaches a preconfigured driver to an existing device instance.
791	*
792	* This is used to change drivers and suchlike at runtime.
793	*
794	* @returns VBox status code.
795	* @param pVM VM Handle.
796	* @param pszDevice Device name.
797	* @param iInstance Device instance.
798	* @param iLun The Logical Unit to obtain the interface of.
799	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
800	* @param ppBase Where to store the base interface pointer. Optional.
801	* @thread EMT
802	*/
803	VMMR3DECL(int) PDMR3DeviceAttach(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, uint32_t fFlags, PPPDMIBASE ppBase)
804	{
805	VM_ASSERT_EMT(pVM);
806	LogFlow(("PDMR3DeviceAttach: pszDevice=%p:{%s} iInstance=%d iLun=%d fFlags=%#x ppBase=%p\n",
807	pszDevice, pszDevice, iInstance, iLun, fFlags, ppBase));
808
809	/*
810	* Find the LUN in question.
811	*/
812	PPDMLUN pLun;
813	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
814	if (RT_SUCCESS(rc))
815	{
816	/*
817	* Can we attach anything at runtime?
818	*/
819	PPDMDEVINS pDevIns = pLun->pDevIns;
820	if (pDevIns->pDevReg->pfnAttach)
821	{
822	if (!pLun->pTop)
823	{
824	rc = pDevIns->pDevReg->pfnAttach(pDevIns, iLun, fFlags);
825	}
826	else
827	rc = VERR_PDM_DRIVER_ALREADY_ATTACHED;
828	}
829	else
830	rc = VERR_PDM_DEVICE_NO_RT_ATTACH;
831
832	if (ppBase)
833	*ppBase = pLun->pTop ? &pLun->pTop->IBase : NULL;
834	}
835	else if (ppBase)
836	*ppBase = NULL;
837
838	if (ppBase)
839	LogFlow(("PDMR3DeviceAttach: returns %Rrc ppBase=%p\n", rc, ppBase));
840	else
841	LogFlow(("PDMR3DeviceAttach: returns %Rrc\n", rc));
842	return rc;
843	}
844
845
846	/**
847	* Detaches a driver chain from an existing device instance.
848	*
849	* This is used to change drivers and suchlike at runtime.
850	*
851	* @returns VBox status code.
852	* @param pVM VM Handle.
853	* @param pszDevice Device name.
854	* @param iInstance Device instance.
855	* @param iLun The Logical Unit to obtain the interface of.
856	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
857	* @thread EMT
858	*/
859	VMMR3DECL(int) PDMR3DeviceDetach(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, uint32_t fFlags)
860	{
861	return PDMR3DriverDetach(pVM, pszDevice, iInstance, iLun, NULL, 0, fFlags);
862	}
863
864
865	/**
866	* Attaches a preconfigured driver to an existing device or driver instance.
867	*
868	* This is used to change drivers and suchlike at runtime. The driver or device
869	* at the end of the chain will be told to attach to whatever is configured
870	* below it.
871	*
872	* @returns VBox status code.
873	* @param pVM VM Handle.
874	* @param pszDevice Device name.
875	* @param iInstance Device instance.
876	* @param iLun The Logical Unit to obtain the interface of.
877	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
878	* @param ppBase Where to store the base interface pointer. Optional.
879	*
880	* @thread EMT
881	*/
882	VMMR3DECL(int) PDMR3DriverAttach(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, uint32_t fFlags, PPPDMIBASE ppBase)
883	{
884	VM_ASSERT_EMT(pVM);
885	LogFlow(("PDMR3DriverAttach: pszDevice=%p:{%s} iInstance=%d iLun=%d fFlags=%#x ppBase=%p\n",
886	pszDevice, pszDevice, iInstance, iLun, fFlags, ppBase));
887
888	if (ppBase)
889	*ppBase = NULL;
890
891	/*
892	* Find the LUN in question.
893	*/
894	PPDMLUN pLun;
895	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
896	if (RT_SUCCESS(rc))
897	{
898	/*
899	* Anything attached to the LUN?
900	*/
901	PPDMDRVINS pDrvIns = pLun->pTop;
902	if (!pDrvIns)
903	{
904	/* No, ask the device to attach to the new stuff. */
905	PPDMDEVINS pDevIns = pLun->pDevIns;
906	if (pDevIns->pDevReg->pfnAttach)
907	{
908	rc = pDevIns->pDevReg->pfnAttach(pDevIns, iLun, fFlags);
909	if (RT_SUCCESS(rc) && ppBase)
910	*ppBase = pLun->pTop ? &pLun->pTop->IBase : NULL;
911	}
912	else
913	rc = VERR_PDM_DEVICE_NO_RT_ATTACH;
914	}
915	else
916	{
917	/* Yes, find the bottom most driver and ask it to attach to the new stuff. */
918	while (pDrvIns->Internal.s.pDown)
919	pDrvIns = pDrvIns->Internal.s.pDown;
920	if (pDrvIns->pDrvReg->pfnAttach)
921	{
922	rc = pDrvIns->pDrvReg->pfnAttach(pDrvIns, fFlags);
923	if (RT_SUCCESS(rc) && ppBase)
924	*ppBase = pDrvIns->Internal.s.pDown
925	? &pDrvIns->Internal.s.pDown->IBase
926	: NULL;
927	}
928	else
929	rc = VERR_PDM_DRIVER_NO_RT_ATTACH;
930	}
931	}
932
933	if (ppBase)
934	LogFlow(("PDMR3DriverAttach: returns %Rrc ppBase=%p\n", rc, ppBase));
935	else
936	LogFlow(("PDMR3DriverAttach: returns %Rrc\n", rc));
937	return rc;
938	}
939
940
941	/**
942	* Detaches the specified driver instance.
943	*
944	* This is used to replumb drivers at runtime for simulating hot plugging and
945	* media changes.
946	*
947	* This is a superset of PDMR3DeviceDetach. It allows detaching drivers from
948	* any driver or device by specifying the driver to start detaching at. The
949	* only prerequisite is that the driver or device above implements the
950	* pfnDetach callback (PDMDRVREG / PDMDEVREG).
951	*
952	* @returns VBox status code.
953	* @param pVM VM Handle.
954	* @param pszDevice Device name.
955	* @param iDevIns Device instance.
956	* @param iLun The Logical Unit in which to look for the driver.
957	* @param pszDriver The name of the driver which to detach. If NULL
958	* then the entire driver chain is detatched.
959	* @param iOccurance The occurance of that driver in the chain. This is
960	* usually 0.
961	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
962	* @thread EMT
963	*/
964	VMMR3DECL(int) PDMR3DriverDetach(PVM pVM, const char *pszDevice, unsigned iDevIns, unsigned iLun,
965	const char *pszDriver, unsigned iOccurance, uint32_t fFlags)
966	{
967	LogFlow(("PDMR3DriverDetach: pszDevice=%p:{%s} iDevIns=%u iLun=%u pszDriver=%p:{%s} iOccurance=%u fFlags=%#x\n",
968	pszDevice, pszDevice, iDevIns, iLun, pszDriver, iOccurance, fFlags));
969	VM_ASSERT_EMT(pVM);
970	AssertPtr(pszDevice);
971	AssertPtrNull(pszDriver);
972	Assert(iOccurance == 0 \|\| pszDriver);
973	Assert(!(fFlags & ~(PDM_TACH_FLAGS_NOT_HOT_PLUG)));
974
975	/*
976	* Find the LUN in question.
977	*/
978	PPDMLUN pLun;
979	int rc = pdmR3DevFindLun(pVM, pszDevice, iDevIns, iLun, &pLun);
980	if (RT_SUCCESS(rc))
981	{
982	/*
983	* Locate the driver.
984	*/
985	PPDMDRVINS pDrvIns = pLun->pTop;
986	if (pDrvIns)
987	{
988	if (pszDriver)
989	{
990	while (pDrvIns)
991	{
992	if (!strcmp(pDrvIns->pDrvReg->szDriverName, pszDriver))
993	{
994	if (iOccurance == 0)
995	break;
996	iOccurance--;
997	}
998	pDrvIns = pDrvIns->Internal.s.pDown;
999	}
1000	}
1001	if (pDrvIns)
1002	rc = pdmR3DrvDetach(pDrvIns, fFlags);
1003	else
1004	rc = VERR_PDM_DRIVER_INSTANCE_NOT_FOUND;
1005	}
1006	else
1007	rc = VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN;
1008	}
1009
1010	LogFlow(("PDMR3DriverDetach: returns %Rrc\n", rc));
1011	return rc;
1012	}
1013
1014
1015	/**
1016	* Runtime detach and reattach of a new driver chain or sub chain.
1017	*
1018	* This is intended to be called on a non-EMT thread, this will instantiate the
1019	* new driver (sub-)chain, and then the EMTs will do the actual replumbing. The
1020	* destruction of the old driver chain will be taken care of on the calling
1021	* thread.
1022	*
1023	* @returns VBox status code.
1024	* @param pVM VM Handle.
1025	* @param pszDevice Device name.
1026	* @param iDevIns Device instance.
1027	* @param iLun The Logical Unit in which to look for the driver.
1028	* @param pszDriver The name of the driver which to detach and replace.
1029	* If NULL then the entire driver chain is to be
1030	* reattached.
1031	* @param iOccurance The occurance of that driver in the chain. This is
1032	* usually 0.
1033	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1034	* @param pCfg The configuration of the new driver chain that is
1035	* going to be attached. The subtree starts with the
1036	* node containing a Driver key, a Config subtree and
1037	* optionally an AttachedDriver subtree.
1038	* If this parameter is NULL, then this call will work
1039	* like at a non-pause version of PDMR3DriverDetach.
1040	* @param ppBase Where to store the base interface pointer to the new
1041	* driver. Optional.
1042	*
1043	* @thread Any thread. The EMTs will be involved at some point though.
1044	*/
1045	VMMR3DECL(int) PDMR3DriverReattach(PVM pVM, const char *pszDevice, unsigned iDevIns, unsigned iLun,
1046	const char *pszDriver, unsigned iOccurance, uint32_t fFlags,
1047	PCFGMNODE pCfg, PPPDMIBASE ppBase)
1048	{
1049	return VERR_NOT_IMPLEMENTED;
1050	}
1051

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

source: vbox/trunk/src/VBox/VMM/PDMDevice.cpp@ 24911

Download in other formats: