VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp@ 61786

Last change on this file since 61786 was 61786, checked in by vboxsync, 8 years ago

Main/MachineDebugger: Pause the VM before querying the guest stack or we risk running into deadlocks or inconsistent stacks
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 48.0 KB
Line 
1/* $Id: MachineDebuggerImpl.cpp 61786 2016-06-21 09:27:42Z vboxsync $ */
2/** @file
3 * VBox IMachineDebugger COM class implementation (VBoxC).
4 */
5
6/*
7 * Copyright (C) 2006-2013 Oracle Corporation
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/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include "MachineDebuggerImpl.h"
23
24#include "Global.h"
25#include "ConsoleImpl.h"
26
27#include "AutoCaller.h"
28#include "Logging.h"
29
30#include <VBox/vmm/em.h>
31#include <VBox/vmm/patm.h>
32#include <VBox/vmm/csam.h>
33#include <VBox/vmm/uvm.h>
34#include <VBox/vmm/tm.h>
35#include <VBox/vmm/hm.h>
36#include <VBox/err.h>
37#include <iprt/cpp/utils.h>
38
39
40// constructor / destructor
41/////////////////////////////////////////////////////////////////////////////
42
43MachineDebugger::MachineDebugger()
44 : mParent(NULL)
45{
46}
47
48MachineDebugger::~MachineDebugger()
49{
50}
51
52HRESULT MachineDebugger::FinalConstruct()
53{
54 unconst(mParent) = NULL;
55 return BaseFinalConstruct();
56}
57
58void MachineDebugger::FinalRelease()
59{
60 uninit();
61 BaseFinalRelease();
62}
63
64// public initializer/uninitializer for internal purposes only
65/////////////////////////////////////////////////////////////////////////////
66
67/**
68 * Initializes the machine debugger object.
69 *
70 * @returns COM result indicator
71 * @param aParent handle of our parent object
72 */
73HRESULT MachineDebugger::init (Console *aParent)
74{
75 LogFlowThisFunc(("aParent=%p\n", aParent));
76
77 ComAssertRet(aParent, E_INVALIDARG);
78
79 /* Enclose the state transition NotReady->InInit->Ready */
80 AutoInitSpan autoInitSpan(this);
81 AssertReturn(autoInitSpan.isOk(), E_FAIL);
82
83 unconst(mParent) = aParent;
84
85 for (unsigned i = 0; i < RT_ELEMENTS(maiQueuedEmExecPolicyParams); i++)
86 maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
87 mSingleStepQueued = ~0;
88 mRecompileUserQueued = ~0;
89 mRecompileSupervisorQueued = ~0;
90 mPatmEnabledQueued = ~0;
91 mCsamEnabledQueued = ~0;
92 mLogEnabledQueued = ~0;
93 mVirtualTimeRateQueued = ~0;
94 mFlushMode = false;
95
96 /* Confirm a successful initialization */
97 autoInitSpan.setSucceeded();
98
99 return S_OK;
100}
101
102/**
103 * Uninitializes the instance and sets the ready flag to FALSE.
104 * Called either from FinalRelease() or by the parent when it gets destroyed.
105 */
106void MachineDebugger::uninit()
107{
108 LogFlowThisFunc(("\n"));
109
110 /* Enclose the state transition Ready->InUninit->NotReady */
111 AutoUninitSpan autoUninitSpan(this);
112 if (autoUninitSpan.uninitDone())
113 return;
114
115 unconst(mParent) = NULL;
116 mFlushMode = false;
117}
118
119// IMachineDebugger properties
120/////////////////////////////////////////////////////////////////////////////
121
122/**
123 * Returns the current singlestepping flag.
124 *
125 * @returns COM status code
126 * @param a_fEnabled Where to store the result.
127 */
128HRESULT MachineDebugger::getSingleStep(BOOL *aSingleStep)
129{
130 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
131 Console::SafeVMPtr ptrVM(mParent);
132 HRESULT hrc = ptrVM.rc();
133 if (SUCCEEDED(hrc))
134 {
135 /** @todo */
136 ReturnComNotImplemented();
137 }
138 return hrc;
139}
140
141/**
142 * Sets the singlestepping flag.
143 *
144 * @returns COM status code
145 * @param a_fEnable The new state.
146 */
147HRESULT MachineDebugger::setSingleStep(BOOL aSingleStep)
148{
149 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
150 Console::SafeVMPtr ptrVM(mParent);
151 HRESULT hrc = ptrVM.rc();
152 if (SUCCEEDED(hrc))
153 {
154 /** @todo */
155 ReturnComNotImplemented();
156 }
157 return hrc;
158}
159
160/**
161 * Internal worker for getting an EM executable policy setting.
162 *
163 * @returns COM status code.
164 * @param enmPolicy Which EM policy.
165 * @param pfEnforced Where to return the policy setting.
166 */
167HRESULT MachineDebugger::i_getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced)
168{
169 CheckComArgOutPointerValid(pfEnforced);
170
171 AutoCaller autoCaller(this);
172 HRESULT hrc = autoCaller.rc();
173 if (SUCCEEDED(hrc))
174 {
175 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
176 if (i_queueSettings())
177 *pfEnforced = maiQueuedEmExecPolicyParams[enmPolicy] == 1;
178 else
179 {
180 bool fEnforced = false;
181 Console::SafeVMPtrQuiet ptrVM(mParent);
182 hrc = ptrVM.rc();
183 if (SUCCEEDED(hrc))
184 EMR3QueryExecutionPolicy(ptrVM.rawUVM(), enmPolicy, &fEnforced);
185 *pfEnforced = fEnforced;
186 }
187 }
188 return hrc;
189}
190
191/**
192 * Internal worker for setting an EM executable policy.
193 *
194 * @returns COM status code.
195 * @param enmPolicy Which policy to change.
196 * @param fEnforce Whether to enforce the policy or not.
197 */
198HRESULT MachineDebugger::i_setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce)
199{
200 AutoCaller autoCaller(this);
201 HRESULT hrc = autoCaller.rc();
202 if (SUCCEEDED(hrc))
203 {
204 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
205 if (i_queueSettings())
206 maiQueuedEmExecPolicyParams[enmPolicy] = fEnforce ? 1 : 0;
207 else
208 {
209 Console::SafeVMPtrQuiet ptrVM(mParent);
210 hrc = ptrVM.rc();
211 if (SUCCEEDED(hrc))
212 {
213 int vrc = EMR3SetExecutionPolicy(ptrVM.rawUVM(), enmPolicy, fEnforce != FALSE);
214 if (RT_FAILURE(vrc))
215 hrc = setError(VBOX_E_VM_ERROR, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
216 }
217 }
218 }
219 return hrc;
220}
221
222/**
223 * Returns the current recompile user mode code flag.
224 *
225 * @returns COM status code
226 * @param a_fEnabled address of result variable
227 */
228HRESULT MachineDebugger::getRecompileUser(BOOL *aRecompileUser)
229{
230 return i_getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aRecompileUser);
231}
232
233/**
234 * Sets the recompile user mode code flag.
235 *
236 * @returns COM status
237 * @param aEnable new user mode code recompile flag.
238 */
239HRESULT MachineDebugger::setRecompileUser(BOOL aRecompileUser)
240{
241 LogFlowThisFunc(("enable=%d\n", aRecompileUser));
242 return i_setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aRecompileUser);
243}
244
245/**
246 * Returns the current recompile supervisor code flag.
247 *
248 * @returns COM status code
249 * @param aEnabled address of result variable
250 */
251HRESULT MachineDebugger::getRecompileSupervisor(BOOL *aRecompileSupervisor)
252{
253 return i_getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aRecompileSupervisor);
254}
255
256/**
257 * Sets the new recompile supervisor code flag.
258 *
259 * @returns COM status code
260 * @param aEnable new recompile supervisor code flag
261 */
262HRESULT MachineDebugger::setRecompileSupervisor(BOOL aRecompileSupervisor)
263{
264 LogFlowThisFunc(("enable=%d\n", aRecompileSupervisor));
265 return i_setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aRecompileSupervisor);
266}
267
268/**
269 * Returns the current execute-all-in-IEM setting.
270 *
271 * @returns COM status code
272 * @param aEnabled Address of result variable.
273 */
274HRESULT MachineDebugger::getExecuteAllInIEM(BOOL *aExecuteAllInIEM)
275{
276 return i_getEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aExecuteAllInIEM);
277}
278
279/**
280 * Changes the execute-all-in-IEM setting.
281 *
282 * @returns COM status code
283 * @param aEnable New setting.
284 */
285HRESULT MachineDebugger::setExecuteAllInIEM(BOOL aExecuteAllInIEM)
286{
287 LogFlowThisFunc(("enable=%d\n", aExecuteAllInIEM));
288 return i_setEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aExecuteAllInIEM);
289}
290
291/**
292 * Returns the current patch manager enabled flag.
293 *
294 * @returns COM status code
295 * @param aEnabled address of result variable
296 */
297HRESULT MachineDebugger::getPATMEnabled(BOOL *aPATMEnabled)
298{
299#ifdef VBOX_WITH_RAW_MODE
300 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
301
302 Console::SafeVMPtrQuiet ptrVM(mParent);
303 if (ptrVM.isOk())
304 *aPATMEnabled = PATMR3IsEnabled (ptrVM.rawUVM());
305 else
306#endif
307 *aPATMEnabled = false;
308
309 return S_OK;
310}
311
312/**
313 * Set the new patch manager enabled flag.
314 *
315 * @returns COM status code
316 * @param aEnable new patch manager enabled flag
317 */
318HRESULT MachineDebugger::setPATMEnabled(BOOL aPATMEnabled)
319{
320 LogFlowThisFunc(("enable=%d\n", aPATMEnabled));
321
322#ifdef VBOX_WITH_RAW_MODE
323 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
324
325 if (i_queueSettings())
326 {
327 // queue the request
328 mPatmEnabledQueued = aPATMEnabled;
329 return S_OK;
330 }
331
332 Console::SafeVMPtr ptrVM(mParent);
333 if (FAILED(ptrVM.rc()))
334 return ptrVM.rc();
335
336 int vrc = PATMR3AllowPatching(ptrVM.rawUVM(), RT_BOOL(aPATMEnabled));
337 if (RT_FAILURE(vrc))
338 return setError(VBOX_E_VM_ERROR, tr("PATMR3AllowPatching returned %Rrc"), vrc);
339
340#else /* !VBOX_WITH_RAW_MODE */
341 if (aPATMEnabled)
342 return setError(VBOX_E_VM_ERROR, tr("PATM not present"), VERR_NOT_SUPPORTED);
343#endif /* !VBOX_WITH_RAW_MODE */
344 return S_OK;
345}
346
347/**
348 * Returns the current code scanner enabled flag.
349 *
350 * @returns COM status code
351 * @param aEnabled address of result variable
352 */
353HRESULT MachineDebugger::getCSAMEnabled(BOOL *aCSAMEnabled)
354{
355#ifdef VBOX_WITH_RAW_MODE
356 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
357
358 Console::SafeVMPtrQuiet ptrVM(mParent);
359
360 if (ptrVM.isOk())
361 *aCSAMEnabled = CSAMR3IsEnabled(ptrVM.rawUVM());
362 else
363#endif /* VBOX_WITH_RAW_MODE */
364 *aCSAMEnabled = false;
365
366 return S_OK;
367}
368
369/**
370 * Sets the new code scanner enabled flag.
371 *
372 * @returns COM status code
373 * @param aEnable new code scanner enabled flag
374 */
375HRESULT MachineDebugger::setCSAMEnabled(BOOL aCSAMEnabled)
376{
377 LogFlowThisFunc(("enable=%d\n", aCSAMEnabled));
378
379#ifdef VBOX_WITH_RAW_MODE
380 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
381
382 if (i_queueSettings())
383 {
384 // queue the request
385 mCsamEnabledQueued = aCSAMEnabled;
386 return S_OK;
387 }
388
389 Console::SafeVMPtr ptrVM(mParent);
390 if (FAILED(ptrVM.rc()))
391 return ptrVM.rc();
392
393 int vrc = CSAMR3SetScanningEnabled(ptrVM.rawUVM(), aCSAMEnabled != FALSE);
394 if (RT_FAILURE(vrc))
395 return setError(VBOX_E_VM_ERROR, tr("CSAMR3SetScanningEnabled returned %Rrc"), vrc);
396
397#else /* !VBOX_WITH_RAW_MODE */
398 if (aCSAMEnabled)
399 return setError(VBOX_E_VM_ERROR, tr("CASM not present"), VERR_NOT_SUPPORTED);
400#endif /* !VBOX_WITH_RAW_MODE */
401 return S_OK;
402}
403
404/**
405 * Returns the log enabled / disabled status.
406 *
407 * @returns COM status code
408 * @param aLogEnabled address of result variable
409 */
410HRESULT MachineDebugger::getLogEnabled(BOOL *aLogEnabled)
411{
412#ifdef LOG_ENABLED
413 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
414
415 const PRTLOGGER pLogInstance = RTLogDefaultInstance();
416 *aLogEnabled = pLogInstance && !(pLogInstance->fFlags & RTLOGFLAGS_DISABLED);
417#else
418 *aLogEnabled = false;
419#endif
420
421 return S_OK;
422}
423
424/**
425 * Enables or disables logging.
426 *
427 * @returns COM status code
428 * @param aLogEnabled The new code log state.
429 */
430HRESULT MachineDebugger::setLogEnabled(BOOL aLogEnabled)
431{
432 LogFlowThisFunc(("aLogEnabled=%d\n", aLogEnabled));
433
434 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
435
436 if (i_queueSettings())
437 {
438 // queue the request
439 mLogEnabledQueued = aLogEnabled;
440 return S_OK;
441 }
442
443 Console::SafeVMPtr ptrVM(mParent);
444 if (FAILED(ptrVM.rc())) return ptrVM.rc();
445
446#ifdef LOG_ENABLED
447 int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), aLogEnabled ? "enabled" : "disabled");
448 if (RT_FAILURE(vrc))
449 {
450 /** @todo handle error code. */
451 }
452#endif
453
454 return S_OK;
455}
456
457HRESULT MachineDebugger::i_logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr,
458 const char *pszLogGetStr, Utf8Str *pstrSettings)
459{
460 /* Make sure the VM is powered up. */
461 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
462 Console::SafeVMPtr ptrVM(mParent);
463 HRESULT hrc = ptrVM.rc();
464 if (FAILED(hrc))
465 return hrc;
466
467 /* Make sure we've got a logger. */
468 if (!pLogger)
469 {
470 *pstrSettings = "";
471 return S_OK;
472 }
473
474 /* Do the job. */
475 size_t cbBuf = _1K;
476 for (;;)
477 {
478 char *pszBuf = (char *)RTMemTmpAlloc(cbBuf);
479 AssertReturn(pszBuf, E_OUTOFMEMORY);
480 int vrc = pstrSettings->reserveNoThrow(cbBuf);
481 if (RT_SUCCESS(vrc))
482 {
483 vrc = pfnLogGetStr(pLogger, pstrSettings->mutableRaw(), cbBuf);
484 if (RT_SUCCESS(vrc))
485 {
486 pstrSettings->jolt();
487 return S_OK;
488 }
489 *pstrSettings = "";
490 AssertReturn(vrc == VERR_BUFFER_OVERFLOW, setError(VBOX_E_IPRT_ERROR, tr("%s returned %Rrc"), pszLogGetStr, vrc));
491 }
492 else
493 return E_OUTOFMEMORY;
494
495 /* try again with a bigger buffer. */
496 cbBuf *= 2;
497 AssertReturn(cbBuf <= _256K, setError(E_FAIL, tr("%s returns too much data"), pszLogGetStr));
498 }
499}
500
501HRESULT MachineDebugger::getLogDbgFlags(com::Utf8Str &aLogDbgFlags)
502{
503 return i_logStringProps(RTLogGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", &aLogDbgFlags);
504}
505
506HRESULT MachineDebugger::getLogDbgGroups(com::Utf8Str &aLogDbgGroups)
507{
508 return i_logStringProps(RTLogGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", &aLogDbgGroups);
509}
510
511HRESULT MachineDebugger::getLogDbgDestinations(com::Utf8Str &aLogDbgDestinations)
512{
513 return i_logStringProps(RTLogGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", &aLogDbgDestinations);
514}
515
516HRESULT MachineDebugger::getLogRelFlags(com::Utf8Str &aLogRelFlags)
517{
518 return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", &aLogRelFlags);
519}
520
521HRESULT MachineDebugger::getLogRelGroups(com::Utf8Str &aLogRelGroups)
522{
523 return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", &aLogRelGroups);
524}
525
526HRESULT MachineDebugger::getLogRelDestinations(com::Utf8Str &aLogRelDestinations)
527{
528 return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", &aLogRelDestinations);
529}
530
531/**
532 * Returns the current hardware virtualization flag.
533 *
534 * @returns COM status code
535 * @param aEnabled address of result variable
536 */
537HRESULT MachineDebugger::getHWVirtExEnabled(BOOL *aHWVirtExEnabled)
538{
539 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
540
541 Console::SafeVMPtrQuiet ptrVM(mParent);
542
543 if (ptrVM.isOk())
544 *aHWVirtExEnabled = HMR3IsEnabled(ptrVM.rawUVM());
545 else
546 *aHWVirtExEnabled = false;
547
548 return S_OK;
549}
550
551/**
552 * Returns the current nested paging flag.
553 *
554 * @returns COM status code
555 * @param aEnabled address of result variable
556 */
557HRESULT MachineDebugger::getHWVirtExNestedPagingEnabled(BOOL *aHWVirtExNestedPagingEnabled)
558{
559 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
560
561 Console::SafeVMPtrQuiet ptrVM(mParent);
562
563 if (ptrVM.isOk())
564 *aHWVirtExNestedPagingEnabled = HMR3IsNestedPagingActive(ptrVM.rawUVM());
565 else
566 *aHWVirtExNestedPagingEnabled = false;
567
568 return S_OK;
569}
570
571/**
572 * Returns the current VPID flag.
573 *
574 * @returns COM status code
575 * @param aEnabled address of result variable
576 */
577HRESULT MachineDebugger::getHWVirtExVPIDEnabled(BOOL *aHWVirtExVPIDEnabled)
578{
579 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
580
581 Console::SafeVMPtrQuiet ptrVM(mParent);
582
583 if (ptrVM.isOk())
584 *aHWVirtExVPIDEnabled = HMR3IsVpidActive(ptrVM.rawUVM());
585 else
586 *aHWVirtExVPIDEnabled = false;
587
588 return S_OK;
589}
590
591/**
592 * Returns the current unrestricted execution setting.
593 *
594 * @returns COM status code
595 * @param aEnabled address of result variable
596 */
597HRESULT MachineDebugger::getHWVirtExUXEnabled(BOOL *aHWVirtExUXEnabled)
598{
599 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
600
601 Console::SafeVMPtrQuiet ptrVM(mParent);
602
603 if (ptrVM.isOk())
604 *aHWVirtExUXEnabled = HMR3IsUXActive(ptrVM.rawUVM());
605 else
606 *aHWVirtExUXEnabled = false;
607
608 return S_OK;
609}
610
611HRESULT MachineDebugger::getOSName(com::Utf8Str &aOSName)
612{
613 LogFlowThisFunc(("\n"));
614 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
615 Console::SafeVMPtr ptrVM(mParent);
616 HRESULT hrc = ptrVM.rc();
617 if (SUCCEEDED(hrc))
618 {
619 /*
620 * Do the job and try convert the name.
621 */
622 char szName[64];
623 int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), szName, sizeof(szName), NULL, 0);
624 if (RT_SUCCESS(vrc))
625 {
626 try
627 {
628 Bstr bstrName(szName);
629 aOSName = Utf8Str(bstrName);
630 }
631 catch (std::bad_alloc)
632 {
633 hrc = E_OUTOFMEMORY;
634 }
635 }
636 else
637 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
638 }
639 return hrc;
640}
641
642HRESULT MachineDebugger::getOSVersion(com::Utf8Str &aOSVersion)
643{
644 LogFlowThisFunc(("\n"));
645 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
646 Console::SafeVMPtr ptrVM(mParent);
647 HRESULT hrc = ptrVM.rc();
648 if (SUCCEEDED(hrc))
649 {
650 /*
651 * Do the job and try convert the name.
652 */
653 char szVersion[256];
654 int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), NULL, 0, szVersion, sizeof(szVersion));
655 if (RT_SUCCESS(vrc))
656 {
657 try
658 {
659 Bstr bstrVersion(szVersion);
660 aOSVersion = Utf8Str(bstrVersion);
661 }
662 catch (std::bad_alloc)
663 {
664 hrc = E_OUTOFMEMORY;
665 }
666 }
667 else
668 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
669 }
670 return hrc;
671}
672
673/**
674 * Returns the current PAE flag.
675 *
676 * @returns COM status code
677 * @param aEnabled address of result variable
678 */
679HRESULT MachineDebugger::getPAEEnabled(BOOL *aPAEEnabled)
680{
681 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
682
683 Console::SafeVMPtrQuiet ptrVM(mParent);
684
685 if (ptrVM.isOk())
686 {
687 uint32_t cr4;
688 int rc = DBGFR3RegCpuQueryU32(ptrVM.rawUVM(), 0 /*idCpu*/, DBGFREG_CR4, &cr4); AssertRC(rc);
689 *aPAEEnabled = RT_BOOL(cr4 & X86_CR4_PAE);
690 }
691 else
692 *aPAEEnabled = false;
693
694 return S_OK;
695}
696
697/**
698 * Returns the current virtual time rate.
699 *
700 * @returns COM status code.
701 * @param a_puPct Where to store the rate.
702 */
703HRESULT MachineDebugger::getVirtualTimeRate(ULONG *aVirtualTimeRate)
704{
705 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
706
707 Console::SafeVMPtr ptrVM(mParent);
708 HRESULT hrc = ptrVM.rc();
709 if (SUCCEEDED(hrc))
710 *aVirtualTimeRate = TMR3GetWarpDrive(ptrVM.rawUVM());
711
712 return hrc;
713}
714
715/**
716 * Returns the current virtual time rate.
717 *
718 * @returns COM status code.
719 * @param aPct Where to store the rate.
720 */
721HRESULT MachineDebugger::setVirtualTimeRate(ULONG aVirtualTimeRate)
722{
723 HRESULT hrc = S_OK;
724
725 if (aVirtualTimeRate < 2 || aVirtualTimeRate > 20000)
726 return setError(E_INVALIDARG, tr("%u is out of range [2..20000]"), aVirtualTimeRate);
727
728 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
729 if (i_queueSettings())
730 mVirtualTimeRateQueued = aVirtualTimeRate;
731 else
732 {
733 Console::SafeVMPtr ptrVM(mParent);
734 hrc = ptrVM.rc();
735 if (SUCCEEDED(hrc))
736 {
737 int vrc = TMR3SetWarpDrive(ptrVM.rawUVM(), aVirtualTimeRate);
738 if (RT_FAILURE(vrc))
739 hrc = setError(VBOX_E_VM_ERROR, tr("TMR3SetWarpDrive(, %u) failed with rc=%Rrc"), aVirtualTimeRate, vrc);
740 }
741 }
742
743 return hrc;
744}
745
746/**
747 * Hack for getting the user mode VM handle (UVM).
748 *
749 * This is only temporary (promise) while prototyping the debugger.
750 *
751 * @returns COM status code
752 * @param a_u64Vm Where to store the vm handle. Since there is no
753 * uintptr_t in COM, we're using the max integer.
754 * (No, ULONG is not pointer sized!)
755 * @remarks The returned handle must be passed to VMR3ReleaseUVM()!
756 * @remarks Prior to 4.3 this returned PVM.
757 */
758HRESULT MachineDebugger::getVM(LONG64 *aVM)
759{
760 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
761
762 Console::SafeVMPtr ptrVM(mParent);
763 HRESULT hrc = ptrVM.rc();
764 if (SUCCEEDED(hrc))
765 {
766 VMR3RetainUVM(ptrVM.rawUVM());
767 *aVM = (intptr_t)ptrVM.rawUVM();
768 }
769
770 /*
771 * Note! ptrVM protection provided by SafeVMPtr is no long effective
772 * after we return from this method.
773 */
774 return hrc;
775}
776
777// IMachineDebugger methods
778/////////////////////////////////////////////////////////////////////////////
779
780HRESULT MachineDebugger::dumpGuestCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
781{
782 if (aCompression.length())
783 return setError(E_INVALIDARG, tr("The compression parameter must be empty"));
784
785 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
786 Console::SafeVMPtr ptrVM(mParent);
787 HRESULT hrc = ptrVM.rc();
788 if (SUCCEEDED(hrc))
789 {
790 int vrc = DBGFR3CoreWrite(ptrVM.rawUVM(), aFilename.c_str(), false /*fReplaceFile*/);
791 if (RT_SUCCESS(vrc))
792 hrc = S_OK;
793 else
794 hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
795 }
796
797 return hrc;
798}
799
800HRESULT MachineDebugger::dumpHostProcessCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
801{
802 ReturnComNotImplemented();
803}
804
805/**
806 * Debug info string buffer formatter.
807 */
808typedef struct MACHINEDEBUGGERINOFHLP
809{
810 /** The core info helper structure. */
811 DBGFINFOHLP Core;
812 /** Pointer to the buffer. */
813 char *pszBuf;
814 /** The size of the buffer. */
815 size_t cbBuf;
816 /** The offset into the buffer */
817 size_t offBuf;
818 /** Indicates an out-of-memory condition. */
819 bool fOutOfMemory;
820} MACHINEDEBUGGERINOFHLP;
821/** Pointer to a Debug info string buffer formatter. */
822typedef MACHINEDEBUGGERINOFHLP *PMACHINEDEBUGGERINOFHLP;
823
824
825/**
826 * @callback_method_impl{FNRTSTROUTPUT}
827 */
828static DECLCALLBACK(size_t) MachineDebuggerInfoOutput(void *pvArg, const char *pachChars, size_t cbChars)
829{
830 PMACHINEDEBUGGERINOFHLP pHlp = (PMACHINEDEBUGGERINOFHLP)pvArg;
831
832 /*
833 * Grow the buffer if required.
834 */
835 size_t const cbRequired = cbChars + pHlp->offBuf + 1;
836 if (cbRequired > pHlp->cbBuf)
837 {
838 if (RT_UNLIKELY(pHlp->fOutOfMemory))
839 return 0;
840
841 size_t cbBufNew = pHlp->cbBuf * 2;
842 if (cbRequired > cbBufNew)
843 cbBufNew = RT_ALIGN_Z(cbRequired, 256);
844 void *pvBufNew = RTMemRealloc(pHlp->pszBuf, cbBufNew);
845 if (RT_UNLIKELY(!pvBufNew))
846 {
847 pHlp->fOutOfMemory = true;
848 RTMemFree(pHlp->pszBuf);
849 pHlp->pszBuf = NULL;
850 pHlp->cbBuf = 0;
851 pHlp->offBuf = 0;
852 return 0;
853 }
854
855 pHlp->pszBuf = (char *)pvBufNew;
856 pHlp->cbBuf = cbBufNew;
857 }
858
859 /*
860 * Copy the bytes into the buffer and terminate it.
861 */
862 memcpy(&pHlp->pszBuf[pHlp->offBuf], pachChars, cbChars);
863 pHlp->offBuf += cbChars;
864 pHlp->pszBuf[pHlp->offBuf] = '\0';
865 Assert(pHlp->offBuf < pHlp->cbBuf);
866 return cbChars;
867}
868
869/**
870 * @interface_method_impl{DBGFINFOHLP,pfnPrintfV}
871 */
872static DECLCALLBACK(void) MachineDebuggerInfoPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list va)
873{
874 RTStrFormatV(MachineDebuggerInfoOutput, (void *)pHlp, NULL, NULL, pszFormat, va);
875}
876
877/**
878 * @interface_method_impl{DBGFINFOHLP,pfnPrintf}
879 */
880static DECLCALLBACK(void) MachineDebuggerInfoPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
881{
882 va_list va;
883 va_start(va, pszFormat);
884 MachineDebuggerInfoPrintfV(pHlp, pszFormat, va);
885 va_end(va);
886}
887
888/**
889 * Initializes the debug info string buffer formatter
890 *
891 * @param pHlp The help structure to init.
892 */
893static void MachineDebuggerInfoInit(PMACHINEDEBUGGERINOFHLP pHlp)
894{
895 pHlp->Core.pfnPrintf = MachineDebuggerInfoPrintf;
896 pHlp->Core.pfnPrintfV = MachineDebuggerInfoPrintfV;
897 pHlp->pszBuf = NULL;
898 pHlp->cbBuf = 0;
899 pHlp->offBuf = 0;
900 pHlp->fOutOfMemory = false;
901}
902
903/**
904 * Deletes the debug info string buffer formatter.
905 * @param pHlp The helper structure to delete.
906 */
907static void MachineDebuggerInfoDelete(PMACHINEDEBUGGERINOFHLP pHlp)
908{
909 RTMemFree(pHlp->pszBuf);
910 pHlp->pszBuf = NULL;
911}
912
913HRESULT MachineDebugger::info(const com::Utf8Str &aName, const com::Utf8Str &aArgs, com::Utf8Str &aInfo)
914{
915 LogFlowThisFunc(("\n"));
916
917 /*
918 * Do the autocaller and lock bits.
919 */
920 AutoCaller autoCaller(this);
921 HRESULT hrc = autoCaller.rc();
922 if (SUCCEEDED(hrc))
923 {
924 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
925 Console::SafeVMPtr ptrVM(mParent);
926 hrc = ptrVM.rc();
927 if (SUCCEEDED(hrc))
928 {
929 /*
930 * Create a helper and call DBGFR3Info.
931 */
932 MACHINEDEBUGGERINOFHLP Hlp;
933 MachineDebuggerInfoInit(&Hlp);
934 int vrc = DBGFR3Info(ptrVM.rawUVM(), aName.c_str(), aArgs.c_str(), &Hlp.Core);
935 if (RT_SUCCESS(vrc))
936 {
937 if (!Hlp.fOutOfMemory)
938 {
939 /*
940 * Convert the info string, watching out for allocation errors.
941 */
942 try
943 {
944 Bstr bstrInfo(Hlp.pszBuf);
945 aInfo = bstrInfo;
946 }
947 catch (std::bad_alloc)
948 {
949 hrc = E_OUTOFMEMORY;
950 }
951 }
952 else
953 hrc = E_OUTOFMEMORY;
954 }
955 else
956 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3Info failed with %Rrc"), vrc);
957 MachineDebuggerInfoDelete(&Hlp);
958 }
959 }
960 return hrc;
961}
962
963HRESULT MachineDebugger::injectNMI()
964{
965 LogFlowThisFunc(("\n"));
966
967 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
968 Console::SafeVMPtr ptrVM(mParent);
969 HRESULT hrc = ptrVM.rc();
970 if (SUCCEEDED(hrc))
971 {
972 int vrc = DBGFR3InjectNMI(ptrVM.rawUVM(), 0);
973 if (RT_SUCCESS(vrc))
974 hrc = S_OK;
975 else
976 hrc = setError(E_FAIL, tr("DBGFR3InjectNMI failed with %Rrc"), vrc);
977 }
978 return hrc;
979}
980
981HRESULT MachineDebugger::modifyLogFlags(const com::Utf8Str &aSettings)
982{
983 LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
984 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
985 Console::SafeVMPtr ptrVM(mParent);
986 HRESULT hrc = ptrVM.rc();
987 if (SUCCEEDED(hrc))
988 {
989 int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), aSettings.c_str());
990 if (RT_SUCCESS(vrc))
991 hrc = S_OK;
992 else
993 hrc = setError(E_FAIL, tr("DBGFR3LogModifyFlags failed with %Rrc"), vrc);
994 }
995 return hrc;
996}
997
998HRESULT MachineDebugger::modifyLogGroups(const com::Utf8Str &aSettings)
999{
1000 LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
1001 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1002 Console::SafeVMPtr ptrVM(mParent);
1003 HRESULT hrc = ptrVM.rc();
1004 if (SUCCEEDED(hrc))
1005 {
1006 int vrc = DBGFR3LogModifyGroups(ptrVM.rawUVM(), aSettings.c_str());
1007 if (RT_SUCCESS(vrc))
1008 hrc = S_OK;
1009 else
1010 hrc = setError(E_FAIL, tr("DBGFR3LogModifyGroups failed with %Rrc"), vrc);
1011 }
1012 return hrc;
1013}
1014
1015HRESULT MachineDebugger::modifyLogDestinations(const com::Utf8Str &aSettings)
1016{
1017 LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
1018 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1019 Console::SafeVMPtr ptrVM(mParent);
1020 HRESULT hrc = ptrVM.rc();
1021 if (SUCCEEDED(hrc))
1022 {
1023 int vrc = DBGFR3LogModifyDestinations(ptrVM.rawUVM(), aSettings.c_str());
1024 if (RT_SUCCESS(vrc))
1025 hrc = S_OK;
1026 else
1027 hrc = setError(E_FAIL, tr("DBGFR3LogModifyDestinations failed with %Rrc"), vrc);
1028 }
1029 return hrc;
1030}
1031
1032HRESULT MachineDebugger::readPhysicalMemory(LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
1033{
1034 ReturnComNotImplemented();
1035}
1036
1037HRESULT MachineDebugger::writePhysicalMemory(LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
1038{
1039 ReturnComNotImplemented();
1040}
1041
1042HRESULT MachineDebugger::readVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
1043{
1044 ReturnComNotImplemented();
1045}
1046
1047HRESULT MachineDebugger::writeVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
1048{
1049 ReturnComNotImplemented();
1050}
1051
1052HRESULT MachineDebugger::loadPlugIn(const com::Utf8Str &aName, com::Utf8Str &aPlugInName)
1053{
1054 /*
1055 * Lock the debugger and get the VM pointer
1056 */
1057 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1058 Console::SafeVMPtr ptrVM(mParent);
1059 HRESULT hrc = ptrVM.rc();
1060 if (SUCCEEDED(hrc))
1061 {
1062 /*
1063 * Do the job and try convert the name.
1064 */
1065 if (aName.equals("all"))
1066 {
1067 DBGFR3PlugInLoadAll(ptrVM.rawUVM());
1068 try
1069 {
1070 aPlugInName = "all";
1071 hrc = S_OK;
1072 }
1073 catch (std::bad_alloc)
1074 {
1075 hrc = E_OUTOFMEMORY;
1076 }
1077 }
1078 else
1079 {
1080 RTERRINFOSTATIC ErrInfo;
1081 char szName[80];
1082 int vrc = DBGFR3PlugInLoad(ptrVM.rawUVM(), aName.c_str(), szName, sizeof(szName), RTErrInfoInitStatic(&ErrInfo));
1083 if (RT_SUCCESS(vrc))
1084 {
1085 try
1086 {
1087 aPlugInName = szName;
1088 hrc = S_OK;
1089 }
1090 catch (std::bad_alloc)
1091 {
1092 hrc = E_OUTOFMEMORY;
1093 }
1094 }
1095 else
1096 hrc = setErrorVrc(vrc, "%s", ErrInfo.szMsg);
1097 }
1098 }
1099 return hrc;
1100
1101}
1102
1103HRESULT MachineDebugger::unloadPlugIn(const com::Utf8Str &aName)
1104{
1105 /*
1106 * Lock the debugger and get the VM pointer
1107 */
1108 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1109 Console::SafeVMPtr ptrVM(mParent);
1110 HRESULT hrc = ptrVM.rc();
1111 if (SUCCEEDED(hrc))
1112 {
1113 /*
1114 * Do the job and try convert the name.
1115 */
1116 if (aName.equals("all"))
1117 {
1118 DBGFR3PlugInUnloadAll(ptrVM.rawUVM());
1119 hrc = S_OK;
1120 }
1121 else
1122 {
1123 int vrc = DBGFR3PlugInUnload(ptrVM.rawUVM(), aName.c_str());
1124 if (RT_SUCCESS(vrc))
1125 hrc = S_OK;
1126 else if (vrc == VERR_NOT_FOUND)
1127 hrc = setErrorBoth(E_FAIL, vrc, "Plug-in '%s' was not found", aName.c_str());
1128 else
1129 hrc = setErrorVrc(vrc, "Error unloading '%s': %Rrc", aName.c_str(), vrc);
1130 }
1131 }
1132 return hrc;
1133
1134}
1135
1136HRESULT MachineDebugger::detectOS(com::Utf8Str &aOs)
1137{
1138 LogFlowThisFunc(("\n"));
1139
1140 /*
1141 * Lock the debugger and get the VM pointer
1142 */
1143 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1144 Console::SafeVMPtr ptrVM(mParent);
1145 HRESULT hrc = ptrVM.rc();
1146 if (SUCCEEDED(hrc))
1147 {
1148 /*
1149 * Do the job.
1150 */
1151 char szName[64];
1152 int vrc = DBGFR3OSDetect(ptrVM.rawUVM(), szName, sizeof(szName));
1153 if (RT_SUCCESS(vrc) && vrc != VINF_DBGF_OS_NOT_DETCTED)
1154 {
1155 try
1156 {
1157 aOs = szName;
1158 }
1159 catch (std::bad_alloc)
1160 {
1161 hrc = E_OUTOFMEMORY;
1162 }
1163 }
1164 else
1165 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
1166 }
1167 return hrc;
1168}
1169
1170HRESULT MachineDebugger::queryOSKernelLog(ULONG aMaxMessages, com::Utf8Str &aDmesg)
1171{
1172 /*
1173 * Lock the debugger and get the VM pointer
1174 */
1175 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1176 Console::SafeVMPtr ptrVM(mParent);
1177 HRESULT hrc = ptrVM.rc();
1178 if (SUCCEEDED(hrc))
1179 {
1180 PDBGFOSIDMESG pDmesg = (PDBGFOSIDMESG)DBGFR3OSQueryInterface(ptrVM.rawUVM(), DBGFOSINTERFACE_DMESG);
1181 if (pDmesg)
1182 {
1183 size_t cbActual;
1184 size_t cbBuf = _512K;
1185 int vrc = aDmesg.reserveNoThrow(cbBuf);
1186 if (RT_SUCCESS(vrc))
1187 {
1188 uint32_t cMessages = aMaxMessages == 0 ? UINT32_MAX : aMaxMessages;
1189 vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), 0 /*fFlags*/, cMessages,
1190 aDmesg.mutableRaw(), cbBuf, &cbActual);
1191
1192 uint32_t cTries = 10;
1193 while (vrc == VERR_BUFFER_OVERFLOW && cbBuf < 16*_1M && cTries-- > 0)
1194 {
1195 cbBuf = RT_ALIGN_Z(cbActual + _4K, _4K);
1196 vrc = aDmesg.reserveNoThrow(cbBuf);
1197 if (RT_SUCCESS(vrc))
1198 vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), 0 /*fFlags*/, cMessages,
1199 aDmesg.mutableRaw(), cbBuf, &cbActual);
1200 }
1201 if (RT_SUCCESS(vrc))
1202 aDmesg.jolt();
1203 else if (vrc == VERR_BUFFER_OVERFLOW)
1204 hrc = setError(E_FAIL, "Too much log available, must use the maxMessages parameter to restrict.");
1205 else
1206 hrc = setErrorVrc(vrc);
1207 }
1208 else
1209 hrc = setErrorBoth(E_OUTOFMEMORY, vrc);
1210 }
1211 else
1212 hrc = setError(E_FAIL, "The dmesg interface isn't implemented by guest OS digger, or detectOS() has not been called.");
1213 }
1214 return hrc;
1215}
1216
1217/**
1218 * Formats a register value.
1219 *
1220 * This is used by both register getter methods.
1221 *
1222 * @returns
1223 * @param a_pbstr The output Bstr variable.
1224 * @param a_pValue The value to format.
1225 * @param a_enmType The type of the value.
1226 */
1227DECLINLINE(HRESULT) formatRegisterValue(Bstr *a_pbstr, PCDBGFREGVAL a_pValue, DBGFREGVALTYPE a_enmType)
1228{
1229 char szHex[160];
1230 ssize_t cch = DBGFR3RegFormatValue(szHex, sizeof(szHex), a_pValue, a_enmType, true /*fSpecial*/);
1231 if (RT_UNLIKELY(cch <= 0))
1232 return E_UNEXPECTED;
1233 *a_pbstr = szHex;
1234 return S_OK;
1235}
1236
1237HRESULT MachineDebugger::getRegister(ULONG aCpuId, const com::Utf8Str &aName, com::Utf8Str &aValue)
1238{
1239 /*
1240 * The prologue.
1241 */
1242 LogFlowThisFunc(("\n"));
1243 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1244 Console::SafeVMPtr ptrVM(mParent);
1245 HRESULT hrc = ptrVM.rc();
1246 if (SUCCEEDED(hrc))
1247 {
1248 /*
1249 * Real work.
1250 */
1251 DBGFREGVAL Value;
1252 DBGFREGVALTYPE enmType;
1253 int vrc = DBGFR3RegNmQuery(ptrVM.rawUVM(), aCpuId, aName.c_str(), &Value, &enmType);
1254 if (RT_SUCCESS(vrc))
1255 {
1256 try
1257 {
1258 Bstr bstrValue;
1259 hrc = formatRegisterValue(&bstrValue, &Value, enmType);
1260 if (SUCCEEDED(hrc))
1261 aValue = Utf8Str(bstrValue);
1262 }
1263 catch (std::bad_alloc)
1264 {
1265 hrc = E_OUTOFMEMORY;
1266 }
1267 }
1268 else if (vrc == VERR_DBGF_REGISTER_NOT_FOUND)
1269 hrc = setError(E_FAIL, tr("Register '%s' was not found"), aName.c_str());
1270 else if (vrc == VERR_INVALID_CPU_ID)
1271 hrc = setError(E_FAIL, tr("Invalid CPU ID: %u"), aCpuId);
1272 else
1273 hrc = setError(VBOX_E_VM_ERROR,
1274 tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
1275 vrc, aName.c_str(), aCpuId);
1276 }
1277
1278 return hrc;
1279}
1280
1281HRESULT MachineDebugger::getRegisters(ULONG aCpuId, std::vector<com::Utf8Str> &aNames, std::vector<com::Utf8Str> &aValues)
1282{
1283 /*
1284 * The prologue.
1285 */
1286 LogFlowThisFunc(("\n"));
1287 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1288 Console::SafeVMPtr ptrVM(mParent);
1289 HRESULT hrc = ptrVM.rc();
1290 if (SUCCEEDED(hrc))
1291 {
1292 /*
1293 * Real work.
1294 */
1295 size_t cRegs;
1296 int vrc = DBGFR3RegNmQueryAllCount(ptrVM.rawUVM(), &cRegs);
1297 if (RT_SUCCESS(vrc))
1298 {
1299 PDBGFREGENTRYNM paRegs = (PDBGFREGENTRYNM)RTMemAllocZ(sizeof(paRegs[0]) * cRegs);
1300 if (paRegs)
1301 {
1302 vrc = DBGFR3RegNmQueryAll(ptrVM.rawUVM(), paRegs, cRegs);
1303 if (RT_SUCCESS(vrc))
1304 {
1305 try
1306 {
1307 aValues.resize(cRegs);
1308 aNames.resize(cRegs);
1309 for (uint32_t iReg = 0; iReg < cRegs; iReg++)
1310 {
1311 char szHex[160];
1312 szHex[159] = szHex[0] = '\0';
1313 ssize_t cch = DBGFR3RegFormatValue(szHex, sizeof(szHex), &paRegs[iReg].Val,
1314 paRegs[iReg].enmType, true /*fSpecial*/);
1315 Assert(cch > 0);
1316 aNames[iReg] = Utf8Str(paRegs[iReg].pszName);
1317 aValues[iReg] = Utf8Str(szHex);
1318 }
1319 }
1320 catch (std::bad_alloc)
1321 {
1322 hrc = E_OUTOFMEMORY;
1323 }
1324 }
1325 else
1326 hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
1327
1328 RTMemFree(paRegs);
1329 }
1330 else
1331 hrc = E_OUTOFMEMORY;
1332 }
1333 else
1334 hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
1335 }
1336 return hrc;
1337}
1338
1339HRESULT MachineDebugger::setRegister(ULONG aCpuId, const com::Utf8Str &aName, const com::Utf8Str &aValue)
1340{
1341 ReturnComNotImplemented();
1342}
1343
1344HRESULT MachineDebugger::setRegisters(ULONG aCpuId, const std::vector<com::Utf8Str> &aNames,
1345 const std::vector<com::Utf8Str> &aValues)
1346{
1347 ReturnComNotImplemented();
1348}
1349
1350HRESULT MachineDebugger::dumpGuestStack(ULONG aCpuId, com::Utf8Str &aStack)
1351{
1352 /*
1353 * The prologue.
1354 */
1355 LogFlowThisFunc(("\n"));
1356 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1357 Console::SafeVMPtr ptrVM(mParent);
1358 HRESULT hrc = ptrVM.rc();
1359 if (SUCCEEDED(hrc))
1360 {
1361 /* Suspend the VM first or we risk deadlocks or inconsistent guest stacks. */
1362 alock.release();
1363 int vrc = VMR3Suspend(ptrVM.rawUVM(), VMSUSPENDREASON_USER);
1364 alock.acquire();
1365 if (RT_SUCCESS(vrc))
1366 {
1367 PCDBGFSTACKFRAME pFirstFrame;
1368
1369 vrc = DBGFR3StackWalkBegin(ptrVM.rawUVM(), aCpuId, DBGFCODETYPE_GUEST, &pFirstFrame);
1370 if (RT_SUCCESS(vrc))
1371 {
1372 /*
1373 * Print header.
1374 */
1375 try
1376 {
1377 uint32_t fBitFlags = 0;
1378 for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
1379 pFrame;
1380 pFrame = DBGFR3StackWalkNext(pFrame))
1381 {
1382 uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT | DBGFSTACKFRAME_FLAGS_32BIT | DBGFSTACKFRAME_FLAGS_64BIT);
1383 if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
1384 {
1385 if (fCurBitFlags != fBitFlags)
1386 aStack.append("SS:BP Ret SS:BP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
1387 aStack.append(Utf8StrFmt("%04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
1388 pFrame->AddrFrame.Sel,
1389 (uint16_t)pFrame->AddrFrame.off,
1390 pFrame->AddrReturnFrame.Sel,
1391 (uint16_t)pFrame->AddrReturnFrame.off,
1392 (uint32_t)pFrame->AddrReturnPC.Sel,
1393 (uint32_t)pFrame->AddrReturnPC.off,
1394 pFrame->Args.au32[0],
1395 pFrame->Args.au32[1],
1396 pFrame->Args.au32[2],
1397 pFrame->Args.au32[3]));
1398 }
1399 else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
1400 {
1401 if (fCurBitFlags != fBitFlags)
1402 aStack.append("EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
1403 aStack.append(Utf8StrFmt("%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
1404 (uint32_t)pFrame->AddrFrame.off,
1405 (uint32_t)pFrame->AddrReturnFrame.off,
1406 (uint32_t)pFrame->AddrReturnPC.Sel,
1407 (uint32_t)pFrame->AddrReturnPC.off,
1408 pFrame->Args.au32[0],
1409 pFrame->Args.au32[1],
1410 pFrame->Args.au32[2],
1411 pFrame->Args.au32[3]));
1412 }
1413 else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
1414 {
1415 if (fCurBitFlags != fBitFlags)
1416 aStack.append("RBP Ret SS:RBP Ret RIP CS:RIP / Symbol [line]\n");
1417 aStack.append(Utf8StrFmt("%016RX64 %04RX16:%016RX64 %016RX64",
1418 (uint64_t)pFrame->AddrFrame.off,
1419 pFrame->AddrReturnFrame.Sel,
1420 (uint64_t)pFrame->AddrReturnFrame.off,
1421 (uint64_t)pFrame->AddrReturnPC.off));
1422 }
1423
1424 if (!pFrame->pSymPC)
1425 aStack.append(Utf8StrFmt(fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
1426 ? " %RTsel:%016RGv"
1427 : fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
1428 ? " %RTsel:%08RGv"
1429 : " %RTsel:%04RGv"
1430 , pFrame->AddrPC.Sel, pFrame->AddrPC.off));
1431 else
1432 {
1433 RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
1434 if (offDisp > 0)
1435 aStack.append(Utf8StrFmt(" %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp));
1436 else if (offDisp < 0)
1437 aStack.append(Utf8StrFmt(" %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp));
1438 else
1439 aStack.append(Utf8StrFmt(" %s", pFrame->pSymPC->szName));
1440 }
1441 if (pFrame->pLinePC)
1442 aStack.append(Utf8StrFmt(" [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo));
1443 aStack.append(Utf8StrFmt("\n"));
1444
1445 fBitFlags = fCurBitFlags;
1446 }
1447 }
1448 catch (std::bad_alloc)
1449 {
1450 hrc = E_OUTOFMEMORY;
1451 }
1452
1453 DBGFR3StackWalkEnd(pFirstFrame);
1454 }
1455 else
1456 hrc = setError(E_FAIL, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
1457
1458 alock.release();
1459 VMR3Resume(ptrVM.rawUVM(), VMRESUMEREASON_USER);
1460 alock.acquire();
1461 }
1462 else
1463 hrc = setError(E_FAIL, tr("Suspending the VM failed with %Rrc\n"), vrc);
1464 }
1465
1466 return hrc;
1467}
1468
1469/**
1470 * Resets VM statistics.
1471 *
1472 * @returns COM status code.
1473 * @param aPattern The selection pattern. A bit similar to filename globbing.
1474 */
1475HRESULT MachineDebugger::resetStats(const com::Utf8Str &aPattern)
1476{
1477 Console::SafeVMPtrQuiet ptrVM(mParent);
1478
1479 if (!ptrVM.isOk())
1480 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1481
1482 STAMR3Reset(ptrVM.rawUVM(), aPattern.c_str());
1483
1484 return S_OK;
1485}
1486
1487/**
1488 * Dumps VM statistics to the log.
1489 *
1490 * @returns COM status code.
1491 * @param aPattern The selection pattern. A bit similar to filename globbing.
1492 */
1493HRESULT MachineDebugger::dumpStats(const com::Utf8Str &aPattern)
1494{
1495 Console::SafeVMPtrQuiet ptrVM(mParent);
1496
1497 if (!ptrVM.isOk())
1498 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1499
1500 STAMR3Dump(ptrVM.rawUVM(), aPattern.c_str());
1501
1502 return S_OK;
1503}
1504
1505/**
1506 * Get the VM statistics in an XML format.
1507 *
1508 * @returns COM status code.
1509 * @param aPattern The selection pattern. A bit similar to filename globbing.
1510 * @param aWithDescriptions Whether to include the descriptions.
1511 * @param aStats The XML document containing the statistics.
1512 */
1513HRESULT MachineDebugger::getStats(const com::Utf8Str &aPattern, BOOL aWithDescriptions, com::Utf8Str &aStats)
1514{
1515 Console::SafeVMPtrQuiet ptrVM (mParent);
1516
1517 if (!ptrVM.isOk())
1518 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1519
1520 char *pszSnapshot;
1521 int vrc = STAMR3Snapshot(ptrVM.rawUVM(), aPattern.c_str(), &pszSnapshot, NULL,
1522 !!aWithDescriptions);
1523 if (RT_FAILURE(vrc))
1524 return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;
1525
1526 /** @todo this is horribly inefficient! And it's kinda difficult to tell whether it failed...
1527 * Must use UTF-8 or ASCII here and completely avoid these two extra copy operations.
1528 * Until that's done, this method is kind of useless for debugger statistics GUI because
1529 * of the amount statistics in a debug build. */
1530 aStats = Utf8Str(pszSnapshot);
1531 STAMR3SnapshotFree(ptrVM.rawUVM(), pszSnapshot);
1532
1533 return S_OK;
1534}
1535
1536
1537// public methods only for internal purposes
1538/////////////////////////////////////////////////////////////////////////////
1539
1540void MachineDebugger::i_flushQueuedSettings()
1541{
1542 mFlushMode = true;
1543 if (mSingleStepQueued != ~0)
1544 {
1545 COMSETTER(SingleStep)(mSingleStepQueued);
1546 mSingleStepQueued = ~0;
1547 }
1548 for (unsigned i = 0; i < EMEXECPOLICY_END; i++)
1549 if (maiQueuedEmExecPolicyParams[i] != UINT8_MAX)
1550 {
1551 i_setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
1552 maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
1553 }
1554 if (mPatmEnabledQueued != ~0)
1555 {
1556 COMSETTER(PATMEnabled)(mPatmEnabledQueued);
1557 mPatmEnabledQueued = ~0;
1558 }
1559 if (mCsamEnabledQueued != ~0)
1560 {
1561 COMSETTER(CSAMEnabled)(mCsamEnabledQueued);
1562 mCsamEnabledQueued = ~0;
1563 }
1564 if (mLogEnabledQueued != ~0)
1565 {
1566 COMSETTER(LogEnabled)(mLogEnabledQueued);
1567 mLogEnabledQueued = ~0;
1568 }
1569 if (mVirtualTimeRateQueued != ~(uint32_t)0)
1570 {
1571 COMSETTER(VirtualTimeRate)(mVirtualTimeRateQueued);
1572 mVirtualTimeRateQueued = ~0;
1573 }
1574 mFlushMode = false;
1575}
1576
1577// private methods
1578/////////////////////////////////////////////////////////////////////////////
1579
1580bool MachineDebugger::i_queueSettings() const
1581{
1582 if (!mFlushMode)
1583 {
1584 // check if the machine is running
1585 MachineState_T machineState;
1586 mParent->COMGETTER(State)(&machineState);
1587 switch (machineState)
1588 {
1589 // queue the request
1590 default:
1591 return true;
1592
1593 case MachineState_Running:
1594 case MachineState_Paused:
1595 case MachineState_Stuck:
1596 case MachineState_LiveSnapshotting:
1597 case MachineState_Teleporting:
1598 break;
1599 }
1600 }
1601 return false;
1602}
1603/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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