VirtualBox

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

Last change on this file since 98103 was 98103, checked in by vboxsync, 17 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 */
54typedef 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. */
71typedef DBGCSTUB *PDBGCSTUB;
72/** Pointer to a const stub descriptor. */
73typedef const DBGCSTUB *PCDBGCSTUB;
74
75
76/** Pointer to the instance data of the debug console I/O. */
77typedef struct DBGCIOINT *PDBGCIOINT;
78
79
80/**
81 * A single debug console I/O service.
82 */
83typedef 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. */
103typedef DBGCIOSVC *PDBGCIOSVC;
104/** Poitner to a const single debug console I/O service. */
105typedef const DBGCIOSVC *PCDBGCIOSVC;
106
107
108/**
109 * Debug console I/O instance data.
110 */
111typedef 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 */
132static PCDBGCIOPROVREG g_aIoProv[] =
133{
134 &g_DbgcIoProvTcp,
135 &g_DbgcIoProvUdp,
136 &g_DbgcIoProvIpc
137};
138
139
140static DECLCALLBACK(int) dbgcIoNativeStubRunloop(PUVM pUVM, PCDBGCIO pIo, unsigned fFlags);
141
142/**
143 * Array of supported stubs.
144 */
145static 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 */
165static 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 */
191static 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 */
211static 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 */
228static 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 */
242static 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 */
251static 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 */
261static 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 */
271static 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 */
281static 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 */
327static 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 */
337static 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
381static 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 */
425static 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 */
475static 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 */
528DBGDECL(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 */
589DBGDECL(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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use