[86327] | 1 | /* $Id: DBGCIo.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * DBGC - Debugger Console, I/O provider handling.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2020-2023 Oracle and/or its affiliates.
|
---|
[86327] | 8 | *
|
---|
[96407] | 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
|
---|
[86327] | 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,
|
---|
[96865] | 135 | &g_DbgcIoProvUdp,
|
---|
[86327] | 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 | * @param pDbgcIo Pointer to the dbeugger console I/O instance data.
|
---|
| 163 | */
|
---|
| 164 | static void dbgcIoDestroy(PDBGCIOINT pDbgcIo)
|
---|
| 165 | {
|
---|
| 166 | for (uint32_t i = 0; i < pDbgcIo->cSvcsCfg; i++)
|
---|
| 167 | {
|
---|
| 168 | PDBGCIOSVC pIoSvc = &pDbgcIo->aSvc[i];
|
---|
| 169 |
|
---|
| 170 | if (pIoSvc->hThreadSvc != NIL_RTTHREAD)
|
---|
| 171 | {
|
---|
| 172 | int rc = RTThreadWait(pIoSvc->hThreadSvc, RT_MS_10SEC, NULL /*prc*/);
|
---|
| 173 | AssertRC(rc);
|
---|
| 174 |
|
---|
| 175 | pIoSvc->hThreadSvc = NIL_RTTHREAD;
|
---|
| 176 | pIoSvc->pIoProvReg->pfnDestroy(pIoSvc->hDbgcIoProv);
|
---|
| 177 | }
|
---|
| 178 | }
|
---|
| 179 |
|
---|
| 180 | RTMemFree(pDbgcIo);
|
---|
| 181 | }
|
---|
| 182 |
|
---|
| 183 |
|
---|
| 184 | /**
|
---|
| 185 | * Returns the number of I/O services configured.
|
---|
| 186 | *
|
---|
| 187 | * @returns I/O service count.
|
---|
| 188 | * @param pCfgRoot The root of the config.
|
---|
| 189 | */
|
---|
| 190 | static uint32_t dbgcIoGetSvcCount(PCFGMNODE pCfgRoot)
|
---|
| 191 | {
|
---|
| 192 | uint32_t cSvcs = 0;
|
---|
| 193 | PCFGMNODE pNd = CFGMR3GetFirstChild(pCfgRoot);
|
---|
| 194 | while (pNd)
|
---|
| 195 | {
|
---|
| 196 | cSvcs++;
|
---|
| 197 | pNd = CFGMR3GetNextChild(pNd);
|
---|
| 198 | }
|
---|
| 199 |
|
---|
| 200 | return cSvcs;
|
---|
| 201 | }
|
---|
| 202 |
|
---|
| 203 |
|
---|
| 204 | /**
|
---|
| 205 | * Returns a pointer to the I/O provider registration record matching the given name.
|
---|
| 206 | *
|
---|
| 207 | * @returns Pointer to the registration record or NULL if not found.
|
---|
| 208 | * @param pszName The name to look for (case insensitive matching).
|
---|
| 209 | */
|
---|
| 210 | static PCDBGCIOPROVREG dbgcIoProvFindRegByName(const char *pszName)
|
---|
| 211 | {
|
---|
| 212 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aIoProv); i++)
|
---|
| 213 | {
|
---|
| 214 | if (!RTStrICmp(g_aIoProv[i]->pszName, pszName))
|
---|
| 215 | return g_aIoProv[i];
|
---|
| 216 | }
|
---|
| 217 | return NULL;
|
---|
| 218 | }
|
---|
| 219 |
|
---|
| 220 |
|
---|
| 221 | /**
|
---|
| 222 | * Returns a pointer to the stub record matching the given name.
|
---|
| 223 | *
|
---|
| 224 | * @returns Pointer to the stub record or NULL if not found.
|
---|
| 225 | * @param pszName The name to look for (case insensitive matching).
|
---|
| 226 | */
|
---|
| 227 | static PCDBGCSTUB dbgcIoFindStubByName(const char *pszName)
|
---|
| 228 | {
|
---|
| 229 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStubs); i++)
|
---|
| 230 | {
|
---|
| 231 | if (!RTStrICmp(g_aStubs[i].pszName, pszName))
|
---|
| 232 | return &g_aStubs[i];
|
---|
| 233 | }
|
---|
| 234 | return NULL;
|
---|
| 235 | }
|
---|
| 236 |
|
---|
| 237 |
|
---|
| 238 | /**
|
---|
| 239 | * Wrapper around DBGCCreate() to get it working as a callback.
|
---|
| 240 | */
|
---|
| 241 | static DECLCALLBACK(int) dbgcIoNativeStubRunloop(PUVM pUVM, PCDBGCIO pIo, unsigned fFlags)
|
---|
| 242 | {
|
---|
| 243 | return DBGCCreate(pUVM, pIo, fFlags);
|
---|
| 244 | }
|
---|
| 245 |
|
---|
| 246 |
|
---|
| 247 | /**
|
---|
| 248 | * @interface_method_impl{DBGCIO,pfnDestroy}
|
---|
| 249 | */
|
---|
| 250 | static DECLCALLBACK(void) dbgcIoAsciiDestroy(PCDBGCIO pIo)
|
---|
| 251 | {
|
---|
| 252 | PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
|
---|
| 253 | pIoSvc->pIo->pfnDestroy(pIoSvc->pIo);
|
---|
| 254 | }
|
---|
| 255 |
|
---|
| 256 |
|
---|
| 257 | /**
|
---|
| 258 | * @interface_method_impl{DBGCIO,pfnInput}
|
---|
| 259 | */
|
---|
| 260 | static DECLCALLBACK(bool) dbgcIoAsciiInput(PCDBGCIO pIo, uint32_t cMillies)
|
---|
| 261 | {
|
---|
| 262 | PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
|
---|
| 263 | return pIoSvc->pIo->pfnInput(pIoSvc->pIo, cMillies);
|
---|
| 264 | }
|
---|
| 265 |
|
---|
| 266 |
|
---|
| 267 | /**
|
---|
| 268 | * @interface_method_impl{DBGCIO,pfnRead}
|
---|
| 269 | */
|
---|
| 270 | static DECLCALLBACK(int) dbgcIoAsciiRead(PCDBGCIO pIo, void *pvBuf, size_t cbBuf, size_t *pcbRead)
|
---|
| 271 | {
|
---|
| 272 | PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
|
---|
| 273 | return pIoSvc->pIo->pfnRead(pIoSvc->pIo, pvBuf, cbBuf, pcbRead);
|
---|
| 274 | }
|
---|
| 275 |
|
---|
| 276 |
|
---|
| 277 | /**
|
---|
| 278 | * @interface_method_impl{DBGCIO,pfnWrite}
|
---|
| 279 | */
|
---|
| 280 | static DECLCALLBACK(int) dbgcIoAsciiWrite(PCDBGCIO pIo, const void *pvBuf, size_t cbBuf, size_t *pcbWritten)
|
---|
| 281 | {
|
---|
| 282 | PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
|
---|
| 283 |
|
---|
| 284 | /*
|
---|
| 285 | * convert '\n' to '\r\n' while writing.
|
---|
| 286 | */
|
---|
| 287 | int rc = 0;
|
---|
| 288 | size_t cbLeft = cbBuf;
|
---|
| 289 | while (cbLeft)
|
---|
| 290 | {
|
---|
| 291 | size_t cb = cbLeft;
|
---|
| 292 | /* write newlines */
|
---|
| 293 | if (*(const char *)pvBuf == '\n')
|
---|
| 294 | {
|
---|
| 295 | rc = pIoSvc->pIo->pfnWrite(pIoSvc->pIo, "\r\n", 2, NULL);
|
---|
| 296 | cb = 1;
|
---|
| 297 | }
|
---|
| 298 | /* write till next newline */
|
---|
| 299 | else
|
---|
| 300 | {
|
---|
| 301 | const char *pszNL = (const char *)memchr(pvBuf, '\n', cbLeft);
|
---|
| 302 | if (pszNL)
|
---|
| 303 | cb = (uintptr_t)pszNL - (uintptr_t)pvBuf;
|
---|
| 304 | rc = pIoSvc->pIo->pfnWrite(pIoSvc->pIo, pvBuf, cb, NULL);
|
---|
| 305 | }
|
---|
| 306 | if (RT_FAILURE(rc))
|
---|
| 307 | break;
|
---|
| 308 |
|
---|
| 309 | /* advance */
|
---|
| 310 | cbLeft -= cb;
|
---|
| 311 | pvBuf = (const char *)pvBuf + cb;
|
---|
| 312 | }
|
---|
| 313 |
|
---|
| 314 | /*
|
---|
| 315 | * Set returned value and return.
|
---|
| 316 | */
|
---|
| 317 | if (pcbWritten)
|
---|
| 318 | *pcbWritten = cbBuf - cbLeft;
|
---|
| 319 | return rc;
|
---|
| 320 | }
|
---|
| 321 |
|
---|
| 322 |
|
---|
| 323 | /**
|
---|
| 324 | * @interface_method_impl{DBGCIO,pfnSetReady}
|
---|
| 325 | */
|
---|
| 326 | static DECLCALLBACK(void) dbgcIoAsciiSetReady(PCDBGCIO pIo, bool fReady)
|
---|
| 327 | {
|
---|
| 328 | PDBGCIOSVC pIoSvc = RT_FROM_MEMBER(pIo, DBGCIOSVC, IoAscii);
|
---|
| 329 | return pIoSvc->pIo->pfnSetReady(pIoSvc->pIo, fReady);
|
---|
| 330 | }
|
---|
| 331 |
|
---|
| 332 |
|
---|
| 333 | /**
|
---|
| 334 | * The I/O thread handling the service.
|
---|
| 335 | */
|
---|
| 336 | static DECLCALLBACK(int) dbgcIoSvcThread(RTTHREAD hThreadSelf, void *pvUser)
|
---|
| 337 | {
|
---|
| 338 | RT_NOREF(hThreadSelf);
|
---|
| 339 |
|
---|
| 340 | int rc = VINF_SUCCESS;
|
---|
| 341 | PDBGCIOSVC pIoSvc = (PDBGCIOSVC)pvUser;
|
---|
| 342 | PDBGCIOINT pDbgcIo = pIoSvc->pDbgcIo;
|
---|
| 343 | PCDBGCIOPROVREG pIoProvReg = pIoSvc->pIoProvReg;
|
---|
| 344 |
|
---|
| 345 | while (!ASMAtomicReadBool(&pDbgcIo->fShutdown))
|
---|
| 346 | {
|
---|
| 347 | /* Wait until someone connects. */
|
---|
| 348 | rc = pIoProvReg->pfnWaitForConnect(pIoSvc->hDbgcIoProv, RT_INDEFINITE_WAIT, &pIoSvc->pIo);
|
---|
| 349 | if (RT_SUCCESS(rc))
|
---|
| 350 | {
|
---|
| 351 | PCDBGCIO pIo = pIoSvc->pIo;
|
---|
| 352 |
|
---|
| 353 | if (pIoSvc->pStub->fAscii)
|
---|
| 354 | {
|
---|
| 355 | pIoSvc->IoAscii.pfnDestroy = dbgcIoAsciiDestroy;
|
---|
| 356 | pIoSvc->IoAscii.pfnInput = dbgcIoAsciiInput;
|
---|
| 357 | pIoSvc->IoAscii.pfnRead = dbgcIoAsciiRead;
|
---|
| 358 | pIoSvc->IoAscii.pfnWrite = dbgcIoAsciiWrite;
|
---|
| 359 | pIoSvc->IoAscii.pfnSetReady = dbgcIoAsciiSetReady;
|
---|
| 360 | pIo = &pIoSvc->IoAscii;
|
---|
| 361 | }
|
---|
| 362 |
|
---|
| 363 | /* call the runloop for the connection. */
|
---|
| 364 | pIoSvc->pStub->pfnRunloop(pIoSvc->pUVM, pIo, 0 /*fFlags*/);
|
---|
| 365 |
|
---|
| 366 | pIo->pfnDestroy(pIo);
|
---|
| 367 | }
|
---|
| 368 | else if ( rc != VERR_TIMEOUT
|
---|
| 369 | && rc != VERR_INTERRUPTED)
|
---|
| 370 | break;
|
---|
| 371 | }
|
---|
| 372 |
|
---|
| 373 | if (!ASMAtomicDecU32(&pDbgcIo->cSvcsRunning))
|
---|
| 374 | dbgcIoDestroy(pDbgcIo);
|
---|
| 375 |
|
---|
| 376 | return rc;
|
---|
| 377 | }
|
---|
| 378 |
|
---|
| 379 |
|
---|
| 380 | static int dbgcIoSvcInitWorker(PUVM pUVM, PDBGCIOSVC pIoSvc, PCDBGCIOPROVREG pIoProvReg,
|
---|
| 381 | PCDBGCSTUB pStub, PCFGMNODE pCfg, const char *pszName,
|
---|
| 382 | bool fIgnoreNetAddrInUse)
|
---|
| 383 | {
|
---|
| 384 | pIoSvc->pUVM = pUVM;
|
---|
| 385 | pIoSvc->pIoProvReg = pIoProvReg;
|
---|
| 386 | pIoSvc->pStub = pStub;
|
---|
| 387 |
|
---|
| 388 | /* Create the provider instance and spawn the dedicated thread handling that service. */
|
---|
| 389 | int rc = pIoProvReg->pfnCreate(&pIoSvc->hDbgcIoProv, pCfg);
|
---|
| 390 | if (RT_SUCCESS(rc))
|
---|
| 391 | {
|
---|
| 392 | rc = RTThreadCreateF(&pIoSvc->hThreadSvc, dbgcIoSvcThread, pIoSvc, 0 /*cbStack*/,
|
---|
| 393 | RTTHREADTYPE_DEBUGGER, RTTHREADFLAGS_WAITABLE, "DbgcThrd-%s", pszName);
|
---|
| 394 | if (RT_SUCCESS(rc))
|
---|
| 395 | {
|
---|
| 396 | ASMAtomicIncU32(&pIoSvc->pDbgcIo->cSvcsRunning);
|
---|
| 397 | return VINF_SUCCESS;
|
---|
| 398 | }
|
---|
| 399 | else
|
---|
| 400 | rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
|
---|
| 401 | "Configuration error: Creating an instance of the service \"%s\" failed",
|
---|
| 402 | pszName);
|
---|
| 403 |
|
---|
| 404 | pIoProvReg->pfnDestroy(pIoSvc->hDbgcIoProv);
|
---|
| 405 | }
|
---|
| 406 | else if ( rc != VERR_NET_ADDRESS_IN_USE
|
---|
| 407 | || !fIgnoreNetAddrInUse)
|
---|
| 408 | rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
|
---|
| 409 | "Configuration error: Creating an instance of the I/O provider \"%s\" failed",
|
---|
| 410 | pIoProvReg->pszName);
|
---|
| 411 |
|
---|
| 412 | return rc;
|
---|
| 413 | }
|
---|
| 414 |
|
---|
| 415 |
|
---|
| 416 | /**
|
---|
| 417 | * Tries to initialize the given I/O service from the given config.
|
---|
| 418 | *
|
---|
| 419 | * @returns VBox status code.
|
---|
| 420 | * @param pUVM The user mode VM handle.
|
---|
[86329] | 421 | * @param pIoSvc The I/O service instance to initialize.
|
---|
| 422 | * @param pCfg The config for the instance.
|
---|
[86327] | 423 | */
|
---|
| 424 | static int dbgcIoSvcInit(PUVM pUVM, PDBGCIOSVC pIoSvc, PCFGMNODE pCfg)
|
---|
| 425 | {
|
---|
| 426 | char szName[32 + 1]; RT_ZERO(szName);
|
---|
| 427 | int rc = CFGMR3GetName(pCfg, &szName[0], sizeof(szName));
|
---|
| 428 | if (RT_SUCCESS(rc))
|
---|
| 429 | {
|
---|
| 430 | char szIoProvName[32 + 1]; RT_ZERO(szIoProvName);
|
---|
| 431 | rc = CFGMR3QueryString(pCfg, "Provider", &szIoProvName[0], sizeof(szIoProvName));
|
---|
| 432 | if (RT_SUCCESS(rc))
|
---|
| 433 | {
|
---|
| 434 | char szStub[32 + 1]; RT_ZERO(szStub);
|
---|
| 435 | rc = CFGMR3QueryString(pCfg, "StubType", &szStub[0], sizeof(szStub));
|
---|
| 436 | if (RT_SUCCESS(rc))
|
---|
| 437 | {
|
---|
| 438 | PCDBGCIOPROVREG pIoProvReg = dbgcIoProvFindRegByName(szIoProvName);
|
---|
| 439 | if (pIoProvReg)
|
---|
| 440 | {
|
---|
| 441 | PCDBGCSTUB pStub = dbgcIoFindStubByName(szStub);
|
---|
| 442 | if (pStub)
|
---|
| 443 | rc = dbgcIoSvcInitWorker(pUVM, pIoSvc, pIoProvReg, pStub, pCfg, szName,
|
---|
| 444 | false /*fIgnoreNetAddrInUse*/);
|
---|
| 445 | else
|
---|
| 446 | rc = VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS, "Configuration error: The stub type \"%s\" could not be found",
|
---|
| 447 | szStub);
|
---|
| 448 | }
|
---|
| 449 | else
|
---|
| 450 | rc = VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS, "Configuration error: The provider \"%s\" could not be found",
|
---|
| 451 | szIoProvName);
|
---|
| 452 | }
|
---|
| 453 | else
|
---|
| 454 | rc = VM_SET_ERROR_U(pUVM, rc, "Configuration error: Querying \"StubType\" failed");
|
---|
| 455 | }
|
---|
| 456 | else
|
---|
| 457 | rc = VM_SET_ERROR_U(pUVM, rc, "Configuration error: Querying \"Provider\" failed");
|
---|
| 458 | }
|
---|
| 459 | else
|
---|
| 460 | rc = VM_SET_ERROR_U(pUVM, rc, "Configuration error: Querying service identifier failed (maybe too long)");
|
---|
| 461 |
|
---|
| 462 | return rc;
|
---|
| 463 | }
|
---|
| 464 |
|
---|
| 465 |
|
---|
| 466 | /**
|
---|
| 467 | * Creates the DBGC I/O services from the legacy TCP config.
|
---|
| 468 | *
|
---|
| 469 | * @returns VBox status code.
|
---|
| 470 | * @param pUVM The user mode VM handle.
|
---|
| 471 | * @param pKey The config key.
|
---|
| 472 | * @param ppvData Where to store the I/o instance data on success.
|
---|
| 473 | */
|
---|
| 474 | static int dbgcIoCreateLegacyTcp(PUVM pUVM, PCFGMNODE pKey, void **ppvData)
|
---|
| 475 | {
|
---|
| 476 | bool fEnabled;
|
---|
| 477 | int rc = CFGMR3QueryBoolDef(pKey, "Enabled", &fEnabled,
|
---|
| 478 | #if defined(VBOX_WITH_DEBUGGER) && defined(VBOX_WITH_DEBUGGER_TCP_BY_DEFAULT)
|
---|
| 479 | true
|
---|
| 480 | #else
|
---|
| 481 | false
|
---|
| 482 | #endif
|
---|
| 483 | );
|
---|
| 484 | if (RT_FAILURE(rc))
|
---|
| 485 | return VM_SET_ERROR_U(pUVM, rc, "Configuration error: Failed querying \"DBGC/Enabled\"");
|
---|
| 486 |
|
---|
| 487 | if (!fEnabled)
|
---|
| 488 | {
|
---|
| 489 | LogFlow(("DBGCTcpCreate: returns VINF_SUCCESS (Disabled)\n"));
|
---|
| 490 | return VINF_SUCCESS;
|
---|
| 491 | }
|
---|
| 492 |
|
---|
| 493 | PDBGCIOINT pDbgcIo = (PDBGCIOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(DBGCIOINT, aSvc[1]));
|
---|
| 494 | if (RT_LIKELY(pDbgcIo))
|
---|
| 495 | {
|
---|
| 496 | pDbgcIo->aSvc[0].pDbgcIo = pDbgcIo;
|
---|
| 497 | pDbgcIo->cSvcsCfg = 1;
|
---|
| 498 | pDbgcIo->cSvcsRunning = 1;
|
---|
| 499 | rc = dbgcIoSvcInitWorker(pUVM, &pDbgcIo->aSvc[0], &g_DbgcIoProvTcp, &g_aStubs[0], pKey, "TCP",
|
---|
| 500 | true /*fIgnoreNetAddrInUse*/);
|
---|
| 501 | if (RT_SUCCESS(rc))
|
---|
| 502 | {
|
---|
| 503 | *ppvData = pDbgcIo;
|
---|
| 504 | return VINF_SUCCESS;
|
---|
| 505 | }
|
---|
| 506 |
|
---|
| 507 | RTMemFree(pDbgcIo);
|
---|
| 508 | if (rc == VERR_NET_ADDRESS_IN_USE)
|
---|
| 509 | rc = VINF_SUCCESS;
|
---|
| 510 | }
|
---|
| 511 | else
|
---|
| 512 | rc = VERR_NO_MEMORY;
|
---|
| 513 |
|
---|
| 514 | if (RT_FAILURE(rc))
|
---|
| 515 | rc = VM_SET_ERROR_U(pUVM, rc, "Cannot start TCP-based debugging console service");
|
---|
| 516 | return rc;
|
---|
| 517 | }
|
---|
| 518 |
|
---|
| 519 |
|
---|
| 520 | /**
|
---|
| 521 | * Sets up debugger I/O based on the VM config.
|
---|
| 522 | *
|
---|
| 523 | * @returns VBox status code.
|
---|
| 524 | * @param pUVM The user mode VM handle.
|
---|
| 525 | * @param ppvData Where to store a pointer to the instance data.
|
---|
| 526 | */
|
---|
| 527 | DBGDECL(int) DBGCIoCreate(PUVM pUVM, void **ppvData)
|
---|
| 528 | {
|
---|
| 529 | /*
|
---|
| 530 | * Check what the configuration says.
|
---|
| 531 | */
|
---|
| 532 | PCFGMNODE pKey = CFGMR3GetChild(CFGMR3GetRootU(pUVM), "DBGC");
|
---|
| 533 | uint32_t cSvcs = dbgcIoGetSvcCount(pKey);
|
---|
| 534 | int rc = VINF_SUCCESS;
|
---|
| 535 |
|
---|
| 536 | /* If no services are configured try the legacy config supporting TCP only. */
|
---|
| 537 | if (cSvcs)
|
---|
| 538 | {
|
---|
| 539 | PDBGCIOINT pDbgcIo = (PDBGCIOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(DBGCIOINT, aSvc[cSvcs]));
|
---|
| 540 | if (RT_LIKELY(pDbgcIo))
|
---|
| 541 | {
|
---|
| 542 | pDbgcIo->cSvcsCfg = 0;
|
---|
| 543 | pDbgcIo->cSvcsRunning = 1;
|
---|
| 544 | pDbgcIo->fShutdown = false;
|
---|
| 545 |
|
---|
| 546 | for (uint32_t i = 0; i < cSvcs; i++)
|
---|
| 547 | pDbgcIo->aSvc[i].hThreadSvc = NIL_RTTHREAD;
|
---|
| 548 |
|
---|
| 549 | PCFGMNODE pSvcCfg = CFGMR3GetFirstChild(pKey);
|
---|
| 550 | for (uint32_t i = 0; i < cSvcs && RT_SUCCESS(rc); i++)
|
---|
| 551 | {
|
---|
| 552 | pDbgcIo->aSvc[i].pDbgcIo = pDbgcIo;
|
---|
| 553 |
|
---|
| 554 | rc = dbgcIoSvcInit(pUVM, &pDbgcIo->aSvc[i], pSvcCfg);
|
---|
| 555 | if (RT_SUCCESS(rc))
|
---|
| 556 | pDbgcIo->cSvcsCfg++;
|
---|
| 557 | else
|
---|
| 558 | rc = VM_SET_ERROR_U(pUVM, rc, "Failed to initialize the debugger I/O service");
|
---|
| 559 |
|
---|
| 560 | pSvcCfg = CFGMR3GetNextChild(pSvcCfg);
|
---|
| 561 | }
|
---|
| 562 |
|
---|
| 563 | if (RT_SUCCESS(rc))
|
---|
| 564 | *ppvData = pDbgcIo;
|
---|
| 565 | else
|
---|
| 566 | {
|
---|
| 567 | if (!ASMAtomicDecU32(&pDbgcIo->cSvcsRunning))
|
---|
| 568 | dbgcIoDestroy(pDbgcIo);
|
---|
| 569 | }
|
---|
| 570 | }
|
---|
| 571 | else
|
---|
| 572 | rc = VM_SET_ERROR_U(pUVM, VERR_NO_MEMORY, "Failed to allocate memory for the debugger I/O service");
|
---|
| 573 | }
|
---|
| 574 | else
|
---|
| 575 | rc = dbgcIoCreateLegacyTcp(pUVM, pKey, ppvData);
|
---|
| 576 |
|
---|
| 577 | return rc;
|
---|
| 578 | }
|
---|
| 579 |
|
---|
| 580 |
|
---|
| 581 | /**
|
---|
| 582 | * Terminates any running debugger services.
|
---|
| 583 | *
|
---|
| 584 | * @returns VBox status code.
|
---|
| 585 | * @param pUVM The user mode VM handle.
|
---|
| 586 | * @param pvData The data returned by DBGCIoCreate.
|
---|
| 587 | */
|
---|
| 588 | DBGDECL(int) DBGCIoTerminate(PUVM pUVM, void *pvData)
|
---|
| 589 | {
|
---|
| 590 | RT_NOREF(pUVM);
|
---|
| 591 | PDBGCIOINT pDbgcIo = (PDBGCIOINT)pvData;
|
---|
| 592 |
|
---|
| 593 | if (pDbgcIo)
|
---|
| 594 | {
|
---|
| 595 | ASMAtomicXchgBool(&pDbgcIo->fShutdown, true);
|
---|
| 596 |
|
---|
| 597 | for (uint32_t i = 0; i < pDbgcIo->cSvcsCfg; i++)
|
---|
| 598 | {
|
---|
| 599 | PDBGCIOSVC pIoSvc = &pDbgcIo->aSvc[i];
|
---|
| 600 |
|
---|
| 601 | if (pIoSvc->hThreadSvc != NIL_RTTHREAD)
|
---|
| 602 | pIoSvc->pIoProvReg->pfnWaitInterrupt(pIoSvc->hDbgcIoProv);
|
---|
| 603 | }
|
---|
| 604 |
|
---|
| 605 | if (!ASMAtomicDecU32(&pDbgcIo->cSvcsRunning))
|
---|
| 606 | dbgcIoDestroy(pDbgcIo);
|
---|
| 607 | }
|
---|
| 608 |
|
---|
| 609 | return VINF_SUCCESS;
|
---|
| 610 | }
|
---|
| 611 |
|
---|