PDM.cpp@ 773

Last change on this file since 773 was 525, checked in by vboxsync, 18 years ago
VM_GUEST_ADDR isn't the right macro for converting the pPciBusHC into a GC pointer.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.5 KB

Line
1	/* $Id: PDM.cpp 525 2007-02-02 00:42:38Z 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 it's 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	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
336	if (pDrvIns->pDrvReg->pfnDestruct)
337	{
338	LogFlow(("pdmR3DevTerm: Destroying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
339	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
340	pDrvIns->pDrvReg->pfnDestruct(pDrvIns);
341	TMR3TimerDestroyDriver(pVM, pDrvIns);
342	}
343
344	if (pDevIns->pDevReg->pfnDestruct)
345	{
346	LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
347	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
348	pDevIns->pDevReg->pfnDestruct(pDevIns);
349	TMR3TimerDestroyDevice(pVM, pDevIns);
350	pdmR3CritSectDeleteDevice(pVM, pDevIns);
351	}
352	}
353
354	/*
355	* Free modules.
356	*/
357	pdmR3LdrTerm(pVM);
358
359	#ifdef VBOX_WITH_PDM_LOCK
360	/*
361	* Destroy the PDM lock.
362	*/
363	PDMR3CritSectDelete(&pVM->pdm.s.CritSect);
364	#endif
365
366	LogFlow(("PDMR3Term: returns %Vrc\n", VINF_SUCCESS));
367	return VINF_SUCCESS;
368	}
369
370
371	/**
372	* Execute state save operation.
373	*
374	* @returns VBox status code.
375	* @param pVM VM Handle.
376	* @param pSSM SSM operation handle.
377	*/
378	static DECLCALLBACK(int) pdmR3Save(PVM pVM, PSSMHANDLE pSSM)
379	{
380	LogFlow(("pdmR3Save:\n"));
381
382	/*
383	* Save interrupt and DMA states.
384	*/
385	SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC));
386	SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC));
387	SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
388
389	/*
390	* Save the list of device instances so we can check that
391	* they're all still there when we load the state and that
392	* nothing new have been added.
393	*/
394	/** @todo We might have to filter out some device classes, like USB attached devices. */
395	uint32_t i = 0;
396	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC, i++)
397	{
398	SSMR3PutU32(pSSM, i);
399	SSMR3PutStrZ(pSSM, pDevIns->pDevReg->szDeviceName);
400	SSMR3PutU32(pSSM, pDevIns->iInstance);
401	}
402	return SSMR3PutU32(pSSM, ~0); /* terminator */
403	}
404
405
406	/**
407	* Prepare state load operation.
408	*
409	* This will dispatch pending operations and clear the FFs governed by PDM and its devices.
410	*
411	* @returns VBox status code.
412	* @param pVM The VM handle.
413	* @param pSSM The SSM handle.
414	*/
415	static DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM)
416	{
417	LogFlow(("pdmR3LoadPrep: %s%s%s%s\n",
418	VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES) ? " VM_FF_PDM_QUEUES" : "",
419	VM_FF_ISSET(pVM, VM_FF_PDM_DMA) ? " VM_FF_PDM_DMA" : "",
420	VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC) ? " VM_FF_INTERRUPT_APIC" : "",
421	VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC) ? " VM_FF_INTERRUPT_PIC" : ""
422	));
423
424	/*
425	* In case there is work pending that will raise an interrupt,
426	* start a DMA transfer, or release a lock. (unlikely)
427	*/
428	if (VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES))
429	PDMR3QueueFlushAll(pVM);
430
431	/* Clear the FFs. */
432	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
433	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
434	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
435
436	return VINF_SUCCESS;
437	}
438
439
440	/**
441	* Execute state load operation.
442	*
443	* @returns VBox status code.
444	* @param pVM VM Handle.
445	* @param pSSM SSM operation handle.
446	* @param u32Version Data layout version.
447	*/
448	static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version)
449	{
450	LogFlow(("pdmR3Load:\n"));
451
452	/*
453	* Validate version.
454	*/
455	if (u32Version != PDM_SAVED_STATE_VERSION)
456	{
457	Log(("pdmR3Load: Invalid version u32Version=%d!\n", u32Version));
458	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
459	}
460
461	/*
462	* Load the interrupt and DMA states.
463	*/
464	/* APIC interrupt */
465	RTUINT fInterruptPending = 0;
466	int rc = SSMR3GetUInt(pSSM, &fInterruptPending);
467	if (VBOX_FAILURE(rc))
468	return rc;
469	if (fInterruptPending & ~1)
470	{
471	AssertMsgFailed(("fInterruptPending=%#x (APIC)\n", fInterruptPending));
472	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
473	}
474	AssertRelease(!VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC));
475	if (fInterruptPending)
476	VM_FF_SET(pVM, VM_FF_INTERRUPT_APIC);
477
478	/* PIC interrupt */
479	fInterruptPending = 0;
480	rc = SSMR3GetUInt(pSSM, &fInterruptPending);
481	if (VBOX_FAILURE(rc))
482	return rc;
483	if (fInterruptPending & ~1)
484	{
485	AssertMsgFailed(("fInterruptPending=%#x (PIC)\n", fInterruptPending));
486	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
487	}
488	AssertRelease(!VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC));
489	if (fInterruptPending)
490	VM_FF_SET(pVM, VM_FF_INTERRUPT_PIC);
491
492	/* DMA pending */
493	RTUINT fDMAPending = 0;
494	rc = SSMR3GetUInt(pSSM, &fDMAPending);
495	if (VBOX_FAILURE(rc))
496	return rc;
497	if (fDMAPending & ~1)
498	{
499	AssertMsgFailed(("fDMAPending=%#x\n", fDMAPending));
500	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
501	}
502	AssertRelease(!VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
503	if (fDMAPending)
504	VM_FF_SET(pVM, VM_FF_PDM_DMA);
505
506	/*
507	* Load the list of devices and verify that they are all there.
508	*
509	* We boldly ASSUME that the order is fixed and that it's a good, this
510	* makes it way easier to validate...
511	*/
512	uint32_t i = 0;
513	PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances;
514	for (;;pDevIns = pDevIns->Internal.s.pNextHC, i++)
515	{
516	/* Get the separator / terminator. */
517	uint32_t u32Sep;
518	int rc = SSMR3GetU32(pSSM, &u32Sep);
519	if (VBOX_FAILURE(rc))
520	return rc;
521	if (u32Sep == (uint32_t)~0)
522	break;
523	if (u32Sep != i)
524	{
525	AssertMsgFailed(("Out of seqence. u32Sep=%#x i=%#x\n", u32Sep, i));
526	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
527	}
528
529	/* get the name and instance number. */
530	char szDeviceName[sizeof(pDevIns->pDevReg->szDeviceName)];
531	rc = SSMR3GetStrZ(pSSM, szDeviceName, sizeof(szDeviceName));
532	if (VBOX_FAILURE(rc))
533	return rc;
534	RTUINT iInstance;
535	rc = SSMR3GetUInt(pSSM, &iInstance);
536	if (VBOX_FAILURE(rc))
537	return rc;
538
539	/* compare */
540	if (!pDevIns)
541	{
542	LogRel(("Device '%s'/%d not found in current config\n", szDeviceName, iInstance));
543	AssertFailed();
544	return VERR_SSM_LOAD_CONFIG_MISMATCH;
545	}
546	if ( strcmp(szDeviceName, pDevIns->pDevReg->szDeviceName)
547	\|\| pDevIns->iInstance != iInstance
548	)
549	{
550	LogRel(("u32Sep=%d loaded '%s'/%d configured '%s'/%d\n",
551	u32Sep, szDeviceName, iInstance, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
552	AssertFailed();
553	return VERR_SSM_LOAD_CONFIG_MISMATCH;
554	}
555	}
556
557	/*
558	* Too many devices?
559	*/
560	if (pDevIns)
561	{
562	LogRel(("Device '%s'/%d not found in saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
563	AssertFailed();
564	return VERR_SSM_LOAD_CONFIG_MISMATCH;
565	}
566
567	return VINF_SUCCESS;
568	}
569
570
571	/**
572	* This function will notify all the devices and their
573	* attached drivers about the VM now being powered on.
574	*
575	* @param pVM VM Handle.
576	*/
577	PDMR3DECL(void) PDMR3PowerOn(PVM pVM)
578	{
579	LogFlow(("PDMR3PowerOn:\n"));
580
581	/*
582	* Iterate the device instances.
583	* The attached drivers are processed first.
584	*/
585	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
586	{
587	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
588	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
589	if (pDrvIns->pDrvReg->pfnPowerOn)
590	{
591	LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
592	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
593	pDrvIns->pDrvReg->pfnPowerOn(pDrvIns);
594	}
595
596	if (pDevIns->pDevReg->pfnPowerOn)
597	{
598	LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
599	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
600	pDevIns->pDevReg->pfnPowerOn(pDevIns);
601	}
602	}
603
604	LogFlow(("PDMR3PowerOn: returns void\n"));
605	}
606
607
608
609
610	/**
611	* This function will notify all the devices and their
612	* attached drivers about the VM now being reset.
613	*
614	* @param pVM VM Handle.
615	*/
616	PDMR3DECL(void) PDMR3Reset(PVM pVM)
617	{
618	LogFlow(("PDMR3Reset:\n"));
619
620	/*
621	* Clear all pending interrupts and DMA operations.
622	*/
623	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
624	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
625	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
626
627	/*
628	* Iterate the device instances.
629	* The attached drivers are processed first.
630	*/
631	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
632	{
633	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
634	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
635	if (pDrvIns->pDrvReg->pfnReset)
636	{
637	LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
638	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
639	pDrvIns->pDrvReg->pfnReset(pDrvIns);
640	}
641
642	if (pDevIns->pDevReg->pfnReset)
643	{
644	LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
645	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
646	pDevIns->pDevReg->pfnReset(pDevIns);
647	}
648	}
649
650	LogFlow(("PDMR3Reset: returns void\n"));
651	}
652
653
654	/**
655	* This function will notify all the devices and their
656	* attached drivers about the VM now being reset.
657	*
658	* @param pVM VM Handle.
659	*/
660	PDMR3DECL(void) PDMR3Suspend(PVM pVM)
661	{
662	LogFlow(("PDMR3Suspend:\n"));
663
664	/*
665	* Iterate the device instances.
666	* The attached drivers are processed first.
667	*/
668	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
669	{
670	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
671	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
672	if (pDrvIns->pDrvReg->pfnSuspend)
673	{
674	LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
675	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
676	pDrvIns->pDrvReg->pfnSuspend(pDrvIns);
677	}
678
679	if (pDevIns->pDevReg->pfnSuspend)
680	{
681	LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
682	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
683	pDevIns->pDevReg->pfnSuspend(pDevIns);
684	}
685	}
686
687	LogFlow(("PDMR3Suspend: returns void\n"));
688	}
689
690
691	/**
692	* This function will notify all the devices and their
693	* attached drivers about the VM now being resumed.
694	*
695	* @param pVM VM Handle.
696	*/
697	PDMR3DECL(void) PDMR3Resume(PVM pVM)
698	{
699	LogFlow(("PDMR3Resume:\n"));
700
701	/*
702	* Iterate the device instances.
703	* The attached drivers are processed first.
704	*/
705	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
706	{
707	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
708	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
709	if (pDrvIns->pDrvReg->pfnResume)
710	{
711	LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
712	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
713	pDrvIns->pDrvReg->pfnResume(pDrvIns);
714	}
715
716	if (pDevIns->pDevReg->pfnResume)
717	{
718	LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
719	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
720	pDevIns->pDevReg->pfnResume(pDevIns);
721	}
722	}
723
724	LogFlow(("PDMR3Resume: returns void\n"));
725	}
726
727
728	/**
729	* This function will notify all the devices and their
730	* attached drivers about the VM being powered off.
731	*
732	* @param pVM VM Handle.
733	*/
734	PDMR3DECL(void) PDMR3PowerOff(PVM pVM)
735	{
736	LogFlow(("PDMR3PowerOff:\n"));
737
738	/*
739	* Iterate the device instances.
740	* The attached drivers are processed first.
741	*/
742	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
743	{
744	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
745	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
746	if (pDrvIns->pDrvReg->pfnPowerOff)
747	{
748	LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
749	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
750	pDrvIns->pDrvReg->pfnPowerOff(pDrvIns);
751	}
752
753	if (pDevIns->pDevReg->pfnPowerOff)
754	{
755	LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
756	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
757	pDevIns->pDevReg->pfnPowerOff(pDevIns);
758	}
759	}
760
761	LogFlow(("PDMR3PowerOff: returns void\n"));
762	}
763
764
765	/**
766	* Queries the base interace of a device instance.
767	*
768	* The caller can use this to query other interfaces the device implements
769	* and use them to talk to the device.
770	*
771	* @returns VBox status code.
772	* @param pVM VM handle.
773	* @param pszDevice Device name.
774	* @param iInstance Device instance.
775	* @param ppBase Where to store the pointer to the base device interface on success.
776	* @remark We're doing any locking ATM, so don't try call this at times when the
777	* device chain is known to be updated.
778	*/
779	PDMR3DECL(int) PDMR3QueryDevice(PVM pVM, const char pszDevice, unsigned iInstance, PPDMIBASE ppBase)
780	{
781	LogFlow(("PDMR3DeviceQuery: pszDevice=%p:{%s} iInstance=%u ppBase=%p\n", pszDevice, pszDevice, iInstance, ppBase));
782
783	/*
784	* Iterate registered devices looking for the device.
785	*/
786	RTUINT cchDevice = strlen(pszDevice);
787	for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
788	{
789	if ( pDev->cchName == cchDevice
790	&& !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
791	{
792	/*
793	* Iterate device instances.
794	*/
795	for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextHC)
796	{
797	if (pDevIns->iInstance == iInstance)
798	{
799	if (pDevIns->IBase.pfnQueryInterface)
800	{
801	*ppBase = &pDevIns->IBase;
802	LogFlow(("PDMR3DeviceQuery: return VINF_SUCCESS and ppBase=%p\n", ppBase));
803	return VINF_SUCCESS;
804	}
805
806	LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NO_IBASE\n"));
807	return VERR_PDM_DEVICE_INSTANCE_NO_IBASE;
808	}
809	}
810
811	LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NOT_FOUND\n"));
812	return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
813	}
814	}
815
816	LogFlow(("PDMR3QueryDevice: returns VERR_PDM_DEVICE_NOT_FOUND\n"));
817	return VERR_PDM_DEVICE_NOT_FOUND;
818	}
819
820
821	/**
822	* Queries the base interface of a device LUN.
823	*
824	* This differs from PDMR3QueryLun by that it returns the interface on the
825	* device and not the top level driver.
826	*
827	* @returns VBox status code.
828	* @param pVM VM Handle.
829	* @param pszDevice Device name.
830	* @param iInstance Device instance.
831	* @param iLun The Logical Unit to obtain the interface of.
832	* @param ppBase Where to store the base interface pointer.
833	* @remark We're doing any locking ATM, so don't try call this at times when the
834	* device chain is known to be updated.
835	*/
836	PDMR3DECL(int) PDMR3QueryDeviceLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
837	{
838	LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
839	pszDevice, pszDevice, iInstance, iLun, ppBase));
840
841	/*
842	* Find the LUN.
843	*/
844	PPDMLUN pLun;
845	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
846	if (VBOX_SUCCESS(rc))
847	{
848	*ppBase = pLun->pBase;
849	LogFlow(("PDMR3QueryDeviceLun: return VINF_SUCCESS and ppBase=%p\n", ppBase));
850	return VINF_SUCCESS;
851	}
852	LogFlow(("PDMR3QueryDeviceLun: returns %Vrc\n", rc));
853	return rc;
854	}
855
856
857	/**
858	* Query the interface of the top level driver on a LUN.
859	*
860	* @returns VBox status code.
861	* @param pVM VM Handle.
862	* @param pszDevice Device name.
863	* @param iInstance Device instance.
864	* @param iLun The Logical Unit to obtain the interface of.
865	* @param ppBase Where to store the base interface pointer.
866	* @remark We're doing any locking ATM, so don't try call this at times when the
867	* device chain is known to be updated.
868	*/
869	PDMR3DECL(int) PDMR3QueryLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
870	{
871	LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
872	pszDevice, pszDevice, iInstance, iLun, ppBase));
873
874	/*
875	* Find the LUN.
876	*/
877	PPDMLUN pLun;
878	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
879	if (VBOX_SUCCESS(rc))
880	{
881	if (pLun->pTop)
882	{
883	*ppBase = &pLun->pTop->IBase;
884	LogFlow(("PDMR3QueryLun: return %Vrc and ppBase=%p\n", VINF_SUCCESS, ppBase));
885	return VINF_SUCCESS;
886	}
887	rc = VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN;
888	}
889	LogFlow(("PDMR3QueryLun: returns %Vrc\n", rc));
890	return rc;
891	}
892
893	/**
894	* Executes pending DMA transfers.
895	* Forced Action handler.
896	*
897	* @param pVM VM handle.
898	*/
899	PDMR3DECL(void) PDMR3DmaRun(PVM pVM)
900	{
901	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
902	if (pVM->pdm.s.pDmac)
903	{
904	bool fMore = pVM->pdm.s.pDmac->Reg.pfnRun(pVM->pdm.s.pDmac->pDevIns);
905	if (fMore)
906	VM_FF_SET(pVM, VM_FF_PDM_DMA);
907	}
908	}
909
910
911	/**
912	* Call polling function.
913	*
914	* @param pVM VM handle.
915	*/
916	PDMR3DECL(void) PDMR3Poll(PVM pVM)
917	{
918	/* This is temporary hack and shall be removed ASAP! */
919	unsigned iPoller = pVM->pdm.s.cPollers;
920	if (iPoller)
921	{
922	while (iPoller-- > 0)
923	pVM->pdm.s.apfnPollers[iPoller](pVM->pdm.s.aDrvInsPollers[iPoller]);
924	TMTimerSetMillies(pVM->pdm.s.pTimerPollers, 3);
925	}
926	}
927
928
929	/**
930	* Internal timer callback function.
931	*
932	* @param pVM The VM.
933	* @param pTimer The timer handle.
934	* @param pvUser User argument specified upon timer creation.
935	*/
936	static DECLCALLBACK(void) pdmR3PollerTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
937	{
938	PDMR3Poll(pVM);
939	}
940
941
942	/**
943	* Serivce a VMMCALLHOST_PDM_LOCK call.
944	*
945	* @returns VBox status code.
946	* @param pVM The VM handle.
947	*/
948	PDMR3DECL(int) PDMR3LockCall(PVM pVM)
949	{
950	return pdmLockEx(pVM, VERR_INTERNAL_ERROR);
951	}
952

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

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

Download in other formats: