PDM.cpp@ 28

Last change on this file since 28 was 23, checked in by vboxsync, 18 years ago
string.h & stdio.h + header cleanups.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.4 KB

Line
1	/* $Id: PDM.cpp 23 2007-01-15 14:08:28Z 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.pPciBusGC)
298	pDevIns->Internal.s.pPciBusGC = VM_GUEST_ADDR(pVM, pDevIns->Internal.s.pPciBusHC);
299	if (pDevIns->Internal.s.pPciDeviceGC)
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	AssertMsgFailed(("Device '%s'/%d not found in current config\n", szDeviceName, iInstance));
543	return VERR_SSM_LOAD_CONFIG_MISMATCH;
544	}
545	if ( strcmp(szDeviceName, pDevIns->pDevReg->szDeviceName)
546	\|\| pDevIns->iInstance != iInstance
547	)
548	{
549	AssertMsgFailed(("u32Sep=%d loaded '%s'/%d configured '%s'/%d\n",
550	u32Sep, szDeviceName, iInstance, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
551	return VERR_SSM_LOAD_CONFIG_MISMATCH;
552	}
553	}
554
555	/*
556	* Too many devices?
557	*/
558	if (pDevIns)
559	{
560	AssertMsgFailed(("Device '%s'/%d not found in saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
561	return VERR_SSM_LOAD_CONFIG_MISMATCH;
562	}
563
564	return VINF_SUCCESS;
565	}
566
567
568	/**
569	* This function will notify all the devices and their
570	* attached drivers about the VM now being powered on.
571	*
572	* @param pVM VM Handle.
573	*/
574	PDMR3DECL(void) PDMR3PowerOn(PVM pVM)
575	{
576	LogFlow(("PDMR3PowerOn:\n"));
577
578	/*
579	* Iterate the device instances.
580	* The attached drivers are processed first.
581	*/
582	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
583	{
584	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
585	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
586	if (pDrvIns->pDrvReg->pfnPowerOn)
587	{
588	LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
589	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
590	pDrvIns->pDrvReg->pfnPowerOn(pDrvIns);
591	}
592
593	if (pDevIns->pDevReg->pfnPowerOn)
594	{
595	LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
596	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
597	pDevIns->pDevReg->pfnPowerOn(pDevIns);
598	}
599	}
600
601	LogFlow(("PDMR3PowerOn: returns void\n"));
602	}
603
604
605
606
607	/**
608	* This function will notify all the devices and their
609	* attached drivers about the VM now being reset.
610	*
611	* @param pVM VM Handle.
612	*/
613	PDMR3DECL(void) PDMR3Reset(PVM pVM)
614	{
615	LogFlow(("PDMR3Reset:\n"));
616
617	/*
618	* Clear all pending interrupts and DMA operations.
619	*/
620	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
621	VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
622	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
623
624	/*
625	* Iterate the device instances.
626	* The attached drivers are processed first.
627	*/
628	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
629	{
630	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
631	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
632	if (pDrvIns->pDrvReg->pfnReset)
633	{
634	LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
635	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
636	pDrvIns->pDrvReg->pfnReset(pDrvIns);
637	}
638
639	if (pDevIns->pDevReg->pfnReset)
640	{
641	LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
642	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
643	pDevIns->pDevReg->pfnReset(pDevIns);
644	}
645	}
646
647	LogFlow(("PDMR3Reset: returns void\n"));
648	}
649
650
651	/**
652	* This function will notify all the devices and their
653	* attached drivers about the VM now being reset.
654	*
655	* @param pVM VM Handle.
656	*/
657	PDMR3DECL(void) PDMR3Suspend(PVM pVM)
658	{
659	LogFlow(("PDMR3Suspend:\n"));
660
661	/*
662	* Iterate the device instances.
663	* The attached drivers are processed first.
664	*/
665	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
666	{
667	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
668	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
669	if (pDrvIns->pDrvReg->pfnSuspend)
670	{
671	LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
672	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
673	pDrvIns->pDrvReg->pfnSuspend(pDrvIns);
674	}
675
676	if (pDevIns->pDevReg->pfnSuspend)
677	{
678	LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
679	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
680	pDevIns->pDevReg->pfnSuspend(pDevIns);
681	}
682	}
683
684	LogFlow(("PDMR3Suspend: returns void\n"));
685	}
686
687
688	/**
689	* This function will notify all the devices and their
690	* attached drivers about the VM now being resumed.
691	*
692	* @param pVM VM Handle.
693	*/
694	PDMR3DECL(void) PDMR3Resume(PVM pVM)
695	{
696	LogFlow(("PDMR3Resume:\n"));
697
698	/*
699	* Iterate the device instances.
700	* The attached drivers are processed first.
701	*/
702	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
703	{
704	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
705	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
706	if (pDrvIns->pDrvReg->pfnResume)
707	{
708	LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
709	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
710	pDrvIns->pDrvReg->pfnResume(pDrvIns);
711	}
712
713	if (pDevIns->pDevReg->pfnResume)
714	{
715	LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
716	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
717	pDevIns->pDevReg->pfnResume(pDevIns);
718	}
719	}
720
721	LogFlow(("PDMR3Resume: returns void\n"));
722	}
723
724
725	/**
726	* This function will notify all the devices and their
727	* attached drivers about the VM being powered off.
728	*
729	* @param pVM VM Handle.
730	*/
731	PDMR3DECL(void) PDMR3PowerOff(PVM pVM)
732	{
733	LogFlow(("PDMR3PowerOff:\n"));
734
735	/*
736	* Iterate the device instances.
737	* The attached drivers are processed first.
738	*/
739	for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
740	{
741	for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
742	for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
743	if (pDrvIns->pDrvReg->pfnPowerOff)
744	{
745	LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
746	pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
747	pDrvIns->pDrvReg->pfnPowerOff(pDrvIns);
748	}
749
750	if (pDevIns->pDevReg->pfnPowerOff)
751	{
752	LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
753	pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
754	pDevIns->pDevReg->pfnPowerOff(pDevIns);
755	}
756	}
757
758	LogFlow(("PDMR3PowerOff: returns void\n"));
759	}
760
761
762	/**
763	* Queries the base interace of a device instance.
764	*
765	* The caller can use this to query other interfaces the device implements
766	* and use them to talk to the device.
767	*
768	* @returns VBox status code.
769	* @param pVM VM handle.
770	* @param pszDevice Device name.
771	* @param iInstance Device instance.
772	* @param ppBase Where to store the pointer to the base device interface on success.
773	* @remark We're doing any locking ATM, so don't try call this at times when the
774	* device chain is known to be updated.
775	*/
776	PDMR3DECL(int) PDMR3QueryDevice(PVM pVM, const char pszDevice, unsigned iInstance, PPDMIBASE ppBase)
777	{
778	LogFlow(("PDMR3DeviceQuery: pszDevice=%p:{%s} iInstance=%u ppBase=%p\n", pszDevice, pszDevice, iInstance, ppBase));
779
780	/*
781	* Iterate registered devices looking for the device.
782	*/
783	RTUINT cchDevice = strlen(pszDevice);
784	for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
785	{
786	if ( pDev->cchName == cchDevice
787	&& !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
788	{
789	/*
790	* Iterate device instances.
791	*/
792	for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextHC)
793	{
794	if (pDevIns->iInstance == iInstance)
795	{
796	if (pDevIns->IBase.pfnQueryInterface)
797	{
798	*ppBase = &pDevIns->IBase;
799	LogFlow(("PDMR3DeviceQuery: return VINF_SUCCESS and ppBase=%p\n", ppBase));
800	return VINF_SUCCESS;
801	}
802
803	LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NO_IBASE\n"));
804	return VERR_PDM_DEVICE_INSTANCE_NO_IBASE;
805	}
806	}
807
808	LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NOT_FOUND\n"));
809	return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
810	}
811	}
812
813	LogFlow(("PDMR3QueryDevice: returns VERR_PDM_DEVICE_NOT_FOUND\n"));
814	return VERR_PDM_DEVICE_NOT_FOUND;
815	}
816
817
818	/**
819	* Queries the base interface of a device LUN.
820	*
821	* This differs from PDMR3QueryLun by that it returns the interface on the
822	* device and not the top level driver.
823	*
824	* @returns VBox status code.
825	* @param pVM VM Handle.
826	* @param pszDevice Device name.
827	* @param iInstance Device instance.
828	* @param iLun The Logical Unit to obtain the interface of.
829	* @param ppBase Where to store the base interface pointer.
830	* @remark We're doing any locking ATM, so don't try call this at times when the
831	* device chain is known to be updated.
832	*/
833	PDMR3DECL(int) PDMR3QueryDeviceLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
834	{
835	LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
836	pszDevice, pszDevice, iInstance, iLun, ppBase));
837
838	/*
839	* Find the LUN.
840	*/
841	PPDMLUN pLun;
842	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
843	if (VBOX_SUCCESS(rc))
844	{
845	*ppBase = pLun->pBase;
846	LogFlow(("PDMR3QueryDeviceLun: return VINF_SUCCESS and ppBase=%p\n", ppBase));
847	return VINF_SUCCESS;
848	}
849	LogFlow(("PDMR3QueryDeviceLun: returns %Vrc\n", rc));
850	return rc;
851	}
852
853
854	/**
855	* Query the interface of the top level driver on a LUN.
856	*
857	* @returns VBox status code.
858	* @param pVM VM Handle.
859	* @param pszDevice Device name.
860	* @param iInstance Device instance.
861	* @param iLun The Logical Unit to obtain the interface of.
862	* @param ppBase Where to store the base interface pointer.
863	* @remark We're doing any locking ATM, so don't try call this at times when the
864	* device chain is known to be updated.
865	*/
866	PDMR3DECL(int) PDMR3QueryLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE ppBase)
867	{
868	LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
869	pszDevice, pszDevice, iInstance, iLun, ppBase));
870
871	/*
872	* Find the LUN.
873	*/
874	PPDMLUN pLun;
875	int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
876	if (VBOX_SUCCESS(rc))
877	{
878	if (pLun->pTop)
879	{
880	*ppBase = &pLun->pTop->IBase;
881	LogFlow(("PDMR3QueryLun: return %Vrc and ppBase=%p\n", VINF_SUCCESS, ppBase));
882	return VINF_SUCCESS;
883	}
884	rc = VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN;
885	}
886	LogFlow(("PDMR3QueryLun: returns %Vrc\n", rc));
887	return rc;
888	}
889
890	/**
891	* Executes pending DMA transfers.
892	* Forced Action handler.
893	*
894	* @param pVM VM handle.
895	*/
896	PDMR3DECL(void) PDMR3DmaRun(PVM pVM)
897	{
898	VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
899	if (pVM->pdm.s.pDmac)
900	{
901	bool fMore = pVM->pdm.s.pDmac->Reg.pfnRun(pVM->pdm.s.pDmac->pDevIns);
902	if (fMore)
903	VM_FF_SET(pVM, VM_FF_PDM_DMA);
904	}
905	}
906
907
908	/**
909	* Call polling function.
910	*
911	* @param pVM VM handle.
912	*/
913	PDMR3DECL(void) PDMR3Poll(PVM pVM)
914	{
915	/* This is temporary hack and shall be removed ASAP! */
916	unsigned iPoller = pVM->pdm.s.cPollers;
917	if (iPoller)
918	{
919	while (iPoller-- > 0)
920	pVM->pdm.s.apfnPollers[iPoller](pVM->pdm.s.aDrvInsPollers[iPoller]);
921	TMTimerSetMillies(pVM->pdm.s.pTimerPollers, 3);
922	}
923	}
924
925
926	/**
927	* Internal timer callback function.
928	*
929	* @param pVM The VM.
930	* @param pTimer The timer handle.
931	* @param pvUser User argument specified upon timer creation.
932	*/
933	static DECLCALLBACK(void) pdmR3PollerTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
934	{
935	PDMR3Poll(pVM);
936	}
937
938
939	/**
940	* Serivce a VMMCALLHOST_PDM_LOCK call.
941	*
942	* @returns VBox status code.
943	* @param pVM The VM handle.
944	*/
945	PDMR3DECL(int) PDMR3LockCall(PVM pVM)
946	{
947	return pdmLockEx(pVM, VERR_INTERNAL_ERROR);
948	}
949

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

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

Download in other formats: