DBGCIo.cpp@ 99553

Last change on this file since 99553 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.0 KB

Line
1	/* $Id: DBGCIo.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console, I/O provider handling.
4	*/
5
6	/*
7	* Copyright (C) 2020-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/dbg.h>
33	#include <VBox/vmm/cfgm.h>
34	#include <VBox/err.h>
35
36	#include <iprt/mem.h>
37	#include <iprt/thread.h>
38	#include <VBox/log.h>
39	#include <iprt/assert.h>
40
41	#include <iprt/string.h>
42
43	#include "DBGCIoProvInternal.h"
44	#include "DBGCInternal.h"
45
46
47	/*********************************************************************************************************************************
48	* Structures and Typedefs *
49	*********************************************************************************************************************************/
50
51	/**
52	* Stub descriptor.
53	*/
54	typedef struct DBGCSTUB
55	{
56	/** Name of the stub. */
57	const char *pszName;
58	/** Flag whether this is an ASCII based protocol which requires some newline handling. */
59	bool fAscii;
60	/**
61	* The runloop callback.
62	*
63	* @returns VBox status code.
64	* @param pUVM The user mode VM handle.
65	* @param pIo Pointer to the I/O callback table.
66	* @param fFlags Flags for the runloop, MBZ for now.
67	*/
68	DECLCALLBACKMEMBER(int, pfnRunloop, (PUVM pUVM, PCDBGCIO pIo, unsigned fFlags));
69	} DBGCSTUB;
70	/** Pointer to a stub descriptor. */
71	typedef DBGCSTUB *PDBGCSTUB;
72	/** Pointer to a const stub descriptor. */
73	typedef const DBGCSTUB *PCDBGCSTUB;
74
75
76	/** Pointer to the instance data of the debug console I/O. */
77	typedef struct DBGCIOINT *PDBGCIOINT;
78
79
80	/**
81	* A single debug console I/O service.
82	*/
83	typedef struct DBGCIOSVC
84	{
85	/** Pointer to the owning structure. */
86	PDBGCIOINT pDbgcIo;
87	/** The user mode VM handle this service belongs to. */
88	PUVM pUVM;
89	/** The I/O provider registration record for this service. */
90	PCDBGCIOPROVREG pIoProvReg;
91	/** The I/O provider instance. */
92	DBGCIOPROV hDbgcIoProv;
93	/** The stub type. */
94	PCDBGCSTUB pStub;
95	/** The thread managing the service. */
96	RTTHREAD hThreadSvc;
97	/** Pointer to the I/O callback table currently being served. */
98	PCDBGCIO pIo;
99	/** The wrapping DBGC I/O callback table for ASCII based protocols. */
100	DBGCIO IoAscii;
101	} DBGCIOSVC;
102	/** Pointer to a single debug console I/O service. */
103	typedef DBGCIOSVC *PDBGCIOSVC;
104	/** Poitner to a const single debug console I/O service. */
105	typedef const DBGCIOSVC *PCDBGCIOSVC;
106
107
108	/**
109	* Debug console I/O instance data.
110	*/
111	typedef struct DBGCIOINT
112	{
113	/** Number of configured I/O service instances. */
114	volatile uint32_t cSvcsCfg;
115	/** Number of running I/O service instances. */
116	volatile uint32_t cSvcsRunning;
117	/** Flag whether the services were asked to shut down. */
118	volatile bool fShutdown;
119	/** Array of active I/O service instances. */
120	RT_FLEXIBLE_ARRAY_EXTENSION
121	DBGCIOSVC aSvc[RT_FLEXIBLE_ARRAY];
122	} DBGCIOINT;
123
124
125	/*********************************************************************************************************************************
126	* Global Variables *
127	*********************************************************************************************************************************/
128
129	/**
130	* Array of supported I/O providers.
131	*/
132	static PCDBGCIOPROVREG g_aIoProv[] =
133	{
134	&g_DbgcIoProvTcp,
135	&g_DbgcIoProvUdp,
136	&g_DbgcIoProvIpc
137	};
138
139
140	static DECLCALLBACK(int) dbgcIoNativeStubRunloop(PUVM pUVM, PCDBGCIO pIo, unsigned fFlags);
141
142	/**
143	* Array of supported stubs.
144	*/
145	static const DBGCSTUB g_aStubs[] =
146	{
147	/** pszName fAscii pfnRunloop */
148	{ "Native", true, dbgcIoNativeStubRunloop },
149	{ "Gdb", false, dbgcGdbStubRunloop },
150	{ "Kd", false, dbgcKdStubRunloop }
151	};
152
153
154	/*********************************************************************************************************************************
155	* Internal Functions *
156	*********************************************************************************************************************************/
157
158
159	/**
160	* Destroys all allocated data for the given dbeugger console I/O instance.
161	*
162	* @returns nothing.
163	* @param pDbgcIo Pointer to the dbeugger console I/O instance data.
164	*/
165	static void dbgcIoDestroy(PDBGCIOINT pDbgcIo)
166	{
167	for (uint32_t i = 0; i < pDbgcIo->cSvcsCfg; i++)
168	{
169	PDBGCIOSVC pIoSvc = &pDbgcIo->aSvc[i];
170
171	if (pIoSvc->hThreadSvc != NIL_RTTHREAD)
172	{
173	int rc = RTThreadWait(pIoSvc->hThreadSvc, RT_MS_10SEC, NULL /prc/);
174	AssertRC(rc);
175
176	pIoSvc->hThreadSvc = NIL_RTTHREAD;
177	pIoSvc->pIoProvReg->pfnDestroy(pIoSvc->hDbgcIoProv);
178	}
179	}
180
181	RTMemFree(pDbgcIo);
182	}
183
184
185	/**
186	* Returns the number of I/O services configured.
187	*
188	* @returns I/O service count.
189	* @param pCfgRoot The root of the config.
190	*/
191	static uint32_t dbgcIoGetSvcCount(PCFGMNODE pCfgRoot)
192	{
193	uint32_t cSvcs = 0;
194	PCFGMNODE pNd = CFGMR3GetFirstChild(pCfgRoot);
195	while (pNd)
196	{
197	cSvcs++;
198	pNd = CFGMR3GetNextChild(pNd);
199	}
200
201	return cSvcs;
202	}
203
204
205	/**
206	* Returns a pointer to the I/O provider registration record matching the given name.
207	*
208	* @returns Pointer to the registration record or NULL if not found.
209	* @param pszName The name to look for (case insensitive matching).
210	*/
211	static PCDBGCIOPROVREG dbgcIoProvFindRegByName(const char *pszName)
212	{
213	for (uint32_t i = 0; i < RT_ELEMENTS(g_aIoProv); i++)
214	{
215	if (!RTStrICmp(g_aIoProv[i]->pszName, pszName))
216	return g_aIoProv[i];
217	}
218	return NULL;
219	}
220
221
222	/**
223	* Returns a pointer to the stub record matching the given name.
224	*
225	* @returns Pointer to the stub record or NULL if not found.
226	* @param pszName The name to look for (case insensitive matching).
227	*/
228	static PCDBGCSTUB dbgcIoFindStubByName(const char *pszName)
229	{
230	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStubs); i++)
231	{
232	if (!RTStrICmp(g_aStubs[i].pszName, pszName))
233	return &g_aStubs[i];
234	}
235	return NULL;
236	}
237
238
239	/**
240	* Wrapper around DBGCCreate() to get it working as a callback.
241	*/
242	static DECLCALLBACK(int) dbgcIoNativeStubRunloop(PUVM pUVM, PCDBGCIO pIo, unsigned fFlags)
243	{
244	return DBGCCreate(pUVM, pIo, fFlags);
245	}
246
247
248	/**
249	* @interface_method_impl{DBGCIO,pfnDestroy}
250	*/
251	static DECLCALLBACK(void) dbgcIoAsciiDestroy(PCDBGCIO pIo)
252	{
253	PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
254	pIoSvc->pIo->pfnDestroy(pIoSvc->pIo);
255	}
256
257
258	/**
259	* @interface_method_impl{DBGCIO,pfnInput}
260	*/
261	static DECLCALLBACK(bool) dbgcIoAsciiInput(PCDBGCIO pIo, uint32_t cMillies)
262	{
263	PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
264	return pIoSvc->pIo->pfnInput(pIoSvc->pIo, cMillies);
265	}
266
267
268	/**
269	* @interface_method_impl{DBGCIO,pfnRead}
270	*/
271	static DECLCALLBACK(int) dbgcIoAsciiRead(PCDBGCIO pIo, void pvBuf, size_t cbBuf, size_t pcbRead)
272	{
273	PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
274	return pIoSvc->pIo->pfnRead(pIoSvc->pIo, pvBuf, cbBuf, pcbRead);
275	}
276
277
278	/**
279	* @interface_method_impl{DBGCIO,pfnWrite}
280	*/
281	static DECLCALLBACK(int) dbgcIoAsciiWrite(PCDBGCIO pIo, const void pvBuf, size_t cbBuf, size_t pcbWritten)
282	{
283	PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
284
285	/*
286	* convert '\n' to '\r\n' while writing.
287	*/
288	int rc = 0;
289	size_t cbLeft = cbBuf;
290	while (cbLeft)
291	{
292	size_t cb = cbLeft;
293	/* write newlines */
294	if ((const char )pvBuf == '\n')
295	{
296	rc = pIoSvc->pIo->pfnWrite(pIoSvc->pIo, "\r\n", 2, NULL);
297	cb = 1;
298	}
299	/* write till next newline */
300	else
301	{
302	const char pszNL = (const char )memchr(pvBuf, '\n', cbLeft);
303	if (pszNL)
304	cb = (uintptr_t)pszNL - (uintptr_t)pvBuf;
305	rc = pIoSvc->pIo->pfnWrite(pIoSvc->pIo, pvBuf, cb, NULL);
306	}
307	if (RT_FAILURE(rc))
308	break;
309
310	/* advance */
311	cbLeft -= cb;
312	pvBuf = (const char *)pvBuf + cb;
313	}
314
315	/*
316	* Set returned value and return.
317	*/
318	if (pcbWritten)
319	*pcbWritten = cbBuf - cbLeft;
320	return rc;
321	}
322
323
324	/**
325	* @interface_method_impl{DBGCIO,pfnSetReady}
326	*/
327	static DECLCALLBACK(void) dbgcIoAsciiSetReady(PCDBGCIO pIo, bool fReady)
328	{
329	PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
330	return pIoSvc->pIo->pfnSetReady(pIoSvc->pIo, fReady);
331	}
332
333
334	/**
335	* The I/O thread handling the service.
336	*/
337	static DECLCALLBACK(int) dbgcIoSvcThread(RTTHREAD hThreadSelf, void *pvUser)
338	{
339	RT_NOREF(hThreadSelf);
340
341	int rc = VINF_SUCCESS;
342	PDBGCIOSVC pIoSvc = (PDBGCIOSVC)pvUser;
343	PDBGCIOINT pDbgcIo = pIoSvc->pDbgcIo;
344	PCDBGCIOPROVREG pIoProvReg = pIoSvc->pIoProvReg;
345
346	while (!ASMAtomicReadBool(&pDbgcIo->fShutdown))
347	{
348	/* Wait until someone connects. */
349	rc = pIoProvReg->pfnWaitForConnect(pIoSvc->hDbgcIoProv, RT_INDEFINITE_WAIT, &pIoSvc->pIo);
350	if (RT_SUCCESS(rc))
351	{
352	PCDBGCIO pIo = pIoSvc->pIo;
353
354	if (pIoSvc->pStub->fAscii)
355	{
356	pIoSvc->IoAscii.pfnDestroy = dbgcIoAsciiDestroy;
357	pIoSvc->IoAscii.pfnInput = dbgcIoAsciiInput;
358	pIoSvc->IoAscii.pfnRead = dbgcIoAsciiRead;
359	pIoSvc->IoAscii.pfnWrite = dbgcIoAsciiWrite;
360	pIoSvc->IoAscii.pfnSetReady = dbgcIoAsciiSetReady;
361	pIo = &pIoSvc->IoAscii;
362	}
363
364	/* call the runloop for the connection. */
365	pIoSvc->pStub->pfnRunloop(pIoSvc->pUVM, pIo, 0 /fFlags/);
366
367	pIo->pfnDestroy(pIo);
368	}
369	else if ( rc != VERR_TIMEOUT
370	&& rc != VERR_INTERRUPTED)
371	break;
372	}
373
374	if (!ASMAtomicDecU32(&pDbgcIo->cSvcsRunning))
375	dbgcIoDestroy(pDbgcIo);
376
377	return rc;
378	}
379
380
381	static int dbgcIoSvcInitWorker(PUVM pUVM, PDBGCIOSVC pIoSvc, PCDBGCIOPROVREG pIoProvReg,
382	PCDBGCSTUB pStub, PCFGMNODE pCfg, const char *pszName,
383	bool fIgnoreNetAddrInUse)
384	{
385	pIoSvc->pUVM = pUVM;
386	pIoSvc->pIoProvReg = pIoProvReg;
387	pIoSvc->pStub = pStub;
388
389	/* Create the provider instance and spawn the dedicated thread handling that service. */
390	int rc = pIoProvReg->pfnCreate(&pIoSvc->hDbgcIoProv, pCfg);
391	if (RT_SUCCESS(rc))
392	{
393	rc = RTThreadCreateF(&pIoSvc->hThreadSvc, dbgcIoSvcThread, pIoSvc, 0 /cbStack/,
394	RTTHREADTYPE_DEBUGGER, RTTHREADFLAGS_WAITABLE, "DbgcThrd-%s", pszName);
395	if (RT_SUCCESS(rc))
396	{
397	ASMAtomicIncU32(&pIoSvc->pDbgcIo->cSvcsRunning);
398	return VINF_SUCCESS;
399	}
400	else
401	rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
402	"Configuration error: Creating an instance of the service \"%s\" failed",
403	pszName);
404
405	pIoProvReg->pfnDestroy(pIoSvc->hDbgcIoProv);
406	}
407	else if ( rc != VERR_NET_ADDRESS_IN_USE
408	\|\| !fIgnoreNetAddrInUse)
409	rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
410	"Configuration error: Creating an instance of the I/O provider \"%s\" failed",
411	pIoProvReg->pszName);
412
413	return rc;
414	}
415
416
417	/**
418	* Tries to initialize the given I/O service from the given config.
419	*
420	* @returns VBox status code.
421	* @param pUVM The user mode VM handle.
422	* @param pIoSvc The I/O service instance to initialize.
423	* @param pCfg The config for the instance.
424	*/
425	static int dbgcIoSvcInit(PUVM pUVM, PDBGCIOSVC pIoSvc, PCFGMNODE pCfg)
426	{
427	char szName[32 + 1]; RT_ZERO(szName);
428	int rc = CFGMR3GetName(pCfg, &szName[0], sizeof(szName));
429	if (RT_SUCCESS(rc))
430	{
431	char szIoProvName[32 + 1]; RT_ZERO(szIoProvName);
432	rc = CFGMR3QueryString(pCfg, "Provider", &szIoProvName[0], sizeof(szIoProvName));
433	if (RT_SUCCESS(rc))
434	{
435	char szStub[32 + 1]; RT_ZERO(szStub);
436	rc = CFGMR3QueryString(pCfg, "StubType", &szStub[0], sizeof(szStub));
437	if (RT_SUCCESS(rc))
438	{
439	PCDBGCIOPROVREG pIoProvReg = dbgcIoProvFindRegByName(szIoProvName);
440	if (pIoProvReg)
441	{
442	PCDBGCSTUB pStub = dbgcIoFindStubByName(szStub);
443	if (pStub)
444	rc = dbgcIoSvcInitWorker(pUVM, pIoSvc, pIoProvReg, pStub, pCfg, szName,
445	false /fIgnoreNetAddrInUse/);
446	else
447	rc = VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS, "Configuration error: The stub type \"%s\" could not be found",
448	szStub);
449	}
450	else
451	rc = VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS, "Configuration error: The provider \"%s\" could not be found",
452	szIoProvName);
453	}
454	else
455	rc = VM_SET_ERROR_U(pUVM, rc, "Configuration error: Querying \"StubType\" failed");
456	}
457	else
458	rc = VM_SET_ERROR_U(pUVM, rc, "Configuration error: Querying \"Provider\" failed");
459	}
460	else
461	rc = VM_SET_ERROR_U(pUVM, rc, "Configuration error: Querying service identifier failed (maybe too long)");
462
463	return rc;
464	}
465
466
467	/**
468	* Creates the DBGC I/O services from the legacy TCP config.
469	*
470	* @returns VBox status code.
471	* @param pUVM The user mode VM handle.
472	* @param pKey The config key.
473	* @param ppvData Where to store the I/o instance data on success.
474	*/
475	static int dbgcIoCreateLegacyTcp(PUVM pUVM, PCFGMNODE pKey, void **ppvData)
476	{
477	bool fEnabled;
478	int rc = CFGMR3QueryBoolDef(pKey, "Enabled", &fEnabled,
479	#if defined(VBOX_WITH_DEBUGGER) && defined(VBOX_WITH_DEBUGGER_TCP_BY_DEFAULT)
480	true
481	#else
482	false
483	#endif
484	);
485	if (RT_FAILURE(rc))
486	return VM_SET_ERROR_U(pUVM, rc, "Configuration error: Failed querying \"DBGC/Enabled\"");
487
488	if (!fEnabled)
489	{
490	LogFlow(("DBGCTcpCreate: returns VINF_SUCCESS (Disabled)\n"));
491	return VINF_SUCCESS;
492	}
493
494	PDBGCIOINT pDbgcIo = (PDBGCIOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(DBGCIOINT, aSvc[1]));
495	if (RT_LIKELY(pDbgcIo))
496	{
497	pDbgcIo->aSvc[0].pDbgcIo = pDbgcIo;
498	pDbgcIo->cSvcsCfg = 1;
499	pDbgcIo->cSvcsRunning = 1;
500	rc = dbgcIoSvcInitWorker(pUVM, &pDbgcIo->aSvc[0], &g_DbgcIoProvTcp, &g_aStubs[0], pKey, "TCP",
501	true /fIgnoreNetAddrInUse/);
502	if (RT_SUCCESS(rc))
503	{
504	*ppvData = pDbgcIo;
505	return VINF_SUCCESS;
506	}
507
508	RTMemFree(pDbgcIo);
509	if (rc == VERR_NET_ADDRESS_IN_USE)
510	rc = VINF_SUCCESS;
511	}
512	else
513	rc = VERR_NO_MEMORY;
514
515	if (RT_FAILURE(rc))
516	rc = VM_SET_ERROR_U(pUVM, rc, "Cannot start TCP-based debugging console service");
517	return rc;
518	}
519
520
521	/**
522	* Sets up debugger I/O based on the VM config.
523	*
524	* @returns VBox status code.
525	* @param pUVM The user mode VM handle.
526	* @param ppvData Where to store a pointer to the instance data.
527	*/
528	DBGDECL(int) DBGCIoCreate(PUVM pUVM, void **ppvData)
529	{
530	/*
531	* Check what the configuration says.
532	*/
533	PCFGMNODE pKey = CFGMR3GetChild(CFGMR3GetRootU(pUVM), "DBGC");
534	uint32_t cSvcs = dbgcIoGetSvcCount(pKey);
535	int rc = VINF_SUCCESS;
536
537	/* If no services are configured try the legacy config supporting TCP only. */
538	if (cSvcs)
539	{
540	PDBGCIOINT pDbgcIo = (PDBGCIOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(DBGCIOINT, aSvc[cSvcs]));
541	if (RT_LIKELY(pDbgcIo))
542	{
543	pDbgcIo->cSvcsCfg = 0;
544	pDbgcIo->cSvcsRunning = 1;
545	pDbgcIo->fShutdown = false;
546
547	for (uint32_t i = 0; i < cSvcs; i++)
548	pDbgcIo->aSvc[i].hThreadSvc = NIL_RTTHREAD;
549
550	PCFGMNODE pSvcCfg = CFGMR3GetFirstChild(pKey);
551	for (uint32_t i = 0; i < cSvcs && RT_SUCCESS(rc); i++)
552	{
553	pDbgcIo->aSvc[i].pDbgcIo = pDbgcIo;
554
555	rc = dbgcIoSvcInit(pUVM, &pDbgcIo->aSvc[i], pSvcCfg);
556	if (RT_SUCCESS(rc))
557	pDbgcIo->cSvcsCfg++;
558	else
559	rc = VM_SET_ERROR_U(pUVM, rc, "Failed to initialize the debugger I/O service");
560
561	pSvcCfg = CFGMR3GetNextChild(pSvcCfg);
562	}
563
564	if (RT_SUCCESS(rc))
565	*ppvData = pDbgcIo;
566	else
567	{
568	if (!ASMAtomicDecU32(&pDbgcIo->cSvcsRunning))
569	dbgcIoDestroy(pDbgcIo);
570	}
571	}
572	else
573	rc = VM_SET_ERROR_U(pUVM, VERR_NO_MEMORY, "Failed to allocate memory for the debugger I/O service");
574	}
575	else
576	rc = dbgcIoCreateLegacyTcp(pUVM, pKey, ppvData);
577
578	return rc;
579	}
580
581
582	/**
583	* Terminates any running debugger services.
584	*
585	* @returns VBox status code.
586	* @param pUVM The user mode VM handle.
587	* @param pvData The data returned by DBGCIoCreate.
588	*/
589	DBGDECL(int) DBGCIoTerminate(PUVM pUVM, void *pvData)
590	{
591	RT_NOREF(pUVM);
592	PDBGCIOINT pDbgcIo = (PDBGCIOINT)pvData;
593
594	if (pDbgcIo)
595	{
596	ASMAtomicXchgBool(&pDbgcIo->fShutdown, true);
597
598	for (uint32_t i = 0; i < pDbgcIo->cSvcsCfg; i++)
599	{
600	PDBGCIOSVC pIoSvc = &pDbgcIo->aSvc[i];
601
602	if (pIoSvc->hThreadSvc != NIL_RTTHREAD)
603	pIoSvc->pIoProvReg->pfnWaitInterrupt(pIoSvc->hDbgcIoProv);
604	}
605
606	if (!ASMAtomicDecU32(&pDbgcIo->cSvcsRunning))
607	dbgcIoDestroy(pDbgcIo);
608	}
609
610	return VINF_SUCCESS;
611	}
612

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

source: vbox/trunk/src/VBox/Debugger/DBGCIo.cpp@ 99553

Download in other formats: