VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp@ 35273

Last change on this file since 35273 was 33425, checked in by vboxsync, 14 years ago

VBoxManage: fix snapshot messup caused by API changes from last week
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.6 KB
Line 
1/* $Id: VBoxManageSnapshot.cpp 33425 2010-10-25 14:30:43Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'snapshot' command.
4 */
5
6/*
7 * Copyright (C) 2006-2010 Oracle Corporation
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 (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#include <VBox/com/com.h>
22#include <VBox/com/string.h>
23#include <VBox/com/array.h>
24#include <VBox/com/ErrorInfo.h>
25#include <VBox/com/errorprint.h>
26
27#include <VBox/com/VirtualBox.h>
28
29#include <iprt/stream.h>
30#include <iprt/getopt.h>
31
32#include "VBoxManage.h"
33using namespace com;
34
35/**
36 * Helper function used with "VBoxManage snapshot ... dump". Gets called to find the
37 * snapshot in the machine's snapshot tree that uses a particular diff image child of
38 * a medium.
39 * Horribly inefficient since we keep re-querying the snapshots tree for each image,
40 * but this is for quick debugging only.
41 * @param pMedium
42 * @param pThisSnapshot
43 * @param pCurrentSnapshot
44 * @param uMediumLevel
45 * @param uSnapshotLevel
46 * @return
47 */
48bool FindAndPrintSnapshotUsingMedium(ComPtr<IMedium> &pMedium,
49 ComPtr<ISnapshot> &pThisSnapshot,
50 ComPtr<ISnapshot> &pCurrentSnapshot,
51 uint32_t uMediumLevel,
52 uint32_t uSnapshotLevel)
53{
54 HRESULT rc;
55
56 do
57 {
58 // get snapshot machine so we can figure out which diff image this created
59 ComPtr<IMachine> pSnapshotMachine;
60 CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Machine)(pSnapshotMachine.asOutParam()));
61
62 // get media attachments
63 SafeIfaceArray<IMediumAttachment> aAttachments;
64 CHECK_ERROR_BREAK(pSnapshotMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aAttachments)));
65
66 for (uint32_t i = 0;
67 i < aAttachments.size();
68 ++i)
69 {
70 ComPtr<IMediumAttachment> pAttach(aAttachments[i]);
71 DeviceType_T type;
72 CHECK_ERROR_BREAK(pAttach, COMGETTER(Type)(&type));
73 if (type == DeviceType_HardDisk)
74 {
75 ComPtr<IMedium> pMediumInSnapshot;
76 CHECK_ERROR_BREAK(pAttach, COMGETTER(Medium)(pMediumInSnapshot.asOutParam()));
77
78 if (pMediumInSnapshot == pMedium)
79 {
80 // get snapshot name
81 Bstr bstrSnapshotName;
82 CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Name)(bstrSnapshotName.asOutParam()));
83
84 RTPrintf("%*s \"%ls\"%s\n",
85 50 + uSnapshotLevel * 2, "", // indent
86 bstrSnapshotName.raw(),
87 (pThisSnapshot == pCurrentSnapshot) ? " (CURSNAP)" : "");
88 return true; // found
89 }
90 }
91 }
92
93 // not found: then recurse into child snapshots
94 SafeIfaceArray<ISnapshot> aSnapshots;
95 CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Children)(ComSafeArrayAsOutParam(aSnapshots)));
96
97 for (uint32_t i = 0;
98 i < aSnapshots.size();
99 ++i)
100 {
101 ComPtr<ISnapshot> pChild(aSnapshots[i]);
102 if (FindAndPrintSnapshotUsingMedium(pMedium,
103 pChild,
104 pCurrentSnapshot,
105 uMediumLevel,
106 uSnapshotLevel + 1))
107 // found:
108 break;
109 }
110 } while (0);
111
112 return false;
113}
114
115/**
116 * Helper function used with "VBoxManage snapshot ... dump". Called from DumpSnapshot()
117 * for each hard disk attachment found in a virtual machine. This then writes out the
118 * root (base) medium for that hard disk attachment and recurses into the children
119 * tree of that medium, correlating it with the snapshots of the machine.
120 * @param pCurrentStateMedium constant, the medium listed in the current machine data (latest diff image).
121 * @param pMedium variant, initially the base medium, then a child of the base medium when recursing.
122 * @param pRootSnapshot constant, the root snapshot of the machine, if any; this then looks into the child snapshots.
123 * @param pCurrentSnapshot constant, the machine's current snapshot (so we can mark it in the output).
124 * @param uLevel variant, the recursion level for output indentation.
125 */
126void DumpMediumWithChildren(ComPtr<IMedium> &pCurrentStateMedium,
127 ComPtr<IMedium> &pMedium,
128 ComPtr<ISnapshot> &pRootSnapshot,
129 ComPtr<ISnapshot> &pCurrentSnapshot,
130 uint32_t uLevel)
131{
132 HRESULT rc;
133 do
134 {
135 // print this medium
136 Bstr bstrMediumName;
137 CHECK_ERROR_BREAK(pMedium, COMGETTER(Name)(bstrMediumName.asOutParam()));
138 RTPrintf("%*s \"%ls\"%s\n",
139 uLevel * 2, "", // indent
140 bstrMediumName.raw(),
141 (pCurrentStateMedium == pMedium) ? " (CURSTATE)" : "");
142
143 // find and print the snapshot that uses this particular medium (diff image)
144 FindAndPrintSnapshotUsingMedium(pMedium, pRootSnapshot, pCurrentSnapshot, uLevel, 0);
145
146 // recurse into children
147 SafeIfaceArray<IMedium> aChildren;
148 CHECK_ERROR_BREAK(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(aChildren)));
149 for (uint32_t i = 0;
150 i < aChildren.size();
151 ++i)
152 {
153 ComPtr<IMedium> pChild(aChildren[i]);
154 DumpMediumWithChildren(pCurrentStateMedium, pChild, pRootSnapshot, pCurrentSnapshot, uLevel + 1);
155 }
156 } while (0);
157}
158
159/**
160 * Implementation for "VBoxManage snapshot ... dump". This goes thru the machine's
161 * medium attachments and calls DumpMediumWithChildren() for each hard disk medium found,
162 * which then dumps the parent/child tree of that medium together with the corresponding
163 * snapshots.
164 * @param pMachine Machine to dump snapshots for.
165 */
166void DumpSnapshot(ComPtr<IMachine> &pMachine)
167{
168 HRESULT rc;
169
170 do
171 {
172 // get root snapshot
173 ComPtr<ISnapshot> pSnapshot;
174 CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr("").raw(), pSnapshot.asOutParam()));
175
176 // get current snapshot
177 ComPtr<ISnapshot> pCurrentSnapshot;
178 CHECK_ERROR_BREAK(pMachine, COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam()));
179
180 // get media attachments
181 SafeIfaceArray<IMediumAttachment> aAttachments;
182 CHECK_ERROR_BREAK(pMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aAttachments)));
183 for (uint32_t i = 0;
184 i < aAttachments.size();
185 ++i)
186 {
187 ComPtr<IMediumAttachment> pAttach(aAttachments[i]);
188 DeviceType_T type;
189 CHECK_ERROR_BREAK(pAttach, COMGETTER(Type)(&type));
190 if (type == DeviceType_HardDisk)
191 {
192 ComPtr<IMedium> pCurrentStateMedium;
193 CHECK_ERROR_BREAK(pAttach, COMGETTER(Medium)(pCurrentStateMedium.asOutParam()));
194
195 ComPtr<IMedium> pBaseMedium;
196 CHECK_ERROR_BREAK(pCurrentStateMedium, COMGETTER(Base)(pBaseMedium.asOutParam()));
197
198 Bstr bstrBaseMediumName;
199 CHECK_ERROR_BREAK(pBaseMedium, COMGETTER(Name)(bstrBaseMediumName.asOutParam()));
200
201 RTPrintf("[%RI32] Images and snapshots for medium \"%ls\"\n", i, bstrBaseMediumName.raw());
202
203 DumpMediumWithChildren(pCurrentStateMedium,
204 pBaseMedium,
205 pSnapshot,
206 pCurrentSnapshot,
207 0);
208 }
209 }
210 } while (0);
211}
212
213/**
214 * Implementation for all VBoxManage snapshot ... subcommands.
215 * @param a
216 * @return
217 */
218int handleSnapshot(HandlerArg *a)
219{
220 HRESULT rc;
221
222 /* we need at least a VM and a command */
223 if (a->argc < 2)
224 return errorSyntax(USAGE_SNAPSHOT, "Not enough parameters");
225
226 /* the first argument must be the VM */
227 Bstr bstrMachine(a->argv[0]);
228 ComPtr<IMachine> pMachine;
229 CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine.raw(),
230 pMachine.asOutParam()));
231 if (!pMachine)
232 return 1;
233
234 do
235 {
236 /* we have to open a session for this task (new or shared) */
237 rc = pMachine->LockMachine(a->session, LockType_Shared);
238 ComPtr<IConsole> console;
239 CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam()));
240
241 /* switch based on the command */
242 bool fDelete = false,
243 fRestore = false,
244 fRestoreCurrent = false;
245
246 if (!strcmp(a->argv[1], "take"))
247 {
248 /* there must be a name */
249 if (a->argc < 3)
250 {
251 errorSyntax(USAGE_SNAPSHOT, "Missing snapshot name");
252 rc = E_FAIL;
253 break;
254 }
255 Bstr name(a->argv[2]);
256
257 /* parse the optional arguments */
258 Bstr desc;
259 bool fPause = false;
260 static const RTGETOPTDEF s_aTakeOptions[] =
261 {
262 { "--description", 'd', RTGETOPT_REQ_STRING },
263 { "-description", 'd', RTGETOPT_REQ_STRING },
264 { "-desc", 'd', RTGETOPT_REQ_STRING },
265 { "--pause", 'p', RTGETOPT_REQ_NOTHING }
266 };
267 RTGETOPTSTATE GetOptState;
268 RTGetOptInit(&GetOptState, a->argc, a->argv, s_aTakeOptions, RT_ELEMENTS(s_aTakeOptions),
269 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
270 int ch;
271 RTGETOPTUNION Value;
272 while ( SUCCEEDED(rc)
273 && (ch = RTGetOpt(&GetOptState, &Value)))
274 {
275 switch (ch)
276 {
277 case 'p':
278 fPause = true;
279 break;
280
281 case 'd':
282 desc = Value.psz;
283 break;
284
285 default:
286 errorGetOpt(USAGE_SNAPSHOT, ch, &Value);
287 rc = E_FAIL;
288 break;
289 }
290 }
291 if (FAILED(rc))
292 break;
293
294 if (fPause)
295 {
296 MachineState_T machineState;
297 CHECK_ERROR_BREAK(console, COMGETTER(State)(&machineState));
298 if (machineState == MachineState_Running)
299 CHECK_ERROR_BREAK(console, Pause());
300 else
301 fPause = false;
302 }
303
304 ComPtr<IProgress> progress;
305 CHECK_ERROR_BREAK(console, TakeSnapshot(name.raw(), desc.raw(),
306 progress.asOutParam()));
307
308 rc = showProgress(progress);
309 if (FAILED(rc))
310 {
311 com::ProgressErrorInfo info(progress);
312 if (info.isBasicAvailable())
313 RTMsgError("Failed to take snapshot. Error message: %lS", info.getText().raw());
314 else
315 RTMsgError("Failed to take snapshot. No error message available!");
316 }
317
318 if (fPause)
319 {
320 MachineState_T machineState;
321 CHECK_ERROR_BREAK(console, COMGETTER(State)(&machineState));
322 if (machineState == MachineState_Paused)
323 {
324 if (SUCCEEDED(rc))
325 CHECK_ERROR_BREAK(console, Resume());
326 else
327 console->Resume();
328 }
329 }
330 }
331 else if ( (fDelete = !strcmp(a->argv[1], "delete"))
332 || (fRestore = !strcmp(a->argv[1], "restore"))
333 || (fRestoreCurrent = !strcmp(a->argv[1], "restorecurrent"))
334 )
335 {
336 if (fRestoreCurrent)
337 {
338 if (a->argc > 2)
339 {
340 errorSyntax(USAGE_SNAPSHOT, "Too many arguments");
341 rc = E_FAIL;
342 break;
343 }
344 }
345 /* exactly one parameter: snapshot name */
346 else if (a->argc != 3)
347 {
348 errorSyntax(USAGE_SNAPSHOT, "Expecting snapshot name only");
349 rc = E_FAIL;
350 break;
351 }
352
353 ComPtr<ISnapshot> pSnapshot;
354 ComPtr<IProgress> pProgress;
355 Bstr bstrSnapGuid;
356
357 if (fRestoreCurrent)
358 {
359 CHECK_ERROR_BREAK(pMachine, COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam()));
360 }
361 else
362 {
363 // restore or delete snapshot: then resolve cmd line argument to snapshot instance
364 CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
365 pSnapshot.asOutParam()));
366 }
367
368 CHECK_ERROR_BREAK(pSnapshot, COMGETTER(Id)(bstrSnapGuid.asOutParam()));
369
370 if (fDelete)
371 {
372 CHECK_ERROR_BREAK(console, DeleteSnapshot(bstrSnapGuid.raw(),
373 pProgress.asOutParam()));
374 }
375 else
376 {
377 // restore or restore current
378 RTPrintf("Restoring snapshot %ls\n", bstrSnapGuid.raw());
379 CHECK_ERROR_BREAK(console, RestoreSnapshot(pSnapshot, pProgress.asOutParam()));
380 }
381
382 rc = showProgress(pProgress);
383 if (FAILED(rc))
384 {
385 com::ProgressErrorInfo info(pProgress);
386 if (info.isBasicAvailable())
387 RTMsgError("Snapshot operation failed. Error message: %lS", info.getText().raw());
388 else
389 RTMsgError("Snapshot operation failed. No error message available!");
390 }
391 }
392 else if (!strcmp(a->argv[1], "edit"))
393 {
394 if (a->argc < 3)
395 {
396 errorSyntax(USAGE_SNAPSHOT, "Missing snapshot name");
397 rc = E_FAIL;
398 break;
399 }
400
401 ComPtr<ISnapshot> snapshot;
402
403 if ( !strcmp(a->argv[2], "--current")
404 || !strcmp(a->argv[2], "-current"))
405 {
406 CHECK_ERROR_BREAK(pMachine, COMGETTER(CurrentSnapshot)(snapshot.asOutParam()));
407 }
408 else
409 {
410 CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
411 snapshot.asOutParam()));
412 }
413
414 /* parse options */
415 for (int i = 3; i < a->argc; i++)
416 {
417 if ( !strcmp(a->argv[i], "--name")
418 || !strcmp(a->argv[i], "-name")
419 || !strcmp(a->argv[i], "-newname"))
420 {
421 if (a->argc <= i + 1)
422 {
423 errorArgument("Missing argument to '%s'", a->argv[i]);
424 rc = E_FAIL;
425 break;
426 }
427 i++;
428 snapshot->COMSETTER(Name)(Bstr(a->argv[i]).raw());
429 }
430 else if ( !strcmp(a->argv[i], "--description")
431 || !strcmp(a->argv[i], "-description")
432 || !strcmp(a->argv[i], "-newdesc"))
433 {
434 if (a->argc <= i + 1)
435 {
436 errorArgument("Missing argument to '%s'", a->argv[i]);
437 rc = E_FAIL;
438 break;
439 }
440 i++;
441 snapshot->COMSETTER(Description)(Bstr(a->argv[i]).raw());
442 }
443 else
444 {
445 errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str());
446 rc = E_FAIL;
447 break;
448 }
449 }
450
451 }
452 else if (!strcmp(a->argv[1], "showvminfo"))
453 {
454 /* exactly one parameter: snapshot name */
455 if (a->argc != 3)
456 {
457 errorSyntax(USAGE_SNAPSHOT, "Expecting snapshot name only");
458 rc = E_FAIL;
459 break;
460 }
461
462 ComPtr<ISnapshot> snapshot;
463
464 CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
465 snapshot.asOutParam()));
466
467 /* get the machine of the given snapshot */
468 ComPtr<IMachine> pMachine2;
469 snapshot->COMGETTER(Machine)(pMachine2.asOutParam());
470 showVMInfo(a->virtualBox, pMachine2, VMINFO_NONE, console);
471 }
472 else if (!strcmp(a->argv[1], "dump")) // undocumented parameter to debug snapshot info
473 DumpSnapshot(pMachine);
474 else
475 {
476 errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(a->argv[1]).c_str());
477 rc = E_FAIL;
478 }
479 } while (0);
480
481 a->session->UnlockMachine();
482
483 return SUCCEEDED(rc) ? 0 : 1;
484}
485
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use