1 | /* $Id: HardDiskImpl.h 6173 2007-12-21 18:57:02Z vboxsync $ */
|
---|
2 |
|
---|
3 | /** @file
|
---|
4 | *
|
---|
5 | * VirtualBox COM class implementation
|
---|
6 | */
|
---|
7 |
|
---|
8 | /*
|
---|
9 | * Copyright (C) 2006-2007 innotek GmbH
|
---|
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 |
|
---|
20 | #ifndef ____H_HARDDISKIMPL
|
---|
21 | #define ____H_HARDDISKIMPL
|
---|
22 |
|
---|
23 | #include "VirtualBoxBase.h"
|
---|
24 | #include "Collection.h"
|
---|
25 |
|
---|
26 | #include <VBox/VBoxHDD-new.h>
|
---|
27 |
|
---|
28 | #include <iprt/semaphore.h>
|
---|
29 |
|
---|
30 | #include <list>
|
---|
31 |
|
---|
32 | class VirtualBox;
|
---|
33 | class Progress;
|
---|
34 | class HVirtualDiskImage;
|
---|
35 |
|
---|
36 | ////////////////////////////////////////////////////////////////////////////////
|
---|
37 |
|
---|
38 | class ATL_NO_VTABLE HardDisk :
|
---|
39 | public VirtualBoxSupportErrorInfoImpl <HardDisk, IHardDisk>,
|
---|
40 | public VirtualBoxSupportTranslation <HardDisk>,
|
---|
41 | public VirtualBoxBaseWithTypedChildren <HardDisk>,
|
---|
42 | public IHardDisk
|
---|
43 | {
|
---|
44 |
|
---|
45 | public:
|
---|
46 |
|
---|
47 | typedef VirtualBoxBaseWithTypedChildren <HardDisk>::DependentChildren
|
---|
48 | HardDiskList;
|
---|
49 |
|
---|
50 | DECLARE_NOT_AGGREGATABLE(HardDisk)
|
---|
51 |
|
---|
52 | DECLARE_PROTECT_FINAL_CONSTRUCT()
|
---|
53 |
|
---|
54 | BEGIN_COM_MAP(HardDisk)
|
---|
55 | COM_INTERFACE_ENTRY(ISupportErrorInfo)
|
---|
56 | COM_INTERFACE_ENTRY(IHardDisk)
|
---|
57 | END_COM_MAP()
|
---|
58 |
|
---|
59 | NS_DECL_ISUPPORTS
|
---|
60 |
|
---|
61 | HRESULT FinalConstruct();
|
---|
62 | void FinalRelease();
|
---|
63 |
|
---|
64 | protected:
|
---|
65 |
|
---|
66 | // protected initializer/uninitializer for internal purposes only
|
---|
67 | HRESULT protectedInit (VirtualBox *aVirtualBox, HardDisk *aParent);
|
---|
68 | void protectedUninit (AutoLock &alock);
|
---|
69 |
|
---|
70 | public:
|
---|
71 |
|
---|
72 | // IHardDisk properties
|
---|
73 | STDMETHOD(COMGETTER(Id)) (GUIDPARAMOUT aId);
|
---|
74 | STDMETHOD(COMGETTER(StorageType)) (HardDiskStorageType_T *aStorageType);
|
---|
75 | STDMETHOD(COMGETTER(Location)) (BSTR *aLocation);
|
---|
76 | STDMETHOD(COMGETTER(Type)) (HardDiskType_T *aType);
|
---|
77 | STDMETHOD(COMSETTER(Type)) (HardDiskType_T aType);
|
---|
78 | STDMETHOD(COMGETTER(Parent)) (IHardDisk **aParent);
|
---|
79 | STDMETHOD(COMGETTER(Children)) (IHardDiskCollection **aChildren);
|
---|
80 | STDMETHOD(COMGETTER(Root)) (IHardDisk **aRoot);
|
---|
81 | STDMETHOD(COMGETTER(Accessible)) (BOOL *aAccessible);
|
---|
82 | STDMETHOD(COMGETTER(AllAccessible)) (BOOL *aAllAccessible);
|
---|
83 | STDMETHOD(COMGETTER(LastAccessError)) (BSTR *aLastAccessError);
|
---|
84 | STDMETHOD(COMGETTER(MachineId)) (GUIDPARAMOUT aMachineId);
|
---|
85 | STDMETHOD(COMGETTER(SnapshotId)) (GUIDPARAMOUT aSnapshotId);
|
---|
86 |
|
---|
87 | // IHardDisk methods
|
---|
88 | STDMETHOD(CloneToImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage,
|
---|
89 | IProgress **aProgress);
|
---|
90 |
|
---|
91 | // public methods for internal purposes only
|
---|
92 |
|
---|
93 | const Guid &id() const { return mId; }
|
---|
94 | HardDiskStorageType_T storageType() const { return mStorageType; }
|
---|
95 | HardDiskType_T type() const { return mType; }
|
---|
96 | const Guid &machineId() const { return mMachineId; }
|
---|
97 | const Guid &snapshotId() const { return mSnapshotId; }
|
---|
98 |
|
---|
99 | void setMachineId (const Guid &aId) { mMachineId = aId; }
|
---|
100 | void setSnapshotId (const Guid &aId) { mSnapshotId = aId; }
|
---|
101 |
|
---|
102 | bool isDifferencing() const
|
---|
103 | {
|
---|
104 | return mType == HardDiskType_NormalHardDisk &&
|
---|
105 | mStorageType == HardDiskStorageType_VirtualDiskImage &&
|
---|
106 | !mParent.isNull();
|
---|
107 | }
|
---|
108 | bool isParentImmutable() const
|
---|
109 | {
|
---|
110 | AutoLock parentLock (mParent);
|
---|
111 | return !mParent.isNull() && mParent->type() == HardDiskType_ImmutableHardDisk;
|
---|
112 | }
|
---|
113 |
|
---|
114 | inline HVirtualDiskImage *asVDI();
|
---|
115 |
|
---|
116 | ComObjPtr <HardDisk> parent() const { return static_cast <HardDisk *> (mParent); }
|
---|
117 |
|
---|
118 | /** Shortcut to #dependentChildrenLock() */
|
---|
119 | AutoLock::Handle &childrenLock() const { return dependentChildrenLock(); }
|
---|
120 |
|
---|
121 | /**
|
---|
122 | * Shortcut to #dependentChildren().
|
---|
123 | * Do |AutoLock alock (childrenLock());| before acceessing the returned list!
|
---|
124 | */
|
---|
125 | const HardDiskList &children() const { return dependentChildren(); }
|
---|
126 |
|
---|
127 | ComObjPtr <HardDisk> root() const;
|
---|
128 |
|
---|
129 | HRESULT getBaseAccessible (Bstr &aAccessError, bool aCheckBusy = false,
|
---|
130 | bool aCheckReaders = false);
|
---|
131 |
|
---|
132 | // virtual methods that need to be [re]implemented by every subclass
|
---|
133 |
|
---|
134 | virtual HRESULT trySetRegistered (BOOL aRegistered);
|
---|
135 | virtual HRESULT getAccessible (Bstr &aAccessError) = 0;
|
---|
136 |
|
---|
137 | virtual HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode) = 0;
|
---|
138 |
|
---|
139 | virtual void updatePath (const char *aOldPath, const char *aNewPath) {}
|
---|
140 |
|
---|
141 | virtual Bstr toString (bool aShort = false) = 0;
|
---|
142 | virtual bool sameAs (HardDisk *that);
|
---|
143 |
|
---|
144 | virtual HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
145 | Progress *aProgress, bool &aDeleteTarget) = 0;
|
---|
146 | virtual HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
147 | Progress *aProgress) = 0;
|
---|
148 | public:
|
---|
149 |
|
---|
150 | void setBusy();
|
---|
151 | void clearBusy();
|
---|
152 | void addReader();
|
---|
153 | void releaseReader();
|
---|
154 | void addReaderOnAncestors();
|
---|
155 | void releaseReaderOnAncestors();
|
---|
156 | bool hasForeignChildren();
|
---|
157 |
|
---|
158 | HRESULT setBusyWithChildren();
|
---|
159 | void clearBusyWithChildren();
|
---|
160 | HRESULT getAccessibleWithChildren (Bstr &aAccessError);
|
---|
161 |
|
---|
162 | HRESULT checkConsistency();
|
---|
163 |
|
---|
164 | HRESULT createDiffHardDisk (const Bstr &aFolder, const Guid &aMachineId,
|
---|
165 | ComObjPtr <HVirtualDiskImage> &aHardDisk,
|
---|
166 | Progress *aProgress);
|
---|
167 |
|
---|
168 | void updatePaths (const char *aOldPath, const char *aNewPath);
|
---|
169 |
|
---|
170 | /* the following must be called from under the lock */
|
---|
171 | bool isBusy() { isLockedOnCurrentThread(); return mBusy; }
|
---|
172 | unsigned readers() { isLockedOnCurrentThread(); return mReaders; }
|
---|
173 | const Bstr &lastAccessError() const { return mLastAccessError; }
|
---|
174 |
|
---|
175 | static HRESULT openHardDisk (VirtualBox *aVirtualBox, INPTR BSTR aLocation,
|
---|
176 | ComObjPtr <HardDisk> &hardDisk);
|
---|
177 |
|
---|
178 | // for VirtualBoxSupportErrorInfoImpl
|
---|
179 | static const wchar_t *getComponentName() { return L"HardDisk"; }
|
---|
180 |
|
---|
181 | protected:
|
---|
182 |
|
---|
183 | HRESULT loadSettings (const settings::Key &aHDNode);
|
---|
184 | HRESULT saveSettings (settings::Key &aHDNode);
|
---|
185 |
|
---|
186 | /** weak VirualBox parent */
|
---|
187 | ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
|
---|
188 |
|
---|
189 | BOOL mRegistered;
|
---|
190 |
|
---|
191 | ComObjPtr <HardDisk, ComWeakRef> mParent;
|
---|
192 |
|
---|
193 | Guid mId;
|
---|
194 | HardDiskStorageType_T mStorageType;
|
---|
195 | HardDiskType_T mType;
|
---|
196 | Guid mMachineId;
|
---|
197 | Guid mSnapshotId;
|
---|
198 |
|
---|
199 | private:
|
---|
200 |
|
---|
201 | Bstr mLastAccessError;
|
---|
202 |
|
---|
203 | bool mBusy;
|
---|
204 | unsigned mReaders;
|
---|
205 | };
|
---|
206 |
|
---|
207 | ////////////////////////////////////////////////////////////////////////////////
|
---|
208 |
|
---|
209 | class ATL_NO_VTABLE HVirtualDiskImage :
|
---|
210 | public HardDisk,
|
---|
211 | public VirtualBoxSupportTranslation <HVirtualDiskImage>,
|
---|
212 | public IVirtualDiskImage
|
---|
213 | {
|
---|
214 |
|
---|
215 | public:
|
---|
216 |
|
---|
217 | VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HVirtualDiskImage)
|
---|
218 |
|
---|
219 | DECLARE_NOT_AGGREGATABLE(HVirtualDiskImage)
|
---|
220 |
|
---|
221 | DECLARE_PROTECT_FINAL_CONSTRUCT()
|
---|
222 |
|
---|
223 | BEGIN_COM_MAP(HVirtualDiskImage)
|
---|
224 | COM_INTERFACE_ENTRY(ISupportErrorInfo)
|
---|
225 | COM_INTERFACE_ENTRY(IHardDisk)
|
---|
226 | COM_INTERFACE_ENTRY(IVirtualDiskImage)
|
---|
227 | END_COM_MAP()
|
---|
228 |
|
---|
229 | NS_DECL_ISUPPORTS
|
---|
230 |
|
---|
231 | HRESULT FinalConstruct();
|
---|
232 | void FinalRelease();
|
---|
233 |
|
---|
234 | // public initializer/uninitializer for internal purposes only
|
---|
235 |
|
---|
236 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
237 | const settings::Key &aHDNode, const settings::Key &aVDINode);
|
---|
238 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
239 | const BSTR aFilePath, BOOL aRegistered = FALSE);
|
---|
240 | void uninit();
|
---|
241 |
|
---|
242 | // IHardDisk properties
|
---|
243 | STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
|
---|
244 | STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
|
---|
245 | STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
|
---|
246 | STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
|
---|
247 |
|
---|
248 | // IVirtualDiskImage properties
|
---|
249 | STDMETHOD(COMGETTER(FilePath)) (BSTR *aFilePath);
|
---|
250 | STDMETHOD(COMSETTER(FilePath)) (INPTR BSTR aFilePath);
|
---|
251 | STDMETHOD(COMGETTER(Created)) (BOOL *aCreated);
|
---|
252 |
|
---|
253 | // IVirtualDiskImage methods
|
---|
254 | STDMETHOD(CreateDynamicImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
255 | STDMETHOD(CreateFixedImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
256 | STDMETHOD(DeleteImage)();
|
---|
257 |
|
---|
258 | // public methods for internal purposes only
|
---|
259 |
|
---|
260 | const Bstr &filePath() const { return mFilePath; }
|
---|
261 | const Bstr &filePathFull() const { return mFilePathFull; }
|
---|
262 |
|
---|
263 | HRESULT trySetRegistered (BOOL aRegistered);
|
---|
264 | HRESULT getAccessible (Bstr &aAccessError);
|
---|
265 |
|
---|
266 | HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
|
---|
267 |
|
---|
268 | void updatePath (const char *aOldPath, const char *aNewPath);
|
---|
269 |
|
---|
270 | Bstr toString (bool aShort = false);
|
---|
271 |
|
---|
272 | HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
273 | Progress *aProgress, bool &aDeleteTarget);
|
---|
274 | HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
275 | Progress *aProgress);
|
---|
276 |
|
---|
277 | HRESULT cloneDiffImage (const Bstr &aFolder, const Guid &aMachineId,
|
---|
278 | ComObjPtr <HVirtualDiskImage> &aHardDisk,
|
---|
279 | Progress *aProgress);
|
---|
280 |
|
---|
281 | HRESULT mergeImageToParent (Progress *aProgress);
|
---|
282 | HRESULT mergeImageToChildren (Progress *aProgress);
|
---|
283 |
|
---|
284 | HRESULT wipeOutImage();
|
---|
285 | HRESULT deleteImage (bool aIgnoreErrors = false);
|
---|
286 |
|
---|
287 | // for VirtualBoxSupportErrorInfoImpl
|
---|
288 | static const wchar_t *getComponentName() { return L"VirtualDiskImage"; }
|
---|
289 |
|
---|
290 | private:
|
---|
291 |
|
---|
292 | HRESULT setFilePath (const BSTR aFilePath);
|
---|
293 | HRESULT queryInformation (Bstr *aAccessError);
|
---|
294 | HRESULT createImage (ULONG64 aSize, BOOL aDynamic, IProgress **aProgress);
|
---|
295 |
|
---|
296 | /** VDI asynchronous operation thread function */
|
---|
297 | static DECLCALLBACK(int) VDITaskThread (RTTHREAD thread, void *pvUser);
|
---|
298 |
|
---|
299 | enum State
|
---|
300 | {
|
---|
301 | NotCreated,
|
---|
302 | Created,
|
---|
303 | /* the following must be greater than Created */
|
---|
304 | Accessible,
|
---|
305 | };
|
---|
306 |
|
---|
307 | State mState;
|
---|
308 |
|
---|
309 | RTSEMEVENTMULTI mStateCheckSem;
|
---|
310 | ULONG mStateCheckWaiters;
|
---|
311 |
|
---|
312 | Bstr mDescription;
|
---|
313 |
|
---|
314 | ULONG64 mSize;
|
---|
315 | ULONG64 mActualSize;
|
---|
316 |
|
---|
317 | Bstr mFilePath;
|
---|
318 | Bstr mFilePathFull;
|
---|
319 |
|
---|
320 | friend class HardDisk;
|
---|
321 | };
|
---|
322 |
|
---|
323 | // dependent inline members
|
---|
324 | ////////////////////////////////////////////////////////////////////////////////
|
---|
325 |
|
---|
326 | inline HVirtualDiskImage *HardDisk::asVDI()
|
---|
327 | {
|
---|
328 | AssertReturn (mStorageType == HardDiskStorageType_VirtualDiskImage, 0);
|
---|
329 | return static_cast <HVirtualDiskImage *> (this);
|
---|
330 | }
|
---|
331 |
|
---|
332 | ////////////////////////////////////////////////////////////////////////////////
|
---|
333 |
|
---|
334 | class ATL_NO_VTABLE HISCSIHardDisk :
|
---|
335 | public HardDisk,
|
---|
336 | public VirtualBoxSupportTranslation <HISCSIHardDisk>,
|
---|
337 | public IISCSIHardDisk
|
---|
338 | {
|
---|
339 |
|
---|
340 | public:
|
---|
341 |
|
---|
342 | VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HISCSIHardDisk)
|
---|
343 |
|
---|
344 | DECLARE_NOT_AGGREGATABLE(HISCSIHardDisk)
|
---|
345 |
|
---|
346 | DECLARE_PROTECT_FINAL_CONSTRUCT()
|
---|
347 |
|
---|
348 | BEGIN_COM_MAP(HISCSIHardDisk)
|
---|
349 | COM_INTERFACE_ENTRY(ISupportErrorInfo)
|
---|
350 | COM_INTERFACE_ENTRY(IHardDisk)
|
---|
351 | COM_INTERFACE_ENTRY(IISCSIHardDisk)
|
---|
352 | END_COM_MAP()
|
---|
353 |
|
---|
354 | NS_DECL_ISUPPORTS
|
---|
355 |
|
---|
356 | HRESULT FinalConstruct();
|
---|
357 | void FinalRelease();
|
---|
358 |
|
---|
359 | // public initializer/uninitializer for internal purposes only
|
---|
360 |
|
---|
361 | HRESULT init (VirtualBox *aVirtualBox,
|
---|
362 | const settings::Key &aHDNode, const settings::Key &aISCSINode);
|
---|
363 | HRESULT init (VirtualBox *aVirtualBox);
|
---|
364 | void uninit();
|
---|
365 |
|
---|
366 | // IHardDisk properties
|
---|
367 | STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
|
---|
368 | STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
|
---|
369 | STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
|
---|
370 | STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
|
---|
371 |
|
---|
372 | // IISCSIHardDisk properties
|
---|
373 | STDMETHOD(COMGETTER(Server)) (BSTR *aServer);
|
---|
374 | STDMETHOD(COMSETTER(Server)) (INPTR BSTR aServer);
|
---|
375 | STDMETHOD(COMGETTER(Port)) (USHORT *aPort);
|
---|
376 | STDMETHOD(COMSETTER(Port)) (USHORT aPort);
|
---|
377 | STDMETHOD(COMGETTER(Target)) (BSTR *aTarget);
|
---|
378 | STDMETHOD(COMSETTER(Target)) (INPTR BSTR aTarget);
|
---|
379 | STDMETHOD(COMGETTER(Lun)) (ULONG64 *aLun);
|
---|
380 | STDMETHOD(COMSETTER(Lun)) (ULONG64 aLun);
|
---|
381 | STDMETHOD(COMGETTER(UserName)) (BSTR *aUserName);
|
---|
382 | STDMETHOD(COMSETTER(UserName)) (INPTR BSTR aUserName);
|
---|
383 | STDMETHOD(COMGETTER(Password)) (BSTR *aPassword);
|
---|
384 | STDMETHOD(COMSETTER(Password)) (INPTR BSTR aPassword);
|
---|
385 |
|
---|
386 | // public methods for internal purposes only
|
---|
387 |
|
---|
388 | const Bstr &server() const { return mServer; }
|
---|
389 | USHORT port() const { return mPort; }
|
---|
390 | const Bstr &target() const { return mTarget; }
|
---|
391 | ULONG64 lun() const { return mLun; }
|
---|
392 | const Bstr &userName() const { return mUserName; }
|
---|
393 | const Bstr &password() const { return mPassword; }
|
---|
394 |
|
---|
395 | HRESULT trySetRegistered (BOOL aRegistered);
|
---|
396 | HRESULT getAccessible (Bstr &aAccessError);
|
---|
397 |
|
---|
398 | HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
|
---|
399 |
|
---|
400 | Bstr toString (bool aShort = false);
|
---|
401 |
|
---|
402 | HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
403 | Progress *aProgress, bool &aDeleteTarget);
|
---|
404 | HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
405 | Progress *aProgress);
|
---|
406 |
|
---|
407 | public:
|
---|
408 |
|
---|
409 | // for VirtualBoxSupportErrorInfoImpl
|
---|
410 | static const wchar_t *getComponentName() { return L"ISCSIHardDisk"; }
|
---|
411 |
|
---|
412 | private:
|
---|
413 |
|
---|
414 | HRESULT queryInformation (Bstr &aAccessError);
|
---|
415 |
|
---|
416 | Bstr mDescription;
|
---|
417 |
|
---|
418 | ULONG64 mSize;
|
---|
419 | ULONG64 mActualSize;
|
---|
420 |
|
---|
421 | Bstr mServer;
|
---|
422 | USHORT mPort;
|
---|
423 | Bstr mTarget;
|
---|
424 | ULONG64 mLun;
|
---|
425 | Bstr mUserName;
|
---|
426 | Bstr mPassword;
|
---|
427 | };
|
---|
428 |
|
---|
429 | ////////////////////////////////////////////////////////////////////////////////
|
---|
430 |
|
---|
431 | class ATL_NO_VTABLE HVMDKImage :
|
---|
432 | public HardDisk,
|
---|
433 | public VirtualBoxSupportTranslation <HVMDKImage>,
|
---|
434 | public IVMDKImage
|
---|
435 | {
|
---|
436 |
|
---|
437 | public:
|
---|
438 |
|
---|
439 | VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HVMDKImage)
|
---|
440 |
|
---|
441 | DECLARE_NOT_AGGREGATABLE(HVMDKImage)
|
---|
442 |
|
---|
443 | DECLARE_PROTECT_FINAL_CONSTRUCT()
|
---|
444 |
|
---|
445 | BEGIN_COM_MAP(HVMDKImage)
|
---|
446 | COM_INTERFACE_ENTRY(ISupportErrorInfo)
|
---|
447 | COM_INTERFACE_ENTRY(IHardDisk)
|
---|
448 | COM_INTERFACE_ENTRY(IVMDKImage)
|
---|
449 | END_COM_MAP()
|
---|
450 |
|
---|
451 | NS_DECL_ISUPPORTS
|
---|
452 |
|
---|
453 | HRESULT FinalConstruct();
|
---|
454 | void FinalRelease();
|
---|
455 |
|
---|
456 | // public initializer/uninitializer for internal purposes only
|
---|
457 |
|
---|
458 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
459 | const settings::Key &aHDNode, const settings::Key &aVMDKNode);
|
---|
460 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
461 | INPTR BSTR aFilePath, BOOL aRegistered = FALSE);
|
---|
462 | void uninit();
|
---|
463 |
|
---|
464 | // IHardDisk properties
|
---|
465 | STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
|
---|
466 | STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
|
---|
467 | STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
|
---|
468 | STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
|
---|
469 |
|
---|
470 | // IVirtualDiskImage properties
|
---|
471 | STDMETHOD(COMGETTER(FilePath)) (BSTR *aFilePath);
|
---|
472 | STDMETHOD(COMSETTER(FilePath)) (INPTR BSTR aFilePath);
|
---|
473 | STDMETHOD(COMGETTER(Created)) (BOOL *aCreated);
|
---|
474 |
|
---|
475 | // IVirtualDiskImage methods
|
---|
476 | STDMETHOD(CreateDynamicImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
477 | STDMETHOD(CreateFixedImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
478 | STDMETHOD(DeleteImage)();
|
---|
479 |
|
---|
480 | // public methods for internal purposes only
|
---|
481 |
|
---|
482 | const Bstr &filePath() const { return mFilePath; }
|
---|
483 | const Bstr &filePathFull() const { return mFilePathFull; }
|
---|
484 |
|
---|
485 | HRESULT trySetRegistered (BOOL aRegistered);
|
---|
486 | HRESULT getAccessible (Bstr &aAccessError);
|
---|
487 |
|
---|
488 | HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
|
---|
489 |
|
---|
490 | void updatePath (const char *aOldPath, const char *aNewPath);
|
---|
491 |
|
---|
492 | Bstr toString (bool aShort = false);
|
---|
493 |
|
---|
494 | HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
495 | Progress *aProgress, bool &aDeleteTarget);
|
---|
496 | HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
497 | Progress *aProgress);
|
---|
498 |
|
---|
499 | // for VirtualBoxSupportErrorInfoImpl
|
---|
500 | static const wchar_t *getComponentName() { return L"VMDKImage"; }
|
---|
501 |
|
---|
502 | private:
|
---|
503 |
|
---|
504 | HRESULT setFilePath (const BSTR aFilePath);
|
---|
505 | HRESULT queryInformation (Bstr *aAccessError);
|
---|
506 | HRESULT createImage (ULONG64 aSize, BOOL aDynamic, IProgress **aProgress);
|
---|
507 |
|
---|
508 | /** VDI asynchronous operation thread function */
|
---|
509 | static DECLCALLBACK(int) VDITaskThread (RTTHREAD thread, void *pvUser);
|
---|
510 |
|
---|
511 | static DECLCALLBACK(void) VDError (void *pvUser, int rc, RT_SRC_POS_DECL,
|
---|
512 | const char *pszFormat, va_list va);
|
---|
513 |
|
---|
514 | enum State
|
---|
515 | {
|
---|
516 | NotCreated,
|
---|
517 | Created,
|
---|
518 | /* the following must be greater than Created */
|
---|
519 | Accessible,
|
---|
520 | };
|
---|
521 |
|
---|
522 | State mState;
|
---|
523 |
|
---|
524 | RTSEMEVENTMULTI mStateCheckSem;
|
---|
525 | ULONG mStateCheckWaiters;
|
---|
526 |
|
---|
527 | Bstr mDescription;
|
---|
528 |
|
---|
529 | ULONG64 mSize;
|
---|
530 | ULONG64 mActualSize;
|
---|
531 |
|
---|
532 | Bstr mFilePath;
|
---|
533 | Bstr mFilePathFull;
|
---|
534 |
|
---|
535 | PVBOXHDD mContainer;
|
---|
536 |
|
---|
537 | Utf8Str mLastVDError;
|
---|
538 |
|
---|
539 | friend class HardDisk;
|
---|
540 | };
|
---|
541 |
|
---|
542 | ////////////////////////////////////////////////////////////////////////////////
|
---|
543 |
|
---|
544 | class ATL_NO_VTABLE HCustomHardDisk :
|
---|
545 | public HardDisk,
|
---|
546 | public VirtualBoxSupportTranslation <HCustomHardDisk>,
|
---|
547 | public ICustomHardDisk
|
---|
548 | {
|
---|
549 |
|
---|
550 | public:
|
---|
551 |
|
---|
552 | VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HCustomHardDisk)
|
---|
553 |
|
---|
554 | DECLARE_NOT_AGGREGATABLE(HCustomHardDisk)
|
---|
555 |
|
---|
556 | DECLARE_PROTECT_FINAL_CONSTRUCT()
|
---|
557 |
|
---|
558 | BEGIN_COM_MAP(HCustomHardDisk)
|
---|
559 | COM_INTERFACE_ENTRY(ISupportErrorInfo)
|
---|
560 | COM_INTERFACE_ENTRY(IHardDisk)
|
---|
561 | COM_INTERFACE_ENTRY(ICustomHardDisk)
|
---|
562 | END_COM_MAP()
|
---|
563 |
|
---|
564 | NS_DECL_ISUPPORTS
|
---|
565 |
|
---|
566 | HRESULT FinalConstruct();
|
---|
567 | void FinalRelease();
|
---|
568 |
|
---|
569 | // public initializer/uninitializer for internal purposes only
|
---|
570 |
|
---|
571 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
572 | const settings::Key &aHDNode, const settings::Key &aCustomNode);
|
---|
573 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
574 | INPTR BSTR aLocation, BOOL aRegistered = FALSE);
|
---|
575 | void uninit();
|
---|
576 |
|
---|
577 | // IHardDisk properties
|
---|
578 | STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
|
---|
579 | STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
|
---|
580 | STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
|
---|
581 | STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
|
---|
582 |
|
---|
583 | // IVirtualDiskImage properties
|
---|
584 | STDMETHOD(COMGETTER(Location)) (BSTR *aLocation);
|
---|
585 | STDMETHOD(COMSETTER(Location)) (INPTR BSTR aLocation);
|
---|
586 | STDMETHOD(COMGETTER(Format)) (BSTR *aFormat);
|
---|
587 | STDMETHOD(COMGETTER(Created)) (BOOL *aCreated);
|
---|
588 |
|
---|
589 | // IVirtualDiskImage methods
|
---|
590 | STDMETHOD(CreateDynamicImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
591 | STDMETHOD(CreateFixedImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
592 | STDMETHOD(DeleteImage)();
|
---|
593 |
|
---|
594 | // public methods for internal purposes only
|
---|
595 |
|
---|
596 | const Bstr &Location() const { return mLocation; }
|
---|
597 |
|
---|
598 | HRESULT trySetRegistered (BOOL aRegistered);
|
---|
599 | HRESULT getAccessible (Bstr &aAccessError);
|
---|
600 |
|
---|
601 | HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
|
---|
602 |
|
---|
603 | Bstr toString (bool aShort = false);
|
---|
604 |
|
---|
605 | HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
606 | Progress *aProgress, bool &aDeleteTarget);
|
---|
607 | HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
608 | Progress *aProgress);
|
---|
609 |
|
---|
610 | // for VirtualBoxSupportErrorInfoImpl
|
---|
611 | static const wchar_t *getComponentName() { return L"CustomHardDisk"; }
|
---|
612 |
|
---|
613 | private:
|
---|
614 |
|
---|
615 | HRESULT setLocation (const BSTR aLocation);
|
---|
616 | HRESULT queryInformation (Bstr *aAccessError);
|
---|
617 | HRESULT createImage (ULONG64 aSize, BOOL aDynamic, IProgress **aProgress);
|
---|
618 |
|
---|
619 | /** VDI asynchronous operation thread function */
|
---|
620 | static DECLCALLBACK(int) VDITaskThread (RTTHREAD thread, void *pvUser);
|
---|
621 |
|
---|
622 | static DECLCALLBACK(void) VDError (void *pvUser, int rc, RT_SRC_POS_DECL,
|
---|
623 | const char *pszFormat, va_list va);
|
---|
624 |
|
---|
625 | enum State
|
---|
626 | {
|
---|
627 | NotCreated,
|
---|
628 | Created,
|
---|
629 | /* the following must be greater than Created */
|
---|
630 | Accessible,
|
---|
631 | };
|
---|
632 |
|
---|
633 | State mState;
|
---|
634 |
|
---|
635 | RTSEMEVENTMULTI mStateCheckSem;
|
---|
636 | ULONG mStateCheckWaiters;
|
---|
637 |
|
---|
638 | Bstr mDescription;
|
---|
639 |
|
---|
640 | ULONG64 mSize;
|
---|
641 | ULONG64 mActualSize;
|
---|
642 |
|
---|
643 | Bstr mLocation;
|
---|
644 | Bstr mLocationFull;
|
---|
645 | Bstr mFormat;
|
---|
646 |
|
---|
647 | PVBOXHDD mContainer;
|
---|
648 |
|
---|
649 | Utf8Str mLastVDError;
|
---|
650 |
|
---|
651 | friend class HardDisk;
|
---|
652 | };
|
---|
653 |
|
---|
654 | ////////////////////////////////////////////////////////////////////////////////
|
---|
655 |
|
---|
656 | class ATL_NO_VTABLE HVHDImage :
|
---|
657 | public HardDisk,
|
---|
658 | public VirtualBoxSupportTranslation <HVHDImage>,
|
---|
659 | public IVHDImage
|
---|
660 | {
|
---|
661 |
|
---|
662 | public:
|
---|
663 |
|
---|
664 | VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HVHDImage)
|
---|
665 |
|
---|
666 | DECLARE_NOT_AGGREGATABLE(HVHDImage)
|
---|
667 |
|
---|
668 | DECLARE_PROTECT_FINAL_CONSTRUCT()
|
---|
669 |
|
---|
670 | BEGIN_COM_MAP(HVMDKImage)
|
---|
671 | COM_INTERFACE_ENTRY(ISupportErrorInfo)
|
---|
672 | COM_INTERFACE_ENTRY(IHardDisk)
|
---|
673 | COM_INTERFACE_ENTRY(IVHDImage)
|
---|
674 | END_COM_MAP()
|
---|
675 |
|
---|
676 | NS_DECL_ISUPPORTS
|
---|
677 |
|
---|
678 | HRESULT FinalConstruct();
|
---|
679 | void FinalRelease();
|
---|
680 |
|
---|
681 | // public initializer/uninitializer for internal purposes only
|
---|
682 |
|
---|
683 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
684 | const settings::Key &aHDNode, const settings::Key &aVHDNode);
|
---|
685 | HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
|
---|
686 | INPTR BSTR aFilePath, BOOL aRegistered = FALSE);
|
---|
687 | void uninit();
|
---|
688 |
|
---|
689 | // IHardDisk properties
|
---|
690 | STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
|
---|
691 | STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
|
---|
692 | STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
|
---|
693 | STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
|
---|
694 |
|
---|
695 | // IVirtualDiskImage properties
|
---|
696 | STDMETHOD(COMGETTER(FilePath)) (BSTR *aFilePath);
|
---|
697 | STDMETHOD(COMSETTER(FilePath)) (INPTR BSTR aFilePath);
|
---|
698 | STDMETHOD(COMGETTER(Created)) (BOOL *aCreated);
|
---|
699 |
|
---|
700 | // IVirtualDiskImage methods
|
---|
701 | STDMETHOD(CreateDynamicImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
702 | STDMETHOD(CreateFixedImage) (ULONG64 aSize, IProgress **aProgress);
|
---|
703 | STDMETHOD(DeleteImage)();
|
---|
704 |
|
---|
705 | // public methods for internal purposes only
|
---|
706 |
|
---|
707 | const Bstr &filePath() const { return mFilePath; }
|
---|
708 | const Bstr &filePathFull() const { return mFilePathFull; }
|
---|
709 |
|
---|
710 | HRESULT trySetRegistered (BOOL aRegistered);
|
---|
711 | HRESULT getAccessible (Bstr &aAccessError);
|
---|
712 |
|
---|
713 | HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
|
---|
714 |
|
---|
715 | void updatePath (const char *aOldPath, const char *aNewPath);
|
---|
716 |
|
---|
717 | Bstr toString (bool aShort = false);
|
---|
718 |
|
---|
719 | HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
720 | Progress *aProgress, bool &aDeleteTarget);
|
---|
721 | HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
|
---|
722 | Progress *aProgress);
|
---|
723 |
|
---|
724 | // for VirtualBoxSupportErrorInfoImpl
|
---|
725 | static const wchar_t *getComponentName() { return L"VHDImage"; }
|
---|
726 |
|
---|
727 | private:
|
---|
728 |
|
---|
729 | HRESULT setFilePath (const BSTR aFilePath);
|
---|
730 | HRESULT queryInformation (Bstr *aAccessError);
|
---|
731 | HRESULT createImage (ULONG64 aSize, BOOL aDynamic, IProgress **aProgress);
|
---|
732 |
|
---|
733 | /** VDI asynchronous operation thread function */
|
---|
734 | static DECLCALLBACK(int) VDITaskThread (RTTHREAD thread, void *pvUser);
|
---|
735 |
|
---|
736 | static DECLCALLBACK(void) VDError (void *pvUser, int rc, RT_SRC_POS_DECL,
|
---|
737 | const char *pszFormat, va_list va);
|
---|
738 |
|
---|
739 | enum State
|
---|
740 | {
|
---|
741 | NotCreated,
|
---|
742 | Created,
|
---|
743 | /* the following must be greater than Created */
|
---|
744 | Accessible,
|
---|
745 | };
|
---|
746 |
|
---|
747 | State mState;
|
---|
748 |
|
---|
749 | RTSEMEVENTMULTI mStateCheckSem;
|
---|
750 | ULONG mStateCheckWaiters;
|
---|
751 |
|
---|
752 | Bstr mDescription;
|
---|
753 |
|
---|
754 | ULONG64 mSize;
|
---|
755 | ULONG64 mActualSize;
|
---|
756 |
|
---|
757 | Bstr mFilePath;
|
---|
758 | Bstr mFilePathFull;
|
---|
759 |
|
---|
760 | PVBOXHDD mContainer;
|
---|
761 |
|
---|
762 | Utf8Str mLastVDError;
|
---|
763 |
|
---|
764 | friend class HardDisk;
|
---|
765 | };
|
---|
766 |
|
---|
767 |
|
---|
768 | COM_DECL_READONLY_ENUM_AND_COLLECTION (HardDisk)
|
---|
769 |
|
---|
770 | #endif // ____H_HARDDISKIMPL
|
---|