VirtualBox

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

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

Main/MachineDebugger: add method for getting the VM uptime
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 49.3 KB
Line 
1/* $Id: MachineDebuggerImpl.cpp 62598 2016-07-27 14:42:21Z vboxsync $ */
2/** @file
3 * VBox IMachineDebugger COM class implementation (VBoxC).
4 */
5
6/*
7 * Copyright (C) 2006-2016 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 aVM 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/**
778 * Get the VM uptime in milliseconds.
779 *
780 * @returns COM status code
781 * @param aUptime Where to store the uptime.
782 */
783HRESULT MachineDebugger::getUptime(LONG64 *aUptime)
784{
785 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
786
787 Console::SafeVMPtr ptrVM(mParent);
788 HRESULT hrc = ptrVM.rc();
789 if (SUCCEEDED(hrc))
790 *aUptime = (int64_t)TMR3TimeVirtGetMilli(ptrVM.rawUVM());
791
792 return hrc;
793}
794
795// IMachineDebugger methods
796/////////////////////////////////////////////////////////////////////////////
797
798HRESULT MachineDebugger::dumpGuestCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
799{
800 if (aCompression.length())
801 return setError(E_INVALIDARG, tr("The compression parameter must be empty"));
802
803 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
804 Console::SafeVMPtr ptrVM(mParent);
805 HRESULT hrc = ptrVM.rc();
806 if (SUCCEEDED(hrc))
807 {
808 int vrc = DBGFR3CoreWrite(ptrVM.rawUVM(), aFilename.c_str(), false /*fReplaceFile*/);
809 if (RT_SUCCESS(vrc))
810 hrc = S_OK;
811 else
812 hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
813 }
814
815 return hrc;
816}
817
818HRESULT MachineDebugger::dumpHostProcessCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
819{
820 ReturnComNotImplemented();
821}
822
823/**
824 * Debug info string buffer formatter.
825 */
826typedef struct MACHINEDEBUGGERINOFHLP
827{
828 /** The core info helper structure. */
829 DBGFINFOHLP Core;
830 /** Pointer to the buffer. */
831 char *pszBuf;
832 /** The size of the buffer. */
833 size_t cbBuf;
834 /** The offset into the buffer */
835 size_t offBuf;
836 /** Indicates an out-of-memory condition. */
837 bool fOutOfMemory;
838} MACHINEDEBUGGERINOFHLP;
839/** Pointer to a Debug info string buffer formatter. */
840typedef MACHINEDEBUGGERINOFHLP *PMACHINEDEBUGGERINOFHLP;
841
842
843/**
844 * @callback_method_impl{FNRTSTROUTPUT}
845 */
846static DECLCALLBACK(size_t) MachineDebuggerInfoOutput(void *pvArg, const char *pachChars, size_t cbChars)
847{
848 PMACHINEDEBUGGERINOFHLP pHlp = (PMACHINEDEBUGGERINOFHLP)pvArg;
849
850 /*
851 * Grow the buffer if required.
852 */
853 size_t const cbRequired = cbChars + pHlp->offBuf + 1;
854 if (cbRequired > pHlp->cbBuf)
855 {
856 if (RT_UNLIKELY(pHlp->fOutOfMemory))
857 return 0;
858
859 size_t cbBufNew = pHlp->cbBuf * 2;
860 if (cbRequired > cbBufNew)
861 cbBufNew = RT_ALIGN_Z(cbRequired, 256);
862 void *pvBufNew = RTMemRealloc(pHlp->pszBuf, cbBufNew);
863 if (RT_UNLIKELY(!pvBufNew))
864 {
865 pHlp->fOutOfMemory = true;
866 RTMemFree(pHlp->pszBuf);
867 pHlp->pszBuf = NULL;
868 pHlp->cbBuf = 0;
869 pHlp->offBuf = 0;
870 return 0;
871 }
872
873 pHlp->pszBuf = (char *)pvBufNew;
874 pHlp->cbBuf = cbBufNew;
875 }
876
877 /*
878 * Copy the bytes into the buffer and terminate it.
879 */
880 memcpy(&pHlp->pszBuf[pHlp->offBuf], pachChars, cbChars);
881 pHlp->offBuf += cbChars;
882 pHlp->pszBuf[pHlp->offBuf] = '\0';
883 Assert(pHlp->offBuf < pHlp->cbBuf);
884 return cbChars;
885}
886
887/**
888 * @interface_method_impl{DBGFINFOHLP,pfnPrintfV}
889 */
890static DECLCALLBACK(void) MachineDebuggerInfoPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list va)
891{
892 RTStrFormatV(MachineDebuggerInfoOutput, (void *)pHlp, NULL, NULL, pszFormat, va);
893}
894
895/**
896 * @interface_method_impl{DBGFINFOHLP,pfnPrintf}
897 */
898static DECLCALLBACK(void) MachineDebuggerInfoPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
899{
900 va_list va;
901 va_start(va, pszFormat);
902 MachineDebuggerInfoPrintfV(pHlp, pszFormat, va);
903 va_end(va);
904}
905
906/**
907 * Initializes the debug info string buffer formatter
908 *
909 * @param pHlp The help structure to init.
910 */
911static void MachineDebuggerInfoInit(PMACHINEDEBUGGERINOFHLP pHlp)
912{
913 pHlp->Core.pfnPrintf = MachineDebuggerInfoPrintf;
914 pHlp->Core.pfnPrintfV = MachineDebuggerInfoPrintfV;
915 pHlp->pszBuf = NULL;
916 pHlp->cbBuf = 0;
917 pHlp->offBuf = 0;
918 pHlp->fOutOfMemory = false;
919}
920
921/**
922 * Deletes the debug info string buffer formatter.
923 * @param pHlp The helper structure to delete.
924 */
925static void MachineDebuggerInfoDelete(PMACHINEDEBUGGERINOFHLP pHlp)
926{
927 RTMemFree(pHlp->pszBuf);
928 pHlp->pszBuf = NULL;
929}
930
931HRESULT MachineDebugger::info(const com::Utf8Str &aName, const com::Utf8Str &aArgs, com::Utf8Str &aInfo)
932{
933 LogFlowThisFunc(("\n"));
934
935 /*
936 * Do the autocaller and lock bits.
937 */
938 AutoCaller autoCaller(this);
939 HRESULT hrc = autoCaller.rc();
940 if (SUCCEEDED(hrc))
941 {
942 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
943 Console::SafeVMPtr ptrVM(mParent);
944 hrc = ptrVM.rc();
945 if (SUCCEEDED(hrc))
946 {
947 /*
948 * Create a helper and call DBGFR3Info.
949 */
950 MACHINEDEBUGGERINOFHLP Hlp;
951 MachineDebuggerInfoInit(&Hlp);
952 int vrc = DBGFR3Info(ptrVM.rawUVM(), aName.c_str(), aArgs.c_str(), &Hlp.Core);
953 if (RT_SUCCESS(vrc))
954 {
955 if (!Hlp.fOutOfMemory)
956 {
957 /*
958 * Convert the info string, watching out for allocation errors.
959 */
960 try
961 {
962 Bstr bstrInfo(Hlp.pszBuf);
963 aInfo = bstrInfo;
964 }
965 catch (std::bad_alloc)
966 {
967 hrc = E_OUTOFMEMORY;
968 }
969 }
970 else
971 hrc = E_OUTOFMEMORY;
972 }
973 else
974 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3Info failed with %Rrc"), vrc);
975 MachineDebuggerInfoDelete(&Hlp);
976 }
977 }
978 return hrc;
979}
980
981HRESULT MachineDebugger::injectNMI()
982{
983 LogFlowThisFunc(("\n"));
984
985 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
986 Console::SafeVMPtr ptrVM(mParent);
987 HRESULT hrc = ptrVM.rc();
988 if (SUCCEEDED(hrc))
989 {
990 int vrc = DBGFR3InjectNMI(ptrVM.rawUVM(), 0);
991 if (RT_SUCCESS(vrc))
992 hrc = S_OK;
993 else
994 hrc = setError(E_FAIL, tr("DBGFR3InjectNMI failed with %Rrc"), vrc);
995 }
996 return hrc;
997}
998
999HRESULT MachineDebugger::modifyLogFlags(const com::Utf8Str &aSettings)
1000{
1001 LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
1002 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1003 Console::SafeVMPtr ptrVM(mParent);
1004 HRESULT hrc = ptrVM.rc();
1005 if (SUCCEEDED(hrc))
1006 {
1007 int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), aSettings.c_str());
1008 if (RT_SUCCESS(vrc))
1009 hrc = S_OK;
1010 else
1011 hrc = setError(E_FAIL, tr("DBGFR3LogModifyFlags failed with %Rrc"), vrc);
1012 }
1013 return hrc;
1014}
1015
1016HRESULT MachineDebugger::modifyLogGroups(const com::Utf8Str &aSettings)
1017{
1018 LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
1019 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1020 Console::SafeVMPtr ptrVM(mParent);
1021 HRESULT hrc = ptrVM.rc();
1022 if (SUCCEEDED(hrc))
1023 {
1024 int vrc = DBGFR3LogModifyGroups(ptrVM.rawUVM(), aSettings.c_str());
1025 if (RT_SUCCESS(vrc))
1026 hrc = S_OK;
1027 else
1028 hrc = setError(E_FAIL, tr("DBGFR3LogModifyGroups failed with %Rrc"), vrc);
1029 }
1030 return hrc;
1031}
1032
1033HRESULT MachineDebugger::modifyLogDestinations(const com::Utf8Str &aSettings)
1034{
1035 LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
1036 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1037 Console::SafeVMPtr ptrVM(mParent);
1038 HRESULT hrc = ptrVM.rc();
1039 if (SUCCEEDED(hrc))
1040 {
1041 int vrc = DBGFR3LogModifyDestinations(ptrVM.rawUVM(), aSettings.c_str());
1042 if (RT_SUCCESS(vrc))
1043 hrc = S_OK;
1044 else
1045 hrc = setError(E_FAIL, tr("DBGFR3LogModifyDestinations failed with %Rrc"), vrc);
1046 }
1047 return hrc;
1048}
1049
1050HRESULT MachineDebugger::readPhysicalMemory(LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
1051{
1052 ReturnComNotImplemented();
1053}
1054
1055HRESULT MachineDebugger::writePhysicalMemory(LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
1056{
1057 ReturnComNotImplemented();
1058}
1059
1060HRESULT MachineDebugger::readVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
1061{
1062 ReturnComNotImplemented();
1063}
1064
1065HRESULT MachineDebugger::writeVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
1066{
1067 ReturnComNotImplemented();
1068}
1069
1070HRESULT MachineDebugger::loadPlugIn(const com::Utf8Str &aName, com::Utf8Str &aPlugInName)
1071{
1072 /*
1073 * Lock the debugger and get the VM pointer
1074 */
1075 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1076 Console::SafeVMPtr ptrVM(mParent);
1077 HRESULT hrc = ptrVM.rc();
1078 if (SUCCEEDED(hrc))
1079 {
1080 /*
1081 * Do the job and try convert the name.
1082 */
1083 if (aName.equals("all"))
1084 {
1085 DBGFR3PlugInLoadAll(ptrVM.rawUVM());
1086 try
1087 {
1088 aPlugInName = "all";
1089 hrc = S_OK;
1090 }
1091 catch (std::bad_alloc)
1092 {
1093 hrc = E_OUTOFMEMORY;
1094 }
1095 }
1096 else
1097 {
1098 RTERRINFOSTATIC ErrInfo;
1099 char szName[80];
1100 int vrc = DBGFR3PlugInLoad(ptrVM.rawUVM(), aName.c_str(), szName, sizeof(szName), RTErrInfoInitStatic(&ErrInfo));
1101 if (RT_SUCCESS(vrc))
1102 {
1103 try
1104 {
1105 aPlugInName = szName;
1106 hrc = S_OK;
1107 }
1108 catch (std::bad_alloc)
1109 {
1110 hrc = E_OUTOFMEMORY;
1111 }
1112 }
1113 else
1114 hrc = setErrorVrc(vrc, "%s", ErrInfo.szMsg);
1115 }
1116 }
1117 return hrc;
1118
1119}
1120
1121HRESULT MachineDebugger::unloadPlugIn(const com::Utf8Str &aName)
1122{
1123 /*
1124 * Lock the debugger and get the VM pointer
1125 */
1126 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1127 Console::SafeVMPtr ptrVM(mParent);
1128 HRESULT hrc = ptrVM.rc();
1129 if (SUCCEEDED(hrc))
1130 {
1131 /*
1132 * Do the job and try convert the name.
1133 */
1134 if (aName.equals("all"))
1135 {
1136 DBGFR3PlugInUnloadAll(ptrVM.rawUVM());
1137 hrc = S_OK;
1138 }
1139 else
1140 {
1141 int vrc = DBGFR3PlugInUnload(ptrVM.rawUVM(), aName.c_str());
1142 if (RT_SUCCESS(vrc))
1143 hrc = S_OK;
1144 else if (vrc == VERR_NOT_FOUND)
1145 hrc = setErrorBoth(E_FAIL, vrc, "Plug-in '%s' was not found", aName.c_str());
1146 else
1147 hrc = setErrorVrc(vrc, "Error unloading '%s': %Rrc", aName.c_str(), vrc);
1148 }
1149 }
1150 return hrc;
1151
1152}
1153
1154HRESULT MachineDebugger::detectOS(com::Utf8Str &aOs)
1155{
1156 LogFlowThisFunc(("\n"));
1157
1158 /*
1159 * Lock the debugger and get the VM pointer
1160 */
1161 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1162 Console::SafeVMPtr ptrVM(mParent);
1163 HRESULT hrc = ptrVM.rc();
1164 if (SUCCEEDED(hrc))
1165 {
1166 /*
1167 * Do the job.
1168 */
1169 char szName[64];
1170 int vrc = DBGFR3OSDetect(ptrVM.rawUVM(), szName, sizeof(szName));
1171 if (RT_SUCCESS(vrc) && vrc != VINF_DBGF_OS_NOT_DETCTED)
1172 {
1173 try
1174 {
1175 aOs = szName;
1176 }
1177 catch (std::bad_alloc)
1178 {
1179 hrc = E_OUTOFMEMORY;
1180 }
1181 }
1182 else
1183 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
1184 }
1185 return hrc;
1186}
1187
1188HRESULT MachineDebugger::queryOSKernelLog(ULONG aMaxMessages, com::Utf8Str &aDmesg)
1189{
1190 /*
1191 * Lock the debugger and get the VM pointer
1192 */
1193 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1194 Console::SafeVMPtr ptrVM(mParent);
1195 HRESULT hrc = ptrVM.rc();
1196 if (SUCCEEDED(hrc))
1197 {
1198 PDBGFOSIDMESG pDmesg = (PDBGFOSIDMESG)DBGFR3OSQueryInterface(ptrVM.rawUVM(), DBGFOSINTERFACE_DMESG);
1199 if (pDmesg)
1200 {
1201 size_t cbActual;
1202 size_t cbBuf = _512K;
1203 int vrc = aDmesg.reserveNoThrow(cbBuf);
1204 if (RT_SUCCESS(vrc))
1205 {
1206 uint32_t cMessages = aMaxMessages == 0 ? UINT32_MAX : aMaxMessages;
1207 vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), 0 /*fFlags*/, cMessages,
1208 aDmesg.mutableRaw(), cbBuf, &cbActual);
1209
1210 uint32_t cTries = 10;
1211 while (vrc == VERR_BUFFER_OVERFLOW && cbBuf < 16*_1M && cTries-- > 0)
1212 {
1213 cbBuf = RT_ALIGN_Z(cbActual + _4K, _4K);
1214 vrc = aDmesg.reserveNoThrow(cbBuf);
1215 if (RT_SUCCESS(vrc))
1216 vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), 0 /*fFlags*/, cMessages,
1217 aDmesg.mutableRaw(), cbBuf, &cbActual);
1218 }
1219 if (RT_SUCCESS(vrc))
1220 aDmesg.jolt();
1221 else if (vrc == VERR_BUFFER_OVERFLOW)
1222 hrc = setError(E_FAIL, "Too much log available, must use the maxMessages parameter to restrict.");
1223 else
1224 hrc = setErrorVrc(vrc);
1225 }
1226 else
1227 hrc = setErrorBoth(E_OUTOFMEMORY, vrc);
1228 }
1229 else
1230 hrc = setError(E_FAIL, "The dmesg interface isn't implemented by guest OS digger, or detectOS() has not been called.");
1231 }
1232 return hrc;
1233}
1234
1235/**
1236 * Formats a register value.
1237 *
1238 * This is used by both register getter methods.
1239 *
1240 * @returns
1241 * @param a_pbstr The output Bstr variable.
1242 * @param a_pValue The value to format.
1243 * @param a_enmType The type of the value.
1244 */
1245DECLINLINE(HRESULT) formatRegisterValue(Bstr *a_pbstr, PCDBGFREGVAL a_pValue, DBGFREGVALTYPE a_enmType)
1246{
1247 char szHex[160];
1248 ssize_t cch = DBGFR3RegFormatValue(szHex, sizeof(szHex), a_pValue, a_enmType, true /*fSpecial*/);
1249 if (RT_UNLIKELY(cch <= 0))
1250 return E_UNEXPECTED;
1251 *a_pbstr = szHex;
1252 return S_OK;
1253}
1254
1255HRESULT MachineDebugger::getRegister(ULONG aCpuId, const com::Utf8Str &aName, com::Utf8Str &aValue)
1256{
1257 /*
1258 * The prologue.
1259 */
1260 LogFlowThisFunc(("\n"));
1261 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1262 Console::SafeVMPtr ptrVM(mParent);
1263 HRESULT hrc = ptrVM.rc();
1264 if (SUCCEEDED(hrc))
1265 {
1266 /*
1267 * Real work.
1268 */
1269 DBGFREGVAL Value;
1270 DBGFREGVALTYPE enmType;
1271 int vrc = DBGFR3RegNmQuery(ptrVM.rawUVM(), aCpuId, aName.c_str(), &Value, &enmType);
1272 if (RT_SUCCESS(vrc))
1273 {
1274 try
1275 {
1276 Bstr bstrValue;
1277 hrc = formatRegisterValue(&bstrValue, &Value, enmType);
1278 if (SUCCEEDED(hrc))
1279 aValue = Utf8Str(bstrValue);
1280 }
1281 catch (std::bad_alloc)
1282 {
1283 hrc = E_OUTOFMEMORY;
1284 }
1285 }
1286 else if (vrc == VERR_DBGF_REGISTER_NOT_FOUND)
1287 hrc = setError(E_FAIL, tr("Register '%s' was not found"), aName.c_str());
1288 else if (vrc == VERR_INVALID_CPU_ID)
1289 hrc = setError(E_FAIL, tr("Invalid CPU ID: %u"), aCpuId);
1290 else
1291 hrc = setError(VBOX_E_VM_ERROR,
1292 tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
1293 vrc, aName.c_str(), aCpuId);
1294 }
1295
1296 return hrc;
1297}
1298
1299HRESULT MachineDebugger::getRegisters(ULONG aCpuId, std::vector<com::Utf8Str> &aNames, std::vector<com::Utf8Str> &aValues)
1300{
1301 /*
1302 * The prologue.
1303 */
1304 LogFlowThisFunc(("\n"));
1305 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1306 Console::SafeVMPtr ptrVM(mParent);
1307 HRESULT hrc = ptrVM.rc();
1308 if (SUCCEEDED(hrc))
1309 {
1310 /*
1311 * Real work.
1312 */
1313 size_t cRegs;
1314 int vrc = DBGFR3RegNmQueryAllCount(ptrVM.rawUVM(), &cRegs);
1315 if (RT_SUCCESS(vrc))
1316 {
1317 PDBGFREGENTRYNM paRegs = (PDBGFREGENTRYNM)RTMemAllocZ(sizeof(paRegs[0]) * cRegs);
1318 if (paRegs)
1319 {
1320 vrc = DBGFR3RegNmQueryAll(ptrVM.rawUVM(), paRegs, cRegs);
1321 if (RT_SUCCESS(vrc))
1322 {
1323 try
1324 {
1325 aValues.resize(cRegs);
1326 aNames.resize(cRegs);
1327 for (uint32_t iReg = 0; iReg < cRegs; iReg++)
1328 {
1329 char szHex[160];
1330 szHex[159] = szHex[0] = '\0';
1331 ssize_t cch = DBGFR3RegFormatValue(szHex, sizeof(szHex), &paRegs[iReg].Val,
1332 paRegs[iReg].enmType, true /*fSpecial*/);
1333 Assert(cch > 0); NOREF(cch);
1334 aNames[iReg] = Utf8Str(paRegs[iReg].pszName);
1335 aValues[iReg] = Utf8Str(szHex);
1336 }
1337 }
1338 catch (std::bad_alloc)
1339 {
1340 hrc = E_OUTOFMEMORY;
1341 }
1342 }
1343 else
1344 hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
1345
1346 RTMemFree(paRegs);
1347 }
1348 else
1349 hrc = E_OUTOFMEMORY;
1350 }
1351 else
1352 hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
1353 }
1354 return hrc;
1355}
1356
1357HRESULT MachineDebugger::setRegister(ULONG aCpuId, const com::Utf8Str &aName, const com::Utf8Str &aValue)
1358{
1359 ReturnComNotImplemented();
1360}
1361
1362HRESULT MachineDebugger::setRegisters(ULONG aCpuId, const std::vector<com::Utf8Str> &aNames,
1363 const std::vector<com::Utf8Str> &aValues)
1364{
1365 ReturnComNotImplemented();
1366}
1367
1368HRESULT MachineDebugger::dumpGuestStack(ULONG aCpuId, com::Utf8Str &aStack)
1369{
1370 /*
1371 * The prologue.
1372 */
1373 LogFlowThisFunc(("\n"));
1374 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1375 Console::SafeVMPtr ptrVM(mParent);
1376 HRESULT hrc = ptrVM.rc();
1377 if (SUCCEEDED(hrc))
1378 {
1379 /*
1380 * There is currently a problem with the windows diggers and SMP, where
1381 * guest driver memory is being read from CPU zero in order to ensure that
1382 * we've got a consisten virtual memory view. If one of the other CPUs
1383 * initiates a rendezvous while we're unwinding the stack and trying to
1384 * read guest driver memory, we will deadlock.
1385 *
1386 * So, check the VM state and maybe suspend the VM before we continue.
1387 */
1388 int vrc = VINF_SUCCESS;
1389 bool fPaused = false;
1390 if (aCpuId != 0)
1391 {
1392 VMSTATE enmVmState = VMR3GetStateU(ptrVM.rawUVM());
1393 if ( enmVmState == VMSTATE_RUNNING
1394 || enmVmState == VMSTATE_RUNNING_LS
1395 || enmVmState == VMSTATE_RUNNING_FT)
1396 {
1397 alock.release();
1398 vrc = VMR3Suspend(ptrVM.rawUVM(), VMSUSPENDREASON_USER);
1399 alock.acquire();
1400 fPaused = RT_SUCCESS(vrc);
1401 }
1402 }
1403 if (RT_SUCCESS(vrc))
1404 {
1405 PCDBGFSTACKFRAME pFirstFrame;
1406 vrc = DBGFR3StackWalkBegin(ptrVM.rawUVM(), aCpuId, DBGFCODETYPE_GUEST, &pFirstFrame);
1407 if (RT_SUCCESS(vrc))
1408 {
1409 /*
1410 * Print header.
1411 */
1412 try
1413 {
1414 uint32_t fBitFlags = 0;
1415 for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
1416 pFrame;
1417 pFrame = DBGFR3StackWalkNext(pFrame))
1418 {
1419 uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT | DBGFSTACKFRAME_FLAGS_32BIT | DBGFSTACKFRAME_FLAGS_64BIT);
1420 if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
1421 {
1422 if (fCurBitFlags != fBitFlags)
1423 aStack.append("SS:BP Ret SS:BP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
1424 aStack.append(Utf8StrFmt("%04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
1425 pFrame->AddrFrame.Sel,
1426 (uint16_t)pFrame->AddrFrame.off,
1427 pFrame->AddrReturnFrame.Sel,
1428 (uint16_t)pFrame->AddrReturnFrame.off,
1429 (uint32_t)pFrame->AddrReturnPC.Sel,
1430 (uint32_t)pFrame->AddrReturnPC.off,
1431 pFrame->Args.au32[0],
1432 pFrame->Args.au32[1],
1433 pFrame->Args.au32[2],
1434 pFrame->Args.au32[3]));
1435 }
1436 else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
1437 {
1438 if (fCurBitFlags != fBitFlags)
1439 aStack.append("EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
1440 aStack.append(Utf8StrFmt("%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
1441 (uint32_t)pFrame->AddrFrame.off,
1442 (uint32_t)pFrame->AddrReturnFrame.off,
1443 (uint32_t)pFrame->AddrReturnPC.Sel,
1444 (uint32_t)pFrame->AddrReturnPC.off,
1445 pFrame->Args.au32[0],
1446 pFrame->Args.au32[1],
1447 pFrame->Args.au32[2],
1448 pFrame->Args.au32[3]));
1449 }
1450 else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
1451 {
1452 if (fCurBitFlags != fBitFlags)
1453 aStack.append("RBP Ret SS:RBP Ret RIP CS:RIP / Symbol [line]\n");
1454 aStack.append(Utf8StrFmt("%016RX64 %04RX16:%016RX64 %016RX64",
1455 (uint64_t)pFrame->AddrFrame.off,
1456 pFrame->AddrReturnFrame.Sel,
1457 (uint64_t)pFrame->AddrReturnFrame.off,
1458 (uint64_t)pFrame->AddrReturnPC.off));
1459 }
1460
1461 if (!pFrame->pSymPC)
1462 aStack.append(Utf8StrFmt(fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
1463 ? " %RTsel:%016RGv"
1464 : fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
1465 ? " %RTsel:%08RGv"
1466 : " %RTsel:%04RGv"
1467 , pFrame->AddrPC.Sel, pFrame->AddrPC.off));
1468 else
1469 {
1470 RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
1471 if (offDisp > 0)
1472 aStack.append(Utf8StrFmt(" %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp));
1473 else if (offDisp < 0)
1474 aStack.append(Utf8StrFmt(" %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp));
1475 else
1476 aStack.append(Utf8StrFmt(" %s", pFrame->pSymPC->szName));
1477 }
1478 if (pFrame->pLinePC)
1479 aStack.append(Utf8StrFmt(" [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo));
1480 aStack.append(Utf8StrFmt("\n"));
1481
1482 fBitFlags = fCurBitFlags;
1483 }
1484 }
1485 catch (std::bad_alloc)
1486 {
1487 hrc = E_OUTOFMEMORY;
1488 }
1489
1490 DBGFR3StackWalkEnd(pFirstFrame);
1491 }
1492 else
1493 hrc = setError(E_FAIL, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
1494
1495 /*
1496 * Resume the VM if we suspended it.
1497 */
1498 if (fPaused)
1499 {
1500 alock.release();
1501 VMR3Resume(ptrVM.rawUVM(), VMRESUMEREASON_USER);
1502 }
1503 }
1504 else
1505 hrc = setError(E_FAIL, tr("Suspending the VM failed with %Rrc\n"), vrc);
1506 }
1507
1508 return hrc;
1509}
1510
1511/**
1512 * Resets VM statistics.
1513 *
1514 * @returns COM status code.
1515 * @param aPattern The selection pattern. A bit similar to filename globbing.
1516 */
1517HRESULT MachineDebugger::resetStats(const com::Utf8Str &aPattern)
1518{
1519 Console::SafeVMPtrQuiet ptrVM(mParent);
1520
1521 if (!ptrVM.isOk())
1522 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1523
1524 STAMR3Reset(ptrVM.rawUVM(), aPattern.c_str());
1525
1526 return S_OK;
1527}
1528
1529/**
1530 * Dumps VM statistics to the log.
1531 *
1532 * @returns COM status code.
1533 * @param aPattern The selection pattern. A bit similar to filename globbing.
1534 */
1535HRESULT MachineDebugger::dumpStats(const com::Utf8Str &aPattern)
1536{
1537 Console::SafeVMPtrQuiet ptrVM(mParent);
1538
1539 if (!ptrVM.isOk())
1540 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1541
1542 STAMR3Dump(ptrVM.rawUVM(), aPattern.c_str());
1543
1544 return S_OK;
1545}
1546
1547/**
1548 * Get the VM statistics in an XML format.
1549 *
1550 * @returns COM status code.
1551 * @param aPattern The selection pattern. A bit similar to filename globbing.
1552 * @param aWithDescriptions Whether to include the descriptions.
1553 * @param aStats The XML document containing the statistics.
1554 */
1555HRESULT MachineDebugger::getStats(const com::Utf8Str &aPattern, BOOL aWithDescriptions, com::Utf8Str &aStats)
1556{
1557 Console::SafeVMPtrQuiet ptrVM(mParent);
1558
1559 if (!ptrVM.isOk())
1560 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1561
1562 char *pszSnapshot;
1563 int vrc = STAMR3Snapshot(ptrVM.rawUVM(), aPattern.c_str(), &pszSnapshot, NULL,
1564 !!aWithDescriptions);
1565 if (RT_FAILURE(vrc))
1566 return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;
1567
1568 /** @todo this is horribly inefficient! And it's kinda difficult to tell whether it failed...
1569 * Must use UTF-8 or ASCII here and completely avoid these two extra copy operations.
1570 * Until that's done, this method is kind of useless for debugger statistics GUI because
1571 * of the amount statistics in a debug build. */
1572 aStats = Utf8Str(pszSnapshot);
1573 STAMR3SnapshotFree(ptrVM.rawUVM(), pszSnapshot);
1574
1575 return S_OK;
1576}
1577
1578
1579// public methods only for internal purposes
1580/////////////////////////////////////////////////////////////////////////////
1581
1582void MachineDebugger::i_flushQueuedSettings()
1583{
1584 mFlushMode = true;
1585 if (mSingleStepQueued != ~0)
1586 {
1587 COMSETTER(SingleStep)(mSingleStepQueued);
1588 mSingleStepQueued = ~0;
1589 }
1590 for (unsigned i = 0; i < EMEXECPOLICY_END; i++)
1591 if (maiQueuedEmExecPolicyParams[i] != UINT8_MAX)
1592 {
1593 i_setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
1594 maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
1595 }
1596 if (mPatmEnabledQueued != ~0)
1597 {
1598 COMSETTER(PATMEnabled)(mPatmEnabledQueued);
1599 mPatmEnabledQueued = ~0;
1600 }
1601 if (mCsamEnabledQueued != ~0)
1602 {
1603 COMSETTER(CSAMEnabled)(mCsamEnabledQueued);
1604 mCsamEnabledQueued = ~0;
1605 }
1606 if (mLogEnabledQueued != ~0)
1607 {
1608 COMSETTER(LogEnabled)(mLogEnabledQueued);
1609 mLogEnabledQueued = ~0;
1610 }
1611 if (mVirtualTimeRateQueued != ~(uint32_t)0)
1612 {
1613 COMSETTER(VirtualTimeRate)(mVirtualTimeRateQueued);
1614 mVirtualTimeRateQueued = ~0;
1615 }
1616 mFlushMode = false;
1617}
1618
1619// private methods
1620/////////////////////////////////////////////////////////////////////////////
1621
1622bool MachineDebugger::i_queueSettings() const
1623{
1624 if (!mFlushMode)
1625 {
1626 // check if the machine is running
1627 MachineState_T machineState;
1628 mParent->COMGETTER(State)(&machineState);
1629 switch (machineState)
1630 {
1631 // queue the request
1632 default:
1633 return true;
1634
1635 case MachineState_Running:
1636 case MachineState_Paused:
1637 case MachineState_Stuck:
1638 case MachineState_LiveSnapshotting:
1639 case MachineState_Teleporting:
1640 break;
1641 }
1642 }
1643 return false;
1644}
1645/* 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