DBGFInfo.cpp@ 56085

Last change on this file since 56085 was 55881, checked in by vboxsync, 10 years ago
DBGF,DBGC: Moved the plug-ins from DBGC to DBGF so we can make use of them via IMachineDebugger.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 32.4 KB

Line
1	/* $Id: DBGFInfo.cpp 55881 2015-05-16 01:02:51Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Info.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 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_INFO
23	#include <VBox/vmm/dbgf.h>
24
25	#include <VBox/vmm/mm.h>
26	#include "DBGFInternal.h"
27	#include <VBox/vmm/vm.h>
28	#include <VBox/vmm/uvm.h>
29	#include <VBox/err.h>
30	#include <VBox/log.h>
31
32	#include <iprt/assert.h>
33	#include <iprt/ctype.h>
34	#include <iprt/param.h>
35	#include <iprt/semaphore.h>
36	#include <iprt/stream.h>
37	#include <iprt/string.h>
38	#include <iprt/thread.h>
39
40
41	/*******************************************************************************
42	* Internal Functions *
43	*******************************************************************************/
44	static DECLCALLBACK(void) dbgfR3InfoLog_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...);
45	static DECLCALLBACK(void) dbgfR3InfoLog_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args);
46	static DECLCALLBACK(void) dbgfR3InfoLogRel_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...);
47	static DECLCALLBACK(void) dbgfR3InfoLogRel_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args);
48	static DECLCALLBACK(void) dbgfR3InfoStdErr_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...);
49	static DECLCALLBACK(void) dbgfR3InfoStdErr_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args);
50	static DECLCALLBACK(void) dbgfR3InfoHelp(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
51
52
53	/*******************************************************************************
54	* Global Variables *
55	*******************************************************************************/
56	/** Logger output. */
57	static const DBGFINFOHLP g_dbgfR3InfoLogHlp =
58	{
59	dbgfR3InfoLog_Printf,
60	dbgfR3InfoLog_PrintfV
61	};
62
63	/** Release logger output. */
64	static const DBGFINFOHLP g_dbgfR3InfoLogRelHlp =
65	{
66	dbgfR3InfoLogRel_Printf,
67	dbgfR3InfoLogRel_PrintfV
68	};
69
70	/** Standard error output. */
71	static const DBGFINFOHLP g_dbgfR3InfoStdErrHlp =
72	{
73	dbgfR3InfoStdErr_Printf,
74	dbgfR3InfoStdErr_PrintfV
75	};
76
77
78	/**
79	* Initialize the info handlers.
80	*
81	* This is called first during the DBGF init process and thus does the shared
82	* critsect init.
83	*
84	* @returns VBox status code.
85	* @param pUVM The user mode VM handle.
86	*/
87	int dbgfR3InfoInit(PUVM pUVM)
88	{
89	/*
90	* Make sure we already didn't initialized in the lazy manner.
91	*/
92	if (RTCritSectRwIsInitialized(&pUVM->dbgf.s.CritSect))
93	return VINF_SUCCESS;
94
95	/*
96	* Initialize the crit sect.
97	*/
98	int rc = RTCritSectRwInit(&pUVM->dbgf.s.CritSect);
99	AssertRCReturn(rc, rc);
100
101	/*
102	* Register the 'info help' item.
103	*/
104	rc = DBGFR3InfoRegisterInternal(pUVM->pVM, "help", "List of info items.", dbgfR3InfoHelp);
105	AssertRCReturn(rc, rc);
106
107	return VINF_SUCCESS;
108	}
109
110
111	/**
112	* Terminate the info handlers.
113	*
114	* @returns VBox status code.
115	* @param pUVM The user mode VM handle.
116	*/
117	int dbgfR3InfoTerm(PUVM pUVM)
118	{
119	/*
120	* Delete the crit sect.
121	*/
122	int rc = RTCritSectRwDelete(&pUVM->dbgf.s.CritSect);
123	AssertRC(rc);
124	return rc;
125	}
126
127
128	/** Logger output.
129	* @copydoc DBGFINFOHLP::pfnPrintf */
130	static DECLCALLBACK(void) dbgfR3InfoLog_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
131	{
132	NOREF(pHlp);
133	va_list args;
134	va_start(args, pszFormat);
135	RTLogPrintfV(pszFormat, args);
136	va_end(args);
137	}
138
139	/** Logger output.
140	* @copydoc DBGFINFOHLP::pfnPrintfV */
141	static DECLCALLBACK(void) dbgfR3InfoLog_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
142	{
143	NOREF(pHlp);
144	RTLogPrintfV(pszFormat, args);
145	}
146
147
148	/**
149	* Gets the logger info helper.
150	* The returned info helper will unconditionally write all output to the log.
151	*
152	* @returns Pointer to the logger info helper.
153	*/
154	VMMR3DECL(PCDBGFINFOHLP) DBGFR3InfoLogHlp(void)
155	{
156	return &g_dbgfR3InfoLogHlp;
157	}
158
159
160	/** Release logger output.
161	* @copydoc DBGFINFOHLP::pfnPrintf */
162	static DECLCALLBACK(void) dbgfR3InfoLogRel_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
163	{
164	NOREF(pHlp);
165	va_list args;
166	va_start(args, pszFormat);
167	RTLogRelPrintfV(pszFormat, args);
168	va_end(args);
169	}
170
171	/** Release logger output.
172	* @copydoc DBGFINFOHLP::pfnPrintfV */
173	static DECLCALLBACK(void) dbgfR3InfoLogRel_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
174	{
175	NOREF(pHlp);
176	RTLogRelPrintfV(pszFormat, args);
177	}
178
179
180	/** Standard error output.
181	* @copydoc DBGFINFOHLP::pfnPrintf */
182	static DECLCALLBACK(void) dbgfR3InfoStdErr_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
183	{
184	NOREF(pHlp);
185	va_list args;
186	va_start(args, pszFormat);
187	RTStrmPrintfV(g_pStdErr, pszFormat, args);
188	va_end(args);
189	}
190
191	/** Standard error output.
192	* @copydoc DBGFINFOHLP::pfnPrintfV */
193	static DECLCALLBACK(void) dbgfR3InfoStdErr_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
194	{
195	NOREF(pHlp);
196	RTStrmPrintfV(g_pStdErr, pszFormat, args);
197	}
198
199
200	/**
201	* Gets the release logger info helper.
202	* The returned info helper will unconditionally write all output to the release log.
203	*
204	* @returns Pointer to the release logger info helper.
205	*/
206	VMMR3DECL(PCDBGFINFOHLP) DBGFR3InfoLogRelHlp(void)
207	{
208	return &g_dbgfR3InfoLogRelHlp;
209	}
210
211
212	/**
213	* Handle registration worker.
214	*
215	* This allocates the structure, initializes the common fields and inserts into the list.
216	* Upon successful return the we're inside the crit sect and the caller must leave it.
217	*
218	* @returns VBox status code.
219	* @param pUVM The user mode VM handle.
220	* @param pszName The identifier of the info.
221	* @param pszDesc The description of the info and any arguments the handler may take.
222	* @param fFlags The flags.
223	* @param ppInfo Where to store the created
224	*/
225	static int dbgfR3InfoRegister(PUVM pUVM, const char pszName, const char pszDesc, uint32_t fFlags, PDBGFINFO *ppInfo)
226	{
227	/*
228	* Validate.
229	*/
230	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
231	AssertReturn(*pszName, VERR_INVALID_PARAMETER);
232	AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
233	AssertMsgReturn(!(fFlags & ~(DBGFINFO_FLAGS_RUN_ON_EMT)), ("fFlags=%#x\n", fFlags), VERR_INVALID_PARAMETER);
234
235	/*
236	* Allocate and initialize.
237	*/
238	int rc;
239	size_t cchName = strlen(pszName) + 1;
240	PDBGFINFO pInfo = (PDBGFINFO)MMR3HeapAllocU(pUVM, MM_TAG_DBGF_INFO, RT_OFFSETOF(DBGFINFO, szName[cchName]));
241	if (pInfo)
242	{
243	pInfo->enmType = DBGFINFOTYPE_INVALID;
244	pInfo->fFlags = fFlags;
245	pInfo->pszDesc = pszDesc;
246	pInfo->cchName = cchName - 1;
247	memcpy(pInfo->szName, pszName, cchName);
248
249	/* lazy init */
250	rc = VINF_SUCCESS;
251	if (!RTCritSectRwIsInitialized(&pUVM->dbgf.s.CritSect))
252	rc = dbgfR3InfoInit(pUVM);
253	if (RT_SUCCESS(rc))
254	{
255	/*
256	* Insert in alphabetical order.
257	*/
258	rc = RTCritSectRwEnterExcl(&pUVM->dbgf.s.CritSect);
259	AssertRC(rc);
260	PDBGFINFO pPrev = NULL;
261	PDBGFINFO pCur;
262	for (pCur = pUVM->dbgf.s.pInfoFirst; pCur; pPrev = pCur, pCur = pCur->pNext)
263	if (strcmp(pszName, pCur->szName) < 0)
264	break;
265	pInfo->pNext = pCur;
266	if (pPrev)
267	pPrev->pNext = pInfo;
268	else
269	pUVM->dbgf.s.pInfoFirst = pInfo;
270
271	*ppInfo = pInfo;
272	return VINF_SUCCESS;
273	}
274	MMR3HeapFree(pInfo);
275	}
276	else
277	rc = VERR_NO_MEMORY;
278	return rc;
279	}
280
281
282	/**
283	* Register a info handler owned by a device.
284	*
285	* @returns VBox status code.
286	* @param pVM Pointer to the VM.
287	* @param pszName The identifier of the info.
288	* @param pszDesc The description of the info and any arguments the handler may take.
289	* @param pfnHandler The handler function to be called to display the info.
290	* @param pDevIns The device instance owning the info.
291	*/
292	VMMR3_INT_DECL(int) DBGFR3InfoRegisterDevice(PVM pVM, const char pszName, const char pszDesc,
293	PFNDBGFHANDLERDEV pfnHandler, PPDMDEVINS pDevIns)
294	{
295	LogFlow(("DBGFR3InfoRegisterDevice: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p pDevIns=%p\n",
296	pszName, pszName, pszDesc, pszDesc, pfnHandler, pDevIns));
297
298	/*
299	* Validate the specific stuff.
300	*/
301	AssertPtrReturn(pfnHandler, VERR_INVALID_POINTER);
302	AssertPtrReturn(pDevIns, VERR_INVALID_POINTER);
303
304	/*
305	* Register
306	*/
307	PDBGFINFO pInfo;
308	int rc = dbgfR3InfoRegister(pVM->pUVM, pszName, pszDesc, 0, &pInfo);
309	if (RT_SUCCESS(rc))
310	{
311	pInfo->enmType = DBGFINFOTYPE_DEV;
312	pInfo->u.Dev.pfnHandler = pfnHandler;
313	pInfo->u.Dev.pDevIns = pDevIns;
314	RTCritSectRwLeaveExcl(&pVM->pUVM->dbgf.s.CritSect);
315	}
316
317	return rc;
318	}
319
320
321	/**
322	* Register a info handler owned by a driver.
323	*
324	* @returns VBox status code.
325	* @param pVM Pointer to the VM.
326	* @param pszName The identifier of the info.
327	* @param pszDesc The description of the info and any arguments the handler may take.
328	* @param pfnHandler The handler function to be called to display the info.
329	* @param pDrvIns The driver instance owning the info.
330	*/
331	VMMR3_INT_DECL(int) DBGFR3InfoRegisterDriver(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLERDRV pfnHandler, PPDMDRVINS pDrvIns)
332	{
333	LogFlow(("DBGFR3InfoRegisterDriver: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p pDrvIns=%p\n",
334	pszName, pszName, pszDesc, pszDesc, pfnHandler, pDrvIns));
335
336	/*
337	* Validate the specific stuff.
338	*/
339	AssertPtrReturn(pfnHandler, VERR_INVALID_POINTER);
340	AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
341
342	/*
343	* Register
344	*/
345	PDBGFINFO pInfo;
346	int rc = dbgfR3InfoRegister(pVM->pUVM, pszName, pszDesc, 0, &pInfo);
347	if (RT_SUCCESS(rc))
348	{
349	pInfo->enmType = DBGFINFOTYPE_DRV;
350	pInfo->u.Drv.pfnHandler = pfnHandler;
351	pInfo->u.Drv.pDrvIns = pDrvIns;
352	RTCritSectRwLeaveExcl(&pVM->pUVM->dbgf.s.CritSect);
353	}
354
355	return rc;
356	}
357
358
359	/**
360	* Register a info handler owned by an internal component.
361	*
362	* @returns VBox status code.
363	* @param pVM Pointer to the VM.
364	* @param pszName The identifier of the info.
365	* @param pszDesc The description of the info and any arguments the handler may take.
366	* @param pfnHandler The handler function to be called to display the info.
367	*/
368	VMMR3_INT_DECL(int) DBGFR3InfoRegisterInternal(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLERINT pfnHandler)
369	{
370	return DBGFR3InfoRegisterInternalEx(pVM, pszName, pszDesc, pfnHandler, 0);
371	}
372
373
374	/**
375	* Register a info handler owned by an internal component.
376	*
377	* @returns VBox status code.
378	* @param pVM Pointer to the VM.
379	* @param pszName The identifier of the info.
380	* @param pszDesc The description of the info and any arguments the handler may take.
381	* @param pfnHandler The handler function to be called to display the info.
382	* @param fFlags Flags, see the DBGFINFO_FLAGS_*.
383	*/
384	VMMR3_INT_DECL(int) DBGFR3InfoRegisterInternalEx(PVM pVM, const char pszName, const char pszDesc,
385	PFNDBGFHANDLERINT pfnHandler, uint32_t fFlags)
386	{
387	LogFlow(("DBGFR3InfoRegisterInternal: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p fFlags=%x\n",
388	pszName, pszName, pszDesc, pszDesc, pfnHandler, fFlags));
389
390	/*
391	* Validate the specific stuff.
392	*/
393	AssertPtrReturn(pfnHandler, VERR_INVALID_POINTER);
394
395	/*
396	* Register
397	*/
398	PDBGFINFO pInfo;
399	int rc = dbgfR3InfoRegister(pVM->pUVM, pszName, pszDesc, fFlags, &pInfo);
400	if (RT_SUCCESS(rc))
401	{
402	pInfo->enmType = DBGFINFOTYPE_INT;
403	pInfo->u.Int.pfnHandler = pfnHandler;
404	RTCritSectRwLeaveExcl(&pVM->pUVM->dbgf.s.CritSect);
405	}
406
407	return rc;
408	}
409
410
411	/**
412	* Register a info handler owned by an external component.
413	*
414	* @returns VBox status code.
415	* @param pUVM The user mode VM handle.
416	* @param pszName The identifier of the info.
417	* @param pszDesc The description of the info and any arguments the handler may take.
418	* @param pfnHandler The handler function to be called to display the info.
419	* @param pvUser User argument to be passed to the handler.
420	*/
421	VMMR3DECL(int) DBGFR3InfoRegisterExternal(PUVM pUVM, const char pszName, const char pszDesc,
422	PFNDBGFHANDLEREXT pfnHandler, void *pvUser)
423	{
424	LogFlow(("DBGFR3InfoRegisterExternal: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p pvUser=%p\n",
425	pszName, pszName, pszDesc, pszDesc, pfnHandler, pvUser));
426
427	/*
428	* Validate the specific stuff.
429	*/
430	AssertPtrReturn(pfnHandler, VERR_INVALID_POINTER);
431	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
432
433	/*
434	* Register
435	*/
436	PDBGFINFO pInfo;
437	int rc = dbgfR3InfoRegister(pUVM, pszName, pszDesc, 0, &pInfo);
438	if (RT_SUCCESS(rc))
439	{
440	pInfo->enmType = DBGFINFOTYPE_EXT;
441	pInfo->u.Ext.pfnHandler = pfnHandler;
442	pInfo->u.Ext.pvUser = pvUser;
443	RTCritSectRwLeaveExcl(&pUVM->dbgf.s.CritSect);
444	}
445
446	return rc;
447	}
448
449
450	/**
451	* Deregister one(/all) info handler(s) owned by a device.
452	*
453	* @returns VBox status code.
454	* @param pVM Pointer to the VM.
455	* @param pDevIns Device instance.
456	* @param pszName The identifier of the info. If NULL all owned by the device.
457	*/
458	VMMR3_INT_DECL(int) DBGFR3InfoDeregisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName)
459	{
460	LogFlow(("DBGFR3InfoDeregisterDevice: pDevIns=%p pszName=%p:{%s}\n", pDevIns, pszName, pszName));
461
462	/*
463	* Validate input.
464	*/
465	AssertPtrReturn(pDevIns, VERR_INVALID_POINTER);
466	AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
467	size_t cchName = pszName ? strlen(pszName) : 0;
468	PUVM pUVM = pVM->pUVM;
469
470	/*
471	* Enumerate the info handlers and free the requested entries.
472	*/
473	int rc = RTCritSectRwEnterExcl(&pUVM->dbgf.s.CritSect); AssertRC(rc);
474	rc = VERR_FILE_NOT_FOUND;
475	PDBGFINFO pPrev = NULL;
476	PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst;
477	if (pszName)
478	{
479	/*
480	* Free a specific one.
481	*/
482	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
483	if ( pInfo->enmType == DBGFINFOTYPE_DEV
484	&& pInfo->u.Dev.pDevIns == pDevIns
485	&& pInfo->cchName == cchName
486	&& !strcmp(pInfo->szName, pszName))
487	{
488	if (pPrev)
489	pPrev->pNext = pInfo->pNext;
490	else
491	pUVM->dbgf.s.pInfoFirst = pInfo->pNext;
492	MMR3HeapFree(pInfo);
493	rc = VINF_SUCCESS;
494	break;
495	}
496	}
497	else
498	{
499	/*
500	* Free all owned by the device.
501	*/
502	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
503	if ( pInfo->enmType == DBGFINFOTYPE_DEV
504	&& pInfo->u.Dev.pDevIns == pDevIns)
505	{
506	if (pPrev)
507	pPrev->pNext = pInfo->pNext;
508	else
509	pUVM->dbgf.s.pInfoFirst = pInfo->pNext;
510	MMR3HeapFree(pInfo);
511	pInfo = pPrev;
512	}
513	rc = VINF_SUCCESS;
514	}
515	int rc2 = RTCritSectRwLeaveExcl(&pUVM->dbgf.s.CritSect);
516	AssertRC(rc2);
517	AssertRC(rc);
518	LogFlow(("DBGFR3InfoDeregisterDevice: returns %Rrc\n", rc));
519	return rc;
520	}
521
522	/**
523	* Deregister one(/all) info handler(s) owned by a driver.
524	*
525	* @returns VBox status code.
526	* @param pVM Pointer to the VM.
527	* @param pDrvIns Driver instance.
528	* @param pszName The identifier of the info. If NULL all owned by the driver.
529	*/
530	VMMR3_INT_DECL(int) DBGFR3InfoDeregisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName)
531	{
532	LogFlow(("DBGFR3InfoDeregisterDriver: pDrvIns=%p pszName=%p:{%s}\n", pDrvIns, pszName, pszName));
533
534	/*
535	* Validate input.
536	*/
537	AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
538	AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
539	size_t cchName = pszName ? strlen(pszName) : 0;
540	PUVM pUVM = pVM->pUVM;
541
542	/*
543	* Enumerate the info handlers and free the requested entries.
544	*/
545	int rc = RTCritSectRwEnterExcl(&pUVM->dbgf.s.CritSect); AssertRC(rc);
546	rc = VERR_FILE_NOT_FOUND;
547	PDBGFINFO pPrev = NULL;
548	PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst;
549	if (pszName)
550	{
551	/*
552	* Free a specific one.
553	*/
554	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
555	if ( pInfo->enmType == DBGFINFOTYPE_DRV
556	&& pInfo->u.Drv.pDrvIns == pDrvIns
557	&& pInfo->cchName == cchName
558	&& !strcmp(pInfo->szName, pszName))
559	{
560	if (pPrev)
561	pPrev->pNext = pInfo->pNext;
562	else
563	pUVM->dbgf.s.pInfoFirst = pInfo->pNext;
564	MMR3HeapFree(pInfo);
565	rc = VINF_SUCCESS;
566	break;
567	}
568	}
569	else
570	{
571	/*
572	* Free all owned by the driver.
573	*/
574	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
575	if ( pInfo->enmType == DBGFINFOTYPE_DRV
576	&& pInfo->u.Drv.pDrvIns == pDrvIns)
577	{
578	if (pPrev)
579	pPrev->pNext = pInfo->pNext;
580	else
581	pUVM->dbgf.s.pInfoFirst = pInfo->pNext;
582	MMR3HeapFree(pInfo);
583	pInfo = pPrev;
584	}
585	rc = VINF_SUCCESS;
586	}
587	int rc2 = RTCritSectRwLeaveExcl(&pUVM->dbgf.s.CritSect);
588	AssertRC(rc2);
589	AssertRC(rc);
590	LogFlow(("DBGFR3InfoDeregisterDriver: returns %Rrc\n", rc));
591	return rc;
592	}
593
594
595	/**
596	* Internal deregistration helper.
597	*
598	* @returns VBox status code.
599	* @param pUVM Pointer to the VM.
600	* @param pszName The identifier of the info.
601	* @param enmType The info owner type.
602	*/
603	static int dbgfR3InfoDeregister(PUVM pUVM, const char *pszName, DBGFINFOTYPE enmType)
604	{
605	/*
606	* Validate input.
607	*/
608	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
609
610	/*
611	* Find the info handler.
612	*/
613	size_t cchName = strlen(pszName);
614	int rc = RTCritSectRwEnterExcl(&pUVM->dbgf.s.CritSect);
615	AssertRC(rc);
616	rc = VERR_FILE_NOT_FOUND;
617	PDBGFINFO pPrev = NULL;
618	PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst;
619	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
620	if ( pInfo->cchName == cchName
621	&& !strcmp(pInfo->szName, pszName)
622	&& pInfo->enmType == enmType)
623	{
624	if (pPrev)
625	pPrev->pNext = pInfo->pNext;
626	else
627	pUVM->dbgf.s.pInfoFirst = pInfo->pNext;
628	MMR3HeapFree(pInfo);
629	rc = VINF_SUCCESS;
630	break;
631	}
632	int rc2 = RTCritSectRwLeaveExcl(&pUVM->dbgf.s.CritSect);
633	AssertRC(rc2);
634	AssertRC(rc);
635	LogFlow(("dbgfR3InfoDeregister: returns %Rrc\n", rc));
636	return rc;
637	}
638
639
640	/**
641	* Deregister a info handler owned by an internal component.
642	*
643	* @returns VBox status code.
644	* @param pVM Pointer to the VM.
645	* @param pszName The identifier of the info. If NULL all owned by the device.
646	*/
647	VMMR3_INT_DECL(int) DBGFR3InfoDeregisterInternal(PVM pVM, const char *pszName)
648	{
649	LogFlow(("DBGFR3InfoDeregisterInternal: pszName=%p:{%s}\n", pszName, pszName));
650	return dbgfR3InfoDeregister(pVM->pUVM, pszName, DBGFINFOTYPE_INT);
651	}
652
653
654	/**
655	* Deregister a info handler owned by an external component.
656	*
657	* @returns VBox status code.
658	* @param pUVM The user mode VM handle.
659	* @param pszName The identifier of the info. If NULL all owned by the device.
660	*/
661	VMMR3DECL(int) DBGFR3InfoDeregisterExternal(PUVM pUVM, const char *pszName)
662	{
663	LogFlow(("DBGFR3InfoDeregisterExternal: pszName=%p:{%s}\n", pszName, pszName));
664	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
665	return dbgfR3InfoDeregister(pUVM, pszName, DBGFINFOTYPE_EXT);
666	}
667
668
669	/**
670	* Worker for DBGFR3Info and DBGFR3InfoEx.
671	*
672	* @returns VBox status code.
673	* @param pUVM The user mode VM handle.
674	* @param idCpu Which CPU to run EMT bound handlers on. VMCPUID_ANY or
675	* a valid CPU ID.
676	* @param pszName What to dump.
677	* @param pszArgs Arguments, optional.
678	* @param pHlp Output helper, optional.
679	*/
680	static DECLCALLBACK(int) dbgfR3Info(PUVM pUVM, VMCPUID idCpu, const char pszName, const char pszArgs, PCDBGFINFOHLP pHlp)
681	{
682	/*
683	* Validate input.
684	*/
685	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
686	AssertPtrNullReturn(pszArgs, VERR_INVALID_POINTER);
687	if (pHlp)
688	{
689	AssertPtrReturn(pHlp, VERR_INVALID_PARAMETER);
690	AssertPtrReturn(pHlp->pfnPrintf, VERR_INVALID_PARAMETER);
691	AssertPtrReturn(pHlp->pfnPrintfV, VERR_INVALID_PARAMETER);
692	}
693	else
694	pHlp = &g_dbgfR3InfoLogHlp;
695
696	/*
697	* Find the info handler.
698	*/
699	size_t cchName = strlen(pszName);
700	int rc = RTCritSectRwEnterShared(&pUVM->dbgf.s.CritSect);
701	AssertRC(rc);
702	PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst;
703	for (; pInfo; pInfo = pInfo->pNext)
704	if ( pInfo->cchName == cchName
705	&& !memcmp(pInfo->szName, pszName, cchName))
706	break;
707	if (pInfo)
708	{
709	/*
710	* Found it.
711	*/
712	rc = VINF_SUCCESS;
713	switch (pInfo->enmType)
714	{
715	case DBGFINFOTYPE_DEV:
716	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
717	rc = VMR3ReqCallVoidWaitU(pUVM, idCpu, (PFNRT)pInfo->u.Dev.pfnHandler, 3, pInfo->u.Dev.pDevIns, pHlp, pszArgs);
718	else
719	pInfo->u.Dev.pfnHandler(pInfo->u.Dev.pDevIns, pHlp, pszArgs);
720	break;
721
722	case DBGFINFOTYPE_DRV:
723	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
724	rc = VMR3ReqCallVoidWaitU(pUVM, idCpu, (PFNRT)pInfo->u.Drv.pfnHandler, 3, pInfo->u.Drv.pDrvIns, pHlp, pszArgs);
725	else
726	pInfo->u.Drv.pfnHandler(pInfo->u.Drv.pDrvIns, pHlp, pszArgs);
727	break;
728
729	case DBGFINFOTYPE_INT:
730	if (RT_VALID_PTR(pUVM->pVM))
731	{
732	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
733	rc = VMR3ReqCallVoidWaitU(pUVM, idCpu, (PFNRT)pInfo->u.Int.pfnHandler, 3, pUVM->pVM, pHlp, pszArgs);
734	else
735	pInfo->u.Int.pfnHandler(pUVM->pVM, pHlp, pszArgs);
736	}
737	else
738	rc = VERR_INVALID_VM_HANDLE;
739	break;
740
741	case DBGFINFOTYPE_EXT:
742	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
743	rc = VMR3ReqCallVoidWaitU(pUVM, idCpu, (PFNRT)pInfo->u.Ext.pfnHandler, 3, pInfo->u.Ext.pvUser, pHlp, pszArgs);
744	else
745	pInfo->u.Ext.pfnHandler(pInfo->u.Ext.pvUser, pHlp, pszArgs);
746	break;
747
748	default:
749	AssertMsgFailedReturn(("Invalid info type enmType=%d\n", pInfo->enmType), VERR_IPE_NOT_REACHED_DEFAULT_CASE);
750	}
751	int rc2 = RTCritSectRwLeaveShared(&pUVM->dbgf.s.CritSect);
752	AssertRC(rc2);
753	}
754	else
755	{
756	rc = RTCritSectRwLeaveShared(&pUVM->dbgf.s.CritSect);
757	AssertRC(rc);
758	rc = VERR_FILE_NOT_FOUND;
759	}
760	return rc;
761	}
762
763	/**
764	* Display a piece of info writing to the supplied handler.
765	*
766	* @returns VBox status code.
767	* @param pUVM The user mode VM handle.
768	* @param pszName The identifier of the info to display.
769	* @param pszArgs Arguments to the info handler.
770	* @param pHlp The output helper functions. If NULL the logger will be used.
771	*/
772	VMMR3DECL(int) DBGFR3Info(PUVM pUVM, const char pszName, const char pszArgs, PCDBGFINFOHLP pHlp)
773	{
774	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
775	return dbgfR3Info(pUVM, VMCPUID_ANY, pszName, pszArgs, pHlp);
776	}
777
778
779	/**
780	* Display a piece of info writing to the supplied handler.
781	*
782	* @returns VBox status code.
783	* @param pUVM The user mode VM handle.
784	* @param idCpu The CPU to exectue the request on. Pass NIL_VMCPUID
785	* to not involve any EMT.
786	* @param pszName The identifier of the info to display.
787	* @param pszArgs Arguments to the info handler.
788	* @param pHlp The output helper functions. If NULL the logger will be used.
789	*/
790	VMMR3DECL(int) DBGFR3InfoEx(PUVM pUVM, VMCPUID idCpu, const char pszName, const char pszArgs, PCDBGFINFOHLP pHlp)
791	{
792	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
793	if (idCpu == NIL_VMCPUID)
794	return dbgfR3Info(pUVM, VMCPUID_ANY, pszName, pszArgs, pHlp);
795	return VMR3ReqPriorityCallWaitU(pUVM, idCpu,
796	(PFNRT)dbgfR3Info, 5, pUVM, idCpu, pszName, pszArgs, pHlp);
797	}
798
799
800	/**
801	* Wrapper for DBGFR3Info that outputs to the release log.
802	*
803	* @returns See DBGFR3Info.
804	* @param pUVM The user mode VM handle.
805	* @param pszName See DBGFR3Info.
806	* @param pszArgs See DBGFR3Info.
807	*/
808	VMMR3DECL(int) DBGFR3InfoLogRel(PUVM pUVM, const char pszName, const char pszArgs)
809	{
810	return DBGFR3Info(pUVM, pszName, pszArgs, &g_dbgfR3InfoLogRelHlp);
811	}
812
813
814	/**
815	* Wrapper for DBGFR3Info that outputs to standard error.
816	*
817	* @returns See DBGFR3Info.
818	* @param pUVM The user mode VM handle.
819	* @param pszName See DBGFR3Info.
820	* @param pszArgs See DBGFR3Info.
821	*/
822	VMMR3DECL(int) DBGFR3InfoStdErr(PUVM pUVM, const char pszName, const char pszArgs)
823	{
824	return DBGFR3Info(pUVM, pszName, pszArgs, &g_dbgfR3InfoStdErrHlp);
825	}
826
827
828	/**
829	* Display several info items.
830	*
831	* This is intended used by the fatal error dump only.
832	*
833	* @returns
834	* @param pVM Pointer to the VM.
835	* @param pszIncludePat Simple string pattern of info items to include.
836	* @param pszExcludePat Simple string pattern of info items to exclude.
837	* @param pszSepFmt Item separator format string. The item name will be
838	* given as parameter.
839	* @param pHlp The output helper functions. If NULL the logger
840	* will be used.
841	*
842	* @threads EMT
843	*/
844	VMMR3_INT_DECL(int) DBGFR3InfoMulti(PVM pVM, const char pszIncludePat, const char pszExcludePat, const char *pszSepFmt,
845	PCDBGFINFOHLP pHlp)
846	{
847	/*
848	* Validate input.
849	*/
850	PUVM pUVM = pVM->pUVM;
851	VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
852	AssertPtrReturn(pszIncludePat, VERR_INVALID_POINTER);
853	AssertPtrReturn(pszExcludePat, VERR_INVALID_POINTER);
854	if (pHlp)
855	{
856	AssertPtrReturn(pHlp->pfnPrintf, VERR_INVALID_POINTER);
857	AssertPtrReturn(pHlp->pfnPrintfV, VERR_INVALID_POINTER);
858	}
859	else
860	pHlp = &g_dbgfR3InfoLogHlp;
861
862	size_t const cchIncludePat = strlen(pszIncludePat);
863	size_t const cchExcludePat = strlen(pszExcludePat);
864	const char *pszArgs = "";
865
866	/*
867	* Enumerate the info handlers and call the ones matching.
868	* Note! We won't leave the critical section here...
869	*/
870	int rc = RTCritSectRwEnterShared(&pUVM->dbgf.s.CritSect);
871	AssertRC(rc);
872	rc = VWRN_NOT_FOUND;
873	for (PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst; pInfo; pInfo = pInfo->pNext)
874	{
875	if ( RTStrSimplePatternMultiMatch(pszIncludePat, cchIncludePat, pInfo->szName, pInfo->cchName, NULL)
876	&& !RTStrSimplePatternMultiMatch(pszExcludePat, cchExcludePat, pInfo->szName, pInfo->cchName, NULL))
877	{
878	pHlp->pfnPrintf(pHlp, pszSepFmt, pInfo->szName);
879	rc = VINF_SUCCESS;
880	switch (pInfo->enmType)
881	{
882	case DBGFINFOTYPE_DEV:
883	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
884	rc = VMR3ReqCallVoidWaitU(pUVM, VMCPUID_ANY, (PFNRT)pInfo->u.Dev.pfnHandler, 3,
885	pInfo->u.Dev.pDevIns, pHlp, pszArgs);
886	else
887	pInfo->u.Dev.pfnHandler(pInfo->u.Dev.pDevIns, pHlp, pszArgs);
888	break;
889
890	case DBGFINFOTYPE_DRV:
891	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
892	rc = VMR3ReqCallVoidWaitU(pUVM, VMCPUID_ANY, (PFNRT)pInfo->u.Drv.pfnHandler, 3,
893	pInfo->u.Drv.pDrvIns, pHlp, pszArgs);
894	else
895	pInfo->u.Drv.pfnHandler(pInfo->u.Drv.pDrvIns, pHlp, pszArgs);
896	break;
897
898	case DBGFINFOTYPE_INT:
899	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
900	rc = VMR3ReqCallVoidWaitU(pUVM, VMCPUID_ANY, (PFNRT)pInfo->u.Int.pfnHandler, 3, pVM, pHlp, pszArgs);
901	else
902	pInfo->u.Int.pfnHandler(pVM, pHlp, pszArgs);
903	break;
904
905	case DBGFINFOTYPE_EXT:
906	if (pInfo->fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
907	rc = VMR3ReqCallVoidWaitU(pUVM, VMCPUID_ANY, (PFNRT)pInfo->u.Ext.pfnHandler, 3,
908	pInfo->u.Ext.pvUser, pHlp, pszArgs);
909	else
910	pInfo->u.Ext.pfnHandler(pInfo->u.Ext.pvUser, pHlp, pszArgs);
911	break;
912
913	default:
914	AssertMsgFailedReturn(("Invalid info type enmType=%d\n", pInfo->enmType), VERR_IPE_NOT_REACHED_DEFAULT_CASE);
915	}
916	}
917	}
918	int rc2 = RTCritSectRwLeaveShared(&pUVM->dbgf.s.CritSect);
919	AssertRC(rc2);
920
921	return rc;
922	}
923
924
925	/**
926	* Enumerate all the register info handlers.
927	*
928	* @returns VBox status code.
929	* @param pUVM The user mode VM handle.
930	* @param pfnCallback Pointer to callback function.
931	* @param pvUser User argument to pass to the callback.
932	*/
933	VMMR3DECL(int) DBGFR3InfoEnum(PUVM pUVM, PFNDBGFINFOENUM pfnCallback, void *pvUser)
934	{
935	LogFlow(("DBGFR3InfoLog: pfnCallback=%p pvUser=%p\n", pfnCallback, pvUser));
936
937	/*
938	* Validate input.
939	*/
940	if (!pfnCallback)
941	{
942	AssertMsgFailed(("!pfnCallback\n"));
943	return VERR_INVALID_PARAMETER;
944	}
945	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
946
947	/*
948	* Enter and enumerate.
949	*/
950	int rc = RTCritSectRwEnterShared(&pUVM->dbgf.s.CritSect);
951	AssertRC(rc);
952
953	rc = VINF_SUCCESS;
954	for (PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst; RT_SUCCESS(rc) && pInfo; pInfo = pInfo->pNext)
955	rc = pfnCallback(pUVM, pInfo->szName, pInfo->pszDesc, pvUser);
956
957	/*
958	* Leave and exit.
959	*/
960	int rc2 = RTCritSectRwLeaveShared(&pUVM->dbgf.s.CritSect);
961	AssertRC(rc2);
962
963	LogFlow(("DBGFR3InfoLog: returns %Rrc\n", rc));
964	return rc;
965	}
966
967
968	/**
969	* Info handler, internal version.
970	*
971	* @param pVM Pointer to the VM.
972	* @param pHlp Callback functions for doing output.
973	* @param pszArgs Argument string. Optional and specific to the handler.
974	*/
975	static DECLCALLBACK(void) dbgfR3InfoHelp(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
976	{
977	LogFlow(("dbgfR3InfoHelp: pszArgs=%s\n", pszArgs));
978
979	/*
980	* Enter and enumerate.
981	*/
982	PUVM pUVM = pVM->pUVM;
983	int rc = RTCritSectRwEnterShared(&pUVM->dbgf.s.CritSect);
984	AssertRC(rc);
985
986	if (pszArgs && *pszArgs)
987	{
988	for (PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst; pInfo; pInfo = pInfo->pNext)
989	{
990	const char *psz = strstr(pszArgs, pInfo->szName);
991	if ( psz
992	&& ( psz == pszArgs
993	\|\| RT_C_IS_SPACE(psz[-1]))
994	&& ( !psz[pInfo->cchName]
995	\|\| RT_C_IS_SPACE(psz[pInfo->cchName])))
996	pHlp->pfnPrintf(pHlp, "%-16s %s\n",
997	pInfo->szName, pInfo->pszDesc);
998	}
999	}
1000	else
1001	{
1002	for (PDBGFINFO pInfo = pUVM->dbgf.s.pInfoFirst; pInfo; pInfo = pInfo->pNext)
1003	pHlp->pfnPrintf(pHlp, "%-16s %s\n",
1004	pInfo->szName, pInfo->pszDesc);
1005	}
1006
1007	/*
1008	* Leave and exit.
1009	*/
1010	rc = RTCritSectRwLeaveShared(&pUVM->dbgf.s.CritSect);
1011	AssertRC(rc);
1012	}
1013

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFInfo.cpp@ 56085

Download in other formats: