DBGFInfo.cpp@ 41494

Last change on this file since 41494 was 39405, checked in by vboxsync, 13 years ago
VMM: Don't use generic IPE status codes, use specific ones. Part 2.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.5 KB

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

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

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

Download in other formats: