VirtualBox

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

Last change on this file since 31482 was 31482, checked in by vboxsync, 15 years ago

Main: less string copying with media paths
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.2 KB
Line 
1/* $Id: MediumImpl.h 31482 2010-08-09 12:55:33Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2008-2010 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.215389.xyz. 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_MEDIUMIMPL
21#define ____H_MEDIUMIMPL
22
23#include <VBox/VBoxHDD.h>
24
25#include "VirtualBoxBase.h"
26#include "MediumLock.h"
27
28class Progress;
29class MediumFormat;
30
31namespace settings
32{
33 struct Medium;
34}
35
36////////////////////////////////////////////////////////////////////////////////
37
38/**
39 * Medium component class for all media types.
40 */
41class ATL_NO_VTABLE Medium :
42 public VirtualBoxBase,
43 VBOX_SCRIPTABLE_IMPL(IMedium)
44{
45public:
46 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Medium, IMedium)
47
48 DECLARE_NOT_AGGREGATABLE(Medium)
49
50 DECLARE_PROTECT_FINAL_CONSTRUCT()
51
52 BEGIN_COM_MAP(Medium)
53 COM_INTERFACE_ENTRY(ISupportErrorInfo)
54 COM_INTERFACE_ENTRY(IMedium)
55 COM_INTERFACE_ENTRY(IDispatch)
56 END_COM_MAP()
57
58 DECLARE_EMPTY_CTOR_DTOR(Medium)
59
60 HRESULT FinalConstruct();
61 void FinalRelease();
62
63 enum HDDOpenMode { OpenReadWrite, OpenReadOnly };
64 // have to use a special enum for the overloaded init() below;
65 // can't use AccessMode_T from XIDL because that's mapped to an int
66 // and would be ambiguous
67
68 // public initializer/uninitializer for internal purposes only
69
70 // initializer to create empty medium (VirtualBox::CreateHardDisk())
71 HRESULT init(VirtualBox *aVirtualBox,
72 const Utf8Str &aFormat,
73 const Utf8Str &aLocation,
74 bool *pfNeedsSaveSettings);
75
76 // initializer for opening existing media
77 // (VirtualBox::OpenHardDisk/DVD(); Machine::AttachDevice())
78 HRESULT init(VirtualBox *aVirtualBox,
79 const Utf8Str &aLocation,
80 HDDOpenMode enOpenMode,
81 DeviceType_T aDeviceType,
82 BOOL aSetImageId,
83 const Guid &aImageId,
84 BOOL aSetParentId,
85 const Guid &aParentId);
86
87 // initializer used when loading settings
88 HRESULT init(VirtualBox *aVirtualBox,
89 Medium *aParent,
90 DeviceType_T aDeviceType,
91 const settings::Medium &data);
92
93 // initializer for host floppy/DVD
94 HRESULT init(VirtualBox *aVirtualBox,
95 DeviceType_T aDeviceType,
96 const Utf8Str &aLocation,
97 const Utf8Str &aDescription = Utf8Str::Empty);
98
99 void uninit();
100
101 void deparent();
102 void setParent(const ComObjPtr<Medium> &pParent);
103
104 // IMedium properties
105 STDMETHOD(COMGETTER(Id))(BSTR *aId);
106 STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
107 STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
108 STDMETHOD(COMGETTER(State))(MediumState_T *aState);
109 STDMETHOD(COMGETTER(Variant))(MediumVariant_T *aVariant);
110 STDMETHOD(COMGETTER(Location))(BSTR *aLocation);
111 STDMETHOD(COMSETTER(Location))(IN_BSTR aLocation);
112 STDMETHOD(COMGETTER(Name))(BSTR *aName);
113 STDMETHOD(COMGETTER(DeviceType))(DeviceType_T *aDeviceType);
114 STDMETHOD(COMGETTER(HostDrive))(BOOL *aHostDrive);
115 STDMETHOD(COMGETTER(Size))(ULONG64 *aSize);
116 STDMETHOD(COMGETTER(Format))(BSTR *aFormat);
117 STDMETHOD(COMGETTER(MediumFormat))(IMediumFormat **aMediumFormat);
118 STDMETHOD(COMGETTER(Type))(MediumType_T *aType);
119 STDMETHOD(COMSETTER(Type))(MediumType_T aType);
120 STDMETHOD(COMGETTER(Parent))(IMedium **aParent);
121 STDMETHOD(COMGETTER(Children))(ComSafeArrayOut(IMedium *, aChildren));
122 STDMETHOD(COMGETTER(Base))(IMedium **aBase);
123 STDMETHOD(COMGETTER(ReadOnly))(BOOL *aReadOnly);
124 STDMETHOD(COMGETTER(LogicalSize))(ULONG64 *aLogicalSize);
125 STDMETHOD(COMGETTER(AutoReset))(BOOL *aAutoReset);
126 STDMETHOD(COMSETTER(AutoReset))(BOOL aAutoReset);
127 STDMETHOD(COMGETTER(LastAccessError))(BSTR *aLastAccessError);
128 STDMETHOD(COMGETTER(MachineIds))(ComSafeArrayOut(BSTR, aMachineIds));
129
130 // IMedium methods
131 STDMETHOD(RefreshState)(MediumState_T *aState);
132 STDMETHOD(GetSnapshotIds)(IN_BSTR aMachineId,
133 ComSafeArrayOut(BSTR, aSnapshotIds));
134 STDMETHOD(LockRead)(MediumState_T *aState);
135 STDMETHOD(UnlockRead)(MediumState_T *aState);
136 STDMETHOD(LockWrite)(MediumState_T *aState);
137 STDMETHOD(UnlockWrite)(MediumState_T *aState);
138 STDMETHOD(Close)();
139 STDMETHOD(GetProperty)(IN_BSTR aName, BSTR *aValue);
140 STDMETHOD(SetProperty)(IN_BSTR aName, IN_BSTR aValue);
141 STDMETHOD(GetProperties)(IN_BSTR aNames,
142 ComSafeArrayOut(BSTR, aReturnNames),
143 ComSafeArrayOut(BSTR, aReturnValues));
144 STDMETHOD(SetProperties)(ComSafeArrayIn(IN_BSTR, aNames),
145 ComSafeArrayIn(IN_BSTR, aValues));
146 STDMETHOD(CreateBaseStorage)(ULONG64 aLogicalSize,
147 MediumVariant_T aVariant,
148 IProgress **aProgress);
149 STDMETHOD(DeleteStorage)(IProgress **aProgress);
150 STDMETHOD(CreateDiffStorage)(IMedium *aTarget,
151 MediumVariant_T aVariant,
152 IProgress **aProgress);
153 STDMETHOD(MergeTo)(IMedium *aTarget, IProgress **aProgress);
154 STDMETHOD(CloneTo)(IMedium *aTarget, MediumVariant_T aVariant,
155 IMedium *aParent, IProgress **aProgress);
156 STDMETHOD(Compact)(IProgress **aProgress);
157 STDMETHOD(Resize)(ULONG64 aLogicalSize, IProgress **aProgress);
158 STDMETHOD(Reset)(IProgress **aProgress);
159
160 // unsafe methods for internal purposes only (ensure there is
161 // a caller and a read lock before calling them!)
162 const ComObjPtr<Medium>& getParent() const;
163 const MediaList& getChildren() const;
164
165 const Guid& getRegistryMachineId() const;
166
167 const Guid& getId() const;
168 MediumState_T getState() const;
169 MediumVariant_T getVariant() const;
170 bool isHostDrive() const;
171 const Utf8Str& getLocation() const;
172 const Utf8Str& getLocationFull() const;
173 const Utf8Str& getFormat() const;
174 const ComObjPtr<MediumFormat> & getMediumFormat() const;
175 uint64_t getSize() const;
176 DeviceType_T getDeviceType() const;
177 MediumType_T getType() const;
178 Utf8Str getName();
179
180 HRESULT addBackReference(const Guid &aMachineId,
181 const Guid &aSnapshotId = Guid::Empty);
182 HRESULT removeBackReference(const Guid &aMachineId,
183 const Guid &aSnapshotId = Guid::Empty);
184
185 const Guid* getFirstMachineBackrefId() const;
186 const Guid* getFirstMachineBackrefSnapshotId() const;
187
188#ifdef DEBUG
189 void dumpBackRefs();
190#endif
191
192 HRESULT updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
193
194 ComObjPtr<Medium> getBase(uint32_t *aLevel = NULL);
195
196 bool isReadOnly();
197
198 HRESULT saveSettings(settings::Medium &data);
199
200 HRESULT compareLocationTo(const Utf8Str &strLocation, int &aResult);
201
202 HRESULT createMediumLockList(bool fFailIfInaccessible,
203 bool fMediumLockWrite,
204 Medium *pToBeParent,
205 MediumLockList &mediumLockList);
206
207 HRESULT createDiffStorage(ComObjPtr<Medium> &aTarget,
208 MediumVariant_T aVariant,
209 MediumLockList *pMediumLockList,
210 ComObjPtr<Progress> *aProgress,
211 bool aWait,
212 bool *pfNeedsSaveSettings);
213
214 HRESULT close(bool *pfNeedsSaveSettings, AutoCaller &autoCaller);
215 HRESULT deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait, bool *pfNeedsSaveSettings);
216 HRESULT markForDeletion();
217 HRESULT unmarkForDeletion();
218 HRESULT markLockedForDeletion();
219 HRESULT unmarkLockedForDeletion();
220
221 HRESULT prepareMergeTo(const ComObjPtr<Medium> &pTarget,
222 const Guid *aMachineId,
223 const Guid *aSnapshotId,
224 bool fLockMedia,
225 bool &fMergeForward,
226 ComObjPtr<Medium> &pParentForTarget,
227 MediaList &aChildrenToReparent,
228 MediumLockList * &aMediumLockList);
229 HRESULT mergeTo(const ComObjPtr<Medium> &pTarget,
230 bool fMergeForward,
231 const ComObjPtr<Medium> &pParentForTarget,
232 const MediaList &aChildrenToReparent,
233 MediumLockList *aMediumLockList,
234 ComObjPtr<Progress> *aProgress,
235 bool aWait,
236 bool *pfNeedsSaveSettings);
237 void cancelMergeTo(const MediaList &aChildrenToReparent,
238 MediumLockList *aMediumLockList);
239
240 HRESULT fixParentUuidOfChildren(const MediaList &childrenToReparent);
241
242 /** Returns a preferred format for a differencing hard disk. */
243 Utf8Str getPreferredDiffFormat();
244
245private:
246
247 HRESULT queryInfo();
248
249 HRESULT canClose();
250 HRESULT unregisterWithVirtualBox(bool *pfNeedsSaveSettings);
251
252 HRESULT setStateError();
253
254 HRESULT setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
255 HRESULT setFormat(const Utf8Str &aFormat);
256
257 Utf8Str vdError(int aVRC);
258
259 static DECLCALLBACK(void) vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
260 const char *pszFormat, va_list va);
261
262 static DECLCALLBACK(bool) vdConfigAreKeysValid(void *pvUser,
263 const char *pszzValid);
264 static DECLCALLBACK(int) vdConfigQuerySize(void *pvUser, const char *pszName,
265 size_t *pcbValue);
266 static DECLCALLBACK(int) vdConfigQuery(void *pvUser, const char *pszName,
267 char *pszValue, size_t cchValue);
268
269 static DECLCALLBACK(int) vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock);
270 static DECLCALLBACK(int) vdTcpSocketDestroy(VDSOCKET Sock);
271 static DECLCALLBACK(int) vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort);
272 static DECLCALLBACK(int) vdTcpClientClose(VDSOCKET Sock);
273 static DECLCALLBACK(bool) vdTcpIsClientConnected(VDSOCKET Sock);
274 static DECLCALLBACK(int) vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies);
275 static DECLCALLBACK(int) vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead);
276 static DECLCALLBACK(int) vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer);
277 static DECLCALLBACK(int) vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf);
278 static DECLCALLBACK(int) vdTcpFlush(VDSOCKET Sock);
279 static DECLCALLBACK(int) vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable);
280 static DECLCALLBACK(int) vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr);
281 static DECLCALLBACK(int) vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr);
282
283 class Task;
284 class CreateBaseTask;
285 class CreateDiffTask;
286 class CloneTask;
287 class CompactTask;
288 class ResetTask;
289 class DeleteTask;
290 class MergeTask;
291 friend class Task;
292 friend class CreateBaseTask;
293 friend class CreateDiffTask;
294 friend class CloneTask;
295 friend class CompactTask;
296 friend class ResetTask;
297 friend class DeleteTask;
298 friend class MergeTask;
299
300 HRESULT startThread(Medium::Task *pTask);
301 HRESULT runNow(Medium::Task *pTask, bool *pfNeedsSaveSettings);
302
303 HRESULT taskCreateBaseHandler(Medium::CreateBaseTask &task);
304 HRESULT taskCreateDiffHandler(Medium::CreateDiffTask &task);
305 HRESULT taskMergeHandler(Medium::MergeTask &task);
306 HRESULT taskCloneHandler(Medium::CloneTask &task);
307 HRESULT taskDeleteHandler(Medium::DeleteTask &task);
308 HRESULT taskResetHandler(Medium::ResetTask &task);
309 HRESULT taskCompactHandler(Medium::CompactTask &task);
310
311 struct Data; // opaque data struct, defined in MediumImpl.cpp
312 Data *m;
313};
314
315#endif /* ____H_MEDIUMIMPL */
316
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