VBoxManageSnapshot.cpp@ 90739

Last change on this file since 90739 was 85138, checked in by vboxsync, 4 years ago
VBoxManageSnapshot.cpp: Unnecessary conversion.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.4 KB

Line
1	/* $Id: VBoxManageSnapshot.cpp 85138 2020-07-09 07:26:26Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'snapshot' command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <VBox/com/com.h>
23	#include <VBox/com/string.h>
24	#include <VBox/com/array.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27
28	#include <VBox/com/VirtualBox.h>
29
30	#include <iprt/getopt.h>
31	#include <iprt/stream.h>
32	#include <iprt/time.h>
33
34	#include "VBoxManage.h"
35	using namespace com;
36
37	/**
38	* Helper function used with "VBoxManage snapshot ... dump". Gets called to find the
39	* snapshot in the machine's snapshot tree that uses a particular diff image child of
40	* a medium.
41	* Horribly inefficient since we keep re-querying the snapshots tree for each image,
42	* but this is for quick debugging only.
43	* @param pMedium
44	* @param pThisSnapshot
45	* @param pCurrentSnapshot
46	* @param uMediumLevel
47	* @param uSnapshotLevel
48	* @return
49	*/
50	bool FindAndPrintSnapshotUsingMedium(ComPtr<IMedium> &pMedium,
51	ComPtr<ISnapshot> &pThisSnapshot,
52	ComPtr<ISnapshot> &pCurrentSnapshot,
53	uint32_t uMediumLevel,
54	uint32_t uSnapshotLevel)
55	{
56	HRESULT rc;
57
58	do
59	{
60	// get snapshot machine so we can figure out which diff image this created
61	ComPtr<IMachine> pSnapshotMachine;
62	CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Machine)(pSnapshotMachine.asOutParam()));
63
64	// get media attachments
65	SafeIfaceArray<IMediumAttachment> aAttachments;
66	CHECK_ERROR_BREAK(pSnapshotMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aAttachments)));
67
68	for (uint32_t i = 0;
69	i < aAttachments.size();
70	++i)
71	{
72	ComPtr<IMediumAttachment> pAttach(aAttachments[i]);
73	DeviceType_T type;
74	CHECK_ERROR_BREAK(pAttach, COMGETTER(Type)(&type));
75	if (type == DeviceType_HardDisk)
76	{
77	ComPtr<IMedium> pMediumInSnapshot;
78	CHECK_ERROR_BREAK(pAttach, COMGETTER(Medium)(pMediumInSnapshot.asOutParam()));
79
80	if (pMediumInSnapshot == pMedium)
81	{
82	// get snapshot name
83	Bstr bstrSnapshotName;
84	CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Name)(bstrSnapshotName.asOutParam()));
85
86	RTPrintf("%*s \"%ls\"%s\n",
87	50 + uSnapshotLevel * 2, "", // indent
88	bstrSnapshotName.raw(),
89	(pThisSnapshot == pCurrentSnapshot) ? " (CURSNAP)" : "");
90	return true; // found
91	}
92	}
93	}
94
95	// not found: then recurse into child snapshots
96	SafeIfaceArray<ISnapshot> aSnapshots;
97	CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Children)(ComSafeArrayAsOutParam(aSnapshots)));
98
99	for (uint32_t i = 0;
100	i < aSnapshots.size();
101	++i)
102	{
103	ComPtr<ISnapshot> pChild(aSnapshots[i]);
104	if (FindAndPrintSnapshotUsingMedium(pMedium,
105	pChild,
106	pCurrentSnapshot,
107	uMediumLevel,
108	uSnapshotLevel + 1))
109	// found:
110	break;
111	}
112	} while (0);
113
114	return false;
115	}
116
117	/**
118	* Helper function used with "VBoxManage snapshot ... dump". Called from DumpSnapshot()
119	* for each hard disk attachment found in a virtual machine. This then writes out the
120	* root (base) medium for that hard disk attachment and recurses into the children
121	* tree of that medium, correlating it with the snapshots of the machine.
122	* @param pCurrentStateMedium constant, the medium listed in the current machine data (latest diff image).
123	* @param pMedium variant, initially the base medium, then a child of the base medium when recursing.
124	* @param pRootSnapshot constant, the root snapshot of the machine, if any; this then looks into the child snapshots.
125	* @param pCurrentSnapshot constant, the machine's current snapshot (so we can mark it in the output).
126	* @param uLevel variant, the recursion level for output indentation.
127	*/
128	void DumpMediumWithChildren(ComPtr<IMedium> &pCurrentStateMedium,
129	ComPtr<IMedium> &pMedium,
130	ComPtr<ISnapshot> &pRootSnapshot,
131	ComPtr<ISnapshot> &pCurrentSnapshot,
132	uint32_t uLevel)
133	{
134	HRESULT rc;
135	do
136	{
137	// print this medium
138	Bstr bstrMediumName;
139	CHECK_ERROR_BREAK(pMedium, COMGETTER(Name)(bstrMediumName.asOutParam()));
140	RTPrintf("%*s \"%ls\"%s\n",
141	uLevel * 2, "", // indent
142	bstrMediumName.raw(),
143	(pCurrentStateMedium == pMedium) ? " (CURSTATE)" : "");
144
145	// find and print the snapshot that uses this particular medium (diff image)
146	FindAndPrintSnapshotUsingMedium(pMedium, pRootSnapshot, pCurrentSnapshot, uLevel, 0);
147
148	// recurse into children
149	SafeIfaceArray<IMedium> aChildren;
150	CHECK_ERROR_BREAK(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(aChildren)));
151	for (uint32_t i = 0;
152	i < aChildren.size();
153	++i)
154	{
155	ComPtr<IMedium> pChild(aChildren[i]);
156	DumpMediumWithChildren(pCurrentStateMedium, pChild, pRootSnapshot, pCurrentSnapshot, uLevel + 1);
157	}
158	} while (0);
159	}
160
161
162	/**
163	* Handles the 'snapshot myvm list' sub-command.
164	* @returns Exit code.
165	* @param pArgs The handler argument package.
166	* @param pMachine Reference to the VM (locked) we're operating on.
167	*/
168	static RTEXITCODE handleSnapshotList(HandlerArg *pArgs, ComPtr<IMachine> &pMachine)
169	{
170	static const RTGETOPTDEF g_aOptions[] =
171	{
172	{ "--details", 'D', RTGETOPT_REQ_NOTHING },
173	{ "--machinereadable", 'M', RTGETOPT_REQ_NOTHING },
174	};
175
176	VMINFO_DETAILS enmDetails = VMINFO_STANDARD;
177
178	int c;
179	RTGETOPTUNION ValueUnion;
180	RTGETOPTSTATE GetState;
181	RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, g_aOptions, RT_ELEMENTS(g_aOptions), 2 /iArg/, 0 /fFlags/);
182	while ((c = RTGetOpt(&GetState, &ValueUnion)))
183	{
184	switch (c)
185	{
186	case 'D': enmDetails = VMINFO_FULL; break;
187	case 'M': enmDetails = VMINFO_MACHINEREADABLE; break;
188	default: return errorGetOpt(c, &ValueUnion);
189	}
190	}
191
192	ComPtr<ISnapshot> pSnapshot;
193	HRESULT hrc = pMachine->FindSnapshot(Bstr().raw(), pSnapshot.asOutParam());
194	if (FAILED(hrc))
195	{
196	RTPrintf("This machine does not have any snapshots\n");
197	return RTEXITCODE_FAILURE;
198	}
199	if (pSnapshot)
200	{
201	ComPtr<ISnapshot> pCurrentSnapshot;
202	CHECK_ERROR2I_RET(pMachine, COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam()), RTEXITCODE_FAILURE);
203	hrc = showSnapshots(pSnapshot, pCurrentSnapshot, enmDetails);
204	if (FAILED(hrc))
205	return RTEXITCODE_FAILURE;
206	}
207	return RTEXITCODE_SUCCESS;
208	}
209
210	/**
211	* Implementation for "VBoxManage snapshot ... dump". This goes thru the machine's
212	* medium attachments and calls DumpMediumWithChildren() for each hard disk medium found,
213	* which then dumps the parent/child tree of that medium together with the corresponding
214	* snapshots.
215	* @param pMachine Machine to dump snapshots for.
216	*/
217	void DumpSnapshot(ComPtr<IMachine> &pMachine)
218	{
219	HRESULT rc;
220
221	do
222	{
223	// get root snapshot
224	ComPtr<ISnapshot> pSnapshot;
225	CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr("").raw(), pSnapshot.asOutParam()));
226
227	// get current snapshot
228	ComPtr<ISnapshot> pCurrentSnapshot;
229	CHECK_ERROR_BREAK(pMachine, COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam()));
230
231	// get media attachments
232	SafeIfaceArray<IMediumAttachment> aAttachments;
233	CHECK_ERROR_BREAK(pMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aAttachments)));
234	for (uint32_t i = 0;
235	i < aAttachments.size();
236	++i)
237	{
238	ComPtr<IMediumAttachment> pAttach(aAttachments[i]);
239	DeviceType_T type;
240	CHECK_ERROR_BREAK(pAttach, COMGETTER(Type)(&type));
241	if (type == DeviceType_HardDisk)
242	{
243	ComPtr<IMedium> pCurrentStateMedium;
244	CHECK_ERROR_BREAK(pAttach, COMGETTER(Medium)(pCurrentStateMedium.asOutParam()));
245
246	ComPtr<IMedium> pBaseMedium;
247	CHECK_ERROR_BREAK(pCurrentStateMedium, COMGETTER(Base)(pBaseMedium.asOutParam()));
248
249	Bstr bstrBaseMediumName;
250	CHECK_ERROR_BREAK(pBaseMedium, COMGETTER(Name)(bstrBaseMediumName.asOutParam()));
251
252	RTPrintf("[%RI32] Images and snapshots for medium \"%ls\"\n", i, bstrBaseMediumName.raw());
253
254	DumpMediumWithChildren(pCurrentStateMedium,
255	pBaseMedium,
256	pSnapshot,
257	pCurrentSnapshot,
258	0);
259	}
260	}
261	} while (0);
262	}
263
264	typedef enum SnapshotUniqueFlags
265	{
266	SnapshotUniqueFlags_Null = 0,
267	SnapshotUniqueFlags_Number = RT_BIT(1),
268	SnapshotUniqueFlags_Timestamp = RT_BIT(2),
269	SnapshotUniqueFlags_Space = RT_BIT(16),
270	SnapshotUniqueFlags_Force = RT_BIT(30)
271	} SnapshotUniqueFlags;
272
273	static int parseSnapshotUniqueFlags(const char psz, SnapshotUniqueFlags pUnique)
274	{
275	int rc = VINF_SUCCESS;
276	unsigned uUnique = 0;
277	while (psz && *psz && RT_SUCCESS(rc))
278	{
279	size_t len;
280	const char *pszComma = strchr(psz, ',');
281	if (pszComma)
282	len = pszComma - psz;
283	else
284	len = strlen(psz);
285	if (len > 0)
286	{
287	if (!RTStrNICmp(psz, "number", len))
288	uUnique \|= SnapshotUniqueFlags_Number;
289	else if (!RTStrNICmp(psz, "timestamp", len))
290	uUnique \|= SnapshotUniqueFlags_Timestamp;
291	else if (!RTStrNICmp(psz, "space", len))
292	uUnique \|= SnapshotUniqueFlags_Space;
293	else if (!RTStrNICmp(psz, "force", len))
294	uUnique \|= SnapshotUniqueFlags_Force;
295	else
296	rc = VERR_PARSE_ERROR;
297	}
298	if (pszComma)
299	psz += len + 1;
300	else
301	psz += len;
302	}
303
304	if (RT_SUCCESS(rc))
305	*pUnique = (SnapshotUniqueFlags)uUnique;
306	return rc;
307	}
308
309	/**
310	* Implementation for all VBoxManage snapshot ... subcommands.
311	* @param a
312	* @return
313	*/
314	RTEXITCODE handleSnapshot(HandlerArg *a)
315	{
316	HRESULT rc;
317
318	/** @todo r=bird: sub-standard command line parsing here!
319	*
320	* 'VBoxManage snapshot empty take --help' takes a snapshot rather than display
321	* help as you would expect.
322	*
323	*/
324
325	/* we need at least a VM and a command */
326	if (a->argc < 2)
327	return errorSyntax("Not enough parameters");
328
329	/* the first argument must be the VM */
330	Bstr bstrMachine(a->argv[0]);
331	ComPtr<IMachine> pMachine;
332	CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine.raw(),
333	pMachine.asOutParam()));
334	if (!pMachine)
335	return RTEXITCODE_FAILURE;
336
337	/* we have to open a session for this task (new or shared) */
338	CHECK_ERROR_RET(pMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
339	do
340	{
341	/* replace the (read-only) IMachine object by a writable one */
342	ComPtr<IMachine> sessionMachine;
343	CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()));
344
345	/* switch based on the command */
346	bool fDelete = false,
347	fRestore = false,
348	fRestoreCurrent = false;
349
350	if (!strcmp(a->argv[1], "take"))
351	{
352	setCurrentSubcommand(HELP_SCOPE_SNAPSHOT_TAKE);
353
354	/* there must be a name */
355	if (a->argc < 3)
356	{
357	errorSyntax("Missing snapshot name");
358	rc = E_FAIL;
359	break;
360	}
361	Bstr name(a->argv[2]);
362
363	/* parse the optional arguments */
364	Bstr desc;
365	bool fPause = true; /* default is NO live snapshot */
366	SnapshotUniqueFlags enmUnique = SnapshotUniqueFlags_Null;
367	static const RTGETOPTDEF s_aTakeOptions[] =
368	{
369	{ "--description", 'd', RTGETOPT_REQ_STRING },
370	{ "-description", 'd', RTGETOPT_REQ_STRING },
371	{ "-desc", 'd', RTGETOPT_REQ_STRING },
372	{ "--pause", 'p', RTGETOPT_REQ_NOTHING },
373	{ "--live", 'l', RTGETOPT_REQ_NOTHING },
374	{ "--uniquename", 'u', RTGETOPT_REQ_STRING }
375	};
376	RTGETOPTSTATE GetOptState;
377	RTGetOptInit(&GetOptState, a->argc, a->argv, s_aTakeOptions, RT_ELEMENTS(s_aTakeOptions),
378	3, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
379	int ch;
380	RTGETOPTUNION Value;
381	int vrc;
382	while ( SUCCEEDED(rc)
383	&& (ch = RTGetOpt(&GetOptState, &Value)))
384	{
385	switch (ch)
386	{
387	case 'p':
388	fPause = true;
389	break;
390
391	case 'l':
392	fPause = false;
393	break;
394
395	case 'd':
396	desc = Value.psz;
397	break;
398
399	case 'u':
400	vrc = parseSnapshotUniqueFlags(Value.psz, &enmUnique);
401	if (RT_FAILURE(vrc))
402	return errorArgument("Invalid unique name description '%s'", Value.psz);
403	break;
404
405	default:
406	errorGetOpt(ch, &Value);
407	rc = E_FAIL;
408	break;
409	}
410	}
411	if (FAILED(rc))
412	break;
413
414	if (enmUnique & (SnapshotUniqueFlags_Number \| SnapshotUniqueFlags_Timestamp))
415	{
416	ComPtr<ISnapshot> pSnapshot;
417	rc = sessionMachine->FindSnapshot(name.raw(),
418	pSnapshot.asOutParam());
419	if (SUCCEEDED(rc) \|\| (enmUnique & SnapshotUniqueFlags_Force))
420	{
421	/* there is a duplicate, need to create a unique name */
422	uint32_t count = 0;
423	RTTIMESPEC now;
424
425	if (enmUnique & SnapshotUniqueFlags_Number)
426	{
427	if (enmUnique & SnapshotUniqueFlags_Force)
428	count = 1;
429	else
430	count = 2;
431	RTTimeSpecSetNano(&now, 0); /* Shut up MSC */
432	}
433	else
434	RTTimeNow(&now);
435
436	while (count < 500)
437	{
438	Utf8Str suffix;
439	if (enmUnique & SnapshotUniqueFlags_Number)
440	suffix = Utf8StrFmt("%u", count);
441	else
442	{
443	RTTIMESPEC nowplus = now;
444	RTTimeSpecAddSeconds(&nowplus, count);
445	RTTIME stamp;
446	RTTimeExplode(&stamp, &nowplus);
447	suffix = Utf8StrFmt("%04u-%02u-%02uT%02u:%02u:%02uZ", stamp.i32Year, stamp.u8Month, stamp.u8MonthDay, stamp.u8Hour, stamp.u8Minute, stamp.u8Second);
448	}
449	Bstr tryName = name;
450	if (enmUnique & SnapshotUniqueFlags_Space)
451	tryName = BstrFmt("%ls %s", name.raw(), suffix.c_str());
452	else
453	tryName = BstrFmt("%ls%s", name.raw(), suffix.c_str());
454	count++;
455	rc = sessionMachine->FindSnapshot(tryName.raw(),
456	pSnapshot.asOutParam());
457	if (FAILED(rc))
458	{
459	name = tryName;
460	break;
461	}
462	}
463	if (SUCCEEDED(rc))
464	{
465	errorArgument("Failed to generate a unique snapshot name");
466	rc = E_FAIL;
467	break;
468	}
469	}
470	rc = S_OK;
471	}
472
473	ComPtr<IProgress> progress;
474	Bstr snapId;
475	CHECK_ERROR_BREAK(sessionMachine, TakeSnapshot(name.raw(), desc.raw(),
476	fPause, snapId.asOutParam(),
477	progress.asOutParam()));
478
479	rc = showProgress(progress);
480	if (SUCCEEDED(rc))
481	RTPrintf("Snapshot taken. UUID: %ls\n", snapId.raw());
482	else
483	CHECK_PROGRESS_ERROR(progress, ("Failed to take snapshot"));
484	}
485	else if ( (fDelete = !strcmp(a->argv[1], "delete"))
486	\|\| (fRestore = !strcmp(a->argv[1], "restore"))
487	\|\| (fRestoreCurrent = !strcmp(a->argv[1], "restorecurrent"))
488	)
489	{
490	setCurrentSubcommand(fDelete ? HELP_SCOPE_SNAPSHOT_DELETE
491	: fRestore ? HELP_SCOPE_SNAPSHOT_RESTORE
492	: HELP_SCOPE_SNAPSHOT_RESTORECURRENT);
493
494	if (fRestoreCurrent)
495	{
496	if (a->argc > 2)
497	{
498	errorSyntax("Too many arguments");
499	rc = E_FAIL;
500	break;
501	}
502	}
503	/* exactly one parameter: snapshot name */
504	else if (a->argc != 3)
505	{
506	errorSyntax("Expecting snapshot name only");
507	rc = E_FAIL;
508	break;
509	}
510
511	ComPtr<ISnapshot> pSnapshot;
512
513	if (fRestoreCurrent)
514	{
515	CHECK_ERROR_BREAK(sessionMachine, COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam()));
516	if (pSnapshot.isNull())
517	{
518	RTPrintf("This machine does not have any snapshots\n");
519	return RTEXITCODE_FAILURE;
520	}
521	}
522	else
523	{
524	// restore or delete snapshot: then resolve cmd line argument to snapshot instance
525	CHECK_ERROR_BREAK(sessionMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
526	pSnapshot.asOutParam()));
527	}
528
529	Bstr bstrSnapGuid;
530	CHECK_ERROR_BREAK(pSnapshot, COMGETTER(Id)(bstrSnapGuid.asOutParam()));
531
532	Bstr bstrSnapName;
533	CHECK_ERROR_BREAK(pSnapshot, COMGETTER(Name)(bstrSnapName.asOutParam()));
534
535	ComPtr<IProgress> pProgress;
536
537	RTPrintf("%s snapshot '%ls' (%ls)\n",
538	fDelete ? "Deleting" : "Restoring", bstrSnapName.raw(), bstrSnapGuid.raw());
539
540	if (fDelete)
541	{
542	CHECK_ERROR_BREAK(sessionMachine, DeleteSnapshot(bstrSnapGuid.raw(),
543	pProgress.asOutParam()));
544	}
545	else
546	{
547	// restore or restore current
548	CHECK_ERROR_BREAK(sessionMachine, RestoreSnapshot(pSnapshot, pProgress.asOutParam()));
549	}
550
551	rc = showProgress(pProgress);
552	CHECK_PROGRESS_ERROR(pProgress, ("Snapshot operation failed"));
553	}
554	else if (!strcmp(a->argv[1], "edit"))
555	{
556	setCurrentSubcommand(HELP_SCOPE_SNAPSHOT_EDIT);
557	if (a->argc < 3)
558	{
559	errorSyntax("Missing snapshot name");
560	rc = E_FAIL;
561	break;
562	}
563
564	/* Parse the optional arguments, allowing more freedom than the
565	* synopsis explains. Can rename multiple snapshots and so on. */
566	ComPtr<ISnapshot> pSnapshot;
567	static const RTGETOPTDEF s_aEditOptions[] =
568	{
569	{ "--current", 'c', RTGETOPT_REQ_NOTHING },
570	{ "-current", 'c', RTGETOPT_REQ_NOTHING },
571	{ "--name", 'n', RTGETOPT_REQ_STRING },
572	{ "-name", 'n', RTGETOPT_REQ_STRING },
573	{ "-newname", 'n', RTGETOPT_REQ_STRING },
574	{ "--description", 'd', RTGETOPT_REQ_STRING },
575	{ "-description", 'd', RTGETOPT_REQ_STRING },
576	{ "-desc", 'd', RTGETOPT_REQ_STRING }
577	};
578	RTGETOPTSTATE GetOptState;
579	RTGetOptInit(&GetOptState, a->argc, a->argv, s_aEditOptions, RT_ELEMENTS(s_aEditOptions),
580	2, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
581	int ch;
582	RTGETOPTUNION Value;
583	while ( SUCCEEDED(rc)
584	&& (ch = RTGetOpt(&GetOptState, &Value)))
585	{
586	switch (ch)
587	{
588	case 'c':
589	CHECK_ERROR_BREAK(sessionMachine, COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam()));
590	if (pSnapshot.isNull())
591	{
592	RTPrintf("This machine does not have any snapshots\n");
593	return RTEXITCODE_FAILURE;
594	}
595	break;
596
597	case 'n':
598	CHECK_ERROR_BREAK(pSnapshot, COMSETTER(Name)(Bstr(Value.psz).raw()));
599	break;
600
601	case 'd':
602	CHECK_ERROR_BREAK(pSnapshot, COMSETTER(Description)(Bstr(Value.psz).raw()));
603	break;
604
605	case VINF_GETOPT_NOT_OPTION:
606	CHECK_ERROR_BREAK(sessionMachine, FindSnapshot(Bstr(Value.psz).raw(), pSnapshot.asOutParam()));
607	break;
608
609	default:
610	errorGetOpt(ch, &Value);
611	rc = E_FAIL;
612	break;
613	}
614	}
615
616	if (FAILED(rc))
617	break;
618	}
619	else if (!strcmp(a->argv[1], "showvminfo"))
620	{
621	setCurrentSubcommand(HELP_SCOPE_SNAPSHOT_SHOWVMINFO);
622
623	/* exactly one parameter: snapshot name */
624	if (a->argc != 3)
625	{
626	errorSyntax("Expecting snapshot name only");
627	rc = E_FAIL;
628	break;
629	}
630
631	ComPtr<ISnapshot> pSnapshot;
632
633	CHECK_ERROR_BREAK(sessionMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
634	pSnapshot.asOutParam()));
635
636	/* get the machine of the given snapshot */
637	ComPtr<IMachine> pMachine2;
638	pSnapshot->COMGETTER(Machine)(pMachine2.asOutParam());
639	showVMInfo(a->virtualBox, pMachine2, NULL, VMINFO_NONE);
640	}
641	else if (!strcmp(a->argv[1], "list"))
642	{
643	setCurrentSubcommand(HELP_SCOPE_SNAPSHOT_LIST);
644	rc = handleSnapshotList(a, sessionMachine) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
645	}
646	else if (!strcmp(a->argv[1], "dump")) // undocumented parameter to debug snapshot info
647	DumpSnapshot(sessionMachine);
648	else
649	{
650	errorSyntax("Invalid parameter '%s'", a->argv[1]);
651	rc = E_FAIL;
652	}
653	} while (0);
654
655	a->session->UnlockMachine();
656
657	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
658	}
659

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: