VirtualBox

source: vbox/trunk/src/VBox/Main/include/ConsoleImpl.h

Last change on this file was 104286, checked in by vboxsync, 4 weeks ago

IPRT/log,Main: Open the parent directory of the log file on Windows before we opening the log file and do any log rotating to prevent reparse hacks. bugref:10632
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 58.4 KB
Line 
1/* $Id: ConsoleImpl.h 104286 2024-04-11 01:56:27Z vboxsync $ */
2/** @file
3 * VBox Console COM Class definition
4 */
5
6/*
7 * Copyright (C) 2005-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#ifndef MAIN_INCLUDED_ConsoleImpl_h
29#define MAIN_INCLUDED_ConsoleImpl_h
30#ifndef RT_WITHOUT_PRAGMA_ONCE
31# pragma once
32#endif
33
34#include <iprt/cpp/exception.h>
35
36#include "VirtualBoxBase.h"
37#include "VBox/com/array.h"
38#include "EventImpl.h"
39#include "SecretKeyStore.h"
40#include "ConsoleWrap.h"
41#ifdef VBOX_WITH_RECORDING
42# include "Recording.h"
43#endif
44#ifdef VBOX_WITH_CLOUD_NET
45#include "CloudGateway.h"
46#endif /* VBOX_WITH_CLOUD_NET */
47
48class Guest;
49class Keyboard;
50class Mouse;
51class Display;
52class MachineDebugger;
53class TeleporterStateSrc;
54class OUSBDevice;
55class RemoteUSBDevice;
56class ConsoleSharedFolder;
57class VRDEServerInfo;
58class EmulatedUSB;
59class AudioVRDE;
60#ifdef VBOX_WITH_AUDIO_RECORDING
61class AudioVideoRec;
62#endif
63#ifdef VBOX_WITH_USB_CARDREADER
64class UsbCardReader;
65#endif
66class ConsoleVRDPServer;
67class VMMDev;
68class Progress;
69class BusAssignmentManager;
70COM_STRUCT_OR_CLASS(IEventListener);
71#ifdef VBOX_WITH_EXTPACK
72class ExtPackManager;
73#endif
74class VMMDevMouseInterface;
75class DisplayMouseInterface;
76class VMPowerUpTask;
77class VMPowerDownTask;
78class NvramStore;
79#ifdef VBOX_WITH_VIRT_ARMV8
80class ResourceStore;
81#endif
82
83#include <iprt/uuid.h>
84#include <iprt/log.h>
85#include <iprt/memsafer.h>
86#include <VBox/RemoteDesktop/VRDE.h>
87#include <VBox/vmm/pdmdrv.h>
88#ifdef VBOX_WITH_GUEST_PROPS
89# include <VBox/HostServices/GuestPropertySvc.h> /* For the property notification callback */
90#endif
91#ifdef VBOX_WITH_USB
92# include <VBox/vrdpusb.h>
93#endif
94#include <VBox/VBoxCryptoIf.h>
95#include <VBox/pci.h>
96
97#if defined(VBOX_WITH_GUEST_PROPS) || defined(VBOX_WITH_SHARED_CLIPBOARD) \
98 || defined(VBOX_WITH_DRAG_AND_DROP)
99# include "HGCM.h" /** @todo It should be possible to register a service
100 * extension using a VMMDev callback. */
101#endif
102
103struct VUSBIRHCONFIG;
104typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
105
106#include <list>
107#include <vector>
108
109// defines
110///////////////////////////////////////////////////////////////////////////////
111
112/**
113 * Checks the availability of the underlying VM device driver corresponding
114 * to the COM interface (IKeyboard, IMouse, IDisplay, etc.). When the driver is
115 * not available (NULL), sets error info and returns returns E_ACCESSDENIED.
116 * The translatable error message is defined in null context.
117 *
118 * Intended to used only within Console children (i.e. Keyboard, Mouse,
119 * Display, etc.).
120 *
121 * @param drv driver pointer to check (compare it with NULL)
122 */
123#define CHECK_CONSOLE_DRV(drv) \
124 do { \
125 if (!!(drv)) {} \
126 else return setError(E_ACCESSDENIED, Console::tr("The console is not powered up (%Rfn)"), __FUNCTION__); \
127 } while (0)
128
129// Console
130///////////////////////////////////////////////////////////////////////////////
131
132/**
133 * Simple class for storing network boot information.
134 */
135struct BootNic
136{
137 ULONG mInstance;
138 PCIBusAddress mPCIAddress;
139
140 ULONG mBootPrio;
141 bool operator < (const BootNic &rhs) const
142 {
143 ULONG lval = mBootPrio - 1; /* 0 will wrap around and get the lowest priority. */
144 ULONG rval = rhs.mBootPrio - 1;
145 return lval < rval; /* Zero compares as highest number (lowest prio). */
146 }
147};
148
149class ConsoleMouseInterface
150{
151public:
152 virtual ~ConsoleMouseInterface() { }
153 virtual VMMDevMouseInterface *i_getVMMDevMouseInterface(){return NULL;}
154 virtual DisplayMouseInterface *i_getDisplayMouseInterface(){return NULL;}
155 virtual void i_onMouseCapabilityChange(BOOL supportsAbsolute,
156 BOOL supportsRelative,
157 BOOL supportsTouchScreen,
158 BOOL supportsTouchPad,
159 BOOL needsHostCursor)
160 {
161 RT_NOREF(supportsAbsolute, supportsRelative, supportsTouchScreen, supportsTouchPad, needsHostCursor);
162 }
163};
164
165/** IConsole implementation class */
166class ATL_NO_VTABLE Console :
167 public ConsoleWrap,
168 public ConsoleMouseInterface
169{
170
171public:
172
173 DECLARE_COMMON_CLASS_METHODS(Console)
174
175 HRESULT FinalConstruct();
176 void FinalRelease();
177
178 // public initializers/uninitializers for internal purposes only
179 HRESULT initWithMachine(IMachine *aMachine, IInternalMachineControl *aControl, LockType_T aLockType);
180 void uninit();
181
182
183 // public methods for internal purposes only
184
185 /*
186 * Note: the following methods do not increase refcount. intended to be
187 * called only by the VM execution thread.
188 */
189
190 PCVMMR3VTABLE i_getVMMVTable() const RT_NOEXCEPT { return mpVMM; }
191 Guest *i_getGuest() const { return mGuest; }
192 Keyboard *i_getKeyboard() const { return mKeyboard; }
193 Mouse *i_getMouse() const { return mMouse; }
194 Display *i_getDisplay() const { return mDisplay; }
195 MachineDebugger *i_getMachineDebugger() const { return mDebugger; }
196#ifdef VBOX_WITH_AUDIO_VRDE
197 AudioVRDE *i_getAudioVRDE() const { return mAudioVRDE; }
198#endif
199#ifdef VBOX_WITH_RECORDING
200 int i_recordingCreate(void);
201 void i_recordingDestroy(void);
202 int i_recordingEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock);
203 int i_recordingGetSettings(settings::RecordingSettings &recording);
204 int i_recordingStart(util::AutoWriteLock *pAutoLock = NULL);
205 int i_recordingStop(util::AutoWriteLock *pAutoLock = NULL);
206# ifdef VBOX_WITH_AUDIO_RECORDING
207 AudioVideoRec *i_recordingGetAudioDrv(void) const { return mRecording.mAudioRec; }
208# endif
209 RecordingContext *i_recordingGetContext(void) { return &mRecording.mCtx; }
210# ifdef VBOX_WITH_AUDIO_RECORDING
211 HRESULT i_recordingSendAudio(const void *pvData, size_t cbData, uint64_t uDurationMs);
212# endif
213#endif
214
215 const ComPtr<IMachine> &i_machine() const { return mMachine; }
216 const Bstr &i_getId() const { return mstrUuid; }
217
218 bool i_useHostClipboard() { return mfUseHostClipboard; }
219
220 /** Method is called only from ConsoleVRDPServer */
221 IVRDEServer *i_getVRDEServer() const { return mVRDEServer; }
222
223 ConsoleVRDPServer *i_consoleVRDPServer() const { return mConsoleVRDPServer; }
224
225 HRESULT i_updateMachineState(MachineState_T aMachineState);
226 HRESULT i_getNominalState(MachineState_T &aNominalState);
227 Utf8Str i_getAudioAdapterDeviceName(IAudioAdapter *aAudioAdapter);
228
229 // events from IInternalSessionControl
230 HRESULT i_onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter);
231 HRESULT i_onAudioAdapterChange(IAudioAdapter *aAudioAdapter);
232 HRESULT i_onHostAudioDeviceChange(IHostAudioDevice *aDevice, BOOL aNew, AudioDeviceState_T aState,
233 IVirtualBoxErrorInfo *aErrInfo);
234 HRESULT i_onSerialPortChange(ISerialPort *aSerialPort);
235 HRESULT i_onParallelPortChange(IParallelPort *aParallelPort);
236 HRESULT i_onStorageControllerChange(const com::Guid& aMachineId, const com::Utf8Str& aControllerName);
237 HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
238 HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
239 HRESULT i_onCPUExecutionCapChange(ULONG aExecutionCap);
240 HRESULT i_onClipboardError(const Utf8Str &aId, const Utf8Str &aErrMsg, LONG aRc);
241 HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
242 HRESULT i_onClipboardFileTransferModeChange(bool aEnabled);
243 HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
244 HRESULT i_onVRDEServerChange(BOOL aRestart);
245 HRESULT i_onRecordingChange(BOOL fEnable);
246 HRESULT i_onUSBControllerChange();
247 HRESULT i_onSharedFolderChange(BOOL aGlobal);
248 HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs,
249 const Utf8Str &aCaptureFilename);
250 HRESULT i_onUSBDeviceDetach(IN_BSTR aId, IVirtualBoxErrorInfo *aError);
251 HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
252 HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
253 HRESULT i_onExtraDataChange(const Bstr &aMachineId, const Bstr &aKey, const Bstr &aVal);
254 HRESULT i_onGuestDebugControlChange(IGuestDebugControl *aGuestDebugControl);
255
256 HRESULT i_getGuestProperty(const Utf8Str &aName, Utf8Str *aValue, LONG64 *aTimestamp, Utf8Str *aFlags);
257 HRESULT i_setGuestProperty(const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);
258 HRESULT i_deleteGuestProperty(const Utf8Str &aName);
259 HRESULT i_enumerateGuestProperties(const Utf8Str &aPatterns,
260 std::vector<Utf8Str> &aNames,
261 std::vector<Utf8Str> &aValues,
262 std::vector<LONG64> &aTimestamps,
263 std::vector<Utf8Str> &aFlags);
264 HRESULT i_onlineMergeMedium(IMediumAttachment *aMediumAttachment,
265 ULONG aSourceIdx, ULONG aTargetIdx,
266 IProgress *aProgress);
267 HRESULT i_reconfigureMediumAttachments(const std::vector<ComPtr<IMediumAttachment> > &aAttachments);
268 HRESULT i_onVMProcessPriorityChange(VMProcPriority_T priority);
269 int i_hgcmLoadService(const char *pszServiceLibrary, const char *pszServiceName);
270 VMMDev *i_getVMMDev() { return m_pVMMDev; }
271
272#ifdef VBOX_WITH_EXTPACK
273 ExtPackManager *i_getExtPackManager();
274#endif
275 EventSource *i_getEventSource() { return mEventSource; }
276#ifdef VBOX_WITH_USB_CARDREADER
277 UsbCardReader *i_getUsbCardReader() { return mUsbCardReader; }
278#endif
279
280 int i_VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain);
281 void i_VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus);
282 void i_VRDPClientConnect(uint32_t u32ClientId);
283 void i_VRDPClientDisconnect(uint32_t u32ClientId, uint32_t fu32Intercepted);
284 void i_VRDPInterceptAudio(uint32_t u32ClientId);
285 void i_VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept);
286 void i_VRDPInterceptClipboard(uint32_t u32ClientId);
287
288 void i_processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt);
289 void i_reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
290 ULONG aCpuKernel, ULONG aCpuIdle,
291 ULONG aMemTotal, ULONG aMemFree,
292 ULONG aMemBalloon, ULONG aMemShared,
293 ULONG aMemCache, ULONG aPageTotal,
294 ULONG aAllocVMM, ULONG aFreeVMM,
295 ULONG aBalloonedVMM, ULONG aSharedVMM,
296 ULONG aVmNetRx, ULONG aVmNetTx)
297 {
298 mControl->ReportVmStatistics(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
299 aMemTotal, aMemFree, aMemBalloon, aMemShared,
300 aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
301 aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
302 }
303 void i_enableVMMStatistics(BOOL aEnable);
304
305 HRESULT i_pause(Reason_T aReason);
306 HRESULT i_resume(Reason_T aReason, AutoWriteLock &alock);
307 HRESULT i_saveState(Reason_T aReason, const ComPtr<IProgress> &aProgress,
308 const ComPtr<ISnapshot> &aSnapshot,
309 const Utf8Str &aStateFilePath, bool fPauseVM, bool &fLeftPaused);
310 HRESULT i_cancelSaveState();
311
312 // callback callers (partly; for some events console callbacks are notified
313 // directly from IInternalSessionControl event handlers declared above)
314 void i_onMousePointerShapeChange(bool fVisible, bool fAlpha,
315 uint32_t xHot, uint32_t yHot,
316 uint32_t width, uint32_t height,
317 const uint8_t *pu8Shape,
318 uint32_t cbShape);
319 void i_onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
320 BOOL supportsTouchScreen, BOOL supportsTouchPad,
321 BOOL needsHostCursor);
322 void i_onStateChange(MachineState_T aMachineState);
323 void i_onAdditionsStateChange();
324 void i_onAdditionsOutdated();
325 void i_onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock);
326 void i_onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
327 IVirtualBoxErrorInfo *aError);
328 void i_onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage);
329 HRESULT i_onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId);
330 void i_onVRDEServerInfoChange();
331 HRESULT i_sendACPIMonitorHotPlugEvent();
332
333 static const PDMDRVREG DrvStatusReg;
334
335 static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
336 static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const char *pcsz, ...);
337 HRESULT i_setInvalidMachineStateError();
338
339 static const char *i_storageControllerTypeToStr(StorageControllerType_T enmCtrlType);
340 static HRESULT i_storageBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
341 // Called from event listener
342 HRESULT i_onNATRedirectRuleChanged(ULONG ulInstance, BOOL aNatRuleRemove,
343 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
344 HRESULT i_onNATDnsChanged();
345
346 // Mouse interface
347 VMMDevMouseInterface *i_getVMMDevMouseInterface();
348 DisplayMouseInterface *i_getDisplayMouseInterface();
349
350 EmulatedUSB *i_getEmulatedUSB(void) { return mEmulatedUSB; }
351
352 /**
353 * Sets the disk encryption keys.
354 *
355 * @returns COM status code.
356 * @param strCfg The config for the disks.
357 *
358 * @note One line in the config string contains all required data for one disk.
359 * The format for one disk is some sort of comma separated value using
360 * key=value pairs.
361 * There are two keys defined at the moment:
362 * - uuid: The uuid of the base image the key is for (with or without)
363 * the curly braces.
364 * - dek: The data encryption key in base64 encoding
365 */
366 HRESULT i_setDiskEncryptionKeys(const Utf8Str &strCfg);
367
368 int i_retainCryptoIf(PCVBOXCRYPTOIF *ppCryptoIf);
369 int i_releaseCryptoIf(PCVBOXCRYPTOIF pCryptoIf);
370 HRESULT i_unloadCryptoIfModule(void);
371
372#ifdef VBOX_WITH_GUEST_PROPS
373 // VMMDev needs:
374 HRESULT i_pullGuestProperties(ComSafeArrayOut(BSTR, names), ComSafeArrayOut(BSTR, values),
375 ComSafeArrayOut(LONG64, timestamps), ComSafeArrayOut(BSTR, flags));
376 static DECLCALLBACK(int) i_doGuestPropNotification(void *pvExtension, uint32_t, void *pvParms, uint32_t cbParms);
377#endif
378
379private:
380
381 // wrapped IConsole properties
382 HRESULT getMachine(ComPtr<IMachine> &aMachine);
383 HRESULT getState(MachineState_T *aState);
384 HRESULT getGuest(ComPtr<IGuest> &aGuest);
385 HRESULT getKeyboard(ComPtr<IKeyboard> &aKeyboard);
386 HRESULT getMouse(ComPtr<IMouse> &aMouse);
387 HRESULT getDisplay(ComPtr<IDisplay> &aDisplay);
388 HRESULT getDebugger(ComPtr<IMachineDebugger> &aDebugger);
389 HRESULT getUSBDevices(std::vector<ComPtr<IUSBDevice> > &aUSBDevices);
390 HRESULT getRemoteUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aRemoteUSBDevices);
391 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
392 HRESULT getVRDEServerInfo(ComPtr<IVRDEServerInfo> &aVRDEServerInfo);
393 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
394 HRESULT getAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttachedPCIDevices);
395 HRESULT getUseHostClipboard(BOOL *aUseHostClipboard);
396 HRESULT setUseHostClipboard(BOOL aUseHostClipboard);
397 HRESULT getEmulatedUSB(ComPtr<IEmulatedUSB> &aEmulatedUSB);
398
399 // wrapped IConsole methods
400 HRESULT powerUp(ComPtr<IProgress> &aProgress);
401 HRESULT powerUpPaused(ComPtr<IProgress> &aProgress);
402 HRESULT powerDown(ComPtr<IProgress> &aProgress);
403 HRESULT reset();
404 HRESULT pause();
405 HRESULT resume();
406 HRESULT powerButton();
407 HRESULT sleepButton();
408 HRESULT getPowerButtonHandled(BOOL *aHandled);
409 HRESULT getGuestEnteredACPIMode(BOOL *aEntered);
410 HRESULT getDeviceActivity(const std::vector<DeviceType_T> &aType,
411 std::vector<DeviceActivity_T> &aActivity);
412 HRESULT attachUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
413 HRESULT detachUSBDevice(const com::Guid &aId,
414 ComPtr<IUSBDevice> &aDevice);
415 HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
416 ComPtr<IUSBDevice> &aDevice);
417 HRESULT findUSBDeviceById(const com::Guid &aId,
418 ComPtr<IUSBDevice> &aDevice);
419 HRESULT createSharedFolder(const com::Utf8Str &aName,
420 const com::Utf8Str &aHostPath,
421 BOOL aWritable,
422 BOOL aAutomount,
423 const com::Utf8Str &aAutoMountPoint);
424 HRESULT removeSharedFolder(const com::Utf8Str &aName);
425 HRESULT teleport(const com::Utf8Str &aHostname,
426 ULONG aTcpport,
427 const com::Utf8Str &aPassword,
428 ULONG aMaxDowntime,
429 ComPtr<IProgress> &aProgress);
430 HRESULT addEncryptionPassword(const com::Utf8Str &aId, const com::Utf8Str &aPassword,
431 BOOL aClearOnSuspend);
432 HRESULT addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds, const std::vector<com::Utf8Str> &aPasswords,
433 BOOL aClearOnSuspend);
434 HRESULT removeEncryptionPassword(const com::Utf8Str &aId);
435 HRESULT clearAllEncryptionPasswords();
436
437 void notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax);
438 Utf8Str VRDPServerErrorToMsg(int vrc);
439
440 /**
441 * Base template for AutoVMCaller and SafeVMPtr. Template arguments
442 * have the same meaning as arguments of Console::addVMCaller().
443 */
444 template <bool taQuiet = false, bool taAllowNullVM = false>
445 class AutoVMCallerBase
446 {
447 public:
448 AutoVMCallerBase(Console *aThat) : mThat(aThat), mRC(E_FAIL)
449 {
450 Assert(aThat);
451 mRC = aThat->i_addVMCaller(taQuiet, taAllowNullVM);
452 }
453 ~AutoVMCallerBase()
454 {
455 doRelease();
456 }
457 /** Decreases the number of callers before the instance is destroyed. */
458 void releaseCaller()
459 {
460 Assert(SUCCEEDED(mRC));
461 doRelease();
462 }
463 /** Restores the number of callers after by #release(). #hrc() must be
464 * rechecked to ensure the operation succeeded. */
465 void addYY()
466 {
467 AssertReturnVoid(!SUCCEEDED(mRC));
468 mRC = mThat->i_addVMCaller(taQuiet, taAllowNullVM);
469 }
470 /** Returns the result of Console::addVMCaller() */
471 HRESULT hrc() const { return mRC; }
472 /** Shortcut to SUCCEEDED(hrc()) */
473 bool isOk() const { return SUCCEEDED(mRC); }
474 protected:
475 Console *mThat;
476 void doRelease()
477 {
478 if (SUCCEEDED(mRC))
479 {
480 mThat->i_releaseVMCaller();
481 mRC = E_FAIL;
482 }
483 }
484 private:
485 HRESULT mRC; /* Whether the caller was added. */
486 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoVMCallerBase);
487 };
488
489#if 0
490 /**
491 * Helper class that protects sections of code using the mpUVM pointer by
492 * automatically calling addVMCaller() on construction and
493 * releaseVMCaller() on destruction. Intended for Console methods dealing
494 * with mpUVM. The usage pattern is:
495 * <code>
496 * AutoVMCaller autoVMCaller(this);
497 * if (FAILED(autoVMCaller.hrc())) return autoVMCaller.hrc();
498 * ...
499 * VMR3ReqCall (mpUVM, ...
500 * </code>
501 *
502 * @note Temporarily locks the argument for writing.
503 *
504 * @sa SafeVMPtr, SafeVMPtrQuiet
505 * @note Obsolete, use SafeVMPtr
506 */
507 typedef AutoVMCallerBase<false, false> AutoVMCaller;
508#endif
509
510 /**
511 * Same as AutoVMCaller but doesn't set extended error info on failure.
512 *
513 * @note Temporarily locks the argument for writing.
514 * @note Obsolete, use SafeVMPtrQuiet
515 */
516 typedef AutoVMCallerBase<true, false> AutoVMCallerQuiet;
517
518 /**
519 * Same as AutoVMCaller but allows a null VM pointer (to trigger an error
520 * instead of assertion).
521 *
522 * @note Temporarily locks the argument for writing.
523 * @note Obsolete, use SafeVMPtr
524 */
525 typedef AutoVMCallerBase<false, true> AutoVMCallerWeak;
526
527 /**
528 * Same as AutoVMCaller but doesn't set extended error info on failure
529 * and allows a null VM pointer (to trigger an error instead of
530 * assertion).
531 *
532 * @note Temporarily locks the argument for writing.
533 * @note Obsolete, use SafeVMPtrQuiet
534 */
535 typedef AutoVMCallerBase<true, true> AutoVMCallerQuietWeak;
536
537 /**
538 * Base template for SafeVMPtr and SafeVMPtrQuiet.
539 */
540 template<bool taQuiet = false>
541 class SafeVMPtrBase : public AutoVMCallerBase<taQuiet, true>
542 {
543 typedef AutoVMCallerBase<taQuiet, true> Base;
544 public:
545 SafeVMPtrBase(Console *aThat) : Base(aThat), mRC(E_FAIL), mpUVM(NULL), mpVMM(NULL)
546 {
547 if (Base::isOk())
548 mRC = aThat->i_safeVMPtrRetainer(&mpUVM, &mpVMM, taQuiet);
549 }
550 ~SafeVMPtrBase()
551 {
552 doRelease();
553 }
554 /** Direct PUVM access. */
555 PUVM rawUVM() const { return mpUVM; }
556 /** Direct PCVMMR3VTABLE access. */
557 PCVMMR3VTABLE vtable() const { return mpVMM; }
558 /** Release the handles. */
559 void release()
560 {
561 Assert(SUCCEEDED(mRC));
562 doRelease();
563 }
564
565 /** The combined result of Console::addVMCaller() and Console::safeVMPtrRetainer */
566 HRESULT hrc() const { return Base::isOk() ? mRC : Base::hrc(); }
567 /** Shortcut to SUCCEEDED(hrc()) */
568 bool isOk() const { return SUCCEEDED(mRC) && Base::isOk(); }
569
570 private:
571 void doRelease()
572 {
573 if (SUCCEEDED(mRC))
574 {
575 Base::mThat->i_safeVMPtrReleaser(&mpUVM);
576 mRC = E_FAIL;
577 }
578 Base::doRelease();
579 }
580 HRESULT mRC; /* Whether the VM ptr was retained. */
581 PUVM mpUVM;
582 PCVMMR3VTABLE mpVMM;
583 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SafeVMPtrBase);
584 };
585
586public:
587
588 /*
589 * Helper class that safely manages the Console::mpUVM pointer
590 * by calling addVMCaller() on construction and releaseVMCaller() on
591 * destruction. Intended for Console children. The usage pattern is:
592 * <code>
593 * Console::SafeVMPtr ptrVM(mParent);
594 * if (!ptrVM.isOk())
595 * return ptrVM.hrc();
596 * ...
597 * VMR3ReqCall(ptrVM.rawUVM(), ...
598 * ...
599 * printf("%p\n", ptrVM.rawUVM());
600 * </code>
601 *
602 * @note Temporarily locks the argument for writing.
603 *
604 * @sa SafeVMPtrQuiet, AutoVMCaller
605 */
606 typedef SafeVMPtrBase<false> SafeVMPtr;
607
608 /**
609 * A deviation of SafeVMPtr that doesn't set the error info on failure.
610 * Intended for pieces of code that don't need to return the VM access
611 * failure to the caller. The usage pattern is:
612 * <code>
613 * Console::SafeVMPtrQuiet pVM(mParent);
614 * if (pVM.hrc())
615 * VMR3ReqCall(pVM, ...
616 * return S_OK;
617 * </code>
618 *
619 * @note Temporarily locks the argument for writing.
620 *
621 * @sa SafeVMPtr, AutoVMCaller
622 */
623 typedef SafeVMPtrBase<true> SafeVMPtrQuiet;
624
625 class SharedFolderData
626 {
627 public:
628 SharedFolderData()
629 { }
630
631 SharedFolderData(const Utf8Str &aHostPath,
632 bool aWritable,
633 bool aAutoMount,
634 const Utf8Str &aAutoMountPoint)
635 : m_strHostPath(aHostPath)
636 , m_fWritable(aWritable)
637 , m_fAutoMount(aAutoMount)
638 , m_strAutoMountPoint(aAutoMountPoint)
639 { }
640
641 /** Copy constructor. */
642 SharedFolderData(const SharedFolderData& aThat)
643 : m_strHostPath(aThat.m_strHostPath)
644 , m_fWritable(aThat.m_fWritable)
645 , m_fAutoMount(aThat.m_fAutoMount)
646 , m_strAutoMountPoint(aThat.m_strAutoMountPoint)
647 { }
648
649 /** Copy assignment operator. */
650 SharedFolderData &operator=(SharedFolderData const &a_rThat) RT_NOEXCEPT
651 {
652 m_strHostPath = a_rThat.m_strHostPath;
653 m_fWritable = a_rThat.m_fWritable;
654 m_fAutoMount = a_rThat.m_fAutoMount;
655 m_strAutoMountPoint = a_rThat.m_strAutoMountPoint;
656
657 return *this;
658 }
659
660 Utf8Str m_strHostPath;
661 bool m_fWritable;
662 bool m_fAutoMount;
663 Utf8Str m_strAutoMountPoint;
664 };
665
666 /**
667 * Class for managing emulated USB MSDs.
668 */
669 class USBStorageDevice
670 {
671 public:
672 USBStorageDevice()
673 { }
674 /** The UUID associated with the USB device. */
675 RTUUID mUuid;
676 /** Port of the storage device. */
677 LONG iPort;
678 };
679
680 typedef std::map<Utf8Str, ComObjPtr<ConsoleSharedFolder> > SharedFolderMap;
681 typedef std::map<Utf8Str, SharedFolderData> SharedFolderDataMap;
682 typedef std::map<Utf8Str, ComPtr<IMediumAttachment> > MediumAttachmentMap;
683 typedef std::list<USBStorageDevice> USBStorageDeviceList;
684
685 static void i_powerUpThreadTask(VMPowerUpTask *pTask);
686 static void i_powerDownThreadTask(VMPowerDownTask *pTask);
687
688private:
689
690 typedef std::list <ComObjPtr<OUSBDevice> > USBDeviceList;
691 typedef std::list <ComObjPtr<RemoteUSBDevice> > RemoteUSBDeviceList;
692
693 HRESULT i_loadVMM(const char *pszVMMMod) RT_NOEXCEPT;
694 HRESULT i_addVMCaller(bool aQuiet = false, bool aAllowNullVM = false);
695 void i_releaseVMCaller();
696 HRESULT i_safeVMPtrRetainer(PUVM *a_ppUVM, PCVMMR3VTABLE *a_ppVMM, bool aQuiet) RT_NOEXCEPT;
697 void i_safeVMPtrReleaser(PUVM *a_ppUVM);
698
699 HRESULT i_consoleInitReleaseLog(const ComPtr<IMachine> aMachine);
700
701 HRESULT i_powerUp(IProgress **aProgress, bool aPaused);
702 HRESULT i_powerDown(IProgress *aProgress = NULL);
703
704/* Note: FreeBSD needs this whether netflt is used or not. */
705#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) || defined(RT_OS_FREEBSD))
706 HRESULT i_attachToTapInterface(INetworkAdapter *networkAdapter);
707 HRESULT i_detachFromTapInterface(INetworkAdapter *networkAdapter);
708#endif
709 HRESULT i_powerDownHostInterfaces();
710
711 HRESULT i_setMachineState(MachineState_T aMachineState, bool aUpdateServer = true);
712 HRESULT i_setMachineStateLocally(MachineState_T aMachineState)
713 {
714 return i_setMachineState(aMachineState, false /* aUpdateServer */);
715 }
716
717 HRESULT i_findSharedFolder(const Utf8Str &strName,
718 ComObjPtr<ConsoleSharedFolder> &aSharedFolder,
719 bool aSetError = false);
720
721 HRESULT i_fetchSharedFolders(BOOL aGlobal);
722 bool i_findOtherSharedFolder(const Utf8Str &straName,
723 SharedFolderDataMap::const_iterator &aIt);
724
725 HRESULT i_createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
726 HRESULT i_removeSharedFolder(const Utf8Str &strName);
727
728 HRESULT i_suspendBeforeConfigChange(PUVM pUVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock, bool *pfResume);
729 void i_resumeAfterConfigChange(PUVM pUVM, PCVMMR3VTABLE pVMM);
730
731 static DECLCALLBACK(int) i_configConstructor(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, void *pvConsole);
732 void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const char *pcszValue);
733 void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const Utf8Str &rStrValue);
734 void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const Bstr &rBstrValue);
735 void InsertConfigStringF(PCFGMNODE pNode, const char *pcszName, const char *pszFormat, ...);
736 void InsertConfigPassword(PCFGMNODE pNode, const char *pcszName, const Utf8Str &rStrValue);
737 void InsertConfigBytes(PCFGMNODE pNode, const char *pcszName, const void *pvBytes, size_t cbBytes);
738 void InsertConfigInteger(PCFGMNODE pNode, const char *pcszName, uint64_t u64Integer);
739 void InsertConfigNode(PCFGMNODE pNode, const char *pcszName, PCFGMNODE *ppChild);
740 void InsertConfigNodeF(PCFGMNODE pNode, PCFGMNODE *ppChild, const char *pszNameFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
741 void RemoveConfigValue(PCFGMNODE pNode, const char *pcszName);
742 int SetBiosDiskInfo(ComPtr<IMachine> pMachine, PCFGMNODE pCfg, PCFGMNODE pBiosCfg,
743 Bstr controllerName, const char * const s_apszBiosConfig[4]);
744 void i_configAudioDriver(IVirtualBox *pVirtualBox, IMachine *pMachine, PCFGMNODE pLUN, const char *pszDriverName,
745 bool fAudioEnabledIn, bool fAudioEnabledOut);
746 int i_configConstructorInner(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock);
747 int i_configConstructorX86(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock);
748#ifdef VBOX_WITH_VIRT_ARMV8
749 int i_configConstructorArmV8(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock);
750#endif
751 int i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine);
752 int i_configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine);
753
754 int i_configGraphicsController(PCFGMNODE pDevices,
755 const GraphicsControllerType_T graphicsController,
756 BusAssignmentManager *pBusMgr,
757 const ComPtr<IMachine> &ptrMachine,
758 const ComPtr<IGraphicsAdapter> &ptrGraphicsAdapter,
759 const ComPtr<IFirmwareSettings> &ptrFirmwareSettings,
760 bool fForceVmSvga3 = false, bool fExposeLegacyVga = true);
761 int i_checkMediumLocation(IMedium *pMedium, bool *pfUseHostIOCache);
762 int i_unmountMediumFromGuest(PUVM pUVM, PCVMMR3VTABLE pVMM, StorageBus_T enmBus, DeviceType_T enmDevType,
763 const char *pcszDevice, unsigned uInstance, unsigned uLUN,
764 bool fForceUnmount) RT_NOEXCEPT;
765 int i_removeMediumDriverFromVm(PCFGMNODE pCtlInst,
766 const char *pcszDevice,
767 unsigned uInstance,
768 unsigned uLUN,
769 StorageBus_T enmBus,
770 bool fAttachDetach,
771 bool fHotplug,
772 bool fForceUnmount,
773 PUVM pUVM,
774 PCVMMR3VTABLE pVMM,
775 DeviceType_T enmDevType,
776 PCFGMNODE *ppLunL0);
777 int i_configMediumAttachment(const char *pcszDevice,
778 unsigned uInstance,
779 StorageBus_T enmBus,
780 bool fUseHostIOCache,
781 bool fBuiltinIoCache,
782 bool fInsertDiskIntegrityDrv,
783 bool fSetupMerge,
784 unsigned uMergeSource,
785 unsigned uMergeTarget,
786 IMediumAttachment *pMediumAtt,
787 MachineState_T aMachineState,
788 HRESULT *phrc,
789 bool fAttachDetach,
790 bool fForceUnmount,
791 bool fHotplug,
792 PUVM pUVM,
793 PCVMMR3VTABLE pVMM,
794 DeviceType_T *paLedDevType,
795 PCFGMNODE *ppLunL0);
796 int i_configMedium(PCFGMNODE pLunL0,
797 bool fPassthrough,
798 DeviceType_T enmType,
799 bool fUseHostIOCache,
800 bool fBuiltinIoCache,
801 bool fInsertDiskIntegrityDrv,
802 bool fSetupMerge,
803 unsigned uMergeSource,
804 unsigned uMergeTarget,
805 const char *pcszBwGroup,
806 bool fDiscard,
807 bool fNonRotational,
808 ComPtr<IMedium> ptrMedium,
809 MachineState_T aMachineState,
810 HRESULT *phrc);
811 int i_configMediumProperties(PCFGMNODE pCur, IMedium *pMedium, bool *pfHostIP, bool *pfEncrypted);
812 static DECLCALLBACK(int) i_reconfigureMediumAttachment(Console *pThis,
813 PUVM pUVM,
814 PCVMMR3VTABLE pVMM,
815 const char *pcszDevice,
816 unsigned uInstance,
817 StorageBus_T enmBus,
818 bool fUseHostIOCache,
819 bool fBuiltinIoCache,
820 bool fInsertDiskIntegrityDrv,
821 bool fSetupMerge,
822 unsigned uMergeSource,
823 unsigned uMergeTarget,
824 IMediumAttachment *aMediumAtt,
825 MachineState_T aMachineState,
826 HRESULT *phrc);
827 static DECLCALLBACK(int) i_changeRemovableMedium(Console *pThis,
828 PUVM pUVM,
829 PCVMMR3VTABLE pVMM,
830 const char *pcszDevice,
831 unsigned uInstance,
832 StorageBus_T enmBus,
833 bool fUseHostIOCache,
834 IMediumAttachment *aMediumAtt,
835 bool fForce);
836
837 HRESULT i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *BusMgr, PCFGMNODE pDevices);
838 struct LEDSET;
839 typedef struct LEDSET *PLEDSET;
840 PPDMLED volatile *i_getLedSet(uint32_t iLedSet);
841 void i_setLedType(DeviceType_T *penmSubTypeEntry, DeviceType_T enmNewType);
842 HRESULT i_refreshLedTypeArrays(AutoReadLock *pReadLock);
843 uint32_t i_allocateDriverLeds(uint32_t cLeds, uint32_t fTypes, DeviceType_T **ppSubTypes);
844 void i_attachStatusDriver(PCFGMNODE pCtlInst, DeviceType_T enmType, uint32_t cLeds = 1);
845 void i_attachStatusDriver(PCFGMNODE pCtlInst, uint32_t fTypes, uint32_t cLeds, DeviceType_T **ppaSubTypes,
846 Console::MediumAttachmentMap *pmapMediumAttachments,
847 const char *pcszDevice, unsigned uInstance);
848
849 int i_configNetwork(const char *pszDevice, unsigned uInstance, unsigned uLun, INetworkAdapter *aNetworkAdapter,
850 PCFGMNODE pCfg, PCFGMNODE pLunL0, PCFGMNODE pInst, bool fAttachDetach, bool fIgnoreConnectFailure,
851 PUVM pUVM, PCVMMR3VTABLE pVMM);
852 int i_configProxy(ComPtr<IVirtualBox> virtualBox, PCFGMNODE pCfg, const char *pcszPrefix, const com::Utf8Str &strIpAddr);
853
854 int i_configSerialPort(PCFGMNODE pInst, PortMode_T ePortMode, const char *pszPath, bool fServer);
855
856 int i_configAudioCtrl(ComPtr<IVirtualBox> pVBox, ComPtr<IMachine> pMachine, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices,
857 bool fOsXGuest, bool *pfAudioEnabled);
858 int i_configVmmDev(ComPtr<IMachine> pMachine, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices, bool fMmioReq = false);
859 int i_configPdm(ComPtr<IMachine> pMachine, PCVMMR3VTABLE pVMM, PUVM pUVM, PCFGMNODE pRoot);
860 int i_configUsb(ComPtr<IMachine> pMachine, BusAssignmentManager *pBusMgr, PCFGMNODE pRoot, PCFGMNODE pDevices,
861 KeyboardHIDType_T enmKbdHid, PointingHIDType_T enmPointingHid, PCFGMNODE *ppUsbDevices);
862 int i_configGuestDbg(ComPtr<IVirtualBox> pVBox, ComPtr<IMachine> pMachine, PCFGMNODE pRoot);
863 int i_configStorageCtrls(ComPtr<IMachine> pMachine, BusAssignmentManager *pBusMgr, PCVMMR3VTABLE pVMM, PUVM pUVM,
864 PCFGMNODE pDevices, PCFGMNODE pUsbDevices, PCFGMNODE pBiosCfg, bool *pfFdcEnabled);
865 int i_configNetworkCtrls(ComPtr<IMachine> pMachine, ComPtr<IPlatformProperties> pPlatformProperties,
866 ChipsetType_T enmChipset, BusAssignmentManager *pBusMgr, PCVMMR3VTABLE pVMM, PUVM pUVM,
867 PCFGMNODE pDevices, std::list<BootNic> &llBootNics);
868
869 static DECLCALLBACK(void) i_vmstateChangeCallback(PUVM pUVM, PCVMMR3VTABLE pVMM, VMSTATE enmState,
870 VMSTATE enmOldState, void *pvUser);
871 static DECLCALLBACK(int) i_unplugCpu(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, VMCPUID idCpu);
872 static DECLCALLBACK(int) i_plugCpu(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, VMCPUID idCpu);
873 HRESULT i_doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM, PCVMMR3VTABLE pVMM);
874 HRESULT i_doCPURemove(ULONG aCpu, PUVM pUVM, PCVMMR3VTABLE pVMM);
875 HRESULT i_doCPUAdd(ULONG aCpu, PUVM pUVM, PCVMMR3VTABLE pVMM);
876
877 HRESULT i_doNetworkAdapterChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, unsigned uInstance,
878 unsigned uLun, INetworkAdapter *aNetworkAdapter);
879 static DECLCALLBACK(int) i_changeNetworkAttachment(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice,
880 unsigned uInstance, unsigned uLun, INetworkAdapter *aNetworkAdapter);
881 static DECLCALLBACK(int) i_changeSerialPortAttachment(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, ISerialPort *pSerialPort);
882
883 int i_changeClipboardMode(ClipboardMode_T aClipboardMode);
884 int i_changeClipboardFileTransferMode(bool aEnabled);
885 int i_changeDnDMode(DnDMode_T aDnDMode);
886
887#ifdef VBOX_WITH_USB
888 HRESULT i_attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs, const Utf8Str &aCaptureFilename);
889 HRESULT i_detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
890
891 static DECLCALLBACK(int) i_usbAttachCallback(Console *that, PUVM pUVM, PCVMMR3VTABLE pVMM, IUSBDevice *aHostDevice,
892 PCRTUUID aUuid, const char *aBackend, const char *aAddress,
893 PCFGMNODE pRemoteCfg, USBConnectionSpeed_T enmSpeed, ULONG aMaskedIfs,
894 const char *pszCaptureFilename);
895 static DECLCALLBACK(int) i_usbDetachCallback(Console *that, PUVM pUVM, PCVMMR3VTABLE pVMM, PCRTUUID aUuid);
896 static DECLCALLBACK(PREMOTEUSBCALLBACK) i_usbQueryRemoteUsbBackend(void *pvUser, PCRTUUID pUuid, uint32_t idClient);
897
898 /** Interface for the VRDP USB proxy backend to query for a device remote callback table. */
899 REMOTEUSBIF mRemoteUsbIf;
900#endif
901
902 static DECLCALLBACK(int) i_attachStorageDevice(Console *pThis,
903 PUVM pUVM,
904 PCVMMR3VTABLE pVMM,
905 const char *pcszDevice,
906 unsigned uInstance,
907 StorageBus_T enmBus,
908 bool fUseHostIOCache,
909 IMediumAttachment *aMediumAtt,
910 bool fSilent);
911 static DECLCALLBACK(int) i_detachStorageDevice(Console *pThis,
912 PUVM pUVM,
913 PCVMMR3VTABLE pVMM,
914 const char *pcszDevice,
915 unsigned uInstance,
916 StorageBus_T enmBus,
917 IMediumAttachment *aMediumAtt,
918 bool fSilent);
919 HRESULT i_doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, PCVMMR3VTABLE pVMM, bool fSilent);
920 HRESULT i_doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, PCVMMR3VTABLE pVMM, bool fSilent);
921
922 static DECLCALLBACK(int) i_stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
923
924 static DECLCALLBACK(void) i_genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int vrc, RT_SRC_POS_DECL,
925 const char *pszErrorFmt, va_list va);
926
927 void i_atVMRuntimeErrorCallbackF(uint32_t fFatal, const char *pszErrorId, const char *pszFormat, ...);
928 static DECLCALLBACK(void) i_atVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
929 const char *pszErrorId, const char *pszFormat, va_list va);
930
931 HRESULT i_captureUSBDevices(PUVM pUVM);
932 void i_detachAllUSBDevices(bool aDone);
933
934
935 static DECLCALLBACK(int) i_vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM);
936 static DECLCALLBACK(void) i_vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
937 static DECLCALLBACK(void) i_vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
938 static DECLCALLBACK(void) i_vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM);
939 static DECLCALLBACK(void) i_vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM);
940 static DECLCALLBACK(void) i_vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM);
941 static DECLCALLBACK(void *) i_vmm2User_QueryGenericObject(PCVMM2USERMETHODS pThis, PUVM pUVM, PCRTUUID pUuid);
942
943 static DECLCALLBACK(void *) i_drvStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID);
944 static DECLCALLBACK(void) i_drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN);
945 static DECLCALLBACK(int) i_drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned iLUN);
946 static DECLCALLBACK(void) i_drvStatus_Destruct(PPDMDRVINS pDrvIns);
947 static DECLCALLBACK(int) i_drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
948
949 static DECLCALLBACK(int) i_pdmIfSecKey_KeyRetain(PPDMISECKEY pInterface, const char *pszId, const uint8_t **ppbKey,
950 size_t *pcbKey);
951 static DECLCALLBACK(int) i_pdmIfSecKey_KeyRelease(PPDMISECKEY pInterface, const char *pszId);
952 static DECLCALLBACK(int) i_pdmIfSecKey_PasswordRetain(PPDMISECKEY pInterface, const char *pszId, const char **ppszPassword);
953 static DECLCALLBACK(int) i_pdmIfSecKey_PasswordRelease(PPDMISECKEY pInterface, const char *pszId);
954
955 static DECLCALLBACK(int) i_pdmIfSecKeyHlp_KeyMissingNotify(PPDMISECKEYHLP pInterface);
956
957 int mcAudioRefs;
958 volatile uint32_t mcVRDPClients;
959 uint32_t mu32SingleRDPClientId; /* The id of a connected client in the single connection mode. */
960 volatile bool mcGuestCredentialsProvided;
961
962 static const char *sSSMConsoleUnit;
963
964 HRESULT i_loadDataFromSavedState();
965 int i_loadStateFileExecInternal(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, uint32_t u32Version);
966
967 static DECLCALLBACK(int) i_saveStateFileExec(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
968 static DECLCALLBACK(int) i_loadStateFileExec(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
969 uint32_t uVersion, uint32_t uPass);
970
971#ifdef VBOX_WITH_GUEST_PROPS
972 HRESULT i_doEnumerateGuestProperties(const Utf8Str &aPatterns,
973 std::vector<Utf8Str> &aNames,
974 std::vector<Utf8Str> &aValues,
975 std::vector<LONG64> &aTimestamps,
976 std::vector<Utf8Str> &aFlags);
977
978 void i_guestPropertiesHandleVMReset(void);
979 bool i_guestPropertiesVRDPEnabled(void);
980 void i_guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain);
981 void i_guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId);
982 void i_guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached);
983 void i_guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName);
984 void i_guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr);
985 void i_guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation);
986 void i_guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo);
987 void i_guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId);
988#endif
989
990 /** @name Disk encryption support
991 * @{ */
992 HRESULT i_consoleParseDiskEncryption(const char *psz, const char **ppszEnd);
993 HRESULT i_configureEncryptionForDisk(const Utf8Str &strId, unsigned *pcDisksConfigured);
994 HRESULT i_clearDiskEncryptionKeysOnAllAttachmentsWithKeyId(const Utf8Str &strId);
995 HRESULT i_initSecretKeyIfOnAllAttachments(void);
996 int i_consoleParseKeyValue(const char *psz, const char **ppszEnd,
997 char **ppszKey, char **ppszVal);
998 void i_removeSecretKeysOnSuspend();
999 /** @} */
1000
1001 /** @name Teleporter support
1002 * @{ */
1003 static DECLCALLBACK(int) i_teleporterSrcThreadWrapper(RTTHREAD hThreadSelf, void *pvUser);
1004 HRESULT i_teleporterSrc(TeleporterStateSrc *pState);
1005 HRESULT i_teleporterSrcReadACK(TeleporterStateSrc *pState, const char *pszWhich, const char *pszNAckMsg = NULL);
1006 HRESULT i_teleporterSrcSubmitCommand(TeleporterStateSrc *pState, const char *pszCommand, bool fWaitForAck = true);
1007 HRESULT i_teleporterTrg(PUVM pUVM, PCVMMR3VTABLE pVMM, IMachine *pMachine, Utf8Str *pErrorMsg,
1008 bool fStartPaused, Progress *pProgress, bool *pfPowerOffOnFailure);
1009 static DECLCALLBACK(int) i_teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser);
1010 /** @} */
1011
1012#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
1013 /** @name Encrypted log interface
1014 * @{ */
1015 static DECLCALLBACK(int) i_logEncryptedDirCtxOpen(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilename, void **pvDirCtx);
1016 static DECLCALLBACK(int) i_logEncryptedDirCtxClose(PCRTLOGOUTPUTIF pIf, void *pvUser, void *pvDirCtx);
1017 static DECLCALLBACK(int) i_logEncryptedDelete(PCRTLOGOUTPUTIF pIf, void *pvUser, void *pvDirCtx, const char *pszFilename);
1018 static DECLCALLBACK(int) i_logEncryptedRename(PCRTLOGOUTPUTIF pIf, void *pvUser, void *pvDirCtx,
1019 const char *pszFilenameOld, const char *pszFilenameNew, uint32_t fFlags);
1020 static DECLCALLBACK(int) i_logEncryptedOpen(PCRTLOGOUTPUTIF pIf, void *pvUser, void *pvDirCtx, const char *pszFilename, uint32_t fFlags);
1021 static DECLCALLBACK(int) i_logEncryptedClose(PCRTLOGOUTPUTIF pIf, void *pvUser);
1022 static DECLCALLBACK(int) i_logEncryptedQuerySize(PCRTLOGOUTPUTIF pIf, void *pvUser, uint64_t *pcbSize);
1023 static DECLCALLBACK(int) i_logEncryptedWrite(PCRTLOGOUTPUTIF pIf, void *pvUser, const void *pvBuf,
1024 size_t cbWrite, size_t *pcbWritten);
1025 static DECLCALLBACK(int) i_logEncryptedFlush(PCRTLOGOUTPUTIF pIf, void *pvUser);
1026 /** The logging output interface for encrypted logs. */
1027 static RTLOGOUTPUTIF const s_ConsoleEncryptedLogOutputIf;
1028 /** @} */
1029#endif
1030
1031 bool mSavedStateDataLoaded : 1;
1032
1033 const ComPtr<IMachine> mMachine;
1034 const ComPtr<IInternalMachineControl> mControl;
1035
1036 const ComPtr<IVRDEServer> mVRDEServer;
1037
1038 ConsoleVRDPServer * const mConsoleVRDPServer;
1039 bool mfVRDEChangeInProcess;
1040 bool mfVRDEChangePending;
1041 const ComObjPtr<Guest> mGuest;
1042 const ComObjPtr<Keyboard> mKeyboard;
1043 const ComObjPtr<Mouse> mMouse;
1044 const ComObjPtr<Display> mDisplay;
1045 const ComObjPtr<MachineDebugger> mDebugger;
1046 const ComObjPtr<VRDEServerInfo> mVRDEServerInfo;
1047 /** This can safely be used without holding any locks.
1048 * An AutoCaller suffices to prevent it being destroy while in use and
1049 * internally there is a lock providing the necessary serialization. */
1050 const ComObjPtr<EventSource> mEventSource;
1051#ifdef VBOX_WITH_EXTPACK
1052 const ComObjPtr<ExtPackManager> mptrExtPackManager;
1053#endif
1054 const ComObjPtr<EmulatedUSB> mEmulatedUSB;
1055 const ComObjPtr<NvramStore> mptrNvramStore;
1056#ifdef VBOX_WITH_VIRT_ARMV8
1057 const ComObjPtr<ResourceStore> mptrResourceStore;
1058#endif
1059
1060 USBDeviceList mUSBDevices;
1061 RemoteUSBDeviceList mRemoteUSBDevices;
1062
1063 SharedFolderDataMap m_mapGlobalSharedFolders;
1064 SharedFolderDataMap m_mapMachineSharedFolders;
1065 SharedFolderMap m_mapSharedFolders; // the console instances
1066
1067 /** VMM loader handle. */
1068 RTLDRMOD mhModVMM;
1069 /** The VMM vtable. */
1070 PCVMMR3VTABLE mpVMM;
1071 /** The user mode VM handle. */
1072 PUVM mpUVM;
1073 /** Holds the number of "readonly" mpUVM callers (users). */
1074 uint32_t mVMCallers;
1075 /** Semaphore posted when the number of mpUVM callers drops to zero. */
1076 RTSEMEVENT mVMZeroCallersSem;
1077 /** true when Console has entered the mpUVM destruction phase. */
1078 bool mVMDestroying : 1;
1079 /** true when power down is initiated by vmstateChangeCallback (EMT). */
1080 bool mVMPoweredOff : 1;
1081 /** true when vmstateChangeCallback shouldn't initiate a power down. */
1082 bool mVMIsAlreadyPoweringOff : 1;
1083 /** true if we already showed the snapshot folder size warning. */
1084 bool mfSnapshotFolderSizeWarningShown : 1;
1085 /** true if we already showed the snapshot folder ext4/xfs bug warning. */
1086 bool mfSnapshotFolderExt4WarningShown : 1;
1087 /** true if we already listed the disk type of the snapshot folder. */
1088 bool mfSnapshotFolderDiskTypeShown : 1;
1089 /** true if a USB controller is available (i.e. USB devices can be attached). */
1090 bool mfVMHasUsbController : 1;
1091 /** Shadow of the VBoxInternal2/TurnResetIntoPowerOff extra data setting.
1092 * This is initialized by Console::i_configConstructorInner(). */
1093 bool mfTurnResetIntoPowerOff : 1;
1094 /** true if the VM power off was caused by reset. */
1095 bool mfPowerOffCausedByReset : 1;
1096
1097 /** Pointer to the VMM -> User (that's us) callbacks. */
1098 struct MYVMM2USERMETHODS : public VMM2USERMETHODS
1099 {
1100 Console *pConsole;
1101 /** The in-progress snapshot. */
1102 ISnapshot *pISnapshot;
1103 } *mpVmm2UserMethods;
1104
1105 /** The current network attachment type in the VM.
1106 * This doesn't have to match the network attachment type maintained in the
1107 * NetworkAdapter. This is needed to change the network attachment
1108 * dynamically.
1109 */
1110 typedef std::vector<NetworkAttachmentType_T> NetworkAttachmentTypeVector;
1111 NetworkAttachmentTypeVector meAttachmentType;
1112
1113 VMMDev * m_pVMMDev;
1114 AudioVRDE * const mAudioVRDE;
1115#ifdef VBOX_WITH_USB_CARDREADER
1116 UsbCardReader * const mUsbCardReader;
1117#endif
1118 BusAssignmentManager* mBusMgr;
1119
1120 /** @name LEDs and their management
1121 * @{ */
1122 /** Read/write lock separating LED allocations and per-type data construction
1123 * (write) from queries (read). */
1124 RWLockHandle mLedLock;
1125 /** LED configuration generation. This is increased whenever a new set is
1126 * allocated or a sub-device type changes. */
1127 uint32_t muLedGen;
1128 /** The LED configuration generation which maLedTypes was constructed for. */
1129 uint32_t muLedTypeGen;
1130 /** Number of LED sets in use in maLedSets. */
1131 uint32_t mcLedSets;
1132 /** LED sets. */
1133 struct LEDSET
1134 {
1135 /** Bitmask of possible DeviceType_T values (e.g. RT_BIT_32(DeviceType_Network)). */
1136 uint32_t fTypes;
1137 /** Number of LEDs. */
1138 uint32_t cLeds;
1139 /** Array of PDMLED pointers. The pointers in the array can be changed at any
1140 * time by Console::i_drvStatus_UnitChanged(). */
1141 PPDMLED volatile *papLeds;
1142 /** Optionally, device types for each individual LED. Runs parallel to papLeds. */
1143 DeviceType_T *paSubTypes;
1144 } maLedSets[32];
1145 /** LEDs data organized by DeviceType_T.
1146 * This is reconstructed by Console::i_refreshLedTypeArrays() when
1147 * Console::getDeviceActivity is called and mLedTypeGen doesn't match
1148 * muLedGen. */
1149 struct
1150 {
1151 /** Number of possibly valid entries in pappLeds. */
1152 uint32_t cLeds;
1153 /** Number of allocated entries. */
1154 uint32_t cAllocated;
1155 /** Array of pointer to LEDSET::papLed entries.
1156 * The indirection is due to Console::i_drvStatus_UnitChanged() only knowing
1157 * about the LEDSET::papLeds. */
1158 PPDMLED volatile **pappLeds;
1159 } maLedTypes[DeviceType_End];
1160 /** @} */
1161
1162 MediumAttachmentMap mapMediumAttachments;
1163
1164 /** List of attached USB storage devices. */
1165 USBStorageDeviceList mUSBStorageDevices;
1166
1167 /** Store for secret keys. */
1168 SecretKeyStore * const m_pKeyStore;
1169 /** Number of disks configured for encryption. */
1170 unsigned m_cDisksEncrypted;
1171 /** Number of disks which have the key in the map. */
1172 unsigned m_cDisksPwProvided;
1173
1174 /** Current active port modes of the supported serial ports. */
1175 PortMode_T m_aeSerialPortMode[4];
1176
1177 /** Pointer to the key consumer -> provider (that's us) callbacks. */
1178 struct MYPDMISECKEY : public PDMISECKEY
1179 {
1180 Console *pConsole;
1181 } *mpIfSecKey;
1182
1183 /** Pointer to the key helpers -> provider (that's us) callbacks. */
1184 struct MYPDMISECKEYHLP : public PDMISECKEYHLP
1185 {
1186 Console *pConsole;
1187 } *mpIfSecKeyHlp;
1188
1189/* Note: FreeBSD needs this whether netflt is used or not. */
1190#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) || defined(RT_OS_FREEBSD))
1191 Utf8Str maTAPDeviceName[8];
1192 RTFILE maTapFD[8];
1193#endif
1194
1195 bool mVMStateChangeCallbackDisabled;
1196
1197 bool mfUseHostClipboard;
1198
1199 /** Local machine state value. */
1200 MachineState_T mMachineState;
1201
1202 /** Machine uuid string. */
1203 Bstr mstrUuid;
1204
1205 /** @name Members related to the cryptographic support interface.
1206 * @{ */
1207 /** The loaded module handle if loaded. */
1208 RTLDRMOD mhLdrModCrypto;
1209 /** Reference counter tracking how many users of the cryptographic support
1210 * are there currently. */
1211 volatile uint32_t mcRefsCrypto;
1212 /** Pointer to the cryptographic support interface. */
1213 PCVBOXCRYPTOIF mpCryptoIf;
1214 /** @} */
1215
1216#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
1217 /** Flag whether the log is encrypted. */
1218 bool m_fEncryptedLog;
1219 /** The file handle of the encrypted log. */
1220 RTVFSFILE m_hVfsFileLog;
1221 /** The log file key ID. */
1222 Utf8Str m_strLogKeyId;
1223 /** The log file key store. */
1224 Utf8Str m_strLogKeyStore;
1225#endif
1226
1227#ifdef VBOX_WITH_SHARED_CLIPBOARD
1228 /* Service extension for the Shared Clipboard HGCM service. */
1229 HGCMSVCEXTHANDLE m_hHgcmSvcExtShCl;
1230#endif
1231
1232#ifdef VBOX_WITH_DRAG_AND_DROP
1233 /* Service extension for the Drag'n Drop HGCM service. */
1234 HGCMSVCEXTHANDLE m_hHgcmSvcExtDragAndDrop;
1235#endif
1236 /** Pointer to the progress object of a live cancelable task.
1237 *
1238 * This is currently only used by Console::Teleport(), but is intended to later
1239 * be used by the live snapshot code path as well. Actions like
1240 * Console::PowerDown, which automatically cancels out the running snapshot /
1241 * teleportation operation, will cancel the teleportation / live snapshot
1242 * operation before starting. */
1243 ComPtr<IProgress> mptrCancelableProgress;
1244
1245 ComPtr<IEventListener> mVmListener;
1246
1247#ifdef VBOX_WITH_RECORDING
1248 struct Recording
1249 {
1250 Recording()
1251# ifdef VBOX_WITH_AUDIO_RECORDING
1252 : mAudioRec(NULL)
1253# endif
1254 { }
1255
1256 /** The recording context. */
1257 RecordingContext mCtx;
1258# ifdef VBOX_WITH_AUDIO_RECORDING
1259 /** Pointer to capturing audio backend. */
1260 AudioVideoRec * const mAudioRec;
1261# endif
1262 } mRecording;
1263#endif /* VBOX_WITH_RECORDING */
1264
1265#ifdef VBOX_WITH_CLOUD_NET
1266 GatewayInfo mGateway;
1267#endif /* VBOX_WITH_CLOUD_NET */
1268
1269 friend class VMTask;
1270 friend class ConsoleVRDPServer;
1271};
1272
1273
1274class ConfigError : public RTCError
1275{
1276public:
1277
1278 ConfigError(const char *pcszFunction,
1279 int vrc,
1280 const char *pcszName)
1281 : RTCError(Utf8StrFmt(Console::tr("%s failed: vrc=%Rrc, pcszName=%s"), pcszFunction, vrc, pcszName)),
1282 m_vrc(vrc)
1283 {
1284 AssertMsgFailed(("%s\n", what())); // in strict mode, hit a breakpoint here
1285 }
1286
1287 int m_vrc;
1288};
1289
1290DECL_HIDDEN_THROW(Utf8Str *) GetExtraDataBoth(IVirtualBox *pVirtualBox, IMachine *pMachine, const char *pszName, Utf8Str *pStrValue);
1291
1292#ifndef VBOX_WITH_EFI_IN_DD2
1293DECLHIDDEN(int) findEfiRom(IVirtualBox* vbox, PlatformArchitecture_T aPlatformArchitecture, FirmwareType_T aFirmwareType, Utf8Str *pEfiRomFile);
1294#endif
1295
1296#endif /* !MAIN_INCLUDED_ConsoleImpl_h */
1297/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use