VirtualBox

source: vbox/trunk/src/VBox/VMM/DBGF.cpp@ 2676

Last change on this file since 2676 was 2507, checked in by vboxsync, 17 years ago

Drop the VINF_IOM_HC_IOPORT_READWRITE status code as it isn't really used. Made VINF_EM_LAST inclusive as per last/end convention used elsewhere in the VM.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 29.3 KB
Line 
1/* $Id: DBGF.cpp 2507 2007-05-04 18:23:45Z vboxsync $ */
2/** @file
3 * VMM DBGF - Debugger Facility.
4 */
5
6/*
7 * Copyright (C) 2006 InnoTek Systemberatung 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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22
23/** @page pg_dbgf DBGC - The Debugger Facility
24 *
25 * The purpose of the DBGC is to provide an interface for debuggers to manipulate
26 * the VMM without having to mess up the source code for each of them. The DBGF
27 * is always built in and will always work when a debugger attaches to the VM.
28 * The DBGF provides the basic debugger features, such as halting execution,
29 * handling breakpoints and single step execution.
30 *
31 * The interface is working in a manner similar to the win32, linux and os2
32 * debugger interfaces. It interface has an asynchronous nature. This comes from
33 * the fact that the VMM and the Debugger are running in different threads.
34 * They are refered to as the "emulation thread" and the "debugger thread",
35 * or as the "ping thread" and the "pong thread, respectivly. (The last set
36 * of names comes from the use of the Ping-Pong synchronization construct from
37 * the RTSem API.)
38 *
39 *
40 *
41 * @section sec_dbgf_scenario Debugger Scenario
42 *
43 * The debugger starts by attaching to the VM. For pratical reasons we limit the
44 * number of concurrently attached debuggers to 1 per VM. The action of attaching
45 * to the VM causes the VM to check and generate debug events.
46 *
47 * The debugger then will wait/poll for debug events and issue commands.
48 *
49 * The waiting and polling is done by the DBGFEventWait() function. It will wait
50 * for the emulation thread to send a ping, thus indicating that there is an
51 * event waiting to be processed.
52 *
53 * An event can be a respons to an command issued previously, the hitting of a
54 * breakpoint, or running into a bad/fatal VMM condition. The debugger now have
55 * the ping and must respond to the event at hand - the VMM is waiting. This
56 * usually means that the user of the debugger must do something, but it doesn't
57 * have to. The debugger is free to call any DBGF function (nearly at least)
58 * while processing the event.
59 *
60 * Typically the user will issue a request for the execution to be resumed, so
61 * the debugger calls DBGFResume() and goes back to waiting/polling for events.
62 *
63 * When the user eventually terminates the debugging session or selects another
64 * VM, the debugger detaches from the VM. This means that breakpoints are disabled
65 * and that the emulation thread no longer polls for debugger commands.
66 *
67 */
68
69
70
71/*******************************************************************************
72* Header Files *
73*******************************************************************************/
74#define LOG_GROUP LOG_GROUP_DBGF
75#include <VBox/dbgf.h>
76#include <VBox/selm.h>
77#include <VBox/rem.h>
78#include <VBox/em.h>
79#include "DBGFInternal.h"
80#include <VBox/vm.h>
81#include <VBox/err.h>
82
83#include <VBox/log.h>
84#include <iprt/semaphore.h>
85#include <iprt/thread.h>
86#include <iprt/asm.h>
87#include <iprt/time.h>
88#include <iprt/assert.h>
89#include <iprt/stream.h>
90
91
92/*******************************************************************************
93* Internal Functions *
94*******************************************************************************/
95static int dbgfr3VMMWait(PVM pVM);
96static int dbgfr3VMMCmd(PVM pVM, DBGFCMD enmCmd, PDBGFCMDDATA pCmdData, bool *pfResumeExecution);
97
98
99/**
100 * Sets the VMM Debug Command variable.
101 *
102 * @returns Previous command.
103 * @param pVM VM Handle.
104 * @param enmCmd The command.
105 */
106DECLINLINE(DBGFCMD) dbgfr3SetCmd(PVM pVM, DBGFCMD enmCmd)
107{
108 DBGFCMD rc;
109 if (enmCmd == DBGFCMD_NO_COMMAND)
110 {
111 Log2(("DBGF: Setting command to %d (DBGFCMD_NO_COMMAND)\n", enmCmd));
112 rc = (DBGFCMD)ASMAtomicXchgU32((uint32_t volatile *)(void *)&pVM->dbgf.s.enmVMMCmd, enmCmd);
113 VM_FF_CLEAR(pVM, VM_FF_DBGF);
114 }
115 else
116 {
117 Log2(("DBGF: Setting command to %d\n", enmCmd));
118 AssertMsg(pVM->dbgf.s.enmVMMCmd == DBGFCMD_NO_COMMAND, ("enmCmd=%d enmVMMCmd=%d\n", enmCmd, pVM->dbgf.s.enmVMMCmd));
119 rc = (DBGFCMD)ASMAtomicXchgU32((uint32_t volatile *)(void *)&pVM->dbgf.s.enmVMMCmd, enmCmd);
120 VM_FF_SET(pVM, VM_FF_DBGF);
121 VMR3NotifyFF(pVM, false /* didn't notify REM */);
122 }
123 return rc;
124}
125
126
127/**
128 * Initializes the DBGF.
129 *
130 * @returns VBox status code.
131 * @param pVM VM handle.
132 */
133DBGFR3DECL(int) DBGFR3Init(PVM pVM)
134{
135 int rc = dbgfR3InfoInit(pVM);
136 if (VBOX_SUCCESS(rc))
137 rc = dbgfR3SymInit(pVM);
138 if (VBOX_SUCCESS(rc))
139 rc = dbgfR3BpInit(pVM);
140 return rc;
141}
142
143
144/**
145 * Termiantes and cleans up resources allocated by the DBGF.
146 *
147 * @returns VBox status code.
148 * @param pVM VM Handle.
149 */
150DBGFR3DECL(int) DBGFR3Term(PVM pVM)
151{
152 int rc;
153
154 /*
155 * Send a termination event to any attached debuggers.
156 */
157 /* wait for any pending events or whatever */
158 if ( pVM->dbgf.s.fAttached
159 && pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG)
160 {
161 do rc = RTSemPingWait(&pVM->dbgf.s.PingPong, 5000);
162 while (pVM->dbgf.s.fAttached);
163 }
164
165 /* now, send the event */
166 if ( pVM->dbgf.s.fAttached
167 && pVM->dbgf.s.PingPong.enmSpeaker != RTPINGPONGSPEAKER_PONG)
168 {
169 pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_TERMINATING;
170 pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_OTHER;
171 rc = RTSemPing(&pVM->dbgf.s.PingPong);
172 if (VBOX_SUCCESS(rc))
173 {
174 /*
175 * Waits for the debugger to detach.
176 */
177 while (pVM->dbgf.s.fAttached)
178 {
179 /*
180 * Wait.
181 */
182 rc = RTSemPingWait(&pVM->dbgf.s.PingPong, 1000);
183
184 /*
185 * Process the command.
186 */
187 DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
188 DBGFCMD enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_NO_COMMAND);
189 if (enmCmd != DBGFCMD_NO_COMMAND)
190 {
191 bool fResumeExecution = false;
192 rc = dbgfr3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
193 if (enmCmd == DBGFCMD_DETACH_DEBUGGER)
194 break;
195 }
196 else if (VBOX_FAILURE(rc))
197 break;
198 }
199 }
200 }
201
202 /*
203 * Terminate the other bits.
204 */
205 dbgfR3InfoTerm(pVM);
206 return VINF_SUCCESS;
207}
208
209
210/**
211 * Applies relocations to data and code managed by this
212 * component. This function will be called at init and
213 * whenever the VMM need to relocate it self inside the GC.
214 *
215 * @param pVM VM handle.
216 * @param offDelta Relocation delta relative to old location.
217 */
218DBGFR3DECL(void) DBGFR3Relocate(PVM pVM, RTGCINTPTR offDelta)
219{
220}
221
222
223/**
224 * Waits a little while for a debuggger to attach.
225 *
226 * @returns True is a debugger have attached.
227 * @param pVM VM handle.
228 * @param enmEvent Event.
229 */
230bool dbgfR3WaitForAttach(PVM pVM, DBGFEVENTTYPE enmEvent)
231{
232 /*
233 * First a message.
234 */
235#ifndef __L4__
236
237 RTStrmPrintf(g_pStdErr, "DBGF: No debugger attached, waiting 15 seconds for one to attach (event=%d)\n", enmEvent);
238 RTStrmFlush(g_pStdErr);
239# ifdef DEBUG_sandervl
240 int cWait = 10;
241# else
242 int cWait = 150;
243# endif
244 while (cWait > 0)
245 {
246 RTThreadSleep(100);
247 if (pVM->dbgf.s.fAttached)
248 {
249 RTStrmPrintf(g_pStdErr, "Attached!\n");
250 RTStrmFlush(g_pStdErr);
251 return true;
252 }
253
254 /* next */
255 if (!(cWait % 10))
256 {
257 RTStrmPrintf(g_pStdErr, "%d.", cWait / 10);
258 RTStrmFlush(g_pStdErr);
259 }
260 cWait--;
261 }
262#endif
263
264 RTStrmPrintf(g_pStdErr, "Stopping the VM!\n");
265 RTStrmFlush(g_pStdErr);
266 return false;
267}
268
269
270/**
271 * Forced action callback.
272 * The VMM will call this from it's main loop when VM_FF_DBGF is set.
273 *
274 * The function checks and executes pending commands from the debugger.
275 *
276 * @returns VINF_SUCCESS normally.
277 * @returns VERR_DBGF_RAISE_FATAL_ERROR to pretend a fatal error happend.
278 * @param pVM VM Handle.
279 */
280DBGFR3DECL(int) DBGFR3VMMForcedAction(PVM pVM)
281{
282 /*
283 * Clear the FF DBGF request flag.
284 */
285 Assert(pVM->fForcedActions & VM_FF_DBGF);
286 VM_FF_CLEAR(pVM, VM_FF_DBGF);
287
288 /*
289 * Commands?
290 */
291 int rc = VINF_SUCCESS;
292 if (pVM->dbgf.s.enmVMMCmd != DBGFCMD_NO_COMMAND)
293 {
294 /** @todo stupid GDT/LDT sync hack. go away! */
295 SELMR3UpdateFromCPUM(pVM);
296
297 /*
298 * Process the command.
299 */
300 bool fResumeExecution;
301 DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
302 DBGFCMD enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_NO_COMMAND);
303 rc = dbgfr3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
304 if (!fResumeExecution)
305 rc = dbgfr3VMMWait(pVM);
306 }
307 return rc;
308}
309
310
311/**
312 * Flag whether the event implies that we're stopped in the hypervisor code
313 * and have to block certain operations.
314 *
315 * @param pVM The VM handle.
316 * @param enmEvent The event.
317 */
318static void dbgfR3EventSetStoppedInHyperFlag(PVM pVM, DBGFEVENTTYPE enmEvent)
319{
320 switch (enmEvent)
321 {
322 case DBGFEVENT_STEPPED_HYPER:
323 case DBGFEVENT_ASSERTION_HYPER:
324 case DBGFEVENT_BREAKPOINT_HYPER:
325 pVM->dbgf.s.fStoppedInHyper = true;
326 break;
327 default:
328 pVM->dbgf.s.fStoppedInHyper = false;
329 break;
330 }
331}
332
333
334/**
335 * Try determin the event context.
336 *
337 * @returns debug event context.
338 * @param pVM The VM handle.
339 */
340static DBGFEVENTCTX dbgfR3FigureEventCtx(PVM pVM)
341{
342 switch (EMGetState(pVM))
343 {
344 case EMSTATE_RAW:
345 case EMSTATE_DEBUG_GUEST_RAW:
346 return DBGFEVENTCTX_RAW;
347
348 case EMSTATE_REM:
349 case EMSTATE_DEBUG_GUEST_REM:
350 return DBGFEVENTCTX_REM;
351
352 case EMSTATE_DEBUG_HYPER:
353 case EMSTATE_GURU_MEDITATION:
354 return DBGFEVENTCTX_HYPER;
355
356 default:
357 return DBGFEVENTCTX_OTHER;
358 }
359}
360
361/**
362 * The common event prologue code.
363 * It will set the 'stopped-in-hyper' flag, make sure someone's attach,
364 * and perhaps process any high priority pending actions (none yet).
365 *
366 * @returns VBox status.
367 * @param pVM The VM handle.
368 * @param enmEvent The event to be sent.
369 */
370static int dbgfR3EventPrologue(PVM pVM, DBGFEVENTTYPE enmEvent)
371{
372 /*
373 * Check if a debugger is attached.
374 */
375 if ( !pVM->dbgf.s.fAttached
376 && !dbgfR3WaitForAttach(pVM, enmEvent))
377 {
378 Log(("DBGFR3VMMEventSrc: enmEvent=%d - debugger not attached\n", enmEvent));
379 return VERR_DBGF_NOT_ATTACHED;
380 }
381
382 /*
383 * Sync back the state from the REM.
384 */
385 dbgfR3EventSetStoppedInHyperFlag(pVM, enmEvent);
386 if (!pVM->dbgf.s.fStoppedInHyper)
387 REMR3StateUpdate(pVM);
388
389 /*
390 * Look thru pending commands and finish those which make sense now.
391 */
392 /** @todo Process/purge pending commands. */
393 //int rc = DBGFR3VMMForcedAction(pVM);
394 return VINF_SUCCESS;
395}
396
397
398/**
399 * Sends the event in the event buffer.
400 *
401 * @returns VBox status code.
402 * @param pVM The VM handle.
403 */
404static int dbgfR3SendEvent(PVM pVM)
405{
406 int rc = RTSemPing(&pVM->dbgf.s.PingPong);
407 if (VBOX_SUCCESS(rc))
408 rc = dbgfr3VMMWait(pVM);
409
410 pVM->dbgf.s.fStoppedInHyper = false;
411 /** @todo sync VMM -> REM after exitting the debugger. everything may change while in the debugger! */
412 return rc;
413}
414
415
416/**
417 * Send a generic debugger event which takes no data.
418 *
419 * @returns VBox status.
420 * @param pVM The VM handle.
421 * @param enmEvent The event to send.
422 */
423DBGFR3DECL(int) DBGFR3Event(PVM pVM, DBGFEVENTTYPE enmEvent)
424{
425 int rc = dbgfR3EventPrologue(pVM, enmEvent);
426 if (VBOX_FAILURE(rc))
427 return rc;
428
429 /*
430 * Send the event and process the reply communication.
431 */
432 pVM->dbgf.s.DbgEvent.enmType = enmEvent;
433 pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
434 return dbgfR3SendEvent(pVM);
435}
436
437
438/**
439 * Send a debugger event which takes the full source file location.
440 *
441 * @returns VBox status.
442 * @param pVM The VM handle.
443 * @param enmEvent The event to send.
444 * @param pszFile Source file.
445 * @param uLine Line number in source file.
446 * @param pszFunction Function name.
447 * @param pszFormat Message which accompanies the event.
448 * @param ... Message arguments.
449 */
450DBGFR3DECL(int) DBGFR3EventSrc(PVM pVM, DBGFEVENTTYPE enmEvent, const char *pszFile, unsigned uLine, const char *pszFunction, const char *pszFormat, ...)
451{
452 va_list args;
453 va_start(args, pszFormat);
454 int rc = DBGFR3EventSrcV(pVM, enmEvent, pszFile, uLine, pszFunction, pszFormat, args);
455 va_end(args);
456 return rc;
457}
458
459
460/**
461 * Send a debugger event which takes the full source file location.
462 *
463 * @returns VBox status.
464 * @param pVM The VM handle.
465 * @param enmEvent The event to send.
466 * @param pszFile Source file.
467 * @param uLine Line number in source file.
468 * @param pszFunction Function name.
469 * @param pszFormat Message which accompanies the event.
470 * @param args Message arguments.
471 */
472DBGFR3DECL(int) DBGFR3EventSrcV(PVM pVM, DBGFEVENTTYPE enmEvent, const char *pszFile, unsigned uLine, const char *pszFunction, const char *pszFormat, va_list args)
473{
474 int rc = dbgfR3EventPrologue(pVM, enmEvent);
475 if (VBOX_FAILURE(rc))
476 return rc;
477
478 /*
479 * Format the message.
480 */
481 char *pszMessage = NULL;
482 char szMessage[8192];
483 if (pszFormat && *pszFormat)
484 {
485 pszMessage = &szMessage[0];
486 RTStrPrintfV(szMessage, sizeof(szMessage), pszFormat, args);
487 }
488
489 /*
490 * Send the event and process the reply communication.
491 */
492 pVM->dbgf.s.DbgEvent.enmType = enmEvent;
493 pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
494 pVM->dbgf.s.DbgEvent.u.Src.pszFile = pszFile;
495 pVM->dbgf.s.DbgEvent.u.Src.uLine = uLine;
496 pVM->dbgf.s.DbgEvent.u.Src.pszFunction = pszFunction;
497 pVM->dbgf.s.DbgEvent.u.Src.pszMessage = pszMessage;
498 return dbgfR3SendEvent(pVM);
499}
500
501
502/**
503 * Send a debugger event which takes the two assertion messages.
504 *
505 * @returns VBox status.
506 * @param pVM The VM handle.
507 * @param enmEvent The event to send.
508 * @param pszMsg1 First assertion message.
509 * @param pszMsg2 Second assertion message.
510 */
511DBGFR3DECL(int) DBGFR3EventAssertion(PVM pVM, DBGFEVENTTYPE enmEvent, const char *pszMsg1, const char *pszMsg2)
512{
513 int rc = dbgfR3EventPrologue(pVM, enmEvent);
514 if (VBOX_FAILURE(rc))
515 return rc;
516
517 /*
518 * Send the event and process the reply communication.
519 */
520 pVM->dbgf.s.DbgEvent.enmType = enmEvent;
521 pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
522 pVM->dbgf.s.DbgEvent.u.Assert.pszMsg1 = pszMsg1;
523 pVM->dbgf.s.DbgEvent.u.Assert.pszMsg2 = pszMsg2;
524 return dbgfR3SendEvent(pVM);
525}
526
527
528/**
529 * Breakpoint was hit somewhere.
530 * Figure out which breakpoint it is and notify the debugger.
531 *
532 * @returns VBox status.
533 * @param pVM The VM handle.
534 * @param enmEvent DBGFEVENT_BREAKPOINT_HYPER or DBGFEVENT_BREAKPOINT.
535 */
536DBGFR3DECL(int) DBGFR3EventBreakpoint(PVM pVM, DBGFEVENTTYPE enmEvent)
537{
538 int rc = dbgfR3EventPrologue(pVM, enmEvent);
539 if (VBOX_FAILURE(rc))
540 return rc;
541
542 /*
543 * Send the event and process the reply communication.
544 */
545 pVM->dbgf.s.DbgEvent.enmType = enmEvent;
546 RTUINT iBp = pVM->dbgf.s.DbgEvent.u.Bp.iBp = pVM->dbgf.s.iActiveBp;
547 pVM->dbgf.s.iActiveBp = ~0U;
548 if (iBp != ~0U)
549 pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_RAW;
550 else
551 {
552 /* REM breakpoints has be been searched for. */
553#if 0 /** @todo get flat PC api! */
554 uint32_t eip = CPUMGetGuestEIP(pVM);
555#else
556 PCPUMCTX pCtx;
557 CPUMQueryGuestCtxPtr(pVM, &pCtx);
558 uint32_t eip = pCtx->eip + pCtx->csHid.u32Base;
559#endif
560 for (iBp = 0; iBp < ELEMENTS(pVM->dbgf.s.aBreakpoints); iBp++)
561 if ( pVM->dbgf.s.aBreakpoints[iBp].enmType == DBGFBPTYPE_REM
562 && pVM->dbgf.s.aBreakpoints[iBp].GCPtr == eip)
563 {
564 pVM->dbgf.s.DbgEvent.u.Bp.iBp = iBp;
565 break;
566 }
567 AssertMsg(pVM->dbgf.s.DbgEvent.u.Bp.iBp != ~0U, ("eip=%08x\n", eip));
568 pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_REM;
569 }
570 return dbgfR3SendEvent(pVM);
571}
572
573
574/**
575 * Waits for the debugger to respond.
576 *
577 * @returns VBox status. (clearify)
578 * @param pVM VM handle.
579 */
580static int dbgfr3VMMWait(PVM pVM)
581{
582 LogFlow(("dbgfr3VMMWait:\n"));
583
584 /** @todo stupid GDT/LDT sync hack. go away! */
585 SELMR3UpdateFromCPUM(pVM);
586 int rcRet = VINF_SUCCESS;
587
588 /*
589 * Waits for the debugger to reply (i.e. issue an command).
590 */
591 for (;;)
592 {
593 /*
594 * Wait.
595 */
596 for (;;)
597 {
598 int rc = RTSemPingWait(&pVM->dbgf.s.PingPong, 250);
599 if (VBOX_SUCCESS(rc))
600 break;
601 if (rc != VERR_TIMEOUT)
602 {
603 LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rc));
604 return rc;
605 }
606
607 if (VM_FF_ISSET(pVM, VM_FF_REQUEST))
608 {
609 LogFlow(("dbgfr3VMMWait: Processes requests...\n"));
610 rc = VMR3ReqProcess(pVM);
611 LogFlow(("dbgfr3VMMWait: VMR3ReqProcess -> %Vrc rcRet=%Vrc\n", rc, rcRet));
612 if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
613 {
614 switch (rc)
615 {
616 case VINF_EM_DBG_BREAKPOINT:
617 case VINF_EM_DBG_STEPPED:
618 case VINF_EM_DBG_STEP:
619 case VINF_EM_DBG_STOP:
620 AssertMsgFailed(("rc=%Vrc\n", rc));
621 break;
622
623 /* return straight away */
624 case VINF_EM_TERMINATE:
625 case VINF_EM_OFF:
626 LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rc));
627 return rc;
628
629 /* remember return code. */
630 default:
631 AssertReleaseMsgFailed(("rc=%Vrc is not in the switch!\n", rc));
632 case VINF_EM_RESET:
633 case VINF_EM_SUSPEND:
634 case VINF_EM_HALT:
635 case VINF_EM_RESUME:
636 case VINF_EM_RESCHEDULE:
637 case VINF_EM_RESCHEDULE_REM:
638 case VINF_EM_RESCHEDULE_RAW:
639 if (rc < rcRet || rcRet == VINF_SUCCESS)
640 rcRet = rc;
641 break;
642 }
643 }
644 else if (VBOX_FAILURE(rc))
645 {
646 LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rc));
647 return rc;
648 }
649 }
650 }
651
652 /*
653 * Process the command.
654 */
655 bool fResumeExecution;
656 DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
657 DBGFCMD enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_NO_COMMAND);
658 int rc = dbgfr3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
659 if (fResumeExecution)
660 {
661 if (VBOX_FAILURE(rc))
662 rcRet = rc;
663 else if ( rc >= VINF_EM_FIRST
664 && rc <= VINF_EM_LAST
665 && (rc < rcRet || rcRet == VINF_SUCCESS))
666 rcRet = rc;
667 LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rcRet));
668 return rcRet;
669 }
670 }
671}
672
673
674/**
675 * Executes command from debugger.
676 * The caller is responsible for waiting or resuming execution based on the
677 * value returned in the *pfResumeExecution indicator.
678 *
679 * @returns VBox status. (clearify!)
680 * @param pVM VM Handle.
681 * @param enmCmd The command in question.
682 * @param pCmdData Pointer to the command data.
683 * @param pfResumeExecution Where to store the resume execution / continue waiting indicator.
684 */
685static int dbgfr3VMMCmd(PVM pVM, DBGFCMD enmCmd, PDBGFCMDDATA pCmdData, bool *pfResumeExecution)
686{
687 bool fSendEvent;
688 bool fResume;
689 int rc = VINF_SUCCESS;
690
691 switch (enmCmd)
692 {
693 /*
694 * Halt is answered by an event say that we've halted.
695 */
696 case DBGFCMD_HALT:
697 {
698 pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_HALT_DONE;
699 pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
700 fSendEvent = true;
701 fResume = false;
702 break;
703 }
704
705
706 /*
707 * Resume is not answered we'll just resume execution.
708 */
709 case DBGFCMD_GO:
710 {
711 fSendEvent = false;
712 fResume = true;
713 break;
714 }
715
716 /** @todo implement (and define) the rest of the commands. */
717
718 /*
719 * Disable breakpoints and stuff.
720 * Send an everythings cool event to the debugger thread and resume execution.
721 */
722 case DBGFCMD_DETACH_DEBUGGER:
723 {
724 pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_DETACH_DONE;
725 pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_OTHER;
726 VM_FF_CLEAR(pVM, VM_FF_DBGF);
727 pVM->dbgf.s.fAttached = false;
728 fSendEvent = true;
729 fResume = true;
730 break;
731 }
732
733 /*
734 * Single step, with trace into.
735 */
736 case DBGFCMD_SINGLE_STEP:
737 {
738 Log2(("Single step\n"));
739 rc = VINF_EM_DBG_STEP;
740 pVM->dbgf.s.fSingleSteppingRaw = true;
741 fSendEvent = false;
742 fResume = true;
743 break;
744 }
745
746 /*
747 * Default is to send an invalid command event.
748 */
749 default:
750 {
751 pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_INVALID_COMMAND;
752 pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
753 fSendEvent = true;
754 fResume = false;
755 break;
756 }
757 }
758
759 /*
760 * Send pending event.
761 */
762 if (fSendEvent)
763 {
764 Log2(("DBGF: Emulation thread: sending event %d\n", pVM->dbgf.s.DbgEvent.enmType));
765 int rc2 = RTSemPing(&pVM->dbgf.s.PingPong);
766 if (VBOX_FAILURE(rc2))
767 {
768 AssertRC(rc2);
769 *pfResumeExecution = true;
770 return rc2;
771 }
772 }
773
774 /*
775 * Return.
776 */
777 *pfResumeExecution = fResume;
778 return rc;
779}
780
781
782
783
784/**
785 * Attaches a debugger to the specified VM.
786 *
787 * Only one debugger at a time.
788 *
789 * @returns VBox status code.
790 * @param pVM VM Handle.
791 */
792DBGFR3DECL(int) DBGFR3Attach(PVM pVM)
793{
794 /*
795 * Check if already attached.
796 */
797 if (pVM->dbgf.s.fAttached)
798 {
799 AssertMsgFailed(("Already attached\n"));
800 return VERR_DBGF_ALREADY_ATTACHED;
801 }
802
803 /*
804 * Create the Ping-Pong structure.
805 */
806 int rc = RTSemPingPongInit(&pVM->dbgf.s.PingPong);
807 if (rc)
808 return rc;
809
810 /*
811 * Set the attached flag.
812 */
813 pVM->dbgf.s.fAttached = true;
814 return VINF_SUCCESS;
815}
816
817
818/**
819 * Detaches a debugger from the specified VM.
820 *
821 * Caller must be attached to the VM.
822 *
823 * @returns VBox status code.
824 * @param pVM VM Handle.
825 */
826DBGFR3DECL(int) DBGFR3Detach(PVM pVM)
827{
828 /*
829 * Check if attached.
830 */
831 if (!pVM->dbgf.s.fAttached)
832 {
833 AssertMsgFailed(("Not attached to VM!\n"));
834 return VERR_DBGF_NOT_ATTACHED;
835 }
836
837 /*
838 * Send detach command.
839 */
840 if (pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG)
841 {
842 dbgfr3SetCmd(pVM, DBGFCMD_DETACH_DEBUGGER);
843 int rc = RTSemPong(&pVM->dbgf.s.PingPong);
844 if (VBOX_FAILURE(rc))
845 {
846 AssertMsgFailed(("Failed to signal emulation thread. rc=%d\n", rc));
847 return rc;
848 }
849 }
850 else
851 dbgfr3SetCmd(pVM, DBGFCMD_DETACH_DEBUGGER);
852
853 /*
854 * Wait for the ok event.
855 */
856 PCDBGFEVENT pEvent;
857 int rc = DBGFR3EventWait(pVM, RT_INDEFINITE_WAIT, &pEvent);
858 if (VBOX_FAILURE(rc))
859 {
860 AssertMsgFailed(("Wait on detach command failed, rc=%d\n", rc));
861 return rc;
862 }
863
864 /*
865 * Destroy the ping-pong construct and return.
866 */
867 pVM->dbgf.s.fAttached = false;
868 RTThreadSleep(10);
869 rc = RTSemPingPongDestroy(&pVM->dbgf.s.PingPong);
870 AssertRC(rc);
871
872 return VINF_SUCCESS;
873}
874
875
876
877/**
878 * Wait for a debug event.
879 *
880 * @returns VBox status. Will not return VBOX_INTERRUPTED.
881 * @param pVM VM handle.
882 * @param cMillies Number of millies to wait.
883 * @param ppEvent Where to store the event pointer.
884 */
885DBGFR3DECL(int) DBGFR3EventWait(PVM pVM, unsigned cMillies, PCDBGFEVENT *ppEvent)
886{
887 /*
888 * Check state.
889 */
890 if (!pVM->dbgf.s.fAttached)
891 {
892 AssertMsgFailed(("Not attached to VM!\n"));
893 return VERR_DBGF_NOT_ATTACHED;
894 }
895 *ppEvent = NULL;
896
897 /*
898 * Wait.
899 */
900 int rc = RTSemPongWait(&pVM->dbgf.s.PingPong, cMillies);
901 if (VBOX_SUCCESS(rc))
902 {
903 *ppEvent = &pVM->dbgf.s.DbgEvent;
904 Log2(("DBGF: Debugger thread: receiving event %d\n", (*ppEvent)->enmType));
905 return VINF_SUCCESS;
906 }
907
908 return rc;
909}
910
911
912/**
913 * Halts VM execution.
914 *
915 * After calling this the VM isn't actually halted till an DBGFEVENT_HALT_DONE
916 * arrives. Until that time it's not possible to issue any new commands.
917 *
918 * @returns VBox status.
919 * @param pVM VM handle.
920 */
921DBGFR3DECL(int) DBGFR3Halt(PVM pVM)
922{
923 /*
924 * Check state.
925 */
926 if (!pVM->dbgf.s.fAttached)
927 {
928 AssertMsgFailed(("Not attached to VM!\n"));
929 return VERR_DBGF_NOT_ATTACHED;
930 }
931 if ( pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG
932 || pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED)
933 return VWRN_DBGF_ALREADY_HALTED;
934
935 /*
936 * Send command.
937 */
938 dbgfr3SetCmd(pVM, DBGFCMD_HALT);
939
940 return VINF_SUCCESS;
941}
942
943
944/**
945 * Checks if the VM is halted by the debugger.
946 *
947 * @returns True if halted.
948 * @returns False if not halted.
949 * @param pVM VM handle.
950 */
951DBGFR3DECL(bool) DBGFR3IsHalted(PVM pVM)
952{
953 AssertMsg(pVM->dbgf.s.fAttached, ("Not attached to VM!\n"));
954
955 RTPINGPONGSPEAKER enmSpeaker = pVM->dbgf.s.PingPong.enmSpeaker;
956 return pVM->dbgf.s.fAttached
957 && ( enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED
958 || enmSpeaker == RTPINGPONGSPEAKER_PONG);
959}
960
961
962/**
963 * Checks if the the debugger can wait for events or not.
964 *
965 * This function is only used by lazy, multiplexing debuggers. :-)
966 *
967 * @returns True if waitable.
968 * @returns False if not waitable.
969 * @param pVM VM handle.
970 */
971DBGFR3DECL(bool) DBGFR3CanWait(PVM pVM)
972{
973 AssertMsg(pVM->dbgf.s.fAttached, ("Not attached to VM!\n"));
974
975 RTPINGPONGSPEAKER enmSpeaker = pVM->dbgf.s.PingPong.enmSpeaker;
976 return pVM->dbgf.s.fAttached
977 && ( enmSpeaker == RTPINGPONGSPEAKER_PING
978 || enmSpeaker == RTPINGPONGSPEAKER_PING_SIGNALED
979 || enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED);
980}
981
982
983/**
984 * Resumes VM execution.
985 *
986 * There is no receipt event on this command.
987 *
988 * @returns VBox status.
989 * @param pVM VM handle.
990 */
991DBGFR3DECL(int) DBGFR3Resume(PVM pVM)
992{
993 /*
994 * Check state.
995 */
996 if (!pVM->dbgf.s.fAttached)
997 {
998 AssertMsgFailed(("Not attached to VM!\n"));
999 return VERR_DBGF_NOT_ATTACHED;
1000 }
1001 if (pVM->dbgf.s.PingPong.enmSpeaker != RTPINGPONGSPEAKER_PONG)
1002 {
1003 AssertMsgFailed(("Speaking out of turn!\n"));
1004 return VERR_SEM_OUT_OF_TURN;
1005 }
1006
1007 /*
1008 * Send the ping back to the emulation thread telling it to run.
1009 */
1010 dbgfr3SetCmd(pVM, DBGFCMD_GO);
1011 int rc = RTSemPong(&pVM->dbgf.s.PingPong);
1012 AssertRC(rc);
1013
1014 return rc;
1015}
1016
1017
1018/**
1019 * Step Into.
1020 *
1021 * A single step event is generated from this command.
1022 * The current implementation is not reliable, so don't rely on the event comming.
1023 *
1024 * @returns VBox status.
1025 * @param pVM VM handle.
1026 */
1027DBGFR3DECL(int) DBGFR3Step(PVM pVM)
1028{
1029 /*
1030 * Check state.
1031 */
1032 if (!pVM->dbgf.s.fAttached)
1033 {
1034 AssertMsgFailed(("Not attached to VM!\n"));
1035 return VERR_DBGF_NOT_ATTACHED;
1036 }
1037 if (pVM->dbgf.s.PingPong.enmSpeaker != RTPINGPONGSPEAKER_PONG)
1038 {
1039 AssertMsgFailed(("Speaking out of turn!\n"));
1040 return VERR_SEM_OUT_OF_TURN;
1041 }
1042
1043 /*
1044 * Send the ping back to the emulation thread telling it to run.
1045 */
1046 dbgfr3SetCmd(pVM, DBGFCMD_SINGLE_STEP);
1047 int rc = RTSemPong(&pVM->dbgf.s.PingPong);
1048 AssertRC(rc);
1049 return rc;
1050}
1051
1052
1053/**
1054 * Call this to single step rawmode or recompiled mode.
1055 *
1056 * You must pass down the return code to the EM loop! That's
1057 * where the actual single stepping take place (at least in the
1058 * current implementation).
1059 *
1060 * @returns VINF_EM_DBG_STEP
1061 * @thread EMT
1062 */
1063DBGFR3DECL(int) DBGFR3PrgStep(PVM pVM)
1064{
1065 VM_ASSERT_EMT(pVM);
1066
1067 pVM->dbgf.s.fSingleSteppingRaw = true;
1068 return VINF_EM_DBG_STEP;
1069}
1070
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use