VirtualBox

source: vbox/trunk/src/VBox/Main/ConsoleImpl.cpp@ 465

Last change on this file since 465 was 447, checked in by vboxsync, 18 years ago

Support 'VBoxInternal/Value' overlays.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 241.6 KB
Line 
1/** @file
2 *
3 * VBox Console COM Class implementation
4 */
5
6/*
7 * Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22#if defined(__WIN__)
23#elif defined(__LINUX__)
24# include <errno.h>
25# include <sys/ioctl.h>
26# include <sys/poll.h>
27# include <sys/fcntl.h>
28# include <net/if.h>
29# include <linux/if_tun.h>
30#endif
31
32#include "ConsoleImpl.h"
33#include "GuestImpl.h"
34#include "KeyboardImpl.h"
35#include "MouseImpl.h"
36#include "DisplayImpl.h"
37#include "MachineDebuggerImpl.h"
38#include "USBDeviceImpl.h"
39#include "RemoteUSBDeviceImpl.h"
40#include "SharedFolderImpl.h"
41#include "AudioSnifferInterface.h"
42#include "ConsoleVRDPServer.h"
43#include "VMMDev.h"
44
45// generated header
46#include "SchemaDefs.h"
47
48#include "Logging.h"
49
50#include <iprt/string.h>
51#include <iprt/asm.h>
52#include <iprt/file.h>
53#include <iprt/path.h>
54#include <iprt/dir.h>
55#include <iprt/process.h>
56#include <iprt/ldr.h>
57
58#include <VBox/vmapi.h>
59#include <VBox/err.h>
60#include <VBox/param.h>
61#include <VBox/vusb.h>
62#include <VBox/mm.h>
63#include <VBox/ssm.h>
64#include <VBox/version.h>
65
66#include <VBox/VBoxDev.h>
67
68#include <VBox/HostServices/VBoxClipboardSvc.h>
69
70#include <set>
71#include <algorithm>
72#include <memory> // for auto_ptr
73
74
75// VMTask and friends
76////////////////////////////////////////////////////////////////////////////////
77
78/**
79 * Task structure for asynchronous VM operations.
80 *
81 * Once created, the task structure adds itself as a Console caller.
82 * This means:
83 *
84 * 1. The user must check for #rc() before using the created structure
85 * (e.g. passing it as a thread function argument). If #rc() returns a
86 * failure, the Console object may not be used by the task (see
87 Console::addCaller() for more details).
88 * 2. On successful initialization, the structure keeps the Console caller
89 * until destruction (to ensure Console remains in the Ready state and won't
90 * be accidentially uninitialized). Forgetting to delete the created task
91 * will lead to Console::uninit() stuck waiting for releasing all added
92 * callers.
93 *
94 * If \a aUsesVMPtr parameter is true, the task structure will also add itself
95 * as a Console::mpVM caller with the same meaning as above. See
96 * Console::addVMCaller() for more info.
97 */
98struct VMTask
99{
100 VMTask (Console *aConsole, bool aUsesVMPtr)
101 : mConsole (aConsole), mCallerAdded (false), mVMCallerAdded (false)
102 {
103 AssertReturnVoid (aConsole);
104 mRC = aConsole->addCaller();
105 if (SUCCEEDED (mRC))
106 {
107 mCallerAdded = true;
108 if (aUsesVMPtr)
109 {
110 mRC = aConsole->addVMCaller();
111 if (SUCCEEDED (mRC))
112 mVMCallerAdded = true;
113 }
114 }
115 }
116
117 ~VMTask()
118 {
119 if (mVMCallerAdded)
120 mConsole->releaseVMCaller();
121 if (mCallerAdded)
122 mConsole->releaseCaller();
123 }
124
125 HRESULT rc() const { return mRC; }
126 bool isOk() const { return SUCCEEDED (rc()); }
127
128 /** Releases the Console caller before destruction. Not normally necessary. */
129 void releaseCaller()
130 {
131 AssertReturnVoid (mCallerAdded);
132 mConsole->releaseCaller();
133 mCallerAdded = false;
134 }
135
136 /** Releases the VM caller before destruction. Not normally necessary. */
137 void releaseVMCaller()
138 {
139 AssertReturnVoid (mVMCallerAdded);
140 mConsole->releaseVMCaller();
141 mVMCallerAdded = false;
142 }
143
144 const ComObjPtr <Console> mConsole;
145
146private:
147
148 HRESULT mRC;
149 bool mCallerAdded : 1;
150 bool mVMCallerAdded : 1;
151};
152
153struct VMProgressTask : public VMTask
154{
155 VMProgressTask (Console *aConsole, Progress *aProgress, bool aUsesVMPtr)
156 : VMTask (aConsole, aUsesVMPtr), mProgress (aProgress) {}
157
158 const ComObjPtr <Progress> mProgress;
159};
160
161struct VMPowerUpTask : public VMProgressTask
162{
163 VMPowerUpTask (Console *aConsole, Progress *aProgress)
164 : VMProgressTask (aConsole, aProgress, false /* aUsesVMPtr */)
165 , mSetVMErrorCallback (NULL), mConfigConstructor (NULL) {}
166
167 PFNVMATERROR mSetVMErrorCallback;
168 PFNCFGMCONSTRUCTOR mConfigConstructor;
169 Utf8Str mSavedStateFile;
170 std::map <Bstr, ComPtr <ISharedFolder> > mSharedFolders;
171};
172
173struct VMSaveTask : public VMProgressTask
174{
175 VMSaveTask (Console *aConsole, Progress *aProgress)
176 : VMProgressTask (aConsole, aProgress, true /* aUsesVMPtr */)
177 , mIsSnapshot (false)
178 , mLastMachineState (MachineState_InvalidMachineState) {}
179
180 bool mIsSnapshot;
181 Utf8Str mSavedStateFile;
182 MachineState_T mLastMachineState;
183 ComPtr <IProgress> mServerProgress;
184};
185
186
187// constructor / desctructor
188/////////////////////////////////////////////////////////////////////////////
189
190Console::Console()
191 : mSavedStateDataLoaded (false)
192 , mConsoleVRDPServer (NULL)
193 , mpVM (NULL)
194 , mVMCallers (0)
195 , mVMZeroCallersSem (NIL_RTSEMEVENT)
196 , mVMDestroying (false)
197 , meDVDState (DriveState_NotMounted)
198 , meFloppyState (DriveState_NotMounted)
199 , mVMMDev (NULL)
200 , mAudioSniffer (NULL)
201 , mVMStateChangeCallbackDisabled (false)
202 , mMachineState (MachineState_PoweredOff)
203{}
204
205Console::~Console()
206{}
207
208HRESULT Console::FinalConstruct()
209{
210 LogFlowThisFunc (("\n"));
211
212 memset(mapFDLeds, 0, sizeof(mapFDLeds));
213 memset(mapIDELeds, 0, sizeof(mapIDELeds));
214 memset(mapNetworkLeds, 0, sizeof(mapNetworkLeds));
215
216#ifdef __LINUX__
217 Assert(ELEMENTS(maTapFD) == ELEMENTS(maTAPDeviceName));
218 Assert(ELEMENTS(maTapFD) >= SchemaDefs::NetworkAdapterCount);
219 for (unsigned i = 0; i < ELEMENTS(maTapFD); i++)
220 {
221 maTapFD[i] = NIL_RTFILE;
222 maTAPDeviceName[i] = "";
223 }
224#endif
225
226 return S_OK;
227}
228
229void Console::FinalRelease()
230{
231 LogFlowThisFunc (("\n"));
232
233 uninit();
234}
235
236// public initializer/uninitializer for internal purposes only
237/////////////////////////////////////////////////////////////////////////////
238
239HRESULT Console::init (IMachine *aMachine, IInternalMachineControl *aControl)
240{
241 AssertReturn (aMachine && aControl, E_INVALIDARG);
242
243 /* Enclose the state transition NotReady->InInit->Ready */
244 AutoInitSpan autoInitSpan (this);
245 AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
246
247 LogFlowThisFuncEnter();
248 LogFlowThisFunc(("aMachine=%p, aControl=%p\n", aMachine, aControl));
249
250 HRESULT rc = E_FAIL;
251
252 unconst (mMachine) = aMachine;
253 unconst (mControl) = aControl;
254
255 /* Cache essential properties and objects */
256
257 rc = mMachine->COMGETTER(State) (&mMachineState);
258 AssertComRCReturn (rc, rc);
259
260#ifdef VBOX_VRDP
261 rc = mMachine->COMGETTER(VRDPServer) (unconst (mVRDPServer).asOutParam());
262 AssertComRCReturn (rc, rc);
263#endif
264
265 rc = mMachine->COMGETTER(DVDDrive) (unconst (mDVDDrive).asOutParam());
266 AssertComRCReturn (rc, rc);
267
268 rc = mMachine->COMGETTER(FloppyDrive) (unconst (mFloppyDrive).asOutParam());
269 AssertComRCReturn (rc, rc);
270
271 /* Create associated child COM objects */
272
273 unconst (mGuest).createObject();
274 rc = mGuest->init (this);
275 AssertComRCReturn (rc, rc);
276
277 unconst (mKeyboard).createObject();
278 rc = mKeyboard->init (this);
279 AssertComRCReturn (rc, rc);
280
281 unconst (mMouse).createObject();
282 rc = mMouse->init (this);
283 AssertComRCReturn (rc, rc);
284
285 unconst (mDisplay).createObject();
286 rc = mDisplay->init (this);
287 AssertComRCReturn (rc, rc);
288
289 unconst (mRemoteDisplayInfo).createObject();
290 rc = mRemoteDisplayInfo->init (this);
291 AssertComRCReturn (rc, rc);
292
293 /* Create other child objects */
294
295 unconst (mConsoleVRDPServer) = new ConsoleVRDPServer (this);
296 AssertReturn (mConsoleVRDPServer, E_FAIL);
297
298#ifdef VRDP_MC
299 m_cAudioRefs = 0;
300#endif /* VRDP_MC */
301
302 unconst (mVMMDev) = new VMMDev(this);
303 AssertReturn (mVMMDev, E_FAIL);
304
305 unconst (mAudioSniffer) = new AudioSniffer(this);
306 AssertReturn (mAudioSniffer, E_FAIL);
307
308 /* Confirm a successful initialization when it's the case */
309 autoInitSpan.setSucceeded();
310
311 LogFlowThisFuncLeave();
312
313 return S_OK;
314}
315
316/**
317 * Uninitializes the Console object.
318 */
319void Console::uninit()
320{
321 LogFlowThisFuncEnter();
322
323 /* Enclose the state transition Ready->InUninit->NotReady */
324 AutoUninitSpan autoUninitSpan (this);
325 if (autoUninitSpan.uninitDone())
326 {
327 LogFlowThisFunc (("Already uninitialized.\n"));
328 LogFlowThisFuncLeave();
329 return;
330 }
331
332 LogFlowThisFunc (("initFailed()=%d\n", autoUninitSpan.initFailed()));
333
334 /*
335 * Uninit all children that ise addDependentChild()/removeDependentChild()
336 * in their init()/uninit() methods.
337 */
338 uninitDependentChildren();
339
340 /* This should be the first, since this may cause detaching remote USB devices. */
341 if (mConsoleVRDPServer)
342 {
343 delete mConsoleVRDPServer;
344 unconst (mConsoleVRDPServer) = NULL;
345 }
346
347 /* power down the VM if necessary */
348 if (mpVM)
349 {
350 powerDown();
351 Assert (mpVM == NULL);
352 }
353
354 if (mVMZeroCallersSem != NIL_RTSEMEVENT)
355 {
356 RTSemEventDestroy (mVMZeroCallersSem);
357 mVMZeroCallersSem = NIL_RTSEMEVENT;
358 }
359
360 if (mAudioSniffer)
361 {
362 delete mAudioSniffer;
363 unconst (mAudioSniffer) = NULL;
364 }
365
366 if (mVMMDev)
367 {
368 delete mVMMDev;
369 unconst (mVMMDev) = NULL;
370 }
371
372 mSharedFolders.clear();
373 mRemoteUSBDevices.clear();
374 mUSBDevices.clear();
375
376 if (mRemoteDisplayInfo)
377 {
378 mRemoteDisplayInfo->uninit();
379 unconst (mRemoteDisplayInfo).setNull();;
380 }
381
382 if (mDebugger)
383 {
384 mDebugger->uninit();
385 unconst (mDebugger).setNull();
386 }
387
388 if (mDisplay)
389 {
390 mDisplay->uninit();
391 unconst (mDisplay).setNull();
392 }
393
394 if (mMouse)
395 {
396 mMouse->uninit();
397 unconst (mMouse).setNull();
398 }
399
400 if (mKeyboard)
401 {
402 mKeyboard->uninit();
403 unconst (mKeyboard).setNull();;
404 }
405
406 if (mGuest)
407 {
408 mGuest->uninit();
409 unconst (mGuest).setNull();;
410 }
411
412 unconst (mFloppyDrive).setNull();
413 unconst (mDVDDrive).setNull();
414#ifdef VBOX_VRDP
415 unconst (mVRDPServer).setNull();
416#endif
417
418 unconst (mControl).setNull();
419 unconst (mMachine).setNull();
420
421 // Release all callbacks. Do this after uninitializing the components,
422 // as some of them are well-behaved and unregister their callbacks.
423 // These would trigger error messages complaining about trying to
424 // unregister a non-registered callback.
425 mCallbacks.clear();
426
427 LogFlowThisFuncLeave();
428}
429
430#ifdef VRDP_MC
431DECLCALLBACK(int) Console::vrdp_ClientLogon (void *pvUser,
432 uint32_t u32ClientId,
433 const char *pszUser,
434 const char *pszPassword,
435 const char *pszDomain)
436#else
437DECLCALLBACK(int) Console::vrdp_ClientLogon (void *pvUser, const char *pszUser,
438 const char *pszPassword,
439 const char *pszDomain)
440#endif /* VRDP_MC */
441{
442 LogFlowFuncEnter();
443#ifdef VRDP_MC
444 LogFlowFunc (("%d, %s, %s, %s\n", u32ClientId, pszUser, pszPassword, pszDomain));
445#else
446 LogFlowFunc (("%s, %s, %s\n", pszUser, pszPassword, pszDomain));
447#endif /* VRDP_MC */
448
449 Console *console = static_cast <Console *> (pvUser);
450 AssertReturn (console, VERR_INVALID_POINTER);
451
452 AutoCaller autoCaller (console);
453 if (!autoCaller.isOk())
454 {
455 /* Console has been already uninitialized, deny request */
456 LogRel(("VRDPAUTH: Access denied (Console uninitialized).\n"));
457 LogFlowFuncLeave();
458 return VERR_ACCESS_DENIED;
459 }
460
461 Guid uuid;
462 HRESULT hrc = console->mMachine->COMGETTER (Id) (uuid.asOutParam());
463 AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
464
465 VRDPAuthType_T authType = VRDPAuthType_VRDPAuthNull;
466 hrc = console->mVRDPServer->COMGETTER(AuthType) (&authType);
467 AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
468
469 ULONG authTimeout = 0;
470 hrc = console->mVRDPServer->COMGETTER(AuthTimeout) (&authTimeout);
471 AssertComRCReturn (hrc, VERR_ACCESS_DENIED);
472
473 VRDPAuthResult result = VRDPAuthAccessDenied;
474 VRDPAuthGuestJudgement guestJudgement = VRDPAuthGuestNotAsked;
475
476 LogFlowFunc(("Auth type %d\n", authType));
477
478 LogRel (("VRDPAUTH: User: [%s]. Domain: [%s]. Authentication type: [%s]\n",
479 pszUser, pszDomain,
480 authType == VRDPAuthType_VRDPAuthNull?
481 "null":
482 (authType == VRDPAuthType_VRDPAuthExternal?
483 "external":
484 (authType == VRDPAuthType_VRDPAuthGuest?
485 "guest":
486 "INVALID"
487 )
488 )
489 ));
490
491 switch (authType)
492 {
493 case VRDPAuthType_VRDPAuthNull:
494 {
495 result = VRDPAuthAccessGranted;
496 break;
497 }
498
499 case VRDPAuthType_VRDPAuthExternal:
500 {
501 /* Call the external library. */
502 result = console->mConsoleVRDPServer->Authenticate (uuid, guestJudgement, pszUser, pszPassword, pszDomain);
503
504 if (result != VRDPAuthDelegateToGuest)
505 {
506 break;
507 }
508
509 LogRel(("VRDPAUTH: Delegated to guest.\n"));
510
511 LogFlowFunc (("External auth asked for guest judgement\n"));
512 } /* pass through */
513
514 case VRDPAuthType_VRDPAuthGuest:
515 {
516 guestJudgement = VRDPAuthGuestNotReacted;
517
518 if (console->mVMMDev)
519 {
520 /* Issue the request to guest. Assume that the call does not require EMT. It should not. */
521
522 /* Ask the guest to judge these credentials. */
523 uint32_t u32GuestFlags = VMMDEV_SETCREDENTIALS_JUDGE;
524
525 int rc = console->mVMMDev->getVMMDevPort()->pfnSetCredentials (console->mVMMDev->getVMMDevPort(),
526 pszUser, pszPassword, pszDomain, u32GuestFlags);
527
528 if (VBOX_SUCCESS (rc))
529 {
530 /* Wait for guest. */
531 rc = console->mVMMDev->WaitCredentialsJudgement (authTimeout, &u32GuestFlags);
532
533 if (VBOX_SUCCESS (rc))
534 {
535 switch (u32GuestFlags & (VMMDEV_CREDENTIALS_JUDGE_OK | VMMDEV_CREDENTIALS_JUDGE_DENY | VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT))
536 {
537 case VMMDEV_CREDENTIALS_JUDGE_DENY: guestJudgement = VRDPAuthGuestAccessDenied; break;
538 case VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT: guestJudgement = VRDPAuthGuestNoJudgement; break;
539 case VMMDEV_CREDENTIALS_JUDGE_OK: guestJudgement = VRDPAuthGuestAccessGranted; break;
540 default:
541 LogFlowFunc (("Invalid guest flags %08X!!!\n", u32GuestFlags)); break;
542 }
543 }
544 else
545 {
546 LogFlowFunc (("Wait for credentials judgement rc = %Vrc!!!\n", rc));
547 }
548
549 LogFlowFunc (("Guest judgement %d\n", guestJudgement));
550 }
551 else
552 {
553 LogFlowFunc (("Could not set credentials rc = %Vrc!!!\n", rc));
554 }
555 }
556
557 if (authType == VRDPAuthType_VRDPAuthExternal)
558 {
559 LogRel(("VRDPAUTH: Guest judgement %d.\n", guestJudgement));
560 LogFlowFunc (("External auth called again with guest judgement = %d\n", guestJudgement));
561 result = console->mConsoleVRDPServer->Authenticate (uuid, guestJudgement, pszUser, pszPassword, pszDomain);
562 }
563 else
564 {
565 switch (guestJudgement)
566 {
567 case VRDPAuthGuestAccessGranted:
568 result = VRDPAuthAccessGranted;
569 break;
570 default:
571 result = VRDPAuthAccessDenied;
572 break;
573 }
574 }
575 } break;
576
577 default:
578 AssertFailed();
579 }
580
581 LogFlowFunc (("Result = %d\n", result));
582 LogFlowFuncLeave();
583
584 if (result == VRDPAuthAccessGranted)
585 {
586 LogRel(("VRDPAUTH: Access granted.\n"));
587 return VINF_SUCCESS;
588 }
589
590 /* Reject. */
591 LogRel(("VRDPAUTH: Access denied.\n"));
592 return VERR_ACCESS_DENIED;
593}
594
595#ifdef VRDP_MC
596DECLCALLBACK(void) Console::vrdp_ClientConnect (void *pvUser,
597 uint32_t u32ClientId)
598#else
599DECLCALLBACK(void) Console::vrdp_ClientConnect (void *pvUser,
600 uint32_t fu32SupportedOrders)
601#endif /* VRDP_MC */
602{
603 LogFlowFuncEnter();
604
605 Console *console = static_cast <Console *> (pvUser);
606 AssertReturnVoid (console);
607
608 AutoCaller autoCaller (console);
609 AssertComRCReturnVoid (autoCaller.rc());
610
611#ifdef VBOX_VRDP
612#ifdef VRDP_MC
613 NOREF(u32ClientId);
614 console->mDisplay->VideoAccelVRDP (true);
615#else
616 console->mDisplay->VideoAccelVRDP (true, fu32SupportedOrders);
617#endif /* VRDP_MC */
618#endif /* VBOX_VRDP */
619
620 LogFlowFuncLeave();
621 return;
622}
623
624#ifdef VRDP_MC
625DECLCALLBACK(void) Console::vrdp_ClientDisconnect (void *pvUser,
626 uint32_t u32ClientId,
627 uint32_t fu32Intercepted)
628#else
629DECLCALLBACK(void) Console::vrdp_ClientDisconnect (void *pvUser)
630#endif /* VRDP_MC */
631{
632 LogFlowFuncEnter();
633
634 Console *console = static_cast <Console *> (pvUser);
635 AssertReturnVoid (console);
636
637 AutoCaller autoCaller (console);
638 AssertComRCReturnVoid (autoCaller.rc());
639
640 AssertReturnVoid (console->mConsoleVRDPServer);
641
642#ifdef VBOX_VRDP
643#ifdef VRDP_MC
644 console->mDisplay->VideoAccelVRDP (false);
645#else
646 console->mDisplay->VideoAccelVRDP (false, 0);
647#endif /* VRDP_MC */
648#endif /* VBOX_VRDP */
649
650#ifdef VRDP_MC
651 if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_USB)
652 {
653 console->mConsoleVRDPServer->USBBackendDelete (u32ClientId);
654 }
655#else
656 console->mConsoleVRDPServer->DeleteUSBBackend ();
657#endif /* VRDP_MC */
658
659#ifdef VBOX_VRDP
660#ifdef VRDP_MC
661 if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_AUDIO)
662 {
663 console->m_cAudioRefs--;
664
665 if (console->m_cAudioRefs <= 0)
666 {
667 if (console->mAudioSniffer)
668 {
669 PPDMIAUDIOSNIFFERPORT port = console->mAudioSniffer->getAudioSnifferPort();
670 if (port)
671 {
672 port->pfnSetup (port, false, false);
673 }
674 }
675 }
676 }
677#else
678 if (console->mAudioSniffer)
679 {
680 PPDMIAUDIOSNIFFERPORT port = console->mAudioSniffer->getAudioSnifferPort();
681 if (port)
682 {
683 port->pfnSetup (port, false, false);
684 }
685 }
686#endif /* VRDP_MC */
687#endif /* VBOX_VRDP */
688
689 LogFlowFuncLeave();
690 return;
691}
692
693#ifdef VRDP_MC
694DECLCALLBACK(void) Console::vrdp_InterceptAudio (void *pvUser,
695 uint32_t u32ClientId)
696#else
697DECLCALLBACK(void) Console::vrdp_InterceptAudio (void *pvUser, bool fKeepHostAudio)
698#endif /* VRDP_MC */
699{
700 LogFlowFuncEnter();
701
702 Console *console = static_cast <Console *> (pvUser);
703 AssertReturnVoid (console);
704
705 AutoCaller autoCaller (console);
706 AssertComRCReturnVoid (autoCaller.rc());
707
708#ifdef VRDP_MC
709 LogFlowFunc (("mAudioSniffer %p, u32ClientId %d.\n",
710 console->mAudioSniffer, u32ClientId));
711 NOREF(u32ClientId);
712#else
713 LogFlowFunc (("mAudioSniffer %p, keepHostAudio %d.\n",
714 console->mAudioSniffer, fKeepHostAudio));
715#endif /* VRDP_MC */
716
717#ifdef VBOX_VRDP
718#ifdef VRDP_MC
719 console->m_cAudioRefs++;
720
721 if (console->m_cAudioRefs == 1)
722 {
723 if (console->mAudioSniffer)
724 {
725 PPDMIAUDIOSNIFFERPORT port = console->mAudioSniffer->getAudioSnifferPort();
726 if (port)
727 {
728 port->pfnSetup (port, true, true);
729 }
730 }
731 }
732#else
733 if (console->mAudioSniffer)
734 {
735 PPDMIAUDIOSNIFFERPORT port = console->mAudioSniffer->getAudioSnifferPort();
736 if (port)
737 {
738 port->pfnSetup (port, true, !!fKeepHostAudio);
739 }
740 }
741#endif /* VRDP_MC */
742#endif
743
744 LogFlowFuncLeave();
745 return;
746}
747
748#ifdef VRDP_MC
749DECLCALLBACK(void) Console::vrdp_InterceptUSB (void *pvUser,
750 uint32_t u32ClientId,
751 PFNVRDPUSBCALLBACK *ppfn,
752 void **ppv)
753#else
754DECLCALLBACK(void) Console::vrdp_InterceptUSB (void *pvUser, PFNVRDPUSBCALLBACK *ppfn, void **ppv)
755#endif /* VRDP_MC */
756{
757 LogFlowFuncEnter();
758
759 Console *console = static_cast <Console *> (pvUser);
760 AssertReturnVoid (console);
761
762 AutoCaller autoCaller (console);
763 AssertComRCReturnVoid (autoCaller.rc());
764
765 AssertReturnVoid (console->mConsoleVRDPServer);
766
767#ifdef VRDP_MC
768 console->mConsoleVRDPServer->USBBackendCreate (u32ClientId, ppfn, ppv);
769#else
770 console->mConsoleVRDPServer->CreateUSBBackend (ppfn, ppv);
771#endif /* VRDP_MC */
772
773 LogFlowFuncLeave();
774 return;
775}
776
777// static
778VRDPSERVERCALLBACK Console::sVrdpServerCallback =
779{
780 vrdp_ClientLogon,
781 vrdp_ClientConnect,
782 vrdp_ClientDisconnect,
783 vrdp_InterceptAudio,
784 vrdp_InterceptUSB
785};
786
787//static
788char *Console::sSSMConsoleUnit = "ConsoleData";
789//static
790uint32_t Console::sSSMConsoleVer = 0x00010000;
791
792/**
793 * Loads various console data stored in the saved state file.
794 * This method does validation of the state file and returns an error info
795 * when appropriate.
796 *
797 * The method does nothing if the machine is not in the Saved file or if
798 * console data from it has already been loaded.
799 *
800 * @note The caller must lock this object for writing.
801 */
802HRESULT Console::loadDataFromSavedState()
803{
804 if (mMachineState != MachineState_Saved || mSavedStateDataLoaded)
805 return S_OK;
806
807 Bstr savedStateFile;
808 HRESULT rc = mMachine->COMGETTER(StateFilePath) (savedStateFile.asOutParam());
809 if (FAILED (rc))
810 return rc;
811
812 PSSMHANDLE ssm;
813 int vrc = SSMR3Open (Utf8Str(savedStateFile), 0, &ssm);
814 if (VBOX_SUCCESS (vrc))
815 {
816 uint32_t version = 0;
817 vrc = SSMR3Seek (ssm, sSSMConsoleUnit, 0 /* iInstance */, &version);
818 if (version == sSSMConsoleVer)
819 {
820 if (VBOX_SUCCESS (vrc))
821 vrc = loadStateFileExec (ssm, this, 0);
822 else if (vrc == VERR_SSM_UNIT_NOT_FOUND)
823 vrc = VINF_SUCCESS;
824 }
825 else
826 vrc = VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
827
828 SSMR3Close (ssm);
829 }
830
831 if (VBOX_FAILURE (vrc))
832 rc = setError (E_FAIL,
833 tr ("The saved state file '%ls' is invalid (%Vrc). "
834 "Discard the saved state and try again"),
835 savedStateFile.raw(), vrc);
836
837 mSavedStateDataLoaded = true;
838
839 return rc;
840}
841
842/**
843 * Callback handler to save various console data to the state file,
844 * called when the user saves the VM state.
845 *
846 * @param pvUser pointer to Console
847 *
848 * @note Locks the Console object for reading.
849 */
850//static
851DECLCALLBACK(void)
852Console::saveStateFileExec (PSSMHANDLE pSSM, void *pvUser)
853{
854 LogFlowFunc (("\n"));
855
856 Console *that = static_cast <Console *> (pvUser);
857 AssertReturnVoid (that);
858
859 AutoCaller autoCaller (that);
860 AssertComRCReturnVoid (autoCaller.rc());
861
862 AutoReaderLock alock (that);
863
864 int vrc = SSMR3PutU32 (pSSM, that->mSharedFolders.size());
865 AssertRC (vrc);
866
867 for (SharedFolderList::const_iterator it = that->mSharedFolders.begin();
868 it != that->mSharedFolders.end();
869 ++ it)
870 {
871 ComObjPtr <SharedFolder> folder = (*it);
872 AutoLock folderLock (folder);
873
874 Utf8Str name = folder->name();
875 vrc = SSMR3PutU32 (pSSM, name.length() + 1 /* term. 0 */);
876 AssertRC (vrc);
877 vrc = SSMR3PutStrZ (pSSM, name);
878 AssertRC (vrc);
879
880 Utf8Str hostPath = folder->hostPath();
881 vrc = SSMR3PutU32 (pSSM, hostPath.length() + 1 /* term. 0 */);
882 AssertRC (vrc);
883 vrc = SSMR3PutStrZ (pSSM, hostPath);
884 AssertRC (vrc);
885 }
886
887 return;
888}
889
890/**
891 * Callback handler to load various console data from the state file.
892 * When \a u32Version is 0, this method is called from #loadDataFromSavedState,
893 * otherwise it is called when the VM is being restored from the saved state.
894 *
895 * @param pvUser pointer to Console
896 * @param u32Version Console unit version.
897 * When not 0, should match sSSMConsoleVer.
898 *
899 * @note Locks the Console object for writing.
900 */
901//static
902DECLCALLBACK(int)
903Console::loadStateFileExec (PSSMHANDLE pSSM, void *pvUser, uint32_t u32Version)
904{
905 LogFlowFunc (("\n"));
906
907 if (u32Version != 0 && u32Version != sSSMConsoleVer)
908 return VERR_VERSION_MISMATCH;
909
910 if (u32Version != 0)
911 {
912 /* currently, nothing to do when we've been called from VMR3Load */
913 return VINF_SUCCESS;
914 }
915
916 Console *that = static_cast <Console *> (pvUser);
917 AssertReturn (that, VERR_INVALID_PARAMETER);
918
919 AutoCaller autoCaller (that);
920 AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
921
922 AutoLock alock (that);
923
924 AssertReturn (that->mSharedFolders.size() == 0, VERR_INTERNAL_ERROR);
925
926 uint32_t size = 0;
927 int vrc = SSMR3GetU32 (pSSM, &size);
928 AssertRCReturn (vrc, vrc);
929
930 for (uint32_t i = 0; i < size; ++ i)
931 {
932 Bstr name;
933 Bstr hostPath;
934
935 uint32_t szBuf = 0;
936 char *buf = NULL;
937
938 vrc = SSMR3GetU32 (pSSM, &szBuf);
939 AssertRCReturn (vrc, vrc);
940 buf = new char [szBuf];
941 vrc = SSMR3GetStrZ (pSSM, buf, szBuf);
942 AssertRC (vrc);
943 name = buf;
944 delete[] buf;
945
946 vrc = SSMR3GetU32 (pSSM, &szBuf);
947 AssertRCReturn (vrc, vrc);
948 buf = new char [szBuf];
949 vrc = SSMR3GetStrZ (pSSM, buf, szBuf);
950 AssertRC (vrc);
951 hostPath = buf;
952 delete[] buf;
953
954 ComObjPtr <SharedFolder> sharedFolder;
955 sharedFolder.createObject();
956 HRESULT rc = sharedFolder->init (that, name, hostPath);
957 AssertComRCReturn (rc, VERR_INTERNAL_ERROR);
958 if (FAILED (rc))
959 return rc;
960
961 that->mSharedFolders.push_back (sharedFolder);
962 }
963
964 return VINF_SUCCESS;
965}
966
967// IConsole properties
968/////////////////////////////////////////////////////////////////////////////
969
970STDMETHODIMP Console::COMGETTER(Machine) (IMachine **aMachine)
971{
972 if (!aMachine)
973 return E_POINTER;
974
975 AutoCaller autoCaller (this);
976 CheckComRCReturnRC (autoCaller.rc());
977
978 /* mMachine is constant during life time, no need to lock */
979 mMachine.queryInterfaceTo (aMachine);
980
981 return S_OK;
982}
983
984STDMETHODIMP Console::COMGETTER(State) (MachineState_T *aMachineState)
985{
986 if (!aMachineState)
987 return E_POINTER;
988
989 AutoCaller autoCaller (this);
990 CheckComRCReturnRC (autoCaller.rc());
991
992 AutoReaderLock alock (this);
993
994 /* we return our local state (since it's always the same as on the server) */
995 *aMachineState = mMachineState;
996
997 return S_OK;
998}
999
1000STDMETHODIMP Console::COMGETTER(Guest) (IGuest **aGuest)
1001{
1002 if (!aGuest)
1003 return E_POINTER;
1004
1005 AutoCaller autoCaller (this);
1006 CheckComRCReturnRC (autoCaller.rc());
1007
1008 /* mGuest is constant during life time, no need to lock */
1009 mGuest.queryInterfaceTo (aGuest);
1010
1011 return S_OK;
1012}
1013
1014STDMETHODIMP Console::COMGETTER(Keyboard) (IKeyboard **aKeyboard)
1015{
1016 if (!aKeyboard)
1017 return E_POINTER;
1018
1019 AutoCaller autoCaller (this);
1020 CheckComRCReturnRC (autoCaller.rc());
1021
1022 /* mKeyboard is constant during life time, no need to lock */
1023 mKeyboard.queryInterfaceTo (aKeyboard);
1024
1025 return S_OK;
1026}
1027
1028STDMETHODIMP Console::COMGETTER(Mouse) (IMouse **aMouse)
1029{
1030 if (!aMouse)
1031 return E_POINTER;
1032
1033 AutoCaller autoCaller (this);
1034 CheckComRCReturnRC (autoCaller.rc());
1035
1036 /* mMouse is constant during life time, no need to lock */
1037 mMouse.queryInterfaceTo (aMouse);
1038
1039 return S_OK;
1040}
1041
1042STDMETHODIMP Console::COMGETTER(Display) (IDisplay **aDisplay)
1043{
1044 if (!aDisplay)
1045 return E_POINTER;
1046
1047 AutoCaller autoCaller (this);
1048 CheckComRCReturnRC (autoCaller.rc());
1049
1050 /* mDisplay is constant during life time, no need to lock */
1051 mDisplay.queryInterfaceTo (aDisplay);
1052
1053 return S_OK;
1054}
1055
1056STDMETHODIMP Console::COMGETTER(Debugger) (IMachineDebugger **aDebugger)
1057{
1058 if (!aDebugger)
1059 return E_POINTER;
1060
1061 AutoCaller autoCaller (this);
1062 CheckComRCReturnRC (autoCaller.rc());
1063
1064 /* we need a write lock because of the lazy mDebugger initialization*/
1065 AutoLock alock (this);
1066
1067 /* check if we have to create the debugger object */
1068 if (!mDebugger)
1069 {
1070 unconst (mDebugger).createObject();
1071 mDebugger->init (this);
1072 }
1073
1074 mDebugger.queryInterfaceTo (aDebugger);
1075
1076 return S_OK;
1077}
1078
1079STDMETHODIMP Console::COMGETTER(USBDevices) (IUSBDeviceCollection **aUSBDevices)
1080{
1081 if (!aUSBDevices)
1082 return E_POINTER;
1083
1084 AutoCaller autoCaller (this);
1085 CheckComRCReturnRC (autoCaller.rc());
1086
1087 AutoReaderLock alock (this);
1088
1089 ComObjPtr <OUSBDeviceCollection> collection;
1090 collection.createObject();
1091 collection->init (mUSBDevices);
1092 collection.queryInterfaceTo (aUSBDevices);
1093
1094 return S_OK;
1095}
1096
1097STDMETHODIMP Console::COMGETTER(RemoteUSBDevices) (IHostUSBDeviceCollection **aRemoteUSBDevices)
1098{
1099 if (!aRemoteUSBDevices)
1100 return E_POINTER;
1101
1102 AutoCaller autoCaller (this);
1103 CheckComRCReturnRC (autoCaller.rc());
1104
1105 AutoReaderLock alock (this);
1106
1107 ComObjPtr <RemoteUSBDeviceCollection> collection;
1108 collection.createObject();
1109 collection->init (mRemoteUSBDevices);
1110 collection.queryInterfaceTo (aRemoteUSBDevices);
1111
1112 return S_OK;
1113}
1114
1115STDMETHODIMP Console::COMGETTER(RemoteDisplayInfo) (IRemoteDisplayInfo **aRemoteDisplayInfo)
1116{
1117 if (!aRemoteDisplayInfo)
1118 return E_POINTER;
1119
1120 AutoCaller autoCaller (this);
1121 CheckComRCReturnRC (autoCaller.rc());
1122
1123 /* mDisplay is constant during life time, no need to lock */
1124 mRemoteDisplayInfo.queryInterfaceTo (aRemoteDisplayInfo);
1125
1126 return S_OK;
1127}
1128
1129STDMETHODIMP
1130Console::COMGETTER(SharedFolders) (ISharedFolderCollection **aSharedFolders)
1131{
1132 if (!aSharedFolders)
1133 return E_POINTER;
1134
1135 AutoCaller autoCaller (this);
1136 CheckComRCReturnRC (autoCaller.rc());
1137
1138 /* loadDataFromSavedState() needs a write lock */
1139 AutoLock alock (this);
1140
1141 /* Read console data stored in the saved state file (if not yet done) */
1142 HRESULT rc = loadDataFromSavedState();
1143 CheckComRCReturnRC (rc);
1144
1145 ComObjPtr <SharedFolderCollection> coll;
1146 coll.createObject();
1147 coll->init (mSharedFolders);
1148 coll.queryInterfaceTo (aSharedFolders);
1149
1150 return S_OK;
1151}
1152
1153// IConsole methods
1154/////////////////////////////////////////////////////////////////////////////
1155
1156STDMETHODIMP Console::PowerUp (IProgress **aProgress)
1157{
1158 LogFlowThisFuncEnter();
1159 LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1160
1161 AutoCaller autoCaller (this);
1162 CheckComRCReturnRC (autoCaller.rc());
1163
1164 AutoLock alock (this);
1165
1166 if (mMachineState >= MachineState_Running)
1167 return setError(E_FAIL, tr ("Cannot power up the machine as it is already running. (Machine state: %d)"), mMachineState);
1168
1169 /*
1170 * First check whether all disks are accessible. This is not a 100%
1171 * bulletproof approach (race condition, it might become inaccessible
1172 * right after the check) but it's convenient as it will cover 99.9%
1173 * of the cases and here, we're able to provide meaningful error
1174 * information.
1175 */
1176 ComPtr<IHardDiskAttachmentCollection> coll;
1177 mMachine->COMGETTER(HardDiskAttachments)(coll.asOutParam());
1178 ComPtr<IHardDiskAttachmentEnumerator> enumerator;
1179 coll->Enumerate(enumerator.asOutParam());
1180 BOOL fHasMore;
1181 while (SUCCEEDED(enumerator->HasMore(&fHasMore)) && fHasMore)
1182 {
1183 ComPtr<IHardDiskAttachment> attach;
1184 enumerator->GetNext(attach.asOutParam());
1185 ComPtr<IHardDisk> hdd;
1186 attach->COMGETTER(HardDisk)(hdd.asOutParam());
1187 Assert(hdd);
1188 BOOL fAccessible;
1189 HRESULT rc = hdd->COMGETTER(AllAccessible)(&fAccessible);
1190 CheckComRCReturnRC (rc);
1191 if (!fAccessible)
1192 {
1193 Bstr loc;
1194 hdd->COMGETTER(Location) (loc.asOutParam());
1195 Bstr errMsg;
1196 hdd->COMGETTER(LastAccessError) (errMsg.asOutParam());
1197 return setError (E_FAIL,
1198 tr ("VM cannot start because the hard disk '%ls' is not accessible "
1199 "(%ls)"),
1200 loc.raw(), errMsg.raw());
1201 }
1202 }
1203
1204 /* now perform the same check if a ISO is mounted */
1205 ComPtr<IDVDDrive> dvdDrive;
1206 mMachine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());
1207 ComPtr<IDVDImage> dvdImage;
1208 dvdDrive->GetImage(dvdImage.asOutParam());
1209 if (dvdImage)
1210 {
1211 BOOL fAccessible;
1212 HRESULT rc = dvdImage->COMGETTER(Accessible)(&fAccessible);
1213 CheckComRCReturnRC (rc);
1214 if (!fAccessible)
1215 {
1216 Bstr filePath;
1217 dvdImage->COMGETTER(FilePath)(filePath.asOutParam());
1218 /// @todo (r=dmik) grab the last access error once
1219 // IDVDImage::lastAccessError is there
1220 return setError (E_FAIL,
1221 tr ("VM cannot start because the DVD image '%ls' is not accessible"),
1222 filePath.raw());
1223 }
1224 }
1225
1226 /* now perform the same check if a floppy is mounted */
1227 ComPtr<IFloppyDrive> floppyDrive;
1228 mMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
1229 ComPtr<IFloppyImage> floppyImage;
1230 floppyDrive->GetImage(floppyImage.asOutParam());
1231 if (floppyImage)
1232 {
1233 BOOL fAccessible;
1234 HRESULT rc = floppyImage->COMGETTER(Accessible)(&fAccessible);
1235 CheckComRCReturnRC (rc);
1236 if (!fAccessible)
1237 {
1238 Bstr filePath;
1239 floppyImage->COMGETTER(FilePath)(filePath.asOutParam());
1240 /// @todo (r=dmik) grab the last access error once
1241 // IDVDImage::lastAccessError is there
1242 return setError (E_FAIL,
1243 tr ("VM cannot start because the floppy image '%ls' is not accessible"),
1244 filePath.raw());
1245 }
1246 }
1247
1248 /* now the network cards will undergo a quick consistency check */
1249 for (ULONG slot = 0; slot < SchemaDefs::NetworkAdapterCount; slot ++)
1250 {
1251 ComPtr<INetworkAdapter> adapter;
1252 mMachine->GetNetworkAdapter (slot, adapter.asOutParam());
1253 BOOL enabled = FALSE;
1254 adapter->COMGETTER(Enabled) (&enabled);
1255 if (!enabled)
1256 continue;
1257
1258 NetworkAttachmentType_T netattach;
1259 adapter->COMGETTER(AttachmentType)(&netattach);
1260 switch (netattach)
1261 {
1262 case NetworkAttachmentType_HostInterfaceNetworkAttachment:
1263 {
1264#ifdef __WIN__
1265 /* a valid host interface must have been set */
1266 Bstr hostif;
1267 adapter->COMGETTER(HostInterface)(hostif.asOutParam());
1268 if (!hostif)
1269 {
1270 return setError (E_FAIL,
1271 tr ("VM cannot start because host interface networking "
1272 "requires a host interface name to be set"));
1273 }
1274 ComPtr<IVirtualBox> virtualBox;
1275 mMachine->COMGETTER(Parent)(virtualBox.asOutParam());
1276 ComPtr<IHost> host;
1277 virtualBox->COMGETTER(Host)(host.asOutParam());
1278 ComPtr<IHostNetworkInterfaceCollection> coll;
1279 host->COMGETTER(NetworkInterfaces)(coll.asOutParam());
1280 ComPtr<IHostNetworkInterface> hostInterface;
1281 if (!SUCCEEDED(coll->FindByName(hostif, hostInterface.asOutParam())))
1282 {
1283 return setError (E_FAIL,
1284 tr ("VM cannot start because the host interface '%ls' "
1285 "does not exist"),
1286 hostif.raw());
1287 }
1288#endif /* __WIN__ */
1289 break;
1290 }
1291 default:
1292 break;
1293 }
1294 }
1295
1296 /* Read console data stored in the saved state file (if not yet done) */
1297 {
1298 HRESULT rc = loadDataFromSavedState();
1299 CheckComRCReturnRC (rc);
1300 }
1301
1302 /* Check all types of shared folders and compose a single list */
1303 std::map <Bstr, ComPtr <ISharedFolder> > sharedFolders;
1304 {
1305 /// @todo (dmik) check and add globally shared folders when they are
1306 // done
1307
1308 ComPtr <ISharedFolderCollection> coll;
1309 HRESULT rc = mMachine->COMGETTER(SharedFolders) (coll.asOutParam());
1310 CheckComRCReturnRC (rc);
1311 ComPtr <ISharedFolderEnumerator> en;
1312 rc = coll->Enumerate (en.asOutParam());
1313 CheckComRCReturnRC (rc);
1314
1315 BOOL hasMore = FALSE;
1316 while (SUCCEEDED (en->HasMore (&hasMore)) && hasMore)
1317 {
1318 ComPtr <ISharedFolder> folder;
1319 en->GetNext (folder.asOutParam());
1320
1321 Bstr name;
1322 rc = folder->COMGETTER(Name) (name.asOutParam());
1323 CheckComRCReturnRC (rc);
1324
1325 BOOL accessible = FALSE;
1326 rc = folder->COMGETTER(Accessible) (&accessible);
1327 CheckComRCReturnRC (rc);
1328
1329 if (!accessible)
1330 {
1331 Bstr hostPath;
1332 folder->COMGETTER(HostPath) (hostPath.asOutParam());
1333 return setError (E_FAIL,
1334 tr ("Host path '%ls' of the shared folder '%ls' is not accessible"),
1335 hostPath.raw(), name.raw());
1336 }
1337
1338 sharedFolders.insert (std::make_pair (name, folder));
1339 /// @todo (dmik) later, do this:
1340// if (!sharedFolders.insert (std::pair <name, folder>).second)
1341// return setError (E_FAIL,
1342// tr ("Could not accept a permanently shared folder named '%ls' "
1343// "because a globally shared folder with the same name "
1344// "already exists"),
1345// name.raw());
1346 }
1347
1348 for (SharedFolderList::const_iterator it = mSharedFolders.begin();
1349 it != mSharedFolders.end(); ++ it)
1350 {
1351 ComPtr <ISharedFolder> folder = static_cast <SharedFolder *> (*it);
1352
1353 if (!sharedFolders.insert (std::make_pair ((*it)->name(), folder)).second)
1354 return setError (E_FAIL,
1355 tr ("Could not create a transient shared folder named '%ls' "
1356 "because a global or a permanent shared folder with "
1357 "the same name already exists"),
1358 (*it)->name().raw());
1359 }
1360 }
1361
1362 Bstr savedStateFile;
1363
1364 /*
1365 * Saved VMs will have to prove that their saved states are kosher.
1366 */
1367 if (mMachineState == MachineState_Saved)
1368 {
1369 HRESULT rc = mMachine->COMGETTER(StateFilePath) (savedStateFile.asOutParam());
1370 CheckComRCReturnRC (rc);
1371 ComAssertRet (!!savedStateFile, E_FAIL);
1372 int vrc = SSMR3ValidateFile (Utf8Str (savedStateFile));
1373 if (VBOX_FAILURE (vrc))
1374 return setError (E_FAIL,
1375 tr ("VM cannot start because the saved state file '%ls' is invalid (%Vrc). "
1376 "Discard the saved state prior to starting the VM"),
1377 savedStateFile.raw(), vrc);
1378 }
1379
1380 /* create an IProgress object to track progress of this operation */
1381 ComObjPtr <Progress> progress;
1382 progress.createObject();
1383 Bstr progressDesc;
1384 if (mMachineState == MachineState_Saved)
1385 progressDesc = tr ("Restoring the virtual machine");
1386 else
1387 progressDesc = tr ("Starting the virtual machine");
1388 progress->init ((IConsole *) this, progressDesc, FALSE /* aCancelable */);
1389
1390 /* pass reference to caller if requested */
1391 if (aProgress)
1392 progress.queryInterfaceTo (aProgress);
1393
1394 /* setup task object and thread to carry out the operation asynchronously */
1395 std::auto_ptr <VMPowerUpTask> task (new VMPowerUpTask (this, progress));
1396 ComAssertComRCRetRC (task->rc());
1397
1398 task->mSetVMErrorCallback = setVMErrorCallback;
1399 task->mConfigConstructor = configConstructor;
1400 task->mSharedFolders = sharedFolders;
1401 if (mMachineState == MachineState_Saved)
1402 task->mSavedStateFile = savedStateFile;
1403
1404 int vrc = RTThreadCreate (NULL, Console::powerUpThread, (void *) task.get(),
1405 0, RTTHREADTYPE_MAIN_WORKER, 0, "VMPowerUp");
1406
1407 ComAssertMsgRCRet (vrc, ("Could not create VMPowerUp thread (%Vrc)\n", vrc),
1408 E_FAIL);
1409
1410 /* task is now owned by powerUpThread(), so release it */
1411 task.release();
1412
1413 if (mMachineState == MachineState_Saved)
1414 setMachineState (MachineState_Restoring);
1415 else
1416 setMachineState (MachineState_Starting);
1417
1418 LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1419 LogFlowThisFuncLeave();
1420 return S_OK;
1421}
1422
1423STDMETHODIMP Console::PowerDown()
1424{
1425 LogFlowThisFuncEnter();
1426 LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1427
1428 AutoCaller autoCaller (this);
1429 CheckComRCReturnRC (autoCaller.rc());
1430
1431 AutoLock alock (this);
1432
1433 if (mMachineState != MachineState_Running &&
1434 mMachineState != MachineState_Paused)
1435 {
1436 /* extra nice error message for a common case */
1437 if (mMachineState == MachineState_Saved)
1438 return setError(E_FAIL, tr ("Cannot power off a saved machine"));
1439 else
1440 return setError(E_FAIL, tr ("Cannot power off the machine as it is not running or paused. (Machine state: %d)"), mMachineState);
1441 }
1442
1443 LogFlowThisFunc (("Sending SHUTDOWN request...\n"));
1444
1445 HRESULT rc = powerDown();
1446
1447 LogFlowThisFunc (("mMachineState=%d, rc=%08X\n", mMachineState, rc));
1448 LogFlowThisFuncLeave();
1449 return rc;
1450}
1451
1452STDMETHODIMP Console::Reset()
1453{
1454 LogFlowThisFuncEnter();
1455 LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1456
1457 AutoCaller autoCaller (this);
1458 CheckComRCReturnRC (autoCaller.rc());
1459
1460 AutoLock alock (this);
1461
1462 if (mMachineState != MachineState_Running)
1463 return setError(E_FAIL, tr ("Cannot reset the machine as it is not running. (Machine state: %d)"), mMachineState);
1464
1465 /* protect mpVM */
1466 AutoVMCaller autoVMCaller (this);
1467 CheckComRCReturnRC (autoVMCaller.rc());
1468
1469 /* leave the lock before a VMR3* call (EMT will call us back)! */
1470 alock.leave();
1471
1472 int vrc = VMR3Reset (mpVM);
1473
1474 HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1475 setError (E_FAIL, tr ("Could not reset the machine. (Error: %Vrc)"), vrc);
1476
1477 LogFlowThisFunc (("mMachineState=%d, rc=%08X\n", mMachineState, rc));
1478 LogFlowThisFuncLeave();
1479 return rc;
1480}
1481
1482STDMETHODIMP Console::Pause()
1483{
1484 LogFlowThisFuncEnter();
1485
1486 AutoCaller autoCaller (this);
1487 CheckComRCReturnRC (autoCaller.rc());
1488
1489 AutoLock alock (this);
1490
1491 if (mMachineState != MachineState_Running)
1492 return setError (E_FAIL, tr ("Cannot pause the machine as it is not running. (Machine state: %d)"), mMachineState);
1493
1494 /* protect mpVM */
1495 AutoVMCaller autoVMCaller (this);
1496 CheckComRCReturnRC (autoVMCaller.rc());
1497
1498 LogFlowThisFunc (("Sending PAUSE request...\n"));
1499
1500 /* leave the lock before a VMR3* call (EMT will call us back)! */
1501 alock.leave();
1502
1503 int vrc = VMR3Suspend (mpVM);
1504
1505 HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1506 setError (E_FAIL,
1507 tr ("Could not suspend the machine execution. (Error: %Vrc)"), vrc);
1508
1509 LogFlowThisFunc (("rc=%08X\n", rc));
1510 LogFlowThisFuncLeave();
1511 return rc;
1512}
1513
1514STDMETHODIMP Console::Resume()
1515{
1516 LogFlowThisFuncEnter();
1517
1518 AutoCaller autoCaller (this);
1519 CheckComRCReturnRC (autoCaller.rc());
1520
1521 AutoLock alock (this);
1522
1523 if (mMachineState != MachineState_Paused)
1524 return setError (E_FAIL, tr ("Cannot resume the machine as it is not paused. (Machine state: %d)"), mMachineState);
1525
1526 /* protect mpVM */
1527 AutoVMCaller autoVMCaller (this);
1528 CheckComRCReturnRC (autoVMCaller.rc());
1529
1530 LogFlowThisFunc (("Sending RESUME request...\n"));
1531
1532 /* leave the lock before a VMR3* call (EMT will call us back)! */
1533 alock.leave();
1534
1535 int vrc = VMR3Resume (mpVM);
1536
1537 HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1538 setError (E_FAIL,
1539 tr ("Could not resume the machine execution. (Error: %Vrc)"), vrc);
1540
1541 LogFlowThisFunc (("rc=%08X\n", rc));
1542 LogFlowThisFuncLeave();
1543 return rc;
1544}
1545
1546STDMETHODIMP Console::PowerButton()
1547{
1548 LogFlowThisFuncEnter();
1549
1550 AutoCaller autoCaller (this);
1551 CheckComRCReturnRC (autoCaller.rc());
1552
1553 AutoLock lock (this);
1554
1555 if (mMachineState != MachineState_Running)
1556 return setError (E_FAIL, tr ("Cannot power off the machine as it is not running. (Machine state: %d)"), mMachineState);
1557
1558 /* protect mpVM */
1559 AutoVMCaller autoVMCaller (this);
1560 CheckComRCReturnRC (autoVMCaller.rc());
1561
1562 PPDMIBASE pBase;
1563 int vrc = PDMR3QueryDeviceLun (mpVM, "acpi", 0, 0, &pBase);
1564 if (VBOX_SUCCESS (vrc))
1565 {
1566 Assert (pBase);
1567 PPDMIACPIPORT pPort =
1568 (PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
1569 vrc = pPort ? pPort->pfnPowerButtonPress(pPort) : VERR_INVALID_POINTER;
1570 }
1571
1572 HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
1573 setError (E_FAIL,
1574 tr ("Controlled power off failed. (Error: %Vrc)"), vrc);
1575
1576 LogFlowThisFunc (("rc=%08X\n", rc));
1577 LogFlowThisFuncLeave();
1578 return rc;
1579}
1580
1581STDMETHODIMP Console::SaveState (IProgress **aProgress)
1582{
1583 LogFlowThisFuncEnter();
1584 LogFlowThisFunc (("mMachineState=%d\n", mMachineState));
1585
1586 if (!aProgress)
1587 return E_POINTER;
1588
1589 AutoCaller autoCaller (this);
1590 CheckComRCReturnRC (autoCaller.rc());
1591
1592 AutoLock alock (this);
1593
1594 if (mMachineState != MachineState_Running &&
1595 mMachineState != MachineState_Paused)
1596 {
1597 return setError (E_FAIL,
1598 tr ("Cannot save the machine state as the machine is not running or paused. (Machine state: %d)"), mMachineState);
1599 }
1600
1601 /* memorize the current machine state */
1602 MachineState_T lastMachineState = mMachineState;
1603
1604 if (mMachineState == MachineState_Running)
1605 {
1606 HRESULT rc = Pause();
1607 CheckComRCReturnRC (rc);
1608 }
1609
1610 HRESULT rc = S_OK;
1611
1612 /* create a progress object to track operation completion */
1613 ComObjPtr <Progress> progress;
1614 progress.createObject();
1615 progress->init ((IConsole *) this,
1616 Bstr (tr ("Saving the execution state of the virtual machine")),
1617 FALSE /* aCancelable */);
1618
1619 bool beganSavingState = false;
1620 bool taskCreationFailed = false;
1621
1622 do
1623 {
1624 /* create a task object early to ensure mpVM protection is successful */
1625 std::auto_ptr <VMSaveTask> task (new VMSaveTask (this, progress));
1626 rc = task->rc();
1627 /*
1628 * If we fail here it means a PowerDown() call happened on another
1629 * thread while we were doing Pause() (which leaves the Console lock).
1630 * We assign PowerDown() a higher precendence than SaveState(),
1631 * therefore just return the error to the caller.
1632 */
1633 if (FAILED (rc))
1634 {
1635 taskCreationFailed = true;
1636 break;
1637 }
1638
1639 Bstr stateFilePath;
1640
1641 /*
1642 * request a saved state file path from the server
1643 * (this will set the machine state to Saving on the server to block
1644 * others from accessing this machine)
1645 */
1646 rc = mControl->BeginSavingState (progress, stateFilePath.asOutParam());
1647 CheckComRCBreakRC (rc);
1648
1649 beganSavingState = true;
1650
1651 /* sync the state with the server */
1652 setMachineStateLocally (MachineState_Saving);
1653
1654 /* ensure the directory for the saved state file exists */
1655 {
1656 Utf8Str dir = stateFilePath;
1657 RTPathStripFilename (dir.mutableRaw());
1658 if (!RTDirExists (dir))
1659 {
1660 int vrc = RTDirCreateFullPath (dir, 0777);
1661 if (VBOX_FAILURE (vrc))
1662 {
1663 rc = setError (E_FAIL,
1664 tr ("Could not create a directory '%s' to save the state to. (Error: %Vrc)"),
1665 dir.raw(), vrc);
1666 break;
1667 }
1668 }
1669 }
1670
1671 /* setup task object and thread to carry out the operation asynchronously */
1672 task->mIsSnapshot = false;
1673 task->mSavedStateFile = stateFilePath;
1674 /* set the state the operation thread will restore when it is finished */
1675 task->mLastMachineState = lastMachineState;
1676
1677 /* create a thread to wait until the VM state is saved */
1678 int vrc = RTThreadCreate (NULL, Console::saveStateThread, (void *) task.get(),
1679 0, RTTHREADTYPE_MAIN_WORKER, 0, "VMSave");
1680
1681 ComAssertMsgRCBreak (vrc, ("Could not create VMSave thread (%Vrc)\n", vrc),
1682 rc = E_FAIL);
1683
1684 /* task is now owned by saveStateThread(), so release it */
1685 task.release();
1686
1687 /* return the progress to the caller */
1688 progress.queryInterfaceTo (aProgress);
1689 }
1690 while (0);
1691
1692 if (FAILED (rc) && !taskCreationFailed)
1693 {
1694 /* fetch any existing error info */
1695 ErrorInfo ei;
1696
1697 if (beganSavingState)
1698 {
1699 /*
1700 * cancel the requested save state procedure.
1701 * This will reset the machine state to the state it had right
1702 * before calling mControl->BeginSavingState().
1703 */
1704 mControl->EndSavingState (FALSE);
1705 }
1706
1707 if (lastMachineState == MachineState_Running)
1708 {
1709 /* restore the paused state if appropriate */
1710 setMachineStateLocally (MachineState_Paused);
1711 /* restore the running state if appropriate */
1712 Resume();
1713 }
1714 else
1715 setMachineStateLocally (lastMachineState);
1716
1717 /* restore fetched error info */
1718 setError (ei);
1719 }
1720
1721 LogFlowThisFunc (("rc=%08X\n", rc));
1722 LogFlowThisFuncLeave();
1723 return rc;
1724}
1725
1726STDMETHODIMP Console::DiscardSavedState()
1727{
1728 AutoCaller autoCaller (this);
1729 CheckComRCReturnRC (autoCaller.rc());
1730
1731 AutoLock alock (this);
1732
1733 if (mMachineState != MachineState_Saved)
1734 return setError (E_FAIL,
1735 tr ("Cannot discard the machine state as the machine is not in the saved state. (Machine state: %d"), mMachineState);
1736
1737 /*
1738 * Saved -> PoweredOff transition will be detected in the SessionMachine
1739 * and properly handled.
1740 */
1741 setMachineState (MachineState_PoweredOff);
1742
1743 return S_OK;
1744}
1745
1746/** read the value of a LEd. */
1747inline uint32_t readAndClearLed(PPDMLED pLed)
1748{
1749 if (!pLed)
1750 return 0;
1751 uint32_t u32 = pLed->Actual.u32 | pLed->Asserted.u32;
1752 pLed->Asserted.u32 = 0;
1753 return u32;
1754}
1755
1756STDMETHODIMP Console::GetDeviceActivity (DeviceType_T aDeviceType,
1757 DeviceActivity_T *aDeviceActivity)
1758{
1759 if (!aDeviceActivity)
1760 return E_INVALIDARG;
1761
1762 AutoCaller autoCaller (this);
1763 CheckComRCReturnRC (autoCaller.rc());
1764
1765 /*
1766 * Note: we don't lock the console object here because
1767 * readAndClearLed() should be thread safe.
1768 */
1769
1770 /* Get LED array to read */
1771 PDMLEDCORE SumLed = {0};
1772 switch (aDeviceType)
1773 {
1774 case DeviceType_FloppyDevice:
1775 {
1776 for (unsigned i = 0; i < ELEMENTS(mapFDLeds); i++)
1777 SumLed.u32 |= readAndClearLed(mapFDLeds[i]);
1778 break;
1779 }
1780
1781 case DeviceType_DVDDevice:
1782 {
1783 SumLed.u32 |= readAndClearLed(mapIDELeds[2]);
1784 break;
1785 }
1786
1787 case DeviceType_HardDiskDevice:
1788 {
1789 SumLed.u32 |= readAndClearLed(mapIDELeds[0]);
1790 SumLed.u32 |= readAndClearLed(mapIDELeds[1]);
1791 SumLed.u32 |= readAndClearLed(mapIDELeds[3]);
1792 break;
1793 }
1794
1795 case DeviceType_NetworkDevice:
1796 {
1797 for (unsigned i = 0; i < ELEMENTS(mapNetworkLeds); i++)
1798 SumLed.u32 |= readAndClearLed(mapNetworkLeds[i]);
1799 break;
1800 }
1801
1802 case DeviceType_USBDevice:
1803 {
1804 /// @todo (r=dmik)
1805 // USB_DEVICE_ACTIVITY
1806 break;
1807 }
1808
1809 default:
1810 return setError (E_INVALIDARG,
1811 tr ("Invalid device type: %d"), aDeviceType);
1812 }
1813
1814 /* Compose the result */
1815 switch (SumLed.u32 & (PDMLED_READING | PDMLED_WRITING))
1816 {
1817 case 0:
1818 *aDeviceActivity = DeviceActivity_DeviceIdle;
1819 break;
1820 case PDMLED_READING:
1821 *aDeviceActivity = DeviceActivity_DeviceReading;
1822 break;
1823 case PDMLED_WRITING:
1824 case PDMLED_READING | PDMLED_WRITING:
1825 *aDeviceActivity = DeviceActivity_DeviceWriting;
1826 break;
1827 }
1828
1829 return S_OK;
1830}
1831
1832STDMETHODIMP Console::AttachUSBDevice (INPTR GUIDPARAM aId)
1833{
1834 AutoCaller autoCaller (this);
1835 CheckComRCReturnRC (autoCaller.rc());
1836
1837 AutoLock alock (this);
1838
1839 /// @todo (r=dmik) is it legal to attach USB devices when the machine is
1840 // Paused, Starting, Saving, Stopping, etc? if not, we should make a
1841 // stricter check (mMachineState != MachineState_Running).
1842 if (mMachineState < MachineState_Running)
1843 return setError (E_FAIL, tr ("Cannot attach a USB device to a machine which is not running. (Machine state: %d)"), mMachineState);
1844
1845 /* protect mpVM */
1846 AutoVMCaller autoVMCaller (this);
1847 CheckComRCReturnRC (autoVMCaller.rc());
1848
1849 /* Don't proceed unless we've found the usb controller. */
1850 PPDMIBASE pBase = NULL;
1851 int vrc = PDMR3QueryLun (mpVM, "usb-ohci", 0, 0, &pBase);
1852 if (VBOX_FAILURE (vrc))
1853 return setError (E_FAIL, tr ("The virtual machine does not have a USB controller."));
1854
1855 PVUSBIRHCONFIG pRhConfig = (PVUSBIRHCONFIG) pBase->
1856 pfnQueryInterface (pBase, PDMINTERFACE_VUSB_RH_CONFIG);
1857 ComAssertRet (pRhConfig, E_FAIL);
1858
1859 /// @todo (dmik) REMOTE_USB
1860 // when remote USB devices are ready, first search for a device with the
1861 // given UUID in mRemoteUSBDevices. If found, request a capture from
1862 // a remote client. If not found, search it on the local host as done below
1863
1864 /*
1865 * Try attach the given host USB device (a proper errror message should
1866 * be returned in case of error).
1867 */
1868 ComPtr <IUSBDevice> hostDevice;
1869 HRESULT hrc = mControl->CaptureUSBDevice (aId, hostDevice.asOutParam());
1870 CheckComRCReturnRC (hrc);
1871
1872 return attachUSBDevice (hostDevice, true /* aManual */, pRhConfig);
1873}
1874
1875STDMETHODIMP Console::DetachUSBDevice (INPTR GUIDPARAM aId, IUSBDevice **aDevice)
1876{
1877 if (!aDevice)
1878 return E_POINTER;
1879
1880 AutoCaller autoCaller (this);
1881 CheckComRCReturnRC (autoCaller.rc());
1882
1883 AutoLock alock (this);
1884
1885 /* Find it. */
1886 ComObjPtr <OUSBDevice> device;
1887 USBDeviceList::iterator it = mUSBDevices.begin();
1888 while (it != mUSBDevices.end())
1889 {
1890 if ((*it)->id() == aId)
1891 {
1892 device = *it;
1893 break;
1894 }
1895 ++ it;
1896 }
1897
1898 if (!device)
1899 return setError (E_INVALIDARG,
1900 tr ("Cannot detach the USB device (UUID: %s) as it is not attached here."),
1901 Guid (aId).toString().raw());
1902
1903 /* protect mpVM */
1904 AutoVMCaller autoVMCaller (this);
1905 CheckComRCReturnRC (autoVMCaller.rc());
1906
1907 PPDMIBASE pBase = NULL;
1908 int vrc = PDMR3QueryLun (mpVM, "usb-ohci", 0, 0, &pBase);
1909
1910 /* if the device is attached, then there must be a USB controller */
1911 ComAssertRCRet (vrc, E_FAIL);
1912
1913 PVUSBIRHCONFIG pRhConfig = (PVUSBIRHCONFIG) pBase->
1914 pfnQueryInterface (pBase, PDMINTERFACE_VUSB_RH_CONFIG);
1915 ComAssertRet (pRhConfig, E_FAIL);
1916
1917 Guid Uuid(aId);
1918
1919 LogFlowThisFunc (("Detaching USB proxy device {%Vuuid}...\n", Uuid.raw()));
1920
1921 /* leave the lock before a VMR3* call (EMT will call us back)! */
1922 alock.leave();
1923
1924 PVMREQ pReq = NULL;
1925 vrc = VMR3ReqCall (mpVM, &pReq, RT_INDEFINITE_WAIT,
1926 (PFNRT) usbDetachCallback, 5,
1927 this, &it, true /* aManual */, pRhConfig, Uuid.raw());
1928 if (VBOX_SUCCESS (vrc))
1929 vrc = pReq->iStatus;
1930 VMR3ReqFree (pReq);
1931
1932 HRESULT hrc = S_OK;
1933
1934 if (VBOX_SUCCESS (vrc))
1935 device.queryInterfaceTo (aDevice);
1936 else
1937 hrc = setError (E_FAIL,
1938 tr ("Error detaching the USB device. (Failed to destroy the USB proxy device: %Vrc)"), vrc);
1939
1940 return hrc;
1941}
1942
1943STDMETHODIMP
1944Console::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath)
1945{
1946 if (!aName || !aHostPath)
1947 return E_INVALIDARG;
1948
1949 AutoCaller autoCaller (this);
1950 CheckComRCReturnRC (autoCaller.rc());
1951
1952 AutoLock alock (this);
1953
1954 if (mMachineState == MachineState_Saved)
1955 return setError (E_FAIL,
1956 tr ("Cannot create a transient shared folder on a "
1957 "machine in the saved state."));
1958
1959 /// @todo (dmik) check globally shared folders when they are done
1960
1961 /* check machine's shared folders */
1962 {
1963 ComPtr <ISharedFolderCollection> coll;
1964 HRESULT rc = mMachine->COMGETTER(SharedFolders) (coll.asOutParam());
1965 if (FAILED (rc))
1966 return rc;
1967
1968 ComPtr <ISharedFolder> machineSharedFolder;
1969 rc = coll->FindByName (aName, machineSharedFolder.asOutParam());
1970 if (SUCCEEDED (rc))
1971 return setError (E_FAIL,
1972 tr ("A permanent shared folder named '%ls' already "
1973 "exists."), aName);
1974 }
1975
1976 ComObjPtr <SharedFolder> sharedFolder;
1977 HRESULT rc = findSharedFolder (aName, sharedFolder, false /* aSetError */);
1978 if (SUCCEEDED (rc))
1979 return setError (E_FAIL,
1980 tr ("A shared folder named '%ls' already exists."), aName);
1981
1982 sharedFolder.createObject();
1983 rc = sharedFolder->init (this, aName, aHostPath);
1984 CheckComRCReturnRC (rc);
1985
1986 BOOL accessible = FALSE;
1987 rc = sharedFolder->COMGETTER(Accessible) (&accessible);
1988 CheckComRCReturnRC (rc);
1989
1990 if (!accessible)
1991 return setError (E_FAIL,
1992 tr ("The shared folder path '%ls' on the host is not accessible."), aHostPath);
1993
1994 /* protect mpVM */
1995 AutoVMCaller autoVMCaller (this);
1996 CheckComRCReturnRC (autoVMCaller.rc());
1997
1998 /// @todo (r=sander?) should move this into the shared folder class */
1999 if (mpVM && mVMMDev->getShFlClientId())
2000 {
2001 /*
2002 * if the VM is online and supports shared folders, share this folde
2003 * under the specified name. On error, return it to the caller.
2004 */
2005 VBOXHGCMSVCPARM parms[2];
2006 SHFLSTRING *pFolderName, *pMapName;
2007 int cbString;
2008
2009 Log(("Add shared folder %ls -> %ls\n", aName, aHostPath));
2010
2011 cbString = (RTStrUcs2Len(aHostPath) + 1) * sizeof(RTUCS2);
2012 pFolderName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
2013 Assert(pFolderName);
2014 memcpy(pFolderName->String.ucs2, aHostPath, cbString);
2015
2016 pFolderName->u16Size = cbString;
2017 pFolderName->u16Length = cbString - sizeof(RTUCS2);
2018
2019 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
2020 parms[0].u.pointer.addr = pFolderName;
2021 parms[0].u.pointer.size = sizeof(SHFLSTRING) + cbString;
2022
2023 cbString = (RTStrUcs2Len(aName) + 1) * sizeof(RTUCS2);
2024 pMapName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
2025 Assert(pMapName);
2026 memcpy(pMapName->String.ucs2, aName, cbString);
2027
2028 pMapName->u16Size = cbString;
2029 pMapName->u16Length = cbString - sizeof(RTUCS2);
2030
2031 parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
2032 parms[1].u.pointer.addr = pMapName;
2033 parms[1].u.pointer.size = sizeof(SHFLSTRING) + cbString;
2034
2035 rc = mVMMDev->hgcmHostCall("VBoxSharedFolders", SHFL_FN_ADD_MAPPING, 2, &parms[0]);
2036 RTMemFree(pFolderName);
2037 RTMemFree(pMapName);
2038 if (rc != VINF_SUCCESS)
2039 return setError (E_FAIL, tr ("Unable to add mapping %ls to %ls."), aHostPath, aName);
2040 }
2041
2042 mSharedFolders.push_back (sharedFolder);
2043 return S_OK;
2044}
2045
2046STDMETHODIMP Console::RemoveSharedFolder (INPTR BSTR aName)
2047{
2048 if (!aName)
2049 return E_INVALIDARG;
2050
2051 AutoCaller autoCaller (this);
2052 CheckComRCReturnRC (autoCaller.rc());
2053
2054 AutoLock alock (this);
2055
2056 if (mMachineState == MachineState_Saved)
2057 return setError (E_FAIL,
2058 tr ("Cannot remove a transient shared folder when the "
2059 "machine is in the saved state."));
2060
2061 ComObjPtr <SharedFolder> sharedFolder;
2062 HRESULT rc = findSharedFolder (aName, sharedFolder, true /* aSetError */);
2063 CheckComRCReturnRC (rc);
2064
2065 /* protect mpVM */
2066 AutoVMCaller autoVMCaller (this);
2067 CheckComRCReturnRC (autoVMCaller.rc());
2068
2069 if (mpVM && mVMMDev->getShFlClientId())
2070 {
2071 /*
2072 * if the VM is online and supports shared folders, UNshare this folder.
2073 * On error, return it to the caller.
2074 */
2075 VBOXHGCMSVCPARM parms;
2076 SHFLSTRING *pMapName;
2077 int cbString;
2078
2079 cbString = (RTStrUcs2Len(aName) + 1) * sizeof(RTUCS2);
2080 pMapName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
2081 Assert(pMapName);
2082 memcpy(pMapName->String.ucs2, aName, cbString);
2083
2084 pMapName->u16Size = cbString;
2085 pMapName->u16Length = cbString - sizeof(RTUCS2);
2086
2087 parms.type = VBOX_HGCM_SVC_PARM_PTR;
2088 parms.u.pointer.addr = pMapName;
2089 parms.u.pointer.size = sizeof(SHFLSTRING) + cbString;
2090
2091 rc = mVMMDev->hgcmHostCall("VBoxSharedFolders", SHFL_FN_REMOVE_MAPPING, 1, &parms);
2092 RTMemFree(pMapName);
2093 if (rc != VINF_SUCCESS)
2094 rc = setError (E_FAIL, tr ("Unable to remove the mapping %ls."), aName);
2095 }
2096
2097 mSharedFolders.remove (sharedFolder);
2098 return rc;
2099}
2100
2101STDMETHODIMP Console::TakeSnapshot (INPTR BSTR aName, INPTR BSTR aDescription,
2102 IProgress **aProgress)
2103{
2104 LogFlowThisFuncEnter();
2105 LogFlowThisFunc (("aName='%ls' mMachineState=%08X\n", aName, mMachineState));
2106
2107 if (!aName)
2108 return E_INVALIDARG;
2109 if (!aProgress)
2110 return E_POINTER;
2111
2112 AutoCaller autoCaller (this);
2113 CheckComRCReturnRC (autoCaller.rc());
2114
2115 AutoLock alock (this);
2116
2117 if (mMachineState > MachineState_Running &&
2118 mMachineState != MachineState_Paused)
2119 {
2120 return setError (E_FAIL,
2121 tr ("Cannot take a snapshot of a machine while it is changing state. (Machine state: %d)"), mMachineState);
2122 }
2123
2124 /* memorize the current machine state */
2125 MachineState_T lastMachineState = mMachineState;
2126
2127 if (mMachineState == MachineState_Running)
2128 {
2129 HRESULT rc = Pause();
2130 CheckComRCReturnRC (rc);
2131 }
2132
2133 HRESULT rc = S_OK;
2134
2135 bool takingSnapshotOnline = mMachineState == MachineState_Paused;
2136
2137 /*
2138 * create a descriptionless VM-side progress object
2139 * (only when creating a snapshot online)
2140 */
2141 ComObjPtr <Progress> saveProgress;
2142 if (takingSnapshotOnline)
2143 {
2144 saveProgress.createObject();
2145 rc = saveProgress->init (FALSE, 1, Bstr (tr ("Saving the execution state")));
2146 AssertComRCReturn (rc, rc);
2147 }
2148
2149 bool beganTakingSnapshot = false;
2150 bool taskCreationFailed = false;
2151
2152 do
2153 {
2154 /* create a task object early to ensure mpVM protection is successful */
2155 std::auto_ptr <VMSaveTask> task;
2156 if (takingSnapshotOnline)
2157 {
2158 task.reset (new VMSaveTask (this, saveProgress));
2159 rc = task->rc();
2160 /*
2161 * If we fail here it means a PowerDown() call happened on another
2162 * thread while we were doing Pause() (which leaves the Console lock).
2163 * We assign PowerDown() a higher precendence than TakeSnapshot(),
2164 * therefore just return the error to the caller.
2165 */
2166 if (FAILED (rc))
2167 {
2168 taskCreationFailed = true;
2169 break;
2170 }
2171 }
2172
2173 Bstr stateFilePath;
2174 ComPtr <IProgress> serverProgress;
2175
2176 /*
2177 * request taking a new snapshot object on the server
2178 * (this will set the machine state to Saving on the server to block
2179 * others from accessing this machine)
2180 */
2181 rc = mControl->BeginTakingSnapshot (this, aName, aDescription,
2182 saveProgress, stateFilePath.asOutParam(),
2183 serverProgress.asOutParam());
2184 if (FAILED (rc))
2185 break;
2186
2187 /*
2188 * state file is non-null only when the VM is paused
2189 * (i.e. createing a snapshot online)
2190 */
2191 ComAssertBreak (
2192 (!stateFilePath.isNull() && takingSnapshotOnline) ||
2193 (stateFilePath.isNull() && !takingSnapshotOnline),
2194 rc = E_FAIL);
2195
2196 beganTakingSnapshot = true;
2197
2198 /* sync the state with the server */
2199 setMachineStateLocally (MachineState_Saving);
2200
2201 /*
2202 * create a combined VM-side progress object and start the save task
2203 * (only when creating a snapshot online)
2204 */
2205 ComObjPtr <CombinedProgress> combinedProgress;
2206 if (takingSnapshotOnline)
2207 {
2208 combinedProgress.createObject();
2209 rc = combinedProgress->init ((IConsole *) this,
2210 Bstr (tr ("Taking snapshot of virtual machine")),
2211 serverProgress, saveProgress);
2212 AssertComRCBreakRC (rc);
2213
2214 /* setup task object and thread to carry out the operation asynchronously */
2215 task->mIsSnapshot = true;
2216 task->mSavedStateFile = stateFilePath;
2217 task->mServerProgress = serverProgress;
2218 /* set the state the operation thread will restore when it is finished */
2219 task->mLastMachineState = lastMachineState;
2220
2221 /* create a thread to wait until the VM state is saved */
2222 int vrc = RTThreadCreate (NULL, Console::saveStateThread, (void *) task.get(),
2223 0, RTTHREADTYPE_MAIN_WORKER, 0, "VMTakeSnap");
2224
2225 ComAssertMsgRCBreak (vrc, ("Could not create VMTakeSnap thread (%Vrc)\n", vrc),
2226 rc = E_FAIL);
2227
2228 /* task is now owned by saveStateThread(), so release it */
2229 task.release();
2230 }
2231
2232 if (SUCCEEDED (rc))
2233 {
2234 /* return the correct progress to the caller */
2235 if (combinedProgress)
2236 combinedProgress.queryInterfaceTo (aProgress);
2237 else
2238 serverProgress.queryInterfaceTo (aProgress);
2239 }
2240 }
2241 while (0);
2242
2243 if (FAILED (rc) && !taskCreationFailed)
2244 {
2245 /* fetch any existing error info */
2246 ErrorInfo ei;
2247
2248 if (beganTakingSnapshot && takingSnapshotOnline)
2249 {
2250 /*
2251 * cancel the requested snapshot (only when creating a snapshot
2252 * online, otherwise the server will cancel the snapshot itself).
2253 * This will reset the machine state to the state it had right
2254 * before calling mControl->BeginTakingSnapshot().
2255 */
2256 mControl->EndTakingSnapshot (FALSE);
2257 }
2258
2259 if (lastMachineState == MachineState_Running)
2260 {
2261 /* restore the paused state if appropriate */
2262 setMachineStateLocally (MachineState_Paused);
2263 /* restore the running state if appropriate */
2264 Resume();
2265 }
2266 else
2267 setMachineStateLocally (lastMachineState);
2268
2269 /* restore fetched error info */
2270 setError (ei);
2271 }
2272
2273 LogFlowThisFunc (("rc=%08X\n", rc));
2274 LogFlowThisFuncLeave();
2275 return rc;
2276}
2277
2278STDMETHODIMP Console::DiscardSnapshot (INPTR GUIDPARAM aId, IProgress **aProgress)
2279{
2280 if (Guid (aId).isEmpty())
2281 return E_INVALIDARG;
2282 if (!aProgress)
2283 return E_POINTER;
2284
2285 AutoCaller autoCaller (this);
2286 CheckComRCReturnRC (autoCaller.rc());
2287
2288 AutoLock alock (this);
2289
2290 if (mMachineState >= MachineState_Running)
2291 return setError (E_FAIL,
2292 tr ("Cannot discard a snapshot on a running machine (Machine state: %d)"), mMachineState);
2293
2294 MachineState_T machineState = MachineState_InvalidMachineState;
2295 HRESULT rc = mControl->DiscardSnapshot (this, aId, &machineState, aProgress);
2296 CheckComRCReturnRC (rc);
2297
2298 setMachineStateLocally (machineState);
2299 return S_OK;
2300}
2301
2302STDMETHODIMP Console::DiscardCurrentState (IProgress **aProgress)
2303{
2304 AutoCaller autoCaller (this);
2305 CheckComRCReturnRC (autoCaller.rc());
2306
2307 AutoLock alock (this);
2308
2309 if (mMachineState >= MachineState_Running)
2310 return setError (E_FAIL,
2311 tr ("Cannot discard the current state of a running machine. (Machine state: %d)"), mMachineState);
2312
2313 MachineState_T machineState = MachineState_InvalidMachineState;
2314 HRESULT rc = mControl->DiscardCurrentState (this, &machineState, aProgress);
2315 CheckComRCReturnRC (rc);
2316
2317 setMachineStateLocally (machineState);
2318 return S_OK;
2319}
2320
2321STDMETHODIMP Console::DiscardCurrentSnapshotAndState (IProgress **aProgress)
2322{
2323 AutoCaller autoCaller (this);
2324 CheckComRCReturnRC (autoCaller.rc());
2325
2326 AutoLock alock (this);
2327
2328 if (mMachineState >= MachineState_Running)
2329 return setError (E_FAIL,
2330 tr ("Cannot discard the current snapshot and state on a running machine. (Machine state: %d)"), mMachineState);
2331
2332 MachineState_T machineState = MachineState_InvalidMachineState;
2333 HRESULT rc =
2334 mControl->DiscardCurrentSnapshotAndState (this, &machineState, aProgress);
2335 CheckComRCReturnRC (rc);
2336
2337 setMachineStateLocally (machineState);
2338 return S_OK;
2339}
2340
2341STDMETHODIMP Console::RegisterCallback (IConsoleCallback *aCallback)
2342{
2343 if (!aCallback)
2344 return E_INVALIDARG;
2345
2346 AutoCaller autoCaller (this);
2347 CheckComRCReturnRC (autoCaller.rc());
2348
2349 AutoLock alock (this);
2350
2351 mCallbacks.push_back (CallbackList::value_type (aCallback));
2352 return S_OK;
2353}
2354
2355STDMETHODIMP Console::UnregisterCallback (IConsoleCallback *aCallback)
2356{
2357 if (!aCallback)
2358 return E_INVALIDARG;
2359
2360 AutoCaller autoCaller (this);
2361 CheckComRCReturnRC (autoCaller.rc());
2362
2363 AutoLock alock (this);
2364
2365 CallbackList::iterator it;
2366 it = std::find (mCallbacks.begin(),
2367 mCallbacks.end(),
2368 CallbackList::value_type (aCallback));
2369 if (it == mCallbacks.end())
2370 return setError (E_INVALIDARG,
2371 tr ("The given callback handler is not registered"));
2372
2373 mCallbacks.erase (it);
2374 return S_OK;
2375}
2376
2377// Non-interface public methods
2378/////////////////////////////////////////////////////////////////////////////
2379
2380/**
2381 * Called by IInternalSessionControl::OnDVDDriveChange().
2382 *
2383 * @note Locks this object for reading.
2384 */
2385HRESULT Console::onDVDDriveChange()
2386{
2387 LogFlowThisFunc (("\n"));
2388
2389 AutoCaller autoCaller (this);
2390 AssertComRCReturnRC (autoCaller.rc());
2391
2392 AutoReaderLock alock (this);
2393
2394 /* Ignore callbacks when there's no VM around */
2395 if (!mpVM)
2396 return S_OK;
2397
2398 /* protect mpVM */
2399 AutoVMCaller autoVMCaller (this);
2400 CheckComRCReturnRC (autoVMCaller.rc());
2401
2402 /* Get the current DVD state */
2403 HRESULT rc;
2404 DriveState_T eState;
2405
2406 rc = mDVDDrive->COMGETTER (State) (&eState);
2407 ComAssertComRCRetRC (rc);
2408
2409 /* Paranoia */
2410 if ( eState == DriveState_NotMounted
2411 && meDVDState == DriveState_NotMounted)
2412 {
2413 LogFlowThisFunc (("Returns (NotMounted -> NotMounted)\n"));
2414 return S_OK;
2415 }
2416
2417 /* Get the path string and other relevant properties */
2418 Bstr Path;
2419 bool fPassthrough = false;
2420 switch (eState)
2421 {
2422 case DriveState_ImageMounted:
2423 {
2424 ComPtr <IDVDImage> ImagePtr;
2425 rc = mDVDDrive->GetImage (ImagePtr.asOutParam());
2426 if (SUCCEEDED (rc))
2427 rc = ImagePtr->COMGETTER(FilePath) (Path.asOutParam());
2428 break;
2429 }
2430
2431 case DriveState_HostDriveCaptured:
2432 {
2433 ComPtr <IHostDVDDrive> DrivePtr;
2434 BOOL enabled;
2435 rc = mDVDDrive->GetHostDrive (DrivePtr.asOutParam());
2436 if (SUCCEEDED (rc))
2437 rc = DrivePtr->COMGETTER (Name) (Path.asOutParam());
2438 if (SUCCEEDED (rc))
2439 rc = mDVDDrive->COMGETTER (Passthrough) (&enabled);
2440 if (SUCCEEDED (rc))
2441 fPassthrough = !!enabled;
2442 break;
2443 }
2444
2445 case DriveState_NotMounted:
2446 break;
2447
2448 default:
2449 AssertMsgFailed (("Invalid DriveState: %d\n", eState));
2450 rc = E_FAIL;
2451 break;
2452 }
2453
2454 AssertComRC (rc);
2455 if (FAILED (rc))
2456 {
2457 LogFlowThisFunc (("Returns %#x\n", rc));
2458 return rc;
2459 }
2460
2461 return doDriveChange ("piix3ide", 0, 2, eState, &meDVDState,
2462 Utf8Str (Path).raw(), fPassthrough);
2463}
2464
2465
2466/**
2467 * Called by IInternalSessionControl::OnFloppyDriveChange().
2468 *
2469 * @note Locks this object for reading.
2470 */
2471HRESULT Console::onFloppyDriveChange()
2472{
2473 LogFlowThisFunc (("\n"));
2474
2475 AutoCaller autoCaller (this);
2476 AssertComRCReturnRC (autoCaller.rc());
2477
2478 AutoReaderLock alock (this);
2479
2480 /* Ignore callbacks when there's no VM around */
2481 if (!mpVM)
2482 return S_OK;
2483
2484 /* protect mpVM */
2485 AutoVMCaller autoVMCaller (this);
2486 CheckComRCReturnRC (autoVMCaller.rc());
2487
2488 /* Get the current floppy state */
2489 HRESULT rc;
2490 DriveState_T eState;
2491
2492 /* If the floppy drive is disabled, we're not interested */
2493 BOOL fEnabled;
2494 rc = mFloppyDrive->COMGETTER (Enabled) (&fEnabled);
2495 ComAssertComRCRetRC (rc);
2496
2497 if (!fEnabled)
2498 return S_OK;
2499
2500 rc = mFloppyDrive->COMGETTER (State) (&eState);
2501 ComAssertComRCRetRC (rc);
2502
2503 Log2 (("onFloppyDriveChange: eState=%d meFloppyState=%d\n", eState, meFloppyState));
2504
2505
2506 /* Paranoia */
2507 if ( eState == DriveState_NotMounted
2508 && meFloppyState == DriveState_NotMounted)
2509 {
2510 LogFlowThisFunc (("Returns (NotMounted -> NotMounted)\n"));
2511 return S_OK;
2512 }
2513
2514 /* Get the path string and other relevant properties */
2515 Bstr Path;
2516 switch (eState)
2517 {
2518 case DriveState_ImageMounted:
2519 {
2520 ComPtr <IFloppyImage> ImagePtr;
2521 rc = mFloppyDrive->GetImage (ImagePtr.asOutParam());
2522 if (SUCCEEDED (rc))
2523 rc = ImagePtr->COMGETTER(FilePath) (Path.asOutParam());
2524 break;
2525 }
2526
2527 case DriveState_HostDriveCaptured:
2528 {
2529 ComPtr <IHostFloppyDrive> DrivePtr;
2530 rc = mFloppyDrive->GetHostDrive (DrivePtr.asOutParam());
2531 if (SUCCEEDED (rc))
2532 rc = DrivePtr->COMGETTER (Name) (Path.asOutParam());
2533 break;
2534 }
2535
2536 case DriveState_NotMounted:
2537 break;
2538
2539 default:
2540 AssertMsgFailed (("Invalid DriveState: %d\n", eState));
2541 rc = E_FAIL;
2542 break;
2543 }
2544
2545 AssertComRC (rc);
2546 if (FAILED (rc))
2547 {
2548 LogFlowThisFunc (("Returns %#x\n", rc));
2549 return rc;
2550 }
2551
2552 return doDriveChange ("i82078", 0, 0, eState, &meFloppyState,
2553 Utf8Str (Path).raw(), false);
2554}
2555
2556
2557/**
2558 * Process a floppy or dvd change.
2559 *
2560 * @returns COM status code.
2561 *
2562 * @param pszDevice The PDM device name.
2563 * @param uInstance The PDM device instance.
2564 * @param uLun The PDM LUN number of the drive.
2565 * @param eState The new state.
2566 * @param peState Pointer to the variable keeping the actual state of the drive.
2567 * This will be both read and updated to eState or other appropriate state.
2568 * @param pszPath The path to the media / drive which is now being mounted / captured.
2569 * If NULL no media or drive is attached and the lun will be configured with
2570 * the default block driver with no media. This will also be the state if
2571 * mounting / capturing the specified media / drive fails.
2572 * @param fPassthrough Enables using passthrough mode of the host DVD drive if applicable.
2573 *
2574 * @note Locks this object for reading.
2575 */
2576HRESULT Console::doDriveChange (const char *pszDevice, unsigned uInstance, unsigned uLun, DriveState_T eState,
2577 DriveState_T *peState, const char *pszPath, bool fPassthrough)
2578{
2579 LogFlowThisFunc (("pszDevice=%p:{%s} uInstance=%u uLun=%u eState=%d "
2580 "peState=%p:{%d} pszPath=%p:{%s} fPassthrough=%d\n",
2581 pszDevice, pszDevice, uInstance, uLun, eState,
2582 peState, *peState, pszPath, pszPath, fPassthrough));
2583
2584 AutoCaller autoCaller (this);
2585 AssertComRCReturnRC (autoCaller.rc());
2586
2587 AutoReaderLock alock (this);
2588
2589 /* protect mpVM */
2590 AutoVMCaller autoVMCaller (this);
2591 CheckComRCReturnRC (autoVMCaller.rc());
2592
2593 /*
2594 * Call worker in EMT, that's faster and safer than doing everything
2595 * using VM3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
2596 * here to make requests from under the lock in order to serialize them.
2597 */
2598 PVMREQ pReq;
2599 int vrc = VMR3ReqCall (mpVM, &pReq, 0 /* no wait! */,
2600 (PFNRT) Console::changeDrive, 8,
2601 this, pszDevice, uInstance, uLun, eState, peState,
2602 pszPath, fPassthrough);
2603 /// @todo (r=dmik) bird, it would be nice to have a special VMR3Req method
2604 // for that purpose, that doesn't return useless VERR_TIMEOUT
2605 if (vrc == VERR_TIMEOUT)
2606 vrc = VINF_SUCCESS;
2607
2608 /* leave the lock before waiting for a result (EMT will call us back!) */
2609 alock.leave();
2610
2611 if (VBOX_SUCCESS (vrc))
2612 {
2613 vrc = VMR3ReqWait (pReq, RT_INDEFINITE_WAIT);
2614 AssertRC (vrc);
2615 if (VBOX_SUCCESS (vrc))
2616 vrc = pReq->iStatus;
2617 }
2618 VMR3ReqFree (pReq);
2619
2620 if (VBOX_SUCCESS (vrc))
2621 {
2622 LogFlowThisFunc (("Returns S_OK\n"));
2623 return S_OK;
2624 }
2625
2626 if (pszPath)
2627 return setError (E_FAIL,
2628 tr ("Could not mount the media/drive '%s' (%Vrc)"), pszPath, vrc);
2629
2630 return setError (E_FAIL,
2631 tr ("Could not unmount the currently mounted media/drive (%Vrc)"), vrc);
2632}
2633
2634
2635/**
2636 * Performs the Floppy/DVD change in EMT.
2637 *
2638 * @returns VBox status code.
2639 *
2640 * @param pThis Pointer to the Console object.
2641 * @param pszDevice The PDM device name.
2642 * @param uInstance The PDM device instance.
2643 * @param uLun The PDM LUN number of the drive.
2644 * @param eState The new state.
2645 * @param peState Pointer to the variable keeping the actual state of the drive.
2646 * This will be both read and updated to eState or other appropriate state.
2647 * @param pszPath The path to the media / drive which is now being mounted / captured.
2648 * If NULL no media or drive is attached and the lun will be configured with
2649 * the default block driver with no media. This will also be the state if
2650 * mounting / capturing the specified media / drive fails.
2651 * @param fPassthrough Enables using passthrough mode of the host DVD drive if applicable.
2652 *
2653 * @thread EMT
2654 * @note Locks the Console object for writing
2655 */
2656DECLCALLBACK(int) Console::changeDrive (Console *pThis, const char *pszDevice, unsigned uInstance, unsigned uLun,
2657 DriveState_T eState, DriveState_T *peState,
2658 const char *pszPath, bool fPassthrough)
2659{
2660 LogFlowFunc (("pThis=%p pszDevice=%p:{%s} uInstance=%u uLun=%u eState=%d "
2661 "peState=%p:{%d} pszPath=%p:{%s} fPassthrough=%d\n",
2662 pThis, pszDevice, pszDevice, uInstance, uLun, eState,
2663 peState, *peState, pszPath, pszPath, fPassthrough));
2664
2665 AssertReturn (pThis, VERR_INVALID_PARAMETER);
2666
2667 AssertMsg ( (!strcmp (pszDevice, "i82078") && uLun == 0 && uInstance == 0)
2668 || (!strcmp (pszDevice, "piix3ide") && uLun == 2 && uInstance == 0),
2669 ("pszDevice=%s uLun=%d uInstance=%d\n", pszDevice, uLun, uInstance));
2670
2671 AutoCaller autoCaller (pThis);
2672 AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
2673
2674 /*
2675 * Locking the object before doing VMR3* calls is quite safe here,
2676 * since we're on EMT. Write lock is necessary because we're indirectly
2677 * modify the meDVDState/meFloppyState members (pointed to by peState).
2678 */
2679 AutoLock alock (pThis);
2680
2681 /* protect mpVM */
2682 AutoVMCaller autoVMCaller (pThis);
2683 CheckComRCReturnRC (autoVMCaller.rc());
2684
2685 PVM pVM = pThis->mpVM;
2686
2687 /*
2688 * Suspend the VM first.
2689 *
2690 * The VM must not be running since it might have pending I/O to
2691 * the drive which is being changed.
2692 */
2693 bool fResume;
2694 VMSTATE enmVMState = VMR3GetState (pVM);
2695 switch (enmVMState)
2696 {
2697 case VMSTATE_RESETTING:
2698 case VMSTATE_RUNNING:
2699 {
2700 LogFlowFunc (("Suspending the VM...\n"));
2701 /* disable the callback to prevent Console-level state change */
2702 pThis->mVMStateChangeCallbackDisabled = true;
2703 int rc = VMR3Suspend (pVM);
2704 pThis->mVMStateChangeCallbackDisabled = false;
2705 AssertRCReturn (rc, rc);
2706 fResume = true;
2707 break;
2708 }
2709
2710 case VMSTATE_SUSPENDED:
2711 case VMSTATE_CREATED:
2712 case VMSTATE_OFF:
2713 fResume = false;
2714 break;
2715
2716 default:
2717 AssertMsgFailedReturn (("enmVMState=%d\n", enmVMState), VERR_ACCESS_DENIED);
2718 }
2719
2720 int rc = VINF_SUCCESS;
2721 int rcRet = VINF_SUCCESS;
2722
2723 do
2724 {
2725 /*
2726 * Unmount existing media / detach host drive.
2727 */
2728 PPDMIMOUNT pIMount = NULL;
2729 switch (*peState)
2730 {
2731
2732 case DriveState_ImageMounted:
2733 {
2734 /*
2735 * Resolve the interface.
2736 */
2737 PPDMIBASE pBase;
2738 rc = PDMR3QueryLun (pVM, pszDevice, uInstance, uLun, &pBase);
2739 if (VBOX_FAILURE (rc))
2740 {
2741 if (rc == VERR_PDM_LUN_NOT_FOUND)
2742 rc = VINF_SUCCESS;
2743 AssertRC (rc);
2744 break;
2745 }
2746
2747 pIMount = (PPDMIMOUNT) pBase->pfnQueryInterface (pBase, PDMINTERFACE_MOUNT);
2748 AssertBreak (pIMount, rc = VERR_INVALID_POINTER);
2749
2750 /*
2751 * Unmount the media.
2752 */
2753 rc = pIMount->pfnUnmount (pIMount);
2754 if (rc == VERR_PDM_MEDIA_NOT_MOUNTED)
2755 rc = VINF_SUCCESS;
2756 break;
2757 }
2758
2759 case DriveState_HostDriveCaptured:
2760 {
2761 rc = PDMR3DeviceDetach (pVM, pszDevice, uInstance, uLun);
2762 if (rc == VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN)
2763 rc = VINF_SUCCESS;
2764 AssertRC (rc);
2765 break;
2766 }
2767
2768 case DriveState_NotMounted:
2769 break;
2770
2771 default:
2772 AssertMsgFailed (("Invalid *peState: %d\n", peState));
2773 break;
2774 }
2775
2776 if (VBOX_FAILURE (rc))
2777 {
2778 rcRet = rc;
2779 break;
2780 }
2781
2782 /*
2783 * Nothing is currently mounted.
2784 */
2785 *peState = DriveState_NotMounted;
2786
2787
2788 /*
2789 * Process the HostDriveCaptured state first, as the fallback path
2790 * means mounting the normal block driver without media.
2791 */
2792 if (eState == DriveState_HostDriveCaptured)
2793 {
2794 /*
2795 * Detach existing driver chain (block).
2796 */
2797 int rc = PDMR3DeviceDetach (pVM, pszDevice, uInstance, uLun);
2798 if (VBOX_FAILURE (rc))
2799 {
2800 if (rc == VERR_PDM_LUN_NOT_FOUND)
2801 rc = VINF_SUCCESS;
2802 AssertReleaseRC (rc);
2803 break; /* we're toast */
2804 }
2805 pIMount = NULL;
2806
2807 /*
2808 * Construct a new driver configuration.
2809 */
2810 PCFGMNODE pInst = CFGMR3GetChildF (CFGMR3GetRoot (pVM), "Devices/%s/%d/", pszDevice, uInstance);
2811 AssertRelease (pInst);
2812 /* nuke anything which might have been left behind. */
2813 CFGMR3RemoveNode (CFGMR3GetChildF (pInst, "LUN#%d", uLun));
2814
2815 /* create a new block driver config */
2816 PCFGMNODE pLunL0;
2817 PCFGMNODE pCfg;
2818 if ( VBOX_SUCCESS (rc = CFGMR3InsertNodeF (pInst, &pLunL0, "LUN#%u", uLun))
2819 && VBOX_SUCCESS (rc = CFGMR3InsertString (pLunL0, "Driver", !strcmp (pszDevice, "i82078") ? "HostFloppy" : "HostDVD"))
2820 && VBOX_SUCCESS (rc = CFGMR3InsertNode (pLunL0, "Config", &pCfg))
2821 && VBOX_SUCCESS (rc = CFGMR3InsertString (pCfg, "Path", pszPath))
2822 && VBOX_SUCCESS (rc = !strcmp (pszDevice, "i82078") ? VINF_SUCCESS : CFGMR3InsertInteger(pCfg, "Passthrough", fPassthrough)))
2823 {
2824 /*
2825 * Attempt to attach the driver.
2826 */
2827 rc = PDMR3DeviceAttach (pVM, pszDevice, uInstance, uLun, NULL);
2828 AssertRC (rc);
2829 }
2830 if (VBOX_FAILURE (rc))
2831 rcRet = rc;
2832 }
2833
2834 /*
2835 * Process the ImageMounted, NotMounted and failed HostDriveCapture cases.
2836 */
2837 rc = VINF_SUCCESS;
2838 switch (eState)
2839 {
2840#define RC_CHECK() do { if (VBOX_FAILURE (rc)) { AssertReleaseRC (rc); break; } } while (0)
2841
2842 case DriveState_HostDriveCaptured:
2843 if (VBOX_SUCCESS (rcRet))
2844 break;
2845 /* fallback: umounted block driver. */
2846 pszPath = NULL;
2847 eState = DriveState_NotMounted;
2848 /* fallthru */
2849 case DriveState_ImageMounted:
2850 case DriveState_NotMounted:
2851 {
2852 /*
2853 * Resolve the drive interface / create the driver.
2854 */
2855 if (!pIMount)
2856 {
2857 PPDMIBASE pBase;
2858 rc = PDMR3QueryLun (pVM, pszDevice, uInstance, uLun, &pBase);
2859 if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
2860 {
2861 /*
2862 * We have to create it, so we'll do the full config setup and everything.
2863 */
2864 PCFGMNODE pIdeInst = CFGMR3GetChildF (CFGMR3GetRoot (pVM), "Devices/%s/%d/", pszDevice, uInstance);
2865 AssertRelease (pIdeInst);
2866
2867 /* nuke anything which might have been left behind. */
2868 CFGMR3RemoveNode (CFGMR3GetChildF (pIdeInst, "LUN#%d", uLun));
2869
2870 /* create a new block driver config */
2871 PCFGMNODE pLunL0;
2872 rc = CFGMR3InsertNodeF (pIdeInst, &pLunL0, "LUN#%d", uLun); RC_CHECK();
2873 rc = CFGMR3InsertString (pLunL0, "Driver", "Block"); RC_CHECK();
2874 PCFGMNODE pCfg;
2875 rc = CFGMR3InsertNode (pLunL0, "Config", &pCfg); RC_CHECK();
2876 rc = CFGMR3InsertString (pCfg, "Type", !strcmp (pszDevice, "i82078") ? "Floppy 1.44" : "DVD");
2877 RC_CHECK();
2878 rc = CFGMR3InsertInteger (pCfg, "Mountable", 1); RC_CHECK();
2879
2880 /*
2881 * Attach the driver.
2882 */
2883 rc = PDMR3DeviceAttach (pVM, pszDevice, uInstance, uLun, &pBase);
2884 RC_CHECK();
2885 }
2886 else if (VBOX_FAILURE(rc))
2887 {
2888 AssertRC (rc);
2889 return rc;
2890 }
2891
2892 pIMount = (PPDMIMOUNT) pBase->pfnQueryInterface (pBase, PDMINTERFACE_MOUNT);
2893 if (!pIMount)
2894 {
2895 AssertFailed();
2896 return rc;
2897 }
2898 }
2899
2900 /*
2901 * If we've got an image, let's mount it.
2902 */
2903 if (pszPath && *pszPath)
2904 {
2905 rc = pIMount->pfnMount (pIMount, pszPath, strcmp (pszDevice, "i82078") ? "MediaISO" : "RawImage");
2906 if (VBOX_FAILURE (rc))
2907 eState = DriveState_NotMounted;
2908 }
2909 break;
2910 }
2911
2912 default:
2913 AssertMsgFailed (("Invalid eState: %d\n", eState));
2914 break;
2915
2916#undef RC_CHECK
2917 }
2918
2919 if (VBOX_FAILURE (rc) && VBOX_SUCCESS (rcRet))
2920 rcRet = rc;
2921
2922 *peState = eState;
2923 }
2924 while (0);
2925
2926 /*
2927 * Resume the VM if necessary.
2928 */
2929 if (fResume)
2930 {
2931 LogFlowFunc (("Resuming the VM...\n"));
2932 /* disable the callback to prevent Console-level state change */
2933 pThis->mVMStateChangeCallbackDisabled = true;
2934 rc = VMR3Resume (pVM);
2935 pThis->mVMStateChangeCallbackDisabled = false;
2936 AssertRC (rc);
2937 if (VBOX_FAILURE (rc))
2938 {
2939 /* too bad, we failed. try to sync the console state with the VMM state */
2940 vmstateChangeCallback (pVM, VMSTATE_SUSPENDED, enmVMState, pThis);
2941 }
2942 /// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
2943 // error (if any) will be hidden from the caller. For proper reporting
2944 // of such multiple errors to the caller we need to enhance the
2945 // IVurtualBoxError interface. For now, give the first error the higher
2946 // priority.
2947 if (VBOX_SUCCESS (rcRet))
2948 rcRet = rc;
2949 }
2950
2951 LogFlowFunc (("Returning %Vrc\n", rcRet));
2952 return rcRet;
2953}
2954
2955
2956/**
2957 * Called by IInternalSessionControl::OnNetworkAdapterChange().
2958 *
2959 * @note Locks this object for writing.
2960 */
2961HRESULT Console::onNetworkAdapterChange(INetworkAdapter *networkAdapter)
2962{
2963 LogFlowThisFunc (("\n"));
2964
2965 AutoCaller autoCaller (this);
2966 AssertComRCReturnRC (autoCaller.rc());
2967
2968 AutoLock alock (this);
2969
2970 /* Don't do anything if the VM isn't running */
2971 if (!mpVM)
2972 return S_OK;
2973
2974 /* protect mpVM */
2975 AutoVMCaller autoVMCaller (this);
2976 CheckComRCReturnRC (autoVMCaller.rc());
2977
2978 /* Get the properties we need from the adapter */
2979 BOOL fCableConnected;
2980 HRESULT rc = networkAdapter->COMGETTER(CableConnected)(&fCableConnected);
2981 AssertComRC(rc);
2982 if (SUCCEEDED(rc))
2983 {
2984 ULONG ulInstance;
2985 rc = networkAdapter->COMGETTER(Slot)(&ulInstance);
2986 AssertComRC(rc);
2987 if (SUCCEEDED(rc))
2988 {
2989 /*
2990 * Find the pcnet instance, get the config interface and update the link state.
2991 */
2992 PPDMIBASE pBase;
2993 int rcVBox = PDMR3QueryDeviceLun(mpVM, "pcnet", (unsigned)ulInstance, 0, &pBase);
2994 ComAssertRC(rcVBox);
2995 if (VBOX_SUCCESS(rcVBox))
2996 {
2997 Assert(pBase);
2998 PPDMINETWORKCONFIG pINetCfg = (PPDMINETWORKCONFIG)pBase->pfnQueryInterface(pBase, PDMINTERFACE_NETWORK_CONFIG);
2999 if (pINetCfg)
3000 {
3001 Log(("Console::onNetworkAdapterChange: setting link state to %d\n", fCableConnected));
3002 rcVBox = pINetCfg->pfnSetLinkState(pINetCfg, fCableConnected ? PDMNETWORKLINKSTATE_UP : PDMNETWORKLINKSTATE_DOWN);
3003 ComAssertRC(rcVBox);
3004 }
3005 }
3006 }
3007 }
3008
3009 LogFlowThisFunc (("Leaving rc=%#x\n", rc));
3010 return rc;
3011}
3012
3013/**
3014 * Called by IInternalSessionControl::OnVRDPServerChange().
3015 *
3016 * @note Locks this object for writing.
3017 */
3018HRESULT Console::onVRDPServerChange()
3019{
3020 AutoCaller autoCaller (this);
3021 AssertComRCReturnRC (autoCaller.rc());
3022
3023 AutoLock alock (this);
3024
3025 HRESULT rc = S_OK;
3026
3027 if (mVRDPServer && mMachineState == MachineState_Running)
3028 {
3029 BOOL vrdpEnabled = FALSE;
3030
3031 rc = mVRDPServer->COMGETTER(Enabled) (&vrdpEnabled);
3032 ComAssertComRCRetRC (rc);
3033
3034 if (vrdpEnabled)
3035 {
3036 // If there was no VRDP server started the 'stop' will do nothing.
3037 // However if a server was started and this notification was called,
3038 // we have to restart the server.
3039 mConsoleVRDPServer->Stop ();
3040
3041 if (VBOX_FAILURE(mConsoleVRDPServer->Launch ()))
3042 {
3043 rc = E_FAIL;
3044 }
3045 else
3046 {
3047 mConsoleVRDPServer->SetCallback ();
3048 }
3049 }
3050 else
3051 {
3052 mConsoleVRDPServer->Stop ();
3053 }
3054 }
3055
3056 return rc;
3057}
3058
3059/**
3060 * Called by IInternalSessionControl::OnUSBControllerChange().
3061 *
3062 * @note Locks this object for writing.
3063 */
3064HRESULT Console::onUSBControllerChange()
3065{
3066 LogFlowThisFunc (("\n"));
3067
3068 AutoCaller autoCaller (this);
3069 AssertComRCReturnRC (autoCaller.rc());
3070
3071 AutoLock alock (this);
3072
3073 /* Ignore if no VM is running yet. */
3074 if (!mpVM)
3075 return S_OK;
3076
3077/// @todo (dmik)
3078// check for the Enabled state and disable virtual USB controller??
3079// Anyway, if we want to query the machine's USB Controller we need to cache
3080// it to to mUSBController in #init() (as it is done with mDVDDrive).
3081//
3082// bird: While the VM supports hot-plugging, I doubt any guest can handle it at this time... :-)
3083//
3084// /* protect mpVM */
3085// AutoVMCaller autoVMCaller (this);
3086// CheckComRCReturnRC (autoVMCaller.rc());
3087
3088 return S_OK;
3089}
3090
3091/**
3092 * Called by IInternalSessionControl::OnUSBDeviceAttach() or locally by
3093 * processRemoteUSBDevices() after IInternalMachineControl::RunUSBDeviceFilters()
3094 * returns TRUE for a given remote USB device.
3095 *
3096 * @return S_OK if the device was attached to the VM.
3097 * @return failure if not attached.
3098 *
3099 * @param aDevice
3100 * The device in question.
3101 *
3102 * @note Locks this object for writing.
3103 */
3104HRESULT Console::onUSBDeviceAttach (IUSBDevice *aDevice)
3105{
3106 LogFlowThisFunc (("aDevice=%p\n", aDevice));
3107
3108 AutoCaller autoCaller (this);
3109 ComAssertComRCRetRC (autoCaller.rc());
3110
3111 AutoLock alock (this);
3112
3113 /* VM might have been stopped when this message arrives */
3114 if (mMachineState < MachineState_Running)
3115 {
3116 LogFlowThisFunc (("Attach request ignored (mMachineState=%d).\n",
3117 mMachineState));
3118 return E_FAIL;
3119 }
3120
3121 /* protect mpVM */
3122 AutoVMCaller autoVMCaller (this);
3123 CheckComRCReturnRC (autoVMCaller.rc());
3124
3125 /* Don't proceed unless we've found the usb controller. */
3126 PPDMIBASE pBase = NULL;
3127 int vrc = PDMR3QueryLun (mpVM, "usb-ohci", 0, 0, &pBase);
3128 if (VBOX_FAILURE (vrc))
3129 {
3130 LogFlowThisFunc (("Attach request ignored (no USB controller).\n"));
3131 return E_FAIL;
3132 }
3133
3134 PVUSBIRHCONFIG pRhConfig = (PVUSBIRHCONFIG) pBase->
3135 pfnQueryInterface (pBase, PDMINTERFACE_VUSB_RH_CONFIG);
3136 ComAssertRet (pRhConfig, E_FAIL);
3137
3138 return attachUSBDevice (aDevice, false /* aManual */, pRhConfig);
3139}
3140
3141/**
3142 * Called by IInternalSessionControl::OnUSBDeviceDetach() and locally by
3143 * processRemoteUSBDevices().
3144 *
3145 * @note Locks this object for writing.
3146 */
3147HRESULT Console::onUSBDeviceDetach (INPTR GUIDPARAM aId)
3148{
3149 Guid Uuid (aId);
3150 LogFlowThisFunc (("aId={%Vuuid}\n", Uuid.raw()));
3151
3152 AutoCaller autoCaller (this);
3153 AssertComRCReturnRC (autoCaller.rc());
3154
3155 AutoLock alock (this);
3156
3157 /* Find the device. */
3158 ComObjPtr <OUSBDevice> device;
3159 USBDeviceList::iterator it = mUSBDevices.begin();
3160 while (it != mUSBDevices.end())
3161 {
3162 LogFlowThisFunc (("it={%Vuuid}\n", (*it)->id().raw()));
3163 if ((*it)->id() == Uuid)
3164 {
3165 device = *it;
3166 break;
3167 }
3168 ++ it;
3169 }
3170
3171 /* VM might have been stopped when this message arrives */
3172 if (device.isNull())
3173 {
3174 LogFlowThisFunc (("Device not found.\n"));
3175 if (mMachineState < MachineState_Running)
3176 {
3177 LogFlowThisFunc (("Detach request ignored (mMachineState=%d).\n",
3178 mMachineState));
3179 return E_FAIL;
3180 }
3181 /* the device must be in the list */
3182 AssertFailedReturn (E_FAIL);
3183 }
3184
3185 /* protect mpVM */
3186 AutoVMCaller autoVMCaller (this);
3187 CheckComRCReturnRC (autoVMCaller.rc());
3188
3189 PPDMIBASE pBase = NULL;
3190 int vrc = PDMR3QueryLun (mpVM, "usb-ohci", 0, 0, &pBase);
3191
3192 /* if the device is attached, then there must be a USB controller */
3193 AssertRCReturn (vrc, E_FAIL);
3194
3195 PVUSBIRHCONFIG pRhConfig = (PVUSBIRHCONFIG) pBase->
3196 pfnQueryInterface (pBase, PDMINTERFACE_VUSB_RH_CONFIG);
3197 AssertReturn (pRhConfig, E_FAIL);
3198
3199 LogFlowThisFunc (("Detaching USB proxy device {%Vuuid}...\n", Uuid.raw()));
3200
3201 /* leave the lock before a VMR3* call (EMT will call us back)! */
3202 alock.leave();
3203
3204 PVMREQ pReq;
3205 vrc = VMR3ReqCall (mpVM, &pReq, RT_INDEFINITE_WAIT,
3206 (PFNRT) usbDetachCallback, 5,
3207 this, &it, false /* aManual */, pRhConfig, Uuid.raw());
3208 if (VBOX_SUCCESS (vrc))
3209 vrc = pReq->iStatus;
3210 VMR3ReqFree (pReq);
3211
3212 AssertRC (vrc);
3213
3214 return VBOX_SUCCESS (vrc) ? S_OK : E_FAIL;
3215}
3216
3217/**
3218 * Gets called by Session::UpdateMachineState()
3219 * (IInternalSessionControl::updateMachineState()).
3220 *
3221 * Must be called only in certain cases (see the implementation).
3222 *
3223 * @note Locks this object for writing.
3224 */
3225HRESULT Console::updateMachineState (MachineState_T aMachineState)
3226{
3227 AutoCaller autoCaller (this);
3228 AssertComRCReturnRC (autoCaller.rc());
3229
3230 AutoLock alock (this);
3231
3232 AssertReturn (mMachineState == MachineState_Saving ||
3233 mMachineState == MachineState_Discarding,
3234 E_FAIL);
3235
3236 return setMachineStateLocally (aMachineState);
3237}
3238
3239/**
3240 * @note Locks this object for reading.
3241 */
3242void Console::onMousePointerShapeChange(bool fVisible, bool fAlpha,
3243 uint32_t xHot, uint32_t yHot,
3244 uint32_t width, uint32_t height,
3245 void *pShape)
3246{
3247 LogFlowThisFunc (("fVisible=%d, fAlpha=%d, xHot = %d, yHot = %d, width=%d, "
3248 "height=%d, shape=%p\n",
3249 fVisible, fAlpha, xHot, yHot, width, height, pShape));
3250
3251 AutoReaderLock alock (this);
3252
3253 CallbackList::iterator it = mCallbacks.begin();
3254 while (it != mCallbacks.end())
3255 (*it++)->OnMousePointerShapeChange(fVisible, fAlpha, xHot, yHot, width, height, (ULONG)pShape);
3256}
3257
3258/**
3259 * @note Locks this object for reading.
3260 */
3261void Console::onMouseCapabilityChange (BOOL supportsAbsolute, BOOL needsHostCursor)
3262{
3263 LogFlowThisFunc (("supportsAbsolute=%d needsHostCursor=%d\n",
3264 supportsAbsolute, needsHostCursor));
3265
3266 AutoCaller autoCaller (this);
3267 AssertComRCReturnVoid (autoCaller.rc());
3268
3269 AutoReaderLock alock (this);
3270
3271 CallbackList::iterator it = mCallbacks.begin();
3272 while (it != mCallbacks.end())
3273 {
3274 Log2(("Console::onMouseCapabilityChange: calling %p\n", (void*)*it));
3275 (*it++)->OnMouseCapabilityChange (supportsAbsolute, needsHostCursor);
3276 }
3277}
3278
3279/**
3280 * @note Locks this object for reading.
3281 */
3282void Console::onStateChange (MachineState_T machineState)
3283{
3284 AutoCaller autoCaller (this);
3285 AssertComRCReturnVoid (autoCaller.rc());
3286
3287 AutoReaderLock alock (this);
3288
3289 CallbackList::iterator it = mCallbacks.begin();
3290 while (it != mCallbacks.end())
3291 (*it++)->OnStateChange (machineState);
3292}
3293
3294/**
3295 * @note Locks this object for reading.
3296 */
3297void Console::onAdditionsStateChange()
3298{
3299 AutoCaller autoCaller (this);
3300 AssertComRCReturnVoid (autoCaller.rc());
3301
3302 AutoReaderLock alock (this);
3303
3304 CallbackList::iterator it = mCallbacks.begin();
3305 while (it != mCallbacks.end())
3306 (*it++)->OnAdditionsStateChange();
3307}
3308
3309/**
3310 * @note Locks this object for reading.
3311 */
3312void Console::onAdditionsOutdated()
3313{
3314 AutoCaller autoCaller (this);
3315 AssertComRCReturnVoid (autoCaller.rc());
3316
3317 AutoReaderLock alock (this);
3318
3319 /** @todo Use the On-Screen Display feature to report the fact.
3320 * The user should be told to install additions that are
3321 * provided with the current VBox build:
3322 * VBOX_VERSION_MAJOR.VBOX_VERSION_MINOR.VBOX_VERSION_BUILD
3323 */
3324}
3325
3326/**
3327 * @note Locks this object for reading.
3328 */
3329void Console::onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock)
3330{
3331 AutoCaller autoCaller (this);
3332 AssertComRCReturnVoid (autoCaller.rc());
3333
3334 AutoReaderLock alock (this);
3335
3336 CallbackList::iterator it = mCallbacks.begin();
3337 while (it != mCallbacks.end())
3338 (*it++)->OnKeyboardLedsChange(fNumLock, fCapsLock, fScrollLock);
3339}
3340
3341/**
3342 * @note Locks this object for reading.
3343 */
3344void Console::onRuntimeError (BOOL aFatal, INPTR BSTR aErrorID, INPTR BSTR aMessage)
3345{
3346 AutoCaller autoCaller (this);
3347 AssertComRCReturnVoid (autoCaller.rc());
3348
3349 AutoReaderLock alock (this);
3350
3351 CallbackList::iterator it = mCallbacks.begin();
3352 while (it != mCallbacks.end())
3353 (*it++)->OnRuntimeError (aFatal, aErrorID, aMessage);
3354}
3355
3356// private mehtods
3357////////////////////////////////////////////////////////////////////////////////
3358
3359/**
3360 * Increases the usage counter of the mpVM pointer. Guarantees that
3361 * VMR3Destroy() will not be called on it at least until releaseVMCaller()
3362 * is called.
3363 *
3364 * If this method returns a failure, the caller is not allowed to use mpVM
3365 * and may return the failed result code to the upper level. This method sets
3366 * the extended error info on failure if \a aQuiet is false.
3367 *
3368 * Setting \a aQuiet to true is useful for methods that don't want to return
3369 * the failed result code to the caller when this method fails (e.g. need to
3370 * silently check for the mpVM avaliability).
3371 *
3372 * When mpVM is NULL but \a aAllowNullVM is true, a corresponding error will be
3373 * returned instead of asserting. Having it false is intended as a sanity check
3374 * for methods that have checked mMachineState and expect mpVM *NOT* to be NULL.
3375 *
3376 * @param aQuiet true to suppress setting error info
3377 * @param aAllowNullVM true to accept mpVM being NULL and return a failure
3378 * (otherwise this method will assert if mpVM is NULL)
3379 *
3380 * @note Locks this object for writing.
3381 */
3382HRESULT Console::addVMCaller (bool aQuiet /* = false */,
3383 bool aAllowNullVM /* = false */)
3384{
3385 AutoCaller autoCaller (this);
3386 AssertComRCReturnRC (autoCaller.rc());
3387
3388 AutoLock alock (this);
3389
3390 if (mVMDestroying)
3391 {
3392 /* powerDown() is waiting for all callers to finish */
3393 return aQuiet ? E_ACCESSDENIED : setError (E_ACCESSDENIED,
3394 tr ("Virtual machine is being powered down"));
3395 }
3396
3397 if (mpVM == NULL)
3398 {
3399 Assert (aAllowNullVM == true);
3400
3401 /* The machine is not powered up */
3402 return aQuiet ? E_ACCESSDENIED : setError (E_ACCESSDENIED,
3403 tr ("Virtual machine is not powered up"));
3404 }
3405
3406 ++ mVMCallers;
3407
3408 return S_OK;
3409}
3410
3411/**
3412 * Decreases the usage counter of the mpVM pointer. Must always complete
3413 * the addVMCaller() call after the mpVM pointer is no more necessary.
3414 *
3415 * @note Locks this object for writing.
3416 */
3417void Console::releaseVMCaller()
3418{
3419 AutoCaller autoCaller (this);
3420 AssertComRCReturnVoid (autoCaller.rc());
3421
3422 AutoLock alock (this);
3423
3424 AssertReturnVoid (mpVM != NULL);
3425
3426 Assert (mVMCallers > 0);
3427 -- mVMCallers;
3428
3429 if (mVMCallers == 0 && mVMDestroying)
3430 {
3431 /* inform powerDown() there are no more callers */
3432 RTSemEventSignal (mVMZeroCallersSem);
3433 }
3434}
3435
3436/**
3437 * Internal power off worker routine.
3438 *
3439 * This method may be called only at certain places with the folliwing meaning
3440 * as shown below:
3441 *
3442 * - if the machine state is either Running or Paused, a normal
3443 * Console-initiated powerdown takes place (e.g. PowerDown());
3444 * - if the machine state is Saving, saveStateThread() has successfully
3445 * done its job;
3446 * - if the machine state is Starting or Restoring, powerUpThread() has
3447 * failed to start/load the VM;
3448 * - if the machine state is Stopping, the VM has powered itself off
3449 * (i.e. not as a result of the powerDown() call).
3450 *
3451 * Calling it in situations other than the above will cause unexpected
3452 * behavior.
3453 *
3454 * Note that this method should be the only one that destroys mpVM and sets
3455 * it to NULL.
3456 *
3457 * @note Locks this object for writing.
3458 *
3459 * @note Never call this method from a thread that called addVMCaller() or
3460 * instantiated an AutoVMCaller object; first call releaseVMCaller() or
3461 * release(). Otherwise it will deadlock.
3462 */
3463HRESULT Console::powerDown()
3464{
3465 LogFlowThisFuncEnter();
3466
3467 AutoCaller autoCaller (this);
3468 AssertComRCReturnRC (autoCaller.rc());
3469
3470 AutoLock alock (this);
3471
3472 /* sanity */
3473 AssertReturn (mVMDestroying == false, E_FAIL);
3474
3475 LogRel (("Console::powerDown(): a request to power off the VM has been issued "
3476 "(mMachineState=%d, InUninit=%d)\n",
3477 mMachineState, autoCaller.state() == InUninit));
3478
3479 /* First, wait for all mpVM callers to finish their work if necessary */
3480 if (mVMCallers > 0)
3481 {
3482 /* go to the destroying state to prevent from adding new callers */
3483 mVMDestroying = true;
3484
3485 /* lazy creation */
3486 if (mVMZeroCallersSem == NIL_RTSEMEVENT)
3487 RTSemEventCreate (&mVMZeroCallersSem);
3488
3489 LogFlowThisFunc (("Waiting for mpVM callers (%d) to drop to zero...\n",
3490 mVMCallers));
3491
3492 alock.leave();
3493
3494 RTSemEventWait (mVMZeroCallersSem, RT_INDEFINITE_WAIT);
3495
3496 alock.enter();
3497 }
3498
3499 AssertReturn (mpVM, E_FAIL);
3500
3501 AssertMsg (mMachineState == MachineState_Running ||
3502 mMachineState == MachineState_Paused ||
3503 mMachineState == MachineState_Saving ||
3504 mMachineState == MachineState_Starting ||
3505 mMachineState == MachineState_Restoring ||
3506 mMachineState == MachineState_Stopping,
3507 ("Invalid machine state: %d\n", mMachineState));
3508
3509 HRESULT rc = S_OK;
3510 int vrc = VINF_SUCCESS;
3511
3512 /*
3513 * Power off the VM if not already done that. In case of Stopping, the VM
3514 * has powered itself off and notified Console in vmstateChangeCallback().
3515 * In case of Starting or Restoring, powerUpThread() is calling us on
3516 * failure, so the VM is already off at that point.
3517 */
3518 if (mMachineState != MachineState_Stopping &&
3519 mMachineState != MachineState_Starting &&
3520 mMachineState != MachineState_Restoring)
3521 {
3522 /*
3523 * don't go from Saving to Stopping, vmstateChangeCallback needs it
3524 * to set the state to Saved on VMSTATE_TERMINATED.
3525 */
3526 if (mMachineState != MachineState_Saving)
3527 setMachineState (MachineState_Stopping);
3528
3529 LogFlowThisFunc (("Powering off the VM...\n"));
3530
3531 /* Leave the lock since EMT will call us back on VMR3PowerOff() */
3532 alock.leave();
3533
3534 vrc = VMR3PowerOff (mpVM);
3535 /*
3536 * Note that VMR3PowerOff() may fail here (invalid VMSTATE) if the
3537 * VM-(guest-)initiated power off happened in parallel a ms before
3538 * this call. So far, we let this error pop up on the user's side.
3539 */
3540
3541 alock.enter();
3542 }
3543
3544 LogFlowThisFunc (("Ready for VM destruction\n"));
3545
3546 /*
3547 * If we are called from Console::uninit(), then try to destroy the VM
3548 * even on failure (this will most likely fail too, but what to do?..)
3549 */
3550 if (VBOX_SUCCESS (vrc) || autoCaller.state() == InUninit)
3551 {
3552 /*
3553 * Stop the VRDP server and release all USB device.
3554 * (When called from uninit mConsoleVRDPServer is already destroyed.)
3555 */
3556 if (mConsoleVRDPServer)
3557 {
3558 LogFlowThisFunc (("Stopping VRDP server...\n"));
3559 mConsoleVRDPServer->Stop();
3560 }
3561
3562 releaseAllUSBDevices();
3563
3564 /*
3565 * Now we've got to destroy the VM as well. (mpVM is not valid
3566 * beyond this point). We leave the lock before calling VMR3Destroy()
3567 * because it will result into calling destructors of drivers
3568 * associated with Console children which may in turn try to lock
3569 * Console (e.g. by instantiating SafeVMPtr to access mpVM). It's safe
3570 * here because mVMDestroying is set which should prevent any activity.
3571 */
3572
3573 /*
3574 * Set mpVM to NULL early just in case if some old code is not using
3575 * addVMCaller()/releaseVMCaller().
3576 */
3577 PVM pVM = mpVM;
3578 mpVM = NULL;
3579
3580 LogFlowThisFunc (("Destroying the VM...\n"));
3581
3582 alock.leave();
3583
3584 vrc = VMR3Destroy (pVM);
3585
3586 /* take the lock again */
3587 alock.enter();
3588
3589 if (VBOX_SUCCESS (vrc))
3590 {
3591 LogFlowThisFunc (("Machine has been destroyed (mMachineState=%d)\n",
3592 mMachineState));
3593 /*
3594 * Note: the Console-level machine state change happens on the
3595 * VMSTATE_TERMINATE state change in vmstateChangeCallback(). If
3596 * powerDown() is called from EMT (i.e. from vmstateChangeCallback()
3597 * on receiving VM-initiated VMSTATE_OFF), VMSTATE_TERMINATE hasn't
3598 * occured yet. This is okay, because mMachineState is already
3599 * Stopping in this case, so any other attempt to call PowerDown()
3600 * will be rejected.
3601 */
3602 }
3603 else
3604 {
3605 /* bad bad bad, but what to do? */
3606 mpVM = pVM;
3607 rc = setError (E_FAIL,
3608 tr ("Could not destroy the machine. (Error: %Vrc)"), vrc);
3609 }
3610 }
3611 else
3612 {
3613 rc = setError (E_FAIL,
3614 tr ("Could not power off the machine. (Error: %Vrc)"), vrc);
3615 }
3616
3617 /*
3618 * Finished with destruction. Note that if something impossible happened
3619 * and we've failed to destroy the VM, mVMDestroying will remain false and
3620 * mMachineState will be something like Stopping, so most Console methods
3621 * will return an error to the caller.
3622 */
3623 if (mpVM == NULL)
3624 mVMDestroying = false;
3625
3626 LogFlowThisFuncLeave();
3627 return rc;
3628}
3629
3630/**
3631 * @note Locks this object for writing.
3632 */
3633HRESULT Console::setMachineState (MachineState_T aMachineState,
3634 bool aUpdateServer /* = true */)
3635{
3636 AutoCaller autoCaller (this);
3637 AssertComRCReturnRC (autoCaller.rc());
3638
3639 AutoLock alock (this);
3640
3641 HRESULT rc = S_OK;
3642
3643 if (mMachineState != aMachineState)
3644 {
3645 LogFlowThisFunc (("machineState=%d\n", aMachineState));
3646 mMachineState = aMachineState;
3647
3648 /// @todo (dmik)
3649 // possibly, we need to redo onStateChange() using the dedicated
3650 // Event thread, like it is done in VirtualBox. This will make it
3651 // much safer (no deadlocks possible if someone tries to use the
3652 // console from the callback), however, listeners will lose the
3653 // ability to synchronously react to state changes (is it really
3654 // necessary??)
3655 LogFlowThisFunc (("Doing onStateChange()...\n"));
3656 onStateChange (aMachineState);
3657 LogFlowThisFunc (("Done onStateChange()\n"));
3658
3659 if (aUpdateServer)
3660 {
3661 /*
3662 * Server notification MUST be done from under the lock; otherwise
3663 * the machine state here and on the server might go out of sync, that
3664 * can lead to various unexpected results (like the machine state being
3665 * >= MachineState_Running on the server, while the session state is
3666 * already SessionState_SessionClosed at the same time there).
3667 *
3668 * Cross-lock conditions should be carefully watched out: calling
3669 * UpdateState we will require Machine and SessionMachine locks
3670 * (remember that here we're holding the Console lock here, and
3671 * also all locks that have been entered by the thread before calling
3672 * this method).
3673 */
3674 LogFlowThisFunc (("Doing mControl->UpdateState()...\n"));
3675 rc = mControl->UpdateState (aMachineState);
3676 LogFlowThisFunc (("mControl->UpdateState()=%08X\n", rc));
3677 }
3678 }
3679
3680 return rc;
3681}
3682
3683/**
3684 * Searches for a shared folder with the given logical name
3685 * in the collection of shared folders.
3686 *
3687 * @param aName logical name of the shared folder
3688 * @param aSharedFolder where to return the found object
3689 * @param aSetError whether to set the error info if the folder is
3690 * not found
3691 * @return
3692 * S_OK when found or E_INVALIDARG when not found
3693 *
3694 * @note The caller must lock this object for writing.
3695 */
3696HRESULT Console::findSharedFolder (const BSTR aName,
3697 ComObjPtr <SharedFolder> &aSharedFolder,
3698 bool aSetError /* = false */)
3699{
3700 /* sanity check */
3701 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
3702
3703 bool found = false;
3704 for (SharedFolderList::const_iterator it = mSharedFolders.begin();
3705 !found && it != mSharedFolders.end();
3706 ++ it)
3707 {
3708 AutoLock alock (*it);
3709 found = (*it)->name() == aName;
3710 if (found)
3711 aSharedFolder = *it;
3712 }
3713
3714 HRESULT rc = found ? S_OK : E_INVALIDARG;
3715
3716 if (aSetError && !found)
3717 setError (rc, tr ("Could not find a shared folder named '%ls'."), aName);
3718
3719 return rc;
3720}
3721
3722/**
3723 * VM state callback function. Called by the VMM
3724 * using its state machine states.
3725 *
3726 * Primarily used to handle VM initiated power off, suspend and state saving,
3727 * but also for doing termination completed work (VMSTATE_TERMINATE).
3728 *
3729 * In general this function is called in the context of the EMT.
3730 *
3731 * @param aVM The VM handle.
3732 * @param aState The new state.
3733 * @param aOldState The old state.
3734 * @param aUser The user argument (pointer to the Console object).
3735 *
3736 * @note Locks the Console object for writing.
3737 */
3738DECLCALLBACK(void)
3739Console::vmstateChangeCallback (PVM aVM, VMSTATE aState, VMSTATE aOldState,
3740 void *aUser)
3741{
3742 LogFlowFunc (("Changing state from %d to %d (aVM=%p)\n",
3743 aOldState, aState, aVM));
3744
3745 Console *that = static_cast <Console *> (aUser);
3746 AssertReturnVoid (that);
3747
3748 AutoCaller autoCaller (that);
3749 /*
3750 * Note that we must let this method proceed even if Console::uninit() has
3751 * been already called. In such case this VMSTATE change is a result of:
3752 * 1) powerDown() called from uninit() itself, or
3753 * 2) VM-(guest-)initiated power off.
3754 */
3755 AssertReturnVoid (autoCaller.isOk() ||
3756 autoCaller.state() == InUninit);
3757
3758 switch (aState)
3759 {
3760 /*
3761 * The VM has terminated
3762 */
3763 case VMSTATE_OFF:
3764 {
3765 AutoLock alock (that);
3766
3767 if (that->mVMStateChangeCallbackDisabled)
3768 break;
3769
3770 /*
3771 * Do we still think that it is running? It may happen if this is
3772 * a VM-(guest-)initiated shutdown/poweroff.
3773 */
3774 if (that->mMachineState != MachineState_Stopping &&
3775 that->mMachineState != MachineState_Saving &&
3776 that->mMachineState != MachineState_Restoring)
3777 {
3778 LogFlowFunc (("VM has powered itself off but Console still "
3779 "thinks it is running. Notifying.\n"));
3780
3781 /* prevent powerDown() from calling VMR3PowerOff() again */
3782 that->setMachineState (MachineState_Stopping);
3783
3784 /*
3785 * Setup task object and thread to carry out the operation
3786 * asynchronously (if we call powerDown() right here but there
3787 * is one or more mpVM callers (added with addVMCaller()) we'll
3788 * deadlock.
3789 */
3790 std::auto_ptr <VMTask> task (new VMTask (that, true /* aUsesVMPtr */));
3791 /*
3792 * If creating a task is falied, this can currently mean one
3793 * of two: either Console::uninit() has been called just a ms
3794 * before (so a powerDown() call is already on the way), or
3795 * powerDown() itself is being already executed. Just do
3796 * nothing .
3797 */
3798 if (!task->isOk())
3799 {
3800 LogFlowFunc (("Console is already being uninitialized.\n"));
3801 break;
3802 }
3803
3804 int vrc = RTThreadCreate (NULL, Console::powerDownThread,
3805 (void *) task.get(), 0,
3806 RTTHREADTYPE_MAIN_WORKER, 0,
3807 "VMPowerDowm");
3808
3809 AssertMsgRC (vrc, ("Could not create VMPowerUp thread (%Vrc)\n", vrc));
3810 if (VBOX_FAILURE (vrc))
3811 break;
3812
3813 /* task is now owned by powerDownThread(), so release it */
3814 task.release();
3815 }
3816 break;
3817 }
3818
3819 /*
3820 * The VM has been completely destroyed.
3821 *
3822 * Note: This state change can happen at two points:
3823 * 1) At the end of VMR3Destroy() if it was not called from EMT.
3824 * 2) At the end of vmR3EmulationThread if VMR3Destroy() was
3825 * called by EMT.
3826 */
3827 case VMSTATE_TERMINATED:
3828 {
3829 AutoLock alock (that);
3830
3831 if (that->mVMStateChangeCallbackDisabled)
3832 break;
3833
3834 /*
3835 * Terminate host interface networking. If aVM is NULL, we've been
3836 * manually called from powerUpThread() either before calling
3837 * VMR3Create() or after VMR3Create() failed, so no need to touch
3838 * networking.
3839 */
3840 if (aVM)
3841 that->powerDownHostInterfaces();
3842
3843 /*
3844 * From now on the machine is officially powered down or
3845 * remains in the Saved state.
3846 */
3847 switch (that->mMachineState)
3848 {
3849 default:
3850 AssertFailed();
3851 /* fall through */
3852 case MachineState_Stopping:
3853 /* successfully powered down */
3854 that->setMachineState (MachineState_PoweredOff);
3855 break;
3856 case MachineState_Saving:
3857 /*
3858 * successfully saved (note that the machine is already
3859 * in the Saved state on the server due to EndSavingState()
3860 * called from saveStateThread(), so only change the local
3861 * state)
3862 */
3863 that->setMachineStateLocally (MachineState_Saved);
3864 break;
3865 case MachineState_Starting:
3866 /*
3867 * failed to start, but be patient: set back to PoweredOff
3868 * (for similarity with the below)
3869 */
3870 that->setMachineState (MachineState_PoweredOff);
3871 break;
3872 case MachineState_Restoring:
3873 /*
3874 * failed to load the saved state file, but be patient:
3875 * set back to Saved (to preserve the saved state file)
3876 */
3877 that->setMachineState (MachineState_Saved);
3878 break;
3879 }
3880
3881 break;
3882 }
3883
3884 case VMSTATE_SUSPENDED:
3885 {
3886 if (aOldState == VMSTATE_RUNNING)
3887 {
3888 AutoLock alock (that);
3889
3890 if (that->mVMStateChangeCallbackDisabled)
3891 break;
3892
3893 /* Change the machine state from Running to Paused */
3894 Assert (that->mMachineState == MachineState_Running);
3895 that->setMachineState (MachineState_Paused);
3896 }
3897 }
3898
3899 case VMSTATE_RUNNING:
3900 {
3901 if (aOldState == VMSTATE_CREATED ||
3902 aOldState == VMSTATE_SUSPENDED)
3903 {
3904 AutoLock alock (that);
3905
3906 if (that->mVMStateChangeCallbackDisabled)
3907 break;
3908
3909 /*
3910 * Change the machine state from Starting, Restoring or Paused
3911 * to Running
3912 */
3913 Assert ((that->mMachineState == MachineState_Starting &&
3914 aOldState == VMSTATE_CREATED) ||
3915 ((that->mMachineState == MachineState_Restoring ||
3916 that->mMachineState == MachineState_Paused) &&
3917 aOldState == VMSTATE_SUSPENDED));
3918
3919 that->setMachineState (MachineState_Running);
3920 }
3921 }
3922
3923 default: /* shut up gcc */
3924 break;
3925 }
3926}
3927
3928/**
3929 * Sends a request to VMM to attach the given host device.
3930 * After this method succeeds, the attached device will appear in the
3931 * mUSBDevices collection.
3932 *
3933 * If \a aManual is true and a failure occures, the given device
3934 * will be returned back to the USB proxy manager.
3935 *
3936 * @param aHostDevice device to attach
3937 * @param aManual true if device is being manually attached
3938 *
3939 * @note Locks this object for writing.
3940 * @note Synchronously calls EMT.
3941 */
3942HRESULT Console::attachUSBDevice (IUSBDevice *aHostDevice, bool aManual,
3943 PVUSBIRHCONFIG aConfig)
3944{
3945 AssertReturn (aHostDevice && aConfig, E_FAIL);
3946
3947 AutoLock alock (this);
3948
3949 HRESULT hrc;
3950
3951 /*
3952 * Get the address and the Uuid, and call the pfnCreateProxyDevice roothub
3953 * method in EMT (using usbAttachCallback()).
3954 */
3955 Bstr BstrAddress;
3956 hrc = aHostDevice->COMGETTER (Address) (BstrAddress.asOutParam());
3957 ComAssertComRCRetRC (hrc);
3958
3959 Utf8Str Address (BstrAddress);
3960
3961 Guid Uuid;
3962 hrc = aHostDevice->COMGETTER (Id) (Uuid.asOutParam());
3963 ComAssertComRCRetRC (hrc);
3964
3965 BOOL fRemote = FALSE;
3966 void *pvRemote = NULL;
3967
3968 hrc = aHostDevice->COMGETTER (Remote) (&fRemote);
3969 ComAssertComRCRetRC (hrc);
3970
3971#ifndef VRDP_MC
3972 if (fRemote)
3973 {
3974 pvRemote = mConsoleVRDPServer->GetUSBBackendPointer ();
3975 ComAssertRet (pvRemote, E_FAIL);
3976 }
3977#endif /* !VRDP_MC */
3978
3979 /* protect mpVM */
3980 AutoVMCaller autoVMCaller (this);
3981 CheckComRCReturnRC (autoVMCaller.rc());
3982
3983 LogFlowThisFunc (("Proxying USB device '%s' {%Vuuid}...\n",
3984 Address.raw(), Uuid.ptr()));
3985
3986 /* leave the lock before a VMR3* call (EMT will call us back)! */
3987 alock.leave();
3988
3989 PVMREQ pReq = NULL;
3990 int vrc = VMR3ReqCall (mpVM, &pReq, RT_INDEFINITE_WAIT,
3991 (PFNRT) usbAttachCallback, 7,
3992 this, aHostDevice,
3993 aConfig, Uuid.ptr(), fRemote, Address.raw(), pvRemote);
3994 if (VBOX_SUCCESS (vrc))
3995 vrc = pReq->iStatus;
3996 VMR3ReqFree (pReq);
3997
3998 /* restore the lock */
3999 alock.enter();
4000
4001 /* hrc is S_OK here */
4002
4003 if (VBOX_FAILURE (vrc))
4004 {
4005 LogWarningThisFunc (("Failed to create proxy device for '%s' {%Vuuid} (%Vrc)\n",
4006 Address.raw(), Uuid.ptr(), vrc));
4007
4008 if (aManual)
4009 {
4010 /*
4011 * Neither SessionMachine::ReleaseUSBDevice() nor Host::releaseUSBDevice()
4012 * should call the Console back, so keep the lock to provide atomicity
4013 * (to protect Host reapplying USB filters)
4014 */
4015 hrc = mControl->ReleaseUSBDevice (Uuid);
4016 AssertComRC (hrc);
4017 }
4018
4019 switch (vrc)
4020 {
4021 case VERR_VUSB_NO_PORTS:
4022 hrc = setError (E_FAIL,
4023 tr ("Failed to attach the USB device. (No available ports on the USB controller)."));
4024 break;
4025 case VERR_VUSB_USBFS_PERMISSION:
4026 hrc = setError (E_FAIL,
4027 tr ("Not permitted to open the USB device, check usbfs options"));
4028 break;
4029 default:
4030 hrc = setError (E_FAIL,
4031 tr ("Failed to create a proxy device for the USB device. (Error: %Vrc)"), vrc);
4032 break;
4033 }
4034 }
4035
4036 return hrc;
4037}
4038
4039/**
4040 * USB device attack callback used by AttachUSBDevice().
4041 * Note that AttachUSBDevice() doesn't return until this callback is executed,
4042 * so we don't use AutoCaller and don't care about reference counters of
4043 * interface pointers passed in.
4044 *
4045 * @thread EMT
4046 * @note Locks the console object for writing.
4047 */
4048//static
4049DECLCALLBACK(int)
4050Console::usbAttachCallback (Console *that, IUSBDevice *aHostDevice,
4051 PVUSBIRHCONFIG aConfig, PCRTUUID aUuid, bool aRemote,
4052 const char *aAddress, void *aRemoteBackend)
4053{
4054 LogFlowFuncEnter();
4055 LogFlowFunc (("that={%p}\n", that));
4056
4057 AssertReturn (that && aConfig && aUuid, VERR_INVALID_PARAMETER);
4058
4059#ifdef VRDP_MC
4060 if (aRemote)
4061 {
4062 /* @todo aRemoteBackend input parameter is not needed. */
4063 Assert (aRemoteBackend == NULL);
4064
4065 RemoteUSBDevice *pRemoteUSBDevice = static_cast <RemoteUSBDevice *> (aHostDevice);
4066
4067 Guid guid (*aUuid);
4068
4069 aRemoteBackend = that->consoleVRDPServer ()->USBBackendRequestPointer (pRemoteUSBDevice->clientId (), &guid);
4070
4071 if (aRemoteBackend == NULL)
4072 {
4073 /* The clientId is invalid then. */
4074 return VERR_INVALID_PARAMETER;
4075 }
4076 }
4077#endif /* VRDP_MC */
4078
4079 int vrc = aConfig->pfnCreateProxyDevice (aConfig, aUuid, aRemote, aAddress,
4080 aRemoteBackend);
4081
4082 if (VBOX_SUCCESS (vrc))
4083 {
4084 /* Create a OUSBDevice and add it to the device list */
4085 ComObjPtr <OUSBDevice> device;
4086 device.createObject();
4087 HRESULT hrc = device->init (aHostDevice);
4088 AssertComRC (hrc);
4089
4090 AutoLock alock (that);
4091 that->mUSBDevices.push_back (device);
4092 LogFlowFunc (("Attached device {%Vuuid}\n", device->id().raw()));
4093 }
4094
4095 LogFlowFunc (("vrc=%Vrc\n", vrc));
4096 LogFlowFuncLeave();
4097 return vrc;
4098}
4099
4100/**
4101 * USB device attack callback used by AttachUSBDevice().
4102 * Note that AttachUSBDevice() doesn't return until this callback is executed,
4103 * so we don't use AutoCaller and don't care about reference counters of
4104 * interface pointers passed in.
4105 *
4106 * @thread EMT
4107 * @note Locks the console object for writing.
4108 */
4109//static
4110DECLCALLBACK(int)
4111Console::usbDetachCallback (Console *that, USBDeviceList::iterator *aIt,
4112 bool aManual, PVUSBIRHCONFIG aConfig, PCRTUUID aUuid)
4113{
4114 LogFlowFuncEnter();
4115 LogFlowFunc (("that={%p}\n", that));
4116
4117 AssertReturn (that && aConfig && aUuid, VERR_INVALID_PARAMETER);
4118
4119#ifdef VRDP_MC
4120 /*
4121 * If that was a remote device, release the backend pointer.
4122 * The pointer was requested in usbAttachCallback.
4123 */
4124 BOOL fRemote = FALSE;
4125
4126 HRESULT hrc2 = (**aIt)->COMGETTER (Remote) (&fRemote);
4127 ComAssertComRC (hrc2);
4128
4129 if (fRemote)
4130 {
4131 Guid guid (*aUuid);
4132 that->consoleVRDPServer ()->USBBackendReleasePointer (&guid);
4133 }
4134#endif /* VRDP_MC */
4135
4136 int vrc = aConfig->pfnDestroyProxyDevice (aConfig, aUuid);
4137
4138 if (VBOX_SUCCESS (vrc))
4139 {
4140 AutoLock alock (that);
4141
4142 /* Remove the device from the collection */
4143 that->mUSBDevices.erase (*aIt);
4144 LogFlowFunc (("Detached device {%Vuuid}\n", (**aIt)->id().raw()));
4145
4146 /// @todo (dmik) REMOTE_USB
4147 // if the device is remote, notify a remote client that we have
4148 // detached the device
4149
4150 /* If it's a manual detach, give it back to the USB Proxy */
4151 if (aManual)
4152 {
4153 /*
4154 * Neither SessionMachine::ReleaseUSBDevice() nor Host::releaseUSBDevice()
4155 * should call the Console back, so keep the lock to provide atomicity
4156 * (to protect Host reapplying USB filters)
4157 */
4158 LogFlowFunc (("Giving it back it to USB proxy...\n"));
4159 HRESULT hrc = that->mControl->ReleaseUSBDevice (Guid (*aUuid));
4160 AssertComRC (hrc);
4161 vrc = SUCCEEDED (hrc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
4162 }
4163 }
4164
4165 LogFlowFunc (("vrc=%Vrc\n", vrc));
4166 LogFlowFuncLeave();
4167 return vrc;
4168}
4169
4170/**
4171 * Construct the VM configuration tree (CFGM).
4172 *
4173 * This is a callback for VMR3Create() call. It is called from CFGMR3Init()
4174 * in the emulation thread (EMT). Any per thread COM/XPCOM initialization
4175 * is done here.
4176 *
4177 * @param pVM VM handle.
4178 * @param pvTask Pointer to the VMPowerUpTask object.
4179 * @return VBox status code.
4180 *
4181 * @note Locks the Console object for writing.
4182 */
4183DECLCALLBACK(int) Console::configConstructor(PVM pVM, void *pvTask)
4184{
4185 LogFlowFuncEnter();
4186
4187 /* Note: the task pointer is owned by powerUpThread() */
4188 VMPowerUpTask *task = static_cast <VMPowerUpTask *> (pvTask);
4189 AssertReturn (task, VERR_GENERAL_FAILURE);
4190
4191#if defined(__WIN__)
4192 {
4193 /* initialize COM */
4194 HRESULT hrc = CoInitializeEx(NULL,
4195 COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE |
4196 COINIT_SPEED_OVER_MEMORY);
4197 LogFlow (("Console::configConstructor(): CoInitializeEx()=%08X\n", hrc));
4198 AssertComRCReturn (hrc, VERR_GENERAL_FAILURE);
4199 }
4200#endif
4201
4202 ComObjPtr <Console> pConsole = task->mConsole;
4203
4204 AutoCaller autoCaller (pConsole);
4205 AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
4206
4207 /* lock the console because we widely use internal fields and methods */
4208 AutoLock alock (pConsole);
4209
4210 ComPtr <IMachine> pMachine = pConsole->machine();
4211
4212 int rc;
4213 HRESULT hrc;
4214 char *psz = NULL;
4215 BSTR str = NULL;
4216 ULONG cRamMBs;
4217 unsigned i;
4218
4219#define STR_CONV() do { rc = RTStrUcs2ToUtf8(&psz, str); RC_CHECK(); } while (0)
4220#define STR_FREE() do { if (str) { SysFreeString(str); str = NULL; } if (psz) { RTStrFree(psz); psz = NULL; } } while (0)
4221#define RC_CHECK() do { if (VBOX_FAILURE(rc)) { AssertMsgFailed(("rc=%Vrc\n", rc)); STR_FREE(); return rc; } } while (0)
4222#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%#x\n", hrc)); STR_FREE(); return VERR_GENERAL_FAILURE; } } while (0)
4223
4224 /* Get necessary objects */
4225
4226 ComPtr<IVirtualBox> virtualBox;
4227 hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
4228
4229 ComPtr<IHost> host;
4230 hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
4231
4232 ComPtr <ISystemProperties> systemProperties;
4233 hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam()); H();
4234
4235 ComPtr<IBIOSSettings> biosSettings;
4236 hrc = pMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam()); H();
4237
4238
4239 /*
4240 * Get root node first.
4241 * This is the only node in the tree.
4242 */
4243 PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
4244 Assert(pRoot);
4245
4246 /*
4247 * Set the root level values.
4248 */
4249 hrc = pMachine->COMGETTER(Name)(&str); H();
4250 STR_CONV();
4251 rc = CFGMR3InsertString(pRoot, "Name", psz); RC_CHECK();
4252 STR_FREE();
4253 hrc = pMachine->COMGETTER(MemorySize)(&cRamMBs); H();
4254 rc = CFGMR3InsertInteger(pRoot, "RamSize", cRamMBs * _1M); RC_CHECK();
4255 rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10); RC_CHECK();
4256 rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 1); /* boolean */ RC_CHECK();
4257 rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 1); /* boolean */ RC_CHECK();
4258 /** @todo Config: RawR0, PATMEnabled and CASMEnabled needs attention later. */
4259 rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 1); /* boolean */ RC_CHECK();
4260 rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 1); /* boolean */ RC_CHECK();
4261
4262 /* hardware virtualization extensions */
4263 TriStateBool_T hwVirtExEnabled;
4264 BOOL fHWVirtExEnabled;
4265 hrc = pMachine->COMGETTER(HWVirtExEnabled)(&hwVirtExEnabled); H();
4266 if (hwVirtExEnabled == TriStateBool_Default)
4267 {
4268 /* check the default value */
4269 hrc = systemProperties->COMGETTER(HWVirtExEnabled)(&fHWVirtExEnabled); H();
4270 }
4271 else
4272 fHWVirtExEnabled = (hwVirtExEnabled == TriStateBool_True);
4273 if (fHWVirtExEnabled)
4274 {
4275 PCFGMNODE pHWVirtExt;
4276 rc = CFGMR3InsertNode(pRoot, "HWVirtExt", &pHWVirtExt); RC_CHECK();
4277 rc = CFGMR3InsertInteger(pHWVirtExt, "Enabled", 1); RC_CHECK();
4278 }
4279
4280 BOOL fIOAPIC;
4281 hrc = biosSettings->COMGETTER(IOAPICEnabled)(&fIOAPIC); H();
4282
4283 /*
4284 * PDM config.
4285 * Load drivers in VBoxC.[so|dll]
4286 */
4287 PCFGMNODE pPDM;
4288 PCFGMNODE pDrivers;
4289 PCFGMNODE pMod;
4290 rc = CFGMR3InsertNode(pRoot, "PDM", &pPDM); RC_CHECK();
4291 rc = CFGMR3InsertNode(pPDM, "Drivers", &pDrivers); RC_CHECK();
4292 rc = CFGMR3InsertNode(pDrivers, "VBoxC", &pMod); RC_CHECK();
4293#ifdef __LINUX__
4294 // VBoxC is located in the components subdirectory
4295 char szPathProgram[RTPATH_MAX + sizeof("/components/VBoxC")];
4296 rc = RTPathProgram(szPathProgram, RTPATH_MAX); AssertRC(rc);
4297 strcat(szPathProgram, "/components/VBoxC");
4298 rc = CFGMR3InsertString(pMod, "Path", szPathProgram); RC_CHECK();
4299#else
4300 rc = CFGMR3InsertString(pMod, "Path", "VBoxC"); RC_CHECK();
4301#endif
4302
4303 /*
4304 * Devices
4305 */
4306 PCFGMNODE pDevices = NULL; /* /Devices */
4307 PCFGMNODE pDev = NULL; /* /Devices/Dev/ */
4308 PCFGMNODE pInst = NULL; /* /Devices/Dev/0/ */
4309 PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
4310 PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
4311 PCFGMNODE pLunL1 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/ */
4312 rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices); RC_CHECK();
4313
4314 /*
4315 * PC Arch.
4316 */
4317 rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev); RC_CHECK();
4318 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4319 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4320 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4321
4322 /*
4323 * PC Bios.
4324 */
4325 rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev); RC_CHECK();
4326 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4327 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4328 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4329 rc = CFGMR3InsertInteger(pCfg, "RamSize", cRamMBs * _1M); RC_CHECK();
4330 rc = CFGMR3InsertString(pCfg, "HardDiskDevice", "piix3ide"); RC_CHECK();
4331 rc = CFGMR3InsertString(pCfg, "FloppyDevice", "i82078"); RC_CHECK();
4332
4333 DeviceType_T bootDevice;
4334 if (SchemaDefs::MaxBootPosition > 9)
4335 {
4336 AssertMsgFailed (("Too many boot devices %d\n",
4337 SchemaDefs::MaxBootPosition));
4338 return VERR_INVALID_PARAMETER;
4339 }
4340
4341 for (ULONG pos = 1; pos <= SchemaDefs::MaxBootPosition; pos ++)
4342 {
4343 hrc = pMachine->GetBootOrder(pos, &bootDevice); H();
4344
4345 char szParamName[] = "BootDeviceX";
4346 szParamName[sizeof (szParamName) - 2] = ((char (pos - 1)) + '0');
4347
4348 const char *pszBootDevice;
4349 switch (bootDevice)
4350 {
4351 case DeviceType_NoDevice:
4352 pszBootDevice = "NONE";
4353 break;
4354 case DeviceType_HardDiskDevice:
4355 pszBootDevice = "IDE";
4356 break;
4357 case DeviceType_DVDDevice:
4358 pszBootDevice = "DVD";
4359 break;
4360 case DeviceType_FloppyDevice:
4361 pszBootDevice = "FLOPPY";
4362 break;
4363 case DeviceType_NetworkDevice:
4364 pszBootDevice = "LAN";
4365 break;
4366 default:
4367 AssertMsgFailed(("Invalid bootDevice=%d\n", bootDevice));
4368 return VERR_INVALID_PARAMETER;
4369 }
4370 rc = CFGMR3InsertString(pCfg, szParamName, pszBootDevice); RC_CHECK();
4371 }
4372
4373 /*
4374 * BIOS logo
4375 */
4376 BOOL fFadeIn;
4377 hrc = biosSettings->COMGETTER(LogoFadeIn)(&fFadeIn); H();
4378 rc = CFGMR3InsertInteger(pCfg, "FadeIn", fFadeIn ? 1 : 0); RC_CHECK();
4379 BOOL fFadeOut;
4380 hrc = biosSettings->COMGETTER(LogoFadeOut)(&fFadeOut); H();
4381 rc = CFGMR3InsertInteger(pCfg, "FadeOut", fFadeOut ? 1: 0); RC_CHECK();
4382 ULONG logoDisplayTime;
4383 hrc = biosSettings->COMGETTER(LogoDisplayTime)(&logoDisplayTime); H();
4384 rc = CFGMR3InsertInteger(pCfg, "LogoTime", logoDisplayTime); RC_CHECK();
4385 Bstr logoImagePath;
4386 hrc = biosSettings->COMGETTER(LogoImagePath)(logoImagePath.asOutParam()); H();
4387 rc = CFGMR3InsertString(pCfg, "LogoFile", logoImagePath ? Utf8Str(logoImagePath) : ""); RC_CHECK();
4388
4389 /*
4390 * Boot menu
4391 */
4392 BIOSBootMenuMode_T bootMenuMode;
4393 int value;
4394 biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
4395 switch (bootMenuMode)
4396 {
4397 case BIOSBootMenuMode_Disabled:
4398 value = 0;
4399 break;
4400 case BIOSBootMenuMode_MenuOnly:
4401 value = 1;
4402 break;
4403 default:
4404 value = 2;
4405 }
4406 rc = CFGMR3InsertInteger(pCfg, "ShowBootMenu", value); RC_CHECK();
4407
4408 /*
4409 * ACPI
4410 */
4411 BOOL fACPI;
4412 hrc = biosSettings->COMGETTER(ACPIEnabled)(&fACPI); H();
4413 if (fACPI)
4414 {
4415 rc = CFGMR3InsertNode(pDevices, "acpi", &pDev); RC_CHECK();
4416 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4417 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4418 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4419 rc = CFGMR3InsertInteger(pCfg, "RamSize", cRamMBs * _1M); RC_CHECK();
4420 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
4421 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 7); RC_CHECK();
4422 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
4423
4424 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
4425 rc = CFGMR3InsertString(pLunL0, "Driver", "ACPIHost"); RC_CHECK();
4426 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4427 }
4428
4429 /*
4430 * DMA
4431 */
4432 rc = CFGMR3InsertNode(pDevices, "8237A", &pDev); RC_CHECK();
4433 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4434 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4435
4436 /*
4437 * PCI bus.
4438 */
4439 rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */ RC_CHECK();
4440 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4441 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4442 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4443 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
4444
4445 /*
4446 * PS/2 keyboard & mouse.
4447 */
4448 rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev); RC_CHECK();
4449 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4450 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4451 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4452
4453 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
4454 rc = CFGMR3InsertString(pLunL0, "Driver", "KeyboardQueue"); RC_CHECK();
4455 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4456 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 64); RC_CHECK();
4457
4458 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
4459 rc = CFGMR3InsertString(pLunL1, "Driver", "MainKeyboard"); RC_CHECK();
4460 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
4461 Keyboard *pKeyboard = pConsole->mKeyboard;
4462 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pKeyboard); RC_CHECK();
4463
4464 rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL0); RC_CHECK();
4465 rc = CFGMR3InsertString(pLunL0, "Driver", "MouseQueue"); RC_CHECK();
4466 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4467 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 128); RC_CHECK();
4468
4469 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
4470 rc = CFGMR3InsertString(pLunL1, "Driver", "MainMouse"); RC_CHECK();
4471 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
4472 Mouse *pMouse = pConsole->mMouse;
4473 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pMouse); RC_CHECK();
4474
4475 /*
4476 * i82078 Floppy drive controller
4477 */
4478 ComPtr<IFloppyDrive> floppyDrive;
4479 hrc = pMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam()); H();
4480 BOOL fFloppyEnabled;
4481 hrc = floppyDrive->COMGETTER(Enabled)(&fFloppyEnabled); H();
4482 if (fFloppyEnabled)
4483 {
4484 rc = CFGMR3InsertNode(pDevices, "i82078", &pDev); RC_CHECK();
4485 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4486 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); RC_CHECK();
4487 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4488 rc = CFGMR3InsertInteger(pCfg, "IRQ", 6); RC_CHECK();
4489 rc = CFGMR3InsertInteger(pCfg, "DMA", 2); RC_CHECK();
4490 rc = CFGMR3InsertInteger(pCfg, "MemMapped", 0 ); RC_CHECK();
4491 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f0); RC_CHECK();
4492
4493 /* Attach the status driver */
4494 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
4495 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
4496 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4497 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapFDLeds[0]); RC_CHECK();
4498 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
4499 rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
4500
4501 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
4502
4503 ComPtr<IFloppyImage> floppyImage;
4504 hrc = floppyDrive->GetImage(floppyImage.asOutParam()); H();
4505 if (floppyImage)
4506 {
4507 pConsole->meFloppyState = DriveState_ImageMounted;
4508 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
4509 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4510 rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); RC_CHECK();
4511 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
4512
4513 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
4514 rc = CFGMR3InsertString(pLunL1, "Driver", "RawImage"); RC_CHECK();
4515 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
4516 hrc = floppyImage->COMGETTER(FilePath)(&str); H();
4517 STR_CONV();
4518 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
4519 STR_FREE();
4520 }
4521 else
4522 {
4523 ComPtr<IHostFloppyDrive> hostFloppyDrive;
4524 hrc = floppyDrive->GetHostDrive(hostFloppyDrive.asOutParam()); H();
4525 if (hostFloppyDrive)
4526 {
4527 pConsole->meFloppyState = DriveState_HostDriveCaptured;
4528 rc = CFGMR3InsertString(pLunL0, "Driver", "HostFloppy"); RC_CHECK();
4529 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4530 hrc = hostFloppyDrive->COMGETTER(Name)(&str); H();
4531 STR_CONV();
4532 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
4533 STR_FREE();
4534 }
4535 else
4536 {
4537 pConsole->meFloppyState = DriveState_NotMounted;
4538 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
4539 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4540 rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); RC_CHECK();
4541 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
4542 }
4543 }
4544 }
4545
4546 /*
4547 * i8254 Programmable Interval Timer And Dummy Speaker
4548 */
4549 rc = CFGMR3InsertNode(pDevices, "i8254", &pDev); RC_CHECK();
4550 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4551 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4552#ifdef DEBUG
4553 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4554#endif
4555
4556 /*
4557 * i8259 Programmable Interrupt Controller.
4558 */
4559 rc = CFGMR3InsertNode(pDevices, "i8259", &pDev); RC_CHECK();
4560 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4561 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4562 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4563
4564 /*
4565 * Advanced Programmable Interrupt Controller.
4566 */
4567 rc = CFGMR3InsertNode(pDevices, "apic", &pDev); RC_CHECK();
4568 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4569 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4570 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4571
4572 if (fIOAPIC)
4573 {
4574 /*
4575 * I/O Advanced Programmable Interrupt Controller.
4576 */
4577 rc = CFGMR3InsertNode(pDevices, "ioapic", &pDev); RC_CHECK();
4578 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4579 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4580 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4581 }
4582
4583 /*
4584 * RTC MC146818.
4585 */
4586 rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev); RC_CHECK();
4587 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4588 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4589
4590#if 0
4591 /*
4592 * Serial ports
4593 */
4594 rc = CFGMR3InsertNode(pDevices, "serial", &pDev); RC_CHECK();
4595 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4596 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4597 rc = CFGMR3InsertInteger(pCfg, "IRQ", 4); RC_CHECK();
4598 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f8); RC_CHECK();
4599
4600 rc = CFGMR3InsertNode(pDev, "1", &pInst); RC_CHECK();
4601 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4602 rc = CFGMR3InsertInteger(pCfg, "IRQ", 3); RC_CHECK();
4603 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x2f8); RC_CHECK();
4604#endif
4605
4606 /*
4607 * VGA.
4608 */
4609 rc = CFGMR3InsertNode(pDevices, "vga", &pDev); RC_CHECK();
4610 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4611 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4612 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 2); RC_CHECK();
4613 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
4614 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4615 hrc = pMachine->COMGETTER(VRAMSize)(&cRamMBs); H();
4616 rc = CFGMR3InsertInteger(pCfg, "VRamSize", cRamMBs * _1M); RC_CHECK();
4617
4618 /* Custom VESA mode list */
4619 unsigned cModes = 0;
4620 for (unsigned iMode = 1; iMode <= 16; iMode++)
4621 {
4622 char szExtraDataKey[sizeof("CustomVideoModeXX")];
4623 RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%d", iMode);
4624 hrc = pMachine->GetExtraData(Bstr(szExtraDataKey), &str); H();
4625 if (!str || !*str)
4626 break;
4627 STR_CONV();
4628 rc = CFGMR3InsertString(pCfg, szExtraDataKey, psz);
4629 STR_FREE();
4630 cModes++;
4631 }
4632 rc = CFGMR3InsertInteger(pCfg, "CustomVideoModes", cModes);
4633
4634 /* VESA height reduction */
4635 ULONG ulHeightReduction;
4636 IFramebuffer *pFramebuffer = pConsole->getDisplay()->getFramebuffer();
4637 hrc = pFramebuffer->COMGETTER(HeightReduction)(&ulHeightReduction); H();
4638 rc = CFGMR3InsertInteger(pCfg, "HeightReduction", ulHeightReduction); RC_CHECK();
4639
4640 /* Attach the display. */
4641 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
4642 rc = CFGMR3InsertString(pLunL0, "Driver", "MainDisplay"); RC_CHECK();
4643 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4644 Display *pDisplay = pConsole->mDisplay;
4645 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pDisplay); RC_CHECK();
4646
4647 /*
4648 * IDE (update this when the main interface changes)
4649 */
4650 rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */ RC_CHECK();
4651 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
4652 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4653 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 1); RC_CHECK();
4654 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 1); RC_CHECK();
4655 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4656
4657 /* Attach the status driver */
4658 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
4659 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
4660 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4661 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapIDELeds[0]);RC_CHECK();
4662 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
4663 rc = CFGMR3InsertInteger(pCfg, "Last", 3); RC_CHECK();
4664
4665 /* Attach the harddisks */
4666 ComPtr<IHardDiskAttachmentCollection> hdaColl;
4667 hrc = pMachine->COMGETTER(HardDiskAttachments)(hdaColl.asOutParam()); H();
4668 ComPtr<IHardDiskAttachmentEnumerator> hdaEnum;
4669 hrc = hdaColl->Enumerate(hdaEnum.asOutParam()); H();
4670
4671 BOOL fMore = FALSE;
4672 while ( SUCCEEDED(hrc = hdaEnum->HasMore(&fMore))
4673 && fMore)
4674 {
4675 ComPtr<IHardDiskAttachment> hda;
4676 hrc = hdaEnum->GetNext(hda.asOutParam()); H();
4677 ComPtr<IHardDisk> hardDisk;
4678 hrc = hda->COMGETTER(HardDisk)(hardDisk.asOutParam()); H();
4679 DiskControllerType_T enmCtl;
4680 hrc = hda->COMGETTER(Controller)(&enmCtl); H();
4681 LONG lDev;
4682 hrc = hda->COMGETTER(DeviceNumber)(&lDev); H();
4683
4684 switch (enmCtl)
4685 {
4686 case DiskControllerType_IDE0Controller:
4687 i = 0;
4688 break;
4689 case DiskControllerType_IDE1Controller:
4690 i = 2;
4691 break;
4692 default:
4693 AssertMsgFailed(("invalid disk controller type: %d\n", enmCtl));
4694 return VERR_GENERAL_FAILURE;
4695 }
4696
4697 if (lDev < 0 || lDev >= 2)
4698 {
4699 AssertMsgFailed(("invalid controller device number: %d\n", lDev));
4700 return VERR_GENERAL_FAILURE;
4701 }
4702
4703 i = i + lDev;
4704
4705 char szLUN[16];
4706 RTStrPrintf(szLUN, sizeof(szLUN), "LUN#%d", i);
4707 rc = CFGMR3InsertNode(pInst, szLUN, &pLunL0); RC_CHECK();
4708 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
4709 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4710 rc = CFGMR3InsertString(pCfg, "Type", "HardDisk"); RC_CHECK();
4711 rc = CFGMR3InsertInteger(pCfg, "Mountable", 0); RC_CHECK();
4712
4713 HardDiskStorageType_T hddType;
4714 hardDisk->COMGETTER(StorageType)(&hddType);
4715 if (hddType == HardDiskStorageType_VirtualDiskImage)
4716 {
4717 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
4718 rc = CFGMR3InsertString(pLunL1, "Driver", "VBoxHDD"); RC_CHECK();
4719 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
4720 /// @todo (dmik) we temporarily use the location property to
4721 // determine the image file name. This is subject to change
4722 // when iSCSI disks are here (we should either query a
4723 // storage-specific interface from IHardDisk, or "standardize"
4724 // the location property)
4725 hrc = hardDisk->COMGETTER(Location)(&str); H();
4726 STR_CONV();
4727 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
4728 STR_FREE();
4729
4730 /* Create an inversed tree of parents. */
4731 ComPtr<IHardDisk> parentHardDisk = hardDisk;
4732 for (PCFGMNODE pParent = pCfg;;)
4733 {
4734 ComPtr<IHardDisk> curHardDisk;
4735 hrc = parentHardDisk->COMGETTER(Parent)(curHardDisk.asOutParam()); H();
4736 if (!curHardDisk)
4737 break;
4738
4739 PCFGMNODE pCur;
4740 rc = CFGMR3InsertNode(pParent, "Parent", &pCur); RC_CHECK();
4741 /// @todo (dmik) we temporarily use the location property to
4742 // determine the image file name. This is subject to change
4743 // when iSCSI disks are here (we should either query a
4744 // storage-specific interface from IHardDisk, or "standardize"
4745 // the location property)
4746 hrc = curHardDisk->COMGETTER(Location)(&str); H();
4747 STR_CONV();
4748 rc = CFGMR3InsertString(pCur, "Path", psz); RC_CHECK();
4749 STR_FREE();
4750
4751 /* next */
4752 pParent = pCur;
4753 parentHardDisk = curHardDisk;
4754 }
4755 }
4756 else if (hddType == HardDiskStorageType_ISCSIHardDisk)
4757 {
4758 ComPtr<IISCSIHardDisk> iSCSIDisk = hardDisk;
4759
4760 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
4761 rc = CFGMR3InsertString(pLunL1, "Driver", "iSCSI"); RC_CHECK();
4762 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
4763
4764 /* Set up the iSCSI initiator driver configuration. */
4765 hrc = iSCSIDisk->COMGETTER(Target)(&str); H();
4766 STR_CONV();
4767 rc = CFGMR3InsertString(pCfg, "TargetName", psz); RC_CHECK();
4768 STR_FREE();
4769
4770 // @todo currently there is no Initiator name config.
4771 rc = CFGMR3InsertString(pCfg, "InitiatorName", "iqn.2006-02.de.innotek.initiator"); RC_CHECK();
4772
4773 ULONG64 lun;
4774 hrc = iSCSIDisk->COMGETTER(Lun)(&lun); H();
4775 rc = CFGMR3InsertInteger(pCfg, "LUN", lun); RC_CHECK();
4776
4777 hrc = iSCSIDisk->COMGETTER(Server)(&str); H();
4778 STR_CONV();
4779 USHORT port;
4780 hrc = iSCSIDisk->COMGETTER(Port)(&port); H();
4781 if (port != 0)
4782 {
4783 char *pszTN;
4784 RTStrAPrintf(&pszTN, "%s:%u", psz, port);
4785 rc = CFGMR3InsertString(pCfg, "TargetAddress", pszTN); RC_CHECK();
4786 RTStrFree(pszTN);
4787 }
4788 else
4789 {
4790 rc = CFGMR3InsertString(pCfg, "TargetAddress", psz); RC_CHECK();
4791 }
4792 STR_FREE();
4793
4794 hrc = iSCSIDisk->COMGETTER(UserName)(&str); H();
4795 if (str)
4796 {
4797 STR_CONV();
4798 rc = CFGMR3InsertString(pCfg, "InitiatorUsername", psz); RC_CHECK();
4799 STR_FREE();
4800 }
4801
4802 hrc = iSCSIDisk->COMGETTER(Password)(&str); H();
4803 if (str)
4804 {
4805 STR_CONV();
4806 rc = CFGMR3InsertString(pCfg, "InitiatorSecret", psz); RC_CHECK();
4807 STR_FREE();
4808 }
4809
4810 // @todo currently there is no target username config.
4811 //rc = CFGMR3InsertString(pCfg, "TargetUsername", ""); RC_CHECK();
4812
4813 // @todo currently there is no target password config.
4814 //rc = CFGMR3InsertString(pCfg, "TargetSecret", ""); RC_CHECK();
4815
4816 /* The iSCSI initiator needs an attached iSCSI transport driver. */
4817 PCFGMNODE pLunL2 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/AttachedDriver */
4818 rc = CFGMR3InsertNode(pLunL1, "AttachedDriver", &pLunL2); RC_CHECK();
4819 rc = CFGMR3InsertString(pLunL2, "Driver", "iSCSITCP"); RC_CHECK();
4820 /* Currently the transport driver has no config options. */
4821 }
4822 else
4823 AssertFailed();
4824 }
4825 H();
4826
4827 ComPtr<IDVDDrive> dvdDrive;
4828 hrc = pMachine->COMGETTER(DVDDrive)(dvdDrive.asOutParam()); H();
4829 if (dvdDrive)
4830 {
4831 // ASSUME: DVD drive is always attached to LUN#2 (i.e. secondary IDE master)
4832 rc = CFGMR3InsertNode(pInst, "LUN#2", &pLunL0); RC_CHECK();
4833 ComPtr<IHostDVDDrive> hostDvdDrive;
4834 hrc = dvdDrive->GetHostDrive(hostDvdDrive.asOutParam()); H();
4835 if (hostDvdDrive)
4836 {
4837 pConsole->meDVDState = DriveState_HostDriveCaptured;
4838 rc = CFGMR3InsertString(pLunL0, "Driver", "HostDVD"); RC_CHECK();
4839 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4840 hrc = hostDvdDrive->COMGETTER(Name)(&str); H();
4841 STR_CONV();
4842 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
4843 STR_FREE();
4844 BOOL fPassthrough;
4845 hrc = dvdDrive->COMGETTER(Passthrough)(&fPassthrough); H();
4846 rc = CFGMR3InsertInteger(pCfg, "Passthrough", !!fPassthrough); RC_CHECK();
4847 }
4848 else
4849 {
4850 pConsole->meDVDState = DriveState_NotMounted;
4851 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
4852 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4853 rc = CFGMR3InsertString(pCfg, "Type", "DVD"); RC_CHECK();
4854 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
4855
4856 ComPtr<IDVDImage> dvdImage;
4857 hrc = dvdDrive->GetImage(dvdImage.asOutParam()); H();
4858 if (dvdImage)
4859 {
4860 pConsole->meDVDState = DriveState_ImageMounted;
4861 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
4862 rc = CFGMR3InsertString(pLunL1, "Driver", "MediaISO"); RC_CHECK();
4863 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
4864 hrc = dvdImage->COMGETTER(FilePath)(&str); H();
4865 STR_CONV();
4866 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
4867 STR_FREE();
4868 }
4869 }
4870 }
4871
4872 /*
4873 * Network adapters
4874 */
4875 rc = CFGMR3InsertNode(pDevices, "pcnet", &pDev); RC_CHECK();
4876 //rc = CFGMR3InsertNode(pDevices, "ne2000", &pDev); RC_CHECK();
4877 for (ULONG ulInstance = 0; ulInstance < SchemaDefs::NetworkAdapterCount; ulInstance++)
4878 {
4879 ComPtr<INetworkAdapter> networkAdapter;
4880 hrc = pMachine->GetNetworkAdapter(ulInstance, networkAdapter.asOutParam()); H();
4881 BOOL fEnabled = FALSE;
4882 hrc = networkAdapter->COMGETTER(Enabled)(&fEnabled); H();
4883 if (!fEnabled)
4884 continue;
4885
4886 char szInstance[4]; Assert(ulInstance <= 999);
4887 RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
4888 rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
4889 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
4890 /* the first network card gets the PCI ID 3, the followings starting from 8 */
4891 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", !ulInstance ? 3 : ulInstance - 1 + 8); RC_CHECK();
4892 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
4893 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
4894
4895 /*
4896 * The virtual hardware type.
4897 */
4898 NetworkAdapterType_T adapterType;
4899 hrc = networkAdapter->COMGETTER(AdapterType)(&adapterType); H();
4900 switch (adapterType)
4901 {
4902 case NetworkAdapterType_NetworkAdapterAm79C970A:
4903 rc = CFGMR3InsertInteger(pCfg, "Am79C973", 0); RC_CHECK();
4904 break;
4905 case NetworkAdapterType_NetworkAdapterAm79C973:
4906 rc = CFGMR3InsertInteger(pCfg, "Am79C973", 1); RC_CHECK();
4907 break;
4908 default:
4909 AssertMsgFailed(("Invalid network adapter type '%d' for slot '%d'",
4910 adapterType, ulInstance));
4911 return VERR_GENERAL_FAILURE;
4912 }
4913
4914 /*
4915 * Get the MAC address and convert it to binary representation
4916 */
4917 Bstr macAddr;
4918 hrc = networkAdapter->COMGETTER(MACAddress)(macAddr.asOutParam()); H();
4919 Assert(macAddr);
4920 Utf8Str macAddrUtf8 = macAddr;
4921 char *macStr = (char*)macAddrUtf8.raw();
4922 Assert(strlen(macStr) == 12);
4923 PDMMAC Mac;
4924 memset(&Mac, 0, sizeof(Mac));
4925 char *pMac = (char*)&Mac;
4926 for (uint32_t i = 0; i < 6; i++)
4927 {
4928 char c1 = *macStr++ - '0';
4929 if (c1 > 9)
4930 c1 -= 7;
4931 char c2 = *macStr++ - '0';
4932 if (c2 > 9)
4933 c2 -= 7;
4934 *pMac++ = ((c1 & 0x0f) << 4) | (c2 & 0x0f);
4935 }
4936 rc = CFGMR3InsertBytes(pCfg, "MAC", &Mac, sizeof(Mac)); RC_CHECK();
4937
4938 /*
4939 * Check if the cable is supposed to be unplugged
4940 */
4941 BOOL fCableConnected;
4942 hrc = networkAdapter->COMGETTER(CableConnected)(&fCableConnected); H();
4943 rc = CFGMR3InsertInteger(pCfg, "CableConnected", fCableConnected ? 1 : 0); RC_CHECK();
4944
4945 /*
4946 * Attach the status driver.
4947 */
4948 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
4949 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
4950 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4951 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapNetworkLeds[ulInstance]); RC_CHECK();
4952
4953 /*
4954 * Enable the packet sniffer if requested.
4955 */
4956 BOOL fSniffer;
4957 hrc = networkAdapter->COMGETTER(TraceEnabled)(&fSniffer); H();
4958 if (fSniffer)
4959 {
4960 /* insert the sniffer filter driver. */
4961 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
4962 rc = CFGMR3InsertString(pLunL0, "Driver", "NetSniffer"); RC_CHECK();
4963 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4964 hrc = networkAdapter->COMGETTER(TraceFile)(&str); H();
4965 if (str) /* check convention for indicating default file. */
4966 {
4967 STR_CONV();
4968 rc = CFGMR3InsertString(pCfg, "File", psz); RC_CHECK();
4969 STR_FREE();
4970 }
4971 }
4972
4973 NetworkAttachmentType_T networkAttachment;
4974 hrc = networkAdapter->COMGETTER(AttachmentType)(&networkAttachment); H();
4975 switch (networkAttachment)
4976 {
4977 case NetworkAttachmentType_NoNetworkAttachment:
4978 break;
4979
4980 case NetworkAttachmentType_NATNetworkAttachment:
4981 {
4982 if (fSniffer)
4983 {
4984 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
4985 }
4986 else
4987 {
4988 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
4989 }
4990 rc = CFGMR3InsertString(pLunL0, "Driver", "NAT"); RC_CHECK();
4991 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
4992 /* (Port forwarding goes here.) */
4993 break;
4994 }
4995
4996 case NetworkAttachmentType_HostInterfaceNetworkAttachment:
4997 {
4998 /*
4999 * Perform the attachment if required (don't return on error!)
5000 */
5001 hrc = pConsole->attachToHostInterface(networkAdapter);
5002 if (SUCCEEDED(hrc))
5003 {
5004#ifdef __LINUX__
5005 Assert (pConsole->maTapFD[ulInstance] >= 0);
5006 if (pConsole->maTapFD[ulInstance] >= 0)
5007 {
5008 if (fSniffer)
5009 {
5010 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
5011 }
5012 else
5013 {
5014 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5015 }
5016 rc = CFGMR3InsertString(pLunL0, "Driver", "HostInterface"); RC_CHECK();
5017 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5018 rc = CFGMR3InsertInteger(pCfg, "FileHandle", pConsole->maTapFD[ulInstance]); RC_CHECK();
5019 }
5020#else /* !__LINUX__ */
5021 if (fSniffer)
5022 {
5023 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
5024 }
5025 else
5026 {
5027 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5028 }
5029 Bstr hostInterfaceName;
5030 hrc = networkAdapter->COMGETTER(HostInterface)(hostInterfaceName.asOutParam()); H();
5031 ComPtr<IHostNetworkInterfaceCollection> coll;
5032 hrc = host->COMGETTER(NetworkInterfaces)(coll.asOutParam()); H();
5033 ComPtr<IHostNetworkInterface> hostInterface;
5034 rc = coll->FindByName(hostInterfaceName, hostInterface.asOutParam());
5035 if (!SUCCEEDED(rc))
5036 {
5037 AssertMsgFailed(("Cannot get GUID for host interface '%ls'\n", hostInterfaceName));
5038 hrc = networkAdapter->Detach(); H();
5039 }
5040 else
5041 {
5042 rc = CFGMR3InsertString(pLunL0, "Driver", "HostInterface"); RC_CHECK();
5043 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5044 rc = CFGMR3InsertString(pCfg, "HostInterfaceName", Utf8Str(hostInterfaceName)); RC_CHECK();
5045 Guid hostIFGuid;
5046 hrc = hostInterface->COMGETTER(Id)(hostIFGuid.asOutParam()); H();
5047 char szDriverGUID[256] = {0};
5048 /* add curly brackets */
5049 szDriverGUID[0] = '{';
5050 strcpy(szDriverGUID + 1, hostIFGuid.toString().raw());
5051 strcat(szDriverGUID, "}");
5052 rc = CFGMR3InsertBytes(pCfg, "GUID", szDriverGUID, sizeof(szDriverGUID)); RC_CHECK();
5053 }
5054#endif /* !__LINUX__ */
5055 }
5056 else
5057 {
5058 switch (hrc)
5059 {
5060#ifdef __LINUX__
5061 case VERR_ACCESS_DENIED:
5062 return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
5063 "Failed to open '/dev/net/tun' for read/write access. Please check the "
5064 "permissions of that node. Either do 'chmod 0666 /dev/net/tun' or "
5065 "change the group of that node and get member of that group. Make "
5066 "sure that these changes are permanently in particular if you are "
5067 "using udev"));
5068#endif /* __LINUX__ */
5069 default:
5070 AssertMsgFailed(("Could not attach to host interface! Bad!\n"));
5071 return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
5072 "Failed to initialize Host Interface Networking"));
5073 }
5074 }
5075 break;
5076 }
5077
5078 case NetworkAttachmentType_InternalNetworkAttachment:
5079 {
5080 hrc = networkAdapter->COMGETTER(InternalNetwork)(&str); H();
5081 STR_CONV();
5082 if (psz && *psz)
5083 {
5084 if (fSniffer)
5085 {
5086 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
5087 }
5088 else
5089 {
5090 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5091 }
5092 rc = CFGMR3InsertString(pLunL0, "Driver", "IntNet"); RC_CHECK();
5093 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5094 rc = CFGMR3InsertString(pCfg, "Network", psz); RC_CHECK();
5095 }
5096 STR_FREE();
5097 break;
5098 }
5099
5100 default:
5101 AssertMsgFailed(("should not get here!\n"));
5102 break;
5103 }
5104 }
5105
5106 /*
5107 * VMM Device
5108 */
5109 rc = CFGMR3InsertNode(pDevices, "VMMDev", &pDev); RC_CHECK();
5110 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
5111 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
5112 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
5113 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 4); RC_CHECK();
5114 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
5115
5116 /* the VMM device's Main driver */
5117 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5118 rc = CFGMR3InsertString(pLunL0, "Driver", "MainVMMDev"); RC_CHECK();
5119 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5120 VMMDev *pVMMDev = pConsole->mVMMDev;
5121 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pVMMDev); RC_CHECK();
5122
5123 /*
5124 * Audio Sniffer Device
5125 */
5126 rc = CFGMR3InsertNode(pDevices, "AudioSniffer", &pDev); RC_CHECK();
5127 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
5128 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
5129
5130 /* the Audio Sniffer device's Main driver */
5131 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5132 rc = CFGMR3InsertString(pLunL0, "Driver", "MainAudioSniffer"); RC_CHECK();
5133 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5134 AudioSniffer *pAudioSniffer = pConsole->mAudioSniffer;
5135 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pAudioSniffer); RC_CHECK();
5136
5137 /*
5138 * AC'97 ICH audio
5139 */
5140 ComPtr<IAudioAdapter> audioAdapter;
5141 hrc = pMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); H();
5142 BOOL enabled = FALSE;
5143 if (audioAdapter)
5144 {
5145 hrc = audioAdapter->COMGETTER(Enabled)(&enabled); H();
5146 }
5147 if (enabled)
5148 {
5149 rc = CFGMR3InsertNode(pDevices, "ichac97", &pDev); /* ichac97 */
5150 rc = CFGMR3InsertNode(pDev, "0", &pInst);
5151 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
5152 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 5); RC_CHECK();
5153 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
5154 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
5155
5156 /* the Audio driver */
5157 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5158 rc = CFGMR3InsertString(pLunL0, "Driver", "AUDIO"); RC_CHECK();
5159 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5160 AudioDriverType_T audioDriver;
5161 hrc = audioAdapter->COMGETTER(AudioDriver)(&audioDriver); H();
5162 switch (audioDriver)
5163 {
5164 case AudioDriverType_NullAudioDriver:
5165 {
5166 rc = CFGMR3InsertString(pCfg, "AudioDriver", "null"); RC_CHECK();
5167 break;
5168 }
5169#ifdef __WIN__
5170 case AudioDriverType_WINMMAudioDriver:
5171 {
5172 rc = CFGMR3InsertString(pCfg, "AudioDriver", "winmm"); RC_CHECK();
5173 break;
5174 }
5175 case AudioDriverType_DSOUNDAudioDriver:
5176 {
5177 rc = CFGMR3InsertString(pCfg, "AudioDriver", "dsound"); RC_CHECK();
5178 break;
5179 }
5180#else /* !__WIN__ */
5181 case AudioDriverType_OSSAudioDriver:
5182 {
5183 rc = CFGMR3InsertString(pCfg, "AudioDriver", "oss"); RC_CHECK();
5184 break;
5185 }
5186#ifdef VBOX_WITH_ALSA
5187 case AudioDriverType_ALSAAudioDriver:
5188 {
5189 rc = CFGMR3InsertString(pCfg, "AudioDriver", "alsa"); RC_CHECK();
5190 break;
5191 }
5192#endif
5193#endif /* !__WIN__ */
5194 }
5195 }
5196
5197 /*
5198 * The USB Controller.
5199 */
5200 ComPtr<IUSBController> USBCtlPtr;
5201 hrc = pMachine->COMGETTER(USBController)(USBCtlPtr.asOutParam());
5202 if (USBCtlPtr)
5203 {
5204 BOOL fEnabled;
5205 hrc = USBCtlPtr->COMGETTER(Enabled)(&fEnabled); H();
5206 if (fEnabled)
5207 {
5208 rc = CFGMR3InsertNode(pDevices, "usb-ohci", &pDev); RC_CHECK();
5209 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
5210 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
5211 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
5212 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 6); RC_CHECK();
5213 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
5214
5215 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
5216 rc = CFGMR3InsertString(pLunL0, "Driver", "VUSBRootHub"); RC_CHECK();
5217 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
5218 }
5219 }
5220
5221 /*
5222 * Clipboard
5223 */
5224 {
5225 ClipboardMode_T mode = ClipboardMode_ClipDisabled;
5226 hrc = pMachine->COMGETTER(ClipboardMode) (&mode); H();
5227
5228 if (mode != ClipboardMode_ClipDisabled)
5229 {
5230 /* Load the service */
5231 rc = pConsole->mVMMDev->hgcmLoadService ("VBoxSharedClipboard", "VBoxSharedClipboard");
5232
5233 if (VBOX_FAILURE (rc))
5234 {
5235 LogRel(("VBoxSharedClipboard is not available. rc = %Vrc\n", rc));
5236 /* That is not a fatal failure. */
5237 rc = VINF_SUCCESS;
5238 }
5239 else
5240 {
5241 /* Setup the service. */
5242 VBOXHGCMSVCPARM parm;
5243
5244 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
5245
5246 switch (mode)
5247 {
5248 default:
5249 case ClipboardMode_ClipDisabled:
5250 {
5251 LogRel(("VBoxSharedClipboard mode: Off\n"));
5252 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
5253 break;
5254 }
5255 case ClipboardMode_ClipGuestToHost:
5256 {
5257 LogRel(("VBoxSharedClipboard mode: Guest to Host\n"));
5258 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
5259 break;
5260 }
5261 case ClipboardMode_ClipHostToGuest:
5262 {
5263 LogRel(("VBoxSharedClipboard mode: Host to Guest\n"));
5264 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
5265 break;
5266 }
5267 case ClipboardMode_ClipBidirectional:
5268 {
5269 LogRel(("VBoxSharedClipboard mode: Bidirectional\n"));
5270 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
5271 break;
5272 }
5273 }
5274
5275 pConsole->mVMMDev->hgcmHostCall ("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
5276
5277 Log(("Set VBoxSharedClipboard mode\n"));
5278 }
5279 }
5280 }
5281
5282 /*
5283 * CFGM overlay handling.
5284 *
5285 * Here we check the extra data entries for CFGM values
5286 * and create the nodes and insert the values on the fly. Existing
5287 * values will be removed and reinserted. If a value is a valid number,
5288 * it will be inserted as a number, otherwise as a string.
5289 *
5290 * We first perform a run on global extra data, then on the machine
5291 * extra data to support global settings with local overrides.
5292 *
5293 */
5294 Bstr strExtraDataKey;
5295 bool fGlobalExtraData = true;
5296 for (;;)
5297 {
5298 Bstr strNextExtraDataKey;
5299 Bstr strExtraDataValue;
5300
5301 /* get the next key */
5302 if (fGlobalExtraData)
5303 hrc = virtualBox->GetNextExtraDataKey(strExtraDataKey, strNextExtraDataKey.asOutParam(),
5304 strExtraDataValue.asOutParam());
5305 else
5306 hrc = pMachine->GetNextExtraDataKey(strExtraDataKey, strNextExtraDataKey.asOutParam(),
5307 strExtraDataValue.asOutParam());
5308
5309 /* stop if for some reason there's nothing more to request */
5310 if (FAILED(hrc) || !strNextExtraDataKey)
5311 {
5312 /* if we're out of global keys, continue with machine, otherwise we're done */
5313 if (fGlobalExtraData)
5314 {
5315 fGlobalExtraData = false;
5316 strExtraDataKey.setNull();
5317 continue;
5318 }
5319 break;
5320 }
5321
5322 strExtraDataKey = strNextExtraDataKey;
5323 Utf8Str strExtraDataKeyUtf8 = Utf8Str(strExtraDataKey);
5324
5325 /* we only care about keys starting with "VBoxInternal/" */
5326 if (strncmp(strExtraDataKeyUtf8.raw(), "VBoxInternal/", 13) != 0)
5327 continue;
5328 char *pszExtraDataKey = (char*)strExtraDataKeyUtf8.raw() + 13;
5329
5330 /* the key will be in the format "Node1/Node2/Value" or simply "Value". */
5331 PCFGMNODE pNode;
5332 char *pszCFGMValueName = strrchr(pszExtraDataKey, '/');
5333 if (pszCFGMValueName)
5334 {
5335 /* terminate the node and advance to the value */
5336 *pszCFGMValueName = '\0';
5337 pszCFGMValueName++;
5338
5339 /* does the node already exist? */
5340 pNode = CFGMR3GetChild(pRoot, pszExtraDataKey);
5341 if (pNode)
5342 {
5343 /* the value might already exist, remove it to be safe */
5344 CFGMR3RemoveValue(pNode, pszCFGMValueName);
5345 }
5346 else
5347 {
5348 /* create the node */
5349 rc = CFGMR3InsertNode(pRoot, pszExtraDataKey, &pNode);
5350 AssertMsgRC(rc, ("failed to insert node '%s'\n", pszExtraDataKey));
5351 if (VBOX_FAILURE(rc) || !pNode)
5352 continue;
5353 }
5354 }
5355 else
5356 {
5357 pNode = pRoot;
5358 pszCFGMValueName = pszExtraDataKey;
5359 pszExtraDataKey--;
5360
5361 /* the value might already exist, remove it to be safe */
5362 CFGMR3RemoveValue(pNode, pszCFGMValueName);
5363 }
5364
5365 /* now let's have a look at the value */
5366 Utf8Str strCFGMValueUtf8 = Utf8Str(strExtraDataValue);
5367 const char *pszCFGMValue = strCFGMValueUtf8.raw();
5368 /* empty value means remove value which we've already done */
5369 if (pszCFGMValue && *pszCFGMValue)
5370 {
5371 /* if it's a valid number, we'll insert it as such, otherwise string */
5372 uint64_t u64Value;
5373 if (RTStrToUInt64Ex(pszCFGMValue, NULL, 0, &u64Value) == VINF_SUCCESS)
5374 {
5375 rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
5376 }
5377 else
5378 {
5379 rc = CFGMR3InsertString(pNode, pszCFGMValueName, pszCFGMValue);
5380 }
5381 AssertMsgRC(rc, ("failed to insert CFGM value '%s' to key '%s'\n", pszCFGMValue, pszExtraDataKey));
5382 }
5383 }
5384
5385#undef H
5386#undef RC_CHECK
5387#undef STR_FREE
5388#undef STR_CONV
5389
5390 /* Register VM state change handler */
5391 int rc2 = VMR3AtStateRegister (pVM, Console::vmstateChangeCallback, pConsole);
5392 AssertRC (rc2);
5393 if (VBOX_SUCCESS (rc))
5394 rc = rc2;
5395
5396 /* Register VM runtime error handler */
5397 rc2 = VMR3AtRuntimeErrorRegister (pVM, Console::setVMRuntimeErrorCallback, pConsole);
5398 AssertRC (rc2);
5399 if (VBOX_SUCCESS (rc))
5400 rc = rc2;
5401
5402 /* Save the VM pointer in the machine object */
5403 pConsole->mpVM = pVM;
5404
5405 LogFlowFunc (("vrc = %Vrc\n", rc));
5406 LogFlowFuncLeave();
5407
5408 return rc;
5409}
5410
5411/**
5412 * Helper function to handle host interface device creation and attachment.
5413 *
5414 * @param networkAdapter the network adapter which attachment should be reset
5415 * @return COM status code
5416 *
5417 * @note The caller must lock this object for writing.
5418 */
5419HRESULT Console::attachToHostInterface(INetworkAdapter *networkAdapter)
5420{
5421 /* sanity check */
5422 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
5423
5424#ifdef DEBUG
5425 /* paranoia */
5426 NetworkAttachmentType_T attachment;
5427 networkAdapter->COMGETTER(AttachmentType)(&attachment);
5428 Assert(attachment == NetworkAttachmentType_HostInterfaceNetworkAttachment);
5429#endif /* DEBUG */
5430
5431 HRESULT rc = S_OK;
5432
5433#ifdef __LINUX__
5434 ULONG slot = 0;
5435 rc = networkAdapter->COMGETTER(Slot)(&slot);
5436 AssertComRC(rc);
5437
5438 /*
5439 * Try get the FD.
5440 */
5441 LONG ltapFD;
5442 rc = networkAdapter->COMGETTER(TAPFileDescriptor)(&ltapFD);
5443 if (SUCCEEDED(rc))
5444 maTapFD[slot] = (RTFILE)ltapFD;
5445 else
5446 maTapFD[slot] = NIL_RTFILE;
5447
5448 /*
5449 * Are we supposed to use an existing TAP interface?
5450 */
5451 if (maTapFD[slot] != NIL_RTFILE)
5452 {
5453 /* nothing to do */
5454 Assert(ltapFD >= 0);
5455 Assert((LONG)maTapFD[slot] == ltapFD);
5456 rc = S_OK;
5457 }
5458 else
5459#endif /* __LINUX */
5460 {
5461 /*
5462 * Allocate a host interface device
5463 */
5464#ifdef __WIN__
5465 /* nothing to do */
5466 int rcVBox = VINF_SUCCESS;
5467#elif defined(__LINUX__)
5468 int rcVBox = RTFileOpen(&maTapFD[slot], "/dev/net/tun",
5469 RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_INHERIT);
5470 if (VBOX_SUCCESS(rcVBox))
5471 {
5472 /*
5473 * Set/obtain the tap interface.
5474 */
5475 struct ifreq IfReq;
5476 memset(&IfReq, 0, sizeof(IfReq));
5477 Bstr tapDeviceName;
5478 rc = networkAdapter->COMGETTER(HostInterface)(tapDeviceName.asOutParam());
5479 if (FAILED(rc) || tapDeviceName.isEmpty())
5480 strcpy(IfReq.ifr_name, "tap%d");
5481 else
5482 {
5483 Utf8Str str(tapDeviceName);
5484 if (str.length() <= sizeof(IfReq.ifr_name))
5485 strcpy(IfReq.ifr_name, str.raw());
5486 else
5487 memcpy(IfReq.ifr_name, str.raw(), sizeof(IfReq.ifr_name) - 1); /** @todo bitch about names which are too long... */
5488 }
5489 IfReq.ifr_flags = IFF_TAP | IFF_NO_PI;
5490 rcVBox = ioctl(maTapFD[slot], TUNSETIFF, &IfReq);
5491 if (!rcVBox)
5492 {
5493 /*
5494 * Make it pollable.
5495 */
5496 if (fcntl(maTapFD[slot], F_SETFL, O_NONBLOCK) != -1)
5497 {
5498 tapDeviceName = IfReq.ifr_name;
5499 if (tapDeviceName)
5500 {
5501 Log(("attachToHostInterface: %RTfile %ls\n", maTapFD[slot], tapDeviceName.raw()));
5502
5503 /*
5504 * Here is the right place to communicate the TAP file descriptor and
5505 * the host interface name to the server if/when it becomes really
5506 * necessary.
5507 */
5508 maTAPDeviceName[slot] = tapDeviceName;
5509 rcVBox = VINF_SUCCESS;
5510 rc = S_OK;
5511 }
5512 else
5513 rcVBox = VERR_NO_MEMORY;
5514 }
5515 else
5516 {
5517 AssertMsgFailed(("Configuration error: Failed to configure /dev/net/tun non blocking. errno=%d\n", errno));
5518 rcVBox = VERR_HOSTIF_BLOCKING;
5519 rc = setError(E_FAIL, "Failed to set /dev/net/tun to non blocking. errno=%d\n", errno);
5520 }
5521 }
5522 else
5523 {
5524 AssertMsgFailed(("Configuration error: Failed to configure /dev/net/tun. errno=%d\n", errno));
5525 rcVBox = VERR_HOSTIF_IOCTL;
5526 rc = setError(E_FAIL, "Failed to configure /dev/net/tun. errno = %d\n", errno);
5527 }
5528 }
5529 else
5530 {
5531 AssertMsgFailed(("Configuration error: Failed to open /dev/net/tun rc=%Vrc\n", rcVBox));
5532 switch (rcVBox)
5533 {
5534 case VERR_ACCESS_DENIED:
5535 /* will be handled by our caller */
5536 LogRel(("HERE\n"));
5537 rc = rcVBox;
5538 break;
5539 default:
5540 rc = setError(E_FAIL, "Failed to open /dev/net/tun rc = %Vrc\n", rcVBox);
5541 break;
5542 }
5543 }
5544#elif
5545#error "Unknown host OS"
5546#endif
5547 /* in case of failure, cleanup. */
5548 if (VBOX_FAILURE(rcVBox) && SUCCEEDED(rc))
5549 {
5550 rc = setError(E_FAIL, tr ("General failure attaching to host interface"));
5551 }
5552 }
5553#ifdef __LINUX__
5554 if (SUCCEEDED(rc))
5555 {
5556 /*
5557 * Call the initialization program.
5558 *
5559 * The initialization program is passed the device name as the first param.
5560 * The second parameter is the decimal value of the file handle of the device
5561 * which it inherits.
5562 */
5563 Bstr tapSetupApplication;
5564 networkAdapter->COMGETTER(TAPSetupApplication)(tapSetupApplication.asOutParam());
5565 if (tapSetupApplication)
5566 {
5567 /*
5568 * Create the argument list.
5569 */
5570 const char *apszArgs[4];
5571 /* 0. The program name. */
5572 Utf8Str tapSetupApp(tapSetupApplication);
5573 apszArgs[0] = tapSetupApp.raw();
5574
5575 /* 1. The file descriptor. */
5576 char szFD[32];
5577 RTStrPrintf(szFD, sizeof(szFD), "%RTfile", maTapFD[slot]);
5578 apszArgs[1] = szFD;
5579
5580 /* 2. The device name (optional). */
5581 apszArgs[2] = maTAPDeviceName[slot].isEmpty() ? NULL : maTAPDeviceName[slot].raw();
5582
5583 /* 3. The end. */
5584 apszArgs[3] = NULL;
5585
5586 /*
5587 * Create the process and wait for it to complete.
5588 */
5589 RTPROCESS Process;
5590 int rcVBox = RTProcCreate(apszArgs[0], &apszArgs[0], NULL, 0, &Process);
5591 if (VBOX_SUCCESS(rcVBox))
5592 {
5593 /* wait for the process to exit */
5594 RTPROCSTATUS ProcStatus;
5595 rcVBox = RTProcWait(Process, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus);
5596 AssertRC(rcVBox);
5597 if (VBOX_SUCCESS(rcVBox))
5598 {
5599 if ( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
5600 && ProcStatus.iStatus == 0)
5601 rcVBox = VINF_SUCCESS;
5602 else
5603 rcVBox = VMSetError(mpVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_("Failed to initialize Host Interface Networking"));
5604 }
5605 }
5606 else
5607 {
5608 AssertMsgFailed(("Configuration error: Failed to start init program \"%s\", rc=%Vra\n", tapSetupApp.raw(), rcVBox));
5609 rc = setError(E_FAIL, "Failed to start init program \"%s\", rc = %Vra\n", tapSetupApp.raw(), rcVBox);
5610 }
5611
5612 /* in case of failure, cleanup. */
5613 if (VBOX_FAILURE(rcVBox) && SUCCEEDED(rc))
5614 {
5615 rc = setError(E_FAIL, tr ("General failure configuring Host Interface Networking"));
5616 }
5617 }
5618 }
5619#endif /* __LINUX__ */
5620 return rc;
5621}
5622
5623/**
5624 * Helper function to handle detachment from a host interface
5625 *
5626 * @param networkAdapter the network adapter which attachment should be reset
5627 * @return COM status code
5628 *
5629 * @note The caller must lock this object for writing.
5630 */
5631HRESULT Console::detachFromHostInterface(INetworkAdapter *networkAdapter)
5632{
5633 /* sanity check */
5634 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
5635
5636 HRESULT rc = S_OK;
5637#ifdef DEBUG
5638 /* paranoia */
5639 NetworkAttachmentType_T attachment;
5640 networkAdapter->COMGETTER(AttachmentType)(&attachment);
5641 Assert(attachment == NetworkAttachmentType_HostInterfaceNetworkAttachment);
5642#endif /* DEBUG */
5643
5644#ifdef __LINUX__
5645
5646 ULONG slot = 0;
5647 rc = networkAdapter->COMGETTER(Slot)(&slot);
5648 AssertComRC(rc);
5649
5650 /* is there an open TAP device? */
5651 if (maTapFD[slot] != NIL_RTFILE)
5652 {
5653 /*
5654 * Execute term command and close the file handle.
5655 */
5656 Bstr tapTerminateApplication;
5657 networkAdapter->COMGETTER(TAPTerminateApplication)(tapTerminateApplication.asOutParam());
5658 if (tapTerminateApplication)
5659 {
5660 /*
5661 * Create the argument list
5662 */
5663 const char *apszArgs[4];
5664 /* 0. The program name. */
5665 Utf8Str tapTermAppUtf8(tapTerminateApplication);
5666 apszArgs[0] = tapTermAppUtf8.raw();
5667
5668 /* 1. The file descriptor. */
5669 char szFD[32];
5670 RTStrPrintf(szFD, sizeof(szFD), "%RTfile", maTapFD[slot]);
5671 apszArgs[1] = szFD;
5672
5673 /* 2. Device name (optional). */
5674 apszArgs[2] = maTAPDeviceName[slot].isEmpty() ? NULL : maTAPDeviceName[slot].raw();
5675
5676 /* 3. The end. */
5677 apszArgs[3] = NULL;
5678
5679 /*
5680 * Create the process and wait for it to complete.
5681 */
5682 RTPROCESS Process;
5683 int rcVBox = RTProcCreate(apszArgs[0], &apszArgs[0], NULL, 0, &Process);
5684 if (VBOX_SUCCESS(rcVBox))
5685 {
5686 /* wait for the process to exit */
5687 RTPROCSTATUS ProcStatus;
5688 rcVBox = RTProcWait(Process, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus);
5689 AssertRC(rcVBox);
5690 /* ignore return code? */
5691 }
5692 else
5693 AssertMsgFailed(("Configuration error: Failed to start terminate program \"%s\", rc=%Vra\n", apszArgs[0], rcVBox)); /** @todo last error candidate. */
5694 if (VBOX_FAILURE(rcVBox))
5695 rc = E_FAIL;
5696 }
5697
5698 /*
5699 * Now we can close the file handle.
5700 */
5701 int rcVBox = RTFileClose(maTapFD[slot]);
5702 AssertRC(rcVBox);
5703 /* the TAP device name and handle are no longer valid */
5704 maTapFD[slot] = NIL_RTFILE;
5705 maTAPDeviceName[slot] = "";
5706 }
5707#endif
5708 return rc;
5709}
5710
5711
5712/**
5713 * Called at power down to terminate host interface networking.
5714 *
5715 * @note The caller must lock this object for writing.
5716 */
5717HRESULT Console::powerDownHostInterfaces()
5718{
5719 LogFlowThisFunc (("\n"));
5720
5721 /* sanity check */
5722 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
5723
5724 /*
5725 * host interface termination handling
5726 */
5727 HRESULT rc;
5728 for (ULONG slot = 0; slot < SchemaDefs::NetworkAdapterCount; slot ++)
5729 {
5730 ComPtr<INetworkAdapter> networkAdapter;
5731 rc = mMachine->GetNetworkAdapter(slot, networkAdapter.asOutParam());
5732 CheckComRCBreakRC (rc);
5733
5734 BOOL enabled = FALSE;
5735 networkAdapter->COMGETTER(Enabled) (&enabled);
5736 if (!enabled)
5737 continue;
5738
5739 NetworkAttachmentType_T attachment;
5740 networkAdapter->COMGETTER(AttachmentType)(&attachment);
5741 if (attachment == NetworkAttachmentType_HostInterfaceNetworkAttachment)
5742 {
5743 HRESULT rc2 = detachFromHostInterface(networkAdapter);
5744 if (FAILED(rc2) && SUCCEEDED(rc))
5745 rc = rc2;
5746 }
5747 }
5748
5749 return rc;
5750}
5751
5752
5753/**
5754 * Process callback handler for VMR3Load and VMR3Save.
5755 *
5756 * @param pVM The VM handle.
5757 * @param uPercent Completetion precentage (0-100).
5758 * @param pvUser Pointer to the VMProgressTask structure.
5759 * @return VINF_SUCCESS.
5760 */
5761/*static*/ DECLCALLBACK (int)
5762Console::stateProgressCallback (PVM pVM, unsigned uPercent, void *pvUser)
5763{
5764 VMProgressTask *task = static_cast <VMProgressTask *> (pvUser);
5765 AssertReturn (task, VERR_INVALID_PARAMETER);
5766
5767 /* update the progress object */
5768 if (task->mProgress)
5769 task->mProgress->notifyProgress (uPercent);
5770
5771 return VINF_SUCCESS;
5772}
5773
5774/**
5775 * VM error callback function. Called by the various VM components.
5776 *
5777 * @param pVM The VM handle. Can be NULL if an error occurred before
5778 * successfully creating a VM.
5779 * @param pvUser Pointer to the VMProgressTask structure.
5780 * @param rc VBox status code.
5781 * @param pszFormat The error message.
5782 * @thread EMT.
5783 */
5784/* static */ DECLCALLBACK (void)
5785Console::setVMErrorCallback (PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL,
5786 const char *pszFormat, va_list args)
5787{
5788 VMProgressTask *task = static_cast <VMProgressTask *> (pvUser);
5789 AssertReturnVoid (task);
5790
5791 /* we ignore RT_SRC_POS_DECL arguments to avoid confusion of end-users */
5792 HRESULT hrc = setError (E_FAIL, tr ("%N.\n"
5793 "VBox status code: %d (%Vrc)"),
5794 tr (pszFormat), &args,
5795 rc, rc);
5796 task->mProgress->notifyComplete (hrc);
5797}
5798
5799/**
5800 * VM runtime error callback function.
5801 * See VMSetRuntimeError for the detailed description of parameters.
5802 *
5803 * @param pVM The VM handle.
5804 * @param pvUser The user argument.
5805 * @param fFatal Whether it is a fatal error or not.
5806 * @param pszErrorID Error ID string.
5807 * @param pszFormat Error message format string.
5808 * @param args Error message arguments.
5809 * @thread EMT.
5810 */
5811/* static */ DECLCALLBACK(void)
5812Console::setVMRuntimeErrorCallback (PVM pVM, void *pvUser, bool fFatal,
5813 const char *pszErrorID,
5814 const char *pszFormat, va_list args)
5815{
5816 LogFlowFuncEnter();
5817
5818 Console *that = static_cast <Console *> (pvUser);
5819 AssertReturnVoid (that);
5820
5821 Utf8Str message = Utf8StrFmt (pszFormat, args);
5822
5823 LogRel (("Console: VM runtime error: fatal=%RTbool, "
5824 "errorID=%s message=\"%s\"\n",
5825 fFatal, pszErrorID, message.raw()));
5826
5827 that->onRuntimeError (BOOL (fFatal), Bstr (pszErrorID), Bstr (message));
5828
5829 LogFlowFuncLeave();
5830}
5831
5832/**
5833 * Captures and attaches USB devices to a newly created VM.
5834 *
5835 * @param pVM The VM handle.
5836 *
5837 * @note The caller must lock this object for writing.
5838 */
5839HRESULT Console::captureUSBDevices (PVM pVM)
5840{
5841 LogFlowThisFunc (("\n"));
5842
5843 /* sanity check */
5844 ComAssertRet (isLockedOnCurrentThread(), E_FAIL);
5845
5846 /*
5847 * If the machine has an USB controller, capture devices and attach
5848 * them to it.
5849 */
5850 PPDMIBASE pBase;
5851 int vrc = PDMR3QueryLun (pVM, "usb-ohci", 0, 0, &pBase);
5852 if (VBOX_SUCCESS (vrc))
5853 {
5854 PVUSBIRHCONFIG pRhConfig = (PVUSBIRHCONFIG) pBase->
5855 pfnQueryInterface (pBase, PDMINTERFACE_VUSB_RH_CONFIG);
5856 ComAssertRet (pRhConfig, E_FAIL);
5857
5858 /*
5859 * Get the list of USB devices that should be captured and attached to
5860 * the newly created machine.
5861 */
5862 ComPtr <IUSBDeviceCollection> coll;
5863 HRESULT hrc = mControl->AutoCaptureUSBDevices (coll.asOutParam());
5864 ComAssertComRCRetRC (hrc);
5865
5866 /*
5867 * Enumerate the devices and attach them.
5868 * Failing to attach an device is currently ignored and the device
5869 * released.
5870 */
5871 ComPtr <IUSBDeviceEnumerator> en;
5872 hrc = coll->Enumerate (en.asOutParam());
5873 ComAssertComRCRetRC (hrc);
5874
5875 BOOL hasMore = FALSE;
5876 while (SUCCEEDED (en->HasMore (&hasMore)) && hasMore)
5877 {
5878 ComPtr <IUSBDevice> hostDevice;
5879 hrc = en->GetNext (hostDevice.asOutParam());
5880 ComAssertComRCRetRC (hrc);
5881 ComAssertRet (!hostDevice.isNull(), E_FAIL);
5882
5883 hrc = attachUSBDevice (hostDevice, true /* aManual */, pRhConfig);
5884
5885 /// @todo (r=dmik) warning reporting subsystem
5886 }
5887 }
5888 else if ( vrc == VERR_PDM_DEVICE_NOT_FOUND
5889 || vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
5890 vrc = VINF_SUCCESS;
5891 else
5892 AssertRC (vrc);
5893
5894 return VBOX_SUCCESS (vrc) ? S_OK : E_FAIL;
5895}
5896
5897
5898/**
5899 * Releases all USB device which is attached to the VM for the
5900 * purpose of clean up and such like.
5901 *
5902 * @note The caller must lock this object for writing.
5903 */
5904void Console::releaseAllUSBDevices (void)
5905{
5906 LogFlowThisFunc (("\n"));
5907
5908 /* sanity check */
5909 AssertReturnVoid (isLockedOnCurrentThread());
5910
5911 mControl->ReleaseAllUSBDevices();
5912 mUSBDevices.clear();
5913}
5914
5915/**
5916 * @note Locks this object for writing.
5917 */
5918#ifdef VRDP_MC
5919void Console::processRemoteUSBDevices (uint32_t u32ClientId, VRDPUSBDEVICEDESC *pDevList, uint32_t cbDevList)
5920#else
5921void Console::processRemoteUSBDevices (VRDPUSBDEVICEDESC *pDevList, uint32_t cbDevList)
5922#endif /* VRDP_MC */
5923{
5924 LogFlowThisFuncEnter();
5925#ifdef VRDP_MC
5926 LogFlowThisFunc (("u32ClientId = %d, pDevList=%p, cbDevList = %d\n", u32ClientId, pDevList, cbDevList));
5927#else
5928 LogFlowThisFunc (("pDevList=%p, cbDevList = %d\n", pDevList, cbDevList));
5929#endif /* VRDP_MC */
5930
5931 AutoCaller autoCaller (this);
5932 if (!autoCaller.isOk())
5933 {
5934 /* Console has been already uninitialized, deny request */
5935 AssertMsgFailed (("Temporary assertion to prove that it happens, "
5936 "please report to dmik\n"));
5937 LogFlowThisFunc (("Console is already uninitialized\n"));
5938 LogFlowThisFuncLeave();
5939 return;
5940 }
5941
5942 AutoLock alock (this);
5943
5944 /*
5945 * Mark all existing remote USB devices as dirty.
5946 */
5947 RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
5948 while (it != mRemoteUSBDevices.end())
5949 {
5950 (*it)->dirty (true);
5951 ++ it;
5952 }
5953
5954 /*
5955 * Process the pDevList and add devices those are not already in the mRemoteUSBDevices list.
5956 */
5957 /** @todo (sunlover) REMOTE_USB Strict validation of the pDevList. */
5958 VRDPUSBDEVICEDESC *e = pDevList;
5959
5960 /* The cbDevList condition must be checked first, because the function can
5961 * receive pDevList = NULL and cbDevList = 0 on client disconnect.
5962 */
5963 while (cbDevList >= 2 && e->oNext)
5964 {
5965 LogFlowThisFunc (("vendor %04X, product %04X, name = %s\n",
5966 e->idVendor, e->idProduct,
5967 e->oProduct? (char *)e + e->oProduct: ""));
5968
5969 bool fNewDevice = true;
5970
5971 it = mRemoteUSBDevices.begin();
5972 while (it != mRemoteUSBDevices.end())
5973 {
5974#ifdef VRDP_MC
5975 if ((*it)->devId () == e->id
5976 && (*it)->clientId () == u32ClientId)
5977#else
5978 if ((*it)->devId () == e->id)
5979#endif /* VRDP_MC */
5980 {
5981 /* The device is already in the list. */
5982 (*it)->dirty (false);
5983 fNewDevice = false;
5984 break;
5985 }
5986
5987 ++ it;
5988 }
5989
5990 if (fNewDevice)
5991 {
5992 LogRel(("Remote USB: ++++ Vendor %04X. Product %04X. Name = [%s].\n",
5993 e->idVendor, e->idProduct, e->oProduct? (char *)e + e->oProduct: ""
5994 ));
5995
5996 /* Create the device object and add the new device to list. */
5997 ComObjPtr <RemoteUSBDevice> device;
5998 device.createObject();
5999#ifdef VRDP_MC
6000 device->init (u32ClientId, e);
6001#else
6002 device->init (e);
6003#endif /* VRDP_MC */
6004
6005 mRemoteUSBDevices.push_back (device);
6006
6007 /* Check if the device is ok for current USB filters. */
6008 BOOL fMatched = FALSE;
6009
6010 HRESULT hrc = mControl->RunUSBDeviceFilters(device, &fMatched);
6011
6012 AssertComRC (hrc);
6013
6014 LogFlowThisFunc (("USB filters return %d\n", fMatched));
6015
6016 if (fMatched)
6017 {
6018 hrc = onUSBDeviceAttach(device);
6019
6020 /// @todo (r=dmik) warning reporting subsystem
6021
6022 if (hrc == S_OK)
6023 {
6024 LogFlowThisFunc (("Device attached\n"));
6025 device->captured (true);
6026 }
6027 }
6028 }
6029
6030 if (cbDevList < e->oNext)
6031 {
6032 LogWarningThisFunc (("cbDevList %d > oNext %d\n",
6033 cbDevList, e->oNext));
6034 break;
6035 }
6036
6037 cbDevList -= e->oNext;
6038
6039 e = (VRDPUSBDEVICEDESC *)((uint8_t *)e + e->oNext);
6040 }
6041
6042 /*
6043 * Remove dirty devices, that is those which are not reported by the server anymore.
6044 */
6045 for (;;)
6046 {
6047 ComObjPtr <RemoteUSBDevice> device;
6048
6049 RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
6050 while (it != mRemoteUSBDevices.end())
6051 {
6052 if ((*it)->dirty ())
6053 {
6054 device = *it;
6055 break;
6056 }
6057
6058 ++ it;
6059 }
6060
6061 if (!device)
6062 {
6063 break;
6064 }
6065
6066 USHORT vendorId = 0;
6067 device->COMGETTER(VendorId) (&vendorId);
6068
6069 USHORT productId = 0;
6070 device->COMGETTER(ProductId) (&productId);
6071
6072 Bstr product;
6073 device->COMGETTER(Product) (product.asOutParam());
6074
6075 LogRel(("Remote USB: ---- Vendor %04X. Product %04X. Name = [%ls].\n",
6076 vendorId, productId, product.raw ()
6077 ));
6078
6079 /* Detach the device from VM. */
6080 if (device->captured ())
6081 {
6082 Guid uuid;
6083 device->COMGETTER (Id) (uuid.asOutParam());
6084 onUSBDeviceDetach (uuid);
6085 }
6086
6087 /* And remove it from the list. */
6088 mRemoteUSBDevices.erase (it);
6089 }
6090
6091 LogFlowThisFuncLeave();
6092}
6093
6094
6095
6096/**
6097 * Thread function which starts the VM (also from saved state) and
6098 * track progress.
6099 *
6100 * @param Thread The thread id.
6101 * @param pvUser Pointer to a VMPowerUpTask structure.
6102 * @return VINF_SUCCESS (ignored).
6103 *
6104 * @note Locks the Console object for writing.
6105 */
6106/*static*/
6107DECLCALLBACK (int) Console::powerUpThread (RTTHREAD Thread, void *pvUser)
6108{
6109 LogFlowFuncEnter();
6110
6111 std::auto_ptr <VMPowerUpTask> task (static_cast <VMPowerUpTask *> (pvUser));
6112 AssertReturn (task.get(), VERR_INVALID_PARAMETER);
6113
6114 AssertReturn (!task->mConsole.isNull(), VERR_INVALID_PARAMETER);
6115 AssertReturn (!task->mProgress.isNull(), VERR_INVALID_PARAMETER);
6116
6117#if defined(__WIN__)
6118 {
6119 /* initialize COM */
6120 HRESULT hrc = CoInitializeEx (NULL,
6121 COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE |
6122 COINIT_SPEED_OVER_MEMORY);
6123 LogFlowFunc (("CoInitializeEx()=%08X\n", hrc));
6124 }
6125#endif
6126
6127 HRESULT hrc = S_OK;
6128 int vrc = VINF_SUCCESS;
6129
6130 ComObjPtr <Console> console = task->mConsole;
6131
6132 /* Note: no need to use addCaller() because VMPowerUpTask does that */
6133
6134 AutoLock alock (console);
6135
6136 /* sanity */
6137 Assert (console->mpVM == NULL);
6138
6139 do
6140 {
6141 /*
6142 * Initialize the release logging facility. In case something
6143 * goes wrong, there will be no release logging. Maybe in the future
6144 * we can add some logic to use different file names in this case.
6145 * Note that the logic must be in sync with Machine::DeleteSettings().
6146 */
6147
6148 Bstr logFolder;
6149 hrc = console->mControl->GetLogFolder (logFolder.asOutParam());
6150 CheckComRCBreakRC (hrc);
6151
6152 Utf8Str logDir = logFolder;
6153
6154 /* make sure the Logs folder exists */
6155 Assert (!logDir.isEmpty());
6156 if (!RTDirExists (logDir))
6157 RTDirCreateFullPath (logDir, 0777);
6158
6159 Utf8Str logFile = Utf8StrFmt ("%s%cVBox.log",
6160 logDir.raw(), RTPATH_DELIMITER);
6161
6162 /*
6163 * Age the old log files
6164 * Rename .2 to .3, .1 to .2 and the last log file to .1
6165 * Overwrite target files in case they exist;
6166 */
6167 for (int i = 2; i >= 0; i--)
6168 {
6169 Utf8Str oldName;
6170 if (i > 0)
6171 oldName = Utf8StrFmt ("%s.%d", logFile.raw(), i);
6172 else
6173 oldName = logFile;
6174 Utf8Str newName = Utf8StrFmt ("%s.%d", logFile.raw(), i + 1);
6175 RTFileRename(oldName.raw(), newName.raw(), RTFILEMOVE_FLAGS_REPLACE);
6176 }
6177
6178 PRTLOGGER loggerRelease;
6179 static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
6180 vrc = RTLogCreate(&loggerRelease, RTLOGFLAGS_PREFIX_TIME_PROG, "all",
6181 "VBOX_RELEASE_LOG", ELEMENTS(s_apszGroups), s_apszGroups,
6182 RTLOGDEST_FILE, logFile.raw());
6183 if (VBOX_SUCCESS(vrc))
6184 {
6185 /* some introductory information */
6186 RTTIMESPEC timeSpec;
6187 char nowUct[64];
6188 RTTimeSpecToString(RTTimeNow(&timeSpec), nowUct, sizeof(nowUct));
6189 RTLogRelLogger(loggerRelease, 0, ~0U,
6190 "VirtualBox %d.%d.%d (%s %s) release log\n"
6191 "Log opened %s\n",
6192 VBOX_VERSION_MAJOR, VBOX_VERSION_MINOR, VBOX_VERSION_BUILD,
6193 __DATE__, __TIME__,
6194 nowUct);
6195
6196 /* register this logger as the release logger */
6197 RTLogRelSetDefaultInstance(loggerRelease);
6198 }
6199 else
6200 {
6201 hrc = setError (E_FAIL,
6202 tr ("Failed to open release log file '%s' (%Vrc)"),
6203 logFile.raw(), vrc);
6204 break;
6205 }
6206
6207#ifdef VBOX_VRDP
6208 if (VBOX_SUCCESS (vrc))
6209 {
6210 /* Create the VRDP server. In case of headless operation, this will
6211 * also create the framebuffer, required at VM creation.
6212 */
6213 ConsoleVRDPServer *server = console->consoleVRDPServer();
6214 Assert (server);
6215 /// @todo (dmik)
6216 // does VRDP server call Console from the other thread?
6217 // Not sure, so leave the lock just in case
6218 alock.leave();
6219 vrc = server->Launch();
6220 alock.enter();
6221 if (VBOX_FAILURE (vrc))
6222 {
6223 Utf8Str errMsg;
6224 switch (vrc)
6225 {
6226 case VERR_NET_ADDRESS_IN_USE:
6227 {
6228 ULONG port = 0;
6229 console->mVRDPServer->COMGETTER(Port) (&port);
6230 errMsg = Utf8StrFmt (tr ("VRDP server port %d is already in use"),
6231 port);
6232 break;
6233 }
6234 default:
6235 errMsg = Utf8StrFmt (tr ("Failed to launch VRDP server (%Vrc)"),
6236 vrc);
6237 }
6238 LogRel (("Failed to launch VRDP server (%Vrc), error message: '%s'\n",
6239 vrc, errMsg.raw()));
6240 hrc = setError (E_FAIL, errMsg);
6241 break;
6242 }
6243 }
6244#endif /* VBOX_VRDP */
6245
6246 /*
6247 * Create the VM
6248 */
6249 PVM pVM;
6250 /*
6251 * leave the lock since EMT will call Console. It's safe because
6252 * mMachineState is either Starting or Restoring state here.
6253 */
6254 alock.leave();
6255
6256 vrc = VMR3Create (task->mSetVMErrorCallback, task.get(),
6257 task->mConfigConstructor, task.get(),
6258 &pVM);
6259
6260 alock.enter();
6261
6262#ifdef VBOX_VRDP
6263 {
6264 /* Enable client connections to the server. */
6265 ConsoleVRDPServer *server = console->consoleVRDPServer();
6266 server->SetCallback ();
6267 }
6268#endif /* VBOX_VRDP */
6269
6270 if (VBOX_SUCCESS (vrc))
6271 {
6272 do
6273 {
6274 /*
6275 * Register our load/save state file handlers
6276 */
6277 vrc = SSMR3RegisterExternal (pVM,
6278 sSSMConsoleUnit, 0 /* iInstance */, sSSMConsoleVer,
6279 0 /* cbGuess */,
6280 NULL, saveStateFileExec, NULL, NULL, loadStateFileExec, NULL,
6281 static_cast <Console *> (console));
6282 AssertRC (vrc);
6283 if (VBOX_FAILURE (vrc))
6284 break;
6285
6286 /*
6287 * Synchronize debugger settings
6288 */
6289 MachineDebugger *machineDebugger = console->getMachineDebugger();
6290 if (machineDebugger)
6291 {
6292 machineDebugger->flushQueuedSettings();
6293 }
6294
6295 if (console->getVMMDev()->getShFlClientId())
6296 {
6297 /// @todo (dmik)
6298 // does the code below call Console from the other thread?
6299 // Not sure, so leave the lock just in case
6300 alock.leave();
6301
6302 /*
6303 * Shared Folders
6304 */
6305 for (std::map <Bstr, ComPtr <ISharedFolder> >::const_iterator
6306 it = task->mSharedFolders.begin();
6307 it != task->mSharedFolders.end();
6308 ++ it)
6309 {
6310 Bstr name = (*it).first;
6311 ComPtr <ISharedFolder> folder = (*it).second;
6312
6313 Bstr hostPath;
6314 hrc = folder->COMGETTER(HostPath) (hostPath.asOutParam());
6315 CheckComRCBreakRC (hrc);
6316
6317 LogFlowFunc (("Adding shared folder '%ls' -> '%ls'\n",
6318 name.raw(), hostPath.raw()));
6319 ComAssertBreak (!name.isEmpty() && !hostPath.isEmpty(),
6320 hrc = E_FAIL);
6321
6322 /** @todo should move this into the shared folder class */
6323 VBOXHGCMSVCPARM parms[2];
6324 SHFLSTRING *pFolderName, *pMapName;
6325 int cbString;
6326
6327 cbString = (hostPath.length() + 1) * sizeof(RTUCS2);
6328 pFolderName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
6329 Assert(pFolderName);
6330 memcpy(pFolderName->String.ucs2, hostPath.raw(), cbString);
6331
6332 pFolderName->u16Size = cbString;
6333 pFolderName->u16Length = cbString - sizeof(RTUCS2);
6334
6335 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
6336 parms[0].u.pointer.addr = pFolderName;
6337 parms[0].u.pointer.size = sizeof(SHFLSTRING) + cbString;
6338
6339 cbString = (name.length() + 1) * sizeof(RTUCS2);
6340 pMapName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
6341 Assert(pMapName);
6342 memcpy(pMapName->String.ucs2, name.raw(), cbString);
6343
6344 pMapName->u16Size = cbString;
6345 pMapName->u16Length = cbString - sizeof(RTUCS2);
6346
6347 parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
6348 parms[1].u.pointer.addr = pMapName;
6349 parms[1].u.pointer.size = sizeof(SHFLSTRING) + cbString;
6350
6351 vrc = console->getVMMDev()->hgcmHostCall("VBoxSharedFolders",
6352 SHFL_FN_ADD_MAPPING, 2, &parms[0]);
6353
6354 RTMemFree(pFolderName);
6355 RTMemFree(pMapName);
6356
6357 if (VBOX_FAILURE (vrc))
6358 {
6359 hrc = setError (E_FAIL,
6360 tr ("Unable to add mapping '%ls' to '%ls' (%Vrc)"),
6361 hostPath.raw(), name.raw(), vrc);
6362 break;
6363 }
6364 }
6365
6366 /* enter the lock again */
6367 alock.enter();
6368
6369 CheckComRCBreakRC (hrc);
6370 }
6371
6372 /*
6373 * Capture USB devices.
6374 */
6375 hrc = console->captureUSBDevices (pVM);
6376 CheckComRCBreakRC (hrc);
6377
6378 /* leave the lock before a lengthy operation */
6379 alock.leave();
6380
6381 /* Load saved state? */
6382 if (!!task->mSavedStateFile)
6383 {
6384 LogFlowFunc (("Restoring saved state from '%s'...\n",
6385 task->mSavedStateFile.raw()));
6386
6387 vrc = VMR3Load (pVM, task->mSavedStateFile,
6388 Console::stateProgressCallback,
6389 static_cast <VMProgressTask *> (task.get()));
6390
6391 /* Start/Resume the VM execution */
6392 if (VBOX_SUCCESS (vrc))
6393 {
6394 vrc = VMR3Resume (pVM);
6395 AssertRC (vrc);
6396 }
6397
6398 /* Power off in case we failed loading or resuming the VM */
6399 if (VBOX_FAILURE (vrc))
6400 {
6401 int vrc2 = VMR3PowerOff (pVM);
6402 AssertRC (vrc2);
6403 }
6404 }
6405 else
6406 {
6407 /* Power on the VM (i.e. start executing) */
6408 vrc = VMR3PowerOn(pVM);
6409 AssertRC (vrc);
6410 }
6411
6412 /* enter the lock again */
6413 alock.enter();
6414 }
6415 while (0);
6416
6417 /* On failure, destroy the VM */
6418 if (FAILED (hrc) || VBOX_FAILURE (vrc))
6419 {
6420 /* preserve the current error info */
6421 ErrorInfo ei;
6422
6423 /*
6424 * powerDown() will call VMR3Destroy() and do all necessary
6425 * cleanup (VRDP, USB devices)
6426 */
6427 HRESULT hrc2 = console->powerDown();
6428 AssertComRC (hrc2);
6429
6430 setError (ei);
6431 }
6432 }
6433 else
6434 {
6435 /*
6436 * If VMR3Create() failed it has released the VM memory.
6437 */
6438 console->mpVM = NULL;
6439 }
6440
6441 if (SUCCEEDED (hrc) && VBOX_FAILURE (vrc))
6442 {
6443 /*
6444 * If VMR3Create() or one of the other calls in this function fail,
6445 * an appropriate error message has been already set. However since
6446 * that happens via a callback, the status code in this function is
6447 * not updated.
6448 */
6449 if (!task->mProgress->completed())
6450 {
6451 /*
6452 * If the COM error info is not yet set but we've got a
6453 * failure, convert the VBox status code into a meaningful
6454 * error message. This becomes unused once all the sources of
6455 * errors set the appropriate error message themselves.
6456 * Note that we don't use VMSetError() below because pVM is
6457 * either invalid or NULL here.
6458 */
6459 AssertMsgFailed (("Missing error message during powerup for "
6460 "status code %Vrc\n", vrc));
6461 hrc = setError (E_FAIL,
6462 tr ("Failed to start VM execution (%Vrc)"), vrc);
6463 }
6464 else
6465 hrc = task->mProgress->resultCode();
6466
6467 Assert (FAILED (hrc));
6468 break;
6469 }
6470 }
6471 while (0);
6472
6473 if (console->mMachineState == MachineState_Starting ||
6474 console->mMachineState == MachineState_Restoring)
6475 {
6476 /*
6477 * We are still in the Starting/Restoring state. This means one of:
6478 * 1) we failed before VMR3Create() was called;
6479 * 2) VMR3Create() failed.
6480 * In both cases, there is no need to call powerDown(), but we still
6481 * need to go back to the PoweredOff/Saved state. Reuse
6482 * vmstateChangeCallback() for that purpose.
6483 */
6484
6485 /* preserve the current error info */
6486 ErrorInfo ei;
6487
6488 Assert (console->mpVM == NULL);
6489 vmstateChangeCallback (NULL, VMSTATE_TERMINATED, VMSTATE_CREATING,
6490 console);
6491 setError (ei);
6492 }
6493
6494 /*
6495 * Evaluate the final result.
6496 * Note that the appropriate mMachineState value is already set by
6497 * vmstateChangeCallback() in all cases.
6498 */
6499
6500 /* leave the lock, don't need it any more */
6501 alock.leave();
6502
6503 if (SUCCEEDED (hrc))
6504 {
6505 /* Notify the progress object of the success */
6506 task->mProgress->notifyComplete (S_OK);
6507 }
6508 else
6509 {
6510 if (!task->mProgress->completed())
6511 {
6512 /* The progress object will fetch the current error info. This
6513 * gets the errors signalled by using setError(). The ones
6514 * signalled via VMSetError() immediately notify the progress
6515 * object that the operation is completed. */
6516 task->mProgress->notifyComplete (hrc);
6517 }
6518
6519 LogRel (("Power up failed (vrc=%Vrc, hrc=0x%08X)\n", vrc, hrc));
6520 }
6521
6522#if defined(__WIN__)
6523 /* uninitialize COM */
6524 CoUninitialize();
6525#endif
6526
6527 LogFlowFuncLeave();
6528
6529 return VINF_SUCCESS;
6530}
6531
6532
6533/**
6534 * Reconfigures a VDI.
6535 *
6536 * @param pVM The VM handle.
6537 * @param hda The harddisk attachment.
6538 * @param phrc Where to store com error - only valid if we return VERR_GENERAL_FAILURE.
6539 * @return VBox status code.
6540 */
6541static DECLCALLBACK(int) reconfigureVDI(PVM pVM, IHardDiskAttachment *hda, HRESULT *phrc)
6542{
6543 LogFlowFunc (("pVM=%p hda=%p phrc=%p\n", pVM, hda, phrc));
6544
6545 int rc;
6546 HRESULT hrc;
6547 char *psz = NULL;
6548 BSTR str = NULL;
6549 *phrc = S_OK;
6550#define STR_CONV() do { rc = RTStrUcs2ToUtf8(&psz, str); RC_CHECK(); } while (0)
6551#define STR_FREE() do { if (str) { SysFreeString(str); str = NULL; } if (psz) { RTStrFree(psz); psz = NULL; } } while (0)
6552#define RC_CHECK() do { if (VBOX_FAILURE(rc)) { AssertMsgFailed(("rc=%Vrc\n", rc)); STR_FREE(); return rc; } } while (0)
6553#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%#x\n", hrc)); STR_FREE(); *phrc = hrc; return VERR_GENERAL_FAILURE; } } while (0)
6554
6555 /*
6556 * Figure out which IDE device this is.
6557 */
6558 ComPtr<IHardDisk> hardDisk;
6559 hrc = hda->COMGETTER(HardDisk)(hardDisk.asOutParam()); H();
6560 DiskControllerType_T enmCtl;
6561 hrc = hda->COMGETTER(Controller)(&enmCtl); H();
6562 LONG lDev;
6563 hrc = hda->COMGETTER(DeviceNumber)(&lDev); H();
6564
6565 int i;
6566 switch (enmCtl)
6567 {
6568 case DiskControllerType_IDE0Controller:
6569 i = 0;
6570 break;
6571 case DiskControllerType_IDE1Controller:
6572 i = 2;
6573 break;
6574 default:
6575 AssertMsgFailed(("invalid disk controller type: %d\n", enmCtl));
6576 return VERR_GENERAL_FAILURE;
6577 }
6578
6579 if (lDev < 0 || lDev >= 2)
6580 {
6581 AssertMsgFailed(("invalid controller device number: %d\n", lDev));
6582 return VERR_GENERAL_FAILURE;
6583 }
6584
6585 i = i + lDev;
6586
6587 /*
6588 * Is there an existing LUN? If not create it.
6589 * We ASSUME that this will NEVER collide with the DVD.
6590 */
6591 PCFGMNODE pCfg;
6592 PCFGMNODE pLunL1 = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/piix3ide/0/LUN#%d/AttachedDriver/", i);
6593 if (!pLunL1)
6594 {
6595 PCFGMNODE pInst = CFGMR3GetChild(CFGMR3GetRoot(pVM), "Devices/piix3ide/0/");
6596 AssertReturn(pInst, VERR_INTERNAL_ERROR);
6597
6598 PCFGMNODE pLunL0;
6599 rc = CFGMR3InsertNodeF(pInst, &pLunL0, "LUN#%d", i); RC_CHECK();
6600 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
6601 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
6602 rc = CFGMR3InsertString(pCfg, "Type", "HardDisk"); RC_CHECK();
6603 rc = CFGMR3InsertInteger(pCfg, "Mountable", 0); RC_CHECK();
6604
6605 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
6606 rc = CFGMR3InsertString(pLunL1, "Driver", "VBoxHDD"); RC_CHECK();
6607 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
6608 }
6609 else
6610 {
6611#ifdef VBOX_STRICT
6612 char *pszDriver;
6613 rc = CFGMR3QueryStringAlloc(pLunL1, "Driver", &pszDriver); RC_CHECK();
6614 Assert(!strcmp(pszDriver, "VBoxHDD"));
6615 MMR3HeapFree(pszDriver);
6616#endif
6617
6618 /*
6619 * Check if things has changed.
6620 */
6621 pCfg = CFGMR3GetChild(pLunL1, "Config");
6622 AssertReturn(pCfg, VERR_INTERNAL_ERROR);
6623
6624 /* the image */
6625 /// @todo (dmik) we temporarily use the location property to
6626 // determine the image file name. This is subject to change
6627 // when iSCSI disks are here (we should either query a
6628 // storage-specific interface from IHardDisk, or "standardize"
6629 // the location property)
6630 hrc = hardDisk->COMGETTER(Location)(&str); H();
6631 STR_CONV();
6632 char *pszPath;
6633 rc = CFGMR3QueryStringAlloc(pCfg, "Path", &pszPath); RC_CHECK();
6634 if (!strcmp(psz, pszPath))
6635 {
6636 /* parent images. */
6637 ComPtr<IHardDisk> parentHardDisk = hardDisk;
6638 for (PCFGMNODE pParent = pCfg;;)
6639 {
6640 MMR3HeapFree(pszPath);
6641 pszPath = NULL;
6642 STR_FREE();
6643
6644 /* get parent */
6645 ComPtr<IHardDisk> curHardDisk;
6646 hrc = parentHardDisk->COMGETTER(Parent)(curHardDisk.asOutParam()); H();
6647 PCFGMNODE pCur;
6648 pCur = CFGMR3GetChild(pParent, "Parent");
6649 if (!pCur && !curHardDisk)
6650 {
6651 /* no change */
6652 LogFlowFunc (("No change!\n"));
6653 return VINF_SUCCESS;
6654 }
6655 if (!pCur || !curHardDisk)
6656 break;
6657
6658 /* compare paths. */
6659 /// @todo (dmik) we temporarily use the location property to
6660 // determine the image file name. This is subject to change
6661 // when iSCSI disks are here (we should either query a
6662 // storage-specific interface from IHardDisk, or "standardize"
6663 // the location property)
6664 hrc = curHardDisk->COMGETTER(Location)(&str); H();
6665 STR_CONV();
6666 rc = CFGMR3QueryStringAlloc(pCfg, "Path", &pszPath); RC_CHECK();
6667 if (strcmp(psz, pszPath))
6668 break;
6669
6670 /* next */
6671 pParent = pCur;
6672 parentHardDisk = curHardDisk;
6673 }
6674
6675 }
6676 else
6677 LogFlowFunc (("LUN#%d: old leaf image '%s'\n", i, pszPath));
6678
6679 MMR3HeapFree(pszPath);
6680 STR_FREE();
6681
6682 /*
6683 * Detach the driver and replace the config node.
6684 */
6685 rc = PDMR3DeviceDetach(pVM, "piix3ide", 0, i); RC_CHECK();
6686 CFGMR3RemoveNode(pCfg);
6687 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
6688 }
6689
6690 /*
6691 * Create the driver configuration.
6692 */
6693 /// @todo (dmik) we temporarily use the location property to
6694 // determine the image file name. This is subject to change
6695 // when iSCSI disks are here (we should either query a
6696 // storage-specific interface from IHardDisk, or "standardize"
6697 // the location property)
6698 hrc = hardDisk->COMGETTER(Location)(&str); H();
6699 STR_CONV();
6700 LogFlowFunc (("LUN#%d: leaf image '%s'\n", i, psz));
6701 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
6702 STR_FREE();
6703 /* Create an inversed tree of parents. */
6704 ComPtr<IHardDisk> parentHardDisk = hardDisk;
6705 for (PCFGMNODE pParent = pCfg;;)
6706 {
6707 ComPtr<IHardDisk> curHardDisk;
6708 hrc = parentHardDisk->COMGETTER(Parent)(curHardDisk.asOutParam()); H();
6709 if (!curHardDisk)
6710 break;
6711
6712 PCFGMNODE pCur;
6713 rc = CFGMR3InsertNode(pParent, "Parent", &pCur); RC_CHECK();
6714 /// @todo (dmik) we temporarily use the location property to
6715 // determine the image file name. This is subject to change
6716 // when iSCSI disks are here (we should either query a
6717 // storage-specific interface from IHardDisk, or "standardize"
6718 // the location property)
6719 hrc = curHardDisk->COMGETTER(Location)(&str); H();
6720 STR_CONV();
6721 rc = CFGMR3InsertString(pCur, "Path", psz); RC_CHECK();
6722 STR_FREE();
6723
6724 /* next */
6725 pParent = pCur;
6726 parentHardDisk = curHardDisk;
6727 }
6728
6729 /*
6730 * Attach the new driver.
6731 */
6732 rc = PDMR3DeviceAttach(pVM, "piix3ide", 0, i, NULL); RC_CHECK();
6733
6734 LogFlowFunc (("Returns success\n"));
6735 return rc;
6736}
6737
6738
6739/**
6740 * Thread for executing the saved state operation.
6741 *
6742 * @param Thread The thread handle.
6743 * @param pvUser Pointer to a VMSaveTask structure.
6744 * @return VINF_SUCCESS (ignored).
6745 *
6746 * @note Locks the Console object for writing.
6747 */
6748/*static*/
6749DECLCALLBACK (int) Console::saveStateThread (RTTHREAD Thread, void *pvUser)
6750{
6751 LogFlowFuncEnter();
6752
6753 std::auto_ptr <VMSaveTask> task (static_cast <VMSaveTask *> (pvUser));
6754 AssertReturn (task.get(), VERR_INVALID_PARAMETER);
6755
6756 Assert (!task->mSavedStateFile.isNull());
6757 Assert (!task->mProgress.isNull());
6758
6759 const ComObjPtr <Console> &that = task->mConsole;
6760
6761 /*
6762 * Note: no need to use addCaller() to protect Console or addVMCaller() to
6763 * protect mpVM because VMSaveTask does that
6764 */
6765
6766 Utf8Str errMsg;
6767 HRESULT rc = S_OK;
6768
6769 if (task->mIsSnapshot)
6770 {
6771 Assert (!task->mServerProgress.isNull());
6772 LogFlowFunc (("Waiting until the server creates differencing VDIs...\n"));
6773
6774 rc = task->mServerProgress->WaitForCompletion (-1);
6775 if (SUCCEEDED (rc))
6776 {
6777 HRESULT result = S_OK;
6778 rc = task->mServerProgress->COMGETTER(ResultCode) (&result);
6779 if (SUCCEEDED (rc))
6780 rc = result;
6781 }
6782 }
6783
6784 if (SUCCEEDED (rc))
6785 {
6786 LogFlowFunc (("Saving the state to '%s'...\n", task->mSavedStateFile.raw()));
6787
6788 int vrc = VMR3Save (that->mpVM, task->mSavedStateFile,
6789 Console::stateProgressCallback,
6790 static_cast <VMProgressTask *> (task.get()));
6791 if (VBOX_FAILURE (vrc))
6792 {
6793 errMsg = Utf8StrFmt (
6794 Console::tr ("Failed to save the machine state to '%s' (%Vrc)"),
6795 task->mSavedStateFile.raw(), vrc);
6796 rc = E_FAIL;
6797 }
6798 }
6799
6800 /* lock the console sonce we're going to access it */
6801 AutoLock thatLock (that);
6802
6803 if (SUCCEEDED (rc))
6804 {
6805 if (task->mIsSnapshot)
6806 do
6807 {
6808 LogFlowFunc (("Reattaching new differencing VDIs...\n"));
6809
6810 ComPtr <IHardDiskAttachmentCollection> hdaColl;
6811 rc = that->mMachine->COMGETTER(HardDiskAttachments) (hdaColl.asOutParam());
6812 if (FAILED (rc))
6813 break;
6814 ComPtr <IHardDiskAttachmentEnumerator> hdaEn;
6815 rc = hdaColl->Enumerate (hdaEn.asOutParam());
6816 if (FAILED (rc))
6817 break;
6818 BOOL more = FALSE;
6819 while (SUCCEEDED (rc = hdaEn->HasMore (&more)) && more)
6820 {
6821 ComPtr <IHardDiskAttachment> hda;
6822 rc = hdaEn->GetNext (hda.asOutParam());
6823 if (FAILED (rc))
6824 break;
6825
6826 PVMREQ pReq;
6827 IHardDiskAttachment *pHda = hda;
6828 /*
6829 * don't leave the lock since reconfigureVDI isn't going to
6830 * access Console.
6831 */
6832 int vrc = VMR3ReqCall (that->mpVM, &pReq, RT_INDEFINITE_WAIT,
6833 (PFNRT)reconfigureVDI, 3, that->mpVM,
6834 pHda, &rc);
6835 if (VBOX_SUCCESS (rc))
6836 rc = pReq->iStatus;
6837 VMR3ReqFree (pReq);
6838 if (FAILED (rc))
6839 break;
6840 if (VBOX_FAILURE (vrc))
6841 {
6842 errMsg = Utf8StrFmt (Console::tr ("%Vrc"), vrc);
6843 rc = E_FAIL;
6844 break;
6845 }
6846 }
6847 }
6848 while (0);
6849 }
6850
6851 /* finalize the procedure regardless of the result */
6852 if (task->mIsSnapshot)
6853 {
6854 /*
6855 * finalize the requested snapshot object.
6856 * This will reset the machine state to the state it had right
6857 * before calling mControl->BeginTakingSnapshot().
6858 */
6859 that->mControl->EndTakingSnapshot (SUCCEEDED (rc));
6860 }
6861 else
6862 {
6863 /*
6864 * finalize the requested save state procedure.
6865 * In case of success, the server will set the machine state to Saved;
6866 * in case of failure it will reset the it to the state it had right
6867 * before calling mControl->BeginSavingState().
6868 */
6869 that->mControl->EndSavingState (SUCCEEDED (rc));
6870 }
6871
6872 /* synchronize the state with the server */
6873 if (task->mIsSnapshot || FAILED (rc))
6874 {
6875 if (task->mLastMachineState == MachineState_Running)
6876 {
6877 /* restore the paused state if appropriate */
6878 that->setMachineStateLocally (MachineState_Paused);
6879 /* restore the running state if appropriate */
6880 that->Resume();
6881 }
6882 else
6883 that->setMachineStateLocally (task->mLastMachineState);
6884 }
6885 else
6886 {
6887 /*
6888 * The machine has been successfully saved, so power it down
6889 * (vmstateChangeCallback() will set state to Saved on success).
6890 * Note: we release the task's VM caller, otherwise it will
6891 * deadlock.
6892 */
6893 task->releaseVMCaller();
6894
6895 rc = that->powerDown();
6896 }
6897
6898 /* notify the progress object about operation completion */
6899 if (SUCCEEDED (rc))
6900 task->mProgress->notifyComplete (S_OK);
6901 else
6902 {
6903 if (!errMsg.isNull())
6904 task->mProgress->notifyComplete (rc,
6905 COM_IIDOF(IConsole), Console::getComponentName(), errMsg);
6906 else
6907 task->mProgress->notifyComplete (rc);
6908 }
6909
6910 LogFlowFuncLeave();
6911 return VINF_SUCCESS;
6912}
6913
6914/**
6915 * Thread for powering down the Console.
6916 *
6917 * @param Thread The thread handle.
6918 * @param pvUser Pointer to the VMTask structure.
6919 * @return VINF_SUCCESS (ignored).
6920 *
6921 * @note Locks the Console object for writing.
6922 */
6923/*static*/
6924DECLCALLBACK (int) Console::powerDownThread (RTTHREAD Thread, void *pvUser)
6925{
6926 LogFlowFuncEnter();
6927
6928 std::auto_ptr <VMTask> task (static_cast <VMTask *> (pvUser));
6929 AssertReturn (task.get(), VERR_INVALID_PARAMETER);
6930
6931 AssertReturn (task->isOk(), VERR_GENERAL_FAILURE);
6932
6933 const ComObjPtr <Console> &that = task->mConsole;
6934
6935 /*
6936 * Note: no need to use addCaller() to protect Console
6937 * because VMTask does that
6938 */
6939
6940 /* release VM caller to let powerDown() proceed */
6941 task->releaseVMCaller();
6942
6943 HRESULT rc = that->powerDown();
6944 AssertComRC (rc);
6945
6946 LogFlowFuncLeave();
6947 return VINF_SUCCESS;
6948}
6949
6950/**
6951 * The Main status driver instance data.
6952 */
6953typedef struct DRVMAINSTATUS
6954{
6955 /** The LED connectors. */
6956 PDMILEDCONNECTORS ILedConnectors;
6957 /** Pointer to the LED ports interface above us. */
6958 PPDMILEDPORTS pLedPorts;
6959 /** Pointer to the array of LED pointers. */
6960 PPDMLED *papLeds;
6961 /** The unit number corresponding to the first entry in the LED array. */
6962 RTUINT iFirstLUN;
6963 /** The unit number corresponding to the last entry in the LED array.
6964 * (The size of the LED array is iLastLUN - iFirstLUN + 1.) */
6965 RTUINT iLastLUN;
6966} DRVMAINSTATUS, *PDRVMAINSTATUS;
6967
6968
6969/**
6970 * Notification about a unit which have been changed.
6971 *
6972 * The driver must discard any pointers to data owned by
6973 * the unit and requery it.
6974 *
6975 * @param pInterface Pointer to the interface structure containing the called function pointer.
6976 * @param iLUN The unit number.
6977 */
6978DECLCALLBACK(void) Console::drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN)
6979{
6980 PDRVMAINSTATUS pData = (PDRVMAINSTATUS)(void *)pInterface;
6981 if (iLUN >= pData->iFirstLUN && iLUN <= pData->iLastLUN)
6982 {
6983 PPDMLED pLed;
6984 int rc = pData->pLedPorts->pfnQueryStatusLed(pData->pLedPorts, iLUN, &pLed);
6985 if (VBOX_FAILURE(rc))
6986 pLed = NULL;
6987 ASMAtomicXchgPtr((void * volatile *)&pData->papLeds[iLUN - pData->iFirstLUN], pLed);
6988 Log(("drvStatus_UnitChanged: iLUN=%d pLed=%p\n", iLUN, pLed));
6989 }
6990}
6991
6992
6993/**
6994 * Queries an interface to the driver.
6995 *
6996 * @returns Pointer to interface.
6997 * @returns NULL if the interface was not supported by the driver.
6998 * @param pInterface Pointer to this interface structure.
6999 * @param enmInterface The requested interface identification.
7000 */
7001DECLCALLBACK(void *) Console::drvStatus_QueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
7002{
7003 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
7004 PDRVMAINSTATUS pDrv = PDMINS2DATA(pDrvIns, PDRVMAINSTATUS);
7005 switch (enmInterface)
7006 {
7007 case PDMINTERFACE_BASE:
7008 return &pDrvIns->IBase;
7009 case PDMINTERFACE_LED_CONNECTORS:
7010 return &pDrv->ILedConnectors;
7011 default:
7012 return NULL;
7013 }
7014}
7015
7016
7017/**
7018 * Destruct a status driver instance.
7019 *
7020 * @returns VBox status.
7021 * @param pDrvIns The driver instance data.
7022 */
7023DECLCALLBACK(void) Console::drvStatus_Destruct(PPDMDRVINS pDrvIns)
7024{
7025 PDRVMAINSTATUS pData = PDMINS2DATA(pDrvIns, PDRVMAINSTATUS);
7026 LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
7027 if (pData->papLeds)
7028 {
7029 unsigned iLed = pData->iLastLUN - pData->iFirstLUN + 1;
7030 while (iLed-- > 0)
7031 ASMAtomicXchgPtr((void * volatile *)&pData->papLeds[iLed], NULL);
7032 }
7033}
7034
7035
7036/**
7037 * Construct a status driver instance.
7038 *
7039 * @returns VBox status.
7040 * @param pDrvIns The driver instance data.
7041 * If the registration structure is needed, pDrvIns->pDrvReg points to it.
7042 * @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
7043 * of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
7044 * iInstance it's expected to be used a bit in this function.
7045 */
7046DECLCALLBACK(int) Console::drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
7047{
7048 PDRVMAINSTATUS pData = PDMINS2DATA(pDrvIns, PDRVMAINSTATUS);
7049 LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
7050
7051 /*
7052 * Validate configuration.
7053 */
7054 if (!CFGMR3AreValuesValid(pCfgHandle, "papLeds\0First\0Last\0"))
7055 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
7056 PPDMIBASE pBaseIgnore;
7057 int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBaseIgnore);
7058 if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
7059 {
7060 AssertMsgFailed(("Configuration error: Not possible to attach anything to this driver!\n"));
7061 return VERR_PDM_DRVINS_NO_ATTACH;
7062 }
7063
7064 /*
7065 * Data.
7066 */
7067 pDrvIns->IBase.pfnQueryInterface = Console::drvStatus_QueryInterface;
7068 pData->ILedConnectors.pfnUnitChanged = Console::drvStatus_UnitChanged;
7069
7070 /*
7071 * Read config.
7072 */
7073 rc = CFGMR3QueryPtr(pCfgHandle, "papLeds", (void **)&pData->papLeds);
7074 if (VBOX_FAILURE(rc))
7075 {
7076 AssertMsgFailed(("Configuration error: Failed to query the \"papLeds\" value! rc=%Vrc\n", rc));
7077 return rc;
7078 }
7079
7080 rc = CFGMR3QueryU32(pCfgHandle, "First", &pData->iFirstLUN);
7081 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
7082 pData->iFirstLUN = 0;
7083 else if (VBOX_FAILURE(rc))
7084 {
7085 AssertMsgFailed(("Configuration error: Failed to query the \"First\" value! rc=%Vrc\n", rc));
7086 return rc;
7087 }
7088
7089 rc = CFGMR3QueryU32(pCfgHandle, "Last", &pData->iLastLUN);
7090 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
7091 pData->iLastLUN = 0;
7092 else if (VBOX_FAILURE(rc))
7093 {
7094 AssertMsgFailed(("Configuration error: Failed to query the \"Last\" value! rc=%Vrc\n", rc));
7095 return rc;
7096 }
7097 if (pData->iFirstLUN > pData->iLastLUN)
7098 {
7099 AssertMsgFailed(("Configuration error: Invalid unit range %u-%u\n", pData->iFirstLUN, pData->iLastLUN));
7100 return VERR_GENERAL_FAILURE;
7101 }
7102
7103 /*
7104 * Get the ILedPorts interface of the above driver/device and
7105 * query the LEDs we want.
7106 */
7107 pData->pLedPorts = (PPDMILEDPORTS)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_LED_PORTS);
7108 if (!pData->pLedPorts)
7109 {
7110 AssertMsgFailed(("Configuration error: No led ports interface above!\n"));
7111 return VERR_PDM_MISSING_INTERFACE_ABOVE;
7112 }
7113
7114 for (unsigned i = pData->iFirstLUN; i <= pData->iLastLUN; i++)
7115 Console::drvStatus_UnitChanged(&pData->ILedConnectors, i);
7116
7117 return VINF_SUCCESS;
7118}
7119
7120
7121/**
7122 * Keyboard driver registration record.
7123 */
7124const PDMDRVREG Console::DrvStatusReg =
7125{
7126 /* u32Version */
7127 PDM_DRVREG_VERSION,
7128 /* szDriverName */
7129 "MainStatus",
7130 /* pszDescription */
7131 "Main status driver (Main as in the API).",
7132 /* fFlags */
7133 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
7134 /* fClass. */
7135 PDM_DRVREG_CLASS_STATUS,
7136 /* cMaxInstances */
7137 ~0,
7138 /* cbInstance */
7139 sizeof(DRVMAINSTATUS),
7140 /* pfnConstruct */
7141 Console::drvStatus_Construct,
7142 /* pfnDestruct */
7143 Console::drvStatus_Destruct,
7144 /* pfnIOCtl */
7145 NULL,
7146 /* pfnPowerOn */
7147 NULL,
7148 /* pfnReset */
7149 NULL,
7150 /* pfnSuspend */
7151 NULL,
7152 /* pfnResume */
7153 NULL,
7154 /* pfnDetach */
7155 NULL
7156};
7157
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