VirtualBox

source: vbox/trunk/src/VBox/Main/MachineDebuggerImpl.cpp@ 11822

Last change on this file since 11822 was 10695, checked in by vboxsync, 16 years ago

Added HWVirtExNestedPagingEnabled method to MachineDebugger.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.1 KB
Line 
1/** @file
2 *
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#include "MachineDebuggerImpl.h"
23#include "ConsoleImpl.h"
24#include "Logging.h"
25
26#include <VBox/em.h>
27#include <VBox/patm.h>
28#include <VBox/csam.h>
29#include <VBox/vm.h>
30#include <VBox/tm.h>
31#include <VBox/err.h>
32#include <VBox/hwaccm.h>
33
34//
35// defines
36//
37
38
39//
40// globals
41//
42
43
44//
45// constructor / destructor
46//
47
48HRESULT MachineDebugger::FinalConstruct()
49{
50 mParent = NULL;
51 return S_OK;
52}
53
54void MachineDebugger::FinalRelease()
55{
56 if (isReady())
57 uninit();
58}
59
60//
61// public methods
62//
63
64/**
65 * Initializes the machine debugger object.
66 *
67 * @returns COM result indicator
68 * @param parent handle of our parent object
69 */
70HRESULT MachineDebugger::init(Console *parent)
71{
72 LogFlow(("MachineDebugger::init(): isReady=%d\n", isReady()));
73
74 ComAssertRet (parent, E_INVALIDARG);
75
76 AutoWriteLock alock (this);
77 ComAssertRet (!isReady(), E_UNEXPECTED);
78
79 mParent = parent;
80 singlestepQueued = ~0;
81 recompileUserQueued = ~0;
82 recompileSupervisorQueued = ~0;
83 patmEnabledQueued = ~0;
84 csamEnabledQueued = ~0;
85 mLogEnabledQueued = ~0;
86 mVirtualTimeRateQueued = ~0;
87 fFlushMode = false;
88 setReady(true);
89 return S_OK;
90}
91
92/**
93 * Uninitializes the instance and sets the ready flag to FALSE.
94 * Called either from FinalRelease() or by the parent when it gets destroyed.
95 */
96void MachineDebugger::uninit()
97{
98 LogFlow(("MachineDebugger::uninit(): isReady=%d\n", isReady()));
99
100 AutoWriteLock alock (this);
101 AssertReturn (isReady(), (void) 0);
102
103 setReady (false);
104}
105
106/**
107 * Returns the current singlestepping flag.
108 *
109 * @returns COM status code
110 * @param enabled address of result variable
111 */
112STDMETHODIMP MachineDebugger::COMGETTER(Singlestep)(BOOL *enabled)
113{
114 if (!enabled)
115 return E_POINTER;
116 AutoWriteLock alock (this);
117 CHECK_READY();
118 /** @todo */
119 return E_NOTIMPL;
120}
121
122/**
123 * Sets the singlestepping flag.
124 *
125 * @returns COM status code
126 * @param enable new singlestepping flag
127 */
128STDMETHODIMP MachineDebugger::COMSETTER(Singlestep)(BOOL enable)
129{
130 AutoWriteLock alock (this);
131 CHECK_READY();
132 /** @todo */
133 return E_NOTIMPL;
134}
135
136/**
137 * Resets VM statistics.
138 *
139 * @returns COM status code.
140 * @param aPattern The selection pattern. A bit similar to filename globbing.
141 */
142STDMETHODIMP MachineDebugger::ResetStats(INPTR BSTR aPattern)
143{
144 Console::SafeVMPtrQuiet pVM (mParent);
145 if (pVM.isOk())
146 STAMR3Reset(pVM, Utf8Str(aPattern).raw());
147 return S_OK;
148}
149
150/**
151 * Dumps VM statistics to the log.
152 *
153 * @returns COM status code.
154 * @param aPattern The selection pattern. A bit similar to filename globbing.
155 */
156STDMETHODIMP MachineDebugger::DumpStats(INPTR BSTR aPattern)
157{
158 Console::SafeVMPtrQuiet pVM (mParent);
159 if (pVM.isOk())
160 STAMR3Dump(pVM, Utf8Str(aPattern).raw());
161 return S_OK;
162}
163
164/**
165 * Get the VM statistics in an XML format.
166 *
167 * @returns COM status code.
168 * @param aPattern The selection pattern. A bit similar to filename globbing.
169 * @param aWithDescriptions Whether to include the descriptions.
170 * @param aStats The XML document containing the statistics.
171 */
172STDMETHODIMP MachineDebugger::GetStats(INPTR BSTR aPattern, BOOL aWithDescriptions, BSTR *aStats)
173{
174 Console::SafeVMPtrQuiet pVM (mParent);
175 if (!pVM.isOk())
176 return E_FAIL;
177
178 char *pszSnapshot;
179 int vrc = STAMR3Snapshot(pVM, Utf8Str(aPattern).raw(), &pszSnapshot, NULL,
180 !!aWithDescriptions);
181 if (RT_FAILURE(vrc))
182 return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;
183
184 /** @todo this is horribly inefficient! And it's kinda difficult to tell whether it failed...
185 * Must use UTF-8 or ASCII here and completely avoid these two extra copy operations.
186 * Until that's done, this method is kind of useless for debugger statistics GUI because
187 * of the amount statistics in a debug build. */
188 Bstr(pszSnapshot).cloneTo(aStats);
189
190 return S_OK;
191}
192
193/**
194 * Returns the current recompile user mode code flag.
195 *
196 * @returns COM status code
197 * @param enabled address of result variable
198 */
199STDMETHODIMP MachineDebugger::COMGETTER(RecompileUser)(BOOL *enabled)
200{
201 if (!enabled)
202 return E_POINTER;
203 AutoWriteLock alock (this);
204 CHECK_READY();
205 Console::SafeVMPtrQuiet pVM (mParent);
206 if (pVM.isOk())
207 *enabled = !EMIsRawRing3Enabled(pVM.raw());
208 else
209 *enabled = false;
210 return S_OK;
211}
212
213/**
214 * Sets the recompile user mode code flag.
215 *
216 * @returns COM status
217 * @param enable new user mode code recompile flag.
218 */
219STDMETHODIMP MachineDebugger::COMSETTER(RecompileUser)(BOOL enable)
220{
221 LogFlowThisFunc (("enable=%d\n", enable));
222
223 AutoWriteLock alock (this);
224 CHECK_READY();
225
226 if (!fFlushMode)
227 {
228 // check if the machine is running
229 MachineState_T machineState;
230 mParent->COMGETTER(State)(&machineState);
231 if ( machineState != MachineState_Running
232 && machineState != MachineState_Paused
233 && machineState != MachineState_Stuck)
234 {
235 // queue the request
236 recompileUserQueued = enable;
237 return S_OK;
238 }
239 }
240
241 Console::SafeVMPtr pVM (mParent);
242 CheckComRCReturnRC (pVM.rc());
243
244 PVMREQ pReq;
245 EMRAWMODE rawModeFlag = enable ? EMRAW_RING3_DISABLE : EMRAW_RING3_ENABLE;
246 int rcVBox = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
247 (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag);
248 if (VBOX_SUCCESS(rcVBox))
249 {
250 rcVBox = pReq->iStatus;
251 VMR3ReqFree(pReq);
252 }
253
254 if (VBOX_SUCCESS(rcVBox))
255 return S_OK;
256
257 AssertMsgFailed(("Could not set raw mode flags to %d, rcVBox = %Vrc\n",
258 rawModeFlag, rcVBox));
259 return E_FAIL;
260}
261
262/**
263 * Returns the current recompile supervisor code flag.
264 *
265 * @returns COM status code
266 * @param enabled address of result variable
267 */
268STDMETHODIMP MachineDebugger::COMGETTER(RecompileSupervisor)(BOOL *enabled)
269{
270 if (!enabled)
271 return E_POINTER;
272 AutoWriteLock alock (this);
273 CHECK_READY();
274 Console::SafeVMPtrQuiet pVM (mParent);
275 if (pVM.isOk())
276 *enabled = !EMIsRawRing0Enabled(pVM.raw());
277 else
278 *enabled = false;
279 return S_OK;
280}
281
282/**
283 * Sets the new recompile supervisor code flag.
284 *
285 * @returns COM status code
286 * @param enable new recompile supervisor code flag
287 */
288STDMETHODIMP MachineDebugger::COMSETTER(RecompileSupervisor)(BOOL enable)
289{
290 LogFlowThisFunc (("enable=%d\n", enable));
291
292 AutoWriteLock alock (this);
293 CHECK_READY();
294
295 if (!fFlushMode)
296 {
297 // check if the machine is running
298 MachineState_T machineState;
299 mParent->COMGETTER(State)(&machineState);
300 if ( machineState != MachineState_Running
301 && machineState != MachineState_Paused
302 && machineState != MachineState_Stuck)
303 {
304 // queue the request
305 recompileSupervisorQueued = enable;
306 return S_OK;
307 }
308 }
309
310 Console::SafeVMPtr pVM (mParent);
311 CheckComRCReturnRC (pVM.rc());
312
313 PVMREQ pReq;
314 EMRAWMODE rawModeFlag = enable ? EMRAW_RING0_DISABLE : EMRAW_RING0_ENABLE;
315 int rcVBox = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
316 (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag);
317 if (VBOX_SUCCESS(rcVBox))
318 {
319 rcVBox = pReq->iStatus;
320 VMR3ReqFree(pReq);
321 }
322
323 if (VBOX_SUCCESS(rcVBox))
324 return S_OK;
325
326 AssertMsgFailed(("Could not set raw mode flags to %d, rcVBox = %Vrc\n",
327 rawModeFlag, rcVBox));
328 return E_FAIL;
329}
330
331/**
332 * Returns the current patch manager enabled flag.
333 *
334 * @returns COM status code
335 * @param enabled address of result variable
336 */
337STDMETHODIMP MachineDebugger::COMGETTER(PATMEnabled)(BOOL *enabled)
338{
339 if (!enabled)
340 return E_POINTER;
341 AutoWriteLock alock (this);
342 CHECK_READY();
343 Console::SafeVMPtrQuiet pVM (mParent);
344 if (pVM.isOk())
345 *enabled = PATMIsEnabled(pVM.raw());
346 else
347 *enabled = false;
348 return S_OK;
349}
350
351/**
352 * Set the new patch manager enabled flag.
353 *
354 * @returns COM status code
355 * @param new patch manager enabled flag
356 */
357STDMETHODIMP MachineDebugger::COMSETTER(PATMEnabled)(BOOL enable)
358{
359 AutoWriteLock alock (this);
360 CHECK_READY();
361 LogFlowThisFunc (("enable=%d\n", enable));
362
363 if (!fFlushMode)
364 {
365 // check if the machine is running
366 MachineState_T machineState;
367 mParent->COMGETTER(State)(&machineState);
368 if ( machineState != MachineState_Running
369 && machineState != MachineState_Paused
370 && machineState != MachineState_Stuck)
371 {
372 // queue the request
373 patmEnabledQueued = enable;
374 return S_OK;
375 }
376 }
377
378 Console::SafeVMPtr pVM (mParent);
379 CheckComRCReturnRC (pVM.rc());
380
381 PATMR3AllowPatching(pVM, enable);
382 return E_NOTIMPL;
383}
384
385/**
386 * Returns the current code scanner enabled flag.
387 *
388 * @returns COM status code
389 * @param enabled address of result variable
390 */
391STDMETHODIMP MachineDebugger::COMGETTER(CSAMEnabled)(BOOL *enabled)
392{
393 if (!enabled)
394 return E_POINTER;
395 AutoWriteLock alock (this);
396 CHECK_READY();
397 Console::SafeVMPtrQuiet pVM (mParent);
398 if (pVM.isOk())
399 *enabled = CSAMIsEnabled(pVM.raw());
400 else
401 *enabled = false;
402 return S_OK;
403}
404
405/**
406 * Sets the new code scanner enabled flag.
407 *
408 * @returns COM status code
409 * @param enable new code scanner enabled flag
410 */
411STDMETHODIMP MachineDebugger::COMSETTER(CSAMEnabled)(BOOL enable)
412{
413 AutoWriteLock alock (this);
414 CHECK_READY();
415 LogFlowThisFunc (("enable=%d\n", enable));
416
417 if (!fFlushMode)
418 {
419 // check if the machine is running
420 MachineState_T machineState;
421 mParent->COMGETTER(State)(&machineState);
422 if ( machineState != MachineState_Running
423 && machineState != MachineState_Paused
424 && machineState != MachineState_Stuck)
425 {
426 // queue the request
427 csamEnabledQueued = enable;
428 return S_OK;
429 }
430 }
431
432 Console::SafeVMPtr pVM (mParent);
433 CheckComRCReturnRC (pVM.rc());
434
435 int vrc;
436 if (enable)
437 vrc = CSAMEnableScanning(pVM);
438 else
439 vrc = CSAMDisableScanning(pVM);
440 if (VBOX_FAILURE(vrc))
441 {
442 /** @todo handle error case */
443 }
444 return S_OK;
445}
446
447/**
448 * Returns the log enabled / disabled status.
449 *
450 * @returns COM status code
451 * @param aEnabled address of result variable
452 */
453STDMETHODIMP MachineDebugger::COMGETTER(LogEnabled)(BOOL *aEnabled)
454{
455 if (!aEnabled)
456 return E_POINTER;
457 AutoWriteLock alock(this);
458 CHECK_READY();
459#ifdef LOG_ENABLED
460 PRTLOGGER pLogInstance = RTLogDefaultInstance();
461 *aEnabled = pLogInstance && !(pLogInstance->fFlags & RTLOGFLAGS_DISABLED);
462#else
463 *aEnabled = false;
464#endif
465 return S_OK;
466}
467
468/**
469 * Enables or disables logging.
470 *
471 * @returns COM status code
472 * @param aEnabled The new code log state.
473 */
474STDMETHODIMP MachineDebugger::COMSETTER(LogEnabled)(BOOL aEnabled)
475{
476 AutoWriteLock alock(this);
477
478 CHECK_READY();
479 LogFlowThisFunc (("aEnabled=%d\n", aEnabled));
480
481 if (!fFlushMode)
482 {
483 // check if the machine is running
484 MachineState_T machineState;
485 mParent->COMGETTER(State)(&machineState);
486 if ( machineState != MachineState_Running
487 && machineState != MachineState_Paused
488 && machineState != MachineState_Stuck)
489 {
490 // queue the request
491 mLogEnabledQueued = aEnabled;
492 return S_OK;
493 }
494 }
495
496 Console::SafeVMPtr pVM (mParent);
497 CheckComRCReturnRC (pVM.rc());
498
499#ifdef LOG_ENABLED
500 int vrc = DBGFR3LogModifyFlags(pVM, aEnabled ? "enabled" : "disabled");
501 if (VBOX_FAILURE(vrc))
502 {
503 /** @todo handle error code. */
504 }
505#endif
506 return S_OK;
507}
508
509/**
510 * Returns the current hardware virtualization flag.
511 *
512 * @returns COM status code
513 * @param enabled address of result variable
514 */
515STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExEnabled)(BOOL *enabled)
516{
517 if (!enabled)
518 return E_POINTER;
519
520 AutoWriteLock alock (this);
521 CHECK_READY();
522
523 Console::SafeVMPtrQuiet pVM (mParent);
524 if (pVM.isOk())
525 *enabled = HWACCMIsEnabled(pVM.raw());
526 else
527 *enabled = false;
528 return S_OK;
529}
530
531/**
532 * Returns the current nested paging flag.
533 *
534 * @returns COM status code
535 * @param enabled address of result variable
536 */
537STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExNestedPagingEnabled)(BOOL *enabled)
538{
539 if (!enabled)
540 return E_POINTER;
541
542 AutoWriteLock alock (this);
543 CHECK_READY();
544
545 Console::SafeVMPtrQuiet pVM (mParent);
546 if (pVM.isOk())
547 *enabled = HWACCMR3IsNestedPagingActive(pVM.raw());
548 else
549 *enabled = false;
550 return S_OK;
551}
552
553/**
554 * Returns the current PAE flag.
555 *
556 * @returns COM status code
557 * @param enabled address of result variable
558 */
559STDMETHODIMP MachineDebugger::COMGETTER(PAEEnabled)(BOOL *enabled)
560{
561 if (!enabled)
562 return E_POINTER;
563
564 AutoWriteLock alock (this);
565 CHECK_READY();
566
567 Console::SafeVMPtrQuiet pVM (mParent);
568 if (pVM.isOk())
569 {
570 uint64_t cr4 = CPUMGetGuestCR4(pVM.raw());
571 *enabled = !!(cr4 & X86_CR4_PAE);
572 }
573 else
574 *enabled = false;
575 return S_OK;
576}
577
578/**
579 * Returns the current virtual time rate.
580 *
581 * @returns COM status code.
582 * @param pct Where to store the rate.
583 */
584STDMETHODIMP MachineDebugger::COMGETTER(VirtualTimeRate)(ULONG *pct)
585{
586 if (!pct)
587 return E_POINTER;
588
589 AutoWriteLock alock (this);
590 CHECK_READY();
591
592 Console::SafeVMPtrQuiet pVM (mParent);
593 if (pVM.isOk())
594 *pct = TMVirtualGetWarpDrive(pVM);
595 else
596 *pct = 100;
597 return S_OK;
598}
599
600/**
601 * Returns the current virtual time rate.
602 *
603 * @returns COM status code.
604 * @param pct Where to store the rate.
605 */
606STDMETHODIMP MachineDebugger::COMSETTER(VirtualTimeRate)(ULONG pct)
607{
608 if (pct < 2 || pct > 20000)
609 return E_INVALIDARG;
610
611 AutoWriteLock alock (this);
612 CHECK_READY();
613
614 if (!fFlushMode)
615 {
616 // check if the machine is running
617 MachineState_T machineState;
618 mParent->COMGETTER(State)(&machineState);
619 if ( machineState != MachineState_Running
620 && machineState != MachineState_Paused
621 && machineState != MachineState_Stuck)
622 {
623 // queue the request
624 mVirtualTimeRateQueued = pct;
625 return S_OK;
626 }
627 }
628
629 Console::SafeVMPtr pVM (mParent);
630 CheckComRCReturnRC (pVM.rc());
631
632 int vrc = TMVirtualSetWarpDrive(pVM, pct);
633 if (VBOX_FAILURE(vrc))
634 {
635 /** @todo handle error code. */
636 }
637 return S_OK;
638}
639
640/**
641 * Hack for getting the VM handle.
642 * This is only temporary (promise) while prototyping the debugger.
643 *
644 * @returns COM status code
645 * @param vm Where to store the vm handle.
646 * Since there is no uintptr_t in COM, we're using the max integer.
647 * (No, ULONG is not pointer sized!)
648 */
649STDMETHODIMP MachineDebugger::COMGETTER(VM)(ULONG64 *vm)
650{
651 if (!vm)
652 return E_POINTER;
653
654 AutoWriteLock alock (this);
655 CHECK_READY();
656
657 Console::SafeVMPtr pVM (mParent);
658 CheckComRCReturnRC (pVM.rc());
659
660 *vm = (uintptr_t)pVM.raw();
661
662 /*
663 * Note: pVM protection provided by SafeVMPtr is no more effective
664 * after we return from this method.
665 */
666
667 return S_OK;
668}
669
670//
671// "public-private" methods
672//
673void MachineDebugger::flushQueuedSettings()
674{
675 fFlushMode = true;
676 if (singlestepQueued != ~0)
677 {
678 COMSETTER(Singlestep)(singlestepQueued);
679 singlestepQueued = ~0;
680 }
681 if (recompileUserQueued != ~0)
682 {
683 COMSETTER(RecompileUser)(recompileUserQueued);
684 recompileUserQueued = ~0;
685 }
686 if (recompileSupervisorQueued != ~0)
687 {
688 COMSETTER(RecompileSupervisor)(recompileSupervisorQueued);
689 recompileSupervisorQueued = ~0;
690 }
691 if (patmEnabledQueued != ~0)
692 {
693 COMSETTER(PATMEnabled)(patmEnabledQueued);
694 patmEnabledQueued = ~0;
695 }
696 if (csamEnabledQueued != ~0)
697 {
698 COMSETTER(CSAMEnabled)(csamEnabledQueued);
699 csamEnabledQueued = ~0;
700 }
701 if (mLogEnabledQueued != ~0)
702 {
703 COMSETTER(LogEnabled)(mLogEnabledQueued);
704 mLogEnabledQueued = ~0;
705 }
706 if (mVirtualTimeRateQueued != ~(uint32_t)0)
707 {
708 COMSETTER(VirtualTimeRate)(mVirtualTimeRateQueued);
709 mVirtualTimeRateQueued = ~0;
710 }
711 fFlushMode = false;
712}
713
714//
715// private methods
716//
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