MachineDebuggerImpl.cpp@ 61572

Last change on this file since 61572 was 61561, checked in by vboxsync, 9 years ago
Main: Implement IMachineDebugger::dumpGuestStack (implementation blatantly copied from the CodeView debugger implementation)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 47.2 KB

Line
1	/* $Id: MachineDebuggerImpl.cpp 61561 2016-06-08 08:37:19Z 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
43	MachineDebugger::MachineDebugger()
44	: mParent(NULL)
45	{
46	}
47
48	MachineDebugger::~MachineDebugger()
49	{
50	}
51
52	HRESULT MachineDebugger::FinalConstruct()
53	{
54	unconst(mParent) = NULL;
55	return BaseFinalConstruct();
56	}
57
58	void 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	*/
73	HRESULT 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	*/
106	void 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	*/
128	HRESULT 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	*/
147	HRESULT 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	*/
167	HRESULT 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	*/
198	HRESULT 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	*/
228	HRESULT 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	*/
239	HRESULT 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	*/
251	HRESULT 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	*/
262	HRESULT 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	*/
274	HRESULT 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	*/
285	HRESULT 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	*/
297	HRESULT 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	*/
318	HRESULT 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	*/
353	HRESULT 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	*/
375	HRESULT 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	*/
410	HRESULT 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	*/
430	HRESULT 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
457	HRESULT 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
501	HRESULT MachineDebugger::getLogDbgFlags(com::Utf8Str &aLogDbgFlags)
502	{
503	return i_logStringProps(RTLogGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", &aLogDbgFlags);
504	}
505
506	HRESULT MachineDebugger::getLogDbgGroups(com::Utf8Str &aLogDbgGroups)
507	{
508	return i_logStringProps(RTLogGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", &aLogDbgGroups);
509	}
510
511	HRESULT MachineDebugger::getLogDbgDestinations(com::Utf8Str &aLogDbgDestinations)
512	{
513	return i_logStringProps(RTLogGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", &aLogDbgDestinations);
514	}
515
516	HRESULT MachineDebugger::getLogRelFlags(com::Utf8Str &aLogRelFlags)
517	{
518	return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", &aLogRelFlags);
519	}
520
521	HRESULT MachineDebugger::getLogRelGroups(com::Utf8Str &aLogRelGroups)
522	{
523	return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", &aLogRelGroups);
524	}
525
526	HRESULT 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	*/
537	HRESULT 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	*/
557	HRESULT 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	*/
577	HRESULT 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	*/
597	HRESULT 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
611	HRESULT 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
642	HRESULT 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	*/
679	HRESULT 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	*/
703	HRESULT 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	*/
721	HRESULT 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	*/
758	HRESULT 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
780	HRESULT 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
800	HRESULT MachineDebugger::dumpHostProcessCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
801	{
802	ReturnComNotImplemented();
803	}
804
805	/**
806	* Debug info string buffer formatter.
807	*/
808	typedef 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. */
822	typedef MACHINEDEBUGGERINOFHLP *PMACHINEDEBUGGERINOFHLP;
823
824
825	/**
826	* @callback_method_impl{FNRTSTROUTPUT}
827	*/
828	static 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	*/
872	static 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	*/
880	static 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	*/
893	static 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	*/
907	static void MachineDebuggerInfoDelete(PMACHINEDEBUGGERINOFHLP pHlp)
908	{
909	RTMemFree(pHlp->pszBuf);
910	pHlp->pszBuf = NULL;
911	}
912
913	HRESULT 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
963	HRESULT 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
981	HRESULT 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
998	HRESULT 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
1015	HRESULT 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
1032	HRESULT MachineDebugger::readPhysicalMemory(LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
1033	{
1034	ReturnComNotImplemented();
1035	}
1036
1037	HRESULT MachineDebugger::writePhysicalMemory(LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
1038	{
1039	ReturnComNotImplemented();
1040	}
1041
1042	HRESULT MachineDebugger::readVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
1043	{
1044	ReturnComNotImplemented();
1045	}
1046
1047	HRESULT MachineDebugger::writeVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
1048	{
1049	ReturnComNotImplemented();
1050	}
1051
1052	HRESULT 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
1103	HRESULT 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
1136	HRESULT 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
1170	HRESULT 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	*/
1227	DECLINLINE(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
1237	HRESULT 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
1281	HRESULT 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
1339	HRESULT MachineDebugger::setRegister(ULONG aCpuId, const com::Utf8Str &aName, const com::Utf8Str &aValue)
1340	{
1341	ReturnComNotImplemented();
1342	}
1343
1344	HRESULT MachineDebugger::setRegisters(ULONG aCpuId, const std::vector<com::Utf8Str> &aNames,
1345	const std::vector<com::Utf8Str> &aValues)
1346	{
1347	ReturnComNotImplemented();
1348	}
1349
1350	HRESULT 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	PCDBGFSTACKFRAME pFirstFrame;
1362
1363	int vrc = DBGFR3StackWalkBegin(ptrVM.rawUVM(), aCpuId, DBGFCODETYPE_GUEST, &pFirstFrame);
1364	if (RT_SUCCESS(vrc))
1365	{
1366	/*
1367	* Print header.
1368	*/
1369	try
1370	{
1371	uint32_t fBitFlags = 0;
1372	for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
1373	pFrame;
1374	pFrame = DBGFR3StackWalkNext(pFrame))
1375	{
1376	uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT \| DBGFSTACKFRAME_FLAGS_32BIT \| DBGFSTACKFRAME_FLAGS_64BIT);
1377	if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
1378	{
1379	if (fCurBitFlags != fBitFlags)
1380	aStack.append("SS:BP Ret SS:BP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
1381	aStack.append(Utf8StrFmt("%04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
1382	pFrame->AddrFrame.Sel,
1383	(uint16_t)pFrame->AddrFrame.off,
1384	pFrame->AddrReturnFrame.Sel,
1385	(uint16_t)pFrame->AddrReturnFrame.off,
1386	(uint32_t)pFrame->AddrReturnPC.Sel,
1387	(uint32_t)pFrame->AddrReturnPC.off,
1388	pFrame->Args.au32[0],
1389	pFrame->Args.au32[1],
1390	pFrame->Args.au32[2],
1391	pFrame->Args.au32[3]));
1392	}
1393	else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
1394	{
1395	if (fCurBitFlags != fBitFlags)
1396	aStack.append("EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
1397	aStack.append(Utf8StrFmt("%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
1398	(uint32_t)pFrame->AddrFrame.off,
1399	(uint32_t)pFrame->AddrReturnFrame.off,
1400	(uint32_t)pFrame->AddrReturnPC.Sel,
1401	(uint32_t)pFrame->AddrReturnPC.off,
1402	pFrame->Args.au32[0],
1403	pFrame->Args.au32[1],
1404	pFrame->Args.au32[2],
1405	pFrame->Args.au32[3]));
1406	}
1407	else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
1408	{
1409	if (fCurBitFlags != fBitFlags)
1410	aStack.append("RBP Ret SS:RBP Ret RIP CS:RIP / Symbol [line]\n");
1411	aStack.append(Utf8StrFmt("%016RX64 %04RX16:%016RX64 %016RX64",
1412	(uint64_t)pFrame->AddrFrame.off,
1413	pFrame->AddrReturnFrame.Sel,
1414	(uint64_t)pFrame->AddrReturnFrame.off,
1415	(uint64_t)pFrame->AddrReturnPC.off));
1416	}
1417
1418	if (!pFrame->pSymPC)
1419	aStack.append(Utf8StrFmt(fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
1420	? " %RTsel:%016RGv"
1421	: fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
1422	? " %RTsel:%08RGv"
1423	: " %RTsel:%04RGv"
1424	, pFrame->AddrPC.Sel, pFrame->AddrPC.off));
1425	else
1426	{
1427	RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
1428	if (offDisp > 0)
1429	aStack.append(Utf8StrFmt(" %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp));
1430	else if (offDisp < 0)
1431	aStack.append(Utf8StrFmt(" %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp));
1432	else
1433	aStack.append(Utf8StrFmt(" %s", pFrame->pSymPC->szName));
1434	}
1435	if (pFrame->pLinePC)
1436	aStack.append(Utf8StrFmt(" [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo));
1437	aStack.append(Utf8StrFmt("\n"));
1438
1439	fBitFlags = fCurBitFlags;
1440	}
1441	}
1442	catch (std::bad_alloc)
1443	{
1444	hrc = E_OUTOFMEMORY;
1445	}
1446
1447	DBGFR3StackWalkEnd(pFirstFrame);
1448	}
1449	else
1450	hrc = setError(E_FAIL, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
1451	}
1452
1453	return hrc;
1454	}
1455
1456	/**
1457	* Resets VM statistics.
1458	*
1459	* @returns COM status code.
1460	* @param aPattern The selection pattern. A bit similar to filename globbing.
1461	*/
1462	HRESULT MachineDebugger::resetStats(const com::Utf8Str &aPattern)
1463	{
1464	Console::SafeVMPtrQuiet ptrVM(mParent);
1465
1466	if (!ptrVM.isOk())
1467	return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1468
1469	STAMR3Reset(ptrVM.rawUVM(), aPattern.c_str());
1470
1471	return S_OK;
1472	}
1473
1474	/**
1475	* Dumps VM statistics to the log.
1476	*
1477	* @returns COM status code.
1478	* @param aPattern The selection pattern. A bit similar to filename globbing.
1479	*/
1480	HRESULT MachineDebugger::dumpStats(const com::Utf8Str &aPattern)
1481	{
1482	Console::SafeVMPtrQuiet ptrVM(mParent);
1483
1484	if (!ptrVM.isOk())
1485	return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1486
1487	STAMR3Dump(ptrVM.rawUVM(), aPattern.c_str());
1488
1489	return S_OK;
1490	}
1491
1492	/**
1493	* Get the VM statistics in an XML format.
1494	*
1495	* @returns COM status code.
1496	* @param aPattern The selection pattern. A bit similar to filename globbing.
1497	* @param aWithDescriptions Whether to include the descriptions.
1498	* @param aStats The XML document containing the statistics.
1499	*/
1500	HRESULT MachineDebugger::getStats(const com::Utf8Str &aPattern, BOOL aWithDescriptions, com::Utf8Str &aStats)
1501	{
1502	Console::SafeVMPtrQuiet ptrVM (mParent);
1503
1504	if (!ptrVM.isOk())
1505	return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1506
1507	char *pszSnapshot;
1508	int vrc = STAMR3Snapshot(ptrVM.rawUVM(), aPattern.c_str(), &pszSnapshot, NULL,
1509	!!aWithDescriptions);
1510	if (RT_FAILURE(vrc))
1511	return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;
1512
1513	/** @todo this is horribly inefficient! And it's kinda difficult to tell whether it failed...
1514	* Must use UTF-8 or ASCII here and completely avoid these two extra copy operations.
1515	* Until that's done, this method is kind of useless for debugger statistics GUI because
1516	* of the amount statistics in a debug build. */
1517	aStats = Utf8Str(pszSnapshot);
1518	STAMR3SnapshotFree(ptrVM.rawUVM(), pszSnapshot);
1519
1520	return S_OK;
1521	}
1522
1523
1524	// public methods only for internal purposes
1525	/////////////////////////////////////////////////////////////////////////////
1526
1527	void MachineDebugger::i_flushQueuedSettings()
1528	{
1529	mFlushMode = true;
1530	if (mSingleStepQueued != ~0)
1531	{
1532	COMSETTER(SingleStep)(mSingleStepQueued);
1533	mSingleStepQueued = ~0;
1534	}
1535	for (unsigned i = 0; i < EMEXECPOLICY_END; i++)
1536	if (maiQueuedEmExecPolicyParams[i] != UINT8_MAX)
1537	{
1538	i_setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
1539	maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
1540	}
1541	if (mPatmEnabledQueued != ~0)
1542	{
1543	COMSETTER(PATMEnabled)(mPatmEnabledQueued);
1544	mPatmEnabledQueued = ~0;
1545	}
1546	if (mCsamEnabledQueued != ~0)
1547	{
1548	COMSETTER(CSAMEnabled)(mCsamEnabledQueued);
1549	mCsamEnabledQueued = ~0;
1550	}
1551	if (mLogEnabledQueued != ~0)
1552	{
1553	COMSETTER(LogEnabled)(mLogEnabledQueued);
1554	mLogEnabledQueued = ~0;
1555	}
1556	if (mVirtualTimeRateQueued != ~(uint32_t)0)
1557	{
1558	COMSETTER(VirtualTimeRate)(mVirtualTimeRateQueued);
1559	mVirtualTimeRateQueued = ~0;
1560	}
1561	mFlushMode = false;
1562	}
1563
1564	// private methods
1565	/////////////////////////////////////////////////////////////////////////////
1566
1567	bool MachineDebugger::i_queueSettings() const
1568	{
1569	if (!mFlushMode)
1570	{
1571	// check if the machine is running
1572	MachineState_T machineState;
1573	mParent->COMGETTER(State)(&machineState);
1574	switch (machineState)
1575	{
1576	// queue the request
1577	default:
1578	return true;
1579
1580	case MachineState_Running:
1581	case MachineState_Paused:
1582	case MachineState_Stuck:
1583	case MachineState_LiveSnapshotting:
1584	case MachineState_Teleporting:
1585	break;
1586	}
1587	}
1588	return false;
1589	}
1590	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: