1 | /* $Id: MachineImplMoveVM.cpp 98351 2023-01-30 19:26:27Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Implementation of MachineMoveVM
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2011-2023 Oracle and/or its affiliates.
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox base platform packages, as
|
---|
10 | * available from https://www.virtualbox.org.
|
---|
11 | *
|
---|
12 | * This program is free software; you can redistribute it and/or
|
---|
13 | * modify it under the terms of the GNU General Public License
|
---|
14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
15 | * License.
|
---|
16 | *
|
---|
17 | * This program is distributed in the hope that it will be useful, but
|
---|
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
20 | * General Public License for more details.
|
---|
21 | *
|
---|
22 | * You should have received a copy of the GNU General Public License
|
---|
23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
24 | *
|
---|
25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
26 | */
|
---|
27 |
|
---|
28 | #define LOG_GROUP LOG_GROUP_MAIN_MACHINE
|
---|
29 | #include <iprt/fs.h>
|
---|
30 | #include <iprt/dir.h>
|
---|
31 | #include <iprt/file.h>
|
---|
32 | #include <iprt/path.h>
|
---|
33 | #include <iprt/cpp/utils.h>
|
---|
34 | #include <iprt/stream.h>
|
---|
35 | #include <VBox/com/ErrorInfo.h>
|
---|
36 |
|
---|
37 | #include "MachineImplMoveVM.h"
|
---|
38 | #include "SnapshotImpl.h"
|
---|
39 | #include "MediumFormatImpl.h"
|
---|
40 | #include "VirtualBoxImpl.h"
|
---|
41 | #include "LoggingNew.h"
|
---|
42 |
|
---|
43 | typedef std::multimap<Utf8Str, Utf8Str> list_t;
|
---|
44 | typedef std::multimap<Utf8Str, Utf8Str>::const_iterator cit_t;
|
---|
45 | typedef std::multimap<Utf8Str, Utf8Str>::iterator it_t;
|
---|
46 | typedef std::pair <std::multimap<Utf8Str, Utf8Str>::iterator, std::multimap<Utf8Str, Utf8Str>::iterator> rangeRes_t;
|
---|
47 |
|
---|
48 | struct fileList_t
|
---|
49 | {
|
---|
50 | HRESULT add(const Utf8Str &folder, const Utf8Str &file)
|
---|
51 | {
|
---|
52 | m_list.insert(std::make_pair(folder, file));
|
---|
53 | return S_OK;
|
---|
54 | }
|
---|
55 |
|
---|
56 | HRESULT add(const Utf8Str &fullPath)
|
---|
57 | {
|
---|
58 | Utf8Str folder = fullPath;
|
---|
59 | folder.stripFilename();
|
---|
60 | Utf8Str filename = fullPath;
|
---|
61 | filename.stripPath();
|
---|
62 | m_list.insert(std::make_pair(folder, filename));
|
---|
63 | return S_OK;
|
---|
64 | }
|
---|
65 |
|
---|
66 | HRESULT removeFileFromList(const Utf8Str &fullPath)
|
---|
67 | {
|
---|
68 | Utf8Str folder = fullPath;
|
---|
69 | folder.stripFilename();
|
---|
70 | Utf8Str filename = fullPath;
|
---|
71 | filename.stripPath();
|
---|
72 | rangeRes_t res = m_list.equal_range(folder);
|
---|
73 | for (it_t it=res.first; it!=res.second;)
|
---|
74 | {
|
---|
75 | if (it->second.equals(filename))
|
---|
76 | {
|
---|
77 | it_t it2 = it;
|
---|
78 | ++it;
|
---|
79 | m_list.erase(it2);
|
---|
80 | }
|
---|
81 | else
|
---|
82 | ++it;
|
---|
83 | }
|
---|
84 |
|
---|
85 | return S_OK;
|
---|
86 | }
|
---|
87 |
|
---|
88 | HRESULT removeFileFromList(const Utf8Str &path, const Utf8Str &fileName)
|
---|
89 | {
|
---|
90 | rangeRes_t res = m_list.equal_range(path);
|
---|
91 | for (it_t it=res.first; it!=res.second;)
|
---|
92 | {
|
---|
93 | if (it->second.equals(fileName))
|
---|
94 | {
|
---|
95 | it_t it2 = it;
|
---|
96 | ++it;
|
---|
97 | m_list.erase(it2);
|
---|
98 | }
|
---|
99 | else
|
---|
100 | ++it;
|
---|
101 | }
|
---|
102 | return S_OK;
|
---|
103 | }
|
---|
104 |
|
---|
105 | HRESULT removeFolderFromList(const Utf8Str &path)
|
---|
106 | {
|
---|
107 | m_list.erase(path);
|
---|
108 | return S_OK;
|
---|
109 | }
|
---|
110 |
|
---|
111 | rangeRes_t getFilesInRange(const Utf8Str &path)
|
---|
112 | {
|
---|
113 | rangeRes_t res;
|
---|
114 | res = m_list.equal_range(path);
|
---|
115 | return res;
|
---|
116 | }
|
---|
117 |
|
---|
118 | std::list<Utf8Str> getFilesInList(const Utf8Str &path)
|
---|
119 | {
|
---|
120 | std::list<Utf8Str> list_;
|
---|
121 | rangeRes_t res = m_list.equal_range(path);
|
---|
122 | for (it_t it=res.first; it!=res.second; ++it)
|
---|
123 | list_.push_back(it->second);
|
---|
124 | return list_;
|
---|
125 | }
|
---|
126 |
|
---|
127 |
|
---|
128 | list_t m_list;
|
---|
129 |
|
---|
130 | };
|
---|
131 |
|
---|
132 |
|
---|
133 | HRESULT MachineMoveVM::init()
|
---|
134 | {
|
---|
135 | HRESULT hrc = S_OK;
|
---|
136 |
|
---|
137 | Utf8Str strTargetFolder;
|
---|
138 | /* adding a trailing slash if it's needed */
|
---|
139 | {
|
---|
140 | size_t len = m_targetPath.length() + 2;
|
---|
141 | if (len >= RTPATH_MAX)
|
---|
142 | return m_pMachine->setError(VBOX_E_IPRT_ERROR, tr("The destination path exceeds the maximum value."));
|
---|
143 |
|
---|
144 | /** @todo r=bird: I need to add a Utf8Str method or iprt/cxx/path.h thingy
|
---|
145 | * for doing this. We need this often and code like this doesn't
|
---|
146 | * need to be repeated and re-optimized in each instance... */
|
---|
147 | char *path = new char [len];
|
---|
148 | RTStrCopy(path, len, m_targetPath.c_str());
|
---|
149 | RTPathEnsureTrailingSeparator(path, len);
|
---|
150 | strTargetFolder = m_targetPath = path;
|
---|
151 | delete[] path;
|
---|
152 | }
|
---|
153 |
|
---|
154 | /*
|
---|
155 | * We have a mode which user is able to request
|
---|
156 | * basic mode:
|
---|
157 | * - The images which are solely attached to the VM
|
---|
158 | * and located in the original VM folder will be moved.
|
---|
159 | *
|
---|
160 | * Comment: in the future some other modes can be added.
|
---|
161 | */
|
---|
162 |
|
---|
163 | RTFOFF cbTotal = 0;
|
---|
164 | RTFOFF cbFree = 0;
|
---|
165 | uint32_t cbBlock = 0;
|
---|
166 | uint32_t cbSector = 0;
|
---|
167 |
|
---|
168 |
|
---|
169 | int vrc = RTFsQuerySizes(strTargetFolder.c_str(), &cbTotal, &cbFree, &cbBlock, &cbSector);
|
---|
170 | if (RT_FAILURE(vrc))
|
---|
171 | return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
172 | tr("Unable to determine free space at move destination ('%s'): %Rrc"),
|
---|
173 | strTargetFolder.c_str(), vrc);
|
---|
174 |
|
---|
175 | RTDIR hDir;
|
---|
176 | vrc = RTDirOpen(&hDir, strTargetFolder.c_str());
|
---|
177 | if (RT_FAILURE(vrc))
|
---|
178 | return m_pMachine->setErrorVrc(vrc);
|
---|
179 |
|
---|
180 | Utf8Str strTempFile = strTargetFolder + "test.txt";
|
---|
181 | RTFILE hFile;
|
---|
182 | vrc = RTFileOpen(&hFile, strTempFile.c_str(), RTFILE_O_OPEN_CREATE | RTFILE_O_READWRITE | RTFILE_O_DENY_NONE);
|
---|
183 | if (RT_FAILURE(vrc))
|
---|
184 | {
|
---|
185 | RTDirClose(hDir);
|
---|
186 | return m_pMachine->setErrorVrc(vrc,
|
---|
187 | tr("Can't create a test file test.txt in the %s. Check the access rights of the destination folder."),
|
---|
188 | strTargetFolder.c_str());
|
---|
189 | }
|
---|
190 |
|
---|
191 | /** @todo r=vvp: Do we need to check each return result here? Looks excessively.
|
---|
192 | * And it's not so important for the test file.
|
---|
193 | * bird: I'd just do AssertRC on the same line, though the deletion
|
---|
194 | * of the test is a little important. */
|
---|
195 | vrc = RTFileClose(hFile); AssertRC(vrc);
|
---|
196 | RTFileDelete(strTempFile.c_str());
|
---|
197 | vrc = RTDirClose(hDir); AssertRC(vrc);
|
---|
198 |
|
---|
199 | Log2(("blocks: total %RTfoff, free %RTfoff\n", cbTotal, cbFree));
|
---|
200 | Log2(("total space (Kb) %RTfoff (Mb) %RTfoff (Gb) %RTfoff\n", cbTotal/_1K, cbTotal/_1M, cbTotal/_1G));
|
---|
201 | Log2(("total free space (Kb) %RTfoff (Mb) %RTfoff (Gb) %RTfoff\n", cbFree/_1K, cbFree/_1M, cbFree/_1G));
|
---|
202 |
|
---|
203 | RTFSPROPERTIES properties;
|
---|
204 | vrc = RTFsQueryProperties(strTargetFolder.c_str(), &properties);
|
---|
205 | if (RT_FAILURE(vrc))
|
---|
206 | return m_pMachine->setErrorVrc(vrc, "RTFsQueryProperties(%s): %Rrc", strTargetFolder.c_str(), vrc);
|
---|
207 |
|
---|
208 | Log2(("disk properties: remote=%RTbool read only=%RTbool compressed=%RTbool\n",
|
---|
209 | properties.fRemote, properties.fReadOnly, properties.fCompressed));
|
---|
210 |
|
---|
211 | /* Get the original VM path */
|
---|
212 | Utf8Str strSettingsFilePath;
|
---|
213 | Bstr bstr_settingsFilePath;
|
---|
214 | hrc = m_pMachine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam());
|
---|
215 | if (FAILED(hrc))
|
---|
216 | return hrc;
|
---|
217 |
|
---|
218 | strSettingsFilePath = bstr_settingsFilePath;
|
---|
219 | strSettingsFilePath.stripFilename();
|
---|
220 |
|
---|
221 | m_vmFolders.insert(std::make_pair(VBox_SettingFolder, strSettingsFilePath));
|
---|
222 |
|
---|
223 | /* Collect all files from the VM's folder */
|
---|
224 | fileList_t fullFileList;
|
---|
225 | hrc = getFilesList(strSettingsFilePath, fullFileList);
|
---|
226 | if (FAILED(hrc))
|
---|
227 | return hrc;
|
---|
228 |
|
---|
229 | /*
|
---|
230 | * Collect all known folders used by the VM:
|
---|
231 | * - log folder;
|
---|
232 | * - state folder;
|
---|
233 | * - snapshot folder.
|
---|
234 | */
|
---|
235 | Utf8Str strLogFolder;
|
---|
236 | Bstr bstr_logFolder;
|
---|
237 | hrc = m_pMachine->COMGETTER(LogFolder)(bstr_logFolder.asOutParam());
|
---|
238 | if (FAILED(hrc))
|
---|
239 | return hrc;
|
---|
240 |
|
---|
241 | strLogFolder = bstr_logFolder;
|
---|
242 | if ( m_type.equals("basic")
|
---|
243 | && RTPathStartsWith(strLogFolder.c_str(), strSettingsFilePath.c_str()))
|
---|
244 | m_vmFolders.insert(std::make_pair(VBox_LogFolder, strLogFolder));
|
---|
245 |
|
---|
246 | Utf8Str strStateFilePath;
|
---|
247 | Bstr bstr_stateFilePath;
|
---|
248 | MachineState_T machineState;
|
---|
249 | hrc = m_pMachine->COMGETTER(State)(&machineState);
|
---|
250 | if (FAILED(hrc))
|
---|
251 | return hrc;
|
---|
252 |
|
---|
253 | if (machineState == MachineState_Saved || machineState == MachineState_AbortedSaved)
|
---|
254 | {
|
---|
255 | m_pMachine->COMGETTER(StateFilePath)(bstr_stateFilePath.asOutParam());
|
---|
256 | strStateFilePath = bstr_stateFilePath;
|
---|
257 | strStateFilePath.stripFilename();
|
---|
258 | if ( m_type.equals("basic")
|
---|
259 | && RTPathStartsWith(strStateFilePath.c_str(), strSettingsFilePath.c_str()))
|
---|
260 | m_vmFolders.insert(std::make_pair(VBox_StateFolder, strStateFilePath));
|
---|
261 | }
|
---|
262 |
|
---|
263 | Utf8Str strSnapshotFolder;
|
---|
264 | Bstr bstr_snapshotFolder;
|
---|
265 | hrc = m_pMachine->COMGETTER(SnapshotFolder)(bstr_snapshotFolder.asOutParam());
|
---|
266 | if (FAILED(hrc))
|
---|
267 | return hrc;
|
---|
268 |
|
---|
269 | strSnapshotFolder = bstr_snapshotFolder;
|
---|
270 | if ( m_type.equals("basic")
|
---|
271 | && RTPathStartsWith(strSnapshotFolder.c_str(), strSettingsFilePath.c_str()))
|
---|
272 | m_vmFolders.insert(std::make_pair(VBox_SnapshotFolder, strSnapshotFolder));
|
---|
273 |
|
---|
274 | if (m_pMachine->i_isSnapshotMachine())
|
---|
275 | {
|
---|
276 | Bstr bstrSrcMachineId;
|
---|
277 | hrc = m_pMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
|
---|
278 | if (FAILED(hrc))
|
---|
279 | return hrc;
|
---|
280 |
|
---|
281 | ComPtr<IMachine> newSrcMachine;
|
---|
282 | hrc = m_pMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
|
---|
283 | if (FAILED(hrc))
|
---|
284 | return hrc;
|
---|
285 | }
|
---|
286 |
|
---|
287 | /* Add the current machine and all snapshot machines below this machine
|
---|
288 | * in a list for further processing.
|
---|
289 | */
|
---|
290 |
|
---|
291 | int64_t neededFreeSpace = 0;
|
---|
292 |
|
---|
293 | /* Actual file list */
|
---|
294 | fileList_t actualFileList;
|
---|
295 | Utf8Str strTargetImageName;
|
---|
296 |
|
---|
297 | machineList.push_back(m_pMachine);
|
---|
298 |
|
---|
299 | {
|
---|
300 | ULONG cSnapshots = 0;
|
---|
301 | hrc = m_pMachine->COMGETTER(SnapshotCount)(&cSnapshots);
|
---|
302 | if (FAILED(hrc))
|
---|
303 | return hrc;
|
---|
304 |
|
---|
305 | if (cSnapshots > 0)
|
---|
306 | {
|
---|
307 | Utf8Str id;
|
---|
308 | if (m_pMachine->i_isSnapshotMachine())
|
---|
309 | id = m_pMachine->i_getSnapshotId().toString();
|
---|
310 | ComPtr<ISnapshot> pSnapshot;
|
---|
311 | hrc = m_pMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
|
---|
312 | if (FAILED(hrc))
|
---|
313 | return hrc;
|
---|
314 | hrc = createMachineList(pSnapshot);
|
---|
315 | if (FAILED(hrc))
|
---|
316 | return hrc;
|
---|
317 | }
|
---|
318 | }
|
---|
319 |
|
---|
320 | ULONG uCount = 1;//looks like it should be initialized by 1. See assertion in the Progress::setNextOperation()
|
---|
321 | ULONG uTotalWeight = 1;
|
---|
322 |
|
---|
323 | /* The lists m_llMedias, m_llSaveStateFiles and m_llNVRAMFiles are filled in the queryMediasForAllStates() */
|
---|
324 | hrc = queryMediasForAllStates();
|
---|
325 | if (FAILED(hrc))
|
---|
326 | return hrc;
|
---|
327 |
|
---|
328 | /* Calculate the total size of images. Fill m_finalMediumsMap */
|
---|
329 | { /** The scope here for better reading, apart from that the variables have limited scope too */
|
---|
330 | uint64_t totalMediumsSize = 0;
|
---|
331 |
|
---|
332 | for (size_t i = 0; i < m_llMedias.size(); ++i)
|
---|
333 | {
|
---|
334 | MEDIUMTASKCHAINMOVE &mtc = m_llMedias.at(i);
|
---|
335 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
336 | {
|
---|
337 | Bstr bstrLocation;
|
---|
338 | Utf8Str name = mtc.chain[a - 1].strBaseName;
|
---|
339 | ComPtr<IMedium> plMedium = mtc.chain[a - 1].pMedium;
|
---|
340 | hrc = plMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
341 | if (FAILED(hrc))
|
---|
342 | return hrc;
|
---|
343 |
|
---|
344 | Utf8Str strLocation = bstrLocation;
|
---|
345 |
|
---|
346 | /* if an image is located in the actual VM folder it will be added to the actual list */
|
---|
347 | if (strLocation.startsWith(strSettingsFilePath))
|
---|
348 | {
|
---|
349 | LONG64 cbSize = 0;
|
---|
350 | hrc = plMedium->COMGETTER(Size)(&cbSize);
|
---|
351 | if (FAILED(hrc))
|
---|
352 | return hrc;
|
---|
353 |
|
---|
354 | std::pair<std::map<Utf8Str, MEDIUMTASKMOVE>::iterator,bool> ret;
|
---|
355 | ret = m_finalMediumsMap.insert(std::make_pair(name, mtc.chain[a - 1]));
|
---|
356 | if (ret.second == true)
|
---|
357 | {
|
---|
358 | /* Calculate progress data */
|
---|
359 | ++uCount;
|
---|
360 | uTotalWeight += mtc.chain[a - 1].uWeight;
|
---|
361 | totalMediumsSize += (uint64_t)cbSize;
|
---|
362 | Log2(("Image %s was added into the moved list\n", name.c_str()));
|
---|
363 | }
|
---|
364 | }
|
---|
365 | }
|
---|
366 | }
|
---|
367 |
|
---|
368 | Log2(("Total Size of images is %lld bytes\n", totalMediumsSize));
|
---|
369 | neededFreeSpace += totalMediumsSize;
|
---|
370 | }
|
---|
371 |
|
---|
372 | /* Prepare data for moving ".sav" files */
|
---|
373 | {
|
---|
374 | uint64_t totalStateSize = 0;
|
---|
375 |
|
---|
376 | for (size_t i = 0; i < m_llSaveStateFiles.size(); ++i)
|
---|
377 | {
|
---|
378 | uint64_t cbFile = 0;
|
---|
379 | SNAPFILETASKMOVE &sft = m_llSaveStateFiles.at(i);
|
---|
380 |
|
---|
381 | Utf8Str name = sft.strFile;
|
---|
382 | /* if a state file is located in the actual VM folder it will be added to the actual list */
|
---|
383 | if (RTPathStartsWith(name.c_str(), strSettingsFilePath.c_str()))
|
---|
384 | {
|
---|
385 | vrc = RTFileQuerySizeByPath(name.c_str(), &cbFile);
|
---|
386 | if (RT_SUCCESS(vrc))
|
---|
387 | {
|
---|
388 | std::pair<std::map<Utf8Str, SNAPFILETASKMOVE>::iterator,bool> ret;
|
---|
389 | ret = m_finalSaveStateFilesMap.insert(std::make_pair(name, sft));
|
---|
390 | if (ret.second == true)
|
---|
391 | {
|
---|
392 | totalStateSize += cbFile;
|
---|
393 | ++uCount;
|
---|
394 | uTotalWeight += sft.uWeight;
|
---|
395 | Log2(("The state file %s was added into the moved list\n", name.c_str()));
|
---|
396 | }
|
---|
397 | }
|
---|
398 | else
|
---|
399 | {
|
---|
400 | Log2(("The state file %s wasn't added into the moved list. Couldn't get the file size.\n",
|
---|
401 | name.c_str()));
|
---|
402 | return m_pMachine->setErrorVrc(vrc,
|
---|
403 | tr("Failed to get file size for '%s': %Rrc"),
|
---|
404 | name.c_str(), vrc);
|
---|
405 | }
|
---|
406 | }
|
---|
407 | }
|
---|
408 |
|
---|
409 | neededFreeSpace += totalStateSize;
|
---|
410 | }
|
---|
411 |
|
---|
412 | /* Prepare data for moving ".nvram" files */
|
---|
413 | {
|
---|
414 | uint64_t totalNVRAMSize = 0;
|
---|
415 |
|
---|
416 | for (size_t i = 0; i < m_llNVRAMFiles.size(); ++i)
|
---|
417 | {
|
---|
418 | uint64_t cbFile = 0;
|
---|
419 | SNAPFILETASKMOVE &sft = m_llNVRAMFiles.at(i);
|
---|
420 |
|
---|
421 | Utf8Str name = sft.strFile;
|
---|
422 | /* if a NVRAM file is located in the actual VM folder it will be added to the actual list */
|
---|
423 | if (RTPathStartsWith(name.c_str(), strSettingsFilePath.c_str()))
|
---|
424 | {
|
---|
425 | vrc = RTFileQuerySizeByPath(name.c_str(), &cbFile);
|
---|
426 | if (RT_SUCCESS(vrc))
|
---|
427 | {
|
---|
428 | std::pair<std::map<Utf8Str, SNAPFILETASKMOVE>::iterator,bool> ret;
|
---|
429 | ret = m_finalNVRAMFilesMap.insert(std::make_pair(name, sft));
|
---|
430 | if (ret.second == true)
|
---|
431 | {
|
---|
432 | totalNVRAMSize += cbFile;
|
---|
433 | ++uCount;
|
---|
434 | uTotalWeight += sft.uWeight;
|
---|
435 | Log2(("The NVRAM file %s was added into the moved list\n", name.c_str()));
|
---|
436 | }
|
---|
437 | }
|
---|
438 | else
|
---|
439 | {
|
---|
440 | Log2(("The NVRAM file %s wasn't added into the moved list. Couldn't get the file size.\n",
|
---|
441 | name.c_str()));
|
---|
442 | return m_pMachine->setErrorVrc(vrc,
|
---|
443 | tr("Failed to get file size for '%s': %Rrc"),
|
---|
444 | name.c_str(), vrc);
|
---|
445 | }
|
---|
446 | }
|
---|
447 | }
|
---|
448 |
|
---|
449 | neededFreeSpace += totalNVRAMSize;
|
---|
450 | }
|
---|
451 |
|
---|
452 | /* Prepare data for moving the log files */
|
---|
453 | {
|
---|
454 | Utf8Str strFolder = m_vmFolders[VBox_LogFolder];
|
---|
455 |
|
---|
456 | if (RTPathExists(strFolder.c_str()))
|
---|
457 | {
|
---|
458 | uint64_t totalLogSize = 0;
|
---|
459 | hrc = getFolderSize(strFolder, totalLogSize);
|
---|
460 | if (SUCCEEDED(hrc))
|
---|
461 | {
|
---|
462 | neededFreeSpace += totalLogSize;
|
---|
463 | if (cbFree - neededFreeSpace <= _1M)
|
---|
464 | return m_pMachine->setError(E_FAIL,
|
---|
465 | tr("Insufficient disk space available (%RTfoff needed, %RTfoff free)"),
|
---|
466 | neededFreeSpace, cbFree);
|
---|
467 |
|
---|
468 | fileList_t filesList;
|
---|
469 | hrc = getFilesList(strFolder, filesList);
|
---|
470 | if (FAILED(hrc))
|
---|
471 | return hrc;
|
---|
472 |
|
---|
473 | cit_t it = filesList.m_list.begin();
|
---|
474 | while (it != filesList.m_list.end())
|
---|
475 | {
|
---|
476 | Utf8Str strFile = it->first.c_str();
|
---|
477 | strFile.append(RTPATH_DELIMITER).append(it->second.c_str());
|
---|
478 |
|
---|
479 | uint64_t cbFile = 0;
|
---|
480 | vrc = RTFileQuerySizeByPath(strFile.c_str(), &cbFile);
|
---|
481 | if (RT_SUCCESS(vrc))
|
---|
482 | {
|
---|
483 | uCount += 1;
|
---|
484 | uTotalWeight += (ULONG)((cbFile + _1M - 1) / _1M);
|
---|
485 | actualFileList.add(strFile);
|
---|
486 | Log2(("The log file %s added into the moved list\n", strFile.c_str()));
|
---|
487 | }
|
---|
488 | else
|
---|
489 | Log2(("The log file %s wasn't added into the moved list. Couldn't get the file size.\n", strFile.c_str()));
|
---|
490 | ++it;
|
---|
491 | }
|
---|
492 | }
|
---|
493 | else
|
---|
494 | return hrc;
|
---|
495 | }
|
---|
496 | else
|
---|
497 | {
|
---|
498 | Log2(("Information: The original log folder %s doesn't exist\n", strFolder.c_str()));
|
---|
499 | hrc = S_OK;//it's not error in this case if there isn't an original log folder
|
---|
500 | }
|
---|
501 | }
|
---|
502 |
|
---|
503 | LogRel(("Total space needed is %lld bytes\n", neededFreeSpace));
|
---|
504 | /* Check a target location on enough room */
|
---|
505 | if (cbFree - neededFreeSpace <= _1M)
|
---|
506 | {
|
---|
507 | LogRel(("but free space on destination is %RTfoff\n", cbFree));
|
---|
508 | return m_pMachine->setError(VBOX_E_IPRT_ERROR,
|
---|
509 | tr("Insufficient disk space available (%RTfoff needed, %RTfoff free)"),
|
---|
510 | neededFreeSpace, cbFree);
|
---|
511 | }
|
---|
512 |
|
---|
513 | /* Add step for .vbox machine setting file */
|
---|
514 | ++uCount;
|
---|
515 | uTotalWeight += 1;
|
---|
516 |
|
---|
517 | /* Reserve additional steps in case of failure and rollback all changes */
|
---|
518 | uTotalWeight += uCount;//just add 1 for each possible rollback operation
|
---|
519 | uCount += uCount;//and increase the steps twice
|
---|
520 |
|
---|
521 | /* Init Progress instance */
|
---|
522 | {
|
---|
523 | hrc = m_pProgress->init(m_pMachine->i_getVirtualBox(),
|
---|
524 | static_cast<IMachine *>(m_pMachine) /* aInitiator */,
|
---|
525 | Utf8Str(tr("Moving Machine")),
|
---|
526 | true /* fCancellable */,
|
---|
527 | uCount,
|
---|
528 | uTotalWeight,
|
---|
529 | Utf8Str(tr("Initialize Moving")),
|
---|
530 | 1);
|
---|
531 | if (FAILED(hrc))
|
---|
532 | return m_pMachine->setError(hrc,
|
---|
533 | tr("Couldn't correctly setup the progress object for moving VM operation"));
|
---|
534 | }
|
---|
535 |
|
---|
536 | /* save all VM data */
|
---|
537 | m_pMachine->i_setModified(Machine::IsModified_MachineData);
|
---|
538 | hrc = m_pMachine->SaveSettings();
|
---|
539 | if (FAILED(hrc))
|
---|
540 | return hrc;
|
---|
541 |
|
---|
542 | LogFlowFuncLeave();
|
---|
543 |
|
---|
544 | return hrc;
|
---|
545 | }
|
---|
546 |
|
---|
547 | void MachineMoveVM::printStateFile(settings::SnapshotsList &snl)
|
---|
548 | {
|
---|
549 | settings::SnapshotsList::iterator it;
|
---|
550 | for (it = snl.begin(); it != snl.end(); ++it)
|
---|
551 | {
|
---|
552 | if (!it->strStateFile.isEmpty())
|
---|
553 | {
|
---|
554 | settings::Snapshot snap = (settings::Snapshot)(*it);
|
---|
555 | Log2(("snap.uuid = %s\n", snap.uuid.toStringCurly().c_str()));
|
---|
556 | Log2(("snap.strStateFile = %s\n", snap.strStateFile.c_str()));
|
---|
557 | }
|
---|
558 |
|
---|
559 | if (!it->llChildSnapshots.empty())
|
---|
560 | printStateFile(it->llChildSnapshots);
|
---|
561 | }
|
---|
562 | }
|
---|
563 |
|
---|
564 | /* static */
|
---|
565 | DECLCALLBACK(int) MachineMoveVM::updateProgress(unsigned uPercent, void *pvUser)
|
---|
566 | {
|
---|
567 | MachineMoveVM *pTask = *(MachineMoveVM **)pvUser;
|
---|
568 |
|
---|
569 | if ( pTask
|
---|
570 | && !pTask->m_pProgress.isNull())
|
---|
571 | {
|
---|
572 | BOOL fCanceled;
|
---|
573 | pTask->m_pProgress->COMGETTER(Canceled)(&fCanceled);
|
---|
574 | if (fCanceled)
|
---|
575 | return -1;
|
---|
576 | pTask->m_pProgress->SetCurrentOperationProgress(uPercent);
|
---|
577 | }
|
---|
578 | return VINF_SUCCESS;
|
---|
579 | }
|
---|
580 |
|
---|
581 | /* static */
|
---|
582 | DECLCALLBACK(int) MachineMoveVM::copyFileProgress(unsigned uPercentage, void *pvUser)
|
---|
583 | {
|
---|
584 | ComObjPtr<Progress> pProgress = *static_cast<ComObjPtr<Progress> *>(pvUser);
|
---|
585 |
|
---|
586 | BOOL fCanceled = false;
|
---|
587 | HRESULT hrc = pProgress->COMGETTER(Canceled)(&fCanceled);
|
---|
588 | if (FAILED(hrc)) return VERR_GENERAL_FAILURE;
|
---|
589 | /* If canceled by the user tell it to the copy operation. */
|
---|
590 | if (fCanceled) return VERR_CANCELLED;
|
---|
591 | /* Set the new process. */
|
---|
592 | hrc = pProgress->SetCurrentOperationProgress(uPercentage);
|
---|
593 | if (FAILED(hrc)) return VERR_GENERAL_FAILURE;
|
---|
594 |
|
---|
595 | return VINF_SUCCESS;
|
---|
596 | }
|
---|
597 |
|
---|
598 | /* static */
|
---|
599 | void MachineMoveVM::i_MoveVMThreadTask(MachineMoveVM *task)
|
---|
600 | {
|
---|
601 | LogFlowFuncEnter();
|
---|
602 | HRESULT hrc = S_OK;
|
---|
603 |
|
---|
604 | MachineMoveVM *taskMoveVM = task;
|
---|
605 | ComObjPtr<Machine> &machine = taskMoveVM->m_pMachine;
|
---|
606 |
|
---|
607 | AutoCaller autoCaller(machine);
|
---|
608 | // if (FAILED(autoCaller.hrc())) return;//Should we return something here?
|
---|
609 |
|
---|
610 | Utf8Str strTargetFolder = taskMoveVM->m_targetPath;
|
---|
611 | {
|
---|
612 | Bstr bstrMachineName;
|
---|
613 | hrc = machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
614 | if (FAILED(hrc))
|
---|
615 | {
|
---|
616 | taskMoveVM->m_result = hrc;
|
---|
617 | if (!taskMoveVM->m_pProgress.isNull())
|
---|
618 | taskMoveVM->m_pProgress->i_notifyComplete(taskMoveVM->m_result);
|
---|
619 | return;
|
---|
620 | }
|
---|
621 | strTargetFolder.append(Utf8Str(bstrMachineName));
|
---|
622 | }
|
---|
623 |
|
---|
624 | RTCList<Utf8Str> newFiles; /* All extra created files (save states, ...) */
|
---|
625 | RTCList<Utf8Str> originalFiles; /* All original files except images */
|
---|
626 | typedef std::map<Utf8Str, ComObjPtr<Medium> > MediumMap;
|
---|
627 | MediumMap mapOriginalMedium;
|
---|
628 |
|
---|
629 | /*
|
---|
630 | * We have the couple modes which user is able to request
|
---|
631 | * basic mode:
|
---|
632 | * - The images which are solely attached to the VM
|
---|
633 | * and located in the original VM folder will be moved.
|
---|
634 | * All subfolders related to the original VM are also moved from the original location
|
---|
635 | * (Standard - snapshots and logs folders).
|
---|
636 | *
|
---|
637 | * canonical mode:
|
---|
638 | * - All disks tied with the VM will be moved into a new location if it's possible.
|
---|
639 | * All folders related to the original VM are also moved.
|
---|
640 | * This mode is intended to collect all files/images/snapshots related to the VM in the one place.
|
---|
641 | *
|
---|
642 | */
|
---|
643 |
|
---|
644 | /*
|
---|
645 | * A way to handle shareable disk:
|
---|
646 | * Collect the shareable disks attched to the VM.
|
---|
647 | * Get the machines whom the shareable disks attach to.
|
---|
648 | * Return an error if the state of any VM doesn't allow to move a shareable disk and
|
---|
649 | * this disk is located in the VM's folder (it means the disk is intended for "moving").
|
---|
650 | */
|
---|
651 |
|
---|
652 |
|
---|
653 | /*
|
---|
654 | * Check new destination whether enough room for the VM or not. if "not" return an error.
|
---|
655 | * Make a copy of VM settings and a list with all files which are moved. Save the list on the disk.
|
---|
656 | * Start "move" operation.
|
---|
657 | * Check the result of operation.
|
---|
658 | * if the operation was successful:
|
---|
659 | * - delete all files in the original VM folder;
|
---|
660 | * - update VM disks info with new location;
|
---|
661 | * - update all other VM if it's needed;
|
---|
662 | * - update global settings
|
---|
663 | */
|
---|
664 |
|
---|
665 | try
|
---|
666 | {
|
---|
667 | /* Move all disks */
|
---|
668 | hrc = taskMoveVM->moveAllDisks(taskMoveVM->m_finalMediumsMap, strTargetFolder);
|
---|
669 | if (FAILED(hrc))
|
---|
670 | throw hrc;
|
---|
671 |
|
---|
672 | /* Get Machine::Data here because moveAllDisks() change it */
|
---|
673 | Machine::Data *machineData = machine->mData.data();
|
---|
674 | settings::MachineConfigFile *machineConfFile = machineData->pMachineConfigFile;
|
---|
675 |
|
---|
676 | /* Copy all save state files. */
|
---|
677 | Utf8Str strTrgSnapshotFolder;
|
---|
678 | {
|
---|
679 | /* When the current snapshot folder is absolute we reset it to the
|
---|
680 | * default relative folder. */
|
---|
681 | if (RTPathStartsWithRoot(machineConfFile->machineUserData.strSnapshotFolder.c_str()))
|
---|
682 | machineConfFile->machineUserData.strSnapshotFolder = "Snapshots";
|
---|
683 | machineConfFile->strStateFile = "";
|
---|
684 |
|
---|
685 | /* The absolute name of the snapshot folder. */
|
---|
686 | strTrgSnapshotFolder = Utf8StrFmt("%s%c%s", strTargetFolder.c_str(), RTPATH_DELIMITER,
|
---|
687 | machineConfFile->machineUserData.strSnapshotFolder.c_str());
|
---|
688 |
|
---|
689 | /* Check if a snapshot folder is necessary and if so doesn't already
|
---|
690 | * exists. */
|
---|
691 | if ( ( taskMoveVM->m_finalSaveStateFilesMap.size() > 0
|
---|
692 | || taskMoveVM->m_finalNVRAMFilesMap.size() > 1)
|
---|
693 | && !RTDirExists(strTrgSnapshotFolder.c_str()))
|
---|
694 | {
|
---|
695 | int vrc = RTDirCreateFullPath(strTrgSnapshotFolder.c_str(), 0700);
|
---|
696 | if (RT_FAILURE(vrc))
|
---|
697 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
698 | tr("Could not create snapshots folder '%s' (%Rrc)"),
|
---|
699 | strTrgSnapshotFolder.c_str(), vrc);
|
---|
700 | }
|
---|
701 |
|
---|
702 | std::map<Utf8Str, SNAPFILETASKMOVE>::iterator itState = taskMoveVM->m_finalSaveStateFilesMap.begin();
|
---|
703 | while (itState != taskMoveVM->m_finalSaveStateFilesMap.end())
|
---|
704 | {
|
---|
705 | const SNAPFILETASKMOVE &sft = itState->second;
|
---|
706 | const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
|
---|
707 | RTPathFilename(sft.strFile.c_str()));
|
---|
708 |
|
---|
709 | /* Move to next sub-operation. */
|
---|
710 | hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(tr("Copy the save state file '%s' ..."),
|
---|
711 | RTPathFilename(sft.strFile.c_str())).raw(),
|
---|
712 | sft.uWeight);
|
---|
713 | if (FAILED(hrc))
|
---|
714 | throw hrc;
|
---|
715 |
|
---|
716 | int vrc = RTFileCopyEx(sft.strFile.c_str(), strTrgSaveState.c_str(), 0,
|
---|
717 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
718 | if (RT_FAILURE(vrc))
|
---|
719 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
720 | tr("Could not copy state file '%s' to '%s' (%Rrc)"),
|
---|
721 | sft.strFile.c_str(),
|
---|
722 | strTrgSaveState.c_str(),
|
---|
723 | vrc);
|
---|
724 |
|
---|
725 | /* save new file in case of restoring */
|
---|
726 | newFiles.append(strTrgSaveState);
|
---|
727 | /* save original file for deletion in the end */
|
---|
728 | originalFiles.append(sft.strFile);
|
---|
729 | ++itState;
|
---|
730 | }
|
---|
731 |
|
---|
732 | std::map<Utf8Str, SNAPFILETASKMOVE>::iterator itNVRAM = taskMoveVM->m_finalNVRAMFilesMap.begin();
|
---|
733 | while (itNVRAM != taskMoveVM->m_finalNVRAMFilesMap.end())
|
---|
734 | {
|
---|
735 | const SNAPFILETASKMOVE &sft = itNVRAM->second;
|
---|
736 | const Utf8Str &strTrgNVRAM = Utf8StrFmt("%s%c%s", sft.snapshotUuid.isZero() ? strTargetFolder.c_str() : strTrgSnapshotFolder.c_str(),
|
---|
737 | RTPATH_DELIMITER, RTPathFilename(sft.strFile.c_str()));
|
---|
738 |
|
---|
739 | /* Move to next sub-operation. */
|
---|
740 | hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(tr("Copy the NVRAM file '%s' ..."),
|
---|
741 | RTPathFilename(sft.strFile.c_str())).raw(),
|
---|
742 | sft.uWeight);
|
---|
743 | if (FAILED(hrc))
|
---|
744 | throw hrc;
|
---|
745 |
|
---|
746 | int vrc = RTFileCopyEx(sft.strFile.c_str(), strTrgNVRAM.c_str(), 0,
|
---|
747 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
748 | if (RT_FAILURE(vrc))
|
---|
749 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
750 | tr("Could not copy NVRAM file '%s' to '%s' (%Rrc)"),
|
---|
751 | sft.strFile.c_str(),
|
---|
752 | strTrgNVRAM.c_str(),
|
---|
753 | vrc);
|
---|
754 |
|
---|
755 | /* save new file in case of restoring */
|
---|
756 | newFiles.append(strTrgNVRAM);
|
---|
757 | /* save original file for deletion in the end */
|
---|
758 | originalFiles.append(sft.strFile);
|
---|
759 | ++itNVRAM;
|
---|
760 | }
|
---|
761 | }
|
---|
762 |
|
---|
763 | /*
|
---|
764 | * Update state file path
|
---|
765 | * very important step!
|
---|
766 | */
|
---|
767 | Log2(("Update state file path\n"));
|
---|
768 | /** @todo r=klaus: this update is not necessarily matching what the
|
---|
769 | * above code has set as the new folders, so it needs reimplementing */
|
---|
770 | taskMoveVM->updatePathsToStateFiles(taskMoveVM->m_vmFolders[VBox_SettingFolder],
|
---|
771 | strTargetFolder);
|
---|
772 |
|
---|
773 | /*
|
---|
774 | * Update NVRAM file paths
|
---|
775 | * very important step!
|
---|
776 | */
|
---|
777 | Log2(("Update NVRAM paths\n"));
|
---|
778 | /** @todo r=klaus: this update is not necessarily matching what the
|
---|
779 | * above code has set as the new folders, so it needs reimplementing.
|
---|
780 | * What's good about this implementation: it does not look at the
|
---|
781 | * list of NVRAM files, because that only lists the existing ones,
|
---|
782 | * but all paths need fixing. */
|
---|
783 | taskMoveVM->updatePathsToNVRAMFiles(taskMoveVM->m_vmFolders[VBox_SettingFolder],
|
---|
784 | strTargetFolder);
|
---|
785 |
|
---|
786 | /*
|
---|
787 | * Moving Machine settings file
|
---|
788 | * The settings file are moved after all disks and snapshots because this file should be updated
|
---|
789 | * with actual information and only then should be moved.
|
---|
790 | */
|
---|
791 | {
|
---|
792 | Log2(("Copy Machine settings file\n"));
|
---|
793 |
|
---|
794 | hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(tr("Copy Machine settings file '%s' ..."),
|
---|
795 | machineConfFile->machineUserData.strName.c_str()).raw(),
|
---|
796 | 1);
|
---|
797 | if (FAILED(hrc))
|
---|
798 | throw hrc;
|
---|
799 |
|
---|
800 | Utf8Str strTargetSettingsFilePath = strTargetFolder;
|
---|
801 |
|
---|
802 | /* Check a folder existing and create one if it's not */
|
---|
803 | if (!RTDirExists(strTargetSettingsFilePath.c_str()))
|
---|
804 | {
|
---|
805 | int vrc = RTDirCreateFullPath(strTargetSettingsFilePath.c_str(), 0700);
|
---|
806 | if (RT_FAILURE(vrc))
|
---|
807 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
808 | tr("Could not create a home machine folder '%s' (%Rrc)"),
|
---|
809 | strTargetSettingsFilePath.c_str(), vrc);
|
---|
810 |
|
---|
811 | Log2(("Created a home machine folder %s\n", strTargetSettingsFilePath.c_str()));
|
---|
812 | }
|
---|
813 |
|
---|
814 | /* Create a full path */
|
---|
815 | Bstr bstrMachineName;
|
---|
816 | machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
817 | if (FAILED(hrc))
|
---|
818 | throw hrc;
|
---|
819 | strTargetSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName));
|
---|
820 | strTargetSettingsFilePath.append(".vbox");
|
---|
821 |
|
---|
822 | Utf8Str strSettingsFilePath;
|
---|
823 | Bstr bstr_settingsFilePath;
|
---|
824 | machine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam());
|
---|
825 | if (FAILED(hrc))
|
---|
826 | throw hrc;
|
---|
827 | strSettingsFilePath = bstr_settingsFilePath;
|
---|
828 |
|
---|
829 | int vrc = RTFileCopyEx(strSettingsFilePath.c_str(), strTargetSettingsFilePath.c_str(), 0,
|
---|
830 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
831 | if (RT_FAILURE(vrc))
|
---|
832 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
833 | tr("Could not copy the setting file '%s' to '%s' (%Rrc)"),
|
---|
834 | strSettingsFilePath.c_str(),
|
---|
835 | strTargetSettingsFilePath.stripFilename().c_str(),
|
---|
836 | vrc);
|
---|
837 |
|
---|
838 | Log2(("The setting file %s has been copied into the folder %s\n",
|
---|
839 | strSettingsFilePath.c_str(), strTargetSettingsFilePath.stripFilename().c_str()));
|
---|
840 |
|
---|
841 | /* save new file in case of restoring */
|
---|
842 | newFiles.append(strTargetSettingsFilePath);
|
---|
843 | /* save original file for deletion in the end */
|
---|
844 | originalFiles.append(strSettingsFilePath);
|
---|
845 |
|
---|
846 | Utf8Str strPrevSettingsFilePath = strSettingsFilePath;
|
---|
847 | strPrevSettingsFilePath.append("-prev");
|
---|
848 | if (RTFileExists(strPrevSettingsFilePath.c_str()))
|
---|
849 | originalFiles.append(strPrevSettingsFilePath);
|
---|
850 | }
|
---|
851 |
|
---|
852 | /* Moving Machine log files */
|
---|
853 | {
|
---|
854 | Log2(("Copy machine log files\n"));
|
---|
855 |
|
---|
856 | if (taskMoveVM->m_vmFolders[VBox_LogFolder].isNotEmpty())
|
---|
857 | {
|
---|
858 | /* Check an original log folder existence */
|
---|
859 | if (RTDirExists(taskMoveVM->m_vmFolders[VBox_LogFolder].c_str()))
|
---|
860 | {
|
---|
861 | Utf8Str strTargetLogFolderPath = strTargetFolder;
|
---|
862 | strTargetLogFolderPath.append(RTPATH_DELIMITER).append("Logs");
|
---|
863 |
|
---|
864 | /* Check a destination log folder existence and create one if it's not */
|
---|
865 | if (!RTDirExists(strTargetLogFolderPath.c_str()))
|
---|
866 | {
|
---|
867 | int vrc = RTDirCreateFullPath(strTargetLogFolderPath.c_str(), 0700);
|
---|
868 | if (RT_FAILURE(vrc))
|
---|
869 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
870 | tr("Could not create log folder '%s' (%Rrc)"),
|
---|
871 | strTargetLogFolderPath.c_str(), vrc);
|
---|
872 |
|
---|
873 | Log2(("Created a log machine folder %s\n", strTargetLogFolderPath.c_str()));
|
---|
874 | }
|
---|
875 |
|
---|
876 | fileList_t filesList;
|
---|
877 | taskMoveVM->getFilesList(taskMoveVM->m_vmFolders[VBox_LogFolder], filesList);
|
---|
878 | cit_t it = filesList.m_list.begin();
|
---|
879 | while (it != filesList.m_list.end())
|
---|
880 | {
|
---|
881 | Utf8Str strFullSourceFilePath = it->first.c_str();
|
---|
882 | strFullSourceFilePath.append(RTPATH_DELIMITER).append(it->second.c_str());
|
---|
883 |
|
---|
884 | Utf8Str strFullTargetFilePath = strTargetLogFolderPath;
|
---|
885 | strFullTargetFilePath.append(RTPATH_DELIMITER).append(it->second.c_str());
|
---|
886 |
|
---|
887 | /* Move to next sub-operation. */
|
---|
888 | hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(tr("Copying the log file '%s' ..."),
|
---|
889 | RTPathFilename(strFullSourceFilePath.c_str())).raw(),
|
---|
890 | 1);
|
---|
891 | if (FAILED(hrc))
|
---|
892 | throw hrc;
|
---|
893 |
|
---|
894 | int vrc = RTFileCopyEx(strFullSourceFilePath.c_str(), strFullTargetFilePath.c_str(), 0,
|
---|
895 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
896 | if (RT_FAILURE(vrc))
|
---|
897 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
898 | tr("Could not copy the log file '%s' to '%s' (%Rrc)"),
|
---|
899 | strFullSourceFilePath.c_str(),
|
---|
900 | strFullTargetFilePath.stripFilename().c_str(),
|
---|
901 | vrc);
|
---|
902 |
|
---|
903 | Log2(("The log file %s has been copied into the folder %s\n", strFullSourceFilePath.c_str(),
|
---|
904 | strFullTargetFilePath.stripFilename().c_str()));
|
---|
905 |
|
---|
906 | /* save new file in case of restoring */
|
---|
907 | newFiles.append(strFullTargetFilePath);
|
---|
908 | /* save original file for deletion in the end */
|
---|
909 | originalFiles.append(strFullSourceFilePath);
|
---|
910 |
|
---|
911 | ++it;
|
---|
912 | }
|
---|
913 | }
|
---|
914 | }
|
---|
915 | }
|
---|
916 |
|
---|
917 | /* save all VM data */
|
---|
918 | hrc = machine->SaveSettings();
|
---|
919 | if (FAILED(hrc))
|
---|
920 | throw hrc;
|
---|
921 |
|
---|
922 | Log2(("Update path to XML setting file\n"));
|
---|
923 | Utf8Str strTargetSettingsFilePath = strTargetFolder;
|
---|
924 | Bstr bstrMachineName;
|
---|
925 | hrc = machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
926 | if (FAILED(hrc))
|
---|
927 | throw hrc;
|
---|
928 | strTargetSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
|
---|
929 | machineData->m_strConfigFileFull = strTargetSettingsFilePath;
|
---|
930 | machine->mParent->i_copyPathRelativeToConfig(strTargetSettingsFilePath, machineData->m_strConfigFile);
|
---|
931 |
|
---|
932 | /* Marks the global registry for uuid as modified */
|
---|
933 | Guid uuid = machine->mData->mUuid;
|
---|
934 | machine->mParent->i_markRegistryModified(uuid);
|
---|
935 |
|
---|
936 | /* for saving the global settings we should hold only the VirtualBox lock */
|
---|
937 | AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
|
---|
938 |
|
---|
939 | /* Save global settings in the VirtualBox.xml */
|
---|
940 | hrc = machine->mParent->i_saveSettings();
|
---|
941 | if (FAILED(hrc))
|
---|
942 | throw hrc;
|
---|
943 | }
|
---|
944 | catch(HRESULT aRc)
|
---|
945 | {
|
---|
946 | hrc = aRc;
|
---|
947 | taskMoveVM->m_result = hrc;
|
---|
948 | }
|
---|
949 | catch (...)
|
---|
950 | {
|
---|
951 | Log2(("Moving machine to a new destination was failed. Check original and destination places.\n"));
|
---|
952 | hrc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
|
---|
953 | taskMoveVM->m_result = hrc;
|
---|
954 | }
|
---|
955 |
|
---|
956 | /* Cleanup on failure */
|
---|
957 | if (FAILED(hrc))
|
---|
958 | {
|
---|
959 | Machine::Data *machineData = machine->mData.data();
|
---|
960 |
|
---|
961 | /* Restoring the original media */
|
---|
962 | try
|
---|
963 | {
|
---|
964 | /*
|
---|
965 | * Fix the progress counter
|
---|
966 | * In instance, the whole "move vm" operation is failed on 5th step. But total count is 20.
|
---|
967 | * Where 20 = 2 * 10 operations, where 10 is the real number of operations. And this value was doubled
|
---|
968 | * earlier in the init() exactly for one reason - rollback operation. Because in this case we must do
|
---|
969 | * the same operations but in backward direction.
|
---|
970 | * Thus now we want to correct the progress counter from 5 to 15. Why?
|
---|
971 | * Because we should have evaluated the counter as "20/2 + (20/2 - 5)" = 15 or just "20 - 5" = 15
|
---|
972 | * And because the 5th step failed it shouldn't be counted.
|
---|
973 | * As result, we need to rollback 4 operations.
|
---|
974 | * Thus we start from "operation + 1" and finish when "i < operationCount - operation".
|
---|
975 | */
|
---|
976 |
|
---|
977 | /** @todo r=vvp: Do we need to check each return result here? Looks excessively
|
---|
978 | * and what to do with any failure here? We are already in the rollback action.
|
---|
979 | * Throw only the important errors?
|
---|
980 | * We MUST finish this action anyway to avoid garbage and get the original VM state. */
|
---|
981 | /* ! Apparently we should update the Progress object !*/
|
---|
982 | ULONG operationCount = 0;
|
---|
983 | hrc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
|
---|
984 | if (FAILED(hrc))
|
---|
985 | throw hrc;
|
---|
986 | ULONG operation = 0;
|
---|
987 | hrc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
|
---|
988 | if (FAILED(hrc))
|
---|
989 | throw hrc;
|
---|
990 | Bstr bstrOperationDescription;
|
---|
991 | hrc = taskMoveVM->m_pProgress->COMGETTER(OperationDescription)(bstrOperationDescription.asOutParam());
|
---|
992 | if (FAILED(hrc))
|
---|
993 | throw hrc;
|
---|
994 | Utf8Str strOperationDescription = bstrOperationDescription;
|
---|
995 | ULONG operationPercent = 0;
|
---|
996 | hrc = taskMoveVM->m_pProgress->COMGETTER(OperationPercent)(&operationPercent);
|
---|
997 | if (FAILED(hrc))
|
---|
998 | throw hrc;
|
---|
999 | Bstr bstrMachineName;
|
---|
1000 | hrc = machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
1001 | if (FAILED(hrc))
|
---|
1002 | throw hrc;
|
---|
1003 |
|
---|
1004 | Log2(("Moving machine %s was failed on operation %s\n",
|
---|
1005 | Utf8Str(bstrMachineName.raw()).c_str(), Utf8Str(bstrOperationDescription.raw()).c_str()));
|
---|
1006 |
|
---|
1007 | for (ULONG i = operation + 1; i < operationCount - operation; ++i)
|
---|
1008 | taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(tr("Skip the empty operation %d..."), i + 1).raw(), 1);
|
---|
1009 |
|
---|
1010 | hrc = taskMoveVM->moveAllDisks(taskMoveVM->m_finalMediumsMap);
|
---|
1011 | if (FAILED(hrc))
|
---|
1012 | throw hrc;
|
---|
1013 |
|
---|
1014 | /* Revert original paths to the state files */
|
---|
1015 | taskMoveVM->updatePathsToStateFiles(strTargetFolder,
|
---|
1016 | taskMoveVM->m_vmFolders[VBox_SettingFolder]);
|
---|
1017 |
|
---|
1018 | /* Revert original paths to the NVRAM files */
|
---|
1019 | taskMoveVM->updatePathsToNVRAMFiles(strTargetFolder,
|
---|
1020 | taskMoveVM->m_vmFolders[VBox_SettingFolder]);
|
---|
1021 |
|
---|
1022 | /* Delete all created files. Here we update progress object */
|
---|
1023 | hrc = taskMoveVM->deleteFiles(newFiles);
|
---|
1024 | if (FAILED(hrc))
|
---|
1025 | {
|
---|
1026 | Log2(("Rollback scenario: can't delete new created files. Check the destination folder.\n"));
|
---|
1027 | throw hrc;
|
---|
1028 | }
|
---|
1029 |
|
---|
1030 | /* Delete destination folder */
|
---|
1031 | int vrc = RTDirRemove(strTargetFolder.c_str());
|
---|
1032 | if (RT_FAILURE(vrc))
|
---|
1033 | {
|
---|
1034 | Log2(("Rollback scenario: can't delete new destination folder.\n"));
|
---|
1035 | throw machine->setErrorVrc(vrc, tr("Rollback scenario: can't delete new destination folder."));
|
---|
1036 | }
|
---|
1037 |
|
---|
1038 | /* save all VM data */
|
---|
1039 | {
|
---|
1040 | AutoWriteLock srcLock(machine COMMA_LOCKVAL_SRC_POS);
|
---|
1041 | srcLock.release();
|
---|
1042 | hrc = machine->SaveSettings();
|
---|
1043 | if (FAILED(hrc))
|
---|
1044 | {
|
---|
1045 | Log2(("Rollback scenario: can't save machine settings.\n"));
|
---|
1046 | throw hrc;
|
---|
1047 | }
|
---|
1048 | srcLock.acquire();
|
---|
1049 | }
|
---|
1050 |
|
---|
1051 | /* Restore an original path to XML setting file */
|
---|
1052 | {
|
---|
1053 | Log2(("Rollback scenario: restoration of the original path to XML setting file\n"));
|
---|
1054 | Utf8Str strOriginalSettingsFilePath = taskMoveVM->m_vmFolders[VBox_SettingFolder];
|
---|
1055 | strOriginalSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
|
---|
1056 | machineData->m_strConfigFileFull = strOriginalSettingsFilePath;
|
---|
1057 | machine->mParent->i_copyPathRelativeToConfig(strOriginalSettingsFilePath, machineData->m_strConfigFile);
|
---|
1058 | }
|
---|
1059 |
|
---|
1060 | /* Marks the global registry for uuid as modified */
|
---|
1061 | {
|
---|
1062 | AutoWriteLock srcLock(machine COMMA_LOCKVAL_SRC_POS);
|
---|
1063 | srcLock.release();
|
---|
1064 | Guid uuid = machine->mData->mUuid;
|
---|
1065 | machine->mParent->i_markRegistryModified(uuid);
|
---|
1066 | srcLock.acquire();
|
---|
1067 | }
|
---|
1068 |
|
---|
1069 | /* save the global settings; for that we should hold only the VirtualBox lock */
|
---|
1070 | {
|
---|
1071 | AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
|
---|
1072 | hrc = machine->mParent->i_saveSettings();
|
---|
1073 | if (FAILED(hrc))
|
---|
1074 | {
|
---|
1075 | Log2(("Rollback scenario: can't save global settings.\n"));
|
---|
1076 | throw hrc;
|
---|
1077 | }
|
---|
1078 | }
|
---|
1079 | }
|
---|
1080 | catch(HRESULT aRc)
|
---|
1081 | {
|
---|
1082 | hrc = aRc;
|
---|
1083 | Log2(("Rollback scenario: restoration the original media failed. Machine can be corrupted.\n"));
|
---|
1084 | }
|
---|
1085 | catch (...)
|
---|
1086 | {
|
---|
1087 | Log2(("Rollback scenario: restoration the original media failed. Machine can be corrupted.\n"));
|
---|
1088 | hrc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
|
---|
1089 | }
|
---|
1090 | /* In case of failure the progress object on the other side (user side) get notification about operation
|
---|
1091 | completion but the operation percentage may not be set to 100% */
|
---|
1092 | }
|
---|
1093 | else /*Operation was successful and now we can delete the original files like the state files, XML setting, log files */
|
---|
1094 | {
|
---|
1095 | /*
|
---|
1096 | * In case of success it's not urgent to update the progress object because we call i_notifyComplete() with
|
---|
1097 | * the success result. As result, the last number of progress operation can be not equal the number of operations
|
---|
1098 | * because we doubled the number of operations for rollback case.
|
---|
1099 | * But if we want to update the progress object corectly it's needed to add all medium moved by standard
|
---|
1100 | * "move medium" logic (for us it's taskMoveVM->m_finalMediumsMap) to the current number of operation.
|
---|
1101 | */
|
---|
1102 |
|
---|
1103 | ULONG operationCount = 0;
|
---|
1104 | hrc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
|
---|
1105 | ULONG operation = 0;
|
---|
1106 | hrc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
|
---|
1107 |
|
---|
1108 | for (ULONG i = operation; i < operation + taskMoveVM->m_finalMediumsMap.size() - 1; ++i)
|
---|
1109 | taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(tr("Skip the empty operation %d..."), i).raw(), 1);
|
---|
1110 |
|
---|
1111 | hrc = taskMoveVM->deleteFiles(originalFiles);
|
---|
1112 | if (FAILED(hrc))
|
---|
1113 | Log2(("Forward scenario: can't delete all original files.\n"));
|
---|
1114 |
|
---|
1115 | /* delete no longer needed source directories */
|
---|
1116 | if ( taskMoveVM->m_vmFolders[VBox_SnapshotFolder].isNotEmpty()
|
---|
1117 | && RTDirExists(taskMoveVM->m_vmFolders[VBox_SnapshotFolder].c_str()))
|
---|
1118 | RTDirRemove(taskMoveVM->m_vmFolders[VBox_SnapshotFolder].c_str());
|
---|
1119 |
|
---|
1120 | if ( taskMoveVM->m_vmFolders[VBox_LogFolder].isNotEmpty()
|
---|
1121 | && RTDirExists(taskMoveVM->m_vmFolders[VBox_LogFolder].c_str()))
|
---|
1122 | RTDirRemove(taskMoveVM->m_vmFolders[VBox_LogFolder].c_str());
|
---|
1123 |
|
---|
1124 | if ( taskMoveVM->m_vmFolders[VBox_SettingFolder].isNotEmpty()
|
---|
1125 | && RTDirExists(taskMoveVM->m_vmFolders[VBox_SettingFolder].c_str()))
|
---|
1126 | RTDirRemove(taskMoveVM->m_vmFolders[VBox_SettingFolder].c_str());
|
---|
1127 | }
|
---|
1128 |
|
---|
1129 | if (!taskMoveVM->m_pProgress.isNull())
|
---|
1130 | taskMoveVM->m_pProgress->i_notifyComplete(taskMoveVM->m_result);
|
---|
1131 |
|
---|
1132 | LogFlowFuncLeave();
|
---|
1133 | }
|
---|
1134 |
|
---|
1135 | HRESULT MachineMoveVM::moveAllDisks(const std::map<Utf8Str, MEDIUMTASKMOVE> &listOfDisks,
|
---|
1136 | const Utf8Str &strTargetFolder)
|
---|
1137 | {
|
---|
1138 | HRESULT hrc = S_OK;
|
---|
1139 | ComObjPtr<Machine> &machine = m_pMachine;
|
---|
1140 | Utf8Str strLocation;
|
---|
1141 |
|
---|
1142 | AutoWriteLock machineLock(machine COMMA_LOCKVAL_SRC_POS);
|
---|
1143 |
|
---|
1144 | try
|
---|
1145 | {
|
---|
1146 | std::map<Utf8Str, MEDIUMTASKMOVE>::const_iterator itMedium = listOfDisks.begin();
|
---|
1147 | while (itMedium != listOfDisks.end())
|
---|
1148 | {
|
---|
1149 | const MEDIUMTASKMOVE &mt = itMedium->second;
|
---|
1150 | ComPtr<IMedium> pMedium = mt.pMedium;
|
---|
1151 | Utf8Str strTargetImageName;
|
---|
1152 | Bstr bstrLocation;
|
---|
1153 | Bstr bstrSrcName;
|
---|
1154 |
|
---|
1155 | hrc = pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
|
---|
1156 | if (FAILED(hrc)) throw hrc;
|
---|
1157 |
|
---|
1158 | if (strTargetFolder.isNotEmpty())
|
---|
1159 | {
|
---|
1160 | strTargetImageName = strTargetFolder;
|
---|
1161 | hrc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1162 | if (FAILED(hrc)) throw hrc;
|
---|
1163 | strLocation = bstrLocation;
|
---|
1164 |
|
---|
1165 | if (mt.fSnapshot == true)
|
---|
1166 | strLocation.stripFilename().stripPath().append(RTPATH_DELIMITER).append(Utf8Str(bstrSrcName));
|
---|
1167 | else
|
---|
1168 | strLocation.stripPath();
|
---|
1169 |
|
---|
1170 | strTargetImageName.append(RTPATH_DELIMITER).append(strLocation);
|
---|
1171 | hrc = m_pProgress->SetNextOperation(BstrFmt(tr("Moving medium '%ls' ..."), bstrSrcName.raw()).raw(), mt.uWeight);
|
---|
1172 | if (FAILED(hrc)) throw hrc;
|
---|
1173 | }
|
---|
1174 | else
|
---|
1175 | {
|
---|
1176 | strTargetImageName = mt.strBaseName;//Should contain full path to the image
|
---|
1177 | hrc = m_pProgress->SetNextOperation(BstrFmt(tr("Moving medium '%ls' back..."), bstrSrcName.raw()).raw(), mt.uWeight);
|
---|
1178 | if (FAILED(hrc)) throw hrc;
|
---|
1179 | }
|
---|
1180 |
|
---|
1181 |
|
---|
1182 |
|
---|
1183 | /* consistency: use \ if appropriate on the platform */
|
---|
1184 | RTPathChangeToDosSlashes(strTargetImageName.mutableRaw(), false);
|
---|
1185 |
|
---|
1186 | bstrLocation = strTargetImageName.c_str();
|
---|
1187 |
|
---|
1188 | MediumType_T mediumType;//immutable, shared, passthrough
|
---|
1189 | hrc = pMedium->COMGETTER(Type)(&mediumType);
|
---|
1190 | if (FAILED(hrc)) throw hrc;
|
---|
1191 |
|
---|
1192 | DeviceType_T deviceType;//floppy, hard, DVD
|
---|
1193 | hrc = pMedium->COMGETTER(DeviceType)(&deviceType);
|
---|
1194 | if (FAILED(hrc)) throw hrc;
|
---|
1195 |
|
---|
1196 | /* Drop lock early because IMedium::MoveTo needs to get the VirtualBox one. */
|
---|
1197 | machineLock.release();
|
---|
1198 |
|
---|
1199 | ComPtr<IProgress> moveDiskProgress;
|
---|
1200 | hrc = pMedium->MoveTo(bstrLocation.raw(), moveDiskProgress.asOutParam());
|
---|
1201 | if (SUCCEEDED(hrc))
|
---|
1202 | {
|
---|
1203 | /* In case of failure moveDiskProgress would be in the invalid state or not initialized at all
|
---|
1204 | * Call i_waitForOtherProgressCompletion only in success
|
---|
1205 | */
|
---|
1206 | /* Wait until the other process has finished. */
|
---|
1207 | hrc = m_pProgress->WaitForOtherProgressCompletion(moveDiskProgress, 0 /* indefinite wait */);
|
---|
1208 | }
|
---|
1209 |
|
---|
1210 | /*acquire the lock back*/
|
---|
1211 | machineLock.acquire();
|
---|
1212 |
|
---|
1213 | if (FAILED(hrc)) throw hrc;
|
---|
1214 |
|
---|
1215 | Log2(("Moving %s has been finished\n", strTargetImageName.c_str()));
|
---|
1216 |
|
---|
1217 | ++itMedium;
|
---|
1218 | }
|
---|
1219 |
|
---|
1220 | machineLock.release();
|
---|
1221 | }
|
---|
1222 | catch (HRESULT hrcXcpt)
|
---|
1223 | {
|
---|
1224 | Log2(("Exception during moving the disk %s: %Rhrc\n", strLocation.c_str(), hrcXcpt));
|
---|
1225 | hrc = hrcXcpt;
|
---|
1226 | machineLock.release();
|
---|
1227 | }
|
---|
1228 | catch (...)
|
---|
1229 | {
|
---|
1230 | Log2(("Exception during moving the disk %s\n", strLocation.c_str()));
|
---|
1231 | hrc = VirtualBoxBase::handleUnexpectedExceptions(m_pMachine, RT_SRC_POS);
|
---|
1232 | machineLock.release();
|
---|
1233 | }
|
---|
1234 |
|
---|
1235 | return hrc;
|
---|
1236 | }
|
---|
1237 |
|
---|
1238 | void MachineMoveVM::updatePathsToStateFiles(const Utf8Str &sourcePath, const Utf8Str &targetPath)
|
---|
1239 | {
|
---|
1240 | ComObjPtr<Snapshot> pSnapshot;
|
---|
1241 | HRESULT hrc = m_pMachine->i_findSnapshotById(Guid() /* zero */, pSnapshot, true);
|
---|
1242 | if (SUCCEEDED(hrc) && !pSnapshot.isNull())
|
---|
1243 | pSnapshot->i_updateSavedStatePaths(sourcePath.c_str(),
|
---|
1244 | targetPath.c_str());
|
---|
1245 | if (m_pMachine->mSSData->strStateFilePath.isNotEmpty())
|
---|
1246 | {
|
---|
1247 | if (RTPathStartsWith(m_pMachine->mSSData->strStateFilePath.c_str(), sourcePath.c_str()))
|
---|
1248 | m_pMachine->mSSData->strStateFilePath = Utf8StrFmt("%s%s",
|
---|
1249 | targetPath.c_str(),
|
---|
1250 | m_pMachine->mSSData->strStateFilePath.c_str() + sourcePath.length());
|
---|
1251 | else
|
---|
1252 | m_pMachine->mSSData->strStateFilePath = Utf8StrFmt("%s%c%s",
|
---|
1253 | targetPath.c_str(),
|
---|
1254 | RTPATH_DELIMITER,
|
---|
1255 | RTPathFilename(m_pMachine->mSSData->strStateFilePath.c_str()));
|
---|
1256 | }
|
---|
1257 | }
|
---|
1258 |
|
---|
1259 | void MachineMoveVM::updatePathsToNVRAMFiles(const Utf8Str &sourcePath, const Utf8Str &targetPath)
|
---|
1260 | {
|
---|
1261 | ComObjPtr<Snapshot> pSnapshot;
|
---|
1262 | HRESULT hrc = m_pMachine->i_findSnapshotById(Guid() /* zero */, pSnapshot, true);
|
---|
1263 | if (SUCCEEDED(hrc) && !pSnapshot.isNull())
|
---|
1264 | pSnapshot->i_updateNVRAMPaths(sourcePath.c_str(),
|
---|
1265 | targetPath.c_str());
|
---|
1266 | ComObjPtr<NvramStore> pNvramStore(m_pMachine->mNvramStore);
|
---|
1267 | const Utf8Str NVRAMFile(pNvramStore->i_getNonVolatileStorageFile());
|
---|
1268 | if (NVRAMFile.isNotEmpty())
|
---|
1269 | {
|
---|
1270 | Utf8Str newNVRAMFile;
|
---|
1271 | if (RTPathStartsWith(NVRAMFile.c_str(), sourcePath.c_str()))
|
---|
1272 | newNVRAMFile = Utf8StrFmt("%s%s", targetPath.c_str(), NVRAMFile.c_str() + sourcePath.length());
|
---|
1273 | else
|
---|
1274 | newNVRAMFile = Utf8StrFmt("%s%c%s", targetPath.c_str(), RTPATH_DELIMITER, RTPathFilename(newNVRAMFile.c_str()));
|
---|
1275 | pNvramStore->i_updateNonVolatileStorageFile(newNVRAMFile);
|
---|
1276 | }
|
---|
1277 | }
|
---|
1278 |
|
---|
1279 | HRESULT MachineMoveVM::getFilesList(const Utf8Str &strRootFolder, fileList_t &filesList)
|
---|
1280 | {
|
---|
1281 | RTDIR hDir;
|
---|
1282 | HRESULT hrc = S_OK;
|
---|
1283 | int vrc = RTDirOpen(&hDir, strRootFolder.c_str());
|
---|
1284 | if (RT_SUCCESS(vrc))
|
---|
1285 | {
|
---|
1286 | /** @todo r=bird: RTDIRENTRY is big and this function is doing
|
---|
1287 | * unrestrained recursion of arbritrary depth. Four things:
|
---|
1288 | * - Add a depth counter parameter and refuse to go deeper than
|
---|
1289 | * a certain reasonable limit.
|
---|
1290 | * - Split this method into a main and a worker, placing
|
---|
1291 | * RTDIRENTRY on the stack in the main and passing it onto to
|
---|
1292 | * worker as a parameter.
|
---|
1293 | * - RTDirRead may fail for reasons other than
|
---|
1294 | * VERR_NO_MORE_FILES. For instance someone could create an
|
---|
1295 | * entry with a name longer than RTDIRENTRY have space to
|
---|
1296 | * store (windows host with UTF-16 encoding shorter than 255
|
---|
1297 | * chars, but UTF-8 encoding longer than 260).
|
---|
1298 | * - enmType can be RTDIRENTRYTYPE_UNKNOWN if the file system or
|
---|
1299 | * the host doesn't return the information. See
|
---|
1300 | * RTDIRENTRY::enmType. Use RTDirQueryUnknownType() to get the
|
---|
1301 | * actual type. */
|
---|
1302 | RTDIRENTRY DirEntry;
|
---|
1303 | while (RT_SUCCESS(RTDirRead(hDir, &DirEntry, NULL)))
|
---|
1304 | {
|
---|
1305 | if (RTDirEntryIsStdDotLink(&DirEntry))
|
---|
1306 | continue;
|
---|
1307 |
|
---|
1308 | if (DirEntry.enmType == RTDIRENTRYTYPE_FILE)
|
---|
1309 | {
|
---|
1310 | Utf8Str fullPath(strRootFolder);
|
---|
1311 | filesList.add(strRootFolder, DirEntry.szName);
|
---|
1312 | }
|
---|
1313 | else if (DirEntry.enmType == RTDIRENTRYTYPE_DIRECTORY)
|
---|
1314 | {
|
---|
1315 | Utf8Str strNextFolder(strRootFolder);
|
---|
1316 | strNextFolder.append(RTPATH_DELIMITER).append(DirEntry.szName);
|
---|
1317 | hrc = getFilesList(strNextFolder, filesList);
|
---|
1318 | if (FAILED(hrc))
|
---|
1319 | break;
|
---|
1320 | }
|
---|
1321 | }
|
---|
1322 |
|
---|
1323 | vrc = RTDirClose(hDir);
|
---|
1324 | AssertRC(vrc);
|
---|
1325 | }
|
---|
1326 | else if (vrc == VERR_FILE_NOT_FOUND)
|
---|
1327 | hrc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1328 | tr("Folder '%s' doesn't exist (%Rrc)"),
|
---|
1329 | strRootFolder.c_str(), vrc);
|
---|
1330 | else
|
---|
1331 | hrc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1332 | tr("Could not open folder '%s' (%Rrc)"),
|
---|
1333 | strRootFolder.c_str(), vrc);
|
---|
1334 |
|
---|
1335 | return hrc;
|
---|
1336 | }
|
---|
1337 |
|
---|
1338 | HRESULT MachineMoveVM::deleteFiles(const RTCList<Utf8Str> &listOfFiles)
|
---|
1339 | {
|
---|
1340 | HRESULT hrc = S_OK;
|
---|
1341 | /* Delete all created files. */
|
---|
1342 | for (size_t i = 0; i < listOfFiles.size(); ++i)
|
---|
1343 | {
|
---|
1344 | Log2(("Deleting file %s ...\n", listOfFiles.at(i).c_str()));
|
---|
1345 | hrc = m_pProgress->SetNextOperation(BstrFmt(tr("Deleting file %s..."), listOfFiles.at(i).c_str()).raw(), 1);
|
---|
1346 | if (FAILED(hrc)) return hrc;
|
---|
1347 |
|
---|
1348 | int vrc = RTFileDelete(listOfFiles.at(i).c_str());
|
---|
1349 | if (RT_FAILURE(vrc))
|
---|
1350 | return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1351 | tr("Could not delete file '%s' (%Rrc)"),
|
---|
1352 | listOfFiles.at(i).c_str(), vrc);
|
---|
1353 |
|
---|
1354 | else
|
---|
1355 | Log2(("File %s has been deleted\n", listOfFiles.at(i).c_str()));
|
---|
1356 | }
|
---|
1357 |
|
---|
1358 | return hrc;
|
---|
1359 | }
|
---|
1360 |
|
---|
1361 | HRESULT MachineMoveVM::getFolderSize(const Utf8Str &strRootFolder, uint64_t &size)
|
---|
1362 | {
|
---|
1363 | HRESULT hrc = S_OK;
|
---|
1364 | int vrc = 0;
|
---|
1365 | uint64_t totalFolderSize = 0;
|
---|
1366 | fileList_t filesList;
|
---|
1367 |
|
---|
1368 | bool ex = RTPathExists(strRootFolder.c_str());
|
---|
1369 | if (ex == true)
|
---|
1370 | {
|
---|
1371 | hrc = getFilesList(strRootFolder, filesList);
|
---|
1372 | if (SUCCEEDED(hrc))
|
---|
1373 | {
|
---|
1374 | cit_t it = filesList.m_list.begin();
|
---|
1375 | while (it != filesList.m_list.end())
|
---|
1376 | {
|
---|
1377 | uint64_t cbFile = 0;
|
---|
1378 | Utf8Str fullPath = it->first;
|
---|
1379 | fullPath.append(RTPATH_DELIMITER).append(it->second);
|
---|
1380 | vrc = RTFileQuerySizeByPath(fullPath.c_str(), &cbFile);
|
---|
1381 | if (RT_SUCCESS(vrc))
|
---|
1382 | {
|
---|
1383 | totalFolderSize += cbFile;
|
---|
1384 | }
|
---|
1385 | else
|
---|
1386 | return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1387 | tr("Could not get the size of file '%s': %Rrc"),
|
---|
1388 | fullPath.c_str(),
|
---|
1389 | vrc);
|
---|
1390 |
|
---|
1391 | ++it;
|
---|
1392 | }
|
---|
1393 |
|
---|
1394 | size = totalFolderSize;
|
---|
1395 | }
|
---|
1396 | }
|
---|
1397 | else
|
---|
1398 | size = 0;
|
---|
1399 |
|
---|
1400 | return hrc;
|
---|
1401 | }
|
---|
1402 |
|
---|
1403 | HRESULT MachineMoveVM::queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const
|
---|
1404 | {
|
---|
1405 | ComPtr<IMedium> pBaseMedium;
|
---|
1406 | HRESULT hrc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
|
---|
1407 | if (FAILED(hrc)) return hrc;
|
---|
1408 | Bstr bstrBaseName;
|
---|
1409 | hrc = pBaseMedium->COMGETTER(Name)(bstrBaseName.asOutParam());
|
---|
1410 | if (FAILED(hrc)) return hrc;
|
---|
1411 | strBaseName = bstrBaseName;
|
---|
1412 | return hrc;
|
---|
1413 | }
|
---|
1414 |
|
---|
1415 | HRESULT MachineMoveVM::createMachineList(const ComPtr<ISnapshot> &pSnapshot)
|
---|
1416 | {
|
---|
1417 | Bstr name;
|
---|
1418 | HRESULT hrc = pSnapshot->COMGETTER(Name)(name.asOutParam());
|
---|
1419 | if (FAILED(hrc)) return hrc;
|
---|
1420 |
|
---|
1421 | ComPtr<IMachine> l_pMachine;
|
---|
1422 | hrc = pSnapshot->COMGETTER(Machine)(l_pMachine.asOutParam());
|
---|
1423 | if (FAILED(hrc)) return hrc;
|
---|
1424 | machineList.push_back((Machine*)(IMachine*)l_pMachine);
|
---|
1425 |
|
---|
1426 | SafeIfaceArray<ISnapshot> sfaChilds;
|
---|
1427 | hrc = pSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(sfaChilds));
|
---|
1428 | if (FAILED(hrc)) return hrc;
|
---|
1429 | for (size_t i = 0; i < sfaChilds.size(); ++i)
|
---|
1430 | {
|
---|
1431 | hrc = createMachineList(sfaChilds[i]);
|
---|
1432 | if (FAILED(hrc)) return hrc;
|
---|
1433 | }
|
---|
1434 |
|
---|
1435 | return hrc;
|
---|
1436 | }
|
---|
1437 |
|
---|
1438 | HRESULT MachineMoveVM::queryMediasForAllStates()
|
---|
1439 | {
|
---|
1440 | /* In this case we create a exact copy of the original VM. This means just
|
---|
1441 | * adding all directly and indirectly attached disk images to the worker
|
---|
1442 | * list. */
|
---|
1443 | HRESULT hrc = S_OK;
|
---|
1444 | for (size_t i = 0; i < machineList.size(); ++i)
|
---|
1445 | {
|
---|
1446 | const ComObjPtr<Machine> &machine = machineList.at(i);
|
---|
1447 |
|
---|
1448 | /* Add all attachments (and their parents) of the different
|
---|
1449 | * machines to a worker list. */
|
---|
1450 | SafeIfaceArray<IMediumAttachment> sfaAttachments;
|
---|
1451 | hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
|
---|
1452 | if (FAILED(hrc)) return hrc;
|
---|
1453 | for (size_t a = 0; a < sfaAttachments.size(); ++a)
|
---|
1454 | {
|
---|
1455 | const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
|
---|
1456 | DeviceType_T deviceType;//floppy, hard, DVD
|
---|
1457 | hrc = pAtt->COMGETTER(Type)(&deviceType);
|
---|
1458 | if (FAILED(hrc)) return hrc;
|
---|
1459 |
|
---|
1460 | /* Valid medium attached? */
|
---|
1461 | ComPtr<IMedium> pMedium;
|
---|
1462 | hrc = pAtt->COMGETTER(Medium)(pMedium.asOutParam());
|
---|
1463 | if (FAILED(hrc)) return hrc;
|
---|
1464 |
|
---|
1465 | if (pMedium.isNull())
|
---|
1466 | continue;
|
---|
1467 |
|
---|
1468 | Bstr bstrLocation;
|
---|
1469 | hrc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1470 | if (FAILED(hrc)) return hrc;
|
---|
1471 |
|
---|
1472 | /* Cast to ComObjPtr<Medium> */
|
---|
1473 | ComObjPtr<Medium> pObjMedium = (Medium *)(IMedium *)pMedium;
|
---|
1474 |
|
---|
1475 | /* Check for "read-only" medium in terms that VBox can't create this one */
|
---|
1476 | hrc = isMediumTypeSupportedForMoving(pMedium);
|
---|
1477 | if (FAILED(hrc))
|
---|
1478 | {
|
---|
1479 | if (hrc != S_FALSE)
|
---|
1480 | return hrc;
|
---|
1481 | Log2(("Skipping file %ls because of this medium type hasn't been supported for moving.\n", bstrLocation.raw()));
|
---|
1482 | continue;
|
---|
1483 | }
|
---|
1484 |
|
---|
1485 | MEDIUMTASKCHAINMOVE mtc;
|
---|
1486 | mtc.devType = deviceType;
|
---|
1487 | mtc.fAttachLinked = false;
|
---|
1488 | mtc.fCreateDiffs = false;
|
---|
1489 |
|
---|
1490 | while (!pMedium.isNull())
|
---|
1491 | {
|
---|
1492 | /* Refresh the state so that the file size get read. */
|
---|
1493 | MediumState_T e;
|
---|
1494 | hrc = pMedium->RefreshState(&e);
|
---|
1495 | if (FAILED(hrc)) return hrc;
|
---|
1496 |
|
---|
1497 | LONG64 lSize;
|
---|
1498 | hrc = pMedium->COMGETTER(Size)(&lSize);
|
---|
1499 | if (FAILED(hrc)) return hrc;
|
---|
1500 |
|
---|
1501 | MediumType_T mediumType;//immutable, shared, passthrough
|
---|
1502 | hrc = pMedium->COMGETTER(Type)(&mediumType);
|
---|
1503 | if (FAILED(hrc)) return hrc;
|
---|
1504 |
|
---|
1505 | hrc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1506 | if (FAILED(hrc)) return hrc;
|
---|
1507 |
|
---|
1508 | MEDIUMTASKMOVE mt;// = {false, "basename", NULL, 0, 0};
|
---|
1509 | mt.strBaseName = bstrLocation;
|
---|
1510 | Utf8Str const &strFolder = m_vmFolders[VBox_SnapshotFolder];
|
---|
1511 |
|
---|
1512 | if (strFolder.isNotEmpty() && RTPathStartsWith(mt.strBaseName.c_str(), strFolder.c_str()))
|
---|
1513 | mt.fSnapshot = true;
|
---|
1514 | else
|
---|
1515 | mt.fSnapshot = false;
|
---|
1516 |
|
---|
1517 | mt.uIdx = UINT32_MAX;
|
---|
1518 | mt.pMedium = pMedium;
|
---|
1519 | mt.uWeight = (ULONG)((lSize + _1M - 1) / _1M);
|
---|
1520 | mtc.chain.append(mt);
|
---|
1521 |
|
---|
1522 | /* Query next parent. */
|
---|
1523 | hrc = pMedium->COMGETTER(Parent)(pMedium.asOutParam());
|
---|
1524 | if (FAILED(hrc)) return hrc;
|
---|
1525 | }
|
---|
1526 |
|
---|
1527 | m_llMedias.append(mtc);
|
---|
1528 | }
|
---|
1529 |
|
---|
1530 | /* Add the save state files of this machine if there is one. */
|
---|
1531 | hrc = addSaveState(machine);
|
---|
1532 | if (FAILED(hrc)) return hrc;
|
---|
1533 |
|
---|
1534 | /* Add the NVRAM files of this machine if there is one. */
|
---|
1535 | hrc = addNVRAM(machine);
|
---|
1536 | if (FAILED(hrc)) return hrc;
|
---|
1537 | }
|
---|
1538 |
|
---|
1539 | /* Build up the index list of the image chain. Unfortunately we can't do
|
---|
1540 | * that in the previous loop, cause there we go from child -> parent and
|
---|
1541 | * didn't know how many are between. */
|
---|
1542 | for (size_t i = 0; i < m_llMedias.size(); ++i)
|
---|
1543 | {
|
---|
1544 | uint32_t uIdx = 0;
|
---|
1545 | MEDIUMTASKCHAINMOVE &mtc = m_llMedias.at(i);
|
---|
1546 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
1547 | mtc.chain[a - 1].uIdx = uIdx++;
|
---|
1548 | }
|
---|
1549 |
|
---|
1550 | return hrc;
|
---|
1551 | }
|
---|
1552 |
|
---|
1553 | HRESULT MachineMoveVM::addSaveState(const ComObjPtr<Machine> &machine)
|
---|
1554 | {
|
---|
1555 | Bstr bstrSrcSaveStatePath;
|
---|
1556 | HRESULT hrc = machine->COMGETTER(StateFilePath)(bstrSrcSaveStatePath.asOutParam());
|
---|
1557 | if (FAILED(hrc)) return hrc;
|
---|
1558 | if (!bstrSrcSaveStatePath.isEmpty())
|
---|
1559 | {
|
---|
1560 | SNAPFILETASKMOVE sft;
|
---|
1561 |
|
---|
1562 | sft.snapshotUuid = machine->i_getSnapshotId();
|
---|
1563 | sft.strFile = bstrSrcSaveStatePath;
|
---|
1564 | uint64_t cbSize;
|
---|
1565 |
|
---|
1566 | int vrc = RTFileQuerySizeByPath(sft.strFile.c_str(), &cbSize);
|
---|
1567 | if (RT_FAILURE(vrc))
|
---|
1568 | return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1569 | tr("Could not get file size of '%s': %Rrc"),
|
---|
1570 | sft.strFile.c_str(),
|
---|
1571 | vrc);
|
---|
1572 |
|
---|
1573 | /* same rule as above: count both the data which needs to
|
---|
1574 | * be read and written */
|
---|
1575 | sft.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
|
---|
1576 | m_llSaveStateFiles.append(sft);
|
---|
1577 | }
|
---|
1578 | return S_OK;
|
---|
1579 | }
|
---|
1580 |
|
---|
1581 | HRESULT MachineMoveVM::addNVRAM(const ComObjPtr<Machine> &machine)
|
---|
1582 | {
|
---|
1583 | ComPtr<INvramStore> pNvramStore;
|
---|
1584 | HRESULT hrc = machine->COMGETTER(NonVolatileStore)(pNvramStore.asOutParam());
|
---|
1585 | if (FAILED(hrc)) return hrc;
|
---|
1586 | Bstr bstrSrcNVRAMPath;
|
---|
1587 | hrc = pNvramStore->COMGETTER(NonVolatileStorageFile)(bstrSrcNVRAMPath.asOutParam());
|
---|
1588 | if (FAILED(hrc)) return hrc;
|
---|
1589 | Utf8Str strSrcNVRAMPath(bstrSrcNVRAMPath);
|
---|
1590 | if (!strSrcNVRAMPath.isEmpty() && RTFileExists(strSrcNVRAMPath.c_str()))
|
---|
1591 | {
|
---|
1592 | SNAPFILETASKMOVE sft;
|
---|
1593 |
|
---|
1594 | sft.snapshotUuid = machine->i_getSnapshotId();
|
---|
1595 | sft.strFile = strSrcNVRAMPath;
|
---|
1596 | uint64_t cbSize;
|
---|
1597 |
|
---|
1598 | int vrc = RTFileQuerySizeByPath(sft.strFile.c_str(), &cbSize);
|
---|
1599 | if (RT_FAILURE(vrc))
|
---|
1600 | return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
|
---|
1601 | tr("Could not get file size of '%s': %Rrc"),
|
---|
1602 | sft.strFile.c_str(),
|
---|
1603 | vrc);
|
---|
1604 |
|
---|
1605 | /* same rule as above: count both the data which needs to
|
---|
1606 | * be read and written */
|
---|
1607 | sft.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
|
---|
1608 | m_llNVRAMFiles.append(sft);
|
---|
1609 | }
|
---|
1610 | return S_OK;
|
---|
1611 | }
|
---|
1612 |
|
---|
1613 | void MachineMoveVM::updateProgressStats(MEDIUMTASKCHAINMOVE &mtc, ULONG &uCount, ULONG &uTotalWeight) const
|
---|
1614 | {
|
---|
1615 |
|
---|
1616 | /* Currently the copying of diff images involves reading at least
|
---|
1617 | * the biggest parent in the previous chain. So even if the new
|
---|
1618 | * diff image is small in size, it could need some time to create
|
---|
1619 | * it. Adding the biggest size in the chain should balance this a
|
---|
1620 | * little bit more, i.e. the weight is the sum of the data which
|
---|
1621 | * needs to be read and written. */
|
---|
1622 | ULONG uMaxWeight = 0;
|
---|
1623 | for (size_t e = mtc.chain.size(); e > 0; --e)
|
---|
1624 | {
|
---|
1625 | MEDIUMTASKMOVE &mt = mtc.chain.at(e - 1);
|
---|
1626 | mt.uWeight += uMaxWeight;
|
---|
1627 |
|
---|
1628 | /* Calculate progress data */
|
---|
1629 | ++uCount;
|
---|
1630 | uTotalWeight += mt.uWeight;
|
---|
1631 |
|
---|
1632 | /* Save the max size for better weighting of diff image
|
---|
1633 | * creation. */
|
---|
1634 | uMaxWeight = RT_MAX(uMaxWeight, mt.uWeight);
|
---|
1635 | }
|
---|
1636 | }
|
---|
1637 |
|
---|
1638 | HRESULT MachineMoveVM::isMediumTypeSupportedForMoving(const ComPtr<IMedium> &pMedium)
|
---|
1639 | {
|
---|
1640 | Bstr bstrLocation;
|
---|
1641 | HRESULT hrc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1642 | if (FAILED(hrc))
|
---|
1643 | return hrc;
|
---|
1644 |
|
---|
1645 | DeviceType_T deviceType;
|
---|
1646 | hrc = pMedium->COMGETTER(DeviceType)(&deviceType);
|
---|
1647 | if (FAILED(hrc))
|
---|
1648 | return hrc;
|
---|
1649 |
|
---|
1650 | ComPtr<IMediumFormat> mediumFormat;
|
---|
1651 | hrc = pMedium->COMGETTER(MediumFormat)(mediumFormat.asOutParam());
|
---|
1652 | if (FAILED(hrc))
|
---|
1653 | return hrc;
|
---|
1654 |
|
---|
1655 | /* Check whether VBox is able to create this medium format or not, i.e. medium can be "read-only" */
|
---|
1656 | Bstr bstrFormatName;
|
---|
1657 | hrc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
|
---|
1658 | if (FAILED(hrc))
|
---|
1659 | return hrc;
|
---|
1660 |
|
---|
1661 | Utf8Str formatName = Utf8Str(bstrFormatName);
|
---|
1662 | if (formatName.compare("VHDX", Utf8Str::CaseInsensitive) == 0)
|
---|
1663 | {
|
---|
1664 | Log2(("Skipping medium %ls. VHDX format is supported in \"read-only\" mode only.\n", bstrLocation.raw()));
|
---|
1665 | return S_FALSE;
|
---|
1666 | }
|
---|
1667 |
|
---|
1668 | /* Check whether medium is represented by file on the disk or not */
|
---|
1669 | ComObjPtr<Medium> pObjMedium = (Medium *)(IMedium *)pMedium;
|
---|
1670 | if (!pObjMedium->i_isMediumFormatFile())
|
---|
1671 | {
|
---|
1672 | Log2(("Skipping medium %ls because it's not a real file on the disk.\n", bstrLocation.raw()));
|
---|
1673 | return S_FALSE;
|
---|
1674 | }
|
---|
1675 |
|
---|
1676 | /* some special checks for DVD */
|
---|
1677 | if (deviceType == DeviceType_DVD)
|
---|
1678 | {
|
---|
1679 | Utf8Str ext = bstrLocation;
|
---|
1680 | /* only ISO image is moved */
|
---|
1681 | if (!ext.endsWith(".iso", Utf8Str::CaseInsensitive))
|
---|
1682 | {
|
---|
1683 | Log2(("Skipping file %ls. Only ISO images are supported for now.\n", bstrLocation.raw()));
|
---|
1684 | return S_FALSE;
|
---|
1685 | }
|
---|
1686 | }
|
---|
1687 |
|
---|
1688 | return S_OK;
|
---|
1689 | }
|
---|