VirtualBox

source: vbox/trunk/src/VBox/Main/include/MediumImpl.h@ 76298

Last change on this file since 76298 was 76298, checked in by vboxsync, 6 years ago

Main: bugref:6913: Added generation of some medium events. Contains some fixes for VBoxSVC crash in the MacOS
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.9 KB
Line 
1/* $Id: MediumImpl.h 76298 2018-12-19 18:17:50Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2008-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.215389.xyz. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19#ifndef ____H_MEDIUMIMPL
20#define ____H_MEDIUMIMPL
21
22#include <VBox/vd.h>
23#include "MediumWrap.h"
24#include "VirtualBoxBase.h"
25#include "AutoCaller.h"
26#include "SecretKeyStore.h"
27class Progress;
28class MediumFormat;
29class MediumLockList;
30struct MediumCryptoFilterSettings;
31
32namespace settings
33{
34 struct Medium;
35}
36
37////////////////////////////////////////////////////////////////////////////////
38
39/**
40 * Medium component class for all media types.
41 */
42class ATL_NO_VTABLE Medium :
43 public MediumWrap
44{
45public:
46 DECLARE_EMPTY_CTOR_DTOR(Medium)
47
48 HRESULT FinalConstruct();
49 void FinalRelease();
50
51 enum HDDOpenMode { OpenReadWrite, OpenReadOnly };
52 // have to use a special enum for the overloaded init() below;
53 // can't use AccessMode_T from XIDL because that's mapped to an int
54 // and would be ambiguous
55
56 // public initializer/uninitializer for internal purposes only
57
58 // initializer to create empty medium (VirtualBox::CreateMedium())
59 HRESULT init(VirtualBox *aVirtualBox,
60 const Utf8Str &aFormat,
61 const Utf8Str &aLocation,
62 const Guid &uuidMachineRegistry,
63 const DeviceType_T aDeviceType);
64
65 // initializer for opening existing media
66 // (VirtualBox::OpenMedium(); Machine::AttachDevice())
67 HRESULT init(VirtualBox *aVirtualBox,
68 const Utf8Str &aLocation,
69 HDDOpenMode enOpenMode,
70 bool fForceNewUuid,
71 DeviceType_T aDeviceType);
72
73 // initializer used when loading settings
74 HRESULT initOne(Medium *aParent,
75 DeviceType_T aDeviceType,
76 const Guid &uuidMachineRegistry,
77 const settings::Medium &data,
78 const Utf8Str &strMachineFolder);
79 HRESULT init(VirtualBox *aVirtualBox,
80 Medium *aParent,
81 DeviceType_T aDeviceType,
82 const Guid &uuidMachineRegistry,
83 const settings::Medium &data,
84 const Utf8Str &strMachineFolder,
85 AutoWriteLock &mediaTreeLock);
86
87 // initializer for host floppy/DVD
88 HRESULT init(VirtualBox *aVirtualBox,
89 DeviceType_T aDeviceType,
90 const Utf8Str &aLocation,
91 const Utf8Str &aDescription = Utf8Str::Empty);
92
93 void uninit();
94
95 void i_deparent();
96 void i_setParent(const ComObjPtr<Medium> &pParent);
97
98 // unsafe methods for internal purposes only (ensure there is
99 // a caller and a read lock before calling them!)
100 const ComObjPtr<Medium>& i_getParent() const;
101 const MediaList& i_getChildren() const;
102
103 const Guid& i_getId() const;
104 MediumState_T i_getState() const;
105 MediumVariant_T i_getVariant() const;
106 bool i_isHostDrive() const;
107 const Utf8Str& i_getLocationFull() const;
108 const Utf8Str& i_getFormat() const;
109 const ComObjPtr<MediumFormat> & i_getMediumFormat() const;
110 bool i_isMediumFormatFile() const;
111 uint64_t i_getSize() const;
112 uint64_t i_getLogicalSize() const;
113 DeviceType_T i_getDeviceType() const;
114 MediumType_T i_getType() const;
115 Utf8Str i_getName();
116
117 /* handles caller/locking itself */
118 bool i_addRegistry(const Guid &id);
119 /* handles caller/locking itself, caller is responsible for tree lock */
120 bool i_addRegistryRecursive(const Guid &id);
121 /* handles caller/locking itself */
122 bool i_removeRegistry(const Guid& id);
123 /* handles caller/locking itself, caller is responsible for tree lock */
124 bool i_removeRegistryRecursive(const Guid& id);
125 bool i_isInRegistry(const Guid& id);
126 bool i_getFirstRegistryMachineId(Guid &uuid) const;
127 void i_markRegistriesModified();
128
129 HRESULT i_setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue);
130
131 HRESULT i_addBackReference(const Guid &aMachineId,
132 const Guid &aSnapshotId = Guid::Empty);
133 HRESULT i_removeBackReference(const Guid &aMachineId,
134 const Guid &aSnapshotId = Guid::Empty);
135
136
137 const Guid* i_getFirstMachineBackrefId() const;
138 const Guid* i_getAnyMachineBackref() const;
139 const Guid* i_getFirstMachineBackrefSnapshotId() const;
140 size_t i_getMachineBackRefCount() const;
141
142#ifdef DEBUG
143 void i_dumpBackRefs();
144#endif
145
146 HRESULT i_updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
147
148 /* handles caller/locking itself */
149 ComObjPtr<Medium> i_getBase(uint32_t *aLevel = NULL);
150 /* handles caller/locking itself */
151 uint32_t i_getDepth();
152
153 bool i_isReadOnly();
154 void i_updateId(const Guid &id);
155
156 void i_saveSettingsOne(settings::Medium &data,
157 const Utf8Str &strHardDiskFolder);
158 HRESULT i_saveSettings(settings::Medium &data,
159 const Utf8Str &strHardDiskFolder);
160
161 HRESULT i_createMediumLockList(bool fFailIfInaccessible,
162 Medium *pToLock,
163 bool fMediumLockWriteAll,
164 Medium *pToBeParent,
165 MediumLockList &mediumLockList);
166
167 HRESULT i_createDiffStorage(ComObjPtr<Medium> &aTarget,
168 MediumVariant_T aVariant,
169 MediumLockList *pMediumLockList,
170 ComObjPtr<Progress> *aProgress,
171 bool aWait,
172 bool aNotify);
173 Utf8Str i_getPreferredDiffFormat();
174 MediumVariant_T i_getPreferredDiffVariant();
175
176 HRESULT i_close(AutoCaller &autoCaller);
177 HRESULT i_unlockRead(MediumState_T *aState);
178 HRESULT i_unlockWrite(MediumState_T *aState);
179 HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait, bool aNotify);
180 HRESULT i_markForDeletion();
181 HRESULT i_unmarkForDeletion();
182 HRESULT i_markLockedForDeletion();
183 HRESULT i_unmarkLockedForDeletion();
184
185 HRESULT i_queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
186 bool &fMergeForward);
187
188 HRESULT i_prepareMergeTo(const ComObjPtr<Medium> &pTarget,
189 const Guid *aMachineId,
190 const Guid *aSnapshotId,
191 bool fLockMedia,
192 bool &fMergeForward,
193 ComObjPtr<Medium> &pParentForTarget,
194 MediumLockList * &aChildrenToReparent,
195 MediumLockList * &aMediumLockList);
196 HRESULT i_mergeTo(const ComObjPtr<Medium> &pTarget,
197 bool fMergeForward,
198 const ComObjPtr<Medium> &pParentForTarget,
199 MediumLockList *aChildrenToReparent,
200 MediumLockList *aMediumLockList,
201 ComObjPtr<Progress> *aProgress,
202 bool aWait,
203 bool aNotify);
204 void i_cancelMergeTo(MediumLockList *aChildrenToReparent,
205 MediumLockList *aMediumLockList);
206
207 HRESULT i_resize(LONG64 aLogicalSize,
208 MediumLockList *aMediumLockList,
209 ComObjPtr<Progress> *aProgress,
210 bool aWait,
211 bool aNotify);
212
213 HRESULT i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
214
215 HRESULT i_addRawToFss(const char *aFilename, SecretKeyStore *pKeyStore, RTVFSFSSTREAM hVfsFssDst,
216 const ComObjPtr<Progress> &aProgress, bool fSparse);
217
218 HRESULT i_exportFile(const char *aFilename,
219 const ComObjPtr<MediumFormat> &aFormat,
220 MediumVariant_T aVariant,
221 SecretKeyStore *pKeyStore,
222 RTVFSIOSTREAM hVfsIosDst,
223 const ComObjPtr<Progress> &aProgress);
224 HRESULT i_importFile(const char *aFilename,
225 const ComObjPtr<MediumFormat> &aFormat,
226 MediumVariant_T aVariant,
227 RTVFSIOSTREAM hVfsIosSrc,
228 const ComObjPtr<Medium> &aParent,
229 const ComObjPtr<Progress> &aProgress,
230 bool aNotify);
231
232 HRESULT i_cloneToEx(const ComObjPtr<Medium> &aTarget, MediumVariant_T aVariant,
233 const ComObjPtr<Medium> &aParent, IProgress **aProgress,
234 uint32_t idxSrcImageSame, uint32_t idxDstImageSame, bool aNotify);
235
236 const Utf8Str& i_getKeyId();
237
238 HRESULT i_openForIO(bool fWritable, SecretKeyStore *pKeyStore, PVDISK *ppHdd, MediumLockList *pMediumLockList,
239 struct MediumCryptoFilterSettings *pCryptoSettings);
240
241private:
242
243 // wrapped IMedium properties
244 HRESULT getId(com::Guid &aId);
245 HRESULT getDescription(AutoCaller &autoCaller, com::Utf8Str &aDescription);
246 HRESULT setDescription(AutoCaller &autoCaller, const com::Utf8Str &aDescription);
247 HRESULT getState(MediumState_T *aState);
248 HRESULT getVariant(std::vector<MediumVariant_T> &aVariant);
249 HRESULT getLocation(com::Utf8Str &aLocation);
250 HRESULT setLocation(const com::Utf8Str &aLocation);
251 HRESULT getName(com::Utf8Str &aName);
252 HRESULT getDeviceType(DeviceType_T *aDeviceType);
253 HRESULT getHostDrive(BOOL *aHostDrive);
254 HRESULT getSize(LONG64 *aSize);
255 HRESULT getFormat(com::Utf8Str &aFormat);
256 HRESULT getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat);
257 HRESULT getType(AutoCaller &autoCaller, MediumType_T *aType);
258 HRESULT setType(AutoCaller &autoCaller, MediumType_T aType);
259 HRESULT getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes);
260 HRESULT getParent(AutoCaller &autoCaller, ComPtr<IMedium> &aParent);
261 HRESULT getChildren(AutoCaller &autoCaller, std::vector<ComPtr<IMedium> > &aChildren);
262 HRESULT getBase(AutoCaller &autoCaller, ComPtr<IMedium> &aBase);
263 HRESULT getReadOnly(AutoCaller &autoCaller, BOOL *aReadOnly);
264 HRESULT getLogicalSize(LONG64 *aLogicalSize);
265 HRESULT getAutoReset(BOOL *aAutoReset);
266 HRESULT setAutoReset(BOOL aAutoReset);
267 HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
268 HRESULT getMachineIds(std::vector<com::Guid> &aMachineIds);
269
270 // wrapped IMedium methods
271 HRESULT setIds(AutoCaller &aAutoCaller,
272 BOOL aSetImageId,
273 const com::Guid &aImageId,
274 BOOL aSetParentId,
275 const com::Guid &aParentId);
276 HRESULT refreshState(AutoCaller &aAutoCaller,
277 MediumState_T *aState);
278 HRESULT getSnapshotIds(const com::Guid &aMachineId,
279 std::vector<com::Guid> &aSnapshotIds);
280 HRESULT lockRead(ComPtr<IToken> &aToken);
281 HRESULT lockWrite(ComPtr<IToken> &aToken);
282 HRESULT close(AutoCaller &aAutoCaller);
283 HRESULT getProperty(const com::Utf8Str &aName,
284 com::Utf8Str &aValue);
285 HRESULT setProperty(const com::Utf8Str &aName,
286 const com::Utf8Str &aValue);
287 HRESULT getProperties(const com::Utf8Str &aNames,
288 std::vector<com::Utf8Str> &aReturnNames,
289 std::vector<com::Utf8Str> &aReturnValues);
290 HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
291 const std::vector<com::Utf8Str> &aValues);
292 HRESULT createBaseStorage(LONG64 aLogicalSize,
293 const std::vector<MediumVariant_T> &aVariant,
294 ComPtr<IProgress> &aProgress);
295 HRESULT deleteStorage(ComPtr<IProgress> &aProgress);
296 HRESULT createDiffStorage(AutoCaller &autoCaller,
297 const ComPtr<IMedium> &aTarget,
298 const std::vector<MediumVariant_T> &aVariant,
299 ComPtr<IProgress> &aProgress);
300 HRESULT mergeTo(const ComPtr<IMedium> &aTarget,
301 ComPtr<IProgress> &aProgress);
302 HRESULT cloneTo(const ComPtr<IMedium> &aTarget,
303 const std::vector<MediumVariant_T> &aVariant,
304 const ComPtr<IMedium> &aParent,
305 ComPtr<IProgress> &aProgress);
306 HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
307 const std::vector<MediumVariant_T> &aVariant,
308 ComPtr<IProgress> &aProgress);
309 HRESULT moveTo(AutoCaller &autoCaller,
310 const com::Utf8Str &aLocation,
311 ComPtr<IProgress> &aProgress);
312 HRESULT compact(ComPtr<IProgress> &aProgress);
313 HRESULT resize(LONG64 aLogicalSize,
314 ComPtr<IProgress> &aProgress);
315 HRESULT reset(AutoCaller &autoCaller, ComPtr<IProgress> &aProgress);
316 HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword, const com::Utf8Str &aCipher,
317 const com::Utf8Str &aNewPassword, const com::Utf8Str &aNewPasswordId,
318 ComPtr<IProgress> &aProgress);
319 HRESULT getEncryptionSettings(AutoCaller &autoCaller, com::Utf8Str &aCipher, com::Utf8Str &aPasswordId);
320 HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword);
321 HRESULT openForIO(BOOL aWritable, com::Utf8Str const &aPassword, ComPtr<IMediumIO> &aMediumIO);
322
323 // Private internal nmethods
324 HRESULT i_queryInfo(bool fSetImageId, bool fSetParentId, AutoCaller &autoCaller);
325 HRESULT i_canClose();
326 HRESULT i_unregisterWithVirtualBox();
327 HRESULT i_setStateError();
328 HRESULT i_setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
329 HRESULT i_setFormat(const Utf8Str &aFormat);
330 VDTYPE i_convertDeviceType();
331 DeviceType_T i_convertToDeviceType(VDTYPE enmType);
332 Utf8Str i_vdError(int aVRC);
333
334 bool i_isPropertyForFilter(const com::Utf8Str &aName);
335
336 HRESULT i_getFilterProperties(std::vector<com::Utf8Str> &aReturnNames,
337 std::vector<com::Utf8Str> &aReturnValues);
338
339 HRESULT i_preparationForMoving(const Utf8Str &aLocation);
340 bool i_isMoveOperation(const ComObjPtr<Medium> &pTarget) const;
341 bool i_resetMoveOperationData();
342 Utf8Str i_getNewLocationForMoving() const;
343
344 static DECLCALLBACK(void) i_vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
345 const char *pszFormat, va_list va);
346 static DECLCALLBACK(bool) i_vdConfigAreKeysValid(void *pvUser,
347 const char *pszzValid);
348 static DECLCALLBACK(int) i_vdConfigQuerySize(void *pvUser, const char *pszName,
349 size_t *pcbValue);
350 static DECLCALLBACK(int) i_vdConfigQuery(void *pvUser, const char *pszName,
351 char *pszValue, size_t cchValue);
352 static DECLCALLBACK(int) i_vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock);
353 static DECLCALLBACK(int) i_vdTcpSocketDestroy(VDSOCKET Sock);
354 static DECLCALLBACK(int) i_vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort,
355 RTMSINTERVAL cMillies);
356 static DECLCALLBACK(int) i_vdTcpClientClose(VDSOCKET Sock);
357 static DECLCALLBACK(bool) i_vdTcpIsClientConnected(VDSOCKET Sock);
358 static DECLCALLBACK(int) i_vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies);
359 static DECLCALLBACK(int) i_vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead);
360 static DECLCALLBACK(int) i_vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer);
361 static DECLCALLBACK(int) i_vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf);
362 static DECLCALLBACK(int) i_vdTcpFlush(VDSOCKET Sock);
363 static DECLCALLBACK(int) i_vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable);
364 static DECLCALLBACK(int) i_vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr);
365 static DECLCALLBACK(int) i_vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr);
366
367 static DECLCALLBACK(bool) i_vdCryptoConfigAreKeysValid(void *pvUser,
368 const char *pszzValid);
369 static DECLCALLBACK(int) i_vdCryptoConfigQuerySize(void *pvUser, const char *pszName,
370 size_t *pcbValue);
371 static DECLCALLBACK(int) i_vdCryptoConfigQuery(void *pvUser, const char *pszName,
372 char *pszValue, size_t cchValue);
373
374 static DECLCALLBACK(int) i_vdCryptoKeyRetain(void *pvUser, const char *pszId,
375 const uint8_t **ppbKey, size_t *pcbKey);
376 static DECLCALLBACK(int) i_vdCryptoKeyRelease(void *pvUser, const char *pszId);
377 static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRetain(void *pvUser, const char *pszId, const char **ppszPassword);
378 static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRelease(void *pvUser, const char *pszId);
379 static DECLCALLBACK(int) i_vdCryptoKeyStoreSave(void *pvUser, const void *pvKeyStore, size_t cbKeyStore);
380 static DECLCALLBACK(int) i_vdCryptoKeyStoreReturnParameters(void *pvUser, const char *pszCipher,
381 const uint8_t *pbDek, size_t cbDek);
382
383 class Task;
384 class CreateBaseTask;
385 class CreateDiffTask;
386 class CloneTask;
387 class MoveTask;
388 class CompactTask;
389 class ResizeTask;
390 class ResetTask;
391 class DeleteTask;
392 class MergeTask;
393 class ImportTask;
394 class EncryptTask;
395 friend class Task;
396 friend class CreateBaseTask;
397 friend class CreateDiffTask;
398 friend class CloneTask;
399 friend class MoveTask;
400 friend class CompactTask;
401 friend class ResizeTask;
402 friend class ResetTask;
403 friend class DeleteTask;
404 friend class MergeTask;
405 friend class ImportTask;
406 friend class EncryptTask;
407
408 HRESULT i_taskCreateBaseHandler(Medium::CreateBaseTask &task);
409 HRESULT i_taskCreateDiffHandler(Medium::CreateDiffTask &task);
410 HRESULT i_taskMergeHandler(Medium::MergeTask &task);
411 HRESULT i_taskCloneHandler(Medium::CloneTask &task);
412 HRESULT i_taskMoveHandler(Medium::MoveTask &task);
413 HRESULT i_taskDeleteHandler(Medium::DeleteTask &task);
414 HRESULT i_taskResetHandler(Medium::ResetTask &task);
415 HRESULT i_taskCompactHandler(Medium::CompactTask &task);
416 HRESULT i_taskResizeHandler(Medium::ResizeTask &task);
417 HRESULT i_taskImportHandler(Medium::ImportTask &task);
418 HRESULT i_taskEncryptHandler(Medium::EncryptTask &task);
419
420 void i_taskEncryptSettingsSetup(struct MediumCryptoFilterSettings *pSettings, const char *pszCipher,
421 const char *pszKeyStore, const char *pszPassword,
422 bool fCreateKeyStore);
423
424 struct Data; // opaque data struct, defined in MediumImpl.cpp
425 Data *m;
426};
427
428
429/**
430 * Settings for a crypto filter instance.
431 */
432struct MediumCryptoFilterSettings
433{
434 MediumCryptoFilterSettings()
435 : fCreateKeyStore(false),
436 pszPassword(NULL),
437 pszKeyStore(NULL),
438 pszKeyStoreLoad(NULL),
439 pbDek(NULL),
440 cbDek(0),
441 pszCipher(NULL),
442 pszCipherReturned(NULL)
443 { }
444
445 bool fCreateKeyStore;
446 const char *pszPassword;
447 char *pszKeyStore;
448 const char *pszKeyStoreLoad;
449
450 const uint8_t *pbDek;
451 size_t cbDek;
452 const char *pszCipher;
453
454 /** The cipher returned by the crypto filter. */
455 char *pszCipherReturned;
456
457 PVDINTERFACE vdFilterIfaces;
458
459 VDINTERFACECONFIG vdIfCfg;
460 VDINTERFACECRYPTO vdIfCrypto;
461};
462
463
464
465#endif /* !____H_MEDIUMIMPL */
466
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette