PDM.cpp@ 2233

Last change on this file since 2233 was 1812, checked in by vboxsync, 18 years ago
r=bird: Not entirely sure if inverting the destruction order is a good thing or not, but if it is, we should also invert the notification order for consistency. It would be better if drivers/devices didn't rely on order at all.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 32.2 KB

Line
1	/* $Id: PDM.cpp 1812 2007-03-29 17:49:36Z vboxsync $ */
2	/** @file
3	* PDM - Pluggable Device Manager.
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22
23	/** @page pg_pdm PDM - The Pluggable Device Manager
24	*
25	* VBox is designed to be very configurable, i.e. the ability to select
26	* virtual devices and configure them uniquely for a VM. For this reason
27	* virtual devices are not statically linked with the VMM but loaded and
28	* linked at runtime thru the Configuration Manager (CFGM). PDM will use
29	* CFGM to enumerate devices which needs loading and instantiation.
30	*
31	*
32	* @section sec_pdm_dev The Pluggable Device
33	*
34	* Devices register themselves when the module containing them is loaded.
35	* PDM will call an entry point 'VBoxDevicesRegister' when loading a device
36	* module. The device module will then use the supplied callback table to
37	* check the VMM version and to register its devices. Each device have an
38	* unique (for the configured VM) name (string). The name is not only used
39	* in PDM but in CFGM - to organize device and device instance settings - and
40	* by anyone who wants to do ioctls to the device.
41	*
42	* When all device modules have been successfully loaded PDM will instantiate
43	* those devices which are configured for the VM. Mark that this might mean
44	* creating several instances of some devices. When instantiating a device
45	* PDM provides device instance memory and a callback table with the VM APIs
46	* which the device instance is trusted with.
47	*
48	* Some devices are trusted devices, most are not. The trusted devices are
49	* an integrated part of the VM and can obtain the VM handle from their
50	* device instance handles, thus enabling them to call any VM api. Untrusted
51	* devices are can only use the callbacks provided during device
52	* instantiation.
53	*
54	* The guest context extention (optional) of a device is initialized as part
55	* of the GC init. A device marks in it's registration structure that it have
56	* a GC part, in which module and which name the entry point have. PDM will
57	* use its loader facilities to load this module into GC and to find the
58	* specified entry point.
59	*
60	* When writing a GC extention the programmer must keep in mind that this
61	* code will be relocated, so that using global/static pointer variables
62	* won't work.
63	*
64	*
65	* @section sec_pdm_drv The Pluggable Drivers
66	*
67	* The VM devices are often accessing host hardware or OS facilities. For
68	* most devices these facilities can be abstracted in one or more levels.
69	* These abstractions are called drivers.
70	*
71	* For instance take a DVD/CD drive. This can be connected to a SCSI
72	* controller, EIDE controller or SATA controller. The basics of the
73	* DVD/CD drive implementation remains the same - eject, insert,
74	* read, seek, and such. (For the scsi case, you might wanna speak SCSI
75	* directly to, but that can of course be fixed.) So, it makes much sense to
76	* have a generic CD/DVD driver which implements this.
77	*
78	* Then the media 'inserted' into the DVD/CD drive can be a ISO image, or
79	* it can be read from a real CD or DVD drive (there are probably other
80	* custom formats someone could desire to read or construct too). So, it
81	* would make sense to have abstracted interfaces for dealing with this
82	* in a generic way so the cdrom unit doesn't have to implement it all.
83	* Thus we have created the CDROM/DVD media driver family.
84	*
85	* So, for this example the IDE controller #1 (i.e. secondary) will have
86	* the DVD/CD Driver attached to it's LUN #0 (master). When a media is mounted
87	* the DVD/CD Driver will have a ISO, NativeCD, NativeDVD or RAW (media) Driver
88	* attached.
89	*
90	* It is possible to configure many levels of drivers inserting filters, loggers,
91	* or whatever you desire into the chain.
92	*
93	*
94	* @subsection sec_pdm_drv_interfaces Interfaces
95	*
96	* The pluggable drivers exposes one standard interface (callback table) which
97	* is used to construct, destruct, attach, detach, and query other interfaces.
98	* A device will query the interfaces required for it's operation during init
99	* and hotplug. PDM will query some interfaces during runtime mounting too.
100	*
101	* ... list interfaces ...
102	*
103	*/
104
105
106	/*******************************************************************************
107	* Header Files *
108	*******************************************************************************/
109	#define LOG_GROUP LOG_GROUP_PDM
110	#include "PDMInternal.h"
111	#include <VBox/pdm.h>
112	#include <VBox/mm.h>
113	#include <VBox/ssm.h>
114	#include <VBox/vm.h>
115	#include <VBox/vmm.h>
116	#include <VBox/param.h>
117	#include <VBox/err.h>
118	#include <VBox/sup.h>
119
120	#include <VBox/log.h>
121	#include <iprt/asm.h>
122	#include <iprt/assert.h>
123	#include <iprt/alloc.h>
124	#include <iprt/ldr.h>
125	#include <iprt/path.h>
126	#include <iprt/string.h>
127
128
129	/*******************************************************************************
130	* Defined Constants And Macros *
131	*******************************************************************************/
132	/** The PDM saved state version. */
133	#define PDM_SAVED_STATE_VERSION 3
134
135
136	/*******************************************************************************
137	* Internal Functions *
138	*******************************************************************************/
139	static DECLCALLBACK(int) pdmR3Save(PVM pVM, PSSMHANDLE pSSM);
140	static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
141	static DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM);
142	static DECLCALLBACK(void) pdmR3PollerTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
143
144
145
146	/**
147	* Initializes the PDM.
148	*
149	* @returns VBox status code.
150	* @param pVM The VM to operate on.
151	*/
152	PDMR3DECL(int) PDMR3Init(PVM pVM)
153	{
154	LogFlow(("PDMR3Init\n"));
155	/*
156	* Assert alignment and sizes.
157	*/
158	AssertRelease(!(RT_OFFSETOF(VM, pdm.s) & 31));
159	AssertRelease(sizeof(pVM->pdm.s) <= sizeof(pVM->pdm.padding));
160
161	/*
162	* Init the structure.
163	*/
164	pVM->pdm.s.offVM = RT_OFFSETOF(VM, pdm.s);
165
166	int rc = TMR3TimerCreateInternal(pVM, TMCLOCK_VIRTUAL, pdmR3PollerTimer, NULL, "PDM Poller", &pVM->pdm.s.pTimerPollers);
167	AssertRC(rc);
168
169	/*
170	* Initialize sub compontents.
171	*/
172	rc = pdmR3CritSectInit(pVM);
173	if (VBOX_SUCCESS(rc))
174	{
175	#ifdef VBOX_WITH_PDM_LOCK
176	rc = PDMR3CritSectInit(pVM, &pVM->pdm.s.CritSect, "PDM");
177	if (VBOX_SUCCESS(rc))
178	#endif
179	rc = pdmR3LdrInit(pVM);
180	if (VBOX_SUCCESS(rc))
181	{
182	rc = pdmR3DrvInit(pVM);
183	if (VBOX_SUCCESS(rc))
184	{
185	rc = pdmR3DevInit(pVM);
186	if (VBOX_SUCCESS(rc))
187	{
188	/*
189	* Register the saved state data unit.
190	*/
191	rc = SSMR3RegisterInternal(pVM, "pdm", 1, PDM_SAVED_STATE_VERSION, 128,
192	NULL, pdmR3Save, NULL,
193	pdmR3LoadPrep, pdmR3Load, NULL);
194	if (VBOX_SUCCESS(rc))
195	{
196	LogFlow(("PDM: Successfully initialized\n"));
197	return rc;
198	}
199
200	}
201	}
202	}
203	}
204
205	/*
206	* Cleanup and return failure.
207	*/
208	PDMR3Term(pVM);
209	LogFlow(("PDMR3Init: returns %Vrc\n", rc));
210	return rc;
211	}
212
213
214	/**
215	* Applies relocations to data and code managed by this
216	* component. This function will be called at init and
217	* whenever the VMM need to relocate it self inside the GC.
218	*
219	* @param pVM VM handle.
220	* @param offDelta Relocation delta relative to old location.
221	* @remark The loader subcomponent is relocated by PDMR3LdrRelocate() very
222	* early in the relocation phase.
223	*/
224	PDMR3DECL(void) PDMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
225	{
226	LogFlow(("PDMR3Relocate\n"));
227
228	/*
229	* Queues.
230	*/
231	pdmR3QueueRelocate(pVM, offDelta);
232	pVM->pdm.s.pDevHlpQueueGC = PDMQueueGCPtr(pVM->pdm.s.pDevHlpQueueHC);
233
234	/*
235	* Critical sections.
236	*/
237	pdmR3CritSectRelocate(pVM);
238
239	/*
240	* The registered PIC.
241	*/
242	if (pVM->pdm.s.Pic.pDevInsGC)
243	{
244	pVM->pdm.s.Pic.pDevInsGC += offDelta;
245	pVM->pdm.s.Pic.pfnSetIrqGC += offDelta;
246	pVM->pdm.s.Pic.pfnGetInterruptGC += offDelta;
247	}
248
249	/*
250	* The registered APIC.
251	*/
252	if (pVM->pdm.s.Apic.pDevInsGC)
253	{
254	pVM->pdm.s.Apic.pDevInsGC += offDelta;
255	pVM->pdm.s.Apic.pfnGetInterruptGC += offDelta;
256	pVM->pdm.s.Apic.pfnSetBaseGC += offDelta;
257	pVM->pdm.s.Apic.pfnGetBaseGC += offDelta;
258	pVM->pdm.s.Apic.pfnSetTPRGC += offDelta;
259	pVM->pdm.s.Apic.pfnGetTPRGC += offDelta;
260	pVM->pdm.s.Apic.pfnBusDeliverGC += offDelta;
261	}
262
263	/*
264	* The registered I/O APIC.
265	*/
266	if (pVM->pdm.s.IoApic.pDevInsGC)
267	{
268	pVM->pdm.s.IoApic.pDevInsGC += offDelta;
269	pVM->pdm.s.IoApic.pfnSetIrqGC += offDelta;
270	}
271
272	/*
273	* The register PCI Buses.
274	*/
275	for (unsigned i = 0; i < ELEMENTS(pVM->pdm.s.aPciBuses); i++)
276	{
277	if (pVM->pdm.s.aPciBuses[i].pDevInsGC)
278	{
279	pVM->pdm.s.aPciBuses[i].pDevInsGC += offDelta;
280	pVM->pdm.s.aPciBuses[i].pfnSetIrqGC += offDelta;
281	}
282	}
283
284	/*
285	* Devices.
286	*/
287	GCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
288	int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmGCDevHlp", &pDevHlpGC);
289	AssertReleaseMsgRC(rc, ("rc=%Vrc when resolving g_pdmGCDevHlp\n", rc));
290	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
291	{
292	if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC)
293	{
294	pDevIns->pDevHlpGC = pDevHlpGC;
295	pDevIns->pvInstanceDataGC = MMHyperHC2GC(pVM, pDevIns->pvInstanceDataHC);
296	pDevIns->Internal.s.pVMGC = pVM->pVMGC;
297	if (pDevIns->Internal.s.pPciBusHC)
298	pDevIns->Internal.s.pPciBusGC = MMHyperHC2GC(pVM, pDevIns->Internal.s.pPciBusHC);
299	if (pDevIns->Internal.s.pPciDeviceHC)
300	pDevIns->Internal.s.pPciDeviceGC = MMHyperHC2GC(pVM, pDevIns->Internal.s.pPciDeviceHC);
301	if (pDevIns->pDevReg->pfnRelocate)
302	{
303	LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
304	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
305	pDevIns->pDevReg->pfnRelocate(pDevIns, offDelta);
306	}
307	}
308	}
309	}
310
311
312	/**
313	* Terminates the PDM.
314	*
315	* Termination means cleaning up and freeing all resources,
316	* the VM it self is at this point powered off or suspended.
317	*
318	* @returns VBox status code.
319	* @param pVM The VM to operate on.
320	*/
321	PDMR3DECL(int) PDMR3Term(PVM pVM)
322	{
323	LogFlow(("PDMR3Term:\n"));
324	AssertMsg(pVM->pdm.s.offVM, ("bad init order!\n"));
325
326	/*
327	* Iterate the device instances.
328	* The attached drivers are processed first.
329	* N.B. There is no need to mess around freeing memory allocated
330	* from any MM heap since MM will do that in its Term function.
331	*/
332	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
333	{
334	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
335	{
336	/* Find the bottom driver. */
337	/** @todo Add pBottom to PDMLUN, this might not be the only place we will have to work it from the bottom up. */
338	PPDMDRVINS pDrvIns = pLun->pTop;
339	while (pDrvIns && pDrvIns->Internal.s.pDown)
340	pDrvIns = pDrvIns->Internal.s.pDown;
341
342	/* And destroy them one at a time from the bottom up. */
343	while (pDrvIns)
344	{
345	PPDMDRVINS pDrvNext = pDrvIns->Internal.s.pUp;
346
347	if (pDrvIns->pDrvReg->pfnDestruct)
348	{
349	LogFlow(("pdmR3DevTerm: Destroying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
350	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
351	pDrvIns->pDrvReg->pfnDestruct(pDrvIns);
352	TMR3TimerDestroyDriver(pVM, pDrvIns);
353	}
354
355	pDrvIns = pDrvNext;
356	}
357	}
358
359	if (pDevIns->pDevReg->pfnDestruct)
360	{
361	LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
362	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
363	pDevIns->pDevReg->pfnDestruct(pDevIns);
364	TMR3TimerDestroyDevice(pVM, pDevIns);
365	pdmR3CritSectDeleteDevice(pVM, pDevIns);
366	}
367	}
368
369	/*
370	* Free modules.
371	*/
372	pdmR3LdrTerm(pVM);
373
374	#ifdef VBOX_WITH_PDM_LOCK
375	/*
376	* Destroy the PDM lock.
377	*/
378	PDMR3CritSectDelete(&pVM->pdm.s.CritSect);
379	#endif
380
381	LogFlow(("PDMR3Term: returns %Vrc\n", VINF_SUCCESS));
382	return VINF_SUCCESS;
383	}
384
385
386	/**
387	* Execute state save operation.
388	*
389	* @returns VBox status code.
390	* @param pVM VM Handle.
391	* @param pSSM SSM operation handle.
392	*/
393	static DECLCALLBACK(int) pdmR3Save(PVM pVM, PSSMHANDLE pSSM)
394	{
395	LogFlow(("pdmR3Save:\n"));
396
397	/*
398	* Save interrupt and DMA states.
399	*/
400	SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC));
401	SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC));
402	SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
403
404	/*
405	* Save the list of device instances so we can check that
406	* they're all still there when we load the state and that
407	* nothing new have been added.
408	*/
409	/** @todo We might have to filter out some device classes, like USB attached devices. */
410	uint32_t i = 0;
411	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC, i++)
412	{
413	SSMR3PutU32(pSSM, i);
414	SSMR3PutStrZ(pSSM, pDevIns->pDevReg->szDeviceName);
415	SSMR3PutU32(pSSM, pDevIns->iInstance);
416	}
417	return SSMR3PutU32(pSSM, ~0); /* terminator */
418	}
419
420
421	/**
422	* Prepare state load operation.
423	*
424	* This will dispatch pending operations and clear the FFs governed by PDM and its devices.
425	*
426	* @returns VBox status code.
427	* @param pVM The VM handle.
428	* @param pSSM The SSM handle.
429	*/
430	static DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM)
431	{
432	LogFlow(("pdmR3LoadPrep: %s%s%s%s\n",
433	VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES) ? " VM_FF_PDM_QUEUES" : "",
434	VM_FF_ISSET(pVM, VM_FF_PDM_DMA) ? " VM_FF_PDM_DMA" : "",
435	VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC) ? " VM_FF_INTERRUPT_APIC" : "",
436	VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC) ? " VM_FF_INTERRUPT_PIC" : ""
437	));
438
439	/*
440	* In case there is work pending that will raise an interrupt,
441	* start a DMA transfer, or release a lock. (unlikely)
442	*/
443	if (VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES))
444	PDMR3QueueFlushAll(pVM);
445
446	/* Clear the FFs. */
447	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
448	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
449	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
450
451	return VINF_SUCCESS;
452	}
453
454
455	/**
456	* Execute state load operation.
457	*
458	* @returns VBox status code.
459	* @param pVM VM Handle.
460	* @param pSSM SSM operation handle.
461	* @param u32Version Data layout version.
462	*/
463	static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version)
464	{
465	LogFlow(("pdmR3Load:\n"));
466
467	/*
468	* Validate version.
469	*/
470	if (u32Version != PDM_SAVED_STATE_VERSION)
471	{
472	Log(("pdmR3Load: Invalid version u32Version=%d!\n", u32Version));
473	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
474	}
475
476	/*
477	* Load the interrupt and DMA states.
478	*/
479	/* APIC interrupt */
480	RTUINT fInterruptPending = 0;
481	int rc = SSMR3GetUInt(pSSM, &fInterruptPending);
482	if (VBOX_FAILURE(rc))
483	return rc;
484	if (fInterruptPending & ~1)
485	{
486	AssertMsgFailed(("fInterruptPending=%#x (APIC)\n", fInterruptPending));
487	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
488	}
489	AssertRelease(!VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC));
490	if (fInterruptPending)
491	VM_FF_SET(pVM, VM_FF_INTERRUPT_APIC);
492
493	/* PIC interrupt */
494	fInterruptPending = 0;
495	rc = SSMR3GetUInt(pSSM, &fInterruptPending);
496	if (VBOX_FAILURE(rc))
497	return rc;
498	if (fInterruptPending & ~1)
499	{
500	AssertMsgFailed(("fInterruptPending=%#x (PIC)\n", fInterruptPending));
501	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
502	}
503	AssertRelease(!VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC));
504	if (fInterruptPending)
505	VM_FF_SET(pVM, VM_FF_INTERRUPT_PIC);
506
507	/* DMA pending */
508	RTUINT fDMAPending = 0;
509	rc = SSMR3GetUInt(pSSM, &fDMAPending);
510	if (VBOX_FAILURE(rc))
511	return rc;
512	if (fDMAPending & ~1)
513	{
514	AssertMsgFailed(("fDMAPending=%#x\n", fDMAPending));
515	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
516	}
517	AssertRelease(!VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
518	if (fDMAPending)
519	VM_FF_SET(pVM, VM_FF_PDM_DMA);
520
521	/*
522	* Load the list of devices and verify that they are all there.
523	*
524	* We boldly ASSUME that the order is fixed and that it's a good, this
525	* makes it way easier to validate...
526	*/
527	uint32_t i = 0;
528	PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances;
529	for (;;pDevIns = pDevIns->Internal.s.pNextHC, i++)
530	{
531	/* Get the separator / terminator. */
532	uint32_t u32Sep;
533	int rc = SSMR3GetU32(pSSM, &u32Sep);
534	if (VBOX_FAILURE(rc))
535	return rc;
536	if (u32Sep == (uint32_t)~0)
537	break;
538	if (u32Sep != i)
539	{
540	AssertMsgFailed(("Out of seqence. u32Sep=%#x i=%#x\n", u32Sep, i));
541	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
542	}
543
544	/* get the name and instance number. */
545	char szDeviceName[sizeof(pDevIns->pDevReg->szDeviceName)];
546	rc = SSMR3GetStrZ(pSSM, szDeviceName, sizeof(szDeviceName));
547	if (VBOX_FAILURE(rc))
548	return rc;
549	RTUINT iInstance;
550	rc = SSMR3GetUInt(pSSM, &iInstance);
551	if (VBOX_FAILURE(rc))
552	return rc;
553
554	/* compare */
555	if (!pDevIns)
556	{
557	LogRel(("Device '%s'/%d not found in current config\n", szDeviceName, iInstance));
558	AssertFailed();
559	return VERR_SSM_LOAD_CONFIG_MISMATCH;
560	}
561	if ( strcmp(szDeviceName, pDevIns->pDevReg->szDeviceName)
562	\|\| pDevIns->iInstance != iInstance
563	)
564	{
565	LogRel(("u32Sep=%d loaded '%s'/%d configured '%s'/%d\n",
566	u32Sep, szDeviceName, iInstance, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
567	AssertFailed();
568	return VERR_SSM_LOAD_CONFIG_MISMATCH;
569	}
570	}
571
572	/*
573	* Too many devices?
574	*/
575	if (pDevIns)
576	{
577	LogRel(("Device '%s'/%d not found in saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
578	AssertFailed();
579	return VERR_SSM_LOAD_CONFIG_MISMATCH;
580	}
581
582	return VINF_SUCCESS;
583	}
584
585
586	/**
587	* This function will notify all the devices and their
588	* attached drivers about the VM now being powered on.
589	*
590	* @param pVM VM Handle.
591	*/
592	PDMR3DECL(void) PDMR3PowerOn(PVM pVM)
593	{
594	LogFlow(("PDMR3PowerOn:\n"));
595
596	/*
597	* Iterate the device instances.
598	* The attached drivers are processed first.
599	*/
600	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
601	{
602	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
603	/** @todo Inverse the order here? */
604	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
605	if (pDrvIns->pDrvReg->pfnPowerOn)
606	{
607	LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
608	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
609	pDrvIns->pDrvReg->pfnPowerOn(pDrvIns);
610	}
611
612	if (pDevIns->pDevReg->pfnPowerOn)
613	{
614	LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
615	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
616	pDevIns->pDevReg->pfnPowerOn(pDevIns);
617	}
618	}
619
620	LogFlow(("PDMR3PowerOn: returns void\n"));
621	}
622
623
624
625
626	/**
627	* This function will notify all the devices and their
628	* attached drivers about the VM now being reset.
629	*
630	* @param pVM VM Handle.
631	*/
632	PDMR3DECL(void) PDMR3Reset(PVM pVM)
633	{
634	LogFlow(("PDMR3Reset:\n"));
635
636	/*
637	* Clear all pending interrupts and DMA operations.
638	*/
639	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
640	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
641	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
642
643	/*
644	* Iterate the device instances.
645	* The attached drivers are processed first.
646	*/
647	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
648	{
649	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
650	/** @todo Inverse the order here? */
651	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
652	if (pDrvIns->pDrvReg->pfnReset)
653	{
654	LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
655	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
656	pDrvIns->pDrvReg->pfnReset(pDrvIns);
657	}
658
659	if (pDevIns->pDevReg->pfnReset)
660	{
661	LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
662	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
663	pDevIns->pDevReg->pfnReset(pDevIns);
664	}
665	}
666
667	LogFlow(("PDMR3Reset: returns void\n"));
668	}
669
670
671	/**
672	* This function will notify all the devices and their
673	* attached drivers about the VM now being reset.
674	*
675	* @param pVM VM Handle.
676	*/
677	PDMR3DECL(void) PDMR3Suspend(PVM pVM)
678	{
679	LogFlow(("PDMR3Suspend:\n"));
680
681	/*
682	* Iterate the device instances.
683	* The attached drivers are processed first.
684	*/
685	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
686	{
687	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
688	/** @todo Inverse the order here? */
689	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
690	if (pDrvIns->pDrvReg->pfnSuspend)
691	{
692	LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
693	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
694	pDrvIns->pDrvReg->pfnSuspend(pDrvIns);
695	}
696
697	if (pDevIns->pDevReg->pfnSuspend)
698	{
699	LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
700	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
701	pDevIns->pDevReg->pfnSuspend(pDevIns);
702	}
703	}
704
705	LogFlow(("PDMR3Suspend: returns void\n"));
706	}
707
708
709	/**
710	* This function will notify all the devices and their
711	* attached drivers about the VM now being resumed.
712	*
713	* @param pVM VM Handle.
714	*/
715	PDMR3DECL(void) PDMR3Resume(PVM pVM)
716	{
717	LogFlow(("PDMR3Resume:\n"));
718
719	/*
720	* Iterate the device instances.
721	* The attached drivers are processed first.
722	*/
723	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
724	{
725	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
726	/** @todo Inverse the order here? */
727	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
728	if (pDrvIns->pDrvReg->pfnResume)
729	{
730	LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
731	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
732	pDrvIns->pDrvReg->pfnResume(pDrvIns);
733	}
734
735	if (pDevIns->pDevReg->pfnResume)
736	{
737	LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
738	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
739	pDevIns->pDevReg->pfnResume(pDevIns);
740	}
741	}
742
743	LogFlow(("PDMR3Resume: returns void\n"));
744	}
745
746
747	/**
748	* This function will notify all the devices and their
749	* attached drivers about the VM being powered off.
750	*
751	* @param pVM VM Handle.
752	*/
753	PDMR3DECL(void) PDMR3PowerOff(PVM pVM)
754	{
755	LogFlow(("PDMR3PowerOff:\n"));
756
757	/*
758	* Iterate the device instances.
759	* The attached drivers are processed first.
760	*/
761	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
762	{
763	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
764	/** @todo Inverse the order here? */
765	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
766	if (pDrvIns->pDrvReg->pfnPowerOff)
767	{
768	LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
769	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
770	pDrvIns->pDrvReg->pfnPowerOff(pDrvIns);
771	}
772
773	if (pDevIns->pDevReg->pfnPowerOff)
774	{
775	LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
776	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
777	pDevIns->pDevReg->pfnPowerOff(pDevIns);
778	}
779	}
780
781	LogFlow(("PDMR3PowerOff: returns void\n"));
782	}
783
784
785	/**
786	* Queries the base interace of a device instance.
787	*
788	* The caller can use this to query other interfaces the device implements
789	* and use them to talk to the device.
790	*
791	* @returns VBox status code.
792	* @param pVM VM handle.
793	* @param pszDevice Device name.
794	* @param iInstance Device instance.
795	* @param ppBase Where to store the pointer to the base device interface on success.
796	* @remark We're doing any locking ATM, so don't try call this at times when the
797	* device chain is known to be updated.
798	*/
799	PDMR3DECL(int) PDMR3QueryDevice(PVM pVM, const char pszDevice, unsigned iInstance, PPDMIBASE ppBase)
800	{
801	LogFlow(("PDMR3DeviceQuery: pszDevice=%p:{%s} iInstance=%u ppBase=%p\n", pszDevice, pszDevice, iInstance, ppBase));
802
803	/*
804	* Iterate registered devices looking for the device.
805	*/
806	RTUINT cchDevice = strlen(pszDevice);
807	for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
808	{
809	if ( pDev->cchName == cchDevice
810	&& !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
811	{
812	/*
813	* Iterate device instances.
814	*/
815	for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextHC)
816	{
817	if (pDevIns->iInstance == iInstance)
818	{
819	if (pDevIns->IBase.pfnQueryInterface)
820	{
821	*ppBase = &pDevIns->IBase;
822	LogFlow(("PDMR3DeviceQuery: return VINF_SUCCESS and ppBase=%p\n", ppBase));
823	return VINF_SUCCESS;
824	}
825
826	LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NO_IBASE\n"));
827	return VERR_PDM_DEVICE_INSTANCE_NO_IBASE;
828	}
829	}
830
831	LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NOT_FOUND\n"));
832	return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
833	}
834	}
835
836	LogFlow(("PDMR3QueryDevice: returns VERR_PDM_DEVICE_NOT_FOUND\n"));
837	return VERR_PDM_DEVICE_NOT_FOUND;
838	}
839
840
841	/**
842	* Queries the base interface of a device LUN.
843	*
844	* This differs from PDMR3QueryLun by that it returns the interface on the
845	* device and not the top level driver.
846	*
847	* @returns VBox status code.
848	* @param pVM VM Handle.
849	* @param pszDevice Device name.
850	* @param iInstance Device instance.
851	* @param iLun The Logical Unit to obtain the interface of.
852	* @param ppBase Where to store the base interface pointer.
853	* @remark We're doing any locking ATM, so don't try call this at times when the
854	* device chain is known to be updated.
855	*/
856	PDMR3DECL(int) PDMR3QueryDeviceLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
857	{
858	LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
859	pszDevice, pszDevice, iInstance, iLun, ppBase));
860
861	/*
862	* Find the LUN.
863	*/
864	PPDMLUN pLun;
865	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
866	if (VBOX_SUCCESS(rc))
867	{
868	*ppBase = pLun->pBase;
869	LogFlow(("PDMR3QueryDeviceLun: return VINF_SUCCESS and ppBase=%p\n", ppBase));
870	return VINF_SUCCESS;
871	}
872	LogFlow(("PDMR3QueryDeviceLun: returns %Vrc\n", rc));
873	return rc;
874	}
875
876
877	/**
878	* Query the interface of the top level driver on a LUN.
879	*
880	* @returns VBox status code.
881	* @param pVM VM Handle.
882	* @param pszDevice Device name.
883	* @param iInstance Device instance.
884	* @param iLun The Logical Unit to obtain the interface of.
885	* @param ppBase Where to store the base interface pointer.
886	* @remark We're doing any locking ATM, so don't try call this at times when the
887	* device chain is known to be updated.
888	*/
889	PDMR3DECL(int) PDMR3QueryLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
890	{
891	LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
892	pszDevice, pszDevice, iInstance, iLun, ppBase));
893
894	/*
895	* Find the LUN.
896	*/
897	PPDMLUN pLun;
898	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
899	if (VBOX_SUCCESS(rc))
900	{
901	if (pLun->pTop)
902	{
903	*ppBase = &pLun->pTop->IBase;
904	LogFlow(("PDMR3QueryLun: return %Vrc and ppBase=%p\n", VINF_SUCCESS, ppBase));
905	return VINF_SUCCESS;
906	}
907	rc = VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN;
908	}
909	LogFlow(("PDMR3QueryLun: returns %Vrc\n", rc));
910	return rc;
911	}
912
913	/**
914	* Executes pending DMA transfers.
915	* Forced Action handler.
916	*
917	* @param pVM VM handle.
918	*/
919	PDMR3DECL(void) PDMR3DmaRun(PVM pVM)
920	{
921	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
922	if (pVM->pdm.s.pDmac)
923	{
924	bool fMore = pVM->pdm.s.pDmac->Reg.pfnRun(pVM->pdm.s.pDmac->pDevIns);
925	if (fMore)
926	VM_FF_SET(pVM, VM_FF_PDM_DMA);
927	}
928	}
929
930
931	/**
932	* Call polling function.
933	*
934	* @param pVM VM handle.
935	*/
936	PDMR3DECL(void) PDMR3Poll(PVM pVM)
937	{
938	/* This is temporary hack and shall be removed ASAP! */
939	unsigned iPoller = pVM->pdm.s.cPollers;
940	if (iPoller)
941	{
942	while (iPoller-- > 0)
943	pVM->pdm.s.apfnPollers[iPoller](pVM->pdm.s.aDrvInsPollers[iPoller]);
944	TMTimerSetMillies(pVM->pdm.s.pTimerPollers, 3);
945	}
946	}
947
948
949	/**
950	* Internal timer callback function.
951	*
952	* @param pVM The VM.
953	* @param pTimer The timer handle.
954	* @param pvUser User argument specified upon timer creation.
955	*/
956	static DECLCALLBACK(void) pdmR3PollerTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
957	{
958	PDMR3Poll(pVM);
959	}
960
961
962	/**
963	* Serivce a VMMCALLHOST_PDM_LOCK call.
964	*
965	* @returns VBox status code.
966	* @param pVM The VM handle.
967	*/
968	PDMR3DECL(int) PDMR3LockCall(PVM pVM)
969	{
970	return pdmLockEx(pVM, VERR_INTERNAL_ERROR);
971	}
972

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

source: vbox/trunk/src/VBox/VMM/PDM.cpp@ 2233

Download in other formats: