VirtualBox

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

Last change on this file since 57358 was 57358, checked in by vboxsync, 9 years ago

*: scm cleanup run.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 41.8 KB
Line 
1/* $Id: MachineDebuggerImpl.cpp 57358 2015-08-14 15:16:38Z 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 aEnabled 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 aEnabled 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 = "all";
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 ReturnComNotImplemented();
1353}
1354
1355/**
1356 * Resets VM statistics.
1357 *
1358 * @returns COM status code.
1359 * @param aPattern The selection pattern. A bit similar to filename globbing.
1360 */
1361HRESULT MachineDebugger::resetStats(const com::Utf8Str &aPattern)
1362{
1363 Console::SafeVMPtrQuiet ptrVM(mParent);
1364
1365 if (!ptrVM.isOk())
1366 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1367
1368 STAMR3Reset(ptrVM.rawUVM(), aPattern.c_str());
1369
1370 return S_OK;
1371}
1372
1373/**
1374 * Dumps VM statistics to the log.
1375 *
1376 * @returns COM status code.
1377 * @param aPattern The selection pattern. A bit similar to filename globbing.
1378 */
1379HRESULT MachineDebugger::dumpStats(const com::Utf8Str &aPattern)
1380{
1381 Console::SafeVMPtrQuiet ptrVM(mParent);
1382
1383 if (!ptrVM.isOk())
1384 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1385
1386 STAMR3Dump(ptrVM.rawUVM(), aPattern.c_str());
1387
1388 return S_OK;
1389}
1390
1391/**
1392 * Get the VM statistics in an XML format.
1393 *
1394 * @returns COM status code.
1395 * @param aPattern The selection pattern. A bit similar to filename globbing.
1396 * @param aWithDescriptions Whether to include the descriptions.
1397 * @param aStats The XML document containing the statistics.
1398 */
1399HRESULT MachineDebugger::getStats(const com::Utf8Str &aPattern, BOOL aWithDescriptions, com::Utf8Str &aStats)
1400{
1401 Console::SafeVMPtrQuiet ptrVM (mParent);
1402
1403 if (!ptrVM.isOk())
1404 return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1405
1406 char *pszSnapshot;
1407 int vrc = STAMR3Snapshot(ptrVM.rawUVM(), aPattern.c_str(), &pszSnapshot, NULL,
1408 !!aWithDescriptions);
1409 if (RT_FAILURE(vrc))
1410 return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;
1411
1412 /** @todo this is horribly inefficient! And it's kinda difficult to tell whether it failed...
1413 * Must use UTF-8 or ASCII here and completely avoid these two extra copy operations.
1414 * Until that's done, this method is kind of useless for debugger statistics GUI because
1415 * of the amount statistics in a debug build. */
1416 aStats = Utf8Str(pszSnapshot);
1417 STAMR3SnapshotFree(ptrVM.rawUVM(), pszSnapshot);
1418
1419 return S_OK;
1420}
1421
1422
1423// public methods only for internal purposes
1424/////////////////////////////////////////////////////////////////////////////
1425
1426void MachineDebugger::i_flushQueuedSettings()
1427{
1428 mFlushMode = true;
1429 if (mSingleStepQueued != ~0)
1430 {
1431 COMSETTER(SingleStep)(mSingleStepQueued);
1432 mSingleStepQueued = ~0;
1433 }
1434 for (unsigned i = 0; i < EMEXECPOLICY_END; i++)
1435 if (maiQueuedEmExecPolicyParams[i] != UINT8_MAX)
1436 {
1437 i_setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
1438 maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
1439 }
1440 if (mPatmEnabledQueued != ~0)
1441 {
1442 COMSETTER(PATMEnabled)(mPatmEnabledQueued);
1443 mPatmEnabledQueued = ~0;
1444 }
1445 if (mCsamEnabledQueued != ~0)
1446 {
1447 COMSETTER(CSAMEnabled)(mCsamEnabledQueued);
1448 mCsamEnabledQueued = ~0;
1449 }
1450 if (mLogEnabledQueued != ~0)
1451 {
1452 COMSETTER(LogEnabled)(mLogEnabledQueued);
1453 mLogEnabledQueued = ~0;
1454 }
1455 if (mVirtualTimeRateQueued != ~(uint32_t)0)
1456 {
1457 COMSETTER(VirtualTimeRate)(mVirtualTimeRateQueued);
1458 mVirtualTimeRateQueued = ~0;
1459 }
1460 mFlushMode = false;
1461}
1462
1463// private methods
1464/////////////////////////////////////////////////////////////////////////////
1465
1466bool MachineDebugger::i_queueSettings() const
1467{
1468 if (!mFlushMode)
1469 {
1470 // check if the machine is running
1471 MachineState_T machineState;
1472 mParent->COMGETTER(State)(&machineState);
1473 switch (machineState)
1474 {
1475 // queue the request
1476 default:
1477 return true;
1478
1479 case MachineState_Running:
1480 case MachineState_Paused:
1481 case MachineState_Stuck:
1482 case MachineState_LiveSnapshotting:
1483 case MachineState_Teleporting:
1484 break;
1485 }
1486 }
1487 return false;
1488}
1489/* 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