VirtualBox

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

Last change on this file since 8956 was 8822, checked in by vboxsync, 17 years ago

Don't queue stuff when paused or stuck. (Was all but running.)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.6 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 PRTLOGGER pLogInstance = RTLogDefaultInstance();
460 *aEnabled = pLogInstance && !(pLogInstance->fFlags & RTLOGFLAGS_DISABLED);
461 return S_OK;
462}
463
464/**
465 * Enables or disables logging.
466 *
467 * @returns COM status code
468 * @param aEnabled The new code log state.
469 */
470STDMETHODIMP MachineDebugger::COMSETTER(LogEnabled)(BOOL aEnabled)
471{
472 AutoWriteLock alock(this);
473
474 CHECK_READY();
475 LogFlowThisFunc (("aEnabled=%d\n", aEnabled));
476
477 if (!fFlushMode)
478 {
479 // check if the machine is running
480 MachineState_T machineState;
481 mParent->COMGETTER(State)(&machineState);
482 if ( machineState != MachineState_Running
483 && machineState != MachineState_Paused
484 && machineState != MachineState_Stuck)
485 {
486 // queue the request
487 mLogEnabledQueued = aEnabled;
488 return S_OK;
489 }
490 }
491
492 Console::SafeVMPtr pVM (mParent);
493 CheckComRCReturnRC (pVM.rc());
494
495 int vrc = DBGFR3LogModifyFlags(pVM, aEnabled ? "enabled" : "disabled");
496 if (VBOX_FAILURE(vrc))
497 {
498 /** @todo handle error code. */
499 }
500 return S_OK;
501}
502
503/**
504 * Returns the current hardware virtualization flag.
505 *
506 * @returns COM status code
507 * @param enabled address of result variable
508 */
509STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExEnabled)(BOOL *enabled)
510{
511 if (!enabled)
512 return E_POINTER;
513
514 AutoWriteLock alock (this);
515 CHECK_READY();
516
517 Console::SafeVMPtrQuiet pVM (mParent);
518 if (pVM.isOk())
519 *enabled = HWACCMIsEnabled(pVM.raw());
520 else
521 *enabled = false;
522 return S_OK;
523}
524
525/**
526 * Returns the current PAE flag.
527 *
528 * @returns COM status code
529 * @param enabled address of result variable
530 */
531STDMETHODIMP MachineDebugger::COMGETTER(PAEEnabled)(BOOL *enabled)
532{
533 if (!enabled)
534 return E_POINTER;
535
536 AutoWriteLock alock (this);
537 CHECK_READY();
538
539 Console::SafeVMPtrQuiet pVM (mParent);
540 if (pVM.isOk())
541 {
542 uint64_t cr4 = CPUMGetGuestCR4(pVM.raw());
543 *enabled = !!(cr4 & X86_CR4_PAE);
544 }
545 else
546 *enabled = false;
547 return S_OK;
548}
549
550/**
551 * Returns the current virtual time rate.
552 *
553 * @returns COM status code.
554 * @param pct Where to store the rate.
555 */
556STDMETHODIMP MachineDebugger::COMGETTER(VirtualTimeRate)(ULONG *pct)
557{
558 if (!pct)
559 return E_POINTER;
560
561 AutoWriteLock alock (this);
562 CHECK_READY();
563
564 Console::SafeVMPtrQuiet pVM (mParent);
565 if (pVM.isOk())
566 *pct = TMVirtualGetWarpDrive(pVM);
567 else
568 *pct = 100;
569 return S_OK;
570}
571
572/**
573 * Returns the current virtual time rate.
574 *
575 * @returns COM status code.
576 * @param pct Where to store the rate.
577 */
578STDMETHODIMP MachineDebugger::COMSETTER(VirtualTimeRate)(ULONG pct)
579{
580 if (pct < 2 || pct > 20000)
581 return E_INVALIDARG;
582
583 AutoWriteLock alock (this);
584 CHECK_READY();
585
586 if (!fFlushMode)
587 {
588 // check if the machine is running
589 MachineState_T machineState;
590 mParent->COMGETTER(State)(&machineState);
591 if ( machineState != MachineState_Running
592 && machineState != MachineState_Paused
593 && machineState != MachineState_Stuck)
594 {
595 // queue the request
596 mVirtualTimeRateQueued = pct;
597 return S_OK;
598 }
599 }
600
601 Console::SafeVMPtr pVM (mParent);
602 CheckComRCReturnRC (pVM.rc());
603
604 int vrc = TMVirtualSetWarpDrive(pVM, pct);
605 if (VBOX_FAILURE(vrc))
606 {
607 /** @todo handle error code. */
608 }
609 return S_OK;
610}
611
612/**
613 * Hack for getting the VM handle.
614 * This is only temporary (promise) while prototyping the debugger.
615 *
616 * @returns COM status code
617 * @param vm Where to store the vm handle.
618 * Since there is no uintptr_t in COM, we're using the max integer.
619 * (No, ULONG is not pointer sized!)
620 */
621STDMETHODIMP MachineDebugger::COMGETTER(VM)(ULONG64 *vm)
622{
623 if (!vm)
624 return E_POINTER;
625
626 AutoWriteLock alock (this);
627 CHECK_READY();
628
629 Console::SafeVMPtr pVM (mParent);
630 CheckComRCReturnRC (pVM.rc());
631
632 *vm = (uintptr_t)pVM.raw();
633
634 /*
635 * Note: pVM protection provided by SafeVMPtr is no more effective
636 * after we return from this method.
637 */
638
639 return S_OK;
640}
641
642//
643// "public-private" methods
644//
645void MachineDebugger::flushQueuedSettings()
646{
647 fFlushMode = true;
648 if (singlestepQueued != ~0)
649 {
650 COMSETTER(Singlestep)(singlestepQueued);
651 singlestepQueued = ~0;
652 }
653 if (recompileUserQueued != ~0)
654 {
655 COMSETTER(RecompileUser)(recompileUserQueued);
656 recompileUserQueued = ~0;
657 }
658 if (recompileSupervisorQueued != ~0)
659 {
660 COMSETTER(RecompileSupervisor)(recompileSupervisorQueued);
661 recompileSupervisorQueued = ~0;
662 }
663 if (patmEnabledQueued != ~0)
664 {
665 COMSETTER(PATMEnabled)(patmEnabledQueued);
666 patmEnabledQueued = ~0;
667 }
668 if (csamEnabledQueued != ~0)
669 {
670 COMSETTER(CSAMEnabled)(csamEnabledQueued);
671 csamEnabledQueued = ~0;
672 }
673 if (mLogEnabledQueued != ~0)
674 {
675 COMSETTER(LogEnabled)(mLogEnabledQueued);
676 mLogEnabledQueued = ~0;
677 }
678 if (mVirtualTimeRateQueued != ~(uint32_t)0)
679 {
680 COMSETTER(VirtualTimeRate)(mVirtualTimeRateQueued);
681 mVirtualTimeRateQueued = ~0;
682 }
683 fFlushMode = false;
684}
685
686//
687// private methods
688//
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