VirtualBox

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

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

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