VBoxManageDisk.cpp@ 35761

Last change on this file since 35761 was 35261, checked in by vboxsync, 14 years ago
Main+Frontends: fix windows burns
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.4 KB

Line
1	/* $Id: VBoxManageDisk.cpp 35261 2010-12-20 17:44:59Z vboxsync $ */
2	/** @file
3	* VBoxManage - The disk related commands.
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	#ifndef VBOX_ONLY_DOCS
19
20	/*******************************************************************************
21	* Header Files *
22	*******************************************************************************/
23	#include <VBox/com/com.h>
24	#include <VBox/com/array.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27	#include <VBox/com/VirtualBox.h>
28
29	#include <iprt/asm.h>
30	#include <iprt/file.h>
31	#include <iprt/path.h>
32	#include <iprt/param.h>
33	#include <iprt/stream.h>
34	#include <iprt/string.h>
35	#include <iprt/ctype.h>
36	#include <iprt/getopt.h>
37	#include <VBox/log.h>
38	#include <VBox/vd.h>
39
40	#include "VBoxManage.h"
41	using namespace com;
42
43
44	// funcs
45	///////////////////////////////////////////////////////////////////////////////
46
47
48	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
49	{
50	RTMsgError(pszFormat, va);
51	RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
52	}
53
54
55	static int parseDiskVariant(const char psz, MediumVariant_T pDiskVariant)
56	{
57	int rc = VINF_SUCCESS;
58	unsigned DiskVariant = (unsigned)(*pDiskVariant);
59	while (psz && *psz && RT_SUCCESS(rc))
60	{
61	size_t len;
62	const char *pszComma = strchr(psz, ',');
63	if (pszComma)
64	len = pszComma - psz;
65	else
66	len = strlen(psz);
67	if (len > 0)
68	{
69	// Parsing is intentionally inconsistent: "standard" resets the
70	// variant, whereas the other flags are cumulative.
71	if (!RTStrNICmp(psz, "standard", len))
72	DiskVariant = MediumVariant_Standard;
73	else if ( !RTStrNICmp(psz, "fixed", len)
74	\|\| !RTStrNICmp(psz, "static", len))
75	DiskVariant \|= MediumVariant_Fixed;
76	else if (!RTStrNICmp(psz, "Diff", len))
77	DiskVariant \|= MediumVariant_Diff;
78	else if (!RTStrNICmp(psz, "split2g", len))
79	DiskVariant \|= MediumVariant_VmdkSplit2G;
80	else if ( !RTStrNICmp(psz, "stream", len)
81	\|\| !RTStrNICmp(psz, "streamoptimized", len))
82	DiskVariant \|= MediumVariant_VmdkStreamOptimized;
83	else if (!RTStrNICmp(psz, "esx", len))
84	DiskVariant \|= MediumVariant_VmdkESX;
85	else
86	rc = VERR_PARSE_ERROR;
87	}
88	if (pszComma)
89	psz += len + 1;
90	else
91	psz += len;
92	}
93
94	if (RT_SUCCESS(rc))
95	*pDiskVariant = (MediumVariant_T)DiskVariant;
96	return rc;
97	}
98
99	int parseDiskType(const char psz, MediumType_T pDiskType)
100	{
101	int rc = VINF_SUCCESS;
102	MediumType_T DiskType = MediumType_Normal;
103	if (!RTStrICmp(psz, "normal"))
104	DiskType = MediumType_Normal;
105	else if (!RTStrICmp(psz, "immutable"))
106	DiskType = MediumType_Immutable;
107	else if (!RTStrICmp(psz, "writethrough"))
108	DiskType = MediumType_Writethrough;
109	else if (!RTStrICmp(psz, "shareable"))
110	DiskType = MediumType_Shareable;
111	else if (!RTStrICmp(psz, "readonly"))
112	DiskType = MediumType_Readonly;
113	else if (!RTStrICmp(psz, "multiattach"))
114	DiskType = MediumType_MultiAttach;
115	else
116	rc = VERR_PARSE_ERROR;
117
118	if (RT_SUCCESS(rc))
119	*pDiskType = DiskType;
120	return rc;
121	}
122
123	/** @todo move this into getopt, as getting bool values is generic */
124	static int parseBool(const char psz, bool pb)
125	{
126	int rc = VINF_SUCCESS;
127	if ( !RTStrICmp(psz, "on")
128	\|\| !RTStrICmp(psz, "yes")
129	\|\| !RTStrICmp(psz, "true")
130	\|\| !RTStrICmp(psz, "1")
131	\|\| !RTStrICmp(psz, "enable")
132	\|\| !RTStrICmp(psz, "enabled"))
133	{
134	*pb = true;
135	}
136	else if ( !RTStrICmp(psz, "off")
137	\|\| !RTStrICmp(psz, "no")
138	\|\| !RTStrICmp(psz, "false")
139	\|\| !RTStrICmp(psz, "0")
140	\|\| !RTStrICmp(psz, "disable")
141	\|\| !RTStrICmp(psz, "disabled"))
142	{
143	*pb = false;
144	}
145	else
146	rc = VERR_PARSE_ERROR;
147
148	return rc;
149	}
150
151	HRESULT findMedium(HandlerArg a, const char pszFilenameOrUuid,
152	DeviceType_T enmDevType, bool fSilent,
153	ComPtr<IMedium> &pMedium)
154	{
155	HRESULT rc;
156	Guid id(pszFilenameOrUuid);
157	char szFilenameAbs[RTPATH_MAX] = "";
158
159	/* If it is no UUID, convert the filename to an absolute one. */
160	if (id.isEmpty())
161	{
162	int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
163	if (RT_FAILURE(irc))
164	{
165	if (!fSilent)
166	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
167	return E_FAIL;
168	}
169	pszFilenameOrUuid = szFilenameAbs;
170	}
171
172	if (!fSilent)
173	CHECK_ERROR(a->virtualBox, FindMedium(Bstr(pszFilenameOrUuid).raw(),
174	enmDevType, pMedium.asOutParam()));
175	else
176	rc = a->virtualBox->FindMedium(Bstr(pszFilenameOrUuid).raw(),
177	enmDevType, pMedium.asOutParam());
178	return rc;
179	}
180
181	HRESULT findOrOpenMedium(HandlerArg a, const char pszFilenameOrUuid,
182	DeviceType_T enmDevType, ComPtr<IMedium> &pMedium,
183	bool *pfWasUnknown)
184	{
185	HRESULT rc;
186	bool fWasUnknown = false;
187	Guid id(pszFilenameOrUuid);
188	char szFilenameAbs[RTPATH_MAX] = "";
189
190	/* If it is no UUID, convert the filename to an absolute one. */
191	if (id.isEmpty())
192	{
193	int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
194	if (RT_FAILURE(irc))
195	{
196	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
197	return E_FAIL;
198	}
199	pszFilenameOrUuid = szFilenameAbs;
200	}
201
202	rc = a->virtualBox->FindMedium(Bstr(pszFilenameOrUuid).raw(), enmDevType,
203	pMedium.asOutParam());
204	/* If the medium is unknown try to open it. */
205	if (!pMedium)
206	{
207	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
208	enmDevType, AccessMode_ReadWrite,
209	pMedium.asOutParam()));
210	if (SUCCEEDED(rc))
211	fWasUnknown = true;
212	}
213	if (RT_VALID_PTR(pfWasUnknown))
214	*pfWasUnknown = fWasUnknown;
215	return rc;
216	}
217
218	static HRESULT createHardDisk(HandlerArg a, const char pszFormat,
219	const char *pszFilename, ComPtr<IMedium> &pMedium)
220	{
221	HRESULT rc;
222	char szFilenameAbs[RTPATH_MAX] = "";
223
224	/** @todo laziness shortcut. should really check the MediumFormatCapabilities */
225	if (RTStrICmp(pszFormat, "iSCSI"))
226	{
227	int irc = RTPathAbs(pszFilename, szFilenameAbs, sizeof(szFilenameAbs));
228	if (RT_FAILURE(irc))
229	{
230	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilename);
231	return E_FAIL;
232	}
233	pszFilename = szFilenameAbs;
234	}
235
236	CHECK_ERROR(a->virtualBox, CreateHardDisk(Bstr(pszFormat).raw(),
237	Bstr(pszFilename).raw(),
238	pMedium.asOutParam()));
239	return rc;
240	}
241
242	static const RTGETOPTDEF g_aCreateHardDiskOptions[] =
243	{
244	{ "--filename", 'f', RTGETOPT_REQ_STRING },
245	{ "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated
246	{ "--size", 's', RTGETOPT_REQ_UINT64 },
247	{ "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated
248	{ "--sizebyte", 'S', RTGETOPT_REQ_UINT64 },
249	{ "--format", 'o', RTGETOPT_REQ_STRING },
250	{ "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated
251	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
252	{ "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated
253	{ "--variant", 'm', RTGETOPT_REQ_STRING },
254	{ "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated
255	};
256
257	int handleCreateHardDisk(HandlerArg *a)
258	{
259	HRESULT rc;
260	int vrc;
261	const char *filename = NULL;
262	uint64_t size = 0;
263	const char *format = "VDI";
264	MediumVariant_T DiskVariant = MediumVariant_Standard;
265
266	int c;
267	RTGETOPTUNION ValueUnion;
268	RTGETOPTSTATE GetState;
269	// start at 0 because main() has hacked both the argc and argv given to us
270	RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateHardDiskOptions, RT_ELEMENTS(g_aCreateHardDiskOptions),
271	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
272	while ((c = RTGetOpt(&GetState, &ValueUnion)))
273	{
274	switch (c)
275	{
276	case 'f': // --filename
277	filename = ValueUnion.psz;
278	break;
279
280	case 's': // --size
281	size = ValueUnion.u64 * _1M;
282	break;
283
284	case 'S': // --sizebyte
285	size = ValueUnion.u64;
286	break;
287
288	case 'o': // --format
289	format = ValueUnion.psz;
290	break;
291
292	case 'F': // --static ("fixed"/"flat")
293	{
294	unsigned uDiskVariant = (unsigned)DiskVariant;
295	uDiskVariant \|= MediumVariant_Fixed;
296	DiskVariant = (MediumVariant_T)uDiskVariant;
297	break;
298	}
299
300	case 'm': // --variant
301	vrc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
302	if (RT_FAILURE(vrc))
303	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
304	break;
305
306	case VINF_GETOPT_NOT_OPTION:
307	return errorSyntax(USAGE_CREATEHD, "Invalid parameter '%s'", ValueUnion.psz);
308
309	default:
310	if (c > 0)
311	{
312	if (RT_C_IS_PRINT(c))
313	return errorSyntax(USAGE_CREATEHD, "Invalid option -%c", c);
314	else
315	return errorSyntax(USAGE_CREATEHD, "Invalid option case %i", c);
316	}
317	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
318	return errorSyntax(USAGE_CREATEHD, "unknown option: %s\n", ValueUnion.psz);
319	else if (ValueUnion.pDef)
320	return errorSyntax(USAGE_CREATEHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
321	else
322	return errorSyntax(USAGE_CREATEHD, "error: %Rrs", c);
323	}
324	}
325
326	/* check the outcome */
327	if ( !filename
328	\|\| !*filename
329	\|\| size == 0)
330	return errorSyntax(USAGE_CREATEHD, "Parameters --filename and --size are required");
331
332	/* check for filename extension */
333	/** @todo use IMediumFormat to cover all extensions generically */
334	Utf8Str strName(filename);
335	if (!RTPathHaveExt(strName.c_str()))
336	{
337	Utf8Str strFormat(format);
338	if (strFormat.compare("vmdk", iprt::MiniString::CaseInsensitive) == 0)
339	strName.append(".vmdk");
340	else if (strFormat.compare("vhd", iprt::MiniString::CaseInsensitive) == 0)
341	strName.append(".vhd");
342	else
343	strName.append(".vdi");
344	filename = strName.c_str();
345	}
346
347	ComPtr<IMedium> hardDisk;
348	rc = createHardDisk(a, format, filename, hardDisk);
349	if (SUCCEEDED(rc) && hardDisk)
350	{
351	ComPtr<IProgress> progress;
352	CHECK_ERROR(hardDisk, CreateBaseStorage(size, DiskVariant, progress.asOutParam()));
353	if (SUCCEEDED(rc) && progress)
354	{
355	rc = showProgress(progress);
356	if (FAILED(rc))
357	{
358	com::ProgressErrorInfo info(progress);
359	if (info.isBasicAvailable())
360	RTMsgError("Failed to create hard disk. Error message: %lS", info.getText().raw());
361	else
362	RTMsgError("Failed to create hard disk. No error message available!");
363	}
364	else
365	{
366	Bstr uuid;
367	CHECK_ERROR(hardDisk, COMGETTER(Id)(uuid.asOutParam()));
368	RTPrintf("Disk image created. UUID: %s\n", Utf8Str(uuid).c_str());
369	}
370	}
371	CHECK_ERROR(hardDisk, Close());
372	}
373	return SUCCEEDED(rc) ? 0 : 1;
374	}
375
376	static const RTGETOPTDEF g_aModifyHardDiskOptions[] =
377	{
378	{ "--type", 't', RTGETOPT_REQ_STRING },
379	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
380	{ "settype", 't', RTGETOPT_REQ_STRING }, // deprecated
381	{ "--autoreset", 'z', RTGETOPT_REQ_STRING },
382	{ "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
383	{ "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
384	{ "--compact", 'c', RTGETOPT_REQ_NOTHING },
385	{ "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
386	{ "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
387	{ "--resize", 'r', RTGETOPT_REQ_UINT64 },
388	{ "--resizebyte", 'R', RTGETOPT_REQ_UINT64 }
389	};
390
391	int handleModifyHardDisk(HandlerArg *a)
392	{
393	HRESULT rc;
394	int vrc;
395	ComPtr<IMedium> hardDisk;
396	MediumType_T DiskType;
397	bool AutoReset = false;
398	bool fModifyDiskType = false, fModifyAutoReset = false, fModifyCompact = false;
399	bool fModifyResize = false;
400	uint64_t cbResize = 0;
401	const char *FilenameOrUuid = NULL;
402	bool unknown = false;
403
404	int c;
405	RTGETOPTUNION ValueUnion;
406	RTGETOPTSTATE GetState;
407	// start at 0 because main() has hacked both the argc and argv given to us
408	RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyHardDiskOptions, RT_ELEMENTS(g_aModifyHardDiskOptions),
409	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
410	while ((c = RTGetOpt(&GetState, &ValueUnion)))
411	{
412	switch (c)
413	{
414	case 't': // --type
415	vrc = parseDiskType(ValueUnion.psz, &DiskType);
416	if (RT_FAILURE(vrc))
417	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
418	fModifyDiskType = true;
419	break;
420
421	case 'z': // --autoreset
422	vrc = parseBool(ValueUnion.psz, &AutoReset);
423	if (RT_FAILURE(vrc))
424	return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
425	fModifyAutoReset = true;
426	break;
427
428	case 'c': // --compact
429	fModifyCompact = true;
430	break;
431
432	case 'r': // --resize
433	cbResize = ValueUnion.u64 * _1M;
434	fModifyResize = true;
435	break;
436
437	case 'R': // --resizebyte
438	cbResize = ValueUnion.u64;
439	fModifyResize = true;
440	break;
441
442	case VINF_GETOPT_NOT_OPTION:
443	if (!FilenameOrUuid)
444	FilenameOrUuid = ValueUnion.psz;
445	else
446	return errorSyntax(USAGE_CREATEHD, "Invalid parameter '%s'", ValueUnion.psz);
447	break;
448
449	default:
450	if (c > 0)
451	{
452	if (RT_C_IS_PRINT(c))
453	return errorSyntax(USAGE_MODIFYHD, "Invalid option -%c", c);
454	else
455	return errorSyntax(USAGE_MODIFYHD, "Invalid option case %i", c);
456	}
457	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
458	return errorSyntax(USAGE_MODIFYHD, "unknown option: %s\n", ValueUnion.psz);
459	else if (ValueUnion.pDef)
460	return errorSyntax(USAGE_MODIFYHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
461	else
462	return errorSyntax(USAGE_MODIFYHD, "error: %Rrs", c);
463	}
464	}
465
466	if (!FilenameOrUuid)
467	return errorSyntax(USAGE_MODIFYHD, "Disk name or UUID required");
468
469	if (!fModifyDiskType && !fModifyAutoReset && !fModifyCompact && !fModifyResize)
470	return errorSyntax(USAGE_MODIFYHD, "No operation specified");
471
472	/* Depending on the operation the medium must be in the registry or
473	* may be opened on demand. */
474	if (fModifyDiskType \|\| fModifyAutoReset)
475	rc = findMedium(a, FilenameOrUuid, DeviceType_HardDisk, false /* fSilent */, hardDisk);
476	else
477	rc = findOrOpenMedium(a, FilenameOrUuid, DeviceType_HardDisk,
478	hardDisk, &unknown);
479	if (FAILED(rc))
480	return 1;
481	if (hardDisk.isNull())
482	{
483	RTMsgError("Invalid hard disk reference, avoiding crash");
484	return 1;
485	}
486
487	if (fModifyDiskType)
488	{
489	MediumType_T hddType;
490	CHECK_ERROR(hardDisk, COMGETTER(Type)(&hddType));
491
492	if (hddType != DiskType)
493	CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
494	}
495
496	if (fModifyAutoReset)
497	{
498	CHECK_ERROR(hardDisk, COMSETTER(AutoReset)(AutoReset));
499	}
500
501	if (fModifyCompact)
502	{
503	ComPtr<IProgress> progress;
504	CHECK_ERROR(hardDisk, Compact(progress.asOutParam()));
505	if (SUCCEEDED(rc))
506	rc = showProgress(progress);
507	if (FAILED(rc))
508	{
509	if (rc == E_NOTIMPL)
510	RTMsgError("Compact hard disk operation is not implemented!");
511	else if (rc == VBOX_E_NOT_SUPPORTED)
512	RTMsgError("Compact hard disk operation for this format is not implemented yet!");
513	else
514	com::GluePrintRCMessage(rc);
515	}
516	}
517
518	if (fModifyResize)
519	{
520	ComPtr<IProgress> progress;
521	CHECK_ERROR(hardDisk, Resize(cbResize, progress.asOutParam()));
522	if (SUCCEEDED(rc))
523	rc = showProgress(progress);
524	if (FAILED(rc))
525	{
526	if (rc == E_NOTIMPL)
527	RTMsgError("Resize hard disk operation is not implemented!");
528	else if (rc == VBOX_E_NOT_SUPPORTED)
529	RTMsgError("Resize hard disk operation for this format is not implemented yet!");
530	else
531	com::GluePrintRCMessage(rc);
532	}
533	}
534
535	if (unknown)
536	hardDisk->Close();
537
538	return SUCCEEDED(rc) ? 0 : 1;
539	}
540
541	static const RTGETOPTDEF g_aCloneHardDiskOptions[] =
542	{
543	{ "--format", 'o', RTGETOPT_REQ_STRING },
544	{ "-format", 'o', RTGETOPT_REQ_STRING },
545	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
546	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
547	{ "--existing", 'E', RTGETOPT_REQ_NOTHING },
548	{ "--variant", 'm', RTGETOPT_REQ_STRING },
549	{ "-variant", 'm', RTGETOPT_REQ_STRING },
550	};
551
552	int handleCloneHardDisk(HandlerArg *a)
553	{
554	HRESULT rc;
555	int vrc;
556	const char *pszSrc = NULL;
557	const char *pszDst = NULL;
558	Bstr format;
559	MediumVariant_T DiskVariant = MediumVariant_Standard;
560	bool fExisting = false;
561
562	int c;
563	RTGETOPTUNION ValueUnion;
564	RTGETOPTSTATE GetState;
565	// start at 0 because main() has hacked both the argc and argv given to us
566	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneHardDiskOptions, RT_ELEMENTS(g_aCloneHardDiskOptions),
567	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
568	while ((c = RTGetOpt(&GetState, &ValueUnion)))
569	{
570	switch (c)
571	{
572	case 'o': // --format
573	format = ValueUnion.psz;
574	break;
575
576	case 'F': // --static
577	{
578	unsigned uDiskVariant = (unsigned)DiskVariant;
579	uDiskVariant \|= MediumVariant_Fixed;
580	DiskVariant = (MediumVariant_T)uDiskVariant;
581	break;
582	}
583
584	case 'E': // --existing
585	fExisting = true;
586	break;
587
588	case 'm': // --variant
589	vrc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
590	if (RT_FAILURE(vrc))
591	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
592	break;
593
594	case VINF_GETOPT_NOT_OPTION:
595	if (!pszSrc)
596	pszSrc = ValueUnion.psz;
597	else if (!pszDst)
598	pszDst = ValueUnion.psz;
599	else
600	return errorSyntax(USAGE_CLONEHD, "Invalid parameter '%s'", ValueUnion.psz);
601	break;
602
603	default:
604	if (c > 0)
605	{
606	if (RT_C_IS_GRAPH(c))
607	return errorSyntax(USAGE_CLONEHD, "unhandled option: -%c", c);
608	else
609	return errorSyntax(USAGE_CLONEHD, "unhandled option: %i", c);
610	}
611	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
612	return errorSyntax(USAGE_CLONEHD, "unknown option: %s", ValueUnion.psz);
613	else if (ValueUnion.pDef)
614	return errorSyntax(USAGE_CLONEHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
615	else
616	return errorSyntax(USAGE_CLONEHD, "error: %Rrs", c);
617	}
618	}
619
620	if (!pszSrc)
621	return errorSyntax(USAGE_CLONEHD, "Mandatory UUID or input file parameter missing");
622	if (!pszDst)
623	return errorSyntax(USAGE_CLONEHD, "Mandatory output file parameter missing");
624	if (fExisting && (!format.isEmpty() \|\| DiskVariant != MediumType_Normal))
625	return errorSyntax(USAGE_CLONEHD, "Specified options which cannot be used with --existing");
626
627	ComPtr<IMedium> srcDisk;
628	ComPtr<IMedium> dstDisk;
629	bool fSrcUnknown = false;
630	bool fDstUnknown = false;
631
632	rc = findOrOpenMedium(a, pszSrc, DeviceType_HardDisk, srcDisk, &fSrcUnknown);
633	if (FAILED(rc))
634	return 1;
635
636	do
637	{
638	/* open/create destination hard disk */
639	if (fExisting)
640	{
641	rc = findOrOpenMedium(a, pszDst, DeviceType_HardDisk, dstDisk, &fDstUnknown);
642	if (FAILED(rc))
643	break;
644
645	/* Perform accessibility check now. */
646	MediumState_T state;
647	CHECK_ERROR_BREAK(dstDisk, RefreshState(&state));
648	CHECK_ERROR_BREAK(dstDisk, COMGETTER(Format)(format.asOutParam()));
649	}
650	else
651	{
652	/* use the format of the source hard disk if unspecified */
653	if (format.isEmpty())
654	CHECK_ERROR_BREAK(srcDisk, COMGETTER(Format)(format.asOutParam()));
655	rc = createHardDisk(a, Utf8Str(format).c_str(), pszDst, dstDisk);
656	if (FAILED(rc))
657	break;
658	}
659
660	ComPtr<IProgress> progress;
661	CHECK_ERROR_BREAK(srcDisk, CloneTo(dstDisk, DiskVariant, NULL, progress.asOutParam()));
662
663	rc = showProgress(progress);
664	if (FAILED(rc))
665	{
666	com::ProgressErrorInfo info(progress);
667	if (info.isBasicAvailable())
668	RTMsgError("Failed to clone hard disk. Error message: %lS", info.getText().raw());
669	else
670	RTMsgError("Failed to clone hard disk. No error message available!");
671	break;
672	}
673
674	Bstr uuid;
675	CHECK_ERROR_BREAK(dstDisk, COMGETTER(Id)(uuid.asOutParam()));
676
677	RTPrintf("Clone hard disk created in format '%ls'. UUID: %s\n",
678	format.raw(), Utf8Str(uuid).c_str());
679	}
680	while (0);
681
682	if (fDstUnknown && !dstDisk.isNull())
683	{
684	/* forget the created clone */
685	dstDisk->Close();
686	}
687	if (fSrcUnknown)
688	{
689	/* close the unknown hard disk to forget it again */
690	srcDisk->Close();
691	}
692
693	return SUCCEEDED(rc) ? 0 : 1;
694	}
695
696	static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] =
697	{
698	{ "--format", 'o', RTGETOPT_REQ_STRING },
699	{ "-format", 'o', RTGETOPT_REQ_STRING },
700	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
701	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
702	{ "--variant", 'm', RTGETOPT_REQ_STRING },
703	{ "-variant", 'm', RTGETOPT_REQ_STRING },
704	};
705
706	RTEXITCODE handleConvertFromRaw(int argc, char *argv[])
707	{
708	int rc = VINF_SUCCESS;
709	bool fReadFromStdIn = false;
710	const char *format = "VDI";
711	const char *srcfilename = NULL;
712	const char *dstfilename = NULL;
713	const char *filesize = NULL;
714	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
715	void *pvBuf = NULL;
716
717	int c;
718	RTGETOPTUNION ValueUnion;
719	RTGETOPTSTATE GetState;
720	// start at 0 because main() has hacked both the argc and argv given to us
721	RTGetOptInit(&GetState, argc, argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
722	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
723	while ((c = RTGetOpt(&GetState, &ValueUnion)))
724	{
725	switch (c)
726	{
727	case 'o': // --format
728	format = ValueUnion.psz;
729	break;
730
731	case 'm': // --variant
732	MediumVariant_T DiskVariant;
733	rc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
734	if (RT_FAILURE(rc))
735	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
736	/// @todo cleaner solution than assuming 1:1 mapping?
737	uImageFlags = (unsigned)DiskVariant;
738	break;
739
740	case VINF_GETOPT_NOT_OPTION:
741	if (!srcfilename)
742	{
743	srcfilename = ValueUnion.psz;
744	// If you change the OS list here don't forget to update VBoxManageHelp.cpp.
745	#ifndef RT_OS_WINDOWS
746	fReadFromStdIn = !strcmp(srcfilename, "stdin");
747	#endif
748	}
749	else if (!dstfilename)
750	dstfilename = ValueUnion.psz;
751	else if (fReadFromStdIn && !filesize)
752	filesize = ValueUnion.psz;
753	else
754	return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz);
755	break;
756
757	default:
758	return errorGetOpt(USAGE_CONVERTFROMRAW, c, &ValueUnion);
759	}
760	}
761
762	if (!srcfilename \|\| !dstfilename \|\| (fReadFromStdIn && !filesize))
763	return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters");
764	RTStrmPrintf(g_pStdErr, "Converting from raw image file=\"%s\" to file=\"%s\"...\n",
765	srcfilename, dstfilename);
766
767	PVBOXHDD pDisk = NULL;
768
769	PVDINTERFACE pVDIfs = NULL;
770	VDINTERFACE vdInterfaceError;
771	VDINTERFACEERROR vdInterfaceErrorCallbacks;
772	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
773	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
774	vdInterfaceErrorCallbacks.pfnError = handleVDError;
775	vdInterfaceErrorCallbacks.pfnMessage = NULL;
776
777	rc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
778	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
779	AssertRC(rc);
780
781	/* open raw image file. */
782	RTFILE File;
783	if (fReadFromStdIn)
784	File = 0;
785	else
786	rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
787	if (RT_FAILURE(rc))
788	{
789	RTMsgError("Cannot open file \"%s\": %Rrc", srcfilename, rc);
790	goto out;
791	}
792
793	uint64_t cbFile;
794	/* get image size. */
795	if (fReadFromStdIn)
796	cbFile = RTStrToUInt64(filesize);
797	else
798	rc = RTFileGetSize(File, &cbFile);
799	if (RT_FAILURE(rc))
800	{
801	RTMsgError("Cannot get image size for file \"%s\": %Rrc", srcfilename, rc);
802	goto out;
803	}
804
805	RTStrmPrintf(g_pStdErr, "Creating %s image with size %RU64 bytes (%RU64MB)...\n",
806	(uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M);
807	char pszComment[256];
808	RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
809	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
810	if (RT_FAILURE(rc))
811	{
812	RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
813	goto out;
814	}
815
816	Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) -
817	(unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0);
818	VDGEOMETRY PCHS, LCHS;
819	PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383);
820	PCHS.cHeads = 16;
821	PCHS.cSectors = 63;
822	LCHS.cCylinders = 0;
823	LCHS.cHeads = 0;
824	LCHS.cSectors = 0;
825	rc = VDCreateBase(pDisk, format, dstfilename, cbFile,
826	uImageFlags, pszComment, &PCHS, &LCHS, NULL,
827	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
828	if (RT_FAILURE(rc))
829	{
830	RTMsgError("Cannot create the disk image \"%s\": %Rrc", dstfilename, rc);
831	goto out;
832	}
833
834	size_t cbBuffer;
835	cbBuffer = _1M;
836	pvBuf = RTMemAlloc(cbBuffer);
837	if (!pvBuf)
838	{
839	rc = VERR_NO_MEMORY;
840	RTMsgError("Out of memory allocating buffers for image \"%s\": %Rrc", dstfilename, rc);
841	goto out;
842	}
843
844	uint64_t offFile;
845	offFile = 0;
846	while (offFile < cbFile)
847	{
848	size_t cbRead;
849	size_t cbToRead;
850	cbRead = 0;
851	cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
852	cbBuffer : (size_t)(cbFile - offFile);
853	rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
854	if (RT_FAILURE(rc) \|\| !cbRead)
855	break;
856	rc = VDWrite(pDisk, offFile, pvBuf, cbRead);
857	if (RT_FAILURE(rc))
858	{
859	RTMsgError("Failed to write to disk image \"%s\": %Rrc", dstfilename, rc);
860	goto out;
861	}
862	offFile += cbRead;
863	}
864
865	out:
866	if (pvBuf)
867	RTMemFree(pvBuf);
868	if (pDisk)
869	VDClose(pDisk, RT_FAILURE(rc));
870	if (File != NIL_RTFILE)
871	RTFileClose(File);
872
873	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
874	}
875
876	static const RTGETOPTDEF g_aShowHardDiskInfoOptions[] =
877	{
878	{ "--dummy", 256, RTGETOPT_REQ_NOTHING }, // placeholder for C++
879	};
880
881	int handleShowHardDiskInfo(HandlerArg *a)
882	{
883	HRESULT rc;
884	const char *FilenameOrUuid = NULL;
885
886	int c;
887	RTGETOPTUNION ValueUnion;
888	RTGETOPTSTATE GetState;
889	// start at 0 because main() has hacked both the argc and argv given to us
890	RTGetOptInit(&GetState, a->argc, a->argv, g_aShowHardDiskInfoOptions, RT_ELEMENTS(g_aShowHardDiskInfoOptions),
891	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
892	while ((c = RTGetOpt(&GetState, &ValueUnion)))
893	{
894	switch (c)
895	{
896	case VINF_GETOPT_NOT_OPTION:
897	if (!FilenameOrUuid)
898	FilenameOrUuid = ValueUnion.psz;
899	else
900	return errorSyntax(USAGE_SHOWHDINFO, "Invalid parameter '%s'", ValueUnion.psz);
901	break;
902
903	default:
904	if (c > 0)
905	{
906	if (RT_C_IS_PRINT(c))
907	return errorSyntax(USAGE_SHOWHDINFO, "Invalid option -%c", c);
908	else
909	return errorSyntax(USAGE_SHOWHDINFO, "Invalid option case %i", c);
910	}
911	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
912	return errorSyntax(USAGE_SHOWHDINFO, "unknown option: %s\n", ValueUnion.psz);
913	else if (ValueUnion.pDef)
914	return errorSyntax(USAGE_SHOWHDINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
915	else
916	return errorSyntax(USAGE_SHOWHDINFO, "error: %Rrs", c);
917	}
918	}
919
920	/* check for required options */
921	if (!FilenameOrUuid)
922	return errorSyntax(USAGE_SHOWHDINFO, "Disk name or UUID required");
923
924	ComPtr<IMedium> hardDisk;
925	bool unknown = false;
926
927	rc = findOrOpenMedium(a, FilenameOrUuid, DeviceType_HardDisk, hardDisk, &unknown);
928	if (FAILED(rc))
929	return 1;
930
931	do
932	{
933	Bstr uuid;
934	hardDisk->COMGETTER(Id)(uuid.asOutParam());
935	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
936
937	/* check for accessibility */
938	/// @todo NEWMEDIA check accessibility of all parents
939	/// @todo NEWMEDIA print the full state value
940	MediumState_T state;
941	CHECK_ERROR_BREAK(hardDisk, RefreshState(&state));
942	RTPrintf("Accessible: %s\n", state != MediumState_Inaccessible ? "yes" : "no");
943
944	if (state == MediumState_Inaccessible)
945	{
946	Bstr err;
947	CHECK_ERROR_BREAK(hardDisk, COMGETTER(LastAccessError)(err.asOutParam()));
948	RTPrintf("Access Error: %lS\n", err.raw());
949	}
950
951	Bstr description;
952	hardDisk->COMGETTER(Description)(description.asOutParam());
953	if (!description.isEmpty())
954	{
955	RTPrintf("Description: %lS\n", description.raw());
956	}
957
958	LONG64 logicalSize;
959	hardDisk->COMGETTER(LogicalSize)(&logicalSize);
960	RTPrintf("Logical size: %lld MBytes\n", logicalSize);
961	LONG64 actualSize;
962	hardDisk->COMGETTER(Size)(&actualSize);
963	RTPrintf("Current size on disk: %lld MBytes\n", actualSize >> 20);
964
965	ComPtr <IMedium> parent;
966	hardDisk->COMGETTER(Parent)(parent.asOutParam());
967
968	MediumType_T type;
969	hardDisk->COMGETTER(Type)(&type);
970	const char *typeStr = "unknown";
971	switch (type)
972	{
973	case MediumType_Normal:
974	if (!parent.isNull())
975	typeStr = "normal (differencing)";
976	else
977	typeStr = "normal (base)";
978	break;
979	case MediumType_Immutable:
980	typeStr = "immutable";
981	break;
982	case MediumType_Writethrough:
983	typeStr = "writethrough";
984	break;
985	case MediumType_Shareable:
986	typeStr = "shareable";
987	break;
988	case MediumType_Readonly:
989	typeStr = "readonly";
990	break;
991	case MediumType_MultiAttach:
992	typeStr = "multiattach";
993	break;
994	}
995	RTPrintf("Type: %s\n", typeStr);
996
997	Bstr format;
998	hardDisk->COMGETTER(Format)(format.asOutParam());
999	RTPrintf("Storage format: %lS\n", format.raw());
1000	ULONG variant;
1001	hardDisk->COMGETTER(Variant)(&variant);
1002	const char *variantStr = "unknown";
1003	switch (variant & ~(MediumVariant_Fixed \| MediumVariant_Diff))
1004	{
1005	case MediumVariant_VmdkSplit2G:
1006	variantStr = "split2G";
1007	break;
1008	case MediumVariant_VmdkStreamOptimized:
1009	variantStr = "streamOptimized";
1010	break;
1011	case MediumVariant_VmdkESX:
1012	variantStr = "ESX";
1013	break;
1014	case MediumVariant_Standard:
1015	variantStr = "default";
1016	break;
1017	}
1018	const char *variantTypeStr = "dynamic";
1019	if (variant & MediumVariant_Fixed)
1020	variantTypeStr = "fixed";
1021	else if (variant & MediumVariant_Diff)
1022	variantTypeStr = "differencing";
1023	RTPrintf("Format variant: %s %s\n", variantTypeStr, variantStr);
1024
1025	/// @todo also dump config parameters (iSCSI)
1026
1027	if (!unknown)
1028	{
1029	com::SafeArray<BSTR> machineIds;
1030	hardDisk->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
1031	for (size_t j = 0; j < machineIds.size(); ++ j)
1032	{
1033	ComPtr<IMachine> machine;
1034	CHECK_ERROR(a->virtualBox, FindMachine(machineIds[j], machine.asOutParam()));
1035	ASSERT(machine);
1036	Bstr name;
1037	machine->COMGETTER(Name)(name.asOutParam());
1038	machine->COMGETTER(Id)(uuid.asOutParam());
1039	RTPrintf("%s%lS (UUID: %lS)\n",
1040	j == 0 ? "In use by VMs: " : " ",
1041	name.raw(), machineIds[j]);
1042	}
1043	/// @todo NEWMEDIA check usage in snapshots too
1044	/// @todo NEWMEDIA also list children
1045	}
1046
1047	Bstr loc;
1048	hardDisk->COMGETTER(Location)(loc.asOutParam());
1049	RTPrintf("Location: %lS\n", loc.raw());
1050
1051	/* print out information specific for differencing hard disks */
1052	if (!parent.isNull())
1053	{
1054	BOOL autoReset = FALSE;
1055	hardDisk->COMGETTER(AutoReset)(&autoReset);
1056	RTPrintf("Auto-Reset: %s\n", autoReset ? "on" : "off");
1057	}
1058	}
1059	while (0);
1060
1061	if (unknown)
1062	{
1063	/* close the unknown hard disk to forget it again */
1064	hardDisk->Close();
1065	}
1066
1067	return SUCCEEDED(rc) ? 0 : 1;
1068	}
1069
1070	static const RTGETOPTDEF g_aCloseMediumOptions[] =
1071	{
1072	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1073	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1074	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1075	{ "--delete", 'r', RTGETOPT_REQ_NOTHING },
1076	};
1077
1078	int handleCloseMedium(HandlerArg *a)
1079	{
1080	HRESULT rc = S_OK;
1081	enum {
1082	CMD_NONE,
1083	CMD_DISK,
1084	CMD_DVD,
1085	CMD_FLOPPY
1086	} cmd = CMD_NONE;
1087	const char *FilenameOrUuid = NULL;
1088	bool fDelete = false;
1089
1090	int c;
1091	RTGETOPTUNION ValueUnion;
1092	RTGETOPTSTATE GetState;
1093	// start at 0 because main() has hacked both the argc and argv given to us
1094	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions),
1095	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1096	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1097	{
1098	switch (c)
1099	{
1100	case 'd': // disk
1101	if (cmd != CMD_NONE)
1102	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1103	cmd = CMD_DISK;
1104	break;
1105
1106	case 'D': // DVD
1107	if (cmd != CMD_NONE)
1108	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1109	cmd = CMD_DVD;
1110	break;
1111
1112	case 'f': // floppy
1113	if (cmd != CMD_NONE)
1114	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1115	cmd = CMD_FLOPPY;
1116	break;
1117
1118	case 'r': // --delete
1119	fDelete = true;
1120	break;
1121
1122	case VINF_GETOPT_NOT_OPTION:
1123	if (!FilenameOrUuid)
1124	FilenameOrUuid = ValueUnion.psz;
1125	else
1126	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1127	break;
1128
1129	default:
1130	if (c > 0)
1131	{
1132	if (RT_C_IS_PRINT(c))
1133	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c);
1134	else
1135	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c);
1136	}
1137	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1138	return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1139	else if (ValueUnion.pDef)
1140	return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1141	else
1142	return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c);
1143	}
1144	}
1145
1146	/* check for required options */
1147	if (cmd == CMD_NONE)
1148	return errorSyntax(USAGE_CLOSEMEDIUM, "Command variant disk/dvd/floppy required");
1149	if (!FilenameOrUuid)
1150	return errorSyntax(USAGE_CLOSEMEDIUM, "Disk name or UUID required");
1151
1152	ComPtr<IMedium> medium;
1153
1154	if (cmd == CMD_DISK)
1155	rc = findMedium(a, FilenameOrUuid, DeviceType_HardDisk, false /* fSilent */, medium);
1156	else if (cmd == CMD_DVD)
1157	rc = findMedium(a, FilenameOrUuid, DeviceType_DVD, false /* fSilent */, medium);
1158	else if (cmd == CMD_FLOPPY)
1159	rc = findMedium(a, FilenameOrUuid, DeviceType_Floppy, false /* fSilent */, medium);
1160
1161	if (SUCCEEDED(rc) && medium)
1162	{
1163	if (fDelete)
1164	{
1165	ComPtr<IProgress> progress;
1166	CHECK_ERROR(medium, DeleteStorage(progress.asOutParam()));
1167	if (SUCCEEDED(rc))
1168	{
1169	rc = showProgress(progress);
1170	if (FAILED(rc))
1171	{
1172	com::ProgressErrorInfo info(progress);
1173	if (info.isBasicAvailable())
1174	RTMsgError("Failed to delete medium. Error message: %lS", info.getText().raw());
1175	else
1176	RTMsgError("Failed to delete medium. No error message available!");
1177	}
1178	}
1179	else
1180	RTMsgError("Failed to delete medium. Error code %Rrc", rc);
1181	}
1182	CHECK_ERROR(medium, Close());
1183	}
1184
1185	return SUCCEEDED(rc) ? 0 : 1;
1186	}
1187	#endif /* !VBOX_ONLY_DOCS */

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp@ 35761

Download in other formats: