DBGFInfo.cpp@ 12998

Last change on this file since 12998 was 12989, checked in by vboxsync, 16 years ago
VMM + VBox/cdefs.h: consolidated all the XYZDECLS of the VMM into VMMDECL. Removed dead DECL and IN_XYZ* macros.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 25.0 KB

Line
1	/* $Id: DBGFInfo.cpp 12989 2008-10-06 02:15:39Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Info.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_DBGF_INFO
27	#include <VBox/dbgf.h>
28	#include <VBox/mm.h>
29	#include "DBGFInternal.h"
30	#include <VBox/vm.h>
31
32	#include <VBox/log.h>
33	#include <iprt/semaphore.h>
34	#include <iprt/thread.h>
35	#include <iprt/assert.h>
36	#include <iprt/string.h>
37	#include <iprt/ctype.h>
38	#include <VBox/err.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) 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
69	/**
70	* Initialize the info handlers.
71	*
72	* @returns VBox status code.
73	* @param pVM VM handle.
74	*/
75	int dbgfR3InfoInit(PVM pVM)
76	{
77	/*
78	* Make sure we already didn't initialized in the lazy manner.
79	*/
80	if (RTCritSectIsInitialized(&pVM->dbgf.s.InfoCritSect))
81	return VINF_SUCCESS;
82
83	/*
84	* Initialize the crit sect.
85	*/
86	int rc = RTCritSectInit(&pVM->dbgf.s.InfoCritSect);
87	AssertRCReturn(rc, rc);
88
89	/*
90	* Register the 'info help' item.
91	*/
92	rc = DBGFR3InfoRegisterInternal(pVM, "help", "List of info items.", dbgfR3InfoHelp);
93	AssertRCReturn(rc, rc);
94
95	return VINF_SUCCESS;
96	}
97
98
99	/**
100	* Terminate the info handlers.
101	*
102	* @returns VBox status code.
103	* @param pVM VM handle.
104	*/
105	int dbgfR3InfoTerm(PVM pVM)
106	{
107	/*
108	* Delete the crit sect.
109	*/
110	int rc = RTCritSectDelete(&pVM->dbgf.s.InfoCritSect);
111	AssertRC(rc);
112	return rc;
113	}
114
115
116	/** Logger output.
117	* @copydoc DBGFINFOHLP::pfnPrintf */
118	static DECLCALLBACK(void) dbgfR3InfoLog_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
119	{
120	va_list args;
121	va_start(args, pszFormat);
122	RTLogPrintfV(pszFormat, args);
123	va_end(args);
124	}
125
126	/** Logger output.
127	* @copydoc DBGFINFOHLP::pfnPrintfV */
128	static DECLCALLBACK(void) dbgfR3InfoLog_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
129	{
130	RTLogPrintfV(pszFormat, args);
131	}
132
133
134	/**
135	* Gets the logger info helper.
136	* The returned info helper will unconditionally write all output to the log.
137	*
138	* @returns Pointer to the logger info helper.
139	*/
140	VMMR3DECL(PCDBGFINFOHLP) DBGFR3InfoLogHlp(void)
141	{
142	return &g_dbgfR3InfoLogHlp;
143	}
144
145
146	/** Release logger output.
147	* @copydoc DBGFINFOHLP::pfnPrintf */
148	static DECLCALLBACK(void) dbgfR3InfoLogRel_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
149	{
150	va_list args;
151	va_start(args, pszFormat);
152	RTLogRelPrintfV(pszFormat, args);
153	va_end(args);
154	}
155
156	/** Release logger output.
157	* @copydoc DBGFINFOHLP::pfnPrintfV */
158	static DECLCALLBACK(void) dbgfR3InfoLogRel_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
159	{
160	RTLogRelPrintfV(pszFormat, args);
161	}
162
163
164	/**
165	* Gets the release logger info helper.
166	* The returned info helper will unconditionally write all output to the release log.
167	*
168	* @returns Pointer to the release logger info helper.
169	*/
170	VMMR3DECL(PCDBGFINFOHLP) DBGFR3InfoLogRelHlp(void)
171	{
172	return &g_dbgfR3InfoLogRelHlp;
173	}
174
175
176	/**
177	* Handle registration worker.
178	* This allocates the structure, initalizes the common fields and inserts into the list.
179	* Upon successful return the we're inside the crit sect and the caller must leave it.
180	*
181	* @returns VBox status code.
182	* @param pVM VM handle.
183	* @param pszName The identifier of the info.
184	* @param pszDesc The description of the info and any arguments the handler may take.
185	* @param fFlags The flags.
186	* @param ppInfo Where to store the created
187	*/
188	static int dbgfR3InfoRegister(PVM pVM, const char pszName, const char pszDesc, uint32_t fFlags, PDBGFINFO *ppInfo)
189	{
190	/*
191	* Validate.
192	*/
193	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
194	AssertReturn(*pszName, VERR_INVALID_PARAMETER);
195	AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
196	AssertMsgReturn(!(fFlags & ~(DBGFINFO_FLAGS_RUN_ON_EMT)), ("fFlags=%#x\n", fFlags), VERR_INVALID_PARAMETER);
197
198	/*
199	* Allocate and initialize.
200	*/
201	int rc;
202	size_t cchName = strlen(pszName) + 1;
203	PDBGFINFO pInfo = (PDBGFINFO)MMR3HeapAlloc(pVM, MM_TAG_DBGF_INFO, RT_OFFSETOF(DBGFINFO, szName[cchName]));
204	if (pInfo)
205	{
206	pInfo->enmType = DBGFINFOTYPE_INVALID;
207	pInfo->fFlags = fFlags;
208	pInfo->pszDesc = pszDesc;
209	pInfo->cchName = cchName - 1;
210	memcpy(pInfo->szName, pszName, cchName);
211
212	/* lazy init */
213	rc = VINF_SUCCESS;
214	if (!RTCritSectIsInitialized(&pVM->dbgf.s.InfoCritSect))
215	rc = dbgfR3InfoInit(pVM);
216	if (VBOX_SUCCESS(rc))
217	{
218	/*
219	* Insert in alphabetical order.
220	*/
221	rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
222	AssertRC(rc);
223	PDBGFINFO pPrev = NULL;
224	PDBGFINFO pCur;
225	for (pCur = pVM->dbgf.s.pInfoFirst; pCur; pPrev = pCur, pCur = pCur->pNext)
226	if (strcmp(pszName, pCur->szName) < 0)
227	break;
228	pInfo->pNext = pCur;
229	if (pPrev)
230	pPrev->pNext = pInfo;
231	else
232	pVM->dbgf.s.pInfoFirst = pInfo;
233
234	*ppInfo = pInfo;
235	return VINF_SUCCESS;
236	}
237	MMR3HeapFree(pInfo);
238	}
239	else
240	rc = VERR_NO_MEMORY;
241	return rc;
242	}
243
244
245	/**
246	* Register a info handler owned by a device.
247	*
248	* @returns VBox status code.
249	* @param pVM VM handle.
250	* @param pszName The identifier of the info.
251	* @param pszDesc The description of the info and any arguments the handler may take.
252	* @param pfnHandler The handler function to be called to display the info.
253	* @param pDevIns The device instance owning the info.
254	*/
255	VMMR3DECL(int) DBGFR3InfoRegisterDevice(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler, PPDMDEVINS pDevIns)
256	{
257	LogFlow(("DBGFR3InfoRegisterDevice: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p pDevIns=%p\n",
258	pszName, pszName, pszDesc, pszDesc, pfnHandler, pDevIns));
259
260	/*
261	* Validate the specific stuff.
262	*/
263	if (!pfnHandler)
264	{
265	AssertMsgFailed(("No handler\n"));
266	return VERR_INVALID_PARAMETER;
267	}
268	if (!pDevIns)
269	{
270	AssertMsgFailed(("No pDevIns\n"));
271	return VERR_INVALID_PARAMETER;
272	}
273
274	/*
275	* Register
276	*/
277	PDBGFINFO pInfo;
278	int rc = dbgfR3InfoRegister(pVM, pszName, pszDesc, 0, &pInfo);
279	if (VBOX_SUCCESS(rc))
280	{
281	pInfo->enmType = DBGFINFOTYPE_DEV;
282	pInfo->u.Dev.pfnHandler = pfnHandler;
283	pInfo->u.Dev.pDevIns = pDevIns;
284	RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
285	}
286
287	return rc;
288	}
289
290
291	/**
292	* Register a info handler owned by a driver.
293	*
294	* @returns VBox status code.
295	* @param pVM VM handle.
296	* @param pszName The identifier of the info.
297	* @param pszDesc The description of the info and any arguments the handler may take.
298	* @param pfnHandler The handler function to be called to display the info.
299	* @param pDrvIns The driver instance owning the info.
300	*/
301	VMMR3DECL(int) DBGFR3InfoRegisterDriver(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLERDRV pfnHandler, PPDMDRVINS pDrvIns)
302	{
303	LogFlow(("DBGFR3InfoRegisterDriver: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p pDrvIns=%p\n",
304	pszName, pszName, pszDesc, pszDesc, pfnHandler, pDrvIns));
305
306	/*
307	* Validate the specific stuff.
308	*/
309	if (!pfnHandler)
310	{
311	AssertMsgFailed(("No handler\n"));
312	return VERR_INVALID_PARAMETER;
313	}
314	if (!pDrvIns)
315	{
316	AssertMsgFailed(("No pDrvIns\n"));
317	return VERR_INVALID_PARAMETER;
318	}
319
320	/*
321	* Register
322	*/
323	PDBGFINFO pInfo;
324	int rc = dbgfR3InfoRegister(pVM, pszName, pszDesc, 0, &pInfo);
325	if (VBOX_SUCCESS(rc))
326	{
327	pInfo->enmType = DBGFINFOTYPE_DRV;
328	pInfo->u.Drv.pfnHandler = pfnHandler;
329	pInfo->u.Drv.pDrvIns = pDrvIns;
330	RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
331	}
332
333	return rc;
334	}
335
336
337	/**
338	* Register a info handler owned by an internal component.
339	*
340	* @returns VBox status code.
341	* @param pVM VM handle.
342	* @param pszName The identifier of the info.
343	* @param pszDesc The description of the info and any arguments the handler may take.
344	* @param pfnHandler The handler function to be called to display the info.
345	*/
346	VMMR3DECL(int) DBGFR3InfoRegisterInternal(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLERINT pfnHandler)
347	{
348	return DBGFR3InfoRegisterInternalEx(pVM, pszName, pszDesc, pfnHandler, 0);
349	}
350
351
352	/**
353	* Register a info handler owned by an internal component.
354	*
355	* @returns VBox status code.
356	* @param pVM VM handle.
357	* @param pszName The identifier of the info.
358	* @param pszDesc The description of the info and any arguments the handler may take.
359	* @param pfnHandler The handler function to be called to display the info.
360	* @param fFlags Flags, see the DBGFINFO_FLAGS_*.
361	*/
362	VMMR3DECL(int) DBGFR3InfoRegisterInternalEx(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLERINT pfnHandler, uint32_t fFlags)
363	{
364	LogFlow(("DBGFR3InfoRegisterInternal: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p fFlags=%x\n",
365	pszName, pszName, pszDesc, pszDesc, pfnHandler, fFlags));
366
367	/*
368	* Validate the specific stuff.
369	*/
370	if (!pfnHandler)
371	{
372	AssertMsgFailed(("No handler\n"));
373	return VERR_INVALID_PARAMETER;
374	}
375
376	/*
377	* Register
378	*/
379	PDBGFINFO pInfo;
380	int rc = dbgfR3InfoRegister(pVM, pszName, pszDesc, fFlags, &pInfo);
381	if (VBOX_SUCCESS(rc))
382	{
383	pInfo->enmType = DBGFINFOTYPE_INT;
384	pInfo->u.Int.pfnHandler = pfnHandler;
385	RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
386	}
387
388	return rc;
389	}
390
391
392	/**
393	* Register a info handler owned by an external component.
394	*
395	* @returns VBox status code.
396	* @param pVM VM handle.
397	* @param pszName The identifier of the info.
398	* @param pszDesc The description of the info and any arguments the handler may take.
399	* @param pfnHandler The handler function to be called to display the info.
400	* @param pvUser User argument to be passed to the handler.
401	*/
402	VMMR3DECL(int) DBGFR3InfoRegisterExternal(PVM pVM, const char pszName, const char pszDesc, PFNDBGFHANDLEREXT pfnHandler, void *pvUser)
403	{
404	LogFlow(("DBGFR3InfoRegisterExternal: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p pvUser=%p\n",
405	pszName, pszName, pszDesc, pszDesc, pfnHandler, pvUser));
406
407	/*
408	* Validate the specific stuff.
409	*/
410	if (!pfnHandler)
411	{
412	AssertMsgFailed(("No handler\n"));
413	return VERR_INVALID_PARAMETER;
414	}
415
416	/*
417	* Register
418	*/
419	PDBGFINFO pInfo;
420	int rc = dbgfR3InfoRegister(pVM, pszName, pszDesc, 0, &pInfo);
421	if (VBOX_SUCCESS(rc))
422	{
423	pInfo->enmType = DBGFINFOTYPE_EXT;
424	pInfo->u.Ext.pfnHandler = pfnHandler;
425	pInfo->u.Ext.pvUser = pvUser;
426	RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
427	}
428
429	return rc;
430	}
431
432
433	/**
434	* Deregister one(/all) info handler(s) owned by a device.
435	*
436	* @returns VBox status code.
437	* @param pVM VM Handle.
438	* @param pDevIns Device instance.
439	* @param pszName The identifier of the info. If NULL all owned by the device.
440	*/
441	VMMR3DECL(int) DBGFR3InfoDeregisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName)
442	{
443	LogFlow(("DBGFR3InfoDeregisterDevice: pDevIns=%p pszName=%p:{%s}\n", pDevIns, pszName, pszName));
444
445	/*
446	* Validate input.
447	*/
448	if (!pDevIns)
449	{
450	AssertMsgFailed(("!pDevIns\n"));
451	return VERR_INVALID_PARAMETER;
452	}
453	size_t cchName = pszName ? strlen(pszName) : 0;
454
455	/*
456	* Enumerate the info handlers and free the requested entries.
457	*/
458	int rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
459	AssertRC(rc);
460	rc = VERR_FILE_NOT_FOUND;
461	PDBGFINFO pPrev = NULL;
462	PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst;
463	if (pszName)
464	{
465	/*
466	* Free a specific one.
467	*/
468	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
469	if ( pInfo->enmType == DBGFINFOTYPE_DEV
470	&& pInfo->u.Dev.pDevIns == pDevIns
471	&& pInfo->cchName == cchName
472	&& !strcmp(pInfo->szName, pszName))
473	{
474	if (pPrev)
475	pPrev->pNext = pInfo->pNext;
476	else
477	pVM->dbgf.s.pInfoFirst = pInfo->pNext;
478	MMR3HeapFree(pInfo);
479	rc = VINF_SUCCESS;
480	break;
481	}
482	}
483	else
484	{
485	/*
486	* Free all owned by the driver.
487	*/
488	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
489	if ( pInfo->enmType == DBGFINFOTYPE_DEV
490	&& pInfo->u.Dev.pDevIns == pDevIns)
491	{
492	if (pPrev)
493	pPrev->pNext = pInfo->pNext;
494	else
495	pVM->dbgf.s.pInfoFirst = pInfo->pNext;
496	MMR3HeapFree(pInfo);
497	pInfo = pPrev;
498	}
499	rc = VINF_SUCCESS;
500	}
501	int rc2 = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
502	AssertRC(rc2);
503	AssertRC(rc);
504	LogFlow(("DBGFR3InfoDeregisterDevice: returns %Vrc\n", rc));
505	return rc;
506	}
507
508	/**
509	* Deregister one(/all) info handler(s) owned by a driver.
510	*
511	* @returns VBox status code.
512	* @param pVM VM Handle.
513	* @param pDrvIns Driver instance.
514	* @param pszName The identifier of the info. If NULL all owned by the driver.
515	*/
516	VMMR3DECL(int) DBGFR3InfoDeregisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName)
517	{
518	LogFlow(("DBGFR3InfoDeregisterDriver: pDrvIns=%p pszName=%p:{%s}\n", pDrvIns, pszName, pszName));
519
520	/*
521	* Validate input.
522	*/
523	if (!pDrvIns)
524	{
525	AssertMsgFailed(("!pDrvIns\n"));
526	return VERR_INVALID_PARAMETER;
527	}
528	size_t cchName = pszName ? strlen(pszName) : 0;
529
530	/*
531	* Enumerate the info handlers and free the requested entries.
532	*/
533	int rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
534	AssertRC(rc);
535	rc = VERR_FILE_NOT_FOUND;
536	PDBGFINFO pPrev = NULL;
537	PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst;
538	if (pszName)
539	{
540	/*
541	* Free a specific one.
542	*/
543	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
544	if ( pInfo->enmType == DBGFINFOTYPE_DRV
545	&& pInfo->u.Drv.pDrvIns == pDrvIns
546	&& pInfo->cchName == cchName
547	&& !strcmp(pInfo->szName, pszName))
548	{
549	if (pPrev)
550	pPrev->pNext = pInfo->pNext;
551	else
552	pVM->dbgf.s.pInfoFirst = pInfo->pNext;
553	MMR3HeapFree(pInfo);
554	rc = VINF_SUCCESS;
555	break;
556	}
557	}
558	else
559	{
560	/*
561	* Free all owned by the driver.
562	*/
563	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
564	if ( pInfo->enmType == DBGFINFOTYPE_DRV
565	&& pInfo->u.Drv.pDrvIns == pDrvIns)
566	{
567	if (pPrev)
568	pPrev->pNext = pInfo->pNext;
569	else
570	pVM->dbgf.s.pInfoFirst = pInfo->pNext;
571	MMR3HeapFree(pInfo);
572	pInfo = pPrev;
573	}
574	rc = VINF_SUCCESS;
575	}
576	int rc2 = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
577	AssertRC(rc2);
578	AssertRC(rc);
579	LogFlow(("DBGFR3InfoDeregisterDriver: returns %Vrc\n", rc));
580	return rc;
581	}
582
583
584	/**
585	* Internal deregistration helper.
586	*
587	* @returns VBox status code.
588	* @param pVM VM Handle.
589	* @param pszName The identifier of the info.
590	* @param enmType The info owner type.
591	*/
592	static int dbgfR3InfoDeregister(PVM pVM, const char *pszName, DBGFINFOTYPE enmType)
593	{
594	/*
595	* Validate input.
596	*/
597	if (!pszName)
598	{
599	AssertMsgFailed(("!pszName\n"));
600	return VERR_INVALID_PARAMETER;
601	}
602
603	/*
604	* Find the info handler.
605	*/
606	size_t cchName = strlen(pszName);
607	int rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
608	AssertRC(rc);
609	rc = VERR_FILE_NOT_FOUND;
610	PDBGFINFO pPrev = NULL;
611	PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst;
612	for (; pInfo; pPrev = pInfo, pInfo = pInfo->pNext)
613	if ( pInfo->cchName == cchName
614	&& !strcmp(pInfo->szName, pszName)
615	&& pInfo->enmType == enmType)
616	{
617	if (pPrev)
618	pPrev->pNext = pInfo->pNext;
619	else
620	pVM->dbgf.s.pInfoFirst = pInfo->pNext;
621	MMR3HeapFree(pInfo);
622	rc = VINF_SUCCESS;
623	break;
624	}
625	int rc2 = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
626	AssertRC(rc2);
627	AssertRC(rc);
628	LogFlow(("dbgfR3InfoDeregister: returns %Vrc\n", rc));
629	return rc;
630	}
631
632
633	/**
634	* Deregister a info handler owned by an internal component.
635	*
636	* @returns VBox status code.
637	* @param pVM VM Handle.
638	* @param pszName The identifier of the info. If NULL all owned by the device.
639	*/
640	VMMR3DECL(int) DBGFR3InfoDeregisterInternal(PVM pVM, const char *pszName)
641	{
642	LogFlow(("DBGFR3InfoDeregisterInternal: pszName=%p:{%s}\n", pszName, pszName));
643	return dbgfR3InfoDeregister(pVM, pszName, DBGFINFOTYPE_INT);
644	}
645
646
647	/**
648	* Deregister a info handler owned by an external component.
649	*
650	* @returns VBox status code.
651	* @param pVM VM Handle.
652	* @param pszName The identifier of the info. If NULL all owned by the device.
653	*/
654	VMMR3DECL(int) DBGFR3InfoDeregisterExternal(PVM pVM, const char *pszName)
655	{
656	LogFlow(("DBGFR3InfoDeregisterExternal: pszName=%p:{%s}\n", pszName, pszName));
657	return dbgfR3InfoDeregister(pVM, pszName, DBGFINFOTYPE_EXT);
658	}
659
660
661	/**
662	* Display a piece of info writing to the supplied handler.
663	*
664	* @returns VBox status code.
665	* @param pVM VM handle.
666	* @param pszName The identifier of the info to display.
667	* @param pszArgs Arguments to the info handler.
668	* @param pHlp The output helper functions. If NULL the logger will be used.
669	*/
670	VMMR3DECL(int) DBGFR3Info(PVM pVM, const char pszName, const char pszArgs, PCDBGFINFOHLP pHlp)
671	{
672	/*
673	* Validate input.
674	*/
675	if (!pszName)
676	{
677	AssertMsgFailed(("!pszName\n"));
678	return VERR_INVALID_PARAMETER;
679	}
680	if (pHlp)
681	{
682	if ( !pHlp->pfnPrintf
683	\|\| !pHlp->pfnPrintfV)
684	{
685	AssertMsgFailed(("A pHlp member is missing!\n"));
686	return VERR_INVALID_PARAMETER;
687	}
688	}
689	else
690	pHlp = &g_dbgfR3InfoLogHlp;
691
692	/*
693	* Find the info handler.
694	*/
695	size_t cchName = strlen(pszName);
696	int rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
697	AssertRC(rc);
698	PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst;
699	for (; pInfo; pInfo = pInfo->pNext)
700	if ( pInfo->cchName == cchName
701	&& !memcmp(pInfo->szName, pszName, cchName))
702	break;
703	if (pInfo)
704	{
705	/*
706	* Found it.
707	* Make a copy of it on the stack so we can leave the crit sect.
708	* Switch on the type and invoke the handler.
709	*/
710	DBGFINFO Info = *pInfo;
711	rc = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
712	AssertRC(rc);
713	rc = VINF_SUCCESS;
714	PVMREQ pReq = NULL;
715	switch (Info.enmType)
716	{
717	case DBGFINFOTYPE_DEV:
718	if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
719	rc = VMR3ReqCallVoid(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Dev.pfnHandler, 3, Info.u.Dev.pDevIns, pHlp, pszArgs);
720	else
721	Info.u.Dev.pfnHandler(Info.u.Dev.pDevIns, pHlp, pszArgs);
722	break;
723
724	case DBGFINFOTYPE_DRV:
725	if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
726	rc = VMR3ReqCallVoid(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Drv.pfnHandler, 3, Info.u.Drv.pDrvIns, pHlp, pszArgs);
727	else
728	Info.u.Drv.pfnHandler(Info.u.Drv.pDrvIns, pHlp, pszArgs);
729	break;
730
731	case DBGFINFOTYPE_INT:
732	if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
733	rc = VMR3ReqCallVoid(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Int.pfnHandler, 3, pVM, pHlp, pszArgs);
734	else
735	Info.u.Int.pfnHandler(pVM, pHlp, pszArgs);
736	break;
737
738	case DBGFINFOTYPE_EXT:
739	if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT)
740	rc = VMR3ReqCallVoid(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Ext.pfnHandler, 3, Info.u.Ext.pvUser, pHlp, pszArgs);
741	else
742	Info.u.Ext.pfnHandler(Info.u.Ext.pvUser, pHlp, pszArgs);
743	break;
744
745	default:
746	AssertMsgFailed(("Invalid info type enmType=%d\n", Info.enmType));
747	rc = VERR_INTERNAL_ERROR;
748	break;
749	}
750	VMR3ReqFree(pReq);
751	}
752	else
753	{
754	rc = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
755	AssertRC(rc);
756	rc = VERR_FILE_NOT_FOUND;
757	}
758	return rc;
759	}
760
761
762	/**
763	* Enumerate all the register info handlers.
764	*
765	* @returns VBox status code.
766	* @param pVM VM handle.
767	* @param pfnCallback Pointer to callback function.
768	* @param pvUser User argument to pass to the callback.
769	*/
770	VMMR3DECL(int) DBGFR3InfoEnum(PVM pVM, PFNDBGFINFOENUM pfnCallback, void *pvUser)
771	{
772	LogFlow(("DBGFR3InfoLog: pfnCallback=%p pvUser=%p\n", pfnCallback, pvUser));
773
774	/*
775	* Validate input.
776	*/
777	if (!pfnCallback)
778	{
779	AssertMsgFailed(("!pfnCallback\n"));
780	return VERR_INVALID_PARAMETER;
781	}
782
783	/*
784	* Enter and enumerate.
785	*/
786	int rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
787	AssertRC(rc);
788
789	rc = VINF_SUCCESS;
790	for (PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst; VBOX_SUCCESS(rc) && pInfo; pInfo = pInfo->pNext)
791	rc = pfnCallback(pVM, pInfo->szName, pInfo->pszDesc, pvUser);
792
793	/*
794	* Leave and exit.
795	*/
796	int rc2 = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
797	AssertRC(rc2);
798
799	LogFlow(("DBGFR3InfoLog: returns %Vrc\n", rc));
800	return rc;
801	}
802
803
804	/**
805	* Info handler, internal version.
806	*
807	* @param pVM The VM handle.
808	* @param pHlp Callback functions for doing output.
809	* @param pszArgs Argument string. Optional and specific to the handler.
810	*/
811	static DECLCALLBACK(void) dbgfR3InfoHelp(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
812	{
813	LogFlow(("dbgfR3InfoHelp: pszArgs=%s\n", pszArgs));
814
815	/*
816	* Enter and enumerate.
817	*/
818	int rc = RTCritSectEnter(&pVM->dbgf.s.InfoCritSect);
819	AssertRC(rc);
820
821	if (pszArgs && *pszArgs)
822	{
823	for (PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst; pInfo; pInfo = pInfo->pNext)
824	{
825	const char *psz = strstr(pszArgs, pInfo->szName);
826	if ( psz
827	&& ( psz == pszArgs
828	\|\| isspace(psz[-1]))
829	&& ( !psz[pInfo->cchName]
830	\|\| isspace(psz[pInfo->cchName])))
831	pHlp->pfnPrintf(pHlp, "%-16s %s\n",
832	pInfo->szName, pInfo->pszDesc);
833	}
834	}
835	else
836	{
837	for (PDBGFINFO pInfo = pVM->dbgf.s.pInfoFirst; pInfo; pInfo = pInfo->pNext)
838	pHlp->pfnPrintf(pHlp, "%-16s %s\n",
839	pInfo->szName, pInfo->pszDesc);
840	}
841
842	/*
843	* Leave and exit.
844	*/
845	rc = RTCritSectLeave(&pVM->dbgf.s.InfoCritSect);
846	AssertRC(rc);
847	}
848

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

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

Download in other formats: