VirtualBox

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

Last change on this file since 887 was 749, checked in by vboxsync, 18 years ago

Main: Fixed: Don't try to delete the image file of a differencing VDI on unregistration if the last accessibility check for this VDI failed.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 13.0 KB
Line 
1/** @file
2 *
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006 InnoTek Systemberatung GmbH
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22#ifndef ____H_HARDDISKIMPL
23#define ____H_HARDDISKIMPL
24
25#include "VirtualBoxBase.h"
26#include "Collection.h"
27
28#include <VBox/cfgldr.h>
29
30#include <iprt/semaphore.h>
31
32#include <list>
33
34class VirtualBox;
35class Progress;
36class HVirtualDiskImage;
37
38////////////////////////////////////////////////////////////////////////////////
39
40class ATL_NO_VTABLE HardDisk :
41 public VirtualBoxSupportErrorInfoImpl <HardDisk, IHardDisk>,
42 public VirtualBoxSupportTranslation <HardDisk>,
43 public VirtualBoxBaseWithTypedChildren <HardDisk>,
44 public IHardDisk
45{
46
47public:
48
49 typedef VirtualBoxBaseWithTypedChildren <HardDisk>::DependentChildren
50 HardDiskList;
51
52 DECLARE_NOT_AGGREGATABLE(HardDisk)
53
54 DECLARE_PROTECT_FINAL_CONSTRUCT()
55
56 BEGIN_COM_MAP(HardDisk)
57 COM_INTERFACE_ENTRY(ISupportErrorInfo)
58 COM_INTERFACE_ENTRY(IHardDisk)
59 END_COM_MAP()
60
61 NS_DECL_ISUPPORTS
62
63 HRESULT FinalConstruct();
64 void FinalRelease();
65
66protected:
67
68 // protected initializer/uninitializer for internal purposes only
69 HRESULT protectedInit (VirtualBox *aVirtualBox, HardDisk *aParent);
70 void protectedUninit (AutoLock &alock);
71
72public:
73
74 // IHardDisk properties
75 STDMETHOD(COMGETTER(Id)) (GUIDPARAMOUT aId);
76 STDMETHOD(COMGETTER(StorageType)) (HardDiskStorageType_T *aStorageType);
77 STDMETHOD(COMGETTER(Location)) (BSTR *aLocation);
78 STDMETHOD(COMGETTER(Type)) (HardDiskType_T *aType);
79 STDMETHOD(COMSETTER(Type)) (HardDiskType_T aType);
80 STDMETHOD(COMGETTER(Parent)) (IHardDisk **aParent);
81 STDMETHOD(COMGETTER(Children)) (IHardDiskCollection **aChildren);
82 STDMETHOD(COMGETTER(Root)) (IHardDisk **aRoot);
83 STDMETHOD(COMGETTER(Accessible)) (BOOL *aAccessible);
84 STDMETHOD(COMGETTER(AllAccessible)) (BOOL *aAllAccessible);
85 STDMETHOD(COMGETTER(LastAccessError)) (BSTR *aLastAccessError);
86 STDMETHOD(COMGETTER(MachineId)) (GUIDPARAMOUT aMachineId);
87 STDMETHOD(COMGETTER(SnapshotId)) (GUIDPARAMOUT aSnapshotId);
88
89 // IHardDisk methods
90 STDMETHOD(CloneToImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage,
91 IProgress **aProgress);
92
93 // public methods for internal purposes only
94
95 const Guid &id() const { return mId; }
96 HardDiskStorageType_T storageType() const { return mStorageType; }
97 HardDiskType_T type() const { return mType; }
98 const Guid &machineId() const { return mMachineId; }
99 const Guid &snapshotId() const { return mSnapshotId; }
100
101 void setMachineId (const Guid &aId) { mMachineId = aId; }
102 void setSnapshotId (const Guid &aId) { mSnapshotId = aId; }
103
104 bool isDifferencing() const
105 {
106 return mType == HardDiskType_NormalHardDisk &&
107 mStorageType == HardDiskStorageType_VirtualDiskImage &&
108 !mParent.isNull();
109 }
110 bool isParentImmutable() const
111 {
112 AutoLock parentLock (mParent);
113 return !mParent.isNull() && mParent->type() == HardDiskType_ImmutableHardDisk;
114 }
115
116 inline HVirtualDiskImage *asVDI();
117
118 ComObjPtr <HardDisk> parent() const { return static_cast <HardDisk *> (mParent); }
119
120 /** Shortcut to #dependentChildrenLock() */
121 AutoLock::Handle &childrenLock() const { return dependentChildrenLock(); }
122
123 /**
124 * Shortcut to #dependentChildren().
125 * Do |AutoLock alock (childrenLock());| before acceessing the returned list!
126 */
127 const HardDiskList &children() const { return dependentChildren(); }
128
129 ComObjPtr <HardDisk> root() const;
130
131 // virtual methods that need to be [re]implemented by every subclass
132
133 virtual HRESULT trySetRegistered (BOOL aRegistered);
134 virtual HRESULT getAccessible (Bstr &aAccessError);
135
136 virtual HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode) = 0;
137
138 virtual void updatePath (const char *aOldPath, const char *aNewPath) {}
139
140 virtual Bstr toString (bool aShort = false) = 0;
141 virtual bool sameAs (HardDisk *that);
142
143 virtual HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
144 Progress *aProgress) = 0;
145 virtual HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
146 Progress *aProgress) = 0;
147public:
148
149 void setBusy();
150 void clearBusy();
151 void addReader();
152 void releaseReader();
153 void addReaderOnAncestors();
154 void releaseReaderOnAncestors();
155 bool hasForeignChildren();
156
157 HRESULT setBusyWithChildren();
158 void clearBusyWithChildren();
159 HRESULT getAccessibleWithChildren (Bstr &aAccessError);
160
161 HRESULT checkConsistency();
162
163 HRESULT createDiffHardDisk (const Bstr &aFolder, const Guid &aMachineId,
164 ComObjPtr <HVirtualDiskImage> &aHardDisk,
165 Progress *aProgress);
166
167 void updatePaths (const char *aOldPath, const char *aNewPath);
168
169 /* the following must be called from under the lock */
170 bool isBusy() { isLockedOnCurrentThread(); return mBusy; }
171 unsigned readers() { isLockedOnCurrentThread(); return mReaders; }
172 const Bstr &lastAccessError() const { return mLastAccessError; }
173
174 // for VirtualBoxSupportErrorInfoImpl
175 static const wchar_t *getComponentName() { return L"HardDisk"; }
176
177protected:
178
179 HRESULT loadSettings (CFGNODE aHDNode);
180 HRESULT saveSettings (CFGNODE aHDNode);
181
182 /** weak VirualBox parent */
183 ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
184
185 BOOL mRegistered;
186
187 ComObjPtr <HardDisk, ComWeakRef> mParent;
188
189 Guid mId;
190 HardDiskStorageType_T mStorageType;
191 HardDiskType_T mType;
192 Guid mMachineId;
193 Guid mSnapshotId;
194
195private:
196
197 Bstr mLastAccessError;
198
199 bool mBusy;
200 unsigned mReaders;
201};
202
203////////////////////////////////////////////////////////////////////////////////
204
205class ATL_NO_VTABLE HVirtualDiskImage :
206 public HardDisk,
207 public VirtualBoxSupportTranslation <HVirtualDiskImage>,
208 public IVirtualDiskImage
209{
210
211public:
212
213 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HVirtualDiskImage)
214
215 DECLARE_NOT_AGGREGATABLE(HVirtualDiskImage)
216
217 DECLARE_PROTECT_FINAL_CONSTRUCT()
218
219 BEGIN_COM_MAP(HVirtualDiskImage)
220 COM_INTERFACE_ENTRY(ISupportErrorInfo)
221 COM_INTERFACE_ENTRY(IHardDisk)
222 COM_INTERFACE_ENTRY(IVirtualDiskImage)
223 END_COM_MAP()
224
225 NS_DECL_ISUPPORTS
226
227 HRESULT FinalConstruct();
228 void FinalRelease();
229
230 // public initializer/uninitializer for internal purposes only
231
232 HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
233 CFGNODE aHDNode, CFGNODE aVDINode);
234 HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
235 const BSTR aFilePath, BOOL aRegistered = FALSE);
236 void uninit();
237
238 // IHardDisk properties
239 STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
240 STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
241 STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
242 STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
243
244 // IVirtualDiskImage properties
245 STDMETHOD(COMGETTER(FilePath)) (BSTR *aFilePath);
246 STDMETHOD(COMSETTER(FilePath)) (INPTR BSTR aFilePath);
247 STDMETHOD(COMGETTER(Created)) (BOOL *aCreated);
248
249 // IVirtualDiskImage methods
250 STDMETHOD(CreateDynamicImage) (ULONG64 aSize, IProgress **aProgress);
251 STDMETHOD(CreateFixedImage) (ULONG64 aSize, IProgress **aProgress);
252 STDMETHOD(DeleteImage)();
253
254 // public methods for internal purposes only
255
256 const Bstr &filePath() const { return mFilePath; }
257 const Bstr &filePathFull() const { return mFilePathFull; }
258
259 HRESULT trySetRegistered (BOOL aRegistered);
260 HRESULT getAccessible (Bstr &aAccessError);
261
262 HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
263
264 void updatePath (const char *aOldPath, const char *aNewPath);
265
266 Bstr toString (bool aShort = false);
267
268 HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
269 Progress *aProgress);
270 HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
271 Progress *aProgress);
272
273 HRESULT cloneDiffImage (const Bstr &aFolder, const Guid &aMachineId,
274 ComObjPtr <HVirtualDiskImage> &aHardDisk,
275 Progress *aProgress);
276
277 HRESULT mergeImageToParent (Progress *aProgress);
278 HRESULT mergeImageToChildren (Progress *aProgress);
279
280 HRESULT wipeOutImage();
281
282 // for VirtualBoxSupportErrorInfoImpl
283 static const wchar_t *getComponentName() { return L"VirtualDiskImage"; }
284
285private:
286
287 HRESULT setFilePath (const BSTR aFilePath);
288 HRESULT queryInformation (Bstr *aAccessError);
289 HRESULT createImage (ULONG64 aSize, BOOL aDynamic, IProgress **aProgress);
290
291 /** VDI asynchronous operation thread function */
292 static DECLCALLBACK(int) vdiTaskThread (RTTHREAD thread, void *pvUser);
293
294 enum State
295 {
296 NotCreated,
297 Created,
298 /* the following must be greater than Created */
299 Accessible,
300 };
301
302 State mState;
303
304 RTSEMEVENTMULTI mStateCheckSem;
305 ULONG mStateCheckWaiters;
306
307 Bstr mDescription;
308
309 ULONG64 mSize;
310 ULONG64 mActualSize;
311
312 Bstr mFilePath;
313 Bstr mFilePathFull;
314
315 friend class HardDisk;
316};
317
318// dependent inline members
319////////////////////////////////////////////////////////////////////////////////
320
321inline HVirtualDiskImage *HardDisk::asVDI()
322{
323 AssertReturn (mStorageType == HardDiskStorageType_VirtualDiskImage, 0);
324 return static_cast <HVirtualDiskImage *> (this);
325}
326
327////////////////////////////////////////////////////////////////////////////////
328
329class ATL_NO_VTABLE HISCSIHardDisk :
330 public HardDisk,
331 public VirtualBoxSupportTranslation <HISCSIHardDisk>,
332 public IISCSIHardDisk
333{
334
335public:
336
337 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HISCSIHardDisk)
338
339 DECLARE_NOT_AGGREGATABLE(HISCSIHardDisk)
340
341 DECLARE_PROTECT_FINAL_CONSTRUCT()
342
343 BEGIN_COM_MAP(HISCSIHardDisk)
344 COM_INTERFACE_ENTRY(ISupportErrorInfo)
345 COM_INTERFACE_ENTRY(IHardDisk)
346 COM_INTERFACE_ENTRY(IISCSIHardDisk)
347 END_COM_MAP()
348
349 NS_DECL_ISUPPORTS
350
351 HRESULT FinalConstruct();
352 void FinalRelease();
353
354 // public initializer/uninitializer for internal purposes only
355
356 HRESULT init (VirtualBox *aVirtualBox,
357 CFGNODE aHDNode, CFGNODE aISCSINode);
358 HRESULT init (VirtualBox *aVirtualBox);
359 void uninit();
360
361 // IHardDisk properties
362 STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
363 STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
364 STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
365 STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
366
367 // IISCSIHardDisk properties
368 STDMETHOD(COMGETTER(Server)) (BSTR *aServer);
369 STDMETHOD(COMSETTER(Server)) (INPTR BSTR aServer);
370 STDMETHOD(COMGETTER(Port)) (USHORT *aPort);
371 STDMETHOD(COMSETTER(Port)) (USHORT aPort);
372 STDMETHOD(COMGETTER(Target)) (BSTR *aTarget);
373 STDMETHOD(COMSETTER(Target)) (INPTR BSTR aTarget);
374 STDMETHOD(COMGETTER(Lun)) (ULONG64 *aLun);
375 STDMETHOD(COMSETTER(Lun)) (ULONG64 aLun);
376 STDMETHOD(COMGETTER(UserName)) (BSTR *aUserName);
377 STDMETHOD(COMSETTER(UserName)) (INPTR BSTR aUserName);
378 STDMETHOD(COMGETTER(Password)) (BSTR *aPassword);
379 STDMETHOD(COMSETTER(Password)) (INPTR BSTR aPassword);
380
381 // public methods for internal purposes only
382
383 const Bstr &server() const { return mServer; }
384 USHORT port() const { return mPort; }
385 const Bstr &target() const { return mTarget; }
386 ULONG64 lun() const { return mLun; }
387 const Bstr &userName() const { return mUserName; }
388 const Bstr &password() const { return mPassword; }
389
390 HRESULT trySetRegistered (BOOL aRegistered);
391 HRESULT getAccessible (Bstr &aAccessError);
392
393 HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
394
395 Bstr toString (bool aShort = false);
396
397 HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
398 Progress *aProgress);
399 HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
400 Progress *aProgress);
401
402public:
403
404 // for VirtualBoxSupportErrorInfoImpl
405 static const wchar_t *getComponentName() { return L"ISCSIHardDisk"; }
406
407private:
408
409 HRESULT queryInformation (Bstr &aAccessError);
410
411 Bstr mDescription;
412
413 ULONG64 mSize;
414 ULONG64 mActualSize;
415
416 Bstr mServer;
417 USHORT mPort;
418 Bstr mTarget;
419 ULONG64 mLun;
420 Bstr mUserName;
421 Bstr mPassword;
422};
423
424
425COM_DECL_READONLY_ENUM_AND_COLLECTION (HardDisk)
426
427#endif // ____H_HARDDISKIMPL
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