DBGFOS.cpp@ 43363

Last change on this file since 43363 was 41965, checked in by vboxsync, 12 years ago
VMM: ran scm. Mostly svn:keywords changes (adding Revision).
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 13.3 KB

Line
1	/* $Id: DBGFOS.cpp 41965 2012-06-29 02:52:49Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Guest OS Diggers.
4	*/
5
6	/*
7	* Copyright (C) 2008 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGF
23	#include <VBox/vmm/dbgf.h>
24	#include <VBox/vmm/mm.h>
25	#include "DBGFInternal.h"
26	#include <VBox/vmm/vm.h>
27	#include <VBox/err.h>
28	#include <VBox/log.h>
29
30	#include <iprt/assert.h>
31	#include <iprt/thread.h>
32	#include <iprt/param.h>
33
34
35	/*******************************************************************************
36	* Defined Constants And Macros *
37	*******************************************************************************/
38	#define DBGF_OS_READ_LOCK(pVM) do { } while (0)
39	#define DBGF_OS_READ_UNLOCK(pVM) do { } while (0)
40
41	#define DBGF_OS_WRITE_LOCK(pVM) do { } while (0)
42	#define DBGF_OS_WRITE_UNLOCK(pVM) do { } while (0)
43
44
45	/**
46	* Internal cleanup routine called by DBGFR3Term().
47	*
48	* @param pVM Pointer to the VM.
49	*/
50	void dbgfR3OSTerm(PVM pVM)
51	{
52	/*
53	* Terminate the current one.
54	*/
55	if (pVM->dbgf.s.pCurOS)
56	{
57	pVM->dbgf.s.pCurOS->pReg->pfnTerm(pVM, pVM->dbgf.s.pCurOS->abData);
58	pVM->dbgf.s.pCurOS = NULL;
59	}
60
61	/*
62	* Destroy all the instances.
63	*/
64	while (pVM->dbgf.s.pOSHead)
65	{
66	PDBGFOS pOS = pVM->dbgf.s.pOSHead;
67	pVM->dbgf.s.pOSHead = pOS->pNext;
68	if (pOS->pReg->pfnDestruct)
69	pOS->pReg->pfnDestruct(pVM, pOS->abData);
70	MMR3HeapFree(pOS);
71	}
72	}
73
74
75	/**
76	* EMT worker function for DBGFR3OSRegister.
77	*
78	* @returns VBox status code.
79	* @param pVM Pointer to the VM.
80	* @param pReg The registration structure.
81	*/
82	static DECLCALLBACK(int) dbgfR3OSRegister(PVM pVM, PDBGFOSREG pReg)
83	{
84	/* more validations. */
85	DBGF_OS_READ_LOCK(pVM);
86	PDBGFOS pOS;
87	for (pOS = pVM->dbgf.s.pOSHead; pOS; pOS = pOS->pNext)
88	if (!strcmp(pOS->pReg->szName, pReg->szName))
89	{
90	DBGF_OS_READ_UNLOCK(pVM);
91	Log(("dbgfR3OSRegister: %s -> VERR_ALREADY_LOADED\n", pReg->szName));
92	return VERR_ALREADY_LOADED;
93	}
94
95	/*
96	* Allocate a new structure, call the constructor and link it into the list.
97	*/
98	pOS = (PDBGFOS)MMR3HeapAllocZ(pVM, MM_TAG_DBGF_OS, RT_OFFSETOF(DBGFOS, abData[pReg->cbData]));
99	AssertReturn(pOS, VERR_NO_MEMORY);
100	pOS->pReg = pReg;
101
102	int rc = pOS->pReg->pfnConstruct(pVM, pOS->abData);
103	if (RT_SUCCESS(rc))
104	{
105	DBGF_OS_WRITE_LOCK(pVM);
106	pOS->pNext = pVM->dbgf.s.pOSHead;
107	pVM->dbgf.s.pOSHead = pOS;
108	DBGF_OS_WRITE_UNLOCK(pVM);
109	}
110	else
111	{
112	if (pOS->pReg->pfnDestruct)
113	pOS->pReg->pfnDestruct(pVM, pOS->abData);
114	MMR3HeapFree(pOS);
115	}
116
117	return VINF_SUCCESS;
118	}
119
120
121	/**
122	* Registers a guest OS digger.
123	*
124	* This will instantiate an instance of the digger and add it
125	* to the list for us in the next call to DBGFR3OSDetect().
126	*
127	* @returns VBox status code.
128	* @param pVM Pointer to the VM.
129	* @param pReg The registration structure.
130	* @thread Any.
131	*/
132	VMMR3DECL(int) DBGFR3OSRegister(PVM pVM, PCDBGFOSREG pReg)
133	{
134	/*
135	* Validate intput.
136	*/
137	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
138
139	AssertPtrReturn(pReg, VERR_INVALID_POINTER);
140	AssertReturn(pReg->u32Magic == DBGFOSREG_MAGIC, VERR_INVALID_MAGIC);
141	AssertReturn(pReg->u32EndMagic == DBGFOSREG_MAGIC, VERR_INVALID_MAGIC);
142	AssertReturn(!pReg->fFlags, VERR_INVALID_PARAMETER);
143	AssertReturn(pReg->cbData < _2G, VERR_INVALID_PARAMETER);
144	AssertReturn(pReg->szName[0], VERR_INVALID_NAME);
145	AssertReturn(RTStrEnd(&pReg->szName[0], sizeof(pReg->szName)), VERR_INVALID_NAME);
146	AssertPtrReturn(pReg->pfnConstruct, VERR_INVALID_POINTER);
147	AssertPtrNullReturn(pReg->pfnDestruct, VERR_INVALID_POINTER);
148	AssertPtrReturn(pReg->pfnProbe, VERR_INVALID_POINTER);
149	AssertPtrReturn(pReg->pfnInit, VERR_INVALID_POINTER);
150	AssertPtrReturn(pReg->pfnRefresh, VERR_INVALID_POINTER);
151	AssertPtrReturn(pReg->pfnTerm, VERR_INVALID_POINTER);
152	AssertPtrReturn(pReg->pfnQueryVersion, VERR_INVALID_POINTER);
153	AssertPtrReturn(pReg->pfnQueryInterface, VERR_INVALID_POINTER);
154
155	/*
156	* Pass it on to EMT(0).
157	*/
158	return VMR3ReqPriorityCallWait(pVM, 0 /idDstCpu/, (PFNRT)dbgfR3OSRegister, 2, pVM, pReg);
159	}
160
161
162	/**
163	* EMT worker function for DBGFR3OSDeregister.
164	*
165	* @returns VBox status code.
166	* @param pVM Pointer to the VM.
167	* @param pReg The registration structure.
168	*/
169	static DECLCALLBACK(int) dbgfR3OSDeregister(PVM pVM, PDBGFOSREG pReg)
170	{
171	/*
172	* Unlink it.
173	*/
174	bool fWasCurOS = false;
175	PDBGFOS pOSPrev = NULL;
176	PDBGFOS pOS;
177	DBGF_OS_WRITE_LOCK(pVM);
178	for (pOS = pVM->dbgf.s.pOSHead; pOS; pOSPrev = pOS, pOS = pOS->pNext)
179	if (pOS->pReg == pReg)
180	{
181	if (pOSPrev)
182	pOSPrev->pNext = pOS->pNext;
183	else
184	pVM->dbgf.s.pOSHead = pOS->pNext;
185	if (pVM->dbgf.s.pCurOS == pOS)
186	{
187	pVM->dbgf.s.pCurOS = NULL;
188	fWasCurOS = true;
189	}
190	break;
191	}
192	DBGF_OS_WRITE_UNLOCK(pVM);
193	if (!pOS)
194	{
195	Log(("DBGFR3OSDeregister: %s -> VERR_NOT_FOUND\n", pReg->szName));
196	return VERR_NOT_FOUND;
197	}
198
199	/*
200	* Terminate it if it was the current OS, then invoke the
201	* destructor and clean up.
202	*/
203	if (fWasCurOS)
204	pOS->pReg->pfnTerm(pVM, pOS->abData);
205	if (pOS->pReg->pfnDestruct)
206	pOS->pReg->pfnDestruct(pVM, pOS->abData);
207	MMR3HeapFree(pOS);
208
209	return VINF_SUCCESS;
210	}
211
212
213	/**
214	* Deregisters a guest OS digger previously registered by DBGFR3OSRegister.
215	*
216	* @returns VBox status code.
217	*
218	* @param pVM Pointer to the VM.
219	* @param pReg The registration structure.
220	* @thread Any.
221	*/
222	VMMR3DECL(int) DBGFR3OSDeregister(PVM pVM, PCDBGFOSREG pReg)
223	{
224	/*
225	* Validate input.
226	*/
227	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
228	AssertPtrReturn(pReg, VERR_INVALID_POINTER);
229	AssertReturn(pReg->u32Magic == DBGFOSREG_MAGIC, VERR_INVALID_MAGIC);
230	AssertReturn(pReg->u32EndMagic == DBGFOSREG_MAGIC, VERR_INVALID_MAGIC);
231	AssertReturn(RTStrEnd(&pReg->szName[0], sizeof(pReg->szName)), VERR_INVALID_NAME);
232
233	DBGF_OS_READ_LOCK(pVM);
234	PDBGFOS pOS;
235	for (pOS = pVM->dbgf.s.pOSHead; pOS; pOS = pOS->pNext)
236	if (pOS->pReg == pReg)
237	break;
238	DBGF_OS_READ_LOCK(pVM);
239
240	if (!pOS)
241	{
242	Log(("DBGFR3OSDeregister: %s -> VERR_NOT_FOUND\n", pReg->szName));
243	return VERR_NOT_FOUND;
244	}
245
246	/*
247	* Pass it on to EMT(0).
248	*/
249	return VMR3ReqPriorityCallWait(pVM, 0 /idDstCpu/, (PFNRT)dbgfR3OSDeregister, 2, pVM, pReg);
250	}
251
252
253	/**
254	* EMT worker function for DBGFR3OSDetect.
255	*
256	* @returns VBox status code.
257	* @retval VINF_SUCCESS if successfully detected.
258	* @retval VINF_DBGF_OS_NOT_DETCTED if we cannot figure it out.
259	*
260	* @param pVM Pointer to the VM.
261	* @param pszName Where to store the OS name. Empty string if not detected.
262	* @param cchName Size of the buffer.
263	*/
264	static DECLCALLBACK(int) dbgfR3OSDetect(PVM pVM, char *pszName, size_t cchName)
265	{
266	/*
267	* Cycle thru the detection routines.
268	*/
269	PDBGFOS const pOldOS = pVM->dbgf.s.pCurOS;
270	pVM->dbgf.s.pCurOS = NULL;
271
272	for (PDBGFOS pNewOS = pVM->dbgf.s.pOSHead; pNewOS; pNewOS = pNewOS->pNext)
273	if (pNewOS->pReg->pfnProbe(pVM, pNewOS->abData))
274	{
275	int rc;
276	pVM->dbgf.s.pCurOS = pNewOS;
277	if (pOldOS == pNewOS)
278	rc = pNewOS->pReg->pfnRefresh(pVM, pNewOS->abData);
279	else
280	{
281	if (pOldOS)
282	pOldOS->pReg->pfnTerm(pVM, pNewOS->abData);
283	rc = pNewOS->pReg->pfnInit(pVM, pNewOS->abData);
284	}
285	if (pszName && cchName)
286	strncat(pszName, pNewOS->pReg->szName, cchName);
287	return rc;
288	}
289
290	/* not found */
291	if (pOldOS)
292	pOldOS->pReg->pfnTerm(pVM, pOldOS->abData);
293	return VINF_DBGF_OS_NOT_DETCTED;
294	}
295
296
297	/**
298	* Detects the guest OS and try dig out symbols and useful stuff.
299	*
300	* When called the 2nd time, symbols will be updated that if the OS
301	* is the same.
302	*
303	* @returns VBox status code.
304	* @retval VINF_SUCCESS if successfully detected.
305	* @retval VINF_DBGF_OS_NOT_DETCTED if we cannot figure it out.
306	*
307	* @param pVM Pointer to the VM.
308	* @param pszName Where to store the OS name. Empty string if not detected.
309	* @param cchName Size of the buffer.
310	* @thread Any.
311	*/
312	VMMR3DECL(int) DBGFR3OSDetect(PVM pVM, char *pszName, size_t cchName)
313	{
314	AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
315	if (pszName && cchName)
316	*pszName = '\0';
317
318	/*
319	* Pass it on to EMT(0).
320	*/
321	return VMR3ReqPriorityCallWait(pVM, 0 /idDstCpu/, (PFNRT)dbgfR3OSDetect, 3, pVM, pszName, cchName);
322	}
323
324
325	/**
326	* EMT worker function for DBGFR3OSQueryNameAndVersion
327	*
328	* @returns VBox status code.
329	* @param pVM Pointer to the VM.
330	* @param pszName Where to store the OS name. Optional.
331	* @param cchName The size of the name buffer.
332	* @param pszVersion Where to store the version string. Optional.
333	* @param cchVersion The size of the version buffer.
334	*/
335	static DECLCALLBACK(int) dbgfR3OSQueryNameAndVersion(PVM pVM, char pszName, size_t cchName, char pszVersion, size_t cchVersion)
336	{
337	/*
338	* Any known OS?
339	*/
340	if (pVM->dbgf.s.pCurOS)
341	{
342	int rc = VINF_SUCCESS;
343	if (pszName && cchName)
344	{
345	size_t cch = strlen(pVM->dbgf.s.pCurOS->pReg->szName);
346	if (cchName > cch)
347	memcpy(pszName, pVM->dbgf.s.pCurOS->pReg->szName, cch + 1);
348	else
349	{
350	memcpy(pszName, pVM->dbgf.s.pCurOS->pReg->szName, cchName - 1);
351	pszName[cchName - 1] = '\0';
352	rc = VINF_BUFFER_OVERFLOW;
353	}
354	}
355
356	if (pszVersion && cchVersion)
357	{
358	int rc2 = pVM->dbgf.s.pCurOS->pReg->pfnQueryVersion(pVM, pVM->dbgf.s.pCurOS->abData, pszVersion, cchVersion);
359	if (RT_FAILURE(rc2) \|\| rc == VINF_SUCCESS)
360	rc = rc2;
361	}
362	return rc;
363	}
364
365	return VERR_DBGF_OS_NOT_DETCTED;
366	}
367
368
369	/**
370	* Queries the name and/or version string for the guest OS.
371	*
372	* It goes without saying that this querying is done using the current
373	* guest OS digger and not additions or user configuration.
374	*
375	* @returns VBox status code.
376	* @param pVM Pointer to the VM.
377	* @param pszName Where to store the OS name. Optional.
378	* @param cchName The size of the name buffer.
379	* @param pszVersion Where to store the version string. Optional.
380	* @param cchVersion The size of the version buffer.
381	* @thread Any.
382	*/
383	VMMR3DECL(int) DBGFR3OSQueryNameAndVersion(PVM pVM, char pszName, size_t cchName, char pszVersion, size_t cchVersion)
384	{
385	AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
386	AssertPtrNullReturn(pszVersion, VERR_INVALID_POINTER);
387
388	/*
389	* Initialize the output up front.
390	*/
391	if (pszName && cchName)
392	*pszName = '\0';
393	if (pszVersion && cchVersion)
394	*pszVersion = '\0';
395
396	/*
397	* Pass it on to EMT(0).
398	*/
399	return VMR3ReqPriorityCallWait(pVM, 0 /idDstCpu/,
400	(PFNRT)dbgfR3OSQueryNameAndVersion, 5, pVM, pszName, cchName, pszVersion, cchVersion);
401	}
402
403
404	/**
405	* EMT worker for DBGFR3OSQueryInterface.
406	*
407	* @param pVM Pointer to the VM.
408	* @param enmIf The interface identifier.
409	* @param ppvIf Where to store the interface pointer on success.
410	*/
411	static DECLCALLBACK(void) dbgfR3OSQueryInterface(PVM pVM, DBGFOSINTERFACE enmIf, void **ppvIf)
412	{
413	if (pVM->dbgf.s.pCurOS)
414	{
415	*ppvIf = pVM->dbgf.s.pCurOS->pReg->pfnQueryInterface(pVM, pVM->dbgf.s.pCurOS->abData, enmIf);
416	if (*ppvIf)
417	{
418	/** @todo Create EMT wrapper for the returned interface once we've defined one...
419	* Just keep a list of wrapper together with the OS instance. */
420	}
421	}
422	else
423	*ppvIf = NULL;
424	}
425
426
427	/**
428	* Query an optional digger interface.
429	*
430	* @returns Pointer to the digger interface on success, NULL if the interfaces isn't
431	* available or no active guest OS digger.
432	* @param pVM Pointer to the VM.
433	* @param enmIf The interface identifier.
434	* @thread Any.
435	*/
436	VMMR3DECL(void *) DBGFR3OSQueryInterface(PVM pVM, DBGFOSINTERFACE enmIf)
437	{
438	AssertMsgReturn(enmIf > DBGFOSINTERFACE_INVALID && enmIf < DBGFOSINTERFACE_END, ("%d\n", enmIf), NULL);
439
440	/*
441	* Pass it on to an EMT.
442	*/
443	void *pvIf = NULL;
444	VMR3ReqPriorityCallVoidWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3OSQueryInterface, 3, pVM, enmIf, &pvIf);
445	return pvIf;
446	}
447

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFOS.cpp@ 43363

Download in other formats: