VirtualBox

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

Last change on this file since 54948 was 54948, checked in by vboxsync, 10 years ago

Main/Medium+Snapshot: make all code recursing over trees (objects containing lists of child objects) use as little stack as possible, and establish safe depth limits to avoid crashes, plus related cleanups in related code areas
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.5 KB
Line 
1/* $Id: MediumImpl.h 54948 2015-03-25 16:56:48Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2008-2015 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"
26class Progress;
27class MediumFormat;
28class MediumLockList;
29
30namespace settings
31{
32 struct Medium;
33}
34
35////////////////////////////////////////////////////////////////////////////////
36
37/**
38 * Medium component class for all media types.
39 */
40class ATL_NO_VTABLE Medium :
41 public MediumWrap
42{
43public:
44 DECLARE_EMPTY_CTOR_DTOR(Medium)
45
46 HRESULT FinalConstruct();
47 void FinalRelease();
48
49 enum HDDOpenMode { OpenReadWrite, OpenReadOnly };
50 // have to use a special enum for the overloaded init() below;
51 // can't use AccessMode_T from XIDL because that's mapped to an int
52 // and would be ambiguous
53
54 // public initializer/uninitializer for internal purposes only
55
56 // initializer to create empty medium (VirtualBox::CreateMedium())
57 HRESULT init(VirtualBox *aVirtualBox,
58 const Utf8Str &aFormat,
59 const Utf8Str &aLocation,
60 const Guid &uuidMachineRegistry,
61 const DeviceType_T aDeviceType);
62
63 // initializer for opening existing media
64 // (VirtualBox::OpenMedium(); Machine::AttachDevice())
65 HRESULT init(VirtualBox *aVirtualBox,
66 const Utf8Str &aLocation,
67 HDDOpenMode enOpenMode,
68 bool fForceNewUuid,
69 DeviceType_T aDeviceType);
70
71 // initializer used when loading settings
72 HRESULT initOne(Medium *aParent,
73 DeviceType_T aDeviceType,
74 const Guid &uuidMachineRegistry,
75 const settings::Medium &data,
76 const Utf8Str &strMachineFolder);
77 HRESULT init(VirtualBox *aVirtualBox,
78 Medium *aParent,
79 DeviceType_T aDeviceType,
80 const Guid &uuidMachineRegistry,
81 const settings::Medium &data,
82 const Utf8Str &strMachineFolder,
83 AutoWriteLock &mediaTreeLock);
84
85 // initializer for host floppy/DVD
86 HRESULT init(VirtualBox *aVirtualBox,
87 DeviceType_T aDeviceType,
88 const Utf8Str &aLocation,
89 const Utf8Str &aDescription = Utf8Str::Empty);
90
91 void uninit();
92
93 void i_deparent();
94 void i_setParent(const ComObjPtr<Medium> &pParent);
95
96 // unsafe methods for internal purposes only (ensure there is
97 // a caller and a read lock before calling them!)
98 const ComObjPtr<Medium>& i_getParent() const;
99 const MediaList& i_getChildren() const;
100
101 const Guid& i_getId() const;
102 MediumState_T i_getState() const;
103 MediumVariant_T i_getVariant() const;
104 bool i_isHostDrive() const;
105 const Utf8Str& i_getLocationFull() const;
106 const Utf8Str& i_getFormat() const;
107 const ComObjPtr<MediumFormat> & i_getMediumFormat() const;
108 bool i_isMediumFormatFile() const;
109 uint64_t i_getSize() const;
110 DeviceType_T i_getDeviceType() const;
111 MediumType_T i_getType() const;
112 Utf8Str i_getName();
113
114 /* handles caller/locking itself */
115 bool i_addRegistry(const Guid &id);
116 /* handles caller/locking itself, caller is responsible for tree lock */
117 bool i_addRegistryRecursive(const Guid &id);
118 /* handles caller/locking itself */
119 bool i_removeRegistry(const Guid& id);
120 /* handles caller/locking itself, caller is responsible for tree lock */
121 bool i_removeRegistryRecursive(const Guid& id);
122 bool i_isInRegistry(const Guid& id);
123 bool i_getFirstRegistryMachineId(Guid &uuid) const;
124 void i_markRegistriesModified();
125
126 HRESULT i_setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue);
127
128 HRESULT i_addBackReference(const Guid &aMachineId,
129 const Guid &aSnapshotId = Guid::Empty);
130 HRESULT i_removeBackReference(const Guid &aMachineId,
131 const Guid &aSnapshotId = Guid::Empty);
132
133
134 const Guid* i_getFirstMachineBackrefId() const;
135 const Guid* i_getAnyMachineBackref() const;
136 const Guid* i_getFirstMachineBackrefSnapshotId() const;
137 size_t i_getMachineBackRefCount() const;
138
139#ifdef DEBUG
140 void i_dumpBackRefs();
141#endif
142
143 HRESULT i_updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
144
145 /* handles caller/locking itself */
146 ComObjPtr<Medium> i_getBase(uint32_t *aLevel = NULL);
147 /* handles caller/locking itself */
148 uint32_t i_getDepth();
149
150 bool i_isReadOnly();
151 void i_updateId(const Guid &id);
152
153 void i_saveSettingsOne(settings::Medium &data,
154 const Utf8Str &strHardDiskFolder);
155 HRESULT i_saveSettings(settings::Medium &data,
156 const Utf8Str &strHardDiskFolder);
157
158 HRESULT i_createMediumLockList(bool fFailIfInaccessible,
159 bool fMediumLockWrite,
160 bool fMediumLockWriteAll,
161 Medium *pToBeParent,
162 MediumLockList &mediumLockList);
163
164 HRESULT i_createDiffStorage(ComObjPtr<Medium> &aTarget,
165 MediumVariant_T aVariant,
166 MediumLockList *pMediumLockList,
167 ComObjPtr<Progress> *aProgress,
168 bool aWait);
169 Utf8Str i_getPreferredDiffFormat();
170
171 HRESULT i_close(AutoCaller &autoCaller);
172 HRESULT i_unlockRead(MediumState_T *aState);
173 HRESULT i_unlockWrite(MediumState_T *aState);
174 HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait);
175 HRESULT i_markForDeletion();
176 HRESULT i_unmarkForDeletion();
177 HRESULT i_markLockedForDeletion();
178 HRESULT i_unmarkLockedForDeletion();
179
180 HRESULT i_queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
181 bool &fMergeForward);
182
183 HRESULT i_prepareMergeTo(const ComObjPtr<Medium> &pTarget,
184 const Guid *aMachineId,
185 const Guid *aSnapshotId,
186 bool fLockMedia,
187 bool &fMergeForward,
188 ComObjPtr<Medium> &pParentForTarget,
189 MediumLockList * &aChildrenToReparent,
190 MediumLockList * &aMediumLockList);
191 HRESULT i_mergeTo(const ComObjPtr<Medium> &pTarget,
192 bool fMergeForward,
193 const ComObjPtr<Medium> &pParentForTarget,
194 MediumLockList *aChildrenToReparent,
195 MediumLockList *aMediumLockList,
196 ComObjPtr<Progress> *aProgress,
197 bool aWait);
198 void i_cancelMergeTo(MediumLockList *aChildrenToReparent,
199 MediumLockList *aMediumLockList);
200
201 HRESULT i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
202
203 HRESULT i_exportFile(const char *aFilename,
204 const ComObjPtr<MediumFormat> &aFormat,
205 MediumVariant_T aVariant,
206 PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
207 const ComObjPtr<Progress> &aProgress);
208 HRESULT i_importFile(const char *aFilename,
209 const ComObjPtr<MediumFormat> &aFormat,
210 MediumVariant_T aVariant,
211 PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
212 const ComObjPtr<Medium> &aParent,
213 const ComObjPtr<Progress> &aProgress);
214
215 HRESULT i_cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
216 const ComObjPtr<Medium> &aParent, IProgress **aProgress,
217 uint32_t idxSrcImageSame, uint32_t idxDstImageSame);
218
219private:
220
221 // wrapped IMedium properties
222 HRESULT getId(com::Guid &aId);
223 HRESULT getDescription(com::Utf8Str &aDescription);
224 HRESULT setDescription(const com::Utf8Str &aDescription);
225 HRESULT getState(MediumState_T *aState);
226 HRESULT getVariant(std::vector<MediumVariant_T> &aVariant);
227 HRESULT getLocation(com::Utf8Str &aLocation);
228 HRESULT getName(com::Utf8Str &aName);
229 HRESULT getDeviceType(DeviceType_T *aDeviceType);
230 HRESULT getHostDrive(BOOL *aHostDrive);
231 HRESULT getSize(LONG64 *aSize);
232 HRESULT getFormat(com::Utf8Str &aFormat);
233 HRESULT getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat);
234 HRESULT getType(MediumType_T *aType);
235 HRESULT setType(MediumType_T aType);
236 HRESULT getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes);
237 HRESULT getParent(AutoCaller &autoCaller, ComPtr<IMedium> &aParent);
238 HRESULT getChildren(AutoCaller &autoCaller, std::vector<ComPtr<IMedium> > &aChildren);
239 HRESULT getBase(AutoCaller &autoCaller, ComPtr<IMedium> &aBase);
240 HRESULT getReadOnly(BOOL *aReadOnly);
241 HRESULT getLogicalSize(LONG64 *aLogicalSize);
242 HRESULT getAutoReset(BOOL *aAutoReset);
243 HRESULT setAutoReset(BOOL aAutoReset);
244 HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
245 HRESULT getMachineIds(std::vector<com::Guid> &aMachineIds);
246
247 // wrapped IMedium methods
248 HRESULT setIds(AutoCaller &aAutoCaller,
249 BOOL aSetImageId,
250 const com::Guid &aImageId,
251 BOOL aSetParentId,
252 const com::Guid &aParentId);
253 HRESULT refreshState(AutoCaller &aAutoCaller,
254 MediumState_T *aState);
255 HRESULT getSnapshotIds(const com::Guid &aMachineId,
256 std::vector<com::Guid> &aSnapshotIds);
257 HRESULT lockRead(ComPtr<IToken> &aToken);
258 HRESULT lockWrite(ComPtr<IToken> &aToken);
259 HRESULT close(AutoCaller &aAutoCaller);
260 HRESULT getProperty(const com::Utf8Str &aName,
261 com::Utf8Str &aValue);
262 HRESULT setProperty(const com::Utf8Str &aName,
263 const com::Utf8Str &aValue);
264 HRESULT getProperties(const com::Utf8Str &aNames,
265 std::vector<com::Utf8Str> &aReturnNames,
266 std::vector<com::Utf8Str> &aReturnValues);
267 HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
268 const std::vector<com::Utf8Str> &aValues);
269 HRESULT createBaseStorage(LONG64 aLogicalSize,
270 const std::vector<MediumVariant_T> &aVariant,
271 ComPtr<IProgress> &aProgress);
272 HRESULT deleteStorage(ComPtr<IProgress> &aProgress);
273 HRESULT createDiffStorage(const ComPtr<IMedium> &aTarget,
274 const std::vector<MediumVariant_T> &aVariant,
275 ComPtr<IProgress> &aProgress);
276 HRESULT mergeTo(const ComPtr<IMedium> &aTarget,
277 ComPtr<IProgress> &aProgress);
278 HRESULT cloneTo(const ComPtr<IMedium> &aTarget,
279 const std::vector<MediumVariant_T> &aVariant,
280 const ComPtr<IMedium> &aParent,
281 ComPtr<IProgress> &aProgress);
282 HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
283 const std::vector<MediumVariant_T> &aVariant,
284 ComPtr<IProgress> &aProgress);
285 HRESULT setLocation(const com::Utf8Str &aLocation,
286 ComPtr<IProgress> &aProgress);
287 HRESULT compact(ComPtr<IProgress> &aProgress);
288 HRESULT resize(LONG64 aLogicalSize,
289 ComPtr<IProgress> &aProgress);
290 HRESULT reset(ComPtr<IProgress> &aProgress);
291 HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword, const com::Utf8Str &aCipher,
292 const com::Utf8Str &aNewPassword, const com::Utf8Str &aNewPasswordId,
293 ComPtr<IProgress> &aProgress);
294 HRESULT getEncryptionSettings(com::Utf8Str &aCipher, com::Utf8Str &aPasswordId);
295 HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword);
296
297 // Private internal nmethods
298 HRESULT i_queryInfo(bool fSetImageId, bool fSetParentId, AutoCaller &autoCaller);
299 HRESULT i_canClose();
300 HRESULT i_unregisterWithVirtualBox();
301 HRESULT i_setStateError();
302 HRESULT i_setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
303 HRESULT i_setFormat(const Utf8Str &aFormat);
304 VDTYPE i_convertDeviceType();
305 DeviceType_T i_convertToDeviceType(VDTYPE enmType);
306 Utf8Str i_vdError(int aVRC);
307
308 bool i_isPropertyForFilter(const com::Utf8Str &aName);
309
310 static DECLCALLBACK(void) i_vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
311 const char *pszFormat, va_list va);
312 static DECLCALLBACK(bool) i_vdConfigAreKeysValid(void *pvUser,
313 const char *pszzValid);
314 static DECLCALLBACK(int) i_vdConfigQuerySize(void *pvUser, const char *pszName,
315 size_t *pcbValue);
316 static DECLCALLBACK(int) i_vdConfigQuery(void *pvUser, const char *pszName,
317 char *pszValue, size_t cchValue);
318 static DECLCALLBACK(int) i_vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock);
319 static DECLCALLBACK(int) i_vdTcpSocketDestroy(VDSOCKET Sock);
320 static DECLCALLBACK(int) i_vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort,
321 RTMSINTERVAL cMillies);
322 static DECLCALLBACK(int) i_vdTcpClientClose(VDSOCKET Sock);
323 static DECLCALLBACK(bool) i_vdTcpIsClientConnected(VDSOCKET Sock);
324 static DECLCALLBACK(int) i_vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies);
325 static DECLCALLBACK(int) i_vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead);
326 static DECLCALLBACK(int) i_vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer);
327 static DECLCALLBACK(int) i_vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf);
328 static DECLCALLBACK(int) i_vdTcpFlush(VDSOCKET Sock);
329 static DECLCALLBACK(int) i_vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable);
330 static DECLCALLBACK(int) i_vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr);
331 static DECLCALLBACK(int) i_vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr);
332
333 static DECLCALLBACK(bool) i_vdCryptoConfigAreKeysValid(void *pvUser,
334 const char *pszzValid);
335 static DECLCALLBACK(int) i_vdCryptoConfigQuerySize(void *pvUser, const char *pszName,
336 size_t *pcbValue);
337 static DECLCALLBACK(int) i_vdCryptoConfigQuery(void *pvUser, const char *pszName,
338 char *pszValue, size_t cchValue);
339
340 static DECLCALLBACK(int) i_vdCryptoKeyRetain(void *pvUser, const char *pszId,
341 const uint8_t **ppbKey, size_t *pcbKey);
342 static DECLCALLBACK(int) i_vdCryptoKeyRelease(void *pvUser, const char *pszId);
343 static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRetain(void *pvUser, const char *pszId, const char **ppszPassword);
344 static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRelease(void *pvUser, const char *pszId);
345 static DECLCALLBACK(int) i_vdCryptoKeyStoreSave(void *pvUser, const void *pvKeyStore, size_t cbKeyStore);
346 static DECLCALLBACK(int) i_vdCryptoKeyStoreReturnParameters(void *pvUser, const char *pszCipher,
347 const uint8_t *pbDek, size_t cbDek);
348
349 class Task;
350 class CreateBaseTask;
351 class CreateDiffTask;
352 class CloneTask;
353 class CompactTask;
354 class ResizeTask;
355 class ResetTask;
356 class DeleteTask;
357 class MergeTask;
358 class ExportTask;
359 class ImportTask;
360 class EncryptTask;
361 friend class Task;
362 friend class CreateBaseTask;
363 friend class CreateDiffTask;
364 friend class CloneTask;
365 friend class CompactTask;
366 friend class ResizeTask;
367 friend class ResetTask;
368 friend class DeleteTask;
369 friend class MergeTask;
370 friend class ExportTask;
371 friend class ImportTask;
372 friend class EncryptTask;
373
374 HRESULT i_startThread(Medium::Task *pTask);
375 HRESULT i_runNow(Medium::Task *pTask);
376
377 HRESULT i_taskCreateBaseHandler(Medium::CreateBaseTask &task);
378 HRESULT i_taskCreateDiffHandler(Medium::CreateDiffTask &task);
379 HRESULT i_taskMergeHandler(Medium::MergeTask &task);
380 HRESULT i_taskCloneHandler(Medium::CloneTask &task);
381 HRESULT i_taskDeleteHandler(Medium::DeleteTask &task);
382 HRESULT i_taskResetHandler(Medium::ResetTask &task);
383 HRESULT i_taskCompactHandler(Medium::CompactTask &task);
384 HRESULT i_taskResizeHandler(Medium::ResizeTask &task);
385 HRESULT i_taskExportHandler(Medium::ExportTask &task);
386 HRESULT i_taskImportHandler(Medium::ImportTask &task);
387 HRESULT i_taskEncryptHandler(Medium::EncryptTask &task);
388
389 struct CryptoFilterSettings;
390 void i_taskEncryptSettingsSetup(CryptoFilterSettings *pSettings, const char *pszCipher,
391 const char *pszKeyStore, const char *pszPassword,
392 bool fCreateKeyStore);
393
394 struct Data; // opaque data struct, defined in MediumImpl.cpp
395 Data *m;
396};
397
398#endif /* ____H_MEDIUMIMPL */
399
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