DBGFInfo.cpp@ 6457

Last change on this file since 6457 was 5999, checked in by vboxsync, 17 years ago
The Giant CDDL Dual-License Header Change.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 24.8 KB

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

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

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

Download in other formats: