VirtualBox

source: vbox/trunk/src/VBox/Main/include/HardDiskImpl.h@ 11655

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

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

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