VirtualBox

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

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette