MachineDebuggerImpl.cpp@ 39336

Last change on this file since 39336 was 38324, checked in by vboxsync, 13 years ago
FE/Qt,FE/BFE,MachineDebugger,EM: Added execution scheduling options to the Qt GUI and reworked the main/VMM interface.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.2 KB

Line
1	/* $Id: MachineDebuggerImpl.cpp 38324 2011-08-05 14:02:53Z vboxsync $ */
2	/** @file
3	* VBox IMachineDebugger COM class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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	#include "MachineDebuggerImpl.h"
19
20	#include "Global.h"
21	#include "ConsoleImpl.h"
22
23	#include "AutoCaller.h"
24	#include "Logging.h"
25
26	#include <VBox/vmm/em.h>
27	#include <VBox/vmm/patm.h>
28	#include <VBox/vmm/csam.h>
29	#include <VBox/vmm/vm.h>
30	#include <VBox/vmm/tm.h>
31	#include <VBox/vmm/hwaccm.h>
32	#include <VBox/err.h>
33	#include <iprt/cpp/utils.h>
34
35	// defines
36	/////////////////////////////////////////////////////////////////////////////
37
38
39	// globals
40	/////////////////////////////////////////////////////////////////////////////
41
42
43	// constructor / destructor
44	/////////////////////////////////////////////////////////////////////////////
45
46	MachineDebugger::MachineDebugger()
47	: mParent(NULL)
48	{
49	}
50
51	MachineDebugger::~MachineDebugger()
52	{
53	}
54
55	HRESULT MachineDebugger::FinalConstruct()
56	{
57	unconst(mParent) = NULL;
58	return BaseFinalConstruct();
59	}
60
61	void MachineDebugger::FinalRelease()
62	{
63	uninit();
64	BaseFinalRelease();
65	}
66
67	// public initializer/uninitializer for internal purposes only
68	/////////////////////////////////////////////////////////////////////////////
69
70	/**
71	* Initializes the machine debugger object.
72	*
73	* @returns COM result indicator
74	* @param aParent handle of our parent object
75	*/
76	HRESULT MachineDebugger::init (Console *aParent)
77	{
78	LogFlowThisFunc(("aParent=%p\n", aParent));
79
80	ComAssertRet(aParent, E_INVALIDARG);
81
82	/* Enclose the state transition NotReady->InInit->Ready */
83	AutoInitSpan autoInitSpan(this);
84	AssertReturn(autoInitSpan.isOk(), E_FAIL);
85
86	unconst(mParent) = aParent;
87
88	mSinglestepQueued = ~0;
89	mRecompileUserQueued = ~0;
90	mRecompileSupervisorQueued = ~0;
91	mPatmEnabledQueued = ~0;
92	mCsamEnabledQueued = ~0;
93	mLogEnabledQueued = ~0;
94	mVirtualTimeRateQueued = ~0;
95	mFlushMode = false;
96
97	/* Confirm a successful initialization */
98	autoInitSpan.setSucceeded();
99
100	return S_OK;
101	}
102
103	/**
104	* Uninitializes the instance and sets the ready flag to FALSE.
105	* Called either from FinalRelease() or by the parent when it gets destroyed.
106	*/
107	void MachineDebugger::uninit()
108	{
109	LogFlowThisFunc(("\n"));
110
111	/* Enclose the state transition Ready->InUninit->NotReady */
112	AutoUninitSpan autoUninitSpan(this);
113	if (autoUninitSpan.uninitDone())
114	return;
115
116	unconst(mParent) = NULL;
117	mFlushMode = false;
118	}
119
120	// IMachineDebugger properties
121	/////////////////////////////////////////////////////////////////////////////
122
123	/**
124	* Returns the current singlestepping flag.
125	*
126	* @returns COM status code
127	* @param aEnabled address of result variable
128	*/
129	STDMETHODIMP MachineDebugger::COMGETTER(Singlestep) (BOOL *aEnabled)
130	{
131	CheckComArgOutPointerValid(aEnabled);
132
133	AutoCaller autoCaller(this);
134	if (FAILED(autoCaller.rc())) return autoCaller.rc();
135
136	/** @todo */
137	ReturnComNotImplemented();
138	}
139
140	/**
141	* Sets the singlestepping flag.
142	*
143	* @returns COM status code
144	* @param aEnable new singlestepping flag
145	*/
146	STDMETHODIMP MachineDebugger::COMSETTER(Singlestep) (BOOL aEnable)
147	{
148	AutoCaller autoCaller(this);
149	if (FAILED(autoCaller.rc())) return autoCaller.rc();
150
151	/** @todo */
152	ReturnComNotImplemented();
153	}
154
155	/**
156	* Returns the current recompile user mode code flag.
157	*
158	* @returns COM status code
159	* @param aEnabled address of result variable
160	*/
161	STDMETHODIMP MachineDebugger::COMGETTER(RecompileUser) (BOOL *aEnabled)
162	{
163	CheckComArgOutPointerValid(aEnabled);
164
165	AutoCaller autoCaller(this);
166	if (FAILED(autoCaller.rc())) return autoCaller.rc();
167
168	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
169
170	Console::SafeVMPtrQuiet pVM (mParent);
171
172	if (pVM.isOk())
173	*aEnabled = !EMIsRawRing3Enabled (pVM.raw());
174	else
175	*aEnabled = false;
176
177	return S_OK;
178	}
179
180	/**
181	* Sets the recompile user mode code flag.
182	*
183	* @returns COM status
184	* @param aEnable new user mode code recompile flag.
185	*/
186	STDMETHODIMP MachineDebugger::COMSETTER(RecompileUser)(BOOL aEnable)
187	{
188	LogFlowThisFunc(("enable=%d\n", aEnable));
189
190	AutoCaller autoCaller(this);
191	HRESULT hrc = autoCaller.rc();
192	if (SUCCEEDED(hrc))
193	{
194	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
195	if (queueSettings())
196	mRecompileUserQueued = aEnable; // queue the request
197	else
198	{
199	Console::SafeVMPtr ptrVM(mParent);
200	hrc = ptrVM.rc();
201	if (SUCCEEDED(hrc))
202	{
203	int vrc = EMR3SetExecutionPolicy(ptrVM.raw(), EMEXECPOLICY_RECOMPILE_RING3, RT_BOOL(aEnable));
204	if (RT_FAILURE(vrc))
205	hrc = setError(VBOX_E_VM_ERROR, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
206	}
207	}
208	}
209	return hrc;
210	}
211
212	/**
213	* Returns the current recompile supervisor code flag.
214	*
215	* @returns COM status code
216	* @param aEnabled address of result variable
217	*/
218	STDMETHODIMP MachineDebugger::COMGETTER(RecompileSupervisor) (BOOL *aEnabled)
219	{
220	CheckComArgOutPointerValid(aEnabled);
221
222	AutoCaller autoCaller(this);
223	if (FAILED(autoCaller.rc())) return autoCaller.rc();
224
225	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
226
227	Console::SafeVMPtrQuiet pVM (mParent);
228
229	if (pVM.isOk())
230	*aEnabled = !EMIsRawRing0Enabled (pVM.raw());
231	else
232	*aEnabled = false;
233
234	return S_OK;
235	}
236
237	/**
238	* Sets the new recompile supervisor code flag.
239	*
240	* @returns COM status code
241	* @param aEnable new recompile supervisor code flag
242	*/
243	STDMETHODIMP MachineDebugger::COMSETTER(RecompileSupervisor)(BOOL aEnable)
244	{
245	LogFlowThisFunc(("enable=%d\n", aEnable));
246
247	AutoCaller autoCaller(this);
248	HRESULT hrc = autoCaller.rc();
249	if (SUCCEEDED(hrc))
250	{
251	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
252	if (queueSettings())
253	mRecompileSupervisorQueued = aEnable; // queue the request
254	else
255	{
256	Console::SafeVMPtr ptrVM(mParent);
257	hrc = ptrVM.rc();
258	if (SUCCEEDED(hrc))
259	{
260	int vrc = EMR3SetExecutionPolicy(ptrVM.raw(), EMEXECPOLICY_RECOMPILE_RING0, RT_BOOL(aEnable));
261	if (RT_FAILURE(vrc))
262	hrc = setError(VBOX_E_VM_ERROR, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
263	}
264	}
265	}
266	return hrc;
267	}
268
269	/**
270	* Returns the current patch manager enabled flag.
271	*
272	* @returns COM status code
273	* @param aEnabled address of result variable
274	*/
275	STDMETHODIMP MachineDebugger::COMGETTER(PATMEnabled) (BOOL *aEnabled)
276	{
277	CheckComArgOutPointerValid(aEnabled);
278
279	AutoCaller autoCaller(this);
280	if (FAILED(autoCaller.rc())) return autoCaller.rc();
281
282	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
283
284	Console::SafeVMPtrQuiet pVM (mParent);
285
286	if (pVM.isOk())
287	*aEnabled = PATMIsEnabled (pVM.raw());
288	else
289	*aEnabled = false;
290
291	return S_OK;
292	}
293
294	/**
295	* Set the new patch manager enabled flag.
296	*
297	* @returns COM status code
298	* @param aEnable new patch manager enabled flag
299	*/
300	STDMETHODIMP MachineDebugger::COMSETTER(PATMEnabled) (BOOL aEnable)
301	{
302	LogFlowThisFunc(("enable=%d\n", aEnable));
303
304	AutoCaller autoCaller(this);
305	if (FAILED(autoCaller.rc())) return autoCaller.rc();
306
307	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
308
309	if (queueSettings())
310	{
311	// queue the request
312	mPatmEnabledQueued = aEnable;
313	return S_OK;
314	}
315
316	Console::SafeVMPtr pVM(mParent);
317	if (FAILED(pVM.rc())) return pVM.rc();
318
319	PATMR3AllowPatching (pVM, aEnable);
320
321	return S_OK;
322	}
323
324	/**
325	* Returns the current code scanner enabled flag.
326	*
327	* @returns COM status code
328	* @param aEnabled address of result variable
329	*/
330	STDMETHODIMP MachineDebugger::COMGETTER(CSAMEnabled) (BOOL *aEnabled)
331	{
332	CheckComArgOutPointerValid(aEnabled);
333
334	AutoCaller autoCaller(this);
335	if (FAILED(autoCaller.rc())) return autoCaller.rc();
336
337	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
338
339	Console::SafeVMPtrQuiet pVM (mParent);
340
341	if (pVM.isOk())
342	*aEnabled = CSAMIsEnabled (pVM.raw());
343	else
344	*aEnabled = false;
345
346	return S_OK;
347	}
348
349	/**
350	* Sets the new code scanner enabled flag.
351	*
352	* @returns COM status code
353	* @param aEnable new code scanner enabled flag
354	*/
355	STDMETHODIMP MachineDebugger::COMSETTER(CSAMEnabled) (BOOL aEnable)
356	{
357	LogFlowThisFunc(("enable=%d\n", aEnable));
358
359	AutoCaller autoCaller(this);
360	if (FAILED(autoCaller.rc())) return autoCaller.rc();
361
362	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
363
364	if (queueSettings())
365	{
366	// queue the request
367	mCsamEnabledQueued = aEnable;
368	return S_OK;
369	}
370
371	Console::SafeVMPtr pVM(mParent);
372	if (FAILED(pVM.rc())) return pVM.rc();
373
374	int vrc;
375	if (aEnable)
376	vrc = CSAMEnableScanning (pVM);
377	else
378	vrc = CSAMDisableScanning (pVM);
379
380	if (RT_FAILURE(vrc))
381	{
382	/** @todo handle error case */
383	}
384
385	return S_OK;
386	}
387
388	/**
389	* Returns the log enabled / disabled status.
390	*
391	* @returns COM status code
392	* @param aEnabled address of result variable
393	*/
394	STDMETHODIMP MachineDebugger::COMGETTER(LogEnabled) (BOOL *aEnabled)
395	{
396	CheckComArgOutPointerValid(aEnabled);
397
398	AutoCaller autoCaller(this);
399	if (FAILED(autoCaller.rc())) return autoCaller.rc();
400
401	#ifdef LOG_ENABLED
402	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
403
404	const PRTLOGGER pLogInstance = RTLogDefaultInstance();
405	*aEnabled = pLogInstance && !(pLogInstance->fFlags & RTLOGFLAGS_DISABLED);
406	#else
407	*aEnabled = false;
408	#endif
409
410	return S_OK;
411	}
412
413	/**
414	* Enables or disables logging.
415	*
416	* @returns COM status code
417	* @param aEnabled The new code log state.
418	*/
419	STDMETHODIMP MachineDebugger::COMSETTER(LogEnabled) (BOOL aEnabled)
420	{
421	LogFlowThisFunc(("aEnabled=%d\n", aEnabled));
422
423	AutoCaller autoCaller(this);
424	if (FAILED(autoCaller.rc())) return autoCaller.rc();
425
426	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
427
428	if (queueSettings())
429	{
430	// queue the request
431	mLogEnabledQueued = aEnabled;
432	return S_OK;
433	}
434
435	Console::SafeVMPtr pVM(mParent);
436	if (FAILED(pVM.rc())) return pVM.rc();
437
438	#ifdef LOG_ENABLED
439	int vrc = DBGFR3LogModifyFlags (pVM, aEnabled ? "enabled" : "disabled");
440	if (RT_FAILURE(vrc))
441	{
442	/** @todo handle error code. */
443	}
444	#endif
445
446	return S_OK;
447	}
448
449	STDMETHODIMP MachineDebugger::COMGETTER(LogFlags)(BSTR *a_pbstrSettings)
450	{
451	ReturnComNotImplemented();
452	}
453
454	STDMETHODIMP MachineDebugger::COMGETTER(LogGroups)(BSTR *a_pbstrSettings)
455	{
456	ReturnComNotImplemented();
457	}
458
459	STDMETHODIMP MachineDebugger::COMGETTER(LogDestinations)(BSTR *a_pbstrSettings)
460	{
461	ReturnComNotImplemented();
462	}
463
464	/**
465	* Returns the current hardware virtualization flag.
466	*
467	* @returns COM status code
468	* @param aEnabled address of result variable
469	*/
470	STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExEnabled) (BOOL *aEnabled)
471	{
472	CheckComArgOutPointerValid(aEnabled);
473
474	AutoCaller autoCaller(this);
475	if (FAILED(autoCaller.rc())) return autoCaller.rc();
476
477	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
478
479	Console::SafeVMPtrQuiet pVM (mParent);
480
481	if (pVM.isOk())
482	*aEnabled = HWACCMIsEnabled (pVM.raw());
483	else
484	*aEnabled = false;
485
486	return S_OK;
487	}
488
489	/**
490	* Returns the current nested paging flag.
491	*
492	* @returns COM status code
493	* @param aEnabled address of result variable
494	*/
495	STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExNestedPagingEnabled) (BOOL *aEnabled)
496	{
497	CheckComArgOutPointerValid(aEnabled);
498
499	AutoCaller autoCaller(this);
500	if (FAILED(autoCaller.rc())) return autoCaller.rc();
501
502	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
503
504	Console::SafeVMPtrQuiet pVM (mParent);
505
506	if (pVM.isOk())
507	*aEnabled = HWACCMR3IsNestedPagingActive (pVM.raw());
508	else
509	*aEnabled = false;
510
511	return S_OK;
512	}
513
514	/**
515	* Returns the current VPID flag.
516	*
517	* @returns COM status code
518	* @param aEnabled address of result variable
519	*/
520	STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExVPIDEnabled) (BOOL *aEnabled)
521	{
522	CheckComArgOutPointerValid(aEnabled);
523
524	AutoCaller autoCaller(this);
525	if (FAILED(autoCaller.rc())) return autoCaller.rc();
526
527	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
528
529	Console::SafeVMPtrQuiet pVM (mParent);
530
531	if (pVM.isOk())
532	*aEnabled = HWACCMR3IsVPIDActive (pVM.raw());
533	else
534	*aEnabled = false;
535
536	return S_OK;
537	}
538
539	STDMETHODIMP MachineDebugger::COMGETTER(OSName)(BSTR *a_pbstrName)
540	{
541	LogFlowThisFunc(("\n"));
542	CheckComArgNotNull(a_pbstrName);
543	AutoCaller autoCaller(this);
544	HRESULT hrc = autoCaller.rc();
545	if (SUCCEEDED(hrc))
546	{
547	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
548	Console::SafeVMPtr ptrVM(mParent);
549	hrc = ptrVM.rc();
550	if (SUCCEEDED(hrc))
551	{
552	/*
553	* Do the job and try convert the name.
554	*/
555	char szName[64];
556	int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.raw(), szName, sizeof(szName), NULL, 0);
557	if (RT_SUCCESS(vrc))
558	{
559	try
560	{
561	Bstr bstrName(szName);
562	bstrName.detachTo(a_pbstrName);
563	}
564	catch (std::bad_alloc)
565	{
566	hrc = E_OUTOFMEMORY;
567	}
568	}
569	else
570	hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
571	}
572	}
573	return hrc;
574	}
575
576	STDMETHODIMP MachineDebugger::COMGETTER(OSVersion)(BSTR *a_pbstrVersion)
577	{
578	LogFlowThisFunc(("\n"));
579	CheckComArgNotNull(a_pbstrVersion);
580	AutoCaller autoCaller(this);
581	HRESULT hrc = autoCaller.rc();
582	if (SUCCEEDED(hrc))
583	{
584	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
585	Console::SafeVMPtr ptrVM(mParent);
586	hrc = ptrVM.rc();
587	if (SUCCEEDED(hrc))
588	{
589	/*
590	* Do the job and try convert the name.
591	*/
592	char szVersion[256];
593	int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.raw(), NULL, 0, szVersion, sizeof(szVersion));
594	if (RT_SUCCESS(vrc))
595	{
596	try
597	{
598	Bstr bstrVersion(szVersion);
599	bstrVersion.detachTo(a_pbstrVersion);
600	}
601	catch (std::bad_alloc)
602	{
603	hrc = E_OUTOFMEMORY;
604	}
605	}
606	else
607	hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
608	}
609	}
610	return hrc;
611	}
612
613	/**
614	* Returns the current PAE flag.
615	*
616	* @returns COM status code
617	* @param aEnabled address of result variable
618	*/
619	STDMETHODIMP MachineDebugger::COMGETTER(PAEEnabled) (BOOL *aEnabled)
620	{
621	CheckComArgOutPointerValid(aEnabled);
622
623	AutoCaller autoCaller(this);
624	if (FAILED(autoCaller.rc())) return autoCaller.rc();
625
626	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
627
628	Console::SafeVMPtrQuiet pVM (mParent);
629
630	if (pVM.isOk())
631	{
632	uint64_t cr4 = CPUMGetGuestCR4 (VMMGetCpu0(pVM.raw()));
633	*aEnabled = !!(cr4 & X86_CR4_PAE);
634	}
635	else
636	*aEnabled = false;
637
638	return S_OK;
639	}
640
641	/**
642	* Returns the current virtual time rate.
643	*
644	* @returns COM status code.
645	* @param aPct Where to store the rate.
646	*/
647	STDMETHODIMP MachineDebugger::COMGETTER(VirtualTimeRate) (ULONG *aPct)
648	{
649	CheckComArgOutPointerValid(aPct);
650
651	AutoCaller autoCaller(this);
652	if (FAILED(autoCaller.rc())) return autoCaller.rc();
653
654	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
655
656	Console::SafeVMPtrQuiet pVM (mParent);
657
658	if (pVM.isOk())
659	*aPct = TMGetWarpDrive (pVM);
660	else
661	*aPct = 100;
662
663	return S_OK;
664	}
665
666	/**
667	* Returns the current virtual time rate.
668	*
669	* @returns COM status code.
670	* @param aPct Where to store the rate.
671	*/
672	STDMETHODIMP MachineDebugger::COMSETTER(VirtualTimeRate) (ULONG aPct)
673	{
674	if (aPct < 2 \|\| aPct > 20000)
675	return E_INVALIDARG;
676
677	AutoCaller autoCaller(this);
678	if (FAILED(autoCaller.rc())) return autoCaller.rc();
679
680	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
681
682	if (queueSettings())
683	{
684	// queue the request
685	mVirtualTimeRateQueued = aPct;
686	return S_OK;
687	}
688
689	Console::SafeVMPtr pVM(mParent);
690	if (FAILED(pVM.rc())) return pVM.rc();
691
692	int vrc = TMR3SetWarpDrive (pVM, aPct);
693	if (RT_FAILURE(vrc))
694	{
695	/** @todo handle error code. */
696	}
697
698	return S_OK;
699	}
700
701	/**
702	* Hack for getting the VM handle.
703	* This is only temporary (promise) while prototyping the debugger.
704	*
705	* @returns COM status code
706	* @param aVm Where to store the vm handle.
707	* Since there is no uintptr_t in COM, we're using the max integer.
708	* (No, ULONG is not pointer sized!)
709	*/
710	STDMETHODIMP MachineDebugger::COMGETTER(VM) (LONG64 *aVm)
711	{
712	CheckComArgOutPointerValid(aVm);
713
714	AutoCaller autoCaller(this);
715	if (FAILED(autoCaller.rc())) return autoCaller.rc();
716
717	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
718
719	Console::SafeVMPtr pVM(mParent);
720	if (FAILED(pVM.rc())) return pVM.rc();
721
722	*aVm = (intptr_t)pVM.raw();
723
724	/*
725	* Note: pVM protection provided by SafeVMPtr is no more effective
726	* after we return from this method.
727	*/
728
729	return S_OK;
730	}
731
732	// IMachineDebugger methods
733	/////////////////////////////////////////////////////////////////////////////
734
735	STDMETHODIMP MachineDebugger::DumpGuestCore(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression)
736	{
737	CheckComArgStrNotEmptyOrNull(a_bstrFilename);
738	Utf8Str strFilename(a_bstrFilename);
739	if (a_bstrCompression && *a_bstrCompression)
740	return setError(E_INVALIDARG, tr("The compression parameter must be empty"));
741
742	AutoCaller autoCaller(this);
743	HRESULT hrc = autoCaller.rc();
744	if (SUCCEEDED(hrc))
745	{
746	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
747	Console::SafeVMPtr ptrVM(mParent);
748	hrc = ptrVM.rc();
749	if (SUCCEEDED(hrc))
750	{
751	int vrc = DBGFR3CoreWrite(ptrVM, strFilename.c_str(), false /fReplaceFile/);
752	if (RT_SUCCESS(vrc))
753	hrc = S_OK;
754	else
755	hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
756	}
757	}
758
759	return hrc;
760	}
761
762	STDMETHODIMP MachineDebugger::DumpHostProcessCore(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression)
763	{
764	ReturnComNotImplemented();
765	}
766
767	/**
768	* Debug info string buffer formatter.
769	*/
770	typedef struct MACHINEDEBUGGERINOFHLP
771	{
772	/** The core info helper structure. */
773	DBGFINFOHLP Core;
774	/** Pointer to the buffer. */
775	char *pszBuf;
776	/** The size of the buffer. */
777	size_t cbBuf;
778	/** The offset into the buffer */
779	size_t offBuf;
780	/** Indicates an out-of-memory condition. */
781	bool fOutOfMemory;
782	} MACHINEDEBUGGERINOFHLP;
783	/** Pointer to a Debug info string buffer formatter. */
784	typedef MACHINEDEBUGGERINOFHLP *PMACHINEDEBUGGERINOFHLP;
785
786
787	/**
788	* @callback_method_impl{FNRTSTROUTPUT}
789	*/
790	static DECLCALLBACK(size_t) MachineDebuggerInfoOutput(void pvArg, const char pachChars, size_t cbChars)
791	{
792	PMACHINEDEBUGGERINOFHLP pHlp = (PMACHINEDEBUGGERINOFHLP)pvArg;
793
794	/*
795	* Grow the buffer if required.
796	*/
797	size_t const cbRequired = cbChars + pHlp->offBuf + 1;
798	if (cbRequired > pHlp->cbBuf)
799	{
800	if (RT_UNLIKELY(pHlp->fOutOfMemory))
801	return 0;
802
803	size_t cbBufNew = pHlp->cbBuf * 2;
804	if (cbRequired > cbBufNew)
805	cbBufNew = RT_ALIGN_Z(cbRequired, 256);
806	void *pvBufNew = RTMemRealloc(pHlp->pszBuf, cbBufNew);
807	if (RT_UNLIKELY(!pvBufNew))
808	{
809	pHlp->fOutOfMemory = true;
810	RTMemFree(pHlp->pszBuf);
811	pHlp->pszBuf = NULL;
812	pHlp->cbBuf = 0;
813	pHlp->offBuf = 0;
814	return 0;
815	}
816
817	pHlp->pszBuf = (char *)pvBufNew;
818	pHlp->cbBuf = cbBufNew;
819	}
820
821	/*
822	* Copy the bytes into the buffer and terminate it.
823	*/
824	memcpy(&pHlp->pszBuf[pHlp->offBuf], pachChars, cbChars);
825	pHlp->offBuf += cbChars;
826	pHlp->pszBuf[pHlp->offBuf] = '\0';
827	Assert(pHlp->offBuf < pHlp->cbBuf);
828	return cbChars;
829	}
830
831	/**
832	* @interface_method_impl{DBGFINFOHLP, pfnPrintfV}
833	*/
834	static DECLCALLBACK(void) MachineDebuggerInfoPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list va)
835	{
836	RTStrFormatV(MachineDebuggerInfoOutput, (void *)pHlp, NULL, NULL, pszFormat, va);
837	}
838
839	/**
840	* @interface_method_impl{DBGFINFOHLP, pfnPrintf}
841	*/
842	static DECLCALLBACK(void) MachineDebuggerInfoPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
843	{
844	va_list va;
845	va_start(va, pszFormat);
846	MachineDebuggerInfoPrintfV(pHlp, pszFormat, va);
847	va_end(va);
848	}
849
850	/**
851	* Initializes the debug info string buffer formatter
852	*
853	* @param pHlp The help structure to init.
854	*/
855	static void MachineDebuggerInfoInit(PMACHINEDEBUGGERINOFHLP pHlp)
856	{
857	pHlp->Core.pfnPrintf = MachineDebuggerInfoPrintf;
858	pHlp->Core.pfnPrintfV = MachineDebuggerInfoPrintfV;
859	pHlp->pszBuf = NULL;
860	pHlp->cbBuf = 0;
861	pHlp->offBuf = 0;
862	pHlp->fOutOfMemory = false;
863	}
864
865	/**
866	* Deletes the debug info string buffer formatter.
867	* @param pHlp The helper structure to delete.
868	*/
869	static void MachineDebuggerInfoDelete(PMACHINEDEBUGGERINOFHLP pHlp)
870	{
871	RTMemFree(pHlp->pszBuf);
872	pHlp->pszBuf = NULL;
873	}
874
875	STDMETHODIMP MachineDebugger::Info(IN_BSTR a_bstrName, IN_BSTR a_bstrArgs, BSTR *a_pbstrInfo)
876	{
877	LogFlowThisFunc(("\n"));
878
879	/*
880	* Validate and convert input.
881	*/
882	CheckComArgStrNotEmptyOrNull(a_bstrName);
883	Utf8Str strName, strArgs;
884	try
885	{
886	strName = a_bstrName;
887	strArgs = a_bstrArgs;
888	}
889	catch (std::bad_alloc)
890	{
891	return E_OUTOFMEMORY;
892	}
893
894	/*
895	* Do the autocaller and lock bits.
896	*/
897	AutoCaller autoCaller(this);
898	HRESULT hrc = autoCaller.rc();
899	if (SUCCEEDED(hrc))
900	{
901	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
902	Console::SafeVMPtr ptrVM(mParent);
903	hrc = ptrVM.rc();
904	if (SUCCEEDED(hrc))
905	{
906	/*
907	* Create a helper and call DBGFR3Info.
908	*/
909	MACHINEDEBUGGERINOFHLP Hlp;
910	MachineDebuggerInfoInit(&Hlp);
911	int vrc = DBGFR3Info(ptrVM.raw(), strName.c_str(), strArgs.c_str(), &Hlp.Core);
912	if (RT_SUCCESS(vrc))
913	{
914	if (!Hlp.fOutOfMemory)
915	{
916	/*
917	* Convert the info string, watching out for allocation errors.
918	*/
919	try
920	{
921	Bstr bstrInfo(Hlp.pszBuf);
922	bstrInfo.detachTo(a_pbstrInfo);
923	}
924	catch (std::bad_alloc)
925	{
926	hrc = E_OUTOFMEMORY;
927	}
928	}
929	else
930	hrc = E_OUTOFMEMORY;
931	}
932	else
933	hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3Info failed with %Rrc"), vrc);
934	MachineDebuggerInfoDelete(&Hlp);
935	}
936	}
937	return hrc;
938	}
939
940	STDMETHODIMP MachineDebugger::InjectNMI()
941	{
942	LogFlowThisFunc(("\n"));
943
944	AutoCaller autoCaller(this);
945	HRESULT hrc = autoCaller.rc();
946	if (SUCCEEDED(hrc))
947	{
948	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
949	Console::SafeVMPtr ptrVM(mParent);
950	hrc = ptrVM.rc();
951	if (SUCCEEDED(hrc))
952	{
953	int vrc = HWACCMR3InjectNMI(ptrVM);
954	if (RT_SUCCESS(vrc))
955	hrc = S_OK;
956	else
957	hrc = setError(E_FAIL, tr("HWACCMR3InjectNMI failed with %Rrc"), vrc);
958	}
959	}
960	return hrc;
961	}
962
963	STDMETHODIMP MachineDebugger::ModifyLogFlags(IN_BSTR a_bstrSettings)
964	{
965	ReturnComNotImplemented();
966	}
967
968	STDMETHODIMP MachineDebugger::ModifyLogGroups(IN_BSTR a_bstrSettings)
969	{
970	ReturnComNotImplemented();
971	}
972
973	STDMETHODIMP MachineDebugger::ModifyLogDestinations(IN_BSTR a_bstrSettings)
974	{
975	ReturnComNotImplemented();
976	}
977
978	STDMETHODIMP MachineDebugger::ReadPhysicalMemory(LONG64 a_Address, ULONG a_cbRead, ComSafeArrayOut(BYTE, a_abData))
979	{
980	ReturnComNotImplemented();
981	}
982
983	STDMETHODIMP MachineDebugger::WritePhysicalMemory(LONG64 a_Address, ULONG a_cbRead, ComSafeArrayIn(BYTE, a_abData))
984	{
985	ReturnComNotImplemented();
986	}
987
988	STDMETHODIMP MachineDebugger::ReadVirtualMemory(ULONG a_idCpu, LONG64 a_Address, ULONG a_cbRead, ComSafeArrayOut(BYTE, a_abData))
989	{
990	ReturnComNotImplemented();
991	}
992
993	STDMETHODIMP MachineDebugger::WriteVirtualMemory(ULONG a_idCpu, LONG64 a_Address, ULONG a_cbRead, ComSafeArrayIn(BYTE, a_abData))
994	{
995	ReturnComNotImplemented();
996	}
997
998	STDMETHODIMP MachineDebugger::DetectOS(BSTR *a_pbstrName)
999	{
1000	LogFlowThisFunc(("\n"));
1001	CheckComArgNotNull(a_pbstrName);
1002
1003	/*
1004	* Do the autocaller and lock bits.
1005	*/
1006	AutoCaller autoCaller(this);
1007	HRESULT hrc = autoCaller.rc();
1008	if (SUCCEEDED(hrc))
1009	{
1010	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1011	Console::SafeVMPtr ptrVM(mParent);
1012	hrc = ptrVM.rc();
1013	if (SUCCEEDED(hrc))
1014	{
1015	/*
1016	* Do the job and try convert the name.
1017	*/
1018	/** @todo automatically load the DBGC plugins or this is a waste of time. */
1019	char szName[64];
1020	int vrc = DBGFR3OSDetect(ptrVM.raw(), szName, sizeof(szName));
1021	if (RT_SUCCESS(vrc) && vrc != VINF_DBGF_OS_NOT_DETCTED)
1022	{
1023	try
1024	{
1025	Bstr bstrName(szName);
1026	bstrName.detachTo(a_pbstrName);
1027	}
1028	catch (std::bad_alloc)
1029	{
1030	hrc = E_OUTOFMEMORY;
1031	}
1032	}
1033	else
1034	hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
1035	}
1036	}
1037	return hrc;
1038	}
1039
1040	/**
1041	* Formats a register value.
1042	*
1043	* This is used by both register getter methods.
1044	*
1045	* @returns
1046	* @param a_pbstr The output Bstr variable.
1047	* @param a_pValue The value to format.
1048	* @param a_enmType The type of the value.
1049	*/
1050	DECLINLINE(HRESULT) formatRegisterValue(Bstr *a_pbstr, PCDBGFREGVAL a_pValue, DBGFREGVALTYPE a_enmType)
1051	{
1052	char szHex[160];
1053	ssize_t cch = DBGFR3RegFormatValue(szHex, sizeof(szHex), a_pValue, a_enmType, true /fSpecial/);
1054	if (RT_UNLIKELY(cch <= 0))
1055	return E_UNEXPECTED;
1056	*a_pbstr = szHex;
1057	return S_OK;
1058	}
1059
1060	STDMETHODIMP MachineDebugger::GetRegister(ULONG a_idCpu, IN_BSTR a_bstrName, BSTR *a_pbstrValue)
1061	{
1062	/*
1063	* Validate and convert input.
1064	*/
1065	CheckComArgStrNotEmptyOrNull(a_bstrName);
1066	CheckComArgNotNull(a_pbstrValue);
1067	Utf8Str strName;
1068	try
1069	{
1070	strName = a_bstrName;
1071	}
1072	catch (std::bad_alloc)
1073	{
1074	return E_OUTOFMEMORY;
1075	}
1076
1077	/*
1078	* The prologue.
1079	*/
1080	LogFlowThisFunc(("\n"));
1081	AutoCaller autoCaller(this);
1082	HRESULT hrc = autoCaller.rc();
1083	if (SUCCEEDED(hrc))
1084	{
1085	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1086	Console::SafeVMPtr ptrVM(mParent);
1087	hrc = ptrVM.rc();
1088	if (SUCCEEDED(hrc))
1089	{
1090	/*
1091	* Real work.
1092	*/
1093	DBGFREGVAL Value;
1094	DBGFREGVALTYPE enmType;
1095	int vrc = DBGFR3RegNmQuery(ptrVM.raw(), a_idCpu, strName.c_str(), &Value, &enmType);
1096	if (RT_SUCCESS(vrc))
1097	{
1098	try
1099	{
1100	Bstr bstrValue;
1101	hrc = formatRegisterValue(&bstrValue, &Value, enmType);
1102	if (SUCCEEDED(hrc))
1103	bstrValue.detachTo(a_pbstrValue);
1104	}
1105	catch (std::bad_alloc)
1106	{
1107	hrc = E_OUTOFMEMORY;
1108	}
1109	}
1110	else if (vrc == VERR_DBGF_REGISTER_NOT_FOUND)
1111	hrc = setError(E_FAIL, tr("Register '%s' was not found"), strName.c_str());
1112	else if (vrc == VERR_INVALID_CPU_ID)
1113	hrc = setError(E_FAIL, tr("Invalid CPU ID: %u"), a_idCpu);
1114	else
1115	hrc = setError(VBOX_E_VM_ERROR,
1116	tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
1117	vrc, strName.c_str(), a_idCpu);
1118	}
1119	}
1120
1121	return hrc;
1122	}
1123
1124	STDMETHODIMP MachineDebugger::GetRegisters(ULONG a_idCpu, ComSafeArrayOut(BSTR, a_bstrNames), ComSafeArrayOut(BSTR, a_bstrValues))
1125	{
1126	/*
1127	* The prologue.
1128	*/
1129	LogFlowThisFunc(("\n"));
1130	AutoCaller autoCaller(this);
1131	HRESULT hrc = autoCaller.rc();
1132	if (SUCCEEDED(hrc))
1133	{
1134	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1135	Console::SafeVMPtr ptrVM(mParent);
1136	hrc = ptrVM.rc();
1137	if (SUCCEEDED(hrc))
1138	{
1139	/*
1140	* Real work.
1141	*/
1142	size_t cRegs;
1143	int vrc = DBGFR3RegNmQueryAllCount(ptrVM.raw(), &cRegs);
1144	if (RT_SUCCESS(vrc))
1145	{
1146	PDBGFREGENTRYNM paRegs = (PDBGFREGENTRYNM)RTMemAllocZ(sizeof(paRegs[0]) * cRegs);
1147	if (paRegs)
1148	{
1149	vrc = DBGFR3RegNmQueryAll(ptrVM.raw(), paRegs, cRegs);
1150	if (RT_SUCCESS(vrc))
1151	{
1152	try
1153	{
1154	com::SafeArray<BSTR> abstrNames(cRegs);
1155	com::SafeArray<BSTR> abstrValues(cRegs);
1156
1157	for (uint32_t iReg = 0; iReg < cRegs; iReg++)
1158	{
1159	char szHex[128];
1160	Bstr bstrValue;
1161
1162	hrc = formatRegisterValue(&bstrValue, &paRegs[iReg].Val, paRegs[iReg].enmType);
1163	AssertComRC(hrc);
1164	bstrValue.detachTo(&abstrValues[iReg]);
1165
1166	Bstr bstrName(paRegs[iReg].pszName);
1167	bstrName.detachTo(&abstrNames[iReg]);
1168	}
1169
1170	abstrNames.detachTo(ComSafeArrayOutArg(a_bstrNames));
1171	abstrValues.detachTo(ComSafeArrayOutArg(a_bstrValues));
1172	}
1173	catch (std::bad_alloc)
1174	{
1175	hrc = E_OUTOFMEMORY;
1176	}
1177	}
1178	else
1179	hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
1180
1181	RTMemFree(paRegs);
1182	}
1183	else
1184	hrc = E_OUTOFMEMORY;
1185	}
1186	else
1187	hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
1188	}
1189	}
1190	return hrc;
1191	}
1192
1193	STDMETHODIMP MachineDebugger::SetRegister(ULONG a_idCpu, IN_BSTR a_bstrName, IN_BSTR a_bstrValue)
1194	{
1195	ReturnComNotImplemented();
1196	}
1197
1198	STDMETHODIMP MachineDebugger::SetRegisters(ULONG a_idCpu, ComSafeArrayIn(IN_BSTR, a_bstrNames), ComSafeArrayIn(IN_BSTR, a_bstrValues))
1199	{
1200	ReturnComNotImplemented();
1201	}
1202
1203	STDMETHODIMP MachineDebugger::DumpGuestStack(ULONG a_idCpu, BSTR *a_pbstrStack)
1204	{
1205	ReturnComNotImplemented();
1206	}
1207
1208	/**
1209	* Resets VM statistics.
1210	*
1211	* @returns COM status code.
1212	* @param aPattern The selection pattern. A bit similar to filename globbing.
1213	*/
1214	STDMETHODIMP MachineDebugger::ResetStats(IN_BSTR aPattern)
1215	{
1216	Console::SafeVMPtrQuiet pVM (mParent);
1217
1218	if (!pVM.isOk())
1219	return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1220
1221	STAMR3Reset(pVM, Utf8Str(aPattern).c_str());
1222
1223	return S_OK;
1224	}
1225
1226	/**
1227	* Dumps VM statistics to the log.
1228	*
1229	* @returns COM status code.
1230	* @param aPattern The selection pattern. A bit similar to filename globbing.
1231	*/
1232	STDMETHODIMP MachineDebugger::DumpStats (IN_BSTR aPattern)
1233	{
1234	Console::SafeVMPtrQuiet pVM (mParent);
1235
1236	if (!pVM.isOk())
1237	return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1238
1239	STAMR3Dump(pVM, Utf8Str(aPattern).c_str());
1240
1241	return S_OK;
1242	}
1243
1244	/**
1245	* Get the VM statistics in an XML format.
1246	*
1247	* @returns COM status code.
1248	* @param aPattern The selection pattern. A bit similar to filename globbing.
1249	* @param aWithDescriptions Whether to include the descriptions.
1250	* @param aStats The XML document containing the statistics.
1251	*/
1252	STDMETHODIMP MachineDebugger::GetStats (IN_BSTR aPattern, BOOL aWithDescriptions, BSTR *aStats)
1253	{
1254	Console::SafeVMPtrQuiet pVM (mParent);
1255
1256	if (!pVM.isOk())
1257	return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
1258
1259	char *pszSnapshot;
1260	int vrc = STAMR3Snapshot(pVM, Utf8Str(aPattern).c_str(), &pszSnapshot, NULL,
1261	!!aWithDescriptions);
1262	if (RT_FAILURE(vrc))
1263	return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;
1264
1265	/** @todo this is horribly inefficient! And it's kinda difficult to tell whether it failed...
1266	* Must use UTF-8 or ASCII here and completely avoid these two extra copy operations.
1267	* Until that's done, this method is kind of useless for debugger statistics GUI because
1268	* of the amount statistics in a debug build. */
1269	Bstr(pszSnapshot).detachTo(aStats);
1270
1271	return S_OK;
1272	}
1273
1274
1275	// public methods only for internal purposes
1276	/////////////////////////////////////////////////////////////////////////////
1277
1278	void MachineDebugger::flushQueuedSettings()
1279	{
1280	mFlushMode = true;
1281	if (mSinglestepQueued != ~0)
1282	{
1283	COMSETTER(Singlestep) (mSinglestepQueued);
1284	mSinglestepQueued = ~0;
1285	}
1286	if (mRecompileUserQueued != ~0)
1287	{
1288	COMSETTER(RecompileUser) (mRecompileUserQueued);
1289	mRecompileUserQueued = ~0;
1290	}
1291	if (mRecompileSupervisorQueued != ~0)
1292	{
1293	COMSETTER(RecompileSupervisor) (mRecompileSupervisorQueued);
1294	mRecompileSupervisorQueued = ~0;
1295	}
1296	if (mPatmEnabledQueued != ~0)
1297	{
1298	COMSETTER(PATMEnabled) (mPatmEnabledQueued);
1299	mPatmEnabledQueued = ~0;
1300	}
1301	if (mCsamEnabledQueued != ~0)
1302	{
1303	COMSETTER(CSAMEnabled) (mCsamEnabledQueued);
1304	mCsamEnabledQueued = ~0;
1305	}
1306	if (mLogEnabledQueued != ~0)
1307	{
1308	COMSETTER(LogEnabled) (mLogEnabledQueued);
1309	mLogEnabledQueued = ~0;
1310	}
1311	if (mVirtualTimeRateQueued != ~(uint32_t)0)
1312	{
1313	COMSETTER(VirtualTimeRate) (mVirtualTimeRateQueued);
1314	mVirtualTimeRateQueued = ~0;
1315	}
1316	mFlushMode = false;
1317	}
1318
1319	// private methods
1320	/////////////////////////////////////////////////////////////////////////////
1321
1322	bool MachineDebugger::queueSettings() const
1323	{
1324	if (!mFlushMode)
1325	{
1326	// check if the machine is running
1327	MachineState_T machineState;
1328	mParent->COMGETTER(State) (&machineState);
1329	switch (machineState)
1330	{
1331	// queue the request
1332	default:
1333	return true;
1334
1335	case MachineState_Running:
1336	case MachineState_Paused:
1337	case MachineState_Stuck:
1338	case MachineState_LiveSnapshotting:
1339	case MachineState_Teleporting:
1340	break;
1341	}
1342	}
1343	return false;
1344	}
1345	/* 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@ 39336

Download in other formats: